commit 02e140ac9140f6bf638fac97730d848a52dcb7ea
Author: Gerardo Marx <gmarx_cc@itmorelia.edu.mx>
Date:   Mon Nov 29 12:45:23 2021 -0600

    first commit

diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..933d8a2
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="lib" path="/Library/Java/JavaVirtualMachines/jdk1.8.0_311.jdk/Contents/Home/lib/tools.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/.project b/.project
new file mode 100644
index 0000000..34914aa
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>IJ</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/.settings/org.eclipse.jdt.core.prefs b/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..af07d5f
--- /dev/null
+++ b/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.8
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=1.8
diff --git a/IJ_Props.txt b/IJ_Props.txt
new file mode 100644
index 0000000..a58cd47
--- /dev/null
+++ b/IJ_Props.txt
@@ -0,0 +1,466 @@
+ # IJ_Props.txt - This is the ImageJ properties file. ImageJ uses
+# the information in this file to install plug-ins in menus.
+# ImageJ looks for this file in ij.jar. It can be edited by
+# opening ij.jar with a ZIP utility.
+
+# Note that commands must be unique.
+
+# Version 1.53
+
+# Commands installed in the right-click popup menu
+# May be overridden in StartupMacros
+popup01=Show Info...
+popup02=Properties...
+popup03=Rename...
+popup04=Measure
+popup05=Histogram
+popup06=Duplicate Image...
+popup07=Original Scale
+popup08=-
+popup09=Record...
+popup10=Find Commands...
+popup11=Capture Screen
+
+# Plugins installed in the File/New submenu
+new01="Image...[n]",ij.plugin.Commands("new")
+new02="Hyperstack...",ij.plugin.HyperStackMaker
+new03="Text Window[N]",ij.plugin.NewPlugin("text")
+new04="Internal Clipboard",ij.plugin.Clipboard("show")
+new05="System Clipboard[V]",ij.plugin.Clipboard("showsys")
+
+# Plugins installed in the File/Import submenu
+import01="Image Sequence...",ij.plugin.FolderOpener
+import02="Raw...",ij.plugin.Raw
+import03="LUT... ",ij.plugin.LutLoader
+import04="Text Image... ",ij.plugin.TextReader
+import05="Text File... ",ij.plugin.TextFileReader
+import06="Results... ",ij.plugin.SimpleCommands("import")
+import07="Table... ",ij.plugin.SimpleCommands("table")
+import08="URL...",ij.plugin.URLOpener
+import09="Stack From List...",ij.plugin.ListVirtualStack
+import10="TIFF Virtual Stack...",ij.plugin.FileInfoVirtualStack
+import11="AVI...",ij.plugin.AVI_Reader
+import12="XY Coordinates... ",ij.plugin.XY_Reader
+#import08="TWAIN...",ij.plugin.twain.Twain
+#import09="Capture Video...",QT_Capture
+#import10="QuickTime Movie...",Movie_Opener
+#import11="Pict...",QuickTime_Opener
+
+# Plugins installed in the File/Save As submenu
+save01="Tiff...",ij.plugin.filter.Writer("tiff")
+save02="Gif...",ij.plugin.filter.Writer("gif")
+save03="Jpeg...",ij.plugin.filter.Writer("jpeg")
+save04="Text Image...",ij.plugin.filter.Writer("text")
+save05="ZIP...",ij.plugin.filter.Writer("zip")
+save06="Raw Data...",ij.plugin.filter.Writer("raw")
+save07="Image Sequence... ",ij.plugin.StackWriter
+save08="AVI... ",ij.plugin.filter.AVI_Writer
+save09="BMP...",ij.plugin.filter.Writer("bmp")
+save10="PNG...",ij.plugin.filter.Writer("png")
+save11="PGM...",ij.plugin.filter.Writer("pgm")
+save12="FITS...",ij.plugin.filter.Writer("fits")
+save13="LUT...",ij.plugin.filter.Writer("lut")
+save14="Selection...",ij.plugin.filter.RoiWriter
+save15="XY Coordinates...",ij.plugin.filter.XYWriter
+save16="Results...",ij.plugin.MeasurementsWriter
+save17="Text...",ij.plugin.TextWriter
+#save18="QuickTime Movie... ",QT_Movie_Writer
+
+# Plugins installed in the Edit/Selection submenu
+selection01="Select All[a]",ij.plugin.Selection("all")
+selection02="Select None[A]",ij.plugin.Selection("none")
+selection03="Restore Selection[E]",ij.plugin.Selection("restore")
+selection04="Fit Spline",ij.plugin.Selection("spline")
+selection05="Fit Circle",ij.plugin.Selection("circle")
+selection06="Fit Ellipse",ij.plugin.Selection("ellipse")
+selection07="Fit Rectangle",ij.plugin.Selection("rect")
+selection08="Interpolate",ij.plugin.Selection("interpolate")
+selection09="Convex Hull",ij.plugin.Selection("hull")
+selection10="Make Inverse",ij.plugin.Selection("inverse")
+selection11="Create Selection",ij.plugin.Selection("from")
+selection12="Create Mask",ij.plugin.Selection("mask")
+selection13=-
+selection14="Properties... [y]",ij.plugin.Selection("properties")
+selection15="Scale... ",ij.plugin.RoiScaler
+selection16="Rotate...",ij.plugin.Selection("rotate")
+selection17="Enlarge...",ij.plugin.RoiEnlarger
+selection18="Make Band...",ij.plugin.Selection("band")
+selection19="Specify...",ij.plugin.SpecifyROI
+selection20="Straighten...",ij.plugin.Straightener
+selection21="To Bounding Box",ij.plugin.Selection("tobox")
+selection22="Line to Area",ij.plugin.Selection("toarea")
+selection23="Area to Line",ij.plugin.Selection("toline")
+selection24="Image to Selection...",ij.plugin.OverlayCommands("image-roi")
+selection25="Add to Manager[t]",ij.plugin.Selection("add")
+
+# Plugins installed in the Edit/Options submenu
+options01="Appearance...",ij.plugin.AppearanceOptions
+options02="Arrow Tool...",ij.plugin.ArrowToolOptions
+options03="Colors...",ij.plugin.Colors
+options04="Compiler...",ij.plugin.Compiler("options")
+options05="Conversions...",ij.plugin.Options("conv")
+options06="DICOM...",ij.plugin.Options("dicom")
+options07="Fonts...",ij.plugin.SimpleCommands("fonts")
+options08="Input/Output...",ij.plugin.Options("io")
+options09="Line Width...",ij.plugin.Options("line")
+options10="Memory & Threads...",ij.plugin.Memory
+options11="Misc...",ij.plugin.Options("misc")
+options12="Plots...",ij.plugin.Profiler("set")
+options13="Point Tool...",ij.plugin.PointToolOptions
+options14="Proxy Settings...",ij.plugin.ProxySettings
+options15="Roi Defaults...",ij.gui.RoiDefaultsDialog
+options16="Rounded Rect Tool...",ij.plugin.RectToolOptions
+options17="Startup...",ij.plugin.Startup
+options18="Wand Tool...",ij.plugin.WandToolOptions
+options19=-
+options20="Fresh Start",ij.plugin.Options("fresh-start")
+options21="Reset... ",ij.plugin.Options("reset")
+
+# Plugins installed in the Image/Adjust submenu
+adjust01="Brightness/Contrast...[C]",ij.plugin.frame.ContrastAdjuster
+adjust02="Window/Level...",ij.plugin.frame.ContrastAdjuster("wl")
+adjust03="Color Balance...",ij.plugin.frame.ContrastAdjuster("balance")
+adjust04="Threshold...[T]",ij.plugin.frame.ThresholdAdjuster
+adjust05="Color Threshold...",ij.plugin.frame.ColorThresholder
+adjust06="Size...",ij.plugin.Resizer
+adjust07="Canvas Size...",ij.plugin.CanvasResizer
+adjust08="Line Width... ",ij.plugin.frame.LineWidthAdjuster
+adjust09="Coordinates...",ij.plugin.Coordinates
+
+
+# Plugins installed in the Image/Color submenu
+color01="Split Channels",ij.plugin.ChannelSplitter
+color02="Merge Channels...",ij.plugin.RGBStackMerge
+color03="Arrange Channels...",ij.plugin.ChannelArranger
+color04="Channels Tool...[Z]",ij.plugin.frame.Channels
+color05=-
+color06="Stack to RGB",ij.plugin.RGBStackConverter
+color07="Make Composite",ij.plugin.CompositeConverter
+color08="Show LUT",ij.plugin.filter.LutViewer
+color09="Display LUTs",ij.plugin.SimpleCommands("display")
+color10="Edit LUT...",ij.plugin.LUT_Editor
+color11="Color Picker...[K]",ij.plugin.frame.ColorPicker
+
+# Plugins installed in the Image/Stacks submenu
+stacks01="Add Slice",ij.plugin.StackEditor("add")
+stacks02="Delete Slice",ij.plugin.StackEditor("delete")
+stacks03="Next Slice [>]",ij.plugin.Animator("next")
+stacks04="Previous Slice [<]",ij.plugin.Animator("previous")
+stacks05="Set Slice...",ij.plugin.Animator("set")
+stacks06=-
+stacks07="Images to Stack",ij.plugin.ImagesToStack
+stacks08="Stack to Images",ij.plugin.StackEditor("toimages")
+stacks09="Make Montage...",ij.plugin.MontageMaker
+stacks10="Reslice [/]...",ij.plugin.Slicer
+stacks11="Orthogonal Views[H]",ij.plugin.Orthogonal_Views
+stacks12="Z Project...",ij.plugin.ZProjector
+stacks13="3D Project...",ij.plugin.Projector
+stacks14="Plot Z-axis Profile",ij.plugin.ZAxisProfiler
+stacks15="Measure Stack...",ij.plugin.SimpleCommands("measure")
+stacks16="Label...",ij.plugin.filter.StackLabeler
+stacks17="Statistics",ij.plugin.Stack_Statistics
+
+# Plugins installed in the Image/Stacks/Animation submenu
+animation_01="Start Animation [\\]",ij.plugin.Animator("start")
+animation_02="Stop Animation",ij.plugin.Animator("stop")
+animation_03="Animation Options...",ij.plugin.Animator("options")
+
+# Plugins installed in the Image/Stacks/Tools submenu
+tools_01="Combine...",ij.plugin.StackCombiner
+tools_02="Concatenate...",ij.plugin.Concatenator
+tools_03="Grouped Z Project...",ij.plugin.GroupedZProjector
+tools_04="Insert...",ij.plugin.StackInserter
+tools_05="Magic Montage Tools",ij.plugin.SimpleCommands("magic")
+tools_06="Make Substack...",ij.plugin.SubstackMaker
+tools_07="Montage to Stack...",ij.plugin.StackMaker
+tools_08="Plot XY Profile",ij.plugin.StackPlotter
+tools_09="Reduce...",ij.plugin.StackReducer
+tools_10="Remove Slice Labels",ij.plugin.SimpleCommands("remove")
+tools_11="Reverse",ij.plugin.StackReverser
+tools_12="Set Label...",ij.plugin.SimpleCommands("set")
+
+# Plugins installed in the Image/Hyperstacks submenu
+hyperstacks01="New Hyperstack...",ij.plugin.HyperStackMaker
+hyperstacks02="Stack to Hyperstack...",ij.plugin.HyperStackConverter("stacktohs")
+hyperstacks03="Hyperstack to Stack",ij.plugin.HyperStackConverter("hstostack")
+hyperstacks04="Reduce Dimensionality...",ij.plugin.HyperStackReducer
+
+# Plugins installed in the Image/Transform submenu
+transform01="Flip Horizontally",ij.plugin.filter.Transformer("fliph")
+transform02="Flip Vertically",ij.plugin.filter.Transformer("flipv")
+transform03="Flip Z",ij.plugin.StackReverser
+transform04="Rotate 90 Degrees Right",ij.plugin.filter.Transformer("right")
+transform05="Rotate 90 Degrees Left",ij.plugin.filter.Transformer("left")
+transform06="Rotate... ",ij.plugin.filter.Rotator
+transform07="Translate...",ij.plugin.filter.Translator
+transform08="Bin...",ij.plugin.Binner
+transform09=-
+transform10="Image to Results",ij.plugin.SimpleCommands("itor")
+transform11="Results to Image",ij.plugin.SimpleCommands("rtoi")
+
+# Plugins installed in the Image/Zoom submenu
+zoom01="In [+]",ij.plugin.Zoom("in")
+zoom02="Out [-]",ij.plugin.Zoom("out")
+zoom03="Original Scale[4]",ij.plugin.Zoom("orig")
+zoom04="View 100%[5]",ij.plugin.Zoom("100%")
+zoom05="To Selection",ij.plugin.Zoom("to")
+zoom06="Scale to Fit",ij.plugin.Zoom("scale")
+zoom07="Set... ",ij.plugin.Zoom("set")
+zoom08="Maximize",ij.plugin.Zoom("max")
+
+# Plugins installed in the Image/Overlay submenu
+overlay01="Add Selection...[b]",ij.plugin.OverlayCommands("add")
+overlay02="Add Image...",ij.plugin.OverlayCommands("image")
+overlay03="Hide Overlay",ij.plugin.OverlayCommands("hide")
+overlay04="Show Overlay",ij.plugin.OverlayCommands("show")
+overlay05="From ROI Manager",ij.plugin.OverlayCommands("from")
+overlay06="To ROI Manager",ij.plugin.OverlayCommands("to")
+overlay07="Remove Overlay",ij.plugin.OverlayCommands("remove")
+overlay08="List Elements",ij.plugin.OverlayCommands("list")
+overlay09="Flatten[F]",ij.plugin.OverlayCommands("flatten")
+overlay10="Labels...",ij.plugin.OverlayLabels
+overlay11="Measure Overlay",ij.plugin.OverlayCommands("measure")
+overlay12="Overlay Options...[Y]",ij.plugin.OverlayCommands("options")
+
+# Plugins installed in the Image/Lookup Tables submenu
+lookup01="Invert LUT",ij.plugin.LutLoader("invert")
+lookup02="Apply LUT",ij.plugin.filter.LutApplier
+lookup03=-
+lookup04="Fire",ij.plugin.LutLoader("fire")
+lookup05="Grays",ij.plugin.LutLoader("grays")
+lookup06="Ice",ij.plugin.LutLoader("ice")
+lookup07="Spectrum",ij.plugin.LutLoader("spectrum")
+lookup08="3-3-2 RGB",ij.plugin.LutLoader("3-3-2 RGB")
+lookup09="Red",ij.plugin.LutLoader("red")
+lookup10="Green",ij.plugin.LutLoader("green")
+lookup11="Blue",ij.plugin.LutLoader("blue")
+lookup12="Cyan",ij.plugin.LutLoader("cyan")
+lookup13="Magenta",ij.plugin.LutLoader("magenta")
+lookup14="Yellow",ij.plugin.LutLoader("yellow")
+lookup15="Red/Green",ij.plugin.LutLoader("redgreen")
+
+# Plug-ins installed in the Process/Noise submenu
+noise01="Add Noise",ij.plugin.filter.Filters("add")
+noise02="Add Specified Noise...",ij.plugin.filter.Filters("noise")
+noise03="Salt and Pepper",ij.plugin.filter.SaltAndPepper
+noise04=-
+noise05="Despeckle",ij.plugin.filter.RankFilters("despeckle")
+noise06="Remove Outliers...",ij.plugin.filter.RankFilters("outliers")
+noise07="Remove NaNs...",ij.plugin.filter.RankFilters("nan")
+
+# Plugins installed in the Process/Shadows submenu
+shadows01="North",ij.plugin.filter.Shadows("north")
+shadows02="Northeast",ij.plugin.filter.Shadows("northeast")
+shadows03="East",ij.plugin.filter.Shadows("east")
+shadows04="Southeast",ij.plugin.filter.Shadows("southeast")
+shadows05="South",ij.plugin.filter.Shadows("south")
+shadows06="Southwest",ij.plugin.filter.Shadows("southwest")
+shadows07="West",ij.plugin.filter.Shadows("west")
+shadows08="Northwest",ij.plugin.filter.Shadows("northwest")
+shadows09=-
+shadows10="Shadows Demo",ij.plugin.filter.Shadows("demo")
+
+# Plugins installed in the Process/Binary submenu
+binary01="Make Binary",ij.plugin.Thresholder
+binary02="Convert to Mask",ij.plugin.Thresholder("mask")
+binary03=-
+binary04="Erode",ij.plugin.filter.Binary("erode")
+binary05="Dilate",ij.plugin.filter.Binary("dilate")
+binary06="Open",ij.plugin.filter.Binary("open")
+# Can't use "Close" because it conflicts with File/Close
+binary07="Close-",ij.plugin.filter.Binary("close")
+binary08=-
+binary09="Outline",ij.plugin.filter.Binary("outline")
+binary10="Fill Holes",ij.plugin.filter.Binary("fill")
+binary11="Skeletonize",ij.plugin.filter.Binary("skel")
+binary12=-
+binary13="Distance Map",ij.plugin.filter.EDM("edm")
+binary14="Ultimate Points",ij.plugin.filter.EDM("points")
+binary15="Watershed",ij.plugin.filter.EDM("watershed")
+binary16="Voronoi",ij.plugin.filter.EDM("voronoi")
+binary17=-
+binary18="Options...",ij.plugin.filter.Binary("options")
+
+# Plugins installed in the Process/Math submenu
+math01="Add...",ij.plugin.filter.ImageMath("add")
+math02="Subtract...",ij.plugin.filter.ImageMath("sub")
+math03="Multiply...",ij.plugin.filter.ImageMath("mul")
+math04="Divide...",ij.plugin.filter.ImageMath("div")
+math05="AND...",ij.plugin.filter.ImageMath("and")
+math06="OR...",ij.plugin.filter.ImageMath("or")
+math07="XOR...",ij.plugin.filter.ImageMath("xor")
+math08="Min...",ij.plugin.filter.ImageMath("min")
+math09="Max...",ij.plugin.filter.ImageMath("max")
+math10="Gamma...",ij.plugin.filter.ImageMath("gamma")
+math11="Set...",ij.plugin.filter.ImageMath("set")
+math12="Log",ij.plugin.filter.ImageMath("log")
+math13="Exp",ij.plugin.filter.ImageMath("exp")
+math14="Square",ij.plugin.filter.ImageMath("sqr")
+math15="Square Root",ij.plugin.filter.ImageMath("sqrt")
+math16="Reciprocal",ij.plugin.filter.ImageMath("reciprocal")
+math17="NaN Background",ij.plugin.filter.ImageMath("nan")
+math18="Abs",ij.plugin.filter.ImageMath("abs")
+math19="Macro...",ij.plugin.filter.ImageMath("macro")
+
+# Plugins installed in the Process/FFT submenu
+fft01="FFT",ij.plugin.FFT("fft")
+fft02="Inverse FFT",ij.plugin.FFT("inverse")
+fft03="Redisplay Power Spectrum",ij.plugin.FFT("redisplay")
+fft04="FFT Options...",ij.plugin.FFT("options")
+fft05=-
+fft06="Bandpass Filter...",ij.plugin.filter.FFTFilter
+fft07="Custom Filter...",ij.plugin.filter.FFTCustomFilter
+fft08="FD Math...",ij.plugin.FFTMath
+fft09="Swap Quadrants",ij.plugin.FFT("swap")
+fft10="Make Circular Selection...",ij.plugin.CircularRoiMaker
+
+# Plugins installed in the Process/Filters submenu
+filters01="Convolve...",ij.plugin.filter.Convolver
+filters02="Gaussian Blur...",ij.plugin.filter.GaussianBlur
+filters03="Median...",ij.plugin.filter.RankFilters("median")
+filters04="Mean...",ij.plugin.filter.RankFilters("mean")
+filters05="Minimum...",ij.plugin.filter.RankFilters("min")
+filters06="Maximum...",ij.plugin.filter.RankFilters("max")
+filters07="Unsharp Mask...",ij.plugin.filter.UnsharpMask
+filters08="Variance...",ij.plugin.filter.RankFilters("variance")
+filters09="Top Hat...",ij.plugin.filter.RankFilters("tophat")
+filters10=-
+filters11="Gaussian Blur 3D...",ij.plugin.GaussianBlur3D
+filters12="Median 3D...",ij.plugin.Filters3D("median")
+filters13="Mean 3D...",ij.plugin.Filters3D("mean")
+filters14="Minimum 3D...",ij.plugin.Filters3D("min")
+filters15="Maximum 3D...",ij.plugin.Filters3D("max")
+filters16="Variance 3D...",ij.plugin.Filters3D("var")
+filters17=-
+filters18="Show Circular Masks...",ij.plugin.filter.RankFilters("masks")
+
+# Plugins installed in the File/Batch submenu
+batch01="Measure...",ij.plugin.BatchMeasure
+batch02="Convert...",ij.plugin.BatchConverter
+batch03="Macro... ",ij.plugin.BatchProcessor
+batch04="Virtual Stack...",ij.plugin.BatchProcessor("stack")
+
+# Plugins installed in the Analyze/Gels submenu
+gels01="Select First Lane[1]",ij.plugin.GelAnalyzer("first")
+gels02="Select Next Lane[2]",ij.plugin.GelAnalyzer("next")
+gels03="Plot Lanes[3]",ij.plugin.GelAnalyzer("plot")
+gels04="Re-plot Lanes",ij.plugin.GelAnalyzer("replot")
+gels05="Reset",ij.plugin.GelAnalyzer("reset")
+gels06="Label Peaks",ij.plugin.GelAnalyzer("label")
+gels07="Gel Analyzer Options...",ij.plugin.GelAnalyzer("options")
+
+# Plugins installed in the Analyze/Tools submenu
+tools01="Save XY Coordinates...",ij.plugin.XYCoordinates
+tools02="Fractal Box Count...",ij.plugin.filter.FractalBoxCounter
+tools03="Analyze Line Graph",ij.plugin.filter.LineGraphAnalyzer
+tools04="Curve Fitting...",ij.plugin.frame.Fitter
+tools05="ROI Manager...",ij.plugin.frame.RoiManager
+tools06="Scale Bar...",ij.plugin.ScaleBar
+tools07="Calibration Bar...",ij.plugin.CalibrationBar
+tools08="Synchronize Windows",ij.plugin.frame.SyncWindows
+tools09="Grid...",ij.plugin.Grid
+
+# Plugins installed in the Plugins menu
+plug-in01=>"Macros"
+plug-in02=>"Shortcuts"
+plug-in03=>"Utilities"
+plug-in04=>"New_"
+plug-in05="Compile and Run...",ij.plugin.Compiler
+plug-in06="Install... [M]",ij.plugin.PluginInstaller
+#plug-in07=-
+#plug-in08=>"User_Plugins"
+
+# Install user plugins located in ij.jar to Plugins>User Plugins submenu
+#user_plugins01="Red And Blue",RedAndBlue_
+#user_plugins02="Inverter",Inverter_
+
+
+# Plugins installed in the Plugins/Macros submenu
+# 'MACROS_MENU_COMMANDS' in MacroInstaller must be updated when items are added
+macros01="Install...",ij.plugin.MacroInstaller
+macros02="Run...",ij.plugin.Macro_Runner
+macros03="Edit...",ij.plugin.Compiler("edit")
+macros04="Startup Macros...",ij.plugin.Commands("startup")
+macros05="Interactive Interpreter...[j]",ij.plugin.SimpleCommands("interactive")
+macros06="Record...",ij.plugin.frame.Recorder
+macros07=-
+
+# Plugins installed in the Plugins/Shortcuts submenu
+shortcuts01="Add Shortcut... ",ij.plugin.Hotkeys("install")
+shortcuts02="Add Shortcut by Name... ",ij.plugin.Hotkeys("install2")
+shortcuts03="Remove Shortcut...",ij.plugin.Hotkeys("remove")
+shortcuts04="List Shortcuts",ij.plugin.CommandLister("shortcuts")
+shortcuts05="List Commands",ij.plugin.Hotkeys("list")
+shortcuts06=-
+
+# Plugins installed in the Plugins/Utilities submenu
+utilities01="Control Panel...[U]",ij.plugin.ControlPanel
+utilities02="Find Commands...[l]",ij.plugin.CommandFinder
+utilities03="Commands...[L]",ij.plugin.frame.Commands
+utilities04="Search...",ij.plugin.SimpleCommands("search")
+utilities05="Monitor Events...",ij.plugin.EventListener
+utilities06="Monitor Memory...",ij.plugin.frame.MemoryMonitor
+utilities07=-
+utilities08="Capture Screen[G]",ij.plugin.ScreenGrabber
+utilities09="Capture Delayed...",ij.plugin.ScreenGrabber("delay")
+utilities10="Capture Image",ij.plugin.ScreenGrabber("image")
+utilities11=-
+utilities12="ImageJ Properties",ij.plugin.JavaProperties
+utilities13="Threads",ij.plugin.ThreadLister
+utilities14="Benchmark",ij.plugin.Benchmark
+utilities15="Reset...",ij.plugin.SimpleCommands("reset")
+
+# Plugins installed in the Plugins/New submenu
+new_01="Macro",ij.plugin.NewPlugin("macro")
+new_02="Macro Tool",ij.plugin.NewPlugin("macro-tool")
+new_03="JavaScript",ij.plugin.NewPlugin("javascript")
+new_04=-
+new_05="Plugin",ij.plugin.NewPlugin("plugin")
+new_06="Plugin Filter",ij.plugin.NewPlugin("filter")
+new_07="Plugin Frame",ij.plugin.NewPlugin("frame")
+new_08="Plugin Tool",ij.plugin.NewPlugin("plugin-tool")
+new_09=-
+new_10="Text Window...",ij.plugin.NewPlugin("text+dialog")
+
+# Plugins installed in the Help/About submenu
+about01="About This Submenu...",ij.plugin.SimpleCommands("about")
+about02=-
+
+# URL of directory containing the sample images
+# location2 is uses with Java 6, which does not support https
+images.location=https://imagej.net/images/
+images.location2=http://imagej.net/images/
+
+# Images installed in the Open Samples submenu
+# RawReader expects a string with "name width height nImages bitsPerPixel offset [white]"
+open01="AuPbSn 40",ij.plugin.URLOpener("AuPbSn40.jpg")
+open02="Bat Cochlea Volume",ij.plugin.URLOpener("bat-cochlea-volume.zip")
+open03="Bat Cochlea Renderings",ij.plugin.URLOpener("bat-cochlea-renderings.zip")
+open04="Blobs[B]",ij.plugin.URLOpener("blobs.gif")
+open05="Boats",ij.plugin.URLOpener("boats.gif")
+open06="Cardio (RGB DICOM)",ij.plugin.URLOpener("cardio.dcm.zip")
+open07="Cell Colony",ij.plugin.URLOpener("Cell_Colony.jpg")
+open08="Clown",ij.plugin.URLOpener("clown.jpg")
+open09="Confocal Series",ij.plugin.URLOpener("confocal-series.zip")
+open10="CT (16-bit DICOM)",ij.plugin.URLOpener("ct.dcm.zip")
+open11="Dot Blot",ij.plugin.URLOpener("Dot_Blot.jpg")
+open12="Embryos",ij.plugin.URLOpener("embryos.jpg")
+open13="Fluorescent Cells",ij.plugin.URLOpener("FluorescentCells.zip")
+open14="Fly Brain",ij.plugin.URLOpener("flybrain.zip")
+open15="Gel",ij.plugin.URLOpener("gel.gif")
+open16="HeLa Cells (48-bit RGB)",ij.plugin.URLOpener("hela-cells.zip")
+open17="Image with Overlay",ij.plugin.URLOpener("ImageWithOverlay.zip")
+open18="Leaf",ij.plugin.URLOpener("leaf.jpg")
+open19="Line Graph",ij.plugin.URLOpener("LineGraph.jpg")
+open20="Mitosis (5D stack)",ij.plugin.URLOpener("Spindly-GFP.zip")
+open21="MRI Stack",ij.plugin.URLOpener("mri-stack.zip")
+open22="M51 Galaxy (16-bits)",ij.plugin.URLOpener("m51.zip")
+open23="Neuron (5 channels)",ij.plugin.URLOpener("Rat_Hippocampal_Neuron.zip")
+open24="Nile Bend",ij.plugin.URLOpener("NileBend.jpg")
+open25="Organ of Corti (4D stack)",ij.plugin.URLOpener("organ-of-corti.zip")
+open26="Particles",ij.plugin.URLOpener("particles.gif")
+open27="T1 Head (16-bits)",ij.plugin.URLOpener("t1-head.zip")
+open28="T1 Head Renderings",ij.plugin.URLOpener("t1-rendering.zip")
+open29="TEM Filter",ij.plugin.URLOpener("TEM_filter_sample.jpg")
+open30="Tree Rings",ij.plugin.URLOpener("Tree_Rings.jpg")
+
diff --git a/bin/ij/CommandListener.class b/bin/ij/CommandListener.class
new file mode 100644
index 0000000..bbea16c
Binary files /dev/null and b/bin/ij/CommandListener.class differ
diff --git a/bin/ij/CompositeImage.class b/bin/ij/CompositeImage.class
new file mode 100644
index 0000000..592b086
Binary files /dev/null and b/bin/ij/CompositeImage.class differ
diff --git a/bin/ij/Executer.class b/bin/ij/Executer.class
new file mode 100644
index 0000000..267b9e8
Binary files /dev/null and b/bin/ij/Executer.class differ
diff --git a/bin/ij/IJ$ExceptionHandler.class b/bin/ij/IJ$ExceptionHandler.class
new file mode 100644
index 0000000..be6c545
Binary files /dev/null and b/bin/ij/IJ$ExceptionHandler.class differ
diff --git a/bin/ij/IJ.class b/bin/ij/IJ.class
new file mode 100644
index 0000000..7856c34
Binary files /dev/null and b/bin/ij/IJ.class differ
diff --git a/bin/ij/IJEventListener.class b/bin/ij/IJEventListener.class
new file mode 100644
index 0000000..7fbcbdb
Binary files /dev/null and b/bin/ij/IJEventListener.class differ
diff --git a/bin/ij/ImageJ$ExceptionHandler.class b/bin/ij/ImageJ$ExceptionHandler.class
new file mode 100644
index 0000000..9c8e523
Binary files /dev/null and b/bin/ij/ImageJ$ExceptionHandler.class differ
diff --git a/bin/ij/ImageJ.class b/bin/ij/ImageJ.class
new file mode 100644
index 0000000..4c5a84e
Binary files /dev/null and b/bin/ij/ImageJ.class differ
diff --git a/bin/ij/ImageJApplet.class b/bin/ij/ImageJApplet.class
new file mode 100644
index 0000000..689d84d
Binary files /dev/null and b/bin/ij/ImageJApplet.class differ
diff --git a/bin/ij/ImageListener.class b/bin/ij/ImageListener.class
new file mode 100644
index 0000000..b52b154
Binary files /dev/null and b/bin/ij/ImageListener.class differ
diff --git a/bin/ij/ImagePlus$1.class b/bin/ij/ImagePlus$1.class
new file mode 100644
index 0000000..2188236
Binary files /dev/null and b/bin/ij/ImagePlus$1.class differ
diff --git a/bin/ij/ImagePlus.class b/bin/ij/ImagePlus.class
new file mode 100644
index 0000000..6b93ba1
Binary files /dev/null and b/bin/ij/ImagePlus.class differ
diff --git a/bin/ij/ImageStack.class b/bin/ij/ImageStack.class
new file mode 100644
index 0000000..31a492d
Binary files /dev/null and b/bin/ij/ImageStack.class differ
diff --git a/bin/ij/LookUpTable.class b/bin/ij/LookUpTable.class
new file mode 100644
index 0000000..c82d275
Binary files /dev/null and b/bin/ij/LookUpTable.class differ
diff --git a/bin/ij/Macro.class b/bin/ij/Macro.class
new file mode 100644
index 0000000..987fc9c
Binary files /dev/null and b/bin/ij/Macro.class differ
diff --git a/bin/ij/Menus.class b/bin/ij/Menus.class
new file mode 100644
index 0000000..0bf6871
Binary files /dev/null and b/bin/ij/Menus.class differ
diff --git a/bin/ij/OtherInstance$ImageJInstance.class b/bin/ij/OtherInstance$ImageJInstance.class
new file mode 100644
index 0000000..7c4dc40
Binary files /dev/null and b/bin/ij/OtherInstance$ImageJInstance.class differ
diff --git a/bin/ij/OtherInstance$Implementation.class b/bin/ij/OtherInstance$Implementation.class
new file mode 100644
index 0000000..477550a
Binary files /dev/null and b/bin/ij/OtherInstance$Implementation.class differ
diff --git a/bin/ij/OtherInstance.class b/bin/ij/OtherInstance.class
new file mode 100644
index 0000000..8936644
Binary files /dev/null and b/bin/ij/OtherInstance.class differ
diff --git a/bin/ij/Prefs.class b/bin/ij/Prefs.class
new file mode 100644
index 0000000..eef96f6
Binary files /dev/null and b/bin/ij/Prefs.class differ
diff --git a/bin/ij/RecentOpener.class b/bin/ij/RecentOpener.class
new file mode 100644
index 0000000..29ac499
Binary files /dev/null and b/bin/ij/RecentOpener.class differ
diff --git a/bin/ij/Undo.class b/bin/ij/Undo.class
new file mode 100644
index 0000000..976026c
Binary files /dev/null and b/bin/ij/Undo.class differ
diff --git a/bin/ij/VirtualStack.class b/bin/ij/VirtualStack.class
new file mode 100644
index 0000000..3db5cbf
Binary files /dev/null and b/bin/ij/VirtualStack.class differ
diff --git a/bin/ij/WindowManager.class b/bin/ij/WindowManager.class
new file mode 100644
index 0000000..0de8a34
Binary files /dev/null and b/bin/ij/WindowManager.class differ
diff --git a/bin/ij/gui/Arrow.class b/bin/ij/gui/Arrow.class
new file mode 100644
index 0000000..5de9d95
Binary files /dev/null and b/bin/ij/gui/Arrow.class differ
diff --git a/bin/ij/gui/ColorChooser.class b/bin/ij/gui/ColorChooser.class
new file mode 100644
index 0000000..ef77b98
Binary files /dev/null and b/bin/ij/gui/ColorChooser.class differ
diff --git a/bin/ij/gui/ColorPanel.class b/bin/ij/gui/ColorPanel.class
new file mode 100644
index 0000000..acc056a
Binary files /dev/null and b/bin/ij/gui/ColorPanel.class differ
diff --git a/bin/ij/gui/DialogListener.class b/bin/ij/gui/DialogListener.class
new file mode 100644
index 0000000..88d4184
Binary files /dev/null and b/bin/ij/gui/DialogListener.class differ
diff --git a/bin/ij/gui/EllipseRoi.class b/bin/ij/gui/EllipseRoi.class
new file mode 100644
index 0000000..5b33cd2
Binary files /dev/null and b/bin/ij/gui/EllipseRoi.class differ
diff --git a/bin/ij/gui/FreehandRoi.class b/bin/ij/gui/FreehandRoi.class
new file mode 100644
index 0000000..4eff2c0
Binary files /dev/null and b/bin/ij/gui/FreehandRoi.class differ
diff --git a/bin/ij/gui/GUI.class b/bin/ij/gui/GUI.class
new file mode 100644
index 0000000..06a5e3a
Binary files /dev/null and b/bin/ij/gui/GUI.class differ
diff --git a/bin/ij/gui/GenericDialog$1.class b/bin/ij/gui/GenericDialog$1.class
new file mode 100644
index 0000000..3247291
Binary files /dev/null and b/bin/ij/gui/GenericDialog$1.class differ
diff --git a/bin/ij/gui/GenericDialog$BrowseButtonListener.class b/bin/ij/gui/GenericDialog$BrowseButtonListener.class
new file mode 100644
index 0000000..1eb44eb
Binary files /dev/null and b/bin/ij/gui/GenericDialog$BrowseButtonListener.class differ
diff --git a/bin/ij/gui/GenericDialog$TextDropTarget.class b/bin/ij/gui/GenericDialog$TextDropTarget.class
new file mode 100644
index 0000000..5acd288
Binary files /dev/null and b/bin/ij/gui/GenericDialog$TextDropTarget.class differ
diff --git a/bin/ij/gui/GenericDialog.class b/bin/ij/gui/GenericDialog.class
new file mode 100644
index 0000000..e077101
Binary files /dev/null and b/bin/ij/gui/GenericDialog.class differ
diff --git a/bin/ij/gui/HTMLDialog$1.class b/bin/ij/gui/HTMLDialog$1.class
new file mode 100644
index 0000000..aeaa502
Binary files /dev/null and b/bin/ij/gui/HTMLDialog$1.class differ
diff --git a/bin/ij/gui/HTMLDialog$2.class b/bin/ij/gui/HTMLDialog$2.class
new file mode 100644
index 0000000..48f55da
Binary files /dev/null and b/bin/ij/gui/HTMLDialog$2.class differ
diff --git a/bin/ij/gui/HTMLDialog.class b/bin/ij/gui/HTMLDialog.class
new file mode 100644
index 0000000..522b7c7
Binary files /dev/null and b/bin/ij/gui/HTMLDialog.class differ
diff --git a/bin/ij/gui/HistogramPlot.class b/bin/ij/gui/HistogramPlot.class
new file mode 100644
index 0000000..9fabd0c
Binary files /dev/null and b/bin/ij/gui/HistogramPlot.class differ
diff --git a/bin/ij/gui/HistogramWindow.class b/bin/ij/gui/HistogramWindow.class
new file mode 100644
index 0000000..e75813f
Binary files /dev/null and b/bin/ij/gui/HistogramWindow.class differ
diff --git a/bin/ij/gui/ImageCanvas$1.class b/bin/ij/gui/ImageCanvas$1.class
new file mode 100644
index 0000000..8f7f08c
Binary files /dev/null and b/bin/ij/gui/ImageCanvas$1.class differ
diff --git a/bin/ij/gui/ImageCanvas.class b/bin/ij/gui/ImageCanvas.class
new file mode 100644
index 0000000..44151c3
Binary files /dev/null and b/bin/ij/gui/ImageCanvas.class differ
diff --git a/bin/ij/gui/ImageLayout.class b/bin/ij/gui/ImageLayout.class
new file mode 100644
index 0000000..21485be
Binary files /dev/null and b/bin/ij/gui/ImageLayout.class differ
diff --git a/bin/ij/gui/ImagePanel.class b/bin/ij/gui/ImagePanel.class
new file mode 100644
index 0000000..5516de2
Binary files /dev/null and b/bin/ij/gui/ImagePanel.class differ
diff --git a/bin/ij/gui/ImageRoi.class b/bin/ij/gui/ImageRoi.class
new file mode 100644
index 0000000..1395748
Binary files /dev/null and b/bin/ij/gui/ImageRoi.class differ
diff --git a/bin/ij/gui/ImageWindow.class b/bin/ij/gui/ImageWindow.class
new file mode 100644
index 0000000..cf14557
Binary files /dev/null and b/bin/ij/gui/ImageWindow.class differ
diff --git a/bin/ij/gui/Line$PointIterator.class b/bin/ij/gui/Line$PointIterator.class
new file mode 100644
index 0000000..576505c
Binary files /dev/null and b/bin/ij/gui/Line$PointIterator.class differ
diff --git a/bin/ij/gui/Line.class b/bin/ij/gui/Line.class
new file mode 100644
index 0000000..ef6f264
Binary files /dev/null and b/bin/ij/gui/Line.class differ
diff --git a/bin/ij/gui/MessageDialog.class b/bin/ij/gui/MessageDialog.class
new file mode 100644
index 0000000..f5bdc43
Binary files /dev/null and b/bin/ij/gui/MessageDialog.class differ
diff --git a/bin/ij/gui/MultiLineLabel.class b/bin/ij/gui/MultiLineLabel.class
new file mode 100644
index 0000000..f24920a
Binary files /dev/null and b/bin/ij/gui/MultiLineLabel.class differ
diff --git a/bin/ij/gui/NewImage.class b/bin/ij/gui/NewImage.class
new file mode 100644
index 0000000..ffa90d1
Binary files /dev/null and b/bin/ij/gui/NewImage.class differ
diff --git a/bin/ij/gui/NonBlockingGenericDialog$1.class b/bin/ij/gui/NonBlockingGenericDialog$1.class
new file mode 100644
index 0000000..2b7d6c1
Binary files /dev/null and b/bin/ij/gui/NonBlockingGenericDialog$1.class differ
diff --git a/bin/ij/gui/NonBlockingGenericDialog$2.class b/bin/ij/gui/NonBlockingGenericDialog$2.class
new file mode 100644
index 0000000..0706442
Binary files /dev/null and b/bin/ij/gui/NonBlockingGenericDialog$2.class differ
diff --git a/bin/ij/gui/NonBlockingGenericDialog.class b/bin/ij/gui/NonBlockingGenericDialog.class
new file mode 100644
index 0000000..97bea99
Binary files /dev/null and b/bin/ij/gui/NonBlockingGenericDialog.class differ
diff --git a/bin/ij/gui/OvalRoi.class b/bin/ij/gui/OvalRoi.class
new file mode 100644
index 0000000..aba14bb
Binary files /dev/null and b/bin/ij/gui/OvalRoi.class differ
diff --git a/bin/ij/gui/Overlay$1.class b/bin/ij/gui/Overlay$1.class
new file mode 100644
index 0000000..907d4a6
Binary files /dev/null and b/bin/ij/gui/Overlay$1.class differ
diff --git a/bin/ij/gui/Overlay.class b/bin/ij/gui/Overlay.class
new file mode 100644
index 0000000..833e75c
Binary files /dev/null and b/bin/ij/gui/Overlay.class differ
diff --git a/bin/ij/gui/Plot.class b/bin/ij/gui/Plot.class
new file mode 100644
index 0000000..58c834d
Binary files /dev/null and b/bin/ij/gui/Plot.class differ
diff --git a/bin/ij/gui/PlotCanvas.class b/bin/ij/gui/PlotCanvas.class
new file mode 100644
index 0000000..58b6a79
Binary files /dev/null and b/bin/ij/gui/PlotCanvas.class differ
diff --git a/bin/ij/gui/PlotContentsDialog.class b/bin/ij/gui/PlotContentsDialog.class
new file mode 100644
index 0000000..c1aed04
Binary files /dev/null and b/bin/ij/gui/PlotContentsDialog.class differ
diff --git a/bin/ij/gui/PlotDialog$1.class b/bin/ij/gui/PlotDialog$1.class
new file mode 100644
index 0000000..adfa206
Binary files /dev/null and b/bin/ij/gui/PlotDialog$1.class differ
diff --git a/bin/ij/gui/PlotDialog.class b/bin/ij/gui/PlotDialog.class
new file mode 100644
index 0000000..afc1c2a
Binary files /dev/null and b/bin/ij/gui/PlotDialog.class differ
diff --git a/bin/ij/gui/PlotMaker.class b/bin/ij/gui/PlotMaker.class
new file mode 100644
index 0000000..bd34bf9
Binary files /dev/null and b/bin/ij/gui/PlotMaker.class differ
diff --git a/bin/ij/gui/PlotObject.class b/bin/ij/gui/PlotObject.class
new file mode 100644
index 0000000..a9beee6
Binary files /dev/null and b/bin/ij/gui/PlotObject.class differ
diff --git a/bin/ij/gui/PlotProperties.class b/bin/ij/gui/PlotProperties.class
new file mode 100644
index 0000000..37eb6ce
Binary files /dev/null and b/bin/ij/gui/PlotProperties.class differ
diff --git a/bin/ij/gui/PlotVirtualStack.class b/bin/ij/gui/PlotVirtualStack.class
new file mode 100644
index 0000000..5fc1af8
Binary files /dev/null and b/bin/ij/gui/PlotVirtualStack.class differ
diff --git a/bin/ij/gui/PlotWindow$1.class b/bin/ij/gui/PlotWindow$1.class
new file mode 100644
index 0000000..0369222
Binary files /dev/null and b/bin/ij/gui/PlotWindow$1.class differ
diff --git a/bin/ij/gui/PlotWindow.class b/bin/ij/gui/PlotWindow.class
new file mode 100644
index 0000000..24abb4e
Binary files /dev/null and b/bin/ij/gui/PlotWindow.class differ
diff --git a/bin/ij/gui/PointRoi$1.class b/bin/ij/gui/PointRoi$1.class
new file mode 100644
index 0000000..0e3749b
Binary files /dev/null and b/bin/ij/gui/PointRoi$1.class differ
diff --git a/bin/ij/gui/PointRoi.class b/bin/ij/gui/PointRoi.class
new file mode 100644
index 0000000..2a8ae75
Binary files /dev/null and b/bin/ij/gui/PointRoi.class differ
diff --git a/bin/ij/gui/PolygonRoi.class b/bin/ij/gui/PolygonRoi.class
new file mode 100644
index 0000000..b99cf93
Binary files /dev/null and b/bin/ij/gui/PolygonRoi.class differ
diff --git a/bin/ij/gui/ProfilePlot.class b/bin/ij/gui/ProfilePlot.class
new file mode 100644
index 0000000..2d2c812
Binary files /dev/null and b/bin/ij/gui/ProfilePlot.class differ
diff --git a/bin/ij/gui/ProgressBar.class b/bin/ij/gui/ProgressBar.class
new file mode 100644
index 0000000..de3f2bf
Binary files /dev/null and b/bin/ij/gui/ProgressBar.class differ
diff --git a/bin/ij/gui/Roi$RoiPointsIteratorMask.class b/bin/ij/gui/Roi$RoiPointsIteratorMask.class
new file mode 100644
index 0000000..b6b9b52
Binary files /dev/null and b/bin/ij/gui/Roi$RoiPointsIteratorMask.class differ
diff --git a/bin/ij/gui/Roi.class b/bin/ij/gui/Roi.class
new file mode 100644
index 0000000..892625a
Binary files /dev/null and b/bin/ij/gui/Roi.class differ
diff --git a/bin/ij/gui/RoiBrush.class b/bin/ij/gui/RoiBrush.class
new file mode 100644
index 0000000..a347add
Binary files /dev/null and b/bin/ij/gui/RoiBrush.class differ
diff --git a/bin/ij/gui/RoiDefaultsDialog.class b/bin/ij/gui/RoiDefaultsDialog.class
new file mode 100644
index 0000000..115a522
Binary files /dev/null and b/bin/ij/gui/RoiDefaultsDialog.class differ
diff --git a/bin/ij/gui/RoiListener.class b/bin/ij/gui/RoiListener.class
new file mode 100644
index 0000000..335aab5
Binary files /dev/null and b/bin/ij/gui/RoiListener.class differ
diff --git a/bin/ij/gui/RoiProperties.class b/bin/ij/gui/RoiProperties.class
new file mode 100644
index 0000000..6ef1514
Binary files /dev/null and b/bin/ij/gui/RoiProperties.class differ
diff --git a/bin/ij/gui/RotatedRectRoi.class b/bin/ij/gui/RotatedRectRoi.class
new file mode 100644
index 0000000..c94868c
Binary files /dev/null and b/bin/ij/gui/RotatedRectRoi.class differ
diff --git a/bin/ij/gui/SaveChangesDialog.class b/bin/ij/gui/SaveChangesDialog.class
new file mode 100644
index 0000000..6178d30
Binary files /dev/null and b/bin/ij/gui/SaveChangesDialog.class differ
diff --git a/bin/ij/gui/ScrollbarWithLabel$Icon.class b/bin/ij/gui/ScrollbarWithLabel$Icon.class
new file mode 100644
index 0000000..a69b7a1
Binary files /dev/null and b/bin/ij/gui/ScrollbarWithLabel$Icon.class differ
diff --git a/bin/ij/gui/ScrollbarWithLabel.class b/bin/ij/gui/ScrollbarWithLabel.class
new file mode 100644
index 0000000..980c1b8
Binary files /dev/null and b/bin/ij/gui/ScrollbarWithLabel.class differ
diff --git a/bin/ij/gui/ShapeRoi.class b/bin/ij/gui/ShapeRoi.class
new file mode 100644
index 0000000..4f584b7
Binary files /dev/null and b/bin/ij/gui/ShapeRoi.class differ
diff --git a/bin/ij/gui/StackWindow$1.class b/bin/ij/gui/StackWindow$1.class
new file mode 100644
index 0000000..85ada38
Binary files /dev/null and b/bin/ij/gui/StackWindow$1.class differ
diff --git a/bin/ij/gui/StackWindow$2.class b/bin/ij/gui/StackWindow$2.class
new file mode 100644
index 0000000..3bd8870
Binary files /dev/null and b/bin/ij/gui/StackWindow$2.class differ
diff --git a/bin/ij/gui/StackWindow.class b/bin/ij/gui/StackWindow.class
new file mode 100644
index 0000000..fdfcabe
Binary files /dev/null and b/bin/ij/gui/StackWindow.class differ
diff --git a/bin/ij/gui/TextRoi.class b/bin/ij/gui/TextRoi.class
new file mode 100644
index 0000000..d779cbb
Binary files /dev/null and b/bin/ij/gui/TextRoi.class differ
diff --git a/bin/ij/gui/Toolbar$1.class b/bin/ij/gui/Toolbar$1.class
new file mode 100644
index 0000000..3db2893
Binary files /dev/null and b/bin/ij/gui/Toolbar$1.class differ
diff --git a/bin/ij/gui/Toolbar.class b/bin/ij/gui/Toolbar.class
new file mode 100644
index 0000000..8f7d9cc
Binary files /dev/null and b/bin/ij/gui/Toolbar.class differ
diff --git a/bin/ij/gui/TrimmedButton.class b/bin/ij/gui/TrimmedButton.class
new file mode 100644
index 0000000..beb580f
Binary files /dev/null and b/bin/ij/gui/TrimmedButton.class differ
diff --git a/bin/ij/gui/WaitForUserDialog.class b/bin/ij/gui/WaitForUserDialog.class
new file mode 100644
index 0000000..040ada7
Binary files /dev/null and b/bin/ij/gui/WaitForUserDialog.class differ
diff --git a/bin/ij/gui/Wand.class b/bin/ij/gui/Wand.class
new file mode 100644
index 0000000..2d20f47
Binary files /dev/null and b/bin/ij/gui/Wand.class differ
diff --git a/bin/ij/gui/YesNoCancelDialog.class b/bin/ij/gui/YesNoCancelDialog.class
new file mode 100644
index 0000000..669b233
Binary files /dev/null and b/bin/ij/gui/YesNoCancelDialog.class differ
diff --git a/bin/ij/io/BitBuffer.class b/bin/ij/io/BitBuffer.class
new file mode 100644
index 0000000..95785bb
Binary files /dev/null and b/bin/ij/io/BitBuffer.class differ
diff --git a/bin/ij/io/ByteVector.class b/bin/ij/io/ByteVector.class
new file mode 100644
index 0000000..023def5
Binary files /dev/null and b/bin/ij/io/ByteVector.class differ
diff --git a/bin/ij/io/DirectoryChooser$1.class b/bin/ij/io/DirectoryChooser$1.class
new file mode 100644
index 0000000..39d652d
Binary files /dev/null and b/bin/ij/io/DirectoryChooser$1.class differ
diff --git a/bin/ij/io/DirectoryChooser.class b/bin/ij/io/DirectoryChooser.class
new file mode 100644
index 0000000..86bcb2b
Binary files /dev/null and b/bin/ij/io/DirectoryChooser.class differ
diff --git a/bin/ij/io/DragAndDropHandler.class b/bin/ij/io/DragAndDropHandler.class
new file mode 100644
index 0000000..d87ce8b
Binary files /dev/null and b/bin/ij/io/DragAndDropHandler.class differ
diff --git a/bin/ij/io/FileInfo.class b/bin/ij/io/FileInfo.class
new file mode 100644
index 0000000..4b40373
Binary files /dev/null and b/bin/ij/io/FileInfo.class differ
diff --git a/bin/ij/io/FileOpener.class b/bin/ij/io/FileOpener.class
new file mode 100644
index 0000000..037d854
Binary files /dev/null and b/bin/ij/io/FileOpener.class differ
diff --git a/bin/ij/io/FileSaver.class b/bin/ij/io/FileSaver.class
new file mode 100644
index 0000000..8093b35
Binary files /dev/null and b/bin/ij/io/FileSaver.class differ
diff --git a/bin/ij/io/ImageReader.class b/bin/ij/io/ImageReader.class
new file mode 100644
index 0000000..bf3c930
Binary files /dev/null and b/bin/ij/io/ImageReader.class differ
diff --git a/bin/ij/io/ImageWriter.class b/bin/ij/io/ImageWriter.class
new file mode 100644
index 0000000..4778a7e
Binary files /dev/null and b/bin/ij/io/ImageWriter.class differ
diff --git a/bin/ij/io/ImportDialog.class b/bin/ij/io/ImportDialog.class
new file mode 100644
index 0000000..a02dbf0
Binary files /dev/null and b/bin/ij/io/ImportDialog.class differ
diff --git a/bin/ij/io/LogStream.class b/bin/ij/io/LogStream.class
new file mode 100644
index 0000000..5004228
Binary files /dev/null and b/bin/ij/io/LogStream.class differ
diff --git a/bin/ij/io/OpenDialog$1.class b/bin/ij/io/OpenDialog$1.class
new file mode 100644
index 0000000..51f6901
Binary files /dev/null and b/bin/ij/io/OpenDialog$1.class differ
diff --git a/bin/ij/io/OpenDialog.class b/bin/ij/io/OpenDialog.class
new file mode 100644
index 0000000..e427501
Binary files /dev/null and b/bin/ij/io/OpenDialog.class differ
diff --git a/bin/ij/io/Opener$1.class b/bin/ij/io/Opener$1.class
new file mode 100644
index 0000000..0e975ca
Binary files /dev/null and b/bin/ij/io/Opener$1.class differ
diff --git a/bin/ij/io/Opener.class b/bin/ij/io/Opener.class
new file mode 100644
index 0000000..c4492eb
Binary files /dev/null and b/bin/ij/io/Opener.class differ
diff --git a/bin/ij/io/PluginClassLoader.class b/bin/ij/io/PluginClassLoader.class
new file mode 100644
index 0000000..01f372a
Binary files /dev/null and b/bin/ij/io/PluginClassLoader.class differ
diff --git a/bin/ij/io/RandomAccessStream.class b/bin/ij/io/RandomAccessStream.class
new file mode 100644
index 0000000..8668ff9
Binary files /dev/null and b/bin/ij/io/RandomAccessStream.class differ
diff --git a/bin/ij/io/RoiDecoder.class b/bin/ij/io/RoiDecoder.class
new file mode 100644
index 0000000..0898e90
Binary files /dev/null and b/bin/ij/io/RoiDecoder.class differ
diff --git a/bin/ij/io/RoiEncoder.class b/bin/ij/io/RoiEncoder.class
new file mode 100644
index 0000000..535883c
Binary files /dev/null and b/bin/ij/io/RoiEncoder.class differ
diff --git a/bin/ij/io/SaveDialog$1.class b/bin/ij/io/SaveDialog$1.class
new file mode 100644
index 0000000..5cc7e18
Binary files /dev/null and b/bin/ij/io/SaveDialog$1.class differ
diff --git a/bin/ij/io/SaveDialog.class b/bin/ij/io/SaveDialog.class
new file mode 100644
index 0000000..3d51d86
Binary files /dev/null and b/bin/ij/io/SaveDialog.class differ
diff --git a/bin/ij/io/TextEncoder.class b/bin/ij/io/TextEncoder.class
new file mode 100644
index 0000000..caaffae
Binary files /dev/null and b/bin/ij/io/TextEncoder.class differ
diff --git a/bin/ij/io/TiffDecoder.class b/bin/ij/io/TiffDecoder.class
new file mode 100644
index 0000000..2162547
Binary files /dev/null and b/bin/ij/io/TiffDecoder.class differ
diff --git a/bin/ij/io/TiffEncoder.class b/bin/ij/io/TiffEncoder.class
new file mode 100644
index 0000000..8552e57
Binary files /dev/null and b/bin/ij/io/TiffEncoder.class differ
diff --git a/bin/ij/macro/Debugger.class b/bin/ij/macro/Debugger.class
new file mode 100644
index 0000000..3a50082
Binary files /dev/null and b/bin/ij/macro/Debugger.class differ
diff --git a/bin/ij/macro/ExtensionDescriptor.class b/bin/ij/macro/ExtensionDescriptor.class
new file mode 100644
index 0000000..2e1a37e
Binary files /dev/null and b/bin/ij/macro/ExtensionDescriptor.class differ
diff --git a/bin/ij/macro/FunctionFinder.class b/bin/ij/macro/FunctionFinder.class
new file mode 100644
index 0000000..c269bc7
Binary files /dev/null and b/bin/ij/macro/FunctionFinder.class differ
diff --git a/bin/ij/macro/Functions.class b/bin/ij/macro/Functions.class
new file mode 100644
index 0000000..3f6fdce
Binary files /dev/null and b/bin/ij/macro/Functions.class differ
diff --git a/bin/ij/macro/Interpreter.class b/bin/ij/macro/Interpreter.class
new file mode 100644
index 0000000..0984591
Binary files /dev/null and b/bin/ij/macro/Interpreter.class differ
diff --git a/bin/ij/macro/MacroConstants.class b/bin/ij/macro/MacroConstants.class
new file mode 100644
index 0000000..ad4a52c
Binary files /dev/null and b/bin/ij/macro/MacroConstants.class differ
diff --git a/bin/ij/macro/MacroException.class b/bin/ij/macro/MacroException.class
new file mode 100644
index 0000000..f9ce812
Binary files /dev/null and b/bin/ij/macro/MacroException.class differ
diff --git a/bin/ij/macro/MacroExtension.class b/bin/ij/macro/MacroExtension.class
new file mode 100644
index 0000000..e8ce470
Binary files /dev/null and b/bin/ij/macro/MacroExtension.class differ
diff --git a/bin/ij/macro/MacroRunner.class b/bin/ij/macro/MacroRunner.class
new file mode 100644
index 0000000..0a043e1
Binary files /dev/null and b/bin/ij/macro/MacroRunner.class differ
diff --git a/bin/ij/macro/Program.class b/bin/ij/macro/Program.class
new file mode 100644
index 0000000..6ab6073
Binary files /dev/null and b/bin/ij/macro/Program.class differ
diff --git a/bin/ij/macro/ReturnException.class b/bin/ij/macro/ReturnException.class
new file mode 100644
index 0000000..4c1217b
Binary files /dev/null and b/bin/ij/macro/ReturnException.class differ
diff --git a/bin/ij/macro/StartupRunner.class b/bin/ij/macro/StartupRunner.class
new file mode 100644
index 0000000..50d7704
Binary files /dev/null and b/bin/ij/macro/StartupRunner.class differ
diff --git a/bin/ij/macro/Symbol.class b/bin/ij/macro/Symbol.class
new file mode 100644
index 0000000..c80cb48
Binary files /dev/null and b/bin/ij/macro/Symbol.class differ
diff --git a/bin/ij/macro/Tokenizer.class b/bin/ij/macro/Tokenizer.class
new file mode 100644
index 0000000..f913478
Binary files /dev/null and b/bin/ij/macro/Tokenizer.class differ
diff --git a/bin/ij/macro/Variable.class b/bin/ij/macro/Variable.class
new file mode 100644
index 0000000..8167ade
Binary files /dev/null and b/bin/ij/macro/Variable.class differ
diff --git a/bin/ij/measure/Calibration.class b/bin/ij/measure/Calibration.class
new file mode 100644
index 0000000..4cf638b
Binary files /dev/null and b/bin/ij/measure/Calibration.class differ
diff --git a/bin/ij/measure/CurveFitter.class b/bin/ij/measure/CurveFitter.class
new file mode 100644
index 0000000..0c734ba
Binary files /dev/null and b/bin/ij/measure/CurveFitter.class differ
diff --git a/bin/ij/measure/Measurements.class b/bin/ij/measure/Measurements.class
new file mode 100644
index 0000000..c5b3456
Binary files /dev/null and b/bin/ij/measure/Measurements.class differ
diff --git a/bin/ij/measure/Minimizer$1.class b/bin/ij/measure/Minimizer$1.class
new file mode 100644
index 0000000..060832f
Binary files /dev/null and b/bin/ij/measure/Minimizer$1.class differ
diff --git a/bin/ij/measure/Minimizer.class b/bin/ij/measure/Minimizer.class
new file mode 100644
index 0000000..902b204
Binary files /dev/null and b/bin/ij/measure/Minimizer.class differ
diff --git a/bin/ij/measure/ResultsTable$ComparableEntry.class b/bin/ij/measure/ResultsTable$ComparableEntry.class
new file mode 100644
index 0000000..4fb4bbd
Binary files /dev/null and b/bin/ij/measure/ResultsTable$ComparableEntry.class differ
diff --git a/bin/ij/measure/ResultsTable.class b/bin/ij/measure/ResultsTable.class
new file mode 100644
index 0000000..5e28f3a
Binary files /dev/null and b/bin/ij/measure/ResultsTable.class differ
diff --git a/bin/ij/measure/ResultsTableMacros$1.class b/bin/ij/measure/ResultsTableMacros$1.class
new file mode 100644
index 0000000..846a731
Binary files /dev/null and b/bin/ij/measure/ResultsTableMacros$1.class differ
diff --git a/bin/ij/measure/ResultsTableMacros.class b/bin/ij/measure/ResultsTableMacros.class
new file mode 100644
index 0000000..bc61858
Binary files /dev/null and b/bin/ij/measure/ResultsTableMacros.class differ
diff --git a/bin/ij/measure/SplineFitter.class b/bin/ij/measure/SplineFitter.class
new file mode 100644
index 0000000..bb11c5e
Binary files /dev/null and b/bin/ij/measure/SplineFitter.class differ
diff --git a/bin/ij/measure/UserFunction.class b/bin/ij/measure/UserFunction.class
new file mode 100644
index 0000000..cbf2823
Binary files /dev/null and b/bin/ij/measure/UserFunction.class differ
diff --git a/bin/ij/plugin/AVI_Reader$raInputStream.class b/bin/ij/plugin/AVI_Reader$raInputStream.class
new file mode 100644
index 0000000..5248710
Binary files /dev/null and b/bin/ij/plugin/AVI_Reader$raInputStream.class differ
diff --git a/bin/ij/plugin/AVI_Reader.class b/bin/ij/plugin/AVI_Reader.class
new file mode 100644
index 0000000..d6c9d48
Binary files /dev/null and b/bin/ij/plugin/AVI_Reader.class differ
diff --git a/bin/ij/plugin/AboutBox.class b/bin/ij/plugin/AboutBox.class
new file mode 100644
index 0000000..549bfcb
Binary files /dev/null and b/bin/ij/plugin/AboutBox.class differ
diff --git a/bin/ij/plugin/AnimatedGifEncoder2.class b/bin/ij/plugin/AnimatedGifEncoder2.class
new file mode 100644
index 0000000..88f74a6
Binary files /dev/null and b/bin/ij/plugin/AnimatedGifEncoder2.class differ
diff --git a/bin/ij/plugin/Animator.class b/bin/ij/plugin/Animator.class
new file mode 100644
index 0000000..0d9fbf2
Binary files /dev/null and b/bin/ij/plugin/Animator.class differ
diff --git a/bin/ij/plugin/AppearanceOptions.class b/bin/ij/plugin/AppearanceOptions.class
new file mode 100644
index 0000000..4acbf8c
Binary files /dev/null and b/bin/ij/plugin/AppearanceOptions.class differ
diff --git a/bin/ij/plugin/ArrowToolOptions.class b/bin/ij/plugin/ArrowToolOptions.class
new file mode 100644
index 0000000..4d8116b
Binary files /dev/null and b/bin/ij/plugin/ArrowToolOptions.class differ
diff --git a/bin/ij/plugin/BMPDecoder.class b/bin/ij/plugin/BMPDecoder.class
new file mode 100644
index 0000000..8305180
Binary files /dev/null and b/bin/ij/plugin/BMPDecoder.class differ
diff --git a/bin/ij/plugin/BMP_Reader.class b/bin/ij/plugin/BMP_Reader.class
new file mode 100644
index 0000000..45ca76b
Binary files /dev/null and b/bin/ij/plugin/BMP_Reader.class differ
diff --git a/bin/ij/plugin/BMP_Writer.class b/bin/ij/plugin/BMP_Writer.class
new file mode 100644
index 0000000..fbac225
Binary files /dev/null and b/bin/ij/plugin/BMP_Writer.class differ
diff --git a/bin/ij/plugin/BatchConverter.class b/bin/ij/plugin/BatchConverter.class
new file mode 100644
index 0000000..739afe3
Binary files /dev/null and b/bin/ij/plugin/BatchConverter.class differ
diff --git a/bin/ij/plugin/BatchMeasure.class b/bin/ij/plugin/BatchMeasure.class
new file mode 100644
index 0000000..c8a789d
Binary files /dev/null and b/bin/ij/plugin/BatchMeasure.class differ
diff --git a/bin/ij/plugin/BatchProcessor.class b/bin/ij/plugin/BatchProcessor.class
new file mode 100644
index 0000000..58d524b
Binary files /dev/null and b/bin/ij/plugin/BatchProcessor.class differ
diff --git a/bin/ij/plugin/Benchmark.class b/bin/ij/plugin/Benchmark.class
new file mode 100644
index 0000000..6021568
Binary files /dev/null and b/bin/ij/plugin/Benchmark.class differ
diff --git a/bin/ij/plugin/Binner.class b/bin/ij/plugin/Binner.class
new file mode 100644
index 0000000..9b8f2f5
Binary files /dev/null and b/bin/ij/plugin/Binner.class differ
diff --git a/bin/ij/plugin/BrowserLauncher.class b/bin/ij/plugin/BrowserLauncher.class
new file mode 100644
index 0000000..6d64dce
Binary files /dev/null and b/bin/ij/plugin/BrowserLauncher.class differ
diff --git a/bin/ij/plugin/CalibrationBar$LiveDialog.class b/bin/ij/plugin/CalibrationBar$LiveDialog.class
new file mode 100644
index 0000000..6c6ce20
Binary files /dev/null and b/bin/ij/plugin/CalibrationBar$LiveDialog.class differ
diff --git a/bin/ij/plugin/CalibrationBar.class b/bin/ij/plugin/CalibrationBar.class
new file mode 100644
index 0000000..b24d12f
Binary files /dev/null and b/bin/ij/plugin/CalibrationBar.class differ
diff --git a/bin/ij/plugin/CanvasResizer.class b/bin/ij/plugin/CanvasResizer.class
new file mode 100644
index 0000000..0fe5242
Binary files /dev/null and b/bin/ij/plugin/CanvasResizer.class differ
diff --git a/bin/ij/plugin/ChannelArranger.class b/bin/ij/plugin/ChannelArranger.class
new file mode 100644
index 0000000..e2363e9
Binary files /dev/null and b/bin/ij/plugin/ChannelArranger.class differ
diff --git a/bin/ij/plugin/ChannelSplitter.class b/bin/ij/plugin/ChannelSplitter.class
new file mode 100644
index 0000000..ca63545
Binary files /dev/null and b/bin/ij/plugin/ChannelSplitter.class differ
diff --git a/bin/ij/plugin/CircularRoiMaker.class b/bin/ij/plugin/CircularRoiMaker.class
new file mode 100644
index 0000000..b9d2f84
Binary files /dev/null and b/bin/ij/plugin/CircularRoiMaker.class differ
diff --git a/bin/ij/plugin/ClassChecker.class b/bin/ij/plugin/ClassChecker.class
new file mode 100644
index 0000000..e3472b0
Binary files /dev/null and b/bin/ij/plugin/ClassChecker.class differ
diff --git a/bin/ij/plugin/Clipboard.class b/bin/ij/plugin/Clipboard.class
new file mode 100644
index 0000000..c001413
Binary files /dev/null and b/bin/ij/plugin/Clipboard.class differ
diff --git a/bin/ij/plugin/ColorPanel.class b/bin/ij/plugin/ColorPanel.class
new file mode 100644
index 0000000..7effee3
Binary files /dev/null and b/bin/ij/plugin/ColorPanel.class differ
diff --git a/bin/ij/plugin/Colors.class b/bin/ij/plugin/Colors.class
new file mode 100644
index 0000000..1430c36
Binary files /dev/null and b/bin/ij/plugin/Colors.class differ
diff --git a/bin/ij/plugin/CommandFinder$1.class b/bin/ij/plugin/CommandFinder$1.class
new file mode 100644
index 0000000..a8d41b4
Binary files /dev/null and b/bin/ij/plugin/CommandFinder$1.class differ
diff --git a/bin/ij/plugin/CommandFinder$2.class b/bin/ij/plugin/CommandFinder$2.class
new file mode 100644
index 0000000..61980d5
Binary files /dev/null and b/bin/ij/plugin/CommandFinder$2.class differ
diff --git a/bin/ij/plugin/CommandFinder$CommandAction.class b/bin/ij/plugin/CommandFinder$CommandAction.class
new file mode 100644
index 0000000..b976ab1
Binary files /dev/null and b/bin/ij/plugin/CommandFinder$CommandAction.class differ
diff --git a/bin/ij/plugin/CommandFinder$PromptDocumentListener.class b/bin/ij/plugin/CommandFinder$PromptDocumentListener.class
new file mode 100644
index 0000000..510c0f2
Binary files /dev/null and b/bin/ij/plugin/CommandFinder$PromptDocumentListener.class differ
diff --git a/bin/ij/plugin/CommandFinder$TableModel.class b/bin/ij/plugin/CommandFinder$TableModel.class
new file mode 100644
index 0000000..11a3a8c
Binary files /dev/null and b/bin/ij/plugin/CommandFinder$TableModel.class differ
diff --git a/bin/ij/plugin/CommandFinder.class b/bin/ij/plugin/CommandFinder.class
new file mode 100644
index 0000000..4b4667b
Binary files /dev/null and b/bin/ij/plugin/CommandFinder.class differ
diff --git a/bin/ij/plugin/CommandLister.class b/bin/ij/plugin/CommandLister.class
new file mode 100644
index 0000000..dcf8ad5
Binary files /dev/null and b/bin/ij/plugin/CommandLister.class differ
diff --git a/bin/ij/plugin/Commands.class b/bin/ij/plugin/Commands.class
new file mode 100644
index 0000000..8877f11
Binary files /dev/null and b/bin/ij/plugin/Commands.class differ
diff --git a/bin/ij/plugin/Compiler.class b/bin/ij/plugin/Compiler.class
new file mode 100644
index 0000000..fd73f83
Binary files /dev/null and b/bin/ij/plugin/Compiler.class differ
diff --git a/bin/ij/plugin/CompilerTool$JavaxCompilerTool.class b/bin/ij/plugin/CompilerTool$JavaxCompilerTool.class
new file mode 100644
index 0000000..5cdbc90
Binary files /dev/null and b/bin/ij/plugin/CompilerTool$JavaxCompilerTool.class differ
diff --git a/bin/ij/plugin/CompilerTool$LegacyCompilerTool.class b/bin/ij/plugin/CompilerTool$LegacyCompilerTool.class
new file mode 100644
index 0000000..448c967
Binary files /dev/null and b/bin/ij/plugin/CompilerTool$LegacyCompilerTool.class differ
diff --git a/bin/ij/plugin/CompilerTool.class b/bin/ij/plugin/CompilerTool.class
new file mode 100644
index 0000000..0ecf25a
Binary files /dev/null and b/bin/ij/plugin/CompilerTool.class differ
diff --git a/bin/ij/plugin/CompositeConverter.class b/bin/ij/plugin/CompositeConverter.class
new file mode 100644
index 0000000..8d70853
Binary files /dev/null and b/bin/ij/plugin/CompositeConverter.class differ
diff --git a/bin/ij/plugin/Concatenator.class b/bin/ij/plugin/Concatenator.class
new file mode 100644
index 0000000..9c36069
Binary files /dev/null and b/bin/ij/plugin/Concatenator.class differ
diff --git a/bin/ij/plugin/ContrastEnhancer.class b/bin/ij/plugin/ContrastEnhancer.class
new file mode 100644
index 0000000..783e764
Binary files /dev/null and b/bin/ij/plugin/ContrastEnhancer.class differ
diff --git a/bin/ij/plugin/ControlPanel.class b/bin/ij/plugin/ControlPanel.class
new file mode 100644
index 0000000..f0866db
Binary files /dev/null and b/bin/ij/plugin/ControlPanel.class differ
diff --git a/bin/ij/plugin/Converter.class b/bin/ij/plugin/Converter.class
new file mode 100644
index 0000000..a126d68
Binary files /dev/null and b/bin/ij/plugin/Converter.class differ
diff --git a/bin/ij/plugin/Coordinates.class b/bin/ij/plugin/Coordinates.class
new file mode 100644
index 0000000..60ec9ac
Binary files /dev/null and b/bin/ij/plugin/Coordinates.class differ
diff --git a/bin/ij/plugin/DICOM.class b/bin/ij/plugin/DICOM.class
new file mode 100644
index 0000000..dde5e38
Binary files /dev/null and b/bin/ij/plugin/DICOM.class differ
diff --git a/bin/ij/plugin/DicomDecoder.class b/bin/ij/plugin/DicomDecoder.class
new file mode 100644
index 0000000..b53558b
Binary files /dev/null and b/bin/ij/plugin/DicomDecoder.class differ
diff --git a/bin/ij/plugin/DicomDictionary.class b/bin/ij/plugin/DicomDictionary.class
new file mode 100644
index 0000000..ad48b3c
Binary files /dev/null and b/bin/ij/plugin/DicomDictionary.class differ
diff --git a/bin/ij/plugin/Distribution.class b/bin/ij/plugin/Distribution.class
new file mode 100644
index 0000000..4d0a3b0
Binary files /dev/null and b/bin/ij/plugin/Distribution.class differ
diff --git a/bin/ij/plugin/DragAndDrop.class b/bin/ij/plugin/DragAndDrop.class
new file mode 100644
index 0000000..856d110
Binary files /dev/null and b/bin/ij/plugin/DragAndDrop.class differ
diff --git a/bin/ij/plugin/Duplicator.class b/bin/ij/plugin/Duplicator.class
new file mode 100644
index 0000000..14f4dc3
Binary files /dev/null and b/bin/ij/plugin/Duplicator.class differ
diff --git a/bin/ij/plugin/EventListener.class b/bin/ij/plugin/EventListener.class
new file mode 100644
index 0000000..a839e08
Binary files /dev/null and b/bin/ij/plugin/EventListener.class differ
diff --git a/bin/ij/plugin/FFT.class b/bin/ij/plugin/FFT.class
new file mode 100644
index 0000000..30786c2
Binary files /dev/null and b/bin/ij/plugin/FFT.class differ
diff --git a/bin/ij/plugin/FFTMath.class b/bin/ij/plugin/FFTMath.class
new file mode 100644
index 0000000..0007d6a
Binary files /dev/null and b/bin/ij/plugin/FFTMath.class differ
diff --git a/bin/ij/plugin/FITS_Reader.class b/bin/ij/plugin/FITS_Reader.class
new file mode 100644
index 0000000..d392704
Binary files /dev/null and b/bin/ij/plugin/FITS_Reader.class differ
diff --git a/bin/ij/plugin/FITS_Writer.class b/bin/ij/plugin/FITS_Writer.class
new file mode 100644
index 0000000..8ef320f
Binary files /dev/null and b/bin/ij/plugin/FITS_Writer.class differ
diff --git a/bin/ij/plugin/FileInfoVirtualStack.class b/bin/ij/plugin/FileInfoVirtualStack.class
new file mode 100644
index 0000000..ebb75a5
Binary files /dev/null and b/bin/ij/plugin/FileInfoVirtualStack.class differ
diff --git a/bin/ij/plugin/Filters3D$1.class b/bin/ij/plugin/Filters3D$1.class
new file mode 100644
index 0000000..8c286e6
Binary files /dev/null and b/bin/ij/plugin/Filters3D$1.class differ
diff --git a/bin/ij/plugin/Filters3D.class b/bin/ij/plugin/Filters3D.class
new file mode 100644
index 0000000..0ac13fb
Binary files /dev/null and b/bin/ij/plugin/Filters3D.class differ
diff --git a/bin/ij/plugin/FitsDecoder.class b/bin/ij/plugin/FitsDecoder.class
new file mode 100644
index 0000000..a721bba
Binary files /dev/null and b/bin/ij/plugin/FitsDecoder.class differ
diff --git a/bin/ij/plugin/FolderOpener.class b/bin/ij/plugin/FolderOpener.class
new file mode 100644
index 0000000..36bf4e0
Binary files /dev/null and b/bin/ij/plugin/FolderOpener.class differ
diff --git a/bin/ij/plugin/GIF_Reader.class b/bin/ij/plugin/GIF_Reader.class
new file mode 100644
index 0000000..e22a930
Binary files /dev/null and b/bin/ij/plugin/GIF_Reader.class differ
diff --git a/bin/ij/plugin/GaussianBlur3D.class b/bin/ij/plugin/GaussianBlur3D.class
new file mode 100644
index 0000000..35562d2
Binary files /dev/null and b/bin/ij/plugin/GaussianBlur3D.class differ
diff --git a/bin/ij/plugin/GelAnalyzer.class b/bin/ij/plugin/GelAnalyzer.class
new file mode 100644
index 0000000..5aa2e72
Binary files /dev/null and b/bin/ij/plugin/GelAnalyzer.class differ
diff --git a/bin/ij/plugin/GifDecoder.class b/bin/ij/plugin/GifDecoder.class
new file mode 100644
index 0000000..e29d6ef
Binary files /dev/null and b/bin/ij/plugin/GifDecoder.class differ
diff --git a/bin/ij/plugin/GifFrame.class b/bin/ij/plugin/GifFrame.class
new file mode 100644
index 0000000..be72129
Binary files /dev/null and b/bin/ij/plugin/GifFrame.class differ
diff --git a/bin/ij/plugin/GifWriter.class b/bin/ij/plugin/GifWriter.class
new file mode 100644
index 0000000..5a9aac8
Binary files /dev/null and b/bin/ij/plugin/GifWriter.class differ
diff --git a/bin/ij/plugin/Grid.class b/bin/ij/plugin/Grid.class
new file mode 100644
index 0000000..bb1b75f
Binary files /dev/null and b/bin/ij/plugin/Grid.class differ
diff --git a/bin/ij/plugin/GroupedZProjector.class b/bin/ij/plugin/GroupedZProjector.class
new file mode 100644
index 0000000..abc8457
Binary files /dev/null and b/bin/ij/plugin/GroupedZProjector.class differ
diff --git a/bin/ij/plugin/Histogram.class b/bin/ij/plugin/Histogram.class
new file mode 100644
index 0000000..fc5d21a
Binary files /dev/null and b/bin/ij/plugin/Histogram.class differ
diff --git a/bin/ij/plugin/Hotkeys.class b/bin/ij/plugin/Hotkeys.class
new file mode 100644
index 0000000..6a2b119
Binary files /dev/null and b/bin/ij/plugin/Hotkeys.class differ
diff --git a/bin/ij/plugin/HyperStackConverter.class b/bin/ij/plugin/HyperStackConverter.class
new file mode 100644
index 0000000..cc00a79
Binary files /dev/null and b/bin/ij/plugin/HyperStackConverter.class differ
diff --git a/bin/ij/plugin/HyperStackMaker.class b/bin/ij/plugin/HyperStackMaker.class
new file mode 100644
index 0000000..b911ef4
Binary files /dev/null and b/bin/ij/plugin/HyperStackMaker.class differ
diff --git a/bin/ij/plugin/HyperStackReducer.class b/bin/ij/plugin/HyperStackReducer.class
new file mode 100644
index 0000000..8e865b9
Binary files /dev/null and b/bin/ij/plugin/HyperStackReducer.class differ
diff --git a/bin/ij/plugin/ImageCalculator.class b/bin/ij/plugin/ImageCalculator.class
new file mode 100644
index 0000000..a09a60f
Binary files /dev/null and b/bin/ij/plugin/ImageCalculator.class differ
diff --git a/bin/ij/plugin/ImageInfo.class b/bin/ij/plugin/ImageInfo.class
new file mode 100644
index 0000000..0531163
Binary files /dev/null and b/bin/ij/plugin/ImageInfo.class differ
diff --git a/bin/ij/plugin/ImageJ_Updater.class b/bin/ij/plugin/ImageJ_Updater.class
new file mode 100644
index 0000000..710501e
Binary files /dev/null and b/bin/ij/plugin/ImageJ_Updater.class differ
diff --git a/bin/ij/plugin/ImagesToStack.class b/bin/ij/plugin/ImagesToStack.class
new file mode 100644
index 0000000..027551b
Binary files /dev/null and b/bin/ij/plugin/ImagesToStack.class differ
diff --git a/bin/ij/plugin/JavaProperties.class b/bin/ij/plugin/JavaProperties.class
new file mode 100644
index 0000000..464c318
Binary files /dev/null and b/bin/ij/plugin/JavaProperties.class differ
diff --git a/bin/ij/plugin/JavaScriptEvaluator.class b/bin/ij/plugin/JavaScriptEvaluator.class
new file mode 100644
index 0000000..ceffd21
Binary files /dev/null and b/bin/ij/plugin/JavaScriptEvaluator.class differ
diff --git a/bin/ij/plugin/JpegWriter.class b/bin/ij/plugin/JpegWriter.class
new file mode 100644
index 0000000..af0287b
Binary files /dev/null and b/bin/ij/plugin/JpegWriter.class differ
diff --git a/bin/ij/plugin/LUT_Editor.class b/bin/ij/plugin/LUT_Editor.class
new file mode 100644
index 0000000..d8b2fd4
Binary files /dev/null and b/bin/ij/plugin/LUT_Editor.class differ
diff --git a/bin/ij/plugin/LZWEncoder.class b/bin/ij/plugin/LZWEncoder.class
new file mode 100644
index 0000000..5f923c3
Binary files /dev/null and b/bin/ij/plugin/LZWEncoder.class differ
diff --git a/bin/ij/plugin/LZWEncoder2.class b/bin/ij/plugin/LZWEncoder2.class
new file mode 100644
index 0000000..b14ee19
Binary files /dev/null and b/bin/ij/plugin/LZWEncoder2.class differ
diff --git a/bin/ij/plugin/ListVirtualStack.class b/bin/ij/plugin/ListVirtualStack.class
new file mode 100644
index 0000000..49f36b4
Binary files /dev/null and b/bin/ij/plugin/ListVirtualStack.class differ
diff --git a/bin/ij/plugin/LutLoader.class b/bin/ij/plugin/LutLoader.class
new file mode 100644
index 0000000..b51b224
Binary files /dev/null and b/bin/ij/plugin/LutLoader.class differ
diff --git a/bin/ij/plugin/MacroInstaller.class b/bin/ij/plugin/MacroInstaller.class
new file mode 100644
index 0000000..5d206b9
Binary files /dev/null and b/bin/ij/plugin/MacroInstaller.class differ
diff --git a/bin/ij/plugin/Macro_Runner.class b/bin/ij/plugin/Macro_Runner.class
new file mode 100644
index 0000000..482fd9a
Binary files /dev/null and b/bin/ij/plugin/Macro_Runner.class differ
diff --git a/bin/ij/plugin/MeasurementsWriter.class b/bin/ij/plugin/MeasurementsWriter.class
new file mode 100644
index 0000000..e0eea1f
Binary files /dev/null and b/bin/ij/plugin/MeasurementsWriter.class differ
diff --git a/bin/ij/plugin/Memory.class b/bin/ij/plugin/Memory.class
new file mode 100644
index 0000000..cea6090
Binary files /dev/null and b/bin/ij/plugin/Memory.class differ
diff --git a/bin/ij/plugin/MontageMaker.class b/bin/ij/plugin/MontageMaker.class
new file mode 100644
index 0000000..ae30471
Binary files /dev/null and b/bin/ij/plugin/MontageMaker.class differ
diff --git a/bin/ij/plugin/NeuQuant.class b/bin/ij/plugin/NeuQuant.class
new file mode 100644
index 0000000..e8ef458
Binary files /dev/null and b/bin/ij/plugin/NeuQuant.class differ
diff --git a/bin/ij/plugin/NewPlugin.class b/bin/ij/plugin/NewPlugin.class
new file mode 100644
index 0000000..eadfd18
Binary files /dev/null and b/bin/ij/plugin/NewPlugin.class differ
diff --git a/bin/ij/plugin/NextImageOpener.class b/bin/ij/plugin/NextImageOpener.class
new file mode 100644
index 0000000..da2df14
Binary files /dev/null and b/bin/ij/plugin/NextImageOpener.class differ
diff --git a/bin/ij/plugin/Options.class b/bin/ij/plugin/Options.class
new file mode 100644
index 0000000..d034165
Binary files /dev/null and b/bin/ij/plugin/Options.class differ
diff --git a/bin/ij/plugin/Orthogonal_Views.class b/bin/ij/plugin/Orthogonal_Views.class
new file mode 100644
index 0000000..696f4d7
Binary files /dev/null and b/bin/ij/plugin/Orthogonal_Views.class differ
diff --git a/bin/ij/plugin/OverlayCommands.class b/bin/ij/plugin/OverlayCommands.class
new file mode 100644
index 0000000..5c3bc14
Binary files /dev/null and b/bin/ij/plugin/OverlayCommands.class differ
diff --git a/bin/ij/plugin/OverlayLabels.class b/bin/ij/plugin/OverlayLabels.class
new file mode 100644
index 0000000..7e8828f
Binary files /dev/null and b/bin/ij/plugin/OverlayLabels.class differ
diff --git a/bin/ij/plugin/PGM_Reader.class b/bin/ij/plugin/PGM_Reader.class
new file mode 100644
index 0000000..7eec95b
Binary files /dev/null and b/bin/ij/plugin/PGM_Reader.class differ
diff --git a/bin/ij/plugin/PNG_Writer.class b/bin/ij/plugin/PNG_Writer.class
new file mode 100644
index 0000000..69b134a
Binary files /dev/null and b/bin/ij/plugin/PNG_Writer.class differ
diff --git a/bin/ij/plugin/PNM_Writer.class b/bin/ij/plugin/PNM_Writer.class
new file mode 100644
index 0000000..a50f0b6
Binary files /dev/null and b/bin/ij/plugin/PNM_Writer.class differ
diff --git a/bin/ij/plugin/Plots.class b/bin/ij/plugin/Plots.class
new file mode 100644
index 0000000..5721110
Binary files /dev/null and b/bin/ij/plugin/Plots.class differ
diff --git a/bin/ij/plugin/PlotsCanvas.class b/bin/ij/plugin/PlotsCanvas.class
new file mode 100644
index 0000000..9ea7cac
Binary files /dev/null and b/bin/ij/plugin/PlotsCanvas.class differ
diff --git a/bin/ij/plugin/PlugIn.class b/bin/ij/plugin/PlugIn.class
new file mode 100644
index 0000000..76dc09c
Binary files /dev/null and b/bin/ij/plugin/PlugIn.class differ
diff --git a/bin/ij/plugin/PlugInExecuter.class b/bin/ij/plugin/PlugInExecuter.class
new file mode 100644
index 0000000..55acce3
Binary files /dev/null and b/bin/ij/plugin/PlugInExecuter.class differ
diff --git a/bin/ij/plugin/PlugInInterpreter.class b/bin/ij/plugin/PlugInInterpreter.class
new file mode 100644
index 0000000..d61cbf6
Binary files /dev/null and b/bin/ij/plugin/PlugInInterpreter.class differ
diff --git a/bin/ij/plugin/PluginInstaller.class b/bin/ij/plugin/PluginInstaller.class
new file mode 100644
index 0000000..fa18f97
Binary files /dev/null and b/bin/ij/plugin/PluginInstaller.class differ
diff --git a/bin/ij/plugin/PointToolOptions.class b/bin/ij/plugin/PointToolOptions.class
new file mode 100644
index 0000000..765b9a3
Binary files /dev/null and b/bin/ij/plugin/PointToolOptions.class differ
diff --git a/bin/ij/plugin/Profiler.class b/bin/ij/plugin/Profiler.class
new file mode 100644
index 0000000..2c9e90c
Binary files /dev/null and b/bin/ij/plugin/Profiler.class differ
diff --git a/bin/ij/plugin/Projector.class b/bin/ij/plugin/Projector.class
new file mode 100644
index 0000000..b87c39a
Binary files /dev/null and b/bin/ij/plugin/Projector.class differ
diff --git a/bin/ij/plugin/ProxySettings.class b/bin/ij/plugin/ProxySettings.class
new file mode 100644
index 0000000..a6d94f1
Binary files /dev/null and b/bin/ij/plugin/ProxySettings.class differ
diff --git a/bin/ij/plugin/RGBStackConverter.class b/bin/ij/plugin/RGBStackConverter.class
new file mode 100644
index 0000000..b974fd4
Binary files /dev/null and b/bin/ij/plugin/RGBStackConverter.class differ
diff --git a/bin/ij/plugin/RGBStackMerge.class b/bin/ij/plugin/RGBStackMerge.class
new file mode 100644
index 0000000..e5a3284
Binary files /dev/null and b/bin/ij/plugin/RGBStackMerge.class differ
diff --git a/bin/ij/plugin/RandomOvals.txt b/bin/ij/plugin/RandomOvals.txt
new file mode 100644
index 0000000..88c8548
--- /dev/null
+++ b/bin/ij/plugin/RandomOvals.txt
@@ -0,0 +1,15 @@
+
+  newImage("Untitled", "RGB", 400, 400, 1);
+  width = getWidth();
+  height = getHeight();
+  for (i=0; i<1000; i++) {
+      if (nSlices!=1) exit;
+      w = random()*width/2+1;
+      h = random()*width/2+1;
+      x = random()*width-w/2;
+      y = random()*height-h/2;
+      setForegroundColor(random()*255, random()*255, random()*255);
+      makeOval(x, y, w, h);
+      run("Fill");
+   }
+
diff --git a/bin/ij/plugin/Raw.class b/bin/ij/plugin/Raw.class
new file mode 100644
index 0000000..fc9279f
Binary files /dev/null and b/bin/ij/plugin/Raw.class differ
diff --git a/bin/ij/plugin/RectToolOptions.class b/bin/ij/plugin/RectToolOptions.class
new file mode 100644
index 0000000..212c5b0
Binary files /dev/null and b/bin/ij/plugin/RectToolOptions.class differ
diff --git a/bin/ij/plugin/Resizer.class b/bin/ij/plugin/Resizer.class
new file mode 100644
index 0000000..cf7ed35
Binary files /dev/null and b/bin/ij/plugin/Resizer.class differ
diff --git a/bin/ij/plugin/RoiEnlarger.class b/bin/ij/plugin/RoiEnlarger.class
new file mode 100644
index 0000000..847113d
Binary files /dev/null and b/bin/ij/plugin/RoiEnlarger.class differ
diff --git a/bin/ij/plugin/RoiInterpolator.class b/bin/ij/plugin/RoiInterpolator.class
new file mode 100644
index 0000000..9f5a4e5
Binary files /dev/null and b/bin/ij/plugin/RoiInterpolator.class differ
diff --git a/bin/ij/plugin/RoiReader.class b/bin/ij/plugin/RoiReader.class
new file mode 100644
index 0000000..699f84a
Binary files /dev/null and b/bin/ij/plugin/RoiReader.class differ
diff --git a/bin/ij/plugin/RoiRotator.class b/bin/ij/plugin/RoiRotator.class
new file mode 100644
index 0000000..9c1760c
Binary files /dev/null and b/bin/ij/plugin/RoiRotator.class differ
diff --git a/bin/ij/plugin/RoiScaler.class b/bin/ij/plugin/RoiScaler.class
new file mode 100644
index 0000000..c1c66c5
Binary files /dev/null and b/bin/ij/plugin/RoiScaler.class differ
diff --git a/bin/ij/plugin/ScaleBar$BarDialog.class b/bin/ij/plugin/ScaleBar$BarDialog.class
new file mode 100644
index 0000000..2ad7b4a
Binary files /dev/null and b/bin/ij/plugin/ScaleBar$BarDialog.class differ
diff --git a/bin/ij/plugin/ScaleBar$BarDialogListener.class b/bin/ij/plugin/ScaleBar$BarDialogListener.class
new file mode 100644
index 0000000..da61114
Binary files /dev/null and b/bin/ij/plugin/ScaleBar$BarDialogListener.class differ
diff --git a/bin/ij/plugin/ScaleBar$MissingRoiException.class b/bin/ij/plugin/ScaleBar$MissingRoiException.class
new file mode 100644
index 0000000..e2bea27
Binary files /dev/null and b/bin/ij/plugin/ScaleBar$MissingRoiException.class differ
diff --git a/bin/ij/plugin/ScaleBar$ScaleBarConfiguration.class b/bin/ij/plugin/ScaleBar$ScaleBarConfiguration.class
new file mode 100644
index 0000000..827fc16
Binary files /dev/null and b/bin/ij/plugin/ScaleBar$ScaleBarConfiguration.class differ
diff --git a/bin/ij/plugin/ScaleBar.class b/bin/ij/plugin/ScaleBar.class
new file mode 100644
index 0000000..46ebbc4
Binary files /dev/null and b/bin/ij/plugin/ScaleBar.class differ
diff --git a/bin/ij/plugin/Scaler.class b/bin/ij/plugin/Scaler.class
new file mode 100644
index 0000000..ea177c8
Binary files /dev/null and b/bin/ij/plugin/Scaler.class differ
diff --git a/bin/ij/plugin/ScreenGrabber.class b/bin/ij/plugin/ScreenGrabber.class
new file mode 100644
index 0000000..6530e9a
Binary files /dev/null and b/bin/ij/plugin/ScreenGrabber.class differ
diff --git a/bin/ij/plugin/Selection.class b/bin/ij/plugin/Selection.class
new file mode 100644
index 0000000..0935d7e
Binary files /dev/null and b/bin/ij/plugin/Selection.class differ
diff --git a/bin/ij/plugin/SimpleCommands$1.class b/bin/ij/plugin/SimpleCommands$1.class
new file mode 100644
index 0000000..21719c0
Binary files /dev/null and b/bin/ij/plugin/SimpleCommands$1.class differ
diff --git a/bin/ij/plugin/SimpleCommands.class b/bin/ij/plugin/SimpleCommands.class
new file mode 100644
index 0000000..33d3087
Binary files /dev/null and b/bin/ij/plugin/SimpleCommands.class differ
diff --git a/bin/ij/plugin/Slicer.class b/bin/ij/plugin/Slicer.class
new file mode 100644
index 0000000..27ed10f
Binary files /dev/null and b/bin/ij/plugin/Slicer.class differ
diff --git a/bin/ij/plugin/SpecifyROI.class b/bin/ij/plugin/SpecifyROI.class
new file mode 100644
index 0000000..2160793
Binary files /dev/null and b/bin/ij/plugin/SpecifyROI.class differ
diff --git a/bin/ij/plugin/StackCombiner.class b/bin/ij/plugin/StackCombiner.class
new file mode 100644
index 0000000..8481830
Binary files /dev/null and b/bin/ij/plugin/StackCombiner.class differ
diff --git a/bin/ij/plugin/StackEditor.class b/bin/ij/plugin/StackEditor.class
new file mode 100644
index 0000000..6371ab0
Binary files /dev/null and b/bin/ij/plugin/StackEditor.class differ
diff --git a/bin/ij/plugin/StackInserter.class b/bin/ij/plugin/StackInserter.class
new file mode 100644
index 0000000..b3f7048
Binary files /dev/null and b/bin/ij/plugin/StackInserter.class differ
diff --git a/bin/ij/plugin/StackMaker.class b/bin/ij/plugin/StackMaker.class
new file mode 100644
index 0000000..bab4cc9
Binary files /dev/null and b/bin/ij/plugin/StackMaker.class differ
diff --git a/bin/ij/plugin/StackPlotter.class b/bin/ij/plugin/StackPlotter.class
new file mode 100644
index 0000000..a4959e2
Binary files /dev/null and b/bin/ij/plugin/StackPlotter.class differ
diff --git a/bin/ij/plugin/StackReducer.class b/bin/ij/plugin/StackReducer.class
new file mode 100644
index 0000000..16694bd
Binary files /dev/null and b/bin/ij/plugin/StackReducer.class differ
diff --git a/bin/ij/plugin/StackReverser.class b/bin/ij/plugin/StackReverser.class
new file mode 100644
index 0000000..8aca692
Binary files /dev/null and b/bin/ij/plugin/StackReverser.class differ
diff --git a/bin/ij/plugin/StackWriter.class b/bin/ij/plugin/StackWriter.class
new file mode 100644
index 0000000..6bcd9aa
Binary files /dev/null and b/bin/ij/plugin/StackWriter.class differ
diff --git a/bin/ij/plugin/Stack_Statistics.class b/bin/ij/plugin/Stack_Statistics.class
new file mode 100644
index 0000000..8a3cbaf
Binary files /dev/null and b/bin/ij/plugin/Stack_Statistics.class differ
diff --git a/bin/ij/plugin/Startup.class b/bin/ij/plugin/Startup.class
new file mode 100644
index 0000000..70796d9
Binary files /dev/null and b/bin/ij/plugin/Startup.class differ
diff --git a/bin/ij/plugin/Straightener.class b/bin/ij/plugin/Straightener.class
new file mode 100644
index 0000000..0e9d7e7
Binary files /dev/null and b/bin/ij/plugin/Straightener.class differ
diff --git a/bin/ij/plugin/SubHyperstackMaker.class b/bin/ij/plugin/SubHyperstackMaker.class
new file mode 100644
index 0000000..e096854
Binary files /dev/null and b/bin/ij/plugin/SubHyperstackMaker.class differ
diff --git a/bin/ij/plugin/SubstackMaker.class b/bin/ij/plugin/SubstackMaker.class
new file mode 100644
index 0000000..14df673
Binary files /dev/null and b/bin/ij/plugin/SubstackMaker.class differ
diff --git a/bin/ij/plugin/SurfacePlotter.class b/bin/ij/plugin/SurfacePlotter.class
new file mode 100644
index 0000000..6229087
Binary files /dev/null and b/bin/ij/plugin/SurfacePlotter.class differ
diff --git a/bin/ij/plugin/Text.class b/bin/ij/plugin/Text.class
new file mode 100644
index 0000000..898e5c9
Binary files /dev/null and b/bin/ij/plugin/Text.class differ
diff --git a/bin/ij/plugin/TextFileReader.class b/bin/ij/plugin/TextFileReader.class
new file mode 100644
index 0000000..5cf5504
Binary files /dev/null and b/bin/ij/plugin/TextFileReader.class differ
diff --git a/bin/ij/plugin/TextReader.class b/bin/ij/plugin/TextReader.class
new file mode 100644
index 0000000..56baf13
Binary files /dev/null and b/bin/ij/plugin/TextReader.class differ
diff --git a/bin/ij/plugin/TextWriter.class b/bin/ij/plugin/TextWriter.class
new file mode 100644
index 0000000..c4d50bd
Binary files /dev/null and b/bin/ij/plugin/TextWriter.class differ
diff --git a/bin/ij/plugin/ThreadLister$1.class b/bin/ij/plugin/ThreadLister$1.class
new file mode 100644
index 0000000..fd5a9f3
Binary files /dev/null and b/bin/ij/plugin/ThreadLister$1.class differ
diff --git a/bin/ij/plugin/ThreadLister.class b/bin/ij/plugin/ThreadLister.class
new file mode 100644
index 0000000..a2941ae
Binary files /dev/null and b/bin/ij/plugin/ThreadLister.class differ
diff --git a/bin/ij/plugin/Thresholder.class b/bin/ij/plugin/Thresholder.class
new file mode 100644
index 0000000..9e11052
Binary files /dev/null and b/bin/ij/plugin/Thresholder.class differ
diff --git a/bin/ij/plugin/ThumbnailsCanvas.class b/bin/ij/plugin/ThumbnailsCanvas.class
new file mode 100644
index 0000000..e4f7918
Binary files /dev/null and b/bin/ij/plugin/ThumbnailsCanvas.class differ
diff --git a/bin/ij/plugin/TreePanel$1.class b/bin/ij/plugin/TreePanel$1.class
new file mode 100644
index 0000000..14d6467
Binary files /dev/null and b/bin/ij/plugin/TreePanel$1.class differ
diff --git a/bin/ij/plugin/TreePanel$2.class b/bin/ij/plugin/TreePanel$2.class
new file mode 100644
index 0000000..5e43bdd
Binary files /dev/null and b/bin/ij/plugin/TreePanel$2.class differ
diff --git a/bin/ij/plugin/TreePanel$3.class b/bin/ij/plugin/TreePanel$3.class
new file mode 100644
index 0000000..787b43a
Binary files /dev/null and b/bin/ij/plugin/TreePanel$3.class differ
diff --git a/bin/ij/plugin/TreePanel.class b/bin/ij/plugin/TreePanel.class
new file mode 100644
index 0000000..a61c60e
Binary files /dev/null and b/bin/ij/plugin/TreePanel.class differ
diff --git a/bin/ij/plugin/URLOpener.class b/bin/ij/plugin/URLOpener.class
new file mode 100644
index 0000000..f11225c
Binary files /dev/null and b/bin/ij/plugin/URLOpener.class differ
diff --git a/bin/ij/plugin/WandToolOptions.class b/bin/ij/plugin/WandToolOptions.class
new file mode 100644
index 0000000..a40ad46
Binary files /dev/null and b/bin/ij/plugin/WandToolOptions.class differ
diff --git a/bin/ij/plugin/WindowOrganizer.class b/bin/ij/plugin/WindowOrganizer.class
new file mode 100644
index 0000000..7b072c1
Binary files /dev/null and b/bin/ij/plugin/WindowOrganizer.class differ
diff --git a/bin/ij/plugin/XYCoordinates.class b/bin/ij/plugin/XYCoordinates.class
new file mode 100644
index 0000000..1141dc6
Binary files /dev/null and b/bin/ij/plugin/XYCoordinates.class differ
diff --git a/bin/ij/plugin/XY_Reader.class b/bin/ij/plugin/XY_Reader.class
new file mode 100644
index 0000000..d7dd803
Binary files /dev/null and b/bin/ij/plugin/XY_Reader.class differ
diff --git a/bin/ij/plugin/ZAxisProfiler.class b/bin/ij/plugin/ZAxisProfiler.class
new file mode 100644
index 0000000..4d11927
Binary files /dev/null and b/bin/ij/plugin/ZAxisProfiler.class differ
diff --git a/bin/ij/plugin/ZProjector$AverageIntensity.class b/bin/ij/plugin/ZProjector$AverageIntensity.class
new file mode 100644
index 0000000..84b6a0e
Binary files /dev/null and b/bin/ij/plugin/ZProjector$AverageIntensity.class differ
diff --git a/bin/ij/plugin/ZProjector$MaxIntensity.class b/bin/ij/plugin/ZProjector$MaxIntensity.class
new file mode 100644
index 0000000..4f20794
Binary files /dev/null and b/bin/ij/plugin/ZProjector$MaxIntensity.class differ
diff --git a/bin/ij/plugin/ZProjector$MinIntensity.class b/bin/ij/plugin/ZProjector$MinIntensity.class
new file mode 100644
index 0000000..d8ca9ef
Binary files /dev/null and b/bin/ij/plugin/ZProjector$MinIntensity.class differ
diff --git a/bin/ij/plugin/ZProjector$RayFunction.class b/bin/ij/plugin/ZProjector$RayFunction.class
new file mode 100644
index 0000000..7ec894f
Binary files /dev/null and b/bin/ij/plugin/ZProjector$RayFunction.class differ
diff --git a/bin/ij/plugin/ZProjector$StandardDeviation.class b/bin/ij/plugin/ZProjector$StandardDeviation.class
new file mode 100644
index 0000000..b5153de
Binary files /dev/null and b/bin/ij/plugin/ZProjector$StandardDeviation.class differ
diff --git a/bin/ij/plugin/ZProjector.class b/bin/ij/plugin/ZProjector.class
new file mode 100644
index 0000000..cd10655
Binary files /dev/null and b/bin/ij/plugin/ZProjector.class differ
diff --git a/bin/ij/plugin/Zoom.class b/bin/ij/plugin/Zoom.class
new file mode 100644
index 0000000..bdae61a
Binary files /dev/null and b/bin/ij/plugin/Zoom.class differ
diff --git a/bin/ij/plugin/filter/AVI_Writer$RaOutputStream.class b/bin/ij/plugin/filter/AVI_Writer$RaOutputStream.class
new file mode 100644
index 0000000..ed95f82
Binary files /dev/null and b/bin/ij/plugin/filter/AVI_Writer$RaOutputStream.class differ
diff --git a/bin/ij/plugin/filter/AVI_Writer.class b/bin/ij/plugin/filter/AVI_Writer.class
new file mode 100644
index 0000000..f7881e3
Binary files /dev/null and b/bin/ij/plugin/filter/AVI_Writer.class differ
diff --git a/bin/ij/plugin/filter/Analyzer.class b/bin/ij/plugin/filter/Analyzer.class
new file mode 100644
index 0000000..1a3df07
Binary files /dev/null and b/bin/ij/plugin/filter/Analyzer.class differ
diff --git a/bin/ij/plugin/filter/BackgroundSubtracter.class b/bin/ij/plugin/filter/BackgroundSubtracter.class
new file mode 100644
index 0000000..ef30254
Binary files /dev/null and b/bin/ij/plugin/filter/BackgroundSubtracter.class differ
diff --git a/bin/ij/plugin/filter/Benchmark.class b/bin/ij/plugin/filter/Benchmark.class
new file mode 100644
index 0000000..261ceff
Binary files /dev/null and b/bin/ij/plugin/filter/Benchmark.class differ
diff --git a/bin/ij/plugin/filter/Binary.class b/bin/ij/plugin/filter/Binary.class
new file mode 100644
index 0000000..c36e4ae
Binary files /dev/null and b/bin/ij/plugin/filter/Binary.class differ
diff --git a/bin/ij/plugin/filter/Calibrator.class b/bin/ij/plugin/filter/Calibrator.class
new file mode 100644
index 0000000..c7d8b09
Binary files /dev/null and b/bin/ij/plugin/filter/Calibrator.class differ
diff --git a/bin/ij/plugin/filter/Convolver.class b/bin/ij/plugin/filter/Convolver.class
new file mode 100644
index 0000000..1b959a5
Binary files /dev/null and b/bin/ij/plugin/filter/Convolver.class differ
diff --git a/bin/ij/plugin/filter/Duplicater.class b/bin/ij/plugin/filter/Duplicater.class
new file mode 100644
index 0000000..cf2f44b
Binary files /dev/null and b/bin/ij/plugin/filter/Duplicater.class differ
diff --git a/bin/ij/plugin/filter/EDM.class b/bin/ij/plugin/filter/EDM.class
new file mode 100644
index 0000000..84a1223
Binary files /dev/null and b/bin/ij/plugin/filter/EDM.class differ
diff --git a/bin/ij/plugin/filter/ExtendedPlugInFilter.class b/bin/ij/plugin/filter/ExtendedPlugInFilter.class
new file mode 100644
index 0000000..0b23305
Binary files /dev/null and b/bin/ij/plugin/filter/ExtendedPlugInFilter.class differ
diff --git a/bin/ij/plugin/filter/FFTCustomFilter.class b/bin/ij/plugin/filter/FFTCustomFilter.class
new file mode 100644
index 0000000..07108cb
Binary files /dev/null and b/bin/ij/plugin/filter/FFTCustomFilter.class differ
diff --git a/bin/ij/plugin/filter/FFTFilter.class b/bin/ij/plugin/filter/FFTFilter.class
new file mode 100644
index 0000000..86760a3
Binary files /dev/null and b/bin/ij/plugin/filter/FFTFilter.class differ
diff --git a/bin/ij/plugin/filter/Filler.class b/bin/ij/plugin/filter/Filler.class
new file mode 100644
index 0000000..8e6fd47
Binary files /dev/null and b/bin/ij/plugin/filter/Filler.class differ
diff --git a/bin/ij/plugin/filter/Filters.class b/bin/ij/plugin/filter/Filters.class
new file mode 100644
index 0000000..d8584f4
Binary files /dev/null and b/bin/ij/plugin/filter/Filters.class differ
diff --git a/bin/ij/plugin/filter/FractalBoxCounter.class b/bin/ij/plugin/filter/FractalBoxCounter.class
new file mode 100644
index 0000000..aba81ee
Binary files /dev/null and b/bin/ij/plugin/filter/FractalBoxCounter.class differ
diff --git a/bin/ij/plugin/filter/GaussianBlur$1.class b/bin/ij/plugin/filter/GaussianBlur$1.class
new file mode 100644
index 0000000..fd02334
Binary files /dev/null and b/bin/ij/plugin/filter/GaussianBlur$1.class differ
diff --git a/bin/ij/plugin/filter/GaussianBlur.class b/bin/ij/plugin/filter/GaussianBlur.class
new file mode 100644
index 0000000..3337618
Binary files /dev/null and b/bin/ij/plugin/filter/GaussianBlur.class differ
diff --git a/bin/ij/plugin/filter/ImageMath.class b/bin/ij/plugin/filter/ImageMath.class
new file mode 100644
index 0000000..d7da5ff
Binary files /dev/null and b/bin/ij/plugin/filter/ImageMath.class differ
diff --git a/bin/ij/plugin/filter/ImageProperties.class b/bin/ij/plugin/filter/ImageProperties.class
new file mode 100644
index 0000000..7d0feb6
Binary files /dev/null and b/bin/ij/plugin/filter/ImageProperties.class differ
diff --git a/bin/ij/plugin/filter/Info.class b/bin/ij/plugin/filter/Info.class
new file mode 100644
index 0000000..73d53ec
Binary files /dev/null and b/bin/ij/plugin/filter/Info.class differ
diff --git a/bin/ij/plugin/filter/LineGraphAnalyzer.class b/bin/ij/plugin/filter/LineGraphAnalyzer.class
new file mode 100644
index 0000000..aea4849
Binary files /dev/null and b/bin/ij/plugin/filter/LineGraphAnalyzer.class differ
diff --git a/bin/ij/plugin/filter/LutApplier.class b/bin/ij/plugin/filter/LutApplier.class
new file mode 100644
index 0000000..c0f617d
Binary files /dev/null and b/bin/ij/plugin/filter/LutApplier.class differ
diff --git a/bin/ij/plugin/filter/LutViewer.class b/bin/ij/plugin/filter/LutViewer.class
new file mode 100644
index 0000000..757f363
Binary files /dev/null and b/bin/ij/plugin/filter/LutViewer.class differ
diff --git a/bin/ij/plugin/filter/LutWindow.class b/bin/ij/plugin/filter/LutWindow.class
new file mode 100644
index 0000000..89124be
Binary files /dev/null and b/bin/ij/plugin/filter/LutWindow.class differ
diff --git a/bin/ij/plugin/filter/MaximumFinder.class b/bin/ij/plugin/filter/MaximumFinder.class
new file mode 100644
index 0000000..9358543
Binary files /dev/null and b/bin/ij/plugin/filter/MaximumFinder.class differ
diff --git a/bin/ij/plugin/filter/ParticleAnalyzer.class b/bin/ij/plugin/filter/ParticleAnalyzer.class
new file mode 100644
index 0000000..eff6f00
Binary files /dev/null and b/bin/ij/plugin/filter/ParticleAnalyzer.class differ
diff --git a/bin/ij/plugin/filter/PlugInFilter.class b/bin/ij/plugin/filter/PlugInFilter.class
new file mode 100644
index 0000000..6eb96cc
Binary files /dev/null and b/bin/ij/plugin/filter/PlugInFilter.class differ
diff --git a/bin/ij/plugin/filter/PlugInFilterRunner.class b/bin/ij/plugin/filter/PlugInFilterRunner.class
new file mode 100644
index 0000000..ce13e24
Binary files /dev/null and b/bin/ij/plugin/filter/PlugInFilterRunner.class differ
diff --git a/bin/ij/plugin/filter/Printer.class b/bin/ij/plugin/filter/Printer.class
new file mode 100644
index 0000000..5b48739
Binary files /dev/null and b/bin/ij/plugin/filter/Printer.class differ
diff --git a/bin/ij/plugin/filter/RGBStackSplitter.class b/bin/ij/plugin/filter/RGBStackSplitter.class
new file mode 100644
index 0000000..557147e
Binary files /dev/null and b/bin/ij/plugin/filter/RGBStackSplitter.class differ
diff --git a/bin/ij/plugin/filter/RankFilters$1.class b/bin/ij/plugin/filter/RankFilters$1.class
new file mode 100644
index 0000000..b756d55
Binary files /dev/null and b/bin/ij/plugin/filter/RankFilters$1.class differ
diff --git a/bin/ij/plugin/filter/RankFilters.class b/bin/ij/plugin/filter/RankFilters.class
new file mode 100644
index 0000000..6fd8cd4
Binary files /dev/null and b/bin/ij/plugin/filter/RankFilters.class differ
diff --git a/bin/ij/plugin/filter/RoiWriter.class b/bin/ij/plugin/filter/RoiWriter.class
new file mode 100644
index 0000000..076ac9c
Binary files /dev/null and b/bin/ij/plugin/filter/RoiWriter.class differ
diff --git a/bin/ij/plugin/filter/RollingBall.class b/bin/ij/plugin/filter/RollingBall.class
new file mode 100644
index 0000000..6900169
Binary files /dev/null and b/bin/ij/plugin/filter/RollingBall.class differ
diff --git a/bin/ij/plugin/filter/Rotator.class b/bin/ij/plugin/filter/Rotator.class
new file mode 100644
index 0000000..b27d20a
Binary files /dev/null and b/bin/ij/plugin/filter/Rotator.class differ
diff --git a/bin/ij/plugin/filter/SaltAndPepper.class b/bin/ij/plugin/filter/SaltAndPepper.class
new file mode 100644
index 0000000..05abadb
Binary files /dev/null and b/bin/ij/plugin/filter/SaltAndPepper.class differ
diff --git a/bin/ij/plugin/filter/ScaleDialog.class b/bin/ij/plugin/filter/ScaleDialog.class
new file mode 100644
index 0000000..2b1d071
Binary files /dev/null and b/bin/ij/plugin/filter/ScaleDialog.class differ
diff --git a/bin/ij/plugin/filter/SetScaleDialog.class b/bin/ij/plugin/filter/SetScaleDialog.class
new file mode 100644
index 0000000..2f866c1
Binary files /dev/null and b/bin/ij/plugin/filter/SetScaleDialog.class differ
diff --git a/bin/ij/plugin/filter/Shadows.class b/bin/ij/plugin/filter/Shadows.class
new file mode 100644
index 0000000..27303fa
Binary files /dev/null and b/bin/ij/plugin/filter/Shadows.class differ
diff --git a/bin/ij/plugin/filter/StackLabeler.class b/bin/ij/plugin/filter/StackLabeler.class
new file mode 100644
index 0000000..74f8109
Binary files /dev/null and b/bin/ij/plugin/filter/StackLabeler.class differ
diff --git a/bin/ij/plugin/filter/ThresholdToSelection$Outline.class b/bin/ij/plugin/filter/ThresholdToSelection$Outline.class
new file mode 100644
index 0000000..0901ab1
Binary files /dev/null and b/bin/ij/plugin/filter/ThresholdToSelection$Outline.class differ
diff --git a/bin/ij/plugin/filter/ThresholdToSelection.class b/bin/ij/plugin/filter/ThresholdToSelection.class
new file mode 100644
index 0000000..276f8e4
Binary files /dev/null and b/bin/ij/plugin/filter/ThresholdToSelection.class differ
diff --git a/bin/ij/plugin/filter/Transformer.class b/bin/ij/plugin/filter/Transformer.class
new file mode 100644
index 0000000..3b19d9e
Binary files /dev/null and b/bin/ij/plugin/filter/Transformer.class differ
diff --git a/bin/ij/plugin/filter/Translator.class b/bin/ij/plugin/filter/Translator.class
new file mode 100644
index 0000000..778c4cc
Binary files /dev/null and b/bin/ij/plugin/filter/Translator.class differ
diff --git a/bin/ij/plugin/filter/UnsharpMask.class b/bin/ij/plugin/filter/UnsharpMask.class
new file mode 100644
index 0000000..5bc74ef
Binary files /dev/null and b/bin/ij/plugin/filter/UnsharpMask.class differ
diff --git a/bin/ij/plugin/filter/Writer.class b/bin/ij/plugin/filter/Writer.class
new file mode 100644
index 0000000..cae3fef
Binary files /dev/null and b/bin/ij/plugin/filter/Writer.class differ
diff --git a/bin/ij/plugin/filter/XYWriter.class b/bin/ij/plugin/filter/XYWriter.class
new file mode 100644
index 0000000..c02f58e
Binary files /dev/null and b/bin/ij/plugin/filter/XYWriter.class differ
diff --git a/bin/ij/plugin/frame/Channels.class b/bin/ij/plugin/frame/Channels.class
new file mode 100644
index 0000000..e2edc93
Binary files /dev/null and b/bin/ij/plugin/frame/Channels.class differ
diff --git a/bin/ij/plugin/frame/ColorCanvas.class b/bin/ij/plugin/frame/ColorCanvas.class
new file mode 100644
index 0000000..7c7c127
Binary files /dev/null and b/bin/ij/plugin/frame/ColorCanvas.class differ
diff --git a/bin/ij/plugin/frame/ColorGenerator.class b/bin/ij/plugin/frame/ColorGenerator.class
new file mode 100644
index 0000000..d4dcfc0
Binary files /dev/null and b/bin/ij/plugin/frame/ColorGenerator.class differ
diff --git a/bin/ij/plugin/frame/ColorPicker.class b/bin/ij/plugin/frame/ColorPicker.class
new file mode 100644
index 0000000..a9ed0e0
Binary files /dev/null and b/bin/ij/plugin/frame/ColorPicker.class differ
diff --git a/bin/ij/plugin/frame/ColorThresholder$BandPlot.class b/bin/ij/plugin/frame/ColorThresholder$BandPlot.class
new file mode 100644
index 0000000..811fc95
Binary files /dev/null and b/bin/ij/plugin/frame/ColorThresholder$BandPlot.class differ
diff --git a/bin/ij/plugin/frame/ColorThresholder.class b/bin/ij/plugin/frame/ColorThresholder.class
new file mode 100644
index 0000000..a9c9e3e
Binary files /dev/null and b/bin/ij/plugin/frame/ColorThresholder.class differ
diff --git a/bin/ij/plugin/frame/Commands.class b/bin/ij/plugin/frame/Commands.class
new file mode 100644
index 0000000..310f785
Binary files /dev/null and b/bin/ij/plugin/frame/Commands.class differ
diff --git a/bin/ij/plugin/frame/ContrastAdjuster.class b/bin/ij/plugin/frame/ContrastAdjuster.class
new file mode 100644
index 0000000..68bfba0
Binary files /dev/null and b/bin/ij/plugin/frame/ContrastAdjuster.class differ
diff --git a/bin/ij/plugin/frame/ContrastPlot.class b/bin/ij/plugin/frame/ContrastPlot.class
new file mode 100644
index 0000000..aaccc3f
Binary files /dev/null and b/bin/ij/plugin/frame/ContrastPlot.class differ
diff --git a/bin/ij/plugin/frame/DisplayChangeEvent.class b/bin/ij/plugin/frame/DisplayChangeEvent.class
new file mode 100644
index 0000000..76362dd
Binary files /dev/null and b/bin/ij/plugin/frame/DisplayChangeEvent.class differ
diff --git a/bin/ij/plugin/frame/DisplayChangeListener.class b/bin/ij/plugin/frame/DisplayChangeListener.class
new file mode 100644
index 0000000..6f4ca1f
Binary files /dev/null and b/bin/ij/plugin/frame/DisplayChangeListener.class differ
diff --git a/bin/ij/plugin/frame/Editor.class b/bin/ij/plugin/frame/Editor.class
new file mode 100644
index 0000000..94989ce
Binary files /dev/null and b/bin/ij/plugin/frame/Editor.class differ
diff --git a/bin/ij/plugin/frame/Fitter$1.class b/bin/ij/plugin/frame/Fitter$1.class
new file mode 100644
index 0000000..c2cf51b
Binary files /dev/null and b/bin/ij/plugin/frame/Fitter$1.class differ
diff --git a/bin/ij/plugin/frame/Fitter.class b/bin/ij/plugin/frame/Fitter.class
new file mode 100644
index 0000000..b45ac04
Binary files /dev/null and b/bin/ij/plugin/frame/Fitter.class differ
diff --git a/bin/ij/plugin/frame/IJEventMulticaster.class b/bin/ij/plugin/frame/IJEventMulticaster.class
new file mode 100644
index 0000000..ac153ba
Binary files /dev/null and b/bin/ij/plugin/frame/IJEventMulticaster.class differ
diff --git a/bin/ij/plugin/frame/LineWidthAdjuster.class b/bin/ij/plugin/frame/LineWidthAdjuster.class
new file mode 100644
index 0000000..c377da2
Binary files /dev/null and b/bin/ij/plugin/frame/LineWidthAdjuster.class differ
diff --git a/bin/ij/plugin/frame/MemoryMonitor$PlotCanvas.class b/bin/ij/plugin/frame/MemoryMonitor$PlotCanvas.class
new file mode 100644
index 0000000..0b840e7
Binary files /dev/null and b/bin/ij/plugin/frame/MemoryMonitor$PlotCanvas.class differ
diff --git a/bin/ij/plugin/frame/MemoryMonitor.class b/bin/ij/plugin/frame/MemoryMonitor.class
new file mode 100644
index 0000000..fa3edb0
Binary files /dev/null and b/bin/ij/plugin/frame/MemoryMonitor.class differ
diff --git a/bin/ij/plugin/frame/PasteController.class b/bin/ij/plugin/frame/PasteController.class
new file mode 100644
index 0000000..889ae4d
Binary files /dev/null and b/bin/ij/plugin/frame/PasteController.class differ
diff --git a/bin/ij/plugin/frame/PlugInDialog.class b/bin/ij/plugin/frame/PlugInDialog.class
new file mode 100644
index 0000000..b0bf6b9
Binary files /dev/null and b/bin/ij/plugin/frame/PlugInDialog.class differ
diff --git a/bin/ij/plugin/frame/PlugInFrame.class b/bin/ij/plugin/frame/PlugInFrame.class
new file mode 100644
index 0000000..e0510e2
Binary files /dev/null and b/bin/ij/plugin/frame/PlugInFrame.class differ
diff --git a/bin/ij/plugin/frame/Recorder.class b/bin/ij/plugin/frame/Recorder.class
new file mode 100644
index 0000000..0496c29
Binary files /dev/null and b/bin/ij/plugin/frame/Recorder.class differ
diff --git a/bin/ij/plugin/frame/RoiManager$1.class b/bin/ij/plugin/frame/RoiManager$1.class
new file mode 100644
index 0000000..1b0df43
Binary files /dev/null and b/bin/ij/plugin/frame/RoiManager$1.class differ
diff --git a/bin/ij/plugin/frame/RoiManager$2.class b/bin/ij/plugin/frame/RoiManager$2.class
new file mode 100644
index 0000000..21e1c82
Binary files /dev/null and b/bin/ij/plugin/frame/RoiManager$2.class differ
diff --git a/bin/ij/plugin/frame/RoiManager$3.class b/bin/ij/plugin/frame/RoiManager$3.class
new file mode 100644
index 0000000..4367a72
Binary files /dev/null and b/bin/ij/plugin/frame/RoiManager$3.class differ
diff --git a/bin/ij/plugin/frame/RoiManager$4.class b/bin/ij/plugin/frame/RoiManager$4.class
new file mode 100644
index 0000000..0cd66c9
Binary files /dev/null and b/bin/ij/plugin/frame/RoiManager$4.class differ
diff --git a/bin/ij/plugin/frame/RoiManager$MultiMeasureRunner.class b/bin/ij/plugin/frame/RoiManager$MultiMeasureRunner.class
new file mode 100644
index 0000000..6200d61
Binary files /dev/null and b/bin/ij/plugin/frame/RoiManager$MultiMeasureRunner.class differ
diff --git a/bin/ij/plugin/frame/RoiManager.class b/bin/ij/plugin/frame/RoiManager.class
new file mode 100644
index 0000000..6078557
Binary files /dev/null and b/bin/ij/plugin/frame/RoiManager.class differ
diff --git a/bin/ij/plugin/frame/SyncWindows.class b/bin/ij/plugin/frame/SyncWindows.class
new file mode 100644
index 0000000..fbc999f
Binary files /dev/null and b/bin/ij/plugin/frame/SyncWindows.class differ
diff --git a/bin/ij/plugin/frame/ThresholdAdjuster.class b/bin/ij/plugin/frame/ThresholdAdjuster.class
new file mode 100644
index 0000000..94af7ab
Binary files /dev/null and b/bin/ij/plugin/frame/ThresholdAdjuster.class differ
diff --git a/bin/ij/plugin/frame/ThresholdPlot.class b/bin/ij/plugin/frame/ThresholdPlot.class
new file mode 100644
index 0000000..67af72f
Binary files /dev/null and b/bin/ij/plugin/frame/ThresholdPlot.class differ
diff --git a/bin/ij/plugin/frame/TrimmedLabel.class b/bin/ij/plugin/frame/TrimmedLabel.class
new file mode 100644
index 0000000..78b96b6
Binary files /dev/null and b/bin/ij/plugin/frame/TrimmedLabel.class differ
diff --git a/bin/ij/plugin/tool/ArrowTool.class b/bin/ij/plugin/tool/ArrowTool.class
new file mode 100644
index 0000000..845dfc1
Binary files /dev/null and b/bin/ij/plugin/tool/ArrowTool.class differ
diff --git a/bin/ij/plugin/tool/BrushTool$Options.class b/bin/ij/plugin/tool/BrushTool$Options.class
new file mode 100644
index 0000000..19ec1be
Binary files /dev/null and b/bin/ij/plugin/tool/BrushTool$Options.class differ
diff --git a/bin/ij/plugin/tool/BrushTool.class b/bin/ij/plugin/tool/BrushTool.class
new file mode 100644
index 0000000..15d842c
Binary files /dev/null and b/bin/ij/plugin/tool/BrushTool.class differ
diff --git a/bin/ij/plugin/tool/MacroToolRunner.class b/bin/ij/plugin/tool/MacroToolRunner.class
new file mode 100644
index 0000000..9d5f7c1
Binary files /dev/null and b/bin/ij/plugin/tool/MacroToolRunner.class differ
diff --git a/bin/ij/plugin/tool/OverlayBrushTool$Options.class b/bin/ij/plugin/tool/OverlayBrushTool$Options.class
new file mode 100644
index 0000000..6ee184c
Binary files /dev/null and b/bin/ij/plugin/tool/OverlayBrushTool$Options.class differ
diff --git a/bin/ij/plugin/tool/OverlayBrushTool.class b/bin/ij/plugin/tool/OverlayBrushTool.class
new file mode 100644
index 0000000..58fb0aa
Binary files /dev/null and b/bin/ij/plugin/tool/OverlayBrushTool.class differ
diff --git a/bin/ij/plugin/tool/PixelInspectionTool.class b/bin/ij/plugin/tool/PixelInspectionTool.class
new file mode 100644
index 0000000..6fae179
Binary files /dev/null and b/bin/ij/plugin/tool/PixelInspectionTool.class differ
diff --git a/bin/ij/plugin/tool/PixelInspector.class b/bin/ij/plugin/tool/PixelInspector.class
new file mode 100644
index 0000000..f64498c
Binary files /dev/null and b/bin/ij/plugin/tool/PixelInspector.class differ
diff --git a/bin/ij/plugin/tool/PlugInTool.class b/bin/ij/plugin/tool/PlugInTool.class
new file mode 100644
index 0000000..310a914
Binary files /dev/null and b/bin/ij/plugin/tool/PlugInTool.class differ
diff --git a/bin/ij/plugin/tool/RoiRotationTool.class b/bin/ij/plugin/tool/RoiRotationTool.class
new file mode 100644
index 0000000..dbb5ce8
Binary files /dev/null and b/bin/ij/plugin/tool/RoiRotationTool.class differ
diff --git a/bin/ij/process/AutoThresholder$Method.class b/bin/ij/process/AutoThresholder$Method.class
new file mode 100644
index 0000000..1a15826
Binary files /dev/null and b/bin/ij/process/AutoThresholder$Method.class differ
diff --git a/bin/ij/process/AutoThresholder.class b/bin/ij/process/AutoThresholder.class
new file mode 100644
index 0000000..734bf86
Binary files /dev/null and b/bin/ij/process/AutoThresholder.class differ
diff --git a/bin/ij/process/BinaryInterpolator$IDT.class b/bin/ij/process/BinaryInterpolator$IDT.class
new file mode 100644
index 0000000..e43355b
Binary files /dev/null and b/bin/ij/process/BinaryInterpolator$IDT.class differ
diff --git a/bin/ij/process/BinaryInterpolator.class b/bin/ij/process/BinaryInterpolator.class
new file mode 100644
index 0000000..b30cc8f
Binary files /dev/null and b/bin/ij/process/BinaryInterpolator.class differ
diff --git a/bin/ij/process/BinaryProcessor.class b/bin/ij/process/BinaryProcessor.class
new file mode 100644
index 0000000..fbdbcfd
Binary files /dev/null and b/bin/ij/process/BinaryProcessor.class differ
diff --git a/bin/ij/process/Blitter.class b/bin/ij/process/Blitter.class
new file mode 100644
index 0000000..cc3f0d1
Binary files /dev/null and b/bin/ij/process/Blitter.class differ
diff --git a/bin/ij/process/ByteBlitter.class b/bin/ij/process/ByteBlitter.class
new file mode 100644
index 0000000..c4c6c62
Binary files /dev/null and b/bin/ij/process/ByteBlitter.class differ
diff --git a/bin/ij/process/ByteProcessor.class b/bin/ij/process/ByteProcessor.class
new file mode 100644
index 0000000..deb4286
Binary files /dev/null and b/bin/ij/process/ByteProcessor.class differ
diff --git a/bin/ij/process/ByteStatistics.class b/bin/ij/process/ByteStatistics.class
new file mode 100644
index 0000000..7054a31
Binary files /dev/null and b/bin/ij/process/ByteStatistics.class differ
diff --git a/bin/ij/process/ColorBlitter.class b/bin/ij/process/ColorBlitter.class
new file mode 100644
index 0000000..340a38a
Binary files /dev/null and b/bin/ij/process/ColorBlitter.class differ
diff --git a/bin/ij/process/ColorProcessor.class b/bin/ij/process/ColorProcessor.class
new file mode 100644
index 0000000..2c2920b
Binary files /dev/null and b/bin/ij/process/ColorProcessor.class differ
diff --git a/bin/ij/process/ColorSpaceConverter.class b/bin/ij/process/ColorSpaceConverter.class
new file mode 100644
index 0000000..eeba99f
Binary files /dev/null and b/bin/ij/process/ColorSpaceConverter.class differ
diff --git a/bin/ij/process/ColorStatistics.class b/bin/ij/process/ColorStatistics.class
new file mode 100644
index 0000000..2c3ae69
Binary files /dev/null and b/bin/ij/process/ColorStatistics.class differ
diff --git a/bin/ij/process/Cube.class b/bin/ij/process/Cube.class
new file mode 100644
index 0000000..87b103b
Binary files /dev/null and b/bin/ij/process/Cube.class differ
diff --git a/bin/ij/process/DownsizeTable.class b/bin/ij/process/DownsizeTable.class
new file mode 100644
index 0000000..76883ea
Binary files /dev/null and b/bin/ij/process/DownsizeTable.class differ
diff --git a/bin/ij/process/EllipseFitter.class b/bin/ij/process/EllipseFitter.class
new file mode 100644
index 0000000..b57c7e9
Binary files /dev/null and b/bin/ij/process/EllipseFitter.class differ
diff --git a/bin/ij/process/FHT.class b/bin/ij/process/FHT.class
new file mode 100644
index 0000000..8bffdf4
Binary files /dev/null and b/bin/ij/process/FHT.class differ
diff --git a/bin/ij/process/FloatBlitter.class b/bin/ij/process/FloatBlitter.class
new file mode 100644
index 0000000..879ed87
Binary files /dev/null and b/bin/ij/process/FloatBlitter.class differ
diff --git a/bin/ij/process/FloatPolygon.class b/bin/ij/process/FloatPolygon.class
new file mode 100644
index 0000000..a39d3f1
Binary files /dev/null and b/bin/ij/process/FloatPolygon.class differ
diff --git a/bin/ij/process/FloatProcessor.class b/bin/ij/process/FloatProcessor.class
new file mode 100644
index 0000000..ee25fab
Binary files /dev/null and b/bin/ij/process/FloatProcessor.class differ
diff --git a/bin/ij/process/FloatStatistics.class b/bin/ij/process/FloatStatistics.class
new file mode 100644
index 0000000..2d77347
Binary files /dev/null and b/bin/ij/process/FloatStatistics.class differ
diff --git a/bin/ij/process/FloodFiller.class b/bin/ij/process/FloodFiller.class
new file mode 100644
index 0000000..5ad7c69
Binary files /dev/null and b/bin/ij/process/FloodFiller.class differ
diff --git a/bin/ij/process/ImageConverter.class b/bin/ij/process/ImageConverter.class
new file mode 100644
index 0000000..e0e25bf
Binary files /dev/null and b/bin/ij/process/ImageConverter.class differ
diff --git a/bin/ij/process/ImageProcessor.class b/bin/ij/process/ImageProcessor.class
new file mode 100644
index 0000000..5e613ce
Binary files /dev/null and b/bin/ij/process/ImageProcessor.class differ
diff --git a/bin/ij/process/ImageStatistics.class b/bin/ij/process/ImageStatistics.class
new file mode 100644
index 0000000..eb9b972
Binary files /dev/null and b/bin/ij/process/ImageStatistics.class differ
diff --git a/bin/ij/process/IntProcessor.class b/bin/ij/process/IntProcessor.class
new file mode 100644
index 0000000..e9bfb5e
Binary files /dev/null and b/bin/ij/process/IntProcessor.class differ
diff --git a/bin/ij/process/LUT.class b/bin/ij/process/LUT.class
new file mode 100644
index 0000000..47723ab
Binary files /dev/null and b/bin/ij/process/LUT.class differ
diff --git a/bin/ij/process/MedianCut.class b/bin/ij/process/MedianCut.class
new file mode 100644
index 0000000..fe9dcd7
Binary files /dev/null and b/bin/ij/process/MedianCut.class differ
diff --git a/bin/ij/process/PolygonFiller.class b/bin/ij/process/PolygonFiller.class
new file mode 100644
index 0000000..7934ad2
Binary files /dev/null and b/bin/ij/process/PolygonFiller.class differ
diff --git a/bin/ij/process/ShortBlitter.class b/bin/ij/process/ShortBlitter.class
new file mode 100644
index 0000000..41af3d3
Binary files /dev/null and b/bin/ij/process/ShortBlitter.class differ
diff --git a/bin/ij/process/ShortProcessor.class b/bin/ij/process/ShortProcessor.class
new file mode 100644
index 0000000..6bc882d
Binary files /dev/null and b/bin/ij/process/ShortProcessor.class differ
diff --git a/bin/ij/process/ShortStatistics.class b/bin/ij/process/ShortStatistics.class
new file mode 100644
index 0000000..43eb1ee
Binary files /dev/null and b/bin/ij/process/ShortStatistics.class differ
diff --git a/bin/ij/process/StackConverter.class b/bin/ij/process/StackConverter.class
new file mode 100644
index 0000000..534f330
Binary files /dev/null and b/bin/ij/process/StackConverter.class differ
diff --git a/bin/ij/process/StackProcessor.class b/bin/ij/process/StackProcessor.class
new file mode 100644
index 0000000..aa0803b
Binary files /dev/null and b/bin/ij/process/StackProcessor.class differ
diff --git a/bin/ij/process/StackStatistics.class b/bin/ij/process/StackStatistics.class
new file mode 100644
index 0000000..1b45fda
Binary files /dev/null and b/bin/ij/process/StackStatistics.class differ
diff --git a/bin/ij/process/TypeConverter.class b/bin/ij/process/TypeConverter.class
new file mode 100644
index 0000000..e27534f
Binary files /dev/null and b/bin/ij/process/TypeConverter.class differ
diff --git a/bin/ij/text/TableListener.class b/bin/ij/text/TableListener.class
new file mode 100644
index 0000000..3f0f27a
Binary files /dev/null and b/bin/ij/text/TableListener.class differ
diff --git a/bin/ij/text/TextCanvas.class b/bin/ij/text/TextCanvas.class
new file mode 100644
index 0000000..16c8955
Binary files /dev/null and b/bin/ij/text/TextCanvas.class differ
diff --git a/bin/ij/text/TextPanel.class b/bin/ij/text/TextPanel.class
new file mode 100644
index 0000000..77ea6ba
Binary files /dev/null and b/bin/ij/text/TextPanel.class differ
diff --git a/bin/ij/text/TextWindow.class b/bin/ij/text/TextWindow.class
new file mode 100644
index 0000000..02b4fba
Binary files /dev/null and b/bin/ij/text/TextWindow.class differ
diff --git a/bin/ij/util/ArrayUtil.class b/bin/ij/util/ArrayUtil.class
new file mode 100644
index 0000000..3f16c36
Binary files /dev/null and b/bin/ij/util/ArrayUtil.class differ
diff --git a/bin/ij/util/DicomTools.class b/bin/ij/util/DicomTools.class
new file mode 100644
index 0000000..5c51495
Binary files /dev/null and b/bin/ij/util/DicomTools.class differ
diff --git a/bin/ij/util/FloatArray.class b/bin/ij/util/FloatArray.class
new file mode 100644
index 0000000..cd3de35
Binary files /dev/null and b/bin/ij/util/FloatArray.class differ
diff --git a/bin/ij/util/FontUtil.class b/bin/ij/util/FontUtil.class
new file mode 100644
index 0000000..61c9f6c
Binary files /dev/null and b/bin/ij/util/FontUtil.class differ
diff --git a/bin/ij/util/IJMath.class b/bin/ij/util/IJMath.class
new file mode 100644
index 0000000..8a5388a
Binary files /dev/null and b/bin/ij/util/IJMath.class differ
diff --git a/bin/ij/util/Java2.class b/bin/ij/util/Java2.class
new file mode 100644
index 0000000..311830e
Binary files /dev/null and b/bin/ij/util/Java2.class differ
diff --git a/bin/ij/util/StringSorter.class b/bin/ij/util/StringSorter.class
new file mode 100644
index 0000000..91391c7
Binary files /dev/null and b/bin/ij/util/StringSorter.class differ
diff --git a/bin/ij/util/ThreadUtil$1.class b/bin/ij/util/ThreadUtil$1.class
new file mode 100644
index 0000000..a6698f6
Binary files /dev/null and b/bin/ij/util/ThreadUtil$1.class differ
diff --git a/bin/ij/util/ThreadUtil.class b/bin/ij/util/ThreadUtil.class
new file mode 100644
index 0000000..37924d0
Binary files /dev/null and b/bin/ij/util/ThreadUtil.class differ
diff --git a/bin/ij/util/Tools$1.class b/bin/ij/util/Tools$1.class
new file mode 100644
index 0000000..469f9f7
Binary files /dev/null and b/bin/ij/util/Tools$1.class differ
diff --git a/bin/ij/util/Tools$2.class b/bin/ij/util/Tools$2.class
new file mode 100644
index 0000000..00de779
Binary files /dev/null and b/bin/ij/util/Tools$2.class differ
diff --git a/bin/ij/util/Tools.class b/bin/ij/util/Tools.class
new file mode 100644
index 0000000..4ba0ec4
Binary files /dev/null and b/bin/ij/util/Tools.class differ
diff --git a/bin/ij/util/WildcardMatch.class b/bin/ij/util/WildcardMatch.class
new file mode 100644
index 0000000..e120764
Binary files /dev/null and b/bin/ij/util/WildcardMatch.class differ
diff --git a/images/about.jpg b/images/about.jpg
new file mode 100644
index 0000000..3ae6414
Binary files /dev/null and b/images/about.jpg differ
diff --git a/images/microscope.gif b/images/microscope.gif
new file mode 100644
index 0000000..bb2c9f5
Binary files /dev/null and b/images/microscope.gif differ
diff --git a/macros/AddParticles.txt b/macros/AddParticles.txt
new file mode 100644
index 0000000..edd71cf
--- /dev/null
+++ b/macros/AddParticles.txt
@@ -0,0 +1,12 @@
+// Adds particle analyzer ROIs to the ROI Manager
+  if (nResults==0)
+      return "Results table is empty";
+  if (isNaN(getResult('XStart', 0)))
+      return "Run the particle analyzer with \"Clear Results\" \nand \"Record Starts\" checked, then try again.";
+  for (i=0; i<nResults; i++) {
+      x = getResult('XStart', i);
+      y = getResult('YStart', i);
+      doWand(x,y);
+      roiManager("add");
+  }
+  return "";
diff --git a/macros/Circle_Tool.txt b/macros/Circle_Tool.txt
new file mode 100644
index 0000000..567aa34
--- /dev/null
+++ b/macros/Circle_Tool.txt
@@ -0,0 +1,19 @@
+// This example macro tool creates circular selections.
+// Press ctrl-i (Macros>Install Macros) to reinstall after
+// making changes. Double click on the tool icon (a circle)
+// to set the radius of the circle.
+// There is more information about macro tools at
+//   http://imagej.nih.gov/ij/developer/macro/macros.html#tools
+// and many more examples at
+//   http://imagej.nih.gov/ij/macros/tools/
+
+var radius = 20;
+
+macro "Circle Tool - C00cO11cc" {
+   getCursorLoc(x, y, z, flags);
+   makeOval(x-radius, y-radius, radius*2, radius*2);
+}
+
+macro "Circle Tool Options" {
+   radius = getNumber("Radius: ", radius);
+}
diff --git a/macros/CommandFinderTool.txt b/macros/CommandFinderTool.txt
new file mode 100644
index 0000000..4d673d4
--- /dev/null
+++ b/macros/CommandFinderTool.txt
@@ -0,0 +1,4 @@
+   macro "Command Finder Action Tool - C037T0e17CTce17F" {
+      run("Find Commands...");
+   }
+
diff --git a/macros/ConvertStackToBinary.txt b/macros/ConvertStackToBinary.txt
new file mode 100644
index 0000000..faf0842
--- /dev/null
+++ b/macros/ConvertStackToBinary.txt
@@ -0,0 +1,19 @@
+// Converts a stack to binary using locally calculated thresholds
+
+  setBatchMode(true);
+  run("Select None");
+  run("8-bit");
+  id = getImageID;
+  for (i=1; i<=nSlices; i++) {
+     setSlice(i);
+     run("Duplicate...", "title=temp");
+     run("Convert to Mask");
+     invertingLUT = is("Inverting LUT");
+     run("Copy");
+     close;
+     selectImage(id);
+     run("Paste");
+     if (i==1 && invertingLUT != is("Inverting LUT"))
+         run("Invert LUT");
+  }
+  run("Select None");
diff --git a/macros/DeveloperMenuTool.txt b/macros/DeveloperMenuTool.txt
new file mode 100644
index 0000000..491546f
--- /dev/null
+++ b/macros/DeveloperMenuTool.txt
@@ -0,0 +1,14 @@
+   var dCmds = newMenu("Developer Menu Tool",
+      newArray("Record...", "Capture Screen ", "Monitor Memory...", "Find Commands...",
+      "Search...", "ImageJ Properties", "List Elements", "Debug Mode", "ImageJ Website...",
+      "-", "Image...", "Hyperstack...", "Macro", "Open...", 
+      "-", "Blobs", "Fly Brain", "HeLa Cells (48-bit RGB)", "Image with Overlay",
+      "Mitosis (5D stack)", "T1 Head (16-bits)"));
+      
+   macro "Developer Menu Tool - C037T0b14DT9b12eTfb12v" {
+       cmd = getArgument();
+       if (cmd=="Debug Mode")
+          setOption("DebugMode", true);
+       else if (cmd!="-")
+          run(cmd);
+   }
diff --git a/macros/Filter_Plugin.src b/macros/Filter_Plugin.src
new file mode 100644
index 0000000..d2389b4
--- /dev/null
+++ b/macros/Filter_Plugin.src
@@ -0,0 +1,19 @@
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.plugin.filter.*;
+
+public class Filter_Plugin implements PlugInFilter {
+	ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL;
+	}
+
+	public void run(ImageProcessor ip) {
+		ip.invert();
+	}
+
+}
diff --git a/macros/FloodFillTool.txt b/macros/FloodFillTool.txt
new file mode 100644
index 0000000..6d97598
--- /dev/null
+++ b/macros/FloodFillTool.txt
@@ -0,0 +1,18 @@
+   var floodType = call("ij.Prefs.get", "tool.flood", "8-connected");
+   var alt = 8;
+
+    macro "Flood Fill Tool -C037B21P085373b75d0L4d1aL3135L4050L6166D57D77D68D09D94Da7C123Da5La9abLb6bc" {
+        setupUndo();
+        getCursorLoc(x, y, z, flags);
+       if (flags&alt!=0)
+          setColor(getValue("color.background"));
+        floodFill(x, y, floodType);
+     }
+
+  macro 'Flood Fill Tool Options...' {
+      Dialog.create("Flood Fill Tool");
+      Dialog.addChoice("Flood Type:", newArray("4-connected", "8-connected"), floodType);
+      Dialog.show();
+      floodType = Dialog.getChoice();
+      call("ij.Prefs.set", "tool.flood", floodType);
+  }
diff --git a/macros/LUTMenuTool.txt b/macros/LUTMenuTool.txt
new file mode 100644
index 0000000..2ce2add
--- /dev/null
+++ b/macros/LUTMenuTool.txt
@@ -0,0 +1,19 @@
+    var lutdir = getDirectory("startup")+"luts"+File.separator;
+    var luts = getLutMenu();
+    var lCmds = newMenu("LUT Menu Tool", luts);
+    
+    macro "LUT Menu Tool - C037T0b10LT6b10UTeb10T" {
+         cmd = getArgument();
+  	  if (cmd!="-") run(cmd);
+    }
+    
+    function getLutMenu() {
+        list = getList("LUTs");
+        menu = newArray(3+list.length);
+        menu[0] = "Invert LUT";
+        menu[1] = "Apply LUT";
+        menu[2] = "-";
+        for (i=0; i<list.length; i++)
+             menu[i+3] = list[i];
+        return menu;
+    }
diff --git a/macros/Label_Tool.txt b/macros/Label_Tool.txt
new file mode 100644
index 0000000..643b680
--- /dev/null
+++ b/macros/Label_Tool.txt
@@ -0,0 +1,79 @@
+// An ImageJ tool that makes nice and easy labels 
+// as seen https://twitter.com/Astbury_BSL/status/1258677104696311809
+// Author: Jerome Mutterer
+
+   var label = 'label';
+   var lineWidth = 2;
+   var globalLineWidth = parseInt(call('ij.gui.Line.getWidth'));
+  
+   macro "Label Tool (double click for options) - C037o0d55L3d65L65f5T830ca" {  
+     width = parseInt(call('ij.gui.Line.getWidth'));
+      if (width>1 || width!=globalLineWidth) {
+         lineWidth=width;
+         globalLineWidth = width;
+      }
+      radius = maxOf(4,lineWidth*2);
+      getCursorLoc(x, y, z, flags);
+      if (flags&9>0) {  // shift or alt
+         removeLabel(x,y);
+         exit();
+      }
+      getDateAndTime(yr, mo, dw, d, h, m, s, ms);
+      uid = "labeltool_"+yr+""+mo+""+d+""+h+""+m+""+s+""+ms;
+      nbefore = Overlay.size;
+      getCursorLoc(x1, y1, z, flags);
+      setLineWidth(lineWidth);
+      while (flags&16>0) {
+         getCursorLoc(x1, y1, z, flags);
+         drawItem();
+         wait(30);
+         while (Overlay.size>nbefore)
+            Overlay.removeSelection(Overlay.size-1);
+      }
+      drawItem();
+      label =getString("Enter label", label);
+      while (Overlay.size>nbefore)
+         Overlay.removeSelection(Overlay.size-1);
+      drawItem();
+   }
+
+   function drawItem() {
+      makeOval(x-radius, y-radius, radius*2, radius*2);
+      Roi.setName(uid);
+      Overlay.addSelection("",0,""+hexCol());
+      makeLine(x, y,x1,y1,x1+(((x1<x)*-1)+((x1>=x)*1))*getStringWidth(label),y1);
+      Roi.setName(uid);
+      Overlay.addSelection(""+hexCol(), lineWidth);
+      setFont("user");
+      makeText(label, x1 - (x1<x)*getStringWidth(label), y1-getValue("font.height")-lineWidth);
+      Roi.setName(uid);
+      Overlay.addSelection(""+hexCol(), lineWidth);
+      run("Select None");
+   }
+
+   function hexCol() {
+      return IJ.pad(toHex(getValue("rgb.foreground")),6);
+   }
+
+   function removeLabel(x,y) {
+      index = Overlay.indexAt(x,y);
+      if (index>=0) {
+         Overlay.activateSelection(index);
+         name = Roi.getName();
+         Overlay.removeRois(name);
+         Roi.remove;
+      }
+   }
+
+   macro "Label Tool (double click for options) Options" {
+      Dialog.create("Label Maker Tool Options");
+      Dialog.addNumber("Line width:", lineWidth, 0, 3, "pixels");
+      m1 = "Shift or alt click to remove a label.\n";
+      m2 = "Double click on text tool to change\n";
+      m3 = "font size and color.";
+      Dialog.setInsets(0, 0, 0);
+      Dialog.addMessage(m1+m2+m3);
+      Dialog.show();
+      lineWidth = Dialog.getNumber();
+ }
+
diff --git a/macros/MagicMontageTools.txt b/macros/MagicMontageTools.txt
new file mode 100644
index 0000000..9b28037
--- /dev/null
+++ b/macros/MagicMontageTools.txt
@@ -0,0 +1,448 @@
+//--version--1.6
+// 1.6 adds the '?' button that points to the wiki page
+//     panel labels are now drawn on an overlay
+//     added overlay commands and copy to system clipboard to the rightclick menu
+// Montage tools for easy montage manipulation
+// jerome.mutterer at ibmp.fr
+
+var str="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var lcas=false;
+var antialiasedLabels = true;
+var n=0;
+var xoffset=0.05;
+var yoffset=0.05;
+var pos="Clicked quadrant";
+
+var commands = newArray("Copy", "Paste","-", "Scale Bar...", 
+    "Brightness/Contrast...", "-", "Extract Selected Panels","Crop Montage [F3]","-",
+    "Add Panel to Manager [F1]","Selected panels to stack [F2]", "Montage to Stack", "-",
+    "Fit Clipboard content into panel [F4]","Fill Panel with Clipboard content [F5]","-",
+    "Set Montage Layout","Change Montage Layout","-",
+    "Hide Overlay","Show Overlay", "Remove Overlay", "Flatten", "-",
+    "Copy to System"));
+
+var toolCmds = newMenu("Magic Montage Menu Tool",commands);
+var pmCmds = newMenu("Popup Menu",commands);
+ 
+macro "Popup Menu" {
+   runCommand();
+}
+
+macro "Auto Montage Action Tool - C66fF0077C6f6F9977Cf66F9077C888F0977" {
+    setBatchMode(true);
+    b=bitDepth;
+    if ((b!=24)&&(nSlices==1)) 	{ exit("Stack, Composite, or RGB image required.");}
+    if ((b==24)&&(nSlices==1)) 	{ run("Make Composite"); b=8;}
+    Stack.getDimensions(width, height, channels, slices, frames);
+    getVoxelSize(xp,yp,zp,unit);
+    if (channels==1) { channels = channels* frames*slices; Stack.setDimensions(channels,1,1); }
+    id=getImageID;
+    t=getTitle;
+    if (b!=24) {
+        newImage("tempmont", "RGB", width, height,channels);
+        id2=getImageID;
+        for (i=1;i<=channels;i++) {
+            setPasteMode("copy");
+            selectImage(id);
+            Stack.setChannel(i);
+            getLut(r,g,b);
+            run("Duplicate...", "title=temp"+i);
+            setLut(r,g,b);
+            run("RGB Color");
+            run("Copy");
+            selectImage(id2);
+            setSlice(i);
+            run("Paste");
+        }
+    }
+    run("Make Montage...", "scale=1 border=0");
+    rename(getTitle+" of "+t);
+    setVoxelSize(xp,yp,zp,unit);
+    setBatchMode(false);
+}
+
+macro "Select Panels Tool - Cf44R0077R9077C888R9977R0977"{
+    run("Select None");
+    setPasteMode("copy");
+    w = getWidth;
+    h = getHeight;
+    getCursorLoc(x, y, z, flags);
+    id=getImageID;
+    t=getTitle;
+    selectImage(id);
+    xn = info("xMontage");
+    yn = info("yMontage");
+    if ((xn==0)||(yn==0))
+       exit;
+    xc = floor(x/(w/xn));
+    yc = floor(y/(h/yn));
+    makeRectangle(xc*(w/xn),yc*(h/yn),(w/xn),(h/yn));
+    xstart = x; ystart = y;
+    x2=x; y2=y;
+    x2c=xc;y2c=yc;
+    while (flags&16 !=0) {
+        getCursorLoc(x, y, z, flags);
+        if (x!=x2 || y!=y2) {
+            x2c = floor(x/(w/xn));
+            y2c = floor(y/(h/yn));
+            makeRectangle(xc*(w/xn),yc*(h/yn),(w/xn)*(x2c-xc+1),(h/yn)*(y2c-yc+1));
+            x2=x; y2=y;
+            wait(10);
+        }
+    }
+    setPasteMode("add");
+}
+
+macro "Extract Selected Panels"{
+    t=getTitle;
+    xn = info("xMontage");
+    yn = info("yMontage");
+    pw = getWidth/xn;
+    ph = getHeight/yn;
+    run("Duplicate...", "title=[Extract of "+t+"]");
+    setMetadata("Info","xMontage="+getWidth/pw+"\nyMontage="+getHeight/ph+"\n");
+}
+
+macro "Montage Shuffler Tool - C888R0077R9977C44fR0977R9077"{
+    id=getImageID;
+    run("Select None");
+    setPasteMode("copy");
+    w = getWidth;
+    h = getHeight;
+    getCursorLoc(x, y, z, flags);
+    xn = info("xMontage");
+    yn = info("yMontage");
+    if ((xn==0)||(yn==0))
+       exit;
+    xstart = x; ystart = y;
+    x2=x; y2=y;
+    while (flags&16 !=0) {
+        getCursorLoc(x, y, z, flags);
+        if (x!=x2 || y!=y2) spring(xstart, ystart, x, y);
+        x2=x; y2=y;
+        wait(10);
+    }
+    if (x!=xstart || y!=ystart) {
+        xext=0;
+        yext=0;
+        if (x>w) xext=1;
+        if (y>h) yext=1;
+        if ((xext>0)||(yext>0)) {
+            run("Canvas Size...", "width="+w+xext*(w/xn)+" height="+h+yext*(h/yn)+" position=Top-Left zero");
+            setMetadata("Info","xMontage="+(parseInt(xn)+parseInt(xext))+"\nyMontage="+(parseInt(yn)+parseInt(yext))+"\n");
+            exit;
+        }
+        sc = floor(xstart/(w/xn));
+        tc = floor(x/(w/xn));
+        sr = floor(ystart/(h/yn));
+        tr = floor(y/(h/yn));
+        swap(sc,sr,tc,tr);
+
+    }
+}
+
+macro "Annotation Tool - C700 T2709A T8709B T1f09C T8f09D" {
+    xn = info("xMontage");
+    yn = info("yMontage");
+    
+    getCursorLoc(x, y, z, flags);
+    iw = getWidth/xn;
+    ih = getHeight/yn;
+    
+    co = floor(x/iw);
+    li = floor(y/ih);
+
+    fontsize = ih/10;
+    if (fontsize<12) fontsize=12;
+    marque = substring(str,n,n+1);
+    if (lcas==1) marque= toLowerCase(marque);
+    opt="";
+
+    if (pos == "Clicked quadrant") {
+    xoffset=0.05; yoffset=0.05; 
+    if (x>((co+0.5)*iw)) xoffset=0.90; 
+    if (y<((li+0.5)*ih)) yoffset=0.85; 
+    }
+
+    if (antialiasedLabels==true) opt=opt+"antialiased";
+    setFont("SanSerif",fontsize, opt);
+    fg = getValue("rgb.foreground");
+    makeText(marque ,co*iw+xoffset*iw,(li+1)*ih-yoffset*ih-getValue("font.height"));
+    Roi.setStrokeColor(fg&0xff0000>>16,fg&0x00ff00>>8,fg&0x0000ff);
+    Overlay.addSelection("",0);
+    run("Select None");
+    n++; if (n>lengthOf(str)) n=0;
+}
+
+macro "Annotation Tool Options" {
+    if (nImages>0) setupUndo;
+    Dialog.create("Annotation - Options");
+    Dialog.addString("Labels",str);
+    Dialog.addCheckbox("Lowercase labels",lcas);
+    Dialog.addCheckbox("Reset label counter",true);
+    Dialog.addCheckbox("Antialiased",true);
+    Dialog.addChoice("Position",newArray("Clicked quadrant","Lower left","Lower right","Upper right","Upper left"),pos);
+    Dialog.show;
+    str  = Dialog.getString;
+    lcas = Dialog.getCheckbox;
+    resetCounter = Dialog.getCheckbox;
+    if (resetCounter==true)	n=0;
+    antialiasedLabels = Dialog.getCheckbox;
+    pos=Dialog.getChoice();
+    if (pos=="Lower left") {xoffset=0.05; yoffset=0.05;}
+    else if (pos=="Lower right") {xoffset=0.90; yoffset=0.05;}
+    else if (pos=="Upper left") {xoffset=0.05; yoffset=0.85;}
+    else if (pos=="Upper right") {xoffset=0.90; yoffset=0.85;}
+
+}
+
+macro "Montage Sync Tool - C800L07f7L707fG" {
+    w=getWidth;
+    h= getHeight;
+    getCursorLoc(x,y,z,flags);
+    xn = info("xMontage");
+    yn = info("yMontage");
+    if ((xn==0)||(yn==0)) {
+       run("Set Montage Layout");
+       exit;
+    }
+    xc = floor(x/(w/xn));
+    yc = floor(y/(h/yn));
+    x0 = x-xc*w/xn;
+    y0 = y-yc*h/yn;
+    np = 1*xn*yn;
+    xp =newArray(np);
+    yp =newArray(np);
+    for (i=0;i<xn;i++) {
+        for (j=0;j<yn;j++) {
+            xp[j*xn+i] = x0+i*(w/xn);
+            yp[j*xn+i] = y0+j*(h/yn);
+        }
+    }
+    makeSelection("point yellow large hybred",xp,yp);
+}
+
+macro "Magic Montage Menu Tool - C800G027ff200" {
+   runCommand();
+}
+
+function runCommand() {
+   cmd = getArgument();
+    if (cmd=="Scale Bar...")
+       doCommand(cmd);
+    else
+       run(getArgument());
+}
+
+macro "Magic Montage Help Action Tool - C911T4e18?"{
+     run("URL...", "url=http://wsr.imagej.net/macros/toolsets/MagicMontage.pdf");
+      //run("URL...", "url=http://imagejdocu.tudor.lu/doku.php?id=howto:working:work_with_magic_montage");     
+}
+
+// Returns numeric value associated with 'key' or 0 if not found. 
+function info(key) {
+   value = getInfo(key);
+   if (value=="")
+      return 0;
+   else
+      return parseInt(value);
+}
+
+function swap(a,b,c,d) {
+    setupUndo;
+    setBatchMode(true);
+    makeRectangle(a*(w/xn),b*(h/yn),(w/xn),(h/yn));
+    run("Duplicate...", "title=tmp");
+    selectImage(id);
+    makeRectangle(c*(w/xn),d*(h/yn),(w/xn),(h/yn));
+    run("Copy");
+    makeRectangle(a*(w/xn),b*(h/yn),(w/xn),(h/yn));
+    run("Paste");
+    selectWindow("tmp");
+    run("Select All");
+    run("Copy");
+    selectImage(id);
+    makeRectangle(c*(w/xn),d*(h/yn),(w/xn),(h/yn));
+    run("Paste");
+    run("Select None");
+    setBatchMode(false);
+}
+
+function spring(x0,y0,x1,y1) {
+    d = sqrt((y1-y0)*(y1-y0)+(x1-x0)*(x1-x0));
+    step=3;
+    r=15;
+    xa = newArray(floor(d/step));
+    ya = newArray(xa.length);
+    for (i=0;i<xa.length;i++) {
+        j=i*step;
+        xa[i]=x0+j*(x1-x0)/d+sin(j/7)*r;
+        ya[i]=y0+j*(y1-y0)/d+cos(j/7)*r;
+    }
+    if (xa.length>1) {
+        xa[0]=x0;
+        ya[0]=y0;
+        xa[xa.length-1]=x1;
+        ya[ya.length-1]=y1;
+    }
+    makeSelection("freeline",xa,ya);
+}
+
+macro "Add Panel to Manager [F1]" {
+    roiManager("Add");
+    setOption("Show All",true);
+}
+
+macro "Montage to Stack" {
+   columns = info("xMontage");
+   rows = info("yMontage");
+   if (rows==0 || columns==0) {
+       run("Set Montage Layout");
+       columns = info("xMontage");
+       rows = info("yMontage");
+    }
+   run("Montage to Stack...", "columns=&columns rows=&rows");
+}
+
+macro "Selected panels to stack [F2]" {
+    id=getImageID;
+    t=getTitle;
+    selectImage(id);
+    roiManager("select",0);
+    getSelectionBounds(x,y,sw,sh);
+    setBatchMode(true);
+    newImage("Extracted Panels of "+t, "RGB", sw,sh,roiManager("count"));
+    id2=getImageID;
+    setPasteMode("copy");
+    for (i=0;i<roiManager("count");i++) {
+        selectImage(id);
+        roiManager("select",i);
+        run("Copy");
+        selectImage(id2);
+        setSlice(i+1);
+        run("Paste");
+    }
+    setBatchMode(false);
+}
+
+macro "Crop Montage [F3]" {
+    setBatchMode(true);
+    setPasteMode("copy");
+    w=getWidth;
+    h= getHeight;
+    b=bitDepth;
+    getSelectionBounds(x,y,sw,sh);
+    t=getTitle;
+    id=getImageID;
+    getVoxelSize(xp,yp,zp,unit);
+    xn = info("xMontage");
+    yn = info("yMontage");
+    xc = floor(x/(w/xn));
+    yc = floor(y/(h/yn));
+    xpa = x-xc*(w/xn);
+    ypa= y-yc*(h/yn);
+    newImage("Crop of "+t,b+"RGB",sw,sh,(xn)*(yn));
+    id2=getImageID;
+    for (j=0;j<yn;j++) {
+        for (i=0;i<xn;i++) {
+            selectImage(id);
+            makeRectangle(i*(w/xn)+xpa,j*(h/yn)+ypa,sw,sh);
+            run("Copy");
+            selectImage(id2);
+            setSlice(j*(xn)+i+1);
+            run("Paste");
+        }
+    }
+    setVoxelSize(xp,yp,zp,unit);
+    setBatchMode(false);
+    setSlice(nSlices);
+    setSlice(1);
+}
+
+macro "Fit Clipboard content into panel [F4]" {
+    getSelectionBounds(x,y,sw,sh);
+    id=getImageID;
+    setBatchMode(true);
+    ffp=sw/sh;
+    run("Internal Clipboard");
+    run("RGB Color");
+    ffc=getWidth/getHeight;
+    if (ffc>ffp) {
+        run("Size...", "width="+sw+" height="+sw/ffc+" constrain interpolate");
+        run("Canvas Size...", "width="+sw+" height="+sh+" position=Center zero");
+    } else {
+        run("Size...", "width="+sh*ffc+" height="+sh+" constrain interpolate");
+        run("Canvas Size...", "width="+sw+" height="+sh+" position=Center zero");
+    }
+    run("Copy");
+    close;
+    selectImage(id);
+    setBatchMode(false);
+    setPasteMode("Copy");
+    run("Paste");
+}
+
+macro "Fill Panel with Clipboard content [F5]" {
+    getSelectionBounds(x,y,sw,sh);
+    id=getImageID;
+    setBatchMode(true);
+    ffp=sw/sh;
+    run("Internal Clipboard");
+    run("RGB Color");
+    ffc=getWidth/getHeight;
+    if (ffc>ffp) {
+        run("Size...", "width="+sw*ffc+" height="+sh+" constrain interpolate");
+        run("Canvas Size...", "width="+sw+" height="+sh+" position=Center zero");
+    } else {
+        run("Size...", "width="+sw+" height="+sh/ffc+" constrain interpolate");
+        run("Canvas Size...", "width="+sw+" height="+sh+" position=Center zero");
+    }
+    run("Copy");
+    close;
+    selectImage(id);
+    setBatchMode(false);
+    setPasteMode("Copy");
+    run("Paste");
+    
+}
+
+macro "Set Montage Layout" {
+    columns = info("xMontage");
+    rows = info("yMontage");
+    if (columns>0 && rows>0)
+       exit("Layout ("+columns+"x"+rows+") is already set");
+    Dialog.create("Set Montage Layout");
+    Dialog.addNumber("Width:", 2);
+    Dialog.addNumber("Height:", 2);
+    Dialog.show;
+    mw = Dialog.getNumber;
+    mh = Dialog.getNumber;
+    setMetadata("Info","xMontage="+mw+"\nyMontage="+mh+"\n");
+}
+
+macro "Change Montage Layout" {
+   columns = info("xMontage");
+   rows = info("yMontage");
+   if (rows==0 || columns==0) {
+       run("Set Montage Layout");
+       columns = info("xMontage");
+       rows = info("yMontage");
+    }
+    id1 = getImageID;
+    title = getTitle;
+    getVoxelSize(xp,yp,zp,unit);
+    Dialog.create("Change Montage Layout");
+    Dialog.addNumber("Columns:", columns);
+    Dialog.addNumber("Rows:", rows);
+    Dialog.show;
+    columns2 = Dialog.getNumber;
+    rows2 = Dialog.getNumber;
+    run("Montage to Stack...", "columns=&columns rows=&rows");
+    id2 = getImageID;
+    run("Make Montage...", "columns=&columns2 rows=&rows2 scale=1.0");
+    rename(title);
+    setVoxelSize(xp,yp,zp,unit);
+    selectImage(id1); close;
+    selectImage(id2); close;
+}
+
diff --git a/macros/MeasureStack.txt b/macros/MeasureStack.txt
new file mode 100644
index 0000000..78fcf5d
--- /dev/null
+++ b/macros/MeasureStack.txt
@@ -0,0 +1,121 @@
+// This macro runs "Measure" on a all the slices in a stack. With a
+// hyperstack, it runs "Measure" in a user-selected (c,t,z) order.
+// Unchecking "Channels", "Slices" or "Frames" will select the 
+// current channel, slice or frame while running "Measure".
+//
+// Ved P. Sharma, March 21, 2012
+// Albert Einstein College of Medicine, New York
+
+    saveSettings;
+    setOption("Stack position", true);
+    if (!Stack.isHyperstack) {
+        getVoxelSize(width, height, depth, unit);
+        for (n=1; n<=nSlices; n++) {
+          setSlice(n);
+          run("Measure");
+       }
+       if (unit!="pixels") {
+           depths = newArray(Table.size);
+           for (i=0; i<Table.size; i++)
+               depths[i] = i*depth;
+           Table.setColumn(unit, depths);
+           Table.update;
+       }
+       restoreSettings;
+       exit;
+    }
+    Stack.getDimensions(w, h, channels, slices, frames);
+    Stack.getPosition(ch, sl, fr);
+    Dialog.create("Measure Hyperstack");
+    Dialog.addCheckbox("Channels ("+channels+")", true);
+    Dialog.addCheckbox("Slices ("+slices+")", true);
+    Dialog.addCheckbox("Frames ("+frames+")", true);
+    choices = newArray("czt(default)", "ctz", "zct", "ztc", "tcz", "tzc");
+    Dialog.addChoice("Order:", choices, choices[0]);
+    Dialog.show();
+    state1 = Dialog.getCheckbox();
+    state2 = Dialog.getCheckbox();
+    state3 = Dialog.getCheckbox();
+    order = Dialog.getChoice();
+
+    if(state1) {startCh = 1; endCh = channels;}
+    else {startCh = ch; endCh = ch;}
+    if(state2) {startSl = 1; endSl = slices;}
+    else {startSl = sl; endSl = sl;}
+    if(state3) {startFr = 1; endFr = frames;}
+    else {startFr = fr; endFr = fr;}
+
+    if(order == "czt(default)") {
+        for (u=startFr; u<=endFr; u++) {
+            Stack.setFrame(u);
+            for (v=startSl; v<=endSl; v++) {
+                Stack.setSlice(v);
+                for (w=startCh; w<=endCh; w++) {
+                    Stack.setChannel(w);
+                    run("Measure");
+                }
+            }
+        }
+    }
+    if(order == "ctz") {
+        for (u=startSl; u<=endSl; u++) {
+            Stack.setSlice(u);
+            for (v=startFr; v<=endFr; v++) {
+                Stack.setFrame(v);
+                for (w=startCh; w<=endCh; w++) {
+                    Stack.setChannel(w);
+                    run("Measure");
+                }
+            }
+        }
+    }
+    if(order == "zct") {
+        for (u=startFr; u<=endFr; u++) {
+            Stack.setFrame(u);
+            for (v=startCh; v<=endCh; v++) {
+                Stack.setChannel(v);
+                for (w=startSl; w<=endSl; w++) {
+                    Stack.setSlice(w);
+                    run("Measure");
+                }
+            }
+        }
+    }
+    if(order == "ztc") {
+        for (u=startCh; u<=endCh; u++) {
+            Stack.setChannel(u);
+            for (v=startFr; v<=endFr; v++) {
+                Stack.setFrame(v);
+                for (w=startSl; w<=endSl; w++) {
+                    Stack.setSlice(w);
+                    run("Measure");
+                }
+            }
+        }
+    }
+    if(order == "tcz") {
+        for (u=startSl; u<=endSl; u++) {
+            Stack.setSlice(u);
+            for (v=startCh; v<=endCh; v++) {
+                Stack.setChannel(v);
+                for (w=startFr; w<=endFr; w++) {
+                    Stack.setFrame(w);
+                    run("Measure");
+                }
+            }
+        }
+    }
+    if(order == "tzc") {
+        for (u=startCh; u<=endCh; u++) {
+            Stack.setChannel(u);
+            for (v=startSl; v<=endSl; v++) {
+                Stack.setSlice(v);
+                for (w=startFr; w<=endFr; w++) {
+                    Stack.setFrame(w);
+                    run("Measure");
+                }
+            }
+        }
+    }
+    Stack.setPosition(ch, sl, fr);
+    restoreSettings;
diff --git a/macros/MoveSelection.txt b/macros/MoveSelection.txt
new file mode 100644
index 0000000..f7b4462
--- /dev/null
+++ b/macros/MoveSelection.txt
@@ -0,0 +1,40 @@
+  // Moves the selection left and down a specified distance in pixels.
+
+  xy = split(getArgument());
+  if (lengthOf(xy)!=2) {
+      dx = 10;
+      dy = 10;
+  } else {
+      dx = parseFloat(xy[0]);
+      if (isNaN(dx)) dx = 10;
+      dy = parseFloat(xy[1]);
+      if (isNaN(dy)) dy = 10;
+  }
+  getPixelSize(unit, pixelWidth, pixelHeight);
+  if (unit=="pixel") unit = "pixels";
+  dxc = dx*pixelWidth;
+  dyc = dy*pixelHeight;
+  Dialog.create("Move");
+  Dialog.addNumber("Delta_X ("+unit+"):", dxc);
+  Dialog.addNumber("Delta_Y ("+unit+"):", dyc);
+  Dialog.show();
+  dx = Dialog.getNumber()/pixelWidth;
+  dy = Dialog.getNumber()/pixelHeight;
+  moveSelection(dx, dy);
+  return toString(dx)+" "+toString(dy);
+
+  function moveSelection(dx, dy) {
+      getBoundingRect(x, y, width, height);
+      if (selectionType==0)
+          makeRectangle(x+dx, y+dy, width, height);
+      else if (selectionType==1)
+          makeOval(x+dx, y+dy, width, height);
+      else {
+          getSelectionCoordinates(xCoordinates, yCoordinates);
+          for (i=0; i<xCoordinates.length; i++) {
+              xCoordinates[i] += dx;
+              yCoordinates[i] += dy;
+          }
+          makeSelection(selectionType, xCoordinates, yCoordinates);          
+      }
+  }
diff --git a/macros/My_Plugin.src b/macros/My_Plugin.src
new file mode 100644
index 0000000..b5ddb62
--- /dev/null
+++ b/macros/My_Plugin.src
@@ -0,0 +1,17 @@
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.plugin.*;
+import ij.plugin.frame.*;
+
+public class My_Plugin implements PlugIn {
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		IJ.run(imp, "Invert", "");
+		IJ.wait(1000);
+		IJ.run(imp, "Invert", "");
+	}
+
+}
diff --git a/macros/Overlay Editing Tools.txt b/macros/Overlay Editing Tools.txt
new file mode 100644
index 0000000..fa15d5f
--- /dev/null
+++ b/macros/Overlay Editing Tools.txt	
@@ -0,0 +1,281 @@
+// hit = 0x01<<i (left, middle, right, top, center, bottom)
+// r remarkable points, 6 for image + 6 per ROIs, same order as hit
+// dragged roi snaps to guides.
+
+macro "Move Overlay Tool - C037O33aaL03f3L303f" { 
+  getCursorLoc( x, y, z, flags ); 
+  selectNone( ); 
+  r = newArray( 0, getWidth / 2, getWidth, 0, getHeight / 2, getHeight ); 
+  n = Overlay.size; 
+  if( n < 1 ) exit( "Overlay required" ); 
+  id = Overlay.indexAt( x, y ); 
+  for( i = 0; i < n; i ++ ) { 
+    if( i != id ) { 
+      Overlay.getBounds( i, bx, by, bw, bh ); 
+      er = newArray( bx, bx + bw / 2, bx + bw, by, by + bh / 2, by + bh ); 
+      r = Array.concat( r, er ); 
+    } 
+  } 
+  while( flags & 16 > 0 ) { 
+    getCursorLoc( x, y, z, flags ); 
+    Overlay.getBounds( id, bx, by, bw, bh ); 
+    if( id < 0 ) break; 
+    Overlay.moveSelection( id, x - bw / 2, y - bh / 2 ); 
+    Overlay.getBounds( id, bx, by, bw, bh ); 
+    d = newArray( bx, bx + bw / 2, bx + bw, by, by + bw / 2, by + bh ); 
+    while( Overlay.size > n ) Overlay.removeSelection( Overlay.size - 1 ); 
+    hit = 0x00; 
+    for( i = 0; i < r.length; i = i + 6 ) { // each element
+      for( p = 0; p < 6; p ++ ) // each remarkable point
+      if( abs( d [ p ]- r [ i + p ] )< 5 ) { 
+        hit = hit |( 0x01 << p ); // allows for multiple hits
+      } 
+      if( hit > 0 ) { 
+        ihit = i; 
+        break; 
+      } 
+    } 
+    for( i = 0; i < 6; i ++ ) { 
+      if( hit &( 1 << i )> 0 ) { 
+        if( i < 3 ) { 
+          Overlay.getBounds( id, bx, by, bw, bh ); 
+          Overlay.drawLine( r [ ihit + i ], 0, r [ ihit + i ], getHeight ); 
+          if( i == 0 ) Overlay.moveSelection( id, r [ ihit + i ], by ); 
+          if( i == 1 ) Overlay.moveSelection( id, r [ ihit + i ]- bw / 2, by ); 
+          if( i == 2 ) Overlay.moveSelection( id, r [ ihit + i ]- bw, by ); 
+        } 
+        if( i >= 3 ) { 
+          Overlay.getBounds( id, bx, by, bw, bh ); 
+          Overlay.drawLine( 0, r [ ihit + i ], getWidth, r [ ihit + i ] ); 
+          if( i == 3 ) Overlay.moveSelection( id, bx, r [ ihit + i ] ); 
+          if( i == 4 ) Overlay.moveSelection( id, bx, r [ ihit + i ]- bh / 2 ); 
+          if( i == 5 ) Overlay.moveSelection( id, bx, r [ ihit + i ]- bh ); 
+        } 
+      } 
+    } 
+    Overlay.show; 
+    wait( 20 ); 
+  } 
+  while( Overlay.size > n ) Overlay.removeSelection( Overlay.size - 1 ); 
+} 
+// a tool to select one or more overlay elements
+// selection is stored in preferences
+// click outside a roi to deselect all
+// a menu tool to align selected overlay elements
+
+macro "Select Overlay Tool - Ce00R22fbC0e0o0044C037L77ffL777aL77a7" { 
+  getCursorLoc( x, y, z, flags ); 
+  Overlay.removeRois( 'ToolSelectedOverlayElement' ); 
+  Overlay.show; 
+  n = Overlay.size; 
+  if( n < 1 ) exit( "Overlay required" ); 
+  id = Overlay.indexAt( x, y ); 
+  if( id < 0 ) { 
+    selectNone( ); 
+    call( 'ij.Prefs.set', 'overlaytoolset.selected', '' ); 
+    exit( ); 
+  } 
+  if( flags & 1 > 0 ) { 
+    Overlay.activateSelection( id ); 
+    if( Roi.getName != 'ToolSelectedOverlayElement' ) 
+      selectElement( id, true ); 
+  }  else { 
+    Overlay.activateSelection( id ); 
+    if( Roi.getName != 'ToolSelectedOverlayElement' ) 
+      selectElement( id, false ); 
+  } 
+  run( "Select None" ); 
+  highlightSelectedROIs( ); 
+} 
+function highlightSelectedROIs( ) { 
+  Overlay.removeRois( 'ToolSelectedOverlayElement' ); 
+  selected = getSelectedElements( ); 
+  s = split( selected, ',' ); 
+  //print( selected ); 
+  for( i = 0; i < s.length; i ++ ) { 
+    id = s [ i ]; 
+    Overlay.getBounds( id, bx, by, bw, bh ); 
+    makeRectangle( bx, by, bw, bh ); 
+    Roi.setName( 'ToolSelectedOverlayElement' ); 
+    Overlay.addSelection( '#90ff0000', 3 ); 
+  } 
+  run( "Select None" ); 
+  Overlay.show; 
+} 
+function selectNone( ) { 
+  Overlay.removeRois( 'ToolSelectedOverlayElement' ); 
+  Overlay.show; 
+  //call( 'ij.Prefs.set', 'overlaytoolset.selected', '' ); 
+} 
+function selectElement( id, add ) { 
+  if( add == true ) { 
+    selected = getSelectedElements( ); 
+    s = split( selected, ',' ); 
+    isSelected = false; 
+    for( i = 0; i < s.length; i ++ ) { 
+      if( 1 * s [ i ]== id ) isSelected = true; 
+    } 
+    if( ! isSelected ) { 
+      call( 'ij.Prefs.set', 'overlaytoolset.selected', selected + ',' + id  ); 
+      selected = getSelectedElements( ); 
+    } else { 
+      unselectElement( id ); 
+    } 
+  } else { 
+    call( 'ij.Prefs.set', 'overlaytoolset.selected',  id  ); 
+  } 
+  highlightSelectedROIs( ); 
+} 
+function unselectElement( id ) { 
+  selected = getSelectedElements( ); 
+  s = split( selected, ',' ); 
+  selected = ''; 
+  for( i = 0; i < s.length; i ++ ) { 
+    if( s [ i ]!= id ) selected = selected +  s [ i ]+ ','; 
+  } 
+  call( 'ij.Prefs.set', 'overlaytoolset.selected', selected ); 
+  selected = getSelectedElements( ); 
+  highlightSelectedROIs( ); 
+  run( "Select None" ); 
+} 
+function getSelectedElements( ) { 
+  selected = call( 'ij.Prefs.get', 'overlaytoolset.selected', '' ); 
+  while( selected.endsWith( "," ) ) selected = substring( selected, 0, lengthOf( selected )- 1 ); 
+  while( selected.startsWith( "," ) ) selected = substring( selected, 1, lengthOf( selected ) ); 
+  return selected; 
+} 
+var dCmds = newMenu( "Align Overlay Menu Tool", 
+  newArray( "Top", "Middle", "Bottom", "-", "Left", "Center", "Right" ) ); 
+// a menu tool to align selected ROIs 
+macro "Align Overlay Menu Tool - C037L00f0R2244R8248" { 
+  cmd = getArgument( ); 
+  if( cmd == "Top" ) { 
+    s = getSelectedElements( ); 
+    s = split( s, ',' ); 
+    if( s.length < 1 ) exit( ); 
+    tops = newArray( s.length ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      tops [ i ]= y; 
+    } 
+    //Array.print( tops ); 
+    Array.getStatistics( tops, min, max, mean, stdDev ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      Overlay.moveSelection( s [ i ], x, min ); 
+    } 
+    Overlay.show( ); 
+  } else if( cmd == "Bottom" ) { 
+    s = getSelectedElements( ); 
+    s = split( s, ',' ); 
+    if( s.length < 1 ) exit( ); 
+    tops = newArray( s.length ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      tops [ i ]= y + h; 
+    } 
+    Array.getStatistics( tops, min, max, mean, stdDev ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      Overlay.moveSelection( s [ i ], x, max - h ); 
+    } 
+    selectNone( ); 
+  } else if( cmd == "Left" ) { 
+    s = getSelectedElements( ); 
+    s = split( s, ',' ); 
+    if( s.length < 1 ) exit( ); 
+    tops = newArray( s.length ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      tops [ i ]= x; 
+    } 
+    Array.getStatistics( tops, min, max, mean, stdDev ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      Overlay.moveSelection( s [ i ], min, y ); 
+    } 
+    selectNone( ); 
+  } else if( cmd == "Right" ) { 
+    s = getSelectedElements( ); 
+    s = split( s, ',' ); 
+    if( s.length < 1 ) exit( ); 
+    tops = newArray( s.length ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      tops [ i ]= x + w; 
+    } 
+    Array.getStatistics( tops, min, max, mean, stdDev ); 
+    for( i = 0; i < tops.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      Overlay.moveSelection( s [ i ], max - w, y ); 
+    } 
+    selectNone( ); 
+  } else if( cmd == "Middle" ) { 
+    s = getSelectedElements( ); 
+    s = split( s, ',' ); 
+    if( s.length < 1 ) exit( ); 
+    Overlay.getBounds( s [ 0 ], x, y, w, h ); 
+    middle = y + h / 2; 
+    for( i = 0; i < s.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      Overlay.moveSelection( s [ i ], x, middle - h / 2 ); 
+    } 
+    selectNone( ); 
+  } else if( cmd == "Center" ) { 
+    s = getSelectedElements( ); 
+    s = split( s, ',' ); 
+    if( s.length < 1 ) exit( ); 
+    Overlay.getBounds( s [ 0 ], x, y, w, h ); 
+    center = x + w / 2; 
+    for( i = 0; i < s.length; i ++ ) { 
+      Overlay.getBounds( s [ i ], x, y, w, h ); 
+      Overlay.moveSelection( s [ i ], center - w / 2, y ); 
+    } 
+    selectNone( ); 
+  } 
+  highlightSelectedROIs( ); 
+} 
+// Click to delete Overlay element
+// A confirm dialog is shown
+// you can choose not to show it.
+macro "Delete Overlay Tool - C037R00ddB58Cd00L0088L0880" { 
+  getCursorLoc( x, y, z, flags ); 
+  selectNone( ); 
+  call( 'ij.Prefs.set', 'overlaytoolset.selected', '' ); 
+  id = Overlay.indexAt( x, y ); 
+  if( id != - 1 ) { 
+    showWarning = call( "ij.Prefs.get", "overlaytoolset.deletewarning", true ); 
+    mustDelete = true; 
+    if( showWarning == true ) { 
+      Dialog.create( "Delete ROI tool options" ); 
+      Dialog.addCheckbox( "Delete this ROI", true ); 
+      Dialog.addCheckbox( "Show this dialog", showWarning ); 
+      Dialog.show( );  
+      mustDelete = Dialog.getCheckbox( ); 
+      showWarning = Dialog.getCheckbox( ); 
+      call( "ij.Prefs.set", "overlaytoolset.deletewarning", showWarning ); 
+    } 
+    if( mustDelete ) Overlay.removeSelection( id ); 
+  } 
+} 
+macro "Overlay Toolset Help Action Tool - C037T3f18?" { 
+  html = "<html>" + 
+  "Toolset Description<br>" + 
+  "<br><p>* Move overlay tool" + 
+  "<br>Click and drag an overlay element;" + 
+  "<br>It snaps to alignment guides to other elements.</p>" + 
+  "<br><p>* Overlay select tool" + 
+  "<br>Click an overlay element to select it." + 
+  "<br>Shift-click to add elements to the selection." + 
+  "<br>Shift-click a selected element to deselect it.</p>" + 
+  "<br><p>* Overlay align tool menu" + 
+  "<br>Use this menu to align selected elements</p>" + 
+  "<br><p>* Overlay delete tool" + 
+  "<br>Click to remove an overlay element</p>" + 
+  "<br><p>* Overlay toolset help action tool" + 
+  "<br>This dialog. You can leave it open to try toolset functions.</p>" + 
+  "</html>"; 
+  Dialog.createNonBlocking( "Overlay Toolset Help" ); 
+  Dialog.addMessage( html ); 
+  Dialog.show( ); 
+} 
diff --git a/macros/Plugin_Frame.src b/macros/Plugin_Frame.src
new file mode 100644
index 0000000..f31fc1a
--- /dev/null
+++ b/macros/Plugin_Frame.src
@@ -0,0 +1,18 @@
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.plugin.frame.*;
+
+public class Plugin_Frame extends PlugInFrame {
+
+	public Plugin_Frame() {
+		super("Plugin_Frame");
+		TextArea ta = new TextArea(15, 50);
+		add(ta);
+		pack();
+		GUI.center(this);
+		show();
+	}
+
+}
diff --git a/macros/Prototype_Tool.src b/macros/Prototype_Tool.src
new file mode 100644
index 0000000..7cf2850
--- /dev/null
+++ b/macros/Prototype_Tool.src
@@ -0,0 +1,24 @@
+// Prototype plugin tool. There are more plugin tools at
+// http://imagej.nih.gov/ij/plugins/index.html#tools
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.plugin.tool.PlugInTool;
+import java.awt.event.*;
+
+public class Prototype_Tool extends PlugInTool {
+
+	public void mousePressed(ImagePlus imp, MouseEvent e) {
+		IJ.log("mouse pressed: "+e);
+	}
+
+	public void mouseDragged(ImagePlus imp, MouseEvent e) {
+		IJ.log("mouse dragged: "+e);
+	}
+
+	public void showOptionsDialog() {
+		IJ.log("icon double-clicked");
+	}
+
+}
diff --git a/macros/RoiMenuTool.txt b/macros/RoiMenuTool.txt
new file mode 100644
index 0000000..2b3699f
--- /dev/null
+++ b/macros/RoiMenuTool.txt
@@ -0,0 +1,88 @@
+  var rCmds = newMenu("ROI Menu Tool", 
+      newArray("Set Default Group...", "Set Default Stroke Width...", "-", 
+      "Set Group of Selected ROIs", "Select Group", "-", "Properties..." , "Install Keypad Shortcuts") );
+
+  macro "ROI Menu Tool - C037T0d15RT8c12oTfc12i" {
+      cmd = getArgument();
+      if (cmd=="Set Default Group...")
+          setDefaultRoiGroup();
+      else if (cmd=="Set Default Stroke Width...")
+          setDefaultRoiStrokeWidth();
+      else if (cmd=="Set Group of Selected ROIs")
+          setRoiGroup();       
+       else if (cmd=="Select Group")
+          selectRoiGroup();
+      else if (cmd=="Properties...")
+          properties();
+      else if (cmd=="Install Keypad Shortcuts")
+          call("ij.plugin.MacroInstaller.installFromJar", "/macros/RoiMenuTool.txt+");
+  }
+
+  // Numeric keypad shortcuts used to set the default ROI group
+ macro "Keypad shortcuts for setting default group" { }
+  macro "Group 0 (none) [n0]" { npad(0); }
+  macro "Group 1 [n1]" { npad(1); }
+  macro "Group 2 [n2]" { npad(2); }
+  macro "Group 3 [n3]" { npad(3); }
+  macro "Group 4 [n4]" { npad(4); }
+  macro "Group 5 [n5]" { npad(5); }
+  macro "Group 6 [n6]" { npad(6); }
+  macro "Group 7 [n7]" { npad(7); }
+  macro "Group 8 [n8]" { npad(8); }
+  macro "Group 9 [n9]" { npad(9); }
+
+  function npad(digit) {
+      Roi.setDefaultGroup(digit);
+  }
+
+  function properties() {
+     if (selectionType==-1) {
+        showMessage("Selection required");
+        exit;
+     }
+     run("Properties... ");
+  }
+
+  function setDefaultRoiGroup() {
+     group = Roi.getDefaultGroup;
+     Dialog.create("Set Default Group");
+     Dialog.addNumber("Default group", group);
+     Dialog.show;
+     group = Dialog.getNumber();
+     Roi.setDefaultGroup(group);
+     call("ij.plugin.frame.Recorder.recordString", "Roi.setDefaultGroup("+group+");\n");
+  }
+
+  function setDefaultRoiStrokeWidth() {
+     width = Roi.getDefaultStrokeWidth;
+     Dialog.create("Set Default Stroke Width");
+     Dialog.addNumber("Default stroke width", width);
+     Dialog.show;
+     width = Dialog.getNumber();
+     Roi.setDefaultStrokeWidth(width);
+     call("ij.plugin.frame.Recorder.recordString", "Roi.setDefaultStrokeWidth("+width+");\n");
+  }
+
+  function setRoiGroup() {
+     Dialog.create("Set Group");
+     Dialog.addString("Group", "1");
+     Dialog.show;
+     group = Dialog.getString();
+     RoiManager.setGroup(group);
+     if (call("ij.plugin.frame.Recorder.scriptMode")=="true")
+        call("ij.plugin.frame.Recorder.recordString", "rm.setGroup("+group+");\n");
+     else
+        call("ij.plugin.frame.Recorder.recordString", "RoiManager.setGroup("+group+");\n");
+ }
+
+  function selectRoiGroup() {
+     Dialog.create("Select group");
+     Dialog.addString("Group", "0");
+     Dialog.show;
+     group = Dialog.getString();
+     RoiManager.selectGroup(group);
+     if (call("ij.plugin.frame.Recorder.scriptMode")=="true")
+        call("ij.plugin.frame.Recorder.recordString", "rm.selectGroup("+group+");\n");
+     else
+        call("ij.plugin.frame.Recorder.recordString", "RoiManager.selectGroup("+group+");\n");
+  }
diff --git a/macros/Search.txt b/macros/Search.txt
new file mode 100644
index 0000000..2cf005b
--- /dev/null
+++ b/macros/Search.txt
@@ -0,0 +1,139 @@
+// "Search"
+// This macro searches for text in files contained in a directory.
+// TF, 2011.02 Added support for scripts; Recordable.
+
+  str = "";
+  contents = true;
+  ignore = false;
+  search = "Macros";
+  firstLine = true;
+  arg = getArgument;
+  if (arg!="") {
+      args = split(arg, "|");
+      if (args.length==4) {
+          str = args[0];
+          contents = parseInt(args[1]);
+          ignore = parseInt(args[2]);
+          search = args[3];
+       }
+  }
+  extensions = newArray(".java", ".txt", ".ijm", ".js", ".py", ".rb", ".clj", ".bsh", ".html");
+  IJdir = getDirectory("imagej");
+
+  Dialog.create("Search");
+  Dialog.addString("_", str, 20);
+  items = newArray("Macros", "Scripts", "Java", "ImageJ folder", "Choose...");
+  Dialog.setInsets(2,20,0);
+  Dialog.addRadioButtonGroup("Search:", items, 5, 1, search);
+  Dialog.setInsets(0, 20, 0);
+  Dialog.addCheckbox("Search_contents", contents);
+  Dialog.addCheckbox("Ignore case", ignore);
+  Dialog.setInsets(10, 0, 0);
+  Dialog.addMessage("In the Log window, to open a file,\ndouble-click on its file path.");
+  Dialog.show();
+  str = Dialog.getString();
+  contents = Dialog.getCheckbox();
+  ignore = Dialog.getCheckbox();
+  search = Dialog.getRadioButton();
+  if (str=="")
+     exit("Search string is empty");
+
+  sourceExists = File.exists(IJdir+"source");
+  searchNames = false;
+  dir1=""; dir2=""; dir3="";
+  if (search=="Scripts") {
+      dir1 = getDirectory("macros");   
+      dir2 = getDirectory("plugins");     
+      dir3 = IJdir+"scripts/";
+      extensions = newArray(".js", ".py", ".rb", ".clj", ".bsh");
+  } else if (search=="Java") {
+      dir1 = getDirectory("plugins"); 
+      if (sourceExists)
+         dir2 = IJdir+"source"+"/";
+      extensions = newArray(".java");
+  } else if (search=="ImageJ folder") {
+      dir1 = getDirectory("imagej");
+      searchNames = true;
+  } else if (search=="Choose...") {
+      dir1 = getDirectory("Choose a Directory");
+      searchNames = true;
+  } else {
+      dir1 = getDirectory("macros");   
+      dir2 = getDirectory("plugins");     
+      extensions = newArray(".txt", ".ijm");
+  }
+  if (ignore)
+      str = toLowerCase(str);
+  count = 0;
+  if (dir1!="") find(dir1);
+  if (dir2!="") find(dir2);
+  if (dir3!="") find(dir3);
+  if (indexOf(str, "|")==-1)
+      return ""+str+"|"+contents+"|"+ignore+"|"+search;
+  exit; 
+
+  function find(dir) {
+      list = getFileList(dir);
+      for (i=0; i<list.length; i++) {
+          showProgress(i, list.length);
+          if (endsWith(list[i], "/"))
+              find(""+dir+list[i]);
+          else if (contents && valid(list[i])) {
+              s = File.openAsString(dir+list[i]);
+              s2 = s;
+              if (ignore)
+                  s2 = toLowerCase(s);
+              if (indexOf(s2,str)!=-1) {
+                  count++;
+                  if (firstLine)
+                      showMessageInHeader();
+                  print("");
+                  print(dir+list[i]);
+                  lines = split(s, "\n");
+                  n = 0;
+                  for (j=0; j<lines.length; j++) {
+                      line = lines[j];
+                      line2 = line;
+                      if (ignore) line2 = toLowerCase(line);
+                      if (indexOf(line2,str)!=-1 && n<8) {
+                          print((j+1)+": "+line);
+                          n++;
+                      }
+                 } // for
+              } else
+                  searchName(list[i]);
+          } else if (searchNames || valid(list[i]))
+              searchName(list[i]);
+      }
+      if (count==1)
+          showStatus("1 match");
+      else
+          showStatus(count+" matches");
+  }
+
+  function searchName(name) {
+      name2 = name;
+      if (ignore)
+          name2 = toLowerCase(name2);
+      if (indexOf(name2,str)!=-1) {
+          if (firstLine)
+              showMessageInHeader();
+          print("");
+          print(dir+name);
+          count++;
+      }
+  }
+
+  function valid(name) {
+      for (i=0; i<extensions.length; i++) {
+         if (endsWith(name, extensions[i]))
+             return true;
+      }
+      return false;
+  }
+  
+  function showMessageInHeader() {
+      print("\\Heading: Double-click on a file name to open it");
+      firstLine = false;
+  }
+
diff --git a/macros/ShowAllLuts.txt b/macros/ShowAllLuts.txt
new file mode 100644
index 0000000..3de1044
--- /dev/null
+++ b/macros/ShowAllLuts.txt
@@ -0,0 +1,37 @@
+// This macro displays, as a montage, all the LUTs in the
+// Image>Lookup Tables menu.
+
+saveSettings();
+list = getList("LUTs");
+setBatchMode(true);
+newImage("ramp", "8-bit Ramp", 256, 32, 1);
+newImage("luts", "RGB White", 256, 48, 1);
+count = 0;
+setForegroundColor(255, 255, 255);
+setBackgroundColor(255, 255, 255);
+setFont("SansSerif", 12,"antialiased");
+for (i=0; i<list.length; i++) {
+    selectWindow("ramp");
+    run(list[i]);
+    run("Select All");
+    run("Copy");
+    selectWindow("luts");
+    makeRectangle(0, 0, 256, 32);
+    run("Paste");
+    setJustification("center");
+    setColor(0, 0, 0);
+    drawString(list[i],128, 48);
+    run("Add Slice");
+    run("Select All");
+    run("Clear", "slice");
+    count++;
+}
+run("Delete Slice");
+rows = floor(count/4);
+if (rows<count/4) rows++;
+run("Canvas Size...", "width=258 height=50 position=Center");
+run("Make Montage...", "columns=4 rows="+rows
++" scale=1 first=1 last="+count+" increment=1 border=0 use");
+rename("Lookup Tables");
+setBatchMode(false);
+restoreSettings();
diff --git a/macros/SmoothWandTool.txt b/macros/SmoothWandTool.txt
new file mode 100644
index 0000000..45eefcc
--- /dev/null
+++ b/macros/SmoothWandTool.txt
@@ -0,0 +1,80 @@
+//Smooth Wand version 1d
+//N.Vischer
+//01.07.17 20:20
+
+var count, polyX, polyY
+
+getSelectionBounds(x, y, w, h);
+if (w<2 || h<2)
+    exit("Width and height must be > 1 px");
+if (selectionType != 4) 
+    exit("No traced selection found");
+getThreshold(lowThr, hiThr);
+getSelectionCoordinates(xx, yy);
+len = xx.length;
+polyX = newArray(len);
+polyY = newArray(len);
+count = 0;
+for(jj = 0; jj < len; jj++) {
+    x1 = xx[jj];
+    y1 = yy[jj];
+    x2 = xx[(jj+1)%len];
+    y2 = yy[(jj+1)%len];
+    dd = 1;
+    if (y1 == y2) {//horizontal separator
+        if (x1 > x2) dd = -1;
+        for(x = x1; x != x2; x+= dd){
+            processPixelPair(x, y1, x+dd, y1);
+        }
+    }
+    else {//vertical separator
+        if (y1 > y2) dd = -1;
+        for(y = y1; y != y2; y+= dd){
+            processPixelPair(x1, y, x1, y+dd);
+        }
+    }
+}
+polyX = Array.trim(polyX, count);
+polyY = Array.trim(polyY, count);
+makeSelection("polygon", polyX, polyY);
+run("Interpolate", "interval=1 adjust"); //after button released
+
+//processes neighbors of this separator line and adds vertex
+function processPixelPair(x1, y1, x2, y2) {
+    if (x1 == x2) {
+        val1 = getPixel(x1, minOf(y1, y2));
+        val2 = getPixel(x1 - 1, minOf(y1, y2));
+    }
+    if (y1 == y2){
+        val1 = getPixel(minOf(x1, x2), y1);
+        val2 = getPixel(minOf(x1, x2), y1 -1);
+    }
+    bright = maxOf(val1, val2);
+    dark   = minOf(val1, val2);
+
+    if (bright>=lowThr && dark<=lowThr)
+        thr = lowThr;
+    if (bright>=hiThr && dark<=hiThr)
+        thr = hiThr;
+    if (dark==bright)
+        fraction = 0.5;
+    else
+        fraction =  (thr - dark)/(bright - dark);
+    if (val1 < val2)
+        fraction = 1 - fraction;
+    if (y1 == y2) {
+        newY = minOf(y1, y2) + fraction - 0.5;
+        newX = (x1 + x2)/2;
+    }
+    if (x1 == x2) {
+        newX = minOf(x1, x2) + fraction - 0.5;
+        newY = (y1 + y2)/2;
+    }
+    polyX[count] = newX;
+    polyY[count] = newY;
+    count++;
+    if (count == polyX.length){
+        polyX = Array.concat(polyX, polyX);
+        polyY = Array.concat(polyY, polyY);
+    }       
+}
diff --git a/macros/SprayCanTool.txt b/macros/SprayCanTool.txt
new file mode 100644
index 0000000..8ed59b9
--- /dev/null
+++ b/macros/SprayCanTool.txt
@@ -0,0 +1,41 @@
+// Spray Can Tool
+
+  var width=100, dotSize=1, rate=6;
+
+  macro 'Spray Can Tool - C123D20D22D24D41D43D62D82Da2C037L93b3D84Dc4L75d5L757f Ld5dfLa7d7LabdbLa9d9LacdcLa7ac' {
+       setLineWidth(dotSize);
+       radius=width/2; radius2=radius*radius;
+       start = getTime();
+       autoUpdate(false);
+       n = 25*exp(0.9*(10-rate));
+       if (n<=5) n = 0;
+       while (true) {
+          getCursorLoc(x, y, z, flags);
+          if (flags&16==0) exit();
+          x2 = (random()-0.5)*width;
+          y2 = (random()-0.5)*width;
+          if (x2*x2+y2*y2<radius2) {
+              x += x2;
+              y += y2;
+              drawLine(x, y, x, y);
+              if (getTime()>start+50) {
+                  updateDisplay();
+                  start = getTime();
+               }
+          }
+          for (i=0; i<n; i++);
+      }
+  }
+
+  macro 'Spray Can Tool Options' {
+     Dialog.create("Spray Can Options");
+     Dialog.addNumber("Spray Width (pixels):", width);
+     Dialog.addNumber("Dot Size (pixels):", dotSize);
+     Dialog.addNumber("Flow Rate (1-10):", rate);
+     Dialog.show();
+     width = Dialog.getNumber();
+     dotSize = Dialog.getNumber();
+     rate = Dialog.getNumber();
+     if (rate<1) rate = 1;
+     if (rate>10) rate = 10;
+ }
diff --git a/macros/StacksMenuTool.txt b/macros/StacksMenuTool.txt
new file mode 100644
index 0000000..636dc6e
--- /dev/null
+++ b/macros/StacksMenuTool.txt
@@ -0,0 +1,15 @@
+  var sCmds = newMenu("Stacks Menu Tool", 
+    newArray("Add Slice", "Delete Slice", "Set Slice...",
+    "-", "3D Project...", "Grouped Z Project...", "Z Project...", "Orthogonal Views", "Plot Z-axis Profile", "Reslice [/]...",
+    "-", "Images to Stack", "Stack to Images", "Make Montage...",
+    "-", "Make Substack...", "Stack to Hyperstack...",
+    "-", "Combine...", "Concatenate...", "Flip Z", "Label...", "Animation Options...",
+    "-", "T1 Head (2.4M, 16-bits)"));
+
+  macro "Stacks Menu Tool - C037T0b11ST8b09tTcb09k" {
+     cmd = getArgument();
+      if (cmd=="Images to Stack")
+          run(cmd, " ");
+      else if (cmd!="-")
+          run(cmd);
+  }
diff --git a/macros/StartupMacros.txt b/macros/StartupMacros.txt
new file mode 100644
index 0000000..4e7059d
--- /dev/null
+++ b/macros/StartupMacros.txt
@@ -0,0 +1,7 @@
+// Default startup macros
+
+  macro "Developer Menu Built-in Tool" {}
+  macro "Brush Built-in Tool" {}
+  macro "Flood Filler Built-in Tool" {}
+  macro "Arrow Built-in Tool" {}
+
diff --git a/macros/TimeStamp.ijm b/macros/TimeStamp.ijm
new file mode 100644
index 0000000..9f8f915
--- /dev/null
+++ b/macros/TimeStamp.ijm
@@ -0,0 +1,13 @@
+x=20; y=30; size=18;
+interval=1; //seconds
+i = floor(i*interval); // 'i' is the image index
+setFont("SansSerif", size, "antialiased");
+setColor("white");
+s = ""+pad(floor(i/3600))+":"+pad(floor((i/60)%60))+":"+pad(i%60);
+drawString(s, x, y);
+function pad(n) {
+  str = toString(n);
+  if (lengthOf(str)==1) str="0"+str;
+  return str;
+}
+
diff --git a/plugins/Decarburization_Measurements.jar b/plugins/Decarburization_Measurements.jar
new file mode 100644
index 0000000..0bf116d
Binary files /dev/null and b/plugins/Decarburization_Measurements.jar differ
diff --git a/plugins/MacAdapter.class b/plugins/MacAdapter.class
new file mode 100644
index 0000000..ab5202e
Binary files /dev/null and b/plugins/MacAdapter.class differ
diff --git a/plugins/MacAdapter.source b/plugins/MacAdapter.source
new file mode 100644
index 0000000..7eff785
--- /dev/null
+++ b/plugins/MacAdapter.source
@@ -0,0 +1,54 @@
+package ij.plugin;
+import ij.plugin.*;
+import ij.*;
+import ij.io.*;
+import com.apple.eawt.*;
+import java.util.Vector;
+
+/** This Mac-specific plugin is designed to handle the “About ImageJ",
+   Preferences and “Quit ImageJ" commands in the ImageJ menu, and to
+   open files dropped on ImageJ.app and to open double-clicked files
+   with creator code "imgJ". With Java 8, the “About ImageJ" and
+   “Quit ImageJ” commands work without MacAdapter.
+*/
+public class MacAdapter implements PlugIn, ApplicationListener, Runnable {
+   static Vector paths = new Vector();
+
+   public void run(String arg) {
+      Application app = new Application();
+      app.setEnabledPreferencesMenu(true);
+      app.addApplicationListener(this);
+   }
+    
+   public void handleAbout(ApplicationEvent event) {
+      IJ.doCommand("About ImageJ...");
+      event.setHandled(true);
+   }
+
+   public void handleOpenFile(ApplicationEvent event) {
+      paths.add(event.getFilename());
+      Thread thread = new Thread(this, "Open");
+      thread.setPriority(thread.getPriority()-1);
+      thread.start();
+   }
+
+   public void handlePreferences(ApplicationEvent event) {
+      IJ.error("The ImageJ preferences are in the Edit>Options menu.");
+   }
+
+   public void handleQuit(ApplicationEvent event) {
+      new Executer("Quit", null); // works with the CommandListener
+      //IJ.getInstance().quit();
+   }
+  
+    public void run() {
+        if (paths.size() > 0) {
+         (new Opener()).openAndAddToRecent((String) paths.remove(0));
+      }
+    }
+
+   public void handleOpenApplication(ApplicationEvent event) {}
+   public void handleReOpenApplication(ApplicationEvent event) {}
+   public void handlePrintFile(ApplicationEvent event) {}
+
+}
diff --git a/plugins/MacAdapter9.class b/plugins/MacAdapter9.class
new file mode 100644
index 0000000..44ef7dd
Binary files /dev/null and b/plugins/MacAdapter9.class differ
diff --git a/plugins/MacAdapter9.source b/plugins/MacAdapter9.source
new file mode 100644
index 0000000..d5be1ef
--- /dev/null
+++ b/plugins/MacAdapter9.source
@@ -0,0 +1,58 @@
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import java.awt.Desktop;
+import java.awt.desktop.*;
+import java.io.File;
+import java.util.Vector;
+
+/** This Mac-specific plugin is designed to handle the "About ImageJ" 
+ * command in the ImageJ menu, to open files dropped on ImageJ.app 
+ * and to open double-clicked files with creator code "imgJ". 
+ * With Java 9 or newer, we use java.awt.desktop instead of the
+ * previous com.apple.eawt.* classes.
+ * @author Alan Brooks
+*/
+public class MacAdapter9 implements PlugIn, AboutHandler, OpenFilesHandler, QuitHandler, Runnable {
+   static Vector<String> paths = new Vector<String>();
+
+   public void run(String arg) {
+      Desktop dtop = Desktop.getDesktop();
+      dtop.setOpenFileHandler(this);
+      dtop.setAboutHandler(this);
+      dtop.setQuitHandler(this);
+   }
+
+   @Override
+   public void handleAbout(AboutEvent e) {
+      IJ.doCommand("About ImageJ...");
+   }
+
+   @Override
+   public void openFiles(OpenFilesEvent e) {
+      for (File file: e.getFiles()) {
+         paths.add(file.getPath());
+         Thread thread = new Thread(this, "Open");
+         thread.setPriority(thread.getPriority()-1);
+         thread.start();
+      }
+   }
+
+   @Override
+   public void handleQuitRequestWith(QuitEvent e, QuitResponse response) {
+      new Executer("Quit", null); // works with the CommandListener
+   }
+ 
+   // Not adding preference handling
+   // because we don't have the equivalent of app.setEnabledPreferencesMenu(true);
+   // @Override
+   // public void handlePreferences(PreferencesEvent e) {
+   //    IJ.error("The ImageJ preferences are in the Edit>Options menu.");
+   // }
+  
+    public void run() {
+      if (paths.size() > 0) {
+         (new Opener()).openAndAddToRecent(paths.remove(0));
+      }
+    }
+}
diff --git a/plugins/TESTPlugin_.jar b/plugins/TESTPlugin_.jar
new file mode 100644
index 0000000..8436d7e
Binary files /dev/null and b/plugins/TESTPlugin_.jar differ
diff --git a/src/ij/CommandListener.java b/src/ij/CommandListener.java
new file mode 100644
index 0000000..7ec2870
--- /dev/null
+++ b/src/ij/CommandListener.java
@@ -0,0 +1,16 @@
+package ij;
+
+	/** Plugins that implement this interface are notified when ImageJ
+		is about to run a menu command. There is an example plugin at
+		http://imagej.nih.gov/ij/plugins/download/misc/Command_Listener.java
+	*/
+	public interface CommandListener {
+
+	/*	The method is called when ImageJ is about to run a menu command, 
+		where 'command' is the name of the command. Return this string 
+		and ImageJ will run the command, return a different command name
+		and ImageJ will run that command, or return null to not run a command.
+	*/
+	public String commandExecuting(String command);
+
+}
diff --git a/src/ij/CompositeImage.java b/src/ij/CompositeImage.java
new file mode 100644
index 0000000..b0a2cc3
--- /dev/null
+++ b/src/ij/CompositeImage.java
@@ -0,0 +1,666 @@
+package ij;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.*;
+import ij.plugin.frame.*;
+import ij.io.FileInfo;
+import java.awt.*;
+import java.awt.image.*;
+
+public class CompositeImage extends ImagePlus {
+
+	/** Display modes (note: TRANSPARENT mode has not yet been implemented) */
+	public static final int COMPOSITE=1, COLOR=2, GRAYSCALE=3, TRANSPARENT=4;
+	public static final int MAX_CHANNELS = 7;
+	int[] rgbPixels;
+	boolean newPixels;
+	MemoryImageSource imageSource;
+	Image awtImage;
+	WritableRaster rgbRaster;
+	SampleModel rgbSampleModel;
+	BufferedImage rgbImage;
+	ColorModel rgbCM;
+	ImageProcessor[] cip;
+	Color[] colors = {Color.red, Color.green, Color.blue, Color.white, Color.cyan, Color.magenta, Color.yellow};
+	LUT[] lut;
+	int currentChannel = -1;
+	int previousChannel;
+	int currentSlice = 1;
+	int currentFrame = 1;
+	boolean singleChannel;
+	boolean[] active = new boolean[MAX_CHANNELS];
+	int mode = COLOR;
+	int bitDepth;
+	double[] displayRanges;
+	byte[][] channelLuts;
+	boolean customLuts;
+	boolean syncChannels;
+
+	public CompositeImage(ImagePlus imp) {
+		this(imp, COLOR);
+	}
+	
+	public CompositeImage(ImagePlus imp, int mode) {
+		if (mode<COMPOSITE || mode>GRAYSCALE)
+			mode = COLOR;
+		this.mode = mode;
+		int channels = imp.getNChannels();
+		bitDepth = getBitDepth();
+		if (IJ.debugMode) IJ.log("CompositeImage: "+imp+" "+mode+" "+channels);
+		ImageStack stack2;
+		boolean isRGB = imp.getBitDepth()==24;
+		if (isRGB) {
+			if (imp.getImageStackSize()>1)
+				throw new IllegalArgumentException("RGB stacks not supported");
+			stack2 = getRGBStack(imp);
+		} else
+			stack2 = imp.getImageStack();
+		int stackSize = stack2.getSize();
+		if (channels==1 && isRGB)
+			channels = 3;
+		if (channels==1 && stackSize<=MAX_CHANNELS && !imp.dimensionsSet)
+			channels = stackSize;
+		if (channels<1 || (stackSize%channels)!=0)
+			throw new IllegalArgumentException("stacksize not multiple of channels");
+		if (mode==COMPOSITE && channels>MAX_CHANNELS)
+			this.mode = COLOR;
+		compositeImage = true;
+		int z = imp.getNSlices();
+		int t = imp.getNFrames();
+		if (channels==stackSize || channels*z*t!=stackSize)
+			setDimensions(channels, stackSize/channels, 1);
+		else
+			setDimensions(channels, z, t);
+		setStack(imp.getTitle(), stack2);
+		setCalibration(imp.getCalibration());
+		FileInfo fi = imp.getOriginalFileInfo();
+		if (fi!=null) {
+			displayRanges = fi.displayRanges; 
+			channelLuts = fi.channelLuts;
+		}
+		setFileInfo(fi);
+		Object info = imp.getProperty("Info");
+		if (info!=null)
+			setProperty("Info", imp.getProperty("Info"));
+		setProperties(imp.getPropertiesAsArray());		
+		if (mode==COMPOSITE) {
+			for (int i=0; i<MAX_CHANNELS; i++)
+				active[i] = true;
+		} else
+			active[0] = true;
+		//if (!(channels==3&&stackSize==3))
+		setRoi(imp.getRoi());
+		setOverlay(imp.getOverlay());
+		if (channels!=stackSize)
+			setOpenAsHyperStack(true);
+	}
+
+	@Override
+	public Image getImage() {
+		if (img==null)
+			updateImage();
+		return img;
+	}
+	
+	public void updateChannelAndDraw() {
+		if (!customLuts) singleChannel = true;
+		updateAndDraw();
+	}
+	
+	public void updateAllChannelsAndDraw() {
+		if (mode!=COMPOSITE)
+			updateChannelAndDraw();
+		else {
+			syncChannels = true;
+			singleChannel = false;
+			updateAndDraw();
+		}
+	}
+
+	public ImageProcessor getChannelProcessor() {
+		if (cip!=null && currentChannel!=-1)
+			return cip[currentChannel];
+		else
+			return getProcessor();
+	}
+
+	synchronized void setup(int channels, ImageStack stack2) {
+		if (stack2!=null && stack2.getSize()>0 && (stack2.getProcessor(1) instanceof ColorProcessor)) { // RGB?
+			cip = null;
+			lut = null;
+			return;
+		}
+		setupLuts(channels);
+		if (mode==COMPOSITE) {
+			cip = new ImageProcessor[channels];
+			for (int i=0; i<channels; ++i) {
+				cip[i] = stack2.getProcessor(i+1);
+				cip[i].setLut(lut[i]);
+			}
+			currentSlice = currentFrame = 1;
+		}
+	}
+
+	void setupLuts(int channels) {
+		if (ip==null)
+			return;
+		if (lut==null || lut.length<channels) {
+			if (displayRanges!=null && channels!=displayRanges.length/2)
+				displayRanges = null;
+			if (displayRanges==null&&ip.getMin()==0.0&&ip.getMax()==0.0)
+				ip.resetMinAndMax();
+			lut = new LUT[channels];
+			LUT lut2 = channels>MAX_CHANNELS?createLutFromColor(Color.white):null;
+			for (int i=0; i<channels; ++i) {
+				if (channelLuts!=null && i<channelLuts.length) {
+					lut[i] = createLutFromBytes(channelLuts[i]);
+					customLuts = true;
+				} else if (i<MAX_CHANNELS)
+					lut[i] = createLutFromColor(colors[i]);
+				else
+					lut[i] = (LUT)lut2.clone();
+				if (displayRanges!=null) {
+					lut[i].min = displayRanges[i*2];
+					lut[i].max = displayRanges[i*2+1];
+				} else {
+					lut[i].min = ip.getMin();
+					lut[i].max = ip.getMax();
+				}
+			}
+			displayRanges = null;
+		}
+	}
+	
+	public void resetDisplayRanges() {
+		int channels = getNChannels();
+		if (lut==null)
+			setupLuts(channels);
+		ImageStack stack2 = getImageStack();
+		if (lut==null || channels!=lut.length || channels>stack2.getSize() || channels>MAX_CHANNELS)
+			return;
+		for (int i=0; i<channels; ++i) {
+			ImageProcessor ip2 = stack2.getProcessor(i+1);
+			ip2.resetMinAndMax();
+			lut[i].min = ip2.getMin();
+			lut[i].max = ip2.getMax();
+		}
+	}
+
+	public void updateAndDraw() {
+		if (win==null) {
+			img = null;
+			return;
+		}
+		updateImage();
+		if (win!=null)
+			notifyListeners(UPDATED);
+		draw();
+	}
+
+	public synchronized void updateImage() {
+		int imageSize = width*height;
+		int nChannels = getNChannels();
+		int redValue, greenValue, blueValue;
+		int ch = getChannel();
+		
+		//IJ.log("updateImage: "+ch+"/"+nChannels+" "+currentSlice+" "+currentFrame);
+		if (ch>nChannels) ch = nChannels;
+		boolean newChannel = false;
+		if (ch-1!=currentChannel) {
+			previousChannel = currentChannel;
+			currentChannel = ch-1;
+			newChannel = true;
+		}
+
+		ImageProcessor ip = getProcessor();
+		if (mode!=COMPOSITE) {
+			if (newChannel) {
+				setupLuts(nChannels);
+				LUT cm = lut[currentChannel];
+				if (ip!=null && !(ip instanceof ColorProcessor)) {
+					if (mode==COLOR)
+						ip.setLut(cm);
+					if (!(cm.min==0.0&&cm.max==0.0))
+						ip.setMinAndMax(cm.min, cm.max);
+				}
+				if (!IJ.isMacro()) ContrastAdjuster.update();
+				for (int i=0; i<MAX_CHANNELS; i++)
+					active[i] = i==currentChannel?true:false;
+				Channels.updateChannels();
+			}
+			if (ip!=null)
+				img = ip.createImage();
+			return;
+		}
+
+		if (nChannels==1) {
+			cip = null;
+			rgbPixels = null;
+			awtImage = null;
+			if (ip!=null)
+				img = ip.createImage();
+			return;
+		}
+	
+		if (cip==null||cip[0].getWidth()!=width||cip[0].getHeight()!=height||getBitDepth()!=bitDepth) {
+			setup(nChannels, getImageStack());
+			rgbPixels = null;
+			rgbSampleModel = null;
+			if (currentChannel>=nChannels) {
+				setSlice(1);
+				currentChannel = 0;
+				newChannel = true;
+			}
+			bitDepth = getBitDepth();
+		}
+		
+		if (newChannel) {
+			getProcessor().setMinAndMax(cip[currentChannel].getMin(), cip[currentChannel].getMax());
+			if (!IJ.isMacro()) ContrastAdjuster.update();
+		}
+		//IJ.log(nChannels+" "+ch+" "+currentChannel+"  "+newChannel);
+				
+		if (getSlice()!=currentSlice || getFrame()!=currentFrame) {
+			currentSlice = getSlice();
+			currentFrame = getFrame();
+			int position = getStackIndex(1, currentSlice, currentFrame);
+			if (cip==null) return;
+			for (int i=0; i<nChannels; ++i)
+				cip[i].setPixels(getImageStack().getProcessor(position+i).getPixels());
+		}
+
+		if (rgbPixels == null) {
+			rgbPixels = new int[imageSize];
+			newPixels = true;
+			imageSource = null;
+			rgbRaster = null;
+			rgbImage = null;
+		}
+		cip[currentChannel].setMinAndMax(ip.getMin(),ip.getMax());
+		if (singleChannel && nChannels<=3) {
+			switch (currentChannel) {
+				case 0: cip[0].updateComposite(rgbPixels, 1); break;
+				case 1: cip[1].updateComposite(rgbPixels, 2); break;
+				case 2: cip[2].updateComposite(rgbPixels, 3); break;
+			}
+		} else {
+			if (cip==null) return;
+			if (syncChannels) {
+				ImageProcessor ip2 = getProcessor();
+				double min=ip2.getMin(), max=ip2.getMax();
+				for (int i=0; i<nChannels; i++) {
+					cip[i].setMinAndMax(min, max);
+					lut[i].min = min;
+					lut[i].max = max;
+				}
+				syncChannels = false;
+			}
+			if (active[0])
+				cip[0].updateComposite(rgbPixels, 4);
+			else
+				{for (int i=1; i<imageSize; i++) rgbPixels[i] = 0;}
+			if (cip==null || nChannels>cip.length)
+				return;
+			for (int i=1; i<nChannels; i++)
+				if (active[i]) cip[i].updateComposite(rgbPixels, 5);
+		}
+		createBufferedImage();
+		if (img==null && awtImage!=null)
+			img = awtImage;
+		singleChannel = false;
+	}
+		
+	void createImage() {
+		if (imageSource==null) {
+			rgbCM = new DirectColorModel(32, 0xff0000, 0xff00, 0xff);
+			imageSource = new MemoryImageSource(width, height, rgbCM, rgbPixels, 0, width);
+			imageSource.setAnimated(true);
+			imageSource.setFullBufferUpdates(true);
+			awtImage = Toolkit.getDefaultToolkit().createImage(imageSource);
+			newPixels = false;
+		} else if (newPixels){
+			imageSource.newPixels(rgbPixels, rgbCM, 0, width);
+			newPixels = false;
+		} else
+			imageSource.newPixels();	
+	}
+
+	void createBufferedImage() {
+		if (rgbSampleModel==null)
+			rgbSampleModel = getRGBSampleModel();
+		if (rgbRaster==null) {
+			DataBuffer dataBuffer = new DataBufferInt(rgbPixels, width*height, 0);
+			rgbRaster = Raster.createWritableRaster(rgbSampleModel, dataBuffer, null);
+		}
+		if (rgbImage==null)
+			rgbImage = new BufferedImage(rgbCM, rgbRaster, false, null);
+		awtImage = rgbImage;
+	}
+
+	SampleModel getRGBSampleModel() {
+		rgbCM = new DirectColorModel(24, 0xff0000, 0xff00, 0xff);
+		WritableRaster wr = rgbCM.createCompatibleWritableRaster(1, 1);
+		SampleModel sampleModel = wr.getSampleModel();
+		sampleModel = sampleModel.createCompatibleSampleModel(width, height);
+		return sampleModel;
+	}
+
+	ImageStack getRGBStack(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		int w = ip.getWidth();
+		int h = ip.getHeight();
+		int size = w*h;
+		byte[] r = new byte[size];
+		byte[] g = new byte[size];
+		byte[] b = new byte[size];
+		((ColorProcessor)ip).getRGB(r, g, b);
+		ImageStack stack = new ImageStack(w, h);
+		stack.addSlice("Red", r);	
+		stack.addSlice("Green", g);	
+		stack.addSlice("Blue", b);
+		stack.setColorModel(ip.getDefaultColorModel());
+		return stack;
+	}
+
+	public LUT createLutFromColor(Color color) {
+		return LUT.createLutFromColor(color);
+	}
+	
+	LUT createLutFromBytes(byte[] bytes) {
+		if (bytes==null || bytes.length!=768)
+			return createLutFromColor(Color.white);
+		byte[] r = new byte[256];
+		byte[] g = new byte[256];
+		byte[] b = new byte[256];
+		for (int i=0; i<256; i++) r[i] = bytes[i];
+		for (int i=0; i<256; i++) g[i] = bytes[256+i];
+		for (int i=0; i<256; i++) b[i] = bytes[512+i];
+		return new LUT(r, g, b);
+	}
+
+	/** Returns the color used to display the image subtitle and "B&C" histogram. */
+	public Color getChannelColor() {
+		if (lut==null || mode==GRAYSCALE)
+			return Color.black;
+		IndexColorModel cm = lut[getChannelIndex()];
+		if (cm==null)
+			return Color.black;
+		int index = cm.getMapSize() - 1;
+		int r = cm.getRed(index);
+		int g = cm.getGreen(index);
+		int b = cm.getBlue(index);
+		//IJ.log(index+" "+r+" "+g+" "+b);
+		if (r<100 || g<100 || b<100)
+			return new Color(r, g, b);
+		else
+			return Color.black;
+	}
+
+	public ImageProcessor getProcessor(int channel) {
+		if (cip==null || channel>cip.length)
+			return null;
+		else
+			return cip[channel-1];
+	}
+
+	public boolean[] getActiveChannels() {
+		return active;
+	}
+	
+	public synchronized void setMode(int mode) {
+		if (mode<COMPOSITE || mode>GRAYSCALE)
+			return;
+		if (mode==COMPOSITE && getNChannels()>MAX_CHANNELS)
+			mode = COLOR;
+		for (int i=0; i<MAX_CHANNELS; i++)
+			active[i] = true;
+		if (this.mode!=COMPOSITE && mode==COMPOSITE)
+			img = null;
+		this.mode = mode;
+		if (mode==COLOR || mode==GRAYSCALE) {
+			if (cip!=null) {
+				for (int i=0; i<cip.length; i++) {
+					if (cip[i]!=null) cip[i].setPixels(null);
+					cip[i] = null;
+				}
+			}
+			cip = null;
+			rgbPixels = null;
+			awtImage = null;
+			currentChannel = -1;
+		}
+		if (mode==GRAYSCALE || mode==TRANSPARENT)
+			ip.setColorModel(ip.getDefaultColorModel());
+		Channels.updateChannels();
+	}
+
+	public int getMode() {
+		return mode;
+	}
+	
+	public String getModeAsString() {
+		switch (mode) {
+			case COMPOSITE: return "composite";
+			case COLOR: return "color";
+			case GRAYSCALE: return "grayscale";
+		}
+		return "";
+	}
+	
+	/* Returns the LUT used by the specified channel. */
+	public LUT getChannelLut(int channel) {
+		int channels = getNChannels();
+		if (lut==null) setupLuts(channels);
+		if (channel<1 || channel>lut.length)
+			throw new IllegalArgumentException("Channel out of range: "+channel);
+		return lut[channel-1];
+	}
+	
+	/* Returns the LUT used by the current channel. */
+	public LUT getChannelLut() {
+		int c = getChannelIndex();
+		return lut[c];
+	}
+	
+	/* Returns a copy of this image's channel LUTs as an array. */
+	public LUT[] getLuts() {
+		int channels = getNChannels();
+		if (lut==null)
+			setupLuts(channels);
+		LUT[] luts = new LUT[channels];
+		for (int i=0; i<channels; i++) {
+			if (i<lut.length)
+				luts[i] = (LUT)lut[i].clone();
+			else
+				luts[i] = (LUT)lut[0].clone();
+		}
+		return luts;
+	}
+
+	/* Sets the channel LUTs with clones of the LUTs in 'luts'. */
+	public void setLuts(LUT[] luts) {
+		int channels = getNChannels();
+		if (lut==null) setupLuts(channels);
+		if (luts==null || luts.length<channels)
+			throw new IllegalArgumentException("Lut array is null or too small");
+		for (int i=0; i<channels; i++)
+			setChannelLut(luts[i], i+1);
+	}
+	
+	/** Copies the LUTs and display mode of 'imp' to this image. Does
+		nothing if 'imp' is not a CompositeImage or 'imp' and this
+		image do not have the same number of channels. */
+	public synchronized void copyLuts(ImagePlus imp) {
+		int channels = getNChannels();
+		if (!imp.isComposite() || imp.getNChannels()!=channels)
+			return;
+		CompositeImage ci = (CompositeImage)imp;
+		LUT[] luts = ci.getLuts();
+		if (luts!=null && luts.length==channels) {
+			lut = luts;
+			cip = null;
+		}
+		int mode2 = ci.getMode();
+		setMode(mode2);
+		if (mode2==COMPOSITE) {
+			boolean[] active2 = ci.getActiveChannels();
+			for (int i=0; i<MAX_CHANNELS; i++)
+				active[i] = active2[i];
+		}
+		if (ci.hasCustomLuts())
+			customLuts = true;
+	}
+
+	int getChannelIndex() {
+		int channels = getNChannels();
+		if (lut==null) setupLuts(channels);
+		int index = getChannel()-1;
+		return index;
+	}
+	
+	public void reset() {
+		int nChannels = getNChannels();
+		if (nChannels>MAX_CHANNELS && getMode()==COMPOSITE)
+			setMode(COLOR);
+		setup(nChannels, getImageStack());
+	}
+	
+	public void completeReset() {
+		cip = null;
+		lut = null;
+	}
+	
+	/* Sets the LUT of the current channel. */
+	public void setChannelLut(LUT table) {
+		int c = getChannelIndex();
+		double min = lut[c].min;
+		double max = lut[c].max;
+		lut[c] = table;
+		lut[c].min = min;
+		lut[c].max = max;
+		if (mode==COMPOSITE && cip!=null && c<cip.length) {
+			cip[c].setColorModel(lut[c] );
+			imageSource = null;
+			newPixels = true;
+			img = null;
+		}
+		currentChannel = -1;
+		getProcessor().setLut(table);
+		customLuts = true;
+		if (!IJ.isMacro()) ContrastAdjuster.update();
+	}
+	
+	/* Sets the LUT of the specified channel using a clone of 'table'. */
+	public synchronized void setChannelLut(LUT table, int channel) {
+		int channels = getNChannels();
+		if (lut==null) setupLuts(channels);
+		if (channel<1 || channel>lut.length)
+			throw new IllegalArgumentException("Channel out of range");
+		lut[channel-1] = (LUT)table.clone();
+		if (getWindow()!=null && channel==getChannel())
+			getProcessor().setLut(lut[channel-1]);
+		if (cip!=null && cip.length>=channel && cip[channel-1]!=null)
+			cip[channel-1].setLut(lut[channel-1]);
+		else
+			cip = null;
+		customLuts = true;
+	}
+
+	/* Sets the IndexColorModel of the current channel. */
+	public void setChannelColorModel(IndexColorModel cm) {
+		setChannelLut(new LUT(cm,0.0,0.0));
+	}
+	
+	public void setDisplayRange(double min, double max) {
+		ip.setMinAndMax(min, max);
+		int c = getChannelIndex();
+		lut[c].min = min;
+		lut[c].max = max;
+		if (getWindow()==null && cip!=null && c<cip.length)
+			cip[c].setLut(lut[c]);
+	}
+
+	public double getDisplayRangeMin() {
+		if (lut!=null)
+			return lut[getChannelIndex()].min;
+		else
+			return 0.0;
+	}
+
+	public double getDisplayRangeMax() {
+		if (lut!=null)
+			return lut[getChannelIndex()].max;
+		else
+			return 255.0;
+	}
+
+	public void resetDisplayRange() {
+		if (getType()==GRAY16 && getDefault16bitRange()!=0) {
+			int defaultRange = getDefault16bitRange();
+			for (int i=1; i<=getNChannels(); i++) {
+				LUT lut = getChannelLut(i);
+				lut.min = 0;
+				lut.max = Math.pow(2,defaultRange)-1;
+				if (getWindow()!=null)
+					setChannelLut(lut, i);
+			}
+		} else {
+			ip.resetMinAndMax();
+			int c = getChannelIndex();
+			lut[c].min = ip.getMin();
+			lut[c].max = ip.getMax();
+		}
+	}
+	
+	public boolean hasCustomLuts() {
+		return customLuts && mode!=GRAYSCALE;
+	}
+	
+	public void close() {
+		super.close();
+		rgbPixels = null;
+		imageSource = null;
+		awtImage = null;
+		rgbRaster = null;
+		rgbSampleModel = null;
+		rgbImage = null;
+		rgbCM = null;
+		if (cip!=null) {
+			for (int i=0; i<cip.length; i++)
+				cip[i] = null;
+			cip = null;
+		}
+		if (lut!=null) {
+			for (int i=0; i<lut.length; i++)
+				lut[i] = null;
+			lut = null;
+		}
+		if (channelLuts!=null) {
+			for (int i=0; i<channelLuts.length; i++)
+				channelLuts[i] = null;
+			channelLuts = null;
+		}
+	}
+
+	/** Deprecated */
+	public synchronized void setChannelsUpdated() {
+		if (cip!=null) {
+			for (int i=0; i<cip.length; i++) {
+				if (cip[i]!=null) cip[i].setPixels(null);
+				cip[i] = null;
+			}
+		}
+		cip = null;
+		lut = null;
+		img = null;
+		currentChannel = -1;
+		previousChannel = 0;
+		currentSlice = currentFrame = 1;
+		singleChannel = false;
+		rgbPixels = null;
+		awtImage = null;
+		channelLuts = null;
+		boolean[] active = new boolean[MAX_CHANNELS];
+	}
+
+}
diff --git a/src/ij/Executer.java b/src/ij/Executer.java
new file mode 100644
index 0000000..7b23f1b
--- /dev/null
+++ b/src/ij/Executer.java
@@ -0,0 +1,277 @@
+package ij;
+import ij.util.Tools;
+import ij.text.TextWindow;
+import ij.plugin.MacroInstaller;
+import ij.plugin.Duplicator;
+import ij.plugin.frame.Recorder;
+import ij.plugin.frame.Editor;
+import ij.io.OpenDialog;
+import java.io.*;
+import java.util.*;
+import java.awt.event.KeyEvent;
+import java.awt.Menu;
+
+
+/** Runs ImageJ menu commands in a separate thread.*/
+public class Executer implements Runnable {
+
+	private static String previousCommand;
+	private static CommandListener listener;
+	private static Vector listeners = new Vector();
+
+	private String command;
+	private Thread thread;
+	private boolean repeatingCommand;
+
+	/** Create an Executer to run the specified menu command
+		in this thread using the active image. */
+	public Executer(String cmd) {
+		command = cmd;
+	}
+
+	/** Create an Executer that runs the specified menu
+		command in a separate thread using the specified image,
+		or using the active image if 'imp' is null. */
+	public Executer(String cmd, ImagePlus imp) {
+		if (cmd.startsWith("Repeat")) {
+			command = previousCommand;
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);
+			repeatingCommand = true;
+		} else {
+			command = cmd;
+			if (!(cmd.equals("Undo")||cmd.equals("Close")))
+				previousCommand = cmd;
+		}
+		IJ.resetEscape();
+		thread = new Thread(this, cmd);
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		if (imp!=null)
+			WindowManager.setTempCurrentImage(thread, imp);
+		thread.start();
+	}
+
+	public void run() {
+		if (command==null)
+			return;
+		if (listeners.size()>0) synchronized (listeners) {
+			for (int i=0; i<listeners.size(); i++) {
+				CommandListener listener = (CommandListener)listeners.elementAt(i);
+				command = listener.commandExecuting(command);
+				if (command==null) return;
+			}
+		}
+		try {
+			if (Recorder.record) {
+				Recorder.setCommand(command);
+				runCommand(command);
+				Recorder.saveCommand();
+			} else
+				runCommand(command);
+			int len = command.length();
+			if (len>0 && command.charAt(len-1)!=']')
+				IJ.setKeyUp(IJ.ALL_KEYS);  // set keys up except for "<", ">", "+" and "-" shortcuts
+		} catch(Throwable e) {
+			IJ.showStatus("");
+			IJ.showProgress(1, 1);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) imp.unlock();
+			String msg = e.getMessage();
+			if (e instanceof OutOfMemoryError)
+				IJ.outOfMemory(command);
+			else if (e instanceof RuntimeException && msg!=null && msg.equals(Macro.MACRO_CANCELED))
+				; //do nothing
+			else {
+				CharArrayWriter caw = new CharArrayWriter();
+				PrintWriter pw = new PrintWriter(caw);
+				e.printStackTrace(pw);
+				String s = caw.toString();
+				if (IJ.isMacintosh()) {
+					if (s.indexOf("ThreadDeath")>0)
+						return;
+					s = Tools.fixNewLines(s);
+				}
+				int w=500, h=340;
+				if (s.indexOf("UnsupportedClassVersionError")!=-1) {
+					if (s.indexOf("version 49.0")!=-1) {
+						s = e + "\n \nThis plugin requires Java 1.5 or later.";
+						w=700; h=150;
+					}
+					if (s.indexOf("version 50.0")!=-1) {
+						s = e + "\n \nThis plugin requires Java 1.6 or later.";
+						w=700; h=150;
+					}
+					if (s.indexOf("version 51.0")!=-1) {
+						s = e + "\n \nThis plugin requires Java 1.7 or later.";
+						w=700; h=150;
+					}
+					if (s.indexOf("version 52.0")!=-1) {
+						s = e + "\n \nThis plugin requires Java 1.8 or later.";
+						w=700; h=150;
+					}
+				}
+				if (IJ.getInstance()!=null) {
+					s = IJ.getInstance().getInfo()+"\n \n"+s;
+					new TextWindow("Exception", s, w, h);
+				} else
+					IJ.log(s);
+			}
+		} finally {
+			if (thread!=null)
+				WindowManager.setTempCurrentImage(null);
+		}
+	}
+
+	void runCommand(String cmd) {
+		Hashtable table = Menus.getCommands();
+		String className = (String)table.get(cmd);
+		if (className!=null) {
+			String arg = "";
+			if (className.endsWith("\")")) {
+				// extract string argument (e.g. className("arg"))
+				int argStart = className.lastIndexOf("(\"");
+				if (argStart>0) {
+					arg = className.substring(argStart+2, className.length()-2);
+					className = className.substring(0, argStart);
+				}
+			}
+			if (Prefs.nonBlockingFilterDialogs) {
+				// we have the plugin class name, let us see whether it is allowed to run it
+				ImagePlus imp = WindowManager.getCurrentImage();
+				boolean imageLocked = imp!=null && imp.isLockedByAnotherThread();
+				if (imageLocked && !allowedWithLockedImage(className)) {
+					IJ.beep();
+					IJ.showStatus("\""+cmd + "\" blocked because \"" + imp.getTitle() + "\" is locked");
+					return;
+				}
+			}
+			// run the plugin
+			if (IJ.shiftKeyDown() && className.startsWith("ij.plugin.Macro_Runner") && !Menus.getShortcuts().contains("*"+cmd))
+    			IJ.open(IJ.getDirectory("plugins")+arg);
+    		else
+				IJ.runPlugIn(cmd, className, arg);
+		} else { // command is not a plugin
+			// is command in the Plugins>Macros menu?
+			if (MacroInstaller.runMacroCommand(cmd))
+				return;
+			// is it in the Image>Lookup Tables menu?
+			if (loadLut(cmd))
+				return;
+			// is it in the File>Open Recent menu?
+			if (openRecent(cmd))
+				return;
+			// is it an example in Help>Examples menu?
+			if (Editor.openExample(cmd))
+				return;
+			if ("Auto Threshold".equals(cmd)&&(String)table.get("Auto Threshold...")!=null)
+				runCommand("Auto Threshold...");
+			else if ("Enhance Local Contrast (CLAHE)".equals(cmd)&&(String)table.get("CLAHE ")!=null)
+				runCommand("CLAHE ");
+			else {
+				if ("Table...".equals(cmd))
+					IJ.runPlugIn("ij.plugin.NewPlugin", "table");
+				else {
+					if (repeatingCommand)
+						IJ.runMacro(previousCommand);
+					else {
+						if (!extraCommand(cmd))
+							IJ.error("Unrecognized command: \"" + cmd+"\"");
+					}
+				}
+			}
+	 	}
+    }
+    
+	private boolean extraCommand(String cmd) {
+		if (cmd!=null && cmd.equals("Duplicate Image...")) {
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) {
+				Duplicator.ignoreNextSelection();
+				IJ.run(imp, "Duplicate...", "");
+			} else
+				IJ.noImage();
+			return true;
+		} else
+			return false;
+	}
+
+	/** If the foreground image is locked during a filter operation with NonBlockingGenericDialog,
+	 *  the following plugins are allowed */
+	boolean allowedWithLockedImage(String className) {
+		return className.equals("ij.plugin.Zoom") ||
+				className.equals("ij.plugin.frame.ContrastAdjuster") ||
+				className.equals("ij.plugin.SimpleCommands") ||  //includes Plugins>Utiltites>Reset (needed to reset a locked image)
+				className.equals("ij.plugin.WindowOrganizer") ||
+				className.equals("ij.plugin.URLOpener");
+	}
+
+    /** Opens a .lut file from the ImageJ/luts directory and returns 'true' if successful. */
+    public static boolean loadLut(String name) {
+		String path = IJ.getDirectory("luts")+name.replace(" ","_")+".lut";
+		File f = new File(path);
+		if (!f.exists()) {
+			path = IJ.getDirectory("luts")+name+".lut";
+			f = new File(path);
+		}
+		if (!f.exists()) {
+			path = IJ.getDirectory("luts")+name.toLowerCase().replace(" ","_")+".lut";
+			f = new File(path);
+		}
+		if (!f.exists() && Character.isLowerCase(name.charAt(0))) {
+			String name2 = name.substring(0,1).toUpperCase()+name.substring(1);
+			path = IJ.getDirectory("luts")+name2+".lut";
+			f = new File(path);
+		}
+		if (!f.exists() && name.toLowerCase().equals("viridis")) {
+			path = IJ.getDirectory("luts")+"mpl-viridis.lut";  //Fiji version
+			f = new File(path);
+		}
+		if (f.exists()) {
+			String dir = OpenDialog.getLastDirectory();
+			IJ.open(path);
+			OpenDialog.setLastDirectory(dir);
+			return true;
+		}
+		return false;
+    }
+
+    /** Opens a file from the File/Open Recent menu
+ 	      and returns 'true' if successful. */
+    boolean openRecent(String cmd) {
+		Menu menu = Menus.getOpenRecentMenu();
+		if (menu==null) return false;
+		for (int i=0; i<menu.getItemCount(); i++) {
+			if (menu.getItem(i).getLabel().equals(cmd)) {
+				IJ.open(cmd);
+				return true;
+			}
+		}
+		return false;
+    }
+
+	/** Returns the last command executed. Returns null
+		if no command has been executed. */
+	public static String getCommand() {
+		return previousCommand;
+	}
+
+	public static void setAsRepeatCommand(String cmd) {
+		previousCommand = cmd;
+	}
+
+	/** Adds the specified command listener. */
+	public static void addCommandListener(CommandListener listener) {
+		listeners.addElement(listener);
+	}
+
+	/** Removes the specified command listener. */
+	public static void removeCommandListener(CommandListener listener) {
+		listeners.removeElement(listener);
+	}
+
+	public static int getListenerCount() {
+		return listeners.size();
+	}
+
+}
+
+
diff --git a/src/ij/IJ.java b/src/ij/IJ.java
new file mode 100644
index 0000000..08b9ab0
--- /dev/null
+++ b/src/ij/IJ.java
@@ -0,0 +1,2573 @@
+package ij;
+import ij.gui.*;
+import ij.process.*;
+import ij.text.*;
+import ij.io.*;
+import ij.plugin.*;
+import ij.plugin.filter.*;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+import ij.plugin.frame.ThresholdAdjuster;
+import ij.macro.Interpreter;
+import ij.macro.MacroRunner;
+import ij.measure.Calibration;
+import ij.measure.ResultsTable;
+import ij.measure.Measurements;
+import java.awt.event.*;
+import java.text.*;
+import java.util.*;	
+import java.awt.*;	
+import java.applet.Applet;
+import java.io.*;
+import java.lang.reflect.*;
+import java.net.*;
+import javax.net.ssl.*;
+import java.security.cert.*;
+import java.security.KeyStore;
+import java.nio.ByteBuffer;
+import java.math.RoundingMode;
+
+
+/** This class consists of static utility methods. */
+public class IJ {
+
+	/** SansSerif, plain, 10-point font */
+	public static Font font10 = new Font("SansSerif", Font.PLAIN, 10);
+	/** SansSerif, plain, 12-point font */
+	public static Font font12 = ImageJ.SansSerif12;
+	
+	/** Image display modes */
+	public static final int COMPOSITE=1, COLOR=2, GRAYSCALE=3;
+	
+	public static final String URL = "http://imagej.nih.gov/ij";
+	public static final int ALL_KEYS = -1;
+	
+	/** Use setDebugMode(boolean) to enable/disable debug mode. */
+	public static boolean debugMode;
+	
+	public static boolean hideProcessStackDialog;
+	    
+    public static final char micronSymbol = '\u00B5';
+    public static final char angstromSymbol = '\u00C5';
+    public static final char degreeSymbol = '\u00B0';
+
+	private static ImageJ ij;
+	private static java.applet.Applet applet;
+	private static ProgressBar progressBar;
+	private static TextPanel textPanel;
+	private static String osname, osarch;
+	private static boolean isMac, isWin, isLinux, is64Bit;
+	private static int javaVersion;
+	private static boolean controlDown, altDown, spaceDown, shiftDown;
+	private static boolean macroRunning;
+	private static Thread previousThread;
+	private static TextPanel logPanel;
+	private static boolean checkForDuplicatePlugins = true;		
+	private static ClassLoader classLoader;
+	private static boolean memMessageDisplayed;
+	private static long maxMemory;
+	private static boolean escapePressed;
+	private static boolean redirectErrorMessages;
+	private static boolean suppressPluginNotFoundError;
+	private static Hashtable commandTable;
+	private static Vector eventListeners = new Vector();
+	private static String lastErrorMessage;
+	private static Properties properties;	private static DecimalFormat[] df;
+	private static DecimalFormat[] sf;
+	private static DecimalFormatSymbols dfs;
+	private static boolean trustManagerCreated;
+	private static String smoothMacro;
+	private static Interpreter macroInterpreter;
+	private static boolean protectStatusBar;
+	private static Thread statusBarThread;
+			
+	static {
+		osname = System.getProperty("os.name");
+		isWin = osname.startsWith("Windows");
+		isMac = !isWin && osname.startsWith("Mac");
+		isLinux = osname.startsWith("Linux");
+		String version = System.getProperty("java.version");
+		if (version==null || version.length()<2)
+			version = "1.8";
+		if (version.startsWith("1.8"))
+			javaVersion = 8;
+		else if (version.charAt(0)=='1' && Character.isDigit(version.charAt(1)))
+			javaVersion = 10 + (version.charAt(1) - '0');
+		else if (version.charAt(0)=='2' && Character.isDigit(version.charAt(1)))
+			javaVersion = 20 + (version.charAt(1) - '0');
+		else if (version.startsWith("1.6"))
+			javaVersion = 6;
+		else if (version.startsWith("1.9")||version.startsWith("9"))
+			javaVersion = 9;
+		else if (version.startsWith("1.7"))
+			javaVersion = 7;
+		else
+			javaVersion = 8;
+		dfs = new DecimalFormatSymbols(Locale.US);
+		df = new DecimalFormat[10];
+		df[0] = new DecimalFormat("0", dfs);
+		df[1] = new DecimalFormat("0.0", dfs);
+		df[2] = new DecimalFormat("0.00", dfs);
+		df[3] = new DecimalFormat("0.000", dfs);
+		df[4] = new DecimalFormat("0.0000", dfs);
+		df[5] = new DecimalFormat("0.00000", dfs);
+		df[6] = new DecimalFormat("0.000000", dfs);
+		df[7] = new DecimalFormat("0.0000000", dfs);
+		df[8] = new DecimalFormat("0.00000000", dfs);
+		df[9] = new DecimalFormat("0.000000000", dfs);
+		df[0].setRoundingMode(RoundingMode.HALF_UP);
+	}
+			
+	static void init(ImageJ imagej, Applet theApplet) {
+		ij = imagej;
+		applet = theApplet;
+		progressBar = ij.getProgressBar();
+	}
+
+	static void cleanup() {
+		ij=null; applet=null; progressBar=null; textPanel=null;
+	}
+
+	/**Returns a reference to the "ImageJ" frame.*/
+	public static ImageJ getInstance() {
+		return ij;
+	}
+	
+	/**Enable/disable debug mode.*/
+	public static void setDebugMode(boolean b) {
+		debugMode = b;
+		LogStream.redirectSystem(debugMode);
+	}
+
+	/** Runs the macro contained in the string <code>macro</code>
+		on the current thread. Returns any string value returned by
+		the macro, null if the macro does not return a value, or
+		"[aborted]" if the macro was aborted due to an error. The
+		equivalent macro function is eval(). */
+	public static String runMacro(String macro) {
+		return runMacro(macro, "");
+	}
+
+	/** Runs the macro contained in the string <code>macro</code>
+		on the current thread. The optional string argument can be
+		retrieved in the called macro using the getArgument() macro
+		function. Returns any string value returned by the macro, null
+		if the macro does not return a value, or "[aborted]" if the
+		macro was aborted due to an error.  */
+	public static String runMacro(String macro, String arg) {
+		Macro_Runner mr = new Macro_Runner();
+		return mr.runMacro(macro, arg);
+	}
+
+	/** Runs the specified macro or script file in the current thread.
+		The file is assumed to be in the macros folder
+ 		unless <code>name</code> is a full path.
+		The optional string argument (<code>arg</code>) can be retrieved in the called 
+		macro or script using the getArgument() function. 
+		Returns any string value returned by the macro, or null. Scripts always return null.
+		The equivalent macro function is runMacro(). */
+	public static String runMacroFile(String name, String arg) {
+		Macro_Runner mr = new Macro_Runner();
+		return mr.runMacroFile(name, arg);
+	}
+
+	/** Runs the specified macro file. */
+	public static String runMacroFile(String name) {
+		return runMacroFile(name, null);
+	}
+
+	/** Runs the specified plugin using the specified image. */
+	public static Object runPlugIn(ImagePlus imp, String className, String arg) {
+		if (imp!=null) {
+			ImagePlus temp = WindowManager.getTempCurrentImage();
+			WindowManager.setTempCurrentImage(imp);
+			Object o = runPlugIn("", className, arg);
+			WindowManager.setTempCurrentImage(temp);
+			return o;
+		} else
+			return runPlugIn(className, arg);
+	}
+
+	/** Runs the specified plugin and returns a reference to it. */
+	public static Object runPlugIn(String className, String arg) {
+		return runPlugIn("", className, arg);
+	}
+	
+	/** Runs the specified plugin and returns a reference to it. */
+	public static Object runPlugIn(String commandName, String className, String arg) {
+		if (arg==null) arg = "";
+		if (IJ.debugMode)
+			IJ.log("runPlugIn: "+className+argument(arg));
+		// Load using custom classloader if this is a user 
+		// plugin and we are not running as an applet
+		if (!className.startsWith("ij.") && applet==null)
+			return runUserPlugIn(commandName, className, arg, false);
+		Object thePlugIn=null;
+		try {
+			Class c = Class.forName(className);
+ 			thePlugIn = c.newInstance();
+ 			if (thePlugIn instanceof PlugIn)
+				((PlugIn)thePlugIn).run(arg);
+ 			else
+				new PlugInFilterRunner(thePlugIn, commandName, arg);
+		} catch (ClassNotFoundException e) {
+			if (!(className!=null && className.startsWith("ij.plugin.MacAdapter"))) {
+				log("Plugin or class not found: \"" + className + "\"\n(" + e+")");
+				String path = Prefs.getCustomPropsPath();
+				if (path!=null);
+					log("Error may be due to custom properties at " + path);
+			}
+		}
+		catch (InstantiationException e) {log("Unable to load plugin (ins)");}
+		catch (IllegalAccessException e) {log("Unable to load plugin, possibly \nbecause it is not public.");}
+		redirectErrorMessages = false;
+		return thePlugIn;
+	}
+        
+	static Object runUserPlugIn(String commandName, String className, String arg, boolean createNewLoader) {
+		if (IJ.debugMode)
+			IJ.log("runUserPlugIn: "+className+", arg="+argument(arg));
+		if (applet!=null) return null;
+		if (checkForDuplicatePlugins) {
+			// check for duplicate classes and jars in the plugins folder
+			IJ.runPlugIn("ij.plugin.ClassChecker", "");
+			checkForDuplicatePlugins = false;
+		}
+		if (createNewLoader)
+			classLoader = null;
+		ClassLoader loader = getClassLoader();
+		Object thePlugIn = null;
+		try { 
+			thePlugIn = (loader.loadClass(className)).newInstance(); 
+			if (thePlugIn instanceof PlugIn)
+ 				((PlugIn)thePlugIn).run(arg);
+ 			else if (thePlugIn instanceof PlugInFilter)
+				new PlugInFilterRunner(thePlugIn, commandName, arg);
+		}
+		catch (ClassNotFoundException e) {
+			if (className.startsWith("macro:"))
+				runMacro(className.substring(6));
+			else if (className.contains("_")  && !suppressPluginNotFoundError)
+				error("Plugin or class not found: \"" + className + "\"\n(" + e+")");
+		}
+		catch (NoClassDefFoundError e) {
+			int dotIndex = className.indexOf('.');
+			if (dotIndex>=0 && className.contains("_")) {
+				// rerun plugin after removing folder name
+				if (debugMode) IJ.log("runUserPlugIn: rerunning "+className);
+				return runUserPlugIn(commandName, className.substring(dotIndex+1), arg, createNewLoader);
+			}
+			if (className.contains("_") && !suppressPluginNotFoundError)
+				error("Run User Plugin", "Class not found while attempting to run \"" + className + "\"\n \n   " + e);
+		}
+		catch (InstantiationException e) {error("Unable to load plugin (ins)");}
+		catch (IllegalAccessException e) {error("Unable to load plugin, possibly \nbecause it is not public.");}
+		if (thePlugIn!=null && !"HandleExtraFileTypes".equals(className))
+ 			redirectErrorMessages = false;
+		suppressPluginNotFoundError = false;
+		return thePlugIn;
+	} 
+	
+	private static String argument(String arg) {
+		return arg!=null && !arg.equals("") && !arg.contains("\n")?"(\""+arg+"\")":"";
+	}
+
+	static void wrongType(int capabilities, String cmd) {
+		String s = "\""+cmd+"\" requires an image of type:\n \n";
+		if ((capabilities&PlugInFilter.DOES_8G)!=0) s +=  "    8-bit grayscale\n";
+		if ((capabilities&PlugInFilter.DOES_8C)!=0) s +=  "    8-bit color\n";
+		if ((capabilities&PlugInFilter.DOES_16)!=0) s +=  "    16-bit grayscale\n";
+		if ((capabilities&PlugInFilter.DOES_32)!=0) s +=  "    32-bit (float) grayscale\n";
+		if ((capabilities&PlugInFilter.DOES_RGB)!=0) s += "    RGB color\n";
+		error(s);
+	}
+	
+    /** Runs a menu command on a separete thread and returns immediately. */
+	public static void doCommand(String command) {
+		new Executer(command, null);
+	}
+	
+    /** Runs a menu command on a separete thread, using the specified image. */
+	public static void doCommand(ImagePlus imp, String command) {
+		new Executer(command, imp);
+	}
+	
+    /** Runs an ImageJ command. Does not return until 
+    	the command has finished executing. To avoid "image locked",
+    	errors, plugins that call this method should implement
+    	the PlugIn interface instead of PlugInFilter. */
+	public static void run(String command) {
+		run(command, null);
+	}
+	
+    /** Runs an ImageJ command, with options that are passed to the
+		GenericDialog and OpenDialog classes. Does not return until
+		the command has finished executing. To generate run() calls,
+		start the recorder (Plugins/Macro/Record) and run commands
+		from the ImageJ menu bar.
+	*/
+	public static void run(String command, String options) {
+		//IJ.log("run1: "+command+" "+Thread.currentThread().hashCode()+" "+options);
+		if (ij==null && Menus.getCommands()==null)
+			init();
+		Macro.abort = false;
+		Macro.setOptions(options);
+		Thread thread = Thread.currentThread();
+		if (previousThread==null || thread!=previousThread) {
+			String name = thread.getName();
+			if (!name.startsWith("Run$_"))
+				thread.setName("Run$_"+name);
+		}
+		command = convert(command);
+		previousThread = thread;
+		macroRunning = true;
+		Executer e = new Executer(command);
+		e.run();
+		macroRunning = false;
+		Macro.setOptions(null);
+		testAbort();
+		macroInterpreter = null;
+		//IJ.log("run2: "+command+" "+Thread.currentThread().hashCode());
+	}
+	
+	/** The macro interpreter uses this method to run commands. */
+	public static void run(Interpreter interpreter, String command, String options) {
+		macroInterpreter = interpreter;
+		run(command, options);
+		macroInterpreter = null;
+	}
+
+	/** Converts commands that have been renamed so 
+		macros using the old names continue to work. */
+	private static String convert(String command) {
+		if (commandTable==null) {
+			commandTable = new Hashtable(30);
+			commandTable.put("New...", "Image...");
+			commandTable.put("Threshold", "Make Binary");
+			commandTable.put("Display...", "Appearance...");
+			commandTable.put("Start Animation", "Start Animation [\\]");
+			commandTable.put("Convert Images to Stack", "Images to Stack");
+			commandTable.put("Convert Stack to Images", "Stack to Images");
+			commandTable.put("Convert Stack to RGB", "Stack to RGB");
+			commandTable.put("Convert to Composite", "Make Composite");
+			commandTable.put("RGB Split", "Split Channels");
+			commandTable.put("RGB Merge...", "Merge Channels...");
+			commandTable.put("Channels...", "Channels Tool...");
+			commandTable.put("New... ", "Table...");
+			commandTable.put("Arbitrarily...", "Rotate... ");
+			commandTable.put("Measurements...", "Results... ");
+			commandTable.put("List Commands...", "Find Commands...");
+			commandTable.put("Capture Screen ", "Capture Screen");
+			commandTable.put("Add to Manager ", "Add to Manager");
+			commandTable.put("In", "In [+]");
+			commandTable.put("Out", "Out [-]");
+			commandTable.put("Enhance Contrast", "Enhance Contrast...");
+			commandTable.put("XY Coodinates... ", "XY Coordinates... ");
+			commandTable.put("Statistics...", "Statistics");
+			commandTable.put("Channels Tool... ", "Channels Tool...");
+			commandTable.put("Profile Plot Options...", "Plots...");
+			commandTable.put("AuPbSn 40 (56K)", "AuPbSn 40");
+			commandTable.put("Bat Cochlea Volume (19K)", "Bat Cochlea Volume");
+			commandTable.put("Bat Cochlea Renderings (449K)", "Bat Cochlea Renderings");
+			commandTable.put("Blobs (25K)", "Blobs");
+			commandTable.put("Boats (356K)", "Boats");			
+			commandTable.put("Cardio (768K, RGB DICOM)", "Cardio (RGB DICOM)");
+			commandTable.put("Cell Colony (31K)", "Cell Colony");
+			commandTable.put("Clown (14K)", "Clown");
+			commandTable.put("Confocal Series (2.2MB)", "Confocal Series");
+			commandTable.put("CT (420K, 16-bit DICOM)", "CT (16-bit DICOM)");			
+			commandTable.put("Dot Blot (7K)", "Dot Blot");
+			commandTable.put("Embryos (42K)", "Embryos");
+			commandTable.put("Fluorescent Cells (400K)", "Fluorescent Cells");
+			commandTable.put("Fly Brain (1MB)", "Fly Brain");			
+			commandTable.put("Gel (105K)", "Gel");
+			commandTable.put("HeLa Cells (1.3M, 48-bit RGB)", "HeLa Cells (48-bit RGB)");
+			commandTable.put("Leaf (36K)", "Leaf");
+			commandTable.put("Line Graph (21K)", "Line Graph");			
+			commandTable.put("Mitosis (26MB, 5D stack)", "Mitosis (5D stack)");
+			commandTable.put("MRI Stack (528K)", "MRI Stack");
+			commandTable.put("M51 Galaxy (177K, 16-bits)", "M51 Galaxy (16-bits)");
+			commandTable.put("Neuron (1.6M, 5 channels)", "Neuron (5 channels)");
+			commandTable.put("Nile Bend (1.9M)", "Nile Bend");			
+			commandTable.put("Organ of Corti (2.8M, 4D stack)", "Organ of Corti (4D stack)");
+			commandTable.put("Particles (75K)", "Particles");
+			commandTable.put("T1 Head (2.4M, 16-bits)", "T1 Head (16-bits)");
+			commandTable.put("T1 Head Renderings (736K)", "T1 Head Renderings");
+			commandTable.put("TEM Filter (112K)", "TEM Filter");
+			commandTable.put("Tree Rings (48K)", "Tree Rings");
+		}
+		String command2 = (String)commandTable.get(command);
+		if (command2!=null)
+			return command2;
+		else
+			return command;
+	}
+
+	/** Runs an ImageJ command using the specified image and options.
+		To generate run() calls, start the recorder (Plugins/Macro/Record)
+		and run commands from the ImageJ menu bar.*/
+	public static void run(ImagePlus imp, String command, String options) {
+		if (ij==null && Menus.getCommands()==null)
+			init();
+		if (imp!=null) {
+			ImagePlus temp = WindowManager.getTempCurrentImage();
+			WindowManager.setTempCurrentImage(imp);
+			run(command, options);
+			WindowManager.setTempCurrentImage(temp);
+		} else
+			run(command, options);
+	}
+
+	static void init() {
+		Menus m = new Menus(null, null);
+		Prefs.load(m, null);
+		m.addMenuBar();
+	}
+
+	private static void testAbort() {
+		if (Macro.abort)
+			abort();
+	}
+
+	/** Returns true if the run(), open() or newImage() method is executing. */
+	public static boolean macroRunning() {
+		return macroRunning;
+	}
+
+	/** Returns true if a macro is running, or if the run(), open() 
+		or newImage() method is executing. */
+	public static boolean isMacro() {
+		return macroRunning || Interpreter.getInstance()!=null;
+	}
+
+	/**Returns the Applet that created this ImageJ or null if running as an application.*/
+	public static java.applet.Applet getApplet() {
+		return applet;
+	}
+	
+	/**Displays a message in the ImageJ status bar. If 's' starts 
+		with '!', subsequent showStatus() calls in the current
+		thread (without "!" in the message) are suppressed. */
+	public static void showStatus(String s) {
+		if ((Interpreter.getInstance()==null&&statusBarThread==null)
+		|| (statusBarThread!=null&&Thread.currentThread()!=statusBarThread))
+			protectStatusBar(false);
+		boolean doProtect = s.startsWith("!"); // suppress subsequent showStatus() calls
+		if (doProtect) {
+			protectStatusBar(true);
+			statusBarThread = Thread.currentThread();
+			s = s.substring(1);
+		}
+		if (doProtect || !protectStatusBar) {
+			if (ij!=null)
+				ij.showStatus(s);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			ImageCanvas ic = imp!=null?imp.getCanvas():null;
+			if (ic!=null)
+				ic.setShowCursorStatus(s.length()==0?true:false);
+		}
+	}
+	
+	/**Displays a message in the status bar and flashes
+	 * either the status bar or the active image.<br>
+	 * See: http://wsr.imagej.net/macros/FlashingStatusMessages.txt
+	*/ 
+	public static void showStatus(String message, String options) {
+		showStatus(message);
+		if (options==null)
+			return;
+		options = options.replace("flash", "");
+		options = options.replace("ms", "");
+		Color optionalColor = null;
+		int index1 = options.indexOf("#");
+		if (index1>=0) {  // hex color?
+			int index2 = options.indexOf(" ", index1);
+			if (index2==-1) index2 = options.length();
+			String hexColor = options.substring(index1, index2);
+			optionalColor = Colors.decode(hexColor, null);
+			options = options.replace(hexColor, "");
+		}
+		if (optionalColor==null) {  // "red", "green", etc.
+			for (String c : Colors.colors) {
+				if (options.contains(c)) {
+					optionalColor = Colors.getColor(c, ImageJ.backgroundColor);
+					options = options.replace(c, "");
+					break;
+				}
+			}
+		}
+		boolean flashImage = options.contains("image");
+		Color defaultColor = new Color(255,255,245);
+		int defaultDelay = 500;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (flashImage) {
+			options = options.replace("image", "");
+			if (imp!=null && imp.getWindow()!=null) {
+				defaultColor = Color.black;
+				defaultDelay = 100;
+			}
+			else
+				flashImage = false;
+		}
+		Color color = optionalColor!=null?optionalColor:defaultColor;
+		int delay = (int)Tools.parseDouble(options, defaultDelay);
+		if (delay>8000)
+			delay = 8000;
+		String colorString = null;
+		ImageJ ij = IJ.getInstance();
+		if (flashImage) {
+			Color previousColor = imp.getWindow().getBackground();
+			imp.getWindow().setBackground(color);
+			if (delay>0) {
+				wait(delay);			
+				imp.getWindow().setBackground(previousColor);
+			}
+		} else if (ij!=null) {
+			ij.getStatusBar().setBackground(color);
+			wait(delay);
+			ij.getStatusBar().setBackground(ij.backgroundColor);
+		}
+	}
+	
+	/**
+	* @deprecated
+	* replaced by IJ.log(), ResultsTable.setResult() and TextWindow.append().
+	* There are examples at
+	*   http://imagej.nih.gov/ij/plugins/sine-cosine.html
+	*/
+	public static void write(String s) {
+		if (textPanel==null && ij!=null)
+			showResults();
+		if (textPanel!=null)
+				textPanel.append(s);
+		else
+			System.out.println(s);
+	}
+
+	private static void showResults() {
+		TextWindow resultsWindow = new TextWindow("Results", "", 400, 250);
+		textPanel = resultsWindow.getTextPanel();
+		textPanel.setResultsTable(Analyzer.getResultsTable());
+	}
+
+	public static synchronized void log(String s) {
+		if (s==null) return;
+		if (logPanel==null && ij!=null) {
+			TextWindow logWindow = new TextWindow("Log", "", 400, 250);
+			logPanel = logWindow.getTextPanel();
+			logPanel.setFont(new Font("SansSerif", Font.PLAIN, 16));
+		}
+		if (logPanel!=null) {
+			if (s.startsWith("\\"))
+				handleLogCommand(s);
+			else {
+				if (s.endsWith("\n")) {
+					if (s.equals("\n\n"))
+						s= "\n \n ";
+					else if (s.endsWith("\n\n"))
+						s = s.substring(0, s.length()-2)+"\n \n ";
+					else
+						s = s+" ";
+				}
+				logPanel.append(s);
+			}
+		} else {
+			LogStream.redirectSystem(false);
+			System.out.println(s);
+		}
+	}
+
+	static void handleLogCommand(String s) {
+		if (s.equals("\\Closed"))
+			logPanel = null;
+		else if (s.startsWith("\\Update:")) {
+			int n = logPanel.getLineCount();
+			String s2 = s.substring(8, s.length());
+			if (n==0)
+				logPanel.append(s2);
+			else
+				logPanel.setLine(n-1, s2);
+		} else if (s.startsWith("\\Update")) {
+			int cindex = s.indexOf(":");
+			if (cindex==-1)
+				{logPanel.append(s); return;}
+			String nstr = s.substring(7, cindex);
+			int line = (int)Tools.parseDouble(nstr, -1);
+			if (line<0 || line>25)
+				{logPanel.append(s); return;}
+			int count = logPanel.getLineCount();
+			while (line>=count) {
+				log("");
+				count++;
+			}
+			String s2 = s.substring(cindex+1, s.length());
+			logPanel.setLine(line, s2);
+		} else if (s.equals("\\Clear")) {
+			logPanel.clear();
+		} else if (s.startsWith("\\Heading:")) {
+			logPanel.updateColumnHeadings(s.substring(10));
+		} else if (s.equals("\\Close")) {
+			Frame f = WindowManager.getFrame("Log");
+			if (f!=null && (f instanceof TextWindow))
+				((TextWindow)f).close();
+		} else
+			logPanel.append(s);
+	}
+	
+	/** Returns the contents of the Log window or null if the Log window is not open. */
+	public static synchronized String getLog() { 
+		if (logPanel==null || ij==null)
+			return null;
+		else
+			return logPanel.getText(); 
+	} 
+
+/** Clears the "Results" window and sets the column headings to
+		those in the tab-delimited 'headings' String. Writes to
+		System.out.println if the "ImageJ" frame is not present.*/
+	public static void setColumnHeadings(String headings) {
+		if (textPanel==null && ij!=null)
+			showResults();
+		if (textPanel!=null)
+			textPanel.setColumnHeadings(headings);
+		else
+			System.out.println(headings);
+	}
+
+	/** Returns true if the "Results" window is open. */
+	public static boolean isResultsWindow() {
+		return textPanel!=null;
+	}
+	
+	/** Renames a results window. */
+	public static void renameResults(String title) {
+		Frame frame = WindowManager.getFrontWindow();
+		if (frame!=null && (frame instanceof TextWindow)) {
+			TextWindow tw = (TextWindow)frame;
+			if (tw.getResultsTable()==null) {
+				IJ.error("Rename", "\""+tw.getTitle()+"\" is not a results table");
+				return;
+			}
+			tw.rename(title);
+		} else if (isResultsWindow()) {
+			TextPanel tp = getTextPanel();
+			TextWindow tw = (TextWindow)tp.getParent();
+			tw.rename(title);
+		}
+	}
+
+	/** Changes the name of a table window from 'oldTitle' to 'newTitle'. */
+	public static void renameResults(String oldTitle, String newTitle) {
+		Frame frame = WindowManager.getFrame(oldTitle);
+		if (frame==null) {
+			error("Rename", "\""+oldTitle+"\" not found");
+			return;
+		} else if (frame instanceof TextWindow) {
+			TextWindow tw = (TextWindow)frame;
+			if (tw.getResultsTable()==null) {
+				error("Rename", "\""+oldTitle+"\" is not a table");
+				return;
+			}
+			tw.rename(newTitle);
+		} else
+			error("Rename", "\""+oldTitle+"\" is not a table");
+	}
+
+	/** Deletes 'row1' through 'row2' of the "Results" window, where
+		'row1' and 'row2' must be in the range 0-Analyzer.getCounter()-1. */
+	public static void deleteRows(int row1, int row2) {
+		ResultsTable rt = Analyzer.getResultsTable();
+		int tableSize = rt.size();
+		rt.deleteRows(row1, row2);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			Overlay.updateTableOverlay(imp, row1, row2, tableSize);
+		rt.show("Results");
+	}
+	
+	/** Returns a measurement result, where 'measurement' is "Area", 
+	 * "Mean", "StdDev", "Mode", "Min", "Max", "X", "Y", "XM", "YM",
+	 * "Perim.", "BX", "BY", "Width", "Height", "Major", "Minor", "Angle",
+	 * "Circ.", "Feret", "IntDen", "Median", "Skew", "Kurt", "%Area",
+	 * "RawIntDen", "Ch", "Slice", "Frame", "FeretX", "FeretY",
+	 * "FeretAngle", "MinFeret", "AR", "Round", "Solidity", "MinThr"
+	 * or "MaxThr". Add " raw" to the argument to disable calibration,
+	 * for example IJ.getValue("Mean raw"). Add " limit" to enable
+	 * the "limit to threshold" option.
+	*/
+	public static double getValue(ImagePlus imp, String measurement) {
+		String options = "";
+		int index = measurement.indexOf(" ");
+		if (index>0) {
+			if (index<measurement.length()-1)
+				options = measurement.substring(index+1, measurement.length());
+			measurement = measurement.substring(0, index);
+		}
+		int measurements = Measurements.ALL_STATS + Measurements.SLICE;
+		if (options.contains("limit"))
+			measurements += Measurements.LIMIT;
+		Calibration cal = null;
+		if (options.contains("raw")) {
+			cal = imp.getCalibration();
+			imp.setCalibration(null);
+		}
+		ResultsTable rt = new ResultsTable();
+		Analyzer analyzer = new Analyzer(imp, measurements, rt);
+		analyzer.measure();
+		double value = Double.NaN;
+		try {
+			value = rt.getValue(measurement, 0);
+		} catch (Exception e) {};
+		if (cal!=null)
+			imp.setCalibration(cal);
+		return value;
+	}
+
+	/** Returns a reference to the "Results" window TextPanel.
+		Opens the "Results" window if it is currently not open.
+		Returns null if the "ImageJ" window is not open. */
+	public static TextPanel getTextPanel() {
+		if (textPanel==null && ij!=null)
+			showResults();
+		return textPanel;
+	}
+	
+	/** TextWindow calls this method with a null argument when the "Results" window is closed. */
+	public static void setTextPanel(TextPanel tp) {
+		textPanel = tp;
+	}
+    
+    /**Displays a "no images are open" dialog box.*/
+	public static void noImage() {
+		String msg = "There are no images open";
+		if (macroInterpreter!=null) {
+			macroInterpreter.abort(msg);
+			macroInterpreter = null;
+		} else
+			error("No Image", msg);
+	}
+
+	/** Displays an "out of memory" message to the "Log" window. */
+	public static void outOfMemory(String name) {
+		Undo.reset();
+		System.gc();
+		lastErrorMessage = "out of memory";
+		String tot = Runtime.getRuntime().maxMemory()/1048576L+"MB";
+		if (!memMessageDisplayed)
+			log(">>>>>>>>>>>>>>>>>>>>>>>>>>>");
+		log("<Out of memory>");
+		if (!memMessageDisplayed) {
+			log("<All available memory ("+tot+") has been>");
+			log("<used. To make more available, use the>");
+			log("<Edit>Options>Memory & Threads command.>");
+			log(">>>>>>>>>>>>>>>>>>>>>>>>>>>");
+			memMessageDisplayed = true;
+		}
+		Macro.abort();
+	}
+
+	/**	Updates the progress bar, where 0<=progress<=1.0. The progress bar is 
+	not shown in BatchMode and erased if progress>=1.0. The progress bar is
+    updated only if more than 90 ms have passes since the last call. Does nothing 
+	if the ImageJ window is not present. */
+	public static void showProgress(double progress) {
+		if (progressBar!=null) progressBar.show(progress, false);
+	}
+
+	/**	Updates the progress bar, where the length of the bar is set to
+     * (<code>currentValue+1)/finalValue</code> of the maximum bar length.
+     * The bar is erased if <code>currentValue&gt;=finalValue</code>. 
+     * The bar is updated only if more than 90 ms have passed since the
+     * last call. Displays subordinate progress bars as dots if
+     * 'currentIndex' is negative (example: Plugins/Utilities/Benchmark).
+    */
+    public static void showProgress(int currentIndex, int finalIndex) {
+		if (progressBar!=null) {
+			progressBar.show(currentIndex, finalIndex);
+			if (currentIndex==finalIndex)
+				progressBar.setBatchMode(false);
+		}
+	}
+
+	/** Displays a message in a dialog box titled "Message".
+		Writes the Java console if ImageJ is not present. */
+	public static void showMessage(String msg) {
+		showMessage("Message", msg);
+	}
+
+	/** Displays a message in a dialog box with the specified title.
+		Displays HTML formatted text if 'msg' starts with "<html>".
+		There are examples at
+		"http://imagej.nih.gov/ij/macros/HtmlDialogDemo.txt".
+		Writes to the Java console if ImageJ is not present. */
+	public static void showMessage(String title, String msg) {
+		if (ij!=null) {
+			if (msg!=null && (msg.startsWith("<html>")||msg.startsWith("<HTML>"))) {
+				HTMLDialog hd = new HTMLDialog(title, msg);
+				if (isMacro() && hd.escapePressed())
+					throw new RuntimeException(Macro.MACRO_CANCELED);
+			} else {
+				MessageDialog md = new MessageDialog(ij, title, msg); 
+				if (isMacro() && md.escapePressed())
+					throw new RuntimeException(Macro.MACRO_CANCELED);
+			}
+		} else
+			System.out.println(msg);
+	}
+
+	/** Displays a message in a dialog box titled "ImageJ". If a 
+		macro or JavaScript is running, it is aborted. Writes to the
+		Java console if the ImageJ window is not present.*/
+	public static void error(String msg) {
+		error(null, msg);
+		if (Thread.currentThread().getName().endsWith("JavaScript"))
+			throw new RuntimeException(Macro.MACRO_CANCELED);
+		else
+			Macro.abort();
+	}
+	
+	/** Displays a message in a dialog box with the specified title. If a 
+		macro or JavaScript is running, it is aborted. Writes to the
+		Java console if the ImageJ window is not present. */
+	public static void error(String title, String msg) {
+		if (macroInterpreter!=null) {
+			macroInterpreter.abort(msg);
+			macroInterpreter = null;
+			return;
+		}
+		if (msg!=null && msg.endsWith(Macro.MACRO_CANCELED))
+			return;
+		String title2 = title!=null?title:"ImageJ";
+		boolean abortMacro = title!=null;
+		lastErrorMessage = msg;
+		if (redirectErrorMessages) {
+			IJ.log(title2 + ": " + msg);
+			if (abortMacro && (title.contains("Open")||title.contains("Reader")))
+				abortMacro = false;
+		} else
+			showMessage(title2, msg);
+		redirectErrorMessages = false;
+		if (abortMacro)
+			Macro.abort();
+	}
+
+	/** Aborts any currently running JavaScript, or use IJ.error(string)
+		to abort a JavaScript with a message. */
+	public static void exit() {
+		if (Thread.currentThread().getName().endsWith("JavaScript"))
+			throw new RuntimeException(Macro.MACRO_CANCELED);
+	}
+
+	/** 
+	 * Returns the last error message written by IJ.error() or null if there
+	 * was no error since the last time this method was called.
+	 * @see #error(String)
+	 */
+	public static String getErrorMessage() {
+		String msg = lastErrorMessage;
+		lastErrorMessage = null;
+		return msg;
+	}
+
+	/** Displays a message in a dialog box with the specified title.
+		Returns false if the user pressed "Cancel". */
+	public static boolean showMessageWithCancel(String title, String msg) {
+		GenericDialog gd = new GenericDialog(title);
+		gd.addMessage(msg);
+		gd.showDialog();
+		return !gd.wasCanceled();
+	}
+
+	public static final int CANCELED = Integer.MIN_VALUE;
+
+	/** Allows the user to enter a number in a dialog box. Returns the	
+	    value IJ.CANCELED (-2,147,483,648) if the user cancels the dialog box. 
+	    Returns 'defaultValue' if the user enters an invalid number. */
+	public static double getNumber(String prompt, double defaultValue) {
+		GenericDialog gd = new GenericDialog("");
+		int decimalPlaces = (int)defaultValue==defaultValue?0:2;
+		gd.addNumericField(prompt, defaultValue, decimalPlaces);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return CANCELED;
+		double v = gd.getNextNumber();
+		if (gd.invalidNumber())
+			return defaultValue;
+		else
+			return v;
+	}
+
+	/** Allows the user to enter a string in a dialog box. Returns
+	    "" if the user cancels the dialog box. */
+	public static String getString(String prompt, String defaultString) {
+		GenericDialog gd = new GenericDialog("");
+		gd.addStringField(prompt, defaultString, 20);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return "";
+		return gd.getNextString();
+	}
+
+	/**Delays 'msecs' milliseconds.*/
+	public static void wait(int msecs) {
+		try {Thread.sleep(msecs);}
+		catch (InterruptedException e) { }
+	}
+	
+	/** Emits an audio beep. */
+	public static void beep() {
+		java.awt.Toolkit.getDefaultToolkit().beep();
+	}
+	
+	/**	Returns a string something like "64K of 256MB (25%)"
+	 * that shows how much of  the  available memory is in use.
+	 * This is the string displayed when the user clicks in the
+	 * status bar.
+	*/
+	public static String freeMemory() {
+		long inUse = currentMemory();
+		String inUseStr = inUse<10000*1024?inUse/1024L+"K":inUse/1048576L+"MB";
+		String maxStr="";
+		long max = maxMemory();
+		if (max>0L) {
+			double percent = inUse*100/max;
+			maxStr = " of "+max/1048576L+"MB ("+(percent<1.0?"<1":d2s(percent,0)) + "%)";
+		}
+		return  inUseStr + maxStr;
+	}
+	
+	/** Returns the amount of memory currently being used by ImageJ. */
+	public static long currentMemory() {
+		long freeMem = Runtime.getRuntime().freeMemory();
+		long totMem = Runtime.getRuntime().totalMemory();
+		return totMem-freeMem;
+	}
+
+	/** Returns the maximum amount of memory available to ImageJ or
+		zero if ImageJ is unable to determine this limit. */
+	public static long maxMemory() {
+		if (maxMemory==0L) {
+			Memory mem = new Memory();
+			maxMemory = mem.getMemorySetting();
+			if (maxMemory==0L) maxMemory = mem.maxMemory();
+		}
+		return maxMemory;
+	}
+	
+	public static void showTime(ImagePlus imp, long start, String str) {
+		showTime(imp, start, str, 1);
+	}
+	
+	public static void showTime(ImagePlus imp, long start, String str, int nslices) {
+		if (Interpreter.isBatchMode())
+			return;
+		double seconds = (System.currentTimeMillis()-start)/1000.0;
+		if (seconds<=0.5 && macroRunning())
+			return;
+		double pixels = (double)imp.getWidth() * imp.getHeight();
+		double rate = pixels*nslices/seconds;
+		String str2;
+		if (rate>1000000000.0)
+			str2 = "";
+		else if (rate<1000000.0)
+			str2 = ", "+d2s(rate,0)+" pixels/second";
+		else
+			str2 = ", "+d2s(rate/1000000.0,1)+" million pixels/second";
+		showStatus(str+seconds+" seconds"+str2);
+	}
+	
+	/** Experimental */
+	public static  String time(ImagePlus imp, long startNanoTime) {
+		double planes = imp.getStackSize();
+		double seconds = (System.nanoTime()-startNanoTime)/1000000000.0;
+		double mpixels = imp.getWidth()*imp.getHeight()*planes/1000000.0;
+		String time = seconds<1.0?d2s(seconds*1000.0,0)+" ms":d2s(seconds,1)+" seconds";
+		return time+", "+d2s(mpixels/seconds,1)+" million pixels/second";
+	}
+		
+	/** Converts a number to a formatted string using
+		2 digits to the right of the decimal point. */
+	public static String d2s(double n) {
+		return d2s(n, 2);
+	}
+	
+	/** Converts a number to a rounded formatted string.
+		The 'decimalPlaces' argument specifies the number of
+		digits to the right of the decimal point (0-9). Uses
+		scientific notation if 'decimalPlaces is negative. */
+	public static String d2s(double n, int decimalPlaces) {
+		if (Double.isNaN(n)||Double.isInfinite(n))
+			return ""+n;
+		if (n==Float.MAX_VALUE) // divide by 0 in FloatProcessor
+			return "3.4e38";
+		double np = n;
+		if (n<0.0) np = -n;
+		if (decimalPlaces<0) synchronized(IJ.class) {
+			decimalPlaces = -decimalPlaces;
+			if (decimalPlaces>9) decimalPlaces=9;
+			if (sf==null) {
+				if (dfs==null)
+					dfs = new DecimalFormatSymbols(Locale.US);
+				sf = new DecimalFormat[10];
+				sf[1] = new DecimalFormat("0.0E0",dfs);
+				sf[2] = new DecimalFormat("0.00E0",dfs);
+				sf[3] = new DecimalFormat("0.000E0",dfs);
+				sf[4] = new DecimalFormat("0.0000E0",dfs);
+				sf[5] = new DecimalFormat("0.00000E0",dfs);
+				sf[6] = new DecimalFormat("0.000000E0",dfs);
+				sf[7] = new DecimalFormat("0.0000000E0",dfs);
+				sf[8] = new DecimalFormat("0.00000000E0",dfs);
+				sf[9] = new DecimalFormat("0.000000000E0",dfs);
+			}
+			return sf[decimalPlaces].format(n); // use scientific notation
+		}
+		if (decimalPlaces<0) decimalPlaces = 0;
+		if (decimalPlaces>9) decimalPlaces = 9;
+		return df[decimalPlaces].format(n);
+	}
+
+    /** Converts a number to a rounded formatted string.
+    * The 'significantDigits' argument specifies the minimum number
+    * of significant digits, which is also the preferred number of
+    * digits behind the decimal. Fewer decimals are shown if the 
+    * number would have more than 'maxDigits'.
+    * Exponential notation is used if more than 'maxDigits' would be needed.
+    */
+    public static String d2s(double x, int significantDigits, int maxDigits) {
+        double log10 = Math.log10(Math.abs(x));
+        double roundErrorAtMax = 0.223*Math.pow(10, -maxDigits);
+        int magnitude = (int)Math.ceil(log10+roundErrorAtMax);
+        int decimals = x==0 ? 0 : maxDigits - magnitude;
+        if (decimals<0 || magnitude<significantDigits+1-maxDigits)
+            return IJ.d2s(x, -significantDigits); // exp notation for large and small numbers
+        else {
+            if (decimals>significantDigits)
+                decimals = Math.max(significantDigits, decimals-maxDigits+significantDigits);
+            return IJ.d2s(x, decimals);
+        }
+    }
+
+	/** Pad 'n' with leading zeros to the specified number of digits. */
+	public static String pad(int n, int digits) {
+		String str = ""+n;
+		while (str.length()<digits)
+			str = "0"+str;
+		return str;
+	}
+
+	/** Pad 's' with leading zeros to the specified number of digits. */
+	public static String pad(String s, int digits) {
+		String str = ""+s;
+		while (str.length()<digits)
+			str = "0"+str;
+		return str;
+	}
+
+	/** Adds the specified class to a Vector to keep it from being garbage
+	collected, which would cause the classes static fields to be reset. 
+	Probably not needed with Java 1.2 or later. */
+	public static void register(Class c) {
+		if (ij!=null) ij.register(c);
+	}
+	
+	/** Returns true if the space bar is down. */
+	public static boolean spaceBarDown() {
+		return spaceDown;
+	}
+
+	/** Returns true if the control key is down. */
+	public static boolean controlKeyDown() {
+		return controlDown;
+	}
+
+	/** Returns true if the alt key is down. */
+	public static boolean altKeyDown() {
+		return altDown;
+	}
+
+	/** Returns true if the shift key is down. */
+	public static boolean shiftKeyDown() {
+		return shiftDown;
+	}
+	
+	public static void setKeyDown(int key) {
+		switch (key) {
+			case KeyEvent.VK_CONTROL:
+				controlDown=true;
+				break;
+			case KeyEvent.VK_META:
+				if (isMacintosh()) controlDown=true;
+				break;
+			case KeyEvent.VK_ALT:
+				altDown=true;
+				updateStatus();
+				break;
+			case KeyEvent.VK_SHIFT:
+				shiftDown=true;
+				if (debugMode) beep();
+				break;
+			case KeyEvent.VK_SPACE: {
+				spaceDown=true;
+				ImageWindow win = WindowManager.getCurrentWindow();
+				//if (win!=null) win.getCanvas().setCursor(-1,-1,-1, -1);
+				break;
+			}
+			case KeyEvent.VK_ESCAPE: {
+				escapePressed = true;
+				break;
+			}
+		}
+	}
+
+	public static void setKeyUp(int key) {
+		switch (key) {
+			case KeyEvent.VK_CONTROL: controlDown=false; break;
+			case KeyEvent.VK_META: if (isMacintosh()) controlDown=false; break;
+			case KeyEvent.VK_ALT: altDown=false; updateStatus(); break;
+			case KeyEvent.VK_SHIFT: shiftDown=false; if (debugMode) beep(); break;
+			case KeyEvent.VK_SPACE:
+				spaceDown=false;
+				ImageWindow win = WindowManager.getCurrentWindow();
+				//if (win!=null) win.getCanvas().setCursor(-1,-1,-1,-1);
+				break;
+			case ALL_KEYS:
+				shiftDown=controlDown=altDown=spaceDown=false;
+				break;
+		}
+	}
+	
+	private static void updateStatus() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			Roi roi = imp.getRoi();
+			if (roi!=null && imp.getCalibration().scaled()) {
+				roi.showStatus();
+			}
+		}
+	}
+
+	public static void setInputEvent(InputEvent e) {
+		altDown = e.isAltDown();
+		shiftDown = e.isShiftDown();
+	}
+
+	/** Returns true if this machine is a Macintosh. */
+	public static boolean isMacintosh() {
+		return isMac;
+	}
+	
+	/** Returns true if this machine is a Macintosh running OS X. */
+	public static boolean isMacOSX() {
+		return isMacintosh();
+	}
+
+	/** Returns true if this machine is running Windows. */
+	public static boolean isWindows() {
+		return isWin;
+	}
+	
+	/** Returns the Java version (6, 7, 8, 9, 10, etc.). */
+	public static int javaVersion() {
+		return javaVersion;
+	}
+	
+	/** Always returns true. */
+	public static boolean isJava2() {
+		return true;
+	}
+	
+	/** Always returns true. */
+	public static boolean isJava14() {
+		return true;
+	}
+
+	/** Always returns true. */
+	public static boolean isJava15() {
+		return true;
+	}
+
+	/** Returns true if ImageJ is running on a Java 1.6 or greater JVM. */
+	public static boolean isJava16() {
+		return javaVersion >= 6;
+	}
+
+	/** Returns true if ImageJ is running on a Java 1.7 or greater JVM. */
+	public static boolean isJava17() {
+		return javaVersion >= 7;
+	}
+
+	/** Returns true if ImageJ is running on a Java 1.8 or greater JVM. */
+	public static boolean isJava18() {
+		return javaVersion >= 8;
+	}
+
+	/** Returns true if ImageJ is running on a Java 1.9 or greater JVM. */
+	public static boolean isJava19() {
+		return javaVersion >= 9;
+	}
+
+	/** Returns true if ImageJ is running on Linux. */
+	public static boolean isLinux() {
+		return isLinux;
+	}
+
+	/** Obsolete; always returns false. */
+	public static boolean isVista() {
+		return false;
+	}
+	
+	/** Returns true if ImageJ is running a 64-bit version of Java. */
+	public static boolean is64Bit() {
+		if (osarch==null)
+			osarch = System.getProperty("os.arch");
+		return osarch!=null && osarch.indexOf("64")!=-1;
+	}
+
+	/** Displays an error message and returns true if the
+		ImageJ version is less than the one specified. */
+	public static boolean versionLessThan(String version) {
+		boolean lessThan = ImageJ.VERSION.compareTo(version)<0;
+		if (lessThan)
+			error("This plugin or macro requires ImageJ "+version+" or later. Use\nHelp>Update ImageJ to upgrade to the latest version.");
+		return lessThan;
+	}
+	
+	/** Displays a "Process all images?" dialog. Returns
+		'flags'+PlugInFilter.DOES_STACKS if the user selects "Yes",
+		'flags' if the user selects "No" and PlugInFilter.DONE
+		if the user selects "Cancel".
+	*/
+	public static int setupDialog(ImagePlus imp, int flags) {
+		if (imp==null || (ij!=null&&ij.hotkey)) {
+			if (ij!=null) ij.hotkey=false;
+			return flags;
+		}
+		int stackSize = imp.getStackSize();
+		if (stackSize>1) {
+			String macroOptions = Macro.getOptions();
+			if (imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.COMPOSITE) {
+				if (macroOptions==null || !macroOptions.contains("slice"))
+					return flags | PlugInFilter.DOES_STACKS;
+			}
+			if (macroOptions!=null) {
+				if (macroOptions.indexOf("stack ")>=0)
+					return flags | PlugInFilter.DOES_STACKS;
+				else
+					return flags;
+			}
+			if (hideProcessStackDialog)
+				return flags;
+			String note = ((flags&PlugInFilter.NO_CHANGES)==0)?" There is\nno Undo if you select \"Yes\".":"";
+ 			YesNoCancelDialog d = new YesNoCancelDialog(getInstance(),
+				"Process Stack?", "Process all "+stackSize+" images?"+note);
+			if (d.cancelPressed())
+				return PlugInFilter.DONE;
+			else if (d.yesPressed()) {
+		    	if (imp.getStack().isVirtual() && ((flags&PlugInFilter.NO_CHANGES)==0)) {
+		    		int size = (stackSize*imp.getWidth()*imp.getHeight()*imp.getBytesPerPixel()+524288)/1048576;
+		    		String msg =
+						"Use the Process>Batch>Virtual Stack command\n"+
+						"to process a virtual stack or convert it into a\n"+
+						"normal stack using Image>Duplicate, which\n"+
+						"will require "+size+"MB of additional memory.";
+		    		error(msg);
+					return PlugInFilter.DONE;
+		    	}
+				if (Recorder.record)
+					Recorder.recordOption("stack");
+				return flags | PlugInFilter.DOES_STACKS;
+			}
+			if (Recorder.record)
+				Recorder.recordOption("slice");
+		}
+		return flags;
+	}
+		
+	/** Creates a rectangular selection. Removes any existing 
+		selection if width or height are less than 1. */
+	public static void makeRectangle(int x, int y, int width, int height) {
+		if (width<=0 || height<0)
+			getImage().deleteRoi();
+		else {
+			ImagePlus img = getImage();
+			if (Interpreter.isBatchMode())
+				img.setRoi(new Roi(x,y,width,height), false);
+			else
+				img.setRoi(x, y, width, height);
+		}
+	}
+	
+	/** Creates a subpixel resolution rectangular selection. */
+	public static void makeRectangle(double x, double y, double width, double height) {
+		if (width<=0 || height<0)
+			getImage().deleteRoi();
+		else
+			getImage().setRoi(new Roi(x,y,width,height), !Interpreter.isBatchMode());
+	}
+
+	/** Creates an oval selection. Removes any existing 
+		selection if width or height are less than 1. */
+	public static void makeOval(int x, int y, int width, int height) {
+		if (width<=0 || height<0)
+			getImage().deleteRoi();
+		else {
+			ImagePlus img = getImage();
+			img.setRoi(new OvalRoi(x, y, width, height));
+		}
+	}
+	
+	/** Creates an subpixel resolution oval selection. */
+	public static void makeOval(double x, double y, double width, double height) {
+		if (width<=0 || height<0)
+			getImage().deleteRoi();
+		else
+			getImage().setRoi(new OvalRoi(x, y, width, height));
+	}
+
+	/** Creates a straight line selection. */
+	public static void makeLine(int x1, int y1, int x2, int y2) {
+		getImage().setRoi(new Line(x1, y1, x2, y2));
+	}
+	
+	/** Creates a straight line selection using floating point coordinates. */
+	public static void makeLine(double x1, double y1, double x2, double y2) {
+		getImage().setRoi(new Line(x1, y1, x2, y2));
+	}
+
+	/** Creates a point selection using integer coordinates.. */
+	public static void makePoint(int x, int y) {
+		ImagePlus img = getImage();
+		Roi roi = img.getRoi();
+		if (shiftKeyDown() && roi!=null && roi.getType()==Roi.POINT) {
+			Polygon p = roi.getPolygon();
+			p.addPoint(x, y);
+			img.setRoi(new PointRoi(p.xpoints, p.ypoints, p.npoints));
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);
+		} else if (altKeyDown() && roi!=null && roi.getType()==Roi.POINT) {
+			((PolygonRoi)roi).deleteHandle(x, y);
+			IJ.setKeyUp(KeyEvent.VK_ALT);
+		} else
+			img.setRoi(new PointRoi(x, y));
+	}
+	
+	/** Creates a point selection using floating point coordinates. */
+	public static void makePoint(double x, double y) {
+		ImagePlus img = getImage();
+		Roi roi = img.getRoi();
+		if (shiftKeyDown() && roi!=null && roi.getType()==Roi.POINT) {
+			Polygon p = roi.getPolygon();
+			p.addPoint((int)Math.round(x), (int)Math.round(y));
+			img.setRoi(new PointRoi(p.xpoints, p.ypoints, p.npoints));
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);
+		} else if (altKeyDown() && roi!=null && roi.getType()==Roi.POINT) {
+			((PolygonRoi)roi).deleteHandle(x, y);
+			IJ.setKeyUp(KeyEvent.VK_ALT);
+		} else
+			img.setRoi(new PointRoi(x, y));
+	}
+
+	/** Creates an Roi. */
+	public static Roi Roi(double x, double y, double width, double height) {
+		return new Roi(x, y, width, height);
+	}
+
+	/** Creates an OvalRoi. */
+	public static OvalRoi OvalRoi(double x, double y, double width, double height) {
+		return new OvalRoi(x, y, width, height);
+	}
+
+	/** Sets the display range (minimum and maximum displayed pixel values) of the current image. */
+	public static void setMinAndMax(double min, double max) {
+		setMinAndMax(getImage(), min, max, 7);
+	}
+
+	/** Sets the display range (minimum and maximum displayed pixel values) of the specified image. */
+	public static void setMinAndMax(ImagePlus img, double min, double max) {
+		setMinAndMax(img, min, max, 7);
+	}
+
+	/** Sets the minimum and maximum displayed pixel values on the specified RGB
+	channels, where 4=red, 2=green and 1=blue. */
+	public static void setMinAndMax(double min, double max, int channels) {
+		setMinAndMax(getImage(), min, max, channels);
+	}
+
+	private static void setMinAndMax(ImagePlus img, double min, double max, int channels) {
+		Calibration cal = img.getCalibration();
+		min = cal.getRawValue(min); 
+		max = cal.getRawValue(max);
+		if (channels==7)
+			img.setDisplayRange(min, max);
+		else
+			img.setDisplayRange(min, max, channels);
+		img.updateAndDraw();
+	}
+
+	/** Resets the minimum and maximum displayed pixel values of the
+		current image to be the same as the min and max pixel values. */
+	public static void resetMinAndMax() {
+		resetMinAndMax(getImage());
+	}
+
+	/** Resets the minimum and maximum displayed pixel values of the
+		specified image to be the same as the min and max pixel values. */
+	public static void resetMinAndMax(ImagePlus img) {
+		img.resetDisplayRange();
+		img.updateAndDraw();
+	}
+
+	/** Sets the lower and upper threshold levels and displays the image 
+		using red to highlight thresholded pixels. May not work correctly on
+		16 and 32 bit images unless the display range has been reset using IJ.resetMinAndMax().
+	*/
+	public static void setThreshold(double lowerThreshold, double upperThresold) {
+		setThreshold(lowerThreshold, upperThresold, null);
+	}
+	
+	/** Sets the lower and upper threshold levels and displays the image using
+		the specified <code>displayMode</code> ("Red", "Black & White", "Over/Under" or "No Update"). */
+	public static void setThreshold(double lowerThreshold, double upperThreshold, String displayMode) {
+		setThreshold(getImage(), lowerThreshold, upperThreshold, displayMode);
+	}
+
+	/** Sets the lower and upper threshold levels of the specified image. */
+	public static void setThreshold(ImagePlus img, double lowerThreshold, double upperThreshold) {
+		setThreshold(img, lowerThreshold, upperThreshold, "Red");
+	}
+
+	/** Sets the lower and upper threshold levels of the specified image and updates the display using
+		the specified <code>displayMode</code> ("Red", "Black & White", "Over/Under" or "No Update").
+		With calibrated images, 'lowerThreshold' and 'upperThreshold' must be density calibrated values.
+		Use setRawThreshold() to set the threshold using raw (uncalibrated) values. */
+	public static void setThreshold(ImagePlus img, double lowerThreshold, double upperThreshold, String displayMode) {
+		Calibration cal = img.getCalibration();
+		if (displayMode==null || !displayMode.contains("raw")) {
+			lowerThreshold = cal.getRawValue(lowerThreshold); 
+			upperThreshold = cal.getRawValue(upperThreshold);
+		}
+		setRawThreshold(img, lowerThreshold, upperThreshold, displayMode);
+	}
+
+	/** This is a version of setThreshold() that always uses raw (uncalibrated) values
+		 in the range 0-255 for 8-bit images and 0-65535 for 16-bit images. */
+	public static void setRawThreshold(ImagePlus img, double lowerThreshold, double upperThreshold, String displayMode) {
+		int mode = ImageProcessor.RED_LUT;
+		if (displayMode!=null) {
+			displayMode = displayMode.toLowerCase(Locale.US);
+			if (displayMode.contains("black"))
+				mode = ImageProcessor.BLACK_AND_WHITE_LUT;
+			else if (displayMode.contains("over"))
+				mode = ImageProcessor.OVER_UNDER_LUT;
+			else if (displayMode.contains("no"))
+				mode = ImageProcessor.NO_LUT_UPDATE;
+		}
+		img.getProcessor().setThreshold(lowerThreshold, upperThreshold, mode);
+		if (mode!=ImageProcessor.NO_LUT_UPDATE && img.getWindow()!=null) {
+			img.getProcessor().setLutAnimation(true);
+			img.updateAndDraw();
+			ThresholdAdjuster.update();
+		}
+	}
+
+	public static void setAutoThreshold(ImagePlus imp, String method) {
+		ImageProcessor ip = imp.getProcessor();
+		if (ip instanceof ColorProcessor)
+			throw new IllegalArgumentException("Non-RGB image required");
+		ip.setRoi(imp.getRoi());
+		if (method!=null) {
+			try {
+				if (method.indexOf("stack")!=-1)
+					setStackThreshold(imp, ip, method);
+				else
+					ip.setAutoThreshold(method);
+			} catch (Exception e) {
+				log(e.getMessage());
+			}
+		} else
+			ip.setAutoThreshold(ImageProcessor.ISODATA2, ImageProcessor.RED_LUT);
+		imp.updateAndDraw();
+	}
+	
+	private static void setStackThreshold(ImagePlus imp, ImageProcessor ip, String method) {
+		boolean darkBackground = method.indexOf("dark")!=-1;
+		int measurements = Analyzer.getMeasurements();
+		Analyzer.setMeasurements(Measurements.AREA+Measurements.MIN_MAX);
+		ImageStatistics stats = new StackStatistics(imp);
+		Analyzer.setMeasurements(measurements);
+		AutoThresholder thresholder = new AutoThresholder();
+		double min=0.0, max=255.0;
+		if (imp.getBitDepth()!=8) {
+			min = stats.min;
+			max = stats.max;
+		}
+		int threshold = thresholder.getThreshold(method, stats.histogram);
+		double lower, upper;
+		if (darkBackground) {
+			if (ip.isInvertedLut())
+				{lower=0.0; upper=threshold;}
+			else
+				{lower=threshold+1; upper=255.0;}
+		} else {
+			if (ip.isInvertedLut())
+				{lower=threshold+1; upper=255.0;}
+			else
+				{lower=0.0; upper=threshold;}
+		}
+		if (lower>255) lower = 255;
+		if (max>min) {
+			lower = min + (lower/255.0)*(max-min);
+			upper = min + (upper/255.0)*(max-min);
+		} else
+			lower = upper = min;
+		ip.setMinAndMax(min, max);
+		ip.setThreshold(lower, upper, ImageProcessor.RED_LUT);
+		imp.updateAndDraw();
+	}
+
+	/** Disables thresholding on the current image. */
+	public static void resetThreshold() {
+		resetThreshold(getImage());
+	}
+	
+	/** Disables thresholding on the specified image. */
+	public static void resetThreshold(ImagePlus img) {
+		ImageProcessor ip = img.getProcessor();
+		ip.resetThreshold();
+		ip.setLutAnimation(true);
+		img.updateAndDraw();
+		ThresholdAdjuster.update();
+	}
+	
+	/** For IDs less than zero, activates the image with the specified ID.
+		For IDs greater than zero, activates the Nth image. */
+	public static void selectWindow(int id) {
+		if (id>0)
+			id = WindowManager.getNthImageID(id);
+		ImagePlus imp = WindowManager.getImage(id);
+		if (imp==null)
+			error("Macro Error", "Image "+id+" not found or no images are open.");
+		if (Interpreter.isBatchMode()) {
+			ImagePlus impT = WindowManager.getTempCurrentImage();
+			ImagePlus impC = WindowManager.getCurrentImage();
+			if (impC!=null && impC!=imp && impT!=null)
+				impC.saveRoi();
+            WindowManager.setTempCurrentImage(imp);
+            Interpreter.activateImage(imp);
+            WindowManager.setWindow(null);
+		} else {
+			if (imp==null)
+				return;
+			ImageWindow win = imp.getWindow();
+			if (win!=null) {
+				win.toFront();
+				win.setState(Frame.NORMAL);
+				WindowManager.setWindow(win);
+			}
+			long start = System.currentTimeMillis();
+			// timeout after 1 second unless current thread is event dispatch thread
+			String thread = Thread.currentThread().getName();
+			int timeout = thread!=null&&thread.indexOf("EventQueue")!=-1?0:1000;
+			if (IJ.isMacOSX() && IJ.isJava18() && timeout>0)
+				timeout = 250;  //work around OS X/Java 8 window activation bug
+			while (true) {
+				wait(10);
+				imp = WindowManager.getCurrentImage();
+				if (imp!=null && imp.getID()==id)
+					return; // specified image is now active
+				if ((System.currentTimeMillis()-start)>timeout && win!=null) {
+					WindowManager.setCurrentWindow(win);
+					return;
+				}
+			}
+		}
+	}
+
+	/** Activates the window with the specified title. */
+	public static void selectWindow(String title) {
+		if (title.equals("ImageJ")&&ij!=null) {
+			ij.toFront();
+			return;
+		}
+		long start = System.currentTimeMillis();
+		while (System.currentTimeMillis()-start<3000) { // 3 sec timeout
+			Window win = WindowManager.getWindow(title);
+			if (win!=null && !(win instanceof ImageWindow)) {
+				selectWindow(win);
+				return;
+			}
+			int[] wList = WindowManager.getIDList();
+			int len = wList!=null?wList.length:0;
+			for (int i=0; i<len; i++) {
+				ImagePlus imp = WindowManager.getImage(wList[i]);
+				if (imp!=null) {
+					if (imp.getTitle().equals(title)) {
+						selectWindow(imp.getID());
+						return;
+					}
+				}
+			}
+			wait(10);
+		}
+		error("Macro Error", "No window with the title \""+title+"\" found.");
+	}
+	
+	static void selectWindow(Window win) {
+		if (win instanceof Frame) {
+			((Frame)win).toFront();
+			((Frame)win).setState(Frame.NORMAL);
+		} else
+			((Dialog)win).toFront();
+		long start = System.currentTimeMillis();
+		while (true) {
+			wait(10);
+			if (WindowManager.getActiveWindow()==win)
+				return; // specified window is now in front
+			if ((System.currentTimeMillis()-start)>1000) {
+				WindowManager.setWindow(win);
+				return;   // 1 second timeout
+			}
+		}
+	}
+	
+	/** Sets the foreground color. */
+	public static void setForegroundColor(int red, int green, int blue) {
+		setColor(red, green, blue, true);
+	}
+
+	/** Sets the background color. */
+	public static void setBackgroundColor(int red, int green, int blue) {
+		setColor(red, green, blue, false);
+	}
+	
+	static void setColor(int red, int green, int blue, boolean foreground) {
+		Color c = Colors.toColor(red, green, blue);
+		if (foreground) {
+			Toolbar.setForegroundColor(c);
+			ImagePlus img = WindowManager.getCurrentImage();
+			if (img!=null)
+				img.getProcessor().setColor(c);
+		} else
+			Toolbar.setBackgroundColor(c);
+	}
+
+	/** Switches to the specified tool, where id = Toolbar.RECTANGLE (0),
+		Toolbar.OVAL (1), etc. */
+	public static void setTool(int id) {
+		Toolbar.getInstance().setTool(id);
+	}
+
+	/** Switches to the specified tool, where 'name' is "rect", "elliptical", 
+		"brush", etc. Returns 'false' if the name is not recognized. */
+	public static boolean setTool(String name) {
+		return Toolbar.getInstance().setTool(name);
+	}
+
+	/** Returns the name of the current tool. */
+	public static String getToolName() {
+		return Toolbar.getToolName();
+	}
+
+	/** Equivalent to clicking on the current image at (x,y) with the
+		wand tool. Returns the number of points in the resulting ROI. */
+	public static int doWand(int x, int y) {
+		return doWand(getImage(), x, y, 0, null);
+	}
+
+	/** Traces the boundary of the area with pixel values within
+	* 'tolerance' of the value of the pixel at the starting location.
+	* 'tolerance' is in uncalibrated units.
+	* 'mode' can be "4-connected", "8-connected" or "Legacy".
+	* "Legacy" is for compatibility with previous versions of ImageJ;
+	* it is ignored if 'tolerance' > 0.
+	*/
+	public static int doWand(int x, int y, double tolerance, String mode) {
+		return doWand(getImage(), x, y, tolerance, mode);
+	}
+	
+	/** This version of doWand adds an ImagePlus argument. */
+	public static int doWand(ImagePlus img, int x, int y, double tolerance, String mode) {
+		ImageProcessor ip = img.getProcessor();
+		if ((img.getType()==ImagePlus.GRAY32) && Double.isNaN(ip.getPixelValue(x,y)))
+			return 0;
+		int imode = Wand.LEGACY_MODE;
+		boolean smooth = false;
+		if (mode!=null) {
+			if (mode.startsWith("4"))
+				imode = Wand.FOUR_CONNECTED;
+			else if (mode.startsWith("8"))
+				imode = Wand.EIGHT_CONNECTED;
+			smooth = mode.contains("smooth");
+				
+		}
+		Wand w = new Wand(ip);
+		double t1 = ip.getMinThreshold();
+		if (t1==ImageProcessor.NO_THRESHOLD || (ip.getLutUpdateMode()==ImageProcessor.NO_LUT_UPDATE&& tolerance>0.0)) {
+			w.autoOutline(x, y, tolerance, imode);
+			smooth = false;
+		} else
+			w.autoOutline(x, y, t1, ip.getMaxThreshold(), imode);
+		if (w.npoints>0) {
+			Roi previousRoi = img.getRoi();
+			Roi roi = new PolygonRoi(w.xpoints, w.ypoints, w.npoints, Roi.TRACED_ROI);
+			img.deleteRoi();
+			img.setRoi(roi);			
+			if (previousRoi!=null)
+				roi.update(shiftKeyDown(), altKeyDown());  // add/subtract ROI to previous one if shift/alt key down
+			Roi roi2 = img.getRoi();
+			if (smooth && roi2!=null && roi2.getType()==Roi.TRACED_ROI) {
+				Rectangle bounds = roi2.getBounds();
+				if (bounds.width>1 && bounds.height>1) {
+					if (smoothMacro==null)
+						smoothMacro = BatchProcessor.openMacroFromJar("SmoothWandTool.txt");
+					if (EventQueue.isDispatchThread())
+						new MacroRunner(smoothMacro); // run on separate thread
+					else
+						Macro.eval(smoothMacro);
+				}
+			}
+		}
+		return w.npoints;
+	}
+	
+	/** Sets the transfer mode used by the <i>Edit/Paste</i> command, where mode is "Copy", "Blend", "Average", "Difference", 
+		"Transparent", "Transparent2", "AND", "OR", "XOR", "Add", "Subtract", "Multiply", or "Divide". */
+	public static void setPasteMode(String mode) {
+		Roi.setPasteMode(stringToPasteMode(mode));
+	}
+
+	public static int stringToPasteMode(String mode) {
+		if (mode==null)
+			return Blitter.COPY;
+		mode = mode.toLowerCase(Locale.US);
+		int m = Blitter.COPY;
+		if (mode.startsWith("ble") || mode.startsWith("ave"))
+			m = Blitter.AVERAGE;
+		else if (mode.startsWith("diff"))
+			m = Blitter.DIFFERENCE;
+		else if (mode.indexOf("zero")!=-1)
+			m = Blitter.COPY_ZERO_TRANSPARENT;
+		else if (mode.startsWith("tran"))
+			m = Blitter.COPY_TRANSPARENT;
+		else if (mode.startsWith("and"))
+			m = Blitter.AND;
+		else if (mode.startsWith("or"))
+			m = Blitter.OR;
+		else if (mode.startsWith("xor"))
+			m = Blitter.XOR;
+		else if (mode.startsWith("sub"))
+			m = Blitter.SUBTRACT;
+		else if (mode.startsWith("add"))
+			m = Blitter.ADD;
+		else if (mode.startsWith("div"))
+			m = Blitter.DIVIDE;
+		else if (mode.startsWith("mul"))
+			m = Blitter.MULTIPLY;
+		else if (mode.startsWith("min"))
+			m = Blitter.MIN;
+		else if (mode.startsWith("max"))
+			m = Blitter.MAX;
+		return m;
+	}
+
+	/** Returns a reference to the active image, or displays an error
+		message and aborts the plugin or macro if no images are open. */
+	public static ImagePlus getImage() {
+		ImagePlus img = WindowManager.getCurrentImage();
+		if (img==null) {
+			IJ.noImage();
+			if (ij==null)
+				System.exit(0);
+			else
+				abort();
+		}
+		return img;
+	}
+	
+	/**The macro interpreter uses this method to call getImage().*/
+	public static ImagePlus getImage(Interpreter interpreter) {
+		macroInterpreter = interpreter;
+		ImagePlus imp =  getImage();
+		macroInterpreter = null;
+		return imp;
+	}
+	
+	/** Returns the active image or stack slice as an ImageProcessor, or displays
+		an error message and aborts the plugin or macro if no images are open. */
+	public static ImageProcessor getProcessor() {
+		ImagePlus imp = IJ.getImage();
+		return imp.getProcessor();
+	}
+
+	/** Switches to the specified stack slice, where 1<='slice'<=stack-size. */
+	public static void setSlice(int slice) {
+		getImage().setSlice(slice);
+	}
+
+	/** Returns the ImageJ version number as a string. */
+	public static String getVersion() {
+		return ImageJ.VERSION;
+	}
+	
+	/** Returns the ImageJ version and build number as a String, for 
+		example "1.46n05", or 1.46n99 if there is no build number. */
+	public static String getFullVersion() {
+		String build = ImageJ.BUILD;
+		if (build.length()==0)
+			build = "99";
+		else if (build.length()==1)
+			build = "0" + build;
+		return ImageJ.VERSION+build;
+	}
+		
+	/** Returns the path to the specified directory if <code>title</code> is
+		"home" ("user.home"), "downloads", "startup",  "imagej" (ImageJ directory),
+		"plugins", "macros", "luts", "temp", "current", "default",
+		"image" (directory active image was loaded from), "file" 
+		(directory most recently used to open or save a file) or "cwd"
+		(current working directory), otherwise displays a dialog and
+		returns the path to the directory selected by the user. Returns
+		null if the specified directory is not found or the user cancels the
+		dialog box. Also aborts the macro if the user cancels the
+		dialog box.*/
+	public static String getDirectory(String title) {
+		String dir = null;
+		String title2 = title.toLowerCase(Locale.US);
+		if (title2.equals("plugins"))
+			dir = Menus.getPlugInsPath();
+		else if (title2.equals("macros"))
+			dir = Menus.getMacrosPath();
+		else if (title2.equals("luts")) {
+			String ijdir = Prefs.getImageJDir();
+			if (ijdir!=null)
+				dir = ijdir + "luts" + File.separator;
+			else
+				dir = null;
+		} else if (title2.equals("home"))
+			dir = System.getProperty("user.home");
+		else if (title2.equals("downloads"))
+			dir = System.getProperty("user.home")+File.separator+"Downloads";
+		else if (title2.equals("startup"))
+			dir = Prefs.getImageJDir();
+		else if (title2.equals("imagej"))
+			dir = Prefs.getImageJDir();
+		else if (title2.equals("current") || title2.equals("default"))
+			dir = OpenDialog.getDefaultDirectory();
+		else if (title2.equals("temp")) {
+			dir = System.getProperty("java.io.tmpdir");
+			if (isMacintosh()) dir = "/tmp/";
+		} else if (title2.equals("image")) {
+			ImagePlus imp = WindowManager.getCurrentImage();
+			FileInfo fi = imp!=null?imp.getOriginalFileInfo():null;
+			if (fi!=null && fi.directory!=null) {
+				dir = fi.directory;
+			} else
+				dir = null;
+		} else if (title2.equals("file"))
+			dir = OpenDialog.getLastDirectory();
+		else if (title2.equals("cwd"))
+			dir = System.getProperty("user.dir");
+		else {
+			DirectoryChooser dc = new DirectoryChooser(title);
+			dir = dc.getDirectory();
+			if (dir==null) Macro.abort();
+		}
+		dir = addSeparator(dir);
+		return dir;
+	}
+	
+	public static String addSeparator(String path) {
+		if (path==null)
+			return null;
+		if (path.length()>0 && !(path.endsWith(File.separator)||path.endsWith("/"))) {
+			if (IJ.isWindows()&&path.contains(File.separator))
+				path += File.separator;
+			else
+				path += "/";
+		}
+		return path;
+	}
+		
+	/** Alias for getDirectory(). */
+	public static String getDir(String title) {
+		return getDirectory(title);
+	}
+
+	
+	/** Displays an open file dialog and returns the path to the
+		choosen file, or returns null if the dialog is canceled. */
+	public static String getFilePath(String dialogTitle) {
+		OpenDialog od = new OpenDialog(dialogTitle);
+		return od.getPath();
+	}
+		
+	/** Displays a file open dialog box and then opens the tiff, dicom, 
+		fits, pgm, jpeg, bmp, gif, lut, roi, or text file selected by 
+		the user. Displays an error message if the selected file is not
+		in one of the supported formats, or if it is not found. */
+	public static void open() {
+		open(null);
+	}
+
+	/** Opens and displays a tiff, dicom, fits, pgm, jpeg, bmp, gif, lut, 
+		roi, or text file. Displays an error message if the specified file
+		is not in one of the supported formats, or if it is not found.
+		With 1.41k or later, opens images specified by a URL.
+		*/
+	public static void open(String path) {
+		if (ij==null && Menus.getCommands()==null)
+			init();
+		Opener o = new Opener();
+		macroRunning = true;
+		if (path==null || path.equals(""))		
+			o.open();
+		else
+			o.open(path);
+		macroRunning = false;
+	}
+		
+	/** Opens and displays the nth image in the specified tiff stack. */
+	public static void open(String path, int n) {
+		if (ij==null && Menus.getCommands()==null)
+			init();
+		ImagePlus imp = openImage(path, n);
+		if (imp!=null) imp.show();
+	}
+
+	/** Opens the specified file as a tiff, bmp, dicom, fits, pgm, gif, jpeg 
+		or text image and returns an ImagePlus object if successful.
+		Calls HandleExtraFileTypes plugin if the file type is not recognised.
+		Displays a file open dialog if 'path' is null or an empty string.
+		Note that 'path' can also be a URL. Some reader plugins, including
+		the Bio-Formats plugin, display the image and return null.
+		Use IJ.open() to display a file open dialog box.
+	*/
+	public static ImagePlus openImage(String path) {
+		macroRunning = true;
+		ImagePlus imp = (new Opener()).openImage(path);
+		macroRunning = false;
+		return imp;
+	}
+
+	/** Opens the nth image of the specified tiff stack. */
+	public static ImagePlus openImage(String path, int n) {
+		return (new Opener()).openImage(path, n);
+	}
+
+	/** Opens the specified tiff file as a virtual stack. */
+	public static ImagePlus openVirtual(String path) {
+		return FileInfoVirtualStack.openVirtual(path);
+	}
+
+	/** Opens an image using a file open dialog and returns it as an ImagePlus object. */
+	public static ImagePlus openImage() {
+		return openImage(null);
+	}
+
+	/** Opens a URL and returns the contents as a string.
+		Returns "<Error: message>" if there an error, including
+		host or file not found. */
+	public static String openUrlAsString(String url) {
+		//if (!trustManagerCreated && url.contains("nih.gov")) trustAllCerts();
+		url = Opener.updateUrl(url);
+		if (debugMode) log("OpenUrlAsString: "+url);
+		StringBuffer sb = null;
+		url = url.replaceAll(" ", "%20");
+		try {
+			//if (url.contains("nih.gov")) addRootCA();
+			URL u = new URL(url);
+			URLConnection uc = u.openConnection();
+			long len = uc.getContentLength();
+			if (len>5242880L)
+				return "<Error: file is larger than 5MB>";
+			InputStream in = u.openStream();
+			BufferedReader br = new BufferedReader(new InputStreamReader(in));
+			sb = new StringBuffer() ;
+			String line;
+			while ((line=br.readLine()) != null)
+				sb.append (line + "\n");
+			in.close ();
+		} catch (Exception e) {
+			return("<Error: "+e+">");
+		}
+		if (sb!=null)
+			return new String(sb);
+		else
+			return "";
+	}
+	
+	/* 
+	public static void addRootCA() throws Exception {
+		String path = "/Users/wayne/Downloads/Certificates/lets-encrypt-x1-cross-signed.pem";
+		InputStream fis = new BufferedInputStream(new FileInputStream(path));
+		Certificate ca = CertificateFactory.getInstance("X.509").generateCertificate(fis);
+		KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
+		ks.load(null, null);
+		ks.setCertificateEntry(Integer.toString(1), ca);
+		TrustManagerFactory tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+		tmf.init(ks);
+		SSLContext ctx = SSLContext.getInstance("TLS");
+		ctx.init(null, tmf.getTrustManagers(), null); 
+		HttpsURLConnection.setDefaultSSLSocketFactory(ctx.getSocketFactory());
+	}
+	*/
+	
+	/*
+	// Create a new trust manager that trust all certificates
+	// http://stackoverflow.com/questions/10135074/download-file-from-https-server-using-java
+	private static void trustAllCerts() {
+		trustManagerCreated = true;
+		TrustManager[] trustAllCerts = new TrustManager[] {
+			new X509TrustManager() {
+				public java.security.cert.X509Certificate[] getAcceptedIssuers() {
+					return null;
+				}
+				public void checkClientTrusted (java.security.cert.X509Certificate[] certs, String authType) {
+				}
+				public void checkServerTrusted (java.security.cert.X509Certificate[] certs, String authType) {
+				}
+			}
+		};
+		// Activate the new trust manager
+		try {
+			SSLContext sc = SSLContext.getInstance("SSL");
+			sc.init(null, trustAllCerts, new java.security.SecureRandom());
+			HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
+		} catch (Exception e) {
+			IJ.log(""+e);
+		}
+	}
+	*/
+
+	/** Saves the current image, lookup table, selection or text window to the specified file path. 
+		The path must end in ".tif", ".jpg", ".gif", ".zip", ".raw", ".avi", ".bmp", ".fits", ".pgm", ".png", ".lut", ".roi" or ".txt".  */
+	public static void save(String path) {
+		save(null, path);
+	}
+
+	/** Saves the specified image, lookup table or selection to the specified file path. 
+		The file path should end with ".tif", ".jpg", ".gif", ".zip", ".raw", ".avi", ".bmp", 
+		".fits", ".pgm", ".png", ".lut", ".roi" or ".txt". The specified image is saved in 
+		TIFF format if there is no extension. */
+	public static void save(ImagePlus imp, String path) {
+		ImagePlus imp2 = imp;
+		if (imp2==null)
+			imp2 = WindowManager.getCurrentImage();
+		int dotLoc = path.lastIndexOf('.');
+		if (dotLoc==-1 && imp2!=null) {
+			path = path + ".tif"; // save as TIFF if file name does not have an extension
+			dotLoc = path.lastIndexOf('.');
+		}
+		if (dotLoc!=-1) {
+			String title = imp2!=null?imp2.getTitle():null;
+			saveAs(imp, path.substring(dotLoc+1), path);
+			if (title!=null)
+				imp2.setTitle(title);
+		} else
+			error("The file path passed to IJ.save() method or save()\nmacro function is missing the required extension.\n \n\""+path+"\"");
+	}
+
+	/* Saves the active image, lookup table, selection, measurement results, selection XY 
+		coordinates or text window to the specified file path. The format argument must be "tiff", 
+		"jpeg", "gif", "zip", "raw", "avi", "bmp", "fits", "pgm", "png", "text image", "lut", "selection", "measurements", 
+		"xy Coordinates" or "text".  If <code>path</code> is null or an emply string, a file
+		save dialog is displayed. */
+ 	public static void saveAs(String format, String path) {
+ 		saveAs(null, format, path);
+ 	}
+
+	/* Saves the specified image. The format argument must be "tiff",  
+		"jpeg", "gif", "zip", "raw", "avi", "bmp", "fits", "pgm", "png", 
+		"text image", "lut", "selection" or "xy Coordinates". */
+ 	public static void saveAs(ImagePlus imp, String format, String path) {
+		if (format==null)
+			return;
+		if (path!=null && path.length()==0)
+			path = null;
+		format = format.toLowerCase(Locale.US);
+		Roi roi2 = imp!=null?imp.getRoi():null;
+		if (roi2!=null)
+			roi2.endPaste();
+		if (format.indexOf("tif")!=-1) {
+			saveAsTiff(imp, path);
+			return;
+		} else if (format.indexOf("jpeg")!=-1 || format.indexOf("jpg")!=-1) {
+			path = updateExtension(path, ".jpg");
+			JpegWriter.save(imp, path, FileSaver.getJpegQuality());
+			return;
+		} else if (format.indexOf("gif")!=-1) {
+			path = updateExtension(path, ".gif");
+			GifWriter.save(imp, path);
+			return;
+		} else if (format.indexOf("text image")!=-1) {
+			path = updateExtension(path, ".txt");
+			format = "Text Image...";
+		} else if (format.indexOf("text")!=-1 || format.indexOf("txt")!=-1) {
+			if (path!=null && !path.endsWith(".xls") && !path.endsWith(".csv") && !path.endsWith(".tsv"))
+				path = updateExtension(path, ".txt");
+			format = "Text...";
+		} else if (format.indexOf("zip")!=-1) {
+			path = updateExtension(path, ".zip");
+			format = "ZIP...";
+		} else if (format.indexOf("raw")!=-1) {
+			//path = updateExtension(path, ".raw");
+			format = "Raw Data...";
+		} else if (format.indexOf("avi")!=-1) {
+			path = updateExtension(path, ".avi");
+			format = "AVI... ";
+		} else if (format.indexOf("bmp")!=-1) {
+			path = updateExtension(path, ".bmp");
+			format = "BMP...";
+		} else if (format.indexOf("fits")!=-1) {
+			path = updateExtension(path, ".fits");
+			format = "FITS...";
+		} else if (format.indexOf("png")!=-1) {
+			path = updateExtension(path, ".png");
+			format = "PNG...";
+		} else if (format.indexOf("pgm")!=-1) {
+			path = updateExtension(path, ".pgm");
+			format = "PGM...";
+		} else if (format.indexOf("lut")!=-1) {
+			path = updateExtension(path, ".lut");
+			format = "LUT...";
+		} else if (format.contains("results") || format.contains("measurements") || format.contains("table")) {
+			format = "Results...";
+		} else if (format.contains("selection") || format.contains("roi")) {
+			path = updateExtension(path, ".roi");
+			format = "Selection...";
+		} else if (format.indexOf("xy")!=-1 || format.indexOf("coordinates")!=-1) {
+			path = updateExtension(path, ".txt");
+			format = "XY Coordinates...";
+		} else
+			error("Unsupported save() or saveAs() file format: \""+format+"\"\n \n\""+path+"\"");
+		if (path==null)
+			run(format);
+		else {
+			if (path.contains(" "))
+				run(imp, format, "save=["+path+"]");
+			else
+				run(imp, format, "save="+path);
+		}
+	}
+	
+	/** Saves the specified image in TIFF format. Displays a file save dialog
+		if 'path' is null or an empty string. Returns 'false' if there is an
+		error or if the user selects "Cancel" in the file save dialog. */
+	public static boolean saveAsTiff(ImagePlus imp, String path) {
+		if (imp==null)
+			imp = getImage();
+		if (path==null || path.equals(""))
+			return (new FileSaver(imp)).saveAsTiff();
+		if (!path.endsWith(".tiff"))
+			path = updateExtension(path, ".tif");
+		FileSaver fs = new FileSaver(imp);
+		boolean ok;
+		if (imp.getStackSize()>1)
+			ok = fs.saveAsTiffStack(path);
+		else
+			ok = fs.saveAsTiff(path);
+		if (ok)
+			fs.updateImagePlus(path, FileInfo.TIFF);
+		return ok;
+	}
+	
+	static String updateExtension(String path, String extension) {
+		if (path==null) return null;
+		int dotIndex = path.lastIndexOf(".");
+		int separatorIndex = path.lastIndexOf(File.separator);
+		if (dotIndex>=0 && dotIndex>separatorIndex && (path.length()-dotIndex)<=5) {
+			if (dotIndex+1<path.length() && Character.isDigit(path.charAt(dotIndex+1)))
+				path += extension;
+			else
+				path = path.substring(0, dotIndex) + extension;
+		} else
+			path += extension;
+		return path;
+	}
+	
+	/** Saves a string as a file. Displays a file save dialog if
+		'path' is null or blank. Returns an error message 
+		if there is an exception, otherwise returns null. */
+	public static String saveString(String string, String path) {
+		return write(string, path, false);
+	}
+
+	/** Appends a string to the end of a file. A newline character ("\n") 
+		is added to the end of the string before it is written. Returns an  
+		error message if there is an exception, otherwise returns null. */
+	public static String append(String string, String path) {
+		return write(string+"\n", path, true);
+	}
+
+	private static String write(String string, String path, boolean append) {
+		if (path==null || path.equals("")) {
+			String msg = append?"Append String...":"Save String...";
+			SaveDialog sd = new SaveDialog(msg, "Untitled", ".txt");
+			String name = sd.getFileName();
+			if (name==null) return null;
+			path = sd.getDirectory() + name;
+		}
+		try {
+			BufferedWriter out = new BufferedWriter(new FileWriter(path, append));
+			out.write(string);
+			out.close();
+		} catch (IOException e) {
+			return ""+e;
+		}
+		return null;
+	}
+
+	/** Opens a text file as a string. Displays a file open dialog
+		if path is null or blank. Returns null if the user cancels
+		the file open dialog. If there is an error, returns a 
+		 message in the form "Error: message". */
+	public static String openAsString(String path) {
+		if (path==null || path.equals("")) {
+			OpenDialog od = new OpenDialog("Open Text File", "");
+			String directory = od.getDirectory();
+			String name = od.getFileName();
+			if (name==null) return null;
+			path = directory + name;
+		}
+		String str = "";
+		File file = new File(path);
+		if (!file.exists())
+			return "Error: file not found";
+		try {
+			StringBuffer sb = new StringBuffer(5000);
+			BufferedReader r = new BufferedReader(new FileReader(file));
+			while (true) {
+				String s=r.readLine();
+				if (s==null)
+					break;
+				else
+					sb.append(s+"\n");
+			}
+			r.close();
+			str = new String(sb);
+		}
+		catch (Exception e) {
+			str = "Error: "+e.getMessage();
+		}
+		return str;
+	}
+	
+	public static ByteBuffer openAsByteBuffer(String path) {
+		if (path==null || path.equals("")) {
+			OpenDialog od = new OpenDialog("Open as ByteBuffer", "");
+			String directory = od.getDirectory();
+			String name = od.getFileName();
+			if (name==null) return null;
+			path = directory + name;
+		}
+		File file = new File(path);
+		if (!file.exists()) {
+			error("OpenAsByteBuffer", "File not found");
+			return null;
+		}
+		int len = (int)file.length();
+		byte[] buffer = new byte[len];
+		try {
+			InputStream in = new BufferedInputStream(new FileInputStream(path));
+			DataInputStream dis = new DataInputStream(in);
+			dis.readFully(buffer);
+			dis.close();
+		}
+		catch (Exception e) {
+			error("OpenAsByteBuffer", e.getMessage());
+			return null;
+		}
+		return ByteBuffer.wrap(buffer);
+	}
+
+	/** Creates a new image.
+	*  @param title   image name
+	*  @param width  image width in pixels
+	*  @param height image height in pixels
+	*  @param depth number of stack images
+	*  @param bitdepth  8, 16, 32 (float) or 24 (RGB)
+	*/
+	 public static ImagePlus createImage(String title, int width, int height, int depth, int bitdepth) {
+		return NewImage.createImage(title, width, height, depth, bitdepth, NewImage.FILL_BLACK);
+	 }
+
+	 /** Creates a new imagePlus. <code>Type</code> should contain "8-bit", "16-bit", "32-bit" or "RGB". 
+		 In addition, it can contain "white", "black" or "ramp". <code>Width</code> 
+	 	and <code>height</code> specify the width and height of the image in pixels.  
+	 	<code>Depth</code> specifies the number of stack slices. */
+	 public static ImagePlus createImage(String title, String type, int width, int height, int depth) {
+		type = type.toLowerCase(Locale.US);
+		int bitDepth = 8;
+		if (type.contains("16"))
+			bitDepth = 16;
+		boolean signedInt = type.contains("32-bit int");
+		if (type.contains("32"))
+			bitDepth = 32;
+		if (type.contains("24") || type.contains("rgb") || signedInt)
+			bitDepth = 24;
+		int options = NewImage.FILL_WHITE;
+		if (bitDepth==16 || bitDepth==32)
+			options = NewImage.FILL_BLACK;
+		if (type.contains("white"))
+			options = NewImage.FILL_WHITE;
+		else if (type.contains("black"))
+			options = NewImage.FILL_BLACK;
+		else if (type.contains("ramp"))
+			options = NewImage.FILL_RAMP;
+		else if (type.contains("noise") || type.contains("random"))
+			options = NewImage.FILL_NOISE;
+		options += NewImage.CHECK_AVAILABLE_MEMORY;
+		if (signedInt)
+			options += NewImage.SIGNED_INT;
+		return NewImage.createImage(title, width, height, depth, bitDepth, options);
+	}
+
+	/** Creates a new hyperstack.
+	* @param title   image name
+	* @param type  "8-bit", "16-bit", "32-bit" or "RGB".  May also
+	* contain "white" , "black" (the default), "ramp", "composite-mode",
+	* "color-mode", "grayscale-mode or "label".
+	* @param width  image width in pixels
+	* @param height image height in pixels
+	* @param channels number of channels
+	* @param slices number of slices
+	* @param frames number of frames
+	*/
+	 public static ImagePlus createImage(String title, String type, int width, int height, int channels, int slices, int frames) {
+		if (type.contains("label"))
+	 		type += "ramp";
+		if (!(type.contains("white")||type.contains("ramp")))
+	 		type += "black";
+		ImagePlus imp = IJ.createImage(title, type, width, height, channels*slices*frames);
+		imp.setDimensions(channels, slices, frames);
+		int mode = IJ.COLOR;
+		if (type.contains("composite"))
+			mode = IJ.COMPOSITE;
+		if (type.contains("grayscale"))
+			mode = IJ.GRAYSCALE;
+		if (channels>1 && imp.getBitDepth()!=24)
+			imp = new CompositeImage(imp, mode);
+		imp.setOpenAsHyperStack(true);
+		if (type.contains("label"))
+			HyperStackMaker.labelHyperstack(imp);
+		return imp;
+	 }
+
+	/** Creates a new hyperstack.
+	*  @param title   image name
+	*  @param width  image width in pixels
+	*  @param height image height in pixels
+	*  @param channels number of channels
+	*  @param slices number of slices
+	*  @param frames number of frames
+	*  @param bitdepth  8, 16, 32 (float) or 24 (RGB)
+	*/
+	 public static ImagePlus createHyperStack(String title, int width, int height, int channels, int slices, int frames, int bitdepth) {
+		ImagePlus imp = createImage(title, width, height, channels*slices*frames, bitdepth);
+		imp.setDimensions(channels, slices, frames);
+		if (channels>1 && bitdepth!=24)
+			imp = new CompositeImage(imp, IJ.COMPOSITE);
+		imp.setOpenAsHyperStack(true);
+		return imp;
+	 }
+	 
+	 /** Opens a new image. <code>Type</code> should contain "8-bit", "16-bit", "32-bit" or "RGB". 
+		In addition, it can contain "white", "black" or "ramp". <code>Width</code> 
+		and <code>height</code> specify the width and height of the image in pixels.  
+		<code>Depth</code> specifies the number of stack slices. */
+	public static void newImage(String title, String type, int width, int height, int depth) {
+		ImagePlus imp = createImage(title, type, width, height, depth);
+		if (imp!=null) {
+			macroRunning = true;
+			imp.show();
+			macroRunning = false;
+		}
+	}
+
+	/** Returns true if the <code>Esc</code> key was pressed since the
+		last ImageJ command started to execute or since resetEscape() was called. */
+	public static boolean escapePressed() {
+		return escapePressed;
+	}
+
+	/** This method sets the <code>Esc</code> key to the "up" position.
+		The Executer class calls this method when it runs 
+		an ImageJ command in a separate thread. */
+	public static void resetEscape() {
+		escapePressed = false;
+	}
+	
+	/** Causes IJ.error() output to be temporarily redirected to the "Log" window. */
+	public static void redirectErrorMessages() {
+		redirectErrorMessages = true;
+		lastErrorMessage = null;
+	}
+	
+	/** Set 'true' and IJ.error() output will be temporarily redirected to the "Log" window. */
+	public static void redirectErrorMessages(boolean redirect) {
+		redirectErrorMessages = redirect;
+		lastErrorMessage = null;
+	}
+
+	/** Returns the state of the  'redirectErrorMessages' flag, which is set by File/Import/Image Sequence. */
+	public static boolean redirectingErrorMessages() {
+		return redirectErrorMessages;
+	}
+
+	/** Temporarily suppress "plugin not found" errors. */
+	public static void suppressPluginNotFoundError() {
+		suppressPluginNotFoundError = true;
+	}
+
+	/** Returns the class loader ImageJ uses to run plugins or the
+		system class loader if Menus.getPlugInsPath() returns null. */
+	public static ClassLoader getClassLoader() {
+		if (classLoader==null) {
+			String pluginsDir = Menus.getPlugInsPath();
+			if (pluginsDir==null) {
+				String home = System.getProperty("plugins.dir");
+				if (home!=null) {
+					if (!home.endsWith(Prefs.separator)) home+=Prefs.separator;
+					pluginsDir = home+"plugins"+Prefs.separator;
+					if (!(new File(pluginsDir)).isDirectory())
+						pluginsDir = home;
+				}
+			}
+			if (pluginsDir==null)
+				return IJ.class.getClassLoader();
+			else {
+				if (Menus.jnlp)
+					classLoader = new PluginClassLoader(pluginsDir, true);
+				else
+					classLoader = new PluginClassLoader(pluginsDir);
+			}
+		}
+		return classLoader;
+	}
+	
+	/** Returns the size, in pixels, of the primary display. */
+	public static Dimension getScreenSize() {
+		Rectangle bounds = GUI.getScreenBounds();
+		return new Dimension(bounds.width, bounds.height);
+	}
+	
+	/** Returns, as an array of strings, a list of the LUTs in the 
+	 * Image/Lookup Tables menu.
+	 * @see ij.plugin#LutLoader.getLut
+	 * See also: Help>Examples>JavaScript/Show all LUTs
+	 * and Image/Color/Display LUTs
+	*/
+	public static String[] getLuts() {
+		ArrayList list = new ArrayList();
+		Hashtable commands = Menus.getCommands();
+		Menu lutsMenu = Menus.getImageJMenu("Image>Lookup Tables");
+		if (commands==null || lutsMenu==null)
+			return new String[0];
+		for (int i=0; i<lutsMenu.getItemCount(); i++) {
+			MenuItem menuItem = lutsMenu.getItem(i);
+			String label = menuItem.getLabel();
+			if (label.equals("-") || label.equals("Invert LUT") || label.equals("Apply LUT"))
+				continue;
+			String command = (String)commands.get(label);
+			if (command==null || command.startsWith("ij.plugin.LutLoader"))
+				list.add(label);
+		}
+		return (String[])list.toArray(new String[list.size()]);
+	}
+	
+	static void abort() {
+		if ((ij!=null || Interpreter.isBatchMode()) && macroInterpreter==null)
+			throw new RuntimeException(Macro.MACRO_CANCELED);
+	}
+	
+	static void setClassLoader(ClassLoader loader) {
+		classLoader = loader;
+	}
+
+	public static void resetClassLoader() {
+		setClassLoader(null);
+	}
+
+	/** Displays a stack trace. Use the setExceptionHandler 
+		method() to override with a custom exception handler. */
+	public static void handleException(Throwable e) {
+		if (exceptionHandler!=null) {
+			exceptionHandler.handle(e);
+			return;
+		}
+		if (Macro.MACRO_CANCELED.equals(e.getMessage()))
+			return;
+		CharArrayWriter caw = new CharArrayWriter();
+		PrintWriter pw = new PrintWriter(caw);
+		e.printStackTrace(pw);
+		String s = caw.toString();
+		if (s!=null && s.contains("ThreadDeath"))
+			return;
+		if (getInstance()!=null) {
+			s = IJ.getInstance().getInfo()+"\n \n"+s;
+			new TextWindow("Exception", s, 500, 340);
+		} else
+			log(s);
+	}
+
+	/** Installs a custom exception handler that 
+		overrides the handleException() method. */
+	public static void setExceptionHandler(ExceptionHandler handler) {
+		exceptionHandler = handler;
+	}
+
+	public interface ExceptionHandler {
+		public void handle(Throwable e);
+	}
+
+	static ExceptionHandler exceptionHandler;
+
+	public static void addEventListener(IJEventListener listener) {
+		eventListeners.addElement(listener);
+	}
+	
+	public static void removeEventListener(IJEventListener listener) {
+		eventListeners.removeElement(listener);
+	}
+	
+	public static void notifyEventListeners(int eventID) {
+		synchronized (eventListeners) {
+			for (int i=0; i<eventListeners.size(); i++) {
+				IJEventListener listener = (IJEventListener)eventListeners.elementAt(i);
+				listener.eventOccurred(eventID);
+			}
+		}
+	}
+
+	/** Adds a key-value pair to IJ.properties. The key
+	* and value are removed if 'value' is null.
+	*/
+	public static void setProperty(String key, Object value) {
+		if (properties==null)
+			properties = new Properties();
+		if (value==null)
+			properties.remove(key);
+		else
+			properties.put(key, value);
+	}
+
+	/** Returns the object in IJ.properties associated
+	*  with 'key', or null if 'key' is not found.
+	*/
+	public static Object getProperty(String key) {
+		if (properties==null)
+			return null;
+		else
+			return properties.get(key);
+	}
+	
+	public static boolean statusBarProtected() {
+		return protectStatusBar;
+	}
+	
+	public static void protectStatusBar(boolean protect) {
+		protectStatusBar = protect;
+		if (!protectStatusBar)
+			statusBarThread = null;
+	}
+
+}
diff --git a/src/ij/IJEventListener.java b/src/ij/IJEventListener.java
new file mode 100644
index 0000000..f5af9b5
--- /dev/null
+++ b/src/ij/IJEventListener.java
@@ -0,0 +1,17 @@
+package ij;
+
+	/** Plugins that implement this interface are notified when the user
+	     changes the foreground color, changes the background color,
+	     closes the color picker, closes the Log window or switches to
+	     another tool.
+	*/
+	public interface IJEventListener {
+		public static final int FOREGROUND_COLOR_CHANGED = 0;
+		public static final int BACKGROUND_COLOR_CHANGED = 1;
+		public static final int COLOR_PICKER_CLOSED= 2;
+		public static final int LOG_WINDOW_CLOSED= 3;
+		public static final int TOOL_CHANGED= 4;
+
+	public void eventOccurred(int eventID);
+
+}
diff --git a/src/ij/ImageJ.java b/src/ij/ImageJ.java
new file mode 100644
index 0000000..8f77e3f
--- /dev/null
+++ b/src/ij/ImageJ.java
@@ -0,0 +1,923 @@
+package ij;
+import ij.gui.*;
+import ij.process.*;
+import ij.io.*;
+import ij.plugin.*;
+import ij.plugin.filter.*;
+import ij.plugin.frame.*;
+import ij.text.*;
+import ij.macro.Interpreter;
+import ij.io.Opener;
+import ij.util.*;
+import java.awt.*;
+import java.util.*;
+import java.awt.event.*;
+import java.io.*;
+import java.net.*;
+import java.awt.image.*;
+import javax.swing.ImageIcon;
+import javax.swing.JLabel;
+import javax.swing.SwingUtilities;
+
+/**
+This frame is the main ImageJ class.
+<p>
+ImageJ is a work of the United States Government. It is in the public domain 
+and open source. There is no copyright. You are free to do anything you want
+with this source but I like to get credit for my work and I would like you to 
+offer your changes to me so I can possibly add them to the "official" version.
+
+<pre>
+The following command line options are recognized by ImageJ:
+
+  "file-name"
+     Opens a file
+     Example 1: blobs.tif
+     Example 2: /Users/wayne/images/blobs.tif
+     Example 3: e81*.tif
+
+  -macro path [arg]
+     Runs a macro or script (JavaScript, BeanShell or Python), passing an
+     optional string argument, which the macro or script can be retrieve
+     using the getArgument() function. The macro or script is assumed to 
+     be in the ImageJ/macros folder if 'path' is not a full directory path.
+     Example 1: -macro analyze.ijm
+     Example 2: -macro script.js /Users/wayne/images/stack1
+     Example 2: -macro script.py '1.2 2.4 3.8'
+
+  -batch path [arg]
+    Runs a macro or script (JavaScript, BeanShell or Python) in
+    batch (no GUI) mode, passing an optional argument.
+    ImageJ exits when the macro finishes.
+
+  -eval "macro code"
+     Evaluates macro code
+     Example 1: -eval "print('Hello, world');"
+     Example 2: -eval "return getVersion();"
+
+  -run command
+     Runs an ImageJ menu command
+     Example: -run "About ImageJ..."
+     
+  -ijpath path
+     Specifies the path to the directory containing the plugins directory
+     Example: -ijpath /Applications/ImageJ
+
+  -port<n>
+     Specifies the port ImageJ uses to determine if another instance is running
+     Example 1: -port1 (use default port address + 1)
+     Example 2: -port2 (use default port address + 2)
+     Example 3: -port0 (don't check for another instance)
+
+  -debug
+     Runs ImageJ in debug mode
+</pre>
+@author Wayne Rasband (rasband@gmail.com)
+*/
+public class ImageJ extends Frame implements ActionListener, 
+	MouseListener, KeyListener, WindowListener, ItemListener, Runnable {
+
+	/** Plugins should call IJ.getVersion() or IJ.getFullVersion() to get the version string. */
+	public static final String VERSION = "1.53n";
+	public static final String BUILD = ""; //28
+	public static Color backgroundColor = new Color(237,237,237);
+	/** SansSerif, 12-point, plain font. */
+	public static final Font SansSerif12 = new Font("SansSerif", Font.PLAIN, 12);
+	/** Address of socket where Image accepts commands */
+	public static final int DEFAULT_PORT = 57294;
+	
+	/** Run as normal application. */
+	public static final int STANDALONE = 0;
+	
+	/** Run embedded in another application. */
+	public static final int EMBEDDED = 1;
+	
+	/** Run embedded and invisible in another application. */
+	public static final int NO_SHOW = 2;
+	
+	/** Run ImageJ in debug mode. */
+	public static final int DEBUG = 256;
+
+	private static final String IJ_X="ij.x",IJ_Y="ij.y";
+	private static int port = DEFAULT_PORT;
+	private static String[] arguments;
+	
+	private Toolbar toolbar;
+	private Panel statusBar;
+	private ProgressBar progressBar;
+	private JLabel statusLine;
+	private boolean firstTime = true;
+	private java.applet.Applet applet; // null if not running as an applet
+	private Vector classes = new Vector();
+	private boolean exitWhenQuitting;
+	private boolean quitting;
+	private boolean quitMacro;
+	private long keyPressedTime, actionPerformedTime;
+	private String lastKeyCommand;
+	private boolean embedded;
+	private boolean windowClosed;
+	private static String commandName;
+	private static boolean batchMode;
+		
+	boolean hotkey;
+	
+	/** Creates a new ImageJ frame that runs as an application. */
+	public ImageJ() {
+		this(null, STANDALONE);
+	}
+	
+	/** Creates a new ImageJ frame that runs as an application in the specified mode. */
+	public ImageJ(int mode) {
+		this(null, mode);
+	}
+
+	/** Creates a new ImageJ frame that runs as an applet. */
+	public ImageJ(java.applet.Applet applet) {
+		this(applet, STANDALONE);
+	}
+
+	/** If 'applet' is not null, creates a new ImageJ frame that runs as an applet.
+		If  'mode' is ImageJ.EMBEDDED and 'applet is null, creates an embedded 
+		(non-standalone) version of ImageJ. */
+	public ImageJ(java.applet.Applet applet, int mode) {
+		super("ImageJ");
+		if ((mode&DEBUG)!=0)
+			IJ.setDebugMode(true);
+		mode = mode & 255;
+		if (IJ.debugMode) IJ.log("ImageJ starting in debug mode: "+mode);
+		embedded = applet==null && (mode==EMBEDDED||mode==NO_SHOW);
+		this.applet = applet;
+		String err1 = Prefs.load(this, applet);
+		setBackground(backgroundColor);
+		Menus m = new Menus(this, applet);
+		String err2 = m.addMenuBar();
+		m.installPopupMenu(this);
+		setLayout(new BorderLayout());
+		
+		// Tool bar
+		toolbar = new Toolbar();
+		toolbar.addKeyListener(this);
+		add("Center", toolbar);
+
+		// Status bar
+		statusBar = new Panel();
+		statusBar.setLayout(new BorderLayout());
+		statusBar.setForeground(Color.black);
+		statusBar.setBackground(backgroundColor);
+		statusLine = new JLabel();
+		double scale = Prefs.getGuiScale();
+		statusLine.setFont(new Font("SansSerif", Font.PLAIN, (int)(13*scale)));
+		statusLine.addKeyListener(this);
+		statusLine.addMouseListener(this);
+		statusBar.add("Center", statusLine);
+		progressBar = new ProgressBar((int)(ProgressBar.WIDTH*scale), (int)(ProgressBar.HEIGHT*scale));
+		progressBar.addKeyListener(this);
+		progressBar.addMouseListener(this);
+		statusBar.add("East", progressBar);
+		add("South", statusBar);
+
+		IJ.init(this, applet);
+		addKeyListener(this);
+		addWindowListener(this);
+		setFocusTraversalKeysEnabled(false);
+		m.installStartupMacroSet(); //add custom tools
+ 		
+		Point loc = getPreferredLocation();
+		Dimension tbSize = toolbar.getPreferredSize();
+		setCursor(Cursor.getDefaultCursor()); // work-around for JDK 1.1.8 bug
+		if (mode!=NO_SHOW) {
+			if (IJ.isWindows()) try {setIcon();} catch(Exception e) {}
+			setResizable(false);
+			setAlwaysOnTop(Prefs.alwaysOnTop);
+			pack();
+			setLocation(loc.x, loc.y);
+			setVisible(true);
+			Dimension size = getSize();
+			if (size!=null) {
+				if (IJ.debugMode) IJ.log("size: "+size);
+				if (IJ.isWindows() && (size.height>108||IJ.javaVersion()>=10)) {
+					// workaround for IJ window layout and FileDialog freeze problems with Windows 10 Creators Update
+					IJ.wait(10);
+					pack();
+					if (IJ.debugMode) IJ.log("pack()");
+					if (!Prefs.jFileChooserSettingChanged)
+						Prefs.useJFileChooser = true;
+				} else if (IJ.isMacOSX()) {
+					Rectangle maxBounds = GUI.getMaxWindowBounds(this);
+					if (loc.x+size.width>maxBounds.x+maxBounds.width)
+						setLocation(loc.x, loc.y);
+				}
+			}
+		}
+		if (err1!=null)
+			IJ.error(err1);
+		if (err2!=null) {
+			IJ.error(err2);
+			IJ.runPlugIn("ij.plugin.ClassChecker", "");
+		}
+		if (IJ.isMacintosh()&&applet==null) {
+			try {
+				if (IJ.javaVersion()>8) // newer JREs use different drag-drop, about mechanism
+					IJ.runPlugIn("ij.plugin.MacAdapter9", "");
+				else
+					IJ.runPlugIn("ij.plugin.MacAdapter", "");
+			} catch(Throwable e) {}
+		} 
+		if (applet==null)
+			IJ.runPlugIn("ij.plugin.DragAndDrop", "");
+		if (!getTitle().contains("Fiji")) {
+			Thread.setDefaultUncaughtExceptionHandler(new ExceptionHandler());
+			System.setProperty("sun.awt.exception.handler",ExceptionHandler.class.getName());
+		}
+		String str = m.getMacroCount()==1?" macro":" macros";
+		configureProxy();
+		if (applet==null)
+			loadCursors();
+		(new ij.macro.StartupRunner()).run(batchMode); // run RunAtStartup and AutoRun macros
+		IJ.showStatus(version()+ m.getPluginCount() + " commands; " + m.getMacroCount() + str);
+ 	}
+ 	
+ 	private void loadCursors() {
+		Toolkit toolkit = Toolkit.getDefaultToolkit();
+		String path = Prefs.getImageJDir()+"images/crosshair-cursor.gif";
+		File f = new File(path);
+		if (!f.exists())
+			return;
+		//Image image = toolkit.getImage(path);
+		ImageIcon icon = new ImageIcon(path);
+		Image image = icon.getImage();
+		if (image==null)
+			return;
+		int width = icon.getIconWidth();
+		int height = icon.getIconHeight();
+		Point hotSpot = new Point(width/2, height/2);
+		Cursor crosshairCursor = toolkit.createCustomCursor(image, hotSpot, "crosshair-cursor.gif");
+		ImageCanvas.setCursor(crosshairCursor, 0);
+	}
+    	
+	void configureProxy() {
+		if (Prefs.useSystemProxies) {
+			try {
+				System.setProperty("java.net.useSystemProxies", "true");
+			} catch(Exception e) {}
+		} else {
+			String server = Prefs.get("proxy.server", null);
+			if (server==null||server.equals(""))
+				return;
+			int port = (int)Prefs.get("proxy.port", 0);
+			if (port==0) return;
+			Properties props = System.getProperties();
+			props.put("proxySet", "true");
+			props.put("http.proxyHost", server);
+			props.put("http.proxyPort", ""+port);
+			props.put("https.proxyHost", server);
+			props.put("https.proxyPort", ""+port);
+		}
+		//new ProxySettings().logProperties();
+	}
+	
+    void setIcon() throws Exception {
+		URL url = this.getClass().getResource("/microscope.gif");
+		if (url==null) return;
+		Image img = createImage((ImageProducer)url.getContent());
+		if (img!=null) setIconImage(img);
+	}
+	
+	public Point getPreferredLocation() {
+		int ijX = Prefs.getInt(IJ_X,-99);
+		int ijY = Prefs.getInt(IJ_Y,-99);
+		Rectangle maxBounds = GUI.getMaxWindowBounds();
+		//System.out.println("getPreferredLoc1: "+ijX+" "+ijY+" "+maxBounds);
+		if (ijX>=maxBounds.x && ijY>=maxBounds.y && ijX<(maxBounds.x+maxBounds.width-75)
+		&& ijY<(maxBounds.y+maxBounds.height-75))
+			return new Point(ijX, ijY);
+		Dimension tbsize = toolbar.getPreferredSize();
+		int ijWidth = tbsize.width+10;
+		double percent = maxBounds.width>832?0.8:0.9;
+		ijX = (int)(percent*(maxBounds.width-ijWidth));
+		if (ijX<10) ijX = 10;
+		return new Point(ijX, maxBounds.y);
+	}
+	
+	void showStatus(String s) {
+        statusLine.setText(s);
+	}
+
+	public ProgressBar getProgressBar() {
+        return progressBar;
+	}
+
+	public Panel getStatusBar() {
+        return statusBar;
+	}
+
+    /** Starts executing a menu command in a separate thread. */
+    void doCommand(String name) {
+		new Executer(name, null);
+    }
+        
+	public void runFilterPlugIn(Object theFilter, String cmd, String arg) {
+		new PlugInFilterRunner(theFilter, cmd, arg);
+	}
+        
+	public Object runUserPlugIn(String commandName, String className, String arg, boolean createNewLoader) {
+		return IJ.runUserPlugIn(commandName, className, arg, createNewLoader);	
+	} 
+	
+	/** Return the current list of modifier keys. */
+	public static String modifiers(int flags) { //?? needs to be moved
+		String s = " [ ";
+		if (flags == 0) return "";
+		if ((flags & Event.SHIFT_MASK) != 0) s += "Shift ";
+		if ((flags & Event.CTRL_MASK) != 0) s += "Control ";
+		if ((flags & Event.META_MASK) != 0) s += "Meta ";
+		if ((flags & Event.ALT_MASK) != 0) s += "Alt ";
+		s += "] ";
+		return s;
+	}
+
+	/** Handle menu events. */
+	public void actionPerformed(ActionEvent e) {
+		if ((e.getSource() instanceof MenuItem)) {
+			MenuItem item = (MenuItem)e.getSource();
+			String cmd = e.getActionCommand();
+			Frame frame = WindowManager.getFrontWindow();
+			if (frame!=null && (frame instanceof Fitter)) {
+				((Fitter)frame).actionPerformed(e);
+				return;
+			}
+			commandName = cmd;
+			ImagePlus imp = null;
+			if (item.getParent()==Menus.getOpenRecentMenu()) {
+				new RecentOpener(cmd); // open image in separate thread
+				return;
+			} else if (item.getParent()==Menus.getPopupMenu()) {
+				Object parent = Menus.getPopupMenu().getParent();
+				if (parent instanceof ImageCanvas)
+					imp = ((ImageCanvas)parent).getImage();
+			}
+			int flags = e.getModifiers();
+			hotkey = false;
+			actionPerformedTime = System.currentTimeMillis();
+			long ellapsedTime = actionPerformedTime-keyPressedTime;
+			if (cmd!=null && (ellapsedTime>=200L||!cmd.equals(lastKeyCommand))) {
+				if ((flags & Event.ALT_MASK)!=0)
+					IJ.setKeyDown(KeyEvent.VK_ALT);
+				if ((flags & Event.SHIFT_MASK)!=0)
+					IJ.setKeyDown(KeyEvent.VK_SHIFT);
+				new Executer(cmd, imp);
+			}
+			lastKeyCommand = null;
+			if (IJ.debugMode) IJ.log("actionPerformed: time="+ellapsedTime+", "+e);
+		}
+	}
+
+	/** Handles CheckboxMenuItem state changes. */
+	public void itemStateChanged(ItemEvent e) {
+		MenuItem item = (MenuItem)e.getSource();
+		MenuComponent parent = (MenuComponent)item.getParent();
+		String cmd = e.getItem().toString();
+		if ("Autorun Examples".equals(cmd)) // Examples>Autorun Examples
+			Prefs.autoRunExamples = e.getStateChange()==1;
+		else if ((Menu)parent==Menus.window)
+			WindowManager.activateWindow(cmd, item);
+		else
+			doCommand(cmd);
+	}
+
+	public void mousePressed(MouseEvent e) {
+		Undo.reset();
+		if (!Prefs.noClickToGC)
+			System.gc();
+		IJ.showStatus(version()+IJ.freeMemory());
+		if (IJ.debugMode)
+			IJ.log("Windows: "+WindowManager.getWindowCount());
+	}
+	
+	public String getInfo() {
+		return version()+System.getProperty("os.name")+" "+System.getProperty("os.version")+"; "+IJ.freeMemory();
+	}
+
+	private String version() {
+		return "ImageJ "+VERSION+BUILD + "; "+"Java "+System.getProperty("java.version")+(IJ.is64Bit()?" [64-bit]; ":" [32-bit]; ");
+	}
+	
+	public void mouseReleased(MouseEvent e) {}
+	public void mouseExited(MouseEvent e) {}
+	public void mouseClicked(MouseEvent e) {}
+	public void mouseEntered(MouseEvent e) {}
+
+ 	public void keyPressed(KeyEvent e) {
+		if (e.isConsumed())
+			return;
+		int keyCode = e.getKeyCode();
+		IJ.setKeyDown(keyCode);
+		hotkey = false;
+		if (keyCode==KeyEvent.VK_CONTROL || keyCode==KeyEvent.VK_SHIFT)
+			return;
+		char keyChar = e.getKeyChar();
+		int flags = e.getModifiers();
+		if (IJ.debugMode) IJ.log("keyPressed: code=" + keyCode + " (" + KeyEvent.getKeyText(keyCode)
+			+ "), char=\"" + keyChar + "\" (" + (int)keyChar + "), flags="
+			+ KeyEvent.getKeyModifiersText(flags));
+		boolean shift = (flags & KeyEvent.SHIFT_MASK) != 0;
+		boolean control = (flags & KeyEvent.CTRL_MASK) != 0;
+		boolean alt = (flags & KeyEvent.ALT_MASK) != 0;
+		boolean meta = (flags & KeyEvent.META_MASK) != 0;
+		if (keyCode==KeyEvent.VK_H && meta && IJ.isMacOSX())
+			return; // Allow macOS to run ImageJ>Hide ImageJ command
+		String cmd = null;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		boolean isStack = (imp!=null) && (imp.getStackSize()>1);
+		
+		if (imp!=null && !meta && ((keyChar>=32 && keyChar<=255) || keyChar=='\b' || keyChar=='\n')) {
+			Roi roi = imp.getRoi();
+			if (roi!=null && roi instanceof TextRoi) {
+				if (imp.getOverlay()!=null && (control || alt || meta)
+				&& (keyCode==KeyEvent.VK_BACK_SPACE || keyCode==KeyEvent.VK_DELETE)) {
+					if (deleteOverlayRoi(imp))
+							return;
+				}
+				if ((flags & KeyEvent.META_MASK)!=0 && IJ.isMacOSX())
+					return;
+				if (alt) {
+					switch (keyChar) {
+						case 'u': case 'm': keyChar = IJ.micronSymbol; break;
+						case 'A': keyChar = IJ.angstromSymbol; break;
+						default:
+					}
+				}
+				((TextRoi)roi).addChar(keyChar);
+				return;
+			}
+		}
+        		
+		// Handle one character macro shortcuts
+		if (!control && !meta) {
+			Hashtable macroShortcuts = Menus.getMacroShortcuts();
+			if (macroShortcuts.size()>0) {
+				if (shift)
+					cmd = (String)macroShortcuts.get(new Integer(keyCode+200));
+				else
+					cmd = (String)macroShortcuts.get(new Integer(keyCode));
+				if (cmd!=null) {
+					commandName = cmd;
+					MacroInstaller.runMacroShortcut(cmd);
+					return;
+				}
+			}
+		}
+
+		if (keyCode==KeyEvent.VK_SEPARATOR)
+			keyCode = KeyEvent.VK_DECIMAL;
+		boolean functionKey = keyCode>=KeyEvent.VK_F1 && keyCode<=KeyEvent.VK_F12;
+		boolean numPad = keyCode==KeyEvent.VK_DIVIDE || keyCode==KeyEvent.VK_MULTIPLY
+			|| keyCode==KeyEvent.VK_DECIMAL
+			|| (keyCode>=KeyEvent.VK_NUMPAD0 && keyCode<=KeyEvent.VK_NUMPAD9);			
+		if ((!Prefs.requireControlKey||control||meta||functionKey||numPad) && keyChar!='+') {
+			Hashtable shortcuts = Menus.getShortcuts();
+			if (shift && !functionKey)
+				cmd = (String)shortcuts.get(new Integer(keyCode+200));
+			else
+				cmd = (String)shortcuts.get(new Integer(keyCode));
+		}
+		
+		if (cmd==null) {
+			switch (keyChar) {
+				case '<': case ',': if (isStack) cmd="Previous Slice [<]"; break;
+				case '>': case '.': case ';': if (isStack) cmd="Next Slice [>]"; break;
+				case '+': case '=': cmd="In [+]"; break;
+				case '-': cmd="Out [-]"; break;
+				case '/': cmd="Reslice [/]..."; break;
+				default:
+			}
+		}
+
+		if (cmd==null) {
+			switch (keyCode) {
+				case KeyEvent.VK_TAB: WindowManager.putBehind(); return;				
+				case KeyEvent.VK_BACK_SPACE: case KeyEvent.VK_DELETE:
+					if (!(shift||control||alt||meta)) {
+						if (deleteOverlayRoi(imp))
+							return;
+						if (imp!=null&&imp.getOverlay()!=null&&imp==GelAnalyzer.getGelImage())
+							return;
+						cmd="Clear";
+						hotkey=true;
+					}
+					break;
+				//case KeyEvent.VK_BACK_SLASH: cmd=IJ.altKeyDown()?"Animation Options...":"Start Animation"; break;
+				case KeyEvent.VK_EQUALS: cmd="In [+]"; break;
+				case KeyEvent.VK_MINUS: cmd="Out [-]"; break;
+				case KeyEvent.VK_SLASH: case 0xbf: cmd="Reslice [/]..."; break;
+				case KeyEvent.VK_COMMA: case 0xbc: if (isStack) cmd="Previous Slice [<]"; break;
+				case KeyEvent.VK_PERIOD: case 0xbe: if (isStack) cmd="Next Slice [>]"; break;
+				case KeyEvent.VK_LEFT: case KeyEvent.VK_RIGHT: case KeyEvent.VK_UP: case KeyEvent.VK_DOWN: // arrow keys
+					if (imp==null) return;
+					Roi roi = imp.getRoi();
+					if (shift&&imp==Orthogonal_Views.getImage())
+						return;
+					if (IJ.isMacOSX() && IJ.isJava18()) {
+						RoiManager rm = RoiManager.getInstance();
+						boolean rmActive = rm!=null && rm==WindowManager.getActiveWindow();
+						if (rmActive && (keyCode==KeyEvent.VK_DOWN||keyCode==KeyEvent.VK_UP))
+						  rm.repaint();
+					}
+					boolean stackKey = imp.getStackSize()>1 && (roi==null||shift);
+					boolean zoomKey = roi==null || shift || control;
+					if (stackKey && keyCode==KeyEvent.VK_RIGHT)
+							cmd="Next Slice [>]";
+					else if (stackKey && keyCode==KeyEvent.VK_LEFT)
+							cmd="Previous Slice [<]";
+					else if (zoomKey && keyCode==KeyEvent.VK_DOWN && !ignoreArrowKeys(imp) && Toolbar.getToolId()<Toolbar.SPARE6)
+							cmd="Out [-]";
+					else if (zoomKey && keyCode==KeyEvent.VK_UP && !ignoreArrowKeys(imp) && Toolbar.getToolId()<Toolbar.SPARE6)
+							cmd="In [+]";
+					else if (roi!=null) {
+						if ((flags & KeyEvent.ALT_MASK)!=0 || (flags & KeyEvent.CTRL_MASK)!=0)
+							roi.nudgeCorner(keyCode);
+						else
+							roi.nudge(keyCode);
+						return;
+					}
+					break;
+				case KeyEvent.VK_ESCAPE:
+					abortPluginOrMacro(imp);
+					return;
+				case KeyEvent.VK_ENTER: WindowManager.toFront(this); return;
+				default: break;
+			}
+		}
+		
+		if (cmd!=null && !cmd.equals("")) {
+			commandName = cmd;
+			if (!control && !meta && (cmd.equals("Fill")||cmd.equals("Draw")))
+				hotkey = true;
+			if (cmd.charAt(0)==MacroInstaller.commandPrefix)
+				MacroInstaller.runMacroShortcut(cmd);
+			else {
+				doCommand(cmd);
+				keyPressedTime = System.currentTimeMillis();
+				lastKeyCommand = cmd;
+			}
+		}
+	}
+	
+	private boolean deleteOverlayRoi(ImagePlus imp) {
+		if (imp==null)
+			return false;
+		Overlay overlay = null;
+		ImageCanvas ic = imp.getCanvas();
+		if (ic!=null)
+			overlay = ic.getShowAllList();
+		if (overlay==null)
+			overlay = imp.getOverlay();
+		if (overlay==null)
+			return false;
+		Roi roi = imp.getRoi();
+		for (int i=0; i<overlay.size(); i++) {
+			Roi roi2 = overlay.get(i);
+			if (roi2==roi) {
+				overlay.remove(i);
+				imp.deleteRoi();
+				ic = imp.getCanvas();
+				if (ic!=null)
+					ic.roiManagerSelect(roi, true);
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	private boolean ignoreArrowKeys(ImagePlus imp) {
+		Frame frame = WindowManager.getFrontWindow();
+		String title = frame!=null?frame.getTitle():null;
+		if (title!=null && title.equals("ROI Manager"))
+			return true;
+		// Control Panel?
+		if (frame!=null && frame instanceof javax.swing.JFrame)
+			return true;
+		ImageWindow win = imp.getWindow();
+		// LOCI Data Browser window?
+		if (imp.getStackSize()>1 && win!=null && win.getClass().getName().startsWith("loci"))
+			return true;
+		return false;
+	}
+	
+	public void keyTyped(KeyEvent e) {
+		char keyChar = e.getKeyChar();
+		int flags = e.getModifiers();
+		//if (IJ.debugMode) IJ.log("keyTyped: char=\"" + keyChar + "\" (" + (int)keyChar 
+		//	+ "), flags= "+Integer.toHexString(flags)+ " ("+KeyEvent.getKeyModifiersText(flags)+")");
+		if (keyChar=='\\' || keyChar==171 || keyChar==223) {
+			if (((flags&Event.ALT_MASK)!=0))
+				doCommand("Animation Options...");
+			else
+				doCommand("Start Animation [\\]");
+		}
+	}
+
+	public void keyReleased(KeyEvent e) {
+		IJ.setKeyUp(e.getKeyCode());
+	}
+			
+	/** called when escape pressed */
+	void abortPluginOrMacro(ImagePlus imp) {
+		if (imp!=null) {
+			ImageWindow win = imp.getWindow();
+			if (win!=null) {
+				Roi roi = imp.getRoi();
+				if (roi!=null && roi.getState()!=Roi.NORMAL) {
+					roi.abortModification(imp);
+					return;
+				} else {
+					win.running = false;
+					win.running2 = false;
+				}
+			}
+		}
+		Macro.abort();
+		Interpreter.abort();
+		if (Interpreter.getInstance()!=null)
+			IJ.beep();
+	}
+
+	public void windowClosing(WindowEvent e) {
+		if (Executer.getListenerCount()>0)
+			doCommand("Quit");
+		else {
+			quit();
+			windowClosed = true;
+		}
+	}
+
+	public void windowActivated(WindowEvent e) {
+		if (IJ.isMacintosh() && !quitting) {
+			IJ.wait(10); // may be needed for Java 1.4 on OS X
+			MenuBar mb = Menus.getMenuBar();
+			if (mb!=null && mb!=getMenuBar()) {
+				setMenuBar(mb);
+				Menus.setMenuBarCount++;
+				if (IJ.debugMode) IJ.log("setMenuBar: "+Menus.setMenuBarCount);
+			}
+		}
+	}
+	
+	public void windowClosed(WindowEvent e) {}
+	public void windowDeactivated(WindowEvent e) {}
+	public void windowDeiconified(WindowEvent e) {}
+	public void windowIconified(WindowEvent e) {}
+	public void windowOpened(WindowEvent e) {}
+	
+	/** Adds the specified class to a Vector to keep it from being
+		garbage collected, causing static fields to be reset. */
+	public void register(Class c) {
+		if (!classes.contains(c))
+			classes.addElement(c);
+	}
+
+	/** Called by ImageJ when the user selects Quit. */
+	public void quit() {
+		quitMacro = IJ.macroRunning();
+		Thread thread = new Thread(this, "Quit");
+		thread.setPriority(Thread.NORM_PRIORITY);
+		thread.start();
+		IJ.wait(10);
+	}
+	
+	/** Returns true if ImageJ is exiting. */
+	public boolean quitting() {
+		return quitting;
+	}
+	
+	/** Returns true if ImageJ is quitting as a result of a run("Quit") macro call. */
+	public boolean quittingViaMacro() {
+		return quitting && quitMacro;
+	}
+
+	/** Called once when ImageJ quits. */
+	public void savePreferences(Properties prefs) {
+		Point loc = getLocation();
+		prefs.put(IJ_X, Integer.toString(loc.x));
+		prefs.put(IJ_Y, Integer.toString(loc.y));
+	}
+
+	public static void main(String args[]) {
+		boolean noGUI = false;
+		int mode = STANDALONE;
+		arguments = args;
+		int nArgs = args!=null?args.length:0;
+		boolean commandLine = false;
+		for (int i=0; i<nArgs; i++) {
+			String arg = args[i];
+			if (arg==null) continue;
+			if (arg.startsWith("-batch")) {
+				noGUI = true;
+				batchMode = true;
+			} else if (arg.startsWith("-macro") || arg.endsWith(".ijm") || arg.endsWith(".txt"))
+				batchMode = true;
+			else if (arg.startsWith("-debug"))
+				IJ.setDebugMode(true);
+			else if (arg.startsWith("-ijpath") && i+1<nArgs) {
+				if (IJ.debugMode) IJ.log("-ijpath: "+args[i+1]);
+				Prefs.setHomeDir(args[i+1]);
+				commandLine = true;
+				args[i+1] = null;
+			} else if (arg.startsWith("-port")) {
+				int delta = (int)Tools.parseDouble(arg.substring(5, arg.length()), 0.0);
+				commandLine = true;
+				if (delta==0)
+					mode = EMBEDDED;
+				else if (delta>0 && DEFAULT_PORT+delta<65536)
+					port = DEFAULT_PORT+delta;
+			} 
+		}
+  		// If existing ImageJ instance, pass arguments to it and quit.
+  		boolean passArgs = mode==STANDALONE && !noGUI;
+		if (IJ.isMacOSX() && !commandLine)
+			passArgs = false;
+		if (passArgs && isRunning(args)) 
+  			return;
+ 		ImageJ ij = IJ.getInstance();    	
+		if (!noGUI && (ij==null || (ij!=null && !ij.isShowing()))) {
+			ij = new ImageJ(null, mode);
+			ij.exitWhenQuitting = true;
+		} else if (batchMode && noGUI)
+			Prefs.load(null, null);
+		int macros = 0;
+		for (int i=0; i<nArgs; i++) {
+			String arg = args[i];
+			if (arg==null) continue;
+			if (arg.startsWith("-")) {
+				if ((arg.startsWith("-macro") || arg.startsWith("-batch")) && i+1<nArgs) {
+					String arg2 = i+2<nArgs?args[i+2]:null;
+					Prefs.commandLineMacro = true;
+					if (noGUI && args[i+1].endsWith(".js"))
+						Interpreter.batchMode = true;
+					IJ.runMacroFile(args[i+1], arg2);
+					break;
+				} else if (arg.startsWith("-eval") && i+1<nArgs) {
+					String rtn = IJ.runMacro(args[i+1]);
+					if (rtn!=null)
+						System.out.print(rtn);
+					args[i+1] = null;
+				} else if (arg.startsWith("-run") && i+1<nArgs) {
+					IJ.run(args[i+1]);
+					args[i+1] = null;
+				}
+			} else if (macros==0 && (arg.endsWith(".ijm") || arg.endsWith(".txt"))) {
+				IJ.runMacroFile(arg);
+				macros++;
+			} else if (arg.length()>0 && arg.indexOf("ij.ImageJ")==-1) {
+				File file = new File(arg);
+				IJ.open(file.getAbsolutePath());
+			}
+		}
+		if (IJ.debugMode && IJ.getInstance()==null)
+			new JavaProperties().run("");
+		if (noGUI) System.exit(0);
+	}
+		
+	// Is there another instance of ImageJ? If so, send it the arguments and quit.
+	static boolean isRunning(String args[]) {
+		return OtherInstance.sendArguments(args);
+	}
+
+	/** Returns the port that ImageJ checks on startup to see if another instance is running.
+	* @see ij.OtherInstance
+	*/
+	public static int getPort() {
+		return port;
+	}
+	
+	/** Returns the command line arguments passed to ImageJ. */
+	public static String[] getArgs() {
+		return arguments;
+	}
+
+	/** ImageJ calls System.exit() when qutting when 'exitWhenQuitting' is true.*/
+	public void exitWhenQuitting(boolean ewq) {
+		exitWhenQuitting = ewq;
+	}
+	
+	/** Quit using a separate thread, hopefully avoiding thread deadlocks. */
+	public void run() {
+		quitting = true;
+		boolean changes = false;
+		int[] wList = WindowManager.getIDList();
+		if (wList!=null) {
+			for (int i=0; i<wList.length; i++) {
+				ImagePlus imp = WindowManager.getImage(wList[i]);
+				if (imp!=null && imp.changes==true) {
+					changes = true;
+					break;
+				}
+			}
+		}
+		Frame[] frames = WindowManager.getNonImageWindows();
+		if (frames!=null) {
+			for (int i=0; i<frames.length; i++) {
+				if (frames[i]!=null && (frames[i] instanceof Editor)) {
+					if (((Editor)frames[i]).fileChanged()) {
+						changes = true;
+						break;
+					}
+				}
+			}
+		}
+		if (windowClosed && !changes && Menus.window.getItemCount()>Menus.WINDOW_MENU_ITEMS && !(IJ.macroRunning()&&WindowManager.getImageCount()==0)) {
+			GenericDialog gd = new GenericDialog("ImageJ", this);
+			gd.addMessage("Are you sure you want to quit ImageJ?");
+			gd.showDialog();
+			quitting = !gd.wasCanceled();
+			windowClosed = false;
+		}
+		if (!quitting)
+			return;
+		if (!WindowManager.closeAllWindows()) {
+			quitting = false;
+			return;
+		}
+		if (applet==null) {
+			saveWindowLocations();
+			Prefs.set(ImageWindow.LOC_KEY,null); // don't save image window location
+			Prefs.savePreferences();
+		}
+		IJ.cleanup();
+		dispose();
+		if (exitWhenQuitting)
+			System.exit(0);
+	}
+	
+	void saveWindowLocations() {
+		Window win = WindowManager.getWindow("B&C");
+		if (win!=null)
+			Prefs.saveLocation(ContrastAdjuster.LOC_KEY, win.getLocation());
+		win = WindowManager.getWindow("Threshold");
+		if (win!=null)
+			Prefs.saveLocation(ThresholdAdjuster.LOC_KEY, win.getLocation());
+		win = WindowManager.getWindow("Results");
+		if (win!=null) {
+			Prefs.saveLocation(TextWindow.LOC_KEY, win.getLocation());
+			Dimension d = win.getSize();
+			Prefs.set(TextWindow.WIDTH_KEY, d.width);
+			Prefs.set(TextWindow.HEIGHT_KEY, d.height);
+		}
+		win = WindowManager.getWindow("Log");
+		if (win!=null) {
+			Prefs.saveLocation(TextWindow.LOG_LOC_KEY, win.getLocation());
+			Dimension d = win.getSize();
+			Prefs.set(TextWindow.LOG_WIDTH_KEY, d.width);
+			Prefs.set(TextWindow.LOG_HEIGHT_KEY, d.height);
+		}
+		win = WindowManager.getWindow("ROI Manager");
+		if (win!=null)
+			Prefs.saveLocation(RoiManager.LOC_KEY, win.getLocation());
+	}
+	
+	public static String getCommandName() {
+		return commandName!=null?commandName:"null";
+	}
+	
+	public static void setCommandName(String name) {
+		commandName = name;
+	}
+	
+	public void resize() {
+		double scale = Prefs.getGuiScale();
+		toolbar.init();
+		statusLine.setFont(new Font("SansSerif", Font.PLAIN, (int)(13*scale)));
+		progressBar.init((int)(ProgressBar.WIDTH*scale), (int)(ProgressBar.HEIGHT*scale));
+		pack();
+	}
+		
+  /** Handles exceptions on the EDT. */
+  public static class ExceptionHandler implements Thread.UncaughtExceptionHandler {
+
+    // for EDT exceptions
+    public void handle(Throwable thrown) {
+      handleException(Thread.currentThread().getName(), thrown);
+    }
+
+    // for other uncaught exceptions
+    public void uncaughtException(Thread thread, Throwable thrown) {
+      handleException(thread.getName(), thrown);
+    }
+
+    protected void handleException(String tname, Throwable e) {
+    	if (Macro.MACRO_CANCELED.equals(e.getMessage()))
+			return;
+		CharArrayWriter caw = new CharArrayWriter();
+		PrintWriter pw = new PrintWriter(caw);
+		e.printStackTrace(pw);
+		String s = caw.toString();
+		if (s!=null && s.contains("ij.")) {
+			if (IJ.getInstance()!=null)
+				s = IJ.getInstance().getInfo()+"\n"+s;
+			IJ.log(s);
+		}
+    }
+    
+  } // inner class ExceptionHandler
+
+}
diff --git a/src/ij/ImageJApplet.java b/src/ij/ImageJApplet.java
new file mode 100644
index 0000000..db5cb6e
--- /dev/null
+++ b/src/ij/ImageJApplet.java
@@ -0,0 +1,44 @@
+package ij;
+import java.applet.Applet;
+
+/**
+	Runs ImageJ as an applet and optionally opens up to 
+	nine images using URLs passed as a parameters.
+	<p>
+	Here is an example applet tag that launches ImageJ as an applet
+	and passes it the URLs of two images:
+	<pre>
+	&lt;applet archive="../ij.jar" code="ij.ImageJApplet.class" width=0 height=0&gt;
+	&lt;param name=url1 value="http://imagej.nih.gov/ij/images/FluorescentCells.jpg"&gt;
+	&lt;param name=url2 value="http://imagej.nih.gov/ij/images/blobs.gif"&gt;
+	&lt;/applet&gt;
+	</pre>
+	To use plugins, add them to ij.jar and add entries to IJ_Props.txt file (in ij.jar) that will  
+	create commands for them in the Plugins menu, or a submenu. There are examples 
+	of such entries in IJ.Props.txt, in the "Plugins installed in the Plugins menu" section.
+	<p>
+	Macros contained in a file named "StartupMacros.txt", in the same directory as the HTML file
+	containing the applet tag, will be installed on startup.
+*/
+public class ImageJApplet extends Applet {
+
+	/** Starts ImageJ if it's not already running. */
+    public void init() {
+    	ImageJ ij = IJ.getInstance();
+     	if (ij==null || (ij!=null && !ij.isShowing()))
+			new ImageJ(this);
+		for (int i=1; i<=9; i++) {
+			String url = getParameter("url"+i);
+			if (url==null) break;
+			ImagePlus imp = new ImagePlus(url);
+			if (imp!=null) imp.show();
+		}
+    }
+    
+    public void destroy() {
+    	ImageJ ij = IJ.getInstance();
+    	if (ij!=null) ij.quit();
+    }
+
+}
+
diff --git a/src/ij/ImageListener.java b/src/ij/ImageListener.java
new file mode 100644
index 0000000..ae8faac
--- /dev/null
+++ b/src/ij/ImageListener.java
@@ -0,0 +1,17 @@
+package ij;
+
+	/** Plugins that implement this interface are notified when
+		an image is opened, closed or updated. The 
+		Plugins/Utilities/Monitor Events command uses this interface.
+	*/
+	public interface ImageListener {
+
+	public void imageOpened(ImagePlus imp);
+
+	public void imageClosed(ImagePlus imp);
+
+	public void imageUpdated(ImagePlus imp);
+	
+	//default void imageSaved(ImagePlus imp) { }
+
+}
diff --git a/src/ij/ImagePlus.java b/src/ij/ImagePlus.java
new file mode 100644
index 0000000..231609e
--- /dev/null
+++ b/src/ij/ImagePlus.java
@@ -0,0 +1,3438 @@
+package ij;
+import java.awt.*;
+import java.awt.image.*;
+import java.net.URL;
+import java.util.*;
+import ij.process.*;
+import ij.io.*;
+import ij.gui.*;
+
+import ij.measure.*;
+import ij.plugin.filter.Analyzer;
+import ij.util.*;
+import ij.macro.Interpreter;
+import ij.plugin.*;
+import ij.plugin.frame.*;
+
+
+/**
+An ImagePlus contain an ImageProcessor (2D image) or an ImageStack (3D, 4D or 5D image).
+It also includes metadata (spatial calibration and possibly the directory/file where
+it was read from). The ImageProcessor contains the pixel data (8-bit, 16-bit, float or RGB)
+of the 2D image and some basic methods to manipulate it. An ImageStack is essentually
+a list ImageProcessors of same type and size.
+@see ij.process.ImageProcessor
+@see ij.ImageStack
+@see ij.gui.ImageWindow
+@see ij.gui.ImageCanvas
+*/
+
+public class ImagePlus implements ImageObserver, Measurements, Cloneable {
+
+	/** 8-bit grayscale (unsigned)*/
+	public static final int GRAY8 = 0;
+
+	/** 16-bit grayscale (unsigned) */
+	public static final int GRAY16 = 1;
+
+	/** 32-bit floating-point grayscale */
+	public static final int GRAY32 = 2;
+
+	/** 8-bit indexed color */
+	public static final int COLOR_256 = 3;
+
+	/** 32-bit RGB color */
+	public static final int COLOR_RGB = 4;
+
+	/** Title of image used by Flatten command */
+	public static final String flattenTitle = "flatten~canvas";
+
+	/** True if any changes have been made to this image. */
+	public boolean changes;
+
+	protected Image img;
+	protected ImageProcessor ip;
+	protected ImageWindow win;
+	protected Roi roi;
+	protected int currentSlice; // current stack index (one-based)
+	protected static final int OPENED=0, CLOSED=1, UPDATED=2, SAVED=3;
+	protected boolean compositeImage;
+	protected int width;
+	protected int height;
+	protected boolean locked;
+	private int lockedCount;
+	private Thread lockingThread;
+	protected int nChannels = 1;
+	protected int nSlices = 1;
+	protected int nFrames = 1;
+	protected boolean dimensionsSet;
+
+	private ImageJ ij = IJ.getInstance();
+	private String title;
+	private	String url;
+	private FileInfo fileInfo;
+	private int imageType = GRAY8;
+	private boolean typeSet;
+	private ImageStack stack;
+	private static int currentID = -1;
+	private int ID;
+	private static Component comp;
+	private boolean imageLoaded;
+	private int imageUpdateY, imageUpdateW;
+	private Properties properties;
+	private long startTime;
+	private Calibration calibration;
+	private static Calibration globalCalibration;
+	private boolean activated;
+	private boolean ignoreFlush;
+	private boolean errorLoadingImage;
+	private static ImagePlus clipboard;
+	private static Vector listeners = new Vector();
+	private boolean openAsHyperStack;
+	private int[] position = {1,1,1};
+	private boolean noUpdateMode;
+	private ImageCanvas flatteningCanvas;
+	private Overlay overlay;
+	private boolean compositeChanges;
+	private boolean hideOverlay;
+	private static int default16bitDisplayRange;
+	private boolean antialiasRendering = true;
+	private boolean ignoreGlobalCalibration;
+	private boolean oneSliceStack;
+	public boolean setIJMenuBar = Prefs.setIJMenuBar;
+	private Plot plot;
+	private Properties imageProperties;
+	private Color borderColor;
+	private boolean temporary;
+
+
+    /** Constructs an uninitialized ImagePlus. */
+    public ImagePlus() {
+		title = (this instanceof CompositeImage)?"composite":"null";
+		setID();
+    }
+
+    /** Constructs an ImagePlus from an Image or BufferedImage. The first
+		argument will be used as the title of the window that displays the image.
+		Throws an IllegalStateException if an error occurs while loading the image. */
+    public ImagePlus(String title, Image image) {
+		this.title = title;
+		if (image!=null)
+			setImage(image);
+		setID();
+    }
+
+    /** Constructs an ImagePlus from an ImageProcessor. */
+    public ImagePlus(String title, ImageProcessor ip) {
+ 		setProcessor(title, ip);
+   		setID();
+    }
+
+	/** Constructs an ImagePlus from a TIFF, BMP, DICOM, FITS,
+		PGM, GIF or JPRG specified by a path or from a TIFF, DICOM,
+		GIF or JPEG specified by a URL. */
+    public ImagePlus(String pathOrURL) {
+    	Opener opener = new Opener();
+    	ImagePlus imp = null;
+    	boolean isURL = pathOrURL.indexOf("://")>0;
+    	if (isURL)
+    		imp = opener.openURL(pathOrURL);
+    	else
+    		imp = opener.openImage(pathOrURL);
+    	if (imp!=null) {
+    		if (imp.getStackSize()>1)
+    			setStack(imp.getTitle(), imp.getStack());
+    		else
+     			setProcessor(imp.getTitle(), imp.getProcessor());
+     		setCalibration(imp.getCalibration());
+     		properties = imp.getProperties();
+     		setFileInfo(imp.getOriginalFileInfo());
+     		setDimensions(imp.getNChannels(), imp.getNSlices(), imp.getNFrames());
+     		setOverlay(imp.getOverlay());
+     		setRoi(imp.getRoi());
+   			if (isURL)
+   				this.url = pathOrURL;
+   			setID();
+    	}
+    }
+
+	/** Constructs an ImagePlus from a stack. */
+    public ImagePlus(String title, ImageStack stack) {
+    	setStack(title, stack);
+    	setID();
+    }
+
+    private void setID() {
+    	ID = --currentID;
+	}
+	
+	public void setTemporary() {
+		if (!temporary) {
+			temporary = true;		
+			currentID++;
+			ID = -Integer.MAX_VALUE;
+		}
+	}
+
+	/** Locks the image so other threads can test to see if it is in use.
+	 * One thread can lock an image multiple times, then it has to unlock
+	 * it as many times until it is unlocked. This allows nested locking
+	 * within a thread.
+	 * Returns true if the image was successfully locked.
+	 * Beeps, displays a message in the status bar, and returns
+	 * false if the image is already locked by another thread.
+	*/
+	public synchronized boolean lock() {
+		return lock(true);
+	}
+
+	/** Similar to lock, but doesn't beep and display an error
+	 * message if the attempt to lock the image fails.
+	*/
+	public synchronized boolean lockSilently() {
+		return lock(false);
+	}
+
+	private synchronized boolean lock(boolean loud) {
+		if (locked) {
+			if (Thread.currentThread()==lockingThread) {
+				lockedCount++; //allow locking multiple times by the same thread
+				return true;
+			} else {
+				if (loud) {
+					IJ.beep();
+					IJ.showStatus("\"" + title + "\" is locked");
+					if (IJ.debugMode) IJ.log(title + " is locked by " + lockingThread + "; refused locking by " + Thread.currentThread().getName());
+					if (IJ.macroRunning())
+						IJ.wait(500);
+				}
+				return false;
+			}
+		} else {
+			locked = true;  //we could use 'lockedCount instead, but subclasses might use
+			lockedCount = 1;
+			lockingThread = Thread.currentThread();
+			if (win instanceof StackWindow)
+				((StackWindow)win).setSlidersEnabled(false);
+			if (IJ.debugMode) IJ.log(title + ": locked" + (loud ? "" : "silently") + " by " + Thread.currentThread().getName());
+			return true;
+		}
+	}
+
+	/** Unlocks the image.
+	 * In case the image had been locked several times by the current thread,
+	 * it gets unlocked only after as many unlock operations as there were
+	 * previous lock operations.
+	*/
+	public synchronized void unlock() {
+		if (Thread.currentThread()==lockingThread && lockedCount>1)
+			lockedCount--;
+		else {
+			locked = false;
+			lockedCount = 0;
+			lockingThread = null;
+			if (win instanceof StackWindow)
+				((StackWindow)win).setSlidersEnabled(true);
+			if (IJ.debugMode) IJ.log(title + ": unlocked");
+		}
+	}
+
+	/** Returns 'true' if the image is locked. */
+	public boolean isLocked() {
+		return locked;
+	}
+
+	/** Returns 'true' if the image was locked on another thread. */
+	public boolean isLockedByAnotherThread() {
+		return locked && Thread.currentThread()!=lockingThread;
+	}
+
+	private void waitForImage(Image image) {
+		if (comp==null) {
+			comp = IJ.getInstance();
+			if (comp==null)
+				comp = new Canvas();
+		}
+		imageLoaded = false;
+		if (!comp.prepareImage(image, this)) {
+			double progress;
+			waitStart = System.currentTimeMillis();
+			while (!imageLoaded && !errorLoadingImage) {
+				IJ.wait(30);
+				if (imageUpdateW>1) {
+					progress = (double)imageUpdateY/imageUpdateW;
+					if (!(progress<1.0)) {
+						progress = 1.0 - (progress-1.0);
+						if (progress<0.0) progress = 0.9;
+					}
+					showProgress(progress);
+				}
+			}
+			showProgress(1.0);
+		}
+	}
+
+	long waitStart;
+	private void showProgress(double percent) {
+		if ((System.currentTimeMillis()-waitStart)>500L)
+			IJ.showProgress(percent);
+	}
+
+	/** Draws the image. If there is an ROI, its
+		outline is also displayed.  Does nothing if there
+		is no window associated with this image (i.e. show()
+		has not been called).*/
+	public void draw() {
+		if (win!=null)
+			win.getCanvas().repaint();
+	}
+
+	/** Draws image and roi outline using a clip rect. */
+	public void draw(int x, int y, int width, int height){
+		if (win!=null) {
+			ImageCanvas ic = win.getCanvas();
+			double mag = ic.getMagnification();
+			x = ic.screenX(x);
+			y = ic.screenY(y);
+			width = (int)(width*mag);
+			height = (int)(height*mag);
+			ic.repaint(x, y, width, height);
+			if (listeners.size()>0 && roi!=null && roi.getPasteMode()!=Roi.NOT_PASTING)
+				notifyListeners(UPDATED);
+		}
+	}
+
+	/** Updates this image from the pixel data in its
+		associated ImageProcessor, then displays it. Does
+		nothing if there is no window associated with
+		this image (i.e. show() has not been called).*/
+	public synchronized void updateAndDraw() {
+		if (win==null) {
+			img = null;
+			return;
+		}
+		if (stack!=null && !stack.isVirtual() && currentSlice>=1 && currentSlice<=stack.size()) {		
+			if (stack.size()>1 && win!=null && !(win instanceof StackWindow)) {
+				setStack(stack);	//adds scroll bar if stack size has changed to >1
+				return;
+			}
+			Object pixels = stack.getPixels(currentSlice);
+			if (ip!=null && pixels!=null && pixels!=ip.getPixels()) { // was stack updated?
+				try {
+					ip.setPixels(pixels);
+					ip.setSnapshotPixels(null);
+				} catch(Exception e) {}
+			}
+		}
+		if (win!=null) {
+			win.getCanvas().setImageUpdated();
+			if (listeners.size()>0) notifyListeners(UPDATED);
+		}
+		draw();
+	}
+
+	/** Use to update the image when the underlying virtual stack changes. */
+	public void updateVirtualSlice() {
+		ImageStack vstack = getStack();
+		if (vstack.isVirtual()) {
+			double min=getDisplayRangeMin(), max=getDisplayRangeMax();
+			setProcessor(vstack.getProcessor(getCurrentSlice()));
+			setDisplayRange(min,max);
+		} else
+			throw new IllegalArgumentException("Virtual stack required");
+	}
+
+	/** Sets the display mode of composite color images, where 'mode'
+		 should be IJ.COMPOSITE, IJ.COLOR or IJ.GRAYSCALE. */
+	public void setDisplayMode(int mode) {
+		if (this instanceof CompositeImage) {
+			((CompositeImage)this).setMode(mode);
+			updateAndDraw();
+		}
+	}
+
+	/** Returns the display mode (IJ.COMPOSITE, IJ.COLOR
+		or IJ.GRAYSCALE) if this is a composite color
+		image, or 0 if it not. */
+	public int getDisplayMode() {
+		if (this instanceof CompositeImage)
+			return ((CompositeImage)this).getMode();
+		else
+			return 0;
+	}
+
+	/** Controls which channels in a composite color image are displayed,
+		where 'channels' is a list of ones and zeros that specify the channels to
+		display. For example, "101" causes channels 1 and 3 to be displayed. */
+	public void setActiveChannels(String channels) {
+		if (!(this instanceof CompositeImage))
+			return;
+		boolean[] active = ((CompositeImage)this).getActiveChannels();
+		for (int i=0; i<active.length; i++) {
+			boolean b = false;
+			if (channels.length()>i && channels.charAt(i)=='1')
+				b = true;
+			active[i] = b;
+		}
+		updateAndDraw();
+		Channels.updateChannels();
+	}
+
+	/** Updates this image from the pixel data in its
+		associated ImageProcessor, then displays it.
+		The CompositeImage class overrides this method
+		to only update the current channel. */
+	public void updateChannelAndDraw() {
+		updateAndDraw();
+	}
+
+	/** Returns a reference to the current ImageProcessor. The
+		CompositeImage class overrides this method to return
+		the processor associated with the current channel. */
+	public ImageProcessor getChannelProcessor() {
+		return getProcessor();
+	}
+
+	/**  Returns an array containing the lookup tables used by this image,
+	 * one per channel, or an empty array if this is an RGB image.
+	 * @see #getNChannels
+	 * @see #isComposite
+	 * @see #getCompositeMode
+	*/
+	public LUT[] getLuts() {
+		ImageProcessor ip2 = getProcessor();
+		if (ip2==null)
+			return new LUT[0];
+		LUT lut = ip2.getLut();
+		if (lut==null)
+			return new LUT[0];
+		LUT[] luts = new LUT[1];
+		luts[0] = lut;
+		return luts;
+	}
+
+	/** Calls draw to draw the image and also repaints the
+		image window to force the information displayed above
+		the image (dimension, type, size) to be updated. */
+	public void repaintWindow() {
+		if (win!=null) {
+			draw();
+			win.repaint();
+		}
+	}
+
+	/** Calls updateAndDraw to update from the pixel data
+		and draw the image, and also repaints the image
+		window to force the information displayed above
+		the image (dimension, type, size) to be updated. */
+	public void updateAndRepaintWindow() {
+		if (win!=null) {
+			updateAndDraw();
+			win.repaint();
+		}
+	}
+
+	/** ImageCanvas.paint() calls this method when the
+		ImageProcessor has generated a new image. */
+	public void updateImage() {
+		if (win==null) {
+			img = null;
+			return;
+		}
+		if (ip!=null)
+			img = ip.createImage();
+	}
+
+	/** Closes the window, if any, that is displaying this image. */
+	public void hide() {
+		if (win==null) {
+			img = null;
+			Interpreter.removeBatchModeImage(this);
+			return;
+		}
+		boolean unlocked = lockSilently();
+		Overlay overlay2 = getOverlay();
+		changes = false;
+		win.close();
+		win = null;
+		setOverlay(overlay2);
+		if (unlocked) unlock();
+	}
+
+	/** Closes this image and sets the ImageProcessor to null. To avoid the
+		"Save changes?" dialog, first set the public 'changes' variable to false. */
+	public void close() {
+		ImageWindow win = getWindow();
+		if (win!=null)
+			win.close();
+		else {
+            if (WindowManager.getCurrentImage()==this)
+                WindowManager.setTempCurrentImage(null);
+			deleteRoi(); //save any ROI so it can be restored later
+			Interpreter.removeBatchModeImage(this);
+		}
+    }
+
+	/** Opens a window to display this image and clears the status bar. */
+	public void show() {
+		show("");
+	}
+
+	/** Opens a window to display this image and displays
+		'statusMessage' in the status bar. */
+	public void show(String statusMessage) {
+		if (isVisible() || temporary)
+			return;
+		win = null;
+		if ((IJ.isMacro() && ij==null) || Interpreter.isBatchMode()) {
+			if (isComposite()) ((CompositeImage)this).reset();
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) imp.saveRoi();
+			WindowManager.setTempCurrentImage(this);
+			Interpreter.addBatchModeImage(this);
+			return;
+		}
+		if (Prefs.useInvertingLut && getBitDepth()==8 && ip!=null && !ip.isInvertedLut()&& !ip.isColorLut())
+			invertLookupTable();
+		img = getImage();
+		if ((img!=null) && (width>=0) && (height>=0)) {
+			activated = false;
+			int stackSize = getStackSize();
+			if (stackSize>1)
+				win = new StackWindow(this);	// displays the window and (if macro) waits for window to be activated
+			else if (getProperty(Plot.PROPERTY_KEY) != null)
+				win = new PlotWindow(this, (Plot)(getProperty(Plot.PROPERTY_KEY)));
+			else
+				win = new ImageWindow(this);
+			if (roi!=null) roi.setImage(this);
+			if (overlay!=null && getCanvas()!=null)
+				getCanvas().setOverlay(overlay);
+			IJ.showStatus(statusMessage);
+			if (IJ.isMacro() && stackSize==1) // for non-stacks, wait for window to be activated
+				waitTillActivated();
+			if (imageType==GRAY16 && default16bitDisplayRange!=0) {
+				resetDisplayRange();
+				updateAndDraw();
+			}
+			if (stackSize>1) {
+				int c = getChannel();
+				int z = getSlice();
+				int t = getFrame();
+				if (c>1 || z>1 || t>1)
+					setPosition(c, z, t);
+			}
+			if (setIJMenuBar)
+				IJ.wait(25);
+			notifyListeners(OPENED);
+		}
+	}
+	
+	void invertLookupTable() {
+		int nImages = getStackSize();
+		ip.invertLut();
+		if (nImages==1)
+			ip.invert();
+		else {
+			ImageStack stack2 = getStack();
+			for (int i=1; i<=nImages; i++)
+				stack2.getProcessor(i).invert();
+			stack2.setColorModel(ip.getColorModel());
+		}
+	}
+
+	/** Waits until the image window becomes activated. This is necessary in
+	 *  macros or other programs if an ImagePlus is shown on the screen,
+	 *  because displaying the window is asynchronous (happens later)
+	 *  and will make the image the active one. Without waiting, in the
+	 *  meanwhile another window could be already the active one and would
+	 *  become deactivated.
+	 *  If the ImagePlus may have been displayed previously, first call
+	 *  setDeactivated().
+	 *  <code>ImagePlus.show()</code> and <code>new StackWindow(ImagePlus)</code>
+	 *  call this method if IJ.isMacro() is true, i.e., when running a macro or
+	 *  executing an IJ.run(...) call.
+	*/
+	public void waitTillActivated() {
+		if (win == null) return;
+		if (EventQueue.isDispatchThread()) { //'activated' is set in the EventQueue, we can't wait for it in the EventQueue
+			WindowManager.setTempCurrentImage(this);
+			return;
+		}
+		long start = System.currentTimeMillis();
+		while (!activated) {
+			IJ.wait(5);
+			if (ij != null && ij.quitting()) return;
+			if ((System.currentTimeMillis()-start)>2000) {
+				WindowManager.setTempCurrentImage(this);
+				break; // 2 second timeout
+			}
+		}
+	}
+
+	/** Called by ImageWindow.windowActivated(); to end waiting in waitTillActivated. */
+	public void setActivated() {
+		activated = true;
+		if (borderColor!=null && win!=null)
+			win.setBackground(borderColor);
+	}
+
+	/** Called by <code>new StackWindow(ImagePlus)</code>
+	 * before showing the StackWindow, to prepare for
+	 * waitTillActivated().
+	*/
+	public void setDeactivated() {
+		activated = false;
+	}
+
+	/** Returns this image as a AWT image. */
+	public Image getImage() {
+		if (img==null && ip!=null)
+			img = ip.createImage();
+		return img;
+	}
+	
+	/** Returns a copy of this image as an 8-bit or RGB BufferedImage.
+	 * @see ij.process.ShortProcessor#get16BitBufferedImage
+	 */
+	public BufferedImage getBufferedImage() {
+		if (isComposite())
+			return (new ColorProcessor(getImage())).getBufferedImage();
+		else
+			return ip.getBufferedImage();
+	}
+
+	/** Returns this image's unique numeric ID. */
+	public int getID() {
+		return ID;
+	}
+
+	/** Replaces the image, if any, with the one specified.
+	 * Throws an IllegalStateException if an error occurs
+	 * while loading the image.
+	*/
+	public void setImage(Image image) {
+		if (image instanceof BufferedImage) {
+			BufferedImage bi = (BufferedImage)image;			
+			int nBands = bi.getSampleModel().getNumBands();
+			int type = bi.getType();
+			boolean rgb = type==BufferedImage.TYPE_3BYTE_BGR || type==BufferedImage.TYPE_INT_RGB || type==BufferedImage.TYPE_4BYTE_ABGR;
+			if (nBands>1 && !rgb) {
+				ImageStack biStack = new ImageStack(bi.getWidth(), bi.getHeight());			
+				for (int b=0; b<nBands; b++)
+					biStack.addSlice(convertToImageProcessor(bi, b));
+				setImage(new ImagePlus("", biStack));
+				return;
+			}			
+			if (bi.getType()==BufferedImage.TYPE_USHORT_GRAY) {
+				setProcessor(null, new ShortProcessor(bi));
+				return;
+			} else if (bi.getType()==BufferedImage.TYPE_BYTE_GRAY) {
+				setProcessor(null, new ByteProcessor(bi));
+				return;
+			}
+		}
+		roi = null;
+		errorLoadingImage = false;
+		waitForImage(image);
+		if (errorLoadingImage)
+			throw new IllegalStateException ("Error loading image");
+		int newWidth = image.getWidth(ij);
+		int newHeight = image.getHeight(ij);
+		boolean dimensionsChanged = newWidth!=width || newHeight!=height;
+		width = newWidth;
+		height = newHeight;
+		setStackNull();
+		LookUpTable lut = new LookUpTable(image);
+		int type = lut.getMapSize()>0?GRAY8:COLOR_RGB;
+		if (image!=null && type==COLOR_RGB)
+			ip = new ColorProcessor(image);
+		if (ip==null && image!=null)
+			ip = new ByteProcessor(image);
+		setType(type);
+		this.img = ip.createImage();
+		if (win!=null) {
+			if (dimensionsChanged)
+				win = new ImageWindow(this);
+			else
+				repaintWindow();
+		}
+	}
+	
+	/**
+	 * Extract pixels as an an ImageProcessor from a single band of a BufferedImage.
+	 * @param img
+	 * @param band
+	 * @return
+	 */
+	public static ImageProcessor convertToImageProcessor(BufferedImage img, int band) {
+		int w = img.getWidth();
+		int h = img.getHeight();
+		int dataType = img.getSampleModel().getDataType();
+		// Read data as float (no matter what it is - it's the most accuracy ImageJ can provide)
+		FloatProcessor fp = new FloatProcessor(w, h);
+		float[] pixels = (float[])fp.getPixels();
+		img.getRaster().getSamples(0, 0, w, h, band, pixels);
+		// Convert to 8 or 16-bit, if appropriate
+		if (dataType == DataBuffer.TYPE_BYTE) {
+			ByteProcessor bp = new ByteProcessor(w, h);
+			bp.setPixels(0, fp);
+			return bp;
+		} else if (dataType == DataBuffer.TYPE_USHORT) {
+			ShortProcessor sp = new ShortProcessor(w, h);
+			sp.setPixels(0, fp);
+			return sp;
+		} else
+			return fp;
+	}
+
+	/** Replaces this image with the specified ImagePlus. May
+		not work as expected if 'imp' is a CompositeImage
+		and this image is not. */
+	public void setImage(ImagePlus imp) {
+		Properties newProperties = imp.getProperties();
+		if (newProperties!=null)
+			newProperties = (Properties)(newProperties.clone());
+		if (imp.getWindow()!=null)
+			imp = imp.duplicate();
+		ImageStack stack2 = imp.getStack();
+		if (imp.isHyperStack())
+			setOpenAsHyperStack(true);
+		LUT[] luts = null;
+		if (imp.isComposite() && (this instanceof CompositeImage)) {
+			if (((CompositeImage)imp).getMode()!=((CompositeImage)this).getMode())
+				((CompositeImage)this).setMode(((CompositeImage)imp).getMode());
+			luts = ((CompositeImage)imp).getLuts();
+		}
+		LUT lut = !imp.isComposite()?imp.getProcessor().getLut():null;
+		setStack(stack2, imp.getNChannels(), imp.getNSlices(), imp.getNFrames());
+		compositeImage = imp.isComposite();
+		if (luts!=null) {
+			((CompositeImage)this).setLuts(luts);
+			((CompositeImage)this).setMode(((CompositeImage)imp).getMode());
+			updateAndRepaintWindow();
+		} else if (lut!=null) {
+			getProcessor().setLut(lut);
+			updateAndRepaintWindow();
+		}
+		setTitle(imp.getTitle());
+		setCalibration(imp.getCalibration());
+		setOverlay(imp.getOverlay());
+		properties = newProperties;
+		if (getProperty(Plot.PROPERTY_KEY)!=null && win instanceof PlotWindow) {
+			Plot plot = (Plot)(getProperty(Plot.PROPERTY_KEY));
+			((PlotWindow)win).setPlot(plot);
+			plot.setImagePlus(this);
+		}
+		setFileInfo(imp.getOriginalFileInfo());
+		setProperty ("Info", imp.getProperty ("Info"));
+		setProperties(imp.getPropertiesAsArray());
+	}
+
+	/** Replaces the ImageProcessor with the one specified and updates the
+		 display. With stacks, the ImageProcessor must be the same type as the
+		 other images in the stack and it must be the same width and height. */
+	public void setProcessor(ImageProcessor ip) {
+		setProcessor(null, ip);
+	}
+
+	/** Replaces the ImageProcessor with the one specified and updates the display. With
+		stacks, the ImageProcessor must be the same type as other images in the stack and
+		it must be the same width and height.  Set 'title' to null to leave the title unchanged. */
+	public void setProcessor(String title, ImageProcessor ip) {
+		if (ip==null || ip.getPixels()==null)
+			throw new IllegalArgumentException("ip null or ip.getPixels() null");
+		if (getStackSize()>1) {
+			if (ip.getWidth()!=width || ip.getHeight()!=height)
+				throw new IllegalArgumentException("Wrong dimensions for this stack");
+			int stackBitDepth = stack!=null?stack.getBitDepth():0;
+			if (stackBitDepth>0 && getBitDepth()!=stackBitDepth)
+				throw new IllegalArgumentException("Wrong type for this stack");
+		} else {
+			setStackNull();
+			setCurrentSlice(1);
+		}
+		setProcessor2(title, ip, null);
+	}
+
+	void setProcessor2(String title, ImageProcessor ip, ImageStack newStack) {
+		if (title!=null) setTitle(title);
+		if (ip==null)
+			return;
+		this.ip = ip;
+		if (this.ip!=null && getWindow()!=null)
+			notifyListeners(UPDATED);
+		if (ij!=null)
+			ip.setProgressBar(ij.getProgressBar());
+		int stackSize = 1;
+		boolean dimensionsChanged = width>0 && height>0 && (width!=ip.getWidth() || height!=ip.getHeight());
+		if (stack!=null) {
+			stackSize = stack.size();
+			if (currentSlice>stackSize)
+				setCurrentSlice(stackSize);
+			if (currentSlice>=1 && currentSlice<=stackSize && !dimensionsChanged)
+				stack.setPixels(ip.getPixels(),currentSlice);
+		}
+		img = null;
+		if (dimensionsChanged) roi = null;
+		int type;
+		if (ip instanceof ByteProcessor)
+			type = GRAY8;
+		else if (ip instanceof ColorProcessor)
+			type = COLOR_RGB;
+		else if (ip instanceof ShortProcessor)
+			type = GRAY16;
+		else
+			type = GRAY32;
+		if (width==0)
+			imageType = type;
+		else
+			setType(type);
+		width = ip.getWidth();
+		height = ip.getHeight();
+		if (win!=null) {
+			if (dimensionsChanged && stackSize==1)
+                win.updateImage(this);
+			else if (newStack==null)
+				repaintWindow();
+				draw();
+		}
+	}
+
+	/** Replaces the image with the specified stack and updates the display. */
+	public void setStack(ImageStack stack) {
+    	setStack(null, stack);
+    }
+
+	/** Replaces the image with the specified stack and updates
+		the display. Set 'title' to null to leave the title unchanged. */
+    public void setStack(String title, ImageStack newStack) {
+		int bitDepth1 = getBitDepth();
+		int previousStackSize = getStackSize();
+		int newStackSize = newStack.getSize();
+		if (newStackSize==0)
+			throw new IllegalArgumentException("Stack is empty");		
+		if (!newStack.isVirtual()) {
+			Object[] arrays = newStack.getImageArray();
+			if (arrays==null || (arrays.length>0&&arrays[0]==null))
+				throw new IllegalArgumentException("Stack pixel array null");
+		}
+    	boolean sliderChange = false;
+    	if (win!=null && (win instanceof StackWindow)) {
+    		int nScrollbars = ((StackWindow)win).getNScrollbars();
+    		if (nScrollbars>0 && newStackSize==1)
+    			sliderChange = true;
+    		else if (nScrollbars==0 && newStackSize>1)
+    			sliderChange = true;
+    	}
+    	if (currentSlice<1) setCurrentSlice(1);
+    	boolean resetCurrentSlice = currentSlice>newStackSize;
+    	if (resetCurrentSlice) setCurrentSlice(newStackSize);
+    	ImageProcessor ip = newStack.getProcessor(currentSlice);
+    	boolean dimensionsChanged = width>0 && height>0 && (width!=ip.getWidth()||height!=ip.getHeight());
+    	if (this.stack==null)
+    	    newStack.viewers(+1);
+    	this.stack = newStack;
+    	oneSliceStack = false;
+    	setProcessor2(title, ip, newStack);
+		if (bitDepth1!=0 && bitDepth1!=getBitDepth())
+			compositeChanges = true;
+		if (compositeChanges && (this instanceof CompositeImage)) {
+			this.compositeImage = getStackSize()!=getNSlices();
+			((CompositeImage)this).completeReset();
+			if (bitDepth1!=0 && bitDepth1!=getBitDepth())
+				((CompositeImage)this).resetDisplayRanges();
+		}
+		compositeChanges = false;
+		if (win==null) {
+			if (resetCurrentSlice) setSlice(currentSlice);
+			return;
+		}
+		boolean invalidDimensions = (isDisplayedHyperStack()||(this instanceof CompositeImage)) && (win instanceof StackWindow) && !((StackWindow)win).validDimensions();
+		if (newStackSize>1 && !(win instanceof StackWindow)) {
+			if (isDisplayedHyperStack())
+				setOpenAsHyperStack(true);
+			activated = false;
+			win = new StackWindow(this, dimensionsChanged?null:getCanvas());   // replaces this window
+			if (IJ.isMacro()) waitTillActivated(); // wait for stack window to be activated
+			setPosition(1, 1, 1);
+		} else if (newStackSize>1 && invalidDimensions) {
+			if (isDisplayedHyperStack())
+				setOpenAsHyperStack(true);
+			win = new StackWindow(this);   // replaces this window
+			setPosition(1, 1, 1);
+		} else if (dimensionsChanged || sliderChange) {
+			win.updateImage(this);
+		} else {
+			if (win!=null && win instanceof StackWindow)
+				((StackWindow)win).updateSliceSelector();
+			if (isComposite()) {
+				((CompositeImage)this).reset();
+				updateAndDraw();
+			}
+			repaintWindow();
+		}
+		if (resetCurrentSlice)
+			setSlice(currentSlice);
+    }
+
+	public void setStack(ImageStack newStack, int channels, int slices, int frames) {
+		if (newStack==null || channels*slices*frames!=newStack.getSize())
+			throw new IllegalArgumentException("channels*slices*frames!=stackSize");
+		if (IJ.debugMode) IJ.log("setStack: "+newStack.getSize()+" "+channels+" "+slices+" "+frames+" "+isComposite());
+		compositeChanges = channels!=this.nChannels;
+		this.nChannels = channels;
+		this.nSlices = slices;
+		this.nFrames = frames;
+		setStack(null, newStack);
+	}
+
+	private synchronized void setStackNull() {
+		if (oneSliceStack && stack!=null && stack.size()>0) {
+			String label = stack.getSliceLabel(1);
+			setProp("Slice_Label", label);
+		}
+		stack = null;
+		oneSliceStack = false;
+	}
+
+	/**	Saves this image's FileInfo so it can be later
+		retieved using getOriginalFileInfo(). */
+	public void setFileInfo(FileInfo fi) {
+		if (fi!=null) {
+			fi.pixels = null;
+			if (fi.imageSaved) {
+				notifyListeners(SAVED);
+				fi.imageSaved = false;
+			}
+		}
+		fileInfo = fi;
+	}
+
+	/** Returns the ImageWindow that is being used to display
+		this image. Returns null if show() has not be called
+		or the ImageWindow has been closed. */
+	public ImageWindow getWindow() {
+		return win;
+	}
+
+	/** Returns true if this image is currently being displayed in a window. */
+	public boolean isVisible() {
+		return win!=null && win.isVisible();
+	}
+
+	/** This method should only be called from an ImageWindow. */
+	public void setWindow(ImageWindow win) {
+		this.win = win;
+		if (roi!=null)
+			roi.setImage(this);  // update roi's 'ic' field
+	}
+
+	/** Returns the ImageCanvas being used to
+		display this image, or null. */
+	public ImageCanvas getCanvas() {
+		return win!=null?win.getCanvas():flatteningCanvas;
+	}
+
+	/** Sets current foreground color. */
+	public void setColor(Color c) {
+		if (ip!=null)
+			ip.setColor(c);
+	}
+
+	void setupProcessor() {
+	}
+
+	public boolean isProcessor() {
+		return ip!=null;
+	}
+
+	/** Returns a reference to the current ImageProcessor. If there
+	    is no ImageProcessor, it creates one. Returns null if this
+	    ImagePlus contains no ImageProcessor and no AWT Image.
+		Sets the line width to the current line width and sets the
+		calibration table if the image is density calibrated. */
+	public ImageProcessor getProcessor() {
+		if (ip==null)
+			return null;
+		if (roi!=null && roi.isArea())
+			ip.setRoi(roi.getBounds());
+		else
+			ip.resetRoi();
+		if (!compositeImage)
+			ip.setLineWidth(Line.getWidth());
+		if (ij!=null)
+			ip.setProgressBar(ij.getProgressBar());
+		Calibration cal = getCalibration();
+		if (cal.calibrated())
+			ip.setCalibrationTable(cal.getCTable());
+		else
+			ip.setCalibrationTable(null);
+		if (Recorder.record) {
+			Recorder recorder = Recorder.getInstance();
+			if (recorder!=null) recorder.imageUpdated(this);
+		}
+		return ip;
+	}
+
+	/** Frees RAM by setting the snapshot (undo) buffer in
+		the current ImageProcessor to null. */
+	public void trimProcessor() {
+		ImageProcessor ip2 = ip;
+		if (!locked && ip2!=null) {
+			if (IJ.debugMode) IJ.log(title + ": trimProcessor");
+			Roi roi2 = getRoi();
+			if (roi2!=null && roi2.getPasteMode()!=Roi.NOT_PASTING)
+				roi2.endPaste();
+			ip2.setSnapshotPixels(null);
+		}
+	}
+
+	/** For images with irregular ROIs, returns a byte mask, otherwise, returns
+	 * null. Mask pixels have a non-zero value.and the dimensions of the
+	 * mask are equal to the width and height of the ROI.
+	 * @see ij.ImagePlus#createRoiMask
+	 * @see ij.ImagePlus#createThresholdMask
+	*/
+	public ImageProcessor getMask() {
+		if (roi==null) {
+			if (ip!=null) ip.resetRoi();
+			return null;
+		}
+		ImageProcessor mask = roi.getMask();
+		if (mask==null)
+			return null;
+		if (ip!=null && roi!=null) {
+			ip.setMask(mask);
+			ip.setRoi(roi.getBounds());
+		}
+		return mask;
+	}
+
+	/** Returns an 8-bit binary (foreground=255, background=0)
+	 * ROI or overlay mask that has the same dimensions
+	 * as this image. Creates an ROI mask If the image has both
+	 * both an ROI and an overlay. Set the threshold of the mask to 255.
+	 * @see #createThresholdMask
+	 * @see ij.gui.Roi#getMask
+	*/
+	public ByteProcessor createRoiMask() {
+		Roi roi2 = getRoi();
+		Overlay overlay2 = getOverlay();
+		if (roi2==null && overlay2==null)
+			throw new IllegalArgumentException("ROI or overlay required");
+		ByteProcessor mask = new ByteProcessor(getWidth(),getHeight());
+		mask.setColor(255);
+		if (roi2!=null)
+			mask.fill(roi2);
+		else if (overlay2!=null) {
+			if (overlay2.size()==1 && (overlay2.get(0) instanceof ImageRoi)) {
+				ImageRoi iRoi = (ImageRoi)overlay2.get(0);
+				ImageProcessor ip = iRoi.getProcessor();
+				if (ip.getWidth()!=mask.getWidth() || ip.getHeight()!=mask.getHeight())
+					return mask;
+				for (int i=0; i<ip.getPixelCount(); i++) {
+					if (ip.get(i)!=0)
+						mask.set(i, 255);
+				}
+			} else {
+				for (int i=0; i<overlay2.size(); i++)
+					mask.fill(overlay2.get(i));
+			}
+		}
+		mask.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+		return mask;
+	}
+
+	/** Returns an 8-bit binary threshold mask
+	 * (foreground=255, background=0)
+	 * that has the same dimensions as this image.
+	 * The threshold of the mask is set to 255.
+	 * @see ij.plugin.Thresholder#createMask
+	 * @see ij.process.ImageProcessor#createMask
+	*/
+	public ByteProcessor createThresholdMask() {
+		ByteProcessor mask = Thresholder.createMask(this);
+		mask.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+		return mask;
+	}
+
+	/** Get calibrated statistics for this image or ROI, including
+		 histogram, area, mean, min and max, standard
+		 deviation and mode.
+		This code demonstrates how to get the area, mean
+		max and median of the current image or selection:
+		<pre>
+         imp = IJ.getImage();
+         stats = imp.getStatistics();
+         IJ.log("Area: "+stats.area);
+         IJ.log("Mean: "+stats.mean);
+         IJ.log("Max: "+stats.max);
+		</pre>
+		@return an {@link ij.process.ImageStatistics} object
+		@see #getAllStatistics
+		@see #getRawStatistics
+		@see ij.process.ImageProcessor#getStats
+		*/
+	public ImageStatistics getStatistics() {
+		return getStatistics(AREA+MEAN+STD_DEV+MODE+MIN_MAX+RECT);
+	}
+
+	/** This method returns complete calibrated statistics for this
+	 * image or ROI (with "Limit to threshold"), but it is up to 70 times
+	 * slower than getStatistics().
+	 * @return an {@link ij.process.ImageStatistics} object
+	 * @see #getStatistics
+	 * @see ij.process.ImageProcessor#getStatistics
+	*/
+	public ImageStatistics getAllStatistics() {
+		return getStatistics(ALL_STATS+LIMIT);
+	}
+
+	/* Returns uncalibrated statistics for this image or ROI, including
+		256 bin histogram, pixelCount, mean, mode, min and max. */
+	public ImageStatistics getRawStatistics() {
+		if (roi!=null && roi.isArea())
+			ip.setRoi(roi);
+		else
+			ip.resetRoi();
+		return ImageStatistics.getStatistics(ip, AREA+MEAN+MODE+MIN_MAX, null);
+	}
+
+	/** Returns an ImageStatistics object generated using the
+		specified measurement options.
+		@see ij.measure.Measurements
+	*/
+	public ImageStatistics getStatistics(int mOptions) {
+		return getStatistics(mOptions, 256, 0.0, 0.0);
+	}
+
+	/** Returns an ImageStatistics object generated using the
+		specified measurement options and histogram bin count.  */
+	public ImageStatistics getStatistics(int mOptions, int nBins) {
+		return getStatistics(mOptions, nBins, 0.0, 0.0);
+	}
+
+	/** Returns an ImageStatistics object generated using the
+		specified measurement options, histogram bin count
+		and histogram range. */
+	public ImageStatistics getStatistics(int mOptions, int nBins, double histMin, double histMax) {
+		ImageProcessor ip2 = ip;
+		int bitDepth = getBitDepth();
+		if (nBins!=256 && (bitDepth==8||bitDepth==24))
+			ip2 =ip.convertToShort(false);
+		Roi roi2 = roi;
+		if (roi2==null)
+			ip2.resetRoi();
+		else if (roi2.isArea())
+			ip2.setRoi(roi2);
+		else if ((roi2 instanceof PointRoi) && roi2.size()==1) {
+				// needed to be consistent with ImageProcessor.getStatistics()
+				FloatPolygon p = roi2.getFloatPolygon();
+				ip2.setRoi((int)p.xpoints[0], (int)p.ypoints[0], 1, 1);
+		}
+		ip2.setHistogramSize(nBins);
+		Calibration cal = getCalibration();
+		if (getType()==GRAY16&& !(histMin==0.0&&histMax==0.0)) {
+			histMin = cal.getRawValue(histMin);
+			histMax=cal.getRawValue(histMax);
+		}
+		ip2.setHistogramRange(histMin, histMax);
+		ImageStatistics stats = ImageStatistics.getStatistics(ip2, mOptions, cal);
+		ip2.setHistogramSize(256);
+		ip2.setHistogramRange(0.0, 0.0);
+		return stats;
+	}
+
+	/** Returns the image name. */
+	public String getTitle() {
+		if (title==null)
+			return "";
+		else
+    		return title;
+    }
+
+	/** If the image title is a file name, returns the name
+		without the extension and with spaces removed,
+		otherwise returns the title shortened to the first space.
+	*/	
+	public String getShortTitle() {
+		String title = getTitle().trim();
+		int index = title.lastIndexOf('.');
+		boolean fileName = index>0;
+		if (fileName) {
+			title = title.substring(0, index);
+			title = title.replaceAll(" ","");
+		} else {
+			index = title.indexOf(' ');
+			if (index>-1 && !fileName)
+				title = title.substring(0, index);
+		}
+		return title;
+    }
+
+	/** Sets the image name. */
+	public void setTitle(String title) {
+		if (title==null)
+			return;
+    	if (win!=null) {
+    		if (ij!=null)
+				Menus.updateWindowMenuItem(this, this.title, title);
+			String virtual = stack!=null && stack.isVirtual()?" (V)":"";
+			String global = getGlobalCalibration()!=null?" (G)":"";
+			String scale = "";
+			double magnification = win.getCanvas().getMagnification();
+			if (magnification!=1.0) {
+				double percent = magnification*100.0;
+				int digits = percent>100.0||percent==(int)percent?0:1;
+				scale = " (" + IJ.d2s(percent,digits) + "%)";
+			}
+			win.setTitle(title+virtual+global+scale);
+		}
+		boolean titleChanged = !title.equals(this.title);
+		this.title = title;
+		if (titleChanged && listeners.size()>0)
+			notifyListeners(UPDATED);
+    }
+
+    /** Returns the width of this image in pixels. */
+    public int getWidth() {
+    	return width;
+    }
+
+    /** Returns the height of this image in pixels. */
+    public int getHeight() {
+    	return height;
+    }
+
+    /** Returns the size of this image in bytes. */
+    public double getSizeInBytes() {
+    	double size = ((double)getWidth()*getHeight()*getStackSize());
+		int type = getType();
+    	switch (type) {
+	    	case ImagePlus.GRAY16: size *= 2.0; break;
+	    	case ImagePlus.GRAY32: size *= 4.0; break;
+	    	case ImagePlus.COLOR_RGB: size *= 4.0; break;
+    	}
+    	return size;
+	}
+
+	/** If this is a stack, returns the number of slices, else returns 1. */
+	public int getStackSize() {
+		if (stack==null || oneSliceStack)
+			return 1;
+		else {
+			int slices = stack.size();
+			if (slices<=0) slices = 1;
+			return slices;
+		}
+	}
+
+	/** If this is a stack, returns the actual number of images in the stack, else returns 1. */
+	public int getImageStackSize() {
+		if (stack==null)
+			return 1;
+		else {
+			int slices = stack.size();
+			if (slices==0) slices = 1;
+			return slices;
+		}
+	}
+
+	/** Sets the 3rd, 4th and 5th dimensions, where
+	<code>nChannels</code>*<code>nSlices</code>*<code>nFrames</code>
+	must be equal to the stack size. */
+	public void setDimensions(int nChannels, int nSlices, int nFrames) {
+		//IJ.log("setDimensions: "+nChannels+" "+nSlices+" "+nFrames+" "+getImageStackSize());
+		if (nChannels*nSlices*nFrames!=getImageStackSize() && ip!=null) {
+			//throw new IllegalArgumentException("channels*slices*frames!=stackSize");
+			nChannels = 1;
+			nSlices = getImageStackSize();
+			nFrames = 1;
+			if (isDisplayedHyperStack()) {
+				setOpenAsHyperStack(false);
+				new StackWindow(this);
+				setSlice(1);
+			}
+		}
+		boolean updateWin = isDisplayedHyperStack() && (this.nChannels!=nChannels||this.nSlices!=nSlices||this.nFrames!=nFrames);
+		boolean newSingleImage = win!=null && (win instanceof StackWindow) && nChannels==1&&nSlices==1&&nFrames==1;
+		if (newSingleImage) updateWin = true;
+		this.nChannels = nChannels;
+		this.nSlices = nSlices;
+		this.nFrames = nFrames;
+		if (updateWin) {
+			if (nSlices!=getImageStackSize())
+				setOpenAsHyperStack(true);
+			ip = null;
+			img = null;
+			setPositionWithoutUpdate(getChannel(), getSlice(), getFrame());
+			if (isComposite()) ((CompositeImage)this).reset();
+			new StackWindow(this);
+		}
+		dimensionsSet = true;
+	}
+
+	/** Returns 'true' if this image is a hyperstack. */
+	public boolean isHyperStack() {
+		return isDisplayedHyperStack() || (openAsHyperStack&&getNDimensions()>3);
+	}
+
+	/** Returns the number of dimensions (2, 3, 4 or 5). */
+	public int getNDimensions() {
+		int dimensions = 2;
+		int[] dim = getDimensions(true);
+		if (dim[2]>1) dimensions++;
+		if (dim[3]>1) dimensions++;
+		if (dim[4]>1) dimensions++;
+		return dimensions;
+	}
+
+	/** Returns 'true' if this is a hyperstack currently being displayed in a StackWindow. */
+	public boolean isDisplayedHyperStack() {
+		return win!=null && win instanceof StackWindow && ((StackWindow)win).isHyperStack();
+	}
+
+	/** Returns the number of channels. */
+	public int getNChannels() {
+		verifyDimensions();
+		return nChannels;
+	}
+
+	/** Returns the image depth (number of z-slices). */
+	public int getNSlices() {
+		verifyDimensions();
+		return nSlices;
+	}
+
+	/** Returns the number of frames (time-points). */
+	public int getNFrames() {
+		verifyDimensions();
+		return nFrames;
+	}
+
+	/** Returns the dimensions of this image (width, height, nChannels,
+		nSlices, nFrames) as a 5 element int array. */
+	public int[] getDimensions() {
+		return getDimensions(true);
+	}
+
+	public int[] getDimensions(boolean varify) {
+		if (varify)
+			verifyDimensions();
+		int[] d = new int[5];
+		d[0] = width;
+		d[1] = height;
+		d[2] = nChannels;
+		d[3] = nSlices;
+		d[4] = nFrames;
+		return d;
+	}
+
+	void verifyDimensions() {
+		int stackSize = getImageStackSize();
+		if (nSlices==1) {
+			if (nChannels>1 && nFrames==1)
+				nChannels = stackSize;
+			else if (nFrames>1 && nChannels==1)
+				nFrames = stackSize;
+		}
+		if (nChannels*nSlices*nFrames!=stackSize) {
+			nSlices = stackSize;
+			nChannels = 1;
+			nFrames = 1;
+		}
+	}
+
+	/** Returns the current image type (ImagePlus.GRAY8, ImagePlus.GRAY16,
+		ImagePlus.GRAY32, ImagePlus.COLOR_256 or ImagePlus.COLOR_RGB).
+		@see #getBitDepth
+	*/
+    public int getType() {
+    	return imageType;
+    }
+
+    /** Returns the bit depth, 8, 16, 24 (RGB) or 32, or 0 if the bit depth
+    	is unknown. RGB images actually use 32 bits per pixel. */
+    public int getBitDepth() {
+    	ImageProcessor ip2 = ip;
+    	if (ip2==null) {
+			int bitDepth = 0;
+			switch (imageType) {
+				case GRAY8: bitDepth=typeSet?8:0; break;
+				case COLOR_256: bitDepth=8; break;
+				case GRAY16: bitDepth=16; break;
+				case GRAY32: bitDepth=32; break;
+				case COLOR_RGB: bitDepth=24; break;
+			}
+			return bitDepth;
+    	}
+    	if (ip2 instanceof ByteProcessor)
+    		return 8;
+    	else if (ip2 instanceof ShortProcessor)
+    		return 16;
+    	else if (ip2 instanceof ColorProcessor)
+    		return 24;
+      	else if (ip2 instanceof FloatProcessor)
+    		return 32;
+    	return 0;
+    }
+
+    /** Returns the number of bytes per pixel. */
+    public int getBytesPerPixel() {
+    	switch (imageType) {
+	    	case GRAY16: return 2;
+	    	case GRAY32: case COLOR_RGB: return 4;
+	    	default: return 1;
+    	}
+	}
+
+	protected void setType(int type) {
+		if ((type<0) || (type>COLOR_RGB))
+			return;
+		int previousType = imageType;
+		imageType = type;
+		if (imageType!=previousType) {
+			if (win!=null)
+				Menus.updateMenus();
+			getLocalCalibration().setImage(this);
+		}
+		typeSet = true;
+	}
+	
+	public void setTypeToColor256() {
+		if (imageType==ImagePlus.GRAY8) {
+			ImageProcessor ip2 = getProcessor();
+			if (ip2!=null && ip2.getMinThreshold()==ImageProcessor.NO_THRESHOLD && ip2.isColorLut() && !ip2.isPseudoColorLut()) {
+				imageType = COLOR_256;
+				typeSet = true;
+			}
+		}
+	}
+	
+
+ 	/** Returns the string value from the "Info" property string
+	 * associated with 'key', or null if the key is not found.
+	 * Works with DICOM tags and Bio-Formats metadata.
+	 * @see #getNumericProperty
+	 * @see #getInfoProperty
+	 * @see #getProp
+	 * @see #setProp
+	*/
+	public String getStringProperty(String key) {
+		if (key==null)
+			return null;
+		if (isDicomTag(key))
+			return DicomTools.getTag(this, key);
+		if (getStackSize()>1) {
+			ImageStack stack2 = getStack();
+			String label = stack2.getSliceLabel(getCurrentSlice());
+			if (label!=null && label.indexOf('\n')>0) {
+				String value = getStringProperty(key, label);
+				if (value!=null)
+					return value;
+			}
+		}
+		Object obj = getProperty("Info");
+		if (obj==null || !(obj instanceof String))
+			return null;
+		String info = (String)obj;
+		return getStringProperty(key, info);
+	}
+
+	private boolean isDicomTag(String key) {
+		if (key.length()!=9 || key.charAt(4)!=',')
+			return false;
+		key = key.toLowerCase();
+		for (int i=0; i<9; i++) {
+			char c = i!=4?key.charAt(i):'0';
+			if (!(Character.isDigit(c)||(c=='a'||c=='b'||c=='c'||c=='d'||c=='e'||c=='f')))
+				return false;
+		}
+		return true;
+	}
+
+	/** Returns the numeric value from the "Info" property string
+	 * associated with 'key', or NaN if the key is not found or the
+	 * value associated with the key is not numeric. Works with
+	 * DICOM tags and Bio-Formats metadata.
+	 * @see #getStringProperty
+	 * @see #getInfoProperty
+	*/
+	public double getNumericProperty(String key) {
+		return Tools.parseDouble(getStringProperty(key));
+	}
+
+	private String getStringProperty(String key, String info) {
+		int index1 = -1;
+		index1 = findKey(info, key+": "); // standard 'key: value' pair?
+		if (index1<0) // Bio-Formats metadata?
+			index1 = findKey(info, key+" = ");
+		if (index1<0) // '=' with no spaces
+			index1 = findKey(info, key+"=");
+		if (index1<0) // otherwise not found
+			return null;
+		if (index1==info.length())
+			return ""; //empty value at the end
+		int index2 = info.indexOf("\n", index1);
+		if (index2==-1)
+			index2=info.length();
+		String value = info.substring(index1, index2);
+		return value;
+	}
+
+	/** Find a key in a String (words merely ending with 'key' don't qualify).
+	* @return index of first character after the key, or -1 if not found
+	*/
+	private int findKey(String s, String key) {
+		int i = s.indexOf(key);
+		if (i<0)
+			return -1; //key not found
+		while (i>0 && Character.isLetterOrDigit(s.charAt(i-1)))
+			i = s.indexOf(key, i+key.length());
+		if (i>=0)
+			return i + key.length();
+		else
+			return -1;
+	}
+
+	/** Adds a key-value pair to this image's string properties.
+	 * The key-value pair is removed if 'value' is null. The 
+	 * properties persist if the image is saved in TIFF format.
+	 * Add a "HideInfo" property (e.g. set("HideInfo","true")) to
+	 * prevent the properties from being displayed by the
+	 * Image/Show Info command.
+	*/
+	public void setProp(String key, String value) {
+		if (key==null)
+			return;
+		if (imageProperties==null)
+			imageProperties = new Properties();
+		if (value==null || value.length()==0)
+			imageProperties.remove(key);
+		else
+			imageProperties.setProperty(key, value);
+	}
+	
+	/** Saves a persistent numeric propery. The property is
+	 *  removed if 'value' is NaN.
+	 * @see #getNumericProp
+	*/
+	public void setProp(String key, double value) {
+		String svalue = ""+value;
+		if (svalue.endsWith(".0"))
+			svalue = svalue.substring(0,svalue.length()-2);
+		setProp(key, Double.isNaN(value)?null:svalue);
+	}
+
+	/** Returns as a string the image property associated with the
+	 *  specified key or null if the property is not found.
+	 * @see #setProp
+	 * @see #getNumericProp
+	 * @see #getStringProperty
+	*/
+	public String getProp(String key) {
+		if (imageProperties==null)
+			return getStringProperty(key);
+		else {
+			String value = imageProperties.getProperty(key);
+			if (value==null)
+				value = getStringProperty(key);
+			return value;
+		}
+	}
+	
+	/** Returns the numeric property associated with the specified key
+	 * or NaN if the property is not found.
+	 * @see #setProp(String,double)
+	 * @see #getProp
+	*/
+	public double getNumericProp(String key) {
+		if (imageProperties==null)
+			return Double.NaN;
+		else
+			return Tools.parseDouble(getProp(key), Double.NaN);
+	}
+
+	/** Used for saving string properties in TIFF header. */
+	public String[] getPropertiesAsArray() {
+		if (imageProperties==null || imageProperties.size()==0)
+			return null;
+		String props[] = new String[imageProperties.size()*2];
+		int index = 0;
+		for (Enumeration en=imageProperties.keys(); en.hasMoreElements();) {
+			String key = (String)en.nextElement();
+			String value = imageProperties.getProperty(key);
+			props[index++] = key;
+			props[index++] = value;
+		}
+		return props;
+	}
+	
+	/** Returns information displayed by Image/Show Info command. */
+	public String getPropsInfo() {
+		if (imageProperties==null || imageProperties.size()==0)
+			return "0";
+		String info2 = "";
+		for (Enumeration en=imageProperties.keys(); en.hasMoreElements();) {
+			String key = (String)en.nextElement();
+			if (info2.length()>50) {
+				info2 += "...";
+				break;
+			} else
+				info2 += " " + key;
+		}
+		if (info2.length()>1)
+			info2 = " (" + info2.substring(1) + ")";
+		return imageProperties.size() + info2;			
+	}
+	
+	/** Creates a set of image properties from an array of strings.
+	 * @see #getPropertiesAsArray
+	 * @see #getProp(String)
+	 * @see #setProp(String,String)
+	*/
+	public void setProperties(String[] props) {
+		imageProperties = null;
+		if (props==null)
+			return;
+		//IJ.log("setProperties: "+props.length+" "+getTitle());
+		for (int i=0; i<props.length; i+=2) {
+			String key = props[i];
+			String value = props[i+1];
+			//IJ.log("   "+key+" "+value.length());
+			setProp(key,value);
+		}
+	}
+
+	/** Returns the "Info" property string, or null if it is not found.
+	 * @see #getProp
+	 * @see #setProp
+	*/
+	public String getInfoProperty() {
+		String info = null;
+		Object obj = getProperty("Info");
+		if (obj!=null && (obj instanceof String)) {
+			info = (String)obj;
+			if (info.length()==0)
+				info = null;
+		}
+		return info;
+	}
+
+	/** Returns the property associated with 'key', or null if it is not found.
+	 * @see #getProp
+	 * @see #setProp
+	 * @see #getStringProperty
+	 * @see #getNumericProperty
+	 * @see #getInfoProperty
+	*/
+	public Object getProperty(String key) {
+		if (properties==null)
+			return null;
+		else
+			return properties.get(key);
+	}
+
+	/** Adds a key-value pair to this image's properties. The key
+	 * is removed from the properties table if value is null.
+	 * @see #getProp
+	 * @see #setProp
+	*/
+	public void setProperty(String key, Object value) {
+		if (properties==null)
+			properties = new Properties();
+		if (value==null)
+			properties.remove(key);
+		else
+			properties.put(key, value);
+	}
+
+	/** Returns this image's Properties. May return null. */
+	public Properties getProperties() {
+			return properties;
+	}
+	/** Creates a LookUpTable object that corresponds to this image. */
+    public LookUpTable createLut() {
+		ImageProcessor ip2 = getProcessor();
+		if (ip2!=null)
+			return new LookUpTable(ip2.getColorModel());
+		else
+			return new LookUpTable(LookUpTable.createGrayscaleColorModel(false));
+	}
+
+	/** Returns true is this image uses an inverting LUT that
+		displays zero as white and 255 as black. */
+	public boolean isInvertedLut() {
+		return ip!=null && ip.isInvertedLut();
+	}
+
+	private int[] pvalue = new int[4];
+
+	/**
+	Returns the pixel value at (x,y) as a 4 element array. Grayscale values
+	are retuned in the first element. RGB values are returned in the first
+	3 elements. For indexed color images, the RGB values are returned in the
+	first 3 three elements and the index (0-255) is returned in the last.
+	*/
+	public int[] getPixel(int x, int y) {
+		pvalue[0]=pvalue[1]=pvalue[2]=pvalue[3]=0;
+		switch (imageType) {
+			case GRAY8: case COLOR_256:
+				int index;
+				if (ip!=null)
+					index = ip.getPixel(x, y);
+				else {
+					byte[] pixels8;
+					if (img==null) return pvalue;
+					PixelGrabber pg = new PixelGrabber(img,x,y,1,1,false);
+					try {pg.grabPixels();}
+					catch (InterruptedException e){return pvalue;};
+					pixels8 = (byte[])(pg.getPixels());
+					index = pixels8!=null?pixels8[0]&0xff:0;
+				}
+				if (imageType!=COLOR_256) {
+					pvalue[0] = index;
+					return pvalue;
+				}
+				pvalue[3] = index;
+				// fall through to get rgb values
+			case COLOR_RGB:
+				if (ip!=null && ip.getNChannels()==1) {
+					pvalue[0] = ip.getPixel(x, y);
+					return pvalue;
+				}
+				int c = 0;
+				if (imageType==COLOR_RGB && ip!=null)
+					c = ip.getPixel(x, y);
+				else {
+					int[] pixels32 = new int[1];
+					if (img==null) return pvalue;
+					PixelGrabber pg = new PixelGrabber(img, x, y, 1, 1, pixels32, 0, width);
+					try {pg.grabPixels();}
+					catch (InterruptedException e) {return pvalue;};
+					c = pixels32[0];
+				}
+				int r = (c&0xff0000)>>16;
+				int g = (c&0xff00)>>8;
+				int b = c&0xff;
+				pvalue[0] = r;
+				pvalue[1] = g;
+				pvalue[2] = b;
+				break;
+			case GRAY16: case GRAY32:
+				if (ip!=null) pvalue[0] = ip.getPixel(x, y);
+				break;
+		}
+		return pvalue;
+	}
+
+	/** Returns an empty image stack that has the same
+		width, height and color table as this image. */
+	public ImageStack createEmptyStack() {
+		ColorModel cm;
+		if (ip!=null)
+			cm = ip.getColorModel();
+		else
+			cm = createLut().getColorModel();
+		return new ImageStack(width, height, cm);
+	}
+
+	/** Returns the image stack. The stack may have only
+		one slice. After adding or removing slices, call
+		<code>setStack()</code> to update the image and
+		the window that is displaying it.
+		@see #setStack
+	*/
+	public ImageStack getStack() {
+		ImageStack s;
+		if (stack==null) {
+			s = createEmptyStack();
+			ImageProcessor ip2 = getProcessor();
+			if (ip2==null)
+				return s;
+			String label = getProp("Slice_Label");
+			if (label==null) {
+				String info = (String)getProperty("Info");
+				label = info!=null?getTitle()+"\n"+info:null; // DICOM metadata
+			}
+			s.addSlice(label, ip2);
+			s.update(ip2);
+			this.stack = s;
+			ip = ip2;
+			oneSliceStack = true;
+			setCurrentSlice(1);
+		} else {
+			s = stack;
+			if (ip!=null) {
+				Calibration cal = getCalibration();
+				if (cal.calibrated())
+					ip.setCalibrationTable(cal.getCTable());
+				else
+					ip.setCalibrationTable(null);
+			}
+			s.update(ip);
+		}
+		if (roi!=null)
+			s.setRoi(roi.getBounds());
+		else
+			s.setRoi(null);
+		return s;
+	}
+
+	/** Returns the base image stack. */
+	public ImageStack getImageStack() {
+		if (stack==null)
+			return getStack();
+		else {
+			stack.update(ip);
+			return stack;
+		}
+	}
+
+	/** Returns the current stack index (one-based) or 1 if this is a single image. */
+	public int getCurrentSlice() {
+		if (currentSlice<1) setCurrentSlice(1);
+		if (currentSlice>getStackSize())
+			setCurrentSlice(getStackSize());
+		return currentSlice;
+	}
+
+	final void setCurrentSlice(int slice) {
+		currentSlice = slice;
+		int stackSize = getStackSize();
+		if (nChannels==stackSize) updatePosition(currentSlice, 1, 1);
+		if (nSlices==stackSize) updatePosition(1, currentSlice, 1);
+		if (nFrames==stackSize) updatePosition(1, 1, currentSlice);
+	}
+
+	public int getChannel() {
+		return position[0];
+	}
+
+	public int getSlice() {
+		return position[1];
+	}
+
+	public int getFrame() {
+		return position[2];
+	}
+
+	public void killStack() {
+		setStackNull();
+		trimProcessor();
+	}
+
+	/** Sets the current hyperstack position and updates the display,
+		where 'channel', 'slice' and 'frame' are one-based indexes. */
+	public void setPosition(int channel, int slice, int frame) {
+		//IJ.log("setPosition: "+channel+"  "+slice+"  "+frame+"  "+noUpdateMode);
+		verifyDimensions();
+		if (channel<0) channel=0;
+		if (slice<0) slice=0;
+		if (frame<0) frame=0;
+		if (channel==0) channel=getC();
+		if (slice==0) slice=getZ();
+		if (frame==0) frame=getT();
+		if (channel>nChannels) channel=nChannels;
+		if (slice>nSlices) slice=nSlices;
+		if (frame>nFrames) frame=nFrames;
+		if (isDisplayedHyperStack())
+			((StackWindow)win).setPosition(channel, slice, frame);
+		else {
+			boolean channelChanged = channel!=getChannel();
+			setSlice((frame-1)*nChannels*nSlices + (slice-1)*nChannels + channel);
+			updatePosition(channel, slice, frame);
+			if (channelChanged && isComposite() && !noUpdateMode)
+				updateImage();
+		}
+	}
+
+	/** Sets the current hyperstack position without updating the display,
+		where 'channel', 'slice' and 'frame' are one-based indexes. */
+	public void setPositionWithoutUpdate(int channel, int slice, int frame) {
+		noUpdateMode = true;
+		setPosition(channel, slice, frame);
+		noUpdateMode = false;
+	}
+
+	/** Sets the hyperstack channel position (one based). */
+	public void setC(int channel) {
+		setPosition(channel, getZ(), getT());
+	}
+
+	/** Sets the hyperstack slice position (one based). */
+	public void setZ(int slice) {
+		setPosition(getC(), slice, getT());
+	}
+
+	/** Sets the hyperstack frame position (one based). */
+	public void setT(int frame) {
+		setPosition(getC(), getZ(), frame);
+	}
+
+	/** Returns the current hyperstack channel position. */
+	public int getC() {
+		return position[0];
+	}
+
+	/** Returns the current hyperstack slice position. */
+	public int getZ() {
+		return position[1];
+	}
+
+	/** Returns the current hyperstack frame position. */
+	public int getT() {
+		return position[2];
+	}
+
+	/** Returns that stack index (one-based) corresponding to the specified position. */
+	public int getStackIndex(int channel, int slice, int frame) {
+   		if (channel<1) channel = 1;
+    	if (channel>nChannels) channel = nChannels;
+    	if (slice<1) slice = 1;
+    	if (slice>nSlices) slice = nSlices;
+    	if (frame<1) frame = 1;
+    	if (frame>nFrames) frame = nFrames;
+		return (frame-1)*nChannels*nSlices + (slice-1)*nChannels + channel;
+	}
+
+	/* Hack needed to make the HyperStackReducer work. */
+	public void resetStack() {
+		if (currentSlice==1 && stack!=null && stack.size()>0) {
+			ColorModel cm = ip.getColorModel();
+			double min = ip.getMin();
+			double max = ip.getMax();
+			ImageProcessor ip2 = stack.getProcessor(1);
+			if (ip2!=null) {
+				ip = ip2;
+				ip.setColorModel(cm);
+				ip.setMinAndMax(min, max);
+			}
+		}
+	}
+
+	/** Set the current hyperstack position based on the stack index 'n' (one-based). */
+	public void setPosition(int n) {
+		int[] pos = convertIndexToPosition(n);
+		setPosition(pos[0], pos[1], pos[2]);
+	}
+
+	/** Converts the stack index 'n' (one-based) into a hyperstack position (channel, slice, frame). */
+	public int[] convertIndexToPosition(int n) {
+		if (n<1 || n>getStackSize())
+			throw new IllegalArgumentException("n out of range: "+n);
+		int[] position = new int[3];
+		int[] dim = getDimensions();
+		position[0] = ((n-1)%dim[2])+1;
+		position[1] = (((n-1)/dim[2])%dim[3])+1;
+		position[2] = (((n-1)/(dim[2]*dim[3]))%dim[4])+1;
+		return position;
+	}
+
+	/** Displays the specified stack image, where 1<=n<=stackSize.
+	 * Does nothing if this image is not a stack.
+	 * @see #setPosition
+	 * @see #setC
+	 * @see #setZ
+	 * @see #setT
+	 */
+	public synchronized void setSlice(int n) {
+		if (stack==null || (n==currentSlice&&ip!=null)) {
+			if (!noUpdateMode)
+				updateAndRepaintWindow();
+			return;
+		}
+		if (n>=1 && n<=stack.size()) {
+			Roi roi = getRoi();
+			if (roi!=null)
+				roi.endPaste();
+			if (isProcessor()) {
+				if (currentSlice==0) currentSlice=1;
+				stack.setPixels(ip.getPixels(),currentSlice);
+			}
+			setCurrentSlice(n);
+			Object pixels = null;
+			Overlay overlay2 = null;
+			if (stack.isVirtual() && !((stack instanceof FileInfoVirtualStack)||(stack instanceof AVI_Reader))) {
+				ImageProcessor ip2 = stack.getProcessor(currentSlice);
+				overlay2 = ip2!=null?ip2.getOverlay():null;
+				if (overlay2!=null)
+					setOverlay(overlay2);
+				if (stack instanceof VirtualStack) {
+					Properties props = ((VirtualStack)stack).getProperties();
+					if (props!=null)
+						setProperty("FHT", props.get("FHT"));
+				}
+				if (ip2!=null) pixels=ip2.getPixels();
+			} else
+				pixels = stack.getPixels(currentSlice);
+			if (ip!=null && pixels!=null) {
+				try {
+					ip.setPixels(pixels);
+					ip.setSnapshotPixels(null);
+				} catch(Exception e) {}
+			} else {
+				ImageProcessor ip2 = stack.getProcessor(n);
+				if (ip2!=null) ip = ip2;
+			}
+			if (compositeImage && getCompositeMode()==IJ.COMPOSITE && ip!=null) {
+				int channel = getC();
+				if (channel>0 && channel<=getNChannels())
+					ip.setLut(((CompositeImage)this).getChannelLut(channel));
+			}
+			if (win!=null && win instanceof StackWindow)
+				((StackWindow)win).updateSliceSelector();
+			if (Prefs.autoContrast && nChannels==1 && imageType!=COLOR_RGB) {
+				(new ContrastEnhancer()).stretchHistogram(ip,0.35,ip.getStats());
+				ContrastAdjuster.update();
+				//IJ.showStatus(n+": min="+ip.getMin()+", max="+ip.getMax());
+			}
+			if (imageType==COLOR_RGB)
+				ContrastAdjuster.update();
+			if (!noUpdateMode)
+				updateAndRepaintWindow();
+			else
+				img = null;
+		}
+	}
+
+	/** Displays the specified stack image (1<=n<=stackSize)
+		without updating the display. */
+	public void setSliceWithoutUpdate(int n) {
+		noUpdateMode = true;
+		setSlice(n);
+		noUpdateMode = false;
+	}
+
+	/** Returns the current selection, or null if there is no selection. */
+	public Roi getRoi() {
+		return roi;
+	}
+
+	/** Assigns the specified ROI to this image and displays it. Any existing
+		ROI is deleted if <code>roi</code> is null or its width or height is zero. */
+	public void setRoi(Roi newRoi) {
+		setRoi(newRoi, true);
+	}
+
+	/** Assigns 'newRoi'  to this image and displays it if 'updateDisplay' is true. */
+	public void setRoi(Roi newRoi, boolean updateDisplay) {
+		if (newRoi==null) {
+			deleteRoi();
+			return;
+		}
+		if (Recorder.record) {
+			Recorder recorder = Recorder.getInstance();
+			if (recorder!=null) recorder.imageUpdated(this);
+		}
+		Rectangle bounds = newRoi.getBounds();
+		if (newRoi.isVisible()) {
+			if ((newRoi instanceof Arrow) && newRoi.getState()==Roi.CONSTRUCTING && bounds.width==0 && bounds.height==0) {
+				deleteRoi();
+				roi = newRoi;
+				return;
+			}
+			if (newRoi==null) {
+				deleteRoi();
+				return;
+			}
+			ImagePlus imp = newRoi.getImage();
+			if (imp!=null && imp.getID()!=getID())
+				newRoi = (Roi)newRoi.clone();
+			newRoi.setImage(null);
+		}
+		if (bounds.width==0 && bounds.height==0 && !(newRoi.getType()==Roi.POINT||newRoi.getType()==Roi.LINE)) {
+			deleteRoi();
+			return;
+		}
+		roi = newRoi;
+		if (ip!=null) {
+			ip.setMask(null);
+			if (roi.isArea())
+				ip.setRoi(bounds);
+			else
+				ip.resetRoi();
+		}
+		roi.setImage(this);
+		if ((roi instanceof PointRoi) && ((PointRoi)roi).addToOverlay()) {
+			IJ.run(this, "Add Selection...", "");
+			roi = null;
+			return;
+		}
+		if (updateDisplay)
+			draw();
+		if (roi!=null)
+			roi.notifyListeners(RoiListener.CREATED);
+	}
+
+	/** Creates a rectangular selection. */
+	public void setRoi(int x, int y, int width, int height) {
+		setRoi(new Rectangle(x, y, width, height));
+	}
+
+	/** Creates a rectangular selection. */
+	public void setRoi(Rectangle r) {
+		setRoi(new Roi(r.x, r.y, r.width, r.height));
+	}
+
+	/** Starts the process of creating a new selection, where sx and sy are the
+		starting screen coordinates. The selection type is determined by which tool in
+		the tool bar is active. The user interactively sets the selection size and shape. */
+	public void createNewRoi(int sx, int sy) {
+		Roi previousRoi = roi;
+		deleteRoi();   //also saves the roi as <code>Roi.previousRoi</code> if non-null
+		Roi prevRoi = Roi.getPreviousRoi();
+		if (prevRoi != null)
+			prevRoi.setImage(previousRoi==null ? null : this); //with 'this' it will be recalled in case of ESC
+		switch (Toolbar.getToolId()) {
+			case Toolbar.RECTANGLE:
+				if (Toolbar.getRectToolType()==Toolbar.ROTATED_RECT_ROI)
+					roi = new RotatedRectRoi(sx, sy, this);
+				else
+					roi = new Roi(sx, sy, this, Toolbar.getRoundRectArcSize());
+				break;
+			case Toolbar.OVAL:
+				if (Toolbar.getOvalToolType()==Toolbar.ELLIPSE_ROI)
+					roi = new EllipseRoi(sx, sy, this);
+				else
+					roi = new OvalRoi(sx, sy, this);
+				break;
+			case Toolbar.POLYGON:
+			case Toolbar.POLYLINE:
+			case Toolbar.ANGLE:
+				roi = new PolygonRoi(sx, sy, this);
+				break;
+			case Toolbar.FREEROI:
+			case Toolbar.FREELINE:
+				roi = new FreehandRoi(sx, sy, this);
+				break;
+			case Toolbar.LINE:
+				if ("arrow".equals(Toolbar.getToolName()))
+					roi = new Arrow(sx, sy, this);
+				else
+					roi = new Line(sx, sy, this);
+				break;
+			case Toolbar.TEXT:
+				roi = new TextRoi(sx, sy, this);
+				((TextRoi)roi).setPreviousTextRoi(previousRoi);
+				break;
+			case Toolbar.POINT:
+				roi = new PointRoi(sx, sy, this);
+				if (Prefs.pointAddToOverlay) {
+					int measurements = Analyzer.getMeasurements();
+					if (!(Prefs.pointAutoMeasure && (measurements&Measurements.ADD_TO_OVERLAY)!=0))
+						IJ.run(this, "Add Selection...", "");
+					Overlay overlay2 = getOverlay();
+					if (overlay2!=null)
+						overlay2.drawLabels(!Prefs.noPointLabels);
+					Prefs.pointAddToManager = false;
+				}
+				if (Prefs.pointAutoMeasure || (Prefs.pointAutoNextSlice&&!Prefs.pointAddToManager))
+					IJ.run(this, "Measure", "");
+				if (Prefs.pointAddToManager) {
+					IJ.run(this, "Add to Manager ", "");
+					ImageCanvas ic = getCanvas();
+					if (ic!=null) {
+						RoiManager rm = RoiManager.getInstance();
+						if (rm!=null) {
+							if (Prefs.noPointLabels)
+								rm.runCommand("show all without labels");
+							else
+								rm.runCommand("show all with labels");
+						}
+					}
+				}
+				if (Prefs.pointAutoNextSlice && getStackSize()>1) {
+					boolean order = Prefs.reverseNextPreviousOrder;
+					Prefs.reverseNextPreviousOrder = true;
+					IJ.run(this, "Next Slice [>]", "");
+					Prefs.reverseNextPreviousOrder = order;
+					deleteRoi();
+				}
+				break;
+		}
+		if (roi!=null)
+			roi.notifyListeners(RoiListener.CREATED);
+	}
+
+	/** Deletes the current region of interest. Makes a copy of the ROI
+		so it can be recovered by Edit/Selection/Restore Selection. */
+	public void deleteRoi() {
+		if (roi==null)
+			return;
+		saveRoi();
+		if (!(IJ.altKeyDown()||IJ.shiftKeyDown())) {
+			RoiManager rm = RoiManager.getRawInstance();
+			if (rm!=null)
+				rm.deselect(roi);
+		}
+		if (roi!=null)
+			roi.notifyListeners(RoiListener.DELETED);
+		roi = null;
+		if (ip!=null)
+			ip.resetRoi();
+		draw();
+	}
+
+	public boolean okToDeleteRoi() {
+		if (roi!=null && (roi instanceof PointRoi) && getWindow()!=null && ((PointRoi)roi).promptBeforeDeleting()) {
+			int npoints = ((PolygonRoi)roi).getNCoordinates();
+			int counters = ((PointRoi)roi).getNCounters();
+			String msg = "Delete this multi-point selection ("+npoints+" points, "+counters+" counter"+(counters>1?"s":"")+")?";
+			GenericDialog gd=new GenericDialog("Delete Points?");
+			gd.addMessage(msg+"\nRestore using Edit>Selection>Restore Selection.");
+			gd.addHelp(PointToolOptions.help);
+			gd.setOKLabel("Keep");
+			gd.setCancelLabel("Delete");
+			gd.showDialog();
+			if (gd.wasOKed())
+				return false;
+		}
+		return true;
+	}
+
+	/** Deletes the current region of interest. */
+	public void killRoi() {
+		deleteRoi();
+	}
+	
+	/** Deletes the current region of interest. */
+	public void resetRoi() {
+		deleteRoi();
+	}
+
+	public void saveRoi() {
+		Roi roi2 = roi;
+		if (roi2!=null) {
+			roi2.endPaste();
+			Rectangle r = roi2.getBounds();
+			if ((r.width>0 || r.height>0)) {
+				Roi.setPreviousRoi(roi2);
+				if (IJ.debugMode) IJ.log("saveRoi: "+roi2);
+			}
+			if ((roi2 instanceof PointRoi) && ((PointRoi)roi2).promptBeforeDeleting()) {
+				PointRoi.savedPoints = (PointRoi)roi2.clone();
+				if (IJ.debugMode) IJ.log("saveRoi: saving multi-point selection");
+			}
+		}
+	}
+
+	public void restoreRoi() {
+		if (Toolbar.getToolId()==Toolbar.POINT && PointRoi.savedPoints!=null) {
+			roi = (Roi)PointRoi.savedPoints.clone();
+			draw();
+			roi.notifyListeners(RoiListener.MODIFIED);
+			return;
+		}
+		Roi previousRoi = Roi.getPreviousRoi();
+		if (previousRoi!=null) {
+			Roi pRoi = previousRoi;
+			Rectangle r = pRoi.getBounds();
+			if (r.width<=width||r.height<=height||(r.x<width&&r.y<height)||isSmaller(pRoi)) { // will it (mostly) fit in this image?
+				roi = (Roi)pRoi.clone();
+				roi.setImage(this);
+				if (r.x>=width || r.y>=height || (r.x+r.width)<0 || (r.y+r.height)<0) // does it need to be moved?
+					roi.setLocation((width-r.width)/2, (height-r.height)/2);
+				else if (r.width==width && r.height==height) // is it the same size as the image
+					roi.setLocation(0, 0);
+				draw();
+				roi.notifyListeners(RoiListener.MODIFIED);
+			}
+		}
+	}
+
+	boolean isSmaller(Roi r) {
+		ImageProcessor mask = r.getMask();
+		if (mask==null) return false;
+		mask.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+		ImageStatistics stats = ImageStatistics.getStatistics(mask, MEAN+LIMIT, null);
+		return stats.area<=width*height;
+	}
+
+	/** Implements the File/Revert command. */
+	public void revert() {
+		if (getStackSize()>1 && getStack().isVirtual()) {
+			int thisSlice = currentSlice;
+			currentSlice = 0;
+			setSlice(thisSlice);
+			return;
+		}
+		FileInfo fi = getOriginalFileInfo();
+		boolean isFileInfo = fi!=null && fi.fileFormat!=FileInfo.UNKNOWN;
+		if (!isFileInfo && url==null)
+			return;
+		if (fi.directory==null && url==null)
+			return;
+		if (ij!=null && changes && isFileInfo && !Interpreter.isBatchMode() && !IJ.isMacro() && !IJ.altKeyDown()) {
+			if (!IJ.showMessageWithCancel("Revert?", "Revert to saved version of\n\""+getTitle()+"\"?"))
+				return;
+		}
+		Roi saveRoi = null;
+		if (roi!=null) {
+			roi.endPaste();
+			saveRoi = (Roi)roi.clone();
+		}
+		trimProcessor();
+		new FileOpener(fi).revertToSaved(this);
+		if (Prefs.useInvertingLut && getBitDepth()==8 && ip!=null && !ip.isInvertedLut()&& !ip.isColorLut())
+			invertLookupTable();
+		if (getProperty("FHT")!=null) {
+			properties.remove("FHT");
+			if (getTitle().startsWith("FFT of "))
+				setTitle(getTitle().substring(7));
+		}
+		ContrastAdjuster.update();
+		if (saveRoi!=null) setRoi(saveRoi);
+		repaintWindow();
+		IJ.showStatus("");
+		changes = false;
+		notifyListeners(UPDATED);
+    }
+
+	void revertStack(FileInfo fi) {
+		String path = null;
+		String url2 = null;
+		if (url!=null && !url.equals("")) {
+			path = url;
+			url2 = url;
+		} else if (fi!=null && !((fi.directory==null||fi.directory.equals("")))) {
+			path = fi.getFilePath();
+		} else if (fi!=null && fi.url!=null && !fi.url.equals("")) {
+			path = fi.url;
+			url2 = fi.url;
+		} else
+			return;
+		IJ.showStatus("Loading: " + path);
+		ImagePlus imp = IJ.openImage(path);
+		if (imp!=null) {
+			int n = imp.getStackSize();
+			int c = imp.getNChannels();
+			int z = imp.getNSlices();
+			int t = imp.getNFrames();
+			if (z==n || t==n || (c==getNChannels()&&z==getNSlices()&&t==getNFrames())) {
+				setCalibration(imp.getCalibration());
+				setStack(imp.getStack(), c, z, t);
+			} else {
+				ImageWindow win = getWindow();
+				Point loc = null;
+				if (win!=null) loc = win.getLocation();
+				changes = false;
+				close();
+				FileInfo fi2 = imp.getOriginalFileInfo();
+				if (fi2!=null && (fi2.url==null || fi2.url.length()==0)) {
+					fi2.url = url2;
+					imp.setFileInfo(fi2);
+				}
+				ImageWindow.setNextLocation(loc);
+				imp.show();
+			}
+		}
+	}
+
+    /** Returns a FileInfo object containing information, including the
+		pixel array, needed to save this image. Use getOriginalFileInfo()
+		to get a copy of the FileInfo object used to open the image.
+		@see ij.io.FileInfo
+		@see #getOriginalFileInfo
+		@see #setFileInfo
+	*/
+    public FileInfo getFileInfo() {
+    	FileInfo fi = new FileInfo();
+    	fi.width = width;
+    	fi.height = height;
+    	fi.nImages = getStackSize();
+    	if (compositeImage)
+    		fi.nImages = getImageStackSize();
+    	fi.whiteIsZero = isInvertedLut();
+		fi.intelByteOrder = false;
+		if (fi.nImages==1 && ip!=null)
+			fi.pixels = ip.getPixels();
+		else if (stack!=null)
+			fi.pixels = stack.getImageArray();
+		Calibration cal = getCalibration();
+    	if (cal.scaled()) {
+    		fi.pixelWidth = cal.pixelWidth;
+    		fi.pixelHeight = cal.pixelHeight;
+   			fi.unit = cal.getUnit();
+    	}
+    	if (fi.nImages>1)
+     		fi.pixelDepth = cal.pixelDepth;
+   		fi.frameInterval = cal.frameInterval;
+    	if (cal.calibrated()) {
+    		fi.calibrationFunction = cal.getFunction();
+     		fi.coefficients = cal.getCoefficients();
+			fi.valueUnit = cal.getValueUnit();
+		} else if (!Calibration.DEFAULT_VALUE_UNIT.equals(cal.getValueUnit()))
+			fi.valueUnit = cal.getValueUnit();
+
+    	switch (imageType) {
+			case GRAY8: case COLOR_256:
+				LookUpTable lut = createLut();
+				boolean customLut = !lut.isGrayscale() || (ip!=null&&!ip.isDefaultLut());
+				if (imageType==COLOR_256 || customLut)
+					fi.fileType = FileInfo.COLOR8;
+				else
+					fi.fileType = FileInfo.GRAY8;
+				addLut(lut, fi);
+				break;
+	    	case GRAY16:
+	    		if (compositeImage && fi.nImages==3) {
+	    			if ("Red".equals(getStack().getSliceLabel(1)))
+						fi.fileType = fi.RGB48;
+					else
+						fi.fileType = fi.GRAY16_UNSIGNED;
+				} else
+					fi.fileType = fi.GRAY16_UNSIGNED;
+				if (!compositeImage) {
+    				lut = createLut();
+    				if (!lut.isGrayscale() || (ip!=null&&!ip.isDefaultLut()))
+    					addLut(lut, fi);
+				}
+				break;
+	    	case GRAY32:
+				fi.fileType = fi.GRAY32_FLOAT;
+				if (!compositeImage) {
+    				lut = createLut();
+    				if (!lut.isGrayscale() || (ip!=null&&!ip.isDefaultLut()))
+    					addLut(lut, fi);
+				}
+				break;
+	    	case COLOR_RGB:
+				fi.fileType = fi.RGB;
+				break;
+			default:
+    	}
+    	return fi;
+    }
+
+	private void addLut(LookUpTable lut, FileInfo fi) {
+		fi.lutSize = lut.getMapSize();
+		fi.reds = lut.getReds();
+		fi.greens = lut.getGreens();
+		fi.blues = lut.getBlues();
+	}
+
+    /** Returns the FileInfo object that was used to open this image.
+    	Returns null for images created using the File/New command.
+		@see ij.io.FileInfo
+		@see #getFileInfo
+	*/
+    public FileInfo getOriginalFileInfo() {
+    	if (fileInfo==null & url!=null) {
+    		fileInfo = new FileInfo();
+    		fileInfo.width = width;
+    		fileInfo.height = height;
+    		fileInfo.url = url;
+    		fileInfo.directory = null;
+    	}
+    	return fileInfo;
+    }
+
+    /** Used by ImagePlus to monitor loading of images. */
+    public boolean imageUpdate(Image img, int flags, int x, int y, int w, int h) {
+    	imageUpdateY = y;
+    	imageUpdateW = w;
+		if ((flags & ERROR) != 0) {
+			errorLoadingImage = true;
+			return false;
+		}
+    	imageLoaded = (flags & (ALLBITS|FRAMEBITS|ABORT)) != 0;
+		return !imageLoaded;
+    }
+
+	/** Sets the ImageProcessor, Roi, AWT Image and stack image
+		arrays to null. Does nothing if the image is locked. */
+	public synchronized void flush() {
+		notifyListeners(CLOSED);
+		if (locked || ignoreFlush) return;
+		ip = null;
+		if (roi!=null) roi.setImage(null);
+		roi = null;
+		if (stack!=null && stack.viewers(-1)<=0) {
+			Object[] arrays = stack.getImageArray();
+			if (arrays!=null) {
+				for (int i=0; i<arrays.length; i++)
+					arrays[i] = null;
+			}
+			if (isComposite())
+				((CompositeImage)this).setChannelsUpdated(); //flush
+		}
+		setStackNull();
+		img = null;
+		win = null;
+		if (roi!=null) roi.setImage(null);
+		roi = null;
+		properties = null;
+		//calibration = null;
+		overlay = null;
+		flatteningCanvas = null;
+	}
+
+	public void setIgnoreFlush(boolean ignoreFlush) {
+		this.ignoreFlush = ignoreFlush;
+	}
+
+
+	/** Returns a copy of this image or stack.
+	* @see #crop
+	* @see ij.plugin.Duplicator#run
+	*/
+	public ImagePlus duplicate() {
+		Roi roi = getRoi();
+		deleteRoi();
+		ImagePlus imp2 = (new Duplicator()).run(this);
+		setRoi(roi);
+		return imp2;
+	}
+	
+	/** Returns a scaled copy of this image or ROI, where the
+		 'options'  string can contain 'none', 'bilinear'. 'bicubic',
+		'average' and 'constrain'.
+	*/
+	public ImagePlus resize(int dstWidth, int dstHeight, String options) {
+		return resize(dstWidth, dstHeight, 1, options);
+	}
+
+	/** Returns a scaled copy of this image or ROI, where the
+		 'options'  string can contain 'none', 'bilinear'. 'bicubic',
+		'average' and 'constrain'.
+	*/
+	public ImagePlus resize(int dstWidth, int dstHeight, int dstDepth, String options) {
+		return Scaler.resize(this, dstWidth, dstHeight, dstDepth, options);
+	}
+
+	/** Returns a copy this image or stack slice, cropped if there is an ROI.
+	 * @see #duplicate
+	 * @see ij.plugin.Duplicator#crop
+	*/
+	public ImagePlus crop() {
+		return (new Duplicator()).crop(this);
+	}
+
+	/** Returns a cropped copy this image or stack, where 'options'
+	 * can be "stack", "slice", "whole-slice" or a range (e.g., "20-30").
+	 * @see #duplicate
+	 * @see #crop
+	 * @see ij.plugin.Duplicator#crop
+	*/
+	public ImagePlus crop(String options) {
+		int stackSize = getStackSize();
+		if (options==null || options.contains("stack"))
+			return (new Duplicator()).run(this);
+		else if (options.contains("whole")) {
+			Roi saveRoi = getRoi();
+			if (saveRoi!=null)
+				this.roi = null;
+			ImagePlus imp2 = crop();
+			if (saveRoi!=null)
+				this.roi = saveRoi;
+			return imp2;
+		} else if (options.contains("slice") || stackSize==1)
+			return crop();
+		else {
+			String[] range = Tools.split(options, " -");
+			if (range.length!=2)
+				return crop();
+			double s1 = Tools.parseDouble(range[0]);
+			double s2 = Tools.parseDouble(range[1]);
+			if (Double.isNaN(s1) || Double.isNaN(s2))
+				return crop();
+			if (s1<1) s1 = 1;
+			if (s2>stackSize) s2 = stackSize;
+			if (s1>s2) {s1=1; s2=stackSize;}
+			return new Duplicator().run(this, (int)s1, (int)s2);
+		}
+	}
+	
+	/** Returns an array of cropped images based on the provided
+	 * list of rois. 'options' applies with stacks and can be "stack",
+	* "slice" or a range (e.g., "20-30").
+	 * @see #crop(ij.gui.Roi[])
+	*/
+	public ImagePlus[] crop(Roi[] rois, String options) {
+		int nRois = rois.length; 
+		ImagePlus[] cropImps = new ImagePlus[nRois];
+		for (int i=0; i<nRois; i++) {
+			Roi cropRoi = rois[i];
+			String name = cropRoi.getName();
+			if (options.contains("slice") && this.getStackSize()>1) {
+				int position = cropRoi.getPosition();
+				this.setSlice(position); // no effect if roi position is undefined (=0), ok
+			}
+			this.setRoi(cropRoi);
+			ImagePlus cropped = this.crop(options);
+			if (cropRoi.getType()!=Roi.RECTANGLE) {
+				Roi cropRoi2 = (Roi)cropRoi.clone();
+				cropRoi2.setLocation(0,0);
+				cropped.setRoi(cropRoi2);
+			}
+			String name2 = IJ.pad(i+1,3)+"_"+this.getTitle();
+			cropped.setTitle(name!=null?name:name2);
+			cropped.setOverlay(null);
+			cropImps[i] = cropped;
+		}
+		return cropImps;
+	}
+
+	/** Multi-roi cropping with default "slice" option. */
+	public ImagePlus[] crop(Roi[] rois) {
+		return this.crop(rois, "slice");
+	}
+
+	/** Saves the contents of the ROIs in this overlay as separate images,
+	 * where 'directory' is the directory path and 'format' is "tif", "png" or "jpg".
+	* Set 'format' to "show" and the images will be displayed in a stack
+	* and not saved.
+	*/
+	public void cropAndSave(Roi[] rois, String directory, String format) {
+		ImagePlus[] images = crop(rois);
+		if (format==null) format = "";
+		if (format.contains("show")) {
+			ImageStack stack = ImageStack.create(images);
+			new ImagePlus("CROPPED_"+getTitle(),stack).show();
+			return;
+		}
+		String fileFormat = "tif";
+		if (format.contains("png")) fileFormat = "png";
+		if (format.contains("jpg")) fileFormat = "jpg";
+		for (int i=0; i<images.length; i++) {
+			Rectangle bounds = rois[i].getBounds();
+			String title = IJ.pad(bounds.x,4)+"-"+IJ.pad(bounds.y,4);
+			String path = directory + title + "." + fileFormat;
+			IJ.saveAs(images[i], fileFormat, path);
+		}
+	}
+
+	/** Returns a new ImagePlus with this image's attributes
+		(e.g. spatial scale), but no image. */
+	public ImagePlus createImagePlus() {
+		ImagePlus imp2 = new ImagePlus();
+		imp2.setType(getType());
+		imp2.setCalibration(getCalibration());
+		String info = (String)getProperty("Info");
+		if (info!=null)
+			imp2.setProperty("Info", info);
+		imp2.setProperties(getPropertiesAsArray());
+		FileInfo fi = getOriginalFileInfo();
+		if (fi!=null) {
+			fi = (FileInfo)fi.clone();
+			fi.directory = null;
+			fi.url = null;
+			imp2.setFileInfo(fi);
+		}
+		return imp2;
+	}
+
+
+ 	/** This method has been replaced by IJ.createHyperStack(). */
+	public ImagePlus createHyperStack(String title, int channels, int slices, int frames, int bitDepth) {
+		int size = channels*slices*frames;
+		ImageStack stack2 = new ImageStack(width, height, size); // create empty stack
+		ImageProcessor ip2 = null;
+		switch (bitDepth) {
+			case 8: ip2 = new ByteProcessor(width, height); break;
+			case 16: ip2 = new ShortProcessor(width, height); break;
+			case 24: ip2 = new ColorProcessor(width, height); break;
+			case 32: ip2 = new FloatProcessor(width, height); break;
+			default: throw new IllegalArgumentException("Invalid bit depth");
+		}
+		stack2.setPixels(ip2.getPixels(), 1); // can't create ImagePlus will null 1st image
+		ImagePlus imp2 = new ImagePlus(title, stack2);
+		stack2.setPixels(null, 1);
+		imp2.setDimensions(channels, slices, frames);
+		imp2.setCalibration(getCalibration());
+		imp2.setOpenAsHyperStack(true);
+		return imp2;
+	}
+
+	/** Copies the calibration of the specified image to this image. */
+	public void copyScale(ImagePlus imp) {
+		if (imp!=null && globalCalibration==null)
+			setCalibration(imp.getCalibration());
+	}
+
+	/** Used internally. */
+	public void copyAttributes(ImagePlus imp) {
+		if (IJ.debugMode) IJ.log("copyAttributes: "+imp.getID()+"  "+this.getID()+" "+imp+"   "+this);
+		if (imp==null || imp.getWindow()!=null)
+			throw new IllegalArgumentException("Source image is null or displayed");
+		ID = imp.getID();
+		setTitle(imp.getTitle());
+		setCalibration(imp.getCalibration());
+		FileInfo fi = imp.getOriginalFileInfo();
+		if (fi!=null)
+			setFileInfo(fi);
+		Object info = imp.getProperty("Info");
+		if (info!=null)
+			setProperty("Info", imp.getProperty("Info"));
+		setProperties(imp.getPropertiesAsArray());
+		Object plot = imp.getProperty(Plot.PROPERTY_KEY);
+		if (plot != null)
+			setProperty(Plot.PROPERTY_KEY, plot);
+	}
+
+    /** Calls System.currentTimeMillis() to save the current
+		time so it can be retrieved later using getStartTime()
+		to calculate the elapsed time of an operation. */
+    public void startTiming() {
+		startTime = System.currentTimeMillis();
+    }
+
+    /** Returns the time in milliseconds when
+		startTiming() was last called. */
+    public long getStartTime() {
+		return startTime;
+    }
+
+	/** Returns this image's calibration. */
+	public Calibration getCalibration() {
+		//IJ.log("getCalibration: "+globalCalibration+" "+calibration);
+		if (globalCalibration!=null && !ignoreGlobalCalibration) {
+			Calibration gc = globalCalibration.copy();
+			gc.setImage(this);
+			return gc;
+		} else {
+			if (calibration==null)
+				calibration = new Calibration(this);
+			return calibration;
+		}
+	}
+
+   /** Sets this image's calibration. */
+    public void setCalibration(Calibration cal) {
+		if (cal==null)
+			calibration = null;
+		else {
+			calibration = cal.copy();
+			calibration.setImage(this);
+		}
+   }
+
+    /** Sets the system-wide calibration. */
+    public void setGlobalCalibration(Calibration global) {
+		//IJ.log("setGlobalCalibration: "+calibration);
+		if (global==null)
+			globalCalibration = null;
+		else
+			globalCalibration = global.copy();
+    }
+
+    /** Returns the system-wide calibration, or null. */
+    public Calibration getGlobalCalibration() {
+			return globalCalibration;
+    }
+
+    /** This is a version of getGlobalCalibration() that can be called from a static context. */
+    public static Calibration getStaticGlobalCalibration() {
+			return globalCalibration;
+    }
+
+	/** Returns this image's local calibration, ignoring
+		the "Global" calibration flag. */
+	public Calibration getLocalCalibration() {
+		if (calibration==null)
+			calibration = new Calibration(this);
+		return calibration;
+	}
+
+	public void setIgnoreGlobalCalibration(boolean ignoreGlobalCalibration) {
+		this.ignoreGlobalCalibration = ignoreGlobalCalibration;
+	}
+
+    /** Displays the cursor coordinates and pixel value in the status bar.
+	 * Called by ImageCanvas when the mouse moves.
+    */
+	public void mouseMoved(int x, int y) {
+		Roi roi2 = getRoi();
+		if (ij!=null && !IJ.statusBarProtected() && (roi2==null || roi2.getState()==Roi.NORMAL))
+			ij.showStatus(getLocationAsString(x,y) + getValueAsString(x,y));
+	}
+
+    /** Redisplays the (x,y) coordinates and pixel value (which may
+	 * have changed) in the status bar. Called by the Next Slice and
+	 * Previous Slice commands to update the z-coordinate and pixel value.
+    */
+	public void updateStatusbarValue() {
+		ImageCanvas ic = getCanvas();
+		Point loc = ic!=null?ic.getCursorLoc():null;
+		if (loc!=null)
+			mouseMoved(loc.x,loc.y);
+	}
+
+	String getFFTLocation(int x, int y, Calibration cal) {
+		double center = width/2.0;
+		double r = Math.sqrt((x-center)*(x-center) + (y-center)*(y-center));
+		double theta = Math.atan2(y-center, x-center);
+		theta = theta*180.0/Math.PI;
+		if (theta<0) theta=360.0+theta;
+		String s = "r=";
+		if (r<1.0)
+			return s+"Infinity/c (0)"; //origin ('DC offset'), no angle
+		else if (cal.scaled())
+			s += IJ.d2s((width/r)*cal.pixelWidth,2) + " " + cal.getUnit() + "/c (" + IJ.d2s(r,0) + ")";
+		else
+			s += IJ.d2s(width/r,2) + " p/c (" + IJ.d2s(r,0) + ")";
+		s += ", theta= " + IJ.d2s(theta,2) + IJ.degreeSymbol;
+		return s;
+	}
+
+    /** Converts the current cursor location to a string. */
+    public String getLocationAsString(int x, int y) {
+		Calibration cal = getCalibration();
+		if (getProperty("FHT")!=null)
+			return getFFTLocation(x, height-y, cal);
+		String xx="", yy="";
+		if (cal.scaled()) {
+			xx = " ("+x+")";
+			yy = " ("+y+")";
+		}
+		String s = " x="+d2s(cal.getX(x)) + xx + ", y=" + d2s(cal.getY(y,height)) + yy;
+		if (getStackSize()>1) {
+			Roi roi2 = getRoi();
+			if (roi2==null || roi2.getState()==Roi.NORMAL) {
+				int z = isDisplayedHyperStack()?getSlice()-1:getCurrentSlice()-1;
+				String zz = cal.scaled()&&cal.getZ(z)!=z?" ("+z+")":"";
+				s += ", z="+d2s(cal.getZ(z))+zz;
+			}
+		}
+		return s;
+    }
+
+    private String d2s(double n) {
+		return n==(int)n?Integer.toString((int)n):IJ.d2s(n);
+	}
+
+    private String getValueAsString(int x, int y) {
+    	if (win!=null && win instanceof PlotWindow)
+    		return "";
+		Calibration cal = getCalibration();
+    	int[] v = getPixel(x, y);
+    	int type = getType();
+		switch (type) {
+			case GRAY8: case GRAY16: case COLOR_256:
+				if (type==COLOR_256) {
+					if (cal.getCValue(v[3])==v[3]) // not calibrated
+						return(", index=" + v[3] + ", value=" + v[0] + "," + v[1] + "," + v[2]);
+					else
+						v[0] = v[3];
+				}
+				double cValue = cal.getCValue(v[0]);
+				if (cValue==v[0])
+    				return(", value=" + v[0]);
+    			else
+    				return(", value=" + IJ.d2s(cValue) + " ("+v[0]+")");
+    		case GRAY32:
+    			double value = Float.intBitsToFloat(v[0]);
+    			String s = (int)value==value?IJ.d2s(value,0)+".0":IJ.d2s(value,4,7);
+    			return(", value=" + s);
+			case COLOR_RGB:
+				if (ip!=null && ip.getNChannels()==1)
+	 				return(", value=" + v[0]);
+	 			else {
+					String hex = Colors.colorToString(new Color(v[0],v[1],v[2]));
+					return(", value=" + IJ.pad(v[0],3) + "," + IJ.pad(v[1],3) + "," + IJ.pad(v[2],3) + " ("+hex + ")");
+				}
+    		default: return("");
+		}
+    }
+
+	/** Copies the contents of the current selection to the internal
+		clipboard and then clears the selection. */
+	public void cut() {
+		copy(true);
+	}
+
+	/** Copies the contents of the current selection, or the entire
+		image if there is no selection, to the internal clipboard. */
+	public void copy() {
+		copy(false);
+	}
+
+	/** Copies the contents of the current selection to the internal clipboard.
+		Copies the entire image if there is no selection. Also clears
+		the selection if <code>cut</code> is true. */
+	public void copy(boolean cut) {
+		Roi roi = getRoi();
+		if (roi!=null && !roi.isArea())
+			roi = null;
+		if (cut && roi==null && !IJ.isMacro()) {
+			IJ.error("Edit>Cut", "This command requires an area selection");
+			return;
+		}
+		boolean batchMode = Interpreter.isBatchMode();
+		String msg = (cut)?"Cut":"Copy";
+		if (!batchMode) IJ.showStatus(msg+ "ing...");
+		ImageProcessor ip = getProcessor();
+		ImageProcessor ip2;
+		ip2 = ip.crop();
+		clipboard = new ImagePlus("Clipboard", ip2);
+		if (roi!=null)
+			clipboard.setRoi((Roi)roi.clone());
+		if (cut) {
+			ip.snapshot();
+	 		ip.setColor(Toolbar.getBackgroundColor());
+			ip.fill();
+			if (roi!=null && roi.getType()!=Roi.RECTANGLE) {
+				getMask();
+				ip.reset(ip.getMask());
+			} setColor(Toolbar.getForegroundColor());
+			Undo.setup(Undo.FILTER, this);
+			updateAndDraw();
+		}
+		int bytesPerPixel = 1;
+		switch (clipboard.getType()) {
+			case ImagePlus.GRAY16: bytesPerPixel = 2; break;
+			case ImagePlus.GRAY32: case ImagePlus.COLOR_RGB: bytesPerPixel = 4;
+		}
+		if (!batchMode) {
+			msg = (cut)?"Cut":"Copy";
+			IJ.showStatus(msg + ": " + (clipboard.getWidth()*clipboard.getHeight()*bytesPerPixel)/1024 + "k");
+		}
+    }
+
+	 /** Inserts the contents of the internal clipboard into this image. If there
+	 is a selection the same size as the image on the clipboard, the image is inserted
+	 into that selection, otherwise the selection is inserted into the center of the image.*/
+	 public void paste() {
+		if (clipboard==null)
+			return;
+		int cType = clipboard.getType();
+		int iType = getType();
+        int w = clipboard.getWidth();
+        int h = clipboard.getHeight();
+		Roi cRoi = clipboard.getRoi();
+		Rectangle r = null;
+		Rectangle cr = null;
+		Roi roi = getRoi();
+		if (roi!=null)
+			r = roi.getBounds();
+		if (cRoi!=null)
+			cr = cRoi.getBounds();
+		if (cr==null)
+			cr = new Rectangle(0, 0, w, h);
+		if (r==null || (cr.width!=r.width || cr.height!=r.height)) {
+			// Create a new roi centered on visible part of image, or centered on image if clipboard is >= image
+			ImageCanvas ic = win!=null?ic = win.getCanvas():null;
+			Rectangle srcRect = ic!=null?ic.getSrcRect():new Rectangle(0,0,width,height);
+			int xCenter = w>=width ? width/2 : srcRect.x + srcRect.width/2;
+			int yCenter = h>=height ? height/2 : srcRect.y + srcRect.height/2;
+			if (cRoi!=null && cRoi.getType()!=Roi.RECTANGLE) {
+				cRoi.setImage(this);
+				cRoi.setLocation(xCenter-w/2, yCenter-h/2);
+				setRoi(cRoi);
+			} else
+				setRoi(xCenter-w/2, yCenter-h/2, w, h);
+			roi = getRoi();
+		}
+		if (IJ.isMacro()) {
+			//non-interactive paste
+			int pasteMode = Roi.getCurrentPasteMode();
+			boolean nonRect = roi.getType()!=Roi.RECTANGLE;
+			ImageProcessor ip = getProcessor();
+			if (nonRect) ip.snapshot();
+			r = roi.getBounds();
+			int xoffset = cr.x<0?-cr.x:0;
+			int yoffset = cr.y<0?-cr.y:0;
+			ip.copyBits(clipboard.getProcessor(), r.x+xoffset, r.y+yoffset, pasteMode);
+			if (nonRect) {
+				ImageProcessor mask = roi.getMask();
+				ip.setMask(mask);
+				ip.setRoi(roi.getBounds());
+				ip.reset(ip.getMask());
+			}
+			updateAndDraw();
+		} else if (roi!=null) {
+			roi.startPaste(clipboard);
+			Undo.setup(Undo.PASTE, this);
+		}
+		changes = true;
+    }
+    
+    /** Inserts the contents of the internal clipboard at the
+    	specified location, without updating the display. */
+	 public void paste(int x, int y) {
+	 	paste(x, y, null);
+	}
+
+    /** Copies the contents of the internal clipboard to the
+	 * specified location using the specified transfer mode
+	 * ("Copy", "Blend", "Average", "Difference", "Transparent",
+	 * "Transparent2", "AND", "OR", "XOR", "Add", "Subtract",
+	 * "Multiply", or "Divide"). The display is not updating.
+    */
+	 public void paste(int x, int y, String mode) {
+		if (clipboard==null)
+			return;
+		Roi roi = clipboard.getRoi();
+		boolean nonRect = roi!=null && roi.getType()!=Roi.RECTANGLE;
+		if (nonRect)
+			ip.snapshot();
+		if (mode==null)
+			ip.insert(clipboard.getProcessor(), x, y);
+		else {
+			int pasteMode = IJ.stringToPasteMode(mode);
+			ip.copyBits(clipboard.getProcessor(), x, y, pasteMode);
+		}
+		if (nonRect) {
+			ImageProcessor mask = roi.getMask();
+			ip.setRoi(x, y, mask.getWidth(), mask.getHeight());
+			ip.setMask(mask);
+			ip.reset(ip.getMask());
+		}
+	}
+
+   /** Returns the internal clipboard or null if the internal clipboard is empty. */
+    public static ImagePlus getClipboard() {
+        return clipboard;
+    }
+
+	/** Clears the internal clipboard. */
+	public static void resetClipboard() {
+		clipboard = null;
+	}
+	
+	/** Copies the contents of the current selection, or the entire
+		image if there is no selection, to the system clipboard. */
+	public void copyToSystem() {
+		Clipboard.copyToSystem(this);
+	}
+
+	protected void notifyListeners(final int id) {
+		if (temporary)
+			return;
+	    final ImagePlus imp = this;
+		EventQueue.invokeLater(new Runnable() {
+			public void run() {
+				for (int i=0; i<listeners.size(); i++) {
+					ImageListener listener = (ImageListener)listeners.elementAt(i);
+					switch (id) {
+						case OPENED:
+							listener.imageOpened(imp);
+							break;
+						case CLOSED:
+							listener.imageClosed(imp);
+							break;
+						case UPDATED:
+							listener.imageUpdated(imp);
+							break;
+						case SAVED:
+							//listener.imageSaved(imp);
+							break;
+					}
+				}
+			}
+		});
+	}
+
+	public static void addImageListener(ImageListener listener) {
+		listeners.addElement(listener);
+	}
+
+	public static void removeImageListener(ImageListener listener) {
+		listeners.removeElement(listener);
+	}
+	
+	public static Vector getListeners() {
+		return listeners;
+	}
+	
+	/** For debug purposes, writes all registered (and possibly,
+		forgotten) ImageListeners to the log window */
+	public static void logImageListeners() {
+		if (listeners.size() == 0)
+			IJ.log("No ImageListeners");
+		else {
+			for (Object li : listeners) {
+				IJ.log("imageListener: "+li);
+				if (li instanceof Window)
+					IJ.log("   ("+(((Window)li).isShowing() ? "showing" : "invisible")+")");
+			}
+		}
+	}
+
+	public void setOpenAsHyperStack(boolean openAsHyperStack) {
+		this.openAsHyperStack = openAsHyperStack;
+	}
+
+	public boolean getOpenAsHyperStack() {
+		return openAsHyperStack;
+	}
+
+	/** Returns true if this is a CompositeImage. */
+	public boolean isComposite() {
+		return compositeImage && nChannels>=1 && imageType!=COLOR_RGB && (this instanceof CompositeImage);
+	}
+
+	/** Returns the display mode (IJ.COMPOSITE, IJ.COLOR
+		or IJ.GRAYSCALE) if this is a CompositeImage, otherwise returns -1. */
+	public int getCompositeMode() {
+		if (isComposite())
+			return ((CompositeImage)this).getMode();
+		else
+			return -1;
+	}
+
+	/** Sets the display range of the current channel. With non-composite
+	    images it is identical to ip.setMinAndMax(min, max). */
+	public void setDisplayRange(double min, double max) {
+		if (ip!=null)
+			ip.setMinAndMax(min, max);
+	}
+
+	public double getDisplayRangeMin() {
+		return ip.getMin();
+	}
+
+	public double getDisplayRangeMax() {
+		return ip.getMax();
+	}
+
+	/**	Sets the display range of specified channels in an RGB image, where 4=red,
+		2=green, 1=blue, 6=red+green, etc. With non-RGB images, this method is
+		identical to setDisplayRange(min, max).  This method is used by the
+		Image/Adjust/Color Balance tool . */
+	public void setDisplayRange(double min, double max, int channels) {
+		if (ip instanceof ColorProcessor)
+			((ColorProcessor)ip).setMinAndMax(min, max, channels);
+		else
+			ip.setMinAndMax(min, max);
+	}
+
+	public void resetDisplayRange() {
+		if (imageType==GRAY16 && default16bitDisplayRange>=8 && default16bitDisplayRange<=16 && !(getCalibration().isSigned16Bit()))
+			ip.setMinAndMax(0, Math.pow(2,default16bitDisplayRange)-1);
+		else
+			ip.resetMinAndMax();
+	}
+
+	/** Returns 'true' if this image is thresholded. */
+	public boolean isThreshold() {
+		return ip!=null && ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD;
+	}
+
+    /** Set the default 16-bit display range, where 'bitDepth' must be 0 (auto-scaling),
+    	8 (0-255), 10 (0-1023), 12 (0-4095, 14 (0-16383), 15 (0-32767) or 16 (0-65535). */
+    public static void setDefault16bitRange(int bitDepth) {
+    	if (!(bitDepth==8 || bitDepth==10 || bitDepth==12 || bitDepth==14 || bitDepth==15 || bitDepth==16))
+    		bitDepth = 0;
+    	default16bitDisplayRange = bitDepth;
+    }
+
+    /** Returns the default 16-bit display range, 0 (auto-scaling), 8, 10, 12, 14, 15 or 16. */
+    public static int getDefault16bitRange() {
+    	return default16bitDisplayRange;
+    }
+
+	public void updatePosition(int c, int z, int t) {
+ 		position[0] = c;
+		position[1] = z;
+		position[2] = t;
+	}
+
+	/** Returns a "flattened" version of this image, or stack slice, in RGB format. */
+	public ImagePlus flatten() {
+		if (IJ.debugMode) IJ.log("flatten");
+		ImagePlus impCopy = this;
+		if (getStackSize()>1)
+			impCopy = crop("whole-slice");			
+		ImagePlus imp2 = impCopy.createImagePlus();
+		imp2.setOverlay(impCopy.getOverlay());
+		imp2.setTitle(flattenTitle);
+		ImageCanvas ic2 = new ImageCanvas(imp2);
+		imp2.flatteningCanvas = ic2;
+		imp2.setRoi(getRoi());
+		Overlay overlay2 = getOverlay();
+		if (overlay2!=null && imp2.getRoi()!=null && !(imp2.getRoi() instanceof PointRoi)) {
+			imp2.deleteRoi();
+			if (getWindow()!=null) IJ.wait(100);
+		}
+		setPointScale(imp2.getRoi(), overlay2);
+		ImageCanvas ic = getCanvas();
+		if (ic!=null)
+			ic2.setShowAllList(ic.getShowAllList());
+		BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+		Graphics2D g = (Graphics2D)bi.getGraphics();
+		g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+			antialiasRendering?RenderingHints.VALUE_ANTIALIAS_ON:RenderingHints.VALUE_ANTIALIAS_OFF);
+		g.drawImage(getImage(), 0, 0, null);
+		ic2.paint(g);
+		imp2.flatteningCanvas = null;
+		ImagePlus imp3 = new ImagePlus("Flat_"+getTitle(), new ColorProcessor(bi));
+		imp3.copyScale(this);
+		imp3.setProperty("Info", getProperty("Info"));
+		imp3.setProperties(getPropertiesAsArray());
+		return imp3;
+	}
+
+	/** Flattens all slices of this stack or HyperStack.<br>
+	 * @throws UnsupportedOperationException if this image<br>
+	 * does not have an overlay and the RoiManager overlay is null<br>
+	 * or Java version is less than 1.6.
+	 * Copied from OverlayCommands and modified by Marcel Boeglin
+	 * on 2014.01.08 to work with HyperStacks.
+	 */
+	public void flattenStack() {
+		if (IJ.debugMode) IJ.log("flattenStack");
+		if (getStackSize()==1)
+			throw new UnsupportedOperationException("Image stack required");
+		boolean composite = isComposite();
+		if (getBitDepth()!=24)
+			new ImageConverter(this).convertToRGB();
+		Overlay overlay1 = getOverlay();
+		Overlay roiManagerOverlay = null;
+		boolean roiManagerShowAllMode = !Prefs.showAllSliceOnly;
+		ImageCanvas ic = getCanvas();
+		if (ic!=null)
+			roiManagerOverlay = ic.getShowAllList();
+		setOverlay(null);
+		if (roiManagerOverlay!=null) {
+			RoiManager rm = RoiManager.getInstance();
+			if (rm!=null)
+				rm.runCommand("show none");
+		}
+		Overlay overlay2 = overlay1!=null?overlay1:roiManagerOverlay;
+		if (composite && overlay2==null)
+				return;
+		if (overlay2==null || overlay2.size()==0)
+			throw new UnsupportedOperationException("A non-empty overlay is required");
+		ImageStack stack2 = getStack();
+		boolean showAll = overlay1!=null?false:roiManagerShowAllMode;
+		if (isHyperStack()) {
+			int Z = getNSlices();
+			for (int z=1; z<=Z; z++) {
+				for (int t=1; t<=getNFrames(); t++) {
+					int s = z + (t-1)*Z;
+					flattenImage(stack2, s, overlay2.duplicate(), showAll, z, t);
+				}
+			}
+		} else {
+			for (int s=1; s<=stack2.getSize(); s++) {
+				flattenImage(stack2, s, overlay2.duplicate(), showAll);
+			}
+		}
+		setStack(stack2);
+	}
+
+	/** Flattens Overlay 'overlay' on slice 'slice' of ImageStack 'stack'.
+	 * Copied from OverlayCommands by Marcel Boeglin 2014.01.08.
+	 */
+	private void flattenImage(ImageStack stack, int slice, Overlay overlay, boolean showAll) {
+		ImageProcessor ips = stack.getProcessor(slice);
+		ImagePlus imp1 = new ImagePlus("temp", ips);
+		int w = imp1.getWidth();
+		int h = imp1.getHeight();
+		for (int i=0; i<overlay.size(); i++) {
+			Roi r = overlay.get(i);
+			int roiPosition = r.getPosition();
+			//IJ.log(slice+" "+i+" "+roiPosition+" "+showAll+" "+overlay.size());
+			if (!(roiPosition==0 || roiPosition==slice || showAll))
+				r.setLocation(w, h);
+		}
+		imp1.setOverlay(overlay);
+		ImagePlus imp2 = imp1.flatten();
+		stack.setPixels(imp2.getProcessor().getPixels(), slice);
+	}
+
+	/** Flattens Overlay 'overlay' on slice 'slice' corresponding to
+	 * coordinates 'z' and 't' in RGB-HyperStack 'stack'
+	 */
+	private void flattenImage(ImageStack stack, int slice, Overlay overlay, boolean showAll, int z, int t) {
+		ImageProcessor ips = stack.getProcessor(slice);
+		ImagePlus imp1 = new ImagePlus("temp", ips);
+		int w = imp1.getWidth();
+		int h = imp1.getHeight();
+		for (int i=0; i<overlay.size(); i++) {
+			Roi r = overlay.get(i);
+			int cPos = r.getCPosition();// 0 or 1 (RGB-HyperStack)
+			int zPos = r.getZPosition();
+			int tPos = r.getTPosition();
+			if (!((cPos==1 || cPos==0) && (zPos==z || zPos==0) && (tPos==t || tPos==0) || showAll))
+				r.setLocation(w, h);
+		}
+		imp1.setOverlay(overlay);
+		ImagePlus imp2 = imp1.flatten();
+		stack.setPixels(imp2.getProcessor().getPixels(), slice);
+	}
+	
+	public boolean tempOverlay() {
+		Overlay o = getOverlay();
+		if (o==null || o.size()!=1)
+			return false;
+		if ("Pixel Inspector".equals(o.get(0).getName()))
+			return true;
+		else
+			return false;
+	}
+
+	private void setPointScale(Roi roi2, Overlay overlay2) {
+		ImageCanvas ic = getCanvas();
+		if (ic==null)
+			return;
+		double scale = 1.0/ic.getMagnification();
+		if (scale==1.0)
+			return;
+		if (roi2!=null && (roi2 instanceof PointRoi))
+			roi2.setFlattenScale(scale);
+		if (overlay2!=null) {
+			for (int i=0; i<overlay2.size(); i++) {
+				roi2 = overlay2.get(i);
+				if (roi2!=null && (roi2 instanceof PointRoi))
+					roi2.setFlattenScale(scale);
+			}
+		}
+	}
+
+	/** Assigns a LUT (lookup table) to this image.
+	 * @see ij.io.Opener#openLut
+	*/
+	public void setLut(LUT lut) {
+		ImageProcessor ip2 = getProcessor();
+		if (ip2!=null && lut!=null) {
+			ip2.setLut(lut);
+			setProcessor(ip2);
+		}
+	}
+
+	/** Installs a list of ROIs that will be drawn on this image as a non-destructive overlay.
+	 * @see ij.gui.Roi#setStrokeColor
+	 * @see ij.gui.Roi#setStrokeWidth
+	 * @see ij.gui.Roi#setFillColor
+	 * @see ij.gui.Roi#setLocation
+	 * @see ij.gui.Roi#setNonScalable
+	 */
+	public void setOverlay(Overlay overlay) {
+		this.overlay = overlay;
+		setHideOverlay(false);
+		ImageCanvas ic = getCanvas();
+		if (ic!=null)
+			ic.repaintOverlay();
+	}
+
+	/** Creates an Overlay from the specified Shape, Color
+	 * and BasicStroke, and assigns it to this image.
+	 * @see #setOverlay(ij.gui.Overlay)
+	 * @see ij.gui.Roi#setStrokeColor
+	 * @see ij.gui.Roi#setStrokeWidth
+	 */
+	public void setOverlay(Shape shape, Color color, BasicStroke stroke) {
+		if (shape==null)
+			{setOverlay(null); return;}
+		Roi roi = new ShapeRoi(shape);
+		roi.setStrokeColor(color);
+		roi.setStroke(stroke);
+		setOverlay(new Overlay(roi));
+	}
+
+	/** Creates an Overlay from the specified ROI, and assigns it to this image.
+	 * @see #setOverlay(ij.gui.Overlay)
+	 */
+	public void setOverlay(Roi roi, Color strokeColor, int strokeWidth, Color fillColor) {
+		roi.setStrokeColor(strokeColor);
+		roi.setStrokeWidth(strokeWidth);
+		roi.setFillColor(fillColor);
+		setOverlay(new Overlay(roi));
+	}
+
+	/** Returns the current overly, or null if this image does not have an overlay. */
+	public Overlay getOverlay() {
+		return overlay;
+	}
+
+	public void setHideOverlay(boolean hide) {
+		hideOverlay = hide;
+		ImageCanvas ic = getCanvas();
+		if (ic!=null && ic.getOverlay()!=null)
+			ic.repaint();
+	}
+
+	public boolean getHideOverlay() {
+		return hideOverlay;
+	}
+
+	/** Enable/disable use of antialiasing by the flatten() method. */
+	public void setAntialiasRendering(boolean antialiasRendering) {
+		this.antialiasRendering = antialiasRendering;
+	}
+
+	/** Returns a shallow copy of this ImagePlus. */
+	public synchronized Object clone() {
+		try {
+			ImagePlus copy = (ImagePlus)super.clone();
+			copy.win = null;
+			return copy;
+		} catch (CloneNotSupportedException e) {
+			return null;
+		}
+	}
+
+	/** Plots a 256 bin histogram of this image and returns the PlotWindow. */
+	public PlotWindow plotHistogram() {
+		return plotHistogram(256);
+	}
+
+	/** Plots a histogram of this image using the specified
+		number of bins and returns the PlotWindow. */
+	public PlotWindow plotHistogram(int bins) {
+		ImageStatistics stats = getStatistics(AREA+MEAN+MODE+MIN_MAX, bins);
+		Plot plot = new Plot("Hist_"+getTitle(), "Value", "Frequency");
+		plot.setColor("black", "#999999");
+		plot.setFont(new Font("SansSerif",Font.PLAIN,14));
+		double[] y = stats.histogram();
+		int n = y.length;
+		double[] x = new double[n];
+		int bits = getBitDepth();
+		boolean eightBit = bits==8 || bits==24;
+		double min = !eightBit?stats.min:0;
+		for (int i=0; i<n; i++)
+			x[i] = min+i*stats.binSize;
+		plot.add("bar", x, y);
+		if (bins!=256)
+			plot.addLegend(bins+" bins", "auto");
+		if (eightBit)
+			plot.setLimits(0,256,0,Double.NaN);
+		return plot.show();
+	}
+
+    public String toString() {
+    	return "img[\""+getTitle()+"\" ("+getID()+"), "+getBitDepth()+"-bit, "+width+"x"+height+"x"+getNChannels()+"x"+getNSlices()+"x"+getNFrames()+"]";
+    }
+
+    public void setIJMenuBar(boolean b) {
+    	setIJMenuBar = b;
+    }
+
+    public boolean setIJMenuBar() {
+    	return setIJMenuBar && Prefs.setIJMenuBar;
+    }
+
+    public boolean isStack() {
+    	return stack!=null;
+    }
+
+    public void setPlot(Plot plot) {
+    	this.plot = plot;
+    }
+
+    public Plot getPlot() {
+    	return plot;
+    }
+    
+    public Properties getImageProperties() {
+    	if (imageProperties==null)
+    		imageProperties = new Properties();
+    	return imageProperties;
+    }
+    
+    public boolean isRGB() {
+		return ip!=null && ip.getNChannels()==3;
+    }
+    
+    public void setBorderColor(Color borderColor) {
+    	this.borderColor = borderColor;
+    }
+    
+    public boolean windowActivated() {
+    	return this.activated;
+    }
+        
+}
diff --git a/src/ij/ImageStack.java b/src/ij/ImageStack.java
new file mode 100644
index 0000000..f6dc047
--- /dev/null
+++ b/src/ij/ImageStack.java
@@ -0,0 +1,722 @@
+package ij;
+import java.awt.*;
+import java.awt.image.*;
+import ij.process.*;
+
+/**
+This class represents an expandable array of images.
+@see ImagePlus
+*/
+public class ImageStack {
+	static final int INITIAL_SIZE = 25;
+	static final String outOfRange = "Stack argument out of range: ";
+	private int bitDepth = 0; //0=unknown
+	private int nSlices = 0;
+	private Object[] stack;
+	private String[] label;
+	private int width, height;
+	private Rectangle roi;
+	private ColorModel cm;
+	private double min=Double.MAX_VALUE;
+	private double max;
+	private float[] cTable;
+	private int viewers;
+	private boolean signedInt;
+	
+	/** Default constructor. */
+	public ImageStack() { }
+
+	/** Creates a new, empty image stack. */
+	public ImageStack(int width, int height) {
+		this(width, height, null);
+	}
+	
+	/** Creates a new, empty image stack with a capacity of 'size'.  All
+	     'size' slices and labels of this image stack are initially null.*/
+	public ImageStack(int width, int height, int size) {
+		this.width = width;
+		this.height = height;
+		stack = new Object[size];
+		label = new String[size];
+		nSlices = size;
+	}
+
+	/** Creates a new, empty image stack using the specified color model. */
+	public ImageStack(int width, int height, ColorModel cm) {
+		this.width = width;
+		this.height = height;
+		this.cm = cm;
+		stack = new Object[INITIAL_SIZE];
+		label = new String[INITIAL_SIZE];
+		nSlices = 0;
+	}
+
+	/** Adds an image in the form of a pixel array to the end of the stack. */
+	public void addSlice(String sliceLabel, Object pixels) {
+		if (pixels==null) 
+			throw new IllegalArgumentException("'pixels' is null!");
+		if (!pixels.getClass().isArray()) 
+			throw new IllegalArgumentException("'pixels' is not an array");
+		int size = stack.length;
+		nSlices++;
+		if (nSlices>=size) {
+			Object[] tmp1 = new Object[size*2];
+			System.arraycopy(stack, 0, tmp1, 0, size);
+			stack = tmp1;
+			String[] tmp2 = new String[size*2];
+			System.arraycopy(label, 0, tmp2, 0, size);
+			label = tmp2;
+		}
+		stack[nSlices-1] = pixels;
+		this.label[nSlices-1] = sliceLabel;
+		if (this.bitDepth==0)
+			setBitDepth(pixels);
+	}
+	
+	private void setBitDepth(Object pixels) {
+		if (pixels==null)
+			return;
+		if (pixels instanceof byte[])
+			this.bitDepth = 8;
+		else if (pixels instanceof short[])
+			this.bitDepth = 16;
+		else if (pixels instanceof float[])
+			this.bitDepth = 32;
+		else if (pixels instanceof int[])
+			this.bitDepth = 24;
+	}
+	
+	/**
+	* @deprecated
+	* Short images are always unsigned.
+	*/
+	public void addUnsignedShortSlice(String sliceLabel, Object pixels) {
+		addSlice(sliceLabel, pixels);
+	}
+	
+	/** Adds the image in 'ip' to the end of the stack. */
+	public void addSlice(ImageProcessor ip) {
+		addSlice(null, ip);
+	}
+
+	/** Adds the image in 'ip' to the end of the stack, setting
+		the string 'sliceLabel' as the slice metadata. */
+	public void addSlice(String sliceLabel, ImageProcessor ip) {
+		ip = convertType(ip);
+		if (ip.getWidth()!=this.width || ip.getHeight()!=this.height) {
+			if (this.width==0 && this.height==0)
+				init(ip.getWidth(), ip.getHeight());
+			else {
+				ImageProcessor ip2 = ip.createProcessor(this.width,this.height);
+				ip2.insert(ip, 0, 0);
+				ip = ip2;
+			}
+		}
+		if (nSlices==0) {
+			cm = ip.getColorModel();
+			min = ip.getMin();
+			max = ip.getMax();
+		}
+		addSlice(sliceLabel, ip.getPixels());
+	}
+	
+	private void init(int width, int height) {	
+		this.width = width;
+		this.height = height;
+		stack = new Object[INITIAL_SIZE];
+		label = new String[INITIAL_SIZE];
+	}
+	
+	private ImageProcessor convertType(ImageProcessor ip) {
+		int newBitDepth = ip.getBitDepth();
+		if (this.bitDepth==0)
+			this.bitDepth = newBitDepth;
+		if (this.bitDepth!=newBitDepth) {
+			switch (this.bitDepth) {
+				case 8: ip=ip.convertToByte(true); break;
+				case 16: ip=ip.convertToShort(true); break;
+				case 24:  ip=ip.convertToRGB(); break;
+				case 32: ip=ip.convertToFloat(); break;
+			}
+		}
+		return ip;
+	}
+	
+	/** Adds the image in 'ip' to the stack following slice 'n'. Adds
+		the slice to the beginning of the stack if 'n' is zero. */
+	public void addSlice(String sliceLabel, ImageProcessor ip, int n) {
+		if (n<0 || n>nSlices)
+			throw new IllegalArgumentException(outOfRange+n);
+		addSlice(sliceLabel, ip);
+		Object tempSlice = stack[nSlices-1];
+		String tempLabel = label[nSlices-1];
+		int first = n>0?n:1;
+		for (int i=nSlices-1; i>=first; i--) {
+			stack[i] = stack[i-1];
+			label[i] = label[i-1];
+		}
+		stack[n] = tempSlice;
+		label[n] = tempLabel;
+	}
+	
+	/** Deletes the specified slice, were 1<=n<=nslices. */
+	public void deleteSlice(int n) {
+		if (n<1 || n>nSlices)
+			throw new IllegalArgumentException(outOfRange+n);
+		if (nSlices<1)
+			return;
+		for (int i=n; i<nSlices; i++) {
+			stack[i-1] = stack[i];
+			label[i-1] = label[i];
+		}
+		stack[nSlices-1] = null;
+		label[nSlices-1] = null;
+		nSlices--;
+	}
+	
+	/** Deletes the last slice in the stack. */
+	public void deleteLastSlice() {
+		if (nSlices>0)
+			deleteSlice(nSlices);
+	}
+	
+    public int getWidth() {
+    	return width;
+    }
+
+    public int getHeight() {
+    	return height;
+    }
+    
+	public void setRoi(Rectangle roi) {
+		this.roi = roi;
+	}
+	
+	public Rectangle getRoi() {
+		if (roi==null)
+			return new Rectangle(0, 0, width, height);
+		else
+			return(roi);
+	}
+	
+	/** Updates this stack so its attributes, such as min, max,
+		calibration table and color model, are the same as 'ip'. */
+	public void update(ImageProcessor ip) {
+		if (ip!=null) {
+			min = ip.getMin();
+			max = ip.getMax();
+			cTable = ip.getCalibrationTable();
+			cm = ip.getColorModel();
+		}
+	}
+	
+	/** Returns the pixel array for the specified slice, were 1<=n<=nslices. */
+	public Object getPixels(int n) {
+		if (n<1 || n>nSlices)
+			throw new IllegalArgumentException(outOfRange+n);
+		return stack[n-1];
+	}
+	
+	/** Assigns a pixel array to the specified slice,
+		were 1<=n<=nslices. */
+	public void setPixels(Object pixels, int n) {
+		if (n<1 || n>nSlices)
+			throw new IllegalArgumentException(outOfRange+n);
+		stack[n-1] = pixels;
+		if (this.bitDepth==0)
+			setBitDepth(pixels);
+	}
+	
+	/** Returns the stack as an array of 1D pixel arrays. Note
+		that the size of the returned array may be greater than
+		the number of slices currently in the stack, with
+		unused elements set to null. */
+	public Object[] getImageArray() {
+		return stack;
+	}
+	
+	/** Returns the number of slices in this stack. */
+	public int size() {
+		return getSize();
+	}
+
+	public int getSize() {
+		return nSlices;
+	}
+
+	/** Returns the slice labels as an array of Strings. Note
+		that the size of the returned array may be greater than
+		the number of slices currently in the stack. Returns null
+		if the stack is empty or the label of the first slice is null.  */
+	public String[] getSliceLabels() {
+		if (nSlices==0)
+			return null;
+		else
+			return label;
+	}
+	
+	/** Returns the label of the specified slice, were 1<=n<=nslices.
+		Returns null if the slice does not have a label or 'n';
+		is out of range. For DICOM and FITS stacks, labels may
+		contain header information.
+	*/
+	public String getSliceLabel(int n) {
+		if (n<1 || n>nSlices)
+			return null;
+		else
+			return label[n-1];
+	}
+	
+	/** Returns a shortened version (up to the first 60 characters
+	 * or first newline), with the extension removed, of the specified
+	 * slice label, or null if the slice does not have a label.
+	*/
+	public String getShortSliceLabel(int n) {
+		return getShortSliceLabel(n, 60);
+	}
+
+	/** Returns a shortened version (up to the first 'max' characters
+	 * or first newline), with the extension removed, of the specified
+	 * slice label, or null if the slice does not have a label.
+	*/
+	public String getShortSliceLabel(int n, int max) {
+		String shortLabel = getSliceLabel(n);
+		if (shortLabel==null) return null;
+    	int newline = shortLabel.indexOf('\n');
+    	if (newline==0) return null;
+    	if (newline>0)
+    		shortLabel = shortLabel.substring(0, newline);
+    	int len = shortLabel.length();
+		if (len>4 && shortLabel.charAt(len-4)=='.' && !Character.isDigit(shortLabel.charAt(len-1)))
+			shortLabel = shortLabel.substring(0,len-4);
+		if (shortLabel.length()>max)
+			shortLabel = shortLabel.substring(0, max);
+		return shortLabel;
+	}
+	
+	/** Sets the label of the specified slice, were 1<=n<=nslices. */
+	public void setSliceLabel(String label, int n) {
+		if (n<1 || n>nSlices)
+			throw new IllegalArgumentException(outOfRange+n);
+		this.label[n-1] = label;
+	}
+	
+	/** Returns an ImageProcessor for the specified slice,
+		were 1<=n<=nslices. Returns null if the stack is empty.
+	*/
+	public ImageProcessor getProcessor(int n) {
+		ImageProcessor ip;
+		if (n<1 || n>nSlices)
+			throw new IllegalArgumentException(outOfRange+n);
+		if (nSlices==0)
+			return null;
+		if (stack[n-1]==null)
+			throw new IllegalArgumentException("Pixel array is null");
+		if (stack[n-1] instanceof byte[])
+			ip = new ByteProcessor(width, height, null, cm);
+		else if (stack[n-1] instanceof short[])
+			ip = new ShortProcessor(width, height, null, cm);
+		else if (stack[n-1] instanceof int[]) {
+			if (signedInt)
+				ip = new IntProcessor(width, height);
+			else
+				ip = new ColorProcessor(width, height, null);
+		} else if (stack[n-1] instanceof float[])
+			ip = new FloatProcessor(width, height, null, cm);		
+		else
+			throw new IllegalArgumentException("Unknown stack type");
+		ip.setPixels(stack[n-1]);
+		if (min!=Double.MAX_VALUE && ip!=null && !(ip instanceof ColorProcessor))
+			ip.setMinAndMax(min, max);
+		if (cTable!=null)
+			ip.setCalibrationTable(cTable);
+		return ip;
+	}
+	
+	/** Assigns the pixel array of an ImageProcessor to the
+		 specified slice, were 1<=n<=nslices. */
+	public void setProcessor(ImageProcessor ip, int n) {
+		if (n<1 || n>nSlices)
+			throw new IllegalArgumentException(outOfRange+n);
+		ip = convertType(ip);
+		if (ip.getWidth()!=width || ip.getHeight()!=height)
+			throw new IllegalArgumentException("Wrong dimensions for this stack");
+		stack[n-1] = ip.getPixels();
+	}
+
+	/** Assigns a new color model to this stack. */
+	public void setColorModel(ColorModel cm) {
+		this.cm = cm;
+	}
+	
+	/** Returns this stack's color model. May return null. */
+	public ColorModel getColorModel() {
+		return cm;
+	}
+	
+	/** Returns true if this is a 3-slice, 8-bit RGB stack. */
+	public boolean isRGB() {
+    	return nSlices==3 && (stack[0] instanceof byte[]) && getSliceLabel(1)!=null && getSliceLabel(1).equals("Red");
+	}
+	
+	/** Returns true if this is a 3-slice HSB stack. */
+	public boolean isHSB() {
+    	return nSlices==3 && bitDepth==8 && getSliceLabel(1)!=null && getSliceLabel(1).equals("Hue");
+	}
+
+	/** Returns true if this is a 3-slice 32-bit HSB stack. */
+	public boolean isHSB32() {
+    	return nSlices==3 && bitDepth==32 && getSliceLabel(1)!=null && getSliceLabel(1).equals("Hue");
+	}
+
+	/** Returns true if this is a Lab stack. */
+	public boolean isLab() {
+    	return nSlices==3 && getSliceLabel(1)!=null && getSliceLabel(1).equals("L*");	
+	}
+
+	/** Returns true if this is a virtual (disk resident) stack. 
+		This method is overridden by the VirtualStack subclass. */
+	public boolean isVirtual() {
+		return false;
+	}
+
+	/** Frees memory by deleting a few slices from the end of the stack. */
+	public void trim() {
+		int n = (int)Math.round(Math.log(nSlices)+1.0);
+		for (int i=0; i<n; i++) {
+			deleteLastSlice();
+			System.gc();
+		}
+	}
+
+	public String toString() {
+		String v = isVirtual()?"(V)":"";
+		return ("stack["+getWidth()+"x"+getHeight()+"x"+size()+v+"]");
+	}
+	
+	/** Returns, as a double, the value of the specified voxel.
+	 * Throws an IndexOutOfBoundsException if x, y or z are
+	 * beyond the stack limits. Use the ImagePlus.getStackIndex()
+	 * method to convert a C,Z,T hyperstack position (one-based)
+	 * into a z index (zero-based).
+	 * @see ij.ImagePlus#getStackIndex
+	*/
+	public final double getVoxel(int x, int y, int z) {
+		if (x>=0 && x<width && y>=0 && y<height && z>=0 && z<nSlices) {
+			switch (bitDepth) {
+				case 8:
+					byte[] bytes = (byte[])stack[z];
+					return bytes[y*width+x]&0xff;
+				case 16:
+					short[] shorts = (short[])stack[z];
+					return shorts[y*width+x]&0xffff;
+				case 32:
+					float[] floats = (float[])stack[z];
+					return floats[y*width+x];
+				case 24:
+					int[] ints = (int[])stack[z];
+					return ints[y*width+x]&0xffffffff;
+				default: return Double.NaN;
+			}
+		} else
+			throw new IndexOutOfBoundsException();
+	}
+		
+	/* Sets the value of the specified voxel. */
+	public final void setVoxel(int x, int y, int z, double value) {
+		if (x>=0 && x<width && y>=0 && y<height && z>=0 && z<nSlices) {
+			switch (bitDepth) {
+				case 8:
+					byte[] bytes = (byte[])stack[z];
+					if (value>255.0)
+						value = 255.0;
+					else if (value<0.0)
+						value = 0.0;
+					bytes[y*width+x] = (byte)(value+0.5);
+					break;
+				case 16:
+					short[] shorts = (short[])stack[z];
+					if (value>65535.0)
+						value = 65535.0;
+					else if (value<0.0)
+						value = 0.0;
+					shorts[y*width+x] = (short)(value+0.5);
+					break;
+				case 32:
+					float[] floats = (float[])stack[z];
+					floats[y*width+x] = (float)value;
+					break;
+				case 24:
+					int[] ints = (int[])stack[z];
+					ints[y*width+x] = (int)value;
+					break;
+			}
+		}
+	}
+	
+	public float[] getVoxels(int x0, int y0, int z0, int w, int h, int d, float[] voxels) {
+		boolean inBounds = x0>=0 && x0+w<=width && y0>=0 && y0+h<=height && z0>=0 && z0+d<=nSlices;
+		if (voxels==null || voxels.length!=w*h*d)
+			voxels = new float[w*h*d];
+		int i = 0;
+		int offset;
+		for (int z=z0; z<z0+d; z++) {
+			for (int y=y0; y<y0+h; y++) {
+				if (inBounds) {
+					switch (bitDepth) {
+						case 8:
+							byte[] bytes = (byte[])stack[z];
+							for (int x=x0; x<x0+w; x++)
+								voxels[i++] = bytes[y*width+x]&0xff;
+							break;
+						case 16:
+							short[] shorts = (short[])stack[z];
+							for (int x=x0; x<x0+w; x++)
+								voxels[i++] = shorts[y*width+x]&0xffff;
+							break;
+						case 32:
+							float[] floats = (float[])stack[z];
+							for (int x=x0; x<x0+w; x++)
+								voxels[i++] = floats[y*width+x];
+							break;
+						case 24:
+							int[] ints = (int[])stack[z];
+							for (int x=x0; x<x0+w; x++)
+								voxels[i++] = ints[y*width+x]&0xffffffff;
+							break;
+						default:
+							for (int x=x0; x<x0+w; x++)
+								voxels[i++] = 0f;
+					}
+				} else {
+					for (int x=x0; x<x0+w; x++)
+						voxels[i++] = (float)getVoxel(x, y, z);
+				}
+			}
+		}
+		return voxels;
+	}
+
+	public float[] getVoxels(int x0, int y0, int z0, int w, int h, int d, float[] voxels, int channel) {
+		if (bitDepth!=24)
+			return getVoxels(x0, y0, z0, w, h, d, voxels);
+		boolean inBounds = x0>=0 && x0+w<=width && y0>=0 && y0+h<=height && z0>=0 && z0+d<=nSlices;
+		if (voxels==null || voxels.length!=w*h*d)
+			voxels = new float[w*h*d];
+		int i = 0;
+		for (int z=z0; z<z0+d; z++) {
+			int[] ints = (int[])stack[z];
+			for (int y=y0; y<y0+h; y++) {
+				for (int x=x0; x<x0+w; x++) {
+					int value = inBounds?ints[y*width+x]&0xffffffff:(int)getVoxel(x, y, z);
+					switch (channel) {
+						case 0: value=(value&0xff0000)>>16; break;
+						case 1: value=(value&0xff00)>>8; break;
+						case 2: value=value&0xff;; break;
+					}
+					voxels[i++] = (float)value;
+				}
+			}
+		}
+		return voxels;
+	}
+
+	/** Experimental */
+	public void setVoxels(int x0, int y0, int z0, int w, int h, int d, float[] voxels) {
+		boolean inBounds = x0>=0 && x0+w<=width && y0>=0 && y0+h<=height && z0>=0 && z0+d<=nSlices;
+		if (voxels==null || voxels.length!=w*h*d)
+			;
+		int i = 0;
+		float value;
+		for (int z=z0; z<z0+d; z++) {
+			for (int y=y0; y<y0+h; y++) {
+				if (inBounds) {
+					switch (bitDepth) {
+						case 8:
+							byte[] bytes = (byte[])stack[z];
+							for (int x=x0; x<x0+w; x++) {
+								value = voxels[i++];
+								if (value>255f)
+									value = 255f;
+								else if (value<0f)
+									value = 0f;
+								bytes[y*width+x] = (byte)(value+0.5f);
+							}
+							break;
+						case 16:
+							short[] shorts = (short[])stack[z];
+							for (int x=x0; x<x0+w; x++) {
+								value = voxels[i++];
+								if (value>65535f)
+									value = 65535f;
+								else if (value<0f)
+									value = 0f;
+								shorts[y*width+x] = (short)(value+0.5f);
+							}
+							break;
+						case 32:
+							float[] floats = (float[])stack[z];
+							for (int x=x0; x<x0+w; x++) {
+								value = voxels[i++];
+								floats[y*width+x] = value;
+							}
+							break;
+						case 24:
+							int[] ints = (int[])stack[z];
+							for (int x=x0; x<x0+w; x++) {
+								value = voxels[i++];
+								ints[y*width+x] = (int)value;
+							}
+							break;
+					}
+				} else {
+					for (int x=x0; x<x0+w; x++)
+						setVoxel(x, y, z, voxels[i++]);
+				}
+			}
+		}
+	}
+	
+	/** Experimental */
+	public void setVoxels(int x0, int y0, int z0, int w, int h, int d, float[] voxels, int channel) {
+		if (bitDepth!=24) {
+			setVoxels(x0, y0, z0, w, h, d, voxels);
+			return;
+		}
+		boolean inBounds = x0>=0 && x0+w<=width && y0>=0 && y0+h<=height && z0>=0 && z0+d<=nSlices;
+		if (voxels==null || voxels.length!=w*h*d)
+			;
+		int i = 0;
+		for (int z=z0; z<z0+d; z++) {
+			int[] ints = (int[])stack[z];
+			for (int y=y0; y<y0+h; y++) {
+				for (int x=x0; x<x0+w; x++) {
+					int value = inBounds?ints[y*width+x]&0xffffffff:(int)getVoxel(x, y, z);
+					int color = (int)voxels[i++];
+					switch (channel) {
+						case 0: value=(value&0xff00ffff) | ((color&0xff)<<16); break;
+						case 1: value=(value&0xffff00ff) | ((color&0xff)<<8); break;
+						case 2: value=(value&0xffffff00) | (color&0xff); break;
+					}
+					if (inBounds)
+						ints[y*width+x] = value;
+					else
+						setVoxel(x, y, z, value);
+				}
+			}
+		}
+	}
+
+	/** Experimental */
+	public void drawSphere(double radius, int xc, int yc, int zc) {
+		int diameter = (int)Math.round(radius*2);
+	    double r = radius;
+		int xmin=(int)(xc-r+0.5), ymin=(int)(yc-r+0.5), zmin=(int)(zc-r+0.5);
+		int xmax=xmin+diameter, ymax=ymin+diameter, zmax=zmin+diameter;
+		double r2 = r*r;
+		r -= 0.5;
+		double xoffset=xmin+r, yoffset=ymin+r, zoffset=zmin+r;
+		double xx, yy, zz;
+		for (int x=xmin; x<=xmax; x++) {
+			for (int y=ymin; y<=ymax; y++) {
+				for (int z=zmin; z<=zmax; z++) {
+					xx = x-xoffset; yy = y-yoffset;  zz = z-zoffset;
+					if (xx*xx+yy*yy+zz*zz<=r2)
+						setVoxel(x, y, z, 255);
+				}
+			}
+		}
+	}
+
+	
+	/** Returns the bit depth (8=byte, 16=short, 24=RGB, 32=float). */
+	public int getBitDepth() {
+		if (this.bitDepth==0 && stack!=null && stack.length>0)
+			setBitDepth(stack[0]);
+		return this.bitDepth;
+	}
+	
+	/** Sets the bit depth (8=byte, 16=short, 24=RGB, 32=float). */
+	public void setBitDepth(int depth) {
+		if (size()==0 && (depth==8||depth==16||depth==24||depth==32))
+			this.bitDepth = depth;
+	}
+
+	/** Creates a new ImageStack.
+	*  @param width  width in pixels
+	*  @param height height in pixels
+	*  @param depth number of images
+	*  @param bitdepth  8, 16, 32 (float) or 24 (RGB)
+	*/
+	 public static ImageStack create(int width, int height, int depth, int bitdepth) {
+		ImageStack stack =  IJ.createImage("", width, height, depth, bitdepth).getStack();
+		if (bitdepth==16 || bitdepth==32) {
+			stack.min = Double.MAX_VALUE;
+			stack.max = 0.0;
+		}
+		return stack;
+	 }
+	 
+	/** Creates an ImageStack from an ImagePlus array. */
+	 public static ImageStack create(ImagePlus[] images) {
+		int w = 0;
+		int h = 0;
+		for (int i=0; i<images.length; i++) {
+			if (images[i].getWidth()>w) w=images[i].getWidth();
+			if (images[i].getHeight()>h) h=images[i].getHeight();
+		}
+		ImageStack stack =  new ImageStack(w, h);
+		stack.init(w, h);
+		for (int i=0; i<images.length; i++) {
+			stack.addSlice(images[i].getProcessor());
+		}
+		int depth = images[0].getBitDepth();
+		if (depth==16 || depth==32) {
+			stack.min = Double.MAX_VALUE;
+			stack.max = 0.0;
+		}
+		return stack;
+	 }
+
+	/** Duplicates this stack. */
+	 public ImageStack duplicate() {
+	 	return crop(0, 0, 0, width, height, size());
+	 }
+	 
+	/** Creates a new stack by cropping this one. */
+	 public ImageStack crop(int x, int y, int z, int width, int height, int depth) {
+	 	if (x<0||y<0||z<0||x+width>this.width||y+height>this.height||z+depth>size())
+	 		throw new IllegalArgumentException("Argument out of range");
+		ImageStack stack2 = new ImageStack(width, height, getColorModel());
+		for (int i=z; i<z+depth; i++) {
+			ImageProcessor ip2 = this.getProcessor(i+1);
+			ip2.setRoi(x, y, width, height);
+			ip2 = ip2.crop();
+			stack2.addSlice(this.getSliceLabel(i+1), ip2);
+		}
+		return stack2;
+	 }
+	 
+	/** Creates a float version of this stack. */
+	 public ImageStack convertToFloat() {
+		ImageStack stack2 = new ImageStack(width, height, getColorModel());
+		for (int i=1; i<=size(); i++) {
+			ImageProcessor ip2 = this.getProcessor(i);
+			ip2 = ip2.convertToFloat();
+			stack2.addSlice(this.getSliceLabel(i), ip2);
+		}
+		return stack2;
+	 }
+	 
+	 int viewers(int inc) {
+	 	viewers += inc;
+	 	if (IJ.debugMode) IJ.log("stack.viewers: "+viewers);
+	 	return viewers;
+	 }
+	 
+	 public void setOptions(String options) {
+	 	if (options==null) return;
+	 	signedInt = options.contains("32-bit int");
+	 }
+
+}
diff --git a/src/ij/LookUpTable.java b/src/ij/LookUpTable.java
new file mode 100644
index 0000000..c72bf3f
--- /dev/null
+++ b/src/ij/LookUpTable.java
@@ -0,0 +1,136 @@
+package ij;
+import java.awt.*;
+import java.awt.image.*;
+import ij.process.*;
+
+/** This class represents a color look-up table. */
+public class LookUpTable extends Object {
+	private int width, height;
+	private byte[] pixels;
+	private int mapSize = 0;
+	private ColorModel cm;
+	private byte[] rLUT, gLUT,bLUT;
+
+	/** Constructs a LookUpTable object from an AWT Image. */
+	public LookUpTable(Image img) {
+		PixelGrabber pg = new PixelGrabber(img, 0, 0, 1, 1, false);
+		try {
+			pg.grabPixels();
+			cm = pg.getColorModel();
+		}
+		catch (InterruptedException e){};
+		getColors(cm);
+	}
+
+	/** Constructs a LookUpTable object from a ColorModel. */
+	public LookUpTable(ColorModel cm) {
+		this.cm = cm;
+		getColors(cm);
+	}
+	
+	void getColors(ColorModel cm) {
+    	if (cm instanceof IndexColorModel) {
+    		IndexColorModel m = (IndexColorModel)cm;
+    		mapSize = m.getMapSize();
+    		rLUT = new byte[mapSize];
+    		gLUT = new byte[mapSize];
+    		bLUT = new byte[mapSize];
+    		m.getReds(rLUT); 
+    		m.getGreens(gLUT); 
+    		m.getBlues(bLUT); 
+    	}
+	}
+	
+	public int getMapSize() {
+		return mapSize;
+	}
+    
+    public byte[] getReds() {
+    	return rLUT;
+    }
+
+    public byte[] getGreens() {
+    	return gLUT;
+    }
+
+    public byte[] getBlues() {
+    	return bLUT;
+    }
+
+	public ColorModel getColorModel() {
+		return cm;
+	}
+
+	/** Returns <code>true</code> if this is a 256 entry grayscale LUT.
+		@see ij.process.ImageProcessor#isColorLut
+	*/
+	public boolean isGrayscale() {
+		boolean isGray = true;
+		
+		if (mapSize < 256)
+			return false;
+		for (int i=0; i<mapSize; i++)
+			if ((rLUT[i] != gLUT[i]) || (gLUT[i] != bLUT[i]))
+				isGray = false;
+		return isGray;
+	}
+			
+	public void drawColorBar(Graphics g, int x, int y, int width, int height) {
+		if (mapSize == 0)
+			return;
+		ColorProcessor cp = new ColorProcessor(width, height);
+		double scale = 256.0/mapSize;
+		for (int i = 0; i<256; i++) {
+			int index = (int)(i/scale);
+			cp.setColor(new Color(rLUT[index]&0xff,gLUT[index]&0xff,bLUT[index]&0xff));
+			cp.moveTo(i,0); cp.lineTo(i,height);
+		}
+		g.drawImage(cp.createImage(),x,y,null);
+		g.setColor(Color.black);
+		g.drawRect(x, y, width, height);
+	}
+
+	public void drawUnscaledColorBar(ImageProcessor ip, int x, int y, int width, int height) {
+		ImageProcessor bar = null;
+		if (ip instanceof ColorProcessor)
+			bar = new ColorProcessor(width, height);
+		else
+			bar = new ByteProcessor(width, height);
+		if (mapSize == 0) {  //no color table; draw a grayscale bar
+			for (int i = 0; i < 256; i++) {
+				bar.setColor(new Color(i, i, i));
+				bar.moveTo(i, 0); bar.lineTo(i, height);
+			}
+		} else {
+			for (int i = 0; i<mapSize; i++) {
+				bar.setColor(new Color(rLUT[i]&0xff, gLUT[i]&0xff, bLUT[i]&0xff));
+				bar.moveTo(i, 0); bar.lineTo(i, height);
+			}
+		}
+		ip.insert(bar, x,y);
+		ip.setColor(Color.black);
+		ip.drawRect(x-1, y, width+2, height);
+	}
+			
+	public static ColorModel createGrayscaleColorModel(boolean invert) {
+		byte[] rLUT = new byte[256];
+		byte[] gLUT = new byte[256];
+		byte[] bLUT = new byte[256];
+		if (invert)
+			for(int i=0; i<256; i++) {
+				rLUT[255-i]=(byte)i;
+				gLUT[255-i]=(byte)i;
+				bLUT[255-i]=(byte)i;
+			}
+		else {
+			for(int i=0; i<256; i++) {
+				rLUT[i]=(byte)i;
+				gLUT[i]=(byte)i;
+				bLUT[i]=(byte)i;
+			}
+		}
+		return(new IndexColorModel(8, 256, rLUT, gLUT, bLUT));
+	}
+	
+}
+
diff --git a/src/ij/Macro.java b/src/ij/Macro.java
new file mode 100644
index 0000000..9fe727f
--- /dev/null
+++ b/src/ij/Macro.java
@@ -0,0 +1,178 @@
+package ij;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.measure.*;
+import ij.plugin.filter.*;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.util.Locale;
+import java.util.Hashtable;
+
+/** The class contains static methods that perform macro operations. */
+public class Macro {
+
+	public static final String MACRO_CANCELED = "Macro canceled";
+
+	// A table of Thread as keys and String as values, so  
+	// Macro options are local to each calling thread.
+	static private Hashtable table = new Hashtable();
+	static boolean abort;
+
+	public static boolean open(String path) {
+		if (path==null || path.equals("")) {
+			Opener o = new Opener();
+			return true;
+		}
+		Opener o = new Opener();
+		ImagePlus img = o.openImage(path);
+		if (img==null)
+			return false;
+		img.show();	
+		return true;
+	}
+
+	public static boolean saveAs(String path) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			return false;
+		FileSaver fs = new FileSaver(imp);
+		if (path==null || path.equals(""))
+			return fs.saveAsTiff();
+		if (imp.getStackSize()>1)
+			return fs.saveAsTiffStack(path);
+		else
+			return fs.saveAsTiff(path);
+	}
+
+	public static String getName(String path) {
+		int i = path.lastIndexOf('/');
+		if (i==-1)
+			i = path.lastIndexOf('\\');
+		if (i>0)
+			return path.substring(i+1);
+		else
+			return path;
+	}
+	
+	public static String getDir(String path) {
+		int i = path.lastIndexOf('/');
+		if (i==-1)
+			i = path.lastIndexOf('\\');
+		if (i>0)
+			return path.substring(0, i+1);
+		else
+			return "";
+	}
+	
+	/** Aborts the currently running macro or any plugin using IJ.run(). */
+	public static void abort() {
+		//IJ.log("Abort: "+Thread.currentThread().getName());
+		abort = true;
+		if (Thread.currentThread().getName().endsWith("Macro$")) {
+			table.remove(Thread.currentThread());
+			throw new RuntimeException(MACRO_CANCELED);
+		}
+	}
+
+	/** If a command started using run(name, options) is running,
+		and the current thread is the same thread,
+		returns the options string, otherwise, returns null.
+		@see ij.gui.GenericDialog
+		@see ij.io.OpenDialog
+	*/
+	public static String getOptions() {
+		String threadName = Thread.currentThread().getName();
+		//IJ.log("getOptions: "+threadName+" "+Thread.currentThread().hashCode()); //ts
+		if (threadName.startsWith("Run$_")||threadName.startsWith("RMI TCP")) {
+			Object options = table.get(Thread.currentThread());
+			return options==null?null:options+" ";
+		} else
+			return null;
+	}
+
+	/** Define a set of Macro options for the current Thread. */
+	public static void setOptions(String options) {
+		//IJ.log("setOptions: "+Thread.currentThread().getName()+" "+Thread.currentThread().hashCode()+" "+options); //ts
+		if (options==null || options.equals(""))
+			table.remove(Thread.currentThread());
+		else
+			table.put(Thread.currentThread(), options);
+	}
+
+	/** Define a set of Macro options for a Thread. */
+	public static void setOptions(Thread thread, String options) {
+		if (null==thread)
+			throw new RuntimeException("Need a non-null thread instance");
+		if (null==options)
+			table.remove(thread);
+		else
+			table.put(thread, options);
+	}
+
+	public static String getValue(String options, String key, String defaultValue) {
+		key = trimKey(key);
+		if (!options.endsWith(" "))
+			options = options + " ";
+        key += '=';
+		int index=-1;
+		do { // Require that key not be preceded by a letter
+			index = options.indexOf(key, ++index);
+			if (index<0) return defaultValue;
+		} while (index!=0&&Character.isLetter(options.charAt(index-1)));
+		options = options.substring(index+key.length(), options.length());
+		if (options.charAt(0)=='\'') {
+			index = options.indexOf("'",1);
+			if (index<0)
+				return defaultValue;
+			else
+				return options.substring(1, index);
+		} else if (options.charAt(0)=='[') {
+			int count = 1;
+			index = -1;
+			for (int i=1; i<options.length(); i++) {
+				char ch = options.charAt(i);
+				if (ch=='[')
+					count++;
+				else if (ch==']')
+					count--;
+				if (count==0) {
+					index = i;
+					break;
+				}
+			}
+			if (index<0)
+				return defaultValue;
+			else
+				return options.substring(1, index);
+		} else {
+			index = options.indexOf(" ");
+			if (index<0)
+				return defaultValue;
+			else
+				return options.substring(0, index);
+		}
+	}
+	
+	public static String trimKey(String key) {
+		int index = key.indexOf(" ");
+		if (index>-1)
+			key = key.substring(0,index);
+		index = key.indexOf(":");
+		if (index>-1)
+			key = key.substring(0,index);
+		key = key.toLowerCase(Locale.US);
+		return key;
+	}
+	
+	/** Evaluates 'code' and returns the output, or any error, 
+	 * as a String (e.g., Macro.eval("2+2") returns "4").	
+	*/
+	public static String eval(String code) {
+		return new Interpreter().eval(code);
+	}
+
+}
+
diff --git a/src/ij/Menus.java b/src/ij/Menus.java
new file mode 100644
index 0000000..a988703
--- /dev/null
+++ b/src/ij/Menus.java
@@ -0,0 +1,1720 @@
+package ij;
+import ij.process.*;
+import ij.util.*;
+import ij.gui.ImageWindow;
+import ij.plugin.MacroInstaller;
+import ij.gui.Toolbar;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.*;
+import java.applet.Applet;
+import java.awt.event.*;
+import java.util.zip.*;
+
+/**
+This class installs and updates ImageJ's menus. Note that menu labels,
+even in submenus, must be unique. This is because ImageJ uses a single
+hash table for all menu labels. If you look closely, you will see that
+File->Import->Text Image... and File->Save As->Text Image... do not use
+the same label. One of the labels has an extra space.
+
+@see ImageJ
+*/
+
+public class Menus {
+
+	public static final char PLUGINS_MENU = 'p';
+	public static final char IMPORT_MENU = 'i';
+	public static final char SAVE_AS_MENU = 's';
+	public static final char SHORTCUTS_MENU = 'h'; // 'h'=hotkey
+	public static final char ABOUT_MENU = 'a';
+	public static final char FILTERS_MENU = 'f';
+	public static final char TOOLS_MENU = 't';
+	public static final char UTILITIES_MENU = 'u';
+		
+	public static final int WINDOW_MENU_ITEMS = 6; // fixed items at top of Window menu
+	
+	public static final int NORMAL_RETURN = 0;
+	public static final int COMMAND_IN_USE = -1;
+	public static final int INVALID_SHORTCUT = -2;
+	public static final int SHORTCUT_IN_USE = -3;
+	public static final int NOT_INSTALLED = -4;
+	public static final int COMMAND_NOT_FOUND = -5;
+	
+	public static final int MAX_OPEN_RECENT_ITEMS = 15;
+
+	private static Menus instance;
+	private static MenuBar mbar;
+	private static CheckboxMenuItem gray8Item,gray16Item,gray32Item,
+			color256Item,colorRGBItem,RGBStackItem,HSBStackItem,LabStackItem,HSB32Item;
+	private static PopupMenu popup;
+
+	private static ImageJ ij;
+	private static Applet applet;
+	private Hashtable demoImagesTable = new Hashtable();
+	private static String ImageJPath, pluginsPath, macrosPath;
+	private static Properties menus;
+	private static Properties menuSeparators;
+	private static Menu pluginsMenu, saveAsMenu, shortcutsMenu, utilitiesMenu, macrosMenu;
+	static Menu window, openRecentMenu;
+	private static Hashtable pluginsTable;
+	
+	private static int nPlugins, nMacros;
+	private static Hashtable shortcuts;
+	private static Hashtable macroShortcuts;
+	private static Vector pluginsPrefs; // commands saved in IJ_Prefs
+	static int windowMenuItems2; // non-image windows listed in Window menu + separator
+	private String error;
+	private String jarError;
+	private String pluginError;
+    private boolean isJarErrorHeading;
+	private static boolean installingJars, duplicateCommand;
+	private static Vector jarFiles;  // JAR files in plugins folder with "_" in their name
+	private Map menuEntry2jarFile = new HashMap();
+	private static Vector macroFiles;  // Macros and scripts in the plugins folder
+	private static int userPluginsIndex; // First user plugin or submenu in Plugins menu
+	private static boolean addSorted;
+	private static int defaultFontSize = IJ.isWindows()?15:0;
+	private static int fontSize = Prefs.getInt(Prefs.MENU_SIZE, defaultFontSize);
+	private static Font menuFont;
+	private static double scale = 1.0;
+
+	static boolean jnlp; // true when using Java WebStart
+	public static int setMenuBarCount;
+		
+	Menus(ImageJ ijInstance, Applet appletInstance) {
+		ij = ijInstance;
+		String title = ij!=null?ij.getTitle():null;
+		applet = appletInstance;
+		instance = this;
+	}
+
+	String addMenuBar() {
+		scale = Prefs.getGuiScale();
+		if ((scale>=1.5&&scale<2.0) || (scale>=2.5&&scale<3.0))
+			scale = (int)Math.round(scale);
+		nPlugins = nMacros = userPluginsIndex = 0;
+		addSorted = installingJars = duplicateCommand = false;
+		error = null;
+		mbar = null;
+		menus = new Properties();
+		pluginsTable = new Hashtable();
+		shortcuts = new Hashtable();
+		pluginsPrefs = new Vector();
+		macroShortcuts = null;
+		setupPluginsAndMacrosPaths();
+		Menu file = getMenu("File");
+		Menu newMenu = getMenu("File>New", true);
+		addPlugInItem(file, "Open...", "ij.plugin.Commands(\"open\")", KeyEvent.VK_O, false);
+		addPlugInItem(file, "Open Next", "ij.plugin.NextImageOpener", KeyEvent.VK_O, true);
+		Menu openSamples = getMenu("File>Open Samples", true);
+		openSamples.addSeparator();
+		addPlugInItem(openSamples, "Cache Sample Images ", "ij.plugin.URLOpener(\"cache\")", 0, false);
+		addOpenRecentSubMenu(file);
+		Menu importMenu = getMenu("File>Import", true);		
+		Menu showFolderMenu = new Menu("Show Folder");
+		file.add(showFolderMenu);
+		addPlugInItem(showFolderMenu, "Image", "ij.plugin.SimpleCommands(\"showdirImage\")", 0, false);
+		addPlugInItem(showFolderMenu, "Plugins", "ij.plugin.SimpleCommands(\"showdirPlugins\")", 0, false);
+		addPlugInItem(showFolderMenu, "Macros", "ij.plugin.SimpleCommands(\"showdirMacros\")", 0, false);
+		addPlugInItem(showFolderMenu, "LUTs", "ij.plugin.SimpleCommands(\"showdirLuts\")", 0, false);
+		addPlugInItem(showFolderMenu, "ImageJ", "ij.plugin.SimpleCommands(\"showdirImageJ\")", 0, false);
+		addPlugInItem(showFolderMenu, "temp", "ij.plugin.SimpleCommands(\"showdirTemp\")", 0, false);
+		addPlugInItem(showFolderMenu, "Home", "ij.plugin.SimpleCommands(\"showdirHome\")", 0, false);
+		file.addSeparator();
+		addPlugInItem(file, "Close", "ij.plugin.Commands(\"close\")", KeyEvent.VK_W, false);
+		addPlugInItem(file, "Close All", "ij.plugin.Commands(\"close-all\")", KeyEvent.VK_W, true);
+		addPlugInItem(file, "Save", "ij.plugin.Commands(\"save\")", KeyEvent.VK_S, false);
+		saveAsMenu = getMenu("File>Save As", true);
+		addPlugInItem(file, "Revert", "ij.plugin.Commands(\"revert\")", KeyEvent.VK_R,  true);
+		file.addSeparator();
+		addPlugInItem(file, "Page Setup...", "ij.plugin.filter.Printer(\"setup\")", 0, false);
+		addPlugInItem(file, "Print...", "ij.plugin.filter.Printer(\"print\")", KeyEvent.VK_P, false);
+		
+		Menu edit = getMenu("Edit");
+		addPlugInItem(edit, "Undo", "ij.plugin.Commands(\"undo\")", KeyEvent.VK_Z, false);
+		edit.addSeparator();
+		addPlugInItem(edit, "Cut", "ij.plugin.Clipboard(\"cut\")", KeyEvent.VK_X, false);
+		addPlugInItem(edit, "Copy", "ij.plugin.Clipboard(\"copy\")", KeyEvent.VK_C, false);
+		addPlugInItem(edit, "Copy to System", "ij.plugin.Clipboard(\"scopy\")", 0, false);
+		addPlugInItem(edit, "Paste", "ij.plugin.Clipboard(\"paste\")", KeyEvent.VK_V, false);
+		addPlugInItem(edit, "Paste Control...", "ij.plugin.frame.PasteController", 0, false);
+		edit.addSeparator();
+		addPlugInItem(edit, "Clear", "ij.plugin.filter.Filler(\"clear\")", 0, false);
+		addPlugInItem(edit, "Clear Outside", "ij.plugin.filter.Filler(\"outside\")", 0, false);
+		addPlugInItem(edit, "Fill", "ij.plugin.filter.Filler(\"fill\")", KeyEvent.VK_F, false);
+		addPlugInItem(edit, "Draw", "ij.plugin.filter.Filler(\"draw\")", KeyEvent.VK_D, false);
+		addPlugInItem(edit, "Invert", "ij.plugin.filter.Filters(\"invert\")", KeyEvent.VK_I, true);
+		edit.addSeparator();
+		getMenu("Edit>Selection", true);
+		Menu optionsMenu = getMenu("Edit>Options", true);
+		
+		Menu image = getMenu("Image");
+		Menu imageType = getMenu("Image>Type");
+			gray8Item = addCheckboxItem(imageType, "8-bit", "ij.plugin.Converter(\"8-bit\")");
+			gray16Item = addCheckboxItem(imageType, "16-bit", "ij.plugin.Converter(\"16-bit\")");
+			gray32Item = addCheckboxItem(imageType, "32-bit", "ij.plugin.Converter(\"32-bit\")");
+			color256Item = addCheckboxItem(imageType, "8-bit Color", "ij.plugin.Converter(\"8-bit Color\")");
+			colorRGBItem = addCheckboxItem(imageType, "RGB Color", "ij.plugin.Converter(\"RGB Color\")");
+			imageType.add(new MenuItem("-"));
+			RGBStackItem = addCheckboxItem(imageType, "RGB Stack", "ij.plugin.Converter(\"RGB Stack\")");
+			HSBStackItem = addCheckboxItem(imageType, "HSB Stack", "ij.plugin.Converter(\"HSB Stack\")");
+			HSB32Item = addCheckboxItem(imageType, "HSB (32-bit)", "ij.plugin.Converter(\"HSB (32-bit)\")");
+			LabStackItem = addCheckboxItem(imageType, "Lab Stack", "ij.plugin.Converter(\"Lab Stack\")");
+			image.add(imageType);
+			
+		image.addSeparator();
+		getMenu("Image>Adjust", true);
+		addPlugInItem(image, "Show Info...", "ij.plugin.ImageInfo", KeyEvent.VK_I, false);
+		addPlugInItem(image, "Properties...", "ij.plugin.filter.ImageProperties", KeyEvent.VK_P, true);
+		getMenu("Image>Color", true);
+		getMenu("Image>Stacks", true);
+		getMenu("Image>Stacks>Animation_", true);
+		getMenu("Image>Stacks>Tools_", true);
+		Menu hyperstacksMenu = getMenu("Image>Hyperstacks", true);
+		image.addSeparator();
+		addPlugInItem(image, "Crop", "ij.plugin.Resizer(\"crop\")", KeyEvent.VK_X, true);
+		addPlugInItem(image, "Duplicate...", "ij.plugin.Duplicator", KeyEvent.VK_D, true);
+		addPlugInItem(image, "Rename...", "ij.plugin.SimpleCommands(\"rename\")", 0, false);
+		addPlugInItem(image, "Scale...", "ij.plugin.Scaler", KeyEvent.VK_E, false);
+		getMenu("Image>Transform", true);
+		getMenu("Image>Zoom", true);
+		getMenu("Image>Overlay", true);
+		image.addSeparator();
+		getMenu("Image>Lookup Tables", true);
+		
+		Menu process = getMenu("Process");
+		addPlugInItem(process, "Smooth", "ij.plugin.filter.Filters(\"smooth\")", KeyEvent.VK_S, true);
+		addPlugInItem(process, "Sharpen", "ij.plugin.filter.Filters(\"sharpen\")", 0, false);
+		addPlugInItem(process, "Find Edges", "ij.plugin.filter.Filters(\"edge\")", 0, false);
+		addPlugInItem(process, "Find Maxima...", "ij.plugin.filter.MaximumFinder", 0, false);
+		addPlugInItem(process, "Enhance Contrast...", "ij.plugin.ContrastEnhancer", 0, false);
+		getMenu("Process>Noise", true);
+		getMenu("Process>Shadows", true);
+		getMenu("Process>Binary", true);
+		getMenu("Process>Math", true);
+		getMenu("Process>FFT", true);
+		Menu filtersMenu = getMenu("Process>Filters", true);
+		process.addSeparator();
+		getMenu("Process>Batch", true);
+		addPlugInItem(process, "Image Calculator...", "ij.plugin.ImageCalculator", 0, false);
+		addPlugInItem(process, "Subtract Background...", "ij.plugin.filter.BackgroundSubtracter", 0, false);
+		addItem(process, "Repeat Command", KeyEvent.VK_R, false);
+		
+		Menu analyzeMenu = getMenu("Analyze");
+		addPlugInItem(analyzeMenu, "Measure", "ij.plugin.filter.Analyzer", KeyEvent.VK_M, false);
+		addPlugInItem(analyzeMenu, "Analyze Particles...", "ij.plugin.filter.ParticleAnalyzer", 0, false);
+		addPlugInItem(analyzeMenu, "Summarize", "ij.plugin.filter.Analyzer(\"sum\")", 0, false);
+		addPlugInItem(analyzeMenu, "Distribution...", "ij.plugin.Distribution", 0, false);
+		addPlugInItem(analyzeMenu, "Label", "ij.plugin.filter.Filler(\"label\")", 0, false);
+		addPlugInItem(analyzeMenu, "Clear Results", "ij.plugin.filter.Analyzer(\"clear\")", 0, false);
+		addPlugInItem(analyzeMenu, "Set Measurements...", "ij.plugin.filter.Analyzer(\"set\")", 0, false);
+		analyzeMenu.addSeparator();
+		addPlugInItem(analyzeMenu, "Set Scale...", "ij.plugin.filter.ScaleDialog", 0, false);
+		addPlugInItem(analyzeMenu, "Calibrate...", "ij.plugin.filter.Calibrator", 0, false);
+		if (IJ.isMacOSX()) {
+			addPlugInItem(analyzeMenu, "Histogram", "ij.plugin.Histogram", 0, false);
+			shortcuts.put(new Integer(KeyEvent.VK_H),"Histogram");
+		} else
+			addPlugInItem(analyzeMenu, "Histogram", "ij.plugin.Histogram", KeyEvent.VK_H, false);
+		addPlugInItem(analyzeMenu, "Plot Profile", "ij.plugin.Profiler(\"plot\")", KeyEvent.VK_K, false);
+		addPlugInItem(analyzeMenu, "Surface Plot...", "ij.plugin.SurfacePlotter", 0, false);
+		getMenu("Analyze>Gels", true);
+		Menu toolsMenu = getMenu("Analyze>Tools", true);
+
+		// the plugins will be added later, after a separator
+		addPluginsMenu();
+
+		Menu window = getMenu("Window");
+		addPlugInItem(window, "Show All", "ij.plugin.WindowOrganizer(\"show\")", KeyEvent.VK_CLOSE_BRACKET, false);
+		String key = IJ.isWindows()?"enter":"return";
+		addPlugInItem(window, "Main Window ["+key+"]", "ij.plugin.WindowOrganizer(\"imagej\")", 0, false);
+		addPlugInItem(window, "Put Behind [tab]", "ij.plugin.Commands(\"tab\")", 0, false);
+		addPlugInItem(window, "Cascade", "ij.plugin.WindowOrganizer(\"cascade\")", 0, false);
+		addPlugInItem(window, "Tile", "ij.plugin.WindowOrganizer(\"tile\")", 0, false);
+		window.addSeparator();
+
+		Menu help = getMenu("Help");
+		addPlugInItem(help, "ImageJ Website...", "ij.plugin.BrowserLauncher", 0, false);
+		help.addSeparator();
+		addPlugInItem(help, "Dev. Resources...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/developer/index.html\")", 0, false);
+		addPlugInItem(help, "Plugins...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/plugins\")", 0, false);
+		addPlugInItem(help, "Macros...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/macros/\")", 0, false);
+		addPlugInItem(help, "Macro Functions...", "ij.plugin.BrowserLauncher(\""+IJ.URL+"/developer/macro/functions.html\")", 0, false);
+		Menu examplesMenu = getExamplesMenu(ij);
+		addPlugInItem(examplesMenu, "Open as Panel", "ij.plugin.SimpleCommands(\"opencp\")", 0, false);
+		help.add(examplesMenu);
+		help.addSeparator();
+		addPlugInItem(help, "Update ImageJ...", "ij.plugin.ImageJ_Updater", 0, false);
+		addPlugInItem(help, "Refresh Menus", "ij.plugin.ImageJ_Updater(\"menus\")", 0, false);
+		help.addSeparator();
+		Menu aboutMenu = getMenu("Help>About Plugins", true);
+		addPlugInItem(help, "About ImageJ...", "ij.plugin.AboutBox", 0, false);
+				
+		if (applet==null) {
+			menuSeparators = new Properties();
+			installPlugins();
+		}
+
+		// make	sure "Quit" is the last item in the File menu
+		file.addSeparator();
+		addPlugInItem(file, "Quit", "ij.plugin.Commands(\"quit\")", 0, false);
+
+		//System.out.println("MenuBar.setFont: "+fontSize+" "+scale+"  "+getFont());
+		if (fontSize!=0 || scale>1.0)
+			mbar.setFont(getFont());
+		if (ij!=null) {
+			ij.setMenuBar(mbar);
+			Menus.setMenuBarCount++;
+		}
+		
+		// Add deleted sample images to commands table
+		pluginsTable.put("Lena (68K)", "ij.plugin.URLOpener(\"lena-std.tif\")");
+		pluginsTable.put("Bridge (174K)", "ij.plugin.URLOpener(\"bridge.gif\")");
+		
+		if (pluginError!=null)
+			error = error!=null?error+="\n"+pluginError:pluginError;
+		if (jarError!=null)
+			error = error!=null?error+="\n"+jarError:jarError;
+		return error;
+	}
+	
+	public static Menu getExamplesMenu(ActionListener listener) {
+		Menu menu = new Menu("Examples");
+		Menu submenu = new Menu("Plots");
+		addExample(submenu, "Example Plot", "Example_Plot_.ijm");
+		addExample(submenu, "Semi-log Plot", "Semi-log_Plot_.ijm");
+		addExample(submenu, "Arrow Plot", "Arrow_Plot_.ijm");
+		addExample(submenu, "Damped Wave Plot", "Damped_Wave_Plot_.ijm");
+		addExample(submenu, "Dynamic Plot", "Dynamic_Plot_.ijm");
+		addExample(submenu, "Dynamic Plot 2D", "Dynamic_Plot_2D_.ijm");
+		addExample(submenu, "Custom Plot Symbols", "Custom_Plot_Symbols_.ijm");
+		addExample(submenu, "Histograms", "Histograms_.ijm");
+		addExample(submenu, "Bar Charts", "Bar_Charts_.ijm");
+		addExample(submenu, "Shapes", "Plot_Shapes_.ijm");
+		addExample(submenu, "Plot Styles", "Plot_Styles_.ijm");
+		addExample(submenu, "Random Data", "Random_Data_.ijm");
+		addExample(submenu, "Plot Results", "Plot_Results_.ijm");
+		submenu.addActionListener(listener);
+		menu.add(submenu);
+		
+		submenu = new Menu("Tools");
+		addExample(submenu, "Annular Selection", "Annular_Selection_Tool.ijm");		
+		addExample(submenu, "Big Cursor", "Big_Cursor_Tool.ijm");		
+		addExample(submenu, "Circle Tool", "Circle_Tool.ijm");
+		addExample(submenu, "Point Picker", "Point_Picker_Tool.ijm");		
+		addExample(submenu, "Star Tool", "Star_Tool.ijm");
+		addExample(submenu, "Animated Icon Tool", "Animated_Icon_Tool.ijm");
+		submenu.addActionListener(listener);
+		menu.add(submenu);
+
+		submenu = new Menu("Macro");
+		addExample(submenu, "Sphere", "Sphere.ijm");
+		addExample(submenu, "Dialog Box", "Dialog_Box.ijm");
+		addExample(submenu, "Process Folder", "Batch_Process_Folder.ijm");
+		addExample(submenu, "OpenDialog Demo", "OpenDialog_Demo.ijm");
+		addExample(submenu, "Save All Images", "Save_All_Images.ijm");
+		addExample(submenu, "Sine/Cosine Table", "Sine_Cosine_Table.ijm");
+		addExample(submenu, "Non-numeric Table", "Non-numeric_Table.ijm");
+		addExample(submenu, "Overlay", "Overlay.ijm");
+		addExample(submenu, "Stack Overlay", "Stack_Overlay.ijm");
+		addExample(submenu, "Array Functions", "Array_Functions.ijm");
+		addExample(submenu, "Dual Progress Bars", "Dual_Progress_Bars.ijm");
+		addExample(submenu, "Grab Viridis Colormap", "Grab_Viridis_Colormap.ijm");
+		addExample(submenu, "Custom Measurement", "Custom_Measurement.ijm");
+		addExample(submenu, "Synthetic Images", "Synthetic_Images.ijm");
+		addExample(submenu, "Spiral Rotation", "Spiral_Rotation.ijm");
+		addExample(submenu, "Curve Fitting", "Curve_Fitting.ijm");
+		addExample(submenu, "Colors of 2021", "Colors_of_2021.ijm");
+		submenu.addActionListener(listener);
+		menu.add(submenu);
+
+		submenu = new Menu("JavaScript");
+		addExample(submenu, "Sphere", "Sphere.js");
+		addExample(submenu, "Plasma Cloud", "Plasma_Cloud.js");
+		addExample(submenu, "Cloud Debugger", "Cloud_Debugger.js");
+		addExample(submenu, "Synthetic Images", "Synthetic_Images.js");
+		addExample(submenu, "Points", "Points.js");
+		addExample(submenu, "Spiral Rotation", "Spiral_Rotation.js");
+		addExample(submenu, "Example Plot", "Example_Plot.js");
+		addExample(submenu, "Semi-log Plot", "Semi-log_Plot.js");
+		addExample(submenu, "Arrow Plot", "Arrow_Plot.js");
+		addExample(submenu, "Dynamic Plot", "Dynamic_Plot.js");
+		addExample(submenu, "Plot Styles", "Plot_Styles.js");
+		addExample(submenu, "Plot Random Data", "Plot_Random_Data.js");
+		addExample(submenu, "Histogram Plots", "Histogram_Plots.js");
+		addExample(submenu, "JPEG Quality Plot", "JPEG_Quality_Plot.js");
+		addExample(submenu, "Process Folder", "Batch_Process_Folder.js");
+		addExample(submenu, "Sine/Cosine Table", "Sine_Cosine_Table.js");
+		addExample(submenu, "Non-numeric Table", "Non-numeric_Table.js");
+		addExample(submenu, "Overlay", "Overlay.js");
+		addExample(submenu, "Stack Overlay", "Stack_Overlay.js");
+		addExample(submenu, "Dual Progress Bars", "Dual_Progress_Bars.js");
+		addExample(submenu, "Gamma Adjuster", "Gamma_Adjuster.js");
+		addExample(submenu, "Custom Measurement", "Custom_Measurement.js");
+		addExample(submenu, "Terabyte VirtualStack", "Terabyte_VirtualStack.js");
+		addExample(submenu, "Event Listener", "Event_Listener.js");
+		addExample(submenu, "FFT Filter", "FFT_Filter.js");
+		addExample(submenu, "Curve Fitting", "Curve_Fitting.js");
+		addExample(submenu, "Overlay Text", "Overlay_Text.js");
+		addExample(submenu, "Crop Multiple Rois", "Crop_Multiple_Rois.js");
+		addExample(submenu, "Show all LUTs", "Show_all_LUTs.js");
+		addExample(submenu, "Dialog Demo", "Dialog_Demo.js");
+		submenu.addActionListener(listener);
+		menu.add(submenu);
+		submenu = new Menu("BeanShell");
+		addExample(submenu, "Sphere", "Sphere.bsh");
+		addExample(submenu, "Example Plot", "Example_Plot.bsh");
+		addExample(submenu, "Semi-log Plot", "Semi-log_Plot.bsh");
+		addExample(submenu, "Arrow Plot", "Arrow_Plot.bsh");
+		addExample(submenu, "Sine/Cosine Table", "Sine_Cosine_Table.bsh");
+		submenu.addActionListener(listener);
+		menu.add(submenu);
+		submenu = new Menu("Python");
+		addExample(submenu, "Sphere", "Sphere.py");
+		addExample(submenu, "Animated Gaussian Blur", "Animated_Gaussian_Blur.py");
+		addExample(submenu, "Spiral Rotation", "Spiral_Rotation.py");
+		addExample(submenu, "Overlay", "Overlay.py");
+		submenu.addActionListener(listener);
+		menu.add(submenu);
+		submenu = new Menu("Java");
+		addExample(submenu, "Sphere", "Sphere_.java");
+		addExample(submenu, "Plasma Cloud", "Plasma_Cloud.java");
+		addExample(submenu, "Gamma Adjuster", "Gamma_Adjuster.java");
+		addExample(submenu, "Plugin", "My_Plugin.java");
+		addExample(submenu, "Plugin Filter", "Filter_Plugin.java");
+		addExample(submenu, "Plugin Frame", "Plugin_Frame.java");
+		addExample(submenu, "Plugin Tool", "Prototype_Tool.java");
+		submenu.addActionListener(listener);
+		menu.add(submenu);
+		menu.addSeparator();
+		CheckboxMenuItem item = new CheckboxMenuItem("Autorun Examples");
+		menu.add(item);
+		item.addItemListener(ij);
+		item.setState(Prefs.autoRunExamples);
+		return menu;
+	}
+	
+	private static void addExample(Menu menu, String label, String command) {
+		MenuItem item = new MenuItem(label);
+		menu.add(item);
+		item.setActionCommand(command);
+	}
+
+	void addOpenRecentSubMenu(Menu menu) {
+		openRecentMenu = getMenu("File>Open Recent");
+ 		for (int i=0; i<MAX_OPEN_RECENT_ITEMS; i++) {
+			String path = Prefs.getString("recent" + (i/10)%10 + i%10);
+			if (path==null) break;
+			MenuItem item = new MenuItem(path);
+			openRecentMenu.add(item);
+			item.addActionListener(ij);
+		}
+		menu.add(openRecentMenu);
+	}
+
+	static void addItem(Menu menu, String label, int shortcut, boolean shift) {
+		if (menu==null)
+			return;
+		MenuItem item;
+		if (shortcut==0)
+			item = new MenuItem(label);
+		else {
+			if (shift) {
+				item = new MenuItem(label, new MenuShortcut(shortcut, true));
+				shortcuts.put(new Integer(shortcut+200),label);
+			} else {
+				item = new MenuItem(label, new MenuShortcut(shortcut));
+				shortcuts.put(new Integer(shortcut),label);
+			}
+		}
+		if (addSorted) {
+			if (menu==pluginsMenu)
+				addItemSorted(menu, item, userPluginsIndex);
+			else
+				addOrdered(menu, item);
+		} else
+			menu.add(item);
+		item.addActionListener(ij);
+	}
+	
+	void addPlugInItem(Menu menu, String label, String className, int shortcut, boolean shift) {
+		pluginsTable.put(label, className);
+		nPlugins++;
+		addItem(menu, label, shortcut, shift);
+	}
+
+	CheckboxMenuItem addCheckboxItem(Menu menu, String label, String className) {
+		pluginsTable.put(label, className);
+		nPlugins++;
+		CheckboxMenuItem item = new CheckboxMenuItem(label);
+		menu.add(item);
+		item.addItemListener(ij);
+		item.setState(false);
+		return item;
+	}
+
+	static Menu addSubMenu(Menu menu, String name) {
+		String value;
+		String key = name.toLowerCase(Locale.US);
+		int index;
+ 		Menu submenu=new Menu(name.replace('_', ' '));
+		index = key.indexOf(' ');
+		if (index>0)
+			key = key.substring(0, index);
+ 		for (int count=1; count<100; count++) {
+			value = Prefs.getString(key + (count/10)%10 + count%10);
+			if (value==null)
+				break;
+			if (count==1)
+				menu.add(submenu);
+			if (value.equals("-"))
+				submenu.addSeparator();
+			else
+				addPluginItem(submenu, value);
+		}
+		if (name.equals("Lookup Tables") && applet==null)
+			addLuts(submenu);
+		return submenu;
+	}
+	
+	static void addLuts(Menu submenu) {
+		String path = IJ.getDirectory("luts");
+		if (path==null) return;
+		File f = new File(path);
+		String[] list = null;
+		if (applet==null && f.exists() && f.isDirectory())
+			list = f.list();
+		if (list==null) return;
+		if (IJ.isLinux() || IJ.isMacOSX())
+			Arrays.sort(list);
+		submenu.addSeparator();
+ 		for (int i=0; i<list.length; i++) {
+ 			String name = list[i];
+ 			if (name.endsWith(".lut")) {
+ 				name = name.substring(0,name.length()-4);
+ 				if (name.contains("_") && !name.contains(" "))
+ 					name = name.replace("_", " ");
+ 				MenuItem item = new MenuItem(name);
+				submenu.add(item);
+				item.addActionListener(ij);
+				nPlugins++;
+			}
+		}
+	}
+
+	static void addPluginItem(Menu submenu, String s) {
+		if (s.startsWith("\"-\"")) {
+			// add menu separator if command="-"
+			addSeparator(submenu);
+			return;
+		}
+		int lastComma = s.lastIndexOf(',');
+		if (lastComma<=0)
+			return;
+		String command = s.substring(1,lastComma-1);
+		int keyCode = 0;
+		boolean shift = false;
+		if (command.endsWith("]")) {
+			int openBracket = command.lastIndexOf('[');
+			if (openBracket>0) {
+				String shortcut = command.substring(openBracket+1,command.length()-1);
+				keyCode = convertShortcutToCode(shortcut);
+				boolean functionKey = keyCode>=KeyEvent.VK_F1 && keyCode<=KeyEvent.VK_F12;
+				if (keyCode>0 && !functionKey)
+					command = command.substring(0,openBracket);
+			}
+		}
+		if (keyCode>=KeyEvent.VK_F1 && keyCode<=KeyEvent.VK_F12) {
+			shortcuts.put(new Integer(keyCode),command);
+			keyCode = 0;
+		} else if (keyCode>=265 && keyCode<=290) {
+			keyCode -= 200;
+			shift = true;
+		}
+		addItem(submenu,command,keyCode,shift);
+		while(s.charAt(lastComma+1)==' ' && lastComma+2<s.length())
+			lastComma++; // remove leading spaces
+		String className = s.substring(lastComma+1,s.length());
+		//IJ.log(command+"  "+className);
+		if (installingJars)
+			duplicateCommand = pluginsTable.get(command)!=null;
+		pluginsTable.put(command, className);
+		nPlugins++;
+	}
+
+	void checkForDuplicate(String command) {
+		if (pluginsTable.get(command)!=null) {
+		}
+	}
+	
+	void addPluginsMenu() {
+		String value,label,className;
+		int index;
+		//pluginsMenu = new Menu("Plugins");
+		pluginsMenu = getMenu("Plugins");
+		for (int count=1; count<100; count++) {
+			value = Prefs.getString("plug-in" + (count/10)%10 + count%10);
+			if (value==null)
+				break;
+			char firstChar = value.charAt(0);
+			if (firstChar=='-')
+				pluginsMenu.addSeparator();
+			else if (firstChar=='>') {
+				String submenu = value.substring(2,value.length()-1);
+				//Menu menu = getMenu("Plugins>" + submenu, true);
+				Menu menu = addSubMenu(pluginsMenu, submenu);
+				if (submenu.equals("Shortcuts"))
+					shortcutsMenu = menu;
+				else if (submenu.equals("Utilities"))
+					utilitiesMenu = menu;
+				else if (submenu.equals("Macros"))
+					macrosMenu = menu;
+			} else
+				addPluginItem(pluginsMenu, value);
+		}
+		userPluginsIndex = pluginsMenu.getItemCount();
+		if (userPluginsIndex<0) userPluginsIndex = 0;
+	}
+
+	/** Install plugins using "pluginxx=" keys in IJ_Prefs.txt.
+		Plugins not listed in IJ_Prefs are added to the end
+		of the Plugins menu. */
+	void installPlugins() {
+		int nPlugins0 = nPlugins;
+		String value, className;
+		char menuCode;
+		Menu menu;
+		String[] pluginList = getPlugins();
+		String[] pluginsList2 = null;
+		Hashtable skipList = new Hashtable();
+ 		for (int index=0; index<100; index++) {
+			value = Prefs.getString("plugin" + (index/10)%10 + index%10);
+			if (value==null)
+				break;
+			menuCode = value.charAt(0);
+			switch (menuCode) {
+				case PLUGINS_MENU: default: menu = pluginsMenu; break;
+				case IMPORT_MENU: menu = getMenu("File>Import"); break;
+				case SAVE_AS_MENU: menu = getMenu("File>Save As"); break;
+				case SHORTCUTS_MENU: menu = shortcutsMenu; break;
+				case ABOUT_MENU: menu = getMenu("Help>About Plugins"); break;
+				case FILTERS_MENU: menu = getMenu("Process>Filters"); break;
+				case TOOLS_MENU: menu = getMenu("Analyze>Tools"); break;
+				case UTILITIES_MENU: menu = utilitiesMenu; break;
+			}
+			String prefsValue = value;
+			value = value.substring(2,value.length()); //remove menu code and coma
+			className = value.substring(value.lastIndexOf(',')+1,value.length());
+			boolean found = className.startsWith("ij.");
+			if (!found && pluginList!=null) { // does this plugin exist?
+				if (pluginsList2==null)
+					pluginsList2 = getStrippedPlugins(pluginList);
+				for (int i=0; i<pluginsList2.length; i++) {
+					if (className.startsWith(pluginsList2[i])) {
+						found = true;
+						break;
+					}
+				}
+			}
+			if (found && menu!=pluginsMenu) {
+				addPluginItem(menu, value);
+				pluginsPrefs.addElement(prefsValue);
+				if (className.endsWith("\")")) { // remove any argument
+					int argStart = className.lastIndexOf("(\"");
+					if (argStart>0)
+						className = className.substring(0, argStart);
+				}
+				skipList.put(className, "");
+			}
+		}
+		if (pluginList!=null) {
+			for (int i=0; i<pluginList.length; i++) {
+				if (!skipList.containsKey(pluginList[i]))
+					installUserPlugin(pluginList[i]);
+			}
+		}
+		if ((nPlugins-nPlugins0)<=1 && IJ.getDir("imagej")!=null && IJ.getDir("imagej").startsWith("/private")) {
+			pluginsMenu.addSeparator();
+			addPlugInItem(pluginsMenu, "Why are Plugins Missing?", "ij.plugin.SimpleCommands(\"missing\")", 0, false);
+		}
+		installJarPlugins();
+		installMacros();
+	}
+	
+	/** Installs macros and scripts located in the plugins folder. */
+	void installMacros() {
+		if (macroFiles==null)
+			return;
+		for (int i=0; i<macroFiles.size(); i++) {
+			String name = (String)macroFiles.elementAt(i);
+			installMacro(name);
+		}		
+	}
+
+	/** Installs a macro or script in the Plugins menu, or submenu, with
+		with underscores in the file name replaced by spaces. */
+	void installMacro(String name) {
+		Menu menu = pluginsMenu;
+		String dir = null;
+		int slashIndex = name.indexOf('/');
+		if (slashIndex>0) {
+			dir = name.substring(0, slashIndex);
+			name = name.substring(slashIndex+1, name.length());
+			menu = getPluginsSubmenu(dir);
+			slashIndex = name.indexOf('/');
+			if (slashIndex>0) {
+				String dir2 = name.substring(0, slashIndex);
+				name = name.substring(slashIndex+1, name.length());
+				String menuName = "Plugins>"+dir+">"+dir2;
+				menu = getMenu(menuName);
+				dir += File.separator+dir2;
+			}
+		}
+		String command = name.replace('_',' ');
+		if (command.endsWith(".js")||command.endsWith(".py"))
+			command = command.substring(0, command.length()-3); //remove ".js" or ".py"
+		else
+			command = command.substring(0, command.length()-4); //remove ".txt", ".ijm" or ".bsh"
+		command.trim();
+		if (pluginsTable.get(command)!=null) // duplicate command?
+			command = command + " Macro";
+		MenuItem item = new MenuItem(command);
+		addOrdered(menu, item);
+		item.addActionListener(ij);
+		String path = (dir!=null?dir+File.separator:"") + name;
+		pluginsTable.put(command, "ij.plugin.Macro_Runner(\""+path+"\")");
+		nMacros++;
+	}
+
+	static int addPluginSeparatorIfNeeded(Menu menu) {
+		if (menuSeparators == null)
+			return 0;
+		Integer i = (Integer)menuSeparators.get(menu);
+		if (i == null) {
+			if (menu.getItemCount() > 0)
+				addSeparator(menu);
+			i = new Integer(menu.getItemCount());
+			menuSeparators.put(menu, i);
+		}
+		return i.intValue();
+	}
+
+	/** Inserts 'item' into 'menu' in alphanumeric order. */
+	static void addOrdered(Menu menu, MenuItem item) {
+		String label = item.getLabel();
+		int start = addPluginSeparatorIfNeeded(menu);
+		for (int i=start; i<menu.getItemCount(); i++) {
+			if (label.compareTo(menu.getItem(i).getLabel())<0) {
+				menu.insert(item, i);
+				return;
+			}
+		}
+		menu.add(item);
+	}
+	
+	public static String getJarFileForMenuEntry(String menuEntry) {
+		if (instance == null)
+			return null;
+		return (String)instance.menuEntry2jarFile.get(menuEntry);
+	}
+
+	/** Install plugins located in JAR files. */
+	void installJarPlugins() {
+		if (jarFiles==null)
+			return;
+		installingJars = true;
+		for (int i=0; i<jarFiles.size(); i++) {
+            isJarErrorHeading = false;
+			String jar = (String)jarFiles.elementAt(i);
+			InputStream is = getConfigurationFile(jar);
+            if (is==null) continue;
+            ArrayList entries = new ArrayList(20);
+            LineNumberReader lnr = new LineNumberReader(new InputStreamReader(is));
+            try {
+                while(true) {
+                    String s = lnr.readLine();
+                    if (s==null) break;
+					if (s.length()>=3 && !s.startsWith("#"))
+						entries.add(s);
+	            }
+            }
+            catch (IOException e) {}
+			finally {
+				try {if (lnr!=null) lnr.close();}
+				catch (IOException e) {}
+			}
+			for (int j=0; j<entries.size(); j++)
+				installJarPlugin(jar, (String)entries.get(j));
+		}		
+	}
+    
+    /** Install a plugin located in a JAR file. */
+	void installJarPlugin(String jar, String s) {
+		addSorted = false;
+		Menu menu;
+		s = s.trim();
+		if (s.startsWith("Plugins>")) {
+			int firstComma = s.indexOf(',');
+			if (firstComma==-1 || firstComma<=8)
+				menu = null;
+			else {
+				String name = s.substring(8, firstComma);
+				menu = getPluginsSubmenu(name);
+			}
+		} else if (s.startsWith("\"") || s.startsWith("Plugins")) {
+			String name = getSubmenuName(jar);
+			if (name!=null)
+				menu = getPluginsSubmenu(name);
+			else
+				menu = pluginsMenu;
+			addSorted = true;
+		} else {
+			int firstQuote = s.indexOf('"');
+			String name = firstQuote<0 ? s : s.substring(0, firstQuote).trim();
+			int comma = name.indexOf(',');
+			if (comma >= 0)
+				name = name.substring(0, comma);
+			if (name.startsWith("Help>About")) // for backward compatibility
+				name = "Help>About Plugins";
+			menu = getMenu(name);
+		}
+		int firstQuote = s.indexOf('"');
+		if (firstQuote==-1)
+			return;
+		s = s.substring(firstQuote, s.length()); // remove menu
+		if (menu!=null) {
+			addPluginSeparatorIfNeeded(menu);
+            addPluginItem(menu, s);
+            addSorted = false;
+        }
+		String menuEntry = s;
+		if (s.startsWith("\"")) {
+			int quote = s.indexOf('"', 1);
+			menuEntry = quote<0?s.substring(1):s.substring(1, quote);
+		} else {
+			int comma = s.indexOf(',');
+			if (comma > 0)
+				menuEntry = s.substring(0, comma);
+		}
+		if (duplicateCommand) {
+			if (jarError==null) jarError = "";
+            addJarErrorHeading(jar);
+			String jar2 = (String)menuEntry2jarFile.get(menuEntry);
+			if (jar2 != null && jar2.startsWith(pluginsPath))
+				jar2 = jar2.substring(pluginsPath.length());
+			jarError += "    Duplicate command: " + s
+				+ (jar2 != null ? " (already in " + jar2 + ")"
+				   : "") + "\n";
+		} else
+			menuEntry2jarFile.put(menuEntry, jar);
+		duplicateCommand = false;
+    }
+    
+    void addJarErrorHeading(String jar) {
+        if (!isJarErrorHeading) {
+                if (!jarError.equals(""))
+                    jarError += " \n";
+                jarError += "Plugin configuration error: " + jar + "\n";
+                isJarErrorHeading = true;
+            }
+    }
+
+	/** Returns the specified ImageJ menu (e.g., "File>New") or null if it is not found. */
+	public static Menu getImageJMenu(String menuPath) {
+		if (menus==null)
+			IJ.init();
+		if (menus==null)
+			return null;
+		if (menus.get(menuPath)!=null)
+			return getMenu(menuPath, false);
+		else
+			return null;
+	}
+
+	private static Menu getMenu(String menuPath) {
+		return getMenu(menuPath, false);
+	}
+
+	private static Menu getMenu(String menuName, boolean readFromProps) {
+		if (menuName.endsWith(">"))
+			menuName = menuName.substring(0, menuName.length() - 1);
+		Menu result = (Menu)menus.get(menuName);
+		if (result==null) {
+			int offset = menuName.lastIndexOf('>');
+			if (offset < 0) {
+				result = new Menu(menuName);
+				if (mbar == null)
+					mbar = new MenuBar();
+				if (menuName.equals("Help"))
+					mbar.setHelpMenu(result);
+				else
+					mbar.add(result);
+				if (menuName.equals("Window"))
+					window = result;
+				else if (menuName.equals("Plugins"))
+					pluginsMenu = result;
+			} else {
+				String parentName = menuName.substring(0, offset);
+				String menuItemName = menuName.substring(offset + 1);
+				Menu parentMenu = getMenu(parentName);
+				result = new Menu(menuItemName);
+				addPluginSeparatorIfNeeded(parentMenu);
+				if (readFromProps)
+					result = addSubMenu(parentMenu, menuItemName);
+				else if (parentName.startsWith("Plugins") && menuSeparators != null)
+					addItemSorted(parentMenu, result, parentName.equals("Plugins")?userPluginsIndex:0);
+				else
+					parentMenu.add(result);
+				if (menuName.equals("File>Open Recent"))
+					openRecentMenu = result;
+			}
+			menus.put(menuName, result);
+		}
+		return result;
+	}
+
+	Menu getPluginsSubmenu(String submenuName) {
+		return getMenu("Plugins>" + submenuName);
+    }
+    
+	String getSubmenuName(String jarPath) {
+		//IJ.log("getSubmenuName: \n"+jarPath+"\n"+pluginsPath);
+		if (pluginsPath == null)
+			return null;
+		if (jarPath.startsWith(pluginsPath))
+			jarPath = jarPath.substring(pluginsPath.length() - 1);
+		int index = jarPath.lastIndexOf(File.separatorChar);
+		if (index<0) return null;
+		String name = jarPath.substring(0, index);
+		index = name.lastIndexOf(File.separatorChar);
+		if (index<0) return null;
+		name = name.substring(index+1);
+		if (name.equals("plugins")) return null;
+		return name;
+    }
+
+	static void addItemSorted(Menu menu, MenuItem item, int startingIndex) {
+		String itemLabel = item.getLabel();
+		int count = menu.getItemCount();
+		boolean inserted = false;
+		for (int i=startingIndex; i<count; i++) {
+			MenuItem mi = menu.getItem(i);
+			String label = mi.getLabel();
+			//IJ.log(i+ "  "+itemLabel+"  "+label + "  "+(itemLabel.compareTo(label)));
+			if (itemLabel.compareTo(label)<0) {
+				menu.insert(item, i);
+				inserted = true;
+				break;
+			}
+		}
+		if (!inserted) menu.add(item);
+	}
+
+    static void addSeparator(Menu menu) {
+    	menu.addSeparator();
+    }
+
+    /** Opens the configuration file ("plugins.config") from a JAR file and returns it as an InputStream. */
+	InputStream getConfigurationFile(String jar) {
+		try {
+			ZipFile jarFile = new ZipFile(jar);
+			Enumeration entries = jarFile.entries();
+			while (entries.hasMoreElements()) {
+				ZipEntry entry = (ZipEntry) entries.nextElement();
+        		if (entry.getName().endsWith("plugins.config"))
+					return jarFile.getInputStream(entry);
+			}
+		}
+    	catch (Throwable e) {
+    		IJ.log(jar+": "+e);
+    	}
+		return autoGenerateConfigFile(jar);
+	}
+	
+    /** Creates a configuration file for JAR/ZIP files that do not have one. */
+	InputStream autoGenerateConfigFile(String jar) {
+		StringBuffer sb = null;
+		try {
+			ZipFile jarFile = new ZipFile(jar);
+			Enumeration entries = jarFile.entries();
+			while (entries.hasMoreElements()) {
+				ZipEntry entry = (ZipEntry) entries.nextElement();
+				String name = entry.getName();
+				if (name.endsWith(".class") && name.indexOf("_")>0 && name.indexOf("$")==-1
+				&& name.indexOf("/_")==-1 && !name.startsWith("_")) {
+					if (Character.isLowerCase(name.charAt(0))&&name.indexOf("/")!=-1)
+						continue;
+					if (sb==null) sb = new StringBuffer();
+					String className = name.substring(0, name.length()-6);
+					int slashIndex = className.lastIndexOf('/');
+					String plugins = "Plugins";
+					if (slashIndex >= 0) {
+						plugins += ">" + className.substring(0, slashIndex).replace('/', '>').replace('_', ' ');
+						name = className.substring(slashIndex + 1);
+					} else
+						name = className;
+					name = name.replace('_', ' ');
+					className = className.replace('/', '.');
+					//if (className.indexOf(".")==-1 || Character.isUpperCase(className.charAt(0)))
+					sb.append(plugins + ", \""+name+"\", "+className+"\n");
+				}
+			}
+		}
+    	catch (Throwable e) {
+    		IJ.log(jar+": "+e);
+    	}
+		//IJ.log(""+(sb!=null?sb.toString():"null"));
+		if (sb==null)
+			return null;
+		else
+    		return new ByteArrayInputStream(sb.toString().getBytes());
+	}
+	
+	/** Returns a list of the plugins with directory names removed. */
+	String[] getStrippedPlugins(String[] plugins) {
+		String[] plugins2 = new String[plugins.length];
+		int slashPos;
+		for (int i=0; i<plugins2.length; i++) {
+			plugins2[i] = plugins[i];
+			slashPos = plugins2[i].lastIndexOf('/');
+			if (slashPos>=0)
+				plugins2[i] = plugins[i].substring(slashPos+1,plugins2[i].length());
+		}
+		return plugins2;
+	}
+	
+	void setupPluginsAndMacrosPaths() {
+		ImageJPath = pluginsPath = macrosPath = null;
+		String currentDir = Prefs.getHomeDir(); // "user.dir"
+		if (currentDir==null)
+			return;
+		if (currentDir.endsWith("plugins"))
+			ImageJPath = pluginsPath = currentDir+File.separator;
+		else {
+			String pluginsDir = System.getProperty("plugins.dir");
+			if (pluginsDir!=null) {
+				if (pluginsDir.endsWith("/")||pluginsDir.endsWith("\\"))
+					pluginsDir = pluginsDir.substring(0, pluginsDir.length()-1);
+				if (pluginsDir.endsWith("/plugins")||pluginsDir.endsWith("\\plugins"))
+					pluginsDir = pluginsDir.substring(0, pluginsDir.length()-8);
+			}
+			if (pluginsDir==null)
+				pluginsDir = currentDir;
+			else if (pluginsDir.equals("user.home")) {
+				pluginsDir = System.getProperty("user.home");
+				if (!(new File(pluginsDir+File.separator+"plugins")).isDirectory()) 
+					pluginsDir = pluginsDir + File.separator + "ImageJ";
+				// needed to run plugins when ImageJ launched using Java WebStart
+				if (applet==null)
+					System.setSecurityManager(null);
+				jnlp = true;
+			}
+			pluginsPath = pluginsDir+File.separator+"plugins"+File.separator;
+			macrosPath = pluginsDir+File.separator+"macros"+File.separator;
+			ImageJPath = pluginsDir+File.separator;
+		}
+		File f = pluginsPath!=null?new File(pluginsPath):null;
+		if (f==null || !f.isDirectory()) {
+			ImageJPath = currentDir+File.separator;
+			pluginsPath = ImageJPath+"plugins"+File.separator;
+			f = new File(pluginsPath);
+			if (!f.isDirectory()) {
+				String altPluginsPath = System.getProperty("plugins.dir");
+				if (altPluginsPath!=null) {
+					f = new File(altPluginsPath);
+					if (!f.isDirectory())
+						altPluginsPath = null;
+					else {
+						ImageJPath = f.getParent() + File.separator;
+						pluginsPath = ImageJPath + f.getName() + File.separator;
+						macrosPath = ImageJPath+"macros"+File.separator;
+					}
+				}
+				if (altPluginsPath==null)
+					ImageJPath = pluginsPath = null;
+			}
+		}
+		f = macrosPath!=null?new File(macrosPath):null;
+		if (f!=null && !f.isDirectory()) {
+			macrosPath = currentDir+File.separator+"macros"+File.separator;
+			f = new File(macrosPath);
+			if (!f.isDirectory())
+				macrosPath = null;
+		}
+		if (IJ.debugMode) {
+			IJ.log("Menus.setupPluginsAndMacrosPaths");
+			IJ.log("   user.dir: "+currentDir);
+			IJ.log("   plugins.dir: "+System.getProperty("plugins.dir"));
+			IJ.log("   ImageJPath: "+ImageJPath);
+			IJ.log("   pluginsPath: "+pluginsPath);
+		}
+	}
+		
+	/** Returns a list of the plugins in the plugins menu. */
+	public static synchronized String[] getPlugins() {
+		File f = pluginsPath!=null?new File(pluginsPath):null;
+		if (f==null || (f!=null && !f.isDirectory()))
+			return null;
+		String[] list = f.list();
+		if (list==null)
+			return null;
+		Vector v = new Vector();
+		jarFiles = null;
+		macroFiles = null;
+		for (int i=0; i<list.length; i++) {
+			String name = list[i];
+			boolean isClassFile = name.endsWith(".class");
+			boolean hasUnderscore = name.indexOf('_')>=0;
+			if (hasUnderscore && isClassFile && name.indexOf('$')<0 ) {
+				name = name.substring(0, name.length()-6); // remove ".class"
+				v.addElement(name);
+			} else if (hasUnderscore && (name.endsWith(".jar") || name.endsWith(".zip"))) {
+				if (jarFiles==null) jarFiles = new Vector();
+				jarFiles.addElement(pluginsPath + name);
+			} else if (validMacroName(name,hasUnderscore)) {
+				if (macroFiles==null) macroFiles = new Vector();
+				macroFiles.addElement(name);
+			} else {
+				if (!isClassFile)
+					checkSubdirectory(pluginsPath, name, v);
+			}
+		}
+		list = new String[v.size()];
+		v.copyInto((String[])list);
+		StringSorter.sort(list);
+		return list;
+	}
+	
+	/** Looks for plugins and jar files in a subdirectory of the plugins directory. */
+	private static void checkSubdirectory(String path, String dir, Vector v) {
+		if (dir.endsWith(".java"))
+			return;
+		File f = new File(path, dir);
+		if (!f.isDirectory())
+			return;
+		String[] list = f.list();
+		if (list==null)
+			return;
+		dir += "/";
+		int classCount=0, otherCount=0;
+		String className = null;
+		for (int i=0; i<list.length; i++) {
+			String name = list[i];
+			boolean hasUnderscore = name.indexOf('_')>=0;
+			if (hasUnderscore && name.endsWith(".class") && name.indexOf('$')<0) {
+				name = name.substring(0, name.length()-6); // remove ".class"
+				v.addElement(dir+name);
+				classCount++;
+				className = name;
+			} else if (hasUnderscore && (name.endsWith(".jar") || name.endsWith(".zip"))) {
+				if (jarFiles==null) jarFiles = new Vector();
+				jarFiles.addElement(f.getPath() + File.separator + name);
+				otherCount++;
+			} else if (validMacroName(name,hasUnderscore)) {
+				if (macroFiles==null) macroFiles = new Vector();
+				macroFiles.addElement(dir + name);
+				otherCount++;
+			} else {
+				File f2 = new File(f, name);
+				if (f2.isDirectory()) installSubdirectorMacros(f2, dir+name);
+			}
+		}
+		if (Prefs.moveToMisc && classCount==1 && otherCount==0 && dir.indexOf("_")==-1)
+			v.setElementAt("Miscellaneous/" + className,
+				v.size() - 1);
+	}
+	
+	/** Installs macros and scripts located in subdirectories. */
+	private static void installSubdirectorMacros(File f2, String dir) {
+		if (dir.endsWith("Launchers")) return;
+		String[] list = f2.list();
+		if (list==null) return;
+		for (int i=0; i<list.length; i++) {
+			String name = list[i];
+			boolean hasUnderscore = name.indexOf('_')>=0;
+			if (validMacroName(name,hasUnderscore)) {
+				if (macroFiles==null) macroFiles = new Vector();
+				macroFiles.addElement(dir+"/"+name);
+			}
+		}
+	}
+	
+	private static boolean validMacroName(String name, boolean hasUnderscore) {
+		return (hasUnderscore&&name.endsWith(".txt")) || name.endsWith(".ijm")
+			|| name.endsWith(".js") || name.endsWith(".bsh") || name.endsWith(".py");
+	}
+	
+	/** Installs a plugin in the Plugins menu using the class name,
+		with underscores replaced by spaces, as the command. */
+	void installUserPlugin(String className) {
+		installUserPlugin(className, false);
+	}
+
+	public void installUserPlugin(String className, boolean force) {
+		int slashIndex = className.indexOf('/');
+		String menuName = slashIndex < 0 ? "Plugins" : "Plugins>" +
+			className.substring(0, slashIndex).replace('/', '>');
+		Menu menu = getMenu(menuName);
+		String command = className;
+		if (slashIndex>0) {
+			command = className.substring(slashIndex+1);
+		}
+		command = command.replace('_',' ');
+		command.trim();
+		boolean itemExists = (pluginsTable.get(command)!=null);
+		if(force && itemExists)
+			return;
+
+		if (!force && itemExists)  // duplicate command?
+			command = command + " Plugin";
+		MenuItem item = new MenuItem(command);
+		if(force)
+			addItemSorted(menu,item,0);
+		else
+			addOrdered(menu, item);
+		item.addActionListener(ij);
+		pluginsTable.put(command, className.replace('/', '.'));
+		nPlugins++;
+	}
+	
+	void installPopupMenu(ImageJ ij) {
+		String s;
+		int count = 0;
+		MenuItem mi;
+		popup = new PopupMenu("");
+		if (fontSize!=0 || scale>1.0)
+			popup.setFont(getFont());
+		while (true) {
+			count++;
+			s = Prefs.getString("popup" + (count/10)%10 + count%10);
+			if (s==null)
+				break;
+			if (s.equals("-"))
+				popup.addSeparator();
+			else if (!s.equals("")) {
+				mi = new MenuItem(s);
+				mi.addActionListener(ij);
+				popup.add(mi);
+			}
+		}
+	}
+
+	public static MenuBar getMenuBar() {
+		return mbar;
+	}
+		
+	public static Menu getMacrosMenu() {
+		return macrosMenu;
+	}
+
+	public static Menu getOpenRecentMenu() {
+		return openRecentMenu;
+	}
+
+	public int getMacroCount() {
+		return nMacros;
+	}
+
+	public int getPluginCount() {
+		return nPlugins;
+	}
+		
+	static final int RGB_STACK=10, HSB_STACK=11, LAB_STACK=12, HSB32_STACK=13;
+	
+	/** Updates the Image/Type and Window menus. */
+	public static void updateMenus() {
+		if (ij==null) return;
+		gray8Item.setState(false);
+		gray16Item.setState(false);
+		gray32Item.setState(false);
+		color256Item.setState(false);
+		colorRGBItem.setState(false);
+		RGBStackItem.setState(false);
+		HSBStackItem.setState(false);
+		LabStackItem.setState(false);
+		HSB32Item.setState(false);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			return;
+    	int type = imp.getType();
+     	if (imp.getStackSize()>1) {
+    		ImageStack stack = imp.getStack();
+    		if (stack.isRGB())
+    			type = RGB_STACK;
+    		else if (stack.isHSB())
+    			type = HSB_STACK;
+    		else if (stack.isLab())
+    			type = LAB_STACK;
+    		else if (stack.isHSB32())
+    			type = HSB32_STACK;
+    	}
+    	switch (type) {
+    		case ImagePlus.GRAY8:
+				gray8Item.setState(true);
+				break;
+     		case ImagePlus.GRAY16:
+				gray16Item.setState(true);
+				break;
+     		case ImagePlus.GRAY32:
+				gray32Item.setState(true);
+				break;
+   			case ImagePlus.COLOR_256:
+				color256Item.setState(true);
+				break;
+    		case ImagePlus.COLOR_RGB:
+				colorRGBItem.setState(true);
+				break;
+    		case RGB_STACK:
+				RGBStackItem.setState(true);
+				break;
+    		case HSB_STACK:
+				HSBStackItem.setState(true);
+				break;
+    		case LAB_STACK:
+				LabStackItem.setState(true);
+				break;
+    		case HSB32_STACK:
+				HSB32Item.setState(true);
+				break;
+		}
+		
+    	//update Window menu
+    	int nItems = window.getItemCount();
+    	int start = WINDOW_MENU_ITEMS + windowMenuItems2;
+    	int index = start + WindowManager.getCurrentIndex();
+    	try {  // workaround for Linux/Java 5.0/bug
+			for (int i=start; i<nItems; i++) {
+				CheckboxMenuItem item = (CheckboxMenuItem)window.getItem(i);
+				item.setState(i==index);
+			}
+		} catch (Exception e) {}
+	}
+	
+	static boolean isColorLut(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+    	IndexColorModel cm = (IndexColorModel)ip.getColorModel();
+    	if (cm==null) return false;
+		int mapSize = cm.getMapSize();
+		byte[] reds = new byte[mapSize];
+		byte[] greens = new byte[mapSize];
+		byte[] blues = new byte[mapSize];	
+		cm.getReds(reds); 
+		cm.getGreens(greens); 
+		cm.getBlues(blues);
+		boolean isColor = false;
+		for (int i=0; i<mapSize; i++) {
+			if ((reds[i] != greens[i]) || (greens[i] != blues[i])) {
+				isColor = true;
+				break;
+			}
+		}
+		return isColor;
+	}
+
+	
+	/** Use Prefs.getImageJDir() to get the path to the ImageJ directory. */
+	static String getImageJPath() {
+		return ImageJPath;
+	}
+
+	/** Returns the path to the user plugins directory or
+		null if the plugins directory was not found. */
+	public static String getPlugInsPath() {
+		return pluginsPath;
+	}
+
+	/** Returns the path to the macros directory or
+		null if the macros directory was not found. */
+	public static String getMacrosPath() {
+		return macrosPath;
+	}
+        
+	/** Returns the hashtable that associates commands with plugins. */
+	public static Hashtable getCommands() {
+		if (pluginsTable==null)
+			IJ.init();
+		return pluginsTable;
+	}
+        
+	/** Returns the hashtable that associates shortcuts with commands. The keys
+		in the hashtable are Integer keycodes, or keycode+200 for uppercase. */
+	public static Hashtable getShortcuts() {
+		return shortcuts;
+	}
+        
+	/** Returns the hashtable that associates keyboard shortcuts with macros. The keys
+		in the hashtable are Integer keycodes, or keycode+200 for uppercase. */
+	public static Hashtable getMacroShortcuts() {
+		if (macroShortcuts==null)
+			macroShortcuts = new Hashtable();
+		return macroShortcuts;
+	}
+        
+	/** Inserts one item (a non-image window) into the Window menu. */
+	static synchronized void insertWindowMenuItem(Window win) {
+		if (ij==null || win==null)
+			return;
+		String title = win instanceof Frame?((Frame)win).getTitle():((Dialog)win).getTitle();
+		CheckboxMenuItem item = new CheckboxMenuItem(title);
+		item.addItemListener(ij);
+		int index = WINDOW_MENU_ITEMS+windowMenuItems2;
+		if (windowMenuItems2>=2)
+			index--;
+		window.insert(item, index);
+		windowMenuItems2++;
+		if (windowMenuItems2==1) {
+			window.insertSeparator(WINDOW_MENU_ITEMS+windowMenuItems2);
+			windowMenuItems2++;
+		}
+	}
+
+	/** Adds one image to the end of the Window menu. */
+	static synchronized void addWindowMenuItem(ImagePlus imp) {
+		if (ij==null)
+			return;
+		String name = imp.getTitle();
+		String size = ImageWindow.getImageSize(imp);
+		CheckboxMenuItem item = new CheckboxMenuItem(name+" "+size);
+		item.setActionCommand("" + imp.getID());
+		window.add(item);
+		item.addItemListener(ij);
+	}
+	
+	/** Removes the specified item from the Window menu. */
+	static synchronized void removeWindowMenuItem(int index) {
+		//IJ.log("removeWindowMenuItem: "+index+" "+windowMenuItems2+" "+window.getItemCount());
+		if (ij==null)
+			return;
+		try {
+			if (index>=0 && index<window.getItemCount()) {
+				window.remove(WINDOW_MENU_ITEMS+index);
+				if (index<windowMenuItems2) {
+					windowMenuItems2--;
+					if (windowMenuItems2==1) {
+						window.remove(WINDOW_MENU_ITEMS);
+						windowMenuItems2 = 0;
+					}
+				}
+			}
+		} catch (Exception e) {}
+	}
+
+	/** Changes the name of an item in the Window menu. */
+	public static synchronized void updateWindowMenuItem(String oldLabel, String newLabel) {
+		updateWindowMenuItem(null, oldLabel, newLabel);
+	}
+
+	/** Changes the name of an item in the Window menu. */
+	public static synchronized void updateWindowMenuItem(ImagePlus imp, String oldLabel, String newLabel) {
+		if (oldLabel==null || newLabel==null)
+			return;
+		int first = WINDOW_MENU_ITEMS;
+		int count = window.getItemCount();
+		try {  // workaround for Linux/Java 5.0/bug
+			for (int i=first; i<count; i++) {
+				MenuItem item = window.getItem(i);
+				String label = item.getLabel();
+				String cmd = item.getActionCommand();
+				if (imp!=null) {  //remove size (e.g. " 24MB")
+					int index = label.lastIndexOf(" ");
+					if (index>-1)
+						label = label.substring(0, index);
+				}
+				if (item!=null && label.equals(oldLabel) && (imp==null||(""+imp.getID()).equals(cmd))) {
+					String size = "";
+					if (imp!=null)
+						size =  " " + ImageWindow.getImageSize(imp);
+					item.setLabel(newLabel+size);
+					return;
+				}
+			}
+		} catch (Exception e) {}
+	}
+	
+	/** Adds a file path to the beginning of the File/Open Recent submenu. */
+	public static synchronized void addOpenRecentItem(String path) {
+		if (ij==null) return;
+		int count = openRecentMenu.getItemCount();
+		for (int i=0; i<count; ) {
+			if (openRecentMenu.getItem(i).getLabel().equals(path)) {
+				openRecentMenu.remove(i);
+				count--;
+			} else
+				i++;
+		}
+		if (count==MAX_OPEN_RECENT_ITEMS)
+			openRecentMenu.remove(MAX_OPEN_RECENT_ITEMS-1);
+		MenuItem item = new MenuItem(path);
+		openRecentMenu.insert(item, 0);
+		item.addActionListener(ij);
+	}
+
+	public static PopupMenu getPopupMenu() {
+		return popup;
+	}
+	
+	public static Menu getSaveAsMenu() {
+		return saveAsMenu;
+	}
+
+	/** Adds a plugin based command to the end of a specified menu.
+	* @param plugin			the plugin (e.g. "Inverter_", "Inverter_("arg")")
+	* @param menuCode		PLUGINS_MENU, IMPORT_MENU, SAVE_AS_MENU or HOT_KEYS
+	* @param command		the menu item label (set to "" to uninstall)
+	* @param shortcut		the keyboard shortcut (e.g. "y", "Y", "F1")
+	* @param ij				ImageJ (the action listener)
+	*
+	* @return				returns an error code(NORMAL_RETURN,COMMAND_IN_USE_ERROR, etc.)
+	*/
+	public static int installPlugin(String plugin, char menuCode, String command, String shortcut, ImageJ ij) {
+		if (command.equals("")) //uninstall
+			return NORMAL_RETURN;
+		if (commandInUse(command))
+			return COMMAND_IN_USE;
+		if (!validShortcut(shortcut))
+			return INVALID_SHORTCUT;
+		if (shortcutInUse(shortcut))
+			return SHORTCUT_IN_USE;
+			
+		Menu menu;
+		switch (menuCode) {
+			case PLUGINS_MENU: menu = pluginsMenu; break;
+			case IMPORT_MENU: menu = getMenu("File>Import"); break;
+			case SAVE_AS_MENU: menu = getMenu("File>Save As"); break;
+			case SHORTCUTS_MENU: menu = shortcutsMenu; break;
+			case ABOUT_MENU: menu = getMenu("Help>About Plugins"); break;
+			case FILTERS_MENU: menu = getMenu("Process>Filters"); break;
+			case TOOLS_MENU: menu = getMenu("Analyze>Tools"); break;
+			case UTILITIES_MENU: menu = utilitiesMenu; break;
+			default: return 0;
+		}
+		int code = convertShortcutToCode(shortcut);
+		MenuItem item;
+		boolean functionKey = code>=KeyEvent.VK_F1 && code<=KeyEvent.VK_F12;
+		if (code==0)
+			item = new MenuItem(command);
+		else if (functionKey) {
+			command += " [F"+(code-KeyEvent.VK_F1+1)+"]";
+			shortcuts.put(new Integer(code),command);
+			item = new MenuItem(command);
+		} else {
+			shortcuts.put(new Integer(code),command);
+			int keyCode = code;
+			boolean shift = false;
+			if (keyCode>=265 && keyCode<=290) {
+				keyCode -= 200;
+				shift = true;
+			}
+			item = new MenuItem(command, new MenuShortcut(keyCode, shift));
+		}
+		menu.add(item);
+		item.addActionListener(ij);
+		pluginsTable.put(command, plugin);
+		shortcut = code>0 && !functionKey?"["+shortcut+"]":"";
+		pluginsPrefs.addElement(menuCode+",\""+command+shortcut+"\","+plugin);
+		return NORMAL_RETURN;
+	}
+	
+	/** Deletes a command installed by Plugins/Shortcuts/Add Shortcut. */
+	public static int uninstallPlugin(String command) {
+		boolean found = false;
+		for (Enumeration en=pluginsPrefs.elements(); en.hasMoreElements();) {
+			String cmd = (String)en.nextElement();
+			if (cmd.contains(command)) {
+				boolean ok = pluginsPrefs.removeElement((Object)cmd);
+				found = true;
+				break;
+			}
+		}
+		if (found)
+			return NORMAL_RETURN;
+		else
+			return COMMAND_NOT_FOUND;
+
+	}
+	
+	public static boolean commandInUse(String command) {
+		if (pluginsTable.get(command)!=null)
+			return true;
+		else
+			return false;
+	}
+
+	public static int convertShortcutToCode(String shortcut) {
+		int code = 0;
+		int len = shortcut.length();
+		if (len==2 && shortcut.charAt(0)=='F') {
+			code = KeyEvent.VK_F1+(int)shortcut.charAt(1)-49;
+			if (code>=KeyEvent.VK_F1 && code<=KeyEvent.VK_F9)
+				return code;
+			else
+				return 0;
+		}
+		if (len==3 && shortcut.charAt(0)=='F') {
+			code = KeyEvent.VK_F10+(int)shortcut.charAt(2)-48;
+			if (code>=KeyEvent.VK_F10 && code<=KeyEvent.VK_F12)
+				return code;
+			else
+				return 0;
+		}
+		if (len==2 && shortcut.charAt(0)=='N') { // numeric keypad
+			code = KeyEvent.VK_NUMPAD0+(int)shortcut.charAt(1)-48;
+			if (code>=KeyEvent.VK_NUMPAD0 && code<=KeyEvent.VK_NUMPAD9)
+				return code;
+			switch (shortcut.charAt(1)) {
+				case '/': return KeyEvent.VK_DIVIDE;
+				case '*': return KeyEvent.VK_MULTIPLY;
+				case '-': return KeyEvent.VK_SUBTRACT;
+				case '+': return KeyEvent.VK_ADD;
+				case '.': return KeyEvent.VK_DECIMAL;
+				default: return 0;
+			}
+		}
+		if (len!=1)
+			return 0;
+		int c = (int)shortcut.charAt(0);
+		if (c>=65&&c<=90) //A-Z
+			code = KeyEvent.VK_A+c-65 + 200;
+		else if (c>=97&&c<=122) //a-z
+			code = KeyEvent.VK_A+c-97;
+		else if (c>=48&&c<=57) //0-9
+			code = KeyEvent.VK_0+c-48;
+		return code;
+	}
+	
+	void installStartupMacroSet() {
+		if (macrosPath==null) {
+			MacroInstaller.installFromJar("/macros/StartupMacros.txt");
+			return;
+		}
+		String path = macrosPath + "StartupMacros.txt";
+		File f = new File(path);
+		if (!f.exists()) {
+			path = macrosPath + "StartupMacros.ijm";
+			f = new File(path);
+			if (!f.exists()) {
+				(new MacroInstaller()).installFromIJJar("/macros/StartupMacros.txt");
+				return;
+			}
+		} else {
+			if ("StartupMacros.fiji.ijm".equals(f.getName()))
+				path = f.getPath();
+		}
+		String libraryPath = macrosPath + "Library.txt";
+		f = new File(libraryPath);
+		boolean isLibrary = f.exists();
+		try {
+			MacroInstaller mi = new MacroInstaller();
+			if (isLibrary) mi.installLibrary(libraryPath);
+			mi.installStartupMacros(path);
+			nMacros += mi.getMacroCount();
+		} catch (Exception e) {}
+	}
+	
+	static boolean validShortcut(String shortcut) {
+		int len = shortcut.length();
+		if (shortcut.equals(""))
+			return true;
+		else if (len==1)
+			return true;
+		else if (shortcut.startsWith("F") && (len==2 || len==3))
+			return true;
+		else
+			return false;
+	}
+
+	/** Returns 'true' if this keyboard shortcut is in use. */
+	public static boolean shortcutInUse(String shortcut) {
+		int code = convertShortcutToCode(shortcut);
+		if (shortcuts.get(new Integer(code))!=null)
+			return true;
+		else
+			return false;
+	}
+	
+	/** Set the size (in points) used for the fonts in ImageJ menus. 
+		Set the size to 0 to use the Java default size. */
+	public static void setFontSize(int size) {
+		if (size<9 && size!=0) size = 9;
+		if (size>24) size = 24;
+		fontSize = size;
+	}
+	
+	/** Returns the size (in points) used for the fonts in ImageJ menus. Returns
+		0 if the default font size is being used or if this is a Macintosh. */
+	public static int getFontSize() {
+		return fontSize;
+		//return IJ.isMacintosh()?0:fontSize;
+	}
+	
+	public static Font getFont() {
+		if (menuFont==null) {
+			int size = fontSize==0?13:fontSize;
+			size = (int)Math.round(size*scale);
+			if (IJ.isWindows() && scale>1.0 && size>17)
+				size = 17;  // Java resets size to 12 if you try to set it to 18 or greater
+			menuFont =  new Font("SanSerif", Font.PLAIN, size);
+		}
+		//System.out.println("Menus.getFont: "+scale+" "+fontSize+" "+menuFont);
+		return menuFont;
+	}
+
+	/** Called once when ImageJ quits. */
+	public static void savePreferences(Properties prefs) {
+		if (pluginsPrefs==null)
+			return;
+		int index = 0;
+		for (Enumeration en=pluginsPrefs.elements(); en.hasMoreElements();) {
+			String key = "plugin" + (index/10)%10 + index%10;
+			String value = (String)en.nextElement();
+			prefs.put(key, value);
+			index++;
+		}
+		int n = openRecentMenu.getItemCount();
+		for (int i=0; i<n; i++) {
+			String key = ""+i;
+			if (key.length()==1) key = "0"+key;
+			key = "recent"+key;
+			prefs.put(key, openRecentMenu.getItem(i).getLabel());
+		}
+		prefs.put(Prefs.MENU_SIZE, Integer.toString(fontSize));
+	}
+	
+	public static void updateImageJMenus() {
+		jarFiles = macroFiles = null;
+		Menus m = new Menus(IJ.getInstance(), IJ.getApplet());
+		String err = m.addMenuBar();
+		if (err!=null) IJ.error(err);
+		m.installStartupMacroSet();
+		IJ.resetClassLoader();
+		IJ.runPlugIn("ij.plugin.ClassChecker", "");
+		IJ.showStatus("Menus updated: "+m.nPlugins + " commands, " + m.nMacros + " macros");
+	}
+	
+	public static void updateFont() {
+		scale = (int)Math.round(Prefs.getGuiScale());
+		Font font = getFont();
+		mbar.setFont(font);
+		if (ij!=null)
+			ij.setMenuBar(mbar);
+		popup.setFont(font);
+	}
+	
+	/** Adds a command to the ImageJ menu bar. */
+	public static void add(String menuPath, String plugin) {
+		if (pluginsTable==null)
+			return;
+		int index = menuPath.lastIndexOf(">");
+		if (index==-1 || index==menuPath.length()-1)
+			return;
+		String label = menuPath.substring(index+1, menuPath.length());
+		menuPath = menuPath.substring(0, index);
+		pluginsTable.put(label, plugin);
+		addItem(getMenu(menuPath), label, 0, false);
+	}
+	
+}
diff --git a/src/ij/OtherInstance.java b/src/ij/OtherInstance.java
new file mode 100644
index 0000000..17ba5ab
--- /dev/null
+++ b/src/ij/OtherInstance.java
@@ -0,0 +1,241 @@
+package ij;
+
+import ij.IJ;
+import ij.ImageJ;
+import ij.Prefs;
+
+import ij.io.OpenDialog;
+import ij.io.Opener;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+import java.lang.reflect.Method;
+
+import java.rmi.Remote;
+import java.rmi.RemoteException;
+import java.rmi.server.UnicastRemoteObject;
+
+import java.util.Properties;
+
+/*
+ * This class tries to contact another instance on the same machine, started
+ * by the current user.  If such an instance is found, the arguments are
+ * sent to that instance.  If no such an instance is found, listen for clients.
+ *
+ * No need for extra security, as the stub (and its serialization) contain
+ * a hard-to-guess hash code.
+ *
+ *	@author Johannes Schindelin
+ */
+public class OtherInstance {
+	private static final String DELIMETER = "~!~"; // Separates macro name and argument
+
+	interface ImageJInstance extends Remote {
+		void sendArgument(String arg) throws RemoteException;
+	}
+
+	static class Implementation implements ImageJInstance {
+		int counter = 0;
+
+		public void sendArgument(String cmd) {
+			if (IJ.debugMode) IJ.log("SocketServer.sendArgument: \""+ cmd+"\"");
+			if (cmd.startsWith("open "))
+				(new Opener()).openAndAddToRecent(cmd.substring(5));
+			else if (cmd.startsWith("macro ")) {
+				String name = cmd.substring(6);
+				String name2 = name;
+				String arg = null;
+				int index = name2.indexOf(DELIMETER);
+				if (index!=-1) {
+					name = name2.substring(0, index);
+					arg = name2.substring(index+DELIMETER.length(), name2.length());
+				}
+				IJ.runMacroFile(name, arg);
+			} else if (cmd.startsWith("run "))
+				IJ.run(cmd.substring(4));
+			else if (cmd.startsWith("eval ")) {
+				String rtn = IJ.runMacro(cmd.substring(5));
+				if (rtn!=null)
+					System.out.print(rtn);
+			} else if (cmd.startsWith("user.dir "))
+				OpenDialog.setDefaultDirectory(cmd.substring(9));
+		}
+	}
+
+	public static String getStubPath() {
+		String display = System.getenv("DISPLAY");
+		if (display!=null) {
+			display = display.replace(':', '_');
+			display = display.replace('/', '_');
+		}
+		String tmpDir = System.getProperty("java.io.tmpdir");
+		tmpDir = IJ.addSeparator(tmpDir);
+		return tmpDir + "ImageJ-"
+			+ System.getProperty("user.name") + "-"
+			+ (display == null ? "" : display + "-")
+			+ ImageJ.getPort() + ".stub";
+	}
+
+	public static void makeFilePrivate(String path) {
+		try {
+			File file = new File(path);
+			file.deleteOnExit();
+
+			// File.setReadable() is Java 6
+			Class[] types = { boolean.class, boolean.class };
+			Method m = File.class.getMethod("setReadable", types);
+			Object[] arguments = { Boolean.FALSE, Boolean.FALSE };
+			m.invoke(file, arguments);
+			arguments = new Object[] { Boolean.TRUE, Boolean.TRUE };
+			m.invoke(file, arguments);
+			types = new Class[] { boolean.class };
+			m = File.class.getMethod("setWritable", types);
+			arguments = new Object[] { Boolean.FALSE };
+			m.invoke(file, arguments);
+			return;
+		} catch (Exception e) {
+			if (IJ.debugMode)
+				System.err.println("Java < 6 detected,"
+					+ " trying chmod 0600 " + path);
+		}
+		if (!IJ.isWindows()) {
+			try {
+				String[] command = {
+					"chmod", "0600", path
+				};
+				Runtime.getRuntime().exec(command);
+			} catch (Exception e) {
+				if (IJ.debugMode)
+					System.err.println("Even chmod failed.");
+			}
+		}
+	}
+
+	public static boolean sendArguments(String[] args) {
+		if (!isRMIEnabled())
+			return false;
+		String file = getStubPath();
+		try {
+			FileInputStream in = new FileInputStream(file);
+			ImageJInstance instance = (ImageJInstance) new ObjectInputStream(in).readObject();
+			in.close();
+			if (instance==null)
+				return false;
+			instance.sendArgument("user.dir "+System.getProperty("user.dir"));
+			int macros = 0;
+			for (int i=0; i<args.length; i++) {
+				String arg = args[i];
+				if (arg==null)
+					continue;
+				String cmd = null;
+				if (macros==0 && arg.endsWith(".ijm")) {
+					cmd = "macro " + arg;
+					macros++;
+				} else if (arg.startsWith("-macro") && i+1<args.length) {
+					String macroArg = i+2<args.length?DELIMETER+args[i+2]:"";
+					cmd = "macro " + args[i+1] + macroArg;
+					instance.sendArgument(cmd);
+					break;
+				} else if (arg.startsWith("-eval") && i+1<args.length) {
+					cmd = "eval " + args[i+1];
+					args[i+1] = null;
+				} else if (arg.startsWith("-run") && i+1<args.length) {
+					cmd = "run " + args[i+1];
+					args[i+1] = null;
+				} else if (arg.indexOf("ij.ImageJ")==-1 && !arg.startsWith("-"))
+					cmd = "open " + arg;
+				if (cmd!=null)
+					instance.sendArgument(cmd);
+			} // for
+			return true;
+		} catch (Exception e) {
+			if (IJ.debugMode) {
+				System.err.println("Client exception: " + e);
+				e.printStackTrace();
+			}
+			new File(file).delete();
+		}
+		if (!new File(file).exists())
+			startServer();
+		//IJ.log("sendArguments: return false ");
+		return false;
+	}
+
+	static ImageJInstance stub;
+	static Implementation implementation;
+
+	public static void startServer() {
+		if (IJ.debugMode)
+			System.err.println("OtherInstance: starting server");
+		try {
+			implementation = new Implementation();
+			stub = (ImageJInstance)UnicastRemoteObject.exportObject(implementation, 0);
+
+			// Write serialized object
+			String path = getStubPath();
+			FileOutputStream out = new FileOutputStream(path);
+			makeFilePrivate(path);
+			new ObjectOutputStream(out).writeObject(stub);
+			out.close();
+
+			if (IJ.debugMode)
+				System.err.println("OtherInstance: server ready");
+		} catch (Exception e) {
+			if (IJ.debugMode) {
+				System.err.println("Server exception: " + e);
+				e.printStackTrace();
+			}
+		}
+	}
+
+	private static final String OPTIONS = "prefs.options";
+	private static final int RUN_SOCKET_LISTENER=1<<22;
+
+	public static boolean isRMIEnabled() {
+		if (System.getProperty("os.name").startsWith("Mac"))
+			return true;
+		Properties ijProps = loadPrefs();
+		if (ijProps==null)
+			return true;
+		int options = getInt(ijProps, OPTIONS);
+		if (options==-1)
+			return true;
+		return (options&RUN_SOCKET_LISTENER)!=0;
+	}
+	
+	protected static int getInt(Properties props, String key) {
+		String s = props.getProperty(key);
+		if (s!=null) {
+			try {
+				return Integer.decode(s).intValue();
+			} catch (NumberFormatException e) {IJ.log(""+e);}
+		}
+		return -1;
+	}
+
+	protected static Properties loadPrefs() {
+		Properties result = new Properties();
+		File file = new File(getPrefsDirectory(), "IJ_Prefs.txt");
+		try {
+			InputStream in = new BufferedInputStream(new FileInputStream(file));
+			result.load(in);
+			in.close();
+		} catch (IOException e) { /* ignore */ }
+		return result;
+	}
+
+	protected static String getPrefsDirectory() {
+		String env = System.getenv("IJ_PREFS_DIR");
+		if (env != null)
+			return env;
+		else
+			return Prefs.getPrefsDir();
+	}
+}
diff --git a/src/ij/Prefs.java b/src/ij/Prefs.java
new file mode 100644
index 0000000..b8b9938
--- /dev/null
+++ b/src/ij/Prefs.java
@@ -0,0 +1,776 @@
+package ij;
+import ij.util.Java2;
+import java.io.*;
+import java.util.*;
+import java.applet.*;
+import java.net.URL;
+import java.awt.*;
+import java.applet.Applet;
+import ij.io.*;
+import ij.util.Tools;
+import ij.gui.*;
+import ij.plugin.filter.*;
+import ij.process.ImageConverter;
+import ij.plugin.Animator;
+import ij.process.FloatBlitter;
+import ij.plugin.GelAnalyzer;
+import ij.process.ColorProcessor;
+import ij.text.TextWindow;
+
+/**
+This class contains the ImageJ preferences, which are 
+loaded from the "IJ_Props.txt" and "IJ_Prefs.txt" files.
+@see ij.ImageJ
+*/
+public class Prefs {
+
+	public static final String PROPS_NAME = "IJ_Props.txt";
+	public static final String PREFS_NAME = "IJ_Prefs.txt";
+	public static final String DIR_IMAGE = "dir.image";
+	public static final String FCOLOR = "fcolor";
+	public static final String BCOLOR = "bcolor";
+	public static final String ROICOLOR = "roicolor";
+	public static final String SHOW_ALL_COLOR = "showcolor";
+	public static final String JPEG = "jpeg";
+	public static final String FPS = "fps";
+    public static final String DIV_BY_ZERO_VALUE = "div-by-zero";
+    public static final String NOISE_SD = "noise.sd";
+    public static final String MENU_SIZE = "menu.size";
+    public static final String GUI_SCALE = "gui.scale";
+    public static final String THREADS = "threads";
+	public static final String KEY_PREFIX = ".";
+ 
+	private static final int USE_POINTER=1<<0, ANTIALIASING=1<<1, INTERPOLATE=1<<2, ONE_HUNDRED_PERCENT=1<<3,
+		BLACK_BACKGROUND=1<<4, JFILE_CHOOSER=1<<5, UNUSED=1<<6, BLACK_CANVAS=1<<7, WEIGHTED=1<<8, 
+		AUTO_MEASURE=1<<9, REQUIRE_CONTROL=1<<10, USE_INVERTING_LUT=1<<11, ANTIALIASED_TOOLS=1<<12,
+		INTEL_BYTE_ORDER=1<<13, DOUBLE_BUFFER=1<<14, NO_POINT_LABELS=1<<15, NO_BORDER=1<<16,
+		SHOW_ALL_SLICE_ONLY=1<<17, COPY_HEADERS=1<<18, NO_ROW_NUMBERS=1<<19,
+		MOVE_TO_MISC=1<<20, ADD_TO_MANAGER=1<<21, RUN_SOCKET_LISTENER=1<<22,
+		MULTI_POINT_MODE=1<<23, ROTATE_YZ=1<<24, FLIP_XZ=1<<25,
+		DONT_SAVE_HEADERS=1<<26, DONT_SAVE_ROW_NUMBERS=1<<27, NO_CLICK_TO_GC=1<<28,
+		AVOID_RESLICE_INTERPOLATION=1<<29, KEEP_UNDO_BUFFERS=1<<30; 
+    public static final String OPTIONS = "prefs.options";
+    
+	public static final String vistaHint = "";  // no longer used
+
+	private static final int USE_SYSTEM_PROXIES=1<<0, USE_FILE_CHOOSER=1<<1,
+		SUBPIXEL_RESOLUTION=1<<2, ENHANCED_LINE_TOOL=1<<3, SKIP_RAW_DIALOG=1<<4,
+		REVERSE_NEXT_PREVIOUS_ORDER=1<<5, AUTO_RUN_EXAMPLES=1<<6, SHOW_ALL_POINTS=1<<7,
+		DO_NOT_SAVE_WINDOW_LOCS=1<<8, JFILE_CHOOSER_CHANGED=1<<9,
+		CANCEL_BUTTON_ON_RIGHT=1<<10, IGNORE_RESCALE_SLOPE=1<<11,
+		NON_BLOCKING_DIALOGS=1<<12, FIXED_DICOM_SCALINGg=1<<13;
+	public static final String OPTIONS2 = "prefs.options2";
+    
+	/** file.separator system property */
+	public static String separator = System.getProperty("file.separator");
+	/** Use pointer cursor instead of cross */
+	public static boolean usePointerCursor;
+	/** No longer used */
+	public static boolean antialiasedText;
+	/** Display images scaled <100% using bilinear interpolation */
+	public static boolean interpolateScaledImages;
+	/** Open images at 100% magnification*/
+	public static boolean open100Percent;
+	/** Backgound is black in binary images*/
+	public static boolean blackBackground;
+	/** Use JFileChooser instead of FileDialog to open and save files. */
+	public static boolean useJFileChooser;
+	/** Color to grayscale conversion is weighted (0.299, 0.587, 0.114) if the variable is true. */
+	public static boolean weightedColor;
+	/** Use black image border. */
+	public static boolean blackCanvas;
+	/** Point tool auto-measure mode. */
+	public static boolean pointAutoMeasure;
+	/** Point tool auto-next slice mode (not saved in IJ_Prefs). */
+	public static boolean pointAutoNextSlice;
+	/** Require control or command key for keybaord shortcuts. */
+	public static boolean requireControlKey;
+	/** Open 8-bit images with inverting LUT so 0 is white and 255 is black. */
+	public static boolean useInvertingLut;
+	/** Draw tool icons using antialiasing (always true). */
+	public static boolean antialiasedTools = true;
+	/** Export TIFF and Raw using little-endian byte order. */
+	public static boolean intelByteOrder;
+	/** No longer used */
+	public static boolean doubleBuffer = true;
+	/** Do not label multiple points created using point tool. */
+	public static boolean noPointLabels;
+	/** Disable Edit/Undo command. */
+	public static boolean disableUndo;
+	/** Do not draw black border around image. */
+	public static boolean noBorder;
+	/** Only show ROIs associated with current slice in Roi Manager "Show All" mode. */
+	public static boolean showAllSliceOnly = true;
+	/** Include column headers when copying tables to clipboard. */
+	public static boolean copyColumnHeaders;
+	/** Do not include row numbers when copying tables to clipboard. */
+	public static boolean noRowNumbers;
+	/** Move isolated plugins to Miscellaneous submenu. */
+	public static boolean moveToMisc;
+	/** Add points to ROI Manager. */
+	public static boolean pointAddToManager;
+	/** Add points to overlay. */
+	public static boolean pointAddToOverlay;
+	/** Extend the borders to foreground for binary erosions and closings. */
+	public static boolean padEdges;
+	/** Run the SocketListener. */
+	public static boolean runSocketListener;
+	/** Use MultiPoint tool. */
+	public static boolean multiPointMode;
+	/** Open DICOMs as 32-bit float images */
+	public static boolean openDicomsAsFloat;
+	/** Ignore Rescale Slope when opening DICOMs */
+	public static boolean ignoreRescaleSlope;
+	/** Assume DICOM volumes use identical RescaleSlope and RescaleIntercept across all slices */	
+	public static boolean fixedDicomScaling;
+	/** Plot rectangular selectons vertically */
+	public static boolean verticalProfile;
+	/** Rotate YZ orthogonal views 90 degrees */
+	public static boolean rotateYZ;
+	/** Rotate XZ orthogonal views 180 degrees */
+	public static boolean flipXZ;
+	/** Don't save Results table column headers */
+	public static boolean dontSaveHeaders;
+	/** Don't save Results table row numbers */
+	public static boolean dontSaveRowNumbers;
+	/** Don't run garbage collector when user clicks in status bar */
+	public static boolean noClickToGC;
+	/** Angle tool measures reflex angle */
+	public static boolean reflexAngle;
+	/** Avoid interpolation when re-slicing */
+	public static boolean avoidResliceInterpolation;
+	/** Preserve undo (snapshot) buffers when switching images */
+	public static boolean keepUndoBuffers;
+	/** Use ROI names as "show all" labels in the ROI Manager */
+	public static boolean useNamesAsLabels;
+	/** Set the "java.net.useSystemProxies" property */
+	public static boolean useSystemProxies;
+	/** Use the file chooser to import and export image sequences on Windows and Linux*/
+	public static boolean useFileChooser;
+	/** Use sub-pixel resolution with line selections */
+	public static boolean subPixelResolution;
+	/** Adjust contrast when scrolling stacks */
+	public static boolean autoContrast;
+	/** Allow lines to be created with one click at start and another at the end */
+	public static boolean enhancedLineTool;
+	/** Keep arrow selection after adding to overlay */
+	public static boolean keepArrowSelections;
+	/** Aways paint images using double buffering */
+	public static boolean paintDoubleBuffered;
+	/** Do not display dialog when opening .raw files */
+	public static boolean skipRawDialog;
+	/** Reverse channel-slice-frame priority used by Next Slice and Previous Slice commands. */
+	public static boolean reverseNextPreviousOrder;
+	/** Automatically run examples in Help/Examples menu. */
+	public static boolean autoRunExamples = true;
+	/** Ignore stack positions when displaying points. */
+	public static boolean showAllPoints;
+	/** Set MenuBar on Macs running Java 8. */
+	public static boolean setIJMenuBar = IJ.isMacOSX();
+	/** "ImageJ" window is always on top. */
+	public static boolean alwaysOnTop;
+	/** Automatically spline fit line selections */
+	public static boolean splineFitLines;
+	/** Enable this option to workaround a bug with some Linux window
+		managers that causes windows to wander down the screen. */
+	public static boolean doNotSaveWindowLocations;
+	/** Use JFileChooser setting changed/ */
+	public static boolean jFileChooserSettingChanged;
+	/** Convert tiff units to microns if pixel width is less than 0.0001 cm. */
+	public static boolean convertToMicrons = true;
+	/** Wand tool "Smooth if thresholded" option */
+	public static boolean smoothWand;
+	/** "Close All" command running */
+	public static boolean closingAll;
+	/** Dialog "Cancel" button is on right on Linux */
+	public static boolean dialogCancelButtonOnRight;
+	/** Support TRANSFORM Undo in macros */
+	public static boolean supportMacroUndo;
+	/** Use NonBlockingGenericDialogs in filters */	
+	public static boolean nonBlockingFilterDialogs;
+	//Save location of moved image windows */	
+	//public static boolean saveImageLocation = true;
+
+	static boolean commandLineMacro;
+	static Properties ijPrefs = new Properties();
+	static Properties props = new Properties(ijPrefs);
+	static String prefsDir;
+	static String imagesURL;
+	static String ImageJDir;
+	static int threads;
+	static int transparentIndex = -1;
+	private static boolean resetPreferences;
+	private static double guiScale = 1.0;
+	private static Properties locKeys = new Properties();
+	private static String propertiesPath; // location of custom IJ_Props.txt
+	private static String preferencesPath; // location of custom IJ_Prefs.txt
+
+	/** Saves the value of the string <code>text</code> in the preferences
+	 * file using the keyword <code>key</code>. The string can be 
+	 * retrieved using the appropriate <code>get()</code> method.
+	 * @see #get(String,String)
+	*/
+	public static void set(String key, String text) {
+		if (key.indexOf('.')<1)
+			throw new IllegalArgumentException("Key must have a prefix");
+		if (text==null)
+			ijPrefs.remove(KEY_PREFIX+key);
+		else
+			ijPrefs.put(KEY_PREFIX+key, text);
+	}
+
+	/** Saves the value of the integer <code>value</code> in the preferences
+	 * file using the keyword <code>key</code>. The value can be 
+	 * retrieved using the appropriate <code>get()</code> method.
+	 * @see #get(String,double)
+	*/
+	public static void set(String key, int value) {
+		set(key, Integer.toString(value));
+	}
+
+	/** Saves the value of the double <code>value</code> in the preferences
+	 * file using the keyword <code>key</code>. The value can be 
+	 * retrieved using the appropriate <code>get()</code> method.
+	 * @see #get(String,double)
+	*/
+	public static void set(String key, double value) {
+		set(key, ""+value);
+	}
+
+	/** Saves the value of the boolean <code>value</code> in the preferences
+	 * file using the keyword <code>key</code>. The value can be 
+	 * retrieved using the appropriate <code>get()</code> method.
+	 * @see #get(String,boolean)
+	*/
+	public static void set(String key, boolean value) {
+		set(key, ""+value);
+	}
+
+	/** Uses the keyword <code>key</code> to retrieve a string from the
+		preferences file. Returns <code>defaultValue</code> if the key
+		is not found. */
+	public static String get(String key, String defaultValue) {
+		String value = ijPrefs.getProperty(KEY_PREFIX+key);
+		if (value == null)
+			return defaultValue;
+		else
+			return value;
+	}
+
+	/** Uses the keyword <code>key</code> to retrieve a number from the
+		preferences file. Returns <code>defaultValue</code> if the key
+		is not found. */
+	public static double get(String key, double defaultValue) {
+		String s = ijPrefs.getProperty(KEY_PREFIX+key);
+		Double d = null;
+		if (s!=null) {
+			try {d = new Double(s);}
+			catch (NumberFormatException e) {d = null;}
+			if (d!=null)
+				return(d.doubleValue());
+		}
+		return defaultValue;
+	}
+
+	/** Uses the keyword <code>key</code> to retrieve a boolean from
+		the preferences file. Returns <code>defaultValue</code> if
+		the key is not found. */
+	public static boolean get(String key, boolean defaultValue) {
+		String value = ijPrefs.getProperty(KEY_PREFIX+key);
+		if (value==null)
+			return defaultValue;
+		else
+			return value.equals("true");
+	}
+	
+	/** Finds and loads the configuration file ("IJ_Props.txt")
+	 * and the preferences file ("IJ_Prefs.txt").
+	 * @return	an error message if "IJ_Props.txt" not found.
+	*/
+	public static String load(Object ij, Applet applet) {
+		if (ImageJDir==null)
+			ImageJDir = System.getProperty("user.dir");
+		if (ij!=null) {
+			InputStream f = null;
+			try { // Look for IJ_Props.txt in ImageJ folder
+				f = new FileInputStream(ImageJDir+"/"+PROPS_NAME);
+				propertiesPath = ImageJDir+"/"+PROPS_NAME;
+			} catch (FileNotFoundException e) {
+				f = null;
+			}
+			if (f==null) {
+				// Look in ij.jar if not found in ImageJ folder
+				f = ij.getClass().getResourceAsStream("/"+PROPS_NAME);
+			}			
+			if (applet!=null)
+				return loadAppletProps(f, applet);
+			if (f==null)
+				return PROPS_NAME+" not found in ij.jar or in "+ImageJDir;
+			f = new BufferedInputStream(f);
+			try {
+				props.load(f);
+				f.close();
+			} catch (IOException e) {
+				return("Error loading "+PROPS_NAME);
+			}
+			imagesURL = props.getProperty(IJ.isJava18()?"images.location":"images.location2");
+		}
+		loadPreferences();
+		loadOptions();
+		guiScale = get(GUI_SCALE, 1.0);
+		return null;
+	}
+
+	/*
+	static void dumpPrefs() {
+		System.out.println("");
+		Enumeration e = ijPrefs.keys();
+		while (e.hasMoreElements()) {
+			String key = (String) e.nextElement();
+			System.out.println(key+": "+ijPrefs.getProperty(key));
+		}
+	}
+	*/
+
+	static String loadAppletProps(InputStream f, Applet applet) {
+		if (f==null)
+			return PROPS_NAME+" not found in ij.jar";
+		try {
+			props.load(f);
+			f.close();
+		}
+		catch (IOException e) {return("Error loading "+PROPS_NAME);}
+		try {
+			URL url = new URL(applet.getDocumentBase(), "images/");
+			imagesURL = url.toString();
+		}
+		catch (Exception e) {}
+		return null;
+	}
+
+	/** Returns the URL of the directory that contains the ImageJ sample images. */
+	public static String getImagesURL() {
+		return imagesURL;
+	}
+
+	/** Sets the URL of the directory that contains the ImageJ sample images. */
+	public static void setImagesURL(String url) {
+		imagesURL = url;
+	}
+
+	/** Obsolete, replaced by getImageJDir(), which, unlike this method, 
+		returns a path that ends with File.separator. */
+	public static String getHomeDir() {
+		return ImageJDir;
+	}
+
+	/** Returns the path, ending in File.separator, to the ImageJ directory. */
+	public static String getImageJDir() {
+		String path = Menus.getImageJPath();
+		if (path==null)
+			return ImageJDir + File.separator;
+		else
+			return path;
+	}
+
+	/** Returns the path to the directory where the 
+		preferences file (IJPrefs.txt) is saved. */
+	public static String getPrefsDir() {
+		if (prefsDir==null) {
+			if (ImageJDir==null)
+				ImageJDir = System.getProperty("user.dir");
+			File f = new File(ImageJDir+File.separator+PREFS_NAME);
+			if (f.exists()) {
+				prefsDir = ImageJDir;
+				preferencesPath = ImageJDir+"/"+PREFS_NAME;
+			}
+			//System.out.println("getPrefsDir: "+f+"  "+prefsDir);
+			if (prefsDir==null) {
+				String dir = System.getProperty("user.home");
+				if (IJ.isMacOSX())
+					dir += "/Library/Preferences";
+				else
+					dir += File.separator+".imagej";
+				prefsDir = dir;
+			}
+		}
+		return prefsDir;
+	}
+
+	/** Sets the path to the ImageJ directory. */
+	static void setHomeDir(String path) {
+		if (path.endsWith(File.separator))
+			path = path.substring(0, path.length()-1);
+		ImageJDir = path;
+	}
+
+	/** Returns the default directory, if any, or null. */
+	public static String getDefaultDirectory() {
+		if (commandLineMacro)
+			return null;
+		else
+			return getString(DIR_IMAGE);
+	}
+
+	/** Returns the file.separator system property. */
+	public static String getFileSeparator() {
+		return separator;
+	}
+
+	/** Opens the ImageJ preferences file ("IJ_Prefs.txt") file. */
+	static void loadPreferences() {
+		String path = getPrefsDir()+separator+PREFS_NAME;
+		boolean ok =  loadPrefs(path);
+		if (!ok) { // not found
+			if (IJ.isWindows())
+				path = ImageJDir +separator+PREFS_NAME;
+			else
+				path = System.getProperty("user.home")+separator+PREFS_NAME; //User's home dir
+			ok = loadPrefs(path);
+			if (ok)
+				new File(path).delete();
+		}
+
+	}
+
+	static boolean loadPrefs(String path) {
+		try {
+			InputStream is = new BufferedInputStream(new FileInputStream(path));
+			ijPrefs.load(is);
+			is.close();
+			return true;
+		} catch (Exception e) {
+			return false;
+		}
+	}
+
+	/** Saves user preferences in the IJ_Prefs.txt properties file. */
+	public static void savePreferences() {
+		String path = null;
+		commandLineMacro = false;
+		try {
+			Properties prefs = new Properties();
+			String dir = OpenDialog.getDefaultDirectory();
+			if (dir!=null)
+				prefs.put(DIR_IMAGE, dir);
+			prefs.put(ROICOLOR, Tools.c2hex(Roi.getColor()));
+			prefs.put(SHOW_ALL_COLOR, Tools.c2hex(ImageCanvas.getShowAllColor()));
+			prefs.put(FCOLOR, Tools.c2hex(Toolbar.getForegroundColor()));
+			prefs.put(BCOLOR, Tools.c2hex(Toolbar.getBackgroundColor()));
+			prefs.put(JPEG, Integer.toString(FileSaver.getJpegQuality()));
+			prefs.put(FPS, Double.toString(Animator.getFrameRate()));
+			prefs.put(DIV_BY_ZERO_VALUE, Double.toString(FloatBlitter.divideByZeroValue));
+			prefs.put(NOISE_SD, Double.toString(Filters.getSD()));
+			if (threads>1) prefs.put(THREADS, Integer.toString(threads));
+			if (IJ.isMacOSX()) useJFileChooser = false;
+			if (!IJ.isLinux()) dialogCancelButtonOnRight = false;
+			saveOptions(prefs);
+			savePluginPrefs(prefs);
+			ImageJ ij = IJ.getInstance();
+			if (ij!=null)
+				ij.savePreferences(prefs);
+			Menus.savePreferences(prefs);
+			ParticleAnalyzer.savePreferences(prefs);
+			Analyzer.savePreferences(prefs);
+			ImportDialog.savePreferences(prefs);
+			PlotWindow.savePreferences(prefs);
+			NewImage.savePreferences(prefs);
+			String prefsDir = getPrefsDir();
+			path = prefsDir+separator+PREFS_NAME;
+			if (prefsDir.endsWith(".imagej")) {
+				File f = new File(prefsDir);
+				if (!f.exists()) f.mkdir(); // create .imagej directory
+			}
+			if (resetPreferences) {
+				File f = new File(path);
+				if (!f.exists())
+					IJ.error("Edit>Options>Reset", "Unable to reset preferences. File not found at\n"+path);
+				boolean rtn = f.delete();
+				resetPreferences = false;
+			} else
+				savePrefs(prefs, path);
+		} catch (Throwable t) {
+			String msg = t.getMessage();
+			if (msg==null) msg = ""+t;
+			int delay = 4000;
+			try {
+				new TextWindow("Error Saving Preferences:\n"+path, msg, 500, 200);
+				IJ.wait(delay);
+			} catch (Throwable t2) {}
+		}
+	}
+
+	/** Delete the preferences file when ImageJ quits. */
+	public static void resetPreferences() {
+		resetPreferences = true;
+	}
+
+	static void loadOptions() {
+		int defaultOptions = ANTIALIASING+AVOID_RESLICE_INTERPOLATION+ANTIALIASED_TOOLS+MULTI_POINT_MODE
+			+(!IJ.isMacOSX()?RUN_SOCKET_LISTENER:0)+BLACK_BACKGROUND;
+		int options = getInt(OPTIONS, defaultOptions);
+		usePointerCursor = (options&USE_POINTER)!=0;
+		//antialiasedText = (options&ANTIALIASING)!=0;
+		antialiasedText = false;
+		interpolateScaledImages = (options&INTERPOLATE)!=0;
+		open100Percent = (options&ONE_HUNDRED_PERCENT)!=0;
+		blackBackground = (options&BLACK_BACKGROUND)!=0;
+		useJFileChooser = (options&JFILE_CHOOSER)!=0;
+		weightedColor = (options&WEIGHTED)!=0;
+		if (weightedColor)
+			ColorProcessor.setWeightingFactors(0.299, 0.587, 0.114);
+		blackCanvas = (options&BLACK_CANVAS)!=0;
+		requireControlKey = (options&REQUIRE_CONTROL)!=0;
+		useInvertingLut = (options&USE_INVERTING_LUT)!=0;
+		intelByteOrder = (options&INTEL_BYTE_ORDER)!=0;
+		noBorder = (options&NO_BORDER)!=0;
+		showAllSliceOnly = (options&SHOW_ALL_SLICE_ONLY)!=0;
+		copyColumnHeaders = (options&COPY_HEADERS)!=0;
+		noRowNumbers = (options&NO_ROW_NUMBERS)!=0;
+		moveToMisc = (options&MOVE_TO_MISC)!=0;
+		runSocketListener = (options&RUN_SOCKET_LISTENER)!=0;
+		multiPointMode = (options&MULTI_POINT_MODE)!=0;
+		rotateYZ = (options&ROTATE_YZ)!=0;
+		flipXZ = (options&FLIP_XZ)!=0;
+		//dontSaveHeaders = (options&DONT_SAVE_HEADERS)!=0;
+		//dontSaveRowNumbers = (options&DONT_SAVE_ROW_NUMBERS)!=0;
+		noClickToGC = (options&NO_CLICK_TO_GC)!=0;
+		avoidResliceInterpolation = (options&AVOID_RESLICE_INTERPOLATION)!=0;
+		keepUndoBuffers = (options&KEEP_UNDO_BUFFERS)!=0;
+		
+		defaultOptions = (!IJ.isMacOSX()?USE_FILE_CHOOSER:0);
+		int options2 = getInt(OPTIONS2, defaultOptions);
+		useSystemProxies = (options2&USE_SYSTEM_PROXIES)!=0;
+		useFileChooser = (options2&USE_FILE_CHOOSER)!=0;
+		subPixelResolution = (options2&SUBPIXEL_RESOLUTION)!=0;
+		enhancedLineTool = (options2&ENHANCED_LINE_TOOL)!=0;
+		skipRawDialog = (options2&SKIP_RAW_DIALOG)!=0;
+		reverseNextPreviousOrder = (options2&REVERSE_NEXT_PREVIOUS_ORDER)!=0;
+		autoRunExamples = (options2&AUTO_RUN_EXAMPLES)!=0;
+		showAllPoints = (options2&SHOW_ALL_POINTS)!=0;
+		doNotSaveWindowLocations = (options2&DO_NOT_SAVE_WINDOW_LOCS)!=0;
+		jFileChooserSettingChanged = (options2&JFILE_CHOOSER_CHANGED)!=0;
+		dialogCancelButtonOnRight = (options2&CANCEL_BUTTON_ON_RIGHT)!=0;
+		ignoreRescaleSlope = (options2&IGNORE_RESCALE_SLOPE)!=0;
+		nonBlockingFilterDialogs = (options2&NON_BLOCKING_DIALOGS)!=0;
+		fixedDicomScaling = (options2&FIXED_DICOM_SCALINGg)!=0;
+	}
+
+	static void saveOptions(Properties prefs) {
+		int options = (usePointerCursor?USE_POINTER:0) + (antialiasedText?ANTIALIASING:0)
+			+ (interpolateScaledImages?INTERPOLATE:0) + (open100Percent?ONE_HUNDRED_PERCENT:0)
+			+ (blackBackground?BLACK_BACKGROUND:0) + (useJFileChooser?JFILE_CHOOSER:0)
+			+ (blackCanvas?BLACK_CANVAS:0) + (weightedColor?WEIGHTED:0) 
+			+ (requireControlKey?REQUIRE_CONTROL:0)
+			+ (useInvertingLut?USE_INVERTING_LUT:0)
+			+ (intelByteOrder?INTEL_BYTE_ORDER:0) + (doubleBuffer?DOUBLE_BUFFER:0)
+			+ (noPointLabels?NO_POINT_LABELS:0) + (noBorder?NO_BORDER:0)
+			+ (showAllSliceOnly?SHOW_ALL_SLICE_ONLY:0) + (copyColumnHeaders?COPY_HEADERS:0)
+			+ (noRowNumbers?NO_ROW_NUMBERS:0) + (moveToMisc?MOVE_TO_MISC:0)
+			+ (runSocketListener?RUN_SOCKET_LISTENER:0)
+			+ (multiPointMode?MULTI_POINT_MODE:0) + (rotateYZ?ROTATE_YZ:0)
+			+ (flipXZ?FLIP_XZ:0) + (dontSaveHeaders?DONT_SAVE_HEADERS:0)
+			+ (dontSaveRowNumbers?DONT_SAVE_ROW_NUMBERS:0) + (noClickToGC?NO_CLICK_TO_GC:0)
+			+ (avoidResliceInterpolation?AVOID_RESLICE_INTERPOLATION:0)
+			+ (keepUndoBuffers?KEEP_UNDO_BUFFERS:0);
+		prefs.put(OPTIONS, Integer.toString(options));
+
+		int options2 = (useSystemProxies?USE_SYSTEM_PROXIES:0)
+			+ (useFileChooser?USE_FILE_CHOOSER:0) + (subPixelResolution?SUBPIXEL_RESOLUTION:0)
+			+ (enhancedLineTool?ENHANCED_LINE_TOOL:0) + (skipRawDialog?SKIP_RAW_DIALOG:0)
+			+ (reverseNextPreviousOrder?REVERSE_NEXT_PREVIOUS_ORDER:0)
+			+ (autoRunExamples?AUTO_RUN_EXAMPLES:0) + (showAllPoints?SHOW_ALL_POINTS:0)
+			+ (doNotSaveWindowLocations?DO_NOT_SAVE_WINDOW_LOCS:0)
+			+ (jFileChooserSettingChanged?JFILE_CHOOSER_CHANGED:0)
+			+ (dialogCancelButtonOnRight?CANCEL_BUTTON_ON_RIGHT:0)
+			+ (ignoreRescaleSlope?IGNORE_RESCALE_SLOPE:0)
+			+ (nonBlockingFilterDialogs?NON_BLOCKING_DIALOGS:0)
+			+ (fixedDicomScaling?FIXED_DICOM_SCALINGg:0);
+		prefs.put(OPTIONS2, Integer.toString(options2));
+	}
+
+	/** Saves the Point <code>loc</code> in the preferences
+		 file as a string using the keyword <code>key</code>. */
+	public static void saveLocation(String key, Point loc) {
+		if (!doNotSaveWindowLocations)
+			set(key, loc!=null?loc.x+","+loc.y:null);
+	}
+
+	/** Uses the keyword <code>key</code> to retrieve a location
+		from the preferences file. Returns null if the
+		key is not found or the location is not valid (e.g., offscreen). */
+	public static Point getLocation(String key) {
+		String value = ijPrefs.getProperty(KEY_PREFIX+key);
+		if (value==null) return null;
+		int index = value.indexOf(",");
+		if (index==-1) return null;
+		double xloc = Tools.parseDouble(value.substring(0, index));
+		if (Double.isNaN(xloc) || index==value.length()-1) return null;
+		double yloc = Tools.parseDouble(value.substring(index+1));
+		if (Double.isNaN(yloc)) return null;
+		Point p = new Point((int)xloc, (int)yloc);
+		Rectangle bounds = GUI.getScreenBounds(p); // get bounds of screen that contains p
+		if (bounds!=null && p.x+100<=bounds.x+bounds.width && p.y+ 40<=bounds.y+bounds.height) {
+			if (locKeys.get(key)==null) { // first time for this key? 
+				locKeys.setProperty(key, "");
+				Rectangle primaryScreen = GUI.getMaxWindowBounds();
+				ImageJ ij = IJ.getInstance();
+				Point ijLoc = ij!=null?ij.getLocation():null;
+				//System.out.println("getLoc: "+key+" "+(ijLoc!=null&&primaryScreen.contains(ijLoc)) + "  "+!primaryScreen.contains(p));
+				if ((ijLoc!=null&&primaryScreen.contains(ijLoc)) && !primaryScreen.contains(p))
+					return null; // return null if "ImageJ" window on primary screen and this location is not
+			}
+			return p;
+		} else
+			return null;
+	}
+
+	/** Save plugin preferences. */
+	static void savePluginPrefs(Properties prefs) {
+		Enumeration e = ijPrefs.keys();
+		while (e.hasMoreElements()) {
+			String key = (String) e.nextElement();
+			if (key.indexOf(KEY_PREFIX) == 0)
+				prefs.put(key, ijPrefs.getProperty(key));
+		}
+	}
+
+	public static void savePrefs(Properties prefs, String path) throws IOException{
+		FileOutputStream fos = new FileOutputStream(path);
+		BufferedOutputStream bos = new BufferedOutputStream(fos);
+		prefs.store(bos, "ImageJ "+ImageJ.VERSION+" Preferences");
+		bos.close();
+	}
+	
+	/** Returns the number of threads used by PlugInFilters to process images and stacks. */
+	public static int getThreads() {
+		if (threads==0) {
+			threads = getInt(THREADS, 0);
+			int processors = Runtime.getRuntime().availableProcessors();
+			if (threads<1 || threads>processors)
+				threads = processors;
+		}
+		return threads;
+	}
+	
+	/** Sets the number of threads (1-32) used by PlugInFilters to process stacks. */
+	public static void setThreads(int n) {
+		if (n<1) n = 1;
+		threads = n;
+	}
+	
+	/** Sets the transparent index (0-255), or set to -1 to disable transparency. */
+	public static void setTransparentIndex(int index) {
+		if (index<-1 || index>255) index = -1;
+		transparentIndex = index;
+	}
+
+	/** Returns the transparent index (0-255), or -1 if transparency is disabled. */
+	public static int getTransparentIndex() {
+		return transparentIndex;
+	}
+	
+	public static Properties getControlPanelProperties() {
+		return ijPrefs;
+	}
+	
+	public static String defaultResultsExtension() {
+		return get("options.ext", ".csv");
+	}
+		
+	/** Sets the GenericDialog and Command Finder text scale (0.5 to 3.0). */
+	public static void setGuiScale(double scale) {
+		if (scale>=0.5 && scale<=3.0) {
+			guiScale = scale;
+			set(GUI_SCALE, guiScale);
+			Roi.resetDefaultHandleSize();
+		}
+	}
+
+	/** Returns the GenericDialog and Command Finder text scale. */
+	public static double getGuiScale() {
+		return guiScale;
+	}
+
+	/** Returns the custom properties (IJ_Props.txt) file path. */
+	public static String getCustomPropsPath() {
+		return propertiesPath;
+	}
+
+	/** Returns the custom preferences (IJ_Prefs.txt) file path. */
+	public static String getCustomPrefsPath() {
+		return preferencesPath;
+	}
+
+	/** Retrieves a string from IJ_Props or IJ_Prefs.txt.
+		Does not retrieve strings set using Prefs.set(). */
+	public static String getString(String key, String defaultString) {
+		if (props==null)
+			return defaultString;
+		String s = props.getProperty(key);
+		if (s==null)
+			return defaultString;
+		else
+			return s;
+	}
+
+	/** Retrieves a string from string in IJ_Props or IJ_Prefs.txt. */
+	public static String getString(String key) {
+		return props.getProperty(key);
+	}
+
+	/** Retrieves a number from IJ_Props or IJ_Prefs.txt.
+		Does not retrieve numbers set using Prefs.set(). */
+	public static int getInt(String key, int defaultValue) {
+		if (props==null) //workaround for Netscape JIT bug
+			return defaultValue;
+		String s = props.getProperty(key);
+		if (s!=null) {
+			try {
+				return Integer.decode(s).intValue();
+			} catch (NumberFormatException e) {IJ.log(""+e);}
+		}
+		return defaultValue;
+	}
+
+	/** Retrieves a number from IJ_Props or IJ_Prefs.txt.
+		Does not retrieve numbers set using Prefs.set(). */
+	public static double getDouble(String key, double defaultValue) {
+		if (props==null)
+			return defaultValue;
+		String s = props.getProperty(key);
+		Double d = null;
+		if (s!=null) {
+			try {d = new Double(s);}
+			catch (NumberFormatException e){d = null;}
+			if (d!=null)
+				return(d.doubleValue());
+		}
+		return defaultValue;
+	}
+
+	/** Retrieves a boolean from IJ_Props or IJ_Prefs.txt.
+		Does not retrieve boolean set using Prefs.set(). */
+	public static boolean getBoolean(String key, boolean defaultValue) {
+		if (props==null) return defaultValue;
+		String s = props.getProperty(key);
+		if (s==null)
+			return defaultValue;
+		else
+			return s.equals("true");
+	}
+
+	/** Finds a color in IJ_Props or IJ_Prefs.txt. */
+	public static Color getColor(String key, Color defaultColor) {
+		int i = getInt(key, 0xaaa);
+		if (i == 0xaaa)
+			return defaultColor;
+		return new Color((i >> 16) & 0xFF, (i >> 8) & 0xFF, i & 0xFF);
+	}
+	
+	public static boolean commandLineMacro() {
+		return commandLineMacro;
+	}
+
+}
+
diff --git a/src/ij/RecentOpener.java b/src/ij/RecentOpener.java
new file mode 100644
index 0000000..8f04162
--- /dev/null
+++ b/src/ij/RecentOpener.java
@@ -0,0 +1,37 @@
+package ij;
+import ij.io.*;
+import java.awt.*;
+import java.io.*;
+
+/** Opens, in a separate thread, files selected from the File/Open Recent submenu.*/
+public class RecentOpener implements Runnable {
+	private String path;
+
+	RecentOpener(String path) {
+		this.path = path;
+		Thread thread = new Thread(this, "RecentOpener");
+		thread.start();
+	}
+
+	/** Open the file and move the path to top of the submenu. */
+	public void run() {
+		Opener o = new Opener();
+		o.open(path);
+		Menu menu = Menus.getOpenRecentMenu();
+		int n = menu.getItemCount();
+		int index = 0;
+		for (int i=0; i<n; i++) {
+			if (menu.getItem(i).getLabel().equals(path)) {
+				index = i;
+				break;
+			}
+		}
+		if (index>0) {
+			MenuItem item = menu.getItem(index);
+			menu.remove(index);
+			menu.insert(item, 0);
+		}
+	}
+
+}
+
diff --git a/src/ij/Undo.java b/src/ij/Undo.java
new file mode 100644
index 0000000..5bca876
--- /dev/null
+++ b/src/ij/Undo.java
@@ -0,0 +1,215 @@
+/**Implements the Edit/Undo command.*/
+
+package ij;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.awt.image.*;
+
+/** This class consists of static methods and
+	fields that implement ImageJ's Undo command. */
+public class Undo {
+
+	public static final int NOTHING = 0;
+	/** Undo using ImageProcessor.snapshot. */
+	public static final int FILTER = 1;
+	/** Undo using an ImageProcessor copy. */
+	public static final int TYPE_CONVERSION = 2;
+	public static final int PASTE = 3;
+	public static final int COMPOUND_FILTER = 4;
+	public static final int COMPOUND_FILTER_DONE = 5;
+	/** Undo using a single image, or composite color stack, copy (limited to 200MB). */
+	public static final int TRANSFORM = 6;
+	public static final int OVERLAY_ADDITION = 7;
+	public static final int ROI = 8;
+	public static final int MACRO = 9;
+	
+	private static int whatToUndo = NOTHING;
+	private static int imageID;
+	private static ImageProcessor ipCopy = null;
+	private static ImagePlus impCopy;
+	private static Calibration calCopy;
+	private static Roi roiCopy;
+	private static double displayRangeMin, displayRangeMax;
+	private static LUT lutCopy;
+	private static Overlay overlayCopy;
+	
+	public static void setup(int what, ImagePlus imp) {
+		if (imp==null) {
+			whatToUndo = NOTHING;
+			reset();
+			return;
+		}
+		if (IJ.debugMode) IJ.log("Undo.setup: "+what+" "+imp);
+		if (what==FILTER && whatToUndo==COMPOUND_FILTER)
+				return;
+		if (what==COMPOUND_FILTER_DONE) {
+			if (whatToUndo==COMPOUND_FILTER)
+				whatToUndo = what;
+			return;
+		}
+		whatToUndo = what;
+		imageID = imp.getID();
+		if (what==TYPE_CONVERSION) {
+			ipCopy = imp.getProcessor();
+			calCopy = (Calibration)imp.getCalibration().clone();
+		} else if (what==TRANSFORM) {	
+			if ((!IJ.macroRunning()||Prefs.supportMacroUndo) && (imp.getStackSize()==1||imp.getDisplayMode()==IJ.COMPOSITE) && imp.getSizeInBytes()<209715200)
+				impCopy = imp.duplicate();
+			else
+				reset();
+		} else if (what==MACRO) {	
+			ipCopy = imp.getProcessor().duplicate();
+			calCopy = (Calibration)imp.getCalibration().clone();
+			impCopy = null;
+		} else if (what==COMPOUND_FILTER) {
+			ImageProcessor ip = imp.getProcessor();
+			if (ip!=null)
+				ipCopy = ip.duplicate();
+			else
+				ipCopy = null;
+		} else if (what==OVERLAY_ADDITION) {
+			impCopy = null;
+			ipCopy = null;
+		} else if (what==ROI) {
+			impCopy = null;
+			ipCopy = null;
+			Roi roi = imp.getRoi();
+			if (roi!=null) {
+				roiCopy = (Roi)roi.clone();
+				roiCopy.setImage(null);
+			} else
+				whatToUndo = NOTHING;
+		} else {
+			ipCopy = null;
+			ImageProcessor ip = imp.getProcessor();
+			//lutCopy = (LUT)ip.getLut().clone();
+		}
+	}
+	
+	public static void saveOverlay(ImagePlus imp) {
+		Overlay overlay = imp!=null?imp.getOverlay():null;
+		if (overlay!=null)
+			overlayCopy = overlay.duplicate();
+		else
+			overlayCopy = null;
+	}
+		
+	public static void reset() {
+		if (IJ.debugMode) IJ.log("Undo.reset: "+ whatToUndo+" "+impCopy);
+		if (whatToUndo==COMPOUND_FILTER || whatToUndo==OVERLAY_ADDITION)
+			return;
+		whatToUndo = NOTHING;
+		imageID = 0;
+		ipCopy = null;
+		impCopy = null;
+		calCopy = null;
+		roiCopy = null;
+		lutCopy = null;
+		overlayCopy = null;
+	}	
+
+	public static void undo() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (IJ.debugMode) IJ.log("Undo.undo: "+ whatToUndo+" "+imp+"  "+impCopy);
+		if (imp==null || imageID!=imp.getID()) {
+			if (imp!=null && !IJ.macroRunning()) { // does image still have an undo buffer?
+				ImageProcessor ip2 = imp.getProcessor();
+				ip2.swapPixelArrays();
+				imp.updateAndDraw();
+			} else
+				reset();
+			return;
+		}
+		switch (whatToUndo) {
+			case FILTER:
+				if (overlayCopy!=null) {
+					Overlay overlay = imp.getOverlay();
+					if (overlay!=null) {
+						imp.setOverlay(overlayCopy);
+						overlayCopy = overlay.duplicate();
+					}
+				}
+				ImageProcessor ip = imp.getProcessor();
+				if (ip!=null) {
+					if (!IJ.macroRunning()) {
+						ip.swapPixelArrays();
+						imp.updateAndDraw();
+						return; // don't reset
+					} else {
+						ip.reset();
+						imp.updateAndDraw();
+					}
+				}
+				break;
+			case TYPE_CONVERSION:
+			case COMPOUND_FILTER:
+			case COMPOUND_FILTER_DONE:
+				if (ipCopy!=null) {
+					if (whatToUndo==TYPE_CONVERSION && calCopy!=null)
+						imp.setCalibration(calCopy);
+					if (swapImages(new ImagePlus("",ipCopy), imp)) {
+						imp.updateAndDraw();
+						return;
+					} else
+						imp.setProcessor(null, ipCopy);
+				}
+				break;
+			case TRANSFORM:
+				if (impCopy!=null)
+					imp.setStack(impCopy.getStack());
+				break;
+			case PASTE:
+				Roi roi = imp.getRoi();
+				if (roi!=null)
+					roi.abortPaste();
+	    		break;
+			case ROI:
+				Roi roiCopy2 = roiCopy;
+				setup(ROI, imp); // setup redo
+				imp.setRoi(roiCopy2);
+				return; //don't reset
+			case MACRO:
+				if (ipCopy!=null) {
+					imp.setProcessor(ipCopy);
+					if (calCopy!=null) imp.setCalibration(calCopy);
+				}
+				break;
+			case OVERLAY_ADDITION:
+				Overlay overlay = imp.getOverlay();
+				if (overlay==null) 
+					{IJ.beep(); return;}
+				int size = overlay.size();
+				if (size>0) {
+					overlay.remove(size-1);
+					imp.draw();
+				} else {
+					IJ.beep();
+					return;
+				}
+	    		return; //don't reset
+    	}
+    	reset();
+	}
+	
+	static boolean swapImages(ImagePlus imp1, ImagePlus imp2) {
+		if (imp1.getWidth()!=imp2.getWidth() || imp1.getHeight()!=imp2.getHeight()
+		|| imp1.getBitDepth()!=imp2.getBitDepth() || IJ.macroRunning())
+			return false;
+		ImageProcessor ip1 = imp1.getProcessor();
+		ImageProcessor ip2 = imp2.getProcessor();
+		double min1 = ip1.getMin();
+		double max1 = ip1.getMax();
+		double min2 = ip2.getMin();
+		double max2 = ip2.getMax();
+		ip2.setSnapshotPixels(ip1.getPixels());
+		ip2.swapPixelArrays();
+		ip1.setPixels(ip2.getSnapshotPixels());
+		ip2.setSnapshotPixels(null);
+		ip1.setMinAndMax(min2, max2);
+		ip2.setMinAndMax(min1, max1);
+		return true;
+	}
+
+}
diff --git a/src/ij/VirtualStack.java b/src/ij/VirtualStack.java
new file mode 100644
index 0000000..658badf
--- /dev/null
+++ b/src/ij/VirtualStack.java
@@ -0,0 +1,335 @@
+package ij;
+import ij.process.*;
+import ij.io.*;
+import ij.gui.ImageCanvas;
+import ij.util.Tools;
+import ij.plugin.FolderOpener;
+import java.io.*;
+import java.awt.*;
+import java.awt.image.ColorModel;
+import java.util.Properties;
+
+/** This class represents an array of disk-resident images. */
+public class VirtualStack extends ImageStack {
+	private static final int INITIAL_SIZE = 100;
+	private String path;
+	private int nSlices;
+	private String[] names;
+	private String[] labels;
+	private int bitDepth;
+	private int delay;
+	private Properties  properties;
+	private boolean generateData;
+	private int[] indexes;  // used to translate non-CZT hyperstack slice numbers
+
+	
+	/** Default constructor. */
+	public VirtualStack() { }
+	
+	public VirtualStack(int width, int height) {
+		super(width, height);
+	}
+
+	/** Creates an empty virtual stack.
+	 * @param width		image width
+	 * @param height	image height
+	 * @param cm	ColorModel or null
+	 * @param path	file path of directory containing the images
+	 * @see #addSlice(String)
+	 * @see <a href="http://wsr.imagej.net/macros/js/OpenAsVirtualStack.js">OpenAsVirtualStack.js</a>
+	*/
+	public VirtualStack(int width, int height, ColorModel cm, String path) {
+		super(width, height, cm);
+		path = IJ.addSeparator(path);
+		this.path = path;
+		names = new String[INITIAL_SIZE];
+		labels = new String[INITIAL_SIZE];
+	}
+
+	/** Creates a virtual stack with no backing storage.<br>
+	 * See: Help&gt;Examples&gt;JavaScript&gt;Terabyte VirtualStack
+	*/
+	public VirtualStack(int width, int height, int slices) {
+		this(width, height, slices, "8-bit");
+	}
+
+	/** Creates a virtual stack with no backing storage.<br>
+	 * See: Help&gt;Examples&gt;JavaScript&gt;Terabyte VirtualStack
+	 */
+	public VirtualStack(int width, int height, int slices, String options) {
+		super(width, height, null);
+		nSlices = slices;
+		int depth = 8;
+  		if (options.contains("16-bit")) depth=16;
+ 	    if (options.contains("RGB")) depth=24;
+        if (options.contains("32-bit")) depth=32;
+        if (options.contains("delay")) delay=250;
+        this.generateData = options.contains("fill");
+		this.bitDepth = depth;
+	}
+
+	/** Adds an image to the end of a virtual stack created using the
+	 * VirtualStack(w,h,cm,path) constructor. The argument 
+	 * can be a full file path (e.g., "C:/Users/wayne/dir1/image.tif")
+	 * if the 'path' argument in the constructor is "". File names
+	 * that start with '.' are ignored.
+	*/
+	public void addSlice(String fileName) {
+		if (fileName==null) 
+			throw new IllegalArgumentException("'fileName' is null!");
+		if (fileName.startsWith("."))
+			return;
+		if (names==null)
+				throw new IllegalArgumentException("VirtualStack(w,h,cm,path) constructor not used");
+		nSlices++;
+	   if (nSlices==names.length) {
+			String[] tmp = new String[nSlices*2];
+			System.arraycopy(names, 0, tmp, 0, nSlices);
+			names = tmp;
+			tmp = new String[nSlices*2];
+			System.arraycopy(labels, 0, tmp, 0, nSlices);
+			labels = tmp;
+		}
+		names[nSlices-1] = fileName;
+	}
+
+   /** Does nothing. */
+	public void addSlice(String sliceLabel, Object pixels) {
+	}
+
+	/** Does nothing.. */
+	public void addSlice(String sliceLabel, ImageProcessor ip) {
+	}
+	
+	/** Does noting. */
+	public void addSlice(String sliceLabel, ImageProcessor ip, int n) {
+	}
+
+	/** Deletes the specified slice, were 1<=n<=nslices. */
+	public void deleteSlice(int n) {
+		if (n<1 || n>nSlices)
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		if (nSlices<1)
+			return;
+		for (int i=n; i<nSlices; i++)
+			names[i-1] = names[i];
+		names[nSlices-1] = null;
+		nSlices--;
+	}
+	
+	/** Deletes the last slice in the stack. */
+	public void deleteLastSlice() {
+		int n = size();
+		if (n>0)
+			deleteSlice(n);
+	}
+	   
+   /** Returns the pixel array for the specified slice, were 1<=n<=nslices. */
+	public Object getPixels(int n) {
+		ImageProcessor ip = getProcessor(n);
+		if (ip!=null)
+			return ip.getPixels();
+		else
+			return null;
+	}		
+	
+	 /** Assigns a pixel array to the specified slice,
+		were 1<=n<=nslices. */
+	public void setPixels(Object pixels, int n) {
+	}
+
+   /** Returns an ImageProcessor for the specified slice,
+		were 1<=n<=nslices. Returns null if the stack is empty.
+	*/
+	public ImageProcessor getProcessor(int n) {
+		if (path==null) {  //Help>Examples?JavaScript>Terabyte VirtualStack
+			ImageProcessor ip = null;
+			int w=getWidth(), h=getHeight();
+			switch (bitDepth) {
+				case 8: ip = new ByteProcessor(w,h); break;
+				case 16: ip = new ShortProcessor(w,h); break;
+				case 24: ip = new ColorProcessor(w,h); break;
+				case 32: ip = new FloatProcessor(w,h); break;
+			}
+			String hlabel = null;
+			if (generateData) {
+				int value = 0;
+				ImagePlus img = WindowManager.getCurrentImage();
+				if (img!=null && img.getStackSize()==nSlices)
+					value = img.getCurrentSlice()-1;
+				if (bitDepth==16)
+					value *= 256;
+				if (bitDepth!=32) {
+					for (int i=0; i<ip.getPixelCount(); i++)
+						ip.set(i,value++);
+				}
+				if (img!=null && img.isHyperStack()) {
+					int[] pos = img.convertIndexToPosition(n);
+					hlabel = pos[0]+" "+pos[1]+" "+pos[2]+" "+n;
+				}
+			}
+			label(ip, hlabel!=null?hlabel:""+n, Color.white);
+			if (delay>0)
+				IJ.wait(delay);
+			return ip;
+		}
+		n = translate(n);  // update n for hyperstacks not in the default CZT order
+		Opener opener = new Opener();
+		opener.setSilentMode(true);
+		IJ.redirectErrorMessages(true);
+		ImagePlus imp = opener.openTempImage(path, names[n-1]);
+		IJ.redirectErrorMessages(false);
+		ImageProcessor ip = null;
+		int depthThisImage = 0;
+		if (imp!=null) {
+			int w = imp.getWidth();
+			int h = imp.getHeight();
+			int type = imp.getType();
+			ColorModel cm = imp.getProcessor().getColorModel();
+			String info = (String)imp.getProperty("Info");
+			if (info!=null) {
+				if (FolderOpener.useInfo(info))
+					labels[n-1] = info;
+			} else {
+				String sliceLabel = imp.getStack().getSliceLabel(1);
+				if (FolderOpener.useInfo(sliceLabel))
+					labels[n-1] = "Label: "+sliceLabel;
+			}
+			depthThisImage = imp.getBitDepth();
+			ip = imp.getProcessor();
+			ip.setOverlay(imp.getOverlay());
+			properties = imp.getProperty("FHT")!=null?imp.getProperties():null;
+		} else {
+			File f = new File(path, names[n-1]);
+			String msg = f.exists()?"Error opening ":"File not found: ";
+			ip = new ByteProcessor(getWidth(), getHeight());
+			ip.invert();
+			label(ip, msg+names[n-1], Color.black);
+			depthThisImage = 8;
+		}
+		if (depthThisImage!=bitDepth) {
+			switch (bitDepth) {
+				case 8: ip=ip.convertToByte(true); break;
+				case 16: ip=ip.convertToShort(true); break;
+				case 24:  ip=ip.convertToRGB(); break;
+				case 32: ip=ip.convertToFloat(); break;
+			}
+		}
+		if (ip.getWidth()!=getWidth() || ip.getHeight()!=getHeight()) {
+			ImageProcessor ip2 = ip.createProcessor(getWidth(), getHeight());
+			ip2.insert(ip, 0, 0);
+			ip = ip2;
+		}
+		return ip;
+	 }
+	 	 
+	 private void label(ImageProcessor ip, String msg, Color color) {
+		int size = getHeight()/20;
+		if (size<9) size=9;
+		Font font = new Font("Helvetica", Font.PLAIN, size);
+		ip.setFont(font);
+		ip.setAntialiasedText(true);
+		ip.setColor(color);
+		ip.drawString(msg, size, size*2);
+	}
+ 
+	/** Currently not implemented */
+	public int saveChanges(int n) {
+		return -1;
+	}
+	
+	/** Returns the number of slices in this stack. */
+	public int size() {
+		return getSize();
+	}
+
+	public int getSize() {
+		return nSlices;
+	}
+
+	/** Returns the label of the Nth image. */
+	public String getSliceLabel(int n) {
+		if (labels==null)
+			return null;
+		String label = labels[n-1];
+		if (label==null)
+			return names[n-1];
+		else {
+			if (label.startsWith("Label: "))  // slice label
+				return label.substring(7,label.length());
+			else
+				return names[n-1]+"\n"+label;
+		}
+	}
+	
+	/** Returns null. */
+	public Object[] getImageArray() {
+		return null;
+	}
+
+   /** Does nothing. */
+	public void setSliceLabel(String label, int n) {
+	}
+
+	/** Always return true. */
+	public boolean isVirtual() {
+		return true;
+	}
+
+   /** Does nothing. */
+	public void trim() {
+	}
+	
+	/** Returns the path to the directory containing the images. */
+	public String getDirectory() {
+		return IJ.addSeparator(path);
+	}
+		
+	/** Returns the file name of the specified slice, were 1<=n<=nslices. */
+	public String getFileName(int n) {
+		return names[n-1];
+	}
+	
+	/** Sets the bit depth (8, 16, 24 or 32). */
+	public void setBitDepth(int bitDepth) {
+		this.bitDepth = bitDepth;
+	}
+
+	/** Returns the bit depth (8, 16, 24 or 32), or 0 if the bit depth is not known. */
+	public int getBitDepth() {
+		return bitDepth;
+	}
+	
+	public ImageStack sortDicom(String[] strings, String[] info, int maxDigits) {
+		int n = size();
+		String[] names2 = new String[n];
+		for (int i=0; i<n; i++)
+			names2[i] = names[i];
+		for (int i=0; i<n; i++) {
+			int slice = (int)Tools.parseDouble(strings[i].substring(strings[i].length()-maxDigits), 0.0);
+			if (slice==0) return null;
+			names[i] = names2[slice-1];
+			labels[i] = info[slice-1];
+		}
+		return this;
+	}
+	
+	/** Returns the ImagePlus Properties assoctated with the current slice, or null. */
+	public Properties getProperties() {
+		return properties;
+	}
+	
+	/** Sets the table that translates slice numbers of hyperstacks not in default CZT order. */
+	public void setIndexes(int[] indexes) {
+		this.indexes = indexes;
+	}
+	
+	/** Translates slice numbers of hyperstacks not in default CZT order. */
+	public int translate(int n) {
+		int n2 = (indexes!=null&&indexes.length==getSize()) ? indexes[n-1]+1 : n;
+		//IJ.log("translate: "+n+" "+n2+" "+getSize()+" "+(indexes!=null?indexes.length:null));
+		return n2;
+	}
+
+} 
+
diff --git a/src/ij/WindowManager.java b/src/ij/WindowManager.java
new file mode 100644
index 0000000..a957ac7
--- /dev/null
+++ b/src/ij/WindowManager.java
@@ -0,0 +1,643 @@
+package ij;
+import ij.plugin.Converter;
+import ij.plugin.frame.Recorder;
+import ij.plugin.frame.Editor; 
+import ij.text.TextWindow;
+import ij.plugin.frame.PlugInFrame;
+import ij.plugin.frame.Commands;
+import ij.util.Tools;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.util.*;
+import ij.gui.*;
+
+/** This class consists of static methods used to manage ImageJ's windows. */
+public class WindowManager {
+
+	public static boolean checkForDuplicateName;
+	private static Vector imageList = new Vector();		 // list of image windows
+	private static Vector activations = new Vector(); 	// list of image windows, ordered by activation time
+	private static Vector nonImageList = new Vector();	// list of non-image windows (Frames and Dialogs)
+	private static ImageWindow currentWindow;			 // active image window
+	private static Window frontWindow;
+	private static Window frontTable;
+	private static Frame frontFrame;
+	private static Hashtable tempImageTable = new Hashtable();
+	
+	private WindowManager() {
+	}
+
+	/** Makes the image contained in the specified window the active image. */
+	public static void setCurrentWindow(ImageWindow win) {
+		if (win==null || win.isClosed() || win.getImagePlus()==null) // deadlock-"wait to lock"
+			return;
+		//IJ.log("setCurrentWindow: "+win.getImagePlus().getTitle()+" ("+(currentWindow!=null?currentWindow.getImagePlus().getTitle():"null") + ")");
+		setWindow(win);
+		tempImageTable.remove(Thread.currentThread());
+		if (win==currentWindow || imageList.size()==0)
+			return;
+		if (currentWindow!=null) {
+			// free up pixel buffers used by current window
+			ImagePlus imp = currentWindow.getImagePlus();
+			if (imp!=null ) {
+				if (!Prefs.keepUndoBuffers)
+					imp.trimProcessor();
+				imp.saveRoi();
+			}
+		}
+		Undo.reset();
+		currentWindow = win;
+		activations.remove(win);
+		activations.add(win);
+		Menus.updateMenus();
+		if (Recorder.record && !IJ.isMacro())
+			Recorder.record("selectWindow", win.getImagePlus().getTitle());
+	}
+	
+	/** Returns the active ImageWindow. */
+	public static ImageWindow getCurrentWindow() {
+		return currentWindow;
+	}
+
+	static int getCurrentIndex() {
+		return imageList.indexOf(currentWindow);
+	}
+
+	/** Returns a reference to the active image or null if there isn't one.
+	 * @see ij.IJ#getImage
+	 */
+	public static ImagePlus getCurrentImage() {
+		ImagePlus img = (ImagePlus)tempImageTable.get(Thread.currentThread());
+		//String str = (img==null)?" null":"";
+		if (img==null)
+			img = getActiveImage();
+		//if (img!=null) IJ.log("getCurrentImage: "+img.getTitle()+" "+Thread.currentThread().hashCode()+str);
+		return img;
+	}
+
+	/** Makes the specified image temporarily the active 
+		image for this thread. Call again with a null
+		argument to revert to the previous active image. */
+	public static void setTempCurrentImage(ImagePlus img) {
+		//IJ.log("setTempImage: "+(img!=null?""+img:"null")+" "+Thread.currentThread().hashCode());
+		if (img==null)
+			tempImageTable.remove(Thread.currentThread());
+		else
+			tempImageTable.put(Thread.currentThread(), img);
+	}
+	
+	/** Sets a temporary image for the specified thread. */
+	public static void setTempCurrentImage(Thread thread, ImagePlus img) {
+		if (thread==null)
+			throw new RuntimeException("thread==null");
+		if (img==null)
+			tempImageTable.remove(thread);
+		else
+			tempImageTable.put(thread, img);
+	}
+
+	/** Returns the active ImagePlus. */
+	private static ImagePlus getActiveImage() {
+		if (currentWindow!=null)
+			return currentWindow.getImagePlus();
+		else if (frontWindow!=null && (frontWindow instanceof ImageWindow))
+			return frontWindow!=null?((ImageWindow)frontWindow).getImagePlus():null;
+		else if (imageList.size()>0) {	
+			ImagePlus imp = getFocusManagerActiveImage();
+			if (imp!=null)
+				return imp;
+			ImageWindow win = (ImageWindow)imageList.get(imageList.size()-1);
+			return win.getImagePlus();
+		} else
+			return Interpreter.getLastBatchModeImage(); 
+	}
+	
+	private static ImagePlus getFocusManagerActiveImage() {
+		if (IJ.isMacro())
+			return null;
+		KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
+		Window win = kfm.getActiveWindow();
+		ImagePlus imp = null;
+		if (win!=null && (win instanceof ImageWindow))
+			imp = ((ImageWindow)win).getImagePlus();
+		return imp;
+	}
+
+	/** Returns the number of open image windows. */
+	public static int getWindowCount() {
+		int count = imageList.size();
+		return count;
+	}
+
+	/** Returns the number of open images. */
+	public static int getImageCount() {
+		int count = imageList.size();
+		count += Interpreter.getBatchModeImageCount();
+		if (count==0 && getCurrentImage()!=null)
+			count = 1;
+		return count;
+	}
+
+	/** Returns the front most window or null. */
+	public static Window getActiveWindow() {
+		return frontWindow;
+	}
+
+	/** Returns the Window containing the active table, or null.
+	 * @see ij.measure.ResultsTable#getActiveTable
+	*/
+	public static Window getActiveTable() {
+		return frontTable;
+	}
+
+	/** Obsolete; replaced by getActiveWindow. */
+	public static Frame getFrontWindow() {
+		return frontFrame;
+	}
+
+	/** Returns a list of the IDs of open images. Returns
+		null if no image windows are open. */
+	public synchronized static int[] getIDList() {
+		int nWindows = imageList.size();
+		int[] batchModeImages = Interpreter.getBatchModeImageIDs();
+		int nBatchImages = batchModeImages.length;
+		if ((nWindows+nBatchImages)==0)
+			return null;
+		int[] list = new int[nWindows+nBatchImages];
+		for (int i=0; i<nBatchImages; i++)
+			list[i] = batchModeImages[i];
+		int index = 0;
+		for (int i=nBatchImages; i<nBatchImages+nWindows; i++) {
+			ImageWindow win = (ImageWindow)imageList.get(index++);
+			list[i] = win.getImagePlus().getID();
+		}
+		return list;
+	}
+
+	/** Returns a list of the titles of all open images. */
+	public synchronized static String[] getImageTitles() {
+		int[] list = getIDList();
+		if (list==null)
+			return new String[0];
+		String[] titles = new String[list.length];
+		for (int i=0; i<list.length; i++) {
+			ImagePlus img = getImage(list[i]);
+			titles[i] = img.getTitle();
+		}
+		return titles;
+	}
+
+	/** Returns an array containing a list of the non-image Frames. */
+	public synchronized static Frame[] getNonImageWindows() {
+		ArrayList list = new ArrayList();
+		for (int i=0; i<nonImageList.size(); i++) {
+			Object win = nonImageList.get(i);
+			if (win instanceof Frame)
+				list.add(win);
+		}
+		Frame[] frames = new Frame[list.size()];
+		list.toArray(frames);
+		return frames;
+	}
+
+	/** Returns an array containing a list of the non-image Frames and Dialogs. */
+	public synchronized static Window[] getAllNonImageWindows() {
+		ArrayList list = new ArrayList();
+		for (int i=0; i<nonImageList.size(); i++) {
+			Object win = nonImageList.get(i);
+			if (win instanceof Window)
+				list.add(win);
+		}
+		Window[] windows = new Window[list.size()];
+		list.toArray(windows);
+		return windows;
+	}
+
+	/** Returns an array containing the titles of non-image Frames and Dialogs. */
+	public synchronized static String[] getNonImageTitles() {
+		ArrayList list = new ArrayList();
+		for (int i=0; i<nonImageList.size(); i++) {
+			Object win = nonImageList.get(i);
+			String title = win instanceof Frame?((Frame)win).getTitle():((Dialog)win).getTitle();
+			list.add(title);
+		}
+		String[] titles = new String[list.size()];
+		list.toArray(titles);
+		return titles;
+	}
+
+	/** For IDs less than zero, returns the ImagePlus with the specified ID. 
+		Returns null if no open window has a matching ID or no images are open. 
+		For IDs greater than zero, returns the Nth ImagePlus. Returns null if 
+		the ID is zero. */
+	public synchronized static ImagePlus getImage(int imageID) {
+		if (imageID>0)
+			imageID = getNthImageID(imageID);
+		if (imageID==0 || getImageCount()==0)
+			return null;
+		ImagePlus imp2 = Interpreter.getBatchModeImage(imageID);
+		if (imp2!=null)
+			return imp2;
+		ImagePlus imp = null;
+		for (int i=0; i<imageList.size(); i++) {
+			ImageWindow win = (ImageWindow)imageList.get(i);
+			imp2 = win.getImagePlus();
+			if (imageID==imp2.getID()) {
+				imp = imp2;
+				break;
+			}
+		}
+		imp2 = getCurrentImage();
+		if (imp==null &&imp2!=null && imp2.getID()==imageID)
+			return imp2;
+		return imp;
+	}
+	
+	/** Returns the ID of the Nth open image. Returns zero if n<=0 
+		or n greater than the number of open image windows. */
+	public synchronized static int getNthImageID(int n) {
+			if (n<=0) return 0;
+            if (Interpreter.isBatchMode()) {
+                int[] list = getIDList();
+                if (n>list.length)
+                	return 0;
+                else
+                	return list[n-1];
+            } else {
+            	if (n>imageList.size()) return 0;
+                ImageWindow win = (ImageWindow)imageList.get(n-1);
+                if (win!=null)
+                    return win.getImagePlus().getID();
+                else
+                    return 0;
+            }
+	}
+
+	
+	/** Returns the first image that has the specified title or null if it is not found. */
+	public synchronized static ImagePlus getImage(String title) {
+		int[] wList = getIDList();
+		if (wList==null) return null;
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp = getImage(wList[i]);
+			if (imp!=null && imp.getTitle().equals(title))
+				return imp;
+		}
+		return null;
+	}
+
+	/** Adds the specified window to the Window menu. */
+	public synchronized static void addWindow(Window win) {
+		if (win==null)
+			return;
+		else if (win instanceof ImageWindow)
+			addImageWindow((ImageWindow)win);
+		else {
+			Menus.insertWindowMenuItem(win);
+			nonImageList.add(win);
+ 		}
+    }
+
+	/** Adds the specified Frame to the Window menu. */
+	public static void addWindow(Frame win) {
+		addWindow((Window)win);
+	}
+
+	private static void addImageWindow(ImageWindow win) {
+		ImagePlus imp = win.getImagePlus();
+		if (imp==null) return;
+		checkForDuplicateName(imp);
+		imageList.add(win);
+        Menus.addWindowMenuItem(imp);
+        setCurrentWindow(win);
+    }
+    
+	static void checkForDuplicateName(ImagePlus imp) {
+		if (checkForDuplicateName) {
+			String name = imp.getTitle();
+			if (isDuplicateName(name))
+				imp.setTitle(getUniqueName(name));
+		} 
+		checkForDuplicateName = false;
+    }
+
+	static boolean isDuplicateName(String name) {
+		if (name==null)
+			return false;
+		int n = imageList.size();
+		for (int i=0; i<n; i++) {
+			ImageWindow win = (ImageWindow)imageList.get(i);
+			String name2 = win.getImagePlus().getTitle();
+			if (name.equals(name2))
+				return true;
+		}
+		return false;
+	}
+	
+	/*
+	static boolean isDuplicateBatchModeName(String name) {
+		int[] list = getIDList();
+		for (int i=0; i<list.length; i++) {
+			ImagePlus imp = getImage(list[i]);
+
+			if (imp==null) return false;
+			String name2 = imp.getTitle();
+			if (name.equals(name2))
+				return true;
+		}
+		return false;
+	}
+	*/
+
+	/** Returns a unique name by adding, before the extension,  -1, -2, etc. as needed. */
+	public static String getUniqueName(String name) {
+		return getUniqueName(null, name);
+	}
+
+	public static String getUniqueName(ImagePlus imp, String name) {
+        String name2 = name;
+        String extension = "";
+        int len = name2.length();
+        int lastDot = name2.lastIndexOf(".");
+        if (lastDot!=-1 && len-lastDot<6 && lastDot!=len-1) {
+            extension = name2.substring(lastDot, len);
+            name2 = name2.substring(0, lastDot);
+        }
+        int lastDash = name2.lastIndexOf("-");
+        len = name2.length();
+        if (imp!=null && imp.getProp("UniqueName")==null)
+        	lastDash = -1;
+        if (lastDash!=-1&&len-lastDash<4&&lastDash<len-1&&Character.isDigit(name2.charAt(lastDash+1))&&name2.charAt(lastDash+1)!='0')
+            name2 = name2.substring(0, lastDash);
+        for (int i=1; i<=99; i++) {
+            String name3 = name2+"-"+ i + extension;
+            if (!isDuplicateName(name3))
+                return name3;
+        }
+        return name;
+	}
+
+	/** If 'name' is not unique, adds -1, -2, etc. as needed to make it unique. */
+	public static String makeUniqueName(String name) {
+    	return isDuplicateName(name)?getUniqueName(name):name;
+    }
+
+	/** Removes the specified window from the Window menu. */
+	public static void removeWindow(Window win) {
+		if (win instanceof ImageWindow)
+			removeImageWindow((ImageWindow)win);
+		else {
+			int index = nonImageList.indexOf(win);
+			ImageJ ij = IJ.getInstance();
+			if (index>=0) {
+				Menus.removeWindowMenuItem(index);
+				nonImageList.removeElement(win);
+			}
+			if (win!=null && win==frontTable)
+				frontTable = null;
+		}
+		setWindow(null);
+	}
+
+	/** Removes the specified Frame from the Window menu. */
+	public static void removeWindow(Frame win) {
+		removeWindow((Window)win);
+	}
+
+	private static void removeImageWindow(ImageWindow win) {
+		int index = imageList.indexOf(win);
+		if (index==-1)
+			return;  // not on the window list
+		try {
+			synchronized(WindowManager.class) {
+				imageList.remove(win);
+			}
+			activations.remove(win);
+			if (imageList.size()>1 && !Prefs.closingAll) {
+				ImageWindow win2 = activations.size()>0?(ImageWindow)activations.get(activations.size()-1):null;
+				setCurrentWindow(win2);
+			} else
+				currentWindow = null;
+			setTempCurrentImage(null);  //???
+			int nonImageCount = nonImageList.size();
+			if (nonImageCount>0)
+				nonImageCount++;
+			Menus.removeWindowMenuItem(nonImageCount+index);
+			Menus.updateMenus();
+			Undo.reset();
+		}  catch (Exception e) { }
+	}
+
+	/** The specified Window becomes the front window. */
+	public static void setWindow(Window win) {
+		//System.out.println("setWindow(W): "+win);
+		frontWindow = win;
+		if (win instanceof Frame)
+			frontFrame = (Frame)win;
+    }
+
+	/** The specified frame becomes the front window, the one returnd by getFrontWindow(). */
+	public static void setWindow(Frame win) {
+		frontWindow = win;
+		frontFrame = win;
+		if (win!=null && win instanceof TextWindow && !(win instanceof Editor) && !"Log".equals(((TextWindow)win).getTitle()))
+			frontTable = win;
+		//System.out.println("Set window(F): "+(win!=null?win.getTitle():"null"));
+    }
+    
+	/** Closes all windows. Stops and returns false if an image or Editor "save changes" dialog is canceled. */
+	public synchronized static boolean closeAllWindows() {
+		Prefs.closingAll = true;
+		while (imageList.size()>0) {
+			if (!((ImageWindow)imageList.get(0)).close()) {
+				Prefs.closingAll = false;
+				return false;
+			}
+			if (!quittingViaMacro())
+				IJ.wait(100);
+		}
+		Prefs.closingAll = false;
+		Frame[] nonImages = getNonImageWindows();
+		for (int i=0; i<nonImages.length; i++) {
+			Frame frame = nonImages[i];
+			if (frame!=null && frame instanceof Commands)
+				((Commands)frame).close();
+			else if (frame!=null && (frame instanceof Editor)) {
+				((Editor)frame).close();
+				if (((Editor)frame).fileChanged())
+					return false;
+				if (!quittingViaMacro())
+					IJ.wait(100);
+			}
+		}
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null && ij.quitting() && IJ.getApplet()==null)
+			return true;
+		for (int i=0; i<nonImages.length; i++) {
+			Frame frame = nonImages[i];
+			if ((frame instanceof PlugInFrame) && !(frame instanceof Editor))
+				((PlugInFrame)frame).close();
+			else if (frame instanceof TextWindow)
+				((TextWindow)frame).close();
+			else {
+				//frame.setVisible(false);
+				frame.dispose();
+			}
+		}
+		return true;
+    }
+    
+    private static boolean quittingViaMacro() {
+    	ImageJ ij = IJ.getInstance();
+    	return ij!=null && ij.quittingViaMacro();
+    }
+    
+	/** Activates the next image window on the window list. */
+	public static void putBehind() {
+		if (IJ.debugMode) IJ.log("putBehind");
+		if (imageList.size()<1 || currentWindow==null)
+			return;
+		int index = imageList.indexOf(currentWindow);
+		ImageWindow win = null;
+		int count = 0;
+		do {
+			index--;
+			if (index<0) index = imageList.size()-1;
+			win = (ImageWindow)imageList.get(index);
+			if (++count==imageList.size()) return;
+		} while (win instanceof HistogramWindow || win instanceof PlotWindow);
+		if (win==null) return;
+		ImagePlus imp = win.getImagePlus();
+		if (imp!=null)
+			IJ.selectWindow(imp.getID());
+    }
+
+	/** Returns the temporary current image for this thread, or null. */
+	public static ImagePlus getTempCurrentImage() {
+		return (ImagePlus)tempImageTable.get(Thread.currentThread()); 
+	}
+
+    /** Returns the window (a Frame or a Dialog) with the specified
+    	  title,  or null if a window with that title is not found. */
+    public static Window getWindow(String title) {
+		for (int i=0; i<nonImageList.size(); i++) {
+			Object win = nonImageList.get(i);
+			String winTitle = win instanceof Frame?((Frame)win).getTitle():((Dialog)win).getTitle();
+			if (title.equals(winTitle))
+				return (Window)win;
+		}
+		return getImageWindow(title);
+    }
+
+    /** Obsolete; replaced by getWindow(). */
+    public static Frame getFrame(String title) {
+		for (int i=0; i<nonImageList.size(); i++) {
+			Object win = nonImageList.get(i);
+			String winTitle = win instanceof Frame?((Frame)win).getTitle():null;
+			if (title.equals(winTitle))
+				return (Frame)win;
+		}
+		Frame frame = getImageWindow(title);
+		if (frame==null) {
+			Window win = getWindow(title);
+			if (win!=null)
+				frame = new Frame("Proxy");
+		}
+		return frame;
+    }
+    
+    private static Frame getImageWindow(String title) {
+		int[] wList = getIDList();
+		int len = wList!=null?wList.length:0;
+		for (int i=0; i<len; i++) {
+			ImagePlus imp = getImage(wList[i]);
+			if (imp!=null) {
+				if (imp.getTitle().equals(title))
+					return imp.getWindow();
+			}
+		}
+		return null;
+    }
+
+	/** Activates a window selected from the Window menu. */
+	synchronized static void activateWindow(String menuItemLabel, MenuItem item) {
+		for (int i=0; i<nonImageList.size(); i++) {
+			Object win = nonImageList.get(i);
+			String title = win instanceof Frame?((Frame)win).getTitle():((Dialog)win).getTitle();
+			if (menuItemLabel.equals(title)) {
+				if (win instanceof Frame)
+					toFront((Frame)win);
+				else
+					((Dialog)win).toFront();
+				((CheckboxMenuItem)item).setState(false);
+				if (Recorder.record && !IJ.isMacro())
+					Recorder.record("selectWindow", title);
+				return;
+			}
+		}
+		int lastSpace = menuItemLabel.lastIndexOf(' ');
+		if (lastSpace>0) // remove image size (e.g., " 90K")
+		menuItemLabel = menuItemLabel.substring(0, lastSpace);
+		String idString = item.getActionCommand();
+		int id = (int)Tools.parseDouble(idString, 0);
+		ImagePlus imp = WindowManager.getImage(id);
+		if (imp==null) return;
+		ImageWindow win1 = imp.getWindow();
+		if (win1==null) return;
+		setCurrentWindow(win1);
+		toFront(win1);
+		int index = imageList.indexOf(win1);
+		int n = Menus.window.getItemCount();
+		int start = Menus.WINDOW_MENU_ITEMS+Menus.windowMenuItems2;
+		for (int j=start; j<n; j++) {
+			MenuItem mi = Menus.window.getItem(j);
+			if (mi instanceof CheckboxMenuItem)
+				((CheckboxMenuItem)mi).setState((j-start)==index);						
+		}
+	}
+    
+    /** Repaints all open image windows. */
+    public synchronized static void repaintImageWindows() {
+		int[] list = getIDList();
+		if (list==null) return;
+		for (int i=0; i<list.length; i++) {
+			ImagePlus imp2 = getImage(list[i]);
+			if (imp2!=null) {
+				imp2.setTitle(imp2.getTitle()); // update "(G)" flag (global calibration)
+				ImageWindow win = imp2.getWindow();
+				if (win!=null) win.repaint();
+			}
+		}
+	}
+    
+	public static void showList() {
+		for (int i=0; i<imageList.size(); i++) {
+			ImageWindow win = (ImageWindow)imageList.get(i);
+			ImagePlus imp = win.getImagePlus();
+			IJ.log(i + " " + imp.getTitle() + (win==currentWindow?"*":"")+" "+imp.getID());
+		}
+		for (int i=0; i<activations.size(); i++) {
+			ImageWindow win = (ImageWindow)activations.get(i);
+			ImagePlus imp = win.getImagePlus();
+			IJ.log(i + " " + imp.getTitle() + " " + imp.getID());
+		}
+		if (imageList.size()==0) IJ.log("imageList is empty");
+		if (activations.size()==0) IJ.log("activations list is empty");
+		IJ.log(" ");
+    }
+    
+    public static void toFront(Frame frame) {
+		if (frame==null) return;
+		if (frame.getState()==Frame.ICONIFIED)
+			frame.setState(Frame.NORMAL);
+		frame.toFront();
+	}
+	
+	public static void toFront(Window window) {
+		if (window==null) return;
+		if (window instanceof Frame && ((Frame)window).getState()==Frame.ICONIFIED)
+			((Frame)window).setState(Frame.NORMAL);
+		window.toFront();
+	}
+	    
+}
diff --git a/src/ij/gui/Arrow.java b/src/ij/gui/Arrow.java
new file mode 100644
index 0000000..1580b1f
--- /dev/null
+++ b/src/ij/gui/Arrow.java
@@ -0,0 +1,393 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import java.awt.*;
+import java.awt.geom.*;
+
+
+/** This is an Roi subclass for creating and displaying arrows. */
+public class Arrow extends Line {
+	public static final String STYLE_KEY = "arrow.style";
+	public static final String WIDTH_KEY = "arrow.width";
+	public static final String SIZE_KEY = "arrow.size";
+	public static final String DOUBLE_HEADED_KEY = "arrow.double";
+	public static final String OUTLINE_KEY = "arrow.outline";
+	public static final int FILLED=0, NOTCHED=1, OPEN=2, HEADLESS=3, BAR=4;
+	public static final String[] styles = {"Filled", "Notched", "Open", "Headless", "Bar"};
+	private static int defaultStyle = (int)Prefs.get(STYLE_KEY, FILLED);
+	private static float defaultWidth = (float)Prefs.get(WIDTH_KEY, 2);
+	private static double defaultHeadSize = (int)Prefs.get(SIZE_KEY, 10);  // 0-30;
+	private static boolean defaultDoubleHeaded = Prefs.get(DOUBLE_HEADED_KEY, false);
+	private static boolean defaultOutline = Prefs.get(OUTLINE_KEY, false);
+	private int style;
+	private double headSize = 10;  // 0-30
+	private boolean doubleHeaded;
+	private boolean outline;
+	private float[] points = new float[2*5];
+	private GeneralPath path = new GeneralPath();
+	private static Stroke defaultStroke = new BasicStroke();
+	double headShaftRatio;
+	
+	static {
+		if (defaultStyle<FILLED || defaultStyle>HEADLESS)
+			defaultStyle = FILLED;
+	}
+
+	public Arrow(double ox1, double oy1, double ox2, double oy2) {
+		super(ox1, oy1, ox2, oy2);
+		setStrokeWidth(2);
+	}
+
+	public Arrow(int sx, int sy, ImagePlus imp) {
+		super(sx, sy, imp);
+		setStrokeWidth(defaultWidth);
+		style = defaultStyle;
+		headSize = defaultHeadSize;
+		doubleHeaded = defaultDoubleHeaded;
+		outline = defaultOutline;
+		setStrokeColor(Toolbar.getForegroundColor());
+	}
+
+	/** Draws this arrow on the image. */
+	public void draw(Graphics g) {
+		Shape shape2 = null;
+		if (doubleHeaded) {
+			flipEnds();
+			shape2 = getShape();
+			flipEnds();
+		}
+		Shape shape = getShape();
+		Color color =  strokeColor!=null? strokeColor:ROIColor;
+		if (fillColor!=null) color = fillColor;
+		g.setColor(color);
+		Graphics2D g2 = (Graphics2D)g;
+		setRenderingHint(g2);
+		AffineTransform at = g2.getDeviceConfiguration().getDefaultTransform();
+		double mag = getMagnification();
+		int xbase=0, ybase=0;
+		if (ic!=null) {
+			Rectangle r = ic.getSrcRect();
+			xbase = r.x; ybase = r.y;
+		}
+		at.setTransform(mag, 0.0, 0.0, mag, (-xbase+0.5)*mag, (-ybase+0.5)*mag); //0.5: int coordinate at pixel center
+		if (outline) {
+			float lineWidth = (float)(getOutlineWidth()*mag);
+			g2.setStroke(new BasicStroke(lineWidth, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND));
+			g2.draw(at.createTransformedShape(shape));
+			if (doubleHeaded) g2.draw(at.createTransformedShape(shape2));
+			g2.setStroke(defaultStroke);
+		} else  {
+			g2.fill(at.createTransformedShape(shape));
+			if (doubleHeaded) g2.fill(at.createTransformedShape(shape2));
+		}
+		if (!overlay) {
+			handleColor=Color.white;
+			drawHandle(g, screenXD(x1d), screenYD(y1d));
+			drawHandle(g, screenXD(x2d), screenYD(y2d));
+			drawHandle(g, screenXD(x1d+(x2d-x1d)/2.0), screenYD(y1d+(y2d-y1d)/2.0));
+		}
+		if (state!=NORMAL && imp!=null && imp.getRoi()!=null)
+			showStatus();
+		if (updateFullWindow) 
+			{updateFullWindow = false; imp.draw();}
+	}
+		
+	private void flipEnds() {
+		double tmp = x1R;
+		x1R=x2R;
+		x2R=tmp;
+		tmp=y1R;
+		y1R=y2R;
+		y2R=tmp;
+	}
+	
+	private Shape getPath() {
+		path.reset();
+		path = new GeneralPath();
+		calculatePoints();
+		float tailx = points[0];
+		float taily = points[1];
+		float headbackx = points[2*1];
+		float headbacky = points[2*1+1];
+		float headtipx = points[2*3];
+		float headtipy = points[2*3+1];
+		if (outline) {
+			double dx = headtipx - tailx;
+			double dy = headtipy - taily;
+			double shaftLength = Math.sqrt(dx*dx+dy*dy);
+			dx = headtipx - headbackx;
+			dy = headtipy- headbacky;
+			double headLength = Math.sqrt(dx*dx+dy*dy);
+			headShaftRatio = headLength/shaftLength;
+			if (headShaftRatio>1.0)
+				headShaftRatio = 1.0;
+			//IJ.log(headShaftRatio+" "+(int)shaftLength+" "+(int)headLength+" "+(int)tailx+" "+(int)taily+" "+(int)headtipx+" "+(int)headtipy);
+		}
+		path.moveTo(tailx, taily); // tail
+		path.lineTo(headbackx, headbacky); // head back
+		path.moveTo(headbackx, headbacky); // head back
+		if (style==OPEN)
+			path.moveTo(points[2 * 2], points[2 * 2 + 1]);
+		else
+			path.lineTo(points[2 * 2], points[2 * 2 + 1]); // left point
+		path.lineTo(headtipx, headtipy); // head tip
+		path.lineTo(points[2 * 4], points[2 * 4 + 1]); // right point
+		path.lineTo(headbackx, headbacky); // back to the head back
+		return path;
+	}
+
+	 /** Based on the method with the same name in Fiji's Arrow plugin,
+	 	written by Jean-Yves Tinevez and Johannes Schindelin. */
+	 private void calculatePoints() {
+		double tip = 0.0;
+		double base;
+		double shaftWidth = getStrokeWidth();
+		double length = 8+10*shaftWidth*0.5;
+		length = length*(headSize/10.0);
+		length -= shaftWidth*1.42;
+		if (style==NOTCHED) length*=0.74;
+		if (style==OPEN) length*=1.32;
+		if (length<0.0 || style==HEADLESS) length=0.0;
+		double x = getXBase();
+		double y = getYBase();
+		x1d=x+x1R; y1d=y+y1R; x2d=x+x2R; y2d=y+y2R;
+		x1=(int)x1d; y1=(int)y1d; x2=(int)x2d; y2=(int)y2d;
+		double dx=x2d-x1d, dy=y2d-y1d;
+		double arrowLength = Math.sqrt(dx*dx+dy*dy);
+		dx=dx/arrowLength; dy=dy/arrowLength;
+		if (doubleHeaded && style!=HEADLESS) {
+			points[0] = (float)(x1d+dx*shaftWidth*2.0);
+			points[1] = (float)(y1d+dy*shaftWidth*2.0);
+		} else {
+			points[0] = (float)x1d;
+			points[1] = (float)y1d;
+		}
+        if (length>0) {
+			double factor = style==OPEN?1.3:1.42;
+			points[2*3] = (float)(x2d-dx*shaftWidth*factor);
+			points[2*3+1] = (float)(y2d-dy*shaftWidth*factor);
+			if (style==BAR) {
+				points[2*3] = (float)(x2d-dx*shaftWidth*0.5);
+				points[2*3+1] = (float)(y2d-dy*shaftWidth*0.5);
+			}
+		} else {
+			points[2*3] = (float)x2d;
+			points[2*3+1] = (float)y2d;
+		}
+		final double alpha = Math.atan2(points[2*3+1]-points[1], points[2*3]-points[0]);
+		double SL = 0.0;
+		switch (style) {
+			case FILLED: case HEADLESS:
+				tip = Math.toRadians(20.0);
+				base = Math.toRadians(90.0);
+				points[1*2]   = (float) (points[2*3]	- length*Math.cos(alpha));
+				points[1*2+1] = (float) (points[2*3+1] - length*Math.sin(alpha));
+				SL = length*Math.sin(base)/Math.sin(base+tip);;
+				break;
+			case NOTCHED:
+				tip = Math.toRadians(20);
+				base = Math.toRadians(120);
+				points[1*2]   = (float) (points[2*3] - length*Math.cos(alpha));
+				points[1*2+1] = (float) (points[2*3+1] - length*Math.sin(alpha));
+				SL = length*Math.sin(base)/Math.sin(base+tip);;
+				break;
+			case OPEN:
+				tip = Math.toRadians(25); //30
+				points[1*2] = points[2*3];
+				points[1*2+1] = points[2*3+1];
+				SL = length;
+				break;
+			case BAR:
+				tip = Math.toRadians(90); //30
+				points[1*2] = points[2*3];
+				points[1*2+1] = points[2*3+1];
+				SL = length;
+				updateFullWindow = true;
+				break;       
+		}
+		// P2 = P3 - SL*alpha+tip
+		points[2*2] = (float) (points[2*3]	- SL*Math.cos(alpha+tip));
+		points[2*2+1] = (float) (points[2*3+1] - SL*Math.sin(alpha+tip));
+		// P4 = P3 - SL*alpha-tip
+		points[2*4]   = (float) (points[2*3]	- SL*Math.cos(alpha-tip));
+		points[2*4+1] = (float) (points[2*3+1] - SL*Math.sin(alpha-tip));
+ 	}
+ 	
+	private Shape getShape() {
+		Shape arrow = getPath();
+		BasicStroke stroke = new BasicStroke((float)getStrokeWidth(), BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER);
+		Shape outlineShape = stroke.createStrokedShape(arrow);
+		Area a1 = new Area(arrow);
+		Area a2 = new Area(outlineShape);
+		try {a1.add(a2);} catch(Exception e) {};
+		return a1;
+	}
+
+	private ShapeRoi getShapeRoi() {
+		Shape arrow = getPath();
+		BasicStroke stroke = new BasicStroke(getStrokeWidth(), BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER);
+		ShapeRoi sroi = new ShapeRoi(arrow);
+		Shape outlineShape = stroke.createStrokedShape(arrow);
+		sroi.or(new ShapeRoi(outlineShape));
+		return sroi;
+	}
+
+	public ImageProcessor getMask() {
+		if (width==0 && height==0)
+			return null;
+		else
+			return getShapeRoi().getMask();
+	}
+
+	private double getOutlineWidth() {
+		double width = getStrokeWidth()/8.0;
+		double head = headSize/7.0;
+		double lineWidth = width + head + headShaftRatio;
+		if (lineWidth<1.0) lineWidth = 1.0;
+		//if (width<1) width=1;
+		//if (head<1) head=1;
+		//IJ.log(getStrokeWidth()+"  "+IJ.d2s(width,2)+"  "+IJ.d2s(head,2)+"  "+IJ.d2s(headShaftRatio,2)+"  "+IJ.d2s(lineWidth,2)+"  "+IJ.d2s(width*head,2));
+		return lineWidth;
+	}
+	
+	public void drawPixels(ImageProcessor ip) {
+		ShapeRoi shapeRoi = getShapeRoi();
+		ShapeRoi shapeRoi2 = null;
+		if (doubleHeaded) {
+			flipEnds();
+			shapeRoi2 = getShapeRoi();
+			flipEnds();
+		}
+		if (outline) {
+			int lineWidth = ip.getLineWidth();
+			ip.setLineWidth((int)Math.round(getOutlineWidth()));
+			shapeRoi.drawPixels(ip);
+			if (doubleHeaded) shapeRoi2.drawPixels(ip);
+			ip.setLineWidth(lineWidth);
+		} else {
+			ip.fill(shapeRoi);
+			if (doubleHeaded) ip.fill(shapeRoi2);
+		}
+	}
+	
+	public boolean contains(int x, int y) {
+		return getShapeRoi().contains(x, y);
+	}
+
+	/** Return the bounding rectangle of this arrow. */
+	public Rectangle getBounds() {
+		return getShapeRoi().getBounds();
+	}
+
+	protected void handleMouseDown(int sx, int sy) {
+		super.handleMouseDown(sx, sy);
+		startxd = ic!=null?ic.offScreenXD(sx):sx;
+		startyd = ic!=null?ic.offScreenYD(sy):sy;
+	}
+
+	protected int clipRectMargin() {
+		double mag = getMagnification();
+		double arrowWidth = getStrokeWidth();
+		double size = 8+10*arrowWidth*mag*0.5;
+		return (int)Math.max(size*2.0, headSize);
+	}
+			
+	public boolean isDrawingTool() {
+		return true;
+	}
+	
+	public static void setDefaultWidth(double width) {
+		defaultWidth = (float)width;
+	}
+
+	public static double getDefaultWidth() {
+		return defaultWidth;
+	}
+
+	public void setStyle(int style) {
+		this.style = style;
+	}
+	
+	/* Set the style, where 'style' is "filled", "notched", "open", "headless" or "bar",
+		plus optionial modifiers of "outline", "double", "small", "medium" and "large". */
+	public void setStyle(String style) {
+		style = style.toLowerCase();
+		int newStyle = Arrow.FILLED;
+		if (style.contains("notched"))
+			newStyle = Arrow.NOTCHED;
+		else if (style.contains("open"))
+			newStyle = Arrow.OPEN;
+		else if (style.contains("headless"))
+			newStyle = Arrow.HEADLESS;
+		else if (style.contains("bar"))
+			newStyle = Arrow.BAR;
+		setStyle(newStyle);
+		setOutline(style.contains("outline"));
+		setDoubleHeaded(style.contains("double"));
+		if (style.contains("small"))
+			setHeadSize(5);
+		else if (style.contains("large"))
+			setHeadSize(15);
+	}
+
+	public int getStyle() {
+		return style;
+	}
+
+	public static void setDefaultStyle(int style) {
+		defaultStyle = style;
+	}
+
+	public static int getDefaultStyle() {
+		return defaultStyle;
+	}
+
+	public void setHeadSize(double headSize) {
+		this.headSize = headSize;
+	}
+
+	public double getHeadSize() {
+		return headSize;
+	}
+
+	public static void setDefaultHeadSize(double size) {
+		defaultHeadSize = size;
+	}
+
+	public static double getDefaultHeadSize() {
+		return defaultHeadSize;
+	}
+
+	public void setDoubleHeaded(boolean b) {
+		doubleHeaded = b;
+	}
+
+	public boolean getDoubleHeaded() {
+		return doubleHeaded;
+	}
+
+	public static void setDefaultDoubleHeaded(boolean b) {
+		defaultDoubleHeaded = b;
+	}
+
+	public static boolean getDefaultDoubleHeaded() {
+		return defaultDoubleHeaded;
+	}
+
+	public void setOutline(boolean b) {
+		outline = b;
+	}
+
+	public boolean getOutline() {
+		return outline;
+	}
+
+	public static void setDefaultOutline(boolean b) {
+		defaultOutline = b;
+	}
+
+	public static boolean getDefaultOutline() {
+		return defaultOutline;
+	}
+
+}
diff --git a/src/ij/gui/ColorChooser.java b/src/ij/gui/ColorChooser.java
new file mode 100644
index 0000000..d5764bf
--- /dev/null
+++ b/src/ij/gui/ColorChooser.java
@@ -0,0 +1,121 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.util.*;
+import ij.plugin.Colors;
+import java.awt.*;
+import java.util.Vector;
+import java.awt.event.*;
+
+
+ /** Displays a dialog that allows the user to select a color using three sliders. */
+public class ColorChooser implements TextListener, AdjustmentListener {
+	Vector colors, sliders;
+	ColorPanel panel;
+	Color initialColor;
+	int red, green, blue;
+	boolean useHSB;
+	String title;
+	Frame frame;
+	double scale = Prefs.getGuiScale();
+
+	/** Constructs a ColorChooser using the specified title and initial color. */
+	public ColorChooser(String title, Color initialColor, boolean useHSB) {
+		this(title, initialColor, useHSB, null);
+	}
+	
+	public ColorChooser(String title, Color initialColor, boolean useHSB, Frame frame) {
+		this.title = title;
+		if (initialColor==null) initialColor = Color.black;
+		this.initialColor = initialColor;
+		red = initialColor.getRed();
+		green = initialColor.getGreen();
+		blue = initialColor.getBlue();
+		this.useHSB = useHSB;
+		this.frame = frame;
+	}
+
+	/** Displays a color selection dialog and returns the color selected by the user. */
+	public Color getColor() {
+		GenericDialog gd = frame!=null?new GenericDialog(title, frame):new GenericDialog(title);
+		gd.addSlider("Red:", 0, 255, red);
+		gd.addSlider("Green:", 0, 255, green);
+		gd.addSlider("Blue:", 0, 255, blue);
+		panel = new ColorPanel(initialColor, scale);
+		gd.addPanel(panel, GridBagConstraints.CENTER, new Insets(10, 0, 0, 0));
+		colors = gd.getNumericFields();
+		for (int i=0; i<colors.size(); i++)
+			((TextField)colors.elementAt(i)).addTextListener(this);
+		sliders = gd.getSliders();
+		for (int i=0; i<sliders.size(); i++)
+			((Scrollbar)sliders.elementAt(i)).addAdjustmentListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled()) return null;
+		int red = (int)gd.getNextNumber();
+		int green = (int)gd.getNextNumber();
+		int blue = (int)gd.getNextNumber();
+		return new Color(red, green, blue);
+	}
+
+	public void textValueChanged(TextEvent e) {
+		int red = (int)Tools.parseDouble(((TextField)colors.elementAt(0)).getText());
+		int green = (int)Tools.parseDouble(((TextField)colors.elementAt(1)).getText());
+		int blue = (int)Tools.parseDouble(((TextField)colors.elementAt(2)).getText());
+		if (red<0) red=0; if (red>255) red=255;
+		if (green<0) green=0; if (green>255) green=255;
+		if (blue<0) blue=0; if (blue>255) blue=255;
+		panel.setColor(new Color(red, green, blue));
+		panel.repaint();
+	}
+
+	public synchronized void adjustmentValueChanged(AdjustmentEvent e) {
+		Object source = e.getSource();
+		for (int i=0; i<sliders.size(); i++) {
+			if (source==sliders.elementAt(i)) {
+				Scrollbar sb = (Scrollbar)source;
+				TextField tf = (TextField)colors.elementAt(i);
+			}
+		}
+	}
+
+}
+
+class ColorPanel extends Panel {
+	private int width=150, height=50;
+	private Font font;
+	private Color c;
+	 
+	ColorPanel(Color c, double scale) {
+		this.c = c;
+		width = (int)(width*scale);
+		height = (int)(height*scale);
+		font = new Font("Monospaced", Font.PLAIN, (int)(18*scale));
+	}
+
+	public Dimension getPreferredSize() {
+		return new Dimension(width, height);
+	}
+
+	void setColor(Color c) {
+		this.c = c;
+	}
+
+	public Dimension getMinimumSize() {
+		return new Dimension(width, height);
+	}
+
+	public void paint(Graphics g) {
+		g.setColor(c);
+		g.fillRect(0, 0, width, height);
+		int intensity = (c.getRed()+c.getGreen()+c.getBlue())/3;
+		Color c2 = intensity<128?Color.white:Color.black;
+		g.setColor(c2);
+		g.setFont(font);
+		Java2.setAntialiasedText(g, true);
+		String s = Colors.colorToString(c);
+		g.drawString(s, 5, height-5);
+		g.setColor(Color.black);
+		g.drawRect(0, 0, width-1, height-1);
+	}
+
+}
diff --git a/src/ij/gui/DialogListener.java b/src/ij/gui/DialogListener.java
new file mode 100644
index 0000000..cc29920
--- /dev/null
+++ b/src/ij/gui/DialogListener.java
@@ -0,0 +1,35 @@
+package ij.gui;
+import ij.*;
+import java.awt.AWTEvent;
+
+/**
+* PlugIns or PlugInFilters that want to listen to changes in a GenericDialog
+* without adding listeners for each dialog field should implementthis method.
+* The dialogItemChanged method of a PlugIn or PlugInFilter can and should read
+* the various dialog items by the appropriate GenericDialog methods like
+* getNextNumber (items that are not read in the dialogItemChanged method will
+* not be recorded by the Macro recorder).
+*
+* The PlugIn or PlugInFilter has to be added to the GenericDialog by
+* its addDialogListener method:
+* gd.addDialogListener(this);
+*
+*/
+public interface DialogListener {
+
+    /**
+     * This method is invoked by a Generic Dialog if any of the inputs have changed
+     *  (CANCEL does not trigger it; OK and running the dialog from a macro only
+     *   trigger the first DialogListener added to a GenericDialog).
+     * 
+     * @param e   The event that has been generated by the user action in the dialog.
+     *            Note that <code>e</code> is <code>null</code> if the
+     *            dialogItemChanged method is called after the user has pressed the
+     *            OK button or if the GenericDialog has read its parameters from a
+     *            macro.
+     * @param gd  A reference to the GenericDialog.
+     * @return    Should be true if the dialog input is valid. False disables the
+     *              OK button and preview (if any).
+     */
+    boolean dialogItemChanged(GenericDialog gd, AWTEvent e);
+}
diff --git a/src/ij/gui/EllipseRoi.java b/src/ij/gui/EllipseRoi.java
new file mode 100644
index 0000000..9796a32
--- /dev/null
+++ b/src/ij/gui/EllipseRoi.java
@@ -0,0 +1,269 @@
+package ij.gui;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import ij.*;
+import ij.plugin.frame.Recorder;
+import ij.process.FloatPolygon;
+import ij.measure.Calibration;
+
+/** This class implements the ellipse selection tool. */
+public class EllipseRoi extends PolygonRoi {
+	private static final int vertices = 72;
+	private static double defaultRatio = 0.6;
+	private double xstart, ystart;
+	private double aspectRatio = defaultRatio;
+	private int[] handle = {0, vertices/4, vertices/2, vertices/2+vertices/4};
+
+	public EllipseRoi(double x1, double y1, double x2, double y2, double aspectRatio) {
+		super(new float[vertices], new float[vertices], vertices, FREEROI);
+		if (aspectRatio<0.0) aspectRatio = 0.0;
+		if (aspectRatio>1.0) aspectRatio = 1.0;
+		this.aspectRatio = aspectRatio;
+		makeEllipse(x1, y1, x2, y2);
+		state = NORMAL;
+		bounds = null;
+	}
+
+	public EllipseRoi(int sx, int sy, ImagePlus imp) {
+		super(sx, sy, imp);
+		type = FREEROI;
+		xstart = offScreenXD(sx);
+		ystart = offScreenYD(sy);
+		setDrawOffset(false);
+		bounds = null;
+	}
+
+	public void draw(Graphics g) {
+		super.draw(g);
+		if (!overlay) {
+			for (int i=0; i<handle.length; i++)
+				drawHandle(g, xp2[handle[i]], yp2[handle[i]]);
+		}
+	}
+
+	protected void grow(int sx, int sy) {
+		double x1 = xstart;
+		double y1 = ystart;
+		double x2 = offScreenXD(sx);
+		double y2 = offScreenYD(sy);
+		makeEllipse(x1, y1, x2, y2);
+		imp.draw();
+	}
+		
+	void makeEllipse(double x1, double y1, double x2, double y2) {
+		double centerX = (x1 + x2)/2.0;
+		double centerY = (y1 + y2)/2.0;
+		double dx = x2 - x1;
+		double dy = y2 - y1;
+		double major = Math.sqrt(dx*dx + dy*dy);
+		double minor = major*aspectRatio;
+		double phiB = Math.atan2(dy, dx);         
+		double alpha = phiB*180.0/Math.PI;
+		nPoints = 0;
+		for (int i=0; i<vertices; i++) {
+			double degrees = i*360.0/vertices;
+			double beta1 = degrees/180.0*Math.PI;
+			dx = Math.cos(beta1)*major/2.0;
+			dy = Math.sin(beta1)*minor/2.0;
+			double beta2 = Math.atan2(dy, dx);
+			double rad = Math.sqrt(dx*dx + dy*dy);
+			double beta3 = beta2+ alpha/180.0*Math.PI;
+			double dx2 = Math.cos(beta3)*rad;
+			double dy2 = Math.sin(beta3)*rad;
+			xpf[nPoints] = (float)(centerX+dx2);
+			ypf[nPoints] = (float)(centerY+dy2);
+			nPoints++;
+		}
+		makePolygonRelative();
+		cachedMask = null;
+		showStatus();
+	}
+	
+	public void showStatus() {
+		double[] p = getParams();
+		double dx = p[2] - p[0];
+		double dy = p[3] - p[1];
+		double major = Math.sqrt(dx*dx+dy*dy);
+		double minor = major*p[4];
+		double angle = getFloatAngle(p[0], p[1], p[2], p[3]);
+		if (imp!=null && !IJ.altKeyDown()) {
+			Calibration cal = imp.getCalibration();
+			if (cal.scaled()) {
+				dx *= cal.pixelWidth;
+				dy *= cal.pixelHeight;
+				major = Math.sqrt(dx*dx+dy*dy);
+				minor = major*p[4];
+			}
+		}
+		IJ.showStatus("major=" + IJ.d2s(major)+", minor=" + IJ.d2s(minor)+", angle=" + IJ.d2s(angle));
+	}
+
+	public void nudgeCorner(int key) {
+		if (ic==null) return;
+		double x1 = xpf[handle[2]]+x;
+		double y1 = ypf[handle[2]]+y;
+		double x2 = xpf[handle[0]]+x;
+		double y2 = ypf[handle[0]]+y;
+		double inc = 1.0/ic.getMagnification();
+		switch(key) {
+			case KeyEvent.VK_UP: y2-=inc; break;
+			case KeyEvent.VK_DOWN: y2+=inc; break;
+			case KeyEvent.VK_LEFT: x2-=inc; break;
+			case KeyEvent.VK_RIGHT: x2+=inc; break;
+		}
+		makeEllipse(x1, y1, x2, y2);
+		imp.draw();
+		notifyListeners(RoiListener.MOVED);
+		showStatus();
+	}
+
+	void makePolygonRelative() {
+		FloatPolygon poly = new FloatPolygon(xpf, ypf, nPoints);
+		Rectangle r = poly.getBounds();
+		x = r.x;
+		y = r.y;
+		width = r.width;
+		height = r.height;
+		for (int i=0; i<nPoints; i++) {
+			xpf[i] = xpf[i]-x;
+			ypf[i] = ypf[i]-y;
+		}
+	}
+	
+	protected void handleMouseUp(int screenX, int screenY) {
+		if (state==CONSTRUCTING) {
+			if (Recorder.record) {
+				double x1 = xpf[handle[2]]+x;
+				double y1 = ypf[handle[2]]+y;
+				double x2 = xpf[handle[0]]+x;
+				double y2 = ypf[handle[0]]+y;
+ 				if (Recorder.scriptMode())
+					Recorder.recordCall("imp.setRoi(new EllipseRoi("+x1+","+y1+","+x2+","+y2+","+IJ.d2s(aspectRatio,2)+"));");
+				else
+					Recorder.record("makeEllipse", (int)x1, (int)y1, (int)x2, (int)y2, aspectRatio);
+			}
+        }
+		state = NORMAL;
+		modifyRoi();
+	}
+	
+	protected void moveHandle(int sx, int sy) {
+		double ox = offScreenXD(sx); 
+		double oy = offScreenYD(sy);
+		double x1 = xpf[handle[2]]+x;
+		double y1 = ypf[handle[2]]+y;
+		double x2 = xpf[handle[0]]+x;
+		double y2 = ypf[handle[0]]+y;
+		switch(activeHandle) {
+			case 0: 
+				x2 = ox;
+				y2 = oy;
+				break;
+			case 1: 
+				double dx = (xpf[handle[3]]+x) - ox;
+				double dy = (ypf[handle[3]]+y) - oy;
+				updateRatio(Math.sqrt(dx*dx+dy*dy), x1, y1, x2, y2);
+				break;
+			case 2: 
+				x1 = ox;
+				y1 = oy;
+				break;
+			case 3: 
+				dx = (xpf[handle[1]]+x) - ox;
+				dy = (ypf[handle[1]]+y) - oy;
+				updateRatio(Math.sqrt(dx*dx+dy*dy), x1, y1, x2, y2);
+				break;
+		}
+		makeEllipse(x1, y1, x2, y2);
+		imp.draw();
+	}
+	
+	void updateRatio(double minor, double x1, double y1, double x2, double y2) {
+		double dx = x2 - x1;
+		double dy = y2 - y1;
+		double major = Math.sqrt(dx*dx+dy*dy);
+		aspectRatio = minor/major;
+		if (aspectRatio>1.0) aspectRatio = 1.0;
+		defaultRatio = aspectRatio;
+	}
+	
+	public int isHandle(int sx, int sy) {
+		int size = getHandleSize()+5;
+		int halfSize = size/2;
+		int index = -1;
+		for (int i=0; i<handle.length; i++) {
+			int sx2 = xp2[handle[i]]-halfSize, sy2=yp2[handle[i]]-halfSize;
+			if (sx>=sx2 && sx<=sx2+size && sy>=sy2 && sy<=sy2+size) {
+				index = i;
+				break;
+			}
+		}
+		return index;
+	}
+	
+	/** Returns the perimeter of this ellipse. */
+	public double getLength() {
+		double length = 0.0;
+		double dx, dy;
+		double w2=1.0, h2=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			w2 = cal.pixelWidth*cal.pixelWidth;
+			h2 = cal.pixelHeight*cal.pixelHeight;
+		}
+		for (int i=0; i<(nPoints-1); i++) {
+			dx = xpf[i+1]-xpf[i];
+			dy = ypf[i+1]-ypf[i];
+			length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		}
+		dx = xpf[0]-xpf[nPoints-1];
+		dy = ypf[0]-ypf[nPoints-1];
+		length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		return length;
+	}
+
+	/** Returns x1, y1, x2, y2 and aspectRatio as a 5 element array. */
+	public double[] getParams() {
+		double[] params = new double[5];
+		params[0] = xpf[handle[2]]+x;
+		params[1]  = ypf[handle[2]]+y;
+		params[2]  = xpf[handle[0]]+x;
+		params[3]  = ypf[handle[0]]+y;
+		params[4]  = aspectRatio;
+		return params;
+	}
+
+	public double[] getFeretValues() {
+		double a[] = super.getFeretValues();
+		double pw=1.0, ph=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		}
+		if (pw != ph)    //the following calculation holds only for pixel aspect ratio == 1 (otherwise different axes in distorted ellipse)
+			return a;
+		double[] p = getParams();
+		double dx = p[2] - p[0];  //this is always major axis; aspect ratio p[4] is limited to <= 1
+		double dy = p[3] - p[1];
+		double major = Math.sqrt(dx*dx + dy*dy);
+		double minor = major*p[4];
+		a[0] = major*pw; //Feret from convex hull should be accurate anyhow
+		a[2] = minor*pw; //here our own calculation is better
+		System.arraycopy(p, 0, a, 8, 4);  //MaxFeret endpoints
+		double xCenter = 0.5*(p[2] + p[0]);
+		double yCenter = 0.5*(p[3] + p[1]);
+		double semiMinorX = dy * 0.5 * p[4];
+		double semiMinorY = dx * (-0.5) * p[4];
+		a[12] = xCenter + semiMinorX; a[14] = xCenter - semiMinorX;
+		a[13] = yCenter + semiMinorY; a[15] = yCenter - semiMinorY;
+		return a;
+	}
+	
+	/** Always returns true. */
+	public boolean subPixelResolution() {
+		return true;
+	}
+
+}
diff --git a/src/ij/gui/FreehandRoi.java b/src/ij/gui/FreehandRoi.java
new file mode 100644
index 0000000..db844b2
--- /dev/null
+++ b/src/ij/gui/FreehandRoi.java
@@ -0,0 +1,98 @@
+package ij.gui;
+
+import java.awt.*;
+import java.awt.image.*;
+import ij.*;
+
+/** Freehand region of interest or freehand line of interest*/
+public class FreehandRoi extends PolygonRoi {
+
+	public FreehandRoi(int sx, int sy, ImagePlus imp) {
+		super(sx, sy, imp);
+		if (Toolbar.getToolId()==Toolbar.FREEROI)
+			type = FREEROI;
+		else
+			type = FREELINE;
+		if (nPoints==2) nPoints--;
+	}
+
+	protected void grow(int sx, int sy) {
+		if (subPixelResolution() && xpf!=null) {
+			growFloat(sx, sy);
+			return;
+		}
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		if (ox<0) ox = 0;
+		if (oy<0) oy = 0;
+		if (ox>xMax) ox = xMax;
+		if (oy>yMax) oy = yMax;
+		if (ox!=xp[nPoints-1]+x || oy!=yp[nPoints-1]+y) {
+			xp[nPoints] = ox-x;
+			yp[nPoints] = oy-y;
+			nPoints++;
+			if (IJ.altKeyDown())
+				wipeBack();
+			if (nPoints==xp.length)
+				enlargeArrays();
+			drawLine();
+		}
+	}
+              
+	private void growFloat(int sx, int sy) {
+		double ox = offScreenXD(sx);
+		double oy = offScreenYD(sy);
+		if (ox<0.0) ox = 0.0;
+		if (oy<0.0) oy = 0.0;
+		if (ox>xMax) ox = xMax;
+		if (oy>yMax) oy = yMax;
+		double xbase = getXBase();
+		double ybase = getYBase();
+		if (ox!=xpf[nPoints-1]+xbase || oy!=ypf[nPoints-1]+ybase) {
+			xpf[nPoints] = (float)(ox-xbase);
+			ypf[nPoints] = (float)(oy-ybase);
+			nPoints++;
+			if (nPoints==xpf.length)
+				enlargeArrays();
+			drawLine();
+		}
+	}
+	
+	void drawLine() {
+		int x1, y1, x2, y2;
+		if (xpf!=null) {
+			x1 = (int)Math.round(xpf[nPoints-2]+x);
+			y1 = (int)Math.round(ypf[nPoints-2]+y);
+			x2 = (int)Math.round(xpf[nPoints-1]+x);
+			y2 = (int)Math.round(ypf[nPoints-1]+y);
+		} else {
+			x1 = xp[nPoints-2]+x;
+			y1 = yp[nPoints-2]+y;
+			x2 = xp[nPoints-1]+x;
+			y2 = yp[nPoints-1]+y;
+		}
+		int xmin = Math.min(x1, x2);
+		int xmax = Math.max(x1, x2);
+		int ymin = Math.min(y1, y2);
+		int ymax = Math.max(y1, y2);
+		int margin = 4;
+		if (lineWidth>margin && isLine())
+			margin = lineWidth;
+		if (ic!=null) {
+			double mag = ic.getMagnification();
+			if (mag<1.0) margin = (int)(margin/mag);
+		}
+		if (IJ.altKeyDown())
+			margin += 20; // for wipeBack
+		imp.draw(xmin-margin, ymin-margin, (xmax-xmin)+margin*2, (ymax-ymin)+margin*2);
+	}
+
+	protected void handleMouseUp(int screenX, int screenY) {
+		if (state==CONSTRUCTING) {
+            addOffset();
+			finishPolygon();
+        }
+		state = NORMAL;
+	}
+
+}
diff --git a/src/ij/gui/GUI.java b/src/ij/gui/GUI.java
new file mode 100644
index 0000000..6bb4921
--- /dev/null
+++ b/src/ij/gui/GUI.java
@@ -0,0 +1,288 @@
+package ij.gui;
+import ij.*;
+import java.awt.*;
+import javax.swing.JComponent;
+import javax.swing.JList;
+import javax.swing.JTable;
+import javax.swing.UIManager;
+
+/** This class consists of static GUI utility methods. */
+public class GUI {
+	private static final Font DEFAULT_FONT = IJ.font12;
+	private static Color lightGray = new Color(240,240,240);
+	private static boolean isWindows8;
+	private static Color scrollbarBackground = new Color(245,245,245);
+
+	static {
+		if (IJ.isWindows()) {
+			String osname = System.getProperty("os.name");
+			isWindows8 = osname.contains("unknown") || osname.contains("8");
+		}
+	}
+
+	/** Positions the specified window in the center of the screen that contains target. */
+	public static void center(Window win, Component target) {
+		if (win == null)
+			return;
+		Rectangle bounds = getMaxWindowBounds(target);
+		Dimension window = win.getSize();
+		if (window.width == 0)
+			return;
+		int left = bounds.x + Math.max(0, (bounds.width - window.width) / 2);
+		int top = bounds.y + Math.max(0, (bounds.height - window.height) / 4);
+		win.setLocation(left, top);
+	}
+	
+	/** Positions the specified window in the center of the
+		 screen containing the "ImageJ" window. */
+	public static void centerOnImageJScreen(Window win) {
+		center(win, IJ.getInstance());
+	}
+
+	public static void center(Window win) {
+		center(win, win);
+	}
+	
+	private static java.util.List<GraphicsConfiguration> getScreenConfigs() {
+		java.util.ArrayList<GraphicsConfiguration> configs = new java.util.ArrayList<GraphicsConfiguration>();
+		for (GraphicsDevice device : GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()) {
+			configs.add(device.getDefaultConfiguration());
+		}
+		return configs;
+	}
+	
+	/**
+	 * Get maximum bounds for the screen that contains a given point.
+	 * @param point Coordinates of point.
+	 * @param accountForInsets Deduct the space taken up by menu and status bars, etc. (after point is found to be inside bonds)
+	 * @return Rectangle of bounds or <code>null</code> if point not inside of any screen.
+	 */
+	public static Rectangle getScreenBounds(Point point, boolean accountForInsets) {
+		if (GraphicsEnvironment.isHeadless())
+			return new Rectangle(0,0,0,0);
+		for (GraphicsConfiguration config : getScreenConfigs()) {
+			Rectangle bounds = config.getBounds();
+			if (bounds != null && bounds.contains(point)) {
+				Insets insets = accountForInsets ? Toolkit.getDefaultToolkit().getScreenInsets(config) : null;
+				return shrinkByInsets(bounds, insets);
+			}
+		}
+		return null;		
+	}
+	
+	/**
+	 * Get maximum bounds for the screen that contains a given component.
+	 * @param component An AWT component located on the desired screen.
+	 * If <code>null</code> is provided, the default screen is used.
+	 * @param accountForInsets Deduct the space taken up by menu and status bars, etc.
+	 * @return Rectangle of bounds.
+	 */	
+	public static Rectangle getScreenBounds(Component component, boolean accountForInsets) {
+		if (GraphicsEnvironment.isHeadless())
+			return new Rectangle(0,0,0,0);
+		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();		
+		GraphicsConfiguration gc = component == null ? ge.getDefaultScreenDevice().getDefaultConfiguration() :
+													   component.getGraphicsConfiguration();   
+		Insets insets = accountForInsets ? Toolkit.getDefaultToolkit().getScreenInsets(gc) : null;
+		return shrinkByInsets(gc.getBounds(), insets);
+	}
+
+	public static Rectangle getScreenBounds(Point point) {
+		return getScreenBounds(point, false);
+	}		
+
+	public static Rectangle getScreenBounds(Component component) {
+		return getScreenBounds(component, false);
+	}			
+
+	public static Rectangle getScreenBounds() {
+		return getScreenBounds((Component)null);
+	}			
+
+	public static Rectangle getMaxWindowBounds(Point point) {
+		return getScreenBounds(point, true);
+	}
+
+	public static Rectangle getMaxWindowBounds(Component component) {
+		return getScreenBounds(component, true);
+	}
+	
+	public static Rectangle getMaxWindowBounds() {
+		return getMaxWindowBounds((Component)null);
+	}
+	
+	private static Rectangle shrinkByInsets(Rectangle bounds, Insets insets) {
+		Rectangle shrunk = new Rectangle(bounds);
+		if (insets == null) return shrunk; 
+		shrunk.x += insets.left;
+		shrunk.y += insets.top;
+		shrunk.width -= insets.left + insets.right;
+		shrunk.height -= insets.top + insets.bottom;
+		return shrunk;
+	}
+	
+	public static Rectangle getZeroBasedMaxBounds() {
+		for (GraphicsConfiguration config : getScreenConfigs()) {
+			Rectangle bounds = config.getBounds();
+			if (bounds != null && bounds.x == 0 && bounds.y == 0)
+				return bounds;
+		}
+		return null;
+	}
+	
+	public static Rectangle getUnionOfBounds() {
+		Rectangle unionOfBounds = new Rectangle();
+		for (GraphicsConfiguration config : getScreenConfigs()) {
+			unionOfBounds = unionOfBounds.union(config.getBounds());
+		}
+		return unionOfBounds;
+	}
+	
+    static private Frame frame;
+    
+    /** Obsolete */
+    public static Image createBlankImage(int width, int height) {
+        if (width==0 || height==0)
+            throw new IllegalArgumentException("");
+		if (frame==null) {
+			frame = new Frame();
+			frame.pack();
+			frame.setBackground(Color.white);
+		}
+        Image img = frame.createImage(width, height);
+        return img;
+    }
+    
+    /** Lightens overly dark scrollbar background on Windows 8. */
+    public static void fix(Scrollbar sb) {
+    }
+    
+    public static boolean showCompositeAdvisory(ImagePlus imp, String title) {
+    	if (imp==null || imp.getCompositeMode()!=IJ.COMPOSITE || imp.getNChannels()==1 || IJ.macroRunning())
+    		return true;
+    	String msg = "Channel "+imp.getC()+" of this color composite image will be processed.";
+		GenericDialog gd = new GenericDialog(title);
+		gd.addMessage(msg);
+		gd.showDialog();
+		return !gd.wasCanceled();
+	}
+	
+	/**
+	 * Scales an AWT component according to {@link Prefs#getGuiScale()}.
+	 * @param component the AWT component to be scaled. If a container, scaling is applied to all its child components
+	 */
+	public static void scale(final Component component) {
+		final float scale = (float)Prefs.getGuiScale();
+		if (scale==1f)
+			return;
+		if (component instanceof Container)
+			scaleComponents((Container)component, scale);
+		else
+			scaleComponent(component, scale);
+	}
+
+	private static void scaleComponents(final Container container, final float scale) {
+		for (final Component child : container.getComponents()) {
+			if (child instanceof Container)
+				scaleComponents((Container) child, scale);
+			else
+				scaleComponent(child, scale);
+		}
+	}
+
+	private static void scaleComponent(final Component component, final float scale) {
+		Font font = component.getFont();
+		if (font == null)
+			font = DEFAULT_FONT;
+		font = font.deriveFont(scale*font.getSize());
+		component.setFont(font);
+	}
+
+	public static void scalePopupMenu(final PopupMenu popup) {
+		final float scale = (float)Prefs.getGuiScale();
+		if (scale==1f)
+			return;
+		Font font = popup.getFont();
+		if (font == null)
+			font = DEFAULT_FONT;
+		font = font.deriveFont(scale*font.getSize());
+		popup.setFont(font);
+	}
+	
+	/**
+	 * Tries to detect if a Swing component is unscaled and scales it it according
+	 * to {@link #getGuiScale()}.
+	 * <p>
+	 * This is mainly relevant to linux: Swing components scale automatically on
+	 * most platforms, specially since Java 8. However there are still exceptions to
+	 * this on linux: e.g., In Ubuntu, Swing components do scale, but only under the
+	 * GTK L&F. (On the other hand AWT components do not scale <i>at all</i> on
+	 * hiDPI screens on linux).
+	 * </p>
+	 * <p>
+	 * This method tries to avoid exaggerated font sizes by detecting if a component
+	 * has been already scaled by the UIManager, applying only
+	 * {@link #getGuiScale()} to the component's font if not.
+	 * </p>
+	 *
+	 * @param component the component to be scaled
+	 * @return true, if component's font was resized
+	 */
+	public static boolean scale(final JComponent component) {
+		final double guiScale = Prefs.getGuiScale();
+		if (guiScale == 1d)
+			return false;
+		Font font = component.getFont();
+		if (font == null && component instanceof JList)
+			font = UIManager.getFont("List.font");
+		else if (font == null && component instanceof JTable)
+			font = UIManager.getFont("Table.font");
+		else if (font == null)
+			font = UIManager.getFont("Label.font");
+		if (font.getSize() > DEFAULT_FONT.getSize())
+			return false;
+		if (component instanceof JTable)
+			((JTable) component).setRowHeight((int) (((JTable) component).getRowHeight() * guiScale * 0.9));
+		else if (component instanceof JList)
+			((JList<?>) component).setFixedCellHeight((int) (((JList<?>) component).getFixedCellHeight() * guiScale * 0.9));
+		component.setFont(font.deriveFont((float) guiScale * font.getSize()));
+		return true;
+	}
+	
+	/** Works around an OpenJDK bug on Windows that
+	 * causes the scrollbar thumb color and background
+	 * color to be almost identical.
+	*/
+	public static final void fixScrollbar(Scrollbar sb) {
+		if (IJ.isWindows())
+			sb.setBackground(scrollbarBackground);
+	}
+	
+	/** Returns a new NonBlockingGenericDialog with the given title,
+	 *  except when Java is running in headless mode, in which case
+	 *  a GenericDialog is be returned.
+	*/
+	public static GenericDialog newNonBlockingDialog(String title) {
+		if (GraphicsEnvironment.isHeadless())
+			return new GenericDialog(title);
+		else
+			return new NonBlockingGenericDialog(title);
+	}
+
+	/** Returns a new NonBlockingGenericDialog with the given title
+	 * if Prefs.nonBlockingFilterDialogs is 'true' and 'imp' is
+	 * displayed, otherwise returns a GenericDialog.
+	 * @param title Dialog title
+	 * @param imp The image associated with this dialog
+	*/
+	public static GenericDialog newNonBlockingDialog(String title, ImagePlus imp) {
+		if (Prefs.nonBlockingFilterDialogs && imp!=null && imp.getWindow()!=null) {
+			NonBlockingGenericDialog gd = new NonBlockingGenericDialog(title);
+			gd.imp = imp;
+			return gd;
+		} else
+			return new GenericDialog(title);
+	}
+
+	
+}
diff --git a/src/ij/gui/GenericDialog.java b/src/ij/gui/GenericDialog.java
new file mode 100644
index 0000000..0995d71
--- /dev/null
+++ b/src/ij/gui/GenericDialog.java
@@ -0,0 +1,1918 @@
+package ij.gui;
+import ij.*;
+import ij.plugin.frame.Recorder;
+import ij.plugin.ScreenGrabber;
+import ij.plugin.filter.PlugInFilter;
+import ij.plugin.filter.PlugInFilterRunner;
+import ij.util.Tools;
+import ij.macro.*;
+import ij.io.OpenDialog;
+import java.awt.*;
+import java.io.*;
+import java.awt.event.*;
+import java.util.*;
+import java.awt.datatransfer.*;
+import java.awt.dnd.*;
+
+
+/**
+ * This class is a customizable modal dialog box. Here is an example
+ * GenericDialog with one string field and two numeric fields:
+ * <pre>
+ *  public class Generic_Dialog_Example implements PlugIn {
+ *    static String title="Example";
+ *    static int width=512,height=512;
+ *    public void run(String arg) {
+ *      GenericDialog gd = new GenericDialog("New Image");
+ *      gd.addStringField("Title: ", title);
+ *      gd.addNumericField("Width: ", width, 0);
+ *      gd.addNumericField("Height: ", height, 0);
+ *      gd.showDialog();
+ *      if (gd.wasCanceled()) return;
+ *      title = gd.getNextString();
+ *      width = (int)gd.getNextNumber();
+ *      height = (int)gd.getNextNumber();
+ *      IJ.newImage(title, "8-bit", width, height, 1);
+ *   }
+ * }
+ * </pre>
+* To work with macros, the first word of each component label must be
+* unique. If this is not the case, add underscores, which will be converted
+* to spaces when the dialog is displayed. For example, change the checkbox labels
+* "Show Quality" and "Show Residue" to "Show_Quality" and "Show_Residue".
+*/
+public class GenericDialog extends Dialog implements ActionListener, TextListener,
+FocusListener, ItemListener, KeyListener, AdjustmentListener, WindowListener {
+
+	protected Vector numberField, stringField, checkbox, choice, slider, radioButtonGroups;
+	protected TextArea textArea1, textArea2;
+	protected Vector defaultValues,defaultText,defaultStrings,defaultChoiceIndexes;
+	protected Component theLabel;
+	private Button okay;
+	private Button cancel;
+	private Button no, help;
+	private String helpLabel = "Help";
+	private boolean wasCanceled, wasOKed;
+	private int nfIndex, sfIndex, cbIndex, choiceIndex, textAreaIndex, radioButtonIndex;
+	private GridBagConstraints c;
+	private boolean firstNumericField=true;
+	private boolean firstSlider=true;
+	private boolean invalidNumber;
+	private String errorMessage;
+	private Hashtable labels;
+	private boolean macro;
+	private String macroOptions;
+	private boolean addToSameRow;
+	private boolean addToSameRowCalled;
+	private int topInset, leftInset, bottomInset;
+	private boolean customInsets;
+	private Vector sliderIndexes, sliderScales, sliderDigits;
+	private Checkbox previewCheckbox;    // the "Preview" Checkbox, if any
+	private Vector dialogListeners;      // the Objects to notify on user input
+	private PlugInFilterRunner pfr;      // the PlugInFilterRunner for automatic preview
+	private String previewLabel = " Preview";
+	private final static String previewRunning = "wait...";
+	private boolean recorderOn;          // whether recording is allowed (after the dialog is closed)
+	private char echoChar;
+	private boolean hideCancelButton;
+	private boolean centerDialog = true;
+	private String helpURL;
+	private boolean smartRecording;
+	private Vector imagePanels;
+	protected static GenericDialog instance;
+	private boolean firstPaint = true;
+	private boolean fontSizeSet;
+	private boolean showDialogCalled;
+	private boolean optionsRecorded;     // have dialogListeners been called to record options?
+	private Label lastLabelAdded;
+	private int[] windowIDs;
+	private String[] windowTitles;
+
+
+    /** Creates a new GenericDialog with the specified title. Uses the current image
+    	image window as the parent frame or the ImageJ frame if no image windows
+    	are open. Dialog parameters are recorded by ImageJ's command recorder but
+    	this requires that the first word of each label be unique. */
+	public GenericDialog(String title) {
+		this(title, null);
+	}
+
+	private static Frame getParentFrame() {
+		return null;
+	}
+
+    /** Creates a new GenericDialog using the specified title and parent frame. */
+    public GenericDialog(String title, Frame parent) {
+		super(parent, title, true);
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null) setFont(ij.getFont());
+		okay = new Button("  OK  ");
+		cancel = new Button("Cancel");
+		if (Prefs.blackCanvas) {
+			setForeground(SystemColor.controlText);
+			setBackground(SystemColor.control);
+		}
+		//if (IJ.isMacOSX() && System.getProperty("java.vendor").contains("Azul"))
+		//	setForeground(Color.black);  // work around bug on Azul Java 8 on Apple Silicon
+		GridBagLayout grid = new GridBagLayout();
+		c = new GridBagConstraints();
+		setLayout(grid);
+		macroOptions = Macro.getOptions();
+		macro = macroOptions!=null;
+		addKeyListener(this);
+		addWindowListener(this);
+    }
+
+	/** Adds a numeric field. The first word of the label must be
+		unique or command recording will not work.
+	* @param label			the label
+	* @param defaultValue	value to be initially displayed
+	*/
+	public void addNumericField(String label, double defaultValue) {
+		int decimalPlaces = (int)defaultValue==defaultValue?0:3;
+		int columnWidth = decimalPlaces==3?8:6;
+		addNumericField(label, defaultValue, decimalPlaces, columnWidth, null);
+	}
+
+	/** Adds a numeric field. The first word of the label must be
+		unique or command recording will not work.
+	* @param label			the label
+	* @param defaultValue	value to be initially displayed
+	* @param digits			number of digits to right of decimal point
+	*/
+	public void addNumericField(String label, double defaultValue, int digits) {
+		addNumericField(label, defaultValue, digits, 6, null);
+	}
+
+	/** Adds a numeric field. The first word of the label must be
+		unique or command recording will not work.
+	* @param label			the label
+	* @param defaultValue	value to be initially displayed
+	* @param digits			number of digits to right of decimal point
+	* @param columns		width of field in characters
+	* @param units			a string displayed to the right of the field
+	*/
+   public void addNumericField(String label, double defaultValue, int digits, int columns, String units) {
+   		String label2 = label;
+   		if (label2.indexOf('_')!=-1)
+   			label2 = label2.replace('_', ' ');
+		Label fieldLabel = makeLabel(label2);
+		this.lastLabelAdded = fieldLabel;
+		if (addToSameRow) {
+			c.gridx = GridBagConstraints.RELATIVE;
+			c.insets.left = 10;
+		} else {
+			c.gridx = 0; c.gridy++;
+			if (firstNumericField)
+				c.insets = getInsets(5, 0, 3, 0); // top, left, bottom, right
+			else
+				c.insets = getInsets(0, 0, 3, 0);
+		}
+		c.anchor = GridBagConstraints.EAST;
+		c.gridwidth = 1;
+		//IJ.log("x="+c.gridx+", y= "+c.gridy+", width="+c.gridwidth+", ancher= "+c.anchor+" "+c.insets);
+		add(fieldLabel, c);
+		if (addToSameRow) {
+			c.insets.left = 0;
+			addToSameRow = false;
+		}
+		if (numberField==null) {
+			numberField = new Vector(5);
+			defaultValues = new Vector(5);
+			defaultText = new Vector(5);
+		}
+		if (IJ.isWindows()) columns -= 2;
+		if (columns<1) columns = 1;
+		String defaultString = IJ.d2s(defaultValue, digits);
+		if (Double.isNaN(defaultValue))
+			defaultString = "";
+		TextField tf = new TextField(defaultString, columns);
+		if (IJ.isLinux()) tf.setBackground(Color.white);
+		tf.addActionListener(this);
+		tf.addTextListener(this);
+		tf.addFocusListener(this);
+		tf.addKeyListener(this);
+		numberField.addElement(tf);
+		defaultValues.addElement(new Double(defaultValue));
+		defaultText.addElement(tf.getText());
+		c.gridx = GridBagConstraints.RELATIVE;
+		c.anchor = GridBagConstraints.WEST;
+		tf.setEditable(true);
+		//if (firstNumericField) tf.selectAll();
+		firstNumericField = false;
+		if (units==null||units.equals("")) {
+			add(tf, c);
+		} else {
+    		Panel panel = new Panel();
+			panel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
+    		panel.add(tf);
+			panel.add(new Label(" "+units));
+			add(panel, c);
+		}
+		if (Recorder.record || macro)
+			saveLabel(tf, label);
+    }
+
+    private Label makeLabel(String label) {
+    	if (IJ.isMacintosh())
+    		label += " ";
+		return new Label(label);
+    }
+
+	/** Saves the label for given component, for macro recording and for accessing the component in macros. */
+    private void saveLabel(Object component, String label) {
+    	if (labels==null)
+    		labels = new Hashtable();
+    	if (label.length()>0)
+    		label = Macro.trimKey(label.trim());
+    	if (label.length()>0 && hasLabel(label)) {                      // not a unique label?
+    		label += "_0";
+    		for (int n=1; hasLabel(label); n++) {   // while still not a unique label
+    			label = label.substring(0, label.lastIndexOf('_')); //remove counter
+    			label += "_"+n;
+    		}
+    	}
+		labels.put(component, label);
+    }
+
+	/** Returns whether the list of labels for macro recording or macro creation contains a given label. */
+    private boolean hasLabel(String label) {
+    	for (Object o : labels.keySet())
+    		if (labels.get(o).equals(label)) return true;
+    	return false;
+    }
+
+	/** Adds an 8 column text field.
+	* @param label			the label
+	* @param defaultText		the text initially displayed
+	*/
+	public void addStringField(String label, String defaultText) {
+		addStringField(label, defaultText, 8);
+	}
+
+	/** Adds a text field.
+	* @param label			the label
+	* @param defaultText		text initially displayed
+	* @param columns			width of the text field. If columns is 8 or more, additional items may be added to this line with addToSameRow()
+	*/
+	public void addStringField(String label, String defaultText, int columns) {
+		if (addToSameRow && label.equals("_"))
+			label = "";
+   		String label2 = label;
+   		if (label2.indexOf('_')!=-1)
+   			label2 = label2.replace('_', ' ');
+		Label fieldLabel = makeLabel(label2);
+		this.lastLabelAdded = fieldLabel;
+		boolean custom = customInsets;
+		if (addToSameRow) {
+			c.gridx = GridBagConstraints.RELATIVE;
+			addToSameRow = false;
+		} else {
+			c.gridx = 0; c.gridy++;
+			if (stringField==null)
+				c.insets = getInsets(5, 0, 5, 0); // top, left, bottom, right
+			else
+				c.insets = getInsets(0, 0, 5, 0);
+        }
+		c.anchor = GridBagConstraints.EAST;
+		c.gridwidth = 1;
+		add(fieldLabel, c);
+		if (stringField==null) {
+			stringField = new Vector(4);
+			defaultStrings = new Vector(4);
+		}
+
+		TextField tf = new TextField(defaultText, columns);
+		if (IJ.isLinux()) tf.setBackground(Color.white);
+		tf.setEchoChar(echoChar);
+		echoChar = 0;
+		tf.addActionListener(this);
+		tf.addTextListener(this);
+		tf.addFocusListener(this);
+		tf.addKeyListener(this);
+		c.gridx = GridBagConstraints.RELATIVE;
+		c.anchor = GridBagConstraints.WEST;
+		c.gridwidth = columns <= 8 ? 1 : GridBagConstraints.REMAINDER;
+		c.insets.left = 0;
+		tf.setEditable(true);
+		add(tf, c);
+		stringField.addElement(tf);
+		defaultStrings.addElement(defaultText);
+		tf.setDropTarget(null);
+		new DropTarget(tf, new TextDropTarget(tf));
+		if (Recorder.record || macro)
+			saveLabel(tf, label);
+    }
+
+    /** Sets the echo character for the next string field. */
+    public void setEchoChar(char echoChar) {
+    	this.echoChar = echoChar;
+    }
+
+	/** Adds a directory text field and "Browse" button, where the
+	 * field width is determined by the length of 'defaultPath', with
+	 * a minimum of 25 columns. Use getNextString to retrieve the
+	 * directory path. Based on the addDirectoryField() method in
+	 * Fiji's GenericDialogPlus class.
+	 */
+	public void addDirectoryField(String label, String defaultPath) {
+		int columns = defaultPath!=null?Math.max(defaultPath.length(),25):25;
+		addDirectoryField(label, defaultPath, columns);
+	}
+
+	public void addDirectoryField(String label, String defaultPath, int columns) {
+		defaultPath = IJ.addSeparator(defaultPath);
+		addStringField(label, defaultPath, columns);
+		if (GraphicsEnvironment.isHeadless())
+			return;
+		TextField text = (TextField)stringField.lastElement();
+		GridBagLayout layout = (GridBagLayout)getLayout();
+		GridBagConstraints constraints = layout.getConstraints(text);
+		Button button = new TrimmedButton("Browse",IJ.isMacOSX()?10:0);
+		BrowseButtonListener listener = new BrowseButtonListener(label, text, "dir");
+		button.addActionListener(listener);
+		Panel panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
+		panel.add(text);
+		panel.add(button);
+		layout.setConstraints(panel, constraints);
+		add(panel);
+		if (Recorder.record || macro)
+			saveLabel(panel, label);
+	}
+
+	/** Adds a file text field and "Browse" button, where the
+	 * field width is determined by the length of 'defaultPath',
+	 * with a minimum of 25 columns. Use getNextString to
+	 * retrieve the file path. Based on the addFileField() method
+	 * in Fiji's GenericDialogPlus class.
+	 */
+	 public void addFileField(String label, String defaultPath) {
+		int columns = defaultPath!=null?Math.max(defaultPath.length(),25):25;
+		addFileField(label, defaultPath, columns);
+	 }
+
+	public void addFileField(String label, String defaultPath, int columns) {
+		addStringField(label, defaultPath, columns);
+		if (GraphicsEnvironment.isHeadless())
+			return;
+		TextField text = (TextField)stringField.lastElement();
+		GridBagLayout layout = (GridBagLayout)getLayout();
+		GridBagConstraints constraints = layout.getConstraints(text);
+		Button button = new TrimmedButton("Browse",IJ.isMacOSX()?10:0);
+		BrowseButtonListener listener = new BrowseButtonListener(label, text, "file");
+		button.addActionListener(listener);
+		Panel panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
+		panel.add(text);
+		panel.add(button);
+		layout.setConstraints(panel, constraints);
+		add(panel);
+		if (Recorder.record || macro)
+			saveLabel(panel, label);
+	}
+
+	/**
+	 * Add button to the dialog
+	 * @param label button label
+	 * @param listener listener to handle the action when pressing the button
+	*/
+	public void addButton(String label, ActionListener listener) {
+		if (GraphicsEnvironment.isHeadless())
+			return;
+		Button button = new Button(label);
+		button.addActionListener(listener);
+		button.addKeyListener(this);		
+		GridBagLayout layout = (GridBagLayout)getLayout();
+		Panel panel = new Panel();
+		addPanel(panel);
+		GridBagConstraints constraints = layout.getConstraints(panel);
+		remove(panel);
+		layout.setConstraints(button, constraints);
+		add(button);
+	}
+
+	/** Adds a popup menu that lists the currently open images.
+	 * Call getNextImage() to retrieve the selected
+	 * image. Based on the addImageChoice()
+	 * method in Fiji's GenericDialogPlus class.
+	 * @param label  the label
+	 * @param defaultImage  the image title initially selected in the menu
+	 * or the first image if null
+	*/
+	public void addImageChoice(String label, String defaultImage) {
+		if (windowTitles==null) {
+			windowIDs = WindowManager.getIDList();
+			if (windowIDs==null)
+				windowIDs = new int[0];
+			windowTitles = new String[windowIDs.length];
+			for (int i=0; i<windowIDs.length; i++) {
+				ImagePlus image = WindowManager.getImage(windowIDs[i]);
+				windowTitles[i] = image==null ? "" : image.getTitle();
+			}
+		}
+		addChoice(label, windowTitles, defaultImage);
+	}
+
+	public ImagePlus getNextImage() {
+		return WindowManager.getImage(windowIDs[getNextChoiceIndex()]);
+	}
+
+	/**
+	 * Adds a group of choices to the dialog with menu items taken from the
+	 * <code>enum</code> class of the specified default item (enum constant).
+	 * The default item is automatically set. Calls the original (string-based)
+	 * {@link GenericDialog#addChoice(String, String[], String)} method.
+	 * 
+	 * @param <E> the generic enum type containing the items to chose from
+	 * @param label the label displayed for this choice group
+	 * @param defaultItem the menu item initially selected
+	 */
+	public <E extends Enum<E>> void addEnumChoice(String label, Enum<E> defaultItem) {
+		Class<E> enumClass = defaultItem.getDeclaringClass();	
+		E[] enums = enumClass.getEnumConstants();
+		String[] items = new String[enums.length];
+		for (int i = 0; i < enums.length; i++) {
+			items[i] = enums[i].name();
+		}
+		this.addChoice(label, items, defaultItem.name());
+	}
+	
+	/**
+	 * Returns the selected item in the next enum choice menu.
+	 * Note that 'enumClass' is required to infer the proper enum type.
+	 * Throws {@code IllegalArgumentException} if the selected item is not a defined
+	 * constant in the specified enum class.
+	 * 
+	 * @param <E> the generic enum type
+	 * @param enumClass the enum type
+	 * @return the selected item
+	 */
+	public <E extends Enum<E>> E getNextEnumChoice(Class<E> enumClass) {
+		String choiceString = this.getNextChoice();
+		return Enum.valueOf(enumClass, choiceString);
+	}
+
+	/** Adds a checkbox.
+	* @param label			the label
+	* @param defaultValue	the initial state
+	*/
+    public void addCheckbox(String label, boolean defaultValue) {
+        addCheckbox(label, defaultValue, false);
+    }
+
+    /** Adds a checkbox; does not make it recordable if isPreview is true.
+     * With isPreview true, the checkbox can be referred to as previewCheckbox
+     * from hereon.
+     */
+    private void addCheckbox(String label, boolean defaultValue, boolean isPreview) {
+    	String label2 = label;
+   		if (label2.indexOf('_')!=-1)
+   			label2 = label2.replace('_', ' ');
+		if (addToSameRow) {
+			c.gridx = GridBagConstraints.RELATIVE;
+			c.insets.left = 10;
+			addToSameRow = false;
+		} else {
+			c.gridx = 0; c.gridy++;
+			if (checkbox==null)
+				c.insets = getInsets(15, 20, 0, 0);  // top, left, bottom, right
+    		else
+				c.insets = getInsets(0, 20, 0, 0);
+		}
+		c.anchor = GridBagConstraints.WEST;
+		c.gridwidth = 2;
+    	if (checkbox==null)
+    		checkbox = new Vector(4);
+		Checkbox cb = new Checkbox(label2);
+		cb.setState(defaultValue);
+		cb.addItemListener(this);
+		cb.addKeyListener(this);
+		add(cb, c);
+		c.insets.left = 0;
+		checkbox.addElement(cb);
+        if (!isPreview &&(Recorder.record || macro)) //preview checkbox is not recordable
+			saveLabel(cb, label);
+        if (isPreview) previewCheckbox = cb;
+    }
+
+    /** Adds a checkbox labelled "Preview" for "automatic" preview.
+     * The reference to this checkbox can be retrieved by getPreviewCheckbox()
+     * and it provides the additional method previewRunning for optical
+     * feedback while preview is prepared.
+     * PlugInFilters can have their "run" method automatically called for
+     * preview under the following conditions:
+     * - the PlugInFilter must pass a reference to itself (i.e., "this") as an
+     *   argument to the AddPreviewCheckbox
+     * - it must implement the DialogListener interface and set the filter
+     *   parameters in the dialogItemChanged method.
+     * - it must have DIALOG and PREVIEW set in its flags.
+     * A previewCheckbox is always off when the filter is started and does not get
+     * recorded by the Macro Recorder.
+     *
+     * @param pfr A reference to the PlugInFilterRunner calling the PlugInFilter
+     * if automatic preview is desired, null otherwise.
+     */
+    public void addPreviewCheckbox(PlugInFilterRunner pfr) {
+        if (previewCheckbox != null)
+        	return;
+    	ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null && imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.COMPOSITE)
+			return;
+        this.pfr = pfr;
+        addCheckbox(previewLabel, false, true);
+    }
+
+    /** Add the preview checkbox with user-defined label; for details see the
+     *  addPreviewCheckbox method with standard "Preview" label.
+     * Adds the checkbox when the current image is a CompositeImage
+     * in "Composite" mode, unlike the one argument version.
+     * Note that a GenericDialog can have only one PreviewCheckbox.
+     */
+    public void addPreviewCheckbox(PlugInFilterRunner pfr, String label) {
+        if (previewCheckbox!=null)
+        	return;
+        previewLabel = label;
+        this.pfr = pfr;
+        addCheckbox(previewLabel, false, true);
+    }
+
+    /** Adds a group of checkboxs using a grid layout.
+	* @param rows			the number of rows
+	* @param columns		the number of columns
+	* @param labels			the labels
+	* @param defaultValues	the initial states
+	*/
+    public void addCheckboxGroup(int rows, int columns, String[] labels, boolean[] defaultValues) {
+    	addCheckboxGroup(rows, columns, labels, defaultValues, null);
+    }
+
+    /** Adds a group of checkboxs using a grid layout.
+	* @param rows			the number of rows
+	* @param columns		the number of columns
+	* @param labels			the labels
+	* @param defaultValues	the initial states
+	* @param headings	the column headings
+	* Example: http://imagej.nih.gov/ij/plugins/multi-column-dialog/index.html
+	*/
+    public void addCheckboxGroup(int rows, int columns, String[] labels, boolean[] defaultValues, String[] headings) {
+    	Panel panel = new Panel();
+    	int nRows = headings!=null?rows+1:rows;
+    	panel.setLayout(new GridLayout(nRows, columns, 6, 0));
+    	int startCBIndex = cbIndex;
+    	if (checkbox==null)
+    		checkbox = new Vector(12);
+    	if (headings!=null) {
+    		Font font = new Font("SansSerif", Font.BOLD, 12);
+			for (int i=0; i<columns; i++) {
+				if (i>headings.length-1 || headings[i]==null)
+					panel.add(new Label(""));
+				else {
+					Label label = new Label(headings[i]);
+					label.setFont(font);
+					panel.add(label);
+				}
+			}
+    	}
+    	int i1 = 0;
+    	int[] index = new int[labels.length];
+    	for (int row=0; row<rows; row++) {
+			for (int col=0; col<columns; col++) {
+				int i2 = col*rows+row;
+				if (i2>=labels.length) break;
+				index[i1] = i2;
+				String label = labels[i1];
+				if (label==null || label.length()==0) {
+					Label lbl = new Label("");
+					panel.add(lbl);
+					i1++;
+					continue;
+				}
+				if (label.indexOf('_')!=-1)
+   					label = label.replace('_', ' ');
+				Checkbox cb = new Checkbox(label);
+				checkbox.addElement(cb);
+				cb.setState(defaultValues[i1]);
+				cb.addItemListener(this);
+				if (Recorder.record || macro)
+					saveLabel(cb, labels[i1]);
+				if (IJ.isLinux()) {
+					Panel panel2 = new Panel();
+					panel2.setLayout(new BorderLayout());
+					panel2.add("West", cb);
+					panel.add(panel2);
+				} else
+					panel.add(cb);
+ 				i1++;
+			}
+		}
+		c.gridx = 0; c.gridy++;
+		c.gridwidth = GridBagConstraints.REMAINDER;
+		c.anchor = GridBagConstraints.WEST;
+		c.insets = getInsets(10, 0, 0, 0);
+		addToSameRow = false;
+		add(panel, c);
+    }
+
+    /** Adds a radio button group.
+	* @param label			group label (or null)
+	* @param items		radio button labels
+	* @param rows			number of rows
+	* @param columns	number of columns
+	* @param defaultItem		button initially selected
+	*/
+    public void addRadioButtonGroup(String label, String[] items, int rows, int columns, String defaultItem) {
+		addToSameRow = false;
+    	Panel panel = new Panel();
+    	int n = items.length;
+     	panel.setLayout(new GridLayout(rows, columns, 0, 0));
+		CheckboxGroup cg = new CheckboxGroup();
+		for (int i=0; i<n; i++) {
+			Checkbox cb = new Checkbox(items[i],cg,items[i].equals(defaultItem));
+			cb.addItemListener(this);
+			panel.add(cb);
+		}
+		if (radioButtonGroups==null)
+			radioButtonGroups = new Vector();
+		radioButtonGroups.addElement(cg);
+		Insets insets = getInsets(5, 10, 0, 0);
+		if (label==null || label.equals("")) {
+			label = "rbg"+radioButtonGroups.size();
+			insets.top += 5;
+		} else {
+			setInsets(10, insets.left, 0);
+			addMessage(label);
+			insets.top = 2;
+			insets.left += 10;
+		}
+		c.gridx = 0; c.gridy++;
+		c.gridwidth = GridBagConstraints.REMAINDER;
+		c.anchor = GridBagConstraints.WEST;
+		c.insets = new Insets(insets.top, insets.left, 0, 0);
+		add(panel, c);
+		if (Recorder.record || macro)
+			saveLabel(cg, label);
+    }
+
+    /** Adds a popup menu.
+   * @param label	the label
+   * @param items	the menu items
+   * @param defaultItem	the menu item initially selected
+   */
+   public void addChoice(String label, String[] items, String defaultItem) {
+   		String label2 = label;
+   		if (label2.indexOf('_')!=-1)
+   			label2 = label2.replace('_', ' ');
+		Label fieldLabel = makeLabel(label2);
+		this.lastLabelAdded = fieldLabel;
+		if (addToSameRow) {
+			c.gridx = GridBagConstraints.RELATIVE;
+			addToSameRow = false;
+		} else {
+			c.gridx = 0; c.gridy++;
+			if (choice==null)
+				c.insets = getInsets(5, 0, 5, 0);
+			else
+				c.insets = getInsets(0, 0, 5, 0);
+		}
+		c.anchor = GridBagConstraints.EAST;
+		c.gridwidth = 1;
+		if (choice==null) {
+			choice = new Vector(4);
+			defaultChoiceIndexes = new Vector(4);
+		}
+		add(fieldLabel, c);
+		Choice thisChoice = new Choice();
+		thisChoice.addKeyListener(this);
+		thisChoice.addItemListener(this);
+		for (int i=0; i<items.length; i++)
+			thisChoice.addItem(items[i]);
+		if (defaultItem!=null)
+			thisChoice.select(defaultItem);
+		else
+			thisChoice.select(0);
+		c.gridx = GridBagConstraints.RELATIVE;
+		c.anchor = GridBagConstraints.WEST;
+		add(thisChoice, c);
+		choice.addElement(thisChoice);
+		int index = thisChoice.getSelectedIndex();
+		defaultChoiceIndexes.addElement(new Integer(index));
+		if (Recorder.record || macro)
+			saveLabel(thisChoice, label);
+    }
+
+    /** Adds a message consisting of one or more lines of text. */
+    public void addMessage(String text) {
+    	addMessage(text, null, null);
+    }
+
+    /** Adds a message consisting of one or more lines of text,
+    	which will be displayed using the specified font. */
+    public void addMessage(String text, Font font) {
+    	addMessage(text, font, null);
+    }
+
+    /** Adds a message consisting of one or more lines of text,
+    	which will be displayed using the specified font and color. */
+    public void addMessage(String text, Font font, Color color) {
+    	theLabel = null;
+    	if (text.indexOf('\n')>=0)
+			theLabel = new MultiLineLabel(text);
+		else
+			theLabel = new Label(text);
+		if (addToSameRow) {
+			c.gridx = GridBagConstraints.RELATIVE;
+			addToSameRow = false;
+		} else {
+			c.gridx = 0; c.gridy++;
+			c.insets = getInsets("".equals(text)?0:10, 20, 0, 0); // top, left, bottom, right
+		}
+		c.gridwidth = GridBagConstraints.REMAINDER;
+		c.anchor = GridBagConstraints.WEST;
+		c.fill = GridBagConstraints.HORIZONTAL;
+		if (font!=null) {
+			if (Prefs.getGuiScale()>1.0)
+				font = font.deriveFont((float)(font.getSize()*Prefs.getGuiScale()));
+			theLabel.setFont(font);
+		}
+		if (color!=null)
+			theLabel.setForeground(color);
+		add(theLabel, c);
+		c.fill = GridBagConstraints.NONE;
+    }
+
+	/** Adds one or two (side by side) text areas.
+	 * Append "SCROLLBARS_VERTICAL_ONLY" to the text of
+	 * the first text area to get vertical scrollbars
+	 * and "SCROLLBARS_BOTH" to get both vertical and
+	 * horizontal scrollbars.
+	 * @param text1	initial contents of the first text area
+	 * @param text2	initial contents of the second text area or null
+	 * @param rows	the number of rows
+	 * @param columns	the number of columns
+	*/
+    public void addTextAreas(String text1, String text2, int rows, int columns) {
+		if (textArea1!=null) return;
+		Panel panel = new Panel();
+		int scrollbars = TextArea.SCROLLBARS_NONE;
+		if (text1!=null && text1.endsWith("SCROLLBARS_BOTH")) {
+			scrollbars = TextArea.SCROLLBARS_BOTH;
+			text1 = text1.substring(0, text1.length()-15);
+		}
+		if (text1!=null && text1.endsWith("SCROLLBARS_VERTICAL_ONLY")) {
+			scrollbars = TextArea.SCROLLBARS_VERTICAL_ONLY;
+			text1 = text1.substring(0, text1.length()-24);
+		}
+		Font font = new Font("SansSerif", Font.PLAIN, (int)(14*Prefs.getGuiScale()));
+		textArea1 = new TextArea(text1,rows,columns,scrollbars);
+		if (IJ.isLinux()) textArea1.setBackground(Color.white);
+		textArea1.setFont(font);
+		textArea1.addTextListener(this);
+		panel.add(textArea1);
+		if (text2!=null) {
+			textArea2 = new TextArea(text2,rows,columns,scrollbars);
+			if (IJ.isLinux()) textArea2.setBackground(Color.white);
+			textArea2.setFont(font);
+			panel.add(textArea2);
+		}
+		c.gridx = 0; c.gridy++;
+		c.gridwidth = GridBagConstraints.REMAINDER;
+		c.anchor = GridBagConstraints.WEST;
+		c.insets = getInsets(15, 20, 0, 0);
+		addToSameRow = false;
+		add(panel, c);
+    }
+
+	/**
+	* Adds a slider (scroll bar) to the dialog box.
+	* Floating point values are used if (maxValue-minValue)<=5.0
+	* and either defaultValue or minValue are non-integer.
+	* @param label	 the label
+	* @param minValue  the minimum value of the slider
+	* @param maxValue  the maximum value of the slider
+	* @param defaultValue  the initial value of the slider
+	*/
+	public void addSlider(String label, double minValue, double maxValue, double defaultValue) {
+		if (defaultValue<minValue) defaultValue=minValue;
+		if (defaultValue>maxValue) defaultValue=maxValue;
+		int digits = 0;
+		double scale = 1.0;
+		if ((maxValue-minValue)<=5.0 && (minValue!=(int)minValue||maxValue!=(int)maxValue||defaultValue!=(int)defaultValue)) {
+			scale = 50.0;
+			minValue *= scale;
+			maxValue *= scale;
+			defaultValue *= scale;
+			digits = 2;
+		}
+		addSlider( label, minValue, maxValue, defaultValue, scale, digits);
+	}
+
+	/** This vesion of addSlider() adds a 'stepSize' argument.<br>
+	 * Example: http://wsr.imagej.net/macros/SliderDemo.txt
+	*/
+	public void addSlider(String label, double minValue, double maxValue, double defaultValue, double stepSize) {
+		if ( stepSize <= 0 ) stepSize  = 1;
+		int digits = digits(stepSize);
+		if (digits==1 && "Angle:".equals(label))
+			digits = 2;
+		double scale = 1.0 / Math.abs( stepSize );
+		if ( scale <= 0 ) scale = 1;
+		if ( defaultValue < minValue ) defaultValue = minValue;
+		if ( defaultValue > maxValue ) defaultValue = maxValue;
+		minValue *= scale;
+		maxValue *= scale;
+		defaultValue *= scale;
+		addSlider(label, minValue, maxValue, defaultValue, scale, digits);
+	}
+
+	/** Author: Michael Kaul */
+	private static int digits(double d) {
+		if (d == (int)d)
+			return 0;
+		String s  = Double.toString(d);
+		int ePos  = s.indexOf("E");
+		if (ePos==-1)
+			ePos   = s.indexOf("e");
+		int dotPos = s.indexOf( "." );
+		int digits = 0;
+		if (ePos==-1 )
+			digits = s.substring(dotPos+1).length();
+		else {
+			String number = s.substring( dotPos + 1, ePos );
+			if (!number.equals( "0" ))
+				digits += number.length( );
+			digits = digits - Integer.valueOf(s.substring(ePos+1));
+		}
+		return digits;
+	}
+
+	private void addSlider(String label, double minValue, double maxValue, double defaultValue, double scale, int digits) {
+		int columns = 4 + digits - 2;
+		if ( columns < 4 ) columns = 4;
+		if (minValue<0.0) columns++;
+		String mv = IJ.d2s(maxValue,0);
+		if (mv.length()>4 && digits==0)
+			columns += mv.length()-4;
+   		String label2 = label;
+   		if (label2.indexOf('_')!=-1)
+   			label2 = label2.replace('_', ' ');
+		Label fieldLabel = makeLabel(label2);
+		this.lastLabelAdded = fieldLabel;
+		if (addToSameRow) {
+			c.gridx = GridBagConstraints.RELATIVE;
+			c.insets.bottom += 3;
+			addToSameRow = false;
+		} else {
+			c.gridx = 0; c.gridy++;
+			c.insets = getInsets(0, 0, 3, 0); // top, left, bottom, right
+		}
+		c.anchor = GridBagConstraints.EAST;
+		c.gridwidth = 1;
+		add(fieldLabel, c);
+
+		if (slider==null) {
+			slider = new Vector(5);
+			sliderIndexes = new Vector(5);
+			sliderScales = new Vector(5);
+			sliderDigits = new Vector(5);
+		}
+		Scrollbar s = new Scrollbar(Scrollbar.HORIZONTAL, (int)defaultValue, 1, (int)minValue, (int)maxValue+1);
+		GUI.fixScrollbar(s);
+		slider.addElement(s);
+		s.addAdjustmentListener(this);
+		s.setUnitIncrement(1);
+		if (IJ.isMacOSX())
+			s.addKeyListener(this);
+
+		if (numberField==null) {
+			numberField = new Vector(5);
+			defaultValues = new Vector(5);
+			defaultText = new Vector(5);
+		}
+		if (IJ.isWindows()) columns -= 2;
+		if (columns<1) columns = 1;
+		//IJ.log("scale=" + scale + ", columns=" + columns + ", digits=" + digits);
+		TextField tf = new TextField(IJ.d2s(defaultValue/scale, digits), columns);
+		if (IJ.isLinux()) tf.setBackground(Color.white);
+		tf.addActionListener(this);
+		tf.addTextListener(this);
+		tf.addFocusListener(this);
+		tf.addKeyListener(this);
+		numberField.addElement(tf);
+		sliderIndexes.add(new Integer(numberField.size()-1));
+		sliderScales.add(new Double(scale));
+		sliderDigits.add(new Integer(digits));
+		defaultValues.addElement(new Double(defaultValue/scale));
+		defaultText.addElement(tf.getText());
+		tf.setEditable(true);
+		firstSlider = false;
+
+    	Panel panel = new Panel();
+		GridBagLayout pgrid = new GridBagLayout();
+		GridBagConstraints pc  = new GridBagConstraints();
+		panel.setLayout(pgrid);
+		pc.gridx = 0; pc.gridy = 0;
+		pc.gridwidth = 1;
+		pc.ipadx = 85;
+		pc.anchor = GridBagConstraints.WEST;
+		panel.add(s, pc);
+		pc.ipadx = 0;  // reset
+		// text field
+		pc.gridx = 1;
+		pc.insets = new Insets(5, 5, 0, 0);
+		pc.anchor = GridBagConstraints.EAST;
+    	panel.add(tf, pc);
+
+		c.gridx = GridBagConstraints.RELATIVE;
+		c.gridwidth = 1;
+		c.anchor = GridBagConstraints.WEST;
+        c.insets.left = 0;
+        c.insets.bottom -= 3;
+		add(panel, c);
+		if (Recorder.record || macro)
+			saveLabel(tf, label);
+    }
+
+    /** Adds a Panel to the dialog. */
+    public void addPanel(Panel panel) {
+    	addPanel(panel, GridBagConstraints.WEST, addToSameRow ? c.insets : getInsets(5,0,0,0));
+    }
+
+    /** Adds a Panel to the dialog with custom contraint and insets. The
+    	defaults are GridBagConstraints.WEST (left justified) and
+    	"new Insets(5, 0, 0, 0)" (5 pixels of padding at the top). */
+    public void addPanel(Panel panel, int constraints, Insets insets) {
+		if (addToSameRow) {
+			c.gridx = GridBagConstraints.RELATIVE;
+			addToSameRow = false;
+		} else {
+			c.gridx = 0; c.gridy++;
+		}
+		c.gridwidth = 2;
+		c.anchor = constraints;
+		c.insets = insets;
+		add(panel, c);
+    }
+
+	/** Adds an image to the dialog. */
+    public void addImage(ImagePlus image) {
+    	ImagePanel imagePanel = new ImagePanel(image);
+    	addPanel(imagePanel);
+    	if (imagePanels==null)
+    		imagePanels = new Vector();
+    	imagePanels.add(imagePanel);
+    }
+
+    /** Set the insets (margins), in pixels, that will be
+    	used for the next component added to the dialog
+        (except components added to the same row with addToSameRow)
+    <pre>
+    Default insets:
+        addMessage: 0,20,0 (empty string) or 10,20,0
+        addCheckbox: 15,20,0 (first checkbox) or 0,20,0
+        addCheckboxGroup: 10,0,0
+        addRadioButtonGroup: 5,10,0
+        addNumericField: 5,0,3 (first field) or 0,0,3
+        addStringField: 5,0,5 (first field) or 0,0,5
+        addChoice: 5,0,5 (first field) or 0,0,5
+     </pre>
+    */
+    public void setInsets(int top, int left, int bottom) {
+    	topInset = top;
+    	leftInset = left;
+    	bottomInset = bottom;
+    	customInsets = true;
+    }
+
+    /** Makes the next item appear in the same row as the previous.
+     *  May be used for addNumericField, addSlider, addChoice, addCheckbox, addStringField,
+     *  addMessage, addPanel, and before the showDialog() method
+     *  (in the latter case, the buttons appear to the right of the previous item).
+     *  Note that addMessage (and addStringField, if its column width is more than 8) use
+     *  the remaining width, so it must be the last item of a row.
+     */
+    public void addToSameRow() {
+        addToSameRow = true;
+        addToSameRowCalled = true;
+    }
+
+    /** Sets a replacement label for the "OK" button. */
+    public void setOKLabel(String label) {
+		okay.setLabel(label);
+    }
+
+    /** Sets a replacement label for the "Cancel" button. */
+    public void setCancelLabel(String label) {
+    	cancel.setLabel(label);
+    }
+
+    /** Sets a replacement label for the "Help" button. */
+    public void setHelpLabel(String label) {
+    	helpLabel = label;
+    }
+
+    /** Unchanged parameters are not recorder in 'smart recording' mode. */
+    public void setSmartRecording(boolean smartRecording) {
+    	this.smartRecording = smartRecording;
+    }
+
+    /** Make this a "Yes No Cancel" dialog. */
+    public void enableYesNoCancel() {
+    	enableYesNoCancel(" Yes ", " No ");
+    }
+
+    /** Make this a "Yes No Cancel" dialog with custom labels. Here is an example:
+    	<pre>
+        GenericDialog gd = new GenericDialog("YesNoCancel Demo");
+        gd.addMessage("This is a custom YesNoCancel dialog");
+        gd.enableYesNoCancel("Do something", "Do something else");
+        gd.showDialog();
+        if (gd.wasCanceled())
+            IJ.log("User clicked 'Cancel'");
+        else if (gd.wasOKed())
+            IJ. log("User clicked 'Yes'");
+        else
+            IJ. log("User clicked 'No'");
+    	</pre>
+	*/
+	public void enableYesNoCancel(String yesLabel, String noLabel) {
+		okay.setLabel(yesLabel);
+		if (no != null)
+			no.setLabel(noLabel);
+		else if (noLabel!=null)
+			no = new Button(noLabel);
+	}
+
+    /** Do not display "Cancel" button. */
+    public void hideCancelButton() {
+    	hideCancelButton = true;
+    }
+
+	Insets getInsets(int top, int left, int bottom, int right) {
+		if (customInsets) {
+			customInsets = false;
+			return new Insets(topInset, leftInset, bottomInset, 0);
+		} else
+			return new Insets(top, left, bottom, right);
+	}
+
+    /** Add an Object implementing the DialogListener interface. This object will
+     * be notified by its dialogItemChanged method of input to the dialog. The first
+     * DialogListener will be also called after the user has typed 'OK' or if the
+     * dialog has been invoked by a macro; it should read all input fields of the
+     * dialog.
+     * For other listeners, the OK button will not cause a call to dialogItemChanged;
+     * the CANCEL button will never cause such a call.
+     * @param dl the Object that wants to listen.
+     */
+    public void addDialogListener(DialogListener dl) {
+        if (dialogListeners == null)
+            dialogListeners = new Vector();
+        dialogListeners.addElement(dl);
+    }
+
+	/** Returns true if the user clicked on "Cancel". */
+    public boolean wasCanceled() {
+    	if (wasCanceled && !Thread.currentThread().getName().endsWith("Script_Macro$"))
+    		Macro.abort();
+    	return wasCanceled;
+    }
+
+	/** Returns true if the user has clicked on "OK" or a macro is running. */
+    public boolean wasOKed() {
+    	return wasOKed || macro;
+    }
+
+	/** Returns the contents of the next numeric field,
+		or NaN if the field does not contain a number. */
+    public double getNextNumber() {
+		if (numberField==null)
+			return -1.0;
+		TextField tf = (TextField)numberField.elementAt(nfIndex);
+		String theText = tf.getText();
+		String label=null;
+		if (macro) {
+			label = (String)labels.get((Object)tf);
+			theText = Macro.getValue(macroOptions, label, theText);
+		}
+		String originalText = (String)defaultText.elementAt(nfIndex);
+		double defaultValue = ((Double)(defaultValues.elementAt(nfIndex))).doubleValue();
+		double value;
+		boolean skipRecording = false;
+		if (theText.equals(originalText)) {
+			value = defaultValue;
+			if (smartRecording) skipRecording=true;
+		} else {
+			Double d = getValue(theText);
+			if (d!=null)
+				value = d.doubleValue();
+			else {
+				// Is the value a macro variable?
+				if (theText.startsWith("&")) theText = theText.substring(1);
+				Interpreter interp = Interpreter.getInstance();
+				value = interp!=null?interp.getVariable2(theText):Double.NaN;
+				if (Double.isNaN(value)) {
+					invalidNumber = true;
+					errorMessage = "\""+theText+"\" is an invalid number";
+					value = Double.NaN;
+					if (macro) {
+						IJ.error("Macro Error", "Numeric value expected in run() function\n \n"
+							+"   Dialog box title: \""+getTitle()+"\"\n"
+							+"   Key: \""+label.toLowerCase(Locale.US)+"\"\n"
+							+"   Value or variable name: \""+theText+"\"");
+					}
+				}
+			}
+		}
+		if (recorderOn && !skipRecording) {
+			recordOption(tf, trim(theText));
+		}
+		nfIndex++;
+		return value;
+    }
+
+	private String trim(String value) {
+		if (value.endsWith(".0"))
+			value = value.substring(0, value.length()-2);
+		if (value.endsWith(".00"))
+			value = value.substring(0, value.length()-3);
+		return value;
+	}
+
+	private void recordOption(Object component, String value) {
+		String label = (String)labels.get(component);
+		if (value.equals("")) value = "[]";
+		Recorder.recordOption(label, value);
+	}
+
+	private void recordCheckboxOption(Checkbox cb) {
+		String label = (String)labels.get((Object)cb);
+		if (label!=null) {
+			if (cb.getState()) // checked
+				Recorder.recordOption(label);
+			else if (Recorder.getCommandOptions()==null)
+				Recorder.recordOption(" ");
+		}
+	}
+
+ 	protected Double getValue(String text) {
+ 		Double d;
+ 		try {d = new Double(text);}
+		catch (NumberFormatException e){
+			d = null;
+		}
+		return d;
+	}
+
+	public double parseDouble(String s) {
+		if (s==null) return Double.NaN;
+		double value = Tools.parseDouble(s);
+		if (Double.isNaN(value)) {
+			if (s.startsWith("&")) s = s.substring(1);
+			Interpreter interp = Interpreter.getInstance();
+			value = interp!=null?interp.getVariable2(s):Double.NaN;
+		}
+		return value;
+	}
+
+	/** Returns true if one or more of the numeric fields contained an
+		invalid number. Must be called after one or more calls to getNextNumber(). */
+    public boolean invalidNumber() {
+    	boolean wasInvalid = invalidNumber;
+    	invalidNumber = false;
+    	return wasInvalid;
+    }
+
+	/** Returns an error message if getNextNumber was unable to convert a
+		string into a number, otherwise, returns null. */
+	public String getErrorMessage() {
+		return errorMessage;
+   	}
+
+  	/** Returns the contents of the next text field. */
+   public String getNextString() {
+   		String theText;
+		if (stringField==null)
+			return "";
+		TextField tf = (TextField)(stringField.elementAt(sfIndex));
+		theText = tf.getText();
+		String label = labels!=null?(String)labels.get((Object)tf):"";
+		if (macro) {
+			theText = Macro.getValue(macroOptions, label, theText);
+			if (theText!=null && (theText.startsWith("&")||label.toLowerCase(Locale.US).startsWith(theText))) {
+				// Is the value a macro variable?
+				if (theText.startsWith("&")) theText = theText.substring(1);
+				Interpreter interp = Interpreter.getInstance();
+				String s = interp!=null?interp.getVariableAsString(theText):null;
+				if (s!=null) theText = s;
+			}
+		}
+		if (recorderOn && !label.equals("")) {
+			String s = theText;
+			if (s!=null&&s.length()>=3&&Character.isLetter(s.charAt(0))&&s.charAt(1)==':'&&s.charAt(2)=='\\')
+				s = s.replaceAll("\\\\", "/");  // replace "\" with "/" in Windows file paths
+			s = Recorder.fixString(s);
+			if (!smartRecording || !s.equals((String)defaultStrings.elementAt(sfIndex)))
+				recordOption(tf, s);
+			else if (Recorder.getCommandOptions()==null)
+				Recorder.recordOption(" ");
+		}
+		sfIndex++;
+		return theText;
+    }
+
+  	/** Returns the state of the next checkbox. */
+    public boolean getNextBoolean() {
+		if (checkbox==null)
+			return false;
+		Checkbox cb = (Checkbox)(checkbox.elementAt(cbIndex));
+		if (recorderOn)
+			recordCheckboxOption(cb);
+		boolean state = cb.getState();
+		if (macro) {
+			String label = (String)labels.get((Object)cb);
+			String key = Macro.trimKey(label);
+			state = isMatch(macroOptions, key+" ");
+		}
+		cbIndex++;
+		return state;
+    }
+
+    // Returns true if s2 is in s1 and not in a bracketed literal (e.g., "[literal]")
+    boolean isMatch(String s1, String s2) {
+    	if (s1.startsWith(s2))
+    		return true;
+    	s2 = " " + s2;
+    	int len1 = s1.length();
+    	int len2 = s2.length();
+    	boolean match, inLiteral=false;
+    	char c;
+    	for (int i=0; i<len1-len2+1; i++) {
+    		c = s1.charAt(i);
+     		if (inLiteral && c==']')
+    			inLiteral = false;
+    		else if (c=='[')
+    			inLiteral = true;
+    		if (c!=s2.charAt(0) || inLiteral || (i>1&&s1.charAt(i-1)=='='))
+    			continue;
+    		match = true;
+			for (int j=0; j<len2; j++) {
+				if (s2.charAt(j)!=s1.charAt(i+j))
+					{match=false; break;}
+			}
+			if (match) return true;
+    	}
+    	return false;
+    }
+
+  	/** Returns the selected item in the next popup menu. */
+    public String getNextChoice() {
+		if (choice==null)
+			return "";
+		Choice thisChoice = (Choice)(choice.elementAt(choiceIndex));
+		String item = thisChoice.getSelectedItem();
+		if (macro) {
+			String label = (String)labels.get((Object)thisChoice);
+			item = Macro.getValue(macroOptions, label, item);
+			if (item!=null && item.startsWith("&")) // value is macro variable
+				item = getChoiceVariable(item);
+		}
+		if (recorderOn)
+			recordOption(thisChoice, item);
+		choiceIndex++;
+		return item;
+    }
+
+  	/** Returns the index of the selected item in the next popup menu. */
+    public int getNextChoiceIndex() {
+		if (choice==null)
+			return -1;
+		Choice thisChoice = (Choice)(choice.elementAt(choiceIndex));
+		int index = thisChoice.getSelectedIndex();
+		if (macro) {
+			String label = (String)labels.get((Object)thisChoice);
+			String oldItem = thisChoice.getSelectedItem();
+			int oldIndex = thisChoice.getSelectedIndex();
+			String item = Macro.getValue(macroOptions, label, oldItem);
+			if (item!=null && item.startsWith("&")) // value is macro variable
+				item = getChoiceVariable(item);
+			thisChoice.select(item);
+			index = thisChoice.getSelectedIndex();
+			if (index==oldIndex && !item.equals(oldItem)) {
+				// is value a macro variable?
+				Interpreter interp = Interpreter.getInstance();
+				String s = interp!=null?interp.getStringVariable(item):null;
+				if (s==null)
+					IJ.error(getTitle(), "\""+item+"\" is not a valid choice for \""+label+"\"");
+				else
+					item = s;
+			}
+		}
+		if (recorderOn) {
+			int defaultIndex = ((Integer)(defaultChoiceIndexes.elementAt(choiceIndex))).intValue();
+			if (!(smartRecording&&index==defaultIndex)) {
+				String item = thisChoice.getSelectedItem();
+				if (!(item.equals("*None*")&&getTitle().equals("Merge Channels")))
+					recordOption(thisChoice, thisChoice.getSelectedItem());
+			}
+		}
+		choiceIndex++;
+		return index;
+    }
+
+  	/** Returns the selected item in the next radio button group. */
+    public String getNextRadioButton() {
+		if (radioButtonGroups==null)
+			return null;
+		CheckboxGroup cg = (CheckboxGroup)(radioButtonGroups.elementAt(radioButtonIndex));
+		radioButtonIndex++;
+		Checkbox checkbox = cg.getSelectedCheckbox();
+		String item = "null";
+		if (checkbox!=null)
+			item = checkbox.getLabel();
+		if (macro) {
+			String label = (String)labels.get((Object)cg);
+			item = Macro.getValue(macroOptions, label, item);
+		}
+		if (recorderOn)
+			recordOption(cg, item);
+		return item;
+    }
+
+    private String getChoiceVariable(String item) {
+		item = item.substring(1);
+		Interpreter interp = Interpreter.getInstance();
+		String s = interp!=null?interp.getStringVariable(item):null;
+		if (s==null) {
+			double value = interp!=null?interp.getVariable2(item):Double.NaN;
+			if (!Double.isNaN(value)) {
+				if ((int)value==value)
+					s = ""+(int)value;
+				else
+					s = ""+value;
+			}
+		}
+		if (s!=null)
+			item = s;
+		return item;
+	}
+
+  	/** Returns the contents of the next text area. */
+	public String getNextText() {
+		String text = null;
+		String key = "text1";
+		if (textAreaIndex==0 && textArea1!=null) {
+			text = textArea1.getText();
+			if (macro)
+				text = Macro.getValue(macroOptions, "text1", text);
+		} else if (textAreaIndex==1 && textArea2!=null) {
+			text = textArea2.getText();
+			if (macro)
+				text = Macro.getValue(macroOptions, "text2", text);
+			key = "text2";
+		}
+		textAreaIndex++;
+		if (recorderOn && text!=null) {
+			String text2 = text;
+			String cmd = Recorder.getCommand();
+			if (cmd!=null && cmd.equals("Calibrate..."))
+				text2 = text2.replace('\n',' ');
+			if (cmd!=null && cmd.equals("Convolve...")){
+				if (!text2.endsWith("\n"))
+					text2 += "\n";
+			}
+			text2 = Recorder.fixString(text2);
+			Recorder.recordOption(key, text2);
+		}
+		return text;
+	}
+
+	/** Displays this dialog box. */
+	public void showDialog() {
+		showDialogCalled = true;
+		if (macro) {
+			dispose();
+			recorderOn = Recorder.record && Recorder.recordInMacros;
+		} else {
+			if (pfr!=null) // prepare preview (not in macro mode): tell the PlugInFilterRunner to listen
+			pfr.setDialog(this);
+			Panel buttons = new Panel();
+			buttons.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+			okay.addActionListener(this);
+			okay.addKeyListener(this);
+			if (!hideCancelButton) {
+				cancel.addActionListener(this);
+				cancel.addKeyListener(this);
+			}
+			if (no != null) {
+				no.addActionListener(this);
+				no.addKeyListener(this);
+			}
+			boolean addHelp = helpURL!=null;
+			if (addHelp) {
+				help = new Button(helpLabel);
+				help.addActionListener(this);
+				help.addKeyListener(this);
+			}
+			if (IJ.isWindows() || Prefs.dialogCancelButtonOnRight) {
+				buttons.add(okay);
+				if (no != null) buttons.add(no);;
+				if (!hideCancelButton)
+					buttons.add(cancel);
+				if (addHelp) buttons.add(help);
+			} else {
+				if (addHelp) buttons.add(help);
+				if (no != null) buttons.add(no);
+				if (!hideCancelButton) buttons.add(cancel);
+				buttons.add(okay);
+			}
+			if (addToSameRow) {
+				c.gridx = GridBagConstraints.RELATIVE;
+			} else {
+				c.gridx = 0; c.gridy++;
+			}
+			c.anchor = GridBagConstraints.EAST;
+			c.gridwidth = addToSameRowCalled?GridBagConstraints.REMAINDER:2;
+			c.insets = new Insets(15, 0, 0, 0);
+			add(buttons, c);
+			instance = this;
+			Font font = getFont();
+			if (!fontSizeSet && font!=null && Prefs.getGuiScale()!=1.0) {
+				fontSizeSet = true;
+				setFont(font.deriveFont((float)(font.getSize()*Prefs.getGuiScale())));
+			}
+			pack();
+			if (okay!=null && numberField==null && stringField==null && checkbox==null
+			&& choice==null && slider==null && radioButtonGroups==null && textArea1==null)
+				okay.requestFocusInWindow();
+			setup();
+			if (centerDialog)
+				GUI.centerOnImageJScreen(this);
+			setVisible(true);					//except for NonBlockingGenericDialog, returns after 'dispose' by OK or Cancel
+
+		}
+	}
+	
+	/** For plugins that read their input only via dialogItemChanged, call it at least once, then stop recording */
+	void finalizeRecording() {
+		if (optionsRecorded)
+			return;
+		optionsRecorded = true;
+		if (!wasCanceled && dialogListeners!=null && dialogListeners.size()>0) {
+			resetCounters();
+			((DialogListener)dialogListeners.elementAt(0)).dialogItemChanged(this,null);
+			recorderOn = false;
+		}
+		resetCounters();
+	}
+
+	@Override
+	public void setFont(Font font) {
+		super.setFont(!fontSizeSet&&Prefs.getGuiScale()!=1.0&&font!=null?font.deriveFont((float)(font.getSize()*Prefs.getGuiScale())):font);
+		fontSizeSet = true;
+	}
+	
+    /** Reset the counters before reading the dialog parameters */
+	void resetCounters() {
+		nfIndex = 0;        // prepare for readout
+		sfIndex = 0;
+		cbIndex = 0;
+		choiceIndex = 0;
+		textAreaIndex = 0;
+		radioButtonIndex = 0;
+		invalidNumber = false;
+	}
+
+	/** Returns the Vector containing the numeric TextFields. */
+  	public Vector getNumericFields() {
+  		return numberField;
+  	}
+
+  	/** Returns the Vector containing the string TextFields. */
+  	public Vector getStringFields() {
+  		return stringField;
+  	}
+
+  	/** Returns the Vector containing the Checkboxes. */
+  	public Vector getCheckboxes() {
+  		return checkbox;
+  	}
+
+  	/** Returns the Vector containing the Choices. */
+  	public Vector getChoices() {
+  		return choice;
+  	}
+
+  	/** Returns the Vector containing the sliders (Scrollbars). */
+  	public Vector getSliders() {
+  		return slider;
+  	}
+
+  	/** Returns the Vector that contains the RadioButtonGroups. */
+  	public Vector getRadioButtonGroups() {
+  		return radioButtonGroups;
+  	}
+
+  	/** Returns a reference to textArea1. */
+  	public TextArea getTextArea1() {
+  		return textArea1;
+  	}
+
+  	/** Returns a reference to textArea2. */
+  	public TextArea getTextArea2() {
+  		return textArea2;
+  	}
+
+  	/** Returns a reference to the Label or MultiLineLabel created by the
+  	 *	last addMessage() call. Otherwise returns null. */
+  	public Component getMessage() {
+  		return theLabel;
+  	}
+
+    /** Returns a reference to the Preview checkbox. */
+    public Checkbox getPreviewCheckbox() {
+        return previewCheckbox;
+    }
+
+    /** Returns 'true' if this dialog has a "Preview" checkbox and it is enabled. */
+    public boolean isPreviewActive() {
+        return previewCheckbox!=null && previewCheckbox.getState();
+    }
+
+	/** Returns references to the "OK" ("Yes"), "Cancel",
+		and if present, "No" buttons as an array. */
+	public Button[] getButtons() {
+  		Button[] buttons = new Button[3];
+  		buttons[0] = okay;
+  		buttons[1] = cancel;
+  		buttons[2] = no;
+		return buttons;
+  	}
+
+    /** Used by PlugInFilterRunner to provide visable feedback whether preview
+    	is running or not by switching from "Preview" to "wait..."
+     */
+    public void previewRunning(boolean isRunning) {
+        if (previewCheckbox!=null) {
+            previewCheckbox.setLabel(isRunning ? previewRunning : previewLabel);
+            if (IJ.isMacOSX()) repaint();   //workaround OSX 10.4 refresh bug
+        }
+    }
+
+    /** Display dialog centered on the primary screen. */
+    public void centerDialog(boolean b) {
+    	centerDialog = b;
+    }
+
+    /* Display the dialog at the specified location. */
+    public void setLocation(int x, int y) {
+    	super.setLocation(x, y);
+    	centerDialog = false;
+    }
+
+    public void setDefaultString(int index, String str) {
+    	if (defaultStrings!=null && index>=0 && index<defaultStrings.size())
+    		defaultStrings.set(index, str);
+    }
+
+    protected void setup() {
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		Object source = e.getSource();
+		if (source==okay || source==cancel | source==no) {
+			wasCanceled = source==cancel;
+			wasOKed = source==okay;
+			dispose();
+		} else if (source==help) {
+			if (hideCancelButton) {
+				if (helpURL!=null && helpURL.equals("")) {
+            		notifyListeners(e);
+            		return;
+				} else {
+					wasOKed = true;
+					dispose();
+				}
+			}
+			showHelp();
+		} else
+            notifyListeners(e);
+	}
+
+	public void textValueChanged(TextEvent e) {
+        notifyListeners(e);
+		if (slider==null) return;
+		Object source = e.getSource();
+		for (int i=0; i<slider.size(); i++) {
+			int index = ((Integer)sliderIndexes.get(i)).intValue();
+			if (source==numberField.elementAt(index)) {
+				TextField tf = (TextField)numberField.elementAt(index);
+				double value = Tools.parseDouble(tf.getText());
+				if (!Double.isNaN(value)) {
+					Scrollbar sb = (Scrollbar)slider.elementAt(i);
+					double scale = ((Double)sliderScales.get(i)).doubleValue();
+					sb.setValue((int)(value*scale));
+				}
+			}
+		}
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+        notifyListeners(e);
+	}
+
+	public void focusGained(FocusEvent e) {
+		Component c = e.getComponent();
+		//IJ.log("focusGained: "+c);
+		if (c instanceof TextField)
+			((TextField)c).selectAll();
+	}
+
+	public void focusLost(FocusEvent e) {
+		Component c = e.getComponent();
+		if (c instanceof TextField)
+			((TextField)c).select(0,0);
+	}
+
+	public void keyPressed(KeyEvent e) {
+		Component component = e.getComponent();
+		int keyCode = e.getKeyCode();
+		IJ.setKeyDown(keyCode);
+		if ((component instanceof Scrollbar) && (keyCode==KeyEvent.VK_LEFT||keyCode==KeyEvent.VK_RIGHT)) {
+			Scrollbar sb = (Scrollbar)component;
+			int value = sb.getValue();
+			if (keyCode==KeyEvent.VK_RIGHT)
+				sb.setValue(value+1);
+			else
+				sb.setValue(value-1);
+			for (int i=0; i<slider.size(); i++) {
+				if (sb==slider.elementAt(i)) {
+					int index = ((Integer)sliderIndexes.get(i)).intValue();
+					TextField tf = (TextField)numberField.elementAt(index);
+					double scale = ((Double)sliderScales.get(i)).doubleValue();
+					int digits = ((Integer)sliderDigits.get(i)).intValue();
+					tf.setText(""+IJ.d2s(sb.getValue()/scale,digits));
+				}
+			}
+			notifyListeners(e);
+			return;
+		}
+		if (keyCode==KeyEvent.VK_ENTER && textArea1==null && okay!=null && okay.isEnabled()) {
+			wasOKed = true;
+			if (IJ.isMacOSX())
+				accessTextFields();
+			dispose();
+		} else if (keyCode==KeyEvent.VK_ESCAPE) {
+			wasCanceled = true;
+			dispose();
+			IJ.resetEscape();
+		} else if (keyCode==KeyEvent.VK_W && (e.getModifiers()&Toolkit.getDefaultToolkit().getMenuShortcutKeyMask())!=0) {
+			wasCanceled = true;
+			dispose();
+		}
+	}
+
+	void accessTextFields() {
+		if (stringField!=null) {
+			for (int i=0; i<stringField.size(); i++)
+				((TextField)(stringField.elementAt(i))).getText();
+		}
+		if (numberField!=null) {
+			for (int i=0; i<numberField.size(); i++)
+				((TextField)(numberField.elementAt(i))).getText();
+		}
+	}
+
+	public void keyReleased(KeyEvent e) {
+		int keyCode = e.getKeyCode();
+		IJ.setKeyUp(keyCode);
+		int flags = e.getModifiers();
+		boolean control = (flags & KeyEvent.CTRL_MASK) != 0;
+		boolean meta = (flags & KeyEvent.META_MASK) != 0;
+		boolean shift = (flags & e.SHIFT_MASK) != 0;
+		if (keyCode==KeyEvent.VK_G && shift && (control||meta))
+			new ScreenGrabber().run("");
+	}
+
+	public void keyTyped(KeyEvent e) {}
+
+	public Insets getInsets() {
+    	Insets i= super.getInsets();
+    	return new Insets(i.top+10, i.left+10, i.bottom+10, i.right+10);
+	}
+
+	public synchronized void adjustmentValueChanged(AdjustmentEvent e) {
+		Object source = e.getSource();
+		for (int i=0; i<slider.size(); i++) {
+			if (source==slider.elementAt(i)) {
+				Scrollbar sb = (Scrollbar)source;
+				int index = ((Integer)sliderIndexes.get(i)).intValue();
+				TextField tf = (TextField)numberField.elementAt(index);
+				double scale = ((Double)sliderScales.get(i)).doubleValue();
+				int digits = ((Integer)sliderDigits.get(i)).intValue();
+				tf.setText(""+IJ.d2s(sb.getValue()/scale,digits));
+			}
+		}
+	}
+
+    /** Notify any DialogListeners of changes having occurred
+     *  If a listener returns false, do not call further listeners and disable
+     *  the OK button and preview Checkbox (if it exists).
+     *  For PlugInFilters, this ensures that the PlugInFilterRunner,
+     *  which listens as the last one, is not called if the PlugInFilter has
+     *  detected invalid parameters. Thus, unnecessary calling the run(ip) method
+     *  of the PlugInFilter for preview is avoided in that case.
+     */
+    private void notifyListeners(AWTEvent e) {
+        if (dialogListeners==null)
+        	return;
+        boolean everythingOk = true;
+        for (int i=0; everythingOk && i<dialogListeners.size(); i++) {
+            try {
+                resetCounters();
+                if (this instanceof NonBlockingGenericDialog)
+                	Recorder.resetCommandOptions();
+                if (!((DialogListener)dialogListeners.elementAt(i)).dialogItemChanged(this, e))
+                    everythingOk = false;         // disable further listeners if false (invalid parameters) returned
+            } catch (Exception err) {             // for exceptions, don't cover the input by a window but
+                IJ.beep();                          // show them at in the "Log"
+                IJ.log("ERROR: "+err+"\nin DialogListener of "+dialogListeners.elementAt(i)+
+                "\nat "+(err.getStackTrace()[0])+"\nfrom "+(err.getStackTrace()[1]));  //requires Java 1.4
+            }
+        }
+        resetCounters();
+        boolean workaroundOSXbug = IJ.isMacOSX() && okay!=null && !okay.isEnabled() && everythingOk;
+        if (everythingOk && recorderOn)
+			optionsRecorded = true;
+        if (previewCheckbox!=null)
+            previewCheckbox.setEnabled(everythingOk);
+        if (okay!=null)
+            okay.setEnabled(everythingOk);
+        if (workaroundOSXbug)
+        	repaint(); // OSX 10.4 bug delays update of enabled until the next input
+    }
+
+	public void repaint() {
+		super.repaint();
+		if (imagePanels!=null) {
+			for (int i=0; i<imagePanels.size(); i++)
+				((ImagePanel)imagePanels.get(i)).repaint();
+		}
+	}
+
+	public void paint(Graphics g) {
+		super.paint(g);
+		if (firstPaint && IJ.isMacOSX() && IJ.isJava18()) { // fix for incompletely drawn dialogs on Macs
+			EventQueue.invokeLater(new Runnable() {
+				public void run() {
+					IJ.wait(50);
+					Dimension size = getSize();
+					if (size!=null)
+						setSize(size.width+2,size.height+2);
+					firstPaint = false;
+				}
+			});
+		}
+	}
+
+    public void windowClosing(WindowEvent e) {
+		wasCanceled = true;
+		dispose();
+    }
+
+    /** Adds a "Help" button that opens the specified URL in the default browser.
+    	With v1.46b or later, displays an HTML formatted message if
+    	'url' starts with "<html>". There is an example at
+    	http://imagej.nih.gov/ij/macros/js/DialogWithHelp.js
+    */
+    public void addHelp(String url) {
+    	helpURL = url;
+    }
+
+	void showHelp() {
+		if (helpURL.startsWith("<html>")) {
+			String title = getTitle()+" "+helpLabel;
+			if (this instanceof NonBlockingGenericDialog)
+				new HTMLDialog(title, helpURL, false); // non blocking
+			else
+				new HTMLDialog(this, title, helpURL); //modal
+		} else {
+			String macro = "call('ij.plugin.BrowserLauncher.open', '"+helpURL+"');";
+			new MacroRunner(macro); // open on separate thread using BrowserLauncher
+		}
+	}
+
+	protected boolean isMacro() {
+		return macro;
+	}
+
+	public static GenericDialog getInstance() {
+		return instance;
+	}
+
+	/** Closes the dialog; records the options */
+	public void dispose() {
+		super.dispose();
+		instance = null;
+
+		if (!macro) {
+			recorderOn = Recorder.record;
+			IJ.wait(25);
+		}
+		resetCounters();
+		finalizeRecording();
+		resetCounters();
+	}
+
+	 /** Returns a reference to the label of the most recently
+    	added numeric field, string field, choice or slider. */
+    public Label getLabel() {
+    	return lastLabelAdded;
+    }
+
+    public void windowActivated(WindowEvent e) {}
+    public void windowOpened(WindowEvent e) {}
+    public void windowClosed(WindowEvent e) {}
+    public void windowIconified(WindowEvent e) {}
+    public void windowDeiconified(WindowEvent e) {}
+    public void windowDeactivated(WindowEvent e) {}
+    
+    @SuppressWarnings("unchecked")
+	static String getString(DropTargetDropEvent event)
+			throws IOException, UnsupportedFlavorException {
+		String text = null;
+		DataFlavor fileList = DataFlavor.javaFileListFlavor;
+
+		if (event.isDataFlavorSupported(fileList)) {
+			event.acceptDrop(DnDConstants.ACTION_COPY);
+			java.util.List<File> list = (java.util.List<File>)event.getTransferable().getTransferData(fileList);
+			text = list.get(0).getAbsolutePath();
+		}
+		else if (event.isDataFlavorSupported(DataFlavor.stringFlavor)) {
+			event.acceptDrop(DnDConstants.ACTION_COPY);
+			text = (String)event.getTransferable()
+				.getTransferData(DataFlavor.stringFlavor);
+			if (text.startsWith("file://"))
+				text = text.substring(7);
+			text = stripSuffix(stripSuffix(text, "\n"),
+					"\r").replaceAll("%20", " ");
+		}
+		else {
+			event.rejectDrop();
+			return null;
+		}
+
+		event.dropComplete(text != null);
+		return text;
+	}
+
+	static String stripSuffix(String s, String suffix) {
+		return !s.endsWith(suffix) ? s :
+			s.substring(0, s.length() - suffix.length());
+	}
+
+	static class TextDropTarget extends DropTargetAdapter {
+		TextField text;
+		DataFlavor flavor = DataFlavor.stringFlavor;
+
+		public TextDropTarget(TextField text) {
+			this.text = text;
+		}
+
+		@Override
+		public void drop(DropTargetDropEvent event) {
+			try {
+				text.setText(getString(event));
+			} catch (Exception e) { e.printStackTrace(); }
+		}
+	}
+    
+	private class BrowseButtonListener implements ActionListener {
+		private String label;
+		private TextField textField;
+		private String mode;	
+		
+		public BrowseButtonListener(String label, TextField textField, String mode) {
+			this.label = label;
+			this.textField = textField;
+			this.mode = mode;
+		}
+	
+		public void actionPerformed(ActionEvent e) {
+			String path = null;
+			if (mode.equals("dir")) {
+				path = IJ.getDir("Select a Folder");
+			} else {
+				OpenDialog od = new OpenDialog("Select a File", null);
+				String directory = od.getDirectory();
+				String name = od.getFileName();
+				if (name!=null)
+					path = directory+name;
+			}
+			if (path!=null)
+				this.textField.setText(path);
+		}
+	
+	}
+
+}
diff --git a/src/ij/gui/HTMLDialog.java b/src/ij/gui/HTMLDialog.java
new file mode 100644
index 0000000..a08fe4d
--- /dev/null
+++ b/src/ij/gui/HTMLDialog.java
@@ -0,0 +1,149 @@
+package ij.gui;
+import ij.*;
+import ij.plugin.URLOpener;
+import ij.macro.MacroRunner;
+import java.awt.*;
+import java.awt.event.*;
+import javax.swing.*;
+import javax.swing.text.*;
+import javax.swing.text.html.*;
+import javax.swing.event.HyperlinkListener;
+import javax.swing.event.HyperlinkEvent;
+import javax.swing.event.HyperlinkEvent.EventType;
+import java.net.URL;
+
+/** This is modal or non-modal dialog box that displays HTML formated text. */
+public class HTMLDialog extends JDialog implements ActionListener, KeyListener, HyperlinkListener, WindowListener {
+	private boolean escapePressed;
+	private JEditorPane editorPane;
+	private boolean modal = true;
+
+	public HTMLDialog(String title, String message) {
+		super(ij.IJ.getInstance(), title, true);
+		init(message);
+	}
+
+	public HTMLDialog(Dialog parent, String title, String message) {
+		super(parent, title, true);
+		init(message);
+	}
+
+	public HTMLDialog(String title, String message, boolean modal) {
+		super(ij.IJ.getInstance(), title, modal);
+		this.modal = modal;
+		init(message);
+	}
+	
+	private void init(String message) {
+		ij.util.Java2.setSystemLookAndFeel();
+		Container container = getContentPane();
+		container.setLayout(new BorderLayout());
+		if (message==null) message = "";
+		editorPane = new JEditorPane("text/html","");
+		editorPane.setEditable(false);
+		HTMLEditorKit kit = new HTMLEditorKit();
+		editorPane.setEditorKit(kit);
+		StyleSheet styleSheet = kit.getStyleSheet();
+		styleSheet.addRule("body{font-family:Verdana,sans-serif; font-size:11.5pt; margin:5px 10px 5px 10px;}"); //top right bottom left
+		styleSheet.addRule("h1{font-size:18pt;}");
+		styleSheet.addRule("h2{font-size:15pt;}");
+		styleSheet.addRule("dl dt{font-face:bold;}");
+		editorPane.setText(message);    //display the html text with the above style
+		editorPane.getActionMap().put("insert-break", new AbstractAction(){
+				public void actionPerformed(ActionEvent e) {}		
+		}); //suppress beep on <ENTER> key
+		JScrollPane scrollPane = new JScrollPane(editorPane);
+		container.add(scrollPane);
+		JButton button = new JButton("OK");
+		button.addActionListener(this);
+		button.addKeyListener(this);
+		editorPane.addKeyListener(this);
+		editorPane.addHyperlinkListener(this);
+		JPanel panel = new JPanel();
+		panel.add(button);
+		container.add(panel, "South");
+		setForeground(Color.black);
+		addWindowListener(this);
+		pack();
+		Dimension screenD = IJ.getScreenSize();
+		Dimension dialogD = getSize();
+		int maxWidth = (int)(Math.min(0.70*screenD.width, 800)); //max 70% of screen width, but not more than 800 pxl
+		if (maxWidth>400 && dialogD.width>maxWidth)
+			dialogD.width = maxWidth;
+		if (dialogD.height > 0.80*screenD.height && screenD.height>400)  //max 80% of screen height
+			dialogD.height = (int)(0.80*screenD.height);
+		setSize(dialogD);
+		GUI.centerOnImageJScreen(this);		
+		if (!modal) {
+			WindowManager.addWindow(this);
+			show();
+		}
+		final JScrollBar verticalScrollBar = scrollPane.getVerticalScrollBar();
+		if (verticalScrollBar!=null) {
+			EventQueue.invokeLater(new Runnable() {
+				public void run() {
+					verticalScrollBar.setValue(verticalScrollBar.getMinimum()); //start scrollbar at top
+				}
+			});
+		}
+		if (modal) show();
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		dispose();
+	}
+	
+	public void keyPressed(KeyEvent e) {
+		int keyCode = e.getKeyCode(); 
+		ij.IJ.setKeyDown(keyCode);
+		escapePressed = keyCode==KeyEvent.VK_ESCAPE;
+		if (keyCode==KeyEvent.VK_C) {
+			if (editorPane.getSelectedText()==null || editorPane.getSelectedText().length()==0)
+				editorPane.selectAll();
+			editorPane.copy();
+			editorPane.select(0,0);
+		} else if (keyCode==KeyEvent.VK_ENTER || keyCode==KeyEvent.VK_W || escapePressed)
+			dispose();
+	}
+	
+	public void keyReleased(KeyEvent e) {
+		int keyCode = e.getKeyCode();
+		ij.IJ.setKeyUp(keyCode);
+	}
+	
+	public void keyTyped(KeyEvent e) {}
+	
+	public boolean escapePressed() {
+		return escapePressed;
+	}
+
+	public void hyperlinkUpdate(HyperlinkEvent e) {
+		if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {
+			String url = e.getDescription(); //getURL does not work for relative links within document such as "#top"
+			if (url==null) return;
+			if (url.startsWith("#"))
+				editorPane.scrollToReference(url.substring(1));
+			else {
+				String macro = "run('URL...', 'url="+url+"');";
+				new MacroRunner(macro);
+			}
+		}
+	}
+
+	public void dispose() {
+		super.dispose();
+		if (!modal) WindowManager.removeWindow(this);
+	}
+	
+	public void windowClosing(WindowEvent e) {
+		dispose();
+    }
+    
+    public void windowActivated(WindowEvent e) {}
+    public void windowOpened(WindowEvent e) {}
+    public void windowClosed(WindowEvent e) {}
+    public void windowIconified(WindowEvent e) {}
+    public void windowDeiconified(WindowEvent e) {}
+    public void windowDeactivated(WindowEvent e) {}
+    
+}
diff --git a/src/ij/gui/HistogramPlot.java b/src/ij/gui/HistogramPlot.java
new file mode 100644
index 0000000..9e346fc
--- /dev/null
+++ b/src/ij/gui/HistogramPlot.java
@@ -0,0 +1,382 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.plugin.filter.Analyzer;
+import ij.measure.*;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.awt.image.*;
+
+public class HistogramPlot extends ImagePlus {
+	static final double SCALE = Prefs.getGuiScale();
+	static final int HIST_WIDTH = (int)(SCALE*256);
+	static final int HIST_HEIGHT = (int)(SCALE*128);
+	static final int XMARGIN = (int)(20*SCALE);
+	static final int YMARGIN = (int)(10*SCALE);
+	static final int WIN_WIDTH = HIST_WIDTH + (int)(44*SCALE);
+	static final int WIN_HEIGHT = HIST_HEIGHT + (int)(118*SCALE);
+	static final int BAR_HEIGHT = (int)(SCALE*12);
+	static final int INTENSITY1=0, INTENSITY2=1, RGB=2, RED=3, GREEN=4, BLUE=5;
+	static final Color frameColor = new Color(30,60,120);
+	
+	int rgbMode = -1;
+	ImageStatistics stats;
+	boolean stackHistogram;
+	Calibration cal;
+	long[] histogram;
+	LookUpTable lut;
+	int decimalPlaces;
+	int digits; 
+	long newMaxCount;
+	boolean logScale;
+	int yMax;
+	int srcImageID;
+	Rectangle frame;
+	Font font = new Font("SansSerif",Font.PLAIN,(int)(12*SCALE));
+	boolean showBins;
+	int col1, col2, row1, row2, row3, row4, row5;
+	    
+	public HistogramPlot() {
+		setImage(NewImage.createRGBImage("Histogram", WIN_WIDTH, WIN_HEIGHT, 1, NewImage.FILL_WHITE));
+	}
+
+	/** Plots a histogram using the specified title and number of bins. 
+		Currently, the number of bins must be 256 expect for 32 bit images. */
+	public void draw(String title, ImagePlus imp, int bins) {
+		draw(imp, bins, 0.0, 0.0, 0);
+	}
+
+	/** Plots a histogram using the specified title, number of bins and histogram range.
+		Currently, the number of bins must be 256 and the histogram range range must be 
+		the same as the image range expect for 32 bit images. */
+	public void draw(ImagePlus imp, int bins, double histMin, double histMax, int yMax) {
+		boolean limitToThreshold = (Analyzer.getMeasurements()&LIMIT)!=0;
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD
+		&& ip.getLutUpdateMode()==ImageProcessor.NO_LUT_UPDATE)
+			limitToThreshold = false;  // ignore invisible thresholds
+		if (imp.isRGB() && rgbMode<INTENSITY1)
+			rgbMode=INTENSITY1;
+		if (rgbMode==RED||rgbMode==GREEN||rgbMode==BLUE) {
+			int channel = rgbMode - 2;
+			ColorProcessor cp = (ColorProcessor)imp.getProcessor();
+			ip = cp.getChannel(channel, null);
+			ImagePlus imp2 = new ImagePlus("", ip);
+			imp2.setRoi(imp.getRoi());
+			stats = imp2.getStatistics(AREA+MEAN+MODE+MIN_MAX, bins, histMin, histMax);
+		} else if (rgbMode==RGB)
+			stats = RGBHistogram(imp, bins, histMin, histMax);
+		else
+			stats = imp.getStatistics(AREA+MEAN+MODE+MIN_MAX+(limitToThreshold?LIMIT:0), bins, histMin, histMax);
+		draw(imp, stats);
+	}
+	
+	private ImageStatistics RGBHistogram(ImagePlus imp, int bins, double histMin, double histMax) {
+		ImageProcessor ip = (ColorProcessor)imp.getProcessor();
+		ip = ip.crop();
+		int w = ip.getWidth();
+		int h = ip.getHeight();
+		ImageProcessor ip2 = new ByteProcessor(w*3, h);
+		ByteProcessor temp = null;
+		for (int i=0; i<3; i++) {
+			temp = ((ColorProcessor)ip).getChannel(i+1,temp);
+			ip2.insert(temp, i*w, 0);
+		}
+		ImagePlus imp2 = new ImagePlus("imp2", ip2);
+		return imp2.getStatistics(AREA+MEAN+MODE+MIN_MAX, bins, histMin, histMax);
+	}
+
+	/** Draws the histogram using the specified title and ImageStatistics. */
+	public void draw(ImagePlus imp, ImageStatistics stats) {
+		if (imp.isRGB() && rgbMode<INTENSITY1)
+			rgbMode=INTENSITY1;
+		stackHistogram = stats.stackStatistics;
+		this.stats = stats;
+		this.yMax = stats.histYMax;
+		cal = imp.getCalibration();
+		boolean limitToThreshold = (Analyzer.getMeasurements()&LIMIT)!=0;
+		imp.getMask();
+		histogram = stats.getHistogram();
+		if (limitToThreshold && histogram.length==256) {
+			ImageProcessor ip = imp.getProcessor();
+			if (ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+				int lower = scaleDown(ip, ip.getMinThreshold());
+				int upper = scaleDown(ip, ip.getMaxThreshold());
+				for (int i=0; i<lower; i++)
+					histogram[i] = 0L;
+				for (int i=upper+1; i<256; i++)
+					histogram[i] = 0L;
+			}
+		}
+		lut = imp.createLut();
+		int type = imp.getType();
+		boolean fixedRange = type==ImagePlus.GRAY8 || type==ImagePlus.COLOR_256 || imp.isRGB();
+		ip.setColor(Color.white);
+		ip.resetRoi();
+		ip.fill();
+		ImageProcessor srcIP = imp.getProcessor();
+		drawHistogram(imp, ip, fixedRange, stats.histMin, stats.histMax);
+	}
+	
+	protected void drawHistogram(ImageProcessor ip, boolean fixedRange) {
+		drawHistogram(null, ip, fixedRange, 0.0, 0.0);
+	}
+
+	void drawHistogram(ImagePlus imp, ImageProcessor ip, boolean fixedRange, double xMin, double xMax) {
+		setTitle("Histogram of "+imp.getShortTitle());
+		int x, y;
+		long maxCount2 = 0;
+		int mode2 = 0;
+		long saveModalCount;		    	
+		ip.setColor(Color.black);
+		ip.setLineWidth(1);
+		decimalPlaces = Analyzer.getPrecision();
+		digits = cal.calibrated()||stats.binSize!=1.0?decimalPlaces:0;
+		saveModalCount = histogram[stats.mode];
+		for (int i = 0; i<histogram.length; i++) {
+ 			if ((histogram[i] > maxCount2) && (i != stats.mode)) {
+				maxCount2 = histogram[i];
+				mode2 = i;
+  			}
+  		}
+		newMaxCount = histogram[stats.mode];
+		if ((newMaxCount>(maxCount2 * 2)) && (maxCount2 != 0))
+			newMaxCount = (int)(maxCount2 * 1.5);
+		if (logScale)
+			drawLogPlot(yMax>0?yMax:newMaxCount, ip);
+		drawPlot(yMax>0?yMax:newMaxCount, ip);
+		histogram[stats.mode] = saveModalCount;
+ 		x = XMARGIN + 1;
+		y = YMARGIN + HIST_HEIGHT + 2;
+		if (imp==null)
+			lut.drawUnscaledColorBar(ip, x-1, y, HIST_WIDTH, BAR_HEIGHT);
+		else
+			drawAlignedColorBar(imp, xMin, xMax, ip, x-1, y, HIST_WIDTH, BAR_HEIGHT);
+		y += BAR_HEIGHT+(int)(15*SCALE);
+  		drawText(ip, x, y, fixedRange);
+  		srcImageID = imp.getID();
+	}
+       
+	void drawAlignedColorBar(ImagePlus imp, double xMin, double xMax, ImageProcessor ip, int x, int y, int width, int height) {
+		ImageProcessor ipSource = imp.getProcessor();
+		float[] pixels = null;
+		ImageProcessor ipRamp = null;
+		if (rgbMode>=INTENSITY1) {
+			ipRamp = new FloatProcessor(width, height);
+			if (rgbMode==RED)
+				ipRamp.setColorModel(LUT.createLutFromColor(Color.red));
+			else if (rgbMode==GREEN)
+				ipRamp.setColorModel(LUT.createLutFromColor(Color.green));
+			else if (rgbMode==BLUE)
+				ipRamp.setColorModel(LUT.createLutFromColor(Color.blue));
+			pixels = (float[])ipRamp.getPixels();
+		} else
+			pixels = new float[width*height];
+		for (int j=0; j<height; j++) {
+			for(int i=0; i<width; i++)
+				pixels[i+width*j] = (float)(xMin+i*(xMax-xMin)/(width - 1));
+		}
+		double min = ipSource.getMin();
+		double max = ipSource.getMax();
+		if (ipSource.getNChannels()==1) {
+			ColorModel cm = null;
+			if (imp.isComposite()) {
+				if (stats!=null && stats.pixelCount>ipSource.getPixelCount()) { // stack histogram
+					cm = LUT.createLutFromColor(Color.white);
+					min = stats.min;
+					max = stats.max;
+				} else
+					cm = ((CompositeImage)imp).getChannelLut();
+			} else if (ipSource.getMinThreshold()==ImageProcessor.NO_THRESHOLD)
+				cm = ipSource.getColorModel();
+			else
+				cm = ipSource.getCurrentColorModel();
+			ipRamp = new FloatProcessor(width, height, pixels, cm);
+		}
+		ipRamp.setMinAndMax(min,max);
+		ImageProcessor bar = null;
+		if (ip instanceof ColorProcessor)
+			bar = ipRamp.convertToRGB();
+		else
+			bar = ipRamp.convertToByte(true);
+		ip.insert(bar, x,y);
+		ip.setColor(Color.black);
+		ip.drawRect(x-1, y, width+2, height);
+	}
+
+	/** Scales a threshold level to the range 0-255. */
+	int scaleDown(ImageProcessor ip, double threshold) {
+		double min = ip.getMin();
+		double max = ip.getMax();
+		if (max>min)
+			return (int)(((threshold-min)/(max-min))*255.0);
+		else
+			return 0;
+	}
+
+	void drawPlot(long maxCount, ImageProcessor ip) {
+		if (maxCount==0) maxCount = 1;
+		frame = new Rectangle(XMARGIN, YMARGIN, HIST_WIDTH, HIST_HEIGHT);
+		if (histogram.length==256) {
+			double scale2 = HIST_WIDTH/256.0;
+			int barWidth = 1;
+			if (SCALE>1) barWidth=2;
+			if (SCALE>2) barWidth=3;
+			for (int i = 0; i < 256; i++) {
+				int x =(int)(i*scale2);
+				int y = (int)(((double)HIST_HEIGHT*(double)histogram[i])/maxCount);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				for (int j = 0; j<barWidth; j++)
+					ip.drawLine(x+j+XMARGIN, YMARGIN+HIST_HEIGHT, x+j+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else if (histogram.length<=HIST_WIDTH) {
+			int index, y;
+			for (int i=0; i<HIST_WIDTH; i++) {
+				index = (int)(i*(double)histogram.length/HIST_WIDTH); 
+				y = (int)(((double)HIST_HEIGHT*(double)histogram[index])/maxCount);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				ip.drawLine(i+XMARGIN, YMARGIN+HIST_HEIGHT, i+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else {
+			double xscale = (double)HIST_WIDTH/histogram.length; 
+			for (int i=0; i<histogram.length; i++) {
+				long value = histogram[i];
+				if (value>0L) {
+					int y = (int)(((double)HIST_HEIGHT*(double)value)/maxCount);
+					if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+					int x = (int)(i*xscale)+XMARGIN;
+					ip.drawLine(x, YMARGIN+HIST_HEIGHT, x, YMARGIN+HIST_HEIGHT-y);
+				}
+			}
+		}
+		ip.setColor(frameColor);
+		ip.drawRect(frame.x-1, frame.y, frame.width+2, frame.height+1);
+		ip.setColor(Color.black);
+	}
+		
+	void drawLogPlot (long maxCount, ImageProcessor ip) {
+		frame = new Rectangle(XMARGIN, YMARGIN, HIST_WIDTH, HIST_HEIGHT);
+		ip.drawRect(frame.x-1, frame.y, frame.width+2, frame.height+1);
+		double max = Math.log(maxCount);
+		ip.setColor(Color.gray);
+		if (histogram.length==256) {
+			double scale2 = HIST_WIDTH/256.0;
+			int barWidth = 1;
+			if (SCALE>1) barWidth=2;
+			if (SCALE>2) barWidth=3;
+			for (int i=0; i < 256; i++) {
+				int x =(int)(i*scale2);
+				int y = histogram[i]==0?0:(int)(HIST_HEIGHT*Math.log(histogram[i])/max);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				for (int j = 0; j<barWidth; j++)
+					ip.drawLine(x+j+XMARGIN, YMARGIN+HIST_HEIGHT, x+j+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else if (histogram.length<=HIST_WIDTH) {
+			int index, y;
+			for (int i = 0; i<HIST_WIDTH; i++) {
+				index = (int)(i*(double)histogram.length/HIST_WIDTH); 
+				y = histogram[index]==0?0:(int)(HIST_HEIGHT*Math.log(histogram[index])/max);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				ip.drawLine(i+XMARGIN, YMARGIN+HIST_HEIGHT, i+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else {
+			double xscale = (double)HIST_WIDTH/histogram.length; 
+			for (int i=0; i<histogram.length; i++) {
+				long value = histogram[i];
+				if (value>0L) {
+					int y = (int)(HIST_HEIGHT*Math.log(value)/max);
+					if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+					int x = (int)(i*xscale)+XMARGIN;
+					ip.drawLine(x, YMARGIN+HIST_HEIGHT, x, YMARGIN+HIST_HEIGHT-y);
+				}
+			}
+		}
+		ip.setColor(Color.black);
+	}
+		
+	void drawText(ImageProcessor ip, int x, int y, boolean fixedRange) {
+		ip.setFont(font);
+		ip.setAntialiasedText(true);
+		double hmin = cal.getCValue(stats.histMin);
+		double hmax = cal.getCValue(stats.histMax);
+		double range = hmax-hmin;
+		if (fixedRange&&!cal.calibrated()&&hmin==0&&hmax==255)
+			range = 256;
+		ip.drawString(d2s(hmin), x - 4, y);
+		ip.drawString(d2s(hmax), x + HIST_WIDTH - getWidth(hmax, ip) + 10, y);
+		if (rgbMode>=INTENSITY1) {
+			x += HIST_WIDTH/2;
+			y += 1;
+			ip.setJustification(ImageProcessor.CENTER_JUSTIFY);
+			boolean weighted = ((ColorProcessor)ip).weightedHistogram();
+			switch (rgbMode) {
+				case INTENSITY1: ip.drawString((weighted?"Intensity (weighted)":"Intensity (unweighted)"), x, y); break;
+				case INTENSITY2: ip.drawString((weighted?"Intensity (unweighted)":"Intensity (weighted)"), x, y); break;
+				case RGB: ip.drawString("R+G+B", x, y); break;
+				case RED: ip.drawString("Red", x, y); break;
+				case GREEN: ip.drawString("Green", x, y); break;
+				case BLUE: ip.drawString("Blue", x, y);  break;
+			}
+			ip.setJustification(ImageProcessor.LEFT_JUSTIFY);
+		}        
+		double binWidth = range/stats.nBins;
+		binWidth = Math.abs(binWidth);
+		showBins = binWidth!=1.0 || !fixedRange;
+		col1 = XMARGIN + 5;
+		col2 = XMARGIN + HIST_WIDTH/2;
+		row1 = y+(int)(25*SCALE);
+		if (showBins) row1 -= (int)(8*SCALE);
+		row2 = row1 + (int)(15*SCALE);
+		row3 = row2 + (int)(15*SCALE);
+		row4 = row3 + (int)(15*SCALE);
+		row5 = row4 + (int)(15*SCALE);
+		long count = stats.longPixelCount>0?stats.longPixelCount:stats.pixelCount;
+		String modeCount = " (" + stats.maxCount + ")";
+		if (modeCount.length()>12) modeCount = "";
+		
+		ip.drawString("N: " + count, col1, row1);
+		ip.drawString("Min: " + d2s(stats.min), col2, row1);
+		ip.drawString("Mean: " + d2s(stats.mean), col1, row2);
+		ip.drawString("Max: " + d2s(stats.max), col2, row2);
+		ip.drawString("StdDev: " + d2s(stats.stdDev), col1, row3);
+		ip.drawString("Mode: " + d2s(stats.dmode) + modeCount, col2, row3);
+		if (showBins) {
+			ip.drawString("Bins: " + d2s(stats.nBins), col1, row4);
+			ip.drawString("Bin Width: " + d2s(binWidth), col2, row4);
+		}
+	}
+	
+	private String d2s(double d) {
+		if ((int)d==d)
+			return IJ.d2s(d, 0);
+		else
+    		return IJ.d2s(d, 3, 8);
+    }
+	
+	int getWidth(double d, ImageProcessor ip) {
+		return ip.getStringWidth(d2s(d));
+	}
+				
+	public int[] getHistogram() {
+		int[] hist = new int[histogram.length];
+		for (int i=0; i<histogram.length; i++)
+			hist[i] = (int)histogram[i];
+		return hist;
+	}
+
+	public double[] getXValues() {
+		double[] values = new double[stats.nBins];
+		for (int i=0; i<stats.nBins; i++)
+			values[i] = cal.getCValue(stats.histMin+i*stats.binSize);
+		return values;
+	}
+	
+    @Override
+    public void show() {
+		if (IJ.isMacro()&&Interpreter.isBatchMode())
+			super.show();
+		else
+			new HistogramWindow(this, WindowManager.getImage(srcImageID));
+	}
+	
+}
diff --git a/src/ij/gui/HistogramWindow.java b/src/ij/gui/HistogramWindow.java
new file mode 100644
index 0000000..1eedcc2
--- /dev/null
+++ b/src/ij/gui/HistogramWindow.java
@@ -0,0 +1,719 @@
+package ij.gui;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import java.io.*;
+import java.awt.datatransfer.*;
+import java.util.ArrayList;
+import ij.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.filter.Analyzer;
+import ij.text.TextWindow;
+
+/** This class is an extended ImageWindow that displays histograms. */
+public class HistogramWindow extends ImageWindow implements Measurements, ActionListener, 
+	ClipboardOwner, ImageListener, RoiListener, Runnable {
+	private static final double SCALE = HistogramPlot.SCALE;
+	static final int HIST_WIDTH = HistogramPlot.HIST_WIDTH;
+	static final int HIST_HEIGHT = HistogramPlot.HIST_HEIGHT;
+	static final int XMARGIN = HistogramPlot.XMARGIN;
+	static final int YMARGIN = HistogramPlot.YMARGIN;
+	static final int WIN_WIDTH = HistogramPlot.WIN_WIDTH;
+	static final int WIN_HEIGHT = HistogramPlot.WIN_HEIGHT;
+	static final int BAR_HEIGHT = HistogramPlot.BAR_HEIGHT;
+
+	static final int INTENSITY1=0, INTENSITY2=1, RGB=2, RED=3, GREEN=4, BLUE=5;
+	
+	protected ImageStatistics stats;
+	protected long[] histogram;
+	protected LookUpTable lut;
+	protected Rectangle frame = null;
+	protected Button list, save, copy, log, live, rgb;
+	protected Label value, count;
+	protected static String defaultDirectory = null;
+	protected int decimalPlaces;
+	protected int digits;
+	protected long newMaxCount;
+	protected int plotScale = 1;
+	protected boolean logScale;
+	protected Calibration cal;
+	protected int yMax;
+	public static int nBins = 256;
+		
+	private int srcImageID;			// ID of source image
+	private ImagePlus srcImp;		// source image for live histograms
+	private Thread bgThread;		// thread background drawing
+	private boolean doUpdate;	// tells background thread to update
+	private int rgbMode = -1;
+	private String blankLabel;
+	private boolean stackHistogram;
+	private Font font = new Font("SansSerif",Font.PLAIN,(int)(12*SCALE));
+	private boolean showBins;
+	private int col1, col2, row1, row2, row3, row4, row5;
+	    
+	public HistogramWindow(HistogramPlot plot, ImagePlus srcImp) {
+		super(plot);
+		srcImageID = srcImp.getID();
+		frame = plot.frame;
+		histogram = plot.histogram;
+		cal = plot.cal;
+		stats = plot.stats;
+		yMax = plot.yMax;
+		newMaxCount = plot.newMaxCount;
+		showBins = plot.showBins;
+		rgbMode = plot.rgbMode;
+		col1=plot.col1; col2=plot.col2; row1=plot.row1; row2=plot.row2;
+		row3=plot.row3; row4=plot.row4; row5=plot.row5;
+		if (list==null)
+			setup(srcImp);
+	}
+
+	/** Displays a histogram using the title "Histogram of ImageName". */
+	public HistogramWindow(ImagePlus imp) {
+		super(NewImage.createRGBImage("Histogram of "+imp.getShortTitle(), WIN_WIDTH, WIN_HEIGHT, 1, NewImage.FILL_WHITE));
+		showHistogram(imp, 256, 0.0, 0.0);
+	}
+
+	/** Displays a histogram using the specified title and number of bins. 
+		Currently, the number of bins must be 256 expect for 32 bit images. */
+	public HistogramWindow(String title, ImagePlus imp, int bins) {
+		super(NewImage.createRGBImage(title, WIN_WIDTH, WIN_HEIGHT, 1, NewImage.FILL_WHITE));
+		showHistogram(imp, bins, 0.0, 0.0);
+	}
+
+	/** Displays a histogram using the specified title, number of bins and histogram range.
+		Currently, the number of bins must be 256 and the histogram range range must be the 
+		same as the image range expect for 32 bit images. */
+	public HistogramWindow(String title, ImagePlus imp, int bins, double histMin, double histMax) {
+		super(NewImage.createRGBImage(title, WIN_WIDTH, WIN_HEIGHT, 1, NewImage.FILL_WHITE));
+		showHistogram(imp, bins, histMin, histMax);
+	}
+
+	/** Displays a histogram using the specified title, number of bins, histogram range and yMax. */
+	public HistogramWindow(String title, ImagePlus imp, int bins, double histMin, double histMax, int yMax) {
+		super(NewImage.createRGBImage(title, WIN_WIDTH, WIN_HEIGHT, 1, NewImage.FILL_WHITE));
+		this.yMax = yMax;
+		showHistogram(imp, bins, histMin, histMax);
+	}
+
+	/** Displays a histogram using the specified title and ImageStatistics. */
+	public HistogramWindow(String title, ImagePlus imp, ImageStatistics stats) {
+		super(NewImage.createRGBImage(title, WIN_WIDTH, WIN_HEIGHT, 1, NewImage.FILL_WHITE));
+		this.yMax = stats.histYMax;
+		showHistogram(imp, stats);
+	}
+
+	/** Draws the histogram using the specified title and number of bins.
+		Currently, the number of bins must be 256 expect for 32 bit images. */
+	public void showHistogram(ImagePlus imp, int bins) {
+		showHistogram(imp, bins, 0.0, 0.0);
+	}
+
+	/** Draws the histogram using the specified title, number of bins and histogram range.
+		Currently, the number of bins must be 256 and the histogram range range must be 
+		the same as the image range expect for 32 bit images. */
+	public void showHistogram(ImagePlus imp, int bins, double histMin, double histMax) {
+		boolean limitToThreshold = (Analyzer.getMeasurements()&LIMIT)!=0;
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD
+		&& ip.getLutUpdateMode()==ImageProcessor.NO_LUT_UPDATE)
+			limitToThreshold = false;  // ignore invisible thresholds
+		if (imp.isRGB() && rgbMode<INTENSITY1)
+			rgbMode=INTENSITY1;
+		if (rgbMode==RED||rgbMode==GREEN||rgbMode==BLUE) {
+			int channel = rgbMode - 2;
+			ColorProcessor cp = (ColorProcessor)imp.getProcessor();
+			ip = cp.getChannel(channel, null);
+			ImagePlus imp2 = new ImagePlus("", ip);
+			imp2.setRoi(imp.getRoi());
+			stats = imp2.getStatistics(AREA+MEAN+MODE+MIN_MAX, bins, histMin, histMax);
+		} else if (rgbMode==RGB)
+			stats = RGBHistogram(imp, bins, histMin, histMax);
+		else
+			stats = imp.getStatistics(AREA+MEAN+MODE+MIN_MAX+(limitToThreshold?LIMIT:0), bins, histMin, histMax);
+		showHistogram(imp, stats);
+	}
+	
+	private ImageStatistics RGBHistogram(ImagePlus imp, int bins, double histMin, double histMax) {
+		ImageProcessor ip = (ColorProcessor)imp.getProcessor();
+		ip = ip.crop();
+		int w = ip.getWidth();
+		int h = ip.getHeight();
+		ImageProcessor ip2 = new ByteProcessor(w*3, h);
+		ByteProcessor temp = null;
+		for (int i=0; i<3; i++) {
+			temp = ((ColorProcessor)ip).getChannel(i+1,temp);
+			ip2.insert(temp, i*w, 0);
+		}
+		ImagePlus imp2 = new ImagePlus("imp2", ip2);
+		return imp2.getStatistics(AREA+MEAN+MODE+MIN_MAX, bins, histMin, histMax);
+	}
+
+	/** Draws the histogram using the specified title and ImageStatistics. */
+	public void showHistogram(ImagePlus srcImp, ImageStatistics stats) {
+		if (srcImp.isRGB() && rgbMode<INTENSITY1)
+			rgbMode=INTENSITY1;
+		stackHistogram = stats.stackStatistics;
+		if (list==null)
+			setup(srcImp);
+		this.stats = stats;
+		cal = srcImp.getCalibration();
+		boolean limitToThreshold = (Analyzer.getMeasurements()&LIMIT)!=0;
+		srcImp.getMask();
+		histogram = stats.getHistogram();
+		if (limitToThreshold && histogram.length==256) {
+			ImageProcessor ip = srcImp.getProcessor();
+			if (ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+				int lower = scaleDown(ip, ip.getMinThreshold());
+				int upper = scaleDown(ip, ip.getMaxThreshold());
+				for (int i=0; i<lower; i++)
+					histogram[i] = 0L;
+				for (int i=upper+1; i<256; i++)
+					histogram[i] = 0L;
+			}
+		}
+		lut = srcImp.createLut();
+		int type = srcImp.getType();
+		boolean fixedRange = type==ImagePlus.GRAY8 || type==ImagePlus.COLOR_256 || srcImp.isRGB();
+		if (imp==null) {
+			IJ.showStatus("imp==null");
+			return;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		ip.setColor(Color.white);
+		ip.resetRoi();
+		ip.fill();
+		ImageProcessor srcIP = srcImp.getProcessor();
+		drawHistogram(srcImp, ip, fixedRange, stats.histMin, stats.histMax);
+		imp.updateAndDraw();
+	}
+
+	private void setup(ImagePlus imp) {
+		boolean isRGB = imp.isRGB();
+ 		Panel buttons = new Panel();
+ 		int hgap = IJ.isMacOSX()||isRGB?1:5;
+		buttons.setLayout(new FlowLayout(FlowLayout.RIGHT,hgap,0));
+		int trim = IJ.isMacOSX()?6:0;
+		list = new TrimmedButton("List", trim);
+		list.addActionListener(this);
+		buttons.add(list);
+		copy = new TrimmedButton("Copy", trim);
+		copy.addActionListener(this);
+		buttons.add(copy);
+		log = new TrimmedButton("Log", trim);
+		log.addActionListener(this);
+		buttons.add(log);
+		if (!stackHistogram) {
+			live = new TrimmedButton("Live", trim);
+			live.addActionListener(this);
+			buttons.add(live);
+		}
+		if (imp!=null && isRGB && !stackHistogram) {
+			rgb = new TrimmedButton("RGB", trim);
+			rgb.addActionListener(this);
+			buttons.add(rgb);
+		}
+		value = new Label(" ");
+		count = new Label(" ");
+		add(buttons);
+		GUI.scale(buttons);
+		pack();
+		if (IJ.isMacOSX() && IJ.isJava18()) {
+			IJ.wait(50);
+			pack();
+		}
+    }
+    
+	public void setup() {
+		setup(null);
+	}
+	
+	public void mouseMoved(int x, int y) {
+		ImageProcessor ip = this.imp!=null?this.imp.getProcessor():null;
+		if (ip==null)
+			return;
+		if ((frame!=null)  && x>=frame.x && x<=(frame.x+frame.width)) {
+			x = (x - frame.x);
+			int index = (int)(x*(SCALE*histogram.length)/HIST_WIDTH/SCALE);
+			if (index>=histogram.length) index = histogram.length-1;
+			double value = cal.getCValue(stats.histMin+index*stats.binSize);
+			drawValueAndCount(ip, value, histogram[index]);
+		} else
+			drawValueAndCount(ip, Double.NaN, -1);
+		this.imp.updateAndDraw();
+	}
+	
+	protected void drawHistogram(ImageProcessor ip, boolean fixedRange) {
+		drawHistogram(null, ip, fixedRange, 0.0, 0.0);
+	}
+
+	void drawHistogram(ImagePlus imp, ImageProcessor ip, boolean fixedRange, double xMin, double xMax) {
+		int x, y;
+		long maxCount2 = 0;
+		int mode2 = 0;
+		long saveModalCount;		    	
+		ip.setColor(Color.black);
+		ip.setLineWidth(1);
+		decimalPlaces = Analyzer.getPrecision();
+		digits = cal.calibrated()||stats.binSize!=1.0?decimalPlaces:0;
+		saveModalCount = histogram[stats.mode];
+		for (int i = 0; i<histogram.length; i++) {
+ 			if ((histogram[i] > maxCount2) && (i != stats.mode)) {
+				maxCount2 = histogram[i];
+				mode2 = i;
+  			}
+  		}
+		newMaxCount = histogram[stats.mode];
+		if ((newMaxCount>(maxCount2 * 2)) && (maxCount2 != 0))
+			newMaxCount = (int)(maxCount2 * 1.5);
+		if (logScale || IJ.shiftKeyDown() && !liveMode())
+			drawLogPlot(yMax>0?yMax:newMaxCount, ip);
+		drawPlot(yMax>0?yMax:newMaxCount, ip);
+		histogram[stats.mode] = saveModalCount;
+ 		x = XMARGIN + 1;
+		y = YMARGIN + HIST_HEIGHT + 2;
+		if (imp==null)
+			lut.drawUnscaledColorBar(ip, x-1, y, HIST_WIDTH, BAR_HEIGHT);
+		else
+			drawAlignedColorBar(imp, xMin, xMax, ip, x-1, y, HIST_WIDTH, BAR_HEIGHT);
+		y += BAR_HEIGHT+(int)(15*SCALE);
+  		drawText(ip, x, y, fixedRange);
+  		srcImageID = imp.getID();
+	}
+       
+	void drawAlignedColorBar(ImagePlus imp, double xMin, double xMax, ImageProcessor ip, int x, int y, int width, int height) {
+		ImageProcessor ipSource = imp.getProcessor();
+		float[] pixels = null;
+		ImageProcessor ipRamp = null;
+		if (rgbMode>=INTENSITY1) {
+			ipRamp = new FloatProcessor(width, height);
+			if (rgbMode==RED)
+				ipRamp.setColorModel(LUT.createLutFromColor(Color.red));
+			else if (rgbMode==GREEN)
+				ipRamp.setColorModel(LUT.createLutFromColor(Color.green));
+			else if (rgbMode==BLUE)
+				ipRamp.setColorModel(LUT.createLutFromColor(Color.blue));
+			pixels = (float[])ipRamp.getPixels();
+		} else
+			pixels = new float[width*height];
+		for (int j=0; j<height; j++) {
+			for(int i=0; i<width; i++)
+				pixels[i+width*j] = (float)(xMin+i*(xMax-xMin)/(width - 1));
+		}
+		double min = ipSource.getMin();
+		double max = ipSource.getMax();
+		if (ipSource.getNChannels()==1) {
+			ColorModel cm = null;
+			if (imp.isComposite()) {
+				if (stats!=null && stats.pixelCount>ipSource.getPixelCount()) { // stack histogram
+					cm = LUT.createLutFromColor(Color.white);
+					min = stats.min;
+					max = stats.max;
+				} else
+					cm = ((CompositeImage)imp).getChannelLut();
+			} else if (ipSource.getMinThreshold()==ImageProcessor.NO_THRESHOLD)
+				cm = ipSource.getColorModel();
+			else
+				cm = ipSource.getCurrentColorModel();
+			ipRamp = new FloatProcessor(width, height, pixels, cm);
+		}
+		ipRamp.setMinAndMax(min,max);
+		ImageProcessor bar = null;
+		if (ip instanceof ColorProcessor)
+			bar = ipRamp.convertToRGB();
+		else
+			bar = ipRamp.convertToByte(true);
+		ip.insert(bar, x,y);
+		ip.setColor(Color.black);
+		ip.drawRect(x-1, y, width+2, height);
+	}
+
+	/** Scales a threshold level to the range 0-255. */
+	int scaleDown(ImageProcessor ip, double threshold) {
+		double min = ip.getMin();
+		double max = ip.getMax();
+		if (max>min)
+			return (int)(((threshold-min)/(max-min))*255.0);
+		else
+			return 0;
+	}
+
+	void drawPlot(long maxCount, ImageProcessor ip) {
+		if (maxCount==0) maxCount = 1;
+		frame = new Rectangle(XMARGIN, YMARGIN, HIST_WIDTH, HIST_HEIGHT);
+		ip.drawRect(frame.x-1, frame.y, frame.width+2, frame.height+1);
+		if (histogram.length==256) {
+			double scale2 = HIST_WIDTH/256.0;
+			int barWidth = 1;
+			if (SCALE>1) barWidth=2;
+			if (SCALE>2) barWidth=3;
+			for (int i = 0; i < 256; i++) {
+				int x =(int)(i*scale2);
+				int y = (int)(((double)HIST_HEIGHT*(double)histogram[i])/maxCount);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				for (int j = 0; j<barWidth; j++)
+					ip.drawLine(x+j+XMARGIN, YMARGIN+HIST_HEIGHT, x+j+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else if (histogram.length<=HIST_WIDTH) {
+			int index, y;
+			for (int i=0; i<HIST_WIDTH; i++) {
+				index = (int)(i*(double)histogram.length/HIST_WIDTH); 
+				y = (int)(((double)HIST_HEIGHT*(double)histogram[index])/maxCount);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				ip.drawLine(i+XMARGIN, YMARGIN+HIST_HEIGHT, i+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else {
+			double xscale = (double)HIST_WIDTH/histogram.length; 
+			for (int i=0; i<histogram.length; i++) {
+				long value = histogram[i];
+				if (value>0L) {
+					int y = (int)(((double)HIST_HEIGHT*(double)value)/maxCount);
+					if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+					int x = (int)(i*xscale)+XMARGIN;
+					ip.drawLine(x, YMARGIN+HIST_HEIGHT, x, YMARGIN+HIST_HEIGHT-y);
+				}
+			}
+		}
+	}
+		
+	void drawLogPlot (long maxCount, ImageProcessor ip) {
+		frame = new Rectangle(XMARGIN, YMARGIN, HIST_WIDTH, HIST_HEIGHT);
+		ip.drawRect(frame.x-1, frame.y, frame.width+2, frame.height+1);
+		double max = Math.log(maxCount);
+		ip.setColor(Color.gray);
+		if (histogram.length==256) {
+			double scale2 = HIST_WIDTH/256.0;
+			int barWidth = 1;
+			if (SCALE>1) barWidth=2;
+			if (SCALE>2) barWidth=3;
+			for (int i=0; i < 256; i++) {
+				int x =(int)(i*scale2);
+				int y = histogram[i]==0?0:(int)(HIST_HEIGHT*Math.log(histogram[i])/max);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				for (int j = 0; j<barWidth; j++)
+					ip.drawLine(x+j+XMARGIN, YMARGIN+HIST_HEIGHT, x+j+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else if (histogram.length<=HIST_WIDTH) {
+			int index, y;
+			for (int i = 0; i<HIST_WIDTH; i++) {
+				index = (int)(i*(double)histogram.length/HIST_WIDTH); 
+				y = histogram[index]==0?0:(int)(HIST_HEIGHT*Math.log(histogram[index])/max);
+				if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+				ip.drawLine(i+XMARGIN, YMARGIN+HIST_HEIGHT, i+XMARGIN, YMARGIN+HIST_HEIGHT-y);
+			}
+		} else {
+			double xscale = (double)HIST_WIDTH/histogram.length; 
+			for (int i=0; i<histogram.length; i++) {
+				long value = histogram[i];
+				if (value>0L) {
+					int y = (int)(HIST_HEIGHT*Math.log(value)/max);
+					if (y>HIST_HEIGHT) y = HIST_HEIGHT;
+					int x = (int)(i*xscale)+XMARGIN;
+					ip.drawLine(x, YMARGIN+HIST_HEIGHT, x, YMARGIN+HIST_HEIGHT-y);
+				}
+			}
+		}
+		ip.setColor(Color.black);
+	}
+		
+	void drawText(ImageProcessor ip, int x, int y, boolean fixedRange) {
+		ip.setFont(font);
+		ip.setAntialiasedText(true);
+		double hmin = cal.getCValue(stats.histMin);
+		double hmax = cal.getCValue(stats.histMax);
+		double range = hmax-hmin;
+		if (fixedRange&&!cal.calibrated()&&hmin==0&&hmax==255)
+			range = 256;
+		ip.drawString(d2s(hmin), x - 4, y);
+		ip.drawString(d2s(hmax), x + HIST_WIDTH - getWidth(hmax, ip) + 10, y);
+		if (rgbMode>=INTENSITY1) {
+			x += HIST_WIDTH/2;
+			y += 1;
+			ip.setJustification(ImageProcessor.CENTER_JUSTIFY);
+			boolean weighted = ((ColorProcessor)ip).weightedHistogram();
+			switch (rgbMode) {
+				case INTENSITY1: ip.drawString((weighted?"Intensity (weighted)":"Intensity (unweighted)"), x, y); break;
+				case INTENSITY2: ip.drawString((weighted?"Intensity (unweighted)":"Intensity (weighted)"), x, y); break;
+				case RGB: ip.drawString("R+G+B", x, y); break;
+				case RED: ip.drawString("Red", x, y); break;
+				case GREEN: ip.drawString("Green", x, y); break;
+				case BLUE: ip.drawString("Blue", x, y);  break;
+			}
+			ip.setJustification(ImageProcessor.LEFT_JUSTIFY);
+		}        
+		double binWidth = range/stats.nBins;
+		binWidth = Math.abs(binWidth);
+		showBins = binWidth!=1.0 || !fixedRange;
+		col1 = XMARGIN + 5;
+		col2 = XMARGIN + HIST_WIDTH/2;
+		row1 = y+(int)(25*SCALE);
+		if (showBins) row1 -= (int)(8*SCALE);
+		row2 = row1 + (int)(15*SCALE);
+		row3 = row2 + (int)(15*SCALE);
+		row4 = row3 + (int)(15*SCALE);
+		row5 = row4 + (int)(15*SCALE);
+		long count = stats.longPixelCount>0?stats.longPixelCount:stats.pixelCount;
+		String modeCount = " (" + stats.maxCount + ")";
+		if (modeCount.length()>12) modeCount = "";
+		
+		ip.drawString("N: " + count, col1, row1);
+		ip.drawString("Min: " + d2s(stats.min), col2, row1);
+		ip.drawString("Mean: " + d2s(stats.mean), col1, row2);
+		ip.drawString("Max: " + d2s(stats.max), col2, row2);
+		ip.drawString("StdDev: " + d2s(stats.stdDev), col1, row3);
+		ip.drawString("Mode: " + d2s(stats.dmode) + modeCount, col2, row3);
+		if (showBins) {
+			ip.drawString("Bins: " + d2s(stats.nBins), col1, row4);
+			ip.drawString("Bin Width: " + d2s(binWidth), col2, row4);
+		}
+		drawValueAndCount(ip, Double.NaN, -1);		
+	}
+	
+	private void drawValueAndCount(ImageProcessor ip, double value, long count) {
+		int y = showBins?row4:row3;
+		ip.setRoi(0, y, WIN_WIDTH, WIN_HEIGHT-y);
+		ip.setColor(Color.white);
+		ip.fill();
+		ip.setColor(Color.black);
+		String sValue = Double.isNaN(value)?"---":d2s(value);
+		String sCount = count==-1?"---":""+count;
+		int row = showBins?row5:row4;
+		ip.drawString("Value: " + sValue, col1, row);
+		ip.drawString("Count: " + sCount, col2, row);
+	}	
+	
+	private String d2s(double d) {
+		if ((int)d==d)
+			return IJ.d2s(d, 0);
+		else
+    		return IJ.d2s(d, 3, 8);
+    }
+	
+	int getWidth(double d, ImageProcessor ip) {
+		return ip.getStringWidth(d2s(d));
+	}
+	
+	/** Returns the histogram values as a ResultsTable. */
+	public ResultsTable getResultsTable() {
+		ResultsTable rt = new ResultsTable();
+		rt.setPrecision(digits);
+		String vheading = stats.binSize==1.0?"value":"bin start";
+		if (cal.calibrated() && !cal.isSigned16Bit()) {
+			for (int i=0; i<stats.nBins; i++) {
+				rt.setValue("level", i, i);
+				rt.setValue(vheading, i, cal.getCValue(stats.histMin+i*stats.binSize));
+				rt.setValue("count", i, histogram[i]);
+			}
+		} else {
+			for (int i=0; i<stats.nBins; i++) {
+				if (stats.binSize!=1.0)
+					rt.setValue("index", i, i);
+				rt.setValue(vheading, i, cal.getCValue(stats.histMin+i*stats.binSize));
+				rt.setValue("count", i, histogram[i]);
+			}
+		}
+		return rt;
+	}
+
+	protected void showList() {
+		ResultsTable rt = getResultsTable();
+		rt.show(getTitle());
+	}
+	
+	protected void copyToClipboard() {
+		Clipboard systemClipboard = null;
+		try {systemClipboard = getToolkit().getSystemClipboard();}
+		catch (Exception e) {systemClipboard = null; }
+		if (systemClipboard==null)
+			{IJ.error("Unable to copy to Clipboard."); return;}
+		IJ.showStatus("Copying histogram values...");
+		CharArrayWriter aw = new CharArrayWriter(stats.nBins*4);
+		PrintWriter pw = new PrintWriter(aw);
+		for (int i=0; i<stats.nBins; i++)
+			pw.print(ResultsTable.d2s(cal.getCValue(stats.histMin+i*stats.binSize), digits)+"\t"+histogram[i]+"\n");
+		String text = aw.toString();
+		pw.close();
+		StringSelection contents = new StringSelection(text);
+		systemClipboard.setContents(contents, this);
+		IJ.showStatus(text.length() + " characters copied to Clipboard");
+	}
+	
+	void replot() {
+		ImageProcessor ip = this.imp.getProcessor();
+		frame = new Rectangle(XMARGIN, YMARGIN, HIST_WIDTH, HIST_HEIGHT);
+		ip.setColor(Color.white);
+		ip.setRoi(frame.x-1, frame.y, frame.width+2, frame.height);
+		ip.fill();
+		ip.resetRoi();
+		ip.setColor(Color.black);
+		ip.setLineWidth(1);
+		if (logScale) {
+			drawLogPlot(yMax>0?yMax:newMaxCount, ip);
+			drawPlot(yMax>0?yMax:newMaxCount, ip);
+		} else
+			drawPlot(yMax>0?yMax:newMaxCount, ip);
+		this.imp.updateAndDraw();
+	}
+		
+	public void actionPerformed(ActionEvent e) {
+		Object b = e.getSource();
+		if (b==live)
+			toggleLiveMode();
+		else if (b==rgb)
+			changeChannel();
+		else if (b==list)
+			showList();
+		else if (b==copy)
+			copyToClipboard();
+		else if (b==log) {
+			logScale = !logScale;
+			replot();
+		}
+	}
+	
+	public void lostOwnership(Clipboard clipboard, Transferable contents) {}
+	
+	public int[] getHistogram() {
+		int[] hist = new int[histogram.length];
+		for (int i=0; i<histogram.length; i++)
+			hist[i] = (int)histogram[i];
+		return hist;
+	}
+
+	public double[] getXValues() {
+		double[] values = new double[stats.nBins];
+		for (int i=0; i<stats.nBins; i++)
+			values[i] = cal.getCValue(stats.histMin+i*stats.binSize);
+		return values;
+	}
+
+	private void toggleLiveMode() {
+		if (liveMode())
+			removeListeners();
+		else
+			enableLiveMode();
+	}
+	
+	private void changeChannel() {
+		ImagePlus imp = WindowManager.getImage(srcImageID);
+		if (imp==null || !imp.isRGB())
+			return;
+		else {
+			rgbMode++;
+			if (rgbMode>BLUE) rgbMode=INTENSITY1;
+			ColorProcessor cp = (ColorProcessor)imp.getProcessor();
+			boolean weighted = cp.weightedHistogram();
+			if (rgbMode==INTENSITY2) {
+				double[] weights = cp.getRGBWeights();
+				if (weighted)
+					cp.setRGBWeights(1d/3d, 1d/3d, 1d/3d);
+				else
+					cp.setRGBWeights(0.299, 0.587, 0.114);
+				showHistogram(imp, 256);
+				cp.setRGBWeights(weights);
+			} else
+				showHistogram(imp, 256);
+		}
+	}
+
+	private boolean liveMode() {
+		return live!=null && live.getForeground()==Color.red;
+	}
+
+	private void enableLiveMode() {
+		if (bgThread==null) {
+			srcImp = WindowManager.getImage(srcImageID);
+			if (srcImp==null) return;
+			bgThread = new Thread(this, "Live Histogram");
+			bgThread.setPriority(Math.max(bgThread.getPriority()-3, Thread.MIN_PRIORITY));
+			bgThread.start();
+			imageUpdated(srcImp);
+		}
+		createListeners();
+		if (srcImp!=null)
+			imageUpdated(srcImp);
+	}
+	
+	// Unused
+	public void imageOpened(ImagePlus imp) {
+	}
+
+	// This listener is called if the source image content is changed
+	public synchronized void imageUpdated(ImagePlus imp) {
+		if (imp==srcImp) { 
+			doUpdate = true;
+			notify();
+		}
+	}
+	
+	public synchronized void roiModified(ImagePlus img, int id) {
+		if (img==srcImp) {
+			doUpdate=true;
+			notify();
+		}
+	}
+
+	// If either the source image or this image are closed, exit
+	public void imageClosed(ImagePlus imp) {
+		if (imp==srcImp || imp==this.imp) {
+			if (bgThread!=null)
+				bgThread.interrupt();
+			bgThread = null;
+			removeListeners();
+			srcImp = null;
+		}
+	}
+	
+	// the background thread for live plotting.
+	public void run() {
+		while (true) {
+			if (doUpdate && srcImp!=null) {
+				if (srcImp.getRoi()!=null)
+					IJ.wait(50);	//delay to make sure the roi has been updated
+				if (srcImp!=null) {
+					if (srcImp.getBitDepth()==16 && ImagePlus.getDefault16bitRange()!=0)
+						showHistogram(srcImp, 256, 0, Math.pow(2,ImagePlus.getDefault16bitRange())-1);
+					else
+						showHistogram(srcImp, 256);
+				}
+			}
+			synchronized(this) {
+				if (doUpdate) {
+					doUpdate = false;		//and loop again
+				} else {
+					try {wait();}	//notify wakes up the thread
+					catch(InterruptedException e) { //interrupted tells the thread to exit
+						return;
+					}
+				}
+			}
+		}
+	}
+	
+	private void createListeners() {
+		if (srcImp==null)
+			return;
+		ImagePlus.addImageListener(this);
+		Roi.addRoiListener(this);
+		if (live!=null) {
+			Font font = live.getFont();
+			live.setFont(new Font(font.getName(), Font.BOLD, font.getSize()));
+			live.setForeground(Color.red);
+		}
+	}
+	
+	private void removeListeners() {
+		if (srcImp==null)
+			return;
+		ImagePlus.removeImageListener(this);
+		Roi.removeRoiListener(this);
+		if (live!=null) {
+			Font font = live.getFont();
+			live.setFont(new Font(font.getName(), Font.PLAIN, font.getSize()));
+			live.setForeground(Color.black);
+		}
+	}
+
+}
diff --git a/src/ij/gui/ImageCanvas.java b/src/ij/gui/ImageCanvas.java
new file mode 100644
index 0000000..410dc1d
--- /dev/null
+++ b/src/ij/gui/ImageCanvas.java
@@ -0,0 +1,1816 @@
+package ij.gui;
+
+import java.awt.*;
+import java.util.Properties;
+import java.awt.image.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.*;
+import ij.plugin.frame.Recorder;
+import ij.plugin.frame.RoiManager;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.tool.PlugInTool;
+import ij.macro.*;
+import ij.*;
+import ij.util.*;
+import ij.text.*;
+import java.awt.event.*;
+import java.util.*;
+import java.awt.geom.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+
+/** This is a Canvas used to display images in a Window. */
+public class ImageCanvas extends Canvas implements MouseListener, MouseMotionListener, Cloneable {
+
+	protected static Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
+	protected static Cursor handCursor = new Cursor(Cursor.HAND_CURSOR);
+	protected static Cursor moveCursor = new Cursor(Cursor.MOVE_CURSOR);
+	protected static Cursor crosshairCursor = new Cursor(Cursor.CROSSHAIR_CURSOR);
+
+	public static boolean usePointer = Prefs.usePointerCursor;
+
+	protected ImagePlus imp;
+	protected boolean imageUpdated;
+	protected Rectangle srcRect;
+	protected int imageWidth, imageHeight;
+	protected int xMouse; // current cursor offscreen x location 
+	protected int yMouse; // current cursor offscreen y location
+	
+	private boolean showCursorStatus = true;
+	private int sx2, sy2;
+	private boolean disablePopupMenu;
+	private static Color zoomIndicatorColor;
+	private static Font smallFont, largeFont;
+	private Font font;
+	private Rectangle[] labelRects;
+    private boolean maxBoundsReset;
+    private Overlay showAllOverlay;
+    private static final int LIST_OFFSET = 100000;
+    private static Color showAllColor = Prefs.getColor(Prefs.SHOW_ALL_COLOR, new Color(0, 255, 255));
+    private Color defaultColor = showAllColor;
+    private static Color labelColor, bgColor;
+    private int resetMaxBoundsCount;
+    private Roi currentRoi;
+    private int mousePressedX, mousePressedY;
+    private long mousePressedTime;
+    private boolean overOverlayLabel;
+
+    /** If the mouse moves less than this in screen pixels, successive zoom operations are on the same image pixel */
+	protected final static int MAX_MOUSEMOVE_ZOOM = 10;
+	/** Screen coordinates where the last zoom operation was done (initialized to impossible value) */
+	protected int lastZoomSX = -9999999;
+	protected int lastZoomSY = -9999999;
+	/** Image (=offscreen) coordinates where the cursor was moved to for zooming */
+	protected int zoomTargetOX = -1;
+	protected int zoomTargetOY;
+
+	protected ImageJ ij;
+	protected double magnification;
+	protected int dstWidth, dstHeight;
+
+	protected int xMouseStart;
+	protected int yMouseStart;
+	protected int xSrcStart;
+	protected int ySrcStart;
+	protected int flags;
+	
+	private Image offScreenImage;
+	private int offScreenWidth = 0;
+	private int offScreenHeight = 0;
+	private boolean mouseExited = true;
+	private boolean customRoi;
+	private boolean drawNames;
+	private AtomicBoolean paintPending;
+	private boolean scaleToFit;
+	private boolean painted;
+	private boolean hideZoomIndicator;
+	private boolean flattening;
+	private Timer pressTimer;
+	private PopupMenu roiPopupMenu;
+	private static int longClickDelay = 1000; //ms
+
+		
+	public ImageCanvas(ImagePlus imp) {
+		this.imp = imp;
+		paintPending = new AtomicBoolean(false);
+		ij = IJ.getInstance();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		imageWidth = width;
+		imageHeight = height;
+		srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
+		setSize(imageWidth, imageHeight);
+		magnification = 1.0;
+ 		addMouseListener(this);
+ 		addMouseMotionListener(this);
+ 		addKeyListener(ij);  // ImageJ handles keyboard shortcuts
+ 		setFocusTraversalKeysEnabled(false);
+		//setScaleToFit(true);
+	}
+		
+	void updateImage(ImagePlus imp) {
+		this.imp = imp;
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		imageWidth = width;
+		imageHeight = height;
+		srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
+		setSize(imageWidth, imageHeight);
+		magnification = 1.0;
+	}
+
+	/** Update this ImageCanvas to have the same zoom and scale settings as the one specified. */
+	void update(ImageCanvas ic) {
+		if (ic==null || ic==this || ic.imp==null)
+			return;
+		if (ic.imp.getWidth()!=imageWidth || ic.imp.getHeight()!=imageHeight)
+			return;
+		srcRect = new Rectangle(ic.srcRect.x, ic.srcRect.y, ic.srcRect.width, ic.srcRect.height);
+		setMagnification(ic.magnification);
+		setSize(ic.dstWidth, ic.dstHeight);
+	}
+
+	/** Sets the region of the image (in pixels) to be displayed. */
+	public void setSourceRect(Rectangle r) {
+		if (r==null)
+			return;
+		r = new Rectangle(r.x, r.y, r.width, r.height);
+		imageWidth = imp.getWidth();
+		imageHeight = imp.getHeight();
+		if (r.x<0) r.x = 0;
+		if (r.y<0) r.y = 0;
+		if (r.width<1)
+			r.width = 1;
+		if (r.height<1)
+			r.height = 1;
+		if (r.width>imageWidth)
+			r.width = imageWidth;
+		if (r.height>imageHeight)
+			r.height = imageHeight;
+		if (r.x+r.width>imageWidth)
+			r.x = imageWidth-r.width;
+		if (r.y+r.height>imageHeight)
+			r.y = imageHeight-r.height;
+		if (srcRect==null)
+			srcRect = r;
+		else {
+			srcRect.x = r.x;
+			srcRect.y = r.y;
+			srcRect.width = r.width;
+			srcRect.height = r.height;
+		}
+		if (dstWidth==0) {
+			Dimension size = getSize();
+			dstWidth = size.width;
+			dstHeight = size.height;
+		}
+		magnification = (double)dstWidth/srcRect.width;
+		imp.setTitle(imp.getTitle());
+		if (IJ.debugMode) IJ.log("setSourceRect: "+magnification+" "+(int)(srcRect.height*magnification+0.5)+" "+dstHeight+" "+srcRect);
+	}
+
+	void setSrcRect(Rectangle srcRect) {
+		setSourceRect(srcRect);
+	}
+		
+	public Rectangle getSrcRect() {
+		return srcRect;
+	}
+	
+	/** Obsolete; replaced by setSize() */
+	public void setDrawingSize(int width, int height) {
+		dstWidth = width;
+		dstHeight = height;
+		setSize(dstWidth, dstHeight);
+	}
+		
+	public void setSize(int width, int height) {
+		super.setSize(width, height);
+		dstWidth = width;
+		dstHeight = height;
+	}
+
+	/** ImagePlus.updateAndDraw calls this method to force the paint()
+		method to update the image from the ImageProcessor. */
+	public void setImageUpdated() {
+		imageUpdated = true;
+	}
+
+	public void setPaintPending(boolean state) {
+		paintPending.set(state);
+	}
+	
+	public boolean getPaintPending() {
+		return paintPending.get();
+	}
+
+	public void update(Graphics g) {
+		paint(g);
+	}
+	
+	//public void repaint() {
+	//	super.repaint();
+	//	//if (IJ.debugMode) IJ.log("repaint: "+imp);
+	//}
+	
+    public void paint(Graphics g) {
+		// if (IJ.debugMode) IJ.log("paint: "+imp);
+		painted = true;
+		Roi roi = imp.getRoi();
+		Overlay overlay = imp.getOverlay();
+		if (roi!=null || overlay!=null || showAllOverlay!=null || Prefs.paintDoubleBuffered || (IJ.isLinux() && magnification<0.25)) {
+			// Use double buffering to avoid flickering of ROIs and to work around
+			// a Linux problem with large images not showing at low magnification.
+			if (roi!=null)
+				roi.updatePaste();
+			if (imageWidth!=0) {
+				paintDoubleBuffered(g);
+				setPaintPending(false);
+				return;
+			}
+		}
+		try {
+			if (imageUpdated) {
+				imageUpdated = false;
+				imp.updateImage();
+			}
+			setInterpolation(g, Prefs.interpolateScaledImages);
+			Image img = imp.getImage();
+			if (img!=null)
+ 				g.drawImage(img, 0, 0, (int)(srcRect.width*magnification+0.5), (int)(srcRect.height*magnification+0.5),
+				srcRect.x, srcRect.y, srcRect.x+srcRect.width, srcRect.y+srcRect.height, null);
+			if (overlay!=null)
+				drawOverlay(overlay, g);
+			if (showAllOverlay!=null)
+				drawOverlay(showAllOverlay, g);
+			if (roi!=null) drawRoi(roi, g);
+			if (srcRect.width<imageWidth || srcRect.height<imageHeight)
+				drawZoomIndicator(g);
+			//if (IJ.debugMode) showFrameRate(g);
+		} catch(OutOfMemoryError e) {IJ.outOfMemory("Paint");}
+		setPaintPending(false);
+    }
+    
+	private void setInterpolation(Graphics g, boolean interpolate) {
+		if (magnification==1)
+			return;
+		else if (magnification<1.0 || interpolate) {
+			Object value = RenderingHints.VALUE_RENDER_QUALITY;
+			((Graphics2D)g).setRenderingHint(RenderingHints.KEY_RENDERING, value);
+		} else if (magnification>1.0) {
+			Object value = RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
+			((Graphics2D)g).setRenderingHint(RenderingHints.KEY_INTERPOLATION, value);
+		}
+	}
+
+    private void drawRoi(Roi roi, Graphics g) {
+		if (Interpreter.isBatchMode())
+			return;
+		if (roi==currentRoi) {
+			Color lineColor = roi.getStrokeColor();
+			Color fillColor = roi.getFillColor();
+			float lineWidth = roi.getStrokeWidth();
+			roi.setStrokeColor(null);
+			roi.setFillColor(null);
+			boolean strokeSet = roi.getStroke()!=null;
+			if (strokeSet)
+				roi.setStrokeWidth(1);
+			roi.draw(g);
+			roi.setStrokeColor(lineColor);
+			if (strokeSet)
+				roi.setStrokeWidth(lineWidth);
+			roi.setFillColor(fillColor);
+			currentRoi = null;
+		} else
+			roi.draw(g);
+    }
+           
+	public int getSliceNumber(String label) {
+		if (label==null) return 0;
+		int slice = 0;
+		if (label.length()>=14 && label.charAt(4)=='-' && label.charAt(9)=='-')
+			slice = (int)Tools.parseDouble(label.substring(0,4),0);
+		else if (label.length()>=17 && label.charAt(5)=='-' && label.charAt(11)=='-')
+			slice = (int)Tools.parseDouble(label.substring(0,5),0);
+		else if (label.length()>=20 && label.charAt(6)=='-' && label.charAt(13)=='-')
+			slice = (int)Tools.parseDouble(label.substring(0,6),0);
+		return slice;
+	}
+
+	private void drawOverlay(Overlay overlay, Graphics g) {
+		if (imp!=null && imp.getHideOverlay() && overlay!=showAllOverlay)
+			return;
+		flattening = imp!=null && ImagePlus.flattenTitle.equals(imp.getTitle());
+		if (imp!=null && showAllOverlay!=null && overlay!=showAllOverlay)
+			overlay.drawLabels(false);
+		Color labelColor = overlay.getLabelColor();
+		if (labelColor==null) labelColor = Color.white;
+		initGraphics(overlay, g, labelColor, Roi.getColor());
+		int n = overlay.size();
+		//if (IJ.debugMode) IJ.log("drawOverlay: "+n);
+		int currentImage = imp!=null?imp.getCurrentSlice():-1;
+		int stackSize = imp.getStackSize();
+		if (stackSize==1)
+			currentImage = -1;
+		int channel=0, slice=0, frame=0;
+		boolean hyperstack = imp.isHyperStack();
+		if (hyperstack) {
+			channel = imp.getChannel();
+			slice = imp.getSlice();
+			frame = imp.getFrame();
+		}
+		drawNames = overlay.getDrawNames() && overlay.getDrawLabels();
+		boolean drawLabels = drawNames || overlay.getDrawLabels();
+		if (drawLabels)
+			labelRects = new Rectangle[n];
+		else
+			labelRects = null;
+		font = overlay.getLabelFont();
+		if (overlay.scalableLabels() && font!=null) {
+			double mag = getMagnification();
+			if (mag!=1.0)
+				font = font.deriveFont((float)(font.getSize()*mag));
+		}
+		Roi activeRoi = imp.getRoi();
+		boolean roiManagerShowAllMode = overlay==showAllOverlay && !Prefs.showAllSliceOnly;
+		for (int i=0; i<n; i++) {
+			if (overlay==null) break;
+			Roi roi = overlay.get(i);
+			if (roi==null) break;
+			if (hyperstack) {
+				int c = roi.getCPosition();
+				int z = roi.getZPosition();
+				int t = roi.getTPosition();
+				int position = roi.getPosition();
+				//IJ.log(c+" "+z+" "+t+"  "+position+" "+roiManagerShowAllMode);
+				if (position>0) {
+					if (z==0 && imp.getNSlices()>1)
+						z = position;
+					else if (t==0)
+						t = position;
+				}
+				if (((c==0||c==channel) && (z==0||z==slice) && (t==0||t==frame)) || roiManagerShowAllMode)
+					drawRoi(g, roi, drawLabels?i+LIST_OFFSET:-1);
+			} else {
+				int position =  stackSize>1?roi.getPosition():0;
+				if (position==0 && stackSize>1)
+					position = getSliceNumber(roi.getName());
+				if (position>0 && imp.getCompositeMode()==IJ.COMPOSITE)
+					position = 0;
+				//IJ.log(position+"  "+currentImage+" "+roiManagerShowAllMode);
+				if (position==0 || position==currentImage || roiManagerShowAllMode)
+					drawRoi(g, roi, drawLabels?i+LIST_OFFSET:-1);
+			}
+		}
+		((Graphics2D)g).setStroke(Roi.onePixelWide);
+		drawNames = false;
+		font = null;
+	}
+    	
+	void drawOverlay(Graphics g) {
+		drawOverlay(imp.getOverlay(), g);
+	}
+
+    private void initGraphics(Overlay overlay, Graphics g, Color textColor, Color defaultColor) {
+		if (smallFont==null) {
+			smallFont = new Font("SansSerif", Font.PLAIN, 9);
+			largeFont = IJ.font12;
+		}
+		if (textColor!=null) {
+			labelColor = textColor;
+			if (overlay!=null && overlay.getDrawBackgrounds()) {
+				double brightness = (labelColor.getRed()+labelColor.getGreen()+labelColor.getBlue())/3.0;
+				if (labelColor==Color.green) brightness = 255;
+				bgColor = brightness<=85?Color.white:Color.black;
+			} else
+				bgColor = null;
+		} else {
+			int red = defaultColor.getRed();
+			int green = defaultColor.getGreen();
+			int blue = defaultColor.getBlue();
+			if ((red+green+blue)/3<128)
+				labelColor = Color.white;
+			else
+				labelColor = Color.black;
+			bgColor = defaultColor;
+		}
+		this.defaultColor = defaultColor;
+		Font font = overlay!=null?overlay.getLabelFont():null;
+		if (font!=null && font.getSize()>12)
+			((Graphics2D)g).setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+		g.setColor(defaultColor);
+    }
+    
+    void drawRoi(Graphics g, Roi roi, int index) {
+		ImagePlus imp2 = roi.getImage();
+		roi.setImage(imp);
+		Color saveColor = roi.getStrokeColor();
+		if (saveColor==null)
+			roi.setStrokeColor(defaultColor);
+		if (roi.getStroke()==null)
+			((Graphics2D)g).setStroke(Roi.onePixelWide);
+		if (roi instanceof TextRoi)
+			((TextRoi)roi).drawText(g);
+		else
+			roi.drawOverlay(g);
+		roi.setStrokeColor(saveColor);
+		if (index>=0) {
+			if (roi==currentRoi)
+				g.setColor(Roi.getColor());
+			else
+				g.setColor(defaultColor);
+			drawRoiLabel(g, index, roi);
+		}
+		if (imp2!=null)
+			roi.setImage(imp2);
+		else
+			roi.setImage(null);
+    }
+    
+	void drawRoiLabel(Graphics g, int index, Roi roi) {
+		if (roi.isCursor())
+			return;
+		boolean pointRoi = roi instanceof PointRoi;
+		Rectangle r = roi.getBounds();
+		int x = screenX(r.x);
+		int y = screenY(r.y);
+		double mag = getMagnification();
+		int width = (int)(r.width*mag);
+		int height = (int)(r.height*mag);
+		int size = width>40 || height>40?12:9;
+		int pointSize = 0;
+		int crossSize = 0;
+		if (pointRoi) {
+			pointSize = ((PointRoi)roi).getSize();
+			switch (pointSize) {
+				case 0: case 1: size=9; break;
+				case 2: case 3: size=10; break;
+				case 4: size=12; break;
+			}
+			crossSize = pointSize + 10 + 2*pointSize;
+		}
+		if (font!=null) {
+			g.setFont(font);
+			size = font.getSize();
+		} else if (size==12)
+			g.setFont(largeFont);
+		else
+			g.setFont(smallFont);
+		boolean drawingList = index >= LIST_OFFSET;
+		if (drawingList) index -= LIST_OFFSET;
+		String label = "" + (index+1);
+		if (drawNames)
+			label = roi.getName();
+		if (label==null)
+			return;
+		FontMetrics metrics = g.getFontMetrics();
+		int w = metrics.stringWidth(label);
+		x = x + width/2 - w/2;
+		y = y + height/2 + Math.max(size/2,6);
+		int h = metrics.getAscent() + metrics.getDescent();
+		int xoffset=0, yoffset=0;
+		if (pointRoi) {
+			xoffset = 6 + pointSize;
+			yoffset = h - 6 + pointSize;
+		}
+		if (bgColor!=null) {
+			int h2 = h;
+			if (font!=null && font.getSize()>14)
+				h2 = (int)(h2*0.8);
+			g.setColor(bgColor);
+			g.fillRoundRect(x-1+xoffset, y-h2+2+yoffset, w+1, h2-2, 5, 5);
+		}
+		if (labelRects!=null && index<labelRects.length) {
+			if (pointRoi) {
+				int x2 = screenX(r.x);
+				int y2 = screenY(r.y);
+				int crossSize2 = crossSize/2;
+				labelRects[index] = new Rectangle(x2-crossSize2, y2-crossSize2, crossSize, crossSize);
+			} else
+				labelRects[index] = new Rectangle(x-3, y-h+1, w+4, h);
+		}		
+		//IJ.log("drawRoiLabel: "+" "+label+" "+x+" "+y+" "+flattening);
+		g.setColor(labelColor);
+		g.drawString(label, x+xoffset, y-2+yoffset);
+		g.setColor(defaultColor);
+	} 
+
+	void drawZoomIndicator(Graphics g) {
+		if (hideZoomIndicator)
+			return;
+		int x1 = 10;
+		int y1 = 10;
+		double aspectRatio = (double)imageHeight/imageWidth;
+		int w1 = 64;
+		if (aspectRatio>1.0)
+			w1 = (int)(w1/aspectRatio);
+		int h1 = (int)(w1*aspectRatio);
+		if (w1<4) w1 = 4;
+		if (h1<4) h1 = 4;
+		int w2 = (int)(w1*((double)srcRect.width/imageWidth));
+		int h2 = (int)(h1*((double)srcRect.height/imageHeight));
+		if (w2<1) w2 = 1;
+		if (h2<1) h2 = 1;
+		int x2 = (int)(w1*((double)srcRect.x/imageWidth));
+		int y2 = (int)(h1*((double)srcRect.y/imageHeight));
+		if (zoomIndicatorColor==null)
+			zoomIndicatorColor = new Color(128, 128, 255);
+		g.setColor(zoomIndicatorColor);
+		((Graphics2D)g).setStroke(Roi.onePixelWide);
+		g.drawRect(x1, y1, w1, h1);
+		if (w2*h2<=200 || w2<10 || h2<10)
+			g.fillRect(x1+x2, y1+y2, w2, h2);
+		else
+			g.drawRect(x1+x2, y1+y2, w2, h2);
+	}
+
+	// Use double buffer to reduce flicker when drawing complex ROIs.
+	// Author: Erik Meijering
+	void paintDoubleBuffered(Graphics g) {
+		final int srcRectWidthMag = (int)(srcRect.width*magnification+0.5);
+		final int srcRectHeightMag = (int)(srcRect.height*magnification+0.5);
+		if (offScreenImage==null || offScreenWidth!=srcRectWidthMag || offScreenHeight!=srcRectHeightMag) {
+			offScreenImage = createImage(srcRectWidthMag, srcRectHeightMag);
+			offScreenWidth = srcRectWidthMag;
+			offScreenHeight = srcRectHeightMag;
+		}
+		Roi roi = imp.getRoi();
+		try {
+			if (imageUpdated) {
+				imageUpdated = false;
+				imp.updateImage();
+			}
+			Graphics offScreenGraphics = offScreenImage.getGraphics();
+			setInterpolation(offScreenGraphics, Prefs.interpolateScaledImages);
+			Image img = imp.getImage();
+			if (img!=null)
+				offScreenGraphics.drawImage(img, 0, 0, srcRectWidthMag, srcRectHeightMag,
+					srcRect.x, srcRect.y, srcRect.x+srcRect.width, srcRect.y+srcRect.height, null);
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null)
+				drawOverlay(overlay, offScreenGraphics);
+			if (showAllOverlay!=null)
+				drawOverlay(showAllOverlay, offScreenGraphics);
+			if (roi!=null)
+				drawRoi(roi, offScreenGraphics);
+			if (srcRect.width<imageWidth || srcRect.height<imageHeight)
+				drawZoomIndicator(offScreenGraphics);
+			//if (IJ.debugMode) showFrameRate(offScreenGraphics);
+			g.drawImage(offScreenImage, 0, 0, null);
+		}
+		catch(OutOfMemoryError e) {IJ.outOfMemory("Paint");}
+	}
+	
+	public void resetDoubleBuffer() {
+		offScreenImage = null;
+	}
+
+    long firstFrame;
+    int frames, fps;
+        
+	void showFrameRate(Graphics g) {
+		frames++;
+		if (System.currentTimeMillis()>firstFrame+1000) {
+			firstFrame=System.currentTimeMillis();
+			fps = frames;
+			frames=0;
+		}
+		g.setColor(Color.white);
+		g.fillRect(10, 12, 50, 15);
+		g.setColor(Color.black);
+		g.drawString((int)(fps+0.5) + " fps", 10, 25);
+	}
+
+    public Dimension getPreferredSize() {
+        return new Dimension(dstWidth, dstHeight);
+    }
+
+	/** Returns the current cursor location in image coordinates. */
+	public Point getCursorLoc() {
+		return new Point(xMouse, yMouse);
+	}
+	
+	/** Returns 'true' if the cursor is over this image. */
+	public boolean cursorOverImage() {
+		return !mouseExited;
+	}
+
+	/** Returns the mouse event modifiers. */
+	public int getModifiers() {
+		return flags;
+	}
+	
+	/** Returns the ImagePlus object that is associated with this ImageCanvas. */
+	public ImagePlus getImage() {
+		return imp;
+	}
+
+	/** Sets the cursor based on the current tool and cursor location. */
+	public void setCursor(int sx, int sy, int ox, int oy) {
+		xMouse = ox;
+		yMouse = oy;
+		mouseExited = false;
+		Roi roi = imp.getRoi();
+		ImageWindow win = imp.getWindow();
+		overOverlayLabel = false;
+		if (win==null)
+			return;
+		if (IJ.spaceBarDown()) {
+			setCursor(handCursor);
+			return;
+		}
+		int id = Toolbar.getToolId();
+		switch (id) {
+			case Toolbar.MAGNIFIER:
+				setCursor(moveCursor);
+				break;
+			case Toolbar.HAND:
+				setCursor(handCursor);
+				break;
+			default:  //selection tool
+				PlugInTool tool = Toolbar.getPlugInTool();
+				boolean arrowTool = roi!=null && (roi instanceof Arrow) && tool!=null && "Arrow Tool".equals(tool.getToolName());
+				if ((id>=Toolbar.CUSTOM1) && !arrowTool) {
+					if (Prefs.usePointerCursor)
+						setCursor(defaultCursor);
+					else
+						setCursor(crosshairCursor);
+				} else if (roi!=null && roi.getState()!=roi.CONSTRUCTING && roi.isHandle(sx, sy)>=0) {
+					setCursor(handCursor);
+				} else if ((imp.getOverlay()!=null||showAllOverlay!=null) && overOverlayLabel(sx,sy,ox,oy) && (roi==null||roi.getState()!=roi.CONSTRUCTING)) {
+					overOverlayLabel = true;
+					setCursor(handCursor);
+				} else if (Prefs.usePointerCursor || (roi!=null && roi.getState()!=roi.CONSTRUCTING && roi.contains(ox, oy)))
+					setCursor(defaultCursor);
+				else
+					setCursor(crosshairCursor);
+		}
+	}
+	
+	private boolean overOverlayLabel(int sx, int sy, int ox, int oy) {
+		Overlay o = showAllOverlay;
+		if (o==null)
+			o = imp.getOverlay();
+		if (o==null || !o.isSelectable() || !o.isDraggable()|| !o.getDrawLabels() || labelRects==null)
+			return false;
+		for (int i=o.size()-1; i>=0; i--) {
+			if (labelRects!=null&&labelRects[i]!=null&&labelRects[i].contains(sx,sy)) {
+				Roi roi = imp.getRoi();
+				if (roi==null || !roi.contains(ox,oy))
+					return true;
+				else
+					return false;
+			}
+		}
+		return false;
+	}
+
+	/**Converts a screen x-coordinate to an offscreen x-coordinate (nearest pixel center).*/
+	public int offScreenX(int sx) {
+		return srcRect.x + (int)(sx/magnification);
+	}
+		
+	/**Converts a screen y-coordinate to an offscreen y-coordinate (nearest pixel center).*/
+	public int offScreenY(int sy) {
+		return srcRect.y + (int)(sy/magnification);
+	}
+	
+	/**Converts a screen x-coordinate to an offscreen x-coordinate (Roi coordinate of nearest pixel border).*/
+	public int offScreenX2(int sx) {
+		return srcRect.x + (int)Math.round(sx/magnification);
+	}
+		
+	/**Converts a screen y-coordinate to an offscreen y-coordinate (Roi coordinate of nearest pixel border).*/
+	public int offScreenY2(int sy) {
+		return srcRect.y + (int)Math.round(sy/magnification);
+	}
+	
+	/**Converts a screen x-coordinate to a floating-point offscreen x-coordinate.*/
+	public double offScreenXD(int sx) {
+		return srcRect.x + sx/magnification;
+	}
+		
+	/**Converts a screen y-coordinate to a floating-point offscreen y-coordinate.*/
+	public double offScreenYD(int sy) {
+		return srcRect.y + sy/magnification;
+
+	}
+	
+	/**Converts an offscreen x-coordinate to a screen x-coordinate.*/
+	public int screenX(int ox) {
+		return  (int)((ox-srcRect.x)*magnification);
+	}
+	
+	/**Converts an offscreen y-coordinate to a screen y-coordinate.*/
+	public int screenY(int oy) {
+		return  (int)((oy-srcRect.y)*magnification);
+	}
+
+	/**Converts a floating-point offscreen x-coordinate to a screen x-coordinate.*/
+	public int screenXD(double ox) {
+		return  (int)((ox-srcRect.x)*magnification);
+	}
+	
+	/**Converts a floating-point offscreen x-coordinate to a screen x-coordinate.*/
+	public int screenYD(double oy) {
+		return  (int)((oy-srcRect.y)*magnification);
+	}
+
+	public double getMagnification() {
+		return magnification;
+	}
+		
+	public void setMagnification(double magnification) {
+		setMagnification2(magnification);
+	}
+		
+	void setMagnification2(double magnification) {
+		if (magnification>32.0)
+			magnification = 32.0;
+		if (magnification<zoomLevels[0])
+			magnification = zoomLevels[0];
+		this.magnification = magnification;
+		imp.setTitle(imp.getTitle());
+	}
+
+	/** Resizes the canvas when the user resizes the window. */
+	void resizeCanvas(int width, int height) {
+		ImageWindow win = imp.getWindow();
+		//IJ.log("resizeCanvas: "+srcRect+" "+imageWidth+"  "+imageHeight+" "+width+"  "+height+" "+dstWidth+"  "+dstHeight+" "+win.maxBounds);
+		if (!maxBoundsReset&& (width>dstWidth||height>dstHeight)&&win!=null&&win.maxBounds!=null&&width!=win.maxBounds.width-10) {
+			if (resetMaxBoundsCount!=0)
+				resetMaxBounds(); // Works around problem that prevented window from being larger than maximized size
+			resetMaxBoundsCount++;
+		}
+		if (scaleToFit || IJ.altKeyDown())
+			{fitToWindow(); return;}
+		if (width>imageWidth*magnification)
+			width = (int)(imageWidth*magnification);
+		if (height>imageHeight*magnification)
+			height = (int)(imageHeight*magnification);
+		Dimension size = getSize();
+		if (srcRect.width<imageWidth || srcRect.height<imageHeight || (painted&&(width!=size.width||height!=size.height))) {
+			setSize(width, height);
+			srcRect.width = (int)(dstWidth/magnification);
+			srcRect.height = (int)(dstHeight/magnification);
+			if ((srcRect.x+srcRect.width)>imageWidth)
+				srcRect.x = imageWidth-srcRect.width;
+			if ((srcRect.y+srcRect.height)>imageHeight)
+				srcRect.y = imageHeight-srcRect.height;
+			repaint();
+		}
+		//IJ.log("resizeCanvas2: "+srcRect+" "+dstWidth+"  "+dstHeight+" "+width+"  "+height);
+	}
+	
+	public void fitToWindow() {
+		ImageWindow win = imp.getWindow();
+		if (win==null) return;
+		Rectangle bounds = win.getBounds();
+		Insets insets = win.getInsets();
+		int sliderHeight = win.getSliderHeight();
+		double xmag = (double)(bounds.width-(insets.left+insets.right+ImageWindow.HGAP*2))/srcRect.width;
+		double ymag = (double)(bounds.height-(ImageWindow.VGAP*2+insets.top+insets.bottom+sliderHeight))/srcRect.height;
+		setMagnification(Math.min(xmag, ymag));
+		int width=(int)(imageWidth*magnification);
+		int height=(int)(imageHeight*magnification);
+		if (width==dstWidth&&height==dstHeight) return;
+		srcRect=new Rectangle(0,0,imageWidth, imageHeight);
+		setSize(width, height);
+		getParent().doLayout();
+	}
+    
+	void setMaxBounds() {
+		if (maxBoundsReset) {
+			maxBoundsReset = false;
+			ImageWindow win = imp.getWindow();
+			if (win!=null && !IJ.isLinux() && win.maxBounds!=null) {
+				win.setMaximizedBounds(win.maxBounds);
+				win.setMaxBoundsTime = System.currentTimeMillis();
+			}
+		}
+	}
+
+	void resetMaxBounds() {
+		ImageWindow win = imp.getWindow();
+		if (win!=null && (System.currentTimeMillis()-win.setMaxBoundsTime)>500L) {
+			win.setMaximizedBounds(win.maxWindowBounds);
+			maxBoundsReset = true;
+		}
+	}
+	
+	private static final double[] zoomLevels = {
+		1/72.0, 1/48.0, 1/32.0, 1/24.0, 1/16.0, 1/12.0, 
+		1/8.0, 1/6.0, 1/4.0, 1/3.0, 1/2.0, 0.75, 1.0, 1.5,
+		2.0, 3.0, 4.0, 6.0, 8.0, 12.0, 16.0, 24.0, 32.0 };
+	
+	public static double getLowerZoomLevel(double currentMag) {
+		double newMag = zoomLevels[0];
+		for (int i=0; i<zoomLevels.length; i++) {
+			if (zoomLevels[i] < currentMag)
+				newMag = zoomLevels[i];
+			else
+				break;
+		}
+		return newMag;
+	}
+
+	public static double getHigherZoomLevel(double currentMag) {
+		double newMag = 32.0;
+		for (int i=zoomLevels.length-1; i>=0; i--) {
+			if (zoomLevels[i]>currentMag)
+				newMag = zoomLevels[i];
+			else
+				break;
+		}
+		return newMag;
+	}
+
+	/** Zooms in by making the window bigger. If it can't be made bigger, then makes 
+		the source rectangle (srcRect) smaller and centers it on the position in the
+		image where the cursor was when zooming has started.
+		Note that sx and sy are screen coordinates. */
+	public void zoomIn(int sx, int sy) {
+		if (magnification>=32) return;
+		scaleToFit = false;
+	    boolean mouseMoved = sqr(sx-lastZoomSX) + sqr(sy-lastZoomSY) > MAX_MOUSEMOVE_ZOOM*MAX_MOUSEMOVE_ZOOM;
+		lastZoomSX = sx;
+		lastZoomSY = sy;
+		if (mouseMoved || zoomTargetOX<0) {
+		    boolean cursorInside = sx >= 0 && sy >= 0 && sx < dstWidth && sy < dstHeight;
+		    zoomTargetOX = offScreenX(cursorInside ? sx : dstWidth/2); //where to zoom, offscreen (image) coordinates
+		    zoomTargetOY = offScreenY(cursorInside ? sy : dstHeight/2);
+		}
+		double newMag = getHigherZoomLevel(magnification);
+		int newWidth = (int)(imageWidth*newMag);
+		int newHeight = (int)(imageHeight*newMag);
+		Dimension newSize = canEnlarge(newWidth, newHeight);
+		if (newSize!=null) {
+			setSize(newSize.width, newSize.height);
+			if (newSize.width!=newWidth || newSize.height!=newHeight)
+				adjustSourceRect(newMag, zoomTargetOX, zoomTargetOY);
+			else
+				setMagnification(newMag);
+			imp.getWindow().pack();
+		} else // can't enlarge window
+			adjustSourceRect(newMag, zoomTargetOX, zoomTargetOY);
+		repaint();
+		if (srcRect.width<imageWidth || srcRect.height<imageHeight)
+			resetMaxBounds();
+	}
+
+	/** Centers the viewable area on offscreen (image) coordinates x, y */
+	void adjustSourceRect(double newMag, int x, int y) {
+		//IJ.log("adjustSourceRect1: "+newMag+" "+dstWidth+"  "+dstHeight);
+		int w = (int)Math.round(dstWidth/newMag);
+		if (w*newMag<dstWidth) w++;
+		int h = (int)Math.round(dstHeight/newMag);
+		if (h*newMag<dstHeight) h++;
+		Rectangle r = new Rectangle(x-w/2, y-h/2, w, h);
+		if (r.x<0) r.x = 0;
+		if (r.y<0) r.y = 0;
+		if (r.x+w>imageWidth) r.x = imageWidth-w;
+		if (r.y+h>imageHeight) r.y = imageHeight-h;
+		srcRect = r;
+		setMagnification(newMag);
+		//IJ.log("adjustSourceRect2: "+srcRect+" "+dstWidth+"  "+dstHeight);
+	}
+
+    /** Returns the size to which the window can be enlarged, or null if it can't be enlarged.
+     *  <code>newWidth, newHeight</code> is the size needed for showing the full image
+     *  at the magnification needed */
+	protected Dimension canEnlarge(int newWidth, int newHeight) {
+		if (IJ.altKeyDown())
+			return null;
+		ImageWindow win = imp.getWindow();
+		if (win==null) return null;
+		Rectangle r1 = win.getBounds();
+		Insets insets = win.getInsets();
+		Point loc = getLocation();
+		if (loc.x>insets.left+5 || loc.y>insets.top+5) {
+			r1.width = newWidth+insets.left+insets.right+ImageWindow.HGAP*2;
+			r1.height = newHeight+insets.top+insets.bottom+ImageWindow.VGAP*2+win.getSliderHeight();
+		} else {
+			r1.width = r1.width - dstWidth + newWidth;
+			r1.height = r1.height - dstHeight + newHeight;
+		}
+		Rectangle max = GUI.getMaxWindowBounds(win);
+		boolean fitsHorizontally = r1.x+r1.width<max.x+max.width;
+		boolean fitsVertically = r1.y+r1.height<max.y+max.height;
+		if (fitsHorizontally && fitsVertically)
+			return new Dimension(newWidth, newHeight);
+		else if (fitsVertically && newHeight<dstWidth)
+			return new Dimension(dstWidth, newHeight);
+		else if (fitsHorizontally && newWidth<dstHeight)
+			return new Dimension(newWidth, dstHeight);
+		else
+			return null;
+	}
+	
+	/**Zooms out by making the source rectangle (srcRect)  
+		larger and centering it on (x,y). If we can't make it larger,  
+		then make the window smaller. Note that
+		sx and sy are screen coordinates. */
+	public void zoomOut(int sx, int sy) {
+		if (magnification<=zoomLevels[0])
+			return;
+	    boolean mouseMoved = sqr(sx-lastZoomSX) + sqr(sy-lastZoomSY) > MAX_MOUSEMOVE_ZOOM*MAX_MOUSEMOVE_ZOOM;
+		lastZoomSX = sx;
+		lastZoomSY = sy;
+		if (mouseMoved || zoomTargetOX<0) {
+		    boolean cursorInside = sx >= 0 && sy >= 0 && sx < dstWidth && sy < dstHeight;
+		    zoomTargetOX = offScreenX(cursorInside ? sx : dstWidth/2); //where to zoom, offscreen (image) coordinates
+		    zoomTargetOY = offScreenY(cursorInside ? sy : dstHeight/2);
+		}
+		double oldMag = magnification;
+		double newMag = getLowerZoomLevel(magnification);
+		double srcRatio = (double)srcRect.width/srcRect.height;
+		double imageRatio = (double)imageWidth/imageHeight;
+		double initialMag = imp.getWindow().getInitialMagnification();
+		if (Math.abs(srcRatio-imageRatio)>0.05) {
+			double scale = oldMag/newMag;
+			int newSrcWidth = (int)Math.round(srcRect.width*scale);
+			int newSrcHeight = (int)Math.round(srcRect.height*scale);
+			if (newSrcWidth>imageWidth) newSrcWidth=imageWidth; 
+			if (newSrcHeight>imageHeight) newSrcHeight=imageHeight;
+			int newSrcX = srcRect.x - (newSrcWidth - srcRect.width)/2;
+			int newSrcY = srcRect.y - (newSrcHeight - srcRect.height)/2;
+			if (newSrcX + newSrcWidth > imageWidth) newSrcX = imageWidth - newSrcWidth;
+			if (newSrcY + newSrcHeight > imageHeight) newSrcY = imageHeight - newSrcHeight;
+			if (newSrcX<0) newSrcX = 0;
+			if (newSrcY<0) newSrcY = 0;
+			srcRect = new Rectangle(newSrcX, newSrcY, newSrcWidth, newSrcHeight);
+            //IJ.log(newMag+" "+srcRect+" "+dstWidth+" "+dstHeight);
+			int newDstWidth = (int)(srcRect.width*newMag);
+			int newDstHeight = (int)(srcRect.height*newMag);
+			setMagnification(newMag);
+			setMaxBounds();
+            //IJ.log(newDstWidth+" "+dstWidth+" "+newDstHeight+" "+dstHeight);
+			if (newDstWidth<dstWidth || newDstHeight<dstHeight) {
+				setSize(newDstWidth, newDstHeight);
+				imp.getWindow().pack();
+			} else
+				repaint();
+			return;
+		}
+		if (imageWidth*newMag>dstWidth) {
+			int w = (int)Math.round(dstWidth/newMag);
+			if (w*newMag<dstWidth) w++;
+			int h = (int)Math.round(dstHeight/newMag);
+			if (h*newMag<dstHeight) h++;
+			Rectangle r = new Rectangle(zoomTargetOX-w/2, zoomTargetOY-h/2, w, h);
+			if (r.x<0) r.x = 0;
+			if (r.y<0) r.y = 0;
+			if (r.x+w>imageWidth) r.x = imageWidth-w;
+			if (r.y+h>imageHeight) r.y = imageHeight-h;
+			srcRect = r;
+			setMagnification(newMag);
+		} else {
+			srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
+			setSize((int)(imageWidth*newMag), (int)(imageHeight*newMag));
+			setMagnification(newMag);
+			imp.getWindow().pack();
+		}
+		setMaxBounds();
+		repaint();
+	}
+
+    int sqr(int x) {
+        return x*x;
+    }
+
+	/** Implements the Image/Zoom/Original Scale command. */
+	public void unzoom() {
+		double imag = imp.getWindow().getInitialMagnification();
+		if (magnification==imag)
+			return;
+		srcRect = new Rectangle(0, 0, imageWidth, imageHeight);
+		ImageWindow win = imp.getWindow();
+		setSize((int)(imageWidth*imag), (int)(imageHeight*imag));
+		setMagnification(imag);
+        setMaxBounds();
+		win.pack();
+		setMaxBounds();
+		repaint();
+	}
+		
+	/** Implements the Image/Zoom/View 100% command. */
+	public void zoom100Percent() {
+		if (magnification==1.0)
+			return;
+		double imag = imp.getWindow().getInitialMagnification();
+		if (magnification!=imag)
+			unzoom();
+		if (magnification==1.0)
+			return;
+		if (magnification<1.0) {
+			while (magnification<1.0)
+				zoomIn(imageWidth/2, imageHeight/2);
+		} else if (magnification>1.0) {
+			while (magnification>1.0)
+				zoomOut(imageWidth/2, imageHeight/2);
+		} else
+			return;
+		int x=xMouse, y=yMouse;
+		if (mouseExited) {
+			x = imageWidth/2;
+			y = imageHeight/2;
+		}
+		int sx = screenX(x);
+		int sy = screenY(y);
+		adjustSourceRect(1.0, sx, sy);
+		repaint();
+	}
+	
+	protected void scroll(int sx, int sy) {
+		int ox = xSrcStart + (int)(sx/magnification);  //convert to offscreen coordinates
+		int oy = ySrcStart + (int)(sy/magnification);
+		//IJ.log("scroll: "+ox+" "+oy+" "+xMouseStart+" "+yMouseStart);
+		int newx = xSrcStart + (xMouseStart-ox);
+		int newy = ySrcStart + (yMouseStart-oy);
+		if (newx<0) newx = 0;
+		if (newy<0) newy = 0;
+		if ((newx+srcRect.width)>imageWidth) newx = imageWidth-srcRect.width;
+		if ((newy+srcRect.height)>imageHeight) newy = imageHeight-srcRect.height;
+		srcRect.x = newx;
+		srcRect.y = newy;
+		//IJ.log(sx+"  "+sy+"  "+newx+"  "+newy+"  "+srcRect);
+		imp.draw();
+		Thread.yield();
+	}	
+	
+	Color getColor(int index){
+		IndexColorModel cm = (IndexColorModel)imp.getProcessor().getColorModel();
+		return new Color(cm.getRGB(index));
+	}
+	
+	/** Sets the foreground drawing color (or background color if 
+		'setBackground' is true) to the color of the pixel at (ox,oy). */
+	public void setDrawingColor(int ox, int oy, boolean setBackground) {
+		//IJ.log("setDrawingColor: "+setBackground+this);
+		int type = imp.getType();
+		int[] v = imp.getPixel(ox, oy);
+		switch (type) {
+			case ImagePlus.GRAY8: {
+				if (setBackground)
+					setBackgroundColor(getColor(v[0]));
+				else
+					setForegroundColor(getColor(v[0]));
+				break;
+			}
+			case ImagePlus.GRAY16: case ImagePlus.GRAY32: {
+				double min = imp.getProcessor().getMin();
+				double max = imp.getProcessor().getMax();
+				double value = (type==ImagePlus.GRAY32)?Float.intBitsToFloat(v[0]):v[0];
+				int index = (int)(255.0*((value-min)/(max-min)));
+				if (index<0) index = 0;
+				if (index>255) index = 255;
+				if (setBackground)
+					setBackgroundColor(getColor(index));
+				else
+					setForegroundColor(getColor(index));
+				break;
+			}
+			case ImagePlus.COLOR_RGB: case ImagePlus.COLOR_256: {
+				Color c = new Color(v[0], v[1], v[2]);
+				if (setBackground)
+					setBackgroundColor(c);
+				else
+					setForegroundColor(c);
+				break;
+			}
+		}
+		Color c;
+		if (setBackground)
+			c = Toolbar.getBackgroundColor();
+		else {
+			c = Toolbar.getForegroundColor();
+			imp.setColor(c);
+		}
+		IJ.showStatus("("+c.getRed()+", "+c.getGreen()+", "+c.getBlue()+")");
+	}
+	
+	private void setForegroundColor(Color c) {
+		Toolbar.setForegroundColor(c);
+		if (Recorder.record)
+			Recorder.record("setForegroundColor", c.getRed(), c.getGreen(), c.getBlue());
+	}
+
+	private void setBackgroundColor(Color c) {
+		Toolbar.setBackgroundColor(c);
+		if (Recorder.record)
+			Recorder.record("setBackgroundColor", c.getRed(), c.getGreen(), c.getBlue());
+	}
+
+	public void mousePressed(final MouseEvent e) {
+		showCursorStatus = true;
+		int toolID = Toolbar.getToolId();
+		ImageWindow win = imp.getWindow();
+		if (win!=null && win.running2 && toolID!=Toolbar.MAGNIFIER) {
+			if (win instanceof StackWindow)
+				((StackWindow)win).setAnimate(false);
+			else
+				win.running2 = false;
+			return;
+		}
+				
+		int x = e.getX();
+		int y = e.getY();
+		flags = e.getModifiers();		
+		if (toolID!=Toolbar.MAGNIFIER && (e.isPopupTrigger()||(!IJ.isMacintosh()&&(flags&Event.META_MASK)!=0))) {
+			handlePopupMenu(e);
+			return;
+		}
+
+		int ox = offScreenX(x);
+		int oy = offScreenY(y);
+		xMouse = ox; yMouse = oy;
+		if (IJ.spaceBarDown()) {
+			// temporarily switch to "hand" tool of space bar down
+			setupScroll(ox, oy);
+			return;
+		}
+		
+		if (overOverlayLabel && (imp.getOverlay()!=null||showAllOverlay!=null)) {
+			if (activateOverlayRoi(ox, oy))
+				return;
+		}
+		
+		if ((System.currentTimeMillis()-mousePressedTime)<300L && !drawingTool()) {
+			if (activateOverlayRoi(ox,oy))
+				return;
+		}
+		
+		mousePressedX = ox;
+		mousePressedY = oy;
+		mousePressedTime = System.currentTimeMillis();
+		
+		PlugInTool tool = Toolbar.getPlugInTool();
+		if (tool!=null) {
+			tool.mousePressed(imp, e);
+			if (e.isConsumed()) return;
+		}
+		if (customRoi && imp.getOverlay()!=null)
+			return;
+
+		if (toolID>=Toolbar.CUSTOM1) {
+			if (tool!=null && "Arrow Tool".equals(tool.getToolName()))
+				handleRoiMouseDown(e);
+			else
+				Toolbar.getInstance().runMacroTool(toolID);
+			return;
+		}
+		
+		final Roi roi1 = imp.getRoi();
+		final int size1 = roi1!=null?roi1.size():0;
+		final Rectangle r1 = roi1!=null?roi1.getBounds():null;
+
+		switch (toolID) {
+			case Toolbar.MAGNIFIER:
+				if (IJ.shiftKeyDown())
+					zoomToSelection(ox, oy);
+				else if ((flags & (Event.ALT_MASK|Event.META_MASK|Event.CTRL_MASK))!=0) {
+					zoomOut(x, y);
+					if (getMagnification()<1.0)
+						imp.repaintWindow();
+				} else {
+	 				zoomIn(x, y);
+					if (getMagnification()<=1.0)
+						imp.repaintWindow();
+				}
+				break;
+			case Toolbar.HAND:
+				setupScroll(ox, oy);
+				break;
+			case Toolbar.DROPPER:
+				setDrawingColor(ox, oy, IJ.altKeyDown());
+				break;
+			case Toolbar.WAND:
+				double tolerance = WandToolOptions.getTolerance();
+				Roi roi = imp.getRoi();
+				if (roi!=null && (tolerance==0.0||imp.isThreshold()) && roi.contains(ox, oy)) {
+					Rectangle r = roi.getBounds();
+					if (r.width==imageWidth && r.height==imageHeight)
+						imp.deleteRoi();
+					else if (!e.isAltDown()) {
+						handleRoiMouseDown(e);
+						return;
+					}
+				}
+				if (roi!=null) {
+					int handle = roi.isHandle(x, y);
+					if (handle>=0) {
+						roi.mouseDownInHandle(handle, x, y);
+						return;
+					}
+				}
+				if (!imp.okToDeleteRoi())
+					break;
+				setRoiModState(e, roi, -1);
+				String mode = WandToolOptions.getMode();
+				if (Prefs.smoothWand)
+					mode = mode + " smooth";
+				int npoints = IJ.doWand(imp, ox, oy, tolerance, mode);
+				if (Recorder.record && npoints>0) {
+					if (Recorder.scriptMode())
+						Recorder.recordCall("IJ.doWand(imp, "+ox+", "+oy+", "+tolerance+", \""+mode+"\");");
+					else {
+						if (tolerance==0.0 && mode.equals("Legacy"))
+							Recorder.record("doWand", ox, oy);
+						else
+							Recorder.recordString("doWand("+ox+", "+oy+", "+tolerance+", \""+mode+"\");\n");
+					}
+				}
+				break;
+			case Toolbar.OVAL:
+				if (Toolbar.getBrushSize()>0)
+					new RoiBrush();
+				else
+					handleRoiMouseDown(e);
+				break;
+			default:  //selection tool
+				handleRoiMouseDown(e);
+		}
+		
+		if (longClickDelay>0) {
+			if (pressTimer==null)
+				pressTimer = new java.util.Timer();	
+			final Point cursorLoc = getCursorLoc();	
+			pressTimer.schedule(new TimerTask() {
+				public void run() {
+					if (pressTimer != null) {
+						pressTimer.cancel();
+						pressTimer = null;
+					}
+					Roi roi2 = imp.getRoi();
+					int size2 = roi2!=null?roi2.size():0;
+					Rectangle r2 = roi2!=null?roi2.getBounds():null;
+					boolean empty = r2!=null&&r2.width==0&&r2.height==0;
+					int state = roi2!=null?roi2.getState():-1;
+					boolean unchanged = state!=Roi.MOVING_HANDLE && r1!=null && r2!=null && r2.x==r1.x
+						&& r2.y==r1.y  && r2.width==r1.width && r2.height==r1.height && size2==size1
+						&& !(size2>1&&state==Roi.CONSTRUCTING);
+					boolean cursorMoved = !getCursorLoc().equals(cursorLoc);
+					//IJ.log(size2+" "+empty+" "+unchanged+" "+state+" "+roi1+"  "+roi2);			
+					if ((roi1==null && (size2<=1||empty)) || unchanged) {
+						if (roi1==null) imp.deleteRoi();
+						if (!cursorMoved && Toolbar.getToolId()!=Toolbar.HAND)
+							handlePopupMenu(e);
+					}
+				}
+			}, longClickDelay);
+		}
+		
+	}
+	
+	
+		
+	private boolean drawingTool() {
+		int id = Toolbar.getToolId();
+		return id==Toolbar.POLYLINE || id==Toolbar.FREELINE || id>=Toolbar.CUSTOM1;
+	}
+	
+	void zoomToSelection(int x, int y) {
+		IJ.setKeyUp(IJ.ALL_KEYS);
+		String macro =
+			"args = split(getArgument);\n"+
+			"x1=parseInt(args[0]); y1=parseInt(args[1]); flags=20;\n"+
+			"while (flags&20!=0) {\n"+
+				"getCursorLoc(x2, y2, z, flags);\n"+
+				"if (x2>=x1) x=x1; else x=x2;\n"+
+				"if (y2>=y1) y=y1; else y=y2;\n"+
+				"makeRectangle(x, y, abs(x2-x1), abs(y2-y1));\n"+
+				"wait(10);\n"+
+			"}\n"+
+			"run('To Selection');\n";
+		new MacroRunner(macro, x+" "+y);
+	}
+
+	protected void setupScroll(int ox, int oy) {
+		xMouseStart = ox;
+		yMouseStart = oy;
+		xSrcStart = srcRect.x;
+		ySrcStart = srcRect.y;
+	}
+
+	protected void handlePopupMenu(MouseEvent e) {
+		if (disablePopupMenu) return;
+		if (IJ.debugMode) IJ.log("show popup: " + (e.isPopupTrigger()?"true":"false"));
+		int sx = e.getX();
+		int sy = e.getY();
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		Roi roi = imp.getRoi();
+		if (roi!=null && (roi.getType()==Roi.POLYGON || roi.getType()==Roi.POLYLINE || roi.getType()==Roi.ANGLE)
+		&& roi.getState()==roi.CONSTRUCTING) {
+			roi.handleMouseUp(sx, sy); // simulate double-click to finalize
+			roi.handleMouseUp(sx, sy); // polygon or polyline selection
+			return;
+		}
+		if (roi!=null && !(e.isAltDown()||e.isShiftDown())) {  // show ROI popup?
+			if (roi.contains(ox,oy)) {
+				if (roiPopupMenu==null)
+					addRoiPopupMenu();
+				if (IJ.isMacOSX()) IJ.wait(10);
+				roiPopupMenu.show(this, sx, sy);
+				return;					
+			}
+		}
+		PopupMenu popup = Menus.getPopupMenu();
+		if (popup!=null) {
+			add(popup);
+			if (IJ.isMacOSX()) IJ.wait(10);
+			popup.show(this, sx, sy);
+		}
+	}
+	
+	public void mouseExited(MouseEvent e) {
+		PlugInTool tool = Toolbar.getPlugInTool();
+		if (tool!=null) {
+			tool.mouseExited(imp, e);
+			if (e.isConsumed()) return;
+		}
+		ImageWindow win = imp.getWindow();
+		if (win!=null)
+			setCursor(defaultCursor);
+		IJ.showStatus("");
+		mouseExited = true;
+	}
+
+	public void mouseDragged(MouseEvent e) {
+		int x = e.getX();
+		int y = e.getY();
+		xMouse = offScreenX(x);
+		yMouse = offScreenY(y);
+		flags = e.getModifiers();
+		mousePressedX = mousePressedY = -1;
+		//IJ.log("mouseDragged: "+flags);
+		if (flags==0)  // workaround for Mac OS 9 bug
+			flags = InputEvent.BUTTON1_MASK;
+		if (Toolbar.getToolId()==Toolbar.HAND || IJ.spaceBarDown())
+			scroll(x, y);
+		else {
+			PlugInTool tool = Toolbar.getPlugInTool();
+			if (tool!=null) {
+				tool.mouseDragged(imp, e);
+				if (e.isConsumed()) return;
+			}
+			IJ.setInputEvent(e);
+			Roi roi = imp.getRoi();
+			if (roi != null)
+				roi.handleMouseDrag(x, y, flags);
+		}
+	}
+
+	protected void handleRoiMouseDown(MouseEvent e) {
+		int sx = e.getX();
+		int sy = e.getY();
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		Roi roi = imp.getRoi();	
+		int tool = Toolbar.getToolId();	
+
+		int handle = roi!=null?roi.isHandle(sx, sy):-1;
+		boolean multiPointMode = roi!=null && (roi instanceof PointRoi) && handle==-1
+			&& tool==Toolbar.POINT && Toolbar.getMultiPointMode();
+		if (multiPointMode) {
+			double oxd = roi.offScreenXD(sx);
+			double oyd = roi.offScreenYD(sy);
+			if (e.isShiftDown() && !IJ.isMacro()) {
+				FloatPolygon points = roi.getFloatPolygon();
+				if (points.npoints>0) {
+					double x0 = points.xpoints[0];
+					double y0 = points.ypoints[0];
+					double slope = Math.abs((oxd-x0)/(oyd-y0));
+					if (slope>=1.0)
+						oyd = points.ypoints[0];
+					else
+						oxd = points.xpoints[0];
+				}
+			}
+			((PointRoi)roi).addUserPoint(imp, oxd, oyd);
+			imp.setRoi(roi);
+			return;
+		}
+				
+		if (roi!=null && (roi instanceof PointRoi)) {
+			int npoints = ((PolygonRoi)roi).getNCoordinates();
+			if (npoints>1 && handle==-1 && !IJ.altKeyDown() && !(tool==Toolbar.POINT && !Toolbar.getMultiPointMode()&&IJ.shiftKeyDown())) {
+				String msg =  "Type shift-a (Edit>Selection>Select None) to delete\npoints. Use multi-point tool to add points.";
+				GenericDialog gd=new GenericDialog("Point Selection");
+				gd.addMessage(msg);
+				gd.addHelp(PointToolOptions.help);
+				gd.hideCancelButton();
+				gd.showDialog();
+				return;
+			}
+		}
+		
+		setRoiModState(e, roi, handle);
+		if (roi!=null) {
+			if (handle>=0) {
+				roi.mouseDownInHandle(handle, sx, sy);
+				return;
+			}
+			Rectangle r = roi.getBounds();
+			int type = roi.getType();
+			if (type==Roi.RECTANGLE && r.width==imp.getWidth() && r.height==imp.getHeight()
+			&& roi.getPasteMode()==Roi.NOT_PASTING && !(roi instanceof ImageRoi)) {
+				imp.deleteRoi();
+				return;
+			}
+			if (roi.contains(ox, oy)) {
+				if (roi.modState==Roi.NO_MODS)
+					roi.handleMouseDown(sx, sy);
+				else {
+					imp.deleteRoi();
+					imp.createNewRoi(sx,sy);
+				}
+				return;
+			}			
+			boolean segmentedTool = tool==Toolbar.POLYGON || tool==Toolbar.POLYLINE || tool==Toolbar.ANGLE;
+			if (segmentedTool && (type==Roi.POLYGON || type==Roi.POLYLINE || type==Roi.ANGLE)
+			&& roi.getState()==roi.CONSTRUCTING)
+				return;
+			if (segmentedTool&& !(IJ.shiftKeyDown()||IJ.altKeyDown())) {
+				imp.deleteRoi();
+				return;
+			}
+		}
+		imp.createNewRoi(sx,sy);
+	}
+	
+	void setRoiModState(MouseEvent e, Roi roi, int handle) {
+		if (roi==null || (handle>=0 && roi.modState==Roi.NO_MODS))
+			return;
+		if (roi.state==Roi.CONSTRUCTING)
+			return;
+		int tool = Toolbar.getToolId();
+		if (tool>Toolbar.FREEROI && tool!=Toolbar.WAND && tool!=Toolbar.POINT)
+			{roi.modState = Roi.NO_MODS; return;}
+		if (e.isShiftDown())
+			roi.modState = Roi.ADD_TO_ROI;
+		else if (e.isAltDown())
+			roi.modState = Roi.SUBTRACT_FROM_ROI;
+		else
+			roi.modState = Roi.NO_MODS;
+		//IJ.log("setRoiModState: "+roi.modState+" "+ roi.state);
+	}
+	
+	/** Disable/enable popup menu. */
+	public void disablePopupMenu(boolean status) {
+		disablePopupMenu = status;
+	}
+	
+	public void setShowAllList(Overlay showAllList) {
+		this.showAllOverlay = showAllList;
+		labelRects = null;
+	}
+	
+	public Overlay getShowAllList() {
+		return showAllOverlay;
+	}
+
+	/** Obsolete */
+	public void setShowAllROIs(boolean showAllROIs) {
+		RoiManager rm = RoiManager.getInstance();
+		if (rm!=null)
+			rm.runCommand(showAllROIs?"show all":"show none");
+	}
+
+	/** Obsolete */
+	public boolean getShowAllROIs() {
+		return getShowAllList()!=null;
+	}
+	
+	/** Obsolete */
+	public static Color getShowAllColor() {
+		if (showAllColor!=null && showAllColor.getRGB()==0xff80ffff)
+			showAllColor = Color.cyan;
+		return showAllColor;
+	}
+
+	/** Obsolete */
+	public static void setShowAllColor(Color c) {
+		if (c==null) return;
+		showAllColor = c;
+		labelColor = null;
+	}
+	
+	/** Experimental */
+	public static void setCursor(Cursor cursor, int type) {
+		crosshairCursor = cursor;
+	}
+
+	/** Use ImagePlus.setOverlay(ij.gui.Overlay). */
+	public void setOverlay(Overlay overlay) {
+		imp.setOverlay(overlay);
+	}
+	
+	/** Use ImagePlus.getOverlay(). */
+	public Overlay getOverlay() {
+		return imp.getOverlay();
+	}
+
+	/**
+	* @deprecated
+	* replaced by ImagePlus.setOverlay(ij.gui.Overlay)
+	*/
+	public void setDisplayList(Vector list) {
+		if (list!=null) {
+			Overlay list2 = new Overlay();
+			list2.setVector(list);
+			imp.setOverlay(list2);
+		} else
+			imp.setOverlay(null);
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null)
+			overlay.drawLabels(overlay.size()>0&&overlay.get(0).getStrokeColor()==null);
+		else
+			customRoi = false;
+		repaint();
+	}
+
+	/**
+	* @deprecated
+	* replaced by ImagePlus.setOverlay(Shape, Color, BasicStroke)
+	*/
+	public void setDisplayList(Shape shape, Color color, BasicStroke stroke) {
+		imp.setOverlay(shape, color, stroke);
+	}
+	
+	/**
+	* @deprecated
+	* replaced by ImagePlus.setOverlay(Roi, Color, int, Color)
+	*/
+	public void setDisplayList(Roi roi, Color color) {
+		roi.setStrokeColor(color);
+		Overlay list = new Overlay();
+		list.add(roi);
+		imp.setOverlay(list);
+	}
+	
+	/**
+	* @deprecated
+	* replaced by ImagePlus.getOverlay()
+	*/
+	public Vector getDisplayList() {
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			return null;
+		Vector displayList = new Vector();
+		for (int i=0; i<overlay.size(); i++)
+			displayList.add(overlay.get(i));
+		return displayList;
+	}
+	
+	/** Allows plugins (e.g., Orthogonal_Views) to create a custom ROI using a display list. */
+	public void setCustomRoi(boolean customRoi) {
+		this.customRoi = customRoi;
+	}
+
+	public boolean getCustomRoi() {
+		return customRoi;
+	}
+	
+	/** Called by IJ.showStatus() to prevent status bar text from
+		being overwritten until the cursor moves at least 12 pixels. */
+	public void setShowCursorStatus(boolean status) {
+		showCursorStatus = status;
+		if (status==true)
+			sx2 = sy2 = -1000;
+		else {
+			sx2 = screenX(xMouse);
+			sy2 = screenY(yMouse);
+		}
+	}
+
+	public void mouseReleased(MouseEvent e) {
+
+		if (pressTimer!=null) {
+			pressTimer.cancel();
+			pressTimer = null;
+		}
+		
+		int ox = offScreenX(e.getX());
+		int oy = offScreenY(e.getY());
+		Overlay overlay = imp.getOverlay();
+		if ((overlay!=null||showAllOverlay!=null) && ox==mousePressedX && oy==mousePressedY) {
+			boolean cmdDown = IJ.isMacOSX() && e.isMetaDown();
+			Roi roi = imp.getRoi();
+			if (roi!=null && roi.getBounds().width==0)
+				roi=null;
+			if ((e.isAltDown()||e.isControlDown()||cmdDown) && roi==null) {
+				if (activateOverlayRoi(ox, oy))
+					return;
+			} else if ((System.currentTimeMillis()-mousePressedTime)>250L && !drawingTool()) { // long press
+				if (activateOverlayRoi(ox,oy))
+					return;
+			}
+
+		}
+
+		PlugInTool tool = Toolbar.getPlugInTool();
+		if (tool!=null) {
+			tool.mouseReleased(imp, e);
+			if (e.isConsumed()) return;
+		}
+		flags = e.getModifiers();
+		flags &= ~InputEvent.BUTTON1_MASK; // make sure button 1 bit is not set
+		flags &= ~InputEvent.BUTTON2_MASK; // make sure button 2 bit is not set
+		flags &= ~InputEvent.BUTTON3_MASK; // make sure button 3 bit is not set
+		Roi roi = imp.getRoi();
+		if (roi != null) {
+			Rectangle r = roi.getBounds();
+			int type = roi.getType();
+			if ((r.width==0 || r.height==0)
+			&& !(type==Roi.POLYGON||type==Roi.POLYLINE||type==Roi.ANGLE||type==Roi.LINE)
+			&& !(roi instanceof TextRoi)
+			&& roi.getState()==roi.CONSTRUCTING
+			&& type!=roi.POINT)
+				imp.deleteRoi();
+			else
+				roi.handleMouseUp(e.getX(), e.getY());
+		}
+	}
+	
+	private boolean activateOverlayRoi(int ox, int oy) {
+		int currentImage = -1;
+		int stackSize = imp.getStackSize();
+		if (stackSize>1)
+			currentImage = imp.getCurrentSlice();
+		int channel=0, slice=0, frame=0;
+		boolean hyperstack = imp.isHyperStack();
+		if (hyperstack) {
+			channel = imp.getChannel();
+			slice = imp.getSlice();
+			frame = imp.getFrame();
+		}
+		Overlay o = showAllOverlay;
+		if (o==null)
+			o = imp.getOverlay();
+		if (o==null || !o.isSelectable())
+			return false;
+		boolean roiManagerShowAllMode = o==showAllOverlay && !Prefs.showAllSliceOnly;
+		boolean labels = o.getDrawLabels();
+		int sx = screenX(ox);
+		int sy = screenY(oy);
+		for (int i=o.size()-1; i>=0; i--) {
+			Roi roi = o.get(i);
+			if (roi==null)
+				continue;
+			//IJ.log(".isAltDown: "+roi.contains(ox, oy));
+			boolean containsMousePoint = false;
+			if (roi instanceof Line) {	//grab line roi near its center
+				double grabLineWidth = 1.1 + 5./magnification;
+				containsMousePoint = (((Line)roi).getFloatPolygon(grabLineWidth)).contains(ox, oy);
+			} else
+				containsMousePoint = roi.contains(ox, oy);
+			if (containsMousePoint || (labels&&labelRects!=null&&labelRects[i]!=null&&labelRects[i].contains(sx,sy))) {
+				if (hyperstack && roi.getPosition()==0) {
+					int c = roi.getCPosition();
+					int z = roi.getZPosition();
+					int t = roi.getTPosition();
+					if (!((c==0||c==channel)&&(z==0||z==slice)&&(t==0||t==frame) || roiManagerShowAllMode))
+						continue;
+				} else {
+					int position = stackSize>1?roi.getPosition():0;
+					if (!(position==0||position==currentImage||roiManagerShowAllMode))
+						continue;
+				}
+				if (!IJ.altKeyDown() && roi.getType()==Roi.COMPOSITE
+				&& roi.getBounds().width==imp.getWidth() && roi.getBounds().height==imp.getHeight())
+					return false;
+				if (Toolbar.getToolId()==Toolbar.OVAL && Toolbar.getBrushSize()>0)
+					Toolbar.getInstance().setTool(Toolbar.RECTANGLE);
+				roi.setImage(null);
+				imp.setRoi(roi);
+				//roi.handleMouseDown(sx, sy);
+				roiManagerSelect(roi, false);
+				ResultsTable.selectRow(roi);
+				return true;
+			}
+		}
+		return false;
+	}
+		
+    public boolean roiManagerSelect(Roi roi, boolean delete) {
+		RoiManager rm=RoiManager.getInstance();
+		if (rm==null)
+			return false;
+		int index = rm.getRoiIndex(roi);
+		if (index<0)
+			return false;
+		if (delete) {
+			rm.select(imp, index);
+			rm.runCommand("delete");
+		} else
+			rm.selectAndMakeVisible(imp, index);
+		return true;
+    }
+    
+	public void mouseMoved(MouseEvent e) {
+		//if (ij==null) return;
+		int sx = e.getX();
+		int sy = e.getY();
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		flags = e.getModifiers();
+		setCursor(sx, sy, ox, oy);
+		mousePressedX = mousePressedY = -1;
+		IJ.setInputEvent(e);
+		PlugInTool tool = Toolbar.getPlugInTool();
+		if (tool!=null) {
+			tool.mouseMoved(imp, e);
+			if (e.isConsumed()) return;
+		}
+		Roi roi = imp.getRoi();
+		int type = roi!=null?roi.getType():-1;
+		if (type>0 && (type==Roi.POLYGON||type==Roi.POLYLINE||type==Roi.ANGLE||type==Roi.LINE) 
+		&& roi.getState()==roi.CONSTRUCTING)
+			roi.mouseMoved(e);
+		else {
+			if (ox<imageWidth && oy<imageHeight) {
+				ImageWindow win = imp.getWindow();
+				// Cursor must move at least 12 pixels before text
+				// displayed using IJ.showStatus() is overwritten.
+				if ((sx-sx2)*(sx-sx2)+(sy-sy2)*(sy-sy2)>144)
+					showCursorStatus =  true;
+				if (win!=null&&showCursorStatus)
+					win.mouseMoved(ox, oy);
+			} else
+				IJ.showStatus("");
+		}
+	}
+	
+	public void mouseEntered(MouseEvent e) {
+		PlugInTool tool = Toolbar.getPlugInTool();
+		if (tool!=null)
+			tool.mouseEntered(imp, e);
+	}
+
+	public void mouseClicked(MouseEvent e) {
+		PlugInTool tool = Toolbar.getPlugInTool();
+		if (tool!=null)
+			tool.mouseClicked(imp, e);
+	}
+	
+	public void setScaleToFit(boolean scaleToFit) {
+		this.scaleToFit = scaleToFit;
+	}
+
+	public boolean getScaleToFit() {
+		return scaleToFit;
+	}
+	
+	public boolean hideZoomIndicator(boolean hide) {
+		boolean hidden = this.hideZoomIndicator;
+		if (!(srcRect.width<imageWidth||srcRect.height<imageHeight))
+			return hidden;
+		this.hideZoomIndicator = hide;
+		setPaintPending(true);
+		repaint();
+		long t0 = System.currentTimeMillis();
+		while(getPaintPending() && (System.currentTimeMillis()-t0)<500L)
+			IJ.wait(10);
+		return hidden;
+	}
+	
+	public void repaintOverlay() {
+		labelRects = null;
+		repaint();
+	}
+	
+	/** Sets the context menu long click delay in milliseconds
+	 * (default is 1000). Set to 0 to disable long click triggering.
+	*/
+	 public static void setLongClickDelay(int delay) {
+		longClickDelay = delay;
+	}
+	
+	void addRoiPopupMenu() {
+		ImageJ ij = IJ.getInstance();
+		if (ij==null)
+			return;
+		roiPopupMenu = new PopupMenu();
+		GUI.scalePopupMenu(roiPopupMenu);
+		addPopupItem("ROI Properties... ", "Properties... ", roiPopupMenu, ij);
+		addPopupItem("Roi Defaults...", null, roiPopupMenu, ij);
+		addPopupItem("Add to Overlay", "Add Selection...", roiPopupMenu, ij);
+		addPopupItem("Add to ROI Manager", "Add to Manager", roiPopupMenu, ij);				
+		addPopupItem("Duplicate...", null, roiPopupMenu, ij);	
+		addPopupItem("Fit Spline", null, roiPopupMenu, ij);	
+		addPopupItem("Create Mask", null, roiPopupMenu, ij);	
+		addPopupItem("Measure", null, roiPopupMenu, ij);							
+		add(roiPopupMenu);
+	}
+
+	private void addPopupItem(String label, String command, PopupMenu pm, ImageJ ij) {
+		MenuItem mi=new MenuItem(label);
+		if (command!=null)
+			mi.setActionCommand(command);
+		mi.addActionListener(ij);
+		pm.add(mi);
+	}
+
+}
diff --git a/src/ij/gui/ImageLayout.java b/src/ij/gui/ImageLayout.java
new file mode 100644
index 0000000..7888616
--- /dev/null
+++ b/src/ij/gui/ImageLayout.java
@@ -0,0 +1,113 @@
+package ij.gui;
+import java.awt.*;
+import ij.*;
+
+/** This is a custom layout manager that supports resizing of zoomed
+images. It's based on FlowLayout, but with vertical and centered flow. */
+public class ImageLayout implements LayoutManager {
+
+    int hgap = ImageWindow.HGAP;
+    int vgap = ImageWindow.VGAP;
+	ImageCanvas ic;
+	boolean ignoreNonImageWidths;
+
+    /** Creates a new ImageLayout with center alignment. */
+    public ImageLayout(ImageCanvas ic) {
+    	this.ic = ic;
+    }
+
+    /** Not used by this class. */
+    public void addLayoutComponent(String name, Component comp) {
+    }
+
+    /** Not used by this class. */
+    public void removeLayoutComponent(Component comp) {
+    }
+
+    /** Returns the preferred dimensions for this layout. */
+    public Dimension preferredLayoutSize(Container target) {
+		Dimension dim = new Dimension(0,0);
+		int nmembers = target.getComponentCount();
+		for (int i=0; i<nmembers; i++) {
+		    Component m = target.getComponent(i);
+			Dimension d = m.getPreferredSize();
+			if (i==0 || !ignoreNonImageWidths)
+    			dim.width = Math.max(dim.width, d.width);
+			if (i>0) dim.height += vgap;
+			dim.height += d.height;
+		}
+		Insets insets = target.getInsets();
+		dim.width += insets.left + insets.right + hgap*2;
+		dim.height += insets.top + insets.bottom + vgap*2;
+		return dim;
+    }
+
+    /** Returns the minimum dimensions for this layout. */
+    public Dimension minimumLayoutSize(Container target) {
+		return preferredLayoutSize(target);
+    }
+
+    /** Determines whether to ignore the width of non-image components when calculating
+     *  the preferred width (default false, i.e. the maximum of the widths of all components is used).
+     *  When true, components that do not fit the window will be truncated at the right.
+     *  The width of the 0th component (the ImageCanvas) is always taken into account. */
+	public void ignoreNonImageWidths(boolean ignoreNonImageWidths) {
+		this.ignoreNonImageWidths = ignoreNonImageWidths;
+	}
+
+    /** Centers the elements in the specified column, if there is any slack.*/
+    private void moveComponents(Container target, int x, int y, int width, int height, int nmembers) {
+    	int x2 = 0;
+	    y += height / 2;
+		for (int i=0; i<nmembers; i++) {
+		    Component m = target.getComponent(i);
+		    Dimension d = m.getSize();
+		    if (i==0 || d.height>60)
+		    	x2 = x + (width - d.width)/2;
+			m.setLocation(x2, y);
+			y += vgap + d.height;
+		}
+    }
+
+    /** Lays out the container and calls ImageCanvas.resizeCanvas()
+		to adjust the image canvas size as needed. */
+    public void layoutContainer(Container target) {
+		Insets insets = target.getInsets();
+		int nmembers = target.getComponentCount();
+		Dimension d;
+		int extraHeight = 0;
+		for (int i=1; i<nmembers; i++) {
+			Component m = target.getComponent(i);
+			d = m.getPreferredSize();
+			extraHeight += d.height+vgap;
+		}
+		d = target.getSize();
+		int preferredImageWidth = d.width - (insets.left + insets.right + hgap*2);
+		int preferredImageHeight = d.height - (insets.top + insets.bottom + vgap*2 + extraHeight);
+		ic.resizeCanvas(preferredImageWidth, preferredImageHeight);
+		int maxwidth = d.width - (insets.left + insets.right + hgap*2);
+		int maxheight = d.height - (insets.top + insets.bottom + vgap*2);
+		Dimension psize = preferredLayoutSize(target);
+		int x = insets.left + hgap + (d.width - psize.width)/2;
+		int y = 0;
+		int colw = 0;
+		
+		for (int i=0; i<nmembers; i++) {
+			Component m = target.getComponent(i);
+			d = m.getPreferredSize();
+			if ((m instanceof ScrollbarWithLabel) || (m instanceof Scrollbar)) {
+				int scrollbarWidth = target.getComponent(0).getPreferredSize().width;
+				Dimension minSize = m.getMinimumSize();
+				if (scrollbarWidth<minSize.width) scrollbarWidth = minSize.width;
+				m.setSize(scrollbarWidth, d.height);
+			} else
+				m.setSize(d.width, d.height);
+			if (y > 0) y += vgap;
+			y += d.height;
+			if (i==0 || !ignoreNonImageWidths)
+				colw = Math.max(colw, d.width);
+		}
+		moveComponents(target, x, insets.top + vgap, colw, maxheight - y, nmembers);
+    }
+    
+}
diff --git a/src/ij/gui/ImagePanel.java b/src/ij/gui/ImagePanel.java
new file mode 100644
index 0000000..628e575
--- /dev/null
+++ b/src/ij/gui/ImagePanel.java
@@ -0,0 +1,28 @@
+package ij.gui;
+import java.awt.*;
+import ij.*;
+
+/** This class is used by GenericDialog to add images to dialogs. */
+public class ImagePanel extends Panel {
+	private ImagePlus img;
+	private int width, height;
+	 
+	ImagePanel(ImagePlus img) {
+		this.img = img;
+		width = img.getWidth();
+		height = img.getHeight();
+	}
+
+	public Dimension getPreferredSize() {
+		return new Dimension(width, height);
+	}
+
+	public Dimension getMinimumSize() {
+		return new Dimension(width, height);
+	}
+
+	public void paint(Graphics g) {
+		g.drawImage(img.getProcessor().createImage(), 0, 0, null);
+	}
+
+}
diff --git a/src/ij/gui/ImageRoi.java b/src/ij/gui/ImageRoi.java
new file mode 100644
index 0000000..024366d
--- /dev/null
+++ b/src/ij/gui/ImageRoi.java
@@ -0,0 +1,150 @@
+package ij.gui;
+import ij.ImagePlus;
+import ij.process.*;
+import ij.io.FileSaver;
+import java.awt.*;
+import java.awt.image.*;
+
+/** An ImageRoi is an Roi that overlays an image. 
+* @see ij.ImagePlus#setOverlay(ij.gui.Overlay)
+*/
+public class ImageRoi extends Roi {
+	private Image img;
+	private Composite composite;
+	private double opacity = 1.0;
+	private double angle = 0.0;
+	private boolean zeroTransparent;
+	private ImageProcessor ip;
+
+	/** Creates a new ImageRoi from a BufferedImage.*/
+	public ImageRoi(int x, int y, BufferedImage bi) {
+		super(x, y, bi.getWidth(), bi.getHeight());
+		img = bi;
+		setStrokeColor(Color.black);
+	}
+
+	/** Creates a new ImageRoi from a ImageProcessor.*/
+	public ImageRoi(int x, int y, ImageProcessor ip) {
+		super(x, y, ip.getWidth(), ip.getHeight());
+		img = ip.createImage();
+		this.ip = ip;
+		setStrokeColor(Color.black);
+	}
+		
+	public void draw(Graphics g) {
+		Graphics2D g2d = (Graphics2D)g;						
+		double mag = getMagnification();
+		int sx2 = screenX(x+width);
+		int sy2 = screenY(y+height);
+		Composite saveComposite = null;
+		if (composite!=null) {
+			saveComposite = g2d.getComposite();
+			g2d.setComposite(composite);
+		}
+		Image img2 = img;
+		if (angle!=0.0) {
+			ImageProcessor ip = new ColorProcessor(img);
+			ip.setInterpolate(true);
+			ip.setBackgroundValue(0.0);
+			ip.rotate(angle);
+			if (zeroTransparent)
+				ip = makeZeroTransparent(ip, true);
+			img2 = ip.createImage();
+		}
+		g.drawImage(img2, screenX(x), screenY(y), sx2, sy2, 0, 0, img.getWidth(null), img.getHeight(null), null);
+		if (composite!=null) g2d.setComposite(saveComposite);
+		if (isActiveOverlayRoi() && !overlay)
+			super.draw(g);
+ 	}
+ 	 	
+	/** Sets the composite mode. */
+	public void setComposite(Composite composite) {
+		this.composite = composite;
+	}
+	
+	/** Sets the composite mode using the specified opacity (alpha), in the 
+	     range 0.0-1.0, where 0.0 is fully transparent and 1.0 is fully opaque. */
+	public void setOpacity(double opacity) {
+		if (opacity<0.0) opacity = 0.0;
+		if (opacity>1.0) opacity = 1.0;
+		this.opacity = opacity;
+		if (opacity!=1.0)
+			composite = AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float)opacity);
+		else
+			composite = null;
+	}
+	
+	/** Returns a serialized version of the image. */
+	public byte[] getSerializedImage() {
+		ImagePlus imp = new ImagePlus("",img);
+		return new FileSaver(imp).serialize();
+	}
+
+	/** Returns the current opacity. */
+	public double getOpacity() {
+		return opacity;
+	}
+
+	public void rotate(double angle) {
+		this.angle += angle;
+	}
+
+	public void setAngle(double angle) {
+		this.angle = angle;
+	}
+
+	public void setZeroTransparent(boolean zeroTransparent) {
+		if (this.zeroTransparent!=zeroTransparent) {
+			ip = makeZeroTransparent(new ColorProcessor(img), zeroTransparent);
+			img = ip.createImage();
+		}
+		this.zeroTransparent = zeroTransparent;
+	}
+	
+	public boolean getZeroTransparent() {
+		return zeroTransparent;
+	}
+
+	private ImageProcessor makeZeroTransparent(ImageProcessor ip, boolean transparent) {
+		if (transparent) {
+			ip.setColorModel(new DirectColorModel(32,0x00ff0000,0x0000ff00,0x000000ff,0xff000000));
+			for (int x=0; x<width; x++) {
+				for (int y=0; y<height; y++) {
+					double v = ip.getPixelValue(x, y);
+					if (v>1)
+						ip.set(x, y, ip.get(x,y)|0xff000000); // set alpha bits
+					else
+						ip.set(x, y, ip.get(x,y)&0xffffff); // clear alpha bits
+				}
+			}
+		}
+		return ip;
+	}
+
+	public synchronized Object clone() {
+		ImageRoi roi2 = (ImageRoi)super.clone();
+		ImagePlus imp = new ImagePlus("", img);
+		roi2.setProcessor(imp.getProcessor());
+		roi2.setOpacity(getOpacity());
+		roi2.zeroTransparent = !zeroTransparent;
+		roi2.setZeroTransparent(zeroTransparent);
+		return roi2;
+	}
+	
+	public ImageProcessor getProcessor() {
+		if (ip!=null)
+			return ip;
+		else {
+			ip = new ColorProcessor(img);
+			return ip;
+		}
+	}
+
+	public void setProcessor(ImageProcessor ip) {
+		img = ip.createImage();
+		this.ip = ip;
+		width = ip.getWidth();
+		height = ip.getHeight();
+	}
+
+}
\ No newline at end of file
diff --git a/src/ij/gui/ImageWindow.java b/src/ij/gui/ImageWindow.java
new file mode 100644
index 0000000..bb1942a
--- /dev/null
+++ b/src/ij/gui/ImageWindow.java
@@ -0,0 +1,763 @@
+package ij.gui;
+import java.awt.*;
+import java.awt.image.*;
+import java.util.Properties;
+import java.awt.event.*;
+import ij.*;
+import ij.process.*;
+import ij.io.*;
+import ij.measure.*;
+import ij.plugin.frame.*;
+import ij.plugin.PointToolOptions;
+import ij.macro.Interpreter;
+import ij.util.*;
+
+/** A frame for displaying images. */
+public class ImageWindow extends Frame implements FocusListener, WindowListener, WindowStateListener, MouseWheelListener {
+
+	public static final int MIN_WIDTH = 128;
+	public static final int MIN_HEIGHT = 32;
+	public static final int HGAP = 5;
+	public static final int VGAP = 5;
+	public static final String LOC_KEY = "image.loc";
+	
+	protected ImagePlus imp;
+	protected ImageJ ij;
+	protected ImageCanvas ic;
+	private double initialMagnification = 1;
+	private int newWidth, newHeight;
+	protected boolean closed;
+	private boolean newCanvas;
+	private boolean unzoomWhenMinimizing = true;
+	Rectangle maxWindowBounds; // largest possible window on this screen
+	Rectangle maxBounds; // Size of this window after it is maximized
+	long setMaxBoundsTime;
+	private int sliderHeight;
+
+	private static final int XINC = 12;
+	private static final int YINC = 16;
+	private final double SCALE = Prefs.getGuiScale();
+	private int TEXT_GAP = 11;
+	private static int xbase = -1;
+	private static int ybase;
+	private static int xloc;
+	private static int yloc;
+	private static int count;
+	private static boolean centerOnScreen;
+	private static Point nextLocation;
+	public static long setMenuBarTime;	
+	private int textGap = centerOnScreen?0:TEXT_GAP;
+	private Point initialLoc;
+	private int screenHeight, screenWidth;
+
+	
+	/** This variable is set false if the user presses the escape key or closes the window. */
+	public boolean running;
+	
+	/** This variable is set false if the user clicks in this
+		window, presses the escape key, or closes the window. */
+	public boolean running2;
+	
+	public ImageWindow(String title) {
+		super(title);
+	}
+
+	public ImageWindow(ImagePlus imp) {
+		this(imp, null);
+	}
+
+	public ImageWindow(ImagePlus imp, ImageCanvas ic) {
+		super(imp.getTitle());
+		if (SCALE>1.0) {
+			TEXT_GAP = (int)(TEXT_GAP*SCALE);
+			textGap = centerOnScreen?0:TEXT_GAP;
+		}
+		if (Prefs.blackCanvas && getClass().getName().equals("ij.gui.ImageWindow")) {
+			setForeground(Color.white);
+			setBackground(Color.black);
+		} else {
+			setForeground(Color.black);
+		if (IJ.isLinux())
+			setBackground(ImageJ.backgroundColor);
+		else
+			setBackground(Color.white);
+		}
+		boolean openAsHyperStack = imp.getOpenAsHyperStack();
+		ij = IJ.getInstance();
+		this.imp = imp;
+		if (ic==null) {
+			ic = (this instanceof PlotWindow) ? new PlotCanvas(imp) : new ImageCanvas(imp);
+			newCanvas=true;
+		}
+		this.ic = ic;
+		ImageWindow previousWindow = imp.getWindow();
+		setLayout(new ImageLayout(ic));
+		add(ic);
+ 		addFocusListener(this);
+ 		addWindowListener(this);
+ 		addWindowStateListener(this);
+ 		addKeyListener(ij);
+		setFocusTraversalKeysEnabled(false);
+		if (!(this instanceof StackWindow))
+			addMouseWheelListener(this);
+		setResizable(true);
+		if (!(this instanceof HistogramWindow&&IJ.isMacro()&&Interpreter.isBatchMode())) {
+			WindowManager.addWindow(this);
+			imp.setWindow(this);
+		}
+		if (previousWindow!=null) {
+			if (newCanvas)
+				setLocationAndSize(false);
+			else
+				ic.update(previousWindow.getCanvas());
+			Point loc = previousWindow.getLocation();
+			setLocation(loc.x, loc.y);
+			if (!(this instanceof StackWindow || this instanceof PlotWindow)) { //layout now unless components will be added later
+				pack();
+				if (IJ.isMacro())
+					imp.setDeactivated(); //prepare for waitTillActivated (imp may have been activated before if it gets a new Window now)
+				show();
+			}
+			if (ic.getMagnification()!=0.0)
+				imp.setTitle(imp.getTitle());
+			boolean unlocked = imp.lockSilently();
+			boolean changes = imp.changes;
+			imp.changes = false;
+			previousWindow.close();
+			imp.changes = changes;
+			if (unlocked)
+				imp.unlock();
+			if (this.imp!=null)
+				this.imp.setOpenAsHyperStack(openAsHyperStack);
+			WindowManager.setCurrentWindow(this);
+		} else {
+			setLocationAndSize(false);
+			if (ij!=null && !IJ.isMacintosh()) {
+				Image img = ij.getIconImage();
+				if (img!=null) try {
+					setIconImage(img);
+				} catch (Exception e) {}
+			}
+			if (nextLocation!=null)
+				setLocation(nextLocation);
+			else if (centerOnScreen)
+				GUI.center(this);
+			nextLocation = null;
+			centerOnScreen = false;
+			if (Interpreter.isBatchMode() || (IJ.getInstance()==null&&this instanceof HistogramWindow)) {
+				WindowManager.setTempCurrentImage(imp);
+				Interpreter.addBatchModeImage(imp);
+			} else {
+				if (IJ.isMacro())
+					imp.setDeactivated(); //prepare for waitTillActivated (imp may have been activated previously and gets a new Window now)
+				show();
+			}
+		}
+	}
+
+	private void setLocationAndSize(boolean updating) {
+		if (imp==null)
+			return;
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		
+		// load prefernces file location
+		Point loc = Prefs.getLocation(LOC_KEY);
+		Rectangle bounds = null;
+		if (loc!=null) {
+			bounds = GUI.getMaxWindowBounds(loc);
+			if (bounds!=null && (loc.x>bounds.x+bounds.width/3||loc.y>bounds.y+bounds.height/3)
+			&& (loc.x+width>bounds.x+bounds.width||loc.y+height>bounds.y+bounds.height)) {
+				loc = null;
+				bounds = null;
+			}
+		}		
+		// if loc not valid, use screen bounds of visible window (this) or of main window (ij) if not visible yet (updating == false)
+		Rectangle maxWindow = bounds!=null?bounds:GUI.getMaxWindowBounds(updating?this: ij);  
+
+		if (WindowManager.getWindowCount()<=1)
+			xbase = -1;
+		if (width>maxWindow.width/2 && xbase>maxWindow.x+5+XINC*6)
+			xbase = -1;
+		if (xbase==-1) {
+			count = 0;
+			if (loc!=null) {
+				xbase = loc.x;
+				ybase = loc.y;
+			} else if (ij!=null) {
+				Rectangle ijBounds = ij.getBounds();
+				if (ijBounds.y-maxWindow.x<maxWindow.height/8) {
+					xbase = ijBounds.x;
+					if (xbase+width>maxWindow.x+maxWindow.width) {
+						xbase = maxWindow.x+maxWindow.width - width - 10;
+						if (xbase<maxWindow.x)
+							xbase = maxWindow.x + 5;;
+					}
+					ybase = ijBounds.y + ijBounds.height + 5;
+				} else {
+					xbase = maxWindow.x + (maxWindow.width - width) / 2;
+					ybase = maxWindow.y + (maxWindow.height - height) / 4;
+				}
+			} else {
+				xbase = maxWindow.x + (maxWindow.width - width) / 2;
+				ybase = maxWindow.y + (maxWindow.height - height) / 4;
+			}
+			xbase = Math.max(xbase, maxWindow.x);
+			ybase = Math.max(ybase, maxWindow.y);
+			if (IJ.debugMode) IJ.log("ImageWindow.xbase: "+xbase);
+			xloc = xbase;
+			yloc = ybase;
+		}
+		int x = xloc;
+		int y = yloc;
+		xloc += XINC;
+		yloc += YINC;
+		count++;
+		if (count%6==0) {
+			xloc = xbase;
+			yloc = ybase;
+		}
+
+		screenHeight = maxWindow.y+maxWindow.height-sliderHeight;
+		screenWidth = maxWindow.x+maxWindow.width;
+		double mag = 1;
+		if (!(this instanceof PlotWindow)) { // unless a plot (always at 100%), zoom out to show all of image
+			while (xbase+width*mag>screenWidth || ybase+height*mag>=screenHeight) {
+				double mag2 = ImageCanvas.getLowerZoomLevel(mag);
+				if (mag2==mag) break;
+				mag = mag2;
+			}
+		}
+		
+		if (mag<1.0) {
+			initialMagnification = mag;
+			ic.setSize((int)(width*mag), (int)(height*mag));
+		}
+		ic.setMagnification(mag);
+		if (y+height*mag>screenHeight)
+			y = ybase;
+		if (Prefs.open100Percent && ic.getMagnification()<1.0) {
+			while(ic.getMagnification()<1.0)
+				ic.zoomIn(0, 0);
+			setSize(Math.min(width, screenWidth-x), Math.min(height, screenHeight-y));
+			validate();
+		} else 
+			pack();
+		if (!updating) {
+			setLocation(x, y);
+			initialLoc = new Point(x,y);
+		}
+	}
+
+	Rectangle getMaxWindow(int xloc, int yloc) {
+		return GUI.getMaxWindowBounds(new Point(xloc, yloc));
+	}
+
+	public double getInitialMagnification() {
+		return initialMagnification;
+	}
+
+	/** Override Container getInsets() to make room for some text above the image. */
+	public Insets getInsets() {
+		Insets insets = super.getInsets();
+		if (imp==null)
+			return insets;
+		double mag = ic.getMagnification();
+		int extraWidth = (int)((MIN_WIDTH - imp.getWidth()*mag)/2.0);
+		if (extraWidth<0) extraWidth = 0;
+		int extraHeight = (int)((MIN_HEIGHT - imp.getHeight()*mag)/2.0);
+		if (extraHeight<0) extraHeight = 0;
+		insets = new Insets(insets.top+textGap+extraHeight, insets.left+extraWidth, insets.bottom+extraHeight, insets.right+extraWidth);
+		return insets;
+	}
+
+	/** Draws the subtitle. */
+	public void drawInfo(Graphics g) {
+		if (imp==null)
+			return;
+		if (textGap!=0) {
+			Insets insets = super.getInsets();
+			Color savec = null;
+			if (imp.isComposite()) {
+				CompositeImage ci = (CompositeImage)imp;
+				if (ci.getMode()==IJ.COMPOSITE) {
+					savec = g.getColor();
+					Color c = ci.getChannelColor();
+					if (Color.green.equals(c))
+						c = new Color(0,180,0);
+					g.setColor(c);
+				}
+			}
+			Java2.setAntialiasedText(g, true);			
+			if (SCALE>1.0) {
+				Font font = new Font("SansSerif", Font.PLAIN, (int)(12*SCALE));
+				g.setFont(font);
+			}
+			g.drawString(createSubtitle(), insets.left+5, insets.top+TEXT_GAP);
+			if (savec!=null)
+				g.setColor(savec);
+		}
+	}
+
+	/** Creates the subtitle. */
+	public String createSubtitle() {
+		String s="";
+		if (imp==null)
+			return s;
+		int stackSize = imp.getStackSize();
+		if (stackSize>1) {
+			ImageStack stack = imp.getStack();
+			int currentSlice = imp.getCurrentSlice();
+			s += currentSlice+"/"+stackSize;
+			String label = stack.getShortSliceLabel(currentSlice);
+			if (label!=null && label.length()>0) {
+				if (imp.isHyperStack()) label = label.replace(';', ' ');
+				s += " (" + label + ")";
+			}
+			if ((this instanceof StackWindow) && running2) {
+				return s;
+			}
+			s += "; ";
+		} else {
+			String label = imp.getProp("Slice_Label");
+			if (label==null && imp.isStack())
+				label = imp.getStack().getSliceLabel(1);
+			if (label!=null && label.length()>0) {
+				int newline = label.indexOf('\n');
+				if (newline>0)
+					label = label.substring(0, newline);
+				int len = label.length();
+				if (len>4 && label.charAt(len-4)=='.' && !Character.isDigit(label.charAt(len-1)))
+					label = label.substring(0,len-4);
+				if (label.length()>60)
+					label = label.substring(0, 60)+"...";
+				s = "\""+label + "\"; ";
+			}
+		}
+		int type = imp.getType();
+		Calibration cal = imp.getCalibration();
+		if (cal.scaled()) {
+			boolean unitsMatch = cal.getXUnit().equals(cal.getYUnit());
+			double cwidth = imp.getWidth()*cal.pixelWidth;
+			double cheight = imp.getHeight()*cal.pixelHeight;
+			int digits = Tools.getDecimalPlaces(cwidth, cheight);
+			if (digits>2) digits=2;
+			if (unitsMatch) {
+				s += IJ.d2s(cwidth,digits) + "x" + IJ.d2s(cheight,digits)
+					+ " " + cal.getUnits() + " (" + imp.getWidth() + "x" + imp.getHeight() + "); ";
+			} else {
+				s += d2s(cwidth) + " " + cal.getXUnit() + " x "
+					+ d2s(cheight) + " " + cal.getYUnit()
+					+ " (" + imp.getWidth() + "x" + imp.getHeight() + "); ";
+			}
+		} else
+			s += imp.getWidth() + "x" + imp.getHeight() + " pixels; ";
+		switch (type) {
+			case ImagePlus.GRAY8:
+			case ImagePlus.COLOR_256:
+				s += "8-bit";
+				break;
+			case ImagePlus.GRAY16:
+				s += "16-bit";
+				break;
+			case ImagePlus.GRAY32:
+				s += "32-bit";
+				break;
+			case ImagePlus.COLOR_RGB:
+				s += imp.isRGB() ? "RGB" :  "32-bit (int)";
+				break;
+		}
+		if (imp.isInvertedLut())
+			s += " (inverting LUT)";
+	 	return s+"; "+getImageSize(imp);
+	}
+	
+	public static String getImageSize(ImagePlus imp) {
+		if (imp==null)
+			return null;
+		double size = imp.getSizeInBytes()/1024.0;
+   		String s2=null, s3=null;
+		if (size<1024.0)
+			{s2=IJ.d2s(size,0); s3="K";}
+		else if (size<10000.0)
+	 		{s2=IJ.d2s(size/1024.0,1); s3="MB";}
+		else if (size<1048576.0)
+			{s2=IJ.d2s(Math.round(size/1024.0),0); s3="MB";}
+	   	else
+			{s2=IJ.d2s(size/1048576.0,1); s3="GB";}
+		if (s2.endsWith(".0")) s2 = s2.substring(0, s2.length()-2);
+		return s2+s3;
+	}
+    
+    private String d2s(double n) {
+		int digits = Tools.getDecimalPlaces(n);
+		if (digits>2) digits=2;
+		return IJ.d2s(n,digits);
+    }
+
+    public void paint(Graphics g) {
+		drawInfo(g);
+		Rectangle r = ic.getBounds();
+		int extraWidth = MIN_WIDTH - r.width;
+		int extraHeight = MIN_HEIGHT - r.height;
+		if (extraWidth<=0 && extraHeight<=0 && !Prefs.noBorder && !IJ.isLinux())
+			g.drawRect(r.x-1, r.y-1, r.width+1, r.height+1);
+    }
+    
+	/** Removes this window from the window list and disposes of it.
+		Returns false if the user cancels the "save changes" dialog. */
+	public boolean close() {
+		boolean isRunning = running || running2;
+		running = running2 = false;
+		if (imp==null) return true;
+		boolean virtual = imp.getStackSize()>1 && imp.getStack().isVirtual();
+		if (isRunning) IJ.wait(500);
+		if (imp==null) return true;
+		boolean changes = imp.changes;
+		Roi roi = imp.getRoi();
+		if (roi!=null && (roi instanceof PointRoi) && ((PointRoi)roi).promptBeforeDeleting())
+			changes = true;
+		if (ij==null || ij.quittingViaMacro() || IJ.getApplet()!=null || Interpreter.isBatchMode() || IJ.macroRunning() || virtual)
+			changes = false;
+		if (changes) {
+			String msg;
+			String name = imp.getTitle();
+			if (name.length()>22)
+				msg = "Save changes to\n" + "\"" + name + "\"?";
+			else
+				msg = "Save changes to \"" + name + "\"?";
+			if (imp.isLocked())
+				msg += "\nWARNING: This image is locked.\nProbably, processing is unfinished (slow or still previewing).";
+			toFront();
+			YesNoCancelDialog d = new YesNoCancelDialog(this, "ImageJ", msg);
+			if (d.cancelPressed())
+				return false;
+			else if (d.yesPressed()) {
+				FileSaver fs = new FileSaver(imp);
+				if (!fs.save()) return false;
+			}
+		}
+		closed = true;
+		if (WindowManager.getWindowCount()==0) {
+			xloc = 0;
+			yloc = 0;
+		}
+		WindowManager.removeWindow(this);
+		if (ij!=null && ij.quitting())  // this may help avoid thread deadlocks
+			return true;
+		Rectangle bounds = getBounds();
+		if (initialLoc!=null && !bounds.equals(initialLoc) && !IJ.isMacro()
+		&& bounds.y<screenHeight/3 && (bounds.y+bounds.height)<=screenHeight
+		&& (bounds.x+bounds.width)<=screenWidth) {
+			Prefs.saveLocation(LOC_KEY, new Point(bounds.x,bounds.y));
+			xbase = -1;
+		}
+		dispose();
+		if (imp!=null)
+			imp.flush();
+		imp = null;
+		return true;
+	}
+	
+	public ImagePlus getImagePlus() {
+		return imp;
+	}
+
+	public void setImage(ImagePlus imp2) {
+		ImageCanvas ic = getCanvas();
+		if (ic==null || imp2==null)
+			return;
+		imp = imp2;
+		imp.setWindow(this);
+		ic.updateImage(imp);
+		ic.setImageUpdated();
+		ic.repaint();
+		repaint();
+	}
+	
+	public void updateImage(ImagePlus imp) {
+        if (imp!=this.imp)
+            throw new IllegalArgumentException("imp!=this.imp");
+		this.imp = imp;
+        ic.updateImage(imp);
+        setLocationAndSize(true);
+        if (this instanceof StackWindow) {
+        	StackWindow sw = (StackWindow)this;
+        	int stackSize = imp.getStackSize();
+        	int nScrollbars = sw.getNScrollbars();
+        	if (stackSize==1 && nScrollbars>0)
+        		sw.removeScrollbars();
+        	else if (stackSize>1 && nScrollbars==0)
+        		sw.addScrollbars(imp);
+        }
+        pack();
+		repaint();
+		maxBounds = getMaximumBounds();
+		setMaximizedBounds(maxBounds);
+		setMaxBoundsTime = System.currentTimeMillis();
+	}
+
+	public ImageCanvas getCanvas() {
+		return ic;
+	}
+	
+
+	static ImagePlus getClipboard() {
+		return ImagePlus.getClipboard();
+	}
+	
+	public Rectangle getMaximumBounds() {
+		Rectangle maxWindow = GUI.getMaxWindowBounds(this);
+		if (imp==null)
+			return maxWindow;
+		double width = imp.getWidth();
+		double height = imp.getHeight();
+		double iAspectRatio = width/height;
+		maxWindowBounds = maxWindow;
+		if (iAspectRatio/((double)maxWindow.width/maxWindow.height)>0.75) {
+			maxWindow.y += 22;  // uncover ImageJ menu bar
+			maxWindow.height -= 22;
+		}
+		Dimension extraSize = getExtraSize();
+		double maxWidth = maxWindow.width-extraSize.width;
+		double maxHeight = maxWindow.height-extraSize.height;
+		double mAspectRatio = maxWidth/maxHeight;
+		int wWidth, wHeight;
+		double mag;
+		if (iAspectRatio>=mAspectRatio) {
+			mag = maxWidth/width;
+			wWidth = maxWindow.width;
+			wHeight = (int)(height*mag+extraSize.height);
+		} else {
+			mag = maxHeight/height;
+			wHeight = maxWindow.height;
+			wWidth = (int)(width*mag+extraSize.width);
+		}
+		int xloc = (int)(maxWidth-wWidth)/2;
+		if (xloc<maxWindow.x) xloc = maxWindow.x;
+		wWidth = Math.min(wWidth, maxWindow.x-xloc+maxWindow.width);
+		wHeight = Math.min(wHeight, maxWindow.height);
+		return new Rectangle(xloc, maxWindow.y, wWidth, wHeight);
+	}
+	
+	Dimension getExtraSize() {
+		Insets insets = getInsets();
+		int extraWidth = insets.left+insets.right + 10;
+		int extraHeight = insets.top+insets.bottom + 10;
+		if (extraHeight==20) extraHeight = 42;
+		int members = getComponentCount();
+		for (int i=1; i<members; i++) {
+		    Component m = getComponent(i);
+		    Dimension d = m.getPreferredSize();
+			extraHeight += d.height + 5;
+			if (IJ.debugMode) IJ.log(i+"  "+d.height+" "+extraHeight);
+		}
+		return new Dimension(extraWidth, extraHeight);
+	}
+
+	public Component add(Component comp) {
+		comp = super.add(comp);
+		maxBounds = getMaximumBounds();
+		setMaximizedBounds(maxBounds);
+		setMaxBoundsTime = System.currentTimeMillis();
+		return comp;
+	}
+	
+	public void maximize() {
+		if (GenericDialog.getInstance()!=null && IJ.isMacOSX() && IJ.isJava18())
+			return; // workaround for OSX/Java 8 maximize bug 
+		Rectangle rect = getMaximumBounds();
+		if (IJ.debugMode) IJ.log("maximize: "+rect);
+		setLocationAndSize(rect.x, rect.y, rect.width, rect.height);
+	}
+	
+	public void minimize() {
+		if (IJ.debugMode) IJ.log("minimize: "+unzoomWhenMinimizing);
+		if (unzoomWhenMinimizing)
+			ic.unzoom();
+		unzoomWhenMinimizing = true;
+	}
+
+	/** Has this window been closed? */
+	public boolean isClosed() {
+		return closed;
+	}
+	
+	public void focusGained(FocusEvent e) {
+		if (!Interpreter.isBatchMode() && ij!=null && !ij.quitting() && imp!=null) {
+			if (IJ.debugMode) IJ.log("focusGained: "+imp);
+			WindowManager.setCurrentWindow(this);
+		}
+	}
+
+	public void windowActivated(WindowEvent e) {
+		if (IJ.debugMode) IJ.log("windowActivated: "+imp.getTitle());
+		if (IJ.isMacOSX())
+			setImageJMenuBar(this);
+		if (imp==null)
+			return;
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null && !closed && !ij.quitting() && !Interpreter.isBatchMode())
+			WindowManager.setCurrentWindow(this);
+		Roi roi = imp.getRoi();
+		if (roi!=null && (roi instanceof PointRoi))
+			PointToolOptions.update();
+		if (imp.isComposite())
+			Channels.updateChannels();
+		imp.setActivated(); // notify ImagePlus that image has been activated
+	}
+	
+	public void windowClosing(WindowEvent e) {
+		if (closed)
+			return;
+		if (ij!=null) {
+			WindowManager.setCurrentWindow(this);
+			IJ.doCommand("Close");
+		} else {
+			dispose();
+			WindowManager.removeWindow(this);
+		}
+	}
+	
+	public void windowStateChanged(WindowEvent e) {
+		int oldState = e.getOldState();
+		int newState = e.getNewState();
+		if (IJ.debugMode) IJ.log("windowStateChanged: "+oldState+" "+newState);
+		if ((oldState&Frame.MAXIMIZED_BOTH)==0 && (newState&Frame.MAXIMIZED_BOTH)!=0)
+			maximize();
+	}
+
+	public void windowClosed(WindowEvent e) {}
+	public void windowDeactivated(WindowEvent e) {}
+	public void focusLost(FocusEvent e) {}
+	public void windowDeiconified(WindowEvent e) {}
+	public void windowIconified(WindowEvent e) {}	
+	public void windowOpened(WindowEvent e) {}
+	
+	public synchronized void mouseWheelMoved(MouseWheelEvent e) {
+		int rotation = e.getWheelRotation();
+		int amount = e.getScrollAmount();
+		boolean ctrl = (e.getModifiers()&Event.CTRL_MASK)!=0;
+		if (IJ.debugMode) {
+			IJ.log("mouseWheelMoved: "+e);
+			IJ.log("  type: "+e.getScrollType());
+			IJ.log("  ctrl: "+ctrl);
+			IJ.log("  rotation: "+rotation);
+			IJ.log("  amount: "+amount);
+		}
+		if (amount<1) amount=1;
+		if (rotation==0)
+			return;
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		Rectangle srcRect = ic.getSrcRect();
+		int xstart = srcRect.x;
+		int ystart = srcRect.y;
+		if ((ctrl||IJ.shiftKeyDown()) && ic!=null) {
+			Point loc = ic.getCursorLoc();
+			int x = ic.screenX(loc.x);
+			int y = ic.screenY(loc.y);
+			if (rotation<0)
+				ic.zoomIn(x, y);
+			else
+				ic.zoomOut(x, y);
+			return;
+		} else if (IJ.spaceBarDown() || srcRect.height==height) {
+			srcRect.x += rotation*amount*Math.max(width/200, 1);
+			if (srcRect.x<0) srcRect.x = 0;
+			if (srcRect.x+srcRect.width>width) srcRect.x = width-srcRect.width;
+		} else {
+			srcRect.y += rotation*amount*Math.max(height/200, 1);
+			if (srcRect.y<0) srcRect.y = 0;
+			if (srcRect.y+srcRect.height>height) srcRect.y = height-srcRect.height;
+		}
+		if (srcRect.x!=xstart || srcRect.y!=ystart)
+			ic.repaint();
+	}
+
+	/** Copies the current ROI to the clipboard. The entire
+	    image is copied if there is no ROI. */
+	public void copy(boolean cut) {
+		imp.copy(cut);
+    }
+                
+
+	public void paste() {
+		imp.paste();
+    }
+                
+    /** This method is called by ImageCanvas.mouseMoved(MouseEvent). 
+    	@see ij.gui.ImageCanvas#mouseMoved
+    */
+    public void mouseMoved(int x, int y) {
+    	imp.mouseMoved(x, y);
+    }
+    
+    public String toString() {
+    	return imp!=null?imp.getTitle():"";
+    }
+    
+    /** Causes the next image to be opened to be centered on the screen
+    	and displayed without informational text above the image. */
+    public static void centerNextImage() {
+    	centerOnScreen = true;
+    }
+    
+    /** Causes the next image to be displayed at the specified location. */
+    public static void setNextLocation(Point loc) {
+    	nextLocation = loc;
+    }
+
+    /** Causes the next image to be displayed at the specified location. */
+    public static void setNextLocation(int x, int y) {
+    	nextLocation = new Point(x, y);
+    }
+
+    /** Moves and resizes this window. Changes the 
+    	 magnification so the image fills the window. */
+    public void setLocationAndSize(int x, int y, int width, int height) {
+		setBounds(x, y, width, height);
+		getCanvas().fitToWindow();
+		initialLoc = null;
+		pack();
+	}
+	
+    @Override
+    public void setLocation(int x, int y) {
+    	super.setLocation(x, y);
+		initialLoc = null;
+	}
+
+	public void setSliderHeight(int height) {
+		sliderHeight = height;
+	}
+	
+	public int getSliderHeight() {
+		return sliderHeight;
+	}
+	
+	public static void setImageJMenuBar(ImageWindow win) {
+		ImageJ ij = IJ.getInstance();
+		boolean setMenuBar = true;
+		ImagePlus imp = win.getImagePlus();
+		if (imp!=null)
+			setMenuBar = imp.setIJMenuBar();
+		MenuBar mb = Menus.getMenuBar();
+		if (mb!=null && mb==win.getMenuBar())
+			setMenuBar = false;
+		setMenuBarTime = 0L;
+		if (setMenuBar && ij!=null && !ij.quitting() && !Interpreter.nonBatchMacroRunning()) {
+			IJ.wait(10); // may be needed for Java 1.4 on OS X
+			long t0 = System.currentTimeMillis();
+			win.setMenuBar(mb);
+			long time = System.currentTimeMillis()-t0;
+			setMenuBarTime = time;
+			Menus.setMenuBarCount++;
+			if (IJ.debugMode) IJ.log("setMenuBar: "+time+"ms ("+Menus.setMenuBarCount+")");
+			if (time>2000L)
+				Prefs.setIJMenuBar = false;
+		}
+		if (imp!=null) imp.setIJMenuBar(true);
+	}
+			
+} //class ImageWindow
diff --git a/src/ij/gui/Line.java b/src/ij/gui/Line.java
new file mode 100644
index 0000000..b4c601f
--- /dev/null
+++ b/src/ij/gui/Line.java
@@ -0,0 +1,738 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.Straightener;
+import ij.plugin.frame.Recorder;
+import ij.plugin.CalibrationBar;
+import java.awt.*;
+import java.awt.image.*;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.awt.event.*;
+import java.awt.geom.*;
+
+/** This class represents a straight line selection. */
+public class Line extends Roi {
+	public int x1, y1, x2, y2;	// the line end points as integer coordinates, for compatibility only
+	public double x1d, y1d, x2d, y2d;	// the line using sub-pixel coordinates
+	protected double x1R, y1R, x2R, y2R;  // the line, relative to base of subpixel bounding rect 'bounds'
+	protected double startxd, startyd;
+	static boolean widthChanged;
+	private boolean dragged;
+	private int mouseUpCount;
+
+	/** Creates a new straight line selection using the specified
+		starting and ending offscreen integer coordinates. */
+	public Line(int ox1, int oy1, int ox2, int oy2) {
+		this((double)ox1, (double)oy1, (double)ox2, (double)oy2);
+	}
+
+	/** Creates a new straight line selection using the specified
+		starting and ending offscreen double coordinates. */
+	public Line(double ox1, double oy1, double ox2, double oy2) {
+		super((int)(ox1+0.5), (int)(oy1+0.5), 0, 0);
+		type = LINE;
+		updateCoordinates(ox1, oy1, ox2, oy2);
+		if (!(this instanceof Arrow) && lineWidth>1)
+			updateWideLine(lineWidth);
+		updateClipRect();
+		oldX=x; oldY=y; oldWidth=width; oldHeight=height;
+		state = NORMAL;
+	}
+
+	/** Creates a new straight line selection using the specified
+		starting and ending offscreen coordinates. */
+	public static Line create(double x1, double y1, double x2, double y2) {
+		return new Line(x1, y1, x2, y2);
+	}
+
+	/** Starts the process of creating a new user-generated straight line
+		selection. 'sx' and 'sy' are screen coordinates that specify
+		the start of the line. The user will determine the end of the line
+		interactively using rubber banding. */
+	public Line(int sx, int sy, ImagePlus imp) {
+		super(sx, sy, imp);
+		type = LINE;
+		startxd = offScreenXD(sx);
+		startyd = offScreenYD(sy);
+		if (!magnificationForSubPixel()) {
+			startxd = Math.round(startxd);
+			startyd = Math.round(startyd);
+		}
+		updateCoordinates(startxd, startyd, startxd, startyd);
+		if (!(this instanceof Arrow) && lineWidth>1)
+			updateWideLine(lineWidth);
+	}
+
+	/**
+	* @deprecated
+	* replaced by Line(int, int, int, int)
+	*/
+	public Line(int ox1, int oy1, int ox2, int oy2, ImagePlus imp) {
+		this(ox1, oy1, ox2, oy2);
+		setImage(imp);
+	}
+
+	protected void grow(int sx, int sy) { //mouseDragged
+		drawLine(sx, sy);
+		dragged = true;
+	}
+
+	public void mouseMoved(MouseEvent e) {
+		drawLine(e.getX(), e.getY());
+	}
+
+	protected void handleMouseUp(int screenX, int screenY) {
+		mouseUpCount++;
+		if (Prefs.enhancedLineTool && mouseUpCount==1 && !dragged)
+			return;
+		state = NORMAL;
+		if (imp==null) return;
+		imp.draw(clipX-5, clipY-5, clipWidth+10, clipHeight+10);
+		if (Recorder.record) {
+			String method = (this instanceof Arrow)?"makeArrow":"makeLine";
+			Recorder.record(method, x1, y1, x2, y2);
+		}
+		if (getLength()==0.0)
+			imp.deleteRoi();
+	}
+
+	protected void drawLine(int sx, int sy) {
+		double xend = offScreenXD(sx);
+		double yend = offScreenYD(sy);
+		if (xend<0.0) xend=0.0; if (yend<0.0) yend=0.0;
+		if (xend>xMax) xend=xMax; if (yend>yMax) yend=yMax;
+		double xstart=getXBase()+x1R, ystart=getYBase()+y1R;
+		if (constrain) {
+		    int i=0;
+	        double dy = Math.abs(yend-ystart);
+	        double dx = Math.abs(xend-xstart);
+	        double comp = dy / dx;
+	        for (;i<PI_SEARCH.length; i++) {
+	            if(comp < PI_SEARCH[i]) {
+	                break;
+	            }
+	        }
+	        if (i < PI_SEARCH.length) {
+	            if(yend > ystart) {
+	                yend = ystart + dx*PI_MULT[i];
+	            } else {
+	                yend = ystart - dx*PI_MULT[i];
+	            }
+	        } else {
+	            xend = xstart;
+	        }
+		}
+		if (!magnificationForSubPixel() || IJ.controlKeyDown()) {  //during creation, CTRL enforces integer coordinates
+			xstart=Math.round(xstart); ystart=Math.round(ystart);
+			xend=Math.round(xend);     yend=Math.round(yend);
+		}
+		updateCoordinates(xstart, ystart, xend, yend);
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX=x; oldY=y;
+		oldWidth=width; oldHeight=height;
+	}
+
+	/** Used for angle searches in line ROI creation: tan = y/x for angle limits 1/2*45 degrees, and 3/2*45 deg */
+	private static final double[] PI_SEARCH = {Math.tan(Math.PI/8), Math.tan((3*Math.PI)/8)};
+	private static final double[] PI_MULT = {0, 1}; // y/x for horizontal (0 degrees) and 45 deg
+
+	void move(int sx, int sy) {
+		int xNew = offScreenX(sx);
+		int yNew = offScreenY(sy);
+		x += xNew - startxd;
+		y += yNew - startyd;
+		clipboard=null;
+		startxd = xNew;
+		startyd = yNew;
+		updateClipRect();
+		if (ignoreClipRect)
+			imp.draw();
+		else
+			imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX = x;
+		oldY = y;
+		oldWidth = width;
+		oldHeight=height;
+	}
+
+	protected void moveHandle(int sx, int sy) {
+		if (constrain && activeHandle == 2) {  // constrain translation in 90deg steps
+			int dx = sx - previousSX;
+			int dy = sy - previousSY;
+			if (Math.abs(dx) > Math.abs(dy))
+				dy = 0;
+			else
+				dx = 0;
+			sx = previousSX + dx;
+			sy = previousSY + dy;
+		}
+		double ox = offScreenXD(sx);
+		double oy = offScreenYD(sy);
+		double x1d=getXBase()+x1R, y1d=getYBase()+y1R;
+		double x2d=getXBase()+x2R, y2d=getYBase()+y2R;
+		double length = Math.sqrt(sqr(x2d-x1d) + sqr(y2d-y1d));
+		switch (activeHandle) {
+			case 0:
+                double dx = ox-x1d;
+                double dy = oy-y1d;
+                x1d=ox;
+                y1d=oy;
+                if(center){
+                    x2d -= dx;
+                    y2d -= dy;
+                }
+				if (aspect){
+					double ratio = length/(Math.sqrt(sqr(x2d-x1d) + sqr(y2d-y1d)));
+					double xcd = x1d+(x2d-x1d)/2;
+					double ycd = y1d+(y2d-y1d)/2;
+
+					if(center){
+						x1d=xcd-ratio*(xcd-x1d);
+						x2d=xcd+ratio*(x2d-xcd);
+						y1d=ycd-ratio*(ycd-y1d);
+						y2d=ycd+ratio*(y2d-ycd);
+					} else {
+						x1d=x2d-ratio*(x2d-x1d);
+						y1d=y2d-ratio*(y2d-y1d);
+					}
+
+				}
+                break;
+			case 1:
+                dx = ox-x2d;
+                dy = oy-y2d;
+                x2d=ox;
+                y2d=oy;
+                if(center){
+                    x1d -= dx;
+                    y1d -= dy;
+                }
+				if(aspect){
+					double ratio = length/(Math.sqrt((x2d-x1d)*(x2d-x1d) + (y2d-y1d)*(y2d-y1d)));
+					double xcd = x1d+(x2d-x1d)/2;
+					double ycd = y1d+(y2d-y1d)/2;
+
+					if(center){
+						x1d=xcd-ratio*(xcd-x1d);
+						x2d=xcd+ratio*(x2d-xcd);
+						y1d=ycd-ratio*(ycd-y1d);
+						y2d=ycd+ratio*(y2d-ycd);
+					} else {
+						x2d=x1d+ratio*(x2d-x1d);
+						y2d=y1d+ratio*(y2d-y1d);
+					}
+
+				}
+                break;
+			case 2:
+				dx = ox-(x1d+(x2d-x1d)/2);
+				dy = oy-(y1d+(y2d-y1d)/2);
+				x1d+=dx; y1d+=dy; x2d+=dx; y2d+=dy;
+				break;
+		}
+		if (constrain) {
+			double dx = Math.abs(x1d-x2d);
+			double dy = Math.abs(y1d-y2d);
+			double xcd = Math.min(x1d,x2d)+dx/2;
+			double ycd = Math.min(y1d,y2d)+dy/2;
+
+			//double ratio = length/(Math.sqrt((x2d-x1d)*(x2d-x1d) + (y2d-y1d)*(y2d-y1d)));
+			if (activeHandle==0) {
+				if (dx>=dy) {
+					if(aspect){
+						if(x2d>x1d) x1d=x2d-length;
+						else x1d=x2d+length;
+					}
+					y1d = y2d;
+					if(center) {
+						y1d=y2d=ycd;
+						if(aspect){
+							if(xcd>x1d) {
+								x1d=xcd-length/2;
+								x2d=xcd+length/2;
+							}
+							else{
+								x1d=xcd+length/2;
+								x2d=xcd-length/2;
+							}
+						}
+					}
+				} else {
+					if(aspect){
+						if(y2d>y1d) y1d=y2d-length;
+						else y1d=y2d+length;
+					}
+					x1d = x2d;
+					if(center){
+						x1d=x2d=xcd;
+						if(aspect){
+							if(ycd>y1d) {
+								y1d=ycd-length/2;
+								y2d=ycd+length/2;
+							}
+							else{
+								y1d=ycd+length/2;
+								y2d=ycd-length/2;
+							}
+						}
+					}
+				}
+			} else if (activeHandle==1) {
+				if (dx>=dy) {
+					if(aspect){
+						if(x1d>x2d) x2d=x1d-length;
+						else x2d=x1d+length;
+					}
+					y2d= y1d;
+					if(center){
+						y1d=y2d=ycd;
+						if(aspect){
+							if(xcd>x1d) {
+								x1d=xcd-length/2;
+								x2d=xcd+length/2;
+							}
+							else{
+								x1d=xcd+length/2;
+								x2d=xcd-length/2;
+							}
+						}
+					}
+				} else {
+					if(aspect){
+						if(y1d>y2d) y2d=y1d-length;
+						else y2d=y1d+length;
+					}
+					x2d = x1d;
+					if(center){
+						x1d=x2d=xcd;
+						if(aspect){
+							if(ycd>y1d) {
+								y1d=ycd-length/2;
+								y2d=ycd+length/2;
+							}
+							else{
+								y1d=ycd+length/2;
+								y2d=ycd-length/2;
+							}
+						}
+					}
+				}
+			}
+		}
+		if (!magnificationForSubPixel()) {
+			x1d = Math.round(x1d); y1d = Math.round(y1d);
+			x2d = Math.round(x2d); y2d = Math.round(y2d);
+		}
+		updateCoordinates(x1d, y1d, x2d, y2d);
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX = x;
+		oldY = y;
+		oldWidth = width;
+		oldHeight = height;
+	}
+
+	protected void mouseDownInHandle(int handle, int sx, int sy) {
+		super.mouseDownInHandle(handle, sx, sy); //sets state, activeHandle, previousSX&Y
+		if (getStrokeWidth()<=3)
+			ic.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
+	}
+
+	/** Sets the x1d, y1d, x2d, y2d line end points,
+	 *  the (legacy) integer coordinates of the end points x1, y1, x2, y2
+	 *  the 'bounds' subpixel rectangle of the Roi superclass (spanned by the end points),
+	 *  the int x, y, width, height integer bounds of the superclass (these enclose
+	 *  the 'draw' area for 1 pixel width), and
+	 *  the coordinates x1R, y1R, x2R, y2R relative to the base x, y of the 'bounds' */
+	void updateCoordinates(double x1d, double y1d, double x2d, double y2d) {
+		this.x1d = x1d; this.y1d = y1d;
+		this.x2d = x2d; this.y2d = y2d;
+		Rectangle2D.Double bounds = this.bounds;  //local variable (this.bounds may become null asynchronously upon nudge)
+		if (bounds == null) bounds = new Rectangle2D.Double();
+		bounds.x = Math.min(x1d, x2d);
+		bounds.y = Math.min(y1d, y2d);
+		bounds.width  = Math.abs(x2d - x1d);
+		bounds.height = Math.abs(y2d - y1d);
+		setIntBounds(bounds); //sets x, y, width, height
+		x1R = x1d - bounds.x; y1R = y1d - bounds.y;
+		x2R = x2d - bounds.x; y2R = y2d - bounds.y;
+		x1=(int)x1d; y1=(int)y1d; x2=(int)x2d; y2=(int)y2d;
+		this.bounds = bounds;
+	}
+
+	/** Draws this line on the image. */
+	public void draw(Graphics g) {
+		Color color =  strokeColor!=null? strokeColor:ROIColor;
+		boolean isActiveOverlayRoi = !overlay && isActiveOverlayRoi();
+		mag = getMagnification();
+		if (isActiveOverlayRoi) {
+			if (color==Color.cyan)
+				color = Color.magenta;
+			else
+				color = Color.cyan;
+		}
+		g.setColor(color);
+		x1d=getXBase()+x1R; y1d=getYBase()+y1R; x2d=getXBase()+x2R; y2d=getYBase()+y2R;
+		x1=(int)x1d; y1=(int)y1d; x2=(int)x2d; y2=(int)y2d;
+		int sx1 = screenXD(x1d);
+		int sy1 = screenYD(y1d);
+		int sx2 = screenXD(x2d);
+		int sy2 = screenYD(y2d);
+		int sx3 = sx1 + (sx2-sx1)/2;
+		int sy3 = sy1 + (sy2-sy1)/2;
+		Graphics2D g2d = (Graphics2D)g;
+		setRenderingHint(g2d);
+		boolean cbar = overlay && mag<1.0 && Math.abs(getStrokeWidth()-CalibrationBar.STROKE_WIDTH)<0.0001;
+		if (stroke!=null && !isActiveOverlayRoi && !cbar)
+			g2d.setStroke(getScaledStroke());
+		else if (cbar)
+			g2d.setStroke(onePixelWide);
+		if (wideLine && !isActiveOverlayRoi && !cbar) {
+			double dx = sx2 - sx1;
+			double dy = sy2 - sy1;
+			double len = length(dx, dy);
+			dx *= 0.5*mag/len;	//half-pixel extension, corresponding to getFloatPolygon or convertLineToArea
+			dy *= 0.5*mag/len;
+			g2d.draw(new Line2D.Double(sx1-dx, sy1-dy, sx2+dx, sy2+dy));
+		} else
+			g.drawLine(sx1, sy1, sx2, sy2);
+		if (wideLine && !overlay) {
+			g2d.setStroke(onePixelWide);
+			g.setColor(getColor());
+			g.drawLine(sx1, sy1, sx2, sy2);
+		}
+		if (!overlay) {
+			handleColor = strokeColor!=null?strokeColor:ROIColor;
+			drawHandle(g, sx1, sy1);
+			handleColor=Color.white;
+			drawHandle(g, sx2, sy2);
+			drawHandle(g, sx3, sy3);
+		}
+		if (state!=NORMAL)
+			showStatus();
+		if (updateFullWindow)
+			{updateFullWindow = false; imp.draw();}
+	}
+
+	public void showStatus() {
+		IJ.showStatus(imp.getLocationAsString((int)Math.round(x2d),(int)Math.round(y2d))+
+				", angle=" + IJ.d2s(getAngle()) + ", length=" + IJ.d2s(getLength()));
+	}
+
+	public double getAngle() {
+		return getFloatAngle(x1d, y1d, x2d, y2d);
+	}
+
+	/** Returns the length of this line. */
+	public double getLength() {
+		if (imp==null || IJ.altKeyDown())
+			return getRawLength();
+		else {
+			Calibration cal = imp.getCalibration();
+			return Math.sqrt(sqr((x2d-x1d)*cal.pixelWidth) + sqr((y2d-y1d)*cal.pixelHeight));
+		}
+	}
+
+	/** Returns the length of this line in pixels. */
+	public double getRawLength() {
+		return Math.sqrt(sqr(x2d-x1d)+sqr(y2d-y1d));
+	}
+
+	/** Returns the pixel values along this line.
+	 *  The line roi must have an associated ImagePlus */
+	public double[] getPixels() {
+			double[] profile;
+			if (getStrokeWidth()<=1) {
+				ImageProcessor ip = imp.getProcessor();
+				profile = ip.getLine(x1d, y1d, x2d, y2d);
+			} else {
+				ImageProcessor ip2 = (new Straightener()).rotateLine(imp,(int)getStrokeWidth());
+				if (ip2==null) return new double[0];
+				int width = ip2.getWidth();
+				int height = ip2.getHeight();
+				if (ip2 instanceof FloatProcessor)
+					return ProfilePlot.getColumnAverageProfile(new Rectangle(0,0,width,height),ip2);
+				profile = new double[width];
+				double[] aLine;
+				ip2.setInterpolate(false);
+				for (int y=0; y<height; y++) {
+					aLine = ip2.getLine(0, y, width-1, y);
+					for (int i=0; i<width; i++)
+						profile[i] += aLine[i];
+				}
+				for (int i=0; i<width; i++)
+					profile[i] /= height;
+			}
+			return profile;
+	}
+
+	/** Returns, as a Polygon, the two points that define this line. */
+	public Polygon getPoints() {
+		Polygon p = new Polygon();
+		p.addPoint((int)Math.round(x1d), (int)Math.round(y1d));
+		p.addPoint((int)Math.round(x2d), (int)Math.round(y2d));
+		return p;
+	}
+
+	/** Returns, as a FloatPolygon, the two points that define this line. */
+	public FloatPolygon getFloatPoints() {
+		FloatPolygon p = new FloatPolygon();
+		p.addPoint((float)x1d, (float)y1d);
+		p.addPoint((float)x2d, (float)y2d);
+		return p;
+	}
+
+	/** If the width of this line is less than or equal to one, returns the
+	 * starting and ending coordinates as a 2-point Polygon, or, if
+	 * the width is greater than one, returns an outline of the line as
+	 * a 4-point Polygon.
+	 * @see #getFloatPolygon
+	 * @see #getPoints
+	 */
+	public Polygon getPolygon() {
+		FloatPolygon p = getFloatPolygon();
+		return new Polygon(toIntR(p.xpoints), toIntR(p.ypoints), p.npoints);
+	}
+
+	/** If the width of this line is less than or equal to one, returns the
+	 * starting and ending coordinates as a 2-point FloatPolygon, or, if
+	 * the width is greater than one, returns an outline of the line as
+	 * a 4-point FloatPolygon.
+	 * @see #getFloatPoints
+	 */
+	public FloatPolygon getFloatPolygon() {
+		return getFloatPolygon(getStrokeWidth());
+	}
+
+	public FloatPolygon getFloatPolygon(double strokeWidth) {
+		FloatPolygon p = new FloatPolygon();
+		if (strokeWidth <= 1) {
+			p.addPoint((float)x1d, (float)y1d);
+			p.addPoint((float)x2d, (float)y2d);
+		} else {
+			double dx = x2d - x1d;
+			double dy = y2d - y1d;
+			double len = length(dx, dy);
+			dx *= 0.5/len;		// half unit vector in the direction of the line
+			dy *= 0.5/len;		// when rotated 90 deg cw, this yields the vector (-dx, dy)
+			double p1x = x1d + 0.5 - dx + dy*strokeWidth;  //0.5 pxl shift: area vs. line coordinate convention
+			double p1y = y1d + 0.5 - dy - dx*strokeWidth;
+			double p2x = x1d + 0.5 - dx - dy*strokeWidth;
+			double p2y = y1d + 0.5 - dy + dx*strokeWidth;
+			double p3x = x2d + 0.5 + dx - dy*strokeWidth;
+			double p3y = y2d + 0.5 + dy + dx*strokeWidth;
+			double p4x = x2d + 0.5 + dx + dy*strokeWidth;
+			double p4y = y2d + 0.5 + dy - dx*strokeWidth;
+			p.addPoint((float)p1x, (float)p1y);
+			p.addPoint((float)p2x, (float)p2y);
+			p.addPoint((float)p3x, (float)p3y);
+			p.addPoint((float)p4x, (float)p4y);
+		}
+		return p;
+	}
+
+	/** Returns the number of points in this selection; equivalent to getPolygon().npoints. */
+	public int size() {
+		return getStrokeWidth()<=1?2:4;
+	}
+
+	/** If the width of this line is less than or equal to one, draws the line.
+	 *  Otherwise draws the outline of the area of this line */
+	public void drawPixels(ImageProcessor ip) {
+		ip.setLineWidth(1);
+		double x = getXBase();
+		double y = getYBase();
+		x1d=getXBase()+x1R; y1d=getYBase()+y1R; x2d=getXBase()+x2R; y2d=getYBase()+y2R;
+		if (getStrokeWidth()<=1) {
+			ip.moveTo((int)Math.round(x1d), (int)Math.round(y1d));
+			ip.lineTo((int)Math.round(x2d), (int)Math.round(y2d));
+		} else {
+			Polygon p = getPolygon();
+			ip.drawPolygon(p);
+			updateFullWindow = true;
+		}
+	}
+
+	public boolean contains(int x, int y) {
+		if (getStrokeWidth()>1) {
+			if ((x==x1&&y==y1) || (x==x2&&y==y2))
+				return true;
+			else
+				return getPolygon().contains(x,y);
+		} else
+			return false;
+	}
+
+	protected void handleMouseDown(int sx, int sy) {
+		super.handleMouseDown(sx, sy);
+		startxd = ic.offScreenXD(sx);
+		startyd = ic.offScreenYD(sy);
+	}
+
+	/** Returns a handle number if the specified screen coordinates are
+		inside or near a handle, otherwise returns -1. */
+	public int isHandle(int sx, int sy) {
+		int size = HANDLE_SIZE+5;
+		if (getStrokeWidth()>1) size += (int)Math.log(getStrokeWidth());
+		int halfSize = size/2;
+		int sx1 = screenXD(getXBase()+x1R) - halfSize;
+		int sy1 = screenYD(getYBase()+y1R) - halfSize;
+		int sx2 = screenXD(getXBase()+x2R) - halfSize;
+		int sy2 = screenYD(getYBase()+y2R) - halfSize;
+		int sx3 = sx1 + (sx2-sx1)/2-1;
+		int sy3 = sy1 + (sy2-sy1)/2-1;
+		if (sx>=sx1&&sx<=sx1+size&&sy>=sy1&&sy<=sy1+size) return 0;
+		if (sx>=sx2&&sx<=sx2+size&&sy>=sy2&&sy<=sy2+size) return 1;
+		if (sx>=sx3&&sx<=sx3+size+2&&sy>=sy3&&sy<=sy3+size+2) return 2;
+		return -1;
+	}
+
+	public static int getWidth() {
+		return lineWidth;
+	}
+
+	public static void setWidth(int w) {
+		if (w<1) w = 1;
+		int max = 500;
+		if (w>max) {
+			ImagePlus imp2 = WindowManager.getCurrentImage();
+			if (imp2!=null) {
+				max = Math.max(max, imp2.getWidth());
+				max = Math.max(max, imp2.getHeight());
+			}
+			if (w>max) w = max;
+		}
+		lineWidth = w;
+		widthChanged = true;
+	}
+
+	public void setStrokeWidth(float width) {
+		super.setStrokeWidth(width);
+		if (getStrokeColor()==Roi.getColor())
+			wideLine = true;
+	}
+
+	protected int clipRectMargin() {
+		return 4;
+	}
+
+	/** Nudge end point of line by one pixel. */
+	public void nudgeCorner(int key) {
+		if (ic==null) return;
+		double inc = 1.0/ic.getMagnification();
+		switch(key) {
+			case KeyEvent.VK_UP: y2R-=inc; break;
+			case KeyEvent.VK_DOWN: y2R+=inc; break;
+			case KeyEvent.VK_LEFT: x2R-=inc; break;
+			case KeyEvent.VK_RIGHT: x2R+=inc; break;
+		}
+		grow(screenXD(x+x2R), screenYD(y+y2R));
+		notifyListeners(RoiListener.MOVED);
+		showStatus();
+	}
+
+	/** Always returns true. */
+	public boolean subPixelResolution() {
+		return true;
+	}
+
+	public void setLocation(int x, int y) {
+		setLocation((double)x, (double)y);
+	}
+
+	/** Sets the x coordinate of the leftmost and y coordinate of the topmost end point */
+	public void setLocation(double x, double y) {
+		updateCoordinates(x+x1R, y+y1R, x+x2R, y+y2R);
+	}
+
+	public FloatPolygon getRotationCenter() {
+		double xcenter = x1d + (x2d-x1d)/2.0;
+		double ycenter = y1d + (y2d-y1d)/2.0;
+		FloatPolygon p = new FloatPolygon();
+		p.addPoint(xcenter,ycenter);
+		return p;
+	}
+
+	/**
+	 * Dedicated point iterator for thin lines.
+	 * The iterator is based on (an improved version of) the algorithm used by
+	 * the original method {@code ImageProcessor.getLine(double, double, double, double)}.
+	 * Improvements are (a) that the endpoint is drawn too and (b) every line
+	 * point is visited only once, duplicates are skipped.
+	 *
+	 * Author: Wilhelm Burger (04/2017)
+	*/
+	public static class PointIterator implements Iterator<Point> {
+		private double x1, y1;
+		private final int n;
+		private final double xinc, yinc;
+		private double x, y;
+		private int u, v;
+		private int u_prev, v_prev;
+		private int i;
+
+		public PointIterator(Line line) {
+			this(line.x1d, line.y1d, line.x2d, line.y2d);
+		}
+
+		public PointIterator(double x1, double y1, double x2, double y2) {
+			this.x1 = x1;
+			this.y1 = y1;
+			double dx = x2 - x1;
+			double dy = y2 - y1;
+			this.n = (int) Math.ceil(Math.sqrt(dx * dx + dy * dy));
+			this.xinc = dx / n;
+			this.yinc = dy / n;
+			x = x1;
+			y = y1;
+			u = (int) Math.round(x - 0.5);
+			v = (int) Math.round(y - 0.5);
+			u_prev = Integer.MIN_VALUE;
+			v_prev = Integer.MIN_VALUE;
+			i = 0;
+		}
+
+		@Override
+		public boolean hasNext() {
+			return i <= n;	// needs to be '<=' to include last segment (point)!
+		}
+
+		@Override
+		public Point next() {
+			if (i > n) throw new NoSuchElementException();
+			Point p = new Point(u, v);	// the current (next) point
+			moveToNext();
+			return p;
+		}
+
+		// move to next point by skipping duplicate points
+		private void moveToNext() {
+			do {
+				i = i + 1;
+				x = x1 + i * xinc;
+				y = y1 + i * yinc;
+				u_prev = u;
+				v_prev = v;
+				u = (int) Math.round(x - 0.5);
+				v = (int) Math.round(y - 0.5);
+			} while (i <= n && u == u_prev && v == v_prev);
+		}
+
+		@Override
+		public void remove() {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+	@Override
+	public Iterator<Point> iterator() {
+		if (getStrokeWidth() <= 1.0)
+			return new PointIterator(this);	// use the specific thin-line iterator
+		else
+			return super.iterator();	// fall back on Roi's iterator
+	}
+
+}
diff --git a/src/ij/gui/MessageDialog.java b/src/ij/gui/MessageDialog.java
new file mode 100644
index 0000000..7d8b942
--- /dev/null
+++ b/src/ij/gui/MessageDialog.java
@@ -0,0 +1,85 @@
+package ij.gui;
+import ij.*;
+import java.awt.*;
+import java.awt.event.*;
+
+/** A modal dialog box that displays information. Based on the
+	InfoDialogclass from "Java in a Nutshell" by David Flanagan. */
+public class MessageDialog extends Dialog implements ActionListener, KeyListener, WindowListener {
+	protected Button button;
+	protected MultiLineLabel label;
+	private boolean escapePressed;
+	
+	public MessageDialog(Frame parent, String title, String message) {
+		super(parent, title, true);
+		setLayout(new BorderLayout());
+		if (message==null) message = "";
+		Font font = null;
+		double scale = Prefs.getGuiScale();
+		if (scale>1.0) {
+			font = getFont();
+			if (font!=null)
+				font = font.deriveFont((float)(font.getSize()*scale));
+			else
+				font = new Font("SansSerif", Font.PLAIN, (int)(12*scale));
+			setFont(font);
+		}
+		label = new MultiLineLabel(message);
+		if (font!=null)
+			label.setFont(font);
+		else if (!IJ.isLinux())
+			label.setFont(new Font("SansSerif", Font.PLAIN, 14));
+		Panel panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.CENTER, 15, 15));
+		panel.add(label);
+		add("Center", panel);
+		button = new Button("  OK  ");
+		button.addActionListener(this);
+		button.addKeyListener(this);
+		panel = new Panel();
+		panel.setLayout(new FlowLayout());
+		panel.add(button);
+		add("South", panel);
+		if (ij.IJ.isMacintosh())
+			setResizable(false);
+		pack();
+		GUI.centerOnImageJScreen(this);
+		addWindowListener(this);
+		show();
+	}
+	
+	public void actionPerformed(ActionEvent e) {
+		dispose();
+	}
+	
+	public void keyPressed(KeyEvent e) { 
+		int keyCode = e.getKeyCode(); 
+		IJ.setKeyDown(keyCode);
+		escapePressed = keyCode==KeyEvent.VK_ESCAPE;
+		if (keyCode==KeyEvent.VK_ENTER || escapePressed)
+			dispose();
+	} 
+	
+	public void keyReleased(KeyEvent e) {
+		int keyCode = e.getKeyCode(); 
+		IJ.setKeyUp(keyCode); 
+	}
+	
+	public void keyTyped(KeyEvent e) {}
+
+	public void windowClosing(WindowEvent e) {
+		dispose();
+	}
+	
+	public boolean escapePressed() {
+		return escapePressed;
+	}
+
+	public void windowActivated(WindowEvent e) {}
+	public void windowOpened(WindowEvent e) {}
+	public void windowClosed(WindowEvent e) {}
+	public void windowIconified(WindowEvent e) {}
+	public void windowDeiconified(WindowEvent e) {}
+	public void windowDeactivated(WindowEvent e) {}
+
+}
diff --git a/src/ij/gui/MultiLineLabel.java b/src/ij/gui/MultiLineLabel.java
new file mode 100644
index 0000000..054b3ad
--- /dev/null
+++ b/src/ij/gui/MultiLineLabel.java
@@ -0,0 +1,108 @@
+package ij.gui;
+import java.awt.*;
+import java.util.*;
+
+/**Custom component for displaying multiple lines. Based on 
+   MultiLineLabel class from "Java in a Nutshell" by David Flanagan.*/
+public class MultiLineLabel extends Canvas {
+	String[] lines;
+	int num_lines;
+	int margin_width = 6;
+	int margin_height = 6;
+	int line_height;
+	int line_ascent;
+	int[] line_widths;
+	int min_width, max_width;
+    
+    // Breaks the specified label up into an array of lines.
+    public MultiLineLabel(String label) {
+        init(label);
+    }
+
+    public MultiLineLabel(String label, int minimumWidth) {
+        init(label);
+        min_width = minimumWidth;
+    }
+
+    private void init(String text) {
+        StringTokenizer t = new StringTokenizer(text, "\n");
+        num_lines = t.countTokens();
+        lines = new String[num_lines];
+        line_widths = new int[num_lines];
+        for (int i=0; i<num_lines; i++)
+        	lines[i] = t.nextToken();
+    }
+
+    // Figures out how wide each line of the label
+    // is, and how wide the widest line is.
+    protected void measure() {
+        Font font = getFont();
+        FontMetrics fm = font!=null?getFontMetrics(font):null;
+        // If we don't have font metrics yet, just return.
+        if (fm == null) return;
+        line_height = fm.getHeight();
+        line_ascent = fm.getAscent();
+        max_width = 0;
+        for(int i = 0; i < num_lines; i++) {
+            line_widths[i] = fm.stringWidth(lines[i]);
+            if (line_widths[i] > max_width) max_width = line_widths[i];
+        }
+    }
+    
+
+    public void setText(String text) {
+        init(text);
+        measure();
+        repaint();
+    }
+
+    public void setFont(Font f) {
+        super.setFont(f);
+        measure();
+        repaint();
+    }
+
+
+	// This method is invoked after our Canvas is first created
+	// but before it can actually be displayed.  After we've
+	// invoked our superclass's addNotify() method, we have font
+	// metrics and can successfully call measure() to figure out
+	// how big the label is.
+	public void addNotify() {
+		super.addNotify();
+		measure();
+	}
+    
+
+    // Called by a layout manager when it wants to
+    // know how big we'd like to be.  
+    public Dimension getPreferredSize() {
+        return new Dimension(Math.max(min_width, max_width + 2*margin_width), 
+                     num_lines * line_height + 2*margin_height);
+    }
+    
+
+    // Called when the layout manager wants to know
+    // the bare minimum amount of space we need to get by.
+    public Dimension getMinimumSize() {
+        return new Dimension(Math.max(min_width, max_width), num_lines * line_height);
+    }
+    
+    // Draws the label
+    public void paint(Graphics g) {
+        int x, y;
+        Dimension d = this.getSize();
+		if (!ij.IJ.isLinux()) setAntialiasedText(g);
+        y = line_ascent + (d.height - num_lines * line_height)/2;
+        for(int i = 0; i < num_lines; i++, y += line_height) {
+            x = margin_width;
+            g.drawString(lines[i], x, y);
+        }
+    }
+
+	void setAntialiasedText(Graphics g) {
+			Graphics2D g2d = (Graphics2D)g;
+			g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+	}
+
+}
diff --git a/src/ij/gui/NewImage.java b/src/ij/gui/NewImage.java
new file mode 100644
index 0000000..e14e15c
--- /dev/null
+++ b/src/ij/gui/NewImage.java
@@ -0,0 +1,466 @@
+package ij.gui;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.awt.event.*;
+import java.util.*;
+import ij.*;
+import ij.process.*;
+
+/** New image dialog box plus several static utility methods for creating images.*/
+public class NewImage {
+
+	public static final int GRAY8=0, GRAY16=1, GRAY32=2, RGB=3;
+	public static final int FILL_BLACK=1, FILL_RAMP=2, FILL_NOISE=3, FILL_RANDOM=3,
+		FILL_WHITE=4, CHECK_AVAILABLE_MEMORY=8,  SIGNED_INT=16;
+	private static final int OLD_FILL_WHITE=0;
+	
+    static final String TYPE = "new.type";
+    static final String FILL = "new.fill";
+	static final String WIDTH = "new.width";
+	static final String HEIGHT = "new.height";
+	static final String SLICES = "new.slices";
+
+    private static String name = "Untitled";
+    private static int staticWidth = Prefs.getInt(WIDTH, 512);
+    private static int staticHeight = Prefs.getInt(HEIGHT, 512);
+    private static int staticSlices = Prefs.getInt(SLICES, 1);
+    private static int staticType = Prefs.getInt(TYPE, GRAY8);
+    private static int staticFillWith = Prefs.getInt(FILL, FILL_BLACK);
+    private static String[] types = {"8-bit", "16-bit", "32-bit", "RGB"};
+    private static String[] fill = {"White", "Black", "Ramp", "Noise"}; 
+    private int gwidth, gheight, gslices, gtype, gfill;
+	
+    public NewImage() {
+    	openImage();
+    }
+    
+	static boolean createStack(ImagePlus imp, ImageProcessor ip, int nSlices, int type, int options) {
+		int fill = getFill(options);
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		long bytesPerPixel = 1;
+		if (type==GRAY16) bytesPerPixel = 2;
+		else if (type==GRAY32||type==RGB) bytesPerPixel = 4;
+		long size = (long)width*height*nSlices*bytesPerPixel;
+		int sizeThreshold = fill==FILL_NOISE?10:250;
+		boolean bigStack = size/(1024*1024)>=sizeThreshold;
+		String size2 = size/(1024*1024)+"MB ("+width+"x"+height+"x"+nSlices+")";
+		if ((options&CHECK_AVAILABLE_MEMORY)!=0) {
+			long max = IJ.maxMemory(); // - 100*1024*1024;
+			if (max>0) {
+				long inUse = IJ.currentMemory();
+				long available = max - inUse;
+				if (size>available)
+					System.gc();
+				inUse = IJ.currentMemory();
+				available = max-inUse;
+				if (size>available) {
+					IJ.error("Insufficient Memory", "There is not enough free memory to allocate a \n"
+					+ size2+" stack.\n \n"
+					+ "Memory available: "+available/(1024*1024)+"MB\n"		
+					+ "Memory in use: "+IJ.freeMemory()+"\n \n"	
+					+ "More information can be found in the \"Memory\"\n"
+					+ "sections of the ImageJ installation notes at\n"
+					+ "\""+IJ.URL+"/docs/install/\".");
+					return false;
+				}
+			}
+		}
+		ImageStack stack = imp.createEmptyStack();
+		boolean signedInt = (options&SIGNED_INT)!=0;
+		if (type==RGB && signedInt)
+			stack.setOptions("32-bit int");
+		int inc = nSlices/40;
+		if (inc<1) inc = 1;
+		if (bigStack)
+			IJ.showStatus("Allocating "+size2+". Press 'Esc' to abort.");
+		IJ.resetEscape();
+		try {
+			stack.addSlice(null, ip);
+			for (int i=2; i<=nSlices; i++) {
+				if ((i%inc)==0 && bigStack)
+					IJ.showProgress(i, nSlices);
+				Object pixels2 = null;
+				switch (type) {
+					case GRAY8: pixels2 = new byte[width*height];
+						if (fill==FILL_NOISE)
+							fillNoiseByte(new ByteProcessor(width,height,(byte[])pixels2));
+						break;
+					case GRAY16: pixels2 = new short[width*height];
+						if (fill==FILL_NOISE)
+							fillNoiseShort(new ShortProcessor(width,height,(short[])pixels2,null));
+						break;
+					case GRAY32: pixels2 = new float[width*height];
+						if (fill==FILL_NOISE)
+							fillNoiseFloat(new FloatProcessor(width,height,(float[])pixels2,null));
+						break;
+					case RGB: pixels2 = new int[width*height];
+						if (fill==FILL_NOISE) {
+						 if (signedInt)
+							fillNoiseInt(new IntProcessor(width,height,(int[])pixels2));
+						else
+							fillNoiseRGB(new ColorProcessor(width,height,(int[])pixels2), false);
+						}
+						break;
+				}
+				if (signedInt && (fill==FILL_WHITE||fill==FILL_RAMP) || ((type==RGB)&&(fill!=FILL_NOISE)))
+					System.arraycopy(ip.getPixels(), 0, pixels2, 0, width*height);
+				stack.addSlice(null, pixels2);
+				if (IJ.escapePressed()) {IJ.beep(); break;};
+			}
+		}
+		catch(OutOfMemoryError e) {
+			IJ.outOfMemory(imp.getTitle());
+			stack.trim();
+		}
+		IJ.showStatus("");
+		if (bigStack)
+			IJ.showProgress(nSlices, nSlices);
+		if (stack.size()>1)
+			imp.setStack(null, stack);
+		return true;
+	}
+
+	static int getFill(int options) {
+		int fill = options&7; 
+		if (fill==OLD_FILL_WHITE)
+			fill = FILL_WHITE;
+		if (fill==7||fill==6||fill==5)
+			fill = FILL_BLACK;
+		return fill;
+	}
+
+	public static ImagePlus createByteImage(String title, int width, int height, int slices, int options) {
+		int fill = getFill(options);
+		int size = getSize(width, height);
+		if (size<0) return null;
+		byte[] pixels = new byte[size];
+		ImageProcessor ip = new ByteProcessor(width, height, pixels, null);
+		switch (fill) {
+			case FILL_WHITE:
+				for (int i=0; i<width*height; i++)
+					pixels[i] = (byte)255;
+				break;
+			case FILL_BLACK:
+				break;
+			case FILL_RAMP:
+				byte[] ramp = new byte[width];
+				for (int i=0; i<width; i++)
+					ramp[i] = (byte)((i*256.0)/width);
+				int offset;
+				for (int y=0; y<height; y++) {
+					offset = y*width;
+					for (int x=0; x<width; x++)
+						pixels[offset++] = ramp[x];
+				}
+				break;
+			case FILL_NOISE:
+				fillNoiseByte(ip);
+				break;
+		}
+		ImagePlus imp = new ImagePlus(title, ip);
+		if (slices>1) {
+			boolean ok = createStack(imp, ip, slices, GRAY8, options);
+			if (!ok) imp = null;
+		}
+		return imp;
+	}
+	
+	private static void fillNoiseByte(ImageProcessor ip) {
+		ip.add(127);
+		ip.noise(31);
+	}
+
+	public static ImagePlus createRGBImage(String title, int width, int height, int slices, int options) {
+		int fill = getFill(options);
+		int size = getSize(width, height);
+		if (size<0) return null;
+		int[] pixels = new int[size];
+		ColorProcessor ip = new ColorProcessor(width, height, pixels);
+		switch (fill) {
+			case FILL_WHITE:
+				for (int i=0; i<width*height; i++)
+					pixels[i] = -1;
+				break;
+			case FILL_BLACK:
+				for (int i=0; i<width*height; i++)
+					pixels[i] = 0xff000000;
+				break;
+			case FILL_RAMP:
+				int r,g,b,offset;
+				int[] ramp = new int[width];
+				for (int i=0; i<width; i++) {
+					r = g = b = (byte)((i*256.0)/width);
+					ramp[i] = 0xff000000 | ((r<<16)&0xff0000) | ((g<<8)&0xff00) | (b&0xff);
+				}
+				for (int y=0; y<height; y++) {
+					offset = y*width;
+					for (int x=0; x<width; x++)
+						pixels[offset++] = ramp[x];
+				}
+				break;
+			case FILL_NOISE:
+				fillNoiseRGB(ip, true);
+				break;
+		}
+		ImagePlus imp = new ImagePlus(title, ip);
+		if (slices>1) {
+			boolean ok = createStack(imp, ip, slices, RGB, options);
+			if (!ok) imp = null;
+		}
+		return imp;
+	}
+	
+	public static ImagePlus createIntImage(String title, int width, int height, int slices, int options) {
+		int fill = getFill(options);
+		int size = getSize(width, height);
+		if (size<0) return null;
+		int[] pixels = new int[size];
+		IntProcessor ip = new IntProcessor(width, height, pixels);
+		switch (fill) {
+			case FILL_RAMP:
+				int[] ramp = new int[width];
+				double inc = ((double)Integer.MAX_VALUE - (double)Integer.MIN_VALUE)/width;
+				for (int i=0; i<width; i++) {
+        			ramp[i] = (int)((double)Integer.MIN_VALUE + i*inc);
+        		}
+				for (int y=0; y<height; y++) {
+					int offset = y*width;
+					for (int x=0; x<width; x++)
+						pixels[offset++] = ramp[x];
+				}
+				break;
+				
+			case FILL_NOISE:
+				fillNoiseInt(new IntProcessor(width,height,(int[])pixels));
+				break;
+		}
+		ImagePlus imp = new ImagePlus(title, ip);
+		if (slices>1) {
+			boolean ok = createStack(imp, ip, slices, RGB, options);
+			if (!ok) imp = null;
+		}
+		return imp;
+	}
+
+	private static void fillNoiseRGB(ColorProcessor ip, boolean sp) {
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		ByteProcessor rr = new ByteProcessor(width, height);
+		ByteProcessor gg = new ByteProcessor(width, height);
+		ByteProcessor bb = new ByteProcessor(width, height);
+		if (sp) IJ.showProgress(0.0);
+		rr.add(127); if (sp) IJ.showProgress(0.05);
+		gg.add(127); if (sp) IJ.showProgress(0.10);
+		bb.add(127); if (sp) IJ.showProgress(0.15);
+		rr.noise(31); if (sp) IJ.showProgress(0.40);
+		gg.noise(31); if (sp) IJ.showProgress(0.65);
+		bb.noise(31); if (sp) IJ.showProgress(0.90);
+		if (sp) IJ.showProgress(1.0);
+		ip.setChannel(1,rr); ip.setChannel(2,gg); ip.setChannel(3,bb);
+	}
+
+	private static void fillNoiseInt(ImageProcessor ip) {
+		Random rnd = new Random();
+		int n = ip.getPixelCount();
+		double std =((double)Integer.MAX_VALUE - (double)Integer.MIN_VALUE)*0.12;
+		for (int i=0; i<n; i++)
+			ip.set(i, (int)(rnd.nextGaussian()*std));
+	}
+
+	/** Creates an unsigned short image. */
+	public static ImagePlus createShortImage(String title, int width, int height, int slices, int options) {
+		int fill = getFill(options);
+		int size = getSize(width, height);
+		if (size<0) return null;
+		short[] pixels = new short[size];
+		ImageProcessor ip = new ShortProcessor(width, height, pixels, null);
+		switch (fill) {
+			case FILL_WHITE: case FILL_BLACK:
+				break;
+			case FILL_RAMP:
+				short[] ramp = new short[width];
+				for (int i=0; i<width; i++)
+					ramp[i] = (short)(((i*65536.0)/width)+0.5);
+				int offset;
+				for (int y=0; y<height; y++) {
+					offset = y*width;
+					for (int x=0; x<width; x++)
+						pixels[offset++] = ramp[x];
+				}
+				break;
+			case FILL_NOISE:
+				fillNoiseShort(ip);
+				break;
+		}
+	    if (fill==FILL_WHITE)
+	    	ip.invertLut();
+		ImagePlus imp = new ImagePlus(title, ip);
+		if (slices>1) {
+			boolean ok = createStack(imp, ip, slices, GRAY16, options);
+			if (!ok) imp = null;
+		}
+		imp.getProcessor().setMinAndMax(0, 65535); // default display range
+		return imp;
+	}
+
+	private static void fillNoiseShort(ImageProcessor ip) {
+		ip.add(32767);
+		ip.noise(7940);
+	}
+
+	/**
+	* @deprecated
+	* Short images are always unsigned.
+	*/
+	public static ImagePlus createUnsignedShortImage(String title, int width, int height, int slices, int options) {
+		return createShortImage(title, width, height, slices, options);
+	}
+
+	public static ImagePlus createFloatImage(String title, int width, int height, int slices, int options) {
+		int fill = getFill(options);
+		int size = getSize(width, height);
+		if (size<0) return null;
+		float[] pixels = new float[size];
+		ImageProcessor ip = new FloatProcessor(width, height, pixels, null);
+		switch (fill) {
+			case FILL_WHITE: case FILL_BLACK:
+				break;
+			case FILL_RAMP:
+				float[] ramp = new float[width];
+				for (int i=0; i<width; i++)
+					ramp[i] = (float)((i*1.0)/width);
+				int offset;
+				for (int y=0; y<height; y++) {
+					offset = y*width;
+					for (int x=0; x<width; x++)
+						pixels[offset++] = ramp[x];
+				}
+				break;
+			case FILL_NOISE:
+				fillNoiseFloat(ip);
+				break;
+		}
+	    if (fill==FILL_WHITE)
+	    	ip.invertLut();
+		ImagePlus imp = new ImagePlus(title, ip);
+		if (slices>1) {
+			boolean ok = createStack(imp, ip, slices, GRAY32, options);
+			if (!ok) imp = null;
+		}
+		if (fill!=FILL_NOISE)
+			imp.getProcessor().setMinAndMax(0.0, 1.0); // default display range
+		return imp;
+	}
+
+	private static void fillNoiseFloat(ImageProcessor ip) {
+		ip.noise(1);
+	}
+
+	private static int getSize(int width, int height) {
+		long size = (long)width*height;
+		if (size>Integer.MAX_VALUE) {
+			IJ.error("Image is too large. ImageJ does not support\nsingle images larger than 2 gigapixels.");
+			return -1;
+		} else
+			return (int)size;
+	}
+
+	public static void open(String title, int width, int height, int nSlices, int type, int options) {
+		int bitDepth = 8;
+		if (type==GRAY16) bitDepth = 16;
+		else if (type==GRAY32) bitDepth = 32;
+		else if (type==RGB) bitDepth = 24;
+		long startTime = System.currentTimeMillis();
+		ImagePlus imp = createImage(title, width, height, nSlices, bitDepth, options);
+		if (imp!=null) {
+			WindowManager.checkForDuplicateName = true;          
+			imp.show();
+			IJ.showStatus(IJ.d2s(((System.currentTimeMillis()-startTime)/1000.0),2)+" seconds");
+		}
+	}
+
+	public static ImagePlus createImage(String title, int width, int height, int nSlices, int bitDepth, int options) {
+		ImagePlus imp = null;
+		switch (bitDepth) {
+			case 8: imp = createByteImage(title, width, height, nSlices, options); break;
+			case 16: imp = createShortImage(title, width, height, nSlices, options); break;
+			case 32: imp = createFloatImage(title, width, height, nSlices, options); break;
+			case 24:
+				if ((options&SIGNED_INT)!=0)
+					imp = createIntImage(title, width, height, nSlices, options);
+				else
+					imp = createRGBImage(title, width, height, nSlices, options);
+				break;
+			default: throw new IllegalArgumentException("Invalid bitDepth: "+bitDepth);
+		}
+		return imp;
+	}
+	
+	boolean showDialog() {
+		if (staticType<GRAY8|| staticType>RGB)
+			staticType = GRAY8;
+		if (staticFillWith<OLD_FILL_WHITE||staticFillWith>FILL_NOISE)
+			staticFillWith = FILL_WHITE;
+		GenericDialog gd = new GenericDialog("New Image...");
+		gd.addStringField("Name:", name, 12);
+		gd.addChoice("Type:", types, types[staticType]);
+		gd.addChoice("Fill with:", fill, fill[staticFillWith]);
+		gd.addNumericField("Width:", staticWidth, 0, 5, "pixels");
+		gd.addNumericField("Height:", staticHeight, 0, 5, "pixels");
+		gd.addNumericField("Slices:", staticSlices, 0, 5, "");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		name = gd.getNextString();
+		String s = gd.getNextChoice();
+		if (s.startsWith("8"))
+			gtype = GRAY8;
+		else if (s.startsWith("16"))
+			gtype = GRAY16;
+		else if (s.endsWith("RGB") || s.endsWith("rgb"))
+			gtype = RGB;
+		else
+			gtype = GRAY32;
+		gfill = gd.getNextChoiceIndex();
+		gwidth = (int)gd.getNextNumber();
+		gheight = (int)gd.getNextNumber();
+		gslices = (int)gd.getNextNumber();
+		if (gslices<1) gslices = 1;
+		if (gwidth<1 || gheight<1) {
+			IJ.error("New Image", "Width and height must be >0");
+			return false;
+		} else {
+			if (!IJ.isMacro()) {
+				staticWidth = gwidth;
+				staticHeight = gheight;
+				staticSlices = gslices;
+				staticType = gtype;
+				staticFillWith = gfill;
+			}
+			return true;
+		}
+	}
+
+	void openImage() {
+		if (!showDialog())
+			return;
+		try {
+			open(name, gwidth, gheight, gslices, gtype, gfill);
+		} catch(OutOfMemoryError e) {
+			IJ.outOfMemory("New Image...");
+		}
+	}
+	
+	/** Called when ImageJ quits. */
+	public static void savePreferences(Properties prefs) {
+		prefs.put(TYPE, Integer.toString(staticType));
+		prefs.put(FILL, Integer.toString(staticFillWith));
+		prefs.put(WIDTH, Integer.toString(staticWidth));
+		prefs.put(HEIGHT, Integer.toString(staticHeight));
+		prefs.put(SLICES, Integer.toString(staticSlices));
+	}
+
+}
diff --git a/src/ij/gui/NonBlockingGenericDialog.java b/src/ij/gui/NonBlockingGenericDialog.java
new file mode 100644
index 0000000..55dc6b3
--- /dev/null
+++ b/src/ij/gui/NonBlockingGenericDialog.java
@@ -0,0 +1,102 @@
+package ij.gui;
+import ij.*;
+import java.awt.event.*;
+import java.awt.EventQueue;
+import java.awt.GraphicsEnvironment;
+import java.awt.Frame;
+
+/** This is an extension of GenericDialog that is non-modal.
+ *	@author Johannes Schindelin
+ */
+public class NonBlockingGenericDialog extends GenericDialog {
+	ImagePlus imp;                  //when non-null, this dialog gets closed when the image is closed
+	WindowListener windowListener;  //checking for whether the associated window gets closed
+
+	public NonBlockingGenericDialog(String title) {
+		super(title, null);
+		setModal(false);
+		IJ.protectStatusBar(false);
+		instance = this;
+	}
+
+	public synchronized void showDialog() {
+		super.showDialog();
+		if (isMacro())
+			return;
+		if (!IJ.macroRunning()) {   // add to Window menu on event dispatch thread
+			final NonBlockingGenericDialog thisDialog = this;
+			EventQueue.invokeLater(new Runnable() {
+				public void run() {
+					WindowManager.addWindow(thisDialog);
+				}
+			});
+		}
+		if (imp != null) {
+			ImageWindow win = imp.getWindow();
+			if (win != null) {      //when the associated image closes, also close the dialog
+				final NonBlockingGenericDialog gd = this;
+				windowListener = new WindowAdapter() {
+					public void windowClosed(WindowEvent e) {
+						cancelDialogAndClose();
+					}
+				};
+				win.addWindowListener(windowListener);
+			}
+		}
+		try {
+			wait();
+		} catch (InterruptedException e) { }
+	}
+
+	/** Gets called if the associated image window is closed */
+	private void cancelDialogAndClose() {
+		super.windowClosing(null);	// sets wasCanceled=true and does dispose()
+	}
+
+	public synchronized void actionPerformed(ActionEvent e) {
+		super.actionPerformed(e);
+		if (!isVisible())
+			notify();
+	}
+
+	public synchronized void keyPressed(KeyEvent e) {
+		super.keyPressed(e);
+		if (wasOKed() || wasCanceled())
+			notify();
+	}
+
+    public synchronized void windowClosing(WindowEvent e) {
+		super.windowClosing(e);
+		if (wasOKed() || wasCanceled())
+			notify();
+    }
+
+	public void dispose() {
+		super.dispose();
+		WindowManager.removeWindow(this);
+		if (imp != null) {
+			ImageWindow win = imp.getWindow();
+			if (win != null && windowListener != null)
+				win.removeWindowListener(windowListener);
+		}
+	}
+
+	/** Obsolete, replaced by GUI.newNonBlockingDialog(String,ImagePlus). */
+	public static GenericDialog newDialog(String title, ImagePlus imp) {
+		return GUI.newNonBlockingDialog(title, imp);
+	}
+
+	/** Obsolete, replaced by GUI.newNonBlockingDialog(String). */
+	public static GenericDialog newDialog(String title) {
+		return GUI.newNonBlockingDialog(title);
+	}
+
+	/** Put the dialog into the foreground when the image we work on gets into the foreground */
+	@Override
+	public void windowActivated(WindowEvent e) {
+		if ((e.getWindow() instanceof ImageWindow) && e.getOppositeWindow()!=this)
+			toFront();
+		WindowManager.setWindow(this);
+	}
+
+}
diff --git a/src/ij/gui/OvalRoi.java b/src/ij/gui/OvalRoi.java
new file mode 100644
index 0000000..7923313
--- /dev/null
+++ b/src/ij/gui/OvalRoi.java
@@ -0,0 +1,430 @@
+package ij.gui;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.geom.*;
+import ij.*;
+import ij.process.*;
+import ij.measure.Calibration;
+
+/** Oval region of interest */
+public class OvalRoi extends Roi {
+
+	/** Creates an OvalRoi.*/
+	public OvalRoi(int x, int y, int width, int height) {
+		super(x, y, width, height);
+		type = OVAL;
+	}
+
+	/** Creates an OvalRoi using double arguments.*/
+	public OvalRoi(double x, double y, double width, double height) {
+		super(x, y, width, height);
+		type = OVAL;
+	}
+	
+	/** Creates an OvalRoi. */
+	public static OvalRoi create(double x, double y, double width, double height) {
+		return new OvalRoi(x, y, width, height);
+	}
+
+	/** Starts the process of creating a user-defined OvalRoi. */
+	public OvalRoi(int x, int y, ImagePlus imp) {
+		super(x, y, imp);
+		type = OVAL;
+	}
+
+	/** @deprecated */
+		public OvalRoi(int x, int y, int width, int height, ImagePlus imp) {
+		this(x, y, width, height);
+		setImage(imp);
+	}
+
+	/** Feret (caliper width) values, see ij.gui.Roi.getFeretValues().
+	 *  The superclass method of calculating this via the convex hull is less accurate for the MinFeret
+	 *  because it does not get the exact minor axis. */
+	public double[] getFeretValues() {
+		double[] a = new double[FERET_ARRAYSIZE];
+		double pw=1.0, ph=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		}
+		boolean highAspect = ph*height > pw*width;
+		a[0] = highAspect ? height*ph : width*pw;            // (max)Feret
+		a[1] = highAspect ?    90.0   :   0.0;               // (max)Feret angle
+		a[2] = highAspect ? width*pw  : height*ph;           //  MinFeret
+		a[3] = (x + (highAspect ? 0.5*width : 0)) * pw;      //FeretX scaled
+		a[4] = (y + (highAspect ? height : 0.5*height)) * ph;//FeretY scaled
+		int i = FERET_ARRAY_POINTOFFSET;
+		a[i++] = x + (highAspect ? 0.5*width : 0);           //MaxFeret start
+		a[i++] = y + (highAspect ? height : 0.5*height);
+		a[i++] = x + (highAspect ? 0.5*width : width);       //MaxFeret end
+		a[i++] = y + (highAspect ? 0 : 0.5*height);
+		a[i++] = x + (highAspect ? 0 : 0.5*width);           //MinFeret start
+		a[i++] = y + (highAspect ? 0.5*height : height);
+		a[i++] = x + (highAspect ? width : 0.5*width);       //MinFeret end
+		a[i++] = y + (highAspect ? 0.5*height : 0);
+		return a;
+	}
+
+	protected void moveHandle(int sx, int sy) {
+		double asp;
+		if (clipboard!=null) return;
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		//IJ.log("moveHandle: "+activeHandle+" "+ox+" "+oy);
+		int x1=x, y1=y, x2=x+width, y2=y+height, xc=x+width/2, yc=y+height/2;
+		int w2 = (int)(0.14645*width);
+		int h2 = (int)(0.14645*height);
+		if (width > 7 && height > 7) {
+			asp = (double)width/(double)height;
+			asp_bk = asp;
+		} else
+			asp = asp_bk;
+		switch (activeHandle) {
+			case 0: x=ox-w2; y=oy-h2; break;
+			case 1: y=oy; break;
+			case 2: x2=ox+w2; y=oy-h2; break;
+			case 3: x2=ox; break;			
+			case 4: x2=ox+w2; y2=oy+h2; break;
+			case 5: y2=oy; break;
+			case 6: x=ox-w2; y2=oy+h2; break;
+			case 7: x=ox; break;
+		}
+		//if (x<0) x=0; if (y<0) y=0;
+		if (x<x2)
+		   width=x2-x;
+		else
+		  {width=1; x=x2;}
+		if (y<y2)
+		   height = y2-y;
+		else
+		   {height=1; y=y2;}
+		if (center) {
+			switch(activeHandle){
+				case 0:
+					width=(xc-x)*2;
+					height=(yc-y)*2;
+					break;
+				case 1:
+					height=(yc-y)*2;
+					break;
+				case 2:
+					width=(x2-xc)*2;
+					x=x2-width;
+					height=(yc-y)*2;
+					break;
+				case 3:
+					width=(x2-xc)*2;
+					x=x2-width;
+					break;
+				case 4:
+					width=(x2-xc)*2;
+					x=x2-width;
+					height=(y2-yc)*2;
+					y=y2-height;
+					break;
+				case 5:
+					height=(y2-yc)*2;
+					y=y2-height;
+					break;
+				case 6:
+					width=(xc-x)*2;
+					height=(y2-yc)*2;
+					y=y2-height;
+					break;
+				case 7:
+					width=(xc-x)*2;
+					break;
+			}
+			if (x>=x2) {
+				width=1;
+				x=x2=xc;
+			}
+			if (y>=y2) {
+				height=1;
+				y=y2=yc;
+			}
+
+		}
+
+		if (constrain) {
+			if (activeHandle==1 || activeHandle==5) width=height;
+			else height=width;
+			
+			if (x>=x2) {
+				width=1;
+				x=x2=xc;
+			}
+			if (y>=y2) {
+				height=1;
+				y=y2=yc;
+			}
+			switch(activeHandle){
+				case 0:
+					x=x2-width;
+					y=y2-height;
+					break;
+				case 1:
+					x=xc-width/2;
+					y=y2-height;
+					break;
+				case 2:
+					y=y2-height;
+					break;
+				case 3:
+					y=yc-height/2;
+					break;
+				case 5:
+					x=xc-width/2;
+					break;
+				case 6:
+					x=x2-width;
+					break;
+				case 7:
+					y=yc-height/2;
+					x=x2-width;
+					break;
+			}
+			if (center){
+				x=xc-width/2;
+				y=yc-height/2;
+			}
+		}
+
+		if (aspect && !constrain) {
+			if (activeHandle==1 || activeHandle==5) width=(int)Math.rint((double)height*asp);
+			else height=(int)Math.rint((double)width/asp);
+
+			switch (activeHandle) {
+				case 0:
+					x=x2-width;
+					y=y2-height;
+					break;
+				case 1:
+					x=xc-width/2;
+					y=y2-height;
+					break;
+				case 2:
+					y=y2-height;
+					break;
+				case 3:
+					y=yc-height/2;
+					break;
+				case 5:
+					x=xc-width/2;
+					break;
+				case 6:
+					x=x2-width;
+					break;
+				case 7:
+					y=yc-height/2;
+					x=x2-width;
+					break;
+			}
+			if (center) {
+				x=xc-width/2;
+				y=yc-height/2;
+			}
+			// Attempt to preserve aspect ratio when roi very small:
+			if (width<8) {
+				if (width<1) width = 1;
+				height=(int)Math.rint((double)width/asp_bk);
+			}
+			if (height<8) {
+				if (height<1) height =1;
+				width=(int)Math.rint((double)height*asp_bk);
+			}
+		}
+
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX=x; oldY=y;
+		oldWidth=width; oldHeight=height;
+		cachedMask = null;
+		bounds = null;
+	}
+
+	public void draw(Graphics g) {
+		Color color =  strokeColor!=null? strokeColor:ROIColor;
+		if (fillColor!=null) color = fillColor;
+		g.setColor(color);
+		mag = getMagnification();
+		int sw = (int)(width*mag);
+		int sh = (int)(height*mag);
+		int sx1 = screenX(x);
+		int sy1 = screenY(y);
+		if (subPixelResolution() && bounds!=null) {
+			sw = (int)(bounds.width*mag);
+			sh = (int)(bounds.height*mag);
+			sx1 = screenXD(bounds.x);
+			sy1 = screenYD(bounds.y);
+		}
+		int sw2 = (int)(0.14645*width*mag);
+		int sh2 = (int)(0.14645*height*mag);
+		int sx2 = sx1+sw/2;
+		int sy2 = sy1+sh/2;
+		int sx3 = sx1+sw;
+		int sy3 = sy1+sh;
+		Graphics2D g2d = (Graphics2D)g;
+		if (stroke!=null) 
+			g2d.setStroke(getScaledStroke());
+		setRenderingHint(g2d);
+		if (fillColor!=null) {
+			if (!overlay && isActiveOverlayRoi()) {
+				g.setColor(Color.cyan);
+				g.drawOval(sx1, sy1, sw, sh);
+			} else
+				g.fillOval(sx1, sy1, sw, sh);
+		} else
+			g.drawOval(sx1, sy1, sw, sh);
+		if (clipboard==null && !overlay) {
+			drawHandle(g, sx1+sw2, sy1+sh2);
+			drawHandle(g, sx3-sw2, sy1+sh2);
+			drawHandle(g, sx3-sw2, sy3-sh2);
+			drawHandle(g, sx1+sw2, sy3-sh2);
+			drawHandle(g, sx2, sy1);
+			drawHandle(g, sx3, sy2);
+			drawHandle(g, sx2, sy3);
+			drawHandle(g, sx1, sy2);
+		}
+		drawPreviousRoi(g);
+		if (updateFullWindow)
+			{updateFullWindow = false; imp.draw();}
+		if (state!=NORMAL) showStatus();
+	}
+
+	/** Draws an outline of this OvalRoi on the image. */
+	public void drawPixels(ImageProcessor ip) {
+		Polygon p = getPolygon();
+		if (p.npoints>0) {
+			int saveWidth = ip.getLineWidth();
+			if (getStrokeWidth()>1f)
+				ip.setLineWidth((int)Math.round(getStrokeWidth()));
+			ip.drawPolygon(p);
+			ip.setLineWidth(saveWidth);
+		}
+		if (Line.getWidth()>1 || getStrokeWidth()>1)
+			updateFullWindow = true;
+	}		
+
+	/** Returns this OvalRoi as a Polygon that outlines the mask, in image pixel coordinates. */
+	public Polygon getPolygon() {
+		return getPolygon(true);
+	}
+
+	/** Returns this OvalRoi as a Polygon that outlines the mask.
+	 *  @param absoluteCoordinates determines whether to use image pixel coordinates
+	 *         instead of coordinates relative to roi origin. */
+	Polygon getPolygon(boolean absoluteCoordinates) {
+		ImageProcessor mask = getMask();
+		Wand wand = new Wand(mask);
+		wand.autoOutline(width/2,height/2, 255, 255);
+        if (absoluteCoordinates)
+			for (int i=0; i<wand.npoints; i++) {
+				wand.xpoints[i] += x;
+				wand.ypoints[i] += y;
+			}
+		return new Polygon(wand.xpoints, wand.ypoints, wand.npoints);
+	}		
+
+	/** Returns this OvalRoi as a FloatPolygon approximating the ellipse. */
+	public FloatPolygon getFloatPolygon() {
+		ShapeRoi sr = new ShapeRoi(new java.awt.geom.Ellipse2D.Double(x-0.0004, y-0.0004, width+0.0008, height+0.0008));  //better accuracy with slightly increased size
+		return sr.getFloatPolygon();
+	}
+
+	/** Returns the number of corner points in the mask of this selection; equivalent to getPolygon().npoints. */
+	public int size() {
+		return getPolygon().npoints;
+	}
+
+	/** Tests whether the center of the specified pixel is inside the boundary of this OvalRoi.
+	 *  Authors: Barry DeZonia and Michael Schmid
+	 */
+	public boolean contains(int ox, int oy) {
+		double a = width*0.5;
+		double b = height*0.5;
+		double cx = x + a - 0.5;
+		double cy = y + b - 0.5;
+		double dx = ox - cx;
+		double dy = oy - cy;
+		return ((dx*dx)/(a*a) + (dy*dy)/(b*b)) <= 1.0;
+	}
+
+	/** Returns whether coordinate (x,y) is contained in the Roi.
+	 *  Note that the coordinate (0,0) is the top-left corner of pixel (0,0).
+	 *  Use contains(int, int) to determine whether a given pixel is contained in the Roi. */
+	public boolean containsPoint(double x, double y) {
+		if (!super.containsPoint(x, y))
+			return false;
+		Ellipse2D.Double e = new Ellipse2D.Double(this.x, this.y, width, height);
+		return e.contains(x, y);
+	}
+
+	/** Returns a handle number if the specified screen coordinates are  
+		inside or near a handle, otherwise returns -1. */
+	public int isHandle(int sx, int sy) {
+		if (clipboard!=null || ic==null) return -1;
+		double mag = ic.getMagnification();
+		int size = getHandleSize()+3;
+		int halfSize = size/2;
+		int sx1 = screenX(x) - halfSize;
+		int sy1 = screenY(y) - halfSize;
+		int sx3 = screenX(x+width) - halfSize;
+		int sy3 = screenY(y+height) - halfSize;
+		int sx2 = sx1 + (sx3 - sx1)/2;
+		int sy2 = sy1 + (sy3 - sy1)/2;
+		
+		int sw2 = (int)(0.14645*(sx3-sx1));
+		int sh2 = (int)(0.14645*(sy3-sy1));
+		
+		if (sx>=sx1+sw2&&sx<=sx1+sw2+size&&sy>=sy1+sh2&&sy<=sy1+sh2+size) return 0;
+		if (sx>=sx2&&sx<=sx2+size&&sy>=sy1&&sy<=sy1+size) return 1;		
+		if (sx>=sx3-sw2&&sx<=sx3-sw2+size&&sy>=sy1+sh2&&sy<=sy1+sh2+size) return 2;		
+		if (sx>=sx3&&sx<=sx3+size&&sy>=sy2&&sy<=sy2+size) return 3;		
+		if (sx>=sx3-sw2&&sx<=sx3-sw2+size&&sy>=sy3-sh2&&sy<=sy3-sh2+size) return 4;		
+		if (sx>=sx2&&sx<=sx2+size&&sy>=sy3&&sy<=sy3+size) return 5;		
+		if (sx>=sx1+sw2&&sx<=sx1+sw2+size&&sy>=sy3-sh2&&sy<=sy3-sh2+size) return 6;
+		if (sx>=sx1&&sx<=sx1+size&&sy>=sy2&&sy<=sy2+size) return 7;
+		return -1;
+	}
+
+	public ImageProcessor getMask() {
+		ImageProcessor mask = cachedMask;
+		if (mask!=null && mask.getPixels()!=null && mask.getWidth()==width && mask.getHeight()==height)
+			return mask;
+		mask = new ByteProcessor(width, height);
+		double a=width/2.0, b=height/2.0;
+		double a2=a*a, b2=b*b;
+        a -= 0.5; b -= 0.5;
+		double xx, yy;
+        int offset;
+        byte[] pixels = (byte[])mask.getPixels();
+		for (int y=0; y<height; y++) {
+            offset = y*width;
+			for (int x=0; x<width; x++) {
+				xx = x - a;
+				yy = y - b;   
+				if ((xx*xx/a2+yy*yy/b2)<=1.0)
+					pixels[offset+x] = -1;
+			}
+		}
+		cachedMask = mask;
+		return mask;
+	}
+
+	/** Returns the perimeter length using Ramanujan's approximation for the circumference of an ellipse */
+	public double getLength() {
+		double pw=1.0, ph=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		}
+		double a = 0.5*width*pw;
+		double b = 0.5*height*ph;
+		return Math.PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b)));
+	}
+		
+}
diff --git a/src/ij/gui/Overlay.java b/src/ij/gui/Overlay.java
new file mode 100644
index 0000000..e3b0124
--- /dev/null
+++ b/src/ij/gui/Overlay.java
@@ -0,0 +1,582 @@
+package ij.gui;
+import java.awt.*;
+import java.util.Vector;
+import java.awt.geom.Rectangle2D;
+import java.util.*;
+import ij.*;
+import ij.process.ImageProcessor;
+import ij.plugin.filter.*;
+import ij.plugin.*;
+import ij.measure.ResultsTable;
+
+/** An Overlay is a list of ROIs that can be drawn non-destructively on an Image. */
+public class Overlay implements Iterable<Roi> {
+	private Vector<Roi> list;
+    private boolean label;
+    private boolean drawNames;
+    private boolean drawBackgrounds;
+    private Color labelColor;
+    private Font labelFont;
+    private boolean scalableLabels;
+    private boolean isCalibrationBar;
+    private boolean selectable = true;
+    private boolean draggable = true;
+    
+    /** Constructs an empty Overlay. */
+    public Overlay() {
+    	list = new Vector<Roi>();
+    }
+    
+    /** Constructs an Overlay and adds the specified ROI. */
+    public Overlay(Roi roi) {
+    	list = new Vector<Roi>();
+    	if (roi!=null)
+    		list.add(roi);
+    }
+
+    /** Adds an ROI to this Overlay. */
+    public void add(Roi roi) {
+    	if (roi!=null)
+    		list.add(roi);
+    }
+        
+    /** Adds an ROI to this Overlay using the specified name. */
+	public void add(Roi roi, String name) {
+		roi.setName(name);
+		add(roi);
+	}
+
+    /** Adds an ROI to this Overlay. */
+    public void addElement(Roi roi) {
+    	if (roi!=null)
+    		list.add(roi);
+    }
+
+    /** Replaces the ROI at the specified index. */
+    public void set(Roi roi, int index) {
+    	if (index<0 || index>=list.size())
+    		throw new IllegalArgumentException("set: index out of range");
+    	if (roi!=null)
+    		list.set(index, roi);
+    }
+
+    /** Removes the ROI with the specified index from this Overlay. */
+    public void remove(int index) {
+    	if (index>=0)
+    		list.remove(index);
+    }
+    
+    /** Removes the specified ROI from this Overlay. */
+    public void remove(Roi roi) {
+    	list.remove(roi);
+    }
+
+    /** Removes all ROIs that have the specified name. */
+	public void remove(String name) {
+		if (name==null) return;
+		for (int i=size()-1; i>=0; i--) {
+			if (name.equals(get(i).getName()))
+				remove(i);
+		}
+	}
+
+   /** Removes all the ROIs in this Overlay. */
+    public void clear() {
+    	list.clear();
+    }
+
+    /** Returns the ROI with the specified index or null if the index is invalid. */
+    public Roi get(int index) {
+    	try {
+    		return (Roi)list.get(index);
+    	} catch(Exception e) {
+    		return null;
+    	}
+    }
+    
+    /** Returns the ROI with the specified name or null if not found. */
+    public Roi get(String name) {
+    	int index = getIndex(name);
+    	if (index==-1)
+    		return null;
+    	else
+    		return get(index);   		
+    }
+
+    /** Returns the index of the ROI with the specified name, or -1 if not found. */
+    public int getIndex(String name) {
+    	if (name==null) return -1;
+    	Roi[] rois = toArray();
+		for (int i=rois.length-1; i>=0; i--) {
+			if (name.equals(rois[i].getName()))
+				return i;
+		}
+		return -1;
+    }
+    
+    /** Returns the index of the last ROI that contains the point (x,y)
+    	or null if no ROI contains the point. */
+    public int indexAt(int x, int y) {
+     	Roi[] rois = toArray();
+		for (int i=rois.length-1; i>=0; i--) {
+			if (contains(rois[i],x,y))
+				return i;
+		}
+		return -1;
+    }
+    
+	private boolean contains(Roi roi, int x, int y) {
+		if (roi==null) return false;
+		if (roi instanceof Line)
+			return  (((Line)roi).getFloatPolygon(10)).contains(x,y);
+		else
+			return roi.contains(x,y);
+	}
+	
+    /** Returns 'true' if this Overlay contains the specified ROI. */
+    public boolean contains(Roi roi) {
+    	return list.contains(roi);
+    }
+
+    /** Returns the number of ROIs in this Overlay. */
+    public int size() {
+    	return list.size();
+    }
+    
+    /** Returns on array containing the ROIs in this Overlay. */
+    public Roi[] toArray() {
+    	Roi[] array = new Roi[list.size()];
+    	return (Roi[])list.toArray(array);
+    }
+    
+    /** Returns on array containing the ROIs with the specified indexes. */
+    public Roi[] toArray(int[] indexes) {
+		ArrayList rois = new ArrayList();
+		for (int i=0; i<size(); i++) {
+			if (indexes[i]>=0 && indexes[i]<size())
+				rois.add(get(indexes[i]));
+		}
+		return (Roi[])rois.toArray(new Roi[rois.size()]);
+	}
+
+    /** Sets the stroke color of all the ROIs in this overlay. */
+    public void setStrokeColor(Color color) {
+		for (int i=0; i<size(); i++)
+			get(i).setStrokeColor(color);
+	}
+
+    /** Sets the stroke width of all the ROIs in this overlay. */
+    public void setStrokeWidth(Double width) {
+		for (int i=0; i<size(); i++)
+			get(i).setStrokeWidth(width);
+	}
+
+    /** Sets the fill color of all the ROIs in this overlay. */
+    public void setFillColor(Color color) {
+		for (int i=0; i<size(); i++)
+			get(i).setFillColor(color);
+	}
+
+	/** Moves all the ROIs in this overlay. */
+	public void translate(int dx, int dy) {
+		for (int i=0; i<size(); i++) {
+			Roi roi = get(i);
+			if (roi.subPixelResolution()) {
+				Rectangle2D r = roi.getFloatBounds();
+				roi.setLocation(r.getX()+dx, r.getY()+dy);
+			} else {
+				Rectangle r = roi.getBounds();
+				roi.setLocation(r.x+dx, r.y+dy);
+			}
+		}
+	}
+
+	/** Moves all the ROIs in this overlay.
+	* Marcel Boeglin, October 2013
+	*/
+	public void translate(double dx, double dy) {
+		boolean intArgs = (int)dx==dx && (int)dy==dy;
+		for (int i=0; i<size(); i++) {
+			Roi roi = get(i);
+			if (roi.subPixelResolution() || !intArgs) {
+				Rectangle2D r = roi.getFloatBounds();
+				roi.setLocation(r.getX()+dx, r.getY()+dy);
+			} else {
+				Rectangle r = roi.getBounds();
+				roi.setLocation(r.x+(int)dx, r.y+(int)dy);
+			}
+		}
+	}
+	
+	/** Measures the ROIs in this overlay on the specified image
+	* and returns the results as a ResultsTable.
+	*/
+	public ResultsTable measure(ImagePlus imp) {
+		ResultsTable rt = new ResultsTable();
+		rt.showRowNumbers(true);
+		Analyzer analyzer = new Analyzer(imp, rt);
+		for (int i=0; i<size(); i++) {
+			Roi roi = get(i);
+			imp.setRoi(roi);
+			analyzer.measure();
+		}
+		imp.deleteRoi();
+		return rt;
+	}
+
+	/*
+	* Duplicate the elements of this overlay which  
+	* intersect with the rectangle 'bounds'.
+	* Author: Wilhelm Burger
+	* Author: Marcel Boeglin
+	*/
+	public Overlay crop(Rectangle bounds) {
+		if (bounds==null)
+			return duplicate();
+		Overlay overlay2 = create();
+		Roi[] allRois = toArray();
+		for (Roi roi: allRois) {
+			Rectangle roiBounds = roi.getBounds();
+			if (roiBounds.width==0) roiBounds.width=1;
+			if (roiBounds.height==0) roiBounds.height=1;
+			if (bounds.intersects(roiBounds))
+				overlay2.add((Roi)roi.clone());
+		}
+		int dx = bounds.x>0?bounds.x:0;
+		int dy = bounds.y>0?bounds.y:0;
+		if (dx>0 || dy>0)
+			overlay2.translate(-dx, -dy);
+		return overlay2;
+	}
+
+	/** Removes ROIs having positions outside of the  
+	* interval defined by firstSlice and lastSlice.
+	* Marcel Boeglin, September 2013
+	*/
+	public void crop(int firstSlice, int lastSlice) {
+		for (int i=size()-1; i>=0; i--) {
+			Roi roi = get(i);
+			int position = roi.getPosition();
+			if (position>0) {
+				if (position<firstSlice || position>lastSlice)
+					remove(i);
+				else
+					roi.setPosition(position-firstSlice+1);
+			}
+		}
+	}
+
+	/** Removes ROIs having a C, Z or T coordinate outside the volume
+	* defined by firstC, lastC, firstZ, lastZ, firstT and lastT.
+	* Marcel Boeglin, September 2013
+	*/
+	public void crop(int firstC, int lastC, int firstZ, int lastZ, int firstT, int lastT) {
+		int nc = lastC-firstC+1, nz = lastZ-firstZ+1, nt = lastT-firstT+1;
+		boolean toCStack = nz==1 && nt==1;
+		boolean toZStack = nt==1 && nc==1;
+		boolean toTStack = nc==1 && nz==1;
+		Roi roi;
+		int c, z, t, c2, z2, t2;
+		for (int i=size()-1; i>=0; i--) {
+			roi = get(i);
+			c = roi.getCPosition();
+			z = roi.getZPosition();
+			t = roi.getTPosition();
+			c2 = c-firstC+1;
+			z2 = z-firstZ+1;
+			t2 = t-firstT+1;
+			if (toCStack)
+				roi.setPosition(c2);
+			else if (toZStack)
+				roi.setPosition(z2);
+			else if (toTStack)
+				roi.setPosition(t2);
+			else
+				roi.setPosition(c2, z2, t2);
+			if ((c2<1||c2>nc) && c>0 || (z2<1||z2>nz) && z>0 || (t2<1||t2>nt) && t>0)
+				remove(i);
+		}
+	}
+
+    /** Returns the bounds of this overlay. */
+    /*
+    public Rectangle getBounds() {
+    	if (size()==0)
+    		return new Rectangle(0,0,0,0);
+    	int xmin = Integer.MAX_VALUE;
+    	int xmax = -Integer.MAX_VALUE;
+    	int ymin = Integer.MAX_VALUE;
+    	int ymax = -Integer.MAX_VALUE;
+		Roi[] rois = toArray();
+		for (int i=0; i<rois.length; i++) {
+			Rectangle r = rois[i].getBounds();
+			if (r.x<xmin) xmin = r.x;
+			if (r.y<ymin) ymin = r.y;
+			if (r.x+r.width>xmax) xmax = r.x+r.width;
+			if (r.y+r.height>ymax) ymax = r.y+r.height;
+		}
+		return new Rectangle(xmin, ymin, xmax-xmin, ymax-ymin);
+	}
+	*/
+	
+	/* Returns the Roi that results from XORing all the ROIs
+	 * in this overlay that have an index in the array ‘indexes’.
+	*/
+	public Roi xor(int[] indexes) {
+		return Roi.xor(toArray(indexes));
+	}
+
+	/** Returns a new Overlay that has the same properties as this one. */
+	public Overlay create() {
+		Overlay overlay2 = new Overlay();
+		overlay2.drawLabels(label);
+		overlay2.drawNames(drawNames);
+		overlay2.drawBackgrounds(drawBackgrounds);
+		overlay2.setLabelColor(labelColor);
+		overlay2.setLabelFont(labelFont, scalableLabels);
+		overlay2.setIsCalibrationBar(isCalibrationBar);
+		overlay2.selectable(selectable);
+		overlay2.setDraggable(draggable);
+		return overlay2;
+	}
+	
+	/** Returns a clone of this Overlay. */
+	public Overlay duplicate() {
+		Roi[] rois = toArray();
+		Overlay overlay2 = create();
+		for (int i=0; i<rois.length; i++)
+			overlay2.add((Roi)rois[i].clone());
+		return overlay2;
+	}
+	
+	/** Returns a scaled version of this Overlay. */
+	public Overlay scale(double xscale, double yscale) {
+		Overlay overlay2 = create();
+		for (int i=0; i<size(); i++) {
+			Roi roi = get(i);
+			int position = roi.getPosition();
+			roi = RoiScaler.scale(roi, xscale, yscale, false);
+			roi.setPosition(position);
+			overlay2.add(roi);
+		}
+		return overlay2;
+	}
+
+ 	/** Returns a rotated version of this Overlay. */
+	public Overlay rotate(double angle, double xcenter, double ycenter) {
+		//IJ.log("rotate: "+angle+" "+xcenter+" "+ycenter);
+		Overlay overlay2 = create();
+		for (int i=0; i<size(); i++) {
+			Roi roi = get(i);
+			int position = roi.getPosition();
+			if (!Rotator.GRID.equals(roi.getName()))
+				roi = RoiRotator.rotate(roi, angle, xcenter, ycenter);
+			roi.setPosition(position);
+			overlay2.add(roi);
+		}
+		return overlay2;
+	}
+
+   public void drawLabels(boolean b) {
+    	label = b;
+    }
+    
+    public boolean getDrawLabels() {
+    	return label;
+    }
+    
+    public void drawNames(boolean b) {
+    	drawNames = b;
+		Roi[] rois = toArray();
+		for (int i=0; i<rois.length; i++)
+			rois[i].setIgnoreClipRect(drawNames);
+    }
+    
+    public boolean getDrawNames() {
+    	return drawNames;
+    }
+
+    public void drawBackgrounds(boolean b) {
+    	drawBackgrounds = b;
+    }
+    
+    public boolean getDrawBackgrounds() {
+    	return drawBackgrounds;
+    }
+
+    public void setLabelColor(Color c) {
+    	labelColor = c;
+    }
+    
+    public Color getLabelColor() {
+    	return labelColor;
+    }
+
+    public void setLabelFont(Font font) {
+    	setLabelFont(font, false);
+    }
+    
+    public void setLabelFont(Font font, boolean scalable) {
+    	labelFont = font;
+    	scalableLabels = scalable;
+    }
+
+    /** Set the label font size with options. The options string can contain
+     * 'scale' (enlarge labels when image zoomed), 'bold'
+     * (display bold labels) or 'background' (display labels
+     * with contrasting background.
+    */
+    public void setLabelFontSize(int size, String options) {
+    	int style = Font.PLAIN;
+    	if (options!=null) {
+    		scalableLabels = options.contains("scale");
+    		if (options.contains("bold"))
+    			style = Font.BOLD;
+    		drawBackgrounds = options.contains("back");
+    	}
+    	labelFont = new Font("SansSerif", style, size);
+    	drawLabels(true);
+    }
+
+    public Font getLabelFont() {
+    	return labelFont;
+    }
+
+    public void setIsCalibrationBar(boolean b) {
+    	this.isCalibrationBar = b;
+    }
+    
+    public boolean isCalibrationBar() {
+    	return isCalibrationBar;
+    }
+    
+    /** Fills all the ROIs in this overlay with 'foreground' after clearing the
+    	the image to 'background' if it is not null. */
+    public void fill(ImagePlus imp, Color foreground, Color background) {
+    	ImageProcessor ip = imp.getProcessor();
+		if (background!=null) {
+			ip.resetRoi();
+			ip.setColor(background);
+			ip.fillRect(0,0,ip.getWidth(),ip.getHeight());
+		}
+		if (foreground!=null) {
+			ip.setColor(foreground);
+			for (int i=0; i<size(); i++)
+				ip.fill(get(i));
+			ip.resetRoi();
+		}
+		imp.updateAndDraw();
+    }
+
+    void setVector(Vector<Roi> v) {list = v;}
+        
+    Vector<Roi> getVector() {return list;}
+    
+    /** Set 'false' to prevent ROIs in this overlay from being activated 
+		by clicking on their labels or by a long clicking. */ 
+    public void selectable(boolean selectable) {
+    	this.selectable = selectable;
+    }
+    
+    /** Returns 'true' if ROIs in this overlay can be activated
+		by clicking on their labels or by a long press. */ 
+	public boolean isSelectable() {
+		return selectable;
+	}
+	
+    /** Set 'false' to prevent ROIs in this overlay from being dragged by their labels. */ 
+    public void setDraggable(boolean draggable) {
+    	this.draggable = draggable;
+    }
+    
+    /** Returns 'true' if ROIs in this overlay can be dragged by their labels. */
+	public boolean isDraggable() {
+		return draggable;
+	}
+
+ 	public boolean scalableLabels() {
+		return scalableLabels;
+	}
+	
+	public String toString() {
+    	return "Overlay[size="+size()+" "+(scalableLabels?"scale":"")+" "+Colors.colorToString(getLabelColor())+"]";
+    }
+    
+    /** Updates overlays created by the particle analyzer
+    	after rows are deleted from the Results table. */
+    public static void updateTableOverlay(ImagePlus imp, int first, int last, int tableSize) {
+		if (imp==null)
+			return;
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			return;
+		if (overlay.size()!=tableSize)
+			return;
+		if (first<0)
+			first = 0;
+		if (last>tableSize-1)
+			last = tableSize-1;
+		if (first>last)
+			return;
+		String name1 = overlay.get(0).getName();
+		String name2 = overlay.get(overlay.size()-1).getName();
+		if (!"1".equals(name1) || !(""+tableSize).equals(name2))
+			return;
+		int count = last-first+1;
+		if (overlay.size()==count && !IJ.isMacro()) {
+			if (count==1 || IJ.showMessageWithCancel("ImageJ", "Delete "+overlay.size()+" element overlay?  "))
+				imp.setOverlay(null);
+			return;
+		}
+		for (int i=0; i<count; i++)
+			overlay.remove(first);
+		for (int i=first; i<overlay.size(); i++)
+			overlay.get(i).setName(""+(i+1));
+		imp.draw();
+	}
+	
+	public static Overlay createStackOverlay(Roi[] rois) {
+		Overlay overlay = new Overlay();
+		for (int i=0; i<rois.length; i++) {
+			Roi roi = (Roi)rois[i].clone();
+			roi.setLocation(0,0);
+			roi.setPosition(i+1);
+			overlay.add(roi);
+		}
+		return overlay;
+	}
+	
+	@Override
+	public Iterator<Roi> iterator() {
+		final Overlay overlay = this;
+
+		Iterator<Roi> it = new Iterator<Roi>() {
+			private int index = -1;
+
+			/** Returns 'true' if next element exists. */ 
+			@Override
+			public boolean hasNext() {
+				if (index+1<overlay.size()) 
+					return true;
+				else 
+					return false;
+			}
+
+			/** Returns current ROI and updates pointer. */
+			@Override
+			public Roi next() {
+				if (index+1<overlay.size())
+					return overlay.get(++index);
+				else
+					return null;
+			} 
+
+			@Override
+			public void remove() { 
+				throw new UnsupportedOperationException(); 
+			}
+		};
+		return it;
+	}
+    
+}
diff --git a/src/ij/gui/Plot.java b/src/ij/gui/Plot.java
new file mode 100644
index 0000000..50f1353
--- /dev/null
+++ b/src/ij/gui/Plot.java
@@ -0,0 +1,4379 @@
+package ij.gui;
+import java.awt.*;
+import java.util.*;
+import java.io.*;
+import java.lang.reflect.Method;
+import java.awt.geom.Point2D;
+import ij.*;
+import ij.process.*;
+import ij.util.*;
+import ij.plugin.Colors;
+import ij.plugin.filter.Analyzer;
+import ij.macro.Interpreter;
+import ij.measure.Calibration;
+import ij.measure.Measurements;
+import ij.measure.ResultsTable;
+
+/** This class creates an image that line graphs, scatter plots and plots of vector fields
+ *	(arrows) can be drawn on and displayed.
+ *
+ *	Note that the clone() operation is a shallow clone: objects like arrays, the PlotProperties,
+ *	PlotObjects, the ImagePlus etc. of the clone remain the same as those of the original.
+ *
+ * @author Wayne Rasband
+ * @author Philippe CARL, CNRS, philippe.carl (AT) unistra.fr (log axes, arrows, ArrayList data)
+ * @author Norbert Vischer (overlay range arrows, 'R'eset range, filled plots, dynamic plots, boxes and whiskers, superscript)
+ * @author Michael Schmid (axis grid/ticks, resizing/panning/changing range, high-resolution, serialization)
+ */
+public class Plot implements Cloneable {
+
+	/** Text justification. */
+	public static final int LEFT=ImageProcessor.LEFT_JUSTIFY, CENTER=ImageProcessor.CENTER_JUSTIFY, RIGHT=ImageProcessor.RIGHT_JUSTIFY;
+	/** Legend positions */
+	//NOTE: These have only bits of LEGEND_POSITION_MASK set. The flags of the legend are stored as flags of the legend PlotObject.
+	//These are saved in the flags of the PlotObject class; thus bits up to 0x0f are reserved
+	public static final int TOP_LEFT=0x90, TOP_RIGHT=0xA0, BOTTOM_LEFT=0xB0, BOTTOM_RIGHT=0xC0, AUTO_POSITION=0x80;
+	/** Masks out bits for legend positions; if all these bits are off, the legend is turned off */
+	static final int LEGEND_POSITION_MASK = 0xf0;
+	/** Legend has its curves in bottom-to-top sequence (otherwise top to bottom) */
+	public static final int LEGEND_BOTTOM_UP = 0x100;
+	/** Legend erases background (otherwise transparent) */
+	public static final int LEGEND_TRANSPARENT = 0x200;
+	/** Display points using a circle (5 pixels in diameter if line thickness<=1, otherwise 7). */
+	public static final int CIRCLE = 0;
+	/** Display points using an X-shaped mark. */
+	public static final int X = 1;
+	/** Connect points with solid lines. */
+	public static final int LINE = 2;
+	/** Display points using a square box-shaped mark. */
+	public static final int BOX = 3;
+	/** Display points using an tiangular mark. */
+	public static final int TRIANGLE = 4;
+	/** Display points using an cross-shaped mark. */
+	public static final int CROSS = 5;
+	/** Display points using a single pixel. */
+	public static final int DOT = 6;
+	/** Draw black lines between the dots and a circle with the given color at each dot */
+	public static final int CONNECTED_CIRCLES = 7;
+	/** Display points using an diamond-shaped mark. */
+	public static final int DIAMOND = 8;
+	/** Draw shape using macro code */
+	public static final int CUSTOM = 9;
+	/** Fill area between line plot and x-axis at y=0. */
+	public static final int FILLED = 10;
+	/** Draw a histogram bar for each point (bars touch each other unless the x axis has categories set via the axis label.
+	 *  x values should be sorted (ascending or descending) */
+	public static final int BAR = 11;
+	/** Draw a free-standing bar for each point. x values should be equidistant and sorted (ascending or descending) */
+	public static final int SEPARATED_BAR = 12;
+
+	/** Names for the shapes as an array */
+	final static String[] SHAPE_NAMES = new String[] {
+			"Circle", "X", "Line", "Box", "Triangle", "+", "Dot", "Connected Circles", "Diamond",
+			"Custom", "Filled", "Bar", "Separated Bars"};
+	/** Names in nicely sorting order for menus */
+	final static String[] SORTED_SHAPES = new String[] {
+			SHAPE_NAMES[LINE], SHAPE_NAMES[CONNECTED_CIRCLES], SHAPE_NAMES[FILLED], SHAPE_NAMES[BAR], SHAPE_NAMES[SEPARATED_BAR],
+			SHAPE_NAMES[CIRCLE], SHAPE_NAMES[BOX], SHAPE_NAMES[TRIANGLE], SHAPE_NAMES[CROSS],
+			SHAPE_NAMES[DIAMOND], SHAPE_NAMES[X], SHAPE_NAMES[DOT]};
+	/** flag for numeric labels of x-axis ticks */
+	public static final int X_NUMBERS = 0x1;
+	/** flag for numeric labels of x-axis ticks */
+	public static final int Y_NUMBERS = 0x2;
+	/** flag for drawing major ticks on linear (non-logarithmic) x axis */
+	public static final int X_TICKS = 0x4;
+	/** flag for drawing major ticks on linear (non-logarithmic) y axis */
+	public static final int Y_TICKS = 0x8;
+	/** flag for drawing vertical grid lines for x axis */
+	public static final int X_GRID = 0x10;
+	/** flag for drawing horizontal grid lines for y axis */
+	public static final int Y_GRID = 0x20;
+	/** flag for forcing frame to coincide with the grid/ticks in x direction (results in unused space) */
+	public static final int X_FORCE2GRID = 0x40;
+	/** flag for forcing frame to coincide with the grid/ticks in y direction (results in unused space) */
+	public static final int Y_FORCE2GRID = 0x80;
+	/** flag for drawing minor ticks on linear (non-logarithmic) x axis */
+	public static final int X_MINOR_TICKS = 0x100;
+	/** flag for drawing minor ticks on linear (non-logarithmic) y axis */
+	public static final int Y_MINOR_TICKS = 0x200;
+	/** flag for logarithmic x-axis */
+	public static final int X_LOG_NUMBERS = 0x400;
+	/** flag for logarithmic y axis */
+	public static final int Y_LOG_NUMBERS = 0x800;
+	/** flag for ticks (major and minor, if space) on logarithmic x axis */
+	public static final int X_LOG_TICKS = 0x1000;
+	/** flag for ticks (major and minor, if space) on logarithmic y axis */
+	public static final int Y_LOG_TICKS = 0x2000;
+	//leave 0x4000, 0x8000 reserved for broken axes?
+	/** The default axisFlags, will be modified by PlotWindow.noGridLines and PlotWindow.noTicks (see getDefaultFlags) */
+	public static final int DEFAULT_FLAGS =	 X_NUMBERS + Y_NUMBERS + /*X_TICKS + Y_TICKS +*/
+			X_GRID + Y_GRID + X_LOG_TICKS + Y_LOG_TICKS;
+
+	/** Flag for addressing the x axis, for copying from a template: copy/write x axis range. */
+	// This must be 0x1 because bit shift operations are used for the other axes
+	public static final int X_RANGE = 0x1;
+	/** Flag for addressing the y axis, for copying from a template: copy/write y axis range */
+	public static final int Y_RANGE = 0x2;
+	/** Flags for modifying the range of all axes */
+	static final int ALL_AXES_RANGE = X_RANGE | Y_RANGE;
+	//0x4, 0x8 reserved for secondary axes
+	/** Flag for copying from a template: copy plot size */
+	public static final int COPY_SIZE = 0x10;
+	/** Flag for copying from a template: copy style & text of axis labels */
+	public static final int COPY_LABELS = 0x20;
+	/** Flag for copying from a template: copy legend */
+	public static final int COPY_LEGEND = 0x40;
+	/** Flag for copying from a template: copy axis style */
+	public static final int COPY_AXIS_STYLE = 0x80;
+	/** Flag for copying from a template: copy contents style */
+	public static final int COPY_CONTENTS_STYLE = 0x100;
+	/** Flag for copying PlotObjects (curves...) from a template if the template has more PlotObjects than the Plot to copy to. */
+	public static final int COPY_EXTRA_OBJECTS = 0x200;
+
+	/** The default margin width left of the plot frame (enough for 5-digit numbers such as unscaled 16-bit
+	 *	@deprecated Not a fixed value any more, use getDrawingFrame() to get the drawing area */
+	public static final int LEFT_MARGIN = 65;
+	/** The default margin width right of the plot frame
+	 *	@deprecated Not a fixed value any more, use getDrawingFrame() to get the drawing area */
+	public static final int RIGHT_MARGIN = 18;
+	/** The default margin width above the plot frame
+	 *	@deprecated Not a fixed value any more, use getDrawingFrame() to get the drawing area */
+	public static final int TOP_MARGIN = 15;
+	/** The default margin width below the plot frame
+	 *	@deprecated Not a fixed value any more, use getDrawingFrame() to get the drawing area */
+	public static final int BOTTOM_MARGIN = 40;
+	/** minimum width of frame area in plot */
+	public static final int MIN_FRAMEWIDTH = 160;
+	/** minimum width of frame area in plot */
+	public static final int MIN_FRAMEHEIGHT = 90;
+	/** key in ImagePlus properties to access the plot behind an ImagePlus */
+	public static final String PROPERTY_KEY = "thePlot";
+
+	static final float DEFAULT_FRAME_LINE_WIDTH = 1.0001f; //Frame thickness
+	private static final int MIN_X_GRIDSPACING = 45;	//minimum distance between grid lines or ticks along x at plot width 0
+	private static final int MIN_Y_GRIDSPACING = 30;	//minimum distance between grid lines or ticks along y at plot height 0
+	private final double MIN_LOG_RATIO = 3;				//If max/min ratio is less than this, force linear axis even if log required. should be >2
+	private static final int LEGEND_PADDING = 4;		//pixels around legend text etc
+	private static final int LEGEND_LINELENGTH = 20;	//length of lines in legend
+	private static final int USUALLY_ENLARGE = 1, ALWAYS_ENLARGE = 2; //enlargeRange settings
+	private static final double RELATIVE_ARROWHEAD_SIZE = 0.2; //arrow heads have 1/5 of vector length
+	private static final int MIN_ARROWHEAD_LENGTH = 3;
+	private static final int MAX_ARROWHEAD_LENGTH = 20;
+	private static final String MULTIPLY_SYMBOL = "\u00B7"; //middot, default multiplication symbol for scientific notation. Use setOptions("msymbol=\\u00d7") for '×'
+
+	PlotProperties pp = new PlotProperties();		//size, range, formatting etc, for easy serialization
+	PlotProperties ppSnapshot;						//copy for reverting
+	Vector<PlotObject> allPlotObjects = new Vector<PlotObject>();	//all curves, labels etc., also serialized for saving/reading
+	Vector<PlotObject> allPlotObjectsSnapshot;      //copy for reverting
+	private PlotVirtualStack stack;
+	/** For high-resolution plots, everything will be scaled with this number. Otherwise, must be 1.0.
+	 *  (creating margins, saving PlotProperties etc only supports scale=1.0) */
+	float scale = 1.0f;
+	Rectangle frame = null;							//the clip frame, do not use for image scale
+	//The following are the margin sizes actually used. They are modified for font size and also scaled for high-resolution plots
+	int leftMargin = LEFT_MARGIN, rightMargin = RIGHT_MARGIN, topMargin = TOP_MARGIN, bottomMargin = BOTTOM_MARGIN;
+	int frameWidth;									//width corresponding to plot range; frame.width is larger by 1
+	int frameHeight;								//height corresponding to plot range; frame.height is larger by 1
+	int preferredPlotWidth = PlotWindow.plotWidth;  //default size of plot frame (not taking 'High-Resolution' scale factor into account)
+	int preferredPlotHeight = PlotWindow.plotHeight;
+
+	double xMin = Double.NaN, xMax, yMin, yMax;		//current plot range, logarithm if log axis
+	double[] currentMinMax = new double[]{Double.NaN, 0, Double.NaN, 0}; //current plot range, xMin, xMax, yMin, yMax (values, not logarithm if log axis)
+	double[] defaultMinMax = new double[]{Double.NaN, 0, Double.NaN, 0}; //default plot range
+	double[] savedMinMax = new double[]{Double.NaN, 0, Double.NaN, 0};	//keeps previous range for revert
+	int[] enlargeRange;                             // whether to enlarge the range slightly to avoid values at the border (0=off, USUALLY_ENLARGE, ALWAYS_ENLARGE)
+	boolean logXAxis, logYAxis;                     // whether to really use log axis (never for small relative range)
+	//for passing on what should be kept when 'live' plotting (PlotMaker), but note that 'COPY_EXTRA_OBJECTS' is also on for live plotting:
+	int templateFlags = COPY_SIZE | COPY_LABELS | COPY_AXIS_STYLE | COPY_CONTENTS_STYLE | COPY_LEGEND;
+	private int dsize = PlotWindow.getDefaultFontSize();
+	Font defaultFont = FontUtil.getFont("Arial",Font.PLAIN,dsize); //default font for labels, axis, etc.
+	Font currentFont = defaultFont;                 // font as changed by setFont or setFontSize, must never be null
+	private double xScale, yScale;                  // pixels per data unit
+	private int xBasePxl, yBasePxl;                 // pixel coordinates corresponding to 0
+	private int maxIntervals = 12;                  // maximum number of intervals between ticks or grid lines
+	private int tickLength = 7;                     // length of major ticks
+	private int minorTickLength = 3;                // length of minor ticks
+	private Color gridColor = new Color(0xc0c0c0);  // light gray
+	private ImageProcessor ip;
+	private ImagePlus imp;                          // if we have an ImagePlus, updateAndDraw on changes
+	private String title;
+	private boolean invertedLut;                    // grayscale plots only, set in Edit>Options>Appearance
+	private boolean plotDrawn;
+	PlotMaker plotMaker;                            // for PlotMaker interface, handled by PlotWindow
+	private Color currentColor;						// for next objects added
+	private Color currentColor2;					// 2nd color for next object added (e.g. line for CONNECTED_CIRCLES)
+	float currentLineWidth;
+	private int currentJustification = LEFT;
+	private boolean ignoreForce2Grid;               // after explicit setting of range (limits), ignore 'FORCE2GRID' flags
+	//private boolean snapToMinorGrid;  			// snap to grid when zooming to selection
+	private static double SEPARATED_BAR_WIDTH=0.5;  // for plots with separate bars (e.g. categories), fraction of space, 0.1-1.0
+	double[] steps;                                 // x & y interval between numbers, major ticks & grid lines, remembered for redrawing the grid
+	private int objectToReplace = -1;               // index in allPlotObjects, for replace
+	private Point2D.Double textLoc;                 // remembers position of previous addLabel call (replaces text if at the same position)
+	private int textIndex;                          // remembers index of previous addLabel call (for replacing if at the same position)
+
+	/** Constructs a new Plot with the default options.
+	 * Use add(shape,xvalues,yvalues) to add curves.
+	 * @param title the window title
+	 * @param xLabel	the x-axis label; see setXYLabels for seting categories on an axis via the label
+	 * @param yLabel	the y-axis label; see setXYLabels for seting categories on an axis via the label
+	 * @see #add(String,double[],double[])
+	 * @see #add(String,double[])
+	 */
+	public Plot(String title, String xLabel, String yLabel) {
+		this(title, xLabel, yLabel, (float[])null, (float[])null, getDefaultFlags());
+	}
+
+	/** Obsolete, replaced by "new Plot(title,xLabel,yLabel); add(shape,x,y);".
+	 * @deprecated
+	*/
+	public Plot(String title, String xLabel, String yLabel, float[] x, float[] y) {
+		this(title, xLabel, yLabel, x, y, getDefaultFlags());
+	}
+
+	/** Obsolete, replaced by "new Plot(title,xLabel,yLabel); add(shape,x,y);".
+	 * @deprecated
+	*/
+	public Plot(String title, String xLabel, String yLabel, double[] x, double[] y) {
+		this(title, xLabel, yLabel, x!=null?Tools.toFloat(x):null, y!=null?Tools.toFloat(y):null, getDefaultFlags());
+	}
+
+	/** This version of the constructor has a 'flags' argument for
+		controlling whether ticks, grid, etc. are present and whether
+		the axes are logarithmic */
+	public Plot(String title, String xLabel, String yLabel, int flags) {
+		this(title, xLabel, yLabel, (float[])null, (float[])null, flags);
+	}
+
+	/** Obsolete, replaced by "new Plot(title,xLabel,yLabel,flags); add(shape,x,y);".
+	 * @deprecated
+	*/
+	public Plot(String title, String xLabel, String yLabel, float[] xValues, float[] yValues, int flags) {
+		this.title = title;
+		pp.axisFlags = flags;
+		setXYLabels(xLabel, yLabel);
+		if (yValues != null && yValues.length>0) {
+			addPoints(xValues, yValues, /*yErrorBars=*/null, LINE, /*label=*/null);
+			allPlotObjects.get(0).flags = PlotObject.CONSTRUCTOR_DATA;
+		}
+	}
+
+	/** Obsolete, replaced by "new Plot(title,xLabel,yLabel,flags); add(shape,x,y);".
+	 * @deprecated
+	*/
+	public Plot(String title, String xLabel, String yLabel, double[] x, double[] y, int flags) {
+		this(title, xLabel, yLabel, x!=null?Tools.toFloat(x):null, y!=null?Tools.toFloat(y):null, flags);
+	}
+
+	/** Constructs a new plot from an InputStream and closes the stream. If the ImagePlus is
+	 *  non-null, its title and ImageProcessor are used, but the image displayed is not modified.
+	*/
+	public Plot(ImagePlus imp, InputStream is) throws IOException, ClassNotFoundException {
+		ObjectInputStream in = new ObjectInputStream(is);
+		pp = (PlotProperties)in.readObject();
+		allPlotObjects = (Vector<PlotObject>)in.readObject();
+		in.close();
+		if (pp.xLabel.type==8) {
+			pp.xLabel.updateType();	//convert old (pre-1.52i) type codes for the PlotObjects
+			pp.yLabel.updateType();
+			pp.frame.updateType();
+			if (pp.legend != null) pp.legend.updateType();
+			for (PlotObject plotObject : allPlotObjects)
+				plotObject.updateType();
+		}
+
+		defaultMinMax = pp.rangeMinMax;
+		currentFont = nonNullFont(pp.frame.getFont(), currentFont); // best guess in case we want to add a legend
+		getProcessor();     //prepares scale, calibration etc, but does not plot it yet
+		this.title = imp != null ? imp.getTitle() : "Untitled Plot";
+		if (imp != null) {
+			this.imp = imp;
+			ip = imp.getProcessor();
+			imp.setIgnoreGlobalCalibration(true);
+			adjustCalibration(imp.getCalibration());
+			imp.setProperty(PROPERTY_KEY, this);
+		}
+	}
+
+	/** Obsolete, replaced by "new Plot(title,xLabel,yLabel); add(shape,x,y);".
+	 * @deprecated
+	*/
+	public Plot(String dummy, String title, String xLabel, String yLabel, float[] x, float[] y) {
+		this(title, xLabel, yLabel, x, y, getDefaultFlags());
+	}
+
+	/** Writes this plot into an OutputStream containing (1) the serialized PlotProperties and
+	 *	(2) the serialized Vector of all 'added' PlotObjects. The stream is NOT closed.
+	 *	The plot should have been drawn already.
+	 */
+	 //	 Conversion to Streams can be also used to clone plots (not a shallow clone), but this is rather slow.
+	 //	 Sample code:
+	 //	  try {
+	 //		final PipedOutputStream pos = new PipedOutputStream();
+	 //		final PipedInputStream pis = new PipedInputStream(pos);
+	 //		new Thread(new Runnable() {
+	 //		  final public void run() {
+	 //			try {
+	 //			  Plot p = new Plot(null, pis);
+	 //			  pis.close();
+	 //			  pos.close();
+	 //			  p.show();
+	 //			} catch(Exception e) {IJ.handleException(e);};
+	 //		  }
+	 //		}, "threadMakingPlotFromStream").start();
+	 //		toStream(pos);
+	 //	  } catch(Exception e) {IJ.handleException(e);}
+	void toStream(OutputStream os) throws IOException {
+		//prepare
+		for (PlotObject plotObject : pp.getAllPlotObjects())		//make sure all fonts are set properly
+			if (plotObject != null)
+				plotObject.setFont(nonNullFont(plotObject.getFont(), currentFont));
+		pp.rangeMinMax = currentMinMax;
+		//write
+		ObjectOutputStream out = new ObjectOutputStream(os);
+		out.writeObject(pp);
+		out.writeObject(allPlotObjects);
+	}
+
+	/** Writes this plot into a byte array containing (1) the serialized PlotProperties and
+	 *	(2) the serialized Vector of all 'added' PlotObjects.
+	 *	The plot should have been drawn already. Returns null on error (which should never happen). */
+	public byte[] toByteArray() {
+		try {
+			ByteArrayOutputStream bos = new ByteArrayOutputStream();
+			toStream(bos);
+			bos.close();
+			return bos.toByteArray();
+		} catch (Exception e) {
+			IJ.handleException(e);
+			return null;
+		}
+	}
+
+	/** Returns the title of the image showing the plot (if any) or title of the plot */
+	public String getTitle() {
+		return imp == null ? title : imp.getTitle();
+	}
+
+	/** Sets the x-axis and y-axis range. Saves the new limits as default (so the 'R' field sets the limits to these).
+	 *  Updates the image if existing.
+	 *  Accepts NaN values to indicate auto-range. */
+	public void setLimits(double xMin, double xMax, double yMin, double yMax) {
+		setLimitsNoUpdate(xMin, xMax, yMin, yMax);
+		makeLimitsDefault();
+		ignoreForce2Grid = true;
+		if (plotDrawn)
+			setLimitsToDefaults(true);
+	}
+
+	/** Sets the x-axis and y-axis range. Accepts NaN values to indicate auto range.
+	 *  Does not update the image and leaves the default limits (for reset via the 'R' field) untouched. */
+	void setLimitsNoUpdate(double xMin, double xMax, double yMin, double yMax) {
+		boolean containsNaN = (Double.isNaN(xMin + xMax + yMin + yMax));
+		if (containsNaN && getNumPlotObjects(PlotObject.XY_DATA|PlotObject.ARROWS, false)==0)//can't apply auto-range without data
+			return;
+		double[] range = {xMin, xMax, yMin, yMax};
+		if (containsNaN) {                          //auto range for at least one limit
+			double[] extrema = getMinAndMax(true, ALL_AXES_RANGE);
+			boolean[] auto = new boolean[range.length];
+			for (int i = 0; i < range.length; i++)
+				if (Double.isNaN(range[i])) {
+					auto[i] = true;
+					range[i] = extrema[i];
+				}
+			for (int a = 0; a<range.length; a+=2) { //for all axes (0 for x, 2 for y): would semi-auto reverse the axis?
+				if (auto[a] == auto[a+1]) continue; //ignore if not semi-auto
+				boolean currentAxisReverse = defaultMinMax[a+1] < defaultMinMax[a];
+				if ((!currentAxisReverse && range[a+1] <= range[a]) || (currentAxisReverse && range[a] <= range[a+1])) {
+					auto[a] = true;					//semi-auto to full-auto
+					auto[a+1] = true;
+					range[a] = extrema[a];
+					range[a+1] = extrema[a+1];
+				}
+			}
+			for (int i = 0; i < range.length; i++)
+				if (!auto[i])       // don't modify for limits that were set manually
+					enlargeRange[i] = 0;
+			enlargeRange(range);    // for automatic limits, avoid points exactly at the border
+		}
+		System.arraycopy(range, 0, currentMinMax, 0, Math.min(range.length, currentMinMax.length));
+		ignoreForce2Grid = true;
+	}
+
+	/** Takes over the current limits as the default ones (i.e., the limits set by clicking at the 'R' field in the bottom-left corner) */
+	void makeLimitsDefault() {
+		System.arraycopy(currentMinMax, 0, defaultMinMax, 0, Math.min(currentMinMax.length, defaultMinMax.length));
+	}
+
+	/** Returns the current limits as an array xMin, xMax, yMin, yMax.
+	 *  (note that ImageJ versions before to 1.52i have returned incorrect values in case of log axes)
+	 *	Note that future versions might return a longer array (e.g. for y2 axis limits) */
+	public double[] getLimits() {
+		return currentMinMax.clone();//new double[] {xMin, xMax, yMin, yMax};
+	}
+
+	/** Sets the current limits from an array xMin, xMax, yMin, yMax
+	 *  The array may be also longer or shorter, but should not contain NaN values.
+	 *  Does not update the plot, does not save the old limits. */
+	public void setLimits(double[] limits) {
+		System.arraycopy(limits, 0, currentMinMax, 0, Math.min(limits.length, defaultMinMax.length));
+	}
+
+	/** Sets options for the plot. Multiple options may be separated by whitespace or commas.
+	 *  Note that whitespace surrounding the '=' characters is not allowed.
+	 *  Currently recognized options are:
+	 *  "addhspace=10 addvspace=5" Increases the left&right or top&bottom margins by the given number of pixels.
+	 *  "xinterval=30 yinterval=90" Sets interval between numbers, major ticks & grid lines
+	 *    (default intervals are used if the custom intervals would be too dense or too sparse)
+	 *  "xdecimals=2 ydecimals=-1" Sets the minimum number of decimals; use negative numbers for scientific notation.
+	 *  "msymbol=' \\u00d7 '" Sets multiplication symbol for scientific notation, here a cross with spaces.
+	 *  */
+	public void setOptions(String options) {
+		pp.frame.options = options.toLowerCase();
+	}
+
+	/** Sets the canvas size in (unscaled) pixels and sets the scale to 1.0.
+	 * If the scale remains 1.0, this will be the size of the resulting ImageProcessor.
+	 * When not called, the canvas size is adjusted for the plot size specified
+	 * by setFrameSize() or setWindowSize(), or otherwise in Edit>Options>Plots.
+	 * @see #setFrameSize(int,int)
+	 * @see #setWindowSize(int,int)
+	*/
+	public void setSize(int width, int height) {
+		if (ip != null && width == ip.getWidth() && height == ip.getHeight())
+			return;
+		Dimension minSize = getMinimumSize();
+		pp.width = Math.max(width, minSize.width);
+		pp.height = Math.max(height, minSize.height);
+		scale = 1.0f;
+		ip = null;
+		if (plotDrawn) updateImage();
+	}
+
+	/** The size of the plot including borders with axis labels etc., in pixels */
+	public Dimension getSize() {
+		if (ip == null)
+			getBlankProcessor();
+		return new Dimension(ip.getWidth(), ip.getHeight());
+	}
+
+	/** Sets the plot frame size in (unscaled) pixels. This size does not include the
+	 *	borders with the axis labels. Also sets the scale to 1.0.
+	 *	This frame size in pixels divided by the data range defines the image scale.
+	 *	This method does not check for the minimum size MIN_FRAMEWIDTH, MIN_FRAMEHEIGHT.
+	 *	Note that the black frame will have an outer size that is one pixel larger
+	 *	(when plotted with a linewidth of one pixel).
+	 * @see #setWindowSize(int,int)
+	*/
+	public void setFrameSize(int width, int height) {
+		if (pp.width <= 0) {                //plot not drawn yet? Just remember as preferred size
+			preferredPlotWidth = width;
+			preferredPlotHeight = height;
+			scale = 1.0f;
+		} else {
+			makeMarginValues();
+			width += leftMargin+rightMargin;
+			height += topMargin+bottomMargin;
+			setSize(width, height);
+		}
+	}
+
+	/** Sets the plot window size in pixels.
+	 * @see #setFrameSize(int,int)
+	*/
+	public void setWindowSize(int width, int height) {
+		scale = 1.0f;
+		makeMarginValues();
+		int titleBarHeight = 22;
+		int infoHeight = 11;
+		double scale = Prefs.getGuiScale();
+		if (scale>1.0)
+			infoHeight = (int)(infoHeight*scale);
+		int buttonPanelHeight = 45;
+		if (pp.width <= 0) {     //plot not drawn yet?
+			int extraWidth = leftMargin+rightMargin+ImageWindow.HGAP*2;
+			int extraHeight = topMargin+bottomMargin+titleBarHeight+infoHeight+buttonPanelHeight;
+			if (extraWidth<width)
+				width -= extraWidth;
+			if (extraHeight<height)
+				height -= extraHeight;
+			preferredPlotWidth = width;
+			preferredPlotHeight = height;
+		} else {
+			int extraWidth = ImageWindow.HGAP*2;
+			int extraHeight = titleBarHeight+infoHeight+buttonPanelHeight;
+			if (extraWidth<width)
+				width -= extraWidth;
+			if (extraHeight<height)
+				height -= extraHeight;
+			setSize(width, height);
+		}
+	}
+
+	/** The minimum plot size including borders, in pixels (at scale=1) */
+	public Dimension getMinimumSize() {
+		return new Dimension(MIN_FRAMEWIDTH + leftMargin + rightMargin,
+				MIN_FRAMEHEIGHT + topMargin + bottomMargin);
+	}
+
+	/** Adjusts the format with another plot as a template, using the current
+	 *  (usually default) templateFlags of this plot.
+	 *  <code>plot</code> may be null; then the call has no effect. */
+	public void useTemplate(Plot plot) {
+		useTemplate(plot, templateFlags);
+	}
+
+	/** Adjusts the format (style) with another plot as a template. Flags determine what to
+	 *	copy from the template; these can be X_RANGE, Y_RANGE, COPY_SIZE, COPY_LABELS, COPY_AXIS_STYLE,
+	 *  COPY_CONTENTS_STYLE (hidden items are ignored), and COPY_LEGEND.
+	 *	<code>plot</code> may be null; then the call has no effect. */
+	public void useTemplate(Plot plot, int templateFlags) {
+		if (plot == null) return;
+		this.defaultFont = plot.defaultFont;
+		this.currentFont = plot.currentFont;
+		this.currentLineWidth = plot.currentLineWidth;
+		this.currentColor = plot.currentColor;
+		if ((templateFlags & COPY_AXIS_STYLE) != 0) {
+			this.pp.axisFlags = plot.pp.axisFlags;
+			this.pp.frame = plot.pp.frame.deepClone();
+		}
+		if ((templateFlags & COPY_LABELS) != 0) {
+			this.pp.xLabel.label = plot.pp.xLabel.label;
+			this.pp.yLabel.label = plot.pp.yLabel.label;
+			this.pp.xLabel.setFont(plot.pp.xLabel.getFont());
+			this.pp.yLabel.setFont(plot.pp.yLabel.getFont());
+		}
+		for (int i=0; i<currentMinMax.length; i++)
+			if ((templateFlags>>(i/2)&0x1) != 0) {
+				currentMinMax[i] = plot.currentMinMax[i];
+				if (!plotDrawn) defaultMinMax[i] = plot.currentMinMax[i];
+			}
+		if ((templateFlags & COPY_LEGEND) != 0 && plot.pp.legend != null)
+			this.pp.legend = plot.pp.legend.deepClone();
+		if ((templateFlags & (COPY_LEGEND | COPY_CONTENTS_STYLE)) != 0) {
+			int plotPObjectIndex = 0;  //points to PlotObjects of the templatePlot
+			int plotPObjectsSize = plot.allPlotObjects.size();
+			for (PlotObject plotObject : allPlotObjects) {
+				if (plotObject.type == PlotObject.XY_DATA && !plotObject.hasFlag(PlotObject.HIDDEN)) {
+					while(plotPObjectIndex<plotPObjectsSize &&
+							(plot.allPlotObjects.get(plotPObjectIndex).type != PlotObject.XY_DATA ||
+							 plot.allPlotObjects.get(plotPObjectIndex).hasFlag(PlotObject.HIDDEN)))
+						plotPObjectIndex++; //skip everything that is invisible or has no label
+					if (plotPObjectIndex>=plotPObjectsSize) break;
+					if ((templateFlags & COPY_LEGEND) != 0)
+						plotObject.label = plot.allPlotObjects.get(plotPObjectIndex).label;
+					if ((templateFlags & COPY_CONTENTS_STYLE) != 0)
+						setPlotObjectStyle(plotObject, getPlotObjectStyle(plot.allPlotObjects.get(plotPObjectIndex)));
+					plotPObjectIndex++;
+				}
+			}
+		}
+		if ((templateFlags & COPY_SIZE) != 0)
+			setSize(plot.pp.width, plot.pp.height);
+
+		if ((templateFlags & COPY_EXTRA_OBJECTS) != 0)
+			for (int p = allPlotObjects.size(); p < plot.allPlotObjects.size(); p++)
+				allPlotObjects.add(plot.allPlotObjects.get(p));
+		this.templateFlags = templateFlags;
+	}
+
+	/** Sets the scale. Everything, including labels, line thicknesses, etc will be scaled by this factor.
+	 *  Also multiplies the plot size by this value. Used for 'Create high-resolution plot'.
+	 *	Should be called before creating the plot.
+	 *  Note that plots with a scale different from 1.0 must not be shown in a PlotWindow, but only as
+	 *  simple image in a normal ImageWindow. */
+	public void setScale(float scale) {
+		this.scale = scale;
+		if (scale > 20f) scale = 20f;
+		if (scale < 0.7f) scale = 0.7f;
+		pp.width = sc(pp.width);
+		pp.height = sc(pp.height);
+		plotDrawn = false;
+	}
+
+	/** Sets the labels of the x and y axes. 'xLabel', 'yLabel' may be null.
+	 *  If a label has the form {txt1,txt2,txt3}, the corresponding axis will be labeled
+	 *  not by numbers but rather with the texts "txt1", "txt2" ... instead of 0, 1, ...
+	 *  In this special case, there will be no label for the axis on the plot.
+	 *	Call update() thereafter to make the change visible (if it is shown already). */
+	public void setXYLabels(String xLabel, String yLabel) {
+		pp.xLabel.label = xLabel!=null ? xLabel : "";
+		pp.yLabel.label = yLabel!=null ? yLabel : "";
+	}
+
+	/** Sets the maximum number of intervals in a plot.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+	public void setMaxIntervals(int intervals) {
+			maxIntervals = intervals;
+	}
+
+	/** Sets the length of the major tick in pixels.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+	public void setTickLength(int tickLength) {
+			tickLength = tickLength;
+	}
+
+	/** Sets the length of the minor tick in pixels. */
+	public void setMinorTickLength(int minorTickLength) {
+			minorTickLength = minorTickLength;
+	}
+
+	/** Sets the flags that control the axes format.
+	 *	Does not modify the flags for logarithmic axes on/off and the FORCE2GRID flags.
+	 *	Call update() thereafter to make the change visible (if it is shown already). */
+	public void setFormatFlags(int flags) {
+		int unchangedFlags = X_LOG_NUMBERS | Y_LOG_NUMBERS | X_FORCE2GRID | Y_FORCE2GRID;
+		flags = flags & (~unchangedFlags);	  //remove flags that should not be affected
+		pp.axisFlags = (pp.axisFlags & unchangedFlags) | flags;
+	}
+
+	/** Returns the flags that control the axes */
+	public int getFlags() {
+		return pp.axisFlags;
+	}
+
+	/** Sets the X Axis format to Log or Linear.
+	 *	Call update() thereafter to make the change visible (if it is shown already). */
+	public void setAxisXLog(boolean axisXLog) {
+		pp.axisFlags = axisXLog ? pp.axisFlags | X_LOG_NUMBERS : pp.axisFlags & (~X_LOG_NUMBERS);
+	}
+
+	/** Sets the Y Axis format to Log or Linear.
+	 *	Call update() thereafter to make the change visible (if it is shown already). */
+	public void setAxisYLog(boolean axisYLog) {
+		pp.axisFlags = axisYLog ? pp.axisFlags | Y_LOG_NUMBERS : pp.axisFlags & (~Y_LOG_NUMBERS);
+	}
+
+	/** Sets whether to show major ticks at the x axis.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+
+	public void setXTicks(boolean xTicks) {
+		pp.axisFlags = xTicks ? pp.axisFlags | X_TICKS : pp.axisFlags & (~X_TICKS);
+	}
+
+	/** Sets whether to show major ticks at the y axis.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+	public void setYTicks(boolean yTicks) {
+		pp.axisFlags = yTicks ? pp.axisFlags | Y_TICKS : pp.axisFlags & (~Y_TICKS);
+	}
+
+	/** Sets whether to show minor ticks on the x axis (if linear). Also sets major ticks if true and no grid is set.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+	public void setXMinorTicks(boolean xMinorTicks) {
+		pp.axisFlags = xMinorTicks ? pp.axisFlags | X_MINOR_TICKS : pp.axisFlags & (~X_MINOR_TICKS);
+		if (xMinorTicks && !hasFlag(X_GRID))
+			pp.axisFlags |= X_TICKS;
+	}
+
+	/** Sets whether to show minor ticks on the y axis (if linear). Also sets major ticks if true and no grid is set.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+	public void setYMinorTicks(boolean yMinorTicks) {
+		pp.axisFlags = yMinorTicks ? pp.axisFlags | Y_MINOR_TICKS : pp.axisFlags & (~Y_MINOR_TICKS);
+		if (yMinorTicks && !hasFlag(Y_GRID))
+			pp.axisFlags |= Y_TICKS;
+	}
+
+	/** Sets the properties of the axes. Call update() thereafter to make the change visible
+	 *	(if the image is shown already). */
+	public void setAxes(boolean xLog, boolean yLog, boolean xTicks, boolean yTicks, boolean xMinorTicks, boolean yMinorTicks,
+			int tickLenght, int minorTickLenght) {
+		setAxisXLog		  (xLog);
+		setAxisYLog		  (yLog);
+		setXMinorTicks	  (xMinorTicks);
+		setYMinorTicks	  (yMinorTicks);
+		setXTicks		  (xTicks);
+		setYTicks		  (yTicks);
+		setTickLength	  (tickLenght);
+		setMinorTickLength(minorTickLenght);
+	}
+
+	/** Sets log scale in x. Call update() thereafter to make the change visible
+	 *	(if the image is shown already). */
+
+	public void setLogScaleX() {
+		setAxisXLog(true);
+	}
+
+	public void setLogScaleY() {
+		setAxisYLog(true);
+	}
+
+	/** The default flags, taking PlotWindow.noGridLines, PlotWindow.noTicks into account */
+	public static int getDefaultFlags() {
+		int defaultFlags = 0;
+		if (!PlotWindow.noGridLines) //note that log ticks are also needed because the range may span less than a decade, then no grid is visible
+			defaultFlags |= X_GRID | Y_GRID | X_NUMBERS | Y_NUMBERS | X_LOG_TICKS | Y_LOG_TICKS;
+		if (!PlotWindow.noTicks)
+			defaultFlags |= X_TICKS | Y_TICKS | X_MINOR_TICKS | Y_MINOR_TICKS | X_NUMBERS | Y_NUMBERS | X_LOG_TICKS | Y_LOG_TICKS;
+		return defaultFlags;
+	}
+
+	/** Adds a curve or set of points to this plot, where 'type' is
+	 * "line", "connected circle", "filled", "bar", "separated bar", "circle", "box", "triangle", "diamond", "cross",
+	 * "x" or "dot". Run <i>Help&gt;Examples&gt;JavaScript&gt;Graph Types</i> to see examples.
+	 * If 'type' is in the form "code: <macroCode>", the macro given is executed to draw the symbol;
+	 * macro variables 'x' and 'y' are the pixel coordinates of the point, 'xval' and 'yval' are the plot data
+	 * and 'i' is the index of the data point (starting with 0 for the first point in the array).
+	 * The drawing including line thickness, font size, etc. be scaled by scale factor 's' (to make high-resolution plots work).
+	 * Example: "code: setFont('sanserif',12*s,'bold anti');drawString(d2s(yval,1),x-14*s,y-4*s);"
+	 * writes the y value for each point above the point.
+	*/
+	public void add(String type, double[] xvalues, double[] yvalues) {
+		int iShape = toShape(type);
+		addPoints(Tools.toFloat(xvalues), Tools.toFloat(yvalues), null, iShape, iShape==CUSTOM?type.substring(5, type.length()):null);
+	}
+
+	/** Replaces the specified plot object (curve or set of points).
+		 Equivalent to add() if there are no plot objects. */
+	public void replace(int index, String type, double[] xvalues, double[] yvalues) {
+		if (index>=0 && index<allPlotObjects.size()) {
+			objectToReplace = allPlotObjects.size()>0?index:-1;
+			add(type, xvalues, yvalues);
+		}
+	}
+
+	/** Adds a curve, set of points or error bars to this plot, where 'type' is
+	 * "line", "connected circle", "filled", "bar", "separated bar", "circle", "box",
+	 * "triangle", "diamond", "cross", "x", "dot", "error bars" or "xerror bars".
+	*/
+	public void add(String type, double[] yvalues) {
+		int iShape = toShape(type);
+		if (iShape==-1)
+			addErrorBars(yvalues);
+		else if (iShape==-2)
+			addHorizontalErrorBars(yvalues);
+		else
+			addPoints(null, Tools.toFloat(yvalues), null, iShape, iShape==CUSTOM?type.substring(5, type.length()):null);
+	}
+
+	/** Adds a set of points to the plot or adds a curve if shape is set to LINE.
+	 * @param xValues	the x coordinates, or null. If null, integers starting at 0 will be used for x.
+	 * @param yValues	the y coordinates (must not be null)
+	 * @param yErrorBars error bars in y, may be null
+	 * @param shape		CIRCLE, X, BOX, TRIANGLE, CROSS, DIAMOND, DOT, LINE, CONNECTED_CIRCLES
+	 * @param label		Label for this curve or set of points, used for a legend and for listing the plots
+	 */
+	public void addPoints(float[] xValues, float[] yValues, float[] yErrorBars, int shape, String label) {
+		if (xValues==null || xValues.length==0) {
+			xValues = new float[yValues.length];
+			for (int i=0; i<yValues.length; i++)
+				xValues[i] = i;
+		}
+		if (objectToReplace>=0)
+			allPlotObjects.set(objectToReplace, new PlotObject(xValues, yValues, yErrorBars, shape, currentLineWidth, currentColor, currentColor2, label));
+		else
+			allPlotObjects.add(new PlotObject(xValues, yValues, yErrorBars, shape, currentLineWidth, currentColor, currentColor2, label));
+		objectToReplace = -1;
+		if (plotDrawn) updateImage();
+	}
+
+	/** Adds a set of points to the plot or adds a curve if shape is set to LINE.
+	 * @param x			the x coordinates
+	 * @param y			the y coordinates
+	 * @param shape		CIRCLE, X, BOX, TRIANGLE, CROSS, DIAMOND, DOT, LINE, CONNECTED_CIRCLES
+	 */
+	public void addPoints(float[] x, float[] y, int shape) {
+		addPoints(x, y, null, shape, null);
+	}
+
+	/** Adds a set of points to the plot using double arrays. */
+	public void addPoints(double[] x, double[] y, int shape) {
+		addPoints(Tools.toFloat(x), Tools.toFloat(y), shape);
+	}
+
+	/** Returns the number for a given plot symbol shape, -1 for xError and -2 for yError (all case-insensitive) */
+	public static int toShape(String str) {
+		str = str.toLowerCase(Locale.US);
+		int shape = Plot.CIRCLE;
+		if (str.contains("curve") || str.contains("line"))
+			shape = Plot.LINE;
+		else if (str.contains("connected"))
+			shape = Plot.CONNECTED_CIRCLES;
+		else if (str.contains("filled"))
+			shape = Plot.FILLED;
+		else if (str.contains("circle"))
+			shape = Plot.CIRCLE;
+		else if (str.contains("box"))
+			shape = Plot.BOX;
+		else if (str.contains("triangle"))
+			shape = Plot.TRIANGLE;
+		else if (str.contains("cross") || str.contains("+"))
+			shape = Plot.CROSS;
+		else if (str.contains("diamond"))
+			shape = Plot.DIAMOND;
+		else if (str.contains("dot"))
+			shape = Plot.DOT;
+		else if (str.contains("xerror"))
+			shape = -2;
+		else if (str.contains("error"))
+			shape = -1;
+		else if (str.contains("x"))
+			shape = Plot.X;
+		else if (str.contains("separate"))
+			shape = Plot.SEPARATED_BAR;
+		else if (str.contains("bar"))
+			shape = Plot.BAR;
+		if (str.startsWith("code:"))
+			shape = CUSTOM;
+		return shape;
+	}
+
+	/** Adds a set of points to the plot using double ArrayLists.
+	 * Must be called before the plot is displayed. */
+	public void addPoints(ArrayList x, ArrayList y, int shape) {
+		addPoints(getDoubleFromArrayList(x), getDoubleFromArrayList(y), shape);
+	}
+
+	/** Adds a set of points to the plot or adds a curve if shape is set to LINE.
+	 * @param x			the x-coodinates
+	 * @param y			the y-coodinates
+	 * @param errorBars	half-lengths of the vertical error bars, may be null
+	 * @param shape		CIRCLE, X, BOX, TRIANGLE, CROSS, DIAMOND, DOT or LINE
+	 */
+	public void addPoints(double[] x, double[] y, double[] errorBars, int shape) {
+		addPoints(Tools.toFloat(x), Tools.toFloat(y), Tools.toFloat(errorBars), shape, null);
+	}
+
+	/** Adds a set of points to the plot using double ArrayLists.
+	 * Must be called before the plot is displayed. */
+	public void addPoints(ArrayList x, ArrayList y, ArrayList errorBars, int shape) {
+		addPoints(getDoubleFromArrayList(x), getDoubleFromArrayList(y), getDoubleFromArrayList(errorBars), shape);
+	}
+
+	public double[] getDoubleFromArrayList(ArrayList list) {
+		if (list == null) return null;
+		double[] targ = new double[list.size()];
+		for (int i = 0; i < list.size(); i++)
+			targ[i] = ((Double) list.get(i)).doubleValue();
+		return targ;
+	}
+
+	/** Adds a set of points that will be drawn as ARROWs.
+	 * @param x1		the x-coodinates of the beginning of the arrow
+	 * @param y1		the y-coodinates of the beginning of the arrow
+	 * @param x2		the x-coodinates of the end		  of the arrow
+	 * @param y2		the y-coodinates of the end		  of the arrow
+	 */
+	public void drawVectors(double[] x1, double[] y1, double[] x2, double[] y2) {
+		allPlotObjects.add(new PlotObject(Tools.toFloat(x1), Tools.toFloat(y1),
+				Tools.toFloat(x2), Tools.toFloat(y2), currentLineWidth, currentColor));
+	}
+
+	/**
+	 * Adds a set of 'shapes' such as boxes and whiskers
+	 *
+	 * @param shapeType e.g. "boxes width=20"
+	 * @param floatCoords eg[6][3] holding 1 Xval + 5 Yvals for 3 boxes
+	 */
+	public void drawShapes(String shapeType, ArrayList floatCoords) {
+		allPlotObjects.add(new PlotObject(shapeType, floatCoords, currentLineWidth, currentColor, currentColor2));
+	}
+
+	public static double calculateDistance(int x1, int y1, int x2, int y2) {
+		return java.lang.Math.sqrt((x2 - x1)*(double)(x2 - x1) + (y2 - y1)*(double)(y2 - y1));
+	}
+
+	/** Adds a set of vectors to the plot using double ArrayLists.
+	 *	Does not support logarithmic axes.
+	 *	Must be called before the plot is displayed. */
+	public void drawVectors(ArrayList x1, ArrayList y1, ArrayList x2, ArrayList y2) {
+		drawVectors(getDoubleFromArrayList(x1), getDoubleFromArrayList(y1), getDoubleFromArrayList(x2), getDoubleFromArrayList(y2));
+	}
+
+	/** Adds vertical error bars to the last data passed to the plot (via the constructor or addPoints). */
+	public void addErrorBars(float[] errorBars) {
+		PlotObject mainObject = getLastCurveObject();
+		if (mainObject != null)
+			mainObject.yEValues = errorBars;
+		else throw new RuntimeException("Plot can't add y error bars without data");
+	}
+
+	/** Adds vertical error bars to the last data passed to the plot (via the constructor or addPoints). */
+	public void addErrorBars(double[] errorBars) {
+		addErrorBars(Tools.toFloat(errorBars));
+	}
+
+	/** Adds horizontal error bars to the last data passed to the plot (via the constructor or addPoints). */
+	public void addHorizontalErrorBars(float[] xErrorBars) {
+		PlotObject mainObject = getLastCurveObject();
+		if (mainObject != null)
+			mainObject.xEValues = xErrorBars;
+		else throw new RuntimeException("Plot can't add x error bars without data");
+	}
+
+	/** Adds horizontal error bars to the last data passed to the plot (via the constructor or addPoints). */
+	public void addHorizontalErrorBars(double[] xErrorBars) {
+		addHorizontalErrorBars(Tools.toFloat(xErrorBars));
+	}
+
+	/** Draws text at the specified location, where (0,0)
+	 *  is the upper left corner of the the plot frame and (1,1) is
+	 *  the lower right corner. Uses the justification specified by setJustification().
+	 *  When called with the same position as the previous addLabel call, the text of that previous call is replaced */
+	public void addLabel(double x, double y, String label) {
+		if (textLoc!=null && x==textLoc.getX() && y==textLoc.getY())
+			allPlotObjects.set(textIndex, new PlotObject(label, x, y, currentJustification, currentFont, currentColor, PlotObject.NORMALIZED_LABEL));
+		else {
+			allPlotObjects.add(new PlotObject(label, x, y, currentJustification, currentFont, currentColor, PlotObject.NORMALIZED_LABEL));
+			textLoc = new Point2D.Double(x,y);
+			textIndex = allPlotObjects.size()-1;
+		}
+	}
+
+	/* Draws text at the specified location, using the coordinate system defined
+	 * by setLimits() and the justification specified by setJustification(). */
+	public void addText(String label, double x, double y) {
+		allPlotObjects.add(new PlotObject(label, x, y, currentJustification, currentFont, currentColor, PlotObject.LABEL));
+	}
+
+	/** Adds an automatically positioned legend, where 'labels' can be a tab-delimited or
+		newline-delimited list of curve or point labels in the sequence these data were added.
+		Hidden data sets are ignored.
+		If 'labels' is null or empty, the labels of the data set previously (if any) are used.
+		To modify the legend's style, call 'setFont' and 'setLineWidth' before 'addLegend'. */
+	public void addLegend(String labels) {
+		addLegend(labels, "auto");
+	}
+
+	/** Adds a legend at the position given in 'options', where 'labels' can be tab-delimited or
+		newline-delimited list of curve or point labels in the sequence these data were added.
+		Hidden data sets are ignored.
+		If 'labels' is null or empty, the labels of the data set previously (if any) are used.
+		To modify the legend's style, call 'setFont' and 'setLineWidth' before 'addLegend'. */
+		public void addLegend(String labels, String options) {
+			int flags = 0;
+			if (options!=null) {
+				options = options.toLowerCase();
+				if (options.contains("top-left"))
+					flags |= Plot.TOP_LEFT;
+				else if (options.contains("top-right"))
+					flags |= Plot.TOP_RIGHT;
+				else if (options.contains("bottom-left"))
+					flags |= Plot.BOTTOM_LEFT;
+				else if (options.contains("bottom-right"))
+					flags |= Plot.BOTTOM_RIGHT;
+				else if (!options.contains("off") && !options.contains("no"))
+					flags |= Plot.AUTO_POSITION;
+				if (options.contains("bottom-to-top"))
+					flags |= Plot.LEGEND_BOTTOM_UP;
+				if (options.contains("transparent"))
+					flags |= Plot.LEGEND_TRANSPARENT;
+			}
+			setLegend(labels, flags);
+		}
+
+	/** Adds a legend. The legend will be always drawn last (on top of everything).
+	 *	To modify the legend's style, call 'setFont' and 'setLineWidth' before 'addLegend'
+	 *	@param labels labels of the points or curves in the sequence of the data were added, tab-delimited or linefeed-delimited.
+	 *	The labels of the datasets will be set to these values. If null or not given, the labels set
+	 *	previously (if any) will be used.
+	 *  Hidden data sets are ignored.
+	 *	@param flags  Bitwise or of position (AUTO_POSITION, TOP_LEFT etc.), LEGEND_TRANSPARENT, and LEGEND_BOTTOM_UP if desired.
+	 *	Updates the image (if it is shown already). */
+	public void setLegend(String labels, int flags) {
+		if (labels != null && labels.length()>0) {
+			String[] allLabels = labels.split("[\n\t]");
+			int iPart = 0;
+			for (PlotObject plotObject : allPlotObjects)
+				if (plotObject.type == PlotObject.XY_DATA && !plotObject.hasFlag(PlotObject.HIDDEN))
+					if (iPart < allLabels.length) {
+						String label = allLabels[iPart++];
+						if (label!=null && label.length()>0)
+							plotObject.label = label;
+					}
+		}
+		pp.legend = new PlotObject(currentLineWidth == 0 ? 1 : currentLineWidth,
+				currentFont, currentColor == null ? Color.black : currentColor, flags);
+		if (plotDrawn) updateImage();
+	}
+
+	/** Sets the label for the plot object nuber 'index' in the sequence they were added.
+	 *  With index=-1, sets the label for the last object added.
+	 *  For x/y data, the label is used for the legend and as header in getResultsTableWithLabels.
+	 *  For Text/Label objects, it affects the label shown (but the plot is not redisplayed). */
+	public void setLabel(int index, String label) {
+		if (index < 0) index = allPlotObjects.size() + index;
+		allPlotObjects.get(index).label = label;
+	}
+
+	/** Removes NaNs from the xValues and yValues arrays of all plot objects. */ 
+	public void removeNaNs() {
+		for (PlotObject plotObj : allPlotObjects){
+			if(plotObj != null && plotObj.xValues!= null && plotObj.yValues != null ){
+				int oldSize = plotObj.xValues.length;
+				float[] xVals = new float[oldSize];
+				float[] yVals = new float[oldSize];
+				int newSize = 0;
+				for (int kk = 0; kk < oldSize; kk++) {
+					if (!Float.isNaN(plotObj.xValues[kk] + plotObj.yValues[kk])) {
+						xVals[newSize] = plotObj.xValues[kk];
+						yVals[newSize] = plotObj.yValues[kk];
+						newSize++;
+					}
+				}
+				if (newSize < oldSize) {
+					plotObj.xValues = new float[newSize];
+					plotObj.yValues = new float[newSize];
+					System.arraycopy(xVals, 0, plotObj.xValues, 0, newSize);
+					System.arraycopy(yVals, 0, plotObj.yValues, 0, newSize);
+				}
+			}
+		}
+	}
+
+	/** Returns an array of the available curve types ("Line", "Bar", "Circle", etc). */
+	public String[] getTypes() {
+		return SORTED_SHAPES;
+	}
+
+	/** Sets the justification used by addLabel(), where <code>justification</code>
+	 * is Plot.LEFT, Plot.CENTER or Plot.RIGHT. Default is LEFT. */
+	public void setJustification(int justification) {
+		currentJustification = justification;
+	}
+
+	/** Changes the drawing color for the next objects that will be added to the plot.
+	 *	For selecting the color of the curve passed with the constructor,
+	 *	use <code>setColor</code> before <code>draw</code>.
+	 *	The frame and labels are always drawn in black. */
+	public void setColor(Color c) {
+		currentColor = c;
+		currentColor2 = null;
+	}
+
+	public void setColor(String color) {
+		setColor(Colors.decode(color, Color.black));
+	}
+
+	/** Changes the drawing color for the next objects that will be added to the plot.
+	 *	It also sets secondary color: This is the color of the line for CONNECTED_CIRCLES,
+	 *	and the color for filling open symbols (CIRCLE, BOX, TRIANGLE).
+	 *	Set it to null or use the one-argument call setColor(color) to disable filling.
+	 *	For selecting the color of the curve passed with the constructor,
+	 *	use <code>setColor</code> before <code>draw</code>.
+	 *	The frame and labels are always drawn in black. */
+	public void setColor(Color c, Color c2) {
+		currentColor = c;
+		currentColor2 = c2;
+	}
+
+	/** Sets the drawing colors for the next objects that will be added to the plot. */
+	public void setColor(String c1, String c2) {
+		setColor(Colors.decode(c1, Color.black), Colors.decode(c2, null));
+	}
+
+	/** Set the plot frame background color. */
+	public void setBackgroundColor(Color c) {
+		pp.frame.color2 = c;
+	}
+
+	/** Set the plot frame background color. */
+	public void setBackgroundColor(String c) {
+		setBackgroundColor(Colors.decode(c,Color.white));
+	}
+
+	/** Changes the line width for the next objects that will be added to the plot. */
+	public void setLineWidth(int lineWidth) {
+		currentLineWidth = lineWidth > 0 ? lineWidth : 0.01f;
+	}
+
+	/** Changes the line width for the next objects that will be added to the plot.
+	 *  After all objects have been added, set the line width to the width desired
+	 *  for the frame around the plot (max. 3) */
+	public void setLineWidth(float lineWidth) {
+		currentLineWidth = lineWidth > 0.01 ? lineWidth : 0.01f;
+	}
+
+	/** Draws a line using the coordinate system defined by setLimits(). */
+	public void drawLine(double x1, double y1, double x2, double y2) {
+		allPlotObjects.add(new PlotObject(x1, y1, x2, y2, currentLineWidth, 0, currentColor, PlotObject.LINE));
+	}
+
+	/** Draws a line using a normalized 0-1, 0-1 coordinate system,
+	 * with (0,0) at the top left and (1,1) at the lower right corner.
+	 * This is the same coordinate system used by addLabel(x,y,label).
+	 */
+	public void drawNormalizedLine(double x1, double y1, double x2, double y2) {
+		allPlotObjects.add(new PlotObject(x1, y1, x2, y2, currentLineWidth, 0, currentColor, PlotObject.NORMALIZED_LINE));
+	}
+
+	/** Draws a line using the coordinate system defined by setLimits(). */
+	public void drawDottedLine(double x1, double y1, double x2, double y2, int step) {
+		allPlotObjects.add(new PlotObject(x1, y1, x2, y2, currentLineWidth, step, currentColor, PlotObject.DOTTED_LINE));
+	}
+
+	/** Sets the font size for all following addLabel() etc. operations. The currently set font when
+	 *	displaying the plot determines the font of all labels & numbers.
+	 *  After the plot has been shown, sets the font for the numbers and the legend (if present).
+	 *	If the plot is hown already, call update() thereafter to make the change visible. */
+	public void setFontSize(int size) {
+		setFont(-1, (float)size);
+	}
+
+	/** Sets the font for all following addLabel() etc. operations. The currently set font when
+	 *	displaying the plot determines the font of all labels & numbers.
+	 *  After the plot has been shown, sets the font for the numbers and the legend (if present);
+	 *  use setFont(char, Font) to set these fonts individually.
+	 *	If the plot is hown already, call update() thereafter to make the change visible. */
+	public void setFont(Font font) {
+		if (font == null) font = defaultFont;
+		currentFont = font;
+		if (plotDrawn) {
+			pp.frame.setFont(font);
+			if (pp.legend != null)
+				pp.legend.setFont(font);
+		}
+	}
+
+	/** Sets the font size and style for all following addLabel() etc. operations. This leaves
+	 *	the font name and style of the previously used fonts unchanged. The currently set font
+	 *	when displaying the plot determines the font of the numbers at the axes.
+	 *	That font also sets the default label font size, which may be overridden by
+	 *	setAxisLabelFontSize or setXLabelFont, setYLabelFont.
+	 *  After the plot has been shown, sets the font for the numbers and the legend (if present);
+	 *  use setFont(char, Font) to set these fonts individually.
+	 *	Styles are defined in the Font class, e.g. Font.PLAIN, Font.BOLD.
+	 *	Set <code>style</code> to -1 to leave the style unchanged.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+	public void setFont(int style, float size) {
+		if (size < 9) size = 9f;
+		if (size > 36) size = 36f;
+		Font previousFont = nonNullFont(pp.frame.getFont(), currentFont);
+		if (style < 0) style = previousFont.getStyle();
+		setFont(previousFont.deriveFont(style, size));
+	}
+
+	/** Sets the x and y label font size and style. Styles are defined
+	 *	in the Font class, e.g. Font.PLAIN, Font.BOLD.
+	 *	Set <code>style</code> to -1 to leave the style unchanged.
+	 *	Call update() thereafter to make the change visible (if the image is shown already). */
+	public void setAxisLabelFont(int style, float size) {
+		if (size < 9) size = 9f;
+		if (size > 33) size = 33f;
+		pp.xLabel.setFont(nonNullFont(pp.xLabel.getFont(), currentFont));
+		pp.yLabel.setFont(nonNullFont(pp.yLabel.getFont(), currentFont));
+		setXLabelFont(pp.xLabel.getFont().deriveFont(style < 0 ? pp.xLabel.getFont().getStyle() : style, size));
+		setYLabelFont(pp.xLabel.getFont().deriveFont(style < 0 ? pp.yLabel.getFont().getStyle() : style, size));
+	}
+
+	/** Sets the xLabelFont; must not be null. If this method is not used, the last setFont
+	 *	of setFontSize call before displaying the plot determines the font, or if neither
+	 *	was called, the font size of the Plot Options is used. */
+	public void setXLabelFont(Font font) {
+		pp.xLabel.setFont(font);
+	}
+
+	/** Sets the yLabelFont; must not be null. */
+	public void setYLabelFont(Font font) {
+		pp.yLabel.setFont(font);
+	}
+
+	/** Determines whether to use antialiased text (default true) */
+	public void setAntialiasedText(boolean antialiasedText) {
+		pp.antialiasedText = antialiasedText;
+	}
+
+	/** Returns the font currently used (e.g. for the next 'addLabel') */
+	public Font getCurrentFont() {
+		return currentFont != null ? currentFont : defaultFont;
+	}
+
+	/** Returns the default font for the plot */
+	public Font getDefaultFont() {
+		return defaultFont;
+	}
+
+	/** Gets the font for xLabel ('x'), yLabel('y'), numbers ('f' for 'frame') or the legend ('l').
+	 *	Returns null if the given PlotObject does not exist or its font is null */
+	public Font getFont(char c) {
+		PlotObject plotObject = pp.getPlotObject(c);
+		if (plotObject != null)
+			return plotObject.getFont();
+		else
+			return null;
+	}
+
+	/** Sets the font for xLabel ('x'), yLabel('y'), numbers ('f' for 'frame') or the legend ('l') */
+	public void setFont(char c, Font font) {
+		PlotObject plotObject = pp.getPlotObject(c);
+		if (plotObject != null)
+			plotObject.setFont(font);
+	}
+
+	/** Gets the label String of the xLabel ('x'), yLabel('y') or the legend ('l').
+	 *	Returns null if the given PlotObject does not exist or its label is null */
+	public String getLabel(char c) {
+		PlotObject plotObject = pp.getPlotObject(c);
+		if (plotObject != null)
+			return plotObject.label;
+		else
+			return null;
+	}
+
+	/** Gets the flags of the xLabel ('x'), yLabel('y') or the legend ('l').
+	 *	Returns -1 if the given PlotObject does not exist */
+	public int getObjectFlags(char c) {
+		PlotObject plotObject = pp.getPlotObject(c);
+		if (plotObject != null)
+			return plotObject.flags;
+		else
+			return -1;
+	}
+
+	/** Get the x coordinates of the data set passed with the constructor (if not null)
+	 *	or otherwise of the data set of the first 'addPoints'. Returns null if neither exists */
+	public float[] getXValues() {
+		PlotObject p = getMainCurveObject();
+		return p==null ? null : p.xValues;
+	}
+
+	/** Get the y coordinates of the data set passed with the constructor (if not null)
+	 *	or otherwise of the data set of the first 'addPoints'. Returns null if neither exists */
+	public float[] getYValues() {
+		PlotObject p = getMainCurveObject();
+		return p==null ? null : p.yValues;
+	}
+
+	/** Get the data of the n-th Plot Object containing xy data in the sequence they were added
+	 *  (Other Plot Objects such as labels, arrows, lines, shapes and hidden PlotObjects are not counted).
+	 *	The array returned has elements [0] x data, [1] y data, [2] x error bars, [3] y error bars.
+	 *  If no error bars are given, the corresponding arrays are null.
+	 *  Returns null if there is no Plot Object with xy data with this index.
+	 *  @see #getDataObjectDesignations()
+	**/
+	public float[][] getDataObjectArrays(int index) {
+		int i = 0;
+		for (PlotObject plotObject : allPlotObjects) {
+			if (plotObject.type != PlotObject.XY_DATA || plotObject.hasFlag(PlotObject.HIDDEN)) continue;
+			if (index == i)
+				return new float[][] {plotObject.xValues, plotObject.yValues, plotObject.xEValues, plotObject.yEValues};
+			i++;
+		}
+		return null;
+	}
+
+	/** Gets an array with human-readable designations of the PlotObjects (curves, labels, ...)
+	 *	in the sequence they were added (the object passed with the constructor is first,
+	 *	even though it is plotted last). Hidden PlotObjects are included. **/
+	public String[] getPlotObjectDesignations() {
+		return getPlotObjectDesignations(-1, true);
+	}
+
+	/** Gets an array with human-readable designations of the PlotObjects containing xy data
+	 *	in the sequence they were added. Other Plot Objects such as labels, arrows, lines,
+	 *  shapes and hidden PlotObjects are not counted.
+	 *  (the object passed with the constructor is first, even though it is plotted last). */
+	public String[] getDataObjectDesignations() {
+		return getPlotObjectDesignations(PlotObject.XY_DATA, false);
+	}
+
+	/** Returns the number of PlotObjects (curves, labels, ...) passed with the constructor or added by 'add' or 'draw' methods.
+	 *  Legend, frame and axes (though internally PlotObjects) are not included */
+	public int getNumPlotObjects() {
+		return allPlotObjects.size();
+	}
+
+	/** Returns the number of PlotObjects fitting the mask.
+	 *  Legend, frame and axes (though internally PlotObjects) are not included */
+	int getNumPlotObjects(int mask, boolean includeHidden) {
+		int nObjects = 0;
+		for (PlotObject plotObject : allPlotObjects)
+			if ((plotObject.type & mask) != 0 && (includeHidden || !plotObject.hasFlag(PlotObject.HIDDEN)))
+				nObjects++;
+		return nObjects;
+	}
+
+	/** Gets an array with human-readable designations of the PlotObjects with types fitting the mask
+	 *  (i.e., 'mask' should be a bitwise or of the types desired) */
+	String[] getPlotObjectDesignations(int mask, boolean includeHidden) {
+		int nObjects = getNumPlotObjects(mask, includeHidden);
+		String[] names = new String[nObjects];
+		if (names.length == 0) return names;
+		int iData = 1, iArrow = 1, iLine = 1, iText = 1,  iBox = 1, iShape = 1; //Human readable counters of each object type
+		int i = 0;
+		for (PlotObject plotObject : allPlotObjects) {
+			int type = plotObject.type;
+			if ((type & mask) == 0 || (!includeHidden && plotObject.hasFlag(PlotObject.HIDDEN))) continue;
+			String label = plotObject.label;
+			switch (type) {
+				case PlotObject.XY_DATA:
+					names[i] = "Data Set "+iData+": "+(plotObject.label != null ?
+							plotObject.label : "(" + plotObject.yValues.length + " data points)");
+					iData++;
+					break;
+				case PlotObject.ARROWS:
+					names[i] = "Arrow Set "+iArrow+" ("+ plotObject.xValues.length + ")";
+					iArrow++;
+					break;
+				case PlotObject.LINE: case PlotObject.NORMALIZED_LINE: case PlotObject.DOTTED_LINE:
+					String detail = "";
+					if (type == PlotObject.DOTTED_LINE) detail = "dotted ";
+					if (plotObject.x ==plotObject.xEnd) detail += "vertical";
+					else if (plotObject.y ==plotObject.yEnd) detail += "horizontal";
+					if (detail.length()>0) detail = " ("+detail.trim()+")";
+					names[i] = "Straight Line "+iLine+detail;
+					iLine++;
+					break;
+				case PlotObject.LABEL: case PlotObject.NORMALIZED_LABEL:
+					String text = plotObject.label.replaceAll("\n"," ");
+					if (text.length()>45) text = text.substring(0, 40)+"...";
+					names[i] = "Text "+iText+": \""+text+'"';
+					iText++;
+					break;
+				case PlotObject.SHAPES:
+					String s = plotObject.shapeType;
+					String[] words = s.split(" ");
+					names[i] = "Shapes (" + words[0] +") " + iShape;
+					iShape++;
+					break;
+			}
+			i++;
+		}
+		return names;
+	}
+
+	/** Add the i-th PlotObject (in the sequence how they were added, including hidden ones)
+	 *  from another plot to this one. PlotObjects here refers to curves, arrows, labels etc.
+	 *  (not legend, axes and frame, though implemented as PlotObjects)
+	 *  Use 'update' to update the plot thereafter.
+	 *  @return Index of the plotObject added in the sequence they were added */
+	public int addObjectFromPlot(Plot plot, int i) {
+		PlotObject plotObject = plot.getPlotObjectDeepClone(i);
+		plotObject.unsetFlag(PlotObject.CONSTRUCTOR_DATA);
+		allPlotObjects.add(plotObject);
+		int index = allPlotObjects.size() - 1;
+		return index;
+	}
+
+	/** Get the style of the i-th PlotObject (curve, label, ...) in the sequence
+	 *	they were added (including hidden ones), as String with comma delimiters:
+	 *	Main Color, Secondary Color (or "none"), Line Width [, Symbol shape for XY_DATA] [,hidden]
+	 *  PlotObjects here refers to curves, arrows, labels etc.
+	 *  (not legend, exes and frame, though implemented as PlotObjects) */
+	public String getPlotObjectStyle(int i) {
+		return getPlotObjectStyle(allPlotObjects.get(i));
+	}
+
+	String getPlotObjectStyle(PlotObject plotObject) {
+		String styleString = Colors.colorToString(plotObject.color) + "," +
+				Colors.colorToString(plotObject.color2) + "," +
+				plotObject.lineWidth;
+		if (plotObject.type == PlotObject.XY_DATA)
+			styleString += ","+SHAPE_NAMES[plotObject.shape];
+		if (plotObject.hasFlag(PlotObject.HIDDEN))
+			styleString += ",hidden";
+		return styleString;
+	}
+
+	/** Get the label the i-th PlotObject (in the sequence how they were added, including hidden ones).
+	 *  Returns null if no label. PlotObjects here refers to curves, arrows, labels etc.
+	 *  (not legend, exes and frame, though implemented as PlotObjects) */
+	public String getPlotObjectLabel(int i) {
+		return allPlotObjects.get(i).label;
+	}
+
+	/** Set the label the i-th PlotObject (in the sequence how they were added, including hidden ones)
+	 *  PlotObjects here refers to curves, arrows, labels etc.
+	 *  (not legend, exes and frame, though implemented as PlotObjects) */
+	public void setPlotObjectLabel(int i, String label) {
+		allPlotObjects.get(i).label = label;
+	}
+
+	/** Sets the style of the specified PlotObject (curve, label, etc.) from a
+	 *	comma-delimited string ("color1,color2,lineWidth[,symbol][,hidden]"),
+	 *  where "color2" can be "none" and "symbol" and "hidden" are optional.
+	 *  PlotObjects here refers to curves, arrows, labels etc.
+	 *  (not legend, exes and frame, though implemented as PlotObjects) */
+	public void setStyle(int index, String style) {
+		if (index<0 || index>=allPlotObjects.size())
+			throw new IllegalArgumentException("Index out of range");
+		setPlotObjectStyle(allPlotObjects.get(index), style);
+	}
+
+	public void setPlotObjectStyle(int i, String styleString) {
+		setStyle(i, styleString);
+	}
+
+	void setPlotObjectStyle(PlotObject plotObject, String styleString) {
+		String[] items = styleString.split(",");
+		int nItems = items.length;
+		if (items[nItems-1].indexOf("hidden") >= 0) {
+			plotObject.setFlag(PlotObject.HIDDEN);
+			nItems = items.length - 1;
+		} else
+			plotObject.unsetFlag(PlotObject.HIDDEN);
+		plotObject.color = Colors.decode(items[0].trim(), plotObject.color);
+		plotObject.color2 = Colors.decode(items[1].trim(), null);
+		float lineWidth = plotObject.lineWidth;
+		if (items.length >= 3) try {
+			plotObject.lineWidth = Float.parseFloat(items[2].trim());
+		} catch (NumberFormatException e) {};
+		if (items.length >= 4 && plotObject.shape!=CUSTOM)
+			plotObject.shape = toShape(items[3].trim());
+		updateImage();
+		return;
+	}
+
+	/** Returns the index of the first plot object with x,y data (points, line) or arrows
+	 *  with all data equal to those given.  Returns or -1 is no such plot object exists.
+	 *  The array 'values' should contain the x, y, x error bar, yerror bar data. The 'values' array may have any size;
+	 *  only the data given are compared (e.g. for an array with length 2, there is no check for erro bars).
+	 *  Used when adding data from a table not to suggest the same data twice. */
+	public int getPlotObjectIndex(float[][] values) {
+		return getPlotObjectIndex(PlotObject.XY_DATA|PlotObject.ARROWS, values);
+	}
+
+	/** Returns the index of the first plot object fitting the type mask and with all data equal to those given.
+	 *  ('mask' should be a bitwise or of the types desired)
+	 *  Returns or -1 is no such plot object exists.
+	 *  The array 'values' should contain the x, y, x error bar, yerror bar data. The 'values' array may have any size;
+	 *  only the data given are compared (e.g. for an array with length 2, there is no check for erro bars).
+	 *  Used when adding data from a table not to suggest the same data twice. */
+	int getPlotObjectIndex(int typeMask, float[][] values) {
+		for (int i=0; i<allPlotObjects.size(); i++) {
+			PlotObject plotObject = allPlotObjects.get(i);
+			if ((plotObject.type & typeMask) == 0) continue;
+			float[][] plotObjectArrays = plotObject.getAllDataValues();
+			boolean equal = true;
+			for (int j=0; j<Math.min(plotObjectArrays.length, values.length); j++) {
+				if (!Arrays.equals(plotObjectArrays[j], values[j])) {
+					equal = false;
+					break;
+				}
+			}
+			if (equal) return i;
+		}
+		return -1;
+	}
+
+	/** Creates a snapshot of the plot contents (not including axis formats etc),
+	 *  for later undo by restorePlotObjects. See also killPlotObjectsSnapshot */
+	public void savePlotObjects() {
+		allPlotObjectsSnapshot = new Vector<PlotObject>(allPlotObjects.size());
+		copyPlotObjectsVector(allPlotObjects, allPlotObjectsSnapshot);
+	}
+
+	/** Restores the plot contents (not including axis formats etc) from the snapshot
+	 *  previously created by savePlotObjects(). See also killPlotObjectsSnapshot
+	 *  Use 'update' to update the plot thereafter. */
+	public void restorePlotObjects() {
+		if (allPlotObjectsSnapshot != null)
+			copyPlotObjectsVector(allPlotObjectsSnapshot, allPlotObjects);
+	}
+
+	/** Deletes the snapshot of the plot contents to make space */
+	public void killPlotObjectsSnapshot() {
+		allPlotObjectsSnapshot = null;
+	}
+
+	/** Creates a snapshot of the plot properties (formatting, range etc., not PlotObjects such as data and corresponding curves etc.),
+	 *  for later undo by restorePlotProperties. See also killPlotPropertiesSnapshot */
+	public void savePlotPlotProperties() {
+		pp.rangeMinMax = currentMinMax;
+		ppSnapshot = pp.deepClone();
+	}
+
+	/** Restores the plot properties (formatting, range etc., not PlotObjects such as data and corresponding curves etc.)
+	 *  from a snapshot previously created by savePlotPlotProperties. See also killPlotPropertiesSnapshot.
+ 	 *  Use 'update' to update the plot thereafter. */
+	public void restorePlotProperties() {
+		pp = ppSnapshot.deepClone();
+		System.arraycopy(pp.rangeMinMax, 0, currentMinMax, 0, Math.min(pp.rangeMinMax.length, currentMinMax.length));
+	}
+
+	/** Deletes the snapshot of the plot properties to make space */
+	public void killPlotPropertiesSnapshot() {
+		ppSnapshot = null;
+	}
+
+	private void copyPlotObjectsVector(Vector<PlotObject> src, Vector<PlotObject>dest) {
+		if (dest.size() > 0) dest.removeAllElements();
+		for (PlotObject plotObject : src)
+			dest.add(plotObject.deepClone());
+	}
+
+	PlotObject getPlotObjectDeepClone(int i) {
+		return allPlotObjects.get(i).deepClone();
+	}
+
+	/** Sets the plot range to the initial value determined from minima&maxima or given by setLimits.
+	 *	Updates the image if existing and updateImg is true */
+	public void setLimitsToDefaults(boolean updateImg) {
+		saveMinMax();
+		System.arraycopy(defaultMinMax, 0, currentMinMax, 0, defaultMinMax.length);
+		if (plotDrawn && updateImg) updateImage();
+	}
+
+	/** Sets the plot range to encompass all data. Updates the image if existing and updateImg is true. */
+	public void setLimitsToFit(boolean updateImg) {
+		saveMinMax();
+		currentMinMax = getMinAndMax(true, ALL_AXES_RANGE);
+		if (Double.isNaN(defaultMinMax[0]) && Double.isNaN(defaultMinMax[2])) //no range at all so far
+			System.arraycopy(currentMinMax, 0, defaultMinMax, 0, Math.min(currentMinMax.length, defaultMinMax.length));
+
+		enlargeRange(currentMinMax);              //avoid points exactly at the border
+		//System.arraycopy(currentMinMax, 0, defaultMinMax, 0, currentMinMax.length);
+		if (plotDrawn && updateImg) updateImage();
+	}
+
+	/** reverts plot range to previous values and updates the image */
+	public void setPreviousMinMax() {
+		if (Double.isNaN(savedMinMax[0])) return;  //no saved values yet
+		double[] swap = new double[currentMinMax.length];
+		System.arraycopy(currentMinMax, 0, swap, 0, currentMinMax.length);
+		System.arraycopy(savedMinMax, 0, currentMinMax, 0, currentMinMax.length);
+		System.arraycopy(swap, 0, savedMinMax, 0, currentMinMax.length);
+		updateImage();
+	}
+
+	/** Draws the plot (if not done before) in an ImageProcessor and returns the ImageProcessor with the plot. */
+	public ImageProcessor getProcessor() {
+		draw();
+		return ip;
+	}
+
+	/** Returns the plot as an ImagePlus.
+	 *	If an ImagePlus for this plot already exists, displays the plot in that ImagePlus and returns it. */
+	public ImagePlus getImagePlus() {
+		if (stack != null) {
+			if (imp != null)
+				return imp;
+			else {
+				imp = new ImagePlus(title, stack);
+				adjustCalibration(imp.getCalibration());
+				return imp;
+			}
+		}
+		if (plotDrawn)
+			updateImage();
+		else
+			draw();
+		if (imp != null) {
+			if (imp.getProcessor() != ip)
+				imp.setProcessor(ip);
+			return imp;
+		} else {
+			ImagePlus imp = new ImagePlus(title, ip);
+			setImagePlus(imp);
+			return imp;
+		}
+	}
+
+	/** Sets the ImagePlus where the plot will be displayed. If the ImagePlus is not
+	 *	known otherwise (e.g. from getImagePlus), this is needed for changes such as
+	 *	zooming in to work correctly. It also sets the calibration of the ImagePlus.
+	 *	The ImagePlus is not displayed or updated unless its ImageProcessor is
+	 *  no that of the current Plot (then it gets this ImageProcessor).
+	 *  Does nothing if imp is unchanged and has the ImageProcessor of this plot.
+	 *  'imp' may be null to disconnect the plot from its ImagePlus.
+	 *	Does nothing for Plot Stacks. */
+	public void setImagePlus(ImagePlus imp) {
+		if (imp != null && imp == this.imp && imp.getProcessor() == ip)
+			return;
+		if (stack != null)
+			return;
+		if (this.imp != null)
+			this.imp.setProperty(PROPERTY_KEY, null);
+		this.imp = imp;
+		if (imp != null) {
+			imp.setIgnoreGlobalCalibration(true);
+			adjustCalibration(imp.getCalibration());
+			imp.setProperty(PROPERTY_KEY, this);
+			if (ip != null && imp.getProcessor() != ip)
+				imp.setProcessor(ip);
+		}
+	}
+
+	/** Adjusts a Calibration object to fit the current axes.
+	 *	For log axes, the calibration refers to the base-10 logarithm of the value */
+	public void adjustCalibration(Calibration cal) {
+		if (xMin == xMax)	//tiff images can't handle infinity in scale, see TiffEncoder.writeScale
+			xScale = 1e6;
+		if (yMin == yMax)
+			yScale = 1e6;
+		cal.xOrigin = xBasePxl-xMin*xScale;
+		cal.pixelWidth	= 1.0/Math.abs(xScale); //Calibration must not have negative pixel size
+		cal.yOrigin = yBasePxl+yMin*yScale;
+		cal.pixelHeight = 1.0/Math.abs(yScale);
+		cal.setInvertY(yScale >= 0);
+		cal.setXUnit(" "); // avoid 'pixels' for scaled units
+		if (xMin == xMax)
+			xScale = Double.POSITIVE_INFINITY;
+		if (yMin == yMax)
+			yScale = Double.POSITIVE_INFINITY;
+	}
+
+	/** Displays the plot in a PlotWindow.
+	 *  Plot stacks are shown in a StackWindow, not in a PlotWindow;
+	 *  in this case the return value is null (use getImagePlus().getWindow() instead).
+	 *  Also returns null in BatchMode. Note that the PlotWindow might get closed
+	 *  immediately if its 'listValues' and 'autoClose' flags are set.
+	 *  @see #update()
+	 */
+	public PlotWindow show() {
+		PlotVirtualStack stack = getStack();
+		if (stack!=null) {
+			getImagePlus().show();
+			return null;
+		}
+		if ((IJ.macroRunning() && IJ.getInstance()==null) || Interpreter.isBatchMode()) {
+			imp = getImagePlus();
+			imp.setPlot(this);
+			WindowManager.setTempCurrentImage(imp);
+			if (getMainCurveObject() != null) {
+				imp.setProperty("XValues", getXValues()); // Allows values to be retrieved by
+				imp.setProperty("YValues", getYValues()); // by Plot.getValues() macro function
+			}
+			Interpreter.addBatchModeImage(imp);
+			return null;
+		}
+		if (imp != null) {
+			Window win = imp.getWindow();
+			if (win instanceof PlotWindow && win.isVisible()) {
+				updateImage();			// show in existing window
+				return (PlotWindow)win;
+			} else
+				setImagePlus(null);
+		}
+		PlotWindow pw = new PlotWindow(this);		//note: this may set imp to null if pw has listValues and autoClose are set
+		if (IJ.isMacro() && imp!=null) // wait for plot to be displayed
+			IJ.selectWindow(imp.getID());
+		return pw;
+	}
+
+	/**
+	 * Appends the current plot to a virtual stack and resets allPlotObjects
+	 * for next slice
+	 * N. Vischer
+	 */
+	public void addToStack() {
+		if (stack==null)
+			stack = new PlotVirtualStack(getSize().width,getSize().height);
+		draw();
+		stack.addPlot(this);
+		IJ.showStatus("addToPlotStack: "+stack.size());
+		allPlotObjects.clear();
+		textLoc = null;
+	}
+
+	public void appendToStack() { addToStack(); }
+
+	/** Returns the virtual stack created by addToStack(). */
+	public PlotVirtualStack getStack() {
+		IJ.showStatus("");
+		return stack;
+	}
+
+	/** Draws the plot specified for the first time. Does nothing if the plot has been drawn already.
+	 *	Call getProcessor to retrieve the ImageProcessor with it.
+	 *	Does no action with respect to the ImagePlus (if any) */
+	public void draw() {
+		//IJ.log("draw(); plotDrawn="+plotDrawn);
+		if (plotDrawn) return;
+		getInitialMinAndMax();
+		pp.frame.setFont(nonNullFont(pp.frame.getFont(), currentFont)); //make sure we have a number font for calculating the margins
+		getBlankProcessor();
+		drawContents(ip);
+	}
+
+	/** Freezes or unfreezes the plot. In the frozen state, the plot cannot be resized or updated,
+	 *	and the Plot class does no modifications to the ImageProcessor.
+	 *	Changes are recorded nevertheless and become effective with <code>setFrozen(false)</code>. */
+	public void setFrozen(boolean frozen) {
+		pp.isFrozen = frozen;
+		if (!pp.isFrozen) {	// unfreeze operations ...
+			if (imp != null && ip != null) {
+				ImageCanvas ic = imp.getCanvas();
+				if (ic instanceof PlotCanvas) {
+					((PlotCanvas)ic).resetMagnification();
+					imp.setTitle(imp.getTitle());   //update magnification in title
+				}
+				Undo.setup(Undo.TRANSFORM, imp);
+			}
+			updateImage();
+			ImageWindow win = imp == null ? null : imp.getWindow();
+			if (win != null) win.updateImage(imp); //show any changes made during the frozen state
+		}
+	}
+
+	public boolean isFrozen() {
+		return pp.isFrozen;
+	}
+
+	/** Draws the plot again, ignored if the plot has not been drawn before or the plot is frozen. */
+	public void update() {
+		updateImage();
+	}
+
+	/** Draws the plot again, ignored if the plot has not been drawn before or the plot is frozen.
+	 *	If the ImagePlus exist, updates it and its calibration. */
+	public void updateImage() {
+		if (!plotDrawn || pp.isFrozen) return;
+		getBlankProcessor();
+		drawContents(ip);
+		if (imp == null || stack != null) return;
+		adjustCalibration(imp.getCalibration());
+		imp.updateAndDraw();
+		if (ip != imp.getProcessor())
+			imp.setProcessor(ip);
+	}
+
+	/** Returns the rectangle where the data are plotted.
+	 *	This rectangle includes the black outline frame at the top and left, but not at the bottom
+	 *	and right (when the frame is plotted with 1 pxl width).
+	 *	The image scale is its width or height in pixels divided by the data range in x or y. */
+	public Rectangle getDrawingFrame() {
+		if (frame == null)
+			getBlankProcessor(); //setup frame if not done yet
+		return new Rectangle(frame.x, frame.y, frameWidth, frameHeight);
+	}
+
+	/** Creates a new high-resolution plot by scaling it and displays that plot if showIt is true.
+	 *	<code>title</code> may be null, then a default title is used. */
+	public ImagePlus makeHighResolution(String title, float scale, boolean antialiasedText, boolean showIt) {
+		Plot hiresPlot = null;
+		try {
+			hiresPlot = (Plot)clone();	//shallow clone, thus arrays&objects are not cloned, but they will be used only now
+		} catch (Exception e) {return null;}
+		hiresPlot.ip = null;
+		hiresPlot.imp = null;
+		hiresPlot.pp = pp.clone();
+		if (!plotDrawn) hiresPlot.getInitialMinAndMax();
+		hiresPlot.setScale(scale);
+		hiresPlot.setAntialiasedText(antialiasedText);
+		hiresPlot.defaultMinMax = currentMinMax.clone();
+		ImageProcessor hiresIp = hiresPlot.getProcessor();
+		if (title == null || title.length() == 0)
+			title = getTitle()+"_HiRes";
+		title = WindowManager.makeUniqueName(title);
+		ImagePlus hiresImp = new ImagePlus(title, hiresIp);
+		Calibration cal = hiresImp.getCalibration();
+		hiresPlot.adjustCalibration(cal);
+		if (showIt) {
+			hiresImp.setIgnoreGlobalCalibration(true);
+			hiresImp.show();
+		}
+		hiresPlot.dispose(); //after drawing, we don't need the plot of the high-resolution image any more
+		return hiresImp;
+	}
+
+	/** Releases the ImageProcessor and ImagePlus associated with the plot.
+	 *	May help garbage collection because some garbage collectors
+	 *	are said to be inefficient with circular references. */
+	public void dispose() {
+		if (imp != null)
+			imp.setProperty(PROPERTY_KEY, null);
+		imp = null;
+		ip = null;
+	}
+
+	/** Converts pixels to calibrated coordinates. In contrast to the image calibration, also
+	 *	works with log axes and inverted x axes */
+	public double descaleX(int x) {
+		if (xMin == xMax) return xMin;
+		double xv = (x-xBasePxl)/xScale + xMin;
+		if (logXAxis) xv = Math.pow(10, xv);
+		return xv;
+	}
+
+	/** Converts pixels to calibrated coordinates. In contrast to the image calibration, also
+	 *	works with log axes */
+	public double descaleY(int y) {
+		if (yMin == yMax) return yMin;
+		double yv = (yBasePxl-y)/yScale +yMin;
+		if (logYAxis) yv = Math.pow(10, yv);
+		return yv;
+	}
+
+
+	/** Converts calibrated coordinates to pixel coordinates. In contrast to the image calibration, also
+	 *	works with log x axis and inverted x axis */
+	public double scaleXtoPxl(double x) {
+		if (xMin == xMax) {
+			if (x==xMin) return xBasePxl;
+			else return x>xMin ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+		}
+		if (logXAxis)
+			return xBasePxl+(Math.log10(x)-xMin)*xScale;
+		else
+			return xBasePxl+(x-xMin)*xScale;
+	}
+
+	/** Converts calibrated coordinates to pixel coordinates. In contrast to the image calibration, also
+	 *	works with log y axis */
+	public double scaleYtoPxl(double y) {
+		if (yMin == yMax) {
+			if (y==xMin) return yBasePxl;
+			else return y>yMin ? Double.POSITIVE_INFINITY : Double.NEGATIVE_INFINITY;
+		}
+		if (logYAxis)
+			return yBasePxl-(Math.log10(y)-yMin)*yScale;
+		else
+			return yBasePxl-(y-yMin)*yScale;
+	}
+
+	/** Calibrated coordinates to integer pixel coordinates */
+	private int scaleX(double x) {
+		if (xMin == xMax) {
+			if (x==xMin) return xBasePxl;
+			else return x>xMin ? Integer.MAX_VALUE : Integer.MIN_VALUE;
+		}
+		if (logXAxis)
+			return xBasePxl+(int)Math.round((Math.log10(x)-xMin)*xScale);
+		else
+			return xBasePxl+(int)Math.round((x-xMin)*xScale);
+	}
+
+	/** Converts calibrated coordinates to pixel coordinates. In contrast to the image calibration, also
+	 *	works with log axes */
+	private int scaleY(double y) {
+		if (yMin == yMax) {
+			if (y==yMin) return yBasePxl;
+			else return y>yMin ? Integer.MAX_VALUE : Integer.MIN_VALUE;
+		}
+		if (logYAxis)
+			return yBasePxl-(int)Math.round((Math.log10(y)-yMin)*yScale);
+		else
+			return yBasePxl-(int)Math.round((y-yMin)*yScale);
+	}
+
+	/** Converts calibrated coordinates to pixel coordinates. In contrast to the image calibration, also
+	 *	works with log axes and inverted x axes. Returns a large number instead NaN for log x axis and zero or negative x */
+	private int scaleXWithOverflow(double x) {
+		if (!logXAxis || x>0)
+			return scaleX(x);
+		else
+			return xScale > 0 ? -1000000 : 1000000;
+	}
+
+	/** Converts calibrated coordinates to pixel coordinates. In contrast to the image calibration, also
+	 *	works with log axes and inverted x axes. Returns a large number instead NaN for log y axis and zero or negative y */
+	private int scaleYWithOverflow(double y) {
+		if (!logYAxis || y>0)
+			return scaleY(y);
+		else
+			return yScale > 0 ? 1000000 : -1000000;
+	}
+
+	/** Scales a value of the original plot for a high-resolution plot. Returns an integer number of pixels >=1 */
+	int sc(float length) {
+		int pixels = (int)(length*scale + 0.5);
+		if (pixels < 1) pixels = 1;
+		return pixels;
+	}
+
+	/** Scales a font of the original plot for a high-resolution plot. */
+	Font scFont(Font font) {
+		float size = font.getSize2D();
+		return scale==1 ? font : font.deriveFont(size*scale);
+	}
+
+	/** Returns whether the plot requires color (not grayscale) */
+	boolean isColored() {
+		for (PlotObject plotObject : allPlotObjects)
+			if (isColored(plotObject.color) || isColored(plotObject.color2))
+				return true;
+		for (PlotObject plotObject : pp.getAllPlotObjects())
+			if (plotObject != null && (isColored(plotObject.color) || isColored(plotObject.color2)))
+				return true;
+		return false;
+	}
+
+	/** Whether a color is non-grayscale, which requires color (not grayscale) for the plot */
+	boolean isColored(Color c) {
+		if (c == null) return false;
+		return c.getRed() != c.getGreen() || c.getGreen() != c.getBlue();
+	}
+
+	/** Draws the plot contents (all PlotObjects and the frame and legend), without axes etc. */
+	void drawContents(ImageProcessor ip) {
+		makeRangeGetSteps();
+		ip.setColor(Color.black);
+		ip.setLineWidth(sc(1));
+		float lineWidth = 1;
+		Color color = Color.black;
+		Font font = defaultFont;
+
+		// draw all the plot objects in the sequence they were added, except for the one of the constructor
+		for (PlotObject plotObject : allPlotObjects)
+			if (!plotObject.hasFlag(PlotObject.CONSTRUCTOR_DATA)) {
+				//properties lineWidth, Font, Color set for one object remain for the next object unless changed
+				if (plotObject.lineWidth > 0)
+					lineWidth = plotObject.lineWidth;
+				else
+					plotObject.lineWidth = lineWidth;
+				if (plotObject.color != null)
+					color = plotObject.color;
+				else
+					plotObject.color = color;
+				if (plotObject.getFont() != null)
+					font = plotObject.getFont();
+				else
+					plotObject.setFont(font);
+				//IJ.log("type="+plotObject.type+" color="+plotObject.color);
+				drawPlotObject(plotObject, ip);
+			}
+
+		// draw the line passed with the constructor last, using the settings present when calling 'draw'
+		if (allPlotObjects.size()>0 && allPlotObjects.get(0).hasFlag(PlotObject.CONSTRUCTOR_DATA)) {
+			PlotObject mainPlotObject = allPlotObjects.get(0);
+			if (mainPlotObject.lineWidth == 0)
+				mainPlotObject.lineWidth = currentLineWidth == 0 ? 1 : currentLineWidth;
+			lineWidth = mainPlotObject.lineWidth;
+			if (mainPlotObject.color == null)
+				mainPlotObject.color = currentColor == null ? Color.black : currentColor;
+			drawPlotObject(mainPlotObject, ip);
+		} else {
+			if (currentLineWidth > 0) lineWidth = currentLineWidth; //linewidth when drawing determines frame linewidth
+		}
+
+		// finally draw the frame & legend
+		if (!plotDrawn && pp.frame.lineWidth==DEFAULT_FRAME_LINE_WIDTH) {  //when modifying PlotObjects styles later, don't change the frame line width any more
+			pp.frame.lineWidth = lineWidth;
+			if (pp.frame.lineWidth == 0) pp.frame.lineWidth = 1;
+			if (pp.frame.lineWidth > 3) pp.frame.lineWidth = 3;
+		}
+		ip.setLineWidth(sc(pp.frame.lineWidth));
+		ip.setColor(pp.frame.color);
+		int x2 = frame.x + frame.width - 1;
+		int y2 = frame.y + frame.height - 1;
+		ip.moveTo(frame.x, frame.y);	// draw the frame. Can't use ip.drawRect because it is inconsistent for different lineWidths
+		ip.lineTo(x2, frame.y);
+		ip.lineTo(x2, y2);
+		ip.lineTo(frame.x, y2);
+		ip.lineTo(frame.x, frame.y);
+		if (pp.legend != null && (pp.legend.flags & LEGEND_POSITION_MASK) != 0)
+			drawPlotObject(pp.legend, ip);
+
+		plotDrawn = true;
+	}
+
+	/** Creates the processor if not existing, clears the background and prepares
+	 *	it for plotting. Also called by the PlotWindow class to prepare the window. */
+	ImageProcessor getBlankProcessor() {
+		makeMarginValues();
+		//IJ.log("Plot.getBlankPr preferredH="+preferredPlotHeight+" pp.h="+pp.height);
+		if (pp.width <= 0 || pp.height <= 0) {
+			pp.width = sc(preferredPlotWidth) + leftMargin + rightMargin;
+			pp.height = sc(preferredPlotHeight) + topMargin + bottomMargin;
+		}
+		frameWidth = pp.width - (leftMargin + rightMargin);
+		frameHeight = pp.height - (topMargin + bottomMargin);
+		boolean isColored = isColored();	//color, not grayscale required?
+		if (ip == null || pp.width != ip.getWidth() || pp.height != ip.getHeight() || (isColored != (ip instanceof ColorProcessor))) {
+			if (isColored) {
+				ip = new ColorProcessor(pp.width, pp.height);
+			} else {
+				ip = new ByteProcessor(pp.width, pp.height);
+				invertedLut = Prefs.useInvertingLut && !Interpreter.isBatchMode() && IJ.getInstance()!=null;
+				if (invertedLut) ip.invertLut();
+			}
+			if (imp != null && stack == null)
+				imp.setProcessor(ip);
+		}
+		if (ip instanceof ColorProcessor)
+			Arrays.fill((int[])(ip.getPixels()), 0xffffff);
+		else
+			Arrays.fill((byte[])(ip.getPixels()), invertedLut ? (byte)0 : (byte)0xff);
+
+		ip.setFont(scFont(defaultFont));
+		ip.setLineWidth(sc(1));
+		ip.setAntialiasedText(pp.antialiasedText);
+		frame = new Rectangle(leftMargin, topMargin, frameWidth+1, frameHeight+1);
+		if (pp.frame.color2 != null) {	//background color
+			ip.setColor(pp.frame.color2);
+			ip.setRoi(frame);
+			ip.fill();
+			ip.resetRoi();
+		}
+		ip.setColor(Color.black);
+		return ip;
+	}
+
+	/** Calculates the margin sizes and sets the class variables accordingly */
+	void makeMarginValues() {
+		Font font = nonNullFont(pp.frame.getFont(), currentFont);
+		float marginScale = 0.1f + 0.9f*font.getSize2D()/12f;
+		if (marginScale < 0.7f) marginScale = 0.7f;
+		if (marginScale > 2f) marginScale = 2f;
+		int addHspace = (int)Tools.getNumberFromList(pp.frame.options, "addhspace="); //user-defined extra space
+		int addVspace = (int)Tools.getNumberFromList(pp.frame.options, "addvspace=");
+		leftMargin	 = sc(LEFT_MARGIN*marginScale + addHspace);
+		rightMargin = sc(RIGHT_MARGIN*marginScale + addHspace);
+		topMargin = sc(TOP_MARGIN*marginScale + addVspace);
+		bottomMargin = sc(BOTTOM_MARGIN*marginScale + 2 + addVspace);
+		if(pp != null && pp.xLabel != null && pp.xLabel.getFont() != null){
+			float numberSize = font.getSize2D();
+			float labelSize = pp.xLabel.getFont().getSize2D();
+			float extraHeight = 1.5f *(labelSize - numberSize);
+			if(extraHeight > 0){
+				bottomMargin += sc(extraHeight);
+				leftMargin += sc(extraHeight);
+			}
+		}
+	}
+
+	/** Calculate the actual range, major step interval and set variables for data <-> pixels scaling */
+	double[] makeRangeGetSteps() {
+		steps = new double[2];
+		logXAxis = hasFlag(X_LOG_NUMBERS);
+		logYAxis = hasFlag(Y_LOG_NUMBERS);
+
+		for (int i=0; i<currentMinMax.length; i+=2) {  //for x and y direction
+			boolean logAxis = hasFlag(i==0 ? X_LOG_NUMBERS : Y_LOG_NUMBERS);
+			//don't zoom in too much (otherwise float conversion to int pixels may be wrong)
+			double range = currentMinMax[i+1]-currentMinMax[i];
+			double mid = 0.5*(currentMinMax[i+1]+currentMinMax[i]);
+			double relativeRange = Math.abs(range/mid);
+			if (!logAxis)
+				relativeRange = Math.min(relativeRange, Math.abs(range/(defaultMinMax[i+1]-defaultMinMax[i])));
+			if (range != 0 && relativeRange<1e-4) {
+				currentMinMax[i+1] = mid + 0.5*range*1e-4/relativeRange;
+				currentMinMax[i] = mid - 0.5*range*1e-4/relativeRange;
+			}
+			//no log range if range is too small or not positive values
+			if (logAxis) {
+				double rangeRatio = currentMinMax[i+1]/currentMinMax[i];
+				if (!(rangeRatio > MIN_LOG_RATIO || 1./rangeRatio > MIN_LOG_RATIO) ||
+					!(currentMinMax[i] > 10*Float.MIN_VALUE)  || !(currentMinMax[i+1] > 10*Float.MIN_VALUE))
+				logAxis = false;
+			}
+			//for log axes, temporarily work on the logarithm
+			if (logAxis) {
+				currentMinMax[i] = Math.log10(currentMinMax[i]);
+				currentMinMax[i+1] = Math.log10(currentMinMax[i+1]);
+			}
+			// calculate grid or major tick interval
+			if ((i==0 && !simpleXAxis()) || (i==2 && !simpleYAxis())) {
+				int minGridspacing = i==0 ? MIN_X_GRIDSPACING : MIN_Y_GRIDSPACING;
+				int frameSize = i==0 ? frameWidth : frameHeight;
+				double step = Tools.getNumberFromList(pp.frame.options, i==0 ? "xinterval=" : "yinterval="); //user-defined interval
+				if (!Double.isNaN(step)) {
+					int nSteps = (int)(Math.floor(currentMinMax[i+1]/step+1e-10) - Math.ceil(currentMinMax[i]/step-1e-10));
+					if (nSteps < 1) step = Double.NaN;  //user-suppied interval too large, less than two numbers would be shown
+					if ((i==0 && nSteps*sc(minGridspacing)*0.5 > frameSize) || i!=0 && nSteps*sc(pp.frame.getFont().getSize()) > frameSize)
+						step = Double.NaN;              //user-suppied interval too small, too many numbers would be shown
+				}
+				if (Double.isNaN(step)) {               //automatic interval
+					step = Math.abs((currentMinMax[i+1] - currentMinMax[i]) *
+						Math.max(1.0/maxIntervals, (float)sc(minGridspacing)/frameSize+(maxIntervals>12 ? 0.02 : 0.06))); //the smallest allowable step
+					step = niceNumber(step);
+				}
+				if (logAxis && step < 1)
+					step = 1;
+				steps[i/2] = step;
+				//modify limits to grid or minor ticks if desired
+				boolean force2grid = hasFlag(i==0 ? X_FORCE2GRID : Y_FORCE2GRID) && !ignoreForce2Grid;
+				if (force2grid) {
+					int i1 = (int)Math.floor(Math.min(currentMinMax[i],currentMinMax[i+1])/step+1.e-10);
+					int i2 = (int)Math.ceil (Math.max(currentMinMax[i],currentMinMax[i+1])/step-1.e-10);
+					if (currentMinMax[i+1] > currentMinMax[i]) {	// care about inverted axes with max<min
+						currentMinMax[i] = i1 * step;
+						currentMinMax[i+1] = i2 * step;
+					} else {
+						currentMinMax[i] = i2 * step;
+						currentMinMax[i+1] = i1 * step;
+					}
+				//} else if (snapToMinorGrid) {
+				//	double stepForSnap = niceNumber(0.15*step);
+				//	if (!logXAxis || stepForSnap >= 0.999) {	//don't snap on log axis if minor ticks are not full decades
+				//		currentMinMax[i] = stepForSnap * Math.round(currentMinMax[i]/stepForSnap);
+				//		currentMinMax[i+1] = stepForSnap * Math.round(currentMinMax[i+1]/stepForSnap);
+				//	}
+				}
+			}
+			if (i==0) {
+				xMin = currentMinMax[i];
+				xMax = currentMinMax[i+1];
+				logXAxis = logAxis;
+			} else {
+				yMin = currentMinMax[i];
+				yMax = currentMinMax[i+1];
+				logYAxis = logAxis;
+			}
+			if (logAxis) {
+				currentMinMax[i] = Math.pow(10, currentMinMax[i]);
+				currentMinMax[i+1] = Math.pow(10, currentMinMax[i+1]);
+			}
+		}
+		//snapToMinorGrid = false;
+		ignoreForce2Grid = false;
+
+		// calculate what we need to convert the data to screen pixels
+		xBasePxl = leftMargin;
+		yBasePxl = topMargin + frameHeight;
+		xScale = frameWidth/(xMax-xMin);
+		if (!(xMax-xMin!=0.0))	  //if range==0 (all data the same), or NaN shift zero level so one can see the curve
+			xBasePxl += sc(10);
+		yScale = frameHeight/(yMax-yMin);
+		if (!(yMax-yMin!=0.0))
+			yBasePxl -= sc(10);
+		//IJ.log("x,yScale="+(float)xScale+","+(float)yScale+" xMin,max="+(float)xMin+","+(float)xMax+" yMin.max="+(float)yMin+","+(float)yMax);
+
+		drawAxesTicksGridNumbers(steps);
+		return steps;
+	}
+
+	public void redrawGrid(){
+		if (ip != null) {
+			ip.setColor(Color.black);
+			drawAxesTicksGridNumbers(steps);
+			ip.setColor(Color.black);
+		}
+	}
+
+	/** Gets the initial plot limits (i.e., x&y ranges). For compatibility with previous versions of ImageJ,
+	 *  only the first PlotObject (with numeric data) is used to determine the limits. */
+	void getInitialMinAndMax() {
+		int axisRangeFlags = 0;
+		if (Double.isNaN(defaultMinMax[0])) axisRangeFlags |= X_RANGE;
+		if (Double.isNaN(defaultMinMax[2])) axisRangeFlags |= Y_RANGE;
+		if (axisRangeFlags != 0) {
+			defaultMinMax = getMinAndMax(false, axisRangeFlags);
+			enlargeRange(defaultMinMax);
+		}
+		setLimitsToDefaults(false);			//use the range values to start with, but don't draw yet
+	}
+
+	/** Gets the minimum and maximum values from the first XY_DATA or ARROWS plotObject or all such plotObjects;
+	 *	axisRangeFlags determine for which axis to calculate the min&max (X_RANGE for x axis, Y_RANGE for y axis);
+	 *	for the other axes the limit is taken from defaultMinMax
+	 *	Array elements returned are xMin, xMax, yMin, yMax. Also sets enlargeRange to tell which limits should be enlarged
+	 *	beyond the minimum or maximum of the data */
+	double[] getMinAndMax(boolean allObjects, int axisRangeFlags) {
+		boolean invertedXAxis = currentMinMax[1] < currentMinMax[0];
+		boolean invertedYAxis = currentMinMax[3] < currentMinMax[2];
+		double xSign = invertedXAxis ? -1 : 1;
+		double ySign = invertedYAxis ? -1 : 1;
+		double[] allMinMax = new double[]{xSign*Double.MAX_VALUE, -xSign*Double.MAX_VALUE, ySign*Double.MAX_VALUE, -ySign*Double.MAX_VALUE};
+		for (int i=0; i<allMinMax.length; i++)
+			if (((axisRangeFlags>>i/2) & 1)==0)	  //keep default min & max for this axis
+				allMinMax[i] = defaultMinMax[i];
+		enlargeRange = new int[allMinMax.length];
+		for (PlotObject plotObject : allPlotObjects) {
+			if ((plotObject.type == PlotObject.XY_DATA || plotObject.type == PlotObject.ARROWS) && !plotObject.hasFlag(PlotObject.HIDDEN)) {
+				getMinAndMax(allMinMax, enlargeRange, plotObject, axisRangeFlags);
+				if (!allObjects) break;
+			}
+		}
+		if ((axisRangeFlags & X_RANGE) != 0) {
+			String[] xCats = labelsInBraces('x'); // if we have categories at the axis, make some space for this text
+			if (xCats != null) {
+				allMinMax[0] = Math.min(allMinMax[0], -0.5);
+				allMinMax[1] = Math.min(allMinMax[1], xCats.length+0.5);
+			}
+		}
+		if ((axisRangeFlags & Y_RANGE) != 0) {
+			String[] yCats = labelsInBraces('y');
+			if (yCats != null) {
+				allMinMax[2] = Math.min(allMinMax[2], -0.5);
+				allMinMax[3] = Math.min(allMinMax[3], yCats.length+0.5);
+			}
+		}
+		if (allMinMax[0]==Double.MAX_VALUE && allMinMax[1]==-Double.MAX_VALUE) { // no x values at all? keep previous
+			allMinMax[0] = defaultMinMax[0];
+			allMinMax[1] = defaultMinMax[1];
+		}
+		if (allMinMax[2]==Double.MAX_VALUE && allMinMax[3]==-Double.MAX_VALUE) { // no y values at all? keep previous
+			allMinMax[2] = defaultMinMax[2];
+			allMinMax[3] = defaultMinMax[3];
+		}
+		return allMinMax;
+	}
+
+	/** Enlarges the current minimum and maximum ranges to include the data range of the last plotObject added,
+	 *  if it is an XY_DATA or ARROWS plotObject.
+	 *  Does not set the new limits as default, does not redraw the plot. */
+	void fitRangeToLastPlotObject() {
+		if (allPlotObjects.size() < 1) return;
+		PlotObject plotObject = allPlotObjects.lastElement();
+		if (Double.isNaN(currentMinMax[0]) || Double.isNaN(currentMinMax[2])) {   // no range determined yet?
+			setLimitsToFit(false);
+		} else {   //we have min&max already, just extend the range if necessary
+			enlargeRange = new int[currentMinMax.length];
+			getMinAndMax(currentMinMax, enlargeRange, plotObject, ALL_AXES_RANGE);
+			enlargeRange(currentMinMax);
+		}
+	}
+
+	/** Gets the minimum and maximum values from an XY_DATA or ARROWS plotObject;
+	 *	axisRangeFlags determine for which axis (X_RANGE for x axis, Y_RANGE for y axis)
+	 *	The minimum modifies allMinAndMax[0] (x), allMinAndMax[2] (y); the maximum modifies [1], [3].
+	 *	If allMinAndMax values are modified, the corresponding enlargeRange array elements are also set */
+	void getMinAndMax(double[] allMinAndMax, int[] enlargeRange, PlotObject plotObject, int axisRangeFlags) {
+		boolean invertedXAxis = currentMinMax[1] < currentMinMax[0];
+		boolean invertedYAxis = currentMinMax[3] < currentMinMax[2];
+		if (plotObject.type == PlotObject.XY_DATA) {
+			if ((axisRangeFlags & X_RANGE) != 0) {
+				int suggestedEnlarge = 0;
+				if (!(plotObject.shape == LINE || plotObject.shape == FILLED) || plotObject.yEValues != null)
+					suggestedEnlarge = ALWAYS_ENLARGE;	//enlarge to make space at the obrders (we don't try to keep x=0 at the frame border)
+				getMinAndMax(allMinAndMax, enlargeRange, suggestedEnlarge, 0, plotObject.xValues, plotObject.xEValues, invertedXAxis);
+				if ((plotObject.shape == BAR || plotObject.shape == SEPARATED_BAR)&& plotObject.xValues.length > 1) {
+					int n = plotObject.xValues.length;
+					allMinAndMax[0] -= 0.5 * Math.abs(plotObject.xValues[1] - plotObject.xValues[0]);
+					allMinAndMax[1] += 0.5 * Math.abs(plotObject.xValues[n - 1] - plotObject.xValues[n - 2]);
+				}
+			}
+			if ((axisRangeFlags & Y_RANGE) != 0) {
+				int suggestedEnlarge = 0;
+				if (plotObject.shape==DOT || plotObject.xEValues != null) //these can't be seen if merging with the frame
+					suggestedEnlarge = ALWAYS_ENLARGE;
+				else if (!(plotObject.shape == LINE || plotObject.shape == FILLED))
+					suggestedEnlarge = USUALLY_ENLARGE;
+				getMinAndMax(allMinAndMax, enlargeRange,  suggestedEnlarge, 2, plotObject.yValues, plotObject.yEValues, invertedYAxis);
+				if ((plotObject.shape == BAR || plotObject.shape == SEPARATED_BAR) &&
+						(allMinAndMax[2] > 0 && allMinAndMax[3]/allMinAndMax[2] >= 2) && !logYAxis)
+					allMinAndMax[2] = 0;           // for bar plots, y min = 0 unless values differ less than a factor of 2
+			}
+		} else if (plotObject.type == PlotObject.ARROWS) {
+			if ((axisRangeFlags & X_RANGE) != 0) {
+				getMinAndMax(allMinAndMax, enlargeRange, ALWAYS_ENLARGE, 0, plotObject.xValues, null, invertedXAxis);
+				getMinAndMax(allMinAndMax, enlargeRange, ALWAYS_ENLARGE, 0, plotObject.xEValues, null, invertedXAxis);
+			}
+			if ((axisRangeFlags & Y_RANGE) != 0) {
+				getMinAndMax(allMinAndMax, enlargeRange, ALWAYS_ENLARGE, 2, plotObject.yValues, null, invertedYAxis);
+				getMinAndMax(allMinAndMax, enlargeRange, ALWAYS_ENLARGE, 2, plotObject.yEValues, null, invertedYAxis);
+			}
+		}
+	}
+
+	/** Gets the minimum and maximum values for a dataset (one direction, x or y),
+	 *  taking error bars (if not null) into account.
+	 *	The minimum modifies allMinAndMax[axisIndex] the maximum modifies allMinAndMax[axisIndex+1].
+	 *	Also cares about whether the range should be enlarged to avoid hiding markers at the borders:
+	 *  suggestedEnlarge is 0 for lines or a suggestion for the data type; if the allMinAndMax is
+	 *  range is extended, the corresponding enlargeRange item is set accordingly */
+	void getMinAndMax(double[] allMinAndMax, int[] enlargeRange, int suggestedEnlarge,
+			int axisIndex, float[] data, float[] errorBars, boolean invertedAxis) {
+		int nMinEqual = 0, nMaxEqual = 0;
+		int minIndex = invertedAxis ? axisIndex+1 : axisIndex;   // index of 'min' value in allMinAndMax, enlargeRange
+		int maxIndex = invertedAxis ? axisIndex : axisIndex+1;
+		for (int i=0; i<data.length; i++) {
+			double v1 = data[i];
+			double v2 = data[i];
+			if (errorBars != null && i<errorBars.length) {
+				v1 -= errorBars[i];
+				v2 += errorBars[i];
+			}
+			if (v1 < allMinAndMax[minIndex]) {
+				allMinAndMax[minIndex] = v1;
+				nMinEqual = 1;
+				enlargeRange[minIndex] = suggestedEnlarge;
+				if (suggestedEnlarge == 0 && ((i>0 && i<data.length-1) || v2 != v1)) //for lines except at the end: also enlarge
+					enlargeRange[minIndex] = USUALLY_ENLARGE;
+			} else if (v1 == allMinAndMax[minIndex])
+				nMinEqual++;
+			if (v2 > allMinAndMax[maxIndex]) {
+				allMinAndMax[maxIndex] = v2;
+				nMaxEqual = 1;
+				enlargeRange[maxIndex] = suggestedEnlarge;
+				if (suggestedEnlarge == 0 && ((i>0 && i<data.length-1) || v2 != v1)) //for lines except at the end: also enlarge
+					enlargeRange[maxIndex] = USUALLY_ENLARGE;
+			} else if (v2 == allMinAndMax[maxIndex])
+				nMaxEqual++;
+		}
+		//lines with many points (>10%) at min or max? Add extra space at borders ('usually', i.e. unless limit is zero)
+		if (enlargeRange[minIndex] == 0 && nMinEqual > 2 && nMinEqual*10 > data.length)
+			enlargeRange[minIndex] = USUALLY_ENLARGE;
+		if (enlargeRange[maxIndex] == 0 && nMaxEqual > 2 && nMaxEqual*10 > data.length)
+			enlargeRange[maxIndex] = USUALLY_ENLARGE;
+		//all data at min or max? Always add space to avoid hiding the line behind the frame
+		if (nMinEqual == data.length)
+			enlargeRange[minIndex] = ALWAYS_ENLARGE;
+		if (nMaxEqual == data.length)
+			enlargeRange[maxIndex] = ALWAYS_ENLARGE;
+		//same min or max as for current data set found already previously, but not asking yet for added space at borders?
+		if (nMinEqual>0 && enlargeRange[minIndex]<suggestedEnlarge)
+			enlargeRange[minIndex] = suggestedEnlarge;
+		if (nMaxEqual>0 && enlargeRange[maxIndex]<suggestedEnlarge)
+			enlargeRange[maxIndex] = suggestedEnlarge;
+	}
+
+	/** Saves the plot range for later restoring by 'setPreviousMinMax' */
+	void saveMinMax() {
+		if (!Arrays.equals(currentMinMax, savedMinMax))
+			System.arraycopy(currentMinMax, 0, savedMinMax, 0, currentMinMax.length);
+	}
+
+	/** Modifies automatic limits to avoid points exactly at the borders.
+	 *  This only happens for limits where the corresponding value of the class array 'enlargeRange' is set:
+	 *  ALWAYS_ENLARGE: always enlarges the range; USUALLY_ENLARGE means that the limits should not be shifted across zero */
+	void enlargeRange(double[] minMax) {
+		if (enlargeRange == null) return;
+		for (int a=0; a<Math.min(minMax.length, enlargeRange.length); a+=2) { //for all axes (0 for x, 2 for y)
+			boolean logAxis = a==0 ? logXAxis : logYAxis;
+			if (logAxis) {
+				minMax[a] = Math.log10(minMax[a]);
+				minMax[a+1] = Math.log10(minMax[a+1]);
+			}
+			double range = minMax[a+1] - minMax[a];
+			double tmpMin = minMax[a] - 0.015*range;
+			if (enlargeRange[a] == USUALLY_ENLARGE && !logAxis)  // 'weak' enlarging: dont traverse zero
+				minMax[a] = (tmpMin*minMax[a] <= 0) ? 0 : tmpMin;
+			else if (enlargeRange[a] == ALWAYS_ENLARGE)
+				minMax[a] = tmpMin;
+			double tmpMax = minMax[a+1] + 0.015*range;
+			if (enlargeRange[a+1] == USUALLY_ENLARGE && !logAxis)
+				minMax[a+1] = (tmpMax*minMax[a+1] <= 0) ? 0 : tmpMax;
+			else if (enlargeRange[a+1] == ALWAYS_ENLARGE)
+				minMax[a+1] = tmpMax;
+			if (logAxis) {
+				minMax[a] = Math.pow(10, minMax[a]);
+				minMax[a+1] = Math.pow(10, minMax[a+1]);
+			}
+		}
+	}
+
+	/** Returns the first font of the list that is not null, or defaultFont if both are null */
+	Font nonNullFont(Font font1, Font font2) {
+		if (font1 != null)
+			return font1;
+		else if (font2 != null)
+			return font2;
+		else return
+			defaultFont;
+	}
+
+	/** Zooms to a range given in pixels and updates the image */
+	void zoomToRect(Rectangle r) {
+		saveMinMax();
+		currentMinMax[0] = descaleX(r.x);
+		currentMinMax[1] = descaleX(r.x + r.width);
+		currentMinMax[2] = descaleY(r.y + r.height);
+		currentMinMax[3] = descaleY(r.y);
+		//snapToMinorGrid = true; //get nice bounds when zooming in
+		updateImage();
+	}
+
+	/**
+	 * Adjusts the plot range when the user clicks one of the overlay symbols at the
+	 * axes. Index numbers for arrows start with 0 at the 'down' arrow of the
+	 * lower side of the x axis and end with 7 the up arrow at the upper
+	 * side of the y axis. Numbers 8 & 9 are for "Reset Range" and "Fit All";
+	 * numbers 10-13 for a dialog to set a single limit, and 14-15 for an axis options dialog.
+	 * Numbers 10-15 must correspond to the dialogTypes as defined in PlotDialog.
+	 */
+	void zoomOnRangeArrow(int arrowIndex) {
+		if (arrowIndex < 0) return;
+		if (arrowIndex < 8) {//0..7 = arrows, 8 = Reset Range, 9 = Fit All, 10..13 = set single limit
+			int axisIndex = (arrowIndex / 4) * 2;  //0 for x, 2 for y
+			double min = axisIndex == 0 ? xMin : yMin;
+			double max = axisIndex == 0 ? xMax : yMax;
+			double range = max - min;
+			boolean isMin = (arrowIndex % 4) < 2;
+			boolean shrinkRange = arrowIndex % 4 == 1 || arrowIndex % 4 == 2;
+			double factor = Math.sqrt(2);
+			if (shrinkRange)
+				factor = 1.0 / factor;
+			if (isMin)
+				min = max - range * factor;
+			else
+				max = min + range * factor;
+			boolean logAxis = axisIndex == 0 ? logXAxis : logYAxis;
+			if (logAxis) {
+				min = Math.pow(10, min);
+				max = Math.pow(10, max);
+			}
+			currentMinMax[axisIndex] = min;
+			currentMinMax[axisIndex + 1] = max;
+		} else if (arrowIndex == 8) {
+			setLimitsToDefaults(false);
+		} else if (arrowIndex == 9) {
+			setLimitsToFit(false);
+		} else if (arrowIndex <= 15) {
+			int dialogType = arrowIndex;
+			new PlotDialog(this, dialogType).showDialog(imp.getWindow());
+		}
+		if (arrowIndex <= 9) // the PlotDialog cares about updating the plot
+			updateImage();
+	}
+
+	/**
+	 * Zooms in or out  active plots while keeping focus on cursor position
+	 * Above or below frame: zoom x only
+	 * Left or right of frame: zoom y only
+	 * Corners: focus is in center
+	 *  N. Vischer
+	*/
+	void zoom(int x, int y, double zoomFactor) {
+		boolean wasLogX = logXAxis;
+		boolean wasLogY = logYAxis;
+		double plotX = descaleX(x);
+		double plotY = descaleY(y);
+		IJ.showStatus ("" + plotX);
+		boolean insideX = x > frame.x && x < frame.x + frame.width;
+		boolean insideY = y > frame.y && y < frame.y + frame.height;
+		if (!insideX && !insideY) {
+			insideX = true;
+			insideY = true;
+			x = frame.x + frame.width / 2;
+			y = frame.y + frame.height / 2;
+		}
+		int leftPart = x - frame.x;
+		int rightPart = frame.x + frame.width - x;
+		int highPart = y - frame.y;
+		int lowPart = frame.y + frame.height - y;
+
+		if (insideX) {
+			currentMinMax[0] = descaleX((int) (x - leftPart / zoomFactor));
+			currentMinMax[1] = descaleX((int) (x + rightPart / zoomFactor));
+		}
+		if (insideY) {
+			currentMinMax[2] = descaleY((int) (y + lowPart / zoomFactor));
+			currentMinMax[3] = descaleY((int) (y - highPart / zoomFactor));
+		}
+		updateImage();
+		if (wasLogX != logXAxis ){//log-lin was automatically changed
+			int changedX = (int) scaleXtoPxl(plotX);
+			int left = changedX - leftPart;
+			int right = changedX + rightPart;
+			currentMinMax[0] = descaleX(left);
+			currentMinMax[1] = descaleX(right);
+			updateImage();
+		}
+		if (wasLogY != logYAxis){//log-lin was automatically changed
+			int changedY = (int) scaleYtoPxl(plotY);
+			int bottom = changedY + lowPart;
+			int top = changedY + highPart;
+			currentMinMax[2] = descaleY(bottom);
+			currentMinMax[3] = descaleY(top);
+			updateImage();
+		}
+	}
+
+	/** Moves the plot range by a given number of pixels and updates the image */
+	void scroll(int dx, int dy) {
+		if (logXAxis) {
+			currentMinMax[0] /= Math.pow(10, dx/xScale);
+			currentMinMax[1] /= Math.pow(10, dx/xScale);
+		} else {
+			currentMinMax[0] -= dx/xScale;
+			currentMinMax[1] -= dx/xScale;
+		}
+		if (logYAxis) {
+			currentMinMax[2] *= Math.pow(10, dy/yScale);
+			currentMinMax[3] *= Math.pow(10, dy/yScale);
+		} else {
+			currentMinMax[2] += dy/yScale;
+			currentMinMax[3] += dy/yScale;
+		}
+		updateImage();
+	}
+
+	/** Whether to draw simple axes without ticks, grid and numbers only for min, max*/
+	private boolean simpleXAxis() {
+		return !hasFlag(X_TICKS | X_MINOR_TICKS | X_LOG_TICKS | X_GRID | X_NUMBERS);
+	}
+
+	private boolean simpleYAxis() {
+		return !hasFlag(Y_TICKS | Y_MINOR_TICKS | Y_LOG_TICKS | Y_GRID | Y_NUMBERS);
+	}
+
+	/** Draws ticks, grid and axis label for each tick/grid line.
+	 *	The grid or major tick spacing in each direction is given by steps */
+	void drawAxesTicksGridNumbers(double[] steps) {
+
+		if (ip==null)
+			return;
+		String[] xCats = labelsInBraces('x');   // create categories for the axes (if any)
+		String[] yCats = labelsInBraces('y');
+		String multiplySymbol = getMultiplySymbol(); // for scientific notation
+		Font scFont = scFont(pp.frame.getFont());
+		Font scFontMedium = scFont.deriveFont(scFont.getSize2D()*10f/12f); //for axis numbers if full size does not fit
+		Font scFontSmall = scFont.deriveFont(scFont.getSize2D()*9f/12f);   //for subscripts
+		ip.setFont(scFont);
+		FontMetrics fm = ip.getFontMetrics();
+		int fontAscent = fm.getAscent();
+		ip.setJustification(LEFT);
+		// ---	A l o n g	X	A x i s
+		int yOfXAxisNumbers = topMargin + frameHeight + fm.getHeight()*5/4 + sc(2);
+		if (hasFlag(X_NUMBERS | (logXAxis ? (X_TICKS | X_MINOR_TICKS) : X_LOG_TICKS) + X_GRID)) {
+			Font baseFont = scFont;
+			boolean majorTicks = logXAxis ? hasFlag(X_LOG_TICKS) : hasFlag(X_TICKS);
+			boolean minorTicks = hasFlag(X_MINOR_TICKS);
+			minorTicks = minorTicks && (xCats == null);
+			double step = steps[0];
+			int i1 = (int)Math.ceil (Math.min(xMin, xMax)/step-1.e-10);
+			int i2 = (int)Math.floor(Math.max(xMin, xMax)/step+1.e-10);
+			int suggestedDigits = (int)Tools.getNumberFromList(pp.frame.options, "xdecimals="); //is not given, NaN cast to 0
+			int digits = getDigits(xMin, xMax, step, 7, suggestedDigits);
+			int y1 = topMargin;
+			int y2 = topMargin + frameHeight;
+			if (xMin==xMax) {
+				if (hasFlag(X_NUMBERS)) {
+					String s = IJ.d2s(xMin,getDigits(xMin, 0.001*xMin, 5, suggestedDigits));
+					int y = yBasePxl;
+					ip.drawString(s, xBasePxl-ip.getStringWidth(s)/2, yOfXAxisNumbers);
+				}
+			} else {
+				if (hasFlag(X_NUMBERS)) {
+					int w1 = ip.getStringWidth(IJ.d2s(currentMinMax[0], logXAxis ? -1 : digits));
+					int w2 = ip.getStringWidth(IJ.d2s(currentMinMax[1], logXAxis ? -1 : digits));
+					int wMax = Math.max(w1,w2);
+					if (wMax > Math.abs(step*xScale)-sc(8)) {
+						baseFont = scFontMedium;   //small font if there is not enough space for the numbers
+						ip.setFont(baseFont);
+					}
+				}
+
+				for (int i=0; i<=(i2-i1); i++) {
+					double v = (i+i1)*step;
+					int x = (int)Math.round((v - xMin)*xScale) + leftMargin;
+
+					if (xCats!= null) {
+						int index = (int) v;
+						double remainder =  Math.abs(v - Math.round(v));
+						if(index >= 0 && index < xCats.length  && remainder < 1e-9){
+							String s = xCats[index];
+							String[] parts = s.split("\n");
+							int w = 0;
+							for(int jj = 0; jj < parts.length; jj++)
+								w = Math.max(w, ip.getStringWidth(parts[jj]));
+
+							ip.drawString(s, x-w/2, yOfXAxisNumbers);
+							//ip.drawString(s, x-ip.getStringWidth(s)/2, yOfXAxisNumbers);
+						}
+						continue;
+					}
+
+					if (hasFlag(X_GRID)) {
+						ip.setColor(gridColor);
+						ip.drawLine(x, y1, x, y2);
+						ip.setColor(Color.black);
+					}
+					if (majorTicks) {
+						ip.drawLine(x, y1, x, y1+sc(tickLength));
+						ip.drawLine(x, y2, x, y2-sc(tickLength));
+					}
+					if (hasFlag(X_NUMBERS)) {
+						if (logXAxis || digits<0) {
+							drawExpString(logXAxis ? Math.pow(10,v) : v, logXAxis ? -1 : -digits,
+									x, yOfXAxisNumbers-fontAscent/2, CENTER, fontAscent, baseFont, scFontSmall, multiplySymbol);
+						} else {
+							String s = IJ.d2s(v,digits);
+							ip.drawString(s, x-ip.getStringWidth(s)/2, yOfXAxisNumbers);
+						}
+					}
+				}
+				boolean haveMinorLogNumbers = i2-i1 < 2;		//nunbers on log minor ticks only if < 2 decades
+				if (minorTicks && (!logXAxis || step > 1.1)) {  //'standard' log minor ticks only for full decades
+					double mstep = niceNumber(step*0.19);       //non-log: 4 or 5 minor ticks per major tick
+					double minorPerMajor = step/mstep;
+					if (Math.abs(minorPerMajor-Math.round(minorPerMajor)) > 1e-10) //major steps are not an integer multiple of minor steps? (e.g. user step 90 deg)
+						mstep = step/4;
+					if (logXAxis && mstep < 1) mstep = 1;
+					i1 = (int)Math.ceil (Math.min(xMin,xMax)/mstep-1.e-10);
+					i2 = (int)Math.floor(Math.max(xMin,xMax)/mstep+1.e-10);
+					for (int i=i1; i<=i2; i++) {
+						double v = i*mstep;
+						int x = (int)Math.round((v - xMin)*xScale) + leftMargin;
+						ip.drawLine(x, y1, x, y1+sc(minorTickLength));
+						ip.drawLine(x, y2, x, y2-sc(minorTickLength));
+					}
+				} else if (logXAxis && majorTicks && Math.abs(xScale)>sc(MIN_X_GRIDSPACING)) {		//minor ticks for log
+					int minorNumberLimit = haveMinorLogNumbers ? (int)(0.12*Math.abs(xScale)/(fm.charWidth('0')+sc(2))) : 0;   //more numbers on minor ticks when zoomed in
+					i1 = (int)Math.floor(Math.min(xMin,xMax)-1.e-10);
+					i2 = (int)Math.ceil (Math.max(xMin,xMax)+1.e-10);
+					for (int i=i1; i<=i2; i++) {
+						for (int m=2; m<10; m++) {
+							double v = i+Math.log10(m);
+							if (v > Math.min(xMin,xMax) && v < Math.max(xMin,xMax)) {
+								int x = (int)Math.round((v - xMin)*xScale) + leftMargin;
+								ip.drawLine(x, y1, x, y1+sc(minorTickLength));
+								ip.drawLine(x, y2, x, y2-sc(minorTickLength));
+								if (m<=minorNumberLimit)
+									drawExpString(Math.pow(10,v), 0, x, yOfXAxisNumbers-fontAscent/2, CENTER,
+											fontAscent, baseFont, scFontSmall, multiplySymbol);
+							}
+						}
+					}
+				}
+			}
+		}
+		// ---	A l o n g	Y	A x i s
+		ip.setFont(scFont);
+		int maxNumWidth = 0;
+		int xNumberRight = leftMargin-sc(2)-ip.getStringWidth("0")/2;
+		Rectangle rect = ip.getStringBounds("0169");
+		int yNumberOffset = -rect.y-rect.height/2;
+		if (hasFlag(Y_NUMBERS | (logYAxis ? (Y_TICKS | Y_MINOR_TICKS) : Y_LOG_TICKS) + Y_GRID)) {
+			ip.setJustification(RIGHT);
+			Font baseFont = scFont;
+			boolean majorTicks = logYAxis ? hasFlag(Y_LOG_TICKS) : hasFlag(Y_TICKS);
+			boolean minorTicks = logYAxis ? hasFlag(Y_LOG_TICKS) : hasFlag(Y_MINOR_TICKS);
+			minorTicks = minorTicks && (yCats == null);
+			double step = steps[1];
+			int i1 = (int)Math.ceil (Math.min(yMin, yMax)/step-1.e-10);
+			int i2 = (int)Math.floor(Math.max(yMin, yMax)/step+1.e-10);
+			int suggestedDigits = (int)Tools.getNumberFromList(pp.frame.options, "ydecimals="); //is not given, NaN cast to 0
+			int digits = getDigits(yMin, yMax, step, 5, suggestedDigits);
+			int x1 = leftMargin;
+			int x2 = leftMargin + frameWidth;
+			if (yMin==yMax) {
+				if (hasFlag(Y_NUMBERS)) {
+					String s = IJ.d2s(yMin,getDigits(yMin, 0.001*yMin, 5, suggestedDigits));
+					maxNumWidth = ip.getStringWidth(s);
+					int y = yBasePxl;
+					ip.drawString(s, xNumberRight, y+fontAscent/2+sc(1));
+				}
+			} else {
+				int digitsForWidth = logYAxis ? -1 : digits;
+				if (digitsForWidth < 0) {
+					digitsForWidth--; //"1.0*10^5" etc. needs more space than 1.0*5, simulate by adding one decimal
+					xNumberRight += sc(1)+ip.getStringWidth("0")/4;
+				}
+				String str1 = IJ.d2s(currentMinMax[2], digitsForWidth);
+				String str2 = IJ.d2s(currentMinMax[3], digitsForWidth);
+				if (digitsForWidth < 0) {
+					str1 = str1.replaceFirst("E",multiplySymbol);
+					str2 = str2.replaceFirst("E",multiplySymbol);
+				}
+				int w1 = ip.getStringWidth(str1);
+				int w2 = ip.getStringWidth(str2);
+				int wMax = Math.max(w1,w2);
+				if (hasFlag(Y_NUMBERS)) {
+					if (wMax > xNumberRight - sc(4) - (pp.yLabel.label.length()>0 ? fm.getHeight() : 0)) {
+						baseFont = scFontMedium;   //small font if there is not enough space for the numbers
+						ip.setFont(baseFont);
+					}
+				}
+				//IJ.log(IJ.d2s(currentMinMax[2],digits)+": w="+w1+"; "+IJ.d2s(currentMinMax[3],digits)+": w="+w2+baseFont+" Space="+(leftMargin-sc(4+5)-fm.getHeight()));
+				for (int i=i1; i<=i2; i++) {
+					double v = step==0 ? yMin : i*step;
+					int y = topMargin + frameHeight - (int)Math.round((v - yMin)*yScale);
+
+					if (yCats != null){
+						int index = (int) v;
+						double remainder =  Math.abs(v - Math.round(v));
+						if(index >= 0 && index < yCats.length  && remainder < 1e-9){
+							String s = yCats[index];
+							int multiLineOffset = 0; // multi-line cat labels
+							for(int jj = 0; jj < s.length(); jj++)
+								if(s.charAt(jj) == '\n')
+									multiLineOffset -= rect.height/2;
+
+							ip.drawString(s, xNumberRight, y+yNumberOffset+ multiLineOffset);
+						}
+						continue;
+					}
+
+					if (hasFlag(Y_GRID)) {
+						ip.setColor(gridColor);
+						ip.drawLine(x1, y, x2, y);
+						ip.setColor(Color.black);
+					}
+					if (majorTicks) {
+						ip.drawLine(x1, y, x1+sc(tickLength), y);
+						ip.drawLine(x2, y, x2-sc(tickLength), y);
+					}
+					if (hasFlag(Y_NUMBERS)) {
+						int w = 0;
+						if (logYAxis || digits<0) {
+							w = drawExpString(logYAxis ? Math.pow(10,v) : v, logYAxis ? -1 : -digits,
+									xNumberRight, y, RIGHT, fontAscent, baseFont, scFontSmall, multiplySymbol);
+						} else {
+							String s = IJ.d2s(v,digits);
+							w = ip.getStringWidth(s);
+							ip.drawString(s, xNumberRight, y+yNumberOffset);
+						}
+						if (w > maxNumWidth) maxNumWidth = w;
+					}
+				}
+				boolean haveMinorLogNumbers = i2-i1 < 2;        //numbers on log minor ticks only if < 2 decades
+				if (minorTicks && (!logYAxis || step > 1.1)) {  //'standard' log minor ticks only for full decades
+					double mstep = niceNumber(step*0.19);       //non-log: 4 or 5 minor ticks per major tick
+					double minorPerMajor = step/mstep;
+					if (Math.abs(minorPerMajor-Math.round(minorPerMajor)) > 1e-10) //major steps are not an integer multiple of minor steps? (e.g. user step 90 deg)
+						mstep = step/4;
+					if (logYAxis && step < 1) mstep = 1;
+					i1 = (int)Math.ceil (Math.min(yMin,yMax)/mstep-1.e-10);
+					i2 = (int)Math.floor(Math.max(yMin,yMax)/mstep+1.e-10);
+					for (int i=i1; i<=i2; i++) {
+						double v = i*mstep;
+						int y = topMargin + frameHeight - (int)Math.round((v - yMin)*yScale);
+						ip.drawLine(x1, y, x1+sc(minorTickLength), y);
+						ip.drawLine(x2, y, x2-sc(minorTickLength), y);
+					}
+				}
+				if (logYAxis && majorTicks && Math.abs(yScale)>sc(MIN_X_GRIDSPACING)) {		 //minor ticks for log within the decade
+					int minorNumberLimit = haveMinorLogNumbers ? (int)(0.4*Math.abs(yScale)/fm.getHeight()) : 0;	//more numbers on minor ticks when zoomed in
+					i1 = (int)Math.floor(Math.min(yMin,yMax)-1.e-10);
+					i2 = (int)Math.ceil(Math.max(yMin,yMax)+1.e-10);
+					for (int i=i1; i<=i2; i++) {
+						for (int m=2; m<10; m++) {
+							double v = i+Math.log10(m);
+							if (v > Math.min(yMin,yMax) && v < Math.max(yMin,yMax)) {
+								int y = topMargin + frameHeight - (int)Math.round((v - yMin)*yScale);
+								ip.drawLine(x1, y, x1+sc(minorTickLength), y);
+								ip.drawLine(x2, y, x2-sc(minorTickLength), y);
+								if (m<=minorNumberLimit) {
+									int w = drawExpString(Math.pow(10,v), 0, xNumberRight, y, RIGHT,
+											fontAscent, baseFont, scFontSmall, multiplySymbol);
+									if (w > maxNumWidth) maxNumWidth = w;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+		// --- Write min&max of range if simple style without any axis format flags
+		ip.setFont(scFont);
+		ip.setJustification(LEFT);
+		String xLabelToDraw = pp.xLabel.label;
+		String yLabelToDraw = pp.yLabel.label;
+		if (simpleYAxis()) { // y-axis min&max
+			int digits = getDigits(yMin, yMax, 0.001*(yMax-yMin), 6, 0);
+			String s = IJ.d2s(yMax, digits);
+			int sw = ip.getStringWidth(s);
+			if ((sw+sc(4)) > leftMargin)
+				ip.drawString(s, sc(4), topMargin-sc(4));
+			else
+				ip.drawString(s, leftMargin-ip.getStringWidth(s)-sc(4), topMargin+10);
+			s = IJ.d2s(yMin, digits);
+			sw = ip.getStringWidth(s);
+			if ((sw+4)>leftMargin)
+				ip.drawString(s, sc(4), topMargin+frame.height);
+			else
+				ip.drawString(s, leftMargin-ip.getStringWidth(s)-sc(4), topMargin+frame.height);
+			if (logYAxis) yLabelToDraw += " (LOG)";
+		}
+		int y = yOfXAxisNumbers;
+		if (simpleXAxis()) { // x-axis min&max
+			int digits = getDigits(xMin, xMax, 0.001*(xMax-xMin), 7, 0);
+			ip.drawString(IJ.d2s(xMin,digits), leftMargin, y);
+			String s = IJ.d2s(xMax,digits);
+			ip.drawString(s, leftMargin + frame.width-ip.getStringWidth(s)+6, y);
+			y -= fm.getHeight();
+			if (logXAxis) xLabelToDraw += " (LOG)";
+		} else
+			y += sc(1);
+		// --- Write x and y axis text labels
+		if (xCats == null) {
+			ip.setFont(pp.xLabel.getFont() == null ? scFont : scFont(pp.xLabel.getFont()));
+			ImageProcessor xLabel = stringToPixels(xLabelToDraw);
+			if(xLabel != null){
+				int xpos = leftMargin+(frame.width-xLabel.getWidth())/2;
+				int ypos = y + scFont.getSize()/3;//topMargin + frame.height + bottomMargin-xLabel.getHeight();
+				ip.insert(xLabel, xpos, ypos);
+			}
+		}
+		if (yCats == null) {
+			ip.setFont(pp.yLabel.getFont() == null ? scFont : scFont(pp.yLabel.getFont()));
+			ImageProcessor yLabel = stringToPixels(yLabelToDraw);
+			if(yLabel != null){
+				yLabel = yLabel.rotateLeft();
+				int xRightOfYLabel = xNumberRight - maxNumWidth - sc(2);
+				int xpos = xRightOfYLabel - yLabel.getWidth() - sc(2);
+				int ypos = topMargin + (frame.height -yLabel.getHeight())/2;
+				ip.insert(yLabel, xpos, ypos);
+			}
+		}
+	}
+
+	/** Returns the array of categories from an axis label in the form {cat1,cat2,cat3}, or null if not this form
+	 *  @param labelCode  can be 'x' or 'y', for the x or y axis label*/
+	String[] labelsInBraces(char labelCode) {
+		String s = getLabel(labelCode);
+		if (s.startsWith("{") && s.endsWith("}")) {
+			String inBraces = s.substring(1, s.length() - 1);
+			String[] catLabels = inBraces.split(",");
+			return catLabels;
+		} else {
+			return null;
+		}
+	}
+
+	/** Returns the smallest "nice" number >= v. "Nice" numbers are .. 0.5, 1, 2, 5, 10, 20 ... */
+	double niceNumber(double v) {
+		double base = Math.pow(10,Math.floor(Math.log10(v)-1.e-6));
+		if (v > 5.0000001*base) return 10*base;
+		else if (v > 2.0000001*base) return 5*base;
+		else return 2*base;
+	}
+
+	/** draw something like 1.2 10^-9; returns the width of the string drawn.
+	 *	'Digits' should be >=0 for drawing the mantissa (=1.38 in this example), negative to draw only 10^exponent
+	 *	Currently only supports center justification and right justification (y of center line)
+	 *	Fonts baseFont, smallFont should be scaled already
+	 *  Returns the width of the String */
+	int drawExpString(double value, int digits, int x, int y, int justification,
+			int fontAscent, Font baseFont, Font smallFont, String multiplySymbol) {
+		String base = "10";
+		String exponent = null;
+		String s = IJ.d2s(value, digits<=0 ? -1 : -digits);
+		if (Tools.parseDouble(s) == 0) s = "0"; //don't write 0 as 0*10^0
+		int ePos = s.indexOf('E');
+		if (ePos < 0)
+			base = s;	//can't have exponential format, e.g. NaN
+		else {
+			if (digits>=0) {
+				base = s.substring(0,ePos);
+				if (digits == 0)
+					base = Integer.toString((int)Math.round(Tools.parseDouble(base)));
+				base += multiplySymbol+"10";
+			}
+			exponent = s.substring(ePos+1);
+		}
+		//IJ.log(s+" -> "+base+"^"+exponent+"  maxAsc="+fontAscent+" font="+baseFont);
+		ip.setJustification(RIGHT);
+		int width = ip.getStringWidth(base);
+		if (exponent != null) {
+			ip.setFont(smallFont);
+			int wExponent = ip.getStringWidth(exponent);
+			width += wExponent;
+			if (justification == CENTER) x += width/2;
+			ip.drawString(exponent, x, y+fontAscent*3/10);
+			x -= wExponent;
+			ip.setFont(baseFont);
+		}
+		ip.drawString(base, x, y+fontAscent*7/10);
+		return width;
+	}
+
+	/** Returns the user-supplied (via setOptions) or default multiplication symbol (middot) */
+	String getMultiplySymbol() {
+		String multiplySymbol = Tools.getStringFromList(pp.frame.options, "msymbol=");
+		if (multiplySymbol==null)
+			multiplySymbol = Tools.getStringFromList(pp.frame.options, "multiplysymbol=");
+		return multiplySymbol != null ? multiplySymbol : MULTIPLY_SYMBOL;
+	}
+
+	//Returns a pixelMap containting labelStr.
+	//Uses font of current ImageProcessor.
+	//Returns null for empty or blank-only strings
+	//Supports !!subscript!! and ^^superscript^^
+	ByteProcessor stringToPixels(String labelStr) {
+		Font bigFont = ip.getFont();
+		Rectangle rect = ip.getStringBounds(labelStr);
+		int ww = rect.width * 2;
+		int hh = rect.height * 3;//enough space, will be cropped later
+		int y0 = rect.height * 2;//base line
+		if (ww <= 0 || hh <= 0) {
+			return null;
+		}
+		ByteProcessor box = new ByteProcessor(ww, hh);
+		box.setColor(Color.WHITE);
+		//box.setColor(Color.LIGHT_GRAY); //make box visible for test
+		box.fill();
+		box.setColor(Color.black);
+		box.setAntialiasedText(pp.antialiasedText);
+		if (invertedLut) {
+			box.invertLut();
+		}
+		box.setFont(bigFont);
+
+		FontMetrics fm = box.getFontMetrics();
+		int ascent = fm.getAscent();
+		int offSub = ascent / 6;
+		int offSuper = -ascent / 2;
+		Font smallFont = bigFont.deriveFont((float) (bigFont.getSize() * 0.7));
+
+		Rectangle bigBounds = box.getStringBounds(labelStr);
+		boolean doParse = (labelStr.indexOf("^^") >= 0 || labelStr.indexOf("!!") >= 0);
+		doParse = doParse && (labelStr.indexOf("^^^") < 0 && labelStr.indexOf("!!!") < 0);
+		if (!doParse) {
+			box.drawString(labelStr, 0, y0);
+			Rectangle cropRect = new Rectangle(bigBounds);
+			cropRect.y += y0;
+			box.setRoi(cropRect);
+			ImageProcessor boxI = box.crop();
+			box = boxI.convertToByteProcessor();
+			return box;
+		}
+
+		if (labelStr.endsWith("^^") || labelStr.endsWith("!!")) {
+			labelStr = labelStr.substring(0, labelStr.length() - 2);
+		}
+		if (labelStr.startsWith("^^") || labelStr.startsWith("!!")) {
+			labelStr = " " + labelStr;
+		}
+
+		box.setFont(smallFont);
+		Rectangle smallBounds = box.getStringBounds(labelStr);
+		box.setFont(bigFont);
+		int upperBound = y0 + smallBounds.y + offSuper;
+		int lowerBound = y0 + smallBounds.y + smallBounds.height + offSub;
+
+		int h = fm.getHeight();
+		int len = labelStr.length();
+		int[] tags = new int[len];
+		int nTags = 0;
+
+		for (int jj = 0; jj < len - 2; jj++) {//get positions where font size changes
+			if (labelStr.substring(jj, jj + 2).equals("^^")) {
+				tags[nTags++] = jj;
+			}
+			if (labelStr.substring(jj, jj + 2).equals("!!")) {
+				tags[nTags++] = -jj;
+			}
+		}
+		tags[nTags++] = len;
+		tags = Arrays.copyOf(tags, nTags);
+
+		int leftIndex = 0;
+		int xRight = 0;
+		int y2 = y0;
+
+		boolean subscript = labelStr.startsWith("!!");
+		for (int pp = 0; pp < tags.length; pp++) {//draw all text fragments
+			int rightIndex = tags[pp];
+			rightIndex = Math.abs(rightIndex);
+			String part = labelStr.substring(leftIndex, rightIndex);
+			boolean small = pp % 2 == 1;//toggle odd/even
+			if (small) {
+				box.setFont(smallFont);
+				if (subscript) {
+					y2 = y0 + offSub;
+				} else {//superscript:
+					y2 = y0 + offSuper;
+				}
+			} else {
+				box.setFont(bigFont);
+				y2 = y0;
+			}
+			xRight++;
+			int partWidth = box.getStringWidth(part);
+			box.drawString(part, xRight, y2);
+			leftIndex = rightIndex + 2;
+			subscript = tags[pp] < 0;//negative positions = subscript
+			xRight += partWidth;
+		}
+		xRight += h / 4;
+		Rectangle cropRect = new Rectangle(0, upperBound, xRight, lowerBound - upperBound);
+		box.setRoi(cropRect);
+		ImageProcessor boxI = box.crop();
+		box = boxI.convertToByteProcessor();
+		return box;
+	}
+
+	/** Returns the number of digits to display the number n with resolution 'resolution';
+	 *  (if n is integer and small enough to display without scientific notation,
+	 *  no decimals are needed, irrespective of 'resolution')
+	 *  Scientific notation is used for more than 'maxDigits' (must be >=3), and indicated
+	 *  by a negative return value, or if suggestedDigits is negative
+	 *  Returns 'suggestedDigits' if not 0 and compatible with the resolution; negative values of
+	 *  'suggestedDigits' switch to scientific notation. */
+	static int getDigits(double n, double resolution, int maxDigits, int suggestedDigits) {
+		if (n==Math.round(n) && Math.abs(n) < Math.pow(10,maxDigits-1)-1) //integers and not too big
+			return suggestedDigits;
+		else
+			return getDigits2(n, resolution, maxDigits, suggestedDigits);
+	}
+
+	/** Number of digits to display the range between n1 and n2 with resolution 'resolution';
+	 *  Scientific notation is used for more than 'maxDigits' (must be >=3), and indicated
+	 *  by a negative return value
+	 *  Returns 'suggestedDigits' if not 0 and compatible with the resolution; negative values of
+	 *  'suggestedDigits' switch to sceintific notation. */
+	static int getDigits(double n1, double n2, double resolution, int maxDigits, int suggestedDigits) {
+		if (n1==0 && n2==0) return suggestedDigits;
+		return getDigits2(Math.max(Math.abs(n1),Math.abs(n2)), resolution, maxDigits, suggestedDigits);
+	}
+
+	static int getDigits2(double n, double resolution, int maxDigits, int suggestedDigits) {
+		if (Double.isNaN(n) || Double.isInfinite(n))
+			return 0; //no scientific notation
+		int log10ofN = (int)Math.floor(Math.log10(Math.abs(n))+1e-7);
+		int digits = resolution != 0 ?
+				-(int)Math.floor(Math.log10(Math.abs(resolution))+1e-7) :
+				Math.max(0, -log10ofN+maxDigits-2);
+		int sciDigits = -Math.max((log10ofN+digits),1);
+		//IJ.log("n="+(float)n+"digitsRaw="+digits+" log10ofN="+log10ofN+" sciDigits="+sciDigits);
+		if ((digits < -2 && log10ofN >= maxDigits) || suggestedDigits < 0)
+			digits = sciDigits; //scientific notation for large numbers or if desired via suggestedDigits (plot.setOptions)
+		else if (digits < 0)
+			digits = 0;
+		else if (digits > maxDigits-1 && log10ofN < -2)
+			digits = sciDigits; // scientific notation for small numbers
+		return digits < 0 ? Math.min(sciDigits, suggestedDigits) : Math.max(digits, suggestedDigits);
+	}
+
+	static boolean isInteger(double n) {
+		return n==Math.round(n);
+	}
+
+	private void drawPlotObject(PlotObject plotObject, ImageProcessor ip) {
+		//IJ.log("DRAWING type="+plotObject.type+" lineWidth="+plotObject.lineWidth+" shape="+plotObject.shape);
+		if (plotObject.hasFlag(PlotObject.HIDDEN)) return;
+		ip.setColor(plotObject.color);
+		ip.setLineWidth(sc(plotObject.lineWidth));
+		int type = plotObject.type;
+		switch (type) {
+			case PlotObject.XY_DATA:
+				ip.setClipRect(frame);
+				int nPoints = Math.min(plotObject.xValues.length, plotObject.yValues.length);
+
+				if (plotObject.shape==BAR || plotObject.shape==SEPARATED_BAR)
+					drawBarChart(plotObject);       // (separated) bars
+
+				if (plotObject.shape == FILLED) {   // filling below line
+					ip.setColor(plotObject.color2 != null ? plotObject.color2 : plotObject.color);
+					drawFloatPolyLineFilled(ip, plotObject.xValues, plotObject.yValues, nPoints);
+				}
+				ip.setColor(plotObject.color);
+				ip.setLineWidth(sc(plotObject.lineWidth));
+
+				if (plotObject.yEValues != null)    // error bars in front of bars and fill area below the line, but behind lines and marker symbols
+					drawVerticalErrorBars(plotObject.xValues, plotObject.yValues, plotObject.yEValues);
+				if (plotObject.xEValues != null)
+					drawHorizontalErrorBars(plotObject.xValues, plotObject.yValues, plotObject.xEValues);
+
+				if (plotObject.hasFilledMarker()) { // fill markers with secondary color
+					int markSize = plotObject.getMarkerSize();
+					ip.setColor(plotObject.color2);
+					ip.setLineWidth(1);
+					for (int i=0; i<nPoints; i++)
+						if ((!logXAxis || plotObject.xValues[i]>0) && (!logYAxis || plotObject.yValues[i]>0)
+								&& !Double.isNaN(plotObject.xValues[i]) && !Double.isNaN(plotObject.yValues[i]))
+							fillShape(plotObject.shape, scaleX(plotObject.xValues[i]), scaleY(plotObject.yValues[i]), markSize);
+					ip.setColor(plotObject.color);
+					ip.setLineWidth(sc(plotObject.lineWidth));
+				}
+				if (plotObject.hasCurve()) {        // draw the lines between the points
+					if (plotObject.shape == CONNECTED_CIRCLES)
+						ip.setColor(plotObject.color2 == null ? Color.black : plotObject.color2);
+					drawFloatPolyline(ip, plotObject.xValues, plotObject.yValues, nPoints);
+					ip.setColor(plotObject.color);
+				}
+				if (plotObject.hasMarker()) {       // draw the marker symbols
+					int markSize = plotObject.getMarkerSize();
+					ip.setColor(plotObject.color);
+					Font saveFont = ip.getFont();
+					for (int i=0; i<Math.min(plotObject.xValues.length, plotObject.yValues.length); i++) {
+						if ((!logXAxis || plotObject.xValues[i]>0) && (!logYAxis || plotObject.yValues[i]>0)
+						&& !Double.isNaN(plotObject.xValues[i]) && !Double.isNaN(plotObject.yValues[i]))
+							drawShape(plotObject, scaleX(plotObject.xValues[i]), scaleY(plotObject.yValues[i]), markSize, i);
+					}
+					if (plotObject.shape==CUSTOM)
+						ip.setFont(saveFont);
+				}
+				ip.setClipRect(null);
+				break;
+			case PlotObject.ARROWS:
+				ip.setClipRect(frame);
+				for (int i=0; i<plotObject.xValues.length; i++) {
+					int xt1 = scaleX(plotObject.xValues[i]);
+					int yt1 = scaleY(plotObject.yValues[i]);
+					int xt2 = scaleX(plotObject.xEValues[i]);
+					int yt2 = scaleY(plotObject.yEValues[i]);
+					double dist = calculateDistance(xt1, yt1, xt2, yt2);
+					if (xt1==xt2 && yt1==yt2)
+						ip.drawDot(xt1, yt1);
+					else if (dist < sc(1.5f*MIN_ARROWHEAD_LENGTH))
+						ip.drawLine(xt1, yt1, xt2, yt2);
+					else {
+						int arrowHeadLength = (int)(dist*RELATIVE_ARROWHEAD_SIZE+0.5);
+						if (arrowHeadLength > sc(MAX_ARROWHEAD_LENGTH)) arrowHeadLength = sc(MAX_ARROWHEAD_LENGTH);
+						if (arrowHeadLength < sc(MIN_ARROWHEAD_LENGTH)) arrowHeadLength = sc(MIN_ARROWHEAD_LENGTH);
+						drawArrow(xt1, yt1, xt2, yt2, arrowHeadLength);
+					}
+				}
+				ip.setClipRect(null);
+				break;
+
+			case PlotObject.SHAPES:
+				int iBoxWidth = 20;
+				ip.setClipRect(frame);
+				String shType = plotObject.shapeType.toLowerCase();
+				if (shType.contains("rectangles")) {
+					int nShapes = plotObject.shapeData.size();
+
+					for (int i = 0; i < nShapes; i++) {
+						float[] corners = (float[])(plotObject.shapeData.get(i));
+						int x1 = scaleX(corners[0]);
+						int y1 = scaleY(corners[1]);
+						int x2 = scaleX(corners[2]);
+						int y2 = scaleY(corners[3]);
+
+					ip.setLineWidth(sc(plotObject.lineWidth));
+						int left = Math.min(x1, x2);
+						int right = Math.max(x1, x2);
+						int top = Math.min(y1, y2);
+						int bottom = Math.max(y1, y2);
+
+						Rectangle r1 = new Rectangle(left, top, right-left, bottom - top);
+						Rectangle cBox = frame.intersection(r1);
+						if (plotObject.color2 != null) {
+							ip.setColor(plotObject.color2);
+							ip.fillRect(cBox.x, cBox.y, cBox.width, cBox.height);
+						}
+						ip.setColor(plotObject.color);
+						ip.drawRect(cBox.x, cBox.y, cBox.width, cBox.height);
+					}
+					ip.setClipRect(null);
+					break;
+				}
+				if (shType.equals("redraw_grid")) {
+				ip.setLineWidth(sc(1));
+					redrawGrid();
+					ip.setClipRect(null);
+					break;
+				}
+				if (shType.contains("boxes")) {
+
+					String[] parts = Tools.split(shType);
+					for (int jj = 0; jj < parts.length; jj++) {
+						String[] pairs = parts[jj].split("=");
+						if ((pairs.length == 2) && pairs[0].equals("width")) {
+							iBoxWidth = Integer.parseInt(pairs[1]);
+						}
+					}
+					boolean horizontal = shType.contains("boxesx");
+					int nShapes = plotObject.shapeData.size();
+					int halfWidth = Math.round(sc(iBoxWidth / 2));
+					for (int i = 0; i < nShapes; i++) {
+
+						float[] coords = (float[])(plotObject.shapeData.get(i));
+
+						if (!horizontal) {
+
+							int x = scaleX(coords[0]);
+							int y1 = scaleY(coords[1]);
+							int y2 = scaleY(coords[2]);
+							int y3 = scaleY(coords[3]);
+							int y4 = scaleY(coords[4]);
+							int y5 = scaleY(coords[5]);
+							ip.setLineWidth(sc(plotObject.lineWidth));
+
+							Rectangle r1 = new Rectangle(x - halfWidth, y4, halfWidth * 2, y2 - y4);
+							Rectangle cBox = frame.intersection(r1);
+							if (y1 != y2 || y4 != y5)//otherwise omit whiskers
+							{
+								ip.drawLine(x, y1, x, y5);//whiskers
+							}
+							if (plotObject.color2 != null) {
+								ip.setColor(plotObject.color2);
+								ip.fillRect(cBox.x, cBox.y, cBox.width, cBox.height);
+							}
+							ip.setColor(plotObject.color);
+							ip.drawRect(cBox.x, cBox.y, cBox.width, cBox.height);
+							ip.setClipRect(frame);
+							ip.drawLine(x - halfWidth, y3, x + halfWidth - 1, y3);
+						}
+
+					if (horizontal) {
+
+							int y = scaleY(coords[0]);
+							int x1 = scaleX(coords[1]);
+							int x2 = scaleX(coords[2]);
+							int x3 = scaleX(coords[3]);
+							int x4 = scaleX(coords[4]);
+							int x5 = scaleX(coords[5]);
+							ip.setLineWidth(sc(plotObject.lineWidth));
+							if(x1 !=x2 || x4 != x5)//otherwise omit whiskers
+								ip.drawLine(x1, y, x5, y);//whiskers
+							Rectangle r1 = new Rectangle(x2, y - halfWidth, x4 - x2, halfWidth * 2);
+							Rectangle cBox = frame.intersection(r1);
+							if (plotObject.color2 != null) {
+								ip.setColor(plotObject.color2);
+								ip.fillRect(cBox.x, cBox.y, cBox.width, cBox.height);
+							}
+							ip.setColor(plotObject.color);
+							ip.drawRect(cBox.x, cBox.y, cBox.width, cBox.height);
+							ip.setClipRect(frame);
+							ip.drawLine(x3, y - halfWidth, x3, y + halfWidth - 1);
+						}
+					}
+					ip.setClipRect(null);
+					break;
+				}
+			case PlotObject.LINE:
+				ip.setClipRect(frame);
+				ip.drawLine(scaleX(plotObject.x), scaleY(plotObject.y), scaleX(plotObject.xEnd), scaleY(plotObject.yEnd));
+				ip.setClipRect(null);
+				break;
+			case PlotObject.NORMALIZED_LINE:
+				ip.setClipRect(frame);
+				int ix1 = leftMargin + (int)(plotObject.x*frameWidth);
+				int iy1 = topMargin	 + (int)(plotObject.y*frameHeight);
+				int ix2 = leftMargin + (int)(plotObject.xEnd*frameWidth);
+				int iy2 = topMargin	 + (int)(plotObject.yEnd*frameHeight);
+				ip.drawLine(ix1, iy1, ix2, iy2);
+				ip.setClipRect(null);
+				break;
+			case PlotObject.DOTTED_LINE:
+				ip.setClipRect(frame);
+				ix1 = scaleX(plotObject.x);
+				iy1 = scaleY(plotObject.y);
+				ix2 = scaleX(plotObject.xEnd);
+				iy2 = scaleY(plotObject.yEnd);
+				double length = calculateDistance(ix1, ix2, iy1, iy2) + 0.1;
+				int n = (int)(length/plotObject.step);
+				for (int i = 0; i<=n; i++)
+					ip.drawDot(ix1 + (int)Math.round((ix2-ix1)*(double)i/n), iy1 + (int)Math.round((iy2-iy1)*(double)i/n));
+				ip.setClipRect(null);
+				break;
+			case PlotObject.LABEL:
+			case PlotObject.NORMALIZED_LABEL:
+				ip.setJustification(plotObject.justification);
+				if (plotObject.getFont() != null)
+					ip.setFont(scFont(plotObject.getFont()));
+				int xt = type==PlotObject.LABEL ? scaleX(plotObject.x) : leftMargin + (int)(plotObject.x*frameWidth);
+				int yt = type==PlotObject.LABEL ? scaleY(plotObject.y) : topMargin + (int)(plotObject.y*frameHeight);
+				ip.drawString(plotObject.label, xt, yt);
+				break;
+			case PlotObject.LEGEND:
+				drawLegend(plotObject, ip);
+				break;
+		}
+	}
+
+	/** Draw a bar at each point */
+	void drawBarChart(PlotObject plotObject) {
+		int n = Math.min(plotObject.xValues.length, plotObject.yValues.length);
+		String[] xCats = labelsInBraces('x'); // do we have categories at the x axis instead of numbers?
+		boolean separatedBars = plotObject.shape == SEPARATED_BAR || xCats != null;
+		int halfBarWidthInPixels = n <= 1 ? Math.max(1, frameWidth/2-2) : 0;
+		if (separatedBars && n > 1)
+			halfBarWidthInPixels = Math.max(1, (int)Math.round(Math.abs
+				(0.5*(plotObject.xValues[n-1] - plotObject.xValues[0])/(n-1) * xScale * SEPARATED_BAR_WIDTH)));
+		int y0 = scaleYWithOverflow(0);
+		boolean yZeroInFrame = !logYAxis && yBasePxl>frame.y && yBasePxl<frame.y+frame.height;
+		int prevY = y0;
+		for (int i = 0; i < n; i++) {
+			int left=0, right=0;
+			if (halfBarWidthInPixels == 0) {         //bar boundaries in the middle between successive x values
+				left = scaleX(i > 0 ? 0.5f*(plotObject.xValues[i-1]+plotObject.xValues[i]) :
+						1.5f*plotObject.xValues[i] - 0.5f*plotObject.xValues[i+1]);
+				right = scaleX(i < n-1 ? 0.5f*(plotObject.xValues[i]+plotObject.xValues[i+1]) :
+						1.5f*plotObject.xValues[i] - 0.5f*plotObject.xValues[i-1]);
+			} else {
+				int x = scaleX(plotObject.xValues[i]);
+				left = x - halfBarWidthInPixels;     //separated bars or n<=1 : fixed bar width
+				right = x + halfBarWidthInPixels;
+			}
+			if (left < frame.x) left = frame.x;
+			if (left > frame.x+frame.width) left = frame.x+frame.width;
+			if (right < frame.x) right = frame.x;
+			if (right > frame.x+frame.width) right = frame.x+frame.width;
+			int y = scaleYWithOverflow(plotObject.yValues[i]);
+			if (plotObject.color2 != null) {
+				ip.setColor(plotObject.color2);
+				for (int x2 = Math.min(left,right); x2 <= Math.max(left,right); x2++)
+					ip.drawLine(x2, y0, x2, y);      //cant use ip.fillRect (ignores the clipRect), so we it fill line by line
+			}
+			ip.setColor(plotObject.color);
+			ip.setLineWidth(sc(plotObject.lineWidth));
+			if (separatedBars) {
+				ip.drawLine(left, y0, left, y);      //up
+				ip.drawLine(left, y, right, y);      //right
+				ip.drawLine(right, y, right, y0);    //down
+				if (yZeroInFrame)
+					ip.drawLine(left, y0, right, y0);//baseline
+			} else {
+				ip.drawLine(left, prevY, left, y);   //up or down
+				ip.drawLine(left, y, right, y);      //right
+				if (i == n - 1)
+					ip.drawLine(right, y, right, y0);//last down
+				prevY = y;
+			}
+		}
+	}
+
+	/** Draw the symbol for the data point number 'pointIndex' (pointIndex < 0 when drawing the legend) */
+	void drawShape(PlotObject plotObject, int x, int y, int size, int pointIndex) {
+		int shape = plotObject.shape;
+		if (shape == DIAMOND) size = (int)(size*1.21);
+		int xbase = x-sc(size/2);
+		int ybase = y-sc(size/2);
+		int xend = x+sc(size/2);
+		int yend = y+sc(size/2);
+		if (ip==null)
+			return;
+		switch(shape) {
+			case X:
+				ip.drawLine(xbase,ybase,xend,yend);
+				ip.drawLine(xend,ybase,xbase,yend);
+				break;
+			case BOX:
+				ip.drawLine(xbase,ybase,xend,ybase);
+				ip.drawLine(xend,ybase,xend,yend);
+				ip.drawLine(xend,yend,xbase,yend);
+				ip.drawLine(xbase,yend,xbase,ybase);
+				break;
+			case TRIANGLE:
+				ip.drawLine(x,ybase-sc(1),xend+sc(1),yend); //height must be odd, otherwise rounding leads to asymmetric shape
+				ip.drawLine(x,ybase-sc(1),xbase-sc(1),yend);
+				ip.drawLine(xend+sc(1),yend,xbase-sc(1),yend);
+				break;
+			case CROSS:
+				ip.drawLine(xbase,y,xend,y);
+				ip.drawLine(x,ybase,x,yend);
+				break;
+			case DIAMOND:
+				ip.drawLine(xbase,y,x,ybase);
+				ip.drawLine(x,ybase,xend,y);
+				ip.drawLine(xend,y,x,yend);
+				ip.drawLine(x,yend,xbase,y);
+				break;
+			case DOT:
+				ip.drawDot(x, y); //uses current line width
+				break;
+			case CUSTOM:
+				if (plotObject.macroCode==null || frame==null)
+					break;
+				if (x<frame.x || y<frame.y || x>=frame.x+frame.width || y>=frame.y+frame.height)
+					break;
+				ImagePlus imp = new ImagePlus("", ip);
+				WindowManager.setTempCurrentImage(imp);
+				StringBuilder sb = new StringBuilder(140+plotObject.macroCode.length());
+				sb.append("x="); sb.append(x);
+				sb.append(";y="); sb.append(y);
+				sb.append(";setColor('");
+				sb.append(Tools.c2hex(plotObject.color));
+				sb.append("');s="); sb.append(sc(1));
+				boolean drawingLegend = pointIndex < 0;
+				double xVal = 0;
+				double yVal = 0;
+				if (!drawingLegend) {
+					xVal = plotObject.xValues[pointIndex];
+					yVal = plotObject.yValues[pointIndex];
+				}
+				sb.append(";i="); sb.append(drawingLegend ? 0 : pointIndex);
+				sb.append(";xval=" + xVal);
+				sb.append(";yval=" + yVal);
+				sb.append(";");
+				sb.append(plotObject.macroCode);
+				if (!drawingLegend ||!sb.toString().contains("d2s") ) {// a graphical symbol won't contain "d2s" ..
+					String rtn = IJ.runMacro(sb.toString());//.. so it can go to the legend
+					if ("[aborted]".equals(rtn))
+					plotObject.macroCode = null;
+				}
+				WindowManager.setTempCurrentImage(null);
+				break;
+			default: // CIRCLE, CONNECTED_CIRCLES: 5x5 oval approximated by 5x5 square without corners
+				if (sc(size) < 5.01) {
+					ip.drawLine(x-1, y-2, x+1, y-2);
+					ip.drawLine(x-1, y+2, x+1, y+2);
+					ip.drawLine(x+2, y+1, x+2, y-1);
+					ip.drawLine(x-2, y+1, x-2, y-1);
+				} else {
+					int r = sc(0.5f*size-0.5f);
+					ip.drawOval(x-r, y-r, 2*r, 2*r);
+				}
+				break;
+		}
+	}
+
+	/** Fill the area of the symbols for data points (except for shape=DOT)
+	 *	Note that ip.fill, ip.fillOval etc. can't be used here: they do not care about the clip rectangle */
+	void fillShape(int shape, int x0, int y0, int size) {
+		if (shape == DIAMOND) size = (int)(size*1.21);
+		int r = sc(size/2)-1;
+		switch(shape) {
+			case BOX:
+				for (int dy=-r; dy<=r; dy++)
+					for (int dx=-r; dx<=r; dx++)
+						ip.drawDot(x0+dx, y0+dy);
+				break;
+			case TRIANGLE:
+				int ybase = y0 - r - sc(1);
+				int yend = y0 + r;
+				double halfWidth = sc(size/2)+sc(1)-1;
+				double hwStep = halfWidth/(yend-ybase+1);
+				for (int y=yend; y>=ybase; y--, halfWidth -= hwStep) {
+					int dx = (int)(Math.round(halfWidth));
+					for (int x=x0-dx; x<=x0+dx; x++)
+						ip.drawDot(x,y);
+				}
+				break;
+			case DIAMOND:
+				ybase = y0 - r - sc(1);
+				yend = y0 + r;
+				halfWidth = sc(size/2)+sc(1)-1;
+				hwStep = halfWidth/(yend-ybase+1);
+				for (int y=yend; y>=ybase; y--) {
+					int dx = (int)(Math.round(halfWidth-(hwStep+1)*Math.abs(y-y0)));
+					for (int x=x0-dx; x<=x0+dx; x++)
+						ip.drawDot(x,y);
+				}
+				break;
+			case CIRCLE: case CONNECTED_CIRCLES:
+				int rsquare = (r+1)*(r+1);
+				for (int dy=-r; dy<=r; dy++)
+					for (int dx=-r; dx<=r; dx++)
+						if (dx*dx + dy*dy <= rsquare)
+							ip.drawDot(x0+dx, y0+dy);
+				break;
+		}
+	}
+
+	/** Adds an arrow from position 1 to 2 given in pixels; 'size' is the length of the arrowhead
+	 *	@deprecated Use as a public method is not supported any more because it is incompatible with rescaling */
+	@Deprecated
+	public void drawArrow(int x1, int y1, int x2, int y2, double size) {
+		double dx = x2 - x1;
+		double dy = y2 - y1;
+		double ra = Math.sqrt(dx * dx + dy * dy);
+		dx /= ra;
+		dy /= ra;
+		int x3 = (int) Math.round(x2 - dx * size);	//arrow base
+		int y3 = (int) Math.round(y2 - dy * size);
+		double r = 0.3 * size;
+		int x4 = (int) Math.round(x3 + dy * r);
+		int y4 = (int) Math.round(y3 - dx * r);
+		int x5 = (int) Math.round(x3 - dy * r);
+		int y5 = (int) Math.round(y3 + dx * r);
+		ip.moveTo(x1, y1); ip.lineTo(x2, y2);
+		ip.moveTo(x4, y4); ip.lineTo(x2, y2); ip.lineTo(x5, y5);
+	}
+
+	private void drawVerticalErrorBars(float[] x, float[] y, float[] e) {
+		int nPoints = Math.min(Math.min(x.length, y.length), e.length);
+		for (int i=0; i<nPoints; i++) {
+			if (Float.isNaN(x[i]) || Float.isNaN(y[i]) || (logXAxis && !(x[i] >0))) continue;
+			int x0 = scaleX(x[i]);
+			int yPlus = scaleYWithOverflow(y[i] + e[i]);
+			int yMinus = scaleYWithOverflow(y[i] - e[i]);
+			ip.moveTo(x0,yMinus);
+			ip.lineTo(x0, yPlus);
+		}
+	}
+
+	private void drawHorizontalErrorBars(float[] x, float[] y, float[] e) {
+		int nPoints = Math.min(Math.min(x.length, y.length), e.length);
+		float[] xpoints = new float[2];
+		float[] ypoints = new float[2];
+		for (int i=0; i<nPoints; i++) {
+			if (Float.isNaN(x[i]) || Float.isNaN(y[i]) || (logXAxis && !(y[i] >0))) continue;
+			int y0 = scaleY(y[i]);
+			int xPlus = scaleXWithOverflow(x[i] + e[i]);
+			int xMinus = scaleXWithOverflow(x[i] - e[i]);
+			ip.moveTo(xMinus,y0);
+			ip.lineTo(xPlus, y0);
+		}
+	}
+
+	/** Draw a polygon line; NaN values interrupt it. */
+	void drawFloatPolyline(ImageProcessor ip, float[] x, float[] y, int n) {
+		if (x==null || x.length==0) return;
+		int x1, y1;
+		boolean isNaN1;
+		int x2 = scaleX(x[0]);
+		int y2 = scaleY(y[0]);
+		boolean isNaN2 = Float.isNaN(x[0]) || Float.isNaN(y[0]) || (logXAxis && x[0]<=0) || (logYAxis && y[0]<=0);;
+		for (int i=1; i<n; i++) {
+			x1 = x2;
+			y1 = y2;
+			isNaN1 = isNaN2;
+			x2 = scaleX(x[i]);
+			y2 = scaleY(y[i]);
+			isNaN2 = Float.isNaN(x[i]) || Float.isNaN(y[i]) || (logXAxis && x[i]<=0) || (logYAxis && y[i]<=0);
+			if (!isNaN1 && !isNaN2)
+				ip.drawLine(x1, y1, x2, y2);
+		}
+	}
+
+	/**
+	 * Fills space between polyline and y=0 with the current color (the secondary color of the plotObject)
+	 */
+	void drawFloatPolyLineFilled(ImageProcessor ip, float[] xF, float[] yF, int len) {
+		if (xF == null || len <=1)
+			return;
+		ip.setLineWidth(1);
+		int y0 = scaleYWithOverflow(0);
+		int x1, y1;
+		int x2 = scaleX(xF[0]);
+		int y2 = scaleY(yF[0]);
+		boolean isNaN1;
+		boolean isNaN2 = Float.isNaN(xF[0]) || Float.isNaN(yF[0]) || (logXAxis && xF[0]<=0) || (logYAxis && yF[0]<=0);
+		for (int i = 1; i < len; i++) {
+			isNaN1 = isNaN2;
+			isNaN2 = Float.isNaN(xF[i]) || Float.isNaN(yF[i]) || (logXAxis && xF[i]<=0) || (logYAxis && yF[i]<=0);
+			x1 = x2;
+			y1 = y2;
+			x2 = scaleX(xF[i]);
+			y2 = scaleY(yF[i]);
+			int left = x1;
+			int right = x2;
+			if (isNaN1 || isNaN2) continue;
+			if (left < frame.x && right < frame.x) continue; // ignore if all outside the plot area
+			if (left >= frame.x+frame.width && right >= frame.x+frame.width) continue;
+			if (left < frame.x) left = frame.x;
+			if (left >= frame.x+frame.width) left = frame.x+frame.width-1;
+			if (right < frame.x) right = frame.x;
+			if (right >= frame.x+frame.width) right = frame.x+frame.width-1;
+			if (left != right) {
+				for (int xi = Math.min(left,right); xi <= Math.max(left,right); xi++) {
+					int yi = (int)Math.round(y1 + (double)(y2 - y1)*(double)(xi - x1)/(double)(x2 - x1));
+					/* double yMin = Math.min(yF[i-1], yF[i]);
+					double yMax = Math.max(yF[i-1], yF[i]);
+					if (y < yMin) y = yMin; // dont extrapolate (in case rounding to pixels falls outside [xi, xi+1] interval)
+					if (y > yMax) y = yMax;*/
+					ip.drawLine(xi, y0, xi, yi);
+				}
+			} else {
+				ip.drawLine(left, y0, left, y2);
+			}
+		}
+	}
+	
+	/** Returns only indexed and sorted plot objects, if at least one label is indexed like "1__MyLabel" */
+	Vector<PlotObject> getIndexedPlotObjects(){
+		boolean withIndex = false;
+		int len = allPlotObjects.size();
+		String[] labels = new String[len];
+		Vector<PlotObject> indexedObjects = new Vector<PlotObject>();
+		for(int jj = 0; jj < len; jj++){
+			PlotObject plotObject = allPlotObjects.get(jj);
+			labels[jj] = "";
+			if (plotObject.type == PlotObject.XY_DATA && !plotObject.hasFlag(PlotObject.HIDDEN) && plotObject.label != null) {
+				String label = plotObject.label;
+				if(label.indexOf("__") >=0  && label.indexOf("__") <= 2){
+					labels[jj]= plotObject.label;
+					withIndex = true;
+				}
+			}
+		}
+		int[] ranks = Tools.rank(labels);
+		for(int jj = 0; jj < len; jj++){
+			if(labels[ranks[jj]] != ""){
+				int index = ranks[jj];
+				indexedObjects.add(allPlotObjects.get(index));
+			}
+		}
+		if(!withIndex)
+			return null;	
+		return indexedObjects;
+	}	
+
+	/** Draw the legend */
+	void drawLegend(PlotObject legendObject, ImageProcessor ip) {
+		ip.setFont(scFont(legendObject.getFont()));
+		int nLabels = 0;
+		int maxStringWidth = 0;
+		float maxLineThickness = 0;
+		Vector<PlotObject> usedPlotObjects = allPlotObjects;
+		Vector<PlotObject> indexedObjects = getIndexedPlotObjects();
+		if(indexedObjects != null)
+			usedPlotObjects= indexedObjects;
+		
+		for (PlotObject plotObject : usedPlotObjects)
+			if (plotObject.type == PlotObject.XY_DATA && !plotObject.hasFlag(PlotObject.HIDDEN) && plotObject.label != null) {		//label exists: was set now or previously
+				nLabels++;
+				String label = plotObject.label;
+				if (indexedObjects != null)
+					label = label.substring(label.indexOf("__") + 2);
+				int w = ip.getStringWidth(label);
+				if (w > maxStringWidth) maxStringWidth = w;
+				if (plotObject.lineWidth > maxLineThickness) maxLineThickness = plotObject.lineWidth;
+			}
+		if (nLabels == 0) return;
+		if (pp.antialiasedText && scale > 1)		//fix incorrect width of large fonts
+			maxStringWidth = (int)((1 + 0.004*scale) * maxStringWidth);
+		int frameThickness = sc(legendObject.lineWidth > 0 ? legendObject.lineWidth : 1);
+		FontMetrics fm = ip.getFontMetrics();
+		ip.setJustification(LEFT);
+		int lineHeight = fm.getHeight();
+		int height = nLabels*lineHeight + 2*sc(LEGEND_PADDING);
+		int width = maxStringWidth + sc(3*LEGEND_PADDING + LEGEND_LINELENGTH + maxLineThickness);
+		int positionCode = legendObject.flags & LEGEND_POSITION_MASK;
+		if (positionCode == AUTO_POSITION)
+			positionCode = autoLegendPosition(width, height, frameThickness);
+		Rectangle rect = legendRect(positionCode, width, height, frameThickness);
+		int x0 = rect.x;
+		int y0 = rect.y;
+
+		ip.setColor(Color.white);
+		ip.setLineWidth(1);
+		if (!legendObject.hasFlag(LEGEND_TRANSPARENT)) {
+			ip.setRoi(x0, y0, width, height);
+			ip.fill();
+		} else if (hasFlag(X_GRID | Y_GRID)) {	//erase grid
+			int grid = ip instanceof ColorProcessor ? (gridColor.getRGB() & 0xffffff) : ip.getBestIndex(gridColor);
+			for (int y=y0; y<y0+height; y++)
+				for (int x=x0; x<x0+width; x++)
+					if ((ip.getPixel(x, y) & 0xffffff) == grid)
+						ip.drawPixel(x, y);
+		}
+		ip.setLineWidth(frameThickness);
+		ip.setColor(legendObject.color);
+		ip.drawRect(x0-frameThickness/2, y0-frameThickness/2, width+frameThickness, height);
+		boolean bottomUp = legendObject.hasFlag(LEGEND_BOTTOM_UP);
+		int y = y0 + frameThickness/2 + sc(LEGEND_PADDING) + lineHeight/2;
+		if (bottomUp) y += (nLabels-1) * lineHeight;
+		int xText = x0 + frameThickness/2 + sc(2f*LEGEND_PADDING + LEGEND_LINELENGTH + maxLineThickness);
+		int xMarker = x0 + frameThickness/2 + sc(LEGEND_PADDING + 0.5f*(LEGEND_LINELENGTH + maxLineThickness));
+		for (PlotObject plotObject : usedPlotObjects)
+			if (plotObject.type == PlotObject.XY_DATA && !plotObject.hasFlag(PlotObject.HIDDEN) && plotObject.label != null) {		//label exists: was set now or previously
+				if (plotObject.hasFilledMarker()) {
+					ip.setColor(plotObject.color2);
+					fillShape(plotObject.shape, xMarker, y, plotObject.getMarkerSize());
+				}
+				int lineWidth = sc(plotObject.lineWidth);
+				ip.setLineWidth(lineWidth);
+				if (plotObject.hasMarker()) {
+					Font saveFont = ip.getFont();
+					ip.setColor(plotObject.color);
+					drawShape(plotObject, xMarker, y, plotObject.getMarkerSize(), -1);
+					if (plotObject.shape==CUSTOM) ip.setFont(saveFont);
+				}
+				if (plotObject.hasCurve() || plotObject.shape==BAR) {
+					Color c = plotObject.shape == CONNECTED_CIRCLES ?
+							(plotObject.color2 == null ? Color.black : plotObject.color2) :
+							plotObject.color;
+					ip.setColor(c);
+					ip.drawLine(x0+frameThickness/2+sc(LEGEND_PADDING)+lineWidth, y, xText-sc(LEGEND_PADDING)-lineWidth, y);
+				}
+				ip.setColor(plotObject.color);
+				ip.setLineWidth(frameThickness);
+				String label = plotObject.label;
+				if (indexedObjects != null){
+					int start = label.indexOf("__");
+					if(start >=0)
+						label = label.substring(start+2);
+				}
+				ip.drawString(label, xText, y+ lineHeight/2);
+				y += bottomUp ? -lineHeight : lineHeight;
+			}
+	}
+
+	/** The legend area; positionCode should be TOP_LEFT, TOP_RIGHT, etc. */
+	Rectangle legendRect(int positionCode, int width, int height, int frameThickness)  {
+		boolean leftPosition = positionCode == TOP_LEFT || positionCode == BOTTOM_LEFT;
+		boolean topPosition	 = positionCode == TOP_LEFT || positionCode == TOP_RIGHT;
+		int x0 = (leftPosition) ?
+				leftMargin + sc(2*LEGEND_PADDING) + frameThickness/2 :
+				leftMargin + frameWidth - width - sc(2*LEGEND_PADDING) - frameThickness/2;
+		int y0 = (topPosition) ?
+				topMargin + sc(LEGEND_PADDING) + frameThickness/2 :
+				topMargin + frameHeight - height - sc(LEGEND_PADDING) + frameThickness/2;
+		if (hasFlag(Y_TICKS))
+			x0 += (leftPosition ? 1 : -1) * sc(tickLength - LEGEND_PADDING);
+		if (hasFlag(X_TICKS))
+			y0 += (topPosition ? 1 : -1) * sc(tickLength - LEGEND_PADDING/2);
+		return new Rectangle(x0, y0, width, height);
+	}
+
+	/** The position code of the legend position where the smallest amount of foreground pixels is covered */
+	int autoLegendPosition(int width, int height, int frameThickness) {
+		int background = ip instanceof ColorProcessor ? (0xffffff) : (ip.isInvertedLut() ? 0 : 0xff);
+		int grid = ip instanceof ColorProcessor ? (gridColor.getRGB() & 0xffffff) : ip.getBestIndex(gridColor);
+		int bestPosition = 0;
+		int minCoveredPixels = Integer.MAX_VALUE;
+		for (int positionCode : new int[]{TOP_LEFT, TOP_RIGHT, BOTTOM_RIGHT, BOTTOM_LEFT}) {
+			Rectangle rect = legendRect(positionCode, width, height, frameThickness);
+			int coveredPixels = 0;
+			for (int y = rect.y - frameThickness/2; y <= rect.y + rect.height + frameThickness/2; y++)
+				for (int x = rect.x - frameThickness/2; x <= rect.x + rect.width + frameThickness/2; x++) {
+					int pixel = ip.getPixel(x, y) & 0xffffff;
+					if (pixel != background && pixel != grid)
+						coveredPixels ++;
+				}
+			if (coveredPixels < minCoveredPixels) {
+				minCoveredPixels = coveredPixels;
+				bestPosition = positionCode;
+			}
+		}
+		return bestPosition;
+	}
+
+	/** Returns the x, y coordinates at the cursor position or the nearest point as a String */
+	String getCoordinates(int x, int y) {
+		if (frame==null) return "";
+		String text = "";
+		if (!frame.contains(x, y))
+			return text;
+		double xv = descaleX(x); // cursor location
+		double yv = descaleY(y);
+		boolean yIsValue = false;
+		if (!hasMultiplePlots()) {
+			PlotObject p = getMainCurveObject(); // display x and f(x) instead of cursor y
+			if (p != null) {
+				double bestDx = Double.MAX_VALUE;
+				double xBest = 0, yBest = 0;
+				for (int i=0; i<Math.min(p.xValues.length, p.yValues.length); i++) {
+					double xp = p.xValues[i];
+					if (Math.abs(xp-xv) < bestDx) {
+						bestDx = Math.abs(xp-xv);
+						xBest = xp;
+						yBest = p.yValues[i];
+					}
+				}
+				if (Math.abs(scaleXtoPxl(xBest)-x) < 50) {	//ignore points more than 50 pixels away in x
+					xv = xBest;
+					yv = yBest;
+					yIsValue = true;
+				}
+			}
+		}
+		if (!Double.isNaN(xv)) {
+			int significantDigits = logXAxis ? -2 : getDigits(xv, 0.001*(xMax-xMin), 6, 0);
+			text =	"X=" + IJ.d2s(xv, significantDigits)+", Y";
+			if (yIsValue) text += "(X)";
+			significantDigits = logYAxis ? -2 : getDigits(yv, 0.001*(yMax-yMin), 6, 0);
+			text +="="+ IJ.d2s(yv, significantDigits);
+		}
+		return text;
+		//}catch(Exception e){IJ.handleException(e);return "ERR";}
+	}
+
+
+	/** Returns a reference to the PlotObject having the data passed with the constructor or (if that was null)
+	 *	the first x & y data added later. Otherwise returns null. */
+	private PlotObject getMainCurveObject() {
+		for (PlotObject plotObject : allPlotObjects) {
+			if (plotObject.type == PlotObject.XY_DATA)
+				return plotObject;
+		}
+		return null;
+	}
+
+	/** Returns a reference to the PlotObject with x & y data (points, curve) added last, or null if none. */
+	private PlotObject getLastCurveObject() {
+		for (int i=allPlotObjects.size()-1; i>=0; i--) {
+			if (allPlotObjects.get(i).type == PlotObject.XY_DATA)
+				return allPlotObjects.get(i);
+		}
+		return null;
+	}
+
+	/** returns whether there are several plots so that one cannot give a single y value for a given x value */
+	private boolean hasMultiplePlots() {
+		int nPlots = 0;
+		for (PlotObject plotObject : allPlotObjects) {
+			if (plotObject.type == PlotObject.ARROWS)
+				return true;
+			else if (plotObject.type == PlotObject.XY_DATA) {
+				nPlots ++;
+				if (nPlots > 1) return true;
+			}
+		}
+		return nPlots > 1;
+	}
+
+	public void setPlotMaker(PlotMaker plotMaker) {
+		this.plotMaker = plotMaker;
+	}
+
+	PlotMaker getPlotMaker() {
+		return plotMaker;
+	}
+
+	/** Returns the labels of the (non-hidden) datasets as linefeed-delimited String.
+	 *	If the label is not set, a blank line is added. */
+	String getDataLabels() {
+		String labels = "";
+		boolean first = true;
+		for (PlotObject plotObject : allPlotObjects)
+			if (plotObject.type == PlotObject.XY_DATA && !plotObject.hasFlag(PlotObject.HIDDEN)) {
+				if (first)
+					first = false;
+				else
+					labels += '\n';
+				if (plotObject.label != null) labels += plotObject.label;
+			}
+		return labels;
+	}
+
+	/** Creates a ResultsTable with the plot data. Returns an empty table if no data. */
+	public ResultsTable getResultsTable() {
+		return getResultsTable(true);
+	}
+
+	/** Creates a ResultsTable with the data of the plot. Returns null if no data.
+	 * Does not write the first x column if writeFirstXColumn is false.
+	 * When all columns are the same length, x columns equal to the first x column are
+	 * not written, independent of writeFirstXColumn.
+	 * Column headings are "X", "Y", "X1", "Y1", etc, irrespective of any labels of the data sets
+	 */
+	public ResultsTable getResultsTable(boolean writeFirstXColumn) {
+		return getResultsTable(writeFirstXColumn, false);
+	}
+
+	/** Creates a ResultsTable with the data of the plot. Returns null if no data.
+	 * When all columns are the same length, x columns equal to the first x column are
+	 * not written, independent of writeFirstXColumn.
+	 * When the data sets have labels, they are used for column headings
+	 */
+	public ResultsTable getResultsTableWithLabels() {
+		return getResultsTable(true, true);
+	}
+
+	/** Creates a ResultsTable with the data of the plot. Returns null if no data.
+	 * Does not write the first x column if writeFirstXColumn is false.
+	 * When all columns are the same length, x columns equal to the first x column are
+	 * not written, independent of writeFirstXColumn.
+	 * When the data sets have labels and useLabels is true, they are used for column headings,
+	 * otherwise columns are named X, Y, X1, Y1, ... */
+	ResultsTable getResultsTable(boolean writeFirstXColumn, boolean useLabels) {
+		ResultsTable rt = new ResultsTable();
+		// find the longest x-value data set and count the data sets
+		int nDataSets =	 0;
+		int tableLength = 0;
+		for (PlotObject plotObject : allPlotObjects)
+			if (plotObject.xValues != null) {
+				nDataSets++;
+				tableLength = Math.max(tableLength, plotObject.xValues.length);
+			}
+		if (nDataSets == 0)
+			return null;
+		// enter columns one by one to lists of data and headings
+		ArrayList<String> headings = new ArrayList<String>(2*nDataSets);
+		ArrayList<float[]> data = new ArrayList<float[]>(2*nDataSets);
+		int dataSetNumber = 0;
+		int arrowsNumber = 0;
+		PlotObject firstXYobject = null;
+		boolean allSameLength = true;
+		for (PlotObject plotObject : allPlotObjects) {
+			if (plotObject.type==PlotObject.XY_DATA) {
+				if (firstXYobject != null && firstXYobject.xValues.length!=plotObject.xValues.length) {
+					allSameLength = false;
+					break;
+				}
+				if (firstXYobject==null)
+					firstXYobject = plotObject;
+			}
+		}
+		firstXYobject = null;
+		for (PlotObject plotObject : allPlotObjects) {
+			if (plotObject.type==PlotObject.XY_DATA) {
+				boolean sameX = firstXYobject!=null && Arrays.equals(firstXYobject.xValues, plotObject.xValues) && allSameLength;
+				boolean sameXY = sameX && Arrays.equals(firstXYobject.yValues, plotObject.yValues); //ignore duplicates (e.g. Markers plus Curve)
+				boolean writeX = firstXYobject==null ? writeFirstXColumn : !sameX;
+				addToLists(headings, data, plotObject, dataSetNumber, writeX, /*writeY=*/!sameXY, /*multipleSets=*/nDataSets>1, useLabels);
+				if (firstXYobject == null)
+					firstXYobject = plotObject;
+				dataSetNumber++;
+			} else if (plotObject.type==PlotObject.ARROWS) {
+				addToLists(headings, data, plotObject, arrowsNumber, /*writeX=*/true, /*writeY=*/true, /*multipleSets=*/nDataSets>1, /*useLabels=*/false);
+				arrowsNumber++;
+			}
+		}
+		// populate the ResultsTable
+		int nColumns = headings.size();
+		for (int line=0; line<tableLength; line++) {
+			for (int col=0; col<nColumns; col++) {
+				String heading = headings.get(col);
+				float[] values = data.get(col);
+				if (line<values.length)
+					rt.setValue(heading, line, values[line]);
+				else
+					rt.setValue(heading, line, "");
+			}
+		}
+		// set the decimals (precision) of the table columns
+		nColumns = rt.getLastColumn() + 1;
+		for (int i=0; i<nColumns; i++)
+			rt.setDecimalPlaces(i, getPrecision(rt.getColumn(i)));
+		return rt;
+	}
+
+	// when writing data in scientific mode, use at least 4 decimals behind the decimal point
+	static final int MIN_SCIENTIFIC_DIGITS = 4;
+	// when writing float data, precision should be at least 1e-5*data range
+	static final double MIN_FLOAT_PRECISION = 1e-5;
+
+	void addToLists(ArrayList<String> headings, ArrayList<float[]>data, PlotObject plotObject,
+			int dataSetNumber, boolean writeX, boolean writeY, boolean multipleSets, boolean useLabels) {
+		String plotObjectLabel = useLabels ? replaceSpacesEtc(plotObject.label) : null;
+		if (writeX) {
+			String label = null;                                                     // column header for x column
+			if (plotObject.type!=PlotObject.ARROWS) {
+				String plotXLabel = getLabel('x');
+				if (dataSetNumber==0 && plotXLabel!=null) {                          // use x axis label for 1st dataset if permitted
+					if (useLabels)
+						label = replaceSpacesEtc(plotXLabel);
+					else if (plotXLabel.startsWith(" ") && plotXLabel.endsWith(" ")) // legacy: always use axis label for 1st data if spaces at start&end
+						label = plotXLabel.substring(1,plotXLabel.length()-1);
+				} else if (plotObjectLabel != null && dataSetNumber>0)
+					label = "X_"+plotObjectLabel;                                    // use "X_" + dataset label
+				if (label != null && headings.contains(label))
+					label = null; // avoid duplicate labels (not possible in ResultsTable)
+			}
+			if (label == null) {                                                     // create default label if no specific label yet
+				label = plotObject.type == PlotObject.ARROWS ? "XStart" : "X";
+				if (multipleSets) label += dataSetNumber;
+			}
+			headings.add(label);
+			data.add(plotObject.xValues);
+		}
+		if (writeY) {
+			String label = null;;                                                     // column header for y column
+			if (plotObject.type!=PlotObject.ARROWS) {
+				String plotYLabel = getLabel('y');
+				if (dataSetNumber==0 && plotYLabel!=null) {
+					if (useLabels && plotObjectLabel == null)                         // use y axis label for 1st dataset if no data set label
+						label = replaceSpacesEtc(plotYLabel);
+					else if (plotYLabel.startsWith(" ") && plotYLabel.endsWith(" "))  // legacy: always use axis label for 1st data if spaces at start&end
+						label = plotYLabel.substring(1,plotYLabel.length()-1);
+				}
+				if (plotObjectLabel != null)
+					label = plotObjectLabel;
+				if (label != null && headings.contains(label))
+					label = null; // avoid duplicate labels (not possible in ResultsTable)
+			}
+			if (label == null) {                                                     // create default label if no specific label yet
+				label = plotObject.type == PlotObject.ARROWS ? "YStart" : "Y";
+				if (multipleSets) label += dataSetNumber;
+			}
+			headings.add(label);
+			data.add(plotObject.yValues);
+		}
+		if (plotObject.xEValues != null) {
+			String label = plotObject.type == PlotObject.ARROWS ? "XEnd" : "XERR";
+			if (multipleSets) label += dataSetNumber;
+			headings.add(label);
+			data.add(plotObject.xEValues);
+		}
+		if (plotObject.yEValues != null) {
+			String label = plotObject.type == PlotObject.ARROWS ? "YEnd" : "ERR";
+			if (multipleSets) label += dataSetNumber;
+			headings.add(label);
+			data.add(plotObject.yEValues);
+		}
+	}
+
+	/** Convert a string to a label suitable for a ResultsTable without whitespace, quotes or commas,
+	 *  to avoid problems when saving and reading the table. Returns null if an empty string or null. */
+	static String replaceSpacesEtc(String s) {
+		if (s == null) return null;
+		s = s.trim().replaceAll("[\\s,]", "_").replace("\"","''");
+		if (s.length() == 0) return null;
+		return s;
+	}
+
+	/** get the number of digits for writing a column to the results table or the clipboard */
+	static int getPrecision(float[] values) {
+		int setDigits = Analyzer.getPrecision();
+		int measurements = Analyzer.getMeasurements();
+		boolean scientificNotation = (measurements&Measurements.SCIENTIFIC_NOTATION)!=0;
+		if (scientificNotation) {
+			if (setDigits<MIN_SCIENTIFIC_DIGITS)
+				setDigits = MIN_SCIENTIFIC_DIGITS;
+			return -setDigits;
+		}
+		boolean allInteger = true;
+		float min = Float.MAX_VALUE, max = -Float.MAX_VALUE;
+		for (int i=0; i<values.length; i++) {
+			if ((int)values[i]!=values[i] && !Float.isNaN(values[i])) {
+				allInteger = false;
+			if (values[i] < min) min = values[i];
+			if (values[i] > max) max = values[i];
+			}
+		}
+		if (allInteger)
+			return 0;
+		int digits = (max - min) > 0 ? getDigits(min, max, MIN_FLOAT_PRECISION*(max-min), 15, 0) :
+				getDigits(max, MIN_FLOAT_PRECISION*Math.abs(max), 15, 0);
+		if (setDigits>Math.abs(digits))
+			digits = setDigits * (digits < 0 ? -1 : 1);		//use scientific notation if needed
+		return digits;
+	}
+
+	/** Whether a given flag 'what' is set */
+	boolean hasFlag(int what) {
+		return (pp.axisFlags&what) != 0;
+	}
+
+	/* Obsolete, replaced by add(shape,x,y). */
+	public void addPoints(String dummy, float[] x, float[] y, int shape) {
+		addPoints(x, y, shape);
+	}
+
+	/** Plots a histogram from an array using auto-binning.
+	 *  @param values	array containing the population
+	 *  N.Vischer
+	 */
+	public void addHistogram(double[] values) {
+		addHistogram(values, 0, 0);
+	}
+
+	/** Plots a histogram from an array using the specified bin width.
+	 *  @param values	array containing the population
+	 *  @param binWidth	set zero for auto-binning
+	 *  N.Vischer
+	 */
+	public void addHistogram(double[] values, double binWidth) {
+		addHistogram(values, binWidth, 0);
+	}
+
+	/** Plots a histogram of the value distribution (bin counts) from an array
+	 *  @param values	array containing the values for the population
+	 *  @param binWidth	set zero for auto-binning
+	 *  @param binCenter any x value can be the center of a bin
+	 *  N.Vischer
+	 */
+	public void addHistogram(double[] values, double binWidth, double binCenter) {
+		int len = values.length;
+		double min = Double.POSITIVE_INFINITY;
+		double max = Double.NEGATIVE_INFINITY;
+		double[] cleanVals = new double[len];
+		int count = 0;
+		double sum = 0, sum2 = 0;
+		for (int i = 0; i < len; i++) {
+			double val = values[i];
+			if (!Double.isNaN(val)) {
+				cleanVals[count++] = val;
+				sum += val;
+				sum2 += val * val;
+				if (val < min)
+					min = val;
+				if (val > max)
+					max = val;
+			}
+		}
+		if (binWidth <= 0) {//autobinning
+			double stdDev = Math.sqrt(((count * sum2 - sum * sum) / count) / count);//not count - 1
+			// use Scott's method (1979 Biometrika, 66:605-610) for optimal binning: 3.49*sd*N^-1/3
+			binWidth = 3.49 * stdDev * (Math.pow(count, -1.0 / 3));
+
+		}
+		double modCenter = binCenter % binWidth;
+		double modMin = min % binWidth;
+		double diff = modMin - modCenter;
+		double firstBin = min-diff;
+		while(firstBin  - binWidth * 0.499 > min)
+			firstBin -= binWidth;
+		int nBins =  (int) ((max - firstBin)/binWidth);
+		double lastBin = firstBin + nBins * binWidth;
+		while(lastBin  + binWidth * 0.499 < max)
+			lastBin += binWidth;
+		nBins = (int) Math.round((lastBin - firstBin)/binWidth) + 1;
+		if (nBins == 1)
+			nBins = 2;
+		if (nBins > 9999) {
+			IJ.error("max bins > 9999");
+			return;
+		}
+		double[] histo = new double[nBins];
+		double[] xValues = new double[nBins];
+		for (int i = 0; i < nBins; i++)
+			xValues[i] = firstBin + i * binWidth;
+		for (int i = 0; i < count; i++) {
+			double val = cleanVals[i];
+			double indexD = (val - firstBin) / binWidth;
+			int index = (int) Math.round(indexD);
+			if (index < 0 || index >= nBins) {
+				IJ.error("index out of range");
+				return;
+			} else
+				histo[index]++;
+		}
+		add("bar", xValues, histo);
+	}
+
+	/* Obsolete, replaced by add("error bars",errorBars). */
+	public void addErrorBars(String dummy, float[] errorBars) {
+		addErrorBars(errorBars);
+	}
+
+	/* Obsolete; replaced by setFont(). */
+	public void changeFont(Font font) {
+		setFont(font);
+	}
+	
+}
+
+/** This class contains the properties of the plot, such as size, format, range, etc, except for the data+format (plot contents).
+ *  To enable reading serialized PlotObjects of plots created with previous versions of ImageJ,
+ *  the variable names MUST NEVER be changed! Also any additions should be made after careful thought,
+ *  since they have to be kept for all future versions. */
+class PlotProperties implements Cloneable, Serializable {
+	/** The serialVersionUID should not be modified, otherwise saved plots won't be readable any more */
+	static final long serialVersionUID = 1L;
+	//
+	PlotObject frame = new PlotObject(Plot.DEFAULT_FRAME_LINE_WIDTH);	 //the frame, including background color and axis numbering
+	PlotObject xLabel = new PlotObject(PlotObject.AXIS_LABEL);		//the x axis label (string & font)
+	PlotObject yLabel = new PlotObject(PlotObject.AXIS_LABEL);		//the x axis label (string & font)
+	PlotObject legend;												//the legend (if any)
+	int width = 0;													//canvas width (note: when stored, this must fit the image)
+	int height = 0;
+	int axisFlags;													//these define axis layout
+	double[] rangeMinMax;											//currentMinMax when writing, sets defaultMinMax when reading
+	boolean antialiasedText = true;
+	boolean isFrozen;							                    //modifications (size, range, contents) don't update the ImageProcessor
+
+	/** Returns an array of all PlotObjects defined as PlotProperties. Note that some may be null */
+	PlotObject[] getAllPlotObjects() {
+		return new PlotObject[]{frame, xLabel, xLabel, legend};
+	}
+
+	/** Returns the PlotObject for xLabel ('x'), yLabel('y'), frame ('f'; includes number font) or the legend ('l'). */
+	PlotObject getPlotObject(char c) {
+		switch(c) {
+			case 'x':  return xLabel;
+			case 'y':  return yLabel;
+			case 'f':  return frame;
+			case 'l':  return legend;
+			default:   return null;
+		}
+	}
+
+	/** A shallow clone that does not duplicate arrays or objects */
+	public PlotProperties clone() {
+		try {
+			return (PlotProperties)(super.clone());
+		} catch (CloneNotSupportedException e) {
+			return null;
+		}
+	}
+
+	/** A deep clone; it also duplicates arrays and pPlotObjects */
+	public PlotProperties deepClone() {
+		PlotProperties pp2 = clone(); //shallow clone
+		if (frame != null)  pp2.frame  = frame.deepClone();
+		if (xLabel != null) pp2.xLabel = xLabel.deepClone();
+		if (yLabel != null) pp2.yLabel = yLabel.deepClone();
+		if (legend != null) pp2.legend = legend.deepClone();
+		if (rangeMinMax != null) pp2.rangeMinMax = rangeMinMax.clone();
+		return pp2;
+	}
+
+} // class PlotProperties
+
+/** This class contains the data and properties for displaying a curve, a set of arrows, a line or a label in a plot,
+ *	as well as the legend, axis labels, and frame (including background and fonts of axis numbering).
+ *	Note that all properties such as lineWidths and Fonts have to be scaled up for high-resolution plots.
+ *	This class allows serialization for writing into tiff files.
+ *  To enable reading serialized PlotObjects of plots created with previous versions of ImageJ,
+ *  the variable names MUST NEVER be changed! Also any additions should be made after careful thought,
+ *  since they have to be kept for all future versions. */
+class PlotObject implements Cloneable, Serializable {
+	/** The serialVersionUID should not be modified, otherwise saved plots won't be readable any more */
+	static final long serialVersionUID = 1L;
+	/** Constants for the type of objects. These are powers of two so one can use them as masks */
+	public final static int XY_DATA = 1, ARROWS = 2, LINE = 4, NORMALIZED_LINE = 8, DOTTED_LINE = 16,
+			LABEL = 32, NORMALIZED_LABEL = 64, LEGEND = 128, AXIS_LABEL = 256, FRAME = 512, SHAPES = 1024;
+	/** mask for recovering font style from the flags */
+	final static int FONT_STYLE_MASK = 0x0f;
+	/** flag for the data set passed with the constructor. Note that 0 to 0x0f are reserved for fonts modifiers, 0x010-0x800 are reserved for legend modifiers */
+	public final static int CONSTRUCTOR_DATA = 0x1000;
+	/** flag for hiding a PlotObject */
+	public final static int HIDDEN = 0x2000;
+	/** Type of the object; XY_DATA stands for curve or markers, can be also ARROWS ... SHAPES */
+	public int type = XY_DATA;
+	/** bitwise combination of flags, or the position of a legend */
+	public int flags;
+	/**  Options, currently only for FRAME, see Plot.setOptions */
+	public String options;
+	/** The x and y data arrays and the error bars (if non-null). These arrays also serve as x0, y0, x1, y1
+	 *	arrays for plotting arrays of arrows */
+	public float[] xValues, yValues, xEValues, yEValues;
+	/** For SHAPES: For boxplots with whiskers ('boxes'), elements of the ArrayList are float[6] with x and all 5 y values
+	 *  (for 'boxesx', y and all 5 x values), for 'rectangles', float[4] with x1, y1, x2, y2. */
+	public ArrayList shapeData;
+	/** For SHAPES only, shape type & options. Currently implemented: 'boxes', 'boxesx' (box plots with whiskers), 'rectangles', 'redraw_grid' */
+	public String shapeType; //e.g. "boxes width=20"
+	/** Type of the points, such as Plot.LINE, Plot.CROSS etc. (for type = XY_DATA) */
+	public int shape;
+	/** The line width in pixels for 'normal' plots (for high-resolution plots, to be multiplied by a scale factor) */
+	public float lineWidth;
+	/** The color of the object, must not be null */
+	public Color color;
+	/** The secondary color (for filling closed symbols and for the line of CIRCLES_AND_LINE, may be null for unfilled/default */
+	public Color color2;
+	/** Labels and lines: Position (NORMALIZED objects: relative units 0...1). */
+	public double x, y;
+	/** Lines only: End position */
+	public double xEnd, yEnd;
+	/** Dotted lines only: step */
+	public int step;
+	/** A label for the y data of the curve, a text to draw, or the text of a legend (tab-delimited lines) */
+	public String label;
+	/** Labels only: Justification can be Plot.LEFT, Plot.CENTER or Plot.RIGHT */
+	public int justification;
+	/** Macro code for drawing symbols */
+	public String macroCode;
+	/** Text objects (labels, legend, axis labels) only: the font; maybe null for default. This is not serialized (transient) */
+	private transient Font font;
+	/** String for representation of the font family (for Serialization); may be null for default. Font style is in flags, font size in fontSize. */
+	private String fontFamily;
+	/** Font size (for Serialization), for 'normal' plots (for high-resolution plots, to be multiplied by a scale factor) */
+	private float fontSize;
+
+
+	/** Generic constructor */
+	PlotObject(int type) {
+		this.type = type;
+	}
+
+	/** Constructor for XY_DATA, i.e., a curve or set of points */
+	PlotObject(float[] xValues, float[] yValues, float[] yErrorBars, int shape, float lineWidth, Color color, Color color2, String yLabel) {
+		this.type = XY_DATA;
+		this.xValues = xValues;
+		this.yValues = yValues;
+		this.yEValues = yErrorBars;
+		this.shape = shape;
+		this.lineWidth = lineWidth;
+		this.color = color;
+		this.color2 = color2;
+		this.label = yLabel;
+		if (shape==Plot.CUSTOM)
+			this.macroCode = yLabel;
+	}
+
+	/** Constructor for a set of arrows */
+	PlotObject(float[] x1, float[] y1, float[] x2, float[] y2, float lineWidth, Color color) {
+		this.type = ARROWS;
+		this.xValues = x1;
+		this.yValues = y1;
+		this.xEValues = x2;
+		this.yEValues = y2;
+		this.lineWidth = lineWidth;
+		this.color = color;
+	}
+
+	/** Constructor for a set of shapes */
+	PlotObject(String shapeType, ArrayList shapeData, float lineWidth,  Color color, Color color2) {
+		this.type = SHAPES;
+		this.shapeData = shapeData;
+		this.shapeType = shapeType;
+		this.lineWidth = lineWidth;
+		this.color = color;
+		this.color2 = color2;
+	}
+
+	/** Constructor for a line */
+	PlotObject(double x, double y, double xEnd, double yEnd, float lineWidth, int step, Color color, int type) {
+		this.type = type;
+		this.x = x;
+		this.y = y;
+		this.xEnd = xEnd;
+		this.yEnd = yEnd;
+		this.lineWidth = lineWidth;
+		this.step = step;
+		this.color = color;
+	}
+
+	/** Constructor for a label or NORMALIZED_LABEL */
+	PlotObject(String label, double x, double y, int justification, Font font, Color color, int type) {
+		this.type = type;
+		this.label = label;
+		this.x = x;
+		this.y = y;
+		this.justification = justification;
+		setFont(font);
+		this.color = color;
+	}
+
+	/** Constructor for the legend. <code>flags</code> is bitwise or of TOP_LEFT etc. and LEGEND_TRANSPARENT if desired.
+	 *  Note that the labels in the legend are those of the data plotObjects */
+	PlotObject(float lineWidth, Font font, Color color, int flags) {
+		this.type = LEGEND;
+		this.lineWidth = lineWidth;
+		setFont(font);
+		this.color = color;
+		this.flags = flags;
+	}
+
+	/** Constructor for the frame, including axis numbers. In the current version, the primary color (line color) is always black */
+	PlotObject(float lineWidth) {
+		this.type = FRAME;
+		this.color = Color.black;
+		this.lineWidth = lineWidth;
+	}
+
+	/** Whether a given flag 'what' is set */
+	boolean hasFlag(int what) {
+		return (flags&what) != 0;
+	}
+
+	/** Sets a given flag  */
+	void setFlag(int what) {
+		flags |= what;
+	}
+
+	/** Unsets a given flag  */
+	void unsetFlag(int what) {
+		flags = flags & (~what);
+	}
+
+	/** Whether an XY_DATA object has a curve to draw */
+	boolean hasCurve() {
+		return type == XY_DATA && (shape == Plot.LINE || shape == Plot.CONNECTED_CIRCLES || shape == Plot.FILLED);
+	}
+
+	/** Whether an XY_DATA object has markers to draw */
+	boolean hasMarker() {
+		return type == XY_DATA && (shape == Plot.CIRCLE || shape == Plot.X || shape == Plot.BOX || shape == Plot.TRIANGLE
+				|| shape == Plot.CROSS || shape == Plot.DIAMOND || shape == Plot.DOT || shape == Plot.CONNECTED_CIRCLES
+				|| shape == Plot.CUSTOM);
+	}
+
+	/** Whether an XY_DATA object has markers that can be filled */
+	boolean hasFilledMarker() {
+		return type == XY_DATA && color2 != null && (shape == Plot.CIRCLE || shape == Plot.BOX || shape == Plot.TRIANGLE ||
+				shape == Plot.DIAMOND || shape == Plot.CONNECTED_CIRCLES);
+	}
+
+	/** Size of the markers for an XY_DATA object with markers */
+	int getMarkerSize () {
+		return lineWidth<=1 ? 5 : 7;
+	}
+
+	/** Sets the font. Also writes font properties for serialization. */
+	void setFont(Font font) {
+		if (font == this.font) return;
+		this.font = font;
+		if (font == null) {
+			fontFamily = null;
+		} else {
+			fontFamily = font.getFamily();
+			flags = (flags & ~FONT_STYLE_MASK) | font.getStyle();
+			fontSize = font.getSize2D();
+		}
+	}
+
+	/** Returns the font, or null if none specified */
+	Font getFont() {
+		if (font == null && fontFamily != null)     //after recovery from serialization, create the font from its description
+			font = FontUtil.getFont(fontFamily, flags&FONT_STYLE_MASK, fontSize);
+		return font;
+	}
+
+	/** Returns all data xValues, yValues, xEValues, yEValues as a float[][] array. Note that future versions may have more data. */
+	float[][] getAllDataValues() {
+		return new float[][] {xValues, yValues, xEValues, yEValues};
+	}
+
+	/** A shallow clone that does not duplicate arrays or objects */
+	public PlotObject clone() {
+		try {
+			return (PlotObject)(super.clone());
+		} catch (CloneNotSupportedException e) {
+			return null;
+		}
+	}
+
+	/** A deep clone, which duplicates arrays etc.
+	 *  Note that colors & font are not cloned; it is assumed that these wil not be modified but replaced,
+	 *  so the clone remains unaffected */
+	public PlotObject deepClone() {
+		PlotObject po2 = clone();
+		if (xValues != null) po2.xValues = xValues.clone();
+		if (yValues != null) po2.yValues = yValues.clone();
+		if (xEValues != null) po2.xEValues = xEValues.clone();
+		if (yEValues != null) po2.yEValues = yEValues.clone();
+		if (shapeData != null) po2.shapeData = cloneArrayList(shapeData);
+		return po2;
+	}
+
+	/** A clone of an array list one level deeper than a shallow clone.
+	 *  The clone() method of the objects in the list must be accessible */
+	private ArrayList cloneArrayList(ArrayList src) {
+		ArrayList dest = (ArrayList)(src.clone());     //shallow clone
+		Class[] noClasses = new Class[0];
+		Object[] noObjects = new Object[0];
+		for (int i=0; i<dest.size(); i++) {
+			Object o = dest.get(i);
+			if (o != null) try {
+				Method cloneMethod = o.getClass().getMethod("clone", noClasses);
+				dest.set(i, cloneMethod.invoke(o, noObjects));
+			} catch (Exception e) {}
+		}
+		return dest;
+	}
+
+	/** Converts old (pre-1.52i) type codes for the PlotObjects to the new ones, which can be used as masks */
+	void updateType() {
+		type = 1<<type;
+	}
+
+	public String toString() {  //for debug messages
+		String s = "PlotObject type="+type+" flags="+flags+" xV:"+(xValues==null ? "-":yValues.length)+" yV:"+(yValues==null ? "-":yValues.length)+" label="+label+" col="+color+" fSize="+fontSize+" ff="+fontFamily;
+		return s;
+	}
+} // class PlotObject
diff --git a/src/ij/gui/PlotCanvas.java b/src/ij/gui/PlotCanvas.java
new file mode 100644
index 0000000..9536f88
--- /dev/null
+++ b/src/ij/gui/PlotCanvas.java
@@ -0,0 +1,253 @@
+package ij.gui;
+
+import java.awt.*;
+import ij.process.*;
+import ij.*;
+import ij.util.*;
+import java.awt.event.*;
+
+
+/** This subclass of ImageCanvas has special provisions for plots:
+ * - Zooming: sets the plot range
+ * - Scrolling: moves data area
+ *  This behavior is suppressed if the plot is frozen
+ * */
+public class PlotCanvas extends ImageCanvas {
+	/** The plot displayed */
+	Plot plot;
+	int xScrolled, yScrolled;	//distance scrolled so far
+	int oldWidth, oldHeight;
+	int rangeArrowIndexWhenPressed = -1;
+
+	/** Creates a new PlotCanvas */
+	public PlotCanvas(ImagePlus imp) {
+		super(imp);
+		oldWidth = imp.getWidth();
+		oldHeight = imp.getHeight();
+	}
+
+	/** Tells the PlotCanvas which plot to use for zooming etc.
+	 *	Call this immediately after construction */
+	public void setPlot(Plot plot) {
+		this.plot = plot;
+	}
+
+	/** Returns the Plot displayed in this canvas */
+	public Plot getPlot() {
+		return plot;
+	}
+
+	/** Whether the plot is frozen, i.e. its ImageProcessor can not be changed */
+	public boolean isFrozen() {
+		return plot != null && plot.isFrozen();
+	}
+
+	/** Zoom operations that are handled by ij.plugin.Zoom */
+	public void zoom(String arg) {
+		int cursorX = -1, cursorY = -1;
+		if (cursorOverImage()) {
+			Point cursorLoc = getCursorLoc();
+			cursorX = screenX(cursorLoc.x);
+			cursorY = screenY(cursorLoc.y);
+		}
+		Rectangle roiRect = null;
+		Roi roi = imp.getRoi();
+		if (roi != null && roi.isArea())
+			roiRect = roi.getBounds();
+		if (arg.equals("in")) {
+			if (roiRect != null) {
+				plot.zoomToRect(roiRect);
+				imp.deleteRoi();
+			} else
+				zoomIn(cursorX, cursorY);
+		} else if (arg.equals("out")) {
+				zoomOut(cursorX, cursorY);
+		} else if (arg.equals("orig")) {
+			unzoom();
+		} else if (arg.equals("100%")) {
+			zoom100Percent();
+		} else if (arg.equals("to") && roiRect != null) {
+			plot.zoomToRect(roiRect);
+			imp.deleteRoi();
+		} else if (arg.equals("set"))
+			new PlotDialog(plot, PlotDialog.SET_RANGE).showDialog(null);
+		else if (arg.equals("max")) {
+			ImageWindow win = imp.getWindow();
+			win.setBounds(win.getMaximumBounds());
+			win.maximize();
+		} else if (arg.equals("scale"))
+			plot.setLimitsToFit(true);
+	}
+
+	/** Zooms in by modifying the plot range; sx and sy are screen coordinates */
+	public void zoomIn(int sx, int sy) {
+		zoom(sx, sy, Math.sqrt(2));
+	}
+
+    /** Zooms out by modifying the plot range; sx and sy are screen coordinates */
+	public void zoomOut(int sx, int sy) {
+		zoom(sx, sy, Math.sqrt(0.5));
+	}
+
+	void zoom(int sx, int sy, double zoomFactor) {//n__ 
+		if (plot == null || plot.isFrozen()) {
+			if (zoomFactor > 1)
+				super.zoomIn(sx, sy);
+			else
+				super.zoomOut(sx, sy);
+			return;
+		}
+		plot.zoom(sx, sy, zoomFactor);
+	}
+
+	/** Implements the Image/Zoom/Original Scale command.
+	 *	Sets the original range of the x, y axes (unless the plot is frozen) */
+	public void unzoom() {
+		if (plot == null || plot.isFrozen()) {
+			super.unzoom();
+			return;
+		}
+		resetMagnification();
+		plot.setLimitsToDefaults(true);
+	}
+
+	/** Implements the Image/Zoom/View 100% command: Sets the original frame size as specified
+	 *	in Edit/Options/Plots (unless the plot is frozen) */
+	public void zoom100Percent() {
+		if (plot == null || plot.isFrozen()) {
+			super.zoom100Percent();
+			return;
+		}
+		resetMagnification();
+		plot.setFrameSize(PlotWindow.plotWidth, PlotWindow.plotHeight);
+	}
+
+	/** Resizes the plot (unless frozen) to fit the window */
+	public void fitToWindow() {
+		if (plot == null || plot.isFrozen()) {
+			super.fitToWindow();
+			return;
+		}
+		ImageWindow win = imp.getWindow();
+		if (win==null) return;
+		Rectangle bounds = win.getBounds();
+		Dimension extraSize = win.getExtraSize();
+		int width = bounds.width-extraSize.width;//(insets.left+insets.right+ImageWindow.HGAP*2);
+		int height = bounds.height-extraSize.height;//(insets.top+insets.bottom+ImageWindow.VGAP*2);
+		//IJ.log("fitToWindow "+bounds+"-> w*h="+width+"*"+height);
+		resizeCanvas(width, height);
+		getParent().doLayout();
+	}
+
+	/** Resizes the canvas when the user resizes the window. To avoid a race condition while creating
+	 *	a new window, this is ignored if no window exists or the window has not been activated yet.
+     */
+	void resizeCanvas(int width, int height) {
+		if (plot == null || plot.isFrozen()) {
+			super.resizeCanvas(width, height);
+			return;
+		}
+		resetMagnification();
+		if (width == oldWidth && height == oldHeight) return;
+		if (plot == null) return;
+		ImageWindow win = imp.getWindow();
+		if (win==null || !(win instanceof PlotWindow)) return;
+		if (!win.isVisible()) return;
+		if (!((PlotWindow)win).wasActivated) return;				// window layout not finished yet?
+		Dimension minSize = plot.getMinimumSize();
+		int plotWidth  =  width < minSize.width	 ? minSize.width  : width;
+		int plotHeight = height < minSize.height ? minSize.height : height;
+		plot.setSize(plotWidth, plotHeight);
+		setSize(width, height);
+		oldWidth = width;
+		oldHeight = height;
+		((PlotWindow)win).canvasResized();
+	}
+
+	/** The image of a PlotCanvas is always shown at 100% magnification unless the plot is frozen */
+	public void setMagnification(double magnification) {
+		if (plot == null || plot.isFrozen())
+			super.setMagnification(magnification);
+		else
+			resetMagnification();
+	}
+
+	/** Scrolling a PlotCanvas is updating the plot, not viewing part of the plot, unless the plot is frozen */
+	public void setSourceRect(Rectangle r) {
+		if (plot.isFrozen())
+			super.setSourceRect(r);
+		else
+			resetMagnification();
+	}
+
+	void resetMagnification() {
+		magnification = 1.0;
+		srcRect.x = 0;
+		srcRect.y = 0;
+	}
+
+	/** overrides ImageCanvas.setupScroll; if plot is not frozen, scrolling modifies the plot data range */
+	protected void setupScroll(int ox, int oy) {
+		if (plot.isFrozen()) {
+			super.setupScroll(ox, oy);
+			return;
+		}
+		xMouseStart = ox;
+		yMouseStart = oy;
+		xScrolled = 0;
+		yScrolled = 0;
+	}
+
+	/** overrides ImageCanvas.scroll; if plot is not frozen, scrolling modifies the plot data range */
+	protected void scroll(int sx, int sy) {
+		if (plot.isFrozen()) {
+			super.scroll(sx, sy);
+			return;
+		}
+		if (sx == 0 && sy == 0) return;
+		if (xScrolled == 0 && yScrolled == 0)
+			plot.saveMinMax();
+		int dx = sx - xMouseStart;
+		int dy = sy - yMouseStart;
+		plot.scroll(dx-xScrolled, dy-yScrolled);
+		xScrolled = dx;
+		yScrolled = dy;
+		Thread.yield();
+	}
+
+	/** overrides ImageCanvas.mouseExited; removes 'range' arrows */
+	public void mouseExited(MouseEvent e) {
+		ImageWindow win = imp.getWindow();
+		if (win instanceof PlotWindow)
+			((PlotWindow)win).mouseExited(e);
+		super.mouseExited(e);
+	}
+
+	/** overrides ImageCanvas.mousePressed: no further processing of clicks on 'range' arrows */
+	public void mousePressed(MouseEvent e) {
+		rangeArrowIndexWhenPressed = getRangeArrowIndex(e);
+		if (rangeArrowIndexWhenPressed <0)
+			super.mousePressed(e);
+	}
+
+	/** Overrides ImageCanvas.mouseReleased, handles clicks on 'range' arrows */
+	public void mouseReleased(MouseEvent e) {
+		if (rangeArrowIndexWhenPressed>=0 && rangeArrowIndexWhenPressed==getRangeArrowIndex(e))
+			plot.zoomOnRangeArrow(rangeArrowIndexWhenPressed);
+		else
+			super.mouseReleased(e);
+	}
+
+    /** Returns the index of the arrow for modifying the range when the mouse click was
+     *  at such an arrow, otherwise -1 */
+    int getRangeArrowIndex(MouseEvent e) {
+        ImageWindow win = imp.getWindow();
+        int rangeArrowIndex = -1;
+        if (win instanceof PlotWindow) {
+            int x = e.getX();
+		    int y = e.getY();
+            rangeArrowIndex = ((PlotWindow)win).getRangeArrowIndex(x, y);
+        }
+        return rangeArrowIndex;
+    }
+}
diff --git a/src/ij/gui/PlotContentsDialog.java b/src/ij/gui/PlotContentsDialog.java
new file mode 100644
index 0000000..c3ccdb0
--- /dev/null
+++ b/src/ij/gui/PlotContentsDialog.java
@@ -0,0 +1,671 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.measure.CurveFitter;
+import ij.measure.Minimizer;
+import ij.text.TextWindow;
+import ij.measure.ResultsTable;
+import ij.plugin.Colors;
+import ij.plugin.frame.Recorder;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Arrays;
+import java.util.Vector;
+import java.util.ArrayList;
+
+/** This class implements the Plot Window's Data>"Add from Plot", "Add form Table", "Add Fit" and
+ *  "More>Contents Style" dialogs
+ */
+public class PlotContentsDialog implements DialogListener {
+	/** Types of dialog (ERROR suppresses the dialog after an invalid call of a constructor) */
+	public final static int ERROR=-1, STYLE=0, ADD_FROM_PLOT=1, ADD_FROM_TABLE=2, ADD_FROM_ARRAYS=3, ADD_FIT=4;
+	/** Dialog headings for each dialogType >= 0 */
+	private static final String[] HEADINGS = new String[] {"Plot Contents Style", "Add From Plot", "Plot From Table", "Add Plot Data", "Add Fit"};
+	private Plot          plot;                     // the plot we work on
+	private int           dialogType;               // determines what to do: ADD_FORM_PLOT, etc.
+	private double[]      savedLimits;              // previous plot range, for undo upon cancel
+	GenericDialog         gd;
+	private int currentObjectIndex = -1;
+	private Choice        objectChoice;
+	private Choice        symbolChoice;
+	private TextField     colorField, color2Field, labelField, widthField;
+	private Checkbox      visibleCheckbox;
+	private boolean       creatingPlot;              // for creating plots; dialogType determines source
+	private Choice        plotChoice;                // for "Add from Plot"
+	private Plot[]        allPlots;
+	private String[]      allPlotNames;
+	private static Plot   previousPlot;
+	private static int    previousPlotObjectIndex;
+	private int           defaultPlotIndex, defaultObjectIndex;
+	private int           currentPlotNumObjects;
+	private Choice        tableChoice;               // for "Add from Table"
+	final static int      N_COLUMNS = 4;             // number of data columns that we can have; x, y, xE, yE
+	private int           nColumnsToUse = N_COLUMNS; // user may restrict to 2, for not having error bars
+	private Choice[]      columnChoice = new Choice[N_COLUMNS];
+	private final static String[] COLUMN_NAMES = new String[] {"X:", "Y:", "X Error:", "Y Error:"};
+	private final static boolean[] COLUMN_ALLOW_NONE = new boolean[] {true, false, true, true}; //y data cannot be null
+	private ResultsTable[] allTables;
+	private String[]      allTableNames;
+	private static String previousTableName;
+	private static int[]  previousColumns = new int[]{1, 1, 0, 0}; //must be N_COLUMNS elements
+	private static int    defaultTableIndex;
+	private static int[]  defaultColumnIndex = new int[N_COLUMNS];
+	private String[]      arrayHeadings;             // for "Add from Arrays"
+	private ArrayList<float[]> arrayData;
+	private Choice        fitDataChoice;             // for "Add Fit"
+	private Choice        fitFunctionChoice;
+	private Thread        fittingThread;
+	private static String lastFitFunction = CurveFitter.fitList[0];
+	private String        curveFitterStatusString;
+	private static String previousColor="blue", previousColor2="#a0a0ff", previousSymbol="Circle";
+	private static double previousLineWidth = 1;
+	private static final String[] PLOT_COLORS = new String[] {"blue", "red", "black", "#00c0ff", "#00e000", "gray", "#c08060", "magenta"};
+
+
+	/** Prepares a new PlotContentsDialog for an existing plot. Use showDialog thereafter.
+	 *  @param dialogType may be STYLE (contents style), ADD_FROM_PLOT (add object from other plot), ADD_FROM_TABLE, and ADD_FIT */
+	public PlotContentsDialog(Plot plot, int dialogType) {
+		this.plot = plot;
+		this.dialogType = plot == null ? ERROR : dialogType;
+		if (plot != null) currentPlotNumObjects = plot.getNumPlotObjects();
+	}
+
+	/** Prepares a new PlotContentsDialog for creating a new plot using data from a ResultsTable.
+	 *  Use showDialog thereafter. */
+	public PlotContentsDialog(String title, ResultsTable rt) {
+		creatingPlot = true;
+		dialogType = ADD_FROM_TABLE;
+		if (rt == null || !isValid(rt)) {
+			IJ.error("Cant Create Plot","No (results) table or no data in "+title);
+			dialogType = ERROR;
+		}
+		plot = new Plot("Plot of "+title, "x", "y");
+		allTables = new ResultsTable[] {rt};
+		allTableNames = new String[] {title};
+	}
+
+	/** Prepares a new PlotContentsDialog for creating a new plot using float[] arrays as data.
+	 *  Each 'data' array in the ArrayList must have a corresponding element in the 'headings' array.
+	 *  'defaultHeadings' may contain the headings of the items selected initially for x, y, x error and y error, respectively.
+	 *  'defaultHeadings' and each of its entries may be null, and the array may have any length. */
+	public PlotContentsDialog(String title, String[] headings, String[] defaultHeadings, ArrayList<float[]> data) {
+		creatingPlot = true;
+		dialogType = ADD_FROM_ARRAYS;
+		this.arrayHeadings = headings;
+		this.arrayData = data;
+		plot = new Plot(title, "x", "y");
+		setDefaultColumns(defaultHeadings);
+	}
+
+	/** Prepares a new PlotContentsDialog for adding data from float[] arrays to a plot.
+	 *  Each 'data' array in the ArrayList must have a corresponding element in the 'headings' array.
+	 *  'defaultHeadings' may contain the headings of the items selected initially for x, y, x error and y error, respectively.
+	 *  'defaultHeadings' and each of its entries may be null, and the array may have any length. */
+	public PlotContentsDialog(Plot plot, String[] headings, String[] defaultHeadings, ArrayList<float[]> data) {
+		dialogType = ADD_FROM_ARRAYS;
+		this.plot = plot;
+		this.arrayHeadings = headings;
+		this.arrayData = data;
+		setDefaultColumns(defaultHeadings);
+	}
+
+	/** Avoids showing a selection for the error bars; must be called before showDialog. */
+	public void noErrorBars() {
+		nColumnsToUse = 2; // only x, y columns can be selected
+	}
+
+	/** Shows the dialog, with a given parent Frame (may be null) */
+	public void showDialog(Frame parent) {
+		if (dialogType == ERROR) return;
+		if (!creatingPlot) savedLimits = plot.getLimits();
+		plot.savePlotObjects();
+		String[] designations = plot.getPlotObjectDesignations();
+		if (dialogType == STYLE && designations.length==0) {
+			IJ.error("Empty Plot");
+			return;
+		} else if (dialogType == ADD_FROM_PLOT) {
+			prepareAddFromPlot();
+			if (allPlots.length == 0) return;	//should never happen; we have at least the current plot
+		} else if (dialogType == ADD_FROM_TABLE && !creatingPlot) {
+			prepareAddFromTable();
+			if (allTables.length == 0) return;	//should never happen; PlotWindow should not enable if no table
+		}
+		if ((dialogType == ADD_FROM_TABLE || dialogType == ADD_FROM_ARRAYS) && !creatingPlot)
+			suggestColor();
+		if (parent == null && plot.getImagePlus() != null)
+			parent = plot.getImagePlus().getWindow();
+		gd = parent == null ? new GenericDialog(HEADINGS[dialogType]) :
+				new GenericDialog(HEADINGS[dialogType], parent);
+		IJ.wait(100);			//sometimes needed to avoid hanging?
+		if (dialogType == STYLE) {
+			gd.addChoice("Item:", designations, designations[0]);
+			objectChoice = (Choice)(gd.getChoices().get(0));
+			currentObjectIndex = objectChoice.getSelectedIndex();
+		} else if (dialogType == ADD_FROM_PLOT) {
+			gd.addChoice("Select Plot:", allPlotNames, allPlotNames[defaultPlotIndex]);
+			gd.addChoice("Item to Add:", new String[]{""}, "");  // will be set up by makeSourcePlotObjects
+			Vector choices = gd.getChoices();
+			plotChoice = (Choice)(choices.get(0));
+			objectChoice = (Choice)(choices.get(1));
+			makeSourcePlotObjects();
+		} else if (dialogType == ADD_FROM_TABLE) {
+			gd.addChoice("Select Table:", allTableNames, allTableNames[defaultTableIndex]);
+			tableChoice = (Choice)(gd.getChoices().get(0));
+			if (creatingPlot) tableChoice.setEnabled(false);     // we can't select the table, we have only one
+		} else if (dialogType == ADD_FIT) {
+			String[] dataSources = plot.getDataObjectDesignations();
+			if (dataSources.length == 0) {
+				IJ.error("No Data For Fitting");
+				return;
+			}
+			gd.addChoice("Fit Data Set:", dataSources, dataSources[0]);
+			gd.addChoice("Fit Function:", new String[0], "");
+			Vector choices = gd.getChoices();
+			fitDataChoice = (Choice)(choices.get(0));
+			fitFunctionChoice = (Choice)(choices.get(1));
+			if (dataSources.length == 1)
+				fitDataChoice.setEnabled(false);
+			for (int i=0; i<CurveFitter.fitList.length; i++)
+				fitFunctionChoice.addItem(CurveFitter.fitList[CurveFitter.sortedTypes[i]]);
+			fitFunctionChoice.select(lastFitFunction);
+		}
+		if (dialogType == ADD_FROM_TABLE || dialogType == ADD_FROM_ARRAYS) {
+			for (int i=0; i<nColumnsToUse; i++) {
+				gd.addChoice(COLUMN_NAMES[i], new String[]{""}, "");  // will set up by makeSourceColumns
+				Vector choices = gd.getChoices();
+				columnChoice[i] = (Choice)(choices.get(choices.size()-1));
+			}
+			makeSourceColumns();
+			if (!creatingPlot)
+				suggestNewYColumn();
+		}
+		gd.addStringField("Color:", previousColor, 10);
+		gd.addStringField("Secondary (fill) color:", previousColor2, 10);
+		gd.addNumericField("Line width: ", previousLineWidth, 1);
+		gd.addChoice("Symbol:", Plot.SORTED_SHAPES, dialogType == ADD_FIT ? "line" : previousSymbol);
+		gd.addStringField("Label:", "", 20);
+		gd.setInsets(10, 60, 0);
+		gd.addCheckbox("Visible", true);
+		Vector choices = gd.getChoices();
+		symbolChoice = (Choice)(choices.get(choices.size()-1));
+		Vector stringFields = gd.getStringFields();
+		colorField = (TextField)(stringFields.get(0));
+		color2Field = (TextField)(stringFields.get(1));
+		labelField = (TextField)(stringFields.get(2));
+		widthField = (TextField)(gd.getNumericFields().get(0));
+		visibleCheckbox = (Checkbox)(gd.getCheckboxes().get(0));
+		gd.addDialogListener(this);
+		IJ.wait(100);			//sometimes needed to avoid hanging?
+		if (dialogType == STYLE)
+			setDialogStyleFields(objectChoice.getSelectedIndex());
+		else if (dialogType == ADD_FROM_PLOT)
+			addObjectFromPlot();
+		else if (dialogType == ADD_FROM_TABLE || dialogType == ADD_FROM_ARRAYS)
+			addObjectFromTable();
+		else if (dialogType == ADD_FIT)
+			addFitCurve();
+		plot.updateImage();
+		if (creatingPlot) {
+			boolean recording = Recorder.record;
+			Recorder.record = false; // don't record creating the image as image selection
+			plot.show();
+			if (recording) Recorder.record = true;
+		}
+
+		gd.showDialog();
+
+		if (fittingThread != null) {
+			fittingThread.interrupt();
+			try {
+				fittingThread.join();
+			} catch (InterruptedException e) {}
+		}
+		if (gd.wasCanceled()) {
+			if (creatingPlot) {
+				ImagePlus imp = plot.getImagePlus();
+				if (imp != null) imp.close();
+			} else {
+				plot.restorePlotObjects();
+				if (savedLimits != null)
+					plot.setLimits(savedLimits[0], savedLimits[1], savedLimits[2], savedLimits[3]);
+				plot.updateImage();
+				plot.killPlotObjectsSnapshot();
+			}
+			return;
+		}
+		plot.killPlotObjectsSnapshot();
+		if (dialogType == ADD_FROM_TABLE || dialogType == ADD_FROM_ARRAYS || dialogType == ADD_FIT) {
+			previousColor = colorField.getText();
+			previousColor2 = color2Field.getText();
+			previousSymbol = symbolChoice.getSelectedItem();
+			previousLineWidth = Tools.parseDouble(widthField.getText());
+		}
+		if (dialogType == ADD_FIT) {
+			lastFitFunction = fitFunctionChoice.getSelectedItem();
+			IJ.log(curveFitterStatusString);
+		}
+		if (Recorder.record && !Recorder.scriptMode()) {
+			if (dialogType == ADD_FROM_PLOT) {
+				Recorder.recordString("Plot.addFromPlot(\""+plotChoice.getSelectedItem()+"\", "+objectChoice.getSelectedIndex()+");\n");
+			} else if (dialogType == ADD_FROM_TABLE) {
+				if (creatingPlot)
+					Recorder.recordString("Plot.create(\""+plot.getTitle()+"\", \""+plot.getLabel('x')+"\", \""+plot.getLabel('y')+"\");\n");
+				String xSource = columnChoice[0].getSelectedIndex() == 0 ? "" :
+						"Table.getColumn(\""+columnChoice[0].getSelectedItem()+"\", \""+tableChoice.getSelectedItem()+"\"), ";
+				String ySource = "Table.getColumn(\""+columnChoice[1].getSelectedItem()+"\", \""+tableChoice.getSelectedItem()+"\")";
+				Recorder.recordString("Plot.add(\""+symbolChoice.getSelectedItem()+"\", "+xSource+ySource+");\n");
+				if (columnChoice[2].getSelectedIndex() > 0)
+					Recorder.recordString("Plot.add(\"xerror\", Table.getColumn(\""+
+							columnChoice[2].getSelectedItem()+"\", \""+tableChoice.getSelectedItem()+"\"));\n");
+				if (columnChoice[3].getSelectedIndex() > 0)
+					Recorder.recordString("Plot.add(\"error\", Table.getColumn(\""+
+							columnChoice[3].getSelectedItem()+"\", \""+tableChoice.getSelectedItem()+"\"));\n");
+			}
+			Recorder.recordString("Plot.setStyle("+currentObjectIndex+", \""+getStyleString()+"\");\n");
+		}
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (e==null)
+			return true;	//gets called with e=null upon OK
+		boolean setStyle = false;
+		if (dialogType == STYLE) {
+			int objectIndex = objectChoice.getSelectedIndex();  // no getNextChoice since Choices depend on dialog type
+			setStyle = (e.getSource() != objectChoice);
+			if (e.getSource() == objectChoice) {
+				setDialogStyleFields(objectIndex);
+				currentObjectIndex = objectIndex;
+			} else
+				setStyle = true;
+		} else if (dialogType == ADD_FROM_PLOT) {
+			if (e.getSource() == plotChoice) {
+				makeSourcePlotObjects();
+				addObjectFromPlot();
+			} else if (e.getSource() == objectChoice) {
+				addObjectFromPlot();
+			} else
+				setStyle = true;
+		} else if (dialogType == ADD_FROM_TABLE || dialogType == ADD_FROM_ARRAYS) {
+			if (e.getSource() == tableChoice) {
+				makeSourceColumns();
+				addObjectFromTable();
+			} else {
+				boolean columnChanged = false;
+				for (int c=0; c<nColumnsToUse; c++)
+					if (e.getSource() == columnChoice[c]) {
+						columnChanged = true;
+						break;
+					}
+				if (columnChanged)
+					addObjectFromTable();
+				else
+					setStyle = true;
+			}
+		} else if (dialogType == ADD_FIT) {
+			if (e.getSource() == fitDataChoice || e.getSource() == fitFunctionChoice)
+				addFitCurve();
+			else
+				setStyle = true;
+		}
+		if (setStyle)
+			setPlotObjectStyle();
+		return true;
+	}
+
+	private void setPlotObjectStyle() {
+		if (currentObjectIndex < 0) return;
+		String style = getStyleString();
+		plot.setPlotObjectStyle(currentObjectIndex, style);
+		if (labelField.isEnabled()) {
+			String label = labelField.getText();
+			plot.setPlotObjectLabel(currentObjectIndex, label.length() > 0 ? label : null);
+		}
+	}
+
+	/** Returns the style String for Plot.setPlotObjectStyle from the dialog fields */
+	private String getStyleString() {
+		String color = colorField.getText();
+		String color2 = color2Field.getText();
+		double width = Tools.parseDouble(widthField.getText());
+		String symbol = symbolChoice.getSelectedItem();
+		Boolean visible = visibleCheckbox.getState();
+		String style = color.trim()+","+color2.trim()+","+(float)width+","+ symbol+(visible?"":"hidden");
+		return style;
+	}
+
+	/** Sets the style fields of the dialog according to the style of the PlotObject having the
+	 *  index given. Does nothing with index < 0 */
+	private void setDialogStyleFields(int index) {
+		if (index < 0) return;
+		Checkbox visibleC = (Checkbox)gd.getCheckboxes().get(0);
+		String styleString = plot.getPlotObjectStyle(index);
+		String designation = plot.getPlotObjectDesignations()[index].toLowerCase();
+		boolean isData = designation.startsWith("data");
+		boolean isText = designation.startsWith("text");
+		boolean isBox = designation.startsWith("shapes") &&
+				(designation.contains("boxes") || designation.contains("rectangles"));
+		boolean isGrid = designation.startsWith("shapes") && designation.contains("redraw_grid");
+
+		String[] items = styleString.split(",");
+		colorField.setText(items[0]);
+		color2Field.setText(items[1]);
+		widthField.setText(items[2]);
+		if (items.length >= 4)
+			symbolChoice.select(items[3]);
+		labelField.setText(isData ? plot.getPlotObjectLabel(index) : "");
+		visibleC.setState(!styleString.contains("hidden"));
+
+		colorField.setEnabled(!isGrid);	        //grid color is fixed
+		color2Field.setEnabled(isData || isBox);//only (some) data symbols and boxes have secondary (fill) color
+		widthField.setEnabled(!isText  && !isGrid); //all non-Text types have line width
+		// visibleC.setEnabled(!isGrid);        //allow to hide everything
+		symbolChoice.setEnabled(isData);        //only data have a symbol to choose
+		labelField.setEnabled(isData);          //only data have a label in the legend
+	}
+
+
+	/** Prepare the lists 'allPlots', 'allPlotNames' for the "Add from Plot" dialog.
+	 *  Also sets 'defaultPlotIndex', 'defaultObjectIndex' */
+	private void prepareAddFromPlot() {
+		int[] windowIDlist = WindowManager.getIDList();
+		ArrayList<ImagePlus> plotImps = new ArrayList<ImagePlus>();
+		ImagePlus currentPlotImp = null;
+		for (int windowID : windowIDlist) {
+			ImagePlus imp = WindowManager.getImage(windowID);
+			if (imp == null || imp.getWindow() == null) continue;
+			Plot thePlot = (Plot)(imp.getProperty(Plot.PROPERTY_KEY));
+			if (thePlot != null) {
+				if (thePlot == plot)
+					currentPlotImp = imp;
+				else
+					plotImps.add(imp);
+			}
+		}
+		if (currentPlotImp != null)
+			plotImps.add(currentPlotImp);     // add current plot as the last one (usually not used)
+		if (plotImps.size() == 0) return;     // should never happen; we have at least the current plot
+
+		allPlots = new Plot[plotImps.size()];
+		allPlotNames = new String[plotImps.size()];
+		defaultPlotIndex = 0;
+		for (int i=0; i<allPlots.length; i++) {
+			ImagePlus imp = plotImps.get(i);
+			allPlots[i] = (Plot)(imp.getProperty(Plot.PROPERTY_KEY));
+			if (allPlots[i] == previousPlot)
+				defaultPlotIndex = i;
+			allPlotNames[i] = imp.getWindow().getTitle();
+			if (imp == currentPlotImp)
+				allPlotNames[i] = "THIS PLOT: " + allPlotNames[i];
+		}
+	}
+
+	/** Set up the Choice of Plot objects for the source plot after selecting that plot */
+	private void makeSourcePlotObjects() {
+		int plotIndex = plotChoice.getSelectedIndex();
+		String[] plotObjectNames = allPlots[plotIndex].getPlotObjectDesignations();
+		objectChoice.removeAll();
+		int nPlotObjects = allPlots[plotIndex] == plot ? currentPlotNumObjects : plotObjectNames.length; //for the own plot, the number of objects may have changed in the meanwhile
+		for (int i=0; i<nPlotObjects; i++)
+			objectChoice.addItem(plotObjectNames[i]);
+		objectChoice.select(Math.min(nPlotObjects-1, previousPlotObjectIndex));
+	}
+
+	/** For "Add from Plot", adds item to the plot according to the current Choice settings
+	 *  and sets the Style fields for it. */
+	private void addObjectFromPlot() {
+		int plotIndex = plotChoice.getSelectedIndex();
+		int objectIndex = objectChoice.getSelectedIndex();
+		plot.restorePlotObjects();
+		if (savedLimits != null)
+			plot.setLimits(savedLimits);
+		currentObjectIndex = plot.addObjectFromPlot(allPlots[plotIndex], objectIndex); //no updateImage; will be done later
+		plot.fitRangeToLastPlotObject();
+		setDialogStyleFields(currentObjectIndex);
+		previousPlot = allPlots[plotIndex];
+		previousPlotObjectIndex = objectIndex;
+	}
+
+	/** Prepare the lists 'allTables', "allTableNames' for the "Add from Table" dialog.
+	 *  Also sets 'defaultTableIndex' */
+	private void prepareAddFromTable() {
+		ArrayList<TextWindow> tableWindows = new ArrayList<TextWindow>();
+		Frame[] windows = WindowManager.getNonImageWindows();
+		for (Frame win : windows) {
+			if (!(win instanceof TextWindow)) continue;
+			ResultsTable rt = ((TextWindow)win).getResultsTable();
+			if (isValid(rt))
+				tableWindows.add((TextWindow)win);
+		}
+		allTables = new ResultsTable[tableWindows.size()];
+		allTableNames = new String[tableWindows.size()];
+		defaultTableIndex =  0;
+		for (int i=0; i<allTables.length; i++) {
+			TextWindow tw = tableWindows.get(i);
+			allTables[i] = tw.getResultsTable();
+			if (allTableNames[i] == previousTableName)
+				defaultTableIndex = i;
+			allTableNames[i] = tw.getTitle();
+		}
+	}
+
+	/** Returns whether there is at least one table that can be used for "Add from Table" */
+	public static boolean tableWindowExists() {
+		Frame[] windows = WindowManager.getNonImageWindows();
+		for (Frame win : windows) {
+			if (win instanceof TextWindow) {
+				ResultsTable rt = ((TextWindow)win).getResultsTable();
+				if (isValid(rt)) return true;
+			}
+		}
+		return false;
+	}
+
+	/** Set up the Choices for the source columns for "Add from Table" and "Add from Arrays" */
+	private void makeSourceColumns() {
+		String[] columnHeadings = null;
+		if (dialogType == ADD_FROM_TABLE) {
+			int tableIndex = tableChoice.getSelectedIndex();
+			ResultsTable rt = allTables[tableIndex];
+			String columnHeadingStr = rt.getColumnHeadings();
+			if (!columnHeadingStr.startsWith(" \t"))
+				columnHeadingStr = " \t"+columnHeadingStr;	//add empty field at beginning (if we don't have one)
+			columnHeadings = columnHeadingStr.split("\t");
+			int nBadColumns = 0;
+			for (int i=1; i<columnHeadings.length; i++) {	//check for columns with no data
+				int index = rt.getColumnIndex(columnHeadings[i]);
+				if (!rt.columnExists(index)) {
+					columnHeadings[i] = null;
+					nBadColumns++;
+				}
+			}
+			if (nBadColumns > 0) {
+				String[] newHeadings = new String[columnHeadings.length - nBadColumns];
+				int i=0;
+				for (String heading : columnHeadings)		//copy 'good' headings
+					if (heading != null)
+						newHeadings[i++] = heading;
+				columnHeadings = newHeadings;
+			}
+		} else {   // if (dialogType == ADD_FROM_ARRAYS)
+			columnHeadings = new String[arrayHeadings.length+1];
+			System.arraycopy(arrayHeadings, 0, columnHeadings, 1, arrayHeadings.length);
+		}
+		columnHeadings[0] = "---";
+		for (int c=0; c<nColumnsToUse; c++) {
+			columnChoice[c].removeAll();
+			for (int i=COLUMN_ALLOW_NONE[c] ? 0 : 1; i<columnHeadings.length; i++)
+					columnChoice[c].addItem(columnHeadings[i]);
+			if (columnChoice[c].getItemCount() > 0 && previousColumns[c] >= 0)
+				columnChoice[c].select(Math.min(columnChoice[c].getItemCount()-1, previousColumns[c]));
+		}
+	}
+
+	/** For "Add from Table" and "Add from Arrays" adds item to the plot according to the current Choice settings
+	 *  and sets the Style fields for it. */
+	private void addObjectFromTable() {
+		float[][] data = getDataArrays();
+		if (data[1] == null) return;  //no y data? then can't plot
+		String label = columnChoice[1].getSelectedItem();	//take label from y
+		int shape = Plot.toShape(symbolChoice.getSelectedItem());
+		float lineWidth = (float)(Tools.parseDouble(widthField.getText()));
+		if (lineWidth > 0)
+			plot.setLineWidth(lineWidth);
+		plot.restorePlotObjects();
+		if (savedLimits != null)
+			plot.setLimits(savedLimits);
+		plot.setColor(colorField.getText(), color2Field.getText());
+		plot.addPoints(data[0], data[1], data[3], shape, label);
+		if (data[2] != null)
+			plot.addHorizontalErrorBars(data[2]);
+		if (creatingPlot) {
+			plot.setXYLabels(data[0]==null ? "x" : columnChoice[0].getSelectedItem(), columnChoice[1].getSelectedItem());
+			plot.setLimitsToFit(false);
+		} else
+			plot.fitRangeToLastPlotObject();
+		currentObjectIndex = plot.getNumPlotObjects()-1;
+		setDialogStyleFields(currentObjectIndex);
+		if (dialogType == ADD_FROM_TABLE)
+			previousTableName = allTableNames[tableChoice.getSelectedIndex()];
+	}
+
+	/** For "Add from Table" and "Add from Arrays", tries to set a 'y' data column that has not been plotted yet. */
+	private void suggestNewYColumn() {
+		int nYcolumns = columnChoice[1].getItemCount();
+		int currentIndex = columnChoice[1].getSelectedIndex();
+		for (int i=0; i<nYcolumns; i++) {
+			if (columnChoice[0].getSelectedIndex()==0 ||    //if x is a data column, don't suggest it as y
+					!columnChoice[1].getSelectedItem().equals(columnChoice[0].getSelectedItem())) {
+				float[][] data = getDataArrays();
+				data = new float[][] {data[0], data[1]};	//only compare x & y, not the error bars
+				if (plot.getPlotObjectIndex(data) < 0)
+					return; //current data are ok (not duplicate)
+			}
+			columnChoice[1].select((currentIndex+i+1)%nYcolumns); //try the next one
+		}
+	}
+
+	/** For "Add from Table" and "Add from Arrays", retrieves the data arrays according to the columnChoices */
+	private float[][] getDataArrays() {
+		float[][] data = new float[N_COLUMNS][];
+		if (dialogType == ADD_FROM_TABLE) {
+			ResultsTable rt = allTables[tableChoice.getSelectedIndex()];
+			for (int c=0; c<N_COLUMNS; c++) {
+				String heading = columnChoice[c].getSelectedItem();
+				int index = rt.getColumnIndex(heading);
+				if (index >= 0)
+					data[c] = rt.getColumn(index);
+				previousColumns[c] = columnChoice[c].getSelectedIndex();
+			}
+		} else { //if (dialogType == ADD_FROM_ARRAYS)
+			for (int c=0; c<nColumnsToUse; c++) {
+				String heading = columnChoice[c].getSelectedItem();
+				int index = getIndex(arrayHeadings, heading);
+				if (index >= 0)
+					data[c] = arrayData.get(index);
+				previousColumns[c] = columnChoice[c].getSelectedIndex();
+			}
+		}
+		return data;
+	}
+
+	/** Does the curve fit and adds the fit curve to the plot */
+	private void addFitCurve() {
+		plot.restorePlotObjects();
+		if (savedLimits != null)
+			plot.setLimits(savedLimits);
+		int dataIndex = fitDataChoice.getSelectedIndex();
+		float[][] data = plot.getDataObjectArrays(dataIndex);
+		String fitName = fitFunctionChoice.getSelectedItem();
+		int fitType = getIndex(CurveFitter.fitList, fitName);
+		CurveFitter cf = new CurveFitter(Tools.toDouble(data[0]), Tools.toDouble(data[1]));
+		cf.doFit(fitType);
+		String statusString = "Fit: "+Minimizer.STATUS_STRING[cf.getStatus()];
+		if (cf.getStatus() == Minimizer.SUCCESS)
+			statusString += ", sum residuals ^2 = "+(float)(cf.getSumResidualsSqr());
+		IJ.showStatus(statusString);
+		curveFitterStatusString = "Fit for "+plot.getTitle()+": "+fitDataChoice.getSelectedItem()+cf.getResultString(); //will be shown in Log when done
+
+		double[] plotMinMax = plot.getLimits();
+		double[] dataMinMax = Tools.getMinMax(data[0]);
+		double min = Math.min(plotMinMax[0], dataMinMax[0]);
+		double max = Math.max(plotMinMax[1], dataMinMax[1]);
+		double plotSpan = Math.abs(plotMinMax[1] - plotMinMax[0]);
+		double dataSpan = Math.abs(dataMinMax[1] - dataMinMax[0]);
+		double rangeFactor = Math.max(plotSpan/dataSpan, dataSpan/plotSpan);
+		if (rangeFactor > 20) rangeFactor = 20;
+		int nPoints = (int)(1000*rangeFactor); //finer data point spacing if we will want to zoom out or in
+		float[] xFit = new float[nPoints];
+		float[] yFit = new float[nPoints];
+		for (int i=0; i<nPoints; i++) {
+			xFit[i] = (float)(min + i*((max-min)/(nPoints-1)));
+			yFit[i] = (float)(cf.f(xFit[i]));
+		}
+		plot.addPoints(xFit, yFit, Plot.LINE);
+		currentObjectIndex = plot.getNumPlotObjects()-1;
+		labelField.setText("Fit: "+fitName);
+		setPlotObjectStyle();
+	}
+
+	/** Returns whether the table is non-null and has at least one non-trivial data column */
+	private static boolean isValid(ResultsTable rt) {
+		if (rt == null) return false;
+		String columnHeadingStr = rt.getColumnHeadings();
+		if (columnHeadingStr.startsWith(" \t"))
+			return columnHeadingStr.length() >=3;
+		else
+			return columnHeadingStr.length() >= 1;
+
+	}
+
+	/** For "Add from Arrays", sets default columns from the colums titles */
+	private void setDefaultColumns(String[] defaultHeadings) {
+		if (defaultHeadings == null) return;
+		for (int i=0; i<Math.min(defaultHeadings.length, nColumnsToUse); i++) {
+			if (defaultHeadings[i] == null || defaultHeadings[i].length()==0)
+				previousColumns[i] = 0;
+			else
+				previousColumns[i] = Math.max(0,  //default column index; index=0 means 'none' for all except y
+						getIndex(arrayHeadings, defaultHeadings[i]) + (COLUMN_ALLOW_NONE[i] ? 1 : 0));
+		}
+	}
+
+	/** Finds the index of a searchTerm in the String array; returns -1 if not found */
+	private static int getIndex(String[] strArray, String searchTerm) {
+		for (int i=0; i<strArray.length; i++)
+			if (strArray[i].equals(searchTerm)) return i;
+		return -1;
+	}
+
+	/** Sets the 'previousColor', 'previousColor2' with a suggestion for new colors */
+	private void suggestColor() {
+		boolean[] colorUsed = new boolean[PLOT_COLORS.length];
+		String[] designations = plot.getPlotObjectDesignations();
+		for (int i=0; i<designations.length; i++) {
+			if (!(designations[i].toLowerCase().startsWith("data"))) continue;
+			String styleString = plot.getPlotObjectStyle(i);
+			for (int j=0; j<PLOT_COLORS.length; j++)
+				if (styleString.startsWith(PLOT_COLORS[j]))
+					colorUsed[j] = true;
+		}
+		String newColor = previousColor;
+		for (int j=0; j<PLOT_COLORS.length; j++)
+			if (!colorUsed[j]) {
+				newColor = PLOT_COLORS[j];
+				break;
+			}
+		if (previousColor2 != null && previousColor2.equals(previousColor))  //if fill color was main color, keep it such
+			previousColor2 = newColor;
+		else if (Colors.decode(previousColor2, null) != null) {              //if we had a separate fill color, make main color brighter
+			Color newC = Colors.decode(newColor,Color.BLACK);
+			Color newC2 = new Color(makeBrighter(newC.getRed()), makeBrighter(newC.getGreen()), makeBrighter(newC.getBlue()));
+			previousColor2 = Colors.colorToString(newC2);
+		}
+		previousColor = newColor;
+	}
+
+	/** Creates an 8-bit color value closer to 255 */
+	private static int makeBrighter(int v) {
+		return v> 190 ? 255 : 255 - (int)(0.4*(255-v));
+	}
+}
diff --git a/src/ij/gui/PlotDialog.java b/src/ij/gui/PlotDialog.java
new file mode 100644
index 0000000..2f53362
--- /dev/null
+++ b/src/ij/gui/PlotDialog.java
@@ -0,0 +1,551 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.util.Vector;
+
+/*
+ * This class contains dialogs for formatting of plots (range, axes, labels, legend, creating a high-resolution plot)
+ * Adding and formatting of contents (curves, symbols, ...) is in PlotContentsStyleDialog
+ */
+
+public class PlotDialog implements DialogListener {
+
+	/** Types of dialog. Note that 10-14 must be the same as the corresponding PlotWindow.rangeArrow numbers */
+	public static final int SET_RANGE = 0, AXIS_OPTIONS = 1, LEGEND = 2, HI_RESOLUTION = 3, TEMPLATE = 4, //5-9 spare
+			X_LEFT = 10, X_RIGHT = 11, Y_BOTTOM = 12, Y_TOP = 13, X_AXIS = 14, Y_AXIS = 15;
+	/** Dialog headings for the dialogTypes */
+	private static final String[] HEADINGS = new String[] {"Plot Range", "Axis Options", "Add Legend", "High-Resolution Plot", "Use Template",
+			null, null, null, null, null,  // 5-9 spare
+			"X Left", "X Right", "Y Bottom","Y Top", "X Axis", "Y Axis"};
+	/** Positions and corresponding codes for legend position */
+	private static final String[] LEGEND_POSITIONS = new String[] {"Auto",	"Top-Left", "Top-Right", "Bottom-Left", "Bottom-Right", "No Legend"};
+	private static final int[] LEGEND_POSITION_N = new int[] {Plot.AUTO_POSITION, Plot.TOP_LEFT, Plot.TOP_RIGHT, Plot.BOTTOM_LEFT, Plot.BOTTOM_RIGHT, 0};
+	/** Template "copy what" flag: dialog texts and corresponding bit masks, in the sequence as they appear in the dialog*/
+	private static final String[] TEMPLATE_FLAG_NAMES = new String[] {"X Range", "Y Range", "Axis Style", "Labels",
+			"Legend", "Contents Style", "Extra Objects (Curves...)",  "Window Size"};
+	private static final int[] TEMPLATE_FLAGS = new int[] {Plot.X_RANGE, Plot.Y_RANGE, Plot.COPY_AXIS_STYLE, Plot.COPY_LABELS,
+			Plot.COPY_LEGEND, Plot.COPY_CONTENTS_STYLE, Plot.COPY_EXTRA_OBJECTS, Plot.COPY_SIZE};
+
+	private Plot plot;
+	private int  dialogType;
+	private boolean minMaxSaved;			//whether plot min&max has been saved for "previous range"
+	private boolean dialogShowing;			//when the dialog is showing, ignore the last call with event null
+	private Plot[]  templatePlots;
+
+	private Checkbox xLogCheckbox, yLogCheckbox;
+
+	//saved dialog options: legend
+	private static int legendPosNumber = 0;
+	private static boolean bottomUp;
+	private static boolean transparentBackground;
+	//saved dialog options: Axis labels
+	private static String lastXLabel, lastYLabel;
+	private static float plotFontSize;
+	//saved dialog options: High-resolution plot
+	private static float hiResFactor = 4.0f;
+	private static boolean hiResAntiAliased = true;
+	//saved dialog options: Use Template
+	private static int templateID;
+	private static int lastTemplateFlags = Plot.COPY_AXIS_STYLE|Plot.COPY_CONTENTS_STYLE;
+
+	/** Constructs a new PlotDialog for a given plot and sets the type of dialog */
+	public PlotDialog(Plot plot, int dialogType) {
+		this.plot = plot;
+		this.dialogType = dialogType;
+	}
+
+	/** Asks the user for axis scaling; then replot with new scale on the same ImageProcessor.
+	 *	The 'parent' frame may be null */
+	public void showDialog(Frame parent) {
+		if (dialogType == HI_RESOLUTION) {	//'make high-resolution plot' dialog has no preview, handled separately
+			doHighResolutionDialog(parent);
+			return;
+		}
+		plot.savePlotPlotProperties();
+		if (dialogType == TEMPLATE)
+			plot.savePlotObjects();
+
+		String dialogTitle = dialogType >= X_LEFT && dialogType <= Y_TOP ?
+			"Set Axis Limit..." : (HEADINGS[dialogType] + "...");
+		GenericDialog gd = parent == null ? new GenericDialog(dialogTitle) :
+				new GenericDialog(dialogTitle, parent);
+		if (!setupDialog(gd)) return;
+		gd.addDialogListener(this);
+		dialogItemChanged(gd, null);		//preview immediately
+		dialogShowing = true;
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			plot.restorePlotProperties();
+			if (dialogType == TEMPLATE)
+				plot.restorePlotObjects();
+			plot.update();
+		} else {
+			if (Recorder.record)
+				record();
+			String xAxisLabel = plot.getLabel('x');
+			if ((dialogType == AXIS_OPTIONS || dialogType == X_AXIS) && xAxisLabel != null && xAxisLabel.length() > 0)
+				lastXLabel = xAxisLabel;	//remember for next time, in case we have none
+			String yAxisLabel = plot.getLabel('y');
+			if ((dialogType == AXIS_OPTIONS || dialogType == Y_AXIS) && yAxisLabel != null && yAxisLabel.length() > 0)
+				lastYLabel = yAxisLabel;
+			if (dialogType == SET_RANGE || dialogType == X_AXIS || dialogType == Y_AXIS)
+				plot.makeLimitsDefault();
+			if (dialogType == TEMPLATE)
+				lastTemplateFlags = plot.templateFlags;
+
+		}
+		plot.killPlotPropertiesSnapshot();
+		if (dialogType == TEMPLATE)
+			plot.killPlotObjectsSnapshot();
+
+		ImagePlus imp = plot.getImagePlus();
+		ImageWindow win = imp == null ? null : imp.getWindow();
+		if (win instanceof PlotWindow)
+			((PlotWindow)win).hideRangeArrows(); // arrows etc might be still visible, but the mouse maybe elsewhere
+
+		if (!gd.wasCanceled() && !gd.wasOKed()) { // user has pressed "Set all limits" or "Set Axis Options" button
+			int newDialogType = (dialogType == SET_RANGE) ? AXIS_OPTIONS : SET_RANGE;
+			new PlotDialog(plot, newDialogType).showDialog(parent);
+		}
+	}
+
+	/** Setting up the dialog fields and initial parameters. The input is read in the dialogItemChanged method, which must
+	 *  have exactly the same structure of 'if' blocks and matching 'get' methods for each input field.
+	 *  @return false on error */
+	private boolean setupDialog(GenericDialog gd) {
+		double[] currentMinMax = plot.getLimits();
+		boolean livePlot = plot.plotMaker != null;
+
+		int xDigits = plot.logXAxis ? -2 : Plot.getDigits(currentMinMax[0], currentMinMax[1], 0.005*Math.abs(currentMinMax[1]-currentMinMax[0]), 6, 0);
+		if (dialogType == SET_RANGE || dialogType == X_AXIS) {
+			gd.addNumericField("X_From", currentMinMax[0], xDigits, 6, "*");
+			gd.addToSameRow();
+			gd.addNumericField("To", currentMinMax[1], xDigits, 6, "*");
+			gd.setInsets(0, 20, 0); //top, left, bottom
+			if (livePlot)
+				gd.addCheckbox("Fix_X Range While Live", (plot.templateFlags & Plot.X_RANGE) != 0);
+			gd.addCheckbox("Log_X Axis  **", (plot.hasFlag(Plot.X_LOG_NUMBERS)));
+			xLogCheckbox = lastCheckboxAdded(gd);
+			enableDisableLogCheckbox(xLogCheckbox, currentMinMax[0], currentMinMax[1]);
+		}
+		int yDigits = plot.logYAxis ? -2 : Plot.getDigits(currentMinMax[2], currentMinMax[3], 0.005*Math.abs(currentMinMax[3]-currentMinMax[2]), 6, 0);
+		if (dialogType == SET_RANGE || dialogType == Y_AXIS) {
+			gd.setInsets(20, 0, 3); //top, left, bottom
+			gd.addNumericField("Y_From", currentMinMax[2], yDigits, 6, "*");
+			gd.addToSameRow();
+			gd.addNumericField("To", currentMinMax[3], yDigits, 6, "*");
+			if (livePlot)
+				gd.addCheckbox("Fix_Y Range While Live", (plot.templateFlags & Plot.Y_RANGE) != 0);
+			gd.addCheckbox("Log_Y Axis  **", (plot.hasFlag(Plot.Y_LOG_NUMBERS)));
+			yLogCheckbox = lastCheckboxAdded(gd);
+			enableDisableLogCheckbox(yLogCheckbox, currentMinMax[2], currentMinMax[3]);
+		}
+		if (dialogType >= X_LEFT && dialogType <= Y_TOP) {
+			int digits = dialogType < Y_BOTTOM ? xDigits : yDigits;
+			gd.addNumericField(HEADINGS[dialogType], currentMinMax[dialogType - X_LEFT], digits, 6, "*");
+		}
+
+		if (dialogType == AXIS_OPTIONS || dialogType == X_AXIS || dialogType == Y_AXIS) {
+			int flags = plot.getFlags();
+			final String[] labels = new String[] {" Draw Grid", " Major Ticks", " Minor Ticks", " Ticks if Logarithmic", " Numbers"};
+			final int[] xFlags = new int[] {Plot.X_GRID, Plot.X_TICKS, Plot.X_MINOR_TICKS, Plot.X_LOG_TICKS, Plot.X_NUMBERS};
+			int rows = xFlags.length;
+			int columns = dialogType == AXIS_OPTIONS ? 2 : 1;
+			String[] allLabels = new String[rows*columns];
+			boolean[] defaultValues = new boolean[rows*columns];
+			String[] headings = dialogType == AXIS_OPTIONS ? new String[]{"X Axis", "Y Axis"} : null;
+			int i=0;
+			for (int l=0; l<xFlags.length; l++) {
+				String label = labels[l];
+				boolean xFlag = getFlag(flags, xFlags[l]);
+				boolean yFlag = getFlag(flags, xFlags[l]<<1); //y flags are shifted up one bit
+				if (dialogType == AXIS_OPTIONS || dialogType == X_AXIS) {
+					allLabels[i] = labels[l];
+					defaultValues[i++] = xFlag;
+				}
+				if (dialogType == AXIS_OPTIONS || dialogType == Y_AXIS) {
+					allLabels[i] = labels[l];
+					defaultValues[i++] = yFlag;
+				}
+			}
+			if (dialogType == X_AXIS || dialogType == Y_AXIS)
+				gd.setInsets(15, 20, 0);	//top, left, bottom
+			gd.addCheckboxGroup(rows, columns, allLabels, defaultValues, headings);
+			if (dialogType == AXIS_OPTIONS)
+				gd.setInsets(15, 0, 5);	//top, left, bottom
+
+			String plotXLabel = plot.getLabel('x');
+			String plotYLabel = plot.getLabel('y');
+			if ((plotXLabel == null || plotXLabel.equals("Distance (pixels)") || plotXLabel.equals("Distance ( )")) && lastXLabel != null)
+				plotXLabel = lastXLabel;	// suggest last dialog entry if default profile label
+			if ((plotYLabel == null  || plotYLabel.equals("Gray Value")) && lastYLabel != null)
+				plotYLabel = lastYLabel;
+			int nChars = 20;
+			if ((plotXLabel != null && plotXLabel.startsWith("{")) || (plotYLabel != null && plotYLabel.startsWith("{" ))) {
+					nChars = Math.max(nChars, plotXLabel.length());
+					nChars = Math.max(nChars, plotYLabel.length());
+			}
+			if (nChars > 80) nChars = 80;
+			//plotXLabel = plotXLabel.replace("\n", "|");  //multiline label currently no supported by Plot class
+			if (dialogType == AXIS_OPTIONS || dialogType == X_AXIS)
+				gd.addStringField("X Axis Label", plotXLabel, nChars);
+			//plotYLabel = plotYLabel.replace("\n", "|");
+			if (dialogType == AXIS_OPTIONS || dialogType == Y_AXIS)
+				gd.addStringField("Y Axis Label", plotYLabel, nChars);
+		}
+		if (dialogType == SET_RANGE || dialogType == X_AXIS || dialogType == Y_AXIS) {
+			Font smallFont = IJ.font10;
+			gd.setInsets(10, 0, 0);			//top, left, bottom
+			gd.addMessage("*   Leave empty for automatic range", smallFont, Color.gray);
+			gd.setInsets(0, 0, 0);
+			gd.addMessage("** Requires limits > 0 and max/min > 3", smallFont, Color.gray);
+			if (dialogType == X_AXIS || dialogType == Y_AXIS) {
+				gd.setInsets(0, 0, 0);
+				gd.addMessage("    Label supports !!sub-!! and ^^superscript^^", smallFont, Color.gray);
+			}
+		}
+
+		if (dialogType == AXIS_OPTIONS) {
+			Font plotFont = (plot.currentFont != null) ? plot.currentFont : plot.defaultFont;
+			Font labelFont = plot.getFont('x');
+			if (labelFont == null) labelFont = plotFont;
+			Font numberFont = plot.getFont('f');
+			if (numberFont == null) numberFont = plotFont;
+			gd.addNumericField("Number Font Size", numberFont.getSize2D(), 1);
+			gd.addNumericField("Label Font Size", labelFont.getSize2D(), 1);
+			//gd.setInsets(0, 20, 0); // no extra space
+			gd.addToSameRow();
+			gd.addCheckbox("Bold", labelFont.isBold());
+		}
+		if (dialogType == LEGEND) {
+			String labels = plot.getDataLabels();
+			int nLines = labels.split("\n", -1).length;
+			Font legendFont = plot.getFont('l');
+			if (legendFont == null) legendFont = (plot.currentFont != null) ? plot.currentFont : plot.defaultFont;
+			int lFlags = plot.getObjectFlags('l');
+			if (lFlags != -1) { //if we have a legend already
+				for (int i=0; i<LEGEND_POSITION_N.length; i++)  //determine the position option from the flags
+					if ((lFlags & Plot.LEGEND_POSITION_MASK) == LEGEND_POSITION_N[i]) {
+						legendPosNumber = i;
+						break;
+					}
+				transparentBackground = getFlag(lFlags, Plot.LEGEND_TRANSPARENT);
+				bottomUp = getFlag(lFlags, Plot.LEGEND_BOTTOM_UP);
+			}
+			gd.addMessage("Enter Labels for the datasets, one per line.\n");
+				
+			Font smallFont = IJ.font10;
+			gd.setInsets(0, 20, 0);			//top, left, bottom
+			String msg = "Prepend index plus dual underscore (e.g. '1__MyLabel' )\nto control legend order and to hide non-indexed labels";
+			gd.addMessage(msg, smallFont, Color.darkGray);
+			gd.setInsets(0, 0, 0);
+
+			gd.addTextAreas(labels, null, Math.min(nLines+1, 20), 40);
+			gd.addChoice("Legend position", LEGEND_POSITIONS, LEGEND_POSITIONS[legendPosNumber]);
+			gd.addNumericField("Font Size", legendFont.getSize2D(), 1);
+			gd.addCheckbox("Transparent background", transparentBackground);
+			gd.addCheckbox("Bottom-to-top", bottomUp);
+		}
+		if (dialogType == TEMPLATE) {
+			int[] idList = WindowManager.getIDList();			//create list of plots to use as template
+			int[] plotIdList = new int[idList.length];
+			templatePlots = new Plot[idList.length];
+			int nPlots = 0;
+			for (int id : idList) {
+				ImagePlus imp = WindowManager.getImage(id);
+				if (imp == null) continue;
+				Plot impPlot = (Plot)(imp.getProperty(Plot.PROPERTY_KEY));
+				if (impPlot != null && impPlot != this.plot) {
+					templatePlots[nPlots] = impPlot;
+					plotIdList[nPlots++] = id;
+				}
+			}
+			if (nPlots == 0) {
+				IJ.error("No plot to use as template");
+				return false;
+			}
+			String[] plotImpTitles = new String[nPlots];
+			int defaultTemplateIndex = 0;
+			for (int i=0; i<nPlots; i++) {
+				ImagePlus imp = WindowManager.getImage(plotIdList[i]);
+				plotImpTitles[i] = imp==null ? "" : imp.getTitle();
+				if (imp.getID() == templateID) defaultTemplateIndex = i;
+			}
+			gd.addChoice("Template Plot", plotImpTitles, plotImpTitles[defaultTemplateIndex]);
+			gd.setInsets(10, 0, 0);			//top, left, bottom
+			gd.addMessage("Copy From Template:");
+			gd.setInsets(5, 20, 0);			//top, left, bottom
+			if (lastTemplateFlags == 0) lastTemplateFlags = Plot.COPY_AXIS_STYLE|Plot.COPY_CONTENTS_STYLE;
+			for (int i=0; i<TEMPLATE_FLAGS.length; i++) {
+				boolean flag = getFlag(lastTemplateFlags, TEMPLATE_FLAGS[i]);
+				gd.addCheckbox(TEMPLATE_FLAG_NAMES[i], flag);
+			}
+		}
+		// Add a button to access another dialog that might be also desired
+		if (dialogType >= X_LEFT && dialogType <= Y_TOP)
+			gd.enableYesNoCancel("OK", "Set All Limits...");
+		else if (dialogType == AXIS_OPTIONS)
+			gd.enableYesNoCancel("OK", "Set Range...");
+		else if (dialogType == SET_RANGE)
+			gd.enableYesNoCancel("OK", "Set Axis Options...");
+		return true;
+	} //setupDialog
+
+	/** This method is called when the user changes something in the dialog. Note that the 'if's for reading
+	 *  the fields must be exactly the same as those for setting up the fields in 'setupDialog' (fields must be
+	 *  also read in the same sequence). */
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (dialogShowing && e==null)
+			return true;	//gets called with e=null upon OK; ignore this
+		boolean livePlot = plot.plotMaker != null;
+
+		if (dialogType == SET_RANGE || dialogType == X_AXIS) {
+			double[] currentMinMax = plot.getLimits();
+			double linXMin = gd.getNextNumber();
+			//if (gd.invalidNumber())
+				//linXMin = Double.NaN;
+			double linXMax = gd.getNextNumber();
+			//if (gd.invalidNumber())
+				//linXMax = Double.NaN;
+			if (linXMin == linXMax) return false;
+			if (!minMaxSaved) {
+				plot.saveMinMax();		//save for 'Previous Range' in plot menu
+				minMaxSaved = true;
+			}
+			if (livePlot)
+				plot.templateFlags = setFlag(plot.templateFlags, Plot.X_RANGE, gd.getNextBoolean());
+			boolean xLog = gd.getNextBoolean();
+			plot.setAxisXLog(xLog);
+			plot.setLimitsNoUpdate(linXMin, linXMax, currentMinMax[2], currentMinMax[3]);
+			currentMinMax = plot.getLimits();
+			enableDisableLogCheckbox(xLogCheckbox, currentMinMax[0], currentMinMax[1]);
+		}
+		if (dialogType == SET_RANGE || dialogType == Y_AXIS) {
+			double[] currentMinMax = plot.getLimits();
+			double linYMin = gd.getNextNumber();
+			//if (gd.invalidNumber())
+				//linYMin = Double.NaN;
+			double linYMax = gd.getNextNumber();
+			//if (gd.invalidNumber())
+				//linYMax = Double.NaN;
+			if (linYMin == linYMax) return false;
+			if (!minMaxSaved) {
+				plot.saveMinMax();		//save for 'Previous Range' in plot menu
+				minMaxSaved = true;
+			}
+
+			if (livePlot)
+				plot.templateFlags = setFlag(plot.templateFlags, Plot.Y_RANGE, gd.getNextBoolean());
+			boolean yLog = gd.getNextBoolean();
+			plot.setAxisYLog(yLog);
+			plot.setLimitsNoUpdate(currentMinMax[0], currentMinMax[1], linYMin, linYMax);
+			currentMinMax = plot.getLimits();
+			enableDisableLogCheckbox(yLogCheckbox, currentMinMax[2], currentMinMax[3]);
+		}
+		if (dialogType >= X_LEFT && dialogType <= Y_TOP) {
+			double newLimit = gd.getNextNumber();
+			double[] minMaxCopy = (double[])(plot.getLimits().clone());
+			minMaxCopy[dialogType - X_LEFT] = newLimit;
+			plot.setLimitsNoUpdate(minMaxCopy[0], minMaxCopy[1], minMaxCopy[2], minMaxCopy[3]);
+		}
+
+		if (dialogType == AXIS_OPTIONS || dialogType == X_AXIS || dialogType == Y_AXIS) {
+			final int[] xFlags = new int[] {Plot.X_GRID, Plot.X_TICKS, Plot.X_MINOR_TICKS, Plot.X_LOG_TICKS, Plot.X_NUMBERS};
+			int rows = xFlags.length;
+			int columns = dialogType == AXIS_OPTIONS ? 2 : 1;
+			int flags = 0;
+			if (dialogType == X_AXIS)
+				flags = plot.getFlags() & 0xaaaaaaaa; //keep y flags, i.e., odd bits
+			if (dialogType == Y_AXIS)
+				flags = plot.getFlags() & 0x55555555; //keep x flags, i.e., even bits
+			for (int l=0; l<xFlags.length; l++) {
+				if (dialogType == AXIS_OPTIONS || dialogType == X_AXIS)
+					if (gd.getNextBoolean()) flags |= xFlags[l];
+				if (dialogType == AXIS_OPTIONS || dialogType == Y_AXIS)
+					if (gd.getNextBoolean()) flags |= xFlags[l]<<1; //y flags are shifted up one bit;
+			}
+			plot.setFormatFlags(flags);
+
+			String xAxisLabel = plot.getLabel('x');
+			String yAxisLabel = plot.getLabel('y');
+			if (dialogType == AXIS_OPTIONS || dialogType == X_AXIS) {
+				xAxisLabel = gd.getNextString();
+				//xAxisLabel = xAxisLabel.replace("|", "\n");	//multiline label currently not supported by Plot class
+			}
+			if (dialogType == AXIS_OPTIONS || dialogType == Y_AXIS) {
+				yAxisLabel = gd.getNextString();
+				//yAxisLabel = yAxisLabel.replace("|", "\n");
+			}
+			plot.setXYLabels(xAxisLabel, yAxisLabel);
+		}
+		if (dialogType == AXIS_OPTIONS) {
+			Font plotFont = (plot.currentFont != null) ? plot.currentFont : plot.defaultFont;
+			Font labelFont = plot.getFont('x');
+			if (labelFont == null) labelFont = plotFont;
+			Font numberFont = plot.getFont('f');
+			if (numberFont == null) numberFont = plotFont;
+
+			float numberFontSize = (float)gd.getNextNumber();
+			if (gd.invalidNumber()) numberFontSize = numberFont.getSize2D();
+			if (numberFontSize < 9)  numberFontSize = 9f;
+			if (numberFontSize > 24) numberFontSize = 24f;
+			float labelFontSize = (float)gd.getNextNumber();
+			if (gd.invalidNumber()) labelFontSize = labelFont.getSize2D();
+			boolean axisLabelBold = gd.getNextBoolean();
+			plot.setFont('f', numberFont.deriveFont(numberFont.getStyle(), numberFontSize));
+			plot.setAxisLabelFont(axisLabelBold ? Font.BOLD : Font.PLAIN, labelFontSize);
+			Font smallFont = new Font("SansSerif", Font.PLAIN, (int)(10*Prefs.getGuiScale()));
+			gd.addMessage("Labels support !!sub-!! and ^^superscript^^", smallFont, Color.gray);
+		}
+		if (dialogType == LEGEND) {
+			Font legendFont = plot.getFont('l');
+			if (legendFont == null) legendFont = (plot.currentFont != null) ? plot.currentFont : plot.defaultFont;
+
+			String labels = gd.getNextText();
+			legendPosNumber = gd.getNextChoiceIndex();
+			int lFlags = LEGEND_POSITION_N[legendPosNumber];
+			float legendFontSize = (float)gd.getNextNumber();
+			transparentBackground = gd.getNextBoolean();
+			bottomUp = gd.getNextBoolean();
+			if (bottomUp)
+				lFlags |= Plot.LEGEND_BOTTOM_UP;
+			if (transparentBackground)
+				lFlags |= Plot.LEGEND_TRANSPARENT;
+			plot.setColor(Color.black);
+			plot.setLineWidth(1);
+			plot.setLegend(labels, lFlags);
+			plot.setFont('l', legendFont.deriveFont(legendFont.getStyle(), legendFontSize));
+		}
+		if (dialogType == TEMPLATE) {
+			Plot templatePlot = templatePlots[gd.getNextChoiceIndex()];
+			ImagePlus imp = templatePlot.getImagePlus();
+			if (imp != null) templateID = imp.getID();	//remember for next time
+			int templateFlags = 0;
+			for (int i=0; i<TEMPLATE_FLAGS.length; i++)
+				if (gd.getNextBoolean())
+					templateFlags |= TEMPLATE_FLAGS[i];
+			plot.restorePlotProperties();
+			plot.restorePlotObjects();
+			plot.useTemplate(templatePlot, templateFlags);
+		}
+
+		plot.updateImage();
+		return true;
+	} //dialogItemChanged
+
+	/** Macro recording */
+	private void record() {
+		if (Recorder.scriptMode())
+			Recorder.recordCall("//plot = IJ.getImage().getProperty(Plot.PROPERTY_KEY);");
+		String plotDot = Recorder.scriptMode() ? "plot." : "Plot.";
+
+		if (dialogType == SET_RANGE || dialogType == X_AXIS)
+			Recorder.recordString(plotDot+(Recorder.scriptMode() ? "setAxisXLog(" : "setLogScaleX(")+plot.hasFlag(Plot.X_LOG_NUMBERS)+");\n");
+		if (dialogType == SET_RANGE || dialogType == Y_AXIS)
+			Recorder.recordString(plotDot+(Recorder.scriptMode() ? "setAxisYLog(" : "setLogScaleY(")+plot.hasFlag(Plot.Y_LOG_NUMBERS)+");\n");
+		if (dialogType == SET_RANGE || dialogType == X_AXIS || dialogType == Y_AXIS) {
+			double[] currentMinMax = plot.getLimits();
+			int xDigits = plot.logXAxis ? -2 : Plot.getDigits(currentMinMax[0], currentMinMax[1], 0.005*Math.abs(currentMinMax[1]-currentMinMax[0]), 6, 0);
+			int yDigits = plot.logYAxis ? -2 : Plot.getDigits(currentMinMax[2], currentMinMax[3], 0.005*Math.abs(currentMinMax[3]-currentMinMax[2]), 6, 0);
+			Recorder.recordString(plotDot+"setLimits("+IJ.d2s(currentMinMax[0],xDigits)+","+IJ.d2s(currentMinMax[1],xDigits)+
+						","+IJ.d2s(currentMinMax[2],yDigits)+","+IJ.d2s(currentMinMax[3],yDigits)+");\n");
+		}
+		if (dialogType == AXIS_OPTIONS || dialogType == X_AXIS || dialogType == Y_AXIS) {
+			int flags = plot.getFlags();
+			String xAxisLabel = Recorder.fixString(plot.getLabel('x'));
+			String yAxisLabel = Recorder.fixString(plot.getLabel('y'));
+			Font labelFont = plot.getFont('x');
+			Font numberFont = plot.getFont('f');
+			if (labelFont != null) {
+				if (Recorder.scriptMode())
+					Recorder.recordString("plot.setAxisLabelFont("+(labelFont.isBold() ? "Font.BOLD," : "Font.PLAIN,")+IJ.d2s(labelFont.getSize2D(),1)+");\n");
+				else
+					Recorder.recordString("Plot.setAxisLabelSize("+IJ.d2s(labelFont.getSize2D(),1)+", \""+(labelFont.isBold() ? "bold" : "plain")+"\");\n");
+			}
+			if (numberFont != null)
+				Recorder.recordString(plotDot+(Recorder.scriptMode() ? "setFont(-1, " : "setFontSize(")+IJ.d2s(numberFont.getSize2D(),1)+");\n");
+			Recorder.recordString(plotDot+"setXYLabels(\""+xAxisLabel+"\", \""+yAxisLabel+"\");\n");
+			Recorder.recordString(plotDot+"setFormatFlags("+(Recorder.scriptMode() ? "0x"+Integer.toHexString(flags) : '\"'+Integer.toString(flags,2)+'\"')+ ");\n");
+		}
+		if (dialogType == LEGEND) {
+			String labels = Recorder.fixString(plot.getDataLabels());
+			int lFlags = plot.getObjectFlags('l');
+			if (Recorder.scriptMode()) {
+				Recorder.recordCall("plot.setColor(Color.black);");
+				Recorder.recordCall("plot.setLineWidth(1);");
+				Recorder.recordCall("plot.addLegend(\""+labels+"\", 0x"+Integer.toHexString(lFlags)+");");
+			} else {
+				String options = LEGEND_POSITIONS[legendPosNumber];
+				if (getFlag(lFlags, Plot.LEGEND_BOTTOM_UP))   options+=" Bottom-To-Top";
+				if (getFlag(lFlags, Plot.LEGEND_TRANSPARENT)) options+=" Transparent";
+				Recorder.recordString("Plot.addLegend(\""+labels+"\", \""+options+"\");\n");
+			}
+		}
+
+		if (Recorder.scriptMode())
+			Recorder.recordCall("plot.update();");
+	}
+
+	/** The dialog for "Make High Resolution Plot"; it has no preview*/
+	private void doHighResolutionDialog(Frame parent) {
+		GenericDialog gd = parent == null ? new GenericDialog(HEADINGS[dialogType]) :
+				new GenericDialog(HEADINGS[dialogType], parent);
+		String title = plot.getTitle();
+		if (title.toLowerCase().endsWith(".tif") || title.toLowerCase().endsWith(".zip"))
+			title = title.substring(0, title.length()-4);
+		title += "_HiRes";
+		title = WindowManager.makeUniqueName(title);
+		gd.addStringField("Title: ", title, 20);
+		gd.addNumericField("Scale factor", hiResFactor, 1);
+		gd.addCheckbox("Disable anti-aliased text", !hiResAntiAliased);
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		title = gd.getNextString();
+		double scale = gd.getNextNumber();
+		if (!gd.invalidNumber() && scale>0) //more range checking is done in Plot.setScale
+			hiResFactor = (float)scale;
+		hiResAntiAliased = !gd.getNextBoolean();
+		final ImagePlus hiresImp = plot.makeHighResolution(title, hiResFactor, hiResAntiAliased, /*showIt=*/true);
+		/** The following command is needed to have the high-resolution plot as front window. Otherwise, as the
+		 *	dialog is owned by the original PlotWindow, the WindowManager will see the original plot as active,
+		 *	but the user interface will show the high-res plot as foreground window */
+		EventQueue.invokeLater(new Runnable() {public void run() {IJ.selectWindow(hiresImp.getID());}});
+
+		if (Recorder.record) {
+			if (Recorder.scriptMode()) {
+				Recorder.recordCall("plot.makeHighResolution(\""+title+"\","+hiResFactor+","+hiResAntiAliased+",true);");
+			} else {
+				String options = !hiResAntiAliased ? "disable" : "";
+				if (options.length() > 0)
+					options = ",\""+options+"\"";
+				Recorder.recordString("Plot.makeHighResolution(\""+title+"\","+hiResFactor+options+");\n");
+			}
+		}
+	}
+
+	/** Disables switching on a checkbox for log range if the axis limits do not allow it.
+	 *  The checkbox can be always switched off. */
+	void enableDisableLogCheckbox(Checkbox checkbox, double limit1, double limit2) {
+		boolean logPossible = limit1 > 0 && limit2 > 0 && (limit1 > 3*limit2 || limit2 > 3*limit1);
+		checkbox.setEnabled(logPossible);
+	}
+
+
+	boolean getFlag(int flags, int bitMask) {
+		return (flags&bitMask) != 0;
+	}
+
+	int setFlag(int flags, int bitMask, boolean state) {
+		flags &= ~bitMask;
+		if (state) flags |= bitMask;
+		return flags;
+	}
+
+	Checkbox lastCheckboxAdded(GenericDialog gd) {
+		Vector checkboxes = gd.getCheckboxes();
+		return (Checkbox)(checkboxes.get(checkboxes.size() - 1));
+	}
+
+}
diff --git a/src/ij/gui/PlotMaker.java b/src/ij/gui/PlotMaker.java
new file mode 100644
index 0000000..ddaef8a
--- /dev/null
+++ b/src/ij/gui/PlotMaker.java
@@ -0,0 +1,15 @@
+package ij.gui;
+import ij.ImagePlus;
+
+/** Plugins that generate "Live" profile plots (Profiler and ZAxisProfiler)
+	displayed in PlotWindows implement this interface. */
+public interface PlotMaker {
+
+   /** Returns a profile plot. */
+   public Plot getPlot();
+   
+   /** Returns the ImagePlus used to generate the profile plots. */
+   public ImagePlus getSourceImage();
+
+}
+
diff --git a/src/ij/gui/PlotVirtualStack.java b/src/ij/gui/PlotVirtualStack.java
new file mode 100644
index 0000000..6ef864a
--- /dev/null
+++ b/src/ij/gui/PlotVirtualStack.java
@@ -0,0 +1,85 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import java.util.*;
+import java.io.*;
+
+/** This is a virtual stack of frozen plots. */
+public class PlotVirtualStack extends VirtualStack {
+	private Vector plots = new Vector(50);
+	private int bitDepth = 8;
+	
+	public PlotVirtualStack(int width, int height) {
+		super(width, height);
+		this.bitDepth = bitDepth;
+	}
+	
+	/** Adds a plot to the end of the stack. */
+	public void addPlot(Plot plot) {
+		plots.add(plot.toByteArray());
+		if (plot.isColored())
+			bitDepth = 24;
+	}
+	   
+   /** Returns the pixel array for the specified slice, were 1<=n<=nslices. */
+	public Object getPixels(int n) {
+		ImageProcessor ip = getProcessor(n);
+		if (ip!=null)
+			return ip.getPixels();
+		else
+			return null;
+	}		
+	
+	/** Returns an ImageProcessor for the specified slice,
+		were 1<=n<=nslices. Returns null if the stack is empty. */
+	public ImageProcessor getProcessor(int n) {
+		byte[] bytes = (byte[])plots.get(n-1);
+		if (bytes!=null) {
+			try {
+				Plot plot = new Plot(null, new ByteArrayInputStream(bytes));
+				ImageProcessor ip = plot.getProcessor();
+				if (bitDepth==24)
+					ip = ip.convertToRGB();
+				else if (bitDepth==8)
+					ip =  ip.convertToByte(false);
+				return ip;
+			} catch (Exception e) {
+				IJ.handleException(e);
+			}
+		}
+		return null;
+	}
+	 
+	 /** Returns the number of slices in this stack. */
+	public int getSize() {
+		return plots.size();
+	}
+		
+	/** Returns either 24 (RGB) or 8 (grayscale). */
+	public int getBitDepth() {
+		return bitDepth;
+	}
+		
+	public void setBitDepth(int bitDepth) {
+		this.bitDepth = bitDepth;
+	}
+
+	public String getSliceLabel(int n) {
+		return null;
+	}
+
+	public void setPixels(Object pixels, int n) {
+	}
+	
+	/** Deletes the specified slice, were 1<=n<=nslices. */
+	public void deleteSlice(int n) {
+		if (n<1 || n>plots.size())
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		if (plots.size()<1)
+			return;			
+		plots.remove(n-1);
+	}
+
+
+} // PlotVirtualStack
+
diff --git a/src/ij/gui/PlotWindow.java b/src/ij/gui/PlotWindow.java
new file mode 100644
index 0000000..b411f01
--- /dev/null
+++ b/src/ij/gui/PlotWindow.java
@@ -0,0 +1,917 @@
+package ij.gui;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.awt.datatransfer.*;
+import java.util.*;
+import ij.*;
+import ij.process.*;
+import ij.util.*;
+import ij.text.TextWindow;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.filter.PlugInFilterRunner;
+import ij.measure.*;
+import ij.io.SaveDialog;
+
+/** This class implements the Analyze/Plot Profile command.
+* @author Michael Schmid
+* @author Wayne Rasband
+*/
+public class PlotWindow extends ImageWindow implements ActionListener, ItemListener,
+	ClipboardOwner, ImageListener, RoiListener, Runnable {
+
+	private static final int WIDTH = 600;
+	private static final int HEIGHT = 340;
+	private static final int FONT_SIZE = 14;
+	private static final String PREFS_WIDTH = "pp.width";
+	private static final String PREFS_HEIGHT = "pp.height";
+	private static final String PREFS_FONT_SIZE = "pp.fontsize";
+
+	/** @deprecated */
+	public static final int CIRCLE = Plot.CIRCLE;
+	/** @deprecated */
+	public static final int X = Plot.X;
+	/** @deprecated */
+	public static final int BOX = Plot.BOX;
+	/** @deprecated */
+	public static final int TRIANGLE = Plot.TRIANGLE;
+	/** @deprecated */
+	public static final int CROSS = Plot.CROSS;
+	/** @deprecated */
+	public static final int LINE = Plot.LINE;
+	/** Write first X column when listing or saving. */
+	public static boolean saveXValues = true;
+	/** Automatically close window after saving values. To set, use Edit/Options/Plots. */
+	public static boolean autoClose;
+	/** Display the XY coordinates in a separate window. To set, use Edit/Options/Plots. */
+	public static boolean listValues;
+	/** Interpolate line profiles. To set, use Edit/Options/Plots or setOption("InterpolateLines",boolean). */
+	public static boolean interpolate = true;
+	// default values for new installations; values will be then saved in prefs
+	private static int defaultFontSize = Prefs.getInt(PREFS_FONT_SIZE, FONT_SIZE);
+	/** The width of the plot (without frame) in pixels. */
+	public static int plotWidth = WIDTH;
+	/** The height of the plot in pixels. */
+	public static int plotHeight = HEIGHT;
+	/** The plot text size, can be overridden by Plot.setFont, Plot.setFontSize, Plot.setXLabelFont etc. */
+	public static int fontSize = defaultFontSize;
+	/** Have axes with no grid lines. If both noGridLines and noTicks are true,
+	 *	only min&max value of the axes are given */
+	public static boolean noGridLines;
+	/** Have axes with no ticks. If both noGridLines and noTicks are true,
+	 *	only min&max value of the axes are given */
+	public static boolean noTicks;
+
+	private static final String OPTIONS = "pp.options";
+	private static final int SAVE_X_VALUES = 1;
+	private static final int AUTO_CLOSE = 2;
+	private static final int LIST_VALUES = 4;
+	private static final int INTERPOLATE = 8;
+	private static final int NO_GRID_LINES = 16;
+	private static final int NO_TICKS = 32;
+	private static String moreButtonLabel = "More "+'\u00bb';
+	private static String dataButtonLabel = "Data "+'\u00bb';
+
+	boolean wasActivated;			// true after window has been activated once, needed by PlotCanvas
+
+	private Button list, data, more, live;
+	private PopupMenu dataPopupMenu, morePopupMenu;
+	private static final int NUM_MENU_ITEMS = 20; //how many menu items we have in total
+	private MenuItem[] menuItems = new MenuItem[NUM_MENU_ITEMS];
+	private Label statusLabel;
+	private String userStatusText;
+	private static String defaultDirectory = null;
+	private static int options;
+	private int defaultDigits = -1;
+	private int markSize = 5;
+	private static Plot staticPlot;
+	private Plot plot;
+
+	private PlotMaker plotMaker;
+	private ImagePlus srcImp;		// the source image for live plotting
+	private Thread bgThread;		// thread for plotting (in the background)
+	private boolean doUpdate;		// tells the background thread to update
+
+	private Roi[] rangeArrowRois;	// the overlays (arrows etc) for changing the range. Note: #10-15 must correspond to PlotDialog.dialogType!
+	private boolean rangeArrowsVisible;
+	private int activeRangeArrow = -1;
+	private static Color inactiveRangeArrowColor = Color.GRAY;
+	private static Color inactiveRangeRectColor = new Color(0x20404040, true); //transparent gray
+	private static Color activeRangeArrowColor = Color.RED;
+	private static Color activeRangeRectColor = new Color(0x18ff0000, true); //transparent red
+
+	// static initializer
+	static {
+		options = Prefs.getInt(OPTIONS, SAVE_X_VALUES);
+		autoClose = (options&AUTO_CLOSE)!=0;
+		plotWidth = Prefs.getInt(PREFS_WIDTH, WIDTH);
+		plotHeight = Prefs.getInt(PREFS_HEIGHT, HEIGHT);
+		Dimension screen = IJ.getScreenSize();
+		if (plotWidth>screen.width && plotHeight>screen.height) {
+			plotWidth = WIDTH;
+			plotHeight = HEIGHT;
+		}
+	}
+
+	/**
+	* @deprecated
+	* replaced by the Plot class.
+	*/
+	public PlotWindow(String title, String xLabel, String yLabel, float[] xValues, float[] yValues) {
+		super(createImage(title, xLabel, yLabel, xValues, yValues));
+		plot = staticPlot;
+		((PlotCanvas)getCanvas()).setPlot(plot);
+	}
+
+	/**
+	* @deprecated
+	* replaced by the Plot class.
+	*/
+	public PlotWindow(String title, String xLabel, String yLabel, double[] xValues, double[] yValues) {
+		this(title, xLabel, yLabel, Tools.toFloat(xValues), Tools.toFloat(yValues));
+	}
+
+	/** Creates a PlotWindow from a given ImagePlus with a Plot object.
+	 *  (called when reading an ImagePlus with an associated plot from a file) */
+	public PlotWindow(ImagePlus imp, Plot plot) {
+		super(imp);
+		((PlotCanvas)getCanvas()).setPlot(plot);
+		this.plot = plot;
+		draw();
+	}
+
+	/** Creates a PlotWindow from a Plot object. */
+	PlotWindow(Plot plot) {
+		super(plot.getImagePlus());
+		((PlotCanvas)getCanvas()).setPlot(plot);
+		this.plot = plot;
+		draw();
+	}
+
+	/** Called by the constructor to generate the image the plot will be drawn on.
+		This is a static method because constructors cannot call instance methods. */
+	static ImagePlus createImage(String title, String xLabel, String yLabel, float[] xValues, float[] yValues) {
+		staticPlot = new Plot(title, xLabel, yLabel, xValues, yValues);
+		return new ImagePlus(title, staticPlot.getBlankProcessor());
+	}
+
+	/** Sets the x-axis and y-axis range.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void setLimits(double xMin, double xMax, double yMin, double yMax) {
+		plot.setLimits(xMin, xMax, yMin, yMax);
+	}
+
+	/** Adds a set of points to the plot or adds a curve if shape is set to LINE.
+	 *	Note that there are more options available by using the methods of the Plot class instead.
+	 *  @param x			the x-coodinates
+	 *  @param y			the y-coodinates
+	 *  @param shape		Plot.CIRCLE, X, BOX, TRIANGLE, CROSS, LINE etc.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void addPoints(float[] x, float[] y, int shape) {
+		plot.addPoints(x, y, shape);
+	}
+
+	/** Adds a set of points to the plot using double arrays.
+	 *	Must be called before the plot is displayed.
+	 *	Note that there are more options available by using the methods of the Plot class instead.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void addPoints(double[] x, double[] y, int shape) {
+		addPoints(Tools.toFloat(x), Tools.toFloat(y), shape);
+	}
+
+	/** Adds vertical error bars to the plot.
+	 *	Must be called before the plot is displayed.
+	 *	Note that there are more options available by using the methods of the Plot class instead.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void addErrorBars(float[] errorBars) {
+		plot.addErrorBars(errorBars);
+	}
+
+	/** Draws a label.
+	 *	Note that there are more options available by using the methods of the Plot class instead.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void addLabel(double x, double y, String label) {
+		plot.addLabel(x, y, label);
+	}
+
+	/** Changes the drawing color. The frame and labels are
+	 *	always drawn in black.
+	 *	Must be called before the plot is displayed.
+	 *	Note that there are more options available by using the methods of the Plot class instead.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void setColor(Color c) {
+		plot.setColor(c);
+	}
+
+	/** Changes the line width.
+	 *	Must be called before the plot is displayed.
+	 *	Note that there are more options available by using the methods of the Plot class instead.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void setLineWidth(int lineWidth) {
+		plot.setLineWidth(lineWidth);
+	}
+
+	/** Changes the font.
+	 *	Must be called before the plot is displayed.
+	 *	Note that there are more options available by using the methods of the Plot class instead.
+	 *  @deprecated use the corresponding method of the Plot class */
+	public void changeFont(Font font) {
+		plot.changeFont(font);
+	}
+
+	/** Displays the plot. */
+	public void draw() {
+		Panel bottomPanel = new Panel();
+		int hgap = IJ.isMacOSX()?1:5;
+
+		list = new Button(" List ");
+		list.addActionListener(this);
+		bottomPanel.add(list);
+		bottomPanel.setLayout(new FlowLayout(FlowLayout.RIGHT,hgap,0));
+		data = new Button(dataButtonLabel);
+		data.addActionListener(this);
+		bottomPanel.add(data);
+		more = new Button(moreButtonLabel);
+		more.addActionListener(this);
+		bottomPanel.add(more);
+		if (plot!=null && plot.getPlotMaker()!=null) {
+			live = new Button("Live");
+			live.addActionListener(this);
+			bottomPanel.add(live);
+		}
+		statusLabel = new Label();
+		statusLabel.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		statusLabel.setBackground(new Color(220, 220, 220));
+		bottomPanel.add(statusLabel);
+		add(bottomPanel);
+		data.add(getDataPopupMenu());
+		more.add(getMorePopupMenu());
+		plot.draw();
+		LayoutManager lm = getLayout();
+		if (lm instanceof ImageLayout)
+			((ImageLayout)lm).ignoreNonImageWidths(true);  //don't expand size to make the panel fit
+		GUI.scale(bottomPanel);
+		maximizeCoordinatesLabelWidth();
+		pack();
+
+		ImageProcessor ip = plot.getProcessor();
+		boolean ipIsColor = ip instanceof ColorProcessor;
+		boolean impIsColor = imp.getProcessor() instanceof ColorProcessor;
+		if (ipIsColor != impIsColor)
+			imp.setProcessor(null, ip);
+		else
+			imp.updateAndDraw();
+		if (listValues)
+			showList(/*useLabels=*/false);
+		else
+			ic.requestFocus();	//have focus on the canvas, not the button, so that pressing the space bar allows panning
+	}
+
+	/** Sets the Plot object shown in this PlotWindow. Does not update the window. */
+	public void setPlot(Plot plot) {
+		this.plot = plot;
+		((PlotCanvas)getCanvas()).setPlot(plot);
+	}
+
+	/** Releases the resources used by this PlotWindow */
+	public void dispose() {
+		if (plot!=null)
+			plot.dispose();
+		disableLivePlot();
+		plot = null;
+		plotMaker = null;
+		srcImp = null;
+		super.dispose();
+	}
+
+	/** Called when the window is activated (WindowListener)
+	 *  Window layout is finished at latest a few millisec after windowActivated, then the
+	 *  'wasActivated' boolean is set to tell the ImageCanvas that resize events should
+	 *  lead to resizing the canvas (before, creating the layout can lead to resize events)*/
+	public void windowActivated(WindowEvent e) {
+		super.windowActivated(e);
+		if (!wasActivated) {
+			new Thread(new Runnable() {
+				public void run() {
+					IJ.wait(50);  //sometimes, window layout is done only a few millisec after windowActivated
+					wasActivated = true;
+				}
+			}).start();
+		}
+	}
+
+	/** Called when the canvas is resized */
+	void canvasResized() {
+		if (plot == null) return;
+		/*Dimension d1 = getExtraSize();
+		Dimension d2 = plot.getMinimumSize();
+		setMinimumSize(new Dimension(d1.width + d2.width, d1.height + d2.height));*/
+		maximizeCoordinatesLabelWidth();
+	}
+
+	/** Maximizes the width for the coordinate&status readout field and its parent bottomPanel */
+	void maximizeCoordinatesLabelWidth() {
+		Insets insets = getInsets();                    //by default, left & right insets are 0 anyhow
+		Component parent = statusLabel.getParent();     //the bottomPanel, has insets of 0
+		if (!parent.isValid()) parent.validate();
+		int cWidth = getWidth() - 2*HGAP - statusLabel.getX() - insets.left - insets.right;
+		int cHeight = statusLabel.getPreferredSize().height;
+		statusLabel.setPreferredSize(new Dimension(cWidth, cHeight));
+		parent.setSize(getWidth() - 2*HGAP, parent.getHeight());
+	}
+
+	/** Shows the text in the coordinate&status readout field at the bottom.
+	 *  This text may get temporarily replaced for 'tooltips' (mouse over range arrows etc.).
+	 *  Call with a null argument to enable coordinate readout again. */
+	public void showStatus(String text) {
+		userStatusText = text;
+		if (statusLabel != null)
+			statusLabel.setText(text == null ? "" : text);
+	}
+
+	/** Names for popupMenu items. Update NUM_MENU_ITEMS at the top when adding new ones! */
+	private static int SAVE=0, COPY=1, COPY_ALL=2, LIST_SIMPLE=3, ADD_FROM_TABLE=4, ADD_FROM_PLOT=5, ADD_FIT=6, //data menu
+			SET_RANGE=7, PREV_RANGE=8, RESET_RANGE=9, FIT_RANGE=10,  //the rest is in the more menu
+			ZOOM_SELECTION=11, AXIS_OPTIONS=12, LEGEND=13, STYLE=14, TEMPLATE=15, RESET_PLOT=16,
+			FREEZE=17, HI_RESOLUTION=18, PROFILE_PLOT_OPTIONS=19;
+	//the following commands are disabled when the plot is frozen
+	private static int[] DISABLED_WHEN_FROZEN = new int[]{ADD_FROM_TABLE, ADD_FROM_PLOT, ADD_FIT,
+			SET_RANGE, PREV_RANGE, RESET_RANGE, FIT_RANGE, ZOOM_SELECTION, AXIS_OPTIONS, LEGEND, STYLE, RESET_PLOT};
+
+	/** Prepares and returns the popupMenu of the Data>> button */
+	PopupMenu getDataPopupMenu() {
+		dataPopupMenu = new PopupMenu();
+		GUI.scalePopupMenu(dataPopupMenu);
+		menuItems[SAVE] = addPopupItem(dataPopupMenu, "Save Data...");
+		menuItems[COPY] = addPopupItem(dataPopupMenu, "Copy 1st Data Set");
+		menuItems[COPY_ALL] = addPopupItem(dataPopupMenu, "Copy All Data");
+		menuItems[LIST_SIMPLE] = addPopupItem(dataPopupMenu, "List (Simple Headings)");
+		dataPopupMenu.addSeparator();
+		menuItems[ADD_FROM_TABLE] = addPopupItem(dataPopupMenu, "Add from Table...");
+		menuItems[ADD_FROM_PLOT] = addPopupItem(dataPopupMenu, "Add from Plot...");
+		menuItems[ADD_FIT] = addPopupItem(dataPopupMenu, "Add Fit...");
+		return dataPopupMenu;
+	}
+
+	/** Prepares and returns the popupMenu of the More>> button */
+	PopupMenu getMorePopupMenu() {
+		morePopupMenu = new PopupMenu();
+		GUI.scalePopupMenu(morePopupMenu);
+		menuItems[SET_RANGE] = addPopupItem(morePopupMenu, "Set Range...");
+		menuItems[PREV_RANGE] = addPopupItem(morePopupMenu, "Previous Range");
+		menuItems[RESET_RANGE] = addPopupItem(morePopupMenu, "Reset Range");
+		menuItems[FIT_RANGE] = addPopupItem(morePopupMenu, "Set Range to Fit All");
+		menuItems[ZOOM_SELECTION] = addPopupItem(morePopupMenu, "Zoom to Selection");
+		morePopupMenu.addSeparator();
+		menuItems[AXIS_OPTIONS] = addPopupItem(morePopupMenu, "Axis Options...");
+		menuItems[LEGEND] = addPopupItem(morePopupMenu, "Legend...");
+		menuItems[STYLE] = addPopupItem(morePopupMenu, "Contents Style...");
+		menuItems[TEMPLATE] = addPopupItem(morePopupMenu, "Use Template...");
+		menuItems[RESET_PLOT] = addPopupItem(morePopupMenu, "Reset Format");
+		menuItems[FREEZE] = addPopupItem(morePopupMenu, "Freeze Plot", true);
+		menuItems[HI_RESOLUTION] = addPopupItem(morePopupMenu, "High-Resolution Plot...");
+		morePopupMenu.addSeparator();
+		menuItems[PROFILE_PLOT_OPTIONS] = addPopupItem(morePopupMenu, "Plot Defaults...");
+		return morePopupMenu;
+	}
+
+	MenuItem addPopupItem(PopupMenu popupMenu, String s) {
+		return addPopupItem(popupMenu, s, false);
+	}
+
+	MenuItem addPopupItem(PopupMenu popupMenu, String s, boolean isCheckboxItem) {
+		MenuItem mi = null;
+		if (isCheckboxItem) {
+			mi = new CheckboxMenuItem(s);
+			((CheckboxMenuItem)mi).addItemListener(this);
+		} else {
+			mi = new MenuItem(s);
+			mi.addActionListener(this);
+		}
+		popupMenu.add(mi);
+		return mi;
+	}
+
+	/** Called if user has activated a button or popup menu item */
+	public void actionPerformed(ActionEvent e) {
+		try {
+		Object b = e.getSource();
+		if (b==live)
+			toggleLiveProfiling();
+		else if (b==list)
+			showList(/*useLabels=*/true);
+		else if (b==data) {
+			enableDisableMenuItems();
+			dataPopupMenu.show((Component)b, 1, 1);
+		} else if (b==more) {
+			enableDisableMenuItems();
+			morePopupMenu.show((Component)b, 1, 1);
+		} else if (b==menuItems[SAVE])
+			saveAsText();
+		else if (b==menuItems[COPY])
+			copyToClipboard(false);
+		else if (b==menuItems[COPY_ALL])
+			copyToClipboard(true);
+		else if (b==menuItems[LIST_SIMPLE])
+			showList(/*useLabels=*/false);
+		else if (b==menuItems[ADD_FROM_TABLE])
+			new PlotContentsDialog(plot, PlotContentsDialog.ADD_FROM_TABLE).showDialog(this);
+		else if (b==menuItems[ADD_FROM_PLOT])
+			new PlotContentsDialog(plot, PlotContentsDialog.ADD_FROM_PLOT).showDialog(this);
+		else if (b==menuItems[ADD_FIT])
+			new PlotContentsDialog(plot, PlotContentsDialog.ADD_FIT).showDialog(this);
+		else if (b==menuItems[ZOOM_SELECTION]) {
+			if (imp!=null && imp.getRoi()!=null && imp.getRoi().isArea())
+				plot.zoomToRect(imp.getRoi().getBounds());
+		} else if (b==menuItems[SET_RANGE])
+			new PlotDialog(plot, PlotDialog.SET_RANGE).showDialog(this);
+		else if (b==menuItems[PREV_RANGE])
+			plot.setPreviousMinMax();
+		else if (b==menuItems[RESET_RANGE])
+			plot.setLimitsToDefaults(true);
+		else if (b==menuItems[FIT_RANGE])
+			plot.setLimitsToFit(true);
+		else if (b==menuItems[AXIS_OPTIONS])
+			new PlotDialog(plot, PlotDialog.AXIS_OPTIONS).showDialog(this);
+		else if (b==menuItems[LEGEND])
+			new PlotDialog(plot, PlotDialog.LEGEND).showDialog(this);
+		else if (b==menuItems[STYLE])
+			new PlotContentsDialog(plot, PlotContentsDialog.STYLE).showDialog(this);
+		else if (b==menuItems[TEMPLATE])
+			new PlotDialog(plot, PlotDialog.TEMPLATE).showDialog(this);
+		else if (b==menuItems[RESET_PLOT]) {
+			plot.setFont(Font.PLAIN, fontSize);
+			plot.setAxisLabelFont(Font.PLAIN, fontSize);
+			plot.setFormatFlags(Plot.getDefaultFlags());
+			plot.setFrameSize(plotWidth, plotHeight); //updates the image only when size changed
+			plot.updateImage();
+		} else if (b==menuItems[HI_RESOLUTION])
+			new PlotDialog(plot, PlotDialog.HI_RESOLUTION).showDialog(this);
+		else if (b==menuItems[PROFILE_PLOT_OPTIONS])
+			IJ.doCommand("Plots...");
+		ic.requestFocus();	//have focus on the canvas, not the button, so that pressing the space bar allows panning
+		} catch (Exception ex) { IJ.handleException(ex); }
+	}
+
+	private void enableDisableMenuItems() {
+		boolean frozen = plot.isFrozen();	//prepare menu according to 'frozen' state of plot
+		((CheckboxMenuItem)menuItems[FREEZE]).setState(frozen);
+		for (int i : DISABLED_WHEN_FROZEN)
+			menuItems[i].setEnabled(!frozen);
+		if (!PlotContentsDialog.tableWindowExists())
+			menuItems[ADD_FROM_TABLE].setEnabled(false);
+		if (plot.getDataObjectDesignations().length == 0)
+			menuItems[ADD_FIT].setEnabled(false);
+	}
+
+	/** Called if the user activates/deactivates a CheckboxMenuItem */
+	public void itemStateChanged(ItemEvent e) {
+		if (e.getSource()==menuItems[FREEZE]) {
+			boolean frozen = ((CheckboxMenuItem)menuItems[FREEZE]).getState();
+			plot.setFrozen(frozen);
+		}
+	}
+
+	/**
+	 * Updates the X and Y values when the mouse is moved and, if appropriate,
+	 * shows/hides the overlay with the triangular buttons for changing the axis
+	 * range limits.
+	 * Overrides mouseMoved() in ImageWindow.
+	 *
+	 * @see ij.gui.ImageWindow#mouseMoved
+	 */
+	public void mouseMoved(int x, int y) {
+		super.mouseMoved(x, y);
+		if (plot == null)
+			return;
+		String statusText = null; //coordinate readout, status or tooltip, will be shown in coordinate&status line
+
+		//arrows and other symbols for modifying the plot range
+		if (x < plot.leftMargin || y > plot.topMargin + plot.frameHeight) {
+			if (!rangeArrowsVisible && !plot.isFrozen())
+				showRangeArrows();
+			if (activeRangeArrow < 0)       //mouse is not on one of the symbols, ignore (nothing to display)
+				{}
+			else if (activeRangeArrow < 8)  //mouse over an arrow: 0,3,4,7 for increase, 1,2,5,6 for decrease
+				statusText = ((activeRangeArrow+1)&0x02) != 0 ? "Decrease Range" : "Increase Range";
+			else if (activeRangeArrow == 8) //it's the 'R' icon
+				statusText = "Reset Range";
+			else if (activeRangeArrow == 9) //it's the 'F' icon
+				statusText = "Full Range (Fit All)";
+			else if (activeRangeArrow >= 10 &&
+					activeRangeArrow < 14)  //space between arrow-pairs for single number
+				statusText = "Set limit...";
+			else if (activeRangeArrow >= 14)
+				statusText = "Axis Range & Options...";
+			boolean repaint = false;
+			if (activeRangeArrow >= 0 && !rangeArrowRois[activeRangeArrow].contains(x, y)) {
+				rangeArrowRois[activeRangeArrow].setFillColor(
+						activeRangeArrow < 10 ? inactiveRangeArrowColor : inactiveRangeRectColor);
+				repaint = true;             //de-highlight arrow where cursor has moved out
+				activeRangeArrow = -1;
+			}
+			if (activeRangeArrow < 0) {     //no currently highlighted arrow, do we have a new one?
+				int i = getRangeArrowIndex(x, y);
+				if (i >= 0) {               //we have an arrow or symbol at cursor position
+					rangeArrowRois[i].setFillColor(
+							i < 14 ? activeRangeArrowColor : activeRangeRectColor);
+					activeRangeArrow = i;
+					repaint = true;
+				}
+			}
+			if (repaint) ic.repaint();
+		} else if (rangeArrowsVisible)
+			hideRangeArrows();
+
+		if (statusText == null)
+			statusText = userStatusText != null ? userStatusText : plot.getCoordinates(x, y);
+		if (statusLabel != null)
+			statusLabel.setText(statusText);
+	}
+
+	/** Called by PlotCanvas */
+	void mouseExited(MouseEvent e) {
+		if (rangeArrowsVisible)
+			hideRangeArrows();
+	}
+
+	/** Mouse wheel: zooms when shift or ctrl is pressed, scrolls in x if space bar down, in y otherwise. */
+	public synchronized void mouseWheelMoved(MouseWheelEvent e) {
+		if (plot.isFrozen() || !(ic instanceof PlotCanvas)) {	   //frozen plots are like normal images
+			super.mouseWheelMoved(e);
+			return;
+		}
+		int rotation = e.getWheelRotation();
+		int amount = e.getScrollAmount();
+		if (e.getX() < plot.leftMargin || e.getX() > plot.leftMargin + plot.frameWidth)//n__
+			return;
+		if (e.getY() < plot.topMargin || e.getY() > plot.topMargin + plot.frameHeight)
+			return;
+		boolean ctrl = (e.getModifiers()&Event.CTRL_MASK)!=0;
+		if (amount<1) amount=1;
+		if (rotation==0)
+			return;
+		if (ctrl||IJ.shiftKeyDown()) {
+			double zoomFactor = rotation<0 ? Math.pow(2, 0.2) : Math.pow(0.5, 0.2);
+			Point loc = ic.getCursorLoc();
+			int x = ic.screenX(loc.x);
+			int y = ic.screenY(loc.y);
+			((PlotCanvas)ic).zoom(x, y, zoomFactor);
+		} else if (IJ.spaceBarDown())
+			plot.scroll(rotation*amount*Math.max(ic.imageWidth/50, 1), 0);
+		else
+			plot.scroll(0, rotation*amount*Math.max(ic.imageHeight/50, 1));
+	}
+
+    /**
+     * Creates an overlay with triangular buttons and othr symbols for changing the axis range
+     * limits and shows it
+     */
+    void showRangeArrows() {
+        if (imp == null)
+            return;
+        hideRangeArrows(); //in case we have old arrows from a different plot size or so
+        rangeArrowRois = new Roi[4 * 2 + 2 + 4 + 2]; //4 arrows per axis, + 'Reset' and 'Fit All' icons, + 4 numerical input boxes + 2 axes
+        int i = 0;
+        int height = imp.getHeight();
+        int arrowH = plot.topMargin < 14 ? 6 : 8; //height of arrows and distance between them; base is twice that value
+        float[] yP = new float[]{height - arrowH / 2, height - 3 * arrowH / 2, height - 5 * arrowH / 2 - 0.1f};
+
+        for (float x : new float[]{plot.leftMargin, plot.leftMargin + plot.frameWidth}) { //create arrows for x axis
+            float[] x0 = new float[]{x - arrowH / 2, x - 3 * arrowH / 2 - 0.1f, x - arrowH / 2};
+            rangeArrowRois[i++] = new PolygonRoi(x0, yP, 3, Roi.POLYGON);
+            float[] x1 = new float[]{x + arrowH / 2, x + 3 * arrowH / 2 + 0.1f, x + arrowH / 2};
+            rangeArrowRois[i++] = new PolygonRoi(x1, yP, 3, Roi.POLYGON);
+        }
+        float[] xP = new float[]{arrowH / 2 - 0.1f, 3 * arrowH / 2, 5 * arrowH / 2 + 0.1f};
+        for (float y : new float[]{plot.topMargin + plot.frameHeight, plot.topMargin}) { //create arrows for y axis
+            float[] y0 = new float[]{y + arrowH / 2, y + 3 * arrowH / 2 + 0.1f, y + arrowH / 2};
+            rangeArrowRois[i++] = new PolygonRoi(xP, y0, 3, Roi.POLYGON);
+          float[] y1 = new float[]{y - arrowH / 2, y - 3 * arrowH / 2 - 0.1f, y - arrowH / 2};
+            rangeArrowRois[i++] = new PolygonRoi(xP, y1, 3, Roi.POLYGON);
+        }
+        Font theFont = new Font("SansSerif", Font.BOLD, 13);
+
+        TextRoi txtRoi = new TextRoi(1, height - 19, "\u2009R\u2009", theFont);  //thin spaces to make roi slightly wider
+        rangeArrowRois[8] = txtRoi;
+        TextRoi txtRoi2 = new TextRoi(20, height - 19, "\u2009F\u2009", theFont);
+        rangeArrowRois[9] = txtRoi2;
+
+		rangeArrowRois[10] = new Roi(plot.leftMargin - arrowH/2 + 1, height - 5 * arrowH / 2, arrowH - 2, arrowH * 2);//numerical box left
+		rangeArrowRois[11] = new Roi(plot.leftMargin + plot.frameWidth - arrowH/2 + 1, height - 5 * arrowH / 2, arrowH - 2, arrowH * 2);//numerical box right
+        rangeArrowRois[12] = new Roi(arrowH / 2, plot.topMargin + plot.frameHeight - arrowH/2 + 1, arrowH * 2, arrowH -2);//numerical box bottom
+        rangeArrowRois[13] = new Roi(arrowH / 2, plot.topMargin - arrowH/2 + 1,  arrowH * 2, arrowH - 2   );//numerical box top
+
+        int topMargin = plot.topMargin;
+        int bottomMargin = topMargin + plot.frameHeight;
+        int leftMargin = plot.leftMargin;
+        int rightMargin = plot.leftMargin + plot.frameWidth;
+        rangeArrowRois[14] = new Roi(leftMargin, bottomMargin+2,        // area to click for x axis options
+				rightMargin - leftMargin + 1, 2*arrowH);
+        rangeArrowRois[15] = new Roi(leftMargin-2*arrowH-2, topMargin,  // area to click for y axis options
+				2*arrowH, bottomMargin - topMargin + 1);
+
+        Overlay ovly = imp.getOverlay();
+        if (ovly == null)
+            ovly = new Overlay();
+        for (Roi roi : rangeArrowRois) {
+            if (roi instanceof PolygonRoi)
+                   roi.setFillColor(inactiveRangeArrowColor);
+			else if (roi instanceof TextRoi) {
+                roi.setStrokeColor(Color.WHITE);
+                roi.setFillColor(inactiveRangeArrowColor);
+            } else
+                roi.setFillColor(inactiveRangeRectColor); //transparent gray for single number boxes and axis range
+            ovly.add(roi);
+        }
+        imp.setOverlay(ovly);
+        ic.repaint();
+        rangeArrowsVisible = true;
+    }
+
+	void hideRangeArrows() {
+		if (imp == null || rangeArrowRois==null) return;
+		Overlay ovly = imp.getOverlay();
+		if (ovly == null) return;
+		for (Roi roi : rangeArrowRois)
+			ovly.remove(roi);
+		ic.repaint();
+		rangeArrowsVisible = false;
+		activeRangeArrow = -1;
+	}
+
+	/** Returns the index of the range-modifying symbol or axis at the
+	 *  cursor position x,y, or -1 of none.
+	 *  Index numbers for arrows start with 0 at the 'down' arrow of the
+	 *  lower side of the x axis and end with 7 the up arrow at the upper
+	 *  side of the y axis. Numbers 8 & 9 are for "Reset Range" and "Fit All";
+	 *  numbers 10-13 for a dialog to set a single limit, and 14-15 for the axis options. */
+
+	int getRangeArrowIndex(int x, int y) {
+		if (!rangeArrowsVisible) return -1;
+		for (int i=0; i<rangeArrowRois.length; i++)
+			if (rangeArrowRois[i].getBounds().contains(x,y))
+				return i;
+		return -1;
+	}
+
+
+	/** Shows the data of the backing plot in a Textwindow with columns */
+	void showList(boolean useLabels){
+		ResultsTable rt = plot.getResultsTable(saveXValues, useLabels);
+		if (rt==null) return;
+		rt.show("Plot Values");
+		if (autoClose) {
+			imp.changes=false;
+			close();
+		}
+	}
+
+	/** Returns the plot values with simple headings (X, Y, Y1 etc, not the labels) as a ResultsTable.
+	 *  Use plot.getResultsTableWithLabels for a table with data set labels as column headings */
+	public ResultsTable getResultsTable() {
+		return plot.getResultsTable(saveXValues);
+	}
+
+	/** creates the data that fills the showList() function values */
+	private String getValuesAsString(){
+		ResultsTable rt = getResultsTable();
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<rt.size(); i++) {
+			sb.append(rt.getRowAsString(i));
+			sb.append("\n");
+		}
+		return sb.toString();
+	}
+
+	/** Saves the data of the plot in a text file */
+	void saveAsText() {
+		if (plot.getXValues() == null) {
+			IJ.error("Plot has no data");
+			return;
+		}
+		SaveDialog sd = new SaveDialog("Save as Text", "Values", Prefs.defaultResultsExtension());
+		String name = sd.getFileName();
+		if (name==null) return;
+		String directory = sd.getDirectory();
+		IJ.wait(250);  // give system time to redraw ImageJ window
+		IJ.showStatus("Saving plot values...");
+		ResultsTable rt = plot.getResultsTable(/*writeFirstXColumn=*/saveXValues, /*useLabels=*/true);
+		try {
+			rt.saveAs(directory+name);
+		} catch (IOException e) {
+			IJ.error("" + e);
+			return;
+		}
+		if (autoClose)
+			{imp.changes=false; close();}
+	}
+
+	/** Copy the first dataset or all values to the clipboard */
+	void copyToClipboard(boolean writeAllColumns) {
+		float[] xValues = plot.getXValues();
+		float[] yValues = plot.getYValues();
+		if (xValues == null) return;
+		Clipboard systemClipboard = null;
+		try {systemClipboard = getToolkit().getSystemClipboard();}
+		catch (Exception e) {systemClipboard = null; }
+		if (systemClipboard==null)
+			{IJ.error("Unable to copy to Clipboard."); return;}
+		IJ.showStatus("Copying plot values...");
+		CharArrayWriter aw = new CharArrayWriter(10*xValues.length);
+		PrintWriter pw = new PrintWriter(aw); //uses platform's line termination characters
+
+		if (writeAllColumns) {
+			ResultsTable rt = plot.getResultsTableWithLabels();
+			if (!Prefs.dontSaveHeaders) {
+				String headings = rt.getColumnHeadings();
+				pw.println(headings);
+			}
+			for (int i=0; i<rt.size(); i++)
+				pw.println(rt.getRowAsString(i));
+		} else {
+			int xdigits = 0;
+			if (saveXValues)
+				xdigits = plot.getPrecision(xValues);
+			int ydigits = plot.getPrecision(yValues);
+			for (int i=0; i<Math.min(xValues.length, yValues.length); i++) {
+				if (saveXValues)
+					pw.println(IJ.d2s(xValues[i],xdigits)+"\t"+IJ.d2s(yValues[i],ydigits));
+				else
+					pw.println(IJ.d2s(yValues[i],ydigits));
+			}
+		}
+		String text = aw.toString();
+		pw.close();
+		StringSelection contents = new StringSelection(text);
+		systemClipboard.setContents(contents, this);
+		IJ.showStatus(text.length() + " characters copied to Clipboard");
+		if (autoClose)
+			{imp.changes=false; close();}
+	}
+
+	public void lostOwnership(Clipboard clipboard, Transferable contents) {}
+
+	public float[] getXValues() {
+		return plot.getXValues();
+	}
+
+	public float[] getYValues() {
+		return plot.getYValues();
+	}
+
+	/** Draws a new plot in this window. */
+	public void drawPlot(Plot plot) {
+		this.plot = plot;
+		if (imp!=null) {
+			if (ic instanceof PlotCanvas)
+				((PlotCanvas)ic).setPlot(plot);
+			imp.setProcessor(null, plot.getProcessor());
+			plot.setImagePlus(imp); //also adjusts the calibration of imp
+		}
+	}
+
+	/** Called once when ImageJ quits. */
+	public static void savePreferences(Properties prefs) {
+		double min = ProfilePlot.getFixedMin();
+		double max = ProfilePlot.getFixedMax();
+		prefs.put(PREFS_WIDTH, Integer.toString(plotWidth));
+		prefs.put(PREFS_HEIGHT, Integer.toString(plotHeight));
+		prefs.put(PREFS_FONT_SIZE, Integer.toString(defaultFontSize));
+		int options = 0;
+		if (!interpolate) options |= INTERPOLATE; // true=0, false=1
+		prefs.put(OPTIONS, Integer.toString(options));
+	}
+
+	private void toggleLiveProfiling() {
+		boolean liveMode = bgThread != null;
+		if (liveMode)
+			disableLivePlot();
+		else
+			enableLivePlot();
+	}
+
+	/* Enable live plotting.
+	 * This requires that the PlotWindow has been initialized with a Plot having a PlotMaker */
+	private void enableLivePlot() {
+		if (plotMaker==null)
+			plotMaker = plot!=null?plot.getPlotMaker():null;
+		if (plotMaker==null) return;
+		srcImp = plotMaker.getSourceImage();
+		if (srcImp==null)
+			return;
+		if (bgThread==null) {
+			bgThread = new Thread(this, "Live Plot");
+			bgThread.setPriority(Math.max(bgThread.getPriority()-3, Thread.MIN_PRIORITY));
+			doUpdate = true;
+			bgThread.start();
+		}
+		if (IJ.debugMode) IJ.log("PlotWindow.createListeners");
+		ImagePlus.addImageListener(this);
+		Roi.addRoiListener(this);
+		Font font = live.getFont();
+		live.setFont(new Font(font.getName(), Font.BOLD, font.getSize()));
+		live.setForeground(Color.red);
+	}
+
+	private void disableLivePlot() {
+		if (IJ.debugMode) IJ.log("PlotWindow.disableLivePlot: "+srcImp);
+		if (srcImp==null)
+			return;
+		if (bgThread!=null)
+			bgThread.interrupt();
+		bgThread = null;
+		ImagePlus.removeImageListener(this);
+		Roi.removeRoiListener(this);
+		if (live != null) {
+			Font font = live.getFont();
+			live.setFont(new Font(font.getName(), Font.PLAIN, font.getSize()));
+			live.setForeground(Color.black);
+		}
+	}
+
+
+	/** For live plots, update the plot if the ROI of the source image changes */
+	public synchronized void roiModified(ImagePlus img, int id) {
+		if (IJ.debugMode) IJ.log("PlotWindow.roiModified: "+img+"  "+id);
+		if (img==srcImp) {
+			doUpdate=true;
+			notify();
+		}
+	}
+
+	// Unused
+	public void imageOpened(ImagePlus imp) {
+	}
+
+	/** For live plots, this method is called if the source image content is changed. */
+	public synchronized void imageUpdated(ImagePlus imp) {
+		if (imp==srcImp) {
+			doUpdate = true;
+			notify();
+		}
+	}
+
+	/** For live plots, if either the source image or this image are closed, exit live mode */
+	public void imageClosed(ImagePlus imp) {
+		if (imp==srcImp || imp==this.imp) {
+			disableLivePlot();
+			srcImp = null;
+			plotMaker = null;
+		}
+	}
+
+	// the background thread for live plotting.
+	public void run() {
+		while (true) {
+			IJ.wait(50);	//delay to make sure the roi has been updated
+			Plot plot = plotMaker!=null?plotMaker.getPlot():null;
+			if (doUpdate && plot!=null && plot.getNumPlotObjects()>0) {
+				plot.useTemplate(this.plot, this.plot.templateFlags | Plot.COPY_SIZE | Plot.COPY_LABELS | Plot.COPY_AXIS_STYLE |
+						Plot.COPY_CONTENTS_STYLE | Plot.COPY_LEGEND | Plot.COPY_EXTRA_OBJECTS);
+				plot.setPlotMaker(plotMaker);
+				this.plot = plot;
+				((PlotCanvas)ic).setPlot(plot);
+				ImageProcessor ip = plot.getProcessor();
+				if (ip!=null && imp!=null) {
+					imp.setProcessor(null, ip);
+					plot.setImagePlus(imp);
+				}
+			}
+			synchronized(this) {
+				if (doUpdate) {
+					doUpdate = false;		//and loop again
+				} else {
+					try {wait();}	//notify wakes up the thread
+					catch(InterruptedException e) { //interrupted tells the thread to exit
+						return;
+					}
+				}
+			}
+		}
+	}
+
+	/** Returns the Plot associated with this PlotWindow. */
+	public Plot getPlot() {
+		return plot;
+	}
+
+	/** Freezes the active plot window, so the image does not get redrawn for zooming,
+	 *  setting the range, etc. */
+	public static void freeze() {
+		Window win = WindowManager.getActiveWindow();
+		if (win!=null && (win instanceof PlotWindow))
+			((PlotWindow)win).getPlot().setFrozen(true);
+	}
+	
+	public static void setDefaultFontSize(int size) {
+		if (size < 9) size = 9;
+		defaultFontSize = size;
+	}
+
+	public static int getDefaultFontSize() {
+		return defaultFontSize;
+	}
+
+}
diff --git a/src/ij/gui/PointRoi.java b/src/ij/gui/PointRoi.java
new file mode 100644
index 0000000..2986b31
--- /dev/null
+++ b/src/ij/gui/PointRoi.java
@@ -0,0 +1,987 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.Colors;
+import ij.plugin.PointToolOptions;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.frame.Recorder;
+import ij.util.Java2;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.KeyEvent;
+import java.util.*;
+import java.awt.geom.*;
+
+/** This class represents a collection of points that can be associated with counters.
+ * @see <a href="http://wsr.imagej.net/macros/js/PointProperties.js">PointProperties.js</a>
+*/
+public class PointRoi extends PolygonRoi {
+	public static final String[] sizes = {"Tiny", "Small", "Medium", "Large", "Extra Large", "XXL", "XXXL"};
+	public static final String[] types = {"Hybrid", "Cross", "Dot", "Circle"};
+	public static final int HYBRID=0, CROSS=1, CROSSHAIR=1, DOT=2, CIRCLE=3;
+	private static final String TYPE_KEY = "point.type";
+	private static final String SIZE_KEY = "point.size";
+	private static final String CROSS_COLOR_KEY = "point.cross.color";
+	private static final int TINY=1, SMALL=3, MEDIUM=5, LARGE=7, EXTRA_LARGE=11, XXL=17, XXXL=25;
+	private static final BasicStroke twoPixelsWide = new BasicStroke(2);
+	private static final BasicStroke threePixelsWide = new BasicStroke(3);
+	private static final BasicStroke fivePixelsWide = new BasicStroke(5);
+	private static int defaultType = HYBRID;
+	private static int defaultSize = SMALL;
+	private static Font font;
+	private static Color defaultCrossColor = Color.white;
+	private static int fontSize = 9;
+	public static final int MAX_COUNTERS = 100;
+	private static String[] counterChoices;
+	private static Color[] colors;
+	private boolean showLabels;
+	private int type = HYBRID;
+	private int size = SMALL;
+	private static int defaultCounter;
+	private int counter;
+	private int nCounters = 1;
+	private short[] counters;   //for each point, 0-100 for counter (=category that can be defined by the user)
+	private int[] positions;    //for each point, the stack slice, or 0 for 'show on all'
+	private int[] counts = new int[MAX_COUNTERS];
+	private ResultsTable rt;
+	private long lastPointTime;
+	private int[] counterInfo;
+	private boolean promptBeforeDeleting;
+	private boolean promptBeforeDeletingCalled;
+	private int nMarkers;
+	private boolean addToOverlay;
+	public static PointRoi savedPoints;
+
+	static {
+		setDefaultType((int)Prefs.get(TYPE_KEY, HYBRID));
+		setDefaultSize((int)Prefs.get(SIZE_KEY, 1));
+	}
+
+	public PointRoi() {
+		this(0.0, 0.0);
+		deletePoint(0);
+	}
+
+	/** Creates a new PointRoi using the specified int arrays of offscreen coordinates. */
+	public PointRoi(int[] ox, int[] oy, int points) {
+		super(itof(ox), itof(oy), points, POINT);
+		width+=1; height+=1;
+		updateCounts();
+	}
+
+	/** Creates a new PointRoi using the specified float arrays of offscreen coordinates. */
+	public PointRoi(float[] ox, float[] oy, int points) {
+		super(ox, oy, points, POINT);
+		width+=1; height+=1;
+		updateCounts();
+	}
+
+	/** Creates a new PointRoi using the specified float arrays of offscreen coordinates. */
+	public PointRoi(float[] ox, float[] oy) {
+		this(ox, oy, ox.length);
+	}
+
+	/** Creates a new PointRoi using the specified coordinate arrays and options. */
+	public PointRoi(float[] ox, float[] oy, String options) {
+		this(ox, oy, ox.length);
+		setOptions(options);
+	}
+
+	/** Creates a new PointRoi from a FloatPolygon. */
+	public PointRoi(FloatPolygon poly) {
+		this(poly.xpoints, poly.ypoints, poly.npoints);
+	}
+
+	/** Creates a new PointRoi from a Polygon. */
+	public PointRoi(Polygon poly) {
+		this(itof(poly.xpoints), itof(poly.ypoints), poly.npoints);
+	}
+
+	/** Creates a new PointRoi using the specified coordinates and options. */
+	public PointRoi(double ox, double oy, String options) {
+		super(makeXorYArray(ox, null, false), makeXorYArray(oy, null, true), 1, POINT);
+		width=1; height=1;
+		incrementCounter(null);
+		setOptions(options);
+	}
+
+	/** Creates a new PointRoi using the specified offscreen int coordinates. */
+	public PointRoi(int ox, int oy) {
+		super(makeXorYArray(ox, null, false), makeXorYArray(oy, null, true), 1, POINT);
+		width=1; height=1;
+		incrementCounter(null);
+	}
+
+	/** Creates a new PointRoi using the specified offscreen double coordinates. */
+	public PointRoi(double ox, double oy) {
+		super(makeXorYArray(ox, null, false), makeXorYArray(oy, null, true), 1, POINT);
+		width=1; height=1;
+		incrementCounter(null);
+	}
+
+	/** Creates a new PointRoi using the specified screen coordinates. */
+	public PointRoi(int sx, int sy, ImagePlus imp) {
+		super(makeXorYArray(sx, imp, false), makeXorYArray(sy, imp, true), 1, POINT);
+		//defaultCounter = 0;
+		setImage(imp);
+		width=1; height=1;
+		type = defaultType;
+		size = defaultSize;
+		showLabels = !Prefs.noPointLabels;
+		if (imp!=null) {
+			int r = 10 + size;
+			double mag = ic!=null?ic.getMagnification():1;
+			if (mag<1)
+				r = (int)(r/mag);
+			imp.draw(x-r, y-r, 2*r, 2*r);
+		}
+		setCounter(Toolbar.getMultiPointMode()?defaultCounter:0);
+		incrementCounter(imp);
+		enlargeArrays(50);
+		if (Recorder.record) {
+			String add = Prefs.pointAddToOverlay?" add":"";
+			String options = sizes[convertSizeToIndex(size)]+" "+Colors.colorToString(getColor())+" "+types[type]+add;
+			options = options.toLowerCase();
+			if (Recorder.scriptMode())
+				Recorder.recordCall("imp.setRoi(new PointRoi("+x+","+y+",\""+options+"\"));");
+			else
+				Recorder.record("makePoint", x, y, options);
+		}
+	}
+
+	public void setOptions(String options) {
+		if (options==null)
+			return;
+		if (options.contains("tiny")) size=TINY;
+		else if (options.contains("medium")) size=MEDIUM;
+		else if (options.contains("extra")) size=EXTRA_LARGE;
+		else if (options.contains("large")) size=LARGE;
+		else if (options.contains("xxxl")) size=XXXL;
+		else if (options.contains("xxl")) size=XXL;
+		if (options.contains("cross")) type=CROSS;
+		else if (options.contains("dot")) type=DOT;
+		else if (options.contains("circle")) type=CIRCLE;
+		if (options.contains("nolabel")) setShowLabels(false);
+		else if (options.contains("label")) setShowLabels(true);
+		setStrokeColor(Colors.getColor(options,Roi.getColor()));
+		addToOverlay =  options.contains("add");
+	}
+
+	static float[] itof(int[] arr) {
+		if (arr==null)
+			return null;
+		int n = arr.length;
+		float[] temp = new float[n];
+		for (int i=0; i<n; i++)
+			temp[i] = arr[i];
+		return temp;
+	}
+
+	/** Creates a one-element array with a coordinate; if 'imp' is non-null
+	 *  converts from a screen coordinate to an image (offscreen) coordinate.
+	 *  The array can be used for adding to an existing point selection */
+	static float[] makeXorYArray(double value, ImagePlus imp, boolean isY) {
+		if (imp != null) {
+			ImageCanvas canvas = imp.getCanvas();
+			if (canvas != null) {			//offset 0.5 converts from area to pixel center coordinates
+				value = (isY ? canvas.offScreenYD((int)value) :canvas.offScreenXD((int)value)) - 0.5;
+				if (!magnificationForSubPixel(canvas.getMagnification()))
+					value = Math.round(value);
+			}
+		}
+		return new float[] {(float)value};
+	}
+
+	void handleMouseMove(int ox, int oy) {
+	}
+
+	protected void handleMouseUp(int sx, int sy) {
+		super.handleMouseUp(sx, sy);
+		modifyRoi(); //adds this point to previous points if shift key down
+	}
+
+	/** Draws the points on the image. */
+	public void draw(Graphics g) {
+		updatePolygon();
+		if (showLabels && nPoints>1) {
+			fontSize = 8;
+			double scale = size>=XXL?2:1.5;
+			fontSize += scale*convertSizeToIndex(size);
+			fontSize = (int)Math.round(fontSize);
+			//IJ.log("fontSize: "+fontSize+" "+scale);
+			font = new Font("SansSerif", Font.PLAIN, fontSize);
+			g.setFont(font);
+			if (fontSize>9)
+				Java2.setAntialiasedText(g, true);
+		}
+		int slice = imp!=null&&positions!=null&&imp.getStackSize()>1?imp.getCurrentSlice():0;
+		ImageCanvas ic = imp!=null?imp.getCanvas():null;
+		if (ic!=null && overlay && ic.getShowAllList()!=null && ic.getShowAllList().contains(this) && !Prefs.showAllSliceOnly)
+			slice = 0;  // draw point irrespective of currently selected slice
+		if (Prefs.showAllPoints)
+			slice = 0;
+		//IJ.log("draw: "+positions+" "+imp.getCurrentSlice());
+		for (int i=0; i<nPoints; i++) {
+			//IJ.log(i+" "+slice+" "+(positions!=null?positions[i]:-1)+"  "+getPosition());
+			if (slice==0 || (positions!=null&&(slice==positions[i]||positions[i]==0)))
+				drawPoint(g, xp2[i], yp2[i], i+1);
+		}
+		if (updateFullWindow) {
+			updateFullWindow = false;
+			imp.draw();
+		}
+		PointToolOptions.update();
+		flattenScale = 1.0;
+	}
+
+	void drawPoint(Graphics g, int x, int y, int n) {
+		int size2=size/2;
+		boolean colorSet = false;
+		Graphics2D g2d = (Graphics2D)g;
+		AffineTransform saveXform = null;
+		if (flattenScale>1.0) {
+			saveXform = g2d.getTransform();
+			g2d.translate(x, y);
+			g2d.scale(flattenScale, flattenScale);
+			x = y = 0;
+		}
+		Color color = strokeColor!=null?strokeColor:ROIColor;
+		if (!overlay && isActiveOverlayRoi()) {
+			if (color==Color.cyan)
+				color = Color.magenta;
+			else
+				color = Color.cyan;
+		}
+		if (nCounters>1 && counters!=null && n<=counters.length)
+			color = getColor(counters[n-1]);
+		if (type==HYBRID || type==CROSS) {
+			if (type==HYBRID)
+				g.setColor(Color.white);
+			else {
+				g.setColor(color);
+				colorSet = true;
+			}
+			if (size>XXL)
+				g2d.setStroke(fivePixelsWide);
+			else if (size>LARGE)
+				g2d.setStroke(threePixelsWide);
+			g.drawLine(x-(size+2), y, x+size+2, y);
+			g.drawLine(x, y-(size+2), x, y+size+2);
+		}
+		if (type!=CROSS && size>SMALL)
+			g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		if (type==HYBRID || type==DOT) {
+			if (!colorSet) {
+				g.setColor(color);
+				colorSet = true;
+			}
+			if (size>LARGE)
+				g2d.setStroke(onePixelWide);
+			if (size>LARGE && type==DOT)
+				g.fillOval(x-size2, y-size2, size, size);
+			else if (size>LARGE && type==HYBRID)
+				g.fillRect(x-(size2-2), y-(size2-2), size-4, size-4);
+			else if (size>SMALL && type==HYBRID)
+				g.fillRect(x-(size2-1), y-(size2-1), size-2, size-2);
+			else
+				g.fillRect(x-size2, y-size2, size, size);
+		}
+		if (showLabels && nPoints>1) {
+			int xoffset = 2;
+			if (size==LARGE) xoffset=3;
+			if (size==EXTRA_LARGE) xoffset=4;
+			if (size==XXL) xoffset=5;
+			if (size==XXXL) xoffset=7;
+			int yoffset = xoffset;
+			if (size>=LARGE) yoffset=yoffset-1;
+			if (nCounters==1) {
+				if (!colorSet)
+					g.setColor(color);
+				g.drawString(""+n, x+xoffset, y+yoffset+fontSize);
+			} else if (counters!=null) {
+				g.setColor(getColor(counters[n-1]));
+				g.drawString(""+counters[n-1], x+xoffset, y+yoffset+fontSize);
+			}
+		}
+		if ((size>TINY||type==DOT) && (type==HYBRID||type==DOT)) {
+			g.setColor(Color.black);
+			if (size>LARGE && type==HYBRID)
+				g.drawOval(x-(size2-1), y-(size2-1), size-3, size-3);
+			else if (size>SMALL && type==HYBRID)
+				g.drawOval(x-size2, y-size2, size-1, size-1);
+			else
+				g.drawOval(x-(size2+1), y-(size2+1), size+1, size+1);
+		}
+		if (type==CIRCLE) {
+			int scaledSize = (int)Math.round(size+1);
+			g.setColor(color);
+			if (size>LARGE)
+				g2d.setStroke(twoPixelsWide);
+			g.drawOval(x-scaledSize/2, y-scaledSize/2, scaledSize, scaledSize);
+		}
+		if (saveXform!=null)
+			g2d.setTransform(saveXform);
+	}
+
+	public void drawPixels(ImageProcessor ip) {
+		ip.setLineWidth(Analyzer.markWidth);
+		double x0 = bounds == null ? x : bounds.x;
+		double y0 = bounds == null ? y : bounds.y;
+		for (int i=0; i<nPoints; i++) {
+			ip.moveTo((int)Math.round(x0+xpf[i]), (int)Math.round(y0+ypf[i]));
+			ip.lineTo((int)Math.round(x0+xpf[i]), (int)Math.round(y0+ypf[i]));
+		}
+	}
+
+	/** Adds a point to this PointRoi. */
+	public void addPoint(ImagePlus imp, double ox, double oy) {
+		if (nPoints==xpf.length)
+			enlargeArrays();
+		addPoint2(imp, ox, oy);
+		resetBoundingRect();
+	}
+
+
+	public void addUserPoint(ImagePlus imp, double ox, double oy) {
+		addPoint(imp, ox, oy);
+		nMarkers++;
+	}
+
+	private void addPoint2(ImagePlus imp, double ox, double oy) {
+		double xbase = getXBase();
+		double ybase = getYBase();
+		xpf[nPoints] = (float)(ox-xbase);
+		ypf[nPoints] = (float)(oy-ybase);
+		xp2[nPoints] = (int)ox;
+		yp2[nPoints] = (int)oy;
+		nPoints++;
+		incrementCounter(imp);
+		lastPointTime = System.currentTimeMillis();
+	}
+
+	/** Adds a point to this PointRoi. */
+	public PointRoi addPoint(double x, double y) {
+		addPoint(null, x, y);
+		return this;
+	}
+
+	/** Adds a point at the specified stack position. */
+	public void addPoint(double x, double y, int position) {
+		if (counters==null) {
+			counters = new short[100];
+			positions = new int[100];
+		}
+		addPoint(null, x, y);
+		positions[nPoints-1] = position;	
+	}
+
+	protected void deletePoint(int index) {
+		super.deletePoint(index);
+		if (index>=0 && index<=nPoints && counters!=null) {
+			counts[counters[index]]--;
+			for (int i=index; i<nPoints; i++) {
+				counters[i] = counters[i+1];
+				positions[i] = positions[i+1];
+			}
+			if (rt!=null && WindowManager.getFrame(getCountsTitle())!=null)
+				displayCounts();
+		}
+	}
+
+	private synchronized void incrementCounter(ImagePlus imp) {
+		//IJ.log("incrementCounter: "+nPoints+" "+counter+" "+(counters!=null?""+counters.length:"null"));
+		counts[counter]++;
+		boolean isStack = imp!=null && imp.getStackSize()>1;
+		if (counter!=0 || isStack || counters!=null) {
+			if (counters==null) {
+				counters = new short[nPoints*2];
+				positions = new int[nPoints*2];
+			}
+			counters[nPoints-1] = (short)counter;
+			if (imp!=null)
+					positions[nPoints-1] = imp.getStackSize()>1 ? imp.getCurrentSlice() : 0;
+			//if (positions[nPoints-1]==0 || positions[nPoints-1]==1 || counters[nPoints-1]==0)
+			//	IJ.log("incrementCounter: "+nPoints+" "+" "+positions[nPoints-1]+" "+counters[nPoints-1]+" "+imp);
+			if (nPoints+1==counters.length) {
+				short[] temp = new short[counters.length*2];
+				System.arraycopy(counters, 0, temp, 0, counters.length);
+				counters = temp;
+				int[] temp1 = new int[counters.length*2];
+				System.arraycopy(positions, 0, temp1, 0, positions.length);
+				positions = temp1;
+			}
+		}
+		if (rt!=null && WindowManager.getFrame(getCountsTitle())!=null)
+			displayCounts();
+	}
+	
+	/** Returns the index of the current counter. */
+	public int getCounter() {
+		return counter;
+	}
+
+	/** Returns the count associated with the specified counter index.
+	 * @see #getLastCounter
+	 * @see <a href="http://wsr.imagej.net/macros/js/PointProperties.js">PointProperties.js</a>
+	 */
+	public int getCount(int counter) {
+		if (counter==0 && counters==null)
+			return nPoints;
+		else
+			return counts[counter];
+	}
+
+	/** Returns the index of the last counter. */
+	public int getLastCounter() {
+		return nCounters - 1;
+	}
+
+	/** Returns the number of counters. */
+	public int getNCounters() {
+		int n = 0;
+		for (int counter=0; counter<nCounters; counter++) {
+			if (getCount(counter)>0) n++;
+		}
+		return n;
+	}
+
+	/** Returns the counter assocated with the specified point. */
+	public int getCounter(int index) {
+		if (counters==null || index>=counters.length)
+			return 0;
+		else
+			return counters[index];
+	}
+
+	public void resetCounters() {
+		for (int i=0; i<counts.length; i++)
+			counts[i] = 0;
+		counters = null;
+		positions = null;
+		PointToolOptions.update();
+	}
+
+	/** Returns the points of this Roi that are not contained in the specified area ROI.
+	 *  Returns null if there are no resulting points or Roi is not an area roi. */
+	public PointRoi subtractPoints(Roi roi) {
+		return checkContained(roi, false);
+	}
+
+	/** Returns the points of this Roi that are contained in the specified area ROI.
+	 *  Returns null if there are no resulting points or Roi is not an area roi. */
+	public PointRoi containedPoints(Roi roi) {
+		return checkContained(roi, true);
+	}
+
+	/** Returns the points contained (not contained) in <code>roi</code> if <code>keepContained</code> is true (false). */
+	PointRoi checkContained(Roi roi, boolean keepContained) {
+		if (!roi.isArea()) return null;
+		FloatPolygon points = getFloatPolygon();
+		FloatPolygon points2 = new FloatPolygon();
+		for (int i=0; i<points.npoints; i++) {
+			if (keepContained == roi.containsPoint(points.xpoints[i], points.ypoints[i]))
+				points2.addPoint(points.xpoints[i], points.ypoints[i]);
+		}
+		if (points2.npoints==0)
+			return null;
+		else {
+			PointRoi roi2 = new PointRoi(points2.xpoints, points2.ypoints, points2.npoints);
+			roi2.copyAttributes(this);
+			return roi2;
+		}
+	}
+
+	public ImageProcessor getMask() {
+		ImageProcessor mask = cachedMask;
+		if (mask!=null && mask.getPixels()!=null)
+			return mask;
+		mask = new ByteProcessor(width, height);
+		double deltaX = getXBase() - x;
+		double deltaY = getYBase() - y;
+		for (int i=0; i<nPoints; i++)
+			mask.putPixel((int)Math.round(xpf[i] + deltaX), (int)Math.round(ypf[i] + deltaY), 255);
+		cachedMask = mask;
+		return mask;
+	}
+
+	/** Returns true if (x,y) is one of the points in this collection. */
+	public boolean contains(int x, int y) {
+		for (int i=0; i<nPoints; i++) {
+			if (x==this.x+xpf[i] && y==this.y+ypf[i]) return true;
+		}
+		return false;
+	}
+
+	public void setShowLabels(boolean showLabels) {
+		this.showLabels = showLabels;
+	}
+
+	public boolean getShowLabels() {
+		return showLabels;
+	}
+
+	public static void setDefaultType(int type) {
+		if (type>=0 && type<types.length) {
+			defaultType = type;
+			PointRoi instance = getPointRoiInstance();
+			if (instance!=null)
+				instance.setPointType(defaultType);
+			Prefs.set(TYPE_KEY, type);
+		}
+	}
+
+	public static int getDefaultType() {
+		return defaultType;
+	}
+
+	/** Sets the point type (0=hybrid, 1=cross, 2=dot, 3=circle). */
+	public void setPointType(int type) {
+		if (type>=0 && type<types.length)
+			this.type = type;
+	}
+
+	/** Returns the point type (0=hybrid, 1=cross, 2=dot, 3=circle). */
+	public int getPointType() {
+		return type;
+	}
+
+
+	/** Sets the default point size, where 'size' is 0-6 (Tiny-XXXL). */
+	public static void setDefaultSize(int size) {
+		int index = size;
+		if (index>=0 && index<sizes.length) {
+			defaultSize = convertIndexToSize(index);
+			PointRoi instance = getPointRoiInstance();
+			if (instance!=null)
+				instance.setSize(index);
+			Prefs.set(SIZE_KEY, index);
+		}
+	}
+
+	/** Returns the default point size 0-6 (Tiny-XXXL). */
+	public static int getDefaultSize() {
+		return convertSizeToIndex(defaultSize);
+	}
+
+	/** Sets the point size, where 'size' is 0-6 (Tiny-XXXL). */
+	public void setSize(int size) {
+		if (size>=0 && size<sizes.length)
+			this.size = convertIndexToSize(size);
+	}
+
+	/** Returns the current point size 0-6 (Tiny-XXXL). */
+	public int getSize() {
+		return convertSizeToIndex(size);
+	}
+
+	private static int convertSizeToIndex(int size) {
+		switch (size) {
+			case TINY: return 0;
+			case SMALL: return 1;
+			case MEDIUM: return 2;
+			case LARGE: return 3;
+			case EXTRA_LARGE: return 4;
+			case XXL: return 5;
+			case XXXL: return 6;
+		}
+		return 1;
+	}
+
+	private static int convertIndexToSize(int index) {
+		switch (index) {
+			case 0: return TINY;
+			case 1: return SMALL;
+			case 2: return MEDIUM;
+			case 3: return LARGE;
+			case 4: return EXTRA_LARGE;
+			case 5: return XXL;
+			case 6: return XXXL;
+		}
+		return SMALL;
+	}
+
+	/** Always returns true. */
+	public boolean subPixelResolution() {
+		return true;
+	}
+
+	private static PointRoi getPointRoiInstance() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			Roi roi  = imp.getRoi();
+			if (roi!=null) {
+				if (roi instanceof PointRoi)
+					return (PointRoi)roi;
+			}
+		}
+		return null;
+	}
+
+	public void setCounter(int counter) {
+		this.counter = counter;
+		if (counter>nCounters-1 && nCounters<MAX_COUNTERS)
+			nCounters = counter + 1;
+	}
+
+	public boolean promptBeforeDeleting() {
+	    if (promptBeforeDeletingCalled && getNCounters()==1)
+	    	return promptBeforeDeleting;
+	    else
+			return (nMarkers>8||getNCounters()>1) && imp!=null && imp.getWindow()!=null;
+	}
+
+	public void promptBeforeDeleting(Boolean prompt) {
+		promptBeforeDeleting = prompt;
+		promptBeforeDeletingCalled = true;
+	}
+
+	public static void setDefaultCounter(int counter) {
+		defaultCounter = counter;
+	}
+
+	/** Returns an array containing for each point:
+	 *  The counter number (0-100) in the lower 8 bits, and the slice number
+	 *  (or 0, if the point appears on all slices) in the higher 24 bits.
+	 *  Used when writing a Roi to file (RoiEncoder) */
+	public int[] getCounters() {
+		if (nPoints>65535)
+			return null;
+		int[] temp = new int[nPoints];
+		if (counters!=null) {
+			for (int i=0; i<nPoints; i++)
+				temp[i] = (counters[i]&0xff) + (positions[i]<<8);
+		}
+		return temp;
+	}
+
+	/** Sets the counter number and slice number for each point from an
+	 *  array, where the lower 8 bits are the counter number and the
+	 *  higher 24 bits contain the slice position of each point.
+	 *  Used when reading a roi fromfile (RoiDecoder).  */
+	public void setCounters(int[] counters) {
+		if (counters!=null) {
+			int n = counters.length;
+			this.counters = new short[n*2];
+			this.positions = new int[n*2];
+			for (int i=0; i<n; i++) {
+				int counter = counters[i]&0xff;
+				int position = counters[i]>>8;
+				//IJ.log(i+" cnt="+counter+" slice="+position);
+				this.counters[i] = (short)counter;
+				this.positions[i] = position;
+				if (counter<counts.length && counter>nCounters-1)
+					nCounters = counter + 1;
+			}
+			updateCounts();
+		}
+	}
+
+	/** Updates the counts for each category in 'counters' */
+	public void updateCounts() {
+		Arrays.fill(counts, 0);
+		for (int i=0; i<nPoints; i++)
+			counts[(counters==null || counters[i]>=counts.length) ? 0 : counters[i]] ++;
+	}
+
+	/** Returns the stack slice of the point with the given index, or 0 if no slice defined for this point */
+	public int getPointPosition(int index) {
+		if (positions!=null && index<nPoints)
+			return positions[index];
+		else
+			return 0;
+	}
+
+	public void displayCounts() {
+		ImagePlus imp = getImage();
+		String firstColumnHdr = "Slice";
+		rt = new ResultsTable();
+		int row = 0;
+		if (imp!=null && imp.getStackSize()>1 && positions!=null) {
+			int nChannels = 1;
+			int nSlices = 1;
+			int nFrames = 1;
+			boolean isHyperstack = true;
+			if (imp.isComposite() || imp.isHyperStack()) {
+				nChannels = imp.getNChannels();
+				nSlices = imp.getNSlices();
+				nFrames = imp.getNFrames();
+				int nDimensions = 2;
+				if (nChannels>1) nDimensions++;
+				if (nSlices>1) nDimensions++;
+				if (nFrames>1) nDimensions++;
+				if (nDimensions==3) {
+					isHyperstack = false;
+					if (nChannels>1)
+						firstColumnHdr = "Channel";
+				} else
+					firstColumnHdr = "Image";
+			}
+			int firstSlice = Integer.MAX_VALUE;
+			for (int i=0; i<nPoints; i++) {
+				if (positions[i]>0 && positions[i]<firstSlice)
+					firstSlice = positions[i];
+			}
+			if (firstSlice==Integer.MAX_VALUE)
+				firstSlice = 0;
+			int lastSlice = 0;
+			if (firstSlice>0) {
+				for (int i=0; i<nPoints; i++) {
+					if (positions[i]>lastSlice)
+						lastSlice = positions[i];
+				}
+			}
+			if (firstSlice>0) {
+				for (int slice=firstSlice; slice<=lastSlice; slice++) {
+					rt.setValue(firstColumnHdr, row, slice);
+					if (isHyperstack) {
+						int[] position = imp.convertIndexToPosition(slice);
+						if (nChannels>1)
+							rt.setValue("Channel", row, position[0]);
+						if (nSlices>1)
+							rt.setValue("Slice", row, position[1]);
+						if (nFrames>1)
+							rt.setValue("Frame", row, position[2]);
+					}
+					for (int counter=0; counter<nCounters; counter++) {
+						int count = 0;
+						for (int i=0; i<nPoints; i++) {
+							if (slice==positions[i] && counter==counters[i])
+								count++;
+						}
+						rt.setValue("Ctr "+counter, row, count);
+					}
+					row++;
+				}
+			}
+		}
+		rt.setValue(firstColumnHdr, row, "Total");
+		for (int i=0; i<nCounters; i++)
+			rt.setValue("Ctr "+i, row, counts[i]);
+		rt.show(getCountsTitle());
+		if (IJ.debugMode) debug();
+	}
+
+	private void debug() {
+		FloatPolygon p = getFloatPolygon();
+		ResultsTable rt = new ResultsTable();
+		for (int i=0; i<nPoints; i++) {
+			if (counters!=null) {
+				rt.setValue("Counter", i, counters[i]);
+				rt.setValue("Position", i, positions[i]);
+			}
+			rt.setValue("X", i, p.xpoints[i]);
+			rt.setValue("Y", i, p.ypoints[i]);
+		}
+		rt.show(getCountsTitle());
+	}
+
+	private String getCountsTitle() {
+		return "Counts_"+(imp!=null?imp.getTitle():"");
+	}
+
+	public synchronized static String[] getCounterChoices() {
+		if (counterChoices==null) {
+			counterChoices = new String[MAX_COUNTERS];
+			for (int i=0; i<MAX_COUNTERS; i++)
+				counterChoices[i] = ""+i;
+		}
+		return counterChoices;
+	}
+
+	private static Color getColor(int index) {
+		if (colors==null) {
+			colors = new Color[MAX_COUNTERS];
+			colors[0]=Color.yellow; colors[1]=Color.magenta; colors[2]=Color.cyan;
+			colors[3]=Color.orange; colors[4]=Color.green; colors[5]=Color.blue;
+			colors[6]=Color.white; colors[7]=Color.darkGray; colors[8]=Color.pink;
+			colors[9]=Color.lightGray;
+		}
+		if (colors[index]!=null)
+			return colors[index];
+		else {
+			Random ran = new Random();
+			float r = (float)ran.nextDouble();
+			float g = (float)ran.nextDouble();
+			float b = (float)ran.nextDouble();
+			Color c = new Color(r, g, b);
+			colors[index] = c;
+			return c;
+		}
+	}
+
+	/** Returns a point index if it has been at least one second since
+		the last point was added and the specified screen coordinates are
+		inside or near a point, otherwise returns -1. */
+	public int isHandle(int sx, int sy) {
+		if ((System.currentTimeMillis()-lastPointTime)<1000L)
+			return -1;
+		int size = HANDLE_SIZE+this.size;
+		int halfSize = size/2;
+		int handle = -1;
+		int sx2, sy2;
+		int slice = !Prefs.showAllPoints&&positions!=null&&imp!=null&&imp.getStackSize()>1?imp.getCurrentSlice():0;
+		for (int i=0; i<nPoints; i++) {
+			if (slice!=0 && slice!=positions[i])
+				continue;
+			sx2 = xp2[i]-halfSize; sy2=yp2[i]-halfSize;
+			if (sx>=sx2 && sx<=sx2+size && sy>=sy2 && sy<=sy2+size) {
+				handle = i;
+				break;
+			}
+		}
+		return handle;
+	}
+
+	/** Returns the points as an array of Points.
+	 * Wilhelm Burger: modified to use FloatPolygon for correct point positions.
+	*/
+	public Point[] getContainedPoints() {
+		FloatPolygon p = getFloatPolygon();
+		Point[] points = new Point[p.npoints];
+		for (int i=0; i<p.npoints; i++)
+			points[i] = new Point((int) Math.round(p.xpoints[i] - 0.5f), (int) Math.round(p.ypoints[i] - 0.5f));
+		return points;
+	}
+
+	/** Returns the points as a FloatPolygon. */
+	public FloatPolygon getContainedFloatPoints() {
+		return getFloatPolygon();
+	}
+
+	/**
+	 * Custom iterator for points contained in a {@link PointRoi}.
+	 * Author: W. Burger
+	*/
+	public Iterator<Point> iterator() {
+		return new Iterator<Point>() {
+			final Point[] pnts = getContainedPoints();
+			final int n = pnts.length;
+			int next = (n == 0) ? 1 : 0;
+			@Override
+			public boolean hasNext() {
+				return next < n;
+			}
+			@Override
+			public Point next() {
+				if (next >= n) {
+					throw new NoSuchElementException();
+				}
+				Point pnt = pnts[next];
+				next = next + 1;
+				return pnt;
+			}
+			@Override
+			public void remove() {
+				throw new UnsupportedOperationException();
+			}
+		};
+	}
+
+	@Override
+	protected int getClosestPoint(double x, double y, FloatPolygon points) {
+		int index = -1;
+		double distance = Double.MAX_VALUE;
+		int slice = imp!=null&&positions!=null&&imp.getStackSize()>1?imp.getCurrentSlice():0;
+		if (Prefs.showAllPoints)
+			slice = 0;
+		for (int i=0; i<points.npoints; i++) {
+			double dx = points.xpoints[i] - x;
+			double dy = points.ypoints[i] - y;
+			double distance2 = dx*dx+dy*dy;
+			if (distance2<distance && (slice==0||slice==positions[i])) {
+				distance = distance2;
+				index = i;
+			}
+		}
+		return index;
+	}
+
+	/** Returns a copy of this PointRoi. */
+	public synchronized Object clone() {
+		PointRoi r = (PointRoi)super.clone();
+		if (counters!=null) {
+			r.counters = new short[counters.length];
+			for (int i=0; i<counters.length; i++)
+				r.counters[i] = counters[i];
+		}
+		if (positions!=null) {
+			r.positions = new int[positions.length];
+			for (int i=0; i<positions.length; i++)
+				r.positions[i] = positions[i];
+		}
+		if (counts!=null) {
+			r.counts = new int[counts.length];
+			for (int i=0; i<counts.length; i++)
+				r.counts[i] = counts[i];
+		}
+		return r;
+	}
+
+	/* Returns a version of this PointRoi that only contains points inside 'roi'. */
+	public PointRoi crop(Roi roi) {
+		PointRoi points = (PointRoi)clone();
+		Polygon p = points.getPolygon();
+		for (int i=points.size()-1; i>=0; i--) {
+			if (!roi.contains(p.xpoints[i],p.ypoints[i])) {
+				points.deletePoint(i);
+			}
+		}
+		return points;
+	}
+
+	@Override
+	public void copyAttributes(Roi roi2) {
+		super.copyAttributes(roi2);
+		if (roi2 instanceof PointRoi) {
+			PointRoi p2 = (PointRoi)roi2;
+			this.type = p2.type;
+			this.size = p2.size;
+			this.showLabels = p2.showLabels;
+			this.fontSize = p2.fontSize;
+		}
+	}
+
+	public void setCounterInfo(int[] info) {
+		counterInfo = info;
+	}
+
+	public int[] getCounterInfo() {
+		return counterInfo;
+	}
+
+	public boolean addToOverlay() {
+		return addToOverlay;
+	}
+
+	public String toString() {
+		if (nPoints>1)
+			return ("Roi[Points, count="+nPoints+"]");
+		else
+			return ("Roi[Point, x="+x+", y="+y+"]");
+	}
+
+	/** @deprecated */
+	public void setHideLabels(boolean hideLabels) {
+		this.showLabels = !hideLabels;
+	}
+
+	/** @deprecated */
+	public static void setDefaultMarkerSize(String size) {
+	}
+
+	/** @deprecated */
+	public static String getDefaultMarkerSize() {
+		return sizes[defaultSize];
+	}
+
+	/** Deprecated */
+	public static void setDefaultCrossColor(Color color) {
+	}
+
+	/** Deprecated */
+	public static Color getDefaultCrossColor() {
+		return null;
+	}
+
+}
diff --git a/src/ij/gui/PolygonRoi.java b/src/ij/gui/PolygonRoi.java
new file mode 100644
index 0000000..0257ead
--- /dev/null
+++ b/src/ij/gui/PolygonRoi.java
@@ -0,0 +1,1701 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.frame.*;
+import ij.util.Tools;
+import ij.util.FloatArray;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.geom.*;
+import java.awt.event.*;
+
+/** This class represents a polygon region of interest or polyline of interest. */
+public class PolygonRoi extends Roi {
+
+	protected int maxPoints = 1000; // will be increased if necessary
+	protected int[] xp, yp;		    // image coordinates relative to origin of roi bounding box
+	protected float[] xpf, ypf;		// or alternative sub-pixel coordinates
+	protected int[] xp2, yp2;	    // absolute screen coordinates
+	protected int nPoints;
+	protected float[] xSpline,ySpline; // relative image coordinates
+	protected int splinePoints = 200;
+	Rectangle clip;
+
+	private double angle1, degrees=Double.NaN;
+	private int xClipMin, yClipMin, xClipMax, yClipMax;
+	private boolean userCreated;
+	private int boxSize = 8;
+
+	long mouseUpTime = 0;
+
+	/** Creates a new polygon or polyline ROI from x and y coordinate arrays.
+		Type must be Roi.POLYGON, Roi.FREEROI, Roi.TRACED_ROI, Roi.POLYLINE, Roi.FREELINE or Roi.ANGLE.*/
+	public PolygonRoi(int[] xPoints, int[] yPoints, int nPoints, int type) {
+		super(0, 0, null);
+		init1(nPoints, type);
+		xp = xPoints;
+		yp = yPoints;
+		if (type!=TRACED_ROI) {
+			xp = new int[nPoints];
+			yp = new int[nPoints];
+			for (int i=0; i<nPoints; i++) {
+				xp[i] = xPoints[i];
+				yp[i] = yPoints[i];
+			}
+		}
+		xp2 = new int[nPoints];
+		yp2 = new int[nPoints];
+		init2(type);
+	}
+
+	/** Creates a new polygon or polyline ROI from float x and y arrays.
+		Type must be Roi.POLYGON, Roi.FREEROI, Roi.POLYLINE, Roi.FREELINE or Roi.ANGLE.*/
+	public PolygonRoi(float[] xPoints, float[] yPoints, int nPoints, int type) {
+		super(0, 0, null);
+		init1(nPoints, type);
+		xpf = new float[nPoints];
+		ypf = new float[nPoints];
+		for (int i=0; i<nPoints; i++) {
+			xpf[i] = xPoints[i];
+			ypf[i] = yPoints[i];
+		}
+		enableSubPixelResolution();
+		xp2 = new int[nPoints];
+		yp2 = new int[nPoints];
+		init2(type);
+	}
+
+	/** Creates a new polygon or polyline ROI from float x and y arrays.
+		Type must be Roi.POLYGON, Roi.FREEROI, Roi.POLYLINE, Roi.FREELINE or Roi.ANGLE.*/
+	public PolygonRoi(float[] xPoints, float[] yPoints, int type) {
+		this(xPoints, yPoints, xPoints.length, type);
+	}
+
+	private void init1(int nPoints, int type) throws IllegalArgumentException{
+		maxPoints = nPoints;
+		this.nPoints = nPoints;
+		if (type==POLYGON)
+			this.type = POLYGON;
+		else if (type==FREEROI)
+			this.type = FREEROI;
+		else if (type==TRACED_ROI)
+			this.type = TRACED_ROI;
+		else if (type==POLYLINE)
+			this.type = POLYLINE;
+		else if (type==FREELINE)
+			this.type = FREELINE;
+		else if (type==ANGLE)
+			this.type = ANGLE;
+		else if (type==POINT)
+			this.type = POINT;
+		else
+			throw new IllegalArgumentException("PolygonRoi: Invalid type");
+	}
+
+	private void init2(int type) {
+		if (type==ANGLE && nPoints==3)
+			getAngleAsString();
+		if (type==POINT && Toolbar.getMultiPointMode()) {
+			Prefs.pointAutoMeasure = false;
+			Prefs.pointAutoNextSlice = false;
+			Prefs.pointAddToManager = false;
+			Prefs.pointAddToOverlay = false;
+			userCreated = true;
+		}
+		if (lineWidth>1 && isLine())
+			updateWideLine(lineWidth);
+		finishPolygon();
+	}
+
+	/** Creates a new polygon or polyline ROI from a Polygon. Type must be Roi.POLYGON,
+		Roi.FREEROI, Roi.TRACED_ROI, Roi.POLYLINE, Roi.FREELINE or Roi.ANGLE.*/
+	public PolygonRoi(Polygon p, int type) {
+		this(p.xpoints, p.ypoints, p.npoints, type);
+	}
+
+	/** Creates a new polygon or polyline ROI from a FloatPolygon. Type must be Roi.POLYGON,
+		Roi.FREEROI, Roi.TRACED_ROI, Roi.POLYLINE, Roi.FREELINE or Roi.ANGLE.*/
+	public PolygonRoi(FloatPolygon p, int type) {
+		this(p.xpoints, p.ypoints, p.npoints, type);
+	}
+
+	/** @deprecated */
+	public PolygonRoi(int[] xPoints, int[] yPoints, int nPoints, ImagePlus imp, int type) {
+		this(xPoints, yPoints, nPoints, type);
+		setImage(imp);
+	}
+
+	/** Starts the process of creating a new user-generated polygon or polyline ROI. */
+	public PolygonRoi(int sx, int sy, ImagePlus imp) {
+		super(sx, sy, imp);
+		int tool = Toolbar.getToolId();
+		switch (tool) {
+			case Toolbar.POLYGON:
+				type = POLYGON;
+				break;
+			case Toolbar.FREEROI:
+				type = FREEROI;
+				break;
+			case Toolbar.FREELINE:
+				type = FREELINE;
+				break;
+			case Toolbar.ANGLE:
+				type = ANGLE;
+				break;
+			default:
+				type = POLYLINE;
+				break;
+		}
+		if (magnificationForSubPixel())
+			enableSubPixelResolution();
+		previousSX = sx;
+		previousSY = sy;
+		x = offScreenX(sx);
+		y = offScreenY(sy);
+		startXD = offScreenXD(sx);
+		startYD = offScreenYD(sy);
+		if (subPixelResolution()) {
+			setLocation(startXD, startYD);
+			xpf = new float[maxPoints];
+			ypf = new float[maxPoints];
+			double xbase = getXBase();
+			double ybase = getYBase();
+			xpf[0] = (float)(startXD-xbase);
+			ypf[0] = (float)(startYD-ybase);
+			xpf[1] = xpf[0];
+			ypf[1] = ypf[0];
+		} else {
+			xp = new int[maxPoints];
+			yp = new int[maxPoints];
+		}
+		xp2 = new int[maxPoints];
+		yp2 = new int[maxPoints];
+		nPoints = 2;
+		width=1;
+		height=1;
+		clipX = x;
+		clipY = y;
+		clipWidth = 1;
+		clipHeight = 1;
+		state = CONSTRUCTING;
+		userCreated = true;
+		if (lineWidth>1 && isLine())
+			updateWideLine(lineWidth);
+		boxSize = (int)(boxSize*Prefs.getGuiScale());
+	}
+
+	private void drawStartBox(Graphics g) {
+		if (type!=ANGLE)
+			g.drawRect(screenXD(startXD)-4, screenYD(startYD)-4, 8, 8);
+	}
+
+	public void draw(Graphics g) {
+		updatePolygon();
+		Color color =  strokeColor!=null?strokeColor:ROIColor;
+		boolean hasHandles = xSpline!=null||type==POLYGON||type==POLYLINE||type==ANGLE;
+		boolean isActiveOverlayRoi = !overlay && isActiveOverlayRoi();
+		if (isActiveOverlayRoi) {
+			if (color==Color.cyan)
+				color = Color.magenta;
+			else
+				color = Color.cyan;
+		}
+		boolean fill = false;
+		mag = getMagnification();
+		if (fillColor!=null && !isLine() && state!=CONSTRUCTING) {
+			color = fillColor;
+			fill = true;
+		}
+		g.setColor(color);
+		Graphics2D g2d = (Graphics2D)g;
+		setRenderingHint(g2d);
+		if (stroke!=null && !isActiveOverlayRoi)
+			g2d.setStroke(getScaledStroke());
+		if (xSpline!=null) {
+			if (type==POLYLINE || type==FREELINE) {
+				drawSpline(g, xSpline, ySpline, splinePoints, false, fill, isActiveOverlayRoi);
+				if (wideLine && !overlay) {
+					g2d.setStroke(onePixelWide);
+					g.setColor(getColor());
+					drawSpline(g, xSpline, ySpline, splinePoints, false, fill, isActiveOverlayRoi);
+				}
+			} else
+				drawSpline(g, xSpline, ySpline, splinePoints, true, fill, isActiveOverlayRoi);
+		} else {
+			if (type==POLYLINE || type==FREELINE || type==ANGLE || state==CONSTRUCTING) {
+				g.drawPolyline(xp2, yp2, nPoints);
+				if (wideLine && !overlay) {
+					g2d.setStroke(onePixelWide);
+					g.setColor(getColor());
+					g.drawPolyline(xp2, yp2, nPoints);
+				}
+			} else {
+				if (fill) {
+					if (isActiveOverlayRoi) {
+						g.setColor(Color.cyan);
+						g.drawPolygon(xp2, yp2, nPoints);
+					} else
+						g.fillPolygon(xp2, yp2, nPoints);
+				} else
+					g.drawPolygon(xp2, yp2, nPoints);
+			 }
+			if (state==CONSTRUCTING && type!=FREEROI && type!=FREELINE)
+				drawStartBox(g);
+		}
+		if (hasHandles	&& clipboard==null && !overlay) {
+			if (activeHandle>0)
+				drawHandle(g, xp2[activeHandle-1], yp2[activeHandle-1]);
+			if (activeHandle<nPoints-1)
+				drawHandle(g, xp2[activeHandle+1], yp2[activeHandle+1]);
+			handleColor= strokeColor!=null? strokeColor:ROIColor; drawHandle(g, xp2[0], yp2[0]); handleColor=Color.white;
+			for (int i=1; i<nPoints; i++)
+				drawHandle(g, xp2[i], yp2[i]);
+		}
+		drawPreviousRoi(g);
+		if (!(state==MOVING_HANDLE||state==CONSTRUCTING||state==NORMAL))
+			showStatus();
+		if (updateFullWindow) {
+			updateFullWindow = false;
+			imp.draw();
+		}
+	}
+
+	private void drawSpline(Graphics g, float[] xpoints, float[] ypoints, int npoints, boolean closed, boolean fill, boolean isActiveOverlayRoi) {
+		if (xpoints==null || xpoints.length==0)
+			return;
+		boolean doScaling = (ic != null);	//quicker drawing if we don't need to convert to screen coordinates
+		if (ic!=null) {
+			Rectangle srcRect = ic.getSrcRect();
+			if (srcRect.x == 0 && srcRect.y == 0 && ic.getMagnification()==1.0)
+				doScaling = false;
+		}
+		double xd = getXBase();
+		double yd = getYBase();
+		Graphics2D g2d = (Graphics2D)g;
+		GeneralPath path = new GeneralPath();
+		path.moveTo(screenXD(xpoints[0]+xd), screenYD(ypoints[0]+yd));
+		if (doScaling) {
+			for (int i=1; i<npoints; i++)
+				path.lineTo(screenXD(xpoints[i]+xd), screenYD(ypoints[i]+yd));
+		} else {
+			double xd1 = xd, yd1 = yd;
+			if (useLineSubpixelConvention()) {xd1 += 0.5; yd1 += 0.5;}
+			for (int i=1; i<npoints; i++)
+				path.lineTo(xpoints[i]+xd1, ypoints[i]+yd1);
+		}
+		if (closed)
+			path.lineTo(screenXD(xpoints[0]+xd), screenYD(ypoints[0]+yd));
+		if (fill) {
+			if (isActiveOverlayRoi) {
+				g2d.setColor(Color.cyan);
+				g2d.draw(path);
+			} else
+				g2d.fill(path);
+		} else
+			g2d.draw(path);
+	}
+
+	public void drawPixels(ImageProcessor ip) {
+		int saveWidth = ip.getLineWidth();
+		if (getStrokeWidth()>1f)
+			ip.setLineWidth((int)Math.round(getStrokeWidth()));
+		double xbase = getXBase();
+		double ybase = getYBase();
+		if (xSpline!=null) {
+			ip.moveTo((int)Math.round(xbase+xSpline[0]), (int)Math.round(ybase+ySpline[0]));
+			for (int i=1; i<splinePoints; i++)
+				ip.lineTo((int)Math.round(xbase+xSpline[i]), (int)Math.round(ybase+ySpline[i]));
+			if (type==POLYGON || type==FREEROI || type==TRACED_ROI)  // close the shape
+				ip.lineTo((int)Math.round(xbase+xSpline[0]), (int)Math.round(ybase+ySpline[0]));
+		} else if (xpf!=null) {
+			ip.moveTo((int)Math.round(xbase+xpf[0]), (int)Math.round(ybase+ypf[0]));
+			for (int i=1; i<nPoints; i++)
+				ip.lineTo((int)Math.round(xbase+xpf[i]), (int)Math.round(ybase+ypf[i]));
+			if (type==POLYGON || type==FREEROI || type==TRACED_ROI)  // close the shape
+				ip.lineTo((int)Math.round(xbase+xpf[0]), (int)Math.round(ybase+ypf[0]));
+		} else {
+			ip.moveTo(x+xp[0], y+yp[0]);
+			for (int i=1; i<nPoints; i++)
+				ip.lineTo(x+xp[i], y+yp[i]);
+			if (type==POLYGON || type==FREEROI || type==TRACED_ROI)  // close the shape
+				ip.lineTo(x+xp[0], y+yp[0]);
+		}
+		ip.setLineWidth(saveWidth);
+		updateFullWindow = true;
+	}
+
+	protected void grow(int sx, int sy) {
+	// Overrides grow() in Roi class
+	}
+
+
+	protected void updatePolygon() {
+		int basex=0, basey=0;
+		if (ic!=null) {
+			Rectangle srcRect = ic.getSrcRect();
+			basex=srcRect.x; basey=srcRect.y;
+		}
+		double mag = getMagnification();
+		if (mag==1.0 && basex==0 && basey==0) {
+			if (xpf!=null) {
+				float xbase = (float)getXBase();
+				float ybase = (float)getYBase();
+				for (int i=0; i<nPoints; i++) {
+					xp2[i] = (int)Math.round(xpf[i]+xbase);
+					yp2[i] = (int)Math.round(ypf[i]+ybase);
+				}
+			} else {
+				for (int i=0; i<nPoints; i++) {
+					xp2[i] = xp[i]+x;
+					yp2[i] = yp[i]+y;
+				}
+			}
+		} else {
+			if (xpf!=null) {
+				float xbase = (float)getXBase();
+				float ybase = (float)getYBase();
+				for (int i=0; i<nPoints; i++) {
+					xp2[i] = screenXD(xpf[i]+xbase);
+					yp2[i] = screenYD(ypf[i]+ybase);
+				}
+			} else {
+				for (int i=0; i<nPoints; i++) {
+					xp2[i] = screenXD(xp[i]+x);
+					yp2[i] = screenYD(yp[i]+y);
+				}
+			}
+		}
+	}
+
+	public void mouseMoved(MouseEvent e) {
+		int sx = e.getX();
+		int sy = e.getY();
+		int flags = e.getModifiers();
+		constrain = (flags&Event.SHIFT_MASK)!=0;
+		if (constrain) {  // constrain in 90deg steps
+			int dx = sx - previousSX;
+			int dy = sy - previousSY;
+			if (Math.abs(dx) > Math.abs(dy))
+				dy = 0;
+			else
+				dx = 0;
+			sx = previousSX + dx;
+			sy = previousSY + dy;
+		}
+
+		// Do rubber banding
+		int tool = Toolbar.getToolId();
+		if (!(tool==Toolbar.POLYGON || tool==Toolbar.POLYLINE || tool==Toolbar.ANGLE)) {
+			imp.deleteRoi();
+			imp.draw();
+			return;
+		}
+		if (IJ.altKeyDown())
+			wipeBack();
+
+		drawRubberBand(sx, sy);
+
+		// show status: length & angle
+		degrees = Double.NaN;
+		double len = -1;
+		if (nPoints>1) {
+			double x1, y1, x2, y2;
+			if (xpf!=null) {
+				x1 = xpf[nPoints-2];
+				y1 = ypf[nPoints-2];
+				x2 = xpf[nPoints-1];
+				y2 = ypf[nPoints-1];
+			} else {
+				x1 = xp[nPoints-2];
+				y1 = yp[nPoints-2];
+				x2 = xp[nPoints-1];
+				y2 = yp[nPoints-1];
+			}
+			degrees = getFloatAngle(x1, y1, x2, y2);
+			if (tool!=Toolbar.ANGLE) {
+				Calibration cal = imp.getCalibration();
+				double pw=cal.pixelWidth, ph=cal.pixelHeight;
+				if (IJ.altKeyDown()) {pw=1.0; ph=1.0;}
+				len = Math.sqrt((x2-x1)*pw*(x2-x1)*pw + (y2-y1)*ph*(y2-y1)*ph);
+			}
+		}
+		if (tool==Toolbar.ANGLE) {
+			if (nPoints==2)
+				angle1 = degrees;
+			else if (nPoints==3) {
+				double angle2 = xpf != null ? getFloatAngle(xpf[1], ypf[1], xpf[2], ypf[2]) :
+						getAngle(xp[1], yp[1], xp[2], yp[2]);
+				degrees = Math.abs(180-Math.abs(angle1-angle2));
+				if (degrees>180.0)
+					degrees = 360.0-degrees;
+			}
+		}
+		String length = len!=-1?", length=" + IJ.d2s(len):"";
+		double degrees2 = tool==Toolbar.ANGLE&&nPoints==3&&Prefs.reflexAngle?360.0-degrees:degrees;
+		String angle = !Double.isNaN(degrees)?", angle=" + IJ.d2s(degrees2):"";
+		int ox = ic.offScreenX(sx);
+		int oy = ic.offScreenY(sy);
+		IJ.showStatus(imp.getLocationAsString(ox,oy) + length + angle);
+	}
+
+	//Mouse behaves like an eraser when moved backwards with alt key down.
+	//Within correction circle, all vertices with sharp angles are removed.
+	//Norbert Vischer
+	protected void wipeBack() {
+		Roi prevRoi = Roi.getPreviousRoi();
+		if (prevRoi!=null && prevRoi.modState==SUBTRACT_FROM_ROI)
+			return;
+		double correctionRadius = 20;
+		if (ic!=null)
+			correctionRadius /= ic.getMagnification();
+		boolean found = false;
+		int p3 = nPoints - 1;
+		int p1 = p3;
+		while (p1 > 0 && !found) {
+			p1--;
+			double dx = xpf != null ? xpf[p3] - xpf[p1] : xp[p3] - xp[p1];
+			double dy = xpf != null ? ypf[p3] - ypf[p1] : yp[p3] - yp[p1];
+			double dist = Math.sqrt(dx * dx + dy * dy);
+			if (dist > correctionRadius)
+				found = true;
+		}
+		//examine all angles p1-p2-p3
+		boolean killed = false;
+		int safety = 10; //don't delete more than this number of points at once
+		do {
+			killed = false;
+			safety--;
+			for (int p2 = p1 + 1; p2 < p3; p2++) {
+				double dx1 = xpf != null ? xpf[p2] - xpf[p1] : xp[p2] - xp[p1];
+				double dy1 = xpf != null ? ypf[p2] - ypf[p1] : yp[p2] - yp[p1];
+				double dx2 = xpf != null ? xpf[p3] - xpf[p1] : xp[p3] - xp[p1];
+				double dy2 = xpf != null ? ypf[p3] - ypf[p1] : yp[p3] - yp[p1];
+				double kk = 1;//allowed sharpness
+				if (this instanceof FreehandRoi)
+					kk = 0.8;
+				if ((dx1 * dx1 + dy1 * dy1) > kk * (dx2 * dx2 + dy2 * dy2)) {
+					if (xpf != null) {
+						xpf[p2] = xpf[p3]; ypf[p2] = ypf[p3]; //replace sharp vertex with end point
+					} else {
+						xp[p2] = xp[p3]; yp[p2] = yp[p3];
+					}
+					p3 = p2;
+					nPoints = p2 + 1; //shorten array
+					killed = true;
+				}
+			}
+		} while (killed && safety > 0);
+	}
+
+	void drawRubberBand(int sx, int sy) {
+		double oxd = offScreenXD(sx);
+		double oyd = offScreenYD(sy);
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		int x1, y1, x2, y2;
+		if (xpf!=null) {
+			x1 = (int)xpf[nPoints-2]+x;
+			y1 = (int)ypf[nPoints-2]+y;
+			x2 = (int)xpf[nPoints-1]+x;
+			y2 = (int)ypf[nPoints-1]+y;
+		} else {
+			x1 = xp[nPoints-2]+x;
+			y1 = yp[nPoints-2]+y;
+			x2 = xp[nPoints-1]+x;
+			y2 = yp[nPoints-1]+y;
+		}
+		int xmin=Integer.MAX_VALUE, ymin=Integer.MAX_VALUE, xmax=0, ymax=0;
+		if (x1<xmin) xmin=x1;
+		if (x2<xmin) xmin=x2;
+		if (ox<xmin) xmin=ox;
+		if (x1>xmax) xmax=x1;
+		if (x2>xmax) xmax=x2;
+		if (ox>xmax) xmax=ox;
+		if (y1<ymin) ymin=y1;
+		if (y2<ymin) ymin=y2;
+		if (oy<ymin) ymin=oy;
+		if (y1>ymax) ymax=y1;
+		if (y2>ymax) ymax=y2;
+		if (oy>ymax) ymax=oy;
+		int margin = boxSize;
+		if (ic!=null) {
+			double mag = ic.getMagnification();
+			if (mag<1.0) margin = (int)(margin/mag);
+		}
+		margin = (int)(margin+getStrokeWidth());
+		if (IJ.altKeyDown())
+			margin+=20;
+		if (xpf!=null) {
+			xpf[nPoints-1] = (float)(oxd-getXBase());
+			ypf[nPoints-1] = (float)(oyd-getYBase());
+		} else {
+			xp[nPoints-1] = ox-x;
+			yp[nPoints-1] = oy-y;
+		}
+		if (type==POLYLINE && Prefs.splineFitLines) {
+			fitSpline();
+			imp.draw();
+		} else
+			imp.draw(xmin-margin, ymin-margin, (xmax-xmin)+margin*2, (ymax-ymin)+margin*2);
+	}
+
+	void finishPolygon() {
+		if (xpf!=null) {
+			double xbase0 = getXBase();
+			double ybase0 = getYBase();
+			FloatPolygon poly = new FloatPolygon(xpf, ypf, nPoints);
+			bounds = poly.getFloatBounds();
+			for (int i=0; i<nPoints; i++) {         //xpf, ypf have lowest value of 0.0 sharp
+				xpf[i] -= (float)bounds.x;          //(bounds.x, bounds.y will be adjusted accordingly)
+				ypf[i] -= (float)bounds.y;
+			}
+			if (xSpline!=null) {
+				for (int i=0; i<splinePoints; i++) {
+					xSpline[i] += (float)(xbase0 - bounds.x);
+					ySpline[i] += (float)(ybase0 - bounds.y);
+				}
+			}
+			setIntBounds(bounds);                   //all points must be within the integer bounding rectangle
+		} else {
+			Polygon poly = new Polygon(xp, yp, nPoints);
+			Rectangle r = poly.getBounds();
+			x = r.x;
+			y = r.y;
+			width = r.width;
+			height = r.height;
+			for (int i=0; i<nPoints; i++) {
+				xp[i] = xp[i]-x;
+				yp[i] = yp[i]-y;
+			}
+			if (useLineSubpixelConvention()) {
+				width++; height++;   //for open polylines & PointRois, include the pixels affected by 'draw'
+			}
+			bounds = null;
+		}
+		if (nPoints<2 || (!(type==FREELINE||type==POLYLINE||type==ANGLE) && (nPoints<3||width==0||height==0))) {
+			if (imp!=null) imp.deleteRoi();
+			if (type!=POINT) return;
+		}
+		state = NORMAL;
+		if (imp!=null && !(type==TRACED_ROI))
+			imp.draw(x-5, y-5, width+10, height+10);
+		oldX=x; oldY=y; oldWidth=width; oldHeight=height;
+		if (Recorder.record && userCreated && (type==POLYGON||type==POLYLINE||type==ANGLE
+		||(type==POINT&&Recorder.scriptMode()&&nPoints==3)))
+			Recorder.recordRoi(getPolygon(), type);
+		if (type!=POINT) modifyRoi();
+		LineWidthAdjuster.update();
+		notifyListeners(RoiListener.COMPLETED);
+		updateFullWindow = true;
+	}
+
+	public void exitConstructingMode() {
+		if (type==POLYLINE && state==CONSTRUCTING) {
+			addOffset();
+			finishPolygon();
+		}
+	}
+
+	protected void moveHandle(int sx, int sy) {
+		if (constrain) {  // constrain in 90deg steps
+			int dx = sx - previousSX;
+			int dy = sy - previousSY;
+			if (Math.abs(dx) > Math.abs(dy))
+				dy = 0;
+			else
+				dx = 0;
+			sx = previousSX + dx;
+			sy = previousSY + dy;
+		}
+
+		if (clipboard!=null) return;
+
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		if (xpf!=null) {
+			xpf[activeHandle] = (float)(offScreenXD(sx)-getXBase());
+			ypf[activeHandle] = (float)(offScreenYD(sy)-getYBase());
+		} else {
+			xp[activeHandle] = ox-x;
+			yp[activeHandle] = oy-y;
+		}
+		if (xSpline!=null) {
+			fitSpline(splinePoints);
+			imp.draw();
+		} else {
+			if (!subPixelResolution() || (type==POINT&&nPoints==1))
+				resetBoundingRect();
+			if (type==POINT && width==0 && height==0)
+				{width=1; height=1;}
+			updateClipRectAndDraw();
+		}
+		String angle = type==ANGLE?getAngleAsString():"";
+		IJ.showStatus(imp.getLocationAsString(ox,oy) + angle);
+	}
+
+   /** After handle is moved, find clip rect and repaint. */
+   void updateClipRectAndDraw() {
+		if (xpf!=null) {
+			xp = toInt(xpf, xp, nPoints);
+			yp = toInt(ypf, yp, nPoints);
+		}
+		int xmin=Integer.MAX_VALUE, ymin=Integer.MAX_VALUE, xmax=0, ymax=0;
+		int x2, y2;
+		if (activeHandle>0)
+		   {x2=x+xp[activeHandle-1]; y2=y+yp[activeHandle-1];}
+		else
+		   {x2=x+xp[nPoints-1]; y2=y+yp[nPoints-1];}
+		if (x2<xmin) xmin = x2;
+		if (y2<ymin) ymin = y2;
+		if (x2>xmax) xmax = x2;
+		if (y2>ymax) ymax = y2;
+		x2=x+xp[activeHandle]; y2=y+yp[activeHandle];
+		if (x2<xmin) xmin = x2;
+		if (y2<ymin) ymin = y2;
+		if (x2>xmax) xmax = x2;
+		if (y2>ymax) ymax = y2;
+		if (activeHandle<nPoints-1)
+		   {x2=x+xp[activeHandle+1]; y2=y+yp[activeHandle+1];}
+		else
+		   {x2=x+xp[0]; y2=y+yp[0];}
+		if (x2<xmin) xmin = x2;
+		if (y2<ymin) ymin = y2;
+		if (x2>xmax) xmax = x2;
+		if (y2>ymax) ymax = y2;
+		int xmin2=xmin, ymin2=ymin, xmax2=xmax, ymax2=ymax;
+		if (xClipMin<xmin2) xmin2 = xClipMin;
+		if (yClipMin<ymin2) ymin2 = yClipMin;
+		if (xClipMax>xmax2) xmax2 = xClipMax;
+		if (yClipMax>ymax2) ymax2 = yClipMax;
+		xClipMin=xmin; yClipMin=ymin; xClipMax=xmax; yClipMax=ymax;
+		double mag = ic.getMagnification();
+		int handleSize = type==POINT?getHandleSize()+25:getHandleSize();
+		double strokeWidth = getStrokeWidth();
+		if (strokeWidth<1.0) strokeWidth=1.0;
+		if (handleSize<strokeWidth && isLine())
+			handleSize = (int)strokeWidth;
+		int m = mag<1.0?(int)(handleSize/mag):handleSize;
+		m = (int)(m*strokeWidth);
+		imp.draw(xmin2-m, ymin2-m, xmax2-xmin2+m*2, ymax2-ymin2+m*2);
+	}
+
+	protected void resetBoundingRect() {
+		//IJ.log("resetBoundingRect");
+		if (xpf!=null) {
+			resetSubPixelBoundingRect();
+			xp = toInt(xpf, xp, nPoints);
+			yp = toInt(ypf, yp, nPoints);
+			return;
+		}
+		int xmin=Integer.MAX_VALUE, xmax=-xmin, ymin=xmin, ymax=xmax;
+		int xx, yy;
+		for (int i=0; i<nPoints; i++) {
+			xx = xp[i];
+			if (xx<xmin) xmin=xx;
+			if (xx>xmax) xmax=xx;
+			yy = yp[i];
+			if (yy<ymin) ymin=yy;
+			if (yy>ymax) ymax=yy;
+		}
+		if (xmin!=0) {
+			for (int i=0; i<nPoints; i++)
+				xp[i] -= xmin;
+		}
+		if (ymin!=0) {
+			for (int i=0; i<nPoints; i++)
+				yp[i] -= ymin;
+		}
+		//IJ.log("reset: "+ymin+" "+before+" "+yp[0]);
+		x+=xmin; y+=ymin;
+		width=xmax-xmin; height=ymax-ymin;
+		if (useLineSubpixelConvention()) {
+			width++; height++;    //for open polylines & PointRois, include the pixels affected by 'draw'
+		}
+		bounds = null;
+	}
+
+	private void resetSubPixelBoundingRect() {
+		//IJ.log("resetSubPixelBoundingRect: "+state+" "+bounds);
+		if (xSpline!=null) {
+			resetSplineFitBoundingRect();
+			return;
+		}
+		float xbase = (float)getXBase();
+		float ybase = (float)getYBase();
+		for (int i=0; i<nPoints; i++) {
+			xpf[i] = xpf[i]+xbase;
+			ypf[i] = ypf[i]+ybase;
+		}
+		FloatPolygon poly = new FloatPolygon(xpf, ypf, nPoints);
+		bounds = poly.getFloatBounds();
+		setIntBounds(bounds);
+		xbase = (float)bounds.x;
+		ybase = (float)bounds.y;
+		for (int i=0; i<nPoints; i++) {
+			xpf[i] -= xbase;
+			ypf[i] -= ybase;
+		}
+	}
+
+	private void resetSplineFitBoundingRect() {
+		if (splinePoints==0)
+			return;
+		float xbase = (float)getXBase();
+		float ybase = (float)getYBase();
+		float xSpline0 = xSpline[0];
+		float ySpline0 = ySpline[0];
+		for (int i=0; i<splinePoints; i++) {
+			xSpline[i] = xSpline[i]+xbase;
+			ySpline[i] = ySpline[i]+ybase;
+		}
+		FloatPolygon poly = new FloatPolygon(xSpline, ySpline, splinePoints);
+		bounds = poly.getFloatBounds();
+		setIntBounds(bounds);
+		xbase = (float)bounds.x;
+		ybase = (float)bounds.y;
+		for (int i=0; i<splinePoints; i++) {
+			xSpline[i] -= xbase;
+			ySpline[i] -= ybase;
+		}
+		for (int i=0; i<nPoints; i++) {
+			xpf[i] -= xSpline0 - xSpline[0];
+			ypf[i] -= ySpline0 - ySpline[0];
+		}
+	}
+
+	String getAngleAsString() {
+		double angle1 = 0.0;
+		double angle2 = 0.0;
+		if (xpf!=null) {
+			angle1 = getFloatAngle(xpf[0], ypf[0], xpf[1], ypf[1]);
+			angle2 = getFloatAngle(xpf[1], ypf[1], xpf[2], ypf[2]);
+		} else {
+			angle1 = getFloatAngle(xp[0], yp[0], xp[1], yp[1]);
+			angle2 = getFloatAngle(xp[1], yp[1], xp[2], yp[2]);
+		}
+		degrees = Math.abs(180-Math.abs(angle1-angle2));
+		if (degrees>180.0)
+			degrees = 360.0-degrees;
+		double degrees2 = Prefs.reflexAngle&&type==ANGLE?360.0-degrees:degrees;
+		return ", angle=" + IJ.d2s(degrees2);
+	}
+
+   protected void mouseDownInHandle(int handle, int sx, int sy) {
+		if (state==CONSTRUCTING)
+			return;
+		int ox = offScreenX(sx);
+		int oy = offScreenY(sy);
+		double oxd = offScreenXD(sx);
+		double oyd = offScreenYD(sy);
+		if ((IJ.altKeyDown()||IJ.controlKeyDown()) && !(nPoints<=3 && type!=POINT) && !(this instanceof RotatedRectRoi)) {
+			deleteHandle(oxd, oyd);
+			return;
+		} else if (IJ.shiftKeyDown() && type!=POINT && !(this instanceof RotatedRectRoi)) {
+			addHandle(oxd, oyd);
+			return;
+		}
+		super.mouseDownInHandle(handle, sx, sy); //sets state, activeHandle, previousSX&Y
+		int m = ic!=null?(int)(10.0/ic.getMagnification()):1;
+		xClipMin=ox-m; yClipMin=oy-m; xClipMax=ox+m; yClipMax=oy+m;
+	}
+
+	public void deleteHandle(double ox, double oy) {
+		if (imp==null)
+			return;
+		if (nPoints<=1) {
+			imp.deleteRoi();
+			return;
+		}
+		boolean splineFit = xSpline!=null;
+		if (splineFit)
+			removeSplineFit();
+		FloatPolygon points = getFloatPolygon();
+		int pointToDelete = getClosestPoint(ox, oy, points);
+		if (pointToDelete>=0) {
+			deletePoint(pointToDelete);
+			if (splineFit)
+				fitSpline(splinePoints);
+			imp.draw();
+		}
+	}
+
+	protected void deletePoint(int index) {
+		if (index<0 || index>=nPoints)
+			return;
+		for (int i=index; i<nPoints-1; i++) {
+			if (xp!=null) {
+				xp[i] = xp[i+1];
+				yp[i] = yp[i+1];
+			}
+			if (xp2!=null) {
+				xp2[i] = xp2[i+1];
+				yp2[i] = yp2[i+1];
+			}
+			if (xpf!=null) {
+				xpf[i] = xpf[i+1];
+				ypf[i] = ypf[i+1];
+			}
+		}
+		nPoints--;
+	}
+
+	void addHandle(double ox, double oy) {
+		if (imp==null || type==ANGLE) return;
+		boolean splineFit = xSpline != null;
+		xSpline = null;
+		FloatPolygon points = getFloatPolygon();
+		int n = points.npoints;
+		modState = NO_MODS;
+		Roi prevRoi = Roi.getPreviousRoi();
+		if (prevRoi!=null) prevRoi.modState = NO_MODS;
+		int pointToDuplicate = getClosestPoint(ox, oy, points);
+		if (pointToDuplicate<0)
+			return;
+		FloatPolygon points2 = new FloatPolygon();
+		for (int i2=0; i2<n; i2++) {
+			if (i2==pointToDuplicate) {
+				int i1 = i2-1;
+				if (i1==-1) i1 = isLine()?i2:n-1;
+				int i3 = i2+1;
+				if (i3==n) i3 = isLine()?i2:0;
+				double x1 = points.xpoints[i1]	+ 2*(points.xpoints[i2] - points.xpoints[i1])/3;
+				double y1 = points.ypoints[i1] + 2*(points.ypoints[i2] - points.ypoints[i1])/3;
+				double x2 = points.xpoints[i2] + (points.xpoints[i3] - points.xpoints[i2])/3;
+				double y2 = points.ypoints[i2] + (points.ypoints[i3] - points.ypoints[i2])/3;
+				points2.addPoint(x1, y1);
+				points2.addPoint(x2, y2);
+			} else
+				points2.addPoint(points.xpoints[i2], points.ypoints[i2]);
+		}
+		if (type==POINT)
+			imp.setRoi(new PointRoi(points2));
+		else {
+			setPolygon(points2);
+			if (splineFit)
+				fitSpline(splinePoints);
+			if (imp!=null) imp.draw();
+		}
+	}
+
+	private void setPolygon(FloatPolygon p2) {
+		nPoints = p2.npoints;
+		if (nPoints>=maxPoints)
+			enlargeArrays();
+		float xbase = (float)getXBase();
+		float ybase = (float)getYBase();
+		if (xp==null) {
+			xp = new int[maxPoints];
+			yp = new int[maxPoints];
+		}
+		for (int i=0; i<nPoints; i++) {
+			xp[i] = (int)(p2.xpoints[i]-x);
+			yp[i] = (int)(p2.ypoints[i]-y);
+			if (xpf!=null) {
+				xpf[i] = p2.xpoints[i] - xbase;
+				ypf[i] = p2.ypoints[i] - ybase;
+			}
+		}
+	}
+
+	protected int getClosestPoint(double x, double y, FloatPolygon points) {
+		int index = -1;
+		double distance = Double.MAX_VALUE;
+		for (int i=0; i<points.npoints; i++) {
+			double dx = points.xpoints[i] - x;
+			double dy = points.ypoints[i] - y;
+			double distance2 = dx*dx+dy*dy;
+			if (distance2<distance) {
+				distance = distance2;
+				index = i;
+			}
+		}
+		return index;
+	}
+
+	/** Fits a spline, which becomes the new shape of this Roi */
+	public void fitSpline(int evaluationPoints) {
+		float[][] spline = getSpline(evaluationPoints, xSpline, ySpline);
+		setSpline(spline[0], spline[1]);
+	}
+
+	/** Sets the spline as a new shape of this Roi */
+	void setSpline(float[] xSpline, float[] ySpline) {
+		this.xSpline = xSpline;
+		this.ySpline = ySpline;
+		splinePoints = xSpline.length;
+		cachedMask = null;
+		// update protected xp and yp arrays for backward compatibility
+		xp = toInt(xpf, xp, nPoints);
+		yp = toInt(ypf, yp, nPoints);
+		if (state==NORMAL)
+			resetBoundingRect();
+	}
+
+	/** Fits a spline, but leaves the Roi unchanged.
+	 *  The arrays supplied (which may be null) are reused if the number of spline
+	 *  points remains unchanged.
+	 *  @return Arrays of x coordinates and y coordinates */
+	float[][] getSpline(int evaluationPoints, float[] xSpline, float[] ySpline) {
+		if (xpf==null) {
+			xpf = toFloat(xp);
+			ypf = toFloat(yp);
+			enableSubPixelResolution();
+		}
+		if (xSpline==null || xSpline.length!=evaluationPoints)
+			xSpline = new float[evaluationPoints];
+		if (ySpline==null || ySpline.length!=evaluationPoints)
+			ySpline = new float[evaluationPoints];
+		int nNodes = isLine() ? nPoints : nPoints+1;
+		double length = getUncalibratedLength();
+		float[] nodePositions = new float[nNodes];
+		float lastNodePosition = 0f;		//independent coordinate for x & y-splines,
+		nodePositions[0] = 0f;				//incremented by the sqrt of the distance between points
+		for (int i=1; i<nPoints; i++) {
+			float dx = xpf[i] - xpf[i-1];
+			float dy = ypf[i] - ypf[i-1];
+			float dLength = (float)Math.sqrt(Math.sqrt(dx*dx+dy*dy));
+			if (dLength < 0.001f) dLength = 0.001f; //avoid numerical problems with duplicate points
+			lastNodePosition += dLength;
+			nodePositions[i] = lastNodePosition;
+		}
+		if (!isLine()) {					//closed polygon: close the line
+			float dx = xpf[nPoints-1] - xpf[0];
+			float dy = ypf[nPoints-1] - ypf[0];
+			float dLength = (float)Math.sqrt(Math.sqrt(dx*dx+dy*dy));
+			if (dLength < 0.001f) dLength = 0.001f;
+			lastNodePosition += dLength;
+			nodePositions[nNodes-1] = lastNodePosition;
+			if (xpf.length < nNodes) enlargeArrays(nNodes);
+			xpf[nNodes-1] = xpf[0];
+			ypf[nNodes-1] = ypf[0];
+		}
+		SplineFitter sfx = new SplineFitter(nodePositions, xpf, nNodes, !isLine());
+		SplineFitter sfy = new SplineFitter(nodePositions, ypf, nNodes, !isLine());
+
+		// Evaluate the splines at all points
+		double scale = (double)lastNodePosition/(evaluationPoints-1);
+		for(int i=0; i<evaluationPoints; i++) {
+			double xvalue = i*scale;
+			xSpline[i] = (float)sfx.evalSpline(xvalue);
+			ySpline[i] = (float)sfy.evalSpline(xvalue);
+		}
+		return new float[][] {xSpline, ySpline};
+	}
+
+	/** Fits a spline, which becomes the new shape of this Roi */
+	public void fitSpline() {
+		double length = getUncalibratedLength();
+		int evaluationPoints = (int)(length/2.0);
+		if (ic!=null) {
+			double mag = ic.getMagnification();
+			if (mag<1.0)
+				evaluationPoints *= mag;;
+		}
+		if (evaluationPoints<100)
+			evaluationPoints = 100;
+		fitSpline(evaluationPoints);
+	}
+
+	public void removeSplineFit() {
+		xSpline = null;
+		ySpline = null;
+	}
+
+	/** Returns 'true' if this selection has been fitted with a spline. */
+	public boolean isSplineFit() {
+		return xSpline!=null;
+	}
+
+	/** Creates a spline fitted polygon with (roughly) one pixel segment lengths
+		and sets it as the Roi shape.
+		It can be retrieved using the getFloatPolygon() method. */
+	public void fitSplineForStraightening() {
+		 //create preliminary finer splines with half-pixel steps (these do not change asynchronously)
+		float[][] spline = getSpline((int)(getUncalibratedLength()*2)+1, null, null);
+		spline = getEquidistantPoints(spline[0], spline[1], spline[0].length, 1.0, null);
+		setSpline(spline[0], spline[1]);
+	}
+
+	/** Interpolates an open polgonial shape to get line segments of (roughly) length 'segmentLength',
+	 *  and returns arrays of x & y coordinates.
+	 *  Since the full length is not necessarily an integer multiple of 'segmentLength',
+	 *  the segmentLength actually used is returned as array element [2][0].
+	 *  If the ImagePlus is given, calibrated coordinates are used, based on its calibration,
+	 *  and 'segmentLength' should be in calibrated units.
+	 *  Returns null if an input array is null, or the number of points is 0 */
+	static float[][] getEquidistantPoints(float[] xpoints, float[] ypoints, int npoints, double segmentLength, ImagePlus imp) {
+		if (xpoints==null || xpoints==null || npoints <= 0) return null;
+		if (xpoints.length < npoints) npoints = xpoints.length;	// arguments might be inconsistent due to asynchronous modification
+		if (ypoints.length < npoints) npoints = ypoints.length;
+		double length = getLength(xpoints, ypoints, npoints, /*closeShape=*/false, imp);
+		int npOut = (int)Math.round(length/segmentLength)+1;
+		double step = length/(npOut-1);                  //as close to one pixel as we can get
+		float[] xpOut = new float[npOut];
+		float[] ypOut = new float[npOut];
+		double pixelWidth = 1.0, pixelHeight = 1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pixelWidth = cal.pixelWidth;
+			pixelHeight = cal.pixelHeight;
+		}
+		xpOut[0] = xpoints[0];
+		ypOut[0] = ypoints[0];
+		double lengthRead = 0;   //total arc length read from the preliminary spline
+		int pointsWritten = 1;
+		double x1, y1;
+		double x2 = xpoints[0], y2 = ypoints[0];
+		for (int i=1; i<npoints; i++) {
+			x1=x2; y1=y2;
+			x2=xpoints[i]; y2=ypoints[i];
+			double dx = x2-x1;
+			double dy = y2-y1;
+			double distance = Math.sqrt(sqr(dx*pixelWidth) + sqr(dy*pixelHeight));
+			lengthRead += distance;
+			double distanceOverNextWrite = lengthRead - pointsWritten*step;
+			while ((distanceOverNextWrite >= 0.0 || i==npoints-1) && pointsWritten < npOut) {  // we have to write a new point
+				double fractionOverNextWrite = distanceOverNextWrite/distance;
+				if (distance==0) fractionOverNextWrite = 0;
+				//IJ.log("i="+i+" n="+pointsWritten+"/"+npOut+" leng="+IJ.d2s(lengthRead)+"/"+IJ.d2s(length)+" done="+IJ.d2s(pointsWritten*step)+" over="+IJ.d2s(fractionOverNextWrite)+" x,y="+IJ.d2s(x2 - fractionOverNextWrite*dx)+","+IJ.d2s(y2 - fractionOverNextWrite*dy));
+				xpOut[pointsWritten] = (float)(x2 - fractionOverNextWrite*dx);
+				ypOut[pointsWritten] = (float)(y2 - fractionOverNextWrite*dy);
+				distanceOverNextWrite -= step;
+				pointsWritten++;
+			}
+		}
+		return new float[][] {xpOut, ypOut, new float[] {(float)step}};
+	}
+
+	/** With segmented selections, ignore first mouse up and finalize
+		when user double-clicks, control-clicks or clicks in start box. */
+	protected void handleMouseUp(int sx, int sy) {
+		if (state==MOVING) {
+			state = NORMAL;
+			return;
+		}
+		if (state==MOVING_HANDLE) {
+			cachedMask = null; //mask is no longer valid
+			state = NORMAL;
+			updateClipRect();
+			oldX=x; oldY=y;
+			oldWidth=width; oldHeight=height;
+			if (subPixelResolution())
+				resetBoundingRect();
+			return;
+		}
+		if (state!=CONSTRUCTING)
+			return;
+		if (IJ.spaceBarDown()) // is user scrolling image?
+			return;
+		boolean samePoint = false;
+		if (xpf!=null)
+			samePoint = (xpf[nPoints-2]==xpf[nPoints-1] && ypf[nPoints-2]==ypf[nPoints-1]);
+		else
+			samePoint = (xp[nPoints-2]==xp[nPoints-1] && yp[nPoints-2]==yp[nPoints-1]);
+		boolean doubleClick = (System.currentTimeMillis()-mouseUpTime)<=300;
+		int size = boxSize+2;
+		int size2 = boxSize/2 +1;
+		Rectangle biggerStartBox = new Rectangle(screenXD(startXD)-5, screenYD(startYD)-5, 10, 10);
+		if (nPoints>2 && (biggerStartBox.contains(sx, sy)
+		|| (offScreenXD(sx)==startXD && offScreenYD(sy)==startYD)
+		|| (samePoint && doubleClick))) {
+			boolean okayToFinish = true;
+			if (type==POLYGON && samePoint && doubleClick && nPoints>25) {
+				okayToFinish = IJ.showMessageWithCancel("Polygon Tool", "Complete the selection?");
+			}
+			if (okayToFinish) {
+				nPoints--;
+				addOffset();
+				finishPolygon();
+				return;
+			}
+		} else if (!samePoint) {
+			mouseUpTime = System.currentTimeMillis();
+			if (type==ANGLE && nPoints==3) {
+				addOffset();
+				finishPolygon();
+				return;
+			}
+			//add point to polygon
+			if (xpf!=null) {
+				xpf[nPoints] = xpf[nPoints-1];
+				ypf[nPoints] = ypf[nPoints-1];
+				nPoints++;
+				if (nPoints==xpf.length)
+					enlargeArrays();
+			} else {
+				xp[nPoints] = xp[nPoints-1];
+				yp[nPoints] = yp[nPoints-1];
+				nPoints++;
+				if (nPoints==xp.length)
+					enlargeArrays();
+			}
+			if (constrain) {  // this point was constrained in 90deg steps; correct coordinates
+				int dx = sx - previousSX;
+				int dy = sy - previousSY;
+				if (Math.abs(dx) > Math.abs(dy))
+					dy = 0;
+				else
+					dx = 0;
+				sx = previousSX + dx;
+				sy = previousSY + dy;
+			}
+			previousSX = sx;  //save for constraining next line if desired
+			previousSY = sy;
+			notifyListeners(RoiListener.EXTENDED);
+		}
+	}
+
+	protected void addOffset() {
+		if (xpf!=null) {
+			float xbase = (float)getXBase();
+			float ybase = (float)getYBase();
+			for (int i=0; i<nPoints; i++) {
+				xpf[i] = xpf[i]+xbase;
+				ypf[i] = ypf[i]+ybase;
+			}
+		} else {
+			for (int i=0; i<nPoints; i++) {
+				xp[i] = xp[i]+x;
+				yp[i] = yp[i]+y;
+			}
+		}
+	}
+	/** Returns whether the center of pixel (x,y) is contained in the Roi.
+	 *  The position of a pixel center determines whether a pixel is selected.
+	 *  Note the ImageJ convention of 0.5 pixel shift between outline and pixel centers,
+	 *  i.e., pixel (0,0) is enclosed by the rectangle spanned between (0,0) and (1,1).
+	 *  Points exactly at the left (right) border are considered outside (inside);
+	 *  points exactly on horizontal borders, are considered outside (inside) at the border
+	 *  with the lower (higher) y.
+	 *  This convention is opposite to that of the java.awt.Shape class.
+	 *  In x, the offset is chosen slightly below 0.5 to reduce the impact of numerical
+	 *  errors. */
+	public boolean contains(int x, int y) {
+		if (!super.contains(x, y))
+			return false;
+		if (xSpline!=null) {
+			FloatPolygon poly = new FloatPolygon(xSpline, ySpline, splinePoints);
+			return poly.contains(x - getXBase() + 0.4999, y - getYBase() + 0.5);
+		} else if (xpf!=null) {
+			FloatPolygon poly = new FloatPolygon(xpf, ypf, nPoints);
+			return poly.contains(x - getXBase() + 0.4999, y - getYBase() + 0.5);
+		} else {
+			Polygon poly = new Polygon(xp, yp, nPoints);
+			return poly.contains(x - this.x + 0.4999, y - this.y + 0.5);
+		}
+	}
+
+	/** Returns whether coordinate (x,y) is contained in the Roi.
+	 *  Note that the coordinate (0,0) is the top-left corner of pixel (0,0).
+	 *  Use contains(int, int) to determine whether a given pixel is contained in the Roi. */
+	public boolean containsPoint(double x, double y) {
+		if (!super.containsPoint(x, y))
+			return false;
+		if (xSpline!=null) {
+			FloatPolygon poly = new FloatPolygon(xSpline, ySpline, splinePoints);
+			return poly.contains(x - getXBase() +1e-7, y - getYBase() + 1e-10);
+		} else if (xpf!=null) {
+			FloatPolygon poly = new FloatPolygon(xpf, ypf, nPoints);
+			return poly.contains(x - getXBase() + 1e-7, y - getYBase() + 1e-10);
+		} else {
+			Polygon poly = new Polygon(xp, yp, nPoints);
+			return poly.contains(x - this.x + 1e-7, y - this.y + 1e-10);
+		}
+	}
+
+
+	/** Returns a handle number if the specified screen coordinates are
+		inside or near a handle, otherwise returns -1. */
+	public int isHandle(int sx, int sy) {
+		if (!(xSpline!=null||type==POLYGON||type==POLYLINE||type==ANGLE||type==POINT)||clipboard!=null)
+		   return -1;
+		int size = getHandleSize()+5;
+		int halfSize = size/2;
+		int handle = -1;
+		int sx2, sy2;
+		for (int i=0; i<nPoints; i++) {
+			sx2 = xp2[i]-halfSize; sy2=yp2[i]-halfSize;
+			if (sx>=sx2 && sx<=sx2+size && sy>=sy2 && sy<=sy2+size) {
+				handle = i;
+				break;
+			}
+		}
+		return handle;
+	}
+
+	public ImageProcessor getMask() {
+		ImageProcessor mask = cachedMask;
+		if (mask!=null && mask.getPixels()!=null
+		&& mask.getWidth()==width && mask.getHeight()==height)
+			return mask;
+		PolygonFiller pf = new PolygonFiller();
+		if (xSpline!=null)
+			pf.setPolygon(xSpline, ySpline, splinePoints, getXBase()-x, getYBase()-y);
+		else if (xpf!=null)
+			pf.setPolygon(xpf, ypf, nPoints, getXBase()-x, getYBase()-y);
+		else
+			pf.setPolygon(xp, yp, nPoints);
+		mask = pf.getMask(width, height);
+		cachedMask = mask;
+		return mask;
+	}
+
+	/** Returns the length of this line selection after
+		smoothing using a 3-point running average.*/
+	double getSmoothedLineLength(ImagePlus imp) {
+		if (subPixelResolution() && xpf!=null)
+			return getFloatSmoothedLineLength(imp);
+		double length = 0.0;
+		double w2 = 1.0;
+		double h2 = 1.0;
+		double dx, dy;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			w2 = cal.pixelWidth*cal.pixelWidth;
+			h2 = cal.pixelHeight*cal.pixelHeight;
+		}
+		dx = (xp[0]+xp[1]+xp[2])/3.0-xp[0];
+		dy = (yp[0]+yp[1]+yp[2])/3.0-yp[0];
+		length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		for (int i=1; i<nPoints-2; i++) {
+			dx = (xp[i+2]-xp[i-1])/3.0; // = (x[i]+x[i+1]+x[i+2])/3-(x[i-1]+x[i]+x[i+1])/3
+			dy = (yp[i+2]-yp[i-1])/3.0; // = (y[i]+y[i+1]+y[i+2])/3-(y[i-1]+y[i]+y[i+1])/3
+			length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		}
+		dx = xp[nPoints-1]-(xp[nPoints-3]+xp[nPoints-2]+xp[nPoints-1])/3.0;
+		dy = yp[nPoints-1]-(yp[nPoints-3]+yp[nPoints-2]+yp[nPoints-1])/3.0;
+		length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		return length;
+	}
+
+	double getFloatSmoothedLineLength(ImagePlus imp) {
+		double length = 0.0;
+		double w2 = 1.0;
+		double h2 = 1.0;
+		double dx, dy;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			w2 = cal.pixelWidth*cal.pixelWidth;
+			h2 = cal.pixelHeight*cal.pixelHeight;
+		}
+		dx = (xpf[0]+xpf[1]+xpf[2])/3.0-xpf[0];
+		dy = (ypf[0]+ypf[1]+ypf[2])/3.0-ypf[0];
+		length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		for (int i=1; i<nPoints-2; i++) {
+			dx = (xpf[i+2]-xpf[i-1])/3.0;
+			dy = (ypf[i+2]-ypf[i-1])/3.0;
+			length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		}
+		dx = xpf[nPoints-1]-(xpf[nPoints-3]+xpf[nPoints-2]+xpf[nPoints-1])/3.0;
+		dy = ypf[nPoints-1]-(ypf[nPoints-3]+ypf[nPoints-2]+ypf[nPoints-1])/3.0;
+		length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		return length;
+	}
+
+	/** Returns the perimeter of this ROI after
+		smoothing using a 3-point running average.*/
+	double getSmoothedPerimeter(ImagePlus imp) {
+		if (subPixelResolution() && xpf!=null)
+			return getFloatSmoothedPerimeter(imp);
+		double length = getSmoothedLineLength(imp);
+		double w2=1.0, h2=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			w2 = cal.pixelWidth*cal.pixelWidth;
+			h2 = cal.pixelHeight*cal.pixelHeight;
+		}
+		double dx = xp[nPoints-1]-xp[0];
+		double dy = yp[nPoints-1]-yp[0];
+		length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		return length;
+	}
+
+	double getFloatSmoothedPerimeter(ImagePlus imp) {
+		double length = getSmoothedLineLength(imp);
+		double w2=1.0, h2=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			w2 = cal.pixelWidth*cal.pixelWidth;
+			h2 = cal.pixelHeight*cal.pixelHeight;
+		}
+		double dx = xpf[nPoints-1]-xpf[0];
+		double dy = ypf[nPoints-1]-ypf[0];
+		length += Math.sqrt(dx*dx*w2+dy*dy*h2);
+		return length;
+	}
+
+	/** Returns the perimeter length of ROIs created using the wand tool
+	 *  and the particle analyzer. The algorithm counts pixels in straight edges
+	 *  as 1 and pixels in corners as sqrt(2).
+	 *  It does this by calculating the total length of the ROI boundary and subtracting
+	 *  2-sqrt(2) for each non-adjacent corner. For example, a 1x1 pixel
+	 *  ROI has a boundary length of 4 and 2 non-adjacent edges so the
+	 *  perimeter is 4-2*(2-sqrt(2)). A 2x2 pixel ROI has a boundary length
+	 *  of 8 and 4 non-adjacent edges so the perimeter is 8-4*(2-sqrt(2)).
+	 *  Note that this code can currently create inconsistent legths depending on
+	 *  the starting position.
+	 */
+	double getTracedPerimeter(ImagePlus imp) {
+		if (xp==null)
+			return Double.NaN;
+		if (nPoints < 4) return 0;
+		int sumdx = 0;
+		int sumdy = 0;
+		int nCorners = 0;
+		int dx1 = xp[0] - xp[nPoints-1];
+		int dy1 = yp[0] - yp[nPoints-1];
+		int side1 = Math.abs(dx1) + Math.abs(dy1); //one of these is 0
+		boolean corner = false;
+		int nexti, dx2, dy2, side2;
+		for (int i=0; i<nPoints; i++) {
+			nexti = i+1;
+			if (nexti==nPoints)
+			  nexti = 0;
+			dx2 = xp[nexti] - xp[i];
+			dy2 = yp[nexti] - yp[i];
+			sumdx += Math.abs(dx1);
+			sumdy += Math.abs(dy1);
+			side2 = Math.abs(dx2) + Math.abs(dy2);
+			if (side1>1 || !corner) {
+			  corner = true;
+			  nCorners++;
+			} else
+			  corner = false;
+			dx1 = dx2;
+			dy1 = dy2;
+			side1 = side2;
+		}
+		double w=1.0,h=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			w = cal.pixelWidth;
+			h = cal.pixelHeight;
+		}
+		return sumdx*w+sumdy*h-(nCorners*((w+h)-Math.sqrt(w*w+h*h)));
+		/* Alternative code leading to slightly different results:
+		 *  It does this by calculating the total length of the ROI boundary
+		 *  and subtracting 1-sqrt(2)/2 for each corner.
+		 *  For example, a 1x1 pixel ROI has a boundary length of 4 and
+		 *  and 4 corners so the perimeter is 4-4*(1-sqrt(2)/2) = 2*sqrt(2).
+		 *  A 2x2 pixel ROI has a boundary length of 8 and 4 corners so the
+		 *  perimeter is 8-4*(1-sqrt(2)/2) = 4 + 2*sqrt(2).		/*	int x0 = xp[nPoints-2];
+		int y0 = yp[nPoints-2];
+		int x1 = xp[nPoints-1];
+		int y1 = yp[nPoints-1];
+		int sumdx = 0;
+		int sumdy = 0;
+		int nCorners = 0;
+		for (int i=0; i<nPoints; i++) {
+			int x2 = xp[i];
+			int y2 = yp[i];  //The following is the cross product r01 x r12 = (x1-x0)*(y2-y1) - (y1-y0)*(x2-x1)
+			int crossProduct = x0*(y1-y2) - y0*(x1-x2) + (y2*x1-y1*x2);
+			if (crossProduct != 0) nCorners++;
+			sumdx += Math.abs(x2-x1);
+			sumdy += Math.abs(y2-y1);
+			x0 = x1; y0 = y1;
+			x1 = x2; y1 = y2;
+		}
+		double pw=1.0, ph=1.0;  //pixel width & height (in scaled units)
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		}
+		return sumdx*pw + sumdy*ph - 0.5*nCorners*((pw+ph) - Math.sqrt(pw*pw+ph*ph));
+		*/
+	}
+
+	/** Returns the perimeter (for ROIs) or length (for lines).*/
+	public double getLength() {
+		return getLength(imp);
+	}
+
+	public double getUncalibratedLength() {
+		return getLength(null);
+	}
+
+	/** Returns the perimeter (for ROIs) or length (for lines), using calibration if imp is not null */
+	double getLength(ImagePlus imp) {
+		if (type==TRACED_ROI)
+			return getTracedPerimeter(imp);
+
+		if (nPoints>2) {
+			if (type==FREEROI)
+				return getSmoothedPerimeter(imp);
+			else if (type==FREELINE && !(width==0 || height==0))
+				return getSmoothedLineLength(imp);
+		}
+
+		boolean closeShape = isArea();
+		if (xSpline!=null)
+			return getLength(xSpline, ySpline, splinePoints, closeShape, imp);
+		else if (xpf!=null)
+			return getLength(xpf, ypf, nPoints, closeShape, imp);
+		else
+			return getLength(xp, yp, nPoints, closeShape, imp);
+	}
+
+	/** Returns the length of a polygon with integer coordinates. Uses no calibration if imp is null. */
+	static double getLength(int[] xpoints, int[] ypoints, int npoints, boolean closeShape, ImagePlus imp) {
+		if (npoints < 2) return 0;
+		double pixelWidth = 1.0, pixelHeight = 1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pixelWidth = cal.pixelWidth;
+			pixelHeight = cal.pixelHeight;
+		}
+		double length = 0;
+		for (int i=0; i<npoints-1; i++)
+			length += Math.sqrt(sqr((xpoints[i+1] - xpoints[i])*pixelWidth) +
+					sqr((ypoints[i+1] - ypoints[i])*pixelHeight));
+		if (closeShape)
+			length += Math.sqrt(sqr((xpoints[0] - xpoints[npoints-1])*pixelWidth) +
+					sqr((ypoints[0] - ypoints[npoints-1])*pixelHeight));
+		return length;
+	}
+
+	/** Returns the length of a polygon with float coordinates. Uses no calibration if imp is null. */
+	static double getLength(float[] xpoints, float[] ypoints, int npoints, boolean closeShape, ImagePlus imp) {
+		if (npoints < 2) return 0;
+		double pixelWidth = 1.0, pixelHeight = 1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pixelWidth = cal.pixelWidth;
+			pixelHeight = cal.pixelHeight;
+		}
+		double length = 0;
+		for (int i=0; i<npoints-1; i++)
+			length += Math.sqrt(sqr((xpoints[i+1] - xpoints[i])*pixelWidth) +
+					sqr((ypoints[i+1] - ypoints[i])*pixelHeight));
+		if (closeShape)
+			length += Math.sqrt(sqr((xpoints[0] - xpoints[npoints-1])*pixelWidth) +
+					sqr((ypoints[0] - ypoints[npoints-1])*pixelHeight));
+		return length;
+	}
+
+	/** Returns the angle in degrees between the first two segments of this polyline.*/
+	public double getAngle() {
+		return degrees;
+	}
+
+	/** Returns the number of points that define this PolygonRoi.
+		@see #getNonSplineCoordinates
+	*/
+	public int getNCoordinates() {
+		if (xSpline!=null)
+			return splinePoints;
+		else
+			return nPoints;
+	}
+
+	/** Obsolete; replaced by either getPolygon() or getFloatPolygon(). */
+	public int[] getXCoordinates() {
+		if (xSpline!=null)
+			return toIntR(xSpline);
+		else if (xpf!=null)
+			return toIntR(xpf);
+		else
+			return xp;
+	}
+
+	/** Obsolete; replaced by either getPolygon() or getFloatPolygon(). */
+	public int[] getYCoordinates() {
+		if (xSpline!=null)
+			return toIntR(ySpline);
+		else if (ypf!=null)
+			return toIntR(ypf);
+		else
+			return yp;
+	}
+
+	public Polygon getNonSplineCoordinates() {
+		if (xpf!=null)
+			return new Polygon(toIntR(xpf), toIntR(ypf), nPoints);
+		else
+			return new Polygon(xp, yp, nPoints);
+	}
+
+	public FloatPolygon getNonSplineFloatPolygon() {
+		if (xpf!=null) {
+			FloatPolygon p = (new FloatPolygon(xpf, ypf, nPoints)).duplicate();
+			float xbase = (float)getXBase();
+			float ybase = (float)getYBase();
+			for (int i=0; i<p.npoints; i++) {
+				p.xpoints[i] += xbase;
+				p.ypoints[i] += ybase;
+			}
+			return p;
+		} else
+			return getFloatPolygon();
+	}
+
+	/** Returns this PolygonRoi as a Polygon.
+		@see ij.process.ImageProcessor#setRoi
+		@see ij.process.ImageProcessor#drawPolygon
+		@see ij.process.ImageProcessor#fillPolygon
+	*/
+	public Polygon getPolygon() {
+		int n;
+		int[] xpoints1, ypoints1;
+		if (xSpline!=null) {
+			n = splinePoints;
+			xpoints1 = toInt(xSpline);
+			ypoints1 = toInt(ySpline);
+		} else if (xpf!=null) {
+			n = nPoints;
+			xpoints1 = toIntR(xpf);
+			ypoints1 = toIntR(ypf);
+		} else {
+			n = nPoints;
+			xpoints1 = xp;
+			ypoints1 = yp;
+		}
+		int[] xpoints2 = new int[n];
+		int[] ypoints2 = new int[n];
+		for (int i=0; i<n; i++) {
+			xpoints2[i] = xpoints1[i] + x;
+			ypoints2[i] = ypoints1[i] + y;
+		}
+		return new Polygon(xpoints2, ypoints2, n);
+	}
+
+	/** Returns this polygon or polyline as float arrays in image pixel coordinates. */
+	public FloatPolygon getFloatPolygon() {
+		int n = xSpline!=null?splinePoints:nPoints;
+		float[] xpoints2 = new float[n];
+		float[] ypoints2 = new float[n];
+		float xbase = (float)getXBase();
+		float ybase = (float)getYBase();
+		if (xSpline!=null) {
+			for (int i=0; i<n; i++) {
+				xpoints2[i] = xSpline[i] + xbase;
+				ypoints2[i] = ySpline[i] + ybase;
+			}
+		} else if (xpf!=null) {
+			for (int i=0; i<n; i++) {
+				xpoints2[i] = xpf[i] + xbase;
+				ypoints2[i] = ypf[i] + ybase;
+			}
+		} else {
+			for (int i=0; i<n; i++) {
+				xpoints2[i] = xp[i] + x;
+				ypoints2[i] = yp[i] + y;
+			}
+		}
+		return new FloatPolygon(xpoints2, ypoints2, n);
+	}
+
+	/** Returns the number of points in this selection; equivalent to getPolygon().npoints. */
+	public int size() {
+		return xSpline!=null?splinePoints:nPoints;
+	}
+
+	public FloatPolygon getInterpolatedPolygon(double interval, boolean smooth) {
+		FloatPolygon p = getFloatPolygon();
+		if (smooth && (type==TRACED_ROI || type==FREEROI || type==FREELINE)) {
+			for (int i=1; i<p.npoints-2; i++) {
+				p.xpoints[i] = (p.xpoints[i-1]+p.xpoints[i]+p.xpoints[i+1])/3f;
+				p.ypoints[i] = (p.ypoints[i-1]+p.ypoints[i]+p.ypoints[i+1])/3f;
+			}
+			if (type!=FREELINE) {
+				p.xpoints[0] = (p.xpoints[p.npoints-1]+p.xpoints[0]+p.xpoints[1])/3f;
+				p.ypoints[0] = (p.ypoints[p.npoints-1]+p.ypoints[0]+p.ypoints[1])/3f;
+				p.xpoints[p.npoints-1] = (p.xpoints[p.npoints-2]+p.xpoints[p.npoints-1]+p.xpoints[0])/3f;
+				p.ypoints[p.npoints-1] = (p.ypoints[p.npoints-2]+p.ypoints[p.npoints-1]+p.ypoints[0])/3f;
+			}
+		}
+		return super.getInterpolatedPolygon(p, interval, smooth);
+	}
+
+	protected int clipRectMargin() {
+		return type==POINT?4:0;
+	}
+
+	/** Returns a copy of this PolygonRoi. */
+	public synchronized Object clone() {
+		PolygonRoi r = (PolygonRoi)super.clone();
+		if (xpf!=null) {
+			r.xpf = new float[maxPoints];
+			r.ypf = new float[maxPoints];
+		} else {
+			r.xp = new int[maxPoints];
+			r.yp = new int[maxPoints];
+		}
+		r.xp2 = new int[maxPoints];
+		r.yp2 = new int[maxPoints];
+		for (int i=0; i<nPoints; i++) {
+			if (xpf!=null) {
+				r.xpf[i] = xpf[i];
+				r.ypf[i] = ypf[i];
+			} else {
+				r.xp[i] = xp[i];
+				r.yp[i] = yp[i];
+			}
+			r.xp2[i] = xp2[i];
+			r.yp2[i] = yp2[i];
+		}
+		if (xSpline!=null) {
+			r.xSpline = new float[splinePoints];
+			r.ySpline = new float[splinePoints];
+			r.splinePoints = splinePoints;
+			for (int i=0; i<splinePoints; i++) {
+				r.xSpline[i] = xSpline[i];
+				r.ySpline[i] = ySpline[i];
+			}
+		}
+		return r;
+	}
+
+	void enlargeArrays() {
+		enlargeArrays(maxPoints*2);
+	}
+
+	void enlargeArrays(int newSize) {
+		if (xp!=null) {
+			int[] xptemp = new int[newSize];
+			int[] yptemp = new int[newSize];
+			System.arraycopy(xp, 0, xptemp, 0, maxPoints);
+			System.arraycopy(yp, 0, yptemp, 0, maxPoints);
+			xp=xptemp; yp=yptemp;
+		}
+		if (xpf!=null) {
+			float[] xpftemp = new float[newSize];
+			float[] ypftemp = new float[newSize];
+			System.arraycopy(xpf, 0, xpftemp, 0, maxPoints);
+			System.arraycopy(ypf, 0, ypftemp, 0, maxPoints);
+			xpf=xpftemp; ypf=ypftemp;
+		}
+		int[] xp2temp = new int[newSize];
+		int[] yp2temp = new int[newSize];
+		System.arraycopy(xp2, 0, xp2temp, 0, maxPoints);
+		System.arraycopy(yp2, 0, yp2temp, 0, maxPoints);
+		xp2=xp2temp; yp2=yp2temp;
+		if (IJ.debugMode) IJ.log("PolygonRoi: "+maxPoints+" points -> "+newSize);
+		maxPoints = newSize;
+	}
+
+	public void setLocation(double x, double y) {
+		super.setLocation(x, y);
+		if ((int)x!=x || (int)y!=y)
+			enableSubPixelResolution();
+	}
+
+	public void enableSubPixelResolution() {
+		super.enableSubPixelResolution();
+		if (xpf==null && xp!=null) {
+			xpf = toFloat(xp);
+			ypf = toFloat(yp);
+		}
+	}
+
+	public String getDebugInfo() {
+		String s = "ROI Debug Properties\n";
+		s += "	bounds: "+bounds+"\n";
+		s += "	x,y,w,h: "+x+","+y+","+width+","+height+"\n";
+		if (xpf!=null && xpf.length>0)
+			s += "	xpf[0],ypf[0]: "+xpf[0]+","+ypf[0]+"\n";
+		return s;
+	}
+
+}
diff --git a/src/ij/gui/ProfilePlot.java b/src/ij/gui/ProfilePlot.java
new file mode 100644
index 0000000..875a295
--- /dev/null
+++ b/src/ij/gui/ProfilePlot.java
@@ -0,0 +1,341 @@
+package ij.gui;
+
+import java.awt.*;
+import java.util.ArrayList;
+import ij.*;
+import ij.process.*;
+import ij.util.*;
+import ij.measure.*;
+import ij.plugin.Straightener;
+
+/** Creates a density profile plot of a rectangular selection or line selection. */
+public class ProfilePlot {
+
+	static final int MIN_WIDTH = 350;
+	static final double ASPECT_RATIO = 0.5;
+	private double min, max;
+	private boolean minAndMaxCalculated;
+	private static double fixedMin;
+	private static double fixedMax;
+
+	protected ImagePlus imp;
+	protected double[] profile;
+	protected double magnification;
+	protected double xInc;
+	protected String units;
+	protected String yLabel;
+	protected float[] xValues;
+
+
+	public ProfilePlot() {
+	}
+
+	public ProfilePlot(ImagePlus imp) {
+		this(imp, false);
+	}
+
+	public ProfilePlot(ImagePlus imp, boolean averageHorizontally) {
+		this.imp = imp;
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			IJ.error("Profile Plot", "Selection required.");
+			return;
+		}
+		int roiType = roi.getType();
+		if (!(roi.isLine() || roiType==Roi.RECTANGLE)) {
+			IJ.error("Line or rectangular selection required.");
+			return;
+		}
+		Calibration cal = imp.getCalibration();
+		xInc = cal.pixelWidth;
+		units = cal.getUnits();
+		yLabel = cal.getValueUnit();
+		ImageProcessor ip = imp.getProcessor();
+		if (roiType==Roi.LINE)
+			profile = getStraightLineProfile(roi, cal, ip);
+		else if (roiType==Roi.POLYLINE || roiType==Roi.FREELINE) {
+			int lineWidth = (int)Math.round(roi.getStrokeWidth());
+			if (lineWidth<=1)
+				profile = getIrregularProfile(roi, ip, cal);
+			else
+				profile = getWideLineProfile(imp, lineWidth);
+		} else if (averageHorizontally)
+			profile = getRowAverageProfile(roi.getBounds(), cal, ip);
+		else
+			profile = getColumnAverageProfile(roi.getBounds(), ip);
+		ip.setCalibrationTable(null);
+		ImageCanvas ic = imp.getCanvas();
+		if (ic!=null)
+			magnification = ic.getMagnification();
+		else
+			magnification = 1.0;
+	}
+
+	/** Returns the size of the plot that createWindow() creates. */
+	public Dimension getPlotSize() {
+		if (profile==null) return null;
+		int width = (int)(profile.length*magnification);
+		int height = (int)(width*ASPECT_RATIO);
+		if (width<MIN_WIDTH) {
+			width = MIN_WIDTH;
+			height = (int)(width*ASPECT_RATIO);
+		}
+		Rectangle screen = GUI.getMaxWindowBounds(imp!=null ? imp.getWindow() : IJ.getInstance());
+		int maxWidth = Math.min(screen.width-200, 1000);
+		if (width>maxWidth) {
+			width = maxWidth;
+			height = (int)(width*ASPECT_RATIO);
+		}
+		return new Dimension(width, height);
+	}
+
+	/** Displays this profile plot in a window. */
+	public void createWindow() {
+		Plot plot = getPlot();
+		if (plot!=null)
+			plot.show();
+	}
+
+	public Plot getPlot() {
+		if (profile==null)
+			return null;
+		String xLabel = "Distance ("+units+")";
+  		int n = profile.length;
+  		if (xValues==null) {
+			xValues = new float[n];
+			for (int i=0; i<n; i++)
+				xValues[i] = (float)(i*xInc);
+		}
+        float[] yValues = new float[n];
+        for (int i=0; i<n; i++)
+        	yValues[i] = (float)profile[i];
+		boolean fixedYScale = fixedMin!=0.0 || fixedMax!=0.0;
+		Plot plot = new Plot("Plot of "+getShortTitle(imp), xLabel, yLabel, xValues, yValues);
+		if (fixedYScale) {
+			double[] a = Tools.getMinMax(xValues);
+			plot.setLimits(a[0],a[1],fixedMin,fixedMax);
+		}
+		return plot;
+	}
+
+	String getShortTitle(ImagePlus imp) {
+		String title = imp.getTitle();
+		int index = title.lastIndexOf('.');
+		if (index>0 && (title.length()-index)<=5)
+			title = title.substring(0, index);
+		return title;
+    }
+
+	/** Returns the profile plot data. */
+	public double[] getProfile() {
+		return profile;
+	}
+
+	/** Returns the calculated minimum value. */
+	public double getMin() {
+		if (!minAndMaxCalculated)
+			findMinAndMax();
+		return min;
+	}
+
+	/** Returns the calculated maximum value. */
+	public double getMax() {
+		if (!minAndMaxCalculated)
+			findMinAndMax();
+		return max;
+	}
+
+	/** Sets the y-axis min and max. Specify (0,0) to autoscale. */
+	public static void setMinAndMax(double min, double max) {
+		fixedMin = min;
+		fixedMax = max;
+		IJ.register(ProfilePlot.class);
+	}
+
+	/** Returns the profile plot y-axis min. Auto-scaling is used if min=max=0. */
+	public static double getFixedMin() {
+		return fixedMin;
+	}
+
+	/** Returns the profile plot y-axis max. Auto-scaling is used if min=max=0. */
+	public static double getFixedMax() {
+		return fixedMax;
+	}
+
+	double[] getStraightLineProfile(Roi roi, Calibration cal, ImageProcessor ip) {
+			ip.setInterpolate(PlotWindow.interpolate);
+			Line line = (Line)roi;
+			double[] values = line.getPixels();
+			if (values==null) return null;
+			if (cal!=null && cal.pixelWidth!=cal.pixelHeight) {
+				FloatPolygon p = line.getFloatPoints();
+				double dx = p.xpoints[1] - p.xpoints[0];
+				double dy = p.ypoints[1] - p.ypoints[0];
+				double pixelLength = Math.sqrt(dx*dx + dy*dy);
+				dx = cal.pixelWidth*dx;
+				dy = cal.pixelHeight*dy;
+				double calibratedLength = Math.sqrt(dx*dx + dy*dy);
+				xInc = calibratedLength * 1.0/pixelLength;
+			}
+			return values;
+	}
+
+	double[] getRowAverageProfile(Rectangle rect, Calibration cal, ImageProcessor ip) {
+		double[] profile = new double[rect.height];
+		int[] counts = new int[rect.height];
+		double[] aLine;
+		ip.setInterpolate(false);
+		for (int x=rect.x; x<rect.x+rect.width; x++) {
+			aLine = ip.getLine(x, rect.y, x, rect.y+rect.height-1);
+			for (int i=0; i<rect.height; i++) {
+				if (!Double.isNaN(aLine[i])) {
+					profile[i] += aLine[i];
+					counts[i]++;
+				}
+			}
+		}
+		for (int i=0; i<rect.height; i++)
+			profile[i] /= counts[i];
+		if (cal!=null)
+			xInc = cal.pixelHeight;
+		return profile;
+	}
+
+	public static double[] getColumnAverageProfile(Rectangle rect, ImageProcessor ip) {
+		double[] profile = new double[rect.width];
+		int[] counts = new int[rect.width];
+		double[] aLine;
+		ip.setInterpolate(false);
+		for (int y=rect.y; y<rect.y+rect.height; y++) {
+			aLine = ip.getLine(rect.x, y, rect.x+rect.width-1, y);
+			for (int i=0; i<rect.width; i++) {
+				if (!Double.isNaN(aLine[i])) {
+					profile[i] += aLine[i];
+					counts[i]++;
+				}
+			}
+		}
+		for (int i=0; i<rect.width; i++)
+			profile[i] /= counts[i];
+		return profile;
+	}
+
+	/** Returns the profile for a polyline with single-pixel width.
+	 *  If subpixel resolution is enabled (Plot options>subpixel resolution),
+	 *  the line coordinates are interpreted as the roi line shown at high zoom level,
+	 *  i.e., integer (x,y) is at the top left corner of pixel (x,y).
+	 *  Thus, the coordinates of the pixel center are taken as (x+0.5, y+0.5).
+	 *  If subpixel resolution if off, the coordinates of the pixel centers are taken
+	 *  as integer (x,y). */
+	double[] getIrregularProfile(Roi roi, ImageProcessor ip, Calibration cal) {
+		boolean interpolate = PlotWindow.interpolate;
+		boolean calcXValues = cal!=null && cal.pixelWidth!=cal.pixelHeight;
+		FloatPolygon p = roi.getFloatPolygon();
+		int n = p.npoints;
+		float[] xpoints = p.xpoints;
+		float[] ypoints = p.ypoints;
+		ArrayList values = new ArrayList();
+		int n2;
+		double inc = 0.01;
+		double distance=0.0, distance2=0.0, dx=0.0, dy=0.0, xinc, yinc;
+		double x, y, lastx=0.0, lasty=0.0, x1, y1, x2=xpoints[0], y2=ypoints[0];
+		double value;
+		for (int i=1; i<n; i++) {
+			x1=x2; y1=y2;
+			x=x1; y=y1;
+			x2=xpoints[i]; y2=ypoints[i];
+			dx = x2-x1;
+			dy = y2-y1;
+			distance = Math.sqrt(dx*dx+dy*dy);
+			xinc = dx*inc/distance;
+			yinc = dy*inc/distance;
+			//n2 = (int)(dx/xinc);
+			n2 = (int)(distance/inc);
+			if (n==2) n2++;
+			do {
+				dx = x-lastx;
+				dy = y-lasty;
+				distance2 = Math.sqrt(dx*dx+dy*dy);
+				//IJ.log(i+"   "+IJ.d2s(xinc,5)+"   "+IJ.d2s(yinc,5)+"   "+IJ.d2s(distance,2)+"   "+IJ.d2s(distance2,2)+"   "+IJ.d2s(x,2)+"   "+IJ.d2s(y,2)+"   "+IJ.d2s(lastx,2)+"   "+IJ.d2s(lasty,2)+"   "+n+"   "+n2);
+				if (distance2>=1.0-inc/2.0) {
+					if (interpolate)
+						value = ip.getInterpolatedValue(x, y);
+					else
+						value = ip.getPixelValue((int)Math.round(x), (int)Math.round(y));
+					values.add(new Double(value));
+					lastx=x; lasty=y;
+				}
+				x += xinc;
+				y += yinc;
+			} while (--n2>0);
+		}
+		double[] values2 = new double[values.size()];
+		for (int i=0; i<values.size(); i++)
+			values2[i] = ((Double)values.get(i)).doubleValue();
+		return values2;
+	}
+
+	/*
+	double[] getIrregularProfile(Roi roi, ImageProcessor ip, Calibration cal) {
+		boolean interpolate = PlotWindow.interpolate;
+		FloatPolygon p = roi.getFloatPolygon();
+		float[][] xyPoints = ((PolygonRoi)roi).getEquidistantPoints(p.xpoints, p.ypoints, p.npoints, 1.0, imp);
+		float[] xPoints = xyPoints[0];
+		float[] yPoints = xyPoints[1];
+		double[] values = new double[xPoints.length];
+		for (int i=0; i<xPoints.length; i++)
+			values[i] = interpolate ?
+				ip.getInterpolatedValue(xPoints[i], yPoints[i]) :
+				ip.getPixelValue((int)Math.round(xPoints[i]), (int)Math.round(yPoints[i]));
+		return values;
+	}
+	*/
+
+	double[] getWideLineProfile(ImagePlus imp, int lineWidth) {
+		Roi roi = imp.getRoi();
+		if (roi == null) return null;	//roi may have changed asynchronously
+		if ((roi instanceof PolygonRoi) && roi.getState()==Roi.CONSTRUCTING)
+			return null;				//don't disturb roi under construction by spline fit
+		roi = (Roi)roi.clone();
+		ImageProcessor ip2 = (new Straightener()).straightenLine(imp, lineWidth);
+		if (ip2 == null) return null;
+		int width = ip2.getWidth();
+		int height = ip2.getHeight();
+		if (ip2 instanceof FloatProcessor)
+			return getColumnAverageProfile(new Rectangle(0,0,width,height),ip2);
+		profile = new double[width];
+		double[] aLine;
+		ip2.setInterpolate(false);
+		for (int y=0; y<height; y++) {
+			aLine = ip2.getLine(0, y, width-1, y);
+			for (int i=0; i<width; i++)
+				profile[i] += aLine[i];
+		}
+		for (int i=0; i<width; i++)
+			profile[i] /= height;
+		imp.setRoi(roi);
+		if (roi.getType()==Roi.POLYLINE&& !((PolygonRoi)roi).isSplineFit()) {
+			((PolygonRoi)roi).fitSpline();
+			imp.draw();
+		}
+		return profile;
+	}
+
+	void findMinAndMax() {
+		if (profile==null) return;
+		double min = profile[0];
+		double max = profile[0];
+		double value;
+		for (int i=1; i<profile.length; i++) {
+			value = profile[i];
+			if (value<min)
+				min = value;
+			else if (value>max)
+				max = value;
+		}
+		this.min = min;
+		this.max = max;
+	}
+
+
+}
diff --git a/src/ij/gui/ProgressBar.java b/src/ij/gui/ProgressBar.java
new file mode 100644
index 0000000..7b5ee91
--- /dev/null
+++ b/src/ij/gui/ProgressBar.java
@@ -0,0 +1,165 @@
+package ij.gui;
+
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.awt.image.*;
+
+/**
+ * This is the progress bar that is displayed in the lower right hand corner of
+ * the ImageJ window. Use one of the static IJ.showProgress() methods to display
+ * and update the progress bar.
+ */
+public class ProgressBar extends Canvas {
+
+    public static final int WIDTH = 120;
+    public static final int HEIGHT = 20;
+
+    private int canvasWidth, canvasHeight;
+    private int x, y, width, height;
+    private long lastTime = 0;
+    private boolean showBar;
+    private boolean batchMode;
+
+    private Color barColor = Color.gray;
+    private Color fillColor = new Color(204, 204, 255);
+    private Color backgroundColor = ij.ImageJ.backgroundColor;
+    private Color frameBrighter = backgroundColor.brighter();
+    private Color frameDarker = backgroundColor.darker();
+    private boolean dualDisplay = false;
+    private double slowX = 0.0;//box
+    private double fastX = 0.0;//dot
+
+    /**
+     * This constructor is called once by ImageJ at startup.
+     */
+    public ProgressBar(int canvasWidth, int canvasHeight) {
+    	init(canvasWidth, canvasHeight);
+	}
+    
+    public void init(int canvasWidth, int canvasHeight) {
+        this.canvasWidth = canvasWidth;
+        this.canvasHeight = canvasHeight;
+        x = 3;
+        y = 5;
+        width = canvasWidth - 8;
+        height = canvasHeight - 7;
+    }
+
+    void fill3DRect(Graphics g, int x, int y, int width, int height) {
+        g.setColor(fillColor);
+        g.fillRect(x + 1, y + 1, width - 2, height - 2);
+        g.setColor(frameDarker);
+        g.drawLine(x, y, x, y + height);
+        g.drawLine(x + 1, y, x + width - 1, y);
+        g.setColor(frameBrighter);
+        g.drawLine(x + 1, y + height, x + width, y + height);
+        g.drawLine(x + width, y, x + width, y + height - 1);
+    }
+
+    /**
+     * Updates the progress bar, where abs(progress) should run from 0 to 1.
+     * If abs(<code>progress</code>) == 1 the bar is erased. The bar is updated only
+     * if more than 90 ms have passed since the last call. Does nothing if the
+     * ImageJ window is not present.
+     * @param progress Length of the progress bar to display (0...1). 
+     * Using <code>progress</code> with negative sign (0 .. -1) will regard subsequent calls with
+     * positive argument as sub-ordinate processes that are displayed as moving dot.
+     */
+    public void show(double progress) {
+        show(progress, false);
+    }
+
+    /**
+     * Updates the progress bar, where abs(progress) should run from 0 to 1.
+     * @param progress Length of the progress bar to display (0...1). 
+     * @param showInBatchMode show progress bar in batch mode macros?
+     */
+    public void show(double progress, boolean showInBatchMode) {
+        boolean finished = false;
+        if (progress<=-1)
+            finished = true;
+        if (!dualDisplay && progress >= 1)
+            finished = true;
+        if (!finished) {
+            if (progress < 0) {
+                slowX = -progress;
+                fastX = 0.0;
+                dualDisplay = true;
+            } else if (dualDisplay)
+                fastX = progress;
+            if (!dualDisplay)
+                slowX = progress;
+        }
+        if (!showInBatchMode && (batchMode || Interpreter.isBatchMode()))
+            return;
+        if (finished) {//clear the progress bar
+            slowX = 0.0;
+            fastX = 0.0;
+            showBar = false;
+            dualDisplay = false;
+            repaint();
+            return;
+        }
+        long time = System.currentTimeMillis();
+        if (time-lastTime<90 && progress!=1.0)
+            return;
+        lastTime = time;
+        showBar = true;
+        repaint();
+    }
+
+    /**
+     * Updates the progress bar, where the length of the bar is set to
+     * (<code>(abs(currentIndex)+1)/abs(finalIndex)</code> of the maximum bar
+     * length. Use a negative <code>currentIndex</code> to show subsequent
+     * plugin calls as moving dot. The bar is erased if
+     * <code>currentIndex&gt;=finalIndex-1</code> or <code>finalIndex == 0</code>.
+     */
+    public void show(int currentIndex, int finalIndex) {
+        boolean wasNegative = currentIndex < 0;
+        double progress = ((double) Math.abs(currentIndex) + 1.0) / Math.abs(finalIndex);
+        if (wasNegative)
+            progress = -progress;
+        if (finalIndex == 0)
+            progress = -1;
+        show(progress);
+    }
+
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    public void paint(Graphics g) {
+        if (showBar) {
+            fill3DRect(g, x - 1, y - 1, width + 1, height + 1);
+            drawBar(g);
+        } else {
+            g.setColor(backgroundColor);
+            g.fillRect(0, 0, canvasWidth, canvasHeight);
+        }
+    }
+
+    void drawBar(Graphics g) {
+        int barEnd = (int) (width * slowX);
+        if (Toolbar.getToolId()==Toolbar.ANGLE)
+			g.setColor(Color.getHSBColor(((float)(System.currentTimeMillis()%1000))/1000, 0.5f, 1.0f));
+		else
+       		g.setColor(barColor);
+        g.fillRect(x, y, barEnd, height);
+        if (dualDisplay && fastX > 0) {
+            int dotPos = (int) (width * fastX);
+            g.setColor(Color.BLACK);
+            if (dotPos > 1 && dotPos < width - 7)
+                g.fillOval(dotPos, y + 3, 7, 7);
+        }
+    }
+
+    public Dimension getPreferredSize() {
+        return new Dimension(canvasWidth, canvasHeight);
+    }
+
+    public void setBatchMode(boolean batchMode) {
+        this.batchMode = batchMode;
+    }
+
+}
diff --git a/src/ij/gui/Roi.java b/src/ij/gui/Roi.java
new file mode 100644
index 0000000..a986810
--- /dev/null
+++ b/src/ij/gui/Roi.java
@@ -0,0 +1,2957 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.*;
+import ij.plugin.frame.Recorder;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.filter.ThresholdToSelection;
+import ij.macro.Interpreter;
+import ij.io.RoiDecoder;
+import java.awt.*;
+import java.util.*;
+import java.io.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import java.awt.geom.*;
+
+/**
+ * A rectangular region of interest and superclass for the other ROI classes.
+ *
+ * This class implements {@code Iterable<Point>} and can thus be
+ * used to iterate over the contained coordinates. Usage example:
+ * <pre>
+ * Roi roi = ...;
+ * for (Point p : roi) {
+ *   // process p
+ * }
+ * </pre>
+ * <b>
+ * Convention for subpixel resolution and zooming in:
+ * </b><ul>
+ * <li> Area ROIs: Integer coordinates refer to the top-left corner of the pixel with these coordinates.
+ *      Thus, pixel (0,0) is enclosed by the rectangle spanned between points (0,0) and (1,1),
+ *      i.e., a rectangle at (0,0) with width = height = 1 pixel.
+ * <li> Line and Point Rois: Integer coordinates refer to the center of a pixel.
+ *      Thus, a line from (0,0) to (1,0) has its start and end points in the center of
+ *      pixels (0,0) and (1,0), respectively, and drawing the line should affect both
+ *      pixels. For images dispplayed at high zoom levels, this means that (open) lines
+ *      and single points are displayed 0.5 pixels further to the right and bottom than
+ *      the outlines of area ROIs (closed lines) with the same coordinates.
+ * </ul>
+ * Note that rectangular and (nonrotated) oval ROIs do not support subpixel resolution.
+ * Since ImageJ 1.52t, this convention does not depend on the Prefs.subpixelResolution
+ * (previously accessible via Edit>Options>Plot) and this flag has no effect any more.
+ *
+  */
+public class Roi extends Object implements Cloneable, java.io.Serializable, Iterable<Point> {
+
+	public static final int CONSTRUCTING=0, MOVING=1, RESIZING=2, NORMAL=3, MOVING_HANDLE=4; // States
+	public static final int RECTANGLE=0, OVAL=1, POLYGON=2, FREEROI=3, TRACED_ROI=4, LINE=5,
+		POLYLINE=6, FREELINE=7, ANGLE=8, COMPOSITE=9, POINT=10; // Types
+	public static final int HANDLE_SIZE = 5;  // replaced by getHandleSize()
+	public static final int NOT_PASTING = -1;
+	public static final int FERET_ARRAYSIZE = 16; // Size of array with Feret values
+	public static final int FERET_ARRAY_POINTOFFSET = 8; // Where point coordinates start in Feret array
+	private static final String NAMES_KEY = "group.names";
+
+	static final int NO_MODS=0, ADD_TO_ROI=1, SUBTRACT_FROM_ROI=2; // modification states
+
+	int startX, startY, x, y, width, height;
+	double startXD, startYD;
+	Rectangle2D.Double bounds;
+	int activeHandle;
+	int state;
+	int modState = NO_MODS;
+	int cornerDiameter;             //for rounded rectangle
+	int previousSX, previousSY;     //remember for aborting moving with esc and constrain
+
+	public static final BasicStroke onePixelWide = new BasicStroke(1);
+	protected static Color ROIColor = Prefs.getColor(Prefs.ROICOLOR,Color.yellow);
+	protected static int pasteMode = Blitter.COPY;
+	protected static int lineWidth = 1;
+	protected static Color defaultFillColor;
+	private static Vector listeners = new Vector();
+	private static LUT glasbeyLut;
+	private static int defaultGroup; // zero is no specific group
+	private static Color groupColor;
+	private static double defaultStrokeWidth;
+	private static String groupNamesString = Prefs.get(NAMES_KEY, null);
+	private static String[] groupNames;
+	private static boolean groupNamesChanged;
+
+	/** Get using getPreviousRoi() and set using setPreviousRoi() */
+	public static Roi previousRoi;
+
+	protected int type;
+	protected int xMax, yMax;
+	protected ImagePlus imp;
+	private int imageID;
+	protected ImageCanvas ic;
+	protected int oldX, oldY, oldWidth, oldHeight;  //remembers previous clip rect
+	protected int clipX, clipY, clipWidth, clipHeight;
+	protected ImagePlus clipboard;
+	protected boolean constrain;    // to be square or limit to horizontal/vertical motion
+	protected boolean center;
+	protected boolean aspect;
+	protected boolean updateFullWindow;
+	protected double mag = 1.0;
+	protected double asp_bk;        //saves aspect ratio if resizing takes roi very small
+	protected ImageProcessor cachedMask;
+	protected Color handleColor = Color.white;
+	protected Color strokeColor;
+	protected Color instanceColor;  //obsolete; replaced by strokeColor
+	protected Color fillColor;
+	protected BasicStroke stroke;
+	protected boolean nonScalable;
+	protected boolean overlay;
+	protected boolean wideLine;
+	protected boolean ignoreClipRect;
+	protected double flattenScale = 1.0;
+	protected static Color defaultColor;
+
+	private String name;
+	private int position;
+	private int channel, slice, frame;
+	private boolean hyperstackPosition;
+	private Overlay prototypeOverlay;
+	private boolean subPixel;
+	private boolean activeOverlayRoi;
+	private Properties props;
+	private boolean isCursor;
+	private double xcenter = Double.NaN;
+	private double ycenter;
+	private boolean listenersNotified;
+	private boolean antiAlias = true;
+	private int group;
+	private boolean usingDefaultStroke;
+	private static int defaultHandleSize;
+	private int handleSize = -1;
+	private boolean scaleStrokeWidth; // Scale stroke width when zooming images?
+
+	/** Creates a rectangular ROI. */
+	public Roi(int x, int y, int width, int height) {
+		this(x, y, width, height, 0);
+	}
+
+	/** Creates a rectangular ROI using double arguments. */
+	public Roi(double x, double y, double width, double height) {
+		this(x, y, width, height, 0);
+	}
+
+	/** Creates a new rounded rectangular ROI. */
+	public Roi(int x, int y, int width, int height, int cornerDiameter) {
+		setImage(null);
+		if (width<1) width = 1;
+		if (height<1) height = 1;
+		if (width>xMax) width = xMax;
+		if (height>yMax) height = yMax;
+		this.cornerDiameter = cornerDiameter;
+		this.x = x;
+		this.y = y;
+		startX = x; startY = y;
+		oldX = x; oldY = y; oldWidth=0; oldHeight=0;
+		this.width = width;
+		this.height = height;
+		oldWidth=width;
+		oldHeight=height;
+		clipX = x;
+		clipY = y;
+		clipWidth = width;
+		clipHeight = height;
+		state = NORMAL;
+		type = RECTANGLE;
+		if (ic!=null) {
+			Graphics g = ic.getGraphics();
+			draw(g);
+			g.dispose();
+		}
+		double defaultWidth = defaultStrokeWidth();
+		if (defaultWidth>0) {
+			stroke = new BasicStroke((float)defaultWidth);
+			usingDefaultStroke = true;
+		}
+		fillColor = defaultFillColor;
+		this.group = defaultGroup; //initialize with current group and associated color
+		if (defaultGroup>0)
+			this.strokeColor = groupColor;
+	}
+
+	/** Creates a rounded rectangular ROI using double arguments. */
+	public Roi(double x, double y, double width, double height, int cornerDiameter) {
+		this((int)x, (int)y, (int)Math.ceil(width), (int)Math.ceil(height), cornerDiameter);
+		bounds = new Rectangle2D.Double(x, y, width, height);
+		subPixel = true;
+	}
+
+	/** Creates a new rectangular Roi. */
+	public Roi(Rectangle r) {
+		this(r.x, r.y, r.width, r.height);
+	}
+
+	/** Starts the process of creating a user-defined rectangular Roi,
+		where sx and sy are the starting screen coordinates. */
+	public Roi(int sx, int sy, ImagePlus imp) {
+		this(sx, sy, imp, 0);
+	}
+
+	/** Starts the process of creating a user-defined rectangular Roi,
+		where sx and sy are the starting screen coordinates.
+		For rectangular rois, also a corner diameter may be specified to
+		make it a rounded rectangle */
+	public Roi(int sx, int sy, ImagePlus imp, int cornerDiameter) {
+		setImage(imp);
+		int ox=sx, oy=sy;
+		if (ic!=null) {
+			ox = ic.offScreenX2(sx);
+			oy = ic.offScreenY2(sy);
+		}
+		setLocation(ox, oy);
+		this.cornerDiameter = cornerDiameter;
+		width = 0;
+		height = 0;
+		state = CONSTRUCTING;
+		type = RECTANGLE;
+		if (cornerDiameter>0) {
+			double swidth = RectToolOptions.getDefaultStrokeWidth();
+			if (swidth>0.0)
+				setStrokeWidth(swidth);
+			Color scolor = RectToolOptions.getDefaultStrokeColor();
+			if (scolor!=null)
+				setStrokeColor(scolor);
+		}
+		double defaultWidth = defaultStrokeWidth();
+		if (defaultWidth>0) {
+			stroke = new BasicStroke((float)defaultWidth);
+			usingDefaultStroke = true;
+		}
+		fillColor = defaultFillColor;
+		this.group = defaultGroup;
+		if (defaultGroup>0)
+			this.strokeColor = groupColor;
+	}
+
+	/** Creates a rectangular ROI. */
+	public static Roi create(double x, double y, double width, double height) {
+		return new Roi(x, y, width, height);
+	}
+
+	/** Creates a rounded rectangular ROI. */
+	public static Roi create(double x, double y, double width, double height, int cornerDiameter) {
+		return new Roi(x, y, width, height, cornerDiameter);
+	}
+
+	/** @deprecated */
+	public Roi(int x, int y, int width, int height, ImagePlus imp) {
+		this(x, y, width, height);
+		setImage(imp);
+	}
+
+	/** Set the location of the ROI in image coordinates. */
+	public void setLocation(int x, int y) {
+		this.x = x;
+		this.y = y;
+		startX = x; startY = y;
+		oldX = x; oldY = y; oldWidth=0; oldHeight=0;
+		if (bounds!=null) {
+			if (!isInteger(bounds.x) || !isInteger(bounds.y)) {
+				cachedMask = null;
+				width  = (int)Math.ceil(bounds.width);
+				height = (int)Math.ceil(bounds.height);
+			}
+			bounds.x = x;
+			bounds.y = y;
+			if (this instanceof PolygonRoi) setIntBounds(bounds);
+		}
+	}
+
+	/** Set the location of the ROI in image coordinates. */
+	public void setLocation(double x, double y) {
+		setLocation((int)x, (int)y);
+		if (isInteger(x) && isInteger(y))
+			return;
+		if (bounds!=null) {
+			if (!isInteger(x-bounds.x) || !isInteger(y-bounds.y)) {
+				cachedMask = null;
+				width  = (int)Math.ceil(bounds.x + bounds.width) - this.x;	//ensure that all pixels are inside
+				height = (int)Math.ceil(bounds.y + bounds.height) - this.y;
+			}
+			bounds.x = x;
+			bounds.y = y;
+		} else {
+			cachedMask = null;
+			bounds = new Rectangle2D.Double(x, y, width, height);
+		}
+		if (this instanceof PolygonRoi) setIntBounds(bounds);
+		subPixel = true;
+	}
+
+	/** Sets the ImagePlus associated with this ROI.
+	 *  <code>imp</code> may be null to remove the association to an image. */
+	public void setImage(ImagePlus imp) {
+		this.imp = imp;
+		cachedMask = null;
+		if (imp==null) {
+			ic = null;
+			clipboard = null;
+			xMax = yMax = Integer.MAX_VALUE;
+		} else {
+			ic = imp.getCanvas();
+			xMax = imp.getWidth();
+			yMax = imp.getHeight();
+		}
+	}
+
+	/** Returns the ImagePlus associated with this ROI, or null. */
+	public ImagePlus getImage() {
+		return imp;
+	}
+
+	/** Returns the ID of the image associated with this ROI. */
+	public int getImageID() {
+		return imp!=null?imp.getID():imageID;
+	}
+
+	public int getType() {
+		return type;
+	}
+
+	public int getState() {
+		return state;
+	}
+
+	/** Returns the perimeter length. */
+	public double getLength() {
+		double pw=1.0, ph=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		}
+		double perimeter = 2.0*width*pw + 2.0*height*ph;
+		if (cornerDiameter > 0) {      //using Ramanujan's approximation for the circumference of an ellipse
+			double a = 0.5*Math.min(cornerDiameter, width)*pw;
+			double b = 0.5*Math.min(cornerDiameter, height)*ph;
+			 perimeter += Math.PI*(3*(a + b) - Math.sqrt((3*a + b)*(a + 3*b))) -4*(a+b);
+		}
+		return perimeter;
+	}
+
+	/** Returns Feret's diameter, the greatest distance between
+		any two points along the ROI boundary. */
+	public double getFeretsDiameter() {
+		double[] a = getFeretValues();
+		return a!=null?a[0]:0.0;
+	}
+
+	/** Returns an array with the following values:
+	 *  <br>[0] "Feret" (maximum caliper width)
+	 *  <br>[1] "FeretAngle" (angle of diameter with maximum caliper width, between 0 and 180 deg)
+	 *  <br>[2] "MinFeret" (minimum caliper width)
+	 *  <br>[3][4] , "FeretX" and "FeretY", the X and Y coordinates of the starting point
+	 *  (leftmost point) of the maximum-caliper-width diameter.
+	 *  <br>[5-7] reserved
+	 *  <br>All these values and point coordinates are in calibrated image coordinates.
+	 *  <p>
+	 *  The following array elements are end points of the maximum and minimum caliper diameter,
+	 *  in unscaled image pixel coordinates:
+	 *  <br>[8][9]   "FeretX1", "FeretY1"; unscaled versions of "FeretX" and "FeretY"
+	 *  (subclasses may use any end of the diameter, not necessarily the left one)
+	 *  <br>[10][11] "FeretX2", "FeretY2", end point of the maxium-caliper-width diameter.
+	 *  Both of these points are vertices of the convex hull.
+	 *  <br> The final four array elements are the starting and end points of the minimum caliper width,
+	 *  <br>[12],[13] "MinFeretX", "MinFeretY", and
+	 *  <br>[14],[15] "MinFeretX2", "MinFeretY2". These two pooints are not sorted by x,
+	 *  but the first point point (MinFeretX, MinFeretY) is guaranteed to be a vertex of the convex hull,
+	 *  while second point (MinFeretX2, MinFeretY2) usually is not a vertex point but at a
+	 *  boundary line of the convex hull. */
+	public double[] getFeretValues() {
+		double pw=1.0, ph=1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		}
+
+		FloatPolygon poly = getFloatConvexHull();
+		if (poly==null || poly.npoints==0) return null;
+
+		double[] a = new double[FERET_ARRAYSIZE];
+		// calculate maximum Feret diameter: largest distance between any two points
+		int p1=0, p2=0;
+		double diameterSqr = 0.0;  //square of maximum Feret diameter
+		for (int i=0; i<poly.npoints; i++) {
+			for (int j=i+1; j<poly.npoints; j++) {
+				double dx = (poly.xpoints[i] - poly.xpoints[j])*pw;
+				double dy = (poly.ypoints[i] - poly.ypoints[j])*ph;
+				double dsqr = dx*dx + dy*dy;
+				if (dsqr>diameterSqr) {diameterSqr=dsqr; p1=i; p2=j;}
+			}
+		}
+        if (poly.xpoints[p1] > poly.xpoints[p2]) {
+            int p2swap = p1; p1 = p2; p2 = p2swap;
+        }
+		double xf1=poly.xpoints[p1], yf1=poly.ypoints[p1];
+		double xf2=poly.xpoints[p2], yf2=poly.ypoints[p2];
+		double angle = (180.0/Math.PI)*Math.atan2((yf1-yf2)*ph, (xf2-xf1)*pw);
+		if (angle < 0.0)
+			angle += 180.0;
+		a[0] = Math.sqrt(diameterSqr);
+		a[1] = angle;
+		a[3] = xf1; a[4] = yf1;
+		{ int i = FERET_ARRAY_POINTOFFSET;     //array elements 8-11 are start and end points of max Feret diameter
+			a[i++] = poly.xpoints[p1]; a[i++] = poly.ypoints[p1];
+			a[i++] = poly.xpoints[p2]; a[i++] = poly.ypoints[p2];
+		}
+
+		// Calculate minimum Feret diameter:
+		// For all pairs of points on the convex hull:
+		//   Get the point with the largest distance from the line between these two points
+		//   Of all these pairs, take the one where the distance is the lowest
+		// The following code requires a counterclockwise convex hull with no duplicate points
+		double x0 = poly.xpoints[poly.npoints-1];
+		double y0 = poly.ypoints[poly.npoints-1];
+		double minFeret = Double.MAX_VALUE;
+		double[] xyEnd = new double[4];        //start and end points of the minFeret diameter, uncalibrated
+		double[] xyEi  = new double[4];        //intermediate values of xyEnd
+		for (int i=0; i<poly.npoints; i++) {   //find caliper width for one side of calipers touching points i-1, i
+			double xprev = x0;
+			double yprev = y0;
+			x0 = poly.xpoints[i];
+			y0 = poly.ypoints[i];
+			double xnorm = (y0 - yprev) * ph;
+			double ynorm = (xprev - x0) * pw;
+			double normalizationFactor = 1/Math.sqrt(xnorm*xnorm + ynorm*ynorm);
+			xnorm *= normalizationFactor * pw; //normalized vector perpendicular to line between i-1, i; * scale factor for product below
+			ynorm *= normalizationFactor * ph;
+			double maxDist = 0;
+			for (int j=0; j<poly.npoints; j++) {
+				double x1 = poly.xpoints[j];
+				double y1 = poly.ypoints[j];
+				double dx = x1 - x0;
+				double dy = y1 - y0;
+				double dist = dx*xnorm + dy*ynorm;
+				if (dist > maxDist) {
+					maxDist = dist;
+					xyEi[0] = x1;
+					xyEi[1] = y1;
+					xyEi[2] = xyEi[0] - (xnorm/pw * dist)/pw;
+					xyEi[3] = xyEi[1] - (ynorm/ph * dist)/ph;
+				}
+			}
+			if (maxDist < minFeret) {
+				minFeret = maxDist;
+				System.arraycopy(xyEi, 0, xyEnd, 0, 4);
+			}
+		}
+		a[2] = minFeret;
+		System.arraycopy(xyEnd, 0, a, FERET_ARRAY_POINTOFFSET+4, 4);    //a[12]-a[15] are minFeretX, Y, X2, Y2
+		return a;
+	}
+
+	/** Returns the convex hull of this Roi as a Polygon with integer coordinates
+	 *  by rounding the floating-point values.
+	 *  Coordinates of the convex hull are image pixel coordinates. */
+	public Polygon getConvexHull() {
+		FloatPolygon fp = getFloatConvexHull();
+		return new Polygon(toIntR(fp.xpoints), toIntR(fp.ypoints), fp.npoints);
+	}
+
+	/** Returns the convex hull of this Roi as a FloatPolygon.
+	 *  Coordinates of the convex hull are image pixel coordinates. */
+	public FloatPolygon getFloatConvexHull() {
+		FloatPolygon fp = getFloatPolygon("");   //no duplicate closing points, no path-separating NaNs needed
+		return fp == null ? null : fp.getConvexHull();
+	}
+
+	double getFeretBreadth(Shape shape, double angle, double x1, double y1, double x2, double y2) {
+		double cx = x1 + (x2-x1)/2;
+		double cy = y1 + (y2-y1)/2;
+		AffineTransform at = new AffineTransform();
+		at.rotate(angle*Math.PI/180.0, cx, cy);
+		Shape s = at.createTransformedShape(shape);
+		Rectangle2D r = s.getBounds2D();
+		return Math.min(r.getWidth(), r.getHeight());
+	}
+
+	/** Returns this selection's bounding rectangle. */
+	public Rectangle getBounds() {
+		return new Rectangle(x, y, width, height);
+	}
+
+	/** Returns this selection's bounding rectangle (with subpixel accuracy). */
+	public Rectangle2D.Double getFloatBounds() {
+		if (bounds!=null)
+			return new Rectangle2D.Double(bounds.x, bounds.y, bounds.width, bounds.height);
+		else
+			return new Rectangle2D.Double(x, y, width, height);
+	}
+
+	/** Sets the bounds of rectangular, oval or text selections.
+	 *  Note that for these types, subpixel resolution is ignored,
+	 *  and the x,y values are rounded down, the width and height values rounded up.
+	 *  Do not use for other ROI types since their width and height are results of
+	 *  a calculation.
+	 *  For translating ROIs, use setLocation. */
+	public void setBounds(Rectangle2D.Double b) {
+		if (!(type==RECTANGLE||type==OVAL||(this instanceof TextRoi)))
+			return;
+		this.x = (int)b.x;
+		this.y = (int)b.y;
+		this.width = (int)Math.ceil(b.width);
+		this.height = (int)Math.ceil(b.height);
+		bounds = new Rectangle2D.Double(b.x, b.y, b.width, b.height);
+		cachedMask = null;
+	}
+
+	/** Sets the integer boundaries x, y, width, height from given sub-pixel
+	 *  boundaries, such that all points are within the integer bounding rectangle.
+	 *  For open line selections and (multi)Point Rois, note that integer Roi
+	 *  coordinates correspond to the center of the 1x1 rectangle enclosing a pixel.
+	 *  Points at the boundary of such a rectangle are counted for the higher x or y
+	 *  value, in agreement to how (poly-)line or PointRois are displayed at the
+	 *  screen at high zoom levels. (For lines and points, it should include all
+	 *  pixels affected by 'draw' */
+	void setIntBounds(Rectangle2D.Double bounds) {
+		if (useLineSubpixelConvention()) { //for PointRois & open lines, ensure the 'draw' area is enclosed
+			x = (int)Math.floor(bounds.x + 0.5);
+			y = (int)Math.floor(bounds.y + 0.5);
+			width  = (int)Math.floor(bounds.x + bounds.width + 1.5)  - x;
+			height = (int)Math.floor(bounds.y + bounds.height + 1.5) - y;
+		} else {                           //for area Rois, the subpixel bounds must be enclosed in the int bounds
+			x = (int)Math.floor(bounds.x);
+			y = (int)Math.floor(bounds.y);
+			width  = (int)Math.ceil(bounds.x + bounds.width)  - x;
+			height = (int)Math.ceil(bounds.y + bounds.height) - y;
+		}
+	}
+
+	/**
+	* @deprecated
+	* replaced by getBounds()
+	*/
+	public Rectangle getBoundingRect() {
+		return getBounds();
+	}
+
+	/** Returns the outline of this selection as a Polygon, or
+		null if this is a straight line selection.
+		@see ij.process.ImageProcessor#setRoi
+		@see ij.process.ImageProcessor#drawPolygon
+		@see ij.process.ImageProcessor#fillPolygon
+	*/
+	public Polygon getPolygon() {
+		int[] xpoints = new int[4];
+		int[] ypoints = new int[4];
+		xpoints[0] = x;
+		ypoints[0] = y;
+		xpoints[1] = x+width;
+		ypoints[1] = y;
+		xpoints[2] = x+width;
+		ypoints[2] = y+height;
+		xpoints[3] = x;
+		ypoints[3] = y+height;
+		return new Polygon(xpoints, ypoints, 4);
+	}
+
+	/** Returns the outline (in image pixel coordinates) as a FloatPolygon */
+	public FloatPolygon getFloatPolygon() {
+		if (cornerDiameter>0) {  // Rounded Rectangle
+			ShapeRoi s = new ShapeRoi(this);
+			return s.getFloatPolygon();
+		} else if (subPixelResolution() && bounds!=null) {
+			float[] xpoints = new float[4];
+			float[] ypoints = new float[4];
+			xpoints[0] = (float)bounds.x;
+			ypoints[0] = (float)bounds.y;
+			xpoints[1] = (float)(bounds.x+bounds.width);
+			ypoints[1] = (float)bounds.y;
+			xpoints[2] = (float)(bounds.x+bounds.width);
+			ypoints[2] = (float)(bounds.y+bounds.height);
+			xpoints[3] = (float)bounds.x;
+			ypoints[3] = (float)(bounds.y+bounds.height);
+			return new FloatPolygon(xpoints, ypoints);
+		} else {
+			Polygon p = getPolygon();
+			return new FloatPolygon(toFloat(p.xpoints), toFloat(p.ypoints), p.npoints);
+		}
+	}
+
+	/** Returns the outline in image pixel coordinates,
+	 *  where options may include "close" to add a point to close the outline
+	 *  if this is an area roi and the outline is not closed yet.
+	 *  (For ShapeRois, "separate" inserts NaN values between subpaths). */
+	public FloatPolygon getFloatPolygon(String options) {
+		options = options.toLowerCase();
+		boolean addPointForClose = options.indexOf("close") >= 0;
+		FloatPolygon fp = getFloatPolygon();
+		int n = fp.npoints;
+		if (isArea() && n > 1) {
+			boolean isClosed = fp.xpoints[0] == fp.xpoints[n-1] && fp.ypoints[0] == fp.ypoints[n-1];
+			if (addPointForClose && !isClosed)
+				fp.addPoint(fp.xpoints[0], fp.ypoints[0]);
+			else if (!addPointForClose && isClosed)
+				fp.npoints--;
+		}
+		return fp;
+	}
+
+	/** Returns, as a FloatPolygon, an interpolated version
+	 * of this selection that has points spaced 1.0 pixel apart.
+	 */
+	public FloatPolygon getInterpolatedPolygon() {
+		return getInterpolatedPolygon(1.0, false);
+	}
+
+	/** Returns, as a FloatPolygon, an interpolated version of
+	 * this selection with points spaced 'interval' pixels apart.
+	 * If 'smooth' is true, traced and freehand selections are
+	 * first smoothed using a 3 point running average.
+	 */
+	public FloatPolygon getInterpolatedPolygon(double interval, boolean smooth) {
+		FloatPolygon p = (this instanceof Line)?((Line)this).getFloatPoints():getFloatPolygon();
+		return getInterpolatedPolygon(p, interval, smooth);
+	}
+
+	 /**
+	 * Returns, as a FloatPolygon, an interpolated version of this selection
+	 * with points spaced abs('interval') pixels apart. If 'smooth' is true, traced
+	 * and freehand selections are first smoothed using a 3 point running
+	 * average.
+	 * If 'interval' is negative, the program is allowed to decrease abs('interval')
+	 * so that the last segment will hit the end point
+	 */
+	protected FloatPolygon getInterpolatedPolygon(FloatPolygon p, double interval, boolean smooth) {
+		boolean allowToAdjust = interval < 0;
+		interval = Math.abs(interval);
+		boolean isLine = this.isLine();
+		double length = p.getLength(isLine);
+
+		int npoints = p.npoints;
+		if (npoints<2)
+			return p;
+		if (Math.abs(interval)<0.01) {
+			IJ.error("Interval must be >= 0.01");
+			return p;
+		}
+		
+		if (!isLine) {//**append (and later remove) closing point to end of array
+			npoints++;
+			p.xpoints = java.util.Arrays.copyOf(p.xpoints, npoints);
+			p.xpoints[npoints - 1] = p.xpoints[0];
+			p.ypoints = java.util.Arrays.copyOf(p.ypoints, npoints);
+			p.ypoints[npoints - 1] = p.ypoints[0];
+		}
+		int npoints2 = (int) (10 + (length * 1.5) / interval);//allow some headroom
+
+		double tryInterval = interval;
+		double minDiff = 1e9;
+		double bestInterval = 0;
+		int srcPtr = 0;//index of source polygon
+		int destPtr = 0;//index of destination polygon
+		double[] destXArr = new double[npoints2];
+		double[] destYArr = new double[npoints2];
+		int nTrials = 50;
+		int trial = 0;
+		while (trial <= nTrials) {
+			destXArr[0] = p.xpoints[0];
+			destYArr[0] = p.ypoints[0];
+			srcPtr = 0;
+			destPtr = 0;
+			double xA = p.xpoints[0];//start of current segment
+			double yA = p.ypoints[0];
+
+			while (srcPtr < npoints - 1) {//collect vertices
+				double xC = destXArr[destPtr];//center circle
+				double yC = destYArr[destPtr];
+				double xB = p.xpoints[srcPtr + 1];//end of current segment
+				double yB = p.ypoints[srcPtr + 1];
+				double[] intersections = lineCircleIntersection(xA, yA, xB, yB, xC, yC, tryInterval, true);
+				if (intersections.length >= 2) {
+					xA = intersections[0];//only use first of two intersections
+					yA = intersections[1];
+					destPtr++;
+					destXArr[destPtr] = xA;
+					destYArr[destPtr] = yA;
+				} else {
+					srcPtr++;//no intersection found, pick next segment
+					xA = p.xpoints[srcPtr];
+					yA = p.ypoints[srcPtr];
+				}
+			}
+			destPtr++;
+			destXArr[destPtr] = p.xpoints[npoints - 1];
+			destYArr[destPtr] = p.ypoints[npoints - 1];
+			destPtr++;
+			if (!allowToAdjust) {
+				if (isLine)
+					destPtr--;
+				break;
+			}
+
+			int nSegments = destPtr - 1;
+			double dx = destXArr[destPtr - 2] - destXArr[destPtr - 1];
+			double dy = destYArr[destPtr - 2] - destYArr[destPtr - 1];
+			double lastSeg = Math.sqrt(dx * dx + dy * dy);
+
+			double diff = lastSeg - tryInterval;//always <= 0
+			if (Math.abs(diff) < minDiff) {
+				minDiff = Math.abs(diff);
+				bestInterval = tryInterval;
+			}
+			double feedBackFactor = 0.66;//factor <1: applying soft successive approximation
+			tryInterval = tryInterval + feedBackFactor * diff / nSegments;
+			//stop if tryInterval < 80% of interval, OR if last segment differs < 0.05 pixels
+			if ((tryInterval < 0.8 * interval || Math.abs(diff) < 0.05 || trial == nTrials - 1) && trial < nTrials) {
+				trial = nTrials;//run one more loop with bestInterval to get best polygon
+				tryInterval = bestInterval;
+			} else
+				trial++;
+		}
+		if (!isLine) //**remove closing point from end of array
+			destPtr--;
+		float[] xPoints = new float[destPtr];
+		float[] yPoints = new float[destPtr];
+		for (int jj = 0; jj < destPtr; jj++) {
+			xPoints[jj] = (float) destXArr[jj];
+			yPoints[jj] = (float) destYArr[jj];
+		}
+		FloatPolygon fPoly = new FloatPolygon(xPoints, yPoints);
+		return fPoly;
+	}
+
+	/** Returns the coordinates of the pixels inside this ROI as an array of Points.
+	 * @see #getContainedFloatPoints
+	 * @see #iterator
+	 */
+	public Point[] getContainedPoints() {
+		Roi roi = this;
+		if (isLine())
+			roi = convertLineToArea(this);
+		ImageProcessor mask = roi.getMask();
+		Rectangle bounds = roi.getBounds();
+		ArrayList points = new ArrayList();
+		for (int y=0; y<bounds.height; y++) {
+			for (int x=0; x<bounds.width; x++) {
+				if (mask==null || mask.getPixel(x,y)!=0)
+					points.add(new Point(roi.x+x,roi.y+y));
+			}
+		}
+		return (Point[])points.toArray(new Point[points.size()]);
+	}
+
+	/** Returns the coordinates of the pixels inside this ROI as a FloatPolygon.
+	 * @see #getContainedPoints
+	 * @see #iterator
+	 */
+	public FloatPolygon getContainedFloatPoints() {
+		Roi roi2 = this;
+		if (isLine()) {
+			if (getStrokeWidth()<=1)
+				return roi2.getInterpolatedPolygon();
+			else
+				roi2 = convertLineToArea(this);
+		}
+		ImageProcessor mask = roi2.getMask();
+		Rectangle bounds = roi2.getBounds();
+		FloatPolygon points = new FloatPolygon();
+		for (int y=0; y<bounds.height; y++) {
+			for (int x=0; x<bounds.width; x++) {
+				if (mask==null || mask.getPixel(x,y)!=0)
+					points.addPoint((float)(bounds.x+x),(float)(bounds.y+y));
+			}
+		}
+		return points;
+	}
+
+	/**
+	 * <pre>
+	 * Calculates intersections of a line segment with a circle
+	 * Author N.Vischer
+	 * ax, ay, bx, by: points A and B of line segment
+	 * cx, cy, rad: Circle center and radius.
+	 * ignoreOutside: if true, ignores intersections outside the line segment A-B
+	 * Returns an array of 0, 2 or 4 coordinates (for 0, 1, or 2 intersection
+	 * points). If two intersection points are returned, they are listed in travel
+	 * direction A->B
+	 * </pre>
+	 */
+	public static double[] lineCircleIntersection(double ax, double ay, double bx, double by, double cx, double cy, double rad, boolean ignoreOutside) {
+		//rotates & translates points A, B and C, creating new points A2, B2 and C2.
+		//A2 is then on origin, and B2 is on positive x-axis
+
+		double dxAC = cx - ax;
+		double dyAC = cy - ay;
+		double lenAC = Math.sqrt(dxAC * dxAC + dyAC * dyAC);
+
+		double dxAB = bx - ax;
+		double dyAB = by - ay;
+
+		//calculate B2 and C2:
+		double xB2 = Math.sqrt(dxAB * dxAB + dyAB * dyAB);
+
+		double phi1 = Math.atan2(dyAB, dxAB);//amount of rotation
+		double phi2 = Math.atan2(dyAC, dxAC);
+		double phi3 = phi1 - phi2;
+		double xC2 = lenAC * Math.cos(phi3);
+		double yC2 = lenAC * Math.sin(phi3);//rotation & translation is done
+		if (Math.abs(yC2) > rad)
+			return new double[0];//no intersection found
+		double halfChord = Math.sqrt(rad * rad - yC2 * yC2);
+		double sectOne = xC2 - halfChord;//first intersection point, still on x axis
+		double sectTwo = xC2 + halfChord;//second intersection point, still on x axis
+		double[] xyCoords = new double[4];
+		int ptr = 0;
+		if ((sectOne >= 0 && sectOne <= xB2) || !ignoreOutside) {
+			double sectOneX = Math.cos(phi1) * sectOne + ax;//undo rotation and translation
+			double sectOneY = Math.sin(phi1) * sectOne + ay;
+			xyCoords[ptr++] = sectOneX;
+			xyCoords[ptr++] = sectOneY;
+		}
+		if ((sectTwo >= 0 && sectTwo <= xB2) || !ignoreOutside) {
+			double sectTwoX = Math.cos(phi1) * sectTwo + ax;//undo rotation and translation
+			double sectTwoY = Math.sin(phi1) * sectTwo + ay;
+			xyCoords[ptr++] = sectTwoX;
+			xyCoords[ptr++] = sectTwoY;
+		}
+		if (halfChord == 0 && ptr > 2) //tangent line returns only one intersection
+			ptr = 2;
+		xyCoords = java.util.Arrays.copyOf(xyCoords,ptr);
+		return xyCoords;
+	}
+
+	/** Returns a copy of this roi. See Thinking is Java by Bruce Eckel
+		(www.eckelobjects.com) for a good description of object cloning. */
+	public synchronized Object clone() {
+		try {
+			Roi r = (Roi)super.clone();
+			r.setImage(null);
+			if (!usingDefaultStroke)
+				r.setStroke(getStroke());
+			r.setFillColor(getFillColor());
+			r.imageID = getImageID();
+			r.listenersNotified = false;
+			if (bounds!=null)
+				r.bounds = (Rectangle2D.Double)bounds.clone();
+			return r;
+		}
+		catch (CloneNotSupportedException e) {return null;}
+	}
+
+	/** Aborts constructing or modifying the roi (called by the ImageJ class on escape) */
+	public void abortModification(ImagePlus imp) {
+		if (state == CONSTRUCTING) {
+			setImage(null);
+			if (imp!=null) {
+				Roi savedPreviousRoi = getPreviousRoi();
+				imp.setRoi(previousRoi!=null && previousRoi.getImage() == imp ? previousRoi : null);
+				setPreviousRoi(savedPreviousRoi);     //(overrule saving this aborted roi as previousRoi)
+			}
+		} else if (state==MOVING)
+			move(previousSX, previousSY);       //move back to starting point
+		else if (state == MOVING_HANDLE)
+			moveHandle(previousSX, previousSY); //move handle back to starting point
+		state = NORMAL;
+	}
+
+	protected void grow(int sx, int sy) {
+		if (clipboard!=null) return;
+		int xNew = ic.offScreenX2(sx);
+		int yNew = ic.offScreenY2(sy);
+		if (type==RECTANGLE) {
+			if (xNew < 0) xNew = 0;
+			if (yNew < 0) yNew = 0;
+		}
+		if (constrain) {
+			// constrain selection to be square
+			if (!center)
+				{growConstrained(xNew, yNew); return;}
+			int dx, dy, d;
+			dx = xNew - x;
+			dy = yNew - y;
+			if (dx<dy)
+				d = dx;
+			else
+				d = dy;
+			xNew = x + d;
+			yNew = y + d;
+		}
+		if (center) {
+			width = Math.abs(xNew - startX)*2;
+			height = Math.abs(yNew - startY)*2;
+			x = startX - width/2;
+			y = startY - height/2;
+		} else {
+			width = Math.abs(xNew - startX);
+			height = Math.abs(yNew - startY);
+			x = (xNew>=startX)?startX:startX - width;
+			y = (yNew>=startY)?startY:startY - height;
+			if (type==RECTANGLE) {
+				if ((x+width) > xMax) width = xMax-x;
+				if ((y+height) > yMax) height = yMax-y;
+			}
+		}
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX = x;
+		oldY = y;
+		oldWidth = width;
+		oldHeight = height;
+		bounds = null;
+	}
+
+	private void growConstrained(int xNew, int yNew) {
+		int dx = xNew - startX;
+		int dy = yNew - startY;
+		width = height = (int)Math.round(Math.sqrt(dx*dx + dy*dy));
+		if (type==RECTANGLE) {
+			x = (xNew>=startX)?startX:startX - width;
+			y = (yNew>=startY)?startY:startY - height;
+			if (x<0) x = 0;
+			if (y<0) y = 0;
+			if ((x+width) > xMax) width = xMax-x;
+			if ((y+height) > yMax) height = yMax-y;
+		} else {
+			x = startX + dx/2 - width/2;
+			y = startY + dy/2 - height/2;
+		}
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX = x;
+		oldY = y;
+		oldWidth = width;
+		oldHeight = height;
+	}
+
+	protected void moveHandle(int sx, int sy) {
+		double asp;
+		if (clipboard!=null) return;
+		int ox = ic.offScreenX2(sx);
+		int oy = ic.offScreenY2(sy);
+		if (ox<0) ox=0; if (oy<0) oy=0;
+		if (ox>xMax) ox=xMax; if (oy>yMax) oy=yMax;
+		int x1=x, y1=y, x2=x1+width, y2=y+height, xc=x+width/2, yc=y+height/2;
+		if (width > 7 && height > 7) {
+			asp = (double)width/(double)height;
+			asp_bk = asp;
+		} else
+			asp = asp_bk;
+
+		switch (activeHandle) {
+			case 0:
+				x=ox; y=oy;
+				break;
+			case 1:
+				y=oy;
+				break;
+			case 2:
+				x2=ox; y=oy;
+				break;
+			case 3:
+				x2=ox;
+				break;
+			case 4:
+				x2=ox; y2=oy;
+				break;
+			case 5:
+				y2=oy;
+				break;
+			case 6:
+				x=ox; y2=oy;
+				break;
+			case 7:
+				x=ox;
+				break;
+		}
+		if (x<x2)
+		   width=x2-x;
+		else
+		  {width=1; x=x2;}
+		if (y<y2)
+		   height = y2-y;
+		else
+		   {height=1; y=y2;}
+
+		if (center) {
+			switch (activeHandle){
+				case 0:
+					width=(xc-x)*2;
+					height=(yc-y)*2;
+					break;
+				case 1:
+					height=(yc-y)*2;
+					break;
+				case 2:
+					width=(x2-xc)*2;
+					x=x2-width;
+					height=(yc-y)*2;
+					break;
+				case 3:
+					width=(x2-xc)*2;
+					x=x2-width;
+					break;
+				case 4:
+					width=(x2-xc)*2;
+					x=x2-width;
+					height=(y2-yc)*2;
+					y=y2-height;
+					break;
+				case 5:
+					height=(y2-yc)*2;
+					y=y2-height;
+					break;
+				case 6:
+					width=(xc-x)*2;
+					height=(y2-yc)*2;
+					y=y2-height;
+					break;
+				case 7:
+					width=(xc-x)*2;
+					break;
+			}
+			if (x>=x2) {
+				width=1;
+				x=x2=xc;
+			}
+			if (y>=y2) {
+				height=1;
+				y=y2=yc;
+			}
+			bounds = null;
+		}
+
+		if (constrain) {
+			if (activeHandle==1 || activeHandle==5)
+				width=height;
+			else
+				height=width;
+
+			if(x>=x2) {
+				width=1;
+				x=x2=xc;
+			}
+			if (y>=y2) {
+				height=1;
+				y=y2=yc;
+			}
+			switch (activeHandle) {
+				case 0:
+					x=x2-width;
+					y=y2-height;
+					break;
+				case 1:
+					x=xc-width/2;
+					y=y2-height;
+					break;
+				case 2:
+					y=y2-height;
+					break;
+				case 3:
+					y=yc-height/2;
+					break;
+				case 5:
+					x=xc-width/2;
+					break;
+				case 6:
+					x=x2-width;
+					break;
+				case 7:
+					y=yc-height/2;
+					x=x2-width;
+					break;
+			}
+			if (center) {
+				x=xc-width/2;
+				y=yc-height/2;
+			}
+		}
+
+		if (aspect && !constrain) {
+			if (activeHandle==1 || activeHandle==5) width=(int)Math.rint((double)height*asp);
+			else height=(int)Math.rint((double)width/asp);
+
+			switch (activeHandle){
+				case 0:
+					x=x2-width;
+					y=y2-height;
+					break;
+				case 1:
+					x=xc-width/2;
+					y=y2-height;
+					break;
+				case 2:
+					y=y2-height;
+					break;
+				case 3:
+					y=yc-height/2;
+					break;
+				case 5:
+					x=xc-width/2;
+					break;
+				case 6:
+					x=x2-width;
+					break;
+				case 7:
+					y=yc-height/2;
+					x=x2-width;
+					break;
+			}
+			if (center) {
+				x=xc-width/2;
+				y=yc-height/2;
+			}
+
+			// Attempt to preserve aspect ratio when roi very small:
+			if (width<8) {
+				if(width<1) width = 1;
+				height=(int)Math.rint((double)width/asp_bk);
+			}
+			if (height<8) {
+				if(height<1) height =1;
+				width=(int)Math.rint((double)height*asp_bk);
+			}
+		}
+
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX=x; oldY=y;
+		oldWidth=width; oldHeight=height;
+		bounds = null;
+		subPixel = false;
+	}
+
+	void move(int sx, int sy) {
+		if (constrain) {  // constrain translation in 90deg steps
+			int dx = sx - previousSX;
+			int dy = sy - previousSY;
+			if (Math.abs(dx) > Math.abs(dy))
+				dy = 0;
+			else
+				dx = 0;
+			sx = previousSX + dx;
+			sy = previousSY + dy;
+		}
+		int xNew = ic.offScreenX(sx);
+		int yNew = ic.offScreenY(sy);
+		int dx = xNew - startX;
+		int dy = yNew - startY;
+		if (dx==0 && dy==0)
+			return;
+		x += dx;
+		y += dy;
+		if (bounds!=null)
+			setLocation(bounds.x + dx, bounds.y + dy);
+		boolean isImageRoi = this instanceof ImageRoi;
+		if (clipboard==null && type==RECTANGLE && !isImageRoi) {
+			if (x<0) x=0; if (y<0) y=0;
+			if ((x+width)>xMax) x = xMax-width;
+			if ((y+height)>yMax) y = yMax-height;
+		}
+		startX = xNew;
+		startY = yNew;
+		if (type==POINT || ((this instanceof TextRoi) && ((TextRoi)this).getAngle()!=0.0))
+			ignoreClipRect = true;
+		updateClipRect();
+		if ((lineWidth>1 && isLine()) || ignoreClipRect || ((this instanceof PolygonRoi)&&((PolygonRoi)this).isSplineFit()))
+			imp.draw();
+		else
+			imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX = x;
+		oldY = y;
+		oldWidth = width;
+		oldHeight=height;
+		if (isImageRoi) showStatus();
+	}
+
+	/** Nudge ROI one pixel on arrow key press. */
+	public void nudge(int key) {
+		if (WindowManager.getActiveWindow() instanceof ij.plugin.frame.RoiManager)
+			return;
+		if (bounds != null && (!isInteger(bounds.x) || !isInteger(bounds.y)))
+			cachedMask = null;
+		switch(key) {
+			case KeyEvent.VK_UP:
+				this.y--;
+				if (this.y<0 && (type!=RECTANGLE||clipboard==null))
+					this.y = 0;
+				break;
+			case KeyEvent.VK_DOWN:
+				this.y++;
+				if ((this.y+height)>=yMax && (type!=RECTANGLE||clipboard==null))
+					this.y = yMax-height;
+				break;
+			case KeyEvent.VK_LEFT:
+				this.x--;
+				if (this.x<0 && (type!=RECTANGLE||clipboard==null))
+					this.x = 0;
+				break;
+			case KeyEvent.VK_RIGHT:
+				this.x++;
+				if ((this.x+width)>=xMax && (type!=RECTANGLE||clipboard==null))
+					this.x = xMax-width;
+				break;
+		}
+		updateClipRect();
+		if (type==POINT)
+			imp.draw();
+		else
+			imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX = this.x; oldY = this.y;
+		bounds = null;
+		setLocation(this.x, this.y);
+		showStatus();
+		notifyListeners(RoiListener.MOVED);
+	}
+
+	/** Nudge lower right corner of rectangular and oval ROIs by
+		one pixel based on arrow key press. */
+	public void nudgeCorner(int key) {
+		if (type>OVAL || clipboard!=null)
+			return;
+		switch(key) {
+			case KeyEvent.VK_UP:
+				height--;
+				if (height<1) height = 1;
+				notifyListeners(RoiListener.MODIFIED);
+				break;
+			case KeyEvent.VK_DOWN:
+				height++;
+				if ((y+height) > yMax) height = yMax-y;
+				notifyListeners(RoiListener.MODIFIED);
+				break;
+			case KeyEvent.VK_LEFT:
+				width--;
+				if (width<1) width = 1;
+				notifyListeners(RoiListener.MODIFIED);
+				break;
+			case KeyEvent.VK_RIGHT:
+				width++;
+				if ((x+width) > xMax) width = xMax-x;
+				notifyListeners(RoiListener.MODIFIED);
+				break;
+		}
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+		oldX = x; oldY = y;
+		cachedMask = null;
+		showStatus();
+		notifyListeners(RoiListener.MOVED);
+	}
+
+	// Finds the union of current and previous roi
+	protected void updateClipRect() {
+		clipX = (x<=oldX)?x:oldX;
+		clipY = (y<=oldY)?y:oldY;
+		clipWidth = ((x+width>=oldX+oldWidth)?x+width:oldX+oldWidth) - clipX + 1;
+		clipHeight = ((y+height>=oldY+oldHeight)?y+height:oldY+oldHeight) - clipY + 1;
+		int handleSize = getHandleSize();
+		double mag = ic!=null?ic.getMagnification():1;
+		int m = mag<1.0?(int)(handleSize/mag):handleSize;
+		m += clipRectMargin();
+		double strokeWidth = getStrokeWidth();
+		if (strokeWidth==0.0)
+			strokeWidth = defaultStrokeWidth();
+		m = (int)(m+strokeWidth*2);
+		clipX-=m; clipY-=m;
+		clipWidth+=m*2; clipHeight+=m*2;
+	 }
+
+	protected int clipRectMargin() {
+		return 0;
+	}
+
+	protected void handleMouseDrag(int sx, int sy, int flags) {
+		if (ic==null) return;
+		constrain = (flags&Event.SHIFT_MASK)!=0;
+		center = (flags&Event.CTRL_MASK)!=0 || (IJ.isMacintosh()&&(flags&Event.META_MASK)!=0);
+		aspect = (flags&Event.ALT_MASK)!=0;
+		switch(state) {
+			case CONSTRUCTING:
+				grow(sx, sy);
+				break;
+			case MOVING:
+				move(sx, sy);
+				break;
+			case MOVING_HANDLE:
+				moveHandle(sx, sy);
+				break;
+			default:
+				break;
+		}
+		notifyListeners(state==MOVING?RoiListener.MOVED:RoiListener.MODIFIED);
+	}
+
+	public void draw(Graphics g) {
+		Color color =  strokeColor!=null?strokeColor:ROIColor;
+		if (fillColor!=null) color = fillColor;
+		if (Interpreter.isBatchMode() && imp!=null && imp.getOverlay()!=null && strokeColor==null && fillColor==null)
+			return;
+		g.setColor(color);
+		mag = getMagnification();
+		int sw = (int)(width*mag);
+		int sh = (int)(height*mag);
+		int sx1 = screenX(x);
+		int sy1 = screenY(y);
+		if (subPixelResolution() && bounds!=null) {
+			sw = (int)(bounds.width*mag);
+			sh = (int)(bounds.height*mag);
+			sx1 = screenXD(bounds.x);
+			sy1 = screenYD(bounds.y);
+		}
+		int sx2 = sx1+sw/2;
+		int sy2 = sy1+sh/2;
+		int sx3 = sx1+sw;
+		int sy3 = sy1+sh;
+		Graphics2D g2d = (Graphics2D)g;
+		if (stroke!=null)
+			g2d.setStroke(getScaledStroke());
+		setRenderingHint(g2d);
+		if (cornerDiameter>0) {
+			int sArcSize = (int)Math.round(cornerDiameter*mag);
+			if (fillColor!=null)
+				g.fillRoundRect(sx1, sy1, sw, sh, sArcSize, sArcSize);
+			else
+				g.drawRoundRect(sx1, sy1, sw, sh, sArcSize, sArcSize);
+		} else {
+			if (fillColor!=null) {
+				if (!overlay && isActiveOverlayRoi()) {
+					g.setColor(Color.cyan);
+					g.drawRect(sx1, sy1, sw, sh);
+				} else {
+					if (!(this instanceof TextRoi))
+						g.fillRect(sx1, sy1, sw, sh);
+					else
+						g.drawRect(sx1, sy1, sw, sh);
+				}
+			} else
+				g.drawRect(sx1, sy1, sw, sh);
+		}
+		if (clipboard==null && !overlay) {
+			drawHandle(g, sx1, sy1);
+			drawHandle(g, sx2, sy1);
+			drawHandle(g, sx3, sy1);
+			drawHandle(g, sx3, sy2);
+			drawHandle(g, sx3, sy3);
+			drawHandle(g, sx2, sy3);
+			drawHandle(g, sx1, sy3);
+			drawHandle(g, sx1, sy2);
+		}
+		drawPreviousRoi(g);
+		if (state!=NORMAL)
+			showStatus();
+		if (updateFullWindow)
+			{updateFullWindow = false; imp.draw();}
+	}
+
+	public void drawOverlay(Graphics g) {
+		overlay = true;
+		draw(g);
+		overlay = false;
+	}
+
+	void drawPreviousRoi(Graphics g) {
+		if (previousRoi!=null && previousRoi!=this && previousRoi.modState!=NO_MODS) {
+			if (type!=POINT && previousRoi.getType()==POINT && previousRoi.modState!=SUBTRACT_FROM_ROI)
+				return;
+			previousRoi.setImage(imp);
+			previousRoi.draw(g);
+		}
+	}
+
+	private static double defaultStrokeWidth() {
+		double defaultWidth = defaultStrokeWidth;
+		double guiScale = Prefs.getGuiScale();
+		if (defaultWidth<=1 && guiScale>1.0) {
+			defaultWidth = guiScale;
+			if (defaultWidth<1.5) defaultWidth = 1.5;
+		}
+		return defaultWidth;
+	}
+
+	/** Returns the current handle size. */
+	public int getHandleSize() {
+		if (handleSize>=0)
+			return handleSize;
+		else
+			return getDefaultHandleSize();
+	}
+
+	/** Sets the current handle size. */
+	public void setHandleSize(int size) {
+		if (size>=0 && ((size&1)==0))
+			size++; // add 1 if odd
+		handleSize = size;
+		if (imp!=null)
+			imp.draw();
+	}
+
+	/** Returns the default handle size. */
+	public static int getDefaultHandleSize() {
+		if (defaultHandleSize>0)
+			return defaultHandleSize;
+		double defaultWidth = defaultStrokeWidth();
+		int size = 7;
+		if (defaultWidth>1.5) size=9;
+		if (defaultWidth>=3) size=11;
+		if (defaultWidth>=4) size=13;
+		if (defaultWidth>=5) size=15;
+		if (defaultWidth>=11) size=(int)defaultWidth;
+		defaultHandleSize = size;
+		return defaultHandleSize;
+	}
+
+	public static void resetDefaultHandleSize() {
+		defaultHandleSize = 0;
+	}
+
+	void drawHandle(Graphics g, int x, int y) {
+		int threshold1 = 7500;
+		int threshold2 = 1500;
+		double size = (this.width*this.height)*this.mag*this.mag;
+		if (this instanceof Line) {
+			size = ((Line)this).getLength()*this.mag;
+			threshold1 = 150;
+			threshold2 = 50;
+		} else {
+			if (state==CONSTRUCTING && !(type==RECTANGLE||type==OVAL))
+				size = threshold1 + 1;
+		}
+		int width = 7;
+		int x0=x, y0=y;
+		if (size>threshold1) {
+			x -= 3;
+			y -= 3;
+		} else if (size>threshold2) {
+			x -= 2;
+			y -= 2;
+			width = 5;
+		} else {
+			x--; y--;
+			width = 3;
+		}
+		int inc = getHandleSize() - 7;
+		width += inc;
+		x -= inc/2;
+		y -= inc/2;
+		g.setColor(Color.black);
+		if (width<3) {
+			g.fillRect(x0,y0,1,1);
+			return;
+		}
+		g.fillRect(x++,y++,width,width);
+		g.setColor(handleColor);
+		width -= 2;
+		g.fillRect(x,y,width,width);
+	}
+
+	/**
+	* @deprecated
+	* replaced by drawPixels(ImageProcessor)
+	*/
+	public void drawPixels() {
+		if (imp!=null)
+			drawPixels(imp.getProcessor());
+	}
+
+	/** Draws the selection outline on the specified ImageProcessor.
+		@see ij.process.ImageProcessor#setColor
+		@see ij.process.ImageProcessor#setLineWidth
+	*/
+	public void drawPixels(ImageProcessor ip) {
+		endPaste();
+		int saveWidth = ip.getLineWidth();
+		if (getStrokeWidth()>1f)
+			ip.setLineWidth((int)Math.round(getStrokeWidth()));
+		if (cornerDiameter>0)
+			drawRoundedRect(ip);
+		else {
+			if (ip.getLineWidth()==1)
+				ip.drawRect(x, y, width+1, height+1);
+			else
+				ip.drawRect(x, y, width, height);
+		}
+		ip.setLineWidth(saveWidth);
+		if (Line.getWidth()>1 || getStrokeWidth()>1)
+			updateFullWindow = true;
+	}
+
+	private void drawRoundedRect(ImageProcessor ip) {
+		int margin = (int)getStrokeWidth()/2;
+		BufferedImage bi = new BufferedImage(width+margin*2+1, height+margin*2+1, BufferedImage.TYPE_BYTE_GRAY);
+		Graphics2D g = bi.createGraphics();
+		if (stroke!=null)
+			g.setStroke(stroke);
+		g.drawRoundRect(margin, margin, width, height, cornerDiameter, cornerDiameter);
+		ByteProcessor mask = new ByteProcessor(bi);
+		ip.setRoi(x-margin, y-margin, width+margin*2+1, height+margin*2+1);
+		ip.fill(mask);
+	}
+
+	/** Returns whether the center of pixel (x,y) is contained in the Roi.
+	 *  The position of a pixel center determines whether a pixel is selected.
+	 *  Points exactly at the left (right) border are considered outside (inside);
+	 *  points exactly on horizontal borders are considered outside (inside) at the border
+	 *  with the lower (higher) y. This convention is opposite to that of the java.awt.Shape class. */
+	public boolean contains(int x, int y) {
+		Rectangle r = new Rectangle(this.x, this.y, width, height);
+		boolean contains = r.contains(x, y);
+		if (cornerDiameter==0 || contains==false)
+			return contains;
+		RoundRectangle2D rr = new RoundRectangle2D.Double(this.x, this.y, width, height, cornerDiameter, cornerDiameter);
+		return rr.contains(x+0.4999, y+0.4999);
+	}
+
+	/** Returns whether coordinate (x,y) is contained in the Roi.
+	 *  Note that the coordinate (0,0) is the top-left corner of pixel (0,0).
+	 *  Use contains(int, int) to determine whether a given pixel is contained in the Roi. */
+	public boolean containsPoint(double x, double y) {
+		boolean contains = false;
+		if (bounds == null)
+			contains = x>=this.x && y>=this.y && x<this.x+width && y<this.y+height;
+		if (cornerDiameter==0 || contains==false)
+			return contains;
+		RoundRectangle2D rr = new RoundRectangle2D.Double(this.x, this.y, width, height, cornerDiameter, cornerDiameter);
+		return rr.contains(x, y);
+	}
+
+	/** Returns the inverted roi, or null if this is not an area roi or cannot be converted to a ShapeRoi.
+	 *  If imp is not given, assumes a rectangle of size 2e9*2e9 for the boundary. */
+	public Roi getInverse(ImagePlus imp) {
+		if (!isArea()) return null;
+		Roi fullImage = (imp == null) ? new Roi(0,0, 2000000000, 2000000000) : new Roi(0,0, imp.getWidth(), imp.getHeight());
+		ShapeRoi s = (this instanceof ShapeRoi) ? (ShapeRoi)(this.clone()) : new ShapeRoi(this);
+		if (s == null) return null;
+		ShapeRoi inverse = s.xor(new ShapeRoi(fullImage));
+		return inverse.trySimplify();
+	}
+
+	/** Returns a handle number if the specified screen coordinates are
+		inside or near a handle, otherwise returns -1. */
+	public int isHandle(int sx, int sy) {
+		if (clipboard!=null || ic==null) return -1;
+		double mag = ic.getMagnification();
+		int margin = IJ.getScreenSize().width>1280?5:3;
+		int size = getHandleSize()+margin;
+		int halfSize = size/2;
+		double x = getXBase();
+		double y = getYBase();
+		double width = getFloatWidth();
+		double height = getFloatHeight();
+		int sx1 = screenXD(x) - halfSize;
+		int sy1 = screenYD(y) - halfSize;
+		int sx3 = screenXD(x+width) - halfSize;
+		int sy3 = screenYD(y+height) - halfSize;
+		int sx2 = sx1 + (sx3 - sx1)/2;
+		int sy2 = sy1 + (sy3 - sy1)/2;
+		if (sx>=sx1&&sx<=sx1+size&&sy>=sy1&&sy<=sy1+size) return 0;
+		if (sx>=sx2&&sx<=sx2+size&&sy>=sy1&&sy<=sy1+size) return 1;
+		if (sx>=sx3&&sx<=sx3+size&&sy>=sy1&&sy<=sy1+size) return 2;
+		if (sx>=sx3&&sx<=sx3+size&&sy>=sy2&&sy<=sy2+size) return 3;
+		if (sx>=sx3&&sx<=sx3+size&&sy>=sy3&&sy<=sy3+size) return 4;
+		if (sx>=sx2&&sx<=sx2+size&&sy>=sy3&&sy<=sy3+size) return 5;
+		if (sx>=sx1&&sx<=sx1+size&&sy>=sy3&&sy<=sy3+size) return 6;
+		if (sx>=sx1&&sx<=sx1+size&&sy>=sy2&&sy<=sy2+size) return 7;
+		return -1;
+	}
+
+	protected void mouseDownInHandle(int handle, int sx, int sy) {
+		state = MOVING_HANDLE;
+		previousSX = sx;
+		previousSY = sy;
+		activeHandle = handle;
+	}
+
+	protected void handleMouseDown(int sx, int sy) {
+		if (state==NORMAL && ic!=null) {
+			state = MOVING;
+			previousSX = sx;
+			previousSY = sy;
+			startX = offScreenX(sx);
+			startY = offScreenY(sy);
+			startXD = offScreenXD(sx);
+			startYD = offScreenYD(sy);
+		}
+	}
+
+	protected void handleMouseUp(int screenX, int screenY) {
+		state = NORMAL;
+		if (imp==null) return;
+		imp.draw(clipX-5, clipY-5, clipWidth+10, clipHeight+10);
+		if (Recorder.record) {
+			String method;
+			if (type==OVAL)
+				Recorder.record("makeOval", x, y, width, height);
+			else if (!(this instanceof TextRoi)) {
+				if (cornerDiameter==0)
+					Recorder.record("makeRectangle", x, y, width, height);
+				else {
+					if (Recorder.scriptMode())
+						Recorder.recordCall("imp.setRoi(new Roi("+x+","+y+","+width+","+height+","+cornerDiameter+"));");
+					else
+						Recorder.record("makeRectangle", x, y, width, height, cornerDiameter);
+				}
+			}
+		}
+		if (Toolbar.getToolId()==Toolbar.OVAL&&Toolbar.getBrushSize()>0)  {
+			int flags = ic!=null?ic.getModifiers():16;
+			if ((flags&16)==0) // erase ROI Brush
+				{imp.draw(); return;}
+		}
+		modifyRoi();
+	}
+
+	void modifyRoi() {
+		if (previousRoi==null || previousRoi.modState==NO_MODS || imp==null)
+			return;
+		if (type==POINT || previousRoi.getType()==POINT) {
+			if (type==POINT && previousRoi.getType()==POINT) {
+				addPoint();
+			} else if (isArea() && previousRoi.getType()==POINT && previousRoi.modState==SUBTRACT_FROM_ROI)
+				subtractPoints();
+			return;
+		}
+		Roi previous = (Roi)previousRoi.clone();
+		previous.modState = NO_MODS;
+		ShapeRoi s1	 = null;
+		ShapeRoi s2 = null;
+		if (previousRoi instanceof ShapeRoi)
+			s1 = (ShapeRoi)previousRoi;
+		else
+			s1 = new ShapeRoi(previousRoi);
+		if (this instanceof ShapeRoi)
+			s2 = (ShapeRoi)this;
+		else
+			s2 = new ShapeRoi(this);
+		if (previousRoi.modState==ADD_TO_ROI)
+			s1.or(s2);
+		else
+			s1.not(s2);
+		previousRoi.modState = NO_MODS;
+		Roi roi2 = s1.trySimplify();
+		if (roi2 == null) return;
+		if (roi2!=null)
+			roi2.copyAttributes(previousRoi);
+		imp.setRoi(roi2);
+		setPreviousRoi(previous);
+	}
+
+	void addPoint() {
+		if (!(type==POINT && previousRoi.getType()==POINT)) {
+			modState = NO_MODS;
+			imp.draw();
+			return;
+		}
+		previousRoi.modState = NO_MODS;
+		PointRoi p1 = (PointRoi)previousRoi;
+		FloatPolygon poly = getFloatPolygon();
+		p1.addPoint(imp, poly.xpoints[0], poly.ypoints[0]);
+		imp.setRoi(p1);
+	}
+
+	void subtractPoints() {
+		previousRoi.modState = NO_MODS;
+		PointRoi p1 = (PointRoi)previousRoi;
+		PointRoi p2 = p1.subtractPoints(this);
+		if (p2!=null)
+			imp.setRoi(p1.subtractPoints(this));
+		else
+			imp.deleteRoi();
+	}
+
+	/** If 'add' is true, adds this selection to the previous one. If 'subtract' is true, subtracts
+		it from the previous selection. Called by the IJ.doWand() method, and the makeRectangle(),
+		makeOval(), makePolygon() and makeSelection() macro functions. */
+	public void update(boolean add, boolean subtract) {
+		if (previousRoi==null) return;
+		if (add) {
+			previousRoi.modState = ADD_TO_ROI;
+			modifyRoi();
+		} else if (subtract) {
+			previousRoi.modState = SUBTRACT_FROM_ROI;
+			modifyRoi();
+		} else
+			previousRoi.modState = NO_MODS;
+	 }
+
+	public void showStatus() {
+		if (imp==null)
+			return;
+		String value;
+		if (state!=CONSTRUCTING && (type==RECTANGLE||type==POINT) && width<=25 && height<=25) {
+			ImageProcessor ip = imp.getProcessor();
+			double v = ip.getPixelValue(this.x,this.y);
+			int digits = (imp.getType()==ImagePlus.GRAY8||imp.getType()==ImagePlus.GRAY16)?0:2;
+			value = ", value="+IJ.d2s(v,digits);
+		} else
+			value = "";
+		Calibration cal = imp.getCalibration();
+		String size;
+		if (cal.scaled())
+			size = ", w="+IJ.d2s(width*cal.pixelWidth)+" ("+width+"), h="+IJ.d2s(height*cal.pixelHeight)+" ("+height+")";
+		else
+			size = ", w="+width+", h="+height;
+		IJ.showStatus(imp.getLocationAsString(this.x,this.y)+size+value);
+	}
+
+	/** Always returns null for rectangular Roi's */
+	public ImageProcessor getMask() {
+		if (cornerDiameter>0)
+			return (new ShapeRoi(new RoundRectangle2D.Float(x, y, width, height, cornerDiameter, cornerDiameter))).getMask();
+		else
+			return null;
+	}
+
+	public void startPaste(ImagePlus clipboard) {
+		IJ.showStatus("Pasting...");
+		IJ.wait(10);
+		this.clipboard = clipboard;
+		imp.getProcessor().snapshot();
+		updateClipRect();
+		imp.draw(clipX, clipY, clipWidth, clipHeight);
+	}
+
+	void updatePaste() {
+		if (clipboard!=null) {
+			imp.getMask();
+			ImageProcessor ip = imp.getProcessor();
+			ip.reset();
+			int xoffset=0, yoffset=0;
+			Roi croi = clipboard.getRoi();
+			if (croi!=null) {
+				Rectangle r = croi.getBounds();
+				if (r.x<0) xoffset=-r.x;
+				if (r.y<0) yoffset=-r.y;
+			}
+			ip.copyBits(clipboard.getProcessor(), x+xoffset, y+yoffset, pasteMode);
+			if (type!=RECTANGLE)
+				ip.reset(ip.getMask());
+			if (ic!=null)
+				ic.setImageUpdated();
+		}
+	}
+
+	public void endPaste() {
+		if (clipboard!=null) {
+			updatePaste();
+			clipboard = null;
+			Undo.setup(Undo.FILTER, imp);
+		}
+		activeOverlayRoi = false;
+	}
+
+	public void abortPaste() {
+		clipboard = null;
+		imp.getProcessor().reset();
+		imp.updateAndDraw();
+	}
+
+	/** Returns the default stroke width. */
+	public static double getDefaultStrokeWidth() {
+		return defaultStrokeWidth;
+	}
+
+	/** Sets the default stroke width. */
+	public static void setDefaultStrokeWidth(double width) {
+		defaultStrokeWidth = width<0.0?0.0:width;
+		resetDefaultHandleSize();
+	}
+
+	/** Returns the group value assigned to newly created ROIs. */
+	public static int getDefaultGroup() {
+		return defaultGroup;
+	}
+
+	/** Sets the group value assigned to newly created ROIs, and also
+	 * sets the default ROI color to the group color. Set to zero to not
+	 * have a default group and to use the default ROI color.
+	 * @see #setGroup
+	 * @see #getGroup
+	 * @see #getGroupColor
+	*/
+	public static void setDefaultGroup(int group) {
+		if (group<0 || group>255)
+			throw new IllegalArgumentException("Invalid group: "+group);
+		defaultGroup = group;
+		groupColor = getGroupColor(group);
+	}
+
+	/** Returns the group attribute of this ROI. */
+	public int getGroup() {
+		return this.group;
+	}
+
+	/** Returns the group name associtated with the specified group. */
+	public static String getGroupName(int groupNumber) {
+		if (groupNumber<1 || groupNumber>255)
+			return null;
+		if (groupNames==null && groupNamesString==null)
+			return null;
+		if (groupNames==null)
+			groupNames = groupNamesString.split(",");
+		if (groupNumber>groupNames.length)
+			return null;
+		String name = groupNames[groupNumber-1];
+		if (name==null)
+			return null;
+		return name.length()>0?name:null;
+	}
+
+	public static synchronized void setGroupName(int groupNumber, String name) {
+		if (groupNumber<1 || groupNumber>255)
+			return;
+		if (groupNamesString==null && groupNames==null)
+			groupNames = new String[groupNumber];
+		if (groupNames==null)
+			groupNames = groupNamesString.split(",");
+		if (groupNumber>groupNames.length) {
+			String[] temp = new String[groupNumber];
+			for (int i=0; i<groupNames.length; i++)
+				temp[i] = groupNames[i];
+			groupNames = temp;
+		}
+		//IJ.log("setGroupName: "+groupNumber+"  "+name+"  "+groupNames.length);
+		groupNames[groupNumber-1] = name;
+		groupNamesChanged = true;
+	}
+
+	public static synchronized void saveGroupNames() {
+		if (groupNames==null)
+			return;
+		StringBuilder sb = new StringBuilder(groupNames.length*12);
+		for (int i=0; i<groupNames.length; i++) {
+			String name = groupNames[i];
+			if (name==null)
+				name = "";
+			sb.append(name);
+			if (i<groupNames.length-1)
+				sb.append(",");
+		}
+		groupNamesString = sb.toString();
+		groupNames = null;
+		Prefs.set(NAMES_KEY, groupNamesString);
+	}
+
+	/** Returns the group names as a comma-delimeted string. */
+	public static String getGroupNames() {
+		if (groupNamesChanged && groupNames!=null)
+			saveGroupNames();
+		groupNamesChanged = false;
+		return groupNamesString;
+	}
+
+	/** Sets the group names from a comma-delimeted string. */
+	public static void setGroupNames(String names) {
+		groupNamesString = names;
+		groupNames = null;
+	}
+
+	/** Sets the group of this Roi, and updates stroke color accordingly. */
+	public void setGroup(int group) {
+		if (group<0 || group>255)
+			throw new IllegalArgumentException("Invalid group: "+group);
+		if (group>0)
+			setStrokeColor(getGroupColor(group));
+		if (group==0 && this.group>0)
+			setStrokeColor(null);			
+		this.group = group;
+		if (imp!=null) // Update Roi Color in the GUI
+			imp.draw();
+	}
+
+	/** Retrieves color associated to a given roi group. */
+	private static Color getGroupColor(int group) {
+		Color color = ROIColor; // default ROI color
+		if (group>0) { // read Glasbey Lut
+			if (glasbeyLut==null) {
+				String path = IJ.getDir("luts")+"Glasbey.lut";
+				glasbeyLut = LutLoader.openLut("noerror:"+path);
+				if (glasbeyLut==null)
+					IJ.log("LUT not found: "+path);
+			}
+			if (glasbeyLut!=null)
+				color = new Color(glasbeyLut.getRGB(group));
+		}
+		return color;
+	}
+
+	/** Returns the angle in degrees between the specified line and a horizontal line. */
+	public double getAngle(int x1, int y1, int x2, int y2) {
+		return getFloatAngle(x1, y1, x2, y2);
+	}
+
+	/** Returns the angle in degrees between the specified line and a horizontal line. */
+	public double getFloatAngle(double x1, double y1, double x2, double y2) {
+		double dx = x2-x1;
+		double dy = y1-y2;
+		if (imp!=null && !IJ.altKeyDown()) {
+			Calibration cal = imp.getCalibration();
+			dx *= cal.pixelWidth;
+			dy *= cal.pixelHeight;
+		}
+		return (180.0/Math.PI)*Math.atan2(dy, dx);
+	}
+
+	/** Sets the default (global) color used for ROI outlines.
+	 * @see #getColor()
+	 * @see #setStrokeColor(Color)
+	 */
+	public static void setColor(Color c) {
+		ROIColor = c;
+	}
+
+	/** Returns the default (global) color used for drawing ROI outlines.
+	 * @see #setColor(Color)
+	 * @see #getStrokeColor()
+	 */
+	public static Color getColor() {
+		return ROIColor;
+	}
+
+	/** Sets the color used by this ROI to draw its outline. This color, if not null,
+	 * overrides the global color set by the static setColor() method.
+	 * @see #getStrokeColor
+	 * @see #setStrokeWidth
+	 * @see ij.ImagePlus#setOverlay(ij.gui.Overlay)
+	 */
+	public void setStrokeColor(Color c) {
+		 strokeColor = c;
+	}
+
+	/** Returns the the color used to draw the ROI outline or null if the default color is being used.
+	 * @see #setStrokeColor(Color)
+	 */
+	public Color getStrokeColor() {
+		return	strokeColor;
+	}
+
+	/** Sets the default stroke color. */
+	public static void setDefaultColor(Color color) {
+		 defaultColor = color;
+	}
+
+	/** Sets the fill color used to display this ROI, or set to null to display it transparently.
+	 * @see #getFillColor
+	 * @see #setStrokeColor
+	 */
+	public void setFillColor(Color color) {
+		fillColor = color;
+	}
+
+	/** Returns the fill color used to display this ROI, or null if it is displayed transparently.
+	 * @see #setFillColor
+	 * @see #getStrokeColor
+	 */
+	public Color getFillColor() {
+		return fillColor;
+	}
+
+	public static void setDefaultFillColor(Color color) {
+		defaultFillColor = color;
+	}
+
+	public static Color getDefaultFillColor() {
+		return defaultFillColor;
+	}
+
+	public void setAntiAlias(boolean antiAlias) {
+		this.antiAlias = antiAlias;
+	}
+
+	public boolean getAntiAlias() {
+		return antiAlias;
+	}
+
+	protected void setRenderingHint(Graphics2D g2d) {
+		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+			antiAlias?RenderingHints.VALUE_ANTIALIAS_ON:RenderingHints.VALUE_ANTIALIAS_OFF);
+	}
+
+	/** Copy the attributes (outline color, fill color, outline width)
+		of	'roi2' to the this selection. */
+	public void copyAttributes(Roi roi2) {
+		this. strokeColor = roi2. strokeColor;
+		this.fillColor = roi2.fillColor;
+		this.setStrokeWidth(roi2.getStrokeWidth());
+		this.setName(roi2.getName());
+		this.group = roi2.group;
+	}
+
+	/**
+	* @deprecated
+	* replaced by setStrokeColor()
+	*/
+	public void setInstanceColor(Color c) {
+		 strokeColor = c;
+	}
+
+	/**
+	* @deprecated
+	* replaced by setStrokeWidth(int)
+	*/
+	public void setLineWidth(int width) {
+		setStrokeWidth(width) ;
+	}
+
+	public void updateWideLine(float width) {
+		if (isLine()) {
+			wideLine = true;
+			setStrokeWidth(width);
+			if (getStrokeColor()==null) {
+				Color c = getColor();
+				setStrokeColor(new Color(c.getRed(),c.getGreen(),c.getBlue(), 77));
+			}
+		}
+	}
+
+	/** Set 'nonScalable' true to have TextRois in a display
+		list drawn at a fixed location and size. */
+	public void setNonScalable(boolean nonScalable) {
+		this.nonScalable = nonScalable;
+	}
+
+	/** Sets the width of the line used to draw this ROI. Set
+	 * the width to 0.0 and the ROI will be drawn using a
+	 * a 1 pixel stroke width regardless of the magnification.
+	 * @see #setDefaultStrokeWidth(double)
+	 * @see #setStrokeColor(Color)
+	 * @see ij.ImagePlus#setOverlay(ij.gui.Overlay)
+	 */
+	public void setStrokeWidth(float strokeWidth) {
+		if (strokeWidth<0f)
+			strokeWidth = 0f;
+		if (strokeWidth==0f && usingDefaultStroke)
+			return;
+		if (strokeWidth>0f) {
+			scaleStrokeWidth = true;
+			usingDefaultStroke = false;
+		}
+		boolean notify = listeners.size()>0 && isLine() && getStrokeWidth()!=strokeWidth;
+		if (strokeWidth==0f)
+			this.stroke = null;
+		else if (wideLine)
+			this.stroke = new BasicStroke(strokeWidth, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
+		else
+			this.stroke = new BasicStroke(strokeWidth);
+		if (strokeWidth>1f)
+			fillColor = null;
+		if (notify)
+			notifyListeners(RoiListener.MODIFIED);
+	}
+
+	/** This is a version of setStrokeWidth() that accepts a double argument. */
+	public void setStrokeWidth(double strokeWidth) {
+		setStrokeWidth((float)strokeWidth);
+	}
+
+	public void setUnscalableStrokeWidth(double strokeWidth) {
+		setStrokeWidth((float)strokeWidth);
+		scaleStrokeWidth = false;
+
+	}
+
+	/** Returns the lineWidth. */
+	public float getStrokeWidth() {
+		return (stroke!=null&&!usingDefaultStroke)?stroke.getLineWidth():0f;
+	}
+
+	/** Sets the Stroke used to draw this ROI. */
+	public void setStroke(BasicStroke stroke) {
+		this.stroke = stroke;
+		if (stroke!=null)
+			usingDefaultStroke = false;
+	}
+
+	/** Returns the Stroke used to draw this ROI, or null if no Stroke is used. */
+	public BasicStroke getStroke() {
+		if (usingDefaultStroke)
+			return null;
+		else
+			return stroke;
+	}
+
+	/** Returns 'true' if the stroke width is scaled as images are zoomed. */
+	public boolean getScaleStrokeWidth() {
+		return scaleStrokeWidth;
+	}
+
+	protected BasicStroke getScaledStroke() {
+		if (ic==null || usingDefaultStroke || !scaleStrokeWidth)
+			return stroke;
+		double mag = ic.getMagnification();
+		if (mag!=1.0) {
+			float width = (float)(stroke.getLineWidth()*mag);
+			//return new BasicStroke(width, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL);
+			return new BasicStroke(width, stroke.getEndCap(), stroke.getLineJoin(), stroke.getMiterLimit(), stroke.getDashArray(), stroke.getDashPhase());
+		} else
+			return stroke;
+	}
+
+	/** Returns the name of this ROI, or null. */
+	public String getName() {
+		return name;
+	}
+
+	/** Sets the name of this ROI. */
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	/** Sets the Paste transfer mode.
+		@see ij.process.Blitter
+	*/
+	public static void setPasteMode(int transferMode) {
+		if (transferMode==pasteMode) return;
+		pasteMode = transferMode;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			imp.updateAndDraw();
+	}
+
+	/** Sets the rounded rectangle corner diameter (pixels). */
+	public void setCornerDiameter(int cornerDiameter) {
+		if (cornerDiameter<0) cornerDiameter = 0;
+		this.cornerDiameter = cornerDiameter;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null && this==imp.getRoi())
+			imp.updateAndDraw();
+	}
+
+	/** Returns the rounded rectangle corner diameter (pixels). */
+	public int getCornerDiameter() {
+		return cornerDiameter;
+	}
+
+	/** Obsolete; replaced by setCornerDiameter(). */
+	public void setRoundRectArcSize(int cornerDiameter) {
+		setCornerDiameter(cornerDiameter);
+	}
+
+	/** Obsolete; replaced by getCornerDiameter(). */
+	public int getRoundRectArcSize() {
+		return cornerDiameter;
+	}
+
+	/** Sets the stack position (image number) of this ROI. In an overlay, this
+	* ROI is only displayed when the stack is at the specified position.
+	* Set to zero to have the ROI displayed on all images in the stack.
+	* @see ij.gui.Overlay
+	*/
+	public void setPosition(int n) {
+		if (n<0) n=0;
+		position = n;
+		channel = slice = frame = 0;
+		hyperstackPosition = false;
+	}
+
+	/** Returns the stack position (image number) of this ROI, or
+	*  zero if the ROI is not associated with a particular stack image.
+	* @see ij.gui.Overlay
+	*/
+	public int getPosition() {
+		return position;
+	}
+
+	/** Sets the hyperstack position of this ROI. In an overlay, this
+	* ROI is only displayed when the hyperstack is at the specified position.
+	* @see ij.gui.Overlay
+	*/
+	public void setPosition(int channel, int slice, int frame) {
+		if (channel<0) channel=0;
+		this.channel = channel;
+		if (slice<0) slice=0;
+		this.slice = slice;
+		if (frame<0) frame=0;
+		this.frame = frame;
+		position = 0;
+		hyperstackPosition = true;
+	}
+
+	/** Returns 'true' if setPosition(C,Z,T) has been called. */
+	public boolean hasHyperStackPosition() {
+		return hyperstackPosition;
+	}
+
+	/** Sets the position of this ROI based on the stack position of the specified image.  */
+	public void setPosition(ImagePlus imp ) {
+		if (imp==null)
+			return;
+		if (imp.isHyperStack()) {
+			int channel = imp.getDisplayMode()==IJ.COMPOSITE?0:imp.getChannel();
+			setPosition(channel, imp.getSlice(), imp.getFrame());
+		} else if (imp.getStackSize()>1)
+			setPosition(imp.getCurrentSlice());
+		else
+			setPosition(0);
+	}
+
+	/** Returns the channel position of this ROI, or zero
+	*  if this ROI is not associated with a particular channel.
+	*/
+	public final int getCPosition() {
+		return channel;
+	}
+
+	/** Returns the slice position of this ROI, or zero
+	*  if this ROI is not associated with a particular slice.
+	*/
+	public final int getZPosition() {
+		return slice==0&&!hyperstackPosition?position:slice;
+	}
+
+	/** Returns the frame position of this ROI, or zero
+	*  if this ROI is not associated with a particular frame.
+	*/
+	public final int getTPosition() {
+		return frame;
+	}
+
+	// Used by the FileSaver and RoiEncoder to save overlay settings. */
+	public void setPrototypeOverlay(Overlay overlay) {
+		prototypeOverlay = new Overlay();
+		prototypeOverlay.drawLabels(overlay.getDrawLabels());
+		prototypeOverlay.drawNames(overlay.getDrawNames());
+		prototypeOverlay.drawBackgrounds(overlay.getDrawBackgrounds());
+		prototypeOverlay.setLabelColor(overlay.getLabelColor());
+		prototypeOverlay.setLabelFont(overlay.getLabelFont(), overlay.scalableLabels());
+	}
+
+	// Used by the FileOpener and RoiDecoder to restore overlay settings. */
+	public Overlay getPrototypeOverlay() {
+		if (prototypeOverlay!=null)
+			return prototypeOverlay;
+		else
+			return new Overlay();
+	}
+
+	/** Returns the current paste transfer mode, or NOT_PASTING (-1)
+		if no paste operation is in progress.
+		@see ij.process.Blitter
+	*/
+	public int getPasteMode() {
+		if (clipboard==null)
+			return NOT_PASTING;
+		else
+			return pasteMode;
+	}
+
+	/** Returns the current paste transfer mode. */
+	public static int getCurrentPasteMode() {
+		return pasteMode;
+	}
+
+	/** Returns 'true' if this is an area selection. */
+	public boolean isArea() {
+		return (type>=RECTANGLE && type<=TRACED_ROI) || type==COMPOSITE;
+	}
+
+	/** Returns 'true' if this is a line selection. */
+	public boolean isLine() {
+		return type>=LINE && type<=FREELINE;
+	}
+
+
+	/** Return 'true' if this is a line or point selection. */
+	protected boolean isLineOrPoint() {
+		return isLine() || type==POINT;
+	}
+
+	/** Returns 'true' if this is an ROI primarily used from drawing
+		(e.g., TextRoi or Arrow). */
+	public boolean isDrawingTool() {
+		//return cornerDiameter>0;
+		return false;
+	}
+
+	protected double getMagnification() {
+		return ic!=null?ic.getMagnification():1.0;
+	}
+
+	/** Convenience method that converts Roi type to a human-readable form. */
+	public String getTypeAsString() {
+		String s="";
+		switch(type) {
+			case POLYGON: s="Polygon";
+				if (this instanceof EllipseRoi) s="Ellipse";
+				if (this instanceof RotatedRectRoi) s="Rotated Rectangle";
+				break;
+			case FREEROI: s="Freehand"; break;
+			case TRACED_ROI: s="Traced"; break;
+			case POLYLINE: s="Polyline"; break;
+			case FREELINE: s="Freeline"; break;
+			case ANGLE: s="Angle"; break;
+			case LINE: s=this instanceof Arrow ? "Arrow" : "Straight Line"; break;
+			case OVAL: s="Oval"; break;
+			case COMPOSITE: s = "Composite"; break;
+			case POINT: s="Point"; break;
+			default:
+				if (this instanceof TextRoi)
+					s = "Text";
+				else if (this instanceof ImageRoi)
+					s = "Image";
+				else
+					s = "Rectangle";
+				break;
+		}
+		return s;
+	}
+
+	/** Returns true if this ROI is currently displayed on an image. */
+	public boolean isVisible() {
+		return ic!=null;
+	}
+
+	/** Returns true if this is a slection that supports sub-pixel resolution. */
+	public boolean subPixelResolution() {
+		return subPixel;
+	}
+
+	/** @deprecated Drawoffset is not used any more. */
+	@Deprecated
+	public boolean getDrawOffset() {
+		return false;
+	}
+
+	/** @deprecated This method was previously used to draw lines and polylines shifted
+	 *  by 0.5 pixels top the bottom and right, for better agreement with the
+	 *  position used by ProfilePlot, with the default taken from
+	 *  Prefs.subPixelResolution. Now the shift is independent of this
+	 *  setting and only depends on the ROI type (area or line/point ROI). */
+	@Deprecated
+	public void setDrawOffset(boolean drawOffset) {
+	}
+
+	public void setIgnoreClipRect(boolean ignoreClipRect) {
+		this.ignoreClipRect = ignoreClipRect;
+	}
+
+	/** Returns 'true' if this ROI is displayed and is also in an overlay. */
+	public final boolean isActiveOverlayRoi() {
+		if (imp==null || this!=imp.getRoi())
+			return false;
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null && overlay.contains(this))
+			return true;
+		ImageCanvas ic = imp.getCanvas();
+		overlay = ic!=null?ic.getShowAllList():null; // ROI Manager overlay
+		return overlay!=null && overlay.contains(this);
+	}
+
+	/** Checks whether two rectangles are equal. */
+	public boolean equals(Object obj) {
+		if (obj instanceof Roi) {
+			Roi roi2 = (Roi)obj;
+			if (type!=roi2.getType()) return false;
+			if (!getBounds().equals(roi2.getBounds())) return false;
+			if (getLength()!=roi2.getLength()) return false;
+			return true;
+		} else
+			return false;
+	}
+
+	/** Converts image canvas screen x coordinates to integer offscreen image pixel
+	 *  coordinates, depending on whether this roi uses the line or area convention
+	 *  for coordinates. */
+	protected int offScreenX(int sx) {
+		if (ic == null) return sx;
+		return useLineSubpixelConvention() ? ic.offScreenX(sx) : ic.offScreenX2(sx);
+	}
+
+	/** Converts image canvas screen y coordinates to integer offscreen image pixel
+	 *  coordinates, depending on whether this roi uses the line or area convention
+	 *  for coordinates. */
+	protected int offScreenY(int sy) {
+		if (ic == null) return sy;
+		return useLineSubpixelConvention() ? ic.offScreenY(sy) : ic.offScreenY2(sy);
+	}
+
+	/** Converts image canvas screen x coordinates to floating-point offscreen image pixel
+	 *  coordinates, depending on whether this roi uses the line or area convention
+	 *  for coordinates. */
+	protected double offScreenXD(int sx) {
+		if (ic == null) return sx;
+		double offScreenValue = ic.offScreenXD(sx);
+		if (useLineSubpixelConvention())
+			offScreenValue -= 0.5;
+		return offScreenValue;
+	}
+
+	/** Converts image canvas screen y coordinates to floating-point offscreen image pixel
+	 *  coordinates, depending on whether this roi uses the line or area convention
+	 *  for coordinates. */
+	protected double offScreenYD(int sy) {
+		if (ic == null) return sy;
+		double offScreenValue = ic.offScreenYD(sy);
+		if (useLineSubpixelConvention())
+			offScreenValue -= 0.5;
+		return offScreenValue;
+	}
+
+	/** Returns 'true' if this ROI uses for drawing the convention for
+	 *  line and point ROIs, where the coordinates are with respect
+	 *  to the pixel center.
+	 *  Returns false for area rois, which have coordinates with respect to
+	 *  the upper left corners of the pixels */
+	protected boolean useLineSubpixelConvention() {
+		return isLineOrPoint();
+	}
+
+	/** Returns whether a roi created interactively should have subpixel resolution,
+	 *  (if the roi type supports it), i.e., whether the magnification is high enough */
+	protected boolean magnificationForSubPixel() {
+		return magnificationForSubPixel(getMagnification());
+	}
+
+	protected static boolean magnificationForSubPixel(double magnification) {
+		return magnification > 1.5;
+	}
+
+	/**Converts an image pixel x (offscreen)coordinate to a screen x coordinate,
+	 * taking the the line or area convention for coordinates into account */
+	protected int screenXD(double ox) {
+		if (ic == null) return (int)ox;
+		if (useLineSubpixelConvention()) ox += 0.5;
+		return ic.screenXD(ox);
+	}
+
+	/**Converts an image pixel y (offscreen)coordinate to a screen y coordinate,
+	 * taking the the line or area convention for coordinates into account */
+	protected int screenYD(double oy) {
+		if (ic == null) return (int)oy;
+		if (useLineSubpixelConvention()) oy += 0.5;
+		return ic.screenYD(oy);
+	}
+
+	protected int screenX(int ox) {return screenXD(ox);}
+	protected int screenY(int oy) {return screenYD(oy);}
+
+	/** Converts a float array to an int array using truncation. */
+	public static int[] toInt(float[] arr) {
+		return toInt(arr, null, arr.length);
+	}
+
+	public static int[] toInt(float[] arr, int[] arr2, int size) {
+		int n = arr.length;
+		if (size>n) size=n;
+		int[] temp = arr2;
+		if (temp==null || temp.length<n)
+			temp = new int[n];
+		for (int i=0; i<size; i++)
+			temp[i] = (int)arr[i];
+		return temp;
+	}
+
+	/** Converts a float array to an int array using rounding. */
+	public static int[] toIntR(float[] arr) {
+		int n = arr.length;
+		int[] temp = new int[n];
+		for (int i=0; i<n; i++)
+			temp[i] = (int)Math.floor(arr[i]+0.5);
+		return temp;
+	}
+
+	/** Converts an int array to a float array. */
+	public static float[] toFloat(int[] arr) {
+		int n = arr.length;
+		float[] temp = new float[n];
+		for (int i=0; i<n; i++)
+			temp[i] = arr[i];
+		return temp;
+	}
+
+	/** Returns whether a number is an integer */
+	public static boolean isInteger(double x) {
+		return x == (int)x;
+	}
+
+	public void setProperty(String key, String value) {
+		if (key==null) return;
+		if (props==null)
+			props = new Properties();
+		if (value==null || value.length()==0)
+			props.remove(key);
+		else
+			props.setProperty(key, value);
+	}
+
+	public String getProperty(String property) {
+		if (props==null)
+			return null;
+		else
+			return props.getProperty(property);
+	}
+
+	public void setProperties(String properties) {
+		if (props==null)
+			props = new Properties();
+		else
+			props.clear();
+		try {
+			InputStream is = new ByteArrayInputStream(properties.getBytes("utf-8"));
+			props.load(is);
+		} catch(Exception e) {
+			IJ.error(""+e);
+		}
+	}
+
+	public String getProperties() {
+		if (props==null)
+			return null;
+		Vector v = new Vector();
+		for (Enumeration en=props.keys(); en.hasMoreElements();)
+			v.addElement(en.nextElement());
+		String[] keys = new String[v.size()];
+		for (int i=0; i<keys.length; i++)
+			keys[i] = (String)v.elementAt(i);
+		Arrays.sort(keys);
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<keys.length; i++) {
+			sb.append(keys[i]);
+			sb.append(": ");
+			sb.append(props.get(keys[i]));
+			sb.append("\n");
+		}
+		return sb.toString();
+	}
+
+	public int getPropertyCount() {
+		if (props==null)
+			return 0;
+		else
+			return props.size();
+	}
+
+	public String toString() {
+		return ("Roi["+getTypeAsString()+", x="+x+", y="+y+", width="+width+", height="+height+"]");
+	}
+
+	/** Deprecated */
+	public void temporarilyHide() {
+	}
+
+	public void mouseDragged(MouseEvent e) {
+		handleMouseDrag(e.getX(), e.getY(), e.getModifiers());
+	}
+
+	public void mouseMoved(MouseEvent e) {
+	}
+
+	public void mouseReleased(MouseEvent e) {
+		handleMouseUp(e.getX(), e.getY());
+	}
+
+	public double getXBase() {
+		if (bounds!=null)
+			return bounds.x;
+		else
+			return x;
+	}
+
+	public double getYBase() {
+		if (bounds!=null)
+			return bounds.y;
+		else
+			return y;
+	}
+
+	public double getFloatWidth() {
+		if (bounds!=null)
+			return bounds.width;
+		else
+			return width;
+	}
+
+	public double getFloatHeight() {
+		if (bounds!=null)
+			return bounds.height;
+		else
+			return height;
+	}
+
+	/** Overridden by PolygonRoi (angle between first two points), TextRoi (text angle) and Line (line angle). */
+	public double getAngle() {
+		return 0.0;
+	}
+
+	public void enableSubPixelResolution() {
+		bounds = new Rectangle2D.Double(getXBase(), getYBase(), getFloatWidth(), getFloatHeight());
+		subPixel = true;
+	}
+
+	public void setIsCursor(boolean isCursor) {
+		this.isCursor = isCursor;
+	}
+
+	public boolean isCursor() {
+		return isCursor;
+	}
+
+	public String getDebugInfo() {
+		return "";
+	}
+
+	public ImageStatistics getStatistics() {
+		Roi roi = this;
+		ImageProcessor ip = null;
+		if (imp!=null)
+			ip = imp.getProcessor();
+		boolean noImage = ip==null;
+		Rectangle bounds = null;
+		if (noImage) {
+			roi = (Roi)this.clone();
+			bounds = roi.getBounds();
+			ip = new ByteProcessor(bounds.width, bounds.height);
+			roi.setLocation(0, 0);
+		}
+		if (roi.isLine())
+			roi = null;
+		ip.setRoi(roi);
+		ImageStatistics stats = ip.getStatistics();
+		if (noImage) {
+			stats.mean = stats.min = stats.max = Double.NaN;
+			stats.xCentroid+=bounds.x; stats.yCentroid+=bounds.y;
+		}
+		ip.resetRoi();
+		return stats;
+	}
+
+	public FloatPolygon getRotationCenter() {
+		FloatPolygon p = new FloatPolygon();
+		Rectangle2D r = getFloatBounds();
+		if (Double.isNaN(xcenter)) {
+			xcenter = r.getX()+r.getWidth()/2.0;
+			ycenter = r.getY()+r.getHeight()/2.0;
+		}
+		p.addPoint(xcenter,ycenter);
+		return p;
+	}
+
+	public void setRotationCenter(double x, double y) {
+		xcenter = x;
+		ycenter = y;
+	}
+
+	/** Returns the number of points in this selection; equivalent to getFloatPolygon().npoints. */
+	public int size() {
+		return getFloatPolygon().npoints;
+	}
+
+	/** Saves 'roi' so it can be restored later using Edit/Selection/Restore Selection. */
+	public static void setPreviousRoi(Roi roi) {
+		if (roi!=null) {
+			previousRoi = (Roi)roi.clone();
+			previousRoi.setImage(null);
+		} else
+			previousRoi = null;
+	}
+
+	/** Returns the Roi saved by setPreviousRoi(). */
+	public static Roi getPreviousRoi() {
+		return previousRoi;
+	}
+
+	/*
+	 * Returns the center of the of this selection's countour, or the
+	 * center of the bounding box of composite selections.<br>
+	 * Author: Peter Haub (phaub at dipsystems.de)
+	 */
+	public double[] getContourCentroid() {
+		double xC=0, yC=0, lSum=0, x, y, dx, dy, l;
+		FloatPolygon poly = getFloatPolygon();
+		int nPoints = poly.npoints;
+		int n2 = nPoints-1;
+		for (int n1=0; n1<nPoints; n1++) {
+			dx = poly.xpoints[n1] - poly.xpoints[n2];
+			dy = poly.ypoints[n1] - poly.ypoints[n2];
+			x = poly.xpoints[n2] + dx/2.0;
+			y = poly.ypoints[n2] + dy/2.0;
+			l = Math.sqrt(dx*dx + dy*dy);
+			xC += x*l;
+			yC += y*l;
+			lSum += l;
+			n2 = n1;
+		}
+		xC /= lSum;
+		yC /= lSum;
+		return new double[]{xC, yC};
+	}
+
+	/** Obsolete, replaced by Roi.convertLineToArea()
+	 * @deprecated
+	*/
+	public Roi convertToPolygon() {
+		return convertLineToArea(this);
+	}
+
+	/** Converts a line selection into an area (polygon or composite) selection.<br>
+	 * Author: Michael Schmid
+	*/
+	public static Roi convertLineToArea(Roi line) {
+		if (line==null || !line.isLine())
+			throw new IllegalArgumentException("Line selection required");
+		double lineWidth = line.getStrokeWidth();
+		Roi roi2 = null;
+		if (line.getType()==Roi.LINE) {
+			if (lineWidth<=1.0)
+				lineWidth = 1.0000001;
+			FloatPolygon p = ((Line)line).getFloatPolygon(lineWidth);
+			roi2 = new PolygonRoi(p, Roi.POLYGON);
+			line.setStrokeWidth(lineWidth);
+		} else {
+			if (lineWidth<1)
+				lineWidth = 1;
+			Rectangle bounds = line.getBounds();
+			double width = bounds.x+bounds.width + lineWidth;
+			double height = bounds.y+bounds.height + lineWidth;
+			ByteProcessor ip = new ByteProcessor((int)Math.round(width), (int)Math.round(height));
+			PolygonFiller polygonFiller = new PolygonFiller();
+			//ip.setColor(255);
+			double radius = lineWidth/2.0;
+			FloatPolygon p = line.getFloatPolygon();
+			int n = p.npoints;
+			float[] xv = new float[4]; //vertex points of rectangle will be filled for each line segment
+			float[] yv = new float[4];
+			float[] xt = new float[3]; //vertex points of triangle will be filled between line segments
+			float[] yt = new float[3];
+			double dx1 = p.xpoints[1]-p.xpoints[0];
+			double dy1 = p.ypoints[1]-p.ypoints[0];
+			double l = length(dx1, dy1);
+			dx1 = dx1/l;			   //unit vector along current line segment
+			dy1 = dy1/l;
+			double dx0 = dx1;
+			double dy0 = dy1;
+			double xfrom = p.xpoints[0] - 0.5*dx1;
+			double yfrom = p.ypoints[0] - 0.5*dy1;
+			//Overlay ovly = new Overlay();
+			for (int i=1; i<n; i++) { //line segment from point i-1 ("from") to point i ("to")
+				double xto = p.xpoints[i];
+				double yto = p.ypoints[i];
+				if (i==n-1) {
+					xto += 0.5*dx1;
+					yto += 0.5*dy1;
+				}
+				xv[0] = (float)(xfrom + radius*dy1);
+				yv[0] = (float)(yfrom - radius*dx1);
+				xv[1] = (float)(xfrom - radius*dy1);
+				yv[1] = (float)(yfrom + radius*dx1);
+				xv[2] = (float)(xto - radius*dy1);
+				yv[2] = (float)(yto + radius*dx1);
+				xv[3] = (float)(xto + radius*dy1);
+				yv[3] = (float)(yto - radius*dx1);
+				polygonFiller.setPolygon(xv, yv, 4, 0.5f, 0.5f); //offset 0.5 pxl: line vs area coordinate convention
+				polygonFiller.fillByteProcessorMask(ip);
+				//ovly.add(new PolygonRoi(xv,yv,Roi.POLYGON));
+				if (i>1) {  //fill triangle to previous line segment
+					boolean rightTurn=(dx1*dy0>dx0*dy1);
+					xt[0] = (float)xfrom;
+					yt[0] = (float)yfrom;
+					if (rightTurn) {
+						xt[1] = (float)(xfrom-radius*dy0);
+						yt[1] = (float)(yfrom+radius*dx0);
+						xt[2] = (float)(xfrom-radius*dy1);
+						yt[2] = (float)(yfrom+radius*dx1);
+						xt[0] += (float)(0.5*(radius*dy0+radius*dy1));  //extend triangle to avoid missing pixels (due to rounding errors)
+						yt[0] -= (float)(0.5*(radius*dx0+radius*dx1));  //where it touches a rectangle
+					} else {
+						xt[1] = (float)(xfrom+radius*dy0);
+						yt[1] = (float)(yfrom-radius*dx0);
+						xt[2] = (float)(xfrom+radius*dy1);
+						yt[2] = (float)(yfrom-radius*dx1);
+						xt[0] -= (float)(0.5*(radius*dy0+radius*dy1));
+						yt[0] += (float)(0.5*(radius*dx0+radius*dx1));
+					}
+					polygonFiller.setPolygon(xt, yt, 3, 0.5f, 0.5f);
+					polygonFiller.fillByteProcessorMask(ip);
+					//ovly.add(new PolygonRoi(xt,yt,Roi.POLYGON));
+				}
+				dx0 = dx1;
+				dy0 = dy1;
+				xfrom = xto;
+				yfrom = yto;
+				if (i<n-1) {
+					dx1 = p.xpoints[i+1]-p.xpoints[i];
+					dy1 = p.ypoints[i+1]-p.ypoints[i];
+					l = length(dx1, dy1);
+					dx1 = dx1/l;	   //unit vector along next line segment
+					dy1 = dy1/l;
+				}
+			}
+			//IJ.getImage().setOverlay(ovly);
+			ip.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+			ThresholdToSelection tts = new ThresholdToSelection();
+			roi2 = tts.convert(ip);
+		}
+		if (roi2==null)
+			return null;
+		transferProperties(line, roi2);
+		roi2.setStrokeWidth(0);
+		Color c = roi2.getStrokeColor();
+		if (c!=null)  // remove any transparency
+			roi2.setStrokeColor(new Color(c.getRed(),c.getGreen(),c.getBlue()));
+		return roi2;
+	}
+
+	/** Returns the length of a vector with components dx, dy */
+	static double length(double dx, double dy) {
+		return Math.sqrt(dx*dx+dy*dy);
+	}
+
+	/** Used by PolygonRoi, Line, ShapeRoi etc. */
+	static double sqr(double x) {return x*x; }
+
+	private static void transferProperties(Roi roi1, Roi roi2) {
+		if (roi1==null || roi2==null)
+			return;
+		roi2.setStrokeColor(roi1.getStrokeColor());
+		if (roi1.getStroke()!=null)
+			roi2.setStroke(roi1.getStroke());
+		roi2.setDrawOffset(roi1.getDrawOffset());
+	}
+
+	/** Returns a hashcode for this Roi that typically changes
+		if it is moved, even though it is still the same object. */
+	public int getHashCode() {
+		return hashCode() ^ (new Double(getXBase()).hashCode()) ^
+			Integer.rotateRight(new Double(getYBase()).hashCode(),16);
+	}
+
+	public void setFlattenScale(double scale) {
+		flattenScale = scale;
+	}
+
+	public void notifyListeners(int id) {
+		if (id==RoiListener.CREATED) {
+			if (listenersNotified)
+				return;
+			listenersNotified = true;
+		}
+		synchronized (listeners) {
+			for (int i=0; i<listeners.size(); i++) {
+				RoiListener listener = (RoiListener)listeners.elementAt(i);
+				listener.roiModified(imp, id);
+			}
+		}
+	}
+
+	public static Roi xor(Roi[] rois) {
+		ShapeRoi s1=null, s2=null;
+		for (int i=0; i<rois.length; i++) {
+			Roi roi = rois[i];
+			if (roi==null)
+				continue;
+			if (s1==null) {
+				if (roi instanceof ShapeRoi)
+					s1 = (ShapeRoi)roi.clone();
+				else
+					s1 = new ShapeRoi(roi);
+				if (s1==null) return null;
+			} else {
+				if (roi instanceof ShapeRoi)
+					s2 = (ShapeRoi)roi.clone();
+				else
+					s2 = new ShapeRoi(roi);
+				if (s2==null) continue;
+				s1.xor(s2);
+			}
+		}
+		return s1!=null?s1.trySimplify():null;
+	}
+
+	public static void addRoiListener(RoiListener listener) {
+		listeners.addElement(listener);
+	}
+
+	public static void removeRoiListener(RoiListener listener) {
+		listeners.removeElement(listener);
+	}
+
+	public static Vector getListeners() {
+		return listeners;
+	}
+
+	/**
+	 * Required by the {@link Iterable} interface.
+	 * Use to iterate over the contained coordinates. Usage example:
+	 * <pre>
+	 * for (Point p : roi) {
+	 *   // process p
+	 * }
+	 * </pre>
+	 * Author: Wilhelm Burger
+	 * @see #getContainedPoints()
+	 * @see #getContainedFloatPoints()
+	*/
+	public Iterator<Point> iterator() {
+		// Returns the default (mask-based) point iterator. Note that 'Line' overrides the
+		// iterator() method and returns a specific point iterator.
+		return new RoiPointsIteratorMask();
+	}
+
+
+	/**
+	 * Default iterator over points contained in a mask-backed {@link Roi}.
+	 * Author: W. Burger
+	*/
+	private class RoiPointsIteratorMask implements Iterator<Point> {
+		private ImageProcessor mask;
+		private final Rectangle bounds;
+		private final int xbase, ybase;
+		private final int n;
+		private int next;
+
+		RoiPointsIteratorMask() {
+			if (isLine()) {
+				Roi roi2 = Roi.convertLineToArea(Roi.this);
+				mask = roi2.getMask();
+				xbase = roi2.x;
+				ybase = roi2.y;
+			} else {
+				mask = getMask();
+				if (mask==null && type==RECTANGLE) {
+					mask = new ByteProcessor(width, height);
+					mask.invert();
+				}
+				xbase = Roi.this.x;
+				ybase = Roi.this.y;
+			}
+			bounds = new Rectangle(mask.getWidth(), mask.getHeight());
+			n = bounds.width * bounds.height;
+			findNext(0);	// sets next
+		}
+
+		@Override
+		public boolean hasNext() {
+			return next < n;
+		}
+
+		@Override
+		public Point next() {
+			if (next >= n)
+				throw new NoSuchElementException();
+			int x = next % bounds.width;
+			int y = next / bounds.width;
+			findNext(next+1);
+			return new Point(xbase+x, ybase+y);
+		}
+
+		@Override
+		public void remove() {
+			throw new UnsupportedOperationException();
+		}
+
+		// finds the next element (from start), sets next
+		private void findNext(int start) {
+			if (mask == null)
+				next = start;
+			else {
+				next = n;
+				for (int i=start; i<n; i++) {
+					if (mask.get(i)!=0) {
+						next = i;
+						break;
+					}
+				}
+			}
+		}
+	}
+
+}
diff --git a/src/ij/gui/RoiBrush.java b/src/ij/gui/RoiBrush.java
new file mode 100644
index 0000000..87c7d82
--- /dev/null
+++ b/src/ij/gui/RoiBrush.java
@@ -0,0 +1,88 @@
+package ij.gui;
+import ij.*;
+import java.awt.*;
+
+/** Implements the ROI Brush tool.*/
+class RoiBrush implements Runnable {
+	static int ADD=0, SUBTRACT=1;
+	static int leftClick=16, alt=9, shift=1;
+	private Polygon poly;
+	private Point previousP;
+	private int mode = ADD;
+ 
+	RoiBrush() {
+		Thread thread = new Thread(this, "RoiBrush");
+		thread.start();
+	}
+
+	public void run() {
+		int size = Toolbar.getBrushSize();
+		ImagePlus img = WindowManager.getCurrentImage();
+		if (img==null) return;
+		ImageCanvas ic = img.getCanvas();
+		if (ic==null) return;
+		Roi roi = img.getRoi();
+		if (roi!=null && !roi.isArea())
+			img.deleteRoi();
+		Point p = ic.getCursorLoc();
+		if (roi!=null && !roi.contains(p.x, p.y))
+			mode = SUBTRACT;
+		int flags;
+		while (true) {
+			p = ic.getCursorLoc();
+			if (p.equals(previousP))
+				{IJ.wait(1); continue;}
+			previousP = p;
+			flags = ic.getModifiers();
+			if ((flags&leftClick)==0) return;
+			if ((flags&shift)!=0)
+				mode = ADD;
+			else if ((flags&alt)!=0)
+				mode = SUBTRACT;
+			if (mode==ADD)
+				addCircle(img, p.x, p.y, size);
+			else
+				subtractCircle(img, p.x, p.y, size);
+		}
+	}
+
+	void addCircle(ImagePlus img, int x, int y, int width) {
+		Roi roi = img.getRoi();
+		Roi roi2 = roi;
+		if (roi2!=null) {
+			if (!(roi2 instanceof ShapeRoi))
+				roi2 = new ShapeRoi(roi2);
+			((ShapeRoi)roi2).or(getCircularRoi(x, y, width));
+			roi2.copyAttributes(roi);
+		} else
+			roi2 = new OvalRoi(x-width/2, y-width/2, width, width);
+		img.setRoi(roi2);
+	}
+
+	void subtractCircle(ImagePlus img, int x, int y, int width) {
+		Roi roi = img.getRoi();
+		Roi roi2 = roi;
+		if (roi2!=null) {
+			if (!(roi2 instanceof ShapeRoi))
+			roi2 = new ShapeRoi(roi2);
+			((ShapeRoi)roi2).not(getCircularRoi(x, y, width));
+			roi2.copyAttributes(roi);
+			img.setRoi(roi2);
+		}
+	}
+
+    
+	ShapeRoi getCircularRoi(int x, int y, int width) {
+		if (poly==null) {
+			Roi roi = new OvalRoi(x-width/2, y-width/2, width, width);
+			poly = roi.getPolygon();
+			for (int i=0; i<poly.npoints; i++) {
+				poly.xpoints[i] -= x;
+				poly.ypoints[i] -= y;
+			}
+		}
+		return new ShapeRoi(x, y, poly);
+	}
+
+}
+
diff --git a/src/ij/gui/RoiDefaultsDialog.java b/src/ij/gui/RoiDefaultsDialog.java
new file mode 100644
index 0000000..2bd08bf
--- /dev/null
+++ b/src/ij/gui/RoiDefaultsDialog.java
@@ -0,0 +1,81 @@
+package ij.gui;
+import ij.*;
+import ij.plugin.*;
+import java.awt.*;
+import java.util.Vector;
+
+/** This plugin implements the Edit/Options/Roi Defaults command. */
+public class RoiDefaultsDialog implements PlugIn, DialogListener {
+	private boolean nameChanges;
+
+ 	public void run(String arg) {
+ 		showDialog();
+	}
+				
+	private void showDialog() {
+		String groupNames = Roi.getGroupNames();
+		Color color = Roi.getColor();
+		String cname = Colors.getColorName(color, "yellow");
+		int group = Roi.getDefaultGroup();
+		int strokeWidth = (int)Roi.getDefaultStrokeWidth();
+		String gname = getGroupName(group);
+		GenericDialog gd = new GenericDialog("ROI Defaults");
+		gd.addChoice("Color:", Colors.colors, cname);
+		gd.addNumericField("Stroke width:", strokeWidth, 0, 3, "");
+		gd.setInsets(18, 0, 5);
+		gd.addNumericField("Group:", group, 0, 3, "");
+		gd.setInsets(2, 0, 5);
+		gd.addStringField("Name:", gname, 15);
+		gd.setInsets(2, 50, 5);
+		gd.addMessage("Color predefined if group>0", null, Color.gray);	
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			Roi.setGroupNames(groupNames);
+			Roi.setColor(color);
+			Roi.setDefaultStrokeWidth(strokeWidth);
+			Roi.setDefaultGroup(group);
+			return;
+		}
+		if (nameChanges)
+			Roi.saveGroupNames();
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		int currentGroup = Roi.getDefaultGroup();
+		String cname = gd.getNextChoice();		
+		Color color = Colors.getColor(cname, Color.yellow);
+		Roi.setColor(color);
+		if (color.equals(Roi.getColor())) {
+			Toolbar.repaintTool(Toolbar.POINT);
+			Toolbar.repaintTool(Toolbar.WAND);
+		}
+		Roi.setDefaultStrokeWidth(gd.getNextNumber());
+		int group = (int)gd.getNextNumber();
+		Vector stringFields = gd.getStringFields();
+		TextField nameField = (TextField)(stringFields.get(0));
+		if (group>=0 && group<=255 && group!=currentGroup) {
+			Roi.setDefaultGroup(group);
+			String name = getGroupName(group);
+			nameField.setText(name);
+		} else {
+			String name = getGroupName(group);
+			String name2 = nameField.getText();
+			if (name2!=null && !name2.equals(name)) {
+				Roi.setGroupName(group, name2);
+				nameChanges = true;
+			}
+		}
+		return true;
+	}
+	
+	private String getGroupName(int group) {
+		String gname = Roi.getGroupName(group);		
+		if (group==0)
+			gname = "0 = no group";
+		else if (gname==null)
+			gname = "unnamed";
+		return gname;
+	}
+	
+}
diff --git a/src/ij/gui/RoiListener.java b/src/ij/gui/RoiListener.java
new file mode 100644
index 0000000..5e847eb
--- /dev/null
+++ b/src/ij/gui/RoiListener.java
@@ -0,0 +1,18 @@
+package ij.gui;
+import ij.ImagePlus;
+	
+	/** Plugins that implement this interface are notified when
+		an ROI is created, modified or deleted. The 
+		Plugins/Utilities/Monitor Events command uses this interface.
+	*/
+	public interface RoiListener {
+		public static final int CREATED = 1;
+		public static final int MOVED = 2;
+		public static final int MODIFIED = 3;
+		public static final int EXTENDED = 4;
+		public static final int COMPLETED = 5;
+		public static final int DELETED = 6;
+
+	public void roiModified(ImagePlus imp, int id);
+
+}
diff --git a/src/ij/gui/RoiProperties.java b/src/ij/gui/RoiProperties.java
new file mode 100644
index 0000000..71cabe8
--- /dev/null
+++ b/src/ij/gui/RoiProperties.java
@@ -0,0 +1,428 @@
+package ij.gui;
+import ij.*;
+import ij.plugin.Colors;
+import ij.io.RoiDecoder;
+import ij.process.*;
+import ij.measure.*;
+import ij.util.Tools;
+import ij.plugin.filter.Analyzer;
+import ij.text.TextWindow;
+import java.awt.*;
+import java.util.*;
+import java.awt.event.*;
+
+
+ /** Displays a dialog that allows the user to specify ROI properties such as color and line width. */
+public class RoiProperties implements TextListener, WindowListener {
+	private ImagePlus imp;
+	private Roi roi;
+	private Overlay overlay;
+	private String title;
+	private boolean showName = true;
+	private boolean showListCoordinates;
+	private boolean addToOverlay;
+	private boolean overlayOptions;
+	private boolean setPositions;
+	private boolean listCoordinates;
+	private boolean listProperties;
+	private boolean showPointCounts;
+	private static final String[] justNames = {"Left", "Center", "Right"};
+	private int nProperties;
+	private TextField groupField, colorField;
+	private Label groupName;
+
+	/** Constructs a ColorChooser using the specified title and initial color. */
+	public RoiProperties(String title, Roi roi) {
+		if (roi==null)
+			throw new IllegalArgumentException("ROI is null");
+		this.title = title;
+		showName = title.startsWith("Prop");
+		showListCoordinates = showName && title.endsWith(" ");
+		nProperties = showListCoordinates?roi.getPropertyCount():0;
+		addToOverlay = title.equals("Add to Overlay");
+		overlayOptions = title.equals("Overlay Options");
+		if (overlayOptions) {
+			imp = WindowManager.getCurrentImage();
+			overlay = imp!=null?imp.getOverlay():null;
+			setPositions = roi.getPosition()!=0;
+		}
+		this.roi = roi;
+	}
+	
+	/** Displays the dialog box and returns 'false' if the user cancels it. */
+	public boolean showDialog() {
+		String name= roi.getName();
+		boolean isRange = name!=null && name.startsWith("range:");
+		String nameLabel = isRange?"Range:":"Name:";
+		if (isRange) name = name.substring(7);
+		if (name==null) name = "";
+		if (!isRange && (roi instanceof ImageRoi) && !overlayOptions)
+			return showImageDialog(name);
+		Color strokeColor = roi.getStrokeColor();
+		Color fillColor = roi.getFillColor();
+		double strokeWidth = roi.getStrokeWidth();
+		double strokeWidth2 = strokeWidth;
+		boolean isText = roi instanceof TextRoi;
+		boolean isLine = roi.isLine();
+		boolean isPoint = roi instanceof PointRoi;
+		int justification = TextRoi.LEFT;
+		double angle = 0.0;
+		boolean antialias = true;
+		if (isText) {
+			TextRoi troi = (TextRoi)roi;
+			Font font = troi.getCurrentFont();
+			strokeWidth = font.getSize();
+			angle = troi.getAngle();
+			justification = troi.getJustification();
+			antialias = troi.getAntiAlias();
+		}
+		String position = ""+roi.getPosition();
+		if (roi.hasHyperStackPosition())
+			position =  roi.getCPosition() +","+roi.getZPosition()+","+ roi.getTPosition();
+		if (position.equals("0"))
+			position = "none";
+		String group = ""+roi.getGroup();
+		if (group.equals("0"))
+			group = "none";
+		String linec = Colors.colorToString(strokeColor);
+		String fillc = Colors.colorToString(fillColor);
+		if (IJ.isMacro()) {
+			fillc = "none";
+			setPositions = false;
+		}
+		int digits = (int)strokeWidth==strokeWidth?0:1;
+		GenericDialog gd = new GenericDialog(title);
+		if (showName) {
+			gd.addStringField(nameLabel, name, 20);
+			String label = "Position:";
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (position.contains(",") || (imp!=null&&imp.isHyperStack()))
+				label = "Position (c,s,f):";
+			gd.addStringField(label, position);
+			gd.addStringField("Group:", group);
+			gd.addToSameRow(); gd.addMessage("wwwwwwwwwwww");
+		}
+		if (isText) {
+			gd.addStringField("Stroke color:", linec);
+			gd.addNumericField("Font size:", strokeWidth, digits, 4, "points");
+			digits = (int)angle==angle?0:1;
+			gd.addNumericField("Angle:", angle, digits, 4, "degrees");
+			gd.setInsets(0, 0, 0);
+			gd.addChoice("Justification:", justNames, justNames[justification]);
+		} else {
+			if (isPoint)
+				gd.addStringField("Stroke (point) color:", linec);
+			else {
+				gd.addStringField("Stroke color:", linec);
+				gd.addNumericField("Width:", strokeWidth, digits);
+			}
+		}
+		groupName = (Label)gd.getMessage();
+		if (showName && !IJ.isMacro()) {
+			Vector v = gd.getStringFields();
+			groupField = (TextField)v.elementAt(v.size()-2);
+			groupField.addTextListener(this);
+			colorField = (TextField)v.elementAt(v.size()-1);
+		}
+
+
+		if (!isLine) {
+			if (isPoint) {
+				int index = ((PointRoi)roi).getPointType();
+				gd.addChoice("Point type:", PointRoi.types, PointRoi.types[index]);
+				index = ((PointRoi)roi).getSize();
+				gd.addChoice("Size:", PointRoi.sizes, PointRoi.sizes[index]);
+			} else {
+				gd.addMessage("");
+				gd.addStringField("Fill color:", fillc);
+			}
+		}
+		if (addToOverlay)
+			gd.addCheckbox("New overlay", false);
+		if (overlayOptions) {
+			gd.addCheckbox("Set stack positions", setPositions);
+			if (overlay!=null) {
+				int size = overlay.size();
+				gd.setInsets(15,20,0);
+				if (imp!=null && imp.getHideOverlay())
+					gd.addMessage("Current overlay is hidden", null, Color.darkGray);
+				else
+					gd.addMessage("Current overlay has "+size+" element"+(size>1?"s":""), null, Color.darkGray);
+				gd.setInsets(0,30,0);
+				gd.addCheckbox("Apply", false);
+				gd.setInsets(0,30,0);
+				gd.addCheckbox("Show labels", overlay.getDrawLabels());
+				gd.setInsets(0,30,0);
+				gd.addCheckbox("Hide", imp!=null?imp.getHideOverlay():false);
+			} else
+				gd.addMessage("No overlay", null, Color.darkGray);
+		}
+		if (isText)
+			gd.addCheckbox("Antialiased text", antialias);
+		if (showListCoordinates) {
+			if ((roi instanceof PointRoi) && Toolbar.getMultiPointMode())
+				showPointCounts = true;
+			if (showPointCounts)
+				gd.addCheckbox("Show point counts (shortcut: alt+y)", listCoordinates);
+			else
+				gd.addCheckbox("List coordinates ("+roi.size()+")", listCoordinates);
+			if (nProperties>0)
+				gd.addCheckbox("List properties ("+nProperties+")", listProperties);
+			else {
+				gd.setInsets(5,20,0);
+				gd.addMessage("No properties");
+			}
+		}
+		if (isText && !isRange) {
+			String text = ((TextRoi)roi).getText();
+			int nLines = Tools.split(text, "\n").length + 1;
+			gd.addTextAreas(text, null, Math.min(nLines+1, 5), 30);
+		}
+		if (showName && "".equals(name) && "none".equals(position) && "none".equals(group) && "none".equals(fillc))
+			gd.setSmartRecording(true);
+		gd.addWindowListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		String position2 = "";
+		String group2 = "";
+		if (showName) {
+			name = gd.getNextString();
+			if (!isRange) roi.setName(name.length()>0?name:null);
+			position2 = gd.getNextString();
+			group2 = gd.getNextString();
+		}
+		linec = gd.getNextString();
+		if (!isPoint)
+			strokeWidth2 = gd.getNextNumber();
+		if (isText) {
+			angle = gd.getNextNumber();
+			justification = gd.getNextChoiceIndex();
+		}
+		if (!isLine) {
+			if (isPoint) {
+				int index = gd.getNextChoiceIndex();
+				((PointRoi)roi).setPointType(index);
+				index = gd.getNextChoiceIndex();
+				((PointRoi)roi).setSize(index);
+			} else
+				fillc = gd.getNextString();
+		}
+		boolean applyToOverlay = false;
+		boolean newOverlay = addToOverlay?gd.getNextBoolean():false;
+		if (overlayOptions) {
+			setPositions = gd.getNextBoolean();
+			if (overlay!=null) {
+				applyToOverlay = gd.getNextBoolean();
+				boolean labels = gd.getNextBoolean();
+				boolean hideOverlay = gd.getNextBoolean();
+				if (hideOverlay && imp!=null) {
+					if (!imp.getHideOverlay())
+						imp.setHideOverlay(true);
+				} else {
+					overlay.drawLabels(labels);
+					Analyzer.drawLabels(labels);
+					overlay.drawBackgrounds(true);
+					if (imp.getHideOverlay())
+						imp.setHideOverlay(false);
+					if (!applyToOverlay && imp!=null)
+						imp.draw();
+				}
+			}
+			roi.setPosition(setPositions?1:0);
+		}
+		if (isText)
+			antialias = gd.getNextBoolean();
+		if (showListCoordinates) {
+			listCoordinates = gd.getNextBoolean();
+			if (nProperties>0)
+				listProperties = gd.getNextBoolean();
+		}
+		strokeColor = Colors.decode(linec, null);
+		fillColor = Colors.decode(fillc, null);
+		if (isText) {
+			TextRoi troi = (TextRoi)roi;
+			Font font = troi.getCurrentFont();
+			if (strokeWidth2!=strokeWidth) {
+				font = new Font(font.getName(), font.getStyle(), (int)strokeWidth2);
+				troi.setCurrentFont(font);
+			}
+			troi.setAngle(angle);
+			if (justification!=troi.getJustification())
+				troi.setJustification(justification);
+			troi.setAntiAlias(antialias);
+			if (!isRange) troi.setText(gd.getNextText());
+		} else if (strokeWidth2!=strokeWidth)
+			roi.setStrokeWidth((float)strokeWidth2);
+		roi.setStrokeColor(strokeColor);
+		roi.setFillColor(fillColor);
+		if (showName) {
+			setPosition(roi, position, position2);
+			setGroup(roi, group, group2);
+		}
+		if (newOverlay) roi.setName("new-overlay");
+		if (applyToOverlay) {
+			if (imp==null || overlay==null)
+				return true;
+			Roi[] rois = overlay.toArray();
+			for (int i=0; i<rois.length; i++) {
+				rois[i].setStrokeColor(strokeColor);
+				if (strokeWidth2!=strokeWidth)
+					rois[i].setStrokeWidth((float)strokeWidth2);
+				rois[i].setFillColor(fillColor);
+			}
+			imp.draw();
+			imp.getProcessor(); // needed for correct recordering
+		}
+		if (listCoordinates) {
+			if (showPointCounts && (roi instanceof PointRoi))
+				((PointRoi)roi).displayCounts();
+			else
+				listCoordinates(roi);
+		}
+		if (listProperties && nProperties>0)
+			listProperties(roi);
+		return true;
+	}
+	
+	private void setPosition(Roi roi, String pos1, String pos2) {
+		if (pos1.equals(pos2))
+			return;
+		if (pos2.equals("none") || pos2.equals("0")) {
+			roi.setPosition(0);
+			return;
+		}
+		String[] positions = Tools.split(pos2, " ,");
+		if (positions.length==1) {
+			double stackPos = Tools.parseDouble(positions[0]);
+			if (!Double.isNaN(stackPos))
+				roi.setPosition((int)stackPos);
+			return;
+		}
+		if (positions.length==3) {
+			int[] pos = new int[3];
+			for (int i=0; i<3; i++) {
+				double dpos = Tools.parseDouble(positions[i]);
+				if (Double.isNaN(dpos))
+					return;
+				else
+					pos[i] = (int)dpos;
+			}
+			roi.setPosition(pos[0], pos[1], pos[2]);
+			return;
+		}
+	}
+	
+	private void setGroup(Roi roi, String group1, String group2) {
+		if (group1.equals(group2))
+			return;
+		if (group2.equals("none") || group2.equals("0")) {
+			roi.setGroup(0);
+			return;
+		}
+		double group = Tools.parseDouble(group2);
+		if (!Double.isNaN(group))
+			roi.setGroup((int)group);
+	}
+		
+	public boolean showImageDialog(String name) {
+		ImageRoi iRoi = (ImageRoi)roi;
+		boolean zeroTransparent =  iRoi.getZeroTransparent();
+		GenericDialog gd = new GenericDialog("Image ROI Properties");
+		gd.addStringField("Name:", name, 15);
+		gd.addNumericField("Opacity (0-100%):", iRoi.getOpacity()*100.0, 0);
+		gd.addCheckbox("Transparent background", zeroTransparent);
+		if (addToOverlay)
+			gd.addCheckbox("New Overlay", false);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		name = gd.getNextString();
+		roi.setName(name.length()>0?name:null);
+		double opacity = gd.getNextNumber()/100.0;
+		iRoi.setOpacity(opacity);
+		boolean zeroTransparent2 = gd.getNextBoolean();
+		if (zeroTransparent!=zeroTransparent2)
+			iRoi.setZeroTransparent(zeroTransparent2);
+		boolean newOverlay = addToOverlay?gd.getNextBoolean():false;
+		if (newOverlay) roi.setName("new-overlay");
+		return true;
+	}
+	
+	void listCoordinates(Roi roi) {
+		if (roi==null) return;
+		boolean allIntegers = true;
+		FloatPolygon fp = roi.getFloatPolygon();
+		ImagePlus imp = roi.getImage();
+		String title = "Coordinates";
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			int height = imp.getHeight();
+			for (int i=0; i<fp.npoints; i++) {
+				fp.xpoints[i] = (float)cal.getX(fp.xpoints[i]);
+				fp.ypoints[i] = (float)cal.getY(fp.ypoints[i], height);
+			}
+			if (cal.pixelWidth!=1.0 || cal.pixelHeight!=1.0)
+				allIntegers = false;
+			title = imp.getTitle();
+		}
+		if (allIntegers) {
+			for (int i=0; i<fp.npoints; i++) {
+				if ((int)fp.xpoints[i]!=fp.xpoints[i] || (int)fp.ypoints[i]!=fp.ypoints[i]) {
+					allIntegers = false;
+					break;
+				}
+			}
+		}
+		ResultsTable rt = new ResultsTable();
+		rt.setPrecision(allIntegers?0:Analyzer.getPrecision());
+		for (int i=0; i<fp.npoints; i++) {
+			rt.incrementCounter();
+			rt.addValue("X", fp.xpoints[i]);
+			rt.addValue("Y", fp.ypoints[i]);
+		}
+		rt.show("XY_"+title);
+	}
+	
+	void listProperties(Roi roi) {
+		String props = roi.getProperties();
+		if (props==null) return;
+		props = props.replaceAll(": ", "\t");
+		new TextWindow("Properties", "Key\tValue", props, 300, 300);
+	}
+	
+	public void textValueChanged(TextEvent e) {
+		if (groupName==null)
+			return;
+		TextField tf = (TextField) e.getSource();
+		String str = tf.getText();
+		double group = Tools.parseDouble(str, Double.NaN);
+		if (!Double.isNaN(group) && group>=0 && group<=255) {
+			roi.setGroup((int)group);
+			String name = Roi.getGroupName((int)group);
+			if (name==null)
+				name="unnamed";
+			if (group==0)
+				name = "";
+			groupName.setText(" "+name);
+			Color strokeColor = roi.getStrokeColor();
+			colorField.setText(Colors.colorToString(strokeColor));
+		} else
+			groupName.setText("");
+	}
+	
+	public void windowActivated(WindowEvent e) {
+		if (groupName!=null) {
+			String gname = Roi.getGroupName(roi.getGroup());
+			groupName.setText(gname!=null?" "+gname:"");  // add space to separate label from field
+		}
+	}
+	
+	public void windowClosing(WindowEvent e) {}
+	public void windowOpened(WindowEvent e) {}
+	public void windowClosed(WindowEvent e) {}
+	public void windowIconified(WindowEvent e) {}
+	public void windowDeiconified(WindowEvent e) {}
+	public void windowDeactivated(WindowEvent e) {}
+    
+}
diff --git a/src/ij/gui/RotatedRectRoi.java b/src/ij/gui/RotatedRectRoi.java
new file mode 100644
index 0000000..f2d7ff9
--- /dev/null
+++ b/src/ij/gui/RotatedRectRoi.java
@@ -0,0 +1,229 @@
+package ij.gui;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import ij.*;
+import ij.plugin.frame.Recorder;
+import ij.process.FloatPolygon;
+import ij.measure.Calibration;
+
+/** This class implements the rotated rectangle selection tool. */
+public class RotatedRectRoi extends PolygonRoi {
+	private double xstart, ystart;
+	private static double DefaultRectWidth = 50;
+	private double rectWidth = DefaultRectWidth;
+
+	public RotatedRectRoi(double x1, double y1, double x2, double y2, double rectWidth) {
+		super(new float[5], new float[5], 5, FREEROI);
+		this.rectWidth = rectWidth;
+		makeRectangle(x1, y1, x2, y2);
+		state = NORMAL;
+		bounds = null;
+	}
+
+	public RotatedRectRoi(int sx, int sy, ImagePlus imp) {
+		super(sx, sy, imp);
+		type = FREEROI;
+		xstart = offScreenXD(sx);
+		ystart = offScreenYD(sy);
+		ImageWindow win = imp.getWindow();
+		int pixels = win!=null?(int)(win.getSize().height/win.getCanvas().getMagnification()):imp.getHeight();
+		if (IJ.debugMode) IJ.log("RotatedRectRoi: "+(int)rectWidth+" "+pixels);
+		if (rectWidth>pixels)
+			rectWidth = pixels/3;
+		setDrawOffset(false);
+		bounds = null;
+	}
+
+	public void draw(Graphics g) {	
+		super.draw(g);
+		if (!overlay && ic!=null) {
+			double mag = ic.getMagnification();
+			for (int i=0; i<4; i++) {
+			if (i==3) //mark starting point
+				handleColor = strokeColor!=null?strokeColor:ROIColor;
+			else
+				handleColor=Color.white;
+			drawHandle(g, hxs(i), hys(i));
+			}
+		}
+	}
+	
+	private int hxs(int index) {
+		int indexPlus1 = index<3?index+1:0;
+		return xp2[index]+(xp2[indexPlus1]-xp2[index])/2;
+	}
+
+	private int hys(int index) {
+		int indexPlus1 = index<3?index+1:0;
+		return yp2[index]+(yp2[indexPlus1]-yp2[index])/2;
+	}
+
+	private double hx(int index) {
+		int indexPlus1 = index<3?index+1:0;
+		return xpf[index]+(xpf[indexPlus1]-xpf[index])/2+x;
+	}
+
+	private double hy(int index) {
+		int indexPlus1 = index<3?index+1:0;
+		return ypf[index]+(ypf[indexPlus1]-ypf[index])/2+y;
+	}
+
+	protected void grow(int sx, int sy) {
+		double x1 = xstart;
+		double y1 = ystart;
+		double x2 = offScreenXD(sx);
+		double y2 = offScreenYD(sy);
+		makeRectangle(x1, y1, x2, y2);
+		imp.draw();
+	}
+		
+	void makeRectangle(double x1, double y1, double x2, double y2) {
+		double length = Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
+		double angle = Math.atan ((x2-x1)/(y2-y1));
+		double wsa = (rectWidth/2.0)*Math.sin((Math.PI/2.0)+angle);
+		double wca = (rectWidth/2.0)*Math.cos((Math.PI/2)+angle);
+		nPoints = 5;
+		xpf[3] = (float)(x1-wsa);
+		ypf[3] = (float)(y1-wca);
+		xpf[0] = (float)(x1+wsa);
+		ypf[0] = (float)(y1+wca);
+		xpf[1] = (float)(x2+wsa);
+		ypf[1] = (float)(y2+wca);
+		xpf[2] = (float)(x2-wsa);
+		ypf[2] = (float)(y2-wca);
+		xpf[4] = xpf[0];
+		ypf[4] = ypf[0];
+		makePolygonRelative();
+		cachedMask = null;
+		DefaultRectWidth = rectWidth;
+		showStatus();
+	}
+	
+	public void showStatus() {
+		double[] p = getParams();
+		double dx = p[2] - p[0];
+		double dy = p[3] - p[1];
+		double length = Math.sqrt(dx*dx+dy*dy);
+		double width = p[4];
+		if (imp!=null && !IJ.altKeyDown()) {
+			Calibration cal = imp.getCalibration();
+			if (cal.scaled() && cal.pixelWidth==cal.pixelHeight) {
+				dx *= cal.pixelWidth;
+				dy *= cal.pixelHeight;
+				length = Math.sqrt(dx*dx+dy*dy);
+				width = p[4]*cal.pixelWidth;
+			}
+		}
+		double angle = getFloatAngle(p[0], p[1], p[2], p[3]);
+		IJ.showStatus("length=" + IJ.d2s(length)+", width=" + IJ.d2s(width)+", angle=" + IJ.d2s(angle));
+	}
+
+	public void nudgeCorner(int key) {
+		if (ic==null) return;
+		double[] p = getParams();
+		double x1 = p[0];
+		double y1 = p[1];
+		double x2 = p[2];
+		double y2 = p[3];
+		double inc = 1.0/ic.getMagnification();
+		switch(key) {
+			case KeyEvent.VK_UP: y2-=inc; break;
+			case KeyEvent.VK_DOWN: y2+=inc; break;
+			case KeyEvent.VK_LEFT: x2-=inc; break;
+			case KeyEvent.VK_RIGHT: x2+=inc; break;
+		}
+		makeRectangle(x1, y1, x2, y2);
+		imp.draw();
+		notifyListeners(RoiListener.MOVED);
+		showStatus();
+	}
+
+	void makePolygonRelative() {
+		FloatPolygon poly = new FloatPolygon(xpf, ypf, nPoints);
+		Rectangle r = poly.getBounds();
+		x = r.x;
+		y = r.y;
+		width = r.width;
+		height = r.height;
+		bounds = null;
+		for (int i=0; i<nPoints; i++) {
+			xpf[i] = xpf[i]-x;
+			ypf[i] = ypf[i]-y;
+		}
+	}
+	
+	protected void handleMouseUp(int screenX, int screenY) {
+		nPoints = 4;
+		state = NORMAL;
+		if (Recorder.record) {
+			double[] p = getParams();
+			if (Recorder.scriptMode())
+				Recorder.recordCall("imp.setRoi(new RotatedRectRoi("+(int)p[0]+","+(int)p[1]+","+(int)p[2]+","+(int)p[3]+","+(int)p[4]+"));");
+			else
+				Recorder.record("makeRotatedRectangle", (int)p[0], (int)p[1], (int)p[2], (int)p[3], (int)p[4]);
+		}
+	}
+	
+	protected void moveHandle(int sx, int sy) {
+		double ox = offScreenXD(sx); 
+		double oy = offScreenYD(sy);
+		double x1 = hx(3);
+		double y1 = hy(3);
+		double x2 = hx(1);
+		double y2 = hy(1);
+		switch(activeHandle) {
+			case 0: 
+				double dx = hx(2) - ox;
+				double dy = hy(2) - oy;
+				rectWidth = Math.sqrt(dx*dx+dy*dy);
+				break;
+			case 1: 
+				x2 = ox;
+				y2 = oy;
+				break;
+			case 2: 
+				dx = hx(0) - ox;
+				dy = hy(0) - oy;
+				rectWidth = Math.sqrt(dx*dx+dy*dy);
+				break;
+			case 3: 
+				x1 = ox;
+				y1 = oy;
+				break;
+		}
+		makeRectangle(x1, y1, x2, y2);
+		imp.draw();
+	}
+	
+	public int isHandle(int sx, int sy) {
+		int size = getHandleSize()+5;
+		int halfSize = size/2;
+		int index = -1;
+		for (int i=0; i<4; i++) {
+			int sx2 = (int)Math.round(hxs(i)-halfSize), sy2=(int)Math.round(hys(i)-halfSize);
+			if (sx>=sx2 && sx<=sx2+size && sy>=sy2 && sy<=sy2+size) {
+				index = i;
+				break;
+			}
+		}
+		return index;
+	}
+	
+	/** Returns x1, y1, x2, y2 and width as a 5 element array. */
+	public double[] getParams() {
+		double[] params = new double[5];
+		params[0] = hx(3);
+		params[1]  = hy(3);
+		params[2]  = hx(1);
+		params[3]  = hy(1);
+		params[4]  = rectWidth;
+		return params;
+	}
+	
+	/** Always returns true. */
+	public boolean subPixelResolution() {
+		return true;
+	}
+
+}
diff --git a/src/ij/gui/SaveChangesDialog.java b/src/ij/gui/SaveChangesDialog.java
new file mode 100644
index 0000000..203fd11
--- /dev/null
+++ b/src/ij/gui/SaveChangesDialog.java
@@ -0,0 +1,98 @@
+package ij.gui;
+import ij.IJ;
+import java.awt.*;
+import java.awt.event.*;
+
+/** A modal dialog box with a one line message and
+	"Don't Save", "Cancel" and "Save" buttons. */
+public class SaveChangesDialog extends Dialog implements ActionListener, KeyListener {
+	private Button dontSave, cancel, save;
+	private boolean cancelPressed, savePressed;
+
+	public SaveChangesDialog(Frame parent, String fileName) {
+		super(parent, "Save?", true);
+		setLayout(new BorderLayout());
+		Panel panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 10));
+		Component message;
+		if (fileName.startsWith("Save "))
+			message = new Label(fileName);
+		else {
+			if (fileName.length()>22)
+				message = new MultiLineLabel("Save changes to\n" + "\"" + fileName + "\"?");
+			else
+				message = new Label("Save changes to \"" + fileName + "\"?");
+		}
+		message.setFont(new Font("Dialog", Font.BOLD, 12));
+		panel.add(message);
+		add("Center", panel);
+		
+		panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.CENTER, 8, 8));
+		save = new Button("  Save  ");
+		save.addActionListener(this);
+		save.addKeyListener(this);
+		cancel = new Button("  Cancel  ");
+		cancel.addActionListener(this);
+		cancel.addKeyListener(this);
+		dontSave = new Button("Don't Save");
+		dontSave.addActionListener(this);
+		dontSave.addKeyListener(this);
+		if (ij.IJ.isMacintosh()) {
+			panel.add(dontSave);
+			panel.add(cancel);
+			panel.add(save);
+		} else {
+			panel.add(save);
+			panel.add(dontSave);
+			panel.add(cancel);
+		}
+		add("South", panel);
+		if (ij.IJ.isMacintosh())
+			setResizable(false);
+		pack();
+		GUI.centerOnImageJScreen(this);
+		show();
+	}
+    
+	public void actionPerformed(ActionEvent e) {
+		if (e.getSource()==cancel)
+			cancelPressed = true;
+		else if (e.getSource()==save)
+			savePressed = true;
+		closeDialog();
+	}
+	
+	/** Returns true if the user dismissed dialog by pressing "Cancel". */
+	public boolean cancelPressed() {
+		if (cancelPressed)
+			ij.Macro.abort();
+		return cancelPressed;
+	}
+	
+	/** Returns true if the user dismissed dialog by pressing "Save". */
+	public boolean savePressed() {
+		return savePressed;
+	}
+	
+	void closeDialog() {
+		//setVisible(false);
+		dispose();
+	}
+
+	public void keyPressed(KeyEvent e) { 
+		int keyCode = e.getKeyCode(); 
+		IJ.setKeyDown(keyCode); 
+		if (keyCode==KeyEvent.VK_ENTER) 
+			closeDialog(); 
+		else if (keyCode==KeyEvent.VK_ESCAPE) { 
+			cancelPressed = true; 
+			closeDialog(); 
+			IJ.resetEscape();
+		} 
+	} 
+
+	public void keyReleased(KeyEvent e) {}
+	public void keyTyped(KeyEvent e) {}
+
+}
diff --git a/src/ij/gui/ScrollbarWithLabel.java b/src/ij/gui/ScrollbarWithLabel.java
new file mode 100644
index 0000000..3d1d13a
--- /dev/null
+++ b/src/ij/gui/ScrollbarWithLabel.java
@@ -0,0 +1,233 @@
+package ij.gui;
+import ij.ImageJ;
+import ij.IJ;
+import ij.Prefs;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.geom.*;
+
+
+/** This class, based on Joachim Walter's Image5D package, adds "c", "z" labels 
+	 and play-pause icons (T) to the stack and hyperstacks dimension sliders.
+ * @author Joachim Walter
+ */
+public class ScrollbarWithLabel extends Panel implements Adjustable, AdjustmentListener {
+	Scrollbar bar;
+	private Icon icon;
+	private StackWindow stackWindow;
+	transient AdjustmentListener adjustmentListener;
+	
+	public ScrollbarWithLabel() {
+	}
+
+	public ScrollbarWithLabel(StackWindow stackWindow, int value, int visible, int minimum, int maximum, char label) {
+		super(new BorderLayout(2, 0));
+		this.stackWindow = stackWindow;
+		bar = new Scrollbar(Scrollbar.HORIZONTAL, value, visible, minimum, maximum);
+		GUI.fixScrollbar(bar);
+		icon = new Icon(label);
+		add(icon, BorderLayout.WEST);
+		add(bar, BorderLayout.CENTER);
+		bar.addAdjustmentListener(this);
+		addKeyListener(IJ.getInstance()); 
+	}
+		
+	/* (non-Javadoc)
+	 * @see java.awt.Component#getPreferredSize()
+	 */
+	public Dimension getPreferredSize() {
+		Dimension dim = new Dimension(0,0);
+		int width = bar.getPreferredSize().width;
+		Dimension minSize = getMinimumSize();
+		if (width<minSize.width) width = minSize.width;		
+		int height = bar.getPreferredSize().height;
+		int iconHeight = icon.getPreferredSize().height;
+		if (iconHeight>height)
+			height = iconHeight;
+		dim = new Dimension(width, (int)(height));
+		return dim;
+	}
+	
+	public Dimension getMinimumSize() {
+		return new Dimension(80, 15);
+	}
+	
+	/* Adds KeyListener also to all sub-components.
+	 */
+	public synchronized void addKeyListener(KeyListener l) {
+		super.addKeyListener(l);
+		bar.addKeyListener(l);
+	}
+
+	/* Removes KeyListener also from all sub-components.
+	 */
+	public synchronized void removeKeyListener(KeyListener l) {
+		super.removeKeyListener(l);
+		bar.removeKeyListener(l);
+	}
+
+	/* 
+	 * Methods of the Adjustable interface
+	 */
+	public synchronized void addAdjustmentListener(AdjustmentListener l) {
+		if (l == null) {
+			return;
+		}
+		adjustmentListener = AWTEventMulticaster.add(adjustmentListener, l);
+	}
+	public int getBlockIncrement() {
+		return bar.getBlockIncrement();
+	}
+	public int getMaximum() {
+		return bar.getMaximum();
+	}
+	public int getMinimum() {
+		return bar.getMinimum();
+	}
+	public int getOrientation() {
+		return bar.getOrientation();
+	}
+	public int getUnitIncrement() {
+		return bar.getUnitIncrement();
+	}
+	public int getValue() {
+		return bar.getValue();
+	}
+	public int getVisibleAmount() {
+		return bar.getVisibleAmount();
+	}
+	public synchronized void removeAdjustmentListener(AdjustmentListener l) {
+		if (l == null) {
+			return;
+		}
+		adjustmentListener = AWTEventMulticaster.remove(adjustmentListener, l);
+	}
+	public void setBlockIncrement(int b) {
+		bar.setBlockIncrement(b);		 
+	}
+	public void setMaximum(int max) {
+		bar.setMaximum(max);		
+	}
+	public void setMinimum(int min) {
+		bar.setMinimum(min);		
+	}
+	public void setUnitIncrement(int u) {
+		bar.setUnitIncrement(u);		
+	}
+	public void setValue(int v) {
+		bar.setValue(v);		
+	}
+	public void setVisibleAmount(int v) {
+		bar.setVisibleAmount(v);		
+	}
+
+	public void setFocusable(boolean focusable) {
+		super.setFocusable(focusable);
+		bar.setFocusable(focusable);
+	}
+		
+	/*
+	 * Method of the AdjustmenListener interface.
+	 */
+	public void adjustmentValueChanged(AdjustmentEvent e) {
+		if (bar != null && e.getSource() == bar) {
+			AdjustmentEvent myE = new AdjustmentEvent(this, e.getID(), e.getAdjustmentType(), 
+					e.getValue(), e.getValueIsAdjusting());
+			AdjustmentListener listener = adjustmentListener;
+			if (listener != null) {
+				listener.adjustmentValueChanged(myE);
+			}
+		}
+	}
+		
+	public void updatePlayPauseIcon() {
+		icon.repaint();
+	}
+	
+		
+	class Icon extends Canvas implements MouseListener {
+		private final double SCALE = Prefs.getGuiScale();
+		private final int WIDTH = (int)(12*SCALE);
+		private final int HEIGHT= (int)(14*SCALE);
+		private BasicStroke stroke = new BasicStroke((float)(2*SCALE));
+		private char type;
+		private Image image;
+		
+		public Icon(char type) {
+			addMouseListener(this);
+			addKeyListener(IJ.getInstance()); 
+			setSize(WIDTH, HEIGHT);
+			this.type = type;
+		}
+		
+		/** Overrides Component getPreferredSize(). */
+		public Dimension getPreferredSize() {
+			return new Dimension(WIDTH, HEIGHT);
+		}
+				
+		public void update(Graphics g) {
+			paint(g);
+		}
+		
+		public void paint(Graphics g) {
+			g.setColor(Color.white);
+			g.fillRect(0, 0, WIDTH, HEIGHT);
+			Graphics2D g2d = (Graphics2D)g;
+			g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+			if (type=='t')
+				drawPlayPauseButton(g2d);
+			else
+				drawLetter(g);
+		}
+		
+		private void drawLetter(Graphics g) {
+			Font font = new Font("SansSerif", Font.PLAIN, 14);
+			if (SCALE>1.0)
+				font = font.deriveFont((float)(font.getSize()*SCALE));
+			g.setFont(font);
+			g.setColor(Color.black);
+			g.drawString(String.valueOf(type), (int)(2*SCALE), (int)(12*SCALE));
+		}
+
+		private void drawPlayPauseButton(Graphics2D g) {
+			if (stackWindow.getAnimate()) {
+				g.setColor(Color.black);
+				g.setStroke(stroke);
+				int s3 = (int)(3*SCALE);
+				int s8 = (int)(8*SCALE);
+				int s11 = (int)(11*SCALE);
+				g.drawLine(s3, s3, s3, s11);
+				g.drawLine(s8, s3, s8, s11);
+			} else {
+				g.setColor(Color.darkGray);
+				GeneralPath path = new GeneralPath();
+				path.moveTo(3f, 2f);
+				path.lineTo(10f, 7f);
+				path.lineTo(3f, 12f);
+				path.lineTo(3f, 2f);
+				if (SCALE>1.0) {
+					AffineTransform at = new AffineTransform();
+					at.scale(SCALE, SCALE);
+					path = new GeneralPath(at.createTransformedShape(path));
+				}
+				g.fill(path);
+			}
+		}
+		
+		public void mousePressed(MouseEvent e) {
+			if (type!='t') return;
+			int flags = e.getModifiers();
+			if ((flags&(Event.ALT_MASK|Event.META_MASK|Event.CTRL_MASK))!=0)
+				IJ.doCommand("Animation Options...");
+			else
+				IJ.doCommand("Start Animation [\\]");
+		}
+		
+		public void mouseReleased(MouseEvent e) {}
+		public void mouseExited(MouseEvent e) {}
+		public void mouseClicked(MouseEvent e) {}
+		public void mouseEntered(MouseEvent e) {}
+	
+	} // Icon class
+	
+}
diff --git a/src/ij/gui/ShapeRoi.java b/src/ij/gui/ShapeRoi.java
new file mode 100644
index 0000000..1f943a5
--- /dev/null
+++ b/src/ij/gui/ShapeRoi.java
@@ -0,0 +1,1207 @@
+package ij.gui;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.geom.*;
+import java.awt.event.KeyEvent;
+import java.util.*;
+import ij.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.filter.Analyzer;
+import ij.util.Tools;
+import ij.util.FloatArray;
+
+/**A subclass of <code>ij.gui.Roi</code> (2D Regions Of Interest) implemented in terms of java.awt.Shape.
+ * A ShapeRoi is constructed from a <code>ij.gui.Roi</code> object, or as a result of logical operators
+ * (i.e., union, intersection, exclusive or, and subtraction) provided by this class. These operators use the package
+ * <code>java.awt.geom</code> as a backend. <br>
+ * This code is in the public domain.
+ * @author Cezar M.Tigaret <c.tigaret@ucl.ac.uk>
+ */
+public class ShapeRoi extends Roi {
+
+	/***/
+	static final int NO_TYPE = 128;
+	
+	/**The maximum tolerance allowed in calculating the length of the curve segments of this ROI's shape.*/
+	static final double MAXERROR = 1.0e-3;
+	
+	/** Coefficient used to obtain a flattened version of this ROI's shape. A flattened shape is the
+	*   closest approximation of the original shape's curve segments with line segments.
+	*   The FLATNESS is an indication of the maximum deviation between the flattened and the original shape. */
+	static final double FLATNESS = 0.1;
+
+	/** Flatness used for filling the shape when creating a mask. Lower values result in higher accuracy
+	 *  (determining which pixels near the border are filled), but lower speed when filling shapes with
+	 *  curved borders. */
+	static final double FILL_FLATNESS = 0.01;
+	
+	/**Parsing a shape composed of linear segments less than this value will result in Roi objects of type
+	 * {@link ij.gui.Roi#POLYLINE} and {@link ij.gui.Roi#POLYGON} for open and closed shapes, respectively.
+	 * Conversion of shapes open and closed with more than MAXPOLY line segments will result,
+	 * respectively, in {@link ij.gui.Roi#FREELINE} and {@link ij.gui.Roi#FREEROI} (or
+	 * {@link ij.gui.Roi#TRACED_ROI} if {@link #forceTrace} flag is <strong><code>true</code></strong>.
+	 */
+	private static final int MAXPOLY = 10; // I hate arbitrary values !!!!
+
+    private static final int OR=0, AND=1, XOR=2, NOT=3;
+
+	/**The <code>java.awt.Shape</code> encapsulated by this object.*/
+	private Shape shape;
+	
+	/**The instance value of the maximum tolerance (MAXERROR) allowed in calculating the 
+	 * length of the curve segments of this ROI's shape.
+	 */
+	private double maxerror = ShapeRoi.MAXERROR;
+	
+	/**The instance value of the coefficient (FLATNESS) used to 
+	 * obtain a flattened version of this ROI's shape.
+	 */
+	private double flatness = ShapeRoi.FLATNESS;
+	
+	/**The instance value of MAXPOLY.*/
+	private int maxPoly = ShapeRoi.MAXPOLY;
+    
+	/**If <strong></code>true</code></strong> then methods that manipulate this ROI's shape will work on
+	 * a flattened version of the shape. */
+	private boolean flatten;
+	
+	/**Flag which specifies how Roi objects will be constructed from closed (sub)paths having more than
+	 * <code>MAXPOLY</code> and composed exclusively of line segments.
+	 * If <strong><code>true</code></strong> then (sub)path will be parsed into a
+	 * {@link ij.gui.Roi#TRACED_ROI}; else, into a {@link ij.gui.Roi#FREEROI}. */
+	private boolean forceTrace = false;
+
+	/**Flag which specifies if Roi objects constructed from open (sub)paths composed of only two line segments
+	 * will be of type {@link ij.gui.Roi#ANGLE}.
+	 * If <strong><code>true</code></strong> then (sub)path will be parsed into a {@link ij.gui.Roi#ANGLE};
+	 * else, into a {@link ij.gui.Roi#POLYLINE}. */
+	private boolean forceAngle = false;
+	
+	private Vector savedRois; //not really used any more
+	private static Stroke defaultStroke = new BasicStroke();
+
+
+	/** Constructs a ShapeRoi from an Roi. */
+	public ShapeRoi(Roi r) {
+		this(r, ShapeRoi.FLATNESS, ShapeRoi.MAXERROR, false, false, false, ShapeRoi.MAXPOLY);
+	}
+
+	/** Constructs a ShapeRoi from a Shape. */
+	public ShapeRoi(Shape s) {
+		super(s.getBounds());
+		AffineTransform at = new AffineTransform();
+		at.translate(-x, -y);
+		shape = new GeneralPath(at.createTransformedShape(s));
+		type = COMPOSITE;
+	}
+
+	/** Constructs a ShapeRoi from a Shape. */
+	public ShapeRoi(int x, int y, Shape s) {
+		super(x, y, s.getBounds().width, s.getBounds().height);
+		shape = new GeneralPath(s);
+		type = COMPOSITE;
+	}
+
+	/**Creates a ShapeRoi object from a "classical" ImageJ ROI.
+	 * @param r An ij.gui.Roi object
+	 * @param flatness The flatness factor used in convertion of curve segments into line segments.
+	 * @param maxerror Error correction for calculating length of Bezeir curves.
+	 * @param forceAngle flag used in the conversion of Shape objects to Roi objects (see {@link #shapeToRois()}.
+	 * @param forceTrace flag for conversion of Shape objects to Roi objects (see {@link #shapeToRois()}.
+	 * @param flatten if <strong><code>true</code></strong> then the shape of this ROI will be flattened
+	 * (i.e., curve segments will be aproximated by line segments).
+	 * @param maxPoly Roi objects constructed from shapes composed of linear segments fewer than this
+	 * value will be of type {@link ij.gui.Roi#POLYLINE} or {@link ij.gui.Roi#POLYGON}; conversion of
+	 * shapes with linear segments more than this value will result in Roi objects of type
+	 * {@link ij.gui.Roi#FREELINE} or {@link ij.gui.Roi#FREEROI} unless the average side length
+	 * is large (see {@link #shapeToRois()}).
+	 */
+	ShapeRoi(Roi r, double flatness, double maxerror, boolean forceAngle, boolean forceTrace, boolean flatten, int maxPoly) {
+		super(r.startX, r.startY, r.width, r.height);
+		this.type = COMPOSITE;
+		this.flatness = flatness;
+		this.maxerror = maxerror;
+		this.forceAngle = forceAngle;
+		this.forceTrace = forceTrace;
+		this.maxPoly= maxPoly;
+		this.flatten = flatten;
+		shape = roiToShape((Roi)r.clone());
+	}
+
+	/** Constructs a ShapeRoi from an array of variable length path segments. Each
+		segment consists of the segment type followed by 0-6 coordintes (0-3 end points and control
+		points). Depending on the type, a segment uses from 1 to 7 elements of the array. */
+	public ShapeRoi(float[] shapeArray) {
+		super(0,0,null);
+		shape = makeShapeFromArray(shapeArray);
+		Rectangle r = shape.getBounds();
+		x = r.x;
+		y = r.y;
+		width = r.width;
+		height = r.height;		
+		state = NORMAL;
+		oldX=x; oldY=y; oldWidth=width; oldHeight=height;				
+		AffineTransform at = new AffineTransform();
+		at.translate(-x, -y);
+		shape = new GeneralPath(at.createTransformedShape(shape));
+		flatness = ShapeRoi.FLATNESS;
+		maxerror = ShapeRoi.MAXERROR;
+		maxPoly = ShapeRoi.MAXPOLY;
+		flatten = false;
+		type = COMPOSITE;
+	}
+	
+	/**Returns a deep copy of this. */
+	public synchronized Object clone() { // the equivalent of "operator=" ?
+		ShapeRoi sr = (ShapeRoi)super.clone();
+		sr.type = COMPOSITE;
+		sr.flatness = flatness;
+		sr.maxerror = maxerror;
+		sr.forceAngle = forceAngle;
+		sr.forceTrace = forceTrace;
+		//sr.setImage(imp); //wsr
+		sr.setShape(ShapeRoi.cloneShape(shape));
+		return sr;
+	}
+	
+	/** Returns a deep copy of the argument. */
+	static Shape cloneShape(Shape rhs) {
+		if (rhs==null) return null;
+		else if (rhs instanceof Rectangle2D.Double)
+			return (Rectangle2D.Double)((Rectangle2D.Double)rhs).clone();
+		else if (rhs instanceof Ellipse2D.Double)
+			return (Ellipse2D.Double)((Ellipse2D.Double)rhs).clone();
+		else if (rhs instanceof Line2D.Double)
+			return (Line2D.Double)((Line2D.Double)rhs).clone();
+		else if (rhs instanceof Polygon)
+			return new Polygon(((Polygon)rhs).xpoints, ((Polygon)rhs).ypoints, ((Polygon)rhs).npoints);
+		else if (rhs instanceof GeneralPath)
+			return (GeneralPath)((GeneralPath)rhs).clone();
+		else
+			return makeShapeFromArray(getShapeAsArray(rhs, 0, 0));
+	}
+
+	/**********************************************************************************/
+	/***                  Logical operations on shaped rois                        ****/
+	/**********************************************************************************/
+
+	/**Unary union operator.
+	 * The caller is set to its union with the argument.
+	 * @return the union of <strong><code>this</code></strong> and <code>sr</code>
+	 */
+	public ShapeRoi or(ShapeRoi sr) {return unaryOp(sr, OR);}
+
+	/**Unary intersection operator.
+	 * The caller is set to its intersection with the argument (i.e., the overlapping regions between the
+	 * operands).
+	 * @return the overlapping regions between <strong><code>this</code></strong> and <code>sr</code>
+	 */
+	public ShapeRoi and(ShapeRoi sr) {return unaryOp(sr, AND);}
+
+	/**Unary exclusive or operator.
+	 * The caller is set to the non-overlapping regions between the operands.
+	 * @return the union of the non-overlapping regions of <code>this</code> and <code>sr</code>
+	 * @see ij.gui.Roi#xor(Roi[])
+	 * @see ij.gui.Overlay#xor(int[])
+	 */
+	public ShapeRoi xor(ShapeRoi sr) {return unaryOp(sr, XOR);}
+
+	/**Unary subtraction operator.
+	 * The caller is set to the result of the operation between the operands.
+	 * @return <strong><code>this</code></strong> subtracted from <code>sr</code>
+	 */
+	public ShapeRoi not(ShapeRoi sr) {return unaryOp(sr, NOT);}
+
+	ShapeRoi unaryOp(ShapeRoi sr, int op) {
+		AffineTransform at = new AffineTransform();
+		at.translate(x, y);
+		Area a1 = new Area(at.createTransformedShape(getShape()));
+		at = new AffineTransform();
+		at.translate(sr.x, sr.y);
+		Area a2 = new Area(at.createTransformedShape(sr.getShape()));
+		try {
+			switch (op) {
+				case OR: a1.add(a2); break;
+				case AND: a1.intersect(a2); break;
+				case XOR: a1.exclusiveOr(a2); break;
+				case NOT: a1.subtract(a2); break;
+			}
+		} catch(Exception e) {}
+		Rectangle r = a1.getBounds();
+		at = new AffineTransform();
+		at.translate(-r.x, -r.y);
+		setShape(new GeneralPath(at.createTransformedShape(a1)));
+		x = r.x;
+		y = r.y;
+		cachedMask = null;
+		return this;
+	}
+
+	/**********************************************************************************/
+	/***         Interconversions between "regular" rois and shaped rois           ****/
+	/**********************************************************************************/
+
+	/**Converts the Roi argument to an instance of java.awt.Shape.
+	 * Currently, the following conversions are supported:<br>
+		<table><col><col><col><col><col><col><col>
+			<thead>
+				<tr><th scope=col> Roi class </th><th scope=col> Roi type </th><th scope=col> Shape </th><</tr>
+			</thead>
+			<tbody>
+				<tr><td> ij.gui.Roi </td>       <td> Roi.RECTANGLE </td><td> java.awt.geom.Rectangle2D.Double </td></tr>
+				<tr><td> ij.gui.OvalRoi </td>   <td> Roi.OVAL </td>     <td> java.awt.Polygon of the corresponding traced roi </td></tr>
+				<tr><td> ij.gui.Line </td>      <td> Roi.LINE </td>     <td> java.awt.geom.Line2D.Double </td></tr>
+				<tr><td> ij.gui.PolygonRoi </td><td> Roi.POLYGON </td>  <td> java.awt.Polygon or (if subpixel resolution) closed java.awt.geom.GeneralPath </td></tr>
+				<tr><td> ij.gui.PolygonRoi </td><td> Roi.FREEROI </td>  <td> java.awt.Polygon or (if subpixel resolution) closed java.awt.geom.GeneralPath </td></tr>
+				<tr><td> ij.gui.PolygonRoi </td><td> Roi.TRACED_ROI</td><td> java.awt.Polygon or (if subpixel resolution) closed java.awt.geom.GeneralPath </td></tr>
+				<tr><td> ij.gui.PolygonRoi </td><td> Roi.POLYLINE </td> <td> open java.awt.geom.GeneralPath  </td></tr>
+				<tr><td> ij.gui.PolygonRoi </td><td> Roi.FREELINE </td> <td> open java.awt.geom.GeneralPath  </td></tr>
+				<tr><td> ij.gui.PolygonRoi </td><td> Roi.ANGLE </td>    <td> open java.awt.geom.GeneralPath  </td></tr>
+				<tr><td> ij.gui.ShapeRoi </td>  <td> Roi.COMPOSITE </td><td> shape of argument  </td></tr>
+				<tr><td> ij.gui.ShapeRoi </td>  <td> ShapeRoi.NO_TYPE</td><td> null </td></tr>
+			</tbody>
+		</table>
+	 *
+	 * @return A java.awt.geom.* object that inherits from java.awt.Shape interface.
+	 *
+	 */
+	private Shape roiToShape(Roi roi) {
+		if (roi.isLine())
+			roi = Roi.convertLineToArea(roi);
+		Shape shape = null;
+		Rectangle r = roi.getBounds();
+		boolean closeShape = true;
+		int roiType = roi.getType();
+		switch(roiType) {
+			case Roi.LINE:
+				Line line = (Line)roi;				
+				shape = new Line2D.Double ((double)(line.x1-r.x), (double)(line.y1-r.y), (double)(line.x2-r.x), (double)(line.y2-r.y) );
+				break;
+			case Roi.RECTANGLE:
+				int arcSize = roi.getCornerDiameter();
+				if (arcSize>0)
+					shape = new RoundRectangle2D.Double(0, 0, r.width, r.height, arcSize, arcSize);
+				else
+					shape = new Rectangle2D.Double(0.0, 0.0, (double)r.width, (double)r.height);
+				break;
+			case Roi.POLYLINE: case Roi.FREELINE: case Roi.ANGLE:
+				closeShape = false;
+			case Roi.POLYGON: case Roi.FREEROI: case Roi.TRACED_ROI: case Roi.OVAL:
+				if (roiType == Roi.OVAL) {
+					//shape = new Ellipse2D.Double(-0.001, -0.001, r.width+0.002, r.height+0.002); //inaccurate (though better with increased diameter) 
+					shape = ((OvalRoi)roi).getPolygon(false);
+				} else if (closeShape && !roi.subPixelResolution()) {
+					int nPoints =((PolygonRoi)roi).getNCoordinates();
+					int[] xCoords = ((PolygonRoi)roi).getXCoordinates();
+					int[] yCoords = ((PolygonRoi)roi).getYCoordinates();
+					shape = new Polygon(xCoords, yCoords, nPoints);
+				} else {
+					FloatPolygon floatPoly = roi.getFloatPolygon();
+					if (floatPoly.npoints <=1) break;
+					shape = new GeneralPath(closeShape ? GeneralPath.WIND_EVEN_ODD : GeneralPath.WIND_NON_ZERO, floatPoly.npoints);
+					((GeneralPath)shape).moveTo(floatPoly.xpoints[0] - r.x, floatPoly.ypoints[0] - r.y);
+					for (int i=1; i<floatPoly.npoints; i++)
+						((GeneralPath)shape).lineTo(floatPoly.xpoints[i] - r.x, floatPoly.ypoints[i] - r.y);
+					if (closeShape)
+						((GeneralPath)shape).closePath();
+				}
+				break;
+			case Roi.POINT:
+				ImageProcessor mask = roi.getMask();
+				byte[] maskPixels = (byte[])mask.getPixels();
+				int maskWidth = mask.getWidth();
+				Area area = new Area();
+				for (int y=0; y<mask.getHeight(); y++) {
+					int yOffset = y*maskWidth;
+					for (int x=0; x<maskWidth; x++) {
+						if (maskPixels[x+yOffset]!=0)
+							area.add(new Area(new Rectangle(x, y, 1, 1)));
+					}
+				}
+				shape = area;
+				break;
+			case Roi.COMPOSITE: shape = ShapeRoi.cloneShape(((ShapeRoi)roi).getShape());
+				break;
+			default:
+				throw new IllegalArgumentException("Roi type not supported");
+		}
+
+		if (shape!=null) {
+			setLocation(r.x, r.y);
+            Rectangle2D shapeBounds = shape.getBounds2D();
+            Rectangle2D.Double sBounds = null;
+            if (shapeBounds instanceof Rectangle2D.Double)
+				sBounds = (Rectangle2D.Double)shapeBounds;
+			else {
+				sBounds = new Rectangle2D.Double();
+				sBounds.setRect(shapeBounds);  //convert to Rectangle2D.Double
+			}
+			this.width  = (int)(Math.max(sBounds.x, 0) + sBounds.width + 0.5);
+			this.height = (int)(Math.max(sBounds.y, 0) + sBounds.height+ 0.5);
+			if (bounds != null) {
+				bounds.width = width;
+				bounds.height = height;
+			}
+			this.startX = x;
+			this.startY = y;
+			//IJ.log("RoiToShape: "+x+" "+y+" "+width+" "+height+" "+bounds);
+		}
+		return shape;
+	}
+
+	/** Constructs a GeneralPath from a float array of segment type+coordinates for each segment. 
+	 *  The resulting GeneralPath has winding rule WIND_EVEN_ODD, which is appropriate for closed shapes */
+	static GeneralPath makeShapeFromArray(float[] array) {
+		if(array==null) return null;
+		GeneralPath s = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
+		int index=0;
+		float[] seg = new float[7];
+		while (true) {
+			//if(index<array.length)IJ.log(index+" type="+array[index]);
+			index = getSegment(array, seg, index);
+			if (index<0) break;
+			int type = (int)seg[0];
+			switch(type) {
+				case PathIterator.SEG_MOVETO:
+					((GeneralPath)s).moveTo(seg[1], seg[2]);
+					break;
+				case PathIterator.SEG_LINETO:
+					((GeneralPath)s).lineTo(seg[1], seg[2]);
+					break;
+				case PathIterator.SEG_QUADTO:
+					((GeneralPath)s).quadTo(seg[1], seg[2],seg[3], seg[4]);
+					break;
+				case PathIterator.SEG_CUBICTO:
+					((GeneralPath)s).curveTo(seg[1], seg[2], seg[3], seg[4], seg[5], seg[6]);
+					break;
+				case PathIterator.SEG_CLOSE:
+					((GeneralPath)s).closePath();
+					break;
+				default: break;
+			}
+		}
+		return s;
+	}
+
+	/** Reads the data of a segment from an array describing the shape at as in a PathIterator. Reading starts at 'index'.
+	 *  The position in the array for the next segment is returned, -1 if the array ends.
+	 *  The segment type and coordinates of the segment are stored into 'seg' (which must have a length of at least 7) */
+	private static int getSegment(float[] array, float[] seg, int index) {
+		int len = array.length;
+		if (index>=len) return -1;
+		seg[0] = array[index++];
+		int type = (int)seg[0];
+		int nCoords = nCoords(type);
+		if (index+nCoords > len) return -1;
+		for (int i=1; i<=nCoords; i++)
+			seg[i] = array[index++];
+		return index;
+	}
+
+	/** Returns the number of coordinates for the given PathIterator segment type */
+	private static int nCoords(int segmentType) {
+		switch (segmentType) {
+				case PathIterator.SEG_MOVETO:
+				case PathIterator.SEG_LINETO:
+					return 2;
+				case PathIterator.SEG_QUADTO:
+					return 4;
+				case PathIterator.SEG_CUBICTO:
+					return 6;
+				case PathIterator.SEG_CLOSE:
+					return 0;
+				default:
+					throw new RuntimeException("Invalid Segment Type: "+segmentType);
+		}
+	}
+
+	/** Saves an Roi so it can be retrieved later using getRois(). Not compatible with the other functions of this class.
+	 * @deprecated  Use ShapeRoi(Roi) creator and merge with <code>or(ShapeRoi)</code>. */
+	void saveRoi(Roi roi) {
+		if (savedRois==null)
+			savedRois = new Vector();
+		savedRois.addElement(roi);
+	}
+
+	/**Converts a Shape into Roi object(s).
+	 * <br>This method parses the shape into (possibly more than one) Roi objects 
+	 * and returns them in an array.
+	 * <br>A simple, &quot;regular&quot; path results in a single Roi following these simple rules:
+		<table><col><col><col>
+			<thead><tr><th scope=col> Shape type </th><th scope=col> Roi class </th><th scope=col> Roi type </th></tr></thead>
+			<tbody>
+				<tr><td> java.awt.geom.Rectangle2D.Double </td><td> ij.gui.Roi </td><td> Roi.RECTANGLE </td></tr>
+				<tr><td> java.awt.geom.Ellipse2D.Double </td><td> ij.gui.OvalRoi</td><td> Roi.OVAL </td></tr>
+				<tr><td> java.awt.geom.Line2D.Double </td><td> ij.gui.Line </td><td> Roi.LINE </td></tr>
+				<tr><td> java.awt.Polygon </td>	<td> ij.gui.PolygonRoi </td><td> Roi.POLYGON </td></tr>
+			</tbody>
+		</table>
+	 * <br><br>Each subpath of a <code>java.awt.geom.GeneralPath</code> is converted following these rules:
+		<table frame="border"><col><col><col><col><col><col>
+			<thead>
+				<tr><th rowspan="2" scope=col> Segment<br> types </th><th rowspan="2" scope=col> Number of<br> segments </th>
+					<th rowspan="2" scope=col> Closed<br> path </th><th rowspan="2" scope=col> Value of<br> forceAngle </th>
+					<th rowspan="2" scope=col> Value of<br> forceTrace </th><th rowspan="2" scope=col> Roi type </th></tr>
+			</thead>
+			<tbody>
+				<tr><td> lines only: </td><td align="center"> 0 </td><td>  </td><td>  </td><td>  </td><td> ShapeRoi.NO_TYPE </td></tr>
+				<tr><td>  </td><td align="center"> 1 </td><td>  </td><td>  </td><td>  </td>	<td> ShapeRoi.NO_TYPE </td></tr>
+				<tr><td>  </td><td align="center"> 2 </td><td align="center"> Y </td><td>  </td><td>  </td><td> ShapeRoi.NO_TYPE </td></tr>
+				<tr><td>  </td><td>  </td><td align="center"> N </td><td>  </td><td>  </td><td> Roi.LINE </td></tr>
+				<tr><td>  </td><td align="center"> 3 </td><td align="center"> Y </td><td align="center"> N </td><td>  </td><td> Roi.POLYGON </td></tr>
+				<tr><td>  </td><td>  </td><td align="center"> N </td><td align="center"> Y </td><td>  </td><td> Roi.ANGLE </td></tr>
+				<tr><td>  </td><td>  </td><td align="center"> N </td><td align="center"> N </td><td>  </td><td> Roi.POLYLINE </td></tr>
+				<tr><td>  </td><td align="center"> 4 </td><td align="center"> Y </td><td>  </td<td>  </td><td> Roi.RECTANGLE </td></tr>
+				<tr><td>  </td><td>  </td><td align="center"> N </td><td>  </td><td>  </td><td> Roi.POLYLINE </td></tr>
+				<tr><td>  </td><td align="center"> &lt;= MAXPOLY </td>	<td align="center"> Y </td><td>  </td><td>  </td><td> Roi.POLYGON </td></tr>
+				<tr><td>  </td><td>  </td><td align="center"> N </td><td>  </td><td>  </td><td> Roi.POLYLINE </td></tr>
+				<tr><td>  </td><td align="center"> &gt; MAXPOLY </td><td align="center"> Y </td><td>  </td>	<td align="center"> Y </td><td> Roi.TRACED_ROI </td></tr>
+				<tr><td>  </td><td>  </td><td>  </td><td>  </td><td align="center"> N </td><td> Roi.FREEROI </td></tr>
+				<tr><td>  </td><td>  </td><td align="center"> N </td><td>  </td><td>  </td><td> Roi.FREELINE </td></tr>
+				<tr><td> anything<br>else: </td><td align="center"> &lt;= 2 </td><td>  </td><td>  </td><td>  </td><td> ShapeRoi.NO_TYPE </td></tr>
+				<tr><td>  </td><td align="center"> &gt; 2 </td><td>  </td><td>  </td><td>  </td><td> ShapeRoi.SHAPE_ROI </td></tr>
+			</tbody>
+		</table>
+	 * @return an array of ij.gui.Roi objects.
+	 */
+	public Roi[] getRois () {
+		if (shape==null)
+			return new Roi[0];
+		if (savedRois!=null)
+			return (Roi[])savedRois.toArray(new Roi[savedRois.size()]);
+		ArrayList rois = new ArrayList();
+		if (shape instanceof Rectangle2D.Double) {
+			Roi r = new Roi((int)((Rectangle2D.Double)shape).getX(), (int)((Rectangle2D.Double)shape).getY(), (int)((Rectangle2D.Double)shape).getWidth(), (int)((Rectangle2D.Double)shape).getHeight());
+			rois.add(r);
+		} else if (shape instanceof Ellipse2D.Double) {
+			Roi r = new OvalRoi((int)((Ellipse2D.Double)shape).getX(), (int)((Ellipse2D.Double)shape).getY(), (int)((Ellipse2D.Double)shape).getWidth(), (int)((Ellipse2D.Double)shape).getHeight());
+			rois.add(r);
+		} else if (shape instanceof Line2D.Double) {
+			Roi r = new ij.gui.Line((int)((Line2D.Double)shape).getX1(), (int)((Line2D.Double)shape).getY1(), (int)((Line2D.Double)shape).getX2(), (int)((Line2D.Double)shape).getY2());
+			rois.add(r);
+		} else if (shape instanceof Polygon) {
+			Roi r = new PolygonRoi(((Polygon)shape).xpoints, ((Polygon)shape).ypoints, ((Polygon)shape).npoints, Roi.POLYGON);
+			rois.add(r);
+		} else {
+			PathIterator pIter;
+			if (flatten)
+				pIter = getFlatteningPathIterator(shape,flatness);
+			else
+				pIter = shape.getPathIterator(new AffineTransform());
+			parsePath(pIter, ALL_ROIS, rois);
+		}
+		return (Roi[])rois.toArray(new Roi[rois.size()]);
+	}
+
+
+	/**Attempts to convert this ShapeRoi into a single non-composite Roi.
+	 * @return an ij.gui.Roi object or null if it cannot be simplified to become a non-composite roi.
+	 */
+	public Roi shapeToRoi() {
+		if (shape==null || !(shape instanceof GeneralPath))
+			return null;
+		PathIterator pIter = shape.getPathIterator(new AffineTransform());
+		ArrayList rois = new ArrayList();
+		parsePath(pIter, ONE_ROI, rois);
+		if (rois.size() == 1)
+			return (Roi)rois.get(0);
+		else
+			return null;
+	}
+
+	/**Attempts to convert this ShapeRoi into a single non-composite Roi.
+	 * For showing as a Roi, one should apply copyAttributes
+	 * @return an ij.gui.Roi object, which is either the non-composite roi,
+	 * or this ShapeRoi (if such a conversion is not possible) or null if
+	 * this is an empty roi.
+	 */
+	public Roi trySimplify() {
+		Roi roi = shapeToRoi();
+		return (roi==null) ? this : roi;
+	}
+	
+	/**Implements the rules of conversion from <code>java.awt.geom.GeneralPath</code> to <code>ij.gui.Roi</code>.
+	 * @param nSegments The number of segments that compose the path (= number of vertices for a polygon)
+	 * @param polygonLength length of polygon in pixels, or NaN if curved segments
+	 * @param horizontalVerticalIntOnly Indicates whether the GeneralPath is composed of only vertical and horizontal lines with integer coordinates
+	 * @param forceTrace Indicates that closed shapes with <code>horizontalVerticalIntOnly=true</code> should become TRACED_ROIs
+	 * @param closed Indicates a closed GeneralPath
+	 * @see #shapeToRois()
+	 * @return a type flag like Roi.RECTANGLE or NO_TYPE if the type cannot be determined
+	 */
+	private int guessType(int nSegments, double polygonLength, boolean horizontalVerticalIntOnly, boolean forceTrace, boolean closed) {
+		int roiType = Roi.RECTANGLE;
+		if (Double.isNaN(polygonLength)) {
+			roiType = Roi.COMPOSITE;
+		} else {
+			// For more segments, they should be longer to qualify for a polygon with handles:
+			// The threshold for the average segment length is 4.0 for 4 segments, 16.0 for 64 segments, 32.0 for 256 segments
+			boolean longEdges = polygonLength/(nSegments*Math.sqrt(nSegments)) >= 2;
+			if (nSegments < 2)
+				roiType = NO_TYPE;
+			else if (nSegments == 2)
+				roiType = closed ? NO_TYPE : Roi.LINE;
+			else if (nSegments == 3 && !closed && forceAngle)
+				roiType = Roi.ANGLE;
+			else if (nSegments == 4 && closed && horizontalVerticalIntOnly && longEdges && !forceTrace && !this.forceTrace)
+				roiType = Roi.RECTANGLE;
+			else if (closed && horizontalVerticalIntOnly && (!longEdges || forceTrace || this.forceTrace))
+				roiType = Roi.TRACED_ROI;
+			else if (nSegments <= MAXPOLY || longEdges)
+				roiType = closed ? Roi.POLYGON : Roi.POLYLINE;
+			else
+				roiType = closed ? Roi.FREEROI : Roi.FREELINE;
+		}
+		//IJ.log("guessType n= "+nSegments+" len="+polygonLength+" longE="+(polygonLength/(nSegments*Math.sqrt(nSegments)) >= 2)+" hvert="+horizontalVerticalIntOnly+" clos="+closed+" -> "+roiType);
+		return roiType;
+	}
+
+	/**Creates a 'classical' (non-Shape) Roi object based on the arguments.
+	 * @see #shapeToRois()
+	 * @param xPoints the x coordinates
+	 * @param yPoints the y coordinates
+	 * @param type the type flag
+	 * @return a ij.gui.Roi object or null
+	 */
+	private Roi createRoi(float[] xPoints, float[] yPoints, int roiType) {
+		if (roiType == NO_TYPE || roiType == Roi.COMPOSITE) return null;
+		Roi roi = null;
+		if (xPoints == null || yPoints == null || xPoints.length != yPoints.length || xPoints.length==0) return null;
+
+		Tools.addToArray(xPoints, (float)getXBase());
+		Tools.addToArray(yPoints, (float)getYBase());
+
+		switch(roiType) {
+			case Roi.LINE: roi = new ij.gui.Line(xPoints[0],yPoints[0],xPoints[1],yPoints[1]); break;
+			case Roi.RECTANGLE:
+				double[] xMinMax = Tools.getMinMax(xPoints);
+				double[] yMinMax = Tools.getMinMax(yPoints);
+				roi = new Roi((int)xMinMax[0], (int)yMinMax[0],
+						(int)xMinMax[1] - (int)xMinMax[0], (int)yMinMax[1] - (int)yMinMax[0]);
+				break;
+			case TRACED_ROI:
+				roi = new PolygonRoi(toIntR(xPoints), toIntR(yPoints), xPoints.length, roiType);
+				break;
+			default:
+				roi = new PolygonRoi(xPoints, yPoints, xPoints.length, roiType);
+				break;
+		}
+		return roi;
+	}
+
+	/**********************************************************************************/
+	/***                                   Geometry                                ****/
+	/**********************************************************************************/
+
+	/** Checks whether the center of the specified pixel inside of this ROI's shape boundaries.
+	 *  Note the ImageJ convention of 0.5 pixel shift between outline and pixel center,
+	 *  i.e., pixel (0,0) is enclosed by the rectangle spanned between (0,0) and (1,1).
+	 *  The value slightly below 0.5 is for rounding according to the ImageJ convention
+	 *  (which is opposite to that of the java.awt.Shape class):
+	 *  In ImageJ, points exactly at the left (right) border are considered outside (inside);
+	 *  points exactly on horizontal borders, are considered outside (inside) at the border
+	 *  with the lower (higher) y.
+	 */
+	public boolean contains(int x, int y) {
+		if (shape==null) return false;
+		return shape.contains(x-this.x+0.494, y-this.y+0.49994);
+	}
+
+	/** Returns whether coordinate (x,y) is contained in the Roi.
+	 *  Note that the coordinate (0,0) is the top-left corner of pixel (0,0).
+	 *  Use contains(int, int) to determine whether a given pixel is contained in the Roi. */
+	public boolean containsPoint(double x, double y) {
+		if (!super.containsPoint(x, y))
+			return false;
+		return shape.contains(x-this.x+1e-3, y-this.y+1e-6); //adding a bit to reduce the likelyhood of numerical errors at integers
+	}
+
+	/** Returns the perimeter of this ShapeRoi. */
+	public double getLength() {
+		if (width==0 && height==0)
+			return 0.0;
+		return parsePath(shape.getPathIterator(new AffineTransform()), GET_LENGTH, null);
+	}
+
+	/** Returns a path iterator for this ROI's shape containing no curved (only straight) segments */
+	PathIterator getFlatteningPathIterator(Shape s, double fl) {
+		return s.getPathIterator(new AffineTransform(),fl);
+	}
+
+	/**Length of the control polygon of the cubic B&eacute;zier curve argument, in double precision.*/
+	double cplength(CubicCurve2D.Double c) {
+		return 	Math.sqrt(sqr(c.ctrlx1-c.x1) + sqr(c.ctrly1-c.y1)) +
+				Math.sqrt(sqr(c.ctrlx2-c.ctrlx1) + sqr(c.ctrly2-c.ctrly1)) +
+				Math.sqrt(sqr(c.x2-c.ctrlx2) + sqr(c.y2-c.ctrly2));
+	}
+
+	/**Length of the control polygon of the quadratic B&eacute;zier curve argument, in double precision.*/
+	double qplength(QuadCurve2D.Double c) {
+		return  Math.sqrt(sqr(c.ctrlx-c.x1) + sqr(c.ctrly-c.y1)) +
+				Math.sqrt(sqr(c.x2-c.ctrlx) + sqr(c.y2-c.ctrly));
+	}
+
+	/**Length of the chord between the end points of the cubic B&eacute;zier curve argument, in double precision.*/
+	double cclength(CubicCurve2D.Double c) {
+		return Math.sqrt(sqr(c.x2-c.x1) + sqr(c.y2-c.y1));
+	}
+
+	/**Length of the chord between the end points of the quadratic B&eacute;zier curve argument, in double precision.*/
+	double qclength(QuadCurve2D.Double c) {
+		return Math.sqrt(sqr(c.x2-c.x1) + sqr(c.y2-c.y1));
+	}
+
+	/**Calculates the length of a cubic B&eacute;zier curve specified in double precision.
+	 * The algorithm is based on the theory presented in paper <br>
+	 * &quot;Jens Gravesen. Adaptive subdivision and the length and energy of B&eacute;zier curves. Computational Geometry <strong>8:</strong><em>13-31</em> (1997)&quot;
+	 * implemented using <code>java.awt.geom.CubicCurve2D.Double</code>.
+	 * Please visit {@link <a href="http://www.graphicsgems.org/gems.html#gemsiv">Graphics Gems IV</a>} for
+	 * examples of other possible implementations in C and C++.
+	 */
+	double cBezLength(CubicCurve2D.Double c) {
+		double l = 0.0;
+		double cl = cclength(c);
+		double pl = cplength(c);
+		if((pl-cl)/2.0 > maxerror) {
+			CubicCurve2D.Double[] cc = cBezSplit(c);
+			for(int i=0; i<2; i++) l+=cBezLength(cc[i]);
+			return l;
+		}
+		l = 0.5*pl+0.5*cl;
+		return l;
+	}
+
+	/**Calculates the length of a quadratic B&eacute;zier curve specified in double precision.
+	 * The algorithm is based on the theory presented in paper <br>
+	 * &quot;Jens Gravesen. Adaptive subdivision and the length and energy of B&eacute;zier curves. Computational Geometry <strong>8:</strong><em>13-31</em> (1997)&quot;
+	 * implemented using <code>java.awt.geom.CubicCurve2D.Double</code>.
+	 * Please visit {@link <a href="http://www.graphicsgems.org/gems.html#gemsiv">Graphics Gems IV</a>} for
+	 * examples of other possible implementations in C and C++.
+	 */
+	double qBezLength(QuadCurve2D.Double c) {
+		double l = 0.0;
+		double cl = qclength(c);
+		double pl = qplength(c);
+		if((pl-cl)/2.0 > maxerror)
+		{
+			QuadCurve2D.Double[] cc = qBezSplit(c);
+			for(int i=0; i<2; i++) l+=qBezLength(cc[i]);
+			return l;
+		}
+		l = (2.0*pl+cl)/3.0;
+		return l;
+	}
+
+ /**Splits a cubic B&eacute;zier curve in half.
+  * @param c A cubic B&eacute;zier curve to be divided
+  * @return an array with the left and right cubic B&eacute;zier subcurves
+  *
+	*/
+	CubicCurve2D.Double[] cBezSplit(CubicCurve2D.Double c) {
+		CubicCurve2D.Double[] cc = new CubicCurve2D.Double[2];
+		for (int i=0; i<2 ; i++) cc[i] = new CubicCurve2D.Double();
+		c.subdivide(cc[0],cc[1]);
+		return cc;
+	}
+
+ /**Splits a quadratic B&eacute;zier curve in half.
+  * @param c A quadratic B&eacute;zier curve to be divided
+  * @return an array with the left and right quadratic B&eacute;zier subcurves
+  *
+	*/
+	QuadCurve2D.Double[] qBezSplit(QuadCurve2D.Double c) {
+		QuadCurve2D.Double[] cc = new QuadCurve2D.Double[2];
+		for(int i=0; i<2; i++) cc[i] = new QuadCurve2D.Double();
+		c.subdivide(cc[0],cc[1]);
+		return cc;
+	}
+
+	// c is an array of even length with x0, y0, x1, y1, ... ,xn, yn coordinate pairs
+	/**Scales a coordinate array with the size calibration of a 2D image.
+	 * The array is modified in place.
+	 * @param c Array of coordinates in double precision with a <strong>fixed</strong> structure:<br>
+	 * <code>x0,y0,x1,y1,....,xn,yn</code> and with even length of <code>2*(n+1)</code>.
+	 * @param pw The x-scale of the image.
+	 * @param ph The y-scale of the image.
+	 * @param n  number of values in <code>c</code> that should be modified (must be less or equal to the size of <code>c</code>
+	 *
+	 */
+	void scaleCoords(double[] c, int n, double pw, double ph) {
+		for(int i=0; i<n;) {
+			c[i++]*=pw;
+			c[i++]*=ph;
+		}
+	}
+
+	/** Applies an offset xBase, yBase to the n coordinates, which are supposed to be in x, y, x, y ... sequence */
+	static void addOffset(float[] c, int n, float xBase, float yBase) {
+		for(int i=0; i<n;) {
+			c[i++] += xBase;
+			c[i++] += yBase;
+		}
+	}
+
+	/** Retrieves the end points and control points of the path as a float array. The array 
+	 *  contains a sequence of variable length segments that use from from one to seven array elements.
+	 *  The first element of a segment is the type as defined in the PathIterator interface. SEG_MOVETO 
+	 *  and SEG_LINETO segments also include two coordinates (one end point), SEG_QUADTO segments include four 
+	 *  coordinates and SEG_CUBICTO segments include six coordinates (three points).
+	 *  Coordinates are with respect to the image bounds, not the Roi bounds. */
+	public float[] getShapeAsArray() {
+		return getShapeAsArray(shape, (float)getXBase(), (float)getYBase());
+	}
+
+	/** Converts a java.awt.Shape to an array of segment types and coordinates.
+	 *  'xBase' and 'yBase' are added to the x and y coordinates, respectively. */
+	static float[] getShapeAsArray(Shape shape, float xBase, float yBase) {
+		if (shape==null) return null;
+		PathIterator pIt = shape.getPathIterator(new AffineTransform());
+		FloatArray shapeArray = new FloatArray();
+		float[] coords = new float[6];
+		while (!pIt.isDone()) {
+			int segType = pIt.currentSegment(coords);
+			shapeArray.add(segType);
+			int nCoords = nCoords(segType);
+			if (nCoords > 0) {
+				addOffset(coords, nCoords, xBase, yBase);
+				shapeArray.add(coords, nCoords);
+			}
+			pIt.next();
+		}
+		return shapeArray.toArray();
+	}
+
+	final static int ALL_ROIS=0, ONE_ROI=1, GET_LENGTH=2; //task types
+	final static int NO_SEGMENT_ANY_MORE = -1; //pseudo segment type when closed
+	/**Parses the geometry of this ROI's shape by means of the shape's PathIterator;
+	 * Depending on the <code>task</code> and <code>rois</code> argument it will:
+	 * <br>- create a single non-Shape Roi and add it to <code>rois</code> in case
+	 *       there is only one subpath, otherwise add this Roi unchanged to <code>rois</code>
+	 *       (task = ONE_ROI and rois non-null)
+	 * <br>- add each subpath as a Roi to rois; curved subpaths will be flattened, i.e. converted to a
+	 *       polygon approximation (task != ONE_ROI and rois non-null)
+	 * <br>- measure the combined length of all subpaths/Rois and return it (task = GET_LENGTH, rois may be null)
+	 * @param pIter the PathIterator to be parsed.
+	 * @param params an array with one element that will hold the calculated total length of the rois if its initial value is 0.
+	 *        If params holds the value SHAPE_TO_ROI, it will be tried to convert this ShapeRoi to a non-composite Roi. If this
+	 *        is not possible and this ShapeRoi is not empty, a reference to this ShapeRoi will be returned.
+	 * @param rois an ArrayList that will hold ij.gui.Roi objects constructed from subpaths of this path;
+	 *        may be null only when <code>task = GET_LENGTH</code>
+	 * (see @link #shapeToRois()} for details;
+	 * @return Total length if task = GET_LENGTH.*/
+	double parsePath(PathIterator pIter, int task, ArrayList rois) {
+		if (pIter==null || pIter.isDone())
+			return 0.0;
+		double pw = 1.0, ph = 1.0;
+		if (imp!=null) {
+			Calibration cal = imp.getCalibration();
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		}
+		float xbase = (float)getXBase();
+		float ybase = (float)getYBase();
+
+		FloatArray xPoints = new FloatArray();    //vertex coordinates of current subpath
+		FloatArray yPoints = new FloatArray();
+		FloatArray shapeArray = new FloatArray(); //values for creating a GeneralPath for the current subpath
+		boolean getLength = task == GET_LENGTH;
+		int nSubPaths = 0;           // the number of subpaths
+		boolean horVertOnly = true; // subpath has only horizontal or vertical lines
+		boolean closed = false;
+		//boolean success = false;
+		float[]  fcoords = new float[6];  // unscaled float coordinates of the path segment
+		double[] coords  = new double[6]; // scaled (calibrated) coordinates of the path segment
+		double startCalX = 0.0;   // start x of subpath (scaled)
+		double startCalY = 0.0;   // start y of subpath (scaled)
+		double lastCalX = 0.0;    // x of previous point in the subpath (scaled)
+		double lastCalY = 0.0;    // y of previous point in the subpath (scaled)
+		double pathLength = 0.0;  // calibrated pathLength/perimeter of current curve
+		double totalLength = 0.0; // sum of all calibrated path lengths/perimeters
+		double uncalLength = 0.0; // uncalibrated length of polygon, NaN in case of curves
+		boolean done = false;
+		while (true) {
+			int segType = done ? NO_SEGMENT_ANY_MORE : pIter.currentSegment(fcoords);  //read segment (if there is one more)
+			int nCoords = 0;               //will be number of coordinates supplied with the segment
+			if (!done) {
+				nCoords = nCoords(segType);
+				if (getLength) {           //make scaled coodinates to calculate the length
+					pIter.currentSegment(coords);
+					scaleCoords(coords, nCoords, pw, ph);
+				}
+				pIter.next();
+				done = pIter.isDone();
+			}
+
+			//IJ.log("segType="+segType+" nCoord="+nCoords+" done="+done+" nPoi="+nPoints+" len="+pathLength);
+			if (segType == NO_SEGMENT_ANY_MORE || (segType == PathIterator.SEG_MOVETO && xPoints.size()>0)) {
+				// subpath finished: analyze it & create roi if appropriate
+				closed = closed || (xPoints.size()>0 && xPoints.get(0) == xPoints.getLast() && yPoints.get(0) == yPoints.getLast());
+				float[] xpf = xPoints.toArray();
+				float[] ypf = yPoints.toArray();
+				if (Double.isNaN(uncalLength) || !allInteger(xpf) || !allInteger(ypf))
+					horVertOnly = false;         //allow conversion to rectangle or traced roi only for integer coordinates
+				boolean forceTrace = getLength && (!done || nSubPaths>0);  //when calculating the length for >1 subpath, assume traced rois if it can be such
+				int roiType = guessType(xPoints.size(), uncalLength, horVertOnly, forceTrace, closed);
+				Roi roi = null;
+				if (roiType == COMPOSITE && rois != null) { //for ShapeRois with curves, we have the length from the path already, make roi only if needed
+					Shape shape = makeShapeFromArray(shapeArray.toArray());  //the curved subpath (image pixel coordinates)
+					FloatPolygon fp = getFloatPolygon(shape, FLATNESS, /*separateSubpaths=*/ false, /*addPointForClose=*/ false, /*absoluteCoord=*/ false);
+					roi = new PolygonRoi(fp, FREEROI);
+				} else if (roiType != NO_TYPE) { //NO_TYPE looks like an empty roi; only return non-empty rois
+					roi = createRoi(xpf, ypf, roiType);
+				}
+				if (rois != null && roi != null)
+					rois.add(roi);
+				if (task == ONE_ROI) {
+					if (rois.size() > 1) {       //we can't make a single roi from this; so we can only keep the roi as it is
+						rois.clear();
+						rois.add(this);
+						return 0.0;
+					}
+				}
+				if (getLength && roi != null && !Double.isNaN(uncalLength)) {
+					roi.setImage(imp);           //calibration
+					pathLength = roi.getLength();//we don't use the path length of the Shape; e.g. for traced rois ImageJ has a better algorithm
+					roi.setImage(null);
+				}
+				totalLength += pathLength;
+			}
+			if (segType == NO_SEGMENT_ANY_MORE)  // b r e a k   t h e   l o o p
+				return getLength ? totalLength : 0;
+
+			closed = false;
+			switch(segType) {
+				case PathIterator.SEG_MOVETO:    //we start a new subpath
+					xPoints.clear();
+					yPoints.clear();
+					shapeArray.clear();
+					nSubPaths++;
+					pathLength = 0;
+					startCalX = coords[0];  
+					startCalY = coords[1];
+					closed = false;
+					horVertOnly = true;
+					break;
+				case PathIterator.SEG_LINETO:
+					pathLength += Math.sqrt(sqr(lastCalY-coords[1])+sqr(lastCalX-coords[0]));
+					break;
+				case PathIterator.SEG_QUADTO:
+					if (getLength) {
+						QuadCurve2D.Double curve = new QuadCurve2D.Double(lastCalX,lastCalY,coords[0],coords[2],coords[2],coords[3]);
+						pathLength += qBezLength(curve);
+					}
+					uncalLength = Double.NaN;    // not a polygon
+					break;
+				case PathIterator.SEG_CUBICTO:
+					if (getLength) {
+						CubicCurve2D.Double curve = new CubicCurve2D.Double(lastCalX,lastCalY,coords[0],coords[1],coords[2],coords[3],coords[4],coords[5]);
+						pathLength += cBezLength(curve);
+					}
+					uncalLength = Double.NaN;    // not a polygon
+					break;
+				case PathIterator.SEG_CLOSE:
+					pathLength += Math.sqrt(sqr(lastCalX-startCalX) + sqr(lastCalY-startCalY));
+					fcoords[0] = xPoints.get(0); //destination coordinates; with these we can handle it as SEG_LINETO
+					fcoords[1] = yPoints.get(0);
+					closed = true;
+					break;
+				default:
+					break;
+			}
+			if (xPoints.size()>0 && (segType == PathIterator.SEG_LINETO || segType == PathIterator.SEG_CLOSE)) {
+				float dx = fcoords[0] - xPoints.getLast();
+				float dy = fcoords[1] - yPoints.getLast();
+				uncalLength += Math.sqrt(sqr(dx) + sqr(dy));
+				if (dx != 0f && dy != 0f) horVertOnly = false;
+			}
+
+			if (nCoords > 0) {
+				xPoints.add(fcoords[nCoords - 2]); // the last coordinates are the end point of the segment
+				yPoints.add(fcoords[nCoords - 1]);
+				lastCalX = coords[nCoords - 2];
+				lastCalY = coords[nCoords - 1];
+			}
+			shapeArray.add(segType);
+			addOffset(fcoords, nCoords, xbase, ybase); // shift the shape to image origin
+			shapeArray.add(fcoords, nCoords(segType));
+		}
+	}
+
+	/** Non-destructively draws the shape of this object on the associated ImagePlus. */
+	public void draw(Graphics g) {
+		Color color =  strokeColor!=null? strokeColor:ROIColor;
+		boolean isActiveOverlayRoi = !overlay && isActiveOverlayRoi();
+		//IJ.log("draw: "+overlay+"  "+isActiveOverlayRoi);
+		if (isActiveOverlayRoi) {
+			if (color==Color.cyan)
+				color = Color.magenta;
+			else
+				color = Color.cyan;
+		}
+		if (fillColor!=null) color = fillColor;
+		g.setColor(color);
+		AffineTransform aTx = (((Graphics2D)g).getDeviceConfiguration()).getDefaultTransform();
+		Graphics2D g2d = (Graphics2D)g;
+		if (stroke!=null && !isActiveOverlayRoi)
+			g2d.setStroke((ic!=null&&ic.getCustomRoi())||isCursor()?stroke:getScaledStroke());
+		mag = getMagnification();
+		int basex=0, basey=0;
+		if (ic!=null) {
+			Rectangle r = ic.getSrcRect();
+			basex=r.x; basey=r.y;
+		}
+		aTx.setTransform(mag, 0.0, 0.0, mag, -basex*mag, -basey*mag);
+		aTx.translate(getXBase(), getYBase());
+		if (fillColor!=null) {
+			if (isActiveOverlayRoi) {
+				g2d.setColor(Color.cyan);
+				g2d.draw(aTx.createTransformedShape(shape));
+			} else
+				g2d.fill(aTx.createTransformedShape(shape));
+		} else
+			g2d.draw(aTx.createTransformedShape(shape));
+		if (stroke!=null) g2d.setStroke(defaultStroke);
+		if (Toolbar.getToolId()==Toolbar.OVAL)
+			drawRoiBrush(g);
+		if (state!=NORMAL && imp!=null && imp.getRoi()!=null)
+			showStatus();
+		if (updateFullWindow) 
+			{updateFullWindow = false; imp.draw();}
+	}
+
+	public void drawRoiBrush(Graphics g) {
+		g.setColor(ROIColor);
+		int size = Toolbar.getBrushSize();
+		if (size==0 || ic==null)
+			return;
+		int flags = ic.getModifiers();
+		if ((flags&16)==0) return; // exit if mouse button up
+		int osize = size;
+		size = (int)(size*mag);
+		Point p = ic.getCursorLoc();
+		int sx = ic.screenX(p.x);
+		int sy = ic.screenY(p.y);
+		int offset = (int)Math.round(ic.getMagnification()/2.0);
+		if ((osize&1)==0)
+			offset=0; // not needed when brush width even
+		g.drawOval(sx-size/2+offset, sy-size/2+offset, size, size);
+	}
+	
+	/**Draws the shape of this object onto the specified ImageProcessor.
+	 * <br> This method will always draw a flattened version of the actual shape
+	 * (i.e., all curve segments will be approximated by line segments).
+	 */
+	public void drawPixels(ImageProcessor ip) {
+		PathIterator pIter = shape.getPathIterator(new AffineTransform(), flatness);
+		float[] coords = new float[6];
+		float sx=0f, sy=0f;
+		while (!pIter.isDone()) {
+			int segType = pIter.currentSegment(coords);
+			switch(segType) {
+				case PathIterator.SEG_MOVETO:
+					sx = coords[0];
+					sy = coords[1];
+					ip.moveTo(x+(int)sx, y+(int)sy);
+					break;
+				case PathIterator.SEG_LINETO:
+					ip.lineTo(x+(int)coords[0], y+(int)coords[1]);
+					break;
+				case PathIterator.SEG_CLOSE:
+					ip.lineTo(x+(int)sx, y+(int)sy);
+					break;
+				default: break;
+			}
+			pIter.next();
+		}
+	}
+
+	/** Returns this ROI's mask pixels as a ByteProcessor with pixels "in" the mask
+	 *  set to white (255) and pixels "outside" the mask set to black (0).
+	 *  Takes into account the usual ImageJ convention of 0.5 pxl shift between the outline and pixel
+	 *  coordinates; e.g., pixel (0,0) is surrounded by the rectangle spanned between (0,0) and (1,1).
+	 *  Note that apart from the 0.5 pixel shift, ImageJ has different convention for the border points
+	 *  than the java.awt.Shape class:
+	 *  In ImageJ, points exactly at the left (right) border are considered outside (inside);
+	 *  points exactly on horizontal borders, are considered outside (inside) at the border
+	 *  with the lower (higher) y.
+	 *  */
+	public ImageProcessor getMask() {
+		if (shape==null)
+			return null;
+		ImageProcessor mask = cachedMask;
+		if (mask!=null && mask.getPixels()!=null && mask.getWidth()==width && mask.getHeight()==height)
+			return mask;
+		/* The following code using Graphics2D.fill would in principle work, but is very inaccurate
+		 * at least with Oracle Java 8 or OpenJDK Java 10.
+		 * For near-vertical polgon edges of 1000 pixels length, the deviation can be >0.8 pixels in x.
+		 * Thus, approximating the shape by a polygon and using the PolygonFiller is more accurate
+		 * (and roughly equally fast). --ms Jan 2018 */
+		/*BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
+		Graphics2D g2d = bi.createGraphics();
+		g2d.setColor(Color.white);
+		g2d.transform(AffineTransform.getTranslateInstance(-0.48, -0.49994)); //very inaccurate, only reasonable with "-0.48"
+		g2d.fill(shape);
+		Raster raster = bi.getRaster();
+		DataBufferByte buffer = (DataBufferByte)raster.getDataBuffer();		
+		byte[] mask = buffer.getData();
+		cachedMask = new ByteProcessor(width, height, mask, null);
+		cachedMask.setThreshold(255,255,ImageProcessor.NO_LUT_UPDATE);*/
+		FloatPolygon fpoly = getFloatPolygon(FILL_FLATNESS, true, false, false);
+		PolygonFiller pf = new PolygonFiller(fpoly.xpoints, fpoly.ypoints, fpoly.npoints, (float)(getXBase()-x), (float)(getYBase()-y));
+		mask = pf.getMask(width, height);
+		cachedMask = mask;
+        return mask;
+	}
+
+	/**Returns a reference to the Shape object encapsulated by this ShapeRoi. */
+	public Shape getShape() {
+		return shape;
+	}
+
+	/**Sets the <code>java.awt.Shape</code> object encapsulated by <strong><code>this</code></strong>
+	 * to the argument.
+	 * <br>This object will hold a (shallow) copy of the shape argument. If a deep copy
+	 * of the shape argumnt is required, then a clone of the argument should be passed
+	 * in; a possible example is <code>setShape(ShapeRoi.cloneShape(shape))</code>.
+	 * @return <strong><code>false</code></strong> if the argument is null.
+	 */
+	boolean setShape(Shape rhs) {
+		boolean result = true;
+		if (rhs==null) return false;
+		if (shape.equals(rhs)) return false;
+		shape = rhs;
+		type = Roi.COMPOSITE;
+		Rectangle rect = shape.getBounds();
+		width = rect.width;
+		height = rect.height;
+		return true;
+	}
+
+	/**Returns the element with the smallest value in the array argument.*/
+	private int min(int[] array) {
+		int val = array[0];
+		for (int i=1; i<array.length; i++) val = Math.min(val,array[i]);
+		return val;
+	}
+
+	/**Returns the element with the largest value in the array argument.*/
+	private int max(int[] array) {
+		int val = array[0];
+		for (int i=1; i<array.length; i++) val = Math.max(val,array[i]);
+		return val;
+	}
+	
+	static ShapeRoi getCircularRoi(int x, int y, int width) {
+		return new ShapeRoi(new OvalRoi(x - width / 2, y - width / 2, width, width));
+	}
+
+	/** Always returns -1 since ShapeRois do not have handles. */
+	public int isHandle(int sx, int sy) {
+		   return -1;
+	}
+
+	/** Used by the getSelectionCoordinates macro function */
+	public FloatPolygon getSelectionCoordinates() {
+		return getFloatPolygon(FLATNESS, true, false, true);
+	}
+
+	/** Returns a FloatPolygon with all vertices of the flattened shape, i.e., the shape approximated by
+	 *  straight line segments. This method is for listing the coordinates and creating the convex hull.
+	 *  @param flatness Roughly the maximum allowable distance between the shape and the approximate polygon
+	 *  @param separateSubpaths whether individual subpaths should be separated by NaN coordinates
+	 *  @param addPointForClose whether the starting point of a closed subpath should be repeated at its end.
+	 *   Note that with <code>addPointForClose = false</code>, there is no distinction between open and closed subpaths.
+	 *  @param absoluteCoord specifies whether the coordinates should be with respect to image bounds, not Roi bounds. */
+	public FloatPolygon getFloatPolygon(double flatness, boolean separateSubpaths, boolean addPointForClose, boolean absoluteCoord) {
+		return getFloatPolygon(shape, flatness, separateSubpaths, addPointForClose, absoluteCoord);
+	}
+
+	public FloatPolygon getFloatPolygon(Shape shape, double flatness, boolean separateSubpaths, boolean addPointForClose, boolean absoluteCoord) {
+		if (shape == null) return null;
+		PathIterator pIter = getFlatteningPathIterator(shape, flatness);
+		FloatArray xp = new FloatArray();
+		FloatArray yp = new FloatArray();
+		float[] coords = new float[6];
+		int subPathStart = 0;
+		while (!pIter.isDone()) {
+			int segType = pIter.currentSegment(coords);
+			switch(segType) {
+				case PathIterator.SEG_MOVETO:
+					if (separateSubpaths && xp.size()>0 && !Float.isNaN(xp.get(xp.size()-1))) {
+						xp.add(Float.NaN);
+						yp.add(Float.NaN);
+					}
+					subPathStart = xp.size();
+				case PathIterator.SEG_LINETO:
+					xp.add(coords[0]);
+					yp.add(coords[1]);
+					break;
+				case PathIterator.SEG_CLOSE:
+					boolean isClosed = xp.getLast() == xp.get(subPathStart) && yp.getLast() == yp.get(subPathStart);
+					if (addPointForClose && !isClosed) {
+						xp.add(xp.get(subPathStart));
+						yp.add(yp.get(subPathStart));
+					} else if (isClosed) {
+						xp.removeLast(1);  //remove duplicate point if we should not add point to close the shape
+						yp.removeLast(1);
+					}
+					if (separateSubpaths && xp.size()>0 && !Float.isNaN(xp.get(xp.size()-1))) {
+						xp.add(Float.NaN);
+						yp.add(Float.NaN);
+					}
+					break;
+				default:
+					throw new RuntimeException("Invalid Segment Type: "+segType);
+			}
+			pIter.next();
+		}
+		float[] xpf = xp.toArray();
+		float[] ypf = yp.toArray();
+		if (absoluteCoord) {
+			Tools.addToArray(xpf, (float)getXBase());
+			Tools.addToArray(ypf, (float)getYBase());
+		}
+		int n = xpf.length;
+		if (n>0 && Float.isNaN(xpf[n-1])) n--; //omit NaN at the end
+		return new FloatPolygon(xpf, ypf, n);
+	}
+
+	public FloatPolygon getFloatConvexHull() {
+		FloatPolygon fp = getFloatPolygon(FLATNESS, /*separateSubpaths=*/ false, /*addPointForClose=*/ false, /*absoluteCoord=*/ true);
+		return fp == null ? null : fp.getConvexHull();
+	}
+	
+	public Polygon getPolygon() {
+		FloatPolygon fp = getFloatPolygon();
+		return new Polygon(toIntR(fp.xpoints), toIntR(fp.ypoints), fp.npoints);
+	}
+
+	/** Returns all vertex points of the shape as approximated by polygons,
+	 *  in image pixel coordinates */
+	public FloatPolygon getFloatPolygon() {
+		return getFloatPolygon(FLATNESS, /*separateSubpaths=*/ false, /*addPointForClose=*/ false, /*absoluteCoord=*/ true);
+	}
+
+	/** Returns all vertex points of the shape as approximated by polygons,
+	 *  where options may include "close" to add points to close each subpath, and
+	 *  "separate" to insert NaN values between subpaths (= individual polygons) */
+	public FloatPolygon getFloatPolygon(String options) {
+		options = options.toLowerCase();
+		boolean separateSubpaths = options.indexOf("separate") >= 0;
+		boolean addPointForClose = options.indexOf("close") >= 0;
+		return getFloatPolygon(FLATNESS, separateSubpaths, addPointForClose, /*absoluteCoord=*/ true);
+	}
+
+	/** Retuns the number of vertices, of this shape as approximated by straight lines.
+	 *  Note that points might be counted twice where the shape gets closed. */
+	public int size() {
+		return getPolygon().npoints;
+	}
+
+	boolean allInteger(float[] a) {
+		for (int i=0; i<a.length; i++)
+			if (a[i] != (int)a[i]) return false;
+		return true;
+	}
+}
diff --git a/src/ij/gui/StackWindow.java b/src/ij/gui/StackWindow.java
new file mode 100644
index 0000000..f242058
--- /dev/null
+++ b/src/ij/gui/StackWindow.java
@@ -0,0 +1,374 @@
+package ij.gui;
+import ij.*;
+import ij.measure.Calibration;
+import ij.plugin.frame.SyncWindows;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+
+/** This class is an extended ImageWindow that displays stacks and hyperstacks. */
+public class StackWindow extends ImageWindow implements Runnable, AdjustmentListener, ActionListener, MouseWheelListener {
+
+	protected Scrollbar sliceSelector; // for backward compatibity with Image5D
+	protected ScrollbarWithLabel cSelector, zSelector, tSelector;
+	protected Thread thread;
+	protected volatile boolean done;
+	protected volatile int slice;
+	protected ScrollbarWithLabel animationSelector;
+	boolean hyperStack;
+	int nChannels=1, nSlices=1, nFrames=1;
+	int c=1, z=1, t=1;
+
+
+	public StackWindow(ImagePlus imp) {
+		this(imp, null);
+	}
+
+	public StackWindow(ImagePlus imp, ImageCanvas ic) {
+		super(imp, ic);
+		addScrollbars(imp);
+		addMouseWheelListener(this);
+		if (sliceSelector==null && this.getClass().getName().indexOf("Image5D")!=-1)
+			sliceSelector = new Scrollbar(); // prevents Image5D from crashing
+		pack();
+		ic = imp.getCanvas();
+		if (ic!=null)
+			ic.setMaxBounds();
+		if (IJ.isMacro() && !isVisible()) //'super' may have called show()
+			imp.setDeactivated(); //prepare for waitTillActivated (imp may have been activated before)
+		show();
+		if (IJ.isMacro())
+			imp.waitTillActivated();
+		int previousSlice = imp.getCurrentSlice();
+		if (previousSlice>1 && previousSlice<=imp.getStackSize())
+			imp.setSlice(previousSlice);
+		else
+			imp.setSlice(1);
+		thread = new Thread(this, "zSelector");
+		thread.start();
+	}
+
+	void addScrollbars(ImagePlus imp) {
+		ImageStack s = imp.getStack();
+		int stackSize = s.getSize();
+		int sliderHeight = 0;
+		nSlices = stackSize;
+		hyperStack = imp.getOpenAsHyperStack();
+		//imp.setOpenAsHyperStack(false);
+		int[] dim = imp.getDimensions();
+		int nDimensions = 2+(dim[2]>1?1:0)+(dim[3]>1?1:0)+(dim[4]>1?1:0);
+		if (nDimensions<=3 && dim[2]!=nSlices)
+			hyperStack = false;
+		if (hyperStack) {
+			nChannels = dim[2];
+			nSlices = dim[3];
+			nFrames = dim[4];
+		}
+		if (nSlices==stackSize) hyperStack = false;
+		if (nChannels*nSlices*nFrames!=stackSize) hyperStack = false;
+		if (cSelector!=null||zSelector!=null||tSelector!=null)
+			removeScrollbars();
+		ImageJ ij = IJ.getInstance();
+		//IJ.log("StackWindow: "+hyperStack+" "+nChannels+" "+nSlices+" "+nFrames+" "+imp);
+		if (nChannels>1) {
+			cSelector = new ScrollbarWithLabel(this, 1, 1, 1, nChannels+1, 'c');
+			add(cSelector);
+			sliderHeight += cSelector.getPreferredSize().height + ImageWindow.VGAP;
+			if (ij!=null) cSelector.addKeyListener(ij);
+			cSelector.addAdjustmentListener(this);
+			cSelector.setFocusable(false); // prevents scroll bar from blinking on Windows
+			cSelector.setUnitIncrement(1);
+			cSelector.setBlockIncrement(1);
+		}
+		if (nSlices>1) {
+			char label = nChannels>1||nFrames>1?'z':'t';
+			if (stackSize==dim[2] && imp.isComposite()) label = 'c';
+			zSelector = new ScrollbarWithLabel(this, 1, 1, 1, nSlices+1, label);
+			if (label=='t') animationSelector = zSelector;
+			add(zSelector);
+			sliderHeight += zSelector.getPreferredSize().height + ImageWindow.VGAP;
+			if (ij!=null) zSelector.addKeyListener(ij);
+			zSelector.addAdjustmentListener(this);
+			zSelector.setFocusable(false);
+			int blockIncrement = nSlices/10;
+			if (blockIncrement<1) blockIncrement = 1;
+			zSelector.setUnitIncrement(1);
+			zSelector.setBlockIncrement(blockIncrement);
+			sliceSelector = zSelector.bar;
+		}
+		if (nFrames>1) {
+			animationSelector = tSelector = new ScrollbarWithLabel(this, 1, 1, 1, nFrames+1, 't');
+			add(tSelector);
+			sliderHeight += tSelector.getPreferredSize().height + ImageWindow.VGAP;
+			if (ij!=null) tSelector.addKeyListener(ij);
+			tSelector.addAdjustmentListener(this);
+			tSelector.setFocusable(false);
+			int blockIncrement = nFrames/10;
+			if (blockIncrement<1) blockIncrement = 1;
+			tSelector.setUnitIncrement(1);
+			tSelector.setBlockIncrement(blockIncrement);
+		}
+		ImageWindow win = imp.getWindow();
+		if (win!=null)
+			win.setSliderHeight(sliderHeight);
+	}
+
+	/** Enables or disables the sliders. Used when locking/unlocking an image. */
+	public synchronized void setSlidersEnabled(final boolean b) {
+		EventQueue.invokeLater(new Runnable() {
+			public void run() {
+				if (sliceSelector != null)	   sliceSelector.setEnabled(b);
+				if (cSelector != null)		   cSelector.setEnabled(b);
+				if (zSelector != null)		   zSelector.setEnabled(b);
+				if (tSelector != null)		   tSelector.setEnabled(b);
+				if (animationSelector != null) animationSelector.setEnabled(b);
+			}
+		});
+	}
+
+	public synchronized void adjustmentValueChanged(AdjustmentEvent e) {
+		if (!running2 || imp.isHyperStack()) {
+			if (e.getSource()==cSelector) {
+				c = cSelector.getValue();
+				if (c==imp.getChannel()&&e.getAdjustmentType()==AdjustmentEvent.TRACK) return;
+			} else if (e.getSource()==zSelector) {
+				z = zSelector.getValue();
+				int slice = hyperStack?imp.getSlice():imp.getCurrentSlice();
+				if (z==slice&&e.getAdjustmentType()==AdjustmentEvent.TRACK) return;
+			} else if (e.getSource()==tSelector) {
+				t = tSelector.getValue();
+				if (t==imp.getFrame()&&e.getAdjustmentType()==AdjustmentEvent.TRACK) return;
+			}
+			slice = (t-1)*nChannels*nSlices + (z-1)*nChannels + c;
+			notify();
+		}
+		if (!running)
+			syncWindows(e.getSource());
+	}
+
+	private void syncWindows(Object source) {
+		if (SyncWindows.getInstance()==null)
+			return;
+		if (source==cSelector)
+			SyncWindows.setC(this, cSelector.getValue());
+		else if (source==zSelector) {
+			int stackSize = imp.getStackSize();
+			if (imp.getNChannels()==stackSize)
+				SyncWindows.setC(this, zSelector.getValue());
+			else if (imp.getNFrames()==stackSize)
+				SyncWindows.setT(this, zSelector.getValue());
+			else
+				SyncWindows.setZ(this, zSelector.getValue());
+		} else if (source==tSelector)
+			SyncWindows.setT(this, tSelector.getValue());
+		else
+			throw new RuntimeException("Unknownsource:"+source);
+	}
+
+	public void actionPerformed(ActionEvent e) {
+	}
+
+	public void mouseWheelMoved(MouseWheelEvent e) {
+		synchronized(this) {
+			int rotation = e.getWheelRotation();
+			boolean ctrl = (e.getModifiers()&Event.CTRL_MASK)!=0;
+			if ((ctrl||IJ.shiftKeyDown()) && ic!=null) {
+				Point loc = ic.getCursorLoc();
+				int x = ic.screenX(loc.x);
+				int y = ic.screenY(loc.y);
+				if (rotation<0)
+					ic.zoomIn(x,y);
+				else
+					ic.zoomOut(x,y);
+				return;
+			}
+			if (hyperStack) {
+				if (rotation>0)
+					IJ.run(imp, "Next Slice [>]", "");
+				else if (rotation<0)
+					IJ.run(imp, "Previous Slice [<]", "");
+			} else {
+				int slice = imp.getCurrentSlice() + rotation;
+				if (slice<1)
+					slice = 1;
+				else if (slice>imp.getStack().getSize())
+					slice = imp.getStack().getSize();
+				setSlice(imp,slice);
+				imp.updateStatusbarValue();
+				SyncWindows.setZ(this, slice);
+			}
+		}
+	}
+
+	public boolean close() {
+		if (!super.close())
+			return false;
+		synchronized(this) {
+			done = true;
+			notify();
+		}
+		return true;
+	}
+
+	/** Displays the specified slice and updates the stack scrollbar. */
+	public void showSlice(int index) {
+		if (imp!=null && index>=1 && index<=imp.getStackSize()) {
+			setSlice(imp,index);
+			SyncWindows.setZ(this, index);
+		}
+	}
+
+	/** Updates the stack scrollbar. */
+	public void updateSliceSelector() {
+		if (hyperStack || zSelector==null || imp==null)
+			return;
+		int stackSize = imp.getStackSize();
+		int max = zSelector.getMaximum();
+		if (max!=(stackSize+1))
+			zSelector.setMaximum(stackSize+1);
+		EventQueue.invokeLater(new Runnable() {
+			public void run() {
+				if (imp!=null && zSelector!=null)
+					zSelector.setValue(imp.getCurrentSlice());
+			}
+		});
+	}
+
+	public void run() {
+		while (!done) {
+			synchronized(this) {
+				try {wait();}
+				catch(InterruptedException e) {}
+			}
+			if (done) return;
+			if (slice>0) {
+				int s = slice;
+				slice = 0;
+				if (s!=imp.getCurrentSlice()) {
+					imp.updatePosition(c, z, t);
+					setSlice(imp,s);
+				}
+			}
+		}
+	}
+
+	public String createSubtitle() {
+		String subtitle = super.createSubtitle();
+		if (!hyperStack || imp.getStackSize()==1)
+			return subtitle;
+		String s="";
+		int[] dim = imp.getDimensions(false);
+		int channels=dim[2], slices=dim[3], frames=dim[4];
+		if (channels>1) {
+			s += "c:"+imp.getChannel()+"/"+channels;
+			if (slices>1||frames>1) s += " ";
+		}
+		if (slices>1) {
+			s += "z:"+imp.getSlice()+"/"+slices;
+			if (frames>1) s += " ";
+		}
+		if (frames>1)
+			s += "t:"+imp.getFrame()+"/"+frames;
+		if (running2) return s;
+		int index = subtitle.indexOf(";");
+		if (index!=-1) {
+			int index2 = subtitle.indexOf("(");
+			if (index2>=0 && index2<index && subtitle.length()>index2+4 && !subtitle.substring(index2+1, index2+4).equals("ch:")) {
+				index = index2;
+				s = s + " ";
+			}
+			subtitle = subtitle.substring(index, subtitle.length());
+		} else
+			subtitle = "";
+		return s + subtitle;
+	}
+
+	public boolean isHyperStack() {
+		return hyperStack && getNScrollbars()>0;
+	}
+
+	public void setPosition(int channel, int slice, int frame) {
+		if (cSelector!=null && channel!=c) {
+			c = channel;
+			cSelector.setValue(channel);
+			SyncWindows.setC(this, channel);
+		}
+		if (zSelector!=null && slice!=z) {
+			z = slice;
+			zSelector.setValue(slice);
+			SyncWindows.setZ(this, slice);
+		}
+		if (tSelector!=null && frame!=t) {
+			t = frame;
+			tSelector.setValue(frame);
+			SyncWindows.setT(this, frame);
+		}
+		this.slice = (t-1)*nChannels*nSlices + (z-1)*nChannels + c;
+		imp.updatePosition(c, z, t);
+		if (this.slice>0) {
+			int s = this.slice;
+			this.slice = 0;
+			if (s!=imp.getCurrentSlice())
+				imp.setSlice(s);
+		}
+	}
+
+	private void setSlice(ImagePlus imp, int n) {
+		if (imp.isLocked()) {
+			IJ.beep();
+			IJ.showStatus("Image is locked");
+		} else
+			imp.setSlice(n);
+	}
+
+	public boolean validDimensions() {
+		int c = imp.getNChannels();
+		int z = imp.getNSlices();
+		int t = imp.getNFrames();
+		//IJ.log(c+" "+z+" "+t+" "+nChannels+" "+nSlices+" "+nFrames+" "+imp.getStackSize());
+		int size = imp.getStackSize();
+		if (c==size && c*z*t==size && nSlices==size && nChannels*nSlices*nFrames==size)
+			return true;
+		if (c!=nChannels||z!=nSlices||t!=nFrames||c*z*t!=size)
+			return false;
+		else
+			return true;
+	}
+
+	public void setAnimate(boolean b) {
+		if (running2!=b && animationSelector!=null)
+			animationSelector.updatePlayPauseIcon();
+		running2 = b;
+	}
+
+	public boolean getAnimate() {
+		return running2;
+	}
+
+	public int getNScrollbars() {
+		int n = 0;
+		if (cSelector!=null) n++;
+		if (zSelector!=null) n++;
+		if (tSelector!=null) n++;
+		return n;
+	}
+
+	void removeScrollbars() {
+		if (cSelector!=null) {
+			remove(cSelector);
+			cSelector.removeAdjustmentListener(this);
+			cSelector = null;
+		}
+		if (zSelector!=null) {
+			remove(zSelector);
+			zSelector.removeAdjustmentListener(this);
+			zSelector = null;
+		}
+		if (tSelector!=null) {
+			remove(tSelector);
+			tSelector.removeAdjustmentListener(this);
+			tSelector = null;
+		}
+	}
+
+}
diff --git a/src/ij/gui/TextRoi.java b/src/ij/gui/TextRoi.java
new file mode 100644
index 0000000..44b920a
--- /dev/null
+++ b/src/ij/gui/TextRoi.java
@@ -0,0 +1,743 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.util.*;
+import ij.macro.Interpreter;
+import ij.plugin.frame.Recorder;
+import ij.plugin.Colors;
+import java.awt.geom.*;
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+
+/** This class is a rectangular ROI containing text. */
+public class TextRoi extends Roi {
+
+	public static final int LEFT=0, CENTER=1, RIGHT=2;
+	static final int MAX_LINES = 50;
+
+	private static final String line1 = "Enter text, then press";
+	private static final String line2 = "ctrl+b to add to overlay";
+	private static final String line3 = "or ctrl+d to draw.";
+	private static final String line1a = "Enter text...";
+	private String[] theText = new String[MAX_LINES];
+	private static String name = "SansSerif";
+	private static int style = Font.PLAIN;
+	private static int size = 18;
+	private Font font;
+	private static boolean antialiasedText = true; // global flag used by text tool
+	private static int globalJustification = LEFT;
+	private static Color defaultFillColor;
+	private int justification = LEFT;
+	private double previousMag;
+	private boolean firstChar = true;
+	private boolean firstMouseUp = true;
+	private double angle;  // degrees
+	private static double defaultAngle;
+	private static boolean firstTime = true;
+	private Roi previousRoi;
+	private Graphics fontGraphics;
+	private static Font defaultFont = IJ.font12;
+
+	/** Creates a TextRoi using the defaultFont.*/
+	public TextRoi(int x, int y, String text) {
+		this(x, y, text, defaultFont);
+	}
+	
+	/** Use this constructor as a drop-in replacement for ImageProcessor.drawString(). */
+	public TextRoi(String text, double x, double y, Font font) {
+		super(x, y, 1, 1);
+		init(text,font);
+		if (font!=null) {
+			Graphics g = getFontGraphics(font);
+			FontMetrics metrics = g.getFontMetrics(font);
+			Rectangle2D.Double fbounds = getFloatBounds();
+			fbounds.y = fbounds.y-metrics.getAscent();
+			setBounds(fbounds);
+		}
+	}
+
+	/** Creates a TextRoi using sub-pixel coordinates.*/
+	public TextRoi(double x, double y, String text) {
+		super(x, y, 1.0, 1.0);
+		init(text, null);
+	}
+
+	/** Creates a TextRoi using the specified location and Font.
+	 * @see ij.gui.Roi#setStrokeColor
+	 * @see ij.gui.Roi#setNonScalable
+	 * @see ij.ImagePlus#setOverlay(ij.gui.Overlay)
+	 */
+	public TextRoi(int x, int y, String text, Font font) {
+		super(x, y, 1, 1);
+		init(text, font);
+	}
+
+	/** Creates a TextRoi using the specified sub-pixel location and Font. */
+	public TextRoi(double x, double y, String text, Font font) {
+		super(x, y, 1.0, 1.0);
+		init(text, font);
+	}
+
+	/** Creates a TextRoi using the specified sub-pixel location, size and Font. */
+	public TextRoi(double x, double y, double width, double height, String text, Font font) {
+		super(x, y, width, height);
+		init(text, font);
+	}
+	
+	/** Creates a TextRoi using the specified text and location. */
+	public static TextRoi create(String text, double x, double y, Font font) {
+		return new TextRoi(text, x, y, font);
+	}
+
+	/** Obsolete. */
+	public static TextRoi create(double x, double y, String text, Font font) {
+		return new TextRoi(x, y, text, font);
+	}
+
+	private void init(String text, Font font) {
+		String[] lines = Tools.split(text, "\n");
+		int count = Math.min(lines.length, MAX_LINES);
+		for (int i=0; i<count; i++)
+			theText[i] = lines[i];
+		if (font==null)
+			font = defaultFont;
+		if (font==null)
+			font = new Font("SansSerif", Font.PLAIN, 14);
+		this.font = font;
+		setAntiAlias(antialiasedText);
+		firstChar = false;
+		if (defaultColor!=null)
+			setStrokeColor(defaultColor);
+		updateBounds();
+	}
+
+	/** @deprecated */
+	public TextRoi(int x, int y, String text, Font font, Color color) {
+		super(x, y, 1, 1);
+		if (font==null) font = new Font(name, style, size);
+		this.font = font;
+		IJ.error("TextRoi", "API has changed. See updated example at\nhttp://imagej.nih.gov/ij/macros/js/TextOverlay.js");
+	}
+
+	public TextRoi(int x, int y, ImagePlus imp) {
+		super(x, y, imp);
+		ImageCanvas ic = imp.getCanvas();
+		double mag = getMagnification();
+		if (mag>1.0)
+			mag = 1.0;
+		if (size<(12/mag))
+			size = (int)(12/mag);
+		if (firstTime) {
+			theText[0] = line1;
+			theText[1] = line2;
+			theText[2] = line3;
+			firstTime = false;
+		} else
+			theText[0] = line1a;
+		if (previousRoi!=null && (previousRoi instanceof TextRoi)) {
+			firstMouseUp = false;
+			previousRoi = null;
+		}
+		font = new Font(name, style, size);
+		justification = globalJustification;
+		setStrokeColor(Toolbar.getForegroundColor());
+		setAntiAlias(antialiasedText);
+		if (WindowManager.getWindow("Fonts")!=null) {
+			setFillColor(defaultFillColor);
+			setAngle(defaultAngle);
+		}
+	}
+
+	/** This method is used by the text tool to add typed
+		characters to displayed text selections. */
+	public void addChar(char c) {
+		if (imp==null) return;
+		if (!(c>=' ' || c=='\b' || c=='\n')) return;
+		int cline = 0;
+		if (firstChar) {
+			theText[cline] = new String("");
+			for (int i=1; i<MAX_LINES; i++)
+				theText[i] = null;
+		} else {
+			for (int i=0; i<theText.length && theText[i] != null; i++)
+				cline = i; //add the character to the last line
+		}
+		if ((int)c=='\b') {
+			// backspace
+			if (theText[cline].length()>0)
+				theText[cline] = theText[cline].substring(0, theText[cline].length()-1);
+			else if (cline>0) {
+				theText[cline] = null;
+				cline--;
+			}
+			if (angle!=0.0)
+				imp.draw();
+			else
+				imp.draw(clipX, clipY, clipWidth, clipHeight);
+			firstChar = false;
+			return;
+		} else if ((int)c=='\n') {
+			// newline
+			if (cline<(MAX_LINES-1)) cline++;
+			theText[cline] = "";
+			updateBounds();
+			updateText();
+		} else {
+			char[] chr = {c};
+			theText[cline] += new String(chr);
+			updateBounds();
+			updateText();
+			firstChar = false;
+			return;
+		}
+	}
+
+	Font getScaledFont() {
+		if (font==null)
+			font = new Font("SansSerif", Font.PLAIN, 14);
+		double mag = getMagnification();
+		if (nonScalable || imp==null || mag==1.0)
+			return font;
+		else
+			return font.deriveFont((float)(font.getSize()*mag));
+	}
+	
+	/** Renders the text on the image. Draws the text in
+	 * the foreground color if ip.setColor(Color) has
+	 * not been called.
+	 *	@see ij.process.ImageProcessor#setFont(Font)
+	 *	@see ij.process.ImageProcessor#setAntialiasedText(boolean)
+	 *	@see ij.process.ImageProcessor#setColor(Color)
+	*/
+	public void drawPixels(ImageProcessor ip) {
+		if (!ip.fillValueSet())
+			ip.setColor(Toolbar.getForegroundColor());
+		ip.setFont(font);
+		ip.setAntialiasedText(getAntiAlias());
+		FontMetrics metrics = ip.getFontMetrics();
+		int fontHeight = metrics.getHeight();
+		int descent = metrics.getDescent();
+		int i = 0;
+		int yy = 0;
+		int xi = (int)Math.round(getXBase());
+		int yi = (int)Math.round(getYBase());
+		while (i<MAX_LINES && theText[i]!=null) {
+			switch (justification) {
+				case LEFT:
+					ip.drawString(theText[i], xi, yi+yy+fontHeight);
+					break;
+				case CENTER:
+					int tw = metrics.stringWidth(theText[i]);
+					ip.drawString(theText[i], xi+(this.width-tw)/2, yi+yy+fontHeight);
+					break;
+				case RIGHT:
+					tw = metrics.stringWidth(theText[i]);
+					ip.drawString(theText[i], xi+this.width-tw, yi+yy+fontHeight);
+					break;
+			}
+			i++;
+			yy += fontHeight;
+		}
+	}
+
+	/** Draws the text on the screen, clipped to the ROI. */
+	public void draw(Graphics g) {
+		if (IJ.debugMode) IJ.log("draw: "+theText[0]+"  "+this.width+","+this.height);
+		if (Interpreter.isBatchMode() && ic!=null && ic.getDisplayList()!=null)
+			return;
+		Color c = getStrokeColor();
+		setStrokeColor(getColor());
+		super.draw(g); // draw the rectangle
+		setStrokeColor(c);
+		double mag = getMagnification();
+		int sx = screenXD(getXBase());
+		int sy = screenYD(getYBase());
+		int swidth = (int)((bounds!=null?bounds.width:this.width)*mag);
+		int sheight = (int)((bounds!=null?bounds.height:this.height)*mag);
+		Rectangle r = null;
+		if (angle!=0.0)
+			drawText(g);
+		else {
+			r = g.getClipBounds();
+			g.setClip(sx, sy, swidth, sheight);
+			drawText(g);
+			if (r!=null)
+				g.setClip(r.x, r.y, r.width, r.height);
+		}
+	}
+	
+	public void drawOverlay(Graphics g) {
+		drawText(g);
+	}
+
+	void drawText(Graphics g) {
+		g.setColor( strokeColor!=null? strokeColor:ROIColor);
+		Java2.setAntialiasedText(g, getAntiAlias());
+		double mag = getMagnification();
+		int xi = (int)Math.round(getXBase());
+		int yi = (int)Math.round(getYBase());
+		double widthd = bounds!=null?bounds.width:this.width;
+		double heightd = bounds!=null?bounds.height:this.height;
+		int widthi = (int)Math.round(widthd);
+		int heighti = (int)Math.round(heightd);
+		Font font = getScaledFont();
+		FontMetrics metrics = g.getFontMetrics(font);
+		int fontHeight = metrics.getHeight();
+		int descent = metrics.getDescent();
+		g.setFont(font);
+		Graphics2D g2d = (Graphics2D)g;
+		int sx = nonScalable?xi:screenXD(getXBase());
+		int sy = nonScalable?yi:screenYD(getYBase());
+		int sw = nonScalable?widthi:(int)(getMagnification()*widthd);
+		int sh = nonScalable?heighti:(int)(getMagnification()*heightd);
+		AffineTransform at = null;
+		if (angle!=0.0) {
+			at = g2d.getTransform();
+			double cx=sx, cy=sy;
+			double theta = Math.toRadians(angle);
+			g2d.rotate(-theta, cx, cy);
+		}
+		int i = 0;
+		if (fillColor!=null) {
+			Color c = g.getColor();
+			int alpha = fillColor.getAlpha();
+ 			g.setColor(fillColor);
+			g.fillRect(sx, sy, sw, sh);
+			g.setColor(c);
+		}
+		while (i<MAX_LINES && theText[i]!=null) {
+			switch (justification) {
+				case LEFT:
+					g.drawString(theText[i], sx, sy+fontHeight-descent);
+					break;
+				case CENTER:
+					int tw = metrics.stringWidth(theText[i]);
+					g.drawString(theText[i], sx+(sw-tw)/2, sy+fontHeight-descent);
+					break;
+				case RIGHT:
+					tw = metrics.stringWidth(theText[i]);
+					g.drawString(theText[i], sx+sw-tw, sy+fontHeight-descent);
+					break;
+			}
+			i++;
+			sy += fontHeight;
+		}
+		if (at!=null)  // restore transformation matrix used to rotate text
+			g2d.setTransform(at);
+	}
+
+	/** Returns the name of the default font. Use getCurrentFont().getName()
+		 to get the name of the font that this TextRoi is using. */
+	public static String getDefaultFontName() {
+		return name;
+	}
+
+	/** Returns the default font size. Use getCurrentFont().getSize()
+		 to get the size of the font that this TextRoi is using. */
+	public static int getDefaultFontSize() {
+		return size;
+	}
+
+	/** Returns the default font style. Use getCurrentFont().getStyle()
+		 to get the style of the font that this TextRoi is using. */
+	public static int getDefaultFontStyle() {
+		return style;
+	}
+	
+	/** Sets the current font. */
+	public void setFont(Font font) {
+		this.font = font;
+		updateBounds();
+	}
+	
+	/** Sets the size of the current font. */
+	public void setFontSize(int size) {
+		if (font==null)
+			font = defaultFont;
+		font = font.deriveFont((float)size);
+	}
+		
+	/** Returns the current font. */
+	public Font getCurrentFont() {
+		return font;
+	}
+	
+	/** Returns the state of the global 'antialiasedText' variable, which is used by the "Fonts" widget. */
+	public static boolean isAntialiased() {
+		return antialiasedText;
+	}
+
+	/** Sets the state of the global 'antialiasedText' variable. */
+	public static void setAntialiasedText(boolean antialiased) {
+		antialiasedText = antialiased;
+	}
+	
+	/** Sets the 'antiAlias' instance variable. */
+	public void setAntialiased(boolean antiAlias) {
+		setAntiAlias(antiAlias);
+		if (angle>0.0)
+			setAntiAlias(true);
+	}
+	
+	/** Returns the state of the 'antiAlias' instance variable. */
+	public boolean getAntialiased() {
+		return getAntiAlias();
+	}
+		
+	/** Sets the default text tool justification (LEFT, CENTER or RIGHT). */
+	public static void setGlobalJustification(int justification) {
+		if (justification<0 || justification>RIGHT)
+			justification = LEFT;
+		globalJustification = justification;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			Roi roi = imp.getRoi();
+			if (roi instanceof TextRoi) {
+				((TextRoi)roi).setJustification(justification);
+				imp.draw();
+			}
+		}
+	}
+	
+	/** Returns the default text tool justification (LEFT, CENTER or RIGHT). */
+	public static int getGlobalJustification() {
+		return globalJustification;
+	}
+
+	/** Sets the 'justification' instance variable (LEFT, CENTER or RIGHT) */
+	public void setJustification(int justification) {
+		if (justification<0 || justification>RIGHT)
+			justification = LEFT;
+		this.justification = justification;
+		updateBounds();
+		if (imp!=null)
+			imp.draw();
+	}
+	
+	/** Returns the value of the 'justification' instance variable (LEFT, CENTER or RIGHT). */
+	public int getJustification() {
+		return justification;
+	}
+
+	/** Sets the global font face, size and style that will be used by
+		TextROIs interactively created using the text tool. */
+	public static void setFont(String fontName, int fontSize, int fontStyle) {
+		setFont(fontName, fontSize, fontStyle, true);
+	}
+	
+	/** Sets the font face, size, style and antialiasing mode that will 
+		be used by TextROIs interactively created using the text tool. */
+	public static void setFont(String fontName, int fontSize, int fontStyle, boolean antialiased) {
+		name = fontName;
+		size = fontSize;
+		style = fontStyle;
+		globalJustification = LEFT;
+		antialiasedText = antialiased;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			Roi roi = imp.getRoi();
+			if (roi instanceof TextRoi) {
+				roi.setAntiAlias(antialiased);
+				((TextRoi)roi).setCurrentFont(new Font(name, style, size));
+				imp.draw();
+			}
+		}
+			
+	}
+
+	/** Sets the default font. */
+	public static void setDefaultFont(Font font) {
+		defaultFont = font;
+	}
+	
+	/** Sets the default font size. */
+	public static void setDefaultFontSize(int size) {
+		defaultFont = defaultFont.deriveFont((float)size);
+	}
+
+	/** Sets the default fill (background) color. */
+	public static void setDefaultFillColor(Color fillColor) {
+		defaultFillColor = fillColor;
+	}
+
+	/** Sets the default angle. */
+	public static void setDefaultAngle(double angle) {
+		defaultAngle = angle;
+	}
+
+	protected void handleMouseUp(int screenX, int screenY) {
+		super.handleMouseUp(screenX, screenY);
+		if (this.width<5 && this.height<5 && imp!=null && previousRoi==null) {
+			int ox = ic!=null?ic.offScreenX(screenX):screenX;
+			int oy = ic!=null?ic.offScreenY(screenY):screenY;
+			TextRoi roi = new TextRoi(ox, oy, line1a);
+			roi.setStrokeColor(Toolbar.getForegroundColor());
+			roi.firstChar = true;
+			imp.setRoi(roi);
+			return;
+		} else if (firstMouseUp) {
+			updateBounds();
+			updateText();
+			firstMouseUp = false;
+		}
+		if (this.width<5 || this.height<5)
+			imp.deleteRoi();
+	}
+	
+	/** Increases the size of bounding rectangle so it's large enough to hold the text. */ 
+	private void updateBounds() {
+		if (firstChar )
+			return;
+		double lineHeight = 0;
+		double mag = getMagnification();
+		Font font = getScaledFont();
+		Graphics g = getFontGraphics(font);
+		Java2.setAntialiasedText(g, getAntiAlias());
+		FontMetrics metrics = g.getFontMetrics(font);
+		double fontHeight = metrics.getHeight()/mag;
+		int i=0, nLines=0;
+		Rectangle2D.Double b = getFloatBounds();
+		double newWidth = 10;
+		while (i<MAX_LINES && theText[i]!=null) {
+			nLines++;
+			double w = stringWidth(theText[i],metrics,g)/mag;
+			if (w>newWidth)
+				newWidth = w;
+			i++;
+		}
+		newWidth += 2.0;
+		b.width = newWidth;
+		switch (justification) {
+			case LEFT:
+				break;
+			case CENTER:
+				b.x = this.oldX+this.oldWidth - newWidth/2.0;
+				break;
+			case RIGHT:
+				b.x = this.oldX+this.oldWidth - newWidth;
+				break;
+		}
+		b.height = nLines*fontHeight+2;
+		setBounds(b);
+	}
+	
+	private Graphics getFontGraphics(Font font) {
+		if (fontGraphics==null) {
+			BufferedImage bi =new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
+			fontGraphics = (Graphics2D)bi.getGraphics();
+		}
+		fontGraphics.setFont(font);
+		return  fontGraphics;
+	}
+	
+	void updateText() {
+		if (imp!=null) {
+			updateClipRect();
+			if (angle!=0.0)
+				imp.draw();
+			else
+				imp.draw(clipX, clipY, clipWidth, clipHeight);
+		}
+	}
+
+	double stringWidth(String s, FontMetrics metrics, Graphics g) {
+		java.awt.geom.Rectangle2D r = metrics.getStringBounds(s, g);
+		return r.getWidth();
+	}
+	
+	/** Used by the Recorder for recording the text tool. */
+	public String getMacroCode(String cmd, ImagePlus imp) {
+		String code = "";
+		boolean script = Recorder.scriptMode();
+		boolean addSelection = cmd.startsWith("Add");
+		if (script && !addSelection)
+			code += "ip = imp.getProcessor();\n";
+		if (script) {
+			String str = "Font.PLAIN";
+			if (style==Font.BOLD)
+				str =  "Font.BOLD";
+			else if (style==Font.ITALIC)
+				str =  "Font.ITALIC";
+			code += "font = new Font(\""+name+"\", "+str+", "+size+");\n";
+			if (addSelection)
+				return getAddSelectionScript(code);
+			code += "ip.setFont(font);\n";
+		} else {
+			String options = "";
+			if (style==Font.BOLD)
+				options += "bold";
+			if (style==Font.ITALIC)
+				options += " italic";
+			if (antialiasedText)
+				options += " antialiased";
+			if (options.equals(""))
+				options = "plain";
+			code += "setFont(\""+name+"\", "+size+", \""+options+"\");\n";
+		}
+		ImageProcessor ip = imp.getProcessor();
+		ip.setFont(new Font(name, style, size));
+		FontMetrics metrics = ip.getFontMetrics();
+		int fontHeight = metrics.getHeight();
+		if (script)
+			code += "ip.setColor(new Color("+getColorArgs(getStrokeColor())+"));\n";
+		else
+			code += "setColor(\""+Colors.colorToString(getStrokeColor())+"\");\n";
+		if (addSelection) {
+			code += "Overlay.drawString(\""+text()+"\", "+this.x+", "+(this.y+fontHeight)+", "+getAngle()+");\n";
+			code += "Overlay.show();\n";
+		} else {
+			code += (script?"ip.":"")+"drawString(\""+text()+"\", "+this.x+", "+(this.y+fontHeight)+");\n";
+			if (script)
+				code += "imp.updateAndDraw();\n";
+			else
+				code += "//makeText(\""+text()+"\", "+this.x+", "+(this.y+fontHeight)+");\n";
+		}
+		return (code);
+	}
+	
+	private String text() {
+		String text = "";
+		for (int i=0; i<MAX_LINES; i++) {
+			if (theText[i]==null) break;
+			text += theText[i];
+			if (theText[i+1]!=null) text += "\\n";
+		}
+		return text;
+	}
+	
+	private String getAddSelectionScript(String code) {
+		code += "roi = new TextRoi("+this.x+", "+this.y+", \""+text()+"\", font);\n";
+		code += "roi.setStrokeColor(new Color("+getColorArgs(getStrokeColor())+"));\n";
+		if (getFillColor()!=null)
+			code += "roi.setFillColor(new Color("+getColorArgs(getFillColor())+"));\n";
+		int just = getJustification();
+		if (just>LEFT) {
+			if (just==CENTER)
+				code += "roi.setJustification(TextRoi.CENTER);\n";
+			else if (just==RIGHT)
+				code += "roi.setJustification(TextRoi.RIGHT);\n";
+		}
+		if (getAngle()!=0.0)
+			code += "roi.setAngle("+getAngle()+");\n";
+		code += "overlay.add(roi);\n";
+		return code;
+	}
+	
+	private String getColorArgs(Color c) {
+		return IJ.d2s(c.getRed()/255.0,2)+", "+IJ.d2s(c.getGreen()/255.0,2)+", "+IJ.d2s(c.getBlue()/255.0,2);
+	}
+	
+	public String getText() {
+		String text = "";
+		for (int i=0; i<MAX_LINES; i++) {
+			if (theText[i]==null) break;
+			text += theText[i]+"\n";
+		}
+		return text;
+	}
+
+	public void setText(String text) {
+		String[] lines = Tools.split(text, "\n");
+		boolean changes = false;
+		for (int i=0; i<Math.min(lines.length, theText.length-1); i++) {
+			if (!lines[i].equals(theText[i])) {
+				theText[i] = lines[i];
+				changes = true;
+			}
+		}
+		if (lines.length < theText.length && theText[lines.length] != null) {
+			theText[lines.length] = null;
+			changes = true;
+		}
+		if (changes) {
+			firstChar = false;
+			updateBounds();
+		}
+	}
+
+	public boolean isDrawingTool() {
+		return true;
+	}
+	
+	public void clear(ImageProcessor ip) {
+		if (font==null)
+			ip.fill();
+		else {
+			ip.setFont(font);
+			ip.setAntialiasedText(antialiasedText);
+			int i=0, w=0;
+			while (i<MAX_LINES && theText[i]!=null) {
+				int w2 = ip.getStringWidth(theText[i]);
+				if (w2>w);
+					w = w2;
+				i++;
+			}
+			Rectangle r = ip.getRoi();
+			if (w>r.width) {
+				r.width = w;
+				ip.setRoi(r);
+			}
+			ip.fill();
+		}
+	}
+
+	@Override
+	public void setLocation(int x, int y) {
+		super.setLocation(x, y);
+		oldWidth = this.width;
+	}
+
+	/** Returns a copy of this TextRoi. */
+	public synchronized Object clone() {
+		TextRoi tr = (TextRoi)super.clone();
+		tr.theText = new String[MAX_LINES];
+		for (int i=0; i<MAX_LINES; i++)
+			tr.theText[i] = theText[i];
+		return tr;
+	}
+	
+	public double getAngle() {
+		return angle;
+	}
+	
+	public void setAngle(double angle) {
+		this.angle = angle;
+		if (angle!=0.0)
+			setAntiAlias(true);
+	}
+
+	public boolean getDrawStringMode() {
+		return false;
+	}
+	
+	public void setDrawStringMode(boolean drawStringMode) {
+	}
+	
+	public void setPreviousTextRoi(Roi previousRoi) {
+		this.previousRoi = previousRoi;
+	}
+	
+	/** @deprecated Replaced by getDefaultFontName */
+	public static String getFont() {
+		return name;
+	}
+
+	/** @deprecated Replaced by getDefaultFontSize */
+	public static int getSize() {
+		return size;
+	}
+
+	/** @deprecated Replaced by getDefaultFontStyle */
+	public static int getStyle() {
+		return style;
+	}
+	
+	/** @deprecated Replaced by setFont(font) */
+	public void setCurrentFont(Font font) {
+		this.font = font;
+		updateBounds();
+	}
+
+        
+}
diff --git a/src/ij/gui/Toolbar.java b/src/ij/gui/Toolbar.java
new file mode 100644
index 0000000..3fed309
--- /dev/null
+++ b/src/ij/gui/Toolbar.java
@@ -0,0 +1,2134 @@
+package ij.gui;
+import java.awt.*;
+import java.awt.event.KeyEvent;
+import java.awt.event.*;
+import java.awt.image.BufferedImage;
+import javax.imageio.ImageIO;
+import java.io.File;
+import java.util.Timer;
+import java.util.Hashtable;
+import java.util.TimerTask;
+import java.util.Arrays;
+import java.util.Locale;
+import ij.*;
+import ij.plugin.frame.*;
+import ij.plugin.MacroInstaller;
+import ij.plugin.RectToolOptions;
+import ij.plugin.tool.PlugInTool;
+import ij.plugin.tool.MacroToolRunner;
+import ij.macro.Program;
+
+/** The ImageJ toolbar. */
+public class Toolbar extends Canvas implements MouseListener, MouseMotionListener, ItemListener, ActionListener {
+
+	public static final int RECTANGLE = 0;
+	public static final int OVAL = 1;
+	public static final int POLYGON = 2;
+	public static final int FREEROI = 3;
+	public static final int LINE = 4;
+	public static final int POLYLINE = 5;
+	public static final int FREELINE = 6;
+	public static final int POINT = 7, CROSSHAIR = 7;
+	public static final int WAND = 8;
+	public static final int TEXT = 9;
+	public static final int UNUSED = 10;
+	public static final int MAGNIFIER = 11;
+	public static final int HAND = 12;
+	public static final int DROPPER = 13;
+	public static final int ANGLE = 14;
+	public static final int CUSTOM1 = 15;
+	public static final int CUSTOM2 = 16;
+	public static final int CUSTOM3 = 17;
+	public static final int CUSTOM4 = 18;
+	public static final int CUSTOM5 = 19;
+	public static final int CUSTOM6 = 20;
+	public static final int CUSTOM7 = 21;
+	
+	public static final int DOUBLE_CLICK_THRESHOLD = 650; //ms
+
+	public static final int RECT_ROI=0, ROUNDED_RECT_ROI=1, ROTATED_RECT_ROI=2;
+	public static final int OVAL_ROI=0, ELLIPSE_ROI=1, BRUSH_ROI=2;
+	
+	public static final String[] builtInTools = {"Arrow","Brush","Command Finder", "Developer Menu","Flood Filler",
+		"Label Maker","LUT Menu","Overlay Brush","Pencil","Pixel Inspector","Selection Rotator",
+		"Spray Can","Stacks Menu","ROI Menu"};
+	private static final String[] builtInTools2 = {"Pixel Inspection Tool","Paintbrush Tool","Flood Fill Tool"};
+
+	private static final int NUM_TOOLS = 23;
+	private static final int MAX_EXTRA_TOOLS = 8;
+	private static final int MAX_TOOLS = NUM_TOOLS+MAX_EXTRA_TOOLS;
+	private static final int NUM_BUTTONS = 21;
+	private static final int BUTTON_WIDTH = 30;
+	private static final int BUTTON_HEIGHT = 31;
+	private static final int SIZE = 28;  // no longer used
+	private static final int GAP_SIZE = 9;
+	private static final int OFFSET = 7;
+	private static final String BRUSH_SIZE = "toolbar.brush.size";
+	public static final String CORNER_DIAMETER = "toolbar.arc.size";
+	public static String TOOL_KEY = "toolbar.tool";
+		
+	private Dimension ps;
+	private boolean[] down;
+	private static int current;
+	private int previousTool;
+	private int x,y;
+	private int xOffset, yOffset;
+	private long mouseDownTime;
+	private Graphics g;
+	private static Toolbar instance;
+	private int mpPrevious = RECTANGLE;
+	private String[] names = new String[MAX_TOOLS];
+	private String[] icons = new String[MAX_TOOLS];
+	private PlugInTool[] tools = new PlugInTool[MAX_TOOLS];
+	private PopupMenu[] menus = new PopupMenu[MAX_TOOLS];
+	private int nExtraTools;
+	private MacroInstaller macroInstaller;
+	private boolean addingSingleTool;
+	private boolean installingStartupTool;
+	private boolean doNotSavePrefs;
+	private int pc;
+	private String icon;
+	private int startupTime;
+	private PopupMenu rectPopup, ovalPopup, pointPopup, linePopup, zoomPopup, pickerPopup, switchPopup;
+	private CheckboxMenuItem rectItem, roundRectItem, rotatedRectItem;
+	private CheckboxMenuItem ovalItem, ellipseItem, brushItem;
+	private CheckboxMenuItem pointItem, multiPointItem;
+	private CheckboxMenuItem straightLineItem, polyLineItem, freeLineItem, arrowItem;
+	private String currentSet = "Startup Macros";
+	private Timer pressTimer;
+	private static int longClickDelay = 600; //ms
+	private boolean disableRecording;
+
+	private static Color foregroundColor = Prefs.getColor(Prefs.FCOLOR,Color.white);
+	private static Color backgroundColor = Prefs.getColor(Prefs.BCOLOR,Color.black);
+	private static double foregroundValue = Double.NaN;
+	private static double backgroundValue = Double.NaN;
+	private static int ovalType = OVAL_ROI;
+	private static int rectType = RECT_ROI;
+	private static boolean multiPointMode = Prefs.multiPointMode;
+	private static boolean arrowMode;
+	private static int brushSize = (int)Prefs.get(BRUSH_SIZE, 15);
+	private static int arcSize = (int)Prefs.get(CORNER_DIAMETER, 20);
+	private int lineType = LINE;
+	private static boolean legacyMode;
+	private static double dscale = 1.0;
+	private static int scale = 1;
+	private static int buttonWidth;
+	private static int buttonHeight;
+	private static int gapSize;
+	private static int offset;
+	
+	private Color gray = new Color(228,228,228);
+	private Color brighter = gray.brighter();
+	private Color darker = new Color(180, 180, 180);
+	private Color evenDarker = new Color(110, 110, 110);
+	private Color triangleColor = new Color(150, 0, 0);
+	private Color toolColor = new Color(0, 25, 45);
+	
+	/** Obsolete public constants */
+	public static final int SPARE1=UNUSED, SPARE2=CUSTOM1, SPARE3=CUSTOM2, SPARE4=CUSTOM3, 
+		SPARE5=CUSTOM4, SPARE6=CUSTOM5, SPARE7=CUSTOM6, SPARE8=CUSTOM7, SPARE9=22;
+
+
+	public Toolbar() {
+		init();
+		down = new boolean[MAX_TOOLS];
+		resetButtons();
+		down[0] = true;
+		setForeground(Color.black);
+		setBackground(ImageJ.backgroundColor);
+		addMouseListener(this);
+		addMouseMotionListener(this);
+		instance = this;
+		names[getNumTools()-1] = "\"More Tools\" menu (switch toolsets or add tools)";
+		icons[getNumTools()-1] = "C900T0d18>T6d18>"; // ">>"
+		addPopupMenus();
+	}
+	
+	public void init() {
+		dscale = Prefs.getGuiScale();
+		scale = (int)Math.round(dscale);
+		if ((dscale>=1.5&&dscale<2.0) || (dscale>=2.5&&dscale<3.0))
+			dscale = scale;
+		if (dscale>1.0) {
+			buttonWidth = (int)((BUTTON_WIDTH-2)*dscale);
+			buttonHeight = (int)((BUTTON_HEIGHT-2)*dscale);
+			offset = (int)Math.round((OFFSET-1)*dscale);
+		} else {
+			buttonWidth = BUTTON_WIDTH;
+			buttonHeight = BUTTON_HEIGHT;
+			offset = OFFSET;
+		}
+		gapSize = GAP_SIZE;
+		ps = new Dimension(buttonWidth*NUM_BUTTONS-(buttonWidth-gapSize), buttonHeight);
+	}
+
+	void addPopupMenus() {
+		rectPopup = new PopupMenu();
+		if (Menus.getFontSize()!=0)
+			rectPopup.setFont(Menus.getFont());
+		rectItem = new CheckboxMenuItem("Rectangle", rectType==RECT_ROI);
+		rectItem.addItemListener(this);
+		rectPopup.add(rectItem);
+		roundRectItem = new CheckboxMenuItem("Rounded Rectangle", rectType==ROUNDED_RECT_ROI);
+		roundRectItem.addItemListener(this);
+		rectPopup.add(roundRectItem);
+		rotatedRectItem = new CheckboxMenuItem("Rotated Rectangle", rectType==ROTATED_RECT_ROI);
+		rotatedRectItem.addItemListener(this);
+		rectPopup.add(rotatedRectItem);
+		add(rectPopup);
+
+		ovalPopup = new PopupMenu();
+		if (Menus.getFontSize()!=0)
+			ovalPopup.setFont(Menus.getFont());
+		ovalItem = new CheckboxMenuItem("Oval selections", ovalType==OVAL_ROI);
+		ovalItem.addItemListener(this);
+		ovalPopup.add(ovalItem);
+		ellipseItem = new CheckboxMenuItem("Elliptical selections", ovalType==ELLIPSE_ROI);
+		ellipseItem.addItemListener(this);
+		ovalPopup.add(ellipseItem);
+		brushItem = new CheckboxMenuItem("Selection Brush Tool", ovalType==BRUSH_ROI);
+		brushItem.addItemListener(this);
+		ovalPopup.add(brushItem);
+		add(ovalPopup);
+
+		pointPopup = new PopupMenu();
+		if (Menus.getFontSize()!=0)
+			pointPopup.setFont(Menus.getFont());
+		pointItem = new CheckboxMenuItem("Point Tool", !multiPointMode);
+		pointItem.addItemListener(this);
+		pointPopup.add(pointItem);
+		multiPointItem = new CheckboxMenuItem("Multi-point Tool", multiPointMode);
+		multiPointItem.addItemListener(this);
+		pointPopup.add(multiPointItem);
+		add(pointPopup);
+
+		linePopup = new PopupMenu();
+		if (Menus.getFontSize()!=0)
+			linePopup.setFont(Menus.getFont());
+		straightLineItem = new CheckboxMenuItem("Straight Line", lineType==LINE&&!arrowMode);
+		straightLineItem.addItemListener(this);
+		linePopup.add(straightLineItem);
+		polyLineItem = new CheckboxMenuItem("Segmented Line", lineType==POLYLINE);
+		polyLineItem.addItemListener(this);
+		linePopup.add(polyLineItem);
+		freeLineItem = new CheckboxMenuItem("Freehand Line", lineType==FREELINE);
+		freeLineItem.addItemListener(this);
+		linePopup.add(freeLineItem);
+		arrowItem = new CheckboxMenuItem("Arrow tool", lineType==LINE&&!arrowMode);
+		arrowItem.addItemListener(this);
+		linePopup.add(arrowItem);
+		add(linePopup);
+
+		zoomPopup = new PopupMenu();
+		if (Menus.getFontSize()!=0)
+			zoomPopup.setFont(Menus.getFont());
+		addMenuItem(zoomPopup, "Reset Zoom");
+		addMenuItem(zoomPopup, "Zoom In");
+		addMenuItem(zoomPopup, "Zoom Out");
+		addMenuItem(zoomPopup, "View 100%");
+		addMenuItem(zoomPopup, "Zoom To Selection");
+		addMenuItem(zoomPopup, "Scale to Fit");
+		addMenuItem(zoomPopup, "Set...");
+		addMenuItem(zoomPopup, "Maximize");
+		add(zoomPopup);
+
+		pickerPopup = new PopupMenu();
+		if (Menus.getFontSize()!=0)
+			pickerPopup.setFont(Menus.getFont());
+		addMenuItem(pickerPopup, "White/Black");
+		addMenuItem(pickerPopup, "Black/White");
+		addMenuItem(pickerPopup, "Red");
+		addMenuItem(pickerPopup, "Green");
+		addMenuItem(pickerPopup, "Blue");
+		addMenuItem(pickerPopup, "Yellow");
+		addMenuItem(pickerPopup, "Cyan");
+		addMenuItem(pickerPopup, "Magenta");
+		pickerPopup.addSeparator();
+		addMenuItem(pickerPopup, "Foreground...");
+		addMenuItem(pickerPopup, "Background...");
+		addMenuItem(pickerPopup, "Colors...");
+		addMenuItem(pickerPopup, "Color Picker...");
+		add(pickerPopup);
+		
+		switchPopup = new PopupMenu();
+		if (Menus.getFontSize()!=0)
+			switchPopup.setFont(Menus.getFont());
+		add(switchPopup);
+	}
+	
+	private void addMenuItem(PopupMenu menu, String command) {
+		MenuItem item = new MenuItem(command);
+		item.addActionListener(this);
+		menu.add(item);
+	}
+	
+	/** Returns the ID of the current tool (Toolbar.RECTANGLE, Toolbar.OVAL, etc.). */
+	public static int getToolId() {
+		int id = current;
+		if (legacyMode) {
+			if (id==CUSTOM1)
+				id=UNUSED;
+			else if (id>=CUSTOM2)
+				id--;
+		}
+		return id;
+	}
+
+	/** Returns the ID of the tool whose name (the description displayed in the status bar)
+		starts with the specified string, or -1 if the tool is not found. */
+	public int getToolId(String name) {
+		int tool =  -1;
+		for (int i=0; i<getNumTools(); i++) {
+			if (names[i]!=null && names[i].startsWith(name)) {
+				tool = i;
+				break;
+			}			
+		}
+		return tool;
+	}
+
+	/** Returns a reference to the ImageJ toolbar. */
+	public static Toolbar getInstance() {
+		return instance;
+	}
+
+	private void drawButtons(Graphics g) {
+		if (g==null)
+			return;
+		Graphics2D g2d = (Graphics2D)g;
+		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+		setStrokeWidth(g2d);
+		for (int i=0; i<LINE; i++)
+			drawButton(g, i);
+		drawButton(g, lineType);
+		for (int i=POINT; i<getNumTools(); i++)
+			drawButton(g, i);
+	}
+
+	private void setStrokeWidth(Graphics2D g2d) {
+		if (scale==1) {
+			if (dscale>1.0)
+				g2d.setStroke(new BasicStroke(IJ.isMacOSX()?1.4f:1.25f));
+		} else
+			g2d.setStroke(new BasicStroke(scale));
+	}
+
+	private void fill3DRect(Graphics g, int x, int y, int width, int height, boolean raised) {
+		if (null==g) return;
+		if (raised)
+			g.setColor(gray);
+		else
+			g.setColor(darker);
+		g.fillRect(x+1, y+1, width-2, height-2);
+		g.setColor(raised ? brighter : evenDarker);
+		g.drawLine(x, y, x, y + height - 1);
+		g.drawLine(x + 1, y, x + width - 2, y);
+		g.setColor(raised ? evenDarker : brighter);
+		g.drawLine(x + 1, y + height - 1, x + width - 1, y + height - 1);
+		g.drawLine(x + width - 1, y, x + width - 1, y + height - 2);
+	}    
+
+	private void drawButton(Graphics g, int tool) {
+		if (g==null) return;
+		if (legacyMode) {
+			if (tool==UNUSED)
+				tool = CUSTOM1;
+			else if (tool>=CUSTOM1)
+				tool++;
+			if ((tool==POLYLINE && lineType!=POLYLINE) || (tool==FREELINE && lineType!=FREELINE))
+				return;
+		}
+        int index = toolIndex(tool);
+        int x = index*buttonWidth + 1*scale;
+        if (tool>=CUSTOM1)
+        	x -= buttonWidth-gapSize;
+        if (tool!=UNUSED)
+        	fill3DRect(g, x, 1, buttonWidth, buttonHeight-1, !down[tool]);
+        g.setColor(toolColor);
+        x = index*buttonWidth + offset;
+        if (tool>=CUSTOM1)
+        	x -= buttonWidth-gapSize;
+		int y = offset;
+		if (dscale==1.3) {x++; y++;}
+		if (dscale==1.4) {x+=2; y+=2;}
+		if (down[tool]) { x++; y++;}
+		this.g = g;
+		if (tool>=CUSTOM1 && tool<=getNumTools() && icons[tool]!=null) {
+			drawIcon(g, tool, x+1*scale, y+1*scale);
+			return;
+		}
+		switch (tool) {
+			case RECTANGLE:
+				xOffset = x; yOffset = y;
+				if (rectType==ROUNDED_RECT_ROI)
+					g.drawRoundRect(x-1*scale, y+1*scale, 17*scale, 13*scale, 8*scale, 8*scale);
+				else if (rectType==ROTATED_RECT_ROI)
+					polyline(0,10,7,0,15,6,8,16,0,10); 
+				else
+					g.drawRect(x-1*scale, y+1*scale, 17*scale, 13*scale);
+				drawTriangle(16,16);
+				return;
+			case OVAL:
+				xOffset = x; yOffset = y;
+				if (ovalType==BRUSH_ROI) {
+					yOffset = y - 1;
+					polyline(6,4,8,2,12,1,15,2,16,4,15,7,12,8,9,11,9,14,6,16,2,16,0,13,1,10,4,9,6,7,6,4);
+				} else if (ovalType==ELLIPSE_ROI) {
+					xOffset = x - 1;
+					yOffset = y + 1;
+					polyline(11,0,13,0,14,1,15,1,16,2,17,3,17,7,12,12,11,12,10,13,8,13,7,14,4,14,3,13,2,13,1,12,1,11,0,10,0,9,1,8,1,7,6,2,7,2,8,1,10,1,11,0);
+				} else
+					g.drawOval(x, y+1*scale, 17*scale, 13*scale);
+				drawTriangle(16,16);
+				return;
+			case POLYGON:
+				xOffset = x+1; yOffset = y+2;
+				polyline(4,0,15,0,15,1,11,5,11,6,14,11,14,12,0,12,0,4,4,0);
+				return;
+			case FREEROI:
+				xOffset = x; yOffset = y+3;
+				polyline(2,0,5,0,7,3,10,3,12,0,15,0,17,2,17,5,16,8,13,10,11,11,6,11,4,10,1,8,0,6,0,2,2,0); 
+				return;
+			case LINE:
+				if (arrowMode) {
+					xOffset = x; yOffset = y;
+					m(1,14); d(14,1); m(6,5); d(14,1); m(10,9); d(14,1); m(6,5); d(10,9);
+				} else {
+					xOffset = x-1; yOffset = y-1;
+					m(1,17); d(18,0);
+					drawDot(0,16); drawDot(17,0);
+				}
+				drawTriangle(16,16);
+				return;
+			case POLYLINE:
+				xOffset = x; yOffset = y;
+				polyline(15,6,11,2,1,2,1,3,7,9,2,14);
+				drawTriangle(14,16);
+				return;
+			case FREELINE:
+				xOffset = x; yOffset = y;
+				polyline(16,4,14,6,12,6,9,3,8,3,6,7,2,11,1,11);
+				drawTriangle(14,16);
+				return;
+			case POINT:
+				xOffset = x; yOffset = y;
+				if (multiPointMode) {
+					drawPoint(1,3); drawPoint(9,0); drawPoint(15,5);
+					drawPoint(10,11); drawPoint(2,13);
+				} else {
+					m(1,8); d(6,8); d(6,6); d(10,6); d(10,10); d(6,10); d(6,9);
+					m(8,1); d(8,5); m(11,8); d(15,8); m(8,11); d(8,15);
+					m(8,8); d(8,8);
+					g.setColor(Roi.getColor());
+					m(7,7); d(9,7);
+					m(7,8); d(9,8);
+					m(7,9); d(9,9);
+				}
+				drawTriangle(16,16);
+				return;
+			case WAND:
+				xOffset = x+2; yOffset = y+1;
+				dot(4,0);  m(2,0); d(3,1); d(4,2);  m(0,0); d(1,1);
+				m(0,2); d(1,3); d(2,4);  dot(0,4); m(3,3); d(15,15);
+				g.setColor(Roi.getColor());
+				m(1,2); d(3,2); m(2,1); d(2,3);
+				return;
+			case TEXT:
+				xOffset = x; yOffset = y;
+				m(1,16); d(9,0); d(16,16);
+				m(0,16); d(2,16);
+				m(15,16); d(17,16);
+				m(4,10); d(13,10);
+				return; 
+			case MAGNIFIER:
+				xOffset = x; yOffset = y;
+				g.drawOval(x+3, y, 13*scale, 13*scale);
+				m(5,12); d(-1,18);
+				drawTriangle(15,17);
+				return;
+			case HAND:
+				xOffset = x; yOffset = y;
+				polyline(5,17,5,16,0,11,0,8,1,8,5,11,5,2,8,2,8,8,8,0,11,0,11,8,11,1,14,1,14,9,14,3,17,3,17,12,16,13,16,17);
+				return;
+			case DROPPER:
+				// draw foreground/background rectangles	
+				g.setColor(backgroundColor);
+				g.fillRect(x+2*scale, y+3*scale, 15*scale, 16*scale);
+				g.drawRect(x, y+2*scale, 13*scale, 13*scale);
+				g.setColor(foregroundColor);
+				g.fillRect(x, y+2*scale, 13*scale, 13*scale);
+				// draw dropper icon		
+				xOffset = x+3; yOffset = y-4;
+				g.setColor(toolColor);
+				m(12,2); d(14,2);
+				m(11,3); d(15,3);
+				m(11,4); d(15,4);
+				m(8,5); d(15,5);
+				m(9,6); d(14,6);
+				polyline(10,7,12,7,12,9);
+				polyline(9,6,2,13,2,15,4,15,11,8);
+				g.setColor(gray);
+				polygon(9,6,2,13,2,15,4,15,11,8);
+				drawTriangle(12,21);
+				return;
+			case ANGLE:
+				xOffset = x; yOffset = y+3;
+				m(0,11); d(13,-1); m(0,11); d(16,11); 
+				m(10,11); d(10,8); m(9,7); d(9,6); dot(8,5);
+				drawDot(13,-2); drawDot(16,10);
+				return;
+		}
+	}
+	
+	void drawTriangle(int x, int y) {
+		g.setColor(triangleColor);
+		xOffset+=x*scale; yOffset+=y*scale;
+		m(0,0); d(4,0); m(1,1); d(3,1); m(2,2); d(2,2);
+	}
+	
+	void drawDot(int x, int y) {
+		g.fillRect(xOffset+x*scale, yOffset+y*scale, 2*scale, 2*scale);
+	}
+
+	void drawPoint(int x, int y) {
+		g.setColor(toolColor);
+		m(x-3,y); d(x+3,y);
+		m(x,y-3); d(x,y+3);
+		g.setColor(Roi.getColor());
+		dot(x,y); dot(x-1,y-1);
+	}
+	
+	void drawIcon(Graphics g, int tool, int x, int y) {
+		if (null==g) return;
+		icon = icons[tool];
+		if (icon==null) return;
+		this.icon = icon;
+		int x1, y1, x2, y2;
+		pc = 0;
+		if (icon.trim().startsWith("icon:")) {
+			String path = IJ.getDir("macros")+"toolsets/icons/"+icon.substring(icon.indexOf(":")+1);
+			try {
+				BufferedImage bi = ImageIO.read(new File(path));
+				if (scale==1)
+					g.drawImage(bi,x-5,y-5,null);
+				else {
+					int size = Math.max(bi.getWidth(),bi.getHeight());
+					g.drawImage(bi,x-5*scale,y-5*scale, size*scale,size*scale,null);
+				}
+			} catch (Exception e) {
+				IJ.error("Toolbar", "Error reading tool icon:\n"+path);
+			}
+		} else {
+			while (true) {
+				char command = icon.charAt(pc++);
+				if (pc>=icon.length()) break;
+				switch (command) {
+					case 'B': x+=v(); y+=v(); break;  // adjust base
+					case 'N': x-=v(); y-=v(); break;  // adjust base negatively
+					case 'R': g.drawRect(x+v(), y+v(), v(), v()); break;  // rectangle
+					case 'F': g.fillRect(x+v(), y+v(), v(), v()); break;  // filled rectangle
+					case 'O': g.drawOval(x+v(), y+v(), v(), v()); break;  // oval
+					case 'V': case 'o': g.fillOval(x+v(), y+v(), v(), v()); break;  // filled oval
+					case 'C': // set color
+						int saveScale = scale;
+						scale = 1;
+						int v1=v(), v2=v(), v3=v();
+						int red=v1*16, green=v2*16, blue=v3*16;
+						if (red>255) red=255; if (green>255) green=255; if (blue>255) blue=255;
+						Color color = v1==1&&v2==2&&v3==3?foregroundColor:new Color(red,green,blue);
+						g.setColor(color);
+						scale = saveScale;
+						break; 
+					case 'L': g.drawLine(x+v(), y+v(), x+v(), y+v()); break; // line
+					case 'D':  g.fillRect(x+v(), y+v(), scale, scale); break; // dot
+					case 'P': // polyline
+						Polygon p = new Polygon();
+						p.addPoint(x+v(), y+v());
+						while (true) {
+							x2=v(); if (x2==0) break;
+							y2=v(); if (y2==0) break;
+							p.addPoint(x+x2, y+y2);
+						}
+						g.drawPolyline(p.xpoints, p.ypoints, p.npoints);
+						break;
+					case 'G': case 'H':// polygon or filled polygon
+						p = new Polygon();
+						p.addPoint(x+v(), y+v());
+						while (true) {
+							x2=v(); y2=v();
+							if (x2==0 && y2==0 && p.npoints>2)
+								break;
+							p.addPoint(x+x2, y+y2);
+						}
+						if (command=='G')
+							g.drawPolygon(p.xpoints, p.ypoints, p.npoints);
+						else
+							g.fillPolygon(p.xpoints, p.ypoints, p.npoints);
+						break;
+					case 'T': // text (one character)
+						x2 = x+v()-2;
+						y2 = y+v();
+						int size = v()*10+v()+1;
+						char[] c = new char[1];
+						c[0] = pc<icon.length()?icon.charAt(pc++):'e';
+						g.setFont(new Font("SansSerif", Font.PLAIN, size));
+						g.drawString(new String(c), x2, y2);
+						break;
+					default: break;
+				}
+				if (pc>=icon.length()) break;
+			}
+		}
+		if (menus[tool]!=null && menus[tool].getItemCount()>0) { 
+			xOffset = x; yOffset = y;
+			drawTriangle(15, 16);
+		}
+	}
+	
+	int v() {
+		if (pc>=icon.length()) return 0;
+		char c = icon.charAt(pc++);
+		switch (c) {
+			case '0': return 0*scale;
+			case '1': return 1*scale;
+			case '2': return 2*scale;
+			case '3': return 3*scale;
+			case '4': return 4*scale;
+			case '5': return 5*scale;
+			case '6': return 6*scale;
+			case '7': return 7*scale;
+			case '8': return 8*scale;
+			case '9': return 9*scale;
+			case 'a': return 10*scale;
+			case 'b': return 11*scale;
+			case 'c': return 12*scale;
+			case 'd': return 13*scale;
+			case 'e': return 14*scale;
+			case 'f': return 15*scale;
+			case 'g': return 16*scale;
+			case 'h': return 17*scale;
+			case 'i': return 18*scale;
+			case 'j': return 19*scale;
+			case 'k': return 20*scale;
+			case 'l': return 21*scale;
+			case 'm': return 22*scale;
+			case 'n': return 23*scale;
+			default: return 0;
+		}
+	}
+	
+	private void showMessage(int tool) {
+		if (IJ.statusBarProtected())
+			return;
+		if (tool>=UNUSED && tool<getNumTools() && names[tool]!=null) {
+			String name = names[tool];
+			int index = name.indexOf("Action Tool");
+			if (index!=-1)
+				name = name.replace("Action Tool", "Tool");
+			else {
+				index = name.indexOf("Menu Tool");
+				if (index!=-1)
+					name = name.substring(0, index+4);
+			}
+			IJ.showStatus(name);
+			return;
+		}
+		String hint = " (alt or long click to switch)";
+		String hint2 = " (alt or long click to switch; double click to configure)";
+		switch (tool) {
+			case RECTANGLE:
+				if (rectType==ROUNDED_RECT_ROI)
+					IJ.showStatus("Rectangle, *rounded rect* or rotated rect"+hint);
+				else if (rectType==ROTATED_RECT_ROI)
+					IJ.showStatus("Rectangle, rounded rect or *rotated rect*"+hint);
+				else
+					IJ.showStatus("*Rectangle*, rounded rect or rotated rect"+hint);
+				return;
+			case OVAL:
+				if (ovalType==BRUSH_ROI)
+					IJ.showStatus("Oval, elliptical or *brush* selections"+hint);
+				else if (ovalType==ELLIPSE_ROI)
+					IJ.showStatus("Oval, *elliptical* or brush selections"+hint);
+				else
+					IJ.showStatus("*Oval*, elliptical or brush selections"+hint);
+				return;
+			case POLYGON:
+				IJ.showStatus("Polygon selections");
+				return;
+			case FREEROI:
+				IJ.showStatus("Freehand selections");
+				return;
+			case LINE:
+				if (arrowMode)
+					IJ.showStatus("Straight, segmented or freehand lines, or *arrows*"+hint);
+				else
+					IJ.showStatus("*Straight*, segmented or freehand lines, or arrows"+hint);
+				return;
+			case POLYLINE:
+				IJ.showStatus("Straight, *segmented* or freehand lines, or arrows"+hint);
+				return;
+			case FREELINE:
+				IJ.showStatus("Straight, segmented or *freehand* lines, or arrows"+hint);
+				return;
+			case POINT:
+				if (multiPointMode)
+					IJ.showStatus("*Multi-point* or point"+hint2);
+				else
+					IJ.showStatus("*Point* or multi-point"+hint2);
+				return;
+			case WAND:
+				IJ.showStatus("Wand (tracing) tool");
+				return;
+			case TEXT:
+				IJ.showStatus("Text tool (double-click to configure)");
+				return;
+			case MAGNIFIER:
+				IJ.showStatus("Magnifying glass (or \"+\" and \"-\" keys; alt or long click for menu)");
+				return;
+			case HAND:
+				IJ.showStatus("Scrolling tool (or press space bar and drag)");
+				return;
+			case DROPPER:
+				String fg = foregroundColor.getRed() + "," + foregroundColor.getGreen() + "," + foregroundColor.getBlue();
+				String bg = backgroundColor.getRed() + "," + backgroundColor.getGreen() + "," + backgroundColor.getBlue();
+				IJ.showStatus("Color picker " +  fg + "/"+ bg + " (alt or long click for menu)");
+				return;
+			case ANGLE:
+				IJ.showStatus("Angle tool");
+				return;
+			default:
+				IJ.showStatus("ImageJ "+IJ.getVersion()+" / Java "+System.getProperty("java.version")+(IJ.is64Bit()?" (64-bit)":" (32-bit)"));
+				return;
+		}
+	}
+
+	private void m(int x, int y) {
+		this.x = xOffset+x*scale;
+		this.y = yOffset+y*scale;
+	}
+
+	private void d(int x, int y) {
+		x *= scale;
+		y *= scale;
+		x += xOffset;
+		y += yOffset;
+		g.drawLine(this.x, this.y, x, y);
+		this.x = x;
+		this.y = y;
+	}
+	
+	private void dot(int x, int y) {
+		g.fillRect(xOffset+x*scale, yOffset+y*scale, 1*scale, 1*scale);
+	}
+	
+	private void polyline(int... values) {
+		Polygon p = new Polygon();
+		int n = values.length/2;
+		for (int i=0; i<n; i++)
+			p.addPoint(values[i*2]*scale+xOffset, values[i*2+1]*scale+yOffset);
+		g.drawPolyline(p.xpoints, p.ypoints, p.npoints);
+	}
+
+	private void polygon(int... values) {
+		Polygon p = new Polygon();
+		int n = values.length/2;
+		for (int i=0; i<n; i++)
+			p.addPoint(values[i*2]*scale+xOffset, values[i*2+1]*scale+yOffset);
+		g.fillPolygon(p.xpoints, p.ypoints, p.npoints);
+	}
+
+	private void resetButtons() {
+		for (int i=0; i<getNumTools(); i++)
+			down[i] = false;
+	}
+
+	public void paint(Graphics g) {
+		drawButtons(g);
+	}
+
+	public boolean setTool(String name) {
+		if (name==null) return false;
+		if (name.indexOf(" Tool")!=-1) { // macro tool?
+			for (int i=UNUSED; i<getNumTools(); i++) {
+				if (name.equals(names[i])) {
+					setTool(i);
+					return true;
+				}
+			}
+		}
+		name = name.toLowerCase(Locale.US);
+		boolean ok = true;
+		if (name.indexOf("round")!=-1) {
+			rectType = ROUNDED_RECT_ROI;
+			setTool(RECTANGLE);
+		} else if (name.indexOf("rot")!=-1) {
+			rectType = ROTATED_RECT_ROI;
+			setTool(RECTANGLE);
+		} else if (name.indexOf("rect")!=-1) {
+			rectType = RECT_ROI;
+			setTool(RECTANGLE);
+		} else if (name.indexOf("oval")!=-1) {
+			ovalType = OVAL_ROI;
+			setTool(OVAL);
+		} else if (name.indexOf("ellip")!=-1) {
+			ovalType = ELLIPSE_ROI;
+			setTool(OVAL);
+		} else if (name.indexOf("brush")!=-1) {
+			ovalType = BRUSH_ROI;
+			setTool(OVAL);
+		} else if (name.indexOf("polygon")!=-1)
+			setTool(POLYGON);
+		else if (name.indexOf("polyline")!=-1)
+			setTool(POLYLINE);
+		else if (name.indexOf("freeline")!=-1)
+			setTool(FREELINE);
+		else if (name.indexOf("line")!=-1) {
+			arrowMode = false;
+			setTool(LINE);
+		} else if (name.indexOf("arrow")!=-1) {
+			arrowMode = true;
+			setTool(LINE);
+		} else if (name.indexOf("free")!=-1)
+			setTool(FREEROI);
+		else if (name.indexOf("multi")!=-1) {
+			multiPointMode = true;
+			Prefs.multiPointMode = true;
+			setTool(POINT);
+		} else if (name.indexOf("point")!=-1) {
+			multiPointMode = false;
+			Prefs.multiPointMode = false;
+			setTool(POINT);
+		} else if (name.indexOf("wand")!=-1)
+			setTool(WAND);
+		else if (name.indexOf("text")!=-1)
+			setTool(TEXT);
+		else if (name.indexOf("hand")!=-1)
+			setTool(HAND);
+		else if (name.indexOf("zoom")!=-1)
+			setTool(MAGNIFIER);
+		else if (name.indexOf("dropper")!=-1||name.indexOf("color")!=-1)
+			setTool(DROPPER);
+		else if (name.indexOf("angle")!=-1)
+			setTool(ANGLE);
+		else
+			ok = false;
+		return ok;
+	}
+	
+	/** Returns the name of the current tool. */
+	public static String getToolName() {
+		String name = instance.getName(current);
+		if (current>=UNUSED && current<instance.getNumTools() && instance.names[current]!=null)
+			name = instance.names[current];
+		return name!=null?name:"";
+	}
+
+	/** Returns the name of the specified tool. */
+	String getName(int id) {
+		switch (id) {
+			case RECTANGLE:
+				switch (rectType) {
+					case RECT_ROI: return "rectangle";
+					case ROUNDED_RECT_ROI: return "roundrect";
+					case ROTATED_RECT_ROI: return "rotrect";
+				}
+			case OVAL:
+				switch (ovalType) {
+					case OVAL_ROI: return "oval";
+					case ELLIPSE_ROI: return "ellipse";
+					case BRUSH_ROI: return "brush";
+				}
+			case POLYGON: return "polygon";
+			case FREEROI: return "freehand";
+			case LINE: return arrowMode?"arrow":"line";
+			case POLYLINE: return "polyline";
+			case FREELINE: return "freeline";
+			case ANGLE: return "angle";
+			case POINT: return Prefs.multiPointMode?"multipoint":"point";
+			case WAND: return "wand";
+			case TEXT: return "text";
+			case HAND: return "hand";
+			case MAGNIFIER: return "zoom";
+			case DROPPER: return "dropper";
+			default: return null;
+		}
+		
+	}
+	
+	public void setTool(int tool) {
+		if (tool==UNUSED)  //  "Unused" (blank) tool replaced with gap in 1.48h
+			tool = CUSTOM1;
+		else if (legacyMode && tool>=CUSTOM1)
+			tool++;
+		if (IJ.debugMode) IJ.log("Toolbar.setTool: "+tool);
+		if ((tool==current&&!(tool==RECTANGLE||tool==OVAL||tool==POINT)) || tool<0 || tool>=getNumTools()-1)
+			return;
+		if (tool>=CUSTOM1&&tool<=getNumTools()-2) {
+			if (names[tool]==null)
+				names[tool] = "Spare tool"; // enable tool
+			if (names[tool].indexOf("Action Tool")!=-1)
+				return;
+		}
+		if (isLine(tool)) lineType = tool;
+		setTool2(tool);
+	}
+		
+	private void setTool2(int tool) {
+		if (!isValidTool(tool)) return;
+		String previousName = getToolName();
+		previousTool = current;
+		current = tool;
+		Graphics g = this.getGraphics();
+		if (g==null)
+			return;
+		down[current] = true;
+		if (current!=previousTool)
+			down[previousTool] = false;
+		Graphics2D g2d = (Graphics2D)g;
+		g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		setStrokeWidth(g2d);
+		drawButton(g, previousTool);
+		drawButton(g, current);
+		if (null==g) return;
+		g.dispose();
+		showMessage(current);
+		if (Recorder.record) {
+			String name = getName(current);
+			if (name!=null && name.equals("dropper")) disableRecording=true;
+			if (name!=null && !disableRecording) {
+				IJ.wait(100); // workaround for OSX/Java 8 bug
+				Recorder.record("setTool", name);
+			}
+			if (name!=null && !name.equals("dropper")) disableRecording=false;
+		}
+		if (legacyMode)
+			repaint();
+		if (!previousName.equals(getToolName())) {
+			IJ.notifyEventListeners(IJEventListener.TOOL_CHANGED);;
+			repaint();
+		}
+	}
+	
+	boolean isValidTool(int tool) {
+		if (tool<0 || tool>=getNumTools())
+			return false;
+		if (tool>=CUSTOM1 && tool<getNumTools() && names[tool]==null)
+			return false;
+		return true;
+	}
+
+	/**
+	* @deprecated
+	* replaced by getForegroundColor()
+	*/
+	public Color getColor() {
+		return foregroundColor;
+	}
+
+	/**
+	* @deprecated
+	* replaced by setForegroundColor()
+	*/
+	public void setColor(Color c) {
+		if (c!=null) {
+			foregroundColor = c;
+			drawButton(this.getGraphics(), DROPPER);
+		}
+	}
+	
+	public static Color getForegroundColor() {
+		return foregroundColor;
+	}
+
+	public static void setForegroundColor(Color c) {
+		if (c==null)
+			return;
+		foregroundColor = c;
+		foregroundValue = Double.NaN;
+		IJ.notifyEventListeners(IJEventListener.FOREGROUND_COLOR_CHANGED);
+		if (instance==null)
+			return;
+		repaintTool(DROPPER);
+		for (int i=CUSTOM1; i<=instance.getNumTools()-2; i++) {
+			if (instance.icons[i]!=null && instance.icons[i].contains("C123"))
+				repaintTool(i);  // some of this tool's icon is drawn in the foreground color
+		}
+		if (!IJ.isMacro()) setRoiColor(c);
+	}
+
+	public static Color getBackgroundColor() {
+		return backgroundColor;
+	}
+
+	public static void setBackgroundColor(Color c) {
+		if (c!=null) {
+			backgroundColor = c;
+			backgroundValue = Double.NaN;
+			repaintTool(DROPPER);
+			IJ.notifyEventListeners(IJEventListener.BACKGROUND_COLOR_CHANGED);
+		}
+	}
+	
+	public static double getForegroundValue() {
+		return foregroundValue;
+	}
+	
+	public static void setForegroundValue(double value) {
+		if (value>=0) {
+			int v = (int)value;
+			if (v>255) v=255;
+			setForegroundColor(new Color(v,v,v));
+		}
+		foregroundValue = value;
+	}
+
+	public static double getBackgroundValue() {
+		return backgroundValue;
+	}
+
+	public static void setBackgroundValue(double value) {
+		if (value>=0) {
+			int v = (int)value;
+			if (v>255) v=255;
+			setBackgroundColor(new Color(v,v,v));
+		}
+		backgroundValue = value;
+	}
+	
+	private static void setRoiColor(Color c) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return;
+		Roi roi = imp.getRoi();
+		if (roi!=null && (roi.isDrawingTool())) {
+			roi.setStrokeColor(c);
+			imp.draw();
+		}
+	}
+
+	/** Returns the size of the selection brush tool, or 0 if the brush tool is not enabled. */
+	public static int getBrushSize() {
+		if (ovalType==BRUSH_ROI)
+			return brushSize;
+		else
+			return 0;
+	}
+
+	/** Set the size of the selection brush tool, in pixels. */
+	public static void setBrushSize(int size) {
+		brushSize = size;
+		if (brushSize<1) brushSize = 1;
+		Prefs.set(BRUSH_SIZE, brushSize);
+	}
+		
+	/** Returns the rounded rectangle arc size, or 0 if the rounded rectangle tool is not enabled. */
+	public static int getRoundRectArcSize() {
+		if (rectType==ROUNDED_RECT_ROI)
+			return arcSize;
+		else
+			return 0;
+	}
+
+	/** Sets the rounded rectangle corner diameter (pixels). */
+	public static void setRoundRectArcSize(int size) {
+		if (size<=0)
+			rectType = RECT_ROI;
+		else {
+			arcSize = size;
+			Prefs.set(CORNER_DIAMETER, arcSize);
+		}
+		repaintTool(RECTANGLE);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Roi roi = imp!=null?imp.getRoi():null;
+		if (roi!=null && roi.getType()==Roi.RECTANGLE)
+			roi.setCornerDiameter(rectType==ROUNDED_RECT_ROI?arcSize:0);
+	}
+
+	/** Returns 'true' if the multi-point tool is enabled. */
+	public static boolean getMultiPointMode() {
+		return multiPointMode;
+	}
+
+	/** Returns the rectangle tool type (RECT_ROI, ROUNDED_RECT_ROI or ROTATED_RECT_ROI). */
+	public static int getRectToolType() {
+		return rectType;
+	}
+
+	/** Returns the oval tool type (OVAL_ROI, ELLIPSE_ROI or BRUSH_ROI). */
+	public static int getOvalToolType() {
+		return ovalType;
+	}
+
+	/** Returns the button width (button spacing). */
+	public static int getButtonSize() {
+		return buttonWidth;
+	}
+	
+	public static void repaintTool(int tool) {
+		Toolbar tb = getInstance();
+		if (tb!=null) {
+			Graphics g = tb.getGraphics();
+			if (IJ.debugMode) IJ.log("Toolbar.repaintTool: "+tool+" "+g);
+			if (g==null) return;
+			if (dscale>1.0)
+				tb.setStrokeWidth((Graphics2D)g);
+			((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+			tb.drawButton(g, tool);
+			if (g!=null) g.dispose();
+		}
+	}
+	
+	// Returns the toolbar position index of the specified tool
+    int toolIndex(int tool) {
+    	switch (tool) {
+			case RECTANGLE: return 0;
+			case OVAL: return 1;
+			case POLYGON: return 2;
+			case FREEROI: return 3;
+			case LINE: return 4;
+			case POLYLINE: return 4;
+			case FREELINE: return 4;
+			case POINT: return 6;
+			case WAND: return 7;
+			case TEXT: return 8;
+			case MAGNIFIER: return 9;
+			case HAND: return 10;
+			case DROPPER: return 11;
+			case ANGLE: return 5;
+			case UNUSED: return 12;
+			default: return tool - 2;
+		}
+    }
+
+	// Returns the tool corresponding to the specified x coordinate
+	private int toolID(int x) {
+		if (x>buttonWidth*12+gapSize)
+			x -= gapSize;
+		int index = x/buttonWidth;
+    	switch (index) {
+			case 0: return RECTANGLE;
+			case 1: return OVAL;
+			case 2: return POLYGON;
+			case 3: return FREEROI;
+			case 4: return lineType;
+			case 5: return ANGLE;
+			case 6: return POINT;
+			case 7: return WAND;
+			case 8: return TEXT;
+			case 9: return MAGNIFIER;
+			case 10: return HAND;
+			case 11: return DROPPER;
+			default: return index + 3;
+		}
+    }
+    
+	private boolean inGap(int x) {
+		return x>=(buttonWidth*12) && x<(buttonWidth*12+gapSize);
+ 	}
+
+	public void triggerPopupMenu(int newTool, MouseEvent e, boolean isRightClick, boolean isLongPress) {
+		mpPrevious = current;
+		if (isMacroTool(newTool)) {
+			String name = names[newTool];
+			if (newTool==UNUSED || name.contains("Unused Tool"))
+				return;
+			if (name.indexOf("Action Tool")!=-1) {
+				if (e.isPopupTrigger()||e.isMetaDown()) {
+					name = name.endsWith(" ")?name:name+" ";
+					tools[newTool].runMacroTool(name+"Options");
+				} else {
+					//drawTool(newTool, true);
+					//IJ.wait(50);
+					drawTool(newTool, false);
+					runMacroTool(newTool);
+				}
+				return;
+			} else {	
+				name = name.endsWith(" ")?name:name+" ";
+				tools[newTool].runMacroTool(name+"Selected");
+			}
+		}
+		if (!isLongPress)
+			setTool2(newTool);
+		int x = e.getX();
+		int y = e.getY();
+		if (current==RECTANGLE && isRightClick) {	
+			rectItem.setState(rectType==RECT_ROI);	
+			roundRectItem.setState(rectType==ROUNDED_RECT_ROI);	
+			rotatedRectItem.setState(rectType==ROTATED_RECT_ROI);	
+			if (IJ.isMacOSX()) IJ.wait(10);	
+			rectPopup.show(e.getComponent(),x,y);	
+			mouseDownTime = 0L;	
+		}	
+		if (current==OVAL && isRightClick) {	
+			ovalItem.setState(ovalType==OVAL_ROI);	
+			ellipseItem.setState(ovalType==ELLIPSE_ROI);	
+			brushItem.setState(ovalType==BRUSH_ROI);	
+			if (IJ.isMacOSX()) IJ.wait(10);	
+			ovalPopup.show(e.getComponent(),x,y);	
+			mouseDownTime = 0L;	
+		}	
+		if (current==POINT && isRightClick) {	
+			pointItem.setState(!multiPointMode);	
+			multiPointItem.setState(multiPointMode);	
+			if (IJ.isMacOSX()) IJ.wait(10);	
+			pointPopup.show(e.getComponent(),x,y);	
+			mouseDownTime = 0L;	
+		}	
+		if (isLine(current) && isRightClick) {	
+			straightLineItem.setState(lineType==LINE&&!arrowMode);	
+			polyLineItem.setState(lineType==POLYLINE);	
+			freeLineItem.setState(lineType==FREELINE);	
+			arrowItem.setState(lineType==LINE&&arrowMode);	
+			if (IJ.isMacOSX()) IJ.wait(10);	
+			linePopup.show(e.getComponent(),x,y);	
+			mouseDownTime = 0L;	
+		}
+		if (current==MAGNIFIER && isRightClick) {	
+			zoomPopup.show(e.getComponent(),x,y);	
+			mouseDownTime = 0L;	
+		}				
+		if (current==DROPPER && isRightClick) {	
+			pickerPopup.show(e.getComponent(),x,y);	
+			mouseDownTime = 0L;	
+		}	
+		if (isMacroTool(current) && isRightClick) {	
+			String name = names[current].endsWith(" ")?names[current]:names[current]+" ";	
+			tools[current].runMacroTool(name+"Options");	
+		}	
+		if (isPlugInTool(current) && isRightClick) {	
+			tools[current].showPopupMenu(e, this);	
+		}
+	}
+
+	public void mousePressed(final MouseEvent e) {
+		int x = e.getX();
+		if (inGap(x))
+			return;
+ 		final int newTool = toolID(x);
+		if (newTool==getNumTools()-1) {
+			showSwitchPopupMenu(e);
+			return;
+		}
+		if (!isValidTool(newTool))
+			return;
+		if (menus[newTool]!=null && menus[newTool].getItemCount()>0) {
+            menus[newTool].show(e.getComponent(), e.getX(), e.getY());
+			return;
+		}
+		int flags = e.getModifiers();
+		boolean isRightClick = e.isPopupTrigger()||(!IJ.isMacintosh()&&(flags&Event.META_MASK)!=0);
+		boolean doubleClick = newTool==current && (System.currentTimeMillis()-mouseDownTime)<=DOUBLE_CLICK_THRESHOLD;
+ 		mouseDownTime = System.currentTimeMillis();
+		if (!doubleClick || isRightClick) {
+			triggerPopupMenu(newTool, e, isRightClick, false);
+			if (isRightClick) mouseDownTime = 0L;
+		} else if(!isRightClick) { //double click
+			if (isMacroTool(current)) {
+				String name = names[current].endsWith(" ")?names[current]:names[current]+" ";
+				tools[current].runMacroTool(name+"Options");
+				return;
+			}
+			if (isPlugInTool(current)) {
+				tools[current].showOptionsDialog();
+				return;
+			}
+			ImagePlus imp = WindowManager.getCurrentImage();
+			switch (current) {
+				case RECTANGLE:
+					if (rectType==ROUNDED_RECT_ROI)
+						IJ.doCommand("Rounded Rect Tool...");
+					else
+						IJ.doCommand("Roi Defaults...");
+					break;
+				case OVAL:
+					showBrushDialog();
+					break;
+				case MAGNIFIER:
+					if (imp!=null) {
+						ImageCanvas ic = imp.getCanvas();
+						if (ic!=null) ic.unzoom();
+					}
+					break;
+				case LINE: case POLYLINE: case FREELINE:
+					if (current==LINE && arrowMode) {
+						IJ.doCommand("Arrow Tool...");
+					} else
+						IJ.runPlugIn("ij.plugin.frame.LineWidthAdjuster", "");
+					break;
+				case ANGLE:
+					showAngleDialog();
+					break;
+				case POINT:
+					IJ.doCommand("Point Tool...");
+					break;
+				case WAND:
+					IJ.doCommand("Wand Tool...");
+					break;
+				case TEXT:
+					IJ.run("Fonts...");
+					break;
+				case DROPPER:
+					IJ.doCommand("Color Picker...");
+					setTool2(mpPrevious);
+					break;
+				default:
+			}
+		}
+
+		if (!isRightClick && longClickDelay>0) {
+			if (pressTimer==null)
+				pressTimer = new Timer();			
+			pressTimer.schedule(new TimerTask() {
+				public void run() {
+					if (pressTimer != null) {
+						pressTimer.cancel();
+						pressTimer = null;
+					}
+					triggerPopupMenu(newTool, e, true, true);
+				}
+			}, longClickDelay);
+		}
+		
+	}
+	
+	public void mouseReleased(MouseEvent e) {
+		if (pressTimer!=null) {
+			pressTimer.cancel();
+			pressTimer = null;
+		}
+	}
+	
+	void showSwitchPopupMenu(MouseEvent e) {
+		String path = IJ.getDir("macros")+"toolsets/";
+		if (path==null)
+			return;
+		boolean applet = IJ.getApplet()!=null;
+		File f = new File(path);
+		String[] list;
+		if (!applet && f.exists() && f.isDirectory()) {
+			list = f.list();
+			if (list==null) return;
+			Arrays.sort(list);
+		} else
+			list = new String[0];
+		switchPopup.removeAll();
+        path = IJ.getDir("macros") + "StartupMacros.txt";
+		f = new File(path);
+		if (!f.exists()) {
+			path = IJ.getDir("macros") + "StartupMacros.ijm";
+			f = new File(path);
+		}
+		if (!applet && f.exists())
+            addItem("Startup Macros");
+        else
+            addItem("StartupMacros*");
+ 		for (int i=0; i<list.length; i++) {
+			String name = list[i];
+			if (name.startsWith(".") || name.endsWith(" Tool"))
+				continue;
+			if (name.endsWith(".txt")) {
+				name = name.substring(0, name.length()-4);
+                addItem(name);
+			} else if (name.endsWith(".ijm")) {
+				name = name.substring(0, name.length()-4) + " ";
+                addItem(name);
+			}
+		}
+		addItem("Overlay Editing Tools*");
+		addPluginTools();
+		addItem("Restore Startup Tools");
+		addItem("Remove Custom Tools");
+		addItem("Help...");
+		add(ovalPopup);
+		if (IJ.isMacOSX()) IJ.wait(10);
+		switchPopup.show(e.getComponent(), e.getX(), e.getY());
+	}
+
+	private void addPluginTools() {
+		switchPopup.addSeparator();
+		for (int i=0; i<builtInTools.length; i++)
+			addBuiltInTool(builtInTools[i]);
+		MenuBar menuBar = Menus.getMenuBar();
+		if (menuBar==null)
+			return;
+		int n = menuBar.getMenuCount();
+		Menu pluginsMenu = null;
+		if (menuBar.getMenuCount()>=5)
+			pluginsMenu = menuBar.getMenu(5);
+		if (pluginsMenu==null || !"Plugins".equals(pluginsMenu.getLabel()))
+			return;
+		n = pluginsMenu.getItemCount();
+		Menu toolsMenu = null;
+		for (int i=0; i<n; ++i) {
+			MenuItem m = pluginsMenu.getItem(i);
+			if ("Tools".equals(m.getLabel()) && (m instanceof Menu)) {
+				toolsMenu = (Menu)m;
+				break;
+			}
+		}
+		if (toolsMenu==null) {
+			switchPopup.addSeparator();
+			return;
+		}
+		n = toolsMenu.getItemCount();
+		boolean separatorAdded = false;
+		for (int i=0; i<n; ++i) {
+			MenuItem m = toolsMenu.getItem(i);
+			String label = m.getLabel();
+			if (label!=null && (label.endsWith(" Tool")||label.endsWith(" Menu"))) {
+				if (!separatorAdded) {
+					switchPopup.addSeparator();
+					separatorAdded = true;
+				}
+				addPluginTool(label);
+			}
+		}
+		switchPopup.addSeparator();
+	}
+
+    private void addBuiltInTool(String name) {
+		CheckboxMenuItem item = new CheckboxMenuItem(name, name.equals(currentSet));
+		item.addItemListener(this);
+		item.setActionCommand("Tool");
+		switchPopup.add(item);
+    }
+
+    private void addPluginTool(String name) {
+		CheckboxMenuItem item = new CheckboxMenuItem(name, name.equals(currentSet));
+		item.addItemListener(this);
+		item.setActionCommand("Plugin Tool");
+		switchPopup.add(item);
+    }
+
+    private void addItem(String name) {
+		CheckboxMenuItem item = new CheckboxMenuItem(name, name.equals(currentSet));
+		item.addItemListener(this);
+		switchPopup.add(item);
+    }
+
+	void drawTool(int tool, boolean drawDown) {
+		down[tool] = drawDown;
+		Graphics g = this.getGraphics();
+		if (!drawDown) {
+			Graphics2D g2d = (Graphics2D)g;
+			g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+		}
+		drawButton(g, tool);
+		if (null==g) return;
+		g.dispose();
+	}
+
+	boolean isLine(int tool) {
+		return tool==LINE || tool==POLYLINE || tool==FREELINE;
+	}
+	
+	public void restorePreviousTool() {
+		setTool2(mpPrevious);
+	}
+	
+	boolean isMacroTool(int tool) {
+		return tool>=CUSTOM1 && tool<getNumTools() && names[tool]!=null && (tools[tool] instanceof MacroToolRunner);
+	}
+	
+	boolean isPlugInTool(int tool) {
+		return tool>=CUSTOM1 && tool<getNumTools() && tools[tool]!=null;
+	}
+
+	public void mouseExited(MouseEvent e) {}
+	public void mouseClicked(MouseEvent e) {}
+	public void mouseEntered(MouseEvent e) {}
+	public void  mouseDragged(MouseEvent e) {}
+	
+	public void itemStateChanged(ItemEvent e) {
+		CheckboxMenuItem item = (CheckboxMenuItem)e.getSource();
+		String previousName = getToolName();
+		if (item==rectItem || item==roundRectItem || item==rotatedRectItem) {
+			if (item==roundRectItem)
+				rectType = ROUNDED_RECT_ROI;
+			else if (item==rotatedRectItem)
+				rectType = ROTATED_RECT_ROI;
+			else
+				rectType = RECT_ROI;
+			repaintTool(RECTANGLE);
+			showMessage(RECTANGLE);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			Roi roi = imp!=null?imp.getRoi():null;
+			if (roi!=null && roi.getType()==Roi.RECTANGLE)
+				roi.setCornerDiameter(rectType==ROUNDED_RECT_ROI?arcSize:0);
+			if (!previousName.equals(getToolName()))
+				IJ.notifyEventListeners(IJEventListener.TOOL_CHANGED);
+		} else if (item==ovalItem || item==ellipseItem || item==brushItem) {
+			if (item==brushItem)
+				ovalType = BRUSH_ROI;
+			else if (item==ellipseItem)
+				ovalType = ELLIPSE_ROI;
+			else
+				ovalType = OVAL_ROI;
+			repaintTool(OVAL);
+			showMessage(OVAL);
+			if (!previousName.equals(getToolName()))
+				IJ.notifyEventListeners(IJEventListener.TOOL_CHANGED);
+		} else if (item==pointItem || item==multiPointItem) {
+			multiPointMode = item==multiPointItem;
+			Prefs.multiPointMode = multiPointMode;
+			repaintTool(POINT);
+			showMessage(POINT);
+			if (!previousName.equals(getToolName()))
+				IJ.notifyEventListeners(IJEventListener.TOOL_CHANGED);
+		} else if (item==straightLineItem) {
+			lineType = LINE;
+			arrowMode = false;
+			setTool2(LINE);
+			showMessage(LINE);
+		} else if (item==polyLineItem) {
+			lineType = POLYLINE;
+			setTool2(POLYLINE);
+			showMessage(POLYLINE);
+		} else if (item==freeLineItem) {
+			lineType = FREELINE;
+			setTool2(FREELINE);
+			showMessage(FREELINE);
+		} else if (item==arrowItem) {
+			lineType = LINE;
+			arrowMode = true;
+			setTool2(LINE);
+			showMessage(LINE);
+		} else {
+			String label = item.getLabel();
+			String cmd = item.getActionCommand();
+			boolean isTool = cmd.equals("Tool") || cmd.equals("Plugin Tool");
+			if (!(label.equals("Help...")||label.equals("Remove Custom Tools")) && !isTool && !label.endsWith("Tool") && !label.endsWith("Tool "))
+				currentSet = label;
+			if (isTool) {
+				if (cmd.equals("Tool")) // built in tool
+					installBuiltinTool(label);
+				else  // plugin or macro tool in ImageJ/plugins/Tools
+					IJ.run(label);
+				return;
+			}
+			String path;
+			if (label.equals("Remove Custom Tools")) {
+				removeTools();
+			} else if (label.equals("Restore Startup Tools")) {
+				removeTools();
+				installStartupMacros();
+			} else if (label.equals("Help...")) {
+				IJ.showMessage("Tool Switcher and Loader",
+					"Use this drop down menu to switch to alternative\n"+
+					"macro toolsets or to load additional plugin tools.\n"+
+					"The toolsets listed in the menu are located\n"+
+					"in the ImageJ/macros/toolsets folder and the\n"+
+					"plugin tools are the ones installed in the\n"+
+					"Plugins>Tools submenu.\n"+
+					" \n"+
+					"Hold the shift key down while selecting a\n"+
+					"toolset to view its source code.\n"+
+					" \n"+
+					"More macro toolsets are available at\n"+
+					"  <"+IJ.URL+"/macros/toolsets/>\n"+
+					" \n"+
+					"Plugin tools can be downloaded from\n"+
+					"the Tools section of the Plugins page at\n"+
+					"  <"+IJ.URL+"/plugins/>\n"
+					);
+				return;
+			} else if (label.endsWith("*")) {
+                // load from ij.jar
+                MacroInstaller mi = new MacroInstaller();
+                label = label.substring(0, label.length()-1) + ".txt";
+                path = "/macros/"+label;
+                if (IJ.shiftKeyDown())
+				    showCode(label, mi.openFromIJJar(path));
+				else {
+				    resetTools();
+				    mi.installFromIJJar(path);
+                }
+            } else {
+                // load from ImageJ/macros/toolsets
+                if (label.equals("Startup Macros")) {
+                	installStartupMacros();
+                	return;
+                } else if (label.endsWith(" "))
+                    path = IJ.getDir("macros")+"toolsets"+File.separator+label.substring(0, label.length()-1)+".ijm";
+                else
+                    path = IJ.getDir("macros")+"toolsets"+File.separator+label+".txt";
+                try {
+                    if (IJ.shiftKeyDown()) {
+                        IJ.open(path);
+                		IJ.setKeyUp(KeyEvent.VK_SHIFT);
+                    } else
+                        new MacroInstaller().run(path);
+                } catch(Exception ex) {}
+            }
+		}
+	}
+	
+	private void removeTools() {
+		removeMacroTools();
+		setTool(RECTANGLE);
+		currentSet = "Startup Macros";
+		resetPrefs();
+		if (nExtraTools>0) {
+			String name = names[getNumTools()-1];
+			String icon = icons[getNumTools()-1];
+			nExtraTools = 0;
+			names[getNumTools()-1] = name;
+			icons[getNumTools()-1] = icon;
+			ps = new Dimension(buttonWidth*NUM_BUTTONS-(BUTTON_WIDTH-gapSize)+nExtraTools*BUTTON_WIDTH, buttonHeight);
+			IJ.getInstance().pack();
+		}
+	}
+	
+	private void resetPrefs() {
+		for (int i=0; i<7; i++) {
+			String key = TOOL_KEY+(i/10)%10+i%10;
+			if (!Prefs.get(key, "").equals(""))
+				Prefs.set(key, "");
+		}
+	}
+	
+	public static void restoreTools() {
+		Toolbar tb = Toolbar.getInstance();
+		if (tb!=null) {
+			if (tb.getToolId()>=UNUSED)
+				tb.setTool(RECTANGLE);
+			tb.installStartupMacros();
+		}
+	}
+
+	private void installStartupMacros() {
+		resetTools();
+		String path = IJ.getDir("macros")+"StartupMacros.txt";
+		File f = new File(path);
+		if (!f.exists()) {
+			path = IJ.getDir("macros")+"StartupMacros.ijm";
+			f = new File(path);
+		}
+		if (!f.exists()) {
+			path = IJ.getDir("macros")+"StartupMacros.fiji.ijm";
+			f = new File(path);
+		}
+		if (!f.exists()) {
+			IJ.error("StartupMacros not found in\n \n"+IJ.getDir("macros"));
+			return;
+		}
+		if (IJ.shiftKeyDown()) {
+			IJ.open(path);
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);
+		} else {
+			try {
+				MacroInstaller mi = new MacroInstaller();
+				mi.installFile(path);
+			} catch
+				(Exception ex) {}
+		}
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		MenuItem item = (MenuItem)e.getSource();
+		String cmd = e.getActionCommand();
+		PopupMenu popup = (PopupMenu)item.getParent();
+		
+		if (zoomPopup==popup) {
+			if ("Zoom In".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "in");
+			else if ("Zoom Out".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "out");
+			else if ("Reset Zoom".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "orig");
+			else if ("View 100%".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "100%");
+			else if ("Zoom To Selection".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "to");
+			else if ("Scale to Fit".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "scale");
+			else if ("Set...".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "set");
+			else if ("Maximize".equals(cmd))
+				IJ.runPlugIn("ij.plugin.Zoom", "max");
+			disableRecording = true;
+			setTool(previousTool);
+			disableRecording = false;			
+			return;
+		}
+		
+		if (pickerPopup==popup) {
+			if ("White/Black".equals(cmd)) {
+				setAndRecordForgroundColor(Color.white);
+				setAndRecordBackgroundColor(Color.black);				
+			} else if ("Black/White".equals(cmd)) {
+				setAndRecordForgroundColor(Color.black);
+				setAndRecordBackgroundColor(Color.white);				
+			} else if ("Red".equals(cmd))
+				setAndRecordForgroundColor(Color.red);
+			else if ("Green".equals(cmd))
+				setAndRecordForgroundColor(Color.green);
+			else if ("Blue".equals(cmd))
+				setAndRecordForgroundColor(Color.blue);
+			else if ("Yellow".equals(cmd))
+				setAndRecordForgroundColor(Color.yellow);
+			else if ("Cyan".equals(cmd))
+				setAndRecordForgroundColor(Color.cyan);
+			else if ("Magenta".equals(cmd))
+				setAndRecordForgroundColor(Color.magenta);
+			else if ("Foreground...".equals(cmd))
+				setAndRecordForgroundColor(new ColorChooser("Select Foreground Color", foregroundColor, false).getColor());
+			else if ("Background...".equals(cmd))
+				setAndRecordBackgroundColor(new ColorChooser("Select Background Color", backgroundColor, false).getColor());
+			else if ("Colors...".equals(cmd)) {
+				IJ.run("Colors...", "");
+				Recorder.setForegroundColor(getForegroundColor());
+				Recorder.setBackgroundColor(getBackgroundColor());
+			} else
+				IJ.run("Color Picker...", "");
+			if (!"Color Picker".equals(cmd))
+				ColorPicker.update();	
+			setTool(previousTool);			
+			return;
+		}
+		
+		int tool = -1;
+		for (int i=CUSTOM1; i<getNumTools(); i++) {
+			if (popup==menus[i]) {
+				tool = i;
+				break;
+			}
+		}
+		if (tool==-1) return;
+		if (tools[tool]!=null)
+			tools[tool].runMenuTool(names[tool], cmd);
+    }
+    
+    private void setAndRecordForgroundColor(Color color) {
+		if (color!=null) {
+			setForegroundColor(color);
+			Recorder.setForegroundColor(color);
+		}
+    }
+    
+    private void setAndRecordBackgroundColor(Color color) {
+		if (color!=null) {
+			setBackgroundColor(color);
+			Recorder.setBackgroundColor(color);
+		}
+    }
+
+	public Dimension getPreferredSize(){
+		return ps;
+	}
+
+	public Dimension getMinimumSize(){
+		return ps;
+	}
+	
+	public void mouseMoved(MouseEvent e) {
+		int x = e.getX();
+		if (inGap(x))
+			IJ.showStatus("");
+		else
+			showMessage(toolID(x));
+	}
+
+	/** Adds a tool to the toolbar. The 'toolTip' string is displayed in the status bar
+		 when the mouse is over the tool icon. The 'toolTip' string may include icon 
+		(http://imagej.nih.gov/ij/developer/macro/macros.html#tools).
+		Returns the tool ID, or -1 if all tool slots are in use. */
+	public int addTool(String toolTip) {
+		int index = toolTip.indexOf('-');
+		boolean hasIcon = index>=0 && (toolTip.length()-index)>4;
+		int tool =-1;
+		for (int i=CUSTOM1; i<=getNumTools()-2; i++) {
+			if (names[i]==null || toolTip.startsWith(names[i])) {
+				tool = i;
+				break;
+			}			
+		}
+		if (tool==CUSTOM1)
+			legacyMode = toolTip.startsWith("Select and Transform Tool"); //TrakEM2
+		if (tool==-1 && (nExtraTools<MAX_EXTRA_TOOLS)) {
+			nExtraTools++;
+			names[getNumTools()-1] = names[getNumTools()-2];
+			icons[getNumTools()-1] = icons[getNumTools()-2];
+			names[getNumTools()-2] = null;
+			icons[getNumTools()-2] = null;
+			ps = new Dimension(buttonWidth*NUM_BUTTONS-(buttonWidth-gapSize)+nExtraTools*buttonWidth, buttonHeight);
+			IJ.getInstance().pack();
+			tool = getNumTools()-2;
+		}
+		if (tool==-1) {
+			if (addingSingleTool)
+				tool = getNumTools()-2;
+			else
+				return -1;
+		}
+		if (hasIcon) {
+			icons[tool] = toolTip.substring(index+1);
+			if (index>0 && toolTip.charAt(index-1)==' ')
+				names[tool] = toolTip.substring(0, index-1);
+			else
+				names[tool] = toolTip.substring(0, index);
+		} else {
+			if (toolTip.endsWith("-"))
+				toolTip = toolTip.substring(0, toolTip.length()-1);
+			else if (toolTip.endsWith("- "))
+				toolTip = toolTip.substring(0, toolTip.length()-2);
+			names[tool] = toolTip;
+		}
+        if (tool==current && (names[tool].indexOf("Action Tool")!=-1||names[tool].indexOf("Unused Tool")!=-1))
+        	setTool(RECTANGLE);
+        if (names[tool].endsWith(" Menu Tool"))
+            installMenu(tool);
+        if (IJ.debugMode) IJ.log("Toolbar.addTool: "+tool+" "+toolTip);
+		return tool;
+	}
+    
+    void installMenu(int tool) {
+        Program pgm = macroInstaller.getProgram();
+        Hashtable h = pgm.getMenus();
+        if (h==null) return;
+        String[] commands = (String[])h.get(names[tool]);
+        if (commands==null)
+        	return;
+		if (menus[tool]==null) {
+			menus[tool] = new PopupMenu("");
+			if (Menus.getFontSize()!=0)
+				menus[tool].setFont(Menus.getFont());
+			add(menus[tool] );
+		} else
+			menus[tool].removeAll();
+        for (int i=0; i<commands.length; i++) {
+			if (commands[i].equals("-"))
+				menus[tool].addSeparator();
+			else if (commands[i].startsWith("-"))
+				menus[tool].addSeparator();
+			else {
+				boolean disable = commands[i].startsWith("*");
+				String command = commands[i];
+				if (disable)
+					command = command.substring(1);
+				MenuItem mi = new MenuItem(command);
+				if (disable)
+					mi.setEnabled(false);
+				mi.addActionListener(this);
+				menus[tool].add(mi);
+			}
+        }
+        if (tool==current) setTool(RECTANGLE);
+    }
+    
+	/** Used by the MacroInstaller class to install a set of macro tools. */
+	public void addMacroTool(String name, MacroInstaller macroInstaller, int id) {
+		if (id==0) {
+			resetTools();
+			if (name.startsWith("Unused"))
+				return;
+ 		}
+		if (name.endsWith(" Built-in Tool")) {
+			name = name.substring(0,name.length()-14);
+			doNotSavePrefs = true;
+			boolean ok = installBuiltinTool(name);
+			if (!ok) {
+				Hashtable commands = Menus.getCommands();
+				if (commands!=null && commands.get(name)!=null)
+					IJ.run(name);
+			}
+			doNotSavePrefs = false;
+			return;
+		}
+		this.macroInstaller = macroInstaller;
+		int tool = addTool(name);
+		this.macroInstaller = null;
+		if (tool!=-1)
+			tools[tool] = new MacroToolRunner(macroInstaller);
+	}
+	
+	private void resetTools() {
+		for (int i=CUSTOM1; i<getNumTools()-1; i++) {
+			names[i] = null;
+			tools[i] = null;
+			icons[i] = null;
+			if (menus[i]!=null)
+				menus[i].removeAll();
+		}
+	}
+	
+	/** Used by the MacroInstaller class to add a macro tool to the toolbar. */
+	public void addMacroTool(String name, MacroInstaller macroInstaller) {
+		String custom1Name = names[CUSTOM1];
+		this.macroInstaller = macroInstaller;
+		addingSingleTool = true;
+		int tool = addTool(name);
+		addingSingleTool = false;
+		this.macroInstaller = null;
+		if (tool!=-1) {
+			tools[tool] = new MacroToolRunner(macroInstaller);
+			if (!name.contains(" Menu Tool")) {
+				if (menus[tool]!=null)
+					menus[tool].removeAll();
+				if (!installingStartupTool)
+					setTool(tool);
+				else
+					installingStartupTool = false;
+			}
+			if ((tool-CUSTOM1)>0 || custom1Name==null)
+				setPrefs(tool);
+		}
+	}
+	
+	private void setPrefs(int id) {
+		if (doNotSavePrefs)
+			return;
+		boolean ok = isBuiltInTool(names[id]);
+		String prefsName = instance.names[id];
+		if (!ok) {
+			String name = names[id];
+			int i = name.indexOf(" (");  // remove any hint in parens
+			if (i>0) {
+				name = name.substring(0, i);
+				prefsName=name;
+			}
+		}
+		int index = id - CUSTOM1;
+		String key = TOOL_KEY + (index/10)%10 + index%10;
+		Prefs.set(key, prefsName);
+	}
+	
+	private boolean isBuiltInTool(String name) {
+		for (int i=0; i<builtInTools2.length; i++) {
+			if (name.equals(builtInTools2[i]))
+				return true;
+		}
+		for (int i=0; i<builtInTools.length; i++) {
+			if (name.startsWith(builtInTools[i]))
+				return true;
+		}
+		return false;
+	}
+
+	public static void removeMacroTools() {
+		if (instance!=null) {
+			if (instance.getToolId()>=CUSTOM1)
+				instance.setTool(RECTANGLE);
+			instance.resetTools();
+			instance.repaint();
+		}
+	}
+
+	/** Adds a plugin tool to the first available toolbar slot,
+		or to the last slot if the toolbar is full. */
+	public static void addPlugInTool(PlugInTool tool) {
+		if (instance==null) return;
+		String nameAndIcon = tool.getToolName()+" - "+tool.getToolIcon();
+		instance.addingSingleTool = true;
+		int id = instance.addTool(nameAndIcon);
+		instance.addingSingleTool = false;
+		if (id!=-1) {
+			instance.tools[id] = tool;
+			if (instance.menus[id]!=null)
+				instance.menus[id].removeAll();
+			instance.repaintTool(id);	
+			if (!instance.installingStartupTool)
+				instance.setTool(id);
+			else
+				instance.installingStartupTool = false;
+			instance.setPrefs(id);
+		}
+	}
+
+	public static PlugInTool getPlugInTool() {
+		PlugInTool tool = null;
+		if (instance==null)
+			return null;
+		if (current<instance.tools.length)
+			tool = instance.tools[current];
+		if (tool!=null && tool instanceof MacroToolRunner)
+			tool = null;
+		return tool;
+	}
+
+	void runMacroTool(int id) {
+		if (id<getNumTools() && tools[id]!=null)
+			tools[id].runMacroTool(names[id]);
+	}
+	
+	void showBrushDialog() {
+		GenericDialog gd = new GenericDialog("Selection Brush");
+		gd.addCheckbox("Enable selection brush", ovalType==BRUSH_ROI);
+		gd.addNumericField("           Size:", brushSize, 0, 4, "pixels");
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		if (gd.getNextBoolean())
+			ovalType = BRUSH_ROI;
+		brushSize = (int)gd.getNextNumber();
+		if (brushSize<1) brushSize=1;
+		repaintTool(OVAL);
+		ImagePlus img = WindowManager.getCurrentImage();
+		Roi roi = img!=null?img.getRoi():null;
+		if (roi!=null && roi.getType()==Roi.OVAL && ovalType==BRUSH_ROI)
+			img.deleteRoi();
+		Prefs.set(BRUSH_SIZE, brushSize);
+	}
+
+	void showAngleDialog() {
+		GenericDialog gd = new GenericDialog("Angle Tool");
+		gd.addCheckbox("Measure reflex angle", Prefs.reflexAngle);
+		gd.showDialog();
+		if (!gd.wasCanceled())
+			Prefs.reflexAngle = gd.getNextBoolean();
+	}
+	
+	public void installStartupTools() {
+		if (IJ.debugMode) IJ.log("Toolbar.installStartupTools");
+		for (int i=0; i<=6; i++) {
+			String name = Prefs.get(TOOL_KEY + (i/10)%10 + i%10, "");
+			if (IJ.debugMode) IJ.log("  "+i+" "+name);
+			if (name.equals("")) continue;
+			installingStartupTool = true;
+			boolean ok = installBuiltinTool(name);
+			if (!ok) {
+				ok = installToolsetTool(name);
+				if (!ok) {  // install tool in plugins/Tools
+					if (name.endsWith("Menu Tool"))
+						name = name.substring(0, name.length()-5);
+					Hashtable commands = Menus.getCommands();
+					if (commands!=null && commands.get(name)!=null)
+						IJ.run(name);
+				}
+			}
+			installingStartupTool = false;
+		}
+	}
+	
+	// install tool from ImageJ/macros/toolsets
+	private boolean installToolsetTool(String name) {
+		String path = IJ.getDir("macros")+"toolsets"+File.separator+name+".ijm";
+		if (!((new File(path)).exists())) {
+			name = name.replaceAll(" ", "_");
+			path = IJ.getDir("macros")+"toolsets"+File.separator+name+".ijm";
+		}
+		String text = IJ.openAsString(path);
+		if (text==null || text.startsWith("Error"))
+			return false;
+		new MacroInstaller().installSingleTool(text);
+		return true;
+	}
+	
+	private boolean installBuiltinTool(String label) {
+		if (IJ.debugMode) IJ.log("Toolbar.installBuiltinTool: "+label);
+		boolean ok = true;
+		PlugInTool tool = null;
+		if (label.startsWith("Arrow")) {
+			tool = new ij.plugin.tool.ArrowTool();
+			if (tool!=null) tool.run("");
+			showSource("Arrow");
+		} else if (label.startsWith("Overlay Brush")) {
+			tool = new ij.plugin.tool.OverlayBrushTool();
+			if (tool!=null) tool.run("");
+			showSource("OverlayBrush");
+		} else if (label.startsWith("Pixel Inspect")) {
+			tool = new ij.plugin.tool.PixelInspectionTool();
+			if (tool!=null) tool.run("");
+			showSource("PixelInspection");
+		} else if (label.startsWith("Brush")||label.startsWith("Paintbrush")) {
+			tool = new ij.plugin.tool.BrushTool();
+			if (tool!=null) tool.run("");
+			showSource("Brush");
+		} else if (label.startsWith("Pencil")) {
+			tool = new ij.plugin.tool.BrushTool();
+			if (tool!=null) tool.run("pencil");
+			showSource("Brush");
+		} else if (label.startsWith("Selection Rotator")) {
+			tool = new ij.plugin.tool.RoiRotationTool();
+			if (tool!=null) tool.run("");
+			showSource("RoiRotation");
+		} else if (label.startsWith("Flood Fill"))
+			installMacroFromJar("/macros/FloodFillTool.txt");
+		else if (label.startsWith("Spray Can"))
+			installMacroFromJar("/macros/SprayCanTool.txt");
+		else if (label.startsWith("Developer Menu"))
+			installMacroFromJar("/macros/DeveloperMenuTool.txt");
+		else if (label.startsWith("Stacks Menu"))
+			installMacroFromJar("/macros/StacksMenuTool.txt");
+		else if (label.startsWith("LUT Menu"))
+			installMacroFromJar("/macros/LUTMenuTool.txt");
+		else if (label.startsWith("Command Finder"))
+			installMacroFromJar("/macros/CommandFinderTool.txt");
+		else if (label.startsWith("ROI"))
+			installMacroFromJar("/macros/RoiMenuTool.txt");
+		else if (label.startsWith("Label"))
+			installMacroFromJar("/macros/Label_Tool.txt");
+		else
+			ok = false;
+		return ok;
+	}
+	
+	private void showSource(String name) {
+		if (IJ.shiftKeyDown()) {
+			IJ.runPlugIn("ij.plugin.BrowserLauncher", IJ.URL+"/source/ij/plugin/tool/"+name+"Tool.java");
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);
+		}
+	}
+	
+	private void installMacroFromJar(String path) {
+		if (IJ.shiftKeyDown())
+			showCode(path, (new MacroInstaller()).openFromIJJar(path));
+		else
+			(new MacroInstaller()).installFromIJJar(path);
+	}
+	
+	public static void showCode(String title, String code) {
+		Editor ed = new Editor();
+		ed.setSize(550, 450);
+		ed.create(title, code);
+		IJ.setKeyUp(KeyEvent.VK_SHIFT);
+	}
+	
+	private boolean isMacroSet(int id) {
+		if (tools[id]==null)
+			return false;
+		if (!(tools[id] instanceof MacroToolRunner))
+			return false;
+		boolean rtn = ((MacroToolRunner)tools[id]).getMacroCount()>2;
+		return rtn;
+	}
+	
+	public static boolean installStartupMacrosTools() {
+		String customTool0 = Prefs.get(Toolbar.TOOL_KEY+"00", "");
+		return customTool0.equals("") || Character.isDigit(customTool0.charAt(0));
+	}
+	
+	public int getNumTools() {
+		return NUM_TOOLS + nExtraTools;
+	}
+	
+	/** Sets the tool menu long click delay in milliseconds
+	 * (default is 600). Set to 0 to disable long click triggering.
+	*/
+	 public static void setLongClickDelay(int delay) {
+		longClickDelay = delay;
+	}
+	
+	/** Sets the icon of the specified macro or plugin tool.<br>
+	 * See: Help&gt;Examples&gt;Tool&gt;Animated Icon Tool;
+	*/
+	 public static void setIcon(String toolName, String icon) {
+	 	if (instance==null)
+	 		return;
+	 	int tool = 0;
+	 	for (int i=CUSTOM1; i<instance.getNumTools(); i++) {
+	 		if (instance.names[i]!=null && instance.names[i].equals(toolName)) {
+	 			tool = i;
+	 			break;
+	 		}
+	 	}
+		if (tool>0) {
+	 		instance.icons[tool] = icon;
+	 		Graphics2D g = (Graphics2D)instance.getGraphics();
+	 		instance.setStrokeWidth(g);
+	 		instance.drawButton(g, tool);
+	 	}
+	}
+
+}
diff --git a/src/ij/gui/TrimmedButton.java b/src/ij/gui/TrimmedButton.java
new file mode 100644
index 0000000..7949b80
--- /dev/null
+++ b/src/ij/gui/TrimmedButton.java
@@ -0,0 +1,28 @@
+package ij.gui;
+import java.awt.*;
+import javax.swing.*;
+
+/** This is an extended Button class used to reduce the width of the HUGE buttons on Mac OS X. */
+public class TrimmedButton extends Button {
+    private int trim = 0;
+    
+    public TrimmedButton(String title, int trim) {
+        super(title);
+        if (trim>0) {
+        	LookAndFeel laf = UIManager.getLookAndFeel();
+        	String name = laf!=null?laf.getName():"";
+        	if (ij.IJ.isMacOSX() && name!=null && !name.equals("Mac OS X"))
+        		trim = 0;
+        }
+        this.trim = trim;
+    }
+
+    public Dimension getMinimumSize() {
+        return new Dimension(super.getMinimumSize().width-trim, super.getMinimumSize().height);
+    }
+
+    public Dimension getPreferredSize() {
+        return getMinimumSize();
+    }
+    
+}
diff --git a/src/ij/gui/WaitForUserDialog.java b/src/ij/gui/WaitForUserDialog.java
new file mode 100644
index 0000000..31a758c
--- /dev/null
+++ b/src/ij/gui/WaitForUserDialog.java
@@ -0,0 +1,126 @@
+package ij.gui;
+import ij.*;
+import ij.plugin.frame.RoiManager;
+import java.awt.*;
+import java.awt.event.*;
+import java.lang.reflect.*;
+
+
+/**
+* This is a non-modal dialog box used to ask the user to perform some task
+* while a macro or plugin is running. It implements the waitForUser() macro
+* function. It is based on Michael Schmid's Wait_For_User plugin.<br>
+* Example:
+* <code>new WaitForUserDialog("Use brush to draw on overlay").show();</code>
+*/
+public class WaitForUserDialog extends Dialog implements ActionListener, KeyListener {
+	protected Button button;
+	protected Button cancelButton;
+	protected MultiLineLabel label;
+	static protected int xloc=-1, yloc=-1;
+	private boolean escPressed;
+	
+	public WaitForUserDialog(String title, String text) {
+		super(IJ.getInstance(), title, false);
+		IJ.protectStatusBar(false);
+		if (text!=null && text.startsWith("IJ: "))
+			text = text.substring(4);
+		label = new MultiLineLabel(text, 175);
+		if (!IJ.isLinux()) label.setFont(new Font("SansSerif", Font.PLAIN, 14));
+		if (IJ.isMacOSX()) {
+			RoiManager rm = RoiManager.getInstance();
+			if (rm!=null) rm.runCommand("enable interrupts");
+		}
+        GridBagLayout gridbag = new GridBagLayout(); //set up the layout
+        GridBagConstraints c = new GridBagConstraints();
+        setLayout(gridbag);
+		c.insets = new Insets(6, 6, 0, 6); 
+        c.gridx = 0; c.gridy = 0; c.anchor = GridBagConstraints.WEST;
+        add(label,c); 
+		
+		button = new Button("  OK  ");
+		button.addActionListener(this);
+		button.addKeyListener(this);
+        c.insets = new Insets(2, 6, 6, 6); 
+        c.gridx = 0; c.gridy = 1; c.anchor = GridBagConstraints.EAST;
+        add(button, c);
+
+		if (IJ.isMacro()) {
+			cancelButton = new Button(" Cancel ");
+			cancelButton.addActionListener(this);
+			cancelButton.addKeyListener(this);
+			c.anchor = GridBagConstraints.WEST; //same as OK button but WEST	
+        	add(cancelButton, c);
+        }
+
+		setResizable(false);
+		addKeyListener(this);
+		GUI.scale(this);
+		pack();
+		if (xloc==-1)
+			GUI.centerOnImageJScreen(this);
+		else
+			setLocation(xloc, yloc);
+		setAlwaysOnTop(true);
+	}
+	
+	public WaitForUserDialog(String text) {
+		this("Action Required", text);
+	}
+
+	public void show() {
+		super.show();
+		synchronized(this) {  //wait for OK
+			try {wait();}
+			catch(InterruptedException e) {return;}
+		}
+	}
+	
+    public void close() {
+        synchronized(this) { notify(); }
+        xloc = getLocation().x;
+        yloc = getLocation().y;
+		dispose();
+    }
+
+	public void actionPerformed(ActionEvent e) {
+		String s = e.getActionCommand();
+		if(s.indexOf("Cancel") >= 0){
+			escPressed = true;
+		}
+		close();
+	}
+	
+	public void keyPressed(KeyEvent e) { 
+		int keyCode = e.getKeyCode(); 
+		IJ.setKeyDown(keyCode); 
+		if (keyCode==KeyEvent.VK_ENTER || keyCode==KeyEvent.VK_ESCAPE) {
+			escPressed = keyCode==KeyEvent.VK_ESCAPE;
+			close();
+		}
+	}
+	
+	public boolean escPressed() {
+		return escPressed;
+	}
+	
+	public void keyReleased(KeyEvent e) {
+		int keyCode = e.getKeyCode(); 
+		IJ.setKeyUp(keyCode); 
+	}
+	
+	public void keyTyped(KeyEvent e) {}
+	
+	/** Returns a reference to the 'OK' button */
+	public Button getButton() {
+		return button;
+	}
+	
+	/** Display the next WaitForUser dialog at the specified location. */
+	public static void setNextLocation(int x, int y) {
+		xloc = x;
+		yloc = y;
+	}
+
+
+}
diff --git a/src/ij/gui/Wand.java b/src/ij/gui/Wand.java
new file mode 100644
index 0000000..c6c79b6
--- /dev/null
+++ b/src/ij/gui/Wand.java
@@ -0,0 +1,353 @@
+package ij.gui;
+import ij.*;
+import ij.process.*;
+import ij.plugin.WandToolOptions;
+import java.awt.*;
+
+/** This class implements ImageJ's wand (tracing) tool.
+  * The wand selects pixels of equal or similar value or thresholded pixels
+  * forming a contiguous area.
+  * The wand creates selections that have only one boundary line (inner holes
+  * are not excluded from the selection). There may be holes at the boundary,
+  * however, if the boundary line touches the same vertex twice (both in
+  * 4-connected and 8-connected mode).
+  *
+  * Version 2009-06-01  (code refurbished; tolerance, 4- & 8-connected options added)
+  */
+public class Wand {
+    /** Wand operation type: trace outline of 4-connected pixels */
+    public final static int FOUR_CONNECTED = 4;
+    /** Wand operation type: trace outline of 8-connected pixels */
+    public final static int EIGHT_CONNECTED = 8;
+    /** Wand operation type similar to  that of ImageJ 1.42p and before; for backwards
+      * compatibility.
+      * In this mode, no checking is done whether the foreground or the background
+      * gets selected; four- or 8-connected behaviour depends on foreground/background
+      * and (if no selection) on whether the initial pixel is on a 1-pixel wide line. */
+    public final static int LEGACY_MODE = 1;    
+    /** The number of points in the generated outline. */
+    public int npoints;
+    private int maxPoints = 1000; // will be increased if necessary
+    /** The x-coordinates of the points in the outline.
+        A vertical boundary at x separates the pixels at x-1 and x. */
+    public int[] xpoints = new int[maxPoints];
+    /** The y-coordinates of the points in the outline.
+        A horizontal boundary at y separates the pixels at y-1 and y. */
+    public int[] ypoints = new int[maxPoints];
+
+    private final static int THRESHOLDED_MODE = 256; //work on threshold
+    private ImageProcessor ip;
+    private byte[] bpixels;
+    private int[] cpixels;
+    private short[] spixels;
+    private float[] fpixels;
+    private int width, height;
+    private float lowerThreshold, upperThreshold;
+    private int xmin;                   // of selection created
+    private boolean exactPixelValue;    // For color, match RGB, not gray value
+    private static boolean allPoints;  // output contains intermediate points
+
+
+    /** Constructs a Wand object from an ImageProcessor. */
+    public Wand(ImageProcessor ip) {
+        this.ip = ip;
+        Object pixels = ip.getPixels();
+        if (pixels instanceof byte[])
+            bpixels = (byte[])pixels;
+        else if (pixels instanceof int[])
+            cpixels = (int[])pixels;
+        else if (pixels instanceof short[])
+            spixels = (short[])pixels;
+        else if (pixels instanceof float[])
+            fpixels = (float[])pixels;
+        width = ip.getWidth();
+        height = ip.getHeight();
+    }
+
+
+
+    /** Traces an object defined by lower and upper threshold values.
+      * 'mode' can be FOUR_CONNECTED or EIGHT_CONNECTED.
+      * ('LEGACY_MODE' is also supported and may result in selection of
+      * interior holes instead of the thresholded area if one clicks left
+      * of an interior hole).
+      * The start coordinates must be inside the area or left of it.
+      * When successful, npoints>0 and the boundary points can be accessed
+      * in the public xpoints and ypoints fields. */
+    public void autoOutline(int startX, int startY, double lower, double upper, int mode) {
+        lowerThreshold = (float)lower;
+        upperThreshold = (float)upper;
+        autoOutline(startX, startY, 0.0, mode|THRESHOLDED_MODE);
+    }
+
+    /** Traces an object defined by lower and upper threshold values or an
+      * interior hole; whatever is found first ('legacy mode').
+      * For compatibility with previous versions of ImageJ.
+      * The start coordinates must be inside the area or left of it.
+      * When successful, npoints>0 and the boundary points can be accessed
+      * in the public xpoints and ypoints fields. */
+    public void autoOutline(int startX, int startY, double lower, double upper) {
+        autoOutline(startX, startY, lower, upper, THRESHOLDED_MODE|LEGACY_MODE);
+    }
+
+    /** This is a variation of legacy autoOutline that uses int threshold arguments. */
+    public void autoOutline(int startX, int startY, int lower, int upper) {
+        autoOutline(startX, startY, (double)lower, (double)upper, THRESHOLDED_MODE|LEGACY_MODE);
+    }
+
+    /** Traces the boundary of an area of uniform color, where
+      * 'startX' and 'startY' are somewhere inside the area.
+      * When successful, npoints>0 and the boundary points can be accessed
+      * in the public xpoints and ypoints fields.
+      * For compatibility with previous versions of ImageJ only; otherwise
+      * use the reliable method specifying 4-connected or 8-connected mode
+      * and the tolerance. */
+    public void autoOutline(int startX, int startY) {
+        autoOutline(startX, startY, 0.0, LEGACY_MODE);
+    }
+
+    /** Traces the boundary of the area with pixel values within
+      * 'tolerance' of the value of the pixel at the starting location.
+      * 'tolerance' is in uncalibrated units.
+      * 'mode' can be FOUR_CONNECTED or EIGHT_CONNECTED.
+      * Mode LEGACY_MODE is for compatibility with previous versions of ImageJ;
+      * ignored if tolerance > 0.
+      * Mode bit THRESHOLDED_MODE for internal use only; it is set by autoOutline
+      * with 'upper' and 'lower' arguments.
+      * When successful, npoints>0 and the boundary points can be accessed
+      * in the public xpoints and ypoints fields. */
+    public void autoOutline(int startX, int startY, double tolerance, int mode) {
+        if (startX<0 || startX>=width || startY<0 || startY>=height) return;
+        if (fpixels!=null && Float.isNaN(getPixel(startX, startY))) return;
+        WandToolOptions.setStart(startX, startY);
+        exactPixelValue = tolerance==0;
+        boolean thresholdMode = (mode & THRESHOLDED_MODE) != 0;
+        boolean legacyMode = (mode & LEGACY_MODE) != 0 && tolerance == 0;
+        if (!thresholdMode) {
+            double startValue = getPixel(startX, startY);
+            lowerThreshold = (float)(startValue - tolerance);
+            upperThreshold = (float)(startValue + tolerance);
+        }
+        int x = startX;
+        int y = startY;
+        int seedX;                      // the first inside pixel
+        if (inside(x,y)) {              // find a border when coming from inside
+            seedX = x;                // (seedX, startY) is an inside pixel
+            do {x++;} while (inside(x,y));
+        } else {                        // find a border when coming from outside (thresholded only)
+            do {
+                x++;
+                if (x>=width) return;   // no border found
+            } while (!inside(x,y));
+            seedX = x;
+        }
+        boolean fourConnected;
+        if (legacyMode)
+            fourConnected = !thresholdMode && !(isLine(x, y));
+        else
+            fourConnected = (mode & FOUR_CONNECTED) != 0;
+        //now, we have a border between (x-1, y) and (x,y)
+        boolean first = true;
+        while (true) {                  // loop until we have not traced an inner hole
+            boolean insideSelected = traceEdge(x, y, fourConnected);
+            if (legacyMode) return;     // in legacy mode, don't care what we have got
+            if (insideSelected) {       // not an inner hole
+                if (first) return;      // started at seed, so we got it (sucessful)
+                if (xmin<=seedX) {      // possibly the correct particle
+                    Polygon poly = new Polygon(xpoints, ypoints, npoints);
+                    if (poly.contains(seedX, startY))
+                        return;         // successful, particle contains seed
+                }
+            }
+            first = false;
+            // we have traced an inner hole or the wrong particle
+            if (!inside(x,y)) do {
+                x++;                    // traverse the hole
+                if (x>width) throw new RuntimeException("Wand Malfunction"); //should never happen
+            } while (!inside(x,y));
+            do {x++;} while (inside(x,y)); //retry here; maybe no inner hole any more
+        }
+    }
+
+
+    /* Trace the outline, starting at a point (startX, startY). 
+     * Pixel (startX-1, startY) must be outside, (startX, startY) must be inside,
+     * or reverse. Otherwise an endless loop will occur (and eat up all memory).
+     * Traces 8-connected inside pixels unless fourConnected is true.
+     * Returns whether the selection created encloses an 'inside' area
+     * and not an inner hole.
+     */
+    private boolean traceEdge(int startX, int startY, boolean fourConnected) {
+        // Let us name the crossings between 4 pixels vertices, then the
+        // vertex (x,y) marked with '+', is between pixels (x-1, y-1) and (x,y):
+        //
+        //    pixel    x-1    x
+        //      y-1        |
+        //             ----+----
+        //       y         |
+        //
+        // The four principal directions are numbered such that the direction
+        // number * 90 degrees gives the angle in the mathematical sense; and
+        // the directions to the adjacent pixels (for inside(x,y,direction) are
+        // at (number * 90 - 45) degrees:
+        //      walking                     pixel
+        //   directions:   1           directions:     2 | 1
+        //              2  +  0                      ----+----
+        //                 3                           3 | 0
+        //
+        // Directions, like angles, are cyclic; direction -1 = direction 3, etc.
+        //
+        // The algorithm: We walk along the border, from one vertex to the next,
+        // with the outside pixels always being at the left-hand side.
+        // For 8-connected tracing, we always trying to turn left as much as
+        // possible, to encompass an area as large as possible.
+        // Thus, when walking in direction 1 (up, -y), we start looking
+        // at the pixel in direction 2; if it is inside, we proceed in this
+        // direction (left); otherwise we try with direction 1 (up); if pixel 1
+        // is not inside, we must proceed in direction 0 (right).
+        //
+        //                     2 | 1                 (i=inside, o=outside)
+        //      direction 2 < ---+---- > direction 0
+        //                     o | i
+        //                       ^ direction 1 = up = starting direction
+        //
+        // For 4-connected pixels, we try to go right as much as possible:
+        // First try with pixel 1; if it is outside we go in direction 0 (right).
+        // Otherwise, we examine pixel 2; if it is outside, we go in
+        // direction 1 (up); otherwise in direction 2 (left).
+        //
+        // When moving a closed loop, 'direction' gets incremented or decremented
+        // by a total of 360 degrees (i.e., 4) for counterclockwise and clockwise
+        // loops respectively. As the inside pixels are at the right side, we have
+        // got an outline of inner pixels after a cw loop (direction decremented
+        // by 4).
+        //
+        npoints = 0;
+        xmin = width;
+        final int startDirection;
+        if (inside(startX,startY))      // inside at left, outside right
+            startDirection = 1;         // starting in direction 1 = up
+        else {
+            startDirection = 3;         // starting in direction 3 = down
+            startY++;                   // continue after the boundary that has direction 3
+        }
+        int x = startX;
+        int y = startY;
+        int direction = startDirection;
+        do {
+            int newDirection;
+            if (fourConnected) {
+                newDirection = direction;
+                do {
+                    if (!inside(x, y, newDirection)) break;
+                    newDirection++;
+                } while (newDirection < direction+2);
+                newDirection--;
+            } else { // 8-connected
+                newDirection = direction + 1;
+                do {
+                if (inside(x, y, newDirection)) break;
+                    newDirection--;
+                } while (newDirection >= direction);
+            }
+            if (allPoints || newDirection!=direction)
+                addPoint(x,y);          // a corner point of the outline polygon: add to list
+            switch (newDirection & 3) { // '& 3' is remainder modulo 4
+                case 0: x++; break;
+                case 1: y--; break;
+                case 2: x--; break;
+                case 3: y++; break;
+            }
+            direction = newDirection;
+        } while (x!=startX || y!=startY || (direction&3)!=startDirection);
+        if (xpoints[0]!=x && !allPoints)            // if the start point = end point is a corner: add to list
+            addPoint(x, y);
+        return (direction <= 0);        // if we have done a clockwise loop, inside pixels are enclosed
+    }
+
+    // add a point x,y to the outline polygon
+    private void addPoint (int x, int y) {
+        if (npoints==maxPoints) {
+            int[] xtemp = new int[maxPoints*2];
+            int[] ytemp = new int[maxPoints*2];
+            System.arraycopy(xpoints, 0, xtemp, 0, maxPoints);
+            System.arraycopy(ypoints, 0, ytemp, 0, maxPoints);
+            xpoints = xtemp;
+            ypoints = ytemp;
+            maxPoints *= 2;
+        }
+        xpoints[npoints] = x;
+        ypoints[npoints] = y;
+        npoints++;
+        if (xmin > x) xmin = x;
+    }
+
+    // check pixel at (x,y), whether it is inside traced area
+    private boolean inside(int x, int y) {
+        if (x<0 || x>=width || y<0 || y>=height)
+            return false;
+        float value = getPixel(x, y);
+        return value>=lowerThreshold && value<=upperThreshold;
+    }
+
+    // check pixel in a given direction from vertex (x,y)
+    private boolean inside(int x, int y, int direction) {
+        switch(direction & 3) {         // '& 3' is remainder modulo 4
+            case 0: return inside(x, y);
+            case 1: return inside(x, y-1);
+            case 2: return inside(x-1, y-1);
+            case 3: return inside(x-1, y);
+        }
+        return false; //will never occur, needed for the compiler
+    }
+
+    // get a pixel value; returns Float.NaN if outside the field.
+    private float getPixel(int x, int y) {
+        if (x<0 || x>=width || y<0 || y>=height)
+            return Float.NaN;
+        if (bpixels!=null)
+            return bpixels[y*width + x] & 0xff;
+        else if (spixels!=null)
+            return spixels[y*width + x] & 0xffff;
+        else if (fpixels!=null)
+            return fpixels[y*width + x];
+        else if (exactPixelValue)   //RGB for exact match
+            return cpixels[y*width + x] & 0xffffff; //don't care for upper byte
+        else                      //gray value of RGB
+            return ip.getPixelValue(x,y);
+    }
+
+    /* Are we tracing a one pixel wide line? Makes Legacy mode 8-connected instead of 4-connected */
+    private boolean isLine(int xs, int ys) {
+        int r = 5;
+        int xmin=xs;
+        int xmax=xs+2*r;
+        if (xmax>=width) xmax=width-1;
+        int ymin=ys-r;
+        if (ymin<0) ymin=0;
+        int ymax=ys+r;
+        if (ymax>=height) ymax=height-1;
+        int area = 0;
+        int insideCount = 0;
+        for (int x=xmin; (x<=xmax); x++)
+            for (int y=ymin; y<=ymax; y++) {
+                area++;
+                if (inside(x,y))
+                    insideCount++;
+            }
+        if (IJ.debugMode)
+            IJ.log((((double)insideCount)/area<0.25?"line ":"blob ")+insideCount+" "+area+" "+IJ.d2s(((double)insideCount)/area));
+        return ((double)insideCount)/area<0.25;
+    }
+
+    /** Set 'true' and output will contain intermediate points for straight lines longer than one pixel. */
+    public static void setAllPoints(boolean b) {
+        allPoints = b;
+    }
+
+	/** Returns 'true' if output contains intermediate points for straight lines longer than one pixel. */
+	public static boolean allPoints() {
+		return allPoints;
+	}
+
+}
diff --git a/src/ij/gui/YesNoCancelDialog.java b/src/ij/gui/YesNoCancelDialog.java
new file mode 100644
index 0000000..7f7e79b
--- /dev/null
+++ b/src/ij/gui/YesNoCancelDialog.java
@@ -0,0 +1,138 @@
+package ij.gui;
+import ij.*;
+import java.awt.*;
+import java.awt.event.*;
+
+/** A modal dialog box with a one line message and
+	"Yes", "No" and "Cancel" buttons. */
+public class YesNoCancelDialog extends Dialog implements ActionListener, KeyListener, WindowListener {
+    private Button yesB, noB, cancelB;
+    private boolean cancelPressed, yesPressed;
+	private boolean firstPaint = true;
+
+	public YesNoCancelDialog(Frame parent, String title, String msg) {
+		this(parent, title, msg, "  Yes  ", "  No  ");
+	}
+
+	public YesNoCancelDialog(Frame parent, String title, String msg, String yesLabel, String noLabel) {
+		super(parent, title, true);
+		setLayout(new BorderLayout());
+		Panel panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.LEFT, 10, 10));
+		MultiLineLabel message = new MultiLineLabel(msg);
+		message.setFont(new Font("Dialog", Font.PLAIN, 14));
+		panel.add(message);
+		add("North", panel);
+		
+		panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.RIGHT, 15, 8));
+		if (msg.startsWith("Save")) {
+			yesB = new Button("  Save  ");
+			noB = new Button("Don't Save");
+			cancelB = new Button("  Cancel  ");
+		} else {
+			yesB = new Button(yesLabel);
+			noB = new Button(noLabel);
+			cancelB = new Button(" Cancel ");
+		}
+		yesB.addActionListener(this);
+		noB.addActionListener(this);
+		cancelB.addActionListener(this);
+		yesB.addKeyListener(this);
+		noB.addKeyListener(this);
+		cancelB.addKeyListener(this);
+		if (IJ.isWindows() || Prefs.dialogCancelButtonOnRight) {
+			panel.add(yesB);
+			panel.add(noB);
+			panel.add(cancelB);
+		} else {
+			panel.add(noB);
+			panel.add(cancelB);
+			panel.add(yesB);
+		}
+		if (IJ.isMacintosh())
+			setResizable(false);
+		add("South", panel);
+		addWindowListener(this);
+		GUI.scale(this);
+		pack();
+		yesB.requestFocusInWindow();
+		GUI.centerOnImageJScreen(this);
+		show();
+	}
+    
+	public void actionPerformed(ActionEvent e) {
+		if (e.getSource()==cancelB)
+			cancelPressed = true;
+		else if (e.getSource()==yesB)
+			yesPressed = true;
+		closeDialog();
+	}
+	
+	/** Returns true if the user dismissed dialog by pressing "Cancel". */
+	public boolean cancelPressed() {
+		return cancelPressed;
+	}
+
+	/** Returns true if the user dismissed dialog by pressing "Yes". */
+	public boolean yesPressed() {
+		return yesPressed;
+	}
+	
+	void closeDialog() {
+		dispose();
+	}
+
+	public void keyPressed(KeyEvent e) { 
+		int keyCode = e.getKeyCode(); 
+		IJ.setKeyDown(keyCode); 
+		if (keyCode==KeyEvent.VK_ENTER) {
+			if (cancelB.isFocusOwner()) {
+				cancelPressed = true; 
+				closeDialog(); 
+			} else if (noB.isFocusOwner()) {
+				closeDialog(); 
+			} else {
+				yesPressed = true;
+				closeDialog(); 
+			}
+		} else if (keyCode==KeyEvent.VK_Y||keyCode==KeyEvent.VK_S) {
+			yesPressed = true;
+			closeDialog(); 
+		} else if (keyCode==KeyEvent.VK_N || keyCode==KeyEvent.VK_D) {
+			closeDialog(); 
+		} else if (keyCode==KeyEvent.VK_ESCAPE||keyCode==KeyEvent.VK_C) { 
+			cancelPressed = true; 
+			closeDialog(); 
+			IJ.resetEscape();
+		} 
+	} 
+
+	public void keyReleased(KeyEvent e) {
+		int keyCode = e.getKeyCode(); 
+		IJ.setKeyUp(keyCode); 
+	}
+	
+	public void keyTyped(KeyEvent e) {}
+
+    public void paint(Graphics g) {
+    	super.paint(g);
+      	if (firstPaint) {
+    		yesB.requestFocus();
+    		firstPaint = false;
+    	}
+    }
+
+	public void windowClosing(WindowEvent e) {
+		cancelPressed = true; 
+		closeDialog(); 
+	}
+    
+	public void windowActivated(WindowEvent e) {}
+	public void windowOpened(WindowEvent e) {}
+	public void windowClosed(WindowEvent e) {}
+	public void windowIconified(WindowEvent e) {}
+	public void windowDeiconified(WindowEvent e) {}
+	public void windowDeactivated(WindowEvent e) {}
+	
+}
diff --git a/src/ij/io/BitBuffer.java b/src/ij/io/BitBuffer.java
new file mode 100644
index 0000000..18832e3
--- /dev/null
+++ b/src/ij/io/BitBuffer.java
@@ -0,0 +1,65 @@
+package ij.io;
+
+/**
+ * A class for reading arbitrary numbers of bits from a byte array.
+ * @author Eric Kjellman egkjellman at wisc.edu
+ */
+public class BitBuffer {
+
+	private int currentByte;
+	private int currentBit;
+	private byte[] byteBuffer;
+	private int eofByte;
+	private int[] backMask;
+	private int[] frontMask;
+	private boolean eofFlag;
+
+	public BitBuffer(byte[] byteBuffer) {
+		this.byteBuffer = byteBuffer;
+		currentByte = 0;
+		currentBit = 0;
+		eofByte = byteBuffer.length;
+		backMask = new int[] {0x0000, 0x0001, 0x0003, 0x0007,
+			0x000F, 0x001F, 0x003F, 0x007F};
+		frontMask = new int[] {0x0000, 0x0080, 0x00C0, 0x00E0,
+			0x00F0, 0x00F8, 0x00FC, 0x00FE};
+	}
+
+	public int getBits(int bitsToRead) {
+		if (bitsToRead == 0)
+			return 0;
+		if (eofFlag)
+			return -1; // Already at end of file
+		int toStore = 0;
+		while(bitsToRead != 0  && !eofFlag) {
+			if (bitsToRead >= 8 - currentBit) {
+				if (currentBit == 0) { // special
+					toStore = toStore << 8;
+					int cb = ((int) byteBuffer[currentByte]);
+					toStore += (cb<0 ? (int) 256 + cb : (int) cb);
+					bitsToRead -= 8;
+					currentByte++;
+				} else {
+					toStore = toStore << (8 - currentBit);
+					toStore += ((int) byteBuffer[currentByte]) & backMask[8 - currentBit];
+					bitsToRead -= (8 - currentBit);
+					currentBit = 0;
+					currentByte++;
+				}
+			} else {
+				toStore = toStore << bitsToRead;
+				int cb = ((int) byteBuffer[currentByte]);
+				cb = (cb<0 ? (int) 256 + cb : (int) cb);
+				toStore += ((cb) & (0x00FF - frontMask[currentBit])) >> (8 - (currentBit + bitsToRead));
+				currentBit += bitsToRead;
+				bitsToRead = 0;
+			}
+			if (currentByte == eofByte) {
+				eofFlag = true;
+				return toStore;
+			}
+		}
+		return toStore;
+	}
+
+}
diff --git a/src/ij/io/DirectoryChooser.java b/src/ij/io/DirectoryChooser.java
new file mode 100644
index 0000000..f2944ad
--- /dev/null
+++ b/src/ij/io/DirectoryChooser.java
@@ -0,0 +1,137 @@
+package ij.io;
+import ij.*;
+import ij.gui.*;
+import ij.plugin.frame.Recorder;
+import ij.util.Java2;
+import java.awt.*;
+import java.io.*;
+import javax.swing.*;
+import javax.swing.filechooser.*;
+
+/** This class displays a dialog box that allows the user can select a directory. */ 
+ public class DirectoryChooser {
+ 	private String directory;
+ 	private String title;
+ 
+ 	/** Display a dialog using the specified title. */
+ 	public DirectoryChooser(String title) {
+ 		this.title = title;
+		if (IJ.isMacOSX() && !Prefs.useJFileChooser)
+			getDirectoryUsingFileDialog(title);
+ 		else {
+			String macroOptions = Macro.getOptions();
+			if (macroOptions!=null)
+				directory = Macro.getValue(macroOptions, title, null);
+			if (directory==null) {
+ 				if (EventQueue.isDispatchThread())
+ 					getDirectoryUsingJFileChooserOnThisThread(title);
+ 				else
+ 					getDirectoryUsingJFileChooser(title);
+ 			}
+ 		}
+ 	}
+ 	
+	// runs JFileChooser on event dispatch thread to avoid possible thread deadlocks
+ 	void getDirectoryUsingJFileChooser(final String title) {
+		Java2.setSystemLookAndFeel();
+		try {
+			EventQueue.invokeAndWait(new Runnable() {
+				public void run() {
+					JFileChooser chooser = new JFileChooser();
+					chooser.setDialogTitle(title);
+					chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+					chooser.setDragEnabled(true);
+					chooser.setTransferHandler(new DragAndDropHandler(chooser));
+					String defaultDir = OpenDialog.getDefaultDirectory();
+					if (defaultDir!=null) {
+						File f = new File(defaultDir);
+						if (IJ.debugMode)
+							IJ.log("DirectoryChooser,setSelectedFileW: "+f);
+						chooser.setSelectedFile(f);
+					}
+					chooser.setApproveButtonText("Select");
+					if (chooser.showOpenDialog(null)==JFileChooser.APPROVE_OPTION) {
+						File file = chooser.getSelectedFile();
+						directory = file.getAbsolutePath();
+						directory = IJ.addSeparator(directory);
+						OpenDialog.setDefaultDirectory(directory);
+					}
+				}
+			});
+		} catch (Exception e) {}
+	}
+ 
+	// Choose a directory using JFileChooser on the current thread
+ 	void getDirectoryUsingJFileChooserOnThisThread(final String title) {
+		Java2.setSystemLookAndFeel();
+		try {
+			JFileChooser chooser = new JFileChooser();
+			chooser.setDialogTitle(title);
+			chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
+			chooser.setDragEnabled(true);
+			chooser.setTransferHandler(new DragAndDropHandler(chooser));
+			String defaultDir = OpenDialog.getDefaultDirectory();
+			if (defaultDir!=null) {
+				File f = new File(defaultDir);
+				if (IJ.debugMode)
+					IJ.log("DirectoryChooser,setSelectedFile: "+f);
+				chooser.setSelectedFile(f);
+			}
+			chooser.setApproveButtonText("Select");
+			if (chooser.showOpenDialog(null)==JFileChooser.APPROVE_OPTION) {
+				File file = chooser.getSelectedFile();
+				directory = file.getAbsolutePath();
+				directory = IJ.addSeparator(directory);
+				OpenDialog.setDefaultDirectory(directory);
+			}
+		} catch (Exception e) {}
+	}
+
+ 	// On Mac OS X, we can select directories using the native file open dialog
+ 	void getDirectoryUsingFileDialog(String title) {
+ 		boolean saveUseJFC = Prefs.useJFileChooser;
+ 		Prefs.useJFileChooser = false;
+		System.setProperty("apple.awt.fileDialogForDirectories", "true");
+		String dir=null, name=null;
+		String defaultDir = OpenDialog.getDefaultDirectory();
+		if (defaultDir!=null) {
+			File f = new File(defaultDir);
+			dir = f.getParent();
+			name = f.getName();
+		}
+		if (IJ.debugMode)
+			IJ.log("DirectoryChooser: dir=\""+dir+"\",  file=\""+name+"\"");
+		OpenDialog od = new OpenDialog(title, dir, null);
+		String odDir = od.getDirectory();
+		if (odDir==null)
+			directory = null;
+		else {
+			directory = odDir + od.getFileName() + "/";
+			OpenDialog.setDefaultDirectory(directory);
+		}
+		System.setProperty("apple.awt.fileDialogForDirectories", "false");
+ 		Prefs.useJFileChooser = saveUseJFC;
+	}
+
+ 	/** Returns the directory selected by the user. */
+ 	public String getDirectory() {
+		if (IJ.debugMode)
+			IJ.log("DirectoryChooser.getDirectory: "+directory);
+		if (Recorder.record && !IJ.isMacOSX())
+			Recorder.recordPath(title, directory);
+ 		return directory;
+ 	}
+ 	
+    /** Sets the default directory presented in the dialog. */
+    public static void setDefaultDirectory(String dir) {
+    	if (dir==null || (new File(dir)).isDirectory())
+			OpenDialog.setDefaultDirectory(dir);
+    }
+
+	//private void setSystemLookAndFeel() {
+	//	try {
+	//		UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+	//	} catch(Throwable t) {}
+	//}
+
+}
diff --git a/src/ij/io/DragAndDropHandler.java b/src/ij/io/DragAndDropHandler.java
new file mode 100644
index 0000000..d14227f
--- /dev/null
+++ b/src/ij/io/DragAndDropHandler.java
@@ -0,0 +1,95 @@
+package ij.io;
+import ij.*;
+import ij.gui.*;
+import ij.plugin.frame.Recorder;
+import ij.util.Java2;
+import java.awt.*;
+import java.io.*;
+import java.util.ArrayList; //no  need to import java.util.List; it would be ambiguous because of java.awt.List
+import java.net.URI;
+import java.net.URISyntaxException;
+import javax.swing.*;
+import javax.swing.filechooser.*;
+import java.awt.datatransfer.*;
+
+/** This class handles drag&drop onto JFileChoosers. */ 
+ public class DragAndDropHandler extends TransferHandler {
+ 	private JFileChooser jFileChooser;
+ 
+	/** Given a JFileChooser 'fc', this is how to use this class:
+	 * <pre>
+	 *     fc.setDragEnabled(true);
+	 *     fc.setTransferHandler(new DragAndDropHandler(fc));
+	 * </pre>
+	 */
+ 	public DragAndDropHandler(JFileChooser jFileChooser) {
+		super();
+		this.jFileChooser = jFileChooser;
+ 	}
+
+	/** Returns whether any of the transfer flavors is supported */
+	public boolean canImport(JComponent comp, DataFlavor[] transferFlavors) {
+		for (DataFlavor dataFlavor : transferFlavors) {
+			if (isSupportedTransferFlavor(dataFlavor))
+				return true;
+			}
+		return false;
+	}
+
+	/** Imports the drag&drop file or list of files and sets the JFileChooser to this. 
+	 *  Returns true if successful */
+	public boolean importData(JComponent comp, Transferable t) {
+		DataFlavor[] transferFlavors = t.getTransferDataFlavors();
+		for (DataFlavor dataFlavor : transferFlavors) {
+			try {
+				java.util.List<File> fileList = null;
+				if (dataFlavor.isFlavorJavaFileListType()) {
+					fileList = (java.util.List<File>)t.getTransferData(DataFlavor.javaFileListFlavor);
+					if (IJ.debugMode) IJ.log("dragAndDrop FileList size="+fileList.size()+" first: "+fileList.get(0));
+				} else if (isSupportedTransferFlavor(dataFlavor)) {
+					String str = (String)t.getTransferData(dataFlavor);
+					if (IJ.debugMode) IJ.log("dragAndDrop str="+str);
+					String[] strs = str.split("[\n\r]+");               //multiple files are separate lines
+					fileList = new ArrayList<File>(strs.length);
+					for (String s : strs) {
+						if (s.length() > 0) {
+							File file = new File(s);                    //Try whether it is a plain path (pointing to an existing file)
+							if (!file.exists()) try {
+								file = new File(new URI(s));            //When not successful, try a whether it is a URL, e.g. file:///absolute/path/to/file
+							} catch (URISyntaxException e) {continue;}
+							if (file.exists())                          //We only accept drag&drop of existing files
+								fileList.add(file);
+						}
+					}
+				}
+				if (fileList == null || fileList.size() ==0) continue;  //this data flavor did not work
+
+				File firstFile = fileList.get(0);
+				if (jFileChooser.isMultiSelectionEnabled()) {   //multiple files accepted
+					File dir = firstFile.getParentFile();
+					jFileChooser.setCurrentDirectory(dir);
+					File[] files = fileList.toArray(new File[0]);
+					jFileChooser.setSelectedFiles(files);
+				} else {
+					File file = firstFile;                      //single file required; if we get more take the first one
+					if (jFileChooser.getFileSelectionMode() == JFileChooser.DIRECTORIES_ONLY && !file.isDirectory())
+						file = file.getParentFile();            //if a directory is required and we get a file, use its directory
+					if (jFileChooser.getDialogType() == JFileChooser.SAVE_DIALOG && file.isDirectory())
+						jFileChooser.setCurrentDirectory(file); //in a save operation, if we get a directory, move there
+					else
+						jFileChooser.setSelectedFile(file);
+				}
+				jFileChooser.rescanCurrentDirectory();
+				return true;
+			} catch (Exception e) {if (IJ.debugMode) IJ.handleException(e);}
+		}
+		return false;
+	}
+
+	/** Returns whether this transfer flavor is supported. We support File Lists and Strings (plain or as list of URLs). */
+	public boolean isSupportedTransferFlavor(DataFlavor flavor) {
+		return flavor.isFlavorJavaFileListType() ||
+				(flavor.getRepresentationClass() == String.class &&
+				(flavor.getMimeType().startsWith("text/uri-list") || flavor.getMimeType().startsWith("text/plain")));
+	}
+}
diff --git a/src/ij/io/FileInfo.java b/src/ij/io/FileInfo.java
new file mode 100644
index 0000000..f2f303d
--- /dev/null
+++ b/src/ij/io/FileInfo.java
@@ -0,0 +1,270 @@
+package ij.io;
+import ij.VirtualStack;
+import ij.IJ;
+import java.io.*;
+import java.util.Properties;
+
+/** This class consists of public fields that describe an image file. */
+public class FileInfo implements Cloneable {
+
+	/** 8-bit unsigned integer (0-255). */
+	public static final int GRAY8 = 0;
+	
+	/**	16-bit signed integer (-32768-32767). Imported signed images
+		are converted to unsigned by adding 32768. */
+	public static final int GRAY16_SIGNED = 1;
+	
+	/** 16-bit unsigned integer (0-65535). */
+	public static final int GRAY16_UNSIGNED = 2;
+	
+	/**	32-bit signed integer. Imported 32-bit integer images are
+		converted to floating-point. */
+	public static final int GRAY32_INT = 3;
+	
+	/** 32-bit floating-point. */
+	public static final int GRAY32_FLOAT = 4;
+	
+	/** 8-bit unsigned integer with color lookup table. */
+	public static final int COLOR8 = 5;
+	
+	/** 24-bit interleaved RGB. Import/export only. */
+	public static final int RGB = 6;	
+	
+	/** 24-bit planer RGB. Import only. */
+	public static final int RGB_PLANAR = 7;
+	
+	/** 1-bit black and white. Import only. */
+	public static final int BITMAP = 8;
+	
+	/** 32-bit interleaved ARGB. Import only. */
+	public static final int ARGB = 9;
+	
+	/** 24-bit interleaved BGR. Import only. */
+	public static final int BGR = 10;
+	
+	/**	32-bit unsigned integer. Imported 32-bit integer images are
+		converted to floating-point. */
+	public static final int GRAY32_UNSIGNED = 11;
+	
+	/** 48-bit interleaved RGB. */
+	public static final int RGB48 = 12;	
+
+	/** 12-bit unsigned integer (0-4095). Import only. */
+	public static final int GRAY12_UNSIGNED = 13;	
+
+	/** 24-bit unsigned integer. Import only. */
+	public static final int GRAY24_UNSIGNED = 14;	
+
+	/** 32-bit interleaved BARG (MCID). Import only. */
+	public static final int BARG  = 15;	
+
+	/** 64-bit floating-point. Import only.*/
+	public static final int GRAY64_FLOAT  = 16;	
+
+	/** 48-bit planar RGB. Import only. */
+	public static final int RGB48_PLANAR = 17;	
+
+	/** 32-bit interleaved ABGR. Import only. */
+	public static final int ABGR = 18;
+
+	/** 32-bit interleaved CMYK. Import only. */
+	public static final int CMYK = 19;
+
+	// File formats
+	public static final int UNKNOWN = 0;
+	public static final int RAW = 1;
+	public static final int TIFF = 2;
+	public static final int GIF_OR_JPG = 3;
+	public static final int FITS = 4;
+	public static final int BMP = 5;
+	public static final int DICOM = 6;
+	public static final int ZIP_ARCHIVE = 7;
+	public static final int PGM = 8;
+	public static final int IMAGEIO = 9;
+
+	// Compression modes
+	public static final int COMPRESSION_UNKNOWN = 0;
+	public static final int COMPRESSION_NONE= 1;
+	public static final int LZW = 2;
+	public static final int LZW_WITH_DIFFERENCING = 3;
+	public static final int JPEG = 4;
+	public static final int PACK_BITS = 5;
+	public static final int ZIP = 6;
+	
+	/* File format (TIFF, GIF_OR_JPG, BMP, etc.). Used by the File/Revert command */
+	public int fileFormat;
+	
+	/* File type (GRAY8, GRAY_16_UNSIGNED, RGB, etc.) */
+	public int fileType;	
+	public String fileName;
+	public String directory;
+	public String url;
+    public int width;
+    public int height;
+    public int offset=0;  // Use getOffset() to read
+    public int nImages;
+    public int gapBetweenImages;   // Use getGap() to read
+    public boolean whiteIsZero;
+    public boolean intelByteOrder;
+	public int compression;
+    public int[] stripOffsets; 
+    public int[] stripLengths;
+    public int rowsPerStrip;
+	public int lutSize;
+	public byte[] reds;
+	public byte[] greens;
+	public byte[] blues;
+	public Object pixels;	
+	public String debugInfo;
+	public String[] sliceLabels;
+	public String info;
+	public InputStream inputStream;
+	public VirtualStack virtualStack;
+	public int sliceNumber; // used by FileInfoVirtualStack
+	
+	public double pixelWidth=1.0;
+	public double pixelHeight=1.0;
+	public double pixelDepth=1.0;
+	public String unit;
+	public int calibrationFunction;
+	public double[] coefficients;
+	public String valueUnit;
+	public double frameInterval;
+	public String description;
+	// Use <i>longOffset</i> instead of <i>offset</i> when offset>2147483647.
+	public long longOffset;  // Use getOffset() to read
+	// Use <i>longGap</i> instead of <i>gapBetweenImages</i> when gap>2147483647.
+	public long longGap;  // Use getGap() to read
+	// Extra metadata to be stored in the TIFF header
+	public int[] metaDataTypes; // must be < 0xffffff
+	public byte[][] metaData;
+	public double[] displayRanges;
+	public byte[][] channelLuts;
+	public byte[] plot;			// serialized plot
+	public byte[] roi;			// serialized roi
+	public byte[][] overlay;	// serialized overlay objects
+	public int samplesPerPixel;
+	public String openNextDir, openNextName;
+	public String[] properties; // {key,value,key,value,...}
+	public boolean imageSaved;
+    
+	/** Creates a FileInfo object with all of its fields set to their default value. */
+     public FileInfo() {
+    	// assign default values
+    	fileFormat = UNKNOWN;
+    	fileType = GRAY8;
+    	fileName = "Untitled";
+    	directory = "";
+    	url = "";
+	    nImages = 1;
+		compression = COMPRESSION_NONE;
+		samplesPerPixel = 1;
+    }
+    
+     /** Returns the file path. */
+	public String getFilePath() {
+		String dir = directory;
+		if (dir==null)
+			dir = "";
+		dir = IJ.addSeparator(dir);
+		return dir + fileName;
+	}
+
+   /** Returns the offset as a long. */
+    public final long getOffset() {
+    	return longOffset>0L?longOffset:((long)offset)&0xffffffffL;
+    }
+    
+    /** Returns the gap between images as a long. */
+    public final long getGap() {
+    	return longGap>0L?longGap:((long)gapBetweenImages)&0xffffffffL;
+    }
+
+	/** Returns the number of bytes used per pixel. */
+	public int getBytesPerPixel() {
+		switch (fileType) {
+			case GRAY8: case COLOR8: case BITMAP: return 1;
+			case GRAY16_SIGNED: case GRAY16_UNSIGNED: return 2;
+			case GRAY32_INT: case GRAY32_UNSIGNED: case GRAY32_FLOAT: case ARGB: case GRAY24_UNSIGNED: case BARG: case ABGR: case CMYK: return 4;
+			case RGB: case RGB_PLANAR: case BGR: return 3;
+			case RGB48: case RGB48_PLANAR: return 6;
+			case GRAY64_FLOAT : return 8;
+			default: return 0;
+		}
+	}
+
+    public String toString() {
+    	return
+    		"name=" + fileName
+			+ ", dir=" + directory
+			+ ", width=" + width
+			+ ", height=" + height
+			+ ", nImages=" + nImages
+			+ ", offset=" + getOffset()
+			+ ", gap=" + getGap()
+			+ ", type=" + getType()
+			+ ", byteOrder=" + (intelByteOrder?"little":"big")
+			+ ", format=" + fileFormat
+			+ ", url=" + url
+			+ ", whiteIsZero=" + (whiteIsZero?"t":"f")
+			+ ", lutSize=" + lutSize
+			+ ", comp=" + compression
+			+ ", ranges=" + (displayRanges!=null?""+displayRanges.length/2:"null")
+			+ ", samples=" + samplesPerPixel;
+    }
+    
+    /** Returns JavaScript code that can be used to recreate this FileInfo. */
+    public String getCode() {
+    	String code = "fi = new FileInfo();\n";
+    	String type = null;
+    	if (fileType==GRAY8)
+    		type = "GRAY8";
+    	else if (fileType==GRAY16_UNSIGNED)
+    		type = "GRAY16_UNSIGNED";
+    	else if (fileType==GRAY32_FLOAT)
+    		type = "GRAY32_FLOAT";
+    	else if (fileType==RGB)
+    		type = "RGB";
+    	if (type!=null)
+    		code += "fi.fileType = FileInfo."+type+";\n"; 
+    	code += "fi.width = "+width+";\n";
+    	code += "fi.height = "+height+";\n";
+    	if (nImages>1)
+			code += "fi.nImages = "+nImages+";\n";  	
+    	if (getOffset()>0)
+			code += "fi.longOffset = "+getOffset()+";\n";  	
+    	if (intelByteOrder)
+			code += "fi.intelByteOrder = true;\n";  	
+    	return code;
+    }
+
+    private String getType() {
+    	switch (fileType) {
+			case GRAY8: return "byte";
+			case GRAY16_SIGNED: return "short";
+			case GRAY16_UNSIGNED: return "ushort";
+			case GRAY32_INT: return "int";
+			case GRAY32_UNSIGNED: return "uint";
+			case GRAY32_FLOAT: return "float";
+			case COLOR8: return "byte(lut)";
+			case RGB: return "RGB";
+			case RGB_PLANAR: return "RGB(p)";
+			case RGB48: return "RGB48";
+			case BITMAP: return "bitmap";
+			case ARGB: return "ARGB";
+			case ABGR: return "ABGR";
+			case BGR: return "BGR";
+			case BARG: return "BARG";
+			case CMYK: return "CMYK";
+			case GRAY64_FLOAT: return "double";
+			case RGB48_PLANAR: return "RGB48(p)";
+			default: return "";
+    	}
+    }
+
+	public synchronized Object clone() {
+		try {return super.clone();}
+		catch (CloneNotSupportedException e) {return null;}
+	}
+
+}
diff --git a/src/ij/io/FileOpener.java b/src/ij/io/FileOpener.java
new file mode 100644
index 0000000..202121a
--- /dev/null
+++ b/src/ij/io/FileOpener.java
@@ -0,0 +1,676 @@
+package ij.io;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.util.zip.GZIPInputStream;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.*;
+import ij.plugin.frame.*;
+
+/**
+ * Opens or reverts an image specified by a FileInfo object. Images can
+ * be loaded from either a file (directory+fileName) or a URL (url+fileName).
+ * Here is an example:	
+ * <pre>
+ *   public class FileInfo_Test implements PlugIn {
+ *     public void run(String arg) {
+ *       FileInfo fi = new FileInfo();
+ *       fi.width = 256;
+ *       fi.height = 254;
+ *       fi.offset = 768;
+ *       fi.fileName = "blobs.tif";
+ *       fi.directory = "/Users/wayne/Desktop/";
+ *       new FileOpener(fi).open();
+ *     }  
+ *   }	
+ * </pre> 
+ */
+public class FileOpener {
+
+	private FileInfo fi;
+	private int width, height;
+	private static boolean showConflictMessage = true;
+	private double minValue, maxValue;
+	private static boolean silentMode;
+
+	public FileOpener(FileInfo fi) {
+		this.fi = fi;
+		if (fi!=null) {
+			width = fi.width;
+			height = fi.height;
+		}
+		if (IJ.debugMode) IJ.log("FileInfo: "+fi);
+	}
+	
+	/** Opens the image and returns it has an ImagePlus object. */
+	public ImagePlus openImage() {
+		boolean wasRecording = Recorder.record;
+		Recorder.record = false;
+		ImagePlus imp = open(false);
+		Recorder.record = wasRecording;
+		return imp;
+	}
+
+	/** Opens the image and displays it. */
+	public void open() {
+		open(true);
+	}
+	
+	/** Obsolete, replaced by openImage() and open(). */
+	public ImagePlus open(boolean show) {
+
+		ImagePlus imp=null;
+		Object pixels;
+		ProgressBar pb=null;
+	    ImageProcessor ip;
+		
+		ColorModel cm = createColorModel(fi);
+		if (fi.nImages>1)
+			return openStack(cm, show);
+		switch (fi.fileType) {
+			case FileInfo.GRAY8:
+			case FileInfo.COLOR8:
+			case FileInfo.BITMAP:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+				ip = new ByteProcessor(width, height, (byte[])pixels, cm);
+    			imp = new ImagePlus(fi.fileName, ip);
+				break;
+			case FileInfo.GRAY16_SIGNED:
+			case FileInfo.GRAY16_UNSIGNED:
+			case FileInfo.GRAY12_UNSIGNED:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+	    		ip = new ShortProcessor(width, height, (short[])pixels, cm);
+       			imp = new ImagePlus(fi.fileName, ip);
+				break;
+			case FileInfo.GRAY32_INT:
+			case FileInfo.GRAY32_UNSIGNED:
+			case FileInfo.GRAY32_FLOAT:
+			case FileInfo.GRAY24_UNSIGNED:
+			case FileInfo.GRAY64_FLOAT:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+	    		ip = new FloatProcessor(width, height, (float[])pixels, cm);
+       			imp = new ImagePlus(fi.fileName, ip);
+				break;
+			case FileInfo.RGB:
+			case FileInfo.BGR:
+			case FileInfo.ARGB:
+			case FileInfo.ABGR:
+			case FileInfo.BARG:
+			case FileInfo.RGB_PLANAR:
+			case FileInfo.CMYK:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+				ip = new ColorProcessor(width, height, (int[])pixels);
+				if (fi.fileType==FileInfo.CMYK)
+					ip.invert();
+				imp = new ImagePlus(fi.fileName, ip);
+				break;
+			case FileInfo.RGB48:
+			case FileInfo.RGB48_PLANAR:
+				boolean planar = fi.fileType==FileInfo.RGB48_PLANAR;
+				Object[] pixelArray = (Object[])readPixels(fi);
+				if (pixelArray==null) return null;
+				int nChannels = 3;
+				ImageStack stack = new ImageStack(width, height);
+				stack.addSlice("Red", pixelArray[0]);
+				stack.addSlice("Green", pixelArray[1]);
+				stack.addSlice("Blue", pixelArray[2]);
+				if (fi.samplesPerPixel==4 && pixelArray.length==4) {
+					stack.addSlice("Gray", pixelArray[3]);
+					nChannels = 4;
+				}
+        		imp = new ImagePlus(fi.fileName, stack);
+        		imp.setDimensions(nChannels, 1, 1);
+        		if (planar)
+        			imp.getProcessor().resetMinAndMax();
+				imp.setFileInfo(fi);
+				int mode = IJ.COMPOSITE;
+				if (fi.description!=null) {
+					if (fi.description.indexOf("mode=color")!=-1)
+					mode = IJ.COLOR;
+					else if (fi.description.indexOf("mode=gray")!=-1)
+					mode = IJ.GRAYSCALE;
+				}
+        		imp = new CompositeImage(imp, mode);
+        		if (!planar && fi.displayRanges==null) {
+        			if (nChannels==4)
+        				((CompositeImage)imp).resetDisplayRanges();
+        			else {
+						for (int c=1; c<=3; c++) {
+							imp.setPosition(c, 1, 1);
+							imp.setDisplayRange(minValue, maxValue);
+						}
+						imp.setPosition(1, 1, 1);
+       				}
+        		}
+        		if (fi.whiteIsZero) // cmyk?
+        			IJ.run(imp, "Invert", "");
+				break;
+		}
+		imp.setFileInfo(fi);
+		setCalibration(imp);
+		if (fi.info!=null)
+			imp.setProperty("Info", fi.info);
+		if (fi.sliceLabels!=null&&fi.sliceLabels.length==1&&fi.sliceLabels[0]!=null)
+			imp.setProp("Slice_Label", fi.sliceLabels[0]);
+		if (fi.plot!=null) try {
+			Plot plot = new Plot(imp, new ByteArrayInputStream(fi.plot));
+			imp.setProperty(Plot.PROPERTY_KEY, plot);
+		} catch (Exception e) { IJ.handleException(e); }
+		if (fi.roi!=null)
+			decodeAndSetRoi(imp, fi);
+		if (fi.overlay!=null)
+			setOverlay(imp, fi.overlay);
+		if (fi.properties!=null)
+			imp.setProperties(fi.properties);
+		if (show) imp.show();
+		return imp;
+	}
+	
+	public ImageProcessor openProcessor() {
+		Object pixels;
+		ProgressBar pb=null;
+		ImageProcessor ip = null;		
+		ColorModel cm = createColorModel(fi);
+		switch (fi.fileType) {
+			case FileInfo.GRAY8:
+			case FileInfo.COLOR8:
+			case FileInfo.BITMAP:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+				ip = new ByteProcessor(width, height, (byte[])pixels, cm);
+				break;
+			case FileInfo.GRAY16_SIGNED:
+			case FileInfo.GRAY16_UNSIGNED:
+			case FileInfo.GRAY12_UNSIGNED:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+	    		ip = new ShortProcessor(width, height, (short[])pixels, cm);
+				break;
+			case FileInfo.GRAY32_INT:
+			case FileInfo.GRAY32_UNSIGNED:
+			case FileInfo.GRAY32_FLOAT:
+			case FileInfo.GRAY24_UNSIGNED:
+			case FileInfo.GRAY64_FLOAT:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+	    		ip = new FloatProcessor(width, height, (float[])pixels, cm);
+				break;
+			case FileInfo.RGB:
+			case FileInfo.BGR:
+			case FileInfo.ARGB:
+			case FileInfo.ABGR:
+			case FileInfo.BARG:
+			case FileInfo.RGB_PLANAR:
+			case FileInfo.CMYK:
+				pixels = readPixels(fi);
+				if (pixels==null) return null;
+				ip = new ColorProcessor(width, height, (int[])pixels);
+				if (fi.fileType==FileInfo.CMYK)
+					ip.invert();
+				break;
+		}
+		return ip;
+	}
+
+	void setOverlay(ImagePlus imp, byte[][] rois) {
+		Overlay overlay = new Overlay();
+		Overlay proto = null;
+		for (int i=0; i<rois.length; i++) {
+			Roi roi = RoiDecoder.openFromByteArray(rois[i]);
+			if (roi==null)
+				continue;
+			if (proto==null) {
+				proto = roi.getPrototypeOverlay();
+				overlay.drawLabels(proto.getDrawLabels());
+				overlay.drawNames(proto.getDrawNames());
+				overlay.drawBackgrounds(proto.getDrawBackgrounds());
+				overlay.setLabelColor(proto.getLabelColor());
+				overlay.setLabelFont(proto.getLabelFont(), proto.scalableLabels());
+			}
+			overlay.add(roi);
+		}
+		imp.setOverlay(overlay);
+	}
+
+	/** Opens a stack of images. */
+	ImagePlus openStack(ColorModel cm, boolean show) {
+		ImageStack stack = new ImageStack(fi.width, fi.height, cm);
+		long skip = fi.getOffset();
+		Object pixels;
+		try {
+			ImageReader reader = new ImageReader(fi);
+			InputStream is = createInputStream(fi);
+			if (is==null)
+				return null;
+			IJ.resetEscape();
+			for (int i=1; i<=fi.nImages; i++) {
+				if (!silentMode)
+					IJ.showStatus("Reading: " + i + "/" + fi.nImages);
+				if (IJ.escapePressed()) {
+					IJ.beep();
+					IJ.showProgress(1.0);
+					silentMode = false;
+					return null;
+				}
+				pixels = reader.readPixels(is, skip);
+				if (pixels==null)
+					break;
+				stack.addSlice(null, pixels);
+				skip = fi.getGap();
+				if (!silentMode)
+					IJ.showProgress(i, fi.nImages);
+			}
+			is.close();
+		}
+		catch (Exception e) {
+			IJ.log("" + e);
+		}
+		catch(OutOfMemoryError e) {
+			IJ.outOfMemory(fi.fileName);
+			stack.trim();
+		}
+		if (!silentMode) IJ.showProgress(1.0);
+		if (stack.size()==0)
+			return null;
+		if (fi.sliceLabels!=null && fi.sliceLabels.length<=stack.size()) {
+			for (int i=0; i<fi.sliceLabels.length; i++)
+				stack.setSliceLabel(fi.sliceLabels[i], i+1);
+		}
+		ImagePlus imp = new ImagePlus(fi.fileName, stack);
+		if (fi.info!=null)
+			imp.setProperty("Info", fi.info);
+		if (fi.roi!=null)
+			decodeAndSetRoi(imp, fi);
+		if (fi.overlay!=null)
+			setOverlay(imp, fi.overlay);
+		if (fi.properties!=null)
+			imp.setProperties(fi.properties);
+		if (show) imp.show();
+		imp.setFileInfo(fi);
+		setCalibration(imp);
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.getMin()==ip.getMax())  // find stack min and max if first slice is blank
+			setStackDisplayRange(imp);
+		if (!silentMode) IJ.showProgress(1.0);
+		return imp;
+	}
+	
+	private void decodeAndSetRoi(ImagePlus imp, FileInfo fi) {
+		Roi roi = RoiDecoder.openFromByteArray(fi.roi);
+		imp.setRoi(roi);
+		if ((roi instanceof PointRoi) && ((PointRoi)roi).getNCounters()>1) 
+			IJ.setTool("multi-point");
+	}
+
+	void setStackDisplayRange(ImagePlus imp) {
+		ImageStack stack = imp.getStack();
+		double min = Double.MAX_VALUE;
+		double max = -Double.MAX_VALUE;
+		int n = stack.size();
+		for (int i=1; i<=n; i++) {
+			if (!silentMode)
+				IJ.showStatus("Calculating stack min and max: "+i+"/"+n);
+			ImageProcessor ip = stack.getProcessor(i);
+			ip.resetMinAndMax();
+			if (ip.getMin()<min)
+				min = ip.getMin();
+			if (ip.getMax()>max)
+				max = ip.getMax();
+		}
+		imp.getProcessor().setMinAndMax(min, max);
+		imp.updateAndDraw();
+	}
+	
+	/** Restores the original version of the specified image. */
+	public void revertToSaved(ImagePlus imp) {
+		if (fi==null)
+			return;
+		String path = fi.getFilePath();
+		if (fi.url!=null && !fi.url.equals("") && (fi.directory==null||fi.directory.equals("")))
+			path = fi.url;
+		IJ.showStatus("Loading: " + path);
+		ImagePlus imp2 = null;
+		if (!path.endsWith(".raw"))
+			imp2 = IJ.openImage(path);
+		if (imp2!=null)
+			imp.setImage(imp2);
+		else {
+			if (fi.nImages>1)
+				return;
+			Object pixels = readPixels(fi);
+			if (pixels==null) return;
+			ColorModel cm = createColorModel(fi);
+			ImageProcessor ip = null;
+			switch (fi.fileType) {
+				case FileInfo.GRAY8:
+				case FileInfo.COLOR8:
+				case FileInfo.BITMAP:
+					ip = new ByteProcessor(width, height, (byte[])pixels, cm);
+					imp.setProcessor(null, ip);
+					break;
+				case FileInfo.GRAY16_SIGNED:
+				case FileInfo.GRAY16_UNSIGNED:
+				case FileInfo.GRAY12_UNSIGNED:
+					ip = new ShortProcessor(width, height, (short[])pixels, cm);
+					imp.setProcessor(null, ip);
+					break;
+				case FileInfo.GRAY32_INT:
+				case FileInfo.GRAY32_FLOAT:
+					ip = new FloatProcessor(width, height, (float[])pixels, cm);
+					imp.setProcessor(null, ip);
+					break;
+				case FileInfo.RGB:
+				case FileInfo.BGR:
+				case FileInfo.ARGB:
+				case FileInfo.ABGR:
+				case FileInfo.RGB_PLANAR:
+					Image img = Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(width, height, (int[])pixels, 0, width));
+					imp.setImage(img);
+					break;
+				case FileInfo.CMYK:
+					ip = new ColorProcessor(width, height, (int[])pixels);
+					ip.invert();
+					imp.setProcessor(null, ip);
+					break;
+			}
+		}
+	}
+	
+	void setCalibration(ImagePlus imp) {
+		if (fi.fileType==FileInfo.GRAY16_SIGNED) {
+			if (IJ.debugMode) IJ.log("16-bit signed");
+ 			imp.getLocalCalibration().setSigned16BitCalibration();
+		}
+		Properties props = decodeDescriptionString(fi);
+		Calibration cal = imp.getCalibration();
+		boolean calibrated = false;
+		if (fi.pixelWidth>0.0 && fi.unit!=null) {
+			if (Prefs.convertToMicrons && fi.pixelWidth<=0.0001 && fi.unit.equals("cm")) {
+				fi.pixelWidth *= 10000.0;
+				fi.pixelHeight *= 10000.0;
+				if (fi.pixelDepth!=1.0)
+					fi.pixelDepth *= 10000.0;
+				fi.unit = "um";
+			}
+			cal.pixelWidth = fi.pixelWidth;
+			cal.pixelHeight = fi.pixelHeight;
+			cal.pixelDepth = fi.pixelDepth;
+			cal.setUnit(fi.unit);
+			calibrated = true;
+		}
+		
+		if (fi.valueUnit!=null) {
+			if (imp.getBitDepth()==32)
+				cal.setValueUnit(fi.valueUnit);
+			else {
+				int f = fi.calibrationFunction;
+				if ((f>=Calibration.STRAIGHT_LINE && f<=Calibration.EXP_RECOVERY && fi.coefficients!=null)
+				|| f==Calibration.UNCALIBRATED_OD) {
+					boolean zeroClip = props!=null && props.getProperty("zeroclip", "false").equals("true");	
+					cal.setFunction(f, fi.coefficients, fi.valueUnit, zeroClip);
+					calibrated = true;
+				}
+			}
+		}
+		
+		if (calibrated)
+			checkForCalibrationConflict(imp, cal);
+		
+		if (fi.frameInterval!=0.0)
+			cal.frameInterval = fi.frameInterval;
+		
+		if (props==null)
+			return;
+					
+		cal.xOrigin = getDouble(props,"xorigin");
+		cal.yOrigin = getDouble(props,"yorigin");
+		cal.zOrigin = getDouble(props,"zorigin");
+		cal.setInvertY(getBoolean(props, "inverty"));
+		cal.info = props.getProperty("info");		
+				
+		cal.fps = getDouble(props,"fps");
+		cal.loop = getBoolean(props, "loop");
+		cal.frameInterval = getDouble(props,"finterval");
+		cal.setTimeUnit(props.getProperty("tunit", "sec"));
+		cal.setYUnit(props.getProperty("yunit"));
+		cal.setZUnit(props.getProperty("zunit"));
+
+		double displayMin = getDouble(props,"min");
+		double displayMax = getDouble(props,"max");
+		if (!(displayMin==0.0&&displayMax==0.0)) {
+			int type = imp.getType();
+			ImageProcessor ip = imp.getProcessor();
+			if (type==ImagePlus.GRAY8 || type==ImagePlus.COLOR_256)
+				ip.setMinAndMax(displayMin, displayMax);
+			else if (type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32) {
+				if (ip.getMin()!=displayMin || ip.getMax()!=displayMax)
+					ip.setMinAndMax(displayMin, displayMax);
+			}
+		}
+		
+		if (getBoolean(props, "8bitcolor"))
+			imp.setTypeToColor256(); // set type to COLOR_256
+		
+		int stackSize = imp.getStackSize();
+		if (stackSize>1) {
+			int channels = (int)getDouble(props,"channels");
+			int slices = (int)getDouble(props,"slices");
+			int frames = (int)getDouble(props,"frames");
+			if (channels==0) channels = 1;
+			if (slices==0) slices = 1;
+			if (frames==0) frames = 1;
+			//IJ.log("setCalibration: "+channels+"  "+slices+"  "+frames);
+			if (channels*slices*frames==stackSize) {
+				imp.setDimensions(channels, slices, frames);
+				if (getBoolean(props, "hyperstack"))
+					imp.setOpenAsHyperStack(true);
+			}
+		}
+	}
+
+		
+	void checkForCalibrationConflict(ImagePlus imp, Calibration cal) {
+		Calibration gcal = imp.getGlobalCalibration();
+		if  (gcal==null || !showConflictMessage || IJ.isMacro())
+			return;
+		if (cal.pixelWidth==gcal.pixelWidth && cal.getUnit().equals(gcal.getUnit()))
+			return;
+		GenericDialog gd = new GenericDialog(imp.getTitle());
+		gd.addMessage("The calibration of this image conflicts\nwith the current global calibration.");
+		gd.addCheckbox("Disable_Global Calibration", true);
+		gd.addCheckbox("Disable_these Messages", false);
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		boolean disable = gd.getNextBoolean();
+		if (disable) {
+			imp.setGlobalCalibration(null);
+			imp.setCalibration(cal);
+			WindowManager.repaintImageWindows();
+		}
+		boolean dontShow = gd.getNextBoolean();
+		if (dontShow) showConflictMessage = false;
+	}
+
+	/** Returns an IndexColorModel for the image specified by this FileInfo. */
+	public ColorModel createColorModel(FileInfo fi) {
+		if (fi.lutSize>0)
+			return new IndexColorModel(8, fi.lutSize, fi.reds, fi.greens, fi.blues);
+		else
+			return LookUpTable.createGrayscaleColorModel(fi.whiteIsZero);
+	}
+
+	/** Returns an InputStream for the image described by this FileInfo. */
+	public InputStream createInputStream(FileInfo fi) throws IOException, MalformedURLException {
+		InputStream is = null;
+		boolean gzip = fi.fileName!=null && (fi.fileName.endsWith(".gz")||fi.fileName.endsWith(".GZ"));
+		if (fi.inputStream!=null)
+			is = fi.inputStream;
+		else if (fi.url!=null && !fi.url.equals(""))
+			is = new URL(fi.url+fi.fileName).openStream();
+		else {
+			if (fi.directory!=null && fi.directory.length()>0 && !(fi.directory.endsWith(Prefs.separator)||fi.directory.endsWith("/")))
+				fi.directory += Prefs.separator;
+		    File f = new File(fi.getFilePath());
+		    if (gzip) fi.compression = FileInfo.COMPRESSION_UNKNOWN;
+		    if (f==null || !f.exists() || f.isDirectory() || !validateFileInfo(f, fi))
+		    	is = null;
+		    else
+				is = new FileInputStream(f);
+		}
+		if (is!=null) {
+			if (fi.compression>=FileInfo.LZW)
+				is = new RandomAccessStream(is);
+			else if (gzip)
+				is = new GZIPInputStream(is, 50000);
+		}
+		return is;
+	}
+	
+	static boolean validateFileInfo(File f, FileInfo fi) {
+		long offset = fi.getOffset();
+		long length = 0;
+		if (fi.width<=0 || fi.height<=0) {
+		   error("Width or height <= 0.", fi, offset, length);
+		   return false;
+		}
+		if (offset>=0 && offset<1000L)
+			 return true;
+		if (offset<0L) {
+		   error("Offset is negative.", fi, offset, length);
+		   return false;
+		}
+		if (fi.fileType==FileInfo.BITMAP || fi.compression!=FileInfo.COMPRESSION_NONE)
+			return true;
+		length = f.length();
+		long size = fi.width*fi.height*fi.getBytesPerPixel();
+		size = fi.nImages>1?size:size/4;
+		if (fi.height==1) size = 0; // allows plugins to read info of unknown length at end of file
+		if (offset+size>length) {
+		   error("Offset + image size > file length.", fi, offset, length);
+		   return false;
+		}
+		return true;
+	}
+
+	static void error(String msg, FileInfo fi, long offset, long length) {
+		String msg2 = "FileInfo parameter error. \n"
+			+msg + "\n \n"
+			+"  Width: " + fi.width + "\n"
+			+"  Height: " + fi.height + "\n"
+			+"  Offset: " + offset + "\n"
+			+"  Bytes/pixel: " + fi.getBytesPerPixel() + "\n"
+			+(length>0?"  File length: " + length + "\n":"");
+		if (silentMode) {
+			IJ.log("Error opening "+fi.getFilePath());
+			IJ.log(msg2);
+		} else
+			IJ.error("FileOpener", msg2);
+	}
+
+
+	/** Reads the pixel data from an image described by a FileInfo object. */
+	Object readPixels(FileInfo fi) {
+		Object pixels = null;
+		try {
+			InputStream is = createInputStream(fi);
+			if (is==null)
+				return null;
+			ImageReader reader = new ImageReader(fi);
+			pixels = reader.readPixels(is);
+			minValue = reader.min;
+			maxValue = reader.max;
+			is.close();
+		}
+		catch (Exception e) {
+			if (!Macro.MACRO_CANCELED.equals(e.getMessage()))
+				IJ.handleException(e);
+		}
+		return pixels;
+	}
+
+	public Properties decodeDescriptionString(FileInfo fi) {
+		if (fi.description==null || fi.description.length()<7)
+			return null;
+		if (IJ.debugMode)
+			IJ.log("Image Description: " + new String(fi.description).replace('\n',' '));
+		if (!fi.description.startsWith("ImageJ"))
+			return null;
+		Properties props = new Properties();
+		InputStream is = new ByteArrayInputStream(fi.description.getBytes());
+		try {props.load(is); is.close();}
+		catch (IOException e) {return null;}
+		String dsUnit = props.getProperty("unit","");
+		if ("cm".equals(fi.unit) && "um".equals(dsUnit)) {
+			fi.pixelWidth *= 10000;
+			fi.pixelHeight *= 10000;
+		}
+		fi.unit = dsUnit;
+		Double n = getNumber(props,"cf");
+		if (n!=null) fi.calibrationFunction = n.intValue();
+		double c[] = new double[5];
+		int count = 0;
+		for (int i=0; i<5; i++) {
+			n = getNumber(props,"c"+i);
+			if (n==null) break;
+			c[i] = n.doubleValue();
+			count++;
+		}
+		if (count>=2) {
+			fi.coefficients = new double[count];
+			for (int i=0; i<count; i++)
+				fi.coefficients[i] = c[i];			
+		}
+		fi.valueUnit = props.getProperty("vunit");
+		n = getNumber(props,"images");
+		if (n!=null && n.doubleValue()>1.0)
+		fi.nImages = (int)n.doubleValue();
+		n = getNumber(props, "spacing");
+		if (n!=null) {
+			double spacing = n.doubleValue();
+			if (spacing<0) spacing = -spacing;
+			fi.pixelDepth = spacing;
+		}
+		String name = props.getProperty("name");
+		if (name!=null)
+			fi.fileName = name;
+		return props;
+	}
+
+	private Double getNumber(Properties props, String key) {
+		String s = props.getProperty(key);
+		if (s!=null) {
+			try {
+				return Double.valueOf(s);
+			} catch (NumberFormatException e) {}
+		}	
+		return null;
+	}
+	
+	private double getDouble(Properties props, String key) {
+		Double n = getNumber(props, key);
+		return n!=null?n.doubleValue():0.0;
+	}
+	
+	private boolean getBoolean(Properties props, String key) {
+		String s = props.getProperty(key);
+		return s!=null&&s.equals("true")?true:false;
+	}
+	
+	public static void setShowConflictMessage(boolean b) {
+		showConflictMessage = b;
+	}
+	
+	static void setSilentMode(boolean mode) {
+		silentMode = mode;
+	}
+
+
+}
diff --git a/src/ij/io/FileSaver.java b/src/ij/io/FileSaver.java
new file mode 100644
index 0000000..a7ef326
--- /dev/null
+++ b/src/ij/io/FileSaver.java
@@ -0,0 +1,837 @@
+package ij.io;
+import java.awt.*;
+import java.io.*;
+import java.util.zip.*;
+import ij.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.frame.Recorder;
+import ij.plugin.JpegWriter;
+import ij.plugin.Orthogonal_Views;
+import ij.gui.*;
+import ij.measure.Measurements;
+import ij.util.Tools;
+import javax.imageio.*;
+
+/** Saves images in tiff, gif, jpeg, raw, zip and text format. */
+public class FileSaver {
+
+	public static final int DEFAULT_JPEG_QUALITY = 85;
+	private static int jpegQuality;
+	private static int bsize = 32768; // 32K default buffer size
+	
+    static {setJpegQuality(ij.Prefs.getInt(ij.Prefs.JPEG, DEFAULT_JPEG_QUALITY));}
+
+	private static String defaultDirectory = null;
+	private ImagePlus imp;
+	private FileInfo fi;
+	private String name;
+	private String directory;
+	private boolean saveName;
+
+	/** Constructs a FileSaver from an ImagePlus. */
+	public FileSaver(ImagePlus imp) {
+		this.imp = imp;
+		fi = imp.getFileInfo();
+	}
+
+	/** Resaves the image. Calls saveAsTiff() if this is a new image, not a TIFF,
+		or if the image was loaded using a URL. Returns false if saveAsTiff() is
+		called and the user selects cancel in the file save dialog box. */
+	public boolean save() {
+		FileInfo ofi = null;
+		if (imp!=null) ofi = imp.getOriginalFileInfo();
+		boolean validName = ofi!=null && imp.getTitle().equals(ofi.fileName);
+		if (validName && ofi.fileFormat==FileInfo.TIFF && ofi.directory!=null && !ofi.directory.equals("") && (ofi.url==null||ofi.url.equals(""))) {
+            name = imp.getTitle();
+            directory = ofi.directory;
+			String path = directory+name;
+			File f = new File(path);
+			if (f==null || !f.exists())
+				return saveAsTiff();
+			if (!IJ.isMacro()) {
+				GenericDialog gd = new GenericDialog("Save as TIFF");
+				gd.addMessage("\""+ofi.fileName+"\" already exists.\nDo you want to replace it?");
+				gd.setOKLabel("Replace");
+				gd.showDialog();
+				if (gd.wasCanceled())
+					return false;
+			}
+			IJ.showStatus("Saving "+path);
+			if (imp.getStackSize()>1) {
+				IJ.saveAs(imp, "tif", path);
+				return true;
+			} else
+		    	return saveAsTiff(path);
+		} else
+			return saveAsTiff();
+	}
+	
+	String getPath(String type, String extension) {
+		name = imp.getTitle();
+		SaveDialog sd = new SaveDialog("Save as "+type, name, extension);
+		name = sd.getFileName();
+		if (name==null)
+			return null;
+		directory = sd.getDirectory();
+		imp.startTiming();
+		String path = directory+name;
+		return path;
+	}
+	
+	/** Saves the image or stack in TIFF format using a save file
+		dialog. Returns false if the user selects cancel. Equivalent to 
+		IJ.saveAsTiff(imp,""), which is more convenient. */
+	public boolean saveAsTiff() {
+		String path = getPath("TIFF", ".tif");
+		if (path==null)
+			return false;
+		if (fi.nImages>1)
+			return saveAsTiffStack(path);
+		else
+			return saveAsTiff(path);
+	}
+	
+	/** Saves the image in TIFF format using the specified path. Equivalent to
+		 IJ.saveAsTiff(imp,path), which is more convenient. */
+	public boolean saveAsTiff(String path) {
+		if (fi.nImages>1)
+			return saveAsTiffStack(path);
+		if (imp.getProperty("FHT")!=null && path.contains("FFT of "))
+			setupFFTSave();
+		fi.info = imp.getInfoProperty();
+		String label = imp.isStack()?imp.getStack().getSliceLabel(1):null;
+		if (label!=null) {
+			fi.sliceLabels = new String[1];
+			fi.sliceLabels[0] = label;
+		}
+		fi.description = getDescriptionString();
+		if (imp.getProperty(Plot.PROPERTY_KEY) != null) {
+			Plot plot = (Plot)(imp.getProperty(Plot.PROPERTY_KEY));
+			fi.plot = plot.toByteArray();
+		}
+		fi.roi = RoiEncoder.saveAsByteArray(imp.getRoi());
+		fi.overlay = getOverlay(imp);
+		fi.properties = imp.getPropertiesAsArray();
+		DataOutputStream out = null;
+		try {
+			TiffEncoder file = new TiffEncoder(fi);
+			out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path),bsize));
+			file.write(out);
+			out.close();
+		} catch (IOException e) {
+			showErrorMessage("saveAsTiff", path, e);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		updateImp(fi, FileInfo.TIFF);
+		return true;
+	}
+	
+	private void setupFFTSave() {
+		Object obj = imp.getProperty("FHT");
+		if (obj==null) return;
+		FHT fht = (obj instanceof FHT)?(FHT)obj:null;
+		if (fht==null) return;
+		if (fht.originalColorModel!=null && fht.originalBitDepth!=24)
+			fht.setColorModel(fht.originalColorModel);
+		ImagePlus imp2 = new ImagePlus(imp.getTitle(), fht);
+		imp2.setProperty("Info", imp.getProperty("Info"));
+		imp2.setProperties(imp.getPropertiesAsArray());
+		imp2.setCalibration(imp.getCalibration());
+		imp = imp2;
+		fi = imp.getFileInfo();
+	}
+	
+	public static byte[][] getOverlay(ImagePlus imp) {
+		if (imp.getHideOverlay())
+			return null;
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null) {
+			ImageCanvas ic = imp.getCanvas();
+			if (ic==null) return null;
+			overlay = ic.getShowAllList(); // ROI Manager "Show All" list
+			if (overlay==null) return null;
+		}
+		int n = overlay.size();
+		if (n==0)
+			return null;
+		if (Orthogonal_Views.isOrthoViewsImage(imp))
+			return null;
+		byte[][] array = new byte[n][];
+		for (int i=0; i<overlay.size(); i++) {
+			Roi roi = overlay.get(i);
+			if (i==0)
+				roi.setPrototypeOverlay(overlay);
+			array[i] = RoiEncoder.saveAsByteArray(roi);
+		}
+		return array;
+	}
+
+	/** Saves the stack as a multi-image TIFF using the specified path.
+		 Equivalent to IJ.saveAsTiff(imp,path), which is more convenient. */
+	public boolean saveAsTiffStack(String path) {
+		if (fi.nImages==1) {
+			error("This is not a stack");
+			return false;
+		}
+		boolean virtualStack = imp.getStack().isVirtual();
+		if (virtualStack)
+			fi.virtualStack = (VirtualStack)imp.getStack();
+		fi.info = imp.getInfoProperty();
+		fi.description = getDescriptionString();
+		if (virtualStack) {
+			FileInfo ofi = imp.getOriginalFileInfo();
+			if (path!=null && ofi!=null && path.equals(ofi.directory+ofi.fileName)) {
+				error("TIFF virtual stacks cannot be saved in place.");
+				return false;
+			}
+			String[] labels = null;
+			ImageStack vs = imp.getStack();
+			for (int i=1; i<=vs.getSize(); i++) {
+				String label = vs.getSliceLabel(i);
+				if (i==1 && label==null)
+					break;
+				if (labels==null)
+					labels = new String[vs.getSize()];
+				labels[i-1] = label;
+			}
+			fi.sliceLabels = labels;
+		} else
+			fi.sliceLabels = imp.getStack().getSliceLabels();
+		fi.roi = RoiEncoder.saveAsByteArray(imp.getRoi());
+		fi.overlay = getOverlay(imp);
+		fi.properties = imp.getPropertiesAsArray();
+		if (imp.isComposite()) saveDisplayRangesAndLuts(imp, fi);
+		DataOutputStream out = null;
+		try {
+			TiffEncoder file = new TiffEncoder(fi);
+			out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path),bsize));
+			file.write(out);
+			out.close();
+		} catch (IOException e) {
+			showErrorMessage("saveAsTiffStack", path, e);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		updateImp(fi, FileInfo.TIFF);
+		return true;
+	}
+	
+	/** Converts this image to a TIFF encoded array of bytes, 
+		which can be decoded using Opener.deserialize(). */
+	public byte[] serialize() {
+		if (imp.getStack().isVirtual())
+			return null;
+		fi.info = imp.getInfoProperty();
+		saveName = true;
+		fi.description = getDescriptionString();
+		saveName = false;
+		fi.sliceLabels = imp.getStack().getSliceLabels();
+		if (imp.getProperty(Plot.PROPERTY_KEY) != null) {
+			Plot plot = (Plot)(imp.getProperty(Plot.PROPERTY_KEY));
+			fi.plot = plot.toByteArray();
+		}
+		fi.roi = RoiEncoder.saveAsByteArray(imp.getRoi());
+		fi.overlay = getOverlay(imp);
+		if (imp.isComposite()) saveDisplayRangesAndLuts(imp, fi);
+		ByteArrayOutputStream out = null;
+		try {
+			TiffEncoder encoder = new TiffEncoder(fi);
+			out = new ByteArrayOutputStream();
+			encoder.write(out);
+			out.close();
+		} catch (IOException e) {
+			return null;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		return out.toByteArray();
+	}
+
+	public void saveDisplayRangesAndLuts(ImagePlus imp, FileInfo fi) {
+		CompositeImage ci = (CompositeImage)imp;
+		int channels = imp.getNChannels();
+		fi.displayRanges = new double[channels*2];
+		for (int i=1; i<=channels; i++) {
+			LUT lut = ci.getChannelLut(i);
+			fi.displayRanges[(i-1)*2] = lut.min;
+			fi.displayRanges[(i-1)*2+1] = lut.max;
+		}
+		if (ci.hasCustomLuts()) {
+			fi.channelLuts = new byte[channels][];
+			for (int i=0; i<channels; i++) {
+				LUT lut = ci.getChannelLut(i+1);
+				byte[] bytes = lut.getBytes();
+				if (bytes==null)
+					{fi.channelLuts=null; break;}
+				fi.channelLuts[i] = bytes;
+			}
+		}	
+	}
+
+	/** Uses a save file dialog to save the image or stack as a TIFF
+		in a ZIP archive. Returns false if the user selects cancel. */
+	public boolean saveAsZip() {
+		String path = getPath("TIFF/ZIP", ".zip");
+		if (path==null)
+			return false;
+		else
+			return saveAsZip(path);
+	}
+	
+	/** Save the image or stack in TIFF/ZIP format using the specified path. */
+	public boolean saveAsZip(String path) {
+		if (imp.getProperty("FHT")!=null && path.contains("FFT of "))
+			setupFFTSave();
+		if (!path.endsWith(".zip"))
+			path = path+".zip";
+		if (name==null)
+			name = imp.getTitle();
+		if (name.endsWith(".zip"))
+			name = name.substring(0,name.length()-4);
+		if (!name.endsWith(".tif"))
+			name = name+".tif";
+		fi.description = getDescriptionString();
+		fi.info = imp.getInfoProperty();
+		fi.properties = imp.getPropertiesAsArray();
+		if (imp.getProperty(Plot.PROPERTY_KEY) != null) {
+			Plot plot = (Plot)(imp.getProperty(Plot.PROPERTY_KEY));
+			fi.plot = plot.toByteArray();
+		}
+		fi.roi = RoiEncoder.saveAsByteArray(imp.getRoi());
+		fi.overlay = getOverlay(imp);
+		fi.sliceLabels = imp.getStack().getSliceLabels();
+		if (imp.isComposite()) saveDisplayRangesAndLuts(imp, fi);
+		if (fi.nImages>1 && imp.getStack().isVirtual())
+			fi.virtualStack = (VirtualStack)imp.getStack();
+		DataOutputStream out = null;
+		try {
+			ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(path));
+			out = new DataOutputStream(new BufferedOutputStream(zos,bsize));
+        	zos.putNextEntry(new ZipEntry(name));
+			TiffEncoder te = new TiffEncoder(fi);
+			te.write(out);
+			out.close();
+		}
+		catch (IOException e) {
+			showErrorMessage("saveAsZip", path, e);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		updateImp(fi, FileInfo.TIFF);
+		return true;
+	}
+
+	public static boolean okForGif(ImagePlus imp) {
+		if (imp.getType()==ImagePlus.COLOR_RGB)
+			return false;
+		else
+			return true;
+	}
+
+	/** Save the image in GIF format using a save file
+		dialog. Returns false if the user selects cancel
+		or the image is not 8-bits. */
+	public boolean saveAsGif() {
+		String path = getPath("GIF", ".gif");
+		if (path==null)
+			return false;
+		else
+			return saveAsGif(path);
+	}
+	
+	/** Save the image in Gif format using the specified path. Returns
+		false if the image is not 8-bits or there is an I/O error. */
+	public boolean saveAsGif(String path) {
+		IJ.runPlugIn(imp, "ij.plugin.GifWriter", path);
+		updateImp(fi, FileInfo.GIF_OR_JPG);
+		return true;
+	}
+
+	/** Always returns true. */
+	public static boolean okForJpeg(ImagePlus imp) {
+		return true;
+	}
+
+	/** Save the image in JPEG format using a save file
+		dialog. Returns false if the user selects cancel.
+		@see #setJpegQuality
+		@see #getJpegQuality
+	*/
+	public boolean saveAsJpeg() {
+		String type = "JPEG ("+getJpegQuality()+")";
+		String path = getPath(type, ".jpg");
+		if (path==null)
+			return false;
+		else
+			return saveAsJpeg(path);
+	}
+
+	/** Save the image in JPEG format using the specified path.
+		@see #setJpegQuality
+		@see #getJpegQuality
+	*/
+	public boolean saveAsJpeg(String path) {
+		String err = JpegWriter.save(imp, path, jpegQuality);
+		if (err==null && !(imp.getType()==ImagePlus.GRAY16 || imp.getType()==ImagePlus.GRAY32))
+			updateImp(fi, FileInfo.GIF_OR_JPG);
+		return true;
+	}
+
+	/** Save the image in BMP format using a save file dialog. 
+		Returns false if the user selects cancel. */
+	public boolean saveAsBmp() {
+		String path = getPath("BMP", ".bmp");
+		if (path==null)
+			return false;
+		else
+			return saveAsBmp(path);
+	}
+
+	/** Save the image in BMP format using the specified path. */
+	public boolean saveAsBmp(String path) {
+		IJ.runPlugIn(imp, "ij.plugin.BMP_Writer", path);
+		updateImp(fi, FileInfo.BMP);
+		return true;
+	}
+
+	/** Saves grayscale images in PGM (portable graymap) format 
+		and RGB images in PPM (portable pixmap) format,
+		using a save file dialog.
+		Returns false if the user selects cancel.
+	*/
+	public boolean saveAsPgm() {
+		String extension = imp.getBitDepth()==24?".pnm":".pgm";
+		String path = getPath("PGM", extension);
+		if (path==null)
+			return false;
+		else
+			return saveAsPgm(path);
+	}
+
+	/** Saves grayscale images in PGM (portable graymap) format 
+		and RGB images in PPM (portable pixmap) format,
+		using the specified path. */
+	public boolean saveAsPgm(String path) {
+		IJ.runPlugIn(imp, "ij.plugin.PNM_Writer", path);
+		updateImp(fi, FileInfo.PGM);
+		return true;
+	}
+
+	/** Save the image in PNG format using a save file dialog. 
+		Returns false if the user selects cancel. */
+	public boolean saveAsPng() {
+		String path = getPath("PNG", ".png");
+		if (path==null)
+			return false;
+		else
+			return saveAsPng(path);
+	}
+
+	/** Save the image in PNG format using the specified path. */
+	public boolean saveAsPng(String path) {
+		IJ.runPlugIn(imp, "ij.plugin.PNG_Writer", path);
+		updateImp(fi, FileInfo.IMAGEIO);
+		return true;
+	}
+
+	/** Save the image in FITS format using a save file dialog. 
+		Returns false if the user selects cancel. */
+	public boolean saveAsFits() {
+		if (!okForFits(imp)) return false;
+		String path = getPath("FITS", ".fits");
+		if (path==null)
+			return false;
+		else
+			return saveAsFits(path);
+	}
+
+	/** Save the image in FITS format using the specified path. */
+	public boolean saveAsFits(String path) {
+		if (!okForFits(imp)) return false;
+		IJ.runPlugIn(imp, "ij.plugin.FITS_Writer", path);
+		updateImp(fi, FileInfo.FITS);
+		return true;
+	}
+
+	public static boolean okForFits(ImagePlus imp) {
+		if (imp.getBitDepth()==24) {
+			IJ.error("FITS Writer", "Grayscale image required");
+			return false;
+		} else
+			return true;
+	}
+
+	/** Save the image or stack as raw data using a save file
+		dialog. Returns false if the user selects cancel. */
+	public boolean saveAsRaw() {
+		String path = getPath("Raw", ".raw");
+		if (path==null)
+			return false;
+		if (imp.getStackSize()==1)
+			return saveAsRaw(path);
+		else
+			return saveAsRawStack(path);
+	}
+	
+	/** Save the image as raw data using the specified path. */
+	public boolean saveAsRaw(String path) {
+		fi.nImages = 1;
+		fi.intelByteOrder = Prefs.intelByteOrder;
+		boolean signed16Bit = false;
+		short[] pixels = null;
+		int n = 0;
+		OutputStream out = null;
+		try {
+			signed16Bit = imp.getCalibration().isSigned16Bit();
+			if (signed16Bit) {
+				pixels = (short[])imp.getProcessor().getPixels();
+				n = imp.getWidth()*imp.getHeight();
+				for (int i=0; i<n; i++)
+					pixels[i] = (short)(pixels[i]-32768);
+			}
+			ImageWriter file = new ImageWriter(fi);
+			out = new BufferedOutputStream(new FileOutputStream(path),bsize);
+			file.write(out);
+			out.close();
+		}
+		catch (IOException e) {
+			showErrorMessage("saveAsRaw", path, e);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		if (signed16Bit) {
+			for (int i=0; i<n; i++)
+			pixels[i] = (short)(pixels[i]+32768);
+		}
+		updateImp(fi, fi.RAW);
+		return true;
+	}
+
+	/** Save the stack as raw data using the specified path. */
+	public boolean saveAsRawStack(String path) {
+		if (fi.nImages==1)
+			{IJ.log("This is not a stack"); return false;}
+		fi.intelByteOrder = Prefs.intelByteOrder;
+		boolean signed16Bit = false;
+		Object[] stack = null;
+		int n = 0;
+		boolean virtualStack = imp.getStackSize()>1 && imp.getStack().isVirtual();
+		if (virtualStack) {
+			fi.virtualStack = (VirtualStack)imp.getStack();
+			if (imp.getProperty("AnalyzeFormat")!=null) fi.fileName="FlipTheseImages";
+		}
+		OutputStream out = null;
+		try {
+			signed16Bit = imp.getCalibration().isSigned16Bit();
+			if (signed16Bit && !virtualStack) {
+				stack = (Object[])fi.pixels;
+				n = imp.getWidth()*imp.getHeight();
+				for (int slice=0; slice<fi.nImages; slice++) {
+					short[] pixels = (short[])stack[slice];
+					for (int i=0; i<n; i++)
+						pixels[i] = (short)(pixels[i]-32768);
+				}
+			}
+			ImageWriter file = new ImageWriter(fi);
+			out = new BufferedOutputStream(new FileOutputStream(path),bsize);
+			file.write(out);
+			out.close();
+		} catch (IOException e) {
+			showErrorMessage("saveAsRawStack", path, e);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		if (signed16Bit) {
+			for (int slice=0; slice<fi.nImages; slice++) {
+				short[] pixels = (short[])stack[slice];
+				for (int i=0; i<n; i++)
+					pixels[i] = (short)(pixels[i]+32768);
+			}
+		}
+		updateImp(fi, fi.RAW);
+		return true;
+	}
+
+	/** Save the image as tab-delimited text using a save file
+		dialog. Returns false if the user selects cancel. */
+	public boolean saveAsText() {
+		String path = getPath("Text", ".txt");
+		if (path==null)
+			return false;
+		return saveAsText(path);
+	}
+	
+	/** Save the image as tab-delimited text using the specified path. */
+	public boolean saveAsText(String path) {
+		DataOutputStream out = null;
+		try {
+			Calibration cal = imp.getCalibration();
+			int precision = Analyzer.getPrecision();
+			int measurements = Analyzer.getMeasurements();
+			boolean scientificNotation = (measurements&Measurements.SCIENTIFIC_NOTATION)!=0;
+			if (scientificNotation)
+				precision = -precision;
+			TextEncoder file = new TextEncoder(imp.getProcessor(), cal, precision);
+			out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
+			file.write(out);
+			out.close();
+		} catch (IOException e) {
+			showErrorMessage("saveAsText", path, e);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		return true;
+	}
+
+	/** Save the current LUT using a save file
+		dialog. Returns false if the user selects cancel. */
+	public boolean saveAsLut() {
+		if (imp.getType()==ImagePlus.COLOR_RGB) {
+			error("RGB Images do not have a LUT.");
+			return false;
+		}
+		String path = getPath("LUT", ".lut");
+		if (path==null)
+			return false;
+		return saveAsLut(path);
+	}
+	
+	/** Save the current LUT using the specified path. */
+	public boolean saveAsLut(String path) {
+		LookUpTable lut = imp.createLut();
+		int mapSize = lut.getMapSize();
+		if (mapSize==0) {
+			error("RGB Images do not have a LUT.");
+			return false;
+		}
+		if (mapSize<256) {
+			error("Cannot save LUTs with less than 256 entries.");
+			return false;
+		}
+		byte[] reds = lut.getReds(); 
+		byte[] greens = lut.getGreens();
+		byte[] blues = lut.getBlues();
+		byte[] pixels = new byte[768];
+		for (int i=0; i<256; i++) {
+			pixels[i] = reds[i];
+			pixels[i+256] = greens[i];
+			pixels[i+512] = blues[i];
+		}
+		FileInfo fi = new FileInfo();
+		fi.width = 768;
+		fi.height = 1;
+		fi.pixels = pixels;
+
+		OutputStream out = null;
+		try {
+			ImageWriter file = new ImageWriter(fi);
+			out = new FileOutputStream(path);
+			file.write(out);
+			out.close();
+		}
+		catch (IOException e) {
+			showErrorMessage("saveAsLut", path, e);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		return true;
+	}
+
+	public void updateImagePlus(String path, int fileFormat) {
+		if (imp==null || fi==null)
+			return;
+		if (name==null && path!=null) {
+			File f = new File(path);
+			directory = f.getParent() + File.separator;
+			name = f.getName();
+		}
+		updateImp(fi, fileFormat);
+	}
+	
+	private void updateImp(FileInfo fi, int fileFormat) {
+		imp.changes = false;
+		if (name!=null) {
+			fi.fileFormat = fileFormat;
+			FileInfo ofi = imp.getOriginalFileInfo();
+			if (ofi!=null) {
+				if (ofi.openNextName==null) {
+					fi.openNextName = ofi.fileName;
+					fi.openNextDir = ofi.directory;
+				} else {
+					fi.openNextName = ofi.openNextName;
+					fi.openNextDir = ofi.openNextDir ;
+				}
+			}
+			fi.fileName = name;
+			fi.directory = directory;
+			//if (fileFormat==fi.TIFF)
+			//	fi.offset = TiffEncoder.IMAGE_START;
+			fi.description = null;
+			imp.setTitle(name);
+			fi.imageSaved = true;
+			imp.setFileInfo(fi);
+		}
+	}
+
+	private void showErrorMessage(String title, String path, IOException e) {
+		String msg = e.getMessage();
+		if (msg.length()>100)
+			msg = msg.substring(0, 100);
+		msg = "File saving error (IOException):\n   \"" + msg + "\"";
+		IJ.error("FileSaver."+title, msg+" \n   "+path);
+		IJ.showProgress(1.0);
+	}
+	
+	private void error(String msg) {
+		IJ.error("FileSaver", msg);
+	}
+
+	/** Returns a string containing information about the specified  image. */
+	public String getDescriptionString() {
+		Calibration cal = imp.getCalibration();
+		StringBuffer sb = new StringBuffer(100);
+		sb.append("ImageJ="+ImageJ.VERSION+"\n");
+		if (fi.nImages>1 && fi.fileType!=FileInfo.RGB48)
+			sb.append("images="+fi.nImages+"\n");
+		int channels = imp.getNChannels();
+		if (channels>1)
+			sb.append("channels="+channels+"\n");
+		int slices = imp.getNSlices();
+		if (slices>1)
+			sb.append("slices="+slices+"\n");
+		int frames = imp.getNFrames();
+		if (frames>1)
+			sb.append("frames="+frames+"\n");
+		if (imp.isHyperStack()) sb.append("hyperstack=true\n");
+		if (imp.isComposite()) {
+			String mode = ((CompositeImage)imp).getModeAsString();
+			sb.append("mode="+mode+"\n");
+		}
+		if (fi.unit!=null)
+			appendEscapedLine(sb, "unit="+fi.unit);
+		int bitDepth = imp.getBitDepth();
+		if (fi.valueUnit!=null && (fi.calibrationFunction!=Calibration.CUSTOM||bitDepth==32)) {
+			if (bitDepth!=32) {
+				sb.append("cf="+fi.calibrationFunction+"\n");
+				if (fi.coefficients!=null) {
+					for (int i=0; i<fi.coefficients.length; i++)
+						sb.append("c"+i+"="+fi.coefficients[i]+"\n");
+				}
+			}
+			appendEscapedLine(sb, "vunit="+fi.valueUnit);
+			if (cal.zeroClip() && bitDepth!=32)
+				sb.append("zeroclip=true\n");
+		}
+		// get stack z-spacing, more units and fps
+		if (cal.frameInterval!=0.0) {
+			if ((int)cal.frameInterval==cal.frameInterval)
+				sb.append("finterval="+(int)cal.frameInterval+"\n");
+			else
+				sb.append("finterval="+cal.frameInterval+"\n");
+		}
+		if (!cal.getTimeUnit().equals("sec"))
+			appendEscapedLine(sb, "tunit="+cal.getTimeUnit());
+		if (!cal.getYUnit().equals(cal.getUnit()))
+			appendEscapedLine(sb, "yunit="+cal.getYUnit());
+		if (!cal.getZUnit().equals(cal.getUnit()))
+			appendEscapedLine(sb, "zunit="+cal.getZUnit());
+		if (fi.nImages>1) {
+			if (fi.pixelDepth!=1.0)
+				sb.append("spacing="+fi.pixelDepth+"\n");
+			if (cal.fps!=0.0) {
+				if ((int)cal.fps==cal.fps)
+					sb.append("fps="+(int)cal.fps+"\n");
+				else
+					sb.append("fps="+cal.fps+"\n");
+			}
+			sb.append("loop="+(cal.loop?"true":"false")+"\n");
+		}
+
+		// get min and max display values
+		ImageProcessor ip = imp.getProcessor();
+		double min = ip.getMin();
+		double max = ip.getMax();
+		int type = imp.getType();
+		boolean enhancedLut = (type==ImagePlus.GRAY8 || type==ImagePlus.COLOR_256) && (min!=0.0 || max !=255.0);
+		if (enhancedLut || type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32) {
+			sb.append("min="+min+"\n");
+			sb.append("max="+max+"\n");
+		}
+		
+		// get non-zero origins
+		if (cal.xOrigin!=0.0)
+			sb.append("xorigin="+cal.xOrigin+"\n");
+		if (cal.yOrigin!=0.0)
+			sb.append("yorigin="+cal.yOrigin+"\n");
+		if (cal.zOrigin!=0.0)
+			sb.append("zorigin="+cal.zOrigin+"\n");
+		if (cal.info!=null && cal.info.length()<=64 && cal.info.indexOf('=')==-1 && cal.info.indexOf('\n')==-1)
+			appendEscapedLine(sb, "info="+cal.info);
+			
+		// get invertY flag
+		if (cal.getInvertY())
+			sb.append("inverty=true\n");
+
+		if (saveName)
+			appendEscapedLine(sb, "name="+imp.getTitle());
+			
+		if (imp.getType()==ImagePlus.COLOR_256)
+			sb.append("8bitcolor=true\n");
+
+		sb.append((char)0);
+		return new String(sb);
+	}
+
+	// Append a string to a StringBuffer with escaped special characters as needed for java.util.Properties,
+	// and add a linefeed character
+	void appendEscapedLine(StringBuffer sb, String str) {
+		for (int i=0; i<str.length(); i++) {
+			char c = str.charAt(i);
+			if (c>=0x20 && c<0x7f && c!='\\')
+				sb.append(c);
+			else if (c<=0xffff) {   //(supplementary unicode characters >0xffff unsupported)
+				sb.append("\\u");
+				sb.append(Tools.int2hex(c, 4));
+			}
+		}
+		sb.append('\n');
+	}
+
+	/** Specifies the image quality (0-100). 0 is poorest image quality,
+		highest compression, and 100 is best image quality, lowest compression. */
+    public static void setJpegQuality(int quality) {
+        jpegQuality = quality;
+    	if (jpegQuality<0) jpegQuality = 0;
+    	if (jpegQuality>100) jpegQuality = 100;
+    }
+
+    /** Returns the current JPEG quality setting (0-100). */
+    public static int getJpegQuality() {
+        return jpegQuality;
+    }
+    
+    /** Sets the BufferedOutputStream buffer size in bytes (default is 32K). */
+    public static void setBufferSize(int bufferSize) {
+        bsize = bufferSize;
+        if (bsize<2048) bsize = 2048;
+    }
+
+}
diff --git a/src/ij/io/ImageReader.java b/src/ij/io/ImageReader.java
new file mode 100644
index 0000000..ed929b1
--- /dev/null
+++ b/src/ij/io/ImageReader.java
@@ -0,0 +1,1069 @@
+package ij.io;
+import ij.*;
+import ij.process.*;
+import java.io.*;
+import java.net.*;
+import java.awt.image.BufferedImage;
+import javax.imageio.ImageIO;
+import java.util.zip.Inflater;
+import java.util.zip.DataFormatException;
+
+
+/** Reads raw 8-bit, 16-bit or 32-bit (float or RGB)
+	images from a stream or URL. */
+public class ImageReader {
+
+	private static final int CLEAR_CODE = 256;
+	private static final int EOI_CODE = 257;
+
+    private FileInfo fi;
+    private int width, height;
+    private long skipCount;
+    private int bytesPerPixel, bufferSize, nPixels;
+    private long byteCount;
+	private boolean showProgressBar=true;
+	private int eofErrorCount;
+	private int imageCount;
+	private long startTime;
+	public double min, max; // readRGB48() calculates min/max pixel values
+
+	/**
+	Constructs a new ImageReader using a FileInfo object to describe the file to be read.
+	@see ij.io.FileInfo
+	*/
+	public ImageReader (FileInfo fi) {
+		this.fi = fi;
+	    width = fi.width;
+	    height = fi.height;
+	    skipCount = fi.getOffset();
+	}
+	
+	void eofError() {
+		eofErrorCount++;
+	}
+	
+	byte[] read8bitImage(InputStream in) throws IOException {
+		if (fi.compression>FileInfo.COMPRESSION_NONE)
+			return readCompressed8bitImage(in);
+		byte[] pixels = new byte[nPixels];
+		// assume contiguous strips
+		int count, actuallyRead;
+		int totalRead = 0;
+	  	while (totalRead<byteCount) {
+	  		if (totalRead+bufferSize>byteCount)
+	  			count = (int)(byteCount-totalRead);
+  			else
+  				count = bufferSize;
+  			actuallyRead = in.read(pixels, totalRead, count);
+  			if (actuallyRead==-1) {eofError(); break;}
+  			totalRead += actuallyRead;
+  			showProgress(totalRead, byteCount);
+  		}
+		return pixels;
+	}
+	
+	byte[] readCompressed8bitImage(InputStream in) throws IOException {
+		byte[] pixels = new byte[nPixels];
+		int current = 0;
+		byte last = 0;
+		for (int i=0; i<fi.stripOffsets.length; i++) {
+			if (in instanceof RandomAccessStream)
+				((RandomAccessStream)in).seek(fi.stripOffsets[i]);
+			else if (i > 0) {
+				long skip = (fi.stripOffsets[i]&0xffffffffL) - (fi.stripOffsets[i-1]&0xffffffffL) - fi.stripLengths[i-1];
+				if (skip > 0L) in.skip(skip);
+			}
+			byte[] byteArray = new byte[fi.stripLengths[i]];
+			int read = 0, left = byteArray.length;
+			while (left > 0) {
+				int r = in.read(byteArray, read, left);
+				if (r == -1) {eofError(); break;}
+				read += r;
+				left -= r;
+			}
+			byteArray = uncompress(byteArray);
+			int length = byteArray.length;
+			length = length - (length%fi.width);
+			if (fi.compression==FileInfo.LZW_WITH_DIFFERENCING) {
+				for (int b=0; b<length; b++) {
+					byteArray[b] += last;
+					last = b % fi.width == fi.width - 1 ? 0 : byteArray[b];
+				}
+			}
+			if (current+length>pixels.length)
+				length = pixels.length-current;
+			System.arraycopy(byteArray, 0, pixels, current, length);
+			current += length;
+			showProgress(i+1, fi.stripOffsets.length);
+		}
+		return pixels;
+	}
+	
+	/** Reads a 16-bit image. Signed pixels are converted to unsigned by adding 32768. */
+	short[] read16bitImage(InputStream in) throws IOException {
+		if (fi.compression>FileInfo.COMPRESSION_NONE || (fi.stripOffsets!=null&&fi.stripOffsets.length>1) && fi.fileType!=FileInfo.RGB48_PLANAR)
+			return readCompressed16bitImage(in);
+		int pixelsRead;
+		byte[] buffer = new byte[bufferSize];
+		short[] pixels = new short[nPixels];
+		long totalRead = 0L;
+		int base = 0;
+		int count, value;
+		int bufferCount;
+		
+		while (totalRead<byteCount) {
+			if ((totalRead+bufferSize)>byteCount)
+				bufferSize = (int)(byteCount-totalRead);
+			bufferCount = 0;
+			while (bufferCount<bufferSize) { // fill the buffer
+				count = in.read(buffer, bufferCount, bufferSize-bufferCount);
+				if (count==-1) {
+					for (int i=bufferCount; i<bufferSize; i++) buffer[i] = 0;
+					totalRead = byteCount;
+					eofError();
+					break;
+				}
+				bufferCount += count;
+			}
+			totalRead += bufferSize;
+			showProgress(totalRead, byteCount);
+			pixelsRead = bufferSize/bytesPerPixel;
+			if (fi.intelByteOrder) {
+				if (fi.fileType==FileInfo.GRAY16_SIGNED)
+					for (int i=base,j=0; i<(base+pixelsRead); i++,j+=2)
+						pixels[i] = (short)((((buffer[j+1]&0xff)<<8) | (buffer[j]&0xff))+32768);
+				else
+					for (int i=base,j=0; i<(base+pixelsRead); i++,j+=2)
+						pixels[i] = (short)(((buffer[j+1]&0xff)<<8) | (buffer[j]&0xff));
+			} else {
+				if (fi.fileType==FileInfo.GRAY16_SIGNED)
+					for (int i=base,j=0; i<(base+pixelsRead); i++,j+=2)
+						pixels[i] = (short)((((buffer[j]&0xff)<<8) | (buffer[j+1]&0xff))+32768);
+				else
+					for (int i=base,j=0; i<(base+pixelsRead); i++,j+=2)
+						pixels[i] = (short)(((buffer[j]&0xff)<<8) | (buffer[j+1]&0xff));
+			}
+			base += pixelsRead;
+		}
+		return pixels;
+	}
+	
+	short[] readCompressed16bitImage(InputStream in) throws IOException {
+		if (IJ.debugMode) IJ.log("ImageReader.read16bit, offset="+fi.stripOffsets[0]);
+		short[] pixels = new short[nPixels];
+		int base = 0;
+		short last = 0;
+		for (int k=0; k<fi.stripOffsets.length; k++) {
+			//IJ.log("seek: "+k+" "+fi.stripOffsets[k]+" "+fi.stripLengths[k]+"  "+(in instanceof RandomAccessStream));
+			if (in instanceof RandomAccessStream)
+				((RandomAccessStream)in).seek(fi.stripOffsets[k]);
+			else if (k > 0) {
+				long skip = (fi.stripOffsets[k]&0xffffffffL) - (fi.stripOffsets[k-1]&0xffffffffL) - fi.stripLengths[k-1];
+				if (skip > 0L) in.skip(skip);
+			}
+			byte[] byteArray = new byte[fi.stripLengths[k]];
+			int read = 0, left = byteArray.length;
+			while (left > 0) {
+				int r = in.read(byteArray, read, left);
+				if (r == -1) {eofError(); break;}
+				read += r;
+				left -= r;
+			}
+			byteArray = uncompress(byteArray);
+			int pixelsRead = byteArray.length/bytesPerPixel;
+			pixelsRead = pixelsRead - (pixelsRead%fi.width);
+			int pmax = base+pixelsRead;
+			if (pmax > nPixels) pmax = nPixels;
+			if (fi.intelByteOrder) {
+				for (int i=base,j=0; i<pmax; i++,j+=2)
+					pixels[i] = (short)(((byteArray[j+1]&0xff)<<8) | (byteArray[j]&0xff));
+			} else {
+				for (int i=base,j=0; i<pmax; i++,j+=2)
+					pixels[i] = (short)(((byteArray[j]&0xff)<<8) | (byteArray[j+1]&0xff));
+			}
+			if (fi.compression==FileInfo.LZW_WITH_DIFFERENCING) {
+				for (int b=base; b<pmax; b++) {
+					pixels[b] += last;
+					last = b % fi.width == fi.width - 1 ? 0 : pixels[b];
+				}
+			}
+			base += pixelsRead;
+			showProgress(k+1, fi.stripOffsets.length);
+		}
+		if (fi.fileType==FileInfo.GRAY16_SIGNED) {
+			// convert to unsigned
+			for (int i=0; i<nPixels; i++)
+				pixels[i] = (short)(pixels[i]+32768);
+		}
+		return pixels;
+	}
+
+	float[] read32bitImage(InputStream in) throws IOException {
+		if (fi.compression>FileInfo.COMPRESSION_NONE || (fi.stripOffsets!=null&&fi.stripOffsets.length>1))
+			return readCompressed32bitImage(in);
+		int pixelsRead;
+		byte[] buffer = new byte[bufferSize];
+		float[] pixels = new float[nPixels];
+		long totalRead = 0L;
+		int base = 0;
+		int count, value;
+		int bufferCount;
+		int tmp;
+		
+		while (totalRead<byteCount) {
+			if ((totalRead+bufferSize)>byteCount)
+				bufferSize = (int)(byteCount-totalRead);
+			bufferCount = 0;
+			while (bufferCount<bufferSize) { // fill the buffer
+				count = in.read(buffer, bufferCount, bufferSize-bufferCount);
+				if (count==-1) {
+					for (int i=bufferCount; i<bufferSize; i++) buffer[i] = 0;
+					totalRead = byteCount;
+					eofError();
+					break;
+				}
+				bufferCount += count;
+			}
+			totalRead += bufferSize;
+			showProgress(totalRead, byteCount);
+			pixelsRead = bufferSize/bytesPerPixel;
+			int pmax = base+pixelsRead;
+			if (pmax>nPixels) pmax = nPixels;
+			int j = 0;
+			if (fi.intelByteOrder)
+				for (int i=base; i<pmax; i++) {
+					tmp = (int)(((buffer[j+3]&0xff)<<24) | ((buffer[j+2]&0xff)<<16) | ((buffer[j+1]&0xff)<<8) | (buffer[j]&0xff));
+					if (fi.fileType==FileInfo.GRAY32_FLOAT)
+						pixels[i] = Float.intBitsToFloat(tmp);
+					else if (fi.fileType==FileInfo.GRAY32_UNSIGNED)
+						pixels[i] = (float)(tmp&0xffffffffL);
+					else
+						pixels[i] = tmp;
+					j += 4;
+				}
+			else
+				for (int i=base; i<pmax; i++) {
+					tmp = (int)(((buffer[j]&0xff)<<24) | ((buffer[j+1]&0xff)<<16) | ((buffer[j+2]&0xff)<<8) | (buffer[j+3]&0xff));
+					if (fi.fileType==FileInfo.GRAY32_FLOAT)
+						pixels[i] = Float.intBitsToFloat(tmp);
+					else if (fi.fileType==FileInfo.GRAY32_UNSIGNED)
+						pixels[i] = (float)(tmp&0xffffffffL);
+					else
+						pixels[i] = tmp;
+					j += 4;
+				}
+			base += pixelsRead;
+		}
+		return pixels;
+	}
+	
+	float[] readCompressed32bitImage(InputStream in) throws IOException {
+		float[] pixels = new float[nPixels];
+		int base = 0;
+		float last = 0;
+		for (int k=0; k<fi.stripOffsets.length; k++) {
+			if (in instanceof RandomAccessStream)
+				((RandomAccessStream)in).seek(fi.stripOffsets[k]);
+			else if (k > 0) {
+				long skip = (fi.stripOffsets[k]&0xffffffffL) - (fi.stripOffsets[k-1]&0xffffffffL) - fi.stripLengths[k-1];
+				if (skip > 0L) in.skip(skip);
+			}
+			byte[] byteArray = new byte[fi.stripLengths[k]];
+			int read = 0, left = byteArray.length;
+			while (left > 0) {
+				int r = in.read(byteArray, read, left);
+				if (r == -1) {eofError(); break;}
+				read += r;
+				left -= r;
+			}
+			byteArray = uncompress(byteArray);
+			int pixelsRead = byteArray.length/bytesPerPixel;
+			pixelsRead = pixelsRead - (pixelsRead%fi.width);
+			int pmax = base+pixelsRead;
+			if (pmax > nPixels) pmax = nPixels;
+			int tmp;
+			if (fi.intelByteOrder) {
+				for (int i=base,j=0; i<pmax; i++,j+=4) {
+					tmp = (int)(((byteArray[j+3]&0xff)<<24) | ((byteArray[j+2]&0xff)<<16) | ((byteArray[j+1]&0xff)<<8) | (byteArray[j]&0xff));
+					if (fi.fileType==FileInfo.GRAY32_FLOAT)
+						pixels[i] = Float.intBitsToFloat(tmp);
+					else if (fi.fileType==FileInfo.GRAY32_UNSIGNED)
+						pixels[i] = (float)(tmp&0xffffffffL);
+					else
+						pixels[i] = tmp;
+				}
+			} else {
+				for (int i=base,j=0; i<pmax; i++,j+=4) {
+					tmp = (int)(((byteArray[j]&0xff)<<24) | ((byteArray[j+1]&0xff)<<16) | ((byteArray[j+2]&0xff)<<8) | (byteArray[j+3]&0xff));
+					if (fi.fileType==FileInfo.GRAY32_FLOAT)
+						pixels[i] = Float.intBitsToFloat(tmp);
+					else if (fi.fileType==FileInfo.GRAY32_UNSIGNED)
+						pixels[i] = (float)(tmp&0xffffffffL);
+					else
+						pixels[i] = tmp;
+				}
+			}
+			if (fi.compression==FileInfo.LZW_WITH_DIFFERENCING) {
+				for (int b=base; b<pmax; b++) {
+					pixels[b] += last;
+					last = b % fi.width == fi.width - 1 ? 0 : pixels[b];
+				}
+			}
+			base += pixelsRead;
+			showProgress(k+1, fi.stripOffsets.length);
+		}
+		return pixels;
+	}
+
+	float[] read64bitImage(InputStream in) throws IOException {
+		int pixelsRead;
+		byte[] buffer = new byte[bufferSize];
+		float[] pixels = new float[nPixels];
+		long totalRead = 0L;
+		int base = 0;
+		int count, value;
+		int bufferCount;
+		long tmp;
+		long b1, b2, b3, b4, b5, b6, b7, b8;
+		
+		while (totalRead<byteCount) {
+			if ((totalRead+bufferSize)>byteCount)
+				bufferSize = (int)(byteCount-totalRead);
+			bufferCount = 0;
+			while (bufferCount<bufferSize) { // fill the buffer
+				count = in.read(buffer, bufferCount, bufferSize-bufferCount);
+				if (count==-1) {
+					for (int i=bufferCount; i<bufferSize; i++) buffer[i] = 0;
+					totalRead = byteCount;
+					eofError();
+					break;
+				}
+				bufferCount += count;
+			}
+			totalRead += bufferSize;
+			showProgress(totalRead, byteCount);
+			pixelsRead = bufferSize/bytesPerPixel;
+			int j = 0;
+			for (int i=base; i < (base+pixelsRead); i++) {
+				b1 = buffer[j+7]&0xff;  b2 = buffer[j+6]&0xff;  b3 = buffer[j+5]&0xff;  b4 = buffer[j+4]&0xff; 
+				b5 = buffer[j+3]&0xff;  b6 = buffer[j+2]&0xff;  b7 = buffer[j+1]&0xff;  b8 = buffer[j]&0xff; 
+				if (fi.intelByteOrder)
+					tmp = (long)((b1<<56)|(b2<<48)|(b3<<40)|(b4<<32)|(b5<<24)|(b6<<16)|(b7<<8)|b8);
+				else
+					tmp = (long)((b8<<56)|(b7<<48)|(b6<<40)|(b5<<32)|(b4<<24)|(b3<<16)|(b2<<8)|b1);
+				pixels[i] = (float)Double.longBitsToDouble(tmp);
+				j += 8;
+			}
+			base += pixelsRead;
+		}
+		return pixels;
+	}
+
+	int[] readChunkyRGB(InputStream in) throws IOException {
+		if (fi.compression==FileInfo.JPEG)
+			return readJPEG(in);
+		else if (fi.compression>FileInfo.COMPRESSION_NONE || (fi.stripOffsets!=null&&fi.stripOffsets.length>1))
+			return readCompressedChunkyRGB(in);
+		int pixelsRead;
+		bufferSize = 24*width;
+		byte[] buffer = new byte[bufferSize];
+		int[] pixels = new int[nPixels];
+		long totalRead = 0L;
+		int base = 0;
+		int count, value;
+		int bufferCount;
+		int r, g, b, a;
+		
+		while (totalRead<byteCount) {
+			if ((totalRead+bufferSize)>byteCount)
+				bufferSize = (int)(byteCount-totalRead);
+			bufferCount = 0;
+			while (bufferCount<bufferSize) { // fill the buffer
+				count = in.read(buffer, bufferCount, bufferSize-bufferCount);
+				if (count==-1) {
+					for (int i=bufferCount; i<bufferSize; i++) buffer[i] = 0;
+					totalRead = byteCount;
+					eofError();
+					break;
+				}
+				bufferCount += count;
+			}
+			totalRead += bufferSize;
+			showProgress(totalRead, byteCount);
+			pixelsRead = bufferSize/bytesPerPixel;
+			boolean bgr = fi.fileType==FileInfo.BGR;
+			int j = 0;
+			for (int i=base; i<(base+pixelsRead); i++) {
+				if (bytesPerPixel==4) {
+					if (fi.fileType==FileInfo.BARG) {  // MCID
+						b = buffer[j++]&0xff;
+						j++; // ignore alfa byte
+						r = buffer[j++]&0xff;
+						g = buffer[j++]&0xff;
+					} else if (fi.fileType==FileInfo.ABGR) {
+						b = buffer[j++]&0xff;
+						g = buffer[j++]&0xff;
+						r = buffer[j++]&0xff;
+						j++; // ignore alfa byte
+					} else if (fi.fileType==FileInfo.CMYK) {
+						r = buffer[j++] & 0xff; // c
+						g = buffer[j++] & 0xff; // m
+						b = buffer[j++] & 0xff; // y
+						a = buffer[j++] & 0xff; // k
+						if (a>0) { // if k>0 then  c=c*(1-k)+k
+							r = ((r*(256 - a))>>8) + a;
+							g = ((g*(256 - a))>>8) + a;
+							b = ((b*(256 - a))>>8) + a;
+						} // else  r=1-c, g=1-m and b=1-y, which IJ does by inverting image
+					} else { // ARGB
+						r = buffer[j++]&0xff;
+						g = buffer[j++]&0xff;
+						b = buffer[j++]&0xff;
+						j++; // ignore alfa byte
+					}
+				} else {
+					r = buffer[j++]&0xff;
+					g = buffer[j++]&0xff;
+					b = buffer[j++]&0xff;
+				}
+				if (bgr)
+					pixels[i] = 0xff000000 | (b<<16) | (g<<8) | r;
+				else
+					pixels[i] = 0xff000000 | (r<<16) | (g<<8) | b;
+			}
+			base += pixelsRead;
+		}
+		return pixels;
+	}
+
+	int[] readCompressedChunkyRGB(InputStream in) throws IOException {
+		int[] pixels = new int[nPixels];
+		int base = 0;
+		int lastRed=0, lastGreen=0, lastBlue=0;
+		int nextByte;
+		int red=0, green=0, blue=0, alpha = 0;
+		boolean bgr = fi.fileType==FileInfo.BGR;
+		boolean cmyk = fi.fileType==FileInfo.CMYK;
+		boolean differencing = fi.compression == FileInfo.LZW_WITH_DIFFERENCING;
+		for (int i=0; i<fi.stripOffsets.length; i++) {
+			if (in instanceof RandomAccessStream)
+				((RandomAccessStream)in).seek(fi.stripOffsets[i]);
+			else if (i > 0) {
+				long skip = (fi.stripOffsets[i]&0xffffffffL) - (fi.stripOffsets[i-1]&0xffffffffL) - fi.stripLengths[i-1];
+				if (skip > 0L) in.skip(skip);
+			}
+			byte[] byteArray = new byte[fi.stripLengths[i]];
+			int read = 0, left = byteArray.length;
+			while (left > 0) {
+				int r = in.read(byteArray, read, left);
+				if (r == -1) {eofError(); break;}
+				read += r;
+				left -= r;
+			}
+			byteArray = uncompress(byteArray);
+			if (differencing) {
+				for (int b=0; b<byteArray.length; b++) {
+					if (b / bytesPerPixel % fi.width == 0) continue;
+					byteArray[b] += byteArray[b - bytesPerPixel];
+				}
+			}
+			int k = 0;
+			int pixelsRead = byteArray.length/bytesPerPixel;
+			pixelsRead = pixelsRead - (pixelsRead%fi.width);
+			int pmax = base+pixelsRead;
+			if (pmax > nPixels) pmax = nPixels;
+			for (int j=base; j<pmax; j++) {
+				if (bytesPerPixel==4) {
+					red = byteArray[k++]&0xff;
+					green = byteArray[k++]&0xff;
+					blue = byteArray[k++]&0xff;
+					alpha = byteArray[k++]&0xff;
+					if (cmyk && alpha>0) {
+						red = ((red*(256-alpha))>>8) + alpha;
+						green = ((green*(256-alpha))>>8) + alpha;
+						blue = ((blue*(256-alpha))>>8) + alpha;
+					}
+				} else {
+					red = byteArray[k++]&0xff;
+					green = byteArray[k++]&0xff;
+					blue = byteArray[k++]&0xff;
+				}
+				if (bgr)
+					pixels[j] = 0xff000000 | (blue<<16) | (green<<8) | red;
+				else
+					pixels[j] = 0xff000000 | (red<<16) | (green<<8) | blue;
+			}
+			base += pixelsRead;
+			showProgress(i+1, fi.stripOffsets.length);
+		}
+		return pixels;
+	}
+	
+	int[] readJPEG(InputStream in) throws IOException {
+		BufferedImage bi = ImageIO.read(in);
+		ImageProcessor ip =  new ColorProcessor(bi);
+		return (int[])ip.getPixels();
+	}
+
+	int[] readPlanarRGB(InputStream in) throws IOException {
+		if (fi.compression>FileInfo.COMPRESSION_NONE || (fi.stripOffsets!=null&&fi.stripOffsets.length>1))
+			return readCompressedPlanarRGBImage(in);
+		DataInputStream dis = new DataInputStream(in);
+		int planeSize = nPixels; // 1/3 image size
+		byte[] buffer = new byte[planeSize];
+		int[] pixels = new int[nPixels];
+		int r, g, b;
+
+		startTime = 0L;
+		showProgress(10, 100);
+		dis.readFully(buffer);
+		for (int i=0; i < planeSize; i++) {
+			r = buffer[i]&0xff;
+			pixels[i] = 0xff000000 | (r<<16);
+		}
+		
+		showProgress(40, 100);
+		dis.readFully(buffer);
+		for (int i=0; i < planeSize; i++) {
+			g = buffer[i]&0xff;
+			pixels[i] |= g<<8;
+		}
+
+		showProgress(70, 100);
+		dis.readFully(buffer);
+		for (int i=0; i < planeSize; i++) {
+			b = buffer[i]&0xff;
+			pixels[i] |= b;
+		}
+
+		showProgress(90, 100);
+		return pixels;
+	}
+
+	int[] readCompressedPlanarRGBImage(InputStream in) throws IOException {
+		int[] pixels = new int[nPixels];
+		int r, g, b;
+		nPixels *= 3; // read all 3 planes
+		byte[] buffer = readCompressed8bitImage(in);
+		nPixels /= 3;
+		for (int i=0; i<nPixels; i++) {
+			r = buffer[i]&0xff;
+			pixels[i] = 0xff000000 | (r<<16);
+		}
+		for (int i=0; i<nPixels; i++) {
+			g = buffer[nPixels+i]&0xff;
+			pixels[i] |= g<<8;
+		}
+		for (int i=0; i<nPixels; i++) {
+			b = buffer[nPixels*2+i]&0xff;
+			pixels[i] |= b;
+		}
+		return pixels;
+	}
+
+	private void showProgress(int current, int last) {
+		if (showProgressBar && (System.currentTimeMillis()-startTime)>500L)
+			IJ.showProgress(current, last);
+	}
+	
+	private void showProgress(long current, long last) {
+		showProgress((int)(current/10L), (int)(last/10L));
+	}
+	
+	Object readRGB48(InputStream in) throws IOException {
+		if (fi.compression>FileInfo.COMPRESSION_NONE)
+			return readCompressedRGB48(in);
+		int channels = fi.samplesPerPixel;
+		if (channels==1) channels=3;
+		short[][] stack = new short[channels][nPixels];
+		DataInputStream dis = new DataInputStream(in);
+		int pixel = 0;
+		int min=65535, max=0;
+		if (fi.stripLengths==null) {
+			fi.stripLengths = new int[fi.stripOffsets.length];
+			fi.stripLengths[0] = width*height*bytesPerPixel;
+		}
+		for (int i=0; i<fi.stripOffsets.length; i++) {
+			if (i>0) {
+				long skip = (fi.stripOffsets[i]&0xffffffffL) - (fi.stripOffsets[i-1]&0xffffffffL) - fi.stripLengths[i-1];
+				if (skip>0L) dis.skip(skip);
+			}
+			int len = fi.stripLengths[i];
+			int bytesToGo = (nPixels-pixel)*channels*2;
+			if (len>bytesToGo) len = bytesToGo;
+			byte[] buffer = new byte[len];
+			dis.readFully(buffer);
+			int value;
+			int channel=0;
+			boolean intel = fi.intelByteOrder;
+			for (int base=0; base<len; base+=2) {
+				if (intel)
+					value = ((buffer[base+1]&0xff)<<8) | (buffer[base]&0xff);
+				else
+					value = ((buffer[base]&0xff)<<8) | (buffer[base+1]&0xff);
+				if (value<min)
+					min = value;
+				if (value>max)
+					max = value;
+				stack[channel][pixel] = (short)(value);
+				channel++;
+				if (channel==channels) {
+					channel = 0;
+					pixel++;
+				}
+			}
+			showProgress(i+1, fi.stripOffsets.length);
+		}
+		this.min=min; this.max=max;
+		return stack;
+	}
+
+	Object readCompressedRGB48(InputStream in) throws IOException {
+		if (fi.compression==FileInfo.LZW_WITH_DIFFERENCING)
+			throw new IOException("ImageJ cannot open 48-bit LZW compressed TIFFs with predictor");
+		int channels = 3;
+		short[][] stack = new short[channels][nPixels];
+		DataInputStream dis = new DataInputStream(in);
+		int pixel = 0;
+		int min=65535, max=0;
+		for (int i=0; i<fi.stripOffsets.length; i++) {
+			if (i>0) {
+				long skip = (fi.stripOffsets[i]&0xffffffffL) - (fi.stripOffsets[i-1]&0xffffffffL) - fi.stripLengths[i-1];
+				if (skip>0L) dis.skip(skip);
+			}
+			int len = fi.stripLengths[i];
+			byte[] buffer = new byte[len];
+			dis.readFully(buffer);
+			buffer = uncompress(buffer);
+			len = buffer.length;
+			if (len % 2 != 0) len--;
+			int value;
+			int channel=0;
+			boolean intel = fi.intelByteOrder;
+			for (int base=0; base<len && pixel<nPixels; base+=2) {
+				if (intel)
+					value = ((buffer[base+1]&0xff)<<8) | (buffer[base]&0xff);
+				else
+					value = ((buffer[base]&0xff)<<8) | (buffer[base+1]&0xff);
+				if (value<min)
+					min = value;
+				if (value>max)
+					max = value;
+				stack[channel][pixel] = (short)(value);
+				channel++;
+				if (channel==channels) {
+					channel = 0;
+					pixel++;
+				}
+			}
+			showProgress(i+1, fi.stripOffsets.length);
+		}
+		this.min=min; this.max=max;
+		return stack;
+	}
+
+	Object readRGB48Planar(InputStream in) throws IOException {
+		int channels = fi.samplesPerPixel;
+		if (channels==1) channels=3;
+		Object[] stack = new Object[channels];
+		for (int i=0; i<channels; i++) 
+			stack[i] = read16bitImage(in);
+		return stack;
+	}
+
+	short[] read12bitImage(InputStream in) throws IOException {
+		int bytesPerLine = (int)(width*1.5);
+		if ((width&1)==1) bytesPerLine++; // add 1 if odd
+		byte[] buffer = new byte[bytesPerLine*height];
+		short[] pixels = new short[nPixels];
+		DataInputStream dis = new DataInputStream(in);
+		dis.readFully(buffer);
+		for (int y=0; y<height; y++) {
+			int index1 = y*bytesPerLine;
+			int index2 = y*width;
+			int count = 0;
+			while (count<width) {
+				pixels[index2+count] = (short)(((buffer[index1]&0xff)*16) + ((buffer[index1+1]>>4)&0xf));
+				count++;
+				if (count==width) break;
+				pixels[index2+count] = (short)(((buffer[index1+1]&0xf)*256) + (buffer[index1+2]&0xff));
+				count++; index1+=3;
+			}
+		}
+		return pixels;
+	}
+
+	float[] read24bitImage(InputStream in) throws IOException {
+		byte[] buffer = new byte[width*3];
+		float[] pixels = new float[nPixels];
+		int b1, b2, b3;
+		DataInputStream dis = new DataInputStream(in);
+		for (int y=0; y<height; y++) {
+			dis.readFully(buffer);
+			int b = 0;
+			for (int x=0; x<width; x++) {
+				b1 = buffer[b++]&0xff;
+				b2 = buffer[b++]&0xff;
+				b3 = buffer[b++]&0xff;
+				pixels[x+y*width] = (b3<<16) | (b2<<8) | b1;
+			}
+		}
+		return pixels;
+	}
+
+	byte[] read1bitImage(InputStream in) throws IOException {
+		if (fi.compression==FileInfo.LZW)
+			throw new IOException("ImageJ cannot open 1-bit LZW compressed TIFFs");
+ 		int scan=(int)Math.ceil(width/8.0);
+		int len = scan*height;
+		byte[] buffer = new byte[len];
+		byte[] pixels = new byte[nPixels];
+		DataInputStream dis = new DataInputStream(in);
+		dis.readFully(buffer);
+		int value1,value2, offset, index;
+		for (int y=0; y<height; y++) {
+			offset = y*scan;
+			index = y*width;
+			for (int x=0; x<scan; x++) {
+				value1 = buffer[offset+x]&0xff;
+				for (int i=7; i>=0; i--) {
+					value2 = (value1&(1<<i))!=0?255:0;
+					if (index<pixels.length)
+						pixels[index++] = (byte)value2;
+				}
+			}
+		}
+		return pixels;
+	}
+
+	void skip(InputStream in) throws IOException {
+		if (skipCount>0) {
+			long bytesRead = 0;
+			int skipAttempts = 0;
+			long count;
+			while (bytesRead<skipCount) {
+				count = in.skip(skipCount-bytesRead);
+				skipAttempts++;
+				if (count==-1 || skipAttempts>5) break;
+				bytesRead += count;
+			}
+		}
+		byteCount = ((long)width)*height*bytesPerPixel;
+		if (fi.fileType==FileInfo.BITMAP) {
+ 			int scan=width/8, pad = width%8;
+			if (pad>0) scan++;
+			byteCount = scan*height;
+		}
+		nPixels = width*height;
+		bufferSize = (int)(byteCount/25L);
+		if (bufferSize<8192)
+			bufferSize = 8192;
+		else
+			bufferSize = (bufferSize/8192)*8192;
+	}
+	
+	/** 
+	Reads the image from the InputStream and returns the pixel
+	array (byte, short, int or float). Returns null if there
+	was an IO exception. Does not close the InputStream.
+	*/
+	public Object readPixels(InputStream in) {
+		Object pixels;
+		startTime = System.currentTimeMillis();
+		try {
+			switch (fi.fileType) {
+				case FileInfo.GRAY8:
+				case FileInfo.COLOR8:
+					bytesPerPixel = 1;
+					skip(in);
+					pixels = (Object)read8bitImage(in);
+					break;
+				case FileInfo.GRAY16_SIGNED:
+				case FileInfo.GRAY16_UNSIGNED:
+					bytesPerPixel = 2;
+					skip(in);
+					pixels = (Object)read16bitImage(in);
+					break;
+				case FileInfo.GRAY32_INT:
+				case FileInfo.GRAY32_UNSIGNED:
+				case FileInfo.GRAY32_FLOAT:
+					bytesPerPixel = 4;
+					skip(in);
+					pixels = (Object)read32bitImage(in);
+					break;
+				case FileInfo.GRAY64_FLOAT:
+					bytesPerPixel = 8;
+					skip(in);
+					pixels = (Object)read64bitImage(in);
+					break;
+				case FileInfo.RGB:
+				case FileInfo.BGR:
+				case FileInfo.ARGB:
+				case FileInfo.ABGR:
+				case FileInfo.BARG:
+				case FileInfo.CMYK:
+					bytesPerPixel = fi.getBytesPerPixel();
+					skip(in);
+					pixels = (Object)readChunkyRGB(in);
+					break;
+				case FileInfo.RGB_PLANAR:
+					if (!(in instanceof RandomAccessStream) && fi.stripOffsets!=null && fi.stripOffsets.length>1)
+						in = new RandomAccessStream(in);
+					bytesPerPixel = 3;
+					skip(in);
+					pixels = (Object)readPlanarRGB(in);
+					break;
+				case FileInfo.BITMAP:
+					bytesPerPixel = 1;
+					skip(in);
+					pixels = (Object)read1bitImage(in);
+					break;
+				case FileInfo.RGB48:
+					bytesPerPixel = 6;
+					skip(in);
+					pixels = (Object)readRGB48(in);
+					break;
+				case FileInfo.RGB48_PLANAR:
+					bytesPerPixel = 2;
+					skip(in);
+					pixels = (Object)readRGB48Planar(in);
+					break;
+				case FileInfo.GRAY12_UNSIGNED:
+					skip(in);
+					short[] data = read12bitImage(in);
+					pixels = (Object)data;
+					break;
+				case FileInfo.GRAY24_UNSIGNED:
+					skip(in);
+					pixels = (Object)read24bitImage(in);
+					break;
+				default:
+					pixels = null;
+			}
+			showProgress(1, 1);
+			imageCount++;
+			return pixels;
+		}
+		catch (IOException e) {
+			IJ.log("" + e);
+			return null;
+		}
+	}
+	
+	/** 
+	Skips the specified number of bytes, then reads an image and 
+	returns the pixel array (byte, short, int or float). Returns
+	null if there was an IO exception. Does not close the InputStream.
+	*/
+	public Object readPixels(InputStream in, long skipCount) {
+		this.skipCount = skipCount;
+		showProgressBar = false;
+		Object pixels = readPixels(in);
+		if (eofErrorCount>(imageCount==1?1:0))
+			return null;
+		else
+			return pixels;
+	}
+	
+	/** 
+	Reads the image from a URL and returns the pixel array (byte, 
+	short, int or float). Returns null if there was an IO exception.
+	*/
+	public Object readPixels(String url) {
+		java.net.URL theURL;
+		InputStream is;
+		try {theURL = new URL(url);}
+		catch (MalformedURLException e) {IJ.log(""+e); return null;}
+		try {is = theURL.openStream();}
+		catch (IOException e) {IJ.log(""+e); return null;}
+		return readPixels(is);
+	}
+	
+	private byte[] uncompress(byte[] input) {
+		if (fi.compression==FileInfo.PACK_BITS)
+			return packBitsUncompress(input, fi.rowsPerStrip*fi.width*fi.getBytesPerPixel());
+		else if (fi.compression==FileInfo.LZW || fi.compression==FileInfo.LZW_WITH_DIFFERENCING)
+			return lzwUncompress(input);
+		else if (fi.compression==FileInfo.ZIP)
+			return zipUncompress(input);
+		else
+			return input;
+	}
+
+	/** TIFF Adobe ZIP support contributed by Jason Newton. */
+	public byte[] zipUncompress(byte[] input) {
+		ByteArrayOutputStream imageBuffer = new ByteArrayOutputStream();
+		byte[] buffer = new byte[1024];
+		Inflater decompressor = new Inflater();
+		decompressor.setInput(input);
+		try {
+			while(!decompressor.finished()) {
+				int rlen = decompressor.inflate(buffer);
+				imageBuffer.write(buffer, 0, rlen);
+			}
+		} catch(DataFormatException e){
+			IJ.log(e.toString());
+		}
+		decompressor.end();
+		return imageBuffer.toByteArray();
+	}
+
+  /**
+ * Utility method for decoding an LZW-compressed image strip. 
+ * Adapted from the TIFF 6.0 Specification:
+ * http://partners.adobe.com/asn/developer/pdfs/tn/TIFF6.pdf (page 61)
+ * Author: Curtis Rueden (ctrueden at wisc.edu)
+ */
+	public byte[] lzwUncompress(byte[] input) {
+		if (input==null || input.length==0)
+			return input;
+		byte[][] symbolTable = new byte[16384][1];
+		int bitsToRead = 9;
+		int nextSymbol = 258;
+		int code;
+		int oldCode = -1;
+		ByteVector out = new ByteVector(8192);
+		BitBuffer bb = new BitBuffer(input);
+		byte[] byteBuffer1 = new byte[16];
+		byte[] byteBuffer2 = new byte[16];
+		
+		while (out.size()<byteCount) {
+			code = bb.getBits(bitsToRead);
+			if (code==EOI_CODE || code==-1)
+				break;
+			if (code==CLEAR_CODE) {
+				// initialize symbol table
+				for (int i = 0; i < 256; i++)
+					symbolTable[i][0] = (byte)i;
+				nextSymbol = 258;
+				bitsToRead = 9;
+				code = bb.getBits(bitsToRead);
+				if (code==EOI_CODE || code==-1)
+					break;
+				out.add(symbolTable[code]);
+				oldCode = code;
+			} else {
+				if (oldCode==-1) oldCode=0;
+				if (code<nextSymbol) {
+					// code is in table
+					out.add(symbolTable[code]);
+					// add string to table
+					ByteVector symbol = new ByteVector(byteBuffer1);
+					symbol.add(symbolTable[oldCode]);
+					symbol.add(symbolTable[code][0]);
+					symbolTable[nextSymbol] = symbol.toByteArray(); //**
+					oldCode = code;
+					nextSymbol++;
+				} else {
+					// out of table
+					ByteVector symbol = new ByteVector(byteBuffer2);
+					symbol.add(symbolTable[oldCode]);
+					symbol.add(symbolTable[oldCode][0]);
+					byte[] outString = symbol.toByteArray();
+					out.add(outString);
+					symbolTable[nextSymbol] = outString; //**
+					oldCode = code;
+					nextSymbol++;
+				}
+				if (nextSymbol == 511) { bitsToRead = 10; }
+				if (nextSymbol == 1023) { bitsToRead = 11; }
+				if (nextSymbol == 2047) { bitsToRead = 12; }
+			}
+		}
+		return out.toByteArray();
+	}
+	 
+	/** Based on the Bio-Formats PackbitsCodec written by Melissa Linkert. */
+	public byte[] packBitsUncompress(byte[] input, int expected) {
+		if (expected==0) expected = Integer.MAX_VALUE;
+		ByteVector output = new ByteVector(1024);
+		int index = 0;
+		while (output.size()<expected && index<input.length) {
+			byte n = input[index++];
+			if (n>=0) { // 0 <= n <= 127
+				byte[] b = new byte[n+1];
+				for (int i=0; i<n+1; i++)
+					b[i] = input[index++];
+				output.add(b);
+				b = null;
+			} else if (n != -128) { // -127 <= n <= -1
+				int len = -n + 1;
+				byte inp = input[index++];
+				for (int i=0; i<len; i++) output.add(inp);
+			}
+		}
+		return output.toByteArray();
+	}
+
+	/*
+	void debug(String label, InputStream in) {
+		int offset = -1;
+		if (in instanceof RandomAccessStream) {
+			try {
+				offset = ((RandomAccessStream)in).getFilePointer();
+			} catch(Exception e) {}
+		}
+		IJ.log(label+": debug: offset="+offset+", fi="+fi);
+	}
+	*/
+}
+
+
+/** A growable array of bytes. */
+class ByteVector {
+	private byte[] data;
+	private int size;
+
+	public ByteVector() {
+		data = new byte[10];
+		size = 0;
+	}
+
+	public ByteVector(int initialSize) {
+		data = new byte[initialSize];
+		size = 0;
+	}
+
+	public ByteVector(byte[] byteBuffer) {
+		data = byteBuffer;
+		size = 0;
+	}
+
+	public void add(byte x) {
+		if (size>=data.length) {
+			doubleCapacity();
+			add(x);
+		} else
+			data[size++] = x;
+	}
+
+	public int size() {
+		return size;
+	}
+
+	public void add(byte[] array) {
+		int length = array.length;
+		while (data.length-size<length)
+	    	doubleCapacity();
+		System.arraycopy(array, 0, data, size, length);
+		size += length;
+    }
+
+	void doubleCapacity() {
+		byte[] tmp = new byte[data.length*2 + 1];
+		System.arraycopy(data, 0, tmp, 0, data.length);
+		data = tmp;
+	}
+
+	public void clear() {
+		size = 0;
+	}
+
+	public byte[] toByteArray() {
+		byte[] bytes = new byte[size];
+		System.arraycopy(data, 0, bytes, 0, size);
+		return bytes;
+	}
+		
+}
+
diff --git a/src/ij/io/ImageWriter.java b/src/ij/io/ImageWriter.java
new file mode 100644
index 0000000..2188eac
--- /dev/null
+++ b/src/ij/io/ImageWriter.java
@@ -0,0 +1,323 @@
+package ij.io;
+import java.io.*;
+import ij.*;  //??
+import ij.process.ImageProcessor;
+
+/** Writes a raw image described by a FileInfo object to an OutputStream. */
+public class ImageWriter {
+	private FileInfo fi;
+	private boolean showProgressBar=true;
+	private boolean savingStack;
+	
+	public ImageWriter (FileInfo fi) {
+		this.fi = fi;
+	}
+	
+	private void showProgress(double progress) {
+		if (showProgressBar)
+			IJ.showProgress(progress);
+	}
+	
+	void write8BitImage(OutputStream out, byte[] pixels)  throws IOException {
+		int bytesWritten = 0;
+		int size = fi.width*fi.height;
+		int count = getCount(size);
+		while (bytesWritten<size) {
+			if ((bytesWritten + count)>size)
+				count = size - bytesWritten;
+			//System.out.println(bytesWritten + " " + count + " " + size);
+			out.write(pixels, bytesWritten, count);
+			bytesWritten += count;
+			showProgress((double)bytesWritten/size);
+		}
+	}
+	
+	void write8BitStack(OutputStream out, Object[] stack)  throws IOException {
+		showProgressBar = false;
+		savingStack = true;
+		for (int i=0; i<fi.nImages; i++) {
+			IJ.showStatus("Writing: " + (i+1) + "/" + fi.nImages);
+			write8BitImage(out, (byte[])stack[i]);
+			IJ.showProgress((double)(i+1)/fi.nImages);
+		}
+	}
+
+	void write8BitVirtualStack(OutputStream out, VirtualStack virtualStack)  throws IOException {
+		showProgressBar = false;
+		boolean flip = "FlipTheseImages".equals(fi.fileName);
+		for (int i=1; i<=fi.nImages; i++) {
+			IJ.showStatus("Writing: " + i + "/" + fi.nImages);
+			ImageProcessor ip = virtualStack.getProcessor(i);
+			if (flip) ip.flipVertical();
+			byte[] pixels = (byte[])ip.getPixels();
+			write8BitImage(out, pixels);
+			IJ.showProgress((double)i/fi.nImages);
+		}
+	}
+
+	void write16BitImage(OutputStream out, short[] pixels)  throws IOException {
+		long bytesWritten = 0L;
+		long size = 2L*fi.width*fi.height;
+		int count = getCount(size);
+		byte[] buffer = new byte[count];
+
+		while (bytesWritten<size) {
+			if ((bytesWritten + count)>size)
+				count = (int)(size-bytesWritten);
+			int j = (int)(bytesWritten/2L);
+			int value;
+			if (fi.intelByteOrder)
+				for (int i=0; i < count; i+=2) {
+					value = pixels[j];
+					buffer[i] = (byte)value;
+					buffer[i+1] = (byte)(value>>>8);
+					j++;
+				}
+			else
+				for (int i=0; i < count; i+=2) {
+					value = pixels[j];
+					buffer[i] = (byte)(value>>>8);
+					buffer[i+1] = (byte)value;
+					j++;
+				}
+			out.write(buffer, 0, count);
+			bytesWritten += count;
+			showProgress((double)bytesWritten/size);
+		}
+	}
+	
+	void write16BitStack(OutputStream out, Object[] stack)  throws IOException {
+		showProgressBar = false;
+		for (int i=0; i<fi.nImages; i++) {
+			IJ.showStatus("Writing: " + (i+1) + "/" + fi.nImages);
+			write16BitImage(out, (short[])stack[i]);
+			IJ.showProgress((double)(i+1)/fi.nImages);
+		}
+	}
+
+	void write16BitVirtualStack(OutputStream out, VirtualStack virtualStack)  throws IOException {
+		showProgressBar = false;
+		boolean flip = "FlipTheseImages".equals(fi.fileName);
+		for (int i=1; i<=fi.nImages; i++) {
+			IJ.showStatus("Writing: " + i + "/" + fi.nImages);
+			ImageProcessor ip = virtualStack.getProcessor(i);
+			if (flip) ip.flipVertical();
+			short[] pixels = (short[])ip.getPixels();
+			write16BitImage(out, pixels);
+			IJ.showProgress((double)i/fi.nImages);
+		}
+	}
+
+	void writeRGB48Image(OutputStream out, Object[] stack)  throws IOException {
+		short[] r = (short[])stack[0];
+		short[] g = (short[])stack[1];
+		short[] b = (short[])stack[2];
+		int size = fi.width*fi.height;
+		int count = fi.width*6;
+		byte[] buffer = new byte[count];
+		for (int line=0; line<fi.height; line++) {
+			int index2 = 0;
+			int index1 = line*fi.width;
+			int value;
+			if (fi.intelByteOrder) {
+				for (int i=0; i<fi.width; i++) {
+					value = r[index1];
+					buffer[index2++] = (byte)value;
+					buffer[index2++] = (byte)(value>>>8);
+					value = g[index1];
+					buffer[index2++] = (byte)value;
+					buffer[index2++] = (byte)(value>>>8);
+					value = b[index1];
+					buffer[index2++] = (byte)value;
+					buffer[index2++] = (byte)(value>>>8);
+					index1++;
+				}
+			} else {
+				for (int i=0; i<fi.width; i++) {
+					value = r[index1];
+					buffer[index2++] = (byte)(value>>>8);
+					buffer[index2++] = (byte)value;
+					value = g[index1];
+					buffer[index2++] = (byte)(value>>>8);
+					buffer[index2++] = (byte)value;
+					value = b[index1];
+					buffer[index2++] = (byte)(value>>>8);
+					buffer[index2++] = (byte)value;
+					index1++;
+				}
+			}
+			out.write(buffer, 0, count);
+		}
+	}
+
+	void writeFloatImage(OutputStream out, float[] pixels)  throws IOException {
+		long bytesWritten = 0L;
+		long size = 4L*fi.width*fi.height;
+		int count = getCount(size);
+		byte[] buffer = new byte[count];
+		int tmp;
+
+		while (bytesWritten<size) {
+			if ((bytesWritten + count)>size)
+				count = (int)(size-bytesWritten);
+			int j = (int)(bytesWritten/4L);
+			if (fi.intelByteOrder)
+				for (int i=0; i < count; i+=4) {
+					tmp = Float.floatToRawIntBits(pixels[j]);
+					buffer[i]   = (byte)tmp;
+					buffer[i+1] = (byte)(tmp>>8);
+					buffer[i+2] = (byte)(tmp>>16);
+					buffer[i+3] = (byte)(tmp>>24);
+					j++;
+				}
+			else
+				for (int i=0; i < count; i+=4) {
+					tmp = Float.floatToRawIntBits(pixels[j]);
+					buffer[i]   = (byte)(tmp>>24);
+					buffer[i+1] = (byte)(tmp>>16);
+					buffer[i+2] = (byte)(tmp>>8);
+					buffer[i+3] = (byte)tmp;
+					j++;
+				}
+			out.write(buffer, 0, count);
+			bytesWritten += count;
+			showProgress((double)bytesWritten/size);
+		}
+	}
+	
+	private int getCount(long imageSize) {
+		if (savingStack || imageSize<4L)
+			return (int)imageSize;
+		int count = (int)(imageSize/50L);
+		if (count<65536)
+			count = 65536;
+		if (count>imageSize)
+			count = (int)imageSize;
+		count = (count/4)*4;
+		if (IJ.debugMode) IJ.log("ImageWriter: "+imageSize+" "+count+" "+imageSize/50);	
+		return count;	
+	}
+	
+	void writeFloatStack(OutputStream out, Object[] stack)  throws IOException {
+		showProgressBar = false;
+		for (int i=0; i<fi.nImages; i++) {
+			IJ.showStatus("Writing: " + (i+1) + "/" + fi.nImages);
+			writeFloatImage(out, (float[])stack[i]);
+			IJ.showProgress((double)(i+1)/fi.nImages);
+		}
+	}
+
+	void writeFloatVirtualStack(OutputStream out, VirtualStack virtualStack)  throws IOException {
+		showProgressBar = false;
+		boolean flip = "FlipTheseImages".equals(fi.fileName);
+		for (int i=1; i<=fi.nImages; i++) {
+			IJ.showStatus("Writing: " + i + "/" + fi.nImages);
+			ImageProcessor ip = virtualStack.getProcessor(i);
+			if (flip) ip.flipVertical();
+			float[] pixels = (float[])ip.getPixels();
+			writeFloatImage(out, pixels);
+			IJ.showProgress((double)i/fi.nImages);
+		}
+	}
+
+	void writeRGBImage(OutputStream out, int[] pixels)  throws IOException {
+		long bytesWritten = 0L;
+		long size = 3L*fi.width*fi.height;
+		int count = fi.width*24;
+		byte[] buffer = new byte[count];
+		while (bytesWritten<size) {
+			if ((bytesWritten+count)>size)
+				count = (int)(size-bytesWritten);
+			int j = (int)(bytesWritten/3L);
+			for (int i=0; i<count; i+=3) {
+				buffer[i]   = (byte)(pixels[j]>>16);	//red
+				buffer[i+1] = (byte)(pixels[j]>>8);	//green
+				buffer[i+2] = (byte)pixels[j];		//blue
+				j++;
+			}
+			out.write(buffer, 0, count);
+			bytesWritten += count;
+			showProgress((double)bytesWritten/size);
+		}
+	}
+	
+	void writeRGBStack(OutputStream out, Object[] stack)  throws IOException {
+		showProgressBar = false;
+		for (int i=0; i<fi.nImages; i++) {
+			IJ.showStatus("Writing: " + (i+1) + "/" + fi.nImages);
+			writeRGBImage(out, (int[])stack[i]);
+			IJ.showProgress((double)(i+1)/fi.nImages);
+		}
+	}
+
+	void writeRGBVirtualStack(OutputStream out, VirtualStack virtualStack)  throws IOException {
+		showProgressBar = false;
+		boolean flip = "FlipTheseImages".equals(fi.fileName);
+		for (int i=1; i<=fi.nImages; i++) {
+			IJ.showStatus("Writing: " + i + "/" + fi.nImages);
+			ImageProcessor ip = virtualStack.getProcessor(i);
+			if (flip) ip.flipVertical();
+			int[] pixels = (int[])ip.getPixels();
+			writeRGBImage(out, pixels);
+			IJ.showProgress((double)i/fi.nImages);
+		}
+	}
+
+	/** Writes the image to the specified OutputStream.
+		The OutputStream is not closed. The fi.pixels field
+		must contain the image data. If fi.nImages>1
+		then fi.pixels must be a 2D array, for example an
+ 		array of images returned by ImageStack.getImageArray()).
+ 		The fi.offset field is ignored. */
+	public void write(OutputStream out) throws IOException {
+		if (fi.pixels==null && fi.virtualStack==null)
+				throw new IOException("ImageWriter: fi.pixels==null");
+		if (fi.nImages>1 && fi.virtualStack==null && !(fi.pixels instanceof Object[]))
+				throw new IOException("ImageWriter: fi.pixels not a stack");
+		if (fi.width*fi.height*fi.getBytesPerPixel()<26214400)
+			showProgressBar = false; // don't show progress bar if image<25MB
+		switch (fi.fileType) {
+			case FileInfo.GRAY8:
+			case FileInfo.COLOR8:
+				if (fi.nImages>1 && fi.virtualStack!=null)
+					write8BitVirtualStack(out, fi.virtualStack);
+				else if (fi.nImages>1)
+					write8BitStack(out, (Object[])fi.pixels);
+				else
+					write8BitImage(out, (byte[])fi.pixels);
+				break;
+			case FileInfo.GRAY16_SIGNED:
+			case FileInfo.GRAY16_UNSIGNED:
+				if (fi.nImages>1 && fi.virtualStack!=null)
+					write16BitVirtualStack(out, fi.virtualStack);
+				else if (fi.nImages>1)
+					write16BitStack(out, (Object[])fi.pixels);
+				else
+					write16BitImage(out, (short[])fi.pixels);
+				break;
+			case FileInfo.RGB48:
+				writeRGB48Image(out, (Object[])fi.pixels);
+				break;
+			case FileInfo.GRAY32_FLOAT:
+				if (fi.nImages>1 && fi.virtualStack!=null)
+					writeFloatVirtualStack(out, fi.virtualStack);
+				else if (fi.nImages>1)
+					writeFloatStack(out, (Object[])fi.pixels);
+				else
+					writeFloatImage(out, (float[])fi.pixels);
+				break;
+			case FileInfo.RGB:
+				if (fi.nImages>1 && fi.virtualStack!=null)
+					writeRGBVirtualStack(out, fi.virtualStack);
+				else if (fi.nImages>1)
+					writeRGBStack(out, (Object[])fi.pixels);
+				else
+					writeRGBImage(out, (int[])fi.pixels);
+				break;
+			default:
+		}
+		savingStack = false;
+	}
+	
+}
+
diff --git a/src/ij/io/ImportDialog.java b/src/ij/io/ImportDialog.java
new file mode 100644
index 0000000..d5e328e
--- /dev/null
+++ b/src/ij/io/ImportDialog.java
@@ -0,0 +1,362 @@
+package ij.io;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.util.*;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.util.*;
+import ij.plugin.frame.Recorder;
+import ij.plugin.*;
+import ij.measure.Calibration;
+
+
+/** This is a dialog box used to imports raw 8, 16, 24 and 32-bit images. */
+public class ImportDialog {
+	private String fileName;
+    private String directory;
+	static final String TYPE = "raw.type";
+	static final String WIDTH = "raw.width";
+	static final String HEIGHT = "raw.height";
+	static final String OFFSET = "raw.offset";
+	static final String N = "raw.n";
+	static final String GAP = "raw.gap";
+	static final String OPTIONS = "raw.options";
+	static final int WHITE_IS_ZERO = 1;
+	static final int INTEL_BYTE_ORDER = 2;
+	static final int OPEN_ALL = 4;
+	
+    // default settings
+    private static int sChoiceSelection = Prefs.getInt(TYPE,0);
+    private static int sWidth = Prefs.getInt(WIDTH,512);
+    private static int sHeight = Prefs.getInt(HEIGHT,512);
+    private static long sOffset = Prefs.getInt(OFFSET,0);
+    private static int sNImages = Prefs.getInt(N,1);
+    private static long sGapBetweenImages = Prefs.getInt(GAP,0);
+    private static boolean sWhiteIsZero;
+    private static boolean sIntelByteOrder;
+    private static boolean sVirtual;
+    private int choiceSelection = sChoiceSelection;
+    private int width = sWidth;
+    private int height = sHeight;
+    private long offset = sOffset;
+    private int nImages = sNImages;
+    private long gapBetweenImages = sGapBetweenImages;
+    private boolean whiteIsZero = sWhiteIsZero;
+    private boolean intelByteOrder = sIntelByteOrder;
+    private boolean virtual = sVirtual;
+
+	private static int options;
+    private static FileInfo lastFileInfo;
+    private boolean openAll;
+    private static String[] types = {"8-bit", "16-bit Signed", "16-bit Unsigned",
+		"32-bit Signed", "32-bit Unsigned", "32-bit Real", "64-bit Real", "24-bit RGB", 
+		"24-bit RGB Planar", "24-bit BGR", "24-bit Integer", "32-bit ARGB", "32-bit ABGR", "1-bit Bitmap"};
+    	
+    static {
+    	options = Prefs.getInt(OPTIONS, 0);
+    	sWhiteIsZero = (options&WHITE_IS_ZERO)!=0;
+    	sIntelByteOrder = (options&INTEL_BYTE_ORDER)!=0;
+    }
+	
+    public ImportDialog(String fileName, String directory) {
+        this.fileName = fileName;
+        this.directory = directory;
+		IJ.showStatus("Importing: " + fileName);
+	}
+
+    public ImportDialog() {
+	}
+
+	boolean showDialog() {
+		boolean macro = Macro.getOptions()!=null;
+		if (macro) {
+			width = height = 512;
+			offset = gapBetweenImages = 0;
+			nImages = 1;
+			whiteIsZero = intelByteOrder = virtual = false;
+		}
+		if (choiceSelection>=types.length)
+			choiceSelection = 0;
+		getDimensionsFromName(fileName);
+		GenericDialog gd = new GenericDialog("Import>Raw...");
+		gd.addChoice("Image type:", types, types[choiceSelection]);
+		gd.addNumericField("Width:", width, 0, 8, "pixels");
+		gd.addNumericField("Height:", height, 0, 8, "pixels");
+		gd.addNumericField("Offset to first image:", offset, 0, 8, "bytes");
+		gd.addNumericField("Number of images:", nImages, 0, 8, null);
+		gd.addNumericField("Gap between images:", gapBetweenImages, 0, 8, "bytes");
+		gd.addCheckbox("White is zero", whiteIsZero);
+		gd.addCheckbox("Little-endian byte order", intelByteOrder);
+		gd.addCheckbox("Open all files in folder", openAll);
+		gd.addCheckbox("Use virtual stack", virtual);
+		gd.addHelp(IJ.URL+"/docs/menus/file.html#raw");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		choiceSelection = gd.getNextChoiceIndex();
+		width = (int)gd.getNextNumber();
+		height = (int)gd.getNextNumber();
+		gd.setSmartRecording(offset==0);
+		offset = (long)gd.getNextNumber();
+		gd.setSmartRecording(nImages==1);
+		nImages = (int)gd.getNextNumber();
+		gd.setSmartRecording(gapBetweenImages==0);
+		gapBetweenImages = (long)gd.getNextNumber();
+		gd.setSmartRecording(false);
+		whiteIsZero = gd.getNextBoolean();
+		intelByteOrder = gd.getNextBoolean();
+		openAll = gd.getNextBoolean();
+		virtual = gd.getNextBoolean();
+		IJ.register(ImportDialog.class);
+		if (!macro) {
+			sChoiceSelection = choiceSelection;
+			sWidth = width;
+			sHeight = height;
+			sOffset = offset;
+			sNImages = nImages;
+			sGapBetweenImages = gapBetweenImages;
+			sWhiteIsZero = whiteIsZero;
+			sIntelByteOrder = intelByteOrder;
+			sVirtual = virtual;
+		}
+		return true;
+	}
+	
+	/** Opens all the images in the directory. */
+	void openAll(String[] list, FileInfo fi) {
+		FolderOpener fo = new FolderOpener();
+		list = fo.trimFileList(list);
+		list = fo.sortFileList(list);
+		if (list==null) return;
+		ImageStack stack=null;
+		ImagePlus imp=null;
+		double min = Double.MAX_VALUE;
+		double max = -Double.MAX_VALUE;
+		int digits = 0;
+		for (int i=0; i<list.length; i++) {
+			if (list[i].startsWith("."))
+				continue;
+			fi.fileName = list[i];
+			imp = new FileOpener(fi).openImage();
+			if (imp==null)
+				IJ.log(list[i] + ": unable to open");
+			else {
+				if (stack==null)
+					stack = imp.createEmptyStack();
+				try {
+					ImageStack stack2 = imp.getStack();
+					int slices = stack2.getSize();
+					if (digits==0) {
+						digits = 2;
+						if (slices>99) digits=3;
+						if (slices>999) digits=4;
+						if (slices>9999) digits=5;
+					}
+					for (int n=1; n<=slices; n++) {
+						ImageProcessor ip = stack2.getProcessor(n);
+						if (ip.getMin()<min)
+							min = ip.getMin();
+						if (ip.getMax()>max)
+							max = ip.getMax();
+						String label = list[i];
+						if (slices>1) label += "-" + IJ.pad(n,digits);
+						stack.addSlice(label, ip);
+					}
+				} catch(OutOfMemoryError e) {
+					IJ.outOfMemory("OpenAll");
+					stack.trim();
+					break;
+				}
+				IJ.showStatus((stack.size()+1) + ": " + list[i]);
+			}
+		}
+		String dir = Recorder.fixPath(fi.directory);
+		Recorder.recordCall(fi.getCode()+"imp = Raw.openAll(\""+ dir+"\", fi);");
+		if (stack!=null) {
+			imp = new ImagePlus("Imported Stack", stack);
+			if (imp.getBitDepth()==16 || imp.getBitDepth()==32)
+				imp.getProcessor().setMinAndMax(min, max);
+                Calibration cal = imp.getCalibration();
+                if (fi.fileType==FileInfo.GRAY16_SIGNED)
+                	cal.setSigned16BitCalibration();
+			imp.show();
+		}
+	}
+	
+	/** Displays the dialog and opens the specified image or images.
+		Does nothing if the dialog is canceled. */
+	public void openImage() {
+		FileInfo fi = getFileInfo();
+		if (fi==null)
+			return;
+		if (openAll) {
+			if (virtual) {
+				ImagePlus imp = Raw.openAllVirtual(directory, fi);
+				String dir = Recorder.fixPath(directory);
+				Recorder.recordCall(fi.getCode()+"imp = Raw.openAllVirtual(\""+dir+"\", fi);");
+				if (imp!=null) {
+					imp.setSlice(imp.getStackSize()/2);
+					imp.show();
+					imp.setSlice(1);
+				}
+				return;
+			}
+			String[] list = new File(directory).list();
+			if (list==null) return;
+			openAll(list, fi);
+		} else if (virtual)
+			new FileInfoVirtualStack(fi);
+		else {
+			FileOpener fo = new FileOpener(fi);
+			ImagePlus imp = fo.openImage();
+			String filePath = fi.getFilePath();
+			filePath = Recorder.fixPath(filePath);
+			Recorder.recordCall(fi.getCode()+"imp = Raw.open(\""+filePath+"\", fi);");
+			if (imp!=null) {
+				imp.show();
+				int n = imp.getStackSize();
+				if (n>1) {
+					imp.setSlice(n/2);
+					ImageProcessor ip = imp.getProcessor();
+					ip.resetMinAndMax();
+					imp.setDisplayRange(ip.getMin(),ip.getMax());
+				}
+			} else
+				IJ.error("File>Import>Raw", "File not found: "+filePath);
+		}
+	}
+
+	/** Displays the dialog and returns a FileInfo object that can be used to
+		open the image. Returns null if the dialog is canceled. The fileName 
+		and directory fields are null if the no argument constructor was used. */
+	public FileInfo getFileInfo() {
+		if (!showDialog())
+			return null;
+		String imageType = types[choiceSelection];
+		FileInfo fi = new FileInfo();
+		fi.fileFormat = fi.RAW;
+		fi.fileName = fileName;
+		directory = IJ.addSeparator(directory);
+		fi.directory = directory;
+		fi.width = width;
+		fi.height = height;
+		if (offset>2147483647)
+			fi.longOffset = offset;
+		else
+			fi.offset = (int)offset;
+		fi.nImages = nImages;
+		fi.gapBetweenImages = (int)gapBetweenImages;
+		fi.longGap = gapBetweenImages;
+		fi.intelByteOrder = intelByteOrder;
+		fi.whiteIsZero = whiteIsZero;
+		if (imageType.equals("8-bit"))
+			fi.fileType = FileInfo.GRAY8;
+		else if (imageType.equals("16-bit Signed"))
+			fi.fileType = FileInfo.GRAY16_SIGNED;
+		else if (imageType.equals("16-bit Unsigned"))
+			fi.fileType = FileInfo.GRAY16_UNSIGNED;
+		else if (imageType.equals("32-bit Signed"))
+			fi.fileType = FileInfo.GRAY32_INT;
+		else if (imageType.equals("32-bit Unsigned"))
+			fi.fileType = FileInfo.GRAY32_UNSIGNED;
+		else if (imageType.equals("32-bit Real"))
+			fi.fileType = FileInfo.GRAY32_FLOAT;
+		else if (imageType.equals("64-bit Real"))
+			fi.fileType = FileInfo.GRAY64_FLOAT;
+		else if (imageType.equals("24-bit RGB"))
+			fi.fileType = FileInfo.RGB;
+		else if (imageType.equals("24-bit RGB Planar"))
+			fi.fileType = FileInfo.RGB_PLANAR;
+		else if (imageType.equals("24-bit BGR"))
+			fi.fileType = FileInfo.BGR;
+		else if (imageType.equals("24-bit Integer"))
+			fi.fileType = FileInfo.GRAY24_UNSIGNED;
+		else if (imageType.equals("32-bit ARGB"))
+			fi.fileType = FileInfo.ARGB;
+		else if (imageType.equals("32-bit ABGR"))
+			fi.fileType = FileInfo.ABGR;
+		else if (imageType.equals("1-bit Bitmap"))
+			fi.fileType = FileInfo.BITMAP;
+		else
+			fi.fileType = FileInfo.GRAY8;
+		if (IJ.debugMode) IJ.log("ImportDialog: "+fi);
+		lastFileInfo = (FileInfo)fi.clone();
+		return fi;
+	}
+
+	/** Called once when ImageJ quits. */
+	public static void savePreferences(Properties prefs) {
+		prefs.put(TYPE, Integer.toString(sChoiceSelection));
+		prefs.put(WIDTH, Integer.toString(sWidth));
+		prefs.put(HEIGHT, Integer.toString(sHeight));
+		prefs.put(OFFSET, Integer.toString(sOffset>2147483647?0:(int)sOffset));
+		prefs.put(N, Integer.toString(sNImages));
+		prefs.put(GAP, Integer.toString(sGapBetweenImages>2147483647?0:(int)sGapBetweenImages));
+		int options = 0;
+		if (sWhiteIsZero)
+			options |= WHITE_IS_ZERO;
+		if (sIntelByteOrder)
+			options |= INTEL_BYTE_ORDER;
+		prefs.put(OPTIONS, Integer.toString(options));
+	}
+	
+	/** Returns the FileInfo object used to import the last raw image,
+		or null if a raw image has not been imported. */
+	public static FileInfo getLastFileInfo() {
+		return lastFileInfo;
+	}
+		
+	private void getDimensionsFromName(String name) {
+		if (name==null)
+			return;
+		if (!name.matches(".*[0-9]+x[0-9]+.*"))
+			return; // must have 'x' seperator
+		int lastUnderscore = name.lastIndexOf("_");
+		String name2 = name;
+		if (lastUnderscore>=0)
+			name2 = name.substring(lastUnderscore);
+		char[] chars = new char[name2.length()];
+		for (int i=0; i<name2.length(); i++)  // change non-digits to spaces
+			chars[i] = Character.isDigit(name2.charAt(i))?name2.charAt(i):' ';
+		name2 = new String(chars);
+		String[] numbers = Tools.split(name2);
+		int n = numbers.length;
+		if (n<2) return;
+		int w = (int)Tools.parseDouble(numbers[0],0);
+		if (w<1) return;
+		int h = (int)Tools.parseDouble(numbers[1],0);
+		if (h<1) return;
+		width = w;
+		height = h;
+		nImages = 1;
+		if (n>2) {
+			int d = (int)Tools.parseDouble(numbers[2],0);
+			if (d>0)
+				nImages = d;
+		}
+		guessFormat(directory, name);
+	}
+    
+	private void guessFormat(String dir, String name) {
+		if (dir==null) return;
+		File file = new File(dir+name);
+		long imageSize = (long)width*height*nImages;
+		long fileSize = file.length();
+		if (fileSize==4*imageSize)
+			choiceSelection = 5; // 32-bit real
+		else if (fileSize==2*imageSize)
+			choiceSelection = 2;	// 16-bit unsigned
+		else if (fileSize==3*imageSize)
+			choiceSelection = 7;	// 24-bit RGB
+		else if (fileSize==imageSize)
+			choiceSelection = 0;	// 8-bit
+		if (name.endsWith("be.raw"))  // big-endian
+			intelByteOrder = false;
+		else if (name.endsWith("le.raw"))  // little-endian
+			intelByteOrder = true;
+	}
+	
+}
diff --git a/src/ij/io/LogStream.java b/src/ij/io/LogStream.java
new file mode 100644
index 0000000..33d6cac
--- /dev/null
+++ b/src/ij/io/LogStream.java
@@ -0,0 +1,203 @@
+package ij.io;
+import ij.IJ;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+
+/**
+ * This class provides the functionality to divert output sent to the System.out
+ * and System.err streams to ImageJ's log console. The purpose is to allow 
+ * use of existing Java classes or writing new generic Java classes that only 
+ * output to System.out and are thus less dependent on ImageJ.
+ * See the ImageJ plugin Redirect_System_Streams at
+ *    http://staff.fh-hagenberg.at/burger/imagej/
+ * for usage examples.
+ *
+ * @author Wilhelm Burger (wilbur at ieee.org)
+ * See Also: Redirect_System_Streams (http://staff.fh-hagenberg.at/burger/imagej/)
+ */
+public class LogStream extends PrintStream {
+	
+	private static String outPrefix = "out> ";	// prefix string for System.out
+	private static String errPrefix = "err >";	// prefix string for System.err
+	
+	private static PrintStream originalSystemOut = null;
+	private static PrintStream originalSystemErr = null;
+	private static PrintStream temporarySystemOut = null;
+	private static PrintStream temporarySystemErr = null;
+	
+	/**
+	 * Redirects all output sent to <code>System.out</code> and <code>System.err</code> to ImageJ's log console
+	 * using the default prefixes.
+	 */
+	public static void redirectSystem(boolean redirect) {
+		if (redirect)
+			redirectSystem();
+		else
+			revertSystem();
+	}
+	
+	/**
+	 * Redirects all output sent to <code>System.out</code> and <code>System.err</code> to ImageJ's log console
+	 * using the default prefixes.
+	 * Alternatively use 
+	 * {@link #redirectSystemOut(String)} and {@link #redirectSystemErr(String)}
+	 * to redirect the streams separately and to specify individual prefixes.
+	 */
+	public static void redirectSystem() {
+		redirectSystemOut(outPrefix);
+		redirectSystemErr(errPrefix);
+	}
+
+	/**
+	 * Redirects all output sent to <code>System.out</code> to ImageJ's log console.
+	 * @param prefix The prefix string inserted at the start of each output line. 
+	 * Pass <code>null</code>  to use the default prefix or an empty string to 
+	 * remove the prefix.
+	 */
+	public static void redirectSystemOut(String prefix) {
+		if (originalSystemOut == null) {		// has no effect if System.out is already replaced
+			originalSystemOut = System.out;		// remember the original System.out stream
+			temporarySystemOut = new LogStream(prefix);
+			System.setOut(temporarySystemOut);
+		}
+	}
+	
+	/**
+	 * Redirects all output sent to <code>System.err</code> to ImageJ's log console.
+	 * @param prefix The prefix string inserted at the start of each output line. 
+	 * Pass <code>null</code>  to use the default prefix or an empty string to 
+	 * remove the prefix.
+	 */
+	public static void redirectSystemErr(String prefix) {
+		if (originalSystemErr == null) {		// has no effect if System.out is already replaced
+			originalSystemErr = System.err;		// remember the original System.out stream
+			temporarySystemErr = new LogStream(prefix);
+			System.setErr(temporarySystemErr);
+		}
+	}
+	
+	/**
+	 * Returns the redirection stream for {@code System.out} if it exists.
+	 * Note that a reference to the current output stream can also be obtained directly from 
+	 * the {@code System.out} field.
+	 * @return A reference to the {@code PrintStream} object currently substituting {@code System.out}
+	 * or {@code null} of if {@code System.out} is currently not redirected.
+	 */
+	public static PrintStream getCurrentOutStream() {
+		return temporarySystemOut;
+	}
+	
+	/**
+	 * Returns the redirection stream for {@code System.err} if it exists.
+	 * Note that a reference to the current output stream can also be obtained directly from 
+	 * the {@code System.err} field.
+	 * @return A reference to the {@code PrintStream} object currently substituting {@code System.err}
+	 * or {@code null} of if {@code System.err} is currently not redirected.
+	 */
+	public static PrintStream getCurrentErrStream() {
+		return temporarySystemErr;
+	}
+	
+	/**
+	 * Use this method to revert both <code>System.out</code> and <code>System.err</code> 
+	 * to their original output streams.
+	 */
+	public static void revertSystem() {
+		revertSystemOut();
+		revertSystemErr();
+	}
+
+	/**
+	 * Use this method to revert<code>System.out</code>
+	 * to the original output stream.
+	 */
+	public static void revertSystemOut() {
+		if (originalSystemOut != null && temporarySystemOut != null) {
+			temporarySystemOut.flush();
+			temporarySystemOut.close();
+			System.setOut(originalSystemOut);
+			originalSystemOut = null;
+			temporarySystemOut = null;
+		}
+	}
+	
+	/**
+	 * Use this method to revert<code>System.err</code>
+	 * to the original output stream.
+	 */
+	public static void revertSystemErr() {
+		if (originalSystemErr != null && temporarySystemErr != null) {
+			temporarySystemErr.flush();
+			temporarySystemErr.close();
+			System.setErr(originalSystemErr);
+			originalSystemErr = null;
+			temporarySystemErr = null;
+		}
+	}
+	
+	// ----------------------------------------------------------------
+	
+	private final String endOfLineSystem = System.getProperty("line.separator"); 
+	private final String endOfLineShort = String.format("\n"); 	
+	private final ByteArrayOutputStream byteStream;
+	private final String prefix;
+	
+	public LogStream() {
+		super(new ByteArrayOutputStream());
+		this.byteStream = (ByteArrayOutputStream) this.out;
+		this.prefix = "";
+	}
+
+	private LogStream(String prefix) {
+		super(new ByteArrayOutputStream());
+		this.byteStream = (ByteArrayOutputStream) this.out;
+		this.prefix = (prefix == null) ? "" : prefix;
+	}
+	
+	@Override
+	// ever called?
+	public void write(byte[] b) {
+		this.write(b, 0, b.length);
+	}
+	
+	@Override
+	public void write(byte[] b, int off, int len) {
+		String msg = new String(b, off, len);
+		if (msg.equals(endOfLineSystem) || msg.equals(endOfLineShort)) { // this is a newline sequence only
+			ejectBuffer();
+		} else {
+			byteStream.write(b, off, len);	// append message to buffer
+			if (msg.endsWith(endOfLineSystem) || msg.endsWith(endOfLineShort)) { // line terminated by Newline
+				// note that this does not seem to happen ever (even with format)!?
+				ejectBuffer();
+			}
+		}
+	}
+	
+	@Override
+	// ever called?
+	public void write(int b) {
+		byteStream.write(b);
+	}
+
+	@Override
+	public void flush() {
+		if (byteStream.size() > 0) {
+			String msg = byteStream.toString();
+			if (msg.endsWith(endOfLineSystem) || msg.endsWith(endOfLineShort))
+				ejectBuffer();
+		}
+		super.flush();
+	}
+	
+	@Override
+	public void close() {
+		super.close();
+	}
+	
+	private void ejectBuffer() {
+		IJ.log(prefix + byteStream.toString());
+		byteStream.reset();
+	}
+	
+}
diff --git a/src/ij/io/OpenDialog.java b/src/ij/io/OpenDialog.java
new file mode 100644
index 0000000..33090a3
--- /dev/null
+++ b/src/ij/io/OpenDialog.java
@@ -0,0 +1,266 @@
+package ij.io;
+import ij.*;
+import ij.gui.*;
+import ij.plugin.frame.Recorder;
+import ij.util.Java2;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.io.*;
+import javax.swing.*;
+import javax.swing.filechooser.*;
+
+/** This class displays a dialog window from 
+ * which the user can select an input file.
+*/ 
+public class OpenDialog {
+
+	private String dir;
+	private String name;
+	private boolean recordPath;
+	private static String defaultDirectory;
+	private static Frame sharedFrame;
+	private String title;
+	private static String lastDir, lastName;
+	private static boolean defaultDirectorySet;
+
+	
+	/** Displays a file open dialog with 'title' as the title. */
+	public OpenDialog(String title) {
+		this(title, null);
+	}
+
+	/** Displays a file open dialog with 'title' as
+		the title. If 'path' is non-blank, it is
+		used and the dialog is not displayed. Uses
+		and updates the ImageJ default directory. */
+	public OpenDialog(String title, String path) {
+		String macroOptions = Macro.getOptions();
+		if (macroOptions!=null && (path==null||path.equals(""))) {
+			path = Macro.getValue(macroOptions, title, path);
+			if (path==null || path.equals(""))
+				path = Macro.getValue(macroOptions, "path", path);
+			if ((path==null || path.equals("")) && title!=null && title.equals("Open As String"))
+				path = Macro.getValue(macroOptions, "OpenAsString", path);
+			path = lookupPathVariable(path);
+		}
+		if (path==null || path.equals("")) {
+			if (Prefs.useJFileChooser)
+				jOpen(title, getDefaultDirectory(), null);
+			else
+				open(title, getDefaultDirectory(), null);
+			if (name!=null)
+				setDefaultDirectory(dir);
+			this.title = title;
+			recordPath = true;
+		} else {
+			decodePath(path);
+			recordPath = IJ.macroRunning();
+		}
+		IJ.register(OpenDialog.class);
+	}
+	
+	/** Displays a file open dialog, using the specified 
+		default directory and file name. */
+	public OpenDialog(String title, String defaultDir, String defaultName) {
+		String path = null;
+		String macroOptions = Macro.getOptions();
+		if (macroOptions!=null)
+			path = Macro.getValue(macroOptions, title, path);
+		if (path!=null)
+			decodePath(path);
+		else {
+			if (Prefs.useJFileChooser)
+				jOpen(title, defaultDir, defaultName);
+			else
+				open(title, defaultDir, defaultName);
+			this.title = title;
+			recordPath = true;
+		}
+	}
+	
+	public static String lookupPathVariable(String path) {
+		if (path!=null && path.indexOf(".")==-1 && !((new File(path)).exists())) {
+			if (path.startsWith("&")) path=path.substring(1);
+			Interpreter interp = Interpreter.getInstance();
+			String path2 = interp!=null?interp.getStringVariable(path):null;
+			if (path2!=null) path = path2;
+		}
+		return path;
+	}
+
+	// Uses JFileChooser to display file open dialog box.
+	void jOpen(String title, String path, String fileName) {
+		Java2.setSystemLookAndFeel();
+		if (EventQueue.isDispatchThread())
+			jOpenDispatchThread(title, path, fileName);
+		else
+			jOpenInvokeAndWait(title, path, fileName);
+	}
+		
+	// Uses the JFileChooser class to display the dialog box.
+	// Assumes we are running on the event dispatch thread
+	void jOpenDispatchThread(String title, String path, final String fileName) {
+		JFileChooser fc = new JFileChooser();
+		fc.setDialogTitle(title);
+		fc.setDragEnabled(true);
+		fc.setTransferHandler(new DragAndDropHandler(fc));
+		File fdir = null;
+		if (path!=null)
+			fdir = new File(path);
+		if (fdir!=null)
+			fc.setCurrentDirectory(fdir);
+		if (fileName!=null)
+			fc.setSelectedFile(new File(fileName));
+		int returnVal = fc.showOpenDialog(IJ.getInstance());
+		if (returnVal!=JFileChooser.APPROVE_OPTION)
+			{Macro.abort(); return;}
+		File file = fc.getSelectedFile();
+		if (file==null)
+			{Macro.abort(); return;}
+		name = file.getName();
+		dir = fc.getCurrentDirectory().getPath()+File.separator;
+	}
+
+	// Run JFileChooser on event dispatch thread to avoid deadlocks
+	void jOpenInvokeAndWait(final String title, final String path, final String fileName) {
+		final boolean isMacro = Thread.currentThread().getName().endsWith("Macro$");
+		try {
+			EventQueue.invokeAndWait(new Runnable() {
+				public void run() {
+				JFileChooser fc = new JFileChooser();
+				fc.setDialogTitle(title);
+				fc.setDragEnabled(true);
+				fc.setTransferHandler(new DragAndDropHandler(fc));
+				File fdir = null;
+				if (path!=null)
+					fdir = new File(path);
+				if (fdir!=null)
+					fc.setCurrentDirectory(fdir);
+				if (fileName!=null)
+					fc.setSelectedFile(new File(fileName));
+				int returnVal = fc.showOpenDialog(IJ.getInstance());
+				if (returnVal!=JFileChooser.APPROVE_OPTION && isMacro)
+					{Interpreter.abort(); return;}
+				File file = fc.getSelectedFile();
+				if (file==null && isMacro)
+					{Interpreter.abort(); return;}
+				name = file.getName();
+				dir = fc.getCurrentDirectory().getPath()+File.separator;
+				}
+			});
+		} catch (Exception e) {}
+	}
+	
+	// Uses the AWT FileDialog class to display the dialog box
+	void open(String title, String path, String fileName) {
+		Frame parent = IJ.getInstance();
+		if (parent==null) {
+			if (sharedFrame==null) sharedFrame = new Frame();
+			parent = sharedFrame;
+		}
+		if (IJ.isMacOSX() && IJ.isJava18()) {
+			ImageJ ij = IJ.getInstance();
+			if (ij!=null && ij.isActive())
+				parent = ij;
+			else
+				parent = null;
+		}
+		FileDialog fd = new FileDialog(parent, title);
+		if (path!=null) {
+			if (IJ.isWindows() && path.contains("/"))
+				path = path.replaceAll("/","\\\\"); // work around FileDialog.setDirectory() bug
+			fd.setDirectory(path);
+		}
+		if (fileName!=null)
+			fd.setFile(fileName);
+		fd.show();
+		name = fd.getFile();
+		if (name==null) {
+			if (IJ.isMacOSX())
+				System.setProperty("apple.awt.fileDialogForDirectories", "false");
+			Macro.abort();
+		} else
+			dir = fd.getDirectory();
+	}
+
+	void decodePath(String path) {
+		int i = path.lastIndexOf('/');
+		if (i==-1)
+			i = path.lastIndexOf('\\');
+		if (i>0) {
+			dir = path.substring(0, i+1);
+			name = path.substring(i+1);
+		} else {
+			dir = "";
+			name = path;
+		}
+	}
+
+	/** Returns the selected directory. */
+	public String getDirectory() {
+		lastDir = dir;
+		return dir;
+	}
+	
+	/** Returns the selected file name. */
+	public String getFileName() {
+		if (name!=null) {
+			if (Recorder.record && recordPath && dir!=null)
+				Recorder.recordPath(title, dir+name);
+			lastName = name;
+		}
+		return name;
+	}
+		
+	/** Returns the selected file path or null if the dialog was canceled. */
+	public String getPath() {
+		if (getFileName()==null)
+			return null;
+		else return
+			getDirectory() + getFileName();
+	}
+
+	/** Returns the current working directory as a string
+		ending in the separator character ("/" or "\"), or
+		an empty or null string. */
+	public static String getDefaultDirectory() {
+		if (Prefs.commandLineMacro() && !defaultDirectorySet)
+			return IJ.getDir("cwd");
+		if (defaultDirectory==null)
+			defaultDirectory = Prefs.getDefaultDirectory();
+		return defaultDirectory;
+	}
+
+	/** Sets the current working directory.
+	 * @see ij.plugin.frame.Editor#setDefaultDirectory
+	*/
+	public static void setDefaultDirectory(String dir) {
+		dir = IJ.addSeparator(dir);
+		defaultDirectory = dir;
+		defaultDirectorySet = true;
+	}
+	
+	/** Returns the path to the directory that contains the last file
+		 opened or saved, or null if a file has not been opened or saved. */
+	public static String getLastDirectory() {
+		return lastDir;
+	}
+		
+	/** Sets the path to the directory containing the last file opened by the user. */
+	public static void setLastDirectory(String dir) {
+		lastDir = dir;
+	}
+
+	/** Returns the name of the last file opened by the user
+		using a file open or file save dialog, or using drag and drop.
+		Returns null if the users has not opened a file. */
+	public static String getLastName() {
+		return lastName;
+	}
+
+	/** Sets the name of the last file opened by the user. */
+	public static void setLastName(String name) {
+		lastName = name;
+	}
+
+}
diff --git a/src/ij/io/Opener.java b/src/ij/io/Opener.java
new file mode 100644
index 0000000..3503c3b
--- /dev/null
+++ b/src/ij/io/Opener.java
@@ -0,0 +1,1388 @@
+package ij.io;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.frame.*;
+import ij.plugin.*;
+import ij.text.TextWindow;
+import ij.util.Java2;
+import ij.measure.ResultsTable;
+import ij.macro.Interpreter;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.net.URL;
+import java.net.*;
+import java.util.*;
+import java.util.zip.*;
+import javax.swing.*;
+import javax.swing.filechooser.*;
+import java.awt.event.KeyEvent;
+import javax.imageio.ImageIO;
+import java.lang.reflect.Method;
+
+/** Opens tiff (and tiff stacks), dicom, fits, pgm, jpeg, bmp or
+	gif images, and look-up tables, using a file open dialog or a path.
+	Calls HandleExtraFileTypes plugin if the file type is unrecognised. */
+public class Opener {
+
+	public static final int UNKNOWN=0,TIFF=1,DICOM=2,FITS=3,PGM=4,JPEG=5,
+		GIF=6,LUT=7,BMP=8,ZIP=9,JAVA_OR_TEXT=10,ROI=11,TEXT=12,PNG=13,
+		TIFF_AND_DICOM=14,CUSTOM=15, AVI=16, OJJ=17, TABLE=18, RAW=19; // don't forget to also update 'types'
+	public static final String[] types = {"unknown","tif","dcm","fits","pgm",
+		"jpg","gif","lut","bmp","zip","java/txt","roi","txt","png","t&d","custom","ojj","table","raw"};
+	private static String defaultDirectory = null;
+	private int fileType;
+	private boolean error;
+	private boolean isRGB48;
+	private boolean silentMode;
+	private String omDirectory;
+	private File[] omFiles;
+	private static boolean openUsingPlugins;
+	private static boolean bioformats;
+	private String url;
+
+	static {
+		Hashtable commands = Menus.getCommands();
+		bioformats = commands!=null && commands.get("Bio-Formats Importer")!=null;
+	}
+
+	public Opener() {
+	}
+
+	/**
+	 * Displays a file open dialog box and then opens the tiff, dicom, 
+	 * fits, pgm, jpeg, bmp, gif, lut, roi, or text file selected by 
+	 * the user. Displays an error message if the selected file is not
+	 * in a supported format. This is the method that
+	 * ImageJ's File/Open command uses to open files.
+	 * @see ij.IJ#open()
+	 * @see ij.IJ#open(String)
+	 * @see ij.IJ#openImage()
+	 * @see ij.IJ#openImage(String)
+	*/
+	public void open() {
+		OpenDialog od = new OpenDialog("Open", "");
+		String directory = od.getDirectory();
+		String name = od.getFileName();
+		if (name!=null) {
+			String path = directory+name;
+			error = false;
+			open(path);
+			if (!error) Menus.addOpenRecentItem(path);
+		}
+	}
+
+	/**
+	 * Opens and displays the specified tiff, dicom, fits, pgm, jpeg, 
+	 * bmp, gif, lut, roi, or text file. Displays an error message if 
+	 * the file is not in a supported format.
+	 * @see ij.IJ#open(String)
+	 * @see ij.IJ#openImage(String)
+	*/
+	public void open(String path) {
+		boolean isURL = path.contains("://") || path.contains("file:/");
+		if (isURL && isText(path)) {
+			openTextURL(path);
+			return;
+		}
+		if (path.endsWith(".jar") || path.endsWith(".class")) {
+				(new PluginInstaller()).install(path);
+				return;
+		}
+		path = makeFullPath(path);
+		if (!silentMode)
+			IJ.showStatus("Opening: " + path);
+		long start = System.currentTimeMillis();
+		ImagePlus imp = null;
+		if (path.endsWith(".txt"))
+			this.fileType = JAVA_OR_TEXT;
+		else
+			imp = openImage(path);
+		if (imp==null && isURL)
+			return;
+		if (imp!=null) {
+			WindowManager.checkForDuplicateName = true;
+			if (isRGB48)
+				openRGB48(imp);
+			else
+				imp.show(getLoadRate(start,imp));
+		} else {
+			switch (this.fileType) {
+				case LUT:
+					imp = (ImagePlus)IJ.runPlugIn("ij.plugin.LutLoader", path);
+					if (imp.getWidth()!=0)
+						imp.show();
+					break;
+				case ROI:
+					IJ.runPlugIn("ij.plugin.RoiReader", path);
+					break;
+				case JAVA_OR_TEXT: case TEXT:
+					if (IJ.altKeyDown()) { // open in TextWindow if alt key down
+						new TextWindow(path,400,450);
+						IJ.setKeyUp(KeyEvent.VK_ALT);
+						break;
+					}
+					File file = new File(path);
+					int maxSize = 250000;
+					long size = file.length();
+					if (size>=28000) {
+						String osName = System.getProperty("os.name");
+						if (osName.equals("Windows 95") || osName.equals("Windows 98") || osName.equals("Windows Me"))
+							maxSize = 60000;
+					}
+					if (size<maxSize) {
+						Editor ed = new Editor(path);
+						if (ed!=null) ed.open(getDir(path), getName(path));
+					} else
+						new TextWindow(path,400,450);
+					break;
+				case OJJ:  // ObjectJ project
+					IJ.runPlugIn("ObjectJ_", path);
+					break;
+				case TABLE: 
+					openTable(path);
+					break;
+				case RAW:
+					IJ.runPlugIn("ij.plugin.Raw", path);
+					break;
+				case UNKNOWN:
+					File f = new File(path);
+					String msg = (f.exists()) ?
+						"Format not supported or reader plugin not found:"
+						: "File not found:";					
+					if (path!=null) {
+						if (path.length()>64)
+							path = (new File(path)).getName();
+						if (path.length()<=64)
+								msg += " \n"+path;
+					}
+					if (openUsingPlugins && msg.length()>20)
+						msg += "\n \nNOTE: The \"OpenUsingPlugins\" option is set.";
+					IJ.wait(IJ.isMacro()?500:100); // work around for OS X thread deadlock problem
+					IJ.error("Opener", msg);
+					error = true;
+					break;
+			}
+		}
+	}
+		
+	/** Displays a JFileChooser and then opens the tiff, dicom, 
+		fits, pgm, jpeg, bmp, gif, lut, roi, or text files selected by 
+		the user. Displays error messages if one or more of the selected 
+		files is not in one of the supported formats. This is the method
+		that ImageJ's File/Open command uses to open files if
+		"Open/Save Using JFileChooser" is checked in EditOptions/Misc. */
+	public void openMultiple() {
+		Java2.setSystemLookAndFeel();
+		// run JFileChooser in a separate thread to avoid possible thread deadlocks
+		try {
+			EventQueue.invokeAndWait(new Runnable() {
+				public void run() {
+					JFileChooser fc = new JFileChooser();
+					fc.setMultiSelectionEnabled(true);
+					fc.setDragEnabled(true);
+					fc.setTransferHandler(new DragAndDropHandler(fc));
+					File dir = null;
+					String sdir = OpenDialog.getDefaultDirectory();
+					if (sdir!=null)
+						dir = new File(sdir);
+					if (dir!=null)
+						fc.setCurrentDirectory(dir);
+					if (IJ.debugMode) IJ.log("Opener.openMultiple: "+sdir+" "+dir);
+					int returnVal = fc.showOpenDialog(IJ.getInstance());
+					if (returnVal!=JFileChooser.APPROVE_OPTION)
+						return;
+					omFiles = fc.getSelectedFiles();
+					if (omFiles.length==0) { // getSelectedFiles does not work on some JVMs
+						omFiles = new File[1];
+						omFiles[0] = fc.getSelectedFile();
+					}
+					omDirectory = fc.getCurrentDirectory().getPath()+File.separator;
+				}
+			});
+		} catch (Exception e) {}
+		if (omDirectory==null) return;
+		OpenDialog.setDefaultDirectory(omDirectory);
+		for (int i=0; i<omFiles.length; i++) {
+			String path = omDirectory + omFiles[i].getName();
+			open(path);
+			if (i==0 && Recorder.record)
+				Recorder.recordPath("open", path);
+			if (i==0 && !error)
+				Menus.addOpenRecentItem(path);
+		}
+	}
+	
+	/**
+	 * Opens, but does not display, the specified image file
+	 * and returns an ImagePlus object object if successful,
+	 * or returns null if the file is not in a supported format
+	 * or is not found. Displays a file open dialog if 'path'
+	 * is null or an empty string.
+	 * @see ij.IJ#openImage(String)
+	 * @see ij.IJ#openImage()
+	*/
+	public ImagePlus openImage(String path) {
+		if (path==null || path.equals(""))
+			path = getPath();
+		if (path==null) return null;
+		ImagePlus img = null;
+		if (path.contains("://") || path.contains("file:/")) // path is a URL
+			img = openURL(path);
+		else
+			img = openImage(getDir(path), getName(path));
+		return img;
+	}
+	
+	/**
+	 * Open the nth image of the specified tiff stack.
+	 * @see ij.IJ#openImage(String,int)
+	*/
+	public ImagePlus openImage(String path, int n) {
+		if (path==null || path.equals(""))
+			path = getPath();
+		if (path==null) return null;
+		int type = getFileType(path);
+		if (type!=TIFF)
+			throw new IllegalArgumentException("Opener: TIFF file required");
+		return openTiff(path, n);
+	}
+
+	public static String getLoadRate(double time, ImagePlus imp) {
+		time = (System.currentTimeMillis()-time)/1000.0;
+		double mb = imp.getWidth()*imp.getHeight()*imp.getStackSize();
+		int bits = imp.getBitDepth();
+		if (bits==16)
+			mb *= 2;
+		else if (bits==24 || bits==32)
+			mb *=4;
+		mb /= 1024*1024;
+		double rate = mb/time;
+		int digits = rate<100.0?1:0;
+		return ""+IJ.d2s(time,2)+" seconds ("+IJ.d2s(mb/time,digits)+" MB/sec)";
+	}
+	
+	public static String makeFullPath(String path) {
+		if (path==null)
+			return path;
+		if (!isFullPath(path)) {
+			String defaultDir = OpenDialog.getDefaultDirectory();
+			if (defaultDir!=null)
+				path = defaultDir + path;
+			else
+				path = (new File(path)).getAbsolutePath();
+		}
+		return path;
+	}
+	
+	public static boolean isFullPath(String path) {
+		if (path==null)
+			return false;
+		else
+			return path.startsWith("/") || path.startsWith("\\") || path.contains(":\\") || path.contains(":/") || path.contains("://");
+	}
+
+	private boolean isText(String path) {
+		if (path.endsWith(".txt") || path.endsWith(".ijm") || path.endsWith(".java")
+		|| path.endsWith(".js") || path.endsWith(".html") || path.endsWith(".htm")
+		|| path.endsWith(".bsh") || path.endsWith(".py") || path.endsWith("/"))
+			return true;
+		int lastSlash = path.lastIndexOf("/");
+		if (lastSlash==-1) lastSlash = 0;
+		int lastDot = path.lastIndexOf(".");
+		if (lastDot==-1 || lastDot<lastSlash || (path.length()-lastDot)>6)
+			return true;  // no extension
+		else
+			return false;
+	}
+	
+	/** Opens the specified file and adds it to the File/Open Recent menu.
+		Returns true if the file was opened successfully.  */
+	public boolean openAndAddToRecent(String path) {
+		open(path);
+		if (!error)
+			Menus.addOpenRecentItem(path);
+		return error;
+	}
+
+	/**
+	 * Attempts to open the specified file as a tiff, bmp, dicom, fits,
+	 * pgm, gif or jpeg image. Returns an ImagePlus object if successful.
+	 * Modified by Gregory Jefferis to call HandleExtraFileTypes plugin if 
+	 * the file type is unrecognised.
+	 * @see ij.IJ#openImage(String)
+	*/
+	public ImagePlus openImage(String directory, String name) {
+		ImagePlus imp;
+		FileOpener.setSilentMode(silentMode);
+		if (directory.length()>0 && !(directory.endsWith("/")||directory.endsWith("\\")))
+			directory += Prefs.separator;
+		OpenDialog.setLastDirectory(directory);
+		OpenDialog.setLastName(name);
+		String path = directory+name;
+		this.fileType = getFileType(path);
+		if (IJ.debugMode) IJ.log("openImage: \""+types[this.fileType]+"\", "+path);
+		switch (this.fileType) {
+			case TIFF:
+				imp = openTiff(directory, name);
+				return imp;
+			case DICOM: case TIFF_AND_DICOM:
+				imp = (ImagePlus)IJ.runPlugIn("ij.plugin.DICOM", path);
+				if (imp.getWidth()!=0) return imp; else return null;
+			case FITS:
+				imp = (ImagePlus)IJ.runPlugIn("ij.plugin.FITS_Reader", path);
+				if (imp.getWidth()!=0) return imp; else return null;
+			case PGM:
+				imp = (ImagePlus)IJ.runPlugIn("ij.plugin.PGM_Reader", path);
+				if (imp.getWidth()!=0) {
+					if (imp.getStackSize()==3 && imp.getBitDepth()==16)
+						imp = new CompositeImage(imp, IJ.COMPOSITE);
+					return imp;
+				} else
+					return null;
+			case JPEG:
+				imp = openJpegOrGif(directory, name);
+				if (imp!=null&&imp.getWidth()!=0) return imp; else return null;
+			case GIF:
+				imp = (ImagePlus)IJ.runPlugIn("ij.plugin.GIF_Reader", path);
+				if (imp!=null&&imp.getWidth()!=0) return imp; else return null;
+			case PNG: 
+				imp = openUsingImageIO(directory+name);
+				if (imp!=null&&imp.getWidth()!=0) return imp; else return null;
+			case BMP:
+				imp = (ImagePlus)IJ.runPlugIn("ij.plugin.BMP_Reader", path);
+				if (imp.getWidth()!=0) return imp; else return null;
+			case ZIP:
+				return openZip(path);
+			case AVI:
+				AVI_Reader reader = new AVI_Reader();
+				reader.setVirtual(true);
+				reader.displayDialog(!IJ.macroRunning());
+				reader.run(path);
+				return reader.getImagePlus();
+			case JAVA_OR_TEXT:
+				if (name.endsWith(".txt"))
+					return openTextImage(directory,name);
+				else
+					return null;
+			case UNKNOWN: case TEXT:
+				return openUsingHandleExtraFileTypes(path);
+			default:
+				return null;
+		}
+	}
+	
+	public ImagePlus openTempImage(String directory, String name) {
+		ImagePlus imp = openImage(directory, name);
+		if (imp!=null)
+			imp.setTemporary();
+		return imp;
+	}
+	
+	// Call HandleExtraFileTypes plugin to see if it can handle unknown formats
+	// or files in TIFF format that the built in reader is unable to open.
+	private ImagePlus openUsingHandleExtraFileTypes(String path) {
+		File f = new File(path);
+		if (!f.exists())
+			return null;
+		int[] wrap = new int[] {this.fileType};
+		ImagePlus imp = openWithHandleExtraFileTypes(path, wrap);
+		if (imp!=null && imp.getNChannels()>1)
+			imp = new CompositeImage(imp, IJ.COLOR);
+		this.fileType = wrap[0];
+		return imp;
+	}
+	
+	String getPath() {
+		OpenDialog od = new OpenDialog("Open", "");
+		String dir = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+			return null;
+		else
+			return dir+name;
+	}
+
+	/** Opens the specified text file as a float image. */
+	public ImagePlus openTextImage(String dir, String name) {
+		String path = dir+name;
+		TextReader tr = new TextReader();
+		ImageProcessor ip = tr.open(path);
+		return ip!=null?new ImagePlus(name,ip):null;
+	}
+
+	/**
+	 * Attempts to open the specified url as a tiff, zip compressed tiff, 
+	 * dicom, gif or jpeg. Tiff file names must end in ".tif", ZIP file names 
+	 * must end in ".zip" and dicom file names must end in ".dcm". Returns an 
+	 * ImagePlus object if successful.
+	 * @see ij.IJ#openImage(String)
+	*/
+	public ImagePlus openURL(String url) {
+		url = updateUrl(url);
+		if (IJ.debugMode) IJ.log("OpenURL: "+url);
+		ImagePlus imp = openCachedImage(url);
+		if (imp!=null)
+			return imp;
+		try {
+			String name = "";
+			int index = url.lastIndexOf('/');
+			if (index==-1)
+				index = url.lastIndexOf('\\');
+			if (index>0)
+				name = url.substring(index+1);
+			else
+				throw new MalformedURLException("Invalid URL: "+url);
+			if (url.indexOf(" ")!=-1)
+				url = url.replaceAll(" ", "%20");
+			URL u = new URL(url);
+			IJ.showStatus(""+url);
+			String lurl = url.toLowerCase(Locale.US);
+			if (lurl.endsWith(".tif")) {
+				this.url = url;
+				imp = openTiff(u.openStream(), name);
+			} else if (lurl.endsWith(".zip"))
+				imp = openZipUsingUrl(u);
+			else if (lurl.endsWith(".jpg") || lurl.endsWith(".jpeg") || lurl.endsWith(".gif"))
+				imp = openJpegOrGifUsingURL(name, u);
+			else if (lurl.endsWith(".dcm") || lurl.endsWith(".ima")) {
+				imp = (ImagePlus)IJ.runPlugIn("ij.plugin.DICOM", url);
+				if (imp!=null && imp.getWidth()==0) imp = null;
+			} else if (lurl.endsWith(".png"))
+				imp = openPngUsingURL(name, u);
+			else {
+				URLConnection uc = u.openConnection();
+				String type = uc.getContentType();
+				if (type!=null && (type.equals("image/jpeg")||type.equals("image/gif")))
+					imp = openJpegOrGifUsingURL(name, u);
+				else if (type!=null && type.equals("image/png"))
+					imp = openPngUsingURL(name, u);
+				else
+					imp = openWithHandleExtraFileTypes(url, new int[]{0});
+			}
+			IJ.showStatus("");
+			return imp;
+		} catch (Exception e) {
+			String msg = e.getMessage();
+			if (msg==null || msg.equals(""))
+				msg = "" + e;
+			msg += "\n"+url;
+			IJ.error("Open URL", msg);
+			return null;
+		} 
+	}
+	
+	/** Can't open imagej.nih.gov URLs due to encryption so redirect to imagej.net mirror. */
+	public static String updateUrl(String url) {
+		if (url==null || !url.contains("nih.gov"))
+			return url;
+		if (IJ.isJava18())
+			url = url.replace("http:", "https:");
+		else {
+			url = url.replace("imagej.nih.gov/ij", "imagej.net");
+			url = url.replace("rsb.info.nih.gov/ij", "imagej.net");
+			url = url.replace("rsbweb.nih.gov/ij", "imagej.net");
+		}
+		return url;
+	}
+	
+	private ImagePlus openCachedImage(String url) {
+		if (url==null || !url.contains("/images"))
+			return null;
+		String ijDir = IJ.getDirectory("imagej");
+		if (ijDir==null)
+			return null;
+		int slash = url.lastIndexOf('/');
+		File file = new File(ijDir + "samples", url.substring(slash+1));
+		if (!file.exists())
+			return null;
+		if (url.endsWith(".gif"))  // ij.plugin.GIF_Reader does not correctly handle inverting LUTs
+			return openJpegOrGif(file.getParent()+File.separator, file.getName());
+		return IJ.openImage(file.getPath());
+	}
+
+	/** Used by open() and IJ.open() to open text URLs. */
+	void openTextURL(String url) {
+		if (url.endsWith(".pdf")||url.endsWith(".zip"))
+			return;
+		String text = IJ.openUrlAsString(url);
+		if (text!=null && text.startsWith("<Error: ")) {
+			IJ.error("Open Text URL", text);
+			return;
+		}
+		String name = url.substring(7);
+		int index = name.lastIndexOf("/");
+		int len = name.length();
+		if (index==len-1)
+			name = name.substring(0, len-1);
+		else if (index!=-1 && index<len-1)
+			name = name.substring(index+1);
+		name = name.replaceAll("%20", " ");
+		Editor ed = new Editor(name);
+		ed.setSize(600, 300);
+		ed.create(name, text);
+		IJ.showStatus("");
+	}
+
+	
+	public ImagePlus openWithHandleExtraFileTypes(String path, int[] fileTypes) {
+		ImagePlus imp = null;
+		if (path.endsWith(".db")) {
+			// skip hidden Thumbs.db files on Windows
+			fileTypes[0] = CUSTOM;
+			return null;
+		}
+		imp = (ImagePlus)IJ.runPlugIn("HandleExtraFileTypes", path);
+		if (imp==null) return null;
+		FileInfo fi = imp.getOriginalFileInfo();
+		if (fi==null) {
+			fi = new FileInfo();
+			fi.width = imp.getWidth();
+			fi.height = imp.getHeight();
+			fi.directory = getDir(path);
+			fi.fileName = getName(path);
+			imp.setFileInfo(fi);
+		}
+		if (imp.getWidth()>0 && imp.getHeight()>0) {
+			fileTypes[0] = CUSTOM;
+			return imp;
+		} else {
+			if (imp.getWidth()==-1)
+				fileTypes[0] = CUSTOM; // plugin opened image so don't display error
+			return null;
+		}
+	}
+
+	/** Opens the ZIP compressed TIFF or DICOM at the specified URL. */
+	ImagePlus openZipUsingUrl(URL url) throws IOException {
+		URLConnection uc = url.openConnection();
+		InputStream in = uc.getInputStream();
+		ZipInputStream zis = new ZipInputStream(in);
+		ZipEntry entry = zis.getNextEntry();
+		if (entry==null) {
+			zis.close();
+			return null;
+		}
+		String name = entry.getName();
+		if (!(name.endsWith(".tif")||name.endsWith(".dcm")))
+			throw new IOException("This ZIP archive does not appear to contain a .tif or .dcm file\n"+name);
+		if (name.endsWith(".dcm"))
+			return openDicomStack(zis, entry);
+		else
+			return openTiff(zis, name);
+	}
+	
+	ImagePlus openDicomStack(ZipInputStream zis, ZipEntry entry) throws IOException {
+		ImagePlus imp = null;
+		int count = 0;
+		ImageStack stack = null;
+		while (true) {
+			if (count>0) entry = zis.getNextEntry();
+			if (entry==null) break;
+			String name = entry.getName();
+			ImagePlus imp2 = null;
+			if (name.endsWith(".dcm")) {
+				ByteArrayOutputStream out = new ByteArrayOutputStream();
+				byte[] buf = new byte[4096];
+				int len, byteCount=0, progress=0;
+				while (true) {
+					len = zis.read(buf);
+					if (len<0) break;
+					out.write(buf, 0, len);
+					byteCount += len;
+					//IJ.showProgress((double)(byteCount%fileSize)/fileSize);
+				}
+				byte[] bytes = out.toByteArray();
+				out.close();
+				InputStream is = new ByteArrayInputStream(bytes);
+				DICOM dcm = new DICOM(is);
+				dcm.run(name);
+				imp2 = dcm;
+				is.close();
+			}
+			zis.closeEntry();
+			if (imp2==null) continue;
+			count++;
+			String label = imp2.getTitle();
+			String info = (String)imp2.getProperty("Info");
+			if (info!=null) label += "\n" + info;
+			if (count==1) {
+				imp = imp2;
+				imp.getStack().setSliceLabel(label, 1);
+			} else {
+				stack = imp.getStack();
+				stack.addSlice(label, imp2.getProcessor());
+				imp.setStack(stack);
+			}
+		}
+		zis.close();
+		IJ.showProgress(1.0);
+		if (count==0)
+			throw new IOException("This ZIP archive does not appear to contain any .dcm files");
+		return imp;
+	}
+
+	ImagePlus openJpegOrGifUsingURL(String title, URL url) {
+		if (url==null) return null;
+		Image img = Toolkit.getDefaultToolkit().createImage(url);
+		if (img!=null) {
+			ImagePlus imp = new ImagePlus(title, img);
+			return imp;
+		} else
+			return null;
+	}
+
+	ImagePlus openPngUsingURL(String title, URL url) {
+		if (url==null)
+			return null;
+		Image img = null;
+		try {
+			InputStream in = url.openStream();
+			img = ImageIO.read(in);
+		} catch (FileNotFoundException e) {
+			IJ.error("Open PNG Using URL", ""+e);
+		} catch (IOException e) {
+			IJ.handleException(e);
+		}
+		if (img!=null) {
+			ImagePlus imp = new ImagePlus(title, img);
+			return imp;
+		} else
+			return null;
+	}
+
+	ImagePlus openJpegOrGif(String dir, String name) {
+		ImagePlus imp = null;
+		Image img = Toolkit.getDefaultToolkit().createImage(dir+name);
+		if (img!=null) {
+			try {
+				imp = new ImagePlus(name, img);
+			} catch (Exception e) {
+				IJ.error("Opener", e.getMessage()+"\n(Note: ImageJ cannot open CMYK JPEGs)\n \n"+dir+name);
+				return null; // error loading image
+			}				
+			if (imp.getType()==ImagePlus.COLOR_RGB)
+				convertGrayJpegTo8Bits(imp);
+			FileInfo fi = new FileInfo();
+			fi.fileFormat = fi.GIF_OR_JPG;
+			fi.fileName = name;
+			fi.directory = dir;
+			imp.setFileInfo(fi);
+		}
+		if (imp != null) {  // correct iPhone photo orientation (Norbert Vischer)
+			String exifText = new ImageInfo().getExifData(imp);
+			if (exifText != null) {
+				String[] lines = exifText.split("\n");
+				for (int jj = 0; jj < lines.length; jj++) {
+					int orientationIndex = lines[jj].indexOf("Orientation:");
+					int rotateIndex = lines[jj].indexOf("Rotate");
+					if (orientationIndex >= 0 && rotateIndex >= 0) {
+						String rest = lines[jj].substring(rotateIndex);
+						rest = rest.replace(")", " ");
+						String[] parts = rest.split(" ");
+						if (parts.length >= 2) {
+							ImageProcessor ip = imp.getProcessor();
+							double angle = Double.parseDouble(parts[1]);
+							ImageProcessor ip2 = null;
+							if (angle == 90)
+								ip2 = ip.rotateRight();
+							else if (angle == 180) {
+								ip2 = ip.rotateRight();
+								ip2 = ip2.rotateRight();
+							} else if (angle == 270)
+								ip2 = ip.rotateLeft();
+							if (ip2!=null)
+								imp.setProcessor(ip2);
+							break;
+						}
+					}
+				}
+			}
+		}
+		return imp;
+	}
+	
+	ImagePlus openUsingImageIO(String path) {
+		ImagePlus imp = null;
+		BufferedImage img = null;
+		File f = new File(path);
+		try {
+			img = ImageIO.read(f);
+		} catch (Exception e) {
+			IJ.error("Open Using ImageIO", ""+e);
+		} 
+		if (img==null)
+			return null;
+		if (img.getColorModel().hasAlpha()) {
+			int width = img.getWidth();
+			int height = img.getHeight();
+			BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
+			Graphics g = bi.getGraphics();
+			g.setColor(Color.white);
+			g.fillRect(0,0,width,height);
+			g.drawImage(img, 0, 0, null);
+			img = bi;
+		}
+		imp = new ImagePlus(f.getName(), img);
+		FileInfo fi = new FileInfo();
+		fi.fileFormat = fi.IMAGEIO;
+		fi.fileName = f.getName();
+		String parent = f.getParent();
+		if (parent!=null)
+			fi.directory = parent + File.separator;
+		imp.setFileInfo(fi);
+		return imp;
+	}
+
+	/** Converts the specified RGB image to 8-bits if the 3 channels are identical. */
+	public static void convertGrayJpegTo8Bits(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.getBitDepth()==24 && ip.isGrayscale()) {
+			IJ.showStatus("Converting to 8-bit grayscale");
+			new ImageConverter(imp).convertToGray8();
+		}
+	}
+
+	/** Are all the images in this file the same size and type? */
+	boolean allSameSizeAndType(FileInfo[] info) {
+		boolean sameSizeAndType = true;
+		boolean contiguous = true;
+		long startingOffset = info[0].getOffset();
+		int size = info[0].width*info[0].height*info[0].getBytesPerPixel();
+		for (int i=1; i<info.length; i++) {
+			sameSizeAndType &= info[i].fileType==info[0].fileType
+				&& info[i].width==info[0].width
+				&& info[i].height==info[0].height;
+			contiguous &= info[i].getOffset()==startingOffset+i*size;
+		}
+		if (contiguous &&  info[0].fileType!=FileInfo.RGB48)
+			info[0].nImages = info.length;
+		//if (IJ.debugMode) {
+		//	IJ.log("sameSizeAndType: " + sameSizeAndType);
+		//	IJ.log("contiguous: " + contiguous);
+		//}
+		return sameSizeAndType;
+	}
+	
+	/** Attemps to open a tiff file as a stack. Returns 
+		an ImagePlus object if successful. */
+	public ImagePlus openTiffStack(FileInfo[] info) {
+		if (info.length>1 && !allSameSizeAndType(info))
+			return null;
+		FileInfo fi = info[0];
+		if (fi.nImages>1)
+			return new FileOpener(fi).openImage(); // open contiguous images as stack
+		else {
+			ColorModel cm = createColorModel(fi);
+			ImageStack stack = new ImageStack(fi.width, fi.height, cm);
+			Object pixels = null;
+			long skip = fi.getOffset();
+			int imageSize = fi.width*fi.height*fi.getBytesPerPixel();
+			if (info[0].fileType==FileInfo.GRAY12_UNSIGNED) {
+				imageSize = (int)(fi.width*fi.height*1.5);
+				if ((imageSize&1)==1) imageSize++; // add 1 if odd
+			} if (info[0].fileType==FileInfo.BITMAP) {
+				int scan=(int)Math.ceil(fi.width/8.0);
+				imageSize = scan*fi.height;
+			}
+			long loc = 0L;
+			int nChannels = 1;
+			try {
+				InputStream is = createInputStream(fi);
+				ImageReader reader = new ImageReader(fi);
+				IJ.resetEscape();
+				for (int i=0; i<info.length; i++) {
+					nChannels = 1;
+					Object[] channels = null;
+					if (!silentMode)
+						IJ.showStatus("Reading: " + (i+1) + "/" + info.length);
+					if (IJ.escapePressed()) {
+						IJ.beep();
+						IJ.showProgress(1.0);
+						return null;
+					}
+					fi.stripOffsets = info[i].stripOffsets;
+					fi.stripLengths = info[i].stripLengths;
+					int bpp = info[i].getBytesPerPixel();
+					if (info[i].samplesPerPixel>1 && !(bpp==3||bpp==4||bpp==6)) {
+						nChannels = fi.samplesPerPixel;
+						channels = new Object[nChannels];
+						for (int c=0; c<nChannels; c++) {
+							pixels = reader.readPixels(is, c==0?skip:0L);
+							channels[c] = pixels;
+						}
+					} else 
+						pixels = reader.readPixels(is, skip);
+					if (pixels==null && channels==null) break;
+					loc += imageSize*nChannels+skip;
+					if (i<(info.length-1)) {
+						skip = info[i+1].getOffset()-loc;
+						if (info[i+1].compression>=FileInfo.LZW) skip = 0;
+						if (skip<0L) {
+							IJ.error("Opener", "Unexpected image offset");
+							break;
+						}
+					}
+					if (fi.fileType==FileInfo.RGB48) {
+						Object[] pixels2 = (Object[])pixels;
+						stack.addSlice(null, pixels2[0]);					
+						stack.addSlice(null, pixels2[1]);					
+						stack.addSlice(null, pixels2[2]);
+						isRGB48 = true;					
+					} else if (nChannels>1) {
+						for (int c=0; c<nChannels; c++) {
+							if (channels[c]!=null)
+								stack.addSlice(null, channels[c]);
+						}
+					} else
+						stack.addSlice(null, pixels);
+					IJ.showProgress(i, info.length);
+				}
+				is.close();
+			}
+			catch (Exception e) {
+				IJ.handleException(e);
+			}
+			catch(OutOfMemoryError e) {
+				IJ.outOfMemory(fi.fileName);
+				stack.deleteLastSlice();
+				stack.deleteLastSlice();
+			}
+			IJ.showProgress(1.0);
+			if (stack.size()==0)
+				return null;
+			if (fi.fileType==FileInfo.GRAY16_UNSIGNED||fi.fileType==FileInfo.GRAY12_UNSIGNED
+			||fi.fileType==FileInfo.GRAY32_FLOAT||fi.fileType==FileInfo.RGB48) {
+				ImageProcessor ip = stack.getProcessor(1);
+				ip.resetMinAndMax();
+				stack.update(ip);
+			}
+			//if (fi.whiteIsZero)
+			//	new StackProcessor(stack, stack.getProcessor(1)).invert();
+			ImagePlus imp = new ImagePlus(fi.fileName, stack);
+			new FileOpener(fi).setCalibration(imp);
+			imp.setFileInfo(fi);
+			if (fi.info!=null)
+				imp.setProperty("Info", fi.info);
+			if (fi.description!=null && fi.description.contains("order=zct"))
+				new HyperStackConverter().shuffle(imp, HyperStackConverter.ZCT);
+			int stackSize = stack.size();
+			if (nChannels>1 && (stackSize%nChannels)==0) {
+				imp.setDimensions(nChannels, stackSize/nChannels, 1);
+				imp = new CompositeImage(imp, IJ.COMPOSITE);
+				imp.setOpenAsHyperStack(true);
+			} else if (imp.getNChannels()>1)
+				imp = makeComposite(imp, fi);
+			IJ.showProgress(1.0);
+			return imp;
+		}
+	}
+	
+	/** Attempts to open the specified file as a tiff.
+		Returns an ImagePlus object if successful. */
+	public ImagePlus openTiff(String directory, String name) {
+		TiffDecoder td = new TiffDecoder(directory, name);
+		if (IJ.debugMode) td.enableDebugging();
+		FileInfo[] info=null;
+		try {
+			info = td.getTiffInfo();
+		} catch (IOException e) {
+			this.fileType = TIFF;
+			directory = IJ.addSeparator(directory);
+			return openUsingHandleExtraFileTypes(directory+name);
+		}
+		if (info==null)
+			return null;
+		return openTiff2(info);
+	}
+	
+	/** Opens the nth image of the specified TIFF stack. */
+	public ImagePlus openTiff(String path, int n) {
+		TiffDecoder td = new TiffDecoder(getDir(path), getName(path));
+		if (IJ.debugMode) td.enableDebugging();
+		FileInfo[] info=null;
+		try {
+			info = td.getTiffInfo();
+		} catch (IOException e) {
+			String msg = e.getMessage();
+			if (msg==null||msg.equals("")) msg = ""+e;
+			IJ.error("Open TIFF", msg);
+			return null;
+		}
+		if (info==null) return null;
+		FileInfo fi = info[0];
+		if (info.length==1 && fi.nImages>1) {
+			if (n<1 || n>fi.nImages)
+				throw new IllegalArgumentException("N out of 1-"+fi.nImages+" range");
+			long size = fi.width*fi.height*fi.getBytesPerPixel();
+			fi.longOffset = fi.getOffset() + (n-1)*(size+fi.getGap());
+			fi.offset = 0;
+			fi.nImages = 1;
+		} else {
+			if (n<1 || n>info.length)
+				throw new IllegalArgumentException("N out of 1-"+info.length+" range");
+			fi.longOffset = info[n-1].getOffset();
+			fi.offset = 0;
+			fi.stripOffsets = info[n-1].stripOffsets; 
+			fi.stripLengths = info[n-1].stripLengths; 
+		}
+		FileOpener fo = new FileOpener(fi);
+		return fo.openImage();
+	}
+
+	/** Returns the FileInfo of the specified TIFF file. */
+	public static FileInfo[] getTiffFileInfo(String path) {
+		Opener o = new Opener();
+		TiffDecoder td = new TiffDecoder(o.getDir(path), o.getName(path));
+		if (IJ.debugMode) td.enableDebugging();
+		try {
+			return td.getTiffInfo();
+		} catch (IOException e) {
+			return null;
+		}
+	}
+
+	/** Attempts to open the specified inputStream as a
+		TIFF, returning an ImagePlus object if successful. */
+	public ImagePlus openTiff(InputStream in, String name) {
+		FileInfo[] info = null;
+		try {
+			TiffDecoder td = new TiffDecoder(in, name);
+			if (IJ.debugMode) td.enableDebugging();
+			info = td.getTiffInfo();
+		} catch (FileNotFoundException e) {
+			IJ.error("Open TIFF", "File not found: "+e.getMessage());
+			return null;
+		} catch (Exception e) {
+			IJ.error("Open TIFF", ""+e);
+			return null;
+		}
+		if (url!=null && info!=null && info.length==1 && info[0].inputStream!=null) {
+			try {
+				info[0].inputStream.close();
+			} catch (IOException e) {}
+			try {
+				info[0].inputStream = new URL(url).openStream();
+			} catch (Exception e) {
+				IJ.error("Open TIFF", ""+e);
+				return null;
+			}
+		}
+		return openTiff2(info);
+	}
+
+	/** Opens a single TIFF or DICOM contained in a ZIP archive,
+		or a ZIPed collection of ".roi" files created by the ROI manager. */	
+	public ImagePlus openZip(String path) {
+		ImagePlus imp = null;
+		try {
+			ZipInputStream zis = new ZipInputStream(new FileInputStream(path));
+			ZipEntry entry = zis.getNextEntry();
+			if (entry==null) {
+				zis.close();
+				return null;
+			}
+			String name = entry.getName();
+			if (name.endsWith(".roi")) {
+				zis.close();
+				if (!silentMode)
+					if (IJ.isMacro() && Interpreter.isBatchMode() && RoiManager.getInstance()==null)
+						IJ.log("Use roiManager(\"Open\", path) instead of open(path)\nto open ROI sets in batch mode macros.");
+					else
+						IJ.runMacro("roiManager(\"Open\", getArgument());", path);
+				return null;
+			}
+			if (name.endsWith(".tif")) {
+				imp = openTiff(zis, name);
+			} else if (name.endsWith(".dcm")) {
+				DICOM dcm = new DICOM(zis);
+				dcm.run(name);
+				imp = dcm;
+			} else {
+				zis.close();
+				String msg = "This ZIP archive does not contain a TIFF or DICOM file, or ROIs:\n   "+path;
+				if (silentMode)
+					IJ.log(msg);
+				else
+					IJ.error("Opener", msg);
+				return null;
+			}
+			zis.close();
+		} catch (Exception e) {
+			IJ.error("Opener", ""+e);
+			return null;
+		}
+		File f = new File(path);
+		FileInfo fi = imp.getOriginalFileInfo();
+		if (fi!=null) {
+			fi.fileFormat = FileInfo.ZIP_ARCHIVE;
+			fi.fileName = f.getName();
+			String parent = f.getParent();
+			if (parent!=null)
+				fi.directory = parent+File.separator;
+		}
+		return imp;
+	}
+	
+	/** Deserialize a byte array that was serialized using the FileSaver.serialize(). */
+	public ImagePlus deserialize(byte[] bytes) {
+		ByteArrayInputStream stream = new ByteArrayInputStream(bytes);
+		TiffDecoder decoder = new TiffDecoder(stream, "Untitled");
+		if (IJ.debugMode)
+			decoder.enableDebugging();
+		FileInfo[] info = null;
+		try {
+			info = decoder.getTiffInfo();
+		} catch (IOException e) {
+			return null;
+		}
+		FileOpener opener = new FileOpener(info[0]);
+		ImagePlus imp = opener.openImage();
+		if (imp==null)
+			return null;
+		imp.setTitle(info[0].fileName);
+		imp = makeComposite(imp, info[0]);
+		return imp;
+   }
+   
+	private ImagePlus makeComposite(ImagePlus imp, FileInfo fi) {
+		int c = imp.getNChannels();
+		boolean composite = c>1 && fi.description!=null && fi.description.indexOf("mode=")!=-1;
+		if (c>1 && (imp.getOpenAsHyperStack()||composite) && !imp.isComposite() && imp.getType()!=ImagePlus.COLOR_RGB) {
+			int mode = IJ.COLOR;
+			if (fi.description!=null) {
+				if (fi.description.indexOf("mode=composite")!=-1)
+					mode = IJ.COMPOSITE;
+				else if (fi.description.indexOf("mode=gray")!=-1)
+					mode = IJ.GRAYSCALE;
+			}
+			imp = new CompositeImage(imp, mode);
+		}
+		return imp;
+	}
+
+		
+	public String getName(String path) {
+		int i = path.lastIndexOf('/');
+		if (i==-1)
+			i = path.lastIndexOf('\\');
+		if (i>0)
+			return path.substring(i+1);
+		else
+			return path;
+	}
+	
+	public String getDir(String path) {
+		int i = path.lastIndexOf('/');
+		if (i==-1)
+			i = path.lastIndexOf('\\');
+		if (i>0)
+			return path.substring(0, i+1);
+		else
+			return "";
+	}
+
+	ImagePlus openTiff2(FileInfo[] info) {
+		if (info==null)
+			return null;
+		ImagePlus imp = null;
+		if (IJ.debugMode) // dump tiff tags
+			IJ.log(info[0].debugInfo);
+		if (info.length>1) { // try to open as stack
+			imp = openTiffStack(info);
+			if (imp!=null)
+				return imp;
+		}
+		FileOpener fo = new FileOpener(info[0]);
+		imp = fo.openImage();
+		if (imp==null)
+			return null;
+		int[] offsets = info[0].stripOffsets;
+		if (offsets!=null&&offsets.length>1 && offsets[offsets.length-1]<offsets[0])
+			ij.IJ.run(imp, "Flip Vertically", "stack");
+		imp = makeComposite(imp, info[0]);
+		if (imp.getBitDepth()==32 && imp.getTitle().startsWith("FFT of"))
+			return openFFT(imp);
+		else
+			return imp;
+	}
+	
+	private ImagePlus openFFT(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		FHT fht = new FHT(ip, true);
+		ImageProcessor ps = fht.getPowerSpectrum();
+		ImagePlus imp2 = new ImagePlus(imp.getTitle(), ps);
+		imp2.setProperty("FHT", fht);
+		imp2.setProperty("Info", imp.getInfoProperty());
+		fht.originalWidth = (int)imp2.getNumericProperty("width");
+		fht.originalHeight = (int)imp2.getNumericProperty("height");
+		fht.originalBitDepth = (int)imp2.getNumericProperty("bitdepth");
+		fht.originalColorModel = ip.getColorModel();
+		imp2.setCalibration(imp.getCalibration());
+		return imp2;
+	}
+	
+	/** Attempts to open the specified ROI, returning null if unsuccessful. */
+	public Roi openRoi(String path) {
+		Roi roi = null;
+		RoiDecoder rd = new RoiDecoder(path);
+		try {roi = rd.getRoi();}
+		catch (IOException e) {
+			IJ.error("RoiDecoder", e.getMessage());
+			return null;
+		}
+		return roi;
+	}
+	
+	/** Opens an image file using the Bio-Formats plugin. */
+	public static ImagePlus openUsingBioFormats(String path) {
+		String className = "loci.plugins.BF";
+		String methodName = "openImagePlus";
+		try {
+			Class c = IJ.getClassLoader().loadClass(className);
+			if (c==null)
+				return null;
+			Class[] argClasses = new Class[1];
+			argClasses[0] = methodName.getClass();
+			Method m = c.getMethod(methodName, argClasses);
+			Object[] args = new Object[1];
+			args[0] = path;
+			Object obj = m.invoke(null, args);
+			ImagePlus[] images = obj!=null?(ImagePlus[])obj:null;
+			if (images==null || images.length==0)
+				return null;
+			ImagePlus imp = images[0];
+			if (imp.getStackSize()==3 && imp.getNChannels()==3 && imp.getBitDepth()==8)
+				imp = imp.flatten();
+			return imp;
+		} catch(Exception e) {
+		}
+		return null;
+	}
+
+	/** Opens a lookup table (LUT) and returns it as a LUT object, or returns null if there is an error.
+	 * @see ij.ImagePlus#setLut
+	*/
+	public static LUT openLut(String filePathOrUrl) {
+		return LutLoader.openLut(filePathOrUrl);
+	}
+
+	/** Opens a tab or comma delimited text file in the Results window. */
+	public static void openResultsTable(String path) {
+		try {
+			ResultsTable rt = ResultsTable.open(path);
+			if (rt!=null) {
+				rt.showRowNumbers(true);
+				rt.show("Results");
+			}
+		} catch(IOException e) {
+			IJ.error("Open Results", e.getMessage());
+		}
+	}
+	
+	/** Opens a tab or comma delimited text file. */
+	public static void openTable(String path) {
+		String name = "";
+		if (path==null || path.equals("")) {
+			OpenDialog od = new OpenDialog("Open Table...");
+			String dir = od.getDirectory();
+			name = od.getFileName();
+			if (name==null)
+				return;
+			else
+				path = dir+name;
+		} else {
+			name = (new Opener()).getName(path);
+			if (name.startsWith("Results."))
+				name = "Results";
+		}
+		try {
+			ResultsTable rt = ResultsTable.open(path);
+			if (rt!=null)
+				rt.show(name);
+		} catch(IOException e) {
+			IJ.error("Open Table", e.getMessage());
+		}
+	}
+
+	public static String getFileFormat(String path) {
+		if (!((new File(path)).exists()))
+			return("not found");
+		else
+			return Opener.types[(new Opener()).getFileType(path)];
+	}
+	
+	/**
+	Attempts to determine the image file type by looking for
+	'magic numbers' and the file name extension.
+	 */
+	public int getFileType(String path) {
+		if (openUsingPlugins && !path.endsWith(".txt") &&  !path.endsWith(".java"))
+			return UNKNOWN;
+		File file = new File(path);
+		String name = file.getName();
+		InputStream is;
+		byte[] buf = new byte[132];
+		try {
+			is = new FileInputStream(file);
+			is.read(buf, 0, 132);
+			is.close();
+		} catch (IOException e) {
+			return UNKNOWN;
+		}
+		
+		int b0=buf[0]&255, b1=buf[1]&255, b2=buf[2]&255, b3=buf[3]&255;
+		//IJ.log("getFileType: "+ name+" "+b0+" "+b1+" "+b2+" "+b3);
+		
+		 // Combined TIFF and DICOM created by GE Senographe scanners
+		if (buf[128]==68 && buf[129]==73 && buf[130]==67 && buf[131]==77
+		&& ((b0==73 && b1==73)||(b0==77 && b1==77)))
+			return TIFF_AND_DICOM;
+
+		 // Big-endian TIFF ("MM")
+		if (name.endsWith(".lsm"))
+				return UNKNOWN; // The LSM	Reader plugin opens these files
+		if (b0==73 && b1==73 && b2==42 && b3==0 && !(bioformats&&name.endsWith(".flex")))
+			return TIFF;
+
+		 // Little-endian TIFF ("II")
+		if (b0==77 && b1==77 && b2==0 && b3==42)
+			return TIFF;
+
+		 // JPEG
+		if (b0==255 && b1==216 && b2==255)
+			return JPEG;
+
+		 // GIF ("GIF8")
+		if (b0==71 && b1==73 && b2==70 && b3==56)
+			return GIF;
+
+		name = name.toLowerCase(Locale.US);
+
+		 // DICOM ("DICM" at offset 128)
+		if (buf[128]==68 && buf[129]==73 && buf[130]==67 && buf[131]==77 || name.endsWith(".dcm")) {
+			return DICOM;
+		}
+
+		// ACR/NEMA with first tag = 00002,00xx or 00008,00xx
+		if ((b0==8||b0==2) && b1==0 && b3==0 && !name.endsWith(".spe") && !name.equals("fid"))	
+				return DICOM;
+
+		// PGM ("P1", "P4", "P2", "P5", "P3" or "P6")
+		if (b0==80&&(b1==49||b1==52||b1==50||b1==53||b1==51||b1==54)&&(b2==10||b2==13||b2==32||b2==9))
+			return PGM;
+
+		// Lookup table
+		if (name.endsWith(".lut"))
+			return LUT;
+		
+		// PNG
+		if (b0==137 && b1==80 && b2==78 && b3==71)
+			return PNG;
+				
+		// ZIP containing a TIFF
+		if (name.endsWith(".zip"))
+			return ZIP;
+
+		// FITS ("SIMP")
+		if ((b0==83 && b1==73 && b2==77 && b3==80) || name.endsWith(".fts.gz") || name.endsWith(".fits.gz"))
+			return FITS;
+			
+		// Java source file, text file or macro
+		if (name.endsWith(".java") || name.endsWith(".txt") || name.endsWith(".ijm") || name.endsWith(".js")
+			|| name.endsWith(".bsh") || name.endsWith(".py") || name.endsWith(".html"))
+			return JAVA_OR_TEXT;
+
+		// ImageJ, NIH Image, Scion Image for Windows ROI
+		if (b0==73 && b1==111) // "Iout"
+			return ROI;
+			
+		// ObjectJ project
+		if ((b0=='o' && b1=='j' && b2=='j' && b3==0) || name.endsWith(".ojj") )
+			return OJJ;
+
+		// Results table (tab-delimited or comma-separated tabular text)
+		if (name.endsWith(".xls") || name.endsWith(".csv") || name.endsWith(".tsv")) 
+			return TABLE;
+
+		// AVI
+		if (name.endsWith(".avi"))
+			return AVI;
+
+		// Text file
+		boolean isText = true;
+		for (int i=0; i<10; i++) {
+		  int c = buf[i]&255;
+		  if ((c<32&&c!=9&&c!=10&&c!=13) || c>126) {
+			  isText = false;
+			  break;
+		  }
+		}
+		if (isText)
+		   return TEXT;
+
+		// BMP ("BM")
+		if ((b0==66 && b1==77)||name.endsWith(".dib"))
+			return BMP;
+				
+		// RAW
+		if (name.endsWith(".raw") && !Prefs.skipRawDialog)
+			return RAW;
+
+		return UNKNOWN;
+	}
+
+	/** Returns an IndexColorModel for the image specified by this FileInfo. */
+	ColorModel createColorModel(FileInfo fi) {
+		if (fi.lutSize>0)
+			return new IndexColorModel(8, fi.lutSize, fi.reds, fi.greens, fi.blues);
+		else
+			return LookUpTable.createGrayscaleColorModel(fi.whiteIsZero);
+	}
+
+	/** Returns an InputStream for the image described by this FileInfo. */
+	InputStream createInputStream(FileInfo fi) throws IOException, MalformedURLException {
+		if (fi.inputStream!=null)
+			return fi.inputStream;
+		else if (fi.url!=null && !fi.url.equals(""))
+			return new URL(fi.url+fi.fileName).openStream();
+		else {
+			File f = new File(fi.getFilePath());
+			if (f==null || f.isDirectory())
+				return null;
+			else {
+				InputStream is = new FileInputStream(f);
+				if (fi.compression>=FileInfo.LZW || (fi.stripOffsets!=null&&fi.stripOffsets.length>1))
+					is = new RandomAccessStream(is);
+				return is;
+			}
+		}
+	}
+	
+	void openRGB48(ImagePlus imp) {
+			isRGB48 = false;
+			int stackSize = imp.getStackSize();
+			imp.setDimensions(3, stackSize/3, 1);
+			imp = new CompositeImage(imp, IJ.COMPOSITE);
+			imp.show();
+	}
+	
+	/** The "Opening: path" status message is not displayed in silent mode. */
+	public void setSilentMode(boolean mode) {
+		silentMode = mode;
+	}
+
+	/** Open all images using HandleExtraFileTypes. Set from
+		a macro using setOption("openUsingPlugins", true). */
+	public static void setOpenUsingPlugins(boolean b) {
+		openUsingPlugins = b;
+	}
+
+	/** Returns the state of the openUsingPlugins flag. */
+	public static boolean getOpenUsingPlugins() {
+		return openUsingPlugins;
+	}
+		
+}
diff --git a/src/ij/io/PluginClassLoader.java b/src/ij/io/PluginClassLoader.java
new file mode 100644
index 0000000..5f2572d
--- /dev/null
+++ b/src/ij/io/PluginClassLoader.java
@@ -0,0 +1,105 @@
+package ij.io;
+import ij.IJ;
+import java.io.*;
+import java.net.*;
+
+/** ImageJ uses this class loader to load plugins and resources from the
+ * plugins directory and immediate subdirectories. This class loader will
+ * also load classes and resources from JAR files.
+ *
+ * <p> The class loader searches for classes and resources in the following order:
+ * <ol>
+ *  <li> Plugins directory</li>
+ *  <li> Subdirectories of the Plugins directory</li>
+ *  <li> JAR and ZIP files in the plugins directory and subdirectories</li>
+ * </ol>
+ * <p> The class loader does not recurse into subdirectories beyond the first level.
+*/
+public class PluginClassLoader extends URLClassLoader {
+    protected String path;
+
+    /**
+     * Creates a new PluginClassLoader that searches in the directory path
+     * passed as a parameter. The constructor automatically finds all JAR and ZIP
+     * files in the path and first level of subdirectories. The JAR and ZIP files
+     * are stored in a Vector for future searches.
+     * @param path the path to the plugins directory.
+     */
+	public PluginClassLoader(String path) {
+		super(new URL[0], IJ.class.getClassLoader());
+		init(path);
+	}
+	
+	/** This version of the constructor is used when ImageJ is launched using Java WebStart. */
+	public PluginClassLoader(String path, boolean callSuper) {
+		super(new URL[0], Thread.currentThread().getContextClassLoader());
+		init(path);
+	}
+
+	void init(String path) {
+		this.path = path;
+
+		//find all JAR files on the path and subdirectories
+		File f = new File(path);
+        try {
+            // Add plugin directory to search path
+            addURL(f.toURI().toURL());
+        } catch (MalformedURLException e) {
+            ij.IJ.log("PluginClassLoader: "+e);
+        }
+		String[] list = f.list();
+		if (list==null)
+			return;
+		for (int i=0; i<list.length; i++) {
+			if (list[i].equals(".rsrc"))
+				continue;
+			File f2=new File(path, list[i]);
+			if (f2.isDirectory())
+				addDirectory(f2);
+			else 
+				addJar(f2);
+		}
+		addDirectory(f, "jars"); // add ImageJ/jars; requested by Wilhelm Burger
+	}
+
+	private void addDirectory(File f) {
+		//if (IJ.debugMode) IJ.log("PluginClassLoader.addDirectory: "+f);
+		try {
+			// Add first level subdirectories to search path
+			addURL(f.toURI().toURL());
+		} catch (MalformedURLException e) {
+			ij.IJ.log("PluginClassLoader: "+e);
+		}
+		String[] innerlist = f.list();
+		if (innerlist==null)
+			return;
+		for (int j=0; j<innerlist.length; j++) {
+			File g = new File(f,innerlist[j]);
+			if (g.isFile())
+				addJar(g);
+		}
+	}
+
+    private void addJar(File f) {
+        if (f.getName().endsWith(".jar") || f.getName().endsWith(".zip")) {
+			//if (IJ.debugMode) IJ.log("PluginClassLoader.addJar: "+f);
+            try {
+                addURL(f.toURI().toURL());
+            } catch (MalformedURLException e) {
+				ij.IJ.log("PluginClassLoader: "+e);
+            }
+        }
+    }
+
+	private void addDirectory(File f, String name) {
+		f = f.getParentFile();
+		if (f==null)
+			return;
+		f = new File(f, name);
+		if (f==null)
+			return;
+		if (f.isDirectory())
+			addDirectory(f);
+	}
+
+}
diff --git a/src/ij/io/RandomAccessStream.java b/src/ij/io/RandomAccessStream.java
new file mode 100644
index 0000000..5b997ff
--- /dev/null
+++ b/src/ij/io/RandomAccessStream.java
@@ -0,0 +1,192 @@
+package ij.io;
+import ij.IJ;
+import java.io.*;
+import java.util.Vector;
+
+
+/** This class uses a memory cache to allow seeking within
+	an InputStream. Based on the JAI MemoryCacheSeekableStream class.
+	Can also be constructed from a RandomAccessFile, which uses less
+	memory since the memory cache is not required.
+*/ 
+public final class RandomAccessStream extends InputStream {
+
+    private static final int BLOCK_SIZE = 1024;
+    private static final int BLOCK_MASK = 1023;
+    private static final int BLOCK_SHIFT = 10;
+
+    private InputStream src;
+    private RandomAccessFile ras;
+    private long pointer;
+    private Vector data;
+    private long length;
+    private boolean foundEOS;
+    
+    /** Constructs a RandomAccessStream from an InputStream. Seeking
+		backwards is supported using a memory cache. */
+	public RandomAccessStream(InputStream inputstream) {
+        pointer = 0L;
+        data = new Vector();
+        length = 0L;
+        foundEOS = false;
+        src = inputstream;
+    }
+
+    /** Constructs a RandomAccessStream from an RandomAccessFile. */
+	public RandomAccessStream(RandomAccessFile ras) {
+		this.ras = ras;
+    }
+
+    public int getFilePointer() throws IOException {
+    	if (ras!=null)
+    		return (int)ras.getFilePointer();
+    	else
+        	return (int)pointer;
+    }
+
+    public long getLongFilePointer() throws IOException {
+    	if (ras!=null)
+    		return ras.getFilePointer();
+    	else
+        	return pointer;
+    }
+
+    public int read() throws IOException {
+    	if (ras!=null)
+    		return ras.read();
+        long l = pointer + 1L;
+        long l1 = readUntil(l);
+        if (l1>=l) {
+            byte abyte0[] = (byte[])data.elementAt((int)(pointer>>BLOCK_SHIFT));
+            return abyte0[(int)(pointer++ & BLOCK_MASK)] & 0xff;
+        } else
+            return -1;
+    }
+
+    public int read(byte[] bytes, int off, int len) throws IOException {
+        if(bytes == null)
+            throw new NullPointerException();
+     	if (ras!=null)
+    		return ras.read(bytes, off, len);
+        if (off<0 || len<0 || off+len>bytes.length)
+            throw new IndexOutOfBoundsException();
+        if (len == 0)
+            return 0;
+        long l = readUntil(pointer+len);
+        if (l<=pointer)
+            return -1;
+        else {
+            byte abyte1[] = (byte[])data.elementAt((int)(pointer >> BLOCK_SHIFT));
+            int k = Math.min(len, BLOCK_SIZE - (int)(pointer & BLOCK_MASK));
+            System.arraycopy(abyte1, (int)(pointer & BLOCK_MASK), bytes, off, k);
+            pointer += k;
+            return k;
+        }
+    }
+
+    public final void readFully(byte[] bytes) throws IOException {
+        readFully(bytes, bytes.length);
+    }
+
+    public final void readFully(byte[] bytes, int len) throws IOException {
+   		int read = 0;
+        do {
+            int l = read(bytes, read, len - read);
+            if(l < 0) break;
+            read += l;
+        } while (read<len);
+    }
+
+    private long readUntil(long l) throws IOException {
+        if (l<length)
+            return l;
+        if (foundEOS)
+            return length;
+        int i = (int)(l>>BLOCK_SHIFT);
+        int j = (int)(length>>BLOCK_SHIFT);
+        for (int k=j; k<=i; k++) {
+            byte abyte0[] = new byte[BLOCK_SIZE];
+            data.addElement(abyte0);
+            int i1 = BLOCK_SIZE;
+            int j1 = 0;
+            while (i1>0) {
+                int k1 = src.read(abyte0, j1, i1);
+                if (k1==-1) {
+                    foundEOS = true;
+                    return length;
+                }
+                j1 += k1;
+                i1 -= k1;
+                length += k1;
+            }
+        }
+        return length;
+    }
+
+    public void seek(long loc) throws IOException {
+		//IJ.log("seek (long): "+loc+"  "+(ras!=null));
+    	if (ras!=null)
+    		{ras.seek(loc); return;}
+        if (loc<0L)
+			pointer = 0L;
+        else
+            pointer = loc;
+    }
+
+	public void seek(int loc) throws IOException {
+		long lloc = ((long)loc)&0xffffffffL;
+		//IJ.log("seek (int): "+lloc+"  "+(ras!=null));
+		if (ras!=null) {
+			ras.seek(lloc);
+			return;
+		}
+		if (lloc<0L)
+			pointer = 0L;
+		else
+			pointer = lloc;
+	}
+
+    public final int readInt() throws IOException {
+        int i = read();
+        int j = read();
+        int k = read();
+        int l = read();
+        if ((i | j | k | l) < 0)
+            throw new EOFException();
+        else
+            return (i << 24) + (j << 16) + (k << 8) + l;
+    }
+
+    public final long readLong() throws IOException {
+        return ((long)readInt()<<32) + ((long)readInt()&0xffffffffL);
+    }
+
+    public final double readDouble() throws IOException {
+        return Double.longBitsToDouble(readLong());
+    }
+
+    public final short readShort() throws IOException {
+        int i = read();
+        int j = read();
+        if ((i | j) < 0)
+            throw new EOFException();
+        else
+            return (short)((i<<8) + j);
+    }
+
+    public final float readFloat() throws IOException {
+        return Float.intBitsToFloat(readInt());
+    }
+    
+    public void close() throws IOException {
+		//ij.IJ.log("close: "+(data!=null?""+data.size():""));
+ 		if (ras!=null)
+ 			ras.close();
+ 		else {
+ 			data.removeAllElements();
+    		src.close();
+    	}
+    }
+    
+ 
+}
diff --git a/src/ij/io/RoiDecoder.java b/src/ij/io/RoiDecoder.java
new file mode 100644
index 0000000..bf5c7bb
--- /dev/null
+++ b/src/ij/io/RoiDecoder.java
@@ -0,0 +1,602 @@
+package ij.io;
+import ij.gui.*;
+import ij.ImagePlus;
+import ij.process.*;
+import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.awt.*;
+import java.awt.geom.Rectangle2D;
+
+/** This class decodes an ImageJ .roi file. 
+	<p>
+	Format of the original 64 byte ImageJ/NIH Image
+	.roi file header. Two byte numbers are big-endian
+	signed shorts. The JavaScript example at
+	http://wsr.imagej.net/macros/js/DecodeRoiFile.js
+	demonstrates how to use this information to 
+	decode a .roi file.
+	<pre>
+	0-3		"Iout"
+	4-5		version (>=217)
+	6-7		roi type (encoded as one byte)
+	8-9		top
+	10-11	left
+	12-13	bottom
+	14-15	right
+	16-17	NCoordinates
+	18-33	x1,y1,x2,y2 (straight line) | x,y,width,height (double rect) | size (npoints)
+	34-35	stroke width (v1.43i or later)
+	36-39   ShapeRoi size (type must be 1 if this value>0)
+	40-43   stroke color (v1.43i or later)
+	44-47   fill color (v1.43i or later)
+	48-49   subtype (v1.43k or later)
+	50-51   options (v1.43k or later)
+	52-52   arrow style or aspect ratio (v1.43p or later)
+	53-53   arrow head size (v1.43p or later)
+	54-55   rounded rect arc size (v1.43p or later)
+	56-59   position
+	60-63   header2 offset
+	64-       x-coordinates (short), followed by y-coordinates
+	<pre>
+	@see <a href="http://wsr.imagej.net/macros/js/DecodeRoiFile.js">DecodeRoiFile.js</a>
+*/
+
+public class RoiDecoder {
+	// offsets
+	public static final int VERSION_OFFSET = 4;
+	public static final int TYPE = 6;
+	public static final int TOP = 8;
+	public static final int LEFT = 10;
+	public static final int BOTTOM = 12;
+	public static final int RIGHT = 14;
+	public static final int N_COORDINATES = 16;
+	public static final int X1 = 18;
+	public static final int Y1 = 22;
+	public static final int X2 = 26;
+	public static final int Y2 = 30;
+	public static final int XD = 18;
+	public static final int YD = 22;
+	public static final int WIDTHD = 26;
+	public static final int HEIGHTD = 30;
+	public static final int SIZE = 18;
+	public static final int STROKE_WIDTH = 34;
+	public static final int SHAPE_ROI_SIZE = 36;
+	public static final int STROKE_COLOR = 40;
+	public static final int FILL_COLOR = 44;
+	public static final int SUBTYPE = 48;
+	public static final int OPTIONS = 50;
+	public static final int ARROW_STYLE = 52;
+	public static final int FLOAT_PARAM = 52; //ellipse ratio or rotated rect width
+	public static final int POINT_TYPE= 52;
+	public static final int ARROW_HEAD_SIZE = 53;
+	public static final int ROUNDED_RECT_ARC_SIZE = 54;
+	public static final int POSITION = 56;
+	public static final int HEADER2_OFFSET = 60;
+	public static final int COORDINATES = 64;
+	// header2 offsets
+	public static final int C_POSITION = 4;
+	public static final int Z_POSITION = 8;
+	public static final int T_POSITION = 12;
+	public static final int NAME_OFFSET = 16;
+	public static final int NAME_LENGTH = 20;
+	public static final int OVERLAY_LABEL_COLOR = 24;
+	public static final int OVERLAY_FONT_SIZE = 28; //short
+	public static final int GROUP = 30;  //byte
+	public static final int IMAGE_OPACITY = 31;  //byte
+	public static final int IMAGE_SIZE = 32;  //int
+	public static final int FLOAT_STROKE_WIDTH = 36;  //float
+	public static final int ROI_PROPS_OFFSET = 40;
+	public static final int ROI_PROPS_LENGTH = 44;
+	public static final int COUNTERS_OFFSET = 48;
+
+	// subtypes
+	public static final int TEXT = 1;
+	public static final int ARROW = 2;
+	public static final int ELLIPSE = 3;
+	public static final int IMAGE = 4;
+	public static final int ROTATED_RECT = 5;
+	
+	// options
+	public static final int SPLINE_FIT = 1;
+	public static final int DOUBLE_HEADED = 2;
+	public static final int OUTLINE = 4;
+	public static final int OVERLAY_LABELS = 8;
+	public static final int OVERLAY_NAMES = 16;
+	public static final int OVERLAY_BACKGROUNDS = 32;
+	public static final int OVERLAY_BOLD = 64;
+	public static final int SUB_PIXEL_RESOLUTION = 128;
+	public static final int DRAW_OFFSET = 256;
+	public static final int ZERO_TRANSPARENT = 512;
+	public static final int SHOW_LABELS = 1024;
+	public static final int SCALE_LABELS = 2048;
+	public static final int PROMPT_BEFORE_DELETING = 4096; //points
+	public static final int SCALE_STROKE_WIDTH = 8192;
+	
+	// types
+	private final int polygon=0, rect=1, oval=2, line=3, freeline=4, polyline=5, noRoi=6,
+		freehand=7, traced=8, angle=9, point=10;
+	
+	private byte[] data;
+	private String path;
+	private InputStream is;
+	private String name;
+	private int size;
+
+	/** Constructs an RoiDecoder using a file path. */
+	public RoiDecoder(String path) {
+		this.path = path;
+	}
+
+	/** Constructs an RoiDecoder using a byte array. */
+	public RoiDecoder(byte[] bytes, String name) {
+		is = new ByteArrayInputStream(bytes);	
+		this.name = name;
+		this.size = bytes.length;
+	}
+
+	/** Opens the Roi at the specified path. Returns null if there is an error. */
+	public static Roi open(String path) {
+		Roi roi = null;
+		RoiDecoder rd = new RoiDecoder(path);
+		try {
+			roi = rd.getRoi();
+		} catch (IOException e) { }
+		return roi;
+	}
+
+	/** Returns the ROI. */
+	public Roi getRoi() throws IOException {
+		if (path!=null) {
+			File f = new File(path);
+			size = (int)f.length();
+			if (!path.endsWith(".roi") && size>5242880)
+				throw new IOException("This is not an ROI or file size>5MB)");
+			name = f.getName();
+			is = new FileInputStream(path);
+		}
+		data = new byte[size];
+
+		int total = 0;
+		while (total<size)
+			total += is.read(data, total, size-total);
+		is.close();
+		if (getByte(0)!=73 || getByte(1)!=111)  //"Iout"
+			throw new IOException("This is not an ImageJ ROI");
+		int version = getShort(VERSION_OFFSET);
+		int type = getByte(TYPE);
+		int subtype = getShort(SUBTYPE);
+		int top= getShort(TOP);
+		int left = getShort(LEFT);
+		int bottom = getShort(BOTTOM);
+		int right = getShort(RIGHT);
+		int width = right-left;
+		int height = bottom-top;
+		int n = getUnsignedShort(N_COORDINATES);
+		if (n==0)
+			n = getInt(SIZE);
+		int options = getShort(OPTIONS);
+		int position = getInt(POSITION);
+		int hdr2Offset = getInt(HEADER2_OFFSET);
+		int channel=0, slice=0, frame=0;
+		int overlayLabelColor=0;
+		int overlayFontSize=0;
+		int group=0;
+		int imageOpacity=0;
+		int imageSize=0;
+		boolean subPixelResolution = (options&SUB_PIXEL_RESOLUTION)!=0 &&  version>=222;
+		boolean drawOffset = subPixelResolution && (options&DRAW_OFFSET)!=0;
+		boolean scaleStrokeWidth = true;
+		if (version>=228)
+			scaleStrokeWidth = (options&SCALE_STROKE_WIDTH)!=0;
+		
+		boolean subPixelRect = version>=223 && subPixelResolution && (type==rect||type==oval);
+		double xd=0.0, yd=0.0, widthd=0.0, heightd=0.0;
+		if (subPixelRect) {
+			xd = getFloat(XD);
+			yd = getFloat(YD);
+			widthd = getFloat(WIDTHD);
+			heightd = getFloat(HEIGHTD);
+		}
+		
+		if (hdr2Offset>0 && hdr2Offset+IMAGE_SIZE+4<=size) {
+			channel = getInt(hdr2Offset+C_POSITION);
+			slice = getInt(hdr2Offset+Z_POSITION);
+			frame = getInt(hdr2Offset+T_POSITION);
+			overlayLabelColor = getInt(hdr2Offset+OVERLAY_LABEL_COLOR);
+			overlayFontSize = getShort(hdr2Offset+OVERLAY_FONT_SIZE);
+			imageOpacity = getByte(hdr2Offset+IMAGE_OPACITY);
+			imageSize = getInt(hdr2Offset+IMAGE_SIZE);
+			group = getByte(hdr2Offset+GROUP);
+		}
+		
+		if (name!=null && name.endsWith(".roi"))
+			name = name.substring(0, name.length()-4);
+		boolean isComposite = getInt(SHAPE_ROI_SIZE)>0;
+		
+		Roi roi = null;
+		if (isComposite) {
+			roi = getShapeRoi();
+			if (version>=218)
+				getStrokeWidthAndColor(roi, hdr2Offset, scaleStrokeWidth);
+			roi.setPosition(position);
+			if (channel>0 || slice>0 || frame>0)
+				roi.setPosition(channel, slice, frame);
+			decodeOverlayOptions(roi, version, options, overlayLabelColor, overlayFontSize);
+			if (version>=224) {
+				String props = getRoiProps();
+				if (props!=null)
+					roi.setProperties(props);
+			}
+			if (version>=228 && group>0)
+				roi.setGroup(group);
+			return roi;
+		}
+
+		switch (type) {
+			case rect:
+				if (subPixelRect)
+					roi = new Roi(xd, yd, widthd, heightd);
+				else
+					roi = new Roi(left, top, width, height);
+				int arcSize = getShort(ROUNDED_RECT_ARC_SIZE);
+				if (arcSize>0)
+					roi.setCornerDiameter(arcSize);
+				break;
+			case oval:
+				if (subPixelRect)
+					roi = new OvalRoi(xd, yd, widthd, heightd);
+				else
+					roi = new OvalRoi(left, top, width, height);
+				break;
+			case line:
+				double x1 = getFloat(X1);		
+				double y1 = getFloat(Y1);		
+				double x2 = getFloat(X2);		
+				double y2 = getFloat(Y2);
+				if (subtype==ARROW) {
+					roi = new Arrow(x1, y1, x2, y2);		
+					((Arrow)roi).setDoubleHeaded((options&DOUBLE_HEADED)!=0);
+					((Arrow)roi).setOutline((options&OUTLINE)!=0);
+					int style = getByte(ARROW_STYLE);
+					if (style>=Arrow.FILLED && style<=Arrow.BAR)
+						((Arrow)roi).setStyle(style);
+					int headSize = getByte(ARROW_HEAD_SIZE);
+					if (headSize>=0 && style<=30)
+						((Arrow)roi).setHeadSize(headSize);
+				} else {
+					roi = new Line(x1, y1, x2, y2);
+					roi.setDrawOffset(drawOffset);
+				}
+				break;
+			case polygon: case freehand: case traced: case polyline: case freeline: case angle: case point:
+					//IJ.log("type: "+type);
+					//IJ.log("n: "+n);
+					//IJ.log("rect: "+left+","+top+" "+width+" "+height);
+					if (n==0 || n<0) break;
+					int[] x = new int[n];
+					int[] y = new int[n];
+					float[] xf = null;
+					float[] yf = null;
+					int base1 = COORDINATES;
+					int base2 = base1+2*n;
+					int xtmp, ytmp;
+					for (int i=0; i<n; i++) {
+						xtmp = getShort(base1+i*2);
+						if (xtmp<0) xtmp = 0;
+						ytmp = getShort(base2+i*2);
+						if (ytmp<0) ytmp = 0;
+						x[i] = left+xtmp;
+						y[i] = top+ytmp;
+					}
+					if (subPixelResolution) {
+						xf = new float[n];
+						yf = new float[n];
+						base1 = COORDINATES+4*n;
+						base2 = base1+4*n;
+						for (int i=0; i<n; i++) {
+							xf[i] = getFloat(base1+i*4);
+							yf[i] = getFloat(base2+i*4);
+						}
+					}
+					if (type==point) {
+						if (subPixelResolution)
+							roi = new PointRoi(xf, yf, n);
+						else
+							roi = new PointRoi(x, y, n);
+						if (version>=226) {
+							((PointRoi)roi).setPointType(getByte(POINT_TYPE));
+							((PointRoi)roi).setSize(getShort(STROKE_WIDTH));
+						}
+						if ((options&SHOW_LABELS)!=0 && !ij.Prefs.noPointLabels)
+							((PointRoi)roi).setShowLabels(true);
+						if ((options&PROMPT_BEFORE_DELETING)!=0)
+							((PointRoi)roi).promptBeforeDeleting(true);
+						break;
+					}
+					int roiType;
+					if (type==polygon)
+						roiType = Roi.POLYGON;
+					else if (type==freehand) {
+						roiType = Roi.FREEROI;
+						if (subtype==ELLIPSE || subtype==ROTATED_RECT) {
+							double ex1 = getFloat(X1);		
+							double ey1 = getFloat(Y1);		
+							double ex2 = getFloat(X2);		
+							double ey2 = getFloat(Y2);
+							double param = getFloat(FLOAT_PARAM);
+							if (subtype==ROTATED_RECT)
+								roi = new RotatedRectRoi(ex1,ey1,ex2,ey2,param);
+							else
+								roi = new EllipseRoi(ex1,ey1,ex2,ey2,param);
+							break;
+						}
+					} else if (type==traced)
+						roiType = Roi.TRACED_ROI;
+					else if (type==polyline)
+						roiType = Roi.POLYLINE;
+					else if (type==freeline)
+						roiType = Roi.FREELINE;
+					else if (type==angle)
+						roiType = Roi.ANGLE;
+					else
+						roiType = Roi.FREEROI;
+					if (subPixelResolution) {
+						roi = new PolygonRoi(xf, yf, n, roiType);
+						roi.setDrawOffset(drawOffset);
+					} else
+						roi = new PolygonRoi(x, y, n, roiType);
+					break;
+			default:
+				throw new IOException("Unrecognized ROI type: "+type);
+		}
+		if (roi==null)
+			return null;
+		roi.setName(getRoiName());
+		
+		// read stroke width, stroke color and fill color (1.43i or later)
+		if (version>=218) {
+			getStrokeWidthAndColor(roi, hdr2Offset, scaleStrokeWidth);
+			if (type==point)
+				roi.setStrokeWidth(0);
+			boolean splineFit = (options&SPLINE_FIT)!=0;
+			if (splineFit && roi instanceof PolygonRoi)
+				((PolygonRoi)roi).fitSpline();
+		}
+		
+		if (version>=218 && subtype==TEXT)
+			roi = getTextRoi(roi, version);
+
+		if (version>=221 && subtype==IMAGE)
+			roi = getImageRoi(roi, imageOpacity, imageSize, options);
+
+		if (version>=224) {
+			String props = getRoiProps();
+			if (props!=null)
+				roi.setProperties(props);
+		}
+
+		if (version>=227) {
+			int[] counters = getPointCounters(n);
+			if (counters!=null && (roi instanceof PointRoi))
+				((PointRoi)roi).setCounters(counters);
+		}
+		
+		// set group (1.52t or later)
+		if (version>=228 && group>0)
+			roi.setGroup(group);
+
+		roi.setPosition(position);
+		if (channel>0 || slice>0 || frame>0)
+			roi.setPosition(channel, slice, frame);
+		decodeOverlayOptions(roi, version, options, overlayLabelColor, overlayFontSize);
+		return roi;
+	}
+	
+	void decodeOverlayOptions(Roi roi, int version, int options, int color, int fontSize) {
+		Overlay proto = new Overlay();
+		proto.drawLabels((options&OVERLAY_LABELS)!=0);
+		proto.drawNames((options&OVERLAY_NAMES)!=0);
+		proto.drawBackgrounds((options&OVERLAY_BACKGROUNDS)!=0);
+		if (version>=220 && color!=0)
+			proto.setLabelColor(new Color(color));
+		boolean bold = (options&OVERLAY_BOLD)!=0;
+		boolean scalable = (options&SCALE_LABELS)!=0;
+		if (fontSize>0 || bold || scalable) {
+			proto.setLabelFont(new Font("SansSerif", bold?Font.BOLD:Font.PLAIN, fontSize), scalable);
+		}
+		roi.setPrototypeOverlay(proto);
+	}
+
+	void getStrokeWidthAndColor(Roi roi, int hdr2Offset, boolean scaleStrokeWidth) {
+		double strokeWidth = getShort(STROKE_WIDTH);
+		if (hdr2Offset>0) {
+			double strokeWidthD = getFloat(hdr2Offset+FLOAT_STROKE_WIDTH);
+			if (strokeWidthD>0.0)
+				strokeWidth = strokeWidthD;
+		}
+		if (strokeWidth>0.0) {
+			if (scaleStrokeWidth)
+				roi.setStrokeWidth(strokeWidth);
+			else
+				roi.setUnscalableStrokeWidth(strokeWidth);
+		}
+		int strokeColor = getInt(STROKE_COLOR);
+		if (strokeColor!=0) {
+			int alpha = (strokeColor>>24)&0xff;
+			roi.setStrokeColor(new Color(strokeColor, alpha!=255));
+		}
+		int fillColor = getInt(FILL_COLOR);
+		if (fillColor!=0) {
+			int alpha = (fillColor>>24)&0xff;
+			roi.setFillColor(new Color(fillColor, alpha!=255));
+		}
+	}
+
+	public Roi getShapeRoi() throws IOException {
+		int type = getByte(TYPE);
+		if (type!=rect)
+			throw new IllegalArgumentException("Invalid composite ROI type");
+		int top= getShort(TOP);
+		int left = getShort(LEFT);
+		int bottom = getShort(BOTTOM);
+		int right = getShort(RIGHT);
+		int width = right-left;
+		int height = bottom-top;
+		int n = getInt(SHAPE_ROI_SIZE);
+
+		ShapeRoi roi = null;
+		float[] shapeArray = new float[n];
+		int base = COORDINATES;
+		for(int i=0; i<n; i++) {
+			shapeArray[i] = getFloat(base);
+			base += 4;
+		}
+		roi = new ShapeRoi(shapeArray);
+		roi.setName(getRoiName());
+		return roi;
+	}
+	
+	Roi getTextRoi(Roi roi, int version) {
+		Rectangle r = roi.getBounds();
+		int hdrSize = RoiEncoder.HEADER_SIZE;
+		int size = getInt(hdrSize);
+		int styleAndJustification = getInt(hdrSize+4);
+		int style = styleAndJustification&255;
+		int justification = (styleAndJustification>>8) & 3;
+		boolean drawStringMode = (styleAndJustification&1024)!=0;
+		int nameLength = getInt(hdrSize+8);
+		int textLength = getInt(hdrSize+12);
+		char[] name = new char[nameLength];
+		char[] text = new char[textLength];
+		for (int i=0; i<nameLength; i++)
+			name[i] = (char)getShort(hdrSize+16+i*2);
+		for (int i=0; i<textLength; i++)
+			text[i] = (char)getShort(hdrSize+16+nameLength*2+i*2);
+		double angle = version>=225?getFloat(hdrSize+16+nameLength*2+textLength*2):0f;
+		Font font = new Font(new String(name), style, size);
+		TextRoi roi2 = null;
+		if (roi.subPixelResolution()) {
+			Rectangle2D fb = roi.getFloatBounds();
+			roi2 = new TextRoi(fb.getX(), fb.getY(), fb.getWidth(), fb.getHeight(), new String(text), font);
+		} else
+			roi2 = new TextRoi(r.x, r.y, r.width, r.height, new String(text), font);
+		roi2.setStrokeColor(roi.getStrokeColor());
+		roi2.setFillColor(roi.getFillColor());
+		roi2.setName(getRoiName());
+		roi2.setJustification(justification);
+		roi2.setDrawStringMode(drawStringMode);
+		roi2.setAngle(angle);
+		return roi2;
+	}
+	
+	Roi getImageRoi(Roi roi, int opacity, int size, int options) {
+		if (size<=0)
+			return roi;
+		Rectangle r = roi.getBounds();
+		byte[] bytes = new byte[size];
+		for (int i=0; i<size; i++)
+			bytes[i] = (byte)getByte(COORDINATES+i);
+		ImagePlus imp = new Opener().deserialize(bytes);
+		ImageRoi roi2 = new ImageRoi(r.x, r.y, imp.getProcessor());
+		roi2.setOpacity(opacity/255.0);
+		if ((options&ZERO_TRANSPARENT)!=0)
+			roi2.setZeroTransparent(true);
+		return roi2;
+	}
+
+	String getRoiName() {
+		String fileName = name;
+		int hdr2Offset = getInt(HEADER2_OFFSET);
+		if (hdr2Offset==0)
+			return fileName;
+		int offset = getInt(hdr2Offset+NAME_OFFSET);
+		int length = getInt(hdr2Offset+NAME_LENGTH);
+		if (offset==0 || length==0)
+			return fileName;
+		if (offset+length*2>size)
+			return fileName;
+		char[] name = new char[length];
+		for (int i=0; i<length; i++)
+			name[i] = (char)getShort(offset+i*2);
+		return new String(name);
+	}
+	
+	String getRoiProps() {
+		int hdr2Offset = getInt(HEADER2_OFFSET);
+		if (hdr2Offset==0)
+			return null;
+		int offset = getInt(hdr2Offset+ROI_PROPS_OFFSET);
+		int length = getInt(hdr2Offset+ROI_PROPS_LENGTH);
+		if (offset==0 || length==0)
+			return null;
+		if (offset+length*2>size)
+			return null;
+		char[] props = new char[length];
+		for (int i=0; i<length; i++)
+			props[i] = (char)getShort(offset+i*2);
+		return new String(props);
+	}
+	
+	int[] getPointCounters(int n) {
+		int hdr2Offset = getInt(HEADER2_OFFSET);
+		if (hdr2Offset==0)
+			return null;
+		int offset = getInt(hdr2Offset+COUNTERS_OFFSET);
+		if (offset==0)
+			return null;
+		if (offset+n*4>data.length)
+			return null;
+		int[] counters = new int[n];
+		for (int i=0; i<n; i++)
+			counters[i] = getInt(offset+i*4);
+		return counters;
+	}
+
+
+	int getByte(int base) {
+		return data[base]&255;
+	}
+
+	int getShort(int base) {
+		int b0 = data[base]&255;
+		int b1 = data[base+1]&255;
+		int n = (short)((b0<<8) + b1);
+		if (n<-5000)
+			n = (b0<<8) + b1; // assume n>32767 and unsigned
+		return n;		
+	}
+	
+	int getUnsignedShort(int base) {
+		int b0 = data[base]&255;
+		int b1 = data[base+1]&255;
+		return (b0<<8) + b1;	
+	}
+
+	int getInt(int base) {
+		int b0 = data[base]&255;
+		int b1 = data[base+1]&255;
+		int b2 = data[base+2]&255;
+		int b3 = data[base+3]&255;
+		return ((b0<<24) + (b1<<16) + (b2<<8) + b3);
+	}
+
+	float getFloat(int base) {
+		return Float.intBitsToFloat(getInt(base));
+	}
+	
+	/** Opens an ROI from a byte array. */
+	public static Roi openFromByteArray(byte[] bytes) {
+		Roi roi = null;
+		if (bytes==null || bytes.length==0)
+			return roi;
+		try {
+			RoiDecoder decoder = new RoiDecoder(bytes, null);
+			roi = decoder.getRoi();
+		} catch (IOException e) {
+			return null;
+		}
+		return roi;
+	}
+
+}
diff --git a/src/ij/io/RoiEncoder.java b/src/ij/io/RoiEncoder.java
new file mode 100644
index 0000000..7e31123
--- /dev/null
+++ b/src/ij/io/RoiEncoder.java
@@ -0,0 +1,469 @@
+package ij.io;
+import ij.gui.*;
+import ij.process.FloatPolygon;
+import java.awt.*;
+import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.awt.geom.*;
+
+
+/** Saves an ROI to a file or stream. RoiDecoder.java has a description of the file format.
+	@see ij.io.RoiDecoder
+	@see ij.plugin.RoiReader
+*/
+public class RoiEncoder {
+	static final int HEADER_SIZE = 64;
+	static final int HEADER2_SIZE = 64;
+	static final int VERSION = 228; // v1.52t (roi groups, scale stroke width)
+	private String path;
+	private OutputStream f;
+	private final int polygon=0, rect=1, oval=2, line=3, freeline=4, polyline=5, noRoi=6, freehand=7, 
+		traced=8, angle=9, point=10;
+	private byte[] data;
+	private String roiName;
+	private int roiNameSize;
+	private String roiProps;
+	private int roiPropsSize;
+	private int countersSize;
+	private int[] counters;
+
+	
+	/** Creates an RoiEncoder using the specified path. */
+	public RoiEncoder(String path) {
+		this.path = path;
+	}
+
+	/** Creates an RoiEncoder using the specified OutputStream. */
+	public RoiEncoder(OutputStream f) {
+		this.f = f;
+	}
+	
+	/** Saves the specified ROI as a file, returning 'true' if successful. */
+	public static boolean save(Roi roi, String path) {
+		RoiEncoder re = new RoiEncoder(path);
+		try {
+			re.write(roi);
+		} catch (IOException e) {
+			return false;
+		}
+		return true;
+	}
+
+	/** Save the Roi to the file of stream. */
+	public void write(Roi roi) throws IOException {
+		if (f!=null) {
+			write(roi, f);
+		} else {
+			f = new FileOutputStream(path);
+			write(roi, f);
+			f.close();
+		}
+	}
+	
+	/** Saves the specified ROI as a byte array. */
+	public static byte[] saveAsByteArray(Roi roi) {
+		if (roi==null) return null;
+		byte[] bytes = null;
+		try {
+			ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
+			RoiEncoder encoder = new RoiEncoder(out);
+			encoder.write(roi);
+			out.close();
+			bytes = out.toByteArray(); 
+		} catch (IOException e) {
+			return null;
+		}
+		return bytes;
+	}
+
+	void write(Roi roi, OutputStream f) throws IOException {
+		Rectangle r = roi.getBounds();
+		if (r.width>65535||r.height>65535||r.x>65535||r.y>65535)
+			roi.enableSubPixelResolution();
+		int roiType = roi.getType();
+		int type = rect;
+		int options = 0;
+		if (roi.getScaleStrokeWidth())
+			options |= RoiDecoder.SCALE_STROKE_WIDTH;
+		roiName = roi.getName();
+		if (roiName!=null)
+			roiNameSize = roiName.length()*2;
+		else
+			roiNameSize = 0;
+		
+		roiProps = roi.getProperties();
+		if (roiProps!=null)
+			roiPropsSize = roiProps.length()*2;
+		else
+			roiPropsSize = 0;
+
+		switch (roiType) {
+			case Roi.POLYGON: type=polygon; break;
+			case Roi.FREEROI: type=freehand; break;
+			case Roi.TRACED_ROI: type=traced; break;
+			case Roi.OVAL: type=oval; break;
+			case Roi.LINE: type=line; break;
+			case Roi.POLYLINE: type=polyline; break;
+			case Roi.FREELINE: type=freeline; break;
+			case Roi.ANGLE: type=angle; break;
+			case Roi.COMPOSITE: type=rect; break; // shape array size (36-39) will be >0 to indicate composite type
+			case Roi.POINT: type=point; break;
+			default: type = rect; break;
+		}
+		
+		if (roiType==Roi.COMPOSITE) {
+			saveShapeRoi(roi, type, f, options);
+			return;
+		}
+
+		int n=0;
+		int[] x=null, y=null;
+		float[] xf=null, yf=null;
+		int floatSize = 0;
+		if (roi instanceof PolygonRoi) {
+			PolygonRoi proi = (PolygonRoi)roi;
+			Polygon p = proi.getNonSplineCoordinates();
+			n = p.npoints;
+			x = p.xpoints;
+			y = p.ypoints;
+			if (roi.subPixelResolution()) {
+				FloatPolygon fp = null;
+				if (proi.isSplineFit())
+					fp = proi.getNonSplineFloatPolygon();
+				else
+					fp = roi.getFloatPolygon();
+				if (n==fp.npoints) {
+					options |= RoiDecoder.SUB_PIXEL_RESOLUTION;
+					if (roi.getDrawOffset())
+						options |= RoiDecoder.DRAW_OFFSET;
+					xf = fp.xpoints;
+					yf = fp.ypoints;
+					floatSize = n*8;
+				}
+			}
+		}
+		
+		countersSize = 0;
+		if (roi instanceof PointRoi) {
+			counters = ((PointRoi)roi).getCounters();
+			if (counters!=null && counters.length>=n)
+				countersSize = n*4;
+		}
+		
+		data = new byte[HEADER_SIZE+HEADER2_SIZE+n*4+floatSize+roiNameSize+roiPropsSize+countersSize];
+		data[0]=73; data[1]=111; data[2]=117; data[3]=116; // "Iout"
+		putShort(RoiDecoder.VERSION_OFFSET, VERSION);
+		data[RoiDecoder.TYPE] = (byte)type;
+		putShort(RoiDecoder.TOP, r.y);
+		putShort(RoiDecoder.LEFT, r.x);
+		putShort(RoiDecoder.BOTTOM, r.y+r.height);
+		putShort(RoiDecoder.RIGHT, r.x+r.width);	
+		if (roi.subPixelResolution() && (type==rect||type==oval)) {
+			FloatPolygon p = roi.getFloatPolygon();
+			if (p.npoints==4) {
+				putFloat(RoiDecoder.XD, p.xpoints[0]);
+				putFloat(RoiDecoder.YD, p.ypoints[0]);
+				putFloat(RoiDecoder.WIDTHD, p.xpoints[1]-p.xpoints[0]);
+				putFloat(RoiDecoder.HEIGHTD, p.ypoints[2]-p.ypoints[1]);	
+				options |= RoiDecoder.SUB_PIXEL_RESOLUTION;
+				putShort(RoiDecoder.OPTIONS, options);
+			}
+		}
+		if (n>65535 && type!=point) {
+			if (type==polygon || type==freehand || type==traced) {
+				String name = roi.getName();
+				roi = new ShapeRoi(roi);
+				if (name!=null) roi.setName(name);
+				saveShapeRoi(roi, rect, f, options);
+				return;
+			}
+			ij.IJ.beep();
+			ij.IJ.log("Non-polygonal selections with more than 65k points cannot be saved.");
+			n = 65535;
+		}
+		if (type==point && n>65535)
+			putInt(RoiDecoder.SIZE, n);
+		else 
+			putShort(RoiDecoder.N_COORDINATES, n);
+		putInt(RoiDecoder.POSITION, roi.getPosition());
+		
+		if (type==rect) {
+			int arcSize = roi.getCornerDiameter();
+			if (arcSize>0)
+				putShort(RoiDecoder.ROUNDED_RECT_ARC_SIZE, arcSize);
+		}
+		
+		if (roi instanceof Line) {
+			Line line = (Line)roi;
+			putFloat(RoiDecoder.X1, (float)line.x1d);
+			putFloat(RoiDecoder.Y1, (float)line.y1d);
+			putFloat(RoiDecoder.X2, (float)line.x2d);
+			putFloat(RoiDecoder.Y2, (float)line.y2d);
+			if (roi instanceof Arrow) {
+				putShort(RoiDecoder.SUBTYPE, RoiDecoder.ARROW);
+				if (((Arrow)roi).getDoubleHeaded())
+					options |= RoiDecoder.DOUBLE_HEADED;
+				if (((Arrow)roi).getOutline())
+					options |= RoiDecoder.OUTLINE;
+				putShort(RoiDecoder.OPTIONS, options);
+				putByte(RoiDecoder.ARROW_STYLE, ((Arrow)roi).getStyle());
+				putByte(RoiDecoder.ARROW_HEAD_SIZE, (int)((Arrow)roi).getHeadSize());
+			} else {
+				if (roi.getDrawOffset())
+					options |= RoiDecoder.SUB_PIXEL_RESOLUTION+RoiDecoder.DRAW_OFFSET;
+			}
+		}
+		
+		if (roi instanceof PointRoi) {
+			PointRoi point = (PointRoi)roi;
+			putByte(RoiDecoder.POINT_TYPE, point.getPointType());
+			putShort(RoiDecoder.STROKE_WIDTH, point.getSize());
+			if (point.getShowLabels())
+				options |= RoiDecoder.SHOW_LABELS;
+			if (point.promptBeforeDeleting())
+				options |= RoiDecoder.PROMPT_BEFORE_DELETING;
+		}
+
+		if (roi instanceof RotatedRectRoi || roi instanceof EllipseRoi) {
+			double[] p = null;
+			if (roi instanceof RotatedRectRoi) {
+				putShort(RoiDecoder.SUBTYPE, RoiDecoder.ROTATED_RECT);
+				p = ((RotatedRectRoi)roi).getParams();
+			} else {
+				putShort(RoiDecoder.SUBTYPE, RoiDecoder.ELLIPSE);
+				p = ((EllipseRoi)roi).getParams();
+			}
+			putFloat(RoiDecoder.X1, (float)p[0]);
+			putFloat(RoiDecoder.Y1, (float)p[1]);
+			putFloat(RoiDecoder.X2, (float)p[2]);
+			putFloat(RoiDecoder.Y2, (float)p[3]);
+			putFloat(RoiDecoder.FLOAT_PARAM, (float)p[4]);
+		}
+				
+		// save stroke width, stroke color and fill color (1.43i or later)
+		if (VERSION>=218) {
+			saveStrokeWidthAndColor(roi);
+			if ((roi instanceof PolygonRoi) && ((PolygonRoi)roi).isSplineFit()) {
+				options |= RoiDecoder.SPLINE_FIT;
+				putShort(RoiDecoder.OPTIONS, options);
+			}
+		}
+		
+		if (n==0 && roi instanceof TextRoi)
+			saveTextRoi((TextRoi)roi);
+		else if (n==0 && roi instanceof ImageRoi)
+			options = saveImageRoi((ImageRoi)roi, options);
+		else
+			putHeader2(roi, HEADER_SIZE+n*4+floatSize);
+			
+		if (n>0) {
+			int base1 = 64;
+			int base2 = base1+2*n;
+			for (int i=0; i<n; i++) {
+				putShort(base1+i*2, x[i]);
+				putShort(base2+i*2, y[i]);
+			}
+			if (xf!=null) {
+				base1 = 64+4*n;
+				base2 = base1+4*n;
+				for (int i=0; i<n; i++) {
+					putFloat(base1+i*4, xf[i]);
+					putFloat(base2+i*4, yf[i]);
+				}
+			}
+		}
+		
+		saveOverlayOptions(roi, options);
+		f.write(data);
+	}
+
+	void saveStrokeWidthAndColor(Roi roi) {
+		BasicStroke stroke = roi.getStroke();
+		if (stroke!=null)
+			putShort(RoiDecoder.STROKE_WIDTH, (int)stroke.getLineWidth());
+		Color strokeColor = roi.getStrokeColor();
+		if (strokeColor!=null)
+			putInt(RoiDecoder.STROKE_COLOR, strokeColor.getRGB());
+		Color fillColor = roi.getFillColor();
+		if (fillColor!=null)
+			putInt(RoiDecoder.FILL_COLOR, fillColor.getRGB());
+	}
+
+	void saveShapeRoi(Roi roi, int type, OutputStream f, int options) throws IOException {
+		float[] shapeArray = ((ShapeRoi)roi).getShapeAsArray();
+		if (shapeArray==null) return;
+		BufferedOutputStream bout = new BufferedOutputStream(f);
+		Rectangle r = roi.getBounds();
+		data  = new byte[HEADER_SIZE+HEADER2_SIZE+shapeArray.length*4+roiNameSize+roiPropsSize];
+		data[0]=73; data[1]=111; data[2]=117; data[3]=116; // "Iout"
+		
+		putShort(RoiDecoder.VERSION_OFFSET, VERSION);
+		data[RoiDecoder.TYPE] = (byte)type;
+		putShort(RoiDecoder.TOP, r.y);
+		putShort(RoiDecoder.LEFT, r.x);
+		putShort(RoiDecoder.BOTTOM, r.y+r.height);
+		putShort(RoiDecoder.RIGHT, r.x+r.width);	
+		putInt(RoiDecoder.POSITION, roi.getPosition());
+		//putShort(16, n);
+		putInt(36, shapeArray.length); // non-zero segment count indicate composite type
+		if (VERSION>=218) saveStrokeWidthAndColor(roi);
+		saveOverlayOptions(roi, options);
+
+		// handle the actual data: data are stored segment-wise, i.e.,
+		// the type of the segment followed by 0-6 control point coordinates.
+		int base = 64;
+		for (int i=0; i<shapeArray.length; i++) {
+			putFloat(base, shapeArray[i]);
+			base += 4;
+		}
+		int hdr2Offset = HEADER_SIZE+shapeArray.length*4;
+		//ij.IJ.log("saveShapeRoi: "+HEADER_SIZE+"  "+shapeArray.length);
+		putHeader2(roi, hdr2Offset);
+		bout.write(data,0,data.length);
+		bout.flush();
+	}
+	
+	void saveOverlayOptions(Roi roi, int options) {
+		Overlay proto = roi.getPrototypeOverlay();
+		if (proto.getDrawLabels())
+			options |= RoiDecoder.OVERLAY_LABELS;
+		if (proto.getDrawNames())
+			options |= RoiDecoder.OVERLAY_NAMES;
+		if (proto.getDrawBackgrounds())
+			options |= RoiDecoder.OVERLAY_BACKGROUNDS;
+		Font font = proto.getLabelFont();
+		if (font!=null && font.getStyle()==Font.BOLD)
+			options |= RoiDecoder.OVERLAY_BOLD;
+		if (proto.scalableLabels())
+			options |= RoiDecoder.SCALE_LABELS;
+		putShort(RoiDecoder.OPTIONS, options);
+	}
+	
+	void saveTextRoi(TextRoi roi) {
+		Font font = roi.getCurrentFont();
+		String fontName = font.getName();
+		int size = font.getSize();
+		int drawStringMode = roi.getDrawStringMode()?1024:0;
+		int style = font.getStyle() + roi.getJustification()*256+drawStringMode;
+		String text = roi.getText();
+		float angle = (float)roi.getAngle();
+		int angleLength = 4;
+		int fontNameLength = fontName.length();
+		int textLength = text.length();
+		int textRoiDataLength = 16+fontNameLength*2+textLength*2 + angleLength;
+		byte[] data2 = new byte[HEADER_SIZE+HEADER2_SIZE+textRoiDataLength+roiNameSize+roiPropsSize];
+		System.arraycopy(data, 0, data2, 0, HEADER_SIZE);
+		data = data2;
+		putShort(RoiDecoder.SUBTYPE, RoiDecoder.TEXT);
+		putInt(HEADER_SIZE, size);
+		putInt(HEADER_SIZE+4, style);
+		putInt(HEADER_SIZE+8, fontNameLength);
+		putInt(HEADER_SIZE+12, textLength);
+		for (int i=0; i<fontNameLength; i++)
+			putShort(HEADER_SIZE+16+i*2, fontName.charAt(i));
+		for (int i=0; i<textLength; i++)
+			putShort(HEADER_SIZE+16+fontNameLength*2+i*2, text.charAt(i));
+		int hdr2Offset = HEADER_SIZE+textRoiDataLength;
+		//ij.IJ.log("saveTextRoi: "+HEADER_SIZE+"  "+textRoiDataLength+"  "+fontNameLength+"  "+textLength);
+		putFloat(hdr2Offset-angleLength, angle);
+		putHeader2(roi, hdr2Offset);
+	}
+	
+	private int saveImageRoi(ImageRoi roi, int options) {
+		byte[] bytes = roi.getSerializedImage();
+		int imageSize = bytes.length;
+		byte[] data2 = new byte[HEADER_SIZE+HEADER2_SIZE+imageSize+roiNameSize+roiPropsSize];
+		System.arraycopy(data, 0, data2, 0, HEADER_SIZE);
+		data = data2;
+		putShort(RoiDecoder.SUBTYPE, RoiDecoder.IMAGE);
+		for (int i=0; i<imageSize; i++)
+			putByte(HEADER_SIZE+i, bytes[i]&255);
+		int hdr2Offset = HEADER_SIZE+imageSize;
+		double opacity = roi.getOpacity();
+		putByte(hdr2Offset+RoiDecoder.IMAGE_OPACITY, (int)(opacity*255.0));
+		putInt(hdr2Offset+RoiDecoder.IMAGE_SIZE, imageSize);
+		if (roi.getZeroTransparent())
+			options |= RoiDecoder.ZERO_TRANSPARENT;
+		putHeader2(roi, hdr2Offset);
+		return options;
+	}
+
+	void putHeader2(Roi roi, int hdr2Offset) {
+		//ij.IJ.log("putHeader2: "+hdr2Offset+" "+roiNameSize+"  "+roiName);
+		putInt(RoiDecoder.HEADER2_OFFSET, hdr2Offset);
+		putInt(hdr2Offset+RoiDecoder.C_POSITION, roi.getCPosition());
+		putInt(hdr2Offset+RoiDecoder.Z_POSITION, roi.hasHyperStackPosition()?roi.getZPosition():0);
+		putInt(hdr2Offset+RoiDecoder.T_POSITION, roi.getTPosition());
+		Overlay proto = roi.getPrototypeOverlay();
+		Color overlayLabelColor = proto.getLabelColor();
+		if (overlayLabelColor!=null)
+			putInt(hdr2Offset+RoiDecoder.OVERLAY_LABEL_COLOR, overlayLabelColor.getRGB());
+		Font font = proto.getLabelFont();
+		if (font!=null)
+			putShort(hdr2Offset+RoiDecoder.OVERLAY_FONT_SIZE, font.getSize());
+		if (roiNameSize>0)
+			putName(roi, hdr2Offset);
+		double strokeWidth = roi.getStrokeWidth();
+		if (roi.getStroke()==null)
+			strokeWidth = 0.0;
+		putFloat(hdr2Offset+RoiDecoder.FLOAT_STROKE_WIDTH, (float)strokeWidth);
+		if (roiPropsSize>0)
+			putProps(roi, hdr2Offset);
+		if (countersSize>0)
+			putPointCounters(roi, hdr2Offset);
+		putByte(hdr2Offset+RoiDecoder.GROUP, roi.getGroup());
+	}
+
+	void putName(Roi roi, int hdr2Offset) {
+		int offset = hdr2Offset+HEADER2_SIZE;
+		int nameLength = roiNameSize/2;
+		putInt(hdr2Offset+RoiDecoder.NAME_OFFSET, offset);
+		putInt(hdr2Offset+RoiDecoder.NAME_LENGTH, nameLength);
+		for (int i=0; i<nameLength; i++)
+			putShort(offset+i*2, roiName.charAt(i));
+	}
+
+	void putProps(Roi roi, int hdr2Offset) {
+		int offset = hdr2Offset+HEADER2_SIZE+roiNameSize;
+		int roiPropsLength = roiPropsSize/2;
+		putInt(hdr2Offset+RoiDecoder.ROI_PROPS_OFFSET, offset);
+		putInt(hdr2Offset+RoiDecoder.ROI_PROPS_LENGTH, roiPropsLength);
+		for (int i=0; i<roiPropsLength; i++)
+			putShort(offset+i*2, roiProps.charAt(i));
+	}
+
+	void putPointCounters(Roi roi, int hdr2Offset) {
+		int offset = hdr2Offset+HEADER2_SIZE+roiNameSize+roiPropsSize;
+		putInt(hdr2Offset+RoiDecoder.COUNTERS_OFFSET, offset);
+		for (int i=0; i<countersSize/4; i++)
+			putInt(offset+i*4, counters[i]);
+		countersSize = 0;
+	}
+
+    void putByte(int base, int v) {
+		data[base] = (byte)v;
+    }
+
+    void putShort(int base, int v) {
+		data[base] = (byte)(v>>>8);
+		data[base+1] = (byte)v;
+    }
+
+	void putFloat(int base, float v) {
+		int tmp = Float.floatToIntBits(v);
+		data[base]   = (byte)(tmp>>24);
+		data[base+1] = (byte)(tmp>>16);
+		data[base+2] = (byte)(tmp>>8);
+		data[base+3] = (byte)tmp;
+	}
+
+	void putInt(int base, int i) {
+		data[base]   = (byte)(i>>24);
+		data[base+1] = (byte)(i>>16);
+		data[base+2] = (byte)(i>>8);
+		data[base+3] = (byte)i;
+	}
+	
+	
+}
\ No newline at end of file
diff --git a/src/ij/io/SaveDialog.java b/src/ij/io/SaveDialog.java
new file mode 100644
index 0000000..7101f15
--- /dev/null
+++ b/src/ij/io/SaveDialog.java
@@ -0,0 +1,265 @@
+package ij.io;
+import ij.gui.GenericDialog;
+import java.awt.*;
+import java.io.*;
+import javax.swing.*;
+import javax.swing.filechooser.*;
+import ij.*;
+import ij.plugin.frame.Recorder;
+import ij.util.Java2;
+import ij.macro.Interpreter;
+
+/** This class displays a dialog window from 
+	which the user can save a file. */ 
+public class SaveDialog {
+
+	private String dir;
+	private String name;
+	private String title;
+	private String ext;
+	
+	/** Displays a file save dialog with 'title' as the 
+		title, 'defaultName' as the initial file name, and
+		'extension' (e.g. ".tif") as the default extension.
+	*/
+	public SaveDialog(String title, String defaultName, String extension) {
+		this.title = title;
+		ext = extension;
+		if (isMacro())
+			return;
+		String defaultDir = OpenDialog.getDefaultDirectory();
+		defaultName = setExtension(defaultName, extension);
+		if (Prefs.useJFileChooser)
+			jSave(title, defaultDir, defaultName);
+		else
+			save(title, defaultDir, defaultName);
+		if (name!=null && dir!=null)
+			OpenDialog.setDefaultDirectory(dir);
+		IJ.showStatus(title+": "+dir+name);
+	}
+	
+	/** Displays a file save dialog, using the specified 
+		default directory and file name and extension. */
+	public SaveDialog(String title, String defaultDir, String defaultName, String extension) {
+		this.title = title;
+		ext = extension;
+		if (isMacro())
+			return;
+		defaultName = setExtension(defaultName, extension);
+		if (Prefs.useJFileChooser)
+			jSave(title, defaultDir, defaultName);
+		else
+			save(title, defaultDir, defaultName);
+		IJ.showStatus(title+": "+dir+name);
+	}
+	
+	boolean isMacro() {
+		String macroOptions = Macro.getOptions();
+		if (macroOptions!=null) {
+			String path = Macro.getValue(macroOptions, title, null);
+			if (path==null)
+				path = Macro.getValue(macroOptions, "path", null);
+			if (path!=null && path.indexOf(".")==-1 && !((new File(path)).exists())) {
+				// Is 'path' a macro variable?
+				if (path.startsWith("&")) path=path.substring(1);
+				Interpreter interp = Interpreter.getInstance();
+				String path2 = interp!=null?interp.getStringVariable(path):null;
+				if (path2!=null) path = path2;
+			}
+			if (path!=null) {
+				Opener o = new Opener();
+				dir = o.getDir(path);
+				name = o.getName(path);
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	public static String setExtension(String name, String extension) {
+		if (name==null || extension==null || extension.length()==0)
+			return name;
+		int dotIndex = name.lastIndexOf(".");
+		if (dotIndex>=0 && (name.length()-dotIndex)<=5) {
+			if (dotIndex+1<name.length() && Character.isDigit(name.charAt(dotIndex+1)))
+				name += extension;
+			else
+				name = name.substring(0, dotIndex) + extension;
+		} else if (!name.endsWith(extension))
+			name += extension;
+		return name;
+	}
+	    
+	// Save using JFileChooser.
+	void jSave(String title, String defaultDir, String defaultName) {
+		Java2.setSystemLookAndFeel();
+		if (EventQueue.isDispatchThread())
+			jSaveDispatchThread(title, defaultDir, defaultName);
+		else
+			jSaveInvokeAndWait(title, defaultDir, defaultName);
+	}
+
+	// Save using JFileChooser.
+	// assumes we are running on the event dispatch thread
+	void jSaveDispatchThread(String title, String defaultDir, String defaultName) {
+		JFileChooser fc = new JFileChooser();
+		fc.setDialogTitle(title);
+		fc.setDragEnabled(true);
+		fc.setTransferHandler(new DragAndDropHandler(fc));
+		if (defaultDir!=null) {
+			File f = new File(defaultDir);
+			if (f!=null)
+				fc.setCurrentDirectory(f);
+		}
+		if (defaultName!=null)
+			fc.setSelectedFile(new File(defaultName));
+		int returnVal = fc.showSaveDialog(IJ.getInstance());
+		if (returnVal!=JFileChooser.APPROVE_OPTION)
+			{Macro.abort(); return;}
+		File f = fc.getSelectedFile();
+		if(f.exists()) {
+			int ret = JOptionPane.showConfirmDialog (fc,
+				"The file "+ f.getName() + " already exists. \nWould you like to replace it?",
+				"Replace?",
+				JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
+			if (ret!=JOptionPane.OK_OPTION) f = null;
+		}
+		if (f==null)
+			Macro.abort();
+		else {
+			dir = fc.getCurrentDirectory().getPath()+File.separator;
+			name = fc.getName(f);
+			if (noExtension(name)) {
+				if (".raw".equals(ext))
+					ext = null;
+				name = setExtension(name, ext);
+			}
+		}
+	}
+
+	// Save using JFileChooser. Runs on event
+	// dispatch thread to avoid thread deadlocks.
+	void jSaveInvokeAndWait(final String title, final String defaultDir, final String defaultName) {
+		try {
+			EventQueue.invokeAndWait(new Runnable() {
+				public void run() {
+					JFileChooser fc = new JFileChooser();
+					fc.setDialogTitle(title);
+					fc.setDragEnabled(true);
+					fc.setTransferHandler(new DragAndDropHandler(fc));
+					if (defaultDir!=null) {
+						File f = new File(defaultDir);
+						if (f!=null)
+							fc.setCurrentDirectory(f);
+					}
+					if (defaultName!=null)
+						fc.setSelectedFile(new File(defaultName));
+					int returnVal = fc.showSaveDialog(IJ.getInstance());
+					if (returnVal!=JFileChooser.APPROVE_OPTION)
+						{Macro.abort(); return;}
+					File f = fc.getSelectedFile();
+					if(f.exists()) {
+						int ret = JOptionPane.showConfirmDialog (fc,
+							"The file "+ f.getName() + " already exists. \nWould you like to replace it?",
+							"Replace?",
+							JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
+						if (ret!=JOptionPane.OK_OPTION) f = null;
+					}
+					if (f==null)
+						Macro.abort();
+					else {
+						dir = fc.getCurrentDirectory().getPath()+File.separator;
+						name = fc.getName(f);
+						if (noExtension(name)) {
+							if (".raw".equals(ext))
+								ext = null;
+							name = setExtension(name, ext);
+						}
+					}
+				}
+			});
+		} catch (Exception e) {}
+	}
+
+	// Save using FileDialog
+	void save(String title, String defaultDir, String defaultName) {
+		ImageJ ij = IJ.getInstance();
+		Frame parent = ij!=null?ij:new Frame();
+		FileDialog fd = new FileDialog(parent, title, FileDialog.SAVE);
+		if (defaultName!=null)
+			fd.setFile(defaultName);
+		if (defaultDir!=null) {
+			if (IJ.isWindows() && defaultDir.contains("/")) {
+				File f = new File(defaultDir);
+				if (f.isDirectory())
+					try {
+						defaultDir = f.getCanonicalPath();
+					} catch (IOException e) {}
+			}
+			fd.setDirectory(defaultDir);
+		}
+		fd.show();
+		name = fd.getFile();
+		String origName = name;
+		if (noExtension(name)) {
+			if (".raw".equals(ext))
+				ext = null;
+			name = setExtension(name, ext);
+			boolean dialog = name!=null && !name.equals(origName) && IJ.isMacOSX() && !IJ.isMacro();
+			if (dialog) {
+				File f = new File( fd.getDirectory()+getFileName());
+				if (!f.exists()) dialog = false;
+			}
+			if (dialog) {
+				Font font = new Font("SansSerif", Font.BOLD, 12);
+				GenericDialog gd = new GenericDialog("Replace File?");
+				gd.addMessage("\""+name+"\" already exists.\nDo you want to replace it?", font);
+				gd.addMessage("To avoid this dialog, enable"
+				+"\n\"Show all filename extensions\"\nin Finder Preferences.");
+				gd.setOKLabel("Replace");
+				gd.showDialog();
+				if (gd.wasCanceled())
+					name = null;
+			}
+		}
+		if (IJ.debugMode) IJ.log(origName+"->"+name);
+		dir = fd.getDirectory();
+		if (name==null)
+			Macro.abort();
+		fd.dispose();
+		if (ij==null)
+			parent.dispose();
+	}
+	
+	private boolean noExtension(String name) {
+		if (name==null) return false;
+		int dotIndex = name.indexOf(".");
+		return dotIndex==-1 || (name.length()-dotIndex)>5;
+	}
+	
+	/** Returns the selected directory. */
+	public String getDirectory() {
+		OpenDialog.setLastDirectory(dir);
+		return dir;
+	}
+	
+	/** Returns the selected file name. */
+	public String getFileName() {
+		if (name!=null) {
+			if (Recorder.record && dir!=null)
+				Recorder.recordPath(title, dir+name);
+			OpenDialog.setLastName(name);
+		}
+		return name;
+	}
+	
+	public static String getPath(ImagePlus imp, String extension) {
+		String title = imp!=null?imp.getTitle():"Untitled";
+		SaveDialog sd = new SaveDialog("Save As", title, extension);
+		if (sd.getFileName()==null)
+			return null;
+		else
+			return sd.getDirectory()+sd.getFileName();
+	}
+			
+}
diff --git a/src/ij/io/TextEncoder.java b/src/ij/io/TextEncoder.java
new file mode 100644
index 0000000..addbee6
--- /dev/null
+++ b/src/ij/io/TextEncoder.java
@@ -0,0 +1,54 @@
+package ij.io;
+import java.io.*;
+import ij.*;
+import ij.process.*;
+import ij.measure.*;
+
+/** Saves an image described by an ImageProcessor object as a tab-delimited text file. */
+public class TextEncoder {
+
+	private ImageProcessor ip;
+	private Calibration cal;
+	private int precision;
+
+	/** Constructs a TextEncoder from an ImageProcessor and optional Calibration. */
+	public TextEncoder (ImageProcessor ip, Calibration cal, int precision) {
+		this.ip = ip;
+		this.cal = cal;
+		this.precision = precision;
+	}
+
+	/** Saves the image as a tab-delimited text file. */
+	public void write(DataOutputStream out) throws IOException {
+		PrintWriter pw = new PrintWriter(out);
+		boolean calibrated = cal!=null && cal.calibrated();
+		if (calibrated)
+			ip.setCalibrationTable(cal.getCTable());
+		else
+			ip.setCalibrationTable(null);
+		boolean intData = !calibrated && ((ip instanceof ByteProcessor) || (ip instanceof ShortProcessor));
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		int inc = height/20;
+		if (inc<1) inc = 1;
+		//IJ.showStatus("Exporting as text...");
+		double value;
+		for (int y=0; y<height; y++) {
+			for (int x=0; x<width; x++) {
+				value = ip.getPixelValue(x,y);
+				if (intData)
+					pw.print((int)value);
+				else
+					pw.print(IJ.d2s(value, precision));
+				if (x!=(width-1))
+					pw.print("\t");
+			}
+			pw.println();
+			if (y%inc==0) IJ.showProgress((double)y/height);
+		}
+		pw.close();
+		IJ.showProgress(1.0);
+		//IJ.showStatus("");
+	}
+	
+}
diff --git a/src/ij/io/TiffDecoder.java b/src/ij/io/TiffDecoder.java
new file mode 100644
index 0000000..9757c18
--- /dev/null
+++ b/src/ij/io/TiffDecoder.java
@@ -0,0 +1,876 @@
+package ij.io;
+import ij.util.Tools;
+import ij.IJ;
+import java.io.*;
+import java.util.*;
+import java.net.*;
+
+/**
+Decodes single and multi-image TIFF files. The LZW decompression
+code was contributed by Curtis Rueden.
+*/
+public class TiffDecoder {
+
+	// tags
+	public static final int NEW_SUBFILE_TYPE = 254;
+	public static final int IMAGE_WIDTH = 256;
+	public static final int IMAGE_LENGTH = 257;
+	public static final int BITS_PER_SAMPLE = 258;
+	public static final int COMPRESSION = 259;
+	public static final int PHOTO_INTERP = 262;
+	public static final int IMAGE_DESCRIPTION = 270;
+	public static final int STRIP_OFFSETS = 273;
+	public static final int ORIENTATION = 274;
+	public static final int SAMPLES_PER_PIXEL = 277;
+	public static final int ROWS_PER_STRIP = 278;
+	public static final int STRIP_BYTE_COUNT = 279;
+	public static final int X_RESOLUTION = 282;
+	public static final int Y_RESOLUTION = 283;
+	public static final int PLANAR_CONFIGURATION = 284;
+	public static final int RESOLUTION_UNIT = 296;
+	public static final int SOFTWARE = 305;
+	public static final int DATE_TIME = 306;
+	public static final int ARTIST = 315;
+	public static final int HOST_COMPUTER = 316;
+	public static final int PREDICTOR = 317;
+	public static final int COLOR_MAP = 320;
+	public static final int TILE_WIDTH = 322;
+	public static final int SAMPLE_FORMAT = 339;
+	public static final int JPEG_TABLES = 347;
+	public static final int METAMORPH1 = 33628;
+	public static final int METAMORPH2 = 33629;
+	public static final int IPLAB = 34122;
+	public static final int NIH_IMAGE_HDR = 43314;
+	public static final int META_DATA_BYTE_COUNTS = 50838; // private tag registered with Adobe
+	public static final int META_DATA = 50839; // private tag registered with Adobe
+	
+	//constants
+	static final int UNSIGNED = 1;
+	static final int SIGNED = 2;
+	static final int FLOATING_POINT = 3;
+
+	//field types
+	static final int SHORT = 3;
+	static final int LONG = 4;
+
+	// metadata types
+	static final int MAGIC_NUMBER = 0x494a494a;  // "IJIJ"
+	static final int INFO = 0x696e666f;  // "info" (Info image property)
+	static final int LABELS = 0x6c61626c;  // "labl" (slice labels)
+	static final int RANGES = 0x72616e67;  // "rang" (display ranges)
+	static final int LUTS = 0x6c757473;    // "luts" (channel LUTs)
+	static final int PLOT = 0x706c6f74;    // "plot" (serialized plot)
+	static final int ROI = 0x726f6920;     // "roi " (ROI)
+	static final int OVERLAY = 0x6f766572; // "over" (overlay)
+	static final int PROPERTIES = 0x70726f70; // "prop" (properties)
+	
+	private String directory;
+	private String name;
+	private String url;
+	protected RandomAccessStream in;
+	protected boolean debugMode;
+	private boolean littleEndian;
+	private String dInfo;
+	private int ifdCount;
+	private int[] metaDataCounts;
+	private String tiffMetadata;
+	private int photoInterp;
+		
+	public TiffDecoder(String directory, String name) {
+		if (directory==null)
+			directory = "";
+		directory = IJ.addSeparator(directory);
+		this.directory = directory;
+		this.name = name;
+	}
+
+	public TiffDecoder(InputStream in, String name) {
+		directory = "";
+		this.name = name;
+		url = "";
+		this.in = new RandomAccessStream(in);
+	}
+
+	final int getInt() throws IOException {
+		int b1 = in.read();
+		int b2 = in.read();
+		int b3 = in.read();
+		int b4 = in.read();
+		if (littleEndian)
+			return ((b4 << 24) + (b3 << 16) + (b2 << 8) + (b1 << 0));
+		else
+			return ((b1 << 24) + (b2 << 16) + (b3 << 8) + b4);
+	}
+	
+	final long getUnsignedInt() throws IOException {
+		return (long)getInt()&0xffffffffL;
+	}
+
+	final int getShort() throws IOException {
+		int b1 = in.read();
+		int b2 = in.read();
+		if (littleEndian)
+			return ((b2<<8) + b1);
+		else
+			return ((b1<<8) + b2);
+	}
+
+    final long readLong() throws IOException {
+    	if (littleEndian)
+        	return ((long)getInt()&0xffffffffL) + ((long)getInt()<<32);
+        else
+			return ((long)getInt()<<32) + ((long)getInt()&0xffffffffL);
+        	//return in.read()+(in.read()<<8)+(in.read()<<16)+(in.read()<<24)+(in.read()<<32)+(in.read()<<40)+(in.read()<<48)+(in.read()<<56);
+    }
+
+    final double readDouble() throws IOException {
+        return Double.longBitsToDouble(readLong());
+    }
+
+	long OpenImageFileHeader() throws IOException {
+	// Open 8-byte Image File Header at start of file.
+	// Returns the offset in bytes to the first IFD or -1
+	// if this is not a valid tiff file.
+		int byteOrder = in.readShort();
+		if (byteOrder==0x4949) // "II"
+			littleEndian = true;
+		else if (byteOrder==0x4d4d) // "MM"
+			littleEndian = false;
+		else {
+			in.close();
+			return -1;
+		}
+		int magicNumber = getShort(); // 42
+		long offset = ((long)getInt())&0xffffffffL;
+		return offset;
+	}
+		
+	int getValue(int fieldType, int count) throws IOException {
+		int value = 0;
+		int unused;
+		if (fieldType==SHORT && count==1) {
+			value = getShort();
+			unused = getShort();
+		} else
+			value = getInt();
+		return value;
+	}	
+	
+	void getColorMap(long offset, FileInfo fi) throws IOException {
+		byte[] colorTable16 = new byte[768*2];
+		long saveLoc = in.getLongFilePointer();
+		in.seek(offset);
+		in.readFully(colorTable16);
+		in.seek(saveLoc);
+		fi.lutSize = 256;
+		fi.reds = new byte[256];
+		fi.greens = new byte[256];
+		fi.blues = new byte[256];
+		int j = 0;
+		if (littleEndian) j++;
+		int sum = 0;
+		for (int i=0; i<256; i++) {
+			fi.reds[i] = colorTable16[j];
+			sum += fi.reds[i];
+			fi.greens[i] = colorTable16[512+j];
+			sum += fi.greens[i];
+			fi.blues[i] = colorTable16[1024+j];
+			sum += fi.blues[i];
+			j += 2;
+		}
+		if (sum!=0 && fi.fileType==FileInfo.GRAY8)
+			fi.fileType = FileInfo.COLOR8;
+	}
+	
+	byte[] getString(int count, long offset) throws IOException {
+		count--; // skip null byte at end of string
+		if (count<=3)
+			return null;
+		byte[] bytes = new byte[count];
+		long saveLoc = in.getLongFilePointer();
+		in.seek(offset);
+		in.readFully(bytes);
+		in.seek(saveLoc);
+		return bytes;
+	}
+
+	/** Save the image description in the specified FileInfo. ImageJ
+		saves spatial and density calibration data in this string. For
+		stacks, it also saves the number of images to avoid having to
+		decode an IFD for each image. */
+	public void saveImageDescription(byte[] description, FileInfo fi) {
+        String id = new String(description);
+        boolean createdByImageJ = id.startsWith("ImageJ");
+        if (!createdByImageJ)
+			saveMetadata(getName(IMAGE_DESCRIPTION), id);
+		if (id.length()<7) return;
+		fi.description = id;
+        int index1 = id.indexOf("images=");
+        if (index1>0 && createdByImageJ && id.charAt(7)!='\n') {
+            int index2 = id.indexOf("\n", index1);
+            if (index2>0) {
+                String images = id.substring(index1+7,index2);
+                int n = (int)Tools.parseDouble(images, 0.0);
+                if (n>1 && fi.compression==FileInfo.COMPRESSION_NONE)
+                	fi.nImages = n;
+            }
+        }
+	}
+
+	public void saveMetadata(String name, String data) {
+		if (data==null) return;
+        String str = name+": "+data+"\n";
+        if (tiffMetadata==null)
+        	tiffMetadata = str;
+        else
+        	tiffMetadata += str;
+	}
+
+	void decodeNIHImageHeader(int offset, FileInfo fi) throws IOException {
+		long saveLoc = in.getLongFilePointer();
+		
+		in.seek(offset+12);
+		int version = in.readShort();
+		
+		in.seek(offset+160);
+		double scale = in.readDouble();
+		if (version>106 && scale!=0.0) {
+			fi.pixelWidth = 1.0/scale;
+			fi.pixelHeight = fi.pixelWidth;
+		} 
+
+		// spatial calibration
+		in.seek(offset+172);
+		int units = in.readShort();
+		if (version<=153) units += 5;
+		switch (units) {
+			case 5: fi.unit = "nanometer"; break;
+			case 6: fi.unit = "micrometer"; break;
+			case 7: fi.unit = "mm"; break;
+			case 8: fi.unit = "cm"; break;
+			case 9: fi.unit = "meter"; break;
+			case 10: fi.unit = "km"; break;
+			case 11: fi.unit = "inch"; break;
+			case 12: fi.unit = "ft"; break;
+			case 13: fi.unit = "mi"; break;
+		}
+
+		// density calibration
+		in.seek(offset+182);
+		int fitType = in.read();
+		int unused = in.read();
+		int nCoefficients = in.readShort();
+		if (fitType==11) {
+			fi.calibrationFunction = 21; //Calibration.UNCALIBRATED_OD
+			fi.valueUnit = "U. OD";
+		} else if (fitType>=0 && fitType<=8 && nCoefficients>=1 && nCoefficients<=5) {
+			switch (fitType) {
+				case 0: fi.calibrationFunction = 0; break; //Calibration.STRAIGHT_LINE
+				case 1: fi.calibrationFunction = 1; break; //Calibration.POLY2
+				case 2: fi.calibrationFunction = 2; break; //Calibration.POLY3
+				case 3: fi.calibrationFunction = 3; break; //Calibration.POLY4
+				case 5: fi.calibrationFunction = 4; break; //Calibration.EXPONENTIAL
+				case 6: fi.calibrationFunction = 5; break; //Calibration.POWER
+				case 7: fi.calibrationFunction = 6; break; //Calibration.LOG
+				case 8: fi.calibrationFunction = 10; break; //Calibration.RODBARD2 (NIH Image)
+			}
+			fi.coefficients = new double[nCoefficients];
+			for (int i=0; i<nCoefficients; i++) {
+				fi.coefficients[i] = in.readDouble();
+			}
+			in.seek(offset+234);
+			int size = in.read();
+			StringBuffer sb = new StringBuffer();
+			if (size>=1 && size<=16) {
+				for (int i=0; i<size; i++)
+					sb.append((char)(in.read()));
+				fi.valueUnit = new String(sb);
+			} else
+				fi.valueUnit = " ";
+		}
+			
+		in.seek(offset+260);
+		int nImages = in.readShort();
+		if (nImages>=2 && (fi.fileType==FileInfo.GRAY8||fi.fileType==FileInfo.COLOR8)) {
+			fi.nImages = nImages;
+			fi.pixelDepth = in.readFloat();	//SliceSpacing
+			int skip = in.readShort();		//CurrentSlice
+			fi.frameInterval = in.readFloat();
+		}
+			
+		in.seek(offset+272);
+		float aspectRatio = in.readFloat();
+		if (version>140 && aspectRatio!=0.0)
+			fi.pixelHeight = fi.pixelWidth/aspectRatio;
+		
+		in.seek(saveLoc);
+	}
+	
+	void dumpTag(int tag, int count, int value, FileInfo fi) {
+		long lvalue = ((long)value)&0xffffffffL;
+		String name = getName(tag);
+		String cs = (count==1)?"":", count=" + count;
+		dInfo += "    " + tag + ", \"" + name + "\", value=" + lvalue + cs + "\n";
+		//ij.IJ.log(tag + ", \"" + name + "\", value=" + value + cs + "\n");
+	}
+
+	String getName(int tag) {
+		String name;
+		switch (tag) {
+			case NEW_SUBFILE_TYPE: name="NewSubfileType"; break;
+			case IMAGE_WIDTH: name="ImageWidth"; break;
+			case IMAGE_LENGTH: name="ImageLength"; break;
+			case STRIP_OFFSETS: name="StripOffsets"; break;
+			case ORIENTATION: name="Orientation"; break;
+			case PHOTO_INTERP: name="PhotoInterp"; break;
+			case IMAGE_DESCRIPTION: name="ImageDescription"; break;
+			case BITS_PER_SAMPLE: name="BitsPerSample"; break;
+			case SAMPLES_PER_PIXEL: name="SamplesPerPixel"; break;
+			case ROWS_PER_STRIP: name="RowsPerStrip"; break;
+			case STRIP_BYTE_COUNT: name="StripByteCount"; break;
+			case X_RESOLUTION: name="XResolution"; break;
+			case Y_RESOLUTION: name="YResolution"; break;
+			case RESOLUTION_UNIT: name="ResolutionUnit"; break;
+			case SOFTWARE: name="Software"; break;
+			case DATE_TIME: name="DateTime"; break;
+			case ARTIST: name="Artist"; break;
+			case HOST_COMPUTER: name="HostComputer"; break;
+			case PLANAR_CONFIGURATION: name="PlanarConfiguration"; break;
+			case COMPRESSION: name="Compression"; break; 
+			case PREDICTOR: name="Predictor"; break; 
+			case COLOR_MAP: name="ColorMap"; break; 
+			case SAMPLE_FORMAT: name="SampleFormat"; break; 
+			case JPEG_TABLES: name="JPEGTables"; break; 
+			case NIH_IMAGE_HDR: name="NIHImageHeader"; break; 
+			case META_DATA_BYTE_COUNTS: name="MetaDataByteCounts"; break; 
+			case META_DATA: name="MetaData"; break; 
+			default: name="???"; break;
+		}
+		return name;
+	}
+
+	double getRational(long loc) throws IOException {
+		long saveLoc = in.getLongFilePointer();
+		in.seek(loc);
+		double numerator = getUnsignedInt();
+		double denominator = getUnsignedInt();
+		in.seek(saveLoc);
+		if (denominator!=0.0)
+			return numerator/denominator;
+		else
+			return 0.0;
+	}
+	
+	FileInfo OpenIFD() throws IOException {
+	// Get Image File Directory data
+		int tag, fieldType, count, value;
+		int nEntries = getShort();
+		if (nEntries<1 || nEntries>1000)
+			return null;
+		ifdCount++;
+		if ((ifdCount%50)==0 && ifdCount>0)
+			ij.IJ.showStatus("Opening IFDs: "+ifdCount);
+		FileInfo fi = new FileInfo();
+		fi.fileType = FileInfo.BITMAP;  //BitsPerSample defaults to 1
+		for (int i=0; i<nEntries; i++) {
+			tag = getShort();
+			fieldType = getShort();
+			count = getInt();
+			value = getValue(fieldType, count);
+			long lvalue = ((long)value)&0xffffffffL;
+			if (debugMode && ifdCount<10) dumpTag(tag, count, value, fi);
+			switch (tag) {
+				case IMAGE_WIDTH: 
+					fi.width = value;
+					fi.intelByteOrder = littleEndian;
+					break;
+				case IMAGE_LENGTH: 
+					fi.height = value;
+					break;
+ 				case STRIP_OFFSETS:
+					if (count==1)
+						fi.stripOffsets = new int[] {value};
+					else {
+						long saveLoc = in.getLongFilePointer();
+						in.seek(lvalue);
+						fi.stripOffsets = new int[count];
+						for (int c=0; c<count; c++)
+							fi.stripOffsets[c] = getInt();
+						in.seek(saveLoc);
+					}
+					fi.offset = count>0?fi.stripOffsets[0]:value;
+					if (count>1 && (((long)fi.stripOffsets[count-1])&0xffffffffL)<(((long)fi.stripOffsets[0])&0xffffffffL))
+						fi.offset = fi.stripOffsets[count-1];
+					break;
+				case STRIP_BYTE_COUNT:
+					if (count==1)
+						fi.stripLengths = new int[] {value};
+					else {
+						long saveLoc = in.getLongFilePointer();
+						in.seek(lvalue);
+						fi.stripLengths = new int[count];
+						for (int c=0; c<count; c++) {
+							if (fieldType==SHORT)
+								fi.stripLengths[c] = getShort();
+							else
+								fi.stripLengths[c] = getInt();
+						}
+						in.seek(saveLoc);
+					}
+					break;
+ 				case PHOTO_INTERP:
+ 					photoInterp = value;
+ 					fi.whiteIsZero = value==0;
+					break;
+				case BITS_PER_SAMPLE:
+						if (count==1) {
+							if (value==8)
+								fi.fileType = FileInfo.GRAY8;
+							else if (value==16)
+								fi.fileType = FileInfo.GRAY16_UNSIGNED;
+							else if (value==32)
+								fi.fileType = FileInfo.GRAY32_INT;
+							else if (value==12)
+								fi.fileType = FileInfo.GRAY12_UNSIGNED;
+							else if (value==1)
+								fi.fileType = FileInfo.BITMAP;
+							else
+								error("Unsupported BitsPerSample: " + value);
+						} else if (count>1) {
+							long saveLoc = in.getLongFilePointer();
+							in.seek(lvalue);
+							int bitDepth = getShort();
+							if (bitDepth==8)
+								fi.fileType = FileInfo.GRAY8;
+							else if (bitDepth==16)
+								fi.fileType = FileInfo.GRAY16_UNSIGNED;
+							else
+								error("ImageJ cannot open interleaved "+bitDepth+"-bit images.");
+							in.seek(saveLoc);
+						}
+						break;
+				case SAMPLES_PER_PIXEL:
+					fi.samplesPerPixel = value;
+					if (value==3 && fi.fileType==FileInfo.GRAY8)
+						fi.fileType = FileInfo.RGB;
+					else if (value==3 && fi.fileType==FileInfo.GRAY16_UNSIGNED)
+						fi.fileType = FileInfo.RGB48;
+					else if (value==4 && fi.fileType==FileInfo.GRAY8)
+						fi.fileType = photoInterp==5?FileInfo.CMYK:FileInfo.ARGB;
+					else if (value==4 && fi.fileType==FileInfo.GRAY16_UNSIGNED) {
+						fi.fileType = FileInfo.RGB48;
+						if (photoInterp==5)  //assume cmyk
+							fi.whiteIsZero = true;
+					}
+					break;
+				case ROWS_PER_STRIP:
+					fi.rowsPerStrip = value;
+					break;
+				case X_RESOLUTION:
+					double xScale = getRational(lvalue); 
+					if (xScale!=0.0) fi.pixelWidth = 1.0/xScale; 
+					break;
+				case Y_RESOLUTION:
+					double yScale = getRational(lvalue); 
+					if (yScale!=0.0) fi.pixelHeight = 1.0/yScale; 
+					break;
+				case RESOLUTION_UNIT:
+					if (value==1&&fi.unit==null)
+						fi.unit = " ";
+					else if (value==2) {
+						if (fi.pixelWidth==1.0/72.0) {
+							fi.pixelWidth = 1.0;
+							fi.pixelHeight = 1.0;
+						} else
+							fi.unit = "inch";
+					} else if (value==3)
+						fi.unit = "cm";
+					break;
+				case PLANAR_CONFIGURATION:  // 1=chunky, 2=planar
+					if (value==2 && fi.fileType==FileInfo.RGB48)
+							 fi.fileType = FileInfo.RGB48_PLANAR;
+					else if (value==2 && fi.fileType==FileInfo.RGB)
+						fi.fileType = FileInfo.RGB_PLANAR;
+					else if (value!=2 && !(fi.samplesPerPixel==1||fi.samplesPerPixel==3||fi.samplesPerPixel==4)) {
+						String msg = "Unsupported SamplesPerPixel: " + fi.samplesPerPixel;
+						error(msg);
+					}
+					break;
+				case COMPRESSION:
+					if (value==5)  {// LZW compression
+						fi.compression = FileInfo.LZW;
+						if (fi.fileType==FileInfo.GRAY12_UNSIGNED)
+							error("ImageJ cannot open 12-bit LZW-compressed TIFFs");
+					} else if (value==32773)  // PackBits compression
+						fi.compression = FileInfo.PACK_BITS;
+					else if (value==32946 || value==8)
+						fi.compression = FileInfo.ZIP;
+					else if (value!=1 && value!=0 && !(value==7&&fi.width<500)) {
+						// don't abort with Spot camera compressed (7) thumbnails
+						// otherwise, this is an unknown compression type
+						fi.compression = FileInfo.COMPRESSION_UNKNOWN;
+						error("ImageJ cannot open TIFF files " +
+							"compressed in this fashion ("+value+")");
+					}
+					break;
+				case SOFTWARE: case DATE_TIME: case HOST_COMPUTER: case ARTIST:
+					if (ifdCount==1) {
+						byte[] bytes = getString(count, lvalue);
+						String s = bytes!=null?new String(bytes):null;
+						saveMetadata(getName(tag), s);
+					}
+					break;
+				case PREDICTOR:
+					if (value==2 && fi.compression==FileInfo.LZW)
+						fi.compression = FileInfo.LZW_WITH_DIFFERENCING;
+					if (value==3)
+						IJ.log("TiffDecoder: unsupported predictor value of 3");
+					break;
+				case COLOR_MAP: 
+					if (count==768)
+						getColorMap(lvalue, fi);
+					break;
+				case TILE_WIDTH:
+					error("ImageJ cannot open tiled TIFFs.\nTry using the Bio-Formats plugin.");
+					break;
+				case SAMPLE_FORMAT:
+					if (fi.fileType==FileInfo.GRAY32_INT && value==FLOATING_POINT)
+						fi.fileType = FileInfo.GRAY32_FLOAT;
+					if (fi.fileType==FileInfo.GRAY16_UNSIGNED) {
+						if (value==SIGNED)
+							fi.fileType = FileInfo.GRAY16_SIGNED;
+						if (value==FLOATING_POINT)
+							error("ImageJ cannot open 16-bit float TIFFs");
+					}
+					break;
+				case JPEG_TABLES:
+					if (fi.compression==FileInfo.JPEG)
+						error("Cannot open JPEG-compressed TIFFs with separate tables");
+					break;
+				case IMAGE_DESCRIPTION: 
+					if (ifdCount==1) {
+						byte[] s = getString(count, lvalue);
+						if (s!=null) saveImageDescription(s,fi);
+					}
+					break;
+				case ORIENTATION:
+					fi.nImages = 0; // file not created by ImageJ so look at all the IFDs
+					break;
+				case METAMORPH1: case METAMORPH2:
+					if ((name.indexOf(".STK")>0||name.indexOf(".stk")>0) && fi.compression==FileInfo.COMPRESSION_NONE) {
+						if (tag==METAMORPH2)
+							fi.nImages=count;
+						else
+							fi.nImages=9999;
+					}
+					break;
+				case IPLAB: 
+					fi.nImages=value;
+					break;
+				case NIH_IMAGE_HDR: 
+					if (count==256)
+						decodeNIHImageHeader(value, fi);
+					break;
+ 				case META_DATA_BYTE_COUNTS: 
+					long saveLoc = in.getLongFilePointer();
+					in.seek(lvalue);
+					metaDataCounts = new int[count];
+					for (int c=0; c<count; c++)
+						metaDataCounts[c] = getInt();
+					in.seek(saveLoc);
+					break;
+ 				case META_DATA: 
+ 					getMetaData(value, fi);
+ 					break;
+				default:
+					if (tag>10000 && tag<32768 && ifdCount>1)
+						return null;
+			}
+		}
+		fi.fileFormat = fi.TIFF;
+		fi.fileName = name;
+		fi.directory = directory;
+		if (url!=null)
+			fi.url = url;
+		return fi;
+	}
+
+	void getMetaData(int loc, FileInfo fi) throws IOException {
+		if (metaDataCounts==null || metaDataCounts.length==0)
+			return;
+		int maxTypes = 10;
+		long saveLoc = in.getLongFilePointer();
+		in.seek(loc);
+		int n = metaDataCounts.length;
+		int hdrSize = metaDataCounts[0];
+		if (hdrSize<12 || hdrSize>804) {
+			in.seek(saveLoc);
+			return;
+		}
+		int magicNumber = getInt();
+		if (magicNumber!=MAGIC_NUMBER)  { // "IJIJ"
+			in.seek(saveLoc);
+			return;
+		}
+		int nTypes = (hdrSize-4)/8;
+		int[] types = new int[nTypes];
+		int[] counts = new int[nTypes];		
+		if (debugMode) {
+			dInfo += "Metadata:\n";
+			dInfo += "   Entries: "+(metaDataCounts.length-1)+"\n";
+			dInfo += "   Types: "+nTypes+"\n";
+		}
+		int extraMetaDataEntries = 0;
+		int index = 1;
+		for (int i=0; i<nTypes; i++) {
+			types[i] = getInt();
+			counts[i] = getInt();
+			if (types[i]<0xffffff)
+				extraMetaDataEntries += counts[i];
+			if (debugMode) {
+				String id = "unknown";
+				if (types[i]==INFO) id = "Info property";
+				if (types[i]==LABELS) id = "slice labels";
+				if (types[i]==RANGES) id = "display ranges";
+				if (types[i]==LUTS) id = "luts";
+				if (types[i]==PLOT) id = "plot";
+				if (types[i]==ROI) id = "roi";
+				if (types[i]==OVERLAY) id = "overlay";
+				if (types[i]==PROPERTIES) id = "properties";
+				int len = metaDataCounts[index];
+				int count = counts[i];
+				index += count;
+				if (index>=metaDataCounts.length) index=1;
+				String lenstr = count==1?", length=":", length[0]=";
+				dInfo += "   "+i+", type="+id+", count="+count+lenstr+len+"\n";
+			}
+		}
+		fi.metaDataTypes = new int[extraMetaDataEntries];
+		fi.metaData = new byte[extraMetaDataEntries][];
+		int start = 1;
+		int eMDindex = 0;
+		for (int i=0; i<nTypes; i++) {
+			if (types[i]==INFO)
+				getInfoProperty(start, fi);
+			else if (types[i]==LABELS)
+				getSliceLabels(start, start+counts[i]-1, fi);
+			else if (types[i]==RANGES)
+				getDisplayRanges(start, fi);
+			else if (types[i]==LUTS)
+				getLuts(start, start+counts[i]-1, fi);
+			else if (types[i]==PLOT)
+				getPlot(start, fi);
+			else if (types[i]==ROI)
+				getRoi(start, fi);
+			else if (types[i]==OVERLAY)
+				getOverlay(start, start+counts[i]-1, fi);
+			else if (types[i]==PROPERTIES)
+				getProperties(start, start+counts[i]-1, fi);
+			else if (types[i]<0xffffff) {
+				for (int j=start; j<start+counts[i]; j++) { 
+					int len = metaDataCounts[j]; 
+					fi.metaData[eMDindex] = new byte[len]; 
+					in.readFully(fi.metaData[eMDindex], len); 
+					fi.metaDataTypes[eMDindex] = types[i]; 
+					eMDindex++; 
+				} 
+			} else
+				skipUnknownType(start, start+counts[i]-1);
+			start += counts[i];
+		}
+		in.seek(saveLoc);
+	}
+
+	void getInfoProperty(int first, FileInfo fi) throws IOException {
+		int len = metaDataCounts[first];
+	    byte[] buffer = new byte[len];
+		in.readFully(buffer, len);
+		len /= 2;
+		char[] chars = new char[len];
+		if (littleEndian) {
+			for (int j=0, k=0; j<len; j++)
+				chars[j] = (char)(buffer[k++]&255 + ((buffer[k++]&255)<<8));
+		} else {
+			for (int j=0, k=0; j<len; j++)
+				chars[j] = (char)(((buffer[k++]&255)<<8) + buffer[k++]&255);
+		}
+		fi.info = new String(chars);
+	}
+
+	void getSliceLabels(int first, int last, FileInfo fi) throws IOException {
+		fi.sliceLabels = new String[last-first+1];
+	    int index = 0;
+	    byte[] buffer = new byte[metaDataCounts[first]];
+		for (int i=first; i<=last; i++) {
+			int len = metaDataCounts[i];
+			if (len>0) {
+				if (len>buffer.length)
+					buffer = new byte[len];
+				in.readFully(buffer, len);
+				len /= 2;
+				char[] chars = new char[len];
+				if (littleEndian) {
+					for (int j=0, k=0; j<len; j++)
+						chars[j] = (char)(buffer[k++]&255 + ((buffer[k++]&255)<<8));
+				} else {
+					for (int j=0, k=0; j<len; j++)
+						chars[j] = (char)(((buffer[k++]&255)<<8) + buffer[k++]&255);
+				}
+				fi.sliceLabels[index++] = new String(chars);
+				//ij.IJ.log(i+"  "+fi.sliceLabels[i-1]+"  "+len);
+			} else
+				fi.sliceLabels[index++] = null;
+		}
+	}
+
+	void getDisplayRanges(int first, FileInfo fi) throws IOException {
+		int n = metaDataCounts[first]/8;
+		fi.displayRanges = new double[n];
+		for (int i=0; i<n; i++)
+			fi.displayRanges[i] = readDouble();
+	}
+
+	void getLuts(int first, int last, FileInfo fi) throws IOException {
+		fi.channelLuts = new byte[last-first+1][];
+	    int index = 0;
+		for (int i=first; i<=last; i++) {
+			int len = metaDataCounts[i];
+			fi.channelLuts[index] = new byte[len];
+            in.readFully(fi.channelLuts[index], len);
+            index++;
+		}
+	}
+
+	void getRoi(int first, FileInfo fi) throws IOException {
+		int len = metaDataCounts[first];
+		fi.roi = new byte[len]; 
+		in.readFully(fi.roi, len); 
+	}
+
+	void getPlot(int first, FileInfo fi) throws IOException {
+		int len = metaDataCounts[first];
+		fi.plot = new byte[len];
+		in.readFully(fi.plot, len);
+	}
+
+	void getOverlay(int first, int last, FileInfo fi) throws IOException {
+		fi.overlay = new byte[last-first+1][];
+	    int index = 0;
+		for (int i=first; i<=last; i++) {
+			int len = metaDataCounts[i];
+			fi.overlay[index] = new byte[len];
+            in.readFully(fi.overlay[index], len);
+            index++;
+		}
+	}
+
+	void getProperties(int first, int last, FileInfo fi) throws IOException {
+		fi.properties = new String[last-first+1];
+	    int index = 0;
+	    byte[] buffer = new byte[metaDataCounts[first]];
+		for (int i=first; i<=last; i++) {
+			int len = metaDataCounts[i];
+			if (len>buffer.length)
+				buffer = new byte[len];
+			in.readFully(buffer, len);
+			len /= 2;
+			char[] chars = new char[len];
+			if (littleEndian) {
+				for (int j=0, k=0; j<len; j++)
+					chars[j] = (char)(buffer[k++]&255 + ((buffer[k++]&255)<<8));
+			} else {
+				for (int j=0, k=0; j<len; j++)
+					chars[j] = (char)(((buffer[k++]&255)<<8) + buffer[k++]&255);
+			}
+			fi.properties[index++] = new String(chars);
+		}
+	}
+
+	void error(String message) throws IOException {
+		if (in!=null) in.close();
+		throw new IOException(message);
+	}
+	
+	void skipUnknownType(int first, int last) throws IOException {
+	    byte[] buffer = new byte[metaDataCounts[first]];
+		for (int i=first; i<=last; i++) {
+			int len = metaDataCounts[i];
+            if (len>buffer.length)
+                buffer = new byte[len];
+            in.readFully(buffer, len);
+		}
+	}
+
+	public void enableDebugging() {
+		debugMode = true;
+	}
+		
+	public FileInfo[] getTiffInfo() throws IOException {
+		long ifdOffset;
+		ArrayList list = new ArrayList();
+		if (in==null)
+			in = new RandomAccessStream(new RandomAccessFile(new File(directory+name), "r"));
+		ifdOffset = OpenImageFileHeader();
+		if (ifdOffset<0L) {
+			in.close();
+			return null;
+		}
+		if (debugMode) dInfo = "\n  " + name + ": opening\n";
+		while (ifdOffset>0L) {
+			in.seek(ifdOffset);
+			FileInfo fi = OpenIFD();
+			if (fi!=null) {
+				list.add(fi);
+				ifdOffset = ((long)getInt())&0xffffffffL;
+			} else
+				ifdOffset = 0L;
+			if (debugMode && ifdCount<10) dInfo += "nextIFD=" + ifdOffset + "\n";
+			if (fi!=null && fi.nImages>1)
+				ifdOffset = 0L;   // ignore extra IFDs in ImageJ and NIH Image stacks
+		}
+		if (list.size()==0) {
+			in.close();
+			return null;
+		} else {
+			FileInfo[] info = (FileInfo[])list.toArray(new FileInfo[list.size()]);
+			if (debugMode) info[0].debugInfo = dInfo;
+			if (url!=null) {
+				in.seek(0);
+				info[0].inputStream = in;
+			} else
+				in.close();
+			if (info[0].info==null)
+				info[0].info = tiffMetadata;
+			FileInfo fi = info[0];
+			if (fi.fileType==FileInfo.GRAY16_UNSIGNED && fi.description==null)
+				fi.lutSize = 0; // ignore troublesome non-ImageJ 16-bit LUTs
+			if (debugMode) {
+				int n = info.length;
+				fi.debugInfo += "number of IFDs: "+ n + "\n";
+				fi.debugInfo += "offset to first image: "+fi.getOffset()+ "\n";
+				fi.debugInfo += "gap between images: "+getGapInfo(info) + "\n";
+				fi.debugInfo += "little-endian byte order: "+fi.intelByteOrder + "\n";
+			}
+			return info;
+		}
+	}
+	
+	String getGapInfo(FileInfo[] fi) {
+		if (fi.length<2) return "0";
+		long minGap = Long.MAX_VALUE;
+		long maxGap = -Long.MAX_VALUE;
+		for (int i=1; i<fi.length; i++) {
+			long gap = fi[i].getOffset()-fi[i-1].getOffset();
+			if (gap<minGap) minGap = gap;
+			if (gap>maxGap) maxGap = gap;
+		}
+		long imageSize = fi[0].width*fi[0].height*fi[0].getBytesPerPixel();
+		minGap -= imageSize;
+		maxGap -= imageSize;
+		if (minGap==maxGap)
+			return ""+minGap;
+		else 
+			return "varies ("+minGap+" to "+maxGap+")";
+	}
+
+}
diff --git a/src/ij/io/TiffEncoder.java b/src/ij/io/TiffEncoder.java
new file mode 100644
index 0000000..8989ec8
--- /dev/null
+++ b/src/ij/io/TiffEncoder.java
@@ -0,0 +1,555 @@
+package ij.io;
+import java.io.*;
+
+/**Saves an image described by a FileInfo object as an uncompressed TIFF file.*/
+public class TiffEncoder {
+	static final int HDR_SIZE = 8;
+	static final int MAP_SIZE = 768; // in 16-bit words
+	static final int BPS_DATA_SIZE = 6;
+	static final int SCALE_DATA_SIZE = 16;
+		
+	private FileInfo fi;
+	private int bitsPerSample;
+	private int photoInterp;
+	private int samplesPerPixel;
+	private int nEntries;
+	private int ifdSize;
+	private long imageOffset;
+	private int imageSize;
+	private long stackSize;
+	private byte[] description;
+	private int metaDataSize;
+	private int nMetaDataTypes;
+	private int nMetaDataEntries;
+	private int nSliceLabels;
+	private int extraMetaDataEntries;
+	private int scaleSize;
+	private boolean littleEndian = ij.Prefs.intelByteOrder;
+	private byte buffer[] = new byte[8];
+	private int colorMapSize = 0;
+
+		
+	public TiffEncoder (FileInfo fi) {
+		this.fi = fi;
+		fi.intelByteOrder = littleEndian;
+		bitsPerSample = 8;
+		samplesPerPixel = 1;
+		nEntries = 9;
+		int bytesPerPixel = 1;
+		int bpsSize = 0;
+
+		switch (fi.fileType) {
+			case FileInfo.GRAY8:
+				photoInterp = fi.whiteIsZero?0:1;
+				break;
+			case FileInfo.GRAY16_UNSIGNED:
+			case FileInfo.GRAY16_SIGNED:
+				bitsPerSample = 16;
+				photoInterp = fi.whiteIsZero?0:1;
+				if (fi.lutSize>0) {
+					nEntries = 10;
+					colorMapSize = MAP_SIZE*2;
+				}
+				bytesPerPixel = 2;
+				break;
+			case FileInfo.GRAY32_FLOAT:
+				bitsPerSample = 32;
+				photoInterp = fi.whiteIsZero?0:1;
+				if (fi.lutSize>0) {
+					nEntries = 10;
+					colorMapSize = MAP_SIZE*2;
+				}
+				bytesPerPixel = 4;
+				break;
+			case FileInfo.RGB:
+				photoInterp = 2;
+				samplesPerPixel = 3;
+				bytesPerPixel = 3;
+				bpsSize = BPS_DATA_SIZE;
+				break;
+			case FileInfo.RGB48:
+				bitsPerSample = 16;
+				photoInterp = 2;
+				samplesPerPixel = 3;
+				bytesPerPixel = 6;
+				fi.nImages /= 3;
+				bpsSize = BPS_DATA_SIZE;
+				break;
+			case FileInfo.COLOR8:
+				photoInterp = 3;
+				nEntries = 10;
+				colorMapSize = MAP_SIZE*2;
+				break;
+			default:
+				photoInterp = 0;
+		}
+		if (fi.unit!=null && fi.pixelWidth!=0 && fi.pixelHeight!=0)
+			nEntries += 3; // XResolution, YResolution and ResolutionUnit
+		if (fi.fileType==fi.GRAY32_FLOAT)
+			nEntries++; // SampleFormat tag
+		makeDescriptionString();
+		if (description!=null)
+			nEntries++;  // ImageDescription tag
+		long size = (long)fi.width*fi.height*bytesPerPixel;
+		imageSize = size<=0xffffffffL?(int)size:0;
+		stackSize = (long)imageSize*fi.nImages;
+		metaDataSize = getMetaDataSize();
+		if (metaDataSize>0)
+			nEntries += 2; // MetaData & MetaDataCounts
+		ifdSize = 2 + nEntries*12 + 4;
+		int descriptionSize = description!=null?description.length:0;
+		scaleSize = fi.unit!=null && fi.pixelWidth!=0 && fi.pixelHeight!=0?SCALE_DATA_SIZE:0;
+		imageOffset = HDR_SIZE+ifdSize+bpsSize+descriptionSize+scaleSize+colorMapSize + nMetaDataEntries*4 + metaDataSize;
+		fi.offset = (int)imageOffset;
+		//ij.IJ.log(imageOffset+", "+ifdSize+", "+bpsSize+", "+descriptionSize+", "+scaleSize+", "+colorMapSize+", "+nMetaDataEntries*4+", "+metaDataSize);
+	}
+	
+	/** Saves the image as a TIFF file. The OutputStream is not closed.
+		The fi.pixels field must contain the image data. If fi.nImages>1
+		then fi.pixels must be a 2D array. The fi.offset field is ignored. */
+	public void write(OutputStream out) throws IOException {
+		writeHeader(out);
+		long nextIFD = 0L;
+		if (fi.nImages>1)
+			nextIFD = imageOffset+stackSize;
+		boolean bigTiff = nextIFD+fi.nImages*ifdSize>=0xffffffffL;
+		if (bigTiff)
+			nextIFD = 0L;
+		writeIFD(out, (int)imageOffset, (int)nextIFD);
+		if (fi.fileType==FileInfo.RGB||fi.fileType==FileInfo.RGB48)
+			writeBitsPerPixel(out);
+		if (description!=null)
+			writeDescription(out);
+		if (scaleSize>0)
+			writeScale(out);
+		if (colorMapSize>0)
+			writeColorMap(out);
+		if (metaDataSize>0)
+			writeMetaData(out);
+		new ImageWriter(fi).write(out);
+		if (nextIFD>0L) {
+			int ifdSize2 = ifdSize;
+			if (metaDataSize>0) {
+				metaDataSize = 0;
+				nEntries -= 2;
+				ifdSize2 -= 2*12;
+			}
+			for (int i=2; i<=fi.nImages; i++) {
+				if (i==fi.nImages)
+					nextIFD = 0;
+				else
+					nextIFD += ifdSize2;
+				imageOffset += imageSize;
+				writeIFD(out, (int)imageOffset, (int)nextIFD);
+			}
+		} else if (bigTiff)
+				ij.IJ.log("Stack is larger than 4GB. Most TIFF readers will only open the first image. Use this information to open as raw:\n"+fi);
+	}
+	
+	public void write(DataOutputStream out) throws IOException {
+		write((OutputStream)out);
+	}
+
+	int getMetaDataSize() {
+		nSliceLabels = 0;
+		nMetaDataEntries = 0;
+		int size = 0;
+		int nTypes = 0;
+		if (fi.info!=null && fi.info.length()>0) {
+			nMetaDataEntries = 1;
+			size = fi.info.length()*2;
+			nTypes++;
+		}
+		if (fi.sliceLabels!=null) {
+			int max = Math.min(fi.sliceLabels.length, fi.nImages);
+			boolean isNonNullLabel = false;
+			for (int i=0; i<max; i++) {
+				if (fi.sliceLabels[i]!=null && fi.sliceLabels[i].length()>0) {
+					isNonNullLabel = true;
+					break;
+				}
+			}
+			if (isNonNullLabel) {
+				for (int i=0; i<max; i++) {
+					nSliceLabels++;
+					if (fi.sliceLabels[i]!=null)
+						size += fi.sliceLabels[i].length()*2;
+				}
+				if (nSliceLabels>0) nTypes++;
+				nMetaDataEntries += nSliceLabels;
+			}
+		}
+
+		if (fi.displayRanges!=null) {
+			nMetaDataEntries++;
+			size += fi.displayRanges.length*8;
+			nTypes++;
+		}
+
+		if (fi.channelLuts!=null) {
+			for (int i=0; i<fi.channelLuts.length; i++) {
+                if (fi.channelLuts[i]!=null)
+                    size += fi.channelLuts[i].length;
+            }
+			nTypes++;
+			nMetaDataEntries += fi.channelLuts.length;
+		}
+
+		if (fi.plot!=null) {
+			nMetaDataEntries++;
+			size += fi.plot.length;
+			nTypes++;
+		}
+
+		if (fi.roi!=null) {
+			nMetaDataEntries++;
+			size += fi.roi.length;
+			nTypes++;
+		}
+
+		if (fi.overlay!=null) {
+			for (int i=0; i<fi.overlay.length; i++) {
+				if (fi.overlay[i]!=null)
+					size += fi.overlay[i].length;
+			}
+			nTypes++;
+			nMetaDataEntries += fi.overlay.length;
+		}
+
+		if (fi.properties!=null) {
+			for (int i=0; i<fi.properties.length; i++)
+				size += fi.properties[i].length()*2;
+			nTypes++;
+			nMetaDataEntries += fi.properties.length;
+		}
+
+		if (fi.metaDataTypes!=null && fi.metaData!=null && fi.metaData[0]!=null
+		&& fi.metaDataTypes.length==fi.metaData.length) {
+			extraMetaDataEntries = fi.metaData.length;
+			nTypes += extraMetaDataEntries;
+			nMetaDataEntries += extraMetaDataEntries;
+			for (int i=0; i<extraMetaDataEntries; i++) {
+                if (fi.metaData[i]!=null)
+                    size += fi.metaData[i].length;
+            }
+		}
+		if (nMetaDataEntries>0) nMetaDataEntries++; // add entry for header
+		int hdrSize = 4 + nTypes*8;
+		if (size>0) size += hdrSize;
+		nMetaDataTypes = nTypes;
+		return size;
+	}
+	
+	/** Writes the 8-byte image file header. */
+	void writeHeader(OutputStream out) throws IOException {
+		byte[] hdr = new byte[8];
+		if (littleEndian) {
+			hdr[0] = 73; // "II" (Intel byte order)
+			hdr[1] = 73;
+			hdr[2] = 42;  // 42 (magic number)
+			hdr[3] = 0;
+			hdr[4] = 8;  // 8 (offset to first IFD)
+			hdr[5] = 0;
+			hdr[6] = 0;
+			hdr[7] = 0;
+		} else {
+			hdr[0] = 77; // "MM" (Motorola byte order)
+			hdr[1] = 77;
+			hdr[2] = 0;  // 42 (magic number)
+			hdr[3] = 42;
+			hdr[4] = 0;  // 8 (offset to first IFD)
+			hdr[5] = 0;
+			hdr[6] = 0;
+			hdr[7] = 8;
+		}
+		out.write(hdr);
+	}
+	
+	/** Writes one 12-byte IFD entry. */
+	void writeEntry(OutputStream out, int tag, int fieldType, int count, int value) throws IOException {
+		writeShort(out, tag);
+		writeShort(out, fieldType);
+		writeInt(out, count);
+		if (count==1 && fieldType==TiffDecoder.SHORT) {
+			writeShort(out, value);
+			writeShort(out, 0);
+		} else
+			writeInt(out, value); // may be an offset
+	}
+	
+	/** Writes one IFD (Image File Directory). */
+	void writeIFD(OutputStream out, int imageOffset, int nextIFD) throws IOException {	
+		int tagDataOffset = HDR_SIZE + ifdSize;
+		writeShort(out, nEntries);
+		writeEntry(out, TiffDecoder.NEW_SUBFILE_TYPE, 4, 1, 0);
+		writeEntry(out, TiffDecoder.IMAGE_WIDTH, 4, 1, fi.width);
+		writeEntry(out, TiffDecoder.IMAGE_LENGTH, 4, 1, fi.height);
+		if (fi.fileType==FileInfo.RGB||fi.fileType==FileInfo.RGB48) {
+			writeEntry(out, TiffDecoder.BITS_PER_SAMPLE,  3, 3, tagDataOffset);
+			tagDataOffset += BPS_DATA_SIZE;
+		} else
+			writeEntry(out, TiffDecoder.BITS_PER_SAMPLE,  3, 1, bitsPerSample);
+		writeEntry(out, TiffDecoder.PHOTO_INTERP,     3, 1, photoInterp);
+		if (description!=null) {
+			writeEntry(out, TiffDecoder.IMAGE_DESCRIPTION, 2, description.length, tagDataOffset);
+			tagDataOffset += description.length;
+		}
+		writeEntry(out, TiffDecoder.STRIP_OFFSETS,    4, 1, imageOffset);
+		writeEntry(out, TiffDecoder.SAMPLES_PER_PIXEL,3, 1, samplesPerPixel);
+		writeEntry(out, TiffDecoder.ROWS_PER_STRIP,   3, 1, fi.height);
+		writeEntry(out, TiffDecoder.STRIP_BYTE_COUNT, 4, 1, imageSize);
+		if (fi.unit!=null && fi.pixelWidth!=0 && fi.pixelHeight!=0) {
+			writeEntry(out, TiffDecoder.X_RESOLUTION, 5, 1, tagDataOffset);
+			writeEntry(out, TiffDecoder.Y_RESOLUTION, 5, 1, tagDataOffset+8);
+			tagDataOffset += SCALE_DATA_SIZE;
+			int unit = 1;
+			if (fi.unit.equals("inch"))
+				unit = 2;
+			else if (fi.unit.equals("cm"))
+				unit = 3;
+			writeEntry(out, TiffDecoder.RESOLUTION_UNIT, 3, 1, unit);
+		}
+		if (fi.fileType==fi.GRAY32_FLOAT) {
+			int format = TiffDecoder.FLOATING_POINT;
+			writeEntry(out, TiffDecoder.SAMPLE_FORMAT, 3, 1, format);
+		}
+		if (colorMapSize>0) {
+			writeEntry(out, TiffDecoder.COLOR_MAP, 3, MAP_SIZE, tagDataOffset);
+			tagDataOffset += MAP_SIZE*2;
+		}
+		if (metaDataSize>0) {
+			writeEntry(out, TiffDecoder.META_DATA_BYTE_COUNTS, 4, nMetaDataEntries, tagDataOffset);
+			writeEntry(out, TiffDecoder.META_DATA, 1, metaDataSize, tagDataOffset+4*nMetaDataEntries);
+			tagDataOffset += nMetaDataEntries*4 + metaDataSize;
+		}
+		writeInt(out, nextIFD);
+	}
+	
+	/** Writes the 6 bytes of data required by RGB BitsPerSample tag. */
+	void writeBitsPerPixel(OutputStream out) throws IOException {
+		int bitsPerPixel = fi.fileType==FileInfo.RGB48?16:8;
+		writeShort(out, bitsPerPixel);
+		writeShort(out, bitsPerPixel);
+		writeShort(out, bitsPerPixel);
+	}
+
+	/** Writes the 16 bytes of data required by the XResolution and YResolution tags. */
+	void writeScale(OutputStream out) throws IOException {
+		double xscale = 1.0/fi.pixelWidth;
+		double yscale = 1.0/fi.pixelHeight;
+		double scale = 1000000.0;
+		if (xscale*scale>Integer.MAX_VALUE||yscale*scale>Integer.MAX_VALUE)
+			scale = (int)(Integer.MAX_VALUE/Math.max(xscale,yscale));
+		writeInt(out, (int)(xscale*scale));
+		writeInt(out, (int)scale);
+		writeInt(out, (int)(yscale*scale));
+		writeInt(out, (int)scale);
+	}
+
+	/** Writes the variable length ImageDescription string. */
+	void writeDescription(OutputStream out) throws IOException {
+		out.write(description,0,description.length);
+	}
+
+	/** Writes color palette following the image. */
+	void writeColorMap(OutputStream out) throws IOException {
+		byte[] colorTable16 = new byte[MAP_SIZE*2];
+		int j=littleEndian?1:0;
+		for (int i=0; i<fi.lutSize; i++) {
+			colorTable16[j] = fi.reds[i];
+			colorTable16[512+j] = fi.greens[i];
+			colorTable16[1024+j] = fi.blues[i];
+			j += 2;
+		}
+		out.write(colorTable16);
+	}
+	
+	/** Writes image metadata ("info" property, 
+		stack slice labels, channel display ranges, luts, ROIs,
+		overlays, properties and extra metadata). */
+	void writeMetaData(OutputStream out) throws IOException {
+	
+		// write byte counts (META_DATA_BYTE_COUNTS tag)
+		writeInt(out, 4+nMetaDataTypes*8); // header size	
+		if (fi.info!=null && fi.info.length()>0)
+			writeInt(out, fi.info.length()*2);
+		for (int i=0; i<nSliceLabels; i++) {
+			if (fi.sliceLabels[i]==null)
+				writeInt(out, 0);
+			else
+				writeInt(out, fi.sliceLabels[i].length()*2);
+		}
+		if (fi.displayRanges!=null)
+			writeInt(out, fi.displayRanges.length*8);
+		if (fi.channelLuts!=null) {
+			for (int i=0; i<fi.channelLuts.length; i++)
+				writeInt(out, fi.channelLuts[i].length);
+		}
+		if (fi.plot!=null)
+			writeInt(out, fi.plot.length);
+		if (fi.roi!=null)
+			writeInt(out, fi.roi.length);
+		if (fi.overlay!=null) {
+			for (int i=0; i<fi.overlay.length; i++)
+				writeInt(out, fi.overlay[i].length);
+		}
+		if (fi.properties!=null) {
+			for (int i=0; i<fi.properties.length; i++)
+				writeInt(out, fi.properties[i].length()*2);
+		}
+		for (int i=0; i<extraMetaDataEntries; i++)
+			writeInt(out, fi.metaData[i].length);	
+		
+		// write header (META_DATA tag header)
+		writeInt(out, TiffDecoder.MAGIC_NUMBER); // "IJIJ"
+		if (fi.info!=null) {
+			writeInt(out, TiffDecoder.INFO); // type="info"
+			writeInt(out, 1); // count
+		}
+		if (nSliceLabels>0) {
+			writeInt(out, TiffDecoder.LABELS); // type="labl"
+			writeInt(out, nSliceLabels); // count
+		}
+		if (fi.displayRanges!=null) {
+			writeInt(out, TiffDecoder.RANGES); // type="rang"
+			writeInt(out, 1); // count
+		}
+		if (fi.channelLuts!=null) {
+			writeInt(out, TiffDecoder.LUTS); // type="luts"
+			writeInt(out, fi.channelLuts.length); // count
+		}
+		if (fi.plot!=null) {
+			writeInt(out, TiffDecoder.PLOT); // type="plot"
+			writeInt(out, 1); // count
+		}
+		if (fi.roi!=null) {
+			writeInt(out, TiffDecoder.ROI); // type="roi "
+			writeInt(out, 1); // count
+		}
+		if (fi.overlay!=null) {
+			writeInt(out, TiffDecoder.OVERLAY); // type="over"
+			writeInt(out, fi.overlay.length); // count
+		}
+		if (fi.properties!=null) {
+			writeInt(out, TiffDecoder.PROPERTIES); // type="prop"
+			writeInt(out, fi.properties.length); // count
+		}
+		for (int i=0; i<extraMetaDataEntries; i++) {
+			writeInt(out, fi.metaDataTypes[i]);
+			writeInt(out, 1); // count
+		}
+		
+		// write data (META_DATA tag body)
+		if (fi.info!=null)
+			writeChars(out, fi.info);
+		for (int i=0; i<nSliceLabels; i++) {
+			if (fi.sliceLabels[i]!=null)
+				writeChars(out, fi.sliceLabels[i]);
+		}
+		if (fi.displayRanges!=null) {
+			for (int i=0; i<fi.displayRanges.length; i++)
+				writeDouble(out, fi.displayRanges[i]);
+		}
+		if (fi.channelLuts!=null) {
+			for (int i=0; i<fi.channelLuts.length; i++)
+				out.write(fi.channelLuts[i]);
+		}
+		if (fi.plot!=null)
+			out.write(fi.plot);
+		if (fi.roi!=null)
+			out.write(fi.roi);
+		if (fi.overlay!=null) {
+			for (int i=0; i<fi.overlay.length; i++)
+				out.write(fi.overlay[i]);
+		}
+		if (fi.properties!=null) {
+			for (int i=0; i<fi.properties.length; i++)
+				writeChars(out, fi.properties[i]);
+		}
+		for (int i=0; i<extraMetaDataEntries; i++)
+			out.write(fi.metaData[i]); 					
+	}
+
+	/** Creates an optional image description string for saving calibration data.
+		For stacks, also saves the stack size so ImageJ can open the stack without
+		decoding an IFD for each slice.*/
+	void makeDescriptionString() {
+		if (fi.description!=null) {
+			if (fi.description.charAt(fi.description.length()-1)!=(char)0)
+				fi.description += " ";
+			description = fi.description.getBytes();
+			description[description.length-1] = (byte)0;
+		} else
+			description = null;
+	}
+		
+	final void writeShort(OutputStream out, int v) throws IOException {
+		if (littleEndian) {
+       		out.write(v&255);
+        	out.write((v>>>8)&255);
+ 		} else {
+        	out.write((v>>>8)&255);
+        	out.write(v&255);
+        }
+	}
+
+	final void writeInt(OutputStream out, int v) throws IOException {
+		if (littleEndian) {
+        	out.write(v&255);
+        	out.write((v>>>8)&255);
+        	out.write((v>>>16)&255);
+         	out.write((v>>>24)&255);
+		} else {
+        	out.write((v>>>24)&255);
+        	out.write((v>>>16)&255);
+        	out.write((v>>>8)&255);
+        	out.write(v&255);
+        }
+	}
+
+    final void writeLong(OutputStream out, long v) throws IOException {
+    	if (littleEndian) {
+			buffer[7] = (byte)(v>>>56);
+			buffer[6] = (byte)(v>>>48);
+			buffer[5] = (byte)(v>>>40);
+			buffer[4] = (byte)(v>>>32);
+			buffer[3] = (byte)(v>>>24);
+			buffer[2] = (byte)(v>>>16);
+			buffer[1] = (byte)(v>>> 8);
+			buffer[0] = (byte)v;
+			out.write(buffer, 0, 8);
+        } else {
+			buffer[0] = (byte)(v>>>56);
+			buffer[1] = (byte)(v>>>48);
+			buffer[2] = (byte)(v>>>40);
+			buffer[3] = (byte)(v>>>32);
+			buffer[4] = (byte)(v>>>24);
+			buffer[5] = (byte)(v>>>16);
+			buffer[6] = (byte)(v>>> 8);
+			buffer[7] = (byte)v;
+			out.write(buffer, 0, 8);
+        }
+     }
+
+    final void writeDouble(OutputStream out, double v) throws IOException {
+		writeLong(out, Double.doubleToLongBits(v));
+    }
+    
+	final void writeChars(OutputStream out, String s) throws IOException {
+        int len = s.length();
+        if (littleEndian) {
+			for (int i = 0 ; i < len ; i++) {
+				int v = s.charAt(i);
+				out.write(v&255); 
+				out.write((v>>>8)&255); 
+			}
+        } else {
+			for (int i = 0 ; i < len ; i++) {
+				int v = s.charAt(i);
+				out.write((v>>>8)&255); 
+				out.write(v&255); 
+			}
+        }
+    }
+    
+}
diff --git a/src/ij/macro/Debugger.java b/src/ij/macro/Debugger.java
new file mode 100644
index 0000000..2622c91
--- /dev/null
+++ b/src/ij/macro/Debugger.java
@@ -0,0 +1,10 @@
+package ij.macro;
+
+	public interface Debugger {
+
+		public static final int NOT_DEBUGGING=0, STEP=1, TRACE=2, FAST_TRACE=3,
+			RUN_TO_COMPLETION=4, RUN_TO_CARET=5;
+		
+		public int debug(Interpreter interp, int mode);
+			
+}
diff --git a/src/ij/macro/ExtensionDescriptor.java b/src/ij/macro/ExtensionDescriptor.java
new file mode 100644
index 0000000..c98b011
--- /dev/null
+++ b/src/ij/macro/ExtensionDescriptor.java
@@ -0,0 +1,298 @@
+package ij.macro;
+import ij.IJ;
+import java.util.ArrayList;
+
+public class ExtensionDescriptor {
+  public String name;
+  public int[] argTypes;
+  public MacroExtension handler;
+  
+  public ExtensionDescriptor(String theName, int[] theArgTypes, MacroExtension theHandler) {
+    this.name = theName;
+    this.argTypes = theArgTypes;
+    this.handler = theHandler;
+  }
+  
+  public static ExtensionDescriptor newDescriptor(String theName, MacroExtension theHandler, int[] types) {
+    int[] argTypes = new int[types.length];
+    for (int i=0; i < types.length; ++i) {
+      argTypes[i] = types[i];
+    }
+    
+    return new ExtensionDescriptor(theName, argTypes, theHandler);
+  }
+  
+  public static ExtensionDescriptor newDescriptor(String theName, MacroExtension theHandler) {
+    return newDescriptor(theName, theHandler, new int[0]);
+  }
+  
+  public static ExtensionDescriptor newDescriptor(String theName, MacroExtension theHandler, int type) {
+    return newDescriptor(theName, theHandler, new int[] {type});
+  }
+  
+  public static ExtensionDescriptor newDescriptor(String theName, MacroExtension theHandler, int t1, int t2) {
+    return newDescriptor(theName, theHandler, new int[] {t1, t2});
+  }
+  
+  public static ExtensionDescriptor newDescriptor(String theName, MacroExtension theHandler, int t1, int t2, int t3) {
+    return newDescriptor(theName, theHandler, new int[] {t1, t2, t3});
+  }
+  
+  public static ExtensionDescriptor newDescriptor(String theName, MacroExtension theHandler, int t1, int t2, int t3, int t4) {
+    return newDescriptor(theName, theHandler, new int[] {t1, t2, t3, t4});
+  }  
+    
+  public static ExtensionDescriptor newDescriptor(String theName, MacroExtension theHandler, Integer[] types) {
+    int[] argTypes = new int[types.length];
+    for (int i=0; i < types.length; ++i) {
+      argTypes[i] = types[i].intValue();
+    }
+    
+    return new ExtensionDescriptor(theName, argTypes, theHandler);
+  }
+  
+  public static boolean isOptionalArg(int argType) {
+    return (argType & MacroExtension.ARG_OPTIONAL) == MacroExtension.ARG_OPTIONAL;
+  }
+  
+  public static boolean isOutputArg(int argType) {
+    return (argType & MacroExtension.ARG_OUTPUT) == MacroExtension.ARG_OUTPUT;
+  }
+  
+  public static int getRawType(int argType) {
+    return argType & ~(MacroExtension.ARG_OUTPUT|MacroExtension.ARG_OPTIONAL);
+  }
+  
+  public boolean checkArguments(Object[] args) {
+    for (int i=0; i < argTypes.length; ++i) {
+      boolean optional = isOptionalArg(argTypes[i]);
+      boolean output   = isOutputArg(argTypes[i]);
+      
+      int rawType = getRawType(argTypes[i]);
+      
+      if (args.length < i)
+        return optional ? true : false;
+      
+      switch(rawType) {
+      case MacroExtension.ARG_STRING:
+        if (output) {
+          if (! (args[i] instanceof String[])) return false;
+        } else {
+          if (! (args[i] instanceof String)) return false;
+        }
+      case MacroExtension.ARG_NUMBER:
+        if (output) {
+          if (! (args[i] instanceof Double[])) return false;
+        } else {
+          if (!(args[i] instanceof Double)) return false;
+        }
+      case MacroExtension.ARG_ARRAY:
+        if (!(args[i] instanceof Object[])) return false;
+      }
+    }
+    
+    return true;
+  }
+  
+  public static String getTypeName(int argType) {
+    switch(getRawType(argType)) {
+    case MacroExtension.ARG_STRING:
+      return "string";
+    case MacroExtension.ARG_NUMBER:
+      return "number";
+    case MacroExtension.ARG_ARRAY:
+      return "array";
+    default:
+      return "unknown";
+    }
+  }
+  
+  private static String getVariableTypename(int type) {
+    switch (type) {
+    case Variable.STRING:
+      return "string";
+    case Variable.NUMBER:
+      return "number";
+    case Variable.ARRAY:
+      return "array";
+    default:
+      return "unknown";
+    }
+  }
+  
+  // TODO: this doesn't account for "loops" in the arrays, which will result in an infinite loop
+  private static Object[] convertArray(Variable[] array) {
+    Object[] oArray = new Object[ array.length ];
+    for(int i=0; i < array.length; ++i) {
+      switch(array[i].getType()) {
+      case Variable.STRING:
+        oArray[i] = array[i].getString();
+        break;
+      case Variable.VALUE:
+        oArray[i] = new Double( array[i].getValue() );
+        break;
+      case Variable.ARRAY:
+        oArray[i] = convertArray(array[i].getArray());
+        break;
+      default:
+        oArray[i] = null;
+      }
+    }
+    
+    return oArray;
+  }
+  
+  Variable[] parseArgumentList(Functions func) {
+    Interpreter interp = func.interp;
+
+    Variable[] vArray = new Variable[argTypes.length];
+    int i=0;
+    do {
+      if (i >= argTypes.length) {
+        interp.error("too many arguments (expected "+argTypes.length+")");
+        return null;
+      }
+      boolean output   = isOutputArg(argTypes[i]);
+
+      Variable v;
+      if (output) {
+        v = func.getVariable();
+      } else {
+        v = new Variable();
+        switch (getRawType(argTypes[i])) {
+        case MacroExtension.ARG_STRING:
+          v.setString(func.getString());
+          break;
+        case MacroExtension.ARG_NUMBER:
+          v.setValue(interp.getExpression());
+          break;
+        case MacroExtension.ARG_ARRAY:
+          v.setArray(func.getArray());
+          break;
+        }
+      }
+      vArray[i] = v;
+      ++i;
+      interp.getToken();
+    } while (interp.token == ',');
+    
+    if (interp.token!=')')
+      interp.error("')' expected");
+
+    if (i < argTypes.length && !isOptionalArg(argTypes[i])) {
+      interp.error("too few arguments, expected "+argTypes.length+" but found "+i);
+    }
+    
+    return vArray;
+  }
+ 
+  
+  public static Object convertVariable(Interpreter interp, int rawType, Variable var) {
+    int type = getRawType(rawType);
+    boolean output = isOutputArg(rawType);
+
+    if (var == null)
+      return null;
+
+    switch (type) {
+    case MacroExtension.ARG_STRING:
+      if (!output && var.getType()!=Variable.STRING) {
+        interp.error("Expected string, but variable type is "+getVariableTypename(var.getType()));
+        return null;
+      }
+      if (output) {
+      	String s = var.getString();
+      	if (s==null) s = "";
+        return new String[] { s };
+      } else {
+        return var.getString();
+      }
+    case MacroExtension.ARG_NUMBER:
+      if (var.getType() != Variable.VALUE) {
+        interp.error("Expected number, but variable type is "+getVariableTypename(var.getType()));
+        return null;
+      }
+      if (output) {
+        return new Double[] { new Double(var.getValue()) };
+      } else {
+        return new Double( var.getValue() );
+      }
+    case MacroExtension.ARG_ARRAY:
+      if (var.getType() != Variable.ARRAY) {
+        interp.error("Expected array, but variable type is "+getVariableTypename(var.getType()));
+        return null;
+      }
+      return convertArray(var.getArray());
+    default:
+      interp.error("Unknown descriptor type "+type+" ("+rawType+")");
+      return null;
+    }
+  }
+
+  public static void convertOutputType(Variable variable, Object object) {
+    if (object instanceof String[]) {
+      String[] str = (String[]) object;
+      variable.setString(str[0]);
+    } else if (object instanceof Double[]) {
+      Double[] dbl = (Double[]) object;
+      variable.setValue(dbl[0].doubleValue());
+    } else if (object instanceof Object[]) {
+      Object[] arr = (Object[]) object;
+      Variable[] vArr = new Variable[arr.length];
+      for (int i=0; i < arr.length; ++i) {
+        vArr[i] = new Variable();
+        convertOutputType(vArr[i], arr[i]);
+      }
+      variable.setArray(vArr);
+    }
+  }
+  
+  public String dispatch(Functions func) {
+    Interpreter interp = func.interp;
+
+    if (argTypes.length==0) {
+      interp.getParens();
+      return handler.handleExtension(name, null);
+    }
+    interp.getLeftParen();
+    
+    Variable[] vArgs = null;
+    int next = interp.nextToken();
+    if (next != ')') {
+      vArgs = parseArgumentList(func);
+    }
+    
+    //for (int i=0; i < vArgs.length; ++i) {
+    //  Variable v = vArgs[i];
+    //  System.err.println("variable is "+(v!= null?v.toString():"(null)"));
+    //}
+    
+    Object[] args = new Object[ argTypes.length ];
+    if (vArgs==null && argTypes.length>0) {
+		interp.error("Argument expected");
+		return null;
+    }
+    // check variable types...
+    for (int i=0; i < argTypes.length; ++i) {
+      if (i >= vArgs.length) {
+        if (!ExtensionDescriptor.isOptionalArg(argTypes[i])) {
+          interp.error("Expected argument "+(i+1)+" of type "+ExtensionDescriptor.getTypeName(argTypes[i]));
+          return null;
+        } else {
+          break;
+        }
+      }
+      args[i] = ExtensionDescriptor.convertVariable(interp, argTypes[i], vArgs[i]);
+    }
+    
+    String retVal = handler.handleExtension(name, args);
+    for (int i=0; i < argTypes.length; ++i) {
+      if (i >= vArgs.length) break;
+      if (ExtensionDescriptor.isOutputArg(argTypes[i])) {
+        ExtensionDescriptor.convertOutputType(vArgs[i], args[i]);
+      }
+    }
+    
+    return retVal;
+  }
+}
diff --git a/src/ij/macro/FunctionFinder.java b/src/ij/macro/FunctionFinder.java
new file mode 100644
index 0000000..42ed351
--- /dev/null
+++ b/src/ij/macro/FunctionFinder.java
@@ -0,0 +1,232 @@
+package ij.macro;
+import ij.*;
+import ij.plugin.*;
+import ij.plugin.frame.*;
+import ij.gui.GUI;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Hashtable;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Set;
+
+/** This class implements the text editor's Macros/Find Functions command.
+	It was written by jerome.mutterer at ibmp.fr, and is based on Mark Longair's CommandFinder plugin.
+*/
+public class FunctionFinder implements TextListener,  WindowListener, KeyListener, ItemListener, ActionListener {
+	private static Dialog dialog;
+	private TextField prompt;
+	private List functions;
+	private Button insertButton, infoButton, closeButton;
+	private String [] commands;
+	private Editor editor;
+
+	public FunctionFinder(Editor editor) {
+
+		this.editor = editor;
+
+		String exists = IJ.runMacro("return File.exists(getDirectory('macros')+'functions.html');");
+		if (exists=="0")	{
+			String installLocalMacroFunctionsFile = "functions = File.openUrlAsString('"+IJ.URL+"/developer/macro/functions.html');\n"+
+			"f = File.open(getDirectory('macros')+'functions.html');\n"+
+			"print (f, functions);\n"+
+			"File.close(f);";
+			try { IJ.runMacro(installLocalMacroFunctionsFile);
+			} catch (Throwable e) { IJ.error("Problem downloading functions.html"); return;}
+		}
+		String f = IJ.runMacro("return File.openAsString(getDirectory('macros')+'functions.html');");
+		f = f.replaceAll("&quot;", "\"");
+		String [] l = f.split("\n");
+		commands= new String [l.length];
+		int c=0;
+		for (int i=0; i<l.length; i++) {
+			String line = l[i];
+			if (line.startsWith("<b>")) {
+				commands[c]=line.substring(line.indexOf("<b>")+3,line.indexOf("</b>"));
+				c++;
+			}
+		}
+		if (c==0) {
+			IJ.error("ImageJ/macros/functions.html is corrupted");
+			return;
+		}
+
+		ImageJ imageJ = IJ.getInstance();
+		if (dialog==null) {
+			dialog = new Dialog(imageJ, "Built-in Functions");
+			dialog.setLayout(new BorderLayout());
+			dialog.addWindowListener(this);
+			Panel northPanel = new Panel();
+			prompt = new TextField("", 32);
+			prompt.addTextListener(this);
+			prompt.addKeyListener(this);
+			northPanel.add(prompt);
+			dialog.add(northPanel, BorderLayout.NORTH);
+			functions = new List(12);
+			functions.addKeyListener(this);
+			populateList("");
+			dialog.add(functions, BorderLayout.CENTER);
+			Panel buttonPanel = new Panel();
+			insertButton = new Button("Insert");
+			insertButton.addActionListener(this);
+			buttonPanel.add(insertButton);
+			infoButton = new Button("Info");
+			infoButton.addActionListener(this);
+			buttonPanel.add(infoButton);
+			closeButton = new Button("Close");
+			closeButton.addActionListener(this);
+			buttonPanel.add(closeButton);
+			dialog.add(buttonPanel, BorderLayout.SOUTH);
+			GUI.scale(dialog);
+			dialog.pack();
+		}
+
+		Frame frame = WindowManager.getFrontWindow();
+		if (frame==null) return;
+		java.awt.Point posi=frame.getLocationOnScreen();
+		int initialX = (int)posi.getX() + 38;
+		int initialY = (int)posi.getY() + 84;
+		dialog.setLocation(initialX,initialY);
+		dialog.setVisible(true);
+		dialog.toFront();
+	}
+
+	public FunctionFinder() {
+		this(null);
+	}
+
+	public void populateList(String matchingSubstring) {
+		String substring = matchingSubstring.toLowerCase();
+		functions.removeAll();
+		try {
+			for(int i=0; i<commands.length; ++i) {
+				String commandName = commands[i];
+				if (commandName.length()==0)
+					continue;
+				String lowerCommandName = commandName.toLowerCase();
+				if( lowerCommandName.indexOf(substring) >= 0 ) {
+					functions.add(commands[i]);
+				}
+			}
+		} catch (Exception e){}
+	}
+
+	public void edPaste(String arg) {
+		Frame frame = WindowManager.getFrontWindow();
+		if (!(frame instanceof Editor))
+			return;
+
+		try {
+			TextArea ta = ((Editor)frame).getTextArea();
+			editor = (Editor)frame;
+			int start = ta.getSelectionStart( );
+			int end = ta.getSelectionEnd( );
+			try {
+				ta.replaceRange(arg.substring(0,arg.length()), start, end);
+			} catch (Exception e) { }
+			if (IJ.isMacOSX())
+				ta.setCaretPosition(start+arg.length());
+		} catch (Exception e) { }
+	}
+
+	public void itemStateChanged(ItemEvent ie) {
+		populateList(prompt.getText());
+	}
+
+	protected void runFromLabel(String listLabel) {
+		edPaste(listLabel);
+		closeAndRefocus();
+	}
+
+	public void close() {
+		closeAndRefocus();
+	}
+
+	public void closeAndRefocus() {
+		if (dialog!=null)
+			dialog.dispose();
+		if (editor!=null)
+			editor.toFront();
+	}
+
+	public void keyPressed(KeyEvent ke) {
+		int key = ke.getKeyCode();
+		int items = functions.getItemCount();
+		Object source = ke.getSource();
+		if (source==prompt) {
+			if (key==KeyEvent.VK_ENTER) {
+				if (1==items) {
+					String selected = functions.getItem(0);
+					edPaste(selected);
+				}
+			} else if (key==KeyEvent.VK_UP) {
+				functions.requestFocus();
+				if(items>0)
+					functions.select(functions.getItemCount()-1);
+			} else if (key==KeyEvent.VK_ESCAPE) {
+				closeAndRefocus();
+			} else if (key==KeyEvent.VK_DOWN)  {
+				functions.requestFocus();
+				if (items>0)
+					functions.select(0);
+			}
+		} else if (source==functions) {
+			if (key==KeyEvent.VK_ENTER) {
+				String selected = functions.getSelectedItem();
+				if (selected!=null)
+					edPaste(selected);
+			}
+			else if (key==KeyEvent.VK_ESCAPE) {
+				closeAndRefocus();
+			}
+			else if (key==KeyEvent.VK_BACK_SPACE || key==KeyEvent.VK_DELETE) {
+			/* If someone presses backspace or delete they probably
+			   want to remove the last letter from the search string, so
+			   switch the focus back to the prompt: */
+			prompt.requestFocus();
+		}
+		}
+	}
+
+	public void keyReleased(KeyEvent ke) { }
+
+	public void keyTyped(KeyEvent ke) { }
+
+	public void textValueChanged(TextEvent te) {
+		populateList(prompt.getText());
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		Object b = e.getSource();
+		if (b==insertButton) {
+			int index = functions.getSelectedIndex();
+			if (index>=0) {
+				String selected = functions.getItem(index);
+				edPaste(selected);
+			}
+		} else if (b==infoButton) {
+			String url = IJ.URL+"/developer/macro/functions.html";
+			int index = functions.getSelectedIndex();
+			if (index>=0) {
+				String selected = functions.getItem(index);
+				int index2 = selected.indexOf("(");
+				if (index2==-1)
+					index2 = selected.length();
+				url = url + "#" + selected.substring(0, index2);
+			}
+			IJ.runPlugIn("ij.plugin.BrowserLauncher", url);
+		} else if (b==closeButton)
+		closeAndRefocus();
+	}
+
+	public void windowClosing(WindowEvent e) {
+		closeAndRefocus();
+	}
+
+	public void windowActivated(WindowEvent e) { }
+	public void windowDeactivated(WindowEvent e) { }
+	public void windowClosed(WindowEvent e) { }
+	public void windowOpened(WindowEvent e) { }
+	public void windowIconified(WindowEvent e) { }
+	public void windowDeiconified(WindowEvent e) { }
+}
diff --git a/src/ij/macro/Functions.java b/src/ij/macro/Functions.java
new file mode 100644
index 0000000..2fe055d
--- /dev/null
+++ b/src/ij/macro/Functions.java
@@ -0,0 +1,8233 @@
+package ij.macro;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.*;
+import ij.plugin.filter.*;
+import ij.plugin.frame.*;
+import ij.text.*;
+import ij.io.*;
+import ij.util.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.util.*;
+import java.io.*;
+import java.awt.event.KeyEvent;
+import java.lang.reflect.*;
+import java.net.URL;
+import java.awt.datatransfer.*;
+import java.awt.geom.*;
+
+
+/** This class implements the built-in macro functions. */
+public class Functions implements MacroConstants, Measurements {
+	Interpreter interp;
+	Program pgm;
+	boolean updateNeeded;
+	boolean autoUpdate = true;
+	ImageProcessor defaultIP;
+	ImagePlus defaultImp;
+	int imageType;
+	boolean fontSet;
+	Color globalColor;
+	double globalValue = Double.NaN;
+	int globalLineWidth;
+	Plot plot;
+	static int plotID;
+	int justification = ImageProcessor.LEFT_JUSTIFY;
+	Font font;
+	GenericDialog gd;
+	PrintWriter writer;
+	boolean altKeyDown, shiftKeyDown;
+	boolean antialiasedText;
+	StringBuffer buffer;
+	RoiManager roiManager;
+	Properties props;
+	CurveFitter fitter;
+	boolean showFitDialog;
+	boolean logFitResults;
+	boolean resultsPending;
+	Overlay offscreenOverlay;
+	Overlay overlayClipboard;
+	Roi roiClipboard;
+	GeneralPath overlayPath;
+	boolean overlayDrawLabels;
+	ResultsTable currentTable;
+	ResultsTable unUpdatedTable;
+
+	// save/restore settings
+	boolean saveSettingsCalled;
+	boolean usePointerCursor, hideProcessStackDialog;
+	float divideByZeroValue;
+	int jpegQuality;
+	int saveLineWidth;
+	boolean doScaling;
+	boolean weightedColor;
+	double[] weights;
+	boolean interpolateScaledImages, open100Percent, blackCanvas;
+	boolean useJFileChooser,debugMode;
+	Color foregroundColor, backgroundColor, roiColor;
+	boolean pointAutoMeasure, requireControlKey, useInvertingLut;
+	boolean disablePopup;
+	int measurements;
+	int decimalPlaces;
+	boolean blackBackground;
+	boolean autoContrast;
+	static WaitForUserDialog waitForUserDialog;
+	int pasteMode;
+	boolean expandableArrays = true;
+	int plotWidth;
+	int plotHeight;
+	int plotFontSize;
+	boolean plotInterpolate;
+	boolean plotNoGridLines;
+	boolean plotNoTicks;
+	boolean profileVerticalProfile;
+	boolean profileSubPixelResolution;
+	boolean waitForCompletion = true;
+
+
+	Functions(Interpreter interp, Program pgm) {
+		this.interp = interp;
+		this.pgm = pgm;
+	}
+
+	void doFunction(int type) {
+		switch (type) {
+			case RUN: doRun(); break;
+			case SELECT: selectWindow(); break;
+			case WAIT: IJ.wait((int)getArg()); break;
+			case BEEP: interp.getParens(); IJ.beep(); break;
+			case RESET_MIN_MAX: interp.getParens(); IJ.resetMinAndMax(); resetImage(); break;
+			case RESET_THRESHOLD: interp.getParens(); IJ.resetThreshold(); resetImage(); break;
+			case PRINT: case WRITE: print(); break;
+			case DO_WAND: doWand(); break;
+			case SET_MIN_MAX: setMinAndMax(); break;
+			case SET_THRESHOLD: setThreshold(); break;
+			case SET_TOOL: setTool(); break;
+			case SET_FOREGROUND: setForegroundColor(); break;
+			case SET_BACKGROUND: setBackgroundColor(); break;
+			case SET_COLOR: setColor(); break;
+			case MAKE_LINE: makeLine(); break;
+			case MAKE_ARROW: makeArrow(); break;
+			case MAKE_OVAL: makeOval(); break;
+			case MAKE_RECTANGLE: makeRectangle(); break;
+			case MAKE_ROTATED_RECT: makeRotatedRectangle(); break;
+			case DUMP: interp.dump(); break;
+			case LINE_TO: lineTo(); break;
+			case MOVE_TO: moveTo(); break;
+			case DRAW_LINE: drawLine(); break;
+			case REQUIRES: requires(); break;
+			case AUTO_UPDATE: autoUpdate = getBooleanArg(); break;
+			case UPDATE_DISPLAY: interp.getParens(); updateDisplay(); break;
+			case DRAW_STRING: drawString(); break;
+			case SET_PASTE_MODE: IJ.setPasteMode(getStringArg()); break;
+			case DO_COMMAND: doCommand(); break;
+			case SHOW_STATUS: showStatus(); break;
+			case SHOW_PROGRESS: showProgress(); break;
+			case SHOW_MESSAGE: showMessage(false); break;
+			case SHOW_MESSAGE_WITH_CANCEL: showMessage(true); break;
+			case SET_PIXEL: case PUT_PIXEL: setPixel(); break;
+			case SNAPSHOT: case RESET: case FILL: doIPMethod(type); break;
+			case SET_LINE_WIDTH: setLineWidth((int)getArg()); break;
+			case CHANGE_VALUES: changeValues(); break;
+			case SELECT_IMAGE: selectImage(); break;
+			case EXIT: exit(); break;
+			case SET_LOCATION: setLocation(); break;
+			case GET_CURSOR_LOC: getCursorLoc(); break;
+			case GET_LINE: getLine(); break;
+			case GET_VOXEL_SIZE: getVoxelSize(); break;
+			case GET_HISTOGRAM: getHistogram(); break;
+			case GET_BOUNDING_RECT: case GET_BOUNDS: getBounds(true); break;
+			case GET_LUT: getLut(); break;
+			case SET_LUT: setLut(); break;
+			case GET_COORDINATES: getCoordinates(); break;
+			case MAKE_SELECTION: makeSelection(); break;
+			case SET_RESULT: setResult(null); break;
+			case UPDATE_RESULTS: updateResults(); break;
+			case SET_BATCH_MODE: setBatchMode(); break;
+			case SET_JUSTIFICATION: setJustification(); break;
+			case SET_Z_COORDINATE: setZCoordinate(); break;
+			case GET_THRESHOLD: getThreshold(); break;
+			case GET_PIXEL_SIZE: getPixelSize(); break;
+			case SETUP_UNDO: interp.getParens(); Undo.setup(Undo.MACRO, getImage()); break;
+			case SAVE_SETTINGS: saveSettings(); break;
+			case RESTORE_SETTINGS: restoreSettings(); break;
+			case SET_KEY_DOWN: setKeyDown(); break;
+			case OPEN: open(); break;
+			case SET_FONT: setFont(); break;
+			case GET_MIN_AND_MAX: getMinAndMax(); break;
+			case CLOSE: close(); break;
+			case SET_SLICE: setSlice(); break;
+			case NEW_IMAGE: newImage(); break;
+			case SAVE: IJ.save(getStringArg()); break;
+			case SAVE_AS: saveAs(); break;
+			case SET_AUTO_THRESHOLD: setAutoThreshold(); break;
+			case RENAME: getImage().setTitle(getStringArg()); break;
+			case GET_STATISTICS: getStatistics(true); break;
+			case GET_RAW_STATISTICS: getStatistics(false); break;
+			case FLOOD_FILL: floodFill(); break;
+			case RESTORE_PREVIOUS_TOOL: restorePreviousTool(); break;
+			case SET_VOXEL_SIZE: setVoxelSize(); break;
+			case GET_LOCATION_AND_SIZE: getLocationAndSize(); break;
+			case GET_DATE_AND_TIME: getDateAndTime(); break;
+			case SET_METADATA: setMetadata(); break;
+			case CALCULATOR: imageCalculator(); break;
+			case SET_RGB_WEIGHTS: setRGBWeights(); break;
+			case MAKE_POLYGON: makePolygon(); break;
+			case SET_SELECTION_NAME: setSelectionName(); break;
+			case DRAW_RECT: case FILL_RECT: case DRAW_OVAL: case FILL_OVAL: drawOrFill(type); break;
+			case SET_OPTION: setOption(); break;
+			case SHOW_TEXT: showText(); break;
+			case SET_SELECTION_LOC: setSelectionLocation(); break;
+			case GET_DIMENSIONS: getDimensions(); break;
+			case WAIT_FOR_USER: waitForUser(); break;
+			case MAKE_POINT: makePoint(); break;
+			case MAKE_TEXT: makeText(); break;
+			case MAKE_ELLIPSE: makeEllipse(); break;
+			case GET_DISPLAYED_AREA: getDisplayedArea(); break;
+			case TO_SCALED: toScaled(); break;
+			case TO_UNSCALED: toUnscaled(); break;
+		}
+	}
+
+	final double getFunctionValue(int type) {
+		double value = 0.0;
+		switch (type) {
+			case GET_PIXEL: value = getPixel(); break;
+			case ABS: case COS: case EXP: case FLOOR: case LOG: case ROUND:
+			case SIN: case SQRT: case TAN: case ATAN: case ASIN: case ACOS:
+				value = math(type);
+				break;
+			case MATH: value = doMath(); break;
+			case MAX_OF: case MIN_OF: case POW: case ATAN2: value=math2(type); break;
+			case GET_TIME: interp.getParens(); value=System.currentTimeMillis(); break;
+			case GET_WIDTH: interp.getParens(); value=getImage().getWidth(); break;
+			case GET_HEIGHT: interp.getParens(); value=getImage().getHeight(); break;
+			case RANDOM: value=random(); break;
+			case GET_COUNT: case NRESULTS: value=getResultsCount(); break;
+			case GET_RESULT: value=getResult(null); break;
+			case GET_NUMBER: value=getNumber(); break;
+			case NIMAGES: value=getImageCount(); break;
+			case NSLICES: value=getStackSize(); break;
+			case LENGTH_OF: value=lengthOf(); break;
+			case GET_ID: interp.getParens(); value=getImage().getID(); break;
+			case BIT_DEPTH: interp.getParens(); value = getImage().getBitDepth(); break;
+			case SELECTION_TYPE: value=getSelectionType(); break;
+			case IS_OPEN: value=isOpen(); break;
+			case IS_ACTIVE: value=isActive(); break;
+			case INDEX_OF: value=indexOf(null); break;
+			case LAST_INDEX_OF: value=getFirstString().lastIndexOf(getLastString()); break;
+			case CHAR_CODE_AT: value=charCodeAt(); break;
+			case GET_BOOLEAN: value=getBoolean(); break;
+			case STARTS_WITH: case ENDS_WITH: value = startsWithEndsWith(type); break;
+			case IS_NAN: value = Double.isNaN(getArg())?1:0; break;
+			case GET_ZOOM: value = getZoom(); break;
+			case PARSE_FLOAT: value = parseDouble(getStringArg()); break;
+			case PARSE_INT: value = parseInt(); break;
+			case IS_KEY_DOWN: value = isKeyDown(); break;
+			case GET_SLICE_NUMBER: interp.getParens(); value=getImage().getCurrentSlice(); break;
+			case SCREEN_WIDTH: case SCREEN_HEIGHT: value = getScreenDimension(type); break;
+			case CALIBRATE: value = getImage().getCalibration().getCValue(getArg()); break;
+			case ROI_MANAGER: value = roiManager(); break;
+			case TOOL_ID: interp.getParens(); value = Toolbar.getToolId(); break;
+			case IS: value = is(); break;
+			case GET_VALUE: value = getValue(); break;
+			case STACK: value = doStack(); break;
+			case MATCHES: value = matches(null); break;
+			case GET_STRING_WIDTH: value = getStringWidth(); break;
+			case FIT: value = fit(); break;
+			case OVERLAY: value = overlay(); break;
+			case SELECTION_CONTAINS: value = selectionContains(); break;
+			case PLOT: value = doPlot(); break;
+			default:
+				interp.error("Numeric function expected");
+		}
+		return value;
+	}
+
+	String getStringFunction(int type) {
+		String str;
+		switch (type) {
+			case D2S: str = d2s(); break;
+			case TO_HEX: str = toString(16); break;
+			case TO_BINARY: str = toString(2); break;
+			case GET_TITLE: interp.getParens(); str=getImage().getTitle(); break;
+			case GET_STRING: str = getStringDialog(); break;
+			case SUBSTRING: str=substring(null); break;
+			case FROM_CHAR_CODE: str = fromCharCode(); break;
+			case GET_INFO: str = getInfo(); break;
+			case GET_IMAGE_INFO: interp.getParens(); str = getImageInfo(); break;
+			case GET_DIRECTORY: case GET_DIR: str = getDirectory(); break;
+			case GET_ARGUMENT: interp.getParens(); str=interp.argument!=null?interp.argument:""; break;
+			case TO_LOWER_CASE: str = getStringArg().toLowerCase(Locale.US); break;
+			case TO_UPPER_CASE: str = getStringArg().toUpperCase(Locale.US); break;
+			case RUN_MACRO: str = runMacro(false); break;
+			case EVAL: str = runMacro(true); break;
+			case TO_STRING: str = doToString(); break;
+			case REPLACE: str = replace(null); break;
+			case DIALOG: str = doDialog(); break;
+			case GET_METADATA: str = getMetadata(); break;
+			case FILE: str = doFile(); break;
+			case SELECTION_NAME: str = selectionName(); break;
+			case GET_VERSION: interp.getParens();  str = IJ.getVersion(); break;
+			case GET_RESULT_LABEL: str = getResultLabel(); break;
+			case CALL: str = call(); break;
+			case STRING: str = doString(); break;
+			case EXT: str = doExt(); break;
+			case EXEC: str = exec(); break;
+			case LIST: str = doList(); break;
+			case DEBUG: str = debug(); break;
+			case IJ_CALL: str = doIJ(); break;
+			case GET_RESULT_STRING: str = getResultString(null); break;
+			case TRIM: str = trim(); break;
+			default:
+				str="";
+				interp.error("String function expected");
+		}
+		return str;
+	}
+
+	Variable[] getArrayFunction(int type) {
+		Variable[] array;
+		switch (type) {
+			case GET_PROFILE: array=getProfile(); break;
+			case NEW_ARRAY: array = newArray(); break;
+			case SPLIT: array = split(); break;
+			case GET_FILE_LIST: array = getFileList(); break;
+			case GET_FONT_LIST: array = getFontList(); break;
+			case NEW_MENU: array = newMenu(); break;
+			case GET_LIST: array = getList(); break;
+			case ARRAY_FUNC: array = doArray(); break;
+			default:
+				array = null;
+				interp.error("Array function expected");
+		}
+		return array;
+	}
+
+	// Functions returning a string must be added
+	// to isStringFunction(String,int).
+	Variable getVariableFunction(int type) {
+		Variable var = null;
+		switch (type) {
+			case TABLE: var = doTable(); break;
+			case ROI: var = doRoi(); break;
+			case ROI_MANAGER2: var = doRoiManager(); break;
+			case PROPERTY: var = doProperty(); break;
+			case IMAGE: var = doImage(); break;
+			case COLOR: var = doColor(); break;
+			default:
+				interp.error("Variable function expected");
+		}
+		if (var==null)
+			var = new Variable(Double.NaN);
+		return var;
+	}
+
+	private void setLineWidth(int width) {
+		if (WindowManager.getCurrentImage()!=null) {
+			if (overlayPath!=null && width!=globalLineWidth)
+				addDrawingToOverlay(getImage());
+			getProcessor().setLineWidth(width);
+		}
+		globalLineWidth = width;
+	}
+
+	private double doMath() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==NUMERIC_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("min"))
+			return Math.min(getFirstArg(), getLastArg());
+		else if (name.equals("max"))
+			return Math.max(getFirstArg(), getLastArg());
+		else if (name.equals("pow"))
+			return Math.pow(getFirstArg(), getLastArg());
+		else if (name.equals("atan2"))
+			return Math.atan2(getFirstArg(), getLastArg());
+		else if (name.equals("constrain"))
+			return Math.min(Math.max(getFirstArg(), getNextArg()), getLastArg());
+		else if (name.equals("map")) {
+			double value = getFirstArg();
+			double fromLow = getNextArg();
+			double fromHigh = getNextArg();
+			double toLow = getNextArg();
+			double toHigh = getLastArg();
+			return (value-fromLow)*(toHigh-toLow)/(fromHigh-fromLow)+toLow;
+		}
+		double arg = getArg();
+		if (name.equals("ceil"))
+			return Math.ceil(arg);
+		else if (name.equals("abs"))
+			return Math.abs(arg);
+		else if (name.equals("cos"))
+			return Math.cos(arg);
+		else if (name.equals("exp"))
+			return Math.exp(arg);
+		else if (name.equals("floor"))
+			return Math.floor(arg);
+		else if (name.equals("log"))
+			return Math.log(arg);
+		else if (name.equals("log10"))
+			return Math.log10(arg);
+		else if (name.equals("round"))
+			return Math.round(arg);
+		else if (name.equals("sin"))
+			return Math.sin(arg);
+		else if (name.equals("sqr"))
+			return arg*arg;
+		else if (name.equals("sqrt"))
+			return Math.sqrt(arg);
+		else if (name.equals("tan"))
+			return Math.tan(arg);
+		else if (name.equals("atan"))
+			return Math.atan(arg);
+		else if (name.equals("asin"))
+			return Math.asin(arg);
+		else if (name.equals("acos"))
+			return Math.acos(arg);
+		else if (name.equals("erf"))
+			return IJMath.erf(arg);
+		else if (name.equals("toRadians"))
+			return Math.toRadians(arg);
+		else if (name.equals("toDegrees"))
+			return Math.toDegrees(arg);
+		else
+			interp.error("Unrecognized function name");
+		return Double.NaN;
+	}
+
+	final double math(int type) {
+		double arg = getArg();
+		switch (type) {
+			case ABS: return Math.abs(arg);
+			case COS: return Math.cos(arg);
+			case EXP: return Math.exp(arg);
+			case FLOOR: return Math.floor(arg);
+			case LOG: return Math.log(arg);
+			case ROUND: return Math.floor(arg + 0.5);
+			case SIN: return Math.sin(arg);
+			case SQRT: return Math.sqrt(arg);
+			case TAN: return Math.tan(arg);
+			case ATAN: return Math.atan(arg);
+			case ASIN: return Math.asin(arg);
+			case ACOS: return Math.acos(arg);
+			default: return 0.0;
+		}
+	}
+
+	final double math2(int type) {
+		double a1 = getFirstArg();
+		double a2 = getLastArg();
+		switch (type) {
+			case MIN_OF: return Math.min(a1, a2);
+			case MAX_OF: return Math.max(a1, a2);
+			case POW: return Math.pow(a1, a2);
+			case ATAN2: return Math.atan2(a1, a2);
+			default: return 0.0;
+		}
+	}
+
+	final String getString() {
+		String str = interp.getStringTerm();
+		while (true) {
+			interp.getToken();
+			if (interp.token=='+')
+				str += interp.getStringTerm();
+			else {
+				interp.putTokenBack();
+				break;
+			}
+		};
+		return str;
+	}
+
+	final boolean isStringFunction() {
+		Symbol symbol = pgm.table[interp.tokenAddress];
+		return symbol.type==D2S;
+	}
+
+	final double getArg() {
+		interp.getLeftParen();
+		double arg = interp.getExpression();
+		interp.getRightParen();
+		return arg;
+	}
+
+	final double getFirstArg() {
+		interp.getLeftParen();
+		return interp.getExpression();
+	}
+
+	final double getNextArg() {
+		interp.getComma();
+		return interp.getExpression();
+	}
+
+	final double getLastArg() {
+		interp.getComma();
+		double arg = interp.getExpression();
+		interp.getRightParen();
+		return arg;
+	}
+
+	String getStringArg() {
+		interp.getLeftParen();
+		String arg = getString();
+		interp.getRightParen();
+		return arg;
+	}
+
+	final String getFirstString() {
+		interp.getLeftParen();
+		return getString();
+	}
+
+	final String getNextString() {
+		interp.getComma();
+		return getString();
+	}
+
+	final String getLastString() {
+		interp.getComma();
+		String arg = getString();
+		interp.getRightParen();
+		return arg;
+	}
+
+	boolean getBooleanArg() {
+		interp.getLeftParen();
+		double arg = interp.getBooleanExpression();
+		interp.checkBoolean(arg);
+		interp.getRightParen();
+		return arg==0?false:true;
+	}
+
+	final Variable getVariableArg() {
+		interp.getLeftParen();
+		Variable v = getVariable();
+		interp.getRightParen();
+		return v;
+	}
+
+	final Variable getFirstVariable() {
+		interp.getLeftParen();
+		return getVariable();
+	}
+
+	final Variable getNextVariable() {
+		interp.getComma();
+		return getVariable();
+	}
+
+	final Variable getLastVariable() {
+		interp.getComma();
+		Variable v = getVariable();
+		interp.getRightParen();
+		return v;
+	}
+
+	final Variable getVariable() {
+		interp.getToken();
+		if (interp.token!=WORD)
+			interp.error("Variable expected");
+		Variable v = interp.lookupLocalVariable(interp.tokenAddress);
+		if (v==null)
+				v = interp.push(interp.tokenAddress, 0.0, null, interp);
+		Variable[] array = v.getArray();
+		if (array!=null) {
+			int index = interp.getIndex();
+			checkIndex(index, 0, v.getArraySize()-1);
+			v = array[index];
+		}
+		return v;
+	}
+
+	final Variable getFirstArrayVariable() {
+		interp.getLeftParen();
+		return getArrayVariable();
+	}
+
+	final Variable getNextArrayVariable() {
+		interp.getComma();
+		return getArrayVariable();
+	}
+
+	final Variable getLastArrayVariable() {
+		interp.getComma();
+		Variable v = getArrayVariable();
+		interp.getRightParen();
+		return v;
+	}
+
+	final Variable getArrayVariable() {
+		interp.getToken();
+		if (interp.token!=WORD)
+			interp.error("Variable expected");
+		Variable v = interp.lookupLocalVariable(interp.tokenAddress);
+		if (v==null)
+				v = interp.push(interp.tokenAddress, 0.0, null, interp);
+		return v;
+	}
+
+	final double[] getFirstArray() {
+		interp.getLeftParen();
+		return getNumericArray();
+	}
+
+	final double[] getNextArray() {
+		interp.getComma();
+		return getNumericArray();
+	}
+
+	final double[] getLastArray() {
+		interp.getComma();
+		double[] a = getNumericArray();
+		interp.getRightParen();
+		return a;
+	}
+
+	double[] getNumericArray() {
+		Variable[] a1 = getArray();
+		double[] a2 = new double[a1.length];
+		for (int i=0; i<a1.length; i++)
+			a2[i] = a1[i].getValue();
+		return a2;
+	}
+
+	String[] getStringArray() {
+		Variable[] a1 = getArray();
+		String[] a2 = new String[a1.length];
+		for (int i=0; i<a1.length; i++) {
+			String s = a1[i].getString();
+			if (s==null) s = "" + a1[i].getValue();
+			a2[i] = s;
+		}
+		return a2;
+	}
+
+	Variable[] getArray() {
+		interp.getToken();
+		if (interp.token==VARIABLE_FUNCTION && pgm.table[interp.tokenAddress].type==TABLE) {
+			Variable v = getVariableFunction(TABLE);
+			if (v!=null) {
+				Variable[] a = v.getArray();
+				if (a!=null) return a;
+			}
+		}
+		boolean newArray = interp.token==ARRAY_FUNCTION && pgm.table[interp.tokenAddress].type==NEW_ARRAY;
+		boolean arrayFunction = interp.token==ARRAY_FUNCTION && pgm.table[interp.tokenAddress].type==ARRAY_FUNC;
+		if (!(interp.token==WORD||newArray||arrayFunction))
+			interp.error("Array expected");
+		Variable[] a = null;
+		if (newArray)
+			a = getArrayFunction(NEW_ARRAY);
+		else if (arrayFunction)
+			a = getArrayFunction(ARRAY_FUNC);
+		else {
+			Variable v = interp.lookupVariable();
+			a= v.getArray();
+			int size = v.getArraySize();
+			if (a!=null && a.length!=size) {
+				Variable[] a2 = new Variable[size];
+				for (int i=0; i<size; i++)
+					a2[i] = a[i];
+				v.setArray(a2);
+				a = v.getArray();
+			}
+		}
+		if (a==null)
+			interp.error("Array expected");
+		return a;
+	}
+
+	private Color getColor() {
+		String color = getString();
+		color = color.toLowerCase(Locale.US);
+		if (color.equals("black"))
+			return Color.black;
+		else if (color.equals("white"))
+			return Color.white;
+		else if (color.equals("red"))
+			return Color.red;
+		else if (color.equals("green"))
+			return Color.green;
+		else if (color.equals("blue"))
+			return Color.blue;
+		else if (color.equals("cyan"))
+			return Color.cyan;
+		else if (color.equals("darkgray"))
+			return Color.darkGray;
+		else if (color.equals("gray"))
+			return Color.gray;
+		else if (color.equals("lightgray"))
+			return Color.lightGray;
+		else if (color.equals("magenta"))
+			return Color.magenta;
+		else if (color.equals("orange"))
+			return Color.orange;
+		else if (color.equals("yellow"))
+			return Color.yellow;
+		else if (color.equals("pink"))
+			return Color.pink;
+		else if (color.startsWith("#"))
+			return Colors.decode(color, Color.black);
+		else
+			interp.error("'red', 'green', or '#0000ff' etc. expected");
+		return null;
+	}
+
+	void checkIndex(int index, int lower, int upper) {
+		if (index<lower || index>upper)
+			interp.error("Index ("+index+") is outside of the "+lower+"-"+upper+" range");
+	}
+
+	void doRun() {
+		interp.getLeftParen();
+		String arg1 = getString();
+		interp.getToken();
+		if (!(interp.token==')' || interp.token==','))
+			interp.error("',' or ')'  expected");
+		String arg2 = null;
+		if (interp.token==',') {
+			arg2 = getString();
+			interp.getRightParen();
+		}
+		IJ.run(this.interp, arg1, arg2);
+		resetImage();
+		IJ.setKeyUp(IJ.ALL_KEYS);
+		shiftKeyDown = altKeyDown = false;
+	}
+
+	private void selectWindow() {
+		String title = getStringArg();
+		if (resultsPending && "Results".equals(title)) {
+			ResultsTable rt = ResultsTable.getResultsTable();
+			if (rt!=null && rt.size()>0)
+				rt.show("Results");
+		}
+		IJ.selectWindow(title);
+		resetImage();
+		interp.selectCount++;
+	}
+
+	void setForegroundColor() {
+		boolean isImage = WindowManager.getCurrentImage()!=null;
+		int lnWidth = 0;
+		if (isImage)
+			lnWidth = getProcessor().getLineWidth();
+		int red=0, green=0, blue=0;
+		int arg1 = (int)getFirstArg();
+		if (interp.nextToken()==')') {
+			interp.getRightParen();
+			red = (arg1&0xff0000)>>16;
+			green = (arg1&0xff00)>>8;
+			blue = arg1&0xff;
+		} else {
+			red = arg1;
+			green = (int)getNextArg();
+			blue = (int)getLastArg();
+		}
+		IJ.setForegroundColor(red, green, blue);
+		resetImage();
+		if (isImage)
+			setLineWidth(lnWidth);
+		globalColor = null;
+		globalValue = Double.NaN;
+	}
+
+	void setBackgroundColor() {
+		int red=0, green=0, blue=0;
+		int arg1 = (int)getFirstArg();
+		if (interp.nextToken()==')') {
+			interp.getRightParen();
+			red = (arg1&0xff0000)>>16;
+			green = (arg1&0xff00)>>8;
+			blue = arg1&0xff;
+		} else {
+			red = arg1;
+			green = (int)getNextArg();
+			blue = (int)getLastArg();
+		}
+		IJ.setBackgroundColor(red, green, blue);
+		resetImage();
+	}
+
+	void setColor() {
+		interp.getLeftParen();
+		if (isStringArg()) {
+			globalColor = getColor();
+			globalValue = Double.NaN;
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) {
+				if (overlayPath!=null)
+					addDrawingToOverlay(imp);
+				getProcessor().setColor(globalColor);
+			}
+			interp.getRightParen();
+			return;
+		}
+		double arg1 = interp.getExpression();
+		if (interp.nextToken()==')') {
+			interp.getRightParen();
+			setColor(arg1);
+			return;
+		}
+		int red=(int)arg1, green=(int)getNextArg(), blue=(int)getLastArg();
+		if (red<0) red=0; if (green<0) green=0; if (blue<0) blue=0;
+		if (red>255) red=255; if (green>255) green=255; if (blue>255) blue=255;
+		globalColor = new Color(red, green, blue);
+		globalValue = Double.NaN;
+		if (WindowManager.getCurrentImage()!=null)
+			getProcessor().setColor(globalColor);
+	}
+
+	void setColor(double value) {
+		ImageProcessor ip = getProcessor();
+		ImagePlus imp = getImage();
+		switch (imp.getBitDepth()) {
+			case 8:
+				if (value<0 || value>255)
+					interp.error("Argument out of 8-bit range (0-255)");
+				ip.setValue(value);
+				break;
+			case 16:
+				if (imp.getLocalCalibration().isSigned16Bit())
+					value += 32768;
+				if (value<0 || value>65535)
+					interp.error("Argument out of 16-bit range (0-65535)");
+				ip.setValue(value);
+				break;
+			default:
+				ip.setValue(value);
+				break;
+		}
+		globalValue = value;
+		globalColor = null;
+	}
+
+	void makeLine() {
+		double x1d = getFirstArg();
+		double y1d = getNextArg();
+		double x2d = getNextArg();
+		interp.getComma();
+		double y2d = interp.getExpression();
+		interp.getToken();
+		if (interp.token==')')
+			IJ.makeLine(x1d, y1d, x2d, y2d);
+		else {
+			Polygon points = new Polygon();
+			points.addPoint((int)Math.round(x1d),(int)Math.round(y1d));
+			points.addPoint((int)Math.round(x2d),(int)Math.round(y2d));
+			while (interp.token==',') {
+				int x = (int)Math.round(interp.getExpression());
+				if (points.npoints==2 && interp.nextToken()==')') {
+					interp.getRightParen();
+					Roi line = new Line(x1d, y1d, x2d, y2d);
+					line.updateWideLine((float)x);
+					getImage().setRoi(line);
+					return;
+				}
+				interp.getComma();
+				int y = (int)Math.round(interp.getExpression());
+				points.addPoint(x,y);
+				interp.getToken();
+			}
+			getImage().setRoi(new PolygonRoi(points, Roi.POLYLINE));
+		}
+		resetImage();
+	}
+
+	void makeArrow() {
+		String options = "";
+		double x1 = getFirstArg();
+		double y1 = getNextArg();
+		double x2 = getNextArg();
+		double y2 = getNextArg();
+		if (interp.nextToken()==',')
+			options = getNextString();
+		interp.getRightParen();
+		Arrow arrow = new Arrow(x1, y1, x2, y2);
+		arrow.setStyle(options);
+		getImage().setRoi(arrow);
+	}
+
+	void makeOval() {
+		Roi previousRoi = getImage().getRoi();
+		if (shiftKeyDown||altKeyDown) getImage().saveRoi();
+		IJ.makeOval(getFirstArg(), getNextArg(), getNextArg(), getLastArg());
+		Roi roi = getImage().getRoi();
+		if (previousRoi!=null && roi!=null)
+			updateRoi(roi);
+		resetImage();
+		shiftKeyDown = altKeyDown = false;
+		IJ.setKeyUp(IJ.ALL_KEYS);
+	}
+
+	void makeRectangle() {
+		Roi previousRoi = getImage().getRoi();
+		if (shiftKeyDown||altKeyDown) getImage().saveRoi();
+		double x = getFirstArg();
+		double y = getNextArg();
+		double w = getNextArg();
+		double h = getNextArg();
+		int arcSize = 0;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			arcSize = (int)interp.getExpression();
+		}
+		interp.getRightParen();
+		if (arcSize<1)
+			IJ.makeRectangle(x, y, w, h);
+		else {
+			ImagePlus imp = getImage();
+			imp.setRoi(new Roi(x,y,w,h,arcSize));
+		}
+		Roi roi = getImage().getRoi();
+		if (previousRoi!=null && roi!=null)
+			updateRoi(roi);
+		resetImage();
+		shiftKeyDown = altKeyDown = false;
+		IJ.setKeyUp(IJ.ALL_KEYS);
+	}
+
+	void makeRotatedRectangle() {
+		getImage().setRoi(new RotatedRectRoi(getFirstArg(), getNextArg(), getNextArg(), getNextArg(), getLastArg()));
+		resetImage();
+	}
+
+	ImagePlus getImage() {
+		ImagePlus imp = IJ.getImage(interp);
+		if (imp.getWindow()==null && IJ.getInstance()!=null && !interp.isBatchMode() && WindowManager.getTempCurrentImage()==null)
+			throw new RuntimeException(Macro.MACRO_CANCELED);
+		defaultIP = null;
+		defaultImp = imp;
+		return imp;
+	}
+
+	void resetImage() {
+		defaultImp = null;
+		defaultIP = null;
+		fontSet = false;
+	}
+
+	ImageProcessor getProcessor() {
+		if (defaultIP==null) {
+			defaultIP = getImage().getProcessor();
+			if (globalLineWidth>0)
+				defaultIP.setLineWidth(globalLineWidth);
+			if (globalColor!=null)
+				defaultIP.setColor(globalColor);
+			else if (!Double.isNaN(globalValue))
+				defaultIP.setValue(globalValue);
+			else
+				defaultIP.setColor(Toolbar.getForegroundColor());
+		}
+		return defaultIP;
+	}
+
+	int getType() {
+		imageType = getImage().getType();
+		return imageType;
+	}
+
+	void setPixel() {
+		interp.getLeftParen();
+		int a1 = (int)interp.getExpression();
+		interp.getComma();
+		double a2 = interp.getExpression();
+		interp.getToken();
+		ImageProcessor ip = getProcessor();
+		if (interp.token==',') {
+			double a3 = interp.getExpression();
+			interp.getRightParen();
+			if (ip instanceof FloatProcessor)
+				ip.putPixelValue(a1, (int)a2, a3);
+			else
+				ip.putPixel(a1, (int)a2, (int)a3);
+		} else {
+			if (interp.token!=')') interp.error("')' expected");
+			if (ip instanceof ColorProcessor)
+				ip.set(a1, (int)a2);
+			else
+				ip.setf(a1, (float)a2);
+		}
+		updateNeeded = true;
+	}
+
+	double getPixel() {
+		interp.getLeftParen();
+		double a1 = interp.getExpression();
+		ImageProcessor ip = getProcessor();
+		double value = 0.0;
+		interp.getToken();
+		if (interp.token==',') {
+			double a2 = interp.getExpression();
+			interp.getRightParen();
+			int ia1 = (int)a1;
+			int ia2 = (int)a2;
+			if (a1==ia1 && a2==ia2) {
+				if (ip instanceof FloatProcessor)
+					value = ip.getPixelValue(ia1, ia2);
+				else
+					value = ip.getPixel(ia1, ia2);
+			} else {
+				if (ip instanceof ColorProcessor)
+					value = ip.getPixelInterpolated(a1, a2);
+				else {
+					ImagePlus imp = getImage();
+					Calibration cal = imp.getCalibration();
+					imp.setCalibration(null);
+					ip = imp.getProcessor();
+					value = ip.getInterpolatedValue(a1, a2);
+					imp.setCalibration(cal);
+				}
+			}
+		} else {
+			if (interp.token!=')') interp.error("')' expected");
+			if (ip instanceof ColorProcessor)
+				value = ip.get((int)a1);
+			else
+				value = ip.getf((int)a1);
+		}
+		return value;
+	}
+
+	void setZCoordinate() {
+		int z = (int)getArg();
+		int n = z + 1;
+		ImagePlus imp = getImage();
+		ImageStack stack = imp.getStack();
+		int size = stack.size();
+		if (z<0 || z>=size)
+			interp.error("Z coordinate ("+z+") is out of 0-"+(size-1)+ " range");
+		this.defaultIP = stack.getProcessor(n);
+	}
+
+	void moveTo() {
+		interp.getLeftParen();
+		int a1 = (int)Math.round(interp.getExpression());
+		interp.getComma();
+		int a2 = (int)Math.round(interp.getExpression());
+		interp.getRightParen();
+		getProcessor().moveTo(a1, a2);
+	}
+
+	void lineTo() {
+		interp.getLeftParen();
+		int a1 = (int)Math.round(interp.getExpression());
+		interp.getComma();
+		int a2 = (int)Math.round(interp.getExpression());
+		interp.getRightParen();
+		ImageProcessor ip = getProcessor();
+		ip.lineTo(a1, a2);
+		updateAndDraw();
+	}
+
+	void drawLine() {
+		interp.getLeftParen();
+		int x1 = (int)Math.round(interp.getExpression());
+		interp.getComma();
+		int y1 = (int)Math.round(interp.getExpression());
+		interp.getComma();
+		int x2 = (int)Math.round(interp.getExpression());
+		interp.getComma();
+		int y2 = (int)Math.round(interp.getExpression());
+		interp.getRightParen();
+		ImageProcessor ip = getProcessor();
+		ip.drawLine(x1, y1, x2, y2);
+		updateAndDraw();
+	}
+
+	void doIPMethod(int type) {
+		interp.getParens();
+		ImageProcessor ip = getProcessor();
+		switch (type) {
+			case SNAPSHOT: ip.snapshot(); break;
+			case RESET:
+				ip.reset();
+				updateNeeded = true;
+				break;
+			case FILL:
+				ImagePlus imp = getImage();
+				Roi roi = imp.getRoi();
+				if (roi==null) {
+					ip.resetRoi();
+					ip.fill();
+				} else {
+					ip.setRoi(roi);
+					ip.fill(ip.getMask());
+				}
+				imp.updateAndDraw();
+				break;
+		}
+	}
+
+	void updateAndDraw() {
+		if (autoUpdate) {
+			ImagePlus imp = defaultImp;
+			if (imp==null)
+				imp = getImage();
+			imp.updateChannelAndDraw();
+			imp.changes = true;
+		} else
+			updateNeeded = true;
+	}
+
+	void updateDisplay() {
+		if (updateNeeded && WindowManager.getImageCount()>0) {
+			ImagePlus imp = getImage();
+			imp.updateAndDraw();
+			updateNeeded = false;
+		}
+	}
+
+	void drawString() {
+		interp.getLeftParen();
+		String str = getString();
+		interp.getComma();
+		int x = (int)(interp.getExpression()+0.5);
+		interp.getComma();
+		int y = (int)(interp.getExpression()+0.5);
+		Color background = null;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			background = getColor();
+		}
+		interp.getRightParen();
+		ImageProcessor ip = getProcessor();
+		setFont(ip);
+		ip.setJustification(justification);
+		ip.setAntialiasedText(antialiasedText);
+		if (background!=null)
+			ip.drawString(str, x, y, background);
+		else
+			ip.drawString(str, x, y);
+		updateAndDraw();
+	}
+
+	void setFont(ImageProcessor ip) {
+		if (font!=null && !fontSet)
+			ip.setFont(font);
+		fontSet = true;
+	}
+
+	void setJustification() {
+		String str = getStringArg().toLowerCase(Locale.US);
+		int just = ImageProcessor.LEFT_JUSTIFY;
+		if (str.equals("center"))
+			just = ImageProcessor.CENTER_JUSTIFY;
+		else if (str.equals("right"))
+			just = ImageProcessor.RIGHT_JUSTIFY;
+		justification = just;
+	}
+
+	void changeValues() {
+		double darg1 = getFirstArg();
+		double darg2 = getNextArg();
+		double darg3 = getLastArg();
+		ImagePlus imp = getImage();
+		ImageProcessor ip = getProcessor();
+		Roi roi = imp.getRoi();
+		ImageProcessor mask = null;
+		if (roi==null || !roi.isArea()) {
+			ip.resetRoi();
+			roi = null;
+		} else {
+			ip.setRoi(roi);
+			mask = ip.getMask();
+			if (mask!=null) ip.snapshot();
+		}
+		int xmin=0, ymin=0, xmax=imp.getWidth(), ymax=imp.getHeight();
+		if (roi!=null) {
+			Rectangle r = roi.getBounds();
+			xmin=r.x; ymin=r.y; xmax=r.x+r.width; ymax=r.y+r.height;
+		}
+		boolean isFloat = getType()==ImagePlus.GRAY32;
+		if (imp.getBitDepth()==24) {
+			darg1 = (int)darg1&0xffffff;
+			darg2 = (int)darg2&0xffffff;
+		}
+		double v;
+		for (int y=ymin; y<ymax; y++) {
+			for (int x=xmin; x<xmax; x++) {
+				v = isFloat?ip.getPixelValue(x,y):ip.getPixel(x,y)&0xffffff;
+				boolean replace = v>=darg1 && v<=darg2;
+				if (Double.isNaN(darg1) && Double.isNaN(darg2) && Double.isNaN(v))
+					replace = true;
+				if (replace) {
+					if (isFloat)
+						ip.putPixelValue(x, y, darg3);
+					else
+						ip.putPixel(x, y, (int)darg3);
+				}
+			}
+		}
+		if (mask!=null) ip.reset(mask);
+		imp.updateAndDraw();
+		updateNeeded = false;
+	}
+
+	void requires() {
+		if (IJ.versionLessThan(getStringArg()))
+			interp.done = true;
+	}
+
+	Random ran;
+	double random() {
+		double dseed = Double.NaN;
+		boolean gaussian = false;
+		if (interp.nextToken()=='(') {
+			interp.getLeftParen();
+			if (isStringArg()) {
+				String arg = getString().toLowerCase(Locale.US);
+				if (arg.equals("seed")) {
+					interp.getComma();
+					dseed = interp.getExpression();
+					long seed = (long)dseed;
+					if (seed!=dseed)
+						interp.error("Seed not integer");
+					ran = new Random(seed);
+					ImageProcessor.setRandomSeed(seed);
+				} else if (arg.equals("gaussian"))
+					gaussian = true;
+				else
+					interp.error("'seed' or ''gaussian' expected");
+			}
+			interp.getRightParen();
+			if (!Double.isNaN(dseed)) return Double.NaN;
+		}
+		ImageProcessor.setRandomSeed(Double.NaN);
+		interp.getParens();
+ 		if (ran==null)
+			ran = new Random();
+		if (gaussian)
+			return ran.nextGaussian();
+		else
+			return ran.nextDouble();
+	}
+
+	double getResult(ResultsTable rt) {
+		interp.getLeftParen();
+		String column = getString();
+		int row = -1;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			row = (int)interp.getExpression();
+		}
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			String title = getString();
+			rt = getResultsTable(title);
+		}
+		if (rt==null)
+			rt = getResultsTable(true);
+		interp.getRightParen();
+		int counter = rt.size();
+		if (row==-1) row = counter-1;
+		if (row<0 || row>=counter)
+			interp.error("Row ("+row+") out of range");
+		int col = rt.getColumnIndex(column);
+		if (!rt.columnExists(col))
+			return Double.NaN;
+		else {
+			double value = rt.getValueAsDouble(col, row);
+			if (Double.isNaN(value)) {
+				String s = rt.getStringValue(col, row);
+				if (s!=null && !s.equals("NaN"))
+					value = Tools.parseDouble(s);
+			}
+			return value;
+		}
+	}
+
+	String getResultString(ResultsTable rt) {
+		interp.getLeftParen();
+		String column = getString();
+		int row = -1;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			row = (int)interp.getExpression();
+		}
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			String title = getString();
+			rt = getResultsTable(title);
+		}
+		interp.getRightParen();
+		if (rt==null)
+			rt = getResultsTable(true);
+		int counter = rt.size();
+		if (row==-1) row = counter-1;
+		if (row<0 || row>=counter)
+			interp.error("Row ("+row+") out of range");
+		int col = rt.getColumnIndex(column);
+		if (rt.columnExists(col))
+			return rt.getStringValue(col, row);
+		else {
+			String label = null;
+			if ("Label".equals(column))
+				label = rt.getLabel(row);
+			return label!=null?label:"null";
+		}
+	}
+
+	String getResultLabel() {
+		int row = (int)getArg();
+		ResultsTable rt = getResultsTable(true);
+		int counter = rt.size();
+		if (row<0 || row>=counter)
+			interp.error("Row ("+row+") out of range");
+		String label = rt.getLabel(row);
+		if (label!=null)
+			return label;
+		else {
+			label = rt.getStringValue("Label", row);
+			return label!=null?label:"";
+		}
+	}
+
+	private ResultsTable getResultsTable(boolean reportErrors) {
+		ResultsTable rt = Analyzer.getResultsTable();
+		int size = rt.size();
+		if (size==0) {
+			Frame frame = WindowManager.getFrontWindow();
+			if (frame==null || (frame instanceof Editor))
+				frame = WindowManager.getFrame("Results");
+			if (frame!=null && (frame instanceof TextWindow)) {
+				TextPanel tp = ((TextWindow)frame).getTextPanel();
+				rt = tp.getOrCreateResultsTable();
+				size = rt!=null?rt.size():0;
+			}
+		}
+		if (size==0) {
+			Window win = WindowManager.getActiveTable();
+			if (win!=null && (win instanceof TextWindow)) {
+				TextPanel tp = ((TextWindow)win).getTextPanel();
+				rt = tp.getOrCreateResultsTable();
+				size = rt!=null?rt.size():0;
+			}
+		}
+		if (size==0 && reportErrors)
+			interp.error("No results found");
+		return rt;
+	}
+
+	void setResult(ResultsTable rt) {
+		interp.getLeftParen();
+		String column = getString();
+		interp.getComma();
+		int row = (int)interp.getExpression();
+		interp.getComma();
+		double value = 0.0;
+		String stringValue = null;
+		boolean isLabel = column.equals("Label");
+		if (isStringArg() || isLabel)
+			stringValue = getString();
+		else
+			value = interp.getExpression();
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			String title = getString();
+			rt = getResultsTable(title);
+		}
+		interp.getRightParen();
+		if (rt==null) {
+			rt = Analyzer.getResultsTable();
+			resultsPending = true;
+		} else
+			unUpdatedTable = rt;
+		if (row<0 || row>rt.size())
+			interp.error("Row ("+row+") out of range");
+		if (row==rt.size())
+			rt.incrementCounter();
+		try {
+			if (stringValue!=null) {
+				if (isLabel)
+					rt.setLabel(stringValue, row);
+				else
+					rt.setValue(column, row, stringValue);
+			} else
+				rt.setValue(column, row, value);
+		} catch (Exception e) {
+			interp.error(""+e.getMessage());
+		}
+	}
+
+	void updateResults() {
+		interp.getParens();
+		ResultsTable rt = Analyzer.getResultsTable();
+		rt.show("Results");
+		resultsPending = false;
+	}
+
+	double getNumber() {
+		String prompt = getFirstString();
+		double defaultValue = getLastArg();
+		String title = interp.macroName!=null?interp.macroName:"";
+		if (title.endsWith(" Options"))
+			title = title.substring(0, title.length()-8);
+		GenericDialog gd = new GenericDialog(title);
+		int decimalPlaces = (int)defaultValue==defaultValue?0:2;
+		gd.addNumericField(prompt, defaultValue, decimalPlaces);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			interp.done = true;
+			return defaultValue;
+		}
+		double v = gd.getNextNumber();
+		if (gd.invalidNumber())
+			return defaultValue;
+		else
+			return v;
+	}
+
+	double getBoolean() {
+		interp.getLeftParen();
+		String prompt = getString();
+		String yesButton = "  Yes  ";
+		String noButton = "  No  ";
+		if (interp.nextToken()==',') {
+			yesButton = getNextString();
+			noButton = getNextString();
+		}
+		interp.getRightParen();
+		String title = interp.macroName!=null?interp.macroName:"";
+		if (title.endsWith(" Options"))
+			title = title.substring(0, title.length()-8);
+		YesNoCancelDialog d = new YesNoCancelDialog(IJ.getInstance(), title, prompt, yesButton, noButton);
+		if (d.cancelPressed()) {
+			interp.done = true;
+			return 0.0;
+		} else if (d.yesPressed())
+			return 1.0;
+		else
+			return 0.0;
+	}
+
+	String getStringDialog() {
+		interp.getLeftParen();
+		String prompt = getString();
+		interp.getComma();
+		String defaultStr = getString();
+		interp.getRightParen();
+
+		String title = interp.macroName!=null?interp.macroName:"";
+		if (title.endsWith(" Options"))
+			title = title.substring(0, title.length()-8);
+		GenericDialog gd = new GenericDialog(title);
+		gd.addStringField(prompt, defaultStr, 20);
+		gd.showDialog();
+		String str = "";
+		if (gd.wasCanceled())
+			interp.done = true;
+		else
+			str = gd.getNextString();
+		return str;
+	}
+
+	String d2s() {
+		return IJ.d2s(getFirstArg(), (int)getLastArg());
+	}
+
+	String toString(int base) {
+		int arg = (int)getArg();
+		if (base==2)
+			return Integer.toBinaryString(arg);
+		else
+			return Integer.toHexString(arg);
+	}
+
+	double getStackSize() {
+		interp.getParens();
+		return getImage().getStackSize();
+	}
+
+	double getImageCount() {
+		interp.getParens();
+		return WindowManager.getImageCount();
+	}
+
+	double getResultsCount() {
+		interp.getParens();
+		return Analyzer.getResultsTable().getCounter();
+	}
+
+	void getCoordinates() {
+		Variable xCoordinates = getFirstArrayVariable();
+		Variable yCoordinates = getLastArrayVariable();
+		ImagePlus imp = getImage();
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			interp.error("Selection required");
+		Variable[] xa, ya;
+		if (roi.getType()==Roi.LINE) {
+			xa = new Variable[2];
+			ya = new Variable[2];
+			Line line = (Line)roi;
+			xa[0] = new Variable(line.x1d);
+			ya[0] = new Variable(line.y1d);
+			xa[1] = new Variable(line.x2d);
+			ya[1] = new Variable(line.y2d);
+		} else {
+			FloatPolygon fp = roi.getFloatPolygon();
+			if (fp!=null) {
+				xa = new Variable[fp.npoints];
+				ya = new Variable[fp.npoints];
+				for (int i=0; i<fp.npoints; i++)
+					xa[i] = new Variable(fp.xpoints[i]);
+				for (int i=0; i<fp.npoints; i++)
+					ya[i] = new Variable(fp.ypoints[i]);
+			} else {
+				Polygon p = roi.getPolygon();
+				xa = new Variable[p.npoints];
+				ya = new Variable[p.npoints];
+				for (int i=0; i<p.npoints; i++)
+					xa[i] = new Variable(p.xpoints[i]);
+				for (int i=0; i<p.npoints; i++)
+					ya[i] = new Variable(p.ypoints[i]);
+			}
+		}
+		xCoordinates.setArray(xa);
+		yCoordinates.setArray(ya);
+	}
+
+	Variable[] getProfile() {
+		interp.getParens();
+		ImagePlus imp = getImage();
+		if (imp.getRoi()==null)
+			interp.error("Selection required");
+		ProfilePlot pp = new ProfilePlot(imp, IJ.altKeyDown());
+		double[] array = pp.getProfile();
+		if (array==null) {
+			interp.done=true;
+			return null;
+		} else
+			return new Variable(array).getArray();
+	}
+
+	Variable[] split() {
+		String s1 = getFirstString();
+		String s2 = null;
+		if (interp.nextToken()==')')
+			interp.getRightParen();
+		else
+			s2 = getLastString();
+		if (s1==null)
+			return null;
+		String[] strings = null;
+		if (s1.length()>0 && s2!=null && (s2.equals(",")||s2.equals(";")))
+			strings = s1.split(s2,-1);
+		else if (s1.length()>0 && s2!=null && s2.length()>=3 && s2.startsWith("(")&&s2.endsWith(")")) {
+			s2 = s2.substring(1,s2.length()-1);
+			strings = s1.split(s2,-1);
+		} else
+			strings = (s2==null||s2.equals(""))?Tools.split(s1):Tools.split(s1, s2);
+    	Variable[] array = new Variable[strings.length];
+    	for (int i=0; i<strings.length; i++)
+    		array[i] = new Variable(0, 0.0, strings[i]);
+    	return array;
+	}
+
+	Variable[] getFileList() {
+		String dir = getStringArg();
+		File f = new File(dir);
+		if (!f.exists() || !f.isDirectory())
+			return new Variable[0];
+		String[] list = f.list();
+		if (list==null)
+			return new Variable[0];
+		if (!IJ.isWindows())
+			Arrays.sort(list);
+    	File f2;
+    	int hidden = 0;
+    	for (int i=0; i<list.length; i++) {
+    		if (list[i].startsWith(".") || list[i].equals("Thumbs.db")) {
+    			list[i] = null;
+    			hidden++;
+    		} else {
+    			f2 = new File(dir, list[i]);
+    			if (f2.isDirectory())
+    				list[i] = list[i] + "/";
+    		}
+    	}
+    	int n = list.length-hidden;
+		if (n<=0)
+			return new Variable[0];
+    	if (hidden>0) {
+			String[] list2 = new String[n];
+			int j = 0;
+			for (int i=0; i<list.length; i++) {
+				if (list[i]!=null)
+					list2[j++] = list[i];
+			}
+			list = list2;
+		}
+    	Variable[] array = new Variable[n];
+    	for (int i=0; i<n; i++)
+    		array[i] = new Variable(0, 0.0, list[i]);
+    	return array;
+	}
+
+	Variable[] newArray() {
+		if (interp.nextToken()!='(' || interp.nextNextToken()==')') {
+			interp.getParens();
+			return new Variable[0];
+		}
+		interp.getLeftParen();
+		int next = interp.nextToken();
+		int nextNext = interp.nextNextToken();
+		Vector vector = new Vector();
+		int size = 0;
+		do {
+			Variable v = new Variable();
+			if (isStringArg())
+				v.setString(getString());
+			else
+				v.setValue(interp.getExpression());
+			vector.addElement(v);
+			size++;
+			interp.getToken();
+		} while (interp.token==',');
+		if (interp.token!=')')
+			interp.error("';' expected");
+		Variable[] array = new Variable[size];
+		vector.copyInto((Variable[])array);
+		if (array.length==1 && array[0].getString()==null) {
+			size = (int)array[0].getValue();
+			if (size<0) interp.error("Negative array size");
+			Variable[] array2 = new Variable[size];
+			for (int i=0; i<size; i++)
+				array2[i] = new Variable();
+			return array2;
+		} else
+			return array;
+	}
+
+	String fromCharCode() {
+		char[] chars = new char[100];
+		int count = 0;
+		interp.getLeftParen();
+		while(interp.nextToken()!=')') {
+			int value = (int)interp.getExpression();
+			if (value<0 || value>65535)
+				interp.error("Value (" + value + ") out of 0-65535 range");
+			chars[count++] = (char)value;
+			if (interp.nextToken()==',')
+				interp.getToken();
+		}
+		interp.getRightParen();
+		return new String(chars, 0, count);
+	}
+
+	String getInfo() {
+		if (interp.nextNextToken()==STRING_CONSTANT
+		|| (interp.nextToken()=='('&&interp.nextNextToken()!=')'))
+			return getInfo(getStringArg());
+		else {
+			interp.getParens();
+			return getWindowContents();
+		}
+	}
+
+	String getInfo(String key) {
+			String lowercaseKey = key.toLowerCase(Locale.US);
+			int len = lowercaseKey.length();
+			if (lowercaseKey.equals("command.name")) {
+				return ImageJ.getCommandName();
+			} else if (lowercaseKey.equals("overlay")) {
+				Overlay overlay = getImage().getOverlay();
+				if (overlay==null)
+					return "";
+				else
+					return overlay.toString();
+			} else if (lowercaseKey.equals("log")) {
+				String log = IJ.getLog();
+				return log!=null?log:"";
+			} else if (key.indexOf(".")==-1) {
+				ImagePlus imp = getImage();
+				String value = imp.getStringProperty(key);
+				if (value!=null) return value;
+			} else if (lowercaseKey.equals("micrometer.abbreviation")) {
+				return "\u00B5m";
+			} else if (lowercaseKey.equals("image.title")) {
+				return getImage().getTitle();
+			} else if (lowercaseKey.equals("image.subtitle")) {
+				ImagePlus imp = getImage();
+				ImageWindow win = imp.getWindow();
+				return win!=null?win.createSubtitle():"";
+			} else if (lowercaseKey.equals("slice.label")) {
+				ImagePlus imp = getImage();
+				String label = null;
+				if (imp.getStackSize()==1)
+					label = imp.getProp("Slice_Label");
+				else
+					label = imp.getStack().getShortSliceLabel(imp.getCurrentSlice());
+				return label!=null?label:"";
+			} else if (lowercaseKey.equals("window.contents")) {
+				return getWindowContents();
+			} else if (lowercaseKey.equals("image.description")) {
+				String description = "";
+				FileInfo fi = getImage().getOriginalFileInfo();
+				if (fi!=null) description = fi.description;
+				if  (description==null) description = "";
+				return description;
+			} else if (lowercaseKey.equals("image.filename")) {
+				String name= "";
+				FileInfo fi = getImage().getOriginalFileInfo();
+				if (fi!=null && fi.fileName!=null) name= fi.fileName;
+				return name;
+			} else if (lowercaseKey.equals("image.directory")) {
+				String dir= "";
+				FileInfo fi = getImage().getOriginalFileInfo();
+				if (fi!=null && fi.directory!=null) dir= fi.directory;
+				return dir;
+			} else if (lowercaseKey.equals("selection.name")||lowercaseKey.equals("roi.name")) {
+				ImagePlus imp = getImage();
+				Roi roi = imp.getRoi();
+				String name = roi!=null?roi.getName():null;
+				return name!=null?name:"";
+			} else if (lowercaseKey.equals("selection.color")||lowercaseKey.equals("roi.color")) {
+				ImagePlus imp = getImage();
+				Roi roi = imp.getRoi();
+				if (roi==null)
+					interp.error("No selection");
+				Color color = roi.getStrokeColor();
+				return Colors.colorToString(color);
+			} else if (lowercaseKey.equals("font.name")) {
+				resetImage();
+				ImageProcessor ip = getProcessor();
+				setFont(ip);
+				return ip.getFont().getName();
+			} else if (lowercaseKey.equals("threshold.method")) {
+				return ThresholdAdjuster.getMethod();
+			} else if (lowercaseKey.equals("threshold.mode")) {
+				return ThresholdAdjuster.getMode();
+			} else if (lowercaseKey.equals("window.type")) {
+				return getWindowType();
+			} else if (lowercaseKey.equals("window.title")||lowercaseKey.equals("window.name")) {
+				return getWindowTitle();
+			} else if (lowercaseKey.equals("macro.filepath")) {
+				String path = Macro_Runner.getFilePath();
+				return path!=null?path:"null";
+			} else {
+				String value = "";
+				try {
+					value = System.getProperty(key);
+				} catch (Exception e) {};
+				if (value==null)
+					return("Invalid key");
+				else
+					return value;
+			}
+			return "";
+	}
+
+	private String getWindowTitle() {
+		Window win = WindowManager.getActiveWindow();
+		if (IJ.debugMode) IJ.log("getWindowTitle: "+win);
+		if (win==null)
+			return "";
+		else if (win instanceof Frame)
+			return ((Frame)win).getTitle();
+		else if (win instanceof Dialog)
+			return ((Dialog)win).getTitle();
+		else
+			return "";
+	}
+
+	private String getWindowType() {
+		Window win = WindowManager.getActiveWindow();
+		if (win==null)
+			return "";
+		String type = win.getClass().getName();
+		if (win instanceof TextWindow) {
+			TextPanel tp = ((TextWindow)win).getTextPanel();
+			if (tp.getColumnHeadings().isEmpty()  && tp.getResultsTable()==null)
+				type = "Text";
+			else {
+				if (tp.getResultsTable()!=null)
+					type = "ResultsTable";
+				else
+					type = "Table";
+			}
+		} else if (type.equals("ij.gui.PlotWindow"))
+			type = "Plot";
+		else if (type.equals("ij.gui.HistogramWindow"))
+			type = "Histogram";
+		else if (win instanceof ij.gui.ImageWindow)
+			type = "Image";
+		else {
+			if (type.contains(".")) //strip off hierarchy
+				type = type.substring(type.lastIndexOf('.')+1);
+		}
+		return type;
+	}
+
+	String getWindowContents() {
+		Frame frame = WindowManager.getFrontWindow();
+		if (frame!=null && frame instanceof TextWindow) {
+			TextPanel tp = ((TextWindow)frame).getTextPanel();
+			return tp.getText();
+		} else if (frame!=null && frame instanceof Editor) {
+			return ((Editor)frame).getText();
+		} else if (frame!=null && frame instanceof Recorder) {
+			return ((Recorder)frame).getText();
+		} else
+			return getImageInfo();
+	}
+
+	String getImageInfo() {
+		ImagePlus imp = getImage();
+		ImageInfo infoPlugin = new ImageInfo();
+		return infoPlugin.getImageInfo(imp);
+	}
+
+	public String getDirectory() {
+		String dir = IJ.getDirectory(getStringArg());
+		if (dir==null) dir = "";
+		return dir;
+	}
+
+	double getSelectionType() {
+		interp.getParens();
+		double type = -1;
+		if (WindowManager.getImageCount()==0)
+			return type;
+		ImagePlus imp = getImage();
+		Roi roi = imp.getRoi();
+		if (roi!=null)
+			type = roi.getType();
+		return type;
+	}
+
+	void showMessage(boolean withCancel) {
+		String message;
+		interp.getLeftParen();
+		String title = getString();
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			message = getString();
+		} else {
+			message = title;
+			title = "";
+		}
+		interp.getRightParen();
+		if (withCancel)
+			IJ.showMessageWithCancel(title, message);
+		else
+			IJ.showMessage(title, message);
+	}
+
+	double lengthOf() {
+		int length = 0;
+		interp.getLeftParen();
+		switch (interp.nextToken()) {
+			case STRING_CONSTANT:
+			case STRING_FUNCTION:
+			case USER_FUNCTION:
+				length = getString().length();
+				break;
+			case WORD:
+				if (pgm.code[interp.pc+2]=='[') {
+					length = getString().length();
+					break;
+				}
+				interp.getToken();
+				Variable v = interp.lookupVariable();
+				if (v==null) return 0.0;
+				String s = v.getString();
+				if (s!=null)
+					length = s.length();
+				else {
+					Variable[] array = v.getArray();
+					if (array!=null)
+						length = v.getArraySize();
+					else
+						interp.error("String or array expected");
+				}
+				break;
+			default:
+				interp.error("String or array expected");
+		}
+		interp.getRightParen();
+		return length;
+	}
+
+	void getCursorLoc() {
+		Variable x = getFirstVariable();
+		Variable y = getNextVariable();
+		Variable z = getNextVariable();
+		Variable flags = getLastVariable();
+		ImagePlus imp = getImage();
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null) return;
+		Point p = ic.getCursorLoc();
+		x.setValue(p.x);
+		y.setValue(p.y);
+		z.setValue(imp.getCurrentSlice()-1);
+		Roi roi = imp.getRoi();
+		flags.setValue(ic.getModifiers()+((roi!=null)&&roi.contains(p.x,p.y)?32:0));
+	}
+
+	void getLine() {
+		Variable vx1 = getFirstVariable();
+		Variable vy1 = getNextVariable();
+		Variable vx2 = getNextVariable();
+		Variable vy2 = getNextVariable();
+		Variable lineWidth = getLastVariable();
+		ImagePlus imp = getImage();
+		double x1=-1, y1=-1, x2=-1, y2=-1;
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.getType()==Roi.LINE) {
+			Line line = (Line)roi;
+			x1=line.x1d; y1=line.y1d; x2=line.x2d; y2=line.y2d;
+		}
+		vx1.setValue(x1);
+		vy1.setValue(y1);
+		vx2.setValue(x2);
+		vy2.setValue(y2);
+		lineWidth.setValue(roi!=null?roi.getStrokeWidth():1);
+	}
+
+	void getVoxelSize() {
+		Variable width = getFirstVariable();
+		Variable height = getNextVariable();
+		Variable depth = getNextVariable();
+		Variable unit = getLastVariable();
+		ImagePlus imp = getImage();
+		Calibration cal = imp.getCalibration();
+		width.setValue(cal.pixelWidth);
+		height.setValue(cal.pixelHeight);
+		depth.setValue(cal.pixelDepth);
+		unit.setString(cal.getUnits());
+	}
+
+	void getHistogram() {
+		interp.getLeftParen();
+		Variable values = null;
+		if (interp.nextToken()==NUMBER)
+			interp.getExpression();
+		else
+			values = getArrayVariable();
+		Variable counts = getNextArrayVariable();
+		interp.getComma();
+		int nBins = (int)interp.getExpression();
+		ImagePlus imp = getImage();
+		double histMin=0.0, histMax=0.0;
+		boolean setMinMax = false;
+		int bitDepth = imp.getBitDepth();
+		if (interp.nextToken()==',') {
+			histMin = getNextArg();
+			histMax = getLastArg();
+			if (bitDepth==8 || bitDepth==24)
+				interp.error("16 or 32-bit image required to set histMin and histMax");
+			setMinMax = true;
+		} else
+			interp.getRightParen();
+		if (nBins==65536 && bitDepth==16) {
+			Variable[] array = counts.getArray();
+			ImageProcessor ip = imp.getProcessor();
+			Roi roi = imp.getRoi();
+			if (roi!=null)
+				ip.setRoi(roi);
+			int[] hist = ip.getHistogram();
+			if (array!=null && array.length==nBins) {
+				for (int i=0; i<nBins; i++)
+					array[i].setValue(hist[i]);
+			} else
+				counts.setArray(new Variable(hist).getArray());
+			return;
+		}
+		ImageStatistics stats;
+		boolean custom8Bit = false;
+		if ((bitDepth==8||bitDepth==24) && nBins!=256) {
+			ImageProcessor ip = imp.getProcessor().convertToShort(false);
+			imp = imp.createImagePlus();
+			imp.setProcessor(ip);
+			stats = imp.getStatistics(AREA+MEAN+MODE+MIN_MAX, nBins, 0, 256);
+			custom8Bit = true;
+		} else if (setMinMax)
+			stats = imp.getStatistics(AREA+MEAN+MODE+MIN_MAX, nBins, histMin, histMax);
+		else
+			stats = imp.getStatistics(AREA+MEAN+MODE+MIN_MAX, nBins);
+		if (values!=null) {
+			Calibration cal = imp.getCalibration();
+			double[] array = new double[nBins];
+			double value = cal.getCValue(stats.histMin);
+			double inc = 1.0;
+			if (bitDepth==16 || bitDepth==32 || cal.calibrated() || custom8Bit)
+				inc = (cal.getCValue(stats.histMax) - cal.getCValue(stats.histMin))/stats.nBins;
+			for (int i=0; i<nBins; i++) {
+				array[i] = value;
+				value += inc;
+			}
+			values.setArray(new Variable(array).getArray());
+		}
+		Variable[] array = counts.getArray();
+		if (array!=null && array.length==nBins) {
+			for (int i=0; i<nBins; i++)
+				array[i].setValue(stats.histogram[i]);
+		} else
+			counts.setArray(new Variable(stats.histogram).getArray());
+	}
+
+	void getLut() {
+		Variable reds = getFirstArrayVariable();
+		Variable greens = getNextArrayVariable();
+		Variable blues = getLastArrayVariable();
+		ImagePlus imp = getImage();
+		IndexColorModel cm = null;
+		if (imp.isComposite())
+			cm = ((CompositeImage)imp).getChannelLut();
+		else {
+			ImageProcessor ip = imp.getProcessor();
+			if (ip instanceof ColorProcessor)
+				interp.error("Non-RGB image expected");
+			cm = (IndexColorModel)ip.getColorModel();
+		}
+		int mapSize = cm.getMapSize();
+		byte[] rLUT = new byte[mapSize];
+		byte[] gLUT = new byte[mapSize];
+		byte[] bLUT = new byte[mapSize];
+		cm.getReds(rLUT);
+		cm.getGreens(gLUT);
+		cm.getBlues(bLUT);
+		reds.setArray(new Variable(rLUT).getArray());
+		greens.setArray(new Variable(gLUT).getArray());
+		blues.setArray(new Variable(bLUT).getArray());
+	}
+
+	void setLut() {
+		double[] reds = getFirstArray();
+		double[] greens = getNextArray();
+		double[] blues = getLastArray();
+		int length = reds.length;
+		if (greens.length!=length || blues.length!=length)
+			interp.error("Arrays are not the same length");
+		ImagePlus imp = getImage();
+		if (imp.getBitDepth()==24)
+			interp.error("Non-RGB image expected");
+		ImageProcessor ip = getProcessor();
+		byte[] r = new byte[length];
+		byte[] g = new byte[length];
+		byte[] b = new byte[length];
+		for (int i=0; i<length; i++) {
+			r[i] = (byte)reds[i];
+			g[i] = (byte)greens[i];
+			b[i] = (byte)blues[i];
+		}
+		LUT lut = new LUT(8, length, r, g, b);
+		if (imp.isComposite())
+			((CompositeImage)imp).setChannelLut(lut);
+		else
+			ip.setColorModel(lut);
+		imp.updateAndDraw();
+		updateNeeded = false;
+	}
+
+	void getThreshold() {
+		Variable lower = getFirstVariable();
+		Variable upper = getLastVariable();
+		ImagePlus imp = getImage();
+		ImageProcessor ip = getProcessor();
+		double t1 = ip.getMinThreshold();
+		double t2 = ip.getMaxThreshold();
+		if (t1==ImageProcessor.NO_THRESHOLD) {
+			t1 = -1;
+			t2 = -1;
+		} else {
+			Calibration cal = imp.getCalibration();
+			t1 = cal.getCValue(t1);
+			t2 = cal.getCValue(t2);
+		}
+		lower.setValue(t1);
+		upper.setValue(t2);
+	}
+
+	void getPixelSize() {
+		Variable unit = getFirstVariable();
+		Variable width = getNextVariable();
+		Variable height = getNextVariable();
+		Variable depth = null;
+		if (interp.nextToken()==',')
+			depth = getNextVariable();
+		interp.getRightParen();
+		Calibration cal = getImage().getCalibration();
+		unit.setString(cal.getUnits());
+		width.setValue(cal.pixelWidth);
+		height.setValue(cal.pixelHeight);
+		if (depth!=null)
+		depth.setValue(cal.pixelDepth);
+	}
+
+	void makeSelection() {
+        String type = null;
+        int roiType = -1;
+        interp.getLeftParen();
+		if (isStringArg()) {
+			type = getString().toLowerCase();
+			roiType = Roi.POLYGON;
+			if (type.contains("free"))
+				roiType = Roi.FREEROI;
+			if (type.contains("traced"))
+				roiType = Roi.TRACED_ROI;
+			if (type.contains("line")) {
+				if (type.contains("free"))
+					roiType = Roi.FREELINE;
+				else
+					roiType = Roi.POLYLINE;
+			}
+			if (type.contains("angle"))
+				roiType = Roi.ANGLE;
+			if (type.contains("point")||type.contains("cross")||type.contains("circle")||type.contains("dot"))
+				roiType = Roi.POINT;
+		} else {
+			roiType = (int)interp.getExpression();
+			if (roiType<0 || roiType==Roi.COMPOSITE)
+				interp.error("Invalid selection type ("+roiType+")");
+			if (roiType==Roi.RECTANGLE) roiType = Roi.POLYGON;
+			if (roiType==Roi.OVAL) roiType = Roi.FREEROI;
+		}
+		double[] x = getNextArray();
+		int n = x.length;
+		interp.getComma();
+		double[] y = getNumericArray();
+		if (interp.nextToken()==',') {
+			n = (int)getLastArg();
+			if (n>x.length || n>y.length)
+				interp.error("Array too short");
+		} else {
+			interp.getRightParen();
+			if (y.length!=n)
+				interp.error("Arrays are not the same length");
+		}
+		ImagePlus imp = getImage();
+		boolean floatCoordinates = false;
+		for (int i=0; i<n; i++) {
+			if (x[i]!=(int)x[i] || y[i]!=(int)y[i]) {
+				floatCoordinates = true;
+				break;
+			}
+		}
+		int[] xcoord = null;
+		int[] ycoord = null;
+		float[] xfcoord = null;
+		float[] yfcoord = null;
+		if (floatCoordinates) {
+			xfcoord = new float[n];
+			yfcoord = new float[n];
+			for (int i=0; i<n; i++) {
+				xfcoord[i] = (float)x[i];
+				yfcoord[i] = (float)y[i];
+			}
+		} else {
+			xcoord = new int[n];
+			ycoord = new int[n];
+			for (int i=0; i<n; i++) {
+				xcoord[i] = (int)Math.round(x[i]);
+				ycoord[i] = (int)Math.round(y[i]);
+			}
+		}
+		Roi roi = null;
+		if (roiType==Roi.LINE) {
+			if (!(xcoord!=null&&xcoord.length==2||xfcoord!=null&&xfcoord.length==2))
+				interp.error("2 element arrays expected");
+			if (floatCoordinates)
+				roi = new Line(xfcoord[0], yfcoord[0], xfcoord[1], yfcoord[1]);
+			else
+				roi = new Line(xcoord[0], ycoord[0], xcoord[1], ycoord[1]);
+		} else if (roiType==Roi.POINT) {
+			if (type!=null && !type.equals("point")) {
+				if (!floatCoordinates) {
+					xfcoord = new float[n];
+					yfcoord = new float[n];
+					for (int i=0; i<n; i++) {
+						xfcoord[i] = (float)xcoord[i];
+						yfcoord[i] = (float)ycoord[i];
+					}
+				}
+				roi = new PointRoi(xfcoord, yfcoord, type);
+			} else if (floatCoordinates)
+				roi = new PointRoi(xfcoord, yfcoord, n);
+			else
+				roi = new PointRoi(xcoord, ycoord, n);
+		} else {
+			if (floatCoordinates)
+				roi = new PolygonRoi(xfcoord, yfcoord, n, roiType);
+			else
+				roi = new PolygonRoi(xcoord, ycoord, n, roiType);
+		}
+		Roi previousRoi = imp.getRoi();
+		if (shiftKeyDown||altKeyDown) imp.saveRoi();
+		imp.setRoi(roi);
+		if (roiType==Roi.POLYGON || roiType==Roi.FREEROI) {
+			roi = imp.getRoi();
+			if (previousRoi!=null && roi!=null)
+				updateRoi(roi);
+		}
+		updateNeeded = false;
+		shiftKeyDown = altKeyDown = false;
+	}
+
+	double doPlot() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD || interp.token==PREDEFINED_FUNCTION || interp.token==STRING_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("create")) {
+			return newPlot();
+		} else if (name.equals("getValues")) {
+			return getPlotValues();
+		} else if (name.equals("showValues")) {
+			return showPlotValues(/*useLabels=*/false);
+		} else if (name.equals("showValuesWithLabels")) {
+			return showPlotValues(/*useLabels=*/true);
+		}
+		// the following commands work with a plot under construction or an image with a plot created previously
+		Plot currentPlot = plot;
+		if (currentPlot == null)
+			currentPlot = (Plot)(getImage().getProperty(Plot.PROPERTY_KEY));
+		if (currentPlot==null)
+			interp.error("No plot window and no plot under construction");
+		if (name.equals("setFrameSize")) {
+			currentPlot.setFrameSize((int)getFirstArg(), (int)getLastArg());
+			return Double.NaN;
+		} else if (name.equals("setLimits")) {
+			currentPlot.setLimits(getFirstArg(), getNextArg(), getNextArg(), getLastArg());
+			return Double.NaN;
+		} else if (name.equals("setLimitsToFit")) {
+			interp.getParens();
+			currentPlot.setLimitsToFit(true);
+			return Double.NaN;
+		} else if (name.equals("setLogScaleX")) {
+			if (interp.nextNextToken()==')') {  //no-argument call setLogScaleX() means true
+				interp.getParens();
+				currentPlot.setAxisXLog(true);
+			} else
+				currentPlot.setAxisXLog(getBooleanArg());
+			currentPlot.updateImage();
+			return Double.NaN;
+		} else if (name.equals("setLogScaleY")) {
+			if (interp.nextNextToken()==')') {
+				interp.getParens();
+				currentPlot.setAxisYLog(true);
+			} else
+				currentPlot.setAxisYLog(getBooleanArg());
+			currentPlot.updateImage();
+			return Double.NaN;
+		} else if (name.equals("getLimits")) {
+			return getPlotLimits(currentPlot);
+		} else if (name.equals("freeze")) {
+			currentPlot.setFrozen(getBooleanArg());
+			return Double.NaN;			
+		} else if (name.equals("removeNaNs")) {
+			interp.getParens();
+			currentPlot.removeNaNs();
+			return Double.NaN;
+		}  else if (name.equals("addLegend") || name.equals("setLegend")) {
+			return addPlotLegend(currentPlot);
+		}  else if (name.equals("setStyle")) {
+			int index = (int)getFirstArg();
+			if (index<0 || index>=currentPlot.getNumPlotObjects())
+				interp.error("Index out of bounds");
+			currentPlot.setStyle(index, getLastString());
+			if (plot == null)
+				currentPlot.updateImage();
+			return Double.NaN;
+		}  else if (name.equals("makeHighResolution")) {
+			return makeHighResolution(currentPlot);
+		} else if (name.equals("setColor")) {
+			return setPlotColor(currentPlot);
+		} else if (name.equals("setBackgroundColor")) {
+			return setPlotBackgroundColor(currentPlot);
+		} else if (name.equals("setFontSize")) {
+			return setPlotFontSize(currentPlot, false);
+		} else if (name.equals("setAxisLabelSize")) {
+			return setPlotFontSize(currentPlot, true);
+		} else if (name.equals("setXYLabels")) {
+			currentPlot.setXYLabels(getFirstString(), getLastString());
+			currentPlot.updateImage();
+			return Double.NaN;
+		} else if (name.equals("setFormatFlags")) {
+			return setPlotFormatFlags(currentPlot);
+		} else if (name.equals("useTemplate")) {
+			return fromPlot(currentPlot, 't');
+		} else if (name.equals("setOptions")) {
+			return setPlotOptions(currentPlot);
+		} else if (name.equals("addFromPlot")) {
+			return fromPlot(currentPlot, 'a');
+		} else if (name.equals("getFrameBounds")) {
+			return getPlotFrameBounds(currentPlot);
+		} else if (name.equals("objectCount")||name.equals("getNumObjects")) {
+			return currentPlot.getNumPlotObjects();
+		} else if (name.equals("add")) {
+			return addToPlot(currentPlot);
+		} else if (name.equals("replace")) {
+			return replacePlot(currentPlot);
+		} else if (name.equals("addText") || name.equals("drawLabel")) {
+			return addPlotText(currentPlot);
+		}
+		// the following commands need a plot under construction
+		if (plot==null)
+			interp.error("No plot defined");
+		if (name.equals("show")) {
+			return showPlot();
+		} else if (name.equals("update")) {
+			return updatePlot();
+		} else if (name.equals("drawLine")) {
+			return drawPlotLine(false);
+		} else if (name.equals("drawNormalizedLine")) {
+			return drawPlotLine(true);
+		} else if (name.equals("drawVectors")) {
+			return drawPlotVectors();
+		} else if (name.equals("drawShapes")) {
+			return drawShapes();
+		} else if (name.equals("drawGrid")) {
+			plot.drawShapes("redraw_grid", null);
+			return Double.NaN;
+		} else if (name.startsWith("setLineWidth")) {
+			plot.setLineWidth((float)getArg());
+			return Double.NaN;
+		} else if (name.startsWith("setJustification")) {
+			setJustification();
+			return Double.NaN;
+		} else if (name.equals("addHistogram")) {
+			interp.getLeftParen();
+			Variable[] arrV = getArray();
+			interp.getComma();
+			double binWidth = interp.getExpression();
+			double binCenter = 0;
+			interp.getToken();
+			if (interp.token == ',')
+				 binCenter = interp.getExpression();
+			else
+				interp.putTokenBack();
+			interp.getRightParen();
+			int len1 = arrV.length;
+			double[] arrD = new double[len1];
+			for (int i=0; i<len1; i++)
+				arrD[i] = arrV[i].getValue();
+			plot.addHistogram(arrD, binWidth, binCenter);
+			return Double.NaN;
+		} else if (name.equals("appendToStack")) {
+			plot.appendToStack();
+			return Double.NaN;
+		} else
+			interp.error("Unrecognized plot function");
+		return Double.NaN;
+	}
+
+	double setPlotOptions(Plot plot) {
+		String options = getStringArg();
+		plot.setOptions(options);
+		plot.updateImage();
+		return Double.NaN;
+	}
+
+	double getPlotValues() {
+		Variable xvar = getFirstArrayVariable();
+		Variable yvar = getLastArrayVariable();
+		float[] xvalues = new float[0];
+		float[] yvalues = new float[0];
+		ImagePlus imp = getImage();
+		ImageWindow win = imp.getWindow();
+		if (imp.getProperty("XValues")!=null) {
+			xvalues = (float[])imp.getProperty("XValues");
+			yvalues = (float[])imp.getProperty("YValues");
+		} else if (win!=null && win instanceof PlotWindow) {
+			PlotWindow pw = (PlotWindow)win;
+			xvalues = pw.getXValues();
+			yvalues = pw.getYValues();
+		} else if (win!=null && win instanceof HistogramWindow) {
+			HistogramWindow hw = (HistogramWindow)win;
+			double[] x = hw.getXValues();
+			xvalues = new float[x.length];
+			for (int i=0; i<x.length; i++)
+				xvalues[i] = (float)x[i];
+			int[] y = hw.getHistogram();
+			yvalues = new float[y.length];
+			for (int i=0; i<y.length; i++)
+				yvalues[i] = y[i];
+		} else
+			interp.error("No plot or histogram window");
+		Variable[] xa = new Variable[xvalues.length];
+		Variable[] ya = new Variable[yvalues.length];
+		for (int i=0; i<xvalues.length; i++)
+			xa[i] = new Variable(xvalues[i]);
+		for (int i=0; i<yvalues.length; i++)
+			ya[i] = new Variable(yvalues[i]);
+		xvar.setArray(xa);
+		yvar.setArray(ya);
+		return Double.NaN;
+	}
+
+	double showPlotValues(boolean useLabels) {
+		String title = "Results";
+		if (interp.nextToken() == '(') {
+			interp.getLeftParen();
+			if (interp.nextToken()!=')')
+				title = getString();
+			interp.getRightParen();
+		}
+		interp.getParens();
+		ImagePlus imp = getImage();
+		ImageWindow win = imp.getWindow();
+		Plot plot = win instanceof PlotWindow ? ((PlotWindow)win).getPlot() : imp.getPlot();
+		if (plot!=null) {
+			ResultsTable rt = useLabels ? plot.getResultsTableWithLabels() : plot.getResultsTable(true);
+			rt.show(title);
+			return Double.NaN;
+		} else
+			interp.error("No plot window");
+		return Double.NaN;
+	}
+
+	double newPlot() {
+		String title = getFirstString();
+		String xLabel = getNextString();
+		String yLabel = getNextString();
+		double[] x, y;
+		if (interp.nextToken()==')')
+			x = y = null;
+		else {
+			x = getNextArray();
+			if (interp.nextToken()==')') {
+				y = x;
+				x = new double[y.length];
+				for (int i=0; i<y.length; i++)
+					x[i] = i;
+			} else
+				y = getNextArray();
+		}
+		interp.getRightParen();
+		plot = new Plot(title, xLabel, yLabel, x, y);
+		return Double.NaN;
+	}
+
+	double showPlot() {
+		if (plot!=null) {
+			PlotWindow plotWindow = plot.show();
+			if (plotWindow!=null)
+				plotID = plotWindow.getImagePlus().getID();
+		}
+		plot = null;
+		interp.getParens();
+		return Double.NaN;
+	}
+
+	double updatePlot() {
+		if (plot!=null) {
+			ImagePlus plotImage = WindowManager.getImage(plotID);
+			ImageWindow win = plotImage!=null?plotImage.getWindow():null;
+			if (win!=null)
+				((PlotWindow)win).drawPlot(plot);
+			else {
+				PlotWindow plotWindow = plot.show();
+				if (plotWindow!=null)
+					plotID = plotWindow.getImagePlus().getID();
+			}
+		}
+		plot = null;
+		interp.getParens();
+		return Double.NaN;
+	}
+
+	double addPlotText(Plot plot) {
+		String str = getFirstString();
+		double x = getNextArg();
+		double y = getLastArg();
+		plot.setJustification(justification);
+		plot.addLabel(x, y, str);
+		return Double.NaN;
+	}
+
+	double drawPlotLine(boolean normalized) {
+		double x1 = getFirstArg();
+		double y1 = getNextArg();
+		double x2 = getNextArg();
+		double y2 = getLastArg();
+		if (normalized)
+			plot.drawNormalizedLine(x1, y1, x2, y2);
+		else
+			plot.drawLine(x1, y1, x2, y2);
+		return Double.NaN;
+	}
+
+	double drawPlotVectors() {
+		double[] x1 = getFirstArray();
+		double[] y1 = getNextArray();
+		double[] x2 = getNextArray();
+		double[] y2 = getLastArray();
+		plot.drawVectors(x1, y1, x2, y2);
+		return Double.NaN;
+	}
+
+	//Example 10 boxes: ArrayList has 10 elements, each holding a float[6] for coordinates
+	//Example 10 rectangles: ArrayList has 10 elements, each holding a float[4] for the corners
+	double drawShapes() {
+		String type = getFirstString().toLowerCase();
+		double[][] arr2D = null;
+		int nBoxes = 0;
+		int nCoords = 0;
+		if (type.contains("rectangles")) {
+			nCoords = 4;//lefts, tops, rights, bottoms
+		} else if (type.contains("boxes")) {
+			nCoords = 6;//centers, Q1s, Q2s, Q3s, Q4s, Q5s (Q= quartile border)
+		} else {
+			interp.error("Must contain 'rectangles' or 'boxes'");
+			return Double.NaN;
+		}
+		double[] arr = null;
+		for (int jj = 0; jj < nCoords; jj++) {
+			interp.getToken();
+			if (interp.token == ',') {
+				if (!isArrayArg()) {
+					interp.putTokenBack();
+					double singleVal = getNextArg();
+					arr = new double[]{singleVal};//only 1 box
+				} else {
+					interp.putTokenBack();
+					arr = getNextArray();//>= 2 boxes
+				}
+				nBoxes = arr.length;
+				if (jj > 0 && arr2D[0].length != nBoxes) {
+					interp.error("Arrays must have same length (" + nBoxes + ")");
+					return Double.NaN;
+				}
+				if (arr2D == null) {
+					arr2D = new double[nCoords][nBoxes];
+				}
+				for (int boxNo = 0; boxNo < nBoxes; boxNo++) {
+					arr2D[jj][boxNo] = arr[boxNo];
+				}
+			}
+		}
+		interp.getRightParen();
+		float[][] floatArr = new float[nCoords][nBoxes];
+		for (int row = 0; row < nCoords; row++) {
+			floatArr[row] = Tools.toFloat(arr2D[row]);
+		}
+		ArrayList shapeData = new ArrayList();
+		for (int box = 0; box < nBoxes; box++) {
+			float[] coords = new float[nCoords];
+			for (int coord = 0; coord < nCoords; coord++) {
+				coords[coord] = (float) (arr2D[coord][box]);
+			}
+			shapeData.add(coords);
+		}
+		plot.drawShapes(type, shapeData);
+		return Double.NaN;
+	}
+
+	double setPlotColor(Plot plot) {
+		interp.getLeftParen();
+		Color color = getColor();
+		Color color2 = null;
+		if (interp.nextToken()!=')') {
+			interp.getComma();
+			color2 = getColor();
+		}
+		plot.setColor(color, color2);
+		interp.getRightParen();
+		return Double.NaN;
+	}
+
+	double setPlotBackgroundColor(Plot plot) {
+		interp.getLeftParen();
+		Color color = getColor();
+		interp.getRightParen();
+		plot.setBackgroundColor(color);
+		return Double.NaN;
+	}
+
+	double setPlotFontSize(Plot plot, boolean forAxisLabels) {
+		float size = (float)getFirstArg();
+		int style = -1;
+		if (interp.nextToken()!=')') {
+			String options = getNextString().toLowerCase();
+			style = 0;
+			if (options.indexOf("bold") >= 0)
+				style |= Font.BOLD;
+			if (options.indexOf("ital") >= 0)
+				style |= Font.ITALIC;
+		}
+		interp.getRightParen();
+		if (forAxisLabels)
+			plot.setAxisLabelFont(style, size);
+		else
+			plot.setFont(style, size);
+		plot.updateImage();
+		return Double.NaN;
+	}
+
+	double setPlotFormatFlags(Plot plot) {
+		String flagString = getStringArg();
+		try {
+			int flags = Integer.parseInt(flagString, 2);
+			plot.setFormatFlags(flags);
+			plot.updateImage();
+		} catch (NumberFormatException e) {
+			interp.error("Plot format flags not binary");
+		}
+		return Double.NaN;
+	}
+
+	/** Plot.useTemplate with 't', Plot.addFromPlot with 'a' */
+	double fromPlot(Plot plot, char type) {
+	    ImagePlus sourceImp = null;
+	    interp.getLeftParen();
+		if (isStringArg()) {
+			String title = getString();
+			sourceImp = WindowManager.getImage(title);
+			if (sourceImp==null)
+				interp.error("Image \""+title+"\" not found");
+		} else {
+			int id = (int)interp.getExpression();
+			sourceImp = WindowManager.getImage(id);
+			if (sourceImp==null)
+				interp.error("Image ID="+id+" not found");
+		}
+		Plot sourcePlot = (Plot)(sourceImp.getProperty(Plot.PROPERTY_KEY));
+		if (sourcePlot==null)
+			interp.error("No plot: "+sourceImp.getTitle());
+		if (type == 'a') {
+			int objectIndex = (int)getNextArg();
+			if (objectIndex < 0 || objectIndex > plot.getNumPlotObjects())
+				interp.error("Plot "+sourceImp.getTitle()+" has "+plot.getNumPlotObjects()+"items, no number "+objectIndex);
+			plot.addObjectFromPlot(sourcePlot, objectIndex);
+			plot.updateImage();
+		} else
+			plot.useTemplate(sourcePlot);
+		interp.getRightParen();
+		return Double.NaN;
+	}
+
+	double addPlotLegend(Plot plot) {
+		String labels = getFirstString();
+		String options = "auto";
+		if (interp.nextToken()!=')')
+			options = getLastString();
+		else
+			interp.getRightParen();
+		plot.setColor(Color.BLACK);
+		plot.setLineWidth(1);
+		plot.addLegend(labels, options);
+		return Double.NaN;
+	}
+
+	double getPlotLimits(Plot plot) {
+		double[] limits = plot.getLimits();
+		getFirstVariable().setValue(limits[0]);  //xMin
+		getNextVariable().setValue(limits[1]);   //xMax
+		getNextVariable().setValue(limits[2]);   //yMin
+		getLastVariable().setValue(limits[3]);   //yMax
+		return Double.NaN;
+	}
+
+	double getPlotFrameBounds(Plot plot) {
+		Rectangle r = plot.getDrawingFrame();
+		getFirstVariable().setValue(r.x);
+		getNextVariable().setValue(r.y);
+		getNextVariable().setValue(r.width);
+		getLastVariable().setValue(r.height);
+		return Double.NaN;
+	}
+
+	double makeHighResolution(Plot plot) {
+		String title = getFirstString();
+		double scale = getNextArg();
+		boolean antialiasedText = true;
+		if (interp.nextToken()!=')') {
+			String options = getLastString().toLowerCase();
+			if (options.indexOf("disable")!=-1)
+				antialiasedText = false;
+		} else
+			interp.getRightParen();
+		plot.makeHighResolution(title, (float)scale, antialiasedText, true);
+		return Double.NaN;
+	}
+
+	double addToPlot(Plot currentPlot) {
+		String shape = getFirstString();
+		int what = Plot.toShape(shape);
+		double[] x = getNextArray();
+		double[] y;
+		double[] errorBars = null;
+		String label = null;
+		if (interp.nextToken()==')') {
+			y = x;
+			x = new double[y.length];
+			for (int i=0; i<y.length; i++)
+				x[i] = i;
+		} else {
+			interp.getComma();
+			y = getNumericArray();
+			if (interp.nextToken()!=')') {
+				interp.getComma();
+				if (isArrayArg()) //can error bars (array) or label
+					errorBars = getNumericArray();
+				else
+					label = getString();
+			}
+		}
+		interp.getRightParen();
+		if (what==-1)
+			currentPlot.addErrorBars(y);
+		else if (what==-2)
+			currentPlot.addHorizontalErrorBars(y);
+		else if (errorBars != null)
+			currentPlot.addPoints(x, y, errorBars, what);
+		else if (what==Plot.CUSTOM)
+			currentPlot.add(shape, x, y);
+		else
+			currentPlot.addPoints(x, y, what);
+		if (label != null)
+			currentPlot.setLabel(-1, label);
+		return Double.NaN;
+	}
+
+	double replacePlot(Plot plot) {
+		int index = (int)getFirstArg();
+		String shape = getNextString();
+		double[] x = getNextArray();
+		double[] y = getLastArray();
+		plot.replace(index, shape, x, y);
+		return Double.NaN;
+	}
+
+	void getBounds(boolean intValues) {
+		Variable x = getFirstVariable();
+		Variable y = getNextVariable();
+		Variable width = getNextVariable();
+		Variable height = getLastVariable();
+		ImagePlus imp = getImage();
+		Roi roi = imp.getRoi();
+		if (roi!=null) {
+			if (intValues) {
+				Rectangle r = roi.getBounds();
+				x.setValue(r.x);
+				y.setValue(r.y);
+				width.setValue(r.width);
+				height.setValue(r.height);
+			} else {
+				Rectangle2D.Double r = roi.getFloatBounds();
+				x.setValue(r.x);
+				y.setValue(r.y);
+				width.setValue(r.width);
+				height.setValue(r.height);
+			}
+		} else {
+			x.setValue(0);
+			y.setValue(0);
+			width.setValue(imp.getWidth());
+			height.setValue(imp.getHeight());
+		}
+	}
+
+	String substring(String s) {
+		s = getStringFunctionArg(s);
+		int index1 = (int)interp.getExpression();
+		int index2 = s.length();
+		if (interp.nextToken()==',')
+			index2 = (int)getLastArg();
+		else
+			interp.getRightParen();
+		if (index1>index2)
+			interp.error("beginIndex>endIndex");
+		checkIndex(index1, 0, s.length());
+		checkIndex(index2, 0, s.length());
+		return s.substring(index1, index2);
+	}
+
+	private String getStringFunctionArg(String s) {
+		if (s==null) {
+			s=getFirstString();
+			interp.getComma();
+		} else
+			interp.getLeftParen();
+		return s;
+	}
+
+	int indexOf(String s1) {
+		s1 = getStringFunctionArg(s1);
+		String s2 = getString();
+		int fromIndex = 0;
+		if (interp.nextToken()==',') {
+			fromIndex = (int)getLastArg();
+			checkIndex(fromIndex, 0, s1.length()-1);
+		} else
+			interp.getRightParen();
+		if (fromIndex==0)
+			return s1.indexOf(s2);
+		else
+			return s1.indexOf(s2, fromIndex);
+	}
+
+	int startsWithEndsWith(int type) {
+		String s1 = getFirstString();
+		String s2 = getLastString();
+		if (type==STARTS_WITH)
+			return s1.startsWith(s2)?1:0;
+		else
+			return s1.endsWith(s2)?1:0;
+	}
+
+	double isActive() {
+		int id = (int)getArg();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getID()!=id)
+			return 0.0; //false
+		else
+			return 1.0; //true
+	}
+
+	double isOpen() {
+		interp.getLeftParen();
+		if (isStringArg()) {
+			String title = getString();
+			interp.getRightParen();
+			return isOpen(title)?1.0:0.0;
+		} else {
+			int id = (int)interp.getExpression();
+			interp.getRightParen();
+			return WindowManager.getImage(id)==null?0.0:1.0;
+		}
+	}
+
+	boolean isOpen(String title) {
+		boolean open = WindowManager.getWindow(title)!=null;
+		if (open)
+			return true;
+		else if (Interpreter.isBatchMode() && Interpreter.imageTable!=null) {
+			for (Enumeration en=Interpreter.imageTable.elements(); en.hasMoreElements();) {
+				ImagePlus imp = (ImagePlus)en.nextElement();
+				if (imp!=null && imp.getTitle().equals(title))
+					return true;
+			}
+		}
+		return false;
+	}
+
+	boolean isStringArg() {
+		int nextToken = pgm.code[interp.pc+1];
+		int tok = nextToken&0xff;
+		if (tok==STRING_CONSTANT||tok==STRING_FUNCTION) return true;
+		if (tok==VARIABLE_FUNCTION && interp.isString(interp.pc+1)) return true;
+		if (tok!=WORD) return false;
+		Variable v = interp.lookupVariable(nextToken>>TOK_SHIFT);
+		if (v==null) return false;
+		int type = v.getType();
+		if (type!=Variable.ARRAY)
+			return v.getType()==Variable.STRING;
+		Variable[] array = v.getArray();
+		if (array.length==0 || interp.nextNextToken()=='.') return false;
+		return array[0].getType()==Variable.STRING;
+	}
+
+	void exit() {
+		String msg = null;
+		if (interp.nextToken()=='(') {
+			interp.getLeftParen();
+			if (interp.nextToken()!=')')
+				msg = getString();
+			interp.getRightParen();
+		}
+		interp.finishUp();
+		if (msg!=null)
+			IJ.showMessage("Macro", msg);
+		throw new RuntimeException(Macro.MACRO_CANCELED);
+	}
+
+	private void showStatus () {
+		interp.getLeftParen();
+		String s = getString();
+		String options = null;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			options = getString();
+		}
+		interp.getRightParen();
+		boolean withSign = s.startsWith("!");
+		if (withSign)
+			s = s.substring(1);
+		IJ.protectStatusBar(false);
+		if (options!=null)
+			IJ.showStatus(s, options);
+		else
+			IJ.showStatus(s);
+		IJ.protectStatusBar(withSign);
+		interp.statusUpdated = true;
+	}
+
+	void showProgress() {
+		ImageJ ij = IJ.getInstance();
+		ij.gui.ProgressBar progressBar = ij!=null?ij.getProgressBar():null;
+		interp.getLeftParen();
+		double arg1 = interp.getExpression();
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			double arg2 = interp.getExpression();
+			if (progressBar!=null) progressBar.show((arg1+1.0)/arg2, true);
+		} else
+			if (progressBar!=null) progressBar.show(arg1, true);
+		interp.getRightParen();
+		interp.showingProgress = true;
+	}
+
+	void saveSettings() {
+		interp.getParens();
+		usePointerCursor = Prefs.usePointerCursor;
+		hideProcessStackDialog = IJ.hideProcessStackDialog;
+		divideByZeroValue = FloatBlitter.divideByZeroValue;
+		jpegQuality = FileSaver.getJpegQuality();
+		saveLineWidth = Line.getWidth();
+		doScaling = ImageConverter.getDoScaling();
+		weightedColor = Prefs.weightedColor;
+		weights = ColorProcessor.getWeightingFactors();
+		interpolateScaledImages = Prefs.interpolateScaledImages;
+		open100Percent = Prefs.open100Percent;
+		blackCanvas = Prefs.blackCanvas;
+		useJFileChooser = Prefs.useJFileChooser;
+		debugMode = IJ.debugMode;
+		foregroundColor =Toolbar.getForegroundColor();
+		backgroundColor =Toolbar.getBackgroundColor();
+		roiColor = Roi.getColor();
+		pointAutoMeasure = Prefs.pointAutoMeasure;
+		requireControlKey = Prefs.requireControlKey;
+		useInvertingLut = Prefs.useInvertingLut;
+		saveSettingsCalled = true;
+		measurements = Analyzer.getMeasurements();
+		decimalPlaces = Analyzer.getPrecision();
+		blackBackground = Prefs.blackBackground;
+		autoContrast = Prefs.autoContrast;
+		pasteMode = Roi.getCurrentPasteMode();
+		plotWidth = PlotWindow.plotWidth;
+		plotHeight = PlotWindow.plotHeight;
+		plotFontSize = PlotWindow.getDefaultFontSize();
+		plotInterpolate = PlotWindow.interpolate;
+		plotNoGridLines = PlotWindow.noGridLines;
+		plotNoTicks = PlotWindow.noTicks;
+		profileVerticalProfile = Prefs.verticalProfile;
+		profileSubPixelResolution = Prefs.subPixelResolution;
+	}
+
+	void restoreSettings() {
+		interp.getParens();
+		if (!saveSettingsCalled)
+			interp.error("saveSettings() not called");
+		Prefs.usePointerCursor = usePointerCursor;
+		IJ.hideProcessStackDialog = hideProcessStackDialog;
+		FloatBlitter.divideByZeroValue = divideByZeroValue;
+		FileSaver.setJpegQuality(jpegQuality);
+		Line.setWidth(saveLineWidth);
+		ImageConverter.setDoScaling(doScaling);
+		if (weightedColor!=Prefs.weightedColor) {
+			ColorProcessor.setWeightingFactors(weights[0], weights[1], weights[2]);
+			Prefs.weightedColor = !(weights[0]==1d/3d && weights[1]==1d/3d && weights[2]==1d/3d);
+		}
+		Prefs.interpolateScaledImages = interpolateScaledImages;
+		Prefs.open100Percent = open100Percent;
+		Prefs.blackCanvas = blackCanvas;
+		Prefs.useJFileChooser = useJFileChooser;
+		Prefs.useInvertingLut = useInvertingLut;
+		IJ.setDebugMode(debugMode);
+		Toolbar.setForegroundColor(foregroundColor);
+		Toolbar.setBackgroundColor(backgroundColor);
+		Roi.setColor(roiColor);
+		Analyzer.setMeasurements(measurements);
+		Analyzer.setPrecision(decimalPlaces);
+		ColorProcessor.setWeightingFactors(weights[0], weights[1], weights[2]);
+		Prefs.blackBackground = blackBackground;
+		Prefs.autoContrast = autoContrast;
+		Roi.setPasteMode(pasteMode);
+		PlotWindow.plotWidth = plotWidth;
+		PlotWindow.plotHeight = plotHeight;
+		PlotWindow.setDefaultFontSize(plotFontSize);
+		PlotWindow.interpolate = plotInterpolate;
+		PlotWindow.noGridLines = plotNoGridLines;
+		PlotWindow.noTicks = plotNoTicks;
+		Prefs.verticalProfile = profileVerticalProfile;
+		Prefs.subPixelResolution = profileSubPixelResolution;
+	}
+
+	void setKeyDown() {
+		String keys = getStringArg();
+		keys = keys.toLowerCase(Locale.US);
+		altKeyDown = keys.indexOf("alt")!=-1;
+		if (altKeyDown)
+			IJ.setKeyDown(KeyEvent.VK_ALT);
+		else
+			IJ.setKeyUp(KeyEvent.VK_ALT);
+		shiftKeyDown = keys.indexOf("shift")!=-1;
+		if (shiftKeyDown)
+			IJ.setKeyDown(KeyEvent.VK_SHIFT);
+		else
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);
+		boolean controlKeyDown = keys.indexOf("control")!=-1;
+		if (controlKeyDown)
+			IJ.setKeyDown(KeyEvent.VK_CONTROL);
+		else
+			IJ.setKeyUp(KeyEvent.VK_CONTROL);
+		if (keys.equals("space"))
+			IJ.setKeyDown(KeyEvent.VK_SPACE);
+		else
+			IJ.setKeyUp(KeyEvent.VK_SPACE);
+		if (keys.indexOf("esc")!=-1)
+			abortPluginOrMacro();
+		else
+			interp.keysSet = true;
+	}
+
+	void abortPluginOrMacro() {
+		Interpreter.abortPrevious();
+		IJ.setKeyDown(KeyEvent.VK_ESCAPE);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			ImageWindow win = imp.getWindow();
+			if (win!=null) {
+				win.running = false;
+				win.running2 = false;
+			}
+		}
+	}
+
+	void open() {
+		File f = null;
+		interp.getLeftParen();
+		if (interp.nextToken()==')') {
+			interp.getRightParen();
+			IJ.open();
+		} else {
+			double n = Double.NaN;
+			String options = null;
+			String path = getString();
+			f = new File(path);
+			if (interp.nextToken()==',') {
+				interp.getComma();
+				if (isStringArg())
+					options = getString();
+				else
+					n = interp.getExpression();
+			}
+			interp.getRightParen();
+			if (!Double.isNaN(n)) {
+				try {
+					IJ.open(path, (int)n);
+				} catch (Exception e) {
+					String msg = e.getMessage();
+					if (msg!=null&&msg.indexOf("canceled")==-1)
+						interp.error(""+msg);
+				}
+			} else {
+				if (f!=null&&f.isDirectory()) {
+					FolderOpener fo = new FolderOpener();
+					if (options!=null && options.contains("virtual"))
+						fo.openAsVirtualStack(true);
+					ImagePlus imp = fo.openFolder(path);
+					if (imp!=null) imp.show();
+				} else
+					IJ.open(path);
+			}
+			if (path!=null&&!path.equals("")&&f!=null) {
+				OpenDialog.setLastDirectory(f.getParent()+File.separator);
+				OpenDialog.setLastName(f.getName());
+			}
+		}
+		resetImage();
+	}
+
+	double roiManager() {
+		String cmd = getFirstString();
+		cmd = cmd.toLowerCase();
+		String path = null;
+		String color = null;
+		double lineWidth = 1.0;
+		int index=0;
+		double dx=0.0, dy=0.0;
+		double countOrIndex=Double.NaN;
+		boolean twoArgCommand = cmd.equals("open")||cmd.equals("save")||cmd.equals("rename")
+			||cmd.equals("set color")||cmd.equals("set fill color")||cmd.equals("set line width")
+			||cmd.equals("associate")||cmd.equals("centered")||cmd.equals("usenames")
+			||cmd.equals("save selected");
+		boolean select = cmd.equals("select");
+		boolean multiSelect = false;
+		boolean add = cmd.equals("add");
+		if (twoArgCommand)
+			path = getLastString();
+		else if (add) {
+			if (interp.nextToken()==',') {
+				interp.getComma();
+				color = interp.getString();
+			}
+			if (interp.nextToken()==',') {
+				interp.getComma();
+				lineWidth = interp.getExpression();
+			}
+			interp.getRightParen();
+		} else if (select) {
+			interp.getComma();
+			multiSelect = isArrayArg();
+			if (!multiSelect) {
+				index = (int)interp.getExpression();
+				interp.getRightParen();
+			}
+		} else if (cmd.equals("translate")) {
+			dx = getNextArg();
+			dy = getLastArg();
+		} else
+			interp.getRightParen();
+		if (RoiManager.getInstance()==null&&roiManager==null) {
+			if (Interpreter.isBatchMode())
+				roiManager = new RoiManager(true);
+			else
+				IJ.run("ROI Manager...");
+		}
+		RoiManager rm = roiManager!=null?roiManager:RoiManager.getInstance();
+		if (rm==null)
+			interp.error("ROI Manager not found");
+		if (multiSelect)
+			return setMultipleIndexes(rm);
+		if (twoArgCommand)
+			rm.runCommand(cmd, path);
+		else if (add)
+			rm.runCommand("Add", color, lineWidth);
+		else if (select) {
+			int n = rm.getCount();
+			checkIndex(index, 0, n-1);
+			if (shiftKeyDown || altKeyDown) {
+				rm.select(index, shiftKeyDown, altKeyDown);
+				shiftKeyDown = altKeyDown = false;
+			} else
+				rm.select(index);
+		} else if (cmd.equals("count")||cmd.equals("size"))
+			countOrIndex = rm.getCount();
+		else if (cmd.equals("index"))
+			countOrIndex = rm.getSelectedIndex();
+		else if (cmd.equals("translate")) {
+			rm.translate(dx, dy);
+			return Double.NaN;
+		} else {
+			if (!rm.runCommand(cmd))
+				interp.error("Invalid ROI Manager command");
+		}
+		return countOrIndex;
+	}
+
+	boolean isArrayArg() {
+		int nextToken = pgm.code[interp.pc+1];
+		int tok = nextToken&0xff;
+		if (tok==ARRAY_FUNCTION) return true;
+		if (tok!=WORD) return false;
+		Variable v = interp.lookupVariable(nextToken>>TOK_SHIFT);
+		if (v==null) return false;
+		int nextNextToken = pgm.code[interp.pc+2];
+		return v.getType()==Variable.ARRAY && nextNextToken!='[';
+	}
+
+	double setMultipleIndexes(RoiManager rm) {
+		if (interp.nextToken()==',')
+			interp.getComma();
+		double[] indexes = getNumericArray();
+		interp.getRightParen();
+		int[] selectedIndexes = new int[indexes.length];
+		int count = rm.getCount();
+		for (int i=0; i<indexes.length; i++) {
+			selectedIndexes[i] = (int)indexes[i];
+			if (selectedIndexes[i]<0 || selectedIndexes[i]>=count)
+				interp.error("Invalid index: "+selectedIndexes[i]);
+		}
+		rm.setSelectedIndexes(selectedIndexes);
+		return Double.NaN;
+	}
+
+	void setFont() {
+		String name = getFirstString();
+		int size = 0;
+		int style = 0;
+		if (name.equals("user")) {
+			name = TextRoi.getDefaultFontName();
+			size = TextRoi.getDefaultFontSize();
+			style = TextRoi.getDefaultFontStyle();
+			antialiasedText = TextRoi.isAntialiased();
+			interp.getRightParen();
+		} else {
+			size = (int)getNextArg();
+			antialiasedText = false;
+			if (interp.nextToken()==',') {
+				String styles = getLastString().toLowerCase();
+				if (styles.indexOf("bold")!=-1) style += Font.BOLD;
+				if (styles.indexOf("italic")!=-1) style += Font.ITALIC;
+				if (styles.indexOf("anti")!=-1) antialiasedText = true;
+			} else
+				interp.getRightParen();
+		}
+		font = new Font(name, style, size);
+		fontSet = false;
+	}
+
+	void getMinAndMax() {
+		Variable min = getFirstVariable();
+		Variable max = getLastVariable();
+		ImagePlus imp = getImage();
+		double v1 = imp.getDisplayRangeMin();
+		double v2 = imp.getDisplayRangeMax();
+		Calibration cal = imp.getCalibration();
+		v1 = cal.getCValue(v1);
+		v2 = cal.getCValue(v2);
+		min.setValue(v1);
+		max.setValue(v2);
+	}
+
+	void selectImage() {
+		interp.getLeftParen();
+		if (isStringArg()) {
+			String title = getString();
+			if (!isOpen(title))
+				interp.error("\""+title+"\" not found");
+			selectImage(title);
+			interp.getRightParen();
+		} else {
+			int id = (int)interp.getExpression();
+			if (WindowManager.getImage(id)==null)
+				interp.error("Image "+id+" not found");
+			IJ.selectWindow(id);
+			interp.getRightParen();
+		}
+		resetImage();
+		interp.selectCount++;
+	}
+
+	void selectImage(String title) {
+		if (Interpreter.isBatchMode()) {
+			if (Interpreter.imageTable!=null) {
+				for (Enumeration en=Interpreter.imageTable.elements(); en.hasMoreElements();) {
+					ImagePlus imp = (ImagePlus)en.nextElement();
+					if (imp!=null) {
+						if (imp.getTitle().equals(title)) {
+							ImagePlus imp2 = WindowManager.getCurrentImage();
+							if (imp2!=null && imp2!=imp) imp2.saveRoi();
+							WindowManager.setTempCurrentImage(imp);
+							Interpreter.activateImage(imp);
+							return;
+						}
+					}
+				}
+			}
+			selectWindowManagerImage(title);
+		} else
+			selectWindowManagerImage(title);
+	}
+
+	void notFound(String title) {
+		interp.error(title+" not found");
+	}
+
+	void selectWindowManagerImage(String title) {
+		long start = System.currentTimeMillis();
+		while (System.currentTimeMillis()-start<4000) { // 4 sec timeout
+			int[] wList = WindowManager.getIDList();
+			int len = wList!=null?wList.length:0;
+			for (int i=0; i<len; i++) {
+				ImagePlus imp = WindowManager.getImage(wList[i]);
+				if (imp!=null) {
+					if (imp.getTitle().equals(title)) {
+						IJ.selectWindow(imp.getID());
+						return;
+					}
+				}
+			}
+			IJ.wait(10);
+		}
+		notFound(title);
+	}
+
+	void close() {
+		String pattern = null;
+		boolean keep = false;
+
+		if (interp.nextToken() == '(') {
+			interp.getLeftParen();
+			if (interp.nextToken() != ')') {
+				pattern = getString();
+			}
+			if (interp.nextToken() == ',') {
+				interp.getComma();
+				keep = getString().equalsIgnoreCase("keep");
+			}
+			interp.getRightParen();
+		}
+		if (pattern == null) {//Wayne close front image
+			ImagePlus imp = getImage();
+			ImageWindow win = imp.getWindow();
+			if (win != null) {
+				imp.changes = false;
+				win.close();
+			} else {
+				imp.saveRoi();
+				WindowManager.setTempCurrentImage(null);
+				interp.removeBatchModeImage(imp);
+			}
+			resetImage();
+			return;
+		}
+
+		if (pattern != null) {//Norbert
+			if (pattern.equals("Results"))
+				resultsPending = false;
+			WildcardMatch wm = new WildcardMatch();
+			wm.setCaseSensitive(false);
+			String otherStr = "\\Others";
+			boolean others = pattern.equals(otherStr);
+			boolean hasWildcard = pattern.contains("*") || pattern.contains("?");
+			if (!others) {
+				//S c a n   N o n - i m a g e s
+				Window[] windows = WindowManager.getAllNonImageWindows();
+				String[] textExtension = ".txt .ijm .js .java .py .bs .csv .tsv".split(" ");
+				boolean isTextPattern = false;
+				for (int jj = 0; jj < textExtension.length; jj++) {
+					isTextPattern |= pattern.endsWith(textExtension[jj]);
+				}
+
+				if (!hasWildcard || isTextPattern) {//e.g. "Roi Manager", "Demo*.txt")
+					for (int win = 0; win < windows.length; win++) {
+						Window thisWin = windows[win];
+						if (thisWin instanceof ContrastAdjuster) {//B&C
+							if (pattern.equalsIgnoreCase("b&c")) {
+								((ContrastAdjuster) thisWin).close();
+							}
+						}
+						if (thisWin instanceof ColorPicker) {//CP
+							if (pattern.equalsIgnoreCase("cp")) {
+								((ColorPicker) thisWin).close();
+							}
+						}
+						if (thisWin instanceof ThresholdAdjuster) {//Threshold
+							if (pattern.equalsIgnoreCase("Threshold")) {
+								((ThresholdAdjuster) thisWin).close();
+							}
+						}
+						if (thisWin instanceof Editor) {//macros editor, loaded text files
+							Editor ed = (Editor) thisWin;
+							String title = ed.getTitle();
+							if (wm.match(title, pattern)) {
+								boolean leaveIt = false;
+								leaveIt = leaveIt || (ed.fileChanged() && keep);
+								leaveIt = leaveIt || !isTextPattern;
+								leaveIt = leaveIt || ed == Editor.currentMacroEditor;
+								if (!leaveIt) {
+									ed.close();
+								}
+							}
+						}
+
+						if (thisWin instanceof TextWindow) {//e.g.Results, Log
+							TextWindow txtWin = (TextWindow) thisWin;
+							String title = txtWin.getTitle();
+							if (wm.match(title, pattern)) {
+								if (title.equals("Results"))
+									IJ.run("Clear Results");
+								txtWin.close();
+							}
+
+						}
+						if (thisWin instanceof RoiManager && pattern.equalsIgnoreCase("roi manager")) {//ROI Manager
+							RoiManager rm = (RoiManager) thisWin;
+							rm.close();
+						}
+					}
+				}
+			}
+
+			//S c a n  i m a g e s
+			ImagePlus frontImp = WindowManager.getCurrentImage();
+			int[] ids = WindowManager.getIDList();
+			if (ids == null) {
+				resetImage();
+				return;
+			}
+			int nPics = ids.length;
+			String[] flaggedNames = new String[nPics];
+
+			for (int jj = 0; jj < nPics; jj++) {//add flags to names for debug
+				ImagePlus imp = WindowManager.getImage(ids[jj]);
+				String flags = "fcm_";//fcm = flags for  front, changed, match
+				String title = imp.getTitle();
+				if (imp.changes) {
+					flags = flags.replace("c", "C");
+				}
+				if (imp == WindowManager.getCurrentImage()) {
+					flags = flags.replace("f", "F");
+				}
+				if (others || wm.match(title, pattern)) {
+					flags = flags.replace("m", "M");
+				}
+				String fName = flags + imp.getTitle();
+				flaggedNames[jj] = fName;
+			}
+			boolean currentImpClosed = false;
+			for (int jj = 0; jj < nPics; jj++) {
+				String flags = flaggedNames[jj].substring(0, 4);
+				boolean M = flags.contains("M");//match
+				boolean F = flags.contains("F");//front
+				boolean C = flags.contains("C");//changed
+				boolean kill = M && !(C && keep);
+				if (others)
+					kill = !F && !(C && keep);
+
+				if (kill) {
+					ImagePlus imp = WindowManager.getImage(ids[jj]);
+					if (imp==null)
+						continue;
+					ImageWindow win = imp.getWindow();
+					if (win != null) {
+						imp.changes = false;
+						win.close();
+					} else {
+						imp.saveRoi();
+						WindowManager.setTempCurrentImage(null);
+						interp.removeBatchModeImage(imp);
+					}
+					imp.changes = false;
+					imp.close();
+					if (imp == frontImp) {
+						currentImpClosed = true;
+					}
+				}
+			}
+			if (!currentImpClosed && frontImp != null) {
+				IJ.selectWindow(frontImp.getID());
+			}
+			resetImage();
+		}
+	}
+
+ 	void setBatchMode() {
+		boolean enterBatchMode = false;
+		String sarg = null;
+		interp.getLeftParen();
+		if (isStringArg())
+			sarg = getString();
+		else {
+			double arg = interp.getBooleanExpression();
+			interp.checkBoolean(arg);
+			enterBatchMode = arg==1.0;
+		}
+		interp.getRightParen();
+		if (!interp.isBatchMode())
+			interp.calledMacro = false;
+		resetImage();
+		if (enterBatchMode)  { // true
+			if (interp.isBatchMode()) return;
+			interp.setBatchMode(true);
+			ImagePlus tmp = WindowManager.getTempCurrentImage();
+			if (tmp!=null)
+				Interpreter.addBatchModeImage(tmp);
+			return;
+		}
+		IJ.showProgress(0, 0);
+		ImagePlus imp2 = WindowManager.getCurrentImage();
+		WindowManager.setTempCurrentImage(null);
+		if (sarg==null) {  //false
+			interp.setBatchMode(false);
+			roiManager = null;
+			displayBatchModeImage(imp2);
+		} else if (sarg.equalsIgnoreCase("show")) {
+			if (imp2!=null) {
+				Interpreter.removeBatchModeImage(imp2);
+				Interpreter.setTempShowMode(true);
+				displayBatchModeImage(imp2);
+				Interpreter.setTempShowMode(false);
+			}
+		} else if (sarg.equalsIgnoreCase("hide")) {
+			interp.setBatchMode(true);
+			if (imp2!=null) {
+				ImageWindow win = imp2.getWindow();
+				if (win!=null) {
+					imp2.hide();
+					Interpreter.addBatchModeImage(imp2);
+				}
+				IJ.selectWindow(imp2.getID());
+			}
+		} else {
+			Vector v = Interpreter.imageTable;
+			if (v==null) return;
+			ImagePlus cImp = imp2;
+			interp.setBatchMode(false);
+			roiManager = null;
+			for (int i=0; i<v.size(); i++) {
+				imp2 = (ImagePlus)v.elementAt(i);
+				if (imp2!=null && imp2!=cImp)
+					displayBatchModeImage(imp2);
+			}
+			displayBatchModeImage(cImp);
+		}
+	}
+
+	void displayBatchModeImage(ImagePlus imp2) {
+		if (imp2!=null) {
+			ImageWindow win = imp2.getWindow();
+			if (win==null)
+				imp2.show();
+			else {
+				if (!win.isVisible()) win.show();
+				imp2.updateAndDraw();
+			}
+			Roi roi = imp2.getRoi();
+			if (roi!=null) imp2.setRoi(roi);
+		}
+	}
+
+	void setLocation() {
+		int x = (int)getFirstArg();
+		int y = (int)getNextArg();
+		int width=0, height=0;
+		if (interp.nextToken()==',') {
+			width = (int)getNextArg();
+			height = (int)getNextArg();
+		}
+		interp.getRightParen();
+		if (width==0 && height==0) {
+			Window win = WindowManager.getActiveWindow();
+			if (win!=null)
+				win.setLocation(x, y);
+		} else {
+			ImagePlus imp = getImage();
+			ImageWindow win = imp.getWindow();
+			if (win!=null)
+				win.setLocationAndSize(x, y, width, height);
+		}
+	}
+
+	void setSlice() {
+		int n = (int)getArg();
+		ImagePlus imp = getImage();
+		int nSlices = imp.getStackSize();
+		if (n==1 && nSlices==1)
+			return;
+		else if (n<1 || n>nSlices)
+			interp.error("Argument must be >=1 and <="+nSlices);
+		else {
+			if (imp.isHyperStack())
+				imp.setPosition(n);
+			else
+				imp.setSlice(n);
+		}
+		resetImage();
+	}
+
+	void newImage() {
+		String title = getFirstString();
+		String type = getNextString();
+		int width = (int)getNextArg();
+		int height = (int)getNextArg();
+		int depth = (int)getNextArg();
+		int c=-1, z=-1, t=-1;
+		if (interp.nextToken()==')')
+			interp.getRightParen();
+		else {
+			c = depth;
+			z = (int)getNextArg();
+			t = (int)getLastArg();
+		}
+		if (width<1 || height<1)
+			interp.error("Width or height < 1");
+		if (c<0)
+			IJ.newImage(title, type, width, height, depth);
+		else {
+			ImagePlus imp = IJ.createImage(title, type, width, height, c, z, t);
+			imp.show();
+		}
+		resetImage();
+	}
+
+	void saveAs() {
+		String format = getFirstString();
+		String path =  null;
+		boolean oneArg = false;
+		if (interp.nextToken()==',')
+			path = getLastString();
+		else {
+			interp.getRightParen();
+			oneArg = true;
+		}
+		if (oneArg && (format.contains(File.separator)||format.contains("/")))
+			IJ.save(format); // assume argument is a path
+		else
+			IJ.saveAs(format, path);
+	}
+
+	double getZoom() {
+		interp.getParens();
+		ImagePlus imp = getImage();
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null)
+			{interp.error("Image not displayed"); return 0.0;}
+		else
+			return ic.getMagnification();
+	}
+
+	void setAutoThreshold() {
+		String mString = null;
+		if (interp.nextToken()=='(') {
+			interp.getLeftParen();
+			if (isStringArg())
+				mString = getString();
+			interp.getRightParen();
+		}
+		ImagePlus img = getImage();
+		ImageProcessor ip = getProcessor();
+		if (ip instanceof ColorProcessor)
+			interp.error("Non-RGB image expected");
+		ip.setRoi(img.getRoi());
+		if (mString!=null) {
+			try {
+				if (mString.indexOf("stack")!=-1)
+					IJ.setAutoThreshold(img, mString);
+				else
+					ip.setAutoThreshold(mString);
+			} catch (Exception e) {
+				interp.error(""+e.getMessage());
+			}
+		} else
+			ip.setAutoThreshold(ImageProcessor.ISODATA2, ImageProcessor.RED_LUT);
+		img.updateAndDraw();
+		resetImage();
+	}
+
+	double parseDouble(String s) {
+			if (s==null) return 0.0;
+			s = s.trim();
+			if (s.indexOf(' ')!=-1) s = s.substring(0, s.indexOf(' '));
+			return Tools.parseDouble(s);
+	}
+
+	double parseInt() {
+		String s = getFirstString();
+		int radix = 10;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			radix = (int)interp.getExpression();
+			if (radix<2||radix>36) radix = 10;
+		}
+		interp.getRightParen();
+		double n;
+		try {
+			if (radix==10) {
+				n = parseDouble(s);
+				if (!Double.isNaN(n)) n = Math.round(n);
+			} else
+				n = Integer.parseInt(s, radix);
+		} catch (NumberFormatException e) {
+			n = Double.NaN;
+		}
+		return n;
+	}
+
+	void print() {
+		interp.inPrint = true;
+		String s = getFirstString();
+		if (interp.nextToken()==',') {
+			if (s.startsWith("[") && s.endsWith("]")) {
+				printToWindow(s);
+				return;
+			} else if (s.equals("~0~")) {
+				if (writer==null)
+					interp.error("File not open");
+                String s2 = getLastString();
+                if (s2.endsWith("\n"))
+                    writer.print(s2);
+                else
+                    writer.println(s2);
+				interp.inPrint = false;
+				return;
+			}
+			StringBuffer sb = new StringBuffer(s);
+			do {
+				sb.append(" ");
+				sb.append(getNextString());
+			} while (interp.nextToken()==',');
+			s = sb.toString();
+		}
+		interp.getRightParen();
+		interp.log(s);
+		interp.inPrint = false;
+	}
+
+	void printToWindow(String s) {
+		String title = s.substring(1, s.length()-1);
+		String s2 = getLastString();
+		boolean isCommand = s2.startsWith("\\");
+		Frame frame = WindowManager.getFrame(title);
+		if (frame==null)
+			interp.error("Window not found");
+		boolean isEditor = frame instanceof Editor;
+		if (!(isEditor || frame instanceof TextWindow))
+			interp.error("Window is not text window");
+		if (isEditor) {
+			Editor ed = (Editor)frame;
+			ed.setIsMacroWindow(true);
+			if (isCommand)
+				handleEditorCommand(ed, s2);
+			else
+				ed.append(s2);
+		} else {
+			TextWindow tw = (TextWindow)frame;
+			if (isCommand)
+				handleTextWindowCommand(tw, s2);
+			else {
+				tw.append(s2);
+				TextPanel tp = tw.getTextPanel();
+				if (tp!=null) tp.setResultsTable(null);
+			}
+		}
+	}
+
+	void handleEditorCommand(Editor ed, String s) {
+		if (s.startsWith("\\Update:")) {
+			TextArea ta = ed.getTextArea();
+			ta.setText(s.substring(8, s.length()));
+			ta.setEditable(false);
+		} else if (s.equals("\\Close"))
+			ed.close();
+		else
+			ed.append(s);
+	}
+
+	void handleTextWindowCommand(TextWindow tw, String s) {
+		TextPanel tp = tw.getTextPanel();
+		if (s.startsWith("\\Update:")) {
+			int n = tp.getLineCount();
+			String s2 = s.substring(8, s.length());
+			if (n==0)
+				tp.append(s2);
+			else
+				tp.setLine(n-1, s2);
+		} else if (s.startsWith("\\Update")) {
+			int cindex = s.indexOf(":");
+			if (cindex==-1)
+				{tp.append(s); return;}
+			String nstr = s.substring(7, cindex);
+			int line = (int)Tools.parseDouble(nstr, -1);
+			if (line<0) interp.error("Row index<0 or NaN");
+			int count = tp.getLineCount();
+			while (line>=count) {
+				tp.append("");
+				count++;
+			}
+			String s2 = s.substring(cindex+1, s.length());
+			tp.setLine(line, s2);
+		} else if (s.equals("\\Clear"))
+			tp.clear();
+		else if (s.equals("\\Close"))
+			tw.close();
+		else if (s.startsWith("\\Headings:"))
+			tp.setColumnHeadings(s.substring(10));
+		else
+			tp.append(s);
+	}
+
+
+	double isKeyDown() {
+		double value = 0.0;
+		String key = getStringArg().toLowerCase(Locale.US);
+		if (key.indexOf("alt")!=-1) value = IJ.altKeyDown()==true?1.0:0.0;
+		else if (key.indexOf("shift")!=-1) value = IJ.shiftKeyDown()==true?1.0:0.0;
+		else if (key.indexOf("space")!=-1) value = IJ.spaceBarDown()==true?1.0:0.0;
+		else if (key.indexOf("control")!=-1) value = IJ.controlKeyDown()==true?1.0:0.0;
+		else interp.error("Invalid key");
+		return value;
+	}
+
+	String runMacro(boolean eval) {
+		interp.getLeftParen();
+		String name = getString();
+		String arg = null;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			arg = getString();
+		}
+		interp.getRightParen();
+		if (eval) {
+			if (arg!=null && (name.equals("script")||name.equals("js")))
+				return (new Macro_Runner()).runJavaScript(arg, "");
+			else if (arg!=null && (name.equals("bsh")))
+				return Macro_Runner.runBeanShell(arg,"");
+			else if (arg!=null && (name.equals("python")))
+				return Macro_Runner.runPython(arg,"");
+			else
+				return IJ.runMacro(name, arg);
+		} else
+			return IJ.runMacroFile(name, arg);
+	}
+
+	void setThreshold() {
+		double lower = getFirstArg();
+		double upper = getNextArg();
+		String mode = null;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			mode = getString();
+		}
+		interp.getRightParen();
+		IJ.setThreshold(lower, upper, mode);
+		resetImage();
+	}
+
+	void drawOrFill(int type) {
+		int x = (int)getFirstArg();
+		int y = (int)getNextArg();
+		int width = (int)getNextArg();
+		int height = (int)getLastArg();
+		ImageProcessor ip = getProcessor();
+		switch (type) {
+			case DRAW_RECT: ip.drawRect(x, y, width, height); break;
+			case FILL_RECT: ip.setRoi(x, y, width, height); ip.fill(); break;
+			case DRAW_OVAL: ip.drawOval(x, y, width, height); break;
+			case FILL_OVAL: ip.fillOval(x, y, width, height); break;
+		}
+		updateAndDraw();
+	}
+
+	double getScreenDimension(int type) {
+		interp.getParens();
+		Dimension screen = IJ.getScreenSize();
+		if (type==SCREEN_WIDTH)
+			return screen.width;
+		else
+			return screen.height;
+	}
+
+	void getStatistics(boolean calibrated) {
+		Variable count = getFirstVariable();
+		Variable mean=null, min=null, max=null, std=null, hist=null;
+		int params = AREA+MEAN+MIN_MAX;
+		interp.getToken();
+		int arg = 1;
+		while (interp.token==',') {
+			arg++;
+			switch (arg) {
+				case 2: mean = getVariable(); break;
+				case 3: min = getVariable(); break;
+				case 4: max = getVariable(); break;
+				case 5: std = getVariable(); params += STD_DEV; break;
+				case 6: hist = getArrayVariable(); break;
+				default: interp.error("')' expected");
+			}
+			interp.getToken();
+		}
+		if (interp.token!=')') interp.error("')' expected");
+		ImagePlus imp = getImage();
+		Calibration cal = calibrated?imp.getCalibration():null;
+		ImageProcessor ip = getProcessor();
+		ImageStatistics stats = null;
+		Roi roi = imp.getRoi();
+		int lineWidth = Line.getWidth();
+		if (roi!=null && roi.isLine() && lineWidth>1) {
+			ImageProcessor ip2;
+			if (roi.getType()==Roi.LINE) {
+				ip2 = ip;
+				Rectangle saveR = ip2.getRoi();
+				ip2.setRoi(roi.getPolygon());
+				stats = ImageStatistics.getStatistics(ip2, params, cal);
+				ip2.setRoi(saveR);
+			} else {
+				ip2 = (new Straightener()).straightenLine(imp, lineWidth);
+				stats = ImageStatistics.getStatistics(ip2, params, cal);
+			}
+		} else if (roi!=null && roi.isLine()) {
+			ProfilePlot profile = new ProfilePlot(imp);
+			double[] values = profile.getProfile();
+			ImageProcessor ip2 = new FloatProcessor(values.length, 1, values);
+			if (roi instanceof Line) {
+				Line l = (Line)roi;
+				if ((l.y1==l.y2||l.x1==l.x2)&&l.x1==l.x1d&& l.y1==l.y1d&& l.x2==l.x2d&& l.y2==l.y2d)
+					ip2.setRoi(0, 0, ip2.getWidth()-1, 1);
+			}
+			stats = ImageStatistics.getStatistics(ip2, params, cal);
+		} else {
+			ip.setRoi(roi);
+			stats = ImageStatistics.getStatistics(ip, params, cal);
+		}
+		if (calibrated)
+			count.setValue(stats.area);
+		else
+			count.setValue(stats.pixelCount);
+		if (mean!=null) mean.setValue(stats.mean);
+		if (min!=null) min.setValue(stats.min);
+		if (max!=null) max.setValue(stats.max);
+		if (std!=null) std.setValue(stats.stdDev);
+		if (hist!=null) {
+			boolean is16bit = !calibrated && ip instanceof ShortProcessor && stats.histogram16!=null;
+			int[] histogram = is16bit?stats.histogram16:stats.histogram;
+		    int bins = is16bit?(int)(stats.max+1):histogram.length;
+			Variable[] array = new Variable[bins];
+			int hmax = is16bit?(int)stats.max:255;
+			for (int i=0; i<=hmax; i++)
+				array[i] = new Variable(histogram[i]);
+			hist.setArray(array);
+		}
+	}
+
+	String replace(String s1) {
+		s1 = getStringFunctionArg(s1);
+		String s2 = getString();
+		String s3 = getLastString();
+		if (s2.length()==1) {
+			StringBuilder sb = new StringBuilder(s1.length());
+			for (int i=0; i<s1.length(); i++) {
+				char c = s1.charAt(i);
+				if (c==s2.charAt(0))
+					sb.append(s3);
+				else
+					sb.append(c);
+			}
+			return sb.toString();
+		} else {
+			try {
+				return s1.replaceAll(s2, s3);
+			} catch (Exception e) {
+				interp.error(""+e);
+				return null;
+			}
+		}
+	}
+
+	String trim() {
+		if (interp.nextToken()=='=')
+			interp.error("'trim' is a reserved word");
+		return getStringArg().trim();
+	}
+
+	void floodFill() {
+		int x = (int)getFirstArg();
+		int y = (int)getNextArg();
+		boolean fourConnected = true;
+		if (interp.nextToken()==',') {
+			String s = getLastString();
+			if (s.indexOf("8")!=-1)
+				fourConnected = false;
+		} else
+			interp.getRightParen();
+		ImageProcessor ip = getProcessor();
+		FloodFiller ff = new FloodFiller(ip);
+		if (fourConnected)
+			ff.fill(x, y);
+		else
+			ff.fill8(x, y);
+		updateAndDraw();
+		if (Recorder.record && pgm.hasVars)
+			Recorder.record("floodFill", x, y);
+	}
+
+	void restorePreviousTool() {
+		interp.getParens();
+		Toolbar tb = Toolbar.getInstance();
+		if (tb!=null) tb.restorePreviousTool();
+	}
+
+	void setVoxelSize() {
+		double width = getFirstArg();
+		double height = getNextArg();
+		double depth = getNextArg();
+		String unit = getLastString();
+		ImagePlus imp = getImage();
+		Calibration cal = imp.getCalibration();
+		cal.pixelWidth = width;
+		cal.pixelHeight = height;
+		cal.pixelDepth = depth;
+		cal.setUnit(unit);
+		imp.repaintWindow();
+	}
+
+	void getLocationAndSize() {
+		Variable v1 = getFirstVariable();
+		Variable v2 = getNextVariable();
+		Variable v3 = getNextVariable();
+		Variable v4 = getLastVariable();
+		ImagePlus imp = getImage();
+		int x=0, y=0, w=0, h=0;
+		ImageWindow win = imp.getWindow();
+		if (win!=null) {
+			Point loc = win.getLocation();
+			Dimension size = win.getSize();
+			x=loc.x; y=loc.y; w=size.width; h=size.height;
+		}
+		v1.setValue(x);
+		v2.setValue(y);
+		v3.setValue(w);
+		v4.setValue(h);
+	}
+
+	String doDialog() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD || interp.token==STRING_FUNCTION || interp.token==NUMERIC_FUNCTION || interp.token==PREDEFINED_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		try {
+			if (name.equals("create")) {
+				gd = new GenericDialog(getStringArg());
+				return null;
+			} else if (name.equals("createNonBlocking")) {
+				gd = new NonBlockingGenericDialog(getStringArg());
+				return null;
+			}
+			if (gd==null) {
+				interp.error("No dialog created with Dialog.create()");
+				return null;
+			}
+			if (name.equals("addString")) {
+				String label = getFirstString();
+				String defaultStr = getNextString();
+				int columns = 8;
+				if (interp.nextToken()==',')
+					columns = (int)getNextArg();
+				interp.getRightParen();
+				gd.addStringField(label, defaultStr, columns);
+			} else if (name.equals("addDirectory")) {
+				String label = getFirstString();
+				String defaultDir = getLastString();
+				gd.addDirectoryField(label, defaultDir);
+			} else if (name.equals("addImageChoice")) {
+				String label = getStringArg();
+				if (WindowManager.getImageCount()==0)
+					interp.error("No images");
+				gd.addImageChoice(label, null);
+			} else if (name.equals("addFile")) {
+				String label = getFirstString();
+				String defaultPath = getLastString();
+				gd.addFileField(label, defaultPath);
+			} else if (name.equals("addNumber")) {
+				int columns = 6;
+				String units = null;
+				String prompt = getFirstString();
+				double defaultNumber = getNextArg();
+				int decimalPlaces = (int)defaultNumber==defaultNumber?0:3;
+				if (interp.nextToken()==',') {
+					decimalPlaces = (int)getNextArg();
+					columns = (int)getNextArg();
+					units = getLastString();
+				} else
+					interp.getRightParen();
+				gd.addNumericField(prompt, defaultNumber, decimalPlaces, columns, units);
+			} else if (name.equals("addSlider")) {
+				String label = getFirstString();
+				double minValue = getNextArg();
+				double maxValue = getNextArg();
+				double defaultValue = getNextArg();
+				double stepSize = 0.0;
+				if (interp.nextToken()==',') {
+					interp.getComma();
+					stepSize = interp.getExpression();
+				}
+				interp.getRightParen();
+				if (stepSize==0.0)
+					gd.addSlider(label, minValue, maxValue, defaultValue);
+				else
+					gd.addSlider(label, minValue, maxValue, defaultValue, stepSize);
+			} else if (name.equals("addCheckbox")) {
+				gd.addCheckbox(getFirstString(), getLastArg()==1?true:false);
+			} else if (name.equals("addCheckboxGroup")) {
+				addCheckboxGroup(gd);
+			} else if (name.equals("addRadioButtonGroup")) {
+				addRadioButtonGroup(gd);
+			} else if (name.equals("addMessage")) {
+				String msg = getFirstString();
+				Font font = null;
+				Color color = null;
+				if (interp.nextToken()==',') {
+					interp.getComma();
+					int fontSize = (int)interp.getExpression();
+					if (interp.nextToken()==',') {
+						interp.getComma();
+						String colorName = interp.getString();
+						color = Colors.decode(colorName, Color.BLACK);
+					}
+					font = new Font("SansSerif", Font.PLAIN, fontSize);
+				}
+				interp.getRightParen();
+				gd.addMessage(msg, font, color);
+			} else if (name.equals("addHelp")) {
+				gd.addHelp(getStringArg());
+			} else if (name.equals("addChoice")) {
+				String prompt = getFirstString();
+				interp.getComma();
+				String[] choices = getStringArray();
+				String defaultChoice = null;
+				if (interp.nextToken()==',') {
+					interp.getComma();
+					defaultChoice = getString();
+				} else
+					defaultChoice = choices[0];
+				interp.getRightParen();
+				gd.addChoice(prompt, choices, defaultChoice);
+			} else if (name.equals("setInsets")) {
+				gd.setInsets((int)getFirstArg(), (int)getNextArg(), (int)getLastArg());
+			} else if (name.equals("addToSameRow")) {
+				interp.getParens();
+				gd.addToSameRow();
+			} else if (name.equals("setLocation")) {
+				gd.setLocation((int)getFirstArg(), (int)getLastArg());
+			} else if (name.equals("show")) {
+				interp.getParens();
+				gd.showDialog();
+				if (gd.wasCanceled()) {
+					interp.finishUp();
+					throw new RuntimeException(Macro.MACRO_CANCELED);
+				}
+			} else if (name.equals("getString")) {
+				interp.getParens();
+				return gd.getNextString();
+			} else if (name.equals("getNumber")) {
+				interp.getParens();
+				return ""+gd.getNextNumber();
+			} else if (name.equals("getCheckbox")) {
+				interp.getParens();
+				return gd.getNextBoolean()==true?"1":"0";
+			} else if (name.equals("getChoice")) {
+				interp.getParens();
+				return gd.getNextChoice();
+			} else if (name.equals("getImageChoice")) {
+				interp.getParens();
+				ImagePlus imp = gd.getNextImage();
+				return imp.getTitle();
+			} else if (name.equals("getRadioButton")) {
+				interp.getParens();
+				return gd.getNextRadioButton();
+			} else
+				interp.error("Unrecognized Dialog function "+name);
+		} catch (IndexOutOfBoundsException e) {
+			interp.error("Dialog error");
+		}
+		return null;
+	}
+
+	void addCheckboxGroup(GenericDialog gd) {
+		int rows = (int)getFirstArg();
+		int columns = (int)getNextArg();
+		interp.getComma();
+		String[] labels = getStringArray();
+		int n = labels.length;
+		double[] dstates = getLastArray();
+		if (n!=dstates.length)
+			interp.error("labels.length!=states.length");
+		boolean[] states = new boolean[n];
+		for (int i=0; i<n; i++)
+			states[i] = dstates[i]==1.0?true:false;
+		gd.addCheckboxGroup(rows, columns, labels, states);
+	}
+
+	void addRadioButtonGroup(GenericDialog gd) {
+		String label = getFirstString();
+		interp.getComma();
+		String[] items = getStringArray();
+		int rows = (int)getNextArg();
+		int columns = (int)getNextArg();
+		String defaultItem = getLastString();
+		gd.addRadioButtonGroup(label, items, rows, columns, defaultItem);
+	}
+
+	void getDateAndTime() {
+		Variable year = getFirstVariable();
+		Variable month = getNextVariable();
+		Variable dayOfWeek = getNextVariable();
+		Variable dayOfMonth = getNextVariable();
+		Variable hour = getNextVariable();
+		Variable minute = getNextVariable();
+		Variable second = getNextVariable();
+		Variable millisecond = getLastVariable();
+		Calendar date = Calendar.getInstance();
+		year.setValue(date.get(Calendar.YEAR));
+		month.setValue(date.get(Calendar.MONTH));
+		dayOfWeek.setValue(date.get(Calendar.DAY_OF_WEEK)-1);
+		dayOfMonth.setValue(date.get(Calendar.DAY_OF_MONTH));
+		hour.setValue(date.get(Calendar.HOUR_OF_DAY));
+		minute.setValue(date.get(Calendar.MINUTE));
+		second.setValue(date.get(Calendar.SECOND));
+		millisecond.setValue(date.get(Calendar.MILLISECOND));
+	}
+
+	void setMetadata() {
+		String metadata = null;
+		String arg1 = getFirstString();
+		if (interp.nextToken()==',')
+			metadata = getLastString();
+		else
+			interp.getRightParen();
+		ImagePlus imp = getImage();
+		boolean isInfo = false;
+		if (metadata==null) { // one argument
+			metadata = arg1;
+			if (imp.getStackSize()==1)
+				isInfo = true;
+			if (metadata.startsWith("Info:")) {
+				metadata = metadata.substring(5);
+				isInfo = true;
+			}
+		} else
+			isInfo = arg1.startsWith("info") || arg1.startsWith("Info");
+		if (metadata!=null && metadata.length()==0)
+			metadata = null;
+		if (isInfo)
+			imp.setProperty("Info", metadata);
+		else {
+			imp.getStack().setSliceLabel(metadata, imp.getCurrentSlice());
+			if (!Interpreter.isBatchMode()) imp.repaintWindow();
+		}
+	}
+
+	String getMetadata() {
+		String type = "info";
+		ImagePlus imp = getImage();
+		if (interp.nextToken()=='(' && interp.nextNextToken()!=')')
+			type = getStringArg().toLowerCase(Locale.US);
+		else {  // no arg
+			interp.getParens();
+			type = imp.getStackSize()>1?"label":"info";
+		}
+		String metadata = null;
+		if (type.contains("info")) {
+			metadata = (String)imp.getProperty("Info");
+			if (metadata==null && imp.getStackSize()>1)
+				metadata = imp.getStack().getSliceLabel(imp.getCurrentSlice());
+		} else
+			metadata = imp.getStack().getSliceLabel(imp.getCurrentSlice());
+		if (metadata==null)
+			metadata = "";
+		return metadata;
+	}
+
+	ImagePlus getImageArg() {
+		ImagePlus img = null;
+		if (isStringArg()) {
+			String title = getString();
+			img = WindowManager.getImage(title);
+		} else {
+			int id = (int)interp.getExpression();
+			img = WindowManager.getImage(id);
+		}
+		if (img==null) interp.error("Image not found");
+		return img;
+	}
+
+	void imageCalculator() {
+		String operator = getFirstString();
+		interp.getComma();
+		ImagePlus img1 = getImageArg();
+		interp.getComma();
+		ImagePlus img2 = getImageArg();
+		interp.getRightParen();
+		ImageCalculator ic = new ImageCalculator();
+		ic.calculate(operator, img1, img2);
+		resetImage();
+	}
+
+	void setRGBWeights() {
+		double r = getFirstArg();
+		double g = getNextArg();
+		double b = getLastArg();
+		if (interp.rgbWeights==null)
+			interp.rgbWeights = ColorProcessor.getWeightingFactors();
+		ColorProcessor.setWeightingFactors(r, g, b);
+	}
+
+	private void makePolygon() {
+		Polygon points = new Polygon();
+		points.addPoint((int)Math.round(getFirstArg()), (int)Math.round(getNextArg()));
+		interp.getToken();
+		while (interp.token==',') {
+			int x = (int)Math.round(interp.getExpression());
+			interp.getComma();
+			int y = (int)Math.round(interp.getExpression());
+			points.addPoint(x,y);
+			interp.getToken();
+		}
+		if (points.npoints<3)
+			interp.error("Fewer than 3 points");
+		ImagePlus imp = getImage();
+		Roi previousRoi = imp.getRoi();
+		if (shiftKeyDown||altKeyDown) imp.saveRoi();
+		imp.setRoi(new PolygonRoi(points, Roi.POLYGON));
+		Roi roi = imp.getRoi();
+		if (previousRoi!=null && roi!=null)
+			updateRoi(roi);
+		resetImage();
+		shiftKeyDown = altKeyDown = false;
+	}
+
+	void updateRoi(Roi roi) {
+		if (shiftKeyDown || altKeyDown)
+			roi.update(shiftKeyDown, altKeyDown);
+		shiftKeyDown = altKeyDown = false;
+	}
+
+	String doFile() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD || interp.token==STRING_FUNCTION || interp.token==NUMERIC_FUNCTION || interp.token==PREDEFINED_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("open"))
+			return openFile();
+		else if (name.equals("openAsString"))
+			return openAsString();
+		else if (name.equals("openAsRawString"))
+			return openAsRawString();
+		else if (name.equals("openUrlAsString"))
+			return IJ.openUrlAsString(getStringArg());
+		else if (name.equals("openDialog"))
+			return openDialog();
+		else if (name.equals("close"))
+			return closeFile();
+		else if (name.equals("separator")) {
+			interp.getParens();
+			return File.separator;
+		} else if (name.equals("directory")) {
+			interp.getParens();
+			String lastDir = OpenDialog.getLastDirectory();
+			return lastDir!=null?lastDir:"";
+		} else if (name.equals("name")) {
+			interp.getParens();
+			String lastName = OpenDialog.getLastName();
+			return lastName!=null?lastName:"";
+		} else if (name.equals("nameWithoutExtension")) {
+			interp.getParens();
+			return nameWithoutExtension();
+		} else if (name.equals("rename")) {
+			File f1 = new File(getFirstString());
+			File f2 = new File(getLastString());
+			if (checkPath(f1) && checkPath(f2))
+				return f1.renameTo(f2)?"1":"0";
+			else
+				return "0";
+		} else if (name.equals("copy")) {
+			String f1 = getFirstString();
+			String f2 = getLastString();
+			String err = Tools.copyFile(f1, f2);
+			if (err.length()>0)
+				interp.error(err);
+			return null;
+		} else if (name.equals("append")) {
+			String err = IJ.append(getFirstString(), getLastString());
+			if (err!=null) interp.error(err);
+			return null;
+		} else if (name.equals("saveString")) {
+			String err = IJ.saveString(getFirstString(), getLastString());
+			if (err!=null) interp.error(err);
+			return null;
+		} else if (name.startsWith("setDefaultDir")) {
+			OpenDialog.setDefaultDirectory(getStringArg());
+			return null;
+		} else if (name.startsWith("getDefaultDir")) {
+			String dir = OpenDialog.getDefaultDirectory();
+			return dir!=null?dir:"";
+		}
+
+		File f = new File(getStringArg());
+		if (name.equals("getLength")||name.equals("length"))
+			return ""+f.length();
+		else if (name.equals("getNameWithoutExtension")) {
+			String name2 =  f.getName();
+			int dotIndex = name2.lastIndexOf(".");
+			if (dotIndex>=0)
+				name2 = name2.substring(0, dotIndex);
+			return name2;
+		} else if (name.equals("getName")) {
+			return f.getName();
+		} else if (name.equals("getDirectory")) {
+			String parent = f.getParent();
+			return parent!=null?parent.replaceAll("\\\\", "/")+"/":"";
+		} else if (name.equals("getAbsolutePath"))
+			return f.getAbsolutePath();
+		else if (name.equals("getParent"))
+			return f.getParent();
+		else if (name.equals("exists"))
+			return f.exists()?"1":"0";
+		else if (name.equals("isDirectory"))
+			return f.isDirectory()?"1":"0";
+		else if (name.equals("isFile"))
+			return f.isFile()?"1":"0";
+		else if (name.equals("makeDirectory")||name.equals("mkdir")) {
+			f.mkdir(); return null;
+		} else if (name.equals("lastModified"))
+			return ""+f.lastModified();
+		else if (name.equals("dateLastModified"))
+			return (new Date(f.lastModified())).toString();
+		else if (name.equals("delete")) {
+			return f.delete()?"1":"0";
+		} else
+			interp.error("Unrecognized File function "+name);
+		return null;
+	}
+
+	String nameWithoutExtension() {
+		String name = OpenDialog.getLastName();
+		if (name==null) return "";
+		int dotIndex = name.lastIndexOf(".");
+		if (dotIndex>=0 && (name.length()-dotIndex)<=5)
+			name = name.substring(0, dotIndex);
+		return name;
+	}
+
+	boolean checkPath(File f) {
+		String path = f.getPath();
+		if (path.equals("0") || path.equals("NaN")) {
+				interp.error("Invalid path");
+				return false;
+		} else
+			return true;
+	}
+
+	String openDialog() {
+		String title = getStringArg();
+		OpenDialog od = new OpenDialog(title, null);
+		String directory = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+			return "";
+		else
+			return directory+name;
+	}
+
+	void setSelectionName() {
+		Roi roi = getImage().getRoi();
+		if (roi==null)
+			interp.error("No selection");
+		else
+			roi.setName(getStringArg());
+	}
+
+	String selectionName() {
+		Roi roi = getImage().getRoi();
+		String name = null;
+		if (roi==null)
+			interp.error("No selection");
+		else
+			name = roi.getName();
+		return name!=null?name:"";
+	}
+
+	String openFile() {
+		if (writer!=null) {
+			interp.error("Currently, only one file can be open at a time");
+			return"";
+		}
+		String path = getFirstString();
+		String defaultName = null;
+		if (interp.nextToken()==')')
+			interp.getRightParen();
+		else
+			defaultName = getLastString();
+		if (path.equals("") || defaultName!=null) {
+			String title = defaultName!=null?path:"openFile";
+			defaultName = defaultName!=null?defaultName:"log.txt";
+			SaveDialog sd = new SaveDialog(title, defaultName, ".txt");
+			if (sd.getFileName()==null) return "";
+			path = sd.getDirectory()+sd.getFileName();
+		} else {
+			File file = new File(path);
+			if (file.exists() && !(path.endsWith(".txt")||path.endsWith(".java")||path.endsWith(".xls")
+			||path.endsWith(".csv")||path.endsWith(".tsv")||path.endsWith(".ijm")
+			||path.endsWith(".html")||path.endsWith(".htm")))
+				interp.error("File exists and suffix is not '.txt', '.java', etc.");
+		}
+		try {
+			FileOutputStream fos = new FileOutputStream(path);
+			BufferedOutputStream bos = new BufferedOutputStream(fos);
+			writer = new PrintWriter(bos);
+		}
+		catch (IOException e) {
+			interp.error("File open error \n\""+e.getMessage()+"\"\n");
+			return "";
+		}
+		return "~0~";
+	}
+
+	String openAsString() {
+		String path = getStringArg();
+		String str = IJ.openAsString(path);
+		if (str==null)
+			interp.done = true;
+		else if (str.startsWith("Error: "))
+			interp.error(str);
+		return str;
+	}
+
+	String openAsRawString() {
+		int max = 5000;
+		String path = getFirstString();
+		boolean specifiedMax = false;
+		if (interp.nextToken()==',') {
+			max = (int)getNextArg();
+			specifiedMax = true;
+		}
+		interp.getRightParen();
+		if (path.equals("")) {
+			OpenDialog od = new OpenDialog("Open As String", "");
+			String directory = od.getDirectory();
+			String name = od.getFileName();
+			if (name==null) return "";
+			path = directory + name;
+		}
+		String str = "";
+		File file = new File(path);
+		if (!file.exists())
+			interp.error("File not found");
+		try {
+			StringBuffer sb = new StringBuffer(5000);
+			int len = (int)file.length();
+			if (max>len || (path.endsWith(".txt")&&!specifiedMax))
+				max = len;
+			InputStream in = new BufferedInputStream(new FileInputStream(path));
+			DataInputStream dis = new DataInputStream(in);
+			byte[] buffer = new byte[max];
+			dis.readFully(buffer);
+			dis.close();
+			char[] buffer2 = new char[buffer.length];
+			for (int i=0; i<buffer.length; i++)
+				buffer2[i] = (char)(buffer[i]&255);
+			str = new String(buffer2);
+		}
+		catch (Exception e) {
+			interp.error("File open error \n\""+e.getMessage()+"\"\n");
+		}
+		return str;
+	}
+
+	String closeFile() {
+		String f = getStringArg();
+		if (!f.equals("~0~"))
+			interp.error("Invalid file variable");
+		if (writer!=null) {
+			writer.close();
+			writer = null;
+		}
+		return null;
+	}
+
+	public static String copyFile(File f1, File f2) {
+		return Tools.copyFile(f1.getPath(), f2.getPath());
+	}
+
+	// Calls a public static method with an arbitrary number
+	// of String parameters, returning a String.
+	// Contributed by Johannes Schindelin
+	String call() {
+		// get class and method name
+		String fullName = getFirstString();
+		int dot = fullName.lastIndexOf('.');
+		if(dot<0) {
+			interp.error("'classname.methodname' expected");
+			return null;
+		}
+		String className = fullName.substring(0,dot);
+		String methodName = fullName.substring(dot+1);
+
+		// get optional string arguments
+		Object[] args = null;
+		if (interp.nextToken()==',') {
+			Vector vargs = new Vector();
+			do
+				vargs.add(getNextString());
+			while (interp.nextToken()==',');
+			args = vargs.toArray();
+		}
+		interp.getRightParen();
+		if (args==null) args = new Object[0];
+
+		// get the class
+		Class c;
+		try {
+			c = IJ.getClassLoader().loadClass(className);
+		} catch(Exception ex) {
+			interp.error("Could not load class "+className);
+			return null;
+		}
+
+		// get method
+		Method m;
+		try {
+			Class[] argClasses = null;
+			if (args.length>0) {
+				argClasses = new Class[args.length];
+				for(int i=0;i<args.length;i++)
+					argClasses[i] = args[i].getClass();
+			}
+			m = c.getMethod(methodName,argClasses);
+		} catch(Exception ex) {
+			m = null;
+		}
+		if (m==null && args.length>0) {
+			try {
+				Class[] argClasses = new Class[args.length];
+				for(int i=0;i<args.length;i++) {
+					double value = Tools.parseDouble((String)args[i]);
+					if (!Double.isNaN(value)) {
+						args[i] = new Integer((int)value);
+						argClasses[i] = int.class;
+					} else
+						argClasses[i] = args[i].getClass();
+				}
+				m = c.getMethod(methodName,argClasses);
+			} catch(Exception ex) {
+				m = null;
+			}
+		}
+		if (m==null)
+			interp.error("Could not find the method "+methodName+" with "+
+				     args.length+" parameter(s) in class "+className);
+
+		try {
+			Object obj = m.invoke(null, args);
+			return obj!=null?obj.toString():null;
+		} catch(InvocationTargetException e) {
+			CharArrayWriter caw = new CharArrayWriter();
+			PrintWriter pw = new PrintWriter(caw);
+			e.getCause().printStackTrace(pw);
+			String s = caw.toString();
+			if (IJ.getInstance()!=null)
+				new TextWindow("Exception", s, 400, 400);
+			else
+				IJ.log(s);
+			return null;
+		} catch(Exception e) {
+			IJ.log("Call error ("+e+")");
+			return null;
+		}
+
+ 	}
+
+ 	Variable[] getFontList() {
+		interp.getParens();
+		String fonts[] = null;
+		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+		fonts = ge.getAvailableFontFamilyNames();
+		if (fonts==null) return null;
+    	Variable[] array = new Variable[fonts.length];
+    	for (int i=0; i<fonts.length; i++)
+    		array[i] = new Variable(0, 0.0, fonts[i]);
+    	return array;
+	}
+
+	void setOption() {
+		String arg1 = getFirstString();
+		boolean state = true;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			double arg2 = interp.getBooleanExpression();
+			interp.checkBoolean(arg2);
+			state = arg2==0?false:true;
+		}
+		interp.getRightParen();
+		arg1 = arg1.toLowerCase(Locale.US);
+		if (arg1.equals("disablepopupmenu")) {
+			ImageCanvas ic = getImage().getCanvas();
+			if (ic!=null) ic.disablePopupMenu(state);
+		} else if (arg1.startsWith("show all")) {
+			RoiManager rm = roiManager!=null?roiManager:RoiManager.getInstance();
+			if (rm!=null)
+				rm.runCommand(state?"show all":"show none");
+		} else if (arg1.equals("changes"))
+			getImage().changes = state;
+		else if (arg1.equals("debugmode"))
+			IJ.setDebugMode(state);
+		else if (arg1.equals("openusingplugins"))
+			Opener.setOpenUsingPlugins(state);
+		else if (arg1.equals("queuemacros"))
+			pgm.queueCommands = state;
+		else if (arg1.equals("disableundo"))
+			Prefs.disableUndo = state;
+		else if (arg1.startsWith("openashyper"))
+			getImage().setOpenAsHyperStack(true);
+		else if (arg1.startsWith("black"))
+			Prefs.blackBackground = state;
+		else if (arg1.startsWith("display lab"))
+			Analyzer.setMeasurement(LABELS, state);
+		else if (arg1.startsWith("limit to"))
+			Analyzer.setMeasurement(LIMIT, state);
+		else if (arg1.startsWith("add to"))
+			Analyzer.setMeasurement(ADD_TO_OVERLAY, state);
+		else if (arg1.equals("area"))
+			Analyzer.setMeasurement(AREA, state);
+		else if (arg1.equals("mean"))
+			Analyzer.setMeasurement(MEAN, state);
+		else if (arg1.startsWith("perim"))
+			Analyzer.setMeasurement(PERIMETER, state);
+		else if (arg1.equals("stack position"))
+			Analyzer.setMeasurement(STACK_POSITION, state);
+		else if (arg1.startsWith("std"))
+			Analyzer.setMeasurement(STD_DEV, state);
+		else if (arg1.equals("showrownumbers"))
+			ResultsTable.getResultsTable().showRowNumbers(state);
+		else if (arg1.equals("showrowindexes"))
+			ResultsTable.getResultsTable().showRowIndexes(state);
+		else if (arg1.startsWith("show"))
+			Analyzer.setOption(arg1, state);
+		else if (arg1.startsWith("bicubic"))
+			ImageProcessor.setUseBicubic(state);
+		else if (arg1.startsWith("wand")||arg1.indexOf("points")!=-1)
+			Wand.setAllPoints(state);
+		else if (arg1.startsWith("expandablearrays"))
+			expandableArrays = state;
+		else if (arg1.startsWith("loop"))
+			Calibration.setLoopBackAndForth(state);
+		else if (arg1.startsWith("jfilechooser"))
+			Prefs.useJFileChooser = state;
+		else if (arg1.startsWith("auto"))
+			Prefs.autoContrast = state;
+		else if (arg1.equals("antialiasedtext"))
+			TextRoi.setAntialiasedText(state);
+		else if (arg1.equals("savebatchoutput"))
+			BatchProcessor.saveOutput(state);
+		else if (arg1.startsWith("converttomicrons"))
+			Prefs.convertToMicrons = state;
+		else if (arg1.startsWith("supportmacroundo"))
+			Prefs.supportMacroUndo = state;
+		else if (arg1.equals("inverty"))
+			getImage().getCalibration().setInvertY(state);
+		else if (arg1.equals("scaleconversions"))
+			ImageConverter.setDoScaling(state);
+		else if (arg1.startsWith("copyhead"))
+			Prefs.copyColumnHeaders = state;
+		else if (arg1.equals("waitforcompletion"))
+			waitForCompletion = state;
+		else if (arg1.equals("interpolatelines"))
+			PlotWindow.interpolate = state;
+		else if (arg1.equals("flipfitsimages"))
+			FITS_Reader.flipImages(state);
+		//else if (arg1.startsWith("saveimageloc")) {
+		//	Prefs.saveImageLocation = state;
+		//	if (!state) Prefs.set(ImageWindow.LOC_KEY,null);
+		else
+			interp.error("Invalid option");
+	}
+
+	void setMeasurementOption(String option) {
+	}
+
+	void showText() {
+		String title = getFirstString();
+		String text = null;
+		if (interp.nextToken()==',')
+			text = getLastString();
+		else
+			interp.getRightParen();
+		if (text==null) {
+			text = title;
+			title = "Untitled";
+		}
+		Frame frame = WindowManager.getFrame(title);
+		Editor ed = null;
+		boolean useExisting = frame instanceof Editor;
+		if (useExisting) {
+			ed = (Editor)frame;
+			TextArea ta = ed.getTextArea();
+			ta.selectAll();
+			ta.replaceRange(text, ta.getSelectionStart(), ta.getSelectionEnd());
+		} else {
+			ed = new Editor();
+			ed.setSize(350, 300);
+			ed.create(title, text);
+		}
+		if (title.equals("Untitled") && text.contains("Test Action Tool"))
+			new MacroInstaller().installSingleTool(text);
+	}
+
+	Variable[] newMenu() {
+        String name = getFirstString();
+        interp.getComma();
+        String[] commands = getStringArray();
+        interp.getRightParen();
+        if (pgm.menus==null)
+            pgm.menus = new Hashtable();
+        pgm.menus.put(name, commands);
+    	Variable[] commands2 = new Variable[commands.length];
+    	for (int i=0; i<commands.length; i++)
+    		commands2[i] = new Variable(0, 0.0, commands[i]);
+    	return commands2;
+	}
+
+	void setSelectionLocation() {
+		int x = (int)Math.round(getFirstArg());
+		int y = (int)Math.round(getLastArg());
+		ImagePlus imp = getImage();
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			interp.error("Selection required");
+		roi.setLocation(x, y);
+		imp.draw();
+	}
+
+	double is() {
+		boolean state = false;
+		String arg = getStringArg();
+		arg = arg.toLowerCase(Locale.US);
+		if (arg.equals("locked"))
+			state = getImage().isLocked();
+		else if (arg.contains("invert") && arg.contains("lut"))
+			state = getImage().isInvertedLut();
+		else if (arg.indexOf("hyper")!=-1)
+			state = getImage().isHyperStack();
+		else if (arg.indexOf("batch")!=-1)
+			state = Interpreter.isBatchMode();
+		else if (arg.indexOf("applet")!=-1)
+			state = IJ.getApplet()!=null;
+		else if (arg.indexOf("virtual")!=-1)
+			state = getImage().getStack().isVirtual();
+		else if (arg.indexOf("composite")!=-1)
+			state = getImage().isComposite();
+		else if (arg.indexOf("caps")!=-1)
+			state = getCapsLockState();
+		else if (arg.indexOf("change")!=-1)
+			state = getImage().changes;
+		else if (arg.indexOf("binary")!=-1)
+			state = getProcessor().isBinary();
+		else if (arg.indexOf("grayscale")!=-1)
+			state = getProcessor().isGrayscale();
+		else if (arg.startsWith("global"))
+			state = ImagePlus.getStaticGlobalCalibration()!=null;
+		else if (arg.indexOf("animated")!=-1) {
+			ImageWindow win = getImage().getWindow();
+			state = win!=null && (win instanceof StackWindow) && ((StackWindow)win).getAnimate();
+		} else if (arg.equals("inverty")) {
+			state = getImage().getCalibration().getInvertY();
+		} else if (arg.startsWith("area")) {
+			Roi roi = getImage().getRoi();
+			state = roi!=null?roi.isArea():false;
+		} else if (arg.startsWith("line")) {
+			Roi roi = getImage().getRoi();
+			state = roi!=null?roi.isLine():false;
+		} else
+			interp.error("Invalid argument");
+		return state?1.0:0.0;
+	}
+
+	final boolean getCapsLockState() {
+		boolean capsDown = false;
+		try {
+			capsDown = Toolkit.getDefaultToolkit().getLockingKeyState(KeyEvent.VK_CAPS_LOCK);
+		} catch(Exception e) {}
+		return capsDown;
+	}
+
+	Variable[] getList() {
+		String key = getStringArg().toLowerCase();
+		if (key.equals("java.properties")) {
+			Properties props = System.getProperties();
+			Vector v = new Vector();
+			for (Enumeration en=props.keys(); en.hasMoreElements();)
+				v.addElement((String)en.nextElement());
+			Variable[] array = new Variable[v.size()];
+			for (int i=0; i<array.length; i++)
+				array[i] = new Variable(0, 0.0, (String)v.elementAt(i));
+			return array;
+		} else if (key.equals("image.titles")) {
+			String[] titles = WindowManager.getImageTitles();
+			Variable[] array = new Variable[titles.length];
+			for (int i=0; i<titles.length; i++)
+				array[i] = new Variable(0, 0.0, titles[i]);
+			return array;
+		} else if (key.equals("window.titles")) {
+			String[] titles = WindowManager.getNonImageTitles();
+			Variable[] array = new Variable[titles.length];
+			for (int i=0; i<titles.length; i++)
+				array[i] = new Variable(0, 0.0, titles[i]);
+			return array;
+		} else if (key.equals("threshold.methods")) {
+			String[] list = AutoThresholder.getMethods();
+			Variable[] array = new Variable[list.length];
+			for (int i=0; i<list.length; i++)
+				array[i] = new Variable(0, 0.0, list[i]);
+			return array;
+		} else if (key.equals("luts")) {
+			String[] list = IJ.getLuts();
+			Variable[] array = new Variable[list.length];
+			for (int i=0; i<list.length; i++)
+				array[i] = new Variable(0, 0.0, list[i]);
+			return array;
+		} else {
+			interp.error("Unvalid key");
+			return null;
+		}
+	}
+
+	String doString() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==STRING_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("append"))
+			return appendToBuffer();
+		else if (name.equals("copy"))
+			return copyStringToClipboard();
+		else if (name.equals("copyResults"))
+			return copyResults();
+		else if (name.equals("getResultsHeadings"))
+			return getResultsHeadings();
+		else if (name.equals("paste"))
+			return getClipboardContents();
+		else if (name.equals("resetBuffer"))
+			return resetBuffer();
+		else if (name.equals("buffer"))
+			return getBuffer();
+		else if (name.equals("show"))
+			return showString();
+		else if (name.equals("join"))
+			return join();
+		else if (name.equals("trim"))
+			return getStringArg().trim();
+		else if (name.equals("pad"))
+			return pad();
+		else if (name.equals("format")) {
+			try {return String.format(getFirstString(),getLastArg());}
+			catch (Exception e) {interp.error(""+e);}
+			return null;
+		} else
+			interp.error("Unrecognized String function");
+		return null;
+	}
+
+	private String join() {
+		interp.getLeftParen();
+		String delimiter = ", ";
+		Variable[] arr = getArray();
+		if (interp.nextToken()==',')
+			delimiter = getNextString();
+		interp.getRightParen();
+		return joinArray(arr, delimiter).toString();
+	}
+
+	private StringBuilder joinArray(Variable[] a, String delimiter) {
+		int len = a.length;
+		StringBuilder sb = new StringBuilder(len*6);
+		for (int i=0; i<len; i++) {
+			String s = a[i].getString();
+			if (s==null) {
+				double v = a[i].getValue();
+				if ((int)v==v)
+					s = IJ.d2s(v,0);
+				else
+					s = ResultsTable.d2s(v,4);
+			}
+			sb.append(s);
+			if (i!=len-1)
+				sb.append(delimiter);
+		}
+		return sb;
+	}
+
+	private String showString() {
+		showText();
+		return null;
+	}
+
+	private String getResultsHeadings() {
+		interp.getParens();
+		ResultsTable rt = ResultsTable.getResultsTable();
+		return rt.getColumnHeadings();
+	}
+
+	private String appendToBuffer() {
+		String text = getStringArg();
+		if (buffer==null)
+			buffer = new StringBuffer(256);
+		buffer.append(text);
+		return null;
+	}
+
+	private String copyStringToClipboard() {
+		String text = getStringArg();
+		StringSelection ss = new StringSelection(text);
+		java.awt.datatransfer.Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		clipboard.setContents(ss, null);
+		return null;
+	}
+
+	private String getClipboardContents() {
+		interp.getParens();
+		java.awt.datatransfer.Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+		Transferable data = clipboard.getContents(null);
+		String s = null;
+		try {s = (String)data.getTransferData(DataFlavor.stringFlavor);}
+		catch (Exception e) {s = data.toString();}
+		return s;
+	}
+
+	private String copyResults() {
+		interp.getParens();
+		if (!IJ.isResultsWindow())
+			interp.error("No results");
+		TextPanel tp = IJ.getTextPanel();
+		if (tp!=null)
+			tp.copySelection();
+		return null;
+	}
+
+	private String resetBuffer() {
+		interp.getParens();
+		buffer = new StringBuffer(256);
+		return null;
+	}
+
+	private String getBuffer() {
+		interp.getParens();
+		if (buffer==null)
+			buffer = new StringBuffer(256);
+		return buffer.toString();
+	}
+
+	private void doCommand() {
+		String arg = getStringArg();
+		if (arg.equals("Start Animation"))
+			arg = "Start Animation [\\]";
+		IJ.doCommand(arg);
+	}
+
+	private void getDimensions() {
+		Variable width = getFirstVariable();
+		Variable height = getNextVariable();
+		Variable channels = getNextVariable();
+		Variable slices = getNextVariable();
+		Variable frames = getLastVariable();
+		ImagePlus imp = getImage();
+		int[] dim = imp.getDimensions();
+		width.setValue(dim[0]);
+		height.setValue(dim[1]);
+		channels.setValue(dim[2]);
+		slices.setValue(dim[3]);
+		frames.setValue(dim[4]);
+	}
+
+	public static void registerExtensions(MacroExtension extensions) {
+		if (IJ.debugMode) IJ.log("registerExtensions");
+		Interpreter interp = Interpreter.getInstance();
+		if (interp==null) {
+			IJ.error("Macro must be running to install macro extensions");
+			return;
+		}
+		interp.pgm.extensionRegistry = new Hashtable();
+		ExtensionDescriptor[] descriptors = extensions.getExtensionFunctions();
+		for (int i=0; i<descriptors.length; ++i) {
+			interp.pgm.extensionRegistry.put(descriptors[i].name, descriptors[i]);
+			if (IJ.debugMode) IJ.log("  "+i+" "+descriptors[i].name);
+		}
+	}
+
+	String doExt() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD || interp.token==STRING_FUNCTION || interp.token==NUMERIC_FUNCTION || interp.token==PREDEFINED_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("install")) {
+			Object plugin = IJ.runPlugIn(getStringArg(), "");
+			if (plugin==null) interp.error("Plugin not found");
+			return null;
+		}
+		ExtensionDescriptor desc = null;
+		if (pgm.extensionRegistry!=null)
+			desc = (ExtensionDescriptor) pgm.extensionRegistry.get(name);
+		if (desc == null) {
+			interp.error("Unrecognized Ext function");
+			return null;
+		}
+		return desc.dispatch(this);
+	}
+
+	String exec() {
+		String[] cmd;
+		StringBuffer sb = new StringBuffer(256);
+		String arg1 = getFirstString();
+		if (interp.nextToken()==',') {
+			Vector v = new Vector();
+			v.add(arg1);
+			do
+				v.add(getNextString());
+			while (interp.nextToken()==',');
+			cmd = new String[v.size()];
+			v.copyInto((String[])cmd);
+		} else
+			cmd = Tools.split(arg1);
+		interp.getRightParen();
+		boolean openingDoc = cmd.length==2&&cmd[0].equals("open") || cmd.length==5&&cmd[3].equals("excel.exe");
+		if (openingDoc&&IJ.isWindows()) {
+			String path = cmd[1];
+			if (path.startsWith("http://")||path.startsWith("HTTP://")) {
+				cmd = new String[4];
+				cmd[2] = "start";
+				cmd[3] = path;
+			} else {
+				cmd = new String[3];
+				cmd[2] = path;
+			}
+			cmd[0] = "cmd";
+			cmd[1] = "/c";
+		}
+		BufferedReader reader = null;
+		try {
+			Process p = Runtime.getRuntime().exec(cmd);
+			boolean returnImmediately = openingDoc || !waitForCompletion;
+			waitForCompletion = true;
+			if (returnImmediately)
+				return null;
+			reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
+			String line; int count=1;
+			while ((line=reader.readLine())!=null)  {
+        		sb.append(line+"\n");
+        		if (count++==1&&line.startsWith("Microsoft Windows"))
+        			break; // user probably ran 'cmd' without /c option
+        	}
+		} catch (Exception e) {
+    		sb.append(e.getMessage()+"\n");
+		} finally {
+			if (reader!=null) try {reader.close();} catch (IOException e) {}
+		}
+		return sb.toString();
+	}
+
+	double getValue() {
+		interp.getLeftParen();
+		if (!isStringArg()) {  // getValue(x,y)
+			double x = interp.getExpression();
+			double y = getLastArg();
+			int ix = (int)x;
+			int iy = (int)y;
+			if (x==ix && y==iy)
+				return getProcessor().getPixelValue(ix,iy);
+			else
+				return getProcessor().getInterpolatedValue(x,y);
+		}
+		String key = getString();
+		interp.getRightParen();
+		if (key.equals("image.size"))
+			return getImage().getSizeInBytes();
+		else if (key.equals("rgb.foreground"))
+			return Toolbar.getForegroundColor().getRGB()&0xffffff;
+		else if (key.equals("rgb.background"))
+			return Toolbar.getBackgroundColor().getRGB()&0xffffff;
+		else if (key.contains("foreground")) {
+			double value = Toolbar.getForegroundValue();
+			if (Double.isNaN(value))
+				return getColorValue(Toolbar.getForegroundColor());
+			else
+				return value;
+		} else if (key.contains("background")) {
+			double value = Toolbar.getBackgroundValue();
+			if (Double.isNaN(value))
+				return getColorValue(Toolbar.getBackgroundColor());
+			else
+				return value;
+		} else if (key.equals("font.size")) {
+			resetImage();
+			ImageProcessor ip = getProcessor();
+			setFont(ip);
+			return ip.getFont().getSize();
+		} else if (key.equals("font.height")) {
+			resetImage();
+			ImageProcessor ip = getProcessor();
+			setFont(ip);
+			return ip.getFontMetrics().getHeight();
+		} else if (key.equals("selection.size")) {
+			ImagePlus imp = getImage();
+			Roi roi = imp.getRoi();
+			if (roi==null)
+				return 0.0;
+			else
+				return roi.size();
+		} else if (key.equals("selection.width")) {
+			ImagePlus imp = getImage();
+			Roi roi = imp.getRoi();
+			if (roi==null)
+				interp.error("No selection");
+			return roi.getStrokeWidth();
+		} else if (key.equals("results.count")) {
+			ResultsTable rt = getResultsTable(false);
+			return rt!=null?rt.size():0;
+		} else if (key.equals("rotation.angle")) {
+			return Rotator.getAngle();
+		} else if (key.equals("hashCode")) {
+			return interp.hashCode();
+		} else if (key.equals("instance")) {
+			Interpreter instance = interp.getInstance();
+			return instance!=null?instance.hashCode():0;
+		} else if (key.equals("done")) {
+			return interp.done?1:0;
+		} else if (key.startsWith("Length")) {
+				return IJ.getValue(getImage(), key);
+		} else {
+			String[] headings = ResultsTable.getDefaultHeadings();
+			for (int i=0; i<headings.length; i++) {
+				if (key.startsWith(headings[i]))
+					return IJ.getValue(getImage(), key);
+			}
+			interp.error("Invalid key");
+			return 0.0;
+		}
+	}
+
+	double getColorValue(Color color) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getBitDepth()==24)
+			return color.getRGB()&0xffffff;
+		ImageProcessor ip = imp.getProcessor();
+		ip.setRoi(0,0,1,1);
+		ip = ip.crop();
+		ip.setColor(color);
+		ip.drawDot(0,0);
+		return ip.getf(0,0);
+	}
+
+	double doStack() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (interp.token!=WORD && interp.token!=PREDEFINED_FUNCTION)
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("size"))
+			return getImage().getStackSize();
+		else if (name.equals("isHyperstack")||name.equals("isHyperStack"))
+			return getImage().isHyperStack()?1.0:0.0;
+		else if (name.equals("getDimensions")) {
+			getDimensions();
+			return Double.NaN;
+		} else if (name.equals("stopOrthoViews")) {
+			interp.getParens();
+			Orthogonal_Views.stop();
+			return Double.NaN;
+		} else if (name.equals("getOrthoViewsID")) {
+			interp.getParens();
+			return Orthogonal_Views.getImageID();
+		} else if (name.equals("getOrthoViewsIDs")) {
+			return getOrthoViewsIDs();
+		} else if (name.equals("setOrthoViews"))
+			return setOrthoViews();
+		else if (name.equals("getOrthoViews"))
+			return getOrthoViews();
+		ImagePlus imp = getImage();
+		if (name.equals("setPosition")) {
+			setPosition(imp);
+			return Double.NaN;
+		}
+		if (name.equals("setChannel")) {
+			imp.setPosition((int)getArg(),imp.getSlice(),imp.getFrame());
+			return Double.NaN;
+		}
+		if (name.equals("setSlice")) {
+			imp.setPosition(imp.getChannel(), (int)getArg(), imp.getFrame());
+			return Double.NaN;
+		}
+		if (name.equals("setFrame")) {
+			imp.setPosition(imp.getChannel(), imp.getSlice(), (int)getArg());
+			return Double.NaN;
+		}
+		if (name.equals("getPosition")) {
+			getPosition(imp);
+			return Double.NaN;
+		}
+		Calibration cal = imp.getCalibration();
+		if (name.equals("getFrameRate"))
+			{interp.getParens(); return cal.fps;}
+		if (name.equals("setFrameRate"))
+			{cal.fps=getArg(); return Double.NaN;}
+		if (name.equals("getFrameInterval"))
+			{interp.getParens(); return cal.frameInterval;}
+		if (name.equals("setFrameInterval"))
+			{cal.frameInterval=getArg(); return Double.NaN;}
+		if (name.equals("setTUnit"))
+			{cal.setTimeUnit(getStringArg()); return Double.NaN;}
+		if (name.equals("setXUnit"))
+			{cal.setXUnit(getStringArg()); return Double.NaN;}
+		if (name.equals("setYUnit"))
+			{cal.setYUnit(getStringArg()); return Double.NaN;}
+		if (name.equals("setZUnit"))
+			{cal.setZUnit(getStringArg()); return Double.NaN;}
+		if (name.equals("getUnits"))
+			{getStackUnits(cal); return Double.NaN;}
+		if (name.equals("setUnits"))
+			{setStackUnits(imp); return Double.NaN;}
+		if (imp.getStackSize()==1) {
+			interp.error("Stack required");
+			return Double.NaN;			
+		}
+		if (name.equals("setDimensions"))
+			setDimensions(imp);
+		else if (name.equals("setDisplayMode"))
+			setDisplayMode(imp, getStringArg());
+		else if (name.equals("getDisplayMode"))
+			getDisplayMode(imp);
+		else if (name.equals("setActiveChannels"))
+			imp.setActiveChannels(getStringArg());
+		else if (name.equals("getActiveChannels"))
+			getActiveChannels(imp);
+		else if (name.equals("toggleChannel"))
+			toggleChannel(imp, (int)getArg());
+		else if (name.equals("swap"))
+			swapStackImages(imp);
+		else if (name.equals("getStatistics"))
+			getStackStatistics(imp, true);
+		else
+			interp.error("Unrecognized Stack function");
+		return Double.NaN;
+	}
+
+	private double setOrthoViews() {
+		int x = (int)getFirstArg();
+		int y = (int)getNextArg();
+		int z = (int)getLastArg();
+		Orthogonal_Views orthoViews = Orthogonal_Views.getInstance();
+		if (orthoViews!=null)
+			orthoViews.setCrossLoc(x, y, z);
+		return Double.NaN;
+	}
+
+	private double getOrthoViewsIDs() {
+		Variable xy = getFirstVariable();
+		Variable xz = getNextVariable();
+		Variable yz = getLastVariable();
+		int[] ids = Orthogonal_Views.getImageIDs();
+		xy.setValue(ids[0]);
+		xz.setValue(ids[1]);
+		yz.setValue(ids[2]);
+		return Double.NaN;
+	}
+
+	private double getOrthoViews() {
+		Variable x = getFirstVariable();
+		Variable y = getNextVariable();
+		Variable z = getLastVariable();
+		Orthogonal_Views orthoViews = Orthogonal_Views.getInstance();
+		int[] loc = new int[3];
+		if (orthoViews!=null)
+			loc = orthoViews.getCrossLoc();
+		x.setValue(loc[0]);
+		y.setValue(loc[1]);
+		z.setValue(loc[2]);
+		return Double.NaN;
+	}
+
+	void getStackUnits(Calibration cal) {
+		Variable x = getFirstVariable();
+		Variable y = getNextVariable();
+		Variable z = getNextVariable();
+		Variable t = getNextVariable();
+		Variable v = getLastVariable();
+		x.setString(cal.getXUnit());
+		y.setString(cal.getYUnit());
+		z.setString(cal.getZUnit());
+		t.setString(cal.getTimeUnit());
+		v.setString(cal.getValueUnit());
+	}
+
+	void setStackUnits(ImagePlus imp) {
+		Calibration cal = imp.getCalibration();
+		cal.setXUnit(getFirstString());
+		cal.setYUnit(getNextString());
+		cal.setZUnit(getNextString());
+		cal.setTimeUnit(getNextString());
+		cal.setValueUnit(getLastString());
+		imp.repaintWindow();
+	}
+
+	void getStackStatistics(ImagePlus imp, boolean calibrated) {
+		Variable count = getFirstVariable();
+		Variable mean=null, min=null, max=null, std=null, hist=null;
+		int params = AREA+MEAN+MIN_MAX;
+		interp.getToken();
+		int arg = 1;
+		while (interp.token==',') {
+			arg++;
+			switch (arg) {
+				case 2: mean = getVariable(); break;
+				case 3: min = getVariable(); break;
+				case 4: max = getVariable(); break;
+				case 5: std = getVariable(); params += STD_DEV; break;
+				case 6: hist = getArrayVariable(); break;
+				default: interp.error("')' expected");
+			}
+			interp.getToken();
+		}
+		if (interp.token!=')') interp.error("')' expected");
+		ImageStatistics stats = new StackStatistics(imp);
+		count.setValue(stats.pixelCount);
+		if (mean!=null) mean.setValue(stats.mean);
+		if (min!=null) min.setValue(stats.min);
+		if (max!=null) max.setValue(stats.max);
+		if (std!=null) std.setValue(stats.stdDev);
+		if (hist!=null) {
+			int[] histogram = stats.histogram;
+		    int bins = histogram.length;
+			Variable[] array = new Variable[bins];
+			int hmax = 255;
+			for (int i=0; i<=hmax; i++)
+				array[i] = new Variable(histogram[i]);
+			hist.setArray(array);
+		}
+	}
+
+	void getActiveChannels(ImagePlus imp) {
+		if (!imp.isComposite())
+			interp.error("Composite image required");
+		boolean[] active = ((CompositeImage)imp).getActiveChannels();
+		int n = active.length;
+		char[] chars = new char[n];
+		int nChannels = imp.getNChannels();
+		for (int i=0; i<n; i++) {
+			if (i<nChannels)
+				chars[i] = active[i]?'1':'0';
+			else
+				chars[i] = '0';
+		}
+		Variable channels = getVariableArg();
+		channels.setString(new String(chars));
+	}
+
+	void toggleChannel(ImagePlus imp, int channel) {
+		if (!imp.isComposite())
+			interp.error("Composite image required");
+		if (channel<1 || channel>imp.getNChannels())
+			interp.error("Invalid channel: "+channel);
+		if (((CompositeImage)imp).getMode()!=IJ.COMPOSITE)
+			((CompositeImage)imp).setMode(IJ.COMPOSITE);
+		boolean[] active = ((CompositeImage)imp).getActiveChannels();
+		active[channel-1] = active[channel-1]?false:true;
+		imp.updateAndDraw();
+		Channels.updateChannels();
+	}
+
+	void setDisplayMode(ImagePlus imp, String mode) {
+		mode = mode.toLowerCase(Locale.US);
+		if (!imp.isComposite())
+			interp.error("Composite image required");
+		int m = -1;
+		if (mode.equals("composite"))
+			m = IJ.COMPOSITE;
+		else if (mode.equals("color"))
+			m = IJ.COLOR;
+		else if (mode.startsWith("gray"))
+			m = IJ.GRAYSCALE;
+		if (m==-1)
+			interp.error("Invalid mode");
+		((CompositeImage)imp).setMode(m);
+		imp.updateAndDraw();
+	}
+
+	void swapStackImages(ImagePlus imp) {
+		int n1 = (int)getFirstArg();
+		int n2 = (int)getLastArg();
+		ImageStack stack = imp.getStack();
+		int size = stack.size();
+		if (n1<1||n1>size||n2<1||n2>size)
+			interp.error("Argument out of range");
+		Object pixels = stack.getPixels(n1);
+		String label = stack.getSliceLabel(n1);
+		stack.setPixels(stack.getPixels(n2), n1);
+		stack.setSliceLabel(stack.getSliceLabel(n2), n1);
+		stack.setPixels(pixels, n2);
+		stack.setSliceLabel(label, n2);
+		int current = imp.getCurrentSlice();
+		if (imp.isComposite()) {
+			CompositeImage ci = (CompositeImage)imp;
+			if (ci.getMode()==IJ.COMPOSITE) {
+				ci.reset();
+				imp.updateAndDraw();
+				imp.repaintWindow();
+				return;
+			}
+		}
+		if (n1==current || n2==current)
+			imp.setStack(null, stack);
+	}
+
+	void getDisplayMode(ImagePlus imp) {
+		Variable v = getVariableArg();
+		String mode = "";
+		if (imp.isComposite())
+			mode = ((CompositeImage)imp).getModeAsString();
+		v.setString(mode);
+	}
+
+	void getPosition(ImagePlus imp) {
+		Variable channel = getFirstVariable();
+		Variable slice = getNextVariable();
+		Variable frame = getLastVariable();
+		int c = imp.getChannel();
+		int z = imp.getSlice();
+		int t = imp.getFrame();
+		if (c*z*t>imp.getStackSize())
+			{c=1; z=imp.getCurrentSlice(); t=1;}
+		channel.setValue(c);
+		slice.setValue(z);
+		frame.setValue(t);
+	}
+
+	void setPosition(ImagePlus img) {
+		int channel = (int)getFirstArg();
+		int slice = (int)getNextArg();
+		int frame = (int)getLastArg();
+		img.setPosition(channel, slice, frame);
+	}
+
+	void setDimensions(ImagePlus img) {
+		int c = (int)getFirstArg();
+		int z = (int)getNextArg();
+		int t = (int)getLastArg();
+		img.setDimensions(c, z, t);
+		if (img.getWindow()==null) img.setOpenAsHyperStack(true);
+	}
+
+	void setTool() {
+        interp.getLeftParen();
+		if (isStringArg()) {
+			boolean ok = IJ.setTool(getString());
+			if (!ok) interp.error("Unrecognized tool name");
+		} else
+			IJ.setTool((int)interp.getExpression());
+		interp.getRightParen();
+	}
+
+	String doToString() {
+		String s = getFirstString();
+		interp.getToken();
+		if (interp.token==',') {
+			double value = Tools.parseDouble(s);
+			s = IJ.d2s(value, (int)interp.getExpression());
+			interp.getToken();
+		}
+		if (interp.token!=')') interp.error("')' expected");
+		return s;
+	}
+
+	double matches(String str) {
+		str = getStringFunctionArg(str);
+		String regex = getString();
+		interp.getRightParen();
+		try {
+			return str.matches(regex)?1.0:0.0;
+		} catch (Exception e) {
+			interp.error(""+e);
+			return 0.0;
+		}
+	}
+
+	void waitForUser() {
+		IJ.wait(50);
+		if (waitForUserDialog!=null && waitForUserDialog.isShowing())
+			interp.error("Duplicate call");
+		String title = "Action Required";
+		String text = "   Click \"OK\" to continue     ";
+		if (interp.nextToken()=='(') {
+			title = getFirstString();
+			if (interp.nextToken()==',')
+				text = getLastString();
+			else {
+				text = title;
+				title = "Action Required";
+				interp.getRightParen();
+			}
+		}
+		waitForUserDialog = new WaitForUserDialog(title, text);
+		Interpreter instance = Interpreter.getInstance();
+		interp.waitingForUser = true;
+		waitForUserDialog.show();
+		interp.waitingForUser = false;
+		Interpreter.setInstance(instance); // works around bug caused by use of drawing tools
+		if (waitForUserDialog.escPressed() || IJ.escapePressed())
+			throw new RuntimeException(Macro.MACRO_CANCELED);
+	}
+
+	void abortDialog() {
+		if (waitForUserDialog!=null && waitForUserDialog.isVisible())
+			waitForUserDialog.close();
+	}
+
+	double getStringWidth() {
+		resetImage();
+		ImageProcessor ip = getProcessor();
+		setFont(ip);
+		return ip.getStringWidth(getStringArg());
+	}
+
+	String doList() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==ARRAY_FUNCTION||interp.token==NUMERIC_FUNCTION))
+			interp.error("Function name expected: ");
+		if (props==null)
+			props = new Properties();
+		String value = null;
+		String name = interp.tokenString;
+		if (name.equals("get")) {
+			value = props.getProperty(getStringArg());
+			value = value!=null?value:"";
+		} else if (name.equals("getValue")) {
+			value = props.getProperty(getStringArg());
+			if (value==null) interp.error("Value not found");
+		} else if (name.equals("set")||name.equals("add")||name.equals("put"))
+			props.setProperty(getFirstString(), getLastString());
+		else if (name.equals("clear")||name.equals("reset")) {
+			interp.getParens();
+			props.clear();
+		} else if (name.equals("setList"))
+			setPropertiesFromString(props);
+		else if (name.equals("getList"))
+			value = getPropertiesAsString(props);
+		else if (name.equals("size")||name.equals("getSize")) {
+			interp.getParens();
+			value = ""+props.size();
+		} else if (name.equals("setMeasurements"))
+			setMeasurements();
+		else if (name.equals("setCommands"))
+			setCommands();
+		else if (name.equals("indexOf")) {
+			int index = -1;
+			String key = getStringArg();
+			int size = props.size();
+			String[] keyArr = new String[size];
+			String[] valueArr = new String[size];
+			listToArrays(keyArr, valueArr);
+			for (int i = 0; i < size; i++) {
+				if (keyArr[i].equals(key)) {
+					index = i;
+					break;
+				}
+			}
+			value = "" + index;
+		} else if (name.equals("fromArrays")) {
+			interp.getLeftParen();
+			String[] keys = getStringArray();
+			interp.getComma();
+			String[] values = getStringArray();
+			if (values.length != keys.length) {
+				interp.error("Arrays must have same length");
+			}
+			props.clear();
+			for (int i = 0; i < keys.length; i++) {
+				if (keys[i].equals("")) {
+					interp.error("Key cannot be an empty string");
+				}
+				props.setProperty(keys[i], values[i]);
+			}
+			interp.getRightParen();
+		} else if (name.equals("toArrays")) {
+			Variable keys = getFirstArrayVariable();
+			Variable values = getLastArrayVariable();
+
+			int size = props.size();
+			String[] keyArr = new String[size];
+			String[] valueArr = new String[size];
+
+			listToArrays(keyArr, valueArr);
+			Variable[] keysVar, valuesVar;
+			keysVar = new Variable[size];
+			valuesVar = new Variable[size];
+			for (int i = 0; i < size; i++) {
+				keysVar[i] = new Variable();
+				keysVar[i].setString(keyArr[i]);
+				valuesVar[i] = new Variable();
+				valuesVar[i].setString(valueArr[i]);
+			}
+			keys.setArray(keysVar);
+			values.setArray(valuesVar);
+		} else {
+			interp.error("Unrecognized List function");
+		}
+		return value;
+	}
+
+	void listToArrays(String[] keys, String[] values) {
+		Vector v = new Vector();
+		for (Enumeration en = props.keys(); en.hasMoreElements();) {
+			v.addElement(en.nextElement());
+		}
+		for (int i = 0; i < keys.length; i++) {
+			keys[i] = (String) v.elementAt(i);
+		}
+		Arrays.sort(keys);
+		for (int i = 0; i < keys.length; i++) {
+			values[i] = (String) props.get(keys[i]);
+		}
+	}
+
+	void setCommands() {
+		interp.getParens();
+		Hashtable commands = Menus.getCommands();
+		props = new Properties();
+		for (Enumeration en=commands.keys(); en.hasMoreElements();) {
+			String command = (String)en.nextElement();
+			props.setProperty(command, (String)commands.get(command));
+		}
+	}
+
+	void setMeasurements() {
+		String arg = "";
+		if (interp.nextToken()=='(') {
+			interp.getLeftParen();
+			if (interp.nextToken() != ')')
+				arg = getString().toLowerCase(Locale.US);
+			interp.getRightParen();
+		}
+		props.clear();
+		ImagePlus imp = getImage();
+		int measurements = ALL_STATS + SLICE;
+		if (arg.contains("limit"))
+			measurements += LIMIT;
+		ImageStatistics stats = imp.getStatistics(measurements);
+		ResultsTable rt = new ResultsTable();
+		Analyzer analyzer = new Analyzer(imp, measurements, rt);
+		analyzer.saveResults(stats, imp.getRoi());
+		for (int i=0; i<=rt.getLastColumn(); i++) {
+			if (rt.columnExists(i)) {
+				String name = rt.getColumnHeading(i);
+				String value = ""+rt.getValueAsDouble(i, 0);
+				props.setProperty(name, value);
+			}
+		}
+	}
+
+	void makePoint() {
+		double x = getFirstArg();
+		double y = getNextArg();
+		String options = null;
+		if (interp.nextToken()==',')
+			options = getNextString();
+		interp.getRightParen();
+		if (options==null) {
+			if ((int)x==x && (int)y==y)
+				IJ.makePoint((int)x, (int)y);
+			else
+				IJ.makePoint(x, y);
+		} else
+			getImage().setRoi(new PointRoi(x, y, options));
+		resetImage();
+		shiftKeyDown = altKeyDown = false;
+	}
+
+	void makeText() {
+		String text = getFirstString();
+		int x = (int)getNextArg();
+		int y = (int)getLastArg();
+		ImagePlus imp = getImage();
+		Font font = this.font;
+		boolean nullFont = font==null;
+		if (nullFont)
+			font = imp.getProcessor().getFont();
+		TextRoi roi = new TextRoi(x, y, text, font);
+		if (!nullFont)
+			roi.setAntiAlias(antialiasedText);
+		imp.setRoi(roi);
+	}
+
+	void makeEllipse() {
+		ImagePlus imp = getImage();
+		Roi previousRoi = imp.getRoi();
+		if (shiftKeyDown||altKeyDown)
+			imp.saveRoi();
+		double x1 = getFirstArg();
+		double y1 = getNextArg();
+		double x2 = getNextArg();
+		double y2 = getNextArg();
+		double aspectRatio = getLastArg();
+		Roi roi = new EllipseRoi(x1,y1,x2,y2,aspectRatio);
+		imp.setRoi(roi);
+		if (previousRoi!=null && roi!=null)
+			updateRoi(roi);
+		resetImage();
+		shiftKeyDown = altKeyDown = false;
+	}
+
+	double fit() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==ARRAY_FUNCTION))
+			interp.error("Function name expected: ");
+		if (props==null)
+			props = new Properties();
+		String name = interp.tokenString;
+		if (name.equals("doFit"))
+			return fitCurve(false);
+		if (name.equals("doWeightedFit"))
+			return fitCurve(true);
+		else if (name.equals("getEquation"))
+			return getEquation();
+		else if (name.equals("nEquations")) {
+			interp.getParens();
+			return CurveFitter.fitList.length;
+		} else if (name.equals("showDialog")) {
+			showFitDialog = true;
+			return Double.NaN;
+		} else if (name.equals("logResults")) {
+			logFitResults = true;
+			return Double.NaN;
+		}
+		if (fitter==null)
+			interp.error("No fit");
+		if (name.equals("f"))
+			return fitter.f(fitter.getParams(), getArg());
+		else if (name.equals("plot")) {
+			interp.getParens();
+			Fitter.plot(fitter);
+			return Double.NaN;
+		} else if (name.equals("nParams")) {
+			interp.getParens();
+			return fitter.getNumParams();
+		} else if (name.equals("p")) {
+			int index = (int)getArg();
+			checkIndex(index, 0, fitter.getNumParams()-1);
+			double[] p = fitter.getParams();
+			return index<p.length?p[index]:Double.NaN;
+		} else if (name.equals("rSquared")) {
+			interp.getParens();
+			return fitter.getRSquared();
+		}
+		return Double.NaN;
+	}
+
+	double fitCurve(boolean withWeights) {
+		interp.getLeftParen();
+		int fit = -1;
+		String name = null;
+		double[] initialValues = null;
+		if (isStringArg()) {
+			name = getString();
+			if (!name.contains("Math."))
+				name = name.toLowerCase(Locale.US);
+			String[] list = CurveFitter.fitList;
+			for (int i=0; i<list.length; i++) {
+				if (name.equals(list[i].toLowerCase(Locale.US))) {
+					fit = i;
+					break;
+				}
+			}
+			boolean isCustom = name.indexOf("y=")!=-1 || name.indexOf("y =")!=-1;
+			if (fit==-1&&!isCustom)
+				interp.error("Unrecognized fit");
+		} else
+			fit = (int)interp.getExpression();
+		double[] x = getNextArray();
+		interp.getComma();
+		double[] y = getNumericArray();
+		double[] weights = null;
+		if (withWeights) {
+		interp.getComma();
+			weights = getNumericArray();
+		}
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			initialValues = getNumericArray();
+		}
+		interp.getRightParen();
+		if (x.length!=y.length)
+			interp.error("Arrays not same length");
+		if (x.length==0)
+			interp.error("Zero length array");
+		fitter = new CurveFitter(x, y);
+		if (withWeights)
+			fitter.setWeights(weights);
+		fitter.setStatusAndEsc(null, true);
+		if (fit==-1 && name!=null) {
+			Interpreter instance = Interpreter.getInstance();
+			int params = fitter.doCustomFit(name, initialValues, showFitDialog);
+			Interpreter.instance = instance;
+			if (params==0)
+				interp.error("Invalid custom function");
+		} else
+			fitter.doFit(fit, showFitDialog);
+		if (logFitResults) {
+			IJ.log(fitter.getResultString());
+			logFitResults = false;
+		}
+		showFitDialog = false;
+		return Double.NaN;
+	}
+
+	double getEquation() {
+		int index = (int)getFirstArg();
+		Variable name = getNextVariable();
+		Variable formula = getNextVariable();
+		Variable macroCode=null;
+		interp.getToken();
+		if (interp.token==',') {
+			macroCode = getVariable();
+			interp.getToken();
+		}
+		if (interp.token!=')')
+			interp.error("')' expected");
+		checkIndex(index, 0, CurveFitter.fitList.length-1);
+		name.setString(CurveFitter.fitList[index]);
+		formula.setString(CurveFitter.fList[index]);
+		if (macroCode != null)
+			macroCode.setString(CurveFitter.fMacro[index]);
+		return Double.NaN;
+	}
+
+	void setMinAndMax() {
+		double min = getFirstArg();
+		double max = getNextArg();
+		int channels = 7;
+		if (interp.nextToken()==',') {
+			channels = (int)getLastArg();
+			if (getImage().getBitDepth()!=24)
+				interp.error("RGB image required");
+		} else
+			interp.getRightParen();
+		IJ.setMinAndMax(min, max, channels);
+		resetImage();
+	}
+
+	String debug() {
+		IJ.protectStatusBar(false);
+		String arg = "break";
+		if (interp.nextToken()=='(')
+			arg = getStringArg().toLowerCase(Locale.US);
+		else
+			interp.getParens();
+		if (arg.equals("conditional")) {
+			if (IJ.debugMode)
+				arg = "break";
+			else
+				return null;
+		}
+		if (interp.getDebugger()==null && !(arg.equals("throw")||arg.equals("dump"))) {
+			Editor ed = Editor.getInstance();
+			if (ed==null)
+				interp.error("Macro editor not available");
+			else
+				interp.setDebugger(ed);
+		}
+		if (arg.equals("run"))
+			interp.setDebugMode(Debugger.RUN_TO_COMPLETION);
+		else if (arg.equals("break"))
+			interp.setDebugMode(Debugger.STEP);
+		else if (arg.equals("trace"))
+			interp.setDebugMode(Debugger.TRACE);
+		else if (arg.indexOf("fast")!=-1)
+			interp.setDebugMode(Debugger.FAST_TRACE);
+		else if (arg.equals("dump"))
+			interp.dump();
+		else if (arg.indexOf("throw")!=-1)
+			throw new IllegalArgumentException();
+		else
+			interp.error("Argument must be 'run', 'break', 'trace', 'fast-trace' or 'dump'");
+		IJ.setKeyUp(IJ.ALL_KEYS);
+		return null;
+	}
+
+	Variable[] doArray() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==PREDEFINED_FUNCTION||interp.token==STRING_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("copy"))
+			return copyArray();
+		else if (name.equals("trim"))
+			return trimArray();
+		else if (name.equals("sort"))
+			return sortArray();
+		else if (name.equals("rankPositions"))
+			return getRankPositions();
+		else if (name.equals("getStatistics"))
+			return getArrayStatistics();
+		else if (name.equals("sequence") || name.equals("getSequence"))
+			return getSequence();
+		else if (name.equals("fill"))
+			return fillArray();
+		else if (name.equals("reverse")||name.equals("invert"))
+			return reverseArray();
+		else if (name.equals("concat"))
+			return concatArray();
+		else if (name.equals("slice"))
+			return sliceArray();
+		else if (name.equals("print"))
+			return printArray();
+		else if (name.equals("resample"))
+			return resampleArray();
+		else if (name.equals("findMaxima"))
+			return findArrayMaxima(false);
+		else if (name.equals("findMinima"))
+			return findArrayMaxima(true);
+		else if (name.equals("show"))
+			return showArray();
+		else if (name.equals("fourier"))
+			return fourierArray();
+		else if (name.equals("getVertexAngles"))
+			return getVertexAngles();
+		else if (name.equals("rotate"))
+			return rotateArray();
+		else if (name.equals("deleteValue") || name.equals("delete"))
+			return deleteArrayValue();
+		else if (name.equals("deleteIndex"))
+			return deleteArrayIndex();
+		else if (name.equals("filter"))
+			return filterArray();
+		else
+			interp.error("Unrecognized Array function");
+		return null;
+	}
+
+	Variable[] filterArray() {
+		ArrayList list = new ArrayList();
+		interp.getLeftParen();
+		Variable[] a1 = getArray();
+		String filter = getLastString();
+		for (int i=0; i<a1.length; i++) {
+			String str = a1[i].getString();
+			boolean contains = false;
+			if (str!=null) {
+				if (filter.startsWith("(") && filter.endsWith(")"))
+					contains = FolderOpener.containsRegex(str, filter, false);
+				else
+			 		contains = str.contains(filter);
+				if (contains)
+					list.add(a1[i]);
+			}
+		}
+		return (Variable[])list.toArray(new Variable[list.size()]);
+	}
+
+	Variable[] deleteArrayIndex() {
+		interp.getLeftParen();
+		Variable[] arr1 = getArray();
+		int index = (int)getLastArg();
+		checkIndex(index, 0, arr1.length-1);
+		int len1 = arr1.length;
+		Variable[] arr2 = new Variable[len1-1];
+		int index2 = 0;
+		for (int i=0; i<len1; i++) {
+			if (i!=index)
+				arr2[index2++] = (Variable)arr1[i].clone();
+		}
+		return arr2;
+	}
+
+	Variable[] deleteArrayValue() {
+		interp.getLeftParen();
+		Variable[] arr1 = getArray();
+		double value = Double.MAX_VALUE;
+		String stringValue = null;
+		interp.getComma();
+		if (isStringArg())
+			stringValue = getString();
+		else
+			value = interp.getExpression();
+		interp.getRightParen();
+		int len1 = arr1.length;
+		Variable[] cleanArr = new Variable[len1];
+		int len2 = 0;
+		for (int jj = 0; jj < len1; jj++) {
+			int type = arr1[jj].getType();
+			boolean remove = false;
+			if (stringValue!=null) {
+				if (type==Variable.STRING) {
+					String str = arr1[jj].getString();
+					remove =  stringValue.equals(str);
+				}
+			} else if (type==Variable.VALUE) {
+				double val = arr1[jj].getValue();
+				remove =  (val==value);
+				remove = remove || (Double.isNaN(val) && Double.isNaN(value));
+			}
+			if (!remove)
+				cleanArr[len2++] = (Variable)arr1[jj].clone();
+		}
+		Variable[] shortenedArr = new Variable[len2];
+		for (int jj=0; jj<len2; jj++)
+			shortenedArr[jj] = cleanArr[jj];
+		return shortenedArr;
+	}
+
+	Variable[] fourierArray() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		int windowType = FHT.NO_WINDOW;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			String windowS = getString().toLowerCase();
+			if (windowS.equals("hamming"))
+				windowType = FHT.HAMMING;
+			else if (windowS.startsWith("hann")) //sometimes also called 'Hanning'
+				windowType = FHT.HANN;
+			else if (windowS.startsWith("flat"))
+				windowType = FHT.FLATTOP;
+			else if (!windowS.startsWith("no"))
+				interp.error("Invalid Fourier window '"+windowType+"'");
+		}
+		interp.getRightParen();
+		int n = a.length;
+		float[] data = new float[n];
+		for (int i=0; i<n; i++)
+			data[i] = (float)a[i].getValue();
+		float[] result = new FHT().fourier1D(data, windowType);
+		int n2 = result.length;
+		Variable[] a2 = new Variable[n2];
+		for (int i=0; i<n2; i++)
+			a2[i] = new Variable(result[i]);
+		return a2;
+	}
+
+	Variable[] printArray() {
+		String prefix = null;
+		interp.getLeftParen();
+		if (!isArrayArg() && isStringArg()) {
+			prefix = getString();
+			interp.getComma();
+		}
+		Variable[] a = getArray();
+		interp.getRightParen();
+		StringBuilder sb = joinArray(a, ", ");
+		if (prefix!=null)
+			sb.append(prefix+" ");
+		interp.log(sb.toString());
+		return null;
+	}
+
+	Variable[] concatArray() {
+		interp.getLeftParen();
+		ArrayList list = new ArrayList();
+		int len = 0;
+		do {
+			if (isArrayArg()) {
+				Variable[] a = getArray();
+				for (int i=0; i<a.length; i++) {
+					list.add((Variable)a[i].clone());
+					len++;
+				}
+			} else if (isStringArg()) {
+				Variable v = new Variable();
+				v.setString(getString());
+				list.add(v);
+				len++;
+			} else {
+				Variable v = new Variable();
+				v.setValue(interp.getExpression());
+				list.add(v);
+				len++;
+			}
+			interp.getToken();
+		} while (interp.token==',');
+		Variable[] a2 = new Variable[len];
+		int index = 0;
+		for (int i=0; i<list.size(); i++) {
+			Variable v = (Variable)list.get(i);
+			a2[index++] = v;
+		}
+		return a2;
+	}
+
+	Variable[] sliceArray() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		int len = a.length;
+		int i1 = (int)getNextArg();
+		int i2 = len;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			i2 = (int)interp.getExpression();
+		}
+		if (i1<0)
+			interp.error("Invalid argument");
+		if (i2>len) i2 = len;
+		int len2 = i2-i1;
+		if (len2<0) len2=0;
+		if (len2>len) len2=len;
+		interp.getRightParen();
+		Variable[] a2 = new Variable[len2];
+		for (int i=0; i<len2; i++)
+			a2[i] = (Variable)a[i1++].clone();
+		return a2;
+	}
+
+	Variable[] copyArray() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		interp.getRightParen();
+		return duplicate(a);
+	}
+
+	Variable[] duplicate(Variable[] a1) {
+		Variable[] a2 = new Variable[a1.length];
+		for (int i=0; i<a1.length; i++)
+			a2[i] = (Variable)a1[i].clone();
+		return a2;
+	}
+
+	Variable[] trimArray() {
+		interp.getLeftParen();
+		Variable[] a1 = getArray();
+		int len = a1.length;
+		int size = (int)getLastArg();
+		if (size<0) size = 0;
+		if (size>len) size = len;
+		Variable[] a2 = new Variable[size];
+		for (int i=0; i<size; i++)
+			a2[i] = (Variable)a1[i].clone();
+		return a2;
+	}
+
+	Variable[] sortArray() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		boolean multipleArrays= interp.nextToken()==',';
+		int[] indexes = null;
+		int len = a.length;
+		int nNumbers = 0;
+		for (int i=0; i<len; i++) {
+			if (a[i].getString()==null) nNumbers++;
+		}
+		if (nNumbers==len) {
+			double[] d = new double[len];
+			for (int i=0; i<len; i++)
+				d[i] = a[i].getValue();
+			if(multipleArrays)
+				indexes = Tools.rank(d);
+			Arrays.sort(d);
+			for (int i=0; i<len; i++)
+				a[i].setValue(d[i]);
+		} else if (nNumbers==0) {
+			String[] s = new String[len];
+			for (int i=0; i<len; i++)
+				s[i] = a[i].getString();
+			if(multipleArrays)
+				indexes = Tools.rank(s);
+			Arrays.sort(s, String.CASE_INSENSITIVE_ORDER);
+			for (int i=0; i<len; i++)
+				a[i].setString(s[i]);
+		} else{
+			interp.error("Mixed strings and numbers");
+			return a;
+		}
+		while (interp.nextToken()==',') {
+			interp.getComma();
+			Variable[] b = getArray();
+			if(b.length != len){
+				interp.error("Arrays must have same length");
+				return a;
+			}
+			Variable[] c = new Variable[len];
+			for (int jj = 0; jj < len; jj++){
+				c[jj] = b[indexes[jj]];
+			}
+			for (int jj = 0; jj < len; jj++){
+				b[jj] = c[jj];
+			}
+		}
+		interp.getRightParen();
+		return a;
+	}
+
+	Variable[] getRankPositions() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		interp.getRightParen();
+		int len = a.length;
+		int nNumbers = 0;
+		for (int i = 0; i < len; i++) {
+			if (a[i].getString()==null)
+				nNumbers++;
+		}
+		if (nNumbers!=len && nNumbers!=0) {
+			interp.error("Mixed strings and numbers");
+			return a;
+		}
+		Variable[] varArray = new Variable[len];
+		int[] indexes;
+		if (nNumbers==len) {
+			double[] doubles = new double[len];
+			for (int i = 0; i < len; i++)
+				doubles[i] = (double) (a[i].getValue());
+			indexes = Tools.rank(doubles);
+		} else {
+			String[] strings = new String[len];
+			for (int i = 0; i < len; i++)
+				strings[i] = a[i].getString();
+			indexes = Tools.rank(strings);
+		}
+		for (int i=0; i<len; i++)
+			varArray[i] = new Variable((double) indexes[i]);
+		return varArray;
+	}
+
+    Variable[] getArrayStatistics() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		Variable minv = getNextVariable();
+		Variable maxv=null, mean=null, std=null;
+		interp.getToken();
+		int arg = 1;
+		while (interp.token==',') {
+			arg++;
+			switch (arg) {
+				case 2: maxv = getVariable(); break;
+				case 3: mean = getVariable(); break;
+				case 4: std = getVariable(); break;
+				default: interp.error("')' expected");
+			}
+			interp.getToken();
+		}
+		if (interp.token!=')') interp.error("')' expected");
+		int n = a.length;
+		double sum=0.0, sum2=0.0, value;
+		double min = Double.POSITIVE_INFINITY;
+		double max = Double.NEGATIVE_INFINITY;
+		for (int i=0; i<n; i++) {
+			value = a[i].getValue();
+			sum += value;
+			sum2 += value*value;
+			if (value<min) min = value;
+			if (value>max) max = value;
+		}
+		minv.setValue(min);
+		if (maxv!=null) maxv.setValue(max);
+		if (mean!=null) mean.setValue(sum/n);
+		if (std!=null) {
+      			double stdDev = (n*sum2-sum*sum)/n;
+			stdDev = Math.sqrt(stdDev/(n-1.0));
+			std.setValue(stdDev);
+		}
+		return a;
+	}
+
+	Variable[] getSequence() {
+		int n = (int)getArg();
+		Variable[] a = new Variable[n];
+		for (int i=0; i<n; i++)
+			a[i] = new Variable(i);
+		return a;
+	}
+
+	Variable[] fillArray() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		double v = getLastArg();
+		for (int i=0; i<a.length; i++)
+			a[i].setValue(v);
+		return a;
+	}
+
+	Variable[] resampleArray() {
+		interp.getLeftParen();
+		Variable[] a1 = getArray();
+		int len1 = a1.length;
+		int len2 = (int)getLastArg();
+		if (len1 == 0 || len2<=0)
+			interp.error("Cannot resample from or to zero-length");
+		double[] d1 = new double[len1];
+		for (int i=0; i<len1; i++)
+			d1[i] = a1[i].getValue();
+		double[] d2 = Tools.resampleArray(d1, len2);
+		Variable[] a2 = new Variable[len2];
+		for (int i=0; i<len2; i++)
+			a2[i] = new Variable(d2[i]);
+		return a2;
+	}
+
+	Variable[] reverseArray() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		interp.getRightParen();
+		int n = a.length;
+		for (int i=0; i<n/2; i++) {
+			Variable temp = a[i];
+			a[i] = a[n-i-1];
+			a[n-i-1] = temp;
+		}
+		return a;
+	}
+
+	Variable[] rotateArray() {
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		interp.getComma();
+		int rot = (int) interp.getExpression();
+		interp.getRightParen();
+		int len = a.length;
+		while(rot<0)
+			rot += len;
+		Variable[] b = new Variable[len];
+		for (int i=0; i<len; i++) {
+			int dest = (i + rot)%len;
+			b[dest] = a[i];
+		}
+		for (int i=0; i<len; i++)
+			a[i]= b[i];
+		return a;
+	}
+
+	Variable[] findArrayMaxima(boolean minima) {
+		int edgeMode = 0;
+		interp.getLeftParen();
+		Variable[] a = getArray();
+		double tolerance = getNextArg();
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			edgeMode = (int)interp.getExpression();
+		}
+		interp.getRightParen();
+		int n = a.length;
+		double[] d = new double[n];
+		for (int i=0; i<n; i++)
+			d[i] = a[i].getValue();
+		int[] maxima = null;
+		if (minima)
+			maxima = MaximumFinder.findMinima(d, tolerance, edgeMode);
+		else
+			maxima = MaximumFinder.findMaxima(d, tolerance, edgeMode);
+		int n2 = maxima.length;
+		Variable[] a2 = new Variable[n2];
+		for (int i=0; i<n2; i++)
+			a2[i] = new Variable(maxima[i]);
+		return a2;
+	}
+
+	Variable[] getVertexAngles() {
+		interp.getLeftParen();
+		Variable[] xx = getArray();
+		interp.getComma();
+		Variable[] yy = getArray();
+		interp.getComma();
+		int arm = (int) interp.getExpression();
+		int len = xx.length;
+		if (yy.length != len)
+			interp.error("Same size expected");
+		double[] x = new double[len];
+		double[] y = new double[len];
+		double[] vAngles = new double[len];
+		interp.getRightParen();
+		Variable[] a2 = new Variable[len];
+		for (int jj = 0; jj < len; jj++) {
+			x[jj] = xx[jj].getValue();
+			y[jj] = yy[jj].getValue();
+		}
+		for (int mid = 0; mid < len; mid++) {
+			int left = (mid + 10 * len - arm) % len;
+			int right = (mid + arm) % len;
+			double dotprod = (x[right] - x[mid]) * (x[left] - x[mid]) + (y[right] - y[mid]) * (y[left] - y[mid]);
+			double crossprod = (x[right] - x[mid]) * (y[left] - y[mid]) - (y[right] - y[mid]) * (x[left] - x[mid]);
+			double phi = 180.0 - 180.0 / Math.PI * Math.atan2(crossprod, dotprod);
+			while (phi >= 180.0)
+				phi -= 360.0;
+			vAngles[mid] = phi;
+		}
+		for (int i = 0; i < len; i++)
+			a2[i] = new Variable(vAngles[i]);
+		return a2;
+	}
+
+	Variable[] showArray() {
+		int maxLength = 0;
+		String title = "Arrays";
+		ArrayList arrays = new ArrayList();
+		ArrayList names = new ArrayList();
+		interp.getLeftParen();
+		do {
+			if (isStringArg() && !isArrayArg())
+				title = getString();
+			else {
+				int symbolTableAddress = pgm.code[interp.pc+1]>>TOK_SHIFT;
+				names.add(pgm.table[symbolTableAddress].str);
+				Variable[] a = getArray();
+				arrays.add(a);
+				if (a.length>maxLength)
+					maxLength = a.length;
+			}
+			interp.getToken();
+		} while (interp.token==',');
+		if (interp.token!=')')
+			interp.error("')' expected");
+		int n = arrays.size();
+		if (n==1) {
+			if (title.equals("Arrays"))
+				title = (String)names.get(0);
+			names.set(0, "Value");
+		}
+		ResultsTable rt = new ResultsTable();
+		//rt.setPrecision(Analyzer.getPrecision());
+		int openParenIndex = title.indexOf("(");
+		boolean showRowNumbers = false;
+		if (openParenIndex>=0) {
+			String options = title.substring(openParenIndex, title.length());
+			title = title.substring(0, openParenIndex);
+			title = title.trim();
+			showRowNumbers = options.contains("row") || options.contains("1");
+			if (!showRowNumbers && options.contains("index")) {
+				for (int i=0; i<maxLength; i++)
+					rt.setValue("Index", i, ""+i);
+			}
+		}
+		if (showRowNumbers)
+			rt.showRowNumbers(true);
+		for (int arr=0; arr<n; arr++) {
+			Variable[] a = (Variable[])arrays.get(arr);
+			String heading = (String)names.get(arr);
+			for (int i=0; i<maxLength; i++) {
+				if (i>=a.length) {
+					rt.setValue(heading, i, "");
+					continue;
+				}
+				String s = a[i].getString();
+				if (s!=null)
+					rt.setValue(heading, i, s);
+				else
+					rt.setValue(heading, i, a[i].getValue());
+			}
+		}
+     	rt.show(title);
+		waitUntilActivated(title);
+		return null;
+	}
+
+	double charCodeAt() {
+		String str = getFirstString();
+		int index = (int)getLastArg();
+		checkIndex(index, 0, str.length()-1);
+		return str.charAt(index);
+	}
+
+	void doWand() {
+		int x = (int)getFirstArg();
+		int y = (int)getNextArg();
+		double tolerance = 0.0;
+		String mode = null;
+		if (interp.nextToken()==',') {
+			tolerance = getNextArg();
+			mode = getNextString();
+		}
+		interp.getRightParen();
+		IJ.doWand(x, y, tolerance, mode);
+		resetImage();
+	}
+
+	private String doIJ() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==NUMERIC_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("pad"))
+			return pad();
+		else if (name.equals("deleteRows"))
+			IJ.deleteRows((int)getFirstArg(), (int)getLastArg());
+		else if (name.equals("log"))
+			IJ.log(getStringArg());
+		else if (name.equals("freeMemory"))
+			{interp.getParens(); return IJ.freeMemory();}
+		else if (name.equals("currentMemory"))
+			{interp.getParens(); return ""+IJ.currentMemory();}
+		else if (name.equals("maxMemory"))
+			{interp.getParens(); return ""+IJ.maxMemory();}
+		else if (name.equals("getToolName"))
+			{interp.getParens(); return ""+IJ.getToolName();}
+		else if (name.equals("redirectErrorMessages"))
+			{interp.getParens(); IJ.redirectErrorMessages(); return null;}
+		else if (name.equals("renameResults"))
+			renameResults();
+		else if (name.equals("getFullVersion"))
+			{interp.getParens(); return ""+IJ.getFullVersion();}
+		else if (name.equals("checksum"))
+			return checksum();
+		else
+			interp.error("Unrecognized IJ function name");
+		return null;
+	}
+
+	private String checksum(){
+		String method = getFirstString();
+		String src = getLastString();
+		method = method.toUpperCase();
+		if (method.contains("FILE") && method.contains("MD5"))
+			return Tools.getHash("MD5", true, src);
+		if (method.contains("STRING") && method.contains("MD5"))
+			return Tools.getHash("MD5", false, src);
+		if (method.contains("FILE") && method.contains("SHA-256"))
+			return Tools.getHash("SHA-256", true, src);
+		if (method.contains("STRING") && method.contains("SHA-256"))
+			return Tools.getHash("SHA-256", false, src);
+		interp.error("must contain 'file' or 'string' and 'MD5' or 'SHA-256'");
+		return "0";
+	}
+
+	private String pad() {
+		int intArg = 0;
+		String stringArg = null;
+		interp.getLeftParen();
+		if (isStringArg())
+			stringArg = getString();
+		else
+			intArg = (int)interp.getExpression();
+		int digits = (int)getLastArg();
+		if (stringArg!=null)
+			return IJ.pad(stringArg, digits);
+		else
+			return IJ.pad(intArg, digits);
+	}
+
+	private void renameResults() {
+		String arg1 = getFirstString();
+		String arg2 = null;
+		if (interp.nextToken()==')')
+			interp.getRightParen();
+		else
+			arg2 = getLastString();
+		if (resultsPending) {
+			ResultsTable rt = Analyzer.getResultsTable();
+			if (rt!=null && rt.size()>0)
+				rt.show("Results");
+			resultsPending = false;
+		}
+		if (arg2!=null)
+			IJ.renameResults(arg1, arg2);
+		else
+			IJ.renameResults(arg1);
+	}
+
+	double overlay() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==ARRAY_FUNCTION
+		|| interp.token==PREDEFINED_FUNCTION||interp.token==USER_FUNCTION))
+			interp.error("Function name expected");
+		String name = interp.tokenString;
+		ImagePlus imp = getImage();
+		if (name.equals("lineTo"))
+			return overlayLineTo();
+		else if (name.equals("moveTo"))
+			return overlayMoveTo();
+		else if (name.equals("drawLine"))
+			return overlayDrawLine();
+		else if (name.equals("drawRect"))
+			return overlayDrawRectOrEllipse(imp, false);
+		else if (name.equals("drawEllipse"))
+			return overlayDrawRectOrEllipse(imp, true);
+		else if (name.equals("drawString"))
+			return overlayDrawString(imp);
+		else if (name.equals("add"))
+			return addDrawing(imp);
+		else if (name.equals("show"))
+			return showOverlay(imp);
+		else if (name.equals("hide"))
+			return hideOverlay(imp);
+		else if (name.equals("selectable"))
+			return overlaySelectable(imp);
+		else if (name.equals("remove"))
+			return removeOverlay(imp);
+		else if (name.equals("clear"))
+			return clearOverlay(imp);
+		else if (name.equals("paste")) {
+			interp.getParens();
+			if (overlayClipboard==null)
+				interp.error("Overlay clipboard empty");
+			getImage().setOverlay(overlayClipboard);
+			return Double.NaN;
+		} else if (name.equals("drawLabels")) {
+			overlayDrawLabels = getBooleanArg();
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null) {
+				overlay.drawLabels(overlayDrawLabels);
+				imp.draw();
+			}
+			return Double.NaN;
+		} else if (name.equals("useNamesAsLabels")) {
+			boolean useNames = getBooleanArg();
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null) {
+				overlay.drawNames(useNames);
+				imp.draw();
+			}
+			return Double.NaN;
+		}
+		Overlay overlay = imp.getOverlay();
+		int size = overlay!=null?overlay.size():0;
+		if (overlay==null && name.equals("size"))
+			return 0.0;
+		else if (name.equals("hidden"))
+			return overlay!=null && imp.getHideOverlay()?1.0:0.0;
+		else if (name.equals("addSelection") || name.equals("addRoi"))
+			return overlayAddSelection(imp, overlay);
+		else if (name.equals("setPosition")) {
+			addDrawingToOverlay(imp);
+			return overlaySetPosition(overlay);
+		} else if (name.equals("setFillColor"))
+			return overlaySetFillColor(overlay);
+		else if (name.equals("indexAt")) {
+			int x = (int)getFirstArg();
+			int y = (int)getLastArg();
+			return overlay!=null?overlay.indexAt(x,y):-1;
+		} else if (name.equals("getType")) {
+			int index = (int)getArg();
+			if (overlay==null || index==-1) return -1;
+			checkIndex(index, 0, size-1);
+			return overlay.get(index).getType();
+		}
+		if (overlay==null)
+			interp.error("No overlay");
+		if (name.equals("size")||name.equals("getSize"))
+			return size;
+		else if (name.equals("copy")) {
+			interp.getParens();
+			overlayClipboard = getImage().getOverlay();
+			return Double.NaN;
+		} else if (name.equals("update")) {
+			int index = (int)getArg();
+			checkIndex(index, 0, size-1);
+			overlay.set(imp.getRoi(), index);
+			return Double.NaN;
+		} else if (name.equals("removeSelection")||name.equals("removeRoi")) {
+			int index = (int)getArg();
+			checkIndex(index, 0, size-1);
+			overlay.remove(index);
+			imp.draw();
+			return Double.NaN;
+		} else if (name.equals("activateSelection")||name.equals("activateSelectionAndWait")||name.equals("activateRoi")) {
+			boolean waitForDisplayRefresh = name.equals("activateSelectionAndWait");
+			return activateSelection(imp, overlay, waitForDisplayRefresh);
+		} else if (name.equals("moveSelection")) {
+			int index = (int)getFirstArg();
+			int x = (int)getNextArg();
+			int y = (int)getLastArg();
+			checkIndex(index, 0, size-1);
+			Roi roi = overlay.get(index);
+			roi.setLocation(x, y);
+			imp.draw();
+			return Double.NaN;
+		} else if (name.equals("measure")) {
+			ResultsTable rt = overlay.measure(imp);
+			if (IJ.getInstance()==null)
+				Analyzer.setResultsTable(rt);
+			else
+				rt.show("Results");
+		} else if (name.equals("fill")) {
+			interp.getLeftParen();
+			Color foreground = getColor();
+			Color background = null;
+			if (interp.nextToken()!=')') {
+				interp.getComma();
+				background = getColor();
+			}
+			interp.getRightParen();
+			overlay.fill(imp, foreground, background);
+			return Double.NaN;
+		} else if (name.equals("flatten")) {
+			IJ.runPlugIn("ij.plugin.OverlayCommands", "flatten");
+			return Double.NaN;
+		} else if (name.equals("setLabelFontSize")) {
+			int fontSize = (int)getFirstArg();
+			String options = null;
+			if (interp.nextToken()!=')')
+				options = getLastString();
+			else
+				interp.getRightParen();
+			overlay.setLabelFontSize(fontSize, options);
+			return Double.NaN;
+		} else if (name.equals("setLabelColor")) {
+			interp.getLeftParen();
+			Color color = getColor();
+			if (interp.nextToken()==',') {
+				interp.getComma();
+				Color ignore = getColor();
+				overlay.drawBackgrounds(true);
+			}
+			interp.getRightParen();
+			overlay.setLabelColor(color);
+			overlay.drawLabels(true);
+			return Double.NaN;
+		} else if (name.equals("setStrokeColor")) {
+			interp.getLeftParen();
+			Color color = getColor();
+			interp.getRightParen();
+			overlay.setStrokeColor(color);
+			return Double.NaN;
+		} else if (name.equals("setStrokeWidth")) {
+			overlay.setStrokeWidth(getArg());
+			return Double.NaN;
+		} else if (name.equals("removeRois")) {
+			overlay.remove(getStringArg());
+			return Double.NaN;
+		} else if (name.equals("getBounds")) {
+			return getOverlayElementBounds(overlay);
+ 		} else if (name.equals("cropAndSave")) {
+ 			Roi[] rois = overlay.toArray();
+ 			imp.cropAndSave(rois, getFirstString(), getLastString());
+			return Double.NaN;
+		} else if (name.equals("xor")) {
+			double[] arg = getFirstArray();
+			interp.getRightParen();
+			int[] indexes = new int[arg.length];
+			for (int i=0; i<arg.length; i++)
+ 				indexes[i] = (int)arg[i];
+ 			imp.setRoi(Roi.xor(overlay.toArray(indexes)));
+			return Double.NaN;
+		} else
+			interp.error("Unrecognized function name");
+		return Double.NaN;
+	}
+
+	private double activateSelection(ImagePlus imp, Overlay overlay, boolean wait) {
+		int index = (int)getArg();
+		int size = overlay.size();
+		checkIndex(index, 0, size-1);
+		Roi roi = overlay.get(index);
+		if (roi==null)
+			return Double.NaN;;
+		if (imp.getStackSize()>1) {
+			if (imp.isHyperStack() && roi.hasHyperStackPosition()) {
+				int c = roi.getCPosition();
+				int z = roi.getZPosition();
+				int t = roi.getTPosition();
+				c = c>0?c:imp.getChannel();
+				z = z>0?z:imp.getSlice();
+				t = t>0?t:imp.getFrame();
+				imp.setPosition(c, z, t);
+			} else if (roi.getPosition()>0)
+				imp.setSlice(roi.getPosition());
+		}
+		if (wait) { // wait for display to finish updating
+			ImageCanvas ic = imp.getCanvas();
+			if (ic!=null) ic.setPaintPending(true);
+			imp.setRoi(roi, !Interpreter.isBatchMode());
+			long t0 = System.currentTimeMillis();
+			do {
+				IJ.wait(5);
+			 } while (ic!=null && ic.getPaintPending() && System.currentTimeMillis()-t0<50);
+		} else
+			imp.setRoi(roi, !Interpreter.isBatchMode());
+		if (Analyzer.addToOverlay())
+			ResultsTable.selectRow(roi);
+		return Double.NaN;
+	}
+
+	private double getOverlayElementBounds(Overlay overlay) {
+		int index = (int)getFirstArg();
+		Variable x = getNextVariable();
+		Variable y = getNextVariable();
+		Variable width = getNextVariable();
+		Variable height = getLastVariable();
+		Roi roi = overlay.get(index);
+		if (roi==null)
+			return Double.NaN;
+		Rectangle2D.Double r = roi.getFloatBounds();
+		x.setValue(r.x);
+		y.setValue(r.y);
+		width.setValue(r.width);
+		height.setValue(r.height);
+		return Double.NaN;
+	}
+
+	double overlayAddSelection(ImagePlus imp, Overlay overlay) {
+		String strokeColor = null;
+		double strokeWidth = Double.NaN;
+		String fillColor = null;
+		if (interp.nextToken()=='(') {
+			interp.getLeftParen();
+			if (isStringArg()) {
+				strokeColor = getString();
+				if (interp.nextToken()==',') {
+					interp.getComma();
+					strokeWidth = interp.getExpression();
+					if (interp.nextToken()==',') {
+						interp.getComma();
+						fillColor = interp.getString();
+					}
+				}
+			}
+			interp.getRightParen();
+		}
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			interp.error("No selection");
+		if (offscreenOverlay!=null) {
+			imp.setOverlay(offscreenOverlay);
+			offscreenOverlay = null;
+			overlay = imp.getOverlay();
+		}
+		if (overlay==null)
+			overlay = new Overlay();
+		if (strokeColor!=null && !strokeColor.equals("")) {
+			roi.setFillColor(null);
+			roi.setStrokeColor(Colors.decode(strokeColor, Color.black));
+		}
+		if (!Double.isNaN(strokeWidth))
+			roi.setStrokeWidth(strokeWidth);
+		if (fillColor!=null && !fillColor.equals(""))
+			roi.setFillColor(Colors.decode(fillColor, Color.black));
+		overlay.add(roi);
+		imp.setOverlay(overlay);
+		return Double.NaN;
+	}
+
+	double overlaySetPosition(Overlay overlay) {
+		int c=0, z=0, t=0;
+		int nargs = 1;
+		int n = (int)getFirstArg();
+		if (interp.nextToken()==',') {
+			nargs = 3;
+			c = n;
+			z = (int)getNextArg();
+			t = (int)getLastArg();
+		} else
+			interp.getRightParen();
+		if (overlay==null)
+			overlay = offscreenOverlay;
+		if (overlay==null)
+			interp.error("No overlay");
+		int size = overlay.size();
+		if (size==0)
+			return Double.NaN;
+		if (nargs==1)
+			overlay.get(size-1).setPosition(n);
+		else if (nargs==3)
+			overlay.get(size-1).setPosition(c, z, t);
+		return Double.NaN;
+	}
+
+	double overlaySetFillColor(Overlay overlay) {
+		interp.getLeftParen();
+		Color color = getColor();
+		interp.getRightParen();
+		if (overlay==null)
+			overlay = offscreenOverlay;
+		if (overlay==null)
+			interp.error("No overlay");
+		int size = overlay.size();
+		if (size>0)
+			overlay.get(size-1).setFillColor(color);
+		return Double.NaN;
+	}
+
+	double overlayMoveTo() {
+		if (overlayPath==null)
+			overlayPath = new GeneralPath();
+		interp.getLeftParen();
+		float x = (float)interp.getExpression();
+		interp.getComma();
+		float y = (float)interp.getExpression();
+		interp.getRightParen();
+		overlayPath.moveTo(x, y);
+		return Double.NaN;
+	}
+
+	double overlayLineTo() {
+		if (overlayPath==null) {
+			overlayPath = new GeneralPath();
+			overlayPath.moveTo(0, 0);
+		}
+		interp.getLeftParen();
+		float x = (float)interp.getExpression();
+		interp.getComma();
+		float y = (float)interp.getExpression();
+		interp.getRightParen();
+		overlayPath.lineTo(x, y);
+		return Double.NaN;
+	}
+
+	double overlayDrawLine() {
+		if (overlayPath==null) overlayPath = new GeneralPath();
+		interp.getLeftParen();
+		float x1 = (float)interp.getExpression();
+		interp.getComma();
+		float y1 = (float)interp.getExpression();
+		interp.getComma();
+		float x2 = (float)interp.getExpression();
+		interp.getComma();
+		float y2 = (float)interp.getExpression();
+		interp.getRightParen();
+		overlayPath.moveTo(x1, y1);
+		overlayPath.lineTo(x2, y2);
+		return Double.NaN;
+	}
+
+	double overlayDrawRectOrEllipse(ImagePlus imp, boolean ellipse) {
+		addDrawingToOverlay(imp);
+		float x = (float)Math.round(getFirstArg());
+		float y = (float)Math.round(getNextArg());
+		float w = (float)Math.round(getNextArg());
+		float h = (float)Math.round(getLastArg());
+		Shape shape = null;
+		if (ellipse)
+			shape = new Ellipse2D.Float(x, y, w, h);
+		else
+			shape = new Rectangle2D.Float(x, y, w, h);
+		Roi roi = new ShapeRoi(shape);
+		addRoi(imp, roi);
+		return Double.NaN;
+	}
+
+	double overlayDrawString(ImagePlus imp) {
+		addDrawingToOverlay(imp);
+		String text = getFirstString();
+		int x = (int)getNextArg();
+		int y = (int)getNextArg();
+		double angle = 0.0;
+		if (interp.nextToken()==',')
+			angle = getLastArg();
+		else
+			interp.getRightParen();
+		Font font = this.font;
+		boolean nullFont = font==null;
+		if (nullFont)
+			font = imp.getProcessor().getFont();
+		TextRoi roi = new TextRoi(text, x, y, font);  // use drawString() compatible constructor
+		if (!nullFont && !antialiasedText)
+			roi.setAntiAlias(false);
+		roi.setAngle(angle);
+		roi.setJustification(justification);
+		addRoi(imp, roi);
+		return Double.NaN;
+	}
+
+	double addDrawing(ImagePlus imp) {
+		interp.getParens();
+		addDrawingToOverlay(imp);
+		return Double.NaN;
+	}
+
+	void addDrawingToOverlay(ImagePlus imp) {
+		if (overlayPath==null)
+			return;
+		Roi roi = new ShapeRoi(overlayPath);
+		overlayPath = null;
+		addRoi(imp, roi);
+	}
+
+	void addRoi(ImagePlus imp, Roi roi){
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null || overlay.size()==0) {
+			if (offscreenOverlay==null)
+				offscreenOverlay = new Overlay();
+			overlay = offscreenOverlay;
+		}
+		if (globalColor!=null)
+			roi.setStrokeColor(globalColor);
+		roi.setStrokeWidth(getProcessor().getLineWidth());
+		overlay.add(roi);
+	}
+
+	double showOverlay(ImagePlus imp) {
+		interp.getParens();
+		addDrawingToOverlay(imp);
+		if (offscreenOverlay!=null) {
+			imp.setOverlay(offscreenOverlay);
+			offscreenOverlay = null;
+		} else
+			imp.setHideOverlay(false);
+		return Double.NaN;
+	}
+
+	double hideOverlay(ImagePlus imp) {
+		interp.getParens();
+		imp.setHideOverlay(true);
+		return Double.NaN;
+	}
+
+	double overlaySelectable(ImagePlus imp) {
+		boolean selectable = getBooleanArg();
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null)
+			overlay.selectable(selectable);
+		return Double.NaN;
+	}
+
+	double removeOverlay(ImagePlus imp) {
+		interp.getParens();
+		imp.setOverlay(null);
+		offscreenOverlay = null;
+		return Double.NaN;
+	}
+
+	double clearOverlay(ImagePlus imp) {
+		interp.getParens();
+		offscreenOverlay = null;
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null)
+			overlay.clear();
+		return Double.NaN;
+	}
+
+	private Variable doTable() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD || interp.token==NUMERIC_FUNCTION || interp.token==PREDEFINED_FUNCTION || interp.token==STRING_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("create"))
+			return resetTable();
+		else if (name.equals("size"))
+			return new Variable(getResultsTable(getTitleArg()).size());
+		else if (name.equals("get"))
+			return new Variable(getResult(getRT(null)));
+		else if (name.equals("getColumn"))
+			return getColumn();
+		else if (name.equals("getString"))
+			return new Variable(getResultString(getRT(null)));
+		else if (name.equals("set"))
+			return setTableValue();
+		else if (name.equals("setColumn"))
+			return setTableColumn();
+		else if (name.equals("reset"))
+			return resetTable();
+		else if (name.equals("update"))
+			return updateTable();
+		else if (name.equals("applyMacro"))
+			return applyMacroToTable();
+		else if (name.equals("deleteRows"))
+			return deleteRows();
+		else if (name.equals("deleteColumn"))
+			return deleteColumn();
+		else if (name.equals("renameColumn"))
+			return renameColumn();
+		else if (name.equals("save"))
+			return saveTable();
+		else if (name.equals("open"))
+			return openTable();
+		else if (name.equals("title"))
+			return new Variable(getResultsTable(getTitleArg()).getTitle());
+		else if (name.equals("headings"))
+			return new Variable(getResultsTable(getTitleArg()).getColumnHeadings());
+		else if (name.equals("allHeadings"))
+			return getAllHeadings();
+		else if (name.equals("showRowNumbers"))
+			return showRowNumbers(true);
+		else if (name.equals("showRowIndexes"))
+			return showRowNumbers(false);
+		else if (name.startsWith("saveColumnHeader"))
+			return saveColumnHeaders();
+		else if (name.equals("sort"))
+			return sortTable();
+		else if (name.equals("hideRowNumbers")) {
+			getResultsTable(getTitleArg()).showRowNumbers(false);
+			return null;
+		} else if (name.equals("rename")) {
+			renameResults();
+			return null;
+		} else if (name.startsWith("showArray")) {
+			showArray();
+			return null;
+		} else if (name.equals("getSelectionStart"))
+			return getSelectionStart();
+		else if (name.equals("getSelectionEnd"))
+			return getSelectionEnd();
+		else if (name.equals("setSelection"))
+			return setSelection();
+		else if (name.equals("setLocAndSize") || name.equals("setLocationAndSize"))
+			return setTableLocAndSize();
+		else
+			interp.error("Unrecognized function name");
+		return null;
+	}
+
+	private Variable setTableLocAndSize() {
+		double x = getFirstArg();
+		double y = getNextArg();
+		double width = getNextArg();
+		double height = getNextArg();
+		String title = getTitle();
+		if (title==null) {
+			ResultsTable rt = getResultsTable(title);
+			title = rt.getTitle();
+		}
+		Frame frame = WindowManager.getFrame(title);
+		if (frame!=null) {
+			Point loc = frame.getLocation();
+			Dimension size = frame.getSize();
+			frame.setLocation(Double.isNaN(x)?loc.x:(int)x, Double.isNaN(y)?loc.y:(int)y);
+			frame.setSize(Double.isNaN(width)?size.width:(int)width, Double.isNaN(height)?size.height:(int)height);
+		}
+		return null;
+	}
+
+	private Variable setSelection() {
+		interp.getLeftParen();
+		double from = interp.getExpression();
+		interp.getComma();
+		double to = interp.getExpression();
+		ResultsTable rt = getResultsTable(getTitle());
+		String title = rt.getTitle();
+		Frame f = WindowManager.getFrame(title);
+		if (f!=null && (f instanceof TextWindow)){
+			TextWindow tWin = (TextWindow)f;
+			if (from == -1 && to == -1)
+				tWin.getTextPanel().resetSelection();
+			else
+				tWin.getTextPanel().setSelection((int)from, (int)to);
+			return null;
+		}
+		interp.error("\""+title+"\" table not found");
+		return null;
+	}
+
+	private Variable getSelectionStart() {
+		int selStart = -1;
+		ResultsTable rt = getResultsTable(getTitleArg());
+		String title = rt.getTitle();
+		Frame f = WindowManager.getFrame(title);
+		if (f!=null && (f instanceof TextWindow)){
+			TextWindow tWin = (TextWindow)f;
+			selStart = tWin.getTextPanel().getSelectionStart();
+			return new Variable(selStart);
+		}
+		return new Variable(selStart);
+	}
+
+	private Variable getSelectionEnd() {
+		int selEnd = -1;
+		ResultsTable rt = getResultsTable(getTitleArg());
+		String title = rt.getTitle();
+		Frame f = WindowManager.getFrame(title);
+		if (f!=null && (f instanceof TextWindow)){
+			TextWindow tWin = (TextWindow)f;
+			selEnd = tWin.getTextPanel().getSelectionEnd();
+			return new Variable(selEnd);
+		}
+		interp.error("\""+title+"\" table not found");
+		return new Variable(selEnd);
+	}
+
+	private Variable setTableValue() {
+		ResultsTable rt = getRT(null);
+		setResult(rt);
+		return null;
+	}
+
+	private Variable setTableColumn() {
+		String column = getFirstString();
+		Variable[] array = new Variable[0];
+		if (interp.nextToken()!=')') {
+			interp.getComma();
+			array = getArray();
+		}
+		ResultsTable rt = getResultsTable(getTitle());
+		rt.setColumn(column, array);
+		rt.show(rt.getTitle());
+		return null;
+	}
+
+	private Variable updateTable() {
+		String title = getTitleArg();
+		ResultsTable rt = getResultsTable(title);
+		rt.show(rt.getTitle());
+		unUpdatedTable = null;
+		if (rt==Analyzer.getResultsTable())
+			resultsPending = false;
+		return null;
+	}
+
+	private Variable resetTable() {
+		String title = getTitleArg();
+		ResultsTable rt = null;
+		if ("Results".equals(title)) {
+			rt = Analyzer.getResultsTable();
+			rt.showRowNumbers(false);
+			rt.reset();
+			rt.show("Results");
+			toFront("Results");
+			return null;
+		}
+		if (getRT(title)==null) {
+			rt = new ResultsTable();
+			rt.show(title);
+			waitUntilActivated(title);
+		} else {
+			rt = getResultsTable(title);
+			rt.reset();
+			toFront(title);
+			if (rt==Analyzer.getResultsTable())
+				resultsPending = true;
+		}
+		return null;
+	}
+
+	private void waitUntilActivated(String title) {
+		long start = System.currentTimeMillis();
+		while (true) {
+			IJ.wait(5);
+			Frame frame = WindowManager.getFrontWindow();
+			String title2 = frame!=null?frame.getTitle():null;
+			if (title.equals(title2))
+				return;
+			if ((System.currentTimeMillis()-start)>200)
+				break;
+		}
+	}
+
+
+	private void toFront(String title) {
+		if (title==null)
+			return;
+		Frame frame = WindowManager.getFrame(title);
+		if (frame!=null) {
+			frame.toFront();
+			WindowManager.setWindow(frame);
+		}
+	}
+
+	private Variable applyMacroToTable() {
+		String macro = getFirstString();
+		String title = getTitle();
+		if (macro.equals("Results")) {
+			macro = title;
+			title = "Results";
+		}
+		ResultsTable rt = getResultsTable(title);
+		rt.applyMacro(macro);
+		rt.show(rt.getTitle());
+		return null;
+	}
+
+	private Variable deleteRows() {
+		int row1 = (int)getFirstArg();
+		int row2 = (int)getNextArg();
+		String title = getTitle();
+		ResultsTable rt = getResultsTable(title);
+		int tableSize = rt.size();
+		rt.deleteRows(row1, row2);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			Overlay.updateTableOverlay(imp, row1, row2, tableSize);
+		rt.show(title);
+		return null;
+	}
+
+	private Variable deleteColumn() {
+		String column = getFirstString();
+		String title = getTitle();
+		ResultsTable rt = getResultsTable(title);
+		try {
+			rt.deleteColumn(column);
+			unUpdatedTable = rt;
+		} catch (Exception e) {
+			interp.error(e.getMessage());
+		}
+		return null;
+	}
+
+	private Variable getColumn() {
+		String col = getFirstString();
+		ResultsTable rt = getResultsTable(getTitle());
+		Variable column = null;
+		try {
+			column =  new Variable(rt.getColumnAsVariables(col));
+		} catch (Exception e) {
+			interp.error(e.getMessage());
+		}
+		return column;
+	}
+
+	private Variable renameColumn() {
+		String oldName = getFirstString();
+		String newName = getNextString();
+		String title = getTitle();
+		ResultsTable rt = getResultsTable(title);
+		try {
+			rt.renameColumn(oldName, newName);
+			unUpdatedTable = rt;
+		} catch (Exception e) {
+			interp.error(e.getMessage());
+		}
+		return null;
+	}
+
+	private Variable showRowNumbers(boolean numbers) {
+		boolean show = (int)getFirstArg()!=0;
+		ResultsTable rt = getResultsTable(getTitle());
+		if (numbers)
+			rt.showRowNumbers(show);
+		else
+			rt.showRowIndexes(show);
+		unUpdatedTable = rt;
+		return null;
+	}
+
+	private Variable saveColumnHeaders() {
+		boolean save = (int)getFirstArg()!=0;
+		ResultsTable rt = getResultsTable(getTitle());
+		rt.saveColumnHeaders(save);
+		unUpdatedTable = rt;
+		return null;
+	}
+
+	private Variable sortTable() {
+		String column = getFirstString();
+		ResultsTable rt = getResultsTable(getTitle());
+		try {
+			rt.sort(column);
+		} catch (Exception e) {
+			interp.error(e.getMessage());
+		}
+		rt.show(rt.getTitle());
+		return null;
+	}
+
+	private Variable saveTable() {
+		String path = getFirstString();
+		ResultsTable rt = getResultsTable(getTitle());
+		try {
+			rt.saveAs(path);
+		} catch (Exception e) {
+			String msg = e.getMessage();
+			if (msg!=null && !msg.startsWith("Macro canceled"))
+				interp.error(msg);
+		}
+		return null;
+	}
+
+	private Variable openTable() {
+		String path = getFirstString();
+		String title = getTitle();
+		if (title==null)
+			title = new File(path).getName();
+		ResultsTable rt = null;
+		try {
+			rt = rt.open(path);
+		} catch (Exception e) {
+			String msg = e.getMessage();
+			if (!msg.startsWith("Macro canceled"))
+				interp.error(msg);
+		}
+		rt.show(title);
+		return null;
+	}
+
+	private Variable getAllHeadings() {
+		interp.getParens();
+		String[] headings = ResultsTable.getDefaultHeadings();
+		StringBuilder sb = new StringBuilder(250);
+		for (int i=0; i<headings.length; i++) {
+			sb.append(headings[i]);
+			if (i<headings.length-1)
+				sb.append("\t");
+		}
+		return new Variable(sb.toString());
+	}
+
+	private String getTitle() {
+		String title = null;
+		if (interp.nextToken()==',') {
+			interp.getComma();
+			title = getString();
+		}
+		interp.getRightParen();
+		return title;
+	}
+
+	private String getTitleArg() {
+		String title = null;
+		if (interp.nextToken() == '(') {
+			interp.getLeftParen();
+			if (interp.nextToken()!=')')
+				title = getString();
+			interp.getRightParen();
+		}
+		return title;
+	}
+
+	private ResultsTable getResultsTable(String title) {
+		ResultsTable rt = getRT(title);
+		if (title==null)
+			title="Results";
+		if (rt==null && "Results".equals(title))
+			rt = Analyzer.getResultsTable();
+		if (rt==null)
+			interp.error("\""+title+"\" table not found");
+		return rt;
+	}
+
+	private ResultsTable getRT(String title) {
+		if (interp.applyMacroTable!=null && title==null)
+			return interp.applyMacroTable;
+		ResultsTable rt = null;
+		Frame frame = null;
+		if (title==null) {
+			frame = WindowManager.getFrontWindow();
+			if (!(frame instanceof TextWindow))
+				frame = null;
+			if (frame!=null) {
+				rt = ((TextWindow)frame).getResultsTable();
+				if (rt==null) {
+					if (currentTable!=null)
+						return currentTable;
+					frame = null;
+				} else {
+					currentTable = rt;
+					return rt;
+				}
+			}
+		}
+		if (title==null && rt==null && currentTable!=null)
+			return currentTable;
+		if (title==null)
+			title="Results";
+		if (frame==null) {
+			frame = WindowManager.getFrame(title);
+			if (!(frame instanceof TextWindow))
+				frame = null;
+		}
+		if (frame==null) {
+			if (title!=null && !title.equals("Results"))
+				return null;
+			Frame[] frames = WindowManager.getNonImageWindows();
+			if (frames==null) return null;
+			for (int i=0; i<frames.length; i++) {
+				if (frames[i]!=null && (frames[i] instanceof TextWindow) &&
+				!("Results".equals(frames[i].getTitle())||"Log".equals(frames[i].getTitle())))
+					rt = ((TextWindow)frames[i]).getResultsTable();
+				if (rt!=null)
+					break;
+			}
+			if (rt!=null)
+				currentTable = rt;
+			return rt;
+		}
+		if (frame==null || !(frame instanceof TextWindow))
+			return null;
+		rt = ((TextWindow)frame).getResultsTable();
+		currentTable = rt;
+		return rt;
+	}
+
+	final double selectionContains() {
+		int x = (int)Math.round(getFirstArg());
+		int y = (int)Math.round(getLastArg());
+		ImagePlus imp = getImage();
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			interp.error("Selection required");
+		return roi.contains(x,y)?1.0:0.0;
+	}
+
+	void getDisplayedArea() {
+		Variable x = getFirstVariable();
+		Variable y = getNextVariable();
+		Variable w = getNextVariable();
+		Variable h = getLastVariable();
+		ImagePlus imp = getImage();
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null) return;
+		Rectangle r = ic.getSrcRect();
+		x.setValue(r.x);
+		y.setValue(r.y);
+		w.setValue(r.width);
+		h.setValue(r.height);
+	}
+
+	void toScaled() {   //pixel coordinates to calibrated coordinates
+		ImagePlus imp = getImage();
+		Plot plot = (Plot)(getImage().getProperty(Plot.PROPERTY_KEY)); //null if not a plot window
+		int height = imp.getHeight();
+		Calibration cal = imp.getCalibration();
+		interp.getLeftParen();
+		if (isArrayArg()) {
+			Variable[] x = getArray();
+			interp.getComma();
+			Variable[] y = getArray();
+			interp.getRightParen();
+			for (int i=0; i<x.length; i++)
+				x[i].setValue(plot==null ? cal.getX(x[i].getValue()) : plot.descaleX((int)(x[i].getValue()+0.5)));
+			for (int i=0; i<y.length; i++)
+				y[i].setValue(plot==null ? cal.getY(y[i].getValue(),height) : plot.descaleY((int)(y[i].getValue()+0.5)));
+		} else {
+			Variable xv = getVariable();
+			Variable yv = null;
+			Variable zv = null;
+			boolean twoArgs = interp.nextToken()==',';
+			if (twoArgs) {
+				interp.getComma();
+				yv = getVariable();
+			}
+			boolean threeArgs = interp.nextToken()==',';
+			if (threeArgs) {
+				interp.getComma();
+				zv = getVariable();
+			}
+			interp.getRightParen();
+			double x = xv.getValue();
+			if (twoArgs) {
+				double y = yv.getValue();
+				xv.setValue(plot == null ? cal.getX(x) : plot.descaleX((int)(x+0.5)));
+				yv.setValue(plot == null ? cal.getY(y,height) : plot.descaleY((int)(y+0.5)));
+				if (threeArgs)
+					zv.setValue(cal.getZ(zv.getValue()));
+			} else //oneArg; convert horizontal length (not the x coordinate, no offset)
+				xv.setValue(x * cal.pixelWidth) ;
+		}
+	}
+
+	void toUnscaled() {   //calibrated coordinates to pixel coordinates
+		ImagePlus imp = getImage();
+		Plot plot = (Plot)(getImage().getProperty(Plot.PROPERTY_KEY)); //null if not a plot window
+		int height = imp.getHeight();
+		Calibration cal = imp.getCalibration();
+		interp.getLeftParen();
+		if (isArrayArg()) {
+			Variable[] x = getArray();
+			interp.getComma();
+			Variable[] y = getArray();
+			interp.getRightParen();
+			for (int i=0; i<x.length; i++)
+				x[i].setValue(plot == null ? cal.getRawX(x[i].getValue()) : plot.scaleXtoPxl(x[i].getValue()));
+			for (int i=0; i<y.length; i++)
+				y[i].setValue(plot == null ? cal.getRawY(y[i].getValue(),height) : plot.scaleYtoPxl(y[i].getValue()));
+		} else {
+			Variable xv = getVariable();
+			Variable yv = null;
+			Variable zv = null;
+			boolean twoArgs = interp.nextToken()==',';
+			if (twoArgs) {
+				interp.getComma();
+				yv = getVariable();
+			}
+			boolean threeArgs = interp.nextToken()==',';
+			if (threeArgs) {
+				interp.getComma();
+				zv = getVariable();
+			}
+			interp.getRightParen();
+			double x = xv.getValue();
+			if (twoArgs) {
+				double y = yv.getValue();
+				xv.setValue(plot == null ? cal.getRawX(x) : plot.scaleXtoPxl(x));
+				yv.setValue(plot == null ? cal.getRawY(y,height) : plot.scaleYtoPxl(y));
+				if (threeArgs)
+					zv.setValue(cal.getRawZ(zv.getValue()));
+			} else  //oneArg; convert horizontal length (not the x coordinate, no offset)
+				xv.setValue(x/cal.pixelWidth);
+		}
+	}
+
+	private Variable doRoi() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==PREDEFINED_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("getDefaultStrokeWidth")) {
+			interp.getParens();
+			return new Variable(Roi.getDefaultStrokeWidth());
+		} else if (name.equals("setDefaultStrokeWidth")) {
+			Roi.setDefaultStrokeWidth(getArg());
+			return null;
+		} else if (name.equals("getDefaultGroup")) {
+			interp.getParens();
+			return new Variable(Roi.getDefaultGroup());
+		} else if (name.equals("setDefaultGroup")) {
+			Roi.setDefaultGroup((int)getArg());
+			return null;
+		} else if (name.equals("getGroupNames")) {
+			String names = Roi.getGroupNames();
+			return new Variable(names!=null?names:"");
+		} else if (name.equals("setGroupNames")) {
+			Roi.setGroupNames(getStringArg());
+			return null;
+		} else if (name.equals("getDefaultColor")) {
+			interp.getParens();
+			Color color = Roi.getColor();
+			return new Variable(Colors.colorToString(color));
+		}
+		ImagePlus imp = getImage();
+		if (name.equals("paste")) {
+			interp.getParens();
+			if (roiClipboard!=null)
+				getImage().setRoi((Roi)roiClipboard.clone());
+			return null;
+		} else if (name.equals("setPolygonSplineAnchors"))
+			return setSplineAnchors(imp, false);
+		else if (name.equals("setPolylineSplineAnchors"))
+			return setSplineAnchors(imp, true);
+		else if (name.equals("remove")) {
+			getImage().deleteRoi();
+			return null;
+		}
+		Roi roi = imp.getRoi();
+		if (name.equals("size")) {
+			interp.getParens();
+			return new Variable(roi!=null?roi.size():0);
+		}
+		if (roi==null)
+			interp.error("No selection");
+		if (name.equals("contains")) {
+			int x = (int)Math.round(getFirstArg());
+			int y = (int)Math.round(getLastArg());
+			return new Variable(roi.contains(x,y)?1:0);
+		} else if (name.equals("copy")) {
+			interp.getParens();
+			roiClipboard = getImage().getRoi();
+			if (roiClipboard!=null)
+				roiClipboard = (Roi)roiClipboard.clone();
+			return null;
+		} else if (name.equals("getBounds")) {
+			getBounds(true);
+			return null;
+		} else if (name.equals("getFloatBounds")) {
+			getBounds(false);
+			return null;
+		} else if (name.equals("getStrokeColor")) {
+			interp.getParens();
+			Color color = roi.getStrokeColor();
+			return new Variable(Colors.colorToString(color));
+		} else if (name.equals("getFillColor")) {
+			interp.getParens();
+			Color color = roi.getFillColor();
+			return new Variable(Colors.colorToString(color));
+		} else if (name.equals("getCoordinates")) {
+			getCoordinates();
+			return null;
+		} else if (name.equals("getContainedPoints")) {
+			getContainedPoints(roi);
+			return null;
+		} else if (name.equals("getName")) {
+			interp.getParens();
+			String roiName = roi.getName();
+			return new Variable(roiName!=null?roiName:"");
+		} else if (name.equals("getGroup")) {
+			interp.getParens();
+			return new Variable(roi.getGroup());
+		} else if (name.equals("setGroup")) {
+			roi.setGroup((int)getArg());
+			return null;
+		} else if (name.equals("getProperty")) {
+			String property = roi.getProperty(getStringArg());
+			return new Variable(property!=null?property:"");
+		} else if (name.equals("getProperties")) {
+			interp.getParens();
+			String properties = roi.getProperties();
+			return new Variable(properties!=null?properties:"");
+		} else if (name.equals("setFillColor")) {
+			roi.setFillColor(getRoiColor());
+			imp.draw();
+			return null;
+		} else if (name.equals("setAntiAlias")) {
+			roi.setAntiAlias(getBooleanArg());
+			imp.draw();
+			return null;
+		} else if (name.equals("move")) {
+			setSelectionLocation();
+			return null;
+		} else if (name.equals("setName")) {
+			roi.setName(getStringArg());
+			return null;
+		} else if (name.equals("setStrokeColor")) {
+			roi.setStrokeColor(getRoiColor());
+			imp.draw();
+			return null;
+		} else if (name.equals("setStrokeWidth")) {
+			roi.setStrokeWidth(getArg());
+			imp.draw();
+			return null;
+		} else if (name.equals("getStrokeWidth")) {
+			interp.getParens();
+			return new Variable(roi.getStrokeWidth());
+		} else if (name.equals("setProperty")) {
+			String value = "1";
+			interp.getLeftParen();
+			String key = getString();
+			if (key.contains(" "))
+				interp.error("Keys contain a space");
+			if (interp.nextToken()==',') {
+				interp.getComma();
+				value = getString();
+			}
+			interp.getRightParen();
+			roi.setProperty(key, value);
+			return null;
+		} else if (name.equals("getType")) {
+			interp.getParens();
+			String type = roi.getTypeAsString();
+			if (type.equals("Straight Line"))
+				type = "Line";
+			return new Variable(type.toLowerCase(Locale.US));
+		} else if (name.equals("getSplineAnchors")) {
+			return getSplineAnchors(roi);
+		} else if (name.equals("getFeretPoints")) {
+			return getFeretPoints(roi);
+		} else if (name.equals("setPosition")) {
+			setRoiPosition(roi);
+			return null;
+		} else if (name.equals("getPosition")) {
+			getRoiPosition(roi);
+			return null;
+		} else if (name.equals("getPointPosition")) {
+			if (!(roi instanceof PointRoi))
+				interp.error("Point selection required");
+			return new Variable(((PointRoi)roi).getPointPosition((int)getArg()));
+		} else if (name.equals("setFontSize")) {
+			if (roi instanceof TextRoi)
+				((TextRoi)roi).setFontSize((int)getArg());
+			return null;
+		} else if (name.equals("setJustification")) {
+			if (!(roi instanceof TextRoi))
+				return null;
+			String str = getStringArg().toLowerCase(Locale.US);
+			int just = TextRoi.LEFT;
+			if (str.equals("center"))
+				just = TextRoi.CENTER;
+			else if (str.equals("right"))
+				just = TextRoi.RIGHT;
+			((TextRoi)roi).setJustification(just);
+			return null;
+		} else
+			interp.error("Unrecognized Roi function");
+		return null;
+	}
+
+	void setRoiPosition(Roi roi) {
+		int channel = (int)getFirstArg();
+		if (interp.nextToken()==')') {
+			interp.getRightParen();
+			roi.setPosition(channel);
+			return;
+		}
+		int slice = (int)getNextArg();
+		int frame = (int)getLastArg();
+		roi.setPosition(channel, slice, frame);
+	}
+
+	void getRoiPosition(Roi roi) {
+		Variable channel = getFirstVariable();
+		Variable slice = getNextVariable();
+		Variable frame = getLastVariable();
+		channel.setValue(roi.getCPosition());
+		slice.setValue(roi.getZPosition());
+		frame.setValue(roi.getTPosition());
+	}
+
+	private Variable getFeretPoints(Roi roi) {
+		Variable xCoordinates = getFirstArrayVariable();
+		Variable yCoordinates = getLastArrayVariable();
+		double[] feretValues = roi.getFeretValues();
+		Variable[] xa = new Variable[4];
+		Variable[] ya = new Variable[4];
+		for (int i=0; i<4; i++) {
+			xa[i] = new Variable(feretValues[Roi.FERET_ARRAY_POINTOFFSET + 2*i]);
+			ya[i] = new Variable(feretValues[Roi.FERET_ARRAY_POINTOFFSET + 2*i+1]);
+		}
+		xCoordinates.setArray(xa);
+		yCoordinates.setArray(ya);
+		return null;
+	}
+
+	/*
+	private String getRoiPosition(Roi roi) {
+		Variable channel = getFirstVariable();
+		Variable slice = getNextVariable();
+		Variable frame = getLastVariable();
+		int c = roi.getCPosition();
+		int z = roi.getZPosition();
+		int t = roi.getTPosition();
+		channel.setValue(c);
+		slice.setValue(z);
+		frame.setValue(t);
+		return null;
+	}
+
+	private String setRoiPosition(ImagePlus imp, Roi roi) {
+		int channel = (int)getFirstArg();
+		int slice = (int)getNextArg();
+		int frame = (int)getLastArg();
+		if (channel<=1 && frame<=1 && !imp.isHyperStack())
+			roi.setPosition(slice);
+		else
+			roi.setPosition(channel, slice, frame);
+		return null;
+	}
+	*/
+
+	private Color getRoiColor() {
+		interp.getLeftParen();
+		if (isStringArg()) {
+			Color color = Colors.decode(getString(),null);
+			interp.getRightParen();
+			return color;
+		} else {
+			int r = (int)interp.getExpression();
+			if (interp.nextToken()==')') {
+				interp.getRightParen();
+				return new Color(r);
+			}
+			int g = (int)getNextArg();
+			int b = (int)getLastArg();
+			if (r<0) r=0; if (g<0) g=0; if (b<0) b=0;
+			if (r>255) r=255; if (g>255) g=255; if (b>255) b=255;
+			return new Color(r, g, b);
+		}
+	}
+
+	private void getContainedPoints(Roi roi) {
+		Variable xCoordinates = getFirstArrayVariable();
+		Variable yCoordinates = getLastArrayVariable();
+		FloatPolygon points = roi.getContainedFloatPoints();
+		Variable[] xa = new Variable[points.npoints];
+		Variable[] ya = new Variable[points.npoints];
+		for (int i=0; i<points.npoints; i++) {
+			xa[i] = new Variable(points.xpoints[i]);
+			ya[i] = new Variable(points.ypoints[i]);
+		}
+		xCoordinates.setArray(xa);
+		yCoordinates.setArray(ya);
+	}
+
+	private Variable getSplineAnchors(Roi roi) {
+		Variable xCoordinates = getFirstArrayVariable();
+		Variable yCoordinates = getLastArrayVariable();
+		Variable[] xa=null, ya=null;
+		FloatPolygon fp = null;
+		if (roi instanceof PolygonRoi)
+			fp = ((PolygonRoi)roi).getNonSplineFloatPolygon();
+		else
+			fp = roi.getFloatPolygon();
+		if (fp!=null) {
+			xa = new Variable[fp.npoints];
+			ya = new Variable[fp.npoints];
+			for (int i=0; i<fp.npoints; i++)
+				xa[i] = new Variable(fp.xpoints[i]);
+			for (int i=0; i<fp.npoints; i++)
+				ya[i] = new Variable(fp.ypoints[i]);
+		}
+		xCoordinates.setArray(xa);
+		yCoordinates.setArray(ya);
+		return null;
+	}
+
+	private Variable setSplineAnchors(ImagePlus imp, boolean polyline) {
+		double[] x = getFirstArray();
+		int n = x.length;
+		double[] y = getLastArray();
+		if (y.length!=n)
+			interp.error("Arrays are not the same length");
+		float[] xcoord = new float[n];
+		float[] ycoord = new float[n];
+		for (int i=0; i<n; i++) {
+			xcoord[i] = (float)x[i];
+			ycoord[i] = (float)y[i];
+		}
+		Roi roi = null;
+		if (polyline)
+			roi = new PolygonRoi(xcoord, ycoord, n, PolygonRoi.POLYLINE);
+		else
+			roi = new PolygonRoi(xcoord, ycoord, n, PolygonRoi.POLYGON);
+		((PolygonRoi)roi).fitSpline();
+		imp.setRoi(roi);
+		return null;
+	}
+
+	private Variable doRoiManager() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (interp.token!=WORD)
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		RoiManager rm = RoiManager.getInstance2();
+		if (rm==null)
+			interp.error("No ROI Manager");
+		if (name.equals("size")) {
+			interp.getParens();
+			return new Variable(rm.getCount());
+		} else if (name.equals("selected")) {
+			interp.getParens();
+			return new Variable(rm.selected());
+		} else if (name.equals("select")) {
+			rm.select((int)getArg());
+			return null;
+		} else if (name.equals("setGroup")) {
+			int group = (int)getArg();
+			if (group<0 || group>255)
+				interp.error("Group out of range");
+			rm.setGroup(group);
+			return null;
+		} else if (name.equals("selectGroup")) {
+			rm.selectGroup((int)getArg());
+			return null;
+		} else if (name.equals("getName")) {
+			String roiName = rm.getName((int)getArg());
+			return new Variable(roiName!=null?roiName:"");
+		} else if (name.equals("setPosition")) {
+			int position = (int)getArg();
+			rm.setPosition(position);
+			return null;
+		} else if (name.equals("multiCrop")) {
+			rm.multiCrop(getFirstString(),getLastString());
+			return null;
+		} else
+			interp.error("Unrecognized RoiManager function");
+		return null;
+	}
+
+	private Variable doProperty() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==STRING_FUNCTION||interp.token==NUMERIC_FUNCTION||interp.token==ARRAY_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		ImagePlus imp = getImage();
+		if (name.equals("set")) {
+			String key = getFirstString();
+			String value = getLastString();
+			if (value.length()==0) value = null;
+			imp.setProp(key, value);
+			return null;
+		} else if (name.equals("get")) {
+			String value = imp.getProp(getStringArg());
+			return new Variable(value!=null?value:"");
+		} else if (name.equals("getNumber")) {
+			String svalue = imp.getProp(getStringArg());
+			double nvalue = svalue!=null?Tools.parseDouble(svalue):Double.NaN;
+			return new Variable(nvalue);
+		} else if (name.equals("getInfo")) {
+			interp.getParens();
+			String value = (String)imp.getProperty("Info");
+			return new Variable(value!=null?value:"");
+		} else if (name.equals("setInfo")) {
+			imp.setProperty("Info", getStringArg());
+			return null;
+		} else if (name.equals("getSliceLabel")) {
+			String label = imp.getStack().getSliceLabel(imp.getCurrentSlice());
+			if (interp.nextToken()=='(') {
+				if (interp.nextNextToken()==')')
+					interp.getParens();
+				else
+					label = imp.getStack().getSliceLabel((int)getArg());
+			}
+			Variable v = new Variable(label!=null?label:"");
+			return v;
+		} else if (name.equals("setSliceLabel")) {
+			String label = getFirstString();
+			int slice = imp.getCurrentSlice();
+			if (interp.nextToken()==',')
+				slice = (int)getLastArg();
+			else
+				interp.getRightParen();
+			if (slice<1 || slice>imp.getStackSize())
+				interp.error("Argument must be >=1 and <="+imp.getStackSize());
+			imp.getStack().setSliceLabel(label, slice);
+			if (!Interpreter.isBatchMode()) imp.repaintWindow();
+			return null;
+		} else if (name.equals("getDicomTag")) {
+			String value = imp.getStringProperty(getStringArg());
+			return new Variable(value!=null?value:"");
+		} else if (name.equals("setList")) {
+			setPropertiesFromString(imp.getImageProperties());
+			return null;
+		} else if (name.equals("getList")) {
+			return new Variable(getPropertiesAsString(imp.getImageProperties()));
+		} else
+			interp.error("Unrecognized Property function");
+		return null;
+	}
+
+	private void setPropertiesFromString(Properties props) {
+		String list = getStringArg();
+		props.clear();
+		try {
+			InputStream is = new ByteArrayInputStream(list.getBytes("utf-8"));
+			props.load(is);
+		} catch(Exception e) {
+			interp.error(""+e);
+		}
+	}
+
+	private String getPropertiesAsString(Properties props) {
+		interp.getParens();
+		Vector v = new Vector();
+		for (Enumeration en=props.keys(); en.hasMoreElements();)
+			v.addElement(en.nextElement());
+		String[] keys = new String[v.size()];
+		for (int i=0; i<keys.length; i++)
+			keys[i] = (String)v.elementAt(i);
+		Arrays.sort(keys);
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<keys.length; i++) {
+			sb.append(keys[i]);
+			sb.append("=");
+			sb.append(props.get(keys[i]));
+			sb.append("\n");
+		}
+		return sb.toString();
+	}
+
+	static boolean isStringFunction(String name, int type) {
+		boolean isString = false;
+		switch (type) {
+			case TABLE:
+				if (name.equals("getString") || name.equals("title") || name.equals("headings")
+				|| name.equals("allHeadings"))
+					isString = true;
+				break;
+			case ROI:
+				if (name.equals("getStrokeColor") || name.equals("getDefaultColor")
+				|| name.equals("getFillColor") || name.equals("getName")
+				|| name.equals("getProperty") || name.equals("getProperties")
+				|| name.equals("getGroupNames") || name.equals("getType"))
+					isString = true;
+				break;
+			case PROPERTY:
+				if (name.equals("getProperty") || name.equals("getProperties")
+				|| (name.equals("get")&&type!=TABLE) || name.equals("getInfo")
+				|| name.equals("getList") || name.equals("getSliceLabel")
+				|| name.equals("getDicomTag"))
+					isString = true;
+				break;
+			case ROI_MANAGER2:
+				if (name.equals("getName"))
+					isString = true;
+				break;
+			case IMAGE:
+				if (name.equals("title") || name.equals("name"))
+					isString = true;
+				break;
+			case COLOR:
+				if (name.equals("foreground") || name.equals("background")
+				|| name.equals("toString"))
+					isString = true;
+				break;
+		}
+		return isString;
+	}
+
+	private Variable doImage() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==PREDEFINED_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		ImagePlus imp = getImage();
+		if (name.equals("width")) {
+			interp.getParens();
+			return new Variable(imp.getWidth());
+		} else if (name.equals("height")) {
+			interp.getParens();
+			return new Variable(imp.getHeight());
+		} else if (name.equals("copy")) {
+			interp.getParens();
+			imp.copy();
+			return null;
+		} else if (name.equals("paste")) {
+			int x = (int)getFirstArg();
+			int y = (int)getNextArg();
+			String mode = null;
+			if (interp.nextToken()==',')
+				mode = getNextString();
+			interp.getRightParen();
+			imp.paste(x, y, mode);
+			imp.updateAndDraw();
+			return null;
+		} else if (name.equals("title") || name.equals("name")) {
+			interp.getParens();
+			return new Variable(imp.getTitle());
+		} else
+			interp.error("Unrecognized Image function");
+		return null;
+	}
+
+	private Variable doColor() {
+		interp.getToken();
+		if (interp.token!='.')
+			interp.error("'.' expected");
+		interp.getToken();
+		if (!(interp.token==WORD||interp.token==PREDEFINED_FUNCTION||interp.token==STRING_FUNCTION))
+			interp.error("Function name expected: ");
+		String name = interp.tokenString;
+		if (name.equals("set")) {
+			setColor();
+			return null;
+		} else if (name.equals("foreground")) {
+			interp.getParens();
+			Color color = Toolbar.getForegroundColor();
+			return new Variable(Colors.colorToString(color));
+		} else if (name.equals("background")) {
+			interp.getParens();
+			Color color = Toolbar.getBackgroundColor();
+			return new Variable(Colors.colorToString(color));
+		} else if (name.equals("setForeground")) {
+			return setForegroundOrBackground(true);
+		} else if (name.equals("setBackground")) {
+			return setForegroundOrBackground(false);
+		} else if (name.equals("setForegroundValue")) {
+			Toolbar.setForegroundValue(getArg());
+			return null;
+		} else if (name.equals("setBackgroundValue")) {
+			Toolbar.setBackgroundValue(getArg());
+			return null;
+		} else if (name.equals("toString")) {
+			int red = (int)getFirstArg();
+			int green = (int)getNextArg();
+			int blue = (int)getLastArg();
+			Color color = Colors.toColor(red, green, blue);
+			return new Variable(Colors.colorToString(color));
+		} else if (name.equals("toArray")) {
+			String color = getStringArg();
+			int rgb = Colors.decode(color, Color.black).getRGB();
+			Variable[] array = new Variable[3];
+			array[0] = new Variable((rgb&0xff0000)>>16);
+			array[1] = new Variable((rgb&0xff00)>>8);
+			array[2] = new Variable(rgb&0xff);
+			return new Variable(array);
+		} else if (name.equals("setLut")) {
+			setLut();
+			return null;
+		} else if (name.equals("getLut")) {
+			getLut();
+			return null;
+		} else
+			interp.error("Unrecognized Color function");
+		return null;
+	}
+
+	private Variable setForegroundOrBackground(boolean foreground) {
+		interp.getLeftParen();
+		Color color = null;
+		if (isStringArg()) {
+			String arg = getString();
+			interp.getRightParen();
+			color = Colors.decode(arg, Color.black);
+		} else {
+			int red = (int)interp.getExpression();
+			int green = (int)getNextArg();
+			int blue = (int)getLastArg();
+			color = Colors.toColor(red, green, blue);
+		}
+		if (foreground)
+			Toolbar.setForegroundColor(color);
+		else
+			Toolbar.setBackgroundColor(color);
+		return null;
+	}
+
+} // class Functions
diff --git a/src/ij/macro/Interpreter.java b/src/ij/macro/Interpreter.java
new file mode 100644
index 0000000..3608dbe
--- /dev/null
+++ b/src/ij/macro/Interpreter.java
@@ -0,0 +1,2553 @@
+package ij.macro;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.Macro_Runner;
+import ij.plugin.frame.*;
+import ij.util.Tools;
+import ij.text.*;
+import ij.measure.ResultsTable;
+import java.awt.*;
+import java.util.*;
+import java.awt.event.KeyEvent;
+import java.io.PrintWriter;
+
+
+/** This is the recursive descent parser/interpreter for the ImageJ macro language. */
+public class Interpreter implements MacroConstants {
+
+	static final int STACK_SIZE = 1000;
+	static final int MAX_ARGS = 20;
+
+	int pc;
+	int token;
+	int tokenAddress;
+	double tokenValue;
+	String tokenString;
+	boolean looseSyntax = true;
+	int lineNumber;
+	boolean statusUpdated;
+	boolean showingProgress;
+	boolean keysSet;
+	boolean checkingType;
+	int prefixValue;
+	
+	Variable[] stack;
+	int topOfStack = -1;
+	int topOfGlobals = -1;
+	int startOfLocals = 0;
+
+	static volatile Interpreter instance, previousInstance;
+	public static boolean batchMode;
+	static Vector imageTable; // images opened in batch mode
+	static Vector imageActivations; // images ordered by activation time
+	volatile boolean done;
+	Program pgm;
+	Functions func;
+	boolean inFunction;
+	String macroName;
+	String argument;
+	String returnValue;
+	boolean calledMacro; // macros envoked by eval() or runMacro()
+	boolean batchMacro; // macros envoked by Process/Batch commands
+	double[] rgbWeights;
+	boolean inPrint;
+	static String additionalFunctions;
+	Debugger debugger;
+	int debugMode = Debugger.NOT_DEBUGGING;
+	boolean showDebugFunctions;
+	static boolean showVariables;
+	boolean wasError;
+	ImagePlus batchMacroImage;
+	boolean inLoop;
+	int loopDepth;
+	static boolean tempShowMode;
+	boolean waitingForUser;
+	int selectCount;
+	
+	static TextWindow arrayWindow;
+	int inspectStkIndex = -1;
+	int inspectSymIndex = -1;
+	boolean evaluating;
+	ResultsTable applyMacroTable;
+	int errorCount;
+	volatile boolean ignoreErrors;
+	String errorMessage;
+	String evalOutput;
+	int[] callStack;
+	int callDepth = 0;
+	
+	/** Interprets the specified string. */
+	public void run(String macro) {
+		if (additionalFunctions!=null) {
+			if (!(macro.endsWith("\n")|| additionalFunctions.startsWith("\n")))
+				macro = macro + "\n" + additionalFunctions;
+			else
+				macro = macro + additionalFunctions;
+		}
+		IJ.resetEscape();
+		Tokenizer tok = new Tokenizer();
+		Program pgm = tok.tokenize(macro);
+		if (pgm.hasVars && pgm.hasFunctions)
+			saveGlobals2(pgm);
+		run(pgm);
+	}
+	
+	/** Runs the specified macro, passing it a string 
+	 * argument and returning a string value.
+	 * @see ij.IJ#runMacro(String,String)
+	 * @see ij.IJ#runMacroFile(String,String)
+	*/
+	public String run(String macro, String arg) {
+		synchronized(Interpreter.class) {
+			argument = arg;
+			calledMacro = true;
+			if (IJ.getInstance()==null)
+				setBatchMode(true);
+			Interpreter saveInstance = instance;
+			run(macro);
+			instance = saveInstance;
+			return returnValue;
+		}
+	}
+	
+	/** Evaluates 'code' and returns the output, or any error, as a String.
+	 * @see ij.Macro#eval
+	*/
+	public String eval(String code) {
+		Interpreter saveInstance = instance;
+		if (pgm!=null)
+			reuseSymbolTable();
+		Tokenizer tok = new Tokenizer();
+		Program pgm = tok.tokenize(code);
+		if (pgm.hasVars && pgm.hasFunctions)
+			saveGlobals2(pgm);
+		evaluating = true;
+		evalOutput = null;
+		ignoreErrors = true;
+		calledMacro = true;
+		run(pgm);
+		instance = saveInstance;
+		if (errorMessage!=null)
+			return errorMessage;
+		else
+			return evalOutput;
+	}
+	
+	private void reuseSymbolTable() {
+		if (pgm==null)
+			return;
+		Symbol[] table1 = pgm.getSymbolTable();
+		Symbol[] table2 = new Symbol[pgm.stLoc+1];
+		for (int i=0; i<=pgm.stLoc; i++)
+			table2[i] = table1[i];
+		Program.systemTable = table2;
+	}
+	
+	/** Interprets the specified tokenized macro file starting at location 0. */
+	public void run(Program pgm) {
+		this.pgm = pgm;
+		pc = -1;
+		callDepth = 0;
+		instance = this;
+		if (!calledMacro) {
+			batchMode = false;
+			imageTable = imageActivations = null;
+		}
+		pushGlobals();
+		if (func==null)
+			func = new Functions(this, pgm);
+		else
+			func.pgm = pgm;
+		func.plot = null;
+		done = false;
+		errorMessage = null;
+		doStatements();
+		finishUp();
+	}
+
+	/** Runs an existing macro starting at the specified program counter location. */
+	public void run(int location) {
+		topOfStack = topOfGlobals;
+		done = false;
+		pc = location-1;
+		doStatements();
+	}
+
+	/** Interprets the specified tokenized macro starting at the specified location. */
+	public void runMacro(Program pgm, int macroLoc, String macroName) {
+		calledMacro = true;
+		this.pgm = pgm;
+		this.macroName = macroName;
+		pc = macroLoc-1;
+		previousInstance = instance;
+		instance = this;
+		pushGlobals();
+		if (func==null)
+			func = new Functions(this, pgm);
+		func.plot = null;
+		if (macroLoc==0)
+			doStatements();
+		else
+			doBlock(); 
+		finishUp();
+		Recorder.recordInMacros = false;
+	}
+	
+	/** Runs Process/Batch/ macros. */
+	public ImagePlus runBatchMacro(String macro, ImagePlus imp) {
+		calledMacro = true;
+		batchMacro = true;
+		setBatchMode(true);
+		addBatchModeImage(imp);
+		batchMacroImage = null;
+		run(macro);
+		IJ.showStatus("");
+		return batchMacroImage;
+	}
+
+	/** Saves global variables. */
+	public void saveGlobals(Program pgm) {
+		Interpreter saveInstance = instance;
+		saveGlobals2(pgm);
+		instance = saveInstance; 
+	}
+	
+	void saveGlobals2(Program pgm) {
+		this.pgm = pgm;
+		pc = -1;
+		instance = this;
+		func = new Functions(this, pgm);
+		while (!done) {
+			getToken();
+			switch (token) {
+				case VAR: doVar(); break;
+				case MACRO: skipMacro(); break;
+				case FUNCTION: skipFunction(); break;
+				default:
+			}
+		}
+		instance = null;
+		pgm.saveGlobals(this);
+		pc = -1;
+		topOfStack = -1;
+		done = false;
+	}
+
+	final void getToken() {
+		if (done) return;
+		token = pgm.code[++pc];
+		//IJ.log(pc+" "+pgm.decodeToken(token));
+		if (token<=127)
+			return;
+		tokenAddress = token>>TOK_SHIFT;
+		token = token&TOK_MASK;
+		Symbol sym = pgm.table[tokenAddress];
+		tokenString = sym.str;
+		tokenValue = sym.value;
+		done = token==EOF;
+	}
+
+	final int nextToken() {
+		return pgm.code[pc+1]&TOK_MASK;
+	}
+
+	final int nextNextToken() {
+		return pgm.code[pc+2]&TOK_MASK;
+	}
+
+	final void putTokenBack() {
+		pc--;
+		if (pc<0)
+			pc = -1;
+		if (token==EOF)
+			done = false;
+	}
+
+	void doStatements() {
+		while (!done)
+			doStatement();
+	}
+
+	final void doStatement() {
+		getToken();
+		if (debugMode!=Debugger.NOT_DEBUGGING && debugger!=null && !done && token!=';' && token!=FUNCTION) {
+			debugger.debug(this, debugMode);
+			if (done) return;
+		}
+		switch (token) {
+			case VAR:
+				doVar();
+				break;
+			case PREDEFINED_FUNCTION:
+				func.doFunction(pgm.table[tokenAddress].type);
+				break;
+			case USER_FUNCTION:
+				runUserFunction();
+				break;
+			case RETURN:
+				doReturn();
+				break;
+			case BREAK:
+				if (inLoop) throw new MacroException(BREAK);
+				break;
+			case CONTINUE:
+				if (inLoop) throw new MacroException(CONTINUE);
+				break;
+			case WORD:
+				if (pgm.code[pc+1]=='.')
+					doStringFunction();
+				else
+					doAssignment();
+				break;
+			case IF:
+				doIf();
+				return;
+			case ELSE:
+				error("Else without if");
+				return;
+			case FOR:
+				doFor();
+				return;
+			case WHILE:
+				doWhile();
+				return;
+			case DO:
+				doDo();
+				return;
+			case MACRO:
+				runFirstMacro();
+				return;
+			case FUNCTION:
+				skipFunction();
+				return;
+			case ';':
+				return;
+			case '{':
+				putTokenBack();
+				doBlock();
+				return;
+			case NUMBER:
+			case NUMERIC_FUNCTION:
+			case STRING_FUNCTION:
+			case STRING_CONSTANT:
+			case VARIABLE_FUNCTION:
+			case '(': 
+				putTokenBack();
+				inPrint = true;
+				String s = getString();
+				inPrint = false;
+				if (s!=null && s.length()>0 && !s.equals("NaN") && !s.equals("[aborted]"))
+					log(s);
+				return;
+			case ARRAY_FUNCTION: func.getArrayFunction(pgm.table[tokenAddress].type); break;
+			case EOF: break;
+			default:
+				if (evaluating && token==PI) {
+					putTokenBack();
+					log(""+getExpression());
+				} else
+					error("Statement cannot begin with '"+pgm.decodeToken(token, tokenAddress)+"'");
+		}
+		if (!looseSyntax) {
+			getToken();
+			if (token!=';' && !done)
+				error("';' expected");
+		}
+	}
+	
+	private void doStringFunction() {
+		boolean stringFunction = (pgm.code[pc+2]&0xff)==STRING_FUNCTION;
+		putTokenBack();
+		String s = stringFunction?getString():""+getExpression();
+		if (s.endsWith(".0"))
+			s = s.substring(0,s.length()-2);
+		IJ.log(s);
+	}
+	
+	void log(String s) {
+		if (evaluating)
+			evalOutput = s;
+		else
+			IJ.log(s);
+	}
+	
+	//For showing call stack in macro errors
+	private void growCallStack(int grow) {
+		if(callStack == null){
+			callStack = new int[10];
+			callDepth = 0;
+		}
+		if (callDepth <0 ||  callDepth > 8)
+			return;
+		if (grow == 1){
+			int line = pgm.lineNumbers[pc];
+			callStack[callDepth++] = line;
+		}
+		if (grow == -1 && callDepth > 0)
+			callDepth--;
+	}
+	
+	Variable runUserFunction() {
+		growCallStack(1);
+		int newPC = (int)tokenValue;
+		int saveStartOfLocals = startOfLocals;
+		startOfLocals = topOfStack+1;
+		int saveTOS = topOfStack;		
+		int nArgs = pushArgs();
+		int savePC = pc;
+		Variable value = null;
+		pc = newPC;
+		setupArgs(nArgs);
+		boolean saveInFunction = inFunction;
+		inFunction = true;
+		try {
+			doBlock();
+		} catch (ReturnException e) {
+			value = new Variable(0, e.value, e.str, e.array);
+			if (value.getArray()!=null && e.arraySize!=0)
+				value.setArraySize(e.arraySize);
+		}
+		inFunction = saveInFunction;
+		pc = savePC;
+		trimStack(saveTOS, saveStartOfLocals);
+		growCallStack(-1);
+		return value;
+	}
+
+	/** Push function arguments onto the stack. */
+	int pushArgs() {
+		getLeftParen();
+		int count = 0;
+		Variable[] args = new Variable[MAX_ARGS];
+		double value;
+		if (nextToken()!=')') {
+			do {
+				if (count==MAX_ARGS)
+					error("Too many arguments");
+				int next = nextToken();
+				int nextPlus = pgm.code[pc+2]&0xff;
+				if (next==STRING_CONSTANT || next==STRING_FUNCTION)
+					args[count] = new Variable(0, 0.0, getString());
+				else if (next==USER_FUNCTION) {
+					int savePC = pc;
+					getToken(); // the function
+					boolean simpleFunctionCall = isSimpleFunctionCall(false);
+					pc = savePC;
+					if (simpleFunctionCall) {
+						getToken(); // the function
+						Variable v2 = runUserFunction();
+						if (v2==null)
+							error("No return value");
+						args[count] = v2;
+					} else
+						args[count] = new Variable(0, getExpression(), null);	
+				} else if (next==WORD && (nextPlus==','||nextPlus==')')) {
+					value = 0.0;
+					Variable[] array = null;
+					int arraySize = 0;
+					String str = null;
+					getToken();
+					Variable v = lookupVariable();
+					if (v!=null) {
+						int type = v.getType();
+						if (type==Variable.VALUE)
+							value = v.getValue();
+						else if (type==Variable.ARRAY) {
+							array = v.getArray();
+							arraySize = v.getArraySize();
+						} else
+							str = v.getString();
+					}
+					args[count] = new Variable(0, value, str, array);
+					if (array!=null) args[count].setArraySize(arraySize);
+				} else if (next==WORD && nextPlus=='[' ) {
+					int savePC = pc;
+					getToken();
+					Variable v = lookupVariable();
+					v = getArrayElement(v);
+					if (v.getString()!=null)
+						args[count] = new Variable(0, 0.0, v.getString(), null);
+					else {
+						pc = savePC;
+						args[count] = new Variable(0, getExpression(), null);
+					}
+				} else if (next==WORD && nextPlus=='.' ) { // s.length, s.substring(), etc.
+					boolean stringFunction = (pgm.code[pc+3]&0xff)==136;
+					if (stringFunction)
+						args[count] = new Variable(0, 0.0, func.getString(), null);
+					else
+						args[count] = new Variable(0, getExpression(), null);
+				} else if (nextPlus=='+' && next==WORD) {
+					int savePC = pc;
+					getToken();
+					Variable v = lookupVariable();
+					boolean isString = v!=null && v.getType()==Variable.STRING;
+					pc = savePC;
+					if (isString)
+						args[count] = new Variable(0, 0.0, getString());
+					else
+						args[count] = new Variable(0, getExpression(), null);
+				} else if (next==ARRAY_FUNCTION) {
+					getToken();
+					Variable[] array = func.getArrayFunction(pgm.table[tokenAddress].type);
+					args[count] = new Variable(0, 0, null, array);
+				} else
+					args[count] = new Variable(0, getExpression(), null);
+				count++;
+				getToken();
+			} while (token==',');
+			putTokenBack();
+		}
+		int nArgs = count;
+		while(count>0)
+			push(args[--count], this);
+		getRightParen();
+		return nArgs;
+	}
+
+	void setupArgs(int nArgs) {
+		getLeftParen();
+		int i = topOfStack;
+		int count = nArgs;
+		if (nextToken()!=')') {
+			do {
+			   getToken();
+			   if (i>=0)
+				  stack[i].symTabIndex = tokenAddress;
+			   i--;
+			   count--;
+			   getToken();
+			} while (token==',');
+			putTokenBack();
+		}
+		if (count!=0)
+		   error(nArgs+" argument"+(nArgs==1?"":"s")+" expected");
+		getRightParen();
+	}
+	
+	// cache exception object for better performance
+    ReturnException returnException;
+    
+    // Handle return statement 
+	void doReturn() {
+		double value = 0.0;
+		String str = null;
+		Variable[] array = null;
+		int arraySize = 0;
+		getToken();		
+		if (token=='(') {
+			int next = pgm.code[pc+1];
+			if ((next&TOK_MASK)==STRING_CONSTANT || (next&TOK_MASK)==STRING_FUNCTION || isString(pc+1))
+				error("String enclosed in parens");
+		}		
+		if (token!=';') {
+			boolean isString = token==STRING_CONSTANT || token==STRING_FUNCTION;
+			boolean isArrayFunction = token==ARRAY_FUNCTION;
+			if (token==WORD) {
+				Variable v = lookupLocalVariable(tokenAddress);
+				if (v!=null && nextToken()==';') {
+					array = v.getArray();
+					if (array!=null) arraySize=v.getArraySize();
+					isString = v.getString()!=null;
+				} else if (v!=null && nextToken()=='+')
+					isString = v.getType()==Variable.STRING;
+			}
+			putTokenBack();
+			if (isString)
+				str = getString();
+			else if (isArrayFunction) {
+				getToken();
+				array = func.getArrayFunction(pgm.table[tokenAddress].type);
+			} else if (array==null) {
+				if ((pgm.code[pc+2]&0xff)=='[' && nextToken()==WORD) {
+					int savePC = pc;
+					getToken();
+					Variable v = lookupVariable();
+					v = getArrayElement(v);
+					pc = savePC;
+					if (v.getString()!=null)
+						str = getString();
+					else
+						value = getExpression();
+				} else
+					value = getExpression();
+			}
+		}
+		if (inFunction) {
+			if (returnException==null)
+				returnException = new ReturnException();
+			returnException.value = value;
+			returnException.str = str;
+			returnException.array = array;
+			returnException.arraySize = arraySize;
+			//throw new ReturnException(value, str, array);
+			throw returnException;
+		} else {
+			finishUp();
+			if (value!=0.0 || array!=null)
+				error("Macros can only return strings");
+			returnValue = str;
+			done = true;
+		}
+	}
+	
+	void doFor() {
+		boolean saveLooseSyntax = looseSyntax;
+		looseSyntax = false;
+		loopDepth++;
+		inLoop = true;
+		getToken();
+		if (token!='(')
+			error("'(' expected");
+		getToken(); // skip 'var'
+		if (token!=VAR)
+			putTokenBack();
+		do {
+			if (nextToken()!=';')
+			   getAssignmentExpression();
+			getToken();
+		} while (token==',');
+		if (token!=';')
+			error("';' expected");
+		int condPC = pc;
+		int incPC2, startPC=0;
+		double cond = 1;
+		while (true) {
+			if (pgm.code[pc+1]!=';')
+			   cond = getLogicalExpression();
+			if (startPC==0)
+				checkBoolean(cond);
+			getToken();
+			if (token!=';')
+				error("';' expected");
+			int incPC = pc;
+			// skip to start of code
+			if (startPC!=0)
+				pc = startPC;
+			else {
+			  while (token!=')') {
+				getToken();
+				//IJ.log(pgm.decodeToken(token,tokenAddress));
+				if (token=='{' || token==';' || token=='(' || done)
+					error("')' expected");
+			   }
+			}
+			startPC = pc;
+			if (cond==1) {
+				try {
+					doStatement();
+				} catch(MacroException e) {
+					if (e.getType()==BREAK) {
+						pc = startPC;
+						skipStatement();
+						break;
+					}
+				}
+			} else {
+				skipStatement();
+				break;
+			}
+			pc = incPC; // do increment
+			do {
+				 if (nextToken()!=')')
+					getAssignmentExpression();
+				getToken();
+			} while (token==',');
+			pc = condPC;
+		}
+		looseSyntax = saveLooseSyntax;
+		loopDepth--;
+		if (loopDepth==0)
+			inLoop = false;
+	}
+
+	void doWhile() {
+		looseSyntax = false;
+		loopDepth++;
+		inLoop = true;
+		int savePC = pc;
+		boolean isTrue;
+		do {
+			pc = savePC;
+			isTrue = getBoolean();
+			if (isTrue) {
+				try {
+					doStatement();
+				} catch(MacroException e) {
+					if (e.getType()==BREAK) {
+						pc = savePC;
+						getBoolean();
+						skipStatement();
+						break;
+					}
+				}
+			} else
+				skipStatement();
+		} while (isTrue && !done);
+		loopDepth--;
+		if (loopDepth==0)
+			inLoop = false;
+	}
+
+	void doDo() {
+		looseSyntax = false;
+		int savePC = pc;
+		boolean isTrue;
+		do {
+			doStatement();
+			getToken();
+			if (token!=WHILE)
+				error("'while' expected");
+			isTrue = getBoolean();
+			if (isTrue)
+				pc = savePC;
+		} while (isTrue && !done);
+	}
+
+	final void doBlock() {
+		getToken();
+		if (token!='{')
+			error("'{' expected");
+		while (!done) {
+			getToken();
+			if (token=='}')
+				break;
+			putTokenBack();
+			doStatement();
+		}
+		if (token!='}')
+			error("'}' expected");
+	}
+
+	final void skipStatement() {
+		if (done)
+			return;
+		getToken();
+		switch (token) {
+			case PREDEFINED_FUNCTION: case USER_FUNCTION: case VAR:
+			case WORD: case '(': case PLUS_PLUS: case RETURN: case ARRAY_FUNCTION:
+			case NUMERIC_FUNCTION: case STRING_FUNCTION: case VARIABLE_FUNCTION:
+				skipSimpleStatement();
+				break;
+			case IF:
+				skipParens();
+				skipStatement();
+				getToken();
+				if (token==ELSE)
+					skipStatement();
+				else
+					putTokenBack();
+				break;
+			case FOR:
+				skipParens();
+				skipStatement();
+				break;
+			case WHILE:
+				skipParens();
+				skipStatement();
+				break;
+			case DO:
+				skipStatement();
+				getToken(); // skip 'while'
+				skipParens();
+				break;
+			case BREAK: case CONTINUE: case ';':
+				break;
+			case '{':
+				putTokenBack();
+				skipBlock();
+				break;
+			default:
+				error("Skipped statement cannot begin with '"+pgm.decodeToken(token, tokenAddress)+"'");
+		}
+	}
+
+	final void skipBlock() {
+		int count = 0;
+		do {
+			getToken();
+			if (token=='{')
+				count++;
+			else if (token=='}')
+				count--;
+			else if (done) {
+				error("'}' expected");
+				return;
+			}
+		} while (count>0);
+	}
+	
+	final void skipParens() {
+		int count = 0;
+		do {
+			getToken();
+			if (token=='(')
+				count++;
+			else if (token==')')
+				count--;
+			else if (done) {
+				error("')' expected");
+				return;
+			}
+		} while (count>0);
+	}
+
+	final void skipSimpleStatement() {
+		boolean finished = done;
+		getToken();
+		while (!finished && !done) {
+			if (token==';')
+				finished = true;
+			else if (token==ELSE||(token==PREDEFINED_FUNCTION&&pgm.code[pc-1]!='.'))
+				error("';' expected");
+			else
+				getToken();
+		}
+	}
+
+	/** Skips a user-defined function. */
+	void skipFunction() {
+		getToken(); // skip function id
+		skipParens();
+		skipBlock();
+	}
+
+	void runFirstMacro() {
+		getToken(); // skip macro label
+		doBlock(); 
+		done = true;
+		finishUp();
+	}
+
+	void skipMacro() {
+		getToken(); // skip macro label
+		skipBlock();
+	}
+
+	final void doAssignment() {
+		int next = pgm.code[pc+1]&0xff;
+		if (next=='[') {
+			doArrayElementAssignment();
+			return;
+		} 
+		int type = getExpressionType();
+		switch (type) {
+			case Variable.STRING: doStringAssignment(); break;
+			case Variable.ARRAY: doArrayAssignment(); break;
+			case USER_FUNCTION: doUserFunctionAssignment(); break;
+			case STRING_FUNCTION: doNumericStringAssignment(); break;
+			default:
+				putTokenBack();
+				double value = getAssignmentExpression();
+				if (evaluating) log(""+value);
+		}
+	}
+
+	int getExpressionType() {
+		int rightSideToken = pgm.code[pc+2];
+		int tok = rightSideToken&0xff;
+		if (tok==STRING_CONSTANT)
+			return Variable.STRING;
+		if (tok==STRING_FUNCTION) {
+			int address = rightSideToken>>TOK_SHIFT;
+			int type = pgm.table[address].type;
+			if (type==DIALOG) {
+				int token2 = pgm.code[pc+4];
+				String name = pgm.table[token2>>TOK_SHIFT].str;
+				if (name.equals("getNumber") || name.equals("getCheckbox"))
+					return STRING_FUNCTION; 
+			} else if (type==FILE) {
+				int token2 = pgm.code[pc+4];
+				String name = pgm.table[token2>>TOK_SHIFT].str;
+				if (name.equals("exists")||name.equals("isDirectory")||name.equals("length")
+				||name.equals("getLength")||name.equals("rename")||name.equals("delete"))
+					return STRING_FUNCTION;
+			} else if (type==LIST) {
+				int token2 = pgm.code[pc+4];
+				String name = pgm.table[token2>>TOK_SHIFT].str;
+				if (name.equals("getValue")) return STRING_FUNCTION;
+			} else if (numericStringFunction(pc+2))
+				return Variable.VALUE;
+			return Variable.STRING;
+		}
+		if (tok==ARRAY_FUNCTION)
+			return Variable.ARRAY;
+		if (tok==USER_FUNCTION)
+			return USER_FUNCTION;
+		if (tok==VARIABLE_FUNCTION) {
+			int address = rightSideToken>>TOK_SHIFT;
+			int type = pgm.table[address].type;
+			if (isString(pc+2))
+				return Variable.STRING;
+			int token2 = pgm.code[pc+4];
+			String name = pgm.table[token2>>TOK_SHIFT].str;
+			if (name.equals("getColumn")||name.equals("toArray"))
+				return Variable.ARRAY;			
+		}
+		if (tok!=WORD)
+			return Variable.VALUE;
+		Variable v = lookupVariable(rightSideToken>>TOK_SHIFT);
+		if (v==null)
+			return Variable.VALUE;
+		int type = v.getType();
+		if (type==Variable.VALUE)
+			return Variable.VALUE;
+		else if (type==Variable.STRING) {
+			if (isString(pc+2))
+				return Variable.STRING;
+			else 
+				return Variable.VALUE;
+		}
+		if (pgm.code[pc+3]=='.')
+			return Variable.VALUE;		
+		if (pgm.code[pc+3]!='[')
+			return Variable.ARRAY;
+		int savePC = pc;
+		getToken(); //"="
+		getToken(); //the variable
+		checkingType = true;
+		int index = getIndex();
+		checkingType = false;
+		pc = savePC-1;
+		getToken();
+		Variable[] array = v.getArray();
+		if (index<0 || index>=array.length)
+			return Variable.VALUE;
+		return array[index].getType();
+	}
+	
+	/** Handles string functions such as Dialog.getNumber() that return a number. */
+	final void doNumericStringAssignment() {
+		putTokenBack();
+		getToken();		
+		Variable v = lookupLocalVariable(tokenAddress);
+		if (v==null) v = push(tokenAddress, 0.0, null, this);
+		getToken();
+		if (token!='=') error("'=' expected");
+		v.setValue(getExpression());
+	}
+
+	final void doArrayElementAssignment() {
+		Variable v = lookupLocalVariable(tokenAddress);
+		if (v==null)
+				error("Undefined identifier");
+		if (pgm.code[pc+5]==';'&&(pgm.code[pc+4]==PLUS_PLUS||pgm.code[pc+4]==MINUS_MINUS))
+			{putTokenBack(); getFactor(); return;}
+		int index = getIndex();
+		int expressionType = getExpressionType();
+		if (expressionType==Variable.ARRAY) 
+			error("Arrays of arrays not supported");
+		getToken();
+		int op = token;
+		if (!(op=='='||op==PLUS_EQUAL||op==MINUS_EQUAL||op==MUL_EQUAL||op==DIV_EQUAL))
+			{error("'=', '+=', '-=', '*=' or '/=' expected"); return;}
+		if (op!='=' && (expressionType==Variable.STRING||expressionType==Variable.ARRAY))
+			{error("'=' expected"); return;}
+		Variable[] array = v.getArray();
+		if (array==null)
+			error("Array expected");
+		if (index<0)
+			error("Negative index");
+		if (index>=array.length) {  // expand array
+			if (!func.expandableArrays)
+				error("Index ("+index+") out of range");
+			Variable[] array2 = new Variable[index+array.length/2+1];
+			boolean strings = array.length>0 && array[0].getString()!=null;
+			for (int i=0; i<array2.length; i++) {
+				if (i<array.length)
+					array2[i] = array[i];
+				else {
+					array2[i] = new Variable(Double.NaN);
+					if (strings)
+						array2[i].setString("undefined");
+				}
+			}
+			v.setArray(array2);
+			v.setArraySize(index+1);
+			array = v.getArray();
+		}
+		int size = v.getArraySize();
+		if (index+1>size)
+			v.setArraySize(index+1);
+		int next = nextToken();
+		switch (expressionType) {
+			case Variable.STRING:
+				array[index].setString(getString());
+				break;
+			case Variable.ARRAY:
+				getToken();
+				if (token==ARRAY_FUNCTION)
+					array[index].setArray(func.getArrayFunction(pgm.table[tokenAddress].type));
+				break;
+			case USER_FUNCTION:
+				int savePC = pc;
+				getToken(); // the function
+				boolean simpleFunctionCall = isSimpleFunctionCall(true);
+				pc = savePC;
+				if (simpleFunctionCall) {
+					getToken(); // the function
+					Variable v2 = runUserFunction();
+					if (v2==null)
+						error("No return value");
+					if (done) return;
+					int type = v2.getType();
+					if (type==Variable.VALUE)
+						array[index].setValue(v2.getValue());
+					else
+						array[index].setString(v2.getString());
+				} else
+					array[index].setValue(getExpression());
+				break;
+			default:
+				switch (op) {
+					case '=': array[index].setValue(getExpression()); break;
+					case PLUS_EQUAL: array[index].setValue(array[index].getValue()+getExpression()); break;
+					case MINUS_EQUAL: array[index].setValue(array[index].getValue()-getExpression()); break;
+					case MUL_EQUAL: array[index].setValue(array[index].getValue()*getExpression()); break;
+					case DIV_EQUAL: array[index].setValue(array[index].getValue()/getExpression()); break;
+				}
+				break;
+		}				
+	}
+
+	final void doUserFunctionAssignment() {
+		//IJ.log("doUserFunctionAssignment0: "+pgm.decodeToken(token, tokenAddress));
+		putTokenBack();
+		int savePC = pc;
+		getToken(); // the variable
+		getToken(); // '='
+		getToken(); // the function
+		boolean simpleAssignment = isSimpleFunctionCall(true);
+		pc = savePC;
+		if (!simpleAssignment)
+			getAssignmentExpression();
+		else {
+			getToken();		
+			Variable v1 = lookupLocalVariable(tokenAddress);
+			if (v1==null)
+				v1 = push(tokenAddress, 0.0, null, this);
+			getToken();
+			if (token!='=')
+				error("'=' expected");
+			getToken(); // the function
+			Variable v2 = runUserFunction();
+			if (v2==null)
+				error("No return value");
+			if (done) return;
+			int type = v2.getType();
+			if (type==Variable.VALUE)
+				v1.setValue(v2.getValue());
+			else if (type==Variable.ARRAY) {
+				v1.setArray(v2.getArray());
+				v1.setArraySize(v2.getArraySize());
+			} else
+				v1.setString(v2.getString());
+		}	
+	}
+	
+	boolean isSimpleFunctionCall(boolean assignment) {
+		int count = 0;
+		do {
+			getToken();
+			if (token=='(')
+				count++;
+			else if (token==')')
+				count--;
+			else if (done)
+				error("')' expected");
+		} while (count>0);
+		getToken();
+		if (assignment)
+			return token==';';
+		else
+			return token==','||token==')';
+	}
+	
+	final void doStringAssignment() {
+		Variable v = lookupLocalVariable(tokenAddress);
+		if (v==null) {
+			if (nextToken()=='=')
+				v = push(tokenAddress, 0.0, null, this);
+			else
+				error("Undefined identifier");
+		}
+		getToken();
+		if (token=='=')
+			v.setString(getString());
+		else if (token==PLUS_EQUAL)
+			v.setString(v.getString()+getString());
+		else
+			error("'=' or '+=' expected");
+	}
+
+	final void doArrayAssignment() {
+		Variable v = lookupLocalVariable(tokenAddress);
+		if (v==null) {
+			if (nextToken()=='=')
+				v = push(tokenAddress, 0.0, null, this);
+			else
+				error("Undefined identifier");
+		}
+		getToken();
+		if (token!='=') {
+			error("'=' expected");
+			return;
+		}
+		getToken();
+		if (token==ARRAY_FUNCTION)
+			v.setArray(func.getArrayFunction(pgm.table[tokenAddress].type));
+		else if (token==WORD) {
+			Variable v2 = lookupVariable();
+			v.setArray(v2.getArray());
+			v.setArraySize(v2.getArraySize());
+		} else if (token==VARIABLE_FUNCTION) {
+			Variable v2 = func.getVariableFunction(pgm.table[tokenAddress].type);
+			Variable[] array = v2.getArray();
+			if (array==null)
+				error("Array expected");			
+			v.setArray(array);
+		} else
+			error("Array expected");
+	}
+
+	final void doIf() {
+		looseSyntax = false;
+		boolean b = getBoolean();
+		if (b)
+			doStatement();
+		else
+			skipStatement();
+		int next = nextToken();
+		if (next==';') {
+			getToken();
+			next = nextToken();
+		}
+		if (next==ELSE) {
+			getToken();
+			if (b)
+				skipStatement();
+			else
+				doStatement();
+		}
+	}
+
+	final boolean getBoolean() {
+		getLeftParen();
+		double value = getLogicalExpression();
+		checkBoolean(value);
+		getRightParen();
+		return value==0.0?false:true;
+	}
+
+	final double getLogicalExpression() {
+		double v1 = getBooleanExpression();
+		int next = nextToken();
+		if (!(next==LOGICAL_AND || next==LOGICAL_OR))
+			return v1;
+		checkBoolean(v1);
+		getToken();
+		int op = token;	
+		double v2 = getLogicalExpression();
+		checkBoolean(v2);
+		if (op==LOGICAL_AND)
+			return (int)v1 & (int)v2;
+		else if (op==LOGICAL_OR)
+			return (int)v1 | (int)v2;
+		return v1;
+	}
+
+	final double getBooleanExpression() {
+		double v1 = 0.0;
+		String s1 = null;
+		int next = pgm.code[pc+1];
+		int tok = next&TOK_MASK;
+		if (tok==STRING_CONSTANT || tok==STRING_FUNCTION || isString(pc+1)) {
+			if (numericStringFunction(pc+1))
+				v1 = getExpression();
+			else
+				s1 = getString();
+		} else
+			v1 = getExpression();
+		next = nextToken();
+		if (next>=EQ && next<=LTE) {
+			getToken();
+			int op = token;
+			if (s1!=null)
+				return compareStrings(s1, getString(), op);
+			double v2 = getExpression();
+			switch (op) {
+				case EQ:
+					v1 = v1==v2?1.0:0.0;
+					break;
+				case NEQ:
+					v1 = v1!=v2?1.0:0.0;
+					break;
+				case GT:
+					v1 = v1>v2?1.0:0.0;
+					break;
+				case GTE:
+					v1 = v1>=v2?1.0:0.0;
+					break;
+				case LT:
+					v1 = v1<v2?1.0:0.0;
+					break;
+				case LTE:
+					v1 = v1<=v2?1.0:0.0;
+					break;
+			}
+		} else if (s1!=null) {
+			if (s1.equals("true"))
+				v1 = 1.0;
+			else if (s1.equals("false"))
+				v1 = 0.0;
+			else
+				v1 = Tools.parseDouble(s1, Double.NaN);
+		}
+		return v1;
+	}
+	
+	private boolean numericStringFunction(int loc) {
+		if ((pgm.code[loc]&TOK_MASK)!=STRING_FUNCTION)
+			return false;
+		int address = pgm.code[loc]>>TOK_SHIFT;
+		int type = pgm.table[address].type;
+		if (type==VARIABLE_FUNCTION||type==DIALOG||type==FILE||type==STRING||type==EXT||type==LIST||type==IJ_CALL)
+			return false;
+		if (pgm.code[loc+1]=='.' && (pgm.code[loc+2]&0xff)!=STRING_FUNCTION)
+			return true;
+		if (pgm.code[loc+1]=='(' && pgm.code[loc+2]==')' && pgm.code[loc+3]=='.'  && (pgm.code[loc+4]&0xff)!=STRING_FUNCTION)
+			return true;
+		return false;
+	}
+
+	// Returns true if the token at the specified location is a string
+	boolean isString(int pcLoc) {
+		int tok = pgm.code[pcLoc];
+		if ((tok&0xff)==VARIABLE_FUNCTION) {
+			int address = tok>>TOK_SHIFT;
+			int type = pgm.table[address].type;
+			int token2 = pgm.code[pcLoc+2];
+			String name = pgm.table[token2>>TOK_SHIFT].str;
+			if (Functions.isStringFunction(name,type))
+				return true; 
+		}
+		if ((tok&TOK_MASK)!=WORD)
+			return false;
+		Variable v = lookupVariable(tok>>TOK_SHIFT);
+		if (v==null)
+			return false;
+		if (pgm.code[pcLoc+1]=='[') {
+			Variable[] array = v.getArray();
+			if (array!=null && array.length>0)
+				return array[0].getType()==Variable.STRING;
+		}
+		int type = v.getType();
+		if (type==Variable.STRING && (pgm.code[pcLoc+1]&0xff)=='.' && (pgm.code[pcLoc+2]&0xff)!=STRING_FUNCTION)
+			return false;
+		return type==Variable.STRING;
+	}
+
+	double compareStrings(String s1, String s2, int op) {
+		int result;
+		result = s1.compareToIgnoreCase(s2);
+		double v1 = 0.0;
+		switch (op) {
+			case EQ:
+				v1 = result==0?1.0:0.0;
+				break;
+			case NEQ:
+				v1 = result!=0?1.0:0.0;
+				break;
+			case GT:
+				v1 = result>0?1.0:0.0;
+				break;
+			case GTE:
+				v1 = result>=0?1.0:0.0;
+				break;
+			case LT:
+				v1 = result<0?1.0:0.0;
+				break;
+			case LTE:
+				v1 = result<=0?1.0:0.0;
+				break;
+		}
+		return v1;
+	}
+
+	final double getAssignmentExpression() {
+		int tokPlus2 = pgm.code[pc+2];
+		if ((pgm.code[pc+1]&0xff)==WORD && (tokPlus2=='='||tokPlus2==PLUS_EQUAL
+		||tokPlus2==MINUS_EQUAL||tokPlus2==MUL_EQUAL||tokPlus2==DIV_EQUAL)) {
+			getToken();
+			Variable v = lookupLocalVariable(tokenAddress);
+			int saveAddress = tokenAddress;
+			getToken();
+			double value = 0.0;
+			if (token=='=')
+				value = getAssignmentExpression();
+			else {
+				value = v!=null?v.getValue():0.0;
+				switch (token) {
+					case PLUS_EQUAL: value += getAssignmentExpression(); break;
+					case MINUS_EQUAL: value -= getAssignmentExpression(); break;
+					case MUL_EQUAL: value *= getAssignmentExpression(); break;
+					case DIV_EQUAL: value /= getAssignmentExpression(); break;
+				}
+			}
+			if (v==null)
+				v = push(saveAddress, 0.0, null, this);
+			v.setValue(value);
+			return value;
+		} else
+			return getLogicalExpression();
+	}
+
+	final void checkBoolean(double value) {
+		if (!(value==0.0 || value==1.0))
+			error("Boolean expression expected: "+value);
+	}
+
+	void doVar() {
+		getToken();
+		while (token==WORD) {
+			if (nextToken()=='=')
+				doAssignment();
+			else {
+				Variable v = lookupVariable(tokenAddress);
+				if (v==null)
+					push(tokenAddress, 0.0, null, this);
+			}
+			getToken();
+			if (token==',')
+				getToken();
+			else {
+				putTokenBack();
+				break;
+			}
+		}
+	}
+	
+	final void getLeftParen() {
+		getToken();
+		if (token!='(')
+			error("'(' expected");
+	}
+
+	final void getRightParen() {
+		getToken();
+		if (token!=')')
+			error("')' expected");
+	}
+
+	final void getParens() {
+		if (nextToken()=='(') {
+			getLeftParen();
+			getRightParen();
+		}
+	}
+
+	final void getComma() {
+		getToken();
+		if (token!=',') {
+			if (looseSyntax)
+				putTokenBack();
+			else
+				error("',' expected");
+		}
+	}
+
+	void error (String message) {
+		errorMessage = message;
+		if (ignoreErrors)
+			return;
+		errorCount++;
+		boolean showMessage = !done;
+		String[] variables = showMessage?getVariables():null;
+		token = EOF;
+		tokenString = "";
+		IJ.showStatus("");
+		IJ.showProgress(0, 0);
+		batchMode = false;
+		imageTable = imageActivations = null;
+		WindowManager.setTempCurrentImage(null);
+		wasError = true;
+		if (!evaluating)
+			instance = null;
+		if (showMessage && message!=null) {
+			String line = getErrorLine();
+			done = true;
+			if (line.length()>120)
+				line = line.substring(0,119)+"...";			
+			Frame f = WindowManager.getFrame("Debug");			
+			TextPanel panel = null;
+			if (showVariables && f!=null && (f instanceof TextWindow)) { //clear previous content
+				TextWindow debugWindow = (TextWindow) f;
+				if (debugWindow != null) {
+					panel = debugWindow.getTextPanel();
+					panel.clear();
+				}	
+			}
+			String calledFrom = "";
+			if (callDepth > 0 && callStack != null) {
+				for (int jj = callDepth - 1; jj >= 0; jj--) {
+					int theline = callStack[jj];
+					calledFrom += "\t\t(called from line " + theline +")\n";
+				}
+			}
+			showError("Macro Error", message+" in line "+lineNumber +"\n" + calledFrom +" \n"+line, variables);
+			f = WindowManager.getFrame("Debug");
+			if (showVariables && f!=null && (f instanceof TextWindow)) {
+				TextWindow debugWindow = (TextWindow)f;
+				debugWindow.append("\n---\t\t---\nError:\t\t" + message + " in line "+lineNumber + ":");
+				debugWindow.append(calledFrom + "\t\t");	
+				debugWindow.append("\t\t"+line);
+			}			
+			throw new RuntimeException(Macro.MACRO_CANCELED);
+		}
+		done = true;
+		if (errorCount>10) 
+			throw new RuntimeException(Macro.MACRO_CANCELED);
+	}
+		
+	void showError(String title, String msg, String[] variables) {
+		boolean noImages = msg.startsWith("There are no images open");
+		if (noImages)
+			title = "No Image";
+		Macro.setOptions(null);
+		GenericDialog gd = new GenericDialog(title);
+		gd.setInsets(6,5,0);
+		gd.addMessage(msg);
+		gd.setInsets(15,30,5);
+		if (!noImages)
+			gd.addCheckbox("Show \"Debug\" Window", showVariables);
+		gd.hideCancelButton();
+		gd.showDialog();
+		if (!noImages)
+			showVariables = gd.getNextBoolean();
+		else
+			showVariables = false;
+		if (!gd.wasCanceled() && showVariables)
+			updateDebugWindow(variables, null);
+	}
+
+	public TextWindow updateDebugWindow(String[] variables, TextWindow debugWindow) {
+		if (debugWindow==null) {
+			Frame f = WindowManager.getFrame("Debug");
+			if (f!=null && (f instanceof TextWindow)) {
+				debugWindow = (TextWindow)f;
+				debugWindow.toFront();
+			}
+		}
+		if (debugWindow==null)
+			debugWindow = new TextWindow("Debug", "Name\t*\tValue", "", 300, 400);
+		TextPanel panel = debugWindow.getTextPanel();
+		int n = variables.length;
+		if (n==0) {
+			panel.clear();
+			return debugWindow;
+		}
+		int lines = panel.getLineCount();
+		String[] markedVariables = markChanges(variables);
+		for (int i=0; i<lines; i++) {
+			if (i<n)
+				panel.setLine(i, markedVariables[i]);
+			else
+				panel.setLine(i, "");
+		}
+		for (int i=lines; i<n; i++)
+			debugWindow.append(markedVariables[i]);
+		return debugWindow;
+	}
+
+	private static String[] prevVars; //previous variables for comparison
+
+	private String[] markChanges(String[] newVars) {//add asterisk if variable has changed
+		int len = newVars.length;
+		String[] copyOfNew = new String[len];
+		String[] hilitedVars = new String[len];
+		for (int jj = 0; jj < len; jj++) {
+			copyOfNew[jj] = newVars[jj];
+			String marker = "\t*\t";//changed
+			if (prevVars != null && jj < prevVars.length && jj < len && prevVars[jj].equals(newVars[jj]))
+				marker = "\t\t";//unchanged
+			hilitedVars[jj] = newVars[jj].replaceFirst("\t", marker);
+		}
+		prevVars = copyOfNew;
+		return hilitedVars;
+	}
+
+	String getErrorLine() {
+		int savePC = pc;
+		lineNumber = pgm.lineNumbers[pc];
+		while (pc>=0 && lineNumber==pgm.lineNumbers[pc])
+			pc--;   //go to beginning of line
+		if (lineNumber<=1)
+			pc = -1;
+		String line = "";
+		getToken();
+		while (!done && lineNumber==pgm.lineNumbers[pc]) {
+			String str = pgm.decodeToken(token, tokenAddress);
+			if (pc==savePC)
+				str = "<" + str + ">";
+			line += str + " ";
+			getToken();
+		}
+		return line;
+	}
+
+	final String getString() {
+		String str = getStringTerm();
+		while (true) {
+			getToken();
+			if (token=='+')
+				str += getStringTerm();
+			else {
+				putTokenBack();
+				break;
+			}
+		}
+		return str;
+	}
+
+	final String getStringTerm() {
+		String str;
+		Variable v;
+		getToken();
+		switch (token) {
+			case STRING_CONSTANT:
+				str = tokenString;
+				break;
+			case STRING_FUNCTION:
+				str = func.getStringFunction(pgm.table[tokenAddress].type);
+				break;
+			case VARIABLE_FUNCTION:		
+				if (!isString(pc)) {
+					putTokenBack();
+					str = toString(getStringExpression());
+					break;
+				}
+				v = func.getVariableFunction(pgm.table[tokenAddress].type);
+				str = v.getString();
+				if (str==null) {
+					double value = v.getValue();
+					if ((int)value==value)
+						str = IJ.d2s(value,0);
+					else
+						str = ""+value;
+				}
+				break;
+			case USER_FUNCTION:
+				v = runUserFunction();
+				if (v==null)
+					error("No return value");
+				str = v.getString();
+				if (str==null) {
+					double value = v.getValue();
+					if ((int)value==value)
+						str = IJ.d2s(value,0);
+					else
+						str = ""+value;
+				}
+				break;
+			case WORD:
+				str = lookupStringVariable();
+				if (str!=null)
+					break;
+				// else fall through
+			default:
+				putTokenBack();
+				str = toString(getStringExpression());
+		}
+		return str;
+	}
+	
+	private String toString(double x) {
+		if ((int)x==x)
+			return IJ.d2s(x,0);
+		else {
+			if (evaluating)
+				return ""+x;
+			String str = IJ.d2s(x, 4, 9);
+			while(str.endsWith("0") && str.contains(".") && !str.contains("E"))
+				str = str.substring(0, str.length()-1);
+			if (str.endsWith("."))
+				str = str.substring(0, str.length()-1);
+			return str;
+		}
+	}
+
+	final boolean isStringFunction() {
+		Symbol symbol = pgm.table[tokenAddress];
+		return symbol.type==D2S;
+	}
+
+	final double getExpression() {
+		double value = getTerm();
+		int next;
+		while (true) {
+			next = nextToken();
+			if (next=='+') {
+				getToken();
+				value += getTerm();
+			} else if (next=='-') {
+				getToken();
+				value -= getTerm();
+			} else
+				break;
+		}
+		return value;
+	}
+
+	final double getTerm() {
+		double value = getFactor();
+		boolean done = false;
+		int next;
+		while (!done) {
+			next = nextToken();
+			switch (next) {
+				case '*': getToken(); value *= getFactor(); break;
+				case '/': getToken(); value /= getFactor(); break;
+				case '%': getToken(); value %= getFactor(); break;
+				case '&': getToken(); value = (int)value&(int)getFactor(); break;
+				case '|': getToken(); value = (int)value|(int)getFactor(); break;
+				case '^': getToken(); value = (int)value^(int)getFactor(); break;
+				case SHIFT_RIGHT: getToken(); value = (int)value>>(int)getFactor(); break;
+				case SHIFT_LEFT: getToken(); value = (int)value<<(int)getFactor(); break;
+				default: done = true; break;
+			}
+		}
+		return value;
+	}
+
+	final double getFactor() {
+		double value = 0.0;
+		Variable v = null;
+		getToken();
+		switch (token) {
+			case NUMBER:
+				value = tokenValue;
+				break;
+			case STRING_CONSTANT:
+				value = Tools.parseDouble(tokenString,Double.NaN);
+				break;
+			case NUMERIC_FUNCTION:
+				value = func.getFunctionValue(pgm.table[tokenAddress].type);
+				break;
+			case STRING_FUNCTION:
+				String str = func.getStringFunction(pgm.table[tokenAddress].type);
+				if (nextToken()=='.') {
+					getToken();  // '.'
+					getToken();  // numericFunction
+					value = getNumericStringFunction(str);
+				} else
+					value = Tools.parseDouble(str);
+				if ("NaN".equals(str))
+					value = Double.NaN;
+				else if (Double.isNaN(value))
+					error("Numeric value expected");
+				break;				
+			case VARIABLE_FUNCTION:
+				v = func.getVariableFunction(pgm.table[tokenAddress].type);
+				if (v==null)
+					error("No return value");
+				if (v.getString()!=null) {
+						error("Numeric return value expected");
+				} else
+					value = v.getValue();
+				break;
+			case USER_FUNCTION:
+				v = runUserFunction();
+				if (v==null)
+					error("No return value");
+				if (done)
+					value = 0;
+				else {
+					if (v.getString()!=null)
+						error("Numeric return value expected");
+					else
+						value = v.getValue();
+				}
+				break;
+			case TRUE: value = 1.0; break;
+			case FALSE: value = 0.0; break;
+			case PI: value = Math.PI; break;
+			case NaN: value = Double.NaN; break;
+			case WORD:
+				v = lookupVariable();
+				if (v==null)
+					return 0.0;
+				int next = nextToken();
+				if (next=='[') {
+					v = getArrayElement(v);
+					value = v.getValue();
+					next = nextToken();
+					if (next=='.') {
+						value = runNumericFunction(v);
+						next = nextToken();
+					}
+				} else if (next=='.') {
+					value = runNumericFunction(v);
+					next = nextToken();
+				} else {
+					if (v.getArray()!=null) {
+						getToken();
+						error("'[' or '.' expected");
+					}
+					if (prefixValue!=0 && !checkingType) {
+						v.setValue(v.getValue()+prefixValue);
+						prefixValue = 0;
+					}
+					value = v.getValue();
+				}
+				if (!(next==PLUS_PLUS || next==MINUS_MINUS))
+					break;
+				getToken();
+				if (token==PLUS_PLUS)
+					v.setValue(v.getValue()+(checkingType?0:1));
+				else
+					v.setValue(v.getValue()-(checkingType?0:1));
+				break;
+			case (int)'(':
+				value = getLogicalExpression();
+				getRightParen();
+				break;
+			case PLUS_PLUS:
+				prefixValue = 1;
+				value = getFactor();
+				break;
+			case MINUS_MINUS:
+				prefixValue = -1;
+				value = getFactor();
+				break;
+			case '!':
+				value = getFactor();
+				if (value==0.0 || value==1.0) {
+					value = value==0.0?1.0:0.0;
+				} else
+					error("Boolean expected");
+				break;
+			case '-':
+				value = -getFactor();
+				break;
+			case '~':
+				value = ~(int)getFactor();
+				break;
+			default:
+				error("Number or numeric function expected");
+		}
+		// IJ.log("getFactor: "+value+" "+pgm.decodeToken(preToken,0));
+		return value;
+	}
+
+
+	private double getNumericStringFunction(String str) {
+		double value = Double.NaN;
+		if (token==WORD) {
+			if (tokenString.equals("length")) {
+				getParens();
+				value = str.length();
+			} else if (tokenString.equals("contains"))
+				value = str.contains(func.getStringArg())?1:0;
+			else if (tokenString.equals("charAt"))
+				value = str.charAt((int)func.getArg());
+		} else if (token==NUMERIC_FUNCTION) {
+			int type = pgm.table[tokenAddress].type;
+			switch (type) {
+				case INDEX_OF: value = func.indexOf(str); break;
+				case LAST_INDEX_OF: value = str.lastIndexOf(func.getStringArg()); break;
+				case STARTS_WITH: value = str.startsWith(func.getStringArg())?1:0; break;
+				case ENDS_WITH: value = str.endsWith(func.getStringArg())?1:0; break;
+				case MATCHES: value = func.matches(str); break;
+			}
+		} else
+			error("Numeric function expected");
+		return value;
+	}
+
+	final Variable getArrayElement(Variable v) {
+		int index = getIndex();
+		Variable[] array = v.getArray();
+		if (array==null)
+			error("Array expected");
+		if (index<0 || index>=array.length) {
+			if (array.length==0)
+				error("Empty array");
+			else
+				error("Index ("+index+") out of 0-"+(array.length-1)+" range");
+		}
+		return array[index];
+	}
+	
+	final double runNumericFunction(Variable v) {
+		getToken(); // '.'
+		getToken();
+		if (token==WORD && v.getArray()!=null && tokenString.equals("length"))
+			return v.getArraySize();			
+		String str = v.getString();
+		if (str==null)
+			error("Array or string expected");	
+		return getNumericStringFunction(str);
+	}
+	
+	final double getStringExpression() {
+		double value = getTerm();
+		while (true) {
+			getToken();
+			if (token=='+') {
+				getToken();
+				if (token==STRING_CONSTANT || token==STRING_FUNCTION) {
+					putTokenBack();
+					putTokenBack();
+					break;
+				}
+				if (token==WORD) {
+					Variable v = lookupVariable(tokenAddress);
+					if (v!=null && v.getString()!=null) {
+						putTokenBack();
+						putTokenBack();
+						break;
+					}
+				}
+				putTokenBack();
+				value += getTerm();
+			} else if (token=='-')
+				value -= getTerm();
+			else {
+				putTokenBack();
+				break;
+			}
+		};
+		return value;
+	}
+
+	/** Searches the local and global sections of the stack for.
+		the specified variable. Returns null if it is not found. */
+	final Variable lookupLocalVariable(int symTabAddress) {
+		//IJ.log("lookupLocalVariable: "+topOfStack+" "+startOfLocals+" "+topOfGlobals);
+		Variable v = null;
+		for (int i=topOfStack; i>=startOfLocals; i--) {
+			if (stack[i].symTabIndex==symTabAddress) {
+				v = stack[i];
+				break;
+			}
+		}
+		if (v==null) {
+			for (int i=topOfGlobals; i>=0; i--) {
+				if (stack[i].symTabIndex==symTabAddress) {
+					v = stack[i];
+					break;
+				}
+			}
+		}
+		return v;
+	}
+
+	/** Searches the entire stack for the specified variable. Returns null if it is not found. */
+	final Variable lookupVariable(int symTabAddress) {
+		Variable v = null;
+		for (int i=topOfStack; i>=0; i--) {
+			if (stack[i].symTabIndex==symTabAddress) {
+				v = stack[i];
+				break;
+			}
+		}
+		return v;
+	}
+
+	Variable push(Variable var, Interpreter interp) {
+		if (stack==null)
+			stack = new Variable[STACK_SIZE];
+		if (topOfStack>=(STACK_SIZE-2))
+			interp.error("Stack overflow");
+		else
+			topOfStack++;
+		stack[topOfStack] = var;
+		return var;
+	}
+
+	void pushGlobals() {
+		if (pgm.globals==null)
+			return;
+		if (stack==null)
+			stack = new Variable[STACK_SIZE];
+		for (int i=0; i<pgm.globals.length; i++) {
+			topOfStack++;
+			stack[topOfStack] = pgm.globals[i];
+		}
+		topOfGlobals = topOfStack;
+	}
+
+	/** Creates a Variable and pushes it onto the stack. */
+	Variable push(int symTabLoc, double value, String str, Interpreter interp) {
+		Variable var = new Variable(symTabLoc, value, str);
+		if (stack==null)
+			stack = new Variable[STACK_SIZE];
+		if (topOfStack>=(STACK_SIZE-2))
+			interp.error("Stack overflow");
+		else
+			topOfStack++;
+		stack[topOfStack] = var;
+		return var;
+	}
+
+	void trimStack(int previousTOS, int previousStartOfLocals) {
+		for (int i=previousTOS+1; i<=topOfStack; i++)
+			stack[i] = null;
+		topOfStack = previousTOS;
+	    startOfLocals = previousStartOfLocals;
+	}
+	
+	/** Searches the entire stack for the variable associated with the 
+		current token. Aborts the macro if it is not found. */
+	final Variable lookupVariable() {
+		Variable v = null;
+		if (stack==null) {
+			undefined();
+			return v;
+		}
+		boolean found = false;
+		for (int i=topOfStack; i>=0; i--) {
+			v = stack[i];
+			if (v.symTabIndex==tokenAddress) {
+				found = true;
+				break;
+			}
+		}
+		if (!found)
+			undefined();
+		return v;
+	}
+
+	final String lookupStringVariable() {
+		if (stack==null) {
+			undefined();
+			return "";
+		}
+		boolean found = false;
+		String str = null;
+		for (int i=topOfStack; i>=0; i--) {
+			if (stack[i].symTabIndex==tokenAddress) {
+				Variable v = stack[i];
+				found = true;
+				int next = nextToken();
+				if (next=='[') {
+					int savePC = pc;
+					int index = getIndex();
+					Variable[] array = v.getArray();
+					if (array==null)
+						error("Array expected");
+					if (index<0 || index>=array.length)
+						error("Index ("+index+") out of 0-"+(array.length-1)+" range");
+					str = array[index].getString();
+					int next2 = nextToken();			
+					if (str!=null) {
+						if (next2=='.')
+							str = runStringFunction(str);
+					} else {
+						if (next2==')' || next2==';')
+							str = toString(array[index].getValue());
+						else {
+							pc = savePC-1;
+							getToken();
+						}
+					}
+				} else if (next=='.') {
+					if (v.getString()!=null)
+						str = runStringFunction(v.getString());
+				} else {
+					if (v.getArray()!=null)
+						{getToken(); error("'[' or '.' expected");}
+					str = v.getString();
+				}
+				break;
+			}
+		}
+		if (!found)
+			undefined();
+		return str;
+	}
+	
+	private String runStringFunction(String str) {
+		getToken(); // '.'
+		getToken();
+		if (token==WORD) {
+			if (tokenString.equals("length")) {
+				getParens();
+				str = ""+str.length();
+			} else if (tokenString.equals("contains")) {
+				str = ""+str.contains(func.getStringArg());
+			} else if (tokenString.equals("charAt")) {
+				str = ""+str.charAt((int)func.getArg());
+			} else if (tokenString.equals("replaceAll")) {
+				str = func.replace(str);
+			} else
+				str = null;
+		} else if (token==NUMERIC_FUNCTION) {
+			int type = pgm.table[tokenAddress].type;
+			switch (type) {
+				case INDEX_OF: str = ""+func.indexOf(str); break;
+				case LAST_INDEX_OF: str = ""+str.lastIndexOf(func.getStringArg()); break;
+				case STARTS_WITH: str = ""+str.startsWith(func.getStringArg()); break;
+				case ENDS_WITH: str = ""+str.endsWith(func.getStringArg()); break;
+				case MATCHES: str = ""+func.matches(str); break;
+				default:
+					str = null;
+			}
+		} else if (token==STRING_FUNCTION) {
+			int type = pgm.table[tokenAddress].type;
+			switch (type) {
+				case SUBSTRING: str = func.substring(str); break;
+				case TO_LOWER_CASE: getParens(); str = str.toLowerCase(Locale.US); break;
+				case TO_UPPER_CASE: getParens(); str = str.toUpperCase(Locale.US); break;
+				case REPLACE: str = func.replace(str); break;
+				case TRIM: getParens();  str = str.trim(); break;
+				default:
+					str = null;
+			}
+		} else
+			str = null;
+		if (str==null)
+			error("String function expected");
+		return str;
+	}
+
+	int getIndex() {
+		getToken();
+		if (token!='[')
+			error("'['expected");
+		int index = (int)getExpression();
+		getToken();
+		if (token!=']')
+			error("']' expected");
+		return index;
+	}
+	
+	void undefined() {
+		if (nextToken()=='(')
+			error("Undefined identifier");
+		else {
+			if (pgm.getSize()==1) {
+				String cmd = pgm.decodeToken(pgm.code[0]);
+				cmd = cmd.replaceAll("_", " ");
+				Hashtable commands = Menus.getCommands();
+				if (commands!=null && commands.get(cmd)!=null)
+					IJ.run(cmd);
+				else
+					error("Undefined variable");
+			} else
+				error("Undefined variable");
+		}
+	}
+	
+	void dump() {
+		getParens();
+		if (!done) {
+			pgm.dumpSymbolTable();
+			pgm.dumpProgram();
+			dumpStack();
+		}
+	}
+
+	void dumpStack() {
+		IJ.log("");
+		IJ.log("Stack");
+		if (stack!=null) {
+			for (int i=topOfStack; i>=0; i--) {
+				Variable v = stack[i];
+				Symbol symbol = v!=null?pgm.table[v.symTabIndex]:null;
+				IJ.log(i+" "+(symbol!=null?symbol.str:"null")+" "+v);
+			}
+		}
+	}
+	
+	void finishUp() {
+		if (batchMacro)
+			batchMacroImage = WindowManager.getCurrentImage();
+		func.updateDisplay();
+		instance = null;
+		if (!calledMacro || batchMacro) {
+			if (batchMode)
+				showingProgress = true;
+			batchMode = false;
+			imageTable = imageActivations = null;
+			WindowManager.setTempCurrentImage(null);
+		}
+		if (func.plot!=null) {
+			func.plot.show();
+			func.plot = null;
+		}
+		if (showingProgress)
+			IJ.showProgress(0, 0);
+		if (keysSet) {
+			IJ.setKeyUp(KeyEvent.VK_ALT);
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);		
+			IJ.setKeyUp(KeyEvent.VK_SPACE);
+		}
+		if (rgbWeights!=null)
+			ColorProcessor.setWeightingFactors(rgbWeights[0], rgbWeights[1], rgbWeights[2]);
+		if (func.writer!=null)
+			func.writer.close();
+		func.roiManager = null;
+		if (func.resultsPending) {
+			ResultsTable rt = ResultsTable.getResultsTable();
+			if (rt!=null && rt.size()>0)
+				rt.show("Results");
+		}
+		if (func.unUpdatedTable!=null)
+			func.unUpdatedTable.show(func.unUpdatedTable.getTitle());
+		if (IJ.isMacOSX() && selectCount>0 && debugger==null) {
+			Frame frame = WindowManager.getFrontWindow();
+			if (frame!=null && (frame instanceof ImageWindow))
+				ImageWindow.setImageJMenuBar((ImageWindow)frame);
+		}
+	}
+	
+	/** Aborts currently running macro. */
+	public static void abort() {
+		//IJ.log("abort: "+(instance!=null?""+instance.hashCode():"null"));
+		if (instance!=null)
+			instance.abortMacro();
+	}
+	
+	/** Aborts the macro that was running when this one started. */
+	static void abortPrevious() {
+		if (previousInstance!=null) {
+			previousInstance.abortMacro();
+			IJ.beep();
+			previousInstance = null;
+		}
+	}
+
+	/** Absolete, replaced by abortMacro(). */
+	public static void abort(Interpreter interp) {
+		if (interp!=null)
+			interp.abortMacro();
+	}
+	
+	/** Aborts this macro. */
+	public void abortMacro() {
+		if (!calledMacro || batchMacro) {
+			batchMode = false;
+			imageTable = imageActivations = null;
+		}
+		if (func!=null && !(macroName!=null&&macroName.indexOf(" Tool")!=-1))
+			func.abortDialog();
+		IJ.showStatus("Macro aborted");
+		shutdown();
+		//IJ.log("abortMacro1: "+done+" "+(instance!=null?""+instance.hashCode():"null"));
+		long t0 = System.currentTimeMillis();
+		while ((System.currentTimeMillis()-t0)<2000 && instance!=null)
+			IJ.wait(5);
+		if (instance!=null) {
+			abortAllMacroThreads();
+			setInstance(null);
+		}
+	}
+	
+	public void abort(String message) {
+		errorMessage = message;
+		if (ignoreErrors) {
+			done = true;
+			finishUp();
+		} else {
+			error(message);
+		}
+	}
+	
+	private synchronized void shutdown() {
+		ignoreErrors = true;
+		for (int i=0; i<10; i++)
+			done = true;
+	}
+		
+	private void abortAllMacroThreads() {
+		try {
+			ThreadGroup group = Thread.currentThread().getThreadGroup(); 
+			int activeCount = group.activeCount(); 
+			Thread[] threads = new Thread[activeCount]; 
+			group.enumerate(threads); 
+			for (int i = 0; i < activeCount; i++) { 
+				String name = threads[i].getName(); 
+				if (name!=null && name.endsWith("Macro$"))
+					threads[i].stop(); 
+			}
+		} catch (Throwable e) {
+		}
+	} 
+
+	public static Interpreter getInstance() {
+		return instance;
+	}
+	
+	static void setInstance(Interpreter i) {
+		instance = i;
+	}
+
+	static void setBatchMode(boolean b) {
+		batchMode = b;
+		if (b==false)
+			imageTable = imageActivations = null;
+	}
+
+	public static boolean isBatchMode() {
+		return batchMode && !tempShowMode;
+	}
+	
+	public static void addBatchModeImage(ImagePlus imp) {
+		if (!batchMode || imp==null) return;
+		if (imageTable==null)
+			imageTable = new Vector();
+		imageTable.add(imp);
+		activateImage(imp);
+	}
+
+	public static void removeBatchModeImage(ImagePlus imp) {
+		if (imageTable!=null && imp!=null) {
+			int index = imageTable.indexOf(imp);
+			if (index!=-1) {
+				imageTable.remove(index);
+				imageActivations.remove(imp);
+				WindowManager.setTempCurrentImage(getLastBatchModeImage());
+			}
+		}
+	}
+	
+	public static void activateImage(ImagePlus imp) {
+		if (imageTable!=null && imp!=null) {
+			if (imageActivations==null)
+				imageActivations = new Vector();
+			imageActivations.remove(imp);
+			imageActivations.add(imp);
+		}
+	}
+
+	public static int[] getBatchModeImageIDs() {
+		if (!batchMode || imageTable==null)
+			return new int[0];
+		int n = imageTable.size();
+		int[] imageIDs = new int[n];
+		for (int i=0; i<n; i++) {
+			ImagePlus imp = (ImagePlus)imageTable.get(i);
+			imageIDs[i] = imp.getID();
+		}
+		return imageIDs;
+	}
+
+	public static int getBatchModeImageCount() {
+		if (!batchMode || imageTable==null)
+			return 0;
+		else
+			return imageTable.size();
+	}
+	
+	public static ImagePlus getBatchModeImage(int id) {
+		if (!batchMode || imageTable==null)
+			return null;
+		for (Enumeration en=Interpreter.imageTable.elements(); en.hasMoreElements();) {
+			ImagePlus imp = (ImagePlus)en.nextElement();
+			if (id==imp.getID())
+				return imp;
+		}
+		return null;
+	}
+	
+	public static ImagePlus getLastBatchModeImage() { 
+		if (!batchMode || imageTable==null)
+			return null; 
+		ImagePlus imp2 = null;
+		try {
+			int size = imageTable.size(); 
+			if (size==0)
+				return null;
+			if (imageActivations!=null && imageActivations.size()>0)
+				imp2 =  (ImagePlus)imageActivations.get(imageActivations.size()-1);
+			if (imp2==null)
+				imp2 = (ImagePlus)imageTable.get(size-1);
+		} catch(Exception e) { }
+		return imp2;
+	} 
+ 
+ 	/** The specified string, if not null, is added to strings passed to the run() method. */
+ 	public static void setAdditionalFunctions(String functions) {
+ 		additionalFunctions = functions;
+	} 
+
+ 	public static String getAdditionalFunctions() {
+ 		return additionalFunctions;
+	} 
+	
+	/** Returns the batch mode RoiManager instance. */
+	public static RoiManager getBatchModeRoiManager() {
+		Interpreter interp = getInstance();
+		if (interp!=null && isBatchMode() && RoiManager.getRawInstance()==null) {
+			if (interp.func.roiManager==null)
+				interp.func.roiManager = new RoiManager(true);
+			return interp.func.roiManager;
+		} else
+			return null;
+	}
+	
+	/** Returns true if there is an internal batch mode RoiManager. */
+	public static boolean isBatchModeRoiManager() {
+		Interpreter interp = getInstance();
+		return interp!=null && isBatchMode() && interp.func.roiManager!=null;
+	}
+	
+	public void setDebugger(Debugger debugger) {
+		this.debugger = debugger;
+		if (debugger!=null)
+			debugMode = Debugger.STEP;
+		else
+			debugMode = Debugger.NOT_DEBUGGING;
+	}
+	
+	// Returns the Debugger (editor), if any, associated with this macro. */
+	public Debugger getDebugger() {
+		return debugger;
+	}
+
+	public void setDebugMode(int mode) {
+		debugMode = mode;
+	}
+	
+	public int getLineNumber() {
+        return pgm.lineNumbers[pc];
+    }
+
+	/** Returns the names of all variables and functions with human-readable annotations */
+	public String[] getVariables() {
+		int nImages = WindowManager.getImageCount();
+		if (nImages>0) showDebugFunctions = true;
+		int nFunctions = showDebugFunctions?3:0;
+		String[] variables = new String[topOfStack+1+nFunctions];
+		if (showDebugFunctions) {
+			String title = null;
+			if (nImages>0) {
+				ImagePlus imp = WindowManager.getCurrentImage();
+				if (imp!=null) title = imp.getTitle();
+			}
+			if (debugMode==Debugger.STEP) System.gc();
+			variables[0] = "Memory\t" + IJ.freeMemory();
+			variables[1] = "nImages()\t" + nImages;
+			variables[2] = "getTitle()\t" + (title!=null?"\""+title+"\"":"");
+		}
+		String name;
+		int index = nFunctions;
+		for (int i=0; i<=topOfStack; i++) {
+			name = pgm.table[stack[i].symTabIndex].str;
+			if (i<=topOfGlobals)
+				name += " (g)";
+			variables[index++] = name + "\t" + stack[i];
+		}
+		return variables;
+	}
+	
+	/** Returns the names of all variables, without any annotation */
+	public String[] getVariableNames() {
+		String[] variables = new String[topOfStack+1];
+		for (int i=0; i<=topOfStack; i++)
+			variables[i] = pgm.table[stack[i].symTabIndex].str;
+		return variables;
+	}
+
+	// Returns 'true' if this macro has finished or if it was aborted. */
+	public boolean done() {
+		return done;
+	}
+
+	// Returns 'true' if this macro generated an error and was aborted. */
+	public boolean wasError() {
+		return wasError;
+	}
+
+	public void setVariable(String name, double value) {
+		int index;
+		for (int i=0; i<=topOfStack; i++) {
+			index = stack[i].symTabIndex;
+			if (pgm.table[index].str.equals(name)) {
+				stack[i].setValue(value);
+				break;
+			}
+		}
+	}
+	
+	public void setVariable(String name, String str) {
+		int index;
+		for (int i=0; i<=topOfStack; i++) {
+			index = stack[i].symTabIndex;
+			if (pgm.table[index].str.equals(name)) {
+				stack[i].setString(str);
+				break;
+			}
+		}
+	}
+
+	public double getVariable(String name) {
+		int index;
+		for (int i=0; i<=topOfStack; i++) {
+			index = stack[i].symTabIndex;
+			if (pgm.table[index].str.equals(name))
+				return stack[i].getValue();
+		}
+		return Double.NaN;
+	}
+
+	public double getVariable2(String name) {
+		int index;
+		for (int i=topOfStack; i>=0; i--) {
+			index = stack[i].symTabIndex;
+			if (pgm.table[index].str.equals(name))
+				return stack[i].getValue();
+		}
+		return Double.NaN;
+	}
+
+	public String getStringVariable(String name) {
+		int index;
+		for (int i=topOfStack; i>=0; i--) {
+			index = stack[i].symTabIndex;
+			if (pgm.table[index].str.equals(name))
+				return stack[i].getString();
+		}
+		return null;
+	}
+	
+	public String getVariableAsString(String name) {
+		String s = getStringVariable(name);
+		if (s==null) {
+			double value = getVariable2(name);
+			if (!Double.isNaN(value)) s=""+value;
+		}
+		return s;
+	}
+	
+	 /**
+	 * Shows array elements after clicking an array variable in Debug
+	 * window
+	 * N. Vischer 
+	 *
+	 * @param row Debug window row of variable to be shown
+	 */
+	public void showArrayInspector(int row) {
+		if (stack==null)
+			return;
+		int nFunctions = showDebugFunctions?3:0;
+		int stkPos = row - nFunctions;
+		if (stack.length>stkPos && stkPos>=0) {
+			Variable var = stack[stkPos];
+			if (var==null)
+				return;
+			if (var.getType()!=Variable.ARRAY && arrayWindow!=null)
+				arrayWindow.setVisible(false);
+			if (var.getType()==Variable.ARRAY) {
+				String headings = "Index\t*\tValue";
+				if (arrayWindow==null)
+					arrayWindow = new TextWindow("Array", "", "", 170, 300);
+				arrayWindow.setVisible(true);
+ 				int symIndex = var.symTabIndex;
+				String arrName = pgm.table[symIndex].str;
+				inspectStkIndex = stkPos;
+				inspectSymIndex = symIndex;
+				TextPanel txtPanel = arrayWindow.getTextPanel();
+				String oldText = txtPanel.getText();// possible NullPointer at ij.text.TextPanel.getText(TextPanel.java:875) vData == null
+				String[] oldLines = oldText.split("\n");
+				txtPanel.clear();
+				txtPanel.setColumnHeadings(headings);
+				Variable[] elements = var.getArray();
+				String title = arrName + "[" + elements.length + "]";
+				arrayWindow.setTitle(title);
+				arrayWindow.rename(title);
+				String newText = "";
+				String valueStr = "";
+				for (int jj=0; jj<elements.length; jj++) {
+					Variable element = elements[jj];
+					if (element.getType()==Variable.STRING) {
+						valueStr = elements[jj].getString();
+						valueStr = valueStr.replaceAll("\n", "\\\\n");
+						valueStr = "\"" + valueStr + "\""; //show it's a string
+					} else if (element.getType()==Variable.VALUE) {
+						double v = elements[jj].getValue();
+						if ((int)v==v)
+							valueStr = IJ.d2s(v, 0);
+						else
+							valueStr = ResultsTable.d2s(v, 4);
+					}
+						String flag = " ";
+						if (oldLines.length > jj + 1){
+							String [] parts = oldLines[jj+1].split("\t");
+							String oldValue = parts[2];
+							if (!valueStr.equals(oldValue))
+									flag ="*";
+						}
+					String ss = ("" + jj + "\t" + flag +"\t" + valueStr) + "\n";
+					newText += ss;
+				}
+				txtPanel.append(newText);
+				txtPanel.scrollToTop();
+				if (debugger!=null && (debugger instanceof Window))
+					((Window)debugger).toFront();
+				// scroll position should not change during single-stepping
+			}
+		}
+	}
+
+	/**
+	 * Updates Array inspector if variable exists, otherwise closes
+	 * ArrayInspector
+	 */
+	public void updateArrayInspector() {
+		boolean varExists = false;
+		if (arrayWindow!=null && arrayWindow.isVisible()) {
+ 			for (int stkIndex=0; stkIndex<=topOfStack; stkIndex++) {
+				Variable var = stack[stkIndex];
+				int symIndex = var.symTabIndex;
+				if (inspectStkIndex==stkIndex && inspectSymIndex==symIndex && var.getType()==Variable.ARRAY) {
+					varExists = true;
+					break;
+				}
+			}
+			if (varExists)
+				showArrayInspector(inspectStkIndex+(showDebugFunctions?3:0));
+			else{
+				arrayWindow.setVisible(false);
+				arrayWindow.getTextPanel().clear();
+			}
+		}
+	}
+	
+	static void setTempShowMode(boolean mode) {
+		tempShowMode = mode;
+	}
+	
+	private static Interpreter lastInterp;
+	
+	public static boolean nonBatchMacroRunning() {
+		Interpreter interp = getInstance();
+		if (interp==null)
+			return false;
+		int count =  interp.selectCount;
+		if (interp==lastInterp)
+			interp.selectCount++;
+		lastInterp = interp;
+		return !interp.waitingForUser && interp.debugger==null && count>0 && !isBatchMode();
+	}
+	
+	public void setApplyMacroTable(ResultsTable rt) {
+		applyMacroTable = rt;
+	}
+	
+	public void setIgnoreErrors(boolean ignoreErrors) {
+		this.ignoreErrors = ignoreErrors;
+	}
+	
+	public String getErrorMessage() {
+		return errorMessage;
+	}
+			
+} // class Interpreter
+
+
+
+
+
diff --git a/src/ij/macro/MacroConstants.java b/src/ij/macro/MacroConstants.java
new file mode 100644
index 0000000..1c301aa
--- /dev/null
+++ b/src/ij/macro/MacroConstants.java
@@ -0,0 +1,143 @@
+package ij.macro;
+
+public interface MacroConstants {
+
+	// In the tokenized macro, the token and optional symbol table address 
+	// are packed into a single 32-bit int. The token is stored in the right-most 
+	// 12 bits and the address in the remaining 24 bits. 
+	public static final int TOK_SHIFT=12, TOK_MASK=0xfff;
+
+	static final int PLUS_PLUS=1, MINUS_MINUS=2, EQ=3, NEQ=4, GT=5, GTE=6, LT=7, LTE=8,
+		PLUS_EQUAL=9, MINUS_EQUAL=10, MUL_EQUAL=11, DIV_EQUAL=12, LOGICAL_AND=13, LOGICAL_OR=14,
+		SHIFT_RIGHT=15, SHIFT_LEFT=16;
+
+	// Token types
+	public static final int EOF=128, WORD=129, NUMBER=130, NOP=131, /*EOL=132,*/ STRING_CONSTANT=133, 
+		PREDEFINED_FUNCTION=134, NUMERIC_FUNCTION=135, STRING_FUNCTION=136, ARRAY_FUNCTION=137, 
+		USER_FUNCTION=138, ARRAY=139, VARIABLE_FUNCTION=140;
+
+	// Keywords
+	static final String[] keywords = {"macro", "var", "if", "else", "while", "do", "for", "function",
+		"return", "true", "false", "PI", "NaN", "break", "continue"};
+	public static final int MACRO=200, VAR=201, IF=202, ELSE=203, WHILE=204, DO=205, FOR=206, FUNCTION=207,
+		RETURN=208, TRUE=209, FALSE=210, PI=211, NaN=212, BREAK=213, CONTINUE=214;
+	static final int[] keywordIDs = {MACRO, VAR, IF, ELSE, WHILE, DO, FOR, FUNCTION,
+		RETURN, TRUE, FALSE, PI, NaN, BREAK, CONTINUE};
+
+	// Functions that don't return a value
+	static final int RUN=300, INVERT=301, SELECT=302, WAIT=303, BEEP=304, RESET_MIN_MAX=305, RESET_THRESHOLD=306,
+		PRINT=307, WRITE=308, DO_WAND=309, SET_MIN_MAX=310, SET_THRESHOLD=311, SET_TOOL=312,
+		SET_FOREGROUND=313, SET_BACKGROUND=314, MAKE_LINE=315, MAKE_OVAL=316, MAKE_RECTANGLE=317,
+		DUMP=318, MOVE_TO=319, LINE_TO=320, DRAW_LINE=321, REQUIRES=322, AUTO_UPDATE=323, UPDATE_DISPLAY=324, DRAW_STRING=325,
+		SET_PASTE_MODE=326, DO_COMMAND=327, SHOW_STATUS=328, SHOW_PROGRESS=329, SHOW_MESSAGE=330, PUT_PIXEL=331, SET_PIXEL=332,
+		SNAPSHOT=333, RESET=334, FILL=335, SET_COLOR=336, SET_LINE_WIDTH=337, CHANGE_VALUES=338, SELECT_IMAGE=339, EXIT=340,
+		SET_LOCATION=341, GET_CURSOR_LOC=342, GET_LINE=343, GET_VOXEL_SIZE=344, GET_HISTOGRAM=345, GET_STATISTICS=346,
+		GET_BOUNDING_RECT=347, GET_LUT=348, SET_LUT=349, GET_COORDINATES=350, SHOW_MESSAGE_WITH_CANCEL=351,
+		MAKE_SELECTION=352, SET_RESULT=353, UPDATE_RESULTS=354, SET_BATCH_MODE=355, SET_JUSTIFICATION=357,
+		SET_Z_COORDINATE=358, GET_THRESHOLD=359, GET_PIXEL_SIZE=360, SETUP_UNDO=361, SAVE_SETTINGS=362, RESTORE_SETTINGS=363,
+		SET_KEY_DOWN=364, OPEN=365, SET_FONT=366, GET_MIN_AND_MAX=367, CLOSE=368, SET_SLICE=369,
+		NEW_IMAGE=370, SAVE_AS=371, SAVE=372, SET_AUTO_THRESHOLD=373, RENAME=374, GET_BOUNDS=375, FILL_RECT=376,
+		GET_RAW_STATISTICS=377, FLOOD_FILL=378, RESTORE_PREVIOUS_TOOL=379, SET_VOXEL_SIZE=380, GET_LOCATION_AND_SIZE=381,
+		GET_DATE_AND_TIME=382, SET_METADATA=383, CALCULATOR=384, SET_RGB_WEIGHTS=385, MAKE_POLYGON=386, SET_SELECTION_NAME=387,
+		DRAW_RECT=388, DRAW_OVAL=389, FILL_OVAL=390, SET_OPTION=391, SHOW_TEXT=392, SET_SELECTION_LOC=393, GET_DIMENSIONS=394,
+		WAIT_FOR_USER=395, MAKE_POINT=396, MAKE_TEXT=397, MAKE_ELLIPSE=398, GET_DISPLAYED_AREA=399,
+		TO_SCALED=400, TO_UNSCALED=401, MAKE_ARROW=402, MAKE_ROTATED_RECT=403;
+	static final String[] functions = {"run","invert","selectWindow","wait", "beep", "resetMinAndMax", "resetThreshold",
+		"print", "write", "doWand", "setMinAndMax", "setThreshold", "setTool",
+		"setForegroundColor", "setBackgroundColor", "makeLine", "makeOval", "makeRectangle",
+		"dump", "moveTo", "lineTo", "drawLine", "requires", "autoUpdate", "updateDisplay", "drawString",
+		"setPasteMode", "doCommand", "showStatus", "showProgress", "showMessage", "putPixel", "setPixel",
+		"snapshot", "reset", "fill", "setColor", "setLineWidth", "changeValues", "selectImage", "exit",
+		"setLocation", "getCursorLoc", "getLine", "getVoxelSize", "getHistogram", "getStatistics",
+		"getBoundingRect", "getLut", "setLut", "getSelectionCoordinates", "showMessageWithCancel",
+		"makeSelection", "setResult", "updateResults", "setBatchMode", "setJustification",
+		"setZCoordinate", "getThreshold", "getPixelSize", "setupUndo", "saveSettings", "restoreSettings",
+		"setKeyDown", "open", "setFont", "getMinAndMax", "close", "setSlice",
+		"newImage", "saveAs", "save", "setAutoThreshold", "rename", "getSelectionBounds", "fillRect",
+		"getRawStatistics", "floodFill", "restorePreviousTool", "setVoxelSize", "getLocationAndSize",
+		"getDateAndTime", "setMetadata", "imageCalculator", "setRGBWeights", "makePolygon", "setSelectionName",
+		"drawRect", "drawOval", "fillOval", "setOption", "showText", "setSelectionLocation", "getDimensions",
+		"waitForUser", "makePoint", "makeText", "makeEllipse", "getDisplayedArea",
+		"toScaled", "toUnscaled", "makeArrow", "makeRotatedRectangle"};
+	static final int[] functionIDs = {RUN, INVERT, SELECT, WAIT, BEEP, RESET_MIN_MAX, RESET_THRESHOLD,
+		PRINT, WRITE, DO_WAND, SET_MIN_MAX, SET_THRESHOLD, SET_TOOL,
+		SET_FOREGROUND, SET_BACKGROUND, MAKE_LINE, MAKE_OVAL, MAKE_RECTANGLE,
+		DUMP, MOVE_TO, LINE_TO, DRAW_LINE, REQUIRES, AUTO_UPDATE, UPDATE_DISPLAY, DRAW_STRING,
+		SET_PASTE_MODE, DO_COMMAND, SHOW_STATUS, SHOW_PROGRESS, SHOW_MESSAGE, PUT_PIXEL, SET_PIXEL,
+		SNAPSHOT, RESET, FILL, SET_COLOR, SET_LINE_WIDTH, CHANGE_VALUES, SELECT_IMAGE, EXIT,
+		SET_LOCATION, GET_CURSOR_LOC, GET_LINE, GET_VOXEL_SIZE, GET_HISTOGRAM, GET_STATISTICS,
+		GET_BOUNDING_RECT, GET_LUT, SET_LUT, GET_COORDINATES, SHOW_MESSAGE_WITH_CANCEL,
+		MAKE_SELECTION, SET_RESULT, UPDATE_RESULTS, SET_BATCH_MODE, SET_JUSTIFICATION,
+		SET_Z_COORDINATE, GET_THRESHOLD, GET_PIXEL_SIZE, SETUP_UNDO, SAVE_SETTINGS, RESTORE_SETTINGS,
+		SET_KEY_DOWN, OPEN, SET_FONT, GET_MIN_AND_MAX, CLOSE, SET_SLICE,
+		NEW_IMAGE, SAVE_AS, SAVE, SET_AUTO_THRESHOLD, RENAME, GET_BOUNDS, FILL_RECT,
+		GET_RAW_STATISTICS, FLOOD_FILL, RESTORE_PREVIOUS_TOOL, SET_VOXEL_SIZE, GET_LOCATION_AND_SIZE,
+		GET_DATE_AND_TIME, SET_METADATA, CALCULATOR, SET_RGB_WEIGHTS, MAKE_POLYGON, SET_SELECTION_NAME,
+		DRAW_RECT, DRAW_OVAL, FILL_OVAL, SET_OPTION, SHOW_TEXT, SET_SELECTION_LOC, GET_DIMENSIONS,
+		WAIT_FOR_USER, MAKE_POINT, MAKE_TEXT, MAKE_ELLIPSE, GET_DISPLAYED_AREA,
+		TO_SCALED, TO_UNSCALED, MAKE_ARROW, MAKE_ROTATED_RECT};
+
+	// Numeric functions
+	static final int GET_PIXEL=1000, ABS=1001, COS=1002, EXP=1003, FLOOR=1004, LOG=1005, MAX_OF=1006, MIN_OF=1007, POW=1008,
+		ROUND=1009, SIN=1010, SQRT=1011, TAN=1012, GET_TIME=1013, GET_WIDTH=1014, GET_HEIGHT=1015, RANDOM=1016,
+		GET_RESULT=1017, GET_COUNT=1018, GET_NUMBER=1019, NIMAGES=1020, NSLICES=1021,
+		LENGTH_OF=1022, NRESULTS=1023, GET_ID=1024, BIT_DEPTH=1025, SELECTION_TYPE=1026, ATAN=1027, IS_OPEN=1028, 
+		IS_ACTIVE=1029, INDEX_OF=1030, LAST_INDEX_OF=1031, CHAR_CODE_AT=1032, GET_BOOLEAN=1033,
+		STARTS_WITH=1034, ENDS_WITH=1035, ATAN2=1036, IS_NAN=1037, GET_ZOOM=1038, PARSE_INT=1039, PARSE_FLOAT=1040,
+		IS_KEY_DOWN=1041, GET_SLICE_NUMBER=1042, SCREEN_WIDTH=1043, SCREEN_HEIGHT=1044, CALIBRATE=1045,
+		ASIN=1046, ACOS=1047, ROI_MANAGER=1048, TOOL_ID=1049, IS=1050, GET_VALUE=1051, STACK=1052, MATCHES=1053,
+		GET_STRING_WIDTH=1054, FIT=1055, OVERLAY=1056, SELECTION_CONTAINS=1057, PLOT=1058, MATH=1059;
+	static final String[] numericFunctions = { "getPixel", "abs", "cos", "exp", "floor", "log", "maxOf", "minOf", "pow",
+		"round", "sin", "sqrt", "tan", "getTime", "getWidth", "getHeight", "random",
+		"getResult", "getResultsCount", "getNumber", "nImages", "nSlices", 
+		"lengthOf", "nResults", "getImageID", "bitDepth", "selectionType", "atan", "isOpen",
+		"isActive", "indexOf", "lastIndexOf", "charCodeAt", "getBoolean",
+		"startsWith", "endsWith", "atan2", "isNaN", "getZoom", "parseInt", "parseFloat",
+		"isKeyDown", "getSliceNumber", "screenWidth", "screenHeight", "calibrate",
+		"asin", "acos", "roiManager", "toolID", "is", "getValue", "Stack", "matches",
+		"getStringWidth", "Fit", "Overlay", "selectionContains", "Plot", "Math"};
+	static final int[] numericFunctionIDs = {GET_PIXEL, ABS, COS, EXP, FLOOR, LOG, MAX_OF, MIN_OF, POW,
+		ROUND, SIN, SQRT, TAN, GET_TIME, GET_WIDTH, GET_HEIGHT, RANDOM,
+		GET_RESULT, GET_COUNT, GET_NUMBER, NIMAGES, NSLICES,
+		LENGTH_OF, NRESULTS, GET_ID, BIT_DEPTH, SELECTION_TYPE, ATAN, IS_OPEN, 
+		IS_ACTIVE, INDEX_OF, LAST_INDEX_OF, CHAR_CODE_AT, GET_BOOLEAN,
+		STARTS_WITH, ENDS_WITH, ATAN2, IS_NAN, GET_ZOOM, PARSE_INT, PARSE_FLOAT,
+		IS_KEY_DOWN, GET_SLICE_NUMBER, SCREEN_WIDTH, SCREEN_HEIGHT, CALIBRATE,
+		ASIN, ACOS, ROI_MANAGER, TOOL_ID, IS, GET_VALUE, STACK, MATCHES,
+		GET_STRING_WIDTH, FIT, OVERLAY, SELECTION_CONTAINS, PLOT, MATH};
+		
+	// String functions
+	static final int D2S=2000, TO_HEX=2001, TO_BINARY=2002, GET_TITLE=2003, GET_STRING=2004, SUBSTRING=2005,
+		FROM_CHAR_CODE=2006, GET_INFO=2007, GET_DIRECTORY=2008, GET_ARGUMENT=2009, GET_IMAGE_INFO=2010,
+		TO_LOWER_CASE=2011, TO_UPPER_CASE=2012, RUN_MACRO=2013, EVAL=2014, TO_STRING=2015, REPLACE=2016,
+		DIALOG=2017, GET_METADATA=2018, FILE=2019, SELECTION_NAME=2020, GET_VERSION=2021, GET_RESULT_LABEL=2022,
+		CALL=2023, STRING=2024, EXT=2025, EXEC=2026, LIST=2027, DEBUG=2028, IJ_CALL=2029, GET_RESULT_STRING=2030,
+		GET_DIR=2031, TRIM=2032;
+	
+	static final String[] stringFunctions = {"d2s", "toHex", "toBinary", "getTitle", "getString", "substring",
+		"fromCharCode", "getInfo", "getDirectory", "getArgument", "getImageInfo", 
+		"toLowerCase", "toUpperCase", "runMacro", "eval", "toString", "replace",
+		"Dialog", "getMetadata", "File", "selectionName", "getVersion", "getResultLabel",
+		"call", "String", "Ext", "exec", "List", "debug", "IJ", "getResultString",
+		"getDir", "trim"};
+	static final int[] stringFunctionIDs = {D2S, TO_HEX, TO_BINARY, GET_TITLE, GET_STRING, SUBSTRING,
+		FROM_CHAR_CODE, GET_INFO, GET_DIRECTORY, GET_ARGUMENT, GET_IMAGE_INFO,
+		TO_LOWER_CASE, TO_UPPER_CASE, RUN_MACRO, EVAL, TO_STRING, REPLACE,
+		DIALOG, GET_METADATA, FILE, SELECTION_NAME, GET_VERSION, GET_RESULT_LABEL,
+		CALL, STRING, EXT, EXEC, LIST, DEBUG, IJ_CALL, GET_RESULT_STRING,
+		GET_DIR, TRIM};
+
+	// Array functions
+	static final int GET_PROFILE=3000, NEW_ARRAY=3001, SPLIT=3002, GET_FILE_LIST=3003,
+		GET_FONT_LIST=3004, NEW_MENU=3005, GET_LIST=3006, ARRAY_FUNC=3007;
+	static final String[] arrayFunctions = {"getProfile", "newArray", "split", "getFileList",
+		"getFontList", "newMenu", "getList", "Array"};
+	static final int[] arrayFunctionIDs = {GET_PROFILE, NEW_ARRAY, SPLIT, GET_FILE_LIST,
+		GET_FONT_LIST, NEW_MENU, GET_LIST, ARRAY_FUNC};
+
+	// functions that return a Variable
+	static final int TABLE=4000, ROI=4001, ROI_MANAGER2=4002, PROPERTY=4003, IMAGE=4004, COLOR=4005;
+	static final String[] variableFunctions = {"Table", "Roi", "RoiManager", "Property", "Image", "Color"};
+	static final int[] variableFunctionIDs = {TABLE, ROI, ROI_MANAGER2, PROPERTY, IMAGE, COLOR};
+
+}  // interface MacroConstants
diff --git a/src/ij/macro/MacroException.java b/src/ij/macro/MacroException.java
new file mode 100644
index 0000000..d44a4c9
--- /dev/null
+++ b/src/ij/macro/MacroException.java
@@ -0,0 +1,15 @@
+package ij.macro;
+
+/** This runtime exception is thrown by break and continue statements. */
+class MacroException extends RuntimeException {
+	private int type;
+	
+	MacroException(int type) {
+		this.type = type;
+	}
+	
+	int getType() {
+		return type;
+	}
+	
+}
diff --git a/src/ij/macro/MacroExtension.java b/src/ij/macro/MacroExtension.java
new file mode 100644
index 0000000..af8102b
--- /dev/null
+++ b/src/ij/macro/MacroExtension.java
@@ -0,0 +1,14 @@
+package ij.macro;
+
+public interface MacroExtension {
+  public static final int ARG_STRING = 0x01;
+  public static final int ARG_NUMBER = 0x02;
+  public static final int ARG_ARRAY  = 0x04;
+  
+  public static final int ARG_OUTPUT = 0x10;
+  public static final int ARG_OPTIONAL = 0x20;
+
+  public String handleExtension(String name, Object[] args);
+  
+  public ExtensionDescriptor[] getExtensionFunctions();
+}
diff --git a/src/ij/macro/MacroRunner.java b/src/ij/macro/MacroRunner.java
new file mode 100644
index 0000000..b562936
--- /dev/null
+++ b/src/ij/macro/MacroRunner.java
@@ -0,0 +1,174 @@
+package ij.macro;
+import ij.*;
+import ij.text.*;
+import ij.util.*;
+import ij.gui.ImageCanvas;
+import java.io.*;
+import java.awt.*;
+import ij.plugin.frame.Editor;
+																																																																																																																																																					   
+
+/** This class runs macros in a separate thread. */
+public class MacroRunner implements Runnable {
+
+	private String macro;
+	private Program pgm;
+	private int address;
+	private String name;
+	private Thread thread;
+	private String argument;
+	private Editor editor;
+
+	/** Create a MacroRunner. */
+	public MacroRunner() {
+	}
+
+	/** Create a new object that interprets macro source in a separate thread. */
+	public MacroRunner(String macro) {
+		this(macro, (Editor)null);
+	}
+
+	/** Create a new object that interprets macro source in debug mode if 'editor' is not null. */
+	public MacroRunner(String macro, Editor editor) {
+		this.macro = macro;
+		this.editor = editor;
+		thread = new Thread(this, "Macro$"); 
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	/** Interprets macro source in a separate thread, passing a string argument. */
+	public MacroRunner(String macro, String argument) {
+		this.macro = macro;
+		this.argument = argument;
+		thread = new Thread(this, "Macro$"); 
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	/** Interprets a macro file in a separate thread. */
+	public MacroRunner(File file) {
+		int size = (int)file.length();
+		if (size<=0)
+			return;
+		try {
+			StringBuffer sb = new StringBuffer(5000);
+			BufferedReader r = new BufferedReader(new FileReader(file));
+			while (true) {
+				String s=r.readLine();
+				if (s==null)
+					break;
+				else
+					sb.append(s+"\n");
+			}
+			r.close();
+			macro = new String(sb);
+		}
+		catch (Exception e) {
+			IJ.error(e.getMessage());
+			return;
+		}
+		thread = new Thread(this, "Macro$"); 
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	/** Runs a tokenized macro in a separate thread. */
+	public MacroRunner(Program pgm, int address, String name) {
+		this(pgm, address, name, (String)null);
+	}
+
+	/** Runs a tokenized macro in a separate thread,
+		passing a string argument. */
+	public MacroRunner(Program pgm, int address, String name, String argument) {
+		this.pgm = pgm;
+		this.address = address;
+		this.name = name;
+		this.argument = argument;
+		thread = new Thread(this, name+"_Macro$");
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	/** Runs a tokenized macro in debug mode if 'editor' is not null. */
+	public MacroRunner(Program pgm, int address, String name, Editor editor) {
+		this.pgm = pgm;
+		this.address = address;
+		this.name = name;
+		this.editor = editor;
+		thread = new Thread(this, name+"_Macro$");
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	/** Runs tokenized macro on current thread if pgm.queueCommands is true. */
+	public void runShortcut(Program pgm, int address, String name) {
+		this.pgm = pgm;
+		this.address = address;
+		this.name = name;
+		if (pgm.queueCommands)
+			run();
+		else {
+			thread = new Thread(this, name+"_Macro$");
+			thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+			thread.start();
+		}
+	}
+	
+	/** Runs a tokenized macro on the current thread. */
+	public void run(Program pgm, int address, String name) {
+		this.pgm = pgm;
+		this.address = address;
+		this.name = name;
+		this.argument = null;
+		run();
+	}
+
+	public Thread getThread() {
+		return thread;
+	}
+
+	/** Used to run the macro code in 'macro' on a separate thread. */
+	public void run() {
+		Interpreter interp = new Interpreter();
+		interp.argument = argument;
+		if (editor!=null)
+			interp.setDebugger(editor);
+		try {
+			if (pgm==null)
+				interp.run(macro);
+			else {
+				if ("Popup Menu".equals(name)) {
+					PopupMenu popup = Menus.getPopupMenu();
+					if (popup!=null) {
+						ImagePlus imp = null;
+						Object parent = popup.getParent();
+						if (parent instanceof ImageCanvas)
+							imp = ((ImageCanvas)parent).getImage();
+						if (imp!=null)
+							WindowManager.setTempCurrentImage(Thread.currentThread(), imp);
+					}
+				}
+				interp.runMacro(pgm, address, name);
+			}
+		} catch(Throwable e) {
+			interp.abortMacro();
+			IJ.showStatus("");
+			IJ.showProgress(1.0);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null)
+				imp.unlock();
+			String msg = e.getMessage();
+			if (e instanceof RuntimeException && msg!=null && e.getMessage().equals(Macro.MACRO_CANCELED)) {
+				interp.error(null);
+				return;
+			}
+			IJ.handleException(e);
+		} finally {
+			if (thread!=null)
+				WindowManager.setTempCurrentImage(null);
+		}
+	}
+
+}
+
diff --git a/src/ij/macro/Program.java b/src/ij/macro/Program.java
new file mode 100644
index 0000000..fa46a64
--- /dev/null
+++ b/src/ij/macro/Program.java
@@ -0,0 +1,286 @@
+package ij.macro;
+import ij.*;
+import java.util.Hashtable;
+
+/** An object of this type is a tokenized macro file and the associated symbol table. */
+public class Program implements MacroConstants {
+
+	private int maxSymbols = 500;  // will be increased as needed
+	private int maxProgramSize = 650;  // well be increased as needed
+	private int pc = -1;
+	
+	int stLoc = -1;
+	int symTabLoc;
+	Symbol[] table = new Symbol[maxSymbols];
+    static Symbol[] systemTable;
+	int[] code = new int[maxProgramSize];
+	int[] lineNumbers = new int[maxProgramSize];
+	Variable[] globals;
+	boolean hasVars, hasFunctions;
+	int macroCount;
+    Hashtable menus;
+    // run keyboard shortcut macros on event dispatch thread?
+	boolean queueCommands; 
+	Hashtable extensionRegistry;
+			
+	public Program() {
+		if (systemTable!=null) {
+			if (systemTable.length>table.length)
+				enlargeSymbolTable();
+			stLoc = systemTable.length - 1;
+			for (int i=0; i<=stLoc; i++)
+				table[i] = systemTable[i];
+		} else {
+			addKeywords();
+			addFunctions();
+			addNumericFunctions();
+			addStringFunctions();
+			addArrayFunctions();
+			addVariableFunctions();
+			systemTable = new Symbol[stLoc+1];
+			for (int i=0; i<=stLoc; i++)
+				systemTable[i] = table[i];
+		}
+		if (IJ.debugMode) IJ.log("Symbol table: "+(stLoc+1)+"  "+table.length+"  "+systemTable.length);
+	}
+	
+	public int[] getCode() {
+		return code;
+	}
+	
+	public Symbol[] getSymbolTable() {
+		return table;
+	}
+	
+	void addKeywords() {
+		for (int i=0; i<keywords.length; i++)
+			addSymbol(new Symbol(keywordIDs[i], keywords[i]));
+	}
+
+	void addFunctions() {
+		for (int i=0; i<functions.length; i++)
+			addSymbol(new Symbol(functionIDs[i], functions[i]));
+	}
+
+	void addNumericFunctions() {
+		for (int i=0; i<numericFunctions.length; i++)
+			addSymbol(new Symbol(numericFunctionIDs[i], numericFunctions[i]));
+	}
+	
+	void addStringFunctions() {
+		for (int i=0; i<stringFunctions.length; i++)
+			addSymbol(new Symbol(stringFunctionIDs[i], stringFunctions[i]));
+	}
+
+	void addArrayFunctions() {
+		for (int i=0; i<arrayFunctions.length; i++)
+			addSymbol(new Symbol(arrayFunctionIDs[i], arrayFunctions[i]));
+	}
+
+	void addVariableFunctions() {
+		for (int i=0; i<variableFunctions.length; i++)
+			addSymbol(new Symbol(variableFunctionIDs[i], variableFunctions[i]));
+	}
+
+	void addSymbol(Symbol sym) {
+		stLoc++;
+		if (stLoc==table.length)
+			enlargeSymbolTable();
+		table[stLoc] = sym;
+	}
+	
+	void enlargeSymbolTable() {
+		Symbol[] tmp = new Symbol[maxSymbols*2];
+		System.arraycopy(table, 0, tmp, 0, maxSymbols);
+		table = tmp;
+		maxSymbols *= 2;
+		if (IJ.debugMode) IJ.log("enlargeSymbolTable: "+table.length);
+	}
+	
+	void addToken(int tok, int lineNumber) {//n__
+		pc++;
+		if (pc==code.length) {
+			int[] tmp = new int[maxProgramSize*2];
+			System.arraycopy(code, 0, tmp, 0, maxProgramSize);
+			code = tmp;
+            tmp = new int[maxProgramSize*2];  //n__
+			System.arraycopy(lineNumbers, 0, tmp, 0, maxProgramSize);
+			lineNumbers = tmp;
+			maxProgramSize *= 2;
+        }
+		code[pc] = tok;
+        lineNumbers[pc] = lineNumber; //n__
+	}
+
+	/** Looks up a word in the symbol table. Returns null if the word is not found. */
+	Symbol lookupWord(String str) {
+		Symbol symbol;
+		String symStr;
+		for (int i=0; i<=stLoc; i++) {
+			symbol = table[i];
+			if (symbol.type!=STRING_CONSTANT && str.equals(symbol.str)) {
+				symTabLoc = i;
+				return symbol;
+			}
+		}
+		return null;
+	}
+
+	void saveGlobals(Interpreter interp) {
+		if (interp.topOfStack==-1)
+			return;
+		int n = interp.topOfStack+1;
+		globals = new Variable[n];
+		for (int i=0; i<n; i++)
+			globals[i] = interp.stack[i];
+	}
+	
+	public void dumpSymbolTable() {
+		IJ.log("");
+		IJ.log("Symbol Table");
+		for (int i=0; i<=maxSymbols; i++) {
+			Symbol symbol = table[i];
+			if (symbol==null)
+				break;
+			IJ.log(i+" "+symbol);
+		}
+	}
+
+	public void dumpProgram() {
+		IJ.log("");
+		IJ.log("Tokenized Program");
+		String str;
+		int token, address;
+		for (int i=0; i<=pc; i++) 
+			IJ.log(i+"	 "+lineNumbers[i]+"   "+(code[i]&TOK_MASK)+"   "+decodeToken(code[i]));
+	}
+	
+	public Variable[] getGlobals() {
+		return globals;
+	}
+
+	public boolean hasVars() {
+		return hasVars;
+	}
+
+	public int macroCount() {
+		return macroCount;
+	}
+
+	public String decodeToken(int token) {
+		return decodeToken(token&TOK_MASK, token>>TOK_SHIFT);
+	}
+
+	String decodeToken(int token, int address) {
+		String str;
+		switch (token) {
+			case WORD:
+			case PREDEFINED_FUNCTION:
+			case NUMERIC_FUNCTION:
+			case STRING_FUNCTION:
+			case ARRAY_FUNCTION:
+			case VARIABLE_FUNCTION:
+			case USER_FUNCTION:
+				str = table[address].str;
+				break;
+			case STRING_CONSTANT:
+				str = "\""+table[address].str+"\"";
+				break;
+			case NUMBER:
+				double v = table[address].value;
+				if ((int)v==v)
+					str = IJ.d2s(v,0);
+				else
+					str = ""+v;
+				break;
+			case EOF:
+				str = "EOF";
+				break;
+			default:
+				if (token<32) {
+					switch (token) {
+					case PLUS_PLUS:
+						str="++";
+						break;
+					case MINUS_MINUS:
+						str="--";
+						break;
+					case PLUS_EQUAL:
+						str="+=";
+						break;
+					case MINUS_EQUAL:
+						str="-=";
+						break;
+					case MUL_EQUAL:
+						str="*=";
+						break;
+					case DIV_EQUAL:
+						str="/=";
+						break;
+					case LOGICAL_AND:
+						str="&&";
+						break;
+					case LOGICAL_OR:
+						str="||";
+						break;
+					case EQ:
+						str="==";
+						break;
+					case NEQ:
+						str="!=";
+						break;
+					case GT:
+						str=">";
+						break;
+					case GTE:
+						str=">=";
+						break;
+					case LT:
+						str="<";
+						break;
+					case LTE:
+						str="<=";
+						break;
+					default:
+						str="";
+						break;
+					}
+				} else if (token>=200) {
+					str = table[address].str;
+				} else {
+					char s[] = new char[1];
+					s[0] = (char)token;
+					str = new String(s);
+				}
+				break;
+		}
+		return str;
+	}
+    
+    public Hashtable getMenus() {
+        return menus;
+    }
+
+	// Returns 'true' if this macro program contains the specified word. */
+	public boolean hasWord(String word) {
+		int token, tokenAddress;
+		for (int i=0; i<code.length; i++) {
+			token = code[i];
+			if (token<=127) continue;
+			if (token==EOF) return false;
+			tokenAddress = token>>TOK_SHIFT;
+			String str = table[tokenAddress].str;
+			if (str!=null && str.equals(word)) return true;
+		}
+		return false;
+	}
+		
+	public int getSize() {
+		return pc;
+	}
+	
+	public String toString() {
+		return "pgm[code="+(code!=null?""+code.length:"null") + " tab="+(table!=null?""+table.length:"null")+"]";
+	}
+	
+} // Program
diff --git a/src/ij/macro/ReturnException.java b/src/ij/macro/ReturnException.java
new file mode 100644
index 0000000..21d3f50
--- /dev/null
+++ b/src/ij/macro/ReturnException.java
@@ -0,0 +1,12 @@
+package ij.macro;
+
+/** This runtime exceptions is thrown when return is invoked in a user-defined function. */
+class ReturnException extends RuntimeException {
+	double value;
+	String str;
+	Variable[] array;
+	int arraySize;
+	
+	ReturnException() {
+	}
+}
diff --git a/src/ij/macro/StartupRunner.java b/src/ij/macro/StartupRunner.java
new file mode 100644
index 0000000..fa3cece
--- /dev/null
+++ b/src/ij/macro/StartupRunner.java
@@ -0,0 +1,32 @@
+package ij.macro;
+import ij.IJ;
+import ij.plugin.MacroInstaller;
+import ij.plugin.Startup;
+
+/** Runs the RunAtStartup (created by Edit/Options/Startup) and AutoRun (in StartupMacros) macros. */
+public class StartupRunner implements Runnable {
+
+	/** Runs the RunAtStartup and AutoRun macros, on the current thread
+		if 'batchMode' true, otherwise on a separate thread. */
+	public void run(boolean batchMode) {
+		if (IJ.debugMode) IJ.log("StartupRunner: "+batchMode);
+		if (batchMode)
+			run();
+		else {
+			Thread thread = new Thread(this, "StartupRunner");
+			thread.start();
+		}
+	}
+
+	public void run() {
+ 		String macro = (new Startup()).getStartupMacro();
+ 		if (macro!=null && macro.length()>4) {
+ 			if (macro.contains("setForegroundColor"))
+ 				IJ.wait(100);
+ 			IJ.runMacro(macro);
+ 		}
+		MacroInstaller.autoRun();
+ 	}
+ 	
+}
+
diff --git a/src/ij/macro/Symbol.java b/src/ij/macro/Symbol.java
new file mode 100644
index 0000000..2ad1a64
--- /dev/null
+++ b/src/ij/macro/Symbol.java
@@ -0,0 +1,37 @@
+package ij.macro;
+
+/** Objects of this class are used as entries in the macro language symbol table. */
+public class Symbol implements MacroConstants {
+    public int type;
+    public double value;
+    public String str;
+
+    Symbol(int token, String str) {
+        type = token&0xffff;
+        this.str = str;
+    }
+
+    Symbol(double value) {
+        this.value = value;
+    }
+
+    int getFunctionType() {
+        int t = 0;
+        if (type>=300 && type<1000)
+            t = PREDEFINED_FUNCTION;
+        else if (type>=1000 && type<2000)
+            t = NUMERIC_FUNCTION;
+        else if (type>=2000 && type<3000)
+            t = STRING_FUNCTION;
+        else if (type>=3000 && type<4000)
+            t = ARRAY_FUNCTION;
+        else if (type>=4000 && type<5000)
+            t =  VARIABLE_FUNCTION;
+        return t;
+    }
+
+    public String toString() {
+        return type+" "+value+" "+str;
+    }
+
+} // class Symbol
diff --git a/src/ij/macro/Tokenizer.java b/src/ij/macro/Tokenizer.java
new file mode 100644
index 0000000..145f021
--- /dev/null
+++ b/src/ij/macro/Tokenizer.java
@@ -0,0 +1,293 @@
+package ij.macro;
+import ij.*;
+import java.io.*;
+
+/** This class converts an imageJ macro file file into a token stream. */
+public class Tokenizer implements MacroConstants {
+
+    private StreamTokenizer st;
+    private int token;
+    private String tokenString;
+    private double tokenValue;
+    private Program pgm;
+    private int lineNumber;
+
+    /** Uses a StreamTokenizer to convert an ImageJ macro file into a token stream. */
+    public Program tokenize(String program) {
+        if (program.contains("/*") && program.contains("*/"))
+            program = addSpacesToEmptyLines(program);
+        st = new StreamTokenizer(new StringReader(program));
+        st.ordinaryChar('-');
+        st.ordinaryChar('/');
+        st.ordinaryChar('.');
+        st.wordChars('_', '_');
+        st.whitespaceChars(128, 255);
+        st.slashStarComments(true);
+        st.slashSlashComments(true);
+        pgm = new Program();
+        do {
+            getToken();
+            addToken();
+        } while (token!=EOF);
+        if (pgm.hasFunctions)
+        	addUserFunctions();
+		//IJ.log(program.length()+" "+pgm.getSize()+" "+IJ.d2s((double)program.length()/pgm.getSize(),1)+" "+program.length()/10);
+        return pgm;
+    }
+
+    final void getToken() {
+        try {
+            token = st.nextToken();
+            lineNumber = st.lineno();
+            String ret = null;
+            int nextToken;
+            switch (st.ttype) {
+				case StreamTokenizer.TT_EOF:
+					ret = "EOF";
+					token = EOF;
+					break;
+				case StreamTokenizer.TT_WORD:
+					ret = st.sval;
+					token = WORD;
+					break;
+				case StreamTokenizer.TT_NUMBER:
+					ret = ""+st.nval;
+					tokenValue = st.nval;
+					if (tokenValue==0.0)
+						tokenValue = getHexConstant();
+					else if (tryScientificNotation())
+						ret += st.sval;
+					token = NUMBER;
+					break;
+				case '"': case '\'':
+					ret = ""+st.sval;
+					token = STRING_CONSTANT;
+					break;
+				case '+':
+					nextToken = st.nextToken();
+					if (nextToken=='+')
+						token = PLUS_PLUS;
+					else if (nextToken=='=')
+						token = PLUS_EQUAL;
+					else
+						st.pushBack();
+					break;
+				case '-':
+					nextToken = st.nextToken();
+					if (nextToken=='-')
+						token = MINUS_MINUS;
+					else if (nextToken=='=')
+						token = MINUS_EQUAL;
+					else
+						st.pushBack();
+					break;
+				case '*':
+					nextToken = st.nextToken();
+					if (nextToken=='=')
+						token = MUL_EQUAL;
+					else
+						st.pushBack();
+					break;
+				case '/':
+					nextToken = st.nextToken();
+					if (nextToken=='=')
+						token = DIV_EQUAL;
+					else
+						st.pushBack();
+					break;
+				case '=':
+					nextToken = st.nextToken();
+					if (nextToken=='=')
+						token = EQ;
+					else
+						st.pushBack();
+					break;
+				case '!':
+					nextToken = st.nextToken();
+					if (nextToken=='=')
+						token = NEQ;
+					else
+						st.pushBack();
+					break;
+				case '>':
+					nextToken = st.nextToken();
+					if (nextToken=='=')
+						token = GTE;
+					else if (nextToken=='>')
+						token = SHIFT_RIGHT;
+					else {
+						st.pushBack();
+						token = GT;
+					}
+					break;
+				case '<':
+					nextToken = st.nextToken();
+					if (nextToken=='=')
+						token = LTE;
+					else if (nextToken=='<')
+						token = SHIFT_LEFT;
+					else {
+						st.pushBack();
+						token = LT;
+					}
+					break;
+				case '&':
+					nextToken = st.nextToken();
+					if (nextToken=='&')
+						token = LOGICAL_AND;
+					else
+						st.pushBack();
+					break;
+				case '|':
+					nextToken = st.nextToken();
+					if (nextToken=='|')
+						token = LOGICAL_OR;
+					else
+						st.pushBack();
+					break;
+				default:
+            }
+            tokenString = ret;
+        } catch (Exception e) {
+            return;
+        }
+    }
+
+    final void addToken() {
+        	int tok = token;
+        	switch (token) {
+        		case WORD:
+				Symbol symbol = pgm.lookupWord(tokenString);
+				if (symbol!=null) {
+					int type = symbol.getFunctionType();
+					if (type==0) {
+						tok = symbol.type;
+						switch (tok) {
+							case FUNCTION: pgm.hasFunctions=true; break;
+							case VAR: pgm.hasVars=true; break;
+							case MACRO: pgm.macroCount++; break;
+						}
+					} else
+						tok = type;
+					tok += pgm.symTabLoc<<TOK_SHIFT;
+				} else {
+					pgm.addSymbol(new Symbol(token, tokenString));
+					tok += pgm.stLoc<<TOK_SHIFT;
+				}
+				break;
+			case STRING_CONSTANT:
+				pgm.addSymbol(new Symbol(token, tokenString));
+				tok += pgm.stLoc<<TOK_SHIFT;
+				break;
+			case NUMBER:
+				pgm.addSymbol(new Symbol(tokenValue));
+				tok += pgm.stLoc<<TOK_SHIFT;
+				break;
+			default:
+				break;
+        }
+        pgm.addToken(tok, lineNumber);
+    }
+
+    double getHexConstant() {
+        try {
+            token = st.nextToken();
+        } catch (Exception e) {
+            return 0.0;
+        }
+        if (st.ttype != StreamTokenizer.TT_WORD) {
+            st.pushBack();
+            return 0.0;
+        }
+        if (!st.sval.startsWith("x")) {
+            st.pushBack();
+            return 0.0;
+        }
+        String s = st.sval.substring(1, st.sval.length());
+        double n = 0.0;
+        try {
+            n = Long.parseLong(s, 16);
+        } catch (NumberFormatException e) {
+            st.pushBack();
+            n = 0.0;
+        }
+        return n;
+    }
+
+	boolean tryScientificNotation() {
+		String sval = "" + tokenValue;
+		try {
+			int next = st.nextToken();
+			String sval2 = st.sval;
+			if (st.ttype == st.TT_WORD && (sval2.startsWith("e")||sval2.startsWith("E"))) {
+				// Usually we would just append the sval, but "-" is special...
+				if (sval2.equalsIgnoreCase("e")) {
+					//if (st.nextToken() != st.TT_WORD || !st.sval.equals("-"))
+					next = st.nextToken();
+					if (next == '-')
+						sval2 += "-";
+					else if (next != '+')
+						throw new Exception();
+					if (st.nextToken() != st.TT_NUMBER)
+						throw new Exception();
+					sval2 += st.nval;
+				}
+				if (sval2.endsWith(".0"))
+					sval2 = sval2.substring(0, sval2.length() - 2);
+				tokenValue = Double.parseDouble(sval + sval2);
+				return true;
+			}
+			st.pushBack();
+		} catch(Exception e) {}
+		return false;
+    }
+
+	/** Adds user-defined functions to the symbol table. */
+	void addUserFunctions() {
+		int[] code = pgm.getCode();
+		int nextToken, address, address2;
+		for (int i=0; i<code.length; i++) {
+			token = code[i]&TOK_MASK;
+			if (token==FUNCTION) {
+				nextToken = code[i+1]&TOK_MASK;
+				if (nextToken==WORD || (nextToken>=PREDEFINED_FUNCTION&&nextToken<=ARRAY_FUNCTION)) {
+					address = address2 = code[i+1]>>TOK_SHIFT;
+					if (nextToken!=WORD) { // override built in function
+                		pgm.addSymbol(new Symbol(WORD, pgm.getSymbolTable()[address].str));
+                		address2 = pgm.stLoc;
+                		code[i+1] = WORD + (address2<<TOK_SHIFT);
+					}
+					Symbol sym = pgm.getSymbolTable()[address2];
+					sym.type = USER_FUNCTION;
+					sym.value = i+1;  //address of function
+					for (int j=0; j<code.length; j++) {
+						token = code[j]&TOK_MASK;
+						if ((token==WORD || (token>=PREDEFINED_FUNCTION&&token<=ARRAY_FUNCTION))
+						&& (code[j]>>TOK_SHIFT)==address && (j==0||(code[j-1]&0xfff)!=FUNCTION)) {
+							code[j] = USER_FUNCTION;
+							code[j] += address2<<TOK_SHIFT;
+							//IJ.log((code[j]&TOK_MASK)+" "+(code[j]>>TOK_SHIFT)+" "+USER_FUNCTION+" "+address);
+						} else if (token==EOF)
+							break;
+					}
+					//IJ.log(i+"  "+pgm.decodeToken(nextToken, address));
+				}					
+			} else if (token==EOF)
+				break;
+		}
+	}
+	
+	private String addSpacesToEmptyLines(String pgm) {
+		StringBuilder sb = new StringBuilder();
+		int len = pgm.length();
+		for (int jj=0; jj<len-1; jj++) {//insert a space if line is empty
+			char c = pgm.charAt(jj);
+			sb.append(c);
+			if (jj<len-1 && c=='\n' && pgm.charAt(jj+1)=='\n')
+				sb.append(" ");
+		}
+		sb.append(pgm.charAt(len-1)); //add last char
+		return sb.toString(); //program no longer contain empty lines
+	}
+
+}
diff --git a/src/ij/macro/Variable.java b/src/ij/macro/Variable.java
new file mode 100644
index 0000000..2881f56
--- /dev/null
+++ b/src/ij/macro/Variable.java
@@ -0,0 +1,147 @@
+package ij.macro;
+
+public class Variable implements MacroConstants, Cloneable {
+	static final int VALUE=0, ARRAY=1, STRING=2;
+    int symTabIndex;
+    private double value;
+    private String str;
+    private Variable[] array;
+    private int arraySize;
+
+    public Variable() {
+    }
+
+    public Variable(double value) {
+        this.value = value;
+    }
+
+    public Variable(String str) {
+        this.str = str;
+    }
+    
+    public Variable(Variable[] array) {
+    	this.array = array;
+    }
+
+    Variable(int symTabIndex, double value, String str) {
+        this.symTabIndex = symTabIndex;
+        this.value = value;
+        this.str = str;
+    }
+
+    Variable(int symTabIndex, double value, String str, Variable[] array) {
+        this.symTabIndex = symTabIndex;
+        this.value = value;
+        this.str = str;
+        this.array = array;
+    }
+
+    Variable(byte[] array) {
+    	this.array = new Variable[array.length];
+    	for (int i=0; i<array.length; i++)
+    		this.array[i] = new Variable(array[i]&255);
+    }
+
+    Variable(int[] array) {
+    	this.array = new Variable[array.length];
+    	for (int i=0; i<array.length; i++)
+    		this.array[i] = new Variable(array[i]);
+    }
+
+    Variable(double[] array) {
+    	this.array = new Variable[array.length];
+    	for (int i=0; i<array.length; i++)
+    		this.array[i] = new Variable(array[i]);
+    }
+
+    public double getValue() {
+    	if (str!=null)
+    			return convertToDouble();  // string to number conversions
+    	else
+        	return value;
+    }
+
+	double convertToDouble() {
+		try {
+			Double d = new Double(str);
+			return d.doubleValue();
+		} catch (NumberFormatException e){
+			return Double.NaN;
+		}
+	}
+
+    void setValue(double value) {
+        this.value = value;
+        str = null;
+        array = null;
+    }
+
+    public String getString() {
+        return str;
+    }
+
+    void setString(String str) {
+        this.str = str;
+        value = 0.0;
+        array = null;
+    }
+
+    Variable[] getArray() {
+        return array;
+    }
+
+    void setArray(Variable[] array) {
+        this.array = array;
+        value = 0.0;
+        str = null;
+        arraySize = 0;
+    }
+    
+    void setArraySize(int size) {
+    	if (array==null)
+    		size = 0;
+    	else if (size>array.length)
+    		size = array.length;
+    	arraySize = size;
+    }
+    
+    int getArraySize() {
+    	int size = array!=null?array.length:0;
+    	if (arraySize>0) size = arraySize;
+    	return size;
+    }
+
+    int getType() {
+    	if (array!=null)
+    		return ARRAY;
+    	else if (str!=null)
+    		return STRING;
+    	else
+    		return VALUE;
+    }
+
+	public String toString() {
+		String s = "";
+		if (array!=null)
+			s += "array["+array.length+"]";
+		else if (str!=null) {
+			s = str;
+			if (s.length()>80)
+				s = s.substring(0, 80)+"...";
+			s = s.replaceAll("\n", " | ");
+			s = "\""+s+"\"";
+		} else {
+			if (value==(int)value)
+				s += (int)value;
+			else
+				s += ij.IJ.d2s(value,4);
+		}
+		return s;
+	}
+    
+	public synchronized Object clone() {
+		try {return super.clone();}
+		catch (CloneNotSupportedException e) {return null;}
+	}
+
+} // class Variable
diff --git a/src/ij/measure/Calibration.java b/src/ij/measure/Calibration.java
new file mode 100644
index 0000000..123fcea
--- /dev/null
+++ b/src/ij/measure/Calibration.java
@@ -0,0 +1,530 @@
+package ij.measure;
+import ij.*;
+import ij.plugin.filter.Analyzer;
+
+/** Calibration objects contain an image's spatial and density calibration data. */
+   
+public class Calibration implements Cloneable {
+
+	public static final int STRAIGHT_LINE=0,POLY2=1,POLY3=2,POLY4=3,
+		EXPONENTIAL=4,POWER=5,LOG=6,RODBARD=7,GAMMA_VARIATE=8, LOG2=9, RODBARD2=10,
+		EXP_WITH_OFFSET=11, GAUSSIAN=12, EXP_RECOVERY=13;
+	public static final int NONE=20, UNCALIBRATED_OD=21, CUSTOM=22;
+	public static final String DEFAULT_VALUE_UNIT = "Gray Value";
+	private static final int UNKNOWN = 0;
+
+	/** Pixel width in 'unit's */
+	public double pixelWidth = 1.0;
+	
+	/** Pixel height in 'unit's */
+	public double pixelHeight = 1.0;
+	
+	/** Pixel depth in 'unit's */
+	public double pixelDepth = 1.0;
+	
+	/** Frame interval in 'timeUnit's */
+	public double frameInterval;
+
+	/** Frame rate in frames per second */
+	public double fps;
+
+	/** Loop back and forth when animating stack */
+	private static boolean loopBackAndForth;
+	public boolean loop = loopBackAndForth;
+
+	/** X origin in pixels. */
+	public double xOrigin;
+
+	/** Y origin in pixels. */
+	public double yOrigin;
+
+	/** Z origin in pixels. */
+	public double zOrigin;
+
+	/** Plugin writers can use this string to store information about the
+		image. This string is saved in the TIFF header if it is not longer
+		than 64 characters and it contains no '=' or '\n' characters. */
+	public String info;
+
+	/** Calibration function coefficients */
+	private double[] coefficients;
+		
+	/* Default distance unit (e.g. 'cm', 'inch') */
+	private String unit = "pixel";
+	
+	/* Y distance unit */
+	private String yunit;
+
+	/* Z distance unit */
+	private String zunit;
+
+	/* Pixel value unit (e.g. 'gray level', 'OD') */
+	private String valueUnit = DEFAULT_VALUE_UNIT;
+
+	/* Unit of time (e.g. 'sec', 'msec') */
+	private String timeUnit = "sec";
+
+	/* Calibration function ID */
+	private int function = NONE;
+
+	/* Calibration table */
+	private float[] cTable;
+	
+	private boolean invertedLut;
+	private int bitDepth = UNKNOWN;
+	private boolean zeroClip;
+	private boolean invertY;
+
+	/** Constructs a new Calibration object using the default values. */ 
+	public Calibration(ImagePlus imp) {
+		if (imp!=null) {
+			bitDepth = imp.getBitDepth();
+			if (bitDepth!=UNKNOWN)
+				invertedLut=imp.isInvertedLut();
+		}
+	}
+	
+	/** Constructs a new Calibration object using the default values.
+		For density calibration, the image is assumed to be 8-bits. */ 
+	public Calibration() {
+	}
+	
+	/** Returns true if this image is spatially calibrated. */
+	public boolean scaled() {
+		return pixelWidth!=1.0 || pixelHeight!=1.0 || pixelDepth!=1.0 || !unit.equals("pixel");
+	}
+	
+	/** Sets the default length unit (e.g. "mm", "inch"). */
+	public void setUnit(String unit) {
+		this.unit = sanitizeUnit(unit);
+	}
+ 	
+   	/** Sets the X length unit. */
+ 	public void setXUnit(String unit) {
+		setUnit(unit);
+	}
+
+   	/** Sets the Y length unit. */
+ 	public void setYUnit(String unit) {
+ 		if (unit==null || unit.equals(""))
+ 			yunit = null;
+ 		else
+			yunit = sanitizeUnit(unit);
+	}
+
+   	/** Sets the Z length unit. */
+ 	public void setZUnit(String unit) {
+ 		if (unit==null || unit.equals(""))
+ 			zunit = null;
+ 		else
+			zunit = sanitizeUnit(unit );
+	}
+
+	private static String sanitizeUnit(String unit) {
+		if (unit==null || unit.equals(""))
+			return "pixel";
+		else if (unit.equals("um"))
+			unit = "\u00B5m";
+        else if (unit.equals("A"))
+            unit = ""+IJ.angstromSymbol;
+        return unit;
+	}
+
+ 	/** Returns the default length unit (e.g. "micron", "inch"). */
+ 	public String getUnit() {
+ 		return unit;
+ 	}
+ 	
+ 	/** Returns the X length unit. */
+ 	public String getXUnit() {
+ 		return unit;
+ 	}
+
+ 	/** Returns the Y length unit, or the default unit if 'yunit' is null. */
+ 	public String getYUnit() {
+ 		return yunit!=null?yunit:unit;
+ 	}
+
+ 	/** Returns the Z length unit, or the default unit if 'zunit' is null. */
+ 	public String getZUnit() {
+ 		return zunit!=null?zunit:unit;
+ 	}
+
+	/** Returns the plural form of the unit passed as argument (e.g. "micron" gives "microns", "inch" gives "inches"). */
+	private static String pluralForm(String unit) {
+		String units;
+		if (unit.equals("pixel"))
+			units = "pixels";
+		else if (unit.equals("micron"))
+			units = "microns";
+		else if (unit.equals("inch"))
+			units = "inches";
+		else
+			units = unit;
+	   return units;
+	}
+
+	/** Returns the plural form of the length unit (e.g. "microns", "inches"). */
+ 	public String getUnits() {
+		return pluralForm(getUnit());
+ 	}
+
+	/** Returns the plural form of the X length unit (e.g. "microns", "inches"), or of the default unit if 'xunit' is null. */
+	public String getXUnits() {
+		return pluralForm(getXUnit());
+	}
+
+	/** Returns the plural form of the Y length unit (e.g. "microns", "inches"), or of the default unit if 'yunit' is null. */
+	public String getYUnits() {
+		return pluralForm(getYUnit());
+	}
+
+	/** Returns the plural form of the Z length unit (e.g. "microns", "inches"), or of the default unit if 'zunit' is null. */
+	public String getZUnits() {
+		return pluralForm(getZUnit());
+	}
+
+   	/** Sets the time unit (e.g. "sec", "msec"). */
+ 	public void setTimeUnit(String unit) {
+ 		if (unit==null || unit.equals(""))
+ 			timeUnit = "sec";
+ 		else
+ 			timeUnit = unit;
+ 	}
+
+ 	/** Returns the distance unit (e.g. "sec", "msec"). */
+ 	public String getTimeUnit() {
+ 		return timeUnit;
+ 	}
+
+ 	/** Converts a x-coodinate in pixels to physical units (e.g. mm). */
+ 	public double getX(double x) {
+ 		return (x-xOrigin)*pixelWidth;
+ 	}
+ 	
+  	/** Converts a y-coordinate in pixels to physical units (e.g. mm). */
+ 	public double getY(double y) {
+ 		return (y-yOrigin)*pixelHeight;
+ 	}
+ 	
+ 	/** Converts a y-coordinate in pixels to physical units (e.g. mm),
+ 		taking into account the invertY and global "Invert Y Coordinates" flags. */
+ 	public double getY(double y, int imageHeight) {
+ 		if (invertY || (Analyzer.getMeasurements()&Measurements.INVERT_Y)!=0) {
+			if (yOrigin!=0.0)
+				return (yOrigin-y)*pixelHeight;
+			else
+				return (imageHeight-y-1)*pixelHeight;
+		} else
+   			return (y-yOrigin)*pixelHeight;
+	}
+
+  	/** Converts a z-coordinate in pixels to physical units (e.g. mm). */
+ 	public double getZ(double z) {
+ 		return (z-zOrigin)*pixelDepth;
+ 	}
+ 	
+ 	/** Converts a x-coordinate in physical units to pixels. */
+ 	public double getRawX(double x) {
+ 		return x/pixelWidth + xOrigin;
+ 	}
+ 	
+   	/** Converts a y-coodinate in physical units to pixels. */
+ 	public double getRawY(double y) {
+  		return y/pixelHeight + yOrigin;
+	}
+ 	
+   	/** Converts a z-coodinate in physical units to pixels. */
+ 	public double getRawZ(double z) {
+  		return z/pixelDepth + zOrigin;
+	}
+
+ 	/** Converts a y-coodinate in physical units to pixels,
+ 		taking into account the 'invertY' flag. */
+ 	public double getRawY(double y, int imageHeight) {
+ 		if (invertY || (Analyzer.getMeasurements()&Measurements.INVERT_Y)!=0) {
+			if (yOrigin!=0.0)
+				return yOrigin-y/pixelHeight;
+			else
+				return imageHeight -y/pixelHeight - 1;
+		} else
+   			return y/pixelHeight + yOrigin;
+	}
+
+	//public double getX(int x) {return getX((double)x);}
+ 	//public double getY(int y) {return getY((double)y);}
+ 	//public double getZ(int z) {return getZ((double)z);}
+ 	
+  	/** Sets the calibration function,  coefficient table and unit (e.g. "OD"). */
+ 	public void setFunction(int function, double[] coefficients, String unit) {
+ 		setFunction(function, coefficients, unit, false);
+ 	}
+ 	
+ 	public void setFunction(int function, double[] coefficients, String unit, boolean zeroClip) {
+ 		if (function==NONE)
+ 			{disableDensityCalibration(); return;}
+ 		if (coefficients==null && function>=STRAIGHT_LINE && function<=EXP_RECOVERY)
+ 			return;
+ 		this.function = function;
+ 		this.coefficients = coefficients;
+ 		this.zeroClip = zeroClip;
+ 		if (unit!=null)
+ 			valueUnit = unit;
+ 		cTable = null;
+ 	}
+
+ 	/** Disables the density calibation if the specified image has a differenent bit depth. */
+ 	public void setImage(ImagePlus imp) {
+ 		if (imp==null)
+ 			return;
+ 		int type = imp.getType();
+		int newBitDepth = imp.getBitDepth();
+ 		if (newBitDepth==16 && imp.getLocalCalibration().isSigned16Bit()) {
+			double[] coeff = new double[2]; coeff[0] = -32768.0; coeff[1] = 1.0;
+ 			setFunction(Calibration.STRAIGHT_LINE, coeff, DEFAULT_VALUE_UNIT);
+		} else if ((newBitDepth!=bitDepth&&bitDepth!=UNKNOWN) || type==ImagePlus.GRAY32 || type==ImagePlus.COLOR_RGB) {
+			String saveUnit = valueUnit;
+			disableDensityCalibration();
+			if (type==ImagePlus.GRAY32) valueUnit = saveUnit;
+		}
+ 		bitDepth = newBitDepth;
+ 	}
+ 	
+ 	public void disableDensityCalibration() {
+		function = NONE;
+		coefficients = null;
+		cTable = null;
+		valueUnit = DEFAULT_VALUE_UNIT;
+ 	}
+ 	
+	/** Returns the value unit. */
+ 	public String getValueUnit() {
+ 		return valueUnit;
+ 	}
+ 	
+	/** Sets the value unit. */
+ 	public void setValueUnit(String unit) {
+ 		if (unit!=null)
+ 			valueUnit = unit;
+ 	}
+
+ 	/** Returns the calibration function coefficients. */
+ 	public double[] getCoefficients() {
+ 		return coefficients;
+ 	}
+
+ 	/** Returns true if this image is density calibrated. */
+	public boolean calibrated() {
+		return function!=NONE;
+	}
+	
+	/** Returns the calibration function ID. */
+ 	public int getFunction() {
+ 		return function;
+ 	}
+ 	
+	/** Returns the calibration table. With 8-bit images,
+		the table has a length of 256. With 16-bit images,
+		the length is 65536. */
+ 	public float[] getCTable() {
+ 		if (cTable==null)
+ 			makeCTable();
+ 		return cTable;
+ 	}
+ 	
+	/** Sets the calibration table. With 8-bit images, the table must 
+		have a length of 256. With 16-bit images, it must be 65536. */
+ 	public void setCTable(float[] table, String unit) {
+ 		if (table==null) {
+ 			disableDensityCalibration();
+ 			return;
+ 		}
+ 		if (bitDepth==UNKNOWN) {
+ 			if (table.length==256)
+ 				bitDepth = 8;
+ 			else if (table.length==65536)
+ 				bitDepth = 16;
+ 		}
+ 		if (bitDepth==16 && table.length!=65536)
+ 			throw new IllegalArgumentException("Table.length!=65536");
+ 		cTable = table;
+ 		function = CUSTOM;
+ 		coefficients = null;
+ 		zeroClip = false;
+ 		if (unit!=null) valueUnit = unit;
+ 	}
+
+ 	void makeCTable() {
+ 		if (bitDepth==16)
+ 			{make16BitCTable(); return;}
+ 		if (bitDepth==UNKNOWN)
+ 			bitDepth = 8;
+ 		if (bitDepth!=8)
+ 			return;
+ 		if (function==UNCALIBRATED_OD) {
+ 			cTable = new float[256];
+			for (int i=0; i<256; i++)
+				cTable[i] = (float)od(i);
+		} else if (function>=STRAIGHT_LINE && function<=EXP_RECOVERY && coefficients!=null) {
+ 			cTable = new float[256];
+ 			double value;
+ 			for (int i=0; i<256; i++) {
+				value = CurveFitter.f(function, coefficients, i);
+				if (zeroClip && value<0.0)
+					cTable[i] = 0f;
+				else
+					cTable[i] = (float)value;
+			}
+		} else
+ 			cTable = null;
+  	}
+
+ 	void make16BitCTable() {
+		if (function>=STRAIGHT_LINE && function<=EXP_RECOVERY && coefficients!=null) {
+ 			cTable = new float[65536];
+ 			for (int i=0; i<65536; i++)
+				cTable[i] = (float)CurveFitter.f(function, coefficients, i);
+		} else
+ 			cTable = null;
+  	}
+
+	double od(double v) {
+		if (invertedLut) {
+			if (v==255.0) v = 254.5;
+			return 0.434294481*Math.log(255.0/(255.0-v));
+		} else {
+			if (v==0.0) v = 0.5;
+			return 0.434294481*Math.log(255.0/v);
+		}
+	}
+	
+  	/** Converts a raw pixel value to a density calibrated value. */
+ 	public double getCValue(int value) {
+		if (function==NONE)
+			return value;
+		if (function>=STRAIGHT_LINE && function<=EXP_RECOVERY && coefficients!=null) {
+			double v = CurveFitter.f(function, coefficients, value);
+			if (zeroClip && v<0.0)
+				return 0.0;
+			else
+				return v;
+		}
+		if (cTable==null)
+			makeCTable();
+ 		if (cTable!=null && value>=0 && value<cTable.length)
+ 			return cTable[value];
+ 		else
+ 			return value;
+ 	}
+ 	 	
+  	/** Converts a raw pixel value to a density calibrated value. */
+ 	public double getCValue(double value) {
+		if (function==NONE)
+			return value;
+		else {
+			if (function>=STRAIGHT_LINE && function<=EXP_RECOVERY && coefficients!=null) {
+				double 	v = CurveFitter.f(function, coefficients, value);
+				if (zeroClip && v<0.0)
+					return 0.0;
+				else
+					return v;
+			} else
+				return getCValue((int)value);
+		}
+ 	}
+ 	
+  	/** Converts a density calibrated value into a raw pixel value. */
+ 	public double getRawValue(double value) {
+		if (function==NONE)
+			return value;
+		if (function==STRAIGHT_LINE && coefficients!=null && coefficients.length==2 && coefficients[1]!=0.0)
+			return (value-coefficients[0])/coefficients[1];
+		if (cTable==null)
+			makeCTable();
+		float fvalue = (float)value;
+		float smallestDiff = Float.MAX_VALUE;
+		float diff;
+		int index = 0;
+		for (int i=0; i<cTable.length; i++) {
+			diff = fvalue - cTable[i];
+			if (diff<0f) diff = -diff;
+			if (diff<smallestDiff) {
+				smallestDiff = diff;
+				index = i;
+			}
+		}
+ 		return index;
+ 	}
+ 	 	
+	/** Returns a clone of this object. */
+	public Calibration copy() {
+		return (Calibration)clone();
+	}
+	
+	public synchronized Object clone() {
+		try {return super.clone();}
+		catch (CloneNotSupportedException e) {return null;}
+	}
+
+	/** Compares two Calibration objects for equality. */
+ 	public boolean equals(Calibration cal) {
+ 		if (cal==null)
+ 			return false;
+ 		boolean equal = true;
+ 		if (cal.pixelWidth!=pixelWidth || cal.pixelHeight!=pixelHeight || cal.pixelDepth!=pixelDepth)
+ 			equal = false;
+ 		if (!cal.unit.equals(unit))
+ 			equal = false;
+ 		if (!cal.valueUnit.equals(valueUnit) || cal.function!=function)
+ 			equal = false;
+ 		return equal;
+ 	}
+ 	
+  	/** Returns true if this is a signed 16-bit image. */
+ 	public boolean isSigned16Bit() {
+		return (bitDepth==16 && function>=STRAIGHT_LINE && function<=EXP_RECOVERY && coefficients!=null
+			&& coefficients[0]==-32768.0 && coefficients[1]==1.0);
+ 	}
+ 	
+ 	/** Sets up a calibration function that subtracts 32,768 from pixel values. */
+ 	public void setSigned16BitCalibration() {
+		double[] coeff = new double[2];
+		coeff[0] = -32768.0;
+		coeff[1] = 1.0;
+		setFunction(STRAIGHT_LINE, coeff, "Gray Value");
+ 	}
+
+ 	/** Returns true if zero clipping is enabled. */
+ 	public boolean zeroClip() {
+ 		return zeroClip;
+ 	}
+ 	
+ 	/** Sets the 'invertY' flag. */
+ 	public void setInvertY(boolean invertYCoordinates) {
+ 		invertY = invertYCoordinates;
+ 	}
+ 	
+ 	/** Returns the 'invertY' flag. */
+ 	public boolean getInvertY() {
+ 		return invertY;
+ 	}
+
+ 	/** Set the default state of the animation "Loop back and forth" flag */
+	public static void setLoopBackAndForth(boolean loop) {
+ 		loopBackAndForth = loop;
+ 	}
+ 	
+    public String toString() {
+    	return
+    		"w=" + pixelWidth
+			+ ", h=" + pixelHeight
+			+ ", d=" + pixelDepth
+			+ ", unit=" + unit
+			+ ", f=" + function
+ 			+ ", nc=" + (coefficients!=null?""+coefficients.length:"null")
+ 			+ ", table=" + (cTable!=null?""+cTable.length:"null")
+			+ ", vunit=" + valueUnit
+			+ ", bd=" + bitDepth;
+   }
+}
+
diff --git a/src/ij/measure/CurveFitter.java b/src/ij/measure/CurveFitter.java
new file mode 100644
index 0000000..4f8d252
--- /dev/null
+++ b/src/ij/measure/CurveFitter.java
@@ -0,0 +1,1462 @@
+package ij.measure;
+import ij.*;
+import ij.gui.*;
+import ij.macro.*;
+import ij.util.Tools;
+import ij.util.IJMath;
+import java.util.Arrays;
+import java.util.Hashtable;
+import java.awt.Color;
+
+/** Curve fitting class based on the Simplex method in the Minimizer class
+ *
+ *
+ *	Notes on fitting polynomial functions:
+ *	(i) The range of x values should not be too far from 0, especially for higher-order polynomials.
+ *	For polynomials of 4th order, the average x value should fulfill |xMean| < 2*(xMax-xMin).
+ *	For polynomials of 5th order or higher, the x range should encompass x=0; and for
+ *	7th and 8th order it is desirable to have x=0 near the center of the x range.
+ *	(ii) In contrast to some fitting algorithms using the normal equations and matrix inversion, the
+ *	simplex algorithm used here can cope with parameters having very different orders of magnitude,
+ *	as long as the coefficients of the polynomial are within a reasonable range (say, 1e-80 to 1e80).
+ *	Thus, it is usually not needed to scale the x values, even for high-order polynomials.
+ *
+ *	Version history:
+ *
+ *	2008-01-21: Modified to do Gaussian fitting by Stefan Woerz (s.woerz at dkfz.de).
+ *	2012-01-30: Modified for external Minimizer class and UserFunction fit by Michael Schmid.
+ *			  - Also fixed incorrect equation string for 'Gamma Variate' & 'Rodbard (NIH Image)',
+ *			  - Added 'Inverse Rodbard', 'Exponential (linear regression)', 'Power (linear regression)'
+ *				functions and polynomials of order 5-8. Added 'nicely' sorted list of types.
+ *			  - Added absolute error for minimizer to avoid endless minimization if exact fit is possible.
+ *			  - Added 'initialParamVariations' (order of magnitude if parameter variations) -
+ *				this is important for safer and better convergence.
+ *			  - Linear regression for up to 2 linear parameters, reduces the number of parameters handled
+ *				by the simplex Minimizer and improves convergence.	These parameters can be an offset and
+ *				either a linear slope or a factor that the full function is multiplied with.
+ *	2012-10-07: added GAUSSIAN_NOOFFSET fit type
+ *	2012-11-20: Bugfix: exception on Gaussian&Rodbard with initial params, bad initial params for Gaussian
+ *  2013-09-24: Added "Exponential Recovery (no offset)" and "Chapman-Richards" (3-parameter;
+ *              used e.g. to describe forest growth) fit types.
+ *  2013-10-11: bugfixes, added setStatusAndEsc to show iterations and enable abort by ESC
+ *  2015-03-26: bugfix, did not use linear regression for RODBARD
+ *  2016-11-28: added static getNumParams methods
+ *  2018-03-23: fixes NullPointerException for custom fit without initialParamVariations
+ *  2018-07-19: added error function erf (=integral over Gaussian)
+ *  2021-04-30: data points can have weights
+ */
+
+public class CurveFitter implements UserFunction{
+	/** Constants for the built-in fit functions */
+	public static final int STRAIGHT_LINE=0, POLY2=1, POLY3=2, POLY4=3,
+	EXPONENTIAL=4, POWER=5, LOG=6, RODBARD=7, GAMMA_VARIATE=8, LOG2=9,
+	RODBARD2=10, EXP_WITH_OFFSET=11, GAUSSIAN=12, EXP_RECOVERY=13,
+	INV_RODBARD=14, EXP_REGRESSION=15, POWER_REGRESSION=16,
+	POLY5=17, POLY6=18, POLY7=19, POLY8=20,
+	GAUSSIAN_NOOFFSET=21, EXP_RECOVERY_NOOFFSET=22, CHAPMAN=23, ERF=24;
+
+	/** Nicer sequence of the built-in function types */
+	public static final int[] sortedTypes = { STRAIGHT_LINE, POLY2, POLY3, POLY4,
+			POLY5, POLY6, POLY7, POLY8,
+			POWER, POWER_REGRESSION,
+			EXPONENTIAL, EXP_REGRESSION, EXP_WITH_OFFSET,
+			EXP_RECOVERY, EXP_RECOVERY_NOOFFSET,
+			LOG, LOG2,
+			GAUSSIAN, GAUSSIAN_NOOFFSET, ERF,
+			RODBARD, RODBARD2, INV_RODBARD,
+			GAMMA_VARIATE,CHAPMAN
+	};
+
+	/** Names of the built-in fit functions */
+	public static final String[] fitList = {"Straight Line","2nd Degree Polynomial",
+	"3rd Degree Polynomial", "4th Degree Polynomial","Exponential","Power",
+	"Log","Rodbard", "Gamma Variate", "y = a+b*ln(x-c)","Rodbard (NIH Image)",
+	"Exponential with Offset","Gaussian", "Exponential Recovery",
+	"Inverse Rodbard", "Exponential (linear regression)", "Power (linear regression)",
+	"5th Degree Polynomial","6th Degree Polynomial","7th Degree Polynomial","8th Degree Polynomial",
+	"Gaussian (no offset)", "Exponential Recovery (no offset)",
+	"Chapman-Richards", "Error Function"
+	}; // fList, doFit(), getNumParams() and makeInitialParamsAndVariations() must also be updated
+
+	/** Equations of the built-in fit functions */
+	public static final String[] fList = {
+	"y = a+bx","y = a+bx+cx^2",									//STRAIGHT_LINE,POLY2
+	"y = a+bx+cx^2+dx^3","y = a+bx+cx^2+dx^3+ex^4",
+	"y = a*exp(bx)","y = a*x^b", "y = a*ln(bx)",				//EXPONENTIAL,POWER,LOG
+	"y = d+(a-d)/(1+(x/c)^b)", "y = b*(x-a)^c*exp(-(x-a)/d)",	//RODBARD,GAMMA_VARIATE
+	"y = a+b*ln(x-c)", "x = d+(a-d)/(1+(y/c)^b) [y = c*((x-a)/(d-x))^(1/b)]",  //LOG2,RODBARD2
+	"y = a*exp(-bx) + c", "y = a + (b-a)*exp(-(x-c)*(x-c)/(2*d*d))", //EXP_WITH_OFFSET,GAUSSIAN
+	"y = a*(1-exp(-b*x)) + c", "y = c*((x-a)/(d-x))^(1/b)",		//EXP_RECOVERY, INV_RODBARD
+	"y = a*exp(bx)", "y = a*x^b",								//EXP_REGRESSION, POWER_REGRESSION
+	"y = a+bx+cx^2+dx^3+ex^4+fx^5", "y = a+bx+cx^2+dx^3+ex^4+fx^5+gx^6",
+	"y = a+bx+cx^2+dx^3+ex^4+fx^5+gx^6+hx^7", "y = a+bx+cx^2+dx^3+ex^4+fx^5+gx^6+hx^7+ix^8",
+	"y = a*exp(-(x-b)*(x-b)/(2*c*c)))",						//GAUSSIAN_NOOFFSET
+	"y = a*(1-exp(-b*x))",										//EXP_RECOVERY_NOOFFSET
+	"y = a*(1-exp(-b*x))^c",									//CHAPMAN
+	"y = a+b*erf((x-c)/d)"										//ERF; note that the c parameter is sqrt2 times the Gaussian
+	};
+
+	/** ImageJ Macro language code for the built-in functions */
+	public static final String[] fMacro = {
+	"y = a+x*b","y = a+x*(b+x*c)",								//STRAIGHT_LINE,POLY2
+	"y = a+x*(b+x*(c+x*d))","y = a+x*(b+x*(c+x*(d+x*e)))",
+	"y = a*Math.exp(b*x)","y = a*Math.pow(x,b)", "y = a*Math.log(b*x)", //EXPONENTIAL,POWER,LOG
+	"y = d+(a-d)/(1+Math.pow(x/c,b))", "y = b*Math.pow(x-a,c)*Math.exp(-(x-a)/d)",	//RODBARD,GAMMA_VARIATE
+	"y = a+b*Math.log(x-c)", "y = c*Math.pow((x-a)/(d-x),1/b)",  	 //LOG2,RODBARD2
+	"y = a*Math.exp(-b*x)+c", "y = a+(b-a)*Math.exp(-(x-c)*(x-c)/(2*d*d))", //EXP_WITH_OFFSET,GAUSSIAN
+	"y = a*(1-Math.exp(-b*x))+c", "y = c*Math.pow((x-a)/(d-x),1/b)", //EXP_RECOVERY, INV_RODBARD
+	"y = a*Math.exp(b*x)", "y = a*Math.pow(x,b)",						//EXP_REGRESSION, POWER_REGRESSION
+	"y = a+x*(b+x*(c+x*(d+x*(e+x*f))))", "y = a+x*(b+x*(c+x*(d+x*(e+x*(f+x*g)))))",
+	"y = a+x*(b+x*(c+x*(d+x*(e+x*(f+x*(g+x*h))))))", "y = a+x*(b+x*(c+x*(d+x*(e+x*(f+x*(g+x*(h+x*i)))))))",
+	"y = a*Math.exp(-(x-b)*(x-b)/(2*c*c))",						//GAUSSIAN_NOOFFSET
+	"y = a*(1-Math.exp(-b*x))",									//EXP_RECOVERY_NOOFFSET
+	"y = a*Math.pow(1-Math.exp(-b*x),c)",						//CHAPMAN
+	"y = a+b*Math.erf((x-c)/d)"									//ERF; note that the c parameter is sqrt2 times the Gaussian sigma
+	};
+
+	/** @deprecated now in the Minimizer class (since ImageJ 1.46f).
+	 *	(probably of not much value for anyone anyhow?) */
+	public static final int IterFactor = 500;
+
+	private static final int CUSTOM = 100;	 // user function defined in macro or plugin
+	private static final int GAUSSIAN_INTERNAL = 101;	// Gaussian with separate offset & multiplier
+	private static final int RODBARD_INTERNAL = 102;	// Rodbard with separate offset & multiplier
+
+	private int fitType = -1;		// Number of curve type to fit
+	private double[] xData, yData;	// x,y data to fit
+	private double[] weights;		// weights for the data to fit
+	private double[] xDataSave, yDataSave;	//saved original data after fitting modified data
+	private int numPoints;			// number of data points in actual fit
+	private double ySign = 0;		// remember sign of y data for power-law fit via regression
+	private double sumY = Double.NaN, sumY2 = Double.NaN;  // sum(y*w), sum(y^2*w) of the data used for fitting (w=weight, default 1)
+	private double sumWeights = Double.NaN;  //sum of weights (or numPoints, if no weigths are given)
+	private int numParams;			// number of parameters
+	private double[] initialParams; // user specified or estimated initial parameters
+	private double[] initialParamVariations; // estimate of range of parameters
+	private double[] minimizerInitialParams;		  // modified initialParams of the minimizer
+	private double[] minimizerInitialParamVariations; // modified initialParamVariations of the minimizer
+	private double maxRelError = 1e-10;// maximum relative deviation of sum of residuals^2 from minimum
+	private long time;				// elapsed time in ms
+	private int customParamCount;	// number of parameters of user-supplied function (macro or plugin)
+	private String customFormula;	// equation defined in macro or text
+	private UserFunction userFunction; // plugin with custom fit function
+	private Interpreter macro;		// holds macro with custom equation
+	private int macroStartProgramCounter;	 // equation in macro starts here
+	private int numRegressionParams;// number of parameters that can be calculated by linear regression
+	private int offsetParam = -1;   // parameter number: function has this parameter as offset
+	private int factorParam = -1;   // index of parameter that is slope or multiplicative factor of the function
+	private boolean hasSlopeParam;	// whether the 'factorParam' is the slope of the function
+	private double[] finalParams;	// parameters obtained by fit
+	private boolean linearRegressionUsed;	// whether linear regression alone was used instead of the minimizer
+	private boolean restrictPower;	// power via linear regression fit: (0,0) requires positive power
+	private Minimizer minimizer = new Minimizer();
+	private int minimizerStatus = Minimizer.INITIALIZATION_FAILURE; // status of the minimizer after minimizing
+	private String errorString;		// in case of error before invoking the minimizer
+	private static String[] sortedFitList; // names like fitList, but in more logical sequence
+	private static Hashtable<String, Integer> namesTable; // converts fitList String into number
+
+	/** Construct a new CurveFitter. */
+	public CurveFitter (double[] xData, double[] yData) {
+		int cleanPoints = 0;
+		for (int jj=0; jj<xData.length; jj++) {
+			if (!Double.isNaN(xData[jj] + yData[jj]))
+				cleanPoints++;
+		}
+		if (cleanPoints==xData.length) {
+			this.xData = xData;
+			this.yData = yData;
+		} else { //remove pairs containing a NaN
+			double[] cleanX = new double[cleanPoints];
+			double[] cleanY = new double[cleanPoints];
+			int ptr = 0;
+			for (int jj=0; jj<xData.length; jj++) {
+				if (!Double.isNaN(xData[jj] + yData[jj])) {
+					cleanX[ptr] = xData[jj];
+					cleanY[ptr] = yData[jj];
+					ptr++;
+				}
+			}
+			this.xData = cleanX;
+			this.yData = cleanY;
+		}
+		numPoints = this.xData.length;
+	}
+
+	/** Perform curve fitting with one of the built-in functions
+	 *			doFit(fitType) does the fit quietly
+	 *	Use getStatus() and/or getStatusString() to see whether fitting was (probably) successful and
+	 *	getParams() to access the result.
+	 */
+	public void doFit(int fitType) {
+		doFit(fitType, false);
+	}
+
+	/** Perform curve fitting with one of the built-in functions
+	 *			doFit(fitType, true) pops up a dialog allowing the user to set the initial
+	 *						fit parameters and various numbers controlling the Minimizer
+	 *	Use getStatus() and/or getStatusString() to see whether fitting was (probably) successful and
+	 *	getParams() to access the result.
+	 */
+	public void doFit(int fitType, boolean showSettings) {
+		if (!(fitType>=STRAIGHT_LINE && fitType<fitList.length || fitType==CUSTOM))
+			throw new IllegalArgumentException("Invalid fit type");
+		if (fitType==CUSTOM && macro==null && userFunction==null)
+			throw new IllegalArgumentException("No custom formula!");
+		this.fitType = fitType;
+		if (isModifiedFitType(fitType))			// these fits don't use the original data and a different fit type (this.fitType)
+			if (!prepareModifiedFitType(fitType)) return;
+		numParams = getNumParams();
+		if (fitType != CUSTOM)
+			getOffsetAndFactorParams();
+		//IJ.log("special params: off="+offsetParam+(hasSlopeParam ? " slo=" : " fac=")+factorParam+" numPar="+numParams+" numRegressPar="+numRegressionParams);
+		calculateSumYandY2();					// sumY, sumY2 needed for regression, abs Error; R, goodness of modified fit functions
+		long startTime = System.currentTimeMillis();
+		if (this.fitType == STRAIGHT_LINE) {	// no minimizer needed
+			finalParams = new double[] {0, 0, 0}; // (does not work with 0 initial slope)
+			doRegression(finalParams);			// fit by regression; save sum(Residuals^2) as last array element
+			linearRegressionUsed = true;
+		} else {								// use simplex minimizer
+			minimizer.setFunction(this, numParams-numRegressionParams);
+			minimizer.setExtraArrayElements(numRegressionParams);  // reserve space for extra parameters if minimizer has fewer paramters
+			if (macro != null) minimizer.setMaximumThreads(1);	// macro interpreter does not allow multithreading
+			if (!makeInitialParamsAndVariations(fitType))		// also includes some data checking
+				return;							// initialization failure
+			if (showSettings) settingsDialog();
+			if (numRegressionParams >0)
+				modifyInitialParamsAndVariations();
+			else {
+				minimizerInitialParams = initialParams;
+				minimizerInitialParamVariations = initialParamVariations;
+			}
+			startTime = System.currentTimeMillis();
+			// The maximum absolute error of the fit must be specified in case the
+			// fit function fits perfectly, i.e. the sume of residuals approaches 0.
+			// In such a case, the maximum relative error is meaningless and the
+			// minimizer would run until it reaches the maximum iteration count.
+			double maxAbsError = Math.min(1e-6,maxRelError)*Math.sqrt(sumY2);
+			minimizer.setMaxError(maxRelError, maxAbsError);
+			//{String s="initVariations:";for(int ii=0;ii<numParams;ii++)s+=" ["+ii+"]:"+IJ.d2s(initialParamVariations[ii],5,9);IJ.log(s);}
+			//{String s="minInitVariations:";for(int ii=0;ii<numParams;ii++)s+=" ["+ii+"]:"+IJ.d2s(minimizerInitialParamVariations[ii],5,9);IJ.log(s);}
+			//{String s="minInitPars:";for(int ii=0;ii<numParams;ii++)s+=" ["+ii+"]:"+IJ.d2s(minimizerInitialParams[ii],5,9);IJ.log(s);}
+			// m i n i m i z a t i o n	of squared residuals
+			minimizerStatus = minimizer.minimize(minimizerInitialParams, minimizerInitialParamVariations);
+			finalParams = minimizer.getParams();
+			if (numRegressionParams > 0)
+				minimizerParamsToFullParams(finalParams, false);
+		}
+		if (isModifiedFitType(fitType))         //params of actual fit to user params
+			postProcessModifiedFitType(fitType);
+		if (fitType == ERF)                     //make it nicer
+			if (finalParams[3] < 0) {           // y = a+b*erf((x-c)/d) with negative d: invert b instead
+				finalParams[1] = -finalParams[1];
+				finalParams[3] = -finalParams[3];
+			}
+
+		switch (fitType) {		                //postprocessing for nicer output:
+		    case GAUSSIAN:                      //Gaussians: width (std deviation) should be >0
+                finalParams[3] = Math.abs(finalParams[3]); break;
+            case GAUSSIAN_NOOFFSET:
+                finalParams[2] = Math.abs(finalParams[2]); break;
+		}
+		time = System.currentTimeMillis()-startTime;
+	}
+
+	/** Fit a function defined as a macro String like "y = a + b*x + c*x*x".
+	 *  When showSettings is true, pops up a dialog allowing the user to set the initial
+	 *						fit parameters and various numbers controlling the Minimizer
+	 *	Returns the number of parameters, or 0 in case of a macro syntax error.
+	 *
+	 *	Use getStatus() and/or getStatusString() to see whether fitting was (probably) successful and
+	 *	getParams() to access the result.
+	 *
+	 *	For complicated fits and good performance, it is advisable to use the doCustomFit method with
+	 *  a (java) UserFunction, which also has more options.
+	 *
+	 */
+	public int doCustomFit(String equation, double[] initialParams, boolean showSettings) {
+		customFormula = null;
+		customParamCount = getNumParams(equation);
+		if (customParamCount==0)
+			return 0;
+		customFormula = equation;
+		String code =
+			"var x, a, b, c, d, e, f;\n"+
+			"function dummy() {}\n"+
+			equation+";\n"; // starts at program counter location 21
+		macroStartProgramCounter = 21;
+		macro = new Interpreter();
+		try {
+			macro.run(code, null);
+		} catch (Exception e) {
+			if (!Macro.MACRO_CANCELED.equals(e.getMessage()))
+				IJ.handleException(e);
+		}
+		if (macro.wasError())
+			return 0;
+		this.initialParams = initialParams;
+		doFit(CUSTOM, showSettings);
+		return customParamCount;
+	}
+
+	/** Fit a function defined in a user plugin implementing the UserFunction interface
+	 *
+	 *	Use getStatus() and/or getStatusString() to see whether fitting was (probably) successful and
+	 *	getParams() to access the result.
+	 *
+	 *  For getter performance, if possible it is advisable to first call setOffsetMultiplySlopeParams,
+	 *  to avoid searching for one or two parameters that can be calculated directly by linear regression.
+	 *
+	 *	@param userFunction     A class instance implementing the userFunction interface. There, the
+	 *                          fit function hould be defined by the method userFunction(params, x).
+	 *                          This function must allow simultaneous calls in multiple threads.
+	 *	@param numParams		Number of parameters of the fit function.
+	 *	@param formula			A String describing the fit formula, may be null.
+	 *	@param initialParams	Starting point for the parameters;  the fit function with these parameters
+	 *                          must not return NaN for any of the data points given in the constructor (xData).
+	 *                          initialParams may be null, then random values are used,
+	 *                          with repeated tries if the userFunction returns NaN.
+	 *	@param initialParamVariations Each parameter is initially varied by up to +/- this value.
+	 *                          If not given (null), initial variations are taken as
+	 *                          10% of initial parameter value or 0.01 for parameters that are zero.
+	 *                          When this array is given, all elements must be positive (nonzero).
+	 *                          See Minimizer.minimize for details. Providing this array is
+	 *                          especially valuable if one or more initial parameters have a value of 0.
+	 *	@param showSettings     Displays a popup dialog for modifying the initial parameters and
+	 *                          a few numbers controlling the minimizer.
+	 */
+	public void doCustomFit(UserFunction userFunction, int numParams, String formula,
+		double[] initialParams, double[] initialParamVariations, boolean showSettings) {
+		this.userFunction = userFunction;
+		this.customParamCount = numParams;
+		this.initialParams = initialParams;
+		this.initialParamVariations = initialParamVariations;
+		customFormula = formula==null ? "(defined in plugin)" : formula;
+		doFit(CUSTOM, showSettings);
+	}
+
+	/** Sets the initial parameters, which override the default initial parameters. */
+	public void setInitialParameters(double[] initialParams) {
+		this.initialParams = initialParams;
+	}
+
+	/** Sets weights of the data points. The 'weights' array must have the same length as the data arrays
+	 *  passed with the constructor. If the error bars of the data points are known, the weights
+	 *  should be proportional to 1/error^2.
+	 *  When weights are specified, note that 'getSumResidualsSqr' will return the weighted sum. */
+	public void setWeights(double[] weights) {
+		this.weights = weights;
+	}
+
+	/** Returns a reference to the Minimizer used, for accessing Minimizer methods directly.
+	 *	Note that no Minimizer is used if fitType is any of STRAIGHT_LINE, EXP_REGRESSION,
+	 *	and POWER_REGRESSION. */
+	public Minimizer getMinimizer() {
+		return minimizer;
+	}
+
+	/** For improved fitting performance when using a custom fit formula, one may
+	 *	specify parameters that can be calculated directly by linear regression.
+	 *	For values not used, set the index to -1
+	 *
+	 * @param offsetParam  Index of a parameter that is a pure offset:
+	 *					   E.g. '0' if	f(p0, p1, p2...) = p0 + function(p1, p2, ...).
+	 * @param multiplyParam	 Index of a parameter that is purely multiplicative.
+	 *					   E.g. multiplyParams=1 if f(p0, p1, p2, p3...) can be expressed as
+	 *					   p1*func(p0, p2, p3, ...) or p0 +p1*func(p0, p2, p3, ...) with '0' being
+	 *					   the offsetparam.
+	 * @param slopeParam   Index of a parameter that is multiplied with x and then summed to the function.
+	 *					   E.g. '1' for f(p0, p1, p2, p3...) = p1*x + func(p0, p2, p3, ...)
+	 *					   Only one, multiplyParam and slopeParam can be used (ie.e, the other
+	 *					   should be set to -1)
+	 */
+	public void setOffsetMultiplySlopeParams(int offsetParam, int multiplyParam, int slopeParam) {
+		if (multiplyParam >= 0 && slopeParam>=0)
+			throw new IllegalArgumentException("CurveFitter: only one of multiplyParam and slopeParam may be given (i.e., >=0)");
+		this.offsetParam = offsetParam;
+		hasSlopeParam = slopeParam >= 0;
+		factorParam = hasSlopeParam ? slopeParam : multiplyParam;
+		numRegressionParams = 0;
+		if (factorParam >= 0 && factorParam==offsetParam)
+			throw new IllegalArgumentException("CurveFitter: offsetParam and slopeParam/factorParam must be different");
+		if (offsetParam >=0) numRegressionParams++;
+		if (factorParam >=0) numRegressionParams++;
+	}
+
+	/** Get number of parameters for current fit formula
+	 *	Do not use before 'doFit', because the fit function would be undefined.	 */
+	public int getNumParams() {
+		if (fitType == CUSTOM)
+			return customParamCount;
+		else
+			return getNumParams(fitType);
+	}
+
+	/** Returns the number of parameters for a given fit type, except for the 'custom' fit,
+	 *  where the number of parameters is given by the equation: see getNumParams(String) */
+	public static int getNumParams(int fitType) {
+		switch (fitType) {
+			case STRAIGHT_LINE: return 2;
+			case POLY2: return 3;
+			case POLY3: return 4;
+			case POLY4: return 5;
+			case POLY5: return 6;
+			case POLY6: return 7;
+			case POLY7: return 8;
+			case POLY8: return 9;
+			case EXPONENTIAL: case EXP_REGRESSION: return 2;
+			case POWER: case POWER_REGRESSION:	   return 2;
+			case EXP_RECOVERY_NOOFFSET: return 2;
+			case LOG:	return 2;
+			case LOG2:	return 3;
+			case GAUSSIAN_NOOFFSET: return 3;
+			case EXP_RECOVERY: return 3;
+			case CHAPMAN: return 3;
+			case EXP_WITH_OFFSET: return 3;
+			case RODBARD: case RODBARD2: case INV_RODBARD: case RODBARD_INTERNAL: return 4;
+			case GAMMA_VARIATE: return 4;
+			case GAUSSIAN: case GAUSSIAN_INTERNAL: return 4;
+			case ERF:   return 4;
+		}
+		return 0;
+	}
+
+	/** Returns the number of parameters for a custom equation given as a macro String,
+	 *  like "y = a + b*x + c*x*x" .  Restricted to 6 parameters "a" ... "f"
+	 *  (fitting more parameters is not likely to yield an accurate result anyhow).
+	 *  Returns 0 if a very basic check does not find a formula of this type. */
+	public static int getNumParams(String customFormula) {
+		Program pgm = (new Tokenizer()).tokenize(customFormula);
+		if (!pgm.hasWord("y") ||  !pgm.hasWord("x"))
+		    return 0;
+		String[] params = {"a","b","c","d","e","f"};
+		int customParamCount = 0;
+		for (int i=0; i<params.length; i++) {
+			if (pgm.hasWord(params[i])) {
+				customParamCount++;
+			}
+		}
+		return customParamCount;
+	}
+
+	/** Returns the formula value for parameters 'p' at 'x'.
+	 *	Do not use before 'doFit', because the fit function would be undefined. */
+	public final double f(double x) {
+		if (finalParams==null)
+			finalParams = minimizer.getParams();
+		return f(finalParams, x);
+	}
+
+	/** Returns the formula value for parameters 'p' at 'x'.
+	 *	Do not use before 'doFit', because the fit function would be undefined.	 */
+	public final double f(double[] p, double x) {
+		if (fitType!=CUSTOM)
+			return f(fitType, p, x);
+		else {
+			if (macro==null) {	// function defined in plugin
+				return userFunction.userFunction(p, x);
+			} else {				// function defined in macro
+				macro.setVariable("x", x);
+				macro.setVariable("a", p[0]);
+				if (customParamCount>1) macro.setVariable("b", p[1]);
+				if (customParamCount>2) macro.setVariable("c", p[2]);
+				if (customParamCount>3) macro.setVariable("d", p[3]);
+				if (customParamCount>4) macro.setVariable("e", p[4]);
+				if (customParamCount>5) macro.setVariable("f", p[5]);
+				macro.run(macroStartProgramCounter);
+				return macro.getVariable("y");
+			}
+		}
+	}
+
+	/** Returns value of built-in 'fitType' formula value for parameters "p" at "x" */
+	public static double f(int fitType, double[] p, double x) {
+		switch (fitType) {
+			case STRAIGHT_LINE:
+				return p[0] + x*p[1];
+			case POLY2:
+				return p[0] + x*(p[1] + x*p[2]);
+			case POLY3:
+				return p[0] + x*(p[1] + x*(p[2] + x*p[3]));
+			case POLY4:
+				return p[0] + x*(p[1] + x*(p[2] + x*(p[3] + x*p[4])));
+			case POLY5:
+				return p[0] + x*(p[1] + x*(p[2] + x*(p[3] + x*(p[4] + x*p[5]))));
+			case POLY6:
+				return p[0] + x*(p[1] + x*(p[2] + x*(p[3] + x*(p[4] + x*(p[5] + x*p[6])))));
+			case POLY7:
+				return p[0] + x*(p[1] + x*(p[2] + x*(p[3] + x*(p[4] + x*(p[5] + x*(p[6] + x*p[7]))))));
+			case POLY8:
+				return p[0] + x*(p[1] + x*(p[2] + x*(p[3] + x*(p[4] + x*(p[5] + x*(p[6] + x*(p[7]+x*p[8])))))));
+			case EXPONENTIAL:
+			case EXP_REGRESSION:
+				return p[0]*Math.exp(p[1]*x);
+			case EXP_WITH_OFFSET:
+				return p[0]*Math.exp(-p[1]*x)+p[2];
+			case EXP_RECOVERY:
+				return p[0]*(1-Math.exp(-p[1]*x))+p[2];
+			case EXP_RECOVERY_NOOFFSET:
+			    return p[0]*(1-Math.exp(-p[1]*x));
+			case CHAPMAN:                               // a*(1-exp(-b*x))^c
+				double value =  p[0]*(Math.pow((1-(Math.exp(-p[1]*x))), p[2]));
+			//	Log.e("test", "values = " + value);
+				return value;
+			case GAUSSIAN:
+				return p[0]+(p[1]-p[0])*Math.exp(-(x-p[2])*(x-p[2])/(2.0*p[3]*p[3]));
+			case GAUSSIAN_INTERNAL:						// replaces GAUSSIAN for the fitting process
+				return p[0]+p[1]*Math.exp(-(x-p[2])*(x-p[2])/(2.0*p[3]*p[3]));
+			case GAUSSIAN_NOOFFSET:
+				return p[0]*Math.exp(-(x-p[1])*(x-p[1])/(2.0*p[2]*p[2]));
+			case POWER:									// ax^b
+			case POWER_REGRESSION:
+				return p[0]*Math.pow(x,p[1]);
+			case LOG:
+				if (x == 0.0)
+					return -1000*p[0];
+				return p[0]*Math.log(p[1]*x);
+			case RODBARD: {								// d+(a-d)/(1+(x/c)^b)
+				double ex = Math.pow(x/p[2], p[1]); //(x/c)^b
+				return p[3]+(p[0]-p[3])/(1.0+ex); }
+			case RODBARD_INTERNAL: {					// d+a/(1+(x/c)^b) , replaces RODBARD of the fitting process
+				double ex = Math.pow(x/p[2], p[1]); //(x/c)^b
+				return p[3]+p[0]/(1.0+ex); }
+			case GAMMA_VARIATE:							// b*(x-a)^c*exp(-(x-a)/d)
+				if (p[0] >= x) return 0.0;
+				if (p[1] <= 0) return Double.NaN;
+				if (p[2] <= 0) return Double.NaN;
+				if (p[3] <= 0) return Double.NaN;
+
+				double pw = Math.pow((x - p[0]), p[2]);
+				double e = Math.exp((-(x - p[0]))/p[3]);
+				return p[1]*pw*e;
+			case LOG2:
+				double tmp = x-p[2];
+				if (tmp<=0)
+					return Double.NaN;
+				return p[0]+p[1]*Math.log(tmp);
+			case INV_RODBARD:		// c*((x-a)/(d-x))^(1/b), the inverse Rodbard function
+			case RODBARD2:			// also used after the 'Rodbard NIH Image' fit
+				double y;
+				if (p[3]-x < 2*Double.MIN_VALUE || x<p[0]) // avoid x>=d (singularity) and x<a (negative exponent)
+					y = fitType==INV_RODBARD ? Double.NaN : 0.0;
+				else {
+					y = (x-p[0])/(p[3]-x);		//(x-a)/(d-x) = ( (a-d)/(x-d) -1 )
+					y = Math.pow(y,1.0/p[1]);	//y=y**(1/b)
+					y = y*p[2];
+				}
+				return y;
+            case ERF:
+				return p[0] + p[1]*IJMath.erf((x-p[2])/p[3]);	//y=a+b*erf((x-c)/d)
+			default:
+				return 0.0;
+		}
+	}
+
+	/** Get the result of fitting, i.e. the set of parameter values for the best fit.
+	 *	Note that the array returned may have more elements than numParams; ignore the rest.
+	 *	May return an array with only NaN values if the minimizer could not start properly,
+	 *	i.e., if getStatus() returns Minimizer.INITILIZATION_FAILURE.
+	 *	See Minimizer.getParams() for details.
+	 */
+	public double[] getParams() {
+		return finalParams==null ? minimizer.getParams() : finalParams; //if we have no result, take all_NaN result from the Minimizer
+	}
+
+	/** Returns residuals array, i.e., differences between data and curve.
+	 *	The residuals are with respect to the real data, also for fit types where the data are
+	 *	modified before fitting (power&exp fit by linear regression, 'Rodbard NIH Image' ).
+	 *	This is in contrast to sum of squared residuals, which is for the fit that was actually done.
+	 */
+	public double[] getResiduals() {
+		double[] params = getParams();
+		double[] residuals = new double[xData.length];
+		for (int i=0; i<xData.length; i++)
+			residuals[i] = yData[i] - f(params, xData[i]);
+		return residuals;
+	}
+
+	/** Returns the sum of the residuals (may be NaN if the minimizer could not start properly
+	 *	i.e., if getStatus() returns Minimizer.INITILIZATION_FAILURE).
+	 *  If weights have been specified, each of the residuals is multiplied by the corresponding
+	 *  weight before summing.
+	 */
+	public double getSumResidualsSqr() {
+		return getParams()[numParams];	// value is stored as last element by the minimizer
+	}
+
+	/** Returns the standard deviation of the residuals.
+	 *	Here, the standard deviation is defined here as the root-mean-square of the residuals
+	 *	times sqrt(n/(n-1)); where n is the number of points.
+	 *  If weights are provided, the standard deviation does not take the weights into account.
+	 *  With weights, the standard deviation and getSumResidualsSqr (which uses weights)
+	 *  are not related the usual way.
+	 */
+	public double getSD() {
+		double[] residuals = getResiduals();
+		int n = residuals.length;
+		double sum=0.0, sum2=0.0;
+		for (int i=0; i<n; i++) {
+			sum += residuals[i];
+			sum2 += residuals[i]*residuals[i];
+		}
+		double stdDev = (sum2-sum*sum/n); //sum of squared residuals
+		return Math.sqrt(stdDev/(n-1.0));
+	}
+
+	/** Returns R^2, where 1.0 is best. For unweighted data,
+	<pre>
+	 r^2 = 1 - SSE/SSD
+
+	 where:  SSE = sum of the squared errors
+	         SSD = sum of the squared deviations about the mean.
+	</pre>
+	 *	For power, exp by linear regression and 'Rodbard NIH Image', this is calculated for the
+	 *	fit actually done, not for the residuals of the original data.
+	 */
+	public double getRSquared() {
+		if (Double.isNaN(sumY)) calculateSumYandY2();
+		double sumMeanDiffSqr = sumY2 - sumY*sumY/sumWeights;
+		double rSquared = 0.0;
+		if (sumMeanDiffSqr > 0.0)
+			rSquared = 1.0 - getSumResidualsSqr()/sumMeanDiffSqr;
+		return rSquared;
+	}
+
+	/** Get a measure of "goodness of fit" where 1.0 is best.
+	 *	Approaches R^2 if the number of points is much larger than the number of fit parameters.
+	 *  Assumes that the data points are independent (i.e., each point having a different x value).
+	 *	For power, exp by linear regression and 'Rodbard NIH Image', this is calculated for the
+	 *	fit actually done, not for the residuals of the original data.
+	 */
+	public double getFitGoodness() {
+		if (Double.isNaN(sumY)) calculateSumYandY2();
+		double sumMeanDiffSqr = sumY2 - sumY*sumY/sumWeights;
+		double fitGoodness = 0.0;
+		int degreesOfFreedom = numPoints - getNumParams();
+		if (sumMeanDiffSqr > 0.0 && degreesOfFreedom > 0)
+			fitGoodness = 1.0 - (getSumResidualsSqr()/ sumMeanDiffSqr) * numPoints / (double)degreesOfFreedom;
+
+		return fitGoodness;
+	}
+
+	public int getStatus() {
+		return linearRegressionUsed ? Minimizer.SUCCESS : minimizerStatus;
+	}
+
+	/** Get a short text with a short description of the status. Should be preferred over
+	 *	Minimizer.STATUS_STRING[getMinimizer().getStatus()] because getStatusString()
+	 *	better explains the problem in some cases of initialization failure (data not
+	 *	compatible with the fit function chosen) */
+	public String getStatusString() {
+		return errorString != null ? errorString : minimizer.STATUS_STRING[getStatus()];
+	}
+
+	/** Get a string with detailed description of the curve fitting results (several lines,
+	 *	including the fit parameters).
+	 */
+	public String getResultString() {
+		String resultS =  "\nFormula: " + getFormula()
+				+ "\nMacro code: "+getMacroCode()
+				+ "\nStatus: "+getStatusString();
+		if (getStatus()==Minimizer.INITIALIZATION_FAILURE)
+			return resultS;
+		if (!linearRegressionUsed) resultS += "\nNumber of completed minimizations: " + minimizer.getCompletedMinimizations();
+		resultS += "\nNumber of iterations: " + getIterations();
+		if (!linearRegressionUsed) resultS += " (max: " + minimizer.getMaxIterations() + ")";
+		resultS += "\nTime: "+time+" ms" +
+				"\nSum of residuals squared: " + IJ.d2s(getSumResidualsSqr(),5,9) +
+				"\nStandard deviation: " + IJ.d2s(getSD(),5,9) +
+				"\nR^2: " + IJ.d2s(getRSquared(),5) +
+				"\nParameters:";
+		char pChar = 'a';
+		double[] pVal = getParams();
+		for (int i = 0; i < numParams; i++) {
+			resultS += "\n	" + pChar + " = " + IJ.d2s(pVal[i],5,9);
+			pChar++;
+		}
+		return resultS;
+	}
+
+	/** Set maximum number of simplex restarts to do. See Minimizer.setMaxRestarts for details. */
+	public void setRestarts(int maxRestarts) {
+		minimizer.setMaxRestarts(maxRestarts);
+	}
+
+	/** Set the maximum error. by which the sum of residuals may deviate from the true value
+	 *	(relative w.r.t. full sum of rediduals). Possible range: 0.1 ... 10^-16 */
+	public void setMaxError(double maxRelError) {
+		if (Double.isNaN(maxRelError)) return;
+		if (maxRelError > 0.1)	 maxRelError = 0.1;
+		if (maxRelError < 1e-16) maxRelError = 1e-16;	// can't be less than numerical accuracy
+		this.maxRelError = maxRelError;
+	}
+
+    /** Create output on the number of iterations in the ImageJ Status line, e.g.
+     *  "<ijStatusString> 50 (max 750); ESC to stop"
+     *  @param ijStatusString Displayed in the beginning of the status message. No display if null.
+     *  E.g. "Curve Fit: Iteration "
+     *  @param checkEscape When true, the Minimizer stops if escape is pressed and the status
+     *  becomes ABORTED. Note that checking for ESC does not work in the Event Queue thread. */
+    public void setStatusAndEsc(String ijStatusString, boolean checkEscape) {
+        minimizer.setStatusAndEsc(ijStatusString, checkEscape);
+    }
+
+	/** Get number of iterations performed. Returns 1 in case the fit was done by linear regression only. */
+	public int getIterations() {
+		return linearRegressionUsed ? 1 : minimizer.getIterations();
+	}
+
+	/** Get maximum number of iterations allowed (sum of iteration count for all restarts) */
+	public int getMaxIterations() {
+		return minimizer.getMaxIterations();
+	}
+
+	/** Set maximum number of iterations allowed (sum of iteration count for all restarts) */
+	public void setMaxIterations(int maxIter) {
+		minimizer.setMaxIterations(maxIter);
+	}
+
+	/** Get maximum number of simplex restarts to do. See Minimizer.setMaxRestarts for details. */
+	public int getRestarts() {
+		return minimizer.getMaxRestarts();
+	}
+
+	/** Returns the status of the Minimizer after doFit.  Minimizer.SUCCESS indicates a
+	 *	successful completion. In case of Minimizer.INITIALIZATION_FAILURE, fitting could
+	 *	not be performed because the data and/or initial parameters are not compatible
+	 *	with the function value.  In that case, getStatusString may explain the problem.
+	 *	For further status codes indicating problems during fitting, see the status codes
+	 *	of the Minimzer class. */
+
+	/** returns the array with the x data */
+	public double[] getXPoints() {
+		return xData;
+	}
+
+	/** returns the array with the y data */
+	public double[] getYPoints() {
+		return yData;
+	}
+
+	/** returns the code of the fit type of the fit performed */
+	public int getFit() {
+		return fitType;
+	}
+
+	/** returns the name of the fit function of the fit performed */
+	public String getName() {
+		if (fitType==CUSTOM)
+			return "User-defined";
+		if (fitType==GAUSSIAN_INTERNAL)
+			fitType = GAUSSIAN;
+		else if (fitType==RODBARD_INTERNAL)
+			fitType = RODBARD;
+		return fitList[fitType];
+	}
+
+	/** returns a String with the formula of the fit function used */
+	public String getFormula() {
+		if (fitType==CUSTOM)
+			return customFormula;
+		if (fitType==GAUSSIAN_INTERNAL)
+			fitType = GAUSSIAN;
+		else if (fitType==RODBARD_INTERNAL)
+			fitType = RODBARD;
+		return fList[fitType];
+	}
+
+	/** Returns macro code of the form "y = ...x" for the fit function used.
+	 *  Note that this is not neccessarily the equation acutally used for the fit
+	 *  (for the various "linear regression" types and RODBARD2, the fit is done
+	 *  differently). Note that no macro code may be avialable for custom fits
+	 *  using the UserFunction interface. */
+	public String getMacroCode() {
+		if (fitType==CUSTOM)
+			return customFormula;
+		if (fitType==GAUSSIAN_INTERNAL)
+			fitType = GAUSSIAN;
+		else if (fitType==RODBARD_INTERNAL)
+			fitType = RODBARD;
+		return fMacro[fitType];
+	}
+
+	/** Returns an array of fit names with nicer sorting */
+	public static String[] getSortedFitList() {
+		if (sortedFitList == null) {
+			String[] tmpList = new String[fitList.length];
+			for (int i=0; i<fitList.length; i++)
+				tmpList[i] = fitList[sortedTypes[i]];
+			sortedFitList = tmpList;
+		}
+		return sortedFitList;
+	}
+
+	/** Returns the code for a fit with given name as defined in fitList, or -1 if not found */
+	public static int getFitCode(String fitName) {
+		if (namesTable == null) {
+			Hashtable<String,Integer> h = new Hashtable<String,Integer>();
+			for (int i=0; i<fitList.length; i++)
+				h.put(fitList[i], new Integer(i));
+			namesTable = h;
+		}
+		Integer i = (Integer)namesTable.get(fitName);
+		return i!=null? i.intValue() : -1;
+	}
+
+	/** This function is called by the Minimizer and calculates the sum of squared
+	 *	residuals for given parameters.
+	 *	To improve the efficiency, simple linear dependencies are solved directly
+	 *	by linear regression; in that case the corresponding parameters are modified.
+	 *	This effectively reduces the number of free parameters by one or two and thereby
+	 *	significantly improves the performance of minimization.
+	 */
+	public final double userFunction(double[] params, double dummy) {
+		double sumResidualsSqr = 0.0;
+		if (numRegressionParams == 0) {		// simply calculate sum of residuals
+			for (int i=0; i<numPoints; i++) {
+				double fValue = f(params,xData[i]);
+				double resSqr = sqr(fValue-yData[i]);
+				if (weights != null) resSqr *= weights[i];
+				sumResidualsSqr += resSqr;
+			}
+            //IJ.log(IJ.d2s(params[0],3,5)+","+IJ.d2s(params[1],3,5)+": r="+IJ.d2s(sumResidualsSqr,3,5)+Thread.currentThread().getName() );
+		} else {	// handle simple linear dependencies by linear regression:
+			//if(getIterations()<1){String s="minimizerPar:";for(int ii=0;ii<=numParams;ii++)s+=" ["+ii+"]:"+IJ.d2s(params[ii],5,9);IJ.log(s);}
+			minimizerParamsToFullParams(params, true);
+			doRegression(params);
+			sumResidualsSqr = fullParamsToMinimizerParams(params);
+		}
+		return sumResidualsSqr;
+	}
+
+	/** For fits where linear regression is used to reduce the number of parameters handled
+	 *	by the Minimizer, convert Minimizer parameters to the complete set of parameters.
+	 *	When not for calculating regression, we use the sum of squared residuals,
+	 *	offset and multiplication factor stored in the extra array elements:
+	 *	The Minimizer stores the sum of squared residuals directly behind its last parameter.
+	 *	The next element is the value of the offsetParam (if any).
+	 *	The final element is the value of the factorParam (if any).
+	 */
+	private void minimizerParamsToFullParams(double[] params, boolean forRegression) {
+		boolean shouldTransformToSmallerParams = false;
+		double offset = 0;
+		double factor = hasSlopeParam ? 0 : 1; //for regression, calculate function value without x*slope, but multiplied with 1
+		double sumResidualsSqr = 0;
+		if (!forRegression) {				// recover regression-calculated parameters from extra array elements
+			int i = params.length - 1;
+			if (factorParam >= 0)
+				factor = params[i--];
+			if (offsetParam >= 0)
+				offset = params[i];
+			sumResidualsSqr = params[numParams-numRegressionParams];	// sum of squared residuals has been calculated already
+			params[numParams] = sumResidualsSqr;						// ... and is now stored in its new (proper) place
+		}
+		// move array elements to position in array with full number of parameters
+		for (int i=numParams-1, iM=numParams-numRegressionParams-1; i>=0; i--) {
+			if (i == offsetParam)
+				params[i] = offset;
+			else if (i == factorParam)
+				params[i] = factor;
+			else if (iM>=0)
+				params[i] = params[iM--];
+			else
+				params[i] = Double.NaN;
+		}
+		params[numParams] = sumResidualsSqr;
+	}
+
+	/** Determine sum of squared residuals with linear regression.
+	 *	The sum of squared residuals is written to the array element with index 'numParams',
+	 *	the offset and factor params (if any) are written to their proper positions in the
+	 *	params array */
+	private void doRegression(double[] params) {
+		double sumX=0, sumX2=0, sumXY=0; //sums for regression; here 'x' are function values
+		double sumY=0, sumY2=0;			//only calculated for 'slope', otherwise we use the values calculated already
+		double sumWeights=0;
+		for (int i=0; i<numPoints; i++) {
+			double fValue = fitType == STRAIGHT_LINE ? 0 : f(params, xData[i]);	 // function value
+			if (Double.isNaN(fValue)) { //check for NaN now; later we need NaN checking for division-by-zero check.
+				params[numParams] = Double.NaN;
+				return;					//sum of squared residuals is NaN if any value is NaN
+			}
+			double w = weights==null ? 1 : weights[i];
+			sumWeights += w;
+			//if(getIterations()==0)IJ.log(xData[i]+"\t"+yData[i]+"\t"+fValue); //x,y,function
+			if (hasSlopeParam) {		// fit y = offset + slope*x + function(of other params)
+				double x = xData[i];
+				double y = yData[i] - fValue;
+				sumX += x*w;
+				sumX2 += x*x*w;
+				sumXY += x*y*w;
+				sumY2 += y*y*w;
+				sumY += y*w;
+			} else {					// fit y = offset + factor * function(of other params)
+				double x = fValue;
+				double y = yData[i];
+				sumX += fValue*w;
+				sumX2 += fValue*fValue*w;
+				sumXY += fValue*yData[i]*w;
+			}
+		}
+		if (!hasSlopeParam) {
+			sumY = this.sumY;
+			sumY2 = this.sumY2;
+		}
+		double factor = 0; // factor or slope
+		double sumResidualsSqr = 0;
+		if (offsetParam<0) {			// only 'factor' parameter, no offset:
+			factor = sumXY/sumX2;
+			if (Double.isNaN(factor) || Double.isInfinite(factor))
+				factor = 0;				// all 'x' values are 0, any factor (slope) will fit
+			sumResidualsSqr = sumY2 + factor*(factor*sumX2 - 2*sumXY);
+			if (sumResidualsSqr < 2e-15*sumY2)
+				sumResidualsSqr = 2e-15*sumY2;
+		} else {						// full linear regression or offset only. Slope is named 'factor' here
+			if (factorParam >= 0) {
+				factor = (sumXY-sumX*sumY/sumWeights)/(sumX2-sumX*sumX/sumWeights);
+				if (restrictPower & factor<=0)	// power-law fit with (0,0) point: power must be >0
+					factor = 1e-100;
+				else if (Double.isNaN(factor) || Double.isInfinite(factor))
+					factor = 0;			// all 'x' values are equal, any factor (slope) will fit
+			}
+			double offset = (sumY-factor*sumX)/sumWeights;
+			params[offsetParam] = offset;
+			sumResidualsSqr = sqr(factor)*sumX2 + sumWeights*sqr(offset) + sumY2 +
+					2*factor*offset*sumX - 2*factor*sumXY - 2*offset*sumY;
+			// check for accuracy problem: large difference of small numbers?
+			// Don't report unrealistic or even negative values, otherwise minimization could lead
+			// into parameters where we have a numeric problem
+			if (sumResidualsSqr < 2e-15*(sqr(factor)*sumX2 + sumWeights*sqr(offset) + sumY2))
+				sumResidualsSqr = 2e-15*(sqr(factor)*sumX2 + sumWeights*sqr(offset) + sumY2);
+			//if(){IJ.log("sumX="+sumX+" sumX2="+sumX2+" sumXY="+sumXY+" factor="+factor+" offset=="+offset);}
+		}
+		params[numParams] = sumResidualsSqr;
+		if (factorParam >= 0)
+			params[factorParam] = factor;
+	}
+	/** Convert full set of parameters to minimizer parameters and returns the sum of residuals squared.
+	 *	The last array elements, not used by the minimizer, are the offset and factor parameters (if any)
+	 */
+	private double fullParamsToMinimizerParams(double[] params) {
+		double offset = offsetParam >=0 ? params[offsetParam] : 0;
+		double factor = factorParam >=0 ? params[factorParam] : 0;
+		double sumResidualsSqr = params[numParams];
+
+		for (int i=0, iNew=0; i<numParams; i++)		// leave only the parameters for the minimizer in the beginning of the array
+			if (i != factorParam && i != offsetParam)
+				params[iNew++] = params[i];
+		int i = params.length - 1;
+		if (factorParam >= 0)
+			params[i--] = factor;
+		if (offsetParam >= 0)
+			params[i--] = offset;
+		params[i--] = sumResidualsSqr;
+		return sumResidualsSqr;
+	}
+
+	/** In case one or two parameters are calculated by regression and not by the minimizer:
+	 *	Make modified initialParams and initialParamVariations for the Minimizer
+	 */
+	private void modifyInitialParamsAndVariations() {
+		minimizerInitialParams = initialParams.clone();
+		minimizerInitialParamVariations = initialParamVariations.clone();
+		if (numRegressionParams >  0) // convert to shorter arrays with only the parameters used by the minimizer
+			for (int i=0, iNew=0; i<numParams; i++)
+				if (i != factorParam && i != offsetParam) {
+					minimizerInitialParams[iNew] = minimizerInitialParams[i];
+					minimizerInitialParamVariations[iNew] = minimizerInitialParamVariations[i];
+					iNew++;
+				}
+	}
+
+	/** Estimate values for initial parameters and their typical range for the built-in
+	 *	function types.	 For fits with modifications for regression, 'fitType' is still
+	 *	the type of the original (unmodified) fit.
+	 *	Also checks for x values being non-negative for fit types that require this,
+	 *	and returns false if the data cannot be fitted because of negative x.
+	 *	In such a case, 'errorString' contains a message about the problem. */
+	private boolean makeInitialParamsAndVariations(int fitType) {
+		if (numPoints == 0) {
+			errorString = "No data to fit";
+			return false;
+		}
+		boolean hasInitialParams = initialParams != null;
+		boolean hasInitialParamVariations = initialParamVariations != null;
+		if (!hasInitialParams) {
+			initialParams = new double[numParams];
+			if (fitType==CUSTOM) {
+            	for (int i=0; i<numParams; i++)
+            		initialParams[i] = 1.0;
+            }
+		}
+		if (!hasInitialParamVariations)
+			initialParamVariations = new double[numParams];
+		if (fitType==CUSTOM) {
+			for (int i=0; i<numParams; i++) {
+				initialParamVariations[i] = 0.1 * initialParams[i];
+                if (initialParamVariations[i] == 0) initialParamVariations[i] = 0.01; //should not be zero
+            }
+            return true; // can't guess the initial parameters or initialParamVariations from the data
+        }
+
+		// Calculate some things that might be useful for predicting parameters
+		double firstx = xData[0];
+		double firsty = yData[0];
+		double lastx = xData[numPoints-1];
+		double lasty = yData[numPoints-1];
+		double xMin=firstx, xMax=firstx;    //with this initialization, the loop starts at 1, not 0
+		double yMin=firsty, yMax=firsty;
+		double xMean=firstx, yMean=firsty;
+		double xOfMax = firstx;
+		for (int i=1; i<numPoints; i++) {
+			xMean += xData[i];
+			yMean += yData[i];
+			if (xData[i]>xMax) xMax = xData[i];
+			if (xData[i]<xMin) xMin = xData[i];
+			if (yData[i]>yMax) { yMax = yData[i]; xOfMax = xData[i]; }
+			if (yData[i]<yMin) yMin = yData[i];
+		}
+		xMean /= numPoints;
+		yMean /= numPoints;
+
+		double slope = (lasty - firsty)/(lastx - firstx);
+		if (Double.isNaN(slope) || Double.isInfinite(slope)) slope = 0;
+		double yIntercept = yMean - slope * xMean;
+
+		//We cannot fit the following cases because we would always get NaN function values
+		if (xMin < 0 && (fitType==POWER||fitType==CHAPMAN)) {
+			errorString = "Cannot fit "+fitList[fitType]+" when x<0";
+			return false;
+		} else if (xMin < 0 && xMax > 0 && fitType==RODBARD) {
+			errorString = "Cannot fit "+fitList[fitType]+" to mixture of x<0 and x>0";
+			return false;
+		} else if (xMin <= 0 && fitType==LOG) {
+			errorString = "Cannot fit "+fitList[fitType]+" when x<=0";
+			return false;
+		}
+
+		if (!hasInitialParams) {
+			switch (fitType) {
+				//case POLY2: case POLY3: case POLY4: case POLY5: case POLY6: case POLY7: case POLY8:
+				// offset&slope calculated via regression; leave the others at 0
+
+				// also for the other cases, some initial parameters are unused; only to show them with 'showSettings'
+				case EXPONENTIAL:			// a*exp(bx)   assuming change by factor of e between xMin & xMax
+					initialParams[1] = 1.0/(xMax-xMin+1e-100) * Math.signum(yMean) * Math.signum(slope);
+					initialParams[0] = yMean/Math.exp(initialParams[1]*xMean); //don't care, done by regression
+					break;
+				case EXP_WITH_OFFSET:		// a*exp(-bx) + c	assuming b>0, change by factor of e between xMin & xMax
+				case EXP_RECOVERY:			// a*(1-exp(-bx)) + c
+					initialParams[1] = 1./(xMax-xMin+1e-100);
+					initialParams[0] = (yMax-yMin+1e-100)/Math.exp(initialParams[1]*xMean) * Math.signum(slope) *
+							fitType==EXP_RECOVERY ? 1 : -1; // don't care, we will do this via regression
+					initialParams[2] = 0.5*yMean;			// don't care, we will do this via regression
+					break;
+				case EXP_RECOVERY_NOOFFSET: // a*(1-exp(-bx))
+				    initialParams[1] = 1.0/(xMax-xMin+1e-100) * Math.signum(yMean) * Math.signum(slope);
+				    initialParams[0] = yMean/Math.exp(initialParams[1]*xMean); //don't care, done by regression
+				    break;
+				case POWER:					// ax^b, assume linear for the beginning
+					initialParams[0] = yMean/(Math.abs(xMean+1e-100));	// don't care, we will do this via regression
+					initialParams[1] = 1.0;
+					break;
+				case LOG:					// a*ln(bx), assume b=e/xMax
+					initialParams[0] = yMean;				// don't care, we will do this via regression
+					initialParams[1] = Math.E/(xMax+1e-100);
+					break;
+				case LOG2:					// y = a+b*ln(x-c)
+					initialParams[0] = yMean;				// don't care, we will do this via regression
+					initialParams[1] = (yMax-yMin+1e-100)/(xMax-xMin+1e-100); // don't care, we will do this via regression
+					initialParams[2] = Math.min(0., -xMin-0.1*(xMax-xMin)-1e-100);
+					break;
+				case RODBARD:				// d+(a-d)/(1+(x/c)^b)
+					initialParams[0] = firsty;	// don't care, we will do this via regression
+					initialParams[1] = 1.0;
+					initialParams[2] = xMin < 0 ? xMin : xMax; //better than xMean;
+					initialParams[3] = lasty;	// don't care, we will do this via regression
+					break;
+				case INV_RODBARD: case RODBARD2: // c*((x-a)/(d-x))^(1/b)
+					initialParams[0] = xMin - 0.1 * (xMax-xMin);
+					initialParams[1] = slope >= 0 ? 1.0 : -1.0;
+					initialParams[2] = yMax;	// don't care, we will do this via regression
+					initialParams[3] = xMax + (xMax - xMin);
+					break;
+				case GAMMA_VARIATE:			// // b*(x-a)^c*exp(-(x-a)/d)
+				//	First guesses based on following observations (naming the 'x' coordinate 't'):
+				//	t0 [a] = time of first rise in gamma curve - so use the user specified first x value
+				//	tmax = t0 + c*d where tmX is the time of the peak of the curve
+				//	therefore an estimate for c and d is sqrt(tm-t0)
+				//	K [a] can now be calculated from these estimates
+					initialParams[0] = xMin;
+					double cd = xOfMax - xMin;
+					if (cd < 0.1*(xMax-xMin)) cd = 0.1*(xMax-xMin);
+					initialParams[2] = Math.sqrt(cd);
+					initialParams[3] = Math.sqrt(cd);
+					initialParams[1] = yMax / (Math.pow(cd, initialParams[2]) * Math.exp(-cd/initialParams[3])); // don't care, we will do this via regression
+					break;
+				case GAUSSIAN:					// a + (b-a)*exp(-(x-c)^2/(2d^2))
+					initialParams[0] = yMin;	//actually don't care, we will do this via regression
+					initialParams[1] = yMax;	//actually don't care, we will do this via regression
+					initialParams[2] = xOfMax;
+					initialParams[3] = 0.39894 * (xMax-xMin) * (yMean-yMin)/(yMax-yMin+1e-100);
+					break;
+				case GAUSSIAN_NOOFFSET:			// a*exp(-(x-b)^2/(2c^2))
+					initialParams[0] = yMax;	//actually don't care, we will do this via regression
+					initialParams[1] = xOfMax;	  //actually don't care, we will do this via regression
+					initialParams[2] = 0.39894 * (xMax-xMin) * yMean/(yMax+1e-100);
+					break;
+				case CHAPMAN:                   // a*(1-exp(-b*x))^c
+					initialParams[0] = yMax;
+					initialParams[2] = 1.5; // just assuming any reasonable value
+					for (int i=1; i<numPoints; i++) //find when we reach 50% of maximum
+					    if (yData[i]>0.5*yMax) {  //approximately (1-exp(-1))^1.5 = 0.5
+					        initialParams[1] = 1./xData[i];
+					        break;
+					    }
+					if(Double.isNaN(initialParams[1]) || initialParams[1]>1000./xMax) //in case an outlier at the beginning has fooled us
+					    initialParams[1] = 10./xMax;
+					break;
+				case ERF:	// a+b*erf((x-c)/d)
+					initialParams[0] = 0.5*(yMax+yMin);	//actually don't care, we will do this via regression
+					initialParams[1] = 0.5*(yMax-yMin+1e-100) * (lasty>firsty ? 1 : -1);	//actually don't care, we will do this via regression
+					initialParams[2] = xMin + (xMax-xMin)*(lasty>firsty ? yMax - yMean : yMean - yMin)/(yMax-yMin+1e-100);
+					initialParams[3] = 0.1 * (xMax-xMin+1e-100);
+					break;
+				//no case CUSTOM: here, was done above
+			}
+		}
+		if (!hasInitialParamVariations) {	// estimate initial range for parameters
+			for (int i=0; i<numParams; i++)
+				initialParamVariations[i] = 0.1 * initialParams[i]; //default, should be overridden if it can be zero
+			switch (fitType) {
+				case POLY2: case POLY3: case POLY4: case POLY5: case POLY6: case POLY7: case POLY8:
+					double xFactor = 0.5*Math.max(Math.abs(xMax+xMin), (xMax-xMin));
+					initialParamVariations[numParams-1] = (yMax-yMin)/(Math.pow(0.5*(xMax-xMin), numParams-1)+1e-100);
+					for (int i=numParams-2; i>=0; i--)
+						initialParamVariations[i] = initialParamVariations[i+1]*xFactor;
+					break;
+				case EXPONENTIAL:		 // a*exp(bx)		  a (and c) is calculated by regression
+				case EXP_WITH_OFFSET:	 // a*exp(-bx) + c
+				case EXP_RECOVERY:		 // a*(1-exp(-bx)) + c
+					initialParamVariations[1] = 0.1/(xMax-xMin+1e-100);
+					break;
+				// case CHAPMAN:            // a*(1-exp(-b*x))^c use default (10% of value) for b, c
+				// case POWER:				// ax^b; use default for b
+				// case LOG:				// a*ln(bx); use default for b
+				// case LOG2:				// y = a+b*ln(x-c); use default for c
+				case RODBARD:				// d+(a-d)/(1+(x/c)^b); a and d calculated by regression
+					initialParamVariations[2] = 0.5*Math.max((xMax-xMin), Math.abs(xMean));
+					initialParamVariations[3] = 0.5*Math.max(yMax-yMin, Math.abs(yMax));
+					break;
+				case INV_RODBARD:			// c*((x-a)/(d-x))^(1/b); c calculated by regression
+					initialParamVariations[0] = 0.01*Math.max(xMax-xMin, Math.abs(xMax));
+					initialParamVariations[2] = 0.1*Math.max(yMax-yMin, Math.abs(yMax));
+					initialParamVariations[3] = 0.1*Math.max((xMax-xMin), Math.abs(xMean));
+					break;
+				case GAMMA_VARIATE:			// // b*(x-a)^c*exp(-(x-a)/d); b calculated by regression
+				//	First guesses based on following observations:
+				//	t0 [b] = time of first rise in gamma curve - so use the user specified first limit
+				//	tm = t0 + a*B [c*d] where tm is the time of the peak of the curve
+				//	therefore an estimate for a and B is sqrt(tm-t0)
+				//	K [a] can now be calculated from these estimates
+					initialParamVariations[0] = 0.1*Math.max(yMax-yMin, Math.abs(yMax));
+					double ab = xOfMax - firstx + 0.1*(xMax-xMin+1e-100);
+					initialParamVariations[2] = 0.1*Math.sqrt(ab);
+					initialParamVariations[3] = 0.1*Math.sqrt(ab);
+					break;
+				case GAUSSIAN:				// a + (b-a)*exp(-(x-c)^2/(2d^2)); a,b calculated by regression
+					initialParamVariations[2] = 0.2*initialParams[3]; //(and default for d)
+					break;
+				case GAUSSIAN_NOOFFSET:		// a*exp(-(x-b)^2/(2c^2))
+					initialParamVariations[1] = 0.2*initialParams[2]; //(and default for c)
+					break;
+				case ERF:		            // a+b*erf((x-c)/d)
+					initialParamVariations[2] = 0.1 * (xMax-xMin+1e-100);
+					initialParamVariations[3] = 0.5 * initialParams[3];
+					break;
+			}
+		}
+		return true;
+	}
+
+	/** Set multiplyParams and offsetParam for built-in functions. This allows us to use linear
+	 *	regression, reducing the number of parameters used by the Minimizer by up to 2, and
+	 *	improving the speed and success rate of the minimization process */
+	private void getOffsetAndFactorParams() {
+		offsetParam = -1;
+		factorParam = -1;
+		hasSlopeParam = false;
+		switch (fitType) {
+			case STRAIGHT_LINE:
+			case POLY2: case POLY3: case POLY4: case POLY5: case POLY6: case POLY7: case POLY8:
+				offsetParam = 0;
+				factorParam = 1;
+				hasSlopeParam = true;
+				break;
+			case EXPONENTIAL:			// a*exp(bx)
+				factorParam = 0;
+				break;
+			case EXP_WITH_OFFSET:		// a*exp(-bx) + c
+			case EXP_RECOVERY:			// a*(1-exp(-bx)) + c
+				offsetParam = 2;
+				factorParam = 0;
+				break;
+			case EXP_RECOVERY_NOOFFSET:	// a*(1-exp(-bx))
+				factorParam = 0;
+				break;
+			case CHAPMAN:               // a*(1-exp(-b*x))^c
+				factorParam = 0;
+				break;
+			case POWER:					// ax^b
+				factorParam = 0;
+				break;
+			case LOG:					// a*ln(bx)
+				factorParam = 0;
+				break;
+			case LOG2:					// y = a+b*ln(x-c)
+				offsetParam = 0;
+				factorParam = 1;
+				break;
+			case RODBARD_INTERNAL:		// d+a/(1+(x/c)^b)
+				offsetParam = 3;
+				factorParam = 0;
+				break;
+			case INV_RODBARD:			// c*((x-a)/(d-x))^(1/b)
+				factorParam = 2;
+				break;
+			case GAMMA_VARIATE:			// b*(x-a)^c*exp(-(x-a)/d)
+				factorParam = 1;
+				break;
+			case GAUSSIAN_INTERNAL:		// a + b*exp(-(x-c)^2/(2d^2))
+				offsetParam = 0;
+				factorParam = 1;
+				break;
+			case GAUSSIAN_NOOFFSET:		// a*exp(-(x-b)^2/(2c^2))
+				factorParam = 0;
+				break;
+			case ERF:					// a + b*erf((x-c)/d)
+				offsetParam = 0;
+				factorParam = 1;
+				break;
+		}
+		numRegressionParams = 0;
+		if (offsetParam >= 0) numRegressionParams++;
+		if (factorParam >= 0) numRegressionParams++;
+	}
+
+
+	/** calculates the sum of y and y^2 (weighted sum if we have weights) */
+	private void calculateSumYandY2() {
+		sumY = 0.0; sumY2 = 0.0; sumWeights = 0.0;
+		double w = 1.0;
+		for (int i=0; i<numPoints; i++) {
+			double y = yData[i];
+			if (weights != null) w = weights[i];
+			sumY += y*w;
+			sumY2 += y*y*w;
+			sumWeights += w;
+		}
+	}
+
+	/** returns whether this a fit type that acutally fits modified data with a modified function */
+	private boolean isModifiedFitType(int fitType) {
+		return fitType == POWER_REGRESSION || fitType == EXP_REGRESSION || fitType == RODBARD	||
+				fitType == RODBARD2	|| fitType == GAUSSIAN;
+	}
+
+	/** For fits don't use the original data, prepare modified data and fit type.
+	 *	Returns false if the data are incompatible with the fit type
+	 *	In that case, 'errorString' is set to a message explaining the problem
+	 */
+	private boolean prepareModifiedFitType(int fitType) {
+		if (fitType == GAUSSIAN) {
+			this.fitType = GAUSSIAN_INTERNAL;	// different definition of parameters for using regression
+			return true;
+		} else if (fitType == RODBARD) {
+			this.fitType = RODBARD_INTERNAL;	// different definition of parameters for using regression
+			return true;
+		} else if (fitType == POWER_REGRESSION || fitType == EXP_REGRESSION) {
+			if (fitType == POWER_REGRESSION) {
+				xDataSave = xData;
+				xData = new double[numPoints];
+			}
+			yDataSave = yData;
+			yData = new double[numPoints];
+			ySign = 0;
+			numPoints=0;  // we may have lower number of points if there is a (0,0) point that we ignore
+			for (int i=0; i<xData.length; i++) {
+				double y = yDataSave[i];
+				if (fitType == POWER_REGRESSION) {
+					double x = xDataSave[i];
+					if (x==0 && y==0) {
+						restrictPower = true;
+						continue;	  // ignore (0,0) point in power law
+					}
+					if (x<=0) {
+						errorString = "Cannot fit x<=0";
+						return false;
+					}
+					xData[numPoints] = Math.log(x);
+				}
+				if (ySign == 0) ySign = Math.signum(y); //if unknown, determine whether y data are positive or negative
+				if (y*ySign<=0) {
+					errorString = "Cannot fit y=0 or mixture of y>0, y<0";
+					return false;
+				}
+				yData[numPoints] = Math.log(y*ySign);
+				numPoints++;
+			}
+			this.fitType = STRAIGHT_LINE;
+		} else if (fitType == RODBARD2) { // 'Rodbard (NIH Image)' fit is inverse Rodbard function, by fitting x(y); for compatibility with NIH Image
+			xDataSave = xData;
+			yDataSave = yData;
+			xData = yDataSave;	//swap
+			yData = xDataSave;
+			this.fitType = RODBARD_INTERNAL;
+		}
+		return true;
+	}
+
+	/** Get correct params and revert xData, yData if fit has been done via another function */
+	private void postProcessModifiedFitType(int fitType) {
+		if (fitType == POWER_REGRESSION || fitType == EXP_REGRESSION)	// ln y = ln (a*x^b) = ln a + b ln x
+			finalParams[0] = ySign * Math.exp(finalParams[0]);			//or: ln (+,-)y = ln ((+,-)a*exp(bx)) = ln (+,-)a + bx
+		if (fitType == GAUSSIAN)							// a + b exp(-...) to  a + (b-a)*exp(-...)
+			finalParams[1] += finalParams[0];
+		else if (fitType == RODBARD || fitType == RODBARD2) //d+a/(1+(x/c)^b) to d+(a-d)/(1+(x/c)^b)
+			finalParams[0] += finalParams[3];
+
+		if (xDataSave != null) {
+			xData = xDataSave;
+			numPoints = xData.length;
+		}
+		if (yDataSave != null) yData = yDataSave;
+		this.fitType = fitType;
+	}
+
+	private final double sqr(double d) { return d * d; }
+
+
+	/** Pop up a dialog allowing control over simplex starting parameters */
+	private void settingsDialog() {
+	    if (initialParamVariations == null)
+	        initialParamVariations = new double[numParams];
+		GenericDialog gd = new GenericDialog("Simplex Fitting Options");
+		gd.addMessage("Function name: " + getName() + "\n" +
+		"Formula: " + getFormula());
+		char pChar = 'a';
+		for (int i = 0; i < numParams; i++)
+			gd.addNumericField("Initial_"+(char)(pChar+i)+":", initialParams[i], 2);
+		gd.addNumericField("Maximum iterations:", minimizer.getMaxIterations(), 0);
+		gd.addNumericField("Number of restarts:", minimizer.getMaxRestarts(), 0);
+		gd.addNumericField("Error tolerance [1*10^(-x)]:", -(Math.log(maxRelError)/Math.log(10)), 0);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		// read initial parameters:
+		for (int i = 0; i < numParams; i++) {
+			double p = gd.getNextNumber();
+			if (!Double.isNaN(p)) {
+				initialParams[i] = p;
+				initialParamVariations[i] = Math.max(0.01*p, 0.001*initialParamVariations[i]); //assume user-set params are accurate
+			}
+		}
+		double n = gd.getNextNumber();
+		if (n>0)
+			minimizer.setMaxIterations((int)n);
+		n = gd.getNextNumber();
+		if (n>=0)
+			minimizer.setMaxRestarts((int)n);
+		n = gd.getNextNumber();
+		setMaxError(Math.pow(10.0, -n));
+	}
+
+	 /**
+	 * Gets index of highest value in an array.
+	 *
+	 * @param			   array the array.
+	 * @return			   Index of highest value.
+	 */
+	public static int getMax(double[] array) {
+		double max = array[0];
+		int index = 0;
+		for(int i = 1; i < array.length; i++) {
+			if(max < array[i]) {
+				max = array[i];
+				index = i;
+			}
+		}
+		return index;
+	}
+
+	public Plot getPlot() {
+		return getPlot(100);
+	}
+
+	public Plot getPlot(int points) {
+		int PLOT_WIDTH=600, PLOT_HEIGHT=350;
+		double[] x = getXPoints();
+		double[] y = getYPoints();
+		if (getStatus()==Minimizer.INITIALIZATION_FAILURE) {
+			Plot plot = new Plot(getFormula(),"X","Y");
+			plot.setColor(Color.RED, Color.RED);
+			plot.addPoints(x, y, PlotWindow.CIRCLE);
+			plot.setColor(Color.BLUE);
+			plot.setFrameSize(PLOT_WIDTH, PLOT_HEIGHT);
+			plot.addLabel(0.02, 0.1, getName());
+			plot.addLabel(0.02, 0.2, getStatusString());
+			return plot;
+		}
+		int npoints = points;
+		if (npoints<x.length)
+			npoints = x.length; //or 2*x.length-1; for 2 values per data point
+		if (npoints>1000)
+			npoints = 1000;
+		double[] a = Tools.getMinMax(x);
+		double xmin=a[0], xmax=a[1];
+		if (points==256) {
+			npoints = points;
+			xmin = 0;
+			xmax = 255;
+		}
+		a = Tools.getMinMax(y);
+		double ymin=a[0], ymax=a[1]; //y range of data points
+		float[] px = new float[npoints];
+		float[] py = new float[npoints];
+		double inc = (xmax-xmin)/(npoints-1);
+		double tmp = xmin;
+		for (int i=0; i<npoints; i++) {
+			px[i]=(float)tmp;
+			tmp += inc;
+		}
+		double[] params = getParams();
+		for (int i=0; i<npoints; i++)
+			py[i] = (float)f(params, px[i]);
+		a = Tools.getMinMax(py);
+		double dataRange = ymax - ymin;
+		ymin = Math.max(ymin - dataRange, Math.min(ymin, a[0])); //expand y range for curve, but not too much
+		ymax = Math.min(ymax + dataRange, Math.max(ymax, a[1]));
+		Plot plot = new Plot(getFormula(), "X", "Y", px, py);
+		plot.setLabel(0, "fit");
+		plot.setLimits(xmin, xmax, ymin, ymax);
+		plot.setFrameSize(PLOT_WIDTH, PLOT_HEIGHT);
+		plot.setColor(Color.RED, Color.RED);
+		plot.addPoints(x, y, PlotWindow.CIRCLE);
+		plot.setLabel(1, "data");
+		plot.setColor(Color.BLUE); //will be used for the data in the constructor
+		StringBuilder legend = new StringBuilder(100);
+		legend.append(getName()); legend.append('\n');
+		legend.append(getFormula()); legend.append('\n');
+        double[] p = getParams();
+        int n = getNumParams();
+        char pChar = 'a';
+        for (int i = 0; i < n; i++) {
+			legend.append(pChar+" = "+IJ.d2s(p[i],5,9)+'\n');
+			pChar++;
+        }
+		legend.append("R^2 = "+IJ.d2s(getRSquared(),4)); legend.append('\n');
+		plot.addLabel(0.02, 0.1, legend.toString());
+		plot.setColor(Color.BLUE);
+		return plot;
+	}
+
+}
diff --git a/src/ij/measure/Measurements.java b/src/ij/measure/Measurements.java
new file mode 100644
index 0000000..c599cd9
--- /dev/null
+++ b/src/ij/measure/Measurements.java
@@ -0,0 +1,21 @@
+package ij.measure;
+
+public interface Measurements {
+	public static final int AREA=1,MEAN=2,STD_DEV=4,MODE=8,MIN_MAX=16,
+		CENTROID=32,CENTER_OF_MASS=64,PERIMETER=128, LIMIT=256, RECT=512,
+		LABELS=1024,ELLIPSE=2048,INVERT_Y=4096,CIRCULARITY=8192,
+		SHAPE_DESCRIPTORS=8192,FERET=16384,INTEGRATED_DENSITY=0x8000,
+		MEDIAN=0x10000, SKEWNESS=0x20000, KURTOSIS=0x40000, AREA_FRACTION=0x80000, 
+		SLICE=0x100000, STACK_POSITION=0x100000, SCIENTIFIC_NOTATION=0x200000,
+		ADD_TO_OVERLAY=0x400000, NaN_EMPTY_CELLS=0x800000;
+		
+	/** Maximum number of calibration standard (20) */
+	public static final int MAX_STANDARDS = 20;
+	
+	/** All measurement options */
+	public static final int ALL_STATS = AREA+MEAN+STD_DEV+MODE+MIN_MAX+
+		CENTROID+CENTER_OF_MASS+PERIMETER+RECT+
+		ELLIPSE+SHAPE_DESCRIPTORS+FERET+INTEGRATED_DENSITY+
+		MEDIAN+SKEWNESS+KURTOSIS+AREA_FRACTION;
+
+}
diff --git a/src/ij/measure/Minimizer.java b/src/ij/measure/Minimizer.java
new file mode 100644
index 0000000..3501c16
--- /dev/null
+++ b/src/ij/measure/Minimizer.java
@@ -0,0 +1,849 @@
+package ij.measure;
+import ij.*;
+import ij.gui.*;
+import ij.macro.*;
+import ij.gui.Roi;
+import ij.gui.PolygonRoi;
+import ij.gui.Line;
+import ij.util.Tools;
+import ij.plugin.frame.RoiManager;
+import java.util.Random;
+import java.util.Arrays;
+import java.util.Vector;
+import java.util.Hashtable;
+
+/** Minimizer based on Nelder-Mead simplex method (also known as polytope method),
+ *  including the 'outside contraction' as described in:
+ *      J.C. Lagarias, J.A. Reeds, M.H. Wright, P. Wright:
+ *      Convergence properties of the Nelder-Mead simplex algorithm in low dimensions.
+ *      SIAM J. Optim. 9, 112-147 (1998).
+ * Differences w.r.t. this publication:
+ * - If outside contraction is rejected, instead of shrinking the whole simplex, an inside
+ *   contraction is tried first. Own experiments show that this results in slightly better
+ *   performance for some test functions (Perm, Mc Kinnon's function with tau=2, theta=6,
+ *   Osborne1 curve-fitting problem). In most cases, there is no difference, however.
+ * - This implementation does not include any 'ordering rules' in case of equal function values.
+ * - When checking for convergence, a special iteration step may be performed, improving
+ *   the best vertex of the simplex.
+ *
+ * Re-initialization within a minimization run:
+ *   In some cases, the simplex algorithm may fail to find the minimum or the convergence
+ *   check might stop it prematurely. Therefore, the search is initialized again, keeping the
+ *   best vertex of the simplex and setting the other vertices to random values, but keeping
+ *   variations of the parameters w.r.t. the best vertex at a similar value. If re-initializing
+ *   the simplex does not lead to a significant improvement, the value is accepted as true
+ *   (local) minimum.
+ *
+ * Multiple minimization runs:
+ *   In spite of re-initializing (see above), there are rare cases where minimization is stopped
+ *   too early. Also, minimization may result in a local minimum. Therefore, unless determined
+ *   otherwise by setting 'setRestarts', two minimization runs with different initialization
+ *   of the simplex are started in parallel threads. If the results don't agree within the
+ *   error limit, two more minimization runs are started. This is repeated until the two best
+ *   results agree within the error limits or the number of restarts (determined by 'setRestarts';
+ *   default 2, i.e., up to 3 runs with two threads each) is exceeded.
+ *   This does not guarantee that the minimum is a global minimum, however: A local minimum
+ *   will be accepted if the minimizer finds a local minimum twice (or two different local
+ *   minima with the same function value within the error bounds), but no better minimum has
+ *   been found at that time.
+ *
+ * The user-supplied target function should return NaN for out-of-bounds parameters instead
+ * of a high (penalty) value (minimization is faster and more reliable with NaNs).
+ * The region where the function is defined (e.g. not returning NaN) must be convex.
+ * Sharp corners of the region where the function value is defined (especially in higher dimensions)
+ * may cause a problem with finding suitable test points when (re-)initializing the simplex.
+ * If all attempts to find initial points result in NaN, the status returned is
+ * INITIALIZATION_FAILURE.
+ *
+ * Versions:
+ * Michael Schmid 2012-01-30: first version, based on previous CurveFitter
+ * 2012-11-20: mor tries to find initial params not leading to NaN
+ * 2013-09-24: 50% higher maximum iteration count, and never uses more than 0.4*maxIter
+ *             iterations per minimization to avoid trying too few sets of initial params
+ * 2013-10-13: setStatusAndEscape to show iterations and enable abort by ESC
+ * 2014-09-16: normalization bug fixed. makeNewParamVariations checks for paramResolutions
+ *
+ */
+public class Minimizer {
+    /** Status returned: successful completion */
+    public final static int SUCCESS = 0;
+    /** Status returned: Could not initialize the simplex because either the initialParams
+     *  resulted in the target function returning NaN or all attempts to find starting
+     *  parameters for the other simplex points resulted in the target function returning NaN.
+     *  No minimization was possible. */    
+    public final static int INITIALIZATION_FAILURE = 1;
+    /** Status returned: aborted by call to abort method.  */
+    public final static int ABORTED = 2;
+    /** Status returned: Could not reinitialize the simplex because all attempts to find restarting
+     *  parameters resulted in the target function returning NaN.  Reinitialization is
+     *  needed to obtain a reliable result; so the result may be inaccurate or wrong. */    
+    public final static int REINITIALIZATION_FAILURE = 3;
+    /** Status returned: no convergence detected after maximum iteration count */
+    public final static int MAX_ITERATIONS_EXCEEDED = 4;
+    /** Status returned: not two equal solutions after maximum number of restarts */
+    public final static int MAX_RESTARTS_EXCEEDED = 5;
+    /** Strings describing the status codes */
+    public final static String[] STATUS_STRING = { "Success",
+            "Initialization failure; no result",
+            "Aborted",
+            "Re-initialization failure (inaccurate result?)",
+            "Max. no. of iterations reached (inaccurate result?)",
+            "Max. no. of restarts reached (inaccurate result?)"};
+
+
+    private final static double C_REFLECTION  = 1.0;  // reflection coefficient
+    private final static double C_CONTRACTION = 0.5;  // contraction coefficient
+    private final static double C_EXPANSION   = 2.0;  // expansion coefficient
+    private final static double C_SHRINK      = 0.5;  // shrink coefficient
+    private final static int    ITER_FACTOR   = 750;  // maximum number of iterations per numParams^2; twice that value for 2 threads
+    private final static int WORST=0, NEXT_WORST=1, BEST=2;//indices in array to pass the numbers of the respective vertices
+
+    private int numParams;                  // number of independent variables (parameters)
+    private int numVertices;                // numParams+1, number of vertices of the simplex
+    private int numExtraArrayElements;      // number of extra array elements for private use in user function
+    private UserFunction userFunction;      // target function to minimize
+    private double maxRelError = 1e-10;     // max relative error
+    private double maxAbsError = 1e-100;    // max absolute error
+    private double[] paramResolutions;      // differences of parameters less than these values are considered 0
+    private int maxIter;                    // stops after this number of iterations
+    private int totalNumIter;               // number of iterations performed in all tries so far
+    private int numCompletedMinimizations;  // number of minimizations completed
+	private int maxRestarts = 2;            // number of times to try finding local minima; each uses 2 threads if restarts>0
+	private int randomSeed;                 // for starting the random number generator
+	private boolean useSingleThread =       // single thread if one processor or set by useSingleThread(true)
+	        Runtime.getRuntime().availableProcessors() <= 1;
+	private int status;                     // SUCCESS or error code
+	private boolean wasInitialized;         // initialization was successful at least once
+    private double[] result;                // result data+function value
+    private Vector<double[]> resultsVector; // holds several results if multiple tries; the best one is kept.
+    private String ijStatusString = null;   // shown together with iteration count in status, no display if null
+    private boolean checkEscape;            // whether to stop when Escape is pressed
+    private int nextIterationForStatus = 10;// next iteration when we should display the status
+    private long startTime;                 // of the whole minimization process
+    /*private Hashtable<Thread, double[][]> simpTable =
+            new Hashtable<Thread, double[][]>(); //for each thread, holds a reference to its simplex */
+
+    //-----------------------------------------------------------------------------
+
+
+    // We can't set the function in the constructor because the CurveFitter
+    // allows specifying the fit function after other variables
+    /** 
+     *  Set the the target function, i.e. function whose value should be minimized. 
+     *  @param userFunction The class having a function to minimize (implementing
+     *                      the UserFunction interface).
+     *                      This function must allow simultaneous calls in multiple threads unless
+     *                      setMaximumThreads(1); has been called.
+     *                      Note that the function will be called with at least numParams+1 array
+     *                      elements; the last one is needed to store the function value. Further
+     *                      array elements for private use in the user function may be added by
+     *                      calling setExtraArrayElements.
+     *  @param numParams    Number of independent variables (also called parameters)
+     *                      of the function.
+     */
+    public void setFunction(UserFunction userFunction, int numParams) {
+        if (maxIter<=0) {
+            maxIter = ITER_FACTOR*numParams*numParams;
+            if (maxRestarts > 0)
+                maxIter *= 2;
+        }
+        this.userFunction = userFunction;
+        this.numParams = numParams;
+        this.numVertices = numParams+1;
+    }
+
+    /** Perform minimization with the gradient-enhanced simplex method once or a few
+     *  times, depending on the value of 'restarts'. Running it several times helps
+     *  to reduce the probability of finding local minima or accepting one of the rare
+     *  results where the minimizer has got stuck before finding the true minimum.
+     *  We are using two threads and terminate after two equal results. Thus, apart
+     *  from the overhead of starting a new thread (typically < 1 ms), for unproblematic
+     *  minimization problems on a dual-core machine this is almost as fast as running
+     *  it once.
+     *
+     *  Use 'setFunction' first to define the function and number of parameters.
+     *  Afterwards, use the 'getParams' method to access the result.
+     *
+     *  @param initialParams   Array with starting values of the parameters (variables).
+     *                         When null, the starting values are assumed to be 0.
+     *                         The target function must be defined (not returning NaN) for
+     *                         the values specified as initialParams.
+     *  @param initialParamVariations   Parameters (variables) are initially varied by up to +/-
+     *                         this value. If not given (null), initial variations are taken as
+     *                         10% of initial parameter value or 0.01 for parameters that are zero.
+     *                         When this array is given, all elements must be positive (nonzero).
+     *  If one or several initial parameters are zero, is advisable to set the initialParamVariations
+     *  array to useful values indicating the typical order of magnitude of the parameters.
+     *  For target functions with only one minimum, convergence is fastest with large values of
+     *  initialParamVariations, so that the expected value is within initialParam+/-initialParamVariations.
+     *  If local minima can occur, it is best to use a value close to the expected global minimum,
+     *  and rather small initialParamVariations, much lower than the distance to the nearest local
+     *  minimum.
+     *
+     *  @return                status code; SUCCESS if two attempts have found minima with the
+     *                         same value (within the error bounds); so a minimum has been found
+     *                         with very high probability.
+     */
+    public int minimize(final double[] initialParams, final double[] initialParamVariations) {
+        status = SUCCESS;
+        resultsVector = new Vector<double[]>();
+        int maxLoopCount = maxRestarts+1;
+        if (useSingleThread) maxLoopCount*=2;       // if we have only one thread, loop twice as many times
+        for (int i=0; i<maxLoopCount; i++) {        // try several times, until we have twice the same result
+            Thread secondThread = null;
+            if (maxRestarts>0 && !useSingleThread) {  // set up 2nd thread to minimize
+                final int seed = randomSeed+1000000+i;
+                final Thread thread = new Thread(
+                    new Runnable() {
+                        final public void run() {
+                            minimizeOnce(initialParams, initialParamVariations, seed);
+                        }
+                    }, "Minimizer-1"
+                );
+                thread.setPriority( Thread.currentThread().getPriority() );
+                thread.start();
+                secondThread = thread;
+            }
+            minimizeOnce(initialParams, initialParamVariations, randomSeed+i); //minimize in main thread
+            if (secondThread != null) try {
+                secondThread.join();                // wait until send thread is done
+            } catch (InterruptedException e) {}
+            if (resultsVector.size() == 0 && result==null)
+                return status;
+            if (result==null)
+                result = (double[])resultsVector.get(0);
+            for (double[] r : resultsVector)        // find best result so far
+                if (value(r) < value(result))
+                    result = r;
+            if (status != SUCCESS && status != REINITIALIZATION_FAILURE && status != MAX_ITERATIONS_EXCEEDED)
+                return status;                      // no more tries if permanent error or aborted
+            if (totalNumIter >= maxIter)
+                return MAX_ITERATIONS_EXCEEDED;     // no more tries if too many iterations
+            for (int ir=0; ir<resultsVector.size(); ir++)
+                if (!belowErrorLimit(value((double[])resultsVector.get(ir)), value(result), 1.0)) {
+                    resultsVector.remove(ir);       // discard results that are significantly worse
+                    ir --;
+                }
+            if (resultsVector.size() >= 2) return SUCCESS;  // if we have two (almost) equal results, it's enough
+        } //for i <= maxRestarts
+        if (ijStatusString != null)
+            IJ.showStatus("");                      // reset status display
+        return maxRestarts>0 ?
+                MAX_RESTARTS_EXCEEDED :             // number of restarts exceeded without two equal results
+                status;                             // if only one run was required, we can't have 2 equal results
+    }
+
+    /** Perform minimization with the simplex method once, including re-initialization until
+     *  we have a stable solution.
+     *  Use the 'getParams' method to access the result.
+     *
+     *  @param initialParams   Array with starting values of the parameters (variables).
+     *                         When null, the starting values are assumed to be 0.
+     *                         The target function must be defined (not returning NaN) for
+     *                         the values specified as initialParams.
+     *  @param initialParamVariations   Parameters (variables) are initially varied by up to +/-
+     *                         this value. If not given (null), iniital variations are taken as
+     *                         10% of inial parameter value or 0.01 for parameters that are zero.
+     *                         When this array is given, all elements must be positive (nonzero).
+     *  If one or several initial parameters are zero, is advisable to set the initialParamVariations
+     *  array to useful values indicating the typical order of magnitude of the parameters.
+     *  For target functions with only one minimum, convergence is fastest with large values of
+     *  initialParamVariations, so that the expected value is within initialParam+/-initialParamVariations.
+     *  If local minima can occur, it is best to use a value close to the expected global minimum,
+     *  and rather small initialParamVariations, much lower than the distance to the nearest local
+     *  minimum.
+     *
+     *  @return                status code; SUCCESS if it is considered likely that a minimum of the
+     *                         target function has been found.
+     */
+    public int minimizeOnce(double[] initialParams, double[] initialParamVariations) {
+        status = SUCCESS;
+        minimizeOnce(initialParams, initialParamVariations, randomSeed);
+        return status;
+    }
+
+    /** Get the result, i.e., the set of parameter values (i.e., variable values)
+     *  from the best corner of the simplex. Note that the array returned may have more
+     *  elements than numParams; ignore the rest.
+     *  May return an array with only NaN values in case the minimize call has returned
+     *  an INITIALIZATION_FAILURE status or that abort() has been called at the very
+     *  beginning of the minimization.
+     *  Do not call this method before minimization. */
+    public double[] getParams() {
+        if (result == null) {
+            result = new double[numParams+1+numExtraArrayElements];
+            Arrays.fill(result, Double.NaN);
+        }
+        return result;
+    }
+
+    /** Get the value of the minimum, i.e. the value associated with the resulting parameters
+     *  as obtained by getParams(). May return NaN in case the minimize call has returned
+     *  an INITIALIZATION_FAILURE status or that abort() has been called at the very
+     *  beginning of the minimization.
+     *  Do not call this method before minimization. */
+    public double getFunctionValue() {
+        if (result == null) {
+            result = new double[numParams+1];
+            Arrays.fill(result, Double.NaN);
+        }
+        return value(result);
+    }
+
+    /** Get number of iterations performed (includes all restarts). One iteration needs
+     *  between one and numParams+3 calls of the target function (typically two calls
+     *  per iteration) */
+    public int getIterations() {
+        return totalNumIter;
+    }
+        
+    /** Set maximum number of iterations allowed (including all restarts and all threads).
+     *  The number of function calls will be higher, up to about twice the number of
+     *  iterations.
+     *  Note that the number of iterations needed typically scales with the square of
+     *  the dimensions (i.e., numParams^2).
+     *  Default value is 1000 * numParams^2 (half that value if maxRestarts=0), which is
+     *  enough for >99% of all cases (if the maximum number of restarts is set to 2);
+     *  typical number of iterations are below 10 and 20% of this value.
+     */
+    public void setMaxIterations(int x) {
+        maxIter = x;
+    }
+
+    /** Get maximum number of iterations allowed. Unless given by 'setMaxIterations',
+     *  this value is defined only after running 'setFunction' */
+    public int getMaxIterations() {
+        return maxIter;
+    }
+
+    /** Set maximum number of minimization restarts to do.
+     *  With n=0, the minimizer is run once in a single thread.
+     *  With n>0, two threads are used, and if the two results do not agree within
+     *  the error bounds, additional optimizations are done up to n times, each
+     *  with two threads. In any case, if the two best results are within the error
+     *  bounds, the best result is accepted.
+     *  Thus, on dual-core machines running no other jobs, values of n=1 or n=2 (default)
+     *  do not cause a notable increase of computing time for 'easy' optimization problems,
+     *  while greatly reducing the risk of running into spurious local minima or non-
+     *  optimal results due to the minimizer getting stuck. In problematic cases, the
+     *  improved 
+     *  The 'n' value does not refer to the restarts within one minimization run
+     *  (there, at least one restart is performed, and restart is repeated until the result
+     *  does not change within the error bounds).
+     *  This value does not affect the 'minimizeOnce' function call.
+     *  When setting the maximum number of restarts to a value much higher than 3, remember
+     *  to adjust the maximum number of iterations (see setMaxIterations).
+     */
+    public void setMaxRestarts(int n) {
+        maxRestarts = n;
+    }
+
+    /** Get maximum number of minimization restarts to do */
+    public int getMaxRestarts() {
+        return maxRestarts;
+    }
+    /** Get number of minimizations completed (i.e. not aborted or stopped because the
+     *  number of minimization was exceeded). After a minimize(..) call, typically 2
+     *  for unproblematic cases. Higher number indicate a functin that is difficult to
+     *  minimize or the existence of more than one minimum.
+     */
+    public int getCompletedMinimizations() {
+        return numCompletedMinimizations;
+    }
+
+    /** Set a seed to initialize the random number generator, which is used for initialization
+     *  of the simplex. */
+    public void setRandomSeed(int n) {
+        randomSeed = n;
+    }
+
+    /** Sets the accuracy of convergence. Minimizing is done as long as the
+     *  relative error of the function value is more than this number (Default: 1e-10).
+     */
+    public void setMaxError(double maxRelError) {
+        this.maxRelError = maxRelError;
+    }
+
+    /** Sets the accuracy of convergence. Minimizing is done as long as the
+     *  relative error of the function value is more than maxRelError (Default: 1e-10)
+     *  and the maximum absolute error is more than maxAbsError
+     *  (i.e. it is enough to fulfil one of these two criteria)
+     */
+    public void setMaxError(double maxRelError, double maxAbsError) {
+        this.maxRelError = maxRelError;
+        this.maxAbsError = maxAbsError;
+    }
+
+    /** Set the resolution of the parameters, for problems where the target function is not smooth
+     *  but suffers from numerical noise. If all parameters of all vertices are closer to the
+     *  best value than the respective resolution value, minimization is finished, irrespective
+     *  of the difference of the target function values at the vertices */
+    public void setParamResolutions(double[] paramResolutions) {
+        this.paramResolutions = paramResolutions;
+    }
+
+    /** Call setMaximuThreads(1) to avoid multi-threaded execution (in case the user-provided
+     *  target function does not allow moultithreading). Currently a maximum of 2 thread is used
+     *  irrespective of any higher value. */
+    public void setMaximumThreads (int numThreads) {
+        useSingleThread = numThreads <= 1;
+    }
+
+    /** Aborts minimization. Calls to getParams() will return the best solution found so far.
+     *  This method may be called from the user-supplied target function.
+     *  If displayStatusAndCheckEsc has been called before, the Minimizer itself checks for the ESC key.
+     */
+    public void abort() {
+        status = ABORTED;
+    }
+
+    /** Create output on the number of iterations in the ImageJ Status line, e.g.
+     *  "<ijStatusString> 50 (max 750); ESC to stop"
+     *  @param ijStatusString Displayed in the beginning of the status message. No display if null.
+     *  E.g. "Optimization: Iteration "
+     *  @param checkEscape When true, the Minimizer stops if escape is pressed and the status
+     *  becomes ABORTED. Note that checking for ESC does not work in the Event Queue thread. */
+    public void setStatusAndEsc(String ijStatusString, boolean checkEscape) {
+        this.ijStatusString = ijStatusString;
+        this.checkEscape = checkEscape;
+    }
+
+    /** Add a given number of extra elements to array of parameters (independent vaiables)
+     *  for private use in the user function.  Note that the first numParams+1 elements
+     *  should not be touched.*/
+    public void setExtraArrayElements(int numExtraArrayElements) {
+        this.numExtraArrayElements = numExtraArrayElements;
+    }
+    /** Get the full simplex of the current thread. This may be useful if the target function
+     *  wants to modify the simplex */
+     /* public double[][] getSimplex() {
+        return simpTable.get(Thread.currentThread());
+     } */
+
+    /** One minimization run (including reinitializations of the simplex until the result is stable) */
+    private void minimizeOnce(double[] initialParams, double[] initialParamVariations, int seed) {
+        Random random = new Random(seed);
+        double[][] simp = makeSimplex(initialParams, initialParamVariations, random);
+        if (simp == null) {
+            status = wasInitialized ? REINITIALIZATION_FAILURE : INITIALIZATION_FAILURE;
+            return;
+        }
+        wasInitialized = true;
+        if (startTime == 0)
+            startTime = System.currentTimeMillis();
+        //if (IJ.debugMode) showSimplex(simp, seed+" Initialized:");
+        int bestVertexNumber = minimize(simp);          // first minimization
+        double bestValueSoFar = value(simp[bestVertexNumber]);
+        //reinitialize until converged or error/aborted (don't care about reinitialization failure in other thread)
+        boolean reinitialisationFailure = false;
+        while (status == SUCCESS || status == REINITIALIZATION_FAILURE) {
+            double[] paramVariations =
+                    makeNewParamVariations(simp, bestVertexNumber, initialParams, initialParamVariations);
+            if (!reInitializeSimplex(simp, bestVertexNumber, paramVariations, random)) {
+                reinitialisationFailure = true;
+                break;
+            }
+            //if (IJ.debugMode) showSimplex(simp, seed+" Reinitialized:");
+            bestVertexNumber = minimize(simp);          // minimize with reinitialized simplex
+            if (belowErrorLimit(value(simp[bestVertexNumber]), bestValueSoFar, 2.0)) break;
+            bestValueSoFar = value(simp[bestVertexNumber]);
+        }
+        if (reinitialisationFailure)
+            status = REINITIALIZATION_FAILURE;
+        else if (status == SUCCESS || status == REINITIALIZATION_FAILURE) //i.e. not aborted, not max iterations exceeded
+            numCompletedMinimizations++;                // it was a complete minimization
+        //if (IJ.debugMode) showSimplex(simp, seed+" Final:");
+        if (resultsVector != null) synchronized(resultsVector) {
+            resultsVector.add(simp[bestVertexNumber]);
+        } else
+            result = simp[bestVertexNumber];
+    }
+
+    /** Minimizes the target function by variation of the simplex.
+     *  Note that one call to this function never does more than 0.4*maxIter iterations.
+     *  @return index of the best value in simp
+     */
+    private int minimize(double[][] simp) {
+        int[] worstNextBestArray = new int[3];          // used to pass these indices from 'order' function
+        double[] center     = new double[numParams+1+numExtraArrayElements];    // center of all vertices except worst
+        double[] reflected  = new double[numParams+1+numExtraArrayElements];  // the 1st new vertex to try
+        double[] secondTry  = new double[numParams+1+numExtraArrayElements];  // expanded or contracted vertex
+
+        order(simp, worstNextBestArray);
+        int worst = worstNextBestArray[WORST];
+        int nextWorst = worstNextBestArray[NEXT_WORST];
+        int best = worstNextBestArray[BEST];
+        //showSimplex(simp, "before minimization, value="+value(simp[best]));
+
+        //String operation="ini";
+        int thisNumIter=0;
+        while (true) {
+            totalNumIter++;                                 // global count over all threads
+            thisNumIter++;                                  // local count for this minimize call
+            // THE MINIMIZAION ALGORITHM IS HERE
+            iteration: {
+                getCenter(simp, worst, center);             // centroid of vertices except worst
+                // Reflect worst vertex through centriod of not-worst
+                getVertexAndEvaluate(center, simp[worst], -C_REFLECTION, reflected);
+                if (value(reflected) <= value(simp[best])) {      // if it's better than the best...
+                    // try expanding it
+                    getVertexAndEvaluate(center, simp[worst], -C_EXPANSION, secondTry);
+                    if (value(secondTry) <= value(reflected)) {
+                        copyVertex(secondTry, simp[worst]);  // if expanded is better than reflected, keep it
+                        //operation="expa";
+                        break iteration;
+                    }
+                }
+                if (value(reflected) < value(simp[nextWorst])) {
+                    copyVertex(reflected, simp[worst]);     // keep reflected if better than 2nd worst
+                    //operation="refl";
+                    break iteration;
+                } else if (value(reflected) < value(simp[worst])) {
+                    // try outer contraction
+                    getVertexAndEvaluate(center, simp[worst], -C_CONTRACTION, secondTry);
+                    if (value(secondTry) <= value(reflected)) {
+                        copyVertex(secondTry, simp[worst]); // keep outer contraction
+                        //operation="outC";
+                        break iteration;
+                    }
+                } else if (value(reflected) > value(simp[worst]) || Double.isNaN(value(reflected))) {
+                    // else inner contraction
+                    getVertexAndEvaluate(center, simp[worst], C_CONTRACTION, secondTry);
+                    if (value(secondTry) < value(simp[worst])) {
+                        copyVertex(secondTry, simp[worst]);     // keep contracted if better than 2nd worst
+                        //operation="innC";
+                        break iteration;
+                    }
+                }
+                // if everything else has failed, contract simplex in on best
+                shrinkSimplexAndEvaluate(simp, best);
+                //operation="shri";
+                break iteration;
+            } // iteration:
+            boolean checkParamResolution =    // if new 'worst' is not close to 'best', don't check any further
+                    paramResolutions!=null && belowResolutionLimit(simp[worst], simp[best]);
+            order(simp, worstNextBestArray);
+            worst = worstNextBestArray[WORST];
+            nextWorst = worstNextBestArray[NEXT_WORST];
+            best = worstNextBestArray[BEST];
+
+            if (checkParamResolution)
+                if (belowResolutionLimit(simp, best))       // check whether all parameters are within the resolution limit
+                    break;
+            if (belowErrorLimit(value(simp[best]), value(simp[worst]), 4.0)) {   // make sure we are at the minimum:
+                getCenter(simp, -1, secondTry);             // check center of the simplex
+                evaluate(secondTry);
+                if (value(secondTry) < value(simp[best]))
+                    copyVertex(secondTry, simp[best]);      // better than best: keep
+            }
+            if (belowErrorLimit(value(simp[best]), value(simp[worst]), 4.0)) // no large spread of values
+                break;                                      // looks like we are at the minimum
+            if (totalNumIter > maxIter || thisNumIter>4*(maxIter/10))
+                status = MAX_ITERATIONS_EXCEEDED;
+            if (status != SUCCESS)
+                break;
+            if ((ijStatusString != null || checkEscape) && totalNumIter > nextIterationForStatus) {
+                long time = System.currentTimeMillis();
+                nextIterationForStatus = totalNumIter + (int)(totalNumIter*500L/(time-startTime+1)); //next display 0.5 sec later
+                if (time - startTime > 1000L) {             // display status and check for ESC after the first second
+                    if (checkEscape && IJ.escapePressed()) {
+                        status = ABORTED;
+                        IJ.resetEscape();
+                        IJ.showStatus(ijStatusString+" ABORTED");
+                        break;
+                    }
+                    if (ijStatusString != null) {
+                        String statusString = ijStatusString+totalNumIter+" ("+maxIter+" max)";
+                        if (checkEscape) statusString += " ESC to stop";
+                        IJ.showStatus(statusString);
+                    }
+                }
+            }
+        }
+        //showSimplex(simp, "after "+totalNumIter+" iterations: value="+value(simp[best]));
+        return best;
+    }
+
+    /** Move along the line between center and worst, where +1 corresponds to worstVertex
+     *  The new point is written to'newVertex' and target function is evaluated there
+     */
+    private void getVertexAndEvaluate(double[] center, double[] worstVertex, double howFar, double[] newVertex) {
+        for (int i = 0; i < numParams; i++)
+            newVertex[i] = (1.-howFar)*center[i] + howFar*worstVertex[i];
+        evaluate(newVertex);
+    }
+
+    /** Get center of all vertices except one to exclude
+     *  (may be -1 to exclude none)
+     *  Does not care about function values (i.e., last array elements) */
+    private void getCenter(double[][]simp, int excludeVertex, double[] center) {
+        Arrays.fill(center, 0.);
+        int nV = 0;
+        for (int v=0; v<numVertices; v++)
+            if (v != excludeVertex) {
+                for (int i=0; i<numParams; i++)
+                    center[i] += simp[v][i];
+                nV++;
+            }
+        double norm = 1.0/nV;
+        for (int i=0; i<numParams; i++)
+            center[i] *= norm;
+    }
+
+    private void shrinkSimplexAndEvaluate(double[][] simp, int best) {
+        for (int v=0; v<numVertices; v++)
+            if (v != best) {
+                for (int i=0; i<numParams; i++)
+                    simp[v][i] = C_SHRINK*simp[v][i] + (1-C_SHRINK)*simp[best][i];
+                evaluate(simp[v]);
+            }
+    }
+
+    /** Whether the highest and lowest values fulfill the error limit criterion.
+     *  Error limits are reduced by a factor of 'sensitivity' */
+    private boolean belowErrorLimit(double highest, double lowest, double sensitivity) {
+        double absError = sensitivity*Math.abs(highest - lowest);
+        double relError = absError/(Math.max(Math.abs(highest),Math.abs(lowest))+1e-100);
+        return relError < maxRelError || absError < maxAbsError;
+    }
+
+    /** Initialise the simplex and evaluate it. Returns null on failure. */
+    private double[][] makeSimplex(double[] initialParams, double[] initialParamVariations, Random random) {
+        double[][] simp = new double[numVertices][numParams+1+numExtraArrayElements];
+        /* simpTable.put(Thread.currentThread(), simp); */
+        
+        if (initialParams!=null) {
+            for (int i=0; i<numParams; i++)
+                if (Double.isNaN(initialParams[i]))
+                    if (IJ.debugMode) IJ.log("Warning: Initial Parameter["+i+"] is NaN");
+            System.arraycopy(initialParams, 0, simp[0], 0, Math.min(initialParams.length, numParams));
+        }
+        evaluate(simp[0]);
+        if (Double.isNaN(value(simp[0]))) {
+            if (IJ.debugMode) showVertex(simp[0], "Warning: Initial Parameters yield NaN:");
+            findValidInitalParams(simp[0], initialParamVariations, random);
+        }
+        if (Double.isNaN(value(simp[0]))) {
+            if (IJ.debugMode) IJ.log("Error: Could not find initial parameters not yielding NaN:");
+            return null;
+        }
+        if (initializeSimplex(simp, initialParamVariations, random))
+            return simp;
+        else {
+            if (IJ.debugMode) showSimplex(simp, "Error: Could not make simplex vertices not yielding NaN");
+            return null;
+        }
+    }
+
+    /** Whether the distance between the best and any other simplex vertex
+     *  is less than the resolution of the parameters */
+    private boolean belowResolutionLimit(double[][] simp, int best) {
+        for (int v=0; v<numVertices; v++)
+            if (v!= best && !belowResolutionLimit(simp[v], simp[best]))
+                return false;
+        return true;
+    }
+
+    /** Whether the distance between two vertices is less than the resolution of the parameters */
+    private boolean belowResolutionLimit(double[] vertex1, double[] vertex2) {
+        for (int i=0; i<numParams; i++)
+            if (Math.abs(vertex1[i]-vertex2[i]) >= paramResolutions[i])
+                return false;
+        return true;
+    }
+
+    /** Find initial parameters not yielding a result of NaN in case those given yield NaN
+     *  Called with params containing the initial parameters that have been tried previously */
+    private void findValidInitalParams(double[] params, double[] initialParamVariations, Random random) {
+        final int maxAttempts = 50*numParams*numParams;  //max number of attempts to find params that do not lead to NaN
+        double rangeFactor = 1;             // will gradually become larger to handle different orders of magnitude
+        final double rangeMultiplyLog = Math.log(1e20)/(maxAttempts-1); //will try up to 1e-20 to 1e20*initialParamVariations
+        double[] firstParams = new double[numParams]; // remember starting params (which may be modified)
+        double[] variations = new double[numParams];    // new values of parameter variations
+        for (int i=0; i<numParams; i++) {
+            firstParams[i] = Double.isNaN(params[i]) ? 0 : params[i];
+            variations[i] = initialParamVariations!=null ? initialParamVariations[i] : 0.1*firstParams[i];
+            if (Double.isNaN(variations[i]) || Math.abs(variations[i])<1e-10 || Math.abs(variations[i])>1e10)
+                variations[i] = 0.1;
+        }
+        for (int attempt=0; attempt<maxAttempts; attempt++) {
+            for (int i=0; i<numParams; i++) {
+                double multiplier = attempt<maxAttempts/10 ? 1 :  //after a while try different orders of magnitude
+                        Math.exp(rangeMultiplyLog*attempt*2*(random.nextDouble()-0.5));
+                params[i] = multiplier*(firstParams[i]+2*(random.nextDouble()-0.5)*variations[i]);
+            }
+            evaluate(params);
+            //showVertex(params,"findValidInitalParams attempt "+attempt);
+            if (!Double.isNaN(value(params))) return;    //found a valid parameter set
+        }
+    }
+
+
+    /** Reinitialize an existing simplex: Create new vertices around the best one, keeping the rough size of
+     *  the simplex. This helps to avoid premature termination or cases where the simplex has become degenerate.
+     *  All points of the new simplex are evaluated already.
+     *  Returns false on error (if it could not create a simplex not resulting in NaN). */
+    private boolean reInitializeSimplex(double[][] simp, int bestVertexNumber, double[] paramVariations, Random random) {
+        if (bestVertexNumber != 0) {
+            double[] swap = simp[0];
+            simp[0] = simp[bestVertexNumber];
+            simp[bestVertexNumber] = swap;
+        }
+        return initializeSimplex(simp, paramVariations, random);
+    }
+
+    /** Initialize simplex vertices except the number 0, which will be taken as starting point.
+     *  All points of the new simplex are evaluated already.
+     *  Returns false on error (if it could not create a simplex not resulting in NaN).
+     */
+    private boolean initializeSimplex(double[][] simp, double[] paramVariations, Random random) {
+        double[] variations = new double[numParams];    // improved values of parameter variations
+        for (int i=0; i<numParams; i++) {
+            double range = paramVariations!=null && i<paramVariations.length ?
+                    paramVariations[i] : 0.1 * Math.abs(simp[0][i]); // if nothing else given, based on initial parameter
+            if (range < 1e-100 || Double.isNaN(range))
+                range = 0.01;                   //range must be nonzero
+            if (Math.abs(range/simp[0][i])<1e-10)
+                range = Math.abs(simp[0][i]*1e-10); //range must be more than very last digits
+            variations[i] = range;
+            //IJ.log("param#"+i+" variation="+(float)variations[i]);
+        }
+        final int maxAttempts = 100*numParams;  //max number of attempts to find params that do not lead to NaN
+        for (int v=1; v<numVertices; v++) {
+            int numTries = 0;
+            do {                                //try finding a vertex that does not yield NaN
+                if (numTries++ > maxAttempts)
+                    return false;
+                // Create a vector orthogonal to all others in a coordinate system where every value is
+                // normalized to its respective variations value. We first use this coordinate system where
+                // every parameter is in the [-1, +1] range.
+                // Don't orthogonalize after getting only NaN function values in many attempts; it might be
+                // easier to find viable parameters without normalization.
+                for (int i=0; i<numParams; i++)
+                    simp[v][i] = 2*random.nextFloat() - 1.0;
+                if (numTries < maxAttempts/3)       // (don't orthogonalize if finding valid params was very difficult
+                    //IJ.log("orthogonalize vertex "+v);
+                    for (int v2=1; v2<v; v2++) {    // to avoid a degenerate simplex, make orthogonal to all others
+                        double lengthSqr = 0;
+                        double innerProduct = 0;
+                        for (int i=0; i<numParams; i++) {
+                            double x2 = (simp[v2][i] - simp[0][i])/variations[i]; // convert to [-1, +1] range
+                            lengthSqr += x2*x2;
+                            innerProduct += x2*simp[v][i];
+                        }
+                        for (int i=0; i<numParams; i++)     //subtract component parallel to the other vector
+                            simp[v][i] -= ((simp[v2][i] - simp[0][i])/variations[i])*(innerProduct/lengthSqr);
+                    }
+                double sumSqr = 0;              // normalize the 'excursion vector' to length = 1
+                for (int i=0; i<numParams; i++)
+                    sumSqr += simp[v][i]*simp[v][i];
+                if (sumSqr < 1e-14) continue;   // bad luck with random numbers, excursion vector almost zero
+                if (numTries > 2 && sumSqr > 1e-6)
+                    sumSqr = 1;                 // don't normalize if attempts with normalized were unsuccessful
+                for (int i=0; i<numParams; i++)
+                    simp[v][i] = simp[0][i] + simp[v][i]/Math.sqrt(sumSqr)*variations[i];
+                evaluate(simp[v]);
+            } while (Double.isNaN(value(simp[v])) && (status == SUCCESS || status == REINITIALIZATION_FAILURE));
+        }
+        //showSimplex(simp, 0);
+        return true;
+    }
+
+    /** Calculate ranges for parameter variations for re-initializing:
+     *  Note that the simplex should have adapted in size to the useful range of each
+     *  parameter, but in special cases it might have become degenerate [i.e. the
+     *  (hyper-)volume spanned by the vertices might be zero; in such a case it may
+     *  happen that one parameter has the same value for all vertices of the simplex].
+     *
+     *  For each parameter, as a variation value we use the typical difference w.r.t. the best
+     *  vertex of the simplex.
+     *  To avoid a degenerate simplex, we have to know what the the relative orders of magnitude of
+     *  the parameter variations should be.  If initialParamVariations are given, we use them as
+     *  indication of the typoical relative values; otherwise we use the parameter values themselves
+     *  and assume that the variation of each parameter should be roughly the same fraction of the value.
+     *  If the variation of a parameter in the simplex w.r.t. this estimated variation is much
+     *  smaller (<10^3) than typical for the parameters, we increase the variation for this parameter.
+     */
+    private double[] makeNewParamVariations(double[][] simp, int bestVertexNumber,
+            double[] initialParams, double[] initialParamVariations) {
+        double[] paramVariations = new double[numParams];   // will be the return value
+        double[] relatedTo = new double[numParams];         // parameter variation should be related to (in size) these values
+        double logTypicalRelativeVariation = 0;
+        for (int i=0; i<numParams; i++) {                   // for all parameters
+            double variation = 0;                           // roughly size of simplex in direction of that parameter
+            for (int v=0; v<numVertices; v++)
+                if (v != bestVertexNumber) {
+                    double delta = Math.abs(simp[v][i] - simp[bestVertexNumber][i]);
+                    paramVariations[i] += delta*delta;
+                }
+            paramVariations[i] = 10*Math.sqrt(paramVariations[i]); // make the new simplex larger than the old one
+            relatedTo[i] = initialParamVariations!=null && initialParamVariations.length>= numParams ?
+                    initialParamVariations[i] :             // relate to initialParamVariations (if given),
+                    Math.max(Math.abs(initialParams[i]), Math.abs(simp[bestVertexNumber][i]));
+            double logRelativeVariation = paramVariations[i]>relatedTo[i] ? 0 :
+                    Math.log(paramVariations[i]/relatedTo[i]);
+            logTypicalRelativeVariation += logRelativeVariation;
+        }
+        logTypicalRelativeVariation /= numParams;
+        double typicalRelativeVariation = Math.exp(logTypicalRelativeVariation);
+        final double WORST_RATIO = 1e-3;        //parameter variation should not be lower than typical value by more than this
+        for (int i=0; i<numParams; i++) {
+            if (paramVariations[i]<relatedTo[i] && paramVariations[i]/relatedTo[i] < typicalRelativeVariation*WORST_RATIO)
+                paramVariations[i] = relatedTo[i]*typicalRelativeVariation*WORST_RATIO;
+            if (paramResolutions != null && paramVariations[i] < 10*paramResolutions[i])
+                paramVariations[i] = 10*paramResolutions[i];// parameter variation must be well above numeric noise limit
+        }
+        return paramVariations;
+    }
+
+    /** Evaluate the target function for the parameters given by 'vertex'
+     *  The function value is stored into the last (extra) array element.
+     */
+    private void evaluate(double[] vertex) {
+        vertex[numParams] = userFunction.userFunction(vertex, 0);
+    }
+
+    /** Function value of a vertex after call to 'evaluate' 
+     *  (stored it as last array element) */
+    private double value(double[] vertex) {
+        return vertex[numParams];
+    }
+
+    /** Keep the newVertex: replace a given Vertex with it */
+    void copyVertex(double[] newVertex, double[] vertex) {
+        System.arraycopy(newVertex, 0, vertex, 0, newVertex.length);
+    }
+    
+    /** Find the simplex vertices with the worst, nextWorst and best values
+     *  of the target function */
+    private void order(double[][] simp, int[] worstNextBestArray) {
+        int worst = 0, nextWorst = 0, best = 0;
+        for (int i = 0; i < numVertices; i++) {
+            if (value(simp[i]) < value(simp[best])) best = i;
+            if (value(simp[i]) > value(simp[worst])) worst = i;
+        }
+        nextWorst = best;
+        for (int i = 0; i < numVertices; i++)
+            if (i != worst && value(simp[i]) > value(simp[nextWorst]))
+                nextWorst = i;
+        worstNextBestArray[WORST] = worst;
+        worstNextBestArray[NEXT_WORST] = nextWorst;
+        worstNextBestArray[BEST] = best;
+    }
+
+    // Display simplex [Iteration: s0(p1, p2....), s1(),....] in Log window
+    private synchronized void showSimplex(double[][] simp, String heading) {
+        IJ.log("Minimizer: "+heading);
+        for (int i = 0; i < numVertices; i++)
+            showVertex(simp[i], null);
+    }
+    private synchronized void showVertex(double[] vertex, String heading) {
+        if (heading != null)
+            IJ.log(heading);
+        String s = "";
+        for (int j=0; j < numParams; j++)
+            s += "  " + IJ.d2s(vertex[j], 8,12);
+        s += " -> " +  IJ.d2s(value(vertex), 8,12);
+        IJ.log(s);
+    }
+}
\ No newline at end of file
diff --git a/src/ij/measure/ResultsTable.java b/src/ij/measure/ResultsTable.java
new file mode 100644
index 0000000..aeef7d3
--- /dev/null
+++ b/src/ij/measure/ResultsTable.java
@@ -0,0 +1,1637 @@
+package ij.measure;
+import ij.*;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.frame.Editor;
+import ij.text.*;
+import ij.process.*;
+import ij.gui.Roi;
+import ij.util.Tools;
+import ij.io.*;
+import ij.macro.*;
+import java.awt.*;
+import java.text.*;
+import java.util.*;
+import java.io.*;
+import java.math.RoundingMode;
+
+
+/** This is a table for storing measurement results and strings as columns of values. 
+	Call the static ResultsTable.getResultsTable() method to get a reference to the 
+	ResultsTable used by the <i>Analyze/Measure</i> command. 
+	@see ij.plugin.filter.Analyzer#getResultsTable
+*/
+public class ResultsTable implements Cloneable {
+
+	/** Obsolete; use getLastColumn(). */
+	public static final int MAX_COLUMNS = 150;
+	
+	public static final int COLUMN_NOT_FOUND = -1;
+	public static final int COLUMN_IN_USE = -2;
+	public static final int TABLE_FULL = -3; // no longer used
+	public static final short AUTO_FORMAT = Short.MIN_VALUE;
+	private static final char commaSubstitute = 0x08B3;
+	
+	public static final int AREA=0, MEAN=1, STD_DEV=2, MODE=3, MIN=4, MAX=5,
+		X_CENTROID=6, Y_CENTROID=7, X_CENTER_OF_MASS=8, Y_CENTER_OF_MASS=9,
+		PERIMETER=10, ROI_X=11, ROI_Y=12, ROI_WIDTH=13, ROI_HEIGHT=14,
+		MAJOR=15, MINOR=16, ANGLE=17, CIRCULARITY=18, FERET=19, 
+		INTEGRATED_DENSITY=20, MEDIAN=21, SKEWNESS=22, KURTOSIS=23, 
+		AREA_FRACTION=24, RAW_INTEGRATED_DENSITY=25, CHANNEL=26, SLICE=27, FRAME=28, 
+		FERET_X=29, FERET_Y=30, FERET_ANGLE=31, MIN_FERET=32, ASPECT_RATIO=33,
+		ROUNDNESS=34, SOLIDITY=35, MIN_THRESHOLD=36, MAX_THRESHOLD=37, LAST_HEADING=37;
+	private static final String[] defaultHeadings = {"Area","Mean","StdDev","Mode","Min","Max",
+		"X","Y","XM","YM","Perim.","BX","BY","Width","Height","Major","Minor","Angle",
+		"Circ.", "Feret", "IntDen", "Median","Skew","Kurt", "%Area", "RawIntDen", "Ch", "Slice", "Frame", 
+		 "FeretX", "FeretY", "FeretAngle", "MinFeret", "AR", "Round", "Solidity", "MinThr", "MaxThr"};
+
+	private int maxRows = 100; // will be increased as needed
+	private int maxColumns = MAX_COLUMNS; // will be increased as needed
+	private String[] headings = new String[maxColumns];
+	private boolean[] keep = new boolean[maxColumns];
+	private short[] decimalPlaces = new short[maxColumns];
+	private int counter;
+	private double[][] columns = new double[maxColumns][];
+	private String[] rowLabels;
+	private int lastColumn = -1;
+	private	StringBuilder sb;
+	private short precision = 3;
+	private String rowLabelHeading = "";
+	private char delimiter = '\t';
+	private boolean headingSet; 
+	private boolean showRowNumbers;
+	private boolean showRowNumbersSet;
+	private int baseRowNumber = 1;
+	private Hashtable stringColumns;
+	private boolean NaNEmptyCells;
+	private boolean quoteCommas;
+	private String title;
+	private boolean columnDeleted;
+	private boolean renameWhenSaving;
+	private boolean saveColumnHeaders = !Prefs.dontSaveHeaders;
+
+
+	/** Constructs an empty ResultsTable with the counter=0, no columns
+		and the precision set to 3 or the "Decimal places" value in
+		Analyze/Set Measurements if that value is higher than 3. */
+	public ResultsTable() {
+		init();
+	} 
+	
+	/** Constructs a ResultsTable with 'nRows' rows. */
+	public ResultsTable(Integer nRows) {
+		init();
+		for (int i=0; i<nRows; i++)
+			incrementCounter();
+	} 
+	
+	private void init() {
+		int p = Analyzer.getPrecision();
+		if (p>precision)
+			precision = (short)p;
+		for (int i=0; i<decimalPlaces.length; i++)
+			decimalPlaces[i] = AUTO_FORMAT;
+	}
+
+	/** Returns the ResultsTable used by the Measure command. This
+		table must be displayed in the "Results" window. */
+	public static ResultsTable getResultsTable() {
+		return Analyzer.getResultsTable();
+	}
+		
+	/** Returns the ResultsTable with the specified title, or null if it does not exist, */
+	public static ResultsTable getResultsTable(String title) {
+		Frame f = WindowManager.getFrame(title);
+		if (f!=null && (f instanceof TextWindow))
+			return ((TextWindow)f).getResultsTable();
+		else
+			return null;
+	}
+	
+	/** Returns the active (front most) displayed ResultsTable. */
+	public static ResultsTable getActiveTable() {
+		ResultsTable rt = null;
+		Window win = WindowManager.getActiveTable();
+		if (win!=null && (win instanceof TextWindow)) {
+			TextPanel tp = ((TextWindow)win).getTextPanel();
+			rt = tp.getOrCreateResultsTable();
+		}
+		return rt;
+	}
+		
+	/** Obsolete. */
+	public static TextWindow getResultsWindow() {
+		Frame f = WindowManager.getFrame("Results");
+		if (f==null || !(f instanceof TextWindow))
+			return null;
+		else
+			return (TextWindow)f;
+	}
+
+	/** Adds a row to the table. */
+	public void addRow() {
+		incrementCounter();
+	}
+
+	/** Adds a row to the table. */
+	public synchronized void incrementCounter() {
+		counter++;
+		if (counter==maxRows) {
+			if (rowLabels!=null) {
+				String[] s = new String[maxRows*2];
+				System.arraycopy(rowLabels, 0, s, 0, maxRows);
+				rowLabels = s;
+			}
+			for (int i=0; i<=lastColumn; i++) {
+				if (columns[i]!=null) {
+					double[] tmp = new double[maxRows*2];
+					if (NaNEmptyCells)
+						Arrays.fill(tmp, maxRows, tmp.length, Double.NaN);
+					System.arraycopy(columns[i], 0, tmp, 0, maxRows);
+					columns[i] = tmp;
+				}
+			}
+			maxRows *= 2;
+		}
+	}
+	
+	/** Obsolete; the addValue() method automatically adds columns as needed.
+	* @see #addValue(String, double)
+	*/
+	public synchronized void addColumns() {
+		String[] tmp1 = new String[maxColumns*2];
+		System.arraycopy(headings, 0, tmp1, 0, maxColumns);
+		headings = tmp1;
+		double[][] tmp2 = new double[maxColumns*2][];
+		for (int i=0; i<maxColumns; i++)
+			tmp2[i] = columns[i];
+		columns = tmp2;
+		boolean[] tmp3 = new boolean[maxColumns*2];
+		System.arraycopy(keep, 0, tmp3, 0, maxColumns);
+		keep = tmp3;
+		short[] tmp4 = new short[maxColumns*2];
+		for (int i=0; i<tmp4.length; i++)
+			tmp4[i] = AUTO_FORMAT;
+		System.arraycopy(decimalPlaces, 0, tmp4, 0, maxColumns);
+		decimalPlaces = tmp4;
+		maxColumns *= 2;
+	}
+	
+	/** Returns the current value of the measurement counter. */
+	public int getCounter() {
+		return counter;
+	}
+	
+	/** Returns the size of this ResultsTable. */
+	public int size() {
+		return counter;
+	}
+
+	/** Adds a numeric value to the specified column, on the last
+	 * table row. Use addRow() to add another row to
+	 * the table.
+	 * @see #addRow
+	 * @see #addValue(String,double)
+	 * @see #addValue(String,String)
+	 * @see #size
+	*/
+	public void addValue(int column, double value) {
+		if (column>=maxColumns)
+			addColumns();
+		if (column<0 || column>=maxColumns)
+			throw new IllegalArgumentException("Column out of range");
+		if (counter==0)
+			incrementCounter();
+		if (columns[column]==null) {
+			columns[column] = new double[maxRows];
+			if (NaNEmptyCells)
+				Arrays.fill(columns[column], Double.NaN);
+			if (headings[column]==null)
+				headings[column] = "C"+(column+1);
+			if (column>lastColumn) lastColumn = column;
+		}
+		columns[column][counter-1] = value;
+		if (counter<25) {
+			if ((int)value!=value && !Double.isNaN(value))
+				decimalPlaces[column] = (short)precision;
+		}
+	}
+	
+	/** Adds a numeric value to the specified column, on the last
+	 * table row. If the column does not exist, it is created.
+	 * Use addRow() to add another row to the table.
+	 * <p>JavaScript example:
+	 * <pre>
+	 * rt = new ResultsTable();
+	 * for (n=0; n<=2*Math.PI; n+=0.1) {
+	 *    rt.addRow();
+	 *    rt.addValue("n", n);
+	 *    rt.addValue("Sine(n)", Math.sin(n));
+	 *    rt.addValue("Cos(n)", Math.cos(n));
+	 * }
+	 * rt.show("Sine/Cosine Table");
+	 * <pre>
+	 * @see #addRow
+	 * @see #addValue(String,String)
+	 * @see #size
+	 */
+	public void addValue(String column, double value) {
+		if (column==null)
+			throw new IllegalArgumentException("Column is null");
+		int index = getColumnIndex(column);
+		if (index==COLUMN_NOT_FOUND)
+			index = getFreeColumn(column);
+		addValue(index, value);
+		keep[index] = true;
+	}
+	
+	/** Adds a string value to the specified column, on the last
+	 * table row. If the column does not exist, it is created.
+	 * Use addRow() to add another row to the table.
+	 * @see #addRow
+	 * @see #addValue(String,double)
+	 * @see #size
+	 */
+	public void addValue(String column, String value) {
+		if (column==null)
+			throw new IllegalArgumentException("Column is null");
+		int index = getColumnIndex(column);
+		if (index==COLUMN_NOT_FOUND)
+			index = getFreeColumn(column);
+		addValue(index, Double.NaN);
+		setValue(column, size()-1, value);
+		keep[index] = true;
+	}
+
+	/** Adds a label to the beginning of the current row. */
+	public void addLabel(String label) {
+		if (rowLabelHeading.equals(""))
+			rowLabelHeading = "Label";
+		addLabel(rowLabelHeading, label);
+	}
+
+	/**
+	 * @deprecated
+	 * Replaced by setValue(String,int,String)
+	*/
+	public void addLabel(String columnHeading, String label) {
+		if (counter==0)
+			throw new IllegalArgumentException("Counter==0");
+		if (rowLabels==null)
+			rowLabels = new String[maxRows];
+		rowLabels[counter-1] = label;
+		if (columnHeading!=null)
+			rowLabelHeading = columnHeading;
+	}
+	
+	/** Adds a label to the beginning of the specified row, 
+		or updates an existing lable, where 0<=row<size().
+		After labels are added or modified, call <code>show()</code>
+		to update the window displaying the table. */
+	public void setLabel(String label, int row) {
+		if (row<0||row>=counter)
+			throw new IllegalArgumentException("row>=counter");
+		if (rowLabels==null)
+			rowLabels = new String[maxRows];
+		if (rowLabelHeading.equals(""))
+			rowLabelHeading = "Label";
+		rowLabels[row] = label;
+	}
+	
+	/** Set the row label column to null if the column label is "Label". */
+	public void disableRowLabels() {
+		if (rowLabelHeading.equals("Label"))
+			rowLabels = null;
+	}
+	
+	/** Returns a copy of the given column as a double array,
+		or null if the column is not found. */
+	public double[] getColumn(String column) {
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND || columns[col]==null)
+			throw new IllegalArgumentException("\""+column+"\" column not found");
+		return getColumnAsDoubles(col);
+	}
+
+	/** Returns a copy of the given column as a String array,
+		or null if the column is not found. */
+	public String[] getColumnAsStrings(String column) {
+		String[] array = new String[size()];
+		if ("Label".equals(column) && rowLabels!=null) {
+			for (int i=0; i<size(); i++)
+				array[i] = getLabel(i);
+			return array;
+		}
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND || columns[col]==null)
+			throw new IllegalArgumentException("\""+column+"\" column not found");
+		for (int i=0; i<size(); i++)
+			array[i] = getStringValue(col, i);
+		return array;
+	}
+
+	/** Returns a copy of the given column as a float array,
+		or null if the column is empty. */
+	public float[] getColumn(int column) {
+		if ((column<0) || (column>=maxColumns))
+			throw new IllegalArgumentException("Index out of range: "+column);
+		if (columns[column]==null)
+			return null;
+		else {
+			float[] data = new float[counter];
+			for (int i=0; i<counter; i++)
+				data[i] = (float)columns[column][i];
+			return data;
+		}
+	}
+	
+	/** Returns a copy of the given column as a double array,
+		or null if the column is empty. */
+	public double[] getColumnAsDoubles(int column) {
+		if ((column<0) || (column>=maxColumns))
+			throw new IllegalArgumentException("Index out of range: "+column);
+		if (columns[column]==null)
+			return null;
+		else {
+			double[] data = new double[counter];
+			for (int i=0; i<counter; i++)
+				data[i] = columns[column][i];
+			return data;
+		}
+	}
+	
+	/** Returns the contents of this ResultsTable as a FloatProcessor. */
+	public ImageProcessor getTableAsImage() {
+		FloatProcessor fp = null;
+		int columns = 0;
+		int[] col = new int[lastColumn+1];
+		for (int i=0; i<=lastColumn; i++) {
+			if (columnExists(i)) {
+				col[columns] = i;
+				columns++;
+			}
+		}
+		if (columns==0) return null;
+		int rows = size();
+		if (rows==0) return null;
+		fp = new FloatProcessor(columns, rows);
+		for (int x=0; x<columns; x++) {
+			for (int y=0; y<rows; y++)
+				fp.setf(x,y,(float)getValueAsDouble(col[x],y));
+		}
+		return fp;
+	}
+	
+	/** Creates a ResultsTable from an image or image selection. */
+	public static ResultsTable createTableFromImage(ImageProcessor ip) {
+		ResultsTable rt = new ResultsTable();
+		Rectangle r = ip.getRoi();
+		for (int y=r.y; y<r.y+r.height; y++) {
+			rt.incrementCounter();
+			rt.addLabel(" ", "Y"+y);
+			for (int x=r.x; x<r.x+r.width; x++)
+				rt.addValue("X"+x, ip.getPixelValue(x,y));
+		}
+		return rt;
+	}
+
+	/** Returns true if the specified column exists and is not empty. */
+	public boolean columnExists(int column) {
+		if ((column<0) || (column>=maxColumns))
+			return false;
+		else
+			return columns[column]!=null;
+	}
+
+	/** Returns the index of the first column with the given heading.
+		heading. If not found, returns COLUMN_NOT_FOUND. */
+	public int getColumnIndex(String heading) {
+		for (int i=0; i<headings.length; i++) {
+			if (headings[i]==null)
+				return COLUMN_NOT_FOUND;
+			else if (headings[i].equals(heading))
+				return i;
+		}
+		return COLUMN_NOT_FOUND;
+	}
+	
+	/** Sets the heading of the the first available column and
+		returns that column's index. Returns COLUMN_IN_USE
+		 if this is a duplicate heading. */
+	public int getFreeColumn(String heading) {
+		for(int i=0; i<headings.length; i++) {
+			if (headings[i]==null) {
+				columns[i] = new double[maxRows];
+				if (NaNEmptyCells)
+					Arrays.fill(columns[i], Double.NaN);
+				headings[i] = heading;
+				if (i>lastColumn) lastColumn = i;
+				return i;
+			}
+			if (headings[i].equals(heading))
+				return COLUMN_IN_USE;
+		}
+		addColumns();
+		lastColumn++;
+		columns[lastColumn] = new double[maxRows];
+		if (NaNEmptyCells)
+			Arrays.fill(columns[lastColumn], Double.NaN);
+		headings[lastColumn] = heading;
+		return lastColumn;
+	}
+	
+	/**	Returns the value of the given column and row, where
+		column must be less than or equal the value returned by
+		getLastColumn() and row must be greater than or equal
+		zero and less than the value returned by size(). */
+	public double getValueAsDouble(int column, int row) {
+		if (column>=maxColumns || row>=counter)
+			throw new IllegalArgumentException("Index out of range: "+column+","+row);
+		if (columns[column]==null)
+			throw new IllegalArgumentException("Column not defined: "+column);
+		return columns[column][row];
+	}
+	
+	/**
+	* @deprecated
+	* replaced by getValueAsDouble
+	*/
+	public float getValue(int column, int row) {
+		return (float)getValueAsDouble(column, row);
+	}
+
+	/**	Returns the value of the specified column and row, where
+		column is the column heading and row is a number greater
+		than or equal zero and less than value returned by size(). 
+		Throws an IllegalArgumentException if this ResultsTable
+		does not have a column with the specified heading. */
+	public double getValue(String column, int row) {
+		if (row<0 || row>=size())
+			throw new IllegalArgumentException("Row out of range");
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND)
+			throw new IllegalArgumentException("\""+column+"\" column not found");
+		//IJ.log("col: "+col+" "+(col==COLUMN_NOT_FOUND?"not found":""+columns[col]));
+		return getValueAsDouble(col,row);
+	}
+	
+	/** Returns 'true' if the specified column exists and is not emptly. */
+	public boolean columnExists(String column) {
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND)
+			return false;
+		else
+			return (col<columns.length && columns[col]!=null);
+	}
+
+	/** Returns the string value of the given column and row,
+		where row must be greater than or equal zero
+		and less than the value returned by size(). */
+	public String getStringValue(String column, int row) {
+		if (row<0 || row>=size())
+			throw new IllegalArgumentException("Row out of range");
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND) {
+			String label = null;
+			if ("Label".equals(column))
+				label = getLabel(row);
+			if (label!=null)
+				return label;
+			else
+				throw new IllegalArgumentException("\""+column+"\" column not found");
+		}
+		return getStringValue(col, row);
+	}
+
+	/** Returns the string value of the given column and row, where
+		column must be less than or equal the value returned by
+		getLastColumn() and row must be greater than or equal
+		zero and less than the value returned by size(). */
+	public String getStringValue(int column, int row) {
+		if (column>=maxColumns || row>=counter)
+			throw new IllegalArgumentException("Index out of range: "+column+","+row);
+		if (columns[column]==null)
+			throw new IllegalArgumentException("Column not defined: "+column);
+		return getValueAsString(column, row);
+	}
+
+	/**	 Returns the label of the specified row. Returns null if the row does not have a label. */
+	public String getLabel(int row) {
+		if (row<0 || row>=size())
+			throw new IllegalArgumentException("Row out of range");
+		String label = null;
+		if (rowLabels!=null && rowLabels[row]!=null)
+				label = rowLabels[row];
+		return label;
+	}
+
+	/** Sets the value of the given column and row, where
+		where 0&lt;=row&lt;size(). If the specified column does 
+		not exist, it is created. When adding columns, 
+		<code>show()</code> must be called to update the 
+		window that displays the table.*/
+	public void setValue(String column, int row, double value) {
+		if (column==null)
+			throw new IllegalArgumentException("Column is null");
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND)
+			col = getFreeColumn(column);
+		setValue(col, row, value);
+	}
+
+	/** Sets the value of the given column and row, where
+		where 0&lt;=column&lt;=(lastRow+1 and 0&lt;=row&lt;=size(). */
+	public void setValue(int column, int row, double value) {
+		if (column>=maxColumns)
+			addColumns();
+		if (column<0 || column>=maxColumns)
+			throw new IllegalArgumentException("Column out of range");
+		if (row>=counter) {
+			if (row==counter)
+				incrementCounter();
+			else
+				throw new IllegalArgumentException("row>counter");
+		}
+		if (columns[column]==null) {
+			columns[column] = new double[maxRows];
+			if (NaNEmptyCells)
+				Arrays.fill(columns[column], Double.NaN);
+			if (column>lastColumn) lastColumn = column;
+		}
+		columns[column][row] = value;
+		if (headings[column]==null)
+			headings[column] = "C"+(column+1);
+		if ((int)value!=value && !Double.isNaN(value))
+			decimalPlaces[column] = (short)precision;
+	}
+
+	/** Sets the string value of the given column and row, where
+		where 0&lt;=row&lt;size(). If the specified column does 
+		not exist, it is created. When adding columns, 
+		<code>show()</code> must be called to update the 
+		window that displays the table.*/
+	public void setValue(String column, int row, String value) {
+		if (column==null)
+			throw new IllegalArgumentException("Column is null");
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND)
+			col = getFreeColumn(column);
+		setValue(col, row, value);
+	}
+
+	/** Sets the string value of the given column and row, where
+		where 0&lt;=column&lt;=(lastRow+1 and 0&lt;=row&lt;=size(). */
+	public void setValue(int column, int row, String value) {
+		setValue(column, row, Double.NaN);
+		if (stringColumns==null)
+			stringColumns = new Hashtable();
+		ArrayList stringColumn = (ArrayList)stringColumns.get(new Integer(column));
+		if (stringColumn==null) {
+			stringColumn = new ArrayList();
+			stringColumns.put(new Integer(column), stringColumn);
+		}
+		int size = stringColumn.size();
+		if (row>=size) {
+			for (int i=size; i<row; i++)
+				stringColumn.add(i, "");
+		}
+		if (row==stringColumn.size())
+			stringColumn.add(row, value);
+		else
+			stringColumn.set(row, value);
+	}
+
+	/** Returns a tab or comma delimited string containing the column headings. */
+	public String getColumnHeadings() {
+		if (headingSet && !rowLabelHeading.equals("")) { // workaround setHeading() bug
+			for (int i=0; i<=lastColumn; i++) {
+				if (columns[i]!=null && rowLabelHeading.equals(headings[i]))
+					{headings[i]=null; columns[i]=null;}
+			}
+			headingSet = false;
+		}
+		StringBuilder sb = new StringBuilder(200);
+		if (showRowNumbers)
+			sb.append(" "+delimiter);
+		if (rowLabels!=null)
+			sb.append(rowLabelHeading + delimiter);
+		String heading;
+		for (int i=0; i<=lastColumn; i++) {
+			if (columns[i]!=null) {
+				heading = headings[i];
+				if (heading==null) heading ="C"+(i+1); 
+				sb.append(heading);
+				if (i!=lastColumn) sb.append(delimiter);
+			}
+		}
+		return new String(sb);
+	}
+
+	/** Returns the column headings as an array of Strings. */
+	public String[] getHeadings() {
+		int n = 0;
+		if (rowLabels!=null)
+			n++;
+		for (int i=0; i<=lastColumn; i++)
+			if (columns[i]!=null) n++;
+		String[] temp = new String[n];
+		int index = 0;
+		if (rowLabels!=null)
+			temp[index++] = rowLabelHeading;
+		String heading;
+		for (int i=0; i<=lastColumn; i++) {
+			if (columns[i]!=null) {
+				heading = headings[i];
+				if (heading==null) heading ="C"+(i+1); 
+				temp[index++] = heading;
+			}
+		}
+		return temp;
+	}
+
+	/** Returns the heading of the specified column or null if the column is empty. */
+	public String getColumnHeading(int column) {
+		if ((column<0) || (column>=maxColumns))
+			throw new IllegalArgumentException("Index out of range: "+column);
+		return headings[column];
+	}
+
+	/** Returns a tab or comma delimited string representing the
+		given row, where 0<=row<=size()-1. */
+	public String getRowAsString(int row) {
+		if ((row<0) || (row>=counter))
+			throw new IllegalArgumentException("Row out of range: "+row);
+		if (sb==null)
+			sb = new StringBuilder(200);
+		else
+			sb.setLength(0);
+		if (showRowNumbers) {
+			sb.append(Integer.toString(row+baseRowNumber));
+			sb.append(delimiter);
+		}
+		if (rowLabels!=null) {
+			if (rowLabels[row]!=null) {
+				String label = rowLabels[row];
+				if (delimiter==',')
+					label = label.replaceAll(",", ";");
+				sb.append(label);
+			}
+			sb.append(delimiter);
+		}
+		for (int i=0; i<=lastColumn; i++) {
+			if (columns[i]!=null) {
+				String value = getValueAsString(i,row);
+				if (quoteCommas) {
+					if (value!=null && value.contains(","))
+						value = "\""+value+"\"";
+				}
+				sb.append(value);
+				if (i!=lastColumn)
+					sb.append(delimiter);
+			}
+		}
+		return new String(sb);
+	}
+	
+	/** Implements the Table.getColumn() macro function. */
+	public Variable[] getColumnAsVariables(String column) {
+		if ("Label".equals(column) && rowLabels!=null) {
+			int n = size();
+			Variable[] labels = new Variable[n];
+			for (int i=0; i<n; i++) {
+				String label = getLabel(i);
+				labels[i] = new Variable(label!=null?label:"");
+			}
+			return labels;
+		}
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND || columns[col]==null)
+			throw new IllegalArgumentException("\""+column+"\" column not found");
+		boolean firstValueNumeric = true;
+		int nValues = size();
+		Variable[] values = new Variable[nValues];
+		for (int row=0; row<size(); row++) {
+			double value = columns[col][row];
+			String str = null;
+			if (Double.isNaN(value) && stringColumns!=null) {
+				ArrayList stringColumn = (ArrayList)stringColumns.get(new Integer(col));
+				if (stringColumn!=null && row>=0 && row<stringColumn.size()) {
+						str = (String)stringColumn.get(row);
+						if (firstValueNumeric && "".equals(str)) {
+							nValues = row;
+							break;
+						}
+				}
+			}
+			if (str!=null)
+				values[row] = new Variable(str);
+			else {
+				values[row] = new Variable(value);
+				if (row==0) firstValueNumeric=true;
+			}
+		}
+		if (nValues<values.length) {
+			Variable[] values2 = new Variable[nValues];
+			for (int i=0; i<nValues; i++)
+				values2[i] = values[i];
+			values = values2;
+		}
+		return values;
+	}
+	
+	/** Implements the Table.setColumn() macro function. */
+	public void setColumn(String column, Variable[] array) {
+		if (column==null)
+			return;
+		int initialSize = size();
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND)
+			col = getFreeColumn(column);
+		for (int i=0; i<array.length; i++) {
+			if (array[i].getString()!=null)
+				setValue(col, i, array[i].getString());
+			else
+				setValue(col, i, array[i].getValue());
+		}
+		if (array.length<size()) {
+			for (int i=array.length; i<size(); i++)
+				setValue(col, i, "");
+		}
+		if (initialSize>0 && size()>initialSize) {
+			for (int c=0; c<=lastColumn; c++) {
+				if (c!=col && columns[c]!=null) {
+					String heading = headings[c];
+					if (heading!=null) {
+						for (int i=initialSize; i<size(); i++)
+							setValue(c, i, "");
+					}
+				}
+			}
+		}
+	}
+		
+	private String getValueAsString(int column, int row) { 
+		double value = columns[column][row];
+		//IJ.log("getValueAsString1: col="+column+ ", row= "+row+", value= "+value+", size="+stringColumns.size());
+		if (Double.isNaN(value) && stringColumns!=null) {
+			String string = "NaN";
+			ArrayList stringColumn = (ArrayList)stringColumns.get(new Integer(column));
+			if (stringColumn==null)
+				return string;
+			//IJ.log("getValueAsString2: "+column+ +row+" "+stringColumn.size());
+			if (row>=0 && row<stringColumn.size()) {
+				string = (String)stringColumn.get(row);
+				if (string!=null && string.contains("\n"))
+					string = string.replaceAll("\n", "\\\\n");
+				return string;
+			} else
+				return string;
+		} else {
+			int places = decimalPlaces[column];
+			if (places==AUTO_FORMAT)
+				return n(value);
+			else
+				return d2s(value, places);
+		}
+	}
+	
+	private String n(double n) {
+		String s;
+		if ((int)n==n && precision>=0)
+			s = d2s(n, 0);
+		else
+			s = d2s(n, precision);
+		return s;
+	}
+		
+	/**
+	* @deprecated
+	* Replaced by addValue(String,double) and setValue(String,int,double)
+	*/
+	public void setHeading(int column, String heading) {
+		if ((column<0) || (column>=headings.length))
+			throw new IllegalArgumentException("Column out of range: "+column);
+		headings[column] = heading;
+		if (columns[column]==null) {
+			columns[column] = new double[maxRows];
+			if (NaNEmptyCells)
+				Arrays.fill(columns[column], Double.NaN);
+		}
+		if (column>lastColumn) lastColumn = column;
+		headingSet = true;
+	}
+	
+	/** Sets the headings used by the Measure command ("Area", "Mean", etc.). */
+	public void setDefaultHeadings() {
+		for(int i=0; i<defaultHeadings.length; i++)
+				headings[i] = defaultHeadings[i];
+		showRowNumbers(true);
+	}
+
+	/** Sets the decimal places (digits to the right of decimal point)
+		that are used when this table is displayed. */
+	public synchronized void setPrecision(int precision) {
+		if (precision>9) precision=9;
+		this.precision = (short)precision;
+		for (int i=0; i<decimalPlaces.length; i++) {
+			if (decimalPlaces[i]!=AUTO_FORMAT)
+				decimalPlaces[i] = (short)precision;
+		}
+	}
+	
+	public void setDecimalPlaces(int column, int digits) {
+		if ((column<0) || (column>=headings.length))
+			throw new IllegalArgumentException("Column out of range: "+column);
+		decimalPlaces[column] = (short)digits;
+	}
+
+	/** Set 'true' to initially fill data arrays with NaNs instead of zeros. */
+	public void setNaNEmptyCells(boolean NaNEmptyCells) {
+		this.NaNEmptyCells = NaNEmptyCells;
+	}
+
+	public void showRowNumbers(boolean showNumbers) {
+		showRowNumbers = showNumbers;
+		baseRowNumber = 1;
+		showRowNumbersSet = true;
+	}
+
+	public boolean showRowNumbers() {
+		return showRowNumbers;
+	}
+
+	public void showRowIndexes(boolean showIndexes) {
+		showRowNumbers = showIndexes;
+		baseRowNumber = showIndexes?0:1;
+	}
+
+	public void saveColumnHeaders(boolean save) {
+		saveColumnHeaders = save;
+	}
+
+	private static DecimalFormat[] df;
+	private static DecimalFormat[] sf;
+	private static DecimalFormatSymbols dfs;
+
+	/** This is a version of IJ.d2s() that uses scientific notation for
+		small numbes that would otherwise display as zero. */
+	public static String d2s(double n, int decimalPlaces) {
+		if (Double.isNaN(n)||Double.isInfinite(n))
+			return ""+n;
+		if (n==Float.MAX_VALUE) // divide by 0 in FloatProcessor
+			return "3.4e38";
+		double np = n;
+		if (n<0.0) np = -n;
+		if ((np<0.001 && np!=0.0 && np<1.0/Math.pow(10,decimalPlaces)) || np>999999999999d || decimalPlaces<0) {
+			if (decimalPlaces<0) {
+				decimalPlaces = -decimalPlaces;
+				if (decimalPlaces>9) decimalPlaces=9;
+			} else
+				decimalPlaces = 3;
+			if (sf==null) {
+				if (dfs==null)
+					dfs = new DecimalFormatSymbols(Locale.US);
+				sf = new DecimalFormat[10];
+				sf[1] = new DecimalFormat("0.0E0",dfs);
+				sf[2] = new DecimalFormat("0.00E0",dfs);
+				sf[3] = new DecimalFormat("0.000E0",dfs);
+				sf[4] = new DecimalFormat("0.0000E0",dfs);
+				sf[5] = new DecimalFormat("0.00000E0",dfs);
+				sf[6] = new DecimalFormat("0.000000E0",dfs);
+				sf[7] = new DecimalFormat("0.0000000E0",dfs);
+				sf[8] = new DecimalFormat("0.00000000E0",dfs);
+				sf[9] = new DecimalFormat("0.000000000E0",dfs);
+			}
+			return sf[decimalPlaces].format(n); // use scientific notation
+		}
+		if (decimalPlaces<0) decimalPlaces = 0;
+		if (decimalPlaces>9) decimalPlaces = 9;
+		if (df==null) {
+			dfs = new DecimalFormatSymbols(Locale.US);
+			df = new DecimalFormat[10];
+			df[0] = new DecimalFormat("0", dfs);
+			df[1] = new DecimalFormat("0.0", dfs);
+			df[2] = new DecimalFormat("0.00", dfs);
+			df[3] = new DecimalFormat("0.000", dfs);
+			df[4] = new DecimalFormat("0.0000", dfs);
+			df[5] = new DecimalFormat("0.00000", dfs);
+			df[6] = new DecimalFormat("0.000000", dfs);
+			df[7] = new DecimalFormat("0.0000000", dfs);
+			df[8] = new DecimalFormat("0.00000000", dfs);
+			df[9] = new DecimalFormat("0.000000000", dfs);
+			df[0].setRoundingMode(RoundingMode.HALF_UP);
+		}
+		return df[decimalPlaces].format(n);
+	}
+
+	/** Deletes the specified row. */
+	public synchronized void deleteRow(int rowIndex) {
+		if (counter==0 || rowIndex<0 || rowIndex>counter-1)
+			return;
+		if (rowLabels!=null) {
+			rowLabels[rowIndex] = null;
+			for (int i=rowIndex; i<counter-1; i++)
+				rowLabels[i] = rowLabels[i+1];
+		}
+		for (int col=0; col<=lastColumn; col++) {
+			if (columns[col]!=null) {
+				for (int i=rowIndex; i<counter-1; i++)
+					columns[col][i] = columns[col][i+1];
+				ArrayList stringColumn = stringColumns!=null?(ArrayList)stringColumns.get(new Integer(col)):null;
+				if (stringColumn!=null && stringColumn.size()==counter) {
+					for (int i=rowIndex; i<counter-1; i++)
+						stringColumn.set(i,stringColumn.get(i+1));
+					stringColumn.remove(counter-1);
+				}
+			}
+		}
+		counter--;
+	}
+	
+	/** Deletes the specified rows. */
+	public void deleteRows(int index1, int index2) {
+		if (index1<0) index1=0;
+		int n = index2 - index1 + 1;
+		for (int i=index1; i<index1+n; i++)
+			deleteRow(index1);
+	}
+	
+	/** Deletes the specified column. */
+	public void deleteColumn(String column) {
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND)
+			throw new IllegalArgumentException("\""+column+"\" column not found");
+		columns[col] = null;
+		headings[col] = "-";
+		columnDeleted = true;
+	}
+
+	/** Changes the name of a column. */
+	public void renameColumn(String oldName, String newName) {
+		int oldCol = getColumnIndex(oldName);
+		if (oldCol==COLUMN_NOT_FOUND)
+			throw new IllegalArgumentException("\""+oldName+"\" column not found");
+		int newCol = getColumnIndex(newName);
+		if (columnExists(newCol))
+			throw new IllegalArgumentException("\""+newName+"\" column exists");
+		headings[oldCol] = newName;
+	}
+
+	public synchronized void reset() {
+		counter = 0;
+		maxRows = 100;
+		for (int i=0; i<maxColumns; i++) {
+			columns[i] = null;
+			headings[i] = null;
+			keep[i] = false;
+			decimalPlaces[i] = AUTO_FORMAT;
+		}
+		lastColumn = -1;
+		rowLabels = null;
+		stringColumns = null;
+		columnDeleted = false;
+	}
+	
+	/** Returns the index of the last used column, or -1 if no columns are used. */
+	public int getLastColumn() {
+		return lastColumn;
+	}
+
+	/** Adds the last row in this table to the Results window without updating it. */
+	public void addResults() {
+		if (counter==1)
+			IJ.setColumnHeadings(getColumnHeadings());		
+		TextPanel textPanel = IJ.getTextPanel();
+		String s = getRowAsString(counter-1);
+		if (textPanel!=null)
+				textPanel.appendWithoutUpdate(s);
+		else
+			System.out.println(s);
+	}
+
+	/** Updates the Results window. */
+	public void updateResults() {
+		TextPanel textPanel = IJ.getTextPanel();
+		if (textPanel!=null) {
+			textPanel.updateColumnHeadings(getColumnHeadings());		
+			textPanel.updateDisplay();
+		}
+	}
+	
+	/** Displays the contents of this ResultsTable in a window with 
+		the specified title, or updates an existing results window. Opens
+		a new window if there is no open text window with this title. 
+		The title must be "Results" if this table was obtained using 
+		ResultsTable.getResultsTable() or Analyzer.getResultsTable . */
+	public void show(String windowTitle) {
+		if  (GraphicsEnvironment.isHeadless())
+			return; // Tables can't be displayed in headless mode
+		if (windowTitle==null)
+			windowTitle = "Results";
+		title = windowTitle;
+		if (!windowTitle.equals("Results") && this==Analyzer.getResultsTable())
+			IJ.log("ResultsTable.show(): the system ResultTable should only be displayed in the \"Results\" window.");
+		if (windowTitle.equals("Results") && !showRowNumbersSet)
+			showRowNumbers(true);
+		String tableHeadings = getColumnHeadings();		
+		TextPanel tp;
+		boolean newWindow = false;
+		boolean cloneNeeded = false;
+		if (windowTitle.equals("Results")) {
+			tp = IJ.getTextPanel();
+			if (tp==null) return;
+			newWindow = tp.getLineCount()==0;
+			if (!newWindow && tp.getLineCount()==size()-1 && ResultsTable.getResultsTable()==this
+			&& tp.getColumnHeadings().equals(tableHeadings)) {
+				String s = getRowAsString(size()-1);
+				tp.append(s);
+				return;
+			}
+			IJ.setColumnHeadings(tableHeadings);
+			if (this!=Analyzer.getResultsTable())
+				Analyzer.setResultsTable(this);
+			if (size()>0)
+				Analyzer.setUnsavedMeasurements(true);
+		} else {
+			Frame frame = WindowManager.getFrame(windowTitle);
+			TextWindow win;
+			if (frame!=null && frame instanceof TextWindow) {
+				win = (TextWindow)frame;
+				if (win!=null) {
+					win.toFront();
+					WindowManager.setWindow(frame);
+				}
+			} else {
+				int chars = Math.max(size()>0?getRowAsString(0).length():15, getColumnHeadings().length());
+				int width = 100 + chars*10;
+				if (width<180) width=180;
+				if (width>700) width=700;
+				if (showRowNumbers)
+					width += 50;
+				int height = 300;
+				if (size()>15) height = 400;
+				if (size()>30 && width>300) height = 500;
+				win = new TextWindow(windowTitle, "", width, height);
+				cloneNeeded = true;
+			}
+			tp = win.getTextPanel();
+			tp.setColumnHeadings(tableHeadings);
+			newWindow = tp.getLineCount()==0;
+		}
+		tp.setResultsTable(cloneNeeded?(ResultsTable)this.clone():this);
+		int n = size();
+		if (n>0) {
+			if (tp.getLineCount()>0) tp.clear();
+			for (int i=0; i<n; i++)
+				tp.appendWithoutUpdate(getRowAsString(i));
+			tp.updateDisplay();
+		}
+		if (newWindow) tp.scrollToTop();
+	}
+	
+	public void update(int measurements, ImagePlus imp, Roi roi) {
+		if (roi==null && imp!=null) roi = imp.getRoi();
+		ResultsTable rt2 = new ResultsTable();
+		Analyzer analyzer = new Analyzer(imp, measurements, rt2);
+		ImageProcessor ip = new ByteProcessor(1, 1);
+		ImageStatistics stats = new ByteStatistics(ip, measurements, null);
+		analyzer.saveResults(stats, roi);
+		//IJ.log(rt2.getColumnHeadings());
+		int last = rt2.getLastColumn();
+		//IJ.log("update1: "+last+"  "+getMaxColumns());
+		while (last+1>=getMaxColumns()) {
+			addColumns();
+		//IJ.log("addColumns: "+getMaxColumns());
+		}
+		if (last<getLastColumn()) {
+			last=getLastColumn();
+			if (last>=rt2.getMaxColumns())
+				last = rt2.getMaxColumns() - 1;
+		}
+		for (int i=0; i<=last; i++) {
+			//IJ.log(i+"  "+rt2.getColumn(i)+"  "+columns[i]+"  "+rt2.getColumnHeading(i)+"  "+getColumnHeading(i));
+			if (rt2.getColumn(i)!=null && columns[i]==null) {
+				columns[i] = new double[maxRows];
+				if (NaNEmptyCells)
+					Arrays.fill(columns[i], Double.NaN);
+				headings[i] = rt2.getColumnHeading(i);
+				if (i>lastColumn) lastColumn = i;
+			} else if (rt2.getColumn(i)==null && columns[i]!=null && !keep[i])
+				columns[i] = null;
+		}
+		if (rt2.getRowLabels()==null)
+			rowLabels = null;
+		else if (rt2.getRowLabels()!=null && rowLabels==null) {
+			rowLabels = new String[maxRows];
+			rowLabelHeading = "Label";
+		}
+		if (size()>0) show("Results");
+	}
+	
+	int getMaxColumns() {
+		return maxColumns;
+	}
+	
+	String[] getRowLabels() {
+		return rowLabels;
+	}
+	
+	/** Opens a tab or comma delimited text file and returns it 
+	* as a ResultsTable, without requiring a try/catch statement.
+	* Displays a file open dialog if 'path' is empty or null.
+	*/
+	public static ResultsTable open2(String path) {
+		ResultsTable rt = null;
+		try {
+			rt = open(path);
+		} catch (IOException e) {
+			IJ.error("Open Results", e.getMessage());
+			rt = null;
+		}
+		return rt;
+	}
+	
+	/** Opens a tab or comma delimited text file and returns it as a 
+	* ResultsTable. Displays a file open dialog if 'path' is empty or null.
+	* @see #open2(String)
+	*/
+	public static ResultsTable open(String path) throws IOException {
+		final String lineSeparator =  "\n";
+		if (path==null || path.equals("")) {
+			OpenDialog od = new OpenDialog("Open Table", "");
+			String dir = od.getDirectory();
+			String name = od.getFileName();
+			if (name==null)
+				return null;
+			path = dir+name;
+		}
+		String text = IJ.openAsString(path);
+		if (text==null)
+			return null;
+		if (text.length()==0)
+			return new ResultsTable();
+		if (text.startsWith("Error:"))
+			throw new IOException("Error opening "+path);
+		boolean csv = path.endsWith(".csv") || path.endsWith(".CSV");
+		String cellSeparator =  csv?",":"\t";
+		boolean commasReplaced = false;
+		if (csv && text.contains("\"")) {
+			text = replaceQuotedCommas(text);
+			commasReplaced = true;
+		}
+		String commaSubstitute2 = ""+commaSubstitute;
+		String[] lines = text.split(lineSeparator);
+		if (lines.length==0 || (lines.length==1 && lines[0].length()==0))
+			throw new IOException("Table is empty or invalid");
+		String[] headings = lines[0].split(cellSeparator);
+		if (headings.length<1)
+			throw new IOException("This is not a tab or comma delimited text file.");
+		int numbersInHeadings = 0;
+		for (int i=0; i<headings.length; i++) {
+			if (headings[i].equals("NaN") || !Double.isNaN(Tools.parseDouble(headings[i])))
+				numbersInHeadings++;
+		}
+		boolean allNumericHeadings = numbersInHeadings==headings.length;
+		if (allNumericHeadings) {
+			for (int i=0; i<headings.length; i++)
+				headings[i] = "C"+(i+1);
+		}
+		int firstColumn = headings.length>0&&headings[0].equals(" ")?1:0;
+		for (int i=0; i<headings.length; i++) {
+			headings[i] = headings[i].trim();
+			if (commasReplaced) {
+				if (headings[i].startsWith("\"") && headings[i].endsWith("\""))
+					headings[i] = headings[i].substring(1, headings[i].length()-1);
+			}
+		}
+		int firstRow = allNumericHeadings?0:1;
+		boolean labels = firstColumn==1 && headings[1].equals("Label");
+		int type=getTableType(path, lines, firstRow, cellSeparator);
+		//if (!labels && (type==1||type==2))
+		//	labels = true;
+		int labelsIndex = (type==2)?0:1;
+		if (lines[0].startsWith("\t")) {
+			String[] headings2 = new String[headings.length+1];
+			headings2[0] = " ";
+			for (int i=0; i<headings.length; i++)
+				headings2[i+1] = headings[i];
+			headings = headings2;
+			firstColumn = 1;
+		}
+		ResultsTable rt = new ResultsTable();
+		if (firstRow>=lines.length) { //empty table?
+			for (int i=0; i<headings.length; i++) {
+				if (headings[i]==null) continue;
+				int col = rt.getColumnIndex(headings[i]);
+				if (col==COLUMN_NOT_FOUND)
+					col = rt.getFreeColumn(headings[i]);
+			}
+			return rt;
+		}
+		rt.showRowNumbers(path.contains("Results"));
+		for (int i=firstRow; i<lines.length; i++) {
+			rt.incrementCounter();
+			String[] items = lines[i].split(cellSeparator);
+			for (int j=firstColumn; j<headings.length; j++) {
+				if (j==labelsIndex&&labels)
+					rt.addLabel(headings[labelsIndex], items[labelsIndex]);
+				else {
+					double defaultValue = -Double.MAX_VALUE;
+					double value = j<items.length?Tools.parseDouble(items[j], defaultValue):Double.NaN;
+					if (value==defaultValue) {
+						String item = j<items.length?items[j]:"";
+						if (commasReplaced) {
+							item = item.replaceAll(commaSubstitute2, ",");
+							if (item.startsWith("\"") && item.endsWith("\""))
+								item = item.substring(1, item.length()-1);
+						}
+						rt.addValue(headings[j], item);
+					} else
+						rt.addValue(headings[j], value);
+				}
+			}
+		}
+		return rt;
+	}
+	
+	private static int getTableType(String path, String[] lines, int firstRow, String cellSeparator) {
+		if (lines.length<2) return 0;
+		String[] items=lines[1].split(cellSeparator);
+		int nonNumericCount = 0;
+		int nonNumericIndex = 0;
+		for (int i=0; i<items.length; i++) {
+			if (!items[i].equals("NaN") && Double.isNaN(Tools.parseDouble(items[i]))) {
+				nonNumericCount++;
+				nonNumericIndex = i;
+			}
+		}
+		boolean csv = path.endsWith(".csv");
+		if (nonNumericCount==0)
+			return 0; // assume this is all-numeric table
+		if (nonNumericCount==1 && nonNumericIndex==1)
+			return 1; // assume this is an ImageJ Results table with row numbers and row labels
+		if (nonNumericCount==1 && nonNumericIndex==0)
+			return 2; // assume this is an ImageJ Results table without row numbers and with row labels
+		return 3;
+	}
+	
+	private static String replaceQuotedCommas(String text) {
+		char[] c = text.toCharArray();
+		boolean inQuotes = false;
+		for (int i=0; i<c.length; i++) {
+			if (c[i]=='"')
+				inQuotes = !inQuotes;
+			if (inQuotes && c[i]==',')
+				c[i] = commaSubstitute;
+		}
+		return new String(c);
+	}
+	
+	/** Saves this ResultsTable as a tab or comma delimited text file. The table
+	     is saved as a CSV (comma-separated values) file if 'path' ends with ".csv".
+	     Displays a file save dialog if 'path' is empty or null. Does nothing if the
+	     table is empty. Displays an error message and returns 'false' if there is
+	     an error. */
+	public boolean save(String path) {
+		try {
+			saveAs(path);
+			return true;
+		} catch (IOException e) {
+			delimiter = '\t';
+			IJ.error("Save As>Results", ""+"Error saving results:\n   "+e.getMessage());
+			return false;
+		}
+	}
+
+	public boolean saveAndRename(String path) {
+		if (!"Results".equals(title))
+			renameWhenSaving = true;
+		boolean ok = save(path);
+		renameWhenSaving = false;
+		return ok;
+	}
+
+	public void saveAs(String path) throws IOException {
+		boolean emptyTable = size()==0 && lastColumn<0;
+		if (path==null || path.equals("")) {
+			SaveDialog sd = new SaveDialog("Save Table", "Table", Prefs.defaultResultsExtension());
+			String file = sd.getFileName();
+			if (file==null)
+				return;
+			path = sd.getDirectory() + file;
+		}
+		boolean csv = path.endsWith(".csv") || path.endsWith(".CSV");
+		delimiter = csv?',':'\t';
+		PrintWriter pw = null;
+		FileOutputStream fos = new FileOutputStream(path);
+		BufferedOutputStream bos = new BufferedOutputStream(fos);
+		pw = new PrintWriter(bos);
+		boolean saveShowRowNumbers = showRowNumbers;
+		if (Prefs.dontSaveRowNumbers)	
+			showRowNumbers = false;
+		if (saveColumnHeaders && !emptyTable) {
+			String headings = getColumnHeadings();
+			pw.println(headings);
+		}
+		quoteCommas = csv?true:false;
+		for (int i=0; i<size(); i++)
+			pw.println(getRowAsString(i));
+		quoteCommas = false;
+		showRowNumbers = saveShowRowNumbers;
+		pw.close();
+		delimiter = '\t';
+		if (renameWhenSaving) {
+			File f = new File(path);
+			title =  f.getName();
+		}
+	}
+	
+	/** Returns the default headings ("Area","Mean","StdDev", etc.). */
+	public static String[] getDefaultHeadings() {
+		return defaultHeadings;
+	}
+
+	public static String getDefaultHeading(int index) {
+		if (index>=0 && index<defaultHeadings.length)
+			return defaultHeadings[index];
+		else
+			return "null";
+	}
+
+	/** Duplicates this ResultsTable. */
+	public synchronized Object clone() {
+		try { 
+			ResultsTable rt2 = (ResultsTable)super.clone();
+			rt2.headings = new String[headings.length];
+			for (int i=0; i<=lastColumn; i++)
+				rt2.headings[i] = headings[i];
+			rt2.columns = new double[columns.length][];
+			for (int i=0; i<=lastColumn; i++) {
+				if (columns[i]!=null) {
+					double[] data = new double[maxRows];
+					for (int j=0; j<counter; j++)
+						data[j] = columns[i][j];
+					rt2.columns[i] = data;
+				}
+			}
+			if (rowLabels!=null) {
+				rt2.rowLabels = new String[rowLabels.length];
+				for (int i=0; i<counter; i++)
+					rt2.rowLabels[i] = rowLabels[i];
+			}
+			if (stringColumns!=null) {
+				rt2.stringColumns = new Hashtable();
+				Set set = stringColumns.keySet();
+				for (Iterator i=set.iterator(); i.hasNext();) {
+					Integer column = (Integer)i.next();
+					ArrayList list = (ArrayList)stringColumns.get(column);
+					rt2.stringColumns.put(column, list.clone());
+				}
+			}
+			return rt2;
+		}
+		catch (CloneNotSupportedException e) {return null;}
+	}
+	
+	public String toString() {
+		return ("title="+title+", size="+counter+", hdr="+getColumnHeadings());
+	}
+	
+	/** Applies a macro to each row of the table; the columns are assigned variable names
+	 *  as given by getHeadingsAsVaribleNames(). New variables starting with an uppercase letter
+	 *  create a new column with this name.
+	 *  The variable 'row' (the row index) is pre-defined.
+	 *  Except for the row label (if existing), currently only supports numeric values, no Strings.
+	 *  @return false in case of a macro error */
+	public boolean applyMacro(String macro) {
+		String[] columnHeadings = getHeadings();
+		String[] columnNames = getHeadingsAsVariableNames(columnHeadings); // same as variable names
+		int[] columnIndices = new int[columnHeadings.length]; // corresponding column index; <0 for rowLabels
+		for (int i=0; i<columnHeadings.length; i++)
+			columnIndices[i] = getColumnIndex(columnHeadings[i]);
+
+		Program pgm = (new Tokenizer()).tokenize(macro);
+		StringBuilder sb = new StringBuilder(1000);
+		sb.append("var ");
+		for (int i=0; i<columnNames.length; i++) {  // create 'var' statement with 'real' data values, so errors are less likely
+			sb.append(columnNames[i]);
+			sb.append('=');
+			if (columnIndices[i] < 0)
+				sb.append(rowLabels[0]==null ? "\"\"" : '"'+rowLabels[0]+'"');
+			else
+				sb.append(Math.abs(getValueAsDouble(columnIndices[i], 0))); //avoid negative values since minus would be extra token
+			sb.append(',');
+		}
+		sb.append("row;\n");
+		sb.append("function dummy() {}\n");
+		sb.append(macro);
+		sb.append(";\n");
+		String code = sb.toString();
+		int PCStart = 9+4*columnNames.length;       // 'macro' code starts at this token number
+		Interpreter interp = new Interpreter();
+		interp.setApplyMacroTable(this);
+		try {
+			interp.run(code, null);  // first test run
+		} catch(Exception e) {}
+		if (interp.wasError())
+			return false;
+
+		boolean[] columnInUse = new boolean[columnNames.length];
+		ArrayList<String> newColumnList = new ArrayList<String>();
+		String[] variables = interp.getVariableNames();
+		for (String variable:variables) {           // check for variables that make a new Column
+			int columnNumber = indexOf(columnNames, variable);
+			if (columnNumber >= 0)                  // variable is a know column
+				columnInUse[columnNumber] = macro.indexOf(variable) >=0;
+			else if (Character.isUpperCase(variable.charAt(0))) {
+				getFreeColumn(variable);            // create new column
+				newColumnList.add(variable);
+			}
+		}
+		String[] newColumns = newColumnList.toArray(new String[0]);
+		int[] newColumnIndices = new int[newColumns.length];
+		for (int i=0; i<newColumns.length; i++)
+		    newColumnIndices[i] = getColumnIndex(newColumns[i]);
+
+		for (int row=0; row<counter; row++) {       // apply macro to each row
+			for (int col=0; col<columnHeadings.length; col++) {
+				if (columnInUse[col]) {             // set variable values for used columns
+					if (columnIndices[col] < 0) {
+						String str = rowLabels[row];
+						interp.setVariable(columnNames[col], str);
+					} else {
+						double v = getValueAsDouble(columnIndices[col], row);
+						interp.setVariable(columnNames[col], v);
+					}
+				}
+			}
+			interp.setVariable("row", row);
+			interp.run(PCStart);
+			if (interp.wasError())
+				return false;
+			for (int col=0; col<columnNames.length; col++) {
+				if (columnInUse[col]) {             // set new values for previous columns
+					if (columnIndices[col] < 0) {
+						String str = interp.getVariableAsString(columnNames[col]);
+						rowLabels[row] = str;
+					} else {
+						double v = interp.getVariable(columnNames[col]);
+						setValue(columnIndices[col], row, v);
+					}
+				}
+			}
+			for (int i=0; i<newColumns.length; i++) {   // set new values for newly-created columns
+				double v = interp.getVariable(newColumns[i]);
+				setValue(newColumnIndices[i], row, v);
+			}
+		}
+		return true;
+	}
+	
+	/** Returns the first index of a given non-null String in a String array, or -1 if not found */
+	private int indexOf(String[] sArray, String s) {
+		for (int i=0; i<sArray.length; i++)
+		    if (s.equals(sArray[i])) return i;
+		return -1;
+	}
+
+	/** Returns the column headings; headings not suitable as variable names are converted
+	 *  to valid variable names by replacing non-fitting characters with underscores and
+	 *  adding underscores. To make unique names, underscores+numbers are added as required. */
+	public String[] getHeadingsAsVariableNames() {
+		return getHeadingsAsVariableNames(getHeadings());
+	}
+
+	/** Converts a list of column headings to a list of corresponding variable names */
+	String[] getHeadingsAsVariableNames(String[] names) {
+		names = (String[])names.clone();
+		for (int i=0; i<names.length; i++) {
+			if (names[i].charAt(0)>='0' && names[i].charAt(0)<='9') // variable must not start with digit
+				names[i] = "_"+names[i];
+			names[i] = names[i].replaceAll("[^A-Za-z0-9_]","_");    // replace unsuitable characters with underscores
+			for (int postfix=0; ; postfix++) {
+				boolean isDuplicate = false;
+				for (int j=0; j<i; j++) {
+					if (names[i].equals(names[j])) {                // check for duplicates
+						isDuplicate = true;
+						break;
+					}
+				}
+				if (!isDuplicate) break;
+				if (postfix > 0)                                    // remove trailing underscore+postfix
+					names[i] = names[i].substring(0, names[i].lastIndexOf('_'));
+				names[i] += "_"+postfix;                            // add underscore+postfix number
+			}
+		}
+		return names;
+	}
+	
+	public String getTitle() {
+		if (title==null && this==Analyzer.getResultsTable())
+			title = "Results";
+		return title;
+	}
+	
+	public boolean columnDeleted() {
+		return columnDeleted;
+	}
+	
+	/** Selects the row in the "Results" table assocuiated with the specified Roi.
+		The row number is obtained from the roi name..
+	*/
+	public static boolean selectRow(Roi roi) {
+		if (roi==null)
+			return false;	
+		String name = roi.getName();
+		if (name==null || name.length()>8)
+			return false ;
+		Frame frame = WindowManager.getFrame("Results");
+		if (frame==null)
+			return false;
+		if (!(frame instanceof TextWindow))
+			return false ;
+		ResultsTable rt = ((TextWindow)frame).getResultsTable();
+		if (rt==null || rt!=Analyzer.getResultsTable())
+			return false ;
+		double n = Tools.parseDouble(name);
+		if (Double.isNaN(n))
+			return false;
+		int index = (int)n - 1;
+		if (index<0 || index>=rt.size())
+			return false;
+		((TextWindow)frame).getTextPanel().setSelection(index, index);
+    	return true;	
+    }
+    	
+	/** Sorts this table on the specified column, with string support.
+	 * Author: 'mountain_man', 8 April 2019
+	*/
+	public void sort(String column) {
+		int col = getColumnIndex(column);
+		if (col==COLUMN_NOT_FOUND)
+			throw new IllegalArgumentException("Column not found");
+
+		// pad short string columns with "NaN" to avoid "holes" after sorting
+		if (stringColumns!=null) {
+		    for (Object c : stringColumns.values()) {
+			ArrayList sc = (ArrayList) c;
+		        for (int i = sc.size(); i < size(); i++)  sc.add ("NaN");
+		    }
+		}
+		
+		ComparableEntry[] ces = new ComparableEntry[size()];
+		ArrayList stringColumn = null;
+		if (stringColumns!=null)
+		    stringColumn = (ArrayList) stringColumns.get (new Integer (col));
+		for (int i = 0; i < size(); i++) {
+		    ComparableEntry ce = new ComparableEntry();
+		    ce.index = i;
+		    ce.dValue = columns[col][i];
+		    if (stringColumn != null)
+			ce.sValue = (String) stringColumn.get (i);
+		    ces[i] = ce;
+		}
+		Arrays.sort(ces);
+		// copy sorted values back into rt from a duplicate
+		ResultsTable rt2 = (ResultsTable)clone();
+		for (int i = 0; i <= getLastColumn(); i++) {
+			if (columns[i]==null)
+				continue;
+		    for (int j = 0; j < size(); j++)
+				columns[i][j] = rt2.columns[i][ces[j].index];
+		    ArrayList sc = null;
+		    Map scs =  stringColumns;
+		    	if (scs != null)
+			sc = (ArrayList) scs.get (new Integer (i));
+		    if (sc != null) {
+				ArrayList sc2 = (ArrayList) rt2.stringColumns.get (new Integer (i));
+				for (int j = 0; j < size(); j++)
+			    	sc.set (j, sc2.get (ces[j].index));
+		    }
+		}
+		if (rowLabels != null) {
+			for (int i = 0; i < size(); i++)
+				rowLabels[i] =  rt2.rowLabels[ces[i].index];
+		}
+	}
+	
+	class ComparableEntry implements Comparable<ComparableEntry>  {
+		int index;
+		double dValue;
+		String sValue;
+		
+		boolean isStr() {
+			return  Double.isNaN (dValue)  &&  sValue != null  &&  !sValue.equals ("NaN");
+		}
+		
+		public int compareTo (ComparableEntry e) {
+			if (isStr() && e.isStr())
+				return sValue.compareTo (e.sValue);
+			if (isStr())
+				return -1;
+			if (e.isStr())
+				return +1;
+			return  (dValue < e.dValue) ? -1 : ( (dValue > e.dValue) ? 1 : 0 );
+		}
+	}
+		
+}
diff --git a/src/ij/measure/ResultsTableMacros.java b/src/ij/measure/ResultsTableMacros.java
new file mode 100644
index 0000000..958a1b8
--- /dev/null
+++ b/src/ij/measure/ResultsTableMacros.java
@@ -0,0 +1,214 @@
+package ij.measure;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.frame.Recorder;
+import ij.plugin.*;
+import ij.*;
+import ij.gui.*;
+import ij.text.*;
+import java.awt.*;
+import java.awt.event.*;
+
+
+/** This class implements the Apply Macro command in tables.
+* @author Michael Schmid
+*/
+public class ResultsTableMacros implements Runnable, DialogListener, ActionListener, KeyListener {
+	private static String NAME = "TableMacro.ijm";
+	private String defaultMacro = "Sin=sin(row*0.1);\nCos=cos(row*0.1);\nSqr=Sin*Sin+Cos*Cos;";
+	private GenericDialog gd;
+	private ResultsTable rt, rtBackup;
+	private Button runButton, resetButton, openButton, saveButton;
+	private String title;
+	private int runCount;
+	private TextArea ta;
+
+	public ResultsTableMacros(ResultsTable rt) {
+		this.rt = rt;
+		title = rt!=null?rt.getTitle():null;
+		Thread thread = new Thread(this, "ResultTableMacros");
+		thread.start();
+	}
+
+	private void showDialog() {
+		if (rt==null)
+			rt = Analyzer.getResultsTable();
+		if (rt==null || rt.size()==0) {
+			IJ.error("Results Table required");
+			return;
+		}
+		String[] temp = rt.getHeadingsAsVariableNames();
+		String[] variableNames = new String[temp.length+2];
+		variableNames[0] = "Insert...";
+		variableNames[1] = "row";
+		for (int i=2; i<variableNames.length; i++)
+			variableNames[i] = temp[i-2];
+		String dialogTitle = "Apply Macro to "+(title!=null?"\""+title+"\"":"Table");
+		Frame parent = title!=null?WindowManager.getFrame(title):null;
+		if (parent!=null)
+			gd = new GenericDialog(dialogTitle, parent);
+		else
+			gd = new GenericDialog(dialogTitle);
+		gd.setInsets(5, 5, 0);
+		gd.addTextAreas(getMacro(), null, 12, 48);
+		ta = gd.getTextArea1();
+		ta.addKeyListener(this);
+
+		Panel panel = new Panel();
+		if (IJ.isMacOSX())
+			panel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
+		runButton = new Button("Run");
+		runButton.addActionListener(this);
+		panel.add(runButton);
+		resetButton = new Button("Reset");
+		resetButton.addActionListener(this);
+		panel.add(resetButton);
+		openButton = new Button("Open");
+		openButton.addActionListener(this);
+		panel.add(openButton);
+		saveButton = new Button("Save");
+		saveButton.addActionListener(this);
+		panel.add(saveButton);
+		gd.addPanel(panel);
+		gd.addToSameRow();
+		gd.addChoice("", variableNames, variableNames[0]);
+
+
+		gd.addHelp("<html><body><h1>Macro Equations for Results Tables</h1><ul>"+
+				"<li>The macro, or a selection, is applied to each row of the table."+
+				"<li>A new variable starting with an Uppercase character creates<br>a new column."+
+				"<li>A new variable starting with a lowercase character is temporary."+
+				"<li>The variable <b>row</b> (row index) is pre-defined.\n"+
+				"<li>String operations are supported for the 'Label' column only (if<br>enabled"+
+				"with Analyze&gt;Set Measurements&gt;Display Label)."+				
+				"<li>Click \"<b>Run</b>\", or press "+(IJ.isMacOSX()?"cmd":"ctrl") + "-r, to apply the macro code to the table."+
+				"<li>Select a line and press "+(IJ.isMacOSX()?"cmd":"ctrl") + "-r to apply a line of macro code."+
+				"<li>Click \"<b>Reset</b>\" to revert to the original version of the table."+
+				"<li>The code is saved at <b>macros/TableMacro.ijm</b>, and the<br>\"Apply Macro\" command is recorded, when you click \"<b>OK</b>\"."+
+				"<li>All <b>Table.</b> macro functions (such as Table.size) refer to the<br>current (frontmost) table unless the table name is given."+
+				"</ul></body></html>");
+
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled()) {  // dialog cancelled?
+			rt = rtBackup;
+			updateDisplay();
+			return;
+		}
+		if (runCount==0)
+			applyMacro();
+		if (Recorder.record) {
+			String macro = getMacroCode();
+			macro = macro.replaceAll("\n", " ");
+			if (Recorder.scriptMode()) {
+				Recorder.recordCall("title = \""+title+"\";");
+				Recorder.recordCall("frame = WindowManager.getFrame(title);");
+				Recorder.recordCall("rt = frame.getResultsTable();");
+				Recorder.recordCall("rt.applyMacro(\""+macro+"\");");
+				Recorder.recordCall("rt.show(title);");
+			} else {
+				if (title.equals("Results"))
+					Recorder.record("Table.applyMacro", macro);
+				else
+					Recorder.record("Table.applyMacro", macro, title);
+			}
+		}
+		IJ.saveString(ta.getText(), IJ.getDir("macros")+NAME);
+	 }
+
+	private void applyMacro() {
+		String code = getMacroCode();
+		rt.applyMacro(code);
+		updateDisplay();
+		runCount++;
+	}
+
+	private String getMacroCode() {
+		int start = ta.getSelectionStart();
+		int end = ta.getSelectionEnd();
+		return start==end?ta.getText():ta.getSelectedText();
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		final String variableName = gd.getNextChoice();
+		if (e!=null && (e.getSource() instanceof Choice) && !variableName.equals("Insert...")) {
+			final int pos = ta.getCaretPosition();
+			((Choice)e.getSource()).select(0);
+			final TextArea textArea = ta;
+			new Thread(new Runnable() {
+					public void run() {
+						IJ.wait(100);
+						textArea.insert(variableName, pos);
+						textArea.setCaretPosition(pos+variableName.length());
+						textArea.requestFocus();
+					}}).start();
+		}
+		return true;
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		Object source = e.getSource();
+		if (source==runButton) {
+			applyMacro();
+		} else if (source==resetButton) {
+			rt = (ResultsTable)rtBackup.clone();
+			updateDisplay();
+		} else if (source==openButton) {
+			String macro = IJ.openAsString(null);
+			if (macro==null)
+				return;
+			if (macro.startsWith("Error: ")) {
+				IJ.error(macro);
+				return;
+			} else
+				ta.setText(macro);
+		} else if (source==saveButton) {
+			ta.selectAll();
+			String macro = ta.getText();
+			ta.select(0, 0);
+			IJ.saveString(macro, null);
+		}
+
+	}
+
+	public void keyPressed(KeyEvent e) {
+		int flags = e.getModifiers();
+		boolean control = (flags & KeyEvent.CTRL_MASK) != 0;
+		boolean meta = (flags & KeyEvent.META_MASK) != 0;
+		int keyCode = e.getKeyCode();
+		if (keyCode==KeyEvent.VK_R && (control||meta))
+			applyMacro();
+		if (keyCode==KeyEvent.VK_Z && (control||meta)) {
+			rt = (ResultsTable)rtBackup.clone();
+			updateDisplay();
+		}
+	}
+
+	private void updateDisplay() {
+		if (title!=null)
+			rt.show(title);
+	}
+
+	public void keyReleased(KeyEvent e) {
+	}
+
+	public void keyTyped(KeyEvent e) {
+	}
+
+	private String getMacro() {
+		String macro = IJ.openAsString(IJ.getDir("macros")+NAME);
+		if (macro==null || macro.startsWith("Error:"))
+			return defaultMacro;
+		else {
+			macro = macro.replaceAll("rowNumber", "row");
+			macro = macro.replaceAll("rowIndex", "row");
+			return macro;
+		}
+	}
+
+	public void run() {
+		rtBackup = (ResultsTable)rt.clone();
+		showDialog();
+ 	}
+
+}
+
diff --git a/src/ij/measure/SplineFitter.java b/src/ij/measure/SplineFitter.java
new file mode 100644
index 0000000..b87dfdc
--- /dev/null
+++ b/src/ij/measure/SplineFitter.java
@@ -0,0 +1,159 @@
+package ij.measure;
+
+/** This class fits a spline function to a set of points.
+	It is based on the InitSpline() and EvalSine() functions from 
+	XY (http://www.trilon.com/xv/), an interactive image manipulation
+	program for the X Window System written by John Bradley. Eric Kischell
+	(keesh@ieee.org) converted these functions to Java and integrated
+	them into the PolygonRoi class.
+*/
+public class SplineFitter {
+	private double[] y2;
+	private static int EXTEND_BY = 7;
+	private int extendBy;
+	private float[] xpoints, ypoints;
+	private int npoints;
+	private int[] ixpoints, iypoints;
+
+	public SplineFitter(int[] x, int[] y, int n) {
+		initSpline(x, y, n);
+	}
+
+	/** For closed curves: the first and last y value should be identical;
+	 *	internally, a periodic continuation with a few will be used at both
+	 *	ends */
+	public SplineFitter(float[] x, float[] y, int n, boolean closed) {
+		initSpline(x, y, n, closed);
+	}
+
+	public SplineFitter(float[] x, float[] y, int n) {
+		initSpline(x, y, n, false);
+	}
+
+	/** Given arrays of data points x[0..n-1] and y[0..n-1], computes the
+		values of the second derivative at each of the data points
+		y2[0..n-1] for use in the evalSpline() function. */
+	private void initSpline(int[] x, int[] y, int n) {
+		int i,k;
+		double p,qn,sig,un;
+		y2 = new double[n];	 // cached
+		double[] u	= new double[n];
+		for (i=1; i<n-1; i++) {
+			// 888 chk for div by 0?
+			sig = ((double) x[i]-x[i-1]) / ((double) x[i+1] - x[i-1]);
+			p = sig * y2[i-1] + 2.0;
+			y2[i] = (sig-1.0) / p;
+			u[i] = (((double) y[i+1]-y[i]) / (x[i+1]-x[i])) -
+				   (((double) y[i]-y[i-1]) / (x[i]-x[i-1]));
+			u[i] = (6.0 * u[i]/ (x[i+1]-x[i-1]) - sig*u[i-1]) / p;
+		}
+		qn = un = 0.0;
+		y2[n-1] = (un-qn*u[n-2]) / (qn*y2[n-2]+1.0);
+		for (k=n-2; k>=0; k--)
+			y2[k] = y2[k]*y2[k+1]+u[k];
+		ixpoints = x;
+		iypoints = y;
+		npoints = n;
+	}
+
+	private void initSpline(float[] x, float[] y, int n, boolean closed) {
+		if (closed) {					//add periodic continuation at both ends
+			extendBy = EXTEND_BY;
+			if (extendBy>=n)
+				extendBy = n - 1;
+			int n2 = n + 2*extendBy;
+			float[] xx = new float[n2];
+			float[] yy = new float[n2];
+			for (int i=0; i<extendBy; i++) {
+				xx[i] = x[n-(extendBy-i+1)] - x[n-1];
+				yy[i] = y[n-(extendBy-i+1)];
+			}
+			for (int i=extendBy; i<extendBy+n; i++) {
+				xx[i] = x[i-extendBy];
+				yy[i] = y[i-extendBy];
+			}
+			for (int i=extendBy+n; i<n2; i++) {
+				xx[i] = x[i+1-(extendBy+n)] - x[0] + x[n-1];
+				yy[i] = y[i+1-(extendBy+n)];
+			}
+			n = n2;
+			x = xx;
+			y = yy;
+		}
+		int i,k;
+		double p,qn,sig,un;
+		y2 = new double[n];	 // cached
+		double[] u	= new double[n];
+		for (i=1; i<n-1; i++) {
+			// 888 chk for div by 0?
+			sig = ((double) x[i]-x[i-1]) / ((double) x[i+1] - x[i-1]);
+			p = sig * y2[i-1] + 2.0;
+			y2[i] = (sig-1.0) / p;
+			u[i] = (((double) y[i+1]-y[i]) / (x[i+1]-x[i])) -
+				   (((double) y[i]-y[i-1]) / (x[i]-x[i-1]));
+			u[i] = (6.0 * u[i]/ (x[i+1]-x[i-1]) - sig*u[i-1]) / p;
+		}
+		qn = un = 0.0;
+		y2[n-1] = (un-qn*u[n-2]) / (qn*y2[n-2]+1.0);
+		for (k=n-2; k>=0; k--)
+			y2[k] = y2[k]*y2[k+1]+u[k];
+		xpoints = x;
+		ypoints = y;
+		npoints = n;
+	}
+
+	/** Evalutes spline function at given point */
+	public double evalSpline(double xp) {
+		if (xpoints!=null)
+			return evalSpline(xpoints, ypoints, npoints, xp);
+		else
+			return evalSpline(ixpoints, iypoints, npoints, xp);
+	}
+	
+	public double evalSpline(int x[], int y[], int n, double xp) {
+		int klo,khi,k;
+		double h,b,a;
+		klo = 0;
+		khi = n-1;
+		while (khi-klo > 1) {
+			k = (khi+klo) >> 1;
+			if (x[k] > xp) khi = k;
+			else klo = k;
+		}
+		h = x[khi] - x[klo];
+		/* orig code */
+		/* if (h==0.0) FatalError("bad xvalues in splint\n"); */
+		if (h==0.0) return (0.0);  /* arbitr ret for now */
+		a = (x[khi]-xp)/h;
+		b = (xp-x[klo])/h;
+		// should have better err checking
+		if(y2==null) return (0.0);
+		return (a*y[klo] + b*y[khi] + ((a*a*a-a)*y2[klo] +(b*b*b-b)*y2[khi]) * (h*h) / 6.0);
+	}
+	
+	public double evalSpline(float x[], float y[], int n, double xp) {
+		int klo,khi,k;
+		double h,b,a;
+		klo = 0;
+		khi = n-1;
+		while (khi-klo>1) {
+			k = (khi+klo)>>1;
+			if (x[k]>xp)
+				khi = k;
+			else
+				klo = k;
+		}
+		h = x[khi] - x[klo];
+		/* orig code */
+		/* if (h==0.0) FatalError("bad xvalues in splint\n"); */
+		if (h==0.0)
+			return (0.0);  /* arbitr ret for now */
+		a = (x[khi]-xp)/h;
+		b = (xp-x[klo])/h;
+		// should have better err checking
+		if (y2==null)
+			return (0.0);
+		return (a*y[klo] + b*y[khi] + ((a*a*a-a)*y2[klo] +(b*b*b-b)*y2[khi]) * (h*h) / 6.0);
+	}
+
+}
diff --git a/src/ij/measure/UserFunction.java b/src/ij/measure/UserFunction.java
new file mode 100644
index 0000000..1beea70
--- /dev/null
+++ b/src/ij/measure/UserFunction.java
@@ -0,0 +1,23 @@
+package ij.measure;
+
+
+/**
+ * A plugin should implement this interface for minimizing a single-valued function
+ * or fitting a curve with a custom fit function.
+ */
+public interface UserFunction {
+    /**
+     * A user-supplied function
+     * @param params    When minimizing, array of variables.
+     *                  For curve fit array of fit parameters.
+     *                  The array contents should not be modified.
+     *                  Note that the function can get an array with more
+     *                  elements then needed to specify the parameters.
+     *                  Ignore the rest (and don't modify them).
+     * @param x         For a fit function, the independent variable of the function.
+     *                  Ignore it when using the minimizer.
+     * @return          The result of the function.
+     */
+    public double userFunction(double[] params, double x);
+}
+
diff --git a/src/ij/plugin/AVI_Reader.java b/src/ij/plugin/AVI_Reader.java
new file mode 100644
index 0000000..1316ae3
--- /dev/null
+++ b/src/ij/plugin/AVI_Reader.java
@@ -0,0 +1,1612 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.plugin.Animator;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.util.*;
+import javax.imageio.ImageIO;
+
+/** <pre>
+ * ImageJ Plugin for reading an AVI file into an image stack
+ *	(one slice per video frame)
+ *
+ *
+ * Restrictions and Notes:
+ *		- Only few formats supported:
+ *			- uncompressed 8 bit with palette (=LUT)
+ *			- uncompressed 8 & 16 bit grayscale
+ *			- uncompressed 24 & 32 bit RGB (alpha channel ignored)
+ *			- uncompressed 32 bit AYUV (alpha channel ignored)
+ *			- various YUV 4:2:2 and 4:2:0 compressed formats (i.e., formats with
+ *						  full luminance resolution, but reduced chroma resolution
+ *			- png or jpeg-encoded individual frames.
+ *			  Note that most MJPG (motion-JPEG) formats are not read correctly.
+ *		- Does not read avi formats with more than one frame per chunk
+ *		- Palette changes during the video not supported
+ *		- Out-of-sequence frames (sequence given by index) not supported
+ *		- Different frame sizes in one file (rcFrame) not supported
+ *		- Conversion of (A)YUV formats to grayscale is non-standard:
+ *		  All 255 levels are kept as in the input (i.e. the full dynamic
+ *		  range of data from a frame grabber is preserved).
+ *		  For standard behavior, use "Brightness&Contrast", Press "Set",
+ *		  enter "Min." 16, "Max." 235, and press "Apply".
+ *		- Restrictions for AVIs with blank frames:
+ *		  Currently only supported with AVI-2 type index.
+ *		  Blank frames are ignored.
+ *		  Selection of start and end frames is inconsistent between normal and
+ *		  virtual stacks.
+ *		  Timing in slice info is incorrect unless read as virtual stack.
+ *		- Note: As a last frame, one can enter '0' (= last frame),
+ *		  '-1' (last frame -1), etc.
+ *
+ * Version History:
+ *	 2008-04-29
+ *		  based on a plugin by Daniel Marsh and Wayne Rasband;
+ *		  modifications by Michael Schmid
+ *		- Support for several other formats added, especially some YUV
+ *		  (also named YCbCr) formats
+ *		- Uneven chunk sizes fixed
+ *		- Negative biHeight fixed
+ *		- Audio or second video stream don't cause a problem
+ *		- Can read part of a file (specify start & end frame numbers)
+ *		- Can convert YUV and RGB to grayscale (does not convert 8-bit with palette)
+ *		- Can flip vertically
+ *		- Can create a virtual stack
+ *		- Added slice label: time of the frame in the movie
+ *		- Added a public method 'getStack' that does not create an image window
+ *		- More compact code, especially for reading the header (rewritten)
+ *		- In the code, bitmapinfo items have their canonical names.
+ *	 2008-06-08
+ *		- Support for png and jpeg/mjpg encoded files added
+ *		- Retrieves animation speed from image frame rate
+ *		- Exception handling without multiple error messages
+ *	 2008-07-03
+ *		- Support for 16bit AVIs coded by MIL (Matrox Imaging Library)
+ *	 2009-03-06
+ *		- Jesper Soendergaard Pedersen added support for extended (large) AVI files,
+ *		  also known as 'AVI 2.0' or 'OpenDML 1.02 AVI file format extension'
+ *		  For Virtual stacks, it reads the 'AVI 2.0' index (indx and ix00 tags).
+ *		  This results in a dramatic speed increase in loading of virtual stacks.
+ *		  If indx and ix00 are not found or bIndexType is unsupported, as well as for
+ *		  non-virtual stacks it finds the frames 'the old way', by scanning the whole file.
+ *		- Fixes a bug where it read too many frames.
+ *		  This version was published as external plugin.
+ *	 2011-12-03
+ *		- Minor updates & cleanup for integration into ImageJ again.
+ *		- Multithread-compliant.
+ *	 2011-12-10
+ *		- Based on a plugin by Jesper Soendergaard Pedersen, also reads the 'idx1' index of
+ *		  AVI 1 files, speeding up initial reading of virtual stacks also for smaller files.
+ *		- When the first frame to read is > 1, uses the index to quickly skip the initial frames.
+ *		- Creates a unique window name.
+ *		- Opens MJPG files also if they do not contain Huffman tables
+ *	 2012-02-01
+ *		- added support for YV12, I420, NV12, NV21 (planar formats with 2x2 U and V subsampling)
+ *	 2012-12-04
+ *		- can read AVI-2 files with blank frames into a virtual stack
+ *	 2013-10-29
+ *		- can read MJPG files where the frames don't have the same pixel number as the overall video
+ *	 2015-09-28
+ *		- reads most ImageJ AVI1 files with size>4 GB (incorrectly written by ImageJ versions before 1.50b)
+ *	 2017-04-21
+ *		- bugfix: file was not closed in case of dialog cancelled or some IO errors.
+ *      - Tries to recover data from truncated files.
+ *
+ *
+ * The AVI format looks like this:
+ * RIFF AVI					RIFF HEADER, AVI CHUNK
+ *	 | LIST hdrl			MAIN AVI HEADER
+ *	 | | avih				AVI HEADER
+ *	 | | LIST strl			STREAM LIST(s) (One per stream)
+ *	 | | | strh				STREAM HEADER (Required after above; fourcc type is 'vids' for video stream)
+ *	 | | | strf				STREAM FORMAT (for video: BitMapInfo; may also contain palette)
+ *	 | | | strd				OPTIONAL -- STREAM DATA (ignored in this plugin)
+ *	 | | | strn				OPTIONAL -- STREAM NAME (ignored in this plugin)
+ *	 | | | indx				OPTIONAL -- MAIN 'AVI 2.0' INDEX
+ *	 | LIST movi			MOVIE DATA
+ *	 | | ix00				partial video index of 'AVI 2.0', usually missing in AVI 1 (ix01 would be for audio)
+ *	 | | [rec]				RECORD DATA (one record per frame for interleaved video; optional, unsupported in this plugin)
+ *	 | | |-dataSubchunks	RAW DATA: '??wb' for audio, '??db' and '??dc' for uncompressed and
+ *	 | |					compressed video, respectively. "??" denotes stream number, usually "00" or "01"
+ *	 | idx1					AVI 1 INDEX ('old-style'); may be missing in very old formats
+ * RIFF AVIX				'AVI 2.0' only: further chunks
+ *	 | LIST movi			more movie data, as above, usually with ix00 index
+ *							Any number of further chunks (RIFF tags) may follow
+ *
+ * Items ('chunks') with one fourcc (four-character code such as 'strh') start with two 4-byte words:
+ * the fourcc and the size of the data area.
+ * Items with two fourcc (e.g. 'LIST hdrl') have three 4-byte words: the first fourcc, the size and the
+ * second fourcc. Note that the size includes the 4 bytes needed for the second fourcc.
+ *
+ * Chunks with fourcc 'JUNK' can appear anywhere and should be ignored.
+ *
+ * </pre>
+ */
+
+public class AVI_Reader extends VirtualStack implements PlugIn {
+
+	//four-character codes for avi chunk types
+	//NOTE: byte sequence is reversed - ints in Intel (little endian) byte order!
+	private final static int   FOURCC_RIFF = 0x46464952;   //'RIFF'
+	private final static int   FOURCC_AVI =	 0x20495641;   //'AVI '
+	private final static int   FOURCC_AVIX = 0x58495641;   //'AVIX'	 // extended AVI
+	private final static int   FOURCC_ix00 = 0x30307869;   //'ix00'  // index within
+	private final static int   FOURCC_indx = 0x78646e69;   //'indx'	 // main index
+	private final static int   FOURCC_idx1 = 0x31786469;   //'idx1'	 // index of single 'movi' block
+	private final static int   FOURCC_LIST = 0x5453494c;   //'LIST'
+	private final static int   FOURCC_hdrl = 0x6c726468;   //'hdrl'
+	private final static int   FOURCC_avih = 0x68697661;   //'avih'
+	private final static int   FOURCC_strl = 0x6c727473;   //'strl'
+	private final static int   FOURCC_strh = 0x68727473;   //'strh'
+	private final static int   FOURCC_strf = 0x66727473;   //'strf'
+	private final static int   FOURCC_movi = 0x69766f6d;   //'movi'
+	private final static int   FOURCC_rec =	 0x20636572;   //'rec '
+	private final static int   FOURCC_JUNK = 0x4b4e554a;   //'JUNK'
+	private final static int   FOURCC_vids = 0x73646976;   //'vids'
+	private final static int   FOURCC_00db = 0x62643030;   //'00db'
+	private final static int   FOURCC_00dc = 0x63643030;   //'00dc'
+
+	//four-character codes for supported compression formats; see fourcc.org
+	private final static int   NO_COMPRESSION	 = 0;		   //uncompressed, also 'RGB ', 'RAW '
+	private final static int   NO_COMPRESSION_RGB= 0x20424752; //'RGB ' -a name for uncompressed
+	private final static int   NO_COMPRESSION_RAW= 0x20574152; //'RAW ' -a name for uncompressed
+	private final static int   NO_COMPRESSION_Y800=0x30303859; //'Y800' -a name for 8-bit grayscale
+	private final static int   NO_COMPRESSION_Y8 = 0x20203859; //'Y8  ' -another name for Y800
+	private final static int   NO_COMPRESSION_GREY=0x59455247; //'GREY' -another name for Y800
+	private final static int   NO_COMPRESSION_Y16= 0x20363159; //'Y16 ' -a name for 16-bit uncompressed grayscale
+	private final static int   NO_COMPRESSION_MIL= 0x204c494d; //'MIL ' - Matrox Imaging Library
+	private final static int   AYUV_COMPRESSION	 = 0x56555941; //'AYUV' -uncompressed, but alpha, Y, U, V bytes
+	private final static int   UYVY_COMPRESSION	 = 0x59565955; //'UYVY' - 4:2:2 with byte order u y0 v y1
+	private final static int   Y422_COMPRESSION	 = 0x564E5955; //'Y422' -another name for of UYVY
+	private final static int   UYNV_COMPRESSION	 = 0x32323459; //'UYNV' -another name for of UYVY
+	private final static int   CYUV_COMPRESSION	 = 0x76757963; //'cyuv' -as UYVY but not top-down
+	private final static int   V422_COMPRESSION	 = 0x32323456; //'V422' -as UYVY but not top-down
+	private final static int   YUY2_COMPRESSION	 = 0x32595559; //'YUY2' - 4:2:2 with byte order y0 u y1 v
+	private final static int   YUNV_COMPRESSION	 = 0x564E5559; //'YUNV' -another name for YUY2
+	private final static int   YUYV_COMPRESSION	 = 0x56595559; //'YUYV' -another name for YUY2
+	private final static int   YVYU_COMPRESSION	 = 0x55595659; //'YVYU' - 4:2:2 with byte order y0 u y1 v
+
+	private final static int   I420_COMPRESSION	 = 0x30323449; //'I420' - y plane followed by 2x2 subsampled U and V
+	private final static int   IYUV_COMPRESSION	 = 0x56555949; //'IYUV' - another name for I420
+	private final static int   YV12_COMPRESSION	 = 0x32315659; //'YV12' - y plane followed by 2x2 subsampled V and U
+	private final static int   NV12_COMPRESSION	 = 0x3231564E; //'NV12' - y plane followed by 2x2 subsampled interleaved U, V
+	private final static int   NV21_COMPRESSION	 = 0x3132564E; //'NV21' - y plane followed by 2x2 subsampled interleaved V, U
+
+	private final static int   JPEG_COMPRESSION	 = 0x6765706a; //'jpeg' JPEG compression of individual frames
+	private final static int   JPEG_COMPRESSION2 = 0x4745504a; //'JPEG' JPEG compression of individual frames
+	private final static int   JPEG_COMPRESSION3 = 0x04;	   //BI_JPEG: JPEG compression of individual frames
+	private final static int   MJPG_COMPRESSION	 = 0x47504a4d; //'MJPG' Motion JPEG, also reads compression of individual frames
+	private final static int   PNG_COMPRESSION	 = 0x20676e70; //'png ' PNG compression of individual frames
+	private final static int   PNG_COMPRESSION2	 = 0x20474e50; //'PNG ' PNG compression of individual frames
+	private final static int   PNG_COMPRESSION3	 = 0x05;	   //BI_PNG PNG compression of individual frames
+
+	private final static int   BITMASK24 = 0x10000;			   //for 24-bit (in contrast to 8, 16,... not a bitmask)
+	private final static long  SIZE_MASK = 0xffffffffL;		   //for conversion of sizes from unsigned int to long
+	private final static long  FOUR_GB	 = 0x100000000L;	   //2^32; above this size of data AVI 1 has a problem for sure
+
+	// flags from AVI chunk header
+	private final static int   AVIF_HASINDEX	 = 0x00000010;	// Index at end of file?
+	private final static int   AVIF_MUSTUSEINDEX = 0x00000020;	// ignored by this plugin
+	private final static int   AVIF_ISINTERLEAVED= 0x00000100;	// ignored by this plugin
+
+	// constants used to read 'AVI 2' index chunks (others than those defined here are not supported)
+	private final static byte  AVI_INDEX_OF_CHUNKS=0x01;	   //index of frames
+	private final static byte  AVI_INDEX_OF_INDEXES=0x00;	   //main indx pointing to ix00 etc subindices
+
+	//static versions of dialog parameters that will be remembered
+	private static boolean	   staticConvertToGray;
+	private static boolean	   staticFlipVertical;
+	private static boolean	   staticIsVirtual = true;
+	
+	//dialog parameters
+	private static final String PATH_KEY = "avi.reader.path";
+	private String path; 					// file path
+	private String fileName;			// file name
+	private String fileDir;		// directory
+	private int	 firstFrame = 1;		//the first frame to read
+	private int	 lastFrame = 0;		//the last frame to read; 0 means 'read all'
+	private boolean convertToGray;		//whether to convert color video to grayscale
+	private boolean flipVertical;		//whether to flip image vertical
+	private boolean isVirtual;			//whether to open as virtual stack
+   //the input file
+	private	 RandomAccessFile  raFile;
+	private	 String			   raFilePath;
+	private	 boolean		   headerOK = false;	//whether header has been read
+	//more avi file properties etc
+	private	 int			   streamNumber;		//number of the (first) video stream
+	private	 int			   type0xdb, type0xdc;	//video stream chunks must have one of these two types (e.g. '00db' for straem 0)
+	private	 long			   fileSize;			//file size
+	private	 long			   aviSize;				//size of 'AVI' chunk
+	private	 long			   headerPositionEnd;	//'movi' will start somewhere here
+	private	 long			   indexPosition;		//position of the main index (indx)
+	private	 long			   indexPositionEnd;	//indx seek end
+	private	 long			   moviPosition;		//position of 'movi' list
+	private	 int			   paddingGranularity = 2;	//tags start at even address
+	private	 int			   frameNumber = 1;		//frame currently read; global because distributed over 1st AVi and further RIFF AVIX chunks
+	private	 int			   lastFrameToRead = Integer.MAX_VALUE;
+	private	 int			   totalFramesFromIndex;//number of frames from 'AVI 2.0' indices
+	private	 boolean		   indexForCountingOnly;//don't read the index, only count int totalFramesFromIndex how many entries
+	private	 boolean		   isOversizedAvi1;		//AVI-1 file > 4GB
+	//derived from BitMapInfo
+	private	 int			   dataCompression;		//data compression type used
+	private	 boolean		   isPlanarFormat;		//I420 & YV12 formats: y frame, then u,v frames
+	private	 int			   scanLineSize;
+	private	 boolean		   dataTopDown;			//whether data start at top of image
+	private	 ColorModel		   cm;
+	private	 boolean		   variableLength;		//compressed (PNG, JPEG) frames have variable length
+	//for conversion to ImageJ stack
+	private	 Vector<long[]>	   frameInfos;			//for virtual stack: long[] with frame pos&size in file, time(usec)
+	private	 ImageStack		   stack;
+	private	 ImagePlus		   imp;
+	//for debug messages and error handling
+	private	 boolean		   verbose = IJ.debugMode;
+	private	 long			   startTime;
+	private	 boolean		   aborting;
+	private	 boolean		   displayDialog = true;
+    private  String 		   errorText;			//error occurred during makeStack, or null
+
+	//From AVI Header Chunk
+	private	 int			   dwMicroSecPerFrame;
+	private	 int			   dwMaxBytesPerSec;
+	private	 int			   dwReserved1;
+	private	 int			   dwFlags;
+	private	 int			   dwTotalFrames;		//AVI 2.0: will be replaced by number of frames from index
+	private	 int			   dwInitialFrames;
+	private	 int			   dwStreams;
+	private	 int			   dwSuggestedBufferSize;
+	private	 int			   dwWidth;
+	private	 int			   dwHeight;
+
+	//From Stream Header Chunk
+	private	 int			   fccStreamHandler;
+	private	 int			   dwStreamFlags;
+	private	 int			   dwPriorityLanguage;	//actually 2 16-bit words: wPriority and wLanguage
+	private	 int			   dwStreamInitialFrames;
+	private	 int			   dwStreamScale;
+	private	 int			   dwStreamRate;
+	private	 int			   dwStreamStart;
+	private	 int			   dwStreamLength;
+	private	 int			   dwStreamSuggestedBufferSize;
+	private	 int			   dwStreamQuality;
+	private	 int			   dwStreamSampleSize;
+
+	//From Stream Format Chunk: BITMAPINFO contents (40 bytes)
+	private	 int			   biSize;				// size of this header in bytes (40)
+	private	 int			   biWidth;
+	private	 int			   biHeight;
+	private	 short			   biPlanes;			// no. of color planes: for the formats decoded; here always 1
+	private	 short			   biBitCount;			// Bits per Pixel
+	private	 int			   biCompression;
+	private	 int			   biSizeImage;			// size of image in bytes (may be 0: if so, calculate)
+	private	 int			   biXPelsPerMeter;		// horizontal resolution, pixels/meter (may be 0)
+	private	 int			   biYPelsPerMeter;		// vertical resolution, pixels/meter (may be 0)
+	private	 int			   biClrUsed;			// no. of colors in palette (if 0, calculate)
+	private	 int			   biClrImportant;		// no. of important colors (appear first in palette) (0 means all are important)
+
+
+
+	/** The plugin is invoked by ImageJ using this method.
+	 *	@param arg	 String 'arg' may be used to select the path. If it is an empty string,
+	 *	a file open dialog is shown, and the resulting ImagePlus is displayed thereafter.
+	 *	The ImagePlus is not displayed if 'arg' is a non-empty String; it can be
+	 *	retrieved with getImagePlus().
+	 */
+	public void run (String arg) {
+		String options = IJ.isMacro()?Macro.getOptions():null;
+		if (options!=null && options.contains("select=") && !options.contains("open="))
+			Macro.setOptions(options.replaceAll("select=", "open="));
+		path = arg;
+		if (displayDialog && !showDialog())					//ask for parameters
+			return;
+		try {
+			openAndReadHeader(path);  //open and read header
+		} catch (Exception e) {
+			error(exceptionMessage(e));
+			return;
+		} finally {
+			closeFile(raFile);
+		}
+		errorText = null;
+		ImageStack stack = makeStack(path, firstFrame, lastFrame, isVirtual, convertToGray, flipVertical);	//read data
+		if (aborting)
+			return;													//error message has been shown already
+		if (stack==null || stack.size() == 0 || stack.getProcessor(1)==null) {	//read nothing?
+            if (errorText != null)
+				error(errorText);
+            else {
+				 String rangeText = "";
+				if (firstFrame > 1 || (lastFrame != 0 && lastFrame != dwTotalFrames))
+					rangeText = "\nin Range "+firstFrame+
+                            (lastFrame>0 ? " - "+lastFrame : " - end");
+                error("Error: No Frames Found"+rangeText);
+            }
+			return;
+		} else if (errorText != null)
+            IJ.showMessage("AVI Reader", errorText);				//show the error, e.g. we may have an incomplete stack
+		if (fileName==null) {
+			File f = new File(path);
+			fileName = f.getName();
+		}
+		imp = new ImagePlus(WindowManager.makeUniqueName(fileName), stack);
+		if (imp.getBitDepth()==16)
+			imp.getProcessor().resetMinAndMax();
+		setFramesPerSecond(imp);
+		FileInfo fi = new FileInfo();
+		fi.fileName = fileName;
+		fi.directory = fileDir;
+		imp.setFileInfo(fi);
+		if (arg.equals(""))
+			imp.show();
+		IJ.showTime(imp, startTime, "Read AVI in ", stack.size());
+	}
+
+	/** Returns the ImagePlus opened by run(). */
+	public ImagePlus getImagePlus() {
+		return imp;
+	}
+
+	/** Opens an AVI file as a virtual stack. The ImagePlus is not displayed. */
+	public static ImagePlus openVirtual(String path) {
+		return open(path, true);
+	}
+
+	/** Opens an AVI file as a stack in memory or a virtual stack. The ImagePlus is not displayed. */
+	public static ImagePlus open(String path, boolean virtual) {
+		AVI_Reader reader = new AVI_Reader();
+		ImageStack stack = reader.makeStack (path, 1, 0, virtual, false, false);
+		if (stack!=null)
+			return new ImagePlus((new File(path)).getName(), stack);
+		else
+			return null;
+	}
+
+	/** Create an ImageStack from an avi file with given path.
+	 * @param path				Directoy+filename of the avi file
+	 * @param firstFrame  Number of first frame to read (first frame of the file is 1)
+	 * @param lastFrame	  Number of last frame to read or 0 for reading all, -1 for all but last...
+	 * @param isVirtual			Whether to return a virtual stack
+	 * @param convertToGray		Whether to convert color images to grayscale
+	 * @return	Returns the stack (may be incomplete on error); null on failure.
+	 *	The stack returned may be non-null, but have a length of zero if no suitable frames were found.
+	 *  Use <code>getErrorText</code> to determine whether there has been an error reading the file.
+	 *  For virtual stacks, not that I/O errors may also occur later, when reading the frames.
+	 */
+	public ImageStack makeStack (String path, int firstFrame, int lastFrame,
+			boolean isVirtual, boolean convertToGray, boolean flipVertical) {
+		this.firstFrame = firstFrame;
+		this.lastFrame = lastFrame;
+		this.isVirtual = isVirtual;
+		this.convertToGray = convertToGray;
+		this.flipVertical = flipVertical;
+		IJ.showProgress(.001);
+		try {
+			readAVI(path);
+		} catch (OutOfMemoryError e) {
+			stack.trim();
+			errorText = "Out of memory.  " + stack.size() + " of " + dwTotalFrames + " frames will be opened.";
+		} catch (Exception e) {
+			errorText = exceptionMessage(e);
+            if (isVirtual || stack==null || stack.size()==0)		//return null only if we have really nothing
+				return null;
+		} finally {
+			closeFile(raFile);
+			if (verbose)
+                IJ.log("File closed.");
+			IJ.showProgress(1.0);
+		}
+		if (isVirtual && frameInfos != null)
+			stack = this;
+		if (stack!=null && cm!=null)
+			stack.setColorModel(cm);
+		return stack;
+	}
+
+    /** Returns a description of the error reading the file with <code>makeStack</code> or null if no error */
+	public String getErrorText() {
+		return errorText;
+	}
+
+	/** Returns an ImageProcessor for the specified slice of this virtual stack (if it is one)
+     *  where 1<=n<=nslices. Returns null if no virtual stack or no slices or error reading the frame.
+	 */
+	public synchronized ImageProcessor getProcessor(int n) {
+		if (frameInfos==null || frameInfos.size()==0 || raFilePath==null)
+			return null;
+		n = translate(n); // update n for hyperstacks not in default CZT order
+		if (n<1 || n>frameInfos.size())
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		Object pixels = null;
+		RandomAccessFile rFile = null;
+		try {
+			rFile = new RandomAccessFile(new File(raFilePath), "r");
+			long[] frameInfo = (long[])(frameInfos.get(n-1));
+			pixels = readFrame(rFile, frameInfo[0], (int)frameInfo[1]);
+		} catch (Exception e) {
+			error(exceptionMessage(e));
+			return null;
+		} finally {
+			closeFile(rFile);
+		}
+		if (pixels == null) return null; //failed
+		if (pixels instanceof byte[])
+			return new ByteProcessor(dwWidth, biHeight, (byte[])pixels, cm);
+		else if (pixels instanceof short[])
+			return new ShortProcessor(dwWidth, biHeight, (short[])pixels, cm);
+		else
+			return new ColorProcessor(dwWidth, biHeight, (int[])pixels);
+	}
+
+	/** Returns the image width of the virtual stack */
+	public int getWidth() {
+		return dwWidth;
+	}
+
+	/** Returns the image height of the virtual stack */
+	public int getHeight() {
+		return biHeight;
+	}
+
+	/** Returns the number of images in this virtual stack (if it is one) */
+	public int getSize() {
+		if (frameInfos == null) return 0;
+		else return frameInfos.size();
+	}
+
+	/** Returns the label of the specified slice in this virtual stack (if it is one). */
+	public String getSliceLabel(int n) {
+		if (frameInfos==null || n<1 || n>frameInfos.size())
+			throw new IllegalArgumentException("No Virtual Stack or argument out of range: "+n);
+		return frameLabel(((long[])(frameInfos.get(n-1)))[2]);
+	}
+
+	/** Deletes the specified image from this virtual stack (if it is one),
+	 *	where 1<=n<=nslices. */
+	public void deleteSlice(int n) {
+		if (frameInfos==null || frameInfos.size()==0) return;
+		if (n<1 || n>frameInfos.size())
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		frameInfos.removeElementAt(n-1);
+	}
+
+	/** Parameters dialog, returns false on cancel */
+	private boolean showDialog () {
+		if (lastFrame!=-1)
+			lastFrame = dwTotalFrames;
+		if (!IJ.isMacro()) {
+			convertToGray = staticConvertToGray;
+			flipVertical = staticFlipVertical;
+			isVirtual = staticIsVirtual;
+		}
+		String options = Macro.getOptions();
+		if  (options!=null) {  //macro
+			if (options.contains("open="))
+				Macro.setOptions(options.replace("open=", "avi="));
+		}
+		if (path==null || path.length()==0)
+			path = Prefs.get(PATH_KEY, IJ.getDir("downloads")+"movie.avi");
+		GenericDialog gd = new GenericDialog("AVI Reader");
+		gd.setInsets(5, 0, 0);
+		gd.addFileField("AVI:", path, 29);
+		gd.setInsets(2, 40, 5);
+		gd.addMessage("drag and drop target", IJ.font10, Color.darkGray);
+		gd.addCheckbox("Use Virtual Stack", isVirtual);
+		gd.addCheckbox("Convert to Grayscale", convertToGray);
+		gd.addCheckbox("Flip Vertical", flipVertical);
+		gd.setInsets(15, 0, 3);
+		gd.addNumericField("First:", firstFrame, 0);
+		gd.addNumericField("Last:", lastFrame, lastFrame, 6, "*");
+		TextField lastField = (TextField)(gd.getNumericFields().lastElement());
+		if (lastFrame == 0)
+			lastField.setText("");
+		gd.setInsets(0, 40, 5);
+		gd.addMessage("* Leave empty or set to 0 for reading to the end.\n   Also accepts e.g. -5 to skip last 5 frames.", IJ.font10, Color.darkGray);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		path = gd.getNextString();
+		Prefs.set(PATH_KEY, path);
+		File f = new File(path);
+		fileName = f.getName();
+		fileDir = IJ.addSeparator(f.getParent());
+		gd.setSmartRecording(true);
+		isVirtual = gd.getNextBoolean();
+		convertToGray = gd.getNextBoolean();
+		flipVertical = gd.getNextBoolean();
+		double first = gd.getNextNumber();
+		if (!Double.isNaN(first)) firstFrame = (int)first;
+		if (lastField.getText().length()==0)
+			lastField.setText("0");
+		double last = gd.getNextNumber();
+		if (!Double.isNaN(last)) lastFrame = (int)last;
+		if (!IJ.isMacro()) {
+			staticConvertToGray = convertToGray;
+			staticFlipVertical = flipVertical;
+			staticIsVirtual = isVirtual;
+		}
+		IJ.register(this.getClass());
+		return true;
+	}
+
+	/** Read into a (virtual) stack */
+	private void readAVI(String path) throws Exception, IOException {
+		if (!headerOK)							// we have not read the header yet?
+			openAndReadHeader(path);
+        else {
+			File file = new File(path);			// open if currently not open
+			raFile = new RandomAccessFile(file, "r");
+        }
+		startTime += System.currentTimeMillis();// taking previously elapsed time into account
+		/** MOVED UP HERE BY JSP*/
+		if (lastFrame > 0)						// last frame number to read: from Dialog
+			lastFrameToRead = lastFrame;
+		if (lastFrame < 0 && dwTotalFrames > 0) // negative means "end frame minus ..."
+			lastFrameToRead = dwTotalFrames+lastFrame;
+		if (lastFrameToRead < firstFrame)		// no frames to read
+			return;
+		boolean hasIndex = (dwFlags & AVIF_HASINDEX) != 0;
+		if (isVirtual || firstFrame>1) {		// avoid scanning frame-by-frame where we only need the positions
+			frameInfos = new Vector<long[]>(100); // holds frame positions, sizes and time since start
+			long nextPosition = -1;
+			if (indexPosition > 0) {			// attempt to get AVI2.0 index instead of scanning for all frames
+				raFile.seek(indexPosition);
+				nextPosition = findFourccAndRead(FOURCC_indx, false, indexPositionEnd, false);
+			}
+			if (hasIndex && (frameInfos==null ||frameInfos.size()==0)) { // got nothing from indx, attempt to read AVI 1 index 'idx1'
+				raFile.seek(headerPositionEnd);
+				moviPosition = findFourccAndSkip(FOURCC_movi, true, fileSize);	// go behind the 'movi' list
+				if (moviPosition<0)
+					throw new Exception("AVI File has no movie data");
+				long positionBehindMovie = raFile.getFilePointer();
+				while (positionBehindMovie < fileSize-8) {
+					if (verbose)
+						IJ.log("searching for 'idx1' at 0x"+Long.toHexString(positionBehindMovie));
+					raFile.seek(positionBehindMovie);
+					if (positionBehindMovie > FOUR_GB)
+						isOversizedAvi1 = true;
+					nextPosition = findFourccAndRead(FOURCC_idx1, false, fileSize, false);
+					if (nextPosition >= 0)		//AVI-1 index 'idx1' found
+						break;
+					positionBehindMovie += FOUR_GB;	 //maybe position was wrong because it was a 32-bit number, but > 4GB?
+				}
+			}
+			if (verbose)
+				IJ.log("'frameInfos' has "+frameInfos.size()+" entries");
+		}
+		if (isVirtual && frameInfos.size()>0)	// Virtual Stack only needs reading the index
+			return;
+		// Read AVI (movie data) frame by frame - if no index tag is present the pointers
+		// for the virtual AVI stack will be read here
+		raFile.seek(headerPositionEnd);
+		if (firstFrame>1 && frameInfos.size()>0) {
+			long[] frameInfo = (long[])frameInfos.get(0);
+			raFile.seek(frameInfo[0]-8);		// chunk starts 8 bytes before frame data
+			frameNumber = firstFrame;
+			if (verbose)
+				IJ.log("directly go to frame "+firstFrame+" @ 0x"+Long.toHexString(frameInfo[0]-8));
+			readMovieData(fileSize);
+		} else {
+			frameNumber = 1;
+			findFourccAndRead(FOURCC_movi, true, fileSize, true);
+		}
+
+		long pos = raFile.getFilePointer();
+		//IJ.log("at 0x"+Long.toHexString(pos)+" filesize=0x"+Long.toHexString(fileSize));
+		// extended AVI: try to find further 'RIFF' chunks, where we expect AVIX tags
+		while (pos>0 && pos<fileSize && (frameNumber<lastFrameToRead+1))
+				pos = findFourccAndRead(FOURCC_RIFF, false, fileSize, false);
+		return;
+	 }
+
+	/** Open the file with given path and read its header */
+	private void openAndReadHeader (String path) throws Exception, IOException {
+		startTime = System.currentTimeMillis();
+		if (verbose)
+			IJ.log("OPEN AND READ AVI FILE HEADER "+timeString());
+		File file = new File(path);							// o p e n
+		raFile = new RandomAccessFile(file, "r");
+		raFilePath = path;
+		fileSize = raFile.length();
+		int fileType = readInt();							// f i l e	 h e a d e r
+		if (verbose)
+			IJ.log("File header: File type='"+fourccString(fileType)+"' (should be 'RIFF')"+timeString());
+		if (fileType != FOURCC_RIFF)
+			throw new Exception("Not an AVI file.");
+		aviSize = readInt() & SIZE_MASK;					//size of AVI chunk
+		int riffType = readInt();
+		if (verbose)
+			IJ.log("File header: RIFF type='"+fourccString(riffType)+"' (should be 'AVI ')");
+		if (riffType != FOURCC_AVI)
+			throw new Exception("Not an AVI file.");
+
+		findFourccAndRead(FOURCC_hdrl, true, fileSize, true);
+		startTime -= System.currentTimeMillis(); //becomes minus elapsed Time
+		headerOK = true;
+	}
+
+	/** Read AVIX chunks following the first RIFF AVI for large files (sequential reading frame-by-frame beyond the first chunk) **/
+	private void readAVIX(long endPosition) throws Exception, IOException {
+		if (verbose)
+			IJ.log("Trying to read AVIX"+timeString());
+		int riffType = readInt();
+		if (verbose)
+			IJ.log("File header: RIFF type='"+fourccString(riffType)+"' (should be 'AVIX')");
+		if (riffType != FOURCC_AVIX)
+			throw new Exception("Not an AVI file.");
+		findFourccAndRead(FOURCC_movi, true, fileSize, true); //read movie data
+	}
+
+	/** Find the next position of fourcc or LIST fourcc and read contents.
+	 *	Returns next position
+	 *	If not found, throws exception or returns -1 */
+	private long findFourccAndRead(int fourcc, boolean isList, long endPosition,
+	boolean throwNotFoundException) throws Exception, IOException {
+		long nextPos;
+		boolean contentOk = false;
+		do {
+			int type = readType(endPosition);
+			if (type == 0) {			//reached endPosition without finding
+				if (throwNotFoundException)
+					throw new Exception("Required item '"+fourccString(fourcc)+"' not found");
+				else
+					return -1;
+			}
+			long size = readInt() & SIZE_MASK;
+			nextPos = raFile.getFilePointer() + size;
+			if (nextPos>endPosition || nextPos>fileSize) {
+				errorText = "AVI File Error: '"+fourccString(type)+"' @ 0x"+Long.toHexString(raFile.getFilePointer()-8)+" has invalid length. File damaged/truncated?";
+				IJ.log(errorText);		// this text is also remembered as error message for showing in message box
+				if (fourcc == FOURCC_movi)
+                    nextPos = fileSize;	// if movie data truncated, try reading what we can get
+				else
+                    return -1;			// otherwise, nothing to be done
+			}
+			if (isList && type == FOURCC_LIST)
+				type = readInt();
+			if (verbose)
+				IJ.log("Search for '"+fourccString(fourcc)+"', found "+fourccString(type)+"' data "+posSizeString(nextPos-size, size));
+			if (type==fourcc) {
+				contentOk = readContents(fourcc, nextPos);
+			} else if (verbose)
+				IJ.log("'"+fourccString(type)+"', ignored");
+			raFile.seek(nextPos);
+			if (contentOk)
+				return nextPos;			//found and read, breaks the loop
+		} while (!contentOk);
+		return nextPos;
+	}
+
+	/** Find the next position of fourcc or LIST fourcc, but does not read it, only
+	 *	returns the first position inside the fourcc chunk and puts the file pointer
+	 *	behind the fourcc chunk (if successful).
+	 *	If not found, returns -1 */
+	private long findFourccAndSkip(int fourcc, boolean isList, long endPosition) throws IOException {
+		while (true) {
+			int type = readType(endPosition);
+			if (type == 0)				//reached endPosition without finding
+				return -1;
+			long size = readInt() & SIZE_MASK;
+			long chunkPos = raFile.getFilePointer();
+			long nextPos = chunkPos + size;	 //note that 'size' of a list includes the 'type' that follows now
+			if (isList && type == FOURCC_LIST)
+				type = readInt();
+			if (verbose)
+				IJ.log("Searching for (to skip) '"+fourccString(fourcc)+"', found "+fourccString(type)+
+						"' data "+posSizeString(chunkPos, size));
+			raFile.seek(nextPos);
+			if (type == fourcc)
+				return chunkPos;		//found and skipped, breaks the loop
+		}
+	}
+
+	/** read contents defined by four-cc code; returns true if contens ok */
+	private boolean readContents (int fourcc, long endPosition) throws Exception, IOException {
+		switch (fourcc) {
+			case FOURCC_hdrl:
+				headerPositionEnd = endPosition;
+				findFourccAndRead(FOURCC_avih, false, endPosition, true);
+				findFourccAndRead(FOURCC_strl, true, endPosition, true);
+				return true;
+			case FOURCC_avih:
+				readAviHeader();
+				return true;
+			case FOURCC_strl:
+				long nextPosition = findFourccAndRead(FOURCC_strh, false, endPosition, false);
+				if (nextPosition<0) return false;
+				indexPosition = findFourccAndRead(FOURCC_strf, false, endPosition, true);
+				indexPositionEnd= endPosition;
+				indexForCountingOnly = true;			//try reading indx for counting number of entries
+				totalFramesFromIndex = 0;
+				nextPosition = findFourccAndRead(FOURCC_indx, false, endPosition, false);
+				if (nextPosition > 0 && totalFramesFromIndex > dwTotalFrames)
+					dwTotalFrames = totalFramesFromIndex;
+				indexForCountingOnly = false;
+				return true;
+			case FOURCC_strh:
+				int streamType = readInt();
+				if (streamType != FOURCC_vids) {
+					if (verbose)
+						IJ.log("Non-video Stream '"+fourccString(streamType)+" skipped");
+					streamNumber++;
+					return false;
+				}
+				readStreamHeader();
+				return true;
+			case FOURCC_strf:
+				readBitMapInfo(endPosition);
+				return true;
+			case FOURCC_indx:
+			case FOURCC_ix00:
+				readAvi2Index(endPosition);
+				return true;
+			case FOURCC_idx1:
+				readOldFrameIndex(endPosition);
+				return true;
+			case FOURCC_RIFF:
+				readAVIX(endPosition);
+				return true;
+			case FOURCC_movi:
+				readMovieData(endPosition);
+				return true;
+		}
+		throw new Exception("Program error, type "+fourccString(fourcc));
+	}
+
+	void readAviHeader() throws Exception, IOException {		//'avih'
+		dwMicroSecPerFrame = readInt();
+		dwMaxBytesPerSec = readInt();
+		dwReserved1 = readInt(); //in newer avi formats, this is dwPaddingGranularity?
+		dwFlags = readInt();
+		dwTotalFrames = readInt();
+		dwInitialFrames = readInt();
+		dwStreams = readInt();
+		dwSuggestedBufferSize = readInt();
+		dwWidth = readInt();
+		dwHeight = readInt();
+		// dwReserved[4] follows, ignored
+
+		if (verbose) {
+			IJ.log("AVI HEADER (avih):"+timeString());
+			IJ.log("   dwMicroSecPerFrame=" + dwMicroSecPerFrame);
+			IJ.log("   dwMaxBytesPerSec=" + dwMaxBytesPerSec);
+			IJ.log("   dwReserved1=" + dwReserved1);
+			IJ.log("   dwFlags=" + dwFlags);
+			IJ.log("   dwTotalFrames=" + dwTotalFrames);
+			IJ.log("   dwInitialFrames=" + dwInitialFrames);
+			IJ.log("   dwStreams=" + dwStreams);
+			IJ.log("   dwSuggestedBufferSize=" + dwSuggestedBufferSize);
+			IJ.log("   dwWidth=" + dwWidth);
+			IJ.log("   dwHeight=" + dwHeight);
+		}
+	}
+
+	void readStreamHeader() throws Exception, IOException {		//'strh'
+		fccStreamHandler = readInt();
+		dwStreamFlags = readInt();
+		dwPriorityLanguage = readInt();
+		dwStreamInitialFrames = readInt();
+		dwStreamScale = readInt();
+		dwStreamRate = readInt();
+		dwStreamStart = readInt();
+		dwStreamLength = readInt();
+		dwStreamSuggestedBufferSize = readInt();
+		dwStreamQuality = readInt();
+		dwStreamSampleSize = readInt();
+		//rcFrame rectangle follows, ignored
+		if (verbose) {
+			IJ.log("VIDEO STREAM HEADER (strh):");
+			IJ.log("   fccStreamHandler='" + fourccString(fccStreamHandler)+"'");
+			IJ.log("   dwStreamFlags=" + dwStreamFlags);
+			IJ.log("   wPriority,wLanguage=" + dwPriorityLanguage);
+			IJ.log("   dwStreamInitialFrames=" + dwStreamInitialFrames);
+			IJ.log("   dwStreamScale=" + dwStreamScale);
+			IJ.log("   dwStreamRate=" + dwStreamRate);
+			IJ.log("   dwStreamStart=" + dwStreamStart);
+			IJ.log("   dwStreamLength=" + dwStreamLength);
+			IJ.log("   dwStreamSuggestedBufferSize=" + dwStreamSuggestedBufferSize);
+			IJ.log("   dwStreamQuality=" + dwStreamQuality);
+			IJ.log("   dwStreamSampleSize=" + dwStreamSampleSize);
+		}
+		if (dwStreamSampleSize > 1)
+			throw new Exception("Video stream with "+dwStreamSampleSize+" (more than 1) frames/chunk not supported");
+		// what the chunks in that stream will be named (we have two possibilites: uncompressed & compressed)
+		type0xdb = FOURCC_00db + (streamNumber<<8); //'01db' for stream 1, etc. (inverse byte order!)
+		type0xdc = FOURCC_00dc + (streamNumber<<8); //'01dc' for stream 1, etc.
+	}
+
+	/** Read 'AVI 2'-type main index 'indx' or an 'ix00' index to frames
+	 *	(only the types AVI_INDEX_OF_INDEXES and AVI_INDEX_OF_CHUNKS are supported) */
+	private void readAvi2Index(long endPosition) throws Exception, IOException {
+		short wLongsPerEntry = readShort();
+		byte bIndexSubType = raFile.readByte();
+		byte bIndexType = raFile.readByte();
+		int nEntriesInUse = readInt();
+		int dwChunkId = readInt();
+		long qwBaseOffset = readLong();
+		readInt();	// 3rd dwReserved (first two dwreserved are qwBaseOffset!)
+		if (verbose) {
+			String bIndexString = bIndexType == AVI_INDEX_OF_CHUNKS ? ": AVI_INDEX_OF_CHUNKS" :
+					bIndexType == AVI_INDEX_OF_INDEXES ? ": AVI_INDEX_OF_INDEXES" : ": UNSUPPORTED";
+			IJ.log("AVI 2 INDEX:");
+			IJ.log("   wLongsPerEntry=" + wLongsPerEntry);
+			IJ.log("   bIndexSubType=" + bIndexSubType);
+			IJ.log("   bIndexType=" + bIndexType + bIndexString);
+			IJ.log("   nEntriesInUse=" + nEntriesInUse);
+			IJ.log("   dwChunkId='" + fourccString(dwChunkId)+"'");
+			if (bIndexType == AVI_INDEX_OF_CHUNKS)
+				IJ.log("   qwBaseOffset=" + "0x"+Long.toHexString(qwBaseOffset));
+		}
+		if (bIndexType == AVI_INDEX_OF_INDEXES) {		// 'indx' points to other indices
+			if (wLongsPerEntry != 4) return;			//badly formed index, ignore it
+			for (int i=0;i<nEntriesInUse;i++) {			//read all entries (each pointing to an ix00 index)
+				long qwOffset = readLong();
+				int dwSize = readInt();
+				int dwDuration = readInt();				//number of frames in ix00; ignored: not always trustworthy
+				if (verbose)
+					IJ.log("   indx entry: '" +fourccString(dwChunkId)+"' incl header "+posSizeString(qwOffset,dwSize)+timeString());
+				long nextIndxEntryPointer = raFile.getFilePointer();
+				raFile.seek(qwOffset);					//qwOffset & dwSize here include chunk header of ix00	
+				findFourccAndRead(FOURCC_ix00, false, qwOffset+dwSize, false);				
+				raFile.seek(nextIndxEntryPointer);
+				if (frameNumber>lastFrameToRead) break;
+			}
+		} else if (bIndexType == AVI_INDEX_OF_CHUNKS) {
+			if (verbose) {
+				IJ.log("readAvi2Index frameNumber="+frameNumber+" firstFrame="+firstFrame);
+				if (indexForCountingOnly) IJ.log("<just counting frames, not interpreting index now>");
+			}
+			if (wLongsPerEntry != 2) return;				//badly formed index, ignore it
+			if (dwChunkId != type0xdb && dwChunkId != type0xdc) { //not the stream we search for? (should not happen)
+				if (verbose)
+					IJ.log("INDEX ERROR: SKIPPED ix00, wrong stream number or type, should be "+
+							fourccString(type0xdb)+" or "+fourccString(type0xdc));
+				return;
+			}
+			if (indexForCountingOnly) {					//only count number of entries, don't put into table
+				totalFramesFromIndex += nEntriesInUse;
+				return;
+			}
+			for (int i=0;i<nEntriesInUse;i++) {
+				long dwOffset = readInt() & 0xffffffffL;
+				long pos=qwBaseOffset+dwOffset;
+				int dwSize = readInt();
+				if (isVirtual) IJ.showProgress((double)frameNumber/lastFrameToRead);
+				if (frameNumber >= firstFrame && dwSize>0) { //only valid frames (no blank frames)
+					frameInfos.add(new long[] {pos, dwSize, (long) frameNumber*dwMicroSecPerFrame});
+					if (verbose)
+						IJ.log("movie data "+frameNumber+" '"+fourccString(dwChunkId)+"' "+posSizeString(pos,dwSize)+timeString());
+				}
+				frameNumber++;
+				if (frameNumber>lastFrameToRead) break;
+			}
+			if (verbose)
+				IJ.log("Index read up to frame "+(frameNumber-1));
+		}
+	}
+
+	/** Read AVI 1 index 'idx1' */
+	private void readOldFrameIndex(long endPosition) throws Exception, IOException {
+		//IJ.log("READ AVI 1 INDEX, isOversizedAvi1="+isOversizedAvi1);
+		int offset = -1;		//difference between absolute frame address and address given in idx1
+		int[] offsetsToTry = new int[] {0, (int)moviPosition}; // dwOffset may be w.r.t. file start or w.r.t. 'movi' list.
+		long lastFramePos = 0;
+		while (true) {
+			if ((raFile.getFilePointer()+16) >endPosition) break;
+
+			int dwChunkId = readInt();
+			int dwFlags = readInt();
+			int dwOffset = readInt();
+			int dwSize = readInt();
+			//IJ.log("idx1: dwOffset=0x"+Long.toHexString(dwOffset));
+			//IJ.log("moviPosition=0x"+Long.toHexString(moviPosition));
+			if ((dwChunkId==type0xdb || dwChunkId==type0xdc) && dwSize>0) {
+				if (offset < 0) {		// find out what the offset refers to
+					long temp = raFile.getFilePointer();
+					for (int i=0; i<offsetsToTry.length; i++) {
+						long pos = (dwOffset + offsetsToTry[i]) & SIZE_MASK;
+						if (pos < moviPosition) continue;	// frame must be in 'movi' list
+						raFile.seek(pos);
+						int chunkIdAtPos = readInt();		// see whether this offset points to the desired chunk
+						//IJ.log("read@=0x"+Long.toHexString(pos)+":  '"+fourccString(chunkIdAtPos)+"'");
+						if (chunkIdAtPos == dwChunkId) {
+							offset = offsetsToTry[i];
+							break;
+						}
+					}
+					if (verbose)
+						IJ.log("idx1: dwOffsets are w.r.t. 0x"+(offset<0 ? " UNKONWN??" : Long.toHexString(offset)));
+					raFile.seek(temp);
+					if (offset < 0) return;					// neither offset works
+				}
+				long framePos = (dwOffset & SIZE_MASK) + offset;
+				if (isOversizedAvi1)
+					while (framePos < lastFramePos) framePos += FOUR_GB; //index entries are modulo 2^32, assume frames are ascending
+				lastFramePos = framePos;
+				if (frameNumber >= firstFrame) {
+					frameInfos.add(new long[]{framePos+8, dwSize, (long)frameNumber*dwMicroSecPerFrame});
+					if (verbose)
+						IJ.log("idx1 movie data '"+fourccString(dwChunkId)+"' "+posSizeString(framePos,dwSize)+timeString());
+				}
+				frameNumber++;
+				if (frameNumber>lastFrameToRead) break;
+			} //if(dwChunkId...)
+		} //while(true)
+		if (verbose)
+			IJ.log("Index read up to frame "+(frameNumber-1));
+
+	}
+
+	/**Read stream format chunk: starts with BitMapInfo, may contain palette
+	*/
+	void readBitMapInfo(long endPosition) throws Exception, IOException {
+		biSize = readInt();
+		biWidth = readInt();
+		biHeight = readInt();
+		biPlanes = readShort();
+		biBitCount = readShort();
+		biCompression = readInt();
+		biSizeImage = readInt();
+		biXPelsPerMeter = readInt();
+		biYPelsPerMeter = readInt();
+		biClrUsed = readInt();
+		biClrImportant = readInt();
+		if (verbose) {
+			IJ.log("   biSize=" + biSize);
+			IJ.log("   biWidth=" + biWidth);
+			IJ.log("   biHeight=" + biHeight);
+			IJ.log("   biPlanes=" + biPlanes);
+			IJ.log("   biBitCount=" + biBitCount);
+			IJ.log("   biCompression=0x" + Integer.toHexString(biCompression)+" '"+fourccString(biCompression)+"'");
+			IJ.log("   biSizeImage=" + biSizeImage);
+			IJ.log("   biXPelsPerMeter=" + biXPelsPerMeter);
+			IJ.log("   biYPelsPerMeter=" + biYPelsPerMeter);
+			IJ.log("   biClrUsed=" + biClrUsed);
+			IJ.log("   biClrImportant=" + biClrImportant);
+		}
+
+		int allowedBitCount = 0;
+		boolean readPalette = false;
+		switch (biCompression) {
+			case NO_COMPRESSION:
+			case NO_COMPRESSION_RGB:
+			case NO_COMPRESSION_RAW:
+				dataCompression = NO_COMPRESSION;
+				dataTopDown = biHeight<0;	//RGB mode is usually bottom-up, negative height signals top-down
+				allowedBitCount = 8 | BITMASK24 | 32; //we don't support 1, 2 and 4 byte data
+				readPalette = biBitCount <= 8;
+				break;
+			case NO_COMPRESSION_Y8:
+			case NO_COMPRESSION_GREY:
+			case NO_COMPRESSION_Y800:
+				dataTopDown = true;
+				dataCompression = NO_COMPRESSION;
+				allowedBitCount = 8;
+				break;
+			case NO_COMPRESSION_Y16:
+			case NO_COMPRESSION_MIL:
+				dataCompression = NO_COMPRESSION;
+				allowedBitCount = 16;
+				break;
+			case AYUV_COMPRESSION:
+				dataCompression = AYUV_COMPRESSION;
+				allowedBitCount = 32;
+				break;
+			case UYVY_COMPRESSION:
+			case UYNV_COMPRESSION:
+				dataTopDown = true;
+			case CYUV_COMPRESSION:	//same, not top-down
+			case V422_COMPRESSION:
+				dataCompression = UYVY_COMPRESSION;
+				allowedBitCount = 16;
+				break;
+			case YUY2_COMPRESSION:
+			case YUNV_COMPRESSION:
+			case YUYV_COMPRESSION:
+				dataTopDown = true;
+				dataCompression = YUY2_COMPRESSION;
+				allowedBitCount = 16;
+				break;
+			case YVYU_COMPRESSION:
+				dataTopDown = true;
+				dataCompression = YVYU_COMPRESSION;
+				allowedBitCount = 16;
+				break;
+			case IYUV_COMPRESSION:
+			case I420_COMPRESSION:
+			case YV12_COMPRESSION:
+			case NV12_COMPRESSION:
+			case NV21_COMPRESSION:
+				dataCompression = (dataCompression==IYUV_COMPRESSION) ?
+						I420_COMPRESSION : biCompression;
+				dataTopDown = biHeight>0;
+				isPlanarFormat = true;
+				allowedBitCount = 12;
+				break;
+			case JPEG_COMPRESSION:
+			case JPEG_COMPRESSION2:
+			case JPEG_COMPRESSION3:
+			case MJPG_COMPRESSION:
+				dataCompression = JPEG_COMPRESSION;
+				variableLength = true;
+				break;
+			case PNG_COMPRESSION:
+			case PNG_COMPRESSION2:
+			case PNG_COMPRESSION3:
+				variableLength = true;
+				dataCompression = PNG_COMPRESSION;
+				break;
+			default:
+				throw new Exception("Unsupported compression: "+Integer.toHexString(biCompression)+
+						(biCompression>=0x20202020 ? " '" + fourccString(biCompression)+"'" : ""));
+		}
+
+		int bitCountTest = (biBitCount==24) ? BITMASK24 : biBitCount;  //convert "24" to a flag
+		if (allowedBitCount!=0 && (bitCountTest & allowedBitCount)==0)
+			throw new Exception("Unsupported: "+biBitCount+" bits/pixel for compression '"+
+					fourccString(biCompression)+"'");
+
+		if (biHeight < 0)		//negative height was for top-down data in RGB mode
+			biHeight = -biHeight;
+
+		if (isPlanarFormat && ((biWidth&1)!=0 || (biHeight&1)!=0))
+			throw new Exception("Odd size ("+biWidth+"x"+biHeight+") unsupported with "+fourccString(biCompression)+" compression");
+		// raw & interleaved YUV: scan line is padded with zeroes to be a multiple of four bytes
+		scanLineSize = isPlanarFormat ?
+				(biWidth * biBitCount) / 8 : ((biWidth * biBitCount + 31) / 32) * 4;
+
+		// a value of biClrUsed=0 means we determine this based on the bits per pixel, if there is a palette
+		long spaceForPalette  = endPosition-raFile.getFilePointer();
+		if (readPalette && biClrUsed==0 && spaceForPalette!=0)
+			biClrUsed = 1 << biBitCount;
+
+		if (verbose) {
+			IJ.log("   > data compression=0x" + Integer.toHexString(dataCompression)+" '"+fourccString(dataCompression)+"'");
+			IJ.log("   > palette colors=" + biClrUsed);
+			IJ.log("   > scan line size=" + scanLineSize);
+			IJ.log("   > data top down=" + dataTopDown);
+		}
+
+		//read color palette
+		if (readPalette && biClrUsed > 0) {
+			if (verbose)
+				IJ.log("   Reading "+biClrUsed+" Palette colors: " + posSizeString(spaceForPalette));
+			if (spaceForPalette < biClrUsed*4)
+				throw new Exception("Not enough data ("+spaceForPalette+") for palette of size "+(biClrUsed*4));
+			byte[]	pr	  = new byte[biClrUsed];
+			byte[]	pg	  = new byte[biClrUsed];
+			byte[]	pb	  = new byte[biClrUsed];
+			for (int i = 0; i < biClrUsed; i++) {
+				pb[i] = raFile.readByte();
+				pg[i] = raFile.readByte();
+				pr[i] = raFile.readByte();
+				raFile.readByte();
+			}
+			cm = new IndexColorModel(biBitCount, biClrUsed, pr, pg, pb);
+		}
+	}
+
+	/**Read from the 'movi' chunk. Skips audio ('..wb', etc.), 'LIST' 'rec' etc, only reads '..db' or '..dc'*/
+	void readMovieData(long endPosition) throws Exception, IOException {
+		if (verbose)
+			IJ.log("MOVIE DATA "+posSizeString(endPosition-raFile.getFilePointer())+timeString()+
+					"\nSearching for stream "+streamNumber+": '"+
+					fourccString(type0xdb)+"' or '"+fourccString(type0xdc)+"' chunks");
+		if (isVirtual) {
+			if (frameInfos==null)						// we might have it already from reading the first chunk
+				frameInfos = new Vector<long[]>(lastFrameToRead);	// holds frame positions in file (for non-constant frame sizes, should hold long[] with pos and size)
+		} else if (stack==null)
+				stack = new ImageStack(dwWidth, biHeight);
+		while (true) {									//loop over all chunks
+			int type = readType(endPosition);
+			if (type==0) break;							//endPosition of 'movi' reached?
+			long size = readInt() & SIZE_MASK;
+			long pos = raFile.getFilePointer();
+			long nextPos = pos + size;
+			if (nextPos > endPosition && nextPos < fileSize-8 && fileSize > FOUR_GB) {
+				endPosition =  fileSize;				//looks like old ImageJ AVI 1.0 >4GB: wrong endPosition
+			}
+			if ((type==type0xdb || type==type0xdc) && size>0) {
+				IJ.showProgress((double)frameNumber /lastFrameToRead);
+				if (verbose)
+					IJ.log(frameNumber+" movie data '"+fourccString(type)+"' "+posSizeString(size)+timeString());
+				if (frameNumber >= firstFrame) {
+					if (isVirtual)
+						frameInfos.add(new long[]{pos, size, frameNumber*dwMicroSecPerFrame});
+					else {						 //read the frame
+						Object pixels = readFrame(raFile, pos, (int)size);
+						String label = frameLabel(frameNumber*dwMicroSecPerFrame);
+						stack.addSlice(label, pixels);
+					}
+				}
+				frameNumber++;
+				if (frameNumber>lastFrameToRead) break;
+			} else if (verbose)
+				IJ.log("skipped '"+fourccString(type)+"' "+posSizeString(size));
+			if (nextPos > endPosition) break;
+			raFile.seek(nextPos);
+		}
+	}
+
+	/** Reads a frame at a given position in the file, returns pixels array */
+	private Object readFrame (RandomAccessFile rFile, long filePos, int size)
+			throws Exception, IOException {
+		rFile.seek(filePos);
+		//if (verbose)
+		//IJ.log("virtual AVI: readFrame @"+posSizeString(filePos, size)+" varlength="+variableLength);
+		if (variableLength)					//JPEG or PNG-compressed frames
+			return readCompressedFrame(rFile, size);
+		else
+			return readFixedLengthFrame(rFile, size);
+	}
+
+	/** Reads a JPEG or PNG-compressed frame from a RandomAccessFile and
+	 *	returns the pixels array of the resulting image and sets the
+	 *	ColorModel cm (if appropriate) */
+	private Object readCompressedFrame (RandomAccessFile rFile, int size)
+			throws Exception, IOException {
+		InputStream inputStream = new raInputStream(rFile, size, biCompression==MJPG_COMPRESSION);
+		BufferedImage bi = ImageIO.read(inputStream);
+		if (bi==null) throw new Exception("can't read frame, ImageIO returns null");
+		int type = bi.getType();
+		ImageProcessor ip = null;
+		if (type==BufferedImage.TYPE_BYTE_GRAY) {
+			ip = new ByteProcessor(bi);
+		} else if (type==bi.TYPE_BYTE_INDEXED) {
+			cm = bi.getColorModel();
+			ip = new ByteProcessor((Image)bi);
+		} else
+			ip =  new ColorProcessor(bi);
+		if (convertToGray)
+			ip = ip.convertToByte(false);
+		if (flipVertical)
+			ip.flipVertical();
+		if (ip.getWidth()!=dwWidth || ip.getHeight()!=biHeight)
+			ip = ip.resize(dwWidth, biHeight);
+		return ip.getPixels();
+	}
+
+	/** Read a fixed-length frame (RandomAccessFile rFile, long filePos, int size)
+	 *	return the pixels array of the resulting image
+	 */
+	private Object readFixedLengthFrame (RandomAccessFile rFile, int size)	throws Exception, IOException {
+		if (size < scanLineSize*biHeight)
+			size = scanLineSize*biHeight; // bugfix for RGB odd-width files
+		byte[] rawData = new byte[size];
+		int	 n	= rFile.read(rawData, 0, size);
+		if (n < rawData.length)
+			throw new Exception("Frame ended prematurely after " + n + " bytes");
+
+		boolean topDown = flipVertical ? !dataTopDown : dataTopDown;
+		Object pixels = null;
+		byte[] bPixels = null;
+		int[] cPixels = null;
+		short[] sPixels = null;
+		if (biBitCount <=8 || convertToGray) {
+			bPixels = new byte[dwWidth * biHeight];
+			pixels = bPixels;
+		} else if (biBitCount == 16 && dataCompression == NO_COMPRESSION) {
+			sPixels = new short[dwWidth * biHeight];
+			pixels = sPixels;
+		} else {
+			cPixels = new int[dwWidth * biHeight];
+			pixels = cPixels;
+		}
+		if (isPlanarFormat && !convertToGray)
+			unpackPlanarImage(rawData, cPixels, topDown);
+		else {
+			int	 offset		= topDown ? 0 : (biHeight-1)*dwWidth;
+			int	 rawOffset	= 0;
+			for (int i = biHeight - 1; i >= 0; i--) {  //for all lines
+				if (biBitCount <=8 || isPlanarFormat)
+					unpack8bit(rawData, rawOffset, bPixels, offset, dwWidth);
+				else if (convertToGray)
+					unpackGray(rawData, rawOffset, bPixels, offset, dwWidth);
+				else if (biBitCount==16 && dataCompression == NO_COMPRESSION)
+					unpackShort(rawData, rawOffset, sPixels, offset, dwWidth);
+				else
+					unpack(rawData, rawOffset, cPixels, offset, dwWidth);
+				rawOffset += isPlanarFormat ? dwWidth : scanLineSize;
+				offset += topDown ? dwWidth : -dwWidth;
+			}
+		}
+		return pixels;
+	}
+
+	/** For one line: copy byte data into the byte array for creating a ByteProcessor */
+	void unpack8bit(byte[] rawData, int rawOffset, byte[] pixels, int byteOffset, int w) {
+		for (int i = 0; i < w; i++)
+			pixels[byteOffset + i] = rawData[rawOffset + i];
+	}
+
+	/** For one line: Unpack and convert YUV or RGB video data to grayscale (byte array for ByteProcessor) */
+	void unpackGray(byte[] rawData, int rawOffset, byte[] pixels, int byteOffset, int w) {
+		int	 j	   = byteOffset;
+		int	 k	   = rawOffset;
+		if (dataCompression == 0) {
+			for (int i = 0; i < w; i++) {
+				int	 b0	 = (((int) (rawData[k++])) & 0xff);
+				int	 b1	 = (((int) (rawData[k++])) & 0xff);
+				int	 b2	 = (((int) (rawData[k++])) & 0xff);
+				if (biBitCount==32) k++; // ignore 4th byte (alpha value)
+				pixels[j++] = (byte)((b0*934 + b1*4809 + b2*2449 + 4096)>>13); //0.299*R+0.587*G+0.114*B
+			}
+		} else {
+			if (dataCompression==UYVY_COMPRESSION || dataCompression==AYUV_COMPRESSION)
+				k++; //skip first byte in these formats (chroma)
+			int step = dataCompression==AYUV_COMPRESSION ? 4 : 2;
+			for (int i = 0; i < w; i++) {
+				pixels[j++] = rawData[k];	//Non-standard: no scaling from 16-235 to 0-255 here
+				k+=step;
+			}
+		}
+	}
+
+	/** For one line: Unpack 16bit grayscale data and convert to short array for ShortProcessor */
+	void unpackShort(byte[] rawData, int rawOffset, short[] pixels, int shortOffset, int w) {
+		int	 j	   = shortOffset;
+		int	 k	   = rawOffset;
+		for (int i = 0; i < w; i++) {
+			pixels[j++] = (short) ((int)(rawData[k++] & 0xFF)| (((int)(rawData[k++] & 0xFF))<<8));
+		}
+	}
+
+	/** For one line: Read YUV, RGB or RGB+alpha data and writes RGB int array for ColorProcessor */
+	void unpack(byte[] rawData, int rawOffset, int[] pixels, int intOffset, int w) {
+		int	 j	   = intOffset;
+		int	 k	   = rawOffset;
+		switch (dataCompression) {
+			case NO_COMPRESSION:
+				for (int i = 0; i < w; i++) {
+					int	 b0	 = (((int) (rawData[k++])) & 0xff);
+					int	 b1	 = (((int) (rawData[k++])) & 0xff) << 8;
+					int	 b2	 = (((int) (rawData[k++])) & 0xff) << 16;
+					if (biBitCount==32) k++; // ignore 4th byte (alpha value)
+					pixels[j++] = 0xff000000 | b0 | b1 | b2;
+				}
+				break;
+			case YUY2_COMPRESSION:
+				for (int i = 0; i < w/2; i++) {
+					int y0 = rawData[k++] & 0xff;
+					int u  = rawData[k++] ^ 0xffffff80; //converts byte range 0...ff to -128 ... 127
+					int y1 = rawData[k++] & 0xff;
+					int v  = rawData[k++] ^ 0xffffff80;
+					writeRGBfromYUV(y0, u, v, pixels, j++);
+					writeRGBfromYUV(y1, u, v, pixels, j++);
+				}
+				break;
+			case UYVY_COMPRESSION:
+				for (int i = 0; i < w/2; i++) {
+					int u  = rawData[k++] ^ 0xffffff80;
+					int y0 = rawData[k++] & 0xff;
+					int v  = rawData[k++] ^ 0xffffff80;
+					int y1 = rawData[k++] & 0xff;
+					writeRGBfromYUV(y0, u, v, pixels, j++);
+					writeRGBfromYUV(y1, u, v, pixels, j++);
+				}
+				break;
+			case YVYU_COMPRESSION:
+				for (int i = 0; i < w/2; i++) {
+					int y0 = rawData[k++] & 0xff;
+					int v  = rawData[k++] ^ 0xffffff80;
+					int y1 = rawData[k++] & 0xff;
+					int u  = rawData[k++] ^ 0xffffff80;
+					writeRGBfromYUV(y0, u, v, pixels, j++);
+					writeRGBfromYUV(y1, u, v, pixels, j++);
+				}
+				break;
+			case AYUV_COMPRESSION:
+				for (int i = 0; i < w; i++) {
+					k++;	//ignore alpha channel
+					int y  = rawData[k++] & 0xff;
+					int v  = rawData[k++] ^ 0xffffff80;
+					int u  = rawData[k++] ^ 0xffffff80;
+					writeRGBfromYUV(y, u, v, pixels, j++);
+				}
+				break;
+
+		}
+	}
+
+	/** Unpack planar YV12 or I420 format (full frame). */
+	void unpackPlanarImage(byte[] rawData, int[] cPixels, boolean topDown) {
+		int w = dwWidth, h = dwHeight;
+		int uP =  w*h, vP = w*h;					// pointers in U, V array
+		int uvInc = (dataCompression==NV12_COMPRESSION || dataCompression==NV21_COMPRESSION) ?
+				2 : 1;	// NV12, NV21 have interleaved u,v
+		if (dataCompression == YV12_COMPRESSION)	// separate planes for U and V, 2-fold subsampling in x&y
+			uP += w*h/4; // first V, then U
+		else if (dataCompression == I420_COMPRESSION)
+			vP += w*h/4; // first U, then V
+		else if (dataCompression == NV12_COMPRESSION)
+			vP++;  //interleaved U, then V
+		else //NV21_COMPRESSION
+			uP++;
+		int lineOutInc = topDown ? w : -w;
+		for (int line=0; line<h; line+=2) {
+			int pRaw0 = line*w;
+			int pRawEnd = pRaw0 + w;
+			int pOut = topDown ? line*w : (h-line-1)*w;
+			for (int pRaw = pRaw0; pRaw < pRawEnd; ) {
+				int u = rawData[uP] ^ 0xffffff80;	// u and v for 2x2-pixel block
+				int v = rawData[vP] ^ 0xffffff80;
+				writeRGBfromYUV(rawData[pRaw] & 0xff, u, v, cPixels, pOut);
+				writeRGBfromYUV(rawData[pRaw+w] & 0xff, u, v, cPixels, pOut+lineOutInc);
+				pRaw++; pOut++;
+				writeRGBfromYUV(rawData[pRaw] & 0xff, u, v, cPixels, pOut);
+				writeRGBfromYUV(rawData[pRaw+w] & 0xff, u, v, cPixels, pOut+lineOutInc);
+				pRaw++; pOut++;
+				uP+=uvInc; vP+=uvInc;
+			}
+		}
+	}
+
+	/** Write an intData RGB value converted from YUV,
+	 *	The y range between 16 and 235 becomes 0...255
+	 *	u, v should be between -112 and +112
+	 */
+	final void writeRGBfromYUV(int y, int u, int v, int[]pixels, int intArrayIndex) {
+		//int r = (int)(1.164*(y-16)+1.596*v+0.5);
+		//int g = (int)(1.164*(y-16)-0.391*u-0.813*v+0.5);
+		//int b = (int)(1.164*(y-16)+2.018*u+0.5);
+		int r = (9535*y + 13074*v -148464) >> 13;
+		int g = (9535*y - 6660*v - 3203*u -148464) >> 13;
+		int b = (9535*y + 16531*u -148464) >> 13;
+		if (r>255) r=255; if (r<0) r=0;
+		if (g>255) g=255; if (g<0) g=0;
+		if (b>255) b=255; if (b<0) b=0;
+		pixels[intArrayIndex] = 0xff000000 | (r<<16) | (g<<8) | b;
+	}
+
+	/** Read 8-byte int with Intel (little-endian) byte order
+	 * (note: RandomAccessFile.readLong has other byte order than AVI) */
+
+	final long readLong() throws IOException {
+		long low = readInt() & 0x00000000FFFFFFFFL;
+		long high = readInt() & 0x00000000FFFFFFFFL;
+		long result = high <<32 | low;
+		return (long) result; //(high << 32 | low);
+	}
+	/** Read 4-byte int with Intel (little-endian) byte order
+	 * (note: RandomAccessFile.readInt has other byte order than AVI) */
+
+	final int readInt() throws IOException {
+		int	 result = 0;
+		for (int shiftBy = 0; shiftBy < 32; shiftBy += 8)
+			result |= (raFile.readByte() & 0xff) << shiftBy;
+		return result;
+	}
+
+	/** Read 2-byte short with Intel (little-endian) byte order
+	 * (note: RandomAccessFile.readShort has other byte order than AVI) */
+	final short readShort() throws IOException {
+		int	 low   = raFile.readByte() & 0xff;
+		int	 high  = raFile.readByte() & 0xff;
+		return (short) (high << 8 | low);
+	}
+
+	/** Read type of next chunk that is not JUNK.
+	 *	Returns type (or 0 if no non-JUNK chunk until endPosition) */
+	private int readType(long endPosition) throws IOException {
+		while (true) {
+			long pos = raFile.getFilePointer();
+			if (pos%paddingGranularity!=0) {
+				pos = (pos/paddingGranularity+1)*paddingGranularity;
+				raFile.seek(pos);	 //pad to even address
+			}
+			if (pos >= endPosition) return 0;
+			int type = readInt();
+			if (type != FOURCC_JUNK)
+				return type;
+			long size = readInt()&SIZE_MASK;
+			if (verbose)
+				IJ.log("Skip JUNK: "+posSizeString(size));
+			raFile.seek(raFile.getFilePointer()+size);	//skip junk
+		}
+	}
+
+	private void setFramesPerSecond (ImagePlus imp) {
+		if (dwMicroSecPerFrame<1000 && dwStreamRate>0)	//if no reasonable frame time, get it from rate
+			dwMicroSecPerFrame = (int)(dwStreamScale*1e6/dwStreamRate);
+		if (dwMicroSecPerFrame>=1000)
+			imp.getCalibration().fps = 1e6 / dwMicroSecPerFrame;
+	}
+
+	private String frameLabel(long timeMicroSec) {
+		return IJ.d2s(timeMicroSec/1.e6)+" s";
+	}
+
+	private String posSizeString(long size) throws IOException {
+		return posSizeString(raFile.getFilePointer(), size);
+	}
+
+	private String posSizeString(long pos, long size) {
+		return "0x"+Long.toHexString(pos)+"-0x"+Long.toHexString(pos+size-1)+" ("+size+" Bytes)";
+	}
+
+	private String timeString() {
+		return " (t="+(System.currentTimeMillis()-startTime)+" ms)";
+	}
+
+	/** returns a string of a four-cc code corresponding to an int (Intel byte order) */
+	private String fourccString(int fourcc) {
+		String s = "";
+		for (int i=0; i<4; i++) {
+			int c = fourcc&0xff;
+			s += Character.toString((char)c);
+			fourcc >>= 8;
+		}
+		return s;
+	}
+
+	/** tries to close the given file (if not null) */
+	private void closeFile(RandomAccessFile rFile) {
+		if (rFile != null) try {
+			rFile.close();
+        } catch (Exception e) {}
+	}
+
+	private void error(String msg) {
+		 aborting = true;
+		 IJ.error("AVI Reader", msg);
+	}
+
+	private String exceptionMessage (Exception e) {
+		String	msg;
+		if (e.getClass() == Exception.class)	//for "home-built" exceptions: message only
+			msg = e.getMessage();
+		else
+			msg = e + "\n" + e.getStackTrace()[0]+"\n"+e.getStackTrace()[1];
+		return "An error occurred reading the AVI file.\n \n" + msg;
+	}
+
+	/** An input stream reading from a RandomAccessFile (starting at the current position).
+	 *	This class also adds 'Define Huffman Table' (DHT) segments to convert MJPG to JPEG.
+	 */
+	final private static int BUFFERSIZE = 4096; //should be large enough to hold the full JFIF header
+							// up to beginning of the image data and the Huffman tables
+	final private static byte[] HUFFMAN_TABLES = new byte[] {	//the 'DHT' segment
+			(byte)0xFF,(byte)0xC4,0x01,(byte)0xA2,	//these 4 bytes are tag & length; data follow
+			0x00,0x00,0x01,0x05,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+			0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x01,0x00,0x03,0x01,0x01,0x01,0x01,
+			0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,
+			0x08,0x09,0x0A,0x0B,0x10,0x00,0x02,0x01,0x03,0x03,0x02,0x04,0x03,0x05,0x05,0x04,0x04,0x00,
+			0x00,0x01,0x7D,0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,
+			0x07,0x22,0x71,0x14,0x32,(byte)0x81,(byte)0x91,(byte)0xA1,0x08,0x23,0x42,
+			(byte)0xB1,(byte)0xC1,0x15,0x52,(byte)0xD1,(byte)0xF0,0x24,
+			0x33,0x62,0x72,(byte)0x82,0x09,0x0A,0x16,0x17,0x18,0x19,0x1A,0x25,0x26,0x27,0x28,0x29,0x2A,0x34,
+			0x35,0x36,0x37,0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,0x55,0x56,
+			0x57,0x58,0x59,0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x73,0x74,0x75,0x76,0x77,0x78,
+			0x79,0x7A,(byte)0x83,(byte)0x84,(byte)0x85,(byte)0x86,(byte)0x87,(byte)0x88,(byte)0x89,
+			(byte)0x8A,(byte)0x92,(byte)0x93,(byte)0x94,(byte)0x95,(byte)0x96,(byte)0x97,(byte)0x98,(byte)0x99,
+			(byte)0x9A,(byte)0xA2,(byte)0xA3,(byte)0xA4,(byte)0xA5,(byte)0xA6,(byte)0xA7,(byte)0xA8,(byte)0xA9,
+			(byte)0xAA,(byte)0xB2,(byte)0xB3,(byte)0xB4,(byte)0xB5,(byte)0xB6,(byte)0xB7,(byte)0xB8,(byte)0xB9,
+			(byte)0xBA,(byte)0xC2,(byte)0xC3,(byte)0xC4,(byte)0xC5,(byte)0xC6,(byte)0xC7,(byte)0xC8,(byte)0xC9,
+			(byte)0xCA,(byte)0xD2,(byte)0xD3,(byte)0xD4,(byte)0xD5,(byte)0xD6,(byte)0xD7,(byte)0xD8,(byte)0xD9,
+			(byte)0xDA,(byte)0xE1,(byte)0xE2,(byte)0xE3,(byte)0xE4,(byte)0xE5,(byte)0xE6,(byte)0xE7,(byte)0xE8,
+			(byte)0xE9,(byte)0xEA,(byte)0xF1,(byte)0xF2,(byte)0xF3,(byte)0xF4,(byte)0xF5,(byte)0xF6,(byte)0xF7,
+			(byte)0xF8,(byte)0xF9,(byte)0xFA,0x11,0x00,0x02,0x01,0x02,0x04,0x04,0x03,0x04,0x07,0x05,0x04,0x04,0x00,0x01,
+			0x02,0x77,0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,
+			0x13,0x22,0x32,(byte)0x81,0x08,0x14,0x42,(byte)0x91,(byte)0xA1,(byte)0xB1,(byte)0xC1,0x09,0x23,0x33,
+			0x52,(byte)0xF0,0x15,0x62,
+			0x72,(byte)0xD1,0x0A,0x16,0x24,0x34,(byte)0xE1,0x25,(byte)0xF1,0x17,0x18,0x19,0x1A,0x26,0x27,0x28,0x29,0x2A,
+			0x35,0x36,0x37,0x38,0x39,0x3A,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x53,0x54,0x55,0x56,
+			0x57,0x58,0x59,0x5A,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x73,0x74,0x75,0x76,0x77,0x78,
+			0x79,0x7A,(byte)0x82,(byte)0x83,(byte)0x84,(byte)0x85,(byte)0x86,(byte)0x87,(byte)0x88,(byte)0x89,
+			(byte)0x8A,(byte)0x92,(byte)0x93,(byte)0x94,(byte)0x95,(byte)0x96,(byte)0x97,(byte)0x98,
+			(byte)0x99,(byte)0x9A,(byte)0xA2,(byte)0xA3,(byte)0xA4,(byte)0xA5,(byte)0xA6,(byte)0xA7,(byte)0xA8,
+			(byte)0xA9,(byte)0xAA,(byte)0xB2,(byte)0xB3,(byte)0xB4,(byte)0xB5,(byte)0xB6,(byte)0xB7,(byte)0xB8,
+			(byte)0xB9,(byte)0xBA,(byte)0xC2,(byte)0xC3,(byte)0xC4,(byte)0xC5,(byte)0xC6,(byte)0xC7,(byte)0xC8,
+			(byte)0xC9,(byte)0xCA,(byte)0xD2,(byte)0xD3,(byte)0xD4,(byte)0xD5,(byte)0xD6,(byte)0xD7,(byte)0xD8,
+			(byte)0xD9,(byte)0xDA,(byte)0xE2,(byte)0xE3,(byte)0xE4,(byte)0xE5,(byte)0xE6,(byte)0xE7,(byte)0xE8,
+			(byte)0xE9,(byte)0xEA,(byte)0xF2,(byte)0xF3,(byte)0xF4,(byte)0xF5,(byte)0xF6,(byte)0xF7,(byte)0xF8,
+			(byte)0xF9,(byte)0xFA };
+	final private static int HUFFMAN_LENGTH = 420;
+
+	class raInputStream extends InputStream {
+		RandomAccessFile rFile; //where to read the data from
+		int readableSize;		//number of bytes that one should expect to be readable
+		boolean fixMJPG;		//whether to use an ugly hack to convert MJPG frames to JPEG
+		byte[] buffer;			//holds beginning of data for fixing Huffman tables
+		int bufferPointer;		//next position in buffer to read
+		int bufferLength;		//bytes allocated in buffer
+
+		/** Constructor */
+		raInputStream (RandomAccessFile rFile, int readableSize, boolean fixMJPG) throws IOException {
+			this.rFile = rFile;
+			this.readableSize = readableSize;
+			this.fixMJPG = fixMJPG;
+			if (fixMJPG) {
+				buffer = new byte[BUFFERSIZE];
+				bufferLength = Math.min(BUFFERSIZE-HUFFMAN_LENGTH, readableSize);
+				bufferLength = rFile.read(buffer, 0, bufferLength);
+				addHuffmanTables();
+			}
+		}
+
+		public int available () {
+			return readableSize;
+		}
+
+		// Read methods:
+		// There is no check against reading beyond the allowed range, which is
+		// start position + readableSize
+		// (i.e., reading beyond the frame in the avi file would be possible).
+		/** Read a single byte */
+		public int read () throws IOException {
+			readableSize--;
+			if (fixMJPG) {
+				int result = buffer[bufferPointer] & 0xff;
+				bufferPointer++;
+				if (bufferPointer >= bufferLength) fixMJPG = false; //buffer exhausted, no more attempt to fix it
+				return result;
+			} else
+				return rFile.read();
+		}
+
+		/** Read bytes into an array */
+		public int read (byte[] b, int off, int len) throws IOException {
+			//IJ.log("read "+len+" bytes, fix="+fixMJPG);
+			int nBytes;
+			if (fixMJPG) {
+				nBytes = Math.min(len, bufferLength-bufferPointer);
+				System.arraycopy(buffer, bufferPointer, b, off, nBytes);
+				bufferPointer += nBytes;
+				if (bufferPointer >= bufferLength) {
+					fixMJPG = false;
+					if (len-nBytes > 0)
+						nBytes += rFile.read(b, off+nBytes, len-nBytes);
+				}
+			} else
+				nBytes = rFile.read(b, off, len);
+			readableSize -= nBytes;
+			return nBytes;
+		}
+		// Add Huffman table if not present yet
+		private void addHuffmanTables() {
+			if (readShort(0)!=0xffd8 || bufferLength<6) return;	  //not a start of JPEG-like data
+			int offset = 2;
+			int segmentLength = 0;
+			do {
+				int code = readShort(offset);				//read segment type
+				//IJ.log("code=0x"+Long.toHexString(code));
+				if (code==0xffc4)							//Huffman table found, nothing to do
+					return;
+				else if (code==0xffda || code==0xffd9) {	//start of image data or end of image?
+					insertHuffmanTables(offset);
+					return;									//finished
+				}
+				offset += 2;
+				segmentLength = readShort(offset);			//read length of this segment
+				offset += segmentLength;					//and skip the segment contents
+			} while (offset<bufferLength-4 && segmentLength>=0);
+		}
+
+		// read a short from the buffer
+		private int readShort(int offset) {
+			return ((buffer[offset]&0xff)<<8) | (buffer[offset+1]&0xff);
+		}
+
+		// insert Huffman tables at the given position
+		private void insertHuffmanTables(int position) {
+			//IJ.log("inserting Huffman tables");
+			System.arraycopy(buffer, position, buffer, position+HUFFMAN_LENGTH, bufferLength-position);
+			System.arraycopy(HUFFMAN_TABLES, 0, buffer, position, HUFFMAN_LENGTH);
+			bufferLength += HUFFMAN_LENGTH;
+			readableSize += HUFFMAN_LENGTH;
+		}
+	}
+
+	public void displayDialog(boolean displayDialog) {
+		this.displayDialog = displayDialog;
+	}
+
+	/** Open as virtual stack? */
+	public void setVirtual(boolean virtual) {
+		isVirtual = virtual;
+	}
+
+}
diff --git a/src/ij/plugin/AboutBox.java b/src/ij/plugin/AboutBox.java
new file mode 100644
index 0000000..ca22d6d
--- /dev/null
+++ b/src/ij/plugin/AboutBox.java
@@ -0,0 +1,76 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.io.*;
+import java.net.URL;
+import java.awt.image.*;
+
+	/** This plugin implements the Help/About ImageJ command by opening
+	 * about.jpg in ij.jar, scaling it 600% and adding text to an overlay.
+	*/
+	public class AboutBox implements PlugIn {
+		private static final int SMALL_FONT=20, LARGE_FONT=45;
+		private static final Color TEXT_COLOR = new Color(255,255,80);
+
+	public void run(String arg) {
+		System.gc();
+		int lines = 7;
+		String[] text = new String[lines];
+		text[0] = "ImageJ "+ImageJ.VERSION+ImageJ.BUILD;
+		text[1] = "Wayne Rasband and contributors";
+		text[2] = "National Institutes of Health, USA";
+		text[3] = IJ.URL;
+		text[4] = "Java "+System.getProperty("java.version")+(IJ.is64Bit()?" (64-bit)":" (32-bit)");
+		text[5] = IJ.freeMemory();
+		text[6] = "ImageJ is in the public domain";
+		ImageProcessor ip = null;
+		ImageJ ij = IJ.getInstance();
+		URL url = ij .getClass() .getResource("/about.jpg");
+		if (url!=null) {
+			Image img = null;
+			try {img = ij.createImage((ImageProducer)url.getContent());}
+			catch(Exception e) {}
+			if (img!=null) {
+				ImagePlus sImp = new ImagePlus("", img);
+				ip = sImp.getProcessor();
+			}
+		}
+		if (ip==null) 
+			ip =  new ColorProcessor(55,45);
+		ip = ip.resize(ip.getWidth()*6, ip.getHeight()*6);
+		ImagePlus imp = new ImagePlus("About ImageJ", ip);
+		int width = imp.getWidth();
+		Overlay overlay = new Overlay();
+		Font font = new Font("SansSerif", Font.PLAIN, LARGE_FONT);
+		int y  = 60;
+		add(text[0], width-20, y, font, TextRoi.RIGHT, overlay);
+		int xcenter = 410;
+		font = new Font("SansSerif", Font.PLAIN, SMALL_FONT);
+		y += 45;
+		add(text[1], xcenter, y, font, TextRoi.CENTER, overlay);
+		y += 27;
+		add(text[2], xcenter, y, font, TextRoi.CENTER, overlay);
+		y += 27;
+		add(text[3], xcenter, y, font, TextRoi.CENTER, overlay);
+		y += 27;
+		add(text[4], xcenter, y, font, TextRoi.CENTER, overlay);
+		if (IJ.maxMemory()>0L) {
+			y += 27;
+			add(text[5], xcenter, y, font, TextRoi.CENTER, overlay);
+		}
+		add(text[6], width-10, ip.getHeight()-10, font, TextRoi.RIGHT, overlay);
+		imp.setOverlay(overlay);
+		ImageWindow.centerNextImage();
+		imp.show();
+	}
+	
+	private void add(String text, int x, int y, Font font, int justification, Overlay overlay) {
+		TextRoi roi = new TextRoi(text, x, y, font);
+		roi.setStrokeColor(TEXT_COLOR);
+		roi.setJustification(justification);
+		overlay.add(roi);
+	}
+
+}
diff --git a/src/ij/plugin/Animator.java b/src/ij/plugin/Animator.java
new file mode 100644
index 0000000..631fc6a
--- /dev/null
+++ b/src/ij/plugin/Animator.java
@@ -0,0 +1,398 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import ij.plugin.frame.Recorder;
+import java.awt.Point;
+
+/** This plugin animates stacks. */
+public class Animator implements PlugIn {
+
+	private static double animationRate = Prefs.getDouble(Prefs.FPS, 7.0);
+	private static int firstFrame=0, lastFrame=0;
+	private ImagePlus imp;
+	private StackWindow swin;
+	private int slice;
+	private int nSlices;	
+	/** Set 'arg' to "set" to display a dialog that allows the user to specify the
+		animation speed. Set it to "start" to start animating the current stack.
+		Set it to "stop" to stop animation. Set it to "next" or "previous"
+		to stop any animation and display the next or previous frame. 
+	*/
+	public void run(String arg) {
+		imp = IJ.getImage();
+		nSlices = imp.getStackSize();
+		if (nSlices<2)
+			{IJ.error("Stack required."); return;}
+		if (imp.isLocked())
+			{IJ.beep(); IJ.showStatus("Image is locked: \""+imp.getTitle()+"\""); return;}
+		ImageWindow win = imp.getWindow();
+		if ((win==null || !(win instanceof StackWindow)) && !arg.equals("options")) {
+			if (arg.equals("next"))
+				imp.setSlice(imp.getCurrentSlice()+1);
+			else if (arg.equals("previous"))
+				imp.setSlice(imp.getCurrentSlice()-1);
+			if (win!=null) imp.updateStatusbarValue();
+			return;
+		}
+		swin = (StackWindow)win;
+		ImageStack stack = imp.getStack();
+		slice = imp.getCurrentSlice();
+		IJ.register(Animator.class);
+		
+		if (arg.equals("options")) {
+			doOptions();
+			return;
+		}
+			
+		if (arg.equals("start")) {
+			startAnimation();
+			return;
+		}
+
+		//if (swin.getAnimate()) // "stop", "next" and "previous" all stop animation
+		//	stopAnimation();
+
+		if (arg.equals("stop")) {
+			stopAnimation();
+			return;
+		}
+			
+		if (arg.equals("next")) {
+			if (Prefs.reverseNextPreviousOrder)
+				changeSlice(1);
+			else
+				nextSlice();
+			return;
+		}
+		
+		if (arg.equals("previous")) {
+			if (Prefs.reverseNextPreviousOrder)
+				changeSlice(-1);
+			else
+				previousSlice();
+			return;
+		}
+		
+		if (arg.equals("set")) {
+			setSlice();
+			return;
+		}
+	}
+
+	void stopAnimation() {
+		swin.setAnimate(false);
+		IJ.wait(500+(int)(1000.0/animationRate));
+	}
+
+	void startAnimation() {
+		int first=firstFrame, last=lastFrame;
+		if (first<1 || first>nSlices || last<1 || last>nSlices)
+			{first=1; last=nSlices;}
+		if (swin.getAnimate())
+			{stopAnimation(); return;}
+		swin.setAnimate(true);
+		long time, nextTime=System.currentTimeMillis();
+		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
+		int sliceIncrement = 1;
+		Calibration cal = imp.getCalibration();
+		if (cal.fps!=0.0)
+			animationRate = cal.fps;
+		if (animationRate<0.1) {
+			animationRate = 1.0;
+			cal.fps = animationRate;
+		}
+		int frames = imp.getNFrames();
+		int slices = imp.getNSlices();
+		
+		if (imp.isDisplayedHyperStack() && frames>1) {
+			int frame = imp.getFrame();
+			first = 1;
+			last = frames;
+			while (swin.getAnimate()) {
+				time = System.currentTimeMillis();
+				if (time<nextTime)
+					IJ.wait((int)(nextTime-time));
+				else
+					Thread.yield();
+				nextTime += (long)(1000.0/animationRate);
+				frame += sliceIncrement;
+				if (frame<first) {
+					frame = first+1;
+					sliceIncrement = 1;
+				}
+				if (frame>last) {
+					if (cal.loop) {
+						frame = last-1;
+						sliceIncrement = -1;
+					} else {
+						frame = first;
+						sliceIncrement = 1;
+					}
+				}
+				if (imp.isLocked()) return;
+				imp.setPosition(imp.getChannel(), imp.getSlice(), frame);
+				imp.updateStatusbarValue();
+			}
+			return;
+		}
+
+		if (imp.isDisplayedHyperStack() && slices>1) {
+			slice = imp.getSlice();
+			first = 1;
+			last = slices;
+			while (swin.getAnimate()) {
+				time = System.currentTimeMillis();
+				if (time<nextTime)
+					IJ.wait((int)(nextTime-time));
+				else
+					Thread.yield();
+				nextTime += (long)(1000.0/animationRate);
+				slice += sliceIncrement;
+				if (slice<first) {
+					slice = first+1;
+					sliceIncrement = 1;
+				}
+				if (slice>last) {
+					if (cal.loop) {
+						slice = last-1;
+						sliceIncrement = -1;
+					} else {
+						slice = first;
+						sliceIncrement = 1;
+					}
+				}
+				if (imp.isLocked()) return;
+				imp.setPosition(imp.getChannel(), slice, imp.getFrame());
+				imp.updateStatusbarValue();
+			}
+			return;
+		}
+		
+		long startTime=System.currentTimeMillis();
+		int count = 0;
+		double fps = 0.0;
+		while (swin.getAnimate()) {
+			time = System.currentTimeMillis();
+			count++;
+			if (time>startTime+1000L) {
+				startTime=System.currentTimeMillis();
+				fps=count;
+				count=0;
+			}
+			ImageCanvas ic = imp.getCanvas();
+			boolean showFrameRate = !(ic!=null?ic.cursorOverImage():false);
+			if (showFrameRate)
+				IJ.showStatus((int)(fps+0.5) + " fps");
+			if (time<nextTime)
+				IJ.wait((int)(nextTime-time));
+			else
+				Thread.yield();
+			nextTime += (long)Math.round(1000.0/animationRate);
+			slice += sliceIncrement;
+			if (slice<first) {
+				slice = first+1;
+				sliceIncrement = 1;
+			}
+			if (slice>last) {
+				if (cal.loop) {
+					slice = last-1;
+					sliceIncrement = -1;
+				} else {
+					slice = first;
+					sliceIncrement = 1;
+				}
+			}
+			if (imp.isLocked()) return;
+			swin.showSlice(slice);
+			if (!showFrameRate)
+				imp.updateStatusbarValue();
+		}
+	}
+
+	void doOptions() {
+		if (firstFrame<1 || firstFrame>nSlices || lastFrame<1 || lastFrame>nSlices)
+			{firstFrame=1; lastFrame=nSlices;}
+		if (imp.isDisplayedHyperStack()) {
+			int frames = imp.getNFrames();
+			int slices = imp.getNSlices();
+			firstFrame = 1;
+			if (frames>1)
+				lastFrame = frames;
+			else if (slices>1)
+				lastFrame=slices;
+		}
+		boolean start = swin!=null && !swin.getAnimate();
+		Calibration cal = imp.getCalibration();
+		if (cal.fps!=0.0)
+			animationRate = cal.fps;
+		else if (cal.frameInterval!=0.0 && cal.getTimeUnit().equals("sec"))
+			animationRate = 1.0/cal.frameInterval;
+		int decimalPlaces = (int)animationRate==animationRate?0:3;
+		GenericDialog gd = new GenericDialog("Animation Options");
+		gd.addNumericField("Speed (0.1-1000 fps):", animationRate, decimalPlaces);
+		if (!imp.isDisplayedHyperStack()) {
+			gd.addNumericField("First Frame:", firstFrame, 0);
+			gd.addNumericField("Last Frame:", lastFrame, 0);
+		}
+		gd.addCheckbox("Loop Back and Forth", cal.loop);
+		gd.addCheckbox("Start Animation", start);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			if (firstFrame==1 && lastFrame==nSlices)
+				{firstFrame=0; lastFrame=0;}
+			return;
+		}
+		double speed = gd.getNextNumber();
+		if (!imp.isDisplayedHyperStack()) {
+			firstFrame = (int)gd.getNextNumber();
+			lastFrame = (int)gd.getNextNumber();
+		}
+		if (firstFrame==1 && lastFrame==nSlices)
+			{firstFrame=0; lastFrame=0;}
+		cal.loop = gd.getNextBoolean();
+		Calibration.setLoopBackAndForth(cal.loop);
+		start = gd.getNextBoolean();
+		if (speed>1000.0) speed = 1000.0;
+		//if (speed<0.1) speed = 0.1;
+		animationRate = speed;
+		if (animationRate!=0.0)
+			cal.fps = animationRate;
+		if (start && swin!=null && !swin.getAnimate())
+			startAnimation();
+	}
+	
+	void nextSlice() {
+		boolean hyperstack = imp.isDisplayedHyperStack();
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		if (hyperstack && channels>1 && !((slices>1||frames>1)&&(IJ.controlKeyDown()||IJ.spaceBarDown()||IJ.altKeyDown()))) {
+			int c = imp.getChannel() + 1;
+			if (c>channels) c = channels;
+			swin.setPosition(c, imp.getSlice(), imp.getFrame());
+		} else if (hyperstack && slices>1 && !(frames>1&&IJ.altKeyDown())) {
+			int z = imp.getSlice() + 1;
+			if (z>slices) z = slices;
+			swin.setPosition(imp.getChannel(), z, imp.getFrame());
+		} else if (hyperstack && frames>1) {
+			int t = imp.getFrame() + 1;
+			if (t>frames) t = frames;
+			swin.setPosition(imp.getChannel(), imp.getSlice(), t);
+		} else {
+			if (IJ.altKeyDown())
+				slice += 10;
+			else
+				slice++;
+			if (slice>nSlices)
+				slice = nSlices;
+			swin.showSlice(slice);
+		}
+		imp.updateStatusbarValue();
+	}	
+	
+	void previousSlice() {
+		boolean hyperstack = imp.isDisplayedHyperStack();
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		if (hyperstack && channels>1 && !((slices>1||frames>1)&&(IJ.controlKeyDown()||IJ.spaceBarDown()||IJ.altKeyDown()))) {
+			int c = imp.getChannel() - 1;
+			if (c<1) c = 1;
+			swin.setPosition(c, imp.getSlice(), imp.getFrame());
+		} else if (hyperstack && slices>1 && !(frames>1&&IJ.altKeyDown())) {
+			int z = imp.getSlice() - 1;
+			if (z<1) z = 1;
+			swin.setPosition(imp.getChannel(), z, imp.getFrame());
+		} else if (hyperstack && frames>1) {
+			int t = imp.getFrame() - 1;
+			if (t<1) t = 1;
+			swin.setPosition(imp.getChannel(), imp.getSlice(), t);
+		} else {
+			if (IJ.altKeyDown())
+				slice -= 10;
+			else
+				slice--;
+			if (slice<1)
+				slice = 1;
+			swin.showSlice(slice);
+		}
+		imp.updateStatusbarValue();
+	}
+
+	void changeSlice(int pn) {
+		boolean hyperstack = imp.isDisplayedHyperStack();
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		if (swin.getAnimate() && (channels*slices*frames==Math.max(channels,Math.max(slices,frames))) )
+			{stopAnimation(); return;} //if only one dimension, stop animating
+		if(hyperstack){
+			int c=imp.getChannel(); int z=imp.getSlice(); int t=imp.getFrame();
+			if (frames>1 && !((slices>1||channels>1)&&(IJ.controlKeyDown()||IJ.spaceBarDown()||IJ.altKeyDown()) || swin.getAnimate())){
+				t += pn;
+				if (t>frames) t = frames;
+				if (t<1) t = 1;
+			} else if (slices>1 && !(channels>1&& (IJ.altKeyDown() || IJ.spaceBarDown()) || ((swin.getAnimate()|| IJ.controlKeyDown()) && frames==1)) ) {
+				z += pn;
+				if (z>slices) z = slices;
+				if (z<1) z = 1;
+			} else if (channels>1) {
+				c += pn;
+				if (c>channels) c = channels;
+				if (c<1) c = 1;
+			}
+			swin.setPosition(c, z, t);
+		} else {
+			if (IJ.altKeyDown())
+				slice+=(pn*10);
+			else
+				slice+=pn;
+			if (slice>nSlices)
+				slice = nSlices;
+			if (slice<1)
+				slice = 1;
+			swin.showSlice(slice);
+		}
+		imp.updateStatusbarValue();
+	}
+	
+	void setSlice() {
+		if (imp.isDisplayedHyperStack()) {
+			GenericDialog gd = new GenericDialog("Set Position");
+			int c = imp.getChannel();
+			int z = imp.getSlice();
+			int t = imp.getFrame();			
+			gd.addNumericField("Channel:", c);
+			gd.addNumericField("Slice:", z);
+			gd.addNumericField("Frame:", t);
+			gd.showDialog();
+			if (!gd.wasCanceled()) {
+				c = (int) gd.getNextNumber();
+				z = (int) gd.getNextNumber();
+				t = (int) gd.getNextNumber();
+				imp.setPosition(c, z, t);
+			}
+			if (Recorder.record) {
+				String method = Recorder.scriptMode()?"imp":"Stack";
+				Recorder.recordString(method+".setPosition("+c+","+z+","+t+");\n");
+				Recorder.disableCommandRecording();
+			}
+		} else {
+			GenericDialog gd = new GenericDialog("Set Slice");
+			gd.addNumericField("Slice (1-"+nSlices+"):", slice, 0);
+			gd.showDialog();
+			if (!gd.wasCanceled()) {
+				int slice = (int)gd.getNextNumber();
+				imp.setSlice(slice);
+			}
+		}
+	}
+
+	/** Returns the current animation speed in frames per second. */
+	public static double getFrameRate() {
+		return animationRate;
+	}
+
+}
diff --git a/src/ij/plugin/AppearanceOptions.java b/src/ij/plugin/AppearanceOptions.java
new file mode 100644
index 0000000..bd96d6e
--- /dev/null
+++ b/src/ij/plugin/AppearanceOptions.java
@@ -0,0 +1,189 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.io.*;
+import ij.plugin.filter.*;
+import ij.plugin.frame.*;
+import ij.measure.Calibration;
+import java.awt.*;
+
+/** This plugin implements the Edit/Options/Appearance command. */
+public class AppearanceOptions implements PlugIn, DialogListener {
+	private boolean interpolate = Prefs.interpolateScaledImages;
+	private boolean open100 = Prefs.open100Percent;
+	private boolean black = Prefs.blackCanvas;
+	private boolean noBorder = Prefs.noBorder;
+	private boolean inverting = Prefs.useInvertingLut;
+	private int rangeIndex = ContrastAdjuster.get16bitRangeIndex();
+	private LUT[] luts = getLuts();
+	private int menuFontSize = Menus.getFontSize();
+	private double saveScale = Prefs.getGuiScale();
+	private boolean redrawn, repainted;
+
+ 	public void run(String arg) {
+ 		showDialog();
+ 	}
+		
+	void showDialog() {
+		String[] ranges = ContrastAdjuster.getSixteenBitRanges();
+		GenericDialog gd = new GenericDialog("Appearance");
+		gd.addCheckbox("Interpolate zoomed images", Prefs.interpolateScaledImages);
+		gd.addCheckbox("Open images at 100%", Prefs.open100Percent);
+		gd.addCheckbox("Black canvas", Prefs.blackCanvas);
+		gd.addCheckbox("No image border", Prefs.noBorder);
+		gd.addCheckbox("Use inverting lookup table", Prefs.useInvertingLut);
+		gd.addCheckbox("Auto contrast stacks", Prefs.autoContrast);
+		gd.addCheckbox("IJ window always on top", Prefs.alwaysOnTop);
+		if (IJ.isLinux())
+			gd.addCheckbox("Cancel button on right", Prefs.dialogCancelButtonOnRight);
+		gd.addChoice("16-bit range:", ranges, ranges[rangeIndex]);
+		Font font = new Font("SansSerif", Font.PLAIN, 9);
+		if (!IJ.isMacOSX()) {
+			gd.setInsets(0, 0, 0);
+			gd.addNumericField("Menu font size:", Menus.getFontSize(), 0, 4, "points");
+			if (IJ.isWindows()) {
+				gd.setInsets(2,30,5);
+				gd.addMessage("Setting size>17 may not work on Windows", font);
+			}
+		}
+		gd.setInsets(0, 0, 0);
+		gd.addNumericField("GUI scale (0.5-3.0):", Prefs.getGuiScale(), 1, 4, "");
+		gd.setInsets(2,20,0);
+		gd.addMessage("Set to 1.5 to double size of tool icons, or 2.5 to triple", font);
+		gd.addHelp(IJ.URL+"/docs/menus/edit.html#appearance");
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			Prefs.interpolateScaledImages = interpolate;
+			Prefs.open100Percent = open100;
+			Prefs.blackCanvas = black;
+			Prefs.noBorder = noBorder;
+			Prefs.useInvertingLut = inverting;
+			Prefs.setGuiScale(saveScale);
+			if (redrawn) draw();
+			if (repainted) repaintWindow();
+			Prefs.open100Percent = open100;
+			if (rangeIndex!=ContrastAdjuster.get16bitRangeIndex()) {
+				ContrastAdjuster.set16bitRange(rangeIndex);
+				ImagePlus imp = WindowManager.getCurrentImage();
+				Calibration cal = imp!=null?imp.getCalibration():null;
+				if (imp!=null && imp.getType()==ImagePlus.GRAY16 && !cal.isSigned16Bit()) {
+					imp.resetDisplayRange();
+					if (rangeIndex==0 && imp.isComposite() && luts!=null)
+						((CompositeImage)imp).setLuts(luts);
+					imp.updateAndDraw();
+				}
+			}
+			return;
+		}
+		boolean messageShown = false;
+		double scale =  Prefs.getGuiScale();
+		if (scale!=saveScale) {
+			if (!IJ.isMacOSX()) {
+				IJ.showMessage("Appearance", "Restart ImageJ to resize \"ImageJ\" window");
+				messageShown = true;
+			} else {
+				ImageJ ij = IJ.getInstance();
+				if (ij!=null)
+					ij.resize();
+			}	
+		}
+		boolean fontSizeChanged = menuFontSize!=Menus.getFontSize();
+		if (fontSizeChanged)
+			Menus.setFontSize(menuFontSize);
+		if (!messageShown && fontSizeChanged && !IJ.isMacOSX())
+			IJ.showMessage("Appearance", "Restart ImageJ to use the new font size");
+		if (Prefs.useInvertingLut) {
+			IJ.showMessage("Appearance",
+				"The \"Use inverting lookup table\" option is set. Newly opened\n"+
+				"8-bit images will use an inverting LUT (white=0, black=255).");
+		}
+		int range = ImagePlus.getDefault16bitRange();
+		if (range>0 && Recorder.record) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("ImagePlus.setDefault16bitRange("+range+");");
+			else
+				Recorder.recordString("call(\"ij.ImagePlus.setDefault16bitRange\", "+range+");\n");
+		}
+
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (IJ.isMacOSX()) IJ.wait(100);
+		boolean interpolate = gd.getNextBoolean();
+		Prefs.open100Percent = gd.getNextBoolean();
+		boolean blackCanvas = gd.getNextBoolean();
+		boolean noBorder = gd.getNextBoolean();
+		Prefs.useInvertingLut = gd.getNextBoolean();
+		boolean alwaysOnTop = Prefs.alwaysOnTop;
+		Prefs.autoContrast = gd.getNextBoolean();
+		Prefs.alwaysOnTop = gd.getNextBoolean();
+		if (IJ.isLinux())
+			Prefs.dialogCancelButtonOnRight = gd.getNextBoolean();
+		if (!IJ.isMacOSX())
+			menuFontSize = (int)gd.getNextNumber();
+		Prefs.setGuiScale(gd.getNextNumber());
+		if (interpolate!=Prefs.interpolateScaledImages) {
+			Prefs.interpolateScaledImages = interpolate;
+			draw();
+		}
+		if (blackCanvas!=Prefs.blackCanvas) {
+			Prefs.blackCanvas = blackCanvas;
+			repaintWindow();
+		}
+		if (noBorder!=Prefs.noBorder) {
+			Prefs.noBorder = noBorder;
+			repaintWindow();
+		}
+		if (alwaysOnTop!=Prefs.alwaysOnTop) {
+			ImageJ ij = IJ.getInstance();
+			if (ij!=null) ij.setAlwaysOnTop(Prefs.alwaysOnTop);
+		}
+		int rangeIndex2 = gd.getNextChoiceIndex();
+		int range1 = ImagePlus.getDefault16bitRange();
+		int range2 = ContrastAdjuster.set16bitRange(rangeIndex2);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Calibration cal = imp!=null?imp.getCalibration():null;
+		if (range1!=range2 && imp!=null && imp.getType()==ImagePlus.GRAY16 && !cal.isSigned16Bit()) {
+			imp.resetDisplayRange();
+			if (rangeIndex2==0 && imp.isComposite() && luts!=null)
+				((CompositeImage)imp).setLuts(luts);
+			imp.updateAndDraw();
+		}
+		return true;
+    }
+    
+    private LUT[] getLuts() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getBitDepth()!=16 || !imp.isComposite())
+			return null;
+		return ((CompositeImage)imp).getLuts();
+    }
+    
+    void draw() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			imp.draw();
+		redrawn = true;
+    }
+
+	void repaintWindow() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			ImageWindow win = imp.getWindow();
+			if (win!=null) {
+				if (Prefs.blackCanvas) {
+					win.setForeground(Color.white);
+					win.setBackground(Color.black);
+				} else {
+					win.setForeground(Color.black);
+					win.setBackground(Color.white);
+				}
+				imp.repaintWindow();
+			}
+		}
+		repainted = true;
+	}
+		
+}
\ No newline at end of file
diff --git a/src/ij/plugin/ArrowToolOptions.java b/src/ij/plugin/ArrowToolOptions.java
new file mode 100644
index 0000000..49a7d2a
--- /dev/null
+++ b/src/ij/plugin/ArrowToolOptions.java
@@ -0,0 +1,84 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import java.awt.*;
+
+/** This plugin implements the Edit/Options/Arrow Tool command. */
+public class ArrowToolOptions implements PlugIn, DialogListener {
+	private String colorName;
+	private static GenericDialog gd;
+	private static final String LOC_KEY = "arrows.loc";
+
+ 	public void run(String arg) {
+ 		if (gd!=null && gd.isVisible())
+ 			gd.toFront();
+ 		else
+			arrowToolOptions();
+	}
+				
+	void arrowToolOptions() {
+		if (!Toolbar.getToolName().equals("arrow"))
+			IJ.setTool("arrow");
+		double width = Arrow.getDefaultWidth();
+		double headSize = Arrow.getDefaultHeadSize();
+		Color color = Toolbar.getForegroundColor();
+		colorName = Colors.colorToString2(color);
+		int style = Arrow.getDefaultStyle();
+		gd = GUI.newNonBlockingDialog("Arrow Tool");
+		gd.addSlider("Width:", 1, 50, (int)width);
+		gd.addSlider("Size:", 0, 50, headSize);
+		gd.addChoice("Color:", Colors.getColors(colorName), colorName);
+		gd.addChoice("Style:", Arrow.styles, Arrow.styles[style]);
+		gd.addCheckbox("Outline", Arrow.getDefaultOutline());
+		gd.addCheckbox("Double head", Arrow.getDefaultDoubleHeaded());
+		gd.addCheckbox("Keep after adding to overlay", Prefs.keepArrowSelections);
+		gd.addDialogListener(this);
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null) {
+			gd.centerDialog(false);
+			gd.setLocation (loc);
+		}
+		gd.showDialog();
+		Prefs.saveLocation(LOC_KEY, gd.getLocation());
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		double width2 = gd.getNextNumber();
+		double headSize2 = gd.getNextNumber();
+		String colorName2 = gd.getNextChoice();
+		int style2 = gd.getNextChoiceIndex();
+		boolean outline2 = gd.getNextBoolean();
+		boolean doubleHeaded2 = gd.getNextBoolean();
+		Prefs.keepArrowSelections = gd.getNextBoolean();
+		if (colorName!=null && !colorName2.equals(colorName)) {
+			Color color = Colors.decode(colorName2, null);
+			Toolbar.setForegroundColor(color);
+		}
+		colorName = colorName2;
+		Arrow.setDefaultWidth(width2);
+		Arrow.setDefaultHeadSize(headSize2);
+		Arrow.setDefaultStyle(style2);
+		Arrow.setDefaultOutline(outline2);
+		Arrow.setDefaultDoubleHeaded(doubleHeaded2);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return true;
+		Roi roi = imp.getRoi();
+		if (roi==null) return true;
+		if (roi instanceof Arrow) {
+			Arrow arrow = (Arrow)roi;
+			roi.setStrokeWidth((float)width2);
+			arrow.setHeadSize(headSize2);
+			arrow.setStyle(style2);
+			arrow.setOutline(outline2);
+			arrow.setDoubleHeaded(doubleHeaded2);
+			imp.draw();
+		}
+		Prefs.set(Arrow.STYLE_KEY, style2);
+		Prefs.set(Arrow.WIDTH_KEY, width2);
+		Prefs.set(Arrow.SIZE_KEY, headSize2);
+		Prefs.set(Arrow.OUTLINE_KEY, outline2);
+		Prefs.set(Arrow.DOUBLE_HEADED_KEY, doubleHeaded2);
+		return true;
+	}
+	
+} 
diff --git a/src/ij/plugin/BMP_Reader.java b/src/ij/plugin/BMP_Reader.java
new file mode 100644
index 0000000..9fd3108
--- /dev/null
+++ b/src/ij/plugin/BMP_Reader.java
@@ -0,0 +1,328 @@
+package ij.plugin;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import ij.*;
+import ij.io.*;
+
+
+/** This plugin reads BMP files. If 'arg' is empty, it
+        displays a file open dialog and opens and displays the 
+        selected file. If 'arg' is a path, it opens the 
+        specified file and the calling routine can display it using
+        "((ImagePlus)IJ.runPlugIn("ij.plugin.BMP_Reader", path)).show()".
+        */
+public class BMP_Reader extends ImagePlus implements PlugIn {
+
+        public void run(String arg) {
+                OpenDialog od = new OpenDialog("Open BMP...", arg);
+                String directory = od.getDirectory();
+                String name = od.getFileName();
+                if (name==null)
+                        return;
+                String path = directory + name;
+
+                //IJ.showStatus("Opening: " + path);
+                BMPDecoder bmp = new BMPDecoder();
+                FileInputStream  is = null;
+                try {
+                        is = new FileInputStream(path);
+                        bmp.read(is);
+                } catch (Exception e) {
+                        String msg = e.getMessage();
+                        if (msg==null || msg.equals(""))
+                                msg = ""+e;
+                        IJ.error("BMP Reader", msg);
+                        return;
+                } finally {
+					if (is!=null) {
+						try {
+							is.close();
+						} catch (IOException e) {}
+					}
+				}
+
+                MemoryImageSource mis = bmp.makeImageSource();
+                if (mis==null) IJ.log("BMP_Reader: mis=null");
+                Image img = Toolkit.getDefaultToolkit().createImage(mis);
+                FileInfo fi = new FileInfo();
+                fi.fileFormat = FileInfo.BMP;
+                fi.fileName = name;
+                fi.directory = directory;
+                setImage(img);
+                setTitle(name);
+                setFileInfo(fi);
+                if (bmp.topDown)
+                    getProcessor().flipVertical();
+                if (arg.equals(""))
+                    show();
+        }
+        
+}
+
+
+/** A decoder for Windows bitmap (.BMP) files. */
+class BMPDecoder {
+        InputStream is;
+        int curPos = 0;
+                
+        int bitmapOffset;               // starting position of image data
+
+        int width;                              // image width in pixels
+        int height;                             // image height in pixels
+        short bitsPerPixel;             // 1, 4, 8, or 24 (no color map)
+        int compression;                // 0 (none), 1 (8-bit RLE), or 2 (4-bit RLE)
+        int actualSizeOfBitmap;
+        int scanLineSize;
+        int actualColorsUsed;
+
+        byte r[], g[], b[];             // color palette
+        int noOfEntries;
+
+        byte[] byteData;                // Unpacked data
+        int[] intData;                     // Unpacked data
+        boolean topDown;
+
+
+        private int readInt() throws IOException {
+                int b1 = is.read();
+                int b2 = is.read();
+                int b3 = is.read();
+                int b4 = is.read();
+                curPos += 4;
+                return ((b4 << 24) + (b3 << 16) + (b2 << 8) + (b1 << 0));
+        }
+
+
+        private short readShort() throws IOException {
+                int b1 = is.read();
+                int b2 = is.read();
+                curPos += 2;
+                return (short)((b2 << 8) + b1);
+        }
+
+
+        void getFileHeader()  throws IOException, Exception {
+                // Actual contents (14 bytes):
+                short fileType = 0x4d42;// always "BM"
+                int fileSize;                   // size of file in bytes
+                short reserved1 = 0;    // always 0
+                short reserved2 = 0;    // always 0
+
+                fileType = readShort();
+                if (fileType != 0x4d42)
+                        throw new Exception("Not a BMP file");  // wrong file type
+                fileSize = readInt();
+                reserved1 = readShort();
+                reserved2 = readShort();
+                bitmapOffset = readInt();
+        }
+
+        void getBitmapHeader() throws IOException {
+        
+                // Actual contents (40 bytes):
+                int size;                               // size of this header in bytes
+                short planes;                   // no. of color planes: always 1
+                int sizeOfBitmap;               // size of bitmap in bytes (may be 0: if so, calculate)
+                int horzResolution;             // horizontal resolution, pixels/meter (may be 0)
+                int vertResolution;             // vertical resolution, pixels/meter (may be 0)
+                int colorsUsed;                 // no. of colors in palette (if 0, calculate)
+                int colorsImportant;    // no. of important colors (appear first in palette) (0 means all are important)
+                int noOfPixels;
+
+                size = readInt();
+                width = readInt();
+                height = readInt();
+                planes = readShort();
+                bitsPerPixel = readShort();
+                compression = readInt();
+                sizeOfBitmap = readInt();
+                horzResolution = readInt();
+                vertResolution = readInt();
+                colorsUsed = readInt();
+                colorsImportant = readInt();
+                if (bitsPerPixel==24)
+                    colorsUsed = colorsImportant = 0;
+
+                topDown = (height < 0);
+                if (topDown) height = -height;
+                noOfPixels = width * height;
+
+                // Scan line is padded with zeroes to be a multiple of four bytes
+                scanLineSize = ((width * bitsPerPixel + 31) / 32) * 4;
+
+                actualSizeOfBitmap = scanLineSize * height;
+
+                if (colorsUsed != 0)
+                        actualColorsUsed = colorsUsed;
+                else
+                        // a value of 0 means we determine this based on the bits per pixel
+                        if (bitsPerPixel < 16)
+                                actualColorsUsed = 1 << bitsPerPixel;
+                        else
+                                actualColorsUsed = 0;   // no palette
+                /*
+                if (IJ.debugMode) {
+                    IJ.log("BMP_Reader");
+                    IJ.log("  width: "+width);
+                    IJ.log("  height: "+height);
+                    IJ.log("  compression: "+compression);
+                    IJ.log("  scanLineSize: "+scanLineSize);
+                    IJ.log("  planes: "+planes);
+                    IJ.log("  bitsPerPixel: "+bitsPerPixel);
+                    IJ.log("  sizeOfBitmap: "+sizeOfBitmap);
+                    IJ.log("  horzResolution: "+horzResolution);
+                    IJ.log("  vertResolution: "+vertResolution);
+                    IJ.log("  colorsUsed: "+colorsUsed);
+                    IJ.log("  colorsImportant: "+colorsImportant);
+                }
+                */
+        }
+
+        void getPalette() throws IOException {
+                noOfEntries = actualColorsUsed;
+                if (noOfEntries>0) {
+                        r = new byte[noOfEntries];
+                        g = new byte[noOfEntries];
+                        b = new byte[noOfEntries];
+
+                        int reserved;
+                        for (int i = 0; i < noOfEntries; i++) {
+                                b[i] = (byte)is.read();
+                                g[i] = (byte)is.read();
+                                r[i] = (byte)is.read();
+                                reserved = is.read();
+                                curPos += 4;
+                        }
+                }
+        }
+
+        void unpack(byte[] rawData, int rawOffset, int bpp, byte[] byteData, int byteOffset, int w) throws Exception {
+                int j = byteOffset;
+                int k = rawOffset;
+                byte mask;
+                int pixPerByte;
+
+                switch (bpp) {
+                case 1: mask = (byte)0x01; pixPerByte = 8; break;
+                case 4: mask = (byte)0x0f; pixPerByte = 2; break;
+                case 8: mask = (byte)0xff; pixPerByte = 1; break;
+                default:
+                        throw new Exception("Unsupported bits-per-pixel value: " + bpp);
+                }
+
+                for (int i = 0;;) {
+                        int shift = 8 - bpp;
+                        for (int ii = 0; ii < pixPerByte; ii++) {
+                                byte br = rawData[k];
+                                br >>= shift;
+                                byteData[j] = (byte)(br & mask);
+                                //System.out.println("Setting byteData[" + j + "]=" + Test.byteToHex(byteData[j]));
+                                j++;
+                                i++;
+                                if (i == w) return;
+                                shift -= bpp;
+                        }
+                        k++;
+                }
+        }
+
+        void unpack24(byte[] rawData, int rawOffset, int[] intData, int intOffset, int w) {
+                int j = intOffset;
+                int k = rawOffset;
+                int mask = 0xff;
+                for (int i = 0; i < w; i++) {
+                        int b0 = (((int)(rawData[k++])) & mask);
+                        int b1 = (((int)(rawData[k++])) & mask) << 8;
+                        int b2 = (((int)(rawData[k++])) & mask) << 16;
+                        intData[j] = 0xff000000 | b0 | b1 | b2;
+                        j++;
+                }
+        }
+
+        void unpack32(byte[] rawData, int rawOffset, int[] intData, int intOffset, int w) {
+                int j = intOffset;
+                int k = rawOffset;
+                int mask = 0xff;
+                for (int i = 0; i < w; i++) {
+                        int b0 = (((int)(rawData[k++])) & mask);
+                        int b1 = (((int)(rawData[k++])) & mask) << 8;
+                        int b2 = (((int)(rawData[k++])) & mask) << 16;
+                        int b3 = (((int)(rawData[k++])) & mask) << 24; // this gets ignored!
+                        intData[j] = 0xff000000 | b0 | b1 | b2;
+                        j++;
+                }
+        }
+
+        void getPixelData() throws IOException, Exception {
+                byte[] rawData;                 // the raw unpacked data
+
+                // Skip to the start of the bitmap data (if we are not already there)
+                long skip = bitmapOffset - curPos;
+                if (skip > 0) {
+                        is.skip(skip);
+                        curPos += skip;
+                }
+
+                int len = scanLineSize;
+                if (bitsPerPixel > 8)
+                        intData = new int[width * height];
+                else
+                        byteData = new byte[width * height];
+                rawData = new byte[actualSizeOfBitmap];
+                int rawOffset = 0;
+                int offset = (height - 1) * width;
+                for (int i = height - 1; i >= 0; i--) {
+                        int n = is.read(rawData, rawOffset, len);
+                        if (n < len) throw new Exception("Scan line ended prematurely after " + n + " bytes");
+                        if (bitsPerPixel==24)
+                                unpack24(rawData, rawOffset, intData, offset, width);
+                        else if (bitsPerPixel==32)
+                                unpack32( rawData, rawOffset, intData, offset, width);
+                        else // 8-bits or less
+                                unpack(rawData, rawOffset, bitsPerPixel, byteData, offset, width);
+                        rawOffset += len;
+                        offset -= width;
+                }
+        }
+
+
+        public void read(InputStream is) throws IOException, Exception {
+                this.is = is;
+                getFileHeader();
+                getBitmapHeader();
+                if (compression!=0)
+                        throw new Exception("Compression not supported");
+                getPalette();
+                getPixelData();
+        }
+
+
+        public MemoryImageSource makeImageSource() {
+                ColorModel cm;
+                MemoryImageSource mis;
+
+                if (noOfEntries>0 && bitsPerPixel!=24) {
+                        // There is a color palette; create an IndexColorModel
+                        cm = new IndexColorModel(bitsPerPixel, noOfEntries, r, g, b);
+                } else {
+                        // There is no palette; use the default RGB color model
+                        cm = ColorModel.getRGBdefault();
+                }
+
+                // Create MemoryImageSource
+
+                if (bitsPerPixel > 8) {
+                        // use one int per pixel
+                        mis = new MemoryImageSource(width,
+                                height, cm, intData, 0, width);
+                } else {
+                        // use one byte per pixel
+                        mis = new MemoryImageSource(width,
+                                height, cm, byteData, 0, width);
+                }
+
+                return mis;      // this can be used by Component.createImage()
+        }
+}
diff --git a/src/ij/plugin/BMP_Writer.java b/src/ij/plugin/BMP_Writer.java
new file mode 100644
index 0000000..a1e8006
--- /dev/null
+++ b/src/ij/plugin/BMP_Writer.java
@@ -0,0 +1,247 @@
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import java.awt.*;
+import java.io.*;
+import java.awt.image.*;
+
+/** Implements the File/Save As/BMP command. Based on BMPFile class from
+   http://www.javaworld.com/javaworld/javatips/jw-javatip60-p2.html */
+
+public class BMP_Writer implements PlugIn {
+ //--- Private constants
+ private final static int BITMAPFILEHEADER_SIZE = 14;
+ private final static int BITMAPINFOHEADER_SIZE = 40;
+ //--- Private variable declaration
+ //--- Bitmap file header
+ private byte bitmapFileHeader [] = new byte [14];
+ private byte bfType [] =  {(byte)'B', (byte)'M'};
+ private int bfSize = 0;
+ private int bfReserved1 = 0;
+ private int bfReserved2 = 0;
+ private int bfOffBits = BITMAPFILEHEADER_SIZE + BITMAPINFOHEADER_SIZE;
+ //--- Bitmap info header
+ private byte bitmapInfoHeader [] = new byte [40];
+ private int biSize = BITMAPINFOHEADER_SIZE;
+ private int biWidth = 0;
+ private int padWidth = 0;
+ private int biHeight = 0;
+ private int biPlanes = 1;
+ private int biBitCount = 24;
+ private int biCompression = 0;
+ private int biSizeImage = 0;
+ private int biXPelsPerMeter = 0x0;
+ private int biYPelsPerMeter = 0x0;
+ private int biClrUsed = 0;
+ private int biClrImportant = 0;
+ //--- Bitmap raw data
+ private int intBitmap [];
+ private byte byteBitmap [];
+ //--- File section
+ private FileOutputStream fo;
+ private BufferedOutputStream bfo;
+ ImagePlus imp;
+
+ public void run(String path) {
+   IJ.showProgress(0);
+   imp = WindowManager.getCurrentImage();
+   if (imp==null)
+     {IJ.noImage(); return;}
+   try {
+     writeImage(imp, path);
+   } catch (Exception e) {
+     String msg = e.getMessage();
+     if (msg==null || msg.equals(""))
+   msg = ""+e;
+     IJ.error("BMP Writer", "An error occured writing the file.\n \n" + msg);
+   }
+   IJ.showProgress(1);
+   IJ.showStatus("");
+ }
+
+ void writeImage(ImagePlus imp, String path) throws Exception {
+   if(imp.getBitDepth()==24)
+     biBitCount = 24;
+   else {
+     biBitCount = 8;
+     LookUpTable lut = imp.createLut();
+     biClrUsed=lut.getMapSize(); // 8 bit color image may use less
+     bfOffBits+=biClrUsed*4;
+   }
+   if (path==null || path.equals("")) {
+     String prompt = "Save as " + biBitCount + " bit BMP";
+     SaveDialog sd = new SaveDialog(prompt, imp.getTitle(), ".bmp");
+     if(sd.getFileName()==null)
+   return;
+     path = sd.getDirectory()+sd.getFileName();
+   }
+   imp.startTiming();
+   saveBitmap (path, imp.getImage(), imp.getWidth(), imp.getHeight() );
+ }
+
+
+ public void saveBitmap (String parFilename, Image parImage, int parWidth, int parHeight) throws Exception {
+   fo = new FileOutputStream (parFilename);
+   bfo = new BufferedOutputStream(fo);
+   save (parImage, parWidth, parHeight);
+   bfo.close();
+   fo.close ();
+ }
+
+ /*
+  *   The saveMethod is the main method of the process. This method
+  *   will call the convertImage method to convert the memory image to
+  *   a byte array; method writeBitmapFileHeader creates and writes
+  *   the bitmap file header; writeBitmapInfoHeader creates the
+  *   information header; and writeBitmap writes the image.
+  *
+  */
+ private void save (Image parImage, int parWidth, int parHeight) throws Exception {
+   convertImage (parImage, parWidth, parHeight);
+   writeBitmapFileHeader ();
+   writeBitmapInfoHeader ();
+   if(biBitCount == 8)
+     writeBitmapPalette ();
+   writeBitmap ();
+ }
+
+ private void writeBitmapPalette() throws Exception {
+   LookUpTable lut = imp.createLut();
+   byte[] g = lut.getGreens();
+   byte[] r = lut.getReds();
+   byte[] b = lut.getBlues();
+   for(int i = 0;i<lut.getMapSize();i++) {
+     bfo.write(b[i]);
+     bfo.write(g[i]);
+     bfo.write(r[i]);
+     bfo.write(0x00);
+   }
+ }
+
+ /*
+  * convertImage converts the memory image to the bitmap format (BRG).
+  * It also computes some information for the bitmap info header.
+  *
+  */
+ private boolean convertImage (Image parImage, int parWidth, int parHeight) {
+   int pad;
+   if(biBitCount == 24)
+     intBitmap = (int[]) imp.getProcessor().getPixels();
+   else
+     byteBitmap = (byte[]) imp.getProcessor().convertToByte(true).getPixels();
+   biWidth = parWidth;
+   biHeight = parHeight;
+   if(biBitCount==24)
+     pad = 4 - ((biWidth * 3) % 4);
+   else
+     pad = 4 - ((biWidth) % 4);
+   if (pad == 4)       // <==== Bug correction
+     pad = 0;            // <==== Bug correction
+   padWidth = biWidth*(biBitCount==24?3:1)+pad;
+   return (true);
+ }
+
+ /*
+  * writeBitmap converts the image returned from the pixel grabber to
+  * the format required. Remember: scan lines are inverted in
+  * a bitmap file!
+  *
+  * Each scan line must be padded to an even 4-byte boundary.
+  */
+ private void writeBitmap () throws Exception {
+   int value;
+   int i;
+   int pad;
+   byte rgb [] = new byte [3];
+   if(biBitCount==24)
+     pad = 4 - ((biWidth * 3) % 4);
+   else
+     pad = 4 - ((biWidth) % 4);
+   if (pad == 4)       // <==== Bug correction
+     pad = 0;            // <==== Bug correction
+
+   int counter=0;
+   for(int row = biHeight; row>0; row--) {
+     if (row%20==0)
+   IJ.showProgress((double)(biHeight-row)/biHeight);
+     for(int col = 0; col<biWidth; col++) {
+   if(biBitCount==24) {
+     value = intBitmap [(row-1)*biWidth + col ];
+     rgb [0] = (byte) (value & 0xFF);
+     rgb [1] = (byte) ((value >> 8) & 0xFF);
+     rgb [2] = (byte) ((value >> 16) & 0xFF);
+     bfo.write(rgb);
+   } else
+     bfo.write(byteBitmap [(row-1)*biWidth + col ]);
+   ++counter;
+     }
+     for (i = 1; i <= pad; i++)
+   bfo.write (0x00);
+     counter += pad;
+   }
+ }
+
+
+ /*
+  * writeBitmapFileHeader writes the bitmap file header to the file.
+  *
+  */
+ private void writeBitmapFileHeader() throws Exception {
+   fo.write (bfType);
+   // calculate bfSize
+   bfSize = bfOffBits+padWidth*biHeight;
+   fo.write (intToDWord (bfSize));
+   fo.write (intToWord (bfReserved1));
+   fo.write (intToWord (bfReserved2));
+   fo.write (intToDWord (bfOffBits));
+ }
+
+ /*
+  *
+  * writeBitmapInfoHeader writes the bitmap information header
+  * to the file.
+  *
+  */
+ private void writeBitmapInfoHeader () throws Exception {
+   fo.write (intToDWord (biSize));
+   fo.write (intToDWord (biWidth));
+   fo.write (intToDWord (biHeight));
+   fo.write (intToWord (biPlanes));
+   fo.write (intToWord (biBitCount));
+   fo.write (intToDWord (biCompression));
+   fo.write (intToDWord (biSizeImage));
+   fo.write (intToDWord (biXPelsPerMeter));
+   fo.write (intToDWord (biYPelsPerMeter));
+   fo.write (intToDWord (biClrUsed));
+   fo.write (intToDWord (biClrImportant));
+ }
+
+ /*
+  *
+  * intToWord converts an int to a word, where the return
+  * value is stored in a 2-byte array.
+  *
+  */
+ private byte [] intToWord (int parValue) {
+   byte retValue [] = new byte [2];
+   retValue [0] = (byte) (parValue & 0x00FF);
+   retValue [1] = (byte) ((parValue >> 8) & 0x00FF);
+   return (retValue);
+ }
+
+ /*
+  *
+  * intToDWord converts an int to a double word, where the return
+  * value is stored in a 4-byte array.
+  *
+  */
+ private byte [] intToDWord (int parValue) {
+   byte retValue [] = new byte [4];
+   retValue [0] = (byte) (parValue & 0x00FF);
+   retValue [1] = (byte) ((parValue >> 8) & 0x000000FF);
+   retValue [2] = (byte) ((parValue >> 16) & 0x000000FF);
+   retValue [3] = (byte) ((parValue >> 24) & 0x000000FF);
+   return (retValue);
+ }
+}
diff --git a/src/ij/plugin/BatchConverter.java b/src/ij/plugin/BatchConverter.java
new file mode 100644
index 0000000..03ec94b
--- /dev/null
+++ b/src/ij/plugin/BatchConverter.java
@@ -0,0 +1,154 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.io.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+
+/** This plugin implements the File/ /Convert command, 
+	which converts the images in a folder to a specified format. */
+	public class BatchConverter implements PlugIn, ActionListener {
+		private static final String[] formats = {"TIFF", "8-bit TIFF", "JPEG", "GIF", "PNG", "PGM", "BMP", "FITS", "Text Image", "ZIP", "Raw"};
+		private static String format = formats[0];
+		private static double scale = 1.0;
+		private static boolean useBioFormats;
+		private static int interpolationMethod = ImageProcessor.BILINEAR;
+		private static boolean averageWhenDownSizing;
+		private String[] methods = ImageProcessor.getInterpolationMethods();
+		private Button input, output;
+		private TextField inputDir, outputDir;
+		private GenericDialog gd;
+
+	public void run(String arg) {
+		if (!showDialog())
+			return;
+		String inputPath = inputDir.getText();
+		if (inputPath.equals("")) {
+			IJ.error("Batch Converter", "Please choose an input folder");
+			return;
+		}
+		String outputPath = outputDir.getText();
+		if (outputPath.equals("")) {
+			IJ.error("Batch Converter", "Please choose an output folder");
+			return;
+		}
+		File f1 = new File(inputPath);
+		if (!f1.exists() || !f1.isDirectory()) {
+			IJ.error("Batch Converter", "Input does not exist or is not a folder\n \n"+inputPath);
+			return;
+		}
+		File f2 = new File(outputPath);
+		if (!outputPath.equals("") && (!f2.exists() || !f2.isDirectory())) {
+			IJ.error("Batch Converter", "Output does not exist or is not a folder\n \n"+outputPath);
+			return;
+		}
+		String[] list = (new File(inputPath)).list();
+		IJ.resetEscape();
+		Opener opener = new Opener();
+		opener.setSilentMode(true);
+		long t0 = System.currentTimeMillis();
+		for (int i=0; i<list.length; i++) {
+			if (IJ.escapePressed())
+				break;
+			if (IJ.debugMode) IJ.log(i+"  "+list[i]);
+			String path = inputPath + list[i];
+			if ((new File(path)).isDirectory())
+				continue;
+			if (list[i].startsWith(".")||list[i].endsWith(".avi")||list[i].endsWith(".AVI"))
+				continue;
+			IJ.showStatus(i+"/"+list.length);
+			IJ.showProgress(i+1, list.length);
+			ImagePlus imp = null;
+			IJ.redirectErrorMessages(true);
+			if (useBioFormats)
+				imp = Opener.openUsingBioFormats(path);
+			else
+				imp = opener.openImage(inputPath,list[i]);
+			IJ.redirectErrorMessages(false);
+			if (imp==null) {
+				String reader = useBioFormats?"Bio-Formats not found or":"IJ.openImage()";
+				IJ.log(reader+" returned null: "+path);
+				continue;
+			}
+			if (scale!=1.0) {
+				int width = (int)(scale*imp.getWidth());
+				int height = (int)(scale*imp.getHeight());
+				ImageProcessor ip = imp.getProcessor();
+				ip.setInterpolationMethod(interpolationMethod);
+				ip.setProgressBar(null);
+				imp.setProcessor(null, ip.resize(width,height,averageWhenDownSizing));
+				ip = null;
+			}
+			if (format.equals("8-bit TIFF") || format.equals("GIF")) {
+				if (imp.getBitDepth()==24)
+					IJ.run(imp, "8-bit Color", "number=256");
+				else
+					IJ.run(imp, "8-bit", "");
+			}
+			IJ.saveAs(imp, format, outputPath+list[i]);
+			imp.close();
+			imp = null;
+		}
+		IJ.showStatus(list.length+" files converted in "+IJ.d2s((System.currentTimeMillis()-t0)/1000.0,2)+" seconds");
+		IJ.showProgress(1,1);
+		Prefs.set("batch.input", inputDir.getText());
+		Prefs.set("batch.output", outputDir.getText());
+	}
+			
+	private boolean showDialog() {
+		gd = new GenericDialog("Batch Convert");
+		addPanels(gd);
+		gd.setInsets(15, 0, 5);
+		gd.addChoice("Output_format:", formats, format);
+		gd.addChoice("Interpolation:", methods, methods[interpolationMethod]);
+		//gd.addStringField("Height (pixels): ", height==0?"\u2014":""+height, 6);
+		gd.addNumericField("Scale factor:", scale, 2);
+		gd.addCheckbox("Average when downsizing", averageWhenDownSizing);
+		gd.addCheckbox("Read images using Bio-Formats", useBioFormats);
+		gd.setOKLabel("Convert");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		format = gd.getNextChoice();
+		interpolationMethod = gd.getNextChoiceIndex();
+		//height = (int)Tools.parseDouble(gd.getNextString(), 0.0);
+		scale = gd.getNextNumber();
+		averageWhenDownSizing = gd.getNextBoolean();
+		useBioFormats = gd.getNextBoolean();
+		return true;
+	}
+
+	void addPanels(GenericDialog gd) {
+		Panel p = new Panel();
+    	p.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		input = new Button("Input...");
+		input.addActionListener(this);
+		p.add(input);
+		inputDir = new TextField(Prefs.get("batch.input", ""), 45);
+		p.add(inputDir);
+		gd.addPanel(p);
+		p = new Panel();
+    	p.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		output = new Button("Output...");
+		output.addActionListener(this);
+		p.add(output);
+		outputDir = new TextField(Prefs.get("batch.output", ""), 45);
+		p.add(outputDir);
+		gd.addPanel(p);
+	}
+	
+	public void actionPerformed(ActionEvent e) {
+		Object source = e.getSource();
+		String s = source==input?"Input":"Output";
+		String path = IJ.getDirectory(s+" Folder");
+		if (path==null) return;
+		if (source==input)
+			inputDir.setText(path);
+		else
+			outputDir.setText(path);
+	}
+
+}
diff --git a/src/ij/plugin/BatchMeasure.java b/src/ij/plugin/BatchMeasure.java
new file mode 100644
index 0000000..c4cb1ec
--- /dev/null
+++ b/src/ij/plugin/BatchMeasure.java
@@ -0,0 +1,32 @@
+package ij.plugin;
+import ij.*;
+import ij.measure.Measurements;
+import ij.plugin.filter.Analyzer;
+import java.io.*;
+
+/** This plugin implements the File/Batch/Measure command, 
+	which measures all the images in a user-specified folder. */
+	public class BatchMeasure implements PlugIn {
+
+	public void run(String arg) {
+		String dir = IJ.getDirectory("Choose a Folder");
+		if (dir==null) return;
+		String[] list = (new File(dir)).list();
+		if (list==null) return;
+		Analyzer.setMeasurement(Measurements.LABELS, true);
+		for (int i=0; i<list.length; i++) {
+			if (list[i].startsWith(".")) continue;
+			String path = dir + list[i];
+			IJ.showProgress(i+1, list.length);
+			IJ.redirectErrorMessages(true);
+			ImagePlus imp = !path.endsWith("/")?IJ.openImage(path):null;
+			IJ.redirectErrorMessages(false);
+			if (imp!=null) {
+				IJ.run(imp, "Measure", "");
+				imp.close();
+			} else if (!path.endsWith("/"))
+				IJ.log("IJ.openImage() returned null: "+path);
+		}
+	}
+
+}
diff --git a/src/ij/plugin/BatchProcessor.java b/src/ij/plugin/BatchProcessor.java
new file mode 100644
index 0000000..80e15cb
--- /dev/null
+++ b/src/ij/plugin/BatchProcessor.java
@@ -0,0 +1,480 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.io.*;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.util.Vector;
+
+/** This plugin implements the File/Batch/Macro and File/Batch/Virtual Stack commands. */
+	public class BatchProcessor implements PlugIn, ActionListener, ItemListener, Runnable {
+		private static final String MACRO_FILE_NAME = "BatchMacro.ijm";
+		private static final String[] formats = {"TIFF", "8-bit TIFF", "JPEG", "GIF", "PNG", "PGM", "BMP", "FITS", "Text Image", "ZIP", "Raw"};
+		private static String format = Prefs.get("batch.format", formats[0]);
+		
+		private static final String[] code = {
+			"[Select from list]",
+			"Add Border",
+			"Convert to RGB",
+			"Crop",
+			"Gaussian Blur",
+			"Invert",
+			"Label",
+			"Timestamp",
+			"Max Dimension",
+			"Measure",
+			"Print Index and Title",
+			"Resize",
+			"Scale",
+			"Show File Info",
+			"Unsharp Mask",
+		};
+		
+		private static final String help = "<html>"
+		+"<h1>Process&gt;Batch&gt;Virtual Stack</h1>"
+		+"<font size=+1>"
+		+"This command runs macro code on each image in a virtual stack.<br>"
+		+"The processed images are saved in the <i>Output</i> folder,<br>"
+		+"in the specified <i>Format</i>, allowing them to be opened as a<br>"
+		+"virtual stack. Make sure the <i>Output</i> folder is empty<br>"
+		+"before clicking on <i>Process</i>.<br>"
+		+"<br>"
+		+"In the macro code, the 'i' (slice index) and 'n' (stack size) variables<br>"
+		+"are predefined. Call <i>setOption('SaveBatchOutput',false)</i> to<br>"
+		+"prevent the image currently being processed from being saved,<br>"
+		+"effectively removing it from the output virtual stack.<br> <br>"
+		+"</font>";
+
+		private String macro = "";
+		private int testImage;
+		private Button input, output, open, save, test;
+		private TextField inputDir, outputDir;
+		private GenericDialog gd;
+		private Thread thread;
+		private ImagePlus virtualStack;
+		private ImagePlus outputImage;
+		private boolean errorDisplayed;
+		private String filter;
+		private static boolean saveOutput = true;
+
+	public void run(String arg) {
+		if (arg.equals("stack")) {
+			virtualStack = IJ.getImage();
+			if (virtualStack.getStackSize()==1) {
+				error("This command requires a stack or virtual stack.");
+				return;
+			}
+		}
+		String macroPath = IJ.getDirectory("macros")+MACRO_FILE_NAME;
+		macro = IJ.openAsString(macroPath);
+		if (macro==null || macro.startsWith("Error: ")) {
+			IJ.showStatus(macro.substring(7) + ": "+macroPath);
+			macro = "";
+		}
+		if (!showDialog()) return;
+		String inputPath = null;
+		if (virtualStack==null) {
+			inputPath = inputDir.getText();
+			if (inputPath.equals("")) {
+				error("Please choose an input folder");
+				return;
+			}
+			inputPath = addSeparator(inputPath);
+			File f1 = new File(inputPath);
+			if (!f1.exists() || !f1.isDirectory()) {
+				error("Input does not exist or is not a folder\n \n"+inputPath);
+				return;
+			}
+		}
+		String outputPath = outputDir.getText();
+		outputPath = addSeparator(outputPath);
+		File f2 = new File(outputPath);
+		if (!outputPath.equals("") && (!f2.exists() || !f2.isDirectory())) {
+			error("Output does not exist or is not a folder\n \n"+outputPath);
+			return;
+		}
+		if (macro.equals("")) {
+			error("There is no macro code in the text area");
+			return;
+		}
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null) ij.getProgressBar().setBatchMode(true);
+		IJ.resetEscape();
+		if (virtualStack!=null)
+			processVirtualStack(outputPath);
+		else
+			processFolder(inputPath, outputPath);
+		IJ.showProgress(1,1);
+		if (virtualStack==null)
+			Prefs.set("batch.input", inputDir.getText());
+		Prefs.set("batch.output", outputDir.getText());
+		Prefs.set("batch.format", format);
+		macro = gd.getTextArea1().getText();
+		if (!macro.equals(""))
+			IJ.saveString(macro, IJ.getDirectory("macros")+MACRO_FILE_NAME);
+	}
+		
+	boolean showDialog() {
+		validateFormat();
+		gd = GUI.newNonBlockingDialog("Batch Process");
+		addPanels(gd);
+		gd.setInsets(15, 0, 5);
+		gd.addChoice("Output_format:", formats, format);
+		gd.setInsets(0, 0, 5);
+		gd.addChoice("Add macro code:", code, code[0]);
+		if (virtualStack==null)
+			gd.addStringField("File name contains:", "", 10);
+		gd.setInsets(15, 10, 0);
+		Dimension screen = IJ.getScreenSize();
+		gd.addTextAreas(macro, null, screen.width<=600?10:15, 60);
+		addButtons(gd);
+		gd.setOKLabel("Process");
+		Vector choices = gd.getChoices();
+		Choice choice = (Choice)choices.elementAt(1);
+		if (virtualStack!=null)
+			gd.addHelp(help);
+		choice.addItemListener(this);
+		gd.showDialog();
+		format = gd.getNextChoice();
+		if (virtualStack==null)
+			filter = gd.getNextString();
+		macro = gd.getNextText();
+		return !gd.wasCanceled();
+	}
+	
+	void processVirtualStack(String outputPath) {
+		ImageStack stack = virtualStack.getStack();
+		int n = stack.size();
+		int index = 0;
+		for (int i=1; i<=n; i++) {
+			if (IJ.escapePressed()) break;
+			IJ.showProgress(i, n);
+			ImageProcessor ip = stack.getProcessor(i);
+			if (ip==null) return;
+			ImagePlus imp = new ImagePlus(i+"/"+stack.size(), ip);
+			if (!macro.equals("")) {
+				if (!runMacro("i="+(index++)+";"+"n="+stack.size()+";"+macro, imp))
+					break;
+			}
+			if (saveOutput && !outputPath.equals("")) {
+				if (format.equals("8-bit TIFF") || format.equals("GIF")) {
+					if (imp.getBitDepth()==24)
+						IJ.run(imp, "8-bit Color", "number=256");
+					else
+						IJ.run(imp, "8-bit", "");
+				}
+				IJ.saveAs(imp, format, outputPath+pad(i));
+			}
+			saveOutput = true;
+			imp.close();
+		}
+		if (outputPath!=null && !outputPath.equals(""))
+			IJ.run("Image Sequence...", "open=[" + outputPath + "]"+" use");
+	}
+	
+	String pad(int n) {
+		String str = ""+n;
+		while (str.length()<5)
+		str = "0" + str;
+		return str;
+	}
+
+	
+	void processFolder(String inputPath, String outputPath) {
+		String[] list = (new File(inputPath)).list();
+		list = FolderOpener.getFilteredList(list, filter, "Batch Processor");
+		if (list==null)
+			return;
+		int index = 0;
+		int startingCount = WindowManager.getImageCount();
+		for (int i=0; i<list.length; i++) {
+			if (IJ.escapePressed()) break;
+			String path = inputPath + list[i];
+			if (IJ.debugMode) IJ.log(i+": "+path);
+			if ((new File(path)).isDirectory())
+				continue;
+			if (list[i].startsWith(".")||list[i].endsWith(".avi")||list[i].endsWith(".AVI") || list[i].equals("Thumbs.db"))
+				continue;
+			IJ.showProgress(i+1, list.length);
+			IJ.redirectErrorMessages(true);
+			ImagePlus imp = IJ.openImage(path);
+			IJ.redirectErrorMessages(false);
+			if (imp==null && WindowManager.getImageCount()>startingCount)
+				imp = WindowManager.getCurrentImage();
+			if (imp==null)
+				imp = Opener.openUsingBioFormats(path);
+			if (imp==null) {
+				IJ.log("openImage() and openUsingBioFormats() returned null: "+path);
+				continue;
+			}
+			if (!macro.equals("")) {
+				outputImage = null;
+				if (!runMacro("i="+(index++)+";"+macro, imp))
+					break;
+			}
+			if (saveOutput && !outputPath.equals("")) {
+				if (format.equals("8-bit TIFF") || format.equals("GIF")) {
+					if (imp.getBitDepth()==24)
+						IJ.run(imp, "8-bit Color", "number=256");
+					else
+						IJ.run(imp, "8-bit", "");
+				}
+				if (outputImage!=null && outputImage!=imp)
+					IJ.saveAs(outputImage, format, outputPath+list[i]);
+				else
+					IJ.saveAs(imp, format, outputPath+list[i]);
+			}
+			saveOutput = true;
+			imp.close();
+		}
+	}
+	
+	private boolean runMacro(String macro, ImagePlus imp) {
+		WindowManager.setTempCurrentImage(imp);
+		Interpreter interp = new Interpreter();
+		try {
+			outputImage = interp.runBatchMacro(macro, imp);
+		} catch(Throwable e) {
+			interp.abortMacro();
+			String msg = e.getMessage();
+			if (!(e instanceof RuntimeException && msg!=null && e.getMessage().equals(Macro.MACRO_CANCELED)))
+				IJ.handleException(e);
+			return false;
+		} finally {
+			WindowManager.setTempCurrentImage(null);
+		}
+		return true;
+	}
+		
+	String addSeparator(String path) {
+		if (path.equals("")) return path;
+		if (!(path.endsWith("/")||path.endsWith("\\")))
+			path = path + File.separator;
+		return path;
+	}
+	
+	void validateFormat() {
+		boolean validFormat = false;
+		for (int i=0; i<formats.length; i++) {
+			if (format.equals(formats[i])) {
+				validFormat = true;
+				break;
+			}
+		}
+		if (!validFormat) format = formats[0];
+	}
+
+	void addPanels(GenericDialog gd) {
+		Panel p = new Panel();
+    	p.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		if (virtualStack==null) {
+			input = new Button("Input...");
+			input.addActionListener(this);
+			p.add(input);
+			inputDir = new TextField(Prefs.get("batch.input", ""), 45);
+			p.add(inputDir);
+			gd.addPanel(p);
+		}
+		p = new Panel();
+    	p.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		output = new Button("Output...");
+		output.addActionListener(this);
+		p.add(output);
+		outputDir = new TextField(Prefs.get("batch.output", ""), 45);
+		p.add(outputDir);
+		gd.addPanel(p);
+	}
+	
+	void addButtons(GenericDialog gd) {
+		Panel p = new Panel();
+    	p.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		test = new Button("Test");
+		test.addActionListener(this);
+		p.add(test);
+		open = new Button("Open...");
+		open.addActionListener(this);
+		p.add(open);
+		save = new Button("Save...");
+		save.addActionListener(this);
+		p.add(save);
+		gd.addPanel(p);
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		Choice choice = (Choice)e.getSource();
+		String item = choice.getSelectedItem();
+		String code = null;
+		if (item.equals("Convert to RGB"))
+			code = "run(\"RGB Color\");\n";
+		else if (item.equals("Measure"))
+			code = "run(\"Measure\");\n";
+		else if (item.equals("Resize"))
+			code = "run(\"Size...\", \"width=512 height=512 interpolation=Bicubic\");\n";
+		else if (item.equals("Scale"))
+			code = "scale=1.5;\nw=getWidth*scale; h=getHeight*scale;\nrun(\"Size...\", \"width=w height=h interpolation=Bilinear\");\n";
+		else if (item.equals("Label"))
+			code = "setFont(\"SansSerif\", 18, \"antialiased\");\nsetColor(\"red\");\ndrawString(\"Hello\", 20, 30);\n";
+		else if (item.equals("Timestamp"))
+			code = openMacroFromJar("TimeStamp.ijm");
+		else if (item.equals("Crop"))
+			code = "makeRectangle(getWidth/4, getHeight/4, getWidth/2, getHeight/2);\nrun(\"Crop\");\n";
+		else if (item.equals("Add Border"))
+			code = "border=25;\nw=getWidth+border*2; h=getHeight+border*2;\nrun(\"Canvas Size...\", \"width=w height=h position=Center zero\");\n";
+		else if (item.equals("Invert"))
+			code = "run(\"Invert\");\n";
+		else if (item.equals("Gaussian Blur"))
+			code = "run(\"Gaussian Blur...\", \"sigma=2\");\n";
+		else if (item.equals("Unsharp Mask"))
+			code = "run(\"Unsharp Mask...\", \"radius=1 mask=0.60\");\n";
+		else if (item.equals("Show File Info"))
+			code = "path=File.directory+File.name;\ndate=File.dateLastModified(path);\nsize=File.length(path);\nprint(i+\", \"+getTitle+\", \"+date+\", \"+size);\n";
+		else if (item.equals("Max Dimension"))
+			code = "max=2048;\nw=getWidth; h=getHeight;\nsize=maxOf(w,h);\nif (size>max) {\n  scale = max/size;\n  w*=scale; h*=scale;\n  run(\"Size...\", \"width=w height=h interpolation=Bicubic average\");\n}";
+		else if (item.equals("Print Index and Title"))
+			code =  "if (i==0) print(\"\\\\Clear\"); print(IJ.pad(i,4)+\": \"+getTitle());\n";
+		if (code!=null) {
+			TextArea ta = gd.getTextArea1();
+			ta.insert(code, ta.getCaretPosition());
+			if (IJ.isMacOSX()) ta.requestFocus();
+		}
+	}
+
+	public static String openMacroFromJar(String name) {
+		ImageJ ij = IJ.getInstance();
+		Class c = ij!=null?ij.getClass():(new ImageStack()).getClass();
+		String macro = null;
+        try {
+			InputStream is = c .getResourceAsStream("/macros/"+name);
+			if (is==null) return null;
+            InputStreamReader isr = new InputStreamReader(is);
+            StringBuffer sb = new StringBuffer();
+            char [] b = new char [8192];
+            int n;
+            while ((n = isr.read(b)) > 0)
+                sb.append(b,0, n);
+            macro = sb.toString();
+        }
+        catch (IOException e) {
+        	return null;
+        }
+        return macro;
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		Object source = e.getSource();
+		if (source==input) {
+			String path = IJ.getDirectory("Input Folder");
+			if (path==null) return;
+			inputDir.setText(path);
+		} else if (source==output) {
+			String path = IJ.getDirectory("Output Folder");
+			if (path==null) return;
+			outputDir.setText(path);
+		} else if (source==test) {
+			thread = new Thread(this, "BatchTest"); 
+			thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+			thread.start();
+		} else if (source==open)
+			open();
+		else if (source==save)
+			save();
+	}
+	
+	void open() {
+		String text = IJ.openAsString("");
+		if (text==null) return;
+		if (text.startsWith("Error: "))
+			error(text.substring(7));
+		else {
+			if (text.length()>30000)
+				error("File is too large");
+			else
+				gd.getTextArea1().setText(text);
+		}
+	}
+	
+	void save() {
+		macro = gd.getTextArea1().getText();
+		if (!macro.equals(""))
+			IJ.saveString(macro, "");
+	}
+
+	void error(String msg) {
+		IJ.error("Batch Processor", msg);
+	}
+	
+	public void run() {
+		TextArea ta = gd.getTextArea1();
+		//ta.selectAll();
+		String macro = ta.getText();
+		if (macro.equals("")) {
+			error("There is no macro code in the text area");
+			return;
+		}
+		ImagePlus imp = null;
+		IJ.redirectErrorMessages(true);
+		if (virtualStack!=null)
+			imp = getVirtualStackImage();
+		else
+			imp = getFolderImage();
+		IJ.redirectErrorMessages(false);
+		if (imp==null) {
+			if (!errorDisplayed)
+				IJ.log("IJ.openImage() returned null");
+			return;
+		}
+		runMacro("i=0;"+macro, imp);
+		Point loc = new Point(10, 30);
+		if (testImage!=0) {
+			ImagePlus imp2 = WindowManager.getImage(testImage);
+			if (imp2!=null) {
+				ImageWindow win = imp2.getWindow();
+				if (win!=null) loc = win.getLocation();
+				imp2.changes=false;
+				imp2.close();
+			}
+		}
+		imp.show();
+		ImageWindow iw = imp.getWindow();
+		if (iw!=null) iw.setLocation(loc);
+		testImage = imp.getID();
+	}
+	
+	ImagePlus getVirtualStackImage() {
+		ImagePlus imp = virtualStack.createImagePlus();
+		imp.setProcessor("", virtualStack.getProcessor().duplicate());
+		return imp;
+	}
+
+	ImagePlus getFolderImage() {
+		String inputPath = inputDir.getText();
+		inputPath = addSeparator(inputPath);
+		File f1 = new File(inputPath);
+		if (!f1.exists() || !f1.isDirectory()) {
+			error("Input does not exist or is not a folder\n \n"+inputPath);
+			errorDisplayed = true;
+			return null;
+		}
+		String[] list = (new File(inputPath)).list();
+		String name = list[0];
+		if (name.startsWith(".")&&list.length>1) name = list[1];
+		String path = inputPath + name;
+		setDirAndName(path);
+		return IJ.openImage(path);
+	}
+	
+	void setDirAndName(String path) {
+		File f = new File(path);
+		OpenDialog.setLastDirectory(f.getParent()+File.separator);
+		OpenDialog.setLastName(f.getName());
+	}
+	
+	public static void saveOutput(boolean b) {
+		saveOutput = b;
+	}
+
+}
diff --git a/src/ij/plugin/Benchmark.java b/src/ij/plugin/Benchmark.java
new file mode 100644
index 0000000..9ee4d40
--- /dev/null
+++ b/src/ij/plugin/Benchmark.java
@@ -0,0 +1,127 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.ResultsTable;
+import ij.util.Tools;
+
+/** Implements the Plugins/Utilities/Run Benchmark command.
+ * Suppresses subordinate status bar messages by using
+ * IJ.showStatus("!"+"rest of messager") and displays
+ * subordinate progress bars as dots by using
+ * IJ.showProgress(-currentIndex,finalIndex).
+*/
+public class Benchmark implements PlugIn {
+    private String[] results = {
+        "10.9|MacBook Air (M1, 2020, Native)",
+        "17.2|iMac Pro (2017)",
+        "18.1|MacBook Air (M1, 2020, Rosetta)",
+        "22.8|Dell T7920 (Dual Xeon, 282GB RAM, 2018)", 
+		"24.7|27\" iMac (Early 2015)",
+    	"29.7|13\" MacBook Pro (Late 2015)",
+    	"29.7|15\" MacBook Pro (Early 2013)",
+     	"62.3|Acer Aspire laptop (Core i5, 2014)"
+	};
+    private int size = 5000;
+    private int ops = 62;
+    private int counter;
+
+    public void run(String arg) {
+    	ImagePlus cImp = WindowManager.getCurrentImage();
+    	if (cImp!=null && cImp.getWidth()==512 && cImp.getHeight()==512 && cImp.getBitDepth()==24) {
+			IJ.runPlugIn(cImp, "ij.plugin.filter.Benchmark", "");
+    		return;
+    	}
+        IJ.showStatus("Creating "+size+"x"+size+" 16-bit image");
+        long t0 = System.currentTimeMillis();
+        ImageProcessor.setRandomSeed(12345);
+        ImagePlus imp = IJ.createImage("Untitled", "16-bit noise", size, size, 1);
+        ImageProcessor.setRandomSeed(Double.NaN);
+        imp.copy();                
+        for (int i=0; i<3; i++)
+            analyzeParticles(imp);
+        for (int i=0; i<3; i++) {
+            IJ.run(imp, "Median...", "radius=2");
+            showProgress("Median");
+        }
+        for (int i=0; i<12; i++) {
+            IJ.run(imp, "Unsharp Mask...", "radius=1 mask=0.60");
+            showProgress("Unsharp Mask");
+        }
+        ImageProcessor ip = imp.getProcessor();
+        ip.snapshot();
+        for (int i=0; i<12; i++) {
+            ip.blurGaussian(40);
+            showProgress("Gaussian blur");
+        }
+        ip.reset();
+        for (int i=0; i<360; i+=20) {
+            ip.reset();
+            ip.rotate(i);
+            showProgress("Rotate");
+        }
+        double scale = 1.2;
+        for (int i=0; i<14; i++) {
+            ip.reset();
+            ip.scale(scale, scale);
+            showProgress("Scale");
+            scale = scale*1.2;
+        }
+        double time = (System.currentTimeMillis()-t0)/1000.0;
+        ResultsTable rt = new ResultsTable();
+        rt.showRowNumbers(true);
+        for (int i=0; i<results.length; i++) {
+        	String[] columns = Tools.split(results[i],"|");
+			rt.addRow();
+      		rt.addValue("Time", columns[0]);
+      		rt.addValue("Computer", columns[1]);
+        }
+		rt.addRow();
+		String t = IJ.d2s(time,1);
+		if (t.length()<4) t=" "+t;
+		rt.addValue("Time", t);
+		int threads = Prefs.getThreads();
+		String suffix = " THREAD"+(threads>1?"S":"")+")>>";
+		rt.addValue("Computer", "<<THIS MACHINE ("+threads+suffix);
+		rt.sort("Time");
+        rt.show("Benchmark Results");
+        IJ.showStatus("!"+IJ.d2s(time,1)+" seconds to perform "+counter+" operations on a "+size+"x"+size+" 16-bit image");
+    }
+    
+    void analyzeParticles(ImagePlus imp) {
+        showProgress("Particle analyzer");
+        imp.paste();
+        IJ.setAutoThreshold(imp, "Default");
+        IJ.run(imp, "Gaussian Blur...", "sigma=10");
+        IJ.setAutoThreshold(imp, "Default");
+        IJ.run(imp, "Analyze Particles...", "clear overlay composite");
+        Overlay overlay = imp.getOverlay();
+        int n = overlay.size();
+        double sumArea = 0;
+        double sumMean = 0;
+        for (int i=0; i<n; i++) {
+            imp.setRoi(overlay.get(i));
+            ImageStatistics stats = imp.getStatistics();
+            sumArea += stats.area;
+            sumMean += stats.mean;
+        }
+        imp.resetRoi();
+        if (counter==1 && (n!=1886||sumArea/n!=5843.324496288441||sumMean/n!=32637.72733693335)) {
+            IJ.log(n+" "+sumArea/n+" "+sumMean/n);
+            error("Particle analyzer");
+        }
+    }
+    
+    void showProgress(String msg) {
+        counter++;
+        msg = msg.length()>1?" ("+msg+")":"";
+        IJ.showStatus("!"+counter + "/"+ops+msg);
+        IJ.showProgress(-counter, ops);
+    }
+
+    void error(String msg) {
+        IJ.log("Benchmark: "+msg+" error");
+    }
+}
+
+
diff --git a/src/ij/plugin/Binner.java b/src/ij/plugin/Binner.java
new file mode 100644
index 0000000..2549a66
--- /dev/null
+++ b/src/ij/plugin/Binner.java
@@ -0,0 +1,286 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.awt.image.*;
+
+/** This plugin implements the Image/Transform/Bin command.
+ * It reduces the size of an image or stack by binning groups of 
+ * pixels of user-specified sizes. The resulting pixel can be 
+ * calculated as average, median, maximum or minimum.
+ *
+ * @author Nico Stuurman
+ * @author Wayne Rasband
+ */
+public class Binner implements PlugIn {
+	public static int AVERAGE=0, MEDIAN=1, MIN=2, MAX=3, SUM=4;
+	private static String[] methods = {"Average", "Median", "Min", "Max", "Sum"};
+	private int xshrink=2, yshrink=2, zshrink=1;
+	private int method = AVERAGE;
+	private float maxValue;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		if (!showDialog(imp))
+			return;
+		if (imp.getStackSize()==1)
+			Undo.setup(Undo.TYPE_CONVERSION, imp);
+		imp.startTiming();
+		ImagePlus imp2 = shrink(imp, xshrink, yshrink, zshrink, method);
+		IJ.showTime(imp, imp.getStartTime(), "", imp.getStackSize());
+		imp.setStack(imp2.getStack());
+		imp.setCalibration(imp2.getCalibration());
+		if (zshrink>1)
+			imp.setSlice(1);
+	}
+
+	public ImagePlus shrink(ImagePlus imp, int xshrink, int yshrink, int zshrink, int method) {
+		this.xshrink = xshrink;
+		this.yshrink = yshrink;
+		int w = imp.getWidth()/xshrink;
+		int h = imp.getHeight()/yshrink;
+		ColorModel cm=imp.createLut().getColorModel();
+		ImageStack stack=imp.getStack();
+		ImageStack stack2 = new ImageStack (w, h, cm);
+		int d = stack.size();
+		if (method==SUM) {
+			int bitDepth = imp.getBitDepth();
+			if (bitDepth==8)
+				maxValue = 255;
+			else if (bitDepth==16)
+				maxValue = 65535;
+			else
+				maxValue = 0;
+		}
+		for (int z=1; z<=d; z++) {
+			IJ.showProgress(z, d);
+			ImageProcessor ip = stack.getProcessor(z);
+			if (ip.isInvertedLut()) 
+				ip.invert();
+			ImageProcessor ip2 = shrink(ip, method);
+			if (ip.isInvertedLut()) ip2.invert();
+			stack2.addSlice(stack.getSliceLabel(z), ip2);
+		}
+		if (zshrink>1 && !imp.isHyperStack())
+			stack2 = shrinkZ(stack2, zshrink);
+		ImagePlus imp2 = imp.createImagePlus();
+		imp2.setStack("Reduced "+imp.getShortTitle(), stack2);
+		Calibration cal2 = imp2.getCalibration();
+		if (cal2.scaled()) {
+			cal2.pixelWidth *= xshrink;
+			cal2.pixelHeight *= yshrink;
+			cal2.pixelDepth *= zshrink;
+		}
+		//if (zshrink>1 && imp.isHyperStack())
+		//	imp2 = shrinkHyperstackZ(imp2, zshrink);
+		imp2.setOpenAsHyperStack(imp.isHyperStack());
+		if (method==SUM  && imp2.getBitDepth()>8) {
+			ImageProcessor ip = imp2.getProcessor();
+			ip.setMinAndMax(ip.getMin(), ip.getMax()*xshrink*yshrink*zshrink);
+		}
+		return imp2;
+	}
+	
+	private ImageStack shrinkZ(ImageStack stack, int zshrink) {
+		int w = stack.getWidth();
+		int h = stack.getHeight();
+		int d = stack.size();
+		int d2 = d/zshrink;
+		ImageStack stack2 = new ImageStack (w, h, stack.getColorModel());
+		for (int z=1; z<=d2; z++)
+			stack2.addSlice(stack.getProcessor(z).duplicate());
+		boolean rgb = stack.getBitDepth()==24;
+		ImageProcessor ip = rgb?new ColorProcessor(d, h):new FloatProcessor(d, h);
+		for (int x=0; x<w; x++) {
+			IJ.showProgress(x+1, w);
+			for (int y=0; y<h; y++) {
+				float value;
+				for (int z=0; z<d; z++) {
+					value = (float)stack.getVoxel(x, y, z);
+					ip.setf(z, y, value);
+				}
+			}
+			ImageProcessor ip2 = shrink(ip, zshrink, 1, method);
+			for (int x2=0; x2<d2; x2++) {
+				for (int y2=0; y2<h; y2++) {
+					stack2.setVoxel(x, y2, x2, ip2.getf(x2,y2));
+				}
+			}
+		}
+		return stack2;
+	}
+	
+	public ImagePlus shrinkHyperstackZ(ImagePlus imp, int zshrink) {
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		ImageStack stack = imp.getStack();
+		int slices2 = slices/zshrink;
+		ImageStack stack2 = new ImageStack(width, height);
+		for (int c=1; c<=channels; c++) {
+			for (int t=1; t<=frames; t++) {
+				ImageStack tstack = new ImageStack(width, height);
+				for (int z=1; z<=slices; z++) {
+					int i = imp.getStackIndex(c, z, t);
+					ImageProcessor ip = stack.getProcessor(imp.getStackIndex(c, z, t));
+						tstack.addSlice(stack.getSliceLabel(i), ip);
+				}
+				//IJ.log("1: "+c+"  "+t+" "+tstack.size()+"  "+slices);
+				tstack = shrinkZ(tstack, zshrink);
+				for (int i=1; i<=tstack.size(); i++)
+					stack2.addSlice(tstack.getSliceLabel(i), tstack.getProcessor(i));
+			}
+		}
+		imp.setStack(stack2, channels, slices2, frames);
+		new HyperStackConverter().shuffle(imp, HyperStackConverter.ZTC);
+		IJ.showProgress(1.0);
+		return imp;
+	}
+	
+	public ImageProcessor shrink(ImageProcessor ip, int xshrink, int yshrink, int method) {
+		this.xshrink = xshrink;
+		this.yshrink = yshrink;
+		return shrink(ip, method);
+	}
+
+	private ImageProcessor shrink(ImageProcessor ip, int method) {
+		if (method<0 || method>methods.length)
+			method = AVERAGE;
+		int w = ip.getWidth()/xshrink;
+		int h = ip.getHeight()/yshrink;
+		ImageProcessor ip2 = ip.createProcessor(w, h);
+		if (ip instanceof ColorProcessor)
+			return shrinkRGB((ColorProcessor)ip, (ColorProcessor)ip2, method);
+		for (int y=0; y<h; y++) {
+			for (int x=0; x<w; x++) {
+				if (method==AVERAGE)
+					ip2.setf(x, y, getAverage(ip, x, y));
+				else if (method==MEDIAN)
+					ip2.setf(x, y, getMedian(ip, x, y));
+				else if (method==MIN)
+					ip2.setf(x, y, getMin(ip, x, y));
+				else if (method==MAX)
+					ip2.setf(x, y, getMax(ip, x, y));
+				else if (method==SUM)
+					ip2.setf(x, y, getSum(ip, x, y));
+			}
+		}
+		return ip2;
+	}
+
+	private ImageProcessor shrinkRGB(ColorProcessor cp, ColorProcessor cp2, int method) {
+		ByteProcessor bp = cp.getChannel(1, null);
+		cp2.setChannel(1, (ByteProcessor)shrink(bp, method));
+		cp2.setChannel(2, (ByteProcessor)shrink(cp.getChannel(2,bp), method));
+		cp2.setChannel(3, (ByteProcessor)shrink(cp.getChannel(3,bp), method));
+		return cp2;
+	}
+
+	private float getAverage(ImageProcessor ip, int x, int y) {
+		float sum = 0;
+		for (int y2=0; y2<yshrink; y2++) {
+			for (int x2=0;  x2<xshrink; x2++)
+				sum += ip.getf(x*xshrink+x2, y*yshrink+y2); 
+		}
+		return (float)(sum/(xshrink*yshrink));
+	}
+
+	private float getMedian(ImageProcessor ip, int x, int y) {
+		int shrinksize=xshrink*yshrink;
+		float[] pixels = new float[shrinksize];
+		int p=0;
+		// fill pixels within local neighborhood
+		for (int y2=0; y2<yshrink; y2++) {
+			for (int x2=0;  x2<xshrink; x2++)
+				pixels[p++]= ip.getf(x*xshrink+x2, y*yshrink+y2); 
+		}
+		// find median value
+		int halfsize=shrinksize/2;
+		for (int i=0; i<=halfsize; i++) {
+			float max=0f;
+			int mj=0;
+			for (int j=0; j<shrinksize; j++) {
+				if (pixels[j]>max) {
+					max = pixels[j];
+					mj = j;
+				}
+			}
+			pixels[mj] = 0;
+		}
+		float max = -Float.MAX_VALUE;
+		for (int j=0; j<shrinksize; j++) {
+			if (pixels[j]>max)
+				max = pixels[j];
+		}
+		return max;
+	}
+
+	private float getMin(ImageProcessor ip, int x, int y) {
+		float min = Float.MAX_VALUE;
+		float pixel;
+		for (int y2=0; y2<yshrink; y2++) {
+			for (int x2=0;  x2<xshrink; x2++) {
+				pixel = ip.getf(x*xshrink+x2, y*yshrink+y2); 
+				if (pixel<min)
+					min = pixel;
+			}
+		}
+		return min;
+	}
+
+	private float getMax(ImageProcessor ip, int x, int y) {
+		float max = -Float.MAX_VALUE;
+		float pixel;
+		for (int y2=0; y2<yshrink; y2++) {
+			for (int x2=0;  x2<xshrink; x2++) {
+				pixel = ip.getf(x*xshrink+x2, y*yshrink+y2); 
+				if (pixel>max)
+					max = pixel;
+			}
+		}
+		return max;
+	}
+
+	private float getSum(ImageProcessor ip, int x, int y) {
+		float sum = 0;
+		for (int y2=0; y2<yshrink; y2++) {
+			for (int x2=0;  x2<xshrink; x2++)
+				sum += ip.getf(x*xshrink+x2, y*yshrink+y2); 
+		}
+		if (maxValue>0f && sum>maxValue)
+			sum = maxValue;
+		return sum;
+	}
+
+	private boolean showDialog(ImagePlus imp) {
+		boolean stack = imp.getStackSize()>1;
+		if (imp.isComposite() && imp.getNChannels()==imp.getStackSize())
+			stack = false;
+		GenericDialog gd = new GenericDialog("Image Shrink");
+		gd.addNumericField("X shrink factor:", xshrink, 0);
+		gd.addNumericField("Y shrink factor:", yshrink, 0);
+		if (stack)
+			gd.addNumericField("Z shrink factor:", zshrink, 0);
+		if (method>methods.length)
+			method = 0;
+		gd.addChoice ("Bin Method: ", methods, methods[method]);
+		if (imp.getStackSize()==1) {
+			gd.setInsets(5, 0, 0);
+			gd.addMessage("This command supports Undo", null, Color.darkGray);
+		}
+		gd.showDialog();
+		if (gd.wasCanceled()) 
+			return false;
+		xshrink = (int) gd.getNextNumber();
+		yshrink = (int) gd.getNextNumber();
+		if (stack)
+			zshrink = (int) gd.getNextNumber();
+		method = gd.getNextChoiceIndex();
+		return true;
+	}
+
+}
diff --git a/src/ij/plugin/BrowserLauncher.java b/src/ij/plugin/BrowserLauncher.java
new file mode 100644
index 0000000..a47c93d
--- /dev/null
+++ b/src/ij/plugin/BrowserLauncher.java
@@ -0,0 +1,128 @@
+package ij.plugin;
+import ij.IJ;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+/**
+ * This plugin implements the File/Import/URL command and the commands in the Help menu that 
+ * open web pages. It is based on Eric Albert's cross-platform (Windows, Mac OS X and Unix) 
+ * BrowserLauncher class.
+ * <p>
+ * BrowserLauncher is a class that provides one static method, openURL, which opens the default
+ * web browser for the current user of the system to the given URL.  It may support other
+ * protocols depending on the system -- mailto, ftp, etc. -- but that has not been rigorously
+ * tested and is not guaranteed to work.
+ * <p>
+ * Yes, this is platform-specific code, and yes, it may rely on classes on certain platforms
+ * that are not part of the standard JDK.  What we're trying to do, though, is to take something
+ * that's frequently desirable but inherently platform-specific -- opening a default browser --
+ * and allow programmers (you, for example) to do so without worrying about dropping into native
+ * code or doing anything else similarly evil.
+ * <p>
+ * Anyway, this code is completely in Java and will run on all JDK 1.1-compliant systems without
+ * modification or a need for additional libraries.  All classes that are required on certain
+ * platforms to allow this to run are dynamically loaded at runtime via reflection and, if not
+ * found, will not cause this to do anything other than returning an error when opening the
+ * browser.
+ * <p>
+ * This code is Copyright 1999-2001 by Eric Albert (ejalbert@cs.stanford.edu) and may be
+ * redistributed or modified in any form without restrictions as long as the portion of this
+ * comment from this paragraph through the end of the comment is not removed.  The author
+ * requests that he be notified of any application, applet, or other binary that makes use of
+ * this code, but that's more out of curiosity than anything and is not required.  This software
+ * includes no warranty.  The author is not repsonsible for any loss of data or functionality
+ * or any adverse or unexpected effects of using this software.
+ * <p>
+ * Credits:
+ * <br>Steven Spencer, JavaWorld magazine (<a href="http://www.javaworld.com/javaworld/javatips/jw-javatip66.html">Java Tip 66</a>)
+ * <br>Thanks also to Ron B. Yeh, Eric Shapiro, Ben Engber, Paul Teitlebaum, Andrea Cantatore,
+ * Larry Barowski, Trevor Bedzek, Frank Miedrich, and Ron Rabakukk
+ *
+ * @author Eric Albert (<a href="mailto:ejalbert@cs.stanford.edu">ejalbert@cs.stanford.edu</a>)
+ * @version 1.4b1 (Released June 20, 2001)
+ */
+public class BrowserLauncher implements PlugIn {
+	/** The com.apple.mrj.MRJFileUtils class */
+	private static Class mrjFileUtilsClass;
+	/** The openURL method of com.apple.mrj.MRJFileUtils */
+	private static Method openURL;
+	private static boolean error;
+
+
+	/** Opens the specified URL (default is the ImageJ home page). */
+	public void run(String theURL) {
+		if (error) return;
+		if (theURL==null || theURL.equals(""))
+			theURL = IJ.URL;
+		try {openURL(theURL);}
+		catch (IOException e) {}
+	}
+
+	/** Opens the specified URL in the default browser.
+	 * Returns a message if there is an error.
+	 * Call from a macro using:<br>
+	 *    call("ij.plugin.BrowserLauncher.open",url);
+	 */
+	public static String open(String url) {
+		try {
+			openURL(url);
+		} catch (IOException e) {
+			return e.getMessage();
+		}
+		return "";
+	}
+
+	/**
+	 * Attempts to open the default web browser to the given URL.
+	 * @param url The URL to open
+	 * @throws IOException If the web browser could not be located or does not run
+	 */
+	public static void openURL(String url) throws IOException {
+		String errorMessage = "";
+		if (IJ.isMacOSX())
+			IJ.runMacro("exec('open', getArgument())",url);
+		else if (IJ.isWindows()) {
+			String cmd = "rundll32 url.dll,FileProtocolHandler " + url;
+			if (System.getProperty("os.name").startsWith("Windows 2000"))
+				cmd = "rundll32 shell32.dll,ShellExec_RunDLL " + url;
+			Process process = Runtime.getRuntime().exec(cmd);
+			// This avoids a memory leak on some versions of Java on Windows.
+			// That's hinted at in <http://developer.java.sun.com/developer/qow/archive/68/>.
+			try {
+				process.waitFor();
+				process.exitValue();
+			} catch (InterruptedException ie) {
+				throw new IOException("InterruptedException while launching browser: " + ie.getMessage());
+			}
+		} else {
+				// Assume Linux or Unix
+				// Based on BareBonesBrowserLaunch (http://www.centerkey.com/java/browser/)
+				// The utility 'xdg-open' launches the URL in the user's preferred browser,
+				// therefore we try to use it first, before trying to discover other browsers.
+				String[] browsers = {"xdg-open", "netscape", "firefox", "konqueror", "mozilla", "opera", "epiphany", "lynx" };
+				String browserName = null;
+				try {
+					for (int count=0; count<browsers.length && browserName==null; count++) {
+						String[] c = new String[] {"which", browsers[count]};
+						if (Runtime.getRuntime().exec(c).waitFor()==0)
+							browserName = browsers[count];
+					}
+					if (browserName==null)
+						ij.IJ.error("BrowserLauncher", "Could not find a browser");
+					else
+						Runtime.getRuntime().exec(new String[] {browserName, url});
+				} catch (Exception e) {
+					throw new IOException("Exception while launching browser: " + e.getMessage());
+				}
+		}
+	}
+	
+}
+
diff --git a/src/ij/plugin/CalibrationBar.java b/src/ij/plugin/CalibrationBar.java
new file mode 100644
index 0000000..b3f26ce
--- /dev/null
+++ b/src/ij/plugin/CalibrationBar.java
@@ -0,0 +1,511 @@
+package ij.plugin;
+import ij.*;
+import static ij.IJ.createImage;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import java.io.*;
+import java.awt.datatransfer.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Measurements;
+import ij.plugin.filter.Analyzer;
+import ij.text.TextWindow;
+import ij.measure.*;
+
+/** This plugin implements the Analyze/Tools/Calibration Bar command.
+	Bob Dougherty, OptiNav, Inc., 4/14/2002
+	Based largely on HistogramWindow.java by Wayne Rasband.
+	July 2002: Modified by Daniel Marsh and renamed CalibrationBar.
+	January 2013: Displays calibration bar as an overlay.
+	Jan 2020: calibration bar on separate image, Norbert Vischer
+*/
+
+public class CalibrationBar implements PlugIn {
+	public static final double  STROKE_WIDTH = 1.0001;
+	final static int BAR_LENGTH = 128;
+	final static int BAR_THICKNESS = 12;
+	final static int XMARGIN = 10;
+	final static int YMARGIN = 10;
+	final static int WIN_HEIGHT = BAR_LENGTH;
+	final static int BOX_PAD = 0;
+	final static String CALIBRATION_BAR = "|CB|";
+	static int nBins = 256;
+	static final String[] colors = {"White","Light Gray","Dark Gray","Black","Red","Green","Blue","Yellow","None"};
+	static final String[] locations = {"Upper Right","Lower Right","Lower Left", "Upper Left", "At Selection", "Separate Image"};
+	static final int UPPER_RIGHT=0, LOWER_RIGHT=1, LOWER_LEFT=2, UPPER_LEFT=3, AT_SELECTION=4, SEPARATE_IMAGE = 5;
+
+	private static String sFillColor = colors[0];
+	private static String sTextColor = colors[3];
+	private static String sLocation = locations[UPPER_RIGHT];
+	private static double sZoom = 1;
+	private static int sNumLabels = 5;
+	private static int sFontSize = 12;
+	private static int sDecimalPlaces = 0;
+	private static boolean sFlatten;
+	private static boolean sBoldText;
+	
+	private String fillColor = sFillColor;
+	private String textColor = sTextColor;
+	private String location = sLocation;
+	private double zoom = sZoom;
+	private int numLabels = sNumLabels;
+	private int fontSize = sFontSize;
+	private int decimalPlaces = sDecimalPlaces;
+	private boolean flatten = sFlatten;
+	private boolean boldText = sBoldText;
+
+	ImagePlus imp;
+	LiveDialog gd;
+
+	ImageStatistics stats;
+	Calibration cal;
+	int[] histogram;
+	Image img;
+	Button setup, redraw, insert, unInsert;
+	Checkbox ne,nw,se,sw;
+	CheckboxGroup locGroup;
+	Label value, note;
+	int newMaxCount;
+	boolean logScale;
+	int win_width;
+	int userPadding = 0;
+	int fontHeight = 0;
+	boolean showUnit;
+	Object backupPixels;
+	byte[] byteStorage;
+	int[] intStorage;
+	short[] shortStorage;
+	float[] floatStorage;
+	String boxOutlineColor = colors[8];
+	String barOutlineColor = colors[3];
+	
+	ImageProcessor ip;
+	String[] fieldNames = null;
+	int insetPad;
+	boolean decimalPlacesChanged;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		if (imp.getBitDepth()==24 || imp.getCompositeMode()==IJ.COMPOSITE) {
+			IJ.error("Calibration Bar", "RGB and composite images are not supported");
+			return;
+		}
+		if (imp.getRoi()!=null && imp.getRoi().isArea())
+			location = locations[AT_SELECTION];
+		else if (location.equals(locations[AT_SELECTION]))
+			location = locations[UPPER_RIGHT];
+		ImageCanvas ic = imp.getCanvas();
+		double mag = (ic!=null)?ic.getMagnification():1.0;
+		if (zoom<=1 && mag<1)
+			zoom = (double) 1.0/mag;
+		insetPad = (imp.getWidth()+imp.getHeight())/100;
+		if (insetPad<4)
+			insetPad = 4;
+		updateColorBar();
+		if (IJ.isMacro()) {
+			flatten = true;
+			fillColor = colors[0];
+			textColor = colors[3];
+			location = locations[UPPER_RIGHT];
+			zoom = 1;
+			numLabels = 5;
+			fontSize = 12;
+			decimalPlaces = 0;
+		}
+		if (!showDialog()) {
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null) {
+				overlay.remove(CALIBRATION_BAR);
+				overlay.setIsCalibrationBar(false);
+				imp.draw();
+			}
+			return;
+		}
+		updateColorBar();	
+		boolean separate = location.equals(locations[SEPARATE_IMAGE]);
+		if (flatten || separate) {
+			imp.deleteRoi();
+			IJ.wait(100);
+			ImagePlus imp2 = null;
+			if(!separate){
+				imp2 = imp.flatten();
+				imp2.setTitle(imp.getTitle()+" with bar");
+			}
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null) {	
+				if(separate){	
+					Overlay overlaySep = overlay.duplicate();	
+					overlay.setIsCalibrationBar(false);
+					for (int jj=overlaySep.size()-1; jj>=0; jj--) {//isolate CB components
+						Roi roi = overlaySep.get(jj);
+						if(roi.getName() == null || !roi.getName().equals(CALIBRATION_BAR))
+							overlaySep.remove(roi);
+					}
+					Rectangle r = overlaySep.get(0).getBounds();
+					overlaySep.translate(-r.x, -r.y);
+					ImagePlus impSep = IJ.createImage("CBar", "RGB", r.width, r.height, 1);
+					impSep.setOverlay(overlaySep);
+					impSep = impSep.flatten();//ignore the 'overlay' checkbox
+					impSep.setTitle("CBar");
+					impSep.show();
+				}
+				overlay.remove(CALIBRATION_BAR);
+				imp.draw();
+			}			
+			if(imp2 != null)
+				imp2.show();			
+		}
+	}
+
+	private void updateColorBar() {
+		Roi roi = imp.getRoi();
+		if (roi!=null &&  location.equals(locations[AT_SELECTION])) {
+			Rectangle r = roi.getBounds();
+			drawBarAsOverlay(imp, r.x, r.y);
+		} else if ( location.equals(locations[UPPER_LEFT]))
+			drawBarAsOverlay(imp, insetPad, insetPad);
+		else if (location.equals(locations[UPPER_RIGHT])) {
+			calculateWidth();
+			drawBarAsOverlay(imp, imp.getWidth()-insetPad-win_width, insetPad);
+		} else if (location.equals(locations[LOWER_LEFT]) )
+			drawBarAsOverlay(imp, insetPad,imp.getHeight() - (int)(WIN_HEIGHT*zoom + 2*(int)(YMARGIN*zoom)) - (int)(insetPad*zoom));
+		else if(location.equals(locations[LOWER_RIGHT])) {
+			calculateWidth();
+			drawBarAsOverlay(imp, imp.getWidth()-win_width-insetPad,
+				 imp.getHeight() - (int)(WIN_HEIGHT*zoom + 2*(int)(YMARGIN*zoom)) - insetPad);
+		}
+		else if ( location.equals(locations[SEPARATE_IMAGE])){
+			drawBarAsOverlay(imp, insetPad, insetPad);
+		}
+		this.imp.updateAndDraw();
+	}
+
+	private boolean showDialog() {
+		gd = new LiveDialog("Calibration Bar");
+		gd.addChoice("Location:", locations, location);
+		gd.addChoice("Fill color: ", colors, fillColor);
+		gd.addChoice("Label color: ", colors, textColor);
+		gd.addNumericField("Number of labels:", numLabels, 0);
+		gd.addNumericField("Decimal places:", decimalPlaces, 0);
+		gd.addNumericField("Font size:", fontSize, 0);
+		gd.addNumericField("Zoom factor:", zoom, 1);
+		String[] labels = {"Bold text", "Overlay", "Show unit"};
+		boolean[] states = {boldText, !flatten, showUnit};
+		gd.setInsets(10, 30, 0);
+		gd.addCheckboxGroup(2, 2, labels, states);
+		Checkbox overlayBox = (Checkbox)(gd.getCheckboxes().elementAt(1));
+		if (location.equals(locations[SEPARATE_IMAGE]))
+			overlayBox.setEnabled(false);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		location = gd.getNextChoice();
+		fillColor = gd.getNextChoice();
+		textColor = gd.getNextChoice();
+		numLabels = (int)gd.getNextNumber();
+		decimalPlaces = (int)gd.getNextNumber();
+		fontSize = (int)gd.getNextNumber();
+		zoom = (double)gd.getNextNumber();
+		boldText = gd.getNextBoolean();
+		flatten = !gd.getNextBoolean();
+		showUnit = gd.getNextBoolean();
+		if (!IJ.isMacro()) {
+			sFlatten = flatten;
+			sFillColor = fillColor;
+			sTextColor = textColor;
+			sLocation = location;
+			sZoom = zoom;
+			sNumLabels = numLabels;
+			sFontSize = fontSize;
+			sDecimalPlaces = decimalPlaces;
+			sBoldText = boldText;
+		}
+		return true;
+	}
+
+	private void drawBarAsOverlay(ImagePlus imp, int x, int y) {
+		Roi roi = imp.getRoi();
+		if (roi!=null)
+			imp.deleteRoi();
+		stats = imp.getStatistics(Measurements.MIN_MAX, nBins);
+		if (roi!=null)
+			imp.setRoi(roi);
+		histogram = stats.histogram;
+		cal = imp.getCalibration();
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			overlay = new Overlay();
+		else
+			overlay.remove(CALIBRATION_BAR);
+		int maxTextWidth = addText(null, 0, 0);
+		win_width = (int)(XMARGIN*zoom) + 5 + (int)(BAR_THICKNESS*zoom) + maxTextWidth + (int)((XMARGIN/2)*zoom);
+		if (x==-1 && y==-1)
+			return;	 // return if calculating width
+		Color c = getColor(fillColor);
+		if (c!=null) {
+			Roi r = new Roi(x, y, win_width, (int)(WIN_HEIGHT*zoom + 2*(int)(YMARGIN*zoom)));
+			r.setFillColor(c);
+			overlay.add(r, CALIBRATION_BAR);
+		}
+		int xOffset = x;
+		int yOffset = y;
+		if (decimalPlaces == -1)
+			decimalPlaces = Analyzer.getPrecision();
+		x = (int)(XMARGIN*zoom) + xOffset;
+		y = (int)(YMARGIN*zoom) + yOffset;
+		addVerticalColorBar(overlay, x, y, (int)(BAR_THICKNESS*zoom), (int)(BAR_LENGTH*zoom) );
+		addText(overlay, x + (int)(BAR_THICKNESS*zoom), y);
+		c = getColor(boxOutlineColor);
+		overlay.setIsCalibrationBar(true);
+		if (imp.getCompositeMode()>0) {
+			for (int i=0; i<overlay.size(); i++)
+				overlay.get(i).setPosition(imp.getC(), 0, 0);
+		}
+		imp.setOverlay(overlay);
+	}
+	
+	private void addVerticalColorBar(Overlay overlay, int x, int y, int thickness, int length) {
+		int width = thickness;
+		int height = length;
+		byte[] rLUT,gLUT,bLUT;
+		int mapSize = 0;
+		java.awt.image.ColorModel cm = imp.getProcessor().getCurrentColorModel();
+		if (cm instanceof IndexColorModel) {
+			IndexColorModel m = (IndexColorModel)cm;
+			mapSize = m.getMapSize();
+			rLUT = new byte[mapSize];
+			gLUT = new byte[mapSize];
+			bLUT = new byte[mapSize];
+			m.getReds(rLUT);
+			m.getGreens(gLUT);
+			m.getBlues(bLUT);
+		} else {
+			mapSize = 256;
+			rLUT = new byte[mapSize];
+			gLUT = new byte[mapSize];
+			bLUT = new byte[mapSize];
+			for (int i = 0; i < mapSize; i++) {
+				rLUT[i] = (byte)i;
+				gLUT[i] = (byte)i;
+				bLUT[i] = (byte)i;
+			}
+		}
+		double colors = mapSize;
+		int start = 0;
+		ImageProcessor ipOrig =imp.getProcessor();
+		if (ipOrig instanceof ByteProcessor) {
+			int min = (int)ipOrig.getMin();
+			if (min<0) min = 0;
+			int max = (int)ipOrig.getMax();
+			if (max>255) max = 255;
+			colors = max-min+1;
+			start = min;
+		}
+		for (int i = 0; i<(int)(BAR_LENGTH*zoom); i++) {
+			int iMap = start + (int)Math.round((i*colors)/(BAR_LENGTH*zoom));
+			if (iMap>=mapSize)
+				iMap =mapSize - 1;
+			int j = (int)(BAR_LENGTH*zoom) - i - 1;
+			Line line = new Line(x, j+y, thickness+x, j+y);
+			line.setStrokeColor(new Color(rLUT[iMap]&0xff, gLUT[iMap]&0xff, bLUT[iMap]&0xff));
+			line.setStrokeWidth(STROKE_WIDTH);
+			overlay.add(line, CALIBRATION_BAR);
+		}
+
+		Color c = getColor(barOutlineColor);
+		if (c!=null) {
+			Roi r = new Roi(x, y, width, height);
+			r.setStrokeColor(c);
+			r.setStrokeWidth(1.0);
+			overlay.add(r, CALIBRATION_BAR);
+		}
+	}
+
+	private int addText(Overlay overlay, int x, int y) {
+
+		Color c = getColor(textColor);
+		if (c == null)
+			return 0;
+		double hmin = cal.getCValue(stats.histMin);
+		double hmax = cal.getCValue(stats.histMax);
+		double barStep = (double)(BAR_LENGTH*zoom) ;
+		if (numLabels > 2)
+			barStep /= (numLabels - 1);
+
+		int fontType = boldText?Font.BOLD:Font.PLAIN;
+		Font font = null;
+		if (fontSize<9)
+			font = new Font("SansSerif", fontType, 9);
+		else
+			font = new Font("SansSerif", fontType, (int)( fontSize*zoom));
+		int maxLength = 0;
+
+		FontMetrics metrics = getFontMetrics(font);
+		fontHeight = metrics.getHeight();
+
+		for (int i = 0; i < numLabels; i++) {
+			double yLabelD = (int)(YMARGIN*zoom + BAR_LENGTH*zoom - i*barStep - 1);
+			int yLabel = (int)(Math.round( y + BAR_LENGTH*zoom - i*barStep - 1));
+			Calibration cal = imp.getCalibration();
+			String s = "";
+			if (showUnit)
+				s = cal.getValueUnit();
+			ImageProcessor ipOrig = imp.getProcessor();
+			double min = ipOrig.getMin();
+			double max = ipOrig.getMax();
+			if (ipOrig instanceof ByteProcessor) {
+				if (min<0) min = 0;
+				if (max>255) max = 255;
+			}
+			double grayLabel = min + (max-min)/(numLabels-1) * i;
+			if (cal.calibrated()) {
+				grayLabel = cal.getCValue(grayLabel);
+				double cmin = cal.getCValue(min);
+				double cmax = cal.getCValue(max);
+				if (!decimalPlacesChanged && decimalPlaces==0 && ((int)cmax!=cmax||(int)cmin!=cmin))
+					decimalPlaces = 2;
+			}
+			String todisplay = d2s(grayLabel)+" "+s;
+			if (overlay!=null) {
+				TextRoi label = new TextRoi(todisplay, x + 5, yLabel + fontHeight/2, font);				
+				label.setStrokeColor(c);
+				overlay.add(label, CALIBRATION_BAR);
+			}
+			int iLength = metrics.stringWidth(todisplay);
+			if (iLength > maxLength)
+				maxLength = iLength+5;
+		}
+		return maxLength;
+	}
+		
+	String d2s(double d) {
+			return IJ.d2s(d,decimalPlaces);
+	}
+
+	int getFontHeight() {
+		int fontType = boldText?Font.BOLD:Font.PLAIN;
+		Font font = new Font("SansSerif", fontType, (int) (fontSize*zoom) );
+		FontMetrics metrics = getFontMetrics(font);
+		return metrics.getHeight();
+	}
+
+	Color getColor(String color) {
+		Color c = Color.white;
+		if (color.equals(colors[1]))
+			c = Color.lightGray;
+		else if (color.equals(colors[2]))
+			c = Color.darkGray;
+		else if (color.equals(colors[3]))
+			c = Color.black;
+		else if (color.equals(colors[4]))
+			c = Color.red;
+		else if (color.equals(colors[5]))
+			c = Color.green;
+		else if (color.equals(colors[6]))
+			c = Color.blue;
+		else if (color.equals(colors[7]))
+			c = Color.yellow;
+		else if (color.equals(colors[8]))
+			c = null;
+		return c;
+	}	 
+
+	void calculateWidth() {
+		drawBarAsOverlay(imp, -1, -1);
+	}
+	
+	private FontMetrics getFontMetrics(Font font) {
+		BufferedImage bi =new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
+		Graphics g = (Graphics2D)bi.getGraphics();
+		g.setFont(font);
+		return g.getFontMetrics(font);
+	}
+		
+	class LiveDialog extends GenericDialog {
+
+		LiveDialog(String title) {
+			super(title);
+		}
+
+		public void textValueChanged(TextEvent e) {
+
+			if (fieldNames == null) {
+				fieldNames = new String[4];
+				for(int i=0;i<4;i++)
+					fieldNames[i] = ((TextField)numberField.elementAt(i)).getName();
+			}
+
+			TextField tf = (TextField)e.getSource();
+			String name = tf.getName();
+			String value = tf.getText();
+
+			if (value.equals(""))
+				return;
+
+			int i=0;
+			boolean needsRefresh = false;
+
+			if (name.equals(fieldNames[0])) {
+
+				i = getValue( value ).intValue() ;
+				if(i<1)
+					return;
+				else {
+					needsRefresh = true;
+					numLabels = i;
+				}
+			} else if (name.equals(fieldNames[1])) {
+				i = getValue( value ).intValue() ;
+				if (i<0)
+					return;
+				else {
+					needsRefresh = true;
+					decimalPlaces = i;
+					decimalPlacesChanged = true;
+				}
+
+			} else if (name.equals(fieldNames[2])) {
+				i = getValue( value ).intValue() ;
+				if(i<1)
+					return;
+				else {
+					needsRefresh = true;
+					fontSize = i;
+
+				}
+
+			} else if (name.equals(fieldNames[3])) {
+				double d = 0;
+				d = getValue( "0" + value ).doubleValue() ;
+				if(d<=0)
+					return;
+				else {
+					needsRefresh = true;
+					zoom = d;
+				}
+			}
+
+			if (needsRefresh)
+				updateColorBar();
+			return;
+		}
+
+		public void itemStateChanged(ItemEvent e) {
+			location = ( (Choice)(choice.elementAt(0)) ).getSelectedItem();
+			fillColor = ( (Choice)(choice.elementAt(1)) ).getSelectedItem();
+			textColor = ( (Choice)(choice.elementAt(2)) ).getSelectedItem();
+			boldText = ( (Checkbox)(checkbox.elementAt(0)) ).getState();
+			flatten = !( (Checkbox)(checkbox.elementAt(1)) ).getState();
+			showUnit = ( (Checkbox)(checkbox.elementAt(2)) ).getState();
+			Checkbox overlayBox = (Checkbox)(checkbox.elementAt(1) );
+			if (location.equals(locations[SEPARATE_IMAGE]))
+					overlayBox.setEnabled(false);
+			else
+					overlayBox.setEnabled(true);
+			updateColorBar();
+		}
+
+	} //LiveDialog inner class
+
+}
diff --git a/src/ij/plugin/CanvasResizer.java b/src/ij/plugin/CanvasResizer.java
new file mode 100644
index 0000000..38afc8f
--- /dev/null
+++ b/src/ij/plugin/CanvasResizer.java
@@ -0,0 +1,131 @@
+package ij.plugin;
+import ij.*;
+import ij.plugin.filter.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+
+/** This plugin implements the Image/Adjust/Canvas Size command.
+	It changes the canvas size of an image or stack without resizing the image.
+	The border is filled with the current background color.
+	@author Jeffrey Kuhn (jkuhn at ccwf.cc.utexas.edu)
+*/
+public class CanvasResizer implements PlugIn {
+	boolean zeroFill = Prefs.get("resizer.zero", false);
+
+	public void run(String arg) {
+		int wOld, hOld, wNew, hNew;
+		boolean fIsStack = false;
+
+		ImagePlus imp = IJ.getImage();
+		wOld = imp.getWidth();
+		hOld = imp.getHeight();
+		if (!imp.okToDeleteRoi()) return;
+
+		ImageStack stackOld = imp.getStack();
+		if ((stackOld != null) && (stackOld.getSize() > 1))
+			fIsStack = true;
+
+		String[] sPositions = {
+			"Top-Left", "Top-Center", "Top-Right", 
+			"Center-Left", "Center", "Center-Right",
+			"Bottom-Left", "Bottom-Center", "Bottom-Right"
+		};
+			
+		String strTitle = fIsStack ? "Resize Stack Canvas" : "Resize Image Canvas";
+		GenericDialog gd = new GenericDialog(strTitle);
+		gd.addNumericField("Width:", wOld, 0, 5, "pixels");
+		gd.addNumericField("Height:", hOld, 0, 5, "pixels");
+		gd.addChoice("Position:", sPositions, sPositions[4]);
+		gd.addCheckbox("Zero Fill", zeroFill);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+			
+		wNew = (int)gd.getNextNumber();
+		hNew = (int)gd.getNextNumber();
+		int iPos = gd.getNextChoiceIndex();
+		zeroFill = gd.getNextBoolean();
+		Prefs.set("resizer.zero", zeroFill);
+		
+		int xOff, yOff;
+		int xC = (wNew - wOld)/2;	// offset for centered
+		int xR = (wNew - wOld);		// offset for right
+		int yC = (hNew - hOld)/2;	// offset for centered
+		int yB = (hNew - hOld);		// offset for bottom
+		
+		switch(iPos) {
+		case 0:	// TL
+			xOff=0;	yOff=0; break;
+		case 1:	// TC
+			xOff=xC; yOff=0; break;
+		case 2:	// TR
+			xOff=xR; yOff=0; break;
+		case 3: // CL
+			xOff=0; yOff=yC; break;
+		case 4: // C
+			xOff=xC; yOff=yC; break;
+		case 5:	// CR
+			xOff=xR; yOff=yC; break;
+		case 6: // BL
+			xOff=0; yOff=yB; break;
+		case 7: // BC
+			xOff=xC; yOff=yB; break;
+		case 8: // BR
+			xOff=xR; yOff=yB; break;
+		default: // center
+			xOff=xC; yOff=yC; break;
+		}
+		
+		if (fIsStack) {
+			ImageStack stackNew = expandStack(stackOld, wNew, hNew, xOff, yOff);
+			imp.setStack(null, stackNew);
+		} else {
+			if (!IJ.macroRunning())
+				Undo.setup(Undo.COMPOUND_FILTER, imp);
+			ImageWindow win = imp.getWindow();
+			if (win!=null && (win instanceof PlotWindow))
+				((PlotWindow)win).getPlot().setFrozen(true);
+			ImageProcessor newIP = expandImage(imp.getProcessor(), wNew, hNew, xOff, yOff);
+			imp.setProcessor(null, newIP);
+			if (!IJ.macroRunning())
+				Undo.setup(Undo.COMPOUND_FILTER_DONE, imp);
+		}
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null)
+			overlay.translate(xOff, yOff);
+	}
+	
+	public ImageStack expandStack(ImageStack stackOld, int wNew, int hNew, int xOff, int yOff) {
+		int nFrames = stackOld.getSize();
+		ImageProcessor ipOld = stackOld.getProcessor(1);		
+		ImageStack stackNew = new ImageStack(wNew, hNew, stackOld.getColorModel());
+		ImageProcessor ipNew;
+		
+		for (int i=1; i<=nFrames; i++) {
+			IJ.showProgress((double)i/nFrames);
+			ipNew = ipOld.createProcessor(wNew, hNew);
+			if (zeroFill)
+				ipNew.setValue(0.0);
+			else 
+				ipNew.setGlobalBackgroundColor();
+			ipNew.fill();
+			ipNew.insert(stackOld.getProcessor(i), xOff, yOff);
+			stackNew.addSlice(stackOld.getSliceLabel(i), ipNew);
+		}
+		return stackNew;
+	}
+	
+	public ImageProcessor expandImage(ImageProcessor ipOld, int wNew, int hNew, int xOff, int yOff) {
+		ImageProcessor ipNew = ipOld.createProcessor(wNew, hNew);
+		if (zeroFill)
+			ipNew.setValue(0.0);
+		else 
+			ipNew.setGlobalBackgroundColor();
+		ipNew.fill();
+		ipNew.insert(ipOld, xOff, yOff);
+		return ipNew;
+	}
+
+}
+
diff --git a/src/ij/plugin/ChannelArranger.java b/src/ij/plugin/ChannelArranger.java
new file mode 100644
index 0000000..c07cd57
--- /dev/null
+++ b/src/ij/plugin/ChannelArranger.java
@@ -0,0 +1,352 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.plugin.ChannelSplitter;
+import java.awt.image.BufferedImage;
+import java.awt.event.*;
+import java.util.Vector;
+
+/**
+ * This plugin implements the Image/Colors/Arrange Channels command,
+ *	which allows the user to change the order of channels.
+ *
+ * @author Norbert Vischer <vischer@science.uva.nl> 23-sep-2012
+ */
+public class ChannelArranger implements PlugIn, TextListener {
+	private ThumbnailsCanvas thumbNails;
+	private String patternString;
+	private String allowedDigits;
+	private TextField orderField;
+	private int nChannels;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		nChannels = imp.getNChannels();
+		if (nChannels==1) {
+			IJ.error("Channel Arranger", "Image must have more than one channel");
+			return;
+		}
+		if (nChannels>9) {
+			IJ.error("Channel Arranger", "This command does not work with more than 9 channels.");
+			return;
+		}
+		patternString = "1234567890".substring(0, nChannels);
+		allowedDigits = patternString;
+		GenericDialog gd = new GenericDialog("Arrange Channels");
+		thumbNails = new ThumbnailsCanvas(imp);
+		Panel panel = new Panel();
+		panel.add(thumbNails);
+		gd.addPanel(panel);
+		//gd.setInsets(20, 20, 5);
+		gd.addStringField("New channel order:", allowedDigits);
+		Vector v = gd.getStringFields();
+		orderField = (TextField)v.elementAt(0);
+		orderField.addTextListener(this);
+		gd.addHelp(IJ.URL+"/docs/menus/image.html#arrange");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		String newOrder = gd.getNextString();
+		int nChannels2 = newOrder.length();
+		if (nChannels2==0)
+			return;
+		for (int i=0; i<nChannels2; i++) {
+			if (!Character.isDigit(newOrder.charAt(i))) {
+				IJ.error("Channel Arranger", "Non-digit in new order string: \""+newOrder+"\"");
+				return;
+			}
+		}
+		if (nChannels2<nChannels) {
+			String msg = "The number of channels will be reduced from "+nChannels+" to "+nChannels2+".";
+			if (!IJ.showMessageWithCancel("Reduce Number of Channels?", msg))
+				return;
+		}
+		Point location = imp.getWindow()!=null?imp.getWindow().getLocation():null;
+		int[] newOrder2 = new int[nChannels2];
+		for (int i=0; i<nChannels2; i++)
+			newOrder2[i] = newOrder.charAt(i)-48;
+		ImagePlus imp2 = run(imp, newOrder2);
+		imp2.copyAttributes(imp);
+		if (location!=null)
+			ImageWindow.setNextLocation(location);
+		imp2.changes = true;
+		imp2.show();
+	}
+	
+	/** Changes the order of the channels in a hyperstack.
+		@param img source hyperstack
+		@param newOrder the new channel order
+		@return a hyperstack with channels in the specified order
+		<p>
+		The following example opens the FluorescentCells sample  
+		image and reverses the order of the channels.
+		<pre>
+		ImagePlus img = IJ.openImage("http://imagej.nih.gov/ij/images/FluorescentCells.zip");
+		int[] order = {3,2,1};
+		ImagePlus img2 = ChannelArranger.run(img, order);
+		img2.setDisplayMode(IJ.COLOR);
+		img2.show();
+		</pre>
+	*/
+	public static ImagePlus run(ImagePlus img, int[] newOrder) {
+		int channel = img.getChannel();
+		int slice = img.getSlice();
+		int frame = img.getFrame();
+		ImagePlus[] channels = ChannelSplitter.split(img);
+		int nChannels2 = newOrder.length;
+		if (nChannels2>channels.length)
+			nChannels2 = channels.length;
+		ImagePlus[] channels2 = new ImagePlus[nChannels2];
+		for (int i=0; i<nChannels2; i++) {
+			int index = newOrder[i]-1;
+			if (index<0 || index>=channels.length)
+				throw new IllegalArgumentException("value out of range:"+newOrder[i]);
+			channels2[i] = channels[index];
+		}
+		ImagePlus img2 = null;
+		if (nChannels2==1)
+			img2 = channels2[0];
+		else
+			img2 = RGBStackMerge.mergeChannels(channels2, false);
+		int mode2 = IJ.COLOR;
+		if (img.isComposite())
+			mode2 = ((CompositeImage)img).getMode();
+		if (img2.isComposite())
+			((CompositeImage)img2).setMode(mode2);
+		if (channel<=nChannels2) {
+			int channel2 = newOrder[channel-1];
+			img2.setPosition(channel2, slice, frame);
+		}
+		Overlay overlay = img.getOverlay();
+		if (overlay!=null) {
+			for (int i=0; i<overlay.size(); i++) {
+				Roi roi = overlay.get(i);
+				int c = roi.getCPosition();
+				int z = roi.getZPosition();
+				int t = roi.getTPosition();
+				if (c>=1 && c<=nChannels2)
+					roi.setPosition(newOrder[c-1], z, t);
+			}
+			img2.setOverlay(overlay);
+		}
+		img.changes = false;
+		img.close();
+		return img2;
+	}
+
+	public void textValueChanged(TextEvent e) {
+		TextField tf = (TextField) e.getSource();
+		String typed = tf.getText();
+		if (typed.length()>nChannels) {
+			orderField.setText(patternString);
+			return;
+		}
+		for (int jj=0; jj<typed.length(); jj++) {
+			String digit = typed.substring(jj, jj + 1);
+			int found = typed.indexOf(digit, jj + 1);
+			if (found != -1) {
+				orderField.setText(patternString);
+				return;
+			}
+			if (allowedDigits.indexOf(digit)==-1) {
+				orderField.setText(patternString);
+				return;
+			}
+		}
+		patternString = typed;
+		thumbNails.setSequence(patternString);
+		thumbNails.repaint();
+		//orderField.setText(patternString);
+	}
+
+}
+
+class ThumbnailsCanvas extends Canvas implements MouseListener, MouseMotionListener, ActionListener {
+
+	protected static Cursor handCursor = new Cursor(Cursor.HAND_CURSOR);
+	protected static Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
+	Image os;
+	Graphics osg;
+	CompositeImage cImp;
+	int iconSize = 100;
+	int iconWidth = iconSize, iconHeight = iconSize;
+	int dx = 0, dy = 0;
+	int separatorY = 6;
+	int marginY = 10;
+	int marginX = 44;
+	int nChannels;
+	int channelUnderCursor = 0;
+	String seq = "1234567890";
+	int currentChannel, currentSlice, currentFrame;
+
+	public ThumbnailsCanvas(ImagePlus imp) {
+		if (!imp.isComposite())
+			return;
+		cImp = (CompositeImage) imp;
+		addMouseListener(this);
+		addMouseMotionListener(this);
+		currentChannel = cImp.getChannel();
+		currentSlice = cImp.getSlice();
+		currentFrame = cImp.getFrame();
+		channelUnderCursor = currentChannel;
+		int ww = cImp.getWidth();
+		int hh = cImp.getHeight();
+		if (ww > hh) {
+			iconHeight = iconWidth * hh / ww;
+			dy = (iconWidth - iconHeight) / 2;
+		}
+		if (ww < hh) {
+			iconWidth = iconHeight * ww / hh;
+			dx = (iconHeight - iconWidth) / 2;
+		}
+		nChannels = cImp.getNChannels();
+		seq = seq.substring(0, nChannels);
+		setSize((nChannels + 1) * iconSize, 2 * iconSize + 30);
+	}
+
+	public void update(Graphics g) {
+		paint(g);
+	}
+
+	public void setSequence(String seq) {
+		this.seq = seq;
+	}
+
+	public int[] getStackPos() {
+		return new int[]{currentChannel, currentSlice, currentFrame};
+	}
+
+	public void paint(Graphics g) {
+		if (g == null)
+			return;
+		int savedMode = cImp.getMode();
+		if (savedMode==IJ.COMPOSITE)
+			cImp.setMode(IJ.COLOR);
+		BufferedImage bImg;
+		ImageProcessor ipSmall;
+		os = createImage((nChannels + 1) * iconSize, 2 * iconSize + 30);
+		osg = os.getGraphics();
+		osg.setFont(IJ.font12);
+		int y1;
+		for (int chn = 1; chn <= nChannels; chn++) {
+			cImp.setPositionWithoutUpdate(chn, currentSlice, currentFrame);
+			cImp.updateImage();
+			ipSmall = cImp.getProcessor().resize(iconWidth, iconHeight, true);
+			bImg = ipSmall.getBufferedImage();
+			int index = chn - 1;
+			y1 = marginY;
+			for (int row = 0; row < 2; row++) {
+				if (index >= 0) {
+					int xx = index * iconSize + marginX;
+					osg.drawImage(bImg, xx + dx, y1 + dy, null);
+					osg.setColor(Color.LIGHT_GRAY);
+					osg.drawRect(xx, y1, iconSize, iconSize);
+					osg.fillRoundRect(xx + iconSize / 2 - 4, y1 + iconSize - 22, 18, 18, 6, 6);
+					osg.setColor(Color.BLACK);
+					osg.drawRoundRect(xx + iconSize / 2 - 4, y1 + iconSize - 22, 18, 18, 6, 6);
+					osg.drawString("" + chn, xx + 52, y1 + iconSize - 7);
+					index = seq.indexOf("" + chn, 0);
+					if (seq.indexOf("" + chn, index) == -1) {//char must not occur twice
+						index = -1;
+					}
+				}
+				y1 += (iconSize + separatorY);
+			}
+		}
+		y1 = marginY + iconSize - 7;
+		osg.drawString("Old:", 6, y1);
+		y1 += (iconSize + separatorY);
+		osg.drawString("New:", 6, y1);
+		osg.dispose();
+		if (os == null)
+			return;
+		g.drawImage(os, 0, 0, this);
+		if (savedMode==IJ.COMPOSITE)
+			cImp.setMode(savedMode);
+		cImp.setPosition(currentChannel, currentSlice, currentFrame);
+		cImp.updateImage();
+	}
+
+	protected void handlePopupMenu(MouseEvent e) {
+		int x = e.getX();
+		int y = e.getY();
+		PopupMenu popup = new PopupMenu();
+		String[] colors = "Grays,-,Red,Green,Blue,Yellow,Magenta,Cyan,-,Fire,Ice,Spectrum,3-3-2 RGB,Red/Green".split(",");
+		for (int jj = 0; jj < colors.length; jj++) {
+			if (colors[jj].equals("-"))
+				popup.addSeparator();
+			else {
+				MenuItem mi = new MenuItem(colors[jj]);
+				popup.add(mi);
+				mi.addActionListener(this);
+			}
+		}
+		add(popup);
+		if (IJ.isMacOSX())
+			IJ.wait(10);
+		popup.show(this, x, y);
+		setCursor(defaultCursor);
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		String cmd = e.getActionCommand();
+		cImp.setPosition(currentChannel, currentSlice, currentFrame);
+		CompositeImage cImp = (CompositeImage) this.cImp;
+		IJ.run(cmd);
+		repaint();
+		setCursor(defaultCursor);
+	}
+
+	public void mouseMoved(MouseEvent e) {
+		int x = e.getX() - marginX;
+		int y = e.getY() - marginY;
+		if (x < 0 || x > nChannels * iconSize || y < 0 || y > iconSize * 2 + separatorY) {
+			setCursor(defaultCursor);
+			channelUnderCursor = 0;
+		} else {
+			int chn = x / iconSize + 1;
+			if (y > iconSize) {
+				if (chn <= seq.length()) {
+					String digit = seq.substring(chn - 1, chn);
+					chn = "1234567890".indexOf(digit) + 1;
+				} else {
+					chn = 0;
+				}
+			}
+			if (y > 2 * iconSize + separatorY) {
+				chn = 0;
+			}
+			channelUnderCursor = chn;
+		}
+		if (channelUnderCursor > 0)
+			setCursor(handCursor);
+		else
+			setCursor(defaultCursor);
+	}
+
+	public void mouseEntered(MouseEvent e) {
+	}
+
+	public void mousePressed(MouseEvent e) {
+		if (channelUnderCursor > 0) {
+			currentChannel = channelUnderCursor;
+			handlePopupMenu(e);
+			repaint();
+		}
+	}
+
+	public void mouseReleased(MouseEvent e) {
+		mouseMoved(e);
+	}
+
+	public void mouseExited(MouseEvent e) {
+	}
+
+	public void mouseDragged(MouseEvent e) {
+	}
+
+	public void mouseClicked(MouseEvent e) {
+	}
+}
diff --git a/src/ij/plugin/ChannelSplitter.java b/src/ij/plugin/ChannelSplitter.java
new file mode 100644
index 0000000..c6c16ee
--- /dev/null
+++ b/src/ij/plugin/ChannelSplitter.java
@@ -0,0 +1,152 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import ij.plugin.HyperStackReducer;
+import java.awt.*;
+import java.util.Vector;
+
+/** This plugin implements the Image/Color/Split Channels command. */
+public class ChannelSplitter implements PlugIn {
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		if (imp.isComposite()) {
+			int z = imp.getSlice();
+			int t = imp.getFrame();
+			ImagePlus[] channels = split(imp);
+			imp.changes = false;
+			imp.setIgnoreFlush(true);
+			imp.close();
+			for (int i=0; i<channels.length; i++) {
+				channels[i].setIJMenuBar(i==channels.length-1);
+				channels[i].show();
+				if (z>1 || t>1)
+					channels[i].setPosition(1, z, t);
+			}
+		} else if (imp.getType()==ImagePlus.COLOR_RGB)
+			splitRGB(imp);
+		else 
+			IJ.error("Split Channels", "Multichannel image required");
+	}
+	
+	private void splitRGB(ImagePlus imp) {
+		boolean keepSource = IJ.altKeyDown();
+		String title = imp.getTitle();
+		Calibration cal = imp.getCalibration();
+		int pos = imp.getCurrentSlice();
+		ImageStack[] channels = splitRGB(imp.getStack(), keepSource);
+		if (!keepSource)
+			{imp.unlock(); imp.changes=false; imp.close();}
+		ImagePlus rImp = new ImagePlus(title+" (red)", channels[0]);
+		rImp.setCalibration(cal);
+		rImp.setIJMenuBar(false);
+		rImp.show();
+		rImp.setSlice(pos);
+		if (IJ.isMacOSX()) IJ.wait(500);
+		ImagePlus gImp = new ImagePlus(title+" (green)", channels[1]);
+		gImp.setCalibration(cal);
+		gImp.setIJMenuBar(false);
+		gImp.show();
+		gImp.setSlice(pos);
+		if (IJ.isMacOSX()) IJ.wait(500);
+		ImagePlus bImp = new ImagePlus(title+" (blue)", channels[2]);
+		bImp.setCalibration(cal);
+		bImp.show();
+		bImp.setSlice(pos);
+	}
+
+	/** Splits the specified image into separate channels. */
+	public static ImagePlus[] split(ImagePlus imp) {
+		if (imp.getType()==ImagePlus.COLOR_RGB) {
+			ImageStack[] stacks = splitRGB(imp.getStack(), true);
+			ImagePlus[] images = new ImagePlus[3];
+			images[0] = new ImagePlus("red", stacks[0]);
+			images[1] = new ImagePlus("green", stacks[1]);
+			images[2] = new ImagePlus("blue", stacks[2]);
+			return images;
+		}
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int bitDepth = imp.getBitDepth();
+		int size = slices*frames;
+		Vector images = new Vector();
+		HyperStackReducer reducer = new HyperStackReducer(imp);
+		for (int c=1; c<=channels; c++) {
+			ImageStack stack2 = new ImageStack(width, height, size); // create empty stack
+			stack2.setPixels(imp.getProcessor().getPixels(), 1); // can't create ImagePlus will null 1st image
+			ImagePlus imp2 = new ImagePlus("C"+c+"-"+imp.getTitle(), stack2);
+			stack2.setPixels(null, 1);
+			imp.setPosition(c, 1, 1);
+			imp2.setDimensions(1, slices, frames);
+			imp2.setCalibration(imp.getCalibration());
+			reducer.reduce(imp2);
+			if (imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.GRAYSCALE)
+				IJ.run(imp2, "Grays", "");
+			if (imp2.getNDimensions()>3)
+				imp2.setOpenAsHyperStack(true);
+			images.add(imp2);
+		}
+		ImagePlus[] array = new ImagePlus[images.size()];
+		return (ImagePlus[])images.toArray(array);
+	}
+	
+	/** Returns, as an ImageStack, the specified channel, where 'c' must be greater 
+		than zero and less than or equal to the number of channels in the image. */
+	public static ImageStack getChannel(ImagePlus imp, int c) {
+		if (imp.getBitDepth()==24) { // RGB?
+			if (c<1 || c>3)
+				throw new IllegalArgumentException("Channel must be 1,2 or 3");
+			ImageStack[] channels = splitRGB(imp.getStack(), true);
+			return channels[c-1];
+		}
+		if (c<1 || c>imp.getNChannels())
+			throw new IllegalArgumentException("Channel less than 1 or greater than "+imp.getNChannels());
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(imp.getWidth(), imp.getHeight());
+		for (int t=1; t<=imp.getNFrames(); t++) {
+			for (int z=1; z<=imp.getNSlices(); z++) {
+				int n = imp.getStackIndex(c, z, t);
+				stack2.addSlice(stack1.getProcessor(n));
+			}
+		}
+		return stack2;
+	}
+	
+	/** Splits the specified RGB stack into three 8-bit grayscale stacks. 
+		Deletes the source stack if keepSource is false. */
+	public static ImageStack[] splitRGB(ImageStack rgb, boolean keepSource) {
+		 int w = rgb.getWidth();
+		 int h = rgb.getHeight();
+		 ImageStack[] channels = new ImageStack[3];
+		 for (int i=0; i<3; i++)
+		 	channels[i] = new ImageStack(w,h);
+		 byte[] r,g,b;
+		 ColorProcessor cp;
+		 int slice = 1;
+		 int inc = keepSource?1:0;
+		 int n = rgb.getSize();
+		 for (int i=1; i<=n; i++) {
+			 IJ.showStatus(i+"/"+n);
+			 r = new byte[w*h];
+			 g = new byte[w*h];
+			 b = new byte[w*h];
+			 cp = (ColorProcessor)rgb.getProcessor(slice);
+			 slice += inc;
+			 cp.getRGB(r,g,b);
+			 if (!keepSource)
+				rgb.deleteSlice(1);
+			 channels[0].addSlice(null,r);
+			 channels[1].addSlice(null,g);
+			 channels[2].addSlice(null,b);
+			 IJ.showProgress((double)i/n);
+		}
+		return channels;
+	}
+
+}
+
diff --git a/src/ij/plugin/CircularRoiMaker.java b/src/ij/plugin/CircularRoiMaker.java
new file mode 100644
index 0000000..ceff4cb
--- /dev/null
+++ b/src/ij/plugin/CircularRoiMaker.java
@@ -0,0 +1,83 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import java.awt.*;
+
+/** This class implements the Process/FFT/Make Circular Selection command. */
+public class CircularRoiMaker implements PlugIn, DialogListener {
+	private static double saveRadius;
+	private double xcenter, ycenter, radius;
+	private boolean bAbort;
+	private ImagePlus imp;
+	private Calibration cal;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		cal = imp.getCalibration();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		xcenter = width/2;
+		ycenter = height/2;
+		boolean macro = Macro.getOptions()!=null;
+		radius = !macro&&saveRadius!=0.0?saveRadius:width/4;
+		if (radius>width/2)
+			radius = width/2;
+		if (radius>height/2)
+			radius = height/2;
+		showDialog();
+		if (!macro)
+			saveRadius = radius;
+
+	}
+	
+	private void showDialog() {
+		Roi roi = imp.getRoi();
+		drawRoi();
+		GenericDialog gd = new GenericDialog("Circular ROI");
+		gd.addSlider("Radius:", 0, imp.getWidth()/2, radius);
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			if (roi==null)
+				imp.deleteRoi();
+			 else // restore initial ROI when cancelled
+				imp.setRoi(roi);
+		}
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		radius = gd.getNextNumber();
+		if (gd.invalidNumber())
+			return false;
+		drawRoi();
+		return true;
+	}
+	
+	private void drawRoi() {
+		double x = xcenter - radius;
+		double y = ycenter - radius;
+		Roi roi = new OvalRoi(x, y, radius*2.0, radius*2.0);
+		imp.setRoi(roi);
+		showRadius();
+	}
+		
+	private void showRadius() {
+		String units = cal.getUnits();
+		String s = " radius = ";
+		if (imp.getProperty("FHT")!=null) {
+			int width = imp.getWidth();
+			if (radius<1.0)
+				s += "Infinity/c";
+			else if (cal.scaled()) 
+				s += IJ.d2s((width/radius)*cal.pixelWidth,2) + " " + units + "/c";
+		   else
+				s += IJ.d2s(width/radius,2) + " p/c";
+		} else {
+			int digits = cal.pixelWidth==1.0?0:2;
+			s +=  IJ.d2s(radius*cal.pixelWidth,digits)+" "+units;
+		}
+		IJ.showStatus(s);
+	}
+
+}
diff --git a/src/ij/plugin/ClassChecker.java b/src/ij/plugin/ClassChecker.java
new file mode 100644
index 0000000..9ce3781
--- /dev/null
+++ b/src/ij/plugin/ClassChecker.java
@@ -0,0 +1,107 @@
+package  ij.plugin;
+import ij.*;
+import ij.util.*;
+import java.io.*;
+import java.util.*;
+
+/** Checks for duplicate class and JAR files in the plugins folders and deletes older duplicates. */
+public class ClassChecker implements PlugIn {
+	String[] paths;
+	String[] names;
+
+	public void run(String arg) {
+		//long start = System.currentTimeMillis();
+		deleteDuplicates();
+		//IJ.log("Time: "+(System.currentTimeMillis()-start));
+	}
+	
+	void deleteDuplicates() {
+		getPathsAndNames();
+		if (paths==null || paths.length<2) return;
+		String[] sortedNames = new String[names.length];
+		for (int i=0; i<names.length; i++)
+			sortedNames[i] = names[i];
+		StringSorter.sort(sortedNames);
+		for (int i=0; i<sortedNames.length-1; i++) {
+			if (sortedNames[i].equals(sortedNames[i+1]))
+				delete(sortedNames[i]);
+		}
+	}
+	
+	void delete(String name) {
+		String path1=null, path2=null;
+		File file1, file2;
+		long date1, date2;
+		for (int i=0; i<names.length; i++) {
+			if (path1==null && names[i].equals(name)) {
+				path1 = paths[i] +names[i];
+//IJ.log("path1: "+i+"   "+name+"   "+path1+"   "+paths[i]+"   "+names[i]);
+			} else if (path2==null && names[i].equals(name)) {
+				path2 = paths[i] +names[i];
+//IJ.log("path2: "+i+"   "+name+"   "+path2+"   "+paths[i]+"   "+names[i]);
+			}
+			if (path1!=null && path2!=null) {
+				file1 = new File(path1);
+				file2 = new File(path2);
+				if (file1==null || file2==null) return;
+				date1 = file1.lastModified();
+				date2 = file2.lastModified();
+				if (date1<date2) {
+					write(path1);
+					file1.delete();
+				} else {
+					write(path2);
+					file2.delete();
+				}
+				break;
+			}
+		}
+	}
+
+	void write(String path) {
+		IJ.log("Deleting duplicate plugin: "+path);
+	}
+
+	/** Gets lists of all the class and jar files in the plugins
+	     folder and subfolders of the plugins folder. */
+	void getPathsAndNames() {
+		String path = Menus.getPlugInsPath();
+		if (path==null) return;
+		File f = new File(path);
+		String[] list = f.list();
+		if (list==null) return;
+		Vector v1 = new Vector(1000);
+		Vector v2 = new Vector(1000);
+		for (int i=0; i<list.length; i++) {
+			String name = list[i];
+			if (name.endsWith(".class") || name.endsWith(".jar")) {
+				v1.addElement(path);
+				v2.addElement(name);
+			} else
+				getSubdirectoryFiles(path, name, v1, v2);
+		}
+		paths = new String[v1.size()];
+		v1.copyInto((String[])paths);
+		names = new String[v2.size()];
+		v2.copyInto((String[])names);
+	}
+
+	/** Looks for class and jar files in a subfolders of the plugins folder. */
+	void getSubdirectoryFiles(String path, String dir, Vector v1, Vector v2) {
+		if (dir.endsWith(".java")) return;
+		File f = new File(path, dir);
+		if (!f.isDirectory()) return;
+		String[] list = f.list();
+		if (list==null) return;
+		dir += Prefs.separator;
+		for (int i=0; i<list.length; i++) {
+			String name = list[i];
+			if (name.endsWith(".class") || name.endsWith(".jar")) {
+				v1.addElement(path+dir);
+				v2.addElement(name);
+			}
+		}
+	}
+
+}
+
diff --git a/src/ij/plugin/Clipboard.java b/src/ij/plugin/Clipboard.java
new file mode 100644
index 0000000..d7dd3f1
--- /dev/null
+++ b/src/ij/plugin/Clipboard.java
@@ -0,0 +1,198 @@
+package ij.plugin; 
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.datatransfer.*;
+import java.awt.image.*;
+import java.io.*;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.frame.Editor;
+import ij.plugin.frame.Recorder;
+import ij.text.TextWindow;
+import ij.util.Tools;
+	
+/**	Copies/pastes images to/from the system clipboard. */
+public class Clipboard implements PlugIn, Transferable {
+	static java.awt.datatransfer.Clipboard clipboard;
+	private ImagePlus gImp;
+	
+	public void run(String arg) {
+		if (IJ.altKeyDown()) {
+			if (arg.equals("copy"))
+				arg = "scopy";
+			else if (arg.equals("paste"))
+				arg = "spaste";
+		}
+  		if (arg.equals("copy"))
+			copy(false);
+  		else if (arg.equals("paste"))
+			paste();
+  		else if (arg.equals("cut"))
+			copy(true);
+  		else if (arg.equals("scopy"))
+			copyToSystem();
+		else if (arg.equals("showsys"))
+			showSystemClipboard();
+		else if (arg.equals("show"))
+			showInternalClipboard();
+	}
+	
+	/** Copies the contents of the specified image, or selection, to the system clicpboard. */
+	public static void copyToSystem(ImagePlus imp) {
+		Clipboard cplugin = new Clipboard();
+		cplugin.gImp = imp;
+		cplugin.setup();
+		try {
+			cplugin.clipboard.setContents(cplugin, null);
+		} catch (Throwable t) {}
+	}
+	
+	void copy(boolean cut) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+	 		imp.copy(cut);
+	 		if (cut)
+	 			imp.changes = true;
+	 	} else
+	 		IJ.noImage();
+	 	if (Recorder.scriptMode()) {
+	 		if (cut)
+				Recorder.recordCall("imp.cut();");
+			else
+				Recorder.recordCall("imp.copy();");
+	 	}
+	}
+	
+	private ImagePlus flatten(ImagePlus imp) {
+		if (imp.getOverlay()!=null && !imp.getHideOverlay() && !imp.isHyperStack()) {
+			ImagePlus imp2 = imp;
+			Roi roi = imp.getRoi();
+			if (imp.getStackSize()>1) {
+				imp.deleteRoi();
+				int slice = imp.getCurrentSlice();
+				imp = new Duplicator().run(imp, slice, slice);
+			}
+			imp = imp.flatten();
+			imp.setRoi(roi);
+			imp2.setRoi(roi);
+		}
+		return imp;
+	}
+	
+	void paste() {
+		if (ImagePlus.getClipboard()==null)
+			showSystemClipboard();
+		else {
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) {
+				imp.paste();
+				if (Recorder.scriptMode())
+					Recorder.recordCall("imp.paste();");
+			} else
+				showInternalClipboard	();
+		}
+	}
+
+	void setup() {
+		if (clipboard==null)
+			clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+	}
+	
+	void copyToSystem() {
+		this.gImp = WindowManager.getCurrentImage();
+		setup();
+		try {
+			clipboard.setContents(this, null);
+		} catch (Throwable t) {}
+	 	if (Recorder.scriptMode())
+			Recorder.recordCall("imp.copyToSystem();");
+	}
+	
+	void showSystemClipboard() {
+		setup();
+		IJ.showStatus("Opening system clipboard...");
+		try {
+			Transferable transferable = clipboard.getContents(null);
+			boolean imageSupported = transferable.isDataFlavorSupported(DataFlavor.imageFlavor);
+			boolean textSupported = transferable.isDataFlavorSupported(DataFlavor.stringFlavor);
+			if (imageSupported) {
+				Image img = (Image)transferable.getTransferData(DataFlavor.imageFlavor);
+				if (img==null) {
+					IJ.error("Unable to convert image on system clipboard");
+					IJ.showStatus("");
+					return;
+				}
+				int width = img.getWidth(null);
+				int height = img.getHeight(null);
+				BufferedImage   bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+				Graphics g = bi.createGraphics();
+				g.drawImage(img, 0, 0, null);
+				g.dispose();
+				WindowManager.checkForDuplicateName = true;
+				new ImagePlus("Clipboard", bi).show();
+			} else if (textSupported) {
+				String text = (String)transferable.getTransferData(DataFlavor.stringFlavor);
+				if (IJ.isMacintosh())
+					text = Tools.fixNewLines(text);
+				Editor ed = new Editor();
+				ed.setSize(600, 300);
+				ed.create("Clipboard", text);
+				IJ.showStatus("");
+			} else
+				IJ.error("Unable to find an image on the system clipboard");
+		} catch (Throwable e) {
+			IJ.handleException(e);
+		}
+	}
+	
+	public DataFlavor[] getTransferDataFlavors() {
+		return new DataFlavor[] { DataFlavor.imageFlavor };
+	}
+
+	public boolean isDataFlavorSupported(DataFlavor flavor) {
+		return DataFlavor.imageFlavor.equals(flavor);
+	}
+
+	public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException {
+		if (!isDataFlavorSupported(flavor))
+			throw new UnsupportedFlavorException(flavor);
+		ImagePlus imp = gImp!=null?gImp:WindowManager.getCurrentImage();
+		if (imp==null)
+			return null;
+		Roi roi = imp.getRoi();
+		if (roi!=null && !roi.isLine()) {
+			Rectangle bounds = roi.getBounds();
+			if (!(bounds.x==0&&bounds.y==0&&bounds.width==imp.getWidth()&&bounds.height==imp.getHeight()))
+				imp = imp.crop();
+		}
+		boolean overlay = imp.getOverlay()!=null && !imp.getHideOverlay();
+		if (overlay && !imp.tempOverlay())
+			imp = imp.flatten(); 
+		return imp.getImage();
+	}
+	
+	void showInternalClipboard() {
+		ImagePlus clipboard = ImagePlus.getClipboard();
+		if (clipboard!=null) {
+			ImageProcessor ip = clipboard.getProcessor();
+			ImagePlus imp2 = new ImagePlus("Clipboard", ip.duplicate());
+			Roi roi = clipboard.getRoi();
+			imp2.deleteRoi();
+			if (roi!=null && roi.isArea() && roi.getType()!=Roi.RECTANGLE) {
+				roi = (Roi)roi.clone();
+				roi.setLocation(0, 0);
+				imp2.setRoi(roi);
+				IJ.run(imp2, "Clear Outside", null);
+				imp2.deleteRoi();
+			}
+			WindowManager.checkForDuplicateName = true;          
+			imp2.show();
+		} else
+			IJ.error("The internal clipboard is empty.");
+	}
+
+}
+
+
+
diff --git a/src/ij/plugin/Colors.java b/src/ij/plugin/Colors.java
new file mode 100644
index 0000000..3605817
--- /dev/null
+++ b/src/ij/plugin/Colors.java
@@ -0,0 +1,276 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.io.*;
+import ij.plugin.filter.*;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+
+/** This plugin implements most of the Edit/Options/Colors command. */
+public class Colors implements PlugIn, ItemListener {
+	public static final String[] colors = {"red","green","blue","magenta","cyan","yellow","orange","black","white","gray","lightgray","darkgray","pink"};
+	private static final String[] colors2 = {"Red","Green","Blue","Magenta","Cyan","Yellow","Orange","Black","White","Gray","lightGray","darkGray","Pink"};
+	private Choice fchoice, bchoice, schoice;
+	private Color fc2, bc2, sc2;
+
+ 	public void run(String arg) {
+		showDialog();
+	}
+
+	/** The Edit>Options>Colors dialog */
+	void showDialog() {
+		Color fc =Toolbar.getForegroundColor();
+		String fname = getColorName(fc, "black");
+		Color bc =Toolbar.getBackgroundColor();
+		String bname = getColorName(bc, "white");
+		Color sc =Roi.getColor();
+		String sname = getColorName(sc, "yellow");
+		GenericDialog gd = new GenericDialog("Colors");
+		gd.addChoice("Foreground:", colors, fname);
+		gd.addChoice("Background:", colors, bname);
+		gd.addChoice("Selection:", colors, sname);
+		Vector choices = gd.getChoices();
+		if (choices!=null) {
+			fchoice = (Choice)choices.elementAt(0);
+			bchoice = (Choice)choices.elementAt(1);
+			schoice = (Choice)choices.elementAt(2);
+			fchoice.addItemListener(this);
+			bchoice.addItemListener(this);
+			schoice.addItemListener(this);
+		}
+
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			if (fc2!=fc) Toolbar.setForegroundColor(fc);
+			if (bc2!=bc) Toolbar.setBackgroundColor(bc);
+			if (sc2!=sc) {
+				Roi.setColor(sc);
+				ImagePlus imp = WindowManager.getCurrentImage();
+				if (imp!=null && imp.getRoi()!=null) imp.draw();
+			}
+			return;
+		}
+		fname = gd.getNextChoice();
+		bname = gd.getNextChoice();
+		sname = gd.getNextChoice();
+		fc2 = getColor(fname, Color.black);
+		bc2 = getColor(bname, Color.white);
+		sc2 = getColor(sname, Color.yellow);
+		if (fc2!=fc) Toolbar.setForegroundColor(fc2);
+		if (bc2!=bc) Toolbar.setBackgroundColor(bc2);
+		if (sc2!=sc) {
+			Roi.setColor(sc2);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) imp.draw();
+			Toolbar tb = Toolbar.getInstance();
+			if (tb!=null) tb.repaint();
+		}
+	}
+
+	/** For named colors, returns the name, or 'defaultName' if not a named color.
+	 *  If 'defaultName' is non-null and starts with an uppercase character,
+	 *  the returned name is capitalized (first character uppercase).
+	 *  Use colorToString or colorToString2 to get a String representation (hexadecimal)
+	 *  also for unnamed colors.*/
+	public static String getColorName(Color c, String defaultName) {
+		if (c==null) return defaultName;
+		boolean useCapitalizedName = defaultName!=null && defaultName.length()>0 && Character.isUpperCase(defaultName.charAt(0));
+		return getColorName(c, defaultName, useCapitalizedName);
+	}
+
+	/** For named colors, returns the name, or 'defaultName' if not a named color.
+	 *  'color' must not be null. */
+	private static String getColorName(Color c, String defaultName, boolean useCapitalizedName) {
+		String[] colorNames = useCapitalizedName ? colors2 : colors;
+		if (c.equals(Color.red))            return colorNames[0];
+		else if (c.equals(Color.green))     return colorNames[1];
+		else if (c.equals(Color.blue))      return colorNames[2];
+		else if (c.equals(Color.magenta))   return colorNames[3];
+		else if (c.equals(Color.cyan))      return colorNames[4];
+		else if (c.equals(Color.yellow))    return colorNames[5];
+		else if (c.equals(Color.orange))    return colorNames[6];
+		else if (c.equals(Color.black))     return colorNames[7];
+		else if (c.equals(Color.white))     return colorNames[8];
+		else if (c.equals(Color.gray))      return colorNames[9];
+		else if (c.equals(Color.lightGray)) return colorNames[10];
+		else if (c.equals(Color.darkGray))  return colorNames[11];
+		else if (c.equals(Color.pink))      return colorNames[12];
+		return defaultName;
+	}
+
+	/** For named colors, converts the name String to the corresponding color.
+	 *  Returns 'defaultColor' if the color has no name.
+	 *  Use 'decode' to also decode hex color names like "#ffff00" */
+	public static Color getColor(String name, Color defaultColor) {
+		if (name==null || name.length()<2)
+			return defaultColor;
+		name = name.toLowerCase(Locale.US);
+		Color c = defaultColor;
+		if (name.contains(colors[7])) c = Color.black;
+		else if (name.contains(colors[8]))  c = Color.white;
+		else if (name.contains(colors[0]))  c = Color.red;
+		else if (name.contains(colors[2]))  c = Color.blue;
+		else if (name.contains(colors[5]))  c = Color.yellow;
+		else if (name.contains(colors[1]))  c = Color.green;
+		else if (name.contains(colors[3]))  c = Color.magenta;
+		else if (name.contains(colors[4]))  c = Color.cyan;
+		else if (name.contains(colors[6]))  c = Color.orange;
+		else if (name.contains(colors[12])) c = Color.pink;
+		else if (name.contains(colors[9]) || name.contains("grey")) { //gray or grey
+			if (name.contains("light"))     c = Color.lightGray;
+			else if (name.contains("dark")) c = Color.darkGray;
+			else                            c = Color.gray;
+		}
+		return c;
+	}
+
+	/** Converts a String with the color name or the hexadecimal representation
+	 *  of a color with 6 or 8 hex digits to a Color.
+	 *  With 8 hex digits, the first two digits are the alpha.
+	 *  With 6 hex digits, the color is opaque (alpha = hex ff).
+	 *  A hex String may be preceded by '#' such as "#80ff00".
+	 *  When the string does not include a valid color name or hex code,
+	 *  returns Color.GRAY. */
+	public static Color decode(String hexColor) {
+		return decode(hexColor, Color.gray);
+	}
+
+	/** Converts a String with the color name or the hexadecimal representation
+	 *  of a color with 6 or 8 hex digits to a Color.
+	 *  With 8 hex digits, the first two digits are the alpha.
+	 *  With 6 hex digits, the color is opaque (alpha = hex ff).
+	 *  A hex String may be preceded by "#" such as "#80ff00" or "0x".
+	 *  When the string does not include a valid color name or hex code,
+	 *  returns 'defaultColor'. */
+	public static Color decode(String hexColor, Color defaultColor) {
+		if (hexColor==null || hexColor.length()<2)
+			return defaultColor;
+		Color color = getColor(hexColor, null);  //for named colors
+		if (color==null) {
+			if (hexColor.startsWith("#"))
+				hexColor = hexColor.substring(1);
+			else if (hexColor.startsWith("0x"))
+				hexColor = hexColor.substring(2);
+			int len = hexColor.length();
+			if (!(len==6 || len==8))
+				return defaultColor;
+			boolean hasAlpha = len==8;
+			try {
+				int rgba = (int)Long.parseLong(hexColor, 16);
+				color = new Color(rgba, hasAlpha);
+			} catch (NumberFormatException e) {
+				return defaultColor;
+			}
+		}
+		return color;
+	}
+
+	public static int getRed(String hexColor) {
+		return decode(hexColor, Color.black).getRed();
+	}
+
+	public static int getGreen(String hexColor) {
+		return decode(hexColor, Color.black).getGreen();
+	}
+
+	public static int getBlue(String hexColor) {
+		return decode(hexColor, Color.black).getBlue();
+	}
+
+	/** Converts a hex color (e.g., "ffff00") into "red", "green", "yellow", etc.
+	 *  Returns null if the hex color does not have a name.
+	 *  Unused in ImageJ, for compatibility only. */
+	public static String hexToColor(String hex) {
+		if (hex==null) return null;
+		Color color = decode(hex, null);
+		if (color==null) return null;
+		return getColorName(color, null, false);
+	}
+
+	/** Converts a hex color (e.g., "ffff00" or "#ffff00") into a color name
+	 *  "Red", "Green", "Yellow", etc.
+	 *  Returns null if the hex color does not have a name.
+	 *  Unused in ImageJ, for compatibility only. */
+	public static String hexToColor2(String hex) {
+		if (hex==null) return null;
+		Color color = decode(hex, null);
+		if (color==null) return null;
+		return getColorName(color, null, true);
+	}
+
+	/** Converts a Color into a lowercase string ("red", "green", "#aa55ff", etc.).
+	 *  If <code>color</code> is <code>null</code>, returns the String "none". */
+	public static String colorToString(Color color) {
+		if (color == null) return "none";
+		String str = getColorName(color, null, false);
+		if (str == null)
+			str = "#"+getHexString(color);
+		return str;
+	}
+
+	/** Converts a Color into a string ("Red", "Green", #aa55ff, etc.).
+	 *  If <code>color</code> is <code>null</code>, returns the String "None". */
+	public static String colorToString2(Color color) {
+		if (color == null) return "None";
+		String str = getColorName(color, null, true);
+		if (str == null)
+			str = "#"+getHexString(color);
+		return str;
+	}
+
+	/** Returns the 6-digit hex string such as "aa55ff" for opaque colors or
+	 *  or 8-digit like "80aa55ff" for other colors (the first two hex digits are alpha).
+	 *  'color' must not be null. */
+	private static String getHexString(Color color) {
+		int rgb = color.getRGB();
+		boolean isOpaque = (rgb & 0xff000000) == 0xff000000;
+		if (isOpaque)
+			rgb &= 0x00ffffff;  //don't show alpha for opaque colors
+		String format = isOpaque? "%06x" : "%08x";
+		return String.format(format, rgb);
+	}
+
+	/** Returns an opaque color with the specified red, green, and blue values.
+	 *  Values is outside the 0-255 range are replaced by the nearest
+	 *  valid number (0 or 255) */
+	public static Color toColor(int red, int green, int blue) {
+	    if (red<0) red=0; if (green<0) green=0; if (blue<0) blue=0; 
+	    if (red>255) red=255; if (green>255) green=255; if (blue>255) blue=255;  
+		return  new Color(red, green, blue);
+	}
+
+	/** Callback listener for Choice modifications in the dialog */
+	public void itemStateChanged(ItemEvent e) {
+		Choice choice = (Choice)e.getSource();
+		String item = choice.getSelectedItem();
+		Color color = getColor(item, Color.black);
+		if (choice==fchoice)
+			Toolbar.setForegroundColor(color);
+		else if (choice==bchoice)
+			Toolbar.setBackgroundColor(color);
+		else if (choice==schoice) {
+			Roi.setColor(color);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null && imp.getRoi()!=null) imp.draw();
+			Toolbar.getInstance().repaint();
+		}
+	}
+
+	/** Returns an array of the color Strings in the argument(s) and the 13
+	 *  predefined color names "Red", "Green", ... "Pink".
+	 *  The Strings arguments must be either "None" or hex codes starting with "#".
+	 *  Any null arguments are ignored. */
+	public static String[] getColors(String... moreColors) {
+		ArrayList names = new ArrayList();
+		for (String arg: moreColors) {
+			if (arg!=null && arg.length()>0 && (!Character.isLetter(arg.charAt(0))||arg.equals("None")))
+				names.add(arg);
+		}
+		for (String arg: colors2)
+			names.add(arg);
+		return (String[])names.toArray(new String[names.size()]);
+	}
+}
diff --git a/src/ij/plugin/CommandFinder.java b/src/ij/plugin/CommandFinder.java
new file mode 100644
index 0000000..26fb513
--- /dev/null
+++ b/src/ij/plugin/CommandFinder.java
@@ -0,0 +1,705 @@
+/** This plugin implements the Plugins/Utilities/Find Commands 
+    command. It provides an easy user interface to finding commands 
+    you might know the name of without having to go through
+    all the menus.  If you type a part of a command name, the box
+    below will only show commands that match that substring (case
+    insensitively).  If only a single command matches then that
+    command can be run by hitting Enter.  If multiple commands match,
+    they can be selected by selecting with the mouse and clicking
+    "Run"; alternatively hitting the up or down arrows will move the
+    keyboard focus to the list and the selected command can be run
+    with Enter. When the list has focus, it is also possible to use
+    keyboard "scrolling": E.g., pressing "H" will select the first
+    command starting with the char "H". Pressing "H" again will select
+    the next row starting with the char "H", etc., looping between all
+    "H" starting commands. Double-clicking on a command in the list
+    should also run the appropriate command.
+
+    @author Mark Longair <mark-imagej@longair.net>
+    @author Johannes Schindelin <johannes.schindelin@gmx.de>
+    @author Curtis Rueden <ctrueden@wisc.edu>
+    @author Tiago Ferreira <tiago.ferreira@mail.mcgill.ca>
+
+ */
+
+package ij.plugin;
+
+import ij.*;
+import ij.text.*;
+import ij.plugin.frame.Editor;
+import ij.process.ImageProcessor;
+import ij.gui.GUI;
+import ij.gui.HTMLDialog;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.File;
+import javax.swing.*;
+import javax.swing.table.*;
+import javax.swing.event.*;
+import javax.swing.event.DocumentEvent;
+
+public class CommandFinder implements PlugIn, ActionListener, WindowListener, KeyListener, ItemListener, MouseListener {
+
+	private static final int TABLE_WIDTH = 640;
+	private static final int TABLE_ROWS = 18;
+	private int multiClickInterval;
+	private long lastClickTime;
+	private static JFrame frame;
+	private JTextField prompt;
+	private JScrollPane scrollPane;
+	private JButton runButton, sourceButton, closeButton, commandsButton, helpButton;
+	private JCheckBox closeCheckBox;
+	private JCheckBox lutCheckBox;
+	private Hashtable commandsHash;
+	private String[] commands;
+	private static boolean closeWhenRunning = Prefs.get("command-finder.close", false);
+	private static boolean applyLUT; 
+	private JTable table;
+	private TableModel tableModel;
+	private int lastClickedRow;
+
+	public CommandFinder() {
+		Toolkit toolkit = Toolkit.getDefaultToolkit();
+		Integer interval = (Integer) toolkit.getDesktopProperty("awt.multiClickInterval");
+		if (interval == null)
+			// Hopefully 300ms is a sensible default when the property
+			// is not available.
+			multiClickInterval = 300;
+		else
+			multiClickInterval = interval.intValue();
+	}
+
+	class CommandAction {
+		CommandAction(String classCommand, MenuItem menuItem, String menuLocation) {
+			this.classCommand = classCommand;
+			this.menuItem = menuItem;
+			this.menuLocation = menuLocation;
+		}
+
+		String classCommand;
+		MenuItem menuItem;
+		String menuLocation;
+
+		public String toString() {
+			return "classCommand: " + classCommand + ", menuItem: " + menuItem + ", menuLocation: " + menuLocation;
+		}
+	}
+
+	protected String[] makeRow(String command, CommandAction ca) {
+		String[] result = new String[tableModel.getColumnCount()];
+		result[0] = command;
+		if (ca.menuLocation != null)
+			result[1] = ca.menuLocation;
+		if (ca.classCommand != null)
+			result[2] = ca.classCommand;
+		String jarFile = Menus.getJarFileForMenuEntry(command);
+		if (jarFile != null)
+			result[3] = jarFile;
+		return result;
+	}
+
+	protected void populateList(String matchingSubstring) {
+		String substring = matchingSubstring.toLowerCase();
+		ArrayList list = new ArrayList();
+		int count = 0;
+		for (int i = 0; i < commands.length; ++i) {
+			String commandName = commands[i];
+			String command = commandName.toLowerCase();
+			CommandAction ca = (CommandAction) commandsHash.get(commandName);
+			String menuPath = ca.menuLocation;
+			if (menuPath == null)
+				menuPath = "";
+			menuPath = menuPath.toLowerCase();
+			if (command.indexOf(substring) >= 0 || menuPath.indexOf(substring) >= 0) {
+				String[] row = makeRow(commandName, ca);
+				list.add(row);
+			}
+		}
+		tableModel.setData(list);
+		prompt.requestFocus();
+	}
+
+	public void actionPerformed(ActionEvent ae) {
+		Object source = ae.getSource();
+		if (source == runButton) {
+			int row = table.getSelectedRow();
+			if (row < 0) {
+				error("Please select a command to run");
+				return;
+			}
+			runCommand(tableModel.getCommand(row));
+		} else if (source == sourceButton) {
+			int row = table.getSelectedRow();
+			if (row < 0) {
+				error("Please select a command");
+				return;
+			}
+			showSource(tableModel.getCommand(row));
+		} else if (source == closeButton) {
+			closeWindow();
+		} else if (source == commandsButton) {
+			IJ.doCommand("Commands...");
+		} else if (source == helpButton) {
+			String text = "<html>Shortcuts:<br>" + "&emsp;&uarr; &darr;&ensp; Select items<br>"
+					+ "&emsp;&crarr;&emsp; Open item<br>" + "&ensp;A-Z&ensp; Alphabetic scroll<br>"
+					+ "&emsp;&#9003;&emsp;Activate search field</html>";
+			new HTMLDialog("", text);
+		}
+	}
+
+	public void itemStateChanged(ItemEvent ie) {
+		populateList(prompt.getText());
+		applyLUT = lutCheckBox.isSelected();
+		if (applyLUT)
+			prompt.setText("Lookup Tables");
+	}
+
+	public void mouseClicked(MouseEvent e) {
+		long now = System.currentTimeMillis();
+		int row = table.getSelectedRow();
+		// Is this fast enough to be a double-click?
+		long thisClickInterval = now - lastClickTime;
+		if (thisClickInterval < multiClickInterval) {
+			if (row >= 0 && lastClickedRow >= 0 && row == lastClickedRow)
+				runCommand(tableModel.getCommand(row));
+		}
+		lastClickTime = now;
+		lastClickedRow = row;
+		if (lutCheckBox.isSelected())
+			previewLUT();
+
+	}
+
+	public void mousePressed(MouseEvent e) {
+	}
+
+	public void mouseReleased(MouseEvent e) {
+	}
+
+	public void mouseEntered(MouseEvent e) {
+	}
+
+	public void mouseExited(MouseEvent e) {
+	}
+
+	void showSource(String cmd) {
+		if (showMacro(cmd))
+			return;
+		Hashtable table = Menus.getCommands();
+		String className = (String) table.get(cmd);
+		if (IJ.debugMode)
+			IJ.log("showSource: " + cmd + "   " + className);
+		if (className == null) {
+			error("No source associated with this command:\n  " + cmd);
+			return;
+		}
+		int mstart = className.indexOf("ij.plugin.Macro_Runner(\"");
+		if (mstart >= 0) { // macro or script
+			int mend = className.indexOf("\")");
+			if (mend == -1)
+				return;
+			String macro = className.substring(mstart + 24, mend);
+			IJ.open(IJ.getDirectory("plugins") + macro);
+			return;
+		}
+		if (className.endsWith("\")")) {
+			int openParen = className.lastIndexOf("(\"");
+			if (openParen > 0)
+				className = className.substring(0, openParen);
+		}
+		if (className.startsWith("ij.")) {
+			className = className.replaceAll("\\.", "/");
+			IJ.runPlugIn("ij.plugin.BrowserLauncher", IJ.URL + "/source/" + className + ".java");
+			return;
+		}
+		className = IJ.getDirectory("plugins") + className.replaceAll("\\.", "/");
+		String path = className + ".java";
+		File f = new File(path);
+		if (f.exists()) {
+			IJ.open(path);
+			return;
+		}
+		error("Unable to display source for this plugin:\n  " + className);
+	}
+
+	private boolean showMacro(String cmd) {
+		String name = null;
+		if (cmd.equals("Display LUTs"))
+			name = "ShowAllLuts.txt";
+		else if (cmd.equals("Search..."))
+			name = "Search.txt";
+		if (name == null)
+			return false;
+		String code = BatchProcessor.openMacroFromJar(name);
+		if (code != null) {
+			Editor ed = new Editor();
+			ed.setSize(700, 600);
+			ed.create(name, code);
+			return true;
+		}
+		return false;
+	}
+
+	private void error(String msg) {
+		IJ.error("Command Finder", msg);
+	}
+
+	protected void runCommand(String command) {
+		IJ.showStatus("Running command " + command);
+		IJ.doCommand(command);
+		closeWhenRunning = closeCheckBox.isSelected();
+		if (closeWhenRunning)
+			closeWindow();
+	}
+
+	public void keyPressed(KeyEvent ke) {
+		int key = ke.getKeyCode();
+		int flags = ke.getModifiers();
+		int items = tableModel.getRowCount();
+		Object source = ke.getSource();
+		boolean meta = ((flags & KeyEvent.META_MASK) != 0) || ((flags & KeyEvent.CTRL_MASK) != 0);
+		if (key == KeyEvent.VK_ESCAPE || (key == KeyEvent.VK_W && meta)) {
+			closeWindow();
+		} else if (source == prompt) {
+			/*
+			 * If you hit enter in the text field, and there's only one command
+			 * that matches, run that:
+			 */
+			if (key == KeyEvent.VK_ENTER) {
+				if (1 == items)
+					runCommand(tableModel.getCommand(0));
+			}
+			/*
+			 * If you hit the up or down arrows in the text field, move the
+			 * focus to the table and select the row at the bottom or top.
+			 */
+			int index = -1;
+			if (key == KeyEvent.VK_UP) {
+				index = table.getSelectedRow() - 1;
+				if (index < 0)
+					index = items - 1;
+			} else if (key == KeyEvent.VK_DOWN) {
+				index = table.getSelectedRow() + 1;
+				if (index >= items)
+					index = Math.min(items - 1, 0);
+			}
+			if (index >= 0) {
+				table.requestFocus();
+				// completions.ensureIndexIsVisible(index);
+				table.setRowSelectionInterval(index, index);
+			}
+		} else if (key == KeyEvent.VK_BACK_SPACE || key == KeyEvent.VK_DELETE) {
+			/*
+			 * If someone presses backspace or delete they probably want to
+			 * remove the last letter from the search string, so switch the
+			 * focus back to the prompt:
+			 */
+			prompt.requestFocus();
+		} else if (source == table) {
+			/*
+			 * If you hit enter with the focus in the table, run the selected
+			 * command
+			 */
+			if (key == KeyEvent.VK_ENTER) {
+				ke.consume();
+				int row = table.getSelectedRow();
+				if (row >= 0)
+					runCommand(tableModel.getCommand(row));
+				/* Loop through the list using the arrow keys */
+			} else if (key == KeyEvent.VK_UP) {
+				if (table.getSelectedRow() == 0)
+					table.setRowSelectionInterval(tableModel.getRowCount() - 1, tableModel.getRowCount() - 1);
+			} else if (key == KeyEvent.VK_DOWN) {
+				if (table.getSelectedRow() == tableModel.getRowCount() - 1)
+					table.setRowSelectionInterval(0, 0);
+			}
+		}
+	}
+
+	public void keyReleased(KeyEvent ke) {
+		if (lutCheckBox.isSelected())
+			previewLUT();
+	}
+
+	public void previewLUT() {
+		int row = table.getSelectedRow();
+		if (row >= 0) {
+			String cmd = tableModel.getCommand(row);
+			String mPath = (String) tableModel.getValueAt(row, 1);
+			String cName = (String) tableModel.getValueAt(row, 2);
+			if ((mPath.indexOf("Lookup Table") > 0) && ((null == cName) || (cName.indexOf("LutLoader") > 0))) {
+				ImagePlus imp = WindowManager.getCurrentImage();
+				if (null == imp) {
+					imp = IJ.createImage("LUT Preview", "8-bit ramp", 256, 32, 1);
+					imp.show();
+				}
+				if (imp.getBitDepth() != 24) {
+					if (imp.isComposite())
+						((CompositeImage)imp).setChannelColorModel(LutLoader.getLut(cmd));
+					else {
+						ImageProcessor ip = imp.getProcessor();
+						ip.setColorModel(LutLoader.getLut(cmd));
+						IJ.showStatus(cmd);
+					}
+					imp.updateAndDraw();
+				}
+			}
+		}
+	}
+
+	public void keyTyped(KeyEvent ke) {
+	}
+
+	class PromptDocumentListener implements DocumentListener {
+		public void insertUpdate(DocumentEvent e) {
+			populateList(prompt.getText());
+		}
+
+		public void removeUpdate(DocumentEvent e) {
+			populateList(prompt.getText());
+		}
+
+		public void changedUpdate(DocumentEvent e) {
+			populateList(prompt.getText());
+		}
+	}
+
+	/*
+	 * This function recurses down through a menu, adding to commandsHash the
+	 * location and MenuItem of any items it finds that aren't submenus.
+	 */
+
+	public void parseMenu(String path, Menu menu) {
+		int n = menu.getItemCount();
+		for (int i = 0; i < n; ++i) {
+			MenuItem m = menu.getItem(i);
+			String label = m.getActionCommand();
+			if (m instanceof Menu) {
+				Menu subMenu = (Menu) m;
+				parseMenu(path + ">" + label, subMenu);
+			} else {
+				String trimmedLabel = label.trim();
+				if (trimmedLabel.length() == 0 || trimmedLabel.equals("-"))
+					continue;
+				CommandAction ca = (CommandAction) commandsHash.get(label);
+				if (ca == null)
+					commandsHash.put(label, new CommandAction(null, m, path));
+				else {
+					ca.menuItem = m;
+					ca.menuLocation = path;
+				}
+				CommandAction caAfter = (CommandAction) commandsHash.get(label);
+			}
+		}
+	}
+
+	/*
+	 * Finds all the top level menus from the menu bar and recurses down through
+	 * each.
+	 */
+
+	public void findAllMenuItems() {
+		MenuBar menuBar = Menus.getMenuBar();
+		int topLevelMenus = menuBar.getMenuCount();
+		for (int i = 0; i < topLevelMenus; ++i) {
+			Menu topLevelMenu = menuBar.getMenu(i);
+			parseMenu(topLevelMenu.getLabel(), topLevelMenu);
+		}
+	}
+
+	/**
+	 * Displays the Command Finder dialog. If a Command Finder window is already
+	 * being displayed and <tt>initialSearch</tt> contains a valid query, it
+	 * will be closed and a new one displaying the new search will be rebuilt at
+	 * the same screen location.
+	 *
+	 * @param initialSearch
+	 *            The search string that populates Command Finder's search
+	 *            field. It is ignored if contains an invalid query (ie, if it
+	 *            is either <tt>null</tt> or <tt>empty</tt>).
+	 */
+	public void run(String initialSearch) {
+		if (frame != null) {
+			if (initialSearch != null && !initialSearch.isEmpty()) {
+				frame.dispose(); // Rebuild dialog with new search string
+			} else {
+				WindowManager.toFront(frame);
+				return;
+			}
+		}
+		commandsHash = new Hashtable();
+
+		/*
+		 * Find the "normal" commands; those which are registered plugins:
+		 */
+		Hashtable realCommandsHash = (Hashtable) (ij.Menus.getCommands().clone());
+		Set realCommandSet = realCommandsHash.keySet();
+		for (Iterator i = realCommandSet.iterator(); i.hasNext();) {
+			String command = (String) i.next();
+			// Some of these are whitespace only or separators - ignore them:
+			String trimmedCommand = command.trim();
+			if (trimmedCommand.length() > 0 && !trimmedCommand.equals("-")) {
+				commandsHash.put(command, new CommandAction((String) realCommandsHash.get(command), null, null));
+			}
+		}
+
+		/*
+		 * There are some menu items that don't correspond to plugins, such as
+		 * those added by RefreshScripts, so look through all the menus as well:
+		 */
+		findAllMenuItems();
+
+		/*
+		 * Sort the commands, generate list labels for each and put them into a
+		 * hash:
+		 */
+		commands = (String[]) commandsHash.keySet().toArray(new String[0]);
+		Arrays.sort(commands);
+
+		/* The code below just constructs the dialog: */
+		ImageJ imageJ = IJ.getInstance();
+		frame = new JFrame("Command Finder") {
+			public void setVisible(boolean visible) {
+				if (visible)
+					WindowManager.addWindow(this);
+				super.setVisible(visible);
+			}
+
+			public void dispose() {
+				WindowManager.removeWindow(this);
+				Prefs.set("command-finder.close", closeWhenRunning);
+				frame = null;
+				super.dispose();
+			}
+		};
+		Container contentPane = frame.getContentPane();
+		contentPane.setLayout(new BorderLayout());
+		frame.addWindowListener(this);
+		if (imageJ != null && !IJ.isMacOSX()) {
+			Image img = imageJ.getIconImage();
+			if (img != null)
+				try {
+					frame.setIconImage(img);
+				} catch (Exception e) {
+				}
+		}
+
+		closeCheckBox = new JCheckBox("Close window after running command", closeWhenRunning);
+		GUI.scale(closeCheckBox);
+		closeCheckBox.addItemListener(this);
+
+		lutCheckBox = new JCheckBox("Apply LUTs", applyLUT);
+		GUI.scale(lutCheckBox);
+		lutCheckBox.addItemListener(this);
+
+		JPanel northPanel = new JPanel(new BorderLayout());
+		JLabel searchLabel = new JLabel(" Search:");
+		GUI.scale(searchLabel);
+		northPanel.add(searchLabel, BorderLayout.WEST);
+		prompt = new JTextField("", 20);
+		GUI.scale(prompt);
+
+		prompt.getDocument().addDocumentListener(new PromptDocumentListener());
+		prompt.addKeyListener(this);
+		northPanel.add(prompt);
+		contentPane.add(northPanel, BorderLayout.NORTH);
+
+		tableModel = new TableModel();
+		table = new JTable(tableModel);
+		// table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		table.setRowSelectionAllowed(true);
+		table.setColumnSelectionAllowed(false);
+		// table.setAutoCreateRowSorter(true);
+		tableModel.setColumnWidths(table.getColumnModel());
+		GUI.scale(table);
+
+		Dimension dim = new Dimension(TABLE_WIDTH, table.getRowHeight() * TABLE_ROWS);
+		table.setPreferredScrollableViewportSize(dim);
+		table.addKeyListener(this);
+		table.addMouseListener(this);
+
+		// Auto-scroll table using keystrokes
+		table.addKeyListener(new KeyAdapter() {
+			public void keyTyped(final KeyEvent evt) {
+				if (evt.isControlDown() || evt.isMetaDown())
+					return;
+				final int nRows = tableModel.getRowCount();
+				final char ch = Character.toLowerCase(evt.getKeyChar());
+				if (!Character.isLetterOrDigit(ch)) {
+					return; // Ignore searches for non alpha-numeric characters
+				}
+				final int sRow = table.getSelectedRow();
+				for (int row = (sRow + 1) % nRows; row != sRow; row = (row + 1) % nRows) {
+					final String rowData = tableModel.getValueAt(row, 0).toString();
+					final char rowCh = Character.toLowerCase(rowData.charAt(0));
+					if (ch == rowCh) {
+						table.setRowSelectionInterval(row, row);
+						table.scrollRectToVisible(table.getCellRect(row, 0, true));
+						break;
+					}
+				}
+			}
+		});
+
+		scrollPane = new JScrollPane(table);
+		if (initialSearch == null)
+			initialSearch = "";
+		prompt.setText(initialSearch);
+		populateList(initialSearch);
+		contentPane.add(scrollPane, BorderLayout.CENTER);
+
+		runButton = new JButton("Run");
+		GUI.scale(runButton);
+		sourceButton = new JButton("Source");
+		GUI.scale(sourceButton);
+		closeButton = new JButton("Close");
+		GUI.scale(closeButton);
+		commandsButton = new JButton("Commands");
+		GUI.scale(commandsButton);
+		helpButton = new JButton("Help");
+		GUI.scale(helpButton);
+		runButton.addActionListener(this);
+		sourceButton.addActionListener(this);
+		closeButton.addActionListener(this);
+		commandsButton.addActionListener(this);
+		helpButton.addActionListener(this);
+		runButton.addKeyListener(this);
+		sourceButton.addKeyListener(this);
+		closeButton.addKeyListener(this);
+		commandsButton.addKeyListener(this);
+		helpButton.addKeyListener(this);
+
+		JPanel southPanel = new JPanel();
+		southPanel.setLayout(new BorderLayout());
+
+		JPanel optionsPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 0, 0));
+		optionsPanel.add(closeCheckBox);
+		optionsPanel.add(lutCheckBox);
+
+		JPanel buttonsPanel = new JPanel();
+		buttonsPanel.add(runButton);
+		buttonsPanel.add(sourceButton);
+		buttonsPanel.add(closeButton);
+		buttonsPanel.add(commandsButton);
+		buttonsPanel.add(helpButton);
+
+		southPanel.add(optionsPanel, BorderLayout.CENTER);
+		southPanel.add(buttonsPanel, BorderLayout.SOUTH);
+
+		contentPane.add(southPanel, BorderLayout.SOUTH);
+
+		Rectangle screen = GUI.getMaxWindowBounds(IJ.getInstance());
+
+		frame.pack();
+
+		int dialogWidth = frame.getWidth();
+		int dialogHeight = frame.getHeight();
+
+		Point pos = imageJ.getLocationOnScreen();
+		Dimension size = imageJ.getSize();
+
+		/*
+		 * Generally try to position the dialog slightly offset from the main
+		 * ImageJ window, but if that would push the dialog off to the screen to
+		 * any side, adjust it so that it's on the screen.
+		 */
+		int initialX = pos.x + 10;
+		int initialY = pos.y + 10 + size.height;
+
+		initialX = Math.max(screen.x, Math.min(initialX, screen.x + screen.width - dialogWidth));
+		initialY = Math.max(screen.y, Math.min(initialY, screen.y + screen.height - dialogHeight));
+
+		frame.setLocation(initialX, initialY);
+		frame.setVisible(true);
+		frame.toFront();
+	}
+
+	/* Make sure that clicks on the close icon close the window: */
+	public void windowClosing(WindowEvent e) {
+		closeWindow();
+	}
+
+	private void closeWindow() {
+		if (frame != null)
+			frame.dispose();
+	}
+
+	public void windowActivated(WindowEvent e) {
+		if (IJ.isMacOSX() && frame != null)
+			frame.setMenuBar(Menus.getMenuBar());
+	}
+
+	public void windowDeactivated(WindowEvent e) {
+	}
+
+	public void windowClosed(WindowEvent e) {
+	}
+
+	public void windowOpened(WindowEvent e) {
+	}
+
+	public void windowIconified(WindowEvent e) {
+	}
+
+	public void windowDeiconified(WindowEvent e) {
+	}
+
+	private class TableModel extends AbstractTableModel {
+		protected ArrayList list;
+		public final static int COLUMNS = 4;
+
+		public TableModel() {
+			list = new ArrayList();
+		}
+
+		public void setData(ArrayList list) {
+			this.list = list;
+			fireTableDataChanged();
+		}
+
+		public int getColumnCount() {
+			return COLUMNS;
+		}
+
+		public String getColumnName(int column) {
+			switch (column) {
+			case 0:
+				return "Command";
+			case 1:
+				return "Menu Path";
+			case 2:
+				return "Class";
+			case 3:
+				return "File";
+			}
+			return null;
+		}
+
+		public int getRowCount() {
+			return list.size();
+		}
+
+		public Object getValueAt(int row, int column) {
+			if (row >= list.size() || column >= COLUMNS)
+				return null;
+			String[] strings = (String[]) list.get(row);
+			return strings[column];
+		}
+
+		public String getCommand(int row) {
+			if (row < 0 || row >= list.size())
+				return "";
+			else
+				return (String) getValueAt(row, 0);
+		}
+
+		public void setColumnWidths(TableColumnModel columnModel) {
+			int[] widths = { 170, 150, 170, 30 };
+			for (int i = 0; i < widths.length; i++)
+				columnModel.getColumn(i).setPreferredWidth(widths[i]);
+		}
+
+	}
+
+}
\ No newline at end of file
diff --git a/src/ij/plugin/CommandLister.java b/src/ij/plugin/CommandLister.java
new file mode 100644
index 0000000..fb994ce
--- /dev/null
+++ b/src/ij/plugin/CommandLister.java
@@ -0,0 +1,85 @@
+package ij.plugin;
+import ij.*;
+import ij.text.*;
+import ij.util.*;
+import java.util.*;
+import java.awt.*;
+import java.awt.event.*;
+
+/** This class is used by the Plugins/Shortcuts/List Shortcuts 
+	command to display a list keyboard shortcuts. */
+public class CommandLister implements PlugIn {
+
+	public void run(String arg) {
+		if (arg.equals("shortcuts"))
+			listShortcuts();
+		else
+			listCommands();
+	}
+	
+	public void listCommands() {
+		Hashtable commands = Menus.getCommands();
+		Vector v = new Vector();
+		int index = 1;
+		for (Enumeration en=commands.keys(); en.hasMoreElements();) {
+			String command = (String)en.nextElement();
+			v.addElement(index+"\t"+command+"\t"+(String)commands.get(command));
+			index++;
+		}
+		String[] list = new String[v.size()];
+		v.copyInto((String[])list);
+		showList("Commands", " \tCommand\tPlugin", list);
+	}
+
+	public void listShortcuts() {
+		String[] shortcuts = getShortcuts();
+		for (int i=0; i<shortcuts.length; i++) {
+			if (shortcuts[i].contains("\t^"))
+				shortcuts[i] += " (macro)";
+		}
+		showList("Keyboard Shortcuts", "Shortcut\tCommand", shortcuts);
+	}
+	
+	public String[] getShortcuts() {
+		Vector v = new Vector();
+		Hashtable shortcuts = Menus.getShortcuts();
+		addShortcutsToVector(shortcuts, v);
+		Hashtable macroShortcuts = Menus.getMacroShortcuts();
+		addShortcutsToVector(macroShortcuts, v);
+		String[] list = new String[v.size()];
+		v.copyInto((String[])list);
+		return list;
+	}
+
+	void addShortcutsToVector(Hashtable shortcuts, Vector v) {
+		for (Enumeration en=shortcuts.keys(); en.hasMoreElements();) {
+			Integer key = (Integer)en.nextElement();
+			int keyCode = key.intValue();
+			boolean upperCase = false;
+			if (keyCode>=200+65 && keyCode<=200+90) {
+				upperCase = true;
+				keyCode -= 200;
+			}
+			String shortcut = KeyEvent.getKeyText(keyCode);
+			if (!upperCase && shortcut.length()==1) {
+				char c = shortcut.charAt(0);
+				if (c>=65 && c<=90)
+					c += 32;
+				char[] chars = new char[1];
+				chars[0] = c;
+				shortcut = new String(chars);
+			}
+			if (shortcut.length()>1)
+				shortcut = " " + shortcut; 
+			v.addElement(shortcut+"\t"+(String)shortcuts.get(key));
+		}
+	}
+
+	void showList(String title, String headings, String[] list) {
+		Arrays.sort(list, String.CASE_INSENSITIVE_ORDER);
+		ArrayList list2 = new ArrayList();
+		for (int i=0; i<list.length; i++)
+			list2.add(list[i]);
+		TextWindow tw = new TextWindow(title, headings, list2, 600, 500);
+	}
+}
diff --git a/src/ij/plugin/Commands.java b/src/ij/plugin/Commands.java
new file mode 100644
index 0000000..a85b5df
--- /dev/null
+++ b/src/ij/plugin/Commands.java
@@ -0,0 +1,174 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.plugin.frame.*;
+import ij.text.TextWindow;
+import ij.macro.Interpreter;
+import ij.plugin.Compiler;
+import java.awt.Window;
+import java.io.File;
+import java.applet.Applet;
+	
+/**	Runs miscellaneous File and Window menu commands. */
+public class Commands implements PlugIn {
+	
+	public void run(String cmd) {
+		if (cmd.equals("new")) {
+			if (IJ.altKeyDown())
+				IJ.runPlugIn("ij.plugin.HyperStackMaker", "");
+			else
+				new NewImage();
+		} else if (cmd.equals("open")) {
+			if (Prefs.useJFileChooser && !IJ.macroRunning())
+				new Opener().openMultiple();
+			else
+				new Opener().open();
+		} else if (cmd.equals("close"))
+			close();
+		else if (cmd.equals("close-all"))
+			closeAll();
+		else if (cmd.equals("save"))
+			save();
+		else if (cmd.equals("revert"))
+			revert();
+		else if (cmd.equals("undo"))
+			undo();
+		else if (cmd.equals("ij")) {
+			ImageJ ij = IJ.getInstance();
+			if (ij!=null) ij.toFront();
+		} else if (cmd.equals("tab"))
+			WindowManager.putBehind();
+		else if (cmd.equals("quit")) {
+			ImageJ ij = IJ.getInstance();
+			if (ij!=null) ij.quit();
+		} else if (cmd.equals("startup"))
+			openStartupMacros();
+    }
+    
+    void revert() {
+    	ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			imp.revert();
+		else
+			IJ.noImage();
+	}
+
+    void save() {
+    	ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			if (imp.getStackSize()>1) {
+				imp.setIgnoreFlush(true);
+				new FileSaver(imp).save();
+				imp.setIgnoreFlush(false);
+			} else
+				new FileSaver(imp).save();
+		} else
+			IJ.noImage();
+	}
+	
+    void undo() {
+    	ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			Undo.undo();
+		else
+			IJ.noImage();
+	}
+
+	void close() {
+    	ImagePlus imp = WindowManager.getCurrentImage();
+		Window win = WindowManager.getActiveWindow();
+		if (win==null || (Interpreter.isBatchMode() && win instanceof ImageWindow))
+			closeImage(imp);
+		else if (win instanceof PlugInFrame && !"Commands".equals(((PlugInFrame)win).getTitle()))
+			((PlugInFrame)win).close();
+		else if (win instanceof PlugInDialog)
+			((PlugInDialog)win).close();
+		else if (win instanceof TextWindow)
+			((TextWindow)win).close();
+		else
+			closeImage(imp);
+	}
+
+	/** Closes all image windows, or returns 'false' if the user cancels the unsaved changes dialog box. */
+	public static boolean closeAll() {
+    	int[] list = WindowManager.getIDList();
+    	if (list!=null) {
+    		int imagesWithChanges = 0;
+			for (int i=0; i<list.length; i++) {
+				ImagePlus imp = WindowManager.getImage(list[i]);
+				if (imp!=null && imp.changes) imagesWithChanges++;
+			}
+			if (imagesWithChanges>0 && !IJ.macroRunning()) {
+				GenericDialog gd = new GenericDialog("Close All");
+				String msg = null;
+				String pronoun = null;
+				if (imagesWithChanges==1) {
+					msg = "There is one image";
+					pronoun = "It";
+				} else {
+					msg = "There are "+imagesWithChanges+" images";
+					pronoun = "They";
+				}
+				gd.addMessage(msg+" with unsaved changes. "+pronoun
+					+" will\nbe closed without being saved if you click \"OK\".");
+				gd.showDialog();
+				if (gd.wasCanceled())	
+					return false;
+			}
+			Prefs.closingAll = true;
+			for (int i=0; i<list.length; i++) {
+				ImagePlus imp = WindowManager.getImage(list[i]);
+				if (imp!=null) {
+					imp.changes = false;
+					imp.close();
+				}
+			}
+			Prefs.closingAll = false;
+    	}
+    	return true;
+	}
+
+	void closeImage(ImagePlus imp) {
+		if (imp==null) {
+			IJ.noImage();
+			return;
+		}
+		imp.close();
+		if (Recorder.record && !IJ.isMacro()) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("imp.close();");
+			else
+				Recorder.record("close");
+			Recorder.setCommand(null); // don't record run("Close")
+		}
+	}
+	
+	// Plugins>Macros>Open Startup Macros command
+	void openStartupMacros() {
+		Applet applet = IJ.getApplet();
+		if (applet!=null)
+			IJ.run("URL...", "url="+IJ.URL+"/applet/StartupMacros.txt");
+		else {
+			String path = IJ.getDirectory("macros")+"StartupMacros.txt";
+			File f = new File(path);
+			if (!f.exists()) {
+				path = IJ.getDirectory("macros")+"StartupMacros.ijm";
+				f = new File(path);
+			}
+			if (!f.exists()) {
+				path = IJ.getDirectory("macros")+"StartupMacros.fiji.ijm";
+				f = new File(path);
+			}
+			if (!f.exists())
+				IJ.error("\"StartupMacros.txt\" not found in ImageJ/macros/");
+			else
+				IJ.open(path);
+		}
+	}
+		
+}
+
+
+
diff --git a/src/ij/plugin/Compiler.java b/src/ij/plugin/Compiler.java
new file mode 100644
index 0000000..a9ec95f
--- /dev/null
+++ b/src/ij/plugin/Compiler.java
@@ -0,0 +1,451 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.plugin.frame.Editor;
+import ij.plugin.Macro_Runner;
+import ij.plugin.filter.PlugInFilter;
+import ij.plugin.filter.PlugInFilterRunner;
+import java.awt.Font;
+import java.lang.reflect.Method;
+import java.io.*;
+import java.util.*;
+import javax.tools.*;
+
+/** Compiles and runs plugins using the javac compiler. */
+public class Compiler implements PlugIn, FilenameFilter {
+
+	private static final String info = 
+		"Library JAR files (e.g., imagescience.jar) should\n"
+		+"be located in either plugins/jars or plugins/lib.\n \n"
+		+"The javac command line will be displayed in\n"
+		+"the Log window if ImageJ is in debug mode.";
+	private static final int TARGET14=0, TARGET15=1, TARGET16=2,  TARGET17=3,  TARGET18=4, TARGET19=5;
+	private static final String[] targets = {"1.4", "1.5", "1.6", "1.7", "1.8", "1.9"};
+	private static final String TARGET_KEY = "javac.target";
+	private static CompilerTool compilerTool;
+	private static String dir, name;
+	private static Editor errors;
+	private static boolean generateDebuggingInfo;
+	private static int target = (int)Prefs.get(TARGET_KEY, TARGET18);	
+	private static boolean checkForUpdateDone;
+
+	public void run(String arg) {
+		if (arg.equals("edit"))
+			edit();
+		else if (arg.equals("options"))
+			showDialog();
+		else {
+			if (arg!=null && arg.length()>0 && !arg.endsWith(".java"))
+				IJ.error("Compiler", "File name must end with \".java\"");
+			else
+				compileAndRun(arg);
+		}
+	 }
+	 
+	void edit() {
+		if (open("", "Open macro or plugin")) {
+			Editor ed = (Editor)IJ.runPlugIn("ij.plugin.frame.Editor", "");
+			if (ed!=null) ed.open(dir, name);
+		}
+	}
+	
+	void compileAndRun(String path) {
+		if (!open(path, "Compile and Run Plugin..."))
+			return;
+		if (name.endsWith(".class")) {
+			runPlugin(name.substring(0, name.length()-1));
+			return;
+		}
+		if (!isJavac()) {
+			if (IJ.debugMode) IJ.log("Compiler: javac not found");
+			if (!checkForUpdateDone) {
+				checkForUpdate("/plugins/compiler/Compiler.jar", "1.48c");
+				checkForUpdateDone = true;
+			}
+			Object compiler = IJ.runPlugIn("Compiler", dir+name);
+			if (compiler==null) {
+				boolean ok = Macro_Runner.downloadJar("/plugins/compiler/Compiler.jar");
+				if (ok)
+					IJ.runPlugIn("Compiler", dir+name);
+			}
+			return;
+		}
+		if (compile(dir+name))
+			runPlugin(name);
+	}
+	
+	private void checkForUpdate(String plugin, String currentVersion) {
+		int slashIndex = plugin.lastIndexOf("/");
+		if (slashIndex==-1 || !plugin.endsWith(".jar"))
+			return;
+		String className = plugin.substring(slashIndex+1, plugin.length()-4);
+		File f = new File(Prefs.getImageJDir()+"plugins"+File.separator+"jars"+File.separator+className+".jar");
+		if (!f.exists() || !f.canWrite()) {
+			if (IJ.debugMode) IJ.log("checkForUpdate: jar not found ("+plugin+")");
+			return;
+		}
+		String version = null;
+		try {
+			Class c = IJ.getClassLoader().loadClass("Compiler");
+			version = "0.00a";
+			Method m = c.getDeclaredMethod("getVersion", new Class[0]);
+			version = (String)m.invoke(null, new Object[0]);
+		}
+		catch (Exception e) {}
+		if (version==null) {
+			if (IJ.debugMode) IJ.log("checkForUpdate: class not found ("+className+")");
+			return;
+		}
+		if (version.compareTo(currentVersion)>=0) {
+			if (IJ.debugMode) IJ.log("checkForUpdate: up to date ("+className+"  "+version+")");
+			return;
+		}
+		boolean ok = Macro_Runner.downloadJar(plugin);
+		if (IJ.debugMode) IJ.log("checkForUpdate: "+className+" "+version+" "+ok);
+	}
+	 
+	boolean isJavac() {
+		if (compilerTool==null)
+			compilerTool=CompilerTool.getDefault();
+		return compilerTool!=null;
+	}
+
+	boolean compile(String path) {
+		IJ.showStatus("compiling "+path);
+		String classpath = getClassPath(path);
+		Vector options = new Vector();
+		if (generateDebuggingInfo)
+			options.addElement("-g");
+		validateTarget();
+		options.addElement("-source");
+		options.addElement(targets[target]);
+		options.addElement("-target");
+		options.addElement(targets[target]);
+		options.addElement("-Xlint:unchecked");
+		options.addElement("-deprecation");
+		options.addElement("-classpath");
+		options.addElement(classpath);
+		
+		Vector sources = new Vector();
+		sources.add(path);
+		
+		if (IJ.debugMode) {
+			StringBuilder builder = new StringBuilder();
+			builder.append("javac");
+			for (int i=0; i< options.size(); i++){
+				builder.append(" ");
+				builder.append(options.get(i));
+			}
+			for (int i=0; i< sources.size(); i++){
+				builder.append(" ");
+				builder.append(sources.get(i));
+			}
+			IJ.log(builder.toString());
+		}
+		
+		boolean errors = true;
+		String s = "not compiled";
+		if (compilerTool != null) {
+			final StringWriter outputWriter = new StringWriter();
+			errors = !compilerTool.compile(sources, options, outputWriter);
+			s = outputWriter.toString();
+		} else {
+			errors = true;
+		}
+		
+		if (errors)
+			showErrors(s);
+		else
+			IJ.showStatus("done");
+		return !errors;
+	 }
+	 
+	 // Returns a string containing the Java classpath, 
+	 // the path to the directory containing the plugin, 
+	 // and paths to any .jar files in the plugins folder.
+	 String getClassPath(String path) {
+		long start = System.currentTimeMillis();
+		StringBuffer sb = new StringBuffer();
+		sb.append(System.getProperty("java.class.path"));
+		File f = new File(path);
+		if (f!=null)  // add directory containing file to classpath
+			sb.append(File.pathSeparator + f.getParent());
+		String pluginsDir = Menus.getPlugInsPath();
+		if (pluginsDir!=null)
+			addJars(pluginsDir, sb);
+		return sb.toString();
+	 }
+	 
+	// Adds .jar files in plugins folder, and subfolders, to the classpath
+	void addJars(String path, StringBuffer sb) {
+		String[] list = null;
+		File f = new File(path);
+		if (f.exists() && f.isDirectory())
+			list = f.list();
+		if (list==null)
+			return;
+		boolean isJarsFolder = path.endsWith("jars")|| path.endsWith("lib");
+		path = IJ.addSeparator(path);
+		for (int i=0; i<list.length; i++) {
+			File f2 = new File(path+list[i]);
+			if (f2.isDirectory())
+				addJars(path+list[i], sb);
+			else if (list[i].endsWith(".jar")&&(!list[i].contains("_")||isJarsFolder)) {
+				sb.append(File.pathSeparator+path+list[i]);
+				//IJ.log("javac classpath: "+path+list[i]);
+			}
+		}
+	}
+	
+	void showErrors(String s) {
+		if (errors==null || !errors.isVisible()) {
+			errors = (Editor)IJ.runPlugIn("ij.plugin.frame.Editor", "");
+			errors.setFont(new Font("Monospaced", Font.PLAIN, errors.getFontSize()));
+		}
+		if (errors!=null) {
+			ImageJ ij = IJ.getInstance();
+			if (ij!=null)
+				s = ij.getInfo()+"\n \n"+s;
+			errors.display("Errors", s);
+		}
+		IJ.showStatus("done (errors)");
+	}
+
+	 // open the .java source file
+	 boolean open(String path, String msg) {
+		boolean okay;
+		String fileName, directory;
+		if (path.equals("")) {
+			if (dir==null) dir = IJ.getDirectory("plugins");
+			OpenDialog od = new OpenDialog(msg, dir, name);
+			directory = od.getDirectory();
+			fileName = od.getFileName();
+			okay = fileName!=null;
+			String lcName = okay?fileName.toLowerCase(Locale.US):null;
+			if (okay) {
+				if (msg.startsWith("Compile")) {
+					if (!(lcName.endsWith(".java")||lcName.endsWith(".class"))) {
+						IJ.error("File name must end with \".java\" or \".class\".");
+						okay = false;
+					}
+				} else if (!(lcName.endsWith(".java")||lcName.endsWith(".txt")||lcName.endsWith(".ijm")||lcName.endsWith(".js")||lcName.endsWith(".py")||lcName.endsWith(".bsh"))) {
+					IJ.error("File name must end with \".java\", \".txt\", \".ijm\", \".js\" or \".py\"");
+					okay = false;
+				}
+			}
+		} else {
+			int i = path.lastIndexOf('/');
+			if (i==-1)
+				i = path.lastIndexOf('\\');
+			if (i>0) {
+				directory = path.substring(0, i+1);
+				fileName = path.substring(i+1);
+			} else {
+				directory = "";
+				fileName = path;
+			}
+			okay = true;
+		}
+		if (okay) {
+			name = fileName;
+			dir = directory;
+			Editor.setDefaultDirectory(dir);
+		}
+		return okay;
+	}
+
+	// only show files with names ending in ".java"
+	// doesn't work with Windows
+	public boolean accept(File dir, String name) {
+		return name.endsWith(".java")||name.endsWith(".macro")||name.endsWith(".txt");
+	}
+	
+	// run the plugin using a new class loader
+	void runPlugin(String name) {
+		name = name.substring(0,name.length()-5); // remove ".java" or ".clas"
+		new PlugInExecuter(name);
+	}
+	
+	public void showDialog() {
+		validateTarget();
+		GenericDialog gd = new GenericDialog("Compile and Run");
+		gd.addChoice("Target: ", targets, targets[target]);
+		gd.setInsets(15,5,0);
+		gd.addCheckbox("Generate debugging info (javac -g)", generateDebuggingInfo);
+		gd.addHelp(IJ.URL+"/docs/menus/edit.html#compiler");
+		Font font = IJ.font10;
+		gd.addMessage(info, font);
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		target = gd.getNextChoiceIndex();		
+		generateDebuggingInfo = gd.getNextBoolean();
+		validateTarget();
+	}
+	
+	void validateTarget() {
+		if (target>TARGET19)
+			target = TARGET19;
+		if (target<TARGET16)
+			target = TARGET16;
+		if (target>TARGET16 && IJ.javaVersion()<7)
+			target = TARGET16;
+		if (target>TARGET17 && IJ.javaVersion()<8)
+			target = TARGET17;
+		if (target>TARGET18 && IJ.javaVersion()<9)
+			target = TARGET18;
+		Prefs.set(TARGET_KEY, target);
+	}
+	
+}
+
+class PlugInExecuter implements Runnable {
+	private String plugin;
+	private Thread thread;
+
+	/** Create a new object that runs the specified plugin
+		in a separate thread. */
+	PlugInExecuter(String plugin) {
+		this.plugin = plugin;
+		thread = new Thread(this, plugin);
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	public void run() {
+		IJ.resetEscape();
+		IJ.runPlugIn("ij.plugin.ClassChecker", "");
+		runCompiledPlugin(plugin);
+	}
+	
+	void runCompiledPlugin(String className) {
+		if (IJ.debugMode) IJ.log("Compiler: running \""+className+"\"");
+		IJ.resetClassLoader();
+		ClassLoader loader = IJ.getClassLoader();
+		Object thePlugIn = null;
+		try { 
+			thePlugIn = (loader.loadClass(className)).newInstance(); 
+			if (thePlugIn instanceof PlugIn)
+ 				((PlugIn)thePlugIn).run("");
+ 			else if (thePlugIn instanceof PlugInFilter)
+				new PlugInFilterRunner(thePlugIn, className, "");
+		}
+		catch (ClassNotFoundException e) {
+			if (className.indexOf('_')!=-1)
+				IJ.error("Plugin or class not found: \"" + className + "\"\n(" + e+")");
+		}
+		catch (NoClassDefFoundError e) {
+			String err = e.getMessage();
+			if (IJ.debugMode) IJ.log("NoClassDefFoundError: "+err);
+			int index = err!=null?err.indexOf("wrong name: "):-1;
+			if (index>-1 && !className.contains(".")) {
+				String className2 = err.substring(index+12, err.length()-1);
+				className2 = className2.replace("/", ".");
+				if (className2.equals(className)) { // Java 9 error format different
+					int spaceIndex = err.indexOf(" ");
+					if (spaceIndex>-1) {
+						className2 = err.substring(0, spaceIndex);
+						className2 = className2.replace("/", ".");
+					}
+				}
+				if (className2.equals(className))
+					IJ.error("Plugin not found: "+className2);
+				else
+					runCompiledPlugin(className2);
+				return;
+			}
+			if (className.indexOf('_')!=-1)
+				IJ.error("Plugin or class not found: \"" + className + "\"\n(" + e+")");
+		}
+		catch (Exception e) {
+			//IJ.error(""+e);
+			IJ.handleException(e); //Marcel Boeglin 2013.09.01
+			//Logger.getLogger(getClass().getName()).log(Level.SEVERE, null, e); //IDE output
+		}
+	}
+	
+}
+
+abstract class CompilerTool {
+
+	public static class JavaxCompilerTool extends CompilerTool {
+
+		public boolean compile(List sources, List options, StringWriter log) {
+			if (IJ.debugMode) IJ.log("Compiler: using javax.tool.JavaCompiler");
+			try {
+				JavaCompiler javac = getJavac();
+				DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>();
+				StandardJavaFileManager fileManager = javac.getStandardFileManager(diagnostics, null, null);
+				Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjectsFromStrings(sources);
+				JavaCompiler.CompilationTask task =javac.getTask(log, fileManager, null, options, null, compilationUnits);
+    			fileManager.close();
+    			return task.call();
+			} catch (Exception e) {
+				PrintWriter printer = new PrintWriter(log);
+				e.printStackTrace(printer);
+				printer.flush();
+			}
+			return false;
+		}
+
+		protected JavaCompiler getJavac() throws Exception {
+			JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+			return javac;
+		}
+	}
+
+	public static class LegacyCompilerTool extends CompilerTool {
+		protected static Class javacC;
+
+		public boolean compile(List sources, List options, StringWriter log) {
+			if (IJ.debugMode) IJ.log("Compiler: using com.sun.tools.javac");
+			try {
+				final String[] args = new String[sources.size() + options.size()];
+				int argsIndex = 0;
+				for (int optionsIndex = 0; optionsIndex < options.size(); optionsIndex++)
+					args[argsIndex++] = (String) options.get(optionsIndex);
+				for (int sourcesIndex = 0; sourcesIndex < sources.size(); sourcesIndex++)
+					args[argsIndex++] = (String) sources.get(sourcesIndex);
+				PrintWriter printer = new PrintWriter(log);
+				Object javac = getJavac();
+				Class[] compileTypes = new Class[] { String[].class, PrintWriter.class };
+				Method compile = javacC.getMethod("compile", compileTypes);
+				Object result = compile.invoke(javac, new Object[] { args, printer });
+				printer.flush();
+				return Integer.valueOf(0).equals(result);
+			} catch (Exception e) {
+				e.printStackTrace(new PrintWriter(log));
+			}
+			return false;
+		}
+
+		protected Object getJavac() throws Exception {
+			if (javacC==null)
+				javacC = Class.forName("com.sun.tools.javac.Main");
+			return javacC.newInstance();
+		}
+	}
+
+	public static CompilerTool getDefault() {
+		CompilerTool javax = new JavaxCompilerTool();
+		if (javax.isSupported())
+			return javax;
+		CompilerTool legacy = new LegacyCompilerTool();
+		if (legacy.isSupported())
+			return legacy;
+		return null;
+	}
+
+	public abstract boolean compile(List sources, List options, StringWriter log);
+
+	protected abstract Object getJavac() throws Exception;
+
+	public boolean isSupported() {
+		try {
+			return null != getJavac();
+		} catch (Exception e) {
+			return false;
+		}
+	}
+}
+
diff --git a/src/ij/plugin/CompositeConverter.java b/src/ij/plugin/CompositeConverter.java
new file mode 100644
index 0000000..0a81dd9
--- /dev/null
+++ b/src/ij/plugin/CompositeConverter.java
@@ -0,0 +1,111 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import java.awt.image.*;
+import ij.plugin.frame.ContrastAdjuster;
+import ij.macro.Interpreter;
+import ij.plugin.frame.Recorder;
+
+/** This plugin implements the Image/Color/Make Composite command. */
+public class CompositeConverter implements PlugIn {
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		if (imp.isComposite()) {
+			CompositeImage ci = (CompositeImage)imp;
+			if (ci.getMode()!=IJ.COMPOSITE) {
+				ci.setMode(IJ.COMPOSITE);
+				ci.updateAndDraw();
+			}
+			return;
+		}
+		int c = imp.getNChannels();
+		int z = imp.getNSlices();
+		int t = imp.getNFrames();
+		if (imp.getBitDepth()==24) {
+			ImageWindow win = imp.getWindow();
+			Point loc = win!=null?win.getLocation():null;
+			int slice = imp.getCurrentSlice();
+			ImagePlus imp2 = makeComposite(imp);
+			if (loc!=null) ImageWindow.setNextLocation(loc);
+			imp2.show();
+			imp.changes = false;
+			if (z*t==1) {
+				imp.hide();
+				WindowManager.setCurrentWindow(imp2.getWindow());
+			} else {
+				if (arg!=null && arg.equals("color"))
+					((CompositeImage)imp2).setMode(IJ.COLOR);
+				imp2.setSlice(slice);
+				imp.close();
+			}
+			if (IJ.isMacro() && !Interpreter.isBatchMode())
+				IJ.wait(500);
+		} else if (c>=2 || (IJ.macroRunning()&&c>=1)) {
+			String[] modes = {"Composite", "Color", "Grayscale"};
+			String mode = modes[0];
+			if (c==1 && z*t>7)
+				mode = modes[2];
+			GenericDialog gd = new GenericDialog("Make Composite");
+			gd.addChoice("Display Mode:", modes, mode);
+			gd.showDialog();
+			if (gd.wasCanceled()) return;
+			int index = gd.getNextChoiceIndex();
+			CompositeImage ci = new CompositeImage(imp, index+1);
+			if (imp.getBitDepth()!=8) {
+				ci.reset();
+				ci.resetDisplayRanges();
+			}
+			ImageWindow win = imp.getWindow();
+			Point location = win!=null?win.getLocation():null;
+			imp.hide();
+			if (location!=null)
+				ImageWindow.setNextLocation(location);
+			if (IJ.isMacro())
+				IJ.wait(250);
+			ci.show();
+		} else
+			IJ.error("To create a composite, the current image must be\n a stack with at least 2 channels or be in RGB format.");
+	}
+	
+	public static ImagePlus makeComposite(ImagePlus imp) {
+		if (imp.getBitDepth()==24) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("ImagePlus", "imp2 = CompositeConverter.makeComposite(imp);");
+			return convertRGBToComposite(imp);
+		} else
+			return null;
+	}
+	
+	private static ImagePlus convertRGBToComposite(ImagePlus imp) {
+		if (imp.getBitDepth()!=24)
+			throw new IllegalArgumentException("RGB image or stack required");
+		if (imp.getStackSize()==1)
+			return new CompositeImage(imp, IJ.COMPOSITE);
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		ImageStack stack1 = imp.getStack();
+		int z = imp.getNSlices();
+		int t = imp.getNFrames();
+		int n = z*t;
+		ImageStack stack2 = new ImageStack(width, height);
+		for (int i=0; i<n; i++) {
+			ColorProcessor ip = (ColorProcessor)stack1.getProcessor(1);
+			stack1.deleteSlice(1);
+			byte[] R = new byte[width*height];
+			byte[] G = new byte[width*height];
+			byte[] B = new byte[width*height];
+			ip.getRGB(R, G, B);
+			stack2.addSlice(null, R);
+			stack2.addSlice(null, G);
+			stack2.addSlice(null, B);
+		}
+		ImagePlus imp2 = new ImagePlus(imp.getTitle(), stack2);
+		imp2.setDimensions(3, z, t);
+ 		imp2 = new CompositeImage(imp2, IJ.COMPOSITE);
+		return imp2;
+	}
+
+}
diff --git a/src/ij/plugin/Concatenator.java b/src/ij/plugin/Concatenator.java
new file mode 100644
index 0000000..8b4e7e9
--- /dev/null
+++ b/src/ij/plugin/Concatenator.java
@@ -0,0 +1,493 @@
+package ij.plugin;
+import ij.*;
+import ij.macro.Interpreter;
+import ij.process.*; 
+import ij.gui.*;
+import java.awt.*;
+import ij.measure.*;
+import ij.plugin.filter.*;
+import ij.plugin.frame.Recorder;
+import java.awt.event.*;
+import java.util.*;
+import java.lang.*;
+import java.awt.image.ColorModel;
+
+/** This plugin, which concatenates two or more images or stacks,
+ *	implements the Image/Stacks/Tools/Concatenate command.
+ *	Has the option of viewing the concatenated stack as a 4D image.
+ *	@author Jon Jackson j.jackson # ucl.ac.uk
+ */
+public class Concatenator implements PlugIn, ItemListener{
+	public String pluginName =	"Concatenator";
+	public int maxEntries = 18;	 // limit number of entries to fit on screen
+	private static boolean all_option = false;
+	private boolean keep = false;
+	private static boolean keep_option = false;
+	private boolean batch = false;
+	private boolean macro = false;
+	private boolean im4D = true;
+	private static boolean im4D_option = true;
+	private String[] imageTitles;
+	private ImagePlus[] images;
+	private Vector choices;
+	private Checkbox allWindows;
+	private final String none = "-- None --";
+	private String newtitle = "Untitled";
+	private ImagePlus newImp;
+	private int stackSize;
+	private double min = 0, max = Float.MAX_VALUE;
+	private int maxWidth, maxHeight;
+	private boolean showingDialog;
+
+	
+	/** Optional string argument sets the name dialog boxes if called from another plugin. */
+	public void run(String arg) {
+		macro = !arg.equals("");
+		if (!showDialog())
+			return;
+		newImp = concatenate(images, keep);
+		if (newImp!=null)
+			newImp.show();
+	}
+	
+	/** Displays a dialog requiring user to choose images and
+		returns ImagePlus of concatenated images. */
+	public ImagePlus run() {
+		if (!showDialog())
+			return null;
+		newImp = createHypervol();
+		return newImp;
+	}
+	
+	/** Concatenates two images, stacks or hyperstacks. */
+	public static ImagePlus run(ImagePlus img1, ImagePlus img2) {
+		ImagePlus[] images = new ImagePlus[2];
+		images[0]=img1; images[1]=img2;
+		return (new Concatenator()).concatenate(images, false);
+	}
+
+	/** Concatenates three images, stacks or hyperstacks. */
+	public static ImagePlus run(ImagePlus img1, ImagePlus img2, ImagePlus img3) {
+		ImagePlus[] images = new ImagePlus[3];
+		images[0]=img1; images[1]=img2;  images[2]=img3;
+		return (new Concatenator()).concatenate(images, false);
+	}
+
+	/** Concatenates four images, stacks or hyperstacks. */
+	public static ImagePlus run(ImagePlus img1, ImagePlus img2, ImagePlus img3, ImagePlus img4) {
+		ImagePlus[] images = new ImagePlus[4];
+		images[0]=img1; images[1]=img2;  images[2]=img3; images[2]=img4;
+		return (new Concatenator()).concatenate(images, false);
+	}
+
+	/** Concatenates five images, stacks or hyperstacks. */
+	public static ImagePlus run(ImagePlus img1, ImagePlus img2, ImagePlus img3, ImagePlus img4, ImagePlus img5) {
+		ImagePlus[] images = new ImagePlus[5];
+		images[0]=img1; images[1]=img2;  images[2]=img3; images[2]=img4; images[5]=img5;
+		return (new Concatenator()).concatenate(images, false);
+	}
+
+	/** Concatenates two or more images, stacks or hyperstacks.
+	 * @param images Array of source images
+	 * @return Returns the concatenated images as an ImagePlus
+	*/
+	public static ImagePlus run(ImagePlus[] images) {
+		return  (new Concatenator()).concatenate(images, false);
+	}
+
+	/*
+	// Why does this not work with Java 6?
+	public static ImagePlus run(ImagePlus... args) {
+		return (new Concatenator()).concatenate(args, false);
+	}
+	*/
+
+	/** Concatenates two or more images or stacks. */
+	public ImagePlus concatenate(ImagePlus[] ims, boolean keepIms) {
+		images = ims;
+		imageTitles = new String[ims.length];
+		for (int i = 0; i < ims.length; i++) {
+			if (ims[i] != null) {
+				imageTitles[i] = ims[i].getTitle();
+			} else {
+				IJ.error(pluginName, "Null ImagePlus passed to concatenate(...) method");
+				return null;
+			}
+		}
+		keep = keepIms;
+		batch = true;
+		ImagePlus imp0 = images[0];
+		if (imp0.isComposite() || imp0.getNChannels()>1)
+			newImp = concatenateHyperstacks(images, newtitle, keep);
+		else
+			newImp = createHypervol();
+		if (Recorder.scriptMode()) {
+			String args = "imp1";
+			for (int i=1; i<images.length; i++)
+				args += ", imp"+(i+1);
+			Recorder.recordCall("imp"+(images.length+1)+" = Concatenator.run("+args+");");
+		}
+		if (imp0!=null && newImp!=null)
+			newImp.setProperty("Info", imp0.getProperty("Info"));
+		return newImp;
+	}
+	
+	/** Concatenate two images or stacks. */
+	public ImagePlus concatenate(ImagePlus imp1, ImagePlus imp2, boolean keep) {
+		images = new ImagePlus[2];
+		images[0] = imp1;
+		images[1] = imp2;
+		return concatenate(images, keep);
+	}
+	
+	private ImagePlus createHypervol() {
+		boolean firstImage = true;
+		boolean duplicated;
+		Properties[] propertyArr = new Properties[images.length];
+		ImagePlus currentImp = null;
+		ImageStack concat_Stack = null;
+		stackSize = 0;
+		int dataType = 0, width= 0, height = 0;
+		Calibration cal = null;
+		int count = 0;
+		findMaxDimensions(images);
+		for (int i = 0; i < images.length; i++) {
+			if (images[i] != null) { // Should only find null imp if user has closed an image after starting plugin (unlikely...)
+				currentImp = images[i];
+				if (firstImage) { // Initialise based on first image
+					//concat_Imp = images[i];
+					cal = currentImp.getCalibration();
+					width = currentImp.getWidth();
+					height = currentImp.getHeight();
+					stackSize = currentImp.getNSlices();
+					dataType = currentImp.getType();
+					ColorModel cm = currentImp.getProcessor().getColorModel();
+					concat_Stack = new ImageStack(maxWidth, maxHeight, cm);
+					min = currentImp.getProcessor().getMin();
+					max = currentImp.getProcessor().getMax();
+					firstImage = false;
+				}
+				
+				// Safety Checks
+				boolean unequalSizes = currentImp.getNSlices()!=stackSize;
+				if (unequalSizes)
+					im4D = false;
+				if (currentImp.getType() != dataType) {
+					IJ.log("Omitting " + imageTitles[i] + " - image type not matched");
+					continue;
+				}
+
+			   // concatenate
+				duplicated = isDuplicated(currentImp, i);
+				concat(concat_Stack, currentImp.getStack(), (keep || duplicated));
+				propertyArr[count] = currentImp.getProperties();
+				imageTitles[count] = currentImp.getTitle();
+				if (! (keep || duplicated)) {
+					currentImp.changes = false;
+					currentImp.hide();
+				}
+				count++;
+			}
+		}
+		
+		// Copy across info fields
+		ImagePlus imp = new ImagePlus(newtitle, concat_Stack);
+		imp.setCalibration(cal);
+		imp.setProperty("Number of Stacks", new Integer(count));
+		imp.setProperty("Stacks Properties", propertyArr);
+		imp.setProperty("Image Titles", imageTitles);
+		imp.getProcessor().setMinAndMax(min, max);
+		if (im4D) {
+			imp.setDimensions(1, stackSize, imp.getStackSize()/stackSize);
+			imp.setOpenAsHyperStack(true);
+		}
+		return imp;
+	}
+	
+	// taken from WSR's Concatenator_.java
+	private void concat(ImageStack stack3, ImageStack stack1, boolean dup) {
+		int slice = 1;
+		int size = stack1.getSize();
+		for (int i = 1; i <= size; i++) {
+			ImageProcessor ip = stack1.getProcessor(slice);
+			String label = stack1.getSliceLabel(slice);
+			if (dup) {
+				ip = ip.duplicate();
+				slice++;
+			} else
+				stack1.deleteSlice(slice);
+			ImageProcessor ip2 = ip;
+			if (ip.getWidth()!=maxWidth || ip.getHeight()!=maxHeight) {
+				ip2 = ip.createProcessor(maxWidth, maxHeight);
+				ip2.insert(ip, (maxWidth-ip.getWidth())/2, (maxHeight-ip.getHeight())/2);
+			}
+			stack3.addSlice(label, ip2);
+		}
+	} 
+	
+	/** Obsolete, replaced by concatenate(images,keep) and Concatenator.run(images). */
+	public ImagePlus concatenateHyperstacks(ImagePlus[] images, String newTitle, boolean keep) {
+		int n = images.length;
+		int width = images[0].getWidth();
+		int height = images[0].getHeight();
+		int bitDepth = images[0].getBitDepth();
+		int channels = images[0].getNChannels();
+		int slices =  images[0].getNSlices();
+		int frames = images[0].getNFrames();
+		boolean concatSlices = slices>1 && frames==1;
+		boolean keepCalibration = true;
+		Calibration cal = images[0].getCalibration();
+		maxWidth = width;
+		maxHeight = height;
+		
+		for (int i=1; i<n; i++) {
+			if (images[i].getNFrames()>1)
+				concatSlices = false;
+			if (images[i].getBitDepth()!=bitDepth
+			|| images[i].getNChannels()!=channels
+			|| (!concatSlices && images[i].getNSlices()!=slices)) {
+				IJ.error(pluginName, "Images do not all have the same dimensions or type");
+				return null;
+			}
+			Calibration cal2 = images[i].getCalibration();
+			if (cal2.pixelWidth!=cal.pixelWidth 
+			|| cal2.pixelHeight!=cal.pixelHeight 
+			|| cal2.pixelDepth != cal.pixelDepth)
+				keepCalibration = false;
+			if (images[i].getWidth()>maxWidth)
+				maxWidth = images[i].getWidth();
+			if (images[i].getHeight()>maxHeight)
+				maxHeight = images[i].getHeight();
+		}
+		ImageStack stack2 = new ImageStack(maxWidth, maxHeight);
+		int slices2=0, frames2=0;
+		for (int i=0;i<n;i++) {
+			ImageStack stack = images[i].getStack();
+			slices = images[i].getNSlices();
+			if (concatSlices) {
+				slices = images[i].getNSlices();
+				slices2 += slices;
+				frames2 = frames;
+			} else {
+				frames = images[i].getNFrames();
+				frames2 += frames;
+				slices2 = slices;
+			}
+			for (int f=1; f<=frames; f++) {
+				for (int s=1; s<=slices; s++) {
+					for (int c=1; c<=channels; c++) {
+						int index = (f-1)*channels*slices + (s-1)*channels + c;
+						ImageProcessor ip = stack.getProcessor(index);
+						if (keep)
+							ip = ip.duplicate();
+						String label = stack.getSliceLabel(index);
+						ImageProcessor ip2 = ip;
+						if (ip.getWidth()!=maxWidth || ip.getHeight()!=maxHeight) {
+							ip2 = ip.createProcessor(maxWidth, maxHeight);
+							ip2.insert(ip, (maxWidth-ip.getWidth())/2, (maxHeight-ip.getHeight())/2);
+						}
+						stack2.addSlice(label, ip2);
+					}
+				}
+			}
+		}
+		ImagePlus imp2 = new ImagePlus(newTitle, stack2);
+		imp2.setDimensions(channels, slices2, frames2);
+		if (channels>1) {
+			int mode = 0;
+			if (images[0].isComposite())
+				mode = ((CompositeImage)images[0]).getMode();
+			imp2 = new CompositeImage(imp2, mode);
+			((CompositeImage)imp2).copyLuts(images[0]);
+		}
+		if (channels>1 && frames2>1)
+			imp2.setOpenAsHyperStack(true);
+		if (keepCalibration)
+			imp2.setCalibration(cal);
+		if (!keep) {
+			for (int i=0; i<n; i++) {
+				images[i].changes = false;
+				images[i].close();
+			}
+		}
+		return imp2;
+	}	
+	
+	private boolean showDialog() {
+		boolean all_windows = false;
+		batch = Interpreter.isBatchMode();
+		macro = macro || (IJ.isMacro()&&Macro.getOptions()!=null);
+		if (Menus.commandInUse("Stack to Image5D") && !batch)
+			im4D = true;
+		showingDialog = Macro.getOptions()==null;
+		if (macro) {
+			String options = Macro.getOptions();
+			if (options.contains("stack1")&&options.contains("stack2"))
+				Macro.setOptions(options.replaceAll("stack", "image"));
+			int macroImageCount = 0;
+			options = Macro.getOptions();
+			while (true) {
+				if (options.contains("image"+(macroImageCount+1)))
+					macroImageCount++;
+				else
+					break;
+			}
+			maxEntries = macroImageCount;
+		}
+		
+		// Checks
+		int[] wList = WindowManager.getIDList();
+		if (wList==null) {
+			IJ.error("No windows are open.");
+			return false;
+		} else if (wList.length < 2) {
+			IJ.error("Two or more windows must be open");
+			return false;
+		}
+		int nImages = wList.length;
+		
+		String[] titles = new String[nImages];
+		String[] titles_none = new String[nImages + 1];
+		for (int i=0; i<nImages; i++) {
+			ImagePlus imp = WindowManager.getImage(wList[i]);
+			if (imp!=null) {
+				titles[i] = imp.getTitle();
+				titles_none[i] = imp.getTitle();
+			} else {
+				titles[i] = "";
+				titles_none[i] = "";
+			}
+		}
+		titles_none[nImages] = none;
+		
+		GenericDialog gd = new GenericDialog(pluginName);
+		gd.addCheckbox("All_open windows", all_option);
+		gd.addChoice("Image1:", titles, titles[0]);
+		gd.addChoice("Image2:", titles, titles[1]);
+		for (int i = 2; i < ((nImages+1)<maxEntries?(nImages+1):maxEntries); i++)
+			gd.addChoice("Image" + (i+1)+":", titles_none, titles_none[i]);
+		gd.addStringField("Title:", newtitle, 16);
+		gd.addCheckbox("Keep original images", keep_option);
+		gd.addCheckbox("Open as 4D_image", im4D_option);
+		if (!macro) { // Monitor user selections
+			choices = gd.getChoices();
+			for (Enumeration e = choices.elements() ; e.hasMoreElements() ;)
+				((Choice)e.nextElement()).addItemListener(this);
+			Vector v = gd.getCheckboxes();
+			allWindows = (Checkbox)v.firstElement();
+			allWindows.addItemListener(this);
+			if (all_option) itemStateChanged(new ItemEvent(allWindows, ItemEvent.ITEM_STATE_CHANGED, null, ItemEvent.SELECTED));
+		}
+		gd.showDialog();
+		
+		if (gd.wasCanceled())
+			return false;
+		all_windows = gd.getNextBoolean();
+		all_option = all_windows;
+		gd.setSmartRecording(true);
+		newtitle = gd.getNextString();
+		gd.setSmartRecording(false);
+		keep = gd.getNextBoolean();
+		keep_option = keep;
+		im4D = gd.getNextBoolean();
+		im4D_option = im4D;
+		ImagePlus[] tmpImpArr = new ImagePlus[nImages+1];
+		String[] tmpStrArr = new String[nImages+1];
+		int index=0, count = 0;
+		for (int i=0; i<=nImages; i++) { // compile a list of images to concatenate from user selection
+			if (all_windows) { // Useful to not have to specify images in batch mode
+				index = i;
+			} else {
+				if (i == ((nImages+1)<maxEntries?(nImages+1):maxEntries) ) break;
+				gd.setSmartRecording(i==nImages);
+				index = gd.getNextChoiceIndex();
+			}
+			if (index >= nImages) break; // reached the 'none' string or handled all images (in case of all_windows)
+			if (! titles[index].equals("")) {
+				tmpStrArr[count] = titles[index];
+				tmpImpArr[count] = WindowManager.getImage(wList[index]);
+				count++;
+			}
+		}
+		if (count<2) {
+			IJ.error(pluginName, "Please select at least 2 images");
+			return false;
+		}
+		
+		imageTitles = new String[count];
+		images = new ImagePlus[count];
+		System.arraycopy(tmpStrArr, 0, imageTitles, 0, count);
+		System.arraycopy(tmpImpArr, 0, images, 0, count);
+		return true;
+	}
+	
+	// test if this imageplus appears again in the list
+	boolean isDuplicated(ImagePlus imp, int index) {
+		int length = images.length;
+		if (index >= length - 1) return false;
+		for (int i = index + 1; i < length; i++) {
+			if (imp == images[i]) return true;
+		}
+		return false;
+	}
+	
+	public void itemStateChanged(ItemEvent ie) {
+		Choice c;
+		if (ie.getSource() == allWindows) { // User selected / unselected 'all windows' button
+			int count = 0;
+			if (allWindows.getState()) {
+				for (Enumeration e = choices.elements() ; e.hasMoreElements() ;) {
+					c = (Choice)e.nextElement();
+					c.select(count++);
+					c.setEnabled(false);
+				}
+			} else {
+				for (Enumeration e = choices.elements() ; e.hasMoreElements() ;) {
+					c = (Choice)e.nextElement();
+					c.setEnabled(true);
+				}
+			}
+		} else { // User image selection triggered event
+			boolean foundNone = false;
+			// All image choices after an occurance of 'none' are reset to 'none'
+			for (Enumeration e = choices.elements() ; e.hasMoreElements() ;) {
+				c = (Choice)e.nextElement();
+				if (! foundNone) {
+					c.setEnabled(true);
+					if (c.getSelectedItem().equals(none)) foundNone = true;
+				} else { // a previous choice was 'none'
+					c.select(none);
+					c.setEnabled(false);
+				}
+			}
+		}
+	}
+	
+	public void setIm5D(boolean bool) {
+		im4D_option = bool;
+		im4D = bool;
+	}
+	
+	private void findMaxDimensions(ImagePlus[] images) {
+		boolean first = true;
+		ImagePlus currentImp = null;
+		int dataType = 0;
+		maxWidth = maxHeight = 0;
+		for (int i = 0; i < images.length; i++) {
+			if (images[i] != null) {
+				currentImp = images[i];
+				if (first) {
+					dataType = currentImp.getType();
+					first = false;
+				}
+				if (currentImp.getType() != dataType)
+					continue;
+				if (currentImp.getWidth()>maxWidth)
+					maxWidth = currentImp.getWidth();
+				if (currentImp.getHeight()>maxHeight)
+					maxHeight = currentImp.getHeight();
+			}
+		}
+	}
+	
+}
diff --git a/src/ij/plugin/ContrastEnhancer.java b/src/ij/plugin/ContrastEnhancer.java
new file mode 100644
index 0000000..baab9e9
--- /dev/null
+++ b/src/ij/plugin/ContrastEnhancer.java
@@ -0,0 +1,369 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import java.awt.*;
+
+/** Implements ImageJ's Process/Enhance Contrast command. */
+public class ContrastEnhancer implements PlugIn, Measurements {
+	static final double defaultSaturated = 0.35;
+	static double gSaturated = defaultSaturated;
+	static boolean gEqualize;
+	double saturated = defaultSaturated;
+	int max, range;
+	boolean classicEqualization;
+	int stackSize;
+	boolean updateSelectionOnly;
+	boolean equalize, normalize, processStack, useStackHistogram, entireImage;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		stackSize = imp.getStackSize();
+		imp.trimProcessor();
+		if (!showDialog(imp))
+			return;
+		Roi roi = imp.getRoi();
+		if (roi!=null) roi.endPaste();
+		if (stackSize==1)
+			Undo.setup(Undo.TRANSFORM, imp);
+		else
+			Undo.reset();
+		if (equalize)
+			equalize(imp);
+		else
+			stretchHistogram(imp, saturated);
+		if (normalize) {
+			ImageProcessor ip = imp.getProcessor();
+			ip.setMinAndMax(0,ip.getBitDepth()==32?1.0:ip.maxValue());
+		}
+		imp.updateAndDraw();
+	}
+
+	boolean showDialog(ImagePlus imp) {
+		String options = IJ.isMacro()?Macro.getOptions():null;
+		if (options!=null && options.contains("normalize_all"))
+			Macro.setOptions(options.replaceAll("normalize_all", "process_all"));
+		boolean isMacro = options!=null;
+		if (!isMacro) {
+			equalize = gEqualize;
+			saturated = gSaturated;
+		}
+		int bitDepth = imp.getBitDepth();
+		boolean composite = imp.isComposite();
+		if (composite) stackSize = 1;
+		Roi roi = imp.getRoi();
+		boolean areaRoi = roi!=null && roi.isArea() && !composite;
+		GenericDialog gd = new GenericDialog("Enhance Contrast");
+		gd.addNumericField("Saturated pixels:", saturated, 1, 4, "%");
+		if (bitDepth!=24 && !composite)
+			gd.addCheckbox("Normalize", normalize);
+		if (areaRoi) {
+			String label = bitDepth==24?"Update entire image":"Update all when normalizing";
+			gd.addCheckbox(label, entireImage);
+		}
+		gd.addCheckbox("Equalize histogram", equalize);
+		if (stackSize>1) {
+			if (!composite)
+				gd.addCheckbox("Process_all "+stackSize+" slices", processStack);
+			gd.addCheckbox("Use stack histogram", useStackHistogram);
+		}
+        gd.addHelp(IJ.URL+"/docs/menus/process.html#enhance");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		saturated = gd.getNextNumber();
+		if (bitDepth!=24 && !composite)
+			normalize = gd.getNextBoolean();
+		else
+			normalize = false;
+		if (areaRoi) {
+			entireImage = gd.getNextBoolean();
+			updateSelectionOnly = !entireImage;
+			if (!normalize && bitDepth!=24) 
+				updateSelectionOnly = false;
+		}
+		equalize = gd.getNextBoolean();
+		processStack = stackSize>1?gd.getNextBoolean():false;
+		useStackHistogram = stackSize>1?gd.getNextBoolean():false;
+		if (saturated<0.0) saturated = 0.0;
+		if (saturated>100.0) saturated = 100;
+		if (processStack && !equalize)
+			normalize = true;
+		if (!isMacro) {
+			gEqualize = equalize;
+			gSaturated = saturated;
+		}
+		return true;
+	}
+ 
+	public void stretchHistogram(ImagePlus imp, double saturated) {
+		ImageStatistics stats = null;
+		if (useStackHistogram)
+			stats = new StackStatistics(imp);
+		if (processStack) {
+			ImageStack stack = imp.getStack();
+			int size = this.stackSize==0?stack.size():this.stackSize;
+			for (int i=1; i<=size; i++) {
+				IJ.showProgress(i, size);
+				ImageProcessor ip = stack.getProcessor(i);
+				ip.setRoi(imp.getRoi());
+				if (!useStackHistogram)
+					stats = ImageStatistics.getStatistics(ip, MIN_MAX, null);
+				stretchHistogram(ip, saturated, stats);
+			}
+		} else {
+			ImageProcessor ip = imp.getProcessor();
+			ip.setRoi(imp.getRoi());
+			if (stats==null)
+				stats = ImageStatistics.getStatistics(ip, MIN_MAX, null);
+			if (imp.isComposite())
+				stretchCompositeImageHistogram((CompositeImage)imp, saturated, stats);
+			else
+				stretchHistogram(ip, saturated, stats);
+		}
+	}
+	
+	public void stretchHistogram(ImageProcessor ip, double saturated) {
+		useStackHistogram = false;
+		stretchHistogram(new ImagePlus("", ip), saturated);
+	}
+
+	public void stretchHistogram(ImageProcessor ip, double saturated, ImageStatistics stats) {
+		int[] a = getMinAndMax(ip, saturated, stats);
+		int hmin=a[0], hmax=a[1];
+		if (hmax>hmin) {
+			double min = stats.histMin+hmin*stats.binSize;
+			double max = stats.histMin+hmax*stats.binSize;
+			if (stats.histogram16!=null && ip instanceof ShortProcessor) {
+				min = hmin;
+				max = hmax;
+			}
+			if (!updateSelectionOnly)
+				ip.resetRoi();
+			if (normalize)
+				normalize(ip, min, max);
+			else {
+				if (updateSelectionOnly) {
+					ImageProcessor mask = ip.getMask();
+					if (mask!=null) ip.snapshot();
+					ip.setMinAndMax(min, max);
+					if (mask!=null) ip.reset(mask);
+				} else
+					ip.setMinAndMax(min, max);
+			}
+		}
+	}
+	
+	void stretchCompositeImageHistogram(CompositeImage imp, double saturated, ImageStatistics stats) {
+		ImageProcessor ip = imp.getProcessor();
+		int[] a = getMinAndMax(ip, saturated, stats);
+		int hmin=a[0], hmax=a[1];
+		if (hmax>hmin) {
+			double min = stats.histMin+hmin*stats.binSize;
+			double max = stats.histMin+hmax*stats.binSize;
+			if (stats.histogram16!=null && imp.getBitDepth()==16) {
+				min = hmin;
+				max = hmax;
+			}
+			imp.setDisplayRange(min, max);
+		}
+		/*
+		int channels = imp.getNChannels();b
+		int channel = imp.getChannel();
+		int slice = imp.getSlice();
+		int frame = imp.getFrame();
+		for (int c=1; c<=channels; c++) {
+			imp.setPosition(c, slice, frame);
+			ImageProcessor ip = imp.getProcessor();
+			int[] a = getMinAndMax(ip, saturated, stats);
+			int hmin=a[0], hmax=a[1];
+			if (hmax>hmin) {
+				double min = stats.histMin+hmin*stats.binSize;
+				double max = stats.histMin+hmax*stats.binSize;
+				imp.setDisplayRange(min, max);
+			}
+		}
+		imp.setPosition(channel, slice, frame);
+		*/
+	}
+
+	int[] getMinAndMax(ImageProcessor ip, double saturated, ImageStatistics stats) {
+		int hmin, hmax;
+		int threshold;
+		int[] histogram = stats.histogram;
+		if (stats.histogram16!=null && ip instanceof ShortProcessor)
+			histogram = stats.histogram16;
+		int hsize = histogram.length;
+		if (saturated>0.0)
+			threshold = (int)(stats.pixelCount*saturated/200.0);
+		else
+			threshold = 0;
+		int i = -1;
+		boolean found = false;
+		int count = 0;
+		int maxindex = hsize-1;
+		do {
+			i++;
+			count += histogram[i];
+			found = count>threshold;
+		} while (!found && i<maxindex);
+		hmin = i;
+				
+		i = hsize;
+		count = 0;
+		do {
+			i--;
+			count += histogram[i];
+			found = count>threshold;
+		} while (!found && i>0);
+		hmax = i;
+		int[] a = new int[2];
+		a[0]=hmin; a[1]=hmax;
+		return a;
+	}
+	
+	void normalize(ImageProcessor ip, double min, double max) {
+		int min2 = 0;
+		int max2 = 255;
+		int range = 256;
+		if (ip instanceof ShortProcessor)
+			{max2 = 65535; range=65536;}
+		else if (ip instanceof FloatProcessor)
+			normalizeFloat(ip, min, max);
+		int[] lut = new int[range];
+		for (int i=0; i<range; i++) {
+			if (i<=min)
+				lut[i] = 0;
+			else if (i>=max)
+				lut[i] = max2;
+			else
+				lut[i] = (int)(((double)(i-min)/(max-min))*max2);
+		}
+		applyTable(ip, lut);
+	}
+	
+	void applyTable(ImageProcessor ip, int[] lut) {
+		if (updateSelectionOnly) {
+			ImageProcessor mask = ip.getMask();
+			if (mask!=null) ip.snapshot();
+				ip.applyTable(lut);
+			if (mask!=null) ip.reset(mask);
+		} else
+			ip.applyTable(lut);
+	}
+
+	void normalizeFloat(ImageProcessor ip, double min, double max) {
+		double scale = max>min?1.0/(max-min):1.0;
+		int size = ip.getWidth()*ip.getHeight();
+		float[] pixels = (float[])ip.getPixels();
+		double v;
+		for (int i=0; i<size; i++) {
+			v = pixels[i] - min;
+			if (v<0.0) v = 0.0;
+			v *= scale;
+			if (v>1.0) v = 1.0;
+			pixels[i] = (float)v;
+		}
+	}
+
+	public void equalize(ImagePlus imp) {
+		if (imp.getBitDepth()==32) {
+			IJ.showMessage("Contrast Enhancer", "Equalization of 32-bit images not supported.");
+			return;
+		}
+		classicEqualization = IJ.altKeyDown();
+		int[] histogram = null;
+		if (useStackHistogram) {
+			ImageStatistics stats = new StackStatistics(imp);
+			histogram = stats.histogram;
+			if (stats.histogram16!=null && imp.getBitDepth()==16)
+				histogram = stats.histogram16;
+		}
+		if (processStack) {
+			ImageStack stack = imp.getStack();
+			int size = this.stackSize==0?stack.size():this.stackSize;
+			for (int i=1; i<=size; i++) {
+				IJ.showProgress(i, size);
+				ImageProcessor ip = stack.getProcessor(i);
+				if (histogram==null)
+					histogram = ip.getHistogram();
+				equalize(ip, histogram);
+			}
+		} else {
+			ImageProcessor ip = imp.getProcessor();
+			if (histogram==null)
+				histogram = ip.getHistogram();
+			equalize(ip, histogram);
+		}
+		if (imp.getBitDepth()==16 && processStack && imp.getStackSize()>1) {
+			ImageStack stack = imp.getStack();
+			ImageProcessor ip = stack.getProcessor(stack.size()/2);
+			ImageStatistics stats = ip.getStats();
+			imp.getProcessor().setMinAndMax(stats.min, stats.max);
+		} else
+			imp.getProcessor().resetMinAndMax();
+	}
+
+	/**	
+		Changes the tone curves of images. 
+		It should bring up the detail in the flat regions of your image.
+		Histogram Equalization can enhance meaningless detail and hide 
+		important but small high-contrast features. This method uses a
+		similar algorithm, but uses the square root of the histogram 
+		values, so its effects are less extreme. Hold the alt key down 
+		to use the standard histogram equalization algorithm.
+		This code was contributed by Richard Kirk (rak@cre.canon.co.uk).
+	*/ 
+	public void equalize(ImageProcessor ip) {
+		equalize(ip, ip.getHistogram());
+	}
+
+	private void equalize(ImageProcessor ip, int[] histogram) {
+		ip.resetRoi();
+		if (ip instanceof ShortProcessor) {	// Short
+			max = 65535;
+			range = 65535;
+		} else { //bytes
+			max = 255;
+			range = 255;
+		}
+		double sum;
+		sum = getWeightedValue(histogram, 0);
+		for (int i=1; i<max; i++)
+			sum += 2 * getWeightedValue(histogram, i);
+		sum += getWeightedValue(histogram, max);
+		double scale = range/sum;
+		int[] lut = new int[range+1];
+		lut[0] = 0;
+		sum = getWeightedValue(histogram, 0);
+		for (int i=1; i<max; i++) {
+			double delta = getWeightedValue(histogram, i);
+			sum += delta;
+			lut[i] = (int)Math.round(sum*scale);
+			sum += delta;
+		}
+		lut[max] = max;
+		applyTable(ip, lut);
+	}
+
+	private double getWeightedValue(int[] histogram, int i) {
+		int h = histogram[i];
+		if (h<2 || classicEqualization) return (double)h;
+		return Math.sqrt((double)(h));
+	}
+	
+	public void setNormalize(boolean normalize) {
+		this.normalize = normalize;
+	}
+	
+	public void setProcessStack(boolean processStack) {
+		this.processStack = processStack;
+		this.normalize = true;
+	}
+
+	public void setUseStackHistogram(boolean useStackHistogram) {
+		this.useStackHistogram = useStackHistogram;
+	}
+
+}
diff --git a/src/ij/plugin/ControlPanel.java b/src/ij/plugin/ControlPanel.java
new file mode 100644
index 0000000..c050ab3
--- /dev/null
+++ b/src/ij/plugin/ControlPanel.java
@@ -0,0 +1,1092 @@
+package ij.plugin;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.*;
+import java.io.*;
+import java.util.*;
+import java.net.*;
+import java.net.URL;
+import javax.swing.*;
+import javax.swing.tree.*;
+import javax.swing.event.*;
+import ij.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.plugin.*;
+import ij.plugin.filter.*;
+import ij.plugin.frame.PlugInFrame;
+import ij.util.*;
+import ij.text.TextWindow;
+
+/**ControlPanel.
+ * This plugin displays a panel with ImageJ commands in a hierarchical tree structure.
+ * @author Cezar M. Tigaret <c.tigaret@ucl.ac.uk>
+ */
+public class ControlPanel implements PlugIn {
+
+	/** The platform-specific file separator string.*/
+	private static final String fileSeparator=System.getProperty("file.separator");
+
+	/** The platform-specific file separator character. */
+	private static final char sep=fileSeparator.charAt(0);
+
+	private Hashtable panels = new Hashtable();
+	private Vector visiblePanels = new Vector();
+	private Vector expandedNodes = new Vector();
+	private String defaultArg = "";
+
+	private boolean savePropsUponClose=true;
+	private boolean propertiesChanged=true;
+	private boolean closeChildPanelOnExpand = true;
+	private boolean requireDoubleClick;
+	private boolean quitting = true;
+
+	Vector menus = new Vector();
+	Vector allMenus = new Vector();
+	Hashtable commands=new Hashtable();
+	Hashtable menuCommands=new Hashtable();
+	String[] pluginsArray;
+	Hashtable treeCommands = new Hashtable();
+	int argLength;
+
+	private String path=null;
+	private DefaultMutableTreeNode root;
+
+	MenuItem reloadMI = null;
+
+	public ControlPanel() {
+		//requireDoubleClick = !(IJ.isWindows() || IJ.isMacintosh());
+		Java2.setSystemLookAndFeel();
+	}
+
+
+	/** Creates a panel with the hierarchical tree structure of ImageJ's commands. */
+	public void run(String arg) {
+		load();
+	}
+
+
+	/* *********************************************************************** */
+	/*                             Tree logic                                  */
+	/* *********************************************************************** */
+
+	synchronized void load() {
+		commands = Menus.getCommands();
+		pluginsArray = Menus.getPlugins();
+		root=doRootFromMenus();
+		if (root==null || root.getChildCount()==0 ) return; // do nothing if there's no tree or a root w/o children
+		loadProperties();
+		restoreVisiblePanels();
+		if (panels.isEmpty())
+			newPanel(root);
+	}
+
+	/** Builds up a root tree from ImageJ's menu bar.
+	 * The root tree replicates ImageJ's menu bar with its menus and their submenus.
+	 * Delegates to the {@link recursesubMenu(Menu, DefaultMutableTreeNode} method to gather the root children.
+	 *
+	 */
+	private synchronized DefaultMutableTreeNode doRootFromMenus() {
+		DefaultMutableTreeNode node = new DefaultMutableTreeNode("ImageJ Menus");
+		if(argLength==0) node.setUserObject("Control Panel");
+		MenuBar menuBar = Menus.getMenuBar();
+		for (int i=0; i<menuBar.getMenuCount(); i++) {
+			Menu menu = menuBar.getMenu(i);
+			DefaultMutableTreeNode menuNode = new DefaultMutableTreeNode(menu.getLabel());
+			recurseSubMenu(menu, menuNode);
+			node.add(menuNode);
+		}
+		return node;
+	}
+
+	/**Recursively builds up a tree structure from the Menu argument, by populating the TreeNode argument
+	 * with children TreeNode objects constructed on the menu items.
+	 * Descendants can be intermediate-level nodes (submenus) or leaf nodes (i.e., no children).
+	 * Leaf nodes will only be added if there are any commands associated with them, i.e.
+	 * their labels correspond to keys in the hashtable returned by <code>ij.Menus.getCommands()</code>
+	 * except for the "Reload Plugins" menu item, for which a local action command string is assigned
+	 * to avoid clashes with the action fired from ImageJ Plugins->Utilties->Reload Plugins
+	 * menu item.<br>
+	 * <strong>Note: </strong> this method bypasses the tree buildup based on the
+	 * {@link populateNode(Hashtable,DefaultMutableTreeNode)} method.
+	 * @param menu The Menu instance to be searched recursively for menu items
+	 * @param node The DefaultMutableTreeNode corresponding to the <code>Menu menu</code> argument.
+	 */
+	private void recurseSubMenu(Menu menu, DefaultMutableTreeNode node) {
+		int items = menu.getItemCount();
+		if(items==0) return;
+		for (int i=0; i<items; i++) {
+			MenuItem mItem = menu.getItem(i);
+			String label = mItem.getActionCommand();
+			if (mItem instanceof Menu) {
+				DefaultMutableTreeNode subNode = new DefaultMutableTreeNode(label);
+				recurseSubMenu((Menu)mItem,subNode);
+				node.add(subNode);
+			} else if (mItem instanceof MenuItem) {
+				if (!(label.equals("-"))) {
+					DefaultMutableTreeNode leaf = new DefaultMutableTreeNode(label);
+					node.add(leaf);
+					if(treeCommands==null) treeCommands = new Hashtable();
+					if (label.equals("Reload Plugins")) {
+						reloadMI = mItem;
+						treeCommands.put(label,"Reload Plugins From Panel");
+					}
+				}
+			}
+		}
+	}
+
+	/**Populates the <code>node</code> argument with items retrieved from the collection.
+	 * Actually, the method delegates to {@link populateNode{String[], String[], DefaultMutableTreeNode)}.
+	 * @param collection Hashtable with `keys' (java.lang.String) representing a tree path which
+	 * is to be added to this node, but excludes it; the path extends to the last child (leaf node).
+   * The `values' are (java.lang.String) as labels and user objects for the last child of the path.
+	 * Actually, <code><strong>null<strong></code> elements for labels are allowed, in which case
+	 * the last child will be constructed on the last token in the `key'.
+	 * @param node The TreeNode to be populated.
+	 */
+	private void populateNode(Hashtable collection, DefaultMutableTreeNode node) {
+		Vector labelVector = new Vector();
+		for (Enumeration e=collection.keys(); e.hasMoreElements();) {
+			String key = (String)e.nextElement();
+			labelVector.addElement(key);
+		}
+		String[] labels = new String[labelVector.size()];
+		String[] items = new String[labelVector.size()];
+		labelVector.copyInto((String[])labels); // keys into labels[]
+		StringSorter.sort(labels);
+		for(int i=0; i<labels.length; i++) {
+			items[i] = (String)collection.get(labels[i]); //values into items[]
+		}
+		populateNode(items,labels,node);
+	}
+
+	/**Populates the <code>node</code> argument with items retrieved from the two String[] arguments.
+	 * Delegates indirectly to {@link buildTreePath(String.String,String,DefaultMutableTreeNode)} to do the job.
+	 * If either arguments are empty (i.e., length=0) or have different sizes, the method does nothing.
+	 * @param items String array where each element is the source of a tree path (see {@see buildTreePath(String, String, DefaultMutableTreeNode)}
+	 * and {@see buildTreePath(String,String,String,DefaultMutableTreeNode)}.
+	 * @param labels String array where each element is the label of the root of the tree path
+	 * @param node The TreeNode to be populated
+	 */
+	private void populateNode(String[] items, String[] labels, DefaultMutableTreeNode node) {
+		if (items.length==0 || items.length!=labels.length) return;
+		String label=null;
+		for (int i=0; i<items.length; i++) {
+			if(labels!=null && i<labels.length)
+				label = labels[i];
+			buildTreePath(items[i], label, node);
+		}
+	}
+
+	/**Short-hand for the four-argument <code>buildTreePath</code> method.
+	 * Calls <code>buildTreePath(source,label,<strong>null</strong>,topNode)</code>.
+	 * @see buildTreePath(String,String,String,DefaultMutableTreeNode).
+	 *
+	 */
+	private void buildTreePath(String source, String label, DefaultMutableTreeNode topNode) {
+		buildTreePath(source, label, null, topNode);
+	}
+
+	/**Builds up a tree path structure.
+	 * Populates the <code>node</code> argument with a tree path constructed as described below:
+   * @param source String to be parsed in a tree path; must be composed of tokens delimited by "/"
+	 * @param label The label (String) of the leaf node for this path. If <code><strong>null</strong></code>
+	 * then the leafe nod will be constructed from the last token.
+	 * @param command The command string of the action event fired upon clicking the leaf node.
+	 * If <code><strong>null</strong></code>, then the last token will be taken as action command.
+	 * @param topNode The DefaulMutableTreeNode to which this path will be added
+	 */
+	private void buildTreePath(String source, String label, String command, DefaultMutableTreeNode topNode) {
+		String local=source; // will contain the string to be parsed into the tree path
+		String argument="";  // will store any argument for the plugin
+		String delimiter = fileSeparator; // meaning `/'
+
+		// 1. store plugin arguments (the string between parentheses) in `argument'
+		// then store the rest into `local'
+		// if there aren't any plugin arguments, then local remains the same as `source'
+		int leftParen=source.indexOf('(');
+		int rightParen = source.indexOf(')');
+		if (leftParen>-1 && rightParen>leftParen) {
+			argument = source.substring(leftParen+1, rightParen);
+			local = source.substring(0,leftParen);
+		}
+		// 2. maybe `local' was passed in from some plugin class finder, and is prefixed by
+		// full path of the plugins directory; if so, then remove this prefix
+		String pluginsPath=Menus.getPlugInsPath();
+		if (local.startsWith(pluginsPath))
+			local = local.substring(pluginsPath.length(),local.length());
+		// 3. convert package/class separators into file separators,
+		// to allow parsing into tree path later
+		local=local.replace('.',delimiter.charAt(0));
+		// 4. append the plugin arguments, but with file separator so that to the same
+		// plugin with different arguments will show up as children of the same tree branch
+		if (argument.length()>0)
+			local=local.concat(fileSeparator).concat(argument);
+
+		DefaultMutableTreeNode node=null;
+
+		// 5. parse the tree path: this code is entirely different from the logic in TreePanel,
+		// so don't hold your breath:
+		// split the string into tokens delimited by file separator
+		// and iterate through the tokens adding an intermediate subnode for each token
+		//
+		// use the name of the token for intermediate nodes, and the `label' argument for
+		// the leaf node if not null; else use the last token for the leaf node
+		//
+		// for leaf node replace `_' with ` ' and trim away the `.class' extension
+		StringTokenizer pathParser = new StringTokenizer(local,delimiter);
+		int tokens = pathParser.countTokens();
+		while(pathParser.hasMoreTokens()) {
+			String token = pathParser.nextToken();
+			tokens--;
+			if (topNode.isLeaf()&&topNode.getAllowsChildren()) {
+				if(token.indexOf("ControlPanel")==-1) {// avoid showing this up in the tree
+					// when at leaf level the user object for the node is the `label' if not null,
+					// else is the `token'
+					if(tokens==0) {
+						if(label!=null) token=label; // if label is not null use it instead of token
+						token=token.replace('_',' ');
+						if(token.endsWith(".class"))
+							token = token.substring(0,token.length()-6);//...
+					}
+
+					node = new DefaultMutableTreeNode(token); // finally, construct the node
+
+					// when at leaf level, store the `command' (or the `token' if `command' is null)
+					// into our internal table
+					if (tokens==0) {
+						String cmd = (command==null) ? token : command;
+						if(treeCommands==null) treeCommands = new Hashtable();
+						if(!treeCommands.containsKey(token)) treeCommands.put(token,cmd);
+					}
+					// add this node to the top node, then make it top node and continue iteration
+					topNode.add(node);
+					topNode=node;
+				}
+				continue;
+			} else {
+				// this node may have been visited before, so we avoid duplicate nodes
+				// by recursing through the tree until we find a token that has not been
+				// "made" into a node
+				boolean hasTokenAsNode=false;
+				Enumeration nodes = topNode.children();
+				while(nodes.hasMoreElements()) {
+					node = (DefaultMutableTreeNode)nodes.nextElement();
+					if(((String)node.getUserObject()).equals(token)) {
+						hasTokenAsNode = true;
+						topNode = node;
+						break;
+					}
+				}
+				if (!hasTokenAsNode) {
+					if (token.indexOf("ControlPanel")==-1) {
+						if (tokens==0) {// we're at leaf level
+							if(label!=null) token = label;
+							token=token.replace('_',' ');
+							if (token.endsWith(".class"))
+								token=token.substring(0,token.length()-6); // ...
+						}
+						node = new DefaultMutableTreeNode(token);
+						topNode.add(node);
+						topNode=node;
+					}
+				}
+			}
+		}
+	}
+
+	/* *********************************************************************** */
+	/*                          Factories                                      */
+	/* *********************************************************************** */
+
+	/**Constructs a TreePanel rooted at the <code>node</code> argument.
+	 *
+	 */
+	TreePanel newPanel(DefaultMutableTreeNode node) {
+		boolean main = node.getUserObject().equals(root.getUserObject());
+		TreePanel panel = new TreePanel(node, this, main);
+		return panel;
+	}
+
+	TreePanel newPanel(DefaultMutableTreeNode node, Point location) {
+		boolean main = node.getUserObject().equals(root.getUserObject());
+		TreePanel panel = new TreePanel(node, this, main, location);
+		return panel;
+	}
+	/**Constructs a TreePanel rooted at the path.
+	 *
+	 *  @param s A string with the structure "[item1,item2,...,itemn]", as returned by
+	 *  a call to the <code>toString()</code> method in the <code>javax.swing.tree.TreePath</code> class.
+	 *
+	 */
+	TreePanel newPanel(String path) {
+		if (path.equals("Control_Panel.@Main")) path = "Control_Panel";
+		path = key2pStr(path);
+		TreePanel pnl = null;
+		for(Enumeration e = root.breadthFirstEnumeration(); e.hasMoreElements();) {
+			DefaultMutableTreeNode n = (DefaultMutableTreeNode)e.nextElement();
+			TreePath p = new TreePath(n.getPath());
+			if (p.toString().equals(path))
+				pnl=newPanel(n);
+		}
+		return pnl;
+	}
+
+	/* *************************************************************************** */
+	/*                          Various Accessors                                  */
+	/* *************************************************************************** */
+
+	boolean requiresDoubleClick() {return requireDoubleClick;}
+
+	void setDoubleClick(boolean dc) {requireDoubleClick = dc;}
+
+	boolean hasPanelForNode(DefaultMutableTreeNode node) {
+		TreePath path = new TreePath(node.getPath());
+		return panels.containsKey(pStr2Key(path.toString()));
+	}
+
+	TreePanel getPanelForNode(DefaultMutableTreeNode node) {
+		TreePath path = new TreePath(node.getPath());
+		String pathString = path.toString();
+		if (panels.containsKey(pStr2Key(pathString)))
+			return (TreePanel)panels.get(pStr2Key(pathString));
+		//else return newPanel(node);
+		else return null;
+	}
+
+	public DefaultMutableTreeNode getRoot() {return root;}
+
+	Hashtable getPanels() {return panels;}
+
+	Hashtable getTreeCommands() {
+		return treeCommands;
+	}
+
+	boolean hasVisiblePanels() {
+		return visiblePanels.size()>0;
+	}
+
+	int getVisiblePanelsCount() { return visiblePanels.size(); }
+
+
+
+	/* ************************************************************************** */
+	/*                      Properties and panels management                      */
+	/* ************************************************************************** */
+
+	void registerPanel(TreePanel panel) {
+		String key = pStr2Key(panel.getRootPath().toString());
+		panels.put(key,panel);
+		setPanelShowingProperty(panel.getRootPath().toString());
+		propertiesChanged=true;
+	}
+
+	/** All properties related to the ControlPanel have keywords starting with "Control_Panel".
+	 * This is to facilitate the integration of these properties with ImageJ's properties database.
+	 * The keywords are dot-separated lists of tokens; in each token, spaces are relaced by
+	 * underscores. Each token represents a node, and hence the keyword represents a tree path.
+	 * The values can be either:
+	 * <ol>
+	 * <li> a space-separated list of integers,
+	 * indicating panel frame geometry <strong>in the following fixed order:</strong>
+	 * x coordinate, y coordinate , width, height</li>
+	 * <li> or the word "expand" which indicates that the path represented by the keyword is
+	 * an expanded branch
+	 * </li>
+	 * </ol>
+	 *
+	 */
+	void loadProperties() {
+		if (IJ.debugMode) IJ.log("CP.loadProperties");
+		visiblePanels.removeAllElements();
+		expandedNodes.removeAllElements();
+		panels.clear();
+		Properties properties = Prefs.getControlPanelProperties();
+		for (Enumeration e=properties.keys(); e.hasMoreElements();) {
+			String key = (String)e.nextElement();
+			if (key.startsWith(".Control_Panel.")) {
+				key = key.substring(1, key.length());
+				String val = Prefs.get(key, null);
+				if (IJ.debugMode) IJ.log("  "+key+": "+val);
+				if (Character.isDigit(val.charAt(0))) // value starts with digit
+					visiblePanels.addElement(key);
+				else if (val.equals("expand"))
+					expandedNodes.addElement(key);
+			}
+		}
+	}
+
+	void saveProperties() {
+		if (IJ.debugMode) IJ.log("CP.saveProperties: "+propertiesChanged);
+		if (propertiesChanged) {
+			clearProperties();
+			for (Enumeration e=visiblePanels.elements(); e.hasMoreElements();) {
+				String s = (String)e.nextElement();
+				TreePanel p = (TreePanel)panels.get(s);
+				if (p!=null) recordGeometry(p);
+			}
+			for(Enumeration e=expandedNodes.elements(); e.hasMoreElements();)
+				Prefs.set((String)e.nextElement(),"expand");
+		}
+		propertiesChanged=false;
+	}
+	
+	void clearProperties() {
+		Properties properties = Prefs.getControlPanelProperties();
+		for (Enumeration e=properties.keys(); e.hasMoreElements();) {
+			String key = (String)e.nextElement();
+			if (key.startsWith(".Control_Panel."))
+				properties.remove(key);
+		}
+	}
+
+	void setExpandedStateProperty(String item) {
+		String s = pStr2Key(item);
+		expandedNodes.addElement(s);
+		propertiesChanged=true;
+	}
+
+	boolean hasExpandedStateProperty(String item) {
+		String s = pStr2Key(item);
+		return expandedNodes.contains(s);
+	}
+
+	void unsetExpandedStateProperty(String item) {
+		String s = pStr2Key(item);
+		expandedNodes.remove(s);
+		propertiesChanged=true;
+	}
+
+	void setPanelShowingProperty(String item) {
+		String s = pStr2Key(item);
+		if (!(visiblePanels.contains(s)))
+			visiblePanels.addElement(s);
+		propertiesChanged=true;
+	}
+
+	void unsetPanelShowingProperty(String item) {
+		String s = pStr2Key(item);
+		visiblePanels.remove(s);
+	}
+
+	boolean hasPanelShowingProperty(String item) {
+		String s = pStr2Key(item);
+		return visiblePanels.contains(s);
+	}
+
+	void restoreVisiblePanels() {
+		String[] visPanls = new String[visiblePanels.size()];
+		visiblePanels.toArray(visPanls);
+		Arrays.sort(visPanls);
+		for (int i=0; i<visPanls.length; i++) {
+			if (!panels.containsKey(visPanls[i])) {
+				TreePanel p = newPanel(visPanls[i]);
+			}
+		}
+	}
+
+	void recordGeometry(TreePanel panel) {
+		String pTitle = panel.getRootPath().toString();
+		pTitle = pStr2Key(pTitle);
+		JFrame frame = panel.getFrame();
+		if (frame!=null) {
+			Rectangle rect=frame.getBounds();
+			String xCoord = (new Integer(rect.x)).toString();
+			String yCoord = (new Integer(rect.y)).toString();
+			String width = (new Integer(rect.width)).toString();
+			String height = (new Integer(rect.height)).toString();
+			if (pTitle.equals("Control_Panel")) pTitle = "Control_Panel.@Main";
+			String geometry = xCoord+" "+yCoord+" "+width+" "+height;
+			if (IJ.debugMode) IJ.log("CP.recordGeometry: "+pTitle+" "+geometry);
+			Prefs.set(pTitle, geometry);
+		}
+	}
+
+	void restoreGeometry(TreePanel panel) {
+		String pTitle = panel.getRootPath().toString();
+		pTitle = pStr2Key(pTitle);
+		if (pTitle.equals("Control_Panel")) pTitle = "Control_Panel.@Main";
+		if (IJ.debugMode) IJ.log("CP.restoreGeometry: "+pTitle);
+		String geom = Prefs.get(pTitle, null);
+		if (geom!=null) {
+			int[] coords = s2ints(geom);
+			if (coords!=null && coords.length==4)
+				panel.setBounds(coords[0],coords[1],coords[2],coords[3]);
+			else {
+				Point pnt = panel.getDefaultLocation();
+				if (pnt!=null)
+					panel.getFrame().setLocation((int)pnt.getX(),(int)pnt.getY());
+			}
+		}
+	}
+
+	void closeAll(boolean die) {
+		quitting = die;
+		if (!visiblePanels.isEmpty()) {
+			propertiesChanged = true;
+			saveProperties();
+		}
+		for (Enumeration e = panels.elements(); e.hasMoreElements();) {
+			TreePanel p = (TreePanel)e.nextElement();
+			p.close();
+		}
+		//if(quitting) panels.clear();
+		quitting = true;
+	}
+
+	/* **************************************************************************** */
+	/*                              Helper methods                                  */
+	/* **************************************************************************** */
+
+// 	/**Removes the leading "[" and trailing "]" from the argument
+// 	 *  @param s A string with the structure "[item1,item2,...,itemn]", as returned by
+// 	 *  a call to the <code>toString()</code> method in the <code>javax.swing.tree.TreePath</code> class.
+// 	 *  @return A string with the structure "item1,item2,...,itemn".
+// 	 *  @see javax.swing.tree.TreePath
+// 	 */
+// 	String trimPathString(String s)
+// 	{
+// 		int leftBracket = s.indexOf("[");
+// 		int rightBracket = s.indexOf("]");
+// 		return s.substring(leftBracket+1,rightBracket);
+// 	}
+
+	void showHelp() {
+		IJ.showMessage("About Control Panel...",
+		"This plugin displays a panel with ImageJ commands in a hierarchical tree structure.\n"+" \n"+
+		"Usage:\n"+" \n"+
+		"     Click on a leaf node to launch the corresponding ImageJ command (or plugin)\n"+
+		"     (double-click on X Window Systems)\n"+" \n"+
+		"     Double-click on a tree branch node (folder) to expand or collapse it\n"+" \n"+
+		"     Click and drag on a tree branch node (folder) to display its descendants,\n"+
+		"     in a separate (child) panel (\"tear-off\" mock-up)\n"+" \n"+
+		"     In a child panel, use the \"Show Parent\" menu item to re-open the parent panel\n"+
+		"     if it was accidentally closed\n"+" \n"+
+		"Author: Cezar M. Tigaret (c.tigaret@ucl.ac.uk)\n"+
+		"This code is in the public domain."
+		);
+	}
+
+
+	// 1. trim away the eclosing brackets
+	// 2. replace comma-space with dots
+	// 3. replace spaces with underscores
+	String pStr2Key(String pathString) {
+		String keyword = pathString;
+		if(keyword.startsWith("["))
+			keyword = keyword.substring(keyword.indexOf("[")+1,keyword.length());
+		if(keyword.endsWith("]"))
+			keyword = keyword.substring(0,keyword.lastIndexOf("]"));
+		StringTokenizer st = new StringTokenizer(keyword,",");
+		String result = "";
+		while(st.hasMoreTokens()) {
+			String token  = st.nextToken();
+			if(token.startsWith(" ")) token = token.substring(1,token.length()); // remove leading space
+			result+=token+".";
+		}
+		result = result.substring(0,result.length()-1);//remove trailing dot
+		result = result.replace(' ','_');
+		return result;
+	}
+
+	String key2pStr(String keyword) {
+		//keyword = keyword.replace('_',' '); // restore the spaces from underscores
+		StringTokenizer st = new StringTokenizer(keyword,".");
+		String result = "";
+		while(st.hasMoreTokens()) {
+			String token = st.nextToken();
+			result += token +", ";
+		}
+		result = result.substring(0,result.length()-2); // trim away the ending comma-space
+		result = "["+result+"]";
+		result = result.replace('_', ' ');
+		return result;
+	}
+
+
+	// Thank you, Wayne!
+	/** Breaks the specified string into an array
+	 of ints. Returns null if there is an error.*/
+	public int[] s2ints(String s) {
+		StringTokenizer st = new StringTokenizer(s, ", \t");
+		int nInts = st.countTokens();
+            if (nInts==0) return null;
+		int[] ints = new int[nInts];
+		for(int i=0; i<nInts; i++) {
+			try {ints[i] = Integer.parseInt(st.nextToken());}
+			catch (NumberFormatException e) {return null;}
+		}
+		return ints;
+	}
+
+	//boolean isRunning(){return running;}
+
+} // ControlPanel
+
+
+/**TreePanel.
+*
+*
+* <br>
+* This class lays out the ImageJ user plugins in a vertical, hierarchical tree.. Plugins are launched by double-clicking on their names, in the vertical tree.
+*
+* Advantages: uses less screen estate, and provides a realistic graphical presentation of the plugins installed in the file system.<br>
+*
+* Created: Thu Nov 23 02:12:12 2000
+* @see ControlPanel
+* @author Cezar M. Tigaret <c.tigaret@ucl.ac.uk>
+* @version 1.0f
+*/
+
+
+class TreePanel implements
+	ActionListener, WindowListener, TreeExpansionListener, TreeWillExpandListener {
+
+	ControlPanel pcp;
+	//Vector childrenPanels = new Vector();
+	boolean isMainPanel;
+	String title;
+	boolean isDragging=false;
+	//boolean requireDoubleClick=false;
+	Point defaultLocation;
+
+	private JTree pTree;
+	private JMenuBar pMenuBar;
+	private DefaultMutableTreeNode root;
+	private DefaultMutableTreeNode draggingNode=null;
+	private DefaultTreeModel pTreeModel;
+	private ActionListener listener;
+	private JFrame pFrame;
+	private JCheckBoxMenuItem pMenu_saveOnClose, pMenu_noClutter;
+	private TreePath rootPath;
+
+	// the "up" arrow
+	private static final int _uparrow1_data[] = {
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x0d,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x0d,0x01,0x01,0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x01,0x0e,0x02,0x01,0x03,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x01,0x0e,0x04,0x05,0x06,0x01,0x07,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x08,0x04,0x09,0x0e,0x02,0x06,0x01,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x08,0x04,0x09,0x0e,0x0e,0x0e,
+    0x02,0x06,0x01,0x00,0x00,0x00,0x00,0x00,0x08,0x08,0x04,0x09,0x0e,0x0e,
+    0x0e,0x0e,0x0e,0x02,0x06,0x02,0x00,0x00,0x00,0x08,0x0a,0x0e,0x08,0x0a,
+    0x0b,0x0b,0x0c,0x0c,0x0c,0x0c,0x0c,0x06,0x02,0x00,0x0e,0x01,0x01,0x01,
+    0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x0e,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+    0x00,0x00,0x00,0x00
+	};
+
+	private static final int _uparrow1_ctable[] = {
+    0x21,0xff000000,0xff303030,0xffaaaaaa,0xffffffff,0xff3c3c3c,0xff252525,0xffb6b6b6,0xff585858,0xffc3c3c3,0xff222222,0xff2b2b2b,0xff2e2e2e,0xffa0a0a0,
+    0xff808080
+	};
+
+	private static IndexColorModel iconCM = new IndexColorModel(8,_uparrow1_ctable.length,_uparrow1_ctable,0,true,255,DataBuffer.TYPE_BYTE);
+	private static final ImageIcon upIcon = new ImageIcon( Toolkit.getDefaultToolkit().createImage(new MemoryImageSource(16,16,iconCM,_uparrow1_data,0,16)));
+
+	public TreePanel (DefaultMutableTreeNode root, ControlPanel pcp, boolean isMainPanel) {
+		new TreePanel(root,pcp,isMainPanel,null);
+	}
+
+	public TreePanel(DefaultMutableTreeNode root, ControlPanel pcp, boolean isMainPanel, Point location) {
+		this.root=root;
+		this.pcp=pcp;
+		this.isMainPanel = isMainPanel;
+		defaultLocation = location;
+		rootPath=new TreePath(root.getPath());
+		title = (String)root.getUserObject();
+		buildTreePanel();
+		pcp.registerPanel(this);
+	}
+
+	/* ************************************************************************** */
+	/*                              GUI factories                                 */
+	/* ************************************************************************** */
+
+	public void buildTreePanel() {
+		pFrame=new JFrame(title);
+		pFrame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);
+		pTreeModel = new DefaultTreeModel(root);
+		pTree=new JTree(pTreeModel);
+		pTree.setEditable(false);
+		pTree.putClientProperty("JTree.lineStyle","Angled");
+		pTree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
+		pTree.setRootVisible(false);
+		pTree.setShowsRootHandles(true);
+		//pTree.setDragEnabled(true);
+		JScrollPane ptView=new JScrollPane(pTree);
+		addMenu();
+		pFrame.getContentPane().add(ptView, BorderLayout.CENTER);
+		addListeners();
+		pFrame.pack();
+		if (defaultLocation!=null) {
+			if (IJ.debugMode) IJ.log("CP.buildTreePanel: "+defaultLocation);
+			pFrame.setLocation(defaultLocation.x, defaultLocation.y);
+		} else
+			pcp.restoreGeometry(this);
+		//restoreExpandedNodes();
+		if (pFrame.getLocation().x==0)
+			GUI.center(pFrame);
+		setVisible();
+		ImageJ ij = IJ.getInstance();
+		ij.addWindowListener(this);
+		pFrame.addKeyListener(ij);
+		pTree.addKeyListener(ij);
+	}
+
+	void addMenu() {
+		pMenuBar=new JMenuBar();
+		Insets ins = new Insets(0,0,0,10);
+		pMenuBar.setMargin(ins);
+		if (isMainPanel) {
+			JMenuItem helpMI = new JMenuItem("Help");
+			helpMI.addActionListener(this);
+			helpMI.setActionCommand("Help");
+			pMenuBar.add(helpMI);
+/*			if(pcp.reloadMI!=null)
+			{
+				pcp.reloadMI.addActionListener(this);
+				pMenuBar.add(pcp.reloadMI);
+			}*/
+		}
+		else {
+			JMenuItem spMI = new JMenuItem("Show Parent",upIcon);
+			spMI.addActionListener(this);
+			spMI.setActionCommand("Show Parent");
+			pMenuBar.add(spMI);
+		}
+		pFrame.setJMenuBar(pMenuBar);
+	}
+
+	void addListeners() {
+		addActionListener(this);
+		pFrame.addWindowListener(this);
+		pFrame.addComponentListener(new ComponentAdapter() {
+			public void componentMoved(ComponentEvent e) {
+				Rectangle r = e.getComponent().getBounds();
+				if (IJ.debugMode) IJ.log("CP.componentMoved: "+r);
+				if (r.x>0) {
+					defaultLocation = new Point(r.x, r.y);
+					recordGeometry();
+				}
+			}
+		});
+		pTree.addMouseListener(new MouseAdapter() {
+			public void mouseClicked(MouseEvent e) {
+				isDragging = false;
+				if (e.getClickCount()!=2)
+					return;
+				int selRow=pTree.getRowForLocation(e.getX(),e.getY());
+				if (selRow!=-1) toAction();
+			}
+
+			public void mouseReleased(MouseEvent e) {
+				if (isDragging) {
+					Point pnt = new Point(e.getX(), e.getY());
+					SwingUtilities.convertPointToScreen(pnt,pTree);
+					tearOff(null,pnt);
+				}
+				isDragging = false;
+			}
+		});
+		pTree.addMouseMotionListener(new MouseMotionAdapter()
+		{
+			public void mouseDragged(MouseEvent e)
+			{
+				int selRow = pTree.getRowForLocation(e.getX(), e.getY());
+				if(selRow!=-1)
+				{
+					if(((DefaultMutableTreeNode)pTree.getLastSelectedPathComponent()).isLeaf()) return;
+					pFrame.setCursor(new Cursor(Cursor.MOVE_CURSOR));
+					isDragging = true;
+				}
+			}
+		});
+		pTree.addTreeExpansionListener(this);
+		pTree.addTreeWillExpandListener(this);
+	}
+
+	/* ************************************************************************** */
+	/*              Accessors -- see also Properties management section           */
+	/* ************************************************************************** */
+
+	public String getTitle() {return title;}
+
+	public TreePath getRootPath() {return rootPath;}
+
+	public boolean isTheMainPanel() {return isMainPanel;}
+
+	public JFrame getFrame() {return pFrame;}
+
+	public JTree getTree() {return pTree;}
+
+	public DefaultMutableTreeNode getRootNode() {return root;}
+
+	public Point getDefaultLocation() {return defaultLocation;}
+
+	/* ************************************************************************** */
+	/*                        Properties managmenent                              */
+	/* ************************************************************************** */
+
+	boolean isVisible() {
+		return pFrame.isVisible();
+	}
+
+	void setBounds(int x, int y, int w, int h) {
+		pFrame.setBounds(new Rectangle(x,y,w,h));
+		defaultLocation = new Point(x,y);
+	}
+
+	void setAutoSaveProps(boolean autoSave) {
+		if(isTheMainPanel()) pMenu_saveOnClose.setSelected(autoSave);
+	}
+
+	boolean getAutoSaveProps() {return pMenu_saveOnClose.isSelected();}
+
+	void restoreExpandedNodes() {
+		if (pTree==null || root==null)
+			return;
+		pTree.removeTreeExpansionListener(this);
+		TreeNode[] rootPath = root.getPath();
+		for(Enumeration e = root.breadthFirstEnumeration(); e.hasMoreElements();)
+		//for(Enumeration e = root.children(); e.hasMoreElements();)
+		{
+			DefaultMutableTreeNode node = (DefaultMutableTreeNode)e.nextElement();
+			if(!node.isLeaf() && node != root)
+			{
+				TreeNode[] nodePath = node.getPath();
+				TreePath nTreePath = new TreePath(nodePath);
+				String npS = nTreePath.toString();
+				DefaultMutableTreeNode[] localPath = new DefaultMutableTreeNode[nodePath.length-rootPath.length+1];
+				for(int i=0; i<localPath.length; i++)
+				{
+					localPath[i]=(DefaultMutableTreeNode)nodePath[i+rootPath.length-1];
+				}
+				TreePath newPath = new TreePath(localPath);
+				if(pcp.hasExpandedStateProperty(npS) && !pcp.hasPanelShowingProperty(npS))
+				{
+					if(newPath!=null)
+					{
+						try
+						{
+							pTree.expandPath(newPath);
+						}catch(Throwable t){}
+					}
+				}
+				else if((pcp.hasExpandedStateProperty(npS) || pTree.isExpanded(newPath)) && pcp.hasPanelShowingProperty(npS))
+				{
+					pTree.collapsePath(newPath);
+					pcp.unsetExpandedStateProperty(npS);
+				}
+			}
+		}
+		pTree.addTreeExpansionListener(this);
+	}
+
+	/* ************************************************************************** */
+	/*                        AWT and Swing events manangement                    */
+	/* ************************************************************************** */
+
+	public void processEvent(ActionEvent e) {
+		if (listener != null) listener.actionPerformed(e);
+	}
+
+	public void addActionListener(ActionListener al) {
+			listener=AWTEventMulticaster.add(listener, al);
+	}
+
+	public void removeActionListener(ActionListener al) {
+			listener=AWTEventMulticaster.remove(listener, al);
+	}
+
+	public void actionPerformed(ActionEvent e) {
+			String cmd=e.getActionCommand();
+			if(cmd==null) return;
+			if (cmd.equals("Help")) {
+				showHelp();
+				return;
+			}
+			if(cmd.equals("Show Parent")) {
+				DefaultMutableTreeNode parent = (DefaultMutableTreeNode)root.getParent();
+				if (parent!=null) {
+					TreePanel panel = pcp.getPanelForNode(parent);
+					if(panel==null) panel = pcp.newPanel(parent);
+					if(panel!=null) panel.setVisible();
+				}
+				return;
+			}
+			if(cmd.equals("Reload Plugins From Panel")) {// cmd fired by clicking on tree leaf
+				pcp.closeAll(false);
+				IJ.doCommand("Reload Plugins");
+			}
+			else {
+				if(cmd.equals("Reload Plugins")) // cmd fired from ImageJ menu; don't propagate it further
+					pcp.closeAll(false);
+				else
+					IJ.doCommand(cmd);
+				return;
+			}
+	}
+
+	// we implement window listener directly so that we can catch ImageJ's window events
+	/** Upon window closing, the panel removes itself from the vector of visible panels (member of pcp).
+	 * Then, if this is the only visible panel left, the properties are saved; else, if this is the
+	 * main panel, all other visible panels are also closed and properties
+	 * are saved
+	 */
+	public void windowClosing(WindowEvent e) {
+		if (IJ.debugMode) IJ.log("CP.windowClosing: "+isMainPanel);
+		if (isMainPanel)
+			pcp.saveProperties();
+		pcp.unsetPanelShowingProperty(getRootPath().toString());
+	}
+
+	public void windowActivated(WindowEvent e) {
+		WindowManager.setWindow(getFrame());
+	}
+	
+	public void windowClosed(WindowEvent e) {}
+	public void windowDeactivated(WindowEvent e) {}
+	public void windowDeiconified(WindowEvent e) {}
+	public void windowIconified(WindowEvent e) {}
+	public void windowOpened(WindowEvent e) {}
+
+
+	public void treeCollapsed (TreeExpansionEvent ev) {
+		String evPathString = ev.getPath().toString();
+		evPathString = evPathString.substring(evPathString.indexOf("[")+1,evPathString.lastIndexOf("]"));
+		evPathString = evPathString.substring(getTitle().length()+2,evPathString.length());
+		String rootPath = getRootPath().toString();
+		rootPath = rootPath.substring(rootPath.indexOf("[")+1,rootPath.lastIndexOf("]"));
+		String path = "["+rootPath +", "+evPathString+"]";
+		pcp.unsetExpandedStateProperty(path);
+	}
+
+	public void treeExpanded(TreeExpansionEvent ev) {
+		TreePath evPath = ev.getPath();
+		//DefaultMutableTreeNode node = (DefaultMutableTreeNode)evPath.getLastPathComponent();
+		String evPathString = ev.getPath().toString();
+		evPathString = pcp.pStr2Key(evPathString);
+		evPathString = evPathString.substring(getTitle().length()+1,evPathString.length());
+		String rootPath = getRootPath().toString();
+		rootPath = pcp.pStr2Key(rootPath);
+		//String path = rootPath+"."+evPathString;
+		String path = rootPath+"."+evPathString;
+		if (pcp.hasPanelShowingProperty(path)) {
+			Hashtable panels = pcp.getPanels();
+			TreePanel p = (TreePanel)panels.get(path);
+			if(p!=null) p.close();
+		}
+		pcp.setExpandedStateProperty(path);
+	}
+
+	//stub for future development
+	public void treeWillExpand(TreeExpansionEvent ev) {}
+	//stub for future development
+	public void treeWillCollapse(TreeExpansionEvent ev) {}
+
+	void recordGeometry() {pcp.recordGeometry(this);}
+
+	/* ************************************************************************** */
+	/*                             Actions                                        */
+	/* ************************************************************************** */
+
+	void refreshTree() {
+		pTreeModel.reload();
+	}
+
+	void tearOff() {
+		tearOff(null);
+	}
+
+	void tearOff(DefaultMutableTreeNode node) {
+		tearOff(node, null);
+	}
+
+	void tearOff(DefaultMutableTreeNode node, Point pnt) {
+		isDragging = false;
+		pFrame.setCursor(Cursor.getDefaultCursor());
+		if(node==null)
+			node = (DefaultMutableTreeNode)pTree.getLastSelectedPathComponent();
+		if(node.isLeaf()) return;
+		TreeNode[] nPath = node.getPath();
+		TreeNode[] rPath = root.getPath();
+		DefaultMutableTreeNode[] tPath = new DefaultMutableTreeNode[nPath.length-rPath.length+1];
+		for(int i=0; i<tPath.length; i++)
+			tPath[i] = (DefaultMutableTreeNode)nPath[i+rPath.length-1];
+		TreePath path = new TreePath(nPath);
+		TreePath localPath = new TreePath(tPath);
+		String pathString = localPath.toString();
+		TreePanel p = pcp.getPanelForNode(node);
+		if (p==null) {
+			if(pnt!=null)
+				p = pcp.newPanel(node, pnt);
+			else
+				p = pcp.newPanel(node);
+			pTree.collapsePath(localPath);
+		} else {
+			if (pnt!=null)
+				p.setLocation(pnt);
+			p.setVisible();
+			pTree.collapsePath(localPath);
+		}
+	}
+
+	/** Fires an ActionEvent upon double-click on the plugin item (leaf node) in the JTree */
+	void toAction() {
+			DefaultMutableTreeNode nde=(DefaultMutableTreeNode)pTree.getLastSelectedPathComponent();
+			// if the node has children then do nothing (return)
+			if (nde.getChildCount()>0) return;
+			String aCmd=nde.toString();
+			String cmd= aCmd;
+			if(pcp.treeCommands.containsKey(aCmd))
+				cmd = (String)pcp.treeCommands.get(aCmd);
+			processEvent(new ActionEvent(this,ActionEvent.ACTION_PERFORMED,cmd));
+	}
+
+	void setVisible() {
+		if (pFrame!=null && !pFrame.isVisible()) {
+			restoreExpandedNodes();
+			if (defaultLocation!=null) pFrame.setLocation(defaultLocation);
+			pFrame.setVisible(true);
+			// close expanded path to this panel in its parent panel (if visible and if the path is expanded)
+			DefaultMutableTreeNode parent = (DefaultMutableTreeNode)root.getParent();
+			if (parent!=null) {
+				TreePanel pnl = pcp.getPanelForNode(parent);
+				if (pnl!=null && pnl.isVisible()) {
+					TreeNode[] rPath = root.getPath();
+					TreeNode[] pPath = pnl.getRootNode().getPath();
+					DefaultMutableTreeNode[] tPath = new DefaultMutableTreeNode[rPath.length-pPath.length+1];
+					for(int i=0; i<tPath.length; i++)
+						tPath[i] = (DefaultMutableTreeNode)rPath[i+pPath.length-1];
+					//TreePath path = new TreePath(rPath);
+					TreePath localPath = new TreePath(tPath);
+					pnl.getTree().collapsePath(localPath);
+				}
+			}
+		}
+		if (pcp!=null) pcp.setPanelShowingProperty(getRootPath().toString());
+	}
+
+	void setLocation(Point p) {
+		if (p!=null) defaultLocation = p;
+	}
+
+	void close() {
+		pFrame.dispatchEvent(new WindowEvent(pFrame,WindowEvent.WINDOW_CLOSING));
+		pcp.unsetPanelShowingProperty(getRootPath().toString());
+	}
+
+	private void showHelp() {pcp.showHelp();}
+
+} // TreePanel
+
+
diff --git a/src/ij/plugin/Converter.java b/src/ij/plugin/Converter.java
new file mode 100644
index 0000000..06d02f3
--- /dev/null
+++ b/src/ij/plugin/Converter.java
@@ -0,0 +1,187 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+
+/** Implements the conversion commands in the Image/Type submenu. */
+public class Converter implements PlugIn {
+
+	/** obsolete */
+	public static boolean newWindowCreated;
+	private ImagePlus imp;
+
+	public void run(String arg) {
+		imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			if ("RGB Color".equals(arg))
+				imp.setProp(LUT.nameKey,null);
+			if (imp.isComposite() && arg.equals("RGB Color") && !imp.getStack().isRGB() && !imp.getStack().isHSB() && !imp.getStack().isLab()) {
+				if (imp.getWindow()==null && !ij.macro.Interpreter.isBatchMode())
+					RGBStackConverter.convertToRGB(imp);
+				else {
+					(new RGBStackConverter()).run("");
+					imp.setTitle(imp.getTitle()); // updates size in Window menu
+				}
+			} else if (imp.lock()) {
+				convert(arg);
+				imp.unlock();
+				imp.setTitle(imp.getTitle());
+			} else 
+				IJ.log("<<Converter: image is locked ("+imp+")>>");
+		} else
+			IJ.noImage();
+	}
+
+	/** Converts the ImagePlus to the specified image type. The string
+	argument corresponds to one of the labels in the Image/Type submenu
+	("8-bit", "16-bit", "32-bit", "8-bit Color", "RGB Color", "RGB Stack", "HSB Stack", "Lab Stack" or "HSB (32-bit)"). */
+	public void convert(String item) {
+		int type = imp.getType();
+		ImageStack stack = null;
+		if (imp.getStackSize()>1)
+			stack = imp.getStack();
+		String msg = "Converting to " + item;
+		IJ.showStatus(msg + "...");
+	 	long start = System.currentTimeMillis();
+	 	Roi roi = imp.getRoi();
+	 	imp.deleteRoi();
+	 	if (imp.isThreshold())
+			imp.getProcessor().resetThreshold();
+	 	boolean saveChanges = imp.changes;
+		imp.changes = IJ.getApplet()==null; //if not applet, set 'changes' flag
+	 	ImageWindow win = imp.getWindow();
+		try {
+ 			if (stack!=null) {
+ 				boolean wasVirtual = stack.isVirtual();
+				// do stack conversions
+		    	if (stack.isRGB() && item.equals("RGB Color")) {
+					new ImageConverter(imp).convertRGBStackToRGB();
+					if (win!=null) new ImageWindow(imp, imp.getCanvas()); // replace StackWindow with ImageWindow
+		    	} else if (stack.isHSB() && item.equals("RGB Color")) {
+					new ImageConverter(imp).convertHSBToRGB();
+					if (win!=null) new ImageWindow(imp, imp.getCanvas());
+		    	} else if (stack.isHSB32() && item.equals("RGB Color")) {
+					new ImageConverter(imp).convertHSB32ToRGB();
+					if (win!=null) new ImageWindow(imp, imp.getCanvas());
+		    	} else if (stack.isLab() && item.equals("RGB Color")) {
+					new ImageConverter(imp).convertLabToRGB();
+					if (win!=null) new ImageWindow(imp, imp.getCanvas());
+				} else if (item.equals("8-bit"))
+					new StackConverter(imp).convertToGray8();
+				else if (item.equals("16-bit"))
+					new StackConverter(imp).convertToGray16();
+				else if (item.equals("32-bit"))
+					new ImageConverter(imp).convertToGray32();
+				else if (item.equals("RGB Color"))
+					new StackConverter(imp).convertToRGB();
+				else if (item.equals("RGB Stack"))
+					new StackConverter(imp).convertToRGBHyperstack();
+				else if (item.equals("HSB Stack"))
+					new StackConverter(imp).convertToHSBHyperstack();
+				else if (item.equals("HSB (32-bit)"))
+					new StackConverter(imp).convertToHSB32Hyperstack();
+				else if (item.equals("Lab Stack"))
+					new StackConverter(imp).convertToLabHyperstack();
+		    	else if (item.equals("8-bit Color")) {
+		    		int nColors = getNumber();
+		    		if (nColors!=0)
+						new StackConverter(imp).convertToIndexedColor(nColors);
+				} else throw new IllegalArgumentException();
+				if (wasVirtual) imp.setTitle(imp.getTitle());
+			} else {
+				// do single image conversions
+				Undo.setup(Undo.TYPE_CONVERSION, imp);
+		    	ImageConverter ic = new ImageConverter(imp);
+				if (item.equals("8-bit"))
+					ic.convertToGray8();
+				else if (item.equals("16-bit"))
+					ic.convertToGray16();
+				else if (item.equals("32-bit"))
+					ic.convertToGray32();
+				else if (item.equals("RGB Stack")) {
+			    	Undo.reset(); // Reversible; no need for Undo
+					ic.convertToRGBStack();
+		    	} else if (item.equals("HSB Stack")) {
+			    	Undo.reset();
+					ic.convertToHSB();
+		    	} else if (item.equals("HSB (32-bit)")) {
+			    	Undo.reset();
+					ic.convertToHSB32();
+		    	} else if (item.equals("Lab Stack")) {
+			    	Undo.reset();
+					ic.convertToLab();
+		    	} else if (item.equals("RGB Color")) {
+					ic.convertToRGB();
+		    	} else if (item.equals("8-bit Color")) {
+		    		int nColors = getNumber();
+		 			start = System.currentTimeMillis();
+					if (nColors!=0)
+						ic.convertRGBtoIndexedColor(nColors);
+				} else {
+					imp.changes = saveChanges;
+					return;
+				}
+				IJ.showProgress(1.0);
+			}
+			if ("RGB Color".equals(item))
+				imp.setProp(LUT.nameKey,null);
+		}
+		catch (IllegalArgumentException e) {
+			unsupportedConversion(imp);
+			IJ.showStatus("");
+	    	Undo.reset();
+	    	imp.changes = saveChanges;
+			Menus.updateMenus();
+			Macro.abort();
+			return;
+		}
+		if (roi!=null)
+			imp.setRoi(roi);
+		IJ.showTime(imp, start, "");
+		imp.repaintWindow();
+		Menus.updateMenus();
+	}
+
+	void unsupportedConversion(ImagePlus imp) {
+		IJ.error("Converter",
+			"Supported Conversions:\n" +
+			" \n" +
+			"8-bit -> 16-bit*\n" +
+			"8-bit -> 32-bit*\n" +
+			"8-bit -> RGB Color*\n" +
+			"16-bit -> 8-bit*\n" +
+			"16-bit -> 32-bit*\n" +
+			"16-bit -> RGB Color*\n" +
+			"32-bit -> 8-bit*\n" +
+			"32-bit -> 16-bit\n" +
+			"32-bit -> RGB Color*\n" +
+			"8-bit Color -> 8-bit (grayscale)*\n" +
+			"8-bit Color -> RGB Color\n" +
+			"RGB -> 8-bit (grayscale)*\n" +
+			"RGB -> 8-bit Color*\n" +
+			"RGB -> RGB Stack*\n" +
+			"RGB -> HSB Stack*\n" +
+			"RGB -> Lab Stack\n" +
+			"RGB Stack -> RGB Color\n" +
+			"HSB Stack -> RGB Color\n" +
+			" \n" +
+			"* works with stacks\n"
+			);
+	}
+
+	int getNumber() {
+		if (imp.getType()!=ImagePlus.COLOR_RGB)
+			return 256;
+		GenericDialog gd = new GenericDialog("MedianCut");
+		gd.addNumericField("Number of Colors (2-256):", 256, 0);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return 0;
+		int n = (int)gd.getNextNumber();
+		if (n<2) n = 2;
+		if (n>256) n = 256;
+		return n;
+	}
+		
+}
diff --git a/src/ij/plugin/Coordinates.java b/src/ij/plugin/Coordinates.java
new file mode 100644
index 0000000..0a6f728
--- /dev/null
+++ b/src/ij/plugin/Coordinates.java
@@ -0,0 +1,187 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import ij.plugin.frame.Recorder;
+import java.awt.AWTEvent;
+import java.awt.geom.Rectangle2D;
+
+/**
+ * The plugin implements the Image/Adjust/Coordinates command. It allows
+ * the user to set the corner coordinates of the selection bounds or the full image.
+ * This modifies the image scale (pixelWidth, pixelHeight) and the xOrigin, yOrigin.
+ * If a single point is selected, the coordinates of the point can be specified, which only
+ * sets the xOrigin and yOrigin.
+ * Units for x and y can be also selected (2016-08-30, Michael Schmid).
+ * Z unit of stacks can be selected (2019-09-30, Stein Rorvik).
+ */
+ 
+public class Coordinates implements PlugIn, DialogListener {
+
+	private static final String help = "<html>"
+	+"<h1>Image&gt;Adjust&gt;Coordinates</h1>"
+	+"<font size=+1>"
+	+"This command allows the user to set the corner coordinates of<br>the selection bounds "
+	+"or the full image. This modifies the image<br>scale (<i>pixelWidth</i>, <i>pixelHeight</i>) and <i>xOrigin</i> and <i>yOrigin</i>. "
+	+"If a<br>single point is selected, the coordinates of the point can be<br>specified, which only "
+	+"sets <i>xOrigin</i> and <i>yOrigin</i>. The units for X<br>and Y can be also selected.<br> "
+	+"</font>";
+
+	private final static String SAME_AS_X = "<same as x unit>";
+	private final static int IMAGE = 0, ROI_BOUNDS = 1, POINT = 2;	//mode: coordinates of what to specify
+	private int mode = IMAGE;
+	private boolean isStack;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		int imageHeight = imp.getHeight();
+		Calibration cal = imp.getCalibration();
+		Roi roi = imp.getRoi();
+		Rectangle2D.Double bounds = null;
+		int numSlices = imp.getNSlices();
+		int currSlice = imp.getCurrentSlice();
+		isStack = numSlices>1;
+		if (roi != null) {
+			bounds = roi.getFloatBounds();
+			if (bounds.width==0 && bounds.height==0)
+				mode = POINT;
+			else
+				mode = ROI_BOUNDS;
+		} else {	//no Roi, use image bounds
+			bounds = new Rectangle2D.Double(0, 0, imp.getWidth(), imp.getHeight());
+		}
+		String title = (mode==IMAGE ? "Image" : "Selection") +" Coordinates";
+		if (mode == POINT)
+			title = "Point Coordinates";
+		GenericDialog gd = new GenericDialog(title);
+		if (mode == POINT) {
+			gd.addNumericField("X:", cal.getX(bounds.x), 2, 8, "");
+			gd.addNumericField("Y:", cal.getY(bounds.y, imageHeight), 2, 8, "");
+			if (isStack)
+				gd.addNumericField("Z:", cal.getZ(currSlice-1), 2, 8, "");
+		} else {
+			gd.addNumericField("Left:", cal.getX(bounds.x), 2, 8, "");
+			gd.addNumericField("Right:", cal.getX(bounds.x+bounds.width), 2, 8, "");
+			gd.addNumericField("Top:", cal.getY(bounds.y, imageHeight), 2, 8, "");
+			gd.addNumericField("Bottom:", cal.getY(bounds.y+bounds.height, imageHeight), 2, 8, "");
+			if (isStack) {
+				gd.addNumericField("Front:", cal.getZ(0), 2, 8, "");
+				gd.addNumericField("Back:", cal.getZ(numSlices), 2, 8, "");
+			}
+		}
+		String xUnit = cal.getUnit();
+		String yUnit = cal.getYUnit();
+		String zUnit = cal.getZUnit();
+		boolean xUnitChanged=false,yUnitChanged=false,zUnitChanged=false;
+		gd.addStringField("X_unit:", xUnit, 18);
+		gd.addStringField("Y_unit:", yUnit.equals(xUnit) ? SAME_AS_X : yUnit, 18);
+		if (isStack)
+			gd.addStringField("Z_unit:", zUnit.equals(xUnit) ? SAME_AS_X : zUnit, 18);
+		gd.addHelp(help);
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		if (mode == POINT) {
+			double x = gd.getNextNumber();
+			double y = gd.getNextNumber();
+			if (gd.invalidNumber()) {
+				IJ.error("Invalid number");
+				return;
+			}
+			cal.xOrigin = coordinate2offset(x, bounds.x, cal.pixelWidth);
+			cal.yOrigin = coordinate2offset(y, bounds.y, cal.getInvertY() ? -cal.pixelHeight : cal.pixelHeight);
+			if (isStack) {
+				double z = gd.getNextNumber();
+				if (gd.invalidNumber()) {
+					IJ.error("Invalid number");
+					return;
+				}
+				cal.zOrigin = coordinate2offset(z, currSlice-1, cal.pixelDepth);
+			}
+		} else {
+			double xl = gd.getNextNumber();
+			double xr = gd.getNextNumber();
+			double yt = gd.getNextNumber();
+			double yb = gd.getNextNumber();
+			if (gd.invalidNumber()) {
+				IJ.error("Invalid number");
+				return;
+			}
+			cal.pixelWidth = (xr-xl)/bounds.width;
+			cal.pixelHeight = (yb-yt)/bounds.height;
+			cal.xOrigin = coordinate2offset(xl, bounds.x, cal.pixelWidth);
+			cal.yOrigin = coordinate2offset(yt, bounds.y, cal.pixelHeight);
+			cal.setInvertY(cal.pixelHeight < 0);
+			if (isStack) {
+				double zf = gd.getNextNumber();
+				double zl = gd.getNextNumber();
+				cal.pixelDepth = (zl-zf)/numSlices;
+				cal.zOrigin = coordinate2offset(zf, 0, cal.pixelDepth);	
+			}
+			if (cal.pixelHeight < 0)
+				cal.pixelHeight = -cal.pixelHeight;
+		}
+		String xUnit2 = gd.getNextString();
+		xUnitChanged = !xUnit2.equals(xUnit);
+		if (xUnitChanged)
+			cal.setXUnit(xUnit2);
+		String yUnit2 = gd.getNextString();
+		yUnitChanged = !yUnit2.equals(yUnit) && !yUnit2.equals(SAME_AS_X);
+		if (yUnitChanged)
+			cal.setYUnit(yUnit2);
+		String zUnit2 = null;
+		if (isStack) {
+			zUnit2 = gd.getNextString();
+			zUnitChanged = !zUnit2.equals(zUnit) && !zUnit2.equals(SAME_AS_X);
+			if (zUnitChanged)
+				cal.setZUnit(zUnit2);
+		}
+		ImageWindow win = imp.getWindow();
+		imp.repaintWindow();
+		if (Recorder.record) {
+			if (Recorder.scriptMode()) {
+				if (xUnitChanged)
+					Recorder.recordCall("imp.getCalibration().setXUnit(\""+xUnit2+"\");", true);
+				if (yUnitChanged)
+					Recorder.recordCall("imp.getCalibration().setYUnit(\""+yUnit2+"\");", true);
+				if (zUnitChanged)
+					Recorder.recordCall("imp.getCalibration().setZUnit(\""+zUnit2+"\");", true);
+			} else {
+				if (xUnitChanged)
+					Recorder.record("Stack.setXUnit", xUnit2);
+				if (yUnitChanged)
+					Recorder.record("Stack.setYUnit", yUnit2);
+				if (zUnitChanged)
+					Recorder.record("Stack.setZUnit", zUnit2);
+			}
+		}
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (mode == POINT) {
+			gd.getNextNumber();
+			gd.getNextNumber();
+			if (isStack)
+				gd.getNextNumber();
+			return (!gd.invalidNumber());
+		} else {
+			double xl = gd.getNextNumber();
+			double xr = gd.getNextNumber();
+			double yt = gd.getNextNumber();
+			double yb = gd.getNextNumber();
+			if (isStack) {
+				double zf = gd.getNextNumber();
+				double zl = gd.getNextNumber();
+				return (!gd.invalidNumber() && (xr>xl) && (yt!=yb) && (zl>zf));
+			} else
+				return (!gd.invalidNumber() && xr>xl && yt!=yb);
+		}
+	}
+
+	// Calculates pixel offset from scaled coordinates of a point with given pixel position
+	private double coordinate2offset(double coordinate, double pixelPos, double pixelSize) {
+		return	pixelPos - coordinate/pixelSize;
+	}
+
+}
\ No newline at end of file
diff --git a/src/ij/plugin/DICOM.java b/src/ij/plugin/DICOM.java
new file mode 100644
index 0000000..04effb5
--- /dev/null
+++ b/src/ij/plugin/DICOM.java
@@ -0,0 +1,1727 @@
+package ij.plugin;
+import java.io.*;
+import java.util.*;
+import java.net.URL;
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import ij.util.Tools;
+import ij.measure.Calibration;
+
+/** This plugin decodes DICOM files. If 'arg' is empty, it
+	displays a file open dialog and opens and displays the 
+	image selected by the user. If 'arg' is a path, it opens the 
+	specified image and the calling routine can display it using
+	"((ImagePlus)IJ.runPlugIn("ij.plugin.DICOM", path)).show()".
+	*/
+
+/* RAK (Richard Kirk, rak@cre.canon.co.uk) changes 14/7/99
+
+   InputStream.skip() looped to check the actual number of
+   bytes is read.
+
+   Big/little-endian options on element length.
+
+   Explicit check for each known VR to make mistaken identifications
+   of explicit VR's less likely.
+
+   Variables b1..b4 renamed as b0..b3.
+
+   Increment of 4 to offset on (7FE0,0010) tag removed.
+
+   Queries on some other unrecognized tags.
+   Anyone want to claim them?
+
+   RAK changes 15/7/99
+
+   Bug fix on magic values for explicit VRs with 32-bit lengths.
+
+   Various bits of tidying up, including...
+   'location' incremented on read using getByte() or getString().
+   simpler debug mode message generation (values no longer reported).
+
+   Added z pixel aspect ratio support for multi-slice DICOM volumes.
+   Michael Abramoff, 31-10-2000
+
+   Added DICOM tags to the dictionary (now contains about 2700 tags).
+   implemented getDouble() for VR = FD (Floating Double) and getFloat()
+   for VR = FL (Floating Single).
+   Extended case statement in getHeaderInfo to retrieve FD and FL values.
+   Johannes Hermen, Christian Moll, 25-04-2008
+
+   */
+
+public class DICOM extends ImagePlus implements PlugIn {
+	private boolean showErrors = true;
+	private boolean gettingInfo;
+	private BufferedInputStream inputStream;
+	private String info;
+	
+	/** Default constructor. */
+	public DICOM() {
+	}
+
+	/** Constructs a DICOM reader that using an InputStream. Here 
+		is an example that shows how to open and display a DICOM:
+		<pre>
+		DICOM dcm = new DICOM(is);
+		dcm.run("Name");
+		dcm.show();
+		<pre>
+	*/
+	public DICOM(InputStream is) {
+		this(new BufferedInputStream(is));
+	}
+
+	/** Constructs a DICOM reader that using an BufferredInputStream. */
+	public DICOM(BufferedInputStream bis) {
+		inputStream = bis;
+	}
+
+	public void run(String arg) {
+		OpenDialog od = new OpenDialog("Open Dicom...", arg);
+		String directory = od.getDirectory();
+		String fileName = od.getFileName();
+		if (fileName==null)
+			return;
+		DicomDecoder dd = new DicomDecoder(directory, fileName);
+		dd.inputStream = inputStream;
+		FileInfo fi = null;
+		try {
+			fi = dd.getFileInfo();
+		} catch (IOException e) {
+			String msg = e.getMessage();
+			IJ.showStatus("");
+			if (msg.indexOf("EOF")<0&&showErrors) {
+				IJ.error("DICOM Reader", e.getClass().getName()+"\n \n"+msg);
+				return;
+			} else if (!dd.dicmFound()&&showErrors) {
+				msg = "This does not appear to be a valid\n"
+				+ "DICOM file. It does not have the\n"
+				+ "characters 'DICM' at offset 128.";
+				IJ.error("DICOM Reader", msg);
+				return;
+			}
+		}
+		if (gettingInfo) {
+			info = dd.getDicomInfo();
+			return;
+		}
+		if (fi!=null && fi.width>0 && fi.height>0 && fi.offset>0) {
+			FileOpener fo = new FileOpener(fi);
+			ImagePlus imp = fo.openImage();
+			// Avoid opening as float even if slope != 1.0 in case ignoreRescaleSlope or fixedDicomScaling
+			// were checked in the DICOM preferences.
+			boolean openAsFloat = (dd.rescaleSlope!=1.0 && !(Prefs.ignoreRescaleSlope || Prefs.fixedDicomScaling)) 
+				|| Prefs.openDicomsAsFloat;
+			String options = Macro.getOptions();
+			if (openAsFloat) {
+				IJ.run(imp, "32-bit", "");
+				if (dd.rescaleSlope!=1.0)
+					IJ.run(imp, "Multiply...", "value="+dd.rescaleSlope+" stack");
+				if (dd.rescaleIntercept!=0.0)
+					IJ.run(imp, "Add...", "value="+dd.rescaleIntercept+" stack");
+				if (imp.getStackSize()>1) {
+				    imp.setSlice(imp.getStackSize()/2);
+					ImageStatistics stats = imp.getRawStatistics();
+					imp.setDisplayRange(stats.min,stats.max);
+				}
+			} else if (fi.fileType==FileInfo.GRAY16_SIGNED) {
+				if (dd.rescaleIntercept!=0.0 && (dd.rescaleSlope==1.0||Prefs.fixedDicomScaling)) {
+					double[] coeff = new double[2];
+					coeff[0] = dd.rescaleSlope*(-32768) + dd.rescaleIntercept;
+					coeff[1] = dd.rescaleSlope;
+					imp.getCalibration().setFunction(Calibration.STRAIGHT_LINE, coeff, "Gray Value");
+				}
+			} else if (dd.rescaleIntercept!=0.0 && 
+					  (dd.rescaleSlope==1.0||Prefs.fixedDicomScaling||fi.fileType==FileInfo.GRAY8)) {
+				double[] coeff = new double[2];
+				coeff[0] = dd.rescaleIntercept;
+				coeff[1] = dd.rescaleSlope;
+				imp.getCalibration().setFunction(Calibration.STRAIGHT_LINE, coeff, "Gray Value");
+			}
+			Macro.setOptions(options);
+			if (dd.windowWidth>0.0) {
+				double min = dd.windowCenter-dd.windowWidth/2;
+				double max = dd.windowCenter+dd.windowWidth/2;
+				if (!openAsFloat) {
+					Calibration cal = imp.getCalibration();
+					min = cal.getRawValue(min);
+					max = cal.getRawValue(max);
+				}
+				ImageProcessor ip = imp.getProcessor();
+				ip.setMinAndMax(min, max);
+				if (IJ.debugMode) IJ.log("window: "+min+"-"+max);
+			}
+			if (imp.getStackSize()>1)
+				setStack(fileName, imp.getStack());
+			else
+				setProcessor(fileName, imp.getProcessor());
+			setCalibration(imp.getCalibration());
+			setProperty("Info", dd.getDicomInfo());
+			setFileInfo(fi); // needed for revert
+			if (arg.equals("")) show();
+		} else if (showErrors)
+			IJ.error("DICOM Reader","Unable to decode DICOM header.");
+		IJ.showStatus("");
+	}
+
+	/** Opens the specified file as a DICOM. Does not 
+		display a message if there is an error.
+		Here is an example:
+		<pre>
+		DICOM dcm = new DICOM();
+		dcm.open(path);
+		if (dcm.getWidth()==0)
+			IJ.log("Error opening '"+path+"'");
+		else
+			dcm.show();
+		</pre>
+	*/
+	public void open(String path) {
+		showErrors = false;
+		run(path);
+	}
+	
+	/** Returns the DICOM tags of the specified file as a string. */ 
+	public String getInfo(String path) {
+		showErrors = false;
+		gettingInfo = true;
+		run(path);
+		return info;
+	}
+
+	/** Convert 16-bit signed to unsigned if all pixels>=0. */
+	void convertToUnsigned(ImagePlus imp, FileInfo fi) {
+		ImageProcessor ip = imp.getProcessor();
+		short[] pixels = (short[])ip.getPixels();
+		int min = Integer.MAX_VALUE;
+		int value;
+		for (int i=0; i<pixels.length; i++) {
+			value = pixels[i]&0xffff;
+			if (value<min)
+				min = value;
+		}
+		if (IJ.debugMode) IJ.log("min: "+(min-32768));
+		if (min>=32768) {
+			for (int i=0; i<pixels.length; i++)
+				pixels[i] = (short)(pixels[i]-32768);
+			ip.resetMinAndMax();
+			Calibration cal = imp.getCalibration();
+			cal.setFunction(Calibration.NONE, null, "Gray Value");
+			fi.fileType = FileInfo.GRAY16_UNSIGNED;
+		}
+	}
+	
+	/** Returns the name of the specified DICOM tag id. */
+	public static String getTagName(String id) {
+		id = id.replaceAll(",", "");
+		DicomDictionary d = new DicomDictionary();
+		Properties dictionary = d.getDictionary();
+		String name = (String)dictionary.get(id);
+		if (name!=null)
+			name = name.substring(2);
+		return name;
+	}
+
+}
+
+
+class DicomDecoder {
+
+	private static final int PIXEL_REPRESENTATION = 0x00280103;
+	private static final int TRANSFER_SYNTAX_UID = 0x00020010;
+	private static final int MODALITY = 0x00080060;
+	private static final int SLICE_THICKNESS = 0x00180050;
+	private static final int SLICE_SPACING = 0x00180088;
+	private static final int IMAGER_PIXEL_SPACING = 0x00181164;
+	private static final int SAMPLES_PER_PIXEL = 0x00280002;
+	private static final int PHOTOMETRIC_INTERPRETATION = 0x00280004;
+	private static final int PLANAR_CONFIGURATION = 0x00280006;
+	private static final int NUMBER_OF_FRAMES = 0x00280008;
+	private static final int ROWS = 0x00280010;
+	private static final int COLUMNS = 0x00280011;
+	private static final int PIXEL_SPACING = 0x00280030;
+	private static final int BITS_ALLOCATED = 0x00280100;
+	private static final int WINDOW_CENTER = 0x00281050;
+	private static final int WINDOW_WIDTH = 0x00281051;	
+	private static final int RESCALE_INTERCEPT = 0x00281052;
+	private static final int RESCALE_SLOPE = 0x00281053;
+	private static final int RED_PALETTE = 0x00281201;
+	private static final int GREEN_PALETTE = 0x00281202;
+	private static final int BLUE_PALETTE = 0x00281203;
+	private static final int ACQUISITION_CONTEXT_SEQUENCE = 0x00400555;
+	private static final int VIEW_CODE_SEQUENCE = 0x00540220;
+	private static final int ICON_IMAGE_SEQUENCE = 0x00880200;
+	private static final int ITEM = 0xFFFEE000;
+	private static final int ITEM_DELIMINATION = 0xFFFEE00D;
+	private static final int SEQUENCE_DELIMINATION = 0xFFFEE0DD;
+	private static final int FLOAT_PIXEL_DATA = 0x7FE00008;
+	private static final int PIXEL_DATA = 0x7FE00010;
+
+	private static final int AE=0x4145, AS=0x4153, AT=0x4154, CS=0x4353, DA=0x4441, DS=0x4453, DT=0x4454,
+		FD=0x4644, FL=0x464C, IS=0x4953, LO=0x4C4F, LT=0x4C54, PN=0x504E, SH=0x5348, SL=0x534C, 
+		SS=0x5353, ST=0x5354, TM=0x544D, UI=0x5549, UL=0x554C, US=0x5553, UT=0x5554,
+		OB=0x4F42, OW=0x4F57, SQ=0x5351, UN=0x554E, QQ=0x3F3F,
+		OF=0x4F46, OL=0x4F4C, OD=0x4F44, UC=0x5543, UR=0x5552, OV=0x4F56, SV=0x5356, UV=0x5556;
+		
+		
+	private static Properties dictionary;
+
+	private String directory, fileName;
+	private static final int ID_OFFSET = 128;  //location of "DICM"
+	private static final String DICM = "DICM";
+	
+	private BufferedInputStream f;
+	private int location = 0;
+	private boolean littleEndian = true;
+	
+	private int elementLength;
+	private int vr;  // Value Representation
+	private static final int IMPLICIT_VR = 0x2D2D; // '--' 
+	private byte[] vrLetters = new byte[2];
+ 	private int previousGroup;
+ 	private String previousInfo;
+ 	private StringBuffer dicomInfo = new StringBuffer(1000);
+ 	private boolean dicmFound; // "DICM" found at offset 128
+ 	private boolean oddLocations;  // one or more tags at odd locations
+ 	private boolean bigEndianTransferSyntax = false;
+	double windowCenter, windowWidth;
+	double rescaleIntercept, rescaleSlope=1.0;
+	boolean inSequence;
+ 	BufferedInputStream inputStream;
+ 	String modality;
+ 	private boolean acquisitionSequence;
+
+	public DicomDecoder(String directory, String fileName) {
+		this.directory = directory;
+		this.fileName = fileName;
+		String path = null;
+		if (dictionary==null && IJ.getApplet()==null) {
+			path = Prefs.getImageJDir()+"DICOM_Dictionary.txt";
+			File f = new File(path);
+			if (f.exists()) try {
+				dictionary = new Properties();
+				InputStream is = new BufferedInputStream(new FileInputStream(f));
+				dictionary.load(is);
+				is.close();
+				if (IJ.debugMode) IJ.log("DicomDecoder: using "+dictionary.size()+" tag dictionary at "+path);
+			} catch (Exception e) {
+				dictionary = null;
+			}
+		}
+		if (dictionary==null) {
+			DicomDictionary d = new DicomDictionary();
+			dictionary = d.getDictionary();
+			if (IJ.debugMode) IJ.log("DicomDecoder: "+path+" not found; using "+dictionary.size()+" tag built in dictionary");
+		}
+	}
+  
+	String getString(int length) throws IOException {
+		byte[] buf = new byte[length];
+		int pos = 0;
+		while (pos<length) {
+			int count = f.read(buf, pos, length-pos);
+			if (count==-1)
+				throw new IOException("unexpected EOF");
+			pos += count;
+		}
+		location += length;
+		return new String(buf);
+	}
+  
+	String getUNString(int length) throws IOException {
+		String s = getString(length);
+		if (s!=null && s.length()>60)
+			s = s.substring(0,60);
+		return s;
+	}
+
+	int getByte() throws IOException {
+		int b = f.read();
+		if (b ==-1)
+			throw new IOException("unexpected EOF");
+		++location;
+		return b;
+	}
+
+	int getShort() throws IOException {
+		int b0 = getByte();
+		int b1 = getByte();
+		if (littleEndian)
+			return ((b1 << 8) + b0);
+		else
+			return ((b0 << 8) + b1);
+	}
+	
+	int getSShort() throws IOException {
+		short b0 = (short)getByte();
+		short b1 = (short)getByte();
+		if (littleEndian)
+			return ((b1 << 8) + b0);
+		else
+			return ((b0 << 8) + b1);
+	}
+  
+	final int getInt() throws IOException {
+		int b0 = getByte();
+		int b1 = getByte();
+		int b2 = getByte();
+		int b3 = getByte();
+		if (littleEndian)
+			return ((b3<<24) + (b2<<16) + (b1<<8) + b0);
+		else
+			return ((b0<<24) + (b1<<16) + (b2<<8) + b3);
+	}
+	
+	long getUInt() throws IOException {
+		long b0 = getByte();
+		long b1 = getByte();
+		long b2 = getByte();
+		long b3 = getByte();
+		if (littleEndian)
+			return ((b3<<24) + (b2<<16) + (b1<<8) + b0);
+		else
+			return ((b0<<24) + (b1<<16) + (b2<<8) + b3);
+	}
+
+	double getDouble() throws IOException {
+		int b0 = getByte();
+		int b1 = getByte();
+		int b2 = getByte();
+		int b3 = getByte();
+		int b4 = getByte();
+		int b5 = getByte();
+		int b6 = getByte();
+		int b7 = getByte();
+		long res = 0;
+		if (littleEndian) {
+			res += b0;
+			res += ( ((long)b1) << 8);
+			res += ( ((long)b2) << 16);
+			res += ( ((long)b3) << 24);
+			res += ( ((long)b4) << 32);
+			res += ( ((long)b5) << 40);
+			res += ( ((long)b6) << 48);
+			res += ( ((long)b7) << 56);         
+		} else {
+			res += b7;
+			res += ( ((long)b6) << 8);
+			res += ( ((long)b5) << 16);
+			res += ( ((long)b4) << 24);
+			res += ( ((long)b3) << 32);
+			res += ( ((long)b2) << 40);
+			res += ( ((long)b1) << 48);
+			res += ( ((long)b0) << 56);
+		}
+		return Double.longBitsToDouble(res);
+	}
+    
+	float getFloat() throws IOException {
+		int b0 = getByte();
+		int b1 = getByte();
+		int b2 = getByte();
+		int b3 = getByte();
+		int res = 0;
+		if (littleEndian) {
+			res += b0;
+			res += ( ((long)b1) << 8);
+			res += ( ((long)b2) << 16);
+			res += ( ((long)b3) << 24);     
+		} else {
+			res += b3;
+			res += ( ((long)b2) << 8);
+			res += ( ((long)b1) << 16);
+			res += ( ((long)b0) << 24);
+		}
+		return Float.intBitsToFloat(res);
+	}
+  
+	byte[] getLut(int length) throws IOException {
+		if ((length&1)!=0) { // odd
+			String dummy = getString(length);
+			return null;
+		}
+		length /= 2;
+		byte[] lut = new byte[length];
+		for (int i=0; i<length; i++)
+			lut[i] = (byte)(getShort()>>>8);
+		return lut;
+	}
+  
+  	int getLength() throws IOException {
+		int b0 = getByte();
+		int b1 = getByte();
+		int b2 = getByte();
+		int b3 = getByte();
+		
+		// We cannot know whether the VR is implicit or explicit
+		// without the full DICOM Data Dictionary for public and
+		// private groups.
+		
+		// We will assume the VR is explicit if the two bytes
+		// match the known codes. It is possible that these two
+		// bytes are part of a 32-bit length for an implicit VR.
+		
+		vr = (b0<<8) + b1;
+		
+		switch (vr) {
+			case OB: case OW: case SQ: case UN: case UT:
+			case OF: case OL: case OD: case UC: case UR: 
+			case OV: case SV: case UV:
+				// Explicit VR with 32-bit length if other two bytes are zero
+				if ( (b2 == 0) || (b3 == 0) ) return getInt();
+				// Implicit VR with 32-bit length
+				vr = IMPLICIT_VR;
+				if (littleEndian)
+					return ((b3<<24) + (b2<<16) + (b1<<8) + b0);
+				else
+					return ((b0<<24) + (b1<<16) + (b2<<8) + b3);
+			case AE: case AS: case AT: case CS: case DA: case DS: case DT:  case FD:
+			case FL: case IS: case LO: case LT: case PN: case SH: case SL: case SS:
+			case ST: case TM: case UI: case UL: case US: case QQ:
+				// Explicit vr with 16-bit length
+				if (littleEndian)
+					return ((b3<<8) + b2);
+				else
+					return ((b2<<8) + b3);
+			default:
+				// Implicit VR with 32-bit length...
+				vr = IMPLICIT_VR;
+				if (littleEndian)
+					return ((b3<<24) + (b2<<16) + (b1<<8) + b0);
+				else
+					return ((b0<<24) + (b1<<16) + (b2<<8) + b3);
+		}
+	}
+
+	int getNextTag() throws IOException {
+		int groupWord = getShort();
+		if (groupWord==0x0800 && bigEndianTransferSyntax) {
+			littleEndian = false;
+			groupWord = 0x0008;
+		}
+		int elementWord = getShort();
+		int tag = groupWord<<16 | elementWord;
+		elementLength = getLength();
+		
+		// hack needed to read some GE files
+		// The element length must be even!
+		if (elementLength==13 && !oddLocations) elementLength = 10; 
+		
+		// "Undefined" element length.
+		// This is a sort of bracket that encloses a sequence of elements.
+		if (elementLength==-1) {
+			elementLength = 0;
+			inSequence = true;
+		}
+ 		//IJ.log("getNextTag: "+tag+" "+elementLength);
+		return tag;
+	}
+  
+	FileInfo getFileInfo() throws IOException {
+		long skipCount;
+		FileInfo fi = new FileInfo();
+		int bitsAllocated = 16;
+		fi.fileFormat = fi.RAW;
+		fi.fileName = fileName;
+		if (directory.indexOf("://")>0) { // is URL
+			URL u = new URL(directory+fileName);
+			inputStream = new BufferedInputStream(u.openStream());
+			fi.inputStream = inputStream;
+		} else if (inputStream!=null)
+			fi.inputStream = inputStream;
+		else
+			fi.directory = directory;
+		fi.width = 0;
+		fi.height = 0;
+		fi.offset = 0;
+		fi.intelByteOrder = true;
+		fi.fileType = FileInfo.GRAY16_UNSIGNED;
+		fi.fileFormat = FileInfo.DICOM;
+		int samplesPerPixel = 1;
+		int planarConfiguration = 0;
+		String photoInterpretation = "";
+				
+		if (inputStream!=null) {
+			// Use large buffer to allow URL stream to be reset after reading header
+			f = inputStream;
+			f.mark(400000);
+		} else
+			f = new BufferedInputStream(new FileInputStream(directory + fileName));
+		if (IJ.debugMode) {
+			IJ.log("");
+			IJ.log("DicomDecoder: decoding "+fileName);
+		}
+		
+		int[] bytes = new int[ID_OFFSET];
+		for (int i=0; i<ID_OFFSET; i++)
+			bytes[i] = getByte();
+		
+		if (!getString(4).equals(DICM)) {
+			if (!((bytes[0]==8||bytes[0]==2) && bytes[1]==0 && bytes[3]==0))
+				throw new IOException("This is not a DICOM or ACR/NEMA file");
+			if (inputStream==null) f.close();
+			if (inputStream!=null)
+				f.reset();
+			else
+				f = new BufferedInputStream(new FileInputStream(directory + fileName));
+			location = 0;
+			if (IJ.debugMode) IJ.log(DICM + " not found at offset "+ID_OFFSET+"; reseting to offset 0");
+		} else {
+			dicmFound = true;
+			if (IJ.debugMode) IJ.log(DICM + " found at offset " + ID_OFFSET);
+		}
+		
+		boolean decodingTags = true;
+		boolean signed = false;
+		
+		while (decodingTags) {
+			int tag = getNextTag();
+			if ((location&1)!=0) // DICOM tags must be at even locations
+				oddLocations = true;
+			if (inSequence && !acquisitionSequence) {
+				addInfo(tag, null);
+				continue;
+			}
+			String s;
+			switch (tag) {
+				case TRANSFER_SYNTAX_UID:
+					s = getString(elementLength);
+					addInfo(tag, s);
+					if (s.indexOf("1.2.4")>-1||s.indexOf("1.2.5")>-1) {
+						f.close();
+						String msg = "ImageJ cannot open compressed DICOM images.\n \n";
+						msg += "Transfer Syntax UID = "+s;
+						throw new IOException(msg);
+					}
+					if (s.indexOf("1.2.840.10008.1.2.2")>=0)
+						bigEndianTransferSyntax = true;
+					break;
+				case MODALITY:
+					modality = getString(elementLength);
+					addInfo(tag, modality);
+					break;
+				case NUMBER_OF_FRAMES:
+					s = getString(elementLength);
+					addInfo(tag, s);
+					double frames = s2d(s);
+					if (frames>1.0)
+						fi.nImages = (int)frames;
+					break;
+				case SAMPLES_PER_PIXEL:
+					samplesPerPixel = getShort();
+					addInfo(tag, samplesPerPixel);
+					break;
+				case PHOTOMETRIC_INTERPRETATION:
+					photoInterpretation = getString(elementLength);
+					addInfo(tag, photoInterpretation);
+					break;
+				case PLANAR_CONFIGURATION:
+					planarConfiguration = getShort();
+					addInfo(tag, planarConfiguration);
+					break;
+				case ROWS:
+					fi.height = getShort();
+					addInfo(tag, fi.height);
+					break;
+				case COLUMNS:
+					fi.width = getShort();
+					addInfo(tag, fi.width);
+					break;
+				case IMAGER_PIXEL_SPACING: case PIXEL_SPACING:
+					String scale = getString(elementLength);
+					getSpatialScale(fi, scale);
+					addInfo(tag, scale);
+					break;
+				case SLICE_THICKNESS: case SLICE_SPACING:
+					String spacing = getString(elementLength);
+					fi.pixelDepth = s2d(spacing);
+					addInfo(tag, spacing);
+					break;
+				case BITS_ALLOCATED:
+					bitsAllocated = getShort();
+					if (bitsAllocated==8)
+						fi.fileType = FileInfo.GRAY8;
+					else if (bitsAllocated==32)
+						fi.fileType = FileInfo.GRAY32_UNSIGNED;
+					addInfo(tag, bitsAllocated);
+					break;
+				case PIXEL_REPRESENTATION:
+					int pixelRepresentation = getShort();
+					if (pixelRepresentation==1) {
+						fi.fileType = FileInfo.GRAY16_SIGNED;
+						signed = true;
+					}
+					addInfo(tag, pixelRepresentation);
+					break;
+				case WINDOW_CENTER:
+					String center = getString(elementLength);
+					int index = center.indexOf('\\');
+					if (index!=-1) center = center.substring(index+1);
+					windowCenter = s2d(center);
+					addInfo(tag, center);
+					break;
+				case WINDOW_WIDTH:
+					String width = getString(elementLength);
+					index = width.indexOf('\\');
+					if (index!=-1) width = width.substring(index+1);
+					windowWidth = s2d(width);
+					addInfo(tag, width);
+					break;
+				case RESCALE_INTERCEPT:
+					String intercept = getString(elementLength);
+					rescaleIntercept = s2d(intercept);
+					addInfo(tag, intercept);
+					break;
+				case RESCALE_SLOPE:
+					String slop = getString(elementLength);
+					rescaleSlope = s2d(slop);
+					addInfo(tag, slop);
+					break;
+				case RED_PALETTE:
+					fi.reds = getLut(elementLength);
+					addInfo(tag, elementLength/2);
+					break;
+				case GREEN_PALETTE:
+					fi.greens = getLut(elementLength);
+					addInfo(tag, elementLength/2);
+					break;
+				case BLUE_PALETTE:
+					fi.blues = getLut(elementLength);
+					addInfo(tag, elementLength/2);
+					break;
+				case FLOAT_PIXEL_DATA:
+					fi.fileType = FileInfo.GRAY32_FLOAT;
+					// continue without break
+				case PIXEL_DATA:
+					// Start of image data...
+					if (elementLength!=0) {
+						fi.offset = location;
+						addInfo(tag, location);
+						decodingTags = false;
+					} else
+						addInfo(tag, null);
+					break;
+				case 0x7F880010:
+					// What is this? - RAK
+					if (elementLength!=0) {
+						fi.offset = location+4;
+						decodingTags = false;
+					}
+					break;
+				default:
+					// Not used, skip over it...
+					addInfo(tag, null);
+			}
+		} // while(decodingTags)
+		
+		if (fi.fileType==FileInfo.GRAY8) {
+			if (fi.reds!=null && fi.greens!=null && fi.blues!=null
+			&& fi.reds.length==fi.greens.length
+			&& fi.reds.length==fi.blues.length) {
+				fi.fileType = FileInfo.COLOR8;
+				fi.lutSize = fi.reds.length;
+				
+			}
+		}
+				
+		if (fi.fileType==FileInfo.GRAY32_UNSIGNED && signed)
+			fi.fileType = FileInfo.GRAY32_INT;
+
+		if (samplesPerPixel==3 && photoInterpretation.startsWith("RGB")) {
+			if (planarConfiguration==0)
+				fi.fileType = FileInfo.RGB;
+			else if (planarConfiguration==1)
+				fi.fileType = FileInfo.RGB_PLANAR;
+		} else if (photoInterpretation.endsWith("1 "))
+				fi.whiteIsZero = true;
+				
+		if (!littleEndian)
+			fi.intelByteOrder = false;
+		
+		if (IJ.debugMode) {
+			IJ.log("width: " + fi.width);
+			IJ.log("height: " + fi.height);
+			IJ.log("images: " + fi.nImages);
+			IJ.log("bits allocated: " + bitsAllocated);
+			IJ.log("offset: " + fi.offset);
+		}
+	
+		if (inputStream!=null)
+			f.reset();
+		else
+			f.close();
+		return fi;
+	}
+	
+	String getDicomInfo() {
+		String s = new String(dicomInfo);
+		char[] chars = new char[s.length()];
+		s.getChars(0, s.length(), chars, 0);
+		for (int i=0; i<chars.length; i++) {
+			if (chars[i]<' ' && chars[i]!='\n') chars[i] = ' ';
+		}
+		return new String(chars);
+	}
+
+	void addInfo(int tag, String value) throws IOException {
+		String info = getHeaderInfo(tag, value);
+		if (inSequence && info!=null && vr!=SQ) info = ">" + info;
+		if (info!=null &&  tag!=ITEM) {
+			int group = tag>>>16;
+			//if (group!=previousGroup && (previousInfo!=null&&previousInfo.indexOf("Sequence:")==-1))
+			//	dicomInfo.append("\n");
+			previousGroup = group;
+			previousInfo = info;
+			dicomInfo.append(tag2hex(tag)+info+"\n");
+		}
+		if (IJ.debugMode) {
+			if (info==null) info = "";
+			vrLetters[0] = (byte)(vr >> 8);
+			vrLetters[1] = (byte)(vr & 0xFF);
+			String VR = new String(vrLetters);
+			IJ.log("(" + tag2hex(tag) + VR
+			+ " " + elementLength
+			+ " bytes from "
+			+ (location-elementLength)+") "
+			+ info);
+		}
+	}
+
+	void addInfo(int tag, int value) throws IOException {
+		addInfo(tag, Integer.toString(value));
+	}
+
+	String getHeaderInfo(int tag, String value) throws IOException {
+		if (tag==ITEM_DELIMINATION || tag==SEQUENCE_DELIMINATION) {
+			inSequence = false;
+			if (!IJ.debugMode) return null;
+		}
+		String key = i2hex(tag);
+		//while (key.length()<8)
+		//	key = '0' + key;
+		String id = (String)dictionary.get(key);
+		if (id!=null) {
+			if (vr==IMPLICIT_VR && id!=null)
+				vr = (id.charAt(0)<<8) + id.charAt(1);
+			id = id.substring(2);
+		}
+		if (tag==ITEM)
+			return id!=null?id+":":null;
+		if (value!=null)
+			return id+": "+value;
+		switch (vr) {
+			case FD:
+				if (elementLength==8)
+					value = Double.toString(getDouble());
+				else
+					for (int i=0; i<elementLength; i++) getByte();
+				break;
+			case FL:
+				if (elementLength==4)
+					value = Float.toString(getFloat());
+				else
+					for (int i=0; i<elementLength; i++) getByte();
+				break;
+			//case UT:
+				//throw new IOException("ImageJ cannot read UT (unlimited text) DICOMs");
+			case AE: case AS: case AT: case CS: case DA: case DS: case DT:  case IS: case LO: 
+			case LT: case PN: case SH: case ST: case TM: case UI:
+				value = getString(elementLength);
+				break;
+			case UN:
+				value = getUNString(elementLength);
+				break;
+			case US:
+				if (elementLength==2)
+					value = Integer.toString(getShort());
+				else {
+					int n = elementLength/2;
+					StringBuilder sb = new StringBuilder();
+					for (int i=0; i<n; i++) {
+						sb.append(Integer.toString(getShort()));
+						sb.append(" ");
+					}
+					value = sb.toString();
+				}
+				break;
+			case SS:
+				if (elementLength==2)
+					value = Integer.toString(getSShort());
+				else {
+					int n = elementLength/2;
+					StringBuilder sb = new StringBuilder();
+					for (int i=0; i<n; i++) {
+						sb.append(Integer.toString(getSShort()));
+						sb.append(" ");
+					}
+					value = sb.toString();
+				}
+				break;
+			case UL:
+				if (elementLength==4)
+					value = Long.toString(getUInt());
+				else {
+					int n = elementLength/4;
+					StringBuilder sb = new StringBuilder();
+					for (int i=0; i<n; i++) {
+						sb.append(Long.toString(getUInt()));
+						sb.append(" ");
+					}
+					value = sb.toString();
+				}
+				break;
+			case SL:
+				if (elementLength==4)
+					value = Long.toString(getInt());
+				else {
+					int n = elementLength/4;
+					StringBuilder sb = new StringBuilder();
+					for (int i=0; i<n; i++) {
+						sb.append(Long.toString(getInt()));
+						sb.append(" ");
+					}
+					value = sb.toString();
+				}
+				break;
+			case IMPLICIT_VR:
+				value = getString(elementLength);
+				if (elementLength>44) value=null;
+				break;
+			case SQ:
+				value = "";
+				if (tag==ACQUISITION_CONTEXT_SEQUENCE)
+					acquisitionSequence = true;
+				if (tag==VIEW_CODE_SEQUENCE)
+					acquisitionSequence = false;
+				boolean privateTag = ((tag>>16)&1)!=0;
+				if (tag!=ICON_IMAGE_SEQUENCE && !privateTag)
+					break;
+				// else fall through and skip icon image sequence or private sequence
+			default:
+				long skipCount = (long)elementLength;
+				while (skipCount > 0) skipCount -= f.skip(skipCount);
+				location += elementLength;
+				value = "";
+		}
+		if (value!=null && id==null && !value.equals(""))
+			return "---: "+value;
+		else if (id==null)
+			return null;
+		else
+			return id+": "+value;
+	}
+
+	static char[] buf8 = new char[8];
+	
+	/** Converts an int to an 8 byte hex string. */
+	String i2hex(int i) {
+		for (int pos=7; pos>=0; pos--) {
+			buf8[pos] = Tools.hexDigits[i&0xf];
+			i >>>= 4;
+		}
+		return new String(buf8);
+	}
+
+	char[] buf10;
+	
+	String tag2hex(int tag) {
+		if (buf10==null) {
+			buf10 = new char[11];
+			buf10[4] = ',';
+			buf10[9] = ' ';
+		}
+		int pos = 8;
+		while (pos>=0) {
+			buf10[pos] = Tools.hexDigits[tag&0xf];
+			tag >>>= 4;
+			pos--;
+			if (pos==4) pos--; // skip coma
+		}
+		return new String(buf10);
+	}
+	
+ 	double s2d(String s) {
+ 		if (s==null) return 0.0;
+ 		if (s.startsWith("\\"))
+ 			s = s.substring(1);
+		Double d;
+		try {d = new Double(s);}
+		catch (NumberFormatException e) {d = null;}
+		if (d!=null)
+			return(d.doubleValue());
+		else
+			return(0.0);
+	}
+  
+	void getSpatialScale(FileInfo fi, String scale) {
+		double xscale=0, yscale=0;
+		int i = scale.indexOf('\\');
+		if (i>0) {
+			yscale = s2d(scale.substring(0, i));
+			xscale = s2d(scale.substring(i+1));
+		}
+		if (xscale!=0.0 && yscale!=0.0) {
+			fi.pixelWidth = xscale;
+			fi.pixelHeight = yscale;
+			fi.unit = "mm";
+		}
+	}
+	
+	boolean dicmFound() {
+		return dicmFound;
+	}
+
+}
+
+
+class DicomDictionary {
+
+	Properties getDictionary() {
+		Properties p = new Properties();
+		for (int i=0; i<dict.length; i++) {
+			p.put(dict[i].substring(0,8), dict[i].substring(9));
+		}
+		return p;
+	}
+
+	String[] dict = {
+		"00020002=UIMedia Storage SOP Class UID", 
+		"00020003=UIMedia Storage SOP Inst UID",
+		"00020010=UITransfer Syntax UID",
+		"00020012=UIImplementation Class UID",
+		"00020013=SHImplementation Version Name",
+		"00020016=AESource Application Entity Title",
+		
+		"00080005=CSSpecific Character Set",
+		"00080008=CSImage Type",
+		"00080010=CSRecognition Code",
+		"00080012=DAInstance Creation Date",
+		"00080013=TMInstance Creation Time",
+		"00080014=UIInstance Creator UID",
+		"00080016=UISOP Class UID",
+		"00080018=UISOP Instance UID",
+		"00080020=DAStudy Date",
+		"00080021=DASeries Date",
+		"00080022=DAAcquisition Date",
+		"00080023=DAImage Date",
+		"00080024=DAOverlay Date",
+		"00080025=DACurve Date",
+		"00080030=TMStudy Time",
+		"00080031=TMSeries Time",
+		"00080032=TMAcquisition Time",
+		"00080033=TMImage Time",
+		"00080034=TMOverlay Time",
+		"00080035=TMCurve Time",
+		"00080040=USData Set Type",
+		"00080041=LOData Set Subtype",
+		"00080042=CSNuclear Medicine Series Type",
+		"00080050=SHAccession Number",
+		"00080052=CSQuery/Retrieve Level",
+		"00080054=AERetrieve AE Title",
+		"00080058=AEFailed SOP Instance UID List",
+		"00080060=CSModality",
+		"00080064=CSConversion Type",
+		"00080068=CSPresentation Intent Type",
+		"00080070=LOManufacturer",
+		"00080080=LOInstitution Name",
+		"00080081=STInstitution Address",
+		"00080082=SQInstitution Code Sequence",
+		"00080090=PNReferring Physician's Name",
+		"00080092=STReferring Physician's Address",
+		"00080094=SHReferring Physician's Telephone Numbers",
+		"00080100=SHCode Value",
+		"00080102=SHCoding Scheme Designator",
+		"00080104=LOCode Meaning",
+		"00080201=SHTimezone Offset From UTC",
+		"00081010=SHStation Name",
+		"00081030=LOStudy Description",
+		"00081032=SQProcedure Code Sequence",
+		"0008103E=LOSeries Description",
+		"00081040=LOInstitutional Department Name",
+		"00081048=PNPhysician(s) of Record",
+		"00081050=PNAttending Physician's Name",
+		"00081060=PNName of Physician(s) Reading Study",
+		"00081070=PNOperator's Name",
+		"00081080=LOAdmitting Diagnoses Description",
+		"00081084=SQAdmitting Diagnosis Code Sequence",
+		"00081090=LOManufacturer's Model Name",
+		"00081100=SQReferenced Results Sequence",
+		"00081110=SQReferenced Study Sequence",
+		"00081111=SQReferenced Study Component Sequence",
+		"00081115=SQReferenced Series Sequence",
+		"00081120=SQReferenced Patient Sequence",
+		"00081125=SQReferenced Visit Sequence",
+		"00081130=SQReferenced Overlay Sequence",
+		"00081140=SQReferenced Image Sequence",
+		"00081145=SQReferenced Curve Sequence",
+		"00081150=UIReferenced SOP Class UID",
+		"00081155=UIReferenced SOP Instance UID",
+		"00082111=STDerivation Description",
+		"00082112=SQSource Image Sequence",
+		"00082120=SHStage Name",
+		"00082122=ISStage Number",
+		"00082124=ISNumber of Stages",
+		"00082129=ISNumber of Event Timers",
+		"00082128=ISView Number",
+		"0008212A=ISNumber of Views in Stage",
+		"00082130=DSEvent Elapsed Time(s)",
+		"00082132=LOEvent Timer Name(s)",
+		"00082142=ISStart Trim",
+		"00082143=ISStop Trim",
+		"00082144=ISRecommended Display Frame Rate",
+		"00082200=CSTransducer Position",
+		"00082204=CSTransducer Orientation",
+		"00082208=CSAnatomic Structure",
+		
+		"00100010=PNPatient's Name",
+		"00100020=LOPatient ID",
+		"00100021=LOIssuer of Patient ID",
+		"00100030=DAPatient's Birth Date",
+		"00100032=TMPatient's Birth Time",
+		"00100040=CSPatient's Sex",
+		"00101000=LOOther Patient IDs",
+		"00101001=PNOther Patient Names",
+		"00101005=PNPatient's Maiden Name",
+		"00101010=ASPatient's Age",
+		"00101020=DSPatient's Size",
+		"00101030=DSPatient's Weight",
+		"00101040=LOPatient's Address",
+		"00102150=LOCountry of Residence",
+		"00102152=LORegion of Residence",
+		"00102180=SHOccupation",
+		"001021A0=CSSmoking Status",
+		"001021B0=LTAdditional Patient History",
+		"00104000=LTPatient Comments",
+		
+		"00180010=LOContrast/Bolus Agent",
+		"00180015=CSBody Part Examined",
+		"00180020=CSScanning Sequence",
+		"00180021=CSSequence Variant",
+		"00180022=CSScan Options",
+		"00180023=CSMR Acquisition Type",
+		"00180024=SHSequence Name",
+		"00180025=CSAngio Flag",
+		"00180030=LORadionuclide",
+		"00180031=LORadiopharmaceutical",
+		"00180032=DSEnergy Window Centerline",
+		"00180033=DSEnergy Window Total Width",
+		"00180034=LOIntervention Drug Name",
+		"00180035=TMIntervention Drug Start Time",
+		"00180040=ISCine Rate",
+		"00180050=DSSlice Thickness",
+		"00180060=DSkVp",
+		"00180070=ISCounts Accumulated",
+		"00180071=CSAcquisition Termination Condition",
+		"00180072=DSEffective Series Duration",
+		"00180073=CSAcquisition Start Condition",
+		"00180074=ISAcquisition Start Condition Data",
+		"00180075=ISAcquisition Termination Condition Data",
+		"00180080=DSRepetition Time",
+		"00180081=DSEcho Time",
+		"00180082=DSInversion Time",
+		"00180083=DSNumber of Averages",
+		"00180084=DSImaging Frequency",
+		"00180085=SHImaged Nucleus",
+		"00180086=ISEcho Numbers(s)",
+		"00180087=DSMagnetic Field Strength",
+		"00180088=DSSpacing Between Slices",
+		"00180089=ISNumber of Phase Encoding Steps",
+		"00180090=DSData Collection Diameter",
+		"00180091=ISEcho Train Length",
+		"00180093=DSPercent Sampling",
+		"00180094=DSPercent Phase Field of View",
+		"00180095=DSPixel Bandwidth",
+		"00181000=LODevice Serial Number",
+		"00181004=LOPlate ID",
+		"00181010=LOSecondary Capture Device ID",
+		"00181012=DADate of Secondary Capture",
+		"00181014=TMTime of Secondary Capture",
+		"00181016=LOSecondary Capture Device Manufacturer",
+		"00181018=LOSecondary Capture Device Manufacturer's Model Name",
+		"00181019=LOSecondary Capture Device Software Version(s)",
+		"00181020=LOSoftware Versions(s)",
+		"00181022=SHVideo Image Format Acquired",
+		"00181023=LODigital Image Format Acquired",
+		"00181030=LOProtocol Name",
+		"00181040=LOContrast/Bolus Route",
+		"00181041=DSContrast/Bolus Volume",
+		"00181042=TMContrast/Bolus Start Time",
+		"00181043=TMContrast/Bolus Stop Time",
+		"00181044=DSContrast/Bolus Total Dose",
+		"00181045=ISSyringe Counts",
+		"00181050=DSSpatial Resolution",
+		"00181060=DSTrigger Time",
+		"00181061=LOTrigger Source or Type",
+		"00181062=ISNominal Interval",
+		"00181063=DSFrame Time",
+		"00181064=LOFraming Type",
+		"00181065=DSFrame Time Vector",
+		"00181066=DSFrame Delay",
+		"00181070=LORadionuclide Route",
+		"00181071=DSRadionuclide Volume",
+		"00181072=TMRadionuclide Start Time",
+		"00181073=TMRadionuclide Stop Time",
+		"00181074=DSRadionuclide Total Dose",
+		"00181075=DSRadionuclide Half Life",
+		"00181076=DSRadionuclide Positron Fraction",
+		"00181080=CSBeat Rejection Flag",
+		"00181081=ISLow R-R Value",
+		"00181082=ISHigh R-R Value",
+		"00181083=ISIntervals Acquired",
+		"00181084=ISIntervals Rejected",
+		"00181085=LOPVC Rejection",
+		"00181086=ISSkip Beats",
+		"00181088=ISHeart Rate",
+		"00181090=ISCardiac Number of Images",
+		"00181094=ISTrigger Window",
+		"00181100=DSReconstruction Diameter",
+		"00181110=DSDistance Source to Detector",
+		"00181111=DSDistance Source to Patient",
+		"00181120=DSGantry/Detector Tilt",
+		"00181130=DSTable Height",
+		"00181131=DSTable Traverse",
+		"00181140=CSRotation Direction",
+		"00181141=DSAngular Position",
+		"00181142=DSRadial Position",
+		"00181143=DSScan Arc",
+		"00181144=DSAngular Step",
+		"00181145=DSCenter of Rotation Offset",
+		"00181146=DSRotation Offset",
+		"00181147=CSField of View Shape",
+		"00181149=ISField of View Dimensions(s)",
+		"00181150=ISExposure Time",
+		"00181151=ISX-ray Tube Current",
+		"00181152=ISExposure",
+		"00181153=ISExposure in uAs",
+		"00181154=DSAverage Pulse Width",
+		"00181155=CSRadiation Setting",
+		"00181156=CSRectification Type",
+		"0018115A=CSRadiation Mode",
+		"0018115E=DSImage Area Dose Product",
+		"00181160=SHFilter Type",
+		"00181161=LOType of Filters",
+		"00181162=DSIntensifier Size",
+		"00181164=DSImager Pixel Spacing",
+		"00181166=CSGrid",
+		"00181170=ISGenerator Power",
+		"00181180=SHCollimator/grid Name",
+		"00181181=CSCollimator Type",
+		"00181182=ISFocal Distance",
+		"00181183=DSX Focus Center",
+		"00181184=DSY Focus Center",
+		"00181190=DSFocal Spot(s)",
+		"00181191=CSAnode Target Material",
+		"001811A0=DSBody Part Thickness",
+		"001811A2=DSCompression Force",
+		"00181200=DADate of Last Calibration",
+		"00181201=TMTime of Last Calibration",
+		"00181210=SHConvolution Kernel",
+		"00181242=ISActual Frame Duration",
+		"00181243=ISCount Rate",
+		"00181250=SHReceiving Coil",
+		"00181251=SHTransmitting Coil",
+		"00181260=SHPlate Type",
+		"00181261=LOPhosphor Type",
+		"00181300=ISScan Velocity",
+		"00181301=CSWhole Body Technique",
+		"00181302=ISScan Length",
+		"00181310=USAcquisition Matrix",
+		"00181312=CSPhase Encoding Direction",
+		"00181314=DSFlip Angle",
+		"00181315=CSVariable Flip Angle Flag",
+		"00181316=DSSAR",
+		"00181318=DSdB/dt",
+		"00181400=LOAcquisition Device Processing Description",
+		"00181401=LOAcquisition Device Processing Code",
+		"00181402=CSCassette Orientation",
+		"00181403=CSCassette Size",
+		"00181404=USExposures on Plate",
+		"00181405=ISRelative X-ray Exposure",
+		"00181450=CSColumn Angulation",
+		"00181500=CSPositioner Motion",
+		"00181508=CSPositioner Type",
+		"00181510=DSPositioner Primary Angle",
+		"00181511=DSPositioner Secondary Angle",
+		"00181520=DSPositioner Primary Angle Increment",
+		"00181521=DSPositioner Secondary Angle Increment",
+		"00181530=DSDetector Primary Angle",
+		"00181531=DSDetector Secondary Angle",
+		"00181600=CSShutter Shape",
+		"00181602=ISShutter Left Vertical Edge",
+		"00181604=ISShutter Right Vertical Edge",
+		"00181606=ISShutter Upper Horizontal Edge",
+		"00181608=ISShutter Lower Horizontal Edge",
+		"00181610=ISCenter of Circular Shutter",
+		"00181612=ISRadius of Circular Shutter",
+		"00181620=ISVertices of the Polygonal Shutter",
+		"00181700=ISCollimator Shape",
+		"00181702=ISCollimator Left Vertical Edge",
+		"00181704=ISCollimator Right Vertical Edge",
+		"00181706=ISCollimator Upper Horizontal Edge",
+		"00181708=ISCollimator Lower Horizontal Edge",
+		"00181710=ISCenter of Circular Collimator",
+		"00181712=ISRadius of Circular Collimator",
+		"00181720=ISVertices of the Polygonal Collimator",
+		"00185000=SHOutput Power",
+		"00185010=LOTransducer Data",
+		"00185012=DSFocus Depth",
+		"00185020=LOPreprocessing Function",
+		"00185021=LOPostprocessing Function",
+		"00185022=DSMechanical Index",
+		"00185024=DSThermal Index",
+		"00185026=DSCranial Thermal Index",
+		"00185027=DSSoft Tissue Thermal Index",
+		"00185028=DSSoft Tissue-focus Thermal Index",
+		"00185029=DSSoft Tissue-surface Thermal Index",
+		"00185050=ISDepth of Scan Field",
+		"00185100=CSPatient Position",
+		"00185101=CSView Position",
+		"00185104=SQProjection Eponymous Name Code Sequence",
+		"00185210=DSImage Transformation Matrix",
+		"00185212=DSImage Translation Vector",
+		"00186000=DSSensitivity",
+		"00186011=SQSequence of Ultrasound Regions",
+		"00186012=USRegion Spatial Format",
+		"00186014=USRegion Data Type",
+		"00186016=ULRegion Flags",
+		"00186018=ULRegion Location Min X0",
+		"0018601A=ULRegion Location Min Y0",
+		"0018601C=ULRegion Location Max X1",
+		"0018601E=ULRegion Location Max Y1",
+		"00186020=SLReference Pixel X0",
+		"00186022=SLReference Pixel Y0",
+		"00186024=USPhysical Units X Direction",
+		"00186026=USPhysical Units Y Direction",
+		"00181628=FDReference Pixel Physical Value X",
+		"0018602A=FDReference Pixel Physical Value Y",
+		"0018602C=FDPhysical Delta X",
+		"0018602E=FDPhysical Delta Y",
+		"00186030=ULTransducer Frequency",
+		"00186031=CSTransducer Type",
+		"00186032=ULPulse Repetition Frequency",
+		"00186034=FDDoppler Correction Angle",
+		"00186036=FDSterring Angle",
+		"00186038=ULDoppler Sample Volume X Position",
+		"0018603A=ULDoppler Sample Volume Y Position",
+		"0018603C=ULTM-Line Position X0",
+		"0018603E=ULTM-Line Position Y0",
+		"00186040=ULTM-Line Position X1",
+		"00186042=ULTM-Line Position Y1",
+		"00186044=USPixel Component Organization",
+		"00186046=ULPixel Component Mask",
+		"00186048=ULPixel Component Range Start",
+		"0018604A=ULPixel Component Range Stop",
+		"0018604C=USPixel Component Physical Units",
+		"0018604E=USPixel Component Data Type",
+		"00186050=ULNumber of Table Break Points",
+		"00186052=ULTable of X Break Points",
+		"00186054=FDTable of Y Break Points",
+		"00186056=ULNumber of Table Entries",
+		"00186058=ULTable of Pixel Values",
+		"0018605A=ULTable of Parameter Values",
+		"00187000=CSDetector Conditions Nominal Flag",
+		"00187001=DSDetector Temperature",
+		"00187004=CSDetector Type",
+		"00187005=CSDetector Configuration",
+		"00187006=LTDetector Description",
+		"00187008=LTDetector Mode",
+		"0018700A=SHDetector ID",
+		"0018700C=DADate of Last Detector Calibration",
+		"0018700E=TMTime of Last Detector Calibration",
+		"00187010=ISExposures on Detector Since Last Calibration",
+		"00187011=ISExposures on Detector Since Manufactured",
+		"00187012=DSDetector Time Since Last Exposure",
+		"00187014=DSDetector Active Time",
+		"00187016=DSDetector Activation Offset From Exposure",
+		"0018701A=DSDetector Binning",
+		"00187020=DSDetector Element Physical Size",
+		"00187022=DSDetector Element Spacing",
+		"00187024=CSDetector Active Shape",
+		"00187026=DSDetector Active Dimension(s)",
+		"00187028=DSDetector Active Origin",
+		"00187030=DSField of View Origin",
+		"00187032=DSField of View Rotation",
+		"00187034=CSField of View Horizontal Flip",
+		"00187040=LTGrid Absorbing Material",
+		"00187041=LTGrid Spacing Material",
+		"00187042=DSGrid Thickness",
+		"00187044=DSGrid Pitch",
+		"00187046=ISGrid Aspect Ratio",
+		"00187048=DSGrid Period",
+		"0018704C=DSGrid Focal Distance",
+		"00187050=LTFilter Material LT",
+		"00187052=DSFilter Thickness Minimum",
+		"00187054=DSFilter Thickness Maximum",
+		"00187060=CSExposure Control Mode",
+		"00187062=LTExposure Control Mode Description",
+		"00187064=CSExposure Status",
+		"00187065=DSPhototimer Setting",
+		
+		"0020000D=UIStudy Instance UID",
+		"0020000E=UISeries Instance UID",
+		"00200010=SHStudy ID",
+		"00200011=ISSeries Number",
+		"00200012=ISAcquisition Number",
+		"00200013=ISImage Number",
+		"00200014=ISIsotope Number",
+		"00200015=ISPhase Number",
+		"00200016=ISInterval Number",
+		"00200017=ISTime Slot Number",
+		"00200018=ISAngle Number",
+		"00200020=CSPatient Orientation",
+		"00200022=USOverlay Number",
+		"00200024=USCurve Number",
+		"00200030=DSImage Position",
+		"00200032=DSImage Position (Patient)",
+		"00200037=DSImage Orientation (Patient)",
+		"00200050=DSLocation",
+		"00200052=UIFrame of Reference UID",
+		"00200060=CSLaterality",
+		"00200070=LOImage Geometry Type",
+		"00200080=UIMasking Image UID",
+		"00200100=ISTemporal Position Identifier",
+		"00200105=ISNumber of Temporal Positions",
+		"00200110=DSTemporal Resolution",
+		"00201000=ISSeries in Study",
+		"00201002=ISImages in Acquisition",
+		"00201004=ISAcquisition in Study",
+		"00201040=LOPosition Reference Indicator",
+		"00201041=DSSlice Location",
+		"00201070=ISOther Study Numbers",
+		"00201200=ISNumber of Patient Related Studies",
+		"00201202=ISNumber of Patient Related Series",
+		"00201204=ISNumber of Patient Related Images",
+		"00201206=ISNumber of Study Related Series",
+		"00201208=ISNumber of Study Related Images",
+		"00204000=LTImage Comments",
+		
+		"00280002=USSamples per Pixel",
+		"00280004=CSPhotometric Interpretation",
+		"00280006=USPlanar Configuration",
+		"00280008=ISNumber of Frames",
+		"00280009=ATFrame Increment Pointer",
+		"00280010=USRows",
+		"00280011=USColumns",
+		"00280030=DSPixel Spacing",
+		"00280031=DSZoom Factor",
+		"00280032=DSZoom Center",
+		"00280034=ISPixel Aspect Ratio",
+		"00280051=CSCorrected Image",
+		"00280100=USBits Allocated",
+		"00280101=USBits Stored",
+		"00280102=USHigh Bit",
+		"00280103=USPixel Representation",
+		"00280106=USSmallest Image Pixel Value",
+		"00280107=USLargest Image Pixel Value",
+		"00280108=USSmallest Pixel Value in Series",
+		"00280109=USLargest Pixel Value in Series",
+		"00280120=USPixel Padding Value",
+		"00280300=CSQuality Control Image",
+		"00280301=CSBurned In Annotation",
+		"00281040=CSPixel Intensity Relationship",
+		"00281041=SSPixel Intensity Relationship Sign",
+		"00281050=DSWindow Center",
+		"00281051=DSWindow Width",
+		"00281052=DSRescale Intercept",
+		"00281053=DSRescale Slope",
+		"00281054=LORescale Type",
+		"00281055=LOWindow Center & Width Explanation",
+		"00281101=USRed Palette Color Lookup Table Descriptor",
+		"00281102=USGreen Palette Color Lookup Table Descriptor",
+		"00281103=USBlue Palette Color Lookup Table Descriptor",
+		"00281201=USRed Palette Color Lookup Table Data",
+		"00281202=USGreen Palette Color Lookup Table Data",
+		"00281203=USBlue Palette Color Lookup Table Data",
+		"00282110=CSLossy Image Compression",
+		"00283000=SQModality LUT Sequence",
+		"00283002=USLUT Descriptor",
+		"00283003=LOLUT Explanation",
+		"00283004=LOMadality LUT Type",
+		"00283006=USLUT Data",
+		"00283010=SQVOI LUT Sequence",
+		
+		"30020011=DSImage Plane Pixel Spacing",
+		"30020022=DSRadiation Machine SAD",
+		"30020026=DSRT IMAGE SID",
+		
+		"0032000A=CSStudy Status ID",
+		"0032000C=CSStudy Priority ID",
+		"00320012=LOStudy ID Issuer",
+		"00320032=DAStudy Verified Date",
+		"00320033=TMStudy Verified Time",
+		"00320034=DAStudy Read Date",
+		"00320035=TMStudy Read Time",
+		"00321000=DAScheduled Study Start Date",
+		"00321001=TMScheduled Study Start Time",
+		"00321010=DAScheduled Study Stop Date",
+		"00321011=TMScheduled Study Stop Time",
+		"00321020=LOScheduled Study Location",
+		"00321021=AEScheduled Study Location AE Title(s)",
+		"00321030=LOReason for Study",
+		"00321032=PNRequesting Physician",
+		"00321033=LORequesting Service",
+		"00321040=DAStudy Arrival Date",
+		"00321041=TMStudy Arrival Time",
+		"00321050=DAStudy Completion Date",
+		"00321051=TMStudy Completion Time",
+		"00321055=CSStudy Component Status ID",
+		"00321060=LORequested Procedure Description",
+		"00321064=SQRequested Procedure Code Sequence",
+		"00321070=LORequested Contrast Agent",
+		"00324000=LTStudy Comments",
+		
+		"00400001=AEScheduled Station AE Title",
+		"00400002=DAScheduled Procedure Step Start Date",
+		"00400003=TMScheduled Procedure Step Start Time",
+		"00400004=DAScheduled Procedure Step End Date",
+		"00400005=TMScheduled Procedure Step End Time",
+		"00400006=PNScheduled Performing Physician's Name",
+		"00400007=LOScheduled Procedure Step Description",
+		"00400008=SQScheduled Action Item Code Sequence",
+		"00400009=SHScheduled Procedure Step ID",
+		"00400010=SHScheduled Station Name",
+		"00400011=SHScheduled Procedure Step Location",
+		"00400012=LOPre-Medication",
+		"00400020=CSScheduled Procedure Step Status",
+		"00400100=SQScheduled Procedure Step Sequence",
+		"00400220=SQReferenced Standalone SOP Instance Sequence",
+		"00400241=AEPerformed Station AE Title",
+		"00400242=SHPerformed Station Name",
+		"00400243=SHPerformed Location",
+		"00400244=DAPerformed Procedure Step Start Date",
+		"00400245=TMPerformed Procedure Step Start Time",
+		"00400250=DAPerformed Procedure Step End Date",
+		"00400251=TMPerformed Procedure Step End Time",
+		"00400252=CSPerformed Procedure Step Status",
+		"00400253=SHPerformed Procedure Step ID",
+		"00400254=LOPerformed Procedure Step Description",
+		"00400255=LOPerformed Procedure Type Description",
+		"00400260=SQPerformed Action Item Sequence",
+		"00400270=SQScheduled Step Attributes Sequence",
+		"00400275=SQRequest Attributes Sequence",
+		"00400280=STComments on the Performed Procedure Steps",
+		"00400293=SQQuantity Sequence",
+		"00400294=DSQuantity",
+		"00400295=SQMeasuring Units Sequence",
+		"00400296=SQBilling Item Sequence",
+		"00400300=USTotal Time of Fluoroscopy",
+		"00400301=USTotal Number of Exposures",
+		"00400302=USEntrance Dose",
+		"00400303=USExposed Area",
+		"00400306=DSDistance Source to Entrance",
+		"00400307=DSDistance Source to Support",
+		"00400310=STComments on Radiation Dose",
+		"00400312=DSX-Ray Output",
+		"00400314=DSHalf Value Layer",
+		"00400316=DSOrgan Dose",
+		"00400318=CSOrgan Exposed",
+		"00400320=SQBilling Procedure Step Sequence",
+		"00400321=SQFilm Consumption Sequence",
+		"00400324=SQBilling Supplies and Devices Sequence",
+		"00400330=SQReferenced Procedure Step Sequence",
+		"00400340=SQPerformed Series Sequence",
+		"00400400=LTComments on the Scheduled Procedure Step",
+		"0040050A=LOSpecimen Accession Number",
+		"00400550=SQSpecimen Sequence",
+		"00400551=LOSpecimen Identifier",
+		"0040059A=SQSpecimen Type Code Sequence",
+		"00400555=SQAcquisition Context Sequence",
+		"00400556=STAcquisition Context Description",
+		"004006FA=LOSlide Identifier",
+		"0040071A=SQImage Center Point Coordinates Sequence",
+		"0040072A=DSX offset in Slide Coordinate System",
+		"0040073A=DSY offset in Slide Coordinate System",
+		"0040074A=DSZ offset in Slide Coordinate System",
+		"004008D8=SQPixel Spacing Sequence",
+		"004008DA=SQCoordinate System Axis Code Sequence",
+		"004008EA=SQMeasurement Units Code Sequence",
+		"00401001=SHRequested Procedure ID",
+		"00401002=LOReason for the Requested Procedure",
+		"00401003=SHRequested Procedure Priority",
+		"00401004=LOPatient Transport Arrangements",
+		"00401005=LORequested Procedure Location",
+		"00401006= 1Placer Order Number / Procedure S",
+		"00401007= 1Filler Order Number / Procedure S",
+		"00401008=LOConfidentiality Code",
+		"00401009=SHReporting Priority",
+		"00401010=PNNames of Intended Recipients of Results",
+		"00401400=LTRequested Procedure Comments",
+		"00402001=LOReason for the Imaging Service Request",
+		"00402004=DAIssue Date of Imaging Service Request",
+		"00402005=TMIssue Time of Imaging Service Request",
+		"00402006= 1Placer Order Number / Imaging Service Request S",
+		"00402007= 1Filler Order Number / Imaging Service Request S",
+		"00402008=PNOrder Entered By",
+		"00402009=SHOrder Enterers Location",
+		"00402010=SHOrder Callback Phone Number",
+		"00402016=LOPlacer Order Number / Imaging Service Request",
+		"00402017=LOFiller Order Number / Imaging Service Request",
+		"00402400=LTImaging Service Request Comments",
+		"00403001=LOConfidentiality Constraint on Patient Data Description",
+		"00408302=DSEntrance Dose in mGy",
+		"0040A010=CSRelationship Type",
+		"0040A027=LOVerifying Organization",
+		"0040A030=DTVerification DateTime",
+		"0040A032=DTObservation DateTime",
+		"0040A040=CSValue Type",
+		"0040A043=SQConcept-name Code Sequence",
+		"0040A050=CSContinuity Of Content",
+		"0040A073=SQVerifying Observer Sequence",
+		"0040A075=PNVerifying Observer Name",
+		"0040A088=SQVerifying Observer Identification Code Sequence",
+		"0040A0B0=USReferenced Waveform Channels",
+		"0040A120=DTDateTime",
+		"0040A121=DADate",
+		"0040A122=TMTime",
+		"0040A123=PNPerson Name",
+		"0040A124=UIUID",
+		"0040A130=CSTemporal Range Type",
+		"0040A132=ULReferenced Sample Positions",
+		"0040A136=USReferenced Frame Numbers",
+		"0040A138=DSReferenced Time Offsets",
+		"0040A13A=DTReferenced Datetime",
+		"0040A160=UTText Value",
+		"0040A168=SQConcept Code Sequence",
+		"0040A180=USAnnotation Group Number",
+		"0040A195=SQModifier Code Sequence",
+		"0040A300=SQMeasured Value Sequence",
+		"0040A30A=DSNumeric Value",
+		"0040A360=SQPredecessor Documents Sequence",
+		"0040A370=SQReferenced Request Sequence",
+		"0040A372=SQPerformed Procedure Code Sequence",
+		"0040A375=SQCurrent Requested Procedure Evidence Sequence",
+		"0040A385=SQPertinent Other Evidence Sequence",
+		"0040A491=CSCompletion Flag",
+		"0040A492=LOCompletion Flag Description",
+		"0040A493=CSVerification Flag",
+		"0040A504=SQContent Template Sequence",
+		"0040A525=SQIdentical Documents Sequence",
+		"0040A730=SQContent Sequence",
+		"0040B020=SQAnnotation Sequence",
+		"0040DB00=CSTemplate Identifier",
+		"0040DB06=DTTemplate Version",
+		"0040DB07=DTTemplate Local Version",
+		"0040DB0B=CSTemplate Extension Flag",
+		"0040DB0C=UITemplate Extension Organization UID",
+		"0040DB0D=UITemplate Extension Creator UID",
+		"0040DB73=ULReferenced Content Item Identifier",
+		
+		"00540011=USNumber of Energy Windows",
+		"00540012=SQEnergy Window Information Sequence",
+		"00540013=SQEnergy Window Range Sequence",
+		"00540014=DSEnergy Window Lower Limit",
+		"00540015=DSEnergy Window Upper Limit",
+		"00540016=SQRadiopharmaceutical Information Sequence",
+		"00540017=ISResidual Syringe Counts",
+		"00540018=SHEnergy Window Name",
+		"00540020=USDetector Vector",
+		"00540021=USNumber of Detectors",
+		"00540022=SQDetector Information Sequence",
+		"00540030=USPhase Vector",
+		"00540031=USNumber of Phases",
+		"00540032=SQPhase Information Sequence",
+		"00540033=USNumber of Frames in Phase",
+		"00540036=ISPhase Delay",
+		"00540038=ISPause Between Frames",
+		"00540039=CSPhase Description",
+		"00540050=USRotation Vector",
+		"00540051=USNumber of Rotations",
+		"00540052=SQRotation Information Sequence",
+		"00540053=USNumber of Frames in Rotation",
+		"00540060=USR-R Interval Vector",
+		"00540061=USNumber of R-R Intervals",
+		"00540062=SQGated Information Sequence",
+		"00540063=SQData Information Sequence",
+		"00540070=USTime Slot Vector",
+		"00540071=USNumber of Time Slots",
+		"00540072=SQTime Slot Information Sequence",
+		"00540073=DSTime Slot Time",
+		"00540080=USSlice Vector",
+		"00540081=USNumber of Slices",
+		"00540090=USAngular View Vector",
+		"00540100=USTime Slice Vector",
+		"00540101=USNumber of Time Slices",
+		"00540200=DSStart Angle",
+		"00540202=CSType of Detector Motion",
+		"00540210=ISTrigger Vector",
+		"00540211=USNumber of Triggers in Phase",
+		"00540220=SQView Code Sequence",
+		"00540222=SQView Modifier Code Sequence",
+		"00540300=SQRadionuclide Code Sequence",
+		"00540302=SQAdministration Route Code Sequence",
+		"00540304=SQRadiopharmaceutical Code Sequence",
+		"00540306=SQCalibration Data Sequence",
+		"00540308=USEnergy Window Number",
+		"00540400=SHImage ID",
+		"00540410=SQPatient Orientation Code Sequence",
+		"00540412=SQPatient Orientation Modifier Code Sequence",
+		"00540414=SQPatient Gantry Relationship Code Sequence",
+		"00540500=CSSlice Progression Direction",
+		"00541000=CSSeries Type",
+		"00541001=CSUnits",
+		"00541002=CSCounts Source",
+		"00541004=CSReprojection Method",
+		"00541100=CSRandoms Correction Method",
+		"00541101=LOAttenuation Correction Method",
+		"00541102=CSDecay Correction",
+		"00541103=LOReconstruction Method",
+		"00541104=LODetector Lines of Response Used",
+		"00541105=LOScatter Correction Method",
+		"00541200=DSAxial Acceptance",
+		"00541201=ISAxial Mash",
+		"00541202=ISTransverse Mash",
+		"00541203=DSDetector Element Size",
+		"00541210=DSCoincidence Window Width",
+		"00541220=CSSecondary Counts Type",
+		"00541300=DSFrame Reference Time",
+		"00541310=ISPrimary (Prompts) Counts Accumulated",
+		"00541311=ISSecondary Counts Accumulated",
+		"00541320=DSSlice Sensitivity Factor",
+		"00541321=DSDecay Factor",
+		"00541322=DSDose Calibration Factor",
+		"00541323=DSScatter Fraction Factor",
+		"00541324=DSDead Time Factor",
+		"00541330=USImage Index",
+		"00541400=CSCounts Included",
+		"00541401=CSDead Time Correction Flag",
+		
+		"30020002=SHRT Image Label",
+		"30020003=LORT Image Name",
+		"30020004=STRT Image Description",
+		"3002000A=CSReported Values Origin",
+		"3002000C=CSRT Image Plane",
+		"3002000D=DSX-Ray Image Receptor Translation",
+		"3002000E=DSX-Ray Image Receptor Angle",
+		"30020011=DSImage Plane Pixel Spacing",
+		"30020012=DSRT Image Position",
+		"30020020=SHRadiation Machine Name",
+		"30020022=DSRadiation Machine SAD",
+		"30020026=DSRT Image SID",
+		"30020029=ISFraction Number",
+		"30020030=SQExposure Sequence",
+		"30020032=DSMeterset Exposure",
+		
+		"300A011E=DSGantry Angle",
+		"300A0120=DSBeam Limiting Device Angle",
+		"300A0122=DSPatient Support Angle",
+		"300A0128=DSTable Top Vertical Position",
+		"300A0129=DSTable Top Longitudinal Position",
+		"300A012A=DSTable Top Lateral Position",
+		"300A00B3=CSPrimary Dosimeter Unit",
+		"300A00F0=ISNumber of Blocks",
+		
+		"300C0006=ISReferenced Beam Number",
+		"300C0008=DSStart Cumulative Meterset Weight",
+		"300C0022=ISReferenced Fraction Group Number",
+
+		"7FE00008=OXFloat Pixel Data",
+		"7FE00010=OXPixel Data",
+		
+		"FFFEE000=DLItem",
+		"FFFEE00D=DLItem Delimitation Item",
+		"FFFEE0DD=DLSequence Delimitation Item"
+	};
+
+}
diff --git a/src/ij/plugin/Distribution.java b/src/ij/plugin/Distribution.java
new file mode 100644
index 0000000..f426fc1
--- /dev/null
+++ b/src/ij/plugin/Distribution.java
@@ -0,0 +1,175 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.PlugIn;
+import ij.measure.*;
+import ij.util.Tools;
+import java.util.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Vector;
+
+/**
+This plugin implements the Analyze/Distribution command.
+It reads the data from the ResultsTable and plots a frequency histogram.
+@author G. Landini at bham. ac. uk
+*/
+public class Distribution implements PlugIn, TextListener {
+	static String parameter = "Area";
+	static boolean autoBinning = true;
+	static int nBins = 10;
+	static String range = "0-0";
+	Checkbox checkbox;
+	TextField nBinsField, rangeField;
+	String defaultNBins, defaultRange;
+
+	public void run(String arg) {
+		ResultsTable rt=ResultsTable.getResultsTable();
+		int count = rt.size();
+		if (count==0) {
+			IJ.error("Distribution", "The \"Results\" table is empty");
+			return;
+		}
+		String head= rt.getColumnHeadings();
+		//IJ.log(head);
+
+		StringTokenizer t = new StringTokenizer(head, "\t");
+		int tokens = t.countTokens()-1;
+		String[] strings = new String[tokens];
+		strings[0] = t.nextToken(); // first token is empty?
+	   	for(int i=0; i<tokens; i++)
+			strings[i] = t.nextToken();
+
+		defaultNBins = ""+nBins;
+		defaultRange = range;
+		GenericDialog gd = new GenericDialog("Distribution");
+		gd.addChoice("Parameter: ", strings, strings[getIndex(strings)]);
+		gd.setInsets(0, 40, 0);
+		gd.addMessage(count+" data points", null, Color.darkGray);
+		gd.addCheckbox("Automatic binning", autoBinning);
+		gd.addNumericField ("or specify bins:", nBins, 0);
+		gd.addStringField ("and range:", range);
+
+		Vector v = gd.getNumericFields();
+		if (v!=null) {
+			nBinsField = (TextField)v.elementAt(0);
+			nBinsField.addTextListener(this);
+		}
+		v = gd.getStringFields();
+		if (v!=null) {
+			rangeField = (TextField)v.elementAt(0);
+			rangeField.addTextListener(this);
+		}
+		checkbox = (Checkbox)(gd.getCheckboxes().elementAt(0));
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+
+		parameter = gd.getNextChoice ();
+		autoBinning = gd.getNextBoolean();
+		double nMin=0.0, nMax=0.0;
+		if (!autoBinning) {
+			nBins = (int)gd.getNextNumber();
+			range = gd.getNextString();
+			// find hyphen and replace with comma
+			String[] minAndMax = range.replaceAll("([0-9.])[\t ]*-", "$1,").split(",");
+			nMin = Tools.parseDouble(minAndMax[0]);
+			nMax = minAndMax.length==2?Tools.parseDouble(minAndMax[1]):Double.NaN;
+			if (Double.isNaN(nMin) || Double.isNaN(nMax))
+				{nMin=0.0; nMax=0.0; range="0-0";}
+		}
+
+		float[] data = null;
+		int index = rt.getColumnIndex(parameter);
+		if (index>=0)
+			data = rt.getColumn(index);
+		if (data==null) {
+			IJ.error("Distribution", "No available results: \""+parameter+"\"");
+			return;
+		}
+
+		float [] pars = new float [11];
+		stats(count, data, pars);
+		if (autoBinning) {
+			//sd = 7, min = 3, max = 4
+			// use Scott's method (1979 Biometrika, 66:605-610) for optimal binning: 3.49*sd*N^-1/3
+			float binWidth = (float)(3.49 * pars[7]*(float)Math.pow((float)count, -1.0/3.0));
+			nBins= (int)Math.floor(((pars[4]-pars[3])/binWidth)+.5);
+			if (nBins<2) nBins = 2;
+		}
+
+		ImageProcessor ip = new FloatProcessor(count, 1, data, null);
+		ImagePlus imp = new ImagePlus("", ip);
+		ImageStatistics stats = new StackStatistics(imp, nBins, nMin, nMax);
+		int maxCount = 0;
+		for (int i=0; i<stats.histogram.length; i++) {
+			if (stats.histogram[i]>maxCount)
+				maxCount = stats.histogram[i];
+		}
+		stats.histYMax = maxCount;
+		new HistogramWindow(parameter+" Distribution", imp, stats);
+	}
+	
+	int getIndex(String[] strings) {
+		for (int i=0; i<strings.length; i++) {
+			if (strings[i].equals(parameter))
+				return i;
+		}
+		return 0;
+	}
+
+	public void textValueChanged(TextEvent e) {
+		if (!defaultNBins.equals(nBinsField.getText()))
+			checkbox.setState(false);
+		if (!defaultRange.equals(rangeField.getText()))
+			checkbox.setState(false);
+	}
+
+	void stats(int nc, float[] data, float[] pars){
+ // ("\tPoints\tEdges_n\tGraph_Length\tMin\tMax\tMean\tAvDev\tSDev\tVar\tSkew\tKurt");
+		int i;
+		float s = 0, min = Float.MAX_VALUE, max = -Float.MAX_VALUE, totl=0, ave=0, adev=0, sdev=0, var=0, skew=0, kurt=0, p;
+
+		for(i=0;i<nc;i++){
+			totl+= data[i];
+			//tot& = tot& + 1
+				if(data[i]<min) min = data[i];
+			if(data[i]>max) max = data[i];
+		}
+
+		ave = totl/nc;
+
+		for(i=0;i<nc;i++){
+			s = data[i] - ave;
+			adev+=Math.abs(s);
+			p = s * s;
+			var+= p;
+			p*=s;
+			skew+= p;
+			p*= s;
+			kurt+= p;
+		}
+
+		adev/= nc;
+		var/=nc-1;
+		sdev = (float) Math.sqrt(var);
+
+		if(var> 0){
+			skew = (float)skew / (nc * (float) Math.pow(sdev,3));
+			kurt = (float)kurt / (nc * (float) Math.pow(var, 2)) - 3;
+		}
+		pars[1]=(float) nc;
+		pars[2]=totl;
+		pars[3]=min;
+		pars[4]=max;
+		pars[5]=ave;
+		pars[6]=adev;
+		pars[7]=sdev;
+		pars[8]=var;
+		pars[9]=skew;
+		pars[10]=kurt;
+
+	}
+
+}
diff --git a/src/ij/plugin/DragAndDrop.java b/src/ij/plugin/DragAndDrop.java
new file mode 100644
index 0000000..a7e7e8c
--- /dev/null
+++ b/src/ij/plugin/DragAndDrop.java
@@ -0,0 +1,220 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.process.ImageProcessor;
+import ij.plugin.frame.Recorder;
+import java.io.*;
+import java.awt.Point;
+import java.awt.datatransfer.*;
+import java.awt.dnd.*;
+import java.util.*;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+/** This class opens images, roi's, luts and text files dragged and dropped on  the "ImageJ" window.
+     It is based on the Draw_And_Drop plugin by Eric Kischell (keesh@ieee.org).
+     
+     10 November 2006: Albert Cardona added Linux support and an  
+     option to open all images in a dragged folder as a stack.
+*/
+     
+public class DragAndDrop implements PlugIn, DropTargetListener, Runnable {
+	private Iterator iterator;
+	private static boolean convertToRGB;
+	private static boolean virtualStack;
+	private boolean openAsVirtualStack;
+	
+	public void run(String arg) {
+		ImageJ ij = IJ.getInstance();
+		ij.setDropTarget(null);
+		new DropTarget(ij, this);
+		new DropTarget(Toolbar.getInstance(), this);
+		new DropTarget(ij.getStatusBar(), this);
+	}  
+	    
+	public void drop(DropTargetDropEvent dtde)  {
+		dtde.acceptDrop(DnDConstants.ACTION_COPY);
+		DataFlavor[] flavors = null;
+		try  {
+			Transferable t = dtde.getTransferable();
+			iterator = null;
+			flavors = t.getTransferDataFlavors();
+			if (IJ.debugMode) IJ.log("DragAndDrop.drop: "+flavors.length+" flavors");
+			for (int i=0; i<flavors.length; i++) {
+				if (IJ.debugMode) IJ.log("  flavor["+i+"]: "+flavors[i].getMimeType());
+				if (flavors[i].isFlavorJavaFileListType()) {
+					Object data = t.getTransferData(DataFlavor.javaFileListFlavor);
+					iterator = ((List)data).iterator();
+					break;
+				} else if (flavors[i].isFlavorTextType()) {
+					Object ob = t.getTransferData(flavors[i]);
+					if (!(ob instanceof String)) continue;
+					String s = ob.toString().trim();
+					if (IJ.isLinux() && s.length()>1 && (int)s.charAt(1)==0)
+						s = fixLinuxString(s);
+					ArrayList list = new ArrayList();
+					if (s.indexOf("href=\"")!=-1 || s.indexOf("src=\"")!=-1) {
+						s = parseHTML(s);
+						if (IJ.debugMode) IJ.log("  url: "+s);
+						list.add(s);
+						this.iterator = list.iterator();
+						break;
+					}
+					BufferedReader br = new BufferedReader(new StringReader(s));
+					String tmp;
+					while (null != (tmp = br.readLine())) {
+						tmp = java.net.URLDecoder.decode(tmp.replaceAll("\\+","%2b"), "UTF-8");
+						if (tmp.startsWith("file://")) tmp = tmp.substring(7);
+						if (IJ.debugMode) IJ.log("  content: "+tmp);
+						if (tmp.startsWith("http://"))
+							list.add(s);
+						else
+							list.add(new File(tmp));
+					}
+					this.iterator = list.iterator();
+					break;
+				}
+			}
+			if (iterator!=null) {
+				Thread thread = new Thread(this, "DrawAndDrop");
+				thread.setPriority(Math.max(thread.getPriority()-1, Thread.MIN_PRIORITY));
+				thread.start();
+			}
+		} catch(Exception e)  {
+			dtde.dropComplete(false);
+			return;
+		}
+		dtde.dropComplete(true);
+		if (flavors==null || flavors.length==0) {
+			if (IJ.isMacOSX())
+				IJ.error("First drag and drop ignored. Please try again. You can avoid this\n"
+				+"problem by dragging to the toolbar instead of the status bar.");
+			else
+				IJ.error("Drag and drop failed");
+		}
+	}
+	    
+	private String fixLinuxString(String s) {
+		StringBuffer sb = new StringBuffer(200);
+		for (int i=0; i<s.length(); i+=2)
+			sb.append(s.charAt(i));
+		return new String(sb);
+	}
+	
+	private String parseHTML(String s) {
+		if (IJ.debugMode) IJ.log("parseHTML:\n"+s);
+		int index1 = s.indexOf("src=\"");
+		if (index1>=0) {
+			int index2 = s.indexOf("\"", index1+5);
+			if (index2>0)
+				return s.substring(index1+5, index2);
+		}
+		index1 = s.indexOf("href=\"");
+		if (index1>=0) {
+			int index2 = s.indexOf("\"", index1+6);
+			if (index2>0)
+				return s.substring(index1+6, index2);
+		}
+		return s;
+	}
+
+	public void dragEnter(DropTargetDragEvent e)  {
+		IJ.showStatus("<<Drag and Drop>>");
+		if (IJ.debugMode) IJ.log("DragEnter: "+e.getLocation());
+		e.acceptDrag(DnDConstants.ACTION_COPY);
+		openAsVirtualStack = false;
+	}
+
+	public void dragOver(DropTargetDragEvent e) {
+		if (IJ.debugMode) IJ.log("DragOver: "+e.getLocation());
+		Point loc = e.getLocation();
+		int buttonSize = Toolbar.getButtonSize();
+		int width = IJ.getInstance().getSize().width;
+		openAsVirtualStack = width-loc.x<=(buttonSize+buttonSize/3);
+		if (openAsVirtualStack)
+			IJ.showStatus("<<Open as virtual stack or text image>>");
+		else
+			IJ.showStatus("<<Drag and Drop>>");
+	}
+	
+	public void dragExit(DropTargetEvent e) {
+		IJ.showStatus("");
+	}
+	
+	public void dropActionChanged(DropTargetDragEvent e) {}
+	
+	public void run() {
+		Iterator iterator = this.iterator;
+		while(iterator.hasNext()) {
+			Object obj = iterator.next();
+			String str = ""+obj;
+			if (str!=null && str.startsWith("https:/")) {
+				if (!str.startsWith("https://"))
+					str = str.replace("https:/", "http://");
+				obj = str;
+			}
+			if (obj!=null && (obj instanceof String))
+				openURL((String)obj);
+			else
+				openFile((File)obj);
+		}
+	}
+	
+	/** Open a URL. */
+	private void openURL(String url) {
+		if (IJ.debugMode) IJ.log("DragAndDrop.openURL: "+url);
+		if (url!=null)
+			IJ.open(url);
+	}
+
+	/** Open a file. If it's a directory, ask to open all images as a sequence in a stack or individually. */
+	public void openFile(File f) {
+		if (IJ.debugMode) IJ.log("DragAndDrop.openFile: "+f);
+		try {
+			if (null == f) return;
+			String path = f.getCanonicalPath();
+			if (f.exists()) {
+				if (f.isDirectory()) {
+					if (openAsVirtualStack)
+						IJ.run("Image Sequence...", "open=[" + path + "] sort use");
+					else
+						openDirectory(f, path);
+				} else {
+					if (openAsVirtualStack && (path.endsWith(".tif")||path.endsWith(".TIF")))
+						(new FileInfoVirtualStack()).run(path);
+					else if (openAsVirtualStack && (path.endsWith(".avi")||path.endsWith(".AVI")))
+						IJ.run("AVI...", "open=["+path+"] use");
+					else if (openAsVirtualStack && (path.endsWith(".txt"))) {
+						ImageProcessor ip = (new TextReader()).open(path);
+						if (ip!=null)
+							new ImagePlus(f.getName(),ip).show();
+					} else {
+						Recorder.recordOpen(path);
+						(new Opener()).openAndAddToRecent(path);
+					}
+					OpenDialog.setLastDirectory(f.getParent()+File.separator);
+					OpenDialog.setLastName(f.getName());
+				}
+			} else {
+				IJ.log("File not found: " + path);
+			}
+		} catch (Throwable e) {
+			if (!Macro.MACRO_CANCELED.equals(e.getMessage()))
+				IJ.handleException(e);
+		}
+	}
+	
+	private void openDirectory(File f, String path) {
+		if (path==null) return;
+		path = IJ.addSeparator(path);
+		String[] names = f.list();
+		names = (new FolderOpener()).trimFileList(names);
+		if (names==null)
+			return;
+		FolderOpener fo = new FolderOpener();
+		fo.setDirectory(path);
+		fo.run("");
+	}
+		
+}
diff --git a/src/ij/plugin/Duplicator.java b/src/ij/plugin/Duplicator.java
new file mode 100644
index 0000000..3e73c6b
--- /dev/null
+++ b/src/ij/plugin/Duplicator.java
@@ -0,0 +1,705 @@
+package ij.plugin;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Vector;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+import ij.measure.Calibration;
+
+/** This plugin implements the Image/Duplicate command.
+<pre>
+   // test script
+   img1 = IJ.getImage();
+   img2 = new Duplicator().run(img1);
+   //img2 = new Duplicator().run(img1,1,10);
+   img2.show();
+</pre>
+*/
+public class Duplicator implements PlugIn, TextListener, ItemListener {
+	private static boolean staticDuplicateStack;
+	private static boolean staticIgnoreSelection;
+	private static boolean ignoreNextSelection;
+	private boolean duplicateStack;
+	private boolean ignoreSelection;
+	private int first, last;
+	private Checkbox stackCheckbox;
+	private TextField titleField, rangeField;
+	private TextField[] rangeFields;
+	private int firstC, lastC, firstZ, lastZ, firstT, lastT;
+	private String defaultTitle;
+	private String sliceLabel;
+	private ImagePlus imp;
+	private boolean legacyMacro;
+	private boolean titleChanged;
+	private GenericDialog gd;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		Roi roiA = imp.getRoi();
+		ImagePlus impA = imp;
+		boolean isRotatedRect = (roiA!=null &&  roiA instanceof RotatedRectRoi);
+		if (isRotatedRect) {
+			Rectangle bounds = imp.getRoi().getBounds();
+			imp.setRoi(bounds);
+		}
+		if (roiA!=null) {
+			Rectangle r = roiA.getBounds();
+			if (r.x>=imp.getWidth() || r.y>=imp.getHeight() || r.x+r.width<=0 || r.y+r.height<=0) {
+				IJ.error("Roi is outside image");
+				return;
+			}
+		}
+		int stackSize = imp.getStackSize();
+		String title = imp.getTitle();
+		String newTitle = WindowManager.getUniqueName(imp, title);
+		defaultTitle = newTitle;
+		duplicateStack = staticDuplicateStack && !IJ.isMacro();
+		ignoreSelection = (staticIgnoreSelection||ignoreNextSelection) && Macro.getOptions()==null;
+		if (!IJ.altKeyDown()||stackSize>1) {
+			if (imp.isHyperStack() || imp.isComposite()) {
+				duplicateHyperstack(imp, newTitle);			
+				if (isRotatedRect) {
+					straightenRotatedRect(impA, roiA, IJ.getImage());	
+				}								
+				return;
+			} else
+				newTitle = showDialog(imp, "Duplicate...", "Title: ");
+		}
+		if (newTitle==null) {
+			if (isRotatedRect)
+				imp.setRoi(roiA);
+			return;
+		}
+		ImagePlus imp2;
+		Roi roi = imp.getRoi();
+		if (ignoreSelection && roi!=null)
+			imp.deleteRoi();
+		if (duplicateStack && (first>1||last<stackSize))
+			imp2 = run(imp, first, last);
+		else if (duplicateStack || imp.getStackSize()==1) {
+			imp2 = run(imp);
+			if (imp.getStackSize()==1) recordCrop(imp);
+		} else {
+			imp2 = crop(imp);
+			recordCrop(imp);
+		}
+		if (ignoreSelection && roi!=null)
+			imp.setRoi(roi);
+		Calibration cal = imp2.getCalibration();
+		if (roi!=null && (cal.xOrigin!=0.0||cal.yOrigin!=0.0)) {
+			cal.xOrigin -= roi.getBounds().x;
+			cal.yOrigin -= roi.getBounds().y;
+		}	
+		imp2.setTitle(newTitle);
+		imp2.setProp("UniqueName","true");
+		if (roi!=null && roi.isArea() && roi.getType()!=Roi.RECTANGLE) {
+			Roi roi2 = (Roi)cropRoi(imp, roi).clone();
+			roi2.setLocation(0, 0);
+			imp2.setRoi(roi2);
+		}
+		imp2.show();
+		if (stackSize>1 && imp2.getStackSize()==stackSize)
+			imp2.setSlice(imp.getCurrentSlice());
+		if (isRotatedRect)
+			straightenRotatedRect(impA, roiA, imp2);
+	}
+	
+	private void recordCrop(ImagePlus imp) {
+		if (!Recorder.record)
+			return;
+		if (imp.getStackSize()==1) {
+			if (imp.getRoi()==null || ignoreSelection)
+				Recorder.recordCall("imp = imp.duplicate();");
+			else
+				Recorder.recordCall("imp = imp.crop();");
+		} else if (imp.getRoi()==null || ignoreSelection) {
+			if (duplicateStack)
+				Recorder.recordCall("imp = imp.duplicate();");
+			else
+				Recorder.recordCall("imp = imp.crop(\"whole-slice\");");
+		} else {
+			if (duplicateStack)
+				Recorder.recordCall("imp = imp.crop();");
+			else
+				Recorder.recordCall("imp = imp.crop(\"slice\");");
+		}
+	}
+	
+ /** Rotates duplicated part of image
+	- impA is original image,
+	- roiA is orig rotatedRect
+	- impB contains duplicated overlapping bounding rectangle	
+	processing steps:
+	- increase canvas of impB before rotation
+	- rotate impB
+	- calculate excentricity
+	- translate to compensate excentricity 
+	- create orthogonal rectangle in center
+	- crop to impC	
+	Author: N. Vischer
+	*/
+	private void straightenRotatedRect(ImagePlus impA, Roi roiA, ImagePlus impB) {
+		impB.deleteRoi(); //we have it in roiA
+		Color colorBack = Toolbar.getBackgroundColor();	
+		IJ.setBackgroundColor(0,0,0);
+		String title = impB.getTitle();
+		if(impB.getOverlay() != null)
+			impB.getOverlay().clear();
+		int boundLeft = roiA.getBounds().x;
+		int boundTop = roiA.getBounds().y;
+		int boundWidth = roiA.getBounds().width;
+		int boundHeight = roiA.getBounds().height;
+
+		float[] xx = roiA.getFloatPolygon().xpoints;
+		float[] yy = roiA.getFloatPolygon().ypoints;
+
+		double dx1 = xx[1] - xx[0];//calc sides and angle
+		double dy1 = yy[1] - yy[0];
+		double dx2 = xx[2] - xx[1];
+		double dy2 = yy[2] - yy[1];
+
+		double rrWidth = Math.sqrt(dx1 * dx1 + dy1 * dy1);//width of rot rect
+		double rrHeight = Math.sqrt(dx2 * dx2 + dy2 * dy2);
+		double rrDia = Math.sqrt(rrWidth * rrWidth + rrHeight * rrHeight);
+
+		double phi1 = -Math.atan2(dy1, dx1);
+		double phi0 = phi1 * 180 / Math.PI;
+
+		double usedL = Math.max(boundLeft, 0); //usedrect is orthogonal rect to be rotated
+		double usedR = Math.min(boundLeft + boundWidth, impA.getWidth());
+		double usedT = Math.max(boundTop, 0);
+		double usedB = Math.min(boundTop + boundHeight, impA.getHeight());
+		double usedCX = (usedL + usedR) / 2;
+		double usedCY = (usedT + usedB) / 2; //Center of UsedRect
+
+		double boundsCX = boundLeft + boundWidth / 2;//Center of Bound = center of RotRect
+		double boundsCY = boundTop + boundHeight / 2;
+
+		double dx3 = boundsCX - usedCX;//calculate excentricity
+		double dy3 = boundsCY - usedCY;
+		double rad3 = Math.sqrt(dx3 * dx3 + dy3 * dy3);
+		double phi3 = Math.atan2(dy3, dx3);
+		double phi4 = phi3 + phi1;
+		double dx4 = -rad3 * Math.cos(phi4);
+		double dy4 = -rad3 * Math.sin(phi4);
+
+		//Increase canvas to a square large enough for rotation
+		ImageStack stackOld = impB.getStack();
+		int currentSlice = impB.getCurrentSlice();
+		double xOff = (rrDia - (usedR - usedL)) / 2;//put img in center
+		double yOff = (rrDia - (usedB - usedT)) / 2;
+
+		ImageStack stackNew = (new CanvasResizer()).expandStack(stackOld, (int) rrDia, (int) rrDia, (int) xOff, (int) yOff);
+		impB.setStack(stackNew);
+		ImageProcessor ip = impB.getProcessor();
+		ip.setInterpolationMethod(ImageProcessor.BILINEAR);
+		ip.setBackgroundValue(0);
+
+		for (int slc = 0; slc < stackNew.size(); slc++) {
+			impB.setSlice(slc+1);
+			ip.rotate(phi0); //Rotate
+			ip.translate(dx4, dy4); //Translate
+		}
+
+		int x = (impB.getWidth() - (int) rrWidth) / 2;
+		int y = (impB.getHeight() - (int) rrHeight) / 2;
+
+		impB.setStack(impB.getStack().crop(x, y, 0, (int) rrWidth, (int) rrHeight, impB.getStack().getSize()));//Crop
+		impB.setSlice(currentSlice);
+		impB.setTitle(title);
+		impB.show();
+		impB.updateAndDraw();
+		impA.setRoi(roiA); //restore rotated rect in source image
+		Toolbar.setBackgroundColor(colorBack);
+	}	
+	                
+	/** Returns a copy of the image, stack or hyperstack contained in the specified ImagePlus.
+	* @see ij.ImagePlus#duplicate
+	*/
+	public ImagePlus run(ImagePlus imp) {
+		if (imp.getStackSize()==1)
+			return crop(imp);
+		Rectangle rect = null;
+		Roi roi = imp.getRoi();
+		Roi roi2 = cropRoi(imp, roi);
+		if (roi2!=null && roi2.isArea())
+			rect = roi2.getBounds();
+		ImageStack stack = imp.getStack();
+		boolean virtualStack = stack.isVirtual();
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();
+		ImageStack stack2 = null;
+		int n = stack.size();
+		boolean showProgress = virtualStack || ((double)n*stack.getWidth()*stack.getHeight()>=209715200.0);
+		for (int i=1; i<=n; i++) {
+			if (showProgress) {
+				IJ.showStatus("Duplicating: "+i+"/"+n);
+				IJ.showProgress(i,n);
+			}
+			ImageProcessor ip2 = stack.getProcessor(i);
+			ip2.setRoi(rect);
+			ip2 = ip2.crop();
+			if (stack2==null)
+				stack2 = new ImageStack(ip2.getWidth(), ip2.getHeight(), imp.getProcessor().getColorModel());
+			stack2.addSlice(stack.getSliceLabel(i), ip2);
+		}
+		IJ.showProgress(1.0);
+		ImagePlus imp2 = imp.createImagePlus();
+		imp2.setStack("DUP_"+imp.getTitle(), stack2);
+		String info = (String)imp.getProperty("Info");
+		if (info!=null)
+			imp2.setProperty("Info", info);
+		imp2.setProperties(imp.getPropertiesAsArray());
+		imp2.setCalibration(imp.getCalibration());
+		int[] dim = imp.getDimensions();
+		imp2.setDimensions(dim[2], dim[3], dim[4]);
+		if (imp.isComposite()) {
+			imp2 = new CompositeImage(imp2, 0);
+			((CompositeImage)imp2).copyLuts(imp);
+		}
+		if (virtualStack)
+			imp2.setDisplayRange(min, max);
+		if (imp.isHyperStack())
+			imp2.setOpenAsHyperStack(true);
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null && !imp.getHideOverlay())
+			imp2.setOverlay(overlay.crop(rect));
+   		if (Recorder.record) {
+   			if (imp.getRoi()==null || ignoreSelection)
+   				Recorder.recordCall("imp = imp.duplicate();");
+   			else
+   				Recorder.recordCall("imp = imp.crop(\"stack\");");
+   		}
+		return imp2;
+	}
+	
+	/** Returns a copy the current image or stack slice, cropped if there is a selection.
+	* @see ij.ImagePlus#crop
+	* @see ij.ImagePlus#crop(String)
+	*/
+	public ImagePlus crop(ImagePlus imp) {
+		if (imp.getNChannels()>1 && imp.getCompositeMode()==IJ.COMPOSITE) {
+			int z = imp.getSlice();
+			int t = imp.getFrame();
+			return run(imp, 1, imp.getNChannels(), z, z, t, t);
+		}
+		boolean hyperstack = imp.isHyperStack();
+		int displayMode = imp.isComposite()?imp.getDisplayMode():0;
+		ImageProcessor ip = imp.getProcessor();
+		ImageProcessor ip2 = ip.crop();
+		ImagePlus imp2 = imp.createImagePlus();
+		imp2.setProcessor("DUP_"+imp.getTitle(), ip2);
+		String info = (String)imp.getProperty("Info");
+		if (info!=null)
+			imp2.setProperty("Info", info);
+		imp2.setProperties(imp.getPropertiesAsArray());
+		if (imp.isStack()) {
+			ImageStack stack = imp.getStack();
+			String label = stack.getSliceLabel(imp.getCurrentSlice());
+			if (label!=null) {
+				if (label.length()>250 && label.indexOf('\n')>0 && label.contains("0002,"))
+					imp2.setProperty("Info", label); // DICOM metadata
+				else
+					imp2.setProp("Slice_Label", label);					
+			}
+			if (imp.isComposite()) {
+				LUT lut = ((CompositeImage)imp).getChannelLut();
+				if (displayMode==IJ.GRAYSCALE)
+					imp2.getProcessor().setColorModel(null);
+				else
+					imp2.getProcessor().setColorModel(lut);
+			}
+		} else {
+			String label = imp.getProp("Slice_Label");
+			if (label!=null)
+				imp2.setProp("Slice_Label", label);
+		}
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null && !imp.getHideOverlay()) {
+			Overlay overlay2 = overlay.crop(ip.getRoi());
+ 			if (imp.getStackSize()>1) {
+ 				if (hyperstack) {
+ 					int c = imp.getC();
+ 					int z = imp.getZ();
+ 					int t = imp.getT();
+  					overlay2.crop(c,c,z,z,t,t);
+ 				} else
+ 					overlay2.crop(imp.getCurrentSlice(), imp.getCurrentSlice());
+ 			}
+ 			imp2.setOverlay(overlay2);
+ 		}
+		return imp2;
+	}
+	
+	/** Returns a new stack containing a subrange of the specified stack. */
+	public ImagePlus run(ImagePlus imp, int firstSlice, int lastSlice) {
+		Rectangle rect = null;
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.isArea())
+			rect = roi.getBounds();
+		ImageStack stack = imp.getStack();
+		boolean virtualStack = stack.isVirtual();
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();
+		ImageStack stack2 = null;	
+		int n = lastSlice-firstSlice+1;
+		boolean showProgress = virtualStack || ((double)n*stack.getWidth()*stack.getHeight()>=209715200.0);
+		for (int i=firstSlice; i<=lastSlice; i++) {
+			if (showProgress) {
+				IJ.showStatus("Duplicating: "+i+"/"+lastSlice);
+				IJ.showProgress(i-firstSlice,n);
+			}
+			ImageProcessor ip2 = stack.getProcessor(i);
+			ip2.setRoi(rect);
+			ip2 = ip2.crop();
+			if (stack2==null)
+				stack2 = new ImageStack(ip2.getWidth(), ip2.getHeight(), imp.getProcessor().getColorModel());
+			stack2.addSlice(stack.getSliceLabel(i), ip2);
+		}
+		IJ.showProgress(1.0);
+		ImagePlus imp2 = imp.createImagePlus();
+		imp2.setStack("DUP_"+imp.getTitle(), stack2);
+		String info = (String)imp.getProperty("Info");
+		if (info!=null)
+			imp2.setProperty("Info", info);
+		imp2.setProperties(imp.getPropertiesAsArray());
+		int size = stack2.getSize();
+		boolean tseries = imp.getNFrames()==imp.getStackSize();
+		if (tseries)
+			imp2.setDimensions(1, 1, size);
+		else
+			imp2.setDimensions(1, size, 1);
+		if (virtualStack)
+			imp2.setDisplayRange(min, max);
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null && !imp.getHideOverlay()) {
+			Overlay overlay2 = overlay.crop(rect);
+			overlay2.crop(firstSlice, lastSlice);
+			imp2.setOverlay(overlay2);
+		}
+   		if (Recorder.record)
+   			Recorder.recordCall("imp = imp.crop(\""+firstSlice+"-"+lastSlice+"\");");
+		return imp2;
+	}
+
+	/** Returns a new hyperstack containing a possibly reduced version of the input image. */
+	public ImagePlus run(ImagePlus imp, int firstC, int lastC, int firstZ, int lastZ, int firstT, int lastT) {
+		Rectangle rect = null;
+		Roi roi = imp.getRoi();
+		Roi roi2 = cropRoi(imp, roi);
+		if (roi2!=null && roi2.isArea())
+			rect = roi2.getBounds();
+		ImageStack stack = imp.getStack();
+		ImageStack stack2 = null;
+		for (int t=firstT; t<=lastT; t++) {
+			for (int z=firstZ; z<=lastZ; z++) {
+				for (int c=firstC; c<=lastC; c++) {
+					int n1 = imp.getStackIndex(c, z, t);
+					ImageProcessor ip = stack.getProcessor(n1);
+					String label = stack.getSliceLabel(n1);
+					ip.setRoi(rect);
+					ip = ip.crop();
+					if (stack2==null)
+						stack2 = new ImageStack(ip.getWidth(), ip.getHeight(), null);
+					stack2.addSlice(label, ip);
+				}
+			}
+		}
+		ImagePlus imp2 = imp.createImagePlus();
+		imp2.setStack("DUP_"+imp.getTitle(), stack2);
+		imp2.setDimensions(lastC-firstC+1, lastZ-firstZ+1, lastT-firstT+1);
+		if (imp.isComposite()) {
+			int mode =imp.getDisplayMode();
+			if (lastC>firstC) {
+				imp2 = new CompositeImage(imp2, mode);
+				int i2 = 1;
+				for (int i=firstC; i<=lastC; i++) {
+					LUT lut = ((CompositeImage)imp).getChannelLut(i);
+					((CompositeImage)imp2).setChannelLut(lut, i2++);
+				}
+				if (imp.getNChannels()==imp2.getNChannels()) {	
+					boolean[] active = ((CompositeImage)imp).getActiveChannels();
+					boolean[] active2 = ((CompositeImage)imp2).getActiveChannels();
+					if (active!=null && active2!=null && active.length==active2.length) {
+						for (int i=0; i<active.length; i++)
+							active2[i] = active[i];
+					}
+				}
+			} else if (firstC==lastC) {
+				LUT lut = ((CompositeImage)imp).getChannelLut(firstC);
+				if (mode==IJ.GRAYSCALE)
+					imp2.getProcessor().setColorModel(null);
+				else
+					imp2.getProcessor().setColorModel(lut);
+				imp2.setDisplayRange(lut.min, lut.max);
+			}
+        }
+		imp2.setOpenAsHyperStack(true);
+		Calibration cal = imp2.getCalibration();
+		if (roi!=null && (cal.xOrigin!=0.0||cal.yOrigin!=0.0)) {
+			cal.xOrigin -= roi.getBounds().x;
+			cal.yOrigin -= roi.getBounds().y;
+		}
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null && !imp.getHideOverlay()) {
+			Overlay overlay2 = overlay.crop(roi2!=null?roi2.getBounds():null);
+			int nChannels = imp.getNChannels();
+			int nSlices = imp.getNSlices();
+			int nFrames = imp.getNFrames();
+			if (!(firstC==1&&lastC==nChannels&&firstZ==1&&lastZ==nSlices&&firstT==1&&lastT==nFrames))
+				overlay2.crop(firstC, lastC, firstZ, lastZ, firstT, lastT);
+			imp2.setOverlay(overlay2);
+		}
+   		if (Recorder.record)
+   			Recorder.recordCall("imp = new Duplicator().run(imp, "+firstC+", "+lastC+", "+firstZ+", "+lastZ+", "+firstT+", "+lastT+");");
+		return imp2;
+	}
+
+	String showDialog(ImagePlus imp, String dialogTitle, String prompt) {
+		int stackSize = imp.getStackSize();
+		String options = Macro.getOptions();
+		boolean isRoi = imp.getRoi()!=null;
+		boolean isMacro = options!=null;
+		duplicateStack = stackSize>1 && duplicateStack && !isMacro;
+		legacyMacro = options!=null && (options.contains("duplicate")||!options.contains("use"));
+		String title = getNewTitle();
+		if (title==null) title=defaultTitle;
+		GenericDialog gd = new GenericDialog(dialogTitle);
+		this.gd = gd;
+		gd.addStringField(prompt, title, 15);
+		if (isRoi)
+			gd.addCheckbox("Ignore selection", ignoreSelection);
+		if (stackSize>1) {
+			gd.addCheckbox("Duplicate stack", duplicateStack);
+			gd.setInsets(2, 30, 3);
+			gd.addStringField("Range:", "1-"+stackSize);
+			if (!isMacro) {
+				stackCheckbox = (Checkbox)(gd.getCheckboxes().elementAt(gd.getCheckboxes().size()-1));
+				stackCheckbox.addItemListener(this);
+				Vector v = gd.getStringFields();
+				titleField = (TextField)v.elementAt(0);
+				rangeField = (TextField)v.elementAt(1);
+				titleField.addTextListener(this);
+				rangeField.addTextListener(this);
+			}
+		}
+		gd.setSmartRecording(true);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return null;
+		title = gd.getNextString();
+		if (isRoi)
+			ignoreSelection = gd.getNextBoolean();
+		if (stackSize>1) {
+			duplicateStack = gd.getNextBoolean();
+			if (duplicateStack) {
+				String[] range = Tools.split(gd.getNextString(), " -");
+				double d1 = gd.parseDouble(range[0]);
+				double d2 = range.length==2?gd.parseDouble(range[1]):Double.NaN;
+				first = Double.isNaN(d1)?1:(int)d1;
+				last = Double.isNaN(d2)?stackSize:(int)d2;
+				if (first<1) first = 1;
+				if (last>stackSize) last = stackSize;
+				if (first>last) {first=1; last=stackSize;}
+			} else {
+				first = 1;
+				last = stackSize;
+			}
+		}
+		if (!isMacro) {
+			staticDuplicateStack = duplicateStack;
+			if (!ignoreNextSelection) staticIgnoreSelection=ignoreSelection;
+		}
+		ignoreNextSelection = false;
+		if (Recorder.record && titleField!=null && titleField.getText().equals(sliceLabel))
+			Recorder.recordOption("use");
+		return title;
+	}
+	
+	private String getNewTitle() {
+		if (titleChanged)
+			return null;
+		String title = defaultTitle;
+		if (imp.getStackSize()>1 && !duplicateStack && !legacyMacro && (stackCheckbox==null||!stackCheckbox.getState())) {
+			ImageStack stack = imp.getStack();
+			String label = stack.getShortSliceLabel(imp.getCurrentSlice());
+			if (label!=null && label.length()==0)
+				label = null;
+			if (label!=null) {
+				title = label;
+				sliceLabel = label;
+			}
+		}
+		return title;
+	}
+	
+	void duplicateHyperstack(ImagePlus imp, String newTitle) {
+		newTitle = showHSDialog(imp, newTitle);
+		if (newTitle==null)
+			return;
+		ImagePlus imp2 = null;
+		Roi roi = imp.getRoi();
+		if (!duplicateStack) {
+			int nChannels = imp.getNChannels();
+			boolean singleComposite = imp.isComposite() && nChannels==imp.getStackSize();
+			if (!singleComposite && nChannels>1 && imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.COMPOSITE) {
+				firstC = 1;
+				lastC = nChannels;
+			} else
+				firstC = lastC = imp.getChannel();
+			firstZ = lastZ = imp.getSlice();
+			firstT = lastT = imp.getFrame();
+		}
+		imp2 = run(imp, firstC, lastC, firstZ, lastZ, firstT, lastT);
+		if (imp2==null) return;
+		imp2.setTitle(newTitle);
+		if (imp2.getWidth()==0 || imp2.getHeight()==0) {
+			IJ.error("Duplicator", "Selection is outside the image");
+			return;
+		}
+		if (roi!=null && roi.isArea() && roi.getType()!=Roi.RECTANGLE) {
+			Roi roi2 = (Roi)cropRoi(imp, roi).clone();
+			roi2.setLocation(0, 0);
+			imp2.setRoi(roi2);
+		}
+		imp2.show();
+		imp2.setPosition(imp.getC(), imp.getZ(), imp.getT());
+		if (IJ.isMacro()&&imp2.getWindow()!=null)
+			IJ.wait(50);
+	}
+
+	String showHSDialog(ImagePlus imp, String newTitle) {
+		int nChannels = imp.getNChannels();
+		int nSlices = imp.getNSlices();
+		int nFrames = imp.getNFrames();
+		boolean composite = imp.isComposite() && nChannels==imp.getStackSize();
+		String options = Macro.getOptions();
+		boolean isMacro = options!=null;
+		GenericDialog gd = new GenericDialog("Duplicate");
+		gd.addStringField("Title:", newTitle, 15);
+		gd.setInsets(12, 20, 8);
+		gd.addCheckbox("Duplicate hyperstack", (duplicateStack&&!isMacro)||composite);
+		int nRangeFields = 0;
+		if (nChannels>1) {
+			gd.setInsets(2, 30, 3);
+			gd.addStringField("Channels (c):", "1-"+nChannels);
+			nRangeFields++;
+		}
+		if (nSlices>1) {
+			gd.setInsets(2, 30, 3);
+			gd.addStringField("Slices (z):", "1-"+nSlices);
+			nRangeFields++;
+		}
+		if (nFrames>1) {
+			gd.setInsets(2, 30, 3);
+			gd.addStringField("Frames (t):", "1-"+nFrames);
+			nRangeFields++;
+		}
+		if (!isMacro) {
+			stackCheckbox = (Checkbox)(gd.getCheckboxes().elementAt(gd.getCheckboxes().size()-1));
+			stackCheckbox.addItemListener(this);
+			Vector v = gd.getStringFields();
+			rangeFields = new TextField[3];
+			for (int i=0; i<nRangeFields; i++) {
+				rangeFields[i] = (TextField)v.elementAt(i+1);
+				rangeFields[i].addTextListener(this);
+			}
+		}
+		gd.setSmartRecording(true);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return null;
+		newTitle = gd.getNextString();
+		duplicateStack = gd.getNextBoolean();
+		if (nChannels>1) {
+			String[] range = Tools.split(gd.getNextString(), " -");
+			double c1 = gd.parseDouble(range[0]);
+			double c2 = range.length==2?gd.parseDouble(range[1]):Double.NaN;
+			firstC = Double.isNaN(c1)?1:(int)c1;
+			lastC = Double.isNaN(c2)?firstC:(int)c2;
+			if (firstC<1) firstC = 1;
+			if (lastC>nChannels) lastC = nChannels;
+			if (firstC>lastC) {firstC=1; lastC=nChannels;}
+		} else
+			firstC = lastC = 1;
+		if (nSlices>1) {
+			String[] range = Tools.split(gd.getNextString(), " -");
+			double z1 = gd.parseDouble(range[0]);
+			double z2 = range.length==2?gd.parseDouble(range[1]):Double.NaN;
+			firstZ = Double.isNaN(z1)?1:(int)z1;
+			lastZ = Double.isNaN(z2)?firstZ:(int)z2;
+			if (firstZ<1) firstZ = 1;
+			if (lastZ>nSlices) lastZ = nSlices;
+			if (firstZ>lastZ) {firstZ=1; lastZ=nSlices;}
+		} else
+			firstZ = lastZ = 1;
+		if (nFrames>1) {
+			String[] range = Tools.split(gd.getNextString(), " -");
+			double t1 = gd.parseDouble(range[0]);
+			double t2 = range.length==2?gd.parseDouble(range[1]):Double.NaN;
+			firstT= Double.isNaN(t1)?1:(int)t1;
+			lastT = Double.isNaN(t2)?firstT:(int)t2;
+			if (firstT<1) firstT = 1;
+			if (lastT>nFrames) lastT = nFrames;
+			if (firstT>lastT) {firstT=1; lastT=nFrames;}
+		} else
+			firstT = lastT = 1;
+		if (!isMacro)
+			staticDuplicateStack = duplicateStack;
+		return newTitle;
+	}
+	
+	/*
+	* Returns the part of 'roi' overlaping 'imp'
+	* Author Marcel Boeglin 2013.12.15
+	*/
+	Roi cropRoi(ImagePlus imp, Roi roi) {
+		if (roi==null)
+			return null;
+		if (imp==null)
+			return roi;
+		Rectangle b = roi.getBounds();
+		int w = imp.getWidth();
+		int h = imp.getHeight();
+		if (b.x<0 || b.y<0 || b.x+b.width>w || b.y+b.height>h) {
+			ShapeRoi shape1 = new ShapeRoi(roi);
+			ShapeRoi shape2 = new ShapeRoi(new Roi(0, 0, w, h));
+			roi = shape2.and(shape1);
+		}
+		if (roi.getBounds().width==0 || roi.getBounds().height==0)
+			throw new IllegalArgumentException("Selection is outside the image");
+		return roi;
+	}
+
+	public static Overlay cropOverlay(Overlay overlay, Rectangle bounds) {
+		return overlay.crop(bounds);
+	}
+
+	public void textValueChanged(TextEvent e) {
+		if (IJ.debugMode) IJ.log("Duplicator.textValueChanged: "+e);
+		if (e.getSource()==titleField) {
+			if (!titleField.getText().equals(getNewTitle()))
+				titleChanged = true;
+		} else
+			stackCheckbox.setState(true);
+	}
+	
+	public void itemStateChanged(ItemEvent e) {
+		duplicateStack = stackCheckbox.getState();
+		if (titleField!=null) {
+			String title = getNewTitle();
+			if (title!=null && !title.equals(titleField.getText())) {
+				titleField.setText(title);
+				if (gd!=null) gd.setDefaultString(0, title);
+			}
+		}
+	}
+	
+	public static void ignoreNextSelection() {
+		ignoreNextSelection = true;
+	}
+	
+}
diff --git a/src/ij/plugin/EventListener.java b/src/ij/plugin/EventListener.java
new file mode 100644
index 0000000..f103c3f
--- /dev/null
+++ b/src/ij/plugin/EventListener.java
@@ -0,0 +1,94 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import java.awt.EventQueue;
+
+/** This plugin implements the Plugins/Utilities/Monitor Events command.
+	By implementing the IJEventListener, CommandListener, ImageListener
+	and RoiListener interfaces, it is able to monitor foreground and background
+	color changes, tool switches, Log window closings, command executions, image
+	window openings, closings and updates, and ROI changes.
+*/
+public class EventListener implements PlugIn, IJEventListener, ImageListener, RoiListener, CommandListener {
+
+	public void run(String arg) {
+		IJ.addEventListener(this);
+		Executer.addCommandListener(this);
+		ImagePlus.addImageListener(this);
+		Roi.addRoiListener(this);
+		IJ.log("EventListener started");
+	}
+	
+	public void eventOccurred(int eventID) {
+		switch (eventID) {
+			case IJEventListener.FOREGROUND_COLOR_CHANGED:
+				String c = Integer.toHexString(Toolbar.getForegroundColor().getRGB());
+				c = "#"+c.substring(2);
+				IJ.log("Changed foreground color to "+c);
+				break;
+			case IJEventListener.BACKGROUND_COLOR_CHANGED:
+				c = Integer.toHexString(Toolbar.getBackgroundColor().getRGB());
+				c = "#"+c.substring(2);
+				IJ.log("Changed background color to "+c);
+				break;
+			case IJEventListener.TOOL_CHANGED:
+				String name = IJ.getToolName();
+				IJ.log("Switched to the "+name+(name.endsWith("Tool")?"":" tool"));
+				break;
+			case IJEventListener.COLOR_PICKER_CLOSED:
+				IJ.log("Color picker closed");
+				break;
+			case IJEventListener.LOG_WINDOW_CLOSED:
+				IJ.removeEventListener(this);
+				Executer.removeCommandListener(this);
+				ImagePlus.removeImageListener(this);
+				Roi.removeRoiListener(this);
+				IJ.showStatus("Log window closed; EventListener stopped");
+				break;
+		}
+	}
+
+	// called when an image is opened
+	public void imageOpened(ImagePlus imp) {
+		IJ.log("Image opened: \""+imp.getTitle()+"\""+edt());
+	}
+
+	// Called when an image is closed
+	public void imageClosed(ImagePlus imp) {
+		IJ.log("Image closed: \""+imp.getTitle()+"\""+edt());
+	}
+
+	// Called when an image's pixel data is updated
+	public void imageUpdated(ImagePlus imp) {
+		IJ.log("Image updated: \""+imp.getTitle()+"\""+edt());
+	}
+	
+	// Called when an image is saved
+	public void imageSaved(ImagePlus imp) {
+		IJ.log("Image saved: \""+imp.getTitle()+"\""+edt());
+	}
+
+	private String edt() {
+		return EventQueue.isDispatchThread()?" (EDT)":" (not EDT)";
+	}
+	
+	public String commandExecuting(String command) {
+		IJ.log("Command executed: \""+command+"\" command");
+		return command;
+	}
+	
+	public  void roiModified(ImagePlus img, int id) {
+		String type = "UNKNOWN";
+		switch (id) {
+			case CREATED: type="CREATED"; break;
+			case MOVED: type="MOVED"; break;
+			case MODIFIED: type="MODIFIED"; break;
+			case EXTENDED: type="EXTENDED"; break;
+			case COMPLETED: type="COMPLETED"; break;
+			case DELETED: type="DELETED"; break;
+		}
+		IJ.log("ROI modified: "+(img!=null?img.getTitle():"")+", "+type);
+	}
+
+
+}
diff --git a/src/ij/plugin/FFT.java b/src/ij/plugin/FFT.java
new file mode 100644
index 0000000..4e71780
--- /dev/null
+++ b/src/ij/plugin/FFT.java
@@ -0,0 +1,614 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.ContrastEnhancer;
+import ij.measure.Calibration;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.util.*;
+
+/** 
+This class implements the FFT, Inverse FFT and Redisplay Power Spectrum commands 
+in the Process/FFT submenu. It is based on Arlo Reeves'	 
+Pascal implementation of the Fast Hartley Transform from NIH Image 
+(http://imagej.nih.gov/ij/docs/ImageFFT/). 
+The Fast Hartley Transform was restricted by U.S. Patent No. 4,646,256, but was placed 
+in the public domain by Stanford University in 1995 and is now freely available.
+
+Version 2008-08-25 inverse transform: mask is always symmetrized
+*/
+public class FFT implements PlugIn, Measurements {
+
+	// static settings
+	public static boolean displayRawPS;
+	public static boolean displayFHT;
+	public static boolean displayComplex;
+	private static boolean displayFFT = true;
+	private static boolean doFFT;
+	private static boolean reuseWindow;
+	public static String fileName;
+	
+	// settings as instance variables
+	private boolean iDisplayRawPS;
+	private boolean iDisplayFHT;
+	private boolean iDisplayComplex;
+	private boolean iDisplayFFT;
+	private boolean iDoFFT;
+
+	private ImagePlus imp, imp2;
+	private boolean padded;
+	private int originalWidth;
+	private int originalHeight;
+	private int stackSize = 1;
+	private int slice = 1;
+	private boolean showOutput = true;
+	
+		
+	public void run(String arg) {
+		if (arg.equals("options")) {
+			showDialog();
+			if (iDoFFT)
+				arg="fft";
+			else
+				return;
+		}
+		if (imp==null)
+			imp = IJ.getImage();
+		if (arg.equals("fft") && imp.isComposite()) {
+			if (!GUI.showCompositeAdvisory(imp,"FFT"))
+				return;
+		}
+		if (arg.equals("redisplay")) {
+			redisplayPowerSpectrum();
+			return;
+		}
+		if (arg.equals("swap"))	 {
+			if (imp.getWidth()==imp.getHeight()) {
+				swapQuadrants(imp.getStack());
+				imp.updateAndDraw();
+			} else
+				IJ.error("Swap Quadrants","Image must be square");
+			return;
+		}
+	   if (arg.equals("inverse")) {
+			if (imp.getTitle().startsWith("FHT of")) {
+				doFHTInverseTransform();
+				return;
+			}
+			if (imp.getStackSize()==2) {
+				doComplexInverseTransform();
+				return;
+			}
+		}
+		ImageProcessor ip = imp.getProcessor();
+		Object obj = imp.getProperty("FHT");
+		FHT fht = (obj instanceof FHT)?(FHT)obj:null;
+		stackSize = imp.getStackSize();
+		boolean inverse;
+		if (fht==null && arg.equals("inverse")) {
+			IJ.error("FFT", "Frequency domain image required");
+			return;
+		}
+		if (fht!=null) {
+			inverse = true;
+			imp.deleteRoi();
+		} else {
+			if (imp.getRoi()!=null)
+				ip = ip.crop();
+			fht = newFHT(ip);
+			inverse = false;
+		}
+		if (inverse)
+			doInverseTransform(fht);
+		else {
+			fileName = imp.getTitle();
+			doForwardTransform(fht);   
+		}	 
+		IJ.showProgress(1.0);
+		if (Recorder.record) {
+			if (inverse)
+   				Recorder.recordCall("imp = FFT.inverse(imp);");
+   			else
+   				Recorder.recordCall("imp = FFT.forward(imp); //see Help/Examples/JavaScript/FFT Filter");
+   		}
+	}
+
+	/**
+	 * Performs a forward FHT transform.
+	 * @param imp  A spatial  domain image, which is not modified
+	 * @return	A frequency domain version of the input image
+	 * @see #filter
+	 * @see #inverse
+	*/
+	public static ImagePlus forward(ImagePlus imp) {
+		FFT fft = new FFT();
+		fft.imp = imp;
+		fft.showOutput = false;
+		fft.run("forward");
+		return fft.imp2;
+	}
+
+	/**
+	 * Multiplies a Fourier domain image by a filter
+	 * @param imp A frequency domain image, which is modified.
+	 * @param filter  The filter, 32-bits (0-1) or 8-bits (0-255)
+	 * @see #forward
+	 * @see #inverse
+	 * @see #filter
+	*/
+	public static void multiply(ImagePlus imp, ImageProcessor filter) {
+		Object obj = imp.getProperty("FHT");
+		FHT fht = obj!=null&&(obj instanceof FHT)?(FHT)obj:null;
+		if (fht==null)
+			return;
+		int size = fht.getWidth();
+		boolean isFloat = filter.getBitDepth()==32;
+		if (!isFloat)
+			filter =  filter.convertToByte(true);					
+		filter = filter.resize(size, size);
+		swapQuadrants(filter);
+		float[] fhtPixels = (float[])fht.getPixels();
+		for (int i=0; i<fhtPixels.length; i++) {
+			if (isFloat)
+				fhtPixels[i] = fhtPixels[i]*filter.getf(i);
+			else
+				fhtPixels[i] = (float)(fhtPixels[i]*(filter.get(i)/255.0));
+		}
+	}
+	
+	/**
+	 * Performs an inverse FHT transform.
+	 * @param imp  A frequency domain image
+	 * @return	A spatial  domain version of the input image
+	 * @see #forward
+	 * @see #filter
+	*/
+	public static ImagePlus inverse(ImagePlus imp) {
+		FFT fft = new FFT();
+		fft.imp = imp;
+		fft.showOutput = false;
+		fft.run("inverse");
+		return fft.imp2;
+	}
+
+	/**
+	 * Does frequency domain fitering of the speciified image
+	 * @param imp The image to be filtered.
+	 * @param filter  The filter, 32-bits (0-1) or 8-bits (0-255)
+	 * @see #forward
+	 * @see #multiply
+	 * @see #inverse
+	*/
+	public static void filter(ImagePlus imp, ImageProcessor filter) {
+		Object obj = imp.getProperty("FHT");
+		FHT fht = obj!=null&&(obj instanceof FHT)?(FHT)obj:null;
+		if (fht!=null) {
+			FFT.multiply(imp, filter);
+			return;
+		}
+		ImagePlus imp2 = FFT.forward(imp);
+		FFT.multiply(imp2, filter);
+		imp.setProcessor(FFT.inverse(imp2).getProcessor());
+	}
+
+	/** Version of filter() that accepts an ImagePlus for the filter. */
+	public static void filter(ImagePlus imp, ImagePlus filter) {
+		filter(imp, filter.getProcessor());
+	}
+	
+	void doInverseTransform(FHT fht) {
+		fht = fht.getCopy();
+		doMasking(fht);
+		showStatus("Inverse transform");
+		fht.inverseTransform();
+		if (fht.quadrantSwapNeeded)
+			fht.swapQuadrants();
+		fht.resetMinAndMax();
+		ImageProcessor ip2 = fht;
+		if (fht.originalWidth>0) {
+			fht.setRoi(0, 0, fht.originalWidth, fht.originalHeight);
+			ip2 = fht.crop();
+		}
+		int bitDepth = fht.originalBitDepth>0?fht.originalBitDepth:imp.getBitDepth();
+		if (!showOutput && bitDepth!=24)
+			bitDepth = 32;
+		switch (bitDepth) {
+			case 8: ip2 = ip2.convertToByte(false); break;
+			case 16: ip2 = ip2.convertToShort(false); break;
+			case 24:
+				showStatus("Setting brightness");
+				if (fht.rgb==null || ip2==null) {
+					IJ.error("FFT", "Unable to set brightness");
+					return;
+				}
+				ColorProcessor rgb = (ColorProcessor)fht.rgb.duplicate();
+				rgb.setBrightness((FloatProcessor)ip2);
+				ip2 = rgb; 
+				fht.rgb = null;
+				break;
+			case 32: break;
+		}
+		if (bitDepth!=24 && fht.originalColorModel!=null)
+			ip2.setColorModel(fht.originalColorModel);
+		String title = imp.getTitle();
+		if (title.startsWith("FFT of "))
+			title = title.substring(7, title.length());
+		ImagePlus imp2 = new ImagePlus("Inverse FFT of "+title, ip2);
+		imp2.setCalibration(imp.getCalibration());
+		if (showOutput)
+			imp2.show();
+		else
+			this.imp2 = imp2;
+	}
+
+	void doForwardTransform(FHT fht) {
+		showStatus("Forward transform");
+		long t0 = System.currentTimeMillis();
+		fht.transform();
+		if (iDisplayRawPS || (displayRawPS&&!IJ.isMacro())) {
+			ImageProcessor rawps = fht.getRawPowerSpectrum();
+			if (rawps!=null) {
+				swapQuadrants(rawps);
+				ImagePlus imp2 = new ImagePlus("PS of "+fileName, rawps);
+				enhanceContrast(imp2);
+				imp2.show();
+			}
+		}
+		if (iDisplayFHT || (displayFHT&&!IJ.isMacro())) {
+			ImageProcessor ip2 = fht.duplicate();
+			swapQuadrants(ip2);
+			ImagePlus imp2 = new ImagePlus("FHT of "+FFT.fileName, ip2);
+			enhanceContrast(imp2);
+			setImageProperties(imp2, "Fast Hartley Transform");
+			imp2.show();
+		}
+		if (iDisplayComplex || (displayComplex&&!IJ.isMacro())) {
+			ImageStack ct = fht.getComplexTransform();
+			ImagePlus imp2 = new ImagePlus("Complex of "+FFT.fileName, ct);
+			enhanceContrast(imp2);
+			setImageProperties(imp2, "Complex Fourier Transform");
+			imp2.show();
+		}
+		if (!(iDisplayFHT || iDisplayComplex || iDisplayRawPS))
+			iDisplayFFT = true;
+		if (iDisplayFFT) {
+			showStatus("Calculating power spectrum");
+			ImageProcessor ps = fht.getPowerSpectrum();
+			String title = "FFT of "+imp.getTitle();
+			ImagePlus imp2 = new ImagePlus(title, ps);
+			if (showOutput) {
+				ImagePlus fftImage = reuseWindow?WindowManager.getImage(title):null;
+				if (fftImage!=null)
+					fftImage.setImage(imp2);
+				else
+					imp2.show((System.currentTimeMillis()-t0)+" ms");
+			}
+			fht.powerSpectrumMean = ps.getStats().mean;
+			imp2.setProperty("FHT", fht);
+			imp2.setCalibration(imp.getCalibration());
+			String properties = "Fast Hartley Transform\n";
+			properties += "width: "+fht.originalWidth + "\n";
+			properties += "height: "+fht.originalHeight + "\n";
+			properties += "bitdepth: "+fht.originalBitDepth + "\n";
+			imp2.setProperty("Info", properties);
+			if (!showOutput)
+				this.imp2 = imp2;
+		}
+	}
+	
+	private void setImageProperties(ImagePlus imp, String type) {
+		imp.setProp(" ", type);
+		imp.setProp("Original width", originalWidth);
+		imp.setProp("Original height", originalHeight);
+	}
+	
+	private void enhanceContrast(ImagePlus imp) {
+		IJ.run(imp, "Enhance Contrast", "saturated=0.35");
+	}
+	
+	FHT newFHT(ImageProcessor ip) {
+		FHT fht;
+		if (ip instanceof ColorProcessor) {
+			showStatus("Extracting brightness");
+			ImageProcessor ip2 = ((ColorProcessor)ip).getBrightness();
+			fht = new FHT(pad(ip2));
+			fht.rgb = (ColorProcessor)ip.duplicate(); // save so we can later update the brightness
+		} else
+			fht = new FHT(pad(ip));
+		if (padded) {
+			fht.originalWidth = originalWidth;
+			fht.originalHeight = originalHeight;
+		}
+		int bitDepth = imp.getBitDepth();
+		fht.originalBitDepth = bitDepth;
+		if (bitDepth!=24)
+			fht.originalColorModel = ip.getColorModel();
+		return fht;
+	}
+	
+	ImageProcessor pad(ImageProcessor ip) {
+		originalWidth = ip.getWidth();
+		originalHeight = ip.getHeight();
+		int maxN = Math.max(originalWidth, originalHeight);
+		int i = 2;
+		while(i<maxN) i *= 2;
+		if (i==maxN && originalWidth==originalHeight) {
+			padded = false;
+			return ip;
+		}
+		maxN = i;
+		showStatus("Padding to "+ maxN + "x" + maxN);
+		if (maxN>=65536) {
+			IJ.error("FFT", "Padded image is too large ("+maxN+"x"+maxN+")");
+			return null;
+		}
+		ImageStatistics stats = ImageStatistics.getStatistics(ip, MEAN, null);
+		ImageProcessor ip2 = ip.createProcessor(maxN, maxN);
+		ip2.setValue(stats.mean);
+		ip2.fill();
+		ip2.insert(ip, 0, 0);
+		padded = true;
+		Undo.reset();
+		return ip2;
+	}
+	
+	void showStatus(String msg) {
+		if (stackSize>1)
+			IJ.showStatus("FFT: " + slice+"/"+stackSize);
+		else
+			IJ.showStatus(msg);
+	}
+	
+	void doMasking(FHT ip) {
+		if (stackSize>1)
+			return;
+		float[] fht = (float[])ip.getPixels();
+		ImageProcessor mask = imp.getProcessor();
+		int bitDepth = mask.getBitDepth();
+		mask = mask.convertToByte(false);
+		if (mask.getWidth()!=ip.getWidth() || mask.getHeight()!=ip.getHeight())
+			return;
+		mask.resetRoi();
+		ImageStatistics stats = mask.getStats();
+		if (stats.histogram[0]==0 && stats.histogram[255]==0) {
+			if (bitDepth==8 && ip.powerSpectrumMean!=stats.mean)
+				IJ.showMessage("Inverse FFT", "No pixels have been set to 0 (black) or\n255 (white) so filtering will not be done.");
+			return;
+		}
+		boolean passMode = stats.histogram[255]!=0;
+		IJ.showStatus("Masking: "+(passMode?"pass":"filter"));
+		mask = mask.duplicate();
+		if (passMode)
+			changeValuesAndSymmetrize(mask, (byte)255, (byte)0); //0-254 become 0
+		else
+			changeValuesAndSymmetrize(mask, (byte)0, (byte)255); //1-255 become 255
+		for (int i=0; i<3; i++)
+			smooth(mask);
+		if (IJ.debugMode || IJ.altKeyDown())
+			new ImagePlus("mask", mask.duplicate()).show();
+		swapQuadrants(mask);
+		byte[] maskPixels = (byte[])mask.getPixels();
+		for (int i=0; i<fht.length; i++) {
+			fht[i] = (float)(fht[i]*(maskPixels[i]&255)/255.0);
+		}
+	}
+
+	// Change pixels not equal to v1 to the new value v2.
+	// For pixels equal to v1, also the symmetry-equivalent pixel is set to v1
+	// Requires a quadratic 8-bit image.
+	void changeValuesAndSymmetrize(ImageProcessor ip, byte v1, byte v2) {
+		byte[] pixels = (byte[])ip.getPixels();
+		int n = ip.getWidth();
+		for (int i=0; i<pixels.length; i++) {
+			if (pixels[i] == v1) {	//pixel has been edited for pass or filter, set symmetry-equivalent
+				if (i%n==0) {		//left edge
+					if (i>0) pixels[n*n-i] = v1;
+				} else if (i<n)		//top edge
+					pixels[n-i] = v1;
+				else				//no edge
+					pixels[n*(n+1)-i] = v1;
+			} else
+				pixels[i] = v2;		//reset all other pixel values
+		}
+	}
+
+	// Smooth an 8-bit square image with periodic boundary conditions
+	// by averaging over 3x3 pixels
+	// Requires a quadratic 8-bit image.
+	static void smooth(ImageProcessor ip) {
+		byte[] pixels = (byte[])ip.getPixels();
+		byte[] pixels2 = (byte[])pixels.clone();
+		int n = ip.getWidth();
+		int[] iMinus = new int[n];	//table of previous index modulo n
+		int[] iPlus = new int[n];	//table of next index modulo n
+		for (int i=0; i<n; i++) {	//creating the tables in advance is faster calculating each time
+			iMinus[i] = (i-1+n)%n;
+			iPlus[i] = (i+1)%n;
+		}
+		for (int y=0; y<n; y++) {
+			int offset1 = n*iMinus[y];
+			int offset2 = n*y;
+			int offset3 = n*iPlus[y];
+			for (int x=0; x<n; x++) {
+				int sum = (pixels2[offset1+iMinus[x]]&255)
+						+ (pixels2[offset1+x]&255)
+						+ (pixels2[offset1+iPlus[x]]&255)
+						+ (pixels2[offset2+iMinus[x]]&255)
+						+ (pixels2[offset2+x]&255)
+						+ (pixels2[offset2+iPlus[x]]&255)
+						+ (pixels2[offset3+iMinus[x]]&255)
+						+ (pixels2[offset3+x]&255)
+						+ (pixels2[offset3+iPlus[x]]&255);
+				pixels[offset2 + x] = (byte)((sum+4)/9);
+			}
+		}
+	}
+
+	void redisplayPowerSpectrum() {
+		FHT fht = (FHT)imp.getProperty("FHT");
+		if (fht==null)
+			{IJ.error("FFT", "Frequency domain image required"); return;}
+		ImageProcessor ps = fht.getPowerSpectrum();
+		imp.setProcessor(null, ps);
+	}
+	
+	public static void swapQuadrants(ImageProcessor ip) {
+ 		long time0 = System.currentTimeMillis();
+ 		ImageProcessor t1, t2;
+		int size = ip.getWidth()/2;
+		ip.setRoi(size,0,size,size);
+		t1 = ip.crop();
+  		ip.setRoi(0,size,size,size);
+		t2 = ip.crop();
+		ip.insert(t1,0,size);
+		ip.insert(t2,size,0);
+		ip.setRoi(0,0,size,size);
+		t1 = ip.crop();
+  		ip.setRoi(size,size,size,size);
+		t2 = ip.crop();
+		ip.insert(t1,size,size);
+		ip.insert(t2,0,0);
+		ip.resetRoi();
+		long time1 = System.currentTimeMillis();
+		//IJ.log(""+(time1-time0)+" "+ip);
+	}
+
+	void swapQuadrants(ImageStack stack) {
+		FHT fht = new FHT(new FloatProcessor(1, 1));
+		for (int i=1; i<=stack.size(); i++)
+			swapQuadrants(stack.getProcessor(i));
+	}
+	
+	void showDialog() {
+		if (!IJ.isMacro()) {
+			iDisplayRawPS = displayRawPS;
+			iDisplayFHT = displayFHT;
+			iDisplayComplex = displayComplex;
+			iDisplayFFT = displayFFT;
+			iDoFFT = doFFT;
+		}
+		GenericDialog gd = new GenericDialog("FFT Options");
+		gd.setInsets(0, 20, 0);
+		gd.addMessage("Display:");
+		gd.setInsets(5, 35, 0);
+		gd.addCheckbox("FFT (\"FFT of...\") window", iDisplayFFT);
+		gd.setInsets(0, 35, 0);
+		gd.addCheckbox("Raw power spectrum", iDisplayRawPS);
+		gd.setInsets(0, 35, 0);
+		gd.addCheckbox("Fast Hartley Transform", iDisplayFHT);
+		gd.setInsets(0, 35, 0);
+		gd.addCheckbox("Complex Fourier Transform", iDisplayComplex);
+		gd.setInsets(8, 20, 0);
+		gd.addCheckbox("Reuse \"FFT of...\" window", reuseWindow);
+		gd.addCheckbox("Do forward transform", iDoFFT);
+		gd.addHelp(IJ.URL+"/docs/menus/process.html#fft-options");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		iDisplayFFT = gd.getNextBoolean();
+		iDisplayRawPS = gd.getNextBoolean();
+		iDisplayFHT = gd.getNextBoolean();
+		iDisplayComplex = gd.getNextBoolean();
+		reuseWindow = gd.getNextBoolean();
+		iDoFFT = gd.getNextBoolean();
+		if (!IJ.isMacro()) {
+			displayRawPS = iDisplayRawPS;
+			displayFHT = iDisplayFHT;
+			displayComplex = iDisplayComplex;
+			displayFFT = iDisplayFFT;
+			doFFT = iDoFFT;
+		}
+	}
+	
+	void doFHTInverseTransform() {
+		FHT fht = new FHT(imp.getProcessor().duplicate(), true);
+		swapQuadrants(fht);
+		fht.inverseTransform();
+		fht.resetMinAndMax();
+		String name = WindowManager.getUniqueName(imp.getTitle().substring(7));
+		IJ.showProgress(1.0);
+		ImagePlus img = new ImagePlus(name, fht);
+		img = unpad(img);
+		img.show();
+	}
+
+	void doComplexInverseTransform() {
+		ImageStack stack = imp.getStack();
+		if (!stack.getSliceLabel(1).equals("Real"))
+			return;
+		int maxN = imp.getWidth();
+		swapQuadrants(stack);
+		float[] rein = (float[])stack.getPixels(1);
+		float[] imin = (float[])stack.getPixels(2);
+		float[] reout= new float[maxN*maxN];
+		float[] imout = new float[maxN*maxN];
+		c2c2DFFT(rein, imin, maxN, reout, imout);
+		ImageStack stack2 = new ImageStack(maxN, maxN);
+		swapQuadrants(stack);
+		stack2.addSlice("Real", reout);
+		stack2.addSlice("Imaginary", imout);
+		String name = WindowManager.getUniqueName(imp.getTitle().substring(10));
+		ImagePlus imp2 = new ImagePlus(name, stack2);
+		imp2 = unpad(imp2);
+		imp2.getProcessor().resetMinAndMax();
+		imp2.show();
+	}
+	
+	private ImagePlus unpad(ImagePlus img) {
+		int width = (int)imp.getNumericProp("Original width");
+		int height = (int)imp.getNumericProp("Original height");
+		if (width==0 || height==0 || (width==img.getWidth()&&height==img.getHeight()))
+			return img;
+		int i=2;
+		while (i<width) i *= 2;
+		if (i==width && width==height)
+			return img;
+		img.setRoi(0, 0, width, height);
+		return img.crop("stack");
+	}
+	
+	/** Complex to Complex Inverse Fourier Transform
+	*	Author: Joachim Wesner
+	*/
+	void c2c2DFFT(float[] rein, float[] imin, int maxN, float[] reout, float[] imout) {
+			FHT fht = new FHT(new FloatProcessor(maxN,maxN));
+			float[] fhtpixels = (float[])fht.getPixels();
+			// Real part of inverse transform
+			for (int iy = 0; iy < maxN; iy++)
+				  cplxFHT(iy, maxN, rein, imin, false, fhtpixels);
+			fht.inverseTransform();
+			// Save intermediate result, so we can do a "in-place" transform
+			float[] hlp = new float[maxN*maxN];
+			System.arraycopy(fhtpixels, 0, hlp, 0, maxN*maxN);
+			// Imaginary part of inverse transform
+			for (int iy = 0; iy < maxN; iy++)
+				  cplxFHT(iy, maxN, rein, imin, true, fhtpixels);
+			fht.inverseTransform();
+			System.arraycopy(hlp, 0, reout, 0, maxN*maxN);
+			System.arraycopy(fhtpixels, 0, imout, 0, maxN*maxN);
+	  }
+
+	/** Build FHT input for equivalent inverse FFT
+	*	Author: Joachim Wesner
+	*/
+	void cplxFHT(int row, int maxN, float[] re, float[] im, boolean reim, float[] fht) {
+			int base = row*maxN;
+			int offs = ((maxN-row)%maxN) * maxN;
+			if (!reim) {
+				  for (int c=0; c<maxN; c++) {
+						int l =	 offs + (maxN-c)%maxN;
+						fht[base+c] = ((re[base+c]+re[l]) - (im[base+c]-im[l]))*0.5f;
+				  }
+			} else {
+				  for (int c=0; c<maxN; c++) {
+						int l = offs + (maxN-c)%maxN;
+						fht[base+c] = ((im[base+c]+im[l]) + (re[base+c]-re[l]))*0.5f;
+				  }
+			}
+	  }
+	  
+}
+
diff --git a/src/ij/plugin/FFTMath.java b/src/ij/plugin/FFTMath.java
new file mode 100644
index 0000000..e7b8843
--- /dev/null
+++ b/src/ij/plugin/FFTMath.java
@@ -0,0 +1,163 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.text.*;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.io.*;
+
+/** The class implements the Process/FFT/Math command. */
+public class FFTMath implements PlugIn {
+
+    private static final int CONJUGATE_MULTIPLY=0, MULTIPLY=1, DIVIDE=2;
+    private static String[] ops = {"Correlate", "Convolve", "Deconvolve"};
+    private static int index1;
+    private static int index2;
+    private static int operation = CONJUGATE_MULTIPLY;
+    private static boolean doInverse = true;
+    private static String title = "Result";
+    private ImagePlus imp1, imp2;
+            
+    public void run(String arg) {
+        if (showDialog())
+            doMath(imp1, imp2);
+    }
+    
+    public boolean showDialog() {
+        int[] wList = WindowManager.getIDList();
+        if (wList==null) {
+            IJ.noImage();
+            return false;
+        }
+        int nGoodImages = 0;
+        for (int i=0; i<wList.length; i++) {
+            ImagePlus imp = WindowManager.getImage(wList[i]);
+            if (imp == null || imp.getWidth() != imp.getHeight() || !FHT.isPowerOf2(imp.getWidth()))
+                wList[i] = 0;               //mark images that are not a power of 2
+            else
+                nGoodImages++;
+        }
+        if (nGoodImages == 0) {
+        	IJ.error("FFT Math", "Images must be a power of 2 size (256x256, 512x512, etc.)");
+        	return false;
+        }
+        int[] wList2 = new int[nGoodImages];
+        String[] titles = new String[nGoodImages];
+        for (int i=0, i2=0; i<wList.length; i++) {
+            if (wList[i] == 0) continue;    //ignore this image, not power of 2
+            wList2[i2] = wList[i];
+            ImagePlus imp = WindowManager.getImage(wList2[i2]);
+            if (imp!=null)
+                titles[i2] = imp.getTitle();
+            else
+                titles[i2] = "";
+            i2++;
+        }
+        if (index1>=wList2.length) index1 = 0;
+        if (index2>=wList2.length) index2 = 0;
+        if (WindowManager.getImage(title)!=null)
+            title = WindowManager.getUniqueName(title);
+        GenericDialog gd = new GenericDialog("FFT Math");
+        gd.addChoice("Image1: ", titles, titles[index1]);
+        gd.addChoice("Operation:", ops, ops[operation]);
+        gd.addChoice("Image2: ", titles, titles[index2]);
+        gd.addStringField("Result:", title);
+        gd.addCheckbox("Do inverse transform", doInverse);
+        gd.addHelp(IJ.URL+"/docs/menus/process.html#fft-math");
+        gd.showDialog();
+        if (gd.wasCanceled())
+            return false;
+        index1 = gd.getNextChoiceIndex();
+        operation = gd.getNextChoiceIndex();
+        index2 = gd.getNextChoiceIndex();
+        title = gd.getNextString();
+        doInverse = gd.getNextBoolean();
+        imp1 = WindowManager.getImage(wList2[index1]);
+        imp2 = WindowManager.getImage(wList2[index2]);
+        return true;
+   }
+    
+    public void doMath(ImagePlus imp1, ImagePlus imp2) {
+    	FHT h1, h2=null;
+    	ImageProcessor fht1, fht2;
+		fht1  = (ImageProcessor)imp1.getProperty("FHT");
+		if (fht1!=null)
+			h1 = new FHT(fht1);
+		else {
+			IJ.showStatus("Converting to float");
+       		ImageProcessor ip1 = imp1.getProcessor();
+       	 	h1 = new FHT(ip1);
+       	}
+		fht2  = (ImageProcessor)imp2.getProperty("FHT");
+		if (fht2!=null)
+			h2 = new FHT(fht2);
+		else {
+        	ImageProcessor ip2 = imp2.getProcessor();
+        	if (imp2!=imp1)
+       	 		h2 = new FHT(ip2);
+       	}
+        if (!h1.powerOf2Size()) {
+        	IJ.error("FFT Math", "Images must be a power of 2 size (256x256, 512x512, etc.)");
+        	return;
+        }
+        if (imp1.getWidth()!=imp2.getWidth()) {
+        	IJ.error("FFT Math", "Images must be the same size");
+        	return;
+        }
+		if (fht1==null) {
+			IJ.showStatus("Transform image1");
+			h1.transform();
+		}
+		if (fht2==null) {
+			if (h2==null)
+				h2 = new FHT(h1.duplicate());
+				else {
+					IJ.showStatus("Transform image2");
+					h2.transform();
+				}
+		}
+		FHT result=null;
+		switch (operation) {
+			case CONJUGATE_MULTIPLY: 
+				IJ.showStatus("Complex conjugate multiply");
+				result = h1.conjugateMultiply(h2); 
+				break;
+			case MULTIPLY: 
+				IJ.showStatus("Fourier domain multiply");
+				result = h1.multiply(h2); 
+				break;
+			case DIVIDE: 
+				IJ.showStatus("Fourier domain divide");
+				result = h1.divide(h2); 
+				break;
+		}
+		ImagePlus imp3 = null;
+		if (doInverse) {
+			IJ.showStatus("Inverse transform");
+			result.inverseTransform();
+			IJ.showStatus("Swap quadrants");
+			result.swapQuadrants();
+			IJ.showStatus("Display image");
+			result.resetMinAndMax();
+			imp3 = new ImagePlus(title, result);
+		} else {
+			IJ.showStatus("Power spectrum");
+			ImageProcessor ps = result.getPowerSpectrum();
+			imp3 = new ImagePlus(title, ps.convertToFloat());
+			result.quadrantSwapNeeded = true;
+			imp3.setProperty("FHT", result);
+		}
+		Calibration cal1 = imp1.getCalibration();
+		Calibration cal2 = imp2.getCalibration();
+		Calibration cal3 = cal1.scaled() ? cal1 : cal2;
+		if (cal1.scaled() && cal2.scaled() && !cal1.equals(cal2))
+			cal3 = null;                //can't decide between different calibrations
+		imp3.setCalibration(cal3);
+		cal3 = imp3.getCalibration();   //imp3 has a copy, which we may modify
+		cal3.disableDensityCalibration();
+		imp3.show();
+		IJ.showProgress(1.0);
+    }
+
+}
diff --git a/src/ij/plugin/FITS_Reader.java b/src/ij/plugin/FITS_Reader.java
new file mode 100644
index 0000000..0e14df4
--- /dev/null
+++ b/src/ij/plugin/FITS_Reader.java
@@ -0,0 +1,191 @@
+package ij.plugin;
+import java.awt.*;
+import java.io.*;
+import java.util.zip.GZIPInputStream;
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import ij.measure.*;
+
+/** Opens and displays FITS images. The FITS format is 
+ * described at "http://fits.gsfc.nasa.gov/fits_standard.html".
+ * Add setOption("FlipFitsImages",false) to the
+ * Edit/Options/Startup dialog to have FITS images not
+ * flipped vertically.
+*/
+public class FITS_Reader extends ImagePlus implements PlugIn {
+	private static boolean flipImages = true;
+
+	public void run(String arg) {
+		OpenDialog od = new OpenDialog("Open FITS...", arg);
+		String directory = od.getDirectory();
+		String fileName = od.getFileName();
+		if (fileName==null)
+			return;
+		IJ.showStatus("Opening: " + directory + fileName);
+		FitsDecoder fd = new FitsDecoder(directory, fileName);
+		FileInfo fi = null;
+		try {
+			fi = fd.getInfo();
+		} catch (IOException e) {}
+		if (fi!=null && fi.width>0 && fi.height>0 && fi.offset>0) {
+			FileOpener fo = new FileOpener(fi);
+			ImagePlus imp = fo.openImage();			
+			if (flipImages) {
+				if (fi.nImages==1) {
+				  ImageProcessor ip = imp.getProcessor();			   
+				  ip.flipVertical(); // origin is at bottom left corner
+				  setProcessor(fileName, ip);
+				} else {
+				  ImageStack stack = imp.getStack(); // origin is at bottom left corner				 
+				  for(int i=1; i<=stack.getSize(); i++)
+					  stack.getProcessor(i).flipVertical();
+				  setStack(fileName, stack);
+				}
+			}
+			setStack(fileName, imp.getStack());
+			Calibration cal = imp.getCalibration();
+			if (fi.fileType==FileInfo.GRAY16_SIGNED && fd.bscale==1.0 && fd.bzero==32768.0)
+				cal.setFunction(Calibration.NONE, null, "Gray Value");
+			setCalibration(cal);
+			setProperty("Info", fd.getHeaderInfo());
+			setFileInfo(fi); // needed for File->Revert
+			if (arg.equals("")) show();
+		} else
+			IJ.error("This does not appear to be a FITS file.");
+		IJ.showStatus("");
+	}
+
+	public static void flipImages(boolean flip) {
+		flipImages = flip;
+	}
+
+}
+
+class FitsDecoder {
+	private String directory, fileName;
+	private DataInputStream f;
+	private StringBuffer info = new StringBuffer(512);
+	double bscale, bzero;
+
+	public FitsDecoder(String directory, String fileName) {
+		this.directory = directory;
+		this.fileName = fileName;
+	}
+
+	FileInfo getInfo() throws IOException {
+		FileInfo fi = new FileInfo();
+		fi.fileFormat = FileInfo.FITS;
+		fi.fileName = fileName;
+		fi.directory = directory;
+		fi.width = 0;
+		fi.height = 0;
+		fi.offset = 0;
+
+		InputStream is = new FileInputStream(directory + fileName);
+		if (fileName.toLowerCase().endsWith(".gz")) is = new GZIPInputStream(is);
+		f = new DataInputStream(is);
+		String line = getString(80);
+		info.append(line+"\n");
+		if (!line.startsWith("SIMPLE"))
+			{f.close(); return null;}
+		int count = 1;
+		while ( true ) {
+			count++;
+			line = getString(80);
+			info.append(line+"\n");
+  
+			// Cut the key/value pair
+			int index = line.indexOf ( "=" );
+
+			// Strip out comments
+			int commentIndex = line.indexOf ( "/", index );
+			if ( commentIndex < 0 )
+				commentIndex = line.length ();
+			
+			// Split that values
+			String key;
+			String value;
+			if ( index >= 0 ) {
+				key = line.substring ( 0, index ).trim ();
+				value = line.substring ( index + 1, commentIndex ).trim ();
+			} else {
+				key = line.trim ();
+				value = "";
+			}
+			
+			// Time to stop ?
+			if (key.equals ("END") ) break;
+
+			// Look for interesting information			
+			if (key.equals("BITPIX")) {
+				int bitsPerPixel = Integer.parseInt ( value );
+			   if (bitsPerPixel==8)
+					fi.fileType = FileInfo.GRAY8;
+				else if (bitsPerPixel==16)
+					fi.fileType = FileInfo.GRAY16_SIGNED;
+				else if (bitsPerPixel==32)
+					fi.fileType = FileInfo.GRAY32_INT;
+				else if (bitsPerPixel==-32)
+					fi.fileType = FileInfo.GRAY32_FLOAT;
+				else if (bitsPerPixel==-64)
+					fi.fileType = FileInfo.GRAY64_FLOAT;
+				else {
+					IJ.error("BITPIX must be 8, 16, 32, -32 (float) or -64 (double).");
+					f.close();
+					return null;
+				}
+			} else if (key.equals("NAXIS1"))
+				fi.width = Integer.parseInt ( value );
+			else if (key.equals("NAXIS2"))
+				fi.height = Integer.parseInt( value );
+			else if (key.equals("NAXIS3")) //for multi-frame fits
+				fi.nImages = Integer.parseInt ( value );
+			else if (key.equals("BSCALE"))
+				bscale = parseDouble ( value );
+			else if (key.equals("BZERO"))
+				bzero = parseDouble ( value );
+		else if (key.equals("CDELT1"))
+				fi.pixelWidth = parseDouble ( value );
+		else if (key.equals("CDELT2"))
+				fi.pixelHeight = parseDouble ( value );
+		else if (key.equals("CDELT3"))
+				fi.pixelDepth = parseDouble ( value );
+		else if (key.equals("CTYPE1"))
+				fi.unit = value;
+
+			if (count>360 && fi.width==0)
+				{f.close(); return null;}
+		}
+		if (fi.pixelWidth==1.0 && fi.pixelDepth==1)
+			fi.unit = "pixel";
+
+		f.close();
+		fi.offset = 2880+2880*(((count*80)-1)/2880);
+		return fi;
+	}
+
+	String getString(int length) throws IOException {
+		byte[] b = new byte[length];
+		f.readFully(b);
+		if (IJ.debugMode)
+			IJ.log(new String(b));
+		return new String(b);
+	}
+
+	int getInteger(String s) {
+		s = s.substring(10, 30);
+		s = s.trim();
+		return Integer.parseInt(s);
+	}
+
+	double parseDouble(String s) throws NumberFormatException {
+		Double d = new Double(s);
+		return d.doubleValue();
+	}
+
+	String getHeaderInfo() {
+		return new String(info);
+	}
+	
+}
diff --git a/src/ij/plugin/FITS_Writer.java b/src/ij/plugin/FITS_Writer.java
new file mode 100644
index 0000000..b6b8943
--- /dev/null
+++ b/src/ij/plugin/FITS_Writer.java
@@ -0,0 +1,353 @@
+package ij.plugin;
+import java.io.*;
+import java.util.Properties; 
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import ij.measure.*;
+
+/**
+ * This plugin saves a 16 or 32 bit image in FITS format. It is a stripped-down version of the SaveAs_FITS 
+ *	plugin from the collection of astronomical image processing plugins by Jennifer West at
+ *	http://www.umanitoba.ca/faculties/science/astronomy/jwest/plugins.html.
+ *
+ * <br>Version 2010-11-23 : corrects 16-bit writing, adds BZERO & BSCALE updates (K.A. Collins, Univ. Louisville).
+ * <br>Version 2008-09-07 : preserves non-minimal FITS header if already present (F.V. Hessman, Univ. Goettingen).
+ * <br>Version 2008-12-15 : fixed END card recognition bug (F.V. Hessman, Univ. Goettingen).
+ * <br>Version 2019-11-03 : various updates  (K.A. Collins, CfA-Harvard and Smithsonian).
+ */
+public class FITS_Writer implements PlugIn {
+
+    private int numCards = 0;
+    private Calibration cal;
+    private boolean unsigned16 = false;
+    private double bZero = 0.0;
+    private double bScale = 1.0;
+            
+	public void run(String path) {
+		ImagePlus imp = IJ.getImage();
+		ImageProcessor ip = imp.getProcessor();
+		int numImages = imp.getImageStackSize();
+		int bitDepth = imp.getBitDepth();
+		if (bitDepth==24) {
+			IJ.error("RGB images are not supported");
+			return;
+		}
+
+		// GET PATH
+		if (path == null || path.trim().length() == 0) {
+			String title = "image.fits";
+			SaveDialog sd = new SaveDialog("Write FITS image",title,".fits");
+			path = sd.getDirectory()+sd.getFileName();
+		}
+
+		// GET FILE
+		File f = new File(path);
+		String directory = f.getParent()+File.separator;
+		String name = f.getName();
+		if (f.exists()) f.delete();
+		int numBytes = 0;
+        
+        cal = imp.getCalibration();
+        unsigned16 = (bitDepth==16 && cal.getFunction()==Calibration.NONE && cal.getCoefficients()==null);
+
+		// GET IMAGE
+		if (bitDepth==8) {
+            numBytes = 1;
+            if (cal.getFunction()!=Calibration.NONE && cal.getCoefficients()!=null) {
+                bZero = cal.getCoefficients()[0];
+                if (cal.getCoefficients()[1] != 0) bScale = cal.getCoefficients()[1];
+            }
+        } else if (ip instanceof ShortProcessor) {
+			numBytes = 2;
+            if (unsigned16) {
+                bZero = 32768.0;
+                bScale = 1.0;
+            } else {
+                if (cal.getCoefficients()[1] != 0) bScale = cal.getCoefficients()[1];
+                bZero = cal.getCoefficients()[0] + (32768.0*bScale);
+            }
+        } else if (ip instanceof FloatProcessor) {
+			numBytes = 4;  //float processor does not support calibration - data values are shifted and scaled in FITS_Reader
+            bZero = 0.0;   //float values are written back out without shifting
+            bScale = 1.0;  //and without scaling
+        }
+
+		int fillerLength = 2880 - ( (numBytes * imp.getWidth() * imp.getHeight()) % 2880 );
+
+		// WRITE FITS HEADER
+		String[] hdr = getHeader(imp);
+//		if (hdr == null)
+//			createHeader(path, ip, numBytes);
+//		else
+        createHeader(hdr, path, ip, numBytes);
+
+		// WRITE DATA
+		writeData(path, ip);
+		char[] endFiller = new char[fillerLength];
+		appendFile(endFiller, path);
+    }
+
+//	/**
+//	 * Creates a FITS header for an image which doesn't have one already.
+//	 */	
+//	void createHeader(String path, ImageProcessor ip, int numBytes) {
+//
+//		String bitperpix = "";
+//		if      (numBytes==2) {bitperpix = "                  16";}
+//		else if (numBytes==4) {bitperpix = "                 -32";}
+//		else if (numBytes==1) {bitperpix = "                   8";}
+// 		appendFile(writeCard("SIMPLE", "                   T", "Created by ImageJ FITS_Writer"), path);
+// 		appendFile(writeCard("BITPIX", bitperpix, "number of bits per data pixel"), path);
+// 		appendFile(writeCard("NAXIS", "                   2", "number of data axes"), path);
+// 		appendFile(writeCard("NAXIS1", "                "+ip.getWidth(), "length of data axis 1"), path);
+// 		appendFile(writeCard("NAXIS2", "                "+ip.getHeight(), "length of data axis 2"), path);
+//        if (bZero != 0 || bScale != 1.0)
+//            {
+//            appendFile(writeCard("BZERO", ""+bZero, "data range offset"), path);
+//            appendFile(writeCard("BSCALE", ""+bScale, "scaling factor"), path);
+//            }
+//
+//        int fillerSize = 2880 - ((numCards*80+3) % 2880);
+//		char[] end = new char[3];
+//		end[0] = 'E'; end[1] = 'N'; end[2] = 'D';
+//		char[] filler = new char[fillerSize];
+//		for (int i = 0; i < fillerSize; i++)
+//			filler[i] = ' ';
+// 		appendFile(end, path);
+// 		appendFile(filler, path);
+//	}
+
+	/**
+	 * Writes one line of a FITS header
+	 */ 
+	char[] writeCard(String title, String value, String comment) {
+		char[] card = new char[80];
+		for (int i = 0; i < 80; i++)
+			card[i] = ' ';
+		s2ch(title, card, 0);
+		card[8] = '=';
+		s2ch(value, card, 10);
+		card[31] = '/';
+		card[32] = ' ';
+		s2ch(comment, card, 33);
+        numCards++;
+		return card;
+	}
+    
+	void writeCard(char[] line, String path) {    
+        appendFile(line, path);
+        numCards++;
+    }
+    
+	/**
+	 * Converts a String to a char[]
+	 */
+	void s2ch (String str, char[] ch, int offset) {
+		int j = 0;
+		for (int i = offset; i < 80 && i < str.length()+offset; i++)
+			ch[i] = str.charAt(j++);
+	}
+    
+
+	/**
+	 * Appends 'line' to the end of the file specified by 'path'.
+	 */
+	void appendFile(char[] line, String path) {
+		try {
+			FileWriter output = new FileWriter(path, true);
+			output.write(line);
+			output.close();
+		} catch (IOException e) {
+			IJ.showStatus("Error writing file!");
+			return;
+		}
+	}
+			
+	/**
+	 * Appends the data of the current image to the end of the file specified by path.
+	 */
+	void writeData(String path, ImageProcessor ip) {
+		int w = ip.getWidth();
+		int h = ip.getHeight();
+		if (ip instanceof ByteProcessor) {
+			byte[] pixels = (byte[])ip.getPixels();
+			try {   
+				DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path,true)));
+				for (int i = h - 1; i >= 0; i-- )
+                    for (int j = i*w; j < w*(i+1); j++)
+                        dos.writeByte(pixels[j]);
+				dos.close();
+            } catch (IOException e) {
+				IJ.showStatus("Error writing file!");
+				return;
+            }    
+        } else if (ip instanceof ShortProcessor) {
+			short[] pixels = (short[])ip.getPixels();
+			try {   
+				DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path,true)));
+                for (int i = h - 1; i >= 0; i-- )
+                    for (int j = i*w; j < w*(i+1); j++)
+                        dos.writeShort(pixels[j]^0x8000);
+				dos.close();
+            } catch (IOException e) {
+				IJ.showStatus("Error writing file!");
+				return;
+            }
+		} else if (ip instanceof FloatProcessor) {
+			float[] pixels = (float[])ip.getPixels();
+			try {   
+				DataOutputStream dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path,true)));
+				for (int i = h - 1; i >= 0; i-- )
+                    for (int j = i*w; j < w*(i+1); j++)
+					dos.writeFloat(pixels[j]);
+				dos.close();
+            } catch (IOException e) {
+				IJ.showStatus("Error writing file!");
+				return;
+                }					   
+            }
+        }
+
+	/**
+	 * Extracts the original FITS header from the Properties object of the
+	 * ImagePlus image (or from the current slice label in the case of an ImageStack)
+	 * and returns it as an array of String objects representing each card.
+	 *
+	 * Taken from the ImageJ astroj package (www.astro.physik.uni-goettingen.de/~hessman/ImageJ/Astronomy)
+	 *
+	 * @param img		The ImagePlus image which has the FITS header in it's "Info" property.
+	 */
+	public static String[] getHeader (ImagePlus img) {
+		String content = null;
+
+		int depth = img.getStackSize();
+		if (depth == 1) {
+			Properties props = img.getProperties();
+			if (props == null)
+				return null;
+			content = (String)props.getProperty ("Info");
+		}
+		else if (depth > 1) {
+			int slice = img.getCurrentSlice();
+			ImageStack stack = img.getStack();
+			content = stack.getSliceLabel(slice);
+            if (content == null) {
+                Properties props = img.getProperties();
+                if (props == null)
+                    return null;
+                content = (String)props.getProperty ("Info");  
+            }
+        }
+		if (content == null)
+			return null;
+
+		// PARSE INTO LINES
+
+		String[] lines = content.split("\n");
+
+		// FIND "SIMPLE" AND "END" KEYWORDS
+
+		int istart = 0;
+		for (; istart < lines.length; istart++) {
+			if (lines[istart].startsWith("SIMPLE") ) break;
+		}
+		if (istart == lines.length) return null;
+
+		int iend = istart+1;
+		for (; iend < lines.length; iend++) {
+			String s = lines[iend].trim();
+			if ( s.equals ("END") || s.startsWith ("END ") ) break;
+		}
+		if (iend >= lines.length) return null;
+
+		int l = iend-istart+1;
+		String header = "";
+		for (int i=0; i < l; i++)
+			header += lines[istart+i]+"\n";
+		return header.split("\n");
+	}
+
+	/**
+	 * Converts a string into an 80-char array.
+	 */
+	char[] eighty(String s) {
+		char[] c = new char[80];
+		int l=s.length();
+		for (int i=0; i < l && i < 80; i++)
+			c[i]=s.charAt(i);
+		if (l < 80) {
+			for (; l < 80; l++) c[l]=' ';
+		}
+		return c;
+	}
+
+	/**
+	 * Copies the image header contained in the image's Info property.
+	 */
+	void createHeader(String[] hdr, String path, ImageProcessor ip, int numBytes) {
+		String bitperpix = "";
+        int imw=ip.getWidth();
+        int imh=ip.getHeight();
+        String wbuf = "               ";
+        String hbuf = "               ";
+        if (imw < 10000)
+            wbuf = wbuf + " ";
+        if (imw < 1000)
+            wbuf = wbuf + " ";
+        if (imw < 100)
+            wbuf = wbuf + " ";
+        if (imw < 10)
+            wbuf = wbuf + " ";
+        if (imh < 10000)
+            hbuf = hbuf + " ";
+        if (imh < 1000)
+            hbuf = hbuf + " ";
+        if (imh < 100)
+            hbuf = hbuf + " ";
+        if (imh < 10)
+            hbuf = hbuf + " ";        
+		// THESE KEYWORDS NEED TO BE MADE CONFORMAL WITH THE PRESENT IMAGE
+		if      (numBytes==2) {bitperpix = "                  16";}
+		else if (numBytes==4) {bitperpix = "                 -32";}
+		else if (numBytes==1) {bitperpix = "                   8";}
+ 		appendFile(writeCard("SIMPLE", "                   T", "Created by ImageJ FITS_Writer"), path);
+ 		appendFile(writeCard("BITPIX", bitperpix, "number of bits per data pixel"), path);
+ 		appendFile(writeCard("NAXIS", "                   2", "number of data axes"), path);
+		appendFile(writeCard("NAXIS1", wbuf + imw, "length of data axis 1"), path);
+ 		appendFile(writeCard("NAXIS2", hbuf + imh, "length of data axis 2"), path);
+        if (bZero != 0 || bScale != 1.0) {
+            appendFile(writeCard("BZERO", ""+bZero, "data range offset"), path);
+            appendFile(writeCard("BSCALE", ""+bScale, "scaling factor"), path);
+        }
+
+        if (hdr != null) {
+            // APPEND THE REST OF THE HEADER IF ONE EXISTS
+            char[] card;
+            for (int i=0; i < hdr.length; i++) {
+                String s = hdr[i];
+                card = eighty(s);
+                if (!s.startsWith("SIMPLE") &&
+                    !s.startsWith("BITPIX") &&
+                    !s.startsWith("NAXIS")  &&
+                    !s.startsWith("BZERO") &&
+                    !s.startsWith("BSCALE") &&
+                    !s.startsWith("END")   &&
+                    s.trim().length() > 1) {
+                        writeCard(card, path);
+                    }
+                }
+            }
+
+        // FINISH OFF THE HEADER
+        int fillerSize = 2880 - ((numCards*80+3) % 2880);
+        char[] end = new char[3];
+        end[0] = 'E'; end[1] = 'N'; end[2] = 'D';
+        char[] filler = new char[fillerSize];
+        for (int i = 0; i < fillerSize; i++)
+            filler[i] = ' ';
+        appendFile(end, path);
+        appendFile(filler, path);
+        }
+
+    }
diff --git a/src/ij/plugin/FileInfoVirtualStack.java b/src/ij/plugin/FileInfoVirtualStack.java
new file mode 100644
index 0000000..9836747
--- /dev/null
+++ b/src/ij/plugin/FileInfoVirtualStack.java
@@ -0,0 +1,288 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import java.awt.*;
+import java.io.*;
+import java.util.Properties;
+
+/** This plugin opens a multi-page TIFF file, or a set of raw images, as a 
+	virtual stack. It implements the File/Import/TIFF Virtual Stack command. */
+public class FileInfoVirtualStack extends VirtualStack implements PlugIn {
+	private FileInfo[] info;
+	private int nImages;
+	
+	/* Default constructor. */
+	public FileInfoVirtualStack() {}
+
+	/* Constructs a FileInfoVirtualStack from a FileInfo object. */
+	public FileInfoVirtualStack(FileInfo fi) {
+		info = new FileInfo[1];
+		info[0] = fi;
+		ImagePlus imp = open();
+		if (imp!=null)
+			imp.show();
+	}
+
+	/* Constructs a FileInfoVirtualStack from a FileInfo 
+		object and displays it if 'show' is true. */
+	public FileInfoVirtualStack(FileInfo fi, boolean show) {
+		info = new FileInfo[1];
+		info[0] = fi;
+		ImagePlus imp = open();
+		if (imp!=null && show)
+			imp.show();
+	}
+	
+	/* Constructs a FileInfoVirtualStack from an array of FileInfo objects. */
+	public FileInfoVirtualStack(FileInfo[] fi) {
+		info = fi;
+		nImages = info.length;
+	}
+
+	/** Opens the specified tiff file as a virtual stack. */
+	public static ImagePlus openVirtual(String path) {
+		OpenDialog  od = new OpenDialog("Open TIFF", path);
+		String name = od.getFileName();
+		String  dir = od.getDirectory();
+		if (name==null)
+			return null;
+		FileInfoVirtualStack stack = new FileInfoVirtualStack();
+		stack.init(dir, name);
+		if (stack.info==null)
+			return null;
+		else
+			return stack.open();
+	}
+
+	public void run(String arg) {
+		OpenDialog  od = new OpenDialog("Open TIFF", arg);
+		String name = od.getFileName();
+		String  dir = od.getDirectory();
+		if (name==null)
+			return;
+		init(dir, name);
+		if (info==null)
+			return;
+		ImagePlus imp = open();
+		if (imp!=null)
+			imp.show();
+	}
+	
+	private void init(String dir, String name) {
+		if (name.endsWith(".zip")) {
+			IJ.error("Virtual Stack", "ZIP compressed stacks not supported");
+			return;
+		}
+		TiffDecoder td = new TiffDecoder(dir, name);
+		if (IJ.debugMode) td.enableDebugging();
+		IJ.showStatus("Decoding TIFF header...");
+		try {
+			info = td.getTiffInfo();
+		} catch (IOException e) {
+			String msg = e.getMessage();
+			if (msg==null||msg.equals("")) msg = ""+e;
+			IJ.error("TiffDecoder", msg);
+			return;
+		}
+		if (info==null || info.length==0) {
+			IJ.error("Virtual Stack", "This does not appear to be a TIFF stack");
+			return;
+		}
+		if (IJ.debugMode)
+			IJ.log(info[0].debugInfo);
+	}
+		
+	private ImagePlus open() {
+		FileInfo fi = info[0];
+		int n = fi.nImages;
+		if (info.length==1 && n>1) {
+			n = validateNImages(fi);
+			info = new FileInfo[n];
+			long size = fi.width*fi.height*fi.getBytesPerPixel();
+			for (int i=0; i<n; i++) {
+				info[i] = (FileInfo)fi.clone();
+				info[i].nImages = 1;
+				info[i].longOffset = fi.getOffset() + i*(size + fi.getGap());
+			}
+		}
+		nImages = info.length;
+		FileOpener fo = new FileOpener(info[0]);
+		ImagePlus imp = fo.openImage();
+		if (nImages==1 && fi.fileType==FileInfo.RGB48)
+			return imp;
+		Properties props = fo.decodeDescriptionString(fi);
+		ImagePlus imp2 = new ImagePlus(fi.fileName, this);
+		imp2.setDisplayRange(imp.getDisplayRangeMin(),imp.getDisplayRangeMax());
+		imp2.setFileInfo(fi);
+		if (imp!=null && props!=null) {
+			setBitDepth(imp.getBitDepth());
+			imp2.setCalibration(imp.getCalibration());
+			imp2.setOverlay(imp.getOverlay());
+			if (fi.info!=null)
+				imp2.setProperty("Info", fi.info);
+			int channels = getInt(props,"channels");
+			int slices = getInt(props,"slices");
+			int frames = getInt(props,"frames");
+			if (channels*slices*frames==nImages) {
+				imp2.setDimensions(channels, slices, frames);
+				if (getBoolean(props, "hyperstack"))
+					imp2.setOpenAsHyperStack(true);
+			}
+			if (channels>1 && fi.description!=null) {
+				int mode = IJ.COMPOSITE;
+				if (fi.description.indexOf("mode=color")!=-1)
+					mode = IJ.COLOR;
+				else if (fi.description.indexOf("mode=gray")!=-1)
+					mode = IJ.GRAYSCALE;
+				imp2 = new CompositeImage(imp2, mode);
+			}
+		}
+		return imp2;
+	}
+	
+	private int validateNImages(FileInfo fi) {
+		File f = new File(fi.getFilePath());
+		if (!f.exists())
+			return fi.nImages;
+		long fileLength = f.length();
+		long bytesPerImage = fi.width*fi.height*fi.getBytesPerPixel();
+		for (int i=fi.nImages-1; i>=0; i--) {
+			long offset =  fi.getOffset() + i*(bytesPerImage+fi.getGap());
+			if (offset+bytesPerImage<=fileLength)
+				return i+1;
+		}
+		return fi.nImages;
+	}
+
+	int getInt(Properties props, String key) {
+		Double n = getNumber(props, key);
+		return n!=null?(int)n.doubleValue():1;
+	}
+
+	Double getNumber(Properties props, String key) {
+		String s = props.getProperty(key);
+		if (s!=null) {
+			try {
+				return Double.valueOf(s);
+			} catch (NumberFormatException e) {}
+		}	
+		return null;
+	}
+
+	boolean getBoolean(Properties props, String key) {
+		String s = props.getProperty(key);
+		return s!=null&&s.equals("true")?true:false;
+	}
+
+	/** Deletes the specified image, were 1<=n<=nImages. */
+	public void deleteSlice(int n) {
+		if (n<1 || n>nImages)
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		if (nImages<1) return;
+		for (int i=n; i<nImages; i++)
+			info[i-1] = info[i];
+		info[nImages-1] = null;
+		nImages--;
+	}
+	
+	/** Returns an ImageProcessor for the specified image,
+		were 1<=n<=nImages. Returns null if the stack is empty.
+	*/
+	public ImageProcessor getProcessor(int n) {
+		n = translate(n);  // update n for hyperstacks not in default CZT order
+		if (n<1 || n>nImages)
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		//if (n>1) IJ.log("  "+(info[n-1].getOffset()-info[n-2].getOffset()));
+		info[n-1].nImages = 1; // why is this needed?
+		ImageProcessor ip = null;
+		if (IJ.debugMode) {
+			long t0 = System.currentTimeMillis();
+			FileOpener fo = new FileOpener(info[n-1]);
+			ip = fo.openProcessor();
+			IJ.log("FileInfoVirtualStack: "+n+", offset="+info[n-1].getOffset()+", "+(System.currentTimeMillis()-t0)+"ms");
+		} else {
+			FileOpener fo = new FileOpener(info[n-1]);
+			if (info[n-1].fileType==FileInfo.RGB48) {
+				ImagePlus imp = fo.openImage();
+				if (info[n-1].sliceNumber>0)
+					imp.setSlice(info[n-1].sliceNumber);
+				ip = imp.getProcessor();
+			} else
+				ip = fo.openProcessor();
+		}
+		if (ip!=null)
+			return ip;
+		else {
+			int w=getWidth(), h=getHeight();
+			IJ.log("Read error or file not found ("+n+"): "+info[n-1].directory+info[n-1].fileName);
+			switch (getBitDepth()) {
+				case 8: return new ByteProcessor(w, h);
+				case 16: return new ShortProcessor(w, h);
+				case 24: return new ColorProcessor(w, h);
+				case 32: return new FloatProcessor(w, h);
+				default: return null;
+			}
+		}
+	 }
+ 
+	/** Returns the number of slices in this stack. */
+	public int size() {
+		return getSize();
+	}
+
+	public int getSize() {
+		return nImages;
+	}
+
+	/** Returns the label of the Nth image. */
+	public String getSliceLabel(int n) {
+		if (n<1 || n>nImages)
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		if (info[0].sliceLabels==null || info[0].sliceLabels.length!=nImages)
+			return null;
+		else
+			return info[0].sliceLabels[n-1];
+	}
+
+	public int getWidth() {
+		return info[0].width;
+	}
+	
+	public int getHeight() {
+		return info[0].height;
+	}
+	
+	/** Adds an image to this stack. */
+	public synchronized  void addImage(FileInfo fileInfo) {
+		nImages++;
+		if (info==null)
+			info = new FileInfo[250];
+		if (nImages==info.length) {
+			FileInfo[] tmp = new FileInfo[nImages*2];
+			System.arraycopy(info, 0, tmp, 0, nImages);
+			info = tmp;
+		}
+		info[nImages-1] = fileInfo;
+	}
+	
+	@Override
+	public String getDirectory() {
+		if (info!=null && info.length>0)
+			return info[0].directory;
+		else
+			return null;
+	}
+		
+	@Override
+	public String getFileName(int n) {
+		int index = n - 1;
+		if (index>=0 && info!=null && info.length>index)
+			return info[index].fileName;
+		else
+			return null;
+	}
+
+		
+}
diff --git a/src/ij/plugin/Filters3D.java b/src/ij/plugin/Filters3D.java
new file mode 100644
index 0000000..83de72d
--- /dev/null
+++ b/src/ij/plugin/Filters3D.java
@@ -0,0 +1,148 @@
+package ij.plugin;
+
+import ij.*;
+import ij.process.*;
+import ij.gui.GenericDialog;
+import ij.util.ThreadUtil;
+import ij.plugin.RGBStackMerge;
+import ij.gui.*;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/*
+ * This plugin implements most of the 3D filters in the Process/Filters submenu.
+ * @author Thomas Boudier
+ */
+public class Filters3D implements PlugIn {
+    public final static int MEAN=10, MEDIAN=11, MIN=12, MAX=13, VAR=14, MAXLOCAL=15;
+	private static float xradius = 2, yradius = 2, zradius = 2;
+
+	public void run(String arg) {
+		String name = null;
+		int filter = 0;
+		if (arg.equals("mean")) {
+			name = "3D Mean";
+			filter = MEAN;
+		} else if (arg.equals("median")) {
+			name = "3D Median";
+			filter = MEDIAN;
+		} else if (arg.equals("min")) {
+			name = "3D Minimum";
+			filter = MIN;
+		} else if (arg.equals("max")) {
+			name = "3D Maximum";
+			filter = MAX;
+		} else if (arg.equals("var")) {
+			name = "3D Variance";
+			filter = VAR;
+		} else
+			return;
+		ImagePlus imp = IJ.getImage();
+		if (imp.isComposite() && imp.getNChannels()==imp.getStackSize()) {
+			IJ.error(name, "Composite color images not supported");
+			return;
+		}
+		if (!showDialog(name))
+			return;
+		imp.startTiming();
+		run(imp, filter, xradius, yradius, zradius);
+		IJ.showTime(imp, imp.getStartTime(), "", imp.getStackSize());
+	}
+
+	private boolean showDialog(String name) {
+		GenericDialog gd = new GenericDialog(name);
+		gd.addNumericField("X radius:", xradius, 1);
+		gd.addNumericField("Y radius:", yradius, 1);
+		gd.addNumericField("Z radius:", zradius, 1);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			return false;
+		}
+		xradius = (float) gd.getNextNumber();
+		yradius = (float) gd.getNextNumber();
+		zradius = (float) gd.getNextNumber();
+		return true;
+	}
+
+	private void run(ImagePlus imp, int filter, float radX, float radY, float radZ) {
+		if (imp.isHyperStack()) {
+			filterHyperstack(imp, filter, radX, radY, radZ);
+			return;
+		}
+		ImageStack res = filter(imp.getStack(), filter, radX, radY, radZ);
+		imp.setStack(res);
+	}
+	
+	public static ImageStack filter(ImageStack stackorig, int filter, float vx, float vy, float vz) {
+	
+		if (stackorig.getBitDepth()==24)
+			return filterRGB(stackorig, filter, vx, vy, vz);
+
+		// get stack info
+		final ImageStack stack = stackorig;
+		final float voisx = vx;
+		final float voisy = vy;
+		final float voisz = vz;
+		final int width= stack.getWidth();
+		final int height= stack.getHeight();
+		final int depth= stack.size();
+		ImageStack res = null;
+		
+		if ((filter==MEAN) || (filter==MEDIAN) || (filter==MIN) || (filter==MAX) || (filter==VAR)) {
+			if (filter==VAR)
+				res = ImageStack.create(width, height, depth, 32);
+			else
+				res = ImageStack.create(width, height, depth, stackorig.getBitDepth());
+			IJ.showStatus("3D filtering...");
+			// PARALLEL 
+			final ImageStack out = res;
+			final AtomicInteger ai = new AtomicInteger(0);
+			final int n_cpus = Prefs.getThreads();
+
+			final int f = filter;
+			final int dec = (int) Math.ceil((double) stack.size() / (double) n_cpus);
+			Thread[] threads = ThreadUtil.createThreadArray(n_cpus);
+			for (int ithread = 0; ithread < threads.length; ithread++) {
+				threads[ithread] = new Thread() {
+					public void run() {
+						StackProcessor processor = new StackProcessor(stack);
+						for (int k = ai.getAndIncrement(); k < n_cpus; k = ai.getAndIncrement()) {
+							processor.filter3D(out, voisx, voisy, voisz, dec * k, dec * (k + 1), f);
+						}
+					}
+				};
+			}
+			ThreadUtil.startAndJoin(threads);
+		}
+		return res;
+	}
+	
+	private static void filterHyperstack(ImagePlus imp, int filter, float vx, float vy, float vz) {
+		if (imp.getNDimensions()>4) {
+			IJ.error("5D hyperstacks are currently not supported");
+			return;
+		}
+		if (imp.getNChannels()==1) {
+			ImageStack stack = filter(imp.getStack(), filter, vx, vy, vz);
+			imp.setStack(stack);
+			return;
+		}
+        ImagePlus[] channels = ChannelSplitter.split(imp);
+        int n = channels.length;
+        for (int i=0; i<n; i++) {
+			ImageStack stack = filter(channels[i].getStack(), filter, vx, vy, vz);
+			channels[i].setStack(stack);
+		}
+		ImagePlus imp2 = RGBStackMerge.mergeChannels(channels, false);
+		imp.setImage(imp2);
+		imp.setC(1);
+	}
+
+	private static ImageStack filterRGB(ImageStack rgb_in, int filter, float vx, float vy, float vz) {
+        ImageStack[] channels = ChannelSplitter.splitRGB(rgb_in, false);
+		ImageStack red = filter(channels[0], filter, vx, vy, vz);
+		ImageStack green = filter(channels[1], filter, vx, vy, vz);
+		ImageStack blue = filter(channels[2], filter, vx, vy, vz);
+        return RGBStackMerge.mergeStacks(red, green, blue, false);
+	}
+
+}
diff --git a/src/ij/plugin/FolderOpener.java b/src/ij/plugin/FolderOpener.java
new file mode 100644
index 0000000..a326e1d
--- /dev/null
+++ b/src/ij/plugin/FolderOpener.java
@@ -0,0 +1,787 @@
+package ij.plugin;
+import java.awt.*;
+import java.io.*;
+import java.awt.event.*;
+import java.awt.image.ColorModel;
+import java.util.*;
+import ij.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import ij.util.*;
+import ij.plugin.frame.Recorder;
+
+/** Implements the File/Import/Image Sequence command, which
+	opens a folder of images as a stack. */
+public class FolderOpener implements PlugIn, TextListener {
+	private static final int MAX_SEPARATE = 100;
+	private static final String DIR_KEY = "import.sequence.dir";
+	private static final String[] types = {"default", "16-bit", "32-bit", "RGB"};
+	private static String[] excludedTypes = {".txt",".lut",".roi",".pty",".hdr",".java",".ijm",".py",".js",".bsh",".xml",".rar",".h5",".doc",".xls"};
+	private static boolean staticSortFileNames = true;
+	private static boolean staticOpenAsVirtualStack;
+	private boolean convertToGrayscale;  //unused
+	private boolean sortFileNames = true;
+	private boolean sortByMetaData = true;
+	private boolean openAsVirtualStack;
+	private String directory;
+	private boolean directorySet;
+	private String filter;
+	private String legacyRegex;
+	private FileInfo fi;
+	private String info1;
+	private ImagePlus image;
+	private boolean saveImage;
+	private long t0;
+	private int stackWidth, stackHeight;
+	private int bitDepth;
+	private int defaultBitDepth;
+	private int nFiles = 0;
+	private int start = 1;
+	private int step = 1;
+	private double scale = 100.0;
+	private boolean openAsSeparateImages;
+	private TextField dirField, filterField, startField, countField, stepField;
+
+	
+	/** Opens the images in the specified directory as a stack. Displays
+		directory chooser and options dialogs if the argument is null. */
+	public static ImagePlus open(String path) {
+		return open(path, null);
+	}
+
+	/** Opens the images in the specified directory as a stack. Opens
+		the images as a virtual stack if the 'options' string contains
+		'virtual' or 'use'. Add ' file=abc' to the options string to only open
+		images with, for example, 'abc' in their name. Add ' noMetaSort' to
+		disable sorting of DICOM stacks by series number (0020,0011).
+		Displays directory chooser and options dialogs if the the 'path'
+		argument is null. */
+	public static ImagePlus open(String path, String options) {
+		FolderOpener fo = new FolderOpener();
+		fo.saveImage = true;
+		fo.setOptions(options);
+		fo.run(path);
+		return fo.image;
+	}
+
+	/** Opens the images in the specified directory as a widthxheight stack.
+ 		Opens the images as a virtual stack if the 'options' string contains
+		'virtual' or 'use'. Add ' file=abc' to the options string to only open
+		images with, for example, 'abc' in their name. Add ' noMetaSort' to
+		disable sorting of DICOM stacks by series number (0020,0011).
+	*/
+	public static ImagePlus open(String path, int width, int height, String options) {
+		FolderOpener fo = new FolderOpener();
+		fo.saveImage = true;
+		fo.stackWidth = width;
+		fo.stackHeight = height;
+		fo.setOptions(options);
+		fo.run(path);
+		return fo.image;
+	}
+	
+	private void setOptions(String options) {
+		if (options==null)
+			return;
+		openAsVirtualStack = options.contains("virtual") || options.contains("use");
+		if (options.contains("noMetaSort")) 
+			sortByMetaData = false;
+		bitDepth = (int)Tools.getNumberFromList(options,"bitdepth=",0);
+		filter = Macro.getValue(options, "filter", "");
+		this.start = (int)Tools.getNumberFromList(options,"start=",1);
+		this.step = (int)Tools.getNumberFromList(options,"step=",1);
+		this.scale = Tools.getNumberFromList(options,"scale=",100);
+	}
+
+	/** Opens the images in the specified directory as a stack. Displays
+		directory chooser and options dialogs if the argument is null. */
+	public ImagePlus openFolder(String path) {
+		saveImage = true;
+		run(path);
+		return image;
+	}
+
+	public void run(String arg) {
+		boolean isMacro = Macro.getOptions()!=null;
+		if (!directorySet)
+			directory = null;
+		if (arg!=null && !arg.equals(""))
+			directory = arg;
+		else {
+			if (!isMacro) {
+				sortFileNames = staticSortFileNames;
+				openAsVirtualStack = staticOpenAsVirtualStack;
+			}
+			arg = null;
+			String title = "Open Image Sequence...";
+			String macroOptions = Macro.getOptions();
+			if (macroOptions!=null) {
+				directory = Macro.getValue(macroOptions, title, null);
+				if (directory!=null) {
+					directory = OpenDialog.lookupPathVariable(directory);
+					File f = new File(directory);
+					if (!f.isDirectory() && (f.exists()||directory.lastIndexOf(".")>directory.length()-5))
+						directory = f.getParent();
+				}
+				legacyRegex = Macro.getValue(macroOptions, "or", "");
+				if (legacyRegex.equals(""))
+					legacyRegex = null;
+			}
+		}
+		if (arg==null) {
+			if (!showDialog()) return;
+		}
+		if (directory==null || directory.length()==0) {
+			error("No directory specified.     ");
+			return;
+		}
+		File file = new File(directory);
+		if (!file.exists()) {
+			error("Directory not found: "+directory);
+			return;
+		}
+		String[] list = file.list();
+		if (list==null) {
+			String parent = file.getParent();
+			file = new File(parent);
+			list = file.list();
+			if (list!=null)
+				directory = parent;
+			else {
+				error("Directory not found: "+directory);
+				return;
+			}
+		}
+		//remove subdirectories from list
+		ArrayList fileList = new ArrayList();
+		for (int i=0; i<list.length; i++) {
+			File f = (new File(directory+list[i]));
+			if (!f.isDirectory())
+				fileList.add(list[i]);
+		}
+		if (fileList.size()<list.length)
+			list = (String[])fileList.toArray(new String[fileList.size()]);
+
+		String title = directory;
+		if (title.endsWith(File.separator) || title.endsWith("/"))
+			title = title.substring(0, title.length()-1);
+		int index = title.lastIndexOf(File.separatorChar);
+		if (index!=-1)
+			title = title.substring(index + 1);
+		else {
+			index = title.lastIndexOf("/");
+			if (index!=-1)
+				title = title.substring(index + 1);
+		}
+		if (title.endsWith(":"))
+			title = title.substring(0, title.length()-1);
+		
+		list = trimFileList(list);
+		if (list==null)
+			return;
+		String pluginName = "Sequence Reader";
+		if (legacyRegex!=null)
+			pluginName += "(legacy)";
+		list = getFilteredList(list, filter, pluginName);
+		if (list==null)
+			return;
+		if (sortFileNames || IJ.isMacOSX())
+			list = StringSorter.sortNumerically(list);
+		if (IJ.debugMode) IJ.log("FolderOpener: "+directory+" ("+list.length+" files)");
+		int width=0, height=0, stackSize=1;
+		ImageStack stack = null;
+		double min = Double.MAX_VALUE;
+		double max = -Double.MAX_VALUE;
+		Calibration cal = null;
+		boolean allSameCalibration = true;
+		IJ.resetEscape();		
+		Overlay overlay = null;
+		if (this.nFiles==0)
+			this.nFiles = list.length;
+		boolean dicomImages = false;
+		try {
+			for (int i=0; i<list.length; i++) {
+				Opener opener = new Opener();
+				opener.setSilentMode(true);
+				IJ.redirectErrorMessages(true);
+				ImagePlus imp = opener.openTempImage(directory, list[i]);
+				IJ.redirectErrorMessages(false);
+				if (imp!=null) {
+					width = imp.getWidth();
+					height = imp.getHeight();
+					if (this.bitDepth==0) {
+						this.bitDepth = imp.getBitDepth();
+						this.defaultBitDepth = bitDepth;
+					}
+					String info = (String)imp.getProperty("Info");
+					if (info!=null && info.contains("7FE0,0010"))
+						dicomImages = true;
+					break;
+				}
+			}
+			if (width==0) {
+				error("This folder does not appear to contain\n"
+				+ "any TIFF, JPEG, BMP, DICOM, GIF, FITS or PGM files.\n \n"
+				+ "   \""+directory+"\"");
+				return;
+			}
+			IJ.showStatus("");
+			t0 = System.currentTimeMillis();
+			if (dicomImages && !IJ.isMacOSX() && !sortFileNames)
+				list = StringSorter.sortNumerically(list);
+
+			if (this.nFiles<1)
+				this.nFiles = list.length;
+			if (this.start<1 || this.start>list.length)
+				this.start = 1;
+			if (this.start+this.nFiles-1>list.length)
+				this.nFiles = list.length-this.start+1;
+			int count = 0;
+			int counter = 0;
+			ImagePlus imp = null;
+			boolean firstMessage = true;
+			boolean fileInfoStack = false;
+			
+			// open images as stack
+			for (int i=this.start-1; i<list.length; i++) {
+				if ((counter++%this.step)!=0)
+					continue;
+				Opener opener = new Opener();
+				opener.setSilentMode(true);
+				IJ.redirectErrorMessages(true);
+				if ("RoiSet.zip".equals(list[i])) {
+					IJ.open(directory+list[i]);
+					imp = null;
+				} else if (!openAsVirtualStack||stack==null) {
+					imp = opener.openTempImage(directory, list[i]);
+					stackSize = imp!=null?imp.getStackSize():1;
+				}
+				IJ.redirectErrorMessages(false);
+				if (imp!=null && stack==null) {
+					width = imp.getWidth();
+					height = imp.getHeight();
+					if (stackWidth>0 && stackHeight>0) {
+						width = stackWidth;
+						height = stackHeight;
+					}
+					if (bitDepth==0)
+						bitDepth = imp.getBitDepth();
+					fi = imp.getOriginalFileInfo();
+					ImageProcessor ip = imp.getProcessor();
+					min = ip.getMin();
+					max = ip.getMax();
+					cal = imp.getCalibration();
+					ColorModel cm = imp.getProcessor().getColorModel();
+					if (openAsVirtualStack) {
+						if (stackSize>1) {
+							stack = new FileInfoVirtualStack();
+							fileInfoStack = true;
+						} else {
+							if (stackWidth>0 && stackHeight>0)
+								stack = new VirtualStack(stackWidth, stackHeight, cm, directory);
+							else
+								stack = new VirtualStack(width, height, cm, directory);
+						}
+					}  else if (this.scale<100.0)						
+						stack = new ImageStack((int)(width*this.scale/100.0), (int)(height*this.scale/100.0), cm);
+					else
+						stack = new ImageStack(width, height, cm);
+					if (bitDepth!=0)
+						stack.setBitDepth(bitDepth);
+					info1 = (String)imp.getProperty("Info");
+				}
+				if (imp==null)
+					continue;
+				if (imp.getWidth()!=width || imp.getHeight()!=height) {
+					if (stackWidth>0 && stackHeight>0) {
+						ImagePlus imp2 = imp.createImagePlus();
+						ImageProcessor ip = imp.getProcessor();
+						ImageProcessor ip2 = ip.createProcessor(width,height);
+						ip2.insert(ip, 0, 0);
+						imp2.setProcessor(ip2);
+						imp = imp2;
+					} else {
+						IJ.log(list[i] + ": wrong size; "+width+"x"+height+" expected, "+imp.getWidth()+"x"+imp.getHeight()+" found");
+						continue;
+					}
+				}
+				String label = imp.getTitle();
+				if (stackSize==1) {
+					String info = (String)imp.getProperty("Info");
+					if (info!=null) {
+						if (useInfo(info))
+							label += "\n" + info;
+					} else if (imp.getStackSize()>0) {
+						String sliceLabel = imp.getStack().getSliceLabel(1);
+						if (useInfo(sliceLabel))
+							label =  sliceLabel;
+					}
+				}
+				if (Math.abs(imp.getCalibration().pixelWidth-cal.pixelWidth)>0.0000000001)
+					allSameCalibration = false;
+				ImageStack inputStack = imp.getStack();
+				Overlay overlay2 = imp.getOverlay();
+				if (overlay2!=null && !openAsVirtualStack) {
+					if (overlay==null)
+						overlay = new Overlay();
+					for (int j=0; j<overlay2.size(); j++) {
+						Roi roi = overlay2.get(j);
+						int position = roi.getPosition();
+						if (position==0)
+							roi.setPosition(count+1);
+						overlay.add(roi);
+					}
+				}				
+				if (openAsVirtualStack) { 
+					if (fileInfoStack)
+						openAsFileInfoStack((FileInfoVirtualStack)stack, directory+list[i]);
+					else
+						((VirtualStack)stack).addSlice(list[i]);
+				} else {
+					for (int slice=1; slice<=stackSize; slice++) {
+						int bitDepth2 = imp.getBitDepth();
+						String label2 = label;
+						ImageProcessor ip = null;
+						if (stackSize>1) {
+							String sliceLabel = inputStack.getSliceLabel(slice);
+							if (sliceLabel!=null && sliceLabel.length()<=15)
+								label2 += ":"+sliceLabel;
+							else if (label2!=null && !label2.equals(""))
+								label2 += ":"+slice;
+						}
+						ip = inputStack.getProcessor(slice);
+						if (bitDepth2!=bitDepth) {
+							if (dicomImages && bitDepth==16 && bitDepth2==32 && this.scale==100) {
+								ip = ip.convertToFloat();
+								bitDepth = 32;
+								ImageStack stack2 = new ImageStack(width, height, stack.getColorModel());
+								for (int n=1; n<=stack.size(); n++) {
+									ImageProcessor ip2 = stack.getProcessor(n);
+									ip2 = ip2.convertToFloat();
+									ip2.subtract(32768);
+									String sliceLabel = stack.getSliceLabel(n);
+									stack2.addSlice(sliceLabel, ip2.convertToFloat());
+								}
+								stack = stack2;
+							}
+						}
+						if (this.scale<100.0)
+							ip = ip.resize((int)(width*this.scale/100.0), (int)(height*this.scale/100.0));
+						if (ip.getMin()<min) min = ip.getMin();
+						if (ip.getMax()>max) max = ip.getMax();
+						stack.addSlice(label2, ip);
+					}
+				}
+				count++;
+				IJ.showStatus("!"+count+"/"+this.nFiles);
+				IJ.showProgress(count, this.nFiles);
+				if (count>=this.nFiles) 
+					break;
+				if (IJ.escapePressed())
+					{IJ.beep(); break;}
+			}  // open images as stack
+			
+		} catch(OutOfMemoryError e) {
+			IJ.outOfMemory("FolderOpener");
+			if (stack!=null) stack.trim();
+		}
+		if (stack!=null && stack.size()>0) {
+			ImagePlus imp2 = new ImagePlus(title, stack);
+			if (imp2.getType()==ImagePlus.GRAY16 || imp2.getType()==ImagePlus.GRAY32)
+				imp2.getProcessor().setMinAndMax(min, max);
+			if (fi==null)
+				fi = new FileInfo();
+			fi.fileFormat = FileInfo.UNKNOWN;
+			fi.fileName = "";
+			fi.directory = directory;
+			imp2.setFileInfo(fi); // saves FileInfo of the first image
+			imp2.setOverlay(overlay);
+			if (stack instanceof VirtualStack) {
+				Properties props = ((VirtualStack)stack).getProperties();
+				if (props!=null)
+					imp2.setProperty("FHT", props.get("FHT"));
+			}
+			if (allSameCalibration) {
+				// use calibration from first image
+				if (this.scale!=100.0 && cal.scaled()) {
+					cal.pixelWidth /= this.scale/100.0;
+					cal.pixelHeight /= this.scale/100.0;
+				}
+				if (cal.pixelWidth!=1.0 && cal.pixelDepth==1.0)
+					cal.pixelDepth = cal.pixelWidth;
+				imp2.setCalibration(cal);
+			}
+			if (info1!=null && info1.lastIndexOf("7FE0,0010")>0) { //DICOM
+				if (sortByMetaData)
+					stack = DicomTools.sort(stack);
+				imp2.setStack(stack);
+				double voxelDepth = DicomTools.getVoxelDepth(stack);
+				if (voxelDepth>0.0) {
+					if (IJ.debugMode) IJ.log("DICOM voxel depth set to "+voxelDepth+" ("+cal.pixelDepth+")");
+					cal.pixelDepth = voxelDepth;
+					imp2.setCalibration(cal);
+				}
+				if (imp2.getType()==ImagePlus.GRAY16 || imp2.getType()==ImagePlus.GRAY32) {
+					imp2.getProcessor().setMinAndMax(min, max);
+					imp2.updateAndDraw();
+				}
+			}
+			if (imp2.getStackSize()==1) {
+				int idx = this.start-1;
+				if (idx<0 || idx>=list.length)
+					idx = 0;
+				imp2.setProp("Slice_Label", list[idx]);
+				if (info1!=null)
+					imp2.setProperty("Info", info1);
+			}
+			if (arg==null && !saveImage) {
+				String time = (System.currentTimeMillis()-t0)/1000.0 + " seconds";
+				if (openAsSeparateImages) {
+					if (imp2.getStackSize()>MAX_SEPARATE && !IJ.isMacro()) {
+						boolean ok = IJ.showMessageWithCancel("Import>Image Sequence",
+						"Are you sure you want to open "+imp2.getStackSize()
+						+" separate windows?\nThis may cause the system to become very slow or stall.");
+						if (!ok) return;
+					}
+					openAsSeparateImages(imp2);
+				} else
+					imp2.show(time);
+				if (stack.isVirtual()) {
+					overlay = stack.getProcessor(1).getOverlay();
+					if (overlay!=null)
+						imp2.setOverlay(overlay);
+				}
+			}
+			if (saveImage)
+				image = imp2;
+		}
+		IJ.showProgress(1.0);
+		if (Recorder.record) {
+			String options = openAsVirtualStack?"virtual":"";
+			if (bitDepth!=defaultBitDepth)
+				options = options + " bitdepth=" + bitDepth;				
+			if (filter!=null && filter.length()>0) {
+				if (filter.contains(" "))
+					filter = "["+filter+"]";
+				options = options + " filter=" + filter;
+			}
+			if (start!=1)
+				options = options + " start=" + start;				
+			if (step!=1)
+				options = options + " step=" + step;				
+			if (scale!=100)
+				options = options + " scale=" + scale;				
+			if (!sortByMetaData)
+				options = options + " noMetaSort";
+			String dir = Recorder.fixPath(directory);
+   			Recorder.recordCall("imp = FolderOpener.open(\""+dir+"\", \""+options+"\");");
+		}
+	}
+	
+	private void error(String msg) {
+		IJ.error("Import>Image Sequence", msg);
+	}
+	
+	private void openAsSeparateImages(ImagePlus imp) {
+		VirtualStack stack = (VirtualStack)imp.getStack();
+		String dir = stack.getDirectory();
+		int skip = 0;
+		for (int n=1; n<=stack.size(); n++) {
+			ImagePlus imp2 = IJ.openImage(dir+stack.getFileName(n));
+			if (skip<=0) {
+				imp2.show();
+				skip = imp2.getStackSize()-1;
+			} else
+				skip--;
+		}	
+	}
+
+	public static boolean useInfo(String info) {
+		return info!=null && !(info.startsWith("Software")||info.startsWith("ImageDescription"));
+	 }
+	
+	private void openAsFileInfoStack(FileInfoVirtualStack stack, String path) {
+		FileInfo[] info = Opener.getTiffFileInfo(path);
+		if (info==null || info.length==0)
+			return;
+		int n =info[0].nImages;
+		if (info.length==1 && n>1) {
+			long size = fi.width*fi.height*fi.getBytesPerPixel();
+			for (int i=0; i<n; i++) {
+				FileInfo fi = (FileInfo)info[0].clone();
+				fi.nImages = 1;
+				fi.longOffset = fi.getOffset() + i*(size + fi.getGap());
+				stack.addImage(fi);
+			}
+		} else {
+			FileInfo fi = info[0];
+			if (fi.fileType==FileInfo.RGB48) {
+				for (int slice=1; slice<=3; slice++) {
+					FileInfo fi2 = (FileInfo)fi.clone();
+					fi2.sliceNumber = slice;
+					stack.addImage(fi2);
+				}
+			} else
+				stack.addImage(fi);
+		}
+	}
+	
+	boolean showDialog() {
+		String options = Macro.getOptions();
+		if  (options!=null) {  //macro
+			String optionsOrig = options;
+			options = options.replace("open=", "dir=");
+			options = options.replace("file=", "filter=");
+			options =  options.replace("starting=","start=");
+			options =  options.replace("number=","count=");
+			options =  options.replace("increment=","step=");
+			options =  options.replace("inc=","step=");
+			if (!options.equals(optionsOrig))
+				Macro.setOptions(options);
+			if (options.contains("convert_to_rgb"))
+				this.bitDepth = 24;
+		}
+		String countStr = "---";
+		if (!directorySet)
+			directory = Prefs.get(DIR_KEY, IJ.getDir("downloads")+"stack/");
+		if (directory!=null && !IJ.isMacro()) {			
+			File f = new File(directory);
+			String[] names = f.list();
+			names = trimFileList(names);
+			countStr = names!=null?""+names.length:"---";
+		}
+		GenericDialog gd = new GenericDialog("Import Image Sequence");
+		gd.setInsets(5, 0, 0);
+		gd.addDirectoryField("Dir:", directory);		
+		gd.setInsets(2, 55, 10);
+		gd.addMessage("drag and drop target", IJ.font10, Color.darkGray);
+		gd.addChoice("Type:", types, bitDepthToType(bitDepth));
+		gd.addStringField("Filter:", "", 10);
+		gd.setInsets(0,55,0);
+		gd.addMessage("enclose regex in parens", IJ.font10, Color.darkGray);
+		gd.addNumericField("Start:", this.start, 0, 6, "");
+		gd.addStringField("Count:", countStr, 6);
+		gd.addNumericField("Step:", this.step, 0, 6, "");
+		if (!IJ.isMacro() && !GraphicsEnvironment.isHeadless()) {
+			Vector v = gd.getStringFields();
+			dirField = (TextField)v.elementAt(0);
+			dirField.addTextListener(this);
+			filterField = (TextField)v.elementAt(1);
+			filterField.addTextListener(this);
+			countField = (TextField)v.elementAt(2);
+			v = gd.getNumericFields();
+			startField = (TextField)v.elementAt(0);
+			startField.addTextListener(this);
+			stepField = (TextField)v.elementAt(1);
+			stepField.addTextListener(this);
+		}
+		gd.addNumericField("Scale:", this.scale, 0, 6, "%");
+		gd.addCheckbox("Sort names numerically", sortFileNames);
+		gd.addCheckbox("Use virtual stack", openAsVirtualStack);
+		gd.addCheckbox("Open as separate images", false);		
+		gd.addHelp(IJ.URL+"/docs/menus/file.html#seq1");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		directory = gd.getNextString();
+		Prefs.set(DIR_KEY, directory);
+		gd.setSmartRecording(true);
+		int index = gd.getNextChoiceIndex();
+		bitDepth = typeToBitDepth(types[index]);
+		filter = gd.getNextString();
+		if (legacyRegex!=null)
+			filter = "("+legacyRegex+")";			
+		gd.setSmartRecording(true);
+		this.start = (int)gd.getNextNumber();
+		countStr = gd.getNextString();
+		double count = Tools.parseDouble(countStr);
+		if (!Double.isNaN(count))
+			nFiles = (int)count;
+		this.step = (int)gd.getNextNumber();
+		if (this.step<1)
+			this.step = 1;
+		this.scale = gd.getNextNumber();
+		if (this.scale<5.0) this.scale = 5.0;
+		if (this.scale>100.0) this.scale = 100.0;
+		sortFileNames = gd.getNextBoolean();
+		if (!sortFileNames)
+			sortByMetaData = false;
+		openAsVirtualStack = gd.getNextBoolean();
+		if (openAsVirtualStack)
+			scale = 100.0;
+		openAsSeparateImages = gd.getNextBoolean();
+		if (openAsSeparateImages)
+			openAsVirtualStack = true;
+		if (!IJ.macroRunning()) {
+			staticSortFileNames = sortFileNames;
+			if (!openAsSeparateImages)
+				staticOpenAsVirtualStack = openAsVirtualStack;
+		}
+		return true;
+	}
+	
+	public static String[] getFilteredList(String[] list, String filter, String title) {
+		boolean isRegex = false;
+		if (filter!=null && (filter.equals("") || filter.equals("*")))
+			filter = null;
+		if (list==null || filter==null)
+			return list;
+		if (title==null) {
+			String[] list2 = new String[list.length];
+			for (int i=0; i<list.length; i++)
+				list2[i] = list[i];
+			list = list2;
+		}
+		if (filter.length()>=2 && filter.startsWith("(")&&filter.endsWith(")")) {
+			filter = filter.substring(1,filter.length()-1);
+			isRegex = true;
+		}
+		int filteredImages = 0;
+		for (int i=0; i<list.length; i++) {
+			if (isRegex && containsRegex(list[i],filter,title!=null&&title.contains("(legacy)")))
+				filteredImages++;
+			else if (list[i].contains(filter))
+				filteredImages++;
+			else
+				list[i] = null;
+		}
+		if (filteredImages==0) {
+			if (title!=null) {
+				if (isRegex)
+					IJ.error(title, "None of the file names contain the regular expression '"+filter+"'.");
+				else
+					IJ.error(title, "None of the "+list.length+" files contain '"+filter+"' in the name.");
+			}
+			return null;
+		}
+		String[] list2 = new String[filteredImages];
+		int j = 0;
+		for (int i=0; i<list.length; i++) {
+			if (list[i]!=null)
+				list2[j++] = list[i];
+		}
+		list = list2;
+		return list;
+	}
+	
+	public static boolean containsRegex(String name, String regex, boolean legacy) {
+		boolean contains = false;
+		try {
+			if (legacy)
+				contains = name.matches(regex);
+			else
+				contains = name.replaceAll(regex,"").length()!=name.length();
+			IJ.showStatus("");
+		} catch(Exception e) {
+			String msg = e.getMessage();
+			int index = msg.indexOf("\n");
+			if (index>0)
+				msg = msg.substring(0,index);
+			IJ.showStatus("Regex error: "+msg);
+			contains = true;
+		}
+		return contains;
+	}
+	
+	private int typeToBitDepth(String type) {
+		int depth = 0;
+		if (type.equals("16-bit")) depth=16;
+		else if (type.equals("32-bit")) depth=32;
+		else if (type.equals("RGB")) depth=24;
+		return depth;
+	}
+
+	private String bitDepthToType(int bitDepth) {
+		switch (bitDepth) {
+			case 0: return types[0];
+			case 16: return types[1];
+			case 32: return types[2];
+			case 24: return types[3];
+		}
+		return types[0];
+	}
+
+	/** Removes names that start with "." or end with ".db", ".txt", ".lut", "roi", ".pty", ".hdr", ".py", etc. */
+	public String[] trimFileList(String[] rawlist) {
+		if (rawlist==null)
+			return null;
+		int count = 0;
+		for (int i=0; i< rawlist.length; i++) {
+			String name = rawlist[i];
+			if (name.startsWith(".")||name.equals("Thumbs.db")||excludedFileType(name))
+				rawlist[i] = null;
+			else
+				count++;
+		}
+		if (count==0) return null;
+		String[] list = rawlist;
+		if (count<rawlist.length) {
+			list = new String[count];
+			int index = 0;
+			for (int i=0; i< rawlist.length; i++) {
+				if (rawlist[i]!=null)
+					list[index++] = rawlist[i];
+			}
+		}
+		return list;
+	}
+	
+	/* Returns true if 'name' ends with ".txt", ".lut", ".roi", ".pty", ".hdr", ".java", ".ijm", ".py", ".js" or ".bsh. */
+	public static boolean excludedFileType(String name) {
+		if (name==null) return true;
+		for (int i=0; i<excludedTypes.length; i++) {
+			if (name.endsWith(excludedTypes[i]))
+				return true;
+		}
+		return false;
+	}
+			
+	public void openAsVirtualStack(boolean b) {
+		openAsVirtualStack = b;
+	}
+	
+	public void sortFileNames(boolean b) {
+		sortFileNames = b;
+	}
+	
+	public void sortByMetaData(boolean b) {
+		sortByMetaData = b;
+	}
+
+	public void setDirectory(String path) {
+		directory = path;
+		directorySet = true;
+	}
+
+	/** Sorts file names containing numerical components.
+	* @see ij.util.StringSorter#sortNumerically
+	* Author: Norbert Vischer
+	*/
+	public String[] sortFileList(String[] list) {
+		return StringSorter.sortNumerically(list);
+	}
+	
+	public void textValueChanged(TextEvent e) {
+		if (dirField==null)
+			return;
+		String dir = dirField.getText();
+		File f = new File(dir);
+		String[] names = f.list();
+		names = trimFileList(names);
+		names = getFilteredList(names, filterField.getText(), null);
+		int count = names!=null?names.length:0;
+		double start = Tools.parseDouble(startField.getText(), Double.NaN);
+		if (!Double.isNaN(start) && start>1)
+			count = count - ((int)start-1);
+		double step = Tools.parseDouble(stepField.getText(), Double.NaN);
+		if (!Double.isNaN(step) && step>1)
+			count = count/(int)step;
+		String countStr = count>0?""+count:"---";
+		countField.setText(countStr);
+	}
+
+} // FolderOpener
+
+
diff --git a/src/ij/plugin/GIF_Reader.java b/src/ij/plugin/GIF_Reader.java
new file mode 100644
index 0000000..14ff7db
--- /dev/null
+++ b/src/ij/plugin/GIF_Reader.java
@@ -0,0 +1,741 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.io.*;
+import java.net.*;
+import java.io.*;
+import java.util.*;
+import java.awt.*;
+import java.awt.image.*;
+
+/** This plugin opens GIFs and Animated GIFs. */
+public class GIF_Reader extends ImagePlus implements PlugIn {
+
+	public void run(String arg) {
+		OpenDialog od = new OpenDialog("Open GIF...", arg);
+		String name = od.getFileName();
+		if (name==null)
+			return;
+		String dir = od.getDirectory();
+		GifDecoder d = new GifDecoder();
+		int status = d.read(dir+name);
+		int n = d.getFrameCount();
+		ImageStack stack = null;
+		if (n==1) {
+			Image img = Toolkit.getDefaultToolkit().createImage(dir+name);
+			setImage(img);
+			setTitle(name);
+		} else {
+			for (int i=0; i < n; i++) {
+				ImageProcessor frame = d.getFrame(i);
+				if (i==0)
+					stack = new ImageStack(frame.getWidth(), frame.getHeight());
+				int t = d.getDelay(i);	// display duration of frame in milliseconds
+				stack.addSlice(null, frame);
+			}
+			if (stack==null)
+				return;
+			setStack(name, stack);
+			if (getType()==COLOR_RGB)
+				Opener.convertGrayJpegTo8Bits(this);
+		}
+		FileInfo fi = new FileInfo();
+		fi.fileFormat = fi.GIF_OR_JPG;
+		fi.fileName = name;
+		fi.directory = dir;
+		setFileInfo(fi);
+	}
+
+}
+
+/**
+ * Class GifDecoder - Decodes a GIF file into one or more frames.
+ * No copyright asserted on this code assembly.
+ *
+ * @author Kevin Weiner, FM Software; LZW decoder adapted from John Cristy's ImageMagick.
+ * @version 1.0 January 2001
+ *
+ *	June 2001: Updated to work with ImageJ and JDK 1.1
+ */
+class GifDecoder {
+
+	/**
+	 * File read status: No errors.
+	 */
+	public static final int STATUS_OK = 0;
+
+	/**
+	 * File read status: Error decoding file (may be partially decoded)
+	 */
+	public static final int STATUS_FORMAT_ERROR = 1;
+
+	/**
+	 * File read status: Unable to open source.
+	 */
+	public static final int STATUS_OPEN_ERROR = 2;
+
+	private BufferedInputStream in;
+	private int status;
+
+	private int width;			// full image width
+	private int height;			// full image height
+	private boolean gctFlag;		// global color table used
+	private int gctSize;			// size of global color table
+	private int loopCount;		// iterations; 0 = repeat forever
+
+	private int[] gct;			// global color table
+	private int[] lct;			// local color table
+	private int[] act;			// active color table
+
+	private int bgIndex;			// background color index
+	private int bgColor;			// background color
+	private int lastBgColor;		// previous bg color
+	private int pixelAspect;		// pixel aspect ratio
+
+	private boolean lctFlag;		// local color table flag
+	private boolean interlace;	// interlace flag
+	private int lctSize;			// local color table size
+
+	private int ix, iy, iw, ih;	// current image rectangle
+	private Rectangle lastRect;	// last image rect
+	private ImageProcessor image;	 // current frame
+	private ImageProcessor lastImage;	 // previous frame
+
+	private byte[] block = new byte[256];	 // current data block
+	private int blockSize = 0;	// block size
+
+	// last graphic control extension info
+	private int dispose = 0;		// 0=no action; 1=leave in place; 2=restore to bg; 3=restore to prev
+	private int lastDispose = 0;
+	private boolean transparency = false;	  // use transparent color
+	private int delay = 0;		// delay in milliseconds
+	private int transIndex;		// transparent color index
+
+	private static final int MaxStackSize = 4096;	  // max decoder pixel stack size
+
+	// LZW decoder working arrays
+	private short[] prefix;
+	private byte[] suffix;
+	private byte[] pixelStack;
+	private byte[] pixels;
+
+	private Vector frames;	  // frames read from current file
+	private int frameCount;
+
+   /**
+	 * Gets display duration for specified frame.
+	 *
+	 * @param n int index of frame
+	 * @return delay in milliseconds
+	 */
+
+	public int getDelay(int n) {
+		delay = -1;
+		if ((n >= 0) && (n < frameCount))
+			delay = ((GifFrame) frames.elementAt(n)).delay;
+		return delay;
+	}
+
+
+	/**
+	 * Gets the image contents of frame n.
+	 *
+	 * @return ImageProcessor representation of frame, or null if n is invalid.
+	 */
+	public ImageProcessor getFrame(int n) {
+		ImageProcessor im = null;
+		if ((n >= 0) && (n < frameCount))
+			im = ((GifFrame) frames.elementAt(n)).image;
+		return im;
+	}
+
+
+	/**
+	 * Gets the number of frames read from file.
+	 * @return int frame count
+	 */
+	public int getFrameCount() {
+		return frameCount;
+	}
+
+
+	/**
+	 * Gets the first (or only) image read.
+	 *
+	 * @return ImageProcessor containing first frame, or null if none.
+	 */
+	public ImageProcessor getImage() {
+		return getFrame(0);
+	}
+
+
+	/**
+	 * Gets the "Netscape" iteration count, if any.
+	 * A count of 0 means repeat indefinitiely.
+	 *
+	 * @return int iteration count if one was specified, else 1.
+	 */
+	public int getLoopCount() {
+		 return loopCount;
+	}
+
+
+	/**
+	 * Reads GIF image from stream
+	 *
+	 * @param BufferedInputStream containing GIF file.
+	 * @return int read status code
+	 */
+	public int read(BufferedInputStream is) {
+		init();
+		if (is != null) {
+			in = is;
+			readHeader();
+			if (!err()) {
+				readContents();
+				if (frameCount < 0)
+					status = STATUS_FORMAT_ERROR;
+			}
+		} else {
+			status = STATUS_OPEN_ERROR;
+		}
+		try {
+			is.close();
+		} catch (IOException e) {}
+		return status;
+	}
+
+
+	/**
+	 * Reads GIF file from specified source (file or URL string)
+	 *
+	 * @param name File source string
+	 * @return int read status code
+	 */
+	public int read(String name) {
+		status = STATUS_OK;
+		try {
+			name = name.trim();
+			if (name.indexOf("://") > 0) {
+				URL url = new URL(name);
+				in = new BufferedInputStream(url.openStream());
+			} else {
+				in = new BufferedInputStream(new FileInputStream(name));
+			}
+			status = read(in);
+		} catch (IOException e) {
+			status = STATUS_OPEN_ERROR;
+		}
+
+		return status;
+	}
+
+
+	/**
+	 * Decodes LZW image data into pixel array.
+	 * Adapted from John Cristy's ImageMagick.
+	 */
+
+	 private void decodeImageData() {
+		int NullCode = -1;
+		int npix = iw * ih;
+		int available, clear, code_mask, code_size, end_of_information, in_code, 
+			old_code, bits, code, count, i, datum, data_size, first, top, bi, pi;
+
+		if ((pixels == null) || (pixels.length < npix))
+			pixels = new byte[npix];	// allocate new pixel array
+
+		if (prefix == null)
+			prefix = new short[MaxStackSize];
+		if (suffix == null)
+			suffix = new byte[MaxStackSize];
+		if (pixelStack == null)
+			pixelStack = new byte[MaxStackSize+1];
+
+
+		//	Initialize GIF data stream decoder.
+
+		data_size = read();
+		clear = 1 << data_size;
+		end_of_information = clear + 1;
+		available = clear + 2;
+		old_code = NullCode;
+		code_size = data_size + 1;
+		code_mask = (1 << code_size) - 1;
+		for (code = 0; code < clear; code++) {
+			prefix[code] = 0;
+			suffix[code] = (byte) code;
+		}
+
+		//	Decode GIF pixel stream.
+
+		datum = bits = count = first = top = pi = bi = 0;
+
+		for (i = 0; i < npix; ) {
+			if (top == 0) {
+				if (bits < code_size) {
+					//	Load bytes until there are enough bits for a code.
+					if (count == 0) {
+						// Read a new data block.
+						count = readBlock();
+						if (count <= 0)
+							break;
+						bi = 0;
+					}
+					datum += (((int) block[bi]) & 0xff) << bits;
+					bits += 8;
+					bi++;
+					count--;
+					continue;
+				}
+
+				//	Get the next code.
+
+				code = datum & code_mask;
+				datum >>= code_size;
+				bits -= code_size;
+
+				//	Interpret the code
+
+				if ((code > available) || (code == end_of_information))
+					break;
+				if (code == clear) {
+					//	Reset decoder.
+					code_size = data_size + 1;
+					code_mask = (1 << code_size) - 1;
+					available = clear + 2;
+					old_code = NullCode;
+					continue;
+				}
+				if (old_code == NullCode) {
+					pixelStack[top++] = suffix[code];
+					old_code = code;
+					first = code;
+					continue;
+				}
+				in_code = code;
+				if (code == available) {
+					pixelStack[top++] = (byte) first;
+					code = old_code;
+				}
+				while (code > clear) {
+					pixelStack[top++] = suffix[code];
+					code = prefix[code];
+				}
+				first = ((int) suffix[code]) & 0xff;
+
+				//	Add a new string to the string table,
+
+				if (available >= MaxStackSize)
+					break;
+				pixelStack[top++] = (byte) first;
+				prefix[available] = (short) old_code;
+				suffix[available] = (byte) first;
+				available++;
+				if (((available & code_mask) == 0) && (available < MaxStackSize)) {
+					code_size++;
+					code_mask += available;
+				}
+				old_code = in_code;
+			}
+
+			//	Pop a pixel off the pixel stack.
+
+			top--;
+			pixels[pi++] = pixelStack[top];
+			i++;
+		}
+
+		for (i = pi; i < npix; i++)
+			pixels[i] = 0;	// clear missing pixels
+
+	}
+
+
+	/**
+	 * Returns true if an error was encountered during reading/decoding
+	 */
+	private boolean err() {
+		return status != STATUS_OK;
+	}
+
+
+	/**
+	 * Initializes or re-initializes reader
+	 */
+	private void init() {
+		 status = STATUS_OK;
+		frameCount = 0;
+		frames = new Vector();
+		gct = null;
+		lct = null;
+	}
+
+
+	/**
+	 * Reads a single byte from the input stream.
+	 */
+	private int read() {
+		int curByte = 0;
+		try {
+			curByte = in.read();
+		} catch (IOException e) {
+			status = STATUS_FORMAT_ERROR;
+		}
+		return curByte;
+	}
+
+
+	/**
+	 * Reads next variable length block from input.
+	 *
+	 * @return int number of bytes stored in "buffer"
+	 */
+	private int readBlock() {
+		blockSize = read();
+		int n = 0;
+		int count;
+		if (blockSize > 0) {
+			try {
+				while (n<blockSize) {
+					count = in.read(block, n, blockSize-n);
+					if (count==-1)
+						break;
+					n += count;
+				}
+			} catch (IOException e) {}
+
+			if (n < blockSize)
+				status = STATUS_FORMAT_ERROR; 
+		}
+		return n;
+	}
+
+
+	/**
+	 * Reads color table as 256 RGB integer values
+	 *
+	 * @param ncolors int number of colors to read
+	 * @return int array containing 3*ncolors color components
+	 */
+	private int[] readColorTable(int ncolors) {
+		int nbytes = 3*ncolors;
+		int[] tab = null;
+		byte[] c = new byte[nbytes];
+		int n = 0;
+		try {
+			n = in.read(c);
+		} catch (IOException e) {}
+		if (n < nbytes)
+			status = STATUS_FORMAT_ERROR;
+		else {
+			tab = new int[256];	 // max size to avoid bounds checks
+			int i = 0;
+			int j = 0;
+			while (i < ncolors) {
+				int r = ((int) c[j++]) & 0xff;
+				int g = ((int) c[j++]) & 0xff;
+				int b = ((int) c[j++]) & 0xff;
+				tab[i++] = 0xff000000 | (r << 16) | (g << 8) | b;
+			}
+		}
+		return tab;
+	}
+
+
+	/**
+	 * Main file parser.  Reads GIF content blocks.
+	 */
+	private void readContents() {
+		// read GIF file content blocks
+		boolean done = false;
+		while (!(done || err())) {
+			int code = read();
+			switch (code) {
+
+				case 0x2C:	  // image separator
+					readImage();
+					break;
+
+				case 0x21:	  // extension
+					code = read();
+					switch (code) {
+
+						case 0xf9:	  // graphics control extension
+							readGraphicControlExt();
+							break;
+
+						case 0xff:	  // application extension
+							readBlock();
+							String app = "";
+							for (int i = 0; i < 11; i++)
+								app += (char) block[i];
+							if (app.equals("NETSCAPE2.0"))
+								readNetscapeExt();
+							else
+								skip();		   // don't care
+							break;
+
+						default:	// uninteresting extension
+							skip();
+					}
+					break;
+
+				case 0x3b:	  // terminator
+					done = true;
+					break;
+
+				default:
+					status = STATUS_FORMAT_ERROR;
+			  }
+		}
+	}
+
+
+	/**
+	 * Reads Graphics Control Extension values
+	 */
+	private void readGraphicControlExt() {
+		read();	   // block size
+		int packed = read();		 // packed fields
+		dispose = (packed & 0x1c) >> 1;
+		transparency = (packed & 1) != 0;
+		delay = readShort() * 10;	 // delay in milliseconds
+		transIndex = read();		 // transparent color index
+		read();						 // block terminator
+	}
+
+
+	/**
+	 * Reads GIF file header information.
+	 */
+	private void readHeader() {
+		String id = "";
+		for (int i = 0; i < 6; i++)
+			id += (char) read();
+		if (!id.startsWith("GIF")) {
+			status = STATUS_FORMAT_ERROR;
+			 return;
+		}
+
+		readLSD();
+		if (gctFlag && !err()) {
+			gct = readColorTable(gctSize);
+			bgColor = gct[bgIndex];
+		}
+	}
+
+
+	/**
+	 * Reads next frame image
+	 */
+
+	private void readImage() {
+		ix = readShort();	 // (sub)image position & size
+		iy = readShort();
+		iw = readShort();
+		ih = readShort();
+
+		int packed = read();
+		lctFlag = (packed & 0x80) != 0;		   // 1 - local color table flag
+		interlace = (packed & 0x40) != 0;	   // 2 - interlace flag
+		// 3 - sort flag
+		// 4-5 - reserved
+		lctSize = 2 << (packed & 7);		   // 6-8 - local color table size
+
+		if (lctFlag) {
+			lct = readColorTable(lctSize);	   // read table
+			act = lct;	  // make local table active
+		} else {
+			act = gct;	  // make global table active
+			if (bgIndex == transIndex)
+				bgColor = 0;
+		}
+		int save = 0;
+		if (transparency) {
+			save = act[transIndex];
+			act[transIndex] = 0;	// set transparent color if specified
+		}
+
+		if (act == null) {
+			status = STATUS_FORMAT_ERROR;	  // no color table defined
+		 }
+
+		if (err()) return;
+
+		decodeImageData();			  // decode pixel data
+		skip();
+
+		if (err()) return;
+
+		frameCount++;
+
+		// create new image to receive frame data
+		image = new ColorProcessor(width, height);
+
+		setPixels();	// transfer pixel data to image
+
+		frames.addElement(new GifFrame(image, delay));	 // add image to frame list
+
+		if (transparency)
+			act[transIndex] = save;
+		resetFrame();
+
+	}
+
+
+	/**
+	 * Reads Logical Screen Descriptor
+	 */
+	private void readLSD() {
+
+		// logical screen size
+		width = readShort();
+		height = readShort();
+
+		// packed fields
+		int packed = read();
+		gctFlag = (packed & 0x80) != 0;		   // 1	  : global color table flag
+		// 2-4 : color resolution
+		// 5   : gct sort flag
+		gctSize	   = 2 << (packed & 7);		   // 6-8 : gct size
+
+		bgIndex = read();		 // background color index
+		pixelAspect = read();	 // pixel aspect ratio
+	}
+
+
+	/**
+	 * Reads Netscape extenstion to obtain iteration count
+	 */
+	private void readNetscapeExt() {
+		do {
+			readBlock();
+			if (block[0] == 0x03) {
+				// loop count sub-block
+				int b1 = ((int) block[1]) & 0xff;
+				int b2 = ((int) block[2]) & 0xff;
+				loopCount = (b2 << 8) | b1;
+			}
+		} while ((blockSize > 0) && !err());
+	}
+
+
+	/**
+	 * Reads next 16-bit value, LSB first
+	 */
+	private int readShort() {
+		// read 16-bit value, LSB first
+		return read() | (read() << 8);
+	}
+
+
+	/**
+	 * Resets frame state for reading next image.
+	 */
+	private void resetFrame() {
+		lastDispose = dispose;
+		lastRect = new Rectangle(ix, iy, iw, ih);
+		lastImage = image;
+		lastBgColor = bgColor;
+		int dispose = 0;
+		boolean transparency = false;
+		int delay = 0;
+		lct = null;
+	}
+
+
+	/**
+	 * Creates new frame image from current data (and previous
+	 * frames as specified by their disposition codes).
+	 */
+	private void setPixels() {
+
+		// expose destination image's pixels as int array
+		int[] dest = (int[]) image.getPixels();
+
+		// fill in starting image contents based on last image's dispose code (if any)
+		if (lastDispose > 0) {
+			if (lastDispose == 3) {	 // use image before last
+				int n = frameCount - 2;
+				if (n > 0)
+					lastImage = getFrame(n-1);
+				else
+					lastImage = null;
+			}
+
+			if (lastImage != null) {
+				int[] prev = (int[]) lastImage.getPixels();
+				System.arraycopy(prev, 0, dest, 0, width*height);  // copy pixels
+
+				if ((lastDispose == 2) && (lastBgColor != 0)) {
+					// fill last image rect area with background color
+					 image.setColor(new Color(lastBgColor));
+					 image.setRoi(lastRect);
+					image.fill();
+				 }
+			}
+		}
+
+		// copy each source line to the appropriate place in the destination
+		int pass = 1;
+		int inc = 8;
+		int iline = 0;
+		for (int i = 0; i < ih; i++) {
+			int line = i;
+			if (interlace) {
+				if (iline >= ih) {
+					pass++;
+					switch (pass) {
+						case 2:
+							iline = 4;
+							break;
+						case 3:
+							iline = 2;
+							inc = 4;
+							break;
+						case 4:
+							iline = 1;
+							inc = 2;
+					}
+				}
+				line = iline;
+				iline += inc;
+			}
+			line += iy;
+			if (line < height) {
+				int k = line * width;
+				int dx = k + ix;		   // start of line in dest
+				int dlim = dx + iw;		   // end of dest line
+				if ((k + width) < dlim)
+					dlim = k + width;	   // past dest edge
+				int sx = i * iw;		   // start of line in source
+				while (dx < dlim) {
+					// map color and insert in destination
+					int index = ((int) pixels[sx++]) & 0xff;
+					dest[dx++] = act[index];
+				}
+			}
+		}
+	}
+
+	/**
+	 * Skips variable length blocks up to and including
+	 * next zero length block.
+	 */
+	private void skip() {
+		do {
+			readBlock();
+		} while ((blockSize > 0) && !err());
+	}
+}
+
+ class GifFrame {
+		public GifFrame(ImageProcessor im, int del) {
+			image = im;
+			delay = del;
+		}
+		public ImageProcessor image;
+		public int delay;
+	}
+
diff --git a/src/ij/plugin/GaussianBlur3D.java b/src/ij/plugin/GaussianBlur3D.java
new file mode 100644
index 0000000..bafe5fe
--- /dev/null
+++ b/src/ij/plugin/GaussianBlur3D.java
@@ -0,0 +1,119 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.plugin.filter.*;
+
+public class GaussianBlur3D implements PlugIn {
+	private static double xsigma=2, ysigma=2, zsigma=2;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		if (imp.isComposite() && imp.getNChannels()==imp.getStackSize()) {
+			IJ.error("3D Gaussian Blur", "Composite color images not supported");
+			return;
+		}
+		if (!showDialog())
+			return;
+		imp.startTiming();
+		blur(imp, xsigma, ysigma, zsigma);
+		IJ.showTime(imp, imp.getStartTime(), "", imp.getStackSize());
+	}
+	
+	private boolean showDialog() {
+		GenericDialog gd = new GenericDialog("3D Gaussian Blur");
+		gd.addNumericField("X sigma:", xsigma, 1);
+		gd.addNumericField("Y sigma:", ysigma, 1);
+		gd.addNumericField("Z sigma:", zsigma, 1);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		xsigma = gd.getNextNumber();
+		ysigma = gd.getNextNumber();
+		zsigma = gd.getNextNumber();
+		return true;
+	}
+	
+	public static void blur(ImagePlus imp, double sigmaX, double sigmaY, double sigmaZ) {
+		imp.deleteRoi();
+		ImageStack stack = imp.getStack();
+		if (sigmaX>0.0 || sigmaY>0.0) {
+			GaussianBlur gb = new GaussianBlur();
+			int channels = stack.getProcessor(1).getNChannels();
+			gb.setNPasses(channels*imp.getStackSize());
+			for (int i=1; i<=imp.getStackSize(); i++) {
+				ImageProcessor ip = stack.getProcessor(i);
+				double accuracy = (imp.getBitDepth()==8||imp.getBitDepth()==24)?0.002:0.0002;
+				gb.blurGaussian(ip, sigmaX, sigmaY, accuracy);
+			}
+		}
+		if (sigmaZ>0.0) {
+			if (imp.isHyperStack())
+				blurHyperStackZ(imp, sigmaZ);
+			else
+				blurZ(stack, sigmaZ);
+			imp.updateAndDraw();
+		}
+	}
+
+	private static void blurZ(ImageStack stack, double sigmaZ) {
+		GaussianBlur gb = new GaussianBlur();
+		double accuracy = (stack.getBitDepth()==8||stack.getBitDepth()==24)?0.002:0.0002;
+		int w=stack.getWidth(), h=stack.getHeight(), d=stack.size();
+		float[] zpixels = null;
+		FloatProcessor fp =null;
+		IJ.showStatus("Z blurring");
+		gb.showProgress(false);
+		int channels = stack.getProcessor(1).getNChannels();
+		for (int y=0; y<h; y++) {
+			IJ.showProgress(y, h-1);
+			for (int channel=0; channel<channels; channel++) {
+				zpixels = stack.getVoxels(0, y, 0, w, 1, d, zpixels, channel);
+				if (fp==null)
+					fp = new FloatProcessor(w, d, zpixels);
+				//if (y==h/2) new ImagePlus("before-"+h/2, fp.duplicate()).show();
+				gb.blur1Direction(fp, sigmaZ, accuracy, false, 0);
+				stack.setVoxels(0, y, 0, w, 1, d, zpixels, channel);
+			}
+		}
+		IJ.showStatus("");
+	}
+
+	private static void blurHyperStackZ(ImagePlus imp, double zsigma) {
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int timePoints = imp.getNFrames();
+		int nVolumes = channels*timePoints;
+		for (int c=1; c<=channels; c++) {
+			if (slices==1) {
+				ImageStack stack = getVolume(imp, c, 1);
+				blurZ(stack, zsigma);
+			} else {
+				for (int t=1; t<=timePoints; t++) {
+					ImageStack stack = getVolume(imp, c, t);
+					blurZ(stack, zsigma);
+					//new ImagePlus("stack-"+c+"-"+t, stack).show();
+				}
+			}
+		}
+	}
+
+	private static ImageStack getVolume(ImagePlus imp, int c, int t) {
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(imp.getWidth(), imp.getHeight());
+		if (imp.getNSlices()==1) {
+			for (t=1; t<=imp.getNFrames(); t++) {
+				int n = imp.getStackIndex(c, 1, t);
+				stack2.addSlice(stack1.getProcessor(n));
+			}
+		} else {
+			for (int z=1; z<=imp.getNSlices(); z++) {
+				int n = imp.getStackIndex(c, z, t);
+				stack2.addSlice(stack1.getProcessor(n));
+			}
+		}
+		return stack2;
+	}
+
+}
diff --git a/src/ij/plugin/GelAnalyzer.java b/src/ij/plugin/GelAnalyzer.java
new file mode 100644
index 0000000..910bace
--- /dev/null
+++ b/src/ij/plugin/GelAnalyzer.java
@@ -0,0 +1,649 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.filter.Analyzer;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import java.util.*;
+
+/** This plugin generates gel profile plots that can be analyzed using
+the wand tool. It is similar to the "Gel Plotting Macros" in NIH Image. */
+public class GelAnalyzer implements PlugIn {
+
+    static final String OPTIONS = "gel.options"; 
+    static final String VSCALE = "gel.vscale"; 
+    static final String HSCALE = "gel.hscale"; 
+    static final int OD=1, PERCENT=2, OUTLINE=4, INVERT=8;
+	static int saveID;
+	static int nLanes, saveNLanes;
+	static Rectangle firstRect;
+	static final int MAX_LANES = 100;
+	static int[] x = new int[MAX_LANES+1];
+	static PlotsCanvas plotsCanvas;
+	static ImageProcessor ipLanes;
+	static ImagePlus gel;
+	static int plotHeight;
+	static int options = (int)Prefs.get(OPTIONS, PERCENT+INVERT);
+	static boolean uncalibratedOD = (options&OD)!=0;
+	static boolean labelWithPercentages = (options&PERCENT)!=0;;
+	static boolean outlineLanes;
+	static boolean invertPeaks = (options&INVERT)!=0;
+	static double verticalScaleFactor = Prefs.get(VSCALE, 1.0);
+	static double horizontalScaleFactor = Prefs.get(HSCALE, 1.0);
+	static Overlay overlay;
+	boolean invertedLut;
+	
+	ImagePlus imp;
+	Font f;
+	double odMin=Double.MAX_VALUE, odMax=-Double.MAX_VALUE;
+	static boolean isVertical;
+	static boolean showLaneDialog = true;
+	
+	public void run(String arg) {
+		if (arg.equals("options")) {
+			showDialog();
+			return;
+		}
+		
+		imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			IJ.noImage();
+			return;
+		}
+
+		if (arg.equals("reset")) {
+			nLanes = 0;
+			saveNLanes = 0;
+			saveID = 0;
+			if (plotsCanvas!=null)
+				plotsCanvas.reset();
+			ipLanes = null;
+			overlay = null;
+			if (gel!=null) {
+				ImageCanvas ic = gel.getCanvas();
+				if (ic!=null) ic.setDisplayList(null);
+				gel.draw();
+			}
+			return;
+		}
+
+		if (arg.equals("percent") && plotsCanvas!=null) {
+			plotsCanvas.displayPercentages();
+			return;
+		}
+
+		if (arg.equals("label") && plotsCanvas!=null) {
+			if (plotsCanvas.counter==0)
+				show("There are no peak area measurements.");
+			else
+				plotsCanvas.labelPeaks();
+			return;
+		}
+
+		if (imp.getID()!=saveID) {
+			nLanes=0;
+			ipLanes = null;
+			saveID = 0;
+		}
+
+		if (arg.equals("replot")) {
+			if (saveNLanes==0) {
+				show("The data needed to re-plot the lanes is not available");
+				return;
+			}
+			nLanes = saveNLanes;
+			plotLanes(gel, true);
+			return;
+		}
+		
+		if (arg.equals("draw")) {
+			outlineLanes();
+			return;
+		}
+
+		Roi roi = imp.getRoi();
+		if (roi==null || roi.getType()!=Roi.RECTANGLE) {
+			show("Rectangular selection required.");
+			return;
+		}
+		Rectangle rect = roi.getBounds();
+		if (nLanes==0) {
+			invertedLut = imp.isInvertedLut();
+			IJ.register(GelAnalyzer.class);  // keeps this class from being GC'd
+		}
+
+		if (arg.equals("first")) {
+			selectFirstLane(rect);
+			return;
+		}
+
+		if (nLanes==0) {
+			show("You must first use the \"Select First Lane\" command.");
+			return;
+		}
+		if (arg.equals("next")) {
+			selectNextLane(rect);
+			return;
+		}
+		
+		if (arg.equals("plot")) {
+			if (( isVertical && (rect.x!=x[nLanes]) ) || ( !(isVertical) && (rect.y!=x[nLanes]) )) {
+				selectNextLane(rect);
+			}
+			plotLanes(gel, false);
+			return;
+		}
+
+	}
+
+	void showDialog() {
+		GenericDialog gd = new GenericDialog("Gel Analyzer");
+		gd.addNumericField("Vertical scale factor:", verticalScaleFactor, 1);
+		gd.addNumericField("Horizontal scale factor:", horizontalScaleFactor, 1);
+		gd.addCheckbox("Uncalibrated OD", uncalibratedOD);
+		gd.addCheckbox("Label with percentages", labelWithPercentages);
+		gd.addCheckbox("Invert peaks", invertPeaks);
+		gd.addHelp(IJ.URL+"/docs/menus/analyze.html#gels");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		verticalScaleFactor = gd.getNextNumber();
+		horizontalScaleFactor = gd.getNextNumber();
+		uncalibratedOD = gd.getNextBoolean();
+		labelWithPercentages = gd.getNextBoolean();
+		invertPeaks = gd.getNextBoolean();
+		options = 0;
+		if (uncalibratedOD) options |= OD;
+		if (labelWithPercentages) options |= PERCENT;
+		if (invertPeaks) options |= INVERT;
+		if (verticalScaleFactor==0.0) verticalScaleFactor=1.0;
+		if (horizontalScaleFactor==0.0) horizontalScaleFactor=1.0;
+		Prefs.set(OPTIONS, options);
+		Prefs.set(VSCALE, verticalScaleFactor);
+		Prefs.set(HSCALE, horizontalScaleFactor);
+	}
+
+
+	void selectFirstLane(Rectangle rect) {
+		if (rect.width/rect.height>=2 || IJ.altKeyDown()) {
+			if (showLaneDialog) {
+				String msg = "Are the lanes really horizontal?\n \n"+
+					"ImageJ assumes the lanes are\n"+
+					"horizontal if the selection is more\n"+
+					"than twice as wide as it is tall. Note\n"+
+					"that the selection can only be moved\n"+
+					"vertically when the lanes are horizontal.";
+				GenericDialog gd = new GenericDialog("Gel Analyzer");
+				gd.addMessage(msg);
+				gd.setOKLabel("Yes");
+				gd.showDialog();
+				if (gd.wasCanceled()) return;
+				showLaneDialog = false;
+			}
+			isVertical = false;
+		} else
+			isVertical = true;
+			
+		/*
+		if ( (isVertical && (rect.height/rect.width)<2 ) || (!isVertical && (rect.width/rect.height)<2 ) ) {
+			GenericDialog gd = new GenericDialog("Lane Orientation");
+			String[] orientations = {"Vertical","Horizontal"};
+			int defaultOrientation = isVertical?0:1;
+			gd.addChoice("Lane Orientation:", orientations, orientations[defaultOrientation]);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return;
+			String orientation = gd.getNextChoice();
+			if(orientation.equals(orientations[0]))
+				isVertical=true;
+			else
+				isVertical=false;
+		}
+		*/
+
+		IJ.showStatus("Lane 1 selected ("+(isVertical?"vertical":"horizontal")+" lanes)");
+		firstRect = rect;
+		nLanes = 1;
+		saveNLanes = 0;
+		if(isVertical)
+			x[1] = rect.x;
+		else
+			x[1] = rect.y;
+		gel = imp;
+		saveID = imp.getID();
+		overlay = null;
+		updateRoiList(rect);
+	}
+
+	void selectNextLane(Rectangle rect) {
+		if (rect.width!=firstRect.width || rect.height!=firstRect.height) {
+			show("Selections must all be the same size.");
+			return;
+		}
+		if (nLanes<MAX_LANES)
+			nLanes += 1;
+		IJ.showStatus("Lane " + nLanes + " selected");
+		if (isVertical)
+			x[nLanes] = rect.x;
+		else
+			x[nLanes] = rect.y;
+		if(x[nLanes]==x[nLanes-1]){
+			nLanes--; //avoid duplicate
+			return;
+		}
+		if (isVertical && rect.y!=firstRect.y) {
+			rect.y = firstRect.y;
+			gel.setRoi(rect);
+		} else if (!isVertical && rect.x!=firstRect.x) {
+			rect.x = firstRect.x;
+			gel.setRoi(rect);
+		}
+		updateRoiList(rect);
+	}
+	
+	void updateRoiList(Rectangle rect) {
+			if (gel==null)
+				return;
+			if (overlay==null) {
+				overlay = new Overlay();
+				overlay.drawLabels(true);
+				overlay.setLabelColor(Color.white);
+				overlay.drawBackgrounds(true);
+			}
+			overlay.add(new Roi(rect.x, rect.y, rect.width, rect.height, null));
+			gel.setOverlay(overlay);
+	}
+
+	void plotLanes(ImagePlus imp, boolean replot) {
+		int topMargin = 16;
+		int bottomMargin = 2;
+		double min = Double.MAX_VALUE;
+		double max = -Double.MAX_VALUE;
+		int plotWidth;
+		double[][] profiles;
+		profiles = new double[MAX_LANES+1][];
+		IJ.showStatus("Plotting " + nLanes + " lanes");
+		ImageProcessor ipRotated = imp.getProcessor();
+		if (isVertical)
+			ipRotated = ipRotated.rotateLeft();
+		ImagePlus imp2 = new ImagePlus("", ipRotated);
+		imp2.setCalibration(imp.getCalibration());
+		if (uncalibratedOD && (imp2.getType()==ImagePlus.GRAY16 || imp2.getType()==ImagePlus.GRAY32))
+			new ImageConverter(imp2).convertToGray8();
+		if (invertPeaks) {
+				ImageProcessor ip2 = imp2.getProcessor().duplicate();
+				ip2.invert();
+				imp2.setProcessor(null, ip2);
+		}
+		//imp2.show();
+
+		for (int i=1; i<=nLanes; i++) {
+			if (isVertical)
+				imp2.setRoi(firstRect.y,
+							ipRotated.getHeight() - x[i] - firstRect.width,
+							firstRect.height, firstRect.width);
+			else
+				imp2.setRoi(firstRect.x, x[i], firstRect.width, firstRect.height);
+			ProfilePlot pp = new ProfilePlot(imp2);
+			profiles[i] = pp.getProfile();
+			if (pp.getMin()<min)
+				min = pp.getMin();
+			if (pp.getMax()>max)
+				max = pp.getMax();
+			if (uncalibratedOD)
+				profiles[i] = od(profiles[i]);
+		}
+		if (uncalibratedOD) {
+			min = odMin;
+			max = odMax;
+		}
+
+		if (isVertical)
+			plotWidth = firstRect.height;
+		else
+			plotWidth = firstRect.width;
+		if (plotWidth<650)
+			plotWidth = 650;
+		if (isVertical) {
+			if (plotWidth>4*firstRect.height)
+				plotWidth = 4*firstRect.height;
+		} else {
+			if (plotWidth>4*firstRect.width)
+				plotWidth = 4*firstRect.width;
+		}
+
+		if (verticalScaleFactor==0.0) verticalScaleFactor=1.0;
+		if (horizontalScaleFactor==0.0) horizontalScaleFactor=1.0;
+		Dimension screen = IJ.getScreenSize();
+		if (plotWidth>screen.width-screen.width/6)
+			plotWidth = screen.width - screen.width/6;
+		plotWidth = (int)(plotWidth*horizontalScaleFactor);
+		plotHeight = plotWidth/2;
+		if (plotHeight<250) plotHeight = 250;
+		// if (plotHeight>500) plotHeight = 500;
+		plotHeight = (int)(plotHeight*verticalScaleFactor);
+		ImageProcessor ip = new ByteProcessor(plotWidth, topMargin+nLanes*plotHeight+bottomMargin);
+		ip.setColor(Color.white);
+		ip.fill();
+		ip.setColor(Color.black);
+		//draw border
+		int h= ip.getHeight();
+		ip.moveTo(0,0);
+		ip.lineTo(plotWidth-1,0);
+		ip.lineTo(plotWidth-1, h-1);
+		ip.lineTo(0, h-1);
+		ip.lineTo(0, 0);
+		ip.moveTo(0, h-2);
+		ip.lineTo(plotWidth-1, h-2);
+		String s = imp.getTitle()+"; ";
+		Calibration cal = imp.getCalibration();
+		if (cal.calibrated())
+			s += cal.getValueUnit();
+		else if (uncalibratedOD)
+			s += "Uncalibrated OD";
+		else
+			s += "Uncalibrated";
+		ip.moveTo(5,topMargin);
+		ip.drawString(s);
+		double xScale = (double)plotWidth/profiles[1].length;
+		double yScale;
+		if ((max-min)==0.0)
+			yScale = 1.0;
+		else
+			yScale = plotHeight/(max-min);
+		for (int i=1; i<=nLanes; i++) {
+			double[] profile = profiles[i];
+			int top = (i-1)*plotHeight + topMargin;
+			int base = top+plotHeight;
+			ip.moveTo(0, base);
+			ip.lineTo((int)(profile.length*xScale), base);
+			ip.moveTo(0, base-(int)((profile[0]-min)*yScale));
+			for (int j = 1; j<profile.length; j++)
+				ip.lineTo((int)(j*xScale+0.5), base-(int)((profile[j]-min)*yScale+0.5));
+		}
+		Line.setWidth(1);
+		ImagePlus plots = new Plots();
+		plots.setProcessor("Plots of "+imp.getShortTitle(), ip);
+		plots.changes = true;
+		ip.setThreshold(0,0,ImageProcessor.NO_LUT_UPDATE); // Wand tool works better with threshold set
+		if (cal.calibrated()) {
+			double pixelsAveraged = isVertical?firstRect.width:firstRect.height;
+			double scale = Math.sqrt((xScale*yScale)/pixelsAveraged);
+			Calibration plotsCal = plots.getCalibration();
+			plotsCal.setUnit("unit");
+			plotsCal.pixelWidth = 1.0/scale;
+			plotsCal.pixelHeight = 1.0/scale;
+		}
+		plots.show();
+		saveNLanes = nLanes;
+		nLanes = 0;
+		saveID = 0;
+		//gel = null;
+		ipLanes = null;
+		Toolbar toolbar = Toolbar.getInstance();
+		toolbar.setColor(Color.black);
+		toolbar.setTool(Toolbar.LINE);
+		ImageWindow win = WindowManager.getCurrentWindow();
+		ImageCanvas canvas = win.getCanvas();
+		if (canvas instanceof PlotsCanvas)
+			plotsCanvas = (PlotsCanvas)canvas;
+		else
+			plotsCanvas = null;
+	}
+
+	double[] od(double[] profile) {
+		double v;
+		for (int i=0; i<profile.length; i++) {
+			v = 0.434294481*Math.log(255.0/(255.0-profile[i]));
+			//v = 0.434294481*Math.log(255.0/v);
+			if (v<odMin) odMin = v;
+			if (v>odMax) odMax = v;
+			profile[i] = v;
+		}
+		return profile;
+	}
+
+	void outlineLanes() {
+		if (gel==null || overlay==null) {
+			show("Data needed to outline lanes is no longer available.");
+			return;
+		}
+		int lineWidth = (int)(1.0/gel.getCanvas().getMagnification());
+		if (lineWidth<1)
+			lineWidth = 1;
+		Font f = new Font("Helvetica", Font.PLAIN, 12*lineWidth);
+		ImageProcessor ip = gel.getProcessor();
+		ImageProcessor ipLanes = ip.duplicate();
+		if (!(ipLanes instanceof ByteProcessor))
+			ipLanes = ipLanes.convertToByte(true);
+		ipLanes.setFont(f);
+		ipLanes.setLineWidth(lineWidth);
+		setCustomLut(ipLanes);
+		ImagePlus lanes = new ImagePlus("Lanes of "+gel.getShortTitle(), ipLanes);
+		lanes.changes = true;
+		lanes.setRoi(gel.getRoi());
+		gel.deleteRoi();
+		for (int i=0; i<overlay.size(); i++) {
+			Roi roi = overlay.get(i);
+			Rectangle r = roi.getBounds();
+			ipLanes.drawRect(r.x, r.y, r.width, r.height);
+			String s = ""+(i+1);
+			if(isVertical) {
+				int yloc = r.y;
+				if (yloc<lineWidth*12) yloc += lineWidth*14;
+				ipLanes.drawString(s, r.x+r.width/2-ipLanes.getStringWidth(s)/2, yloc);
+			} else {
+				int xloc = r.x-ipLanes.getStringWidth(s)-2;
+				if (xloc<lineWidth*10) xloc = r.x + 2;
+				ipLanes.drawString(s, xloc, r.y+r.height/2+6);
+			}
+		}
+		lanes.deleteRoi();
+		lanes.show();
+	}
+	
+	void setCustomLut(ImageProcessor ip) {
+		IndexColorModel cm = (IndexColorModel)ip.getColorModel();
+		byte[] reds = new byte[256];
+		byte[] greens = new byte[256];
+		byte[] blues = new byte[256];
+		cm.getReds(reds);
+		cm.getGreens(greens);
+		cm.getBlues(blues);
+		reds[1] =(byte) 255;
+		greens[1] = (byte)0;
+		blues[1] = (byte)0;
+		ip.setColorModel(new IndexColorModel(8, 256, reds, greens, blues));
+		byte[] pixels = (byte[])ip.getPixels();
+		for (int i=0; i<pixels.length; i++)
+			if ((pixels[i]&255)==1)
+			   pixels[i] = 0;
+		ip.setColor(1);
+	}
+
+	void show(String msg) {
+		IJ.showMessage("Gel Analyzer", msg);
+	}
+
+	public static ImagePlus getGelImage() {
+		return gel;
+	}
+
+}
+
+
+class Plots extends ImagePlus {
+
+	/** Overrides ImagePlus.show(). */
+	public void show() {
+		img = ip.createImage();
+		ImageCanvas ic = new PlotsCanvas(this);
+		win = new ImageWindow(this, ic);
+		IJ.showStatus("");
+		if (ic.getMagnification()==1.0)
+			return;
+		while(ic.getMagnification()<1.0)
+			ic.zoomIn(0,0);
+		Point loc = win.getLocation();
+		int w = getWidth()+20;
+		int h = getHeight()+30;
+		Dimension screen = IJ.getScreenSize();
+		if (loc.x+w>screen.width)
+			w = screen.width-loc.x-20;
+		if (loc.y+h>screen.height)
+			h = screen.height-loc.y-30;
+		win.setSize(w, h);
+		win.validate();
+		repaintWindow();
+	}
+
+}
+
+
+class PlotsCanvas extends ImageCanvas {
+
+	public static final int MAX_PEAKS = 200;
+
+	double[] actual = {428566.00,351368.00,233977.00,99413.00,60057.00,31382.00,
+					   14531.00,7843.00,2146.00,752.00,367.00};
+	double[] measured = new double[MAX_PEAKS];
+	Rectangle[] rect = new Rectangle[MAX_PEAKS];
+	int counter;
+	ResultsTable rt;
+
+	public PlotsCanvas(ImagePlus imp) {
+		super(imp);
+	}
+
+	public void mousePressed(MouseEvent e) {
+		super.mousePressed(e);
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			return;
+		if (roi.getType()==Roi.LINE)
+			Roi.setColor(Color.blue);
+		else
+			Roi.setColor(Color.yellow);
+		if (Toolbar.getToolId()!=Toolbar.WAND || IJ.spaceBarDown())
+			return;
+		if (IJ.shiftKeyDown()) {
+			IJ.showMessage("Gel Analyzer", "Unable to measure area because shift key is down.");
+			imp.deleteRoi();
+			counter = 0;
+			return;
+		}
+		ImageStatistics stats = imp.getStatistics();
+		if (counter==0) {
+			rt = ResultsTable.getResultsTable();
+			rt.reset();
+		}
+		//IJ.setColumnHeadings(" \tArea");
+		double perimeter = roi.getLength();
+		String error = "";
+		double circularity = 4.0*Math.PI*(stats.pixelCount/(perimeter*perimeter));
+		if (circularity<0.025)
+			error = " (error?)";
+		double area = stats.pixelCount+perimeter/2.0; // add perimeter/2 to account area under border
+		Calibration cal = imp.getCalibration();
+		area = area*cal.pixelWidth*cal.pixelHeight;
+		rect[counter] = roi.getBounds();
+
+		//area += (rect[counter].width/rect[counter].height)*1.5;
+		// adjustment for small peaks from NIH Image gel macros
+
+		int places = cal.scaled()?3:0;
+		rt.incrementCounter();
+		rt.addValue("Area", area);
+		rt.show("Results");
+		measured[counter] = area;
+		if (counter<MAX_PEAKS)
+			counter++;
+	}
+
+	public void mouseReleased(MouseEvent e) {
+		super.mouseReleased(e);
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.getType()==Roi.LINE) {
+			Undo.setup(Undo.FILTER, imp);
+			imp.getProcessor().snapshot();
+			roi.drawPixels();
+			imp.updateAndDraw();
+			imp.deleteRoi();
+		}
+	}
+
+	void reset() {
+		counter = 0;
+	}
+
+	void labelPeaks() {
+		imp.deleteRoi();
+		double total = 0.0;
+		for (int i=0; i<counter; i++)
+			total += measured[i];
+		ImageProcessor ip = imp.getProcessor();
+		ip.setFont(new Font("SansSerif", Font.PLAIN, 9));
+		for (int i=0; i<counter; i++) {
+			Rectangle r = rect[i];
+			String s;
+			if (GelAnalyzer.labelWithPercentages)
+				s = IJ.d2s((measured[i]/total)*100, 2);
+			else
+				s = IJ.d2s(measured[i], 0);
+			int swidth = ip.getStringWidth(s);
+			int x = r.x + r.width/2 - swidth/2;
+			int y = r.y + r.height*3/4 + 9;
+			int[] data = new int[swidth];
+			ip.getRow(x, y, data, swidth);
+			boolean fits = true;
+			for (int j=0; j<swidth; j++)
+				if (data[j]!=255) {
+					fits = false;
+					break;
+				}
+			fits = fits && measured[i]>500;
+			if (r.height>=(GelAnalyzer.plotHeight-11))
+				fits = true;
+			if (!fits)
+				y = r.y - 2;
+			ip.drawString(s, x, y);
+		}
+		imp.updateAndDraw();
+		displayPercentages();
+		//Toolbar.getInstance().setTool(Toolbar.RECTANGLE);
+		reset();
+	}
+
+	void displayPercentages() {
+		ResultsTable rt = ResultsTable.getResultsTable();
+		rt.reset();
+		//IJ.setColumnHeadings(" \tarea\tpercent");
+		double total = 0.0;
+		for (int i=0; i<counter; i++)
+			total += measured[i];
+		if (IJ.debugMode && counter==actual.length) {
+			debug();
+			return;
+		}
+		for (int i=0; i<counter; i++) {
+			double percent = (measured[i]/total)*100;
+			rt.incrementCounter();
+			rt.addValue("Area", measured[i]);
+			rt.addValue("Percent", percent);
+		}
+		rt.show("Results");
+	}
+
+	void debug() {
+		for (int i=0; i<counter; i++) {
+			double a = (actual[i]/actual[0])*100;
+			double m = (measured[i]/measured[0])*100;
+		}
+	}
+	
+}
+
diff --git a/src/ij/plugin/GifWriter.java b/src/ij/plugin/GifWriter.java
new file mode 100644
index 0000000..38953b1
--- /dev/null
+++ b/src/ij/plugin/GifWriter.java
@@ -0,0 +1,2058 @@
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.*;
+import java.io.*;
+import java.awt.*;
+import java.awt.image.*;
+import javax.imageio.ImageIO;
+
+/** Saves the active image in GIF format, or as an animated GIF if the image is a stack. */
+public class GifWriter implements PlugIn {
+	static int transparentIndex = Prefs.getTransparentIndex();
+	private boolean showErrors = true;
+	private String error;
+		
+	/** Saves the specified image in GIF format or as an animated GIF if the image is a stack. */
+	public static String save(ImagePlus imp, String path) {
+		if (imp==null)
+			imp = IJ.getImage();
+		if (path==null || path.length()==0)
+			path = SaveDialog.getPath(imp, ".gif");
+		if (path==null)
+			return null;
+		GifWriter gf = new GifWriter();
+		//gf.showErrors = false;
+		gf.run(imp, path);
+		return gf.error;
+	}
+
+	public void run(String path) {
+		ImagePlus imp = IJ.getImage();
+		if (path==null || path.equals("")) {
+			SaveDialog sd = new SaveDialog("Save as Gif", imp.getTitle(), ".gif");
+			if (sd.getFileName()==null) return;
+			path = sd.getDirectory()+sd.getFileName();
+		}
+		run(imp, path);
+	}
+	   
+	private void run(ImagePlus imp, String path) {
+		ImageStack stack = imp.getStack();
+		Overlay overlay = imp.getOverlay();
+		int nSlices = stack.size();				
+		if (nSlices==1) { // save using ImageIO
+			if (overlay!=null && !imp.tempOverlay())
+				imp = imp.flatten();
+			try {
+				writeImage(imp, path, transparentIndex);
+			} catch (Exception e) {
+				String msg = e.getMessage();
+				if (msg==null || msg.equals(""))
+					msg = ""+e;
+				error = msg;
+				if (showErrors) {
+					msg = "An error occured writing the file.\n \n" + msg;
+					if (msg.contains("NullPointerException"))
+						msg = "Incorrect file path: \""+path+"\"";
+					IJ.error("GIF Writer", msg);
+					showErrors = false;
+				}
+			}
+			return;
+		}		
+		AnimatedGifEncoder2 ge = new AnimatedGifEncoder2();
+		if (!ge.setoptions())
+			return;
+		double fps = imp.getCalibration().fps;
+		if (fps==0.0) fps = Animator.getFrameRate();
+		if (fps<=0.2) fps = 0.2;
+		if (fps>60.0) fps = 60.0;
+		ge.setDelay((int)((1.0/fps)*1000.0));
+		if (transparentIndex!=-1) {
+			ge.transparent = true;
+			ge.transIndex = transparentIndex;
+		}
+		ge.start(path);
+		ImagePlus tmp = new ImagePlus();
+		for (int i=1; i<=nSlices; i++) {
+			IJ.showStatus("writing: "+i+"/"+nSlices);
+			IJ.showProgress((double)i/nSlices);
+			tmp.setProcessor(null, stack.getProcessor(i));
+			if (overlay!=null) {
+				Overlay overlay2 = overlay.duplicate();
+				overlay2.crop(i, i);
+				if (overlay2.size()>0) {
+					tmp.setOverlay(overlay2);
+					tmp = tmp.flatten();
+					if (imp.getBitDepth()==8)
+						new ImageConverter(tmp).convertRGBtoIndexedColor(256);
+				}
+			}			
+			try {
+				ge.addFrame(tmp);
+			} catch(Exception e)  {
+				error = ""+e;
+				if (showErrors) {
+					IJ.error("Save as Gif: "+e);
+					showErrors = false;
+				}
+			}
+		}	
+		ge.finish();
+		IJ.showStatus("");
+		IJ.showProgress(1.0);
+	}
+	
+	private void writeImage(ImagePlus imp, String path, int transparentIndex) throws Exception {
+		if (transparentIndex>=0 && transparentIndex<=255)
+			writeImageWithTransparency(imp, path, transparentIndex);
+		else
+			ImageIO.write(imp.getBufferedImage(), "gif", new File(path));
+	}
+	
+	private void writeImageWithTransparency(ImagePlus imp, String path, int transparentIndex) throws Exception {
+		int width = imp.getWidth();
+		int	 height = imp.getHeight();
+		ImageProcessor ip = imp.getProcessor();
+		IndexColorModel cm = (IndexColorModel)ip.getColorModel();
+		int size = cm.getMapSize();
+		//IJ.log("write: "+size+" "+transparentIndex);
+		byte[] reds = new byte[256];
+		byte[] greens = new byte[256];
+		byte[] blues = new byte[256];	
+		cm.getReds(reds); 
+		cm.getGreens(greens); 
+		cm.getBlues(blues);
+		cm = new IndexColorModel(8, size, reds, greens, blues, transparentIndex);
+		WritableRaster wr = cm.createCompatibleWritableRaster(width, height);
+		DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
+		byte[] biPixels = db.getData();
+		System.arraycopy(ip.getPixels(), 0, biPixels, 0, biPixels.length);
+		BufferedImage bi = new BufferedImage(cm, wr, false, null);
+		ImageIO.write(bi, "gif", new File(path));
+	}
+
+}
+
+
+/**
+ * Class AnimatedGifEncoder2 - Encodes a GIF file consisting of one or
+ * more frames.
+ * <pre>
+ *
+ *
+ * Extensively Modified for ImagePlus
+ * Extended to handle 8 bit Images with more complex Color lookup tables with transparency index
+ *
+ * Ryan Raz March 2002
+ * raz@rraz.ca
+ * Version 1.01
+ ** Extensively Modified for ImagePlus
+ * Extended to handle 8 bit Images with more complex Color lookup tables with transparency index
+ *
+ * Ryan Raz March 2002
+ * ryan@rraz.ca
+ * Version 1.01 Please report any bugs
+ *
+ * Operation Manual
+ *
+ *
+ * 1) Load stack with 8 bit or RGB images it is possible to use the animated gif reader but because the color
+ *	 table is lost it is best to also load a separate copy of the first image in the series this will allow 
+ *	 extraction of the original image color look up table (see 1below)
+ * 2)Check the option list to bring up the option list.
+ * 3)Experiment with the option list. I usually use a global color table to save space, set to do not dispose if 
+ *		each consecutive image is overlayed on the previous image.
+ * 4)Color table can be imported from another image or extracted from 8bit stack images or loaded as the
+ *	  first 256	 RGB triplets from a RGB images, the last mode takes either a imported image or current 
+ *	  stack and creates the color table from scratch.
+ *	
+ *
+ *	  To do list 
+ *
+ *	   1) Modify existing Animated Gif reader plug in to import in 8 bit mode (currently only works in 
+ *		   RGB	mode.  Right now the best way to alter an animated gif is to save the first image separately
+ *		   and then read the single gif and use the plugin animated reader to read the animated gif to the 
+ *		   stack. Let this plugin encode the stack using the single gif's color table.
+ *		2) Add support for background colors easy but I have no use for them
+ *		3) RGB to 8 bit converter is a linear search. Needs to be replaced with sorted list and fast search. But 
+ *			this update could cause problems with some types of gifs. Easy fix get a faster computer.
+ *		4) Try updating NN color converter seems to be heavily weighted towards quantity of pixels.
+ *		  example:
+ *			 if there is 90% of the image covered in shades of one color or grey the 10% of other colors tend 
+ *			 to be poorly represented it  over fits the shades and under fits the others. Works well if the
+ *			distribution  is balanced.
+ *		 5) Add support for all sizes of Color Look Up tables.
+ *		 6) Re-code to be cleaner. This is my second Java program and I started with some code with too 
+ *			 many  global variables and I added more switches so its a bit hard to follow.
+ *
+ * Credits for the base conversion codes
+ * No copyright asserted on the source code of this class.	May be used
+ * for any purpose, however, refer to the Unisys LZW patent for restrictions
+ * on use of the associated LZWEncoder class.  Please forward any corrections
+ * to kweiner@fmsware.com.
+ *
+ * @author Kevin Weiner, FM Software
+ * @version 1.0 December 2000
+ *
+ *
+ * Example:
+ *	  AnimatedGifEncoder2 e = new AnimatedGifEncoder2();
+ *	  e.start(outputFileName);
+ *	  e.addFrame(image1);
+ *	  e.addFrame(image2);
+ *		"			"			  "
+ *	  e.finish();
+ * </pre>
+ *
+ *
+ */
+
+class AnimatedGifEncoder2 {
+
+	protected int width;					// image size
+	protected int height;
+	protected boolean transparent = false;  // transparent color if given
+	protected int transIndex;			// transparent index in color table
+	protected int repeat = -1;			// no repeat
+	protected int delay = 50;			 // frame delay (hundredths)
+	protected boolean started = false;	// ready to output frames
+	protected OutputStream out;
+	protected ImagePlus image;		// current frame
+	protected byte[] pixels;				// BGR byte array from frame
+	protected byte[] indexedPixels;		// converted frame indexed to palette
+	protected int colorDepth;			// number of bit planes
+	protected byte[] colorTab;			// RGB palette
+	protected int lctSize = 7;			// local color table size (bits-1)
+	protected int dispose = 0;		   // disposal code (-1 = use default)
+	protected boolean closeStream = false;  // close stream when finished
+	protected boolean firstFrame = true;
+	protected boolean sizeSet = false;	// if false, get size from first frame
+	protected int sample = 2;		   // default sample interval for quantizer distance should be small for small icons
+	protected byte[] gct = null;		//Global color table
+	protected boolean gctused = false; // Set to true to use Global color table
+	protected boolean autotransparent = false; // Set True if transparency index coming from image 8 bit only
+	protected boolean GCTextracted = false; // Set if global color table extracted from rgb image 
+	protected boolean GCTloadedExternal = false; // Set if global color table loaded directly from external image 
+	protected int	   GCTred =	 0;	  //Transparent Color
+	protected	  int  GCTgrn = 0;	  // green
+	protected	  int	GCTbl  =  0;   // blue
+	protected	  int	GCTcindex = 0;	//index into color table
+	protected boolean GCTsetTransparent = false; //If true then Color table transparency index is set
+	protected boolean GCToverideIndex = false; //If true Transparent index is set to index with closest colors
+	protected boolean GCToverideColor = false; //if true Color at Transparent index is set to GCTred, GCTgrn GCTbl
+   
+   /**
+	* Adds next GIF frame.	The frame is not written immediately, but is
+	* actually deferred until the next frame is received so that timing
+	* data can be inserted.	 Invoking <code>finish()</code> flushes all
+	* frames.  If <code>setSize</code> was not invoked, the size of the
+	* first image is used for all subsequent frames.
+	*
+	* @param im	 containing frame to write.
+	* @return true if successful.
+	*/
+   public boolean addFrame(ImagePlus image) {
+	  if ((image == null) || !started) return false;
+	  boolean ok = true;
+	  try {
+		 if (firstFrame) {
+			if (!sizeSet) {
+			   // use first frame's size
+			   setSize(image.getWidth(), image.getHeight());
+			}
+			if(gctused)
+			  writeLSDgct();				 // logical screen descriptior
+			  if (GCTloadedExternal){	 //Using external image as color table 
+				colorTab = gct;
+				TransparentIndex(colorTab); //check transparency color
+				writePalette();		// write global color table
+				if (repeat >= 0)
+				writeNetscapeExt();		 // use NS app extension to indicate reps
+			 }
+			if (!gctused) {
+				writeLSD();
+				if (repeat >= 0)
+				writeNetscapeExt();		 // use NS app extension to indicate reps
+			 }
+			firstFrame = false;
+		 }
+	  
+		int type = image.getType();
+		// If  indexed byte image then format does not need changing	  
+		int k;
+		if ((type == 0) ||( type == 3)) //8 bit images
+			Process8bitCLT(image);
+		else if (type==4)	{ //4 for RGB		   
+			packrgb(image);
+			OverRideQuality(image.getWidth()*image.getHeight());							
+			if (gctused && (gct == null))	 { //quality should not	depend on image size
+				analyzePixels();	// build global color table & map pixels
+				colorTab = gct; 
+				TransparentIndex(colorTab); //check transparency color
+				writePalette();		// write global color table
+				if (repeat >= 0)
+				writeNetscapeExt();		 // use NS app extension to indicate reps
+			} else
+				analyzePixels();		// build color table & map pixels
+		}
+		else throw new IllegalArgumentException("Image must be 8-bit or RGB");
+		TransparentIndex(colorTab); //check transparency color
+		 writeGraphicCtrlExt();			// write graphic control extension
+		 writeImageDesc();				// image descriptor
+		 if(!gctused) writePalette();				 // local color table
+		 writePixels();					// encode and write pixel data
+	  } catch (IOException e) { ok = false; }
+
+	  return ok;
+   }
+   
+ /* 
+	Handles transparency color Index
+	Assumes colors and index are already checked for validity
+ */	 
+   void	  TransparentIndex(byte[] colorTab){
+	 if(autotransparent|| !GCTsetTransparent) return;
+	 if(colorTab==null)throw new IllegalArgumentException("Color Table not loaded."); 
+	 int len = colorTab.length;
+	 setTransparent(true); //Sets color tranparency flag
+	 if (!(GCToverideColor||GCToverideIndex)){
+			transIndex = GCTcindex;	 //sets color index
+			return;
+		 }
+		 if(GCToverideIndex)
+		 	GCTcindex= findClosest(colorTab, GCTred, GCTgrn, GCTbl); 
+		//finds index in color Table
+		 transIndex = GCTcindex;	
+		 int pindex = 3*GCTcindex;
+		 if (pindex>(len-3))
+			throw new IllegalArgumentException("Index ("+transIndex+") too large for Color Lookup table."); 
+		  colorTab[pindex++]  = (byte)GCTred; //Set Color Table[transparent index] with specified color
+		  colorTab[pindex++]  = (byte)GCTgrn;
+		  colorTab[pindex] = (byte)GCTbl;
+   }
+
+String name;
+
+public boolean setoptions() {
+	String[] GCTtype = {"Do not use","Load from Current Image", "Load from another Image RGB or 8 Bit",
+	 "Use another RGB to create a new color table " };
+	String[] DisposalType = { "No Disposal","Do not Dispose", "Restore to Background", "Restore to previous" };
+	String[] TransparencyType ={"No Transparency", "Automatically Set if Available (8 bit only)", "Set to Index",
+				"Set to index with specified color", "Set to the index that is closest to specified color"};
+		int setdelay=delay*10;
+	int gctType=0;
+	int setTrans;
+	if (GCTloadedExternal) gctType = 2;
+	if (GCTextracted&&GCTloadedExternal) gctType =3;
+	if (gctused&&!(GCTextracted||GCTloadedExternal))gctType=1;
+	setTrans=1;
+	if (!(autotransparent||GCTsetTransparent||GCToverideIndex||GCToverideColor)) setTrans=0;
+	if (GCTsetTransparent&& !(GCToverideIndex||GCToverideColor)) setTrans = 2;
+	if (GCTsetTransparent&& GCToverideIndex && !GCToverideColor) setTrans = 4;
+	if (GCTsetTransparent&& !GCToverideIndex && GCToverideColor) setTrans = 3;		
+	int red = GCTred;
+	int grn = GCTgrn;
+	int bl = GCTbl;
+	int cindex =GCTcindex;	
+	setRepeat(0);				
+	autotransparent=false;			//no transparent index
+	GCTsetTransparent=false;
+	GCToverideIndex=false;
+	GCToverideColor=false;
+	setTransparent(false);
+	switch (setTrans) {
+				  case 0:	break;
+		  case 1:	autotransparent=true;			 //Set if available from image byte images only
+						break;
+				  case 2:	if(cindex>-1) {
+								GCTsetTransparent=true;	 //set specified  index as transparent color
+								GCTcindex=cindex;	
+							} else
+								IJ.error("Incorrect color index must have value between 0 and 255");
+						break;
+				   case 3:		if((cindex>-1)&&(red>-1)) {	//Set transparent index with specified color
+								GCTsetTransparent=true;
+									GCToverideColor=true;
+									GCTcindex=cindex;	
+									GCTred=red;
+									GCTgrn=grn;
+									GCTbl=bl;
+								} else	 
+										IJ.error("Incorrect colors or color index, they must have values between 0 and 255.");
+								break;	
+					case 4:		if(red>-1){
+									GCTsetTransparent=true;		//Set transparent index to
+						GCToverideIndex=true;	//index which is closest to the specified color
+						GCTred=red;					// and replace the color at the index with
+									GCTgrn=grn;
+									GCTbl=bl;
+								 } else
+								 	IJ.error("Incorrect colors, they must have values between 0 and 255.");
+								break;		
+					default:	break;			
+	}
+	
+	gctused = false; // Set to true to use Global color table
+	GCTextracted = false; // Set if global color table extracted from rgb image 
+	GCTloadedExternal = false; // Set if global color table loaded directly from external image 	
+	return true;
+  }
+  
+/********************************************************
+*	 Gets Color lookup Table from  8 bit image plus pointer to image
+*/
+void Process8bitCLT(ImagePlus image) {  
+		colorDepth = 8;
+		setTransparent(false);		  
+		ByteProcessor pg = new ByteProcessor(image.getImage());
+		ColorModel cm = pg.getColorModel();
+		if (cm instanceof IndexColorModel)
+			indexedPixels = (byte[])(pg.getPixels());
+		else
+			throw new IllegalArgumentException("Image must be 8-bit");
+		IndexColorModel m = (IndexColorModel)cm;
+		if (autotransparent) {
+			transIndex = m.getTransparentPixel();
+			if ((transIndex > -1) && (transIndex < 256)) setTransparent(true); //Sets color flag
+			else transIndex =0;
+		}
+		int mapSize = m.getMapSize();
+		int k;
+		if (gctused && (gct == null))	{	
+			gct = new byte[mapSize*3];	  //Global color table needs to be intialized
+			for (int i = 0; i < mapSize; i++) {
+				k=i*3;
+				colorTab[k] = (byte)m.getRed(i);
+				colorTab[k+1] = (byte)m.getGreen(i);
+				colorTab[k+2] = (byte)m.getBlue(i);
+			}
+			try { 
+				if (! GCTloadedExternal)  {
+						colorTab = gct;
+						writePalette();		// write global color table
+						if (repeat >= 0)
+							writeNetscapeExt();		 // use NS app extension to indicate reps
+				}
+			} catch (IOException e) {
+					System.err.println("Caught IOException: " +	 e.getMessage());
+			}
+		 }
+		 if (gctused)
+			colorTab = gct;
+		 else {
+			colorTab = new byte[mapSize*3];
+			for (int i = 0; i < mapSize; i++) {
+				k=i*3;
+				colorTab[k] = (byte)m.getRed(i);
+				colorTab[k+1] = (byte)m.getGreen(i);
+				colorTab[k+2] = (byte)m.getBlue(i);
+			}
+		}
+		m.finalize();  
+	}	   
+
+   /**
+	* Flushes any pending data and closes output file.
+	* If writing to an OutputStream, the stream is not
+	* closed.
+	*/
+   public boolean finish() {
+	  if (!started) return false;
+	  boolean ok = true;
+	  started = false;
+	  try {
+		 out.write(0x3b);  // gif trailer
+		 out.flush();
+		 if (closeStream)
+			out.close();
+	  } catch (IOException e) { ok = false; }
+
+	  // reset for subsequent use
+	  GCTextracted = false; // Set if global color table extracted from rgb image 
+	  GCTloadedExternal = false; // Set if global color table loaded directly from external image 
+	  transIndex = 0;
+	  transparent = false;	  
+	  gct = null;		//Global color table
+	  out = null;
+	  image = null;
+	  pixels = null;
+	  indexedPixels = null;
+	  colorTab = null;
+	  closeStream = false;
+	  firstFrame = true;
+
+	  return ok;
+   }
+
+/*
+	* Function to load Global Color Table from 8 bit  ImagePlus
+	* This function has to be called before addFrame
+	*/
+   public void loadGCT8bit(ImagePlus image){
+   int type = image.getType();
+   if (!(((type == 0) ||( type == 3))&&(image!=null)))
+			throw new IllegalArgumentException("Color Table Image must be 8 bit");
+   gctused = true;
+   GCTloadedExternal = true;
+   gct = null; 
+   Process8bitCLT(image);
+   }
+/*
+	* Function to extract Global Color Table from RGB ImagePlus
+	* This function has to be called before addFrame
+	*/
+   public void extractGCTrgb(ImagePlus image){
+	  if((image== null)||(4!=image.getType()))
+			throw new IllegalArgumentException("Color Table Image must be RGB");
+	  packrgb(image);
+	  gctused = true;
+	  GCTextracted = true;
+	  GCTloadedExternal =true;
+	  gct = null; 
+	  OverRideQuality(image.getWidth()*image.getHeight());
+	  analyzePixels();		// build color table 
+	  pixels = null;
+	}
+	
+void packrgb(ImagePlus image){
+	int len = image.getWidth()*image.getHeight();
+	ImageProcessor imp = image.getProcessor();
+	 int[] pix = (int[]) imp.getPixels();
+		pixels = new byte[len*3];
+				//pack pixels
+		 for(int i=0; i<len; i++){
+			int k=i*3;
+			pixels[k+2] = (byte)((pix[i] & 0xff0000)>>16);	 //red
+			pixels[k+1] = (byte)((pix[i] & 0x00ff00)>>8); //green
+				pixels[k] = (byte)(pix[i] & 0x0000ff); //blue
+				}
+}
+
+/*
+	* Function to use the first up to 255 elements of a RGB ImagePlus to construct
+	*	 a global color table
+	* This function has to be called before addFrame
+	*/	  
+public void loadGCTrgb(ImagePlus image){
+	if((image == null)||(4!=image.getType()))
+		throw new IllegalArgumentException("Color Table Image must be RGB");
+	int len = image.getWidth()*image.getHeight();
+	if(len>255)len=255;
+	ImageProcessor imp = image.getProcessor();
+		int[] pix = (int[]) imp.getPixels();
+		gct = new byte[len*3];
+				//pack pixels into color Table
+		 for(int i=0; i<len; i++){
+			int k=i*3;
+			gct[k] = (byte)((pix[i] & 0xff0000)>>16);	//red
+			gct[k+1] = (byte)((pix[i] & 0x00ff00)>>8); //green
+			gct[k+2] = (byte)(pix[i] & 0x0000ff); //blue
+		}
+		gctused = true;
+		GCTloadedExternal = true;
+}
+	
+   /*
+	* If gct = true then a global color table is use
+	*
+	*/
+   public void setGCT(boolean flag){
+		gctused = flag;
+   }	  
+   
+   /**
+	* Sets the delay time between each frame, or changes it
+	* for subsequent frames (applies to last frame added).
+	*
+	* @param ms int delay time in milliseconds
+	*/
+   public void setDelay(int ms) {
+	  delay = Math.round(ms / 10.0f);
+   }
+
+
+   /**
+	* Sets the GIF frame disposal code for the last added frame
+	* and any subsequent frames.  Default is 0 if no transparent
+	* color has been set, otherwise 2.
+	* @param code int disposal code.
+	*/
+   public void setDispose(int code) {
+	  if (code >= 0)
+		 dispose = code;
+   }
+
+
+   /**
+	* Sets frame rate in frames per second.	 Equivalent to
+	* <code>setDelay(1000/fps)</code>.
+	*
+	* @param fps float frame rate (frames per second)
+	*/
+   public void setFrameRate(float fps) {
+	  if (fps != 0f) {
+		 delay = Math.round(100f/fps);
+	  }
+   }
+
+
+   /**
+	* Sets quality of color quantization (conversion of images
+	* to the maximum 256 colors allowed by the GIF specification).
+	* Lower values (minimum = 1) produce better colors, but slow
+	* processing significantly.	 10 is the default, and produces
+	* good color mapping at reasonable speeds.	Values greater
+	* than 20 do not yield significant improvements in speed.
+	*
+	* @param quality int greater than 0.
+	* @return
+	*/
+   public void setQuality(int quality) {
+	  if (quality < 1) quality = 1;
+	  sample = quality;
+   }
+/**
+ *	Set True for Global Color Table use 
+ *	This saves space in the output file but colors may not be so goodif the stack uses
+ *		True color images
+ */
+   public void GlobalColorTableused(boolean gtu){
+		gctused = gtu;
+   }	
+   
+   /**
+	* Sets the number of times the set of GIF frames
+	* should be played.	 Default is 1; 0 means play
+	* indefinitely.	 Must be invoked before the first
+	* image is added.
+	*
+	* @param iter int number of iterations.
+	* @return
+	*/
+   public void setRepeat(int iter) {
+	  if (iter >= 0)
+		 repeat = iter;
+   }
+
+   /**
+	* Sets the GIF frame size.	The default size is the
+	* size of the first frame added if this method is
+	* not invoked.
+	*
+	* @param w int frame width.
+	* @param h int frame width.
+	*/
+   public void setSize(int w, int h) {
+	  if (started && !firstFrame) return;
+	  width = w;
+	  height = h;
+	  if (width < 1) width = 320;
+	  if (height < 1) height = 240;
+	  sizeSet = true;
+   }
+
+
+   /**
+	* Sets the transparent color for the last added frame
+	* and any subsequent frames.
+	* Since all colors are subject to modification
+	* in the quantization process, the color in the final
+	* palette for each frame closest to the given color
+	* becomes the transparent color for that frame.
+	* May be set to null to indicate no transparent color.
+	*
+	* @param c Color to be treated as transparent on display.
+	*/
+   public void setTransparent(boolean c) {
+	  transparent = c;
+   }
+
+
+   /**
+	* Initiates GIF file creation on the given stream.	The stream
+	* is not closed automatically.
+	*
+	* @param os OutputStream on which GIF images are written.
+	* @return false if initial write failed.
+	*/
+   public boolean start(OutputStream os) {
+	  if (os == null) return false;
+	  boolean ok = true;
+	  closeStream = false;
+	  out = os;
+	  try {
+		 writeString("GIF89a");		   // header
+	  } catch (IOException e) { ok = false; }
+	  return started = ok;
+   }
+
+
+   /**
+	* Initiates writing of a GIF file with the specified name.
+	*
+	* @param file String containing output file name.
+	* @return false if open or initial write failed.
+	*/
+   public boolean start(String file) {
+	  boolean ok = true;
+	  try {
+		 out = new BufferedOutputStream(new FileOutputStream(file));
+		 ok = start(out);
+		 closeStream = true;
+	  } catch (IOException e) { ok = false; }
+	  return started = ok;
+   }
+/**
+	Sets Net sample size depending on image size
+	
+**/
+   public void OverRideQuality(int npixs){
+		if(npixs>100000) sample = 10;
+		else sample = npixs/10000;
+		if(sample < 1) sample = 1;
+
+	}
+   /**
+	* Analyzes image colors and creates color map.
+	*/
+   protected void analyzePixels() {
+	  int len = pixels.length;
+	  int nPix = len / 3;
+	  indexedPixels = new byte[nPix];
+	  if (gctused && (gct == null)) {	  
+		NeuQuant nq = new NeuQuant(pixels, len, sample);	// initialize quantizer
+		colorTab = nq.process();							// create reduced palette
+		gct = new byte[colorTab.length];
+		// convert map from BGR to RGB
+		for (int i = 0; i < colorTab.length; i+=3) {
+		 byte temp = colorTab[i];
+		 colorTab[i] = colorTab[i+2];
+		 colorTab[i+2] = temp;
+		 gct[i] = colorTab[i];
+		 gct[i+1]  = colorTab[i+1];
+		 gct[i+2]  =colorTab[i+2];
+		}	
+		if(GCTextracted){
+			indexedPixels= null;
+			return;
+		}		
+	  }				
+	  if (!gctused){					
+		NeuQuant nq = new NeuQuant(pixels, len, sample);	// initialize quantizer
+		colorTab = nq.process();							// create reduced palette
+		// convert map from BGR to RGB
+		for (int i = 0; i < colorTab.length; i+=3) {
+		 byte temp = colorTab[i];
+		 colorTab[i] = colorTab[i+2];
+		 colorTab[i+2] = temp;
+		}
+		// map image pixels to new palette
+		 int k = 0;
+		for (int i = 0; i < nPix; i++)
+		 indexedPixels[i] =
+			(byte) nq.map(pixels[k++] & 0xff, pixels[k++] & 0xff, pixels[k++] & 0xff);
+		pixels = null;
+		colorDepth = 8;
+		lctSize = 7;
+		}
+	  if(gctused){
+	  // find closest match for all pixels This routine is not optimized real slow linear search.
+		colorTab = gct;	  
+		int k = 0;
+		int minpos;
+		for (int j = 0; j < nPix; j++){
+		int b = pixels[k++] & 0xff;
+			int g = pixels[k++] & 0xff;
+			int r = pixels[k++] & 0xff;
+			minpos = 0;
+		int dmin = 256*256*256;
+			int lenct = colorTab.length;
+		for (int i = 0; i < lenct; ) {
+				int dr = r - (colorTab[i++] & 0xff);
+				int dg = g - (colorTab[i++] & 0xff);
+				int db = b - (colorTab[i] & 0xff);
+				int d = dr*dr + dg*dg + db*db;
+				if (d < dmin) {
+						dmin = d;
+						minpos = i/3;
+					}
+				i++;
+			}//end inside for
+			indexedPixels[j]=(byte)minpos;
+	 }//end for
+		pixels = null;
+		colorDepth = 8;
+		lctSize = 7;
+   } //end if
+}
+   
+
+
+   /**
+	* Returns index of palette color closest to c
+	*
+	*/
+   protected int findClosest(byte[] colorTab,  int r, int g, int b) {
+	  if (colorTab == null) return -1;
+	  int minpos = 0;
+	  int dmin = 256*256*256;
+	  int len = colorTab.length;
+	  for (int i = 0; i < len; ) {
+		 int dr = r - (colorTab[i++] & 0xff);
+		 int dg = g - (colorTab[i++] & 0xff);
+		 int db = b - (colorTab[i] & 0xff);
+		 int d = dr*dr + dg*dg + db*db;
+		 if (d < dmin) {
+			dmin = d;
+			minpos = i/3;
+		 }
+		 i++;
+	  }
+	  return minpos;
+   }
+
+   /**
+	* Writes Graphic Control Extension
+	*/
+   protected void writeGraphicCtrlExt() throws IOException {
+	  out.write(0x21);		   // extension introducer
+	  out.write(0xf9);		   // GCE label
+	  out.write(4);			   // data block size
+	  int transp, disp;
+	  if (!transparent) {
+		 transp = 0;
+		 disp = 0;			   // dispose = no action
+	  } else {
+		 transp = 1;
+		 disp = 2;			   // force clear if using transparent color  
+	  }
+	  if (dispose >= 0)
+		 disp = dispose & 7;   // user override
+	  disp <<= 2;
+
+	  // packed fields
+	  out.write(  0 |		   // 1:3 reserved
+			   disp |		   // 4:6 disposal
+			   0 |			   // 7	  user input - 0 = none
+			   transp);		   // 8	  transparency flag
+
+	  writeShort(delay);	   // delay x 1/100 sec
+	  out.write(transIndex);   // transparent color index
+	  out.write(0);			   // block terminator
+  }
+
+
+   /**
+	* Writes Image Descriptor
+	*/
+   protected void writeImageDesc() throws IOException {
+	  out.write(0x2c);		   // image separator
+	  writeShort(0);		   // image position x,y = 0,0
+	  writeShort(0);
+	  writeShort(width);	   // image size
+	  writeShort(height);
+	  // packed fields
+	  if(gctused)
+			out.write(0x00); //global color table
+		else
+			out.write(0x80 |		 // 1 local color table	 1=yes
+			0 |			   // 2 interlace - 0=no
+				0 |			   // 3 sorted - 0=no
+				0 |			   // 4-5 reserved
+				lctSize);		 // size of local color table
+		
+   }
+
+   /**
+	* Writes Logical Screen Descriptor with global color table
+	*/
+   protected void writeLSDgct() throws IOException {
+	  // logical screen size
+	  writeShort(width);
+	  writeShort(height);
+	  // packed fields
+	  out.write((0x80 |		  // 1	 : global color table flag = 0 (nn
+			   0x70 |		  // 2-4 : color resolution = 7
+			   0x00 |		  // 5	 : gct sort flag = 0
+			   lctSize));		 // 6-8 : gct size = 0
+
+	  out.write(0);			  // background color index
+	  out.write(0);			  // pixel aspect ratio - assume 1:1
+   }
+   
+ /**
+	* Writes Logical Screen Descriptor without global color table
+	*/
+   protected void writeLSD() throws IOException {
+	  // logical screen size
+	  writeShort(width);
+	  writeShort(height);
+	  // packed fields
+	  out.write((0x00 |		  // 1	 : global color table flag = 0 (none)
+			   0x70 |		  // 2-4 : color resolution = 7
+			   0x00 |		  // 5	 : gct sort flag = 0
+			   0x00));		  // 6-8 : gct size = 0
+
+	  out.write(0);			  // background color index
+	  out.write(0);			  // pixel aspect ratio - assume 1:1
+   }
+
+   /**
+	* Writes Netscape application extension to define
+	* repeat count.
+	*/
+   protected void writeNetscapeExt() throws IOException {
+	  out.write(0x21);		 // extension introducer
+	  out.write(0xff);		 // app extension label
+	  out.write(11);		 // block size
+	  writeString("NETSCAPE"+"2.0");	// app id + auth code
+	  out.write(3);			 // sub-block size
+	  out.write(1);			 // loop sub-block id
+	  writeShort(repeat);	 // loop count (extra iterations, 0=repeat forever)
+	  out.write(0);			 // block terminator
+   }
+
+   /**
+	* Writes color table
+	*/
+   protected void writePalette() throws IOException {
+	  out.write(colorTab, 0, colorTab.length);
+	  int n = (3 * 256) - colorTab.length;
+	  for (int i = 0; i < n; i++)
+		 out.write(0);
+   }
+
+   /**
+	* Encodes and writes pixel data
+	*/
+   protected void writePixels() throws IOException {
+	  LZWEncoder2 encoder =
+		 new LZWEncoder2(width, height, indexedPixels, colorDepth);
+	  encoder.encode(out);
+   }
+
+   /**
+	*	 Write 16-bit value to output stream, LSB first
+	*/
+   protected void writeShort(int value) throws IOException {
+	  out.write(value & 0xff);
+	  out.write((value >> 8) & 0xff);
+   }
+
+   /**
+	* Writes string to output stream
+	*/
+   protected void writeString(String s) throws IOException {
+	  for (int i = 0; i < s.length(); i++)
+		 out.write((byte) s.charAt(i));
+   }
+}
+
+//==============================================================================
+//	Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
+//	K Weiner 12/00
+class LZWEncoder2 {
+
+  private static final int EOF = -1;
+
+  private int	  imgW, imgH;
+  private byte[]  pixAry;
+  private int	  initCodeSize;
+  private int	  remaining;
+  private int	  curPixel;
+
+
+  // GIFCOMPR.C		  - GIF Image compression routines
+  //
+  // Lempel-Ziv compression based on 'compress'.  GIF modifications by
+  // David Rowley (mgardi@watdcsu.waterloo.edu)
+
+  // General DEFINEs
+
+  static final int BITS = 12;
+
+  static final int HSIZE = 5003;	   // 80% occupancy
+
+  // GIF Image compression - modified 'compress'
+  //
+  // Based on: compress.c - File compression ala IEEE Computer, June 1984.
+  //
+  // By Authors:  Spencer W. Thomas		 (decvax!harpo!utah-cs!utah-gr!thomas)
+  //			  Jim McKie				 (decvax!mcvax!jim)
+  //			  Steve Davies			 (decvax!vax135!petsd!peora!srd)
+  //			  Ken Turkowski			 (decvax!decwrl!turtlevax!ken)
+  //			  James A. Woods		 (decvax!ihnp4!ames!jaw)
+  //			  Joe Orost				 (decvax!vax135!petsd!joe)
+
+  int n_bits;						  // number of bits/code
+  int maxbits = BITS;				  // user settable max # bits/code
+  int maxcode;						  // maximum code, given n_bits
+  int maxmaxcode = 1 << BITS; // should NEVER generate this code
+
+  int[] htab = new int[HSIZE];
+  int[] codetab = new int[HSIZE];
+
+  int hsize = HSIZE;				  // for dynamic table sizing
+
+  int free_ent = 0;					  // first unused entry
+
+  // block compression parameters -- after all codes are used up,
+  // and compression rate changes, start over.
+  boolean clear_flg = false;
+
+  // Algorithm:	 use open addressing double hashing (no chaining) on the
+  // prefix code / next character combination.	We do a variant of Knuth's
+  // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+  // secondary probe.  Here, the modular division first probe is gives way
+  // to a faster exclusive-or manipulation.	 Also do block compression with
+  // an adaptive reset, whereby the code table is cleared when the compression
+  // ratio decreases, but after the table fills.  The variable-length output
+  // codes are re-sized at this point, and a special CLEAR code is generated
+  // for the decompressor.	Late addition:	construct the table according to
+  // file size for noticeable speed improvement on small files.	 Please direct
+  // questions about this implementation to ames!jaw.
+
+  int g_init_bits;
+
+  int ClearCode;
+  int EOFCode;
+
+  // output
+  //
+  // Output the given code.
+  // Inputs:
+  //	  code:	  A n_bits-bit integer.	 If == -1, then EOF.  This assumes
+  //			  that n_bits =< wordsize - 1.
+  // Outputs:
+  //	  Outputs code to the file.
+  // Assumptions:
+  //	  Chars are 8 bits long.
+  // Algorithm:
+  //	  Maintain a BITS character long buffer (so that 8 codes will
+  // fit in it exactly).  Use the VAX insv instruction to insert each
+  // code in turn.	When the buffer fills up empty it and start over.
+
+  int cur_accum = 0;
+  int cur_bits = 0;
+
+  int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
+			  0x001F, 0x003F, 0x007F, 0x00FF,
+			  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
+			  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
+
+  // Number of characters so far in this 'packet'
+  int a_count;
+
+  // Define the storage for the packet accumulator
+  byte[] accum = new byte[256];
+
+
+  //----------------------------------------------------------------------------
+  LZWEncoder2(int width, int height, byte[] pixels, int color_depth)
+  {
+   imgW = width;
+   imgH = height;
+   pixAry = pixels;
+   initCodeSize = Math.max(2, color_depth);
+  }
+
+
+  // Add a character to the end of the current packet, and if it is 254
+  // characters, flush the packet to disk.
+  void char_out( byte c, OutputStream outs ) throws IOException
+	 {
+	 accum[a_count++] = c;
+	 if ( a_count >= 254 )
+		flush_char( outs );
+	 }
+
+
+  // Clear out the hash table
+
+  // table clear for block compress
+  void cl_block( OutputStream outs ) throws IOException
+	 {
+	 cl_hash( hsize );
+	 free_ent = ClearCode + 2;
+	 clear_flg = true;
+
+	 output( ClearCode, outs );
+	 }
+
+
+  // reset code table
+  void cl_hash( int hsize )
+	 {
+	 for ( int i = 0; i < hsize; ++i )
+		htab[i] = -1;
+	 }
+
+
+  void compress( int init_bits, OutputStream outs ) throws IOException
+	 {
+	 int fcode;
+	 int i /* = 0 */;
+	 int c;
+	 int ent;
+	 int disp;
+	 int hsize_reg;
+	 int hshift;
+
+	 // Set up the globals:	 g_init_bits - initial number of bits
+	 g_init_bits = init_bits;
+
+	 // Set up the necessary values
+	 clear_flg = false;
+	 n_bits = g_init_bits;
+	 maxcode = MAXCODE( n_bits );
+
+	 ClearCode = 1 << ( init_bits - 1 );
+	 EOFCode = ClearCode + 1;
+	 free_ent = ClearCode + 2;
+
+	 a_count = 0;  // clear packet
+
+	 ent = nextPixel();
+
+	 hshift = 0;
+	 for ( fcode = hsize; fcode < 65536; fcode *= 2 )
+		++hshift;
+	 hshift = 8 - hshift;		  // set hash code range bound
+
+	 hsize_reg = hsize;
+	 cl_hash( hsize_reg );		  // clear hash table
+
+	 output( ClearCode, outs );
+
+	 outer_loop:
+	 while ( (c = nextPixel()) != EOF )
+		{
+		fcode = ( c << maxbits ) + ent;
+		i = ( c << hshift ) ^ ent;	 // xor hashing
+
+		if ( htab[i] == fcode )
+		   {
+		   ent = codetab[i];
+		   continue;
+		   }
+		else if ( htab[i] >= 0 )	 // non-empty slot
+		   {
+		   disp = hsize_reg - i;  // secondary hash (after G. Knott)
+		   if ( i == 0 )
+			  disp = 1;
+		   do
+			  {
+			  if ( (i -= disp) < 0 )
+				 i += hsize_reg;
+
+			  if ( htab[i] == fcode )
+				 {
+				 ent = codetab[i];
+				 continue outer_loop;
+				 }
+			  }
+		   while ( htab[i] >= 0 );
+		   }
+		output( ent, outs );
+		ent = c;
+		if ( free_ent < maxmaxcode )
+		   {
+		   codetab[i] = free_ent++;	 // code -> hashtable
+		   htab[i] = fcode;
+		   }
+		else
+		   cl_block( outs );
+		}
+	 // Put out the final code.
+	 output( ent, outs );
+	 output( EOFCode, outs );
+	 }
+
+
+  //----------------------------------------------------------------------------
+  void encode(OutputStream os) throws IOException
+  {
+   os.write(initCodeSize);		   // write "initial code size" byte
+
+   remaining = imgW * imgH;		   // reset navigation variables
+   curPixel = 0;
+
+   compress(initCodeSize + 1, os); // compress and write the pixel data
+
+   os.write(0);					   // write block terminator
+  }
+
+
+  // Flush the packet to disk, and reset the accumulator
+  void flush_char( OutputStream outs ) throws IOException
+	 {
+	 if ( a_count > 0 )
+		{
+		outs.write( a_count );
+		outs.write( accum, 0, a_count );
+		a_count = 0;
+		}
+	 }
+
+
+  final int MAXCODE( int n_bits )
+	 {
+	 return ( 1 << n_bits ) - 1;
+	 }
+
+
+  //----------------------------------------------------------------------------
+  // Return the next pixel from the image
+  //----------------------------------------------------------------------------
+  private int nextPixel()
+  {
+   if (remaining == 0)
+	 return EOF;
+
+   --remaining;
+
+   byte pix = pixAry[curPixel++];
+
+   return pix & 0xff;
+  }
+
+
+  void output( int code, OutputStream outs ) throws IOException
+	 {
+	 cur_accum &= masks[cur_bits];
+
+	 if ( cur_bits > 0 )
+		cur_accum |= ( code << cur_bits );
+	 else
+		cur_accum = code;
+
+	 cur_bits += n_bits;
+
+	 while ( cur_bits >= 8 )
+		{
+		char_out( (byte) ( cur_accum & 0xff ), outs );
+		cur_accum >>= 8;
+		cur_bits -= 8;
+		}
+
+	 // If the next entry is going to be too big for the code size,
+	 // then increase it, if possible.
+	if ( free_ent > maxcode || clear_flg )
+		{
+		if ( clear_flg )
+		   {
+		   maxcode = MAXCODE(n_bits = g_init_bits);
+		   clear_flg = false;
+		   }
+		else
+		   {
+		   ++n_bits;
+		   if ( n_bits == maxbits )
+			  maxcode = maxmaxcode;
+		   else
+			  maxcode = MAXCODE(n_bits);
+		   }
+		}
+
+	 if ( code == EOFCode )
+		{
+		// At EOF, write the rest of the buffer.
+		while ( cur_bits > 0 )
+		   {
+		   char_out( (byte) ( cur_accum & 0xff ), outs );
+		   cur_accum >>= 8;
+		   cur_bits -= 8;
+		   }
+
+		flush_char( outs );
+		}
+	 }
+}
+
+
+/* NeuQuant Neural-Net Quantization Algorithm
+ * ------------------------------------------
+ *
+ * Copyright (c) 1994 Anthony Dekker
+ *
+ * NEUQUANT Neural-Net quantization algorithm by Anthony Dekker, 1994.
+ * See "Kohonen neural networks for optimal colour quantization"
+ * in "Network: Computation in Neural Systems" Vol. 5 (1994) pp 351-367.
+ * for a discussion of the algorithm.
+ *
+ * Any party obtaining a copy of these files from the author, directly or
+ * indirectly, is granted, free of charge, a full and unrestricted irrevocable,
+ * world-wide, paid up, royalty-free, nonexclusive right and license to deal
+ * in this software and documentation files (the "Software"), including without
+ * limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons who receive
+ * copies from any such party to do so, with the only requirement being
+ * that this copyright notice remain intact.
+ */
+
+// Ported to Java 12/00 K Weiner
+
+class NeuQuant {
+
+   protected static final int netsize = 256; /* number of colours used */
+
+   /* four primes near 500 - assume no image has a length so large */
+   /* that it is divisible by all four primes */
+   protected static final int prime1 = 499;
+   protected static final int prime2 = 491;
+   protected static final int prime3 = 487;
+   protected static final int prime4 = 503;
+
+   protected static final int minpicturebytes = (3 * prime4);
+   /* minimum size for input image */
+
+   /* Program Skeleton
+	  ----------------
+	  [select samplefac in range 1..30]
+	  [read image from input file]
+	  pic = (unsigned char*) malloc(3*width*height);
+	  initnet(pic,3*width*height,samplefac);
+	  learn();
+	  unbiasnet();
+	  [write output image header, using writecolourmap(f)]
+	  inxbuild();
+	  write output image using inxsearch(b,g,r)		 */
+
+   /* Network Definitions
+	  ------------------- */
+
+   protected static final int maxnetpos = (netsize - 1);
+   protected static final int netbiasshift = 4; /* bias for colour values */
+   protected static final int ncycles = 100;	/* no. of learning cycles */
+
+   /* defs for freq and bias */
+   protected static final int intbiasshift = 16; /* bias for fractions */
+   protected static final int intbias = (((int) 1) << intbiasshift);
+   protected static final int gammashift = 10;	 /* gamma = 1024 */
+   protected static final int gamma = (((int) 1) << gammashift);
+   protected static final int betashift = 10;
+   protected static final int beta = (intbias >> betashift); /* beta = 1/1024 */
+   protected static final int betagamma = (intbias << (gammashift - betashift));
+
+   /* defs for decreasing radius factor */
+   protected static final int initrad = (netsize >> 3); /* for 256 cols, radius starts */
+   protected static final int radiusbiasshift = 6;		/* at 32.0 biased by 6 bits */
+   protected static final int radiusbias = (((int) 1) << radiusbiasshift);
+   protected static final int initradius = (initrad * radiusbias); /* and decreases by a */
+   protected static final int radiusdec = 30;			/* factor of 1/30 each cycle */
+
+   /* defs for decreasing alpha factor */
+   protected static final int alphabiasshift = 10;		/* alpha starts at 1.0 */
+   protected static final int initalpha = (((int) 1) << alphabiasshift);
+
+   protected int alphadec; /* biased by 10 bits */
+
+   /* radbias and alpharadbias used for radpower calculation */
+   protected static final int radbiasshift = 8;
+   protected static final int radbias = (((int) 1) << radbiasshift);
+   protected static final int alpharadbshift = (alphabiasshift + radbiasshift);
+   protected static final int alpharadbias = (((int) 1) << alpharadbshift);
+
+   /* Types and Global Variables
+   -------------------------- */
+
+   protected byte[] thepicture;				 /* the input image itself */
+   protected int lengthcount;				 /* lengthcount = H*W*3 */
+
+   protected int samplefac; /* sampling factor 1..30 */
+
+   //	typedef int pixel[4];				 /* BGRc */
+   protected int[][] network; /* the network itself - [netsize][4] */
+
+   protected int[] netindex = new int[256];	 /* for network lookup - really 256 */
+
+   protected int[] bias = new int[netsize];	 /* bias and freq arrays for learning */
+   protected int[] freq = new int[netsize];
+   protected int[] radpower = new int[initrad]; /* radpower for precomputation */
+
+
+   /* Initialise network in range (0,0,0) to (255,255,255) and set parameters
+	  ----------------------------------------------------------------------- */
+
+   public NeuQuant(byte[] thepic, int len, int sample) {
+
+	  int i;
+	  int[] p;
+
+	  thepicture = thepic;
+	  lengthcount = len;
+	  samplefac = sample;
+
+	  network = new int[netsize][];
+	  for (i = 0; i < netsize; i++) {
+		 network[i] = new int[4];
+		 p = network[i];
+		 p[0] = p[1] = p[2] = (i << (netbiasshift + 8)) / netsize;
+		 freq[i] = intbias / netsize; /* 1/netsize */
+		 bias[i] = 0;
+	  }
+   }
+
+
+   public byte[] colorMap() {
+	  byte[] map = new byte[3*netsize];
+	  int[] index = new int[netsize];
+	  for (int i = 0; i < netsize; i++)
+		 index[network[i][3]] = i;
+	  int k = 0;
+	  for (int i = 0; i < netsize; i++) {
+			int j = index[i];
+			map[k++] = (byte) (network[j][0]);
+			map[k++] = (byte) (network[j][1]);
+			map[k++] = (byte) (network[j][2]);
+	  }
+	  return map;
+   }
+
+
+   /* Insertion sort of network and building of netindex[0..255] (to do after unbias)
+	  ------------------------------------------------------------------------------- */
+
+   public void inxbuild() {
+
+	  int i, j, smallpos, smallval;
+	  int[] p;
+	  int[] q;
+	  int previouscol, startpos;
+
+	  previouscol = 0;
+	  startpos = 0;
+	  for (i = 0; i < netsize; i++) {
+		 p = network[i];
+		 smallpos = i;
+		 smallval = p[1]; /* index on g */
+		 /* find smallest in i..netsize-1 */
+		 for (j = i + 1; j < netsize; j++) {
+			q = network[j];
+			if (q[1] < smallval) { /* index on g */
+			   smallpos = j;
+			   smallval = q[1]; /* index on g */
+			}
+		 }
+		 q = network[smallpos];
+		 /* swap p (i) and q (smallpos) entries */
+		 if (i != smallpos) {
+			j = q[0];	 q[0] = p[0];	 p[0] = j;
+			j = q[1];	 q[1] = p[1];	 p[1] = j;
+			j = q[2];	 q[2] = p[2];	 p[2] = j;
+			j = q[3];	 q[3] = p[3];	 p[3] = j;
+		 }
+		 /* smallval entry is now in position i */
+		 if (smallval != previouscol) {
+			netindex[previouscol] = (startpos + i) >> 1;
+			for (j = previouscol + 1; j < smallval; j++)
+			   netindex[j] = i;
+			previouscol = smallval;
+			startpos = i;
+		 }
+	  }
+	  netindex[previouscol] = (startpos + maxnetpos) >> 1;
+	  for (j = previouscol + 1; j < 256; j++)
+		 netindex[j] = maxnetpos; /* really 256 */
+   }
+
+
+   /* Main Learning Loop
+	  ------------------ */
+
+   public void learn() {
+
+	  int i, j, b, g, r;
+	  int radius, rad, alpha, step, delta, samplepixels;
+	  byte[] p;
+	  int pix, lim;
+
+	  if (lengthcount < minpicturebytes)
+		 samplefac = 1;
+	  alphadec = 30 + ((samplefac - 1) / 3);
+	  p = thepicture;
+	  pix = 0;
+	  lim = lengthcount;
+	  samplepixels = lengthcount / (3 * samplefac);
+	  delta = samplepixels / ncycles;
+	  alpha = initalpha;
+	  radius = initradius;
+
+	  rad = radius >> radiusbiasshift;
+	  if (rad <= 1)
+		 rad = 0;
+	  for (i = 0; i < rad; i++)
+		 radpower[i] = alpha * (((rad * rad - i * i) * radbias) / (rad * rad));
+
+	  //fprintf(stderr,"beginning 1D learning: initial radius=%d\n", rad);
+
+	  if (lengthcount < minpicturebytes)
+		 step = 3;
+	  else if ((lengthcount % prime1) != 0)
+		 step = 3 * prime1;
+	  else {
+		 if ((lengthcount % prime2) != 0)
+			step = 3 * prime2;
+		 else {
+			if ((lengthcount % prime3) != 0)
+			   step = 3 * prime3;
+			else
+			   step = 3 * prime4;
+		 }
+	  }
+
+	  i = 0;
+	  while (i < samplepixels) {
+		 b = (p[pix + 0] & 0xff) << netbiasshift;
+		 g = (p[pix + 1] & 0xff) << netbiasshift;
+		 r = (p[pix + 2] & 0xff) << netbiasshift;
+		 j = contest(b, g, r);
+
+		 altersingle(alpha, j, b, g, r);
+		 if (rad != 0)
+			alterneigh(rad, j, b, g, r); /* alter neighbours */
+
+		 pix += step;
+		 if (pix >= lim)
+			pix -= lengthcount;
+
+		 i++;
+		 if (i % delta == 0) {
+			alpha -= alpha / alphadec;
+			radius -= radius / radiusdec;
+			rad = radius >> radiusbiasshift;
+			if (rad <= 1)
+			   rad = 0;
+			for (j = 0; j < rad; j++)
+			   radpower[j] = alpha * (((rad * rad - j * j) * radbias) / (rad * rad));
+		 }
+	  }
+	  //fprintf(stderr,"finished 1D learning: final alpha=%f !\n",((float)alpha)/initalpha);
+   }
+
+
+   /* Search for BGR values 0..255 (after net is unbiased) and return colour index
+	  ---------------------------------------------------------------------------- */
+
+   public int map(int b, int g, int r) {
+
+	  int i, j, dist, a, bestd;
+	  int[] p;
+	  int best;
+
+	  bestd = 1000; /* biggest possible dist is 256*3 */
+	  best = -1;
+	  i = netindex[g]; /* index on g */
+	  j = i - 1; /* start at netindex[g] and work outwards */
+
+	  while ((i < netsize) || (j >= 0)) {
+		 if (i < netsize) {
+			p = network[i];
+			dist = p[1] - g; /* inx key */
+			if (dist >= bestd)
+			   i = netsize; /* stop iter */
+			else {
+			   i++;
+			   if (dist < 0)
+				  dist = -dist;
+			   a = p[0] - b;
+			   if (a < 0)
+				  a = -a;
+			   dist += a;
+			   if (dist < bestd) {
+				  a = p[2] - r;
+				  if (a < 0)
+					 a = -a;
+				  dist += a;
+				  if (dist < bestd) {
+					 bestd = dist;
+					 best = p[3];
+				  }
+			   }
+			}
+		 }
+		 if (j >= 0) {
+			p = network[j];
+			dist = g - p[1]; /* inx key - reverse dif */
+			if (dist >= bestd)
+			   j = -1; /* stop iter */
+			else {
+			   j--;
+			   if (dist < 0)
+				  dist = -dist;
+			   a = p[0] - b;
+			   if (a < 0)
+				  a = -a;
+			   dist += a;
+			   if (dist < bestd) {
+				  a = p[2] - r;
+				  if (a < 0)
+					 a = -a;
+				  dist += a;
+				  if (dist < bestd) {
+					 bestd = dist;
+					 best = p[3];
+				  }
+			   }
+			}
+		 }
+	  }
+	  return (best);
+   }
+
+
+   public byte[] process() {
+	  learn();
+	  unbiasnet();
+	  inxbuild();
+	  return colorMap();
+   }
+
+
+   /* Unbias network to give byte values 0..255 and record position i to prepare for sort
+	  ----------------------------------------------------------------------------------- */
+
+   public void unbiasnet() {
+
+	  int i, j;
+
+	  for (i = 0; i < netsize; i++) {
+		 network[i][0] >>= netbiasshift;
+		 network[i][1] >>= netbiasshift;
+		 network[i][2] >>= netbiasshift;
+		 network[i][3] = i; /* record colour no */
+	  }
+   }
+
+
+   /* Move adjacent neurons by precomputed alpha*(1-((i-j)^2/[r]^2)) in radpower[|i-j|]
+	  --------------------------------------------------------------------------------- */
+
+   protected void alterneigh(int rad, int i, int b, int g, int r) {
+
+	  int j, k, lo, hi, a, m;
+	  int[] p;
+
+	  lo = i - rad;
+	  if (lo < -1)
+		 lo = -1;
+	  hi = i + rad;
+	  if (hi > netsize)
+		 hi = netsize;
+
+	  j = i + 1;
+	  k = i - 1;
+	  m = 1;
+	  while ((j < hi) || (k > lo)) {
+		 a = radpower[m++];
+		 if (j < hi) {
+			p = network[j++];
+			try {
+			   p[0] -= (a * (p[0] - b)) / alpharadbias;
+			   p[1] -= (a * (p[1] - g)) / alpharadbias;
+			   p[2] -= (a * (p[2] - r)) / alpharadbias;
+			} catch (Exception e) {} // prevents 1.3 miscompilation
+		 }
+		 if (k > lo) {
+			p = network[k--];
+			try {
+			   p[0] -= (a * (p[0] - b)) / alpharadbias;
+			   p[1] -= (a * (p[1] - g)) / alpharadbias;
+			   p[2] -= (a * (p[2] - r)) / alpharadbias;
+			} catch (Exception e) {}
+		 }
+	  }
+   }
+
+
+   /* Move neuron i towards biased (b,g,r) by factor alpha
+	  ---------------------------------------------------- */
+
+   protected void altersingle(int alpha, int i, int b, int g, int r) {
+
+	  /* alter hit neuron */
+	  int[] n = network[i];
+	  n[0] -= (alpha * (n[0] - b)) / initalpha;
+	  n[1] -= (alpha * (n[1] - g)) / initalpha;
+	  n[2] -= (alpha * (n[2] - r)) / initalpha;
+   }
+
+
+   /* Search for biased BGR values
+	  ---------------------------- */
+
+   protected int contest(int b, int g, int r) {
+
+	  /* finds closest neuron (min dist) and updates freq */
+	  /* finds best neuron (min dist-bias) and returns position */
+	  /* for frequently chosen neurons, freq[i] is high and bias[i] is negative */
+	  /* bias[i] = gamma*((1/netsize)-freq[i]) */
+
+	  int i, dist, a, biasdist, betafreq;
+	  int bestpos, bestbiaspos, bestd, bestbiasd;
+	  int[] n;
+
+	  bestd = ~(((int) 1) << 31);
+	  bestbiasd = bestd;
+	  bestpos = -1;
+	  bestbiaspos = bestpos;
+
+	  for (i = 0; i < netsize; i++) {
+		 n = network[i];
+		 dist = n[0] - b;
+		 if (dist < 0)
+			dist = -dist;
+		 a = n[1] - g;
+		 if (a < 0)
+			a = -a;
+		 dist += a;
+		 a = n[2] - r;
+		 if (a < 0)
+			a = -a;
+		 dist += a;
+		 if (dist < bestd) {
+			bestd = dist;
+			bestpos = i;
+		 }
+		 biasdist = dist - ((bias[i]) >> (intbiasshift - netbiasshift));
+		 if (biasdist < bestbiasd) {
+			bestbiasd = biasdist;
+			bestbiaspos = i;
+		 }
+		 betafreq = (freq[i] >> betashift);
+		 freq[i] -= betafreq;
+		 bias[i] += (betafreq << gammashift);
+	  }
+	  freq[bestpos] += beta;
+	  bias[bestpos] -= betagamma;
+	  return (bestbiaspos);
+   }
+}
+
+
+//==============================================================================
+//	Adapted from Jef Poskanzer's Java port by way of J. M. G. Elliott.
+//	K Weiner 12/00
+
+
+class LZWEncoder {
+
+  private static final int EOF = -1;
+
+  private int	  imgW, imgH;
+  private byte[]  pixAry;
+  private int	  initCodeSize;
+  private int	  remaining;
+  private int	  curPixel;
+
+
+  // GIFCOMPR.C		  - GIF Image compression routines
+  //
+  // Lempel-Ziv compression based on 'compress'.  GIF modifications by
+  // David Rowley (mgardi@watdcsu.waterloo.edu)
+
+  // General DEFINEs
+
+  static final int BITS = 12;
+
+  static final int HSIZE = 5003;	   // 80% occupancy
+
+  // GIF Image compression - modified 'compress'
+  //
+  // Based on: compress.c - File compression ala IEEE Computer, June 1984.
+  //
+  // By Authors:  Spencer W. Thomas		 (decvax!harpo!utah-cs!utah-gr!thomas)
+  //			  Jim McKie				 (decvax!mcvax!jim)
+  //			  Steve Davies			 (decvax!vax135!petsd!peora!srd)
+  //			  Ken Turkowski			 (decvax!decwrl!turtlevax!ken)
+  //			  James A. Woods		 (decvax!ihnp4!ames!jaw)
+  //			  Joe Orost				 (decvax!vax135!petsd!joe)
+
+  int n_bits;						  // number of bits/code
+  int maxbits = BITS;				  // user settable max # bits/code
+  int maxcode;						  // maximum code, given n_bits
+  int maxmaxcode = 1 << BITS; // should NEVER generate this code
+
+  int[] htab = new int[HSIZE];
+  int[] codetab = new int[HSIZE];
+
+  int hsize = HSIZE;				  // for dynamic table sizing
+
+  int free_ent = 0;					  // first unused entry
+
+  // block compression parameters -- after all codes are used up,
+  // and compression rate changes, start over.
+  boolean clear_flg = false;
+
+  // Algorithm:	 use open addressing double hashing (no chaining) on the
+  // prefix code / next character combination.	We do a variant of Knuth's
+  // algorithm D (vol. 3, sec. 6.4) along with G. Knott's relatively-prime
+  // secondary probe.  Here, the modular division first probe is gives way
+  // to a faster exclusive-or manipulation.	 Also do block compression with
+  // an adaptive reset, whereby the code table is cleared when the compression
+  // ratio decreases, but after the table fills.  The variable-length output
+  // codes are re-sized at this point, and a special CLEAR code is generated
+  // for the decompressor.	Late addition:	construct the table according to
+  // file size for noticeable speed improvement on small files.	 Please direct
+  // questions about this implementation to ames!jaw.
+
+  int g_init_bits;
+
+  int ClearCode;
+  int EOFCode;
+
+  // output
+  //
+  // Output the given code.
+  // Inputs:
+  //	  code:	  A n_bits-bit integer.	 If == -1, then EOF.  This assumes
+  //			  that n_bits =< wordsize - 1.
+  // Outputs:
+  //	  Outputs code to the file.
+  // Assumptions:
+  //	  Chars are 8 bits long.
+  // Algorithm:
+  //	  Maintain a BITS character long buffer (so that 8 codes will
+  // fit in it exactly).  Use the VAX insv instruction to insert each
+  // code in turn.	When the buffer fills up empty it and start over.
+
+  int cur_accum = 0;
+  int cur_bits = 0;
+
+  int masks[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000F,
+			  0x001F, 0x003F, 0x007F, 0x00FF,
+			  0x01FF, 0x03FF, 0x07FF, 0x0FFF,
+			  0x1FFF, 0x3FFF, 0x7FFF, 0xFFFF };
+
+  // Number of characters so far in this 'packet'
+  int a_count;
+
+  // Define the storage for the packet accumulator
+  byte[] accum = new byte[256];
+
+
+  //----------------------------------------------------------------------------
+  LZWEncoder(int width, int height, byte[] pixels, int color_depth) {
+   imgW = width;
+   imgH = height;
+   pixAry = pixels;
+   initCodeSize = Math.max(2, color_depth);
+  }
+
+
+  // Add a character to the end of the current packet, and if it is 254
+  // characters, flush the packet to disk.
+  void char_out( byte c, OutputStream outs ) throws IOException
+	 {
+	 accum[a_count++] = c;
+	 if ( a_count >= 254 )
+		flush_char( outs );
+	 }
+
+
+  // Clear out the hash table
+
+  // table clear for block compress
+  void cl_block( OutputStream outs ) throws IOException
+	 {
+	 cl_hash( hsize );
+	 free_ent = ClearCode + 2;
+	 clear_flg = true;
+
+	 output( ClearCode, outs );
+	 }
+
+
+  // reset code table
+  void cl_hash( int hsize )
+	 {
+	 for ( int i = 0; i < hsize; ++i )
+		htab[i] = -1;
+	 }
+
+
+  void compress( int init_bits, OutputStream outs ) throws IOException
+	 {
+	 int fcode;
+	 int i /* = 0 */;
+	 int c;
+	 int ent;
+	 int disp;
+	 int hsize_reg;
+	 int hshift;
+
+	 // Set up the globals:	 g_init_bits - initial number of bits
+	 g_init_bits = init_bits;
+
+	 // Set up the necessary values
+	 clear_flg = false;
+	 n_bits = g_init_bits;
+	 maxcode = MAXCODE( n_bits );
+
+	 ClearCode = 1 << ( init_bits - 1 );
+	 EOFCode = ClearCode + 1;
+	 free_ent = ClearCode + 2;
+
+	 a_count = 0;  // clear packet
+
+	 ent = nextPixel();
+
+	 hshift = 0;
+	 for ( fcode = hsize; fcode < 65536; fcode *= 2 )
+		++hshift;
+	 hshift = 8 - hshift;		  // set hash code range bound
+
+	 hsize_reg = hsize;
+	 cl_hash( hsize_reg );		  // clear hash table
+
+	 output( ClearCode, outs );
+
+	 outer_loop:
+	 while ( (c = nextPixel()) != EOF )
+		{
+		fcode = ( c << maxbits ) + ent;
+		i = ( c << hshift ) ^ ent;	 // xor hashing
+
+		if ( htab[i] == fcode )
+		   {
+		   ent = codetab[i];
+		   continue;
+		   }
+		else if ( htab[i] >= 0 )	 // non-empty slot
+		   {
+		   disp = hsize_reg - i;  // secondary hash (after G. Knott)
+		   if ( i == 0 )
+			  disp = 1;
+		   do
+			  {
+			  if ( (i -= disp) < 0 )
+				 i += hsize_reg;
+
+			  if ( htab[i] == fcode )
+				 {
+				 ent = codetab[i];
+				 continue outer_loop;
+				 }
+			  }
+		   while ( htab[i] >= 0 );
+		   }
+		output( ent, outs );
+		ent = c;
+		if ( free_ent < maxmaxcode )
+		   {
+		   codetab[i] = free_ent++;	 // code -> hashtable
+		   htab[i] = fcode;
+		   }
+		else
+		   cl_block( outs );
+		}
+	 // Put out the final code.
+	 output( ent, outs );
+	 output( EOFCode, outs );
+	 }
+
+
+  //----------------------------------------------------------------------------
+  void encode(OutputStream os) throws IOException
+  {
+   os.write(initCodeSize);		   // write "initial code size" byte
+
+   remaining = imgW * imgH;		   // reset navigation variables
+   curPixel = 0;
+
+   compress(initCodeSize + 1, os); // compress and write the pixel data
+
+   os.write(0);					   // write block terminator
+  }
+
+
+  // Flush the packet to disk, and reset the accumulator
+  void flush_char( OutputStream outs ) throws IOException
+	 {
+	 if ( a_count > 0 )
+		{
+		outs.write( a_count );
+		outs.write( accum, 0, a_count );
+		a_count = 0;
+		}
+	 }
+
+
+  final int MAXCODE( int n_bits )
+	 {
+	 return ( 1 << n_bits ) - 1;
+	 }
+
+
+  //----------------------------------------------------------------------------
+  // Return the next pixel from the image
+  //----------------------------------------------------------------------------
+  private int nextPixel()
+  {
+   if (remaining == 0)
+	 return EOF;
+
+   --remaining;
+
+   byte pix = pixAry[curPixel++];
+
+   return pix & 0xff;
+  }
+
+
+  void output( int code, OutputStream outs ) throws IOException
+	 {
+	 cur_accum &= masks[cur_bits];
+
+	 if ( cur_bits > 0 )
+		cur_accum |= ( code << cur_bits );
+	 else
+		cur_accum = code;
+
+	 cur_bits += n_bits;
+
+	 while ( cur_bits >= 8 )
+		{
+		char_out( (byte) ( cur_accum & 0xff ), outs );
+		cur_accum >>= 8;
+		cur_bits -= 8;
+		}
+
+	 // If the next entry is going to be too big for the code size,
+	 // then increase it, if possible.
+	if ( free_ent > maxcode || clear_flg )
+		{
+		if ( clear_flg )
+		   {
+		   maxcode = MAXCODE(n_bits = g_init_bits);
+		   clear_flg = false;
+		   }
+		else
+		   {
+		   ++n_bits;
+		   if ( n_bits == maxbits )
+			  maxcode = maxmaxcode;
+		   else
+			  maxcode = MAXCODE(n_bits);
+		   }
+		}
+
+	 if ( code == EOFCode )
+		{
+		// At EOF, write the rest of the buffer.
+		while ( cur_bits > 0 )
+		   {
+		   char_out( (byte) ( cur_accum & 0xff ), outs );
+		   cur_accum >>= 8;
+		   cur_bits -= 8;
+		   }
+
+		flush_char( outs );
+		}
+	 }
+}
+
diff --git a/src/ij/plugin/Grid.java b/src/ij/plugin/Grid.java
new file mode 100644
index 0000000..348647e
--- /dev/null
+++ b/src/ij/plugin/Grid.java
@@ -0,0 +1,288 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.geom.*;
+import java.util.*;
+
+/** This class implements the Analyze/Tools/Grid command. */
+public class Grid implements PlugIn, DialogListener {
+	private static final String OPTIONS = "grid.options";
+	private static final String GRID = "|GRID|";
+	private static double crossSize = 0.1;
+	private static String[] colors = {"Red","Green","Blue","Magenta","Cyan","Yellow","Orange","Black","White"};
+	private final static int LINES=0, HLINES=1, CROSSES=2, POINTS=3, CIRCLES=4, NONE=4;
+	private static String[] types = {"Lines","Horizontal Lines", "Crosses", "Points", "Circles", "None"};
+	private Random random = new Random(System.currentTimeMillis());
+	private ImagePlus imp;
+	private double tileWidth, tileHeight;
+	private int xstart, ystart;
+	private int linesV, linesH;
+	private double pixelWidth=1.0, pixelHeight=1.0;
+	private String units = "pixels";
+	private boolean isMacro;
+	private Roi gridOnEntry;
+
+	private String type = types[LINES];
+	private double areaPerPoint;
+	private static double saveAreaPerPoint;
+	private String color = "Cyan";
+	private boolean bold;
+	private boolean randomOffset;
+	private boolean centered;
+	private Checkbox centerCheckbox, randomCheckbox;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		Overlay overlay = imp.getOverlay();
+		int index = overlay!=null?overlay.getIndex(GRID):-1;
+		if (index>=0)
+			gridOnEntry = overlay.get(index);
+		if (showDialog() && !isMacro)
+			saveSettings();
+	}
+		
+	// http://stackoverflow.com/questions/30654203/how-to-create-a-circle-using-generalpath-and-apache-poi
+	private void drawCircles(double size) {
+		double R  = size*tileWidth;
+		if (R<1) R =1;
+		if (bold && type.equals(types[POINTS])) R*=1.5;
+		double kappa = 0.5522847498f;
+		GeneralPath path = new GeneralPath();
+		for(int h=0; h<linesV; h++) {
+			for(int v=0; v<linesH; v++) {
+				double x = xstart+h*tileWidth;
+				double y = ystart+v*tileHeight;
+				path.moveTo(x, y-R);
+				path.curveTo(x+R*kappa, y-R, x+R, y-R*kappa, x+R, y);
+				path.curveTo(x+R, y+R*kappa, x+R*kappa, y+R, x, y+R );
+				path.curveTo(x-R*kappa, y+R, x-R, y+R*kappa, x-R, y);
+				path.curveTo(x-R, y-R*kappa, x-R*kappa, y-R, x, y-R );
+				path.closePath();
+			}
+		}
+		drawGrid(path);
+	}
+
+	private void drawCrosses() {
+		GeneralPath path = new GeneralPath();
+		double arm  = crossSize*tileWidth;
+		if (arm<3) arm=3;
+		for(int h=0; h<linesV; h++) {
+			for(int v=0; v<linesH; v++) {
+				double x = xstart+h*tileWidth;
+				double y = ystart+v*tileHeight;
+				path.moveTo(x-arm, y);
+				path.lineTo(x+arm, y);
+				path.moveTo(x, y-arm);
+				path.lineTo(x, y+arm);
+			}
+		}
+		drawGrid(path);
+	}
+
+	private void drawLines() {
+		GeneralPath path = new GeneralPath();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		for(int i=0; i<linesV; i++) {
+			float xoff = (float)(xstart+i*tileWidth);
+			path.moveTo(xoff,0f);
+			path.lineTo(xoff, height);
+		}
+		for(int i=0; i<linesH; i++) {
+			float yoff = (float)(ystart+i*tileHeight);
+			path.moveTo(0f, yoff);
+			path.lineTo(width, yoff);
+		}
+		drawGrid(path);
+	}
+
+	private void drawHorizontalLines() {
+		GeneralPath path = new GeneralPath();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		for(int i=0; i<linesH; i++) {
+			float yoff = (float)(ystart+i*tileHeight);
+			path.moveTo(0f, yoff);
+			path.lineTo(width, yoff);
+		}
+		drawGrid(path);
+	}
+
+	void drawGrid(Shape shape) {
+		if (shape==null) {
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null) {
+				if (overlay.size()>1) {
+					overlay.remove(GRID);
+					imp.draw();
+				} else
+					imp.setOverlay(null);
+			}
+		} else {
+			Roi roi = new ShapeRoi(shape);
+			roi.setStrokeColor(Colors.getColor(color,Color.cyan));
+			if (bold && linesV*linesH<5000) {
+				ImageCanvas ic = imp.getCanvas();
+				double mag = ic!=null?ic.getMagnification():1.0;
+				double width = 2.0;
+				if (mag<1.0)
+					width = width/mag;
+				roi.setStrokeWidth(width);
+			}
+			IJ.showStatus(linesV*linesH+" nodes");
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null)
+				overlay.remove(GRID);
+			else
+				overlay = new Overlay();
+			overlay.add(roi, GRID);
+			imp.setOverlay(overlay);
+		}
+	}
+
+	private boolean showDialog() {
+		isMacro = Macro.getOptions()!=null;
+		if (!isMacro)
+			getSettings();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		Calibration cal = imp.getCalibration();
+		int places;
+		if (cal.scaled()) {
+			pixelWidth = cal.pixelWidth;
+			pixelHeight = cal.pixelHeight;
+			units = cal.getUnits();
+			places = 2;
+		} else {
+			pixelWidth = 1.0;
+			pixelHeight = 1.0;
+			units = "pixels";
+			places = 0;
+		}
+		if (areaPerPoint==0.0)
+			areaPerPoint = (width*cal.pixelWidth*height*cal.pixelHeight)/81.0; // default to 9x9 grid
+		GenericDialog gd = new GenericDialog("Grid...");
+		gd.addChoice("Grid type:", types, type);
+		gd.addNumericField("Area per point:", areaPerPoint, places, 6, units+"^2");
+		gd.addChoice("Color:", colors, color);
+		gd.addCheckbox("Bold", bold);
+		gd.addCheckbox("Center grid on image", centered);
+		gd.addCheckbox("Random offset", randomOffset);
+		gd.addDialogListener(this);
+		if (!isMacro) {
+			Vector v = gd.getCheckboxes();
+			centerCheckbox = (Checkbox)v.elementAt(1);
+			randomCheckbox = (Checkbox)v.elementAt(2);
+		}
+		dialogItemChanged(gd, null);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null && gridOnEntry!=null) {
+				overlay.remove(GRID);
+				overlay.add(gridOnEntry);
+				imp.draw();
+			} else
+				drawGrid(null);
+			return false;
+		} else
+			return true;
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		type = gd.getNextChoice();
+		areaPerPoint = gd.getNextNumber();
+		color = gd.getNextChoice();
+		bold = gd.getNextBoolean();
+		centered = gd.getNextBoolean();
+		randomOffset = gd.getNextBoolean();
+		if (randomOffset) {
+			centered = false;
+			if (centerCheckbox!=null)
+				centerCheckbox.setState(false);
+		}
+		double minArea= (width*height)/50000.0;
+		if (type.equals(types[CROSSES])&&minArea<50.0)
+			minArea = 50.0;
+		else if (minArea<16)
+			minArea = 16.0;
+		if (areaPerPoint/(pixelWidth*pixelHeight)<minArea) {
+			String err = "\"Area per Point\" too small";
+			if (gd.wasOKed())
+				IJ.error("Grid", err);
+			else
+				IJ.showStatus(err);
+			return true;
+		}
+		double tileSize = Math.sqrt(areaPerPoint);
+		tileWidth = tileSize/pixelWidth;
+		tileHeight = tileSize/pixelHeight;
+		if (centered) {
+			xstart = (int)Math.round((width%tileWidth)/2.0);
+			ystart = (int)Math.round((height%tileHeight)/2.0);
+		} else if (randomOffset) {
+			xstart = (int)(random.nextDouble()*tileWidth);
+			ystart = (int)(random.nextDouble()*tileHeight);
+		} else {
+			xstart = (int)(tileWidth/2.0+0.5);
+			ystart = (int)(tileHeight/2.0+0.5);
+		}
+		linesV = (int)((width-xstart)/tileWidth)+1; 
+		linesH = (int)((height-ystart)/tileHeight)+1;
+		if (gd.invalidNumber())
+			return true;
+		drawGrid();
+        return true;
+	}
+
+	private void drawGrid() {
+		//IJ.log(centered+" "+xstart+" "+ystart);
+		if (type.equals(types[LINES]))
+			drawLines();
+		else if (type.equals(types[HLINES]))
+			drawHorizontalLines();
+		else if (type.equals(types[CROSSES]))
+			drawCrosses();
+		else  if (type.equals(types[POINTS]))
+			drawCircles(0.01);
+		else  if (type.equals(types[CIRCLES]))
+			drawCircles(0.1);
+		else
+			drawGrid(null);
+	}
+	
+	private void getSettings() {
+		String prefs = Prefs.get(OPTIONS, "Lines,Cyan,-");
+		//IJ.log("options: "+prefs);
+		String[] options = Tools.split(prefs, ",");
+		if (options.length>=3) {
+			type = options[0];
+			if ("None".equals(type))
+				type = types[LINES];
+			areaPerPoint = saveAreaPerPoint;
+			color = options[1];
+			bold = options[2].contains("bold");
+			centered = options[2].contains("centered");
+			randomOffset = options[2].contains("random");
+			if (centered)
+				randomOffset = false;
+		}
+	}
+	
+	private void saveSettings() {
+		String options = type+","+color+",";
+		String options2 = (bold?"bold ":"")+(centered?"centered ":"")+(randomOffset?"random ":"");
+		if (options2.length()==0)
+			options2 = "-";
+		Prefs.set(OPTIONS, options+options2);
+		saveAreaPerPoint = areaPerPoint;
+	}
+
+}
diff --git a/src/ij/plugin/GroupedZProjector.java b/src/ij/plugin/GroupedZProjector.java
new file mode 100644
index 0000000..ea6f72c
--- /dev/null
+++ b/src/ij/plugin/GroupedZProjector.java
@@ -0,0 +1,87 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.GenericDialog;
+import ij.process.*;
+import ij.measure.Calibration;
+
+/** This plugin implements the Image/Stacks/Tools/Grouped Z Project command. */
+
+public class GroupedZProjector implements PlugIn {
+	private static int method = ZProjector.AVG_METHOD;
+	private int groupSize;
+	
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		int size = imp.getStackSize();
+		if (size==1) {
+			IJ.error("Z Project", "This command requires a stack");
+			return;
+		}
+		if (imp.isHyperStack()) {
+			new ZProjector().run("");
+			return;
+		}
+		if (!showDialog(imp))
+			return;
+		ImagePlus imp2 = groupZProject(imp, method, groupSize);
+		imp2.setCalibration(imp.getCalibration());
+		Calibration cal = imp2.getCalibration();
+		cal.pixelDepth *= groupSize;
+		if (imp!=null)
+			imp2.show();
+	}
+	
+	public ImagePlus groupZProject(ImagePlus imp, int method, int groupSize) {
+		if (method<0 || method>=ZProjector.METHODS.length)
+			return null;
+		int[] dim = imp.getDimensions();
+		int projectedStackSize = imp.getStackSize()/groupSize;
+		imp.setDimensions(1, groupSize, projectedStackSize);
+		ZProjector zp = new ZProjector(imp);
+		zp.setMethod(method);
+		zp.setStartSlice(1);
+		zp.setStopSlice(groupSize);
+		zp.doHyperStackProjection(true);
+		imp.setDimensions(dim[2], dim[3], dim[4]);
+
+		ImagePlus zProjectorOutput = zp.getProjection();
+		int[] zProjectDim = zProjectorOutput.getDimensions();
+		for (int i=2; i<dim.length; i++) {
+			if (dim[i] != 1)
+				zProjectDim[i] = projectedStackSize;
+			else
+				zProjectDim[i] = 1;
+		}
+		// Fix dimensions for output ImagePlus
+		zProjectorOutput.setDimensions(zProjectDim[2], zProjectDim[3], zProjectDim[4]);
+		return zProjectorOutput;
+	}
+	
+	boolean showDialog(ImagePlus imp) {
+		int size = imp.getStackSize();
+		GenericDialog gd = new GenericDialog("Z Project");
+		gd.addChoice("Projection method:", ZProjector.METHODS, ZProjector.METHODS[method]);
+		gd.addNumericField("Group size:", size, 0);
+		String factors = "Valid factors: ";
+		int i = 1, count = 0;
+		while (i <= size && count<10) {
+			if (size % i == 0) {
+				count++; factors +=	 " "+ i +",";
+			}
+			i++;
+		}
+		gd.setInsets(10,0,0);
+		gd.addMessage(factors+"...");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		method = gd.getNextChoiceIndex();
+		groupSize = (int)gd.getNextNumber();
+		if (groupSize<1 || groupSize>size || (size%groupSize)!=0) {
+			IJ.error("ZProject", "Group size must divide evenly into the stack size.");
+			return false;
+		}
+		return true;
+	}
+	
+}
\ No newline at end of file
diff --git a/src/ij/plugin/Histogram.java b/src/ij/plugin/Histogram.java
new file mode 100644
index 0000000..4753db6
--- /dev/null
+++ b/src/ij/plugin/Histogram.java
@@ -0,0 +1,186 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.plugin.filter.PlugInFilter;
+import ij.plugin.frame.Recorder;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Vector;
+
+
+/** This plugin implements the Analyze/Histogram command. */
+public class Histogram implements PlugIn, TextListener {
+
+	private static boolean staticUseImageMinAndMax = true;
+	private static double staticXMin, staticXMax;
+	private static String staticYMax = "Auto";
+	private static boolean staticStackHistogram;
+	private static int imageID;	
+	private int nBins = 256;
+	private boolean useImageMinAndMax = true;
+	private double xMin, xMax;
+	private String yMax = "Auto";
+	private boolean stackHistogram;
+	private Checkbox checkbox;
+	private TextField minField, maxField;
+	private String defaultMin, defaultMax;
+
+ 	public void run(String arg) {
+ 		ImagePlus imp = IJ.getImage();
+ 		int bitDepth = imp.getBitDepth();
+ 		if (bitDepth==32 || IJ.altKeyDown() || (IJ.isMacro()&&Macro.getOptions()!=null)) {
+			IJ.setKeyUp(KeyEvent.VK_ALT);
+ 			if (!showDialog(imp))
+ 				return;
+ 		} else {
+ 			int stackSize = imp.getStackSize();
+ 			boolean noDialog = stackSize==1;
+ 			if (stackSize==3) {
+ 				ImageStack stack = imp.getStack();
+ 				String label1 = stack.getSliceLabel(1);
+ 				if ("Hue".equals(label1))
+ 					noDialog = true;
+ 			}
+ 			int flags = noDialog?0:setupDialog(imp, 0);
+ 			if (flags==PlugInFilter.DONE) return;
+			stackHistogram = flags==PlugInFilter.DOES_STACKS;
+			Calibration cal = imp.getCalibration();
+			if (bitDepth==16 && ImagePlus.getDefault16bitRange()!=0) {
+				xMin = 0.0;
+				xMax = Math.pow(2,ImagePlus.getDefault16bitRange())-1;
+				useImageMinAndMax = false;
+			} else if (stackHistogram && ((bitDepth==8&&!cal.calibrated())||imp.isRGB())) {
+				xMin = 0.0;
+				xMax = 256.0;
+				useImageMinAndMax = false;
+			} else
+				useImageMinAndMax = true;
+ 			yMax = "Auto";
+ 		}
+ 		ImageStatistics stats = null;
+ 		if (useImageMinAndMax) {
+ 			xMin = 0.0;
+ 			xMax = 0.0;
+ 		}
+ 		int iyMax = (int)Tools.parseDouble(yMax, 0.0);
+ 		boolean customHistogram = (bitDepth==8||imp.isRGB()) && (!(xMin==0.0&&xMax==0.0)||nBins!=256||iyMax>0);
+		HistogramPlot plot = new HistogramPlot();
+ 		if (stackHistogram || customHistogram) {
+ 			ImagePlus imp2 = imp;
+ 			if (customHistogram && !stackHistogram && imp.getStackSize()>1)
+ 				imp2 = new ImagePlus("Temp", imp.getProcessor());
+			stats = new StackStatistics(imp2, nBins, xMin, xMax);
+			stats.histYMax = iyMax;
+			plot.draw(imp, stats);
+		} else
+			plot.draw(imp, nBins, xMin, xMax, iyMax);
+		plot.show();
+	}
+	
+	boolean showDialog(ImagePlus imp) {
+		if (!IJ.isMacro()) {
+			nBins = HistogramWindow.nBins;
+			useImageMinAndMax = staticUseImageMinAndMax;
+			xMin=staticXMin; xMax=staticXMax;
+			yMax = staticYMax;
+			stackHistogram = staticStackHistogram;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		double min = ip.getMin();
+		double max = ip.getMax();
+		if (imp.getID()!=imageID || (min==xMin&&min==xMax))
+			useImageMinAndMax = true;
+		if (imp.getID()!=imageID || useImageMinAndMax) {
+			xMin = min;
+			xMax = max;
+			Calibration cal = imp.getCalibration();
+			xMin = cal.getCValue(xMin);
+			xMax = cal.getCValue(xMax);
+		}
+		defaultMin = IJ.d2s(xMin,2);
+		defaultMax = IJ.d2s(xMax,2);
+		imageID = imp.getID();
+		int stackSize = imp.getStackSize();
+		GenericDialog gd = new GenericDialog("Histogram");
+		gd.addNumericField("Bins:", nBins, 0);
+		gd.addCheckbox("Use pixel value range", useImageMinAndMax);
+		gd.setInsets(5, 40, 10);
+		gd.addMessage("or use:");
+		int fwidth = 6;
+		int nwidth = Math.max(IJ.d2s(xMin,2).length(), IJ.d2s(xMax,2).length());
+		if (nwidth>fwidth) fwidth = nwidth;
+		int digits = 2;
+		if (xMin==(int)xMin && xMax==(int)xMax)
+			digits = 0;
+		gd.addNumericField("X_min:", xMin, digits, fwidth, null);
+		gd.addNumericField("X_max:", xMax, digits, fwidth, null);
+		gd.setInsets(15, 0, 10);
+		gd.addStringField("Y_max:", yMax, 6);
+		if (stackSize>1)
+			gd.addCheckbox("Stack histogram", stackHistogram);
+		
+		Vector numbers = gd.getNumericFields();
+		if (numbers!=null) {
+			minField = (TextField)numbers.elementAt(1);
+			minField.addTextListener(this);
+			maxField = (TextField)numbers.elementAt(2);
+			maxField.addTextListener(this);
+		}
+		checkbox = (Checkbox)(gd.getCheckboxes().elementAt(0));
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;			
+		nBins = (int)gd.getNextNumber();
+		useImageMinAndMax = gd.getNextBoolean();
+		xMin = gd.getNextNumber();
+		xMax = gd.getNextNumber();
+		yMax = gd.getNextString();
+		stackHistogram = (stackSize>1)?gd.getNextBoolean():false;
+		if (!IJ.isMacro()) {
+			if (nBins>=2 && nBins<=1000)
+				HistogramWindow.nBins = nBins;
+			staticUseImageMinAndMax = useImageMinAndMax;
+			staticXMin=xMin; staticXMax=xMax;
+			staticYMax = yMax;
+			staticStackHistogram = stackHistogram;
+		}
+		IJ.register(Histogram.class);
+		return true;
+	}
+
+	public void textValueChanged(TextEvent e) {
+		boolean rangeChanged = !defaultMin.equals(minField.getText())
+			|| !defaultMax.equals(maxField.getText());
+		if (rangeChanged)
+			checkbox.setState(false);
+	}
+	
+	int setupDialog(ImagePlus imp, int flags) {
+		int stackSize = imp.getStackSize();
+		if (stackSize>1) {
+			String macroOptions = Macro.getOptions();
+			if (macroOptions!=null) {
+				if (macroOptions.indexOf("stack ")>=0)
+					return flags+PlugInFilter.DOES_STACKS;
+				else
+					return flags;
+			}
+			YesNoCancelDialog d = new YesNoCancelDialog(IJ.getInstance(),
+				"Histogram", "Include all "+stackSize+" images?");
+			if (d.cancelPressed())
+				return PlugInFilter.DONE;
+			else if (d.yesPressed()) {
+				if (Recorder.record)
+					Recorder.recordOption("stack");
+				return flags+PlugInFilter.DOES_STACKS;
+			}
+			if (Recorder.record)
+				Recorder.recordOption("slice");
+		}
+		return flags;
+	}
+
+}
diff --git a/src/ij/plugin/Hotkeys.java b/src/ij/plugin/Hotkeys.java
new file mode 100644
index 0000000..f0c3824
--- /dev/null
+++ b/src/ij/plugin/Hotkeys.java
@@ -0,0 +1,198 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.util.*;
+import ij.measure.ResultsTable;
+import java.awt.*;
+import java.io.*;
+import java.util.*;
+
+/** Implements the Plugins/Hotkeys/Create Shortcut and Remove commands. */
+public class Hotkeys implements PlugIn {
+
+	private static final String TITLE = "Hotkeys";
+	private static String command = "";
+	private static String shortcut = "";
+
+	public void run(String arg) {
+		if (arg.equals("install") || arg.equals("install2"))
+			installHotkey(arg);
+		else if (arg.equals("remove"))
+			removeHotkey();
+		else if (arg.equals("list"))
+			listCommands();
+		else {
+			Executer e = new Executer(arg);
+			e.run();
+		}
+		IJ.register(Hotkeys.class);
+	}
+
+	void installHotkey(String arg) {
+		boolean byName = arg.equals("install2");
+		String[] commands = byName?null:getAllCommands();
+		String[] shortcuts = getAvailableShortcuts();
+		String nCommands = commands!=null?" ("+commands.length+")":"";
+		GenericDialog gd = new GenericDialog("Add Shortcut"+nCommands);
+		gd.addChoice("Shortcut:", shortcuts, shortcuts[0]);
+		if (byName)
+			gd.addStringField("Command:", "", 20);
+		else
+			gd.addChoice("Command:", commands, command);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		shortcut = gd.getNextChoice();
+		if (byName) {
+			command = gd.getNextString();
+			Hashtable cmds = Menus.getCommands();
+			if (cmds==null || cmds.get(command)==null) {
+				String command2 = command;
+				if (cmds.get(command)==null)
+					command = command+" ";
+				if (cmds.get(command)==null) {
+					command = command2 + "...";
+					if (cmds.get(command)==null) {
+						command = command2;
+						IJ.error("Command not found:\n \n   "+ "\""+command+"\"");
+						return;
+					}
+				}
+			}
+		} else {
+			command = gd.getNextChoice();
+			Hashtable cmds = Menus.getCommands();
+			if (command.contains("[") && cmds!=null && cmds.get(command)==null) {
+				if (cmds.get(command+"]")!=null)
+					command += "]";
+			}
+		}
+		String plugin = "ij.plugin.Hotkeys("+"\""+command+"\")";
+		int err = Menus.installPlugin(plugin,Menus.SHORTCUTS_MENU,"*"+command,shortcut,IJ.getInstance());
+		switch (err) {
+			case Menus.COMMAND_IN_USE:
+				IJ.showMessage(TITLE, "The command \"" + command + "\" is already installed.");
+				break;
+			case Menus.INVALID_SHORTCUT:
+				IJ.showMessage(TITLE, "The shortcut must be a single character or F1-F24.");
+				break;
+			case Menus.SHORTCUT_IN_USE:
+				IJ.showMessage("The \""+shortcut+"\" shortcut is in use.");
+				break;
+			default:
+				shortcut = "";
+				break;
+		}
+	}
+	
+	void removeHotkey() {
+		String[] shortcuts = getShortcuts();
+		if (shortcuts==null) {
+			IJ.showMessage("Remove...", "No shortcuts found.");
+			return;
+		}
+		GenericDialog gd = new GenericDialog("Remove");
+		gd.addChoice("Shortcut:", shortcuts, "");
+		if (shortcuts.length>1)
+			gd.addCheckbox("Remove all "+shortcuts.length+" shortcuts", false);
+		gd.addMessage("Shortcuts are not removed\nuntil ImageJ is restarted.");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		command = gd.getNextChoice();
+		boolean removeAll = false;
+		if (shortcuts.length>1)
+			removeAll = gd.getNextBoolean();
+		if (removeAll) {
+			boolean ok = IJ.showMessageWithCancel("Remove", "Remove all "+shortcuts.length+" shortcuts?");
+			if (!ok)
+				return;
+			command = "";
+		} else {
+			shortcuts = new String[1];
+			shortcuts[0] = command;
+		}
+		int count = 0;
+		for (int i=0; i<shortcuts.length; i++) {
+			int err = Menus.uninstallPlugin(shortcuts[i]);
+			if (err==Menus.NORMAL_RETURN)
+				count++;
+		}
+		if (count==0)
+			IJ.showStatus("No shortcuts removed");
+		else
+			IJ.showStatus(count+" shortcut"+(count>1?"s":"")+" removed; ImageJ restart required");
+	}
+	
+	private void listCommands() {
+		String[] commands = getAllCommands();
+		Hashtable classes = Menus.getCommands();
+		ResultsTable rt = new ResultsTable();
+		for (int i=0; i<commands.length; i++) {
+			rt.incrementCounter();
+			rt.addValue("Command", commands[i]);
+			rt.addValue("Plugin", (String)classes.get(commands[i]));
+		}
+		rt.show("Commands");
+	}
+
+	String[] getAllCommands() {
+		Vector v = new Vector();
+		Hashtable commandTable = Menus.getCommands();
+		Hashtable shortcuts = Menus.getShortcuts();
+		for (Enumeration en=commandTable.keys(); en.hasMoreElements();) {
+			String cmd = (String)en.nextElement();
+			if (!cmd.startsWith("*") && !cmd.startsWith(" ") && cmd.length()<35 && !shortcuts.contains(cmd))
+				v.addElement(cmd);
+		}
+		String[] list = new String[v.size()];
+		v.copyInto((String[])list);
+		Arrays.sort(list, String.CASE_INSENSITIVE_ORDER);
+		return list;
+	}
+	
+	String[] getAvailableShortcuts() {
+		Vector v = new Vector();
+		String[] existingShortcuts = (new CommandLister()).getShortcuts();
+		for (char c = '0'; c<='9'; c++) {
+			String shortcut = ""+c;
+			if (!Menus.shortcutInUse(shortcut))
+				v.add(shortcut);
+		}
+		for (char c = 'a'; c<='z'; c++) {
+			String shortcut = ""+c;
+			if (!Menus.shortcutInUse(shortcut))
+				v.add(shortcut);
+		}
+		for (char c = 'A'; c<='Z'; c++) {
+			String shortcut = ""+c;
+			if (!Menus.shortcutInUse(shortcut))
+				v.add(shortcut);
+		}
+		for (int i = 1; i<=12; i++) {
+			String shortcut = "F"+i;
+			if (!Menus.shortcutInUse(shortcut))
+				v.add(shortcut);
+		}
+		String[] list = new String[v.size()];
+		v.copyInto((String[])list);
+		return list;
+	}
+
+	String[] getShortcuts() {
+		Vector v = new Vector();
+		Hashtable commandTable = Menus.getCommands();
+		for (Enumeration en=commandTable.keys(); en.hasMoreElements();) {
+			String cmd = (String)en.nextElement();
+			if (cmd.startsWith("*"))
+				v.addElement(cmd);
+		}
+		if (v.size()==0)
+			return null;
+		String[] list = new String[v.size()];
+		v.copyInto((String[])list);
+		Arrays.sort(list, String.CASE_INSENSITIVE_ORDER);
+		return list;
+	}
+	
+}
diff --git a/src/ij/plugin/HyperStackConverter.java b/src/ij/plugin/HyperStackConverter.java
new file mode 100644
index 0000000..c629f48
--- /dev/null
+++ b/src/ij/plugin/HyperStackConverter.java
@@ -0,0 +1,325 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import ij.macro.Interpreter;
+import ij.io.FileInfo;
+import ij.plugin.frame.Recorder;
+import java.awt.image.ColorModel;
+
+
+/** Implements the "Stack to HyperStack", "RGB to HyperStack" 
+	and "HyperStack to Stack" commands. */
+public class HyperStackConverter implements PlugIn {
+	public static final int CZT=0, CTZ=1, ZCT=2, ZTC=3, TCZ=4, TZC=5;
+	static final int C=0, Z=1, T=2;
+	static final String[] orders = {"xyczt(default)", "xyctz", "xyzct", "xyztc", "xytcz", "xytzc"};
+	static int ordering = CZT;
+	static boolean splitRGB = true;
+
+	public void run(String arg) {
+		if (arg.equals("new"))
+			{newHyperStack(); return;}
+		ImagePlus imp = IJ.getImage();
+    	if (arg.equals("stacktohs"))
+    		convertStackToHS(imp);
+    	else if (arg.equals("hstostack"))
+    		convertHSToStack(imp);
+	}
+	
+	/** Converts the specified stack into a hyperstack with 'c' channels, 'z' slices and
+		 't' frames using the default ordering ("xyczt") and display mode ("Composite"). */
+	public static ImagePlus toHyperStack(ImagePlus imp, int c, int z, int t) {
+		return toHyperStack(imp, c, z, t, null, null);
+	}
+
+	/** Converts the specified stack into a hyperstack with 'c' channels, 'z' slices and
+		 't' frames using the default ordering ("xyczt") and the specified display
+		 mode ("composite", "color" or "grayscale"). */
+	public static ImagePlus toHyperStack(ImagePlus imp, int c, int z, int t, String mode) {
+		return toHyperStack(imp, c, z, t, null, mode);
+	}
+
+	/** Converts the specified stack into a hyperstack with 'c' channels,
+	 *  'z' slices and 't' frames. The default "xyczt" order is used if
+	 * 'order' is null. The default "composite" display mode is used
+	 * if 'mode' is null.
+	 * @param imp the stack to be converted
+	 * @param c channels
+	 * @param z slices
+	 * @param t frames
+	 * @param order hyperstack order ("default", "xyctz", "xyzct", "xyztc", "xytcz" or "xytzc")
+	 * @param mode display mode ("composite", "color" or "grayscale")
+	 * @return the resulting hyperstack
+	*/
+	public static ImagePlus toHyperStack(ImagePlus imp, int c, int z, int t, String order, String mode) {
+		int n = imp.getStackSize();
+		if (n==1)
+			throw new IllegalArgumentException("Stack required");
+		if (imp.getBitDepth()==24 && mode.equalsIgnoreCase("composite"))
+			mode = "color";
+		if (c*z*t!=n)
+			throw new IllegalArgumentException("C*Z*T not equal stack size");
+		imp.setDimensions(c, z, t);
+		if (order==null || order.equals("default") || order.equals("xyczt"))
+			order = orders[0];
+		int intOrder = CZT;
+		for (int i=0; i<orders.length; i++) {
+			if (order.equals(orders[i])) {
+				intOrder = i;
+				break;
+			}
+		}
+		if (intOrder!=CZT && imp.getStack().isVirtual())
+			reorderVirtualStack(imp, intOrder);
+		else
+			(new HyperStackConverter()).shuffle(imp, intOrder);
+		ImagePlus imp2 = imp;
+		int intMode = IJ.COMPOSITE;
+		if (mode!=null) {
+			if (mode.equalsIgnoreCase("color"))
+				intMode = IJ.COLOR;
+			else if (mode.equalsIgnoreCase("grayscale"))
+				intMode = IJ.GRAYSCALE;
+		}
+		if (c>1) {
+			LUT[] luts = imp.getLuts();
+			if (luts!=null && luts.length<c)
+				luts = null;
+			imp2 = new CompositeImage(imp, intMode);
+			if (luts!=null)
+				((CompositeImage)imp2).setLuts(luts);
+		}
+		imp2.setOpenAsHyperStack(true);
+		imp2.setOverlay(imp.getOverlay());
+		return imp2;
+	}
+	
+	/** Converts the specified hyperstack into a stack. */
+	public static void toStack(ImagePlus imp) {
+		if (imp.isHyperStack()||imp.isComposite()) {
+			imp.setDimensions(1,imp.getStackSize(),1);
+			imp.draw();				
+		}
+	}
+	
+	private static void reorderVirtualStack(ImagePlus imp, int order) {
+		if (!(imp.getStack() instanceof VirtualStack))
+			return;
+		int[] indexes = shuffleVirtual(imp, order);
+		VirtualStack vstack = (VirtualStack)imp.getStack();
+		vstack.setIndexes(indexes);
+	}
+	
+	//String msg = "This is a custom VirtualStack. To switch to "+orders[order]+" order,\n"
+	//	+"save in TIFF format, import as a TIFF Virtual Stack and\n"
+	//	+"again use the \"Stack to Hyperstack\" command.";
+	
+	private static int[] shuffleVirtual(ImagePlus imp, int order) {
+		int n = imp.getStackSize();
+		int nChannels = imp.getNChannels();
+		int nSlices = imp.getNSlices();
+		int nFrames = imp.getNFrames();
+		int first=C, middle=Z, last=T;
+		int nFirst=nChannels, nMiddle=nSlices, nLast=nFrames;
+		switch (order) {
+			case CTZ: first=C; middle=T; last=Z;
+				nFirst=nChannels; nMiddle=nFrames; nLast=nSlices;
+				break;
+			case ZCT: first=Z; middle=C; last=T;
+				nFirst=nSlices; nMiddle=nChannels; nLast=nFrames;
+				break;
+			case ZTC: first=Z; middle=T; last=C;
+				nFirst=nSlices; nMiddle=nFrames; nLast=nChannels;
+				break;
+			case TCZ: first=T; middle=C; last=Z;
+				nFirst=nFrames; nMiddle=nChannels; nLast=nSlices;
+				break;
+			case TZC: first=T; middle=Z; last=C;
+				nFirst=nFrames; nMiddle=nSlices; nLast=nChannels;
+				break;
+		}
+		int[] indexes1 = new int[n];
+		int[] indexes2 = new int[n];
+		for (int i=0; i<n; i++) {
+			indexes1[i] = i;
+			indexes2[i] = i;
+		}
+		int[] index = new int[3];
+		for (index[2]=0; index[2]<nFrames; ++index[2]) {
+			for (index[1]=0; index[1]<nSlices; ++index[1]) {
+				for (index[0]=0; index[0]<nChannels; ++index[0]) {
+					int dstIndex = index[0] + index[1]*nChannels + index[2]*nChannels*nSlices;
+					int srcIndex = index[first] + index[middle]*nFirst + index[last]*nFirst*nMiddle;
+					indexes1[dstIndex] = indexes2[srcIndex];
+				}
+			}
+		}
+		return indexes1;
+	}
+		
+	/** Displays the specified stack in a HyperStack window. Based on the 
+		Stack_to_Image5D class in Joachim Walter's Image5D plugin. */
+	void convertStackToHS(ImagePlus imp) {
+        int nChannels = imp.getNChannels();
+        int nSlices = imp.getNSlices();
+        int nFrames = imp.getNFrames();
+		int stackSize = imp.getImageStackSize();
+		if (stackSize==1) {
+			IJ.error("Stack to HyperStack", "Stack required");
+			return;
+		}
+		boolean rgb = imp.getBitDepth()==24;
+		String[] modes = {"Composite", "Color", "Grayscale"};
+		GenericDialog gd = new GenericDialog("Convert to HyperStack");
+		gd.addChoice("Order:", orders, orders[ordering]);
+		gd.addNumericField("Channels (c):", nChannels, 0);
+		gd.addNumericField("Slices (z):", nSlices, 0);
+		gd.addNumericField("Frames (t):", nFrames, 0);
+		gd.addChoice("Display Mode:", modes, modes[1]);
+		if (rgb) {
+			gd.setInsets(15, 0, 0);
+			gd.addCheckbox("Convert RGB to 3 Channel Hyperstack", splitRGB);
+		}
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		ordering = gd.getNextChoiceIndex();
+		nChannels = (int) gd.getNextNumber();
+		nSlices = (int) gd.getNextNumber();
+		nFrames = (int) gd.getNextNumber();
+		int mode = gd.getNextChoiceIndex();
+		if (rgb)
+			splitRGB = gd.getNextBoolean();
+		if (rgb && splitRGB==true) {
+			new CompositeConverter().run(mode==0?"composite":"color");
+			return;
+		}
+		if (rgb && nChannels>1) {
+			IJ.error("HyperStack Converter", "RGB stacks are limited to one channel");
+			return;
+		}
+		if (nChannels*nSlices*nFrames!=stackSize) {
+			IJ.error("HyperStack Converter", "channels x slices x frames <> stack size");
+			return;
+		}
+		imp.setDimensions(nChannels, nSlices, nFrames);
+		if (ordering!=CZT && imp.getStack().isVirtual())
+			reorderVirtualStack(imp, ordering);
+		else
+			shuffle(imp, ordering);
+		ImagePlus imp2 = imp;
+		if (nChannels>1 && imp.getBitDepth()!=24) {
+			LUT[] luts = imp.getLuts();
+			if (luts!=null && luts.length<nChannels) luts = null;
+			imp2 = new CompositeImage(imp, mode+1);
+			if (luts!=null)
+				((CompositeImage)imp2).setLuts(luts);
+		} else if (imp.getClass().getName().indexOf("Image5D")!=-1) {
+			imp2 = imp.createImagePlus();
+			imp2.setStack(imp.getTitle(), imp.getImageStack());
+			imp2.setDimensions(imp.getNChannels(), imp.getNSlices(), imp.getNFrames());
+			imp2.getProcessor().resetMinAndMax();
+		}
+		imp2.setOpenAsHyperStack(true);
+		if (imp.getWindow()!=null || imp!=imp2) {
+			if (Interpreter.isBatchMode())
+				imp2.show();
+			else
+				new StackWindow(imp2);
+		}
+		if (imp!=imp2) {
+			imp2.setOverlay(imp.getOverlay());
+			imp.hide();
+			WindowManager.setCurrentWindow(imp2.getWindow());
+		}
+		if (Recorder.record && Recorder.scriptMode()) {
+			String order = orders[ordering];
+			if (order.equals(orders[0])) { // default order
+				Recorder.recordCall("imp2 = HyperStackConverter.toHyperStack(imp, "+nChannels+", "+
+					nSlices+", "+nFrames+", \""+modes[mode]+"\");");
+			} else {
+				Recorder.recordCall("imp2 = HyperStackConverter.toHyperStack(imp, "+nChannels+", "+
+					nSlices+", "+nFrames+", \""+order+"\", \""+modes[mode]+"\");");
+			}
+		}
+	}
+
+	/** Changes the dimension order of a 4D or 5D stack from 
+		the specified order (CTZ, ZCT, ZTC, TCZ or TZC) to 
+		the XYCZT order used by ImageJ. */
+	public void shuffle(ImagePlus imp, int order) {
+        int nChannels = imp.getNChannels();
+        int nSlices = imp.getNSlices();
+        int nFrames = imp.getNFrames();
+		int first=C, middle=Z, last=T;
+		int nFirst=nChannels, nMiddle=nSlices, nLast=nFrames;
+		switch (order) {
+			case CTZ: first=C; middle=T; last=Z;
+				nFirst=nChannels; nMiddle=nFrames; nLast=nSlices;
+				break;
+			case ZCT: first=Z; middle=C; last=T;
+				nFirst=nSlices; nMiddle=nChannels; nLast=nFrames;
+				break;
+			case ZTC: first=Z; middle=T; last=C;
+				nFirst=nSlices; nMiddle=nFrames; nLast=nChannels;
+				break;
+			case TCZ: first=T; middle=C; last=Z;
+				nFirst=nFrames; nMiddle=nChannels; nLast=nSlices;
+				break;
+			case TZC: first=T; middle=Z; last=C;
+				nFirst=nFrames; nMiddle=nSlices; nLast=nChannels;
+				break;
+		}
+		if (order!=CZT) {
+			ImageStack stack = imp.getImageStack();
+			Object[] images1 = stack.getImageArray();
+			Object[] images2 = new Object[images1.length];
+			System.arraycopy(images1, 0, images2, 0, images1.length);
+			String[] labels1 = stack.getSliceLabels();
+			String[] labels2 = new String[labels1.length];
+			System.arraycopy(labels1, 0, labels2, 0, labels1.length);
+			int[] index = new int[3];
+			for (index[2]=0; index[2]<nFrames; ++index[2]) {
+				for (index[1]=0; index[1]<nSlices; ++index[1]) {
+					for (index[0]=0; index[0]<nChannels; ++index[0]) {
+						int dstIndex = index[0] + index[1]*nChannels + index[2]*nChannels*nSlices;
+						int srcIndex = index[first] + index[middle]*nFirst + index[last]*nFirst*nMiddle;
+						images1[dstIndex] = images2[srcIndex];
+						labels1[dstIndex] = labels2[srcIndex];
+					}
+				}
+			}
+		}
+	}
+
+	void convertHSToStack(ImagePlus imp) {
+		if (!(imp.isHyperStack()||imp.isComposite()))
+			return;
+		ImagePlus imp2 = imp;
+		if (imp.isComposite()) {
+			ImageStack stack = imp.getStack();
+			imp2 = imp.createImagePlus();
+			imp2.setStack(imp.getTitle(), stack);
+			int[] dim = imp.getDimensions();
+			imp2.setDimensions(dim[2], dim[3], dim[4]);
+			ImageProcessor ip2 = imp2.getProcessor();
+			ip2.setColorModel(ip2.getDefaultColorModel());
+		}
+		imp2.setOpenAsHyperStack(false);
+		if (imp.getWindow()!=null || imp!=imp2)
+			new StackWindow(imp2);
+		if (imp!=imp2) {
+			imp2.setOverlay(imp.getOverlay());
+			imp.hide();
+		}
+		if (Recorder.record && Recorder.scriptMode())
+			Recorder.recordCall("HyperStackConverter.toStack(imp);");
+	}
+	
+	void newHyperStack() {
+		IJ.runMacroFile("ij.jar:HyperStackMaker", "");
+	}
+	
+}
+
diff --git a/src/ij/plugin/HyperStackMaker.java b/src/ij/plugin/HyperStackMaker.java
new file mode 100644
index 0000000..a5d6361
--- /dev/null
+++ b/src/ij/plugin/HyperStackMaker.java
@@ -0,0 +1,166 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.process.*;
+import java.awt.*;
+
+/** This plugin implements the File/New/Hyperstack command. */
+public class HyperStackMaker implements PlugIn {
+	private static String defaults = "8-bit Color 400 300 3 4 5 1";
+	private static String[] types = {"8-bit", "16-bit", "32-bit", "RGB"};
+	private static String[] modes = {"Composite", "Color", "Grayscale"};
+	private static String title = "HyperStack";
+	private String type, mode;
+	private int width, height, c, z, t;
+	private boolean label;
+
+	public void run(String arg) {
+		String defaults2 = Prefs.get("hyperstack.new", defaults);
+		if (Macro.getOptions()!=null)
+			defaults2 = defaults;
+		String[] prefs = Tools.split(defaults2);
+		if (prefs.length<8)
+			prefs = Tools.split(defaults);
+		type = prefs[0];
+		mode = prefs[1];
+		width = (int)Tools.parseDouble(prefs[2], 400);
+		height = (int)Tools.parseDouble(prefs[3], 300);
+		c = (int)Tools.parseDouble(prefs[4], 3);
+		z = (int)Tools.parseDouble(prefs[5], 4);
+		t = (int)Tools.parseDouble(prefs[6], 5);
+		int labelInt = (int)Tools.parseDouble(prefs[7], 1);
+		label = labelInt==1?true:false;
+		if (!showDialog())
+			return;
+		String type2 = type;
+		if (label)
+			type2 += " ramp label";
+		if (mode.equals("Composite"))
+			type2 += " composite";
+		else if (mode.equals("Color"))
+			type2 += " color";
+		else if (mode.equals("Grayscale"))
+			type2 += " grayscale";
+		ImagePlus imp = IJ.createImage(title, type2, width, height, c, z, t);
+		WindowManager.checkForDuplicateName = true;          
+		imp.show();
+		if (Macro.getOptions()==null) {
+			defaults2 = type+" "+mode+" "+width+" "+height+" "+c+" "+z+" "+t+" "+(label?"1":"0");
+			Prefs.set("hyperstack.new", defaults2);
+		}
+	}
+	
+	private boolean showDialog() {
+		String options = IJ.isMacro()?Macro.getOptions():null;
+		if (options!=null && options.contains("title="))
+			Macro.setOptions(options.replace("title=", "name="));
+		GenericDialog gd = new GenericDialog("New Hyperstack...");
+		gd.addStringField("Name:", title, 12);
+		gd.addChoice("Type:", types, type);
+		gd.addChoice("Display mode:", modes, mode);
+		gd.addNumericField("Width:", width, 0, 5, "pixels");
+		gd.addNumericField("Height:", height, 0, 5, "pixels");
+		gd.addNumericField("Channels (c):", c, 0, 5, "");
+		gd.addNumericField("Slices (z):", z, 0, 5, "");
+		gd.addNumericField("Frames (t):", t, 0, 5, "");
+		gd.addCheckbox("Label images", label);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		title = gd.getNextString();
+		type = gd.getNextChoice();
+		mode = gd.getNextChoice();
+		width = (int)gd.getNextNumber();
+		height = (int)gd.getNextNumber();
+		c = (int)gd.getNextNumber();
+		if (c<1) c=1;
+		z = (int)gd.getNextNumber();
+		if (z<1) z=1;
+		t = (int)gd.getNextNumber();
+		if (t<1) t=1;
+		label = gd.getNextBoolean();
+		if (width<1 || height<1) {
+			IJ.error("New Image", "Width and height must be >0");
+			return false;
+		} else
+			return true;
+	}
+	
+	public static void labelHyperstack(ImagePlus imp) {
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		int c = imp.getNChannels();
+		int z = imp.getNSlices();
+		int t = imp.getNFrames();
+		ImageStack stack = imp.getStack();
+		Overlay overlay = new Overlay();
+		int n = stack.size();
+		int channel=1, slice=1, frame=1;
+		boolean hyperstack = imp.isHyperStack();
+		for (int i=1; i<=n; i++) {
+			int yloc = 30;
+			IJ.showProgress(i, n);
+			ImageProcessor ip = stack.getProcessor(i);
+			ip.setAntialiasedText(true);
+			ip.setColor(Color.black);
+			ip.setRoi(0, 0, width, yloc);
+			ip.fill();
+			ip.setRoi(0, yloc+25, width, height-(yloc+25));
+			ip.fill();
+			
+			ip.setColor(Color.white);
+			Font font = new Font("SansSerif",Font.PLAIN,24);
+			ip.setFont(font);
+			String text = "c="+IJ.pad(channel,3)+", z="+IJ.pad(slice,3)+", t="+IJ.pad(frame,3)+", i="+IJ.pad(i,4);
+			if (!hyperstack)
+				text = IJ.pad(i,4);
+			TextRoi roi = new TextRoi(5, yloc-28, text, font);
+			roi.setStrokeColor(Color.white);
+			if (hyperstack || c>1)
+				roi.setPosition(channel, slice, frame);
+			else
+				roi.setPosition(i);
+			overlay.add(roi);
+			ip.drawString(text, 5, yloc+27);
+			
+			// embed channel, slice, frame and stack index into pixel data
+			yloc += 30;;
+			int size = 20;
+			ip.setValue(channel); ip.setRoi(size,yloc,size,size); ip.fill();
+			ip.setColor(Color.white); ip.drawRect(size,yloc,size,size);
+			ip.setValue(slice); ip.setRoi(size*3,yloc,size,size); ip.fill();
+			ip.setColor(Color.white); ip.drawRect(size*3,yloc,size,size);
+			ip.setValue(frame); ip.setRoi(size*5,yloc,size,size); ip.fill();
+			ip.setColor(Color.white); ip.drawRect(size*5,yloc,size,size);
+			ip.setValue(i); ip.setRoi(size*7,yloc,size,size); ip.fill();
+			ip.setColor(Color.white); ip.drawRect(size*7,yloc,size,size);
+			
+			yloc = 90;
+			if (i==1 && hyperstack) {
+				String msg = "Press shift-z (Image>Color>Channels Tool)\n"+
+					"to open the \"Channels\" window, which will\n"+
+					"allow you switch to composite color mode\n"+
+					"and to enable/disable channels.\n";
+				font = new Font("SansSerif", Font.PLAIN, imp.getWidth()>399?14:12);
+				roi = new TextRoi(25, yloc, msg, font);
+				roi.setStrokeColor(Color.white);
+				roi.setPosition(0, 1, 1);
+				overlay.add(roi);
+			}
+			channel++;
+			if (channel>c) {
+				channel = 1;
+				slice++;
+				if (slice>z) {
+					slice = 1;
+					frame++;
+					if (frame>t) frame = 1;
+				}
+			}
+		}
+		imp.setOverlay(overlay);
+	}
+
+}
+
diff --git a/src/ij/plugin/HyperStackReducer.java b/src/ij/plugin/HyperStackReducer.java
new file mode 100644
index 0000000..ea12156
--- /dev/null
+++ b/src/ij/plugin/HyperStackReducer.java
@@ -0,0 +1,192 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.util.Vector;
+
+/** Implements the Image/HyperStacks/Reduce Dimensionality command. */
+public class HyperStackReducer implements PlugIn, DialogListener {
+	ImagePlus imp;
+	int channels1, slices1, frames1;
+	int channels2, slices2, frames2;
+	double imageSize;
+	static boolean keep = true;
+	
+	/** Default constructor */
+	public HyperStackReducer() {
+	}
+
+	/** Constructs a HyperStackReducer using the specified source image. */
+	public HyperStackReducer(ImagePlus imp) {
+		this.imp = imp;
+	}
+
+	public void run(String arg) {
+		//IJ.log("HyperStackReducer-1");
+		imp = IJ.getImage();
+		if (!imp.isHyperStack() && imp.getNChannels()==1) {
+			IJ.error("Reducer", "HyperStack required");
+			return;
+		}
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		imageSize = width*height*imp.getBytesPerPixel()/(1024.0*1024.0);
+		channels1 = channels2 = imp.getNChannels();
+		slices1 = slices2 = imp.getNSlices();
+		frames1 = frames2 = imp.getNFrames();
+		int z0 = imp.getSlice();
+		int t0 = imp.getFrame();
+		if (!showDialog())
+			return;
+		//IJ.log("HyperStackReducer-2: "+keep+" "+channels2+" "+slices2+" "+frames2);
+		String title2 = keep?WindowManager.getUniqueName(imp.getTitle()):imp.getTitle();
+		ImagePlus imp2 = null;
+		if (keep) {
+			imp2 = IJ.createImage(title2, imp.getBitDepth()+"-bit", width, height, channels2*slices2*frames2);
+			if (imp2==null) return;
+			imp2.setDimensions(channels2, slices2, frames2);
+			imp2.setCalibration(imp.getCalibration());
+			imp2.setOpenAsHyperStack(true);
+		} else
+			imp2 = imp.createHyperStack(title2, channels2, slices2, frames2, imp.getBitDepth());
+		imp2.setProperty("Info", (String)imp.getProperty("Info"));		
+		imp2.setProperties(imp.getPropertiesAsArray());
+		reduce(imp2);
+		if (channels2>1 && channels2==imp.getNChannels() && imp.isComposite()) {
+			int mode = ((CompositeImage)imp).getMode();
+			imp2 = new CompositeImage(imp2, mode);
+			((CompositeImage)imp2).copyLuts(imp);
+		} else {
+			imp2.setDisplayRange(imp.getDisplayRangeMin(), imp.getDisplayRangeMax());
+			if (imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.GRAYSCALE)
+				IJ.run(imp2, "Grays", "");
+		}
+		if (imp.getWindow()==null && !keep) {
+			imp.setImage(imp2);
+			return;
+		}
+		imp2.show();
+		if (z0>1 || t0>1)
+			imp2.setPosition(1, z0, t0);
+		//IJ.log("HyperStackReducer-4");
+		if (!keep) {
+			imp.changes = false;
+			imp.close();
+		}
+	}
+
+	public void reduce(ImagePlus imp2) {
+		int channels = imp2.getNChannels();
+		int slices = imp2.getNSlices();
+		int frames = imp2.getNFrames();
+		int c1 = imp.getChannel();
+		int z1 = imp.getSlice();
+		int t1 = imp.getFrame();
+		int i = 1;
+		int n = channels*slices*frames;
+		ImageStack stack = imp.getStack();
+		ImageStack stack2 = imp2.getStack();
+		for (int c=1; c<=channels; c++) {
+			if (channels==1) c = c1;
+			LUT lut = imp.isComposite()?((CompositeImage)imp).getChannelLut():imp.getProcessor().getLut();
+			imp.setPositionWithoutUpdate(c, 1, 1);
+			ImageProcessor ip = imp.getProcessor();
+			double min = ip.getMin();
+			double max = ip.getMax();
+			for (int z=1; z<=slices; z++) {
+				if (slices==1) z = z1;
+				for (int t=1; t<=frames; t++) {
+					if (frames==1) t = t1;
+					int n1 = imp.getStackIndex(c, z, t);
+					ip = stack.getProcessor(n1);
+					String label = stack.getSliceLabel(n1);
+					int n2 = imp2.getStackIndex(c, z, t);
+					if (stack2.getPixels(n2)!=null)
+						stack2.getProcessor(n2).insert(ip, 0, 0);
+					else
+						stack2.setPixels(ip.getPixels(), n2);
+					stack2.setSliceLabel(label, n2);
+				}
+			}
+			if (lut!=null) {
+				if (imp2.isComposite())
+					((CompositeImage)imp2).setChannelLut(lut);
+				else
+					imp2.getProcessor().setColorModel(lut);
+			}
+			imp2.getProcessor().setMinAndMax(min, max);
+		}
+		imp.setPosition(c1, z1, t1);
+		imp2.resetStack();
+		imp2.setPosition(1, 1, 1);
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null && !imp.getHideOverlay())
+			imp2.setOverlay(reduce(overlay));
+	}
+
+	//Added by Marcel Boeglin 2013.11.29
+	/** Returns a copy of 'overlay', limited to the dimensions of the reduced image. */
+	private Overlay reduce(Overlay overlay) {
+		int c1 = imp.getChannel();
+		int z1 = imp.getSlice();
+		int t1 = imp.getFrame();
+		Overlay overlay2 = overlay.duplicate();
+		if (channels2==1 && slices2==slices1 && frames2==frames1)
+			overlay2.crop(c1, c1, 1, slices1, 1, frames1);
+		else if (channels2==channels1 && slices2==1 && frames2==frames1)
+			overlay2.crop(1, channels1, z1, z1, 1, frames1);
+		else if (channels2==channels1 && slices2==slices1 && frames2==1)
+			overlay2.crop(1, channels1, 1, slices1, t1, t1);
+		else if (channels2==channels1 && slices2==1 && frames2==1)
+			overlay2.crop(1, channels1, z1, z1, t1, t1);
+		else if (channels2==1 && slices2==slices1 && frames2==1)
+			overlay2.crop(c1, c1, 1, slices1, t1, t1);
+		else if (channels2==1 && slices2==1 && frames2==frames1)
+			overlay2.crop(c1, c1, z1, z1, 1, frames1);
+		else if (channels2==1 && slices2==1 && frames2==1)
+			overlay2.crop(c1, c1, z1, z1, t1, t1);
+		return overlay2;
+	}
+    
+    boolean showDialog() {
+		GenericDialog gd = new GenericDialog("Reduce");
+		gd.setInsets(10, 20, 5);
+		gd.addMessage("Create image with:");
+		gd.setInsets(0, 35, 0);
+		if (channels1!=1) gd.addCheckbox("Channels ("+channels1+")", true);
+		gd.setInsets(0, 35, 0);
+		if (slices1!=1) gd.addCheckbox("Slices ("+slices1+")", true);
+		gd.setInsets(0, 35, 0);
+		if (frames1!=1) gd.addCheckbox("Frames ("+frames1+")", true);
+		gd.setInsets(5, 20, 0);
+		gd.addMessage(getNewDimensions()+"      ");
+		gd.setInsets(15, 20, 0);
+		gd.addCheckbox("Keep source", keep);
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		else
+			return true;
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (IJ.isMacOSX()) IJ.wait(100);
+		if (channels1!=1) channels2 = gd.getNextBoolean()?channels1:1;
+		if (slices1!=1) slices2 = gd.getNextBoolean()?slices1:1;
+		if (frames1!=1) frames2 = gd.getNextBoolean()?frames1:1;
+		keep = gd.getNextBoolean();
+		if (imp!=null && imp.getWindow()!=null)
+			((Label)gd.getMessage()).setText(getNewDimensions());
+		return true;
+	}
+
+	String getNewDimensions() {
+		String s = channels2+"x"+slices2+"x"+frames2;
+		s += " ("+(int)Math.round(imageSize*channels2*slices2*frames2)+"MB)";
+		return(s);
+	}
+
+}
diff --git a/src/ij/plugin/ImageCalculator.java b/src/ij/plugin/ImageCalculator.java
new file mode 100644
index 0000000..255a094
--- /dev/null
+++ b/src/ij/plugin/ImageCalculator.java
@@ -0,0 +1,349 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.filter.*;
+import ij.measure.Calibration;
+import ij.plugin.frame.Recorder;
+import ij.macro.Interpreter;
+
+/** This plugin implements the Process/Image Calculator command.
+<pre>
+   // test script
+   imp1 = IJ.openImage("http://imagej.nih.gov/ij/images/boats.gif")
+   imp2 = IJ.openImage("http://imagej.nih.gov/ij/images/bridge.gif")
+   imp3 = ImageCalculator.run(imp1, imp2, "add create 32-bit");
+   imp3.show();
+</pre>
+*/
+public class ImageCalculator implements PlugIn {
+
+	private static String[] operators = {"Add","Subtract","Multiply","Divide", "AND", "OR", "XOR", "Min", "Max", "Average", "Difference", "Copy", "Transparent-zero"};
+	private static String[] lcOperators = {"add","sub","mul","div", "and", "or", "xor", "min", "max", "ave", "diff", "copy", "zero"};
+	private static int operator;
+	private static String title1 = "";
+	private static String title2 = "";
+	private static boolean createWindow = true;
+	private static boolean floatResult;
+	private boolean processStack;
+	private boolean macroCall;
+	
+	public void run(String arg) {
+		int[] wList = WindowManager.getIDList();
+		if (wList==null) {
+			IJ.noImage();
+			return;
+		}
+		IJ.register(ImageCalculator.class);
+		String[] titles = new String[wList.length];
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp = WindowManager.getImage(wList[i]);
+			if (imp!=null)
+				titles[i] = imp.getTitle();
+			else
+				titles[i] = "";
+		}
+		GenericDialog gd = new GenericDialog("Image Calculator");
+		String defaultItem;
+		if (title1.equals(""))
+			defaultItem = titles[0];
+		else
+			defaultItem = title1;
+		gd.addChoice("Image1:", titles, defaultItem);
+		gd.addChoice("Operation:", operators, operators[operator]);
+		if (title2.equals(""))
+			defaultItem = titles[0];
+		else
+			defaultItem = title2;
+		gd.addChoice("Image2:", titles, defaultItem);
+		//gd.addStringField("Result:", "Result", 10);
+		gd.addCheckbox("Create new window", createWindow);
+		gd.addCheckbox("32-bit (float) result", floatResult);
+		gd.addHelp(IJ.URL+"/docs/menus/process.html#calculator");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		int index1 = gd.getNextChoiceIndex();
+		title1 = titles[index1];
+		operator = gd.getNextChoiceIndex();
+		int index2 = gd.getNextChoiceIndex();
+		//String resultTitle = gd.getNextString();
+		createWindow = gd.getNextBoolean();
+		floatResult = gd.getNextBoolean();		
+		title2 = titles[index2];
+		ImagePlus img1 = WindowManager.getImage(wList[index1]);
+		ImagePlus img2 = WindowManager.getImage(wList[index2]);
+		ImagePlus img3 = calculate(img1, img2, false);
+		if (img3!=null) img3.show();
+	}
+	
+	/** Performs arithmetic options on two images and returns the result,
+		where  'operation' ("add","subtract", "multiply","divide", "and", 
+		"or", "xor", "min", "max", "average", "difference" or "copy")
+		specifies the operation. If 'operation' does not contain 'create'
+		or '32-bit', the result is also saved in 'imp1" and null is returned
+		if "imp1" is displayed. The 'operation' argument can include up
+		to three modifiers: "create" (e.g., "add create") causes the result
+		to be returned as a new image, "32-bit" causes the result to 
+		be returned as 32-bit floating-point image and "stack" causes
+		the entire stack to be processed. As an example,
+		<pre>
+		imp3 = ImageCalculator.run(imp1, imp2, "divide create 32-bit");
+		</pre>
+		divides 'imp1' by 'imp2' and returns the result as a new 32-bit image.
+	*/
+	public static ImagePlus run(ImagePlus img1, ImagePlus img2, String operation) {
+		ImageCalculator ic = new ImageCalculator();
+		return ic.run(operation, img1, img2);
+	}
+
+	public ImagePlus run(String operation, ImagePlus img1, ImagePlus img2) {
+		if (img1==null || img2==null || operation==null) return null;
+		operator = getOperator(operation);
+		if (operator==-1)
+			throw new IllegalArgumentException("No valid operator");
+		createWindow = operation.indexOf("create")!=-1;
+		floatResult= operation.indexOf("32")!=-1 || operation.indexOf("float")!=-1;
+		processStack = operation.indexOf("stack")!=-1;
+		return calculate(img1, img2, true);
+	}
+	
+	/**
+	* @deprecated
+	* replaced by run(String,ImagePlus,ImagePlus)
+	*/
+	public void calculate(String operation, ImagePlus img1, ImagePlus img2) {
+		if (img1==null || img2==null || operation==null) return;
+		operator = getOperator(operation);
+		if (operator==-1)
+			{IJ.error("Image Calculator", "No valid operator"); return;}
+		createWindow = operation.indexOf("create")!=-1;
+		floatResult = operation.indexOf("32")!=-1 || operation.indexOf("float")!=-1;
+		processStack = operation.indexOf("stack")!=-1;
+		macroCall = true;
+		ImagePlus img3 = calculate(img1, img2, true);
+		if (img3!=null) img3.show();
+	}
+	
+	int getOperator(String options) {
+		options = options.toLowerCase();
+		int op= -1;
+		if  (options.indexOf("xor")!=-1)
+			op = 6;
+		if (op==-1) {
+			for (int i=0; i<lcOperators.length; i++) {
+				if (options.indexOf(lcOperators[i])!=-1) {
+					op = i;
+					break;
+				}
+			}
+		}
+		return op;
+	}
+		
+	ImagePlus calculate(ImagePlus img1, ImagePlus img2, boolean apiCall) {
+		ImagePlus img3 = null;
+		if (img1.getCalibration().isSigned16Bit() || img2.getCalibration().isSigned16Bit())
+			floatResult = true;
+		if (floatResult && !(img1.getBitDepth()==32&&img2.getBitDepth()==32))
+			createWindow = true;
+		int size1 = img1.getStackSize();
+		int size2 = img2.getStackSize();
+		if (apiCall) {
+			if (processStack && (size1>1||size2>1))
+				img3 = doStackOperation(img1, img2);
+			else
+				img3 = doOperation(img1, img2);
+			if (img3==null && !macroCall && (img1.getWindow()==null))
+				img3 = img1;
+			return img3;
+		}
+		boolean stackOp = false;
+		if (size1>1) {
+			int result = IJ.setupDialog(img1, PlugInFilter.NO_CHANGES);
+			if (result==PlugInFilter.DONE)
+				return null;
+			processStack = (result&PlugInFilter.DOES_STACKS)!=0;
+			if (processStack) {
+				if (img1.getStack().isVirtual())
+					createWindow = true;
+				img3 = doStackOperation(img1, img2);
+				stackOp = true;
+			} else
+				img3 = doOperation(img1, img2);
+		} else
+			img3 = doOperation(img1, img2);
+		if (Recorder.record) {
+			String options = operators[operator];
+			if (createWindow) options += " create";
+			if (floatResult) options += " 32-bit";
+			if (stackOp) options += " stack";
+			if (Recorder.scriptMode()) {
+				Recorder.recordCall("ImagePlus", "imp1 = WindowManager.getImage(\""+img1.getTitle()+"\");");
+				Recorder.recordCall("ImagePlus", "imp2 = WindowManager.getImage(\""+img2.getTitle()+"\");");
+				Recorder.recordCall("ImagePlus", "imp3 = ImageCalculator.run(imp1, imp2, \""+options+"\");");
+				Recorder.recordCall("imp3.show();");
+			} else
+				Recorder.record("imageCalculator", options, img1.getTitle(), img2.getTitle());
+			Recorder.setCommand(null); // don't record run(...)
+		}
+		return img3;
+	}
+
+	/** img1 = img2 op img2 (e.g. img1 = img2/img1) */
+	ImagePlus doStackOperation(ImagePlus img1, ImagePlus img2) {
+		ImagePlus img3 = null;
+		int size1 = img1.getStackSize();
+		int size2 = img2.getStackSize();
+		if (size1>1 && size2>1 && size1!=size2) {
+			IJ.error("Image Calculator", "'Image1' and 'image2' must be stacks with the same\nnumber of slices, or 'image2' must be a single image.");
+			return null;
+		}
+		if (createWindow) {
+			img1 = duplicateStack(img1);
+			if (img1==null) {
+				IJ.error("Calculator", "Out of memory");
+				return null;
+			}
+			img3 = img1;
+		}
+		int mode = getBlitterMode();
+		ImageWindow win = img1.getWindow();
+		if (win!=null)
+			WindowManager.setCurrentWindow(win);
+		else if (Interpreter.isBatchMode() && !createWindow && WindowManager.getImage(img1.getID())!=null)
+			IJ.selectWindow(img1.getID());
+		Undo.reset();
+		ImageStack stack1 = img1.getStack();
+		StackProcessor sp = new StackProcessor(stack1, img1.getProcessor());
+		try {
+			if (size2==1)
+				sp.copyBits(img2.getProcessor(), 0, 0, mode);
+			else
+				sp.copyBits(img2.getStack(), 0, 0, mode);
+		}
+		catch (IllegalArgumentException e) {
+			IJ.error("\""+img1.getTitle()+"\": "+e.getMessage());
+			return null;
+		}
+		img1.setStack(null, stack1);
+		if (img1.getType()!=ImagePlus.GRAY8) {
+			img1.getProcessor().resetMinAndMax();
+		}
+		if (img3==null)
+			img1.updateAndDraw();
+		return img3;
+	}
+
+	ImagePlus doOperation(ImagePlus img1, ImagePlus img2) {
+		ImagePlus img3 = null;
+		int mode = getBlitterMode();
+		ImageProcessor ip1 = img1.getProcessor();
+		ImageProcessor ip2 = img2.getProcessor();
+		Calibration cal1 = img1.getCalibration();
+		Calibration cal2 = img2.getCalibration();
+		if (createWindow)
+			ip1 = createNewImage(ip1, ip2);
+		else {
+			ImageWindow win = img1.getWindow();
+			if (win!=null)
+				WindowManager.setCurrentWindow(win);
+			else if (Interpreter.isBatchMode() && !createWindow && WindowManager.getImage(img1.getID())!=null)
+				IJ.selectWindow(img1.getID());
+			ip1.snapshot();
+			Undo.setup(Undo.FILTER, img1);
+		}
+		boolean rgb = ip2 instanceof ColorProcessor;
+		if (floatResult && !rgb)
+			ip2 = ip2.convertToFloat();
+		try {
+  			ip1.copyBits(ip2, 0, 0, mode);
+		}
+		catch (IllegalArgumentException e) {
+			IJ.error("\""+img1.getTitle()+"\": "+e.getMessage());
+			return null;
+		}
+		if (floatResult && rgb)
+			ip1 = ip1.convertToFloat();
+		if (!(ip1 instanceof ByteProcessor))
+			ip1.resetMinAndMax();
+		if (createWindow) {
+			img3 = new ImagePlus("Result of "+img1.getTitle(), ip1);
+			img3.setCalibration(cal1);
+		} else
+			img1.updateAndDraw();
+		return img3;
+	}
+
+	ImageProcessor createNewImage(ImageProcessor ip1, ImageProcessor ip2) {
+		int width = Math.min(ip1.getWidth(), ip2.getWidth());
+		int height = Math.min(ip1.getHeight(), ip2.getHeight());
+		ImageProcessor ip3 = ip1.createProcessor(width, height);
+		if (floatResult && !(ip1 instanceof ColorProcessor)) {
+			ip1 = ip1.convertToFloat();
+			ip3 = ip3.convertToFloat();
+		}
+		ip3.insert(ip1, 0, 0);
+		return ip3;
+	}
+
+	private int getBlitterMode() {
+		int mode=0;
+		switch (operator) {
+			case 0: mode = Blitter.ADD; break;
+			case 1: mode = Blitter.SUBTRACT; break;
+			case 2: mode = Blitter.MULTIPLY; break;
+			case 3: mode = Blitter.DIVIDE; break;
+			case 4: mode = Blitter.AND; break;
+			case 5: mode = Blitter.OR; break;
+			case 6: mode = Blitter.XOR; break;
+			case 7: mode = Blitter.MIN; break;
+			case 8: mode = Blitter.MAX; break;
+			case 9: mode = Blitter.AVERAGE; break;
+			case 10: mode = Blitter.DIFFERENCE; break;
+			case 11: mode = Blitter.COPY; break;
+			case 12: mode = Blitter.COPY_ZERO_TRANSPARENT; break;
+		}
+		return mode;
+	}
+	
+	ImagePlus duplicateStack(ImagePlus img1) {
+		Calibration cal = img1.getCalibration();
+		ImageStack stack1 = img1.getStack();
+		int width = stack1.getWidth();
+		int height = stack1.getHeight();
+		int n = stack1.getSize();
+		ImageStack stack2 = img1.createEmptyStack();
+		try {
+			for (int i=1; i<=n; i++) {
+				ImageProcessor ip1 = stack1.getProcessor(i);
+				ip1.resetRoi(); 
+				ImageProcessor ip2 = ip1.crop();
+				if (floatResult) {
+					ip2.setCalibrationTable(cal.getCTable());
+					ip2 = ip2.convertToFloat();
+				} 
+				stack2.addSlice(stack1.getSliceLabel(i), ip2);
+			}
+		}
+		catch(OutOfMemoryError e) {
+			stack2.trim();
+			stack2 = null;
+			return null;
+		}
+		ImagePlus img3 = new ImagePlus("Result of "+img1.getTitle(), stack2);
+		img3.setCalibration(cal);
+		if (img3.getStackSize()==n) {
+			int[] dim = img1.getDimensions();
+			img3.setDimensions(dim[2], dim[3], dim[4]);
+			if (img1.isComposite()) {
+				img3 = new CompositeImage(img3, 0);
+				((CompositeImage)img3).copyLuts(img1);
+			}
+			if (img1.isHyperStack())
+				img3.setOpenAsHyperStack(true);
+		}
+		return img3;
+	}
+	
+}
diff --git a/src/ij/plugin/ImageInfo.java b/src/ij/plugin/ImageInfo.java
new file mode 100644
index 0000000..09d3c72
--- /dev/null
+++ b/src/ij/plugin/ImageInfo.java
@@ -0,0 +1,526 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.io.*;
+import ij.util.Tools;
+import ij.plugin.frame.Editor;
+import ij.plugin.filter.Analyzer;
+import ij.text.TextWindow;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.util.*;
+import java.lang.reflect.*;
+import java.awt.geom.Rectangle2D;
+
+/** This plugin implements the Image/Show Info command. */
+public class ImageInfo implements PlugIn {
+
+	public void run(String arg) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			showInfo();
+		else {
+			String info = getImageInfo(imp);
+			if (info.contains("----"))
+				showInfo(imp, info, 450, 600);
+			else {
+				int inc = info.contains("No selection")?0:130;
+				showInfo(imp, info, 400, 500+inc);
+			}
+		}
+	}
+
+	private void showInfo() {
+		String s = new String("");
+		if (IJ.getInstance()!=null)
+			s += IJ.getInstance().getInfo()+"\n \n";
+		s += "No images are open\n";
+		Dimension screen = IJ.getScreenSize();
+		s += "ImageJ home: "+IJ.getDir("imagej")+"\n";
+		s += "Java home: "+System.getProperty("java.home")+"\n";
+		s += "Java version: "+IJ.javaVersion()+"\n";
+		s += "Screen size: "+screen.width+"x"+screen.height+"\n";
+		s += "GUI scale: "+IJ.d2s(Prefs.getGuiScale(),2)+"\n";
+		//s += "Active window: "+WindowManager.getActiveWindow()+"\n";
+		String path = Prefs.getCustomPropsPath();
+		if (path!=null)
+			s += "*Custom properties*: "+ path +"\n";
+		path = Prefs.getCustomPrefsPath();
+		if (path!=null)
+			s += "*Custom preferences*: "+ path +"\n";
+		//if (IJ.isMacOSX()) {
+		//	String time = " ("+ImageWindow.setMenuBarTime+"ms)";
+		//	s += "SetMenuBarCount: "+Menus.setMenuBarCount+time+"\n";
+		//}
+		new TextWindow("Info", s, 600, 300);
+	}
+
+	public String getImageInfo(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		String infoProperty = null;
+		if (imp.getStackSize()>1) {
+			ImageStack stack = imp.getStack();
+			String label = stack.getSliceLabel(imp.getCurrentSlice());
+			if (label!=null && label.indexOf('\n')>0)
+				infoProperty = label;
+		}
+		if (infoProperty==null) {
+			infoProperty = (String)imp.getProperty("Info");
+			if (infoProperty==null)
+				infoProperty = getExifData(imp);
+		}
+		if (imp.getProp("HideInfo")==null) {
+			String properties = getImageProperties(imp);
+			if (properties!=null) {
+				if (infoProperty!=null)
+					infoProperty = properties + "\n" + infoProperty;
+				else
+					infoProperty = properties;
+			}
+		}
+		String info = getInfo(imp, ip);
+		if (infoProperty!=null)
+			return infoProperty + "--------------------------------------------\n" + info;
+		else
+			return info;
+	}
+
+	public String getExifData(ImagePlus imp) {
+		FileInfo fi = imp.getOriginalFileInfo();
+		if (fi==null)
+			return null;
+		String directory = fi.directory;
+		String name = fi.fileName;
+		if (directory==null)
+			return null;
+		if ((name==null||name.equals("")) && imp.getStack().isVirtual())
+			name = imp.getStack().getSliceLabel(imp.getCurrentSlice());
+		if (name==null || !(name.endsWith("jpg")||name.endsWith("JPG")))
+			return null;
+		String path = directory + name;
+		String metadata = null;
+		try {
+			Class c = IJ.getClassLoader().loadClass("Exif_Reader");
+			if (c==null) return null;
+			String methodName = "getMetadata";
+			Class[] argClasses = new Class[1];
+			argClasses[0] = methodName.getClass();
+			Method m = c.getMethod("getMetadata", argClasses);
+			Object[] args = new Object[1];
+			args[0] = path;
+			Object obj = m.invoke(null, args);
+			metadata = obj!=null?obj.toString():null;
+		} catch(Exception e) {
+			return null;
+		}
+		if (metadata!=null && !metadata.startsWith("Error:"))
+			return metadata;
+		else
+			return null;
+	}
+
+	private String getInfo(ImagePlus imp, ImageProcessor ip) {
+		String s = new String("");
+		if (IJ.getInstance()!=null)
+			s += IJ.getInstance().getInfo()+"\n \n";
+		s += "Title: " + imp.getTitle() + "\n";
+		Calibration cal = imp.getCalibration();
+    	int stackSize = imp.getStackSize();
+    	int channels = imp.getNChannels();
+    	int slices = imp.getNSlices();
+    	int frames = imp.getNFrames();
+		int digits = imp.getBitDepth()==32?4:0;
+		int dp, dp2;
+		boolean nonUniformUnits = !cal.getXUnit().equals(cal.getYUnit());
+		String xunit = cal.getXUnit();
+		String yunit = cal.getYUnit();
+		String zunit = cal.getZUnit();
+		if (cal.scaled()) {
+			String xunits = cal.getUnits();
+			String yunits = xunits;
+			String zunits = xunits;
+			if (nonUniformUnits) {
+				xunits = xunit;
+				yunits = yunit;
+				zunits = zunit;
+			}
+			double pw = imp.getWidth()*cal.pixelWidth;
+			double ph = imp.getHeight()*cal.pixelHeight;
+	    	s += "Width:  "+d2s(pw)+" " + xunits+" ("+imp.getWidth()+")\n";
+	    	s += "Height:  "+d2s(ph)+" " + yunits+" ("+imp.getHeight()+")\n";
+	    	if (slices>1) {
+				double pd = slices*cal.pixelDepth;
+	    		s += "Depth:  "+d2s(pd)+" " + zunits+" ("+slices+")\n";
+	    	}
+			s += "Size:  "+ImageWindow.getImageSize(imp)+"\n";
+	    	double xResolution = 1.0/cal.pixelWidth;
+	    	double yResolution = 1.0/cal.pixelHeight;
+	    	if (xResolution==yResolution)
+	    		s += "Resolution:  "+d2s(xResolution) + " pixels per "+xunit+"\n";
+	    	else {
+	    		s += "X Resolution:  "+d2s(xResolution) + " pixels per "+xunit+"\n";
+	    		s += "Y Resolution:  "+d2s(yResolution) + " pixels per "+yunit+"\n";
+	    	}
+	    } else {
+	    	s += "Width:  " + imp.getWidth() + " pixels\n";
+	    	s += "Height:  " + imp.getHeight() + " pixels\n";
+	    	if (stackSize>1)
+	    		s += "Depth:  " + slices + " pixels\n";
+			s += "Size:  "+ImageWindow.getImageSize(imp)+"\n";
+	    }
+    	if (stackSize>1) {
+    		String vunit = cal.getUnit()+"^3";
+    		if (nonUniformUnits)
+    			vunit = "("+xunit+" x "+yunit+" x "+zunit+")";
+	    	s += "Voxel size: "+d2s(cal.pixelWidth)+"x"+d2s(cal.pixelHeight)+"x"+d2s(cal.pixelDepth)+" "+vunit+"\n";
+	    } else {
+    		String punit = cal.getUnit()+"^2";
+    		if (nonUniformUnits)
+    			punit = "("+xunit+" x "+yunit+")";
+	    	dp = Tools.getDecimalPlaces(cal.pixelWidth, cal.pixelHeight);
+	    	s += "Pixel size: "+d2s(cal.pixelWidth)+"x"+d2s(cal.pixelHeight)+" "+punit+"\n";
+	    }
+
+	    s += "ID: "+imp.getID()+"\n";
+	    int type = imp.getType();
+    	switch (type) {
+	    	case ImagePlus.GRAY8:
+	    		s += "Bits per pixel: 8 ";
+	    		String lut = "LUT";
+	    		if (imp.getProcessor().isColorLut())
+	    			lut = "color " + lut;
+	    		else
+	    			lut = "grayscale " + lut;
+	    		if (imp.isInvertedLut())
+	    			lut = "inverting " + lut;
+				s += "(" + lut + ")\n";
+				if (imp.getNChannels()>1)
+					s += displayRanges(imp);
+				else
+					s += "Display range: "+(int)ip.getMin()+"-"+(int)ip.getMax()+"\n";
+				break;
+	    	case ImagePlus.GRAY16: case ImagePlus.GRAY32:
+	    		if (type==ImagePlus.GRAY16) {
+	    			String sign = cal.isSigned16Bit()?"signed":"unsigned";
+	    			s += "Bits per pixel: 16 ("+sign+")\n";
+	    		} else
+	    			s += "Bits per pixel: 32 (float)\n";
+				if (imp.getNChannels()>1)
+					s += displayRanges(imp);
+				else {
+					s += "Display range: ";
+					double min = ip.getMin();
+					double max = ip.getMax();
+					if (cal.calibrated()) {
+						min = cal.getCValue((int)min);
+						max = cal.getCValue((int)max);
+					}
+					s += d2s(min) + " - " + d2s(max) + "\n";
+				}
+				break;
+	    	case ImagePlus.COLOR_256:
+	    		s += "Bits per pixel: 8 (color LUT)\n";
+	    		break;
+	    	case ImagePlus.COLOR_RGB:
+	    		s += "Bits per pixel: 32 (RGB)\n";
+	    		break;
+    	}
+    	String lutName = imp.getProp(LUT.nameKey);
+    	if (lutName!=null)
+			s += "LUT name: "+lutName+"\n";    		
+		double interval = cal.frameInterval;
+		double fps = cal.fps;
+    	if (stackSize>1) {
+    		ImageStack stack = imp.getStack();
+    		int slice = imp.getCurrentSlice();
+    		String number = slice + "/" + stackSize;
+    		String label = stack.getSliceLabel(slice);
+    		if (label!=null && label.contains("\n"))
+    			label = stack.getShortSliceLabel(slice);
+    		if (label!=null && label.length()>0)
+    			label = " (" + label + ")";
+    		else
+    			label = "";
+			if (interval>0.0 || fps!=0.0) {
+				s += "Frame: " + number + label + "\n";
+				if (fps!=0.0) {
+					String sRate = Math.abs(fps-Math.round(fps))<0.00001?IJ.d2s(fps,0):IJ.d2s(fps,5);
+					s += "Frame rate: " + sRate + " fps\n";
+				}
+				if (interval!=0.0)
+					s += "Frame interval: " + ((int)interval==interval?IJ.d2s(interval,0):IJ.d2s(interval,5)) + " " + cal.getTimeUnit() + "\n";
+			} else
+				s += "Image: " + number + label + "\n";
+			if (imp.isHyperStack()) {
+				if (channels>1)
+					s += "  Channel: " + imp.getChannel() + "/" + channels + "\n";
+				if (slices>1)
+					s += "  Slice: " + imp.getSlice() + "/" + slices + "\n";
+				if (frames>1)
+					s += "  Frame: " + imp.getFrame() + "/" + frames + "\n";
+			}
+			if (imp.isComposite()) {
+				if (!imp.isHyperStack() && channels>1)
+					s += "  Channels: " + channels + "\n";
+				String mode = ((CompositeImage)imp).getModeAsString();
+				s += "  Composite mode: \"" + mode + "\"\n";
+			}
+			if (stack.isVirtual()) {
+				String stackType = "virtual";
+				if (stack instanceof AVI_Reader)
+					stackType += " (AVI Reader)";
+				if (stack instanceof FileInfoVirtualStack)
+					stackType += " (FileInfoVirtualStack)";
+				if (stack instanceof ListVirtualStack)
+					stackType += " (ListVirtualStack)";
+				s += "Stack type: " + stackType+ "\n";
+			}
+		} else if (imp.isStack()) { // one image stack
+    		String label = imp.getStack().getShortSliceLabel(1);
+    		if (label!=null && label.length()>0)
+				s += "Image: 1/1 (" + label + ")\n";
+		}
+
+		if (imp.isLocked())
+			s += "**Locked**\n";
+		if (ip.getMinThreshold()==ImageProcessor.NO_THRESHOLD)
+			s += "No threshold\n";
+	    else {
+	    	double lower = ip.getMinThreshold();
+	    	double upper = ip.getMaxThreshold();
+	    	String uncalibrated = "";
+			if (cal.calibrated()) {
+				uncalibrated = " ("+(int)lower+"-"+(int)upper+")";
+				lower = cal.getCValue((int)lower);
+				upper = cal.getCValue((int)upper);
+			}
+			int lutMode = ip.getLutUpdateMode();
+			String mode = "red";
+			switch (lutMode) {
+				case ImageProcessor.BLACK_AND_WHITE_LUT: mode="B&W"; break;
+				case ImageProcessor.NO_LUT_UPDATE: mode="invisible"; break;
+				case ImageProcessor.OVER_UNDER_LUT: mode="over/under"; break;
+			}
+			s += "Threshold: "+d2s(lower)+"-"+d2s(upper)+uncalibrated+" ("+mode+")\n";
+		}
+		ImageCanvas ic = imp.getCanvas();
+    	double mag = ic!=null?ic.getMagnification():1.0;
+    	if (mag!=1.0)
+			s += "Magnification: " + IJ.d2s(mag,2) + "\n";
+		if (ic!=null)
+			s += "ScaleToFit: " + ic.getScaleToFit() + "\n";
+
+
+	    String valueUnit = cal.getValueUnit();
+	    if (cal.calibrated()) {
+	    	s += " \n";
+	    	int curveFit = cal.getFunction();
+			s += "Calibration function: ";
+			if (curveFit==Calibration.UNCALIBRATED_OD)
+				s += "Uncalibrated OD\n";
+			else if (curveFit==Calibration.CUSTOM)
+				s += "Custom lookup table\n";
+			else
+				s += CurveFitter.fList[curveFit]+"\n";
+			double[] c = cal.getCoefficients();
+			if (c!=null) {
+				s += "  a: "+IJ.d2s(c[0],6)+"\n";
+				s += "  b: "+IJ.d2s(c[1],6)+"\n";
+				if (c.length>=3)
+					s += "  c: "+IJ.d2s(c[2],6)+"\n";
+				if (c.length>=4)
+					s += "  c: "+IJ.d2s(c[3],6)+"\n";
+				if (c.length>=5)
+					s += "  c: "+IJ.d2s(c[4],6)+"\n";
+			}
+			s += "  Unit: \""+valueUnit+"\"\n";
+	    } else if (valueUnit!=null && !valueUnit.equals("Gray Value")) {
+			s += "Calibration function: None\n";
+			s += "  Unit: \""+valueUnit+"\"\n";
+	    } else
+	    	s += "Uncalibrated\n";
+
+	    FileInfo fi = imp.getOriginalFileInfo();
+		if (fi!=null) {
+			if (fi.url!=null && !fi.url.equals(""))
+				s += "URL: " + fi.url + "\n";
+			else {
+				String defaultDir = (fi.directory==null || fi.directory.length()==0)?System.getProperty("user.dir"):"";
+				if (defaultDir.length()>0) {
+					defaultDir = defaultDir.replaceAll("\\\\", "/");
+					defaultDir += "/";
+				}
+				s += "Path: " + defaultDir + fi.getFilePath() + "\n";
+			}
+		}
+
+		ImageWindow win = imp.getWindow();
+		if (win!=null) {
+			Point loc = win.getLocation();
+			Rectangle bounds = GUI.getScreenBounds(win);
+			s += "Screen location: "+(loc.x-bounds.x)+","+(loc.y-bounds.y)+" ("+bounds.width+"x"+bounds.height+")\n";
+		}
+		if (IJ.isMacOSX()) {
+			String time = " ("+ImageWindow.setMenuBarTime+"ms)";
+			s += "SetMenuBarCount: "+Menus.setMenuBarCount+time+"\n";
+		}
+
+		String zOrigin = stackSize>1||cal.zOrigin!=0.0?","+d2s(cal.zOrigin):"";
+		String origin = d2s(cal.xOrigin)+","+d2s(cal.yOrigin)+zOrigin;
+		if (!origin.equals("0,0") || cal.getInvertY())
+	    	s += "Coordinate origin:  "+origin+"\n";
+	    if (cal.getInvertY())
+	    	s += "Inverted y coordinates\n";
+
+	    String pinfo = imp.getPropsInfo();
+	    if (!pinfo.equals("0"))
+	   		s += "Properties: " + pinfo + "\n";
+	   	else
+	   		s += "No properties\n";
+	   	
+	    Overlay overlay = imp.getOverlay();
+		if (overlay!=null) {
+			int n = overlay.size();
+			String elements = n==1?" element":" elements";
+			String selectable = overlay.isSelectable()?" selectable ":" non-selectable ";
+			String hidden = imp.getHideOverlay()?" (hidden)":"";
+			s += "Overlay: " + n + selectable + elements + hidden + "\n";
+		} else
+	    	s += "No overlay\n";
+
+		Interpreter interp = Interpreter.getInstance();
+		if (interp!=null)
+			s += "Macro is running"+(Interpreter.isBatchMode()?" in batch mode":"")+"\n";
+
+	    Roi roi = imp.getRoi();
+	    if (roi == null) {
+			if (cal.calibrated())
+	    		s += " \n";
+	    	s += "No selection\n";
+	    } else if (roi instanceof RotatedRectRoi) {
+	    	s += "\nRotated rectangle selection\n";
+	    	double[] p = ((RotatedRectRoi)roi).getParams();
+			double dx = p[2] - p[0];
+			double dy = p[3] - p[1];
+			double major = Math.sqrt(dx*dx+dy*dy);
+			s += "  Length: " + IJ.d2s(major,2) + "\n";
+			s += "  Width: " + IJ.d2s(p[4],2) + "\n";
+			s += "  X1: " + IJ.d2s(p[0],2) + "\n";
+			s += "  Y1: " + IJ.d2s(p[1],2) + "\n";
+			s += "  X2: " + IJ.d2s(p[2],2) + "\n";
+			s += "  Y2: " + IJ.d2s(p[3],2) + "\n";
+	    } else if (roi instanceof EllipseRoi) {
+	    	s += "\nElliptical selection\n";
+	    	double[] p = ((EllipseRoi)roi).getParams();
+			double dx = p[2] - p[0];
+			double dy = p[3] - p[1];
+			double major = Math.sqrt(dx*dx+dy*dy);
+			s += "  Major: " + IJ.d2s(major,2) + "\n";
+			s += "  Minor: " + IJ.d2s(major*p[4],2) + "\n";
+			s += "  X1: " + IJ.d2s(p[0],2) + "\n";
+			s += "  Y1: " + IJ.d2s(p[1],2) + "\n";
+			s += "  X2: " + IJ.d2s(p[2],2) + "\n";
+			s += "  Y2: " + IJ.d2s(p[3],2) + "\n";
+			s += "  Aspect ratio: " + IJ.d2s(p[4],2) + "\n";
+	    } else {
+	    	s += " \n";
+	    	s += roi.getTypeAsString()+" Selection";
+	    	String points = null;
+			if (roi instanceof PointRoi) {
+				int npoints = ((PolygonRoi)roi).getNCoordinates();
+				String suffix = npoints>1?"s)":")";
+				points = " (" + npoints + " point" + suffix;
+			}
+    		String name = roi.getName();
+    		if (name!=null) {
+				s += " (\"" + name + "\")";
+				if (points!=null) s += "\n " + points;
+			} else if (points!=null)
+				s += points;
+			s += "\n";
+	    	if (roi instanceof Line) {
+	    		Line line = (Line)roi;
+	    		s += "  X1: " + IJ.d2s(cal.getX(line.x1d)) + "\n";
+	    		s += "  Y1: " + IJ.d2s(cal.getY(line.y1d, imp.getHeight())) + "\n";
+	    		s += "  X2: " + IJ.d2s(cal.getX(line.x2d)) + "\n";
+	    		s += "  Y2: " + IJ.d2s(cal.getY(line.y2d, imp.getHeight())) + "\n";
+			} else {
+				Rectangle2D.Double r = roi.getFloatBounds();
+				int decimals = r.x==(int)r.x && r.y==(int)r.y && r.width==(int)r.width && r.height==(int)r.height ?
+						0 : 2;
+				if (cal.scaled()) {
+					s += "  X: " + IJ.d2s(cal.getX(r.x)) + " (" + IJ.d2s(r.x, decimals) + ")\n";
+					s += "  Y: " + IJ.d2s(cal.getY(r.y,imp.getHeight())) + " (" +  IJ.d2s(yy(r.y, imp), decimals) + ")\n";
+					s += "  Width: " + IJ.d2s(r.width*cal.pixelWidth) + " (" +  IJ.d2s(r.width, decimals) + ")\n";
+					s += "  Height: " + IJ.d2s(r.height*cal.pixelHeight) + " (" +  IJ.d2s(r.height, decimals) + ")\n";
+				} else {
+					s += "  X: " + IJ.d2s(r.x, decimals) + "\n";
+					s += "  Y: " + IJ.d2s(yy(r.y, imp), decimals) + "\n";
+					s += "  Width: " + IJ.d2s(r.width, decimals) + "\n";
+					s += "  Height: " + IJ.d2s(r.height, decimals) + "\n";
+				}
+			}
+	    }
+
+		return s;
+	}
+
+	private String displayRanges(ImagePlus imp) {
+		LUT[] luts = imp.getLuts();
+		if (luts==null)
+			return "";
+		String s = "Display ranges\n";
+		int n = luts.length;
+		if (n>7) n=7;
+		for (int i=0; i<n; i++) {
+			double min = luts[i].min;
+			double max = luts[i].max;
+			s += "  " + (i+1) + ": " + d2s(min) + "-" + d2s(max) + "\n";
+		}
+		return s;
+	}
+
+	// returns a Y coordinate based on the "Invert Y Coodinates" flag
+	private int yy(int y, ImagePlus imp) {
+		return Analyzer.updateY(y, imp.getHeight());
+	}
+
+	// returns a Y coordinate based on the "Invert Y Coodinates" flag
+	private double yy(double y, ImagePlus imp) {
+		return Analyzer.updateY(y, imp.getHeight());
+	}
+
+	private void showInfo(ImagePlus imp, String info, int width, int height) {
+		new TextWindow("Info for "+imp.getTitle(), info, width, height);
+		//Editor ed = new Editor();
+		//ed.setSize(width, height);
+		//ed.create("Info for "+imp.getTitle(), info);
+	}
+
+    private String d2s(double n) {
+		return IJ.d2s(n,Tools.getDecimalPlaces(n));
+    }
+    
+    private String getImageProperties(ImagePlus imp) {
+    	String s = "";
+    	String[] props = imp.getPropertiesAsArray();
+    	if (props==null)
+    		return null;
+		for (int i=0; i<props.length; i+=2) {
+			String key = props[i];
+			String value = props[i+1];
+			if (LUT.nameKey.equals(key) || "UniqueName".equals(key))
+				continue;
+			if (key!=null && value!=null && !(key.equals("ShowInfo")||key.equals("Slice_Label"))) {
+				if (value.length()<80)
+					s += key + ": " + value + "\n";
+				else
+					s += key + ": <" + value.length() + " characters>\n";
+			}
+		}
+		return  (s.length()>0)?s:null;
+    }
+
+}
diff --git a/src/ij/plugin/ImageJ_Updater.java b/src/ij/plugin/ImageJ_Updater.java
new file mode 100644
index 0000000..0f7280f
--- /dev/null
+++ b/src/ij/plugin/ImageJ_Updater.java
@@ -0,0 +1,192 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.util.Tools;
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.lang.reflect.*;
+
+
+/** This plugin implements the Help/Update ImageJ command. */
+public class ImageJ_Updater implements PlugIn {
+	private static final String URL = "http://wsr.imagej.net";
+	private String notes;
+
+	public void run(String arg) {
+		if (arg.equals("menus")) {
+			updateMenus();
+			return;
+		}
+		if (IJ.getApplet()!=null)
+			return;
+		URL url = getClass().getResource("/ij/IJ.class");
+		String ij_jar = url == null ? null : url.toString().replaceAll("%20", " ");
+		if (ij_jar==null || !ij_jar.startsWith("jar:file:")) {
+			error("Could not determine location of ij.jar");
+			return;
+		}
+		int exclamation = ij_jar.indexOf('!');
+		ij_jar = ij_jar.substring(9, exclamation);
+		if (IJ.debugMode) IJ.log("Updater (jar loc): "+ij_jar);
+		File file = new File(ij_jar);
+		if (!file.exists()) {
+			error("File not found: "+file.getPath());
+			return;
+		}
+		if (!file.canWrite()) {
+			String path = file.getPath();
+			String msg = "No write access: "+path;
+			if (IJ.isMacOSX() && path!=null && path.startsWith("/private/var/folders/")) {
+				msg = "ImageJ is in a read-only folder due to Path Randomization.\n"
+				+ "To work around this problem, drag ImageJ.app to another\n"
+				+ "folder and then (optionally) drag it back.";
+			}
+			error(msg);
+			return;
+		}
+		String[] list = openUrlAsList(URL+"/jars/list.txt");
+		if (list==null || list.length==0) {
+			error("Error opening "+URL+"/jars/list.txt");
+			return;
+		}
+		int count = list.length + 2;
+		String[] versions = new String[count];
+		String[] urls = new String[count];
+		versions[0] = list[0];
+		urls[0] = URL+"/jars/ij.jar";
+		for (int i=1; i<count-2; i++) {
+			String version = list[i];
+			versions[i] = version.substring(0,version.length()-1); // remove letter
+			urls[i] = URL+"/jars/ij"+version.substring(1,2)+version.substring(3,6)+".jar";
+		}
+		versions[count-2] = "daily build";
+		urls[count-2] = URL+"/download/daily-build/ij.jar";
+		versions[count-1] = "previous";
+		urls[count-1] = URL+"/jars/ij2.jar";
+		//for (int i=0; i<count; i++)
+		//	IJ.log(i+" "+versions[i]+"  "+urls[i]);
+		int choice = showDialog(versions);
+		if (choice==-1 || !Commands.closeAll())
+			return;
+		byte[] jar = null;
+		jar = getJar(urls[choice]);
+		if (jar==null) {
+			error("Unable to download ij.jar from "+urls[choice]);
+			return;
+		}
+		Prefs.savePreferences();
+		saveJar(file, jar);
+		if (choice<count-2) // force macro Function Finder to download fresh list
+			new File(IJ.getDirectory("macros")+"functions.html").delete();
+		System.exit(0);
+	}
+
+	int showDialog(String[] versions) {
+		GenericDialog gd = new GenericDialog("ImageJ Updater");
+		gd.addChoice("Upgrade To:", versions, versions[0]);
+		String msg = 
+			"You are currently running v"+ImageJ.VERSION+ImageJ.BUILD+".\n"+
+			" \n"+
+			"If you click \"OK\", ImageJ will quit\n"+
+			"and you will be running the upgraded\n"+
+			"version after you restart ImageJ.\n";
+		gd.addMessage(msg);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return -1;
+		else
+			return gd.getNextChoiceIndex();
+	}
+
+	String openUrlAsString(String address, int maxLines) {
+		StringBuffer sb;
+		try {
+			URL url = new URL(address);
+			InputStream in = url.openStream();
+			BufferedReader br = new BufferedReader(new InputStreamReader(in));
+			sb = new StringBuffer();
+			int count = 0;
+			String line;
+			while ((line=br.readLine())!=null && count++<maxLines)
+				sb.append (line + "\n");
+			in.close ();
+		} catch (IOException e) {sb = null;}
+			return sb!=null?new String(sb):null;
+	}
+
+	byte[] getJar(String address) {
+		byte[] data;
+		try {
+			URL url = new URL(address);
+			IJ.showStatus("Connecting to "+IJ.URL);
+			URLConnection uc = url.openConnection();
+			int len = uc.getContentLength();
+			if (IJ.debugMode) IJ.log("Updater (url): "+ address + " "+ len);
+			if (len<=0)
+				return null;
+			String name = address.contains("daily")?"daily build (":"ij.jar (";
+			IJ.showStatus("Downloading "+ name + IJ.d2s((double)len/1048576,1)+"MB)");
+			InputStream in = uc.getInputStream();
+			data = new byte[len];
+			int n = 0;
+			while (n < len) {
+				int count = in.read(data, n, len - n);
+				if (count<0)
+					throw new EOFException();
+	   			 n += count;
+				IJ.showProgress(n, len);
+			}
+			in.close();
+		} catch (IOException e) {
+			if (IJ.debugMode) IJ.log(""+e);
+			return null;
+		}
+		if (IJ.debugMode) IJ.wait(6000);
+		return data;
+	}
+
+	void saveJar(File f, byte[] data) {
+		try {
+			FileOutputStream out = new FileOutputStream(f);
+			out.write(data, 0, data.length);
+			out.close();
+		} catch (IOException e) {
+		}
+	}
+
+	String[] openUrlAsList(String address) {
+		IJ.showStatus("Connecting to "+IJ.URL);
+		Vector v = new Vector();
+		try {
+			URL url = new URL(address);
+			InputStream in = url.openStream();
+			BufferedReader br = new BufferedReader(new InputStreamReader(in));
+			String line;
+			while (true) {
+				line = br.readLine();
+				if (line==null) break;
+				if (!line.equals("")) v.addElement(line);
+			}
+			br.close();
+		} catch(Exception e) { }
+		String[] lines = new String[v.size()];
+		v.copyInto((String[])lines);
+		IJ.showStatus("");
+		return lines;
+	}
+
+	void error(String msg) {
+		IJ.error("ImageJ Updater", msg);
+	}
+	
+	void updateMenus() {
+		if (IJ.debugMode) {
+			long start = System.currentTimeMillis();
+			Menus.updateImageJMenus();
+			IJ.log("Refresh Menus: "+(System.currentTimeMillis()-start)+" ms");
+		} else
+			Menus.updateImageJMenus();
+	}
+
+}
diff --git a/src/ij/plugin/ImagesToStack.java b/src/ij/plugin/ImagesToStack.java
new file mode 100644
index 0000000..ec0f372
--- /dev/null
+++ b/src/ij/plugin/ImagesToStack.java
@@ -0,0 +1,295 @@
+package ij.plugin;
+import ij.plugin.frame.Recorder;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import ij.macro.Interpreter;
+import ij.io.FileInfo;
+import java.awt.Color;
+
+
+/** Implements the Image/Stacks/Images to Stack" command. */
+public class ImagesToStack implements PlugIn {
+	private static final int rgb = 33;
+	private static final int COPY_CENTER=0, COPY_TOP_LEFT=1, SCALE_SMALL=2, SCALE_LARGE=3;
+	private static final String[] methods = {"Copy (center)", "Copy (top-left)", "Scale (smallest)", "Scale (largest)"};
+	private static int staticMethod = COPY_CENTER;
+	private static boolean staticBicubic;
+	private static boolean staticKeep;
+	private static boolean staticTitlesAsLabels = true;
+	private int method = COPY_CENTER;
+	private boolean bicubic;
+	private boolean keep;
+	private boolean titlesAsLabels = true;
+	private String filter;
+	private int width, height;
+	private int maxWidth, maxHeight;
+	private int minWidth, minHeight;
+	private int minSize, maxSize;
+	private boolean allInvertedLuts;
+	private Calibration cal2;
+	private int stackType;
+	private ImagePlus[] images;
+	private String name = "Stack";
+	private Color fillColor;
+	
+	/** Converts the images in 'images' to a stack, using the 
+		default settings ("copy center" and "titles as labels"). */
+	public static ImagePlus run(ImagePlus[] images) {
+		ImagesToStack itos = new ImagesToStack();
+		int count = itos.findMinMaxSize(images, images.length);
+		return itos.convert(images, count);
+	}
+
+	public void run(String arg) {
+		convertImagesToStack();
+	}
+
+	public void convertImagesToStack() {
+		boolean scale = false;
+		int[] wList = WindowManager.getIDList();
+		if (wList==null) {
+			IJ.error("No images are open.");
+			return;
+		}
+
+		int count = 0;
+		int stackCount = 0;
+		images = new ImagePlus[wList.length];
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp = WindowManager.getImage(wList[i]);
+			if (imp.getStackSize()==1)
+				images[count++] = imp;
+			else
+				stackCount++;
+		}		
+		if (count<2) {
+			String msg = "";
+			if (stackCount>1)
+				msg = "\n \nUse the Image>Stacks>Tools>Concatenate\ncommand to combine stacks.";
+			IJ.error("Images to Stack", "There must be at least two open 2D images."+msg);
+			return;
+		}
+
+		filter = null;
+		count = findMinMaxSize(images, count);
+		boolean sizesDiffer = width!=minWidth||height!=minHeight;
+		boolean showDialog = true;
+		String macroOptions = Macro.getOptions();
+		if (IJ.macroRunning() && macroOptions==null) {
+			if (sizesDiffer) {
+				IJ.error("Images are not all the same size");
+				return;
+			} 
+			showDialog = false;
+		}
+		if (showDialog) {
+			GenericDialog gd = new GenericDialog("Images to Stack");
+			if (sizesDiffer) {
+				String msg = "The "+count+" images differ in size (smallest="+minWidth+"x"+minHeight
+				+",\nlargest="+maxWidth+"x"+maxHeight+"). They will be converted\nto a stack using the specified method.";
+				gd.setInsets(0,0,5);
+				gd.addMessage(msg);
+				gd.addChoice("Method:", methods, methods[staticMethod]);
+			}
+			gd.setSmartRecording(true);
+			gd.addStringField("Name:", name, 12);
+			gd.addStringField("Title contains:", "", 12);
+			gd.addStringField("Fill color:", "", 12);
+			if (sizesDiffer)
+				gd.addCheckbox("Bicubic interpolation", staticBicubic);
+			gd.addCheckbox("Use titles as labels", staticTitlesAsLabels);
+			gd.addCheckbox("Keep source images", staticKeep);
+			gd.showDialog();
+			if (gd.wasCanceled()) return;
+			if (sizesDiffer)
+				method = gd.getNextChoiceIndex();
+			name = gd.getNextString();
+			filter = gd.getNextString();
+			String fillc = gd.getNextString();
+			fillColor = Colors.decode(fillc, null);
+			if (sizesDiffer)
+				bicubic = gd.getNextBoolean();
+			titlesAsLabels = gd.getNextBoolean();
+			keep = gd.getNextBoolean();
+			if (filter!=null && (filter.equals("") || filter.equals("*")))
+				filter = null;
+			if (filter!=null) {
+				count = findMinMaxSize(images, count);
+				if (count==0) {
+					IJ.error("Images to Stack", "None of the images have a title containing \""+filter+"\"");
+				}
+			}
+			if (!IJ.isMacro()) {
+				staticMethod = method;
+				staticBicubic = bicubic;
+				staticKeep = keep;
+				staticTitlesAsLabels = titlesAsLabels;
+			}
+			if (Recorder.record)
+   				Recorder.recordCall("imp = ImagesToStack.run(arrayOfImages);");
+		} else
+			keep = false;
+		if (method==SCALE_SMALL) {
+			width = minWidth;
+			height = minHeight;
+		} else if (method==SCALE_LARGE) {
+			width = maxWidth;
+			height = maxHeight;
+		}
+		ImagePlus stack = convert(images, count);
+		if (stack!=null)
+			stack.show();
+	}
+	
+	private ImagePlus convert(ImagePlus[] images, int count) {		
+		double min = Double.MAX_VALUE;
+		double max = -Double.MAX_VALUE;
+		ImageStack stack = new ImageStack(width, height);
+		FileInfo fi = images[0].getOriginalFileInfo();
+		if (fi!=null && fi.directory==null) fi = null;
+		Overlay overlay = new Overlay();
+		for (int i=0; i<count; i++) {
+			ImageProcessor ip = images[i].getProcessor();
+			boolean invertedLut = ip.isInvertedLut();
+			if (ip.getMin()<min) min = ip.getMin();
+			if (ip.getMax()>max) max = ip.getMax();
+			String label = titlesAsLabels?images[i].getTitle():null;
+			if (label==null)
+				label = images[i].getProp("Slice_Label");
+			if (label!=null) {
+				String info = (String)images[i].getProperty("Info");
+				if (info!=null) label += "\n" + info;
+			}
+			if (fi!=null) {
+				FileInfo fi2 = images[i].getOriginalFileInfo();
+				if (fi2!=null && !fi.directory.equals(fi2.directory))
+					fi = null;
+			}
+			switch (stackType) {
+				case 16: ip = ip.convertToShort(false); break;
+				case 32: ip = ip.convertToFloat(); break;
+				case rgb: ip = ip.convertToRGB(); break;
+				default: break;
+			}
+			if (invertedLut && !allInvertedLuts) {
+				if (keep)
+					ip = ip.duplicate();
+				ip.invert();
+			}
+			if (ip.getWidth()!=width||ip.getHeight()!=height) {
+				switch (method) {
+					case COPY_TOP_LEFT: case COPY_CENTER:
+						ImageProcessor ip2 = null;
+						switch (stackType) {
+							case 8: ip2 = new ByteProcessor(width, height); break;
+							case 16: ip2 = new ShortProcessor(width, height); break;
+							case 32: ip2 = new FloatProcessor(width, height); break;
+							case rgb: ip2 = new ColorProcessor(width, height); break;
+						}
+						if (fillColor!=null) {
+							ip2.setColor(fillColor);
+							ip2.fill();
+						}							
+						int xoff=0, yoff=0;
+						if (method==COPY_CENTER) {
+							xoff = (width-ip.getWidth())/2;
+							yoff = (height-ip.getHeight())/2;
+						}
+						ip2.insert(ip, xoff, yoff);
+						ip = ip2;
+						break;
+					case SCALE_SMALL: case SCALE_LARGE:
+						ip.setInterpolationMethod((bicubic?ImageProcessor.BICUBIC:ImageProcessor.BILINEAR));
+						ip.resetRoi();
+						ip = ip.resize(width, height);
+						break;
+				}
+			} else {
+				if (keep)
+					ip = ip.duplicate();
+				Overlay overlay2 = images[i].getOverlay();
+				if (overlay2!=null) {
+					for (int j=0; j<overlay2.size(); j++) {
+						Roi roi = overlay2.get(j);
+						roi.setPosition(i+1);
+						overlay.add((Roi)roi.clone());
+					}
+				}
+			}
+			stack.addSlice(label, ip);
+			if (i==0 && invertedLut && !allInvertedLuts)
+				stack.setColorModel(null);
+			if (!keep) {
+				images[i].changes = false;
+				images[i].close();
+			}
+		}
+		if (stack.size()==0)
+			return null;
+		ImagePlus imp = new ImagePlus(name, stack);
+		if (stackType==16 || stackType==32)
+			imp.getProcessor().setMinAndMax(min, max);
+		if (cal2!=null)
+			imp.setCalibration(cal2);
+		if (fi!=null) {
+			fi.fileName = "";
+			fi.nImages = imp.getStackSize();
+			imp.setFileInfo(fi);
+		}
+		if (overlay.size()>0)
+			imp.setOverlay(overlay);
+		return imp;
+	}
+	
+	private int findMinMaxSize(ImagePlus[] images, int count) {
+		int index = 0;
+		stackType = 8;
+		width = 0;
+		height = 0;
+		cal2 = images[0].getCalibration();
+		maxWidth = 0;
+		maxHeight = 0;
+		minWidth = Integer.MAX_VALUE;
+		minHeight = Integer.MAX_VALUE;
+		minSize = Integer.MAX_VALUE;
+		allInvertedLuts = true;
+		maxSize = 0;
+		for (int i=0; i<count; i++) {
+			if (exclude(images[i].getTitle())) continue;
+			if (images[i].getType()==ImagePlus.COLOR_256)
+				stackType = rgb;
+			if (!images[i].getProcessor().isInvertedLut())
+				allInvertedLuts = false;
+			int type = images[i].getBitDepth();
+			if (type==24) type = rgb;
+			if (type>stackType) stackType = type;
+			int w=images[i].getWidth(), h=images[i].getHeight();
+			if (w>width) width = w;
+			if (h>height) height = h;
+			int size = w*h;
+			if (size<minSize) {
+				minSize = size;
+				minWidth = w;
+				minHeight = h;
+			}
+			if (size>maxSize) {
+				maxSize = size;
+				maxWidth = w;
+				maxHeight = h;
+			}
+			Calibration cal = images[i].getCalibration();
+			if (!images[i].getCalibration().equals(cal2))
+				cal2 = null;
+			images[index++] = images[i];
+		}
+		return index;
+	}
+
+	final boolean exclude(String title) {
+		return filter!=null && title!=null && title.indexOf(filter)==-1;
+	}
+	
+}
+
diff --git a/src/ij/plugin/JavaProperties.java b/src/ij/plugin/JavaProperties.java
new file mode 100644
index 0000000..f627dd0
--- /dev/null
+++ b/src/ij/plugin/JavaProperties.java
@@ -0,0 +1,190 @@
+package ij.plugin;
+import ij.*;
+import ij.text.*;
+import ij.io.OpenDialog;
+import ij.gui.GUI;
+import java.awt.*;
+import java.util.*;
+import java.applet.Applet;
+
+/** Displays the Java system properties in a text window. */
+public class JavaProperties implements PlugIn {
+
+	ArrayList list = new ArrayList();
+	
+	public void run(String arg) {
+		show("java.version");
+		show("java.vendor");
+		if (IJ.isMacintosh()) show("mrj.version");
+		show("os.name");
+		show("os.version");
+		show("os.arch");
+		show("file.separator");
+		show("path.separator");
+		
+		String s = System.getProperty("line.separator");
+		char ch1, ch2;
+		String str1, str2="";
+		ch1 = s.charAt(0);
+		if (ch1=='\r')
+			str1 = "<cr>";
+		else
+			str1 = "<lf>";
+		if (s.length()==2) {
+			ch2 = s.charAt(1);
+			if (ch2=='\r')
+				str2 = "<cr>";
+			else
+				str2 = "<lf>";
+		}
+		list.add("  line.separator: " + str1 + str2);
+			
+		Applet applet = IJ.getApplet();
+		if (applet!=null) {
+			list.add("");
+			list.add("  code base: "+applet.getCodeBase());
+			list.add("  document base: "+applet.getDocumentBase());
+			list.add("  sample images dir: "+Prefs.getImagesURL());
+			TextWindow tw = new TextWindow("Properties", "", list, 400, 400);
+			return;
+		}
+		list.add("");
+		show("user.name");
+		show("user.home");
+		show("user.dir");
+		show("user.country");
+		show("file.encoding");
+		show("java.home");
+		show("java.compiler");
+		show("java.class.path");
+		show("java.ext.dirs");
+		show("java.io.tmpdir");
+		
+		list.add("");
+		String userDir = System.getProperty("user.dir");
+		String userHome = System.getProperty("user.home");
+		String osName = System.getProperty("os.name");
+		String path = Prefs.getCustomPropsPath();
+		if (path!=null)
+			list.add("  *Custom properties*: "+path);
+		path = Prefs.getCustomPrefsPath();
+		if (path!=null)
+			list.add("  *Custom preferences*: "+path);
+		list.add("  IJ.getVersion: "+IJ.getVersion());
+		list.add("  IJ.getFullVersion: "+IJ.getFullVersion());
+		list.add("  IJ.javaVersion: "+IJ.javaVersion());
+		list.add("  IJ.isJava18(): "+IJ.isJava18());
+		list.add("  IJ.isLinux: "+IJ.isLinux());
+		list.add("  IJ.isMacintosh: "+IJ.isMacintosh());
+		list.add("  IJ.isMacOSX: "+IJ.isMacOSX());
+		list.add("  IJ.isWindows: "+IJ.isWindows());
+		list.add("  IJ.is64Bit: "+IJ.is64Bit());
+		list.add("");
+		list.add("  IJ.getDir(\"imagej\"): "+ IJ.getDir("imagej"));
+		list.add("  IJ.getDir(\"home\"): "+ IJ.getDir("home"));
+		list.add("  IJ.getDir(\"plugins\"): "+ IJ.getDir("plugins"));
+		list.add("  IJ.getDir(\"macros\"): "+ IJ.getDir("macros"));
+		list.add("  IJ.getDir(\"luts\"): "+ IJ.getDir("luts"));
+		list.add("  IJ.getDir(\"current\"): "+ IJ.getDir("current"));
+		list.add("  IJ.getDir(\"cwd\"): "+ IJ.getDir("cwd"));
+		list.add("  IJ.getDir(\"temp\"): "+ IJ.getDir("temp"));
+		list.add("  IJ.getDir(\"default\"): "+ IJ.getDir("default"));
+		list.add("  IJ.getDir(\"image\"): "+ IJ.getDir("image"));
+		list.add("");
+		
+		list.add("  Menus.getPlugInsPath: "+Menus.getPlugInsPath());
+		list.add("  Menus.getMacrosPath: "+Menus.getMacrosPath());
+		list.add("  Prefs.getImageJDir: "+Prefs.getImageJDir());		
+		list.add("  Prefs.getThreads: "+Prefs.getThreads()+cores());	
+		list.add("  Prefs.open100Percent: "+Prefs.open100Percent);		
+		list.add("  Prefs.blackBackground: "+Prefs.blackBackground);		
+		list.add("  Prefs.useJFileChooser: "+Prefs.useJFileChooser);		
+		list.add("  Prefs.weightedColor: "+Prefs.weightedColor);		
+		list.add("  Prefs.blackCanvas: "+Prefs.blackCanvas);		
+		list.add("  Prefs.pointAutoMeasure: "+Prefs.pointAutoMeasure);		
+		list.add("  Prefs.pointAutoNextSlice: "+Prefs.pointAutoNextSlice);		
+		list.add("  Prefs.requireControlKey: "+Prefs.requireControlKey);		
+		list.add("  Prefs.useInvertingLut: "+Prefs.useInvertingLut);		
+		list.add("  Prefs.antialiasedTools: "+Prefs.antialiasedTools);		
+		list.add("  Prefs.useInvertingLut: "+Prefs.useInvertingLut);		
+		list.add("  Prefs.intelByteOrder: "+Prefs.intelByteOrder);			
+		list.add("  Prefs.noPointLabels: "+Prefs.noPointLabels);		
+		list.add("  Prefs.disableUndo: "+Prefs.disableUndo);		
+		list.add("  Prefs dir: "+Prefs.getPrefsDir());
+		list.add("  Current dir: "+OpenDialog.getDefaultDirectory());
+		list.add("  Sample images dir: "+Prefs.getImagesURL());
+		list.add("  Memory in use: "+IJ.freeMemory());	
+		Rectangle s1 = GUI.getScreenBounds(); // primary screen
+		Rectangle s2 = GUI.getScreenBounds(IJ.getInstance()); // screen with "ImageJ" window
+		if (s1.equals(s2))
+			list.add("  Screen size: " + s1.width + "x" + s1.height);
+		else {
+			list.add("  Size of primary screen: " + s1.width + "x" + s1.height);
+			list.add("  Size of \"ImageJ\" screen: " + s2.width + "x" + s2.height);
+		}
+		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+		list.add("  Max window bounds: " + toString(GUI.getMaxWindowBounds(IJ.getInstance())));
+		listMonitors(ge, list);
+		System.gc();
+		doFullDump();
+		if (IJ.getInstance()==null) {
+			for (int i=0; i<list.size(); i++)
+				IJ.log((String)list.get(i));
+		} else
+			new TextWindow("Properties", "", list, 400, 500);
+	}
+	
+	private void listMonitors(GraphicsEnvironment ge, ArrayList list) {
+		int max = 10;
+		String[] str = new String[max];
+		int n = 0;
+		Rectangle bounds2 = null;
+		GraphicsDevice[] gs = ge.getScreenDevices();
+		for (int j=0; j<gs.length; j++) {
+			GraphicsDevice gd = gs[j];
+			GraphicsConfiguration[] gc = gd.getConfigurations();
+			for (int i=0; i<gc.length; i++) {
+				Rectangle bounds = gc[i].getBounds();
+				if (bounds!=null && !bounds.equals(bounds2) && n<max) {
+					str[n++] = toString(bounds);
+					bounds2 = bounds;
+				}
+			}
+		}
+		if (n>1) {
+			for (int i=0; i<n; i++)
+				list.add("  Monitor"+(i+1)+": " + str[i]);
+		}
+	}
+
+	private String toString(Rectangle r) {
+		if (r==null) return "";
+		String s = r.toString();
+		return s.substring(19, s.length()-1);
+	}
+	
+	String cores() {
+		int cores = Runtime.getRuntime().availableProcessors();
+		if (cores==1)
+			return " (1 core)";
+		else
+			return " ("+cores+" cores)";
+	}
+	
+	void show(String property) {
+		String p = System.getProperty(property);
+		if (p!=null)
+			list.add("  " + property + ": " + p);
+	}
+	
+	void doFullDump() {
+		list.add("");
+		list.add("All Java Properties");
+		Properties props = System.getProperties();
+		for (Enumeration en=props.keys(); en.hasMoreElements();) {
+			String key = (String)en.nextElement();
+			list.add("  "+key+": "+(String)props.get(key));
+		}
+	}
+
+}
diff --git a/src/ij/plugin/JavaScriptEvaluator.java b/src/ij/plugin/JavaScriptEvaluator.java
new file mode 100644
index 0000000..9906fcd
--- /dev/null
+++ b/src/ij/plugin/JavaScriptEvaluator.java
@@ -0,0 +1,89 @@
+package ij.plugin;
+import ij.*;
+import ij.plugin.frame.Editor;
+import javax.script.*;
+
+/** Implements the text editor's Macros/Run command, and the
+    IJ.runMacroFile() method, when the file name ends with ".js". */
+public class JavaScriptEvaluator implements PlugIn, Runnable  {
+	private Thread thread;
+	private String script;
+	private Object result;
+	private String error;
+	private boolean evaluating;
+	ScriptEngine engine;
+
+	// run script in separate thread
+	public void run(String script) {
+		if (script.equals(""))
+			return;
+		this.script = script;
+		thread = new Thread(this, "JavaScript"); 
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	// Run script in current thread
+	public String run(String script, String arg) {
+		this.script = script;
+		run();
+		return null;
+	}
+
+	// Evaluates 'script' and returns any error messages as a String. 
+	public String eval(String script) {
+		this.script = script;
+		evaluating = true;
+		run();
+		if (error!=null)
+			return error;
+		else
+			return result!=null?""+result:"";
+	}
+
+	public void run() {
+		result = null;
+		error = null;
+		Thread.currentThread().setContextClassLoader(IJ.getClassLoader());
+		if (IJ.isJava19())
+			System.setProperty("nashorn.args", "--language=es6"); // Use ECMAScript 6 on Java 9
+		try {
+			if (engine==null) {
+				ScriptEngineManager scriptEngineManager = new ScriptEngineManager();
+				engine = scriptEngineManager.getEngineByName("ECMAScript");
+				if (engine == null) {
+					IJ.error("Could not find JavaScript engine");
+					return;
+				}
+				if (!IJ.isJava18()) {
+					engine.eval("function load(path) {\n"
+						+ "  importClass(Packages.sun.org.mozilla.javascript.internal.Context);\n"
+						+ "  importClass(Packages.java.io.FileReader);\n"
+						+ "  var cx = Context.getCurrentContext();\n"
+						+ "  cx.evaluateReader(this, new FileReader(path), path, 1, null);\n"
+						+ "}");
+				}
+			}
+			result = engine.eval(script);
+		} catch(Throwable e) {
+			String msg = e.getMessage();
+			if (msg==null)
+				msg = "";
+			if (msg.startsWith("sun.org.mozilla.javascript.internal.EcmaError: "))
+				msg = msg.substring(47, msg.length());
+			if (msg.startsWith("sun.org.mozilla.javascript.internal.EvaluatorException"))
+				msg = "Error"+msg.substring(54, msg.length());
+			if (msg.length()>0 && !msg.contains("Macro canceled")) {
+				if (evaluating)
+					error = msg;
+				else
+					IJ.log(msg);
+			}
+		}
+	}
+	
+	public String toString() {
+		return result!=null?""+result:"";
+	}
+
+}
diff --git a/src/ij/plugin/JpegWriter.java b/src/ij/plugin/JpegWriter.java
new file mode 100644
index 0000000..3478524
--- /dev/null
+++ b/src/ij/plugin/JpegWriter.java
@@ -0,0 +1,162 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.io.FileSaver;
+import ij.io.SaveDialog;
+import java.awt.image.*;
+import java.awt.*;
+import java.io.*;
+import java.util.Iterator;
+import javax.imageio.*;
+import javax.imageio.stream.*;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import javax.imageio.metadata.IIOMetadata;
+
+
+/** The File/Save As/Jpeg command (FileSaver.saveAsJpeg() method) 
+      uses this plugin to save images in JPEG format. */
+public class JpegWriter implements PlugIn {
+	public static final int DEFAULT_QUALITY = 75;
+	private static boolean disableChromaSubsampling;
+	private static boolean chromaSubsamplingSet;
+
+	public void run(String arg) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return;
+		imp.startTiming();
+		saveAsJpeg(imp,arg,FileSaver.getJpegQuality());
+		IJ.showTime(imp, imp.getStartTime(), "JpegWriter: ");
+	}
+
+	/** Thread-safe method. */
+	public static String save(ImagePlus imp, String path, int quality) {
+		if (imp==null)
+			imp = IJ.getImage();
+		if (path==null || path.length()==0)
+			path = SaveDialog.getPath(imp, ".jpg");
+		if (path==null)
+			return null;
+		String error = (new JpegWriter()).saveAsJpeg(imp, path, quality);
+		return error;
+	}
+
+	String saveAsJpeg(ImagePlus imp, String path, int quality) {
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		int biType = BufferedImage.TYPE_INT_RGB;
+		boolean overlay = imp.getOverlay()!=null && !imp.getHideOverlay();
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.isDefaultLut() && !imp.isComposite() && !overlay && ip.getMinThreshold()==ImageProcessor.NO_THRESHOLD)
+			biType = BufferedImage.TYPE_BYTE_GRAY;
+		BufferedImage bi = new BufferedImage(width, height, biType);
+		String error = null;
+		try {
+			Graphics g = bi.createGraphics();
+			Image img = imp.getImage();
+			if (overlay && !imp.tempOverlay())
+				img = imp.flatten().getImage();
+			g.drawImage(img, 0, 0, null);
+			g.dispose();            
+			Iterator iter = ImageIO.getImageWritersByFormatName("jpeg");
+			ImageWriter writer = (ImageWriter)iter.next();
+			File f = new File(path);
+			String originalPath = null;
+			boolean replacing = f.exists();
+			if (replacing) {
+				originalPath = path;
+				path += ".temp";
+				f = new File(path);
+			}
+			ImageOutputStream ios = ImageIO.createImageOutputStream(f);
+			writer.setOutput(ios);
+			ImageWriteParam param = writer.getDefaultWriteParam();
+			param.setCompressionMode(param.MODE_EXPLICIT);
+			param.setCompressionQuality(quality/100f);
+			if (quality == 100)
+				param.setSourceSubsampling(1, 1, 0, 0);						
+			IIOImage iioImage = null;
+			boolean disableSubsampling = quality>=90;
+			if (chromaSubsamplingSet)
+				disableSubsampling = disableChromaSubsampling;
+			if (!disableSubsampling)  // Use chroma subsampling YUV420
+				iioImage = new IIOImage(bi, null, null);
+			else {
+				// Disable JPEG chroma subsampling
+				// http://svn.apache.org/repos/asf/shindig/trunk/java/gadgets/src/main/java/org/apache/shindig/gadgets/rewrite/image/BaseOptimizer.java
+				// http://svn.apache.org/repos/asf/shindig/trunk/java/gadgets/src/main/java/org/apache/shindig/gadgets/rewrite/image/JpegImageUtils.java
+				// Peter Haub, Okt. 2019
+				IIOMetadata metadata = writer.getDefaultImageMetadata(new ImageTypeSpecifier(bi.getColorModel(), bi.getSampleModel()), param);			
+				Node rootNode = metadata!=null ? metadata.getAsTree("javax_imageio_jpeg_image_1.0") : null;				
+				boolean metadataUpdated = false;
+				// The top level root node has two children, out of which the second one will
+				// contain all the information related to image markers.
+				if (rootNode!=null && rootNode.getLastChild() != null) {
+					Node markerNode = rootNode.getLastChild();
+					NodeList markers = markerNode.getChildNodes();
+					// Search for 'SOF' marker where subsampling information is stored.
+					for (int i = 0; i < markers.getLength(); i++) {
+						Node node = markers.item(i);
+						// 'SOF' marker can have
+						//   1 child node if the color representation is greyscale,
+						//   3 child nodes if the color representation is YCbCr, and
+						//   4 child nodes if the color representation is YCMK.
+						// This subsampling applies only to YCbCr.
+						if (node.getNodeName().equalsIgnoreCase("sof") && node.hasChildNodes() && node.getChildNodes().getLength() == 3) {
+							// In 'SOF' marker, first child corresponds to the luminance channel, and setting
+							// the HsamplingFactor and VsamplingFactor to 1, will imply 4:4:4 chroma subsampling.
+							NamedNodeMap attrMap = node.getFirstChild().getAttributes();
+							// SamplingModes: UNKNOWN(-2), DEFAULT(-1), YUV444(17), YUV422(33), YUV420(34), YUV411(65)					
+							int samplingmode = 17;   // YUV444
+							attrMap.getNamedItem("HsamplingFactor").setNodeValue((samplingmode & 0xf) + "");
+							attrMap.getNamedItem("VsamplingFactor").setNodeValue(((samplingmode >> 4) & 0xf) + "");
+							metadataUpdated = true;
+							break;
+						}
+					}
+				}
+				// Read the updated metadata from the metadata node tree.
+				if (metadataUpdated)
+					metadata.setFromTree("javax_imageio_jpeg_image_1.0", rootNode);					
+				iioImage = new IIOImage(bi, null, metadata);				
+			} // end of code adaption (Disable JPEG chroma subsampling)			
+			writer.write(null, iioImage, param);
+			ios.close();
+			writer.dispose();
+			if (replacing) {
+				File f2 = new File(originalPath);
+				boolean ok = f2.delete();
+				if (ok) f.renameTo(f2);
+			}
+		} catch (Exception e) {
+			error = ""+e;
+			if (error.contains("Output has not been set!"))
+				error = "Incorrect file path: \""+path+"\"";
+			IJ.error("JPEG Writer", error);
+		}
+		return error;
+	}
+	
+	public static void setQuality(int jpegQuality) {
+		FileSaver.setJpegQuality(jpegQuality);
+	}
+
+	public static int getQuality() {
+		return FileSaver.getJpegQuality();
+	}
+	
+	/** Enhance quality of JPEGs by disabing chroma subsampling. 
+		By default, enhanced quality is automatically used
+		when the Quality setting is 90 or greater. */		
+	public static void enhanceQuality(boolean enhance) {
+		disableChromaSubsampling = enhance;
+		chromaSubsamplingSet = true;
+	}
+
+	public static void disableChromaSubsampling(boolean disable) {
+		enhanceQuality(disable);
+	}
+
+
+}
diff --git a/src/ij/plugin/LUT_Editor.java b/src/ij/plugin/LUT_Editor.java
new file mode 100644
index 0000000..e05ca35
--- /dev/null
+++ b/src/ij/plugin/LUT_Editor.java
@@ -0,0 +1,481 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.awt.image.*;
+import ij.util.*;
+import ij.measure.*;
+import java.util.Vector;
+import java.awt.event.*;
+
+public class LUT_Editor implements PlugIn, ActionListener{
+    private ImagePlus imp;
+    Button openButton, saveButton, resizeButton, invertButton;
+    ColorPanel colorPanel;
+    int bitDepth;
+
+    public void run(String args) {
+     	ImagePlus imp = WindowManager.getCurrentImage();
+    	if (imp==null) {
+    		IJ.showMessage("LUT Editor", "No images are open");
+    		return;
+    	}
+    	bitDepth = imp.getBitDepth();
+    	if (bitDepth==24) {
+    		IJ.showMessage("LUT Editor", "RGB images do not use LUTs");
+    		return;
+    	}
+    	if (bitDepth!=8) {
+    		imp.getProcessor().resetMinAndMax();
+    		imp.updateAndDraw();
+    	}
+    	
+        colorPanel = new ColorPanel(imp);
+    	if (colorPanel.getMapSize()!=256) {
+    		IJ.showMessage("LUT Editor", "LUT must have 256 entries");
+    		return;
+    	}
+		boolean recording = Recorder.record;
+		Recorder.record = false;
+        int red=0, green=0, blue=0;
+        GenericDialog gd = new GenericDialog("LUT Editor");
+        Panel buttonPanel = new Panel(new GridLayout(4, 1, 0, 5));
+        openButton = new Button("Open...");
+        openButton.addActionListener(this);
+        buttonPanel.add(openButton);
+        saveButton = new Button("Save...");
+        saveButton.addActionListener(this);
+        buttonPanel.add(saveButton);
+        resizeButton = new Button("Set...");
+        resizeButton.addActionListener(this);
+        buttonPanel.add(resizeButton);
+        invertButton = new Button("Invert...");
+        invertButton.addActionListener(this);
+        buttonPanel.add(invertButton);
+        Panel panel = new Panel();
+        panel.add(colorPanel);
+        panel.add(buttonPanel);
+        gd.addPanel(panel, GridBagConstraints.CENTER, new Insets(10, 0, 0, 0));
+        gd.showDialog();
+		Recorder.record = recording;
+        if (gd.wasCanceled()){
+            colorPanel.cancelLUT();
+            return;
+        } else {
+        	colorPanel.applyLUT();
+        	String lutName = imp.getProp(LUT.nameKey);
+        	if (lutName!=null && !lutName.endsWith(" (edited)"))
+        		imp.setProp(LUT.nameKey, lutName+" (edited)");
+        }
+    }
+
+    void save() {
+    	try {IJ.run("LUT...");} // File>Save As>Lut...
+    	catch(RuntimeException e) {}
+    }
+
+    public void actionPerformed(ActionEvent e) {
+        Object source = e.getSource();
+        if (source==openButton)
+            colorPanel.open();
+        else if (source==saveButton)
+            save();
+        else if (source==resizeButton)
+            colorPanel.resize();
+        else if (source==invertButton)
+            colorPanel.invert();
+    }
+}
+
+
+class ColorPanel extends Panel implements MouseListener, MouseMotionListener{
+     static final int entryWidth=12, entryHeight=12;
+     int rows = 16;
+     int columns = 16; 
+     Color c[] = new Color[256];
+     Color b;
+     ColorProcessor cp;
+     IndexColorModel origin;
+     private ImagePlus imp;
+     private int[] xSize = new int[256], redY, greenY, blueY;
+     private int mapSize, x, y, initialC = -1, finalC = -1;
+     private byte[] reds, greens, blues;
+     private boolean updateLut;
+     private static String[] choices = {"Replication","Interpolation", "Spline Fitting"};
+     private static String scaleMethod = choices[1];
+     private int bitDepth;
+     
+     ColorPanel(ImagePlus imp) {
+         setup(imp);
+     }
+     
+     public void setup(ImagePlus imp) {
+        if (imp==null) {
+           IJ.noImage();
+           return;
+        }
+        this.imp  =  imp;
+        bitDepth = imp.getBitDepth();
+        ImageProcessor ip = imp.getChannelProcessor();
+        IndexColorModel cm = (IndexColorModel)ip.getColorModel();
+        origin = cm;
+        mapSize = cm.getMapSize();
+        reds = new byte[256];
+        greens = new byte[256];
+        blues = new byte[256];
+        cm.getReds(reds);
+        cm.getGreens(greens);
+        cm.getBlues(blues);
+        addMouseListener(this);
+        addMouseMotionListener(this);
+        for(int index  = 0; index < mapSize; index++)
+            c[index] = new Color(reds[index]&255, greens[index]&255, blues[index]&255);
+    }
+    
+    public Dimension getPreferredSize()  {
+        return new Dimension(columns*entryWidth, rows*entryHeight);
+    }
+    
+    public Dimension getMinimumSize() {
+        return new Dimension(columns*entryWidth, rows*entryHeight);
+    }
+    
+    int getMouseZone(int x, int y){
+        int horizontal = (int)x/entryWidth;
+        int vertical = (int)y/entryHeight;
+        int index = (columns*vertical + horizontal);
+        return index;
+    }
+    
+    public void colorRamp() {
+        if (initialC>finalC) {
+            int tmp = initialC;
+            initialC = finalC;
+            finalC = tmp;
+        }
+        float difference = finalC - initialC+1;
+        int start = (byte)c[initialC].getRed()&255;
+        int end = (byte)c[finalC].getRed()&255;
+        float rstep = (end-start)/difference;
+        for(int index =  initialC;  index <= finalC; index++)
+            reds[index] = (byte)(start+ (index-initialC)*rstep);
+        
+        start = (byte)c[initialC].getGreen()&255;
+        end = (byte)c[finalC].getGreen()&255;
+        float gstep = (end-start)/difference;
+            for(int index = initialC; index <= finalC; index++)
+                greens[index] = (byte)(start + (index-initialC)*gstep);
+        
+        start = (byte)c[initialC].getBlue()&255;
+        end = (byte)c[finalC].getBlue()&255;
+        float bstep = (end-start)/difference;
+        for(int index = initialC; index <= finalC; index++)
+            blues[index] = (byte)(start + (index-initialC)*bstep);
+        for (int index = initialC; index <= finalC; index++)
+            c[index] = new Color(reds[index]&255, greens[index]&255, blues[index]&255);
+        repaint();
+    }
+
+    public void mousePressed(MouseEvent e){
+        x = (e.getX());
+        y = (e.getY());
+        initialC = getMouseZone(x,y);
+    }
+
+    public void mouseReleased(MouseEvent e){
+        x = (e.getX());
+        y = (e.getY());
+        finalC =  getMouseZone(x,y);
+        if(initialC>=mapSize&&finalC>=mapSize) {
+    		initialC = finalC = -1;
+    		return;
+        }
+        if(initialC>=mapSize)
+            initialC = mapSize-1;
+        if(finalC>=mapSize)
+            finalC = mapSize-1;
+        if(finalC<0)
+            finalC = 0;
+        if (initialC == finalC) {
+            b = c[finalC];
+            ColorChooser cc = new ColorChooser("Color at Entry " + (finalC) , c[finalC] ,  false);
+            c[finalC] = cc.getColor();
+            if (c[finalC]==null){
+                c[finalC] = b;
+            }
+            colorRamp();
+        } else {
+            b = c[initialC];
+            ColorChooser icc = new ColorChooser("Initial Entry (" + (initialC)+")" , c[initialC] , false);
+            c[initialC] = icc.getColor();
+            if (c[initialC]==null){
+                c[initialC] = b;
+                initialC = finalC = -1;
+                return;
+            }
+            b = c[finalC];
+            ColorChooser fcc = new ColorChooser("Final Entry (" + (finalC)+")" , c[finalC] , false);
+            c[finalC] = fcc.getColor();
+            if (c[finalC]==null){
+                c[finalC] = b;
+                initialC = finalC = -1;
+                return;
+            }
+            colorRamp();
+        }
+    initialC = finalC = -1;
+    applyLUT();
+    }
+
+    public void mouseClicked(MouseEvent e){}
+    public void mouseEntered(MouseEvent e){}
+    public void mouseExited(MouseEvent e){}
+
+    public void mouseDragged(MouseEvent e){
+        x = (e.getX());
+        y = (e.getY());
+        finalC =  getMouseZone(x,y);
+		IJ.showStatus("index=" + getIndex(finalC));
+        repaint();
+    }
+
+    public void mouseMoved(MouseEvent e) {
+        x = (e.getX());
+        y = (e.getY());
+        int entry = getMouseZone(x,y);
+        if (entry<mapSize) {
+           int red = reds[entry]&255;
+           int green = greens[entry]&255;
+           int blue = blues[entry]&255;
+           IJ.showStatus("index=" + getIndex(entry) + ", color=" + red + "," + green + "," + blue);
+        } else
+           IJ.showStatus("");
+    }
+    
+    final String getIndex(int index) {
+    	if (bitDepth==8)
+    		return (""+index);
+		ImageProcessor ip = imp.getProcessor();
+		double min = ip.getMin();
+		double max = ip.getMax();
+		Calibration cal = imp.getCalibration();
+		min = cal.getCValue(min); 
+		max = cal.getCValue(max); 
+		double value = min + (index/255.0)*(max-min);
+		int digits = (max-min)<100?2:0;
+			return (index+" ("+IJ.d2s(value,digits)+")");
+    }
+
+    void open() {
+    	try {IJ.run("LUT... ");} // File>Import>Lut...
+    	catch(RuntimeException e) {}
+        updateLut = true;
+        repaint();
+   }
+
+    void updateLut() {
+        IndexColorModel cm = (IndexColorModel)imp.getChannelProcessor().getColorModel();
+        if (mapSize == 0)
+             return;
+        cm.getReds(reds);
+        cm.getGreens(greens);
+        cm.getBlues(blues);
+        for(int i=0; i<mapSize; i++)
+            c[i] = new Color(reds[i]&255, greens[i]&255, blues[i]&255);
+   }
+
+    void invert() {
+        byte[] reds2 = new byte[mapSize];
+        byte[] greens2 = new byte[mapSize];
+        byte[] blues2 = new byte[mapSize];	
+		for (int i=0; i<mapSize; i++) {
+			reds2[i] = (byte)(reds[mapSize-i-1]&255);
+			greens2[i] = (byte)(greens[mapSize-i-1]&255);
+			blues2[i] = (byte)(blues[mapSize-i-1]&255);
+		}
+        reds=reds2; greens=greens2; blues=blues2;
+        for(int i=0; i<mapSize; i++)
+            c[i] = new Color(reds[i]&255, greens[i]&255, blues[i]&255);
+        applyLUT();
+        repaint();
+    }
+
+    void resize() {
+        GenericDialog sgd = new GenericDialog("LUT Editor");
+        sgd.addNumericField("Number of Colors:", mapSize, 0);
+        sgd.addChoice("Scale Using:", choices, scaleMethod);
+        sgd.showDialog();
+        if (sgd.wasCanceled()){
+            cancelLUT();
+            return;
+        }
+        int newSize = (int)sgd.getNextNumber();
+        if (newSize<2) newSize = 2;
+        if (newSize>256) newSize =256;
+        scaleMethod = sgd.getNextChoice();
+        scale(reds, greens, blues, newSize);
+        mapSize = newSize;
+        for(int i=0; i<mapSize; i++)
+            c[i] = new Color(reds[i]&255, greens[i]&255, blues[i]&255);
+        applyLUT();
+        repaint();
+    }
+
+    void scale(byte[] reds, byte[] greens, byte[] blues, int newSize) {
+        if (newSize==mapSize)
+            return;
+        else if (newSize<mapSize || scaleMethod.equals(choices[0]))
+            scaleUsingReplication(reds, greens, blues, newSize);
+        else if (scaleMethod.equals(choices[1]))
+            scaleUsingInterpolation(reds, greens, blues, newSize);
+        else
+             scaleUsingSplineFitting(reds, greens, blues, newSize);
+    }
+
+    void scaleUsingReplication(byte[] reds, byte[] greens, byte[] blues, int newSize) {
+        byte[] reds2 = new byte[256];
+        byte[] greens2 = new byte[256];
+        byte[] blues2 = new byte[256];
+        for(int i = 0; i < mapSize; i++) {
+            reds2[i] = reds[i];
+            greens2[i] = greens[i];
+            blues2[i] = blues[i];
+        }
+        for(int i = 0; i < newSize; i++) {
+            int index =(int)( i*((double)mapSize/newSize));
+            reds[i] = reds2[index];
+            greens[i] = greens2[index];
+            blues[i] = blues2[index];
+        }
+     }
+
+    void scaleUsingInterpolation(byte[] reds, byte[] greens, byte[] blues, int newSize) {
+        int[] r = new int[mapSize];
+        int[] g = new int[mapSize];
+        int[] b = new int[mapSize];
+        for(int i = 0; i<mapSize; i++) {
+            r[i] = reds[i]&255;
+            g[i] = greens[i]&255;
+            b[i] = blues[i]&255;
+        }
+        double scale = (double)(mapSize-1)/(newSize-1);
+        int i1, i2;
+        double fraction;
+        for (int i=0; i<newSize; i++) {
+            i1 = (int)(i*scale);
+            i2 = i1+1;
+            if (i2==mapSize) i2 = mapSize-1;
+            fraction = i*scale - i1;
+            //IJ.log(i+" "+i1+" "+i2+" "+fraction+" "+mapSize+" "+newSize);
+            reds[i] = (byte)((1.0-fraction)*r[i1] + fraction*r[i2]);
+            greens[i] = (byte)((1.0-fraction)*g[i1] + fraction*g[i2]);
+            blues[i] = (byte)((1.0-fraction)*b[i1] + fraction*b[i2]);
+        }
+     }
+
+    void scaleUsingSplineFitting(byte[] reds, byte[] greens, byte[] blues, int newSize) {
+        //IJ.log("scaleUsingSplineFitting: "+mapSize+" "+newSize);
+        int[] reds2 = new int[mapSize];
+        int[] greens2 = new int[mapSize];
+        int[] blues2 = new int[mapSize];
+        for(int i=0; i<mapSize; i++) {
+            reds2[i] = reds[i]&255;
+            greens2[i] = greens[i]&255;
+            blues2[i] = blues[i]&255;
+        }
+        int[] xValues = new int[mapSize];
+        for(int i = 0; i < mapSize; i++) {
+           xValues[i] = (int)(i*(double)newSize/(mapSize-1));
+           //IJ.log(i+" "+xValues[i]+" "+reds2[i]);
+        }
+        SplineFitter sfReds = new SplineFitter(xValues, reds2, mapSize);
+        SplineFitter sfGreens = new SplineFitter(xValues, greens2, mapSize);
+        SplineFitter sfBlues = new SplineFitter(xValues, blues2, mapSize);
+        for(int i = 0; i < newSize; i++) {
+             double v = Math.round(sfReds.evalSpline(xValues, reds2, mapSize, i));
+             if (v<0.0) v=0.0; if (v>255.0) v=255.0; reds[i] = (byte)v;
+             v = Math.round(sfGreens.evalSpline(xValues, greens2, mapSize, i));
+             if (v<0.0) v=0.0; if (v>255.0) v=255.0; greens[i] = (byte)v;
+             v = Math.round(sfBlues.evalSpline(xValues, blues2, mapSize, i));
+             if (v<0.0) v=0.0; if (v>255.0) v=255.0; blues[i] = (byte)v;
+        }
+     }
+
+    public void cancelLUT() {
+        if (mapSize == 0)
+             return;
+        origin.getReds(reds);
+        origin.getGreens(greens);
+        origin.getBlues(blues);
+        mapSize = 256;
+        applyLUT();
+     }
+
+    public void applyLUT() {
+        byte[] reds2=reds, greens2=greens, blues2=blues;
+        if (mapSize<256) {
+            reds2 = new byte[256];
+            greens2 = new byte[256];
+            blues2 = new byte[256];
+            for(int i = 0; i < mapSize; i++) {
+                reds2[i] = reds[i];
+                greens2[i] = greens[i];
+                blues2[i] = blues[i];
+            }
+            scale(reds2, greens2, blues2, 256);
+        }
+        IndexColorModel cm = new IndexColorModel(8, 256, reds2, greens2, blues2);
+        ImageProcessor ip = imp.getChannelProcessor();
+        ip.setColorModel(cm);
+        if (imp.isComposite())
+        	((CompositeImage)imp).setChannelColorModel(cm);
+        if (imp.getStackSize()>1 && !imp.isComposite())
+            imp.getStack().setColorModel(cm);
+        imp.updateAndDraw();
+    }
+
+    public void update(Graphics g) {
+        paint(g);
+    }
+
+    public void paint(Graphics g) {
+        if (updateLut) {
+            updateLut();
+            updateLut = false;
+        }
+        int index = 0;
+        for (int y=0; y<rows; y++) {
+            for (int x=0; x<columns; x++) {
+                if(index>=mapSize) {
+                    g.setColor(Color.lightGray);
+                    g.fillRect(x*entryWidth,  y*entryHeight, entryWidth, entryHeight);
+                } else if (((index <= finalC) && (index >= initialC)) || ((index >= finalC) && (index <=  initialC))){
+                    g.setColor(c[index].brighter());
+                    g.fillRect(x*entryWidth,  y*entryHeight, entryWidth, entryHeight);
+                    g.setColor(Color.white);
+                    g.drawRect((x*entryWidth), (y*entryHeight), entryWidth, entryHeight);
+                    g.setColor(Color.black);
+                    g.drawLine((x*entryWidth)+entryWidth-1, (y*entryHeight), (x*entryWidth)+entryWidth-1, (y*entryWidth)+entryHeight);
+                    g.drawLine((x*entryWidth), (y*entryHeight)+entryHeight-1, (x*entryWidth)+entryWidth-1, (y*entryHeight)+entryHeight-1);
+                    g.setColor(Color.white);
+                } else {
+                    g.setColor(c[index]);
+                    g.fillRect(x*entryWidth,  y*entryHeight, entryWidth, entryHeight);
+                    g.setColor(Color.white);
+                    g.drawRect((x*entryWidth), (y*entryHeight), entryWidth-1, entryHeight-1);
+                    g.setColor(Color.black);
+                    g.drawLine((x*entryWidth), (y*entryHeight), (x*entryWidth)+entryWidth-1, (y*entryWidth));
+                    g.drawLine((x*entryWidth), (y*entryHeight), (x*entryWidth), (y*entryHeight)+entryHeight-1); 
+                }
+                index++;
+            }
+        }
+    }
+
+    int getMapSize() {
+        return mapSize;
+    }
+
+}
diff --git a/src/ij/plugin/ListVirtualStack.java b/src/ij/plugin/ListVirtualStack.java
new file mode 100644
index 0000000..bc0b93a
--- /dev/null
+++ b/src/ij/plugin/ListVirtualStack.java
@@ -0,0 +1,201 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.util.Tools;
+import java.awt.*;
+import java.io.*;
+import java.util.*;
+
+/** This plugin opens images specified by list of file paths as a virtual stack.
+	It implements the File/Import/Stack From List command. */
+public class ListVirtualStack extends VirtualStack implements PlugIn {
+	private static boolean virtual;
+	private String[] list;
+	private String[] labels;
+	private int nImages;
+	private int imageWidth, imageHeight;
+
+	public void run(String arg) {
+		OpenDialog  od = new OpenDialog("Open Image List", arg);
+		String name = od.getFileName();
+		if (name==null) return;
+		String  dir = od.getDirectory();
+		//IJ.log("ListVirtualStack: "+dir+"   "+name);
+		list = open(dir+name);
+		if (list==null) return;
+		nImages = list.length;
+		labels = new String[nImages];
+		//for (int i=0; i<list.length; i++)
+		//	IJ.log(i+"  "+list[i]);
+		if (list.length==0) {
+			IJ.error("Stack From List", "The file path list is empty");
+			return;
+		}
+		if (!list[0].startsWith("http://")) {
+			File f = new File(list[0]);
+			if (!f.exists()) {
+				IJ.error("Stack From List", "The first file on the list does not exist:\n \n"+list[0]);
+				return;
+			}
+		}
+		ImagePlus imp = IJ.openImage(list[0]);
+		if (imp==null) return;
+		imageWidth = imp.getWidth();
+		imageHeight = imp.getHeight();
+		setBitDepth(imp.getBitDepth());
+		ImageStack stack = this;
+		if (!showDialog(imp)) return;
+		if (!virtual)
+			stack = convertToRealStack(imp);
+		ImagePlus imp2 = new ImagePlus(name, stack);
+		imp2.setCalibration(imp.getCalibration());
+		imp2.show();
+	}
+	
+	boolean showDialog(ImagePlus imp) {
+		double bytesPerPixel = 1;
+		switch (imp.getType()) {
+			case ImagePlus.GRAY16:
+				bytesPerPixel=2; break;
+			case ImagePlus.COLOR_RGB:
+			case ImagePlus.GRAY32:
+				bytesPerPixel=4; break;
+		}
+		double size = (imageWidth*imageHeight*bytesPerPixel)/(1024.0*1024.0);
+		int digits = size*getSize()<10.0?1:0;
+		String size1 = IJ.d2s(size*getSize(), digits)+" MB";
+		String size2 = IJ.d2s(size,1)+" MB";
+		GenericDialog gd = new GenericDialog("Open Stack From List");
+		gd.addCheckbox("Use Virtual Stack", virtual);
+		gd.addMessage("This "+imageWidth+"x"+imageHeight+"x"+getSize()+" stack will require "+size1+",\n or "+size2+" if opened as a virtual stack.");
+		gd.showDialog();
+		if (gd.wasCanceled()) return false;
+		virtual = gd.getNextBoolean();
+		return true;
+	}
+	
+	ImageStack convertToRealStack(ImagePlus imp) {
+		ImageStack stack2 = new ImageStack(imageWidth, imageHeight, imp.getProcessor().getColorModel());
+		int n = this.getSize();
+		for (int i=1; i<=this.getSize(); i++) {
+			IJ.showProgress(i, n);
+			IJ.showStatus("Opening: "+i+"/"+n);
+			ImageProcessor ip2 = this.getProcessor(i);
+			if (ip2!=null)
+				stack2.addSlice(this.getSliceLabel(i), ip2);
+		}
+		return stack2;
+	}
+	
+	String[] open(String path) {
+		if (path.startsWith("http://"))
+			return openUrl(path);
+		Vector v = new Vector();
+		File file = new File(path);
+		try {
+			BufferedReader r = new BufferedReader(new FileReader(file));
+			while (true) {
+				String s=r.readLine();
+				if (s==null || s.equals("") || s.startsWith(" "))
+					break;
+				else
+					v.addElement(s);
+			}
+			r.close();
+    		String[] list = new String[v.size()];
+			v.copyInto((String[])list);
+    		return list;
+		}
+		catch (Exception e) {
+			IJ.error("Open List Error \n\""+e.getMessage()+"\"\n");
+		}
+		return null;
+	}
+
+	String[] openUrl(String url) {
+		String str = IJ.openUrlAsString(url);
+		if (str.startsWith("<Error: ")) {
+			IJ.error("Stack From List", str);
+			return null;
+		} else
+			return Tools.split(str, "\n");
+	}
+	
+	/** Deletes the specified image, were 1<=n<=nslices. */
+	public void deleteSlice(int n) {
+		if (n<1 || n>nImages)
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		if (nImages<1) return;
+		for (int i=n; i<nImages; i++)
+			list[i-1] = list[i];
+		list[nImages-1] = null;
+		nImages--;
+	}
+	
+	/** Returns an ImageProcessor for the specified slice,
+		were 1<=n<=nslices. Returns null if the stack is empty.
+	*/
+	public ImageProcessor getProcessor(int n) {
+		if (n<1 || n>nImages)
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		IJ.redirectErrorMessages(true);
+		String url = list[n-1];
+		ImagePlus imp = null;
+		if (url.length()>0)
+			imp = IJ.openImage(url);
+		if (imp!=null) {
+			labels[n-1] = (new File(list[n-1])).getName()+"\n"+(String)imp.getProperty("Info");
+			ImageProcessor ip =  imp.getProcessor();
+			int bitDepth = getBitDepth();
+			if (imp.getBitDepth()!=bitDepth) {
+				switch (bitDepth) {
+					case 8: ip=ip.convertToByte(true); break;
+					case 16: ip=ip.convertToShort(true); break;
+					case 24:  ip=ip.convertToRGB(); break;
+					case 32: ip=ip.convertToFloat(); break;
+				}
+			}
+			if (ip.getWidth()!=imageWidth || ip.getHeight()!=imageHeight)
+			ip = ip.resize(imageWidth, imageHeight);
+			IJ.redirectErrorMessages(false);
+			return ip;
+		} else {
+				ImageProcessor ip = null;
+				switch (getBitDepth()) {
+					case 8: ip=new ByteProcessor(imageWidth,imageHeight); break;
+					case 16: ip=new ShortProcessor(imageWidth,imageHeight); break;
+					case 24:  ip=new ColorProcessor(imageWidth,imageHeight); break;
+					case 32: ip=new FloatProcessor(imageWidth,imageHeight); break;
+				}
+			IJ.redirectErrorMessages(false);
+			return ip;
+		}
+	 }
+ 
+	 /** Returns the number of images in this stack. */
+	public int getSize() {
+		return nImages;
+	}
+
+	/** Returns the name of the specified image. */
+	public String getSliceLabel(int n) {
+		if (n<1 || n>nImages)
+			throw new IllegalArgumentException("Argument out of range: "+n);
+		if (labels[n-1]!=null)
+			return labels[n-1];
+		else
+			return (new File(list[n-1])).getName();
+	}
+	
+	public int getWidth() {
+		return imageWidth;
+	}
+
+	public int getHeight() {
+		return imageHeight;
+	}
+
+
+}
diff --git a/src/ij/plugin/LutLoader.java b/src/ij/plugin/LutLoader.java
new file mode 100644
index 0000000..77568f4
--- /dev/null
+++ b/src/ij/plugin/LutLoader.java
@@ -0,0 +1,446 @@
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import ij.gui.ImageWindow;
+import java.awt.*;
+import java.io.*;
+import java.awt.image.*;
+import java.net.*;
+
+/** Opens NIH Image look-up tables (LUTs), 768 byte binary LUTs
+	(256 reds, 256 greens and 256 blues), LUTs in text format, 
+	or generates the LUT specified by the string argument 
+	passed to the run() method. */
+public class LutLoader extends ImagePlus implements PlugIn {
+
+	private static String defaultDirectory = null;
+	private boolean suppressErrors;
+	
+	/** Returns the LUT 'name' as an IndexColorModel, where
+	 * 'name' can be any entry in the Image/Lookup Tables menu.
+	 * @see ij.IJ#getLuts
+	 * See: Help>Examples>JavaScript/Show all LUTs
+	*/
+	public static IndexColorModel getLut(String name) {
+		if (name==null) return null;
+		LutLoader ll = new LutLoader();
+		FileInfo fi = ll.getBuiltInLut(name.toLowerCase());
+		if (fi.fileName!=null)
+			return new IndexColorModel(8, 256, fi.reds, fi.greens, fi.blues);
+		String path = IJ.getDir("luts")+name+".lut";
+		IndexColorModel lut = LutLoader.openLut("noerror:"+path);
+		if (lut==null) {
+			path = IJ.getDir("luts")+name.replaceAll(" ","_")+".lut";
+			lut = LutLoader.openLut("noerror:"+path);
+		}
+		return lut;
+	}
+
+	/** If 'arg'="", displays a file open dialog and opens the specified
+		LUT. If 'arg' is a path, opens the LUT specified by the path. If
+		'arg'="fire", "ice", etc., uses a method to generate the LUT. */
+	public void run(String arg) {
+		if (arg.equals("invert")) {
+			invertLut();
+			return;
+		}
+		
+		// Built in LUT
+		FileInfo fi = getBuiltInLut(arg);
+		if (fi.fileName!=null) {
+			showLut(fi, true);
+			Menus.updateMenus();			
+			return;
+		}
+		
+		// LUT in luts folder
+		OpenDialog od = new OpenDialog("Open LUT...", arg);
+		fi.directory = od.getDirectory();
+		fi.fileName = od.getFileName();
+		if (fi.fileName==null)
+				return;
+		if (openLut(fi))
+			showLut(fi, arg.equals(""));
+		IJ.showStatus("");
+	}
+	
+	private FileInfo getBuiltInLut(String name) {
+		FileInfo fi = new FileInfo();
+		fi.reds = new byte[256]; 
+		fi.greens = new byte[256]; 
+		fi.blues = new byte[256];
+		fi.lutSize = 256;
+		fi.fileName = null;
+		if (name==null)
+			return fi;
+		if (name.equals("3-3-2 rgb")) name="3-3-2 RGB";
+		if (name.equals("red/green")) name="redgreen";
+		int nColors = 0;
+		if (name.equals("fire"))
+			nColors = fire(fi.reds, fi.greens, fi.blues);
+		else if (name.equals("grays"))
+			nColors = grays(fi.reds, fi.greens, fi.blues);
+		else if (name.equals("ice"))
+			nColors = ice(fi.reds, fi.greens, fi.blues);
+		else if (name.equals("spectrum"))
+			nColors = spectrum(fi.reds, fi.greens, fi.blues);
+		else if (name.equals("3-3-2 RGB"))
+			nColors = rgb332(fi.reds, fi.greens, fi.blues);
+		else if (name.equals("red"))
+			nColors = primaryColor(4, fi.reds, fi.greens, fi.blues);
+		else if (name.equals("green"))
+			nColors = primaryColor(2, fi.reds, fi.greens, fi.blues);
+		else if (name.equals("blue"))
+			nColors = primaryColor(1, fi.reds, fi.greens, fi.blues);
+		else if (name.equals("cyan"))
+			nColors = primaryColor(3, fi.reds, fi.greens, fi.blues);
+		else if (name.equals("magenta"))
+			nColors = primaryColor(5, fi.reds, fi.greens, fi.blues);
+		else if (name.equals("yellow"))
+			nColors = primaryColor(6, fi.reds, fi.greens, fi.blues);
+		else if (name.equals("redgreen"))
+			nColors = redGreen(fi.reds, fi.greens, fi.blues);
+		if (nColors>0) {
+			if (nColors<256)
+				interpolate(fi.reds, fi.greens, fi.blues, nColors);
+			fi.fileName = name;
+		}
+		return fi;
+	}
+	
+	private void showLut(FileInfo fi, boolean showImage) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			if (imp.getProcessor().getNChannels()!=1)
+				IJ.error("LUTs cannot be assiged to RGB Images.");
+			else if (imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.GRAYSCALE) {
+				CompositeImage cimp = (CompositeImage)imp;
+				cimp.setMode(IJ.COLOR);
+				int saveC = cimp.getChannel();
+				IndexColorModel cm = new IndexColorModel(8, 256, fi.reds, fi.greens, fi.blues);
+				for (int c=1; c<=cimp.getNChannels(); c++) {
+					cimp.setC(c);
+					cimp.setChannelColorModel(cm);
+				}
+				imp.setC(saveC);
+				imp.updateAndRepaintWindow();
+			} else {
+				ImageProcessor ip = imp.getChannelProcessor();
+				IndexColorModel cm = new IndexColorModel(8, 256, fi.reds, fi.greens, fi.blues);
+				if (imp.isComposite())
+					((CompositeImage)imp).setChannelColorModel(cm);
+				else {
+					ip.setColorModel(cm);
+					//ip.setMinAndMax(ip.getMin(), ip.getMax());
+					if (imp.getWindow()==null)
+						imp.setProcessor(ip);
+				}
+				if (imp.getStackSize()>1)
+					imp.getStack().setColorModel(cm);
+				imp.updateAndRepaintWindow();
+				if (IJ.isMacro() && imp.getWindow()!=null)
+					IJ.wait(25);
+			}
+			saveLUTName(imp, fi);
+		} else
+			createImage(fi, showImage);
+	}
+	
+	private void saveLUTName(ImagePlus imp, FileInfo fi) {
+		if (imp!=null && fi!=null && fi.fileName!=null) {
+			String name = fi.fileName;
+			if (name.endsWith(".lut"))
+				name = name.substring(0,name.length()-4);
+			if (name.equals("grays"))
+				imp.setProp(LUT.nameKey, null);
+			else
+				imp.setProp(LUT.nameKey, name);
+		}
+	}
+	
+	void invertLut() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			{IJ.noImage(); return;}
+		if (imp.getProcessor().getNChannels()==3) {
+			IJ.error("RGB images do not use LUTs");
+			return;
+		}
+		if (imp.isComposite()) {
+			CompositeImage ci = (CompositeImage)imp;
+			LUT lut = ci.getChannelLut();
+			if (lut!=null)
+				ci.setChannelLut(lut.createInvertedLut());
+		} else {
+			ImageProcessor ip = imp.getProcessor();
+			ip.invertLut();
+			if (imp.getStackSize()>1)
+				imp.getStack().setColorModel(ip.getColorModel());
+		}
+		imp.updateAndRepaintWindow();
+	}
+
+	int fire(byte[] reds, byte[] greens, byte[] blues) {
+		int[] r = {0,0,1,25,49,73,98,122,146,162,173,184,195,207,217,229,240,252,255,255,255,255,255,255,255,255,255,255,255,255,255,255};
+		int[] g = {0,0,0,0,0,0,0,0,0,0,0,0,0,14,35,57,79,101,117,133,147,161,175,190,205,219,234,248,255,255,255,255};
+		int[] b = {0,61,96,130,165,192,220,227,210,181,151,122,93,64,35,5,0,0,0,0,0,0,0,0,0,0,0,35,98,160,223,255};
+		for (int i=0; i<r.length; i++) {
+			reds[i] = (byte)r[i];
+			greens[i] = (byte)g[i];
+			blues[i] = (byte)b[i];
+		}
+		return r.length;
+	}
+
+	int grays(byte[] reds, byte[] greens, byte[] blues) {
+		for (int i=0; i<256; i++) {
+			reds[i] = (byte)i;
+			greens[i] = (byte)i;
+			blues[i] = (byte)i;
+		}
+		return 256;
+	}
+	
+	int primaryColor(int color, byte[] reds, byte[] greens, byte[] blues) {
+		for (int i=0; i<256; i++) {
+			if ((color&4)!=0)
+				reds[i] = (byte)i;
+			if ((color&2)!=0)
+				greens[i] = (byte)i;
+			if ((color&1)!=0)
+				blues[i] = (byte)i;
+		}
+		return 256;
+	}
+	
+	int ice(byte[] reds, byte[] greens, byte[] blues) {
+		int[] r = {0,0,0,0,0,0,19,29,50,48,79,112,134,158,186,201,217,229,242,250,250,250,250,251,250,250,250,250,251,251,243,230};
+		int[] g = {156,165,176,184,190,196,193,184,171,162,146,125,107,93,81,87,92,97,95,93,93,90,85,69,64,54,47,35,19,0,4,0};
+		int[] b = {140,147,158,166,170,176,209,220,234,225,236,246,250,251,250,250,245,230,230,222,202,180,163,142,123,114,106,94,84,64,26,27};
+		for (int i=0; i<r.length; i++) {
+			reds[i] = (byte)r[i];
+			greens[i] = (byte)g[i];
+			blues[i] = (byte)b[i];
+		}
+		return r.length;
+	}
+
+	int spectrum(byte[] reds, byte[] greens, byte[] blues) {
+		Color c;
+		for (int i=0; i<256; i++) {
+			c = Color.getHSBColor(i/255f, 1f, 1f);
+			reds[i] = (byte)c.getRed();
+			greens[i] = (byte)c.getGreen();
+			blues[i] = (byte)c.getBlue();
+		}
+		return 256;
+	}
+	
+	int rgb332(byte[] reds, byte[] greens, byte[] blues) {
+		Color c;
+		for (int i=0; i<256; i++) {
+			reds[i] = (byte)(i&0xe0);
+			greens[i] = (byte)((i<<3)&0xe0);
+			blues[i] = (byte)((i<<6)&0xc0);
+		}
+		return 256;
+	}
+
+	int redGreen(byte[] reds, byte[] greens, byte[] blues) {
+		for (int i=0; i<128; i++) {
+			reds[i] = (byte)(i*2);
+			greens[i] = (byte)0;
+			blues[i] = (byte)0;
+		}
+		for (int i=128; i<256; i++) {
+			reds[i] = (byte)0;
+			greens[i] = (byte)(i*2);
+			blues[i] = (byte)0;
+		}
+		return 256;
+	}
+
+	void interpolate(byte[] reds, byte[] greens, byte[] blues, int nColors) {
+		byte[] r = new byte[nColors]; 
+		byte[] g = new byte[nColors]; 
+		byte[] b = new byte[nColors];
+		System.arraycopy(reds, 0, r, 0, nColors);
+		System.arraycopy(greens, 0, g, 0, nColors);
+		System.arraycopy(blues, 0, b, 0, nColors);
+		double scale = nColors/256.0;
+		int i1, i2;
+		double fraction;
+		for (int i=0; i<256; i++) {
+			i1 = (int)(i*scale);
+			i2 = i1+1;
+			if (i2==nColors) i2 = nColors-1;
+			fraction = i*scale - i1;
+			reds[i] = (byte)((1.0-fraction)*(r[i1]&255) + fraction*(r[i2]&255));
+			greens[i] = (byte)((1.0-fraction)*(g[i1]&255) + fraction*(g[i2]&255));
+			blues[i] = (byte)((1.0-fraction)*(b[i1]&255) + fraction*(b[i2]&255));
+		}
+	}
+	
+	/** Opens a LUT and returns it as a LUT object. */
+	public static LUT openLut(String pathOrURL) {
+		boolean noError = pathOrURL.startsWith("noerror:");
+		if (noError)
+			pathOrURL = pathOrURL.substring(8);
+		FileInfo fi = new FileInfo();
+		fi.reds = new byte[256]; 
+		fi.greens = new byte[256]; 
+		fi.blues = new byte[256];
+		fi.lutSize = 256;
+		int nColors = 0;
+		if (pathOrURL.contains("://")) {
+			fi.url = pathOrURL;
+			fi.fileName = "";
+		} else {
+			OpenDialog od = new OpenDialog("Open LUT...", pathOrURL);
+			fi.directory = od.getDirectory();
+			fi.fileName = od.getFileName();
+			if (fi.fileName==null)
+				return null;
+		}
+		LutLoader loader = new LutLoader();
+		loader.suppressErrors = noError;
+		boolean ok = loader.openLut(fi);
+		if (ok)
+			return new LUT(fi.reds, fi.greens, fi.blues);
+		else
+			return null;
+	}
+	
+	/** Opens an NIH Image LUT, 768 byte binary LUT or text LUT from a file or URL. */
+	boolean openLut(FileInfo fi) {
+		boolean isURL = fi.url!=null && !fi.url.equals("");
+		int length = 0;
+		String path = isURL?fi.url:fi.getFilePath();
+		if (!isURL) {
+			File f = new File(path);
+			length = (int)f.length();
+			if (length>10000) {
+				error(path);
+				return false;
+			}
+		}
+		int size = 0;
+		try {
+			if (length>768)
+				size = openBinaryLut(fi, isURL, false); // attempt to read NIH Image LUT
+			if (size==0 && (length==0||length==768||length==970))
+				size = openBinaryLut(fi, isURL, true); // otherwise read raw LUT
+			if (size==0 && length>768)
+				size = openTextLut(fi);
+			if (size==0)
+				error(path);
+		} catch (IOException e) {
+			if (!suppressErrors)
+				IJ.error("LUT Loader", ""+e);
+		}
+		return size==256;
+	}
+	
+	private void error(String path) {
+		IJ.error("LUT Reader", "This is not an ImageJ or NIH Image LUT, a 768 byte \nraw LUT, or a LUT in text format.\n \n"+path);
+	}
+
+	/** Opens an NIH Image LUT or a 768 byte binary LUT. */
+	int openBinaryLut(FileInfo fi, boolean isURL, boolean raw) throws IOException {
+		InputStream is;
+		if (isURL)
+			is = new URL(fi.url+fi.fileName).openStream();
+		else
+			is = new FileInputStream(fi.getFilePath());
+		DataInputStream f = new DataInputStream(is);
+		int nColors = 256;
+		if (!raw) {
+			// attempt to read 32 byte NIH Image LUT header
+			int id = f.readInt();
+			if (id!=1229147980) { // 'ICOL'
+				f.close();
+				return 0;
+			}
+			int version = f.readShort();
+			nColors = f.readShort();
+			int start = f.readShort();
+			int end = f.readShort();
+			long fill1 = f.readLong();
+			long fill2 = f.readLong();
+			int filler = f.readInt();
+		}
+		f.read(fi.reds, 0, nColors);
+		f.read(fi.greens, 0, nColors);
+		f.read(fi.blues, 0, nColors);
+		if (nColors<256)
+			interpolate(fi.reds, fi.greens, fi.blues, nColors);
+		f.close();
+		return 256;
+	}
+	
+	int openTextLut(FileInfo fi) throws IOException {
+		TextReader tr = new TextReader();
+		tr.hideErrorMessages();
+		ImageProcessor ip = tr.open(fi.getFilePath());
+		if (ip==null)
+			return 0;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		if (width<3||width>4||height<256||height>258) 
+			return 0; 
+		int x = width==4?1:0; 
+		int y = height>256?1:0;
+		ip.setRoi(x, y, 3, 256);
+		ip = ip.crop();
+		for (int i=0; i<256; i++) {
+			fi.reds[i] = (byte)ip.getPixelValue(0,i);
+			fi.greens[i] = (byte)ip.getPixelValue(1,i);
+			fi.blues[i] = (byte)ip.getPixelValue(2,i);
+		}
+		return 256;
+	}
+
+	private void createImage(FileInfo fi, boolean show) {
+		IndexColorModel cm = new IndexColorModel(8, 256, fi.reds, fi.greens, fi.blues);
+		ByteProcessor bp = createImage(cm);
+		setProcessor(fi.fileName, bp);
+		saveLUTName(this, fi);
+		if (show) show();
+	}
+	
+	/** Opens the specified ImageJ LUT and returns
+		it as an IndexColorModel. Since 1.43t. */
+	public static IndexColorModel open(String path) throws IOException {
+		return open(new FileInputStream(path));
+	}
+
+	/** Opens an ImageJ LUT using an InputStream
+		and returns it as an IndexColorModel. Since 1.43t. */
+	public static IndexColorModel open(InputStream stream) throws IOException {
+		DataInputStream f = new DataInputStream(stream);
+		byte[] reds = new byte[256]; 
+		byte[] greens = new byte[256]; 
+		byte[] blues = new byte[256];
+		f.read(reds, 0, 256);
+		f.read(greens, 0, 256);
+		f.read(blues, 0, 256);
+		f.close();
+		return new IndexColorModel(8, 256, reds, greens, blues);
+	}
+	
+	/** Creates a 256x32 image from an IndexColorModel. Since 1.43t. */
+	public static ByteProcessor createImage(IndexColorModel cm) {
+		int width = 256;
+		int height = 32;
+		byte[] pixels = new byte[width*height];
+		ByteProcessor bp = new ByteProcessor(width, height, pixels, cm);
+		int[] ramp = new int[width];
+		for (int i=0; i<width; i++)
+			ramp[i] = i; 
+		for (int y=0; y<height; y++)
+			bp.putRow(0, y, ramp, width);
+		return bp;
+	}
+	
+}
diff --git a/src/ij/plugin/MacroInstaller.java b/src/ij/plugin/MacroInstaller.java
new file mode 100644
index 0000000..72fbdb3
--- /dev/null
+++ b/src/ij/plugin/MacroInstaller.java
@@ -0,0 +1,551 @@
+package ij.plugin;
+import java.awt.*;
+import java.io.*;
+import java.awt.event.*;
+import ij.*;
+import ij.gui.*;
+import ij.macro.*;
+import ij.text.*;
+import ij.util.Tools;
+import ij.io.*;
+import ij.macro.MacroConstants;
+import ij.plugin.frame.*;
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                import java.util.*;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
+
+/** This plugin implements the Plugins/Macros/Install Macros command. It is also used by the Editor
+	class to install macros in menus and by the ImageJ class to install macros at startup. */
+public class MacroInstaller implements PlugIn, MacroConstants, ActionListener {
+
+	public static final int MAX_SIZE = 28000, MAX_MACROS=100, XINC=10, YINC=18;
+	public static final char commandPrefix = '^';
+	static final String commandPrefixS = "^";
+	static final int MACROS_MENU_COMMANDS = 7; // number of commands in Plugins>Macros submenu
+	
+	private int[] macroStarts;
+	private String[] macroNames;
+	private MenuBar mb = new MenuBar();
+	private int nMacros;
+	private Program pgm;
+	private boolean firstEvent = true;
+	private String shortcutsInUse;
+	private int inUseCount;
+	private int nShortcuts;
+	private int toolCount;
+	private String text;
+	private String anonymousName;
+	private Menu macrosMenu;
+	private int autoRunCount, autoRunAndHideCount;
+	private boolean openingStartupMacrosInEditor;
+	private boolean installTools = true;
+	
+	private static String defaultDir, fileName;
+	private static MacroInstaller instance, listener;
+	private Thread macroToolThread;
+	private ArrayList<Menu> subMenus = new ArrayList();
+	
+	private static Program autoRunPgm;
+	private static int autoRunAddress;
+	private static String autoRunName;
+	private boolean autoRunOnCurrentThread;
+	
+	public void run(String path) {
+		if (path==null || path.equals(""))
+			path = showDialog();
+		if (path==null) return;
+		openingStartupMacrosInEditor = path.indexOf("StartupMacros")!=-1;
+		String text = open(path);
+		if (text!=null) {
+			String functions = Interpreter.getAdditionalFunctions();
+			if (functions!=null) {
+				if (!(text.endsWith("\n") || functions.startsWith("\n")))
+					text = text + "\n" + functions;
+				else
+					text = text + functions;
+			}
+			install(text);
+		}
+	}
+			
+	void install() {
+		subMenus.clear();
+		if (text!=null) {
+			Tokenizer tok = new Tokenizer();
+			pgm = tok.tokenize(text);
+		}
+		if (macrosMenu!=null)
+			IJ.showStatus("");
+		int[] code = pgm.getCode();
+		Symbol[] symbolTable = pgm.getSymbolTable();
+		int count=0, token, nextToken, address;
+		String name;
+		Symbol symbol;
+		shortcutsInUse = null;
+		inUseCount = 0;
+		nShortcuts = 0;
+		toolCount = 0;
+		macroStarts = new int[MAX_MACROS];
+		macroNames = new String[MAX_MACROS];
+		boolean isPluginsMacrosMenu = false;
+		if (macrosMenu!=null) {
+			int itemCount = macrosMenu.getItemCount();
+			isPluginsMacrosMenu = macrosMenu==Menus.getMacrosMenu();
+			int baseCount =isPluginsMacrosMenu?MACROS_MENU_COMMANDS:Editor.MACROS_MENU_ITEMS;
+			if (itemCount>baseCount) {
+				for (int i=itemCount-1; i>=baseCount; i--)
+					macrosMenu.remove(i);
+			}
+		}
+		if (pgm.hasVars() && pgm.macroCount()>0 && pgm.getGlobals()==null)
+			new Interpreter().saveGlobals(pgm);
+		ArrayList tools = new ArrayList();
+		for (int i=0; i<code.length; i++) {
+			token = code[i]&TOK_MASK;
+			if (token==MACRO) {
+				nextToken = code[i+1]&TOK_MASK;
+				if (nextToken==STRING_CONSTANT) {
+					if (count==MAX_MACROS) {
+						if (isPluginsMacrosMenu)
+							IJ.error("Macro Installer", "Macro sets are limited to "+MAX_MACROS+" macros.");
+						break;
+					}
+					address = code[i+1]>>TOK_SHIFT;
+					symbol = symbolTable[address];
+					name = symbol.str;
+					macroStarts[count] = i + 2;
+					macroNames[count] = name;
+					if (name.indexOf('-')!=-1 && (name.indexOf("Tool")!=-1||name.indexOf("tool")!=-1)) {
+						tools.add(name);
+						toolCount++;
+					} else if (name.startsWith("AutoRun")) {
+						if (autoRunCount==0 && !openingStartupMacrosInEditor && !IJ.isMacro()) {
+							if (autoRunOnCurrentThread) { //autoRun() method will run later
+								autoRunPgm = pgm;
+								autoRunAddress = macroStarts[count];
+								autoRunName = name;
+							} else
+								new MacroRunner(pgm, macroStarts[count], name, (String)null); // run on separate thread
+							if (name.equals("AutoRunAndHide"))
+								autoRunAndHideCount++;
+						}
+						autoRunCount++;
+						count--;
+					} else if  (name.equals("Popup Menu"))
+						installPopupMenu(name, pgm);
+					else if (!name.endsWith("Tool Selected")) { 
+						if (macrosMenu!=null) {
+							addShortcut(name);
+							int pos = name.indexOf(">");
+							boolean inSubMenu = name.startsWith("<") && (pos>1);
+							if (inSubMenu) {
+								Menu parent = macrosMenu;
+								Menu subMenu = null;
+								String parentStr = name.substring(1, pos).trim();
+								String childStr = name.substring(pos + 1).trim();
+								MenuItem mnuItem = new MenuItem();
+								mnuItem.setActionCommand(name);
+								mnuItem.setLabel(childStr);
+								for (int jj = 0; jj < subMenus.size(); jj++) {
+									String aName = subMenus.get(jj).getName();
+									if (aName.equals(parentStr))
+										subMenu = subMenus.get(jj);
+								}
+								if (subMenu==null) {
+									subMenu = new Menu(parentStr);
+									subMenu.setName(parentStr);
+									subMenu.addActionListener(this);
+									subMenus.add(subMenu);
+									parent.add(subMenu);
+								}
+								subMenu.add(mnuItem);
+							} else
+								macrosMenu.add(new MenuItem(name));
+						}
+					}
+					count++;
+				}					
+			} else if (token==EOF)
+				break;
+		}
+		nMacros = count;
+		if (toolCount>0  && installTools) {
+			Toolbar tb = Toolbar.getInstance();
+			if (toolCount==1)
+				tb.addMacroTool((String)tools.get(0), this);
+			else {
+				for (int i=0; i<tools.size(); i++) {
+					String toolName = (String)tools.get(i);
+					if (toolName.startsWith("Abort Macro or Plugin") && toolCount>6)
+						toolName = "Unused "+toolName;
+					tb.addMacroTool(toolName, this, i);
+				}
+			}
+			if (toolCount>1 && Toolbar.getToolId()>=Toolbar.CUSTOM1)
+				tb.setTool(Toolbar.RECTANGLE);
+			tb.repaint();
+			installTools = false;
+		}
+		if (macrosMenu!=null)
+			this.instance = this;
+		if (shortcutsInUse!=null && text!=null)
+			IJ.showMessage("Install Macros", (inUseCount==1?"This keyboard shortcut is":"These keyboard shortcuts are")
+			+ " already in use:"+shortcutsInUse);
+		if (nMacros==0 && fileName!=null) {
+			if (text==null||text.length()==0)
+				return;
+			int dotIndex = fileName.lastIndexOf('.');
+			if (dotIndex>0)
+				anonymousName = fileName.substring(0, dotIndex);
+			else
+				anonymousName =fileName;
+			if (macrosMenu!=null)
+				macrosMenu.add(new MenuItem(anonymousName));
+			macroNames[0] = anonymousName;
+			nMacros = 1;
+		}
+		String word = nMacros==1?" macro":" macros";
+		if (isPluginsMacrosMenu)
+			IJ.showStatus(nMacros + word + " installed");
+	}
+	
+	public int install(String text) {
+		if (text==null && pgm==null)
+			return 0;
+		this.text = text;
+		macrosMenu = Menus.getMacrosMenu();
+		if (listener!=null)
+			macrosMenu.removeActionListener(listener);
+		macrosMenu.addActionListener(this);
+		listener = this;
+		install();
+		return nShortcuts;
+	}
+	
+	public int install(String text, Menu menu) {
+		this.text = text;
+		macrosMenu = menu;
+		install();
+		return nShortcuts;
+	}
+
+	public void installFile(String path) {
+		String text = open(path);
+		if (text==null) return;
+		boolean isStartupMacros = path.contains("StartupMacros");
+		if (isStartupMacros && !Toolbar.installStartupMacrosTools())
+			installTools = false;
+		install(text);
+		installTools = true;
+		if (isStartupMacros) {
+			Toolbar tb = Toolbar.getInstance();
+			if (tb!=null)
+				tb.installStartupTools();
+		}
+	}
+
+	public void installTool(String path) {
+		String text = open(path);
+		if (text!=null)
+			installSingleTool(text);
+	}
+
+	public void installLibrary(String path) {
+			String text = open(path);
+			if (text!=null)
+				Interpreter.setAdditionalFunctions(text);
+	}
+	
+	 /** Installs a macro set contained in ij.jar. */
+	public static void installFromJar(String path) {
+		try {
+			(new MacroInstaller()).installFromIJJar(path);
+		} catch (Exception e) {}
+	}
+	
+	 /** Installs a macro set contained in ij.jar. */
+	public void installFromIJJar(String path) {
+		boolean installMacros = false;
+		if (path.endsWith("MenuTool.txt+")) {
+			path = path.substring(0,path.length()-1);
+			installMacros = true;
+		}
+		String text = openFromIJJar(path);
+		if (text==null) return;
+		if (path.endsWith("StartupMacros.txt")) {
+			if (Toolbar.installStartupMacrosTools())
+				install(text);
+			Toolbar tb = Toolbar.getInstance();
+			if (tb!=null)
+				tb.installStartupTools();
+		} else if (path.contains("Tools") || installMacros) {
+			install(text);
+		} else
+			installSingleTool(text);
+	}
+
+	public void installSingleTool(String text) {
+		this.text = text;
+		macrosMenu = null;
+		install();
+	}
+
+	void installPopupMenu(String name, Program pgm) {
+        Hashtable h = pgm.getMenus();
+        if (h==null) return;
+        String[] commands = (String[])h.get(name);
+        if (commands==null) return;
+        PopupMenu popup = Menus.getPopupMenu();
+        if (popup==null) return;
+		popup.removeAll();
+        for (int i=0; i<commands.length; i++) {
+			if (commands[i].equals("-"))
+				popup.addSeparator();
+			else {
+				MenuItem mi = new MenuItem(commands[i]);
+				mi.addActionListener(this);
+				popup.add(mi);
+			}
+        }
+	}
+
+	void removeShortcuts() {
+		Menus.getMacroShortcuts().clear();
+		Hashtable shortcuts = Menus.getShortcuts();
+		for (Enumeration en=shortcuts.keys(); en.hasMoreElements();) {
+			Integer key = (Integer)en.nextElement();
+			String value = (String)shortcuts.get(key);
+			if (value.charAt(0)==commandPrefix)
+				shortcuts.remove(key);
+		}
+	}
+
+	void addShortcut(String name) {
+		int index1 = name.indexOf('[');
+		if (index1==-1)
+			return;
+		int index2 = name.lastIndexOf(']');
+		if (index2<=(index1+1))
+			return;
+		String shortcut = name.substring(index1+1, index2);
+		int len = shortcut.length();
+		if (len>1)
+			shortcut = shortcut.toUpperCase(Locale.US);;
+		if (len>3 || (len>1 && shortcut.charAt(0)!='F' && shortcut.charAt(0)!='N' && shortcut.charAt(0)!='&'))
+			return;
+		boolean bothNumKeys = shortcut.startsWith("&");
+		if (bothNumKeys){ //first handle num key of keyboard
+			shortcut = shortcut.replace("&", "");
+			len = shortcut.length();
+		}			
+		int code = Menus.convertShortcutToCode(shortcut);
+		if (code==0)
+			return;
+		if (nShortcuts==0)
+			removeShortcuts();
+		// One character shortcuts go in a separate hash table to
+		// avoid conflicts with ImageJ menu shortcuts.
+		if (len==1 || shortcut.equals("N+") || shortcut.equals("N-") ) {
+			Hashtable macroShortcuts = Menus.getMacroShortcuts();
+			macroShortcuts.put(new Integer(code), commandPrefix+name);
+			nShortcuts++;
+			if(!bothNumKeys)
+				return;
+		}
+		if(bothNumKeys){//now handle numerical keypad
+			shortcut = "N" + shortcut;
+			code = Menus.convertShortcutToCode(shortcut);
+		}
+		Hashtable shortcuts = Menus.getShortcuts();
+		if (shortcuts.get(new Integer(code))!=null) {
+			if (shortcutsInUse==null)
+				shortcutsInUse = "\n \n";
+			shortcutsInUse += "	  " + name + "\n";
+			inUseCount++;
+			return;
+		}
+		shortcuts.put(new Integer(code), commandPrefix+name);
+		nShortcuts++;
+	}
+	
+	 String showDialog() {
+		if (defaultDir==null) defaultDir = Menus.getMacrosPath();
+		OpenDialog od = new OpenDialog("Install Macros", defaultDir, fileName);
+		String name = od.getFileName();
+		if (name==null) return null;
+		String dir = od.getDirectory();
+		if (!(name.endsWith(".txt")||name.endsWith(".ijm"))) {
+			IJ.showMessage("Macro Installer", "File name must end with \".txt\" or \".ijm\" .");
+			return null;
+		}
+		fileName = name;
+		defaultDir = dir;
+		return dir+name;
+	}
+
+	String open(String path) {
+		if (path==null) return null;
+		try {
+			StringBuffer sb = new StringBuffer(5000);
+			BufferedReader r = new BufferedReader(new FileReader(path));
+			while (true) {
+				String s=r.readLine();
+				if (s==null)
+					break;
+				else
+					sb.append(s+"\n");
+			}
+			r.close();
+			return new String(sb);
+		}
+		catch (Exception e) {
+			IJ.error(e.getMessage());
+			return null;
+		}
+	}
+	 
+	 /** Returns a text file contained in ij.jar. */
+	 public String openFromIJJar(String path) {
+		String text = null;
+		  try {
+			InputStream is = this.getClass().getResourceAsStream(path);
+			if (is==null) return null;
+				InputStreamReader isr = new InputStreamReader(is);
+				StringBuffer sb = new StringBuffer();
+				char [] b = new char [8192];
+				int n;
+				while ((n = isr.read(b)) > 0)
+					 sb.append(b,0, n);
+				text = sb.toString();
+		  }
+		  catch (IOException e) {}
+		  return text;
+	}
+	
+	public boolean runMacroTool(String name) {
+		for (int i=0; i<nMacros; i++) {
+			if (macroNames[i].startsWith(name)) {
+				if (macroToolThread!=null && macroToolThread.getName().indexOf(name)!=-1 && macroToolThread.isAlive())
+					return false; // do nothing if this tool is already running
+				MacroRunner mw = new MacroRunner(pgm, macroStarts[i], name, (String)null);
+				macroToolThread = mw.getThread();
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	public boolean runMenuTool(String name, String command) {
+		for (int i=0; i<nMacros; i++) {
+			if (macroNames[i].startsWith(name)) {
+				Recorder.recordInMacros = true;
+				new MacroRunner(pgm, macroStarts[i], name, command);
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/** Runs a command in the Plugins/Macros submenu on the current thread. */
+	public static boolean runMacroCommand(String name) {
+		if (instance==null)
+			return false;
+		if (name.startsWith(commandPrefixS))
+			name = name.substring(1);
+		for (int i=0; i<instance.nMacros; i++) {
+			if (name.equals(instance.macroNames[i])) {
+				MacroRunner mm = new MacroRunner();
+				mm.run(instance.pgm, instance.macroStarts[i], name);
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	public static void runMacroShortcut(String name) {
+		if (instance==null)
+			return;
+		if (name.startsWith(commandPrefixS))
+			name = name.substring(1);
+		for (int i=0; i<instance.nMacros; i++) {
+			if (name.equals(instance.macroNames[i])) {
+				(new MacroRunner()).runShortcut(instance.pgm, instance.macroStarts[i], name);
+				return;
+			}
+		}
+	}
+
+	public void runMacro(String name) {
+		runMacro(name, null);
+	}
+
+	public void runMacro(String name, Editor editor) {
+		if (anonymousName!=null && name.equals(anonymousName)) {
+			ImageJ.setCommandName(name);
+			new MacroRunner(pgm, 0, anonymousName, editor);
+			return;
+		}
+		for (int i=0; i<nMacros; i++)
+			if (name.equals(macroNames[i])) {
+				ImageJ.setCommandName(name);
+				Interpreter.abort(); // abort any currently running macro
+				new MacroRunner(pgm, macroStarts[i], name, editor);
+				return;
+			}
+	}
+		
+	public int getMacroCount() {
+		return nMacros;
+	}
+    
+    public Program getProgram() {
+		return pgm;
+	}
+
+		
+	/** Returns true if an "AutoRunAndHide" macro was run/installed. */
+	public boolean isAutoRunAndHide() {
+		return autoRunAndHideCount>0;
+	}
+
+	public void setFileName(String fileName) {
+		this.fileName = fileName;
+		openingStartupMacrosInEditor = fileName.startsWith("StartupMacros");
+	}
+
+	public static String getFileName() {
+		return fileName;
+	}
+	
+	public void actionPerformed(ActionEvent evt) {
+		String cmd = evt.getActionCommand();
+		ImageJ.setCommandName(cmd);
+		MenuItem item = (MenuItem)evt.getSource();
+		MenuContainer parent = item.getParent();
+		if (parent instanceof PopupMenu) {
+			for (int i=0; i<nMacros; i++) {
+				if (macroNames[i].equals("Popup Menu")) {
+					new MacroRunner(pgm, macroStarts[i], "Popup Menu", cmd);
+					return;
+				}
+			}
+		}
+		runMacro(cmd);
+	}
+	
+	/** Installs startup macros and runs AutoRun macro on current thread. */
+	public void installStartupMacros(String path) {
+		autoRunOnCurrentThread = true;
+		installFile(path);
+		autoRunOnCurrentThread = false;
+	}
+	
+	/** Runs the StartupMacros AutoRun macro on the current thread. */
+	public static void autoRun() {
+		if (autoRunPgm!=null)
+			(new MacroRunner()).run(autoRunPgm, autoRunAddress, autoRunName);
+		autoRunPgm = null;
+	}
+
+} 
+
+
+
diff --git a/src/ij/plugin/Macro_Runner.java b/src/ij/plugin/Macro_Runner.java
new file mode 100644
index 0000000..28768fc
--- /dev/null
+++ b/src/ij/plugin/Macro_Runner.java
@@ -0,0 +1,353 @@
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import ij.macro.*;
+import ij.text.*;
+import ij.util.*;
+import ij.plugin.frame.*;
+import ij.gui.GenericDialog;
+import java.io.*;
+import java.lang.reflect.*;
+
+/** This class runs macros and scripts installed in the Plugins menu as well as
+	macros and scripts opened using the Plugins/Macros/Run command. */
+public class Macro_Runner implements PlugIn {
+	private static String filePath;
+	
+	/** Opens and runs the specified macro file (.txt or .ijm) or script file (.js, .bsh or .py)  
+		on the current thread. Displays a file open dialog if <code>name</code> 
+		is an empty string. The macro or script is assumed to be in the ImageJ 
+		plugins folder if  <code>name</code> is not a full path. */
+	public void run(String name) {
+		if (IJ.debugMode)
+			IJ.log("Macro_Runner.run(): "+name);
+		Thread thread = Thread.currentThread();
+		String threadName = thread.getName();
+		if (!threadName.endsWith("Macro$")) {
+			if (name.endsWith(".js")||name.endsWith(".bsh")||name.endsWith(".py"))
+				thread.setName(threadName+"_Script_Macro$");
+			else
+				thread.setName(threadName+"_Macro$");
+		}
+		String path = null;
+		if (name.equals("")) {
+			OpenDialog od = new OpenDialog("Run Macro or Script...", path);
+			String directory = od.getDirectory();
+			name = od.getFileName();
+			if (name!=null) {
+				path = directory+name;
+				runMacroFile(path, null);
+				if (Recorder.record) {
+					path = Recorder.fixPath(path);
+					if (Recorder.scriptMode())
+						Recorder.recordCall("IJ.runMacroFile(\""+path+"\");");
+					else
+						Recorder.record("runMacro", path);
+				}
+			}
+		} else if (name.startsWith("JAR:"))
+			runMacroFromJar(name.substring(4), null);
+		else if (name.startsWith("ij.jar:"))
+			runMacroFromIJJar(name, null);
+		else if (name.endsWith("Tool.ijm") || name.endsWith("Tool.txt")
+		|| name.endsWith("Menu.ijm") || name.endsWith("Menu.txt"))
+			(new MacroInstaller()).installTool(Menus.getPlugInsPath()+name);
+		else {
+			boolean fullPath = name.startsWith("/") || name.startsWith("\\") || name.indexOf(":\\")==1 || name.indexOf(":/")==1;
+			if (fullPath)
+				path = name;
+			else
+				path = Menus.getPlugInsPath() + name;
+			runMacroFile(path, null);
+		}
+	}
+        
+	/** Opens and runs the specified macro or script on the current
+		thread. The file is assumed to be in the ImageJ/macros folder
+		unless 'name' is a full path. The macro or script can use the
+		getArgument() function to retrieve the string argument.
+    */
+	public String runMacroFile(String name, String arg) {
+		if (arg==null) arg = "";
+		if (name.startsWith("ij.jar:"))
+			return runMacroFromIJJar(name, arg);
+        boolean fullPath = name.startsWith("/") || name.startsWith("\\") || name.indexOf(":\\")==1 || name.indexOf(":/")==1;
+		String path = name;
+		boolean exists = false;
+        if (!fullPath) {
+        	String macrosDir = Menus.getMacrosPath();
+        	if (macrosDir!=null)
+        		path = Menus.getMacrosPath() + name;
+        }
+		File f = new File(path);
+		boolean hasExtension = f.getName().contains(".");
+		if (hasExtension)
+			exists = f.exists();
+		if (!exists && !fullPath && !hasExtension) {
+			String path2 = path+".txt";
+			f = new File(path2);
+			exists = f.exists();
+			if (exists)
+				path = path2;
+			else {
+				path2 = path+".ijm";
+				f = new File(path2);
+				exists = f.exists();
+				if (exists) path=path2;
+			}
+		}
+		if (!exists) {
+			f = new File(path);
+			exists = f.exists();
+		}
+		if (!exists && !fullPath) {
+			String path2 = System.getProperty("user.dir") + File.separator + name;
+			if (!hasExtension) {
+				String path3 = path2 +".txt";
+				f = new File(path3);
+				exists = f.exists();
+				if (exists)
+					path = path3;
+				else {
+					path3 = path2+".ijm";
+					f = new File(path3);
+					exists = f.exists();
+					if (exists) path=path3;
+				}
+			}
+			if (!exists) {
+				f = new File(path2);
+				exists = f.exists();
+				if (exists) path=path2;
+			}
+		}
+		if (IJ.debugMode) IJ.log("runMacro: "+path+" ("+name+")");
+		if (!exists || f==null) {
+            IJ.error("RunMacro", "Macro or script not found:\n \n"+path);
+			return null;
+		}
+		filePath = path;
+		try {
+			int size = (int)f.length();
+			byte[] buffer = new byte[size];
+			FileInputStream in = new FileInputStream(f);
+			in.read(buffer, 0, size);
+			String macro = new String(buffer, 0, size, "ISO8859_1");
+			in.close();
+			OpenDialog.setLastDirectory(f.getParent()+File.separator);
+			OpenDialog.setLastName(f.getName());
+			if (name.endsWith(".js"))
+				return runJavaScript(macro, arg);
+			else if (name.endsWith(".bsh"))
+				return runBeanShell(macro, arg);
+			else if (name.endsWith(".py"))
+				return runPython(macro, arg);
+			else
+				return runMacro(macro, arg);
+		}
+		catch (Exception e) {
+			if (!Macro.MACRO_CANCELED.equals(e.getMessage()))
+				IJ.error(e.getMessage());
+			return null;
+		}
+	}
+
+    /** Runs the specified macro on the current thread. Macros can retrieve 
+    	the optional string argument by calling the getArgument() macro function. 
+    	Returns the string value returned by the macro, null if the macro does not
+    	return a value, or "[aborted]" if the macro was aborted due to an error. */
+	public String runMacro(String macro, String arg) {
+		Interpreter interp = new Interpreter();
+		try {
+			return interp.run(macro, arg);
+		} catch(Throwable e) {
+			interp.abortMacro();
+			IJ.showStatus("");
+			IJ.showProgress(1.0);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) imp.unlock();
+			String msg = e.getMessage();
+			if (e instanceof RuntimeException && msg!=null && e.getMessage().equals(Macro.MACRO_CANCELED))
+				return  "[aborted]";
+			IJ.handleException(e);
+		}
+		return  "[aborted]";
+	}
+	
+	/** Runs the specified macro from a JAR file in the plugins folder,
+		passing it the specified argument. Returns the String value returned
+		by the macro, null if the macro does not return a value, or "[aborted]"
+		if the macro was aborted due to an error. The macro can reside anywhere
+		in the plugins folder, in or out of a JAR file, so name conflicts are possible.
+		To avoid name conflicts, it is a good idea to incorporate the plugin
+		or JAR file name in the macro name (e.g., "Image_5D_Macro1.ijm"). */
+	public static String runMacroFromJar(String name, String arg) {
+		String macro = null;
+		try {
+			ClassLoader pcl = IJ.getClassLoader();
+			InputStream is = pcl.getResourceAsStream(name);
+			if (is==null) {
+				IJ.error("Macro Runner", "Unable to load \""+name+"\" from jar file");
+				return null;
+			}
+			InputStreamReader isr = new InputStreamReader(is);
+			StringBuffer sb = new StringBuffer();
+			char [] b = new char [8192];
+			int n;
+			while ((n = isr.read(b)) > 0)
+				sb.append(b,0, n);
+			macro = sb.toString();
+			is.close();
+		} catch (IOException e) {
+			IJ.error("Macro Runner", ""+e);
+		}
+		if (macro!=null)
+			return (new Macro_Runner()).runMacro(macro, arg);
+		else
+			return null;
+	}
+
+	public String runMacroFromIJJar(String name, String arg) {
+		ImageJ ij = IJ.getInstance();
+		//if (ij==null) return null;
+		Class c = ij!=null?ij.getClass():(new ImageStack()).getClass();
+		name = name.substring(7);
+		String macro = null;
+        try {
+			InputStream is = c .getResourceAsStream("/macros/"+name+".txt");
+			//IJ.log(is+"  "+("/macros/"+name+".txt"));
+			if (is==null)
+				return runMacroFile(name, arg);
+            InputStreamReader isr = new InputStreamReader(is);
+            StringBuffer sb = new StringBuffer();
+            char [] b = new char [8192];
+            int n;
+            while ((n = isr.read(b)) > 0)
+                sb.append(b,0, n);
+            macro = sb.toString();
+        }
+        catch (IOException e) {
+            String msg = e.getMessage();
+            if (msg==null || msg.equals(""))
+                msg = "" + e;	
+            IJ.showMessage("Macro Runner", msg);
+        }
+		if (macro!=null)
+			return runMacro(macro, arg);
+		else
+			return null;
+	}
+	
+	/** Runs a JavaScript script on the current thread, passing a string argument, 
+		which the script can retrieve using the getArgument() function. Returns,
+		as a string, the last expression evaluated by the script. */
+	public String runJavaScript(String script, String arg) {
+		Object js = null;
+		if (!(IJ.isMacOSX()&&!IJ.is64Bit())) {
+			// Use JavaScript engine built into Java 6 and later.
+			js = IJ.runPlugIn("ij.plugin.JavaScriptEvaluator", "");
+		} else {
+			js = IJ.runPlugIn("JavaScript", "");
+			if (js==null) {
+				boolean ok = downloadJar("/download/tools/JavaScript.jar");
+				if (ok)
+					js = IJ.runPlugIn("JavaScript", "");
+			}
+		}
+		script = Editor.getJSPrefix(arg)+script;
+		if (IJ.isJava18())
+			script = "load(\"nashorn:mozilla_compat.js\");" + script;
+		if (js!=null)
+			return runScript(js, script, arg);
+		else
+			return null;
+	}
+	
+	private static String runScript(Object plugin, String script, String arg) {
+		if (plugin instanceof PlugInInterpreter) {
+			PlugInInterpreter interp = (PlugInInterpreter)plugin;
+			if (IJ.debugMode)
+				IJ.log("Running "+interp.getName()+" script; arg=\""+arg+"\"");
+			interp.run(script, arg);
+			return interp.getReturnValue();
+		} else { // call run(script,arg) method using reflection
+			try {
+				Class c = plugin.getClass();
+				Method m = c.getMethod("run", new Class[] {script.getClass(), arg.getClass()});
+				String s = (String)m.invoke(plugin, new Object[] {script, arg});			
+			} catch(Exception e) {
+				if ("Jython".equals(plugin.getClass().getName()))
+					IJ.runPlugIn("Jython", script);
+			}
+			return ""+plugin;
+		}
+	}
+	
+	/** Runs a BeanShell script on the current thread, passing a string argument, 
+		which the script can retrieve using the getArgument() function. Returns,
+		as a string, the last expression evaluated by the script.
+		Uses the plugin at http://imagej.nih.gov/ij/plugins/bsh/
+		to run the script.
+	*/
+	public static String runBeanShell(String script, String arg) {
+		if (arg==null)
+			arg = "";
+		Object bsh = IJ.runPlugIn("bsh", "");
+		if (bsh==null) {
+			boolean ok = downloadJar("/plugins/bsh/BeanShell.jar");
+			if (ok)
+				bsh = IJ.runPlugIn("bsh", "");
+		}
+		if (bsh!=null)
+			return runScript(bsh, script, arg);
+		else
+			return null;
+	}
+	
+	/** Runs a Python script on the current thread, passing a string argument, 
+		which the script can retrieve using the getArgument() function. Returns,
+		as a string, the value of the variable 'result'. For example, a Python script  
+		containing the line "result=123" will return the string "123".
+		Uses the plugin at http://imagej.nih.gov/ij/plugins/jython/
+		to run the script.
+	*/
+	public static String runPython(String script, String arg) {
+		if (arg==null)
+			arg = "";
+		Object jython = IJ.runPlugIn("Jython", "");
+		if (jython==null) {
+			boolean ok = downloadJar("/plugins/jython/Jython.jar");
+			if (ok)
+				jython = IJ.runPlugIn("Jython", "");
+		}
+		if (jython!=null)
+			return runScript(jython, script, arg);
+		else
+			return null;
+	}
+
+	public static boolean downloadJar(String url) {
+		String name = url.substring(url.lastIndexOf("/")+1);
+		boolean ok = false;
+		String msg = name+" was not found in the plugins\nfolder or it is outdated. Click \"OK\" to download\nit from the ImageJ website.";
+		GenericDialog gd = new GenericDialog("Download "+name+"?");
+		gd.addMessage(msg);
+		gd.showDialog();
+		if (!gd.wasCanceled()) {
+			ok = (new PluginInstaller()).install(IJ.URL+url);
+			if (!ok)
+				IJ.error("Unable to download "+name+" from "+IJ.URL+url);
+		}
+		return ok;
+	}
+	
+	/** Returns the file path of the most recently loaded macro or script. */
+	public static String getFilePath() {
+		return filePath;
+	}
+
+	public static void setFilePath(String path) {
+		filePath = path;
+	}
+
+}
diff --git a/src/ij/plugin/MeasurementsWriter.java b/src/ij/plugin/MeasurementsWriter.java
new file mode 100644
index 0000000..edefc40
--- /dev/null
+++ b/src/ij/plugin/MeasurementsWriter.java
@@ -0,0 +1,50 @@
+package ij.plugin;
+import ij.*;
+import ij.text.*;
+import ij.measure.ResultsTable;
+import ij.io.*;
+import java.io.*;
+import java.awt.Frame;
+
+/** Saves a table as a csv or tab-delimited text file. */
+public class MeasurementsWriter implements PlugIn {
+
+	public void run(String path) {
+		save(path);
+	}
+	
+	public boolean save(String path) {
+		Frame frame = WindowManager.getFrontWindow();
+		if (frame!=null && (frame instanceof TextWindow) && !"Log".equals(frame.getTitle())) {
+			TextWindow tw = (TextWindow)frame;
+			return tw.getTextPanel().saveAs(path);
+		} else if (IJ.isResultsWindow()) {
+			TextPanel tp = IJ.getTextPanel();
+			if (tp!=null) {
+				if (!tp.saveAs(path))
+					return false;
+			}
+		} else {
+			ResultsTable rt = ResultsTable.getResultsTable();
+			if (rt==null || rt.size()==0) {
+				frame = WindowManager.getFrame("Results");
+				if (frame==null || !(frame instanceof TextWindow))
+					return false;
+				else {
+					TextWindow tw = (TextWindow)frame;
+					return tw.getTextPanel().saveAs(path);
+				}
+			}
+			if (path.equals("")) {
+				SaveDialog sd = new SaveDialog("Save as Text", "Results", Prefs.defaultResultsExtension());
+				String file = sd.getFileName();
+				if (file == null) return false;
+				path = sd.getDirectory() + file;
+			}
+			return rt.save(path);
+		}
+		return true;
+	}
+
+}
+
diff --git a/src/ij/plugin/Memory.java b/src/ij/plugin/Memory.java
new file mode 100644
index 0000000..bce11de
--- /dev/null
+++ b/src/ij/plugin/Memory.java
@@ -0,0 +1,164 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import java.io.*;
+import ij.util.Tools;
+
+
+/** This plugin implements the Edit/Options/Memory command. */
+public class Memory implements PlugIn {
+	String s;
+	int index1, index2;
+	File f;
+	boolean fileMissing;
+	boolean sixtyFourBit;
+
+	public void run(String arg) {
+		changeMemoryAllocation();
+		//IJ.log("setting="+getMemorySetting()/(1024*1024)+"MB");
+		//IJ.log("maxMemory="+maxMemory()/(1024*1024)+"MB");
+	}
+
+	void changeMemoryAllocation() {
+		IJ.maxMemory(); // forces IJ to cache old limit
+		int max = (int)(getMemorySetting()/1048576L);
+		boolean unableToSet = max==0;
+		if (max==0) max = (int)(maxMemory()/1048576L);
+		String title = "Memory "+(IJ.is64Bit()?"(64-bit)":"(32-bit)");
+		GenericDialog gd = new GenericDialog(title);
+		gd.addNumericField("Maximum memory:", max, 0, 5, "MB");
+		gd.addNumericField("Parallel threads:", Prefs.getThreads(), 0, 5, "");
+		gd.setInsets(12, 0, 0);
+		gd.addCheckbox("Keep multiple undo buffers", Prefs.keepUndoBuffers);
+		gd.setInsets(12, 0, 0);
+		gd.addCheckbox("Run garbage collector on status bar click", !Prefs.noClickToGC);
+		gd.addHelp(IJ.URL+"/docs/menus/edit.html#memory");
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		int max2 = (int)gd.getNextNumber();
+		Prefs.setThreads((int)gd.getNextNumber());
+		Prefs.keepUndoBuffers = gd.getNextBoolean();
+		Prefs.noClickToGC = !gd.getNextBoolean();
+		if (gd.invalidNumber()) {
+			IJ.showMessage("Memory", "The number entered was invalid.");
+			return;
+		}
+		if (unableToSet && max2!=max)
+			{showError(); return;}
+		if (IJ.isMacOSX() && max2<256)
+			max2 = 256;
+		else if (max2<32)
+			max2 = 32;
+		if (max2==max) return;
+		int limit = IJ.isWindows()?1600:1700;
+		String OSXInfo = "";
+		if (max2>=limit && !IJ.is64Bit()) {
+			if (!IJ.showMessageWithCancel(title, 
+			"Note: setting the memory limit to a value\n"
+			+"greater than "+limit+"MB on a 32-bit system\n"
+			+"may cause ImageJ to fail to start. The title of\n"
+			+"the Edit>Options>Memory & Threads dialog\n"
+			+"box changes to \"Memory (64-bit)\" when ImageJ\n"
+			+"is running on a 64-bit version of Java."));
+				return;
+		}
+		try {
+			String s2 = s.substring(index2);
+			if (s2.startsWith("g"))
+				s2 = "m"+s2.substring(1);
+			String s3 = s.substring(0, index1) + max2 + s2;
+			FileOutputStream fos = new FileOutputStream(f);
+			PrintWriter pw = new PrintWriter(fos);
+			pw.print(s3);
+			pw.close();
+		} catch (IOException e) {
+			String error = e.getMessage();
+			if (error==null || error.equals("")) error = ""+e;
+			String name = IJ.isMacOSX()?"Info.plist":"ImageJ.cfg";
+			String msg = 
+				   "Unable to update the file \"" + name + "\".\n"
+				+ " \n"
+				+ "\"" + error + "\"";
+			IJ.showMessage("Memory", msg);
+			return;
+		}
+		String hint = "";
+		if (IJ.isWindows() && max2>640 && max2>max)
+			hint = "\nDelete the \"ImageJ.cfg\" file, located in the ImageJ folder,\nif ImageJ fails to start.";
+		IJ.showMessage("Memory", "The new " + max2 +"MB limit will take effect after ImageJ is restarted."+hint);		
+	}
+	
+	public long getMemorySetting() {
+		if (IJ.getApplet()!=null) return 0L;
+		long max = 0L;
+		if (IJ.isMacOSX()) {
+			String appPath = System.getProperty("java.class.path");
+			if (appPath==null) return 0L;
+			int index = appPath.indexOf(".app/");
+			if (index==-1) return 0L;
+			appPath = appPath.substring(0,index+5);
+			max = getMemorySetting(appPath+"Contents/Info.plist");
+		} else
+			max = getMemorySetting("ImageJ.cfg");		
+		return max;
+	}
+
+	void showError() {
+		int max = (int)(maxMemory()/1048576L);
+		String msg =
+			   "ImageJ is unable to change the memory limit. For \n"
+			+ "more information, refer to the installation notes at\n \n"
+			+ "    "+IJ.URL+"/docs/install/\n"
+			+ " \n";
+		if (fileMissing) {
+			if (IJ.isMacOSX())
+				msg += "The ImageJ application (ImageJ.app) was not found.\n \n";
+			else if (IJ.isWindows())
+				msg += "ImageJ.cfg not found.\n \n";
+			fileMissing = false;
+		}
+		if (max>0)
+			msg += "Current limit: " + max + "MB";
+		IJ.showMessage("Memory", msg);
+	}
+
+	long getMemorySetting(String file) {
+		String path = file.startsWith("/")?file:Prefs.getImageJDir()+file;
+		if (IJ.debugMode) IJ.log("getMemorySetting: "+path);
+		f = new File(path);
+		if (!f.exists()) {
+			fileMissing = true;
+			return 0L;
+		}
+		long max = 0L;
+		try {
+			int size = (int)f.length();
+			byte[] buffer = new byte[size];
+			FileInputStream in = new FileInputStream(f);
+			in.read(buffer, 0, size);
+			s = new String(buffer, 0, size, "ISO8859_1");
+			in.close();
+			index1 = s.indexOf("-mx");
+			if (index1==-1) index1 = s.indexOf("-Xmx");
+			if (index1==-1) return 0L;
+			if (s.charAt(index1+1)=='X') index1+=4; else index1+=3;
+			index2 = index1;
+			while (index2<s.length()-1 && Character.isDigit(s.charAt(++index2))) {}
+			String s2 = s.substring(index1, index2);
+			max = (long)Tools.parseDouble(s2, 0.0)*1024*1024;
+			if (index2<s.length() && s.charAt(index2)=='g')
+				max = max*1024L;
+		}
+		catch (Exception e) {
+			IJ.log(""+e);
+			return 0L;
+		}
+		return max;
+	}
+
+	/** Returns the maximum amount of memory this JVM will attempt to use. */
+	public long maxMemory() {
+			return Runtime.getRuntime().maxMemory();
+	}
+	
+}
diff --git a/src/ij/plugin/MontageMaker.java b/src/ij/plugin/MontageMaker.java
new file mode 100644
index 0000000..0508ae9
--- /dev/null
+++ b/src/ij/plugin/MontageMaker.java
@@ -0,0 +1,282 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+
+/** Implements the Image/Stacks/Make Montage command. */
+public class MontageMaker implements PlugIn {
+			
+	private static int columns, rows, first, last, inc, borderWidth;
+	private static double scale;
+	private static boolean label;
+	private static boolean useForegroundColor;
+	private static int saveID;
+	private static int saveStackSize;
+	private static final int defaultFontSize = 12;
+	private static int fontSize = defaultFontSize;
+	private boolean hyperstack;
+
+	public void run(String arg) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getStackSize()==1) {
+			error("Stack required");
+			return;
+		}
+		hyperstack = imp.isHyperStack();
+		if (hyperstack && imp.getNSlices()>1 && imp.getNFrames()>1) {
+			error("5D hyperstacks are not supported");
+			return;
+		}
+		int channels = imp.getNChannels();
+		if (!hyperstack && imp.isComposite() && channels>1) {
+			int channel = imp.getChannel();
+			CompositeImage ci = (CompositeImage)imp;
+			int mode = ci.getMode();
+			if (mode==IJ.COMPOSITE)
+				ci.setMode(IJ.COLOR);
+			ImageStack stack = new ImageStack(imp.getWidth(), imp.getHeight());
+			for (int c=1; c<=channels; c++) {
+				imp.setPosition(c, imp.getSlice(), imp.getFrame());
+				Image img = imp.getImage();
+				stack.addSlice(null, new ColorProcessor(img));
+			}
+			if (ci.getMode()!=mode)
+				ci.setMode(mode);
+			imp.setPosition(channel, imp.getSlice(), imp.getFrame());
+			Calibration cal = imp.getCalibration();
+			imp = new ImagePlus(imp.getTitle(), stack);
+			imp.setCalibration(cal);
+		}
+		makeMontage(imp);
+		imp.updateImage();
+		saveID = imp.getID();
+		IJ.register(MontageMaker.class);
+	}
+	
+	public void makeMontage(ImagePlus imp) {
+			int nSlices = imp.getStackSize();
+			if (hyperstack) {
+				nSlices = imp.getNSlices();
+				if (nSlices==1)
+					nSlices = imp.getNFrames();
+			}
+			boolean macro = Macro.getOptions()!=null;
+			if (macro || columns==0 || !(imp.getID()==saveID || nSlices==saveStackSize)) {
+				columns = (int)Math.sqrt(nSlices);
+				rows = columns;
+				int n = nSlices - columns*rows;
+				if (n>0) columns += (int)Math.ceil((double)n/rows);
+				scale = 1.0;
+				if (imp.getWidth()*columns>800)
+					scale = 0.5;
+				if (imp.getWidth()*columns>1600)
+					scale = 0.25;
+				inc = 1;
+				first = 1;
+				last = nSlices;
+			}
+			if (macro) {
+				fontSize = defaultFontSize;
+				borderWidth = 0;
+				label = false;
+				useForegroundColor = false;
+			}
+			saveStackSize = nSlices;
+			
+			GenericDialog gd = new GenericDialog("Make Montage");
+			gd.addNumericField("Columns:", columns, 0);
+			gd.addNumericField("Rows:", rows, 0);
+			gd.addNumericField("Scale factor:", scale, 2);
+			if (!hyperstack) {
+				gd.addNumericField("First slice:", first, 0);
+				gd.addNumericField("Last slice:", last, 0);
+			}
+			gd.addNumericField("Increment:", inc, 0);
+			gd.addNumericField("Border width:", borderWidth, 0);
+			gd.addNumericField("Font size:", fontSize, 0);
+			gd.addCheckbox("Label slices", label);
+			gd.addCheckbox("Use foreground color", useForegroundColor);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return;
+			columns = (int)gd.getNextNumber();
+			rows = (int)gd.getNextNumber();
+			scale = gd.getNextNumber();
+			gd.setSmartRecording(true);
+			if (!hyperstack) {
+				first = (int)gd.getNextNumber();
+				last = (int)gd.getNextNumber();
+			}
+			inc = (int)gd.getNextNumber();
+			borderWidth = (int)gd.getNextNumber();
+			fontSize = (int)gd.getNextNumber();
+			if (borderWidth<0) borderWidth = 0;
+			if (first<1) first = 1;
+			if (last>nSlices) last = nSlices;
+			if (first>last)
+				{first=1; last=nSlices;}
+			if (inc<1) inc = 1;
+			if (gd.invalidNumber()) {
+				error("Invalid number");
+				return;
+			}
+			label = gd.getNextBoolean();
+			useForegroundColor = gd.getNextBoolean();
+			ImagePlus imp2 = null;
+			if (hyperstack)
+				imp2 = makeHyperstackMontage(imp, columns, rows, scale, inc, borderWidth, label);
+			else
+				imp2 = makeMontage2(imp, columns, rows, scale, first, last, inc, borderWidth, label);
+			if (imp2!=null)
+				imp2.show();
+			if (macro) {
+				fontSize = defaultFontSize;
+				borderWidth = 0;
+				label = false;
+				useForegroundColor = false;
+				columns = 0;
+			}
+	}
+	
+	/** Creates a montage and displays it. */
+	public void makeMontage(ImagePlus imp, int columns, int rows, double scale, int first, int last, int inc, int borderWidth, boolean labels) {
+		ImagePlus imp2 = makeMontage2(imp, columns, rows, scale, first, last, inc, borderWidth, labels);
+		imp2.show();
+	}
+
+	/** Creates a montage and returns it as an ImagePlus. */
+	public ImagePlus makeMontage2(ImagePlus imp, int columns, int rows, double scale, int first, int last, int inc, int borderWidth, boolean labels) {
+		int stackWidth = imp.getWidth();
+		int stackHeight = imp.getHeight();
+		int nSlices = imp.getStackSize();
+		int width = (int)(stackWidth*scale);
+		int height = (int)(stackHeight*scale);
+		int montageWidth = width*columns + borderWidth*(columns-1);
+		int montageHeight = height*rows + borderWidth*(rows-1);
+		ImageProcessor ip = imp.getProcessor();
+		ImageProcessor montage = ip.createProcessor(montageWidth, montageHeight);
+		ImagePlus imp2 = new ImagePlus("Montage", montage);
+		imp2.setCalibration(imp.getCalibration());
+		montage = imp2.getProcessor();
+		Color fgColor=Color.white;
+		Color bgColor = Color.black;
+		if (useForegroundColor) {
+			fgColor = Toolbar.getForegroundColor();
+			bgColor = Toolbar.getBackgroundColor();
+		} else {
+			boolean whiteBackground = false;
+			if ((ip instanceof ByteProcessor) || (ip instanceof ColorProcessor)) {
+				ip.setRoi(0, stackHeight-12, stackWidth, 12);
+				ImageStatistics stats = ImageStatistics.getStatistics(ip, Measurements.MODE, null);
+				ip.resetRoi();
+				whiteBackground = stats.mode>=200;
+				if (imp.isInvertedLut())
+					whiteBackground = !whiteBackground;
+			}
+			if (whiteBackground) {
+				fgColor=Color.black;
+				bgColor = Color.white;
+			}
+		}
+		if (Double.isNaN(Toolbar.getBackgroundValue()))
+			montage.setColor(bgColor);
+		else
+			montage.setGlobalBackgroundColor();
+		montage.fill();
+		if (Double.isNaN(Toolbar.getForegroundValue()))
+			montage.setColor(fgColor);
+		else
+			montage.setGlobalForegroundColor();
+		montage.setFont(new Font("SansSerif", Font.PLAIN, fontSize));
+		montage.setAntialiasedText(true);
+		ImageStack stack = imp.getStack();
+		int x = 0;
+		int y = 0;
+		ImageProcessor aSlice;
+	    int slice = first;
+		while (slice<=last) {
+			aSlice = stack.getProcessor(slice);
+			if (scale!=1.0) {
+				aSlice.setInterpolationMethod(ImageProcessor.BILINEAR);
+				boolean averageWhenDownSizing = width<200;
+				aSlice = aSlice.resize(width, height, averageWhenDownSizing);
+			}
+			montage.insert(aSlice, x, y);
+			String label = stack.getShortSliceLabel(slice);
+			if (labels)
+				drawLabel(montage, slice, label, x, y, width, height, borderWidth);
+			x += width + borderWidth;
+			if (x>=montageWidth) {
+				x = 0;
+				y += height + borderWidth;;
+				if (y>=montageHeight)
+					break;
+			}
+			IJ.showProgress((double)(slice-first)/(last-first));
+			slice += inc;
+		}
+		if (borderWidth>0) {
+			for (x=width; x<montageWidth; x+=width+borderWidth) {
+				montage.setRoi(x, 0, borderWidth, montageHeight);
+				montage.fill();
+			}
+			for (y=height; y<montageHeight; y+=height+borderWidth) {
+				montage.setRoi(0, y, montageWidth, borderWidth);
+				montage.fill();
+			}
+		}
+		IJ.showProgress(1.0);
+		Calibration cal = imp2.getCalibration();
+		if (cal.scaled()) {
+			cal.pixelWidth /= scale;
+			cal.pixelHeight /= scale;
+		}
+        imp2.setProperty("Info", "xMontage="+columns+"\nyMontage="+rows+"\n");
+		return imp2;
+	}
+		
+	/** Creates a hyperstack montage and returns it as an ImagePlus. */
+	private ImagePlus makeHyperstackMontage(ImagePlus imp, int columns, int rows, double scale, int inc, int borderWidth, boolean labels) {
+		ImagePlus[] channels = ChannelSplitter.split(imp);
+		int n = channels.length;
+		ImagePlus[] montages = new ImagePlus[n];
+		for (int i=0; i<n; i++) {
+			int last = channels[i].getStackSize();
+			montages[i] = makeMontage2(channels[i], columns, rows, scale, 1, last, inc, borderWidth, labels);
+		}
+		ImagePlus montage = (new RGBStackMerge()).mergeHyperstacks(montages, false);
+		montage.setCalibration(montages[0].getCalibration());
+		montage.setTitle("Montage");
+		return montage;
+	}
+	
+	private void error(String msg) {
+		IJ.error("Make Montage", msg);
+	}
+	
+	void drawLabel(ImageProcessor montage, int slice, String label, int x, int y, int width, int height, int borderWidth) {
+		if (label!=null && !label.equals("") && montage.getStringWidth(label)>=width) {
+			do {
+				label = label.substring(0, label.length()-1);
+			} while (label.length()>1 && montage.getStringWidth(label)>=width);
+		}
+		if (label==null || label.equals(""))
+			label = ""+slice;
+		int swidth = montage.getStringWidth(label);
+		x += width/2 - swidth/2;
+		y -= borderWidth/2;
+		y += height;
+		montage.drawString(label, x, y);
+	}
+	
+	public void setFontSize(int fontSize) {
+		this.fontSize = fontSize;
+	}
+	
+}
+
+
diff --git a/src/ij/plugin/NewPlugin.java b/src/ij/plugin/NewPlugin.java
new file mode 100644
index 0000000..3adccc3
--- /dev/null
+++ b/src/ij/plugin/NewPlugin.java
@@ -0,0 +1,187 @@
+package ij.plugin;
+import java.awt.*;
+import ij.*;
+import ij.gui.*;
+import ij.plugin.frame.Editor;
+import ij.text.TextWindow;
+import ij.io.SaveDialog;
+import ij.util.Tools;
+
+/** This class creates a new macro or the Java source for a new plugin. */
+public class NewPlugin implements PlugIn {
+
+	public static final int MACRO=0, JAVASCRIPT=1, PLUGIN=2, PLUGIN_FILTER=3, PLUGIN_FRAME=4,
+		TEXT_FILE=5, TABLE=6, MACRO_TOOL=7, PLUGIN_TOOL=8, TEMPLATE=9;
+    private static int rows = 24;
+    private static int columns = 80;
+    private static int tableWidth = 350;
+    private static int tableHeight = 250;
+    private int type = MACRO;
+    private String name = "Macro.ijm";
+    private boolean monospaced;
+    private boolean menuBar = true;
+	private Editor ed;
+    
+    public void run(String arg) {
+    	type = -1;
+    	if (arg.startsWith("text")||arg.equals("")) {
+    		type = TEXT_FILE;
+    		name = "Untitled.txt";
+    	} else if (arg.equals("macro")) {
+    		type = MACRO;
+    		name = "Macro.ijm";
+    	} else if (arg.equals("macro-tool")) {
+    		type = TEMPLATE;
+    		name = "Circle_Tool.txt";
+    	} else if (arg.equals("javascript")) {
+    		type = JAVASCRIPT;
+    		name = "Script.js";
+     	} else if (arg.equals("plugin")) {
+    		type = TEMPLATE;
+    		name = "My_Plugin.src";
+    	} else if (arg.equals("frame")) {
+    		type = TEMPLATE;
+    		name = "Plugin_Frame.src";
+    	} else if (arg.equals("plugin-tool")) {
+    		type = TEMPLATE;
+    		name = "Prototype_Tool.src";
+    	} else if (arg.equals("filter")) {
+    		type = TEMPLATE;
+    		name = "Filter_Plugin.src";
+    	} else if (arg.equals("table")) {
+			String options = Macro.getOptions();
+			if  (IJ.isMacro() && options!=null && options.indexOf("[Text File]")!=-1) {
+    			type = TEXT_FILE;
+    			name = "Untitled.txt";
+    			arg = "text+dialog";
+    		} else {
+    			type = TABLE;
+    			name = "Table";
+    		}
+    	}
+    	menuBar = true;
+    	if (arg.equals("text+dialog") || type==TABLE) {
+			if (!showDialog()) return;
+		}
+		if (type==-1)
+    		createPlugin("Converted_Macro.java", PLUGIN, arg);
+		else if (type==TEMPLATE || type==MACRO || type==TEXT_FILE || type==JAVASCRIPT) {
+			if (type==TEXT_FILE && name.equals("Macro"))
+				name = "Untitled.txt";
+			createMacro(name);
+		} else if (type==TABLE)
+			createTable();
+		else
+			createPlugin(name, type, arg);
+    }
+    
+	public void createMacro(String name) {
+		int options = (monospaced?Editor.MONOSPACED:0)+(menuBar?Editor.MENU_BAR:0);
+		if (name.endsWith(".ijm") || name.endsWith(".js"))
+			options |= Editor.RUN_BAR;
+		if (name.endsWith(".ijm"))
+			options |= Editor.INSTALL_BUTTON;
+		String text = "";
+		ed = new Editor(rows, columns, 0, options);
+		if (type==TEMPLATE)
+			text = Tools.openFromIJJarAsString("/macros/"+name);
+		if (name.endsWith(".src"))
+			name = name.substring(0,name.length()-4) + ".java";
+		if (type==MACRO && !name.endsWith(".ijm"))
+			name = SaveDialog.setExtension(name, ".ijm");
+		else if (type==JAVASCRIPT && !name.endsWith(".js")) {
+			if (name.equals("Macro")) name = "script";
+			name = SaveDialog.setExtension(name, ".js");
+		}
+		if (text!=null)
+			ed.create(name, text);
+	}
+	
+	void createTable() {
+			new TextWindow(name, "", tableWidth, tableHeight);
+	}
+
+	public void createPlugin(String name, int type, String methods) {
+  		ed = (Editor)IJ.runPlugIn("ij.plugin.frame.Editor", "");
+		if (ed==null) return;
+		String pluginName = name;
+		if (!(name.endsWith(".java") || name.endsWith(".JAVA")))
+			name = SaveDialog.setExtension(name, ".java");
+		String className = pluginName.substring(0, pluginName.length()-5);
+		String text = "";
+		text += "import ij.*;\n";
+		text += "import ij.process.*;\n";
+		text += "import ij.gui.*;\n";
+		text += "import java.awt.*;\n";
+		text += "import ij.plugin.*;\n";
+		text += "\n";
+		text += "public class "+className+" implements PlugIn {\n";
+		text += "\n";
+		text += "\tpublic void run(String arg) {\n";
+		text += methods;
+		text += "\t}\n";
+		text += "\n";
+		text += "}\n";
+		ed.create(pluginName, text);
+	}
+	
+	public boolean showDialog() {
+		String title;
+		String widthUnit, heightUnit;
+		int width, height;
+		if (type==TABLE) {
+			title = "New Table";
+			name = "Table";
+			width = tableWidth;
+			height = tableHeight;
+			widthUnit = "pixels";
+			heightUnit = "pixels";
+		} else {
+			title = "New Text Window";
+			name = "Untitled";
+			width = columns;
+			height = rows;
+			widthUnit = "characters";
+			heightUnit = "lines";
+		}
+		GenericDialog gd = new GenericDialog(title);
+		gd.addStringField("Name:", name, 16);
+		gd.addMessage("");
+		gd.addNumericField("Width:", width, 0, 3, widthUnit);
+		gd.addNumericField("Height:", height, 0, 3, heightUnit);
+		if (type!=TABLE) {
+			gd.setInsets(5, 30, 0);
+			gd.addCheckbox("Menu Bar", true);
+			gd.setInsets(0, 30, 0);
+			gd.addCheckbox("Monospaced Font", monospaced);
+		}
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		name = gd.getNextString();
+		width = (int)gd.getNextNumber();
+		height = (int)gd.getNextNumber();
+		if (width<1) width = 1;
+		if (height<1) height = 1;
+		if (type!=TABLE) {
+			menuBar = gd.getNextBoolean();
+			monospaced = gd.getNextBoolean();
+			columns = width;
+			rows = height;
+			if (rows>100) rows = 100;
+			if (columns>200) columns = 200;
+		} else {
+			tableWidth = width;
+			tableHeight = height;
+			if (tableWidth<128) tableWidth = 128;
+			if (tableHeight<75) tableHeight = 75;
+		}
+		return true;
+	}
+	
+	/** Returns the Editor the newly created macro or plugin was opened in. */
+	public Editor getEditor() {
+		return ed;
+	}
+
+}
diff --git a/src/ij/plugin/NextImageOpener.java b/src/ij/plugin/NextImageOpener.java
new file mode 100644
index 0000000..fa128e2
--- /dev/null
+++ b/src/ij/plugin/NextImageOpener.java
@@ -0,0 +1,164 @@
+/**
+This plugin, written by Jon Harmon, implements the File/Open Next command.
+It opens the "next" image in a directory, where "next" can be the
+succeeding or preceeding image in the directory list.
+Press shift-o to open the succeeding image or 
+alt-shift-o to open the preceeding image.
+It can leave the previous file open, or close it.
+You may contact the author at Jonathan_Harman at yahoo.com
+This code was modified from Image_Browser by Albert Cardona
+*/
+
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import ij.gui.*;
+import java.io.File;
+
+public class NextImageOpener implements PlugIn {
+
+	boolean forward = true; // default browse direction is forward
+	boolean closeCurrent = true; //default behavior is to close current window
+	ImagePlus imp0;
+	
+	public void run(String arg) {
+		/* get changes to defaults */
+		if (arg.equals("backward") || IJ.altKeyDown()) forward = false;
+		if (arg.equals("backwardsc")) {
+			forward = false;
+			closeCurrent = false;
+		}
+		if (arg.equals("forwardsc")) {
+			forward = true;
+			closeCurrent = false;
+		}
+				
+		// get current image; displays error and aborts if no image is open
+ 		imp0 = IJ.getImage();
+ 		// get current image directory
+ 		String currentPath = getDirectory(imp0);
+		if (IJ.debugMode) IJ.log("OpenNext.currentPath:" + currentPath);
+		if (currentPath==null) {
+			IJ.error("Next Image", "Directory information for \""+imp0.getTitle()+"\" not found.");
+			return;
+		}
+		String nextPath = getNext(currentPath, getName(imp0), forward);
+		if (IJ.debugMode) IJ.log("OpenNext.nextPath:" + nextPath);
+		// open
+		if (nextPath != null) {
+			String rtn = open(nextPath);
+			if (rtn==null)
+				open(getNext(currentPath, (new File(nextPath)).getName(), forward));
+		}
+	}
+	
+	String getDirectory(ImagePlus imp) {
+		FileInfo fi = imp.getOriginalFileInfo();
+		if (fi==null) return null;
+		String dir = fi.openNextDir;
+		if (dir==null) dir = fi.directory;
+		return dir;
+	}
+
+	String getName(ImagePlus imp) {
+		String name = imp.getTitle();
+		FileInfo fi = imp.getOriginalFileInfo();
+		if (fi!=null) {
+			if (fi.openNextName!=null)
+				name = fi.openNextName;
+			else if (fi.fileName!=null)
+				name = fi.fileName;
+		}
+		return name;
+	}
+	
+	String open(String nextPath) {
+		int nImages = WindowManager.getImageCount();
+		ImagePlus imp2 = IJ.openImage(nextPath);		
+		if (imp2==null) {
+			if (WindowManager.getImageCount()>nImages)
+				return "ok";
+			else
+				return null;
+		}
+		String newTitle = imp2.getTitle();
+		if (imp0.changes) {
+			String msg;
+			String name = imp0.getTitle();
+			if (name.length()>22)
+				msg = "Save changes to\n" + "\"" + name + "\"?";
+			else
+				msg = "Save changes to \"" + name + "\"?";
+			YesNoCancelDialog d = new YesNoCancelDialog(imp0.getWindow(), "ImageJ", msg);
+			if (d.cancelPressed())
+				return "Canceled";
+			else if (d.yesPressed()) {
+				FileSaver fs = new FileSaver(imp0);
+				if (!fs.save())
+					return "Canceled";
+			}
+			imp0.changes = false;
+		}
+		if (!(imp0 instanceof CompositeImage) && (imp2.isComposite() || imp2.isHyperStack())) {
+			// imp0.setImage(imp2) does not work if 'imp2' is composite and 'imp0' is not
+			imp2.show();
+			imp0.close();
+			imp0 = imp2;
+		} else
+			imp0.setImage(imp2);
+		return "ok";
+	}
+	
+	/** gets the next image name in a directory list */
+	String getNext(String path, String imageName, boolean forward) {
+		File dir = new File(path);
+		if (!dir.isDirectory()) return null;
+		String[] names = dir.list();
+		ij.util.StringSorter.sort(names);
+		int thisfile = -1;
+		for (int i=0; i<names.length; i++) {
+			if (names[i].equals(imageName)) {
+				thisfile = i;
+				break;
+			}
+		}
+		if (IJ.debugMode) IJ.log("OpenNext.thisfile:" + thisfile);
+		if(thisfile == -1) return null;// can't find current image
+		
+		// make candidate the index of the next file
+		int candidate = thisfile + 1;
+		if (!forward) candidate = thisfile - 1;
+		if (candidate<0) candidate = names.length - 1;
+		if (candidate==names.length) candidate = 0;
+		// keep on going until an image file is found or we get back to beginning
+		while (candidate!=thisfile) {
+			String nextPath = path + names[candidate];
+			if (IJ.debugMode) IJ.log("OpenNext: "+ candidate + "  " + names[candidate]);
+			File nextFile = new File(nextPath);
+			boolean canOpen = true;
+			if (names[candidate].startsWith(".") || nextFile.isDirectory())
+				canOpen = false;
+			if (canOpen) {
+				Opener o = new Opener();
+				int type = o.getFileType(nextPath);
+				if (type==Opener.JAVA_OR_TEXT
+				||  type==Opener.ROI ||  type==Opener.TEXT)
+					canOpen = false;
+			}
+			if (canOpen)
+					return nextPath;
+			else {// increment again
+				if (forward)
+					candidate = candidate + 1;
+				else
+					candidate = candidate - 1;
+				if (candidate<0) candidate = names.length - 1;
+				if (candidate == names.length) candidate = 0;
+			}
+			
+		}
+		if (IJ.debugMode) IJ.log("OpenNext: Search failed");
+		return null;
+	}
+
+}
diff --git a/src/ij/plugin/Options.java b/src/ij/plugin/Options.java
new file mode 100644
index 0000000..457ce2c
--- /dev/null
+++ b/src/ij/plugin/Options.java
@@ -0,0 +1,243 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.io.*;
+import ij.plugin.filter.*;
+import ij.plugin.frame.*;
+import ij.measure.ResultsTable;
+import java.awt.*;
+
+/** This plugin implements most of the commands
+	in the Edit/Options sub-menu. */
+public class Options implements PlugIn {
+
+ 	public void run(String arg) {
+		if (arg.equals("fresh-start"))
+			{freshStart(); return;}
+		if (arg.equals("misc"))
+			{miscOptions(); return;}
+		else if (arg.equals("line"))
+			{lineWidth(); return;}
+		else if (arg.equals("io"))
+			{io(); return;}
+		else if (arg.equals("conv"))
+			{conversions(); return;}
+		else if (arg.equals("dicom"))
+			{dicom(); return;}
+		else if (arg.equals("reset"))
+			{reset(); return;}
+	}
+				
+	// Miscellaneous Options
+	void miscOptions() {
+		String key = IJ.isMacintosh()?"command":"control";
+		GenericDialog gd = new GenericDialog("Miscellaneous Options");
+		gd.addStringField("Divide by zero value:", ""+FloatBlitter.divideByZeroValue, 10);
+		gd.addCheckbox("Use pointer cursor", Prefs.usePointerCursor);
+		gd.addCheckbox("Hide \"Process Stack?\" dialog", IJ.hideProcessStackDialog);
+		gd.addCheckbox("Require "+key+" key for shortcuts", Prefs.requireControlKey);
+		gd.addCheckbox("Move isolated plugins to Misc. menu", Prefs.moveToMisc);
+		if (!IJ.isMacOSX())
+			gd.addCheckbox("Run single instance listener", Prefs.runSocketListener);
+		gd.addCheckbox("Enhanced line tool", Prefs.enhancedLineTool);
+		gd.addCheckbox("Reverse CZT order of \">\" and \"<\"", Prefs.reverseNextPreviousOrder);
+		if (IJ.isMacOSX())
+			gd.addCheckbox("Don't set Mac menu bar", !Prefs.setIJMenuBar);
+		if (IJ.isLinux())
+			gd.addCheckbox("Save window locations", !Prefs.doNotSaveWindowLocations);
+		gd.addCheckbox("Non-blocking filter dialogs", Prefs.nonBlockingFilterDialogs);
+		gd.addCheckbox("Debug mode", IJ.debugMode);
+		//gd.addCheckbox("Modern mode", Prefs.modernMode);
+		gd.addHelp(IJ.URL+"/docs/menus/edit.html#misc");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+			
+		String divValue = gd.getNextString();
+		if (divValue.equalsIgnoreCase("infinity") || divValue.equalsIgnoreCase("infinite"))
+			FloatBlitter.divideByZeroValue = Float.POSITIVE_INFINITY;
+		else if (divValue.equalsIgnoreCase("NaN"))
+			FloatBlitter.divideByZeroValue = Float.NaN;
+		else if (divValue.equalsIgnoreCase("max"))
+			FloatBlitter.divideByZeroValue = Float.MAX_VALUE;
+		else {
+			Float f;
+			try {f = new Float(divValue);}
+			catch (NumberFormatException e) {f = null;}
+			if (f!=null)
+				FloatBlitter.divideByZeroValue = f.floatValue();
+		}
+		IJ.register(FloatBlitter.class); 
+			
+		Prefs.usePointerCursor = gd.getNextBoolean();
+		IJ.hideProcessStackDialog = gd.getNextBoolean();
+		Prefs.requireControlKey = gd.getNextBoolean();
+		Prefs.moveToMisc = gd.getNextBoolean();
+		if (!IJ.isMacOSX())
+			Prefs.runSocketListener = gd.getNextBoolean();
+		Prefs.enhancedLineTool = gd.getNextBoolean();
+		Prefs.reverseNextPreviousOrder = gd.getNextBoolean();
+		if (IJ.isMacOSX())
+			Prefs.setIJMenuBar = !gd.getNextBoolean();
+		if (IJ.isLinux())
+			Prefs.doNotSaveWindowLocations = !gd.getNextBoolean();
+		Prefs.nonBlockingFilterDialogs = gd.getNextBoolean();
+		IJ.setDebugMode(gd.getNextBoolean());
+		//Prefs.modernMode = gd.getNextBoolean();
+	}
+
+	void lineWidth() {
+		int width = (int)IJ.getNumber("Line Width:", Line.getWidth());
+		if (width==IJ.CANCELED) return;
+		Line.setWidth(width);
+		LineWidthAdjuster.update();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null && imp.isProcessor()) {
+			ImageProcessor ip = imp.getProcessor();
+			ip.setLineWidth(Line.getWidth());
+            Roi roi = imp.getRoi();
+            if (roi!=null && roi.isLine()) imp.draw();
+		}
+	}
+
+	// Input/Output options
+	void io() {
+		GenericDialog gd = new GenericDialog("I/O Options");
+		gd.addNumericField("JPEG quality (0-100):", FileSaver.getJpegQuality(), 0, 3, "");
+		gd.addNumericField("GIF and PNG transparent index:", Prefs.getTransparentIndex(), 0, 3, "");
+		gd.addStringField("File extension for tables (.csv, .tsv or .txt):", Prefs.defaultResultsExtension(), 4);
+		gd.addCheckbox("Use JFileChooser to open/save", Prefs.useJFileChooser);
+		if (!IJ.isMacOSX())
+			gd.addCheckbox("Use_file chooser to import sequences", Prefs.useFileChooser);
+		gd.addCheckbox("Save TIFF and raw in Intel byte order", Prefs.intelByteOrder);
+		gd.addCheckbox("Skip dialog when opening .raw files", Prefs.skipRawDialog);
+		
+		gd.setInsets(15, 20, 0);
+		gd.addMessage("Results Table Options");
+		gd.setInsets(3, 40, 0);
+		gd.addCheckbox("Copy_column headers", Prefs.copyColumnHeaders);
+		gd.setInsets(0, 40, 0);
+		gd.addCheckbox("Copy_row numbers", !Prefs.noRowNumbers);
+		gd.setInsets(0, 40, 0);
+		gd.addCheckbox("Save_column headers", !Prefs.dontSaveHeaders);
+		gd.setInsets(0, 40, 0);
+		gd.addCheckbox("Save_row numbers", !Prefs.dontSaveRowNumbers);
+		
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		int quality = (int)gd.getNextNumber();
+		if (quality<0) quality = 0;
+		if (quality>100) quality = 100;
+		FileSaver.setJpegQuality(quality);
+		int transparentIndex = (int)gd.getNextNumber();
+		Prefs.setTransparentIndex(transparentIndex);
+		String extension = gd.getNextString();
+		if (!extension.startsWith("."))
+			extension = "." + extension;
+		Prefs.set("options.ext", extension);
+		boolean useJFileChooser2 = Prefs.useJFileChooser;
+		Prefs.useJFileChooser = gd.getNextBoolean();
+		if (Prefs.useJFileChooser!=useJFileChooser2)
+			Prefs.jFileChooserSettingChanged = true;
+		if (!IJ.isMacOSX())
+			Prefs.useFileChooser = gd.getNextBoolean();
+		Prefs.intelByteOrder = gd.getNextBoolean();
+		Prefs.skipRawDialog = gd.getNextBoolean();
+		Prefs.copyColumnHeaders = gd.getNextBoolean();
+		Prefs.noRowNumbers = !gd.getNextBoolean();
+		Prefs.dontSaveHeaders = !gd.getNextBoolean();
+		ResultsTable.getResultsTable().saveColumnHeaders(!Prefs.dontSaveHeaders);
+		Prefs.dontSaveRowNumbers = !gd.getNextBoolean();
+		return;
+	}
+
+	// Conversion Options
+	void conversions() {
+		double[] weights = ColorProcessor.getWeightingFactors();
+		boolean weighted = !(weights[0]==1d/3d && weights[1]==1d/3d && weights[2]==1d/3d);
+		//boolean weighted = !(Math.abs(weights[0]-1d/3d)<0.0001 && Math.abs(weights[1]-1d/3d)<0.0001 && Math.abs(weights[2]-1d/3d)<0.0001);
+		GenericDialog gd = new GenericDialog("Conversion Options");
+		gd.addCheckbox("Scale when converting", ImageConverter.getDoScaling());
+		String prompt = "Weighted RGB conversions";
+		if (weighted)
+			prompt += " (" + IJ.d2s(weights[0]) + "," + IJ.d2s(weights[1]) + ","+ IJ.d2s(weights[2]) + ")";
+		gd.addCheckbox(prompt, weighted);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		ImageConverter.setDoScaling(gd.getNextBoolean());
+		Prefs.weightedColor = gd.getNextBoolean();
+		if (!Prefs.weightedColor)
+			ColorProcessor.setWeightingFactors(1d/3d, 1d/3d, 1d/3d);
+		else if (Prefs.weightedColor && !weighted)
+			ColorProcessor.setWeightingFactors(0.299, 0.587, 0.114);
+		return;
+	}
+			
+	// replaced by AppearanceOptions class
+	void appearance() {
+	}
+
+	// DICOM options
+	void dicom() {
+		GenericDialog gd = new GenericDialog("DICOM Options");
+		gd.addCheckbox("Open as 32-bit float", Prefs.openDicomsAsFloat);
+		gd.addCheckbox("Ignore rescale slope", Prefs.ignoreRescaleSlope);
+		gd.addCheckbox("Fixed Z slope and intercept", Prefs.fixedDicomScaling);
+		gd.addMessage("Orthogonal views");
+		gd.setInsets(5, 40, 0);
+		gd.addCheckbox("Rotate YZ", Prefs.rotateYZ);
+		gd.setInsets(0, 40, 0);
+		gd.addCheckbox("Flip XZ", Prefs.flipXZ);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		Prefs.openDicomsAsFloat = gd.getNextBoolean();
+		Prefs.ignoreRescaleSlope = gd.getNextBoolean();
+		Prefs.fixedDicomScaling = gd.getNextBoolean();
+		Prefs.rotateYZ = gd.getNextBoolean();
+		Prefs.flipXZ = gd.getNextBoolean();
+	}
+		
+	/** Close all images, empty ROI Manager, clear the
+		 Results table, clears the Log window and sets
+		 "Black background" 'true'.
+	*/
+	private void freshStart() {
+		String options = Macro.getOptions();
+		boolean keepImages = false;
+		boolean keepResults = false;
+		boolean keepRois = false;
+		if (options!=null) {
+			options = options.toLowerCase();
+			keepImages = options.contains("images");			
+			keepResults = options.contains("results");			
+			keepRois = options.contains("rois");
+		}
+		if (!keepImages) {
+			if (!Commands.closeAll())
+				return;
+		}
+		if (!keepResults) {
+			if (!Analyzer.resetCounter())
+				return;
+		}
+		if (!keepRois) {
+			RoiManager rm = RoiManager.getInstance();
+			if (rm!=null)
+				rm.reset();
+		}
+		if (WindowManager.getWindow("Log")!=null)
+   			IJ.log("\\Clear");
+		Prefs.blackBackground = true;
+	}
+
+	// Delete preferences file when ImageJ quits
+	private void reset() {
+		if (IJ.showMessageWithCancel("Reset Preferences", "Preferences will be reset when ImageJ restarts."))
+			Prefs.resetPreferences();
+	}
+
+} // class Options
diff --git a/src/ij/plugin/Orthogonal_Views.java b/src/ij/plugin/Orthogonal_Views.java
new file mode 100644
index 0000000..00a2e9e
--- /dev/null
+++ b/src/ij/plugin/Orthogonal_Views.java
@@ -0,0 +1,1002 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.process.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+import java.awt.geom.*;
+import java.util.*;
+ 
+/**
+ * This plugin projects dynamically orthogonal XZ and YZ views of a stack. 
+ * The output images are calibrated, which allows measurements to be performed more easily. 
+ * 
+ * Many thanks to Jerome Mutterer for the code contributions and testing.
+ * Thanks to Wayne Rasband for the code that properly handles the image magnification.
+ * 		
+ * @author Dimiter Prodanov
+ */
+public class Orthogonal_Views implements PlugIn, MouseListener, MouseMotionListener, KeyListener, ActionListener, 
+	ImageListener, WindowListener, AdjustmentListener, MouseWheelListener, FocusListener, CommandListener, Runnable {
+
+	private ImageWindow win;
+	private ImagePlus imp;
+	private boolean rgb;
+	private ImageStack imageStack;
+	private boolean hyperstack;
+	private int currentChannel, currentFrame, currentMode; 
+	private ImageCanvas canvas;
+	private static final int H_ROI=0, H_ZOOM=1;
+	private static boolean sticky=true;
+	private static int xzID, yzID;
+	private static Orthogonal_Views instance;
+	private ImagePlus xz_image, yz_image;
+	/** ImageProcessors for the xz and yz images */
+	private ImageProcessor fp1, fp2;
+	private double ax, ay, az;
+	private boolean rotateYZ = Prefs.rotateYZ;
+	private boolean flipXZ = Prefs.flipXZ;
+	
+	private int xyX, xyY;
+	private Calibration cal, cal_xz, cal_yz;
+	private double magnification=1.0;
+	private Color color = Roi.getColor();
+	private double min, max;
+	private boolean syncZoom = true;
+	private Point crossLoc;
+	private boolean firstTime = true;
+	private static int previousID, previousX, previousY;
+	private Rectangle startingSrcRect;
+	private boolean done;
+	private boolean initialized;
+	private boolean sliceSet;
+	private Thread thread;
+
+	 
+	public void run(String arg) {
+		imp = IJ.getImage();
+		boolean isStack = imp.getStackSize()>1;
+		hyperstack = imp.isHyperStack();
+		if ((hyperstack||imp.isComposite()) && imp.getNSlices()<=1)
+			isStack = false;
+		if (instance!=null) {
+			if (imp==instance.imp) {
+				instance.dispose();
+				return;
+			} else if (isStack) {
+				instance.dispose();
+				if (IJ.isMacro()) IJ.wait(1000);
+			} else {
+				ImageWindow win = instance.imp!=null?instance.imp.getWindow():null;
+				if (win!=null) win.toFront();
+				return;
+			}
+		}
+		if (!isStack) {
+			IJ.error("Othogonal Views", "This command requires a stack, or a hypertack with Z>1.");
+			return;
+		}
+		yz_image = WindowManager.getImage(yzID);
+		rgb = imp.getBitDepth()==24 || hyperstack;
+		int yzBitDepth = hyperstack?24:imp.getBitDepth();
+		if (yz_image==null || yz_image.getHeight()!=imp.getHeight() || yz_image.getBitDepth()!=yzBitDepth)
+			yz_image = imp.createImagePlus();
+		xz_image = WindowManager.getImage(xzID);
+		if (xz_image==null || xz_image.getWidth()!=imp.getWidth() || xz_image.getBitDepth()!=yzBitDepth)
+			xz_image = imp.createImagePlus();
+		instance = this;
+		int mode = imp.getCompositeMode();
+		ImageProcessor ip = mode==IJ.COMPOSITE?new ColorProcessor(imp.getImage()):imp.getProcessor();
+		min = ip.getMin();
+		max = ip.getMax();
+		cal=this.imp.getCalibration();
+		cal_xz = cal.copy();
+		cal_yz = cal.copy();
+		double calx=cal.pixelWidth;
+		double caly=cal.pixelHeight;
+		double calz=cal.pixelDepth;
+		ax = 1.0;
+		ay = caly/calx;
+		az = calz/calx;
+		if (az>100) {
+			IJ.error("Z spacing ("+(int)az+") is too large.");
+			return;
+		}
+		win = imp.getWindow();
+		canvas = win.getCanvas();
+		addListeners(canvas);
+		magnification= canvas.getMagnification();
+		imp.deleteRoi();
+		Rectangle r = canvas.getSrcRect();
+		if (imp.getID()==previousID)
+			crossLoc = new Point(previousX, previousY);
+		else
+			crossLoc = new Point(r.x+r.width/2, r.y+r.height/2);
+		imageStack = getStack();
+		calibrate();
+		if (createProcessors(imageStack)) {
+			if (ip.isColorLut() || ip.isInvertedLut()) {
+				ColorModel cm = ip.getColorModel();
+				fp1.setColorModel(cm);
+				fp2.setColorModel(cm);				
+			}
+			thread = new Thread(this, "Orthogonal Views");
+			thread.start();
+			IJ.wait(100);
+			update();
+		} else
+			dispose();
+	}
+	
+	private ImageStack getStack() {
+		if (imp.isHyperStack()) {
+			int slices = imp.getNSlices();
+			int c=imp.getChannel();
+			int z=imp.getSlice();
+			int t=imp.getFrame();
+			int mode = imp.getCompositeMode();
+			rgb = mode==IJ.COMPOSITE;
+			ColorModel cm = rgb?null:imp.getProcessor().getColorModel();
+			if (cm!=null && fp1!=null && fp1.getBitDepth()!=24) {
+				fp1.setColorModel(cm);
+				fp2.setColorModel(cm);
+			}
+			ImageStack stack = imp.getStack();
+			ImageStack stack2 = new ImageStack(imp.getWidth(), imp.getHeight());
+			for (int i=1; i<=slices; i++) {
+				if (rgb) {
+					imp.setPositionWithoutUpdate(c, i, t);
+					stack2.addSlice(null, new ColorProcessor(imp.getImage()));
+				} else {
+					int index = imp.getStackIndex(c, i, t);
+					stack2.addSlice(null, stack.getProcessor(index));
+				}
+			}
+			if (rgb)
+				imp.setPosition(c, z, t);
+			currentChannel = c;
+			currentFrame = t;
+			currentMode = mode;
+			return stack2;
+		} else
+			return imp.getStack();
+	}
+ 
+	private void addListeners(ImageCanvas canvas) {
+		canvas.addMouseListener(this);
+		canvas.addMouseMotionListener(this);
+		canvas.addKeyListener(this);
+		win.addWindowListener (this);  
+		win.addMouseWheelListener(this);
+		win.addFocusListener(this);
+		ImagePlus.addImageListener(this);
+		Executer.addCommandListener(this);
+	}
+	 
+	private void calibrate() {
+		String xunit = cal.getXUnit();
+		String yunit = cal.getYUnit();
+		String zunit = cal.getZUnit();
+		double o_depth=cal.pixelDepth;
+		double o_height=cal.pixelHeight;
+		double o_width=cal.pixelWidth;
+		cal_yz.setXUnit(zunit);
+		cal_yz.setYUnit(yunit);
+		cal_yz.setZUnit(xunit);
+		if (rotateYZ) {
+			cal_yz.pixelHeight=o_depth/az;
+			cal_yz.pixelWidth=o_height;
+			cal_yz.setXUnit(yunit);
+			cal_yz.setYUnit(zunit);
+		} else {
+			cal_yz.pixelWidth=o_depth/az;
+			cal_yz.pixelHeight=o_height;
+		}
+		if (flipXZ)
+			cal_yz.setInvertY(true);
+		yz_image.setCalibration(cal_yz);
+		yz_image.setIJMenuBar(false);
+		cal_xz.setXUnit(xunit);
+		cal_xz.setYUnit(zunit);
+		cal_xz.setZUnit(yunit);
+		cal_xz.pixelWidth=o_width;
+		cal_xz.pixelHeight=o_depth/az;
+		if (flipXZ)
+			cal_xz.setInvertY(true);
+		xz_image.setCalibration(cal_xz);
+		xz_image.setIJMenuBar(false);
+	}
+
+	private void updateMagnification(int x, int y) {
+        double magnification= win.getCanvas().getMagnification();
+        int z = imp.getSlice()-1;
+        ImageWindow xz_win = xz_image.getWindow();
+        if (xz_win==null) return;
+        ImageCanvas xz_ic = xz_win.getCanvas();
+        double xz_mag = xz_ic.getMagnification();
+        double arat = az/ax;
+		int zcoord=(int)(arat*z);
+		if (flipXZ) zcoord=(int)(arat*(imp.getNSlices()-z));
+        while (xz_mag<magnification) {
+        	xz_ic.zoomIn(xz_ic.screenX(x), xz_ic.screenY(zcoord));
+        	xz_mag = xz_ic.getMagnification();
+        }
+        while (xz_mag>magnification) {
+        	xz_ic.zoomOut(xz_ic.screenX(x), xz_ic.screenY(zcoord));
+        	xz_mag = xz_ic.getMagnification();
+        }
+        ImageWindow yz_win = yz_image.getWindow();
+        if (yz_win==null) return;
+        ImageCanvas yz_ic = yz_win.getCanvas();
+        double yz_mag = yz_ic.getMagnification();
+		zcoord = (int)(arat*z);
+        while (yz_mag<magnification) {
+        	yz_ic.zoomIn(yz_ic.screenX(zcoord), yz_ic.screenY(y));
+        	yz_mag = yz_ic.getMagnification();
+        }
+        while (yz_mag>magnification) {
+        	yz_ic.zoomOut(yz_ic.screenX(zcoord), yz_ic.screenY(y));
+        	yz_mag = yz_ic.getMagnification();
+        }
+	}
+	
+	void updateViews(Point p, ImageStack is) {
+		if (fp1==null) return;
+		updateXZView(p,is);
+		
+		double arat=az/ax;
+		int width2 = fp1.getWidth();
+		int height2 = (int)Math.round(fp1.getHeight()*az);
+		if (height2<1) height2=1;
+		if (width2!=fp1.getWidth()||height2!=fp1.getHeight()) {
+			fp1.setInterpolate(true);
+			ImageProcessor sfp1=fp1.resize(width2, height2);
+			if (!rgb) sfp1.setMinAndMax(min, max);
+			xz_image.setProcessor("XZ "+p.y, sfp1);
+		} else {
+			if (!rgb) fp1.setMinAndMax(min, max);
+	    	xz_image.setProcessor("XZ "+p.y, fp1);
+		}
+			
+		if (rotateYZ)
+			updateYZView(p, is);
+		else
+			updateZYView(p, is);
+				
+		width2 = (int)Math.round(fp2.getWidth()*az);
+		if (width2<1) width2=1;
+		height2 = fp2.getHeight();
+		String title = "YZ ";
+		if (rotateYZ) {
+			width2 = fp2.getWidth();
+			height2 = (int)Math.round(fp2.getHeight()*az);
+			if (height2<1) height2=1;
+			title = "ZY ";
+		}
+		if (width2!=fp2.getWidth()||height2!=fp2.getHeight()) {
+			fp2.setInterpolate(true);
+			ImageProcessor sfp2=fp2.resize(width2, height2);
+			if (!rgb) sfp2.setMinAndMax(min, max);
+			yz_image.setProcessor(title+p.x, sfp2);
+		} else {
+			if (!rgb) fp2.setMinAndMax(min, max);
+			yz_image.setProcessor(title+p.x, fp2);
+		}
+		
+		calibrate();
+		if (yz_image.getWindow()==null) {
+			yz_image.show();
+			ImageCanvas ic = yz_image.getCanvas();
+			ic.addKeyListener(this);
+			ic.addMouseListener(this);
+			ic.addMouseMotionListener(this);
+			ic.setCustomRoi(true);
+			yzID = yz_image.getID();
+		} else {
+			ImageCanvas ic = yz_image.getWindow().getCanvas();
+			ic.setCustomRoi(true);
+		}
+		if (xz_image.getWindow()==null) {
+			xz_image.show();
+			ImageCanvas ic = xz_image.getCanvas();
+			ic.addKeyListener(this);
+			ic.addMouseListener(this);
+			ic.addMouseMotionListener(this);
+			ic.setCustomRoi(true);
+			xzID = xz_image.getID();
+		} else {
+			ImageCanvas ic = xz_image.getWindow().getCanvas();
+			ic.setCustomRoi(true);
+		}
+		 
+	}
+	
+	void arrangeWindows(boolean sticky) {
+		ImageWindow xyWin = imp.getWindow();
+		if (xyWin==null) return;
+		Point loc = xyWin.getLocation();
+		if ((xyX!=loc.x)||(xyY!=loc.y)) {
+			xyX =  loc.x;
+			xyY =  loc.y;
+ 			ImageWindow yzWin =null;
+ 			long start = System.currentTimeMillis();
+ 			while (yzWin==null && (System.currentTimeMillis()-start)<=2500L) {
+				yzWin = yz_image.getWindow();
+				if (yzWin==null) IJ.wait(50);
+			}
+			if (yzWin!=null)
+ 				yzWin.setLocation(xyX+xyWin.getWidth(), xyY);
+			ImageWindow xzWin =null;
+ 			start = System.currentTimeMillis();
+ 			while (xzWin==null && (System.currentTimeMillis()-start)<=2500L) {
+				xzWin = xz_image.getWindow();
+				if (xzWin==null) IJ.wait(50);
+			}
+			if (xzWin!=null)
+ 				xzWin.setLocation(xyX,xyY+xyWin.getHeight());
+ 			if (firstTime) {
+ 				imp.getWindow().toFront();
+ 				if (!sliceSet && imp.getSlice()==1) {
+					if (hyperstack)
+						imp.setPosition(imp.getChannel(), imp.getNSlices()/2, imp.getFrame());
+					else
+						imp.setSlice(imp.getNSlices()/2);
+ 				}
+ 				firstTime = false;
+ 			}
+		}
+	}
+	
+	/**
+	 * @param is - used to get the dimensions of the new ImageProcessors
+	 * @return
+	 */
+	boolean createProcessors(ImageStack is) {
+		ImageProcessor ip=is.getProcessor(1);
+		int width= is.getWidth();
+		int height=is.getHeight();
+		int ds=is.getSize(); 
+		double arat=1.0;//az/ax;
+		double brat=1.0;//az/ay;
+		int za=(int)(ds*arat);
+		int zb=(int)(ds*brat);
+		
+		if (ip instanceof FloatProcessor) {
+			fp1=new FloatProcessor(width,za);
+			if (rotateYZ)
+				fp2=new FloatProcessor(height,zb);
+			else
+				fp2=new FloatProcessor(zb,height);
+			return true;
+		}
+		
+		if (ip instanceof ByteProcessor) {
+			fp1=new ByteProcessor(width,za);
+			if (rotateYZ)
+				fp2=new ByteProcessor(height,zb);
+			else
+				fp2=new ByteProcessor(zb,height);
+			return true;
+		}
+		
+		if (ip instanceof ShortProcessor) {
+			fp1=new ShortProcessor(width,za);
+			if (rotateYZ)
+				fp2=new ShortProcessor(height,zb);
+			else
+				fp2=new ShortProcessor(zb,height);
+			return true;
+		}
+		
+		if (ip instanceof ColorProcessor) {
+			fp1=new ColorProcessor(width,za);
+			if (rotateYZ)
+				fp2=new ColorProcessor(height,zb);
+			else
+				fp2=new ColorProcessor(zb,height);
+			return true;
+		}
+		
+		return false;
+	}
+	
+	void updateXZView(Point p, ImageStack is) {
+		int width= is.getWidth();
+		int size=is.getSize();
+		ImageProcessor ip=is.getProcessor(1);
+		
+		int y=p.y;
+		// XZ
+		if (ip instanceof ShortProcessor) {
+			short[] newpix=new short[width*size];
+			for (int i=0; i<size; i++) { 
+				Object pixels=is.getPixels(i+1);
+				if (flipXZ)
+					System.arraycopy(pixels, width*y, newpix, width*(size-i-1), width);
+				else
+					System.arraycopy(pixels, width*y, newpix, width*i, width);
+			}
+			fp1.setPixels(newpix);
+			return;
+		}
+		
+		if (ip instanceof ByteProcessor) {
+			byte[] newpix=new byte[width*size];
+			for (int i=0;i<size; i++) { 
+				Object pixels=is.getPixels(i+1);
+				if (flipXZ)
+					System.arraycopy(pixels, width*y, newpix, width*(size-i-1), width);
+				else
+					System.arraycopy(pixels, width*y, newpix, width*i, width);
+			}
+			fp1.setPixels(newpix);
+			return;
+		}
+		
+		if (ip instanceof FloatProcessor) {
+			float[] newpix=new float[width*size];
+			for (int i=0; i<size; i++) { 
+				Object pixels=is.getPixels(i+1);
+				if (flipXZ)
+					System.arraycopy(pixels, width*y, newpix, width*(size-i-1), width);
+				else
+					System.arraycopy(pixels, width*y, newpix, width*i, width);
+			}
+			fp1.setPixels(newpix);
+			return;
+		}
+		
+		if (ip instanceof ColorProcessor) {
+			int[] newpix=new int[width*size];
+			for (int i=0;i<size; i++) { 
+				Object pixels=is.getPixels(i+1);
+				if (flipXZ)
+					System.arraycopy(pixels, width*y, newpix, width*(size-i-1), width);
+				else
+					System.arraycopy(pixels, width*y, newpix, width*i, width);
+			}
+			fp1.setPixels(newpix);
+			return;
+		}
+		
+	}
+	
+	void updateYZView(Point p, ImageStack is) {
+		int width= is.getWidth();
+		int height=is.getHeight();
+		int ds=is.getSize();
+		ImageProcessor ip=is.getProcessor(1);
+		int x=p.x;
+		
+		if (ip instanceof FloatProcessor) {
+			float[] newpix=new float[ds*height];
+			for (int i=0;i<ds; i++) { 
+				float[] pixels= (float[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int j=0;j<height;j++)
+					newpix[(ds-i-1)*height + j] = pixels[x + j* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		
+		if (ip instanceof ByteProcessor) {
+			byte[] newpix=new byte[ds*height];
+			for (int i=0;i<ds; i++) { 
+				byte[] pixels= (byte[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int j=0;j<height;j++)
+					newpix[(ds-i-1)*height + j] = pixels[x + j* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		
+		if (ip instanceof ShortProcessor) {
+			short[] newpix=new short[ds*height];
+			for (int i=0;i<ds; i++) { 
+				short[] pixels= (short[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int j=0;j<height;j++)
+					newpix[(ds-i-1)*height + j] = pixels[x + j* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		
+		if (ip instanceof ColorProcessor) {
+			int[] newpix=new int[ds*height];
+			for (int i=0;i<ds; i++) { 
+				int[] pixels= (int[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int j=0;j<height;j++)
+					newpix[(ds-i-1)*height + j] = pixels[x + j* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		if (!flipXZ)
+			fp2.flipVertical();
+		
+	}
+	
+	void updateZYView(Point p, ImageStack is) {
+		int width= is.getWidth();
+		int height=is.getHeight();
+		int ds=is.getSize();
+		ImageProcessor ip=is.getProcessor(1);
+		int x=p.x;
+		
+		if (ip instanceof FloatProcessor) {
+			float[] newpix=new float[ds*height];
+			for (int i=0;i<ds; i++) { 
+				float[] pixels= (float[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int y=0;y<height;y++)
+					newpix[i + y*ds] = pixels[x + y* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		
+		if (ip instanceof ByteProcessor) {
+			byte[] newpix=new byte[ds*height];
+			for (int i=0;i<ds; i++) { 
+				byte[] pixels= (byte[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int y=0;y<height;y++)
+					newpix[i + y*ds] = pixels[x + y* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		
+		if (ip instanceof ShortProcessor) {
+			short[] newpix=new short[ds*height];
+			for (int i=0;i<ds; i++) { 
+				short[] pixels= (short[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int y=0;y<height;y++)
+					newpix[i + y*ds] = pixels[x + y* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		
+		if (ip instanceof ColorProcessor) {
+			int[] newpix=new int[ds*height];
+			for (int i=0;i<ds; i++) { 
+				int[] pixels= (int[]) is.getPixels(i+1);//toFloatPixels(pixels);
+				for (int y=0;y<height;y++)
+					newpix[i + y*ds] = pixels[x + y* width];
+			}
+			fp2.setPixels(newpix);
+		}
+		
+	}
+	 
+	/** draws the crosses in the images */
+	void drawCross(ImagePlus imp, Point p, GeneralPath path) {
+		int width=imp.getWidth();
+		int height=imp.getHeight();
+		float x = p.x;
+		float y = p.y;
+		path.moveTo(0f, y);
+		path.lineTo(width, y);
+		path.moveTo(x, 0f);
+		path.lineTo(x, height);	
+	}
+	
+	void dispose() {
+		synchronized(this) {
+			done = true;
+			notify();
+		}
+		imp.setOverlay(null);
+		if (canvas!=null) {
+			canvas.removeMouseListener(this);
+			canvas.removeMouseMotionListener(this);
+			canvas.removeKeyListener(this);
+			canvas.setCustomRoi(false);
+		}
+		xz_image.setOverlay(null);
+		ImageWindow win1 = xz_image.getWindow();
+		if (win1!=null) {
+			win1.removeMouseWheelListener(this);
+			ImageCanvas ic = win1.getCanvas();
+			if (ic!=null) {
+				ic.removeKeyListener(this);
+				ic.removeMouseListener(this);
+				ic.removeMouseMotionListener(this);
+				ic.setCustomRoi(false);
+			}
+		}
+		xz_image.changes = false;
+		xz_image.close();
+		yz_image.setOverlay(null);
+		ImageWindow win2 = yz_image.getWindow();
+		if (win2!=null) {
+			win2.removeMouseWheelListener(this);
+			ImageCanvas ic = win2.getCanvas();
+			if (ic!=null) {
+				ic.removeKeyListener(this);
+				ic.removeMouseListener(this);
+				ic.removeMouseMotionListener(this);
+				ic.setCustomRoi(false);
+			}
+		}
+		yz_image.changes = false;
+		yz_image.close();
+		ImagePlus.removeImageListener(this);
+		Executer.removeCommandListener(this);
+		win.removeWindowListener(this);
+		win.removeMouseWheelListener(this);
+		win.removeFocusListener(this);
+		win.setResizable(true);
+		instance = null;
+		previousID = imp.getID();
+		previousX = crossLoc.x;
+		previousY = crossLoc.y;
+		imageStack = null;
+	}
+	
+	public void mouseClicked(MouseEvent e) {
+	}
+
+	public void mouseEntered(MouseEvent e) {
+	}
+
+	public void mouseExited(MouseEvent e) {
+	}
+
+	public void mousePressed(MouseEvent e) {
+		ImageCanvas xyCanvas = imp.getCanvas();
+		startingSrcRect = (Rectangle)xyCanvas.getSrcRect().clone();
+		mouseDragged(e);
+	}
+
+	public void mouseDragged(MouseEvent e) {
+		if (IJ.spaceBarDown())  // scrolling?
+			return;
+		if (e.getSource().equals(canvas)) {
+			crossLoc = canvas.getCursorLoc();
+		} else if (e.getSource().equals(xz_image.getCanvas())) {
+			crossLoc.x = xz_image.getCanvas().getCursorLoc().x;
+			int pos = xz_image.getCanvas().getCursorLoc().y;
+			int z = (int)Math.round(pos/az);
+			int slice = flipXZ?imp.getNSlices()-z:z+1;
+			if (hyperstack)
+				imp.setPosition(imp.getChannel(), slice, imp.getFrame());
+			else
+				imp.setSlice(slice);
+		} else if (e.getSource().equals(yz_image.getCanvas())) {
+			int pos;
+			if (rotateYZ) {
+				crossLoc.y = yz_image.getCanvas().getCursorLoc().x;
+				pos = yz_image.getCanvas().getCursorLoc().y;
+			} else {
+				crossLoc.y = yz_image.getCanvas().getCursorLoc().y;
+				pos = yz_image.getCanvas().getCursorLoc().x;
+			}
+			int z = (int)Math.round(pos/az);
+			int slice = flipXZ?imp.getNSlices()-z:z+1;
+			if (hyperstack)
+				imp.setPosition(imp.getChannel(), slice, imp.getFrame());
+			else
+				imp.setSlice(slice);
+		}
+		update();
+	}
+
+	public void mouseReleased(MouseEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		Rectangle srcRect = ic.getSrcRect();
+		if (srcRect.x!=startingSrcRect.x || srcRect.y!=startingSrcRect.y) {
+			// user has scrolled xy image
+			int dy = srcRect.y - startingSrcRect.y;
+			ImageCanvas yzic = yz_image.getCanvas();
+			Rectangle yzSrcRect =yzic.getSrcRect();
+			if (rotateYZ) {
+				yzSrcRect.x += dy;
+				if (yzSrcRect.x<0)
+					yzSrcRect.x = 0;
+				if (yzSrcRect.x>yz_image.getWidth()-yzSrcRect.width)
+					yzSrcRect.y = yz_image.getWidth()-yzSrcRect.width;
+			} else {
+				yzSrcRect.y += dy;
+				if (yzSrcRect.y<0)
+					yzSrcRect.y = 0;
+				if (yzSrcRect.y>yz_image.getHeight()-yzSrcRect.height)
+					yzSrcRect.y = yz_image.getHeight()-yzSrcRect.height;
+			}
+			yzic.repaint();
+			int dx = srcRect.x - startingSrcRect.x;
+			ImageCanvas xzic = xz_image.getCanvas();
+			Rectangle xzSrcRect =xzic.getSrcRect();
+			xzSrcRect.x += dx;
+			if (xzSrcRect.x<0)
+				xzSrcRect.x = 0;
+			if (xzSrcRect.x>xz_image.getWidth()-xzSrcRect.width)
+				xzSrcRect.x = xz_image.getWidth()-xzSrcRect.width;
+			xzic.repaint();
+		}
+	}
+	
+	/** Refresh the output windows. */
+	synchronized void update() {
+		notify();
+	}
+	
+	private void exec() {
+		if (canvas==null)
+			return;
+		int width=imp.getWidth();
+		int height=imp.getHeight();
+		if (hyperstack) {
+			int mode = IJ.COMPOSITE;
+			if (imp.isComposite()) {
+				mode = ((CompositeImage)imp).getMode();
+				if (mode!=currentMode)
+					imageStack = null;
+			}
+			if (imageStack!=null) {
+				int c = imp.getChannel();
+				int t = imp.getFrame();
+				if ((mode!=IJ.COMPOSITE&&c!=currentChannel) || t!=currentFrame)
+					imageStack = null;
+			}
+		}
+		ImageStack is = imageStack;
+		if (is==null)
+			is = imageStack = getStack();
+		double arat=az/ax;
+		double brat=az/ay;
+		Point p=crossLoc;
+		if (p.y>=height) p.y=height-1;
+		if (p.x>=width) p.x=width-1;
+		if (p.x<0) p.x=0;
+		if (p.y<0) p.y=0;
+		updateViews(p, is);
+		GeneralPath path = new GeneralPath();
+		drawCross(imp, p, path);
+		if (!done)
+			imp.setOverlay(path, color, new BasicStroke(1));
+		canvas.setCustomRoi(true);
+		updateCrosses(p.x, p.y, arat, brat);
+		if (syncZoom) updateMagnification(p.x, p.y);
+		arrangeWindows(sticky);
+		initialized = true;
+	}
+
+	private void updateCrosses(int x, int y, double arat, double brat) {
+		Point p;
+		int z=imp.getNSlices();
+		int zlice=imp.getSlice()-1;
+		int zcoord=(int)Math.round(arat*zlice);
+		if (flipXZ)
+			zcoord = (int)Math.round(arat*(z-zlice));		
+		ImageCanvas xzCanvas = xz_image.getCanvas();
+		p=new Point (x, zcoord);
+		GeneralPath path = new GeneralPath();
+		drawCross(xz_image, p, path);
+		if (!done)
+			xz_image.setOverlay(path, color, new BasicStroke(1));
+		if (rotateYZ) {
+			if (flipXZ)
+				zcoord=(int)Math.round(brat*(z-zlice));
+			else
+				zcoord=(int)Math.round(brat*(zlice));			
+			p=new Point (y, zcoord);
+		} else {
+			zcoord=(int)Math.round(arat*zlice);
+			p=new Point (zcoord, y);
+		}
+		path = new GeneralPath();
+		drawCross(yz_image, p, path);
+		if (!done)
+			yz_image.setOverlay(path, color, new BasicStroke(1));
+		IJ.showStatus(imp.getLocationAsString(crossLoc.x, crossLoc.y));
+	}
+
+	public void mouseMoved(MouseEvent e) {
+	}
+
+	public void keyPressed(KeyEvent e) {
+		int key = e.getKeyCode();
+		if (key==KeyEvent.VK_ESCAPE) {
+			IJ.beep();
+			dispose();
+		} else if (IJ.shiftKeyDown()) {
+			int width=imp.getWidth(), height=imp.getHeight();
+			switch (key) {
+				case KeyEvent.VK_LEFT: crossLoc.x--; if (crossLoc.x<0) crossLoc.x=0; break;
+				case KeyEvent.VK_RIGHT: crossLoc.x++; if (crossLoc.x>=width) crossLoc.x=width-1; break;
+				case KeyEvent.VK_UP: crossLoc.y--; if (crossLoc.y<0) crossLoc.y=0; break;
+				case KeyEvent.VK_DOWN: crossLoc.y++; if (crossLoc.y>=height) crossLoc.y=height-1; break;
+				default: return;
+			}
+			update();
+		}
+	}
+
+	public void keyReleased(KeyEvent e) {
+	}
+
+	public void keyTyped(KeyEvent e) {
+	}
+
+	public void actionPerformed(ActionEvent ev) {
+	}
+
+	public void imageClosed(ImagePlus imp) {
+		if (!done)
+			dispose();
+	}
+
+	public void imageOpened(ImagePlus imp) {
+	}
+
+	public void imageUpdated(ImagePlus imp) {
+		if (imp==this.imp) {
+			ImageProcessor ip = imp.getProcessor();
+			min = ip.getMin();
+			max = ip.getMax();
+			update();
+		}
+	}
+
+	public String commandExecuting(String command) {
+		if (command.equals("In")||command.equals("Out")) {
+			ImagePlus cimp = WindowManager.getCurrentImage();
+			if (cimp==null) return command;
+			if (cimp==imp) {
+				ImageCanvas ic = imp.getCanvas();
+				if (ic==null) return null;
+				int x = ic.screenX(crossLoc.x);
+				int y = ic.screenY(crossLoc.y);
+				if (command.equals("In")) {
+					ic.zoomIn(x, y);
+					if (ic.getMagnification()<=1.0) imp.repaintWindow();
+				} else {
+					ic.zoomOut(x, y);
+					if (ic.getMagnification()<1.0) imp.repaintWindow();
+				}
+				xyX=crossLoc.x; xyY=crossLoc.y;
+				update();
+				return null;
+			} else if (cimp==xz_image || cimp==yz_image) {
+				syncZoom = false;
+				return command;
+			} else
+				return command;
+		} else if (command.equals("Flip Vertically")&& xz_image!=null) {
+			if (xz_image==WindowManager.getCurrentImage()) {
+				flipXZ = !flipXZ;
+				update();
+				return null;
+			} else
+				return command;
+		} else
+			return command;
+	}
+
+	public void windowActivated(WindowEvent e) {
+		 arrangeWindows(sticky);
+	}
+
+	public void windowClosed(WindowEvent e) {
+	}
+
+	public void windowClosing(WindowEvent e) {
+		if (!done)
+			dispose();		
+	}
+
+	public void windowDeactivated(WindowEvent e) {
+	}
+
+	public void windowDeiconified(WindowEvent e) {
+		 arrangeWindows(sticky);
+	}
+
+	public void windowIconified(WindowEvent e) {
+	}
+
+	public void windowOpened(WindowEvent e) {
+	}
+
+	public void adjustmentValueChanged(AdjustmentEvent e) {
+		update();
+	}
+		
+	public void mouseWheelMoved(MouseWheelEvent e) {
+		if (e.getSource().equals(xz_image.getWindow())) {
+			crossLoc.y += e.getWheelRotation();
+		} else if (e.getSource().equals(yz_image.getWindow())) {
+			crossLoc.x += e.getWheelRotation();
+		}
+		update();
+	}
+
+	public void focusGained(FocusEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		if (ic!=null) canvas.requestFocus();
+		arrangeWindows(sticky);
+	}
+
+	public void focusLost(FocusEvent e) {
+		arrangeWindows(sticky);
+	}
+	
+	public static ImagePlus getImage() {
+		if (instance!=null)
+			return instance.imp;
+		else
+			return null;
+	}
+	
+	public static int getImageID() {
+		ImagePlus img = getImage();
+		return img!=null?img.getID():0;
+	}
+
+	/** Returns the IDs of the XY, YZ and XZ images as an int array.*/
+	public static int[] getImageIDs() {
+		int[] ids = new int[3];
+		Orthogonal_Views instance2 = getInstance();
+		if (instance2==null)
+			return ids;
+		ids[0] = instance2.imp.getID();
+		ids[1] = instance2.yz_image.getID();
+		ids[2] = instance2.xz_image.getID();
+		return ids;
+	}
+
+ 	public static void stop() {
+		if (instance!=null)
+			instance.dispose();
+	}
+
+	public static synchronized boolean isOrthoViewsImage(ImagePlus imp) {
+		if (imp==null || instance==null)
+			return false;
+		else
+			return imp==instance.imp || imp==instance.xz_image || imp==instance.yz_image;
+	}
+
+	public static Orthogonal_Views getInstance() {
+		return instance;
+	}
+
+	public int[] getCrossLoc() {
+		int[] loc = new int[3];
+		loc[0] = crossLoc.x;
+		loc[1] = crossLoc.y;
+		loc[2] = imp.getSlice()-1;
+		return loc;
+	}
+	
+	public void setCrossLoc(int x, int y, int z) {
+		crossLoc.setLocation(x, y);
+		int slice = z+1;
+		if (slice!=imp.getSlice()) {
+			if (hyperstack)
+				imp.setPosition(imp.getChannel(), slice, imp.getFrame());
+			else
+				imp.setSlice(slice);
+			sliceSet = true;
+		}
+		while (!initialized) {
+			IJ.wait(10);
+		}
+		update();
+	}
+	
+	public ImagePlus getXZImage(){
+		return xz_image;
+	}
+	
+	public ImagePlus getYZImage(){
+		return yz_image;
+	}
+	
+	public void run() {
+		while (!done) {
+			synchronized(this) {
+				try {wait();}
+				catch(InterruptedException e) {}
+			}
+			if (!done)
+				exec();
+		}
+	}
+
+}
diff --git a/src/ij/plugin/OverlayCommands.java b/src/ij/plugin/OverlayCommands.java
new file mode 100644
index 0000000..3c97fc4
--- /dev/null
+++ b/src/ij/plugin/OverlayCommands.java
@@ -0,0 +1,465 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.frame.RoiManager;
+import ij.plugin.frame.Recorder;
+import ij.macro.Interpreter;
+import ij.io.RoiDecoder;
+import ij.plugin.filter.PlugInFilter;
+import ij.measure.*;
+import java.awt.*;
+import java.util.ArrayList;
+import java.awt.geom.Rectangle2D;
+
+/** This plugin implements the commands in the Image/Overlay menu. */
+public class OverlayCommands implements PlugIn {
+	private static int opacity = 100;
+	private static Roi defaultRoi;
+	private static boolean zeroTransparent;
+	
+	static {
+		defaultRoi = new Roi(0, 0, 1, 1);
+		defaultRoi.setPosition(1); // set stacks positions by default
+	}
+
+	public void run(String arg) {
+		if (arg.equals("add"))
+			addSelection();
+		else if (arg.equals("image"))
+			addImage(false);
+		else if (arg.equals("image-roi"))
+			addImage(true);
+		else if (arg.equals("flatten"))
+			flatten();
+		else if (arg.equals("hide"))
+			hide();
+		else if (arg.equals("show"))
+			show();
+		else if (arg.equals("remove"))
+			remove();
+		else if (arg.equals("from"))
+			fromRoiManager();
+		else if (arg.equals("to"))
+			toRoiManager();
+		else if (arg.equals("list"))
+			list();
+		else if (arg.equals("measure"))
+			measure();
+		else if (arg.equals("options"))
+			options();
+	}
+	
+	private void measure() {
+		ImagePlus imp = IJ.getImage();
+		if (imp==null)
+			return;
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null) {
+			IJ.error("Overlay required");
+			return;
+		}
+		Roi roi0 = imp.getRoi();
+		Roi roi1 = roi0;
+		if (roi0!=null && !roi0.isArea())
+			roi0 = null;
+		boolean isPoints = false;
+		for (int i=0; i<overlay.size(); i++) {
+			Roi roi = (Roi)overlay.get(i).clone();
+			if (roi0!=null && roi instanceof PointRoi) {
+				isPoints = true;
+				PointRoi croppedRoi = ((PointRoi)roi).crop(roi0);
+				imp.setRoi(croppedRoi);
+				IJ.run(imp, "Measure", "");
+			} else {
+				imp.setRoi(roi);
+				ImageStatistics stats = null;
+				if (roi0!=null) {
+					ImageProcessor ip = imp.getProcessor();
+					stats = ImageStatistics.getStatistics(ip, Measurements.CENTROID, null);
+				}
+				if (stats==null || roi0.contains((int)stats.xCentroid,(int)stats.yCentroid)) {
+					if (stats!=null)
+						roi.setFillColor(Color.cyan);
+					IJ.run(imp, "Measure", "");
+				}
+			}
+		}
+		imp.setRoi(roi1);
+		if (roi0!=null && !IJ.isMacro() && !isPoints) {
+			IJ.wait(3000);
+			for (int i=0; i<overlay.size(); i++)
+				overlay.get(i).setFillColor(null);
+			imp.draw();
+		}
+	}
+			
+	void addSelection() {
+		ImagePlus imp = IJ.getImage();
+		String macroOptions = Macro.getOptions();
+		if (macroOptions!=null && IJ.macroRunning() && macroOptions.indexOf("remove")!=-1) {
+			imp.setOverlay(null);
+			return;
+		}
+		Roi roi = imp.getRoi();
+		if (roi==null && imp.getOverlay()!=null) {
+			GenericDialog gd = new GenericDialog("No Selection");
+			gd.addMessage("\"Overlay>Add\" requires a selection.");
+			gd.setInsets(15, 40, 0);
+			gd.addCheckbox("Remove existing overlay", false);
+			gd.showDialog();
+			if (gd.wasCanceled()) return;
+			if (gd.getNextBoolean())
+				imp.setOverlay(null);
+			return;
+ 		}
+		if (roi==null) {
+			IJ.error("This command requires a selection.");
+			return;
+		}
+		roi = (Roi)roi.clone();
+		Overlay overlay = imp.getOverlay();
+		if (!roi.isDrawingTool()) {
+			if (roi.getStroke()==null)
+				roi.setStrokeWidth(defaultRoi.getStrokeWidth());
+			if (roi.getStrokeColor()==null || Line.getWidth()>1&&defaultRoi.getStrokeColor()!=null)
+				roi.setStrokeColor(defaultRoi.getStrokeColor());
+			if (roi.getFillColor()==null)
+				roi.setFillColor(defaultRoi.getFillColor());
+		}
+		setPosition(imp, roi);
+		boolean points = roi instanceof PointRoi && ((PolygonRoi)roi).getNCoordinates()>1;
+		if (IJ.altKeyDown() || (IJ.macroRunning() && Macro.getOptions()!=null)) {
+			RoiProperties rp = new RoiProperties("Add to Overlay", roi);
+			if (!rp.showDialog()) return;
+			defaultRoi.setStrokeColor(roi.getStrokeColor());
+			defaultRoi.setStrokeWidth(roi.getStrokeWidth());
+			defaultRoi.setFillColor(roi.getFillColor());
+		}
+		String name = roi.getName();
+		boolean newOverlay = name!=null && name.equals("new-overlay");
+		Roi roiClone = (Roi)roi.clone();
+		if (roi.getStrokeColor()==null)
+			roi.setStrokeColor(Roi.getColor());
+		if (overlay==null || newOverlay)
+			overlay = OverlayLabels.createOverlay();
+		overlay.add(roi);
+		imp.setOverlay(overlay);
+		boolean brushRoi = roi.getType()==Roi.COMPOSITE && Toolbar.getToolId()==Toolbar.OVAL && Toolbar.getBrushSize()>0;
+		if (points || (roi instanceof ImageRoi) || (roi instanceof Arrow&&!Prefs.keepArrowSelections) || brushRoi)
+			imp.deleteRoi();
+		Undo.setup(Undo.OVERLAY_ADDITION, imp);
+	}
+	
+	void addImage(boolean createImageRoi) {
+		ImagePlus imp = IJ.getImage();
+		int[] wList = WindowManager.getIDList();
+		if (wList==null || wList.length<2) {
+			IJ.error("Add Image...", "The command requires at least two open images.");
+			return;
+		}
+		String[] titles = new String[wList.length];
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp2 = WindowManager.getImage(wList[i]);
+			titles[i] = imp2!=null?imp2.getTitle():"";
+		}
+		int x=0, y=0;
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.isArea()) {
+			Rectangle r = roi.getBounds();
+			x = r.x; y = r.y;
+		}
+		int index = 0;
+		if (wList.length==2) {
+			ImagePlus i1 = WindowManager.getImage(wList[0]);
+			ImagePlus i2 = WindowManager.getImage(wList[1]);
+			if (i2.getWidth()<i1.getWidth() && i2.getHeight()<i1.getHeight())
+				index = 1;
+		} else if (imp.getID()==wList[0])
+			index = 1;
+
+		String title = createImageRoi?"Create Image ROI":"Add Image...";
+		if (IJ.isMacro()) {
+			opacity = 100;
+			zeroTransparent = false;
+		}
+		GenericDialog gd = new GenericDialog(title);
+		if (createImageRoi)
+			gd.addChoice("Image:", titles, titles[index]);
+		else {
+			gd.addChoice("Image to add:", titles, titles[index]);
+			gd.addNumericField("X location:", x, 0);
+			gd.addNumericField("Y location:", y, 0);
+		}
+		gd.addNumericField("Opacity (0-100%):", opacity, 0);
+		gd.addCheckbox("Zero transparent", zeroTransparent);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		index = gd.getNextChoiceIndex();
+		if (!createImageRoi) {
+			x = (int)gd.getNextNumber();
+			y = (int)gd.getNextNumber();
+		}
+		opacity = (int)gd.getNextNumber();
+		zeroTransparent = gd.getNextBoolean();
+		ImagePlus overlay = WindowManager.getImage(wList[index]);
+		if (wList.length==2) {
+			ImagePlus i1 = WindowManager.getImage(wList[0]);
+			ImagePlus i2 = WindowManager.getImage(wList[1]);
+			if (i2.getWidth()<i1.getWidth() && i2.getHeight()<i1.getHeight()) {
+				imp = i1;
+				overlay = i2;
+			}
+		}
+		if (overlay==imp) {
+			IJ.error("Add Image...", "Image to be added cannot be the same as\n\""+imp.getTitle()+"\".");
+			return;
+		}
+		if (overlay.getWidth()>imp.getWidth() && overlay.getHeight()>imp.getHeight()) {
+			IJ.error("Add Image...", "Image to be added cannnot be larger than\n\""+imp.getTitle()+"\".");
+			return;
+		}
+		if (createImageRoi && x==0 && y==0) {
+			x = imp.getWidth()/2-overlay.getWidth()/2;
+			y = imp.getHeight()/2-overlay.getHeight()/2;
+		}	
+		roi = new ImageRoi(x, y, overlay.getProcessor());
+		roi.setName(overlay.getShortTitle());
+		if (opacity!=100)
+			((ImageRoi)roi).setOpacity(opacity/100.0);
+		((ImageRoi)roi).setZeroTransparent(zeroTransparent);
+		if (createImageRoi)
+			imp.setRoi(roi);
+		else {
+			setPosition(imp, roi);
+			Overlay overlayList = imp.getOverlay();
+			if (overlayList==null)
+				overlayList = new Overlay();
+			overlayList.add(roi);
+			imp.setOverlay(overlayList);
+			Undo.setup(Undo.OVERLAY_ADDITION, imp);
+		}
+	}
+	
+	private void setPosition(ImagePlus imp, Roi roi) {
+		int stackSize = imp.getStackSize();
+		if (roi.hasHyperStackPosition() && imp.isHyperStack())
+			return;
+		if (roi.getPosition()>0 && stackSize>1)
+			return;
+		boolean setPos = defaultRoi.getPosition()!=0;
+		if (setPos && stackSize>1) {
+			if (imp.isHyperStack()||imp.isComposite()) {
+				boolean compositeMode = imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.COMPOSITE;
+				int channel = !compositeMode||imp.getNChannels()==stackSize?imp.getChannel():0;
+				if (imp.getNSlices()>1)
+					roi.setPosition(channel, imp.getSlice(), 0);
+				else if (imp.getNFrames()>1)
+					roi.setPosition(channel, 0, imp.getFrame());
+			} else
+				roi.setPosition(imp.getCurrentSlice());
+		}
+	}
+
+	void hide() {
+		ImagePlus imp = IJ.getImage();
+		imp.setHideOverlay(true);
+		RoiManager rm = RoiManager.getInstance();
+		if (rm!=null) rm.runCommand("show none");
+	}
+
+	void show() {
+		ImagePlus imp = IJ.getImage();
+		imp.setHideOverlay(false);
+		if (imp.getOverlay()==null) {
+			RoiManager rm = RoiManager.getInstance();
+			if (rm!=null && rm.getCount()>1) {
+				if (!IJ.isMacro()) rm.toFront();
+				rm.runCommand("show all with labels");
+			}
+		}
+	}
+
+	void remove() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			ImageCanvas ic = imp.getCanvas();
+			if (ic!=null)
+				ic.setShowAllList(null);
+			imp.setOverlay(null);
+		}
+	}
+
+	void flatten() {
+		ImagePlus imp = IJ.getImage();
+		Roi roi = imp.getRoi();
+		if (imp.getStackSize()>1 && roi!=null && (roi instanceof PointRoi)) {
+			ImagePlus imp2 = imp.flatten();
+			imp2.setTitle(WindowManager.getUniqueName(imp.getTitle()));
+			imp2.show();
+			return;
+		}
+		Overlay overlay = imp.getOverlay();
+		Overlay roiManagerOverlay = null;
+		ImageCanvas ic = imp.getCanvas();
+		if (ic!=null)
+			roiManagerOverlay = ic.getShowAllList();
+		if (imp.getBitDepth()==24 && overlay==null && imp.getRoi()==null && roiManagerOverlay==null && !imp.isComposite() && !IJ.macroRunning()) {
+			IJ.error("Flatten", "Overlay or selection required to flatten RGB image");
+			return;
+		}
+		int flags = IJ.setupDialog(imp, 0);
+		if (flags==PlugInFilter.DONE)
+			return;
+		else if (flags==PlugInFilter.DOES_STACKS && !(imp.isComposite()&&overlay==null)) {
+			//Added by Marcel Boeglin 2014.01.24
+			if (overlay==null && roiManagerOverlay==null && !imp.isComposite()) {
+				IJ.error("Flatten", "Overlay or multi-channel image required");
+				return;
+			}
+			flattenStack(imp);
+			if (Recorder.record)
+				Recorder.recordCall("imp.flattenStack();");
+		} else {
+			ImagePlus imp2 = imp.flatten();
+			imp2.setTitle(WindowManager.getUniqueName(imp.getTitle()));
+			imp2.show();
+			if (Recorder.record) // Added by Marcel Boeglin 2014.01.12
+				Recorder.recordCall("imp = imp.flatten();");
+		}
+	}
+
+
+	//Marcel Boeglin 2014.01.25
+	void flattenStack(ImagePlus imp) {
+		imp.flattenStack();
+	}
+	
+	void fromRoiManager() {
+		ImagePlus imp = IJ.getImage();
+		RoiManager rm = RoiManager.getInstance2();
+		if (rm==null) {
+			IJ.error("ROI Manager is not open");
+			return;
+		}
+		Roi[] rois = rm.getRoisAsArray();
+		if (rois.length==0) {
+			IJ.error("ROI Manager is empty");
+			return;
+		}
+		rm.moveRoisToOverlay(imp);
+		imp.deleteRoi();
+	}
+
+	void toRoiManager() {
+		ImagePlus imp = IJ.getImage();
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null) {
+			IJ.error("Overlay required");
+			return;
+		}
+		RoiManager rm = RoiManager.getInstance2();
+		if (rm==null)
+			rm = new RoiManager();
+		if (overlay.size()>=4 && overlay.get(3).getPosition()!=0)
+			Prefs.showAllSliceOnly = true;
+		rm.setOverlay(overlay);
+		imp.setOverlay(null);
+	}
+	
+	void options() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Overlay overlay = null;
+		Roi roi = null;
+		if (imp!=null) {
+			overlay = imp.getOverlay();
+			roi = imp.getRoi();
+			if (roi!=null)
+				roi = (Roi)roi.clone();
+		}
+		if (roi==null)
+			roi = defaultRoi;
+		if (roi==null) {
+			int size = imp!=null?imp.getWidth():512;
+			roi = new Roi(0, 0, size/4, size/4);
+		}
+		if (!roi.isDrawingTool()) {
+			if (roi.getStroke()==null)
+				roi.setStrokeWidth(defaultRoi.getStrokeWidth());
+			if (roi.getStrokeColor()==null || Line.getWidth()>1&&defaultRoi.getStrokeColor()!=null)
+				roi.setStrokeColor(defaultRoi.getStrokeColor());
+			if (roi.getFillColor()==null)
+				roi.setFillColor(defaultRoi.getFillColor());
+		}
+		boolean points = roi instanceof PointRoi && ((PolygonRoi)roi).getNCoordinates()>1;
+		if (points) roi.setStrokeColor(Color.red);
+		roi.setPosition(defaultRoi.getPosition());
+		RoiProperties rp = new RoiProperties("Overlay Options", roi);
+		if (!rp.showDialog()) return;
+		defaultRoi = roi;
+	}
+	
+	void list() {
+		ImagePlus imp = IJ.getImage();
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null)
+			listRois(overlay.toArray());
+	}
+	
+	public static void listRois(Roi[] rois) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		ResultsTable rt = new ResultsTable();
+		rt.showRowNumbers(true);
+		for (int i=0; i<rois.length; i++) {
+			if (rois[i]==null)
+				continue;
+			Rectangle r = rois[i].getBounds();
+			String color = Colors.colorToString(rois[i].getStrokeColor());
+			String fill = Colors.colorToString(rois[i].getFillColor());
+			double strokeWidth = rois[i].getStrokeWidth();
+			int digits = strokeWidth==(int)strokeWidth?0:1;
+			String sWidth = IJ.d2s( strokeWidth,digits);
+			String group = ""+rois[i].getGroup();
+			if (group.equals("0"))
+				group = "none";
+			int position = rois[i].getPosition();
+			int c = rois[i].getCPosition();
+			int z = rois[i].getZPosition();
+			int t = rois[i].getTPosition();
+			if (imp!=null && imp.getNChannels()==1 && imp.getNSlices()==1 && imp.getNFrames()>1) {
+				t = z;
+				z = 0;
+			}
+			rt.setValue("Index", i, i);
+			rt.setValue("Name", i, rois[i].getName());
+			rt.setValue("Type", i, rois[i].getTypeAsString());
+			rt.setValue("Group", i, group);
+			if (rois[i] instanceof PointRoi) {
+				Rectangle2D.Double bounds = rois[i].getFloatBounds();
+				rt.setValue("X", i, (int)Math.round(bounds.x));
+				rt.setValue("Y", i, (int)Math.round(bounds.y));
+			} else if (rois[i] instanceof Arrow) {
+				Polygon p = ((Arrow)rois[i]).getPoints();
+				rt.setValue("X", i, p.xpoints[1]);
+				rt.setValue("Y", i, p.ypoints[1]);
+			} else {
+				rt.setValue("X", i, r.x);
+				rt.setValue("Y", i, r.y);
+			}
+			rt.setValue("Width", i, r.width);		
+			rt.setValue("Height", i, r.height);		
+			rt.setValue("Points", i, rois[i].size());
+			rt.setValue("Color", i, color);		
+			rt.setValue("Fill", i, fill);		
+			rt.setValue("LWidth", i, sWidth);		
+			rt.setValue("Pos", i, position);	
+			rt.setValue("C", i, c);	
+			rt.setValue("Z", i, z);	
+			rt.setValue("T", i, t);	
+		}
+		String title = imp!=null?" of "+imp.getTitle():"";
+		rt.show("Overlay Elements"+title);
+	}
+	
+}
diff --git a/src/ij/plugin/OverlayLabels.java b/src/ij/plugin/OverlayLabels.java
new file mode 100644
index 0000000..cec0e82
--- /dev/null
+++ b/src/ij/plugin/OverlayLabels.java
@@ -0,0 +1,120 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.plugin.filter.Analyzer;
+import java.awt.*;
+import java.util.Vector;
+
+/** This plugin implements the Image/Overlay/Labels command. */
+public class OverlayLabels implements PlugIn, DialogListener {
+	private static final String[] fontSizes = {"7", "8", "9", "10", "12", "14", "18", "24", "28", "36", "48", "72"};
+	private static Overlay defaultOverlay = new Overlay();
+	private ImagePlus imp;
+	private Overlay overlay;
+	private GenericDialog gd;
+	private boolean showLabels;
+	private boolean showNames;
+	private boolean drawBackgrounds;
+	private String colorName;
+	private int fontSize;
+	private boolean bold;
+	
+	public void run(String arg) {
+		imp = WindowManager.getCurrentImage();
+		overlay = null;
+		if (imp!=null) {
+			ImageCanvas ic = imp.getCanvas();
+			if (ic!=null)
+				overlay = ic.getShowAllList();
+			if (overlay==null)
+				overlay = imp.getOverlay();
+		}
+		if (overlay==null)
+			overlay = defaultOverlay;
+		showDialog();
+		if (!gd.wasCanceled()) {
+			defaultOverlay.drawLabels(overlay.getDrawLabels());
+			defaultOverlay.drawNames(overlay.getDrawNames());
+			defaultOverlay.drawBackgrounds(overlay.getDrawBackgrounds());
+			defaultOverlay.setLabelColor(overlay.getLabelColor());
+			defaultOverlay.setLabelFont(overlay.getLabelFont());
+		}
+	}
+	
+	public void showDialog() {
+		showLabels = overlay.getDrawLabels();
+		showNames = overlay.getDrawNames();
+		drawBackgrounds = overlay.getDrawBackgrounds();
+		colorName = Colors.getColorName(overlay.getLabelColor(), "white");
+		fontSize = 12;
+		Font font = overlay.getLabelFont();
+		if (font!=null) {
+			fontSize = font.getSize();
+			bold = font.getStyle()==Font.BOLD;
+		}
+		gd = new GenericDialog("Labels");
+		gd.addChoice("Color:", Colors.colors, colorName);
+		gd.addChoice("Font size:", fontSizes, ""+fontSize);
+		gd.addCheckbox("Show labels", showLabels);
+		gd.addCheckbox("Use names as labels", showNames);
+		gd.addCheckbox("Draw backgrounds", drawBackgrounds);
+		gd.addCheckbox("Bold", bold);
+		gd.addDialogListener(this);
+		gd.showDialog();
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (gd.wasCanceled()) return false;
+		String colorName2 = colorName;
+		boolean showLabels2 = showLabels;
+		boolean showNames2 = showNames;
+		boolean drawBackgrounds2 = drawBackgrounds;
+		boolean bold2 = bold;
+		int fontSize2 = fontSize;
+		colorName = gd.getNextChoice();
+		fontSize = (int)Tools.parseDouble(gd.getNextChoice(), 12);
+		showLabels = gd.getNextBoolean();
+		showNames = gd.getNextBoolean();
+		drawBackgrounds = gd.getNextBoolean();
+		bold = gd.getNextBoolean();
+		boolean colorChanged = !colorName.equals(colorName2);
+		boolean sizeChanged = fontSize!=fontSize2;
+		boolean changes = showLabels!=showLabels2 || showNames!=showNames2
+			|| drawBackgrounds!=drawBackgrounds2 || colorChanged || sizeChanged
+			|| bold!=bold2;
+		if (changes) {
+			if ((showNames&&!showNames2) || colorChanged || sizeChanged) {
+				showLabels = true;
+				Vector checkboxes = gd.getCheckboxes();
+				((Checkbox)checkboxes.elementAt(0)).setState(true);
+			}
+			overlay.drawLabels(showLabels);
+			Analyzer.drawLabels(showLabels);
+			overlay.drawNames(showNames);
+			overlay.drawBackgrounds(drawBackgrounds);
+			Color color = Colors.getColor(colorName, Color.white);
+			overlay.setLabelColor(color);
+			if (sizeChanged || bold || bold!=bold2)
+				overlay.setLabelFont(new Font("SansSerif", bold?Font.BOLD:Font.PLAIN, fontSize));
+			if (imp!=null) {
+				Overlay o = imp.getOverlay();
+				if (o==null) {
+					ImageCanvas ic = imp.getCanvas();
+					if (ic!=null)
+						o = ic.getShowAllList();
+				}
+				if (o!=null)
+					imp.draw();
+			}
+		}
+		return true;
+	}
+
+	/** Creates an empty Overlay that has the current label settings. */
+	public static Overlay createOverlay() {
+		return defaultOverlay.duplicate();
+	}
+
+}
diff --git a/src/ij/plugin/PGM_Reader.java b/src/ij/plugin/PGM_Reader.java
new file mode 100644
index 0000000..9d914eb
--- /dev/null
+++ b/src/ij/plugin/PGM_Reader.java
@@ -0,0 +1,320 @@
+package ij.plugin;
+
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import java.io.*;
+
+/**
+ * This plugin opens PxM format images.
+ * <p/>
+ * The portable graymap format is a lowest common denominator
+ * grayscale file format. The definition is as follows:
+ * <p/>
+ * - A "magic number" for identifying the  file  type.   A  pgm
+ * file's magic number is the two characters "P2".
+ * - Whitespace (blanks, TABs, CRs, LFs).
+ * - A width, formatted as ASCII characters in decimal.
+ * - Whitespace.
+ * - A height, again in ASCII decimal.
+ * - Whitespace.
+ * - The maximum gray value, again in ASCII decimal.
+ * - Whitespace.
+ * - Width * height gray values, each in ASCII decimal, between
+ * 0 and the specified maximum value, separated by whi-
+ * tespace, starting at the top-left corner of the graymap,
+ * proceeding in normal English reading order. A value of 0
+ * means black, and the maximum value means white.
+ * - Characters from a "#" to the next end-of-line are ignored (comments).
+ * - No line should be longer than 70 characters.
+ * <p/>
+ * Here is an example of a small graymap in this format:
+ * P2
+ * # feep.pgm
+ * 24 7
+ * 15
+ * 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+ * 0  3  3  3  3  0  0  7  7  7  7  0  0 11 11 11 11  0  0 15 15 15 15  0
+ * 0  3  0  0  0  0  0  7  0  0  0  0  0 11  0  0  0  0  0 15  0  0 15  0
+ * 0  3  3  3  0  0  0  7  7  7  0  0  0 11 11 11  0  0  0 15 15 15 15  0
+ * 0  3  0  0  0  0  0  7  0  0  0  0  0 11  0  0  0  0  0 15  0  0  0  0
+ * 0  3  0  0  0  0  0  7  7  7  7  0  0 11 11 11 11  0  0 15  0  0  0  0
+ * 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
+ * <p/>
+ * There is a  PGM variant that stores the pixel data as raw bytes:
+ * <p/>
+ * -The "magic number" is "P5" instead of "P2".
+ * -The gray values are stored as plain bytes, instead of ASCII decimal.
+ * -No whitespace is allowed in the grays section, and only a single
+ * character of whitespace (typically a newline) is allowed after the maxval.
+ * -The files are smaller and many times faster to read and write.
+ * <p/>
+ * Kai Barthel Nov 16 2004:
+ * Extended to support PPM (portable pixmap) format images (24 bits only).
+ * -The "magic numbers" are "P6" (raw) "P3" (ASCII).
+ * <p/>
+ * Ulf Dittmer April 2005:
+ * Extended to support PBM (bitmap) images (P1 and P4)
+ * <p/>
+ * Jarek Sacha (jarek.at.ieee.org) December 2005:
+ * Extended PPM support to 48 bit color images.
+ */
+
+public class PGM_Reader extends ImagePlus implements PlugIn {
+
+    private int width, height;
+    private boolean rawBits;
+    private boolean sixteenBits;
+    private boolean isColor;
+    private boolean isBlackWhite;
+    private int maxValue;
+
+    public void run(String arg) {
+        OpenDialog od = new OpenDialog("PBM/PGM/PPM Reader...", arg);
+        String directory = od.getDirectory();
+        String name = od.getFileName();
+        if (name == null)
+            return;
+        String path = directory + name;
+
+        IJ.showStatus("Opening: " + path);
+        ImageStack stack;
+        try {
+            stack = openFile(path);
+        }
+        catch (IOException e) {
+            String msg = e.getMessage();
+            IJ.showMessage("PBM/PGM/PPM Reader", msg.equals("") ? "" + e : msg);
+            return;
+        }
+        setStack(name, stack);
+        FileInfo fi = new FileInfo();
+        fi.fileFormat = FileInfo.PGM;
+        fi.directory = directory;
+        fi.fileName = name;
+        setFileInfo(fi);
+        if (arg.equals("")) show();
+    }
+
+    public ImageStack openFile(String path) throws IOException {
+        InputStream is = new BufferedInputStream(new FileInputStream(path));
+        try {
+			StreamTokenizer tok = new StreamTokenizer(is); //deprecated, but it works
+			//Reader r = new BufferedReader(new InputStreamReader(is));
+			//StreamTokenizer tok = new StreamTokenizer(r);  // doesn't work
+			tok.resetSyntax();
+			tok.wordChars(33, 255);
+			tok.whitespaceChars(0, ' ');
+			tok.parseNumbers();
+			tok.eolIsSignificant(true);
+			tok.commentChar('#');
+			openHeader(tok);
+			//IJ.log("PGM_Reader: w="+width+",h="+height+",raw="+rawBits+",16bits="+sixteenBits+",color="+isColor+",b&w="+isBlackWhite+",max="+maxValue);
+				
+			if (!isColor && sixteenBits) { // 16-bit grayscale
+				if (rawBits) {
+					ImageProcessor ip = open16bitRawImage(is, width, height);
+					ImageStack stack = new ImageStack(width, height);
+					stack.addSlice("", ip);
+					return stack;
+				} else {
+					ImageProcessor ip = open16bitAsciiImage(tok, width, height);
+					ImageStack stack = new ImageStack(width, height);
+					stack.addSlice("", ip);
+					return stack;
+				}
+			}
+			
+			if (!isColor) { // 8-bit grayscale
+				byte[] pixels = new byte[width * height];
+				ImageProcessor ip = new ByteProcessor(width, height, pixels, null);
+				if (rawBits)
+					openRawImage(is, width * height, pixels);
+				else
+					openAsciiImage(tok, width * height, pixels);
+				for (int i = pixels.length - 1; i >= 0; i--) {
+					if (isBlackWhite) {
+						if (rawBits) {
+							if (i < (pixels.length / 8)) {
+								for (int bit = 7; bit >= 0; bit--) {
+									pixels[8 * i + 7 - bit] = (byte) ((pixels[i] & ((int) Math.pow(2, bit))) == 0 ? 255 : 0);
+								}
+							}
+						} else
+							pixels[i] = (byte) (pixels[i] == 0 ? 255 : 0);
+					} else
+						pixels[i] = (byte) (0xff & (255 * (int) (0xff & pixels[i]) / maxValue));
+				}
+				ImageStack stack = new ImageStack(width, height);
+				stack.addSlice("", ip);
+				return stack;
+			}
+			
+			if (!sixteenBits) { // 8-bit color
+				int[] pixels = new int[width * height];
+				byte[] bytePixels = new byte[3 * width * height];
+				ImageProcessor ip = new ColorProcessor(width, height, pixels);
+				if (rawBits)
+					openRawImage(is, 3 * width * height, bytePixels);
+				else
+					openAsciiImage(tok, 3 * width * height, bytePixels);
+				for (int i = 0; i < width * height; i++) {
+					int r = (int) (0xff & bytePixels[i * 3]);
+					int g = (int) (0xff & bytePixels[i * 3 + 1]);
+					int b = (int) (0xff & bytePixels[i * 3 + 2]);
+					r = (r * 255 / maxValue) << 16;
+					g = (g * 255 / maxValue) << 8;
+					b = (b * 255 / maxValue);
+					pixels[i] = 0xFF000000 | r | g | b;
+				}
+				ImageStack stack = new ImageStack(width, height);
+				stack.addSlice("", ip);
+				return stack;
+			}
+			
+			// 16-bit raw color
+			short[] red = new short[width*height];
+			short[] green = new short[width*height];
+			short[] blue = new short[width*height];
+			if (rawBits) {
+				byte[] bytePixels = new byte[6*width*height];
+				openRawImage(is, 6*width*height, bytePixels);
+				for (int i=0; i<width*height; i++) {
+					int r1 = 0xff & bytePixels[i*6];
+					int r2 = 0xff & bytePixels[i*6+1];
+					int g1 = 0xff & bytePixels[i*6+2];
+					int g2 = 0xff & bytePixels[i*6+3];
+					int b1 = 0xff & bytePixels[i*6+ 4];
+					int b2 = 0xff & bytePixels[i*6+5];
+					red[i] = (short) (0xffff & (r1*256+r2));
+					green[i] = (short) (0xffff & (g1*256+g2));
+					blue[i] = (short) (0xffff & (b1*256+b2));
+				}
+			} else {
+				ImageProcessor ip = open16bitAsciiImage(tok, 3*width, height);
+				short[] pixels = (short[])ip.getPixels();
+				for (int i=0; i<width*height; i++) {
+					red[i] = (short)(pixels[i*3]&0xffffff);
+					green[i] = (short)(pixels[i*3+1]&0xffffff);
+					blue[i] = (short)(pixels[i*3+2]&0xffffff);
+				}
+			}
+			ImageStack stack = new ImageStack(width, height);
+			stack.addSlice("red", new ShortProcessor(width, height, red, null));
+			stack.addSlice("green", new ShortProcessor(width, height, green, null));
+			stack.addSlice("blue", new ShortProcessor(width, height, blue, null));
+			return stack;
+        } finally {
+            if (is!=null) is.close();
+        }
+   }
+
+    public void openHeader(StreamTokenizer tok) throws IOException {
+        String magicNumber = getWord(tok);
+        if (magicNumber.equals("P1")) {
+            rawBits = false;
+            isColor = false;
+            isBlackWhite = true;
+        } else if (magicNumber.equals("P4")) {
+            rawBits = true;
+            isColor = false;
+            isBlackWhite = true;
+        } else if (magicNumber.equals("P2")) {
+            rawBits = false;
+            isColor = false;
+            isBlackWhite = false;
+        } else if (magicNumber.equals("P5")) {
+            rawBits = true;
+            isColor = false;
+            isBlackWhite = false;
+        } else if (magicNumber.equals("P3")) {
+            rawBits = false;
+            isColor = true;
+            isBlackWhite = false;
+        } else if (magicNumber.equals("P6")) {
+            rawBits = true;
+            isColor = true;
+            isBlackWhite = false;
+        } else
+            throw new IOException("PxM files must start with \"P1\" or \"P2\" or \"P3\" or \"P4\" or \"P5\" or \"P6\"");
+        width = getInt(tok);
+        height = getInt(tok);
+        if (width == -1 || height == -1)
+            throw new IOException("Error opening PxM header..");
+        if (! isBlackWhite) {
+            maxValue = getInt(tok);
+            if (maxValue == -1)
+                throw new IOException("Error opening PxM header..");
+            sixteenBits = maxValue > 255;
+        } else
+            maxValue = 255;
+        if (sixteenBits && maxValue > 65535)
+            throw new IOException("The maximum gray value is larger than 65535.");
+    }
+
+    public void openAsciiImage(StreamTokenizer tok, int size, byte[] pixels) throws IOException {
+        int i = 0;
+        int inc = size/20;
+        if (inc==0) inc = 1;
+        while (tok.nextToken() != tok.TT_EOF) {
+            if (tok.ttype == tok.TT_NUMBER) {
+                pixels[i++] = (byte) (((int) tok.nval) & 255);
+                if (i%inc==0)
+                    IJ.showProgress(0.5 + ((double) i / size) / 2.0);
+            }
+        }
+        IJ.showProgress(1.0);
+    }
+
+    public void openRawImage(InputStream is, int size, byte[] pixels) throws IOException {
+        int count = 0;
+        while (count < size && count >= 0)
+            count = is.read(pixels, count, size - count);
+    }
+
+    public ImageProcessor open16bitRawImage(InputStream is, int width, int height) throws IOException {
+        int size = width * height * 2;
+        byte[] bytes = new byte[size];
+        int count = 0;
+        while (count < size && count >= 0)
+            count = is.read(bytes, count, size - count);
+        short[] pixels = new short[size / 2];
+        for (int i = 0, j = 0; i < size / 2; i++, j += 2)
+            pixels[i] = (short) (((bytes[j] & 0xff) << 8) | (bytes[j + 1] & 0xff)); //big endian
+        return new ShortProcessor(width, height, pixels, null);
+    }
+
+    public ImageProcessor open16bitAsciiImage(StreamTokenizer tok, int width, int height) throws IOException {
+        int i = 0;
+        int size = width * height;
+        int inc = size/20; // Progress update interval
+        if (inc==0) inc = 1;
+        short[] pixels = new short[size];
+        while (tok.nextToken() != tok.TT_EOF) {
+            if (tok.ttype == tok.TT_NUMBER) {
+                pixels[i++] = (short) (((int) tok.nval) & 65535);
+                if (i%inc==0)
+                    IJ.showProgress(0.5 + ((double) i / size) / 2.0);
+            }
+        }
+        IJ.showProgress(1.0);
+        return new ShortProcessor(width, height, pixels, null);
+    }
+
+    String getWord(StreamTokenizer tok) throws IOException {
+        while (tok.nextToken() != tok.TT_EOF) {
+            if (tok.ttype == tok.TT_WORD)
+                return tok.sval;
+        }
+        return null;
+    }
+
+    int getInt(StreamTokenizer tok) throws IOException {
+        while (tok.nextToken() != tok.TT_EOF) {
+            if (tok.ttype == tok.TT_NUMBER)
+                return (int) tok.nval;
+        }
+        return -1;
+    }
+
+}
diff --git a/src/ij/plugin/PNG_Writer.java b/src/ij/plugin/PNG_Writer.java
new file mode 100644
index 0000000..7960014
--- /dev/null
+++ b/src/ij/plugin/PNG_Writer.java
@@ -0,0 +1,104 @@
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import java.awt.*;
+import java.io.*;
+import java.awt.image.*;
+import javax.imageio.ImageIO;
+
+
+/** Saves in PNG format using the ImageIO classes.  RGB images are saved
+	as RGB PNGs. All other image types are saved as 8-bit PNGs. With 8-bit images,
+	the value of the transparent index can be set in the Edit/Options/Input-Output dialog,
+	or by calling Prefs.setTransparentIndex(index), where 0<=index<=255. */
+public class PNG_Writer implements PlugIn {
+    ImagePlus imp;
+
+    public void run(String path) {
+        imp = WindowManager.getCurrentImage();
+        if (imp==null) {
+        	IJ.noImage();
+        	return;
+        }
+        if (path.equals("")) {
+            SaveDialog sd = new SaveDialog("Save as PNG...", imp.getTitle(), ".png");
+            String name = sd.getFileName();
+            if (name==null)
+                return;
+            String dir = sd.getDirectory();
+            path = dir + name;
+        }
+        try {
+            writeImage(imp, path, Prefs.getTransparentIndex());
+        } catch (Exception e) {
+            String msg = e.getMessage();
+            if (msg==null || msg.equals(""))
+                msg = ""+e;
+            msg = "An error occured writing the file.\n \n" + msg;
+            if (msg.contains("NullPointerException"))
+            	msg = "Incorrect file path:";
+            msg += "\n \n"+path;
+            IJ.error("PNG Writer", msg);
+        }
+        IJ.showStatus("");
+    }
+
+	public void writeImage(ImagePlus imp, String path, int transparentIndex) throws Exception {
+		if (imp.getType()==ImagePlus.COLOR_256) {
+			imp = imp.duplicate();
+			new ImageConverter(imp).convertToRGB();
+		}
+		if (imp.getStackSize()==4 && imp.getBitDepth()==8 && "alpha".equalsIgnoreCase(imp.getStack().getSliceLabel(4)))
+			writeFourChannelsWithAlpha(imp, path);
+		else if (transparentIndex>=0 && transparentIndex<=255 && imp.getBitDepth()==8)
+			writeImageWithTransparency(imp, path, transparentIndex);
+		else if (imp.getOverlay()!=null && !imp.getHideOverlay() && !imp.tempOverlay())
+			ImageIO.write(imp.flatten().getBufferedImage(), "png", new File(path));
+		else if (imp.getBitDepth()==16 && !imp.isComposite() && imp.getProcessor().isDefaultLut())
+			write16gs(imp, path);
+        else
+			ImageIO.write(imp.getBufferedImage(), "png", new File(path));
+	}
+	
+	private void writeFourChannelsWithAlpha(ImagePlus imp, String path) throws Exception {
+		ImageStack stack = imp.getStack();
+		int w=imp.getWidth(), h=imp.getHeight();
+		ImagePlus imp2 = new ImagePlus("", new ColorProcessor(w,h));
+		ColorProcessor cp = (ColorProcessor)imp2.getProcessor();
+		for (int channel=1; channel<=4; channel++)
+			cp.setChannel(channel, (ByteProcessor)stack.getProcessor(channel));
+		BufferedImage bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
+		WritableRaster raster = bi.getRaster();
+		raster.setDataElements(0, 0, w, h, cp.getPixels());
+		ImageIO.write(bi, "png", new File(path));
+	}
+    
+	void writeImageWithTransparency(ImagePlus imp, String path, int transparentIndex) throws Exception {
+		int width = imp.getWidth();
+		int  height = imp.getHeight();
+		ImageProcessor ip = imp.getProcessor();
+		IndexColorModel cm = (IndexColorModel)ip.getColorModel();
+		int size = cm.getMapSize();
+		byte[] reds = new byte[256];
+		byte[] greens = new byte[256];
+		byte[] blues = new byte[256];	
+		cm.getReds(reds); 
+		cm.getGreens(greens); 
+		cm.getBlues(blues);
+		cm = new IndexColorModel(8, 256, reds, greens, blues, transparentIndex);
+		WritableRaster wr = cm.createCompatibleWritableRaster(width, height);
+		DataBufferByte db = (DataBufferByte)wr.getDataBuffer();
+		byte[] biPixels = db.getData();
+		System.arraycopy(ip.getPixels(), 0, biPixels, 0, biPixels.length);
+		BufferedImage bi = new BufferedImage(cm, wr, false, null);
+		ImageIO.write(bi, "png", new File(path));
+	}
+
+    void write16gs(ImagePlus imp, String path) throws Exception {
+		ShortProcessor sp = (ShortProcessor)imp.getProcessor();
+		BufferedImage bi = sp.get16BitBufferedImage();
+		File f = new File(path);
+		ImageIO.write(bi, "png", f);
+    }
+}
diff --git a/src/ij/plugin/PNM_Writer.java b/src/ij/plugin/PNM_Writer.java
new file mode 100644
index 0000000..e3a3f13
--- /dev/null
+++ b/src/ij/plugin/PNM_Writer.java
@@ -0,0 +1,107 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.io.SaveDialog;
+import java.io.*;
+import java.util.*;
+import java.awt.image.*;
+
+/*
+ This plugin saves grayscale images in PGM (portable graymap) format 
+ and RGB images in PPM (portable pixmap) format. These formats, 
+ along with PBM (portable bitmap), are collectively known as the 
+ PNM format. More information can be found at 
+ "http://en.wikipedia.org/wiki/Portable_Pixmap_file_format".
+ 
+ @author Johannes Schindelin
+ */
+public class PNM_Writer implements PlugIn {
+
+	public void run(String path) {
+		ImagePlus img=IJ.getImage();
+		boolean isGray = false;
+		String extension = null;
+		ImageProcessor ip = img.getProcessor();
+		if (img.getBitDepth()==24)
+			extension = ".pnm";
+		else {
+			if (img.getBitDepth()==8&& ip.isInvertedLut()) {
+				ip = ip.duplicate();
+				ip.invert();
+			}
+			if (img.getBitDepth()!=16)
+				ip = ip.convertToByte(true);
+			isGray = true;
+			extension = ".pgm";
+		}
+		String title=img.getTitle();
+		int length=title.length();
+		for (int i=2;i<5;i++)
+			if (length>i+1 && title.charAt(length-i)=='.') {
+				title=title.substring(0,length-i);
+				break;
+			}
+		if (path==null || path.equals("")) {
+			SaveDialog od = new SaveDialog("PNM Writer", title, extension);
+			String dir=od.getDirectory();
+			String name=od.getFileName();
+			if (name==null)
+				return;
+			path = dir + name;
+		}
+		IJ.showStatus("Writing PNM "+path+"...");
+		if (img.getBitDepth()==16) {
+			save16BitImage(ip, path);
+			return;
+		}
+		try {
+			OutputStream fileOutput = new FileOutputStream(path);
+			DataOutputStream output = new DataOutputStream(fileOutput);
+			int w = img.getWidth(), h = img.getHeight();
+			output.writeBytes((isGray ? "P5" : "P6")
+					+ "\n# Written by ImageJ PNM Writer\n"
+					+ w + " " + h + "\n255\n");
+			if (isGray)
+				output.write((byte[])ip.getPixels(), 0, w*h);
+			else {
+				byte[] pixels = new byte[w * h * 3];
+				ColorProcessor proc =
+					(ColorProcessor)ip;
+				for (int j = 0; j < h; j++)
+					for (int i = 0; i < w; i++) {
+						int c = proc.getPixel(i, j);
+						pixels[3 * (i + w * j) + 0] =
+							(byte)((c & 0xff0000) >> 16);
+						pixels[3 * (i + w * j) + 1] =
+							(byte)((c & 0xff00) >> 8);
+						pixels[3 * (i + w * j) + 2] =
+							(byte)(c & 0xff);
+					}
+				output.write(pixels, 0, pixels.length);
+			}
+			output.close();
+		} catch(IOException e) {
+			IJ.handleException(e);
+		}
+		IJ.showStatus("");
+	}
+	
+	private void save16BitImage(ImageProcessor ip, String path) {
+		ip.resetMinAndMax();
+		int max = (int)ip.getMax();
+		if (max<256) max=256;
+		try {
+			DataOutputStream output = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
+			output.writeBytes("P5\n# Written by ImageJ PNM Writer\n" + ip.getWidth() + " " + ip.getHeight() + "\n"+max+"\n");
+			for (int i=0; i<ip.getPixelCount(); i++)
+				output.writeShort(ip.get(i));
+			output.close();
+		} catch(IOException e) {
+			IJ.handleException(e);
+		}
+	}
+
+};
+
diff --git a/src/ij/plugin/PlugIn.java b/src/ij/plugin/PlugIn.java
new file mode 100644
index 0000000..8b18f3a
--- /dev/null
+++ b/src/ij/plugin/PlugIn.java
@@ -0,0 +1,13 @@
+package ij.plugin;
+
+/** Plugins that acquire images or display windows should
+	implement this interface. Plugins that process images 
+	should implement the PlugInFilter interface. */
+public interface PlugIn {
+
+	/** This method is called when the plugin is loaded.
+		'arg', which may be blank, is the argument specified
+		for this plugin in IJ_Props.txt. */ 
+	public void run(String arg);
+	
+}
diff --git a/src/ij/plugin/PlugInInterpreter.java b/src/ij/plugin/PlugInInterpreter.java
new file mode 100644
index 0000000..196ef7f
--- /dev/null
+++ b/src/ij/plugin/PlugInInterpreter.java
@@ -0,0 +1,25 @@
+package ij.plugin;
+
+/** Plugins that run scripts (e.g., BeanShell, Jython) extend this class. */
+public abstract class PlugInInterpreter implements PlugIn {
+
+	/** Run script on separate thread. */
+	public void run(String script) {
+	}
+	
+	/** Run script on current thread. */
+	public abstract String run(String script, String arg);
+	
+	/** Returns the value returned by the script, if any, or null. */
+	public abstract String getReturnValue();
+
+	/** Returns the name of this PlugInInterpreter. */
+	public abstract String getName();
+
+	/** Returns the import statements that are added to the script. */
+	public abstract String getImports();
+	
+	/** Returns the version of ImageJ at the time this plugin was created. */
+	public abstract String getVersion();
+
+}
diff --git a/src/ij/plugin/PluginInstaller.java b/src/ij/plugin/PluginInstaller.java
new file mode 100644
index 0000000..eaa9a85
--- /dev/null
+++ b/src/ij/plugin/PluginInstaller.java
@@ -0,0 +1,246 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.macro.*;
+import java.io.*;
+import java.net.URL;
+import java.net.*;
+import java.util.*;
+
+/** Installs plugins dragged and dropped on the "ImageJ" window, or plugins,
+	macros or scripts opened using the Plugins/Install command. */
+public class PluginInstaller implements PlugIn {
+	public static final String[] validExtensions = {".txt",".ijm",".js",".bsh",".class",".jar",".zip",".java",".py"};
+
+	public void run(String arg) {
+		OpenDialog od = new OpenDialog("Install Plugin, Macro or Script...", arg);
+		String directory = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+				return;
+		if (!validExtension(name)) {
+			IJ.error("Plugin Installer", errorMessage());
+			return;
+		}
+		String path = directory + name;
+		install(path);
+	}
+	
+	public boolean install(String path) {
+		boolean isURL = path.contains("://");
+		String lcPath = path.toLowerCase();
+		if (isURL)
+			path = Opener.updateUrl(path);
+		boolean isTool = lcPath.endsWith("tool.ijm") || lcPath.endsWith("tool.txt")
+			|| lcPath.endsWith("tool.class") || lcPath.endsWith("tool.jar");
+		boolean isMacro = lcPath.endsWith(".txt") || lcPath.endsWith(".ijm");
+		byte[] data = null;
+		String name = path;
+		if (isURL) {
+			int index = path.lastIndexOf("/");
+			if (index!=-1 && index<=path.length()-1)
+				name = path.substring(index+1);
+			data = download(path, name);
+		} else {
+			File f = new File(path);
+			name = f.getName();
+			data = download(f);
+		}
+		if (data==null)
+			return false;
+		if (name.endsWith(".txt") && !name.contains("_"))
+			name = name.substring(0,name.length()-4) + ".ijm";
+		if (name.endsWith(".zip")) {
+			if (!name.contains("_")) {
+				IJ.error("Plugin Installer", "No underscore in file name:\n \n  "+name);
+				return false;
+			}
+			name = name.substring(0,name.length()-4) + ".jar";
+		}
+		String dir = null;
+		boolean isLibrary = name.endsWith(".jar") && !name.contains("_");
+		if (isLibrary) {
+			dir = Menus.getPlugInsPath()+"jars";
+			File f = new File(dir);
+			if (!f.exists()) {
+				boolean ok = f.mkdir();
+				if (!ok)
+					dir = Menus.getPlugInsPath();
+			}
+		}
+		if (isTool) {
+			dir = Menus.getPlugInsPath()+"Tools" + File.separator;
+			File f = new File(dir);
+			if (!f.exists()) {
+				boolean ok = f.mkdir();
+				if (!ok) dir=null;
+			}
+			if (dir!=null && isMacro) {
+				String name2 = getToolName(data);
+				if (name2!=null)
+					name = name2;
+			}
+		}
+		if (dir==null) {
+			SaveDialog sd = new SaveDialog("Save Plugin, Macro or Script...", Menus.getPlugInsPath(), name, null);
+			String name2 = sd.getFileName();
+			if (name2==null)
+				return false;
+			dir = sd.getDirectory();
+		}
+		//IJ.log(dir+"   "+Menus.getPlugInsPath());
+		if (!savePlugin(new File(dir,name), data))
+			return false;
+		if (name.endsWith(".java"))
+			IJ.runPlugIn("ij.plugin.Compiler", dir+name);
+		Menus.updateImageJMenus();
+		if (isTool) {
+			if (isMacro)
+				IJ.runPlugIn("ij.plugin.Macro_Runner", "Tools/"+name);
+			else if (name.endsWith(".class")) {
+				name = name.replaceAll("_"," ");
+				name = name.substring(0,name.length()-6);
+				IJ.run(name);
+			}
+		}
+		return true;
+	}
+	
+	private String getToolName(byte[] data) {
+		String text = new String(data);
+		String name = null;
+		Tokenizer tok = new Tokenizer();
+		Program pgm = tok.tokenize(text);
+		int[] code = pgm.getCode();
+		Symbol[] symbolTable = pgm.getSymbolTable();
+		for (int i=0; i<code.length; i++) {
+			int token = code[i]&MacroConstants.TOK_MASK;
+			if (token==MacroConstants.MACRO) {
+				int nextToken = code[i+1]&MacroConstants.TOK_MASK;
+				if (nextToken==MacroConstants.STRING_CONSTANT) {
+					int address = code[i+1]>>MacroConstants.TOK_SHIFT;
+					Symbol symbol = symbolTable[address];
+					name = symbol.str;
+					break;
+				}
+			}
+		}
+		if (name==null)
+			return null;
+		int index = name.indexOf("Tool");
+		if (index==-1)
+			return null;
+		name = name.substring(0, index+4);
+		name = name.replaceAll(" ","_");
+		name = name + ".ijm";
+		return name;
+	}
+	
+	boolean savePlugin(File f, byte[] data) {
+		try {
+			FileOutputStream out = new FileOutputStream(f);
+			out.write(data, 0, data.length);
+			out.close();
+		} catch (IOException e) {
+			IJ.error("Plugin Installer", ""+e);
+			return false;
+		}
+		return true;
+	}
+
+	public static byte[] download(String urlString, String name) {
+		int maxLength = 52428800; //50MB
+		URL url = null;
+		boolean unknownLength = false;
+		byte[] data = null;;
+		int n = 0;
+		try {
+			url = new URL(urlString);
+			if (IJ.debugMode) IJ.log("PluginInstaller: "+urlString+"  " +url);
+			if (url==null)
+				return null;
+			URLConnection uc = url.openConnection();
+			int len = uc.getContentLength();
+			unknownLength = len<0;
+			if (unknownLength) len = maxLength;
+			if (name!=null)
+				IJ.showStatus("Downloading "+url.getFile());
+			InputStream in = uc.getInputStream();
+			data = new byte[len];
+			int lenk = len/1024;
+			while (n<len) {
+				int count = in.read(data, n, len-n);
+				if (count<0)
+					break;
+				n += count;
+				if (name!=null)
+					IJ.showStatus("Downloading "+name+" ("+(n/1024)+"/"+lenk+"k)");
+				IJ.showProgress(n, len);
+			}
+			in.close();
+		} catch (Exception e) {
+			String msg = "" + e;
+			if (!msg.contains("://"))
+				msg += "\n   "+urlString;
+			IJ.error("Plugin Installer", msg);
+			return null;
+		} finally {
+			IJ.showProgress(1.0);
+		}
+		if (name!=null) IJ.showStatus("");
+		if (unknownLength) {
+			byte[] data2 = data;
+			data = new byte[n];
+			for (int i=0; i<n; i++)
+				data[i] = data2[i];
+		}
+		return data;
+	}
+	
+	byte[] download(File f) {
+		if (!f.exists()) {
+			IJ.error("Plugin Installer", "File not found: "+f);
+			return null;
+		}
+		byte[] data = null;
+		try {
+			int len = (int)f.length();
+			InputStream in = new BufferedInputStream(new FileInputStream(f));
+			DataInputStream dis = new DataInputStream(in);
+			data = new byte[len];
+			dis.readFully(data);
+			dis.close();
+		}
+		catch (Exception e) {
+			IJ.error("Plugin Installer", ""+e);
+			data = null;
+		}
+		return data;
+	}
+	
+	private boolean validExtension(String name) {
+		name = name.toLowerCase(Locale.US);
+		boolean valid = false;
+		for (int i=0; i<validExtensions.length; i++) {
+			if (name.endsWith(validExtensions[i]))
+				return true;
+		}
+		return false;
+	}
+	
+	private String errorMessage() {
+		String s = "File name must end in ";
+		int len = validExtensions.length;
+		for (int i=0; i<len; i++) {
+			if (i==len-2)
+				s += "\""+validExtensions[i]+"\" or ";
+			else if (i==len-1)
+				s += "\""+validExtensions[i]+"\".";
+			else
+				s += "\""+validExtensions[i]+"\", ";
+		}
+		return s;
+	}
+	
+}
diff --git a/src/ij/plugin/PointToolOptions.java b/src/ij/plugin/PointToolOptions.java
new file mode 100644
index 0000000..d023567
--- /dev/null
+++ b/src/ij/plugin/PointToolOptions.java
@@ -0,0 +1,226 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.filter.Analyzer;
+import ij.measure.Measurements;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+
+
+/** This plugin implements the Edit/Options/Point Tool command. */
+public class PointToolOptions implements PlugIn, DialogListener {
+	private static GenericDialog gd = null;
+	private boolean multipointTool;
+	private boolean isMacro;
+
+	public static final String help = "<html>"
+	+"<h1>Point Tool</h1>"
+	+"<font size=+1>"
+	+"<ul>"
+	+"<li> Click on a point and drag to move it.<br>"
+	+"<li> Alt-click, or control-click, on a point to delete it.<br>"
+	+"<li> To delete multiple points, create an area<br>selection while holding down the alt key.<br>"
+	+"<li> Press 'alt+y' (<i>Edit&gt;Selection&gt;Properties</i> plus<br>alt key) to display the counts in a results table.<br>"
+	+"<li> Press 'm' (<i>Analyze&gt;Measure</i>) to list the counter<br>and stack position associated with each point.<br>"
+	+"<li> To measure a subset of the points, move them<br>to an overlay, create a selection and then use<br><i>Image&gt;Overlay&gt;Measure Overlay</i>.<br>"
+	+"<li> Use <i>File&gt;Save As&gt;Tiff</i> or <i>File&gt;Save As&gt;Selection</i><br>to save the points and counts.<br>"
+	+"<li> Press 'F' (<i>Image&gt;Overlay</i>&gt;Flatten</i>) to create an<br>RGB image with embedded markers for export.<br>"
+	+"<li> Hold the shift key down and points will be<br>constrained to a horizontal or vertical line.<br>"
+	+"<li> Use <i>Edit&gt;Selection&gt;Select None</i> to delete a<br>multi-point selection.<br>"
+	+"<li> Switch to the multi-point tool and use<br><i>Edit&gt;Selection&gt;Restore Selection</i> to restore<br>a deleted multi-point selection.<br>"
+	+"</ul>"
+	+" <br>"
+	+"</font>";
+
+ 	public void run(String arg) {
+ 		if (gd!=null && gd.isShowing() && !IJ.isMacro()) {
+ 			gd.toFront();
+ 			update();
+ 		} else
+ 			showDialog();
+ 	}
+
+	void showDialog() {
+		String options = IJ.isMacro()?Macro.getOptions():null;
+		isMacro = options!=null;
+		boolean legacyMacro = false;
+		if (isMacro) {
+			options = options.replace("selection=", "color=");
+			options = options.replace("marker=", "size=");
+			options = options.replace("type=Crosshair", "type=Cross");
+			Macro.setOptions(options);
+			legacyMacro = options.contains("auto-") || options.contains("add");
+		}
+		multipointTool = Toolbar.getMultiPointMode() && !legacyMacro;
+		if (isMacro && !legacyMacro)
+			multipointTool = true;
+		Color sc =Roi.getColor();
+		String sname = Colors.getColorName(sc, "Yellow");
+		Color cc =PointRoi.getDefaultCrossColor();
+		String cname = Colors.getColorName(cc, "None");
+		String type = PointRoi.types[PointRoi.getDefaultType()];
+		String size = PointRoi.sizes[PointRoi.getDefaultSize()];
+		if (multipointTool)
+			gd = GUI.newNonBlockingDialog("Point Tool");
+		else
+			gd = new GenericDialog("Point Tool");
+		gd.setInsets(5,0,2);
+		gd.addChoice("Type:", PointRoi.types, type);
+		gd.addChoice("Color:", Colors.getColors(), sname);
+		gd.addChoice("Size:", PointRoi.sizes, size);
+		if (!multipointTool) {
+			gd.addCheckbox("Auto-measure", Prefs.pointAutoMeasure);
+			gd.addCheckbox("Auto-next slice", Prefs.pointAutoNextSlice);
+			gd.addCheckbox("Add_to overlay", Prefs.pointAddToOverlay);
+			gd.addCheckbox("Add to ROI Manager", Prefs.pointAddToManager);
+		}
+		gd.setInsets(5, 20, 0);
+		gd.addCheckbox("Label points", !Prefs.noPointLabels);
+		gd.addCheckbox("Show on all slices", Prefs.showAllPoints);
+		if (multipointTool) {
+			gd.setInsets(15,0,5);
+			String[] choices =  PointRoi.getCounterChoices();
+			gd.addChoice("Counter:", choices, choices[getCounter()]);
+			gd.setInsets(2, 75, 0);
+			gd.addMessage(getCount(getCounter())+"    ");
+		}
+		gd.addHelp(help);
+		gd.addDialogListener(this);
+		gd.showDialog();
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		boolean redraw = false;
+		// type
+		int typeIndex = gd.getNextChoiceIndex();
+		if (typeIndex!=PointRoi.getDefaultType()) {
+			PointRoi.setDefaultType(typeIndex);
+			redraw = true;
+		}
+		// color
+		String selectionColor = gd.getNextChoice();
+		Color sc = Colors.getColor(selectionColor, Color.yellow);
+		if (sc!=Roi.getColor()) {
+			Roi.setColor(sc);
+			redraw = true;
+			Toolbar tb = Toolbar.getInstance();
+			if (tb!=null) tb.repaint();
+		}
+		// size
+		int sizeIndex = gd.getNextChoiceIndex();
+		if (sizeIndex!=PointRoi.getDefaultSize()) {
+			PointRoi.setDefaultSize(sizeIndex);
+			redraw = true;
+		}
+		if (!multipointTool) {
+			Prefs.pointAutoMeasure = gd.getNextBoolean();
+			Prefs.pointAutoNextSlice = gd.getNextBoolean();
+			Prefs.pointAddToOverlay = gd.getNextBoolean();
+			Prefs.pointAddToManager = gd.getNextBoolean();
+			if (Prefs.pointAddToOverlay)
+				Prefs.pointAddToManager = false;
+			if (Prefs.pointAutoNextSlice&&!Prefs.pointAddToManager)
+				Prefs.pointAutoMeasure = true;
+		}
+		boolean updateLabels = false;
+		boolean noPointLabels = !gd.getNextBoolean();
+		if (noPointLabels!=Prefs.noPointLabels) {
+			redraw = true;
+			updateLabels = true;
+		}
+		Prefs.noPointLabels = noPointLabels;
+		boolean showAllPoints = gd.getNextBoolean();
+		if (showAllPoints!=Prefs.showAllPoints)
+			redraw = true;
+		Prefs.showAllPoints = showAllPoints;
+		if (multipointTool) {
+			int counter = gd.getNextChoiceIndex();
+			if (counter==0 || counter!=getCounter()) {
+				setCounter(counter);
+				redraw = true;
+			}
+		}
+		if (isMacro) {
+			PointRoi roi = getPointRoi();
+			if (roi!=null) {
+				roi.setPointType(typeIndex);
+				roi.setStrokeColor(sc);
+				roi.setSize(sizeIndex);
+				redraw = true;
+			}
+		}
+		if (redraw) {
+			ImagePlus imp = null;
+			boolean impHasPointRoi = false;
+			PointRoi roi = getPointRoi();
+			if (roi!=null) {
+				roi.setShowLabels(!Prefs.noPointLabels);
+				imp = roi.getImage();
+				impHasPointRoi = true;
+			}
+			if (updateLabels) {
+				imp = WindowManager.getCurrentImage();
+				Overlay overlay = imp!=null?imp.getOverlay():null;
+				if (overlay!=null) {
+					for (int i=0; i<overlay.size(); i++) {
+						Roi r = overlay.get(i);
+						roi = r!=null && (r instanceof PointRoi)?(PointRoi)r:null;
+						if (roi!=null) {
+							roi.setShowLabels(!Prefs.noPointLabels);
+							impHasPointRoi = true;
+						}
+					}
+				}
+			}
+			if (imp!=null && impHasPointRoi)
+				imp.draw();
+		}
+		return true;
+    }
+
+    private static int getCounter() {
+     	PointRoi roi = getPointRoi();
+     	return roi!=null?roi.getCounter():0;
+    }
+
+    private static void setCounter(int counter) {
+    	PointRoi roi = getPointRoi();
+		if (roi!=null)
+			roi.setCounter(counter);
+		PointRoi.setDefaultCounter(counter);
+    }
+
+    private static PointRoi getPointRoi() {
+    	ImagePlus imp = WindowManager.getCurrentImage();
+    	if (imp==null)
+    		return null;
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			return null;
+		if (roi instanceof PointRoi)
+			return (PointRoi)roi;
+		else
+			return null;
+    }
+
+    private static int getCount(int counter) {
+     	PointRoi roi = getPointRoi();
+     	return roi!=null?roi.getCount(counter):0;
+    }
+
+    public static void update() {
+    	if (gd!=null && gd.isShowing()) {
+			Vector choices = gd.getChoices();
+			if (choices==null || choices.size()<4)
+				return;
+			Choice counterChoice = (Choice)choices.elementAt(3);
+			int counter = getCounter();
+			int count = getCount(counter);
+			counterChoice.select(counter);
+			((Label)gd.getMessage()).setText(""+count);
+		}
+    }
+
+}
diff --git a/src/ij/plugin/Profiler.java b/src/ij/plugin/Profiler.java
new file mode 100644
index 0000000..6500876
--- /dev/null
+++ b/src/ij/plugin/Profiler.java
@@ -0,0 +1,112 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.awt.event.*;
+
+/** Implements the Analyze/Plot Profile and Edit/Options/Profile Plot Options commands. */
+public class Profiler implements PlugIn, PlotMaker {
+	ImagePlus imp;
+	boolean firstTime = true;
+	boolean plotVertically;
+
+	public void run(String arg) {
+		if (arg.equals("set"))
+			{doOptions(); return;}
+		imp = IJ.getImage();
+		if (firstTime)
+			plotVertically = Prefs.verticalProfile || IJ.altKeyDown();
+		Plot plot = getPlot();
+		firstTime = false;
+		if (plot==null)
+			return;
+		plot.setPlotMaker(this);
+		plot.show();
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.getType()==Roi.RECTANGLE)
+			plot.getImagePlus().setProperty ("Label", plotVertically ? "vertical" : "horizontal");
+	}
+	
+	public Plot getPlot() {
+		Roi roi = imp.getRoi();
+		if (roi==null || !(roi.isLine()||roi.getType()==Roi.RECTANGLE)) {
+			if (firstTime)
+				IJ.error("Plot Profile", "Line or rectangular selection required");
+			return null;
+		}
+		ProfilePlot pp = new ProfilePlot(imp, plotVertically);
+		return pp.getPlot();
+	}
+	
+	public ImagePlus getSourceImage() {
+		return imp;
+	}
+
+	public void doOptions() {
+		double ymin = ProfilePlot.getFixedMin();
+		double ymax = ProfilePlot.getFixedMax();
+		boolean fixedScale = ymin!=0.0 || ymax!=0.0;
+		boolean wasFixedScale = fixedScale;			
+		GenericDialog gd = new GenericDialog("Plot Defaults");
+		gd.setInsets(4,0,0);
+		gd.addMessage("---------- Plot Defaults ---------");
+		gd.addNumericField("Width:", PlotWindow.plotWidth, 0);
+		gd.addNumericField("Height:", PlotWindow.plotHeight, 0);
+		gd.addNumericField("Font size:", PlotWindow.getDefaultFontSize());
+		gd.setInsets(5,20,0); //distance to previous
+		//gd.addCheckbox("Draw grid lines", !PlotWindow.noGridLines);
+		gd.addCheckbox("Draw_ticks", !PlotWindow.noTicks);
+		gd.addCheckbox("Auto-close", PlotWindow.autoClose);
+		gd.addCheckbox("List values", PlotWindow.listValues);		
+		gd.setInsets(15,0,0);
+		gd.addMessage("------- Profile Plot Options -------");
+		gd.setInsets(5,20,0);
+		gd.addCheckbox("Fixed y-axis scale", fixedScale);
+		gd.addNumericField("Minimum Y:", ymin, 2);
+		gd.addNumericField("Maximum Y:", ymax, 2);
+		gd.setInsets(10,20,0);
+		gd.addCheckbox("Vertical profile", Prefs.verticalProfile);
+		gd.addCheckbox("Interpolate line profiles", PlotWindow.interpolate);
+		gd.addHelp(IJ.URL+"/docs/menus/edit.html#plot-options");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		int w = (int)gd.getNextNumber();
+		int h = (int)gd.getNextNumber();
+		if (w<Plot.MIN_FRAMEWIDTH) w = Plot.MIN_FRAMEWIDTH;
+		if (h<Plot.MIN_FRAMEHEIGHT) h = Plot.MIN_FRAMEHEIGHT;
+		int fontSize = (int)gd.getNextNumber();
+		if (!gd.invalidNumber()) {
+			PlotWindow.plotWidth = w;
+			PlotWindow.plotHeight = h;
+			PlotWindow.setDefaultFontSize(fontSize);
+		}
+		PlotWindow.noTicks = !gd.getNextBoolean();
+		//data options
+		PlotWindow.autoClose = gd.getNextBoolean();
+		PlotWindow.listValues = gd.getNextBoolean();
+		//profile plot options
+		fixedScale = gd.getNextBoolean();
+		ymin = gd.getNextNumber();
+		ymax = gd.getNextNumber();
+		//profile options
+		Prefs.verticalProfile = gd.getNextBoolean();
+		PlotWindow.interpolate = gd.getNextBoolean();
+		if (!fixedScale && !wasFixedScale && (ymin!=0.0 || ymax!=0.0))
+			fixedScale = true;
+		if (!fixedScale) {
+			ymin = 0.0;
+			ymax = 0.0;
+		} else if (ymin>ymax) {
+			double tmp = ymin;
+			ymin = ymax;
+			ymax = tmp;
+		}
+		ProfilePlot.setMinAndMax(ymin, ymax);
+		if (!Recorder.scriptMode())
+			Recorder.recordString("setOption(\"InterpolateLines\", "+PlotWindow.interpolate+");\n");
+	}
+		
+}
diff --git a/src/ij/plugin/Projector.java b/src/ij/plugin/Projector.java
new file mode 100644
index 0000000..9e4bef1
--- /dev/null
+++ b/src/ij/plugin/Projector.java
@@ -0,0 +1,871 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.awt.image.*;
+
+/**
+This plugin creates a sequence of projections of a rotating volume (stack of slices) onto a plane using
+nearest-point (surface), brightest-point, or mean-value projection or a weighted combination of nearest-
+point projection with either of the other two methods (partial opacity).  The user may choose to rotate the
+volume about any of the three orthogonal axes (x, y, or z), make portions of the volume transparent (using
+thresholding), or add a greater degree of visual realism by employing depth cues. Based on Pascal code
+contributed by Michael Castle of the  University of Michigan Mental Health Research Institute.
+*/ 
+
+public class Projector implements PlugIn {
+
+	private static final int xAxis=0, yAxis=1, zAxis=2;
+	private static final int nearestPoint=0, brightestPoint=1, meanValue=2;
+	private static final int BIGPOWEROF2 = 8192;
+	private static final String[] axisList = {"X-Axis", "Y-Axis", "Z-Axis"};
+	private static final String[] methodList = {"Nearest Point", "Brightest Point", "Mean Value"};
+	
+	private static int axisOfRotationS = yAxis;
+	private static int projectionMethodS = brightestPoint;
+	private static int initAngleS = 0;
+	private static int totalAngleS = 360;
+	private static int angleIncS = 10;
+	private static int opacityS = 0;
+	private static int depthCueSurfS = 0;
+	private static int depthCueIntS = 50;
+	private static boolean interpolateS;
+	private static boolean allTimePointsS;
+
+	private int axisOfRotation = axisOfRotationS;
+	private int projectionMethod = projectionMethodS;
+	private int initAngle = initAngleS;
+	private int totalAngle = totalAngleS;
+	private int angleInc = angleIncS;
+	private int opacity = opacityS;
+	private int depthCueSurf = depthCueSurfS;
+	private int depthCueInt = depthCueIntS;
+	private boolean interpolate = interpolateS;
+	private boolean allTimePoints = allTimePointsS;
+	
+	private boolean debugMode;
+	private double sliceInterval = 1.0; // pixels
+	private int transparencyLower = 1;
+	private int transparencyUpper = 255;	
+	private ImagePlus imp;
+	private ImageStack stack;
+	private ImageStack stack2;
+	private int width, height, imageWidth;
+	private int left, right, top, bottom;
+	private byte[] projArray, opaArray, brightCueArray;
+	private short[] zBuffer, cueZBuffer, countBuffer;
+	private int[] sumBuffer;
+	private boolean isRGB;
+	private String label = "";
+	private boolean done;
+	private boolean batchMode = Interpreter.isBatchMode();
+	private double progressBase=0.0, progressScale=1.0;
+	private boolean showMicroProgress = true;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.isInvertedLut() && !IJ.isMacro()) {
+			if (!IJ.showMessageWithCancel("3D Project", ZProjector.lutMessage))
+				return;
+		}
+		if (!showDialog())
+			return;
+		if (sliceInterval>100) {
+			IJ.error("Z spacing ("+(int)sliceInterval+") is too large.");
+			return;
+		}
+		imp.startTiming();
+		isRGB = imp.getType()==ImagePlus.COLOR_RGB;
+		if (imp.isHyperStack()) {
+			if (imp.getNSlices()>1)
+				doHyperstackProjections(imp);
+			else
+				IJ.error("Hyperstack Z dimension must be greater than 1");
+			return;
+		}
+		if (interpolate && sliceInterval>1.0) {
+			imp = zScale(imp, true);
+			if (imp==null) return;
+			sliceInterval = 1.0;
+		}
+		if (isRGB)
+			doRGBProjections(imp);
+		else {
+			ImagePlus imp2 = doProjections(imp);
+			if (imp2!=null)
+				imp2.show();
+		}
+	}
+
+	private boolean showDialog() {
+		ImageProcessor ip = imp.getProcessor();
+		double lower = ip.getMinThreshold();
+		if (lower!=ImageProcessor.NO_THRESHOLD) {
+			transparencyLower = (int)lower;
+			transparencyUpper = (int)ip.getMaxThreshold();
+		}
+		Calibration cal = imp.getCalibration();
+		boolean hyperstack = imp.isHyperStack() && imp.getNFrames()>1;
+		GenericDialog gd = new GenericDialog("3D Projection");
+		gd.addChoice("Projection method:", methodList, methodList[projectionMethod]);
+		gd.addChoice("Axis of rotation:", axisList, axisList[axisOfRotation]);
+		//gd.addMessage("");
+		gd.addNumericField("Slice spacing ("+cal.getUnits()+"):",cal.pixelDepth,2); 
+
+		gd.addNumericField("Initial angle (0-359 degrees):", initAngle, 0);
+		gd.addNumericField("Total rotation (0-359 degrees):", totalAngle, 0);
+		gd.addNumericField("Rotation angle increment:", angleInc, 0);
+		gd.addNumericField("Lower transparency bound:", transparencyLower, 0);
+		gd.addNumericField("Upper transparency bound:", transparencyUpper, 0);
+		gd.addNumericField("Opacity (0-100%):", opacity, 0);
+		gd.addNumericField("Surface depth-cueing (0-100%):", 100-depthCueSurf, 0);
+		gd.addNumericField("Interior depth-cueing (0-100%):", 100-depthCueInt, 0);
+		gd.addCheckbox("Interpolate", interpolate);
+		if (hyperstack)
+			gd.addCheckbox("All time points", allTimePoints);
+		//gd.addCheckbox("Debug Mode:", debugMode);
+
+		gd.addHelp(IJ.URL+"/docs/menus/image.html#project");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;;
+		projectionMethod = gd.getNextChoiceIndex();
+		axisOfRotation = gd.getNextChoiceIndex();
+		cal.pixelDepth = gd.getNextNumber();
+		if (cal.pixelWidth==0.0) cal.pixelWidth = 1.0;
+		sliceInterval = cal.pixelDepth/cal.pixelWidth;
+		initAngle =  (int)gd.getNextNumber();
+		totalAngle =  (int)gd.getNextNumber();
+		angleInc =  (int)gd.getNextNumber();
+		transparencyLower =  (int)gd.getNextNumber();
+		transparencyUpper =  (int)gd.getNextNumber();
+		opacity =  (int)gd.getNextNumber();
+		depthCueSurf =  100-(int)gd.getNextNumber();
+		depthCueInt =  100-(int)gd.getNextNumber();
+		interpolate =  gd.getNextBoolean();
+		if (hyperstack)
+			allTimePoints =  gd.getNextBoolean();
+		//debugMode =  gd.getNextBoolean();
+		axisOfRotationS = axisOfRotation;
+		projectionMethodS = projectionMethod;
+		initAngleS = initAngle;
+		totalAngleS = totalAngle;
+		angleIncS = angleInc;
+		opacityS = opacity;
+		depthCueSurfS = depthCueSurf;
+		depthCueIntS = depthCueInt;
+		interpolateS = interpolate;
+		allTimePointsS = allTimePoints;
+		return true;
+    }
+    	
+	private void doHyperstackProjections(ImagePlus imp) {
+		double originalSliceInterval = sliceInterval;
+		ImagePlus buildImp = null;
+		ImagePlus projImpD = null;
+		int finalChannels = imp.getNChannels();
+		int finalSlices = imp.getNSlices();
+		int finalFrames = imp.getNFrames();
+		int f1 = 0;
+		int f2 = imp.getNFrames()-1;
+		if (imp.getBitDepth()==24)
+			allTimePoints = false;
+		if (!allTimePoints)
+			f1 = f2 = imp.getFrame();
+		
+		int channels =  imp.getNChannels();
+		progressScale = 1.0/channels;
+		if (allTimePoints)
+			showMicroProgress = false;
+		int count = 1;
+		for (int c=0; c<channels; c++) {
+			for (int f=f1; f<=f2; f++) {
+				if (allTimePoints)
+					IJ.showProgress(count++, channels*imp.getNFrames());
+				sliceInterval = originalSliceInterval;
+				ImagePlus impD = (new Duplicator()).run(imp, c+1, c+1, 1, imp.getNSlices(), f+1, f+1);
+				impD.setCalibration(imp.getCalibration());
+				if (interpolate && sliceInterval>1.0) {
+					impD = zScale(impD, false);
+					if (impD==null) return;
+					sliceInterval = 1.0;
+				}
+				if (isRGB)
+					doRGBProjections(impD);
+				else {
+					progressBase = (double)c/channels;
+					projImpD = doProjections(impD);
+					if (projImpD==null) return;
+					finalSlices = projImpD.getNSlices();
+					impD.close();
+					if ((f==0||!allTimePoints)&& c==0)  {
+						buildImp = projImpD;
+						buildImp.setTitle("BuildStack");
+					} else {
+						Concatenator concat = new Concatenator();
+						buildImp =  concat.concatenate(buildImp, projImpD, false);
+					}
+				}
+				if (done) return;
+			}
+		}
+		if (imp.getNFrames()==1 || !allTimePoints) {
+			finalFrames = finalSlices;
+			finalSlices = 1;
+		}
+		if (imp.getNChannels()>1)
+			buildImp = HyperStackConverter.toHyperStack(buildImp, finalChannels, finalSlices, finalFrames, "xyztc", "composite");
+		if (imp.isComposite()) {
+			CompositeImage buildImp2 = new CompositeImage(buildImp, 0);
+			((CompositeImage)buildImp2).copyLuts(imp);
+			((CompositeImage)buildImp2).resetDisplayRanges();
+			buildImp = buildImp2;
+		}
+		buildImp.setTitle("Projections of "+imp.getShortTitle());
+		buildImp.show();
+	}
+
+    private  void doRGBProjections(ImagePlus imp) {
+    	boolean saveUseInvertingLut = Prefs.useInvertingLut;
+    	Prefs.useInvertingLut = false;
+        ImageStack[] channels = ChannelSplitter.splitRGB(imp.getStack(), true);
+        ImagePlus red = new ImagePlus("Red", channels[0]);
+        ImagePlus green = new ImagePlus("Green", channels[1]);
+        ImagePlus blue = new ImagePlus("Blue", channels[2]);
+        Calibration cal = imp.getCalibration();
+        Roi roi = imp.getRoi();
+        if (roi!=null)
+        	{red.setRoi(roi); green.setRoi(roi); blue.setRoi(roi);}
+        red.setCalibration(cal); green.setCalibration(cal); blue.setCalibration(cal);
+        label = "Red: ";
+        progressBase = 0.0;
+        progressScale = 1.0/3.0;
+        red = doProjections(red);
+        if (red==null || done) return;
+        label = "Green: ";
+        progressBase = 1.0/3.0;
+        green = doProjections(green);
+        if (green==null || done) return;
+        label = "Blue: ";
+        progressBase = 2.0/3.0;
+        blue = doProjections(blue);
+        if (blue==null || done) return;
+        int w = red.getWidth(), h = red.getHeight(), d = red.getStackSize();
+        RGBStackMerge merge = new RGBStackMerge();
+        ImageStack stack = merge.mergeStacks(w, h, d, red.getStack(), green.getStack(), blue.getStack(), true);
+        new ImagePlus("Projection of  "+imp.getShortTitle(), stack).show();
+    	Prefs.useInvertingLut = saveUseInvertingLut;
+    }
+
+	private  ImagePlus doProjections(ImagePlus imp) {
+		int nSlices;				// number of slices in volume
+		int projwidth, projheight;	//dimensions of projection image
+		int xcenter, ycenter, zcenter;	//coordinates of center of volume of rotation
+		int theta;				//current angle of rotation in degrees
+		double thetarad;			//current angle of rotation in radians
+		int sintheta, costheta;		//sine and cosine of current angle
+		int offset;
+		int curval, prevval, nextval, aboveval, belowval;
+		int n, nProjections, angle;
+		boolean minProjSize = true;
+		
+		stack = imp.getStack();
+		if (imp.getBitDepth()==16 || imp.getBitDepth()==32) {
+			ImageStack stack2 = new ImageStack(imp.getWidth(),imp.getHeight());
+			for (int i=1; i<=stack.size(); i++)
+				stack2.addSlice(stack.getProcessor(i).convertToByte(true));
+			stack = stack2;
+		}
+		if ((angleInc==0) && (totalAngle!=0))
+			angleInc = 5;
+		boolean negInc = angleInc<0;
+		if (negInc) angleInc = -angleInc;
+		angle = 0;
+		nProjections = 0;
+		if (angleInc==0)
+			nProjections = 1;
+		else {
+			while (angle<=totalAngle) {
+				nProjections++;
+				angle += angleInc;
+			}
+  		}
+		if (angle>360)
+			nProjections--;
+		if (nProjections<=0)
+			nProjections = 1;
+		if (negInc) angleInc = -angleInc;
+
+		ImageProcessor ip = imp.getProcessor();
+		Rectangle r = ip.getRoi();
+		left = r.x;
+		top = r.y;
+		right = r.x + r.width;
+		bottom = r.y + r.height;
+		nSlices = imp.getStackSize();
+		imageWidth = imp.getWidth();
+		width = right - left;
+		height = bottom - top;
+		xcenter = (left + right)/2;          //find center of volume of rotation
+		ycenter = (top + bottom)/2;
+		zcenter = (int)(nSlices*sliceInterval/2.0+0.5);
+
+		projwidth = 0;
+		projheight = 0;
+		if (minProjSize && axisOfRotation!=zAxis) {
+			switch (axisOfRotation) {
+				case xAxis:
+					projheight = (int)(Math.sqrt(nSlices*sliceInterval*nSlices*sliceInterval+height*height) + 0.5);
+					projwidth = width;
+					break;
+				case yAxis:
+					projwidth = (int)(Math.sqrt(nSlices*sliceInterval*nSlices*sliceInterval+width*width) + 0.5);
+					projheight = height;
+					break;
+			}
+		} else {
+			projwidth = (int) (Math.sqrt (nSlices*sliceInterval*nSlices*sliceInterval+width*width) + 0.5);
+			projheight = (int) (Math.sqrt (nSlices*sliceInterval*nSlices*sliceInterval+height*height) + 0.5);
+		}
+		if ((projwidth%2)==1)
+			projwidth++;
+		int projsize = projwidth * projheight;		
+		if (projwidth<=0 || projheight<=0) {
+			IJ.error("'projwidth' or 'projheight' <= 0");
+			return null;
+		}
+		try {
+			allocateArrays(nProjections, projwidth, projheight);
+		}  catch(OutOfMemoryError e) {
+			Object[] images = stack2.getImageArray();
+			if (images!=null)
+				for (int i=0; i<images.length; i++) images[i]=null;
+			stack2 = null;
+			IJ.error("Projector - Out of Memory",
+				"To use less memory, use a rectanguar\n"
+				+"selection,  reduce \"Total Rotation\",\n"
+				+"and/or increase \"Angle Increment\"."
+				);
+			return null;
+		}
+		ImagePlus projections = new ImagePlus("Projections of "+imp.getShortTitle(), stack2);
+		projections.setCalibration(imp.getCalibration());
+		//projections.show();
+		
+		IJ.resetEscape();
+		theta = initAngle;
+		IJ.resetEscape();
+		for (n=0; n<nProjections; n++) {
+			IJ.showStatus(n+"/"+nProjections);
+			showProgress((double)n/nProjections);
+			thetarad = theta * Math.PI/180.0;
+			costheta = (int)(BIGPOWEROF2*Math.cos(thetarad) + 0.5);
+			sintheta = (int)(BIGPOWEROF2*Math.sin(thetarad) + 0.5);
+			
+			projArray = (byte[])stack2.getPixels(n+1);
+			if (projArray==null)
+				break;
+			if ((projectionMethod==nearestPoint) || (opacity>0)) {
+  				for (int i=0; i<projsize; i++)
+					zBuffer[i] = (short)32767;
+			}
+			if ((opacity>0) && (projectionMethod!=nearestPoint)) {
+  				for (int i=0; i<projsize; i++)
+					opaArray[i] = (byte)0;
+			}
+			if ((projectionMethod==brightestPoint) && (depthCueInt<100)) {
+   				for (int i=0; i<projsize; i++)
+					brightCueArray[i] = (byte)0;
+ 				for (int i=0; i<projsize; i++)
+					cueZBuffer[i] = (short)0;
+			}
+			if (projectionMethod==meanValue) {
+ 				for (int i=0; i<projsize; i++)
+					sumBuffer[i] = 0;
+ 				for (int i=0; i<projsize; i++)
+					countBuffer[i] = (short)0;
+			}
+			switch (axisOfRotation) {
+				case xAxis:
+					doOneProjectionX (nSlices, ycenter, zcenter,projwidth, projheight, costheta, sintheta);
+					break;
+				case yAxis:
+					doOneProjectionY (nSlices, xcenter, zcenter,projwidth, projheight, costheta, sintheta);
+					break;
+				case zAxis:
+					doOneProjectionZ (nSlices, xcenter, ycenter, zcenter, projwidth, projheight, costheta, sintheta);
+					break;
+			}
+			
+			if (projectionMethod==meanValue) {
+				int count;
+				for (int i=0; i<projsize; i++) {
+					count = countBuffer[i];
+					if (count!=0)
+						projArray[i] = (byte)(sumBuffer[i]/count);
+				}
+			}
+			if ((opacity>0) && (projectionMethod!=nearestPoint)) {
+ 				for (int i=0; i<projsize; i++)
+					projArray[i] = (byte)((opacity*(opaArray[i]&0xff) + (100-opacity)*(projArray[i] &0xff))/100);
+			}
+			if (axisOfRotation==zAxis) {
+  				for (int i=projwidth; i<(projsize-projwidth); i++) {
+					curval = projArray[i]&0xff;
+					prevval = projArray[i-1]&0xff;
+					nextval = projArray[i+1]&0xff;
+					aboveval = projArray[i-projwidth]&0xff;
+					belowval = projArray[i+projwidth]&0xff;
+					if ((curval==0)&&(prevval!=0)&&(nextval!=0)&&(aboveval!=0)&&(belowval!=0))
+						projArray[i] = (byte)((prevval+nextval+aboveval+belowval)/4);
+				}
+			}
+
+			theta = (theta + angleInc)%360;
+			//if (projections.getWindow()==null && IJ.getInstance()!=null && !batchMode)   // is "Projections" window still open?
+			//	{done=true; break;}
+			if (IJ.escapePressed()) {
+				done=true;
+				IJ.beep();
+				IJ.showProgress(1.0);
+				IJ.showStatus("aborted");
+				break;
+			}
+			projections.setSlice(n+1);
+ 		} //end for all projections
+ 		showProgress(1.0);
+ 
+		if (debugMode) {
+			if (projArray!=null) new ImagePlus("projArray", new ByteProcessor(projwidth, projheight, projArray, null)).show();
+			if (opaArray!=null) new ImagePlus("opaArray", new ByteProcessor(projwidth, projheight, opaArray, null)).show();
+			if (brightCueArray!=null) new ImagePlus("brightCueArray", new ByteProcessor(projwidth, projheight, brightCueArray, null)).show();
+			if (zBuffer!=null) new ImagePlus("zBuffer", new ShortProcessor(projwidth, projheight, zBuffer, null)).show();
+			if (cueZBuffer!=null) new ImagePlus("cueZBuffer", new ShortProcessor(projwidth, projheight, cueZBuffer, null)).show();
+			if (countBuffer!=null) new ImagePlus("countBuffer", new ShortProcessor(projwidth, projheight, countBuffer, null)).show();
+			if (sumBuffer!=null) {
+				float[] tmp = new float[projwidth*projheight];
+				for (int i=0; i<projwidth*projheight; i++)
+					tmp[i] = sumBuffer[i];
+				new ImagePlus("sumBuffer", new FloatProcessor(projwidth, projheight, tmp, null)).show();
+			}
+		}
+
+		return projections;
+
+	} // doProjection()
+	
+	
+	private void allocateArrays(int nProjections, int projwidth, int projheight) {
+		int projsize = projwidth*projheight;
+		ColorModel cm = imp.getProcessor().getColorModel();
+		if (isRGB) cm = null;
+		stack2 = new ImageStack(projwidth, projheight, cm);
+		projArray = new byte[projsize];
+		for (int i=0; i<nProjections; i++)
+			stack2.addSlice(null, new byte[projsize]);
+		if ((projectionMethod==nearestPoint) || (opacity > 0))
+			zBuffer = new short[projsize];		
+		if ((opacity>0) && (projectionMethod!=nearestPoint))
+ 			opaArray = new byte[projsize];
+		if ((projectionMethod==brightestPoint) && (depthCueInt<100)) {
+			brightCueArray = new byte[projsize];
+			cueZBuffer = new short[projsize];
+		}
+		if (projectionMethod==meanValue) {
+			sumBuffer = new int[projsize];
+			countBuffer = new short[projsize];
+		}
+	}
+				
+
+	/**
+	This method projects each pixel of a volume (stack of slices) onto a plane as the volume rotates about the x-axis. Integer
+	arithmetic, precomputation of values, and iterative addition rather than multiplication inside a loop are used extensively
+	to make the code run efficiently. Projection parameters stored in global variables determine how the projection will be performed.
+	This procedure returns various buffers which are actually used by DoProjections() to find the final projected image for the volume
+	of slices at the current angle.
+	*/
+	private void doOneProjectionX (int nSlices, int ycenter, int zcenter, int projwidth, int projheight, int costheta, int sintheta) {
+		int     thispixel;			//current pixel to be projected
+		int    offset, offsetinit;		//precomputed offsets into an image buffer
+   		int z;					//z-coordinate of points in current slice before rotation
+		int ynew, znew;			//y- and z-coordinates of current point after rotation
+		int zmax, zmin;			//z-coordinates of first and last slices before rotation
+		int zmaxminuszmintimes100;	//precomputed values to save time in loops
+		int c100minusDepthCueInt, c100minusDepthCueSurf;
+		boolean DepthCueIntLessThan100, DepthCueSurfLessThan100;
+		boolean OpacityOrNearestPt, OpacityAndNotNearestPt;
+		boolean MeanVal, BrightestPt;
+		int ysintheta, ycostheta;
+		int zsintheta, zcostheta, ysinthetainit, ycosthetainit;
+		byte[] pixels;
+		int projsize = projwidth * projheight;
+
+		//find z-coordinates of first and last slices
+		zmax = zcenter + projheight/2;  
+		zmin = zcenter - projheight/2;
+		zmaxminuszmintimes100 = 100 * (zmax-zmin);
+		c100minusDepthCueInt = 100 - depthCueInt;
+		c100minusDepthCueSurf = 100 - depthCueSurf;
+		DepthCueIntLessThan100 = (depthCueInt < 100);
+		DepthCueSurfLessThan100 = (depthCueSurf < 100);
+		OpacityOrNearestPt = ((projectionMethod==nearestPoint) || (opacity>0));
+		OpacityAndNotNearestPt = ((opacity>0) && (projectionMethod!=nearestPoint));
+		MeanVal = (projectionMethod==meanValue);
+		BrightestPt = (projectionMethod==brightestPoint);
+		ycosthetainit = (top - ycenter - 1) * costheta;
+		ysinthetainit = (top - ycenter - 1) * sintheta;
+		offsetinit = ((projheight-bottom+top)/2) * projwidth + (projwidth - right + left)/2 - 1;
+
+		for (int k=1; k<=nSlices; k++) {
+			pixels = (byte[])stack.getPixels(k);
+			z = (int)((k-1)*sliceInterval+0.5) - zcenter;
+			zcostheta = z * costheta;
+			zsintheta = z * sintheta;
+			ycostheta = ycosthetainit;
+			ysintheta = ysinthetainit;
+		for (int j=top; j<bottom; j++) {
+			ycostheta += costheta;  //rotate about x-axis and find new y,z
+			ysintheta += sintheta;  //x-coordinates will not change
+			ynew = (ycostheta - zsintheta)/BIGPOWEROF2 + ycenter - top;
+			znew = (ysintheta + zcostheta)/BIGPOWEROF2 + zcenter;
+			offset = offsetinit + ynew * projwidth;
+			//GetLine (BoundRect.left, j, width, theLine, Info->PicBaseAddr);
+			//read each pixel in current row and project it
+			int lineIndex = j*imageWidth;
+			for (int i=left; i<right; i++) {
+				thispixel = pixels[lineIndex+i]&0xff;
+				offset++;
+				if ((offset>=projsize) || (offset<0))
+					offset = 0;
+				if ((thispixel <= transparencyUpper) && (thispixel >= transparencyLower)) {
+					if (OpacityOrNearestPt) {
+						if (znew<zBuffer[offset]) {
+							zBuffer[offset] = (short)znew;
+							if (OpacityAndNotNearestPt) {
+								if (DepthCueSurfLessThan100)
+									opaArray[offset] = (byte)(/*255 -*/ (depthCueSurf*(/*255-*/thispixel)/100 + 
+										 c100minusDepthCueSurf*(/*255-*/thispixel)*(zmax-znew)/zmaxminuszmintimes100));
+								else
+									opaArray[offset] = (byte)thispixel;
+							} else {
+								//p = (BYTE *)(projaddr + offset);
+								if (DepthCueSurfLessThan100)
+									projArray[offset] = (byte)(/*255 -*/ (depthCueSurf*(/*255-*/thispixel)/100 +
+										c100minusDepthCueSurf*(/*255-*/thispixel)*(zmax-znew)/zmaxminuszmintimes100));
+								else
+									projArray[offset]  = (byte)thispixel;
+							}
+						} // if znew<zBuffer[offset]
+					} //if OpacityOrNearestP
+						if (MeanVal) {
+							//sp = (long *)sumbufaddr;
+							sumBuffer[offset] += thispixel;
+							//cp = (short int *)countbufaddr;
+							countBuffer[offset]++;
+						} else
+							if (BrightestPt) {
+								if (DepthCueIntLessThan100) {
+									if ((thispixel>(brightCueArray[offset]&0xff)) || (thispixel==(brightCueArray[offset]&0xff)) && (znew>cueZBuffer[offset])) {
+										brightCueArray[offset] = (byte)thispixel;  //use z-buffer to ensure that if depth-cueing is on,
+										cueZBuffer[offset] = (short)znew;       //the closer of two equally-bright points is displayed.
+										projArray[offset] = (byte)((depthCueInt*thispixel/100 +
+											c100minusDepthCueInt*thispixel*(zmax-znew)/zmaxminuszmintimes100));
+									}
+							} else {
+								if (thispixel>(projArray[offset]&0xff))
+									projArray[offset] = (byte)thispixel;
+							}
+						} // else BrightestPt
+					} // if thispixel in range
+				} //for i (all pixels in row)
+			} // for j (all rows of BoundRect)
+		} // for k (all slices)
+	} //  doOneProjectionX()
+	
+
+	/** Projects each pixel of a volume (stack of slices) onto a plane as the volume rotates about the y-axis. */
+	private void  doOneProjectionY (int nSlices, int xcenter, int zcenter, int projwidth, int projheight, int costheta, int sintheta) {
+		int thispixel;			//current pixel to be projected
+		int offset, offsetinit;		//precomputed offsets into an image buffer
+		int z;					//z-coordinate of points in current slice before rotation
+  		int xnew, znew;			//y- and z-coordinates of current point after rotation
+		int zmax, zmin;			//z-coordinates of first and last slices before rotation
+  		int zmaxminuszmintimes100; //precomputed values to save time in loops
+		int c100minusDepthCueInt, c100minusDepthCueSurf;
+		boolean DepthCueIntLessThan100, DepthCueSurfLessThan100;
+		boolean OpacityOrNearestPt, OpacityAndNotNearestPt;
+		boolean MeanVal, BrightestPt;
+		int xsintheta, xcostheta;
+		int zsintheta, zcostheta, xsinthetainit, xcosthetainit;
+		byte[] pixels;
+		int projsize = projwidth * projheight;
+
+		//find z-coordinates of first and last slices
+		zmax = zcenter + projwidth/2;  
+		zmin = zcenter - projwidth/2;
+		zmaxminuszmintimes100 = 100 * (zmax-zmin);
+		c100minusDepthCueInt = 100 - depthCueInt;
+		c100minusDepthCueSurf = 100 - depthCueSurf;
+		DepthCueIntLessThan100 = (depthCueInt < 100);
+		DepthCueSurfLessThan100 = (depthCueSurf < 100);
+		OpacityOrNearestPt = ((projectionMethod==nearestPoint) || (opacity>0));
+		OpacityAndNotNearestPt = ((opacity>0) && (projectionMethod!=nearestPoint));
+		MeanVal = (projectionMethod==meanValue);
+		BrightestPt = (projectionMethod==brightestPoint);
+		xcosthetainit = (left - xcenter - 1) * costheta;
+		xsinthetainit = (left - xcenter - 1) * sintheta;
+		for (int k=1; k<=nSlices; k++) {
+ 			pixels = (byte[])stack.getPixels(k);
+			z = (int)((k-1)*sliceInterval+0.5) - zcenter;
+			zcostheta = z * costheta;
+			zsintheta = z * sintheta;
+			offsetinit = ((projheight-bottom+top)/2) * projwidth +(projwidth - right + left)/2 - projwidth;
+			for (int j=top; j<bottom; j++) {
+				xcostheta = xcosthetainit;
+				xsintheta = xsinthetainit;
+				offsetinit += projwidth;
+				int lineOffset = j*imageWidth;
+				//read each pixel in current row and project it
+				for (int i=left; i<right; i++) {
+					thispixel =pixels[lineOffset+i]&0xff;
+					xcostheta += costheta;  //rotate about x-axis and find new y,z
+					xsintheta += sintheta;  //x-coordinates will not change
+					if ((thispixel <= transparencyUpper) && (thispixel >= transparencyLower)) {
+						xnew = (xcostheta + zsintheta)/BIGPOWEROF2 + xcenter - left;
+						znew = (zcostheta - xsintheta)/BIGPOWEROF2 + zcenter;
+						offset = offsetinit + xnew;
+						if ((offset>=projsize) || (offset<0))
+							offset = 0;
+						if (OpacityOrNearestPt) {
+							if (znew<zBuffer[offset]) {
+								zBuffer[offset] = (short)znew;
+								if (OpacityAndNotNearestPt) {
+									if (DepthCueSurfLessThan100)
+										opaArray[offset] = (byte)((depthCueSurf*thispixel/100 + 
+											c100minusDepthCueSurf*thispixel*(zmax-znew)/zmaxminuszmintimes100));
+									else
+										opaArray[offset] = (byte)thispixel;
+								} else {
+									if (DepthCueSurfLessThan100)
+										projArray[offset] = (byte)((depthCueSurf*thispixel/100 +
+											 c100minusDepthCueSurf*thispixel*(zmax-znew)/zmaxminuszmintimes100));
+									else
+										projArray[offset] = (byte)thispixel;
+								}
+							} // if (znew < zBuffer[offset])
+						} // if (OpacityOrNearestPt)
+						if (MeanVal) {
+							sumBuffer[offset] += thispixel;
+							countBuffer[offset]++;
+						} else if (BrightestPt) {
+							if (DepthCueIntLessThan100) {
+								if ((thispixel>(brightCueArray[offset]&0xff)) || (thispixel==(brightCueArray[offset]&0xff)) && (znew>cueZBuffer[offset])) {
+									brightCueArray[offset] = (byte)thispixel;  //use z-buffer to ensure that if depth-cueing is on,
+									cueZBuffer[offset] = (short)znew;       //the closer of two equally-bright points is displayed.
+									projArray[offset] = (byte)((depthCueInt*thispixel/100 +
+										c100minusDepthCueInt*thispixel*(zmax-znew)/zmaxminuszmintimes100));
+								}
+							} else {
+								if (thispixel > (projArray[offset]&0xff))
+									projArray[offset] = (byte)thispixel;
+							}
+						} // if  BrightestPt
+					} //end if thispixel in range
+				} // for i (all pixels in row)
+			} // for j (all rows)
+		} // for k (all slices)
+	} // DoOneProjectionY()
+	
+
+	/** Projects each pixel of a volume (stack of slices) onto a plane as the volume rotates about the z-axis. */
+	private void doOneProjectionZ (int nSlices, int xcenter, int ycenter, int zcenter, int projwidth, int projheight, int costheta, int sintheta) {
+		int thispixel;        //current pixel to be projected
+		int offset, offsetinit; //precomputed offsets into an image buffer
+		int z;   //z-coordinate of points in current slice before rotation
+		int xnew, ynew; //y- and z-coordinates of current point after rotation
+		int zmax, zmin; //z-coordinates of first and last slices before rotation
+		int zmaxminuszmintimes100; //precomputed values to save time in loops
+		int c100minusDepthCueInt, c100minusDepthCueSurf;
+		boolean DepthCueIntLessThan100, DepthCueSurfLessThan100;
+		boolean OpacityOrNearestPt, OpacityAndNotNearestPt;
+		boolean MeanVal, BrightestPt;
+		int xsintheta, xcostheta, ysintheta, ycostheta;
+		int xsinthetainit, xcosthetainit, ysinthetainit, ycosthetainit;
+  		byte[] pixels;
+		int projsize = projwidth * projheight;
+
+		//find z-coordinates of first and last slices
+		//zmax = zcenter + projwidth/2;  
+		//zmin = zcenter - projwidth/2;
+		zmax = (int)((nSlices-1)*sliceInterval+0.5) - zcenter;
+		zmin = -zcenter;
+
+		zmaxminuszmintimes100 = 100 * (zmax-zmin);
+		c100minusDepthCueInt = 100 - depthCueInt;
+		c100minusDepthCueSurf = 100 - depthCueSurf;
+		DepthCueIntLessThan100 = (depthCueInt < 100);
+		DepthCueSurfLessThan100 = (depthCueSurf < 100);
+		OpacityOrNearestPt = ((projectionMethod==nearestPoint) || (opacity>0));
+		OpacityAndNotNearestPt = ((opacity>0) && (projectionMethod!=nearestPoint));
+		MeanVal = (projectionMethod==meanValue);
+		BrightestPt = (projectionMethod==brightestPoint);
+		xcosthetainit = (left - xcenter - 1) * costheta;
+		xsinthetainit = (left - xcenter - 1) * sintheta;
+		ycosthetainit = (top - ycenter - 1) * costheta;
+		ysinthetainit = (top - ycenter - 1) * sintheta;
+		offsetinit = ((projheight-bottom+top)/2) * projwidth + (projwidth - right + left)/2 - 1;
+ 		for (int k=1; k<=nSlices; k++) {
+			pixels = (byte[])stack.getPixels(k);
+			z = (int)((k-1)*sliceInterval+0.5) - zcenter;
+			ycostheta = ycosthetainit;
+			ysintheta = ysinthetainit;
+			for (int j=top; j<bottom; j++) {
+				ycostheta += costheta;
+				ysintheta += sintheta;
+				xcostheta = xcosthetainit;
+				xsintheta = xsinthetainit;
+				//GetLine (BoundRect.left, j, width, theLine, Info->PicBaseAddr);
+				int lineIndex = j*imageWidth;
+				//read each pixel in current row and project it
+				for (int i=left; i<right; i++) {
+					thispixel = pixels[lineIndex+i]&0xff;
+					xcostheta += costheta;  //rotate about x-axis and find new y,z
+					xsintheta += sintheta;  //x-coordinates will not change
+					if ((thispixel <= transparencyUpper) && (thispixel >= transparencyLower)) {
+						xnew = (xcostheta - ysintheta)/BIGPOWEROF2 + xcenter - left;
+						ynew = (xsintheta + ycostheta)/BIGPOWEROF2 + ycenter - top;
+						offset = offsetinit + ynew * projwidth + xnew;
+						if ((offset>=projsize) || (offset<0))
+							offset = 0;
+						if (OpacityOrNearestPt) {
+							if (z<zBuffer[offset]) {
+								zBuffer[offset] = (short)z;
+								if (OpacityAndNotNearestPt) {
+									if (DepthCueSurfLessThan100)
+										opaArray[offset] = (byte)((depthCueSurf*(thispixel)/100 +  c100minusDepthCueSurf*(thispixel)*(zmax-z)/zmaxminuszmintimes100));
+									else
+										opaArray[offset] = (byte)thispixel;
+								} else {
+									if (DepthCueSurfLessThan100) {
+										int v = (depthCueSurf*thispixel/100 + c100minusDepthCueSurf*thispixel*(zmax-z)/zmaxminuszmintimes100);
+										//f[offset] = z;
+										projArray[offset] = (byte)v;
+									} else
+										projArray[offset] = (byte)thispixel;
+								}
+							} // if z<zBuffer[offset]
+						} // OpacityOrNearestPt
+						if (MeanVal) {
+							sumBuffer[offset] += thispixel;
+							countBuffer[offset]++;
+						} else if (BrightestPt) {
+							if (DepthCueIntLessThan100) {
+								if ((thispixel>(brightCueArray[offset]&0xff)) || (thispixel==(brightCueArray[offset]&0xff)) && (z>cueZBuffer[offset])) {
+									brightCueArray[offset] = (byte)thispixel;  //use z-buffer to ensure that if depth-cueing is on,
+									cueZBuffer[offset] = (short)z;       //the closer of two equally-bright points is displayed.
+									projArray[offset] = (byte)((depthCueInt*(thispixel)/100 + c100minusDepthCueInt*(thispixel)*(zmax-z)/zmaxminuszmintimes100));
+								}
+							} else {
+								//p = (BYTE *)(projaddr + offset);
+								if (thispixel > (projArray[offset]&0xff))
+									projArray[offset] = (byte)thispixel;
+							}
+						} // else BrightestPt
+					} //if thispixel in range
+				} //for i (all pixels in row)
+			} // for j (all rows of BoundRect)
+		} // for k (all slices)
+		//new ImagePlus("f", new FloatProcessor(projwidth,projheight,f,null)).show();
+	} // end doOneProjectionZ()
+
+	private ImagePlus zScale(ImagePlus imp, boolean showProgress) {
+		if (imp.getBitDepth()==16 || imp.getBitDepth()==32)
+			IJ.run(imp, "8-bit", "");
+		IJ.showStatus("Z Scaling...");
+		ImageStack stack1 = imp.getStack();
+		int depth1 = stack1.getSize();
+		ImagePlus imp2 = null;
+		String title = imp.getTitle();
+		ImageProcessor ip = imp.getProcessor();
+		ColorModel cm = ip.getColorModel();
+		int width1 = imp.getWidth();
+		int height1 = imp.getHeight();
+		Rectangle r = ip.getRoi();
+		int width2 = r.width;
+		int height2 = r.height;
+		int depth2 = (int)(stack1.getSize()*sliceInterval+0.5);
+		imp2 = NewImage.createImage(title, width2, height2, depth2, isRGB?24:8, NewImage.FILL_BLACK);
+		if (imp2==null || depth2!=imp2.getStackSize()) return null;
+		ImageStack stack2 = imp2.getStack();
+		ImageProcessor xzPlane1 = ip.createProcessor(width2, depth1);
+		xzPlane1.setInterpolate(true);
+		ImageProcessor xzPlane2;		
+		int[] line = new int[width2];
+		for (int y=0; y<height2; y++) {
+			for (int z=0; z<depth1; z++) {
+				if (isRGB)
+					getRGBRow(stack1, r.x, r.y+y, z, width1, width2, line);
+				else
+					getByteRow(stack1, r.x, r.y+y, z, width1, width2, line);
+				xzPlane1.putRow(0, z, line, width2);
+			}
+			//if (y==r.y) new ImagePlus("xzPlane", xzPlane1).show();
+			xzPlane1.setProgressBar(null);
+			xzPlane2 = xzPlane1.resize(width2, depth2);
+			for (int z=0; z<depth2; z++) {
+				xzPlane2.getRow(0, z, line, width2);
+				if (isRGB)
+					putRGBRow(stack2, y, z, width2, line);
+				else
+					putByteRow(stack2, y, z, width2, line);
+			}
+			if (showProgress)
+				IJ.showProgress(y, height2-1);
+		}
+		//imp2.show();
+		//imp2.setCalibration(imp.getCalibration());
+		ImageProcessor ip2 = imp2.getProcessor();
+		ip2.setColorModel(cm);
+		return imp2;
+	}
+	
+	private void showProgress(double percent) {
+		if (showMicroProgress && !done)
+			IJ.showProgress(progressBase+percent*progressScale);
+	}
+
+	private void getByteRow(ImageStack stack, int x, int y, int z, int width1, int width2, int[] line) {
+		byte[] pixels = (byte[])stack.getPixels(z+1);
+		int j = x + y*width1;
+		for (int i=0; i<width2; i++)
+			line[i] = pixels[j++]&255;
+	}
+
+	private void putByteRow(ImageStack stack, int y, int z, int width, int[] line) {
+		byte[] pixels = (byte[])stack.getPixels(z+1);
+		int j = y*width;
+		for (int i=0; i<width; i++)
+			pixels[j++] = (byte)line[i];
+	}
+
+	private void getRGBRow(ImageStack stack, int x, int y, int z, int width1, int width2, int[] line) {
+		int[] pixels = (int[])stack.getPixels(z+1);
+		int j = x + y*width1;
+		for (int i=0; i<width2; i++)
+			line[i] = pixels[j++];
+	}
+
+	private void putRGBRow(ImageStack stack, int y, int z, int width, int[] line) {
+		int[] pixels = (int[])stack.getPixels(z+1);
+		int j = y*width;
+		for (int i=0; i<width; i++)
+			pixels[j++] = line[i];
+	}
+
+}
+
diff --git a/src/ij/plugin/ProxySettings.java b/src/ij/plugin/ProxySettings.java
new file mode 100644
index 0000000..4ab56e4
--- /dev/null
+++ b/src/ij/plugin/ProxySettings.java
@@ -0,0 +1,81 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.util.Tools;
+import java.util.*;
+
+/** This plugin implements the Plugins/Utilities/Proxy Settings command. It sets
+* 	the JVM proxy properties to allow the Help/Update ImageJ command
+*	and File/Open Samples menu to work on networks behind a proxy server. 
+* 
+*     @author	Dimiter Prodanov
+*/
+public class ProxySettings implements PlugIn {
+	private Properties props = System.getProperties();
+	private String proxyhost = Prefs.get("proxy.server", "");
+	private int proxyport = (int)Prefs.get("proxy.port", 8080);
+	
+	public void run(String arg) {
+		if (IJ.getApplet()!=null) return;
+		String host = System.getProperty("http.proxyHost");
+		if (host!=null) proxyhost = host;
+		String port = System.getProperty("http.proxyPort");
+		if (port!=null) {
+			double portNumber = Tools.parseDouble(port);
+			if (!Double.isNaN(portNumber))
+				proxyport = (int)portNumber;
+		}
+		if (!showDialog()) return;
+		if (!proxyhost.equals(""))
+			props.put("proxySet", "true");
+		else
+			props.put("proxySet", "false");
+		props.put("http.proxyHost", proxyhost);
+		props.put("http.proxyPort", ""+proxyport);
+		Prefs.set("proxy.server", proxyhost);
+		Prefs.set("proxy.port", proxyport);
+		String httpsHost = System.getProperty("https.proxyHost");
+		if (httpsHost == null) {
+			httpsHost = proxyhost;
+		}
+		int httpsPort = proxyport;
+		String httpsSystemPort = System.getProperty("https.proxyPort");
+		if (httpsSystemPort != null) {
+			double portNumber = Tools.parseDouble(httpsSystemPort);
+			if (!Double.isNaN(portNumber))
+				httpsPort = (int)portNumber;
+		}
+		props.put("https.proxyHost", httpsHost);
+		props.put("https.proxyPort", ""+httpsPort);
+		try {
+			System.setProperty("java.net.useSystemProxies", Prefs.useSystemProxies?"true":"false");
+		} catch(Exception e) {}
+		if (IJ.debugMode)
+			logProperties();
+	}
+	
+	public void logProperties() {
+		IJ.log("proxy set: "+ System.getProperty("proxySet"));
+		IJ.log("http proxy host: "+ System.getProperty("http.proxyHost"));
+		IJ.log("http proxy port: "+System.getProperty("http.proxyPort"));
+		IJ.log("https proxy host: "+ System.getProperty("https.proxyHost"));
+		IJ.log("https proxy port: "+System.getProperty("https.proxyPort"));
+		IJ.log("java.net.useSystemProxies: "+System.getProperty("java.net.useSystemProxies"));
+	}
+
+	boolean showDialog()   {
+		GenericDialog gd=new GenericDialog("Proxy Settings");
+		gd.addStringField("Proxy server:", proxyhost, 15);
+		gd.addNumericField("Port:", proxyport , 0);
+		gd.addCheckbox("Or, use system proxy settings", Prefs.useSystemProxies);
+		gd.addHelp(IJ.URL+"/docs/menus/edit.html#proxy");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		proxyhost = gd.getNextString();
+		proxyport = (int)gd.getNextNumber();
+		Prefs.useSystemProxies = gd.getNextBoolean();
+		return true;
+	}
+
+}
\ No newline at end of file
diff --git a/src/ij/plugin/RGBStackConverter.java b/src/ij/plugin/RGBStackConverter.java
new file mode 100644
index 0000000..2402dea
--- /dev/null
+++ b/src/ij/plugin/RGBStackConverter.java
@@ -0,0 +1,288 @@
+package ij.plugin;
+import java.awt.*;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+
+/** Converts a 2 or 3 slice stack, or a hyperstack, to RGB. */
+public class RGBStackConverter implements PlugIn, DialogListener {
+	private int channels1, slices1, frames1;
+	private int slices2, frames2;
+	private int width, height;
+	private double imageSize;
+	private static boolean staticKeep = true;
+	private boolean keep;
+	private ImagePlus image;
+	
+	public void run(String arg) {
+		ImagePlus imp = image;
+		if (imp==null)
+			imp = IJ.getImage();
+		if (!IJ.isMacro()) keep = staticKeep;
+		CompositeImage cimg = imp.isComposite()?(CompositeImage)imp:null;
+		int size = imp.getStackSize();
+		if ((size<2||size>3) && cimg==null) {
+			IJ.error("A 2 or 3 image stack, or a HyperStack, required");
+			return;
+		}
+		int type = imp.getType();
+		if (cimg==null && !(type==ImagePlus.GRAY8 || type==ImagePlus.GRAY16)) {
+			IJ.error("8-bit or 16-bit grayscale stack required");
+			return;
+		}
+		if (!imp.lock())
+			return;
+		Undo.reset();
+		String title = imp.getTitle()+" (RGB)";
+		if (cimg!=null)
+			compositeToRGB(cimg, title);
+		else if (type==ImagePlus.GRAY16) {
+			sixteenBitsToRGB(imp);
+		} else {
+			ImagePlus imp2 = imp.createImagePlus();
+			imp2.setStack(title, imp.getStack());
+	 		ImageConverter ic = new ImageConverter(imp2);
+			ic.convertRGBStackToRGB();
+			imp2.show();
+		}
+		imp.unlock();
+	}
+	
+	/** Converts the specified multi-channel (composite) image to RGB. */
+	public static void convertToRGB(ImagePlus imp) {
+		if (!imp.isComposite())
+			throw new IllegalArgumentException("Multi-channel image required");
+		RGBStackConverter converter = new RGBStackConverter();
+		ImageWindow win = imp.getWindow();
+		Point location = null;
+		if (win!=null) {
+			location = win.getLocation();
+			imp.hide();
+		}
+		converter.image = imp;
+		converter.run("");
+		if (win!=null) {
+			ImageWindow.setNextLocation(location);
+			imp.show();
+		}
+	}
+	
+	void compositeToRGB(CompositeImage imp, String title) {
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int images = channels*slices*frames;
+		if (channels==images) {
+			compositeImageToRGB(imp, title);
+			return;
+		}
+		width = imp.getWidth();
+		height = imp.getHeight();
+		imageSize = width*height*4.0/(1024.0*1024.0);
+		channels1 = imp.getNChannels();
+		slices1 = slices2 = imp.getNSlices();
+		frames1 = frames2 = imp.getNFrames();
+		int c1 = imp.getChannel();
+		int z1 = imp.getSlice();
+		int t2 = imp.getFrame();
+		if (image!=null) {
+			slices2 = slices1;
+			frames2 = frames1;
+			keep = false;
+		} else {
+			if (!showDialog())
+				return;
+		}
+		//IJ.log("HyperStackReducer-2: "+keep+" "+channels2+" "+slices2+" "+frames2);
+		String title2 = keep?WindowManager.getUniqueName(imp.getTitle()):imp.getTitle();
+		ImagePlus imp2 = imp.createHyperStack(title2, 1, slices2, frames2, 24);
+		convertHyperstack(imp, imp2);
+		if (imp.getWindow()==null && !keep) {
+			imp.setImage(imp2);
+			imp.setOverlay(imp2.getOverlay());
+			return;
+		}
+		imp2.setOpenAsHyperStack(slices2>1||frames2>1);
+		imp2.show();
+		if (!keep) {
+			imp.changes = false;
+			imp.close();
+		}
+		if (imp2.getWindow()!=null)
+			IJ.selectWindow(imp2.getID());
+	}
+
+	public void convertHyperstack(ImagePlus imp, ImagePlus imp2) {
+		int slices = imp2.getNSlices();
+		int frames = imp2.getNFrames();
+		int c1 = imp.getChannel();
+		int z1 = imp.getSlice();
+		int t1 = imp.getFrame();
+		int i = 1;
+		int c = 1;
+		ImageStack stack = imp.getStack();
+		ImageStack stack2 = imp2.getStack();
+		imp.setPositionWithoutUpdate(c1, 1, 1);
+		ImageProcessor ip = imp.getProcessor();
+		double min = ip.getMin();
+		double max = ip.getMax();
+		boolean hsbStack = imp.getProp("HSB_Stack")!=null;
+		for (int z=1; z<=slices; z++) {
+			if (slices==1) z = z1;
+			for (int t=1; t<=frames; t++) {
+				//IJ.showProgress(i++, n);
+				if (frames==1) t = t1;
+				//ip = stack.getProcessor(n1);
+				imp.setPositionWithoutUpdate(c1, z, t);
+				boolean isHSB = hsbStack && imp.getNChannels()==3;
+				int n2 = imp2.getStackIndex(c1, z, t);
+				if (isHSB) {
+					ImagePlus hsbImp = new Duplicator().run(imp, 1, 3, z, z, t, t);
+					ImageConverter ic = new ImageConverter(hsbImp);
+					ic.convertHSBToRGB();
+					stack2.setPixels(hsbImp.getProcessor().getPixels(), n2);				
+				} else {
+					Image img = imp.getImage();
+					stack2.setPixels((new ColorProcessor(img)).getPixels(), n2);				
+				}
+			}
+		}
+		imp.setPosition(c1, z1, t1);
+		imp2.resetStack();
+		imp2.setPosition(1, 1, 1);
+		
+		//Added by Marcel Boeglin 2013.09.26
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null) {
+			int firstC = c1, lastC = c1, firstZ = z1, lastZ = z1, firstT = t1, lastT = t1;
+			if (imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.COMPOSITE) {
+				firstC = 1;
+				lastC = imp.getNChannels();
+			}
+			if (slices2>1) {firstZ = 1; lastZ = slices2;}
+			if (frames2>1) {firstT = 1; lastT = frames2;}
+			Overlay overlay2 = overlay.duplicate();
+			if (slices2>1 && frames2>1)
+				overlay2.crop(firstC, lastC, firstZ, lastZ, firstT, lastT);//imp2 is hyperstack : ROI's hypercoordinates are conserved but only those with C = 1 are displayed
+			else
+				overlay2.crop(c1, c1, firstZ, lastZ, firstT, lastT); //simple stack
+			imp2.setOverlay(overlay2);
+		}
+	}
+
+	void compositeImageToRGB(CompositeImage imp, String title) {
+		if (imp.getMode()==IJ.COMPOSITE) {
+			ImagePlus imp2 = imp.createImagePlus();
+			imp.updateImage();
+			imp2.setProcessor(title, new ColorProcessor(imp.getImage()));
+			//Added by Marcel Boeglin 2013.09.26
+			Overlay overlay = imp.getOverlay();
+			Overlay overlay2 = null;
+			if (overlay!=null) {
+				overlay2 = overlay.duplicate();
+				overlay2.crop(1, imp.getNChannels());
+				imp2.setOverlay(overlay2);
+			}
+			if (image!=null && imp.getWindow()==null) {
+				imp.setImage(imp2);
+				imp.setOverlay(overlay2);
+			} else
+				imp2.show();
+			return;
+		}
+		ImageStack stack = new ImageStack(imp.getWidth(), imp.getHeight());
+		int c = imp.getChannel();
+		int n = imp.getNChannels();
+		for (int i=1; i<=n; i++) {
+			imp.setPositionWithoutUpdate(i, 1, 1);
+			stack.addSlice(null, new ColorProcessor(imp.getImage()));
+		}
+		imp.setPosition(c, 1, 1);
+		ImagePlus imp2 = imp.createImagePlus();
+		imp2.setStack(title, stack);
+		Object info = imp.getProperty("Info");
+		if (info!=null) imp2.setProperty("Info", info);		
+		imp2.setProperties(imp.getPropertiesAsArray());
+		Overlay overlay = imp.getOverlay();
+		Overlay overlay2 = null;
+		if (overlay!=null) {
+			overlay2 = overlay.duplicate();
+			overlay2.crop(1, imp.getNChannels());
+			imp2.setOverlay(overlay2);
+		}
+		if (image!=null && imp.getWindow()==null) {
+			imp.setImage(imp2);
+			imp.setOverlay(overlay2);
+		} else {
+			imp2.show();
+			imp2.setSlice(c);
+		}
+	}
+
+	void sixteenBitsToRGB(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		int width, height;
+		Rectangle r;
+		if (roi!=null) {
+			r = roi.getBounds();
+			width = r.width;
+			height = r.height;
+		} else
+			r = new Rectangle(0,0,imp.getWidth(),imp.getHeight());
+		ImageProcessor ip;
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(r.width, r.height);
+		for (int i=1; i<=stack1.getSize(); i++) {
+			ip = stack1.getProcessor(i);
+			ip.setRoi(r);
+			ImageProcessor ip2 = ip.crop();
+			ip2 = ip2.convertToByte(true);
+			stack2.addSlice(null, ip2);
+		}
+		ImagePlus imp2 = imp.createImagePlus();
+		imp2.setStack(imp.getTitle()+" (RGB)", stack2);
+	 	ImageConverter ic = new ImageConverter(imp2);
+		ic.convertRGBStackToRGB();
+		imp2.show();
+	}
+	
+	boolean showDialog() {
+		GenericDialog gd = new GenericDialog("Convert to RGB");
+		gd.setInsets(10, 20, 5);
+		gd.addMessage("Create RGB image with:");
+		gd.setInsets(0, 35, 0);
+		if (slices1!=1) gd.addCheckbox("Slices ("+slices1+")", true);
+		gd.setInsets(0, 35, 0);
+		if (frames1!=1) gd.addCheckbox("Frames ("+frames1+")", true);
+		gd.setInsets(5, 20, 0);
+		gd.addMessage(getNewDimensions()+"      ");
+		gd.setInsets(15, 20, 0);
+		gd.addCheckbox("Keep source", keep);
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		else
+			return true;
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (IJ.isMacOSX()) IJ.wait(100);
+		if (slices1!=1) slices2 = gd.getNextBoolean()?slices1:1;
+		if (frames1!=1) frames2 = gd.getNextBoolean()?frames1:1;
+		keep = gd.getNextBoolean();
+		if (!IJ.isMacro()) staticKeep = keep;
+		((Label)gd.getMessage()).setText(getNewDimensions());
+		return true;
+	}
+	
+	String getNewDimensions() {
+		String s1 = slices2>1?"x"+slices2:"";
+		String s2 = frames2>1?"x"+frames2:"";
+		String s = width+"x"+height+s1+s2;
+		s += " ("+(int)Math.round(imageSize*slices2*frames2)+"MB)";
+		return(s);
+	}
+
+	
+}
diff --git a/src/ij/plugin/RGBStackMerge.java b/src/ij/plugin/RGBStackMerge.java
new file mode 100644
index 0000000..0e645db
--- /dev/null
+++ b/src/ij/plugin/RGBStackMerge.java
@@ -0,0 +1,453 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import java.awt.image.*;
+
+/** This plugin implements the Image/Color/Merge Channels command. */
+public class RGBStackMerge implements PlugIn {
+	private static String none = "*None*";
+	private static int maxChannels = 7;
+	private static String[] colors = {"red", "green", "blue", "gray", "cyan", "magenta", "yellow"};
+	private static boolean staticCreateComposite = true;
+	private static boolean staticKeep;
+	private static boolean staticIgnoreLuts;
+	private ImagePlus imp;
+	private byte[] blank;
+	private boolean ignoreLuts;
+	private boolean autoFillDisabled;
+	private String firstChannelName;
+ 
+	public void run(String arg) {
+		imp = WindowManager.getCurrentImage();
+		mergeStacks();
+	}
+	
+	public static ImagePlus mergeChannels(ImagePlus[] images, boolean keepSourceImages) {
+		RGBStackMerge rgbsm = new RGBStackMerge();
+		return rgbsm.mergeHyperstacks(images, keepSourceImages);
+	}
+
+	/** Combines up to seven grayscale stacks into one RGB or composite stack. */
+	public void mergeStacks() {
+		int[] wList = WindowManager.getIDList();
+		if (wList==null) {
+			error("No images are open.");
+			return;
+		}
+
+		String[] titles = new String[wList.length+1];
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp = WindowManager.getImage(wList[i]);
+			titles[i] = imp!=null?imp.getTitle():"";
+		}
+		titles[wList.length] = none;
+		String[] names = getInitialNames(titles);
+		boolean createComposite = staticCreateComposite;
+		boolean keep = staticKeep;
+		ignoreLuts = staticIgnoreLuts;
+		
+		String options = Macro.getOptions();
+		boolean macro = IJ.macroRunning() && options!=null;
+		if (macro) {
+			createComposite = keep = ignoreLuts = false;
+			options = options.replaceAll("red=", "c1=");
+			options = options.replaceAll("green=", "c2=");
+			options = options.replaceAll("blue=", "c3=");
+			options = options.replaceAll("gray=", "c4=");
+			Macro.setOptions(options);
+		}
+
+		GenericDialog gd = new GenericDialog("Merge Channels");
+		gd.addChoice("C1 (red):", titles, macro?none:names[0]);
+		gd.addChoice("C2 (green):", titles, macro?none:names[1]);
+		gd.addChoice("C3 (blue):", titles, macro?none:names[2]);
+		gd.addChoice("C4 (gray):", titles, macro?none:names[3]);
+		gd.addChoice("C5 (cyan):", titles, macro?none:names[4]);
+		gd.addChoice("C6 (magenta):", titles, macro?none:names[5]);
+		gd.addChoice("C7 (yellow):", titles, macro?none:names[6]);
+
+		gd.addCheckbox("Create composite", createComposite);
+		gd.addCheckbox("Keep source images", keep);
+		gd.addCheckbox("Ignore source LUTs", ignoreLuts);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		int[] index = new int[maxChannels];
+		for (int i=0; i<maxChannels; i++) {
+			index[i] = gd.getNextChoiceIndex();
+		}
+		createComposite = gd.getNextBoolean();
+		keep = gd.getNextBoolean();
+		ignoreLuts = gd.getNextBoolean();
+		if (!macro) {
+			staticCreateComposite = createComposite;
+			staticKeep = keep;
+			staticIgnoreLuts = ignoreLuts;
+		}
+
+		ImagePlus[] images = new ImagePlus[maxChannels];
+		int stackSize = 0;
+		int width = 0;
+		int height = 0;
+		int bitDepth = 0;
+		int slices = 0;
+		int frames = 0;
+		for (int i=0; i<maxChannels; i++) {
+			//IJ.log(i+"  "+index[i]+"	"+titles[index[i]]+"  "+wList.length);
+			if (index[i]<wList.length) {
+				images[i] = WindowManager.getImage(wList[index[i]]);
+				if (width==0) {
+					width = images[i].getWidth();
+					height = images[i].getHeight();
+					stackSize = images[i].getStackSize();
+					bitDepth = images[i].getBitDepth();
+					slices = images[i].getNSlices();
+					frames = images[i].getNFrames();
+				}
+			}
+		}
+		if (width==0) {
+			error("There must be at least one source image or stack.");
+			return;
+		}
+		
+		boolean mergeHyperstacks = false;
+		for (int i=0; i<maxChannels; i++) {
+			ImagePlus img = images[i];
+			if (img==null) continue;
+			if (img.getStackSize()!=stackSize) {
+				error("The source stacks must have the same number of images.");
+				return;
+			}
+			if (img.isHyperStack()) {
+				if (img.isComposite()) {
+					CompositeImage ci = (CompositeImage)img;
+					if (ci.getMode()!=IJ.COMPOSITE) {
+						ci.setMode(IJ.COMPOSITE);
+						img.updateAndDraw();
+						if (!IJ.isMacro()) IJ.run("Channels Tool...");
+						return;
+					}
+				}
+				if (bitDepth==24) {
+					error("Source hyperstacks cannot be RGB.");
+					return;
+				}
+				if (img.getNChannels()>1) {
+					error("Source hyperstacks cannot have more than 1 channel.");
+					return;
+				}
+				if (img.getNSlices()!=slices || img.getNFrames()!=frames) {
+					error("Source hyperstacks must have the same dimensions.");
+					return;
+				}
+				mergeHyperstacks = true;
+			} // isHyperStack
+			if (img.getWidth()!=width || images[i].getHeight()!=height) {
+				error("The source images or stacks must have the same width and height.");
+				return;
+			}
+			if (createComposite && img.getBitDepth()!=bitDepth) {
+				error("The source images must have the same bit depth.");
+				return;
+			}
+		}
+
+		ImageStack[] stacks = new ImageStack[maxChannels];
+		for (int i=0; i<maxChannels; i++)
+			stacks[i] = images[i]!=null?images[i].getStack():null;
+		ImagePlus imp2;
+		boolean fourOrMoreChannelRGB = false;
+		for (int i=3; i<maxChannels; i++) {
+			if (stacks[i]!=null) {
+				if (!createComposite)	
+					fourOrMoreChannelRGB=true;
+				createComposite = true;
+			}
+		}
+		if (fourOrMoreChannelRGB)
+			createComposite = true;
+		boolean isRGB = false;
+		int extraIChannels = 0;
+		for (int i=0; i<maxChannels; i++) {
+			if (images[i]!=null) {
+				if (i>2)
+					extraIChannels++;
+				if (images[i].getBitDepth()==24)
+					isRGB = true;
+			}
+		}
+		if (isRGB && extraIChannels>0) {
+			imp2 = mergeUsingRGBProjection(images, createComposite);
+		} else if ((createComposite&&!isRGB) || mergeHyperstacks) {
+			imp2 = mergeHyperstacks(images, keep);
+			if (imp2==null) return;
+		} else {
+			ImageStack rgb = mergeStacks(width, height, stackSize, stacks[0], stacks[1], stacks[2], keep);
+			imp2 = new ImagePlus("RGB", rgb);
+			if (createComposite) {
+				imp2 = CompositeConverter.makeComposite(imp2);
+				imp2.setTitle("Composite");
+			}
+		}
+		for (int i=0; i<images.length; i++) {
+			if (images[i]!=null) {
+				imp2.setCalibration(images[i].getCalibration());
+				break;
+			}
+		}
+		if (fourOrMoreChannelRGB) {
+			if (imp2.getNSlices()==1&&imp2.getNFrames()==1) {
+				imp2 = imp2.flatten();
+				imp2.setTitle("RGB");
+			}
+		}
+		imp2.show();
+		if (!keep) {
+			for (int i=0; i<maxChannels; i++) {
+				if (images[i]!=null) {
+					images[i].changes = false;
+					images[i].close();
+				}
+			}
+			if (imp2.getWindow()!=null)
+				IJ.selectWindow(imp2.getID());
+		}
+	 }
+	 
+	 private String[] getInitialNames(String[] titles) {
+	 	String[] names = new String[maxChannels];
+	 	for (int i=0; i<maxChannels; i++)
+	 		names[i] = getName(i+1, titles);
+	 	return names;
+	 }
+	 
+	 private String getName(int channel, String[] titles) {
+	 	if (autoFillDisabled)
+	 		return none;
+	 	String str = "C"+channel;
+	 	String name = null;
+		for (int i=titles.length-1; i>=0; i--) {
+			if (titles!=null && titles[i].startsWith(str) && (firstChannelName==null||titles[i].contains(firstChannelName))) {
+				name = titles[i];
+	 			if (channel==1) {
+	 				if (name==null || name.length()<3)
+	 					return none;
+	 				firstChannelName = name.substring(3);
+	 			}
+				break;
+			}
+		}
+	 	if (name==null) {
+			for (int i=titles.length-1; i>=0; i--) {
+				int index = titles[i].indexOf(colors[channel-1]);
+				if (titles!=null && index!=-1 && (firstChannelName==null||titles[i].contains(firstChannelName))) {
+					name = titles[i];
+	 				if (channel==1 && index>0) 
+	 					firstChannelName = name.substring(0, index-1);
+					break;
+				}
+			}
+		}
+	 	if (channel==1 && name==null)
+	 		autoFillDisabled = true;
+	 	if (name!=null)
+	 		return name;
+	 	else
+	 		return none;
+	 }
+	 	
+	public ImagePlus mergeHyperstacks(ImagePlus[] images, boolean keep) {
+		int n = images.length;
+		int channels = 0;
+		for (int i=0; i<n; i++) {
+			if (images[i]!=null) channels++;
+		}
+		if (channels<2) return null;
+		ImagePlus[] images2 = new ImagePlus[channels];
+		Color[] defaultColors = {Color.red,Color.green,Color.blue,Color.white,Color.cyan,Color.magenta,Color.yellow};
+		Color[] colors = new Color[channels];
+		int j = 0;
+		for (int i=0; i<n; i++) {
+			if (images[i]!=null) {
+				images2[j] = images[i];
+				if (i<defaultColors.length)
+					colors[j] = defaultColors[i];
+				j++;
+			}
+		}
+		images = images2;
+		ImageStack[] stacks = new ImageStack[channels];
+		for (int i=0; i<channels; i++) {
+			ImagePlus imp2 = images[i];
+			if (isDuplicate(i,images))
+				imp2 = imp2.duplicate();
+			stacks[i] = imp2.getStack();
+		}
+		ImagePlus imp = images[0];
+		int w = imp.getWidth();
+		int h = imp.getHeight();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		ImageStack stack2 = new ImageStack(w, h);
+		//IJ.log("mergeHyperstacks: "+w+" "+h+" "+channels+" "+slices+" "+frames);
+		int[] index = new int[channels];
+		for (int t=0; t<frames; t++) {
+			for (int z=0; z<slices; z++) {
+				for (int c=0; c<channels; c++) {
+					ImageProcessor ip = stacks[c].getProcessor(index[c]+1);
+					if (keep)
+						ip = ip.duplicate();
+					stack2.addSlice(null, ip);
+					if (keep)
+						index[c]++;
+					else
+						stacks[c].deleteSlice(1);
+				}
+			}
+		}
+		String title = imp.getTitle();
+		if (title.startsWith("C1-"))
+			title = title.substring(3);
+		else
+			title = frames>1?"Merged":"Composite";
+		ImagePlus imp2 = new ImagePlus(title, stack2);
+		imp2.setDimensions(channels, slices, frames);
+		imp2 = new CompositeImage(imp2, IJ.COMPOSITE);
+		boolean allGrayLuts = true;
+		for (int c=0; c<channels; c++) {
+			if (images[c].getProcessor().isColorLut()) {
+				allGrayLuts = false;
+				break;
+			}
+		}
+		for (int c=0; c<channels; c++) {
+			ImageProcessor ip = images[c].getProcessor();
+			IndexColorModel cm = (IndexColorModel)ip.getColorModel();
+			LUT lut = null;
+			if (c<colors.length && colors[c]!=null && (ignoreLuts||allGrayLuts)) {
+				lut = LUT.createLutFromColor(colors[c]);
+				lut.min = ip.getMin();
+				lut.max = ip.getMax();
+			} else
+				lut =  new LUT(cm, ip.getMin(), ip.getMax());
+			((CompositeImage)imp2).setChannelLut(lut, c+1);
+		}
+		imp2.setOpenAsHyperStack(true);
+		return imp2;
+	}
+	
+	private boolean isDuplicate(int index, ImagePlus[] images) {
+		int count = 0;
+		for (int i=0; i<index; i++) {
+			if (images[index]==images[i])
+				return true;
+		}
+		return false;
+	}
+
+	/** Deprecated; replaced by mergeChannels(). */
+	public ImagePlus createComposite(int w, int h, int d, ImageStack[] stacks, boolean keep) {
+		ImagePlus[] images = new ImagePlus[stacks.length];
+		for (int i=0; i<stacks.length; i++)
+			images[i] = new ImagePlus(""+i, stacks[i]);
+		return mergeHyperstacks(images, keep);
+	}
+
+	public static ImageStack mergeStacks(ImageStack red, ImageStack green, ImageStack blue, boolean keepSource) {
+        RGBStackMerge merge = new RGBStackMerge();
+		return merge.mergeStacks(red.getWidth(), red.getHeight(), red.getSize(), red, green, blue, keepSource);
+	}
+
+	public ImageStack mergeStacks(int w, int h, int d, ImageStack red, ImageStack green, ImageStack blue, boolean keep) {
+		ImageStack rgb = new ImageStack(w, h);
+		int inc = d/10;
+		if (inc<1) inc = 1;
+		ColorProcessor cp;
+		int slice = 1;
+		blank = new byte[w*h];
+		byte[] redPixels, greenPixels, bluePixels;
+		boolean invertedRed = red!=null?red.getProcessor(1).isInvertedLut():false;
+		boolean invertedGreen = green!=null?green.getProcessor(1).isInvertedLut():false;
+		boolean invertedBlue = blue!=null?blue.getProcessor(1).isInvertedLut():false;
+		try {
+			for (int i=1; i<=d; i++) {
+				cp = new ColorProcessor(w, h);
+				redPixels = getPixels(red, slice, 0);
+				greenPixels = getPixels(green, slice, 1);
+				bluePixels = getPixels(blue, slice, 2);
+				if (invertedRed) redPixels = invert(redPixels);
+				if (invertedGreen) greenPixels = invert(greenPixels);
+				if (invertedBlue) bluePixels = invert(bluePixels);
+				cp.setRGB(redPixels, greenPixels, bluePixels);
+				if (keep)
+					slice++;
+				else {
+					if (red!=null) red.deleteSlice(1);
+					if (green!=null &&green!=red) green.deleteSlice(1);
+					if (blue!=null&&blue!=red && blue!=green) blue.deleteSlice(1);
+				}
+				rgb.addSlice(null, cp);
+				if ((i%inc) == 0) IJ.showProgress((double)i/d);
+			}
+		IJ.showProgress(1.0);
+		} catch(OutOfMemoryError o) {
+			IJ.outOfMemory("Merge Stacks");
+			IJ.showProgress(1.0);
+		}
+		return rgb;
+	}
+	
+	private ImagePlus mergeUsingRGBProjection(ImagePlus[] images, boolean createComposite) {
+		ImageStack stack = new ImageStack(imp.getWidth(),imp.getHeight());
+		for (int i=0; i<images.length; i++) {
+			if (images[i]!=null)
+				stack.addSlice(images[i].getProcessor());
+		}
+		ImagePlus imp2 = new ImagePlus("temp", stack);
+		ZProjector zp = new ZProjector(imp2);
+		zp.setMethod(ZProjector.MAX_METHOD);
+		zp.doRGBProjection();
+		imp2 = zp.getProjection();
+		if (createComposite) {
+			imp2 = CompositeConverter.makeComposite(imp2);
+			imp2.setTitle("Composite");
+		} else
+			imp2.setTitle("RGB");
+		return imp2;
+	}
+
+	byte[] getPixels(ImageStack stack, int slice, int color) {
+		 if (stack==null)
+			return blank;
+		Object pixels = stack.getPixels(slice);
+		if (!(pixels instanceof int[])) {
+			if (pixels instanceof byte[])
+				return (byte[])pixels;
+			else {
+				ImageProcessor ip = stack.getProcessor(slice);
+				ip = ip.convertToByte(true);
+				return (byte[])ip.getPixels();
+			}
+		} else { //RGB
+			ColorProcessor cp = (ColorProcessor)stack.getProcessor(slice);
+			return ((ColorProcessor)cp).getChannel(color+1);
+		}
+	}
+
+	byte[] invert(byte[] pixels) {
+		byte[] pixels2 = new byte[pixels.length];
+		System.arraycopy(pixels, 0, pixels2, 0, pixels.length);
+		for (int i=0; i<pixels2.length; i++)
+			pixels2[i] = (byte)(255-pixels2[i]&255);
+		return pixels2;
+	}
+	
+	void error(String msg) {
+		IJ.error("Merge Channels", msg);
+	}
+
+}
+
diff --git a/src/ij/plugin/RandomOvals.txt b/src/ij/plugin/RandomOvals.txt
new file mode 100644
index 0000000..88c8548
--- /dev/null
+++ b/src/ij/plugin/RandomOvals.txt
@@ -0,0 +1,15 @@
+
+  newImage("Untitled", "RGB", 400, 400, 1);
+  width = getWidth();
+  height = getHeight();
+  for (i=0; i<1000; i++) {
+      if (nSlices!=1) exit;
+      w = random()*width/2+1;
+      h = random()*width/2+1;
+      x = random()*width-w/2;
+      y = random()*height-h/2;
+      setForegroundColor(random()*255, random()*255, random()*255);
+      makeOval(x, y, w, h);
+      run("Fill");
+   }
+
diff --git a/src/ij/plugin/Raw.java b/src/ij/plugin/Raw.java
new file mode 100644
index 0000000..8c49e03
--- /dev/null
+++ b/src/ij/plugin/Raw.java
@@ -0,0 +1,67 @@
+package ij.plugin;
+
+import java.awt.*;
+import java.io.*;
+import ij.*;
+import ij.io.*;
+
+/** This plugin implements the File/Import/Raw command. */
+public class Raw implements PlugIn {
+
+	private static String defaultDirectory = null;
+
+	public void run(String arg) {
+		OpenDialog od = new OpenDialog("Open Raw...", arg);
+		String directory = od.getDirectory();
+		String fileName = od.getFileName();
+		if (fileName==null)
+			return;
+		ImportDialog d = new ImportDialog(fileName, directory);
+		d.openImage();
+	}
+
+	/** Opens the image at 'filePath' using the format specified by 'fi'. */
+	public static ImagePlus open(String filePath, FileInfo fi) {
+		File f = new File(filePath);
+		String parent = f.getParent();
+		if (parent!=null)
+			fi.directory = parent+ "/";
+		fi.fileName = f.getName();
+		return (new FileOpener(fi)).open(false);
+	}	
+
+
+	/** Opens all the images in the specified directory as a stack,
+		using the format specified by 'fi'. */
+	public static ImagePlus openAll(String directory, FileInfo fi) {
+		ImagePlus imp = openAllVirtual(directory,fi);
+		if (imp!=null)
+			return imp.duplicate();
+		else
+			return null;
+	}	
+
+	/** Opens all the images in the specified directory as a virtual stack,
+		using the format specified by 'fi'. */
+	public static ImagePlus openAllVirtual(String directory, FileInfo fi) {
+		String[] list = new File(directory).list();
+		if (list==null)
+			return null;
+		FolderOpener fo = new FolderOpener();
+		list = fo.trimFileList(list);
+		list = fo.sortFileList(list);
+		if (list==null)
+			return null;
+		directory = IJ.addSeparator(directory);
+		FileInfo[] info = new FileInfo[list.length];
+		for (int i=0; i<list.length; i++) {
+			info[i] = (FileInfo)fi.clone();
+			info[i].directory = directory;
+			info[i].fileName = list[i];
+		}
+		VirtualStack stack = new FileInfoVirtualStack(info);
+		ImagePlus imp = new ImagePlus(directory, stack);
+		return imp;
+	}	
+	
+}
diff --git a/src/ij/plugin/RectToolOptions.java b/src/ij/plugin/RectToolOptions.java
new file mode 100644
index 0000000..7e01275
--- /dev/null
+++ b/src/ij/plugin/RectToolOptions.java
@@ -0,0 +1,85 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import java.awt.*;
+
+/** This plugin implements the rounded rectangle tool dialog box. */
+public class RectToolOptions implements PlugIn, DialogListener {
+	private String strokeColorName, fillColorName;
+	private static GenericDialog gd;
+	private static double defaultStrokeWidth = 0.0;
+	private static Color defaultStrokeColor;
+
+ 	public void run(String arg) {
+ 		if (gd!=null && gd.isVisible())
+ 			gd.toFront();
+ 		else
+			rectToolOptions();
+	}
+				
+	void rectToolOptions() {
+		if (defaultStrokeColor==null)
+			defaultStrokeColor = Roi.getColor();
+		Color strokeColor = defaultStrokeColor;
+		Color fillColor = null;
+		if (defaultStrokeWidth==0.0)
+			defaultStrokeWidth = 1.0;
+		double strokeWidth = defaultStrokeWidth;
+		int cornerDiameter = (int)Prefs.get(Toolbar.CORNER_DIAMETER, 20);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Roi roi = imp!=null?imp.getRoi():null;
+		if (roi!=null && (roi.getType()==Roi.RECTANGLE)) {
+			strokeColor = roi.getStrokeColor();
+			if (strokeColor==null)
+				strokeColor = Roi.getColor();
+			fillColor = roi.getFillColor();
+			strokeWidth = roi.getStrokeWidth();
+			cornerDiameter = roi.getCornerDiameter();
+		}
+		String strokec = Colors.colorToString(strokeColor);
+		String fillc = Colors.colorToString(fillColor);
+
+		gd = GUI.newNonBlockingDialog("Rounded Rectangle Tool");
+		gd.addSlider("Stroke width:", 1, 25, (int)strokeWidth);
+		gd.addSlider("Corner diameter:", 0, 200, cornerDiameter);
+		gd.addStringField("Color: ", strokec);
+		gd.addStringField("Fill color: ", fillc);
+		gd.addDialogListener(this);
+		gd.showDialog();
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		double strokeWidth2 = gd.getNextNumber();
+		int cornerDiameter2 = (int)gd.getNextNumber();
+		String strokec2 = gd.getNextString();
+		String fillc2 = gd.getNextString();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Roi roi = imp!=null?imp.getRoi():null;
+		Color strokeColor2 = Colors.decode(strokec2, defaultStrokeColor);
+		if (roi!=null && (roi.getType()==Roi.RECTANGLE)) {
+			roi.setStrokeWidth((int)strokeWidth2);
+			roi.setCornerDiameter((int)(cornerDiameter2));
+			strokeColor2 = Colors.decode(strokec2, roi.getStrokeColor());
+			Color fillColor = Colors.decode(fillc2, roi.getFillColor());
+			roi.setStrokeColor(strokeColor2);
+			roi.setFillColor(fillColor);
+		}
+		defaultStrokeWidth = strokeWidth2;
+		defaultStrokeColor = strokeColor2;
+		Toolbar.setRoundRectArcSize(cornerDiameter2);
+		if (cornerDiameter2>0) {
+			if (!Toolbar.getToolName().equals("roundrect"))
+				IJ.setTool("roundrect");
+		}
+		return true;
+	}
+	
+	public static Color getDefaultStrokeColor() {
+		return defaultStrokeColor;
+	}
+	
+	public static float getDefaultStrokeWidth() {
+		return (float)defaultStrokeWidth;
+	}
+	
+} 
diff --git a/src/ij/plugin/Resizer.java b/src/ij/plugin/Resizer.java
new file mode 100644
index 0000000..fa502e2
--- /dev/null
+++ b/src/ij/plugin/Resizer.java
@@ -0,0 +1,404 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+
+/** This plugin implements the Edit/Crop and Image/Adjust/Size commands. */
+public class Resizer implements PlugIn, TextListener, ItemListener  {
+	public static final int IN_PLACE=16, SCALE_T=32;
+    private static int newWidth;
+    private static int newHeight;
+    private static boolean constrain = true;
+    private static boolean averageWhenDownsizing = true;
+	private static int interpolationMethod = ImageProcessor.BILINEAR;
+	private String[] methods = ImageProcessor.getInterpolationMethods();
+    private Vector fields, checkboxes;
+	private double origWidth, origHeight;
+	private boolean sizeToHeight;
+ 
+	public void run(String arg) {
+		boolean crop = arg.equals("crop");
+		ImagePlus imp = IJ.getImage();
+		ImageProcessor ip = imp.getProcessor();
+		Roi roi = imp.getRoi();
+		int bitDepth = imp.getBitDepth();
+		double min = ip.getMin();
+		double max = ip.getMax();	
+		if (!imp.okToDeleteRoi())
+			return;
+		if ((roi==null||!roi.isArea()) && crop) {
+			IJ.error(crop?"Crop":"Resize", "Area selection required");
+			return;
+		}
+		if (!imp.lock()) {
+			IJ.log("<<Resizer: image is locked ("+imp+")>>");
+			return;
+		}
+		Rectangle r = ip.getRoi();
+		origWidth = r.width;;
+		origHeight = r.height;
+		sizeToHeight=false;
+	    boolean restoreRoi = crop && roi!=null && roi.getType()!=Roi.RECTANGLE;
+		if (roi!=null) {
+			Rectangle b = roi.getBounds();
+			int w = ip.getWidth();
+			int h = ip.getHeight();
+			if (b.x<0 || b.y<0 || b.x+b.width>w || b.y+b.height>h) {
+				ShapeRoi shape1 = new ShapeRoi(roi);
+				ShapeRoi shape2 = new ShapeRoi(new Roi(0, 0, w, h));
+				roi = shape2.and(shape1);
+				if (roi.getBounds().width==0 || roi.getBounds().height==0) {
+					if (IJ.isMacro())
+						IJ.log("Selection is outside image");
+					else
+						throw new IllegalArgumentException("Selection is outside image");
+				}
+				if (restoreRoi) imp.setRoi(roi);
+			}
+		}
+		int stackSize= imp.getStackSize();
+		int z1 = imp.getStackSize();
+		int t1 = 0;
+		int z2=0, t2=0;
+		int saveMethod = interpolationMethod;
+		if (crop) {
+			Rectangle bounds = roi.getBounds();
+			newWidth = bounds.width;
+			newHeight = bounds.height;
+			interpolationMethod = ImageProcessor.NONE;
+		} else {
+			if (newWidth==0 || newHeight==0) {
+				newWidth = (int)origWidth/2;
+				newHeight = (int)origHeight/2;
+			}
+			if (constrain) newHeight = (int)(newWidth*(origHeight/origWidth));
+			if (stackSize>1) {
+				newWidth = (int)origWidth;
+				newHeight = (int)origHeight;
+			}
+			GenericDialog gd = new GenericDialog("Resize");
+			gd.addNumericField("Width (pixels):", newWidth, 0);
+			gd.addNumericField("Height (pixels):", newHeight, 0);
+			if (imp.isHyperStack()) {
+				z1 = imp.getNSlices();
+				t1 = imp.getNFrames();
+			}
+			if (z1==stackSize)
+				gd.addNumericField("Depth (images):", z1, 0);
+			else if (z1>1 && z1<stackSize)
+				gd.addNumericField("Depth (slices):", z1, 0);
+			if (t1>1)
+				gd.addNumericField("Time (frames):", t1, 0);
+			gd.addCheckbox("Constrain aspect ratio", constrain);
+			gd.addCheckbox("Average when downsizing", averageWhenDownsizing);
+			gd.addChoice("Interpolation:", methods, methods[interpolationMethod]);
+			fields = gd.getNumericFields();
+			if (!IJ.macroRunning()) {
+				for (int i=0; i<2; i++)
+					((TextField)fields.elementAt(i)).addTextListener(this);
+			}
+			checkboxes = gd.getCheckboxes();
+			if (!IJ.macroRunning())
+				((Checkbox)checkboxes.elementAt(0)).addItemListener(this);
+			gd.showDialog();
+			if (gd.wasCanceled()) {
+				imp.unlock();
+				return;
+			}
+			newWidth = (int)gd.getNextNumber();
+			newHeight = (int)gd.getNextNumber();
+			if (z1==stackSize || (z1>1 && z1<stackSize))
+				z2 = (int)gd.getNextNumber();
+			if (t1>1)
+				t2 = (int)gd.getNextNumber();
+			if (gd.invalidNumber()) {
+				IJ.error("Width or height are invalid.");
+				imp.unlock();
+				return;
+			}
+			constrain = gd.getNextBoolean();
+			averageWhenDownsizing = gd.getNextBoolean();
+			interpolationMethod = gd.getNextChoiceIndex();
+			if (constrain && newWidth==0)
+				sizeToHeight = true;
+			if (newWidth<=0.0 && !constrain)  newWidth = 50;
+			if (newHeight<=0.0) newHeight = 50;
+		}
+		
+		if (!crop && constrain) {
+			if (sizeToHeight)
+				newWidth = (int)Math.round(newHeight*(origWidth/origHeight));
+			else
+				newHeight = (int)Math.round(newWidth*(origHeight/origWidth));
+		}
+		ip.setInterpolationMethod(interpolationMethod);
+		Undo.setup(crop?Undo.TRANSFORM:Undo.TYPE_CONVERSION, imp);
+			    	
+		if (roi!=null || newWidth!=origWidth || newHeight!=origHeight) {
+			try {
+				StackProcessor sp = new StackProcessor(imp.getStack(), ip);
+				ImageStack s2 = sp.resize(newWidth, newHeight, averageWhenDownsizing);
+				int newSize = s2.getSize();
+				if (s2.getWidth()>0 && newSize>0) {
+					if (restoreRoi)
+						imp.deleteRoi();
+					Calibration cal = imp.getCalibration();
+					if (cal.scaled()) {
+						cal.pixelWidth *= origWidth/newWidth;
+						cal.pixelHeight *= origHeight/newHeight;
+					}
+					if (crop&&roi!=null&&(cal.xOrigin!=0.0||cal.yOrigin!=0.0)) {
+						cal.xOrigin -= roi.getBounds().x;
+						cal.yOrigin -= roi.getBounds().y;
+					}
+					imp.setStack(null, s2);
+					if (crop && roi!=null) {
+						Overlay overlay = imp.getOverlay();
+						if (overlay!=null && !imp.getHideOverlay()) {
+							Overlay overlay2 = overlay.crop(roi.getBounds());
+							imp.setOverlay(overlay2);
+						}
+					} else {
+						Overlay overlay = imp.getOverlay();
+						if (overlay!=null && !imp.getHideOverlay())
+							imp.setOverlay(overlay.scale(newWidth/origWidth,newHeight/origHeight));
+						else
+							imp.setOverlay(null);
+					}
+					if (restoreRoi && roi!=null) {
+						roi.setLocation(0, 0);
+						imp.setRoi(roi);
+						imp.draw();
+					}
+				}
+				if (stackSize>1 && newSize<stackSize)
+					IJ.error("ImageJ ran out of memory causing \nthe last "+(stackSize-newSize)+" slices to be lost.");
+			} catch(OutOfMemoryError o) {
+				IJ.outOfMemory("Resize");
+			}
+			imp.changes = true;
+			if (crop)
+				interpolationMethod = saveMethod;
+		}
+		
+		ImagePlus imp2 = null;
+		if (z2>0 && z2!=z1)
+			imp2 = zScale(imp, z2, interpolationMethod+IN_PLACE);
+		if (t2>0 && t2!=t1)
+			imp2 = zScale(imp2!=null?imp2:imp, t2, interpolationMethod+IN_PLACE+SCALE_T);
+		imp.unlock();
+		if (imp2!=null && imp2!=imp) {
+			imp.changes = false;
+			imp.close();
+			imp2.show();
+		} else if (crop && (bitDepth==16 || bitDepth==32)) {
+			imp.setDisplayRange(min, max);
+			imp.updateAndDraw();
+		}
+		Scaler.record(imp, newWidth, newHeight, 1, interpolationMethod);	
+	}
+
+	public ImagePlus zScale(ImagePlus imp, int newDepth, int interpolationMethod) {
+		ImagePlus imp2 = null;
+		if (imp.isHyperStack())
+			imp2 = zScaleHyperstack(imp, newDepth, interpolationMethod);
+		else {
+			boolean inPlace = (interpolationMethod&IN_PLACE)!=0;
+			interpolationMethod = interpolationMethod&15;
+			int stackSize = imp.getStackSize();
+			int bitDepth = imp.getBitDepth();
+			imp2 = resizeZ(imp, newDepth, interpolationMethod);
+			if (imp2==null)
+				return null;
+			double min = imp.getDisplayRangeMin();
+			double max = imp.getDisplayRangeMax();
+			imp2.setDisplayRange(min, max);
+		}
+		if (imp2==null)
+			return null;
+		if (imp2!=imp) {
+			if (imp.isComposite()) {
+				imp2 = new CompositeImage(imp2, ((CompositeImage)imp).getMode());
+				((CompositeImage)imp2).copyLuts(imp);
+			} else
+				imp2.setLut(imp.getProcessor().getLut());
+		}
+		imp2.setCalibration(imp.getCalibration());
+		Calibration cal = imp2.getCalibration();
+		if (cal.scaled()) cal.pixelDepth *= (double)imp.getNSlices()/imp2.getNSlices();
+		Object info = imp.getProperty("Info");
+		if (info!=null) imp2.setProperty("Info", info);
+		imp2.setProperties(imp.getPropertiesAsArray());
+		if (imp.isHyperStack())
+			imp2.setOpenAsHyperStack(imp.isHyperStack());
+		return imp2;
+	}
+
+	private ImagePlus zScaleHyperstack(ImagePlus imp, int depth2, int interpolationMethod) {
+		boolean inPlace = (interpolationMethod&IN_PLACE)!=0;
+		boolean scaleT = (interpolationMethod&SCALE_T)!=0;
+		interpolationMethod = interpolationMethod&15;
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int slices2 = slices;
+		int frames2 = frames;
+		int bitDepth = imp.getBitDepth();
+		if (slices==1 && frames>1)
+			scaleT = true;
+		if (scaleT)
+			frames2 = depth2;
+		else
+			slices2 = depth2;
+		double scale = (double)(depth2-1)/slices;
+		if (scaleT) scale = (double)(depth2-1)/frames;
+		ImageStack stack1 = imp.getStack();
+		int width = stack1.getWidth();
+		int height = stack1.getHeight();
+		ImagePlus imp2 = IJ.createImage(imp.getTitle(), bitDepth+"-bit", width, height, channels*slices2*frames2);
+		if (imp2==null) return null;
+		imp2.setDimensions(channels, slices2, frames2);
+		ImageStack stack2 = imp2.getStack();
+		ImageProcessor ip = imp.getProcessor();
+		int count = 0;
+		if (scaleT) {
+			IJ.showStatus("T Scaling...");
+			ImageProcessor xtPlane1 = ip.createProcessor(width, frames);
+			xtPlane1.setInterpolationMethod(interpolationMethod);
+			ImageProcessor xtPlane2;		
+			Object xtpixels1 = xtPlane1.getPixels();
+			int last = slices*channels*height-1;
+			for (int z=1; z<=slices; z++) {
+				for (int c=1; c<=channels; c++) {
+					for (int y=0; y<height; y++) {
+						IJ.showProgress(count++, last);
+						for (int t=1; t<=frames; t++) {
+							int index = imp.getStackIndex(c, z, t);
+							//IJ.log("1: "+c+" "+z+" "+t+" "+index+" "+xzPlane1);
+							Object pixels1 = stack1.getPixels(index);
+							System.arraycopy(pixels1, y*width, xtpixels1, (t-1)*width, width);
+						}
+						xtPlane2 = xtPlane1.resize(width, depth2, averageWhenDownsizing);
+						Object xtpixels2 = xtPlane2.getPixels();
+						for (int t=1; t<=frames2; t++) {
+							int index = imp2.getStackIndex(c, z, t);
+							//IJ.log("2: "+c+" "+z+" "+t+" "+index+" "+xzPlane2);
+							Object pixels2 = stack2.getPixels(index);
+							System.arraycopy(xtpixels2, (t-1)*width, pixels2, y*width, width);
+						}
+					}
+				}
+			}
+		} else {
+			IJ.showStatus("Z Scaling...");
+			ImageProcessor xzPlane1 = ip.createProcessor(width, slices);
+			xzPlane1.setInterpolationMethod(interpolationMethod);
+			ImageProcessor xzPlane2;		
+			Object xypixels1 = xzPlane1.getPixels();
+			int last = frames*channels*height-1;
+			for (int t=1; t<=frames; t++) {
+				for (int c=1; c<=channels; c++) {
+					for (int y=0; y<height; y++) {
+						IJ.showProgress(count++, last);
+						for (int z=1; z<=slices; z++) {
+							int index = imp.getStackIndex(c, z, t);
+							Object pixels1 = stack1.getPixels(index);
+							System.arraycopy(pixels1, y*width, xypixels1, (z-1)*width, width);
+						}
+						xzPlane2 = xzPlane1.resize(width, depth2, averageWhenDownsizing);
+						Object xypixels2 = xzPlane2.getPixels();
+						for (int z=1; z<=slices2; z++) {
+							int index = imp2.getStackIndex(c, z, t);
+							Object pixels2 = stack2.getPixels(index);
+							System.arraycopy(xypixels2, (z-1)*width, pixels2, y*width, width);
+						}
+					}
+				}
+			}
+		}
+		imp2.setDimensions(channels, slices2, frames2);
+		return imp2;
+	}
+
+	private ImagePlus resizeZ(ImagePlus imp, int newDepth, int interpolationMethod) {
+		ImageStack stack1 = imp.getStack();
+		int width = stack1.getWidth();
+		int height = stack1.getHeight();
+		int depth = stack1.getSize();
+		int bitDepth = imp.getBitDepth();
+		ImagePlus imp2 = IJ.createImage(imp.getTitle(), bitDepth+"-bit", width, height, newDepth);
+		if (imp2==null) return null;
+		ImageStack stack2 = imp2.getStack();
+		ImageProcessor ip = imp.getProcessor();
+		ImageProcessor xzPlane1 = ip.createProcessor(width, depth);
+		xzPlane1.setInterpolationMethod(interpolationMethod);
+		ImageProcessor xzPlane2;		
+		Object xzpixels1 = xzPlane1.getPixels();
+		IJ.showStatus("Z Scaling...");
+		for (int y=0; y<height; y++) {
+			IJ.showProgress(y, height-1);
+			for (int z=0; z<depth; z++) { // get xz plane at y
+				Object pixels1 = stack1.getPixels(z+1);
+				System.arraycopy(pixels1, y*width, xzpixels1, z*width, width);
+			}
+			xzPlane2 = xzPlane1.resize(width, newDepth, averageWhenDownsizing);
+			Object xypixels2 = xzPlane2.getPixels();
+			for (int z=0; z<newDepth; z++) {
+				Object pixels2 = stack2.getPixels(z+1);
+				System.arraycopy(xypixels2, z*width, pixels2, y*width, width);
+			}
+		}
+		return imp2;
+	}
+
+    public void textValueChanged(TextEvent e) {
+    	TextField widthField = (TextField)fields.elementAt(0);
+    	TextField heightField = (TextField)fields.elementAt(1);
+        int width = (int)Tools.parseDouble(widthField.getText(),-99);
+        int height = (int)Tools.parseDouble(heightField.getText(),-99);
+        if (width==-99 || height==-99)
+        	return;
+        if (constrain) {
+        	if (width!=newWidth) {
+         		sizeToHeight = false;
+        		newWidth = width;
+				updateFields();
+         	} else if (height!=newHeight) {
+         		sizeToHeight = true;
+        		newHeight = height;
+				updateFields();
+			}
+        }
+    }
+    
+    void updateFields() {
+		if (sizeToHeight) {
+			newWidth = (int)Math.round(newHeight*(origWidth/origHeight));
+			TextField widthField = (TextField)fields.elementAt(0);
+			widthField.setText(""+newWidth);
+		} else {
+			newHeight = (int)Math.round(newWidth*(origHeight/origWidth));
+			TextField heightField = (TextField)fields.elementAt(1);
+			heightField.setText(""+newHeight);
+		}
+   }
+
+	public void itemStateChanged(ItemEvent e) {
+		Checkbox cb = (Checkbox)checkboxes.elementAt(0);
+        boolean newConstrain = cb.getState();
+        if (newConstrain && newConstrain!=constrain)
+        	updateFields();
+        constrain = newConstrain;
+	}
+	
+	public void setAverageWhenDownsizing(boolean averageWhenDownsizing) {
+		this. averageWhenDownsizing = averageWhenDownsizing;
+	}
+
+}
diff --git a/src/ij/plugin/RoiEnlarger.java b/src/ij/plugin/RoiEnlarger.java
new file mode 100644
index 0000000..aeb5246
--- /dev/null
+++ b/src/ij/plugin/RoiEnlarger.java
@@ -0,0 +1,277 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import ij.plugin.filter.EDM;
+import ij.plugin.filter.ThresholdToSelection;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.util.Vector;
+
+/** This plugin, which enlarges or shrinks selections, implements the Edit/Selection/Enlarge command. */
+public class RoiEnlarger implements PlugIn, DialogListener {
+	private static final String DISTANCE_KEY = "enlarger.distance";
+	private static final String USE_PIXELS_KEY = "enlarger.pixels";
+	private double defaultDistance = Prefs.get(DISTANCE_KEY, 15); // pixels
+	private boolean defaultUsePixels = Prefs.get(USE_PIXELS_KEY, false);
+	private Calibration cal;
+	private Label unitsLabel;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		Roi roi = imp.getRoi();
+		if (roi==null || roi.isLine()) {
+			IJ.error("Enlarge", "This command requires an area selection");
+			return;
+		}
+		if (!imp.okToDeleteRoi())
+			return;
+		double n = showDialog(imp, defaultDistance);
+		if (Double.isNaN(n))
+			return;
+		Prefs.set(DISTANCE_KEY, defaultDistance);
+		Prefs.set(USE_PIXELS_KEY, defaultUsePixels);
+		Roi roi2 = Math.abs(n)<256?enlarge255(roi,n):enlarge(roi,n);
+		if (roi2!=null) {
+			imp.setRoi(roi2);
+			Roi.setPreviousRoi(roi);
+			defaultDistance = n;
+		}
+		int pixels = (int)Math.round(n);
+		Recorder.recordCall("RoiEnlarger.enlarge(imp, "+pixels+");");
+	}
+
+	public static void enlarge(ImagePlus imp, int pixels) {
+		Roi roi = imp.getRoi();
+		if (roi==null || roi.isLine() || (roi instanceof PointRoi))
+			return;
+		Roi roi2 = Math.abs(pixels)<256?enlarge255(roi,pixels):enlarge(roi,pixels);
+		if (roi2!=null)
+			imp.setRoi(roi2);
+	}
+
+	public double showDialog(ImagePlus imp, double pixels) {
+		cal = imp.getCalibration();
+		boolean scaled = cal.scaled();
+		double pixelWidth = cal.pixelWidth;
+		boolean xyScaleDifferent = scaled && cal.pixelWidth != cal.pixelHeight;
+		boolean usePixels = defaultUsePixels;
+		double n = pixels;
+		int decimalPlaces = 0;
+		if (scaled && !usePixels) {
+			n *= pixelWidth;
+			decimalPlaces = getDecimalPlaces(pixelWidth, n);
+		}
+		GenericDialog gd = new GenericDialog("Enlarge Selection");
+		gd.addNumericField("Enlarge by", n, decimalPlaces);
+		String units = scaled && !usePixels ? cal.getUnits()+"       " : "pixels ";
+		gd.addToSameRow();
+		gd.addMessage(units.replace('\n', ' ')); //just in case of a newline character, which would make it a MultiLineLabel
+		unitsLabel = (Label)gd.getMessage();
+		if (scaled) {
+			gd.setInsets(0, 20, 0);     //top left bottom
+			gd.addCheckbox("Pixel units", usePixels);
+		}
+		gd.setInsets(10, 0, 0);
+		gd.addMessage("Enter negative number to shrink", null, Color.darkGray);
+		if (xyScaleDifferent) {
+			gd.setInsets(5, 0, 0);
+			gd.addMessage(" \n ", null, Color.RED);
+		}
+		gd.addDialogListener(this);
+		if (xyScaleDifferent && Macro.getOptions()==null)
+			updateWarning(gd); //in interactive mode only
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return Double.NaN;
+		n = gd.getNextNumber();
+		if (scaled)
+			usePixels = gd.getNextBoolean();
+		pixels = usePixels ? n : n/pixelWidth;
+		defaultDistance = pixels;
+		defaultUsePixels = usePixels;
+		return pixels;
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		Vector checkboxes = gd.getCheckboxes();
+		Checkbox usePixelsCbx = checkboxes == null ? null : (Checkbox)checkboxes.get(0);
+		double n = gd.getNextNumber();
+		boolean usePixels = cal.scaled() ? gd.getNextBoolean() : true; //getNextBoolean also needed for macro recorded
+		if (e!=null && e.getSource() == usePixelsCbx) {
+			double pixelWidth = cal.pixelWidth;
+			int decimalPlaces = 0;
+			if (usePixels) {
+				n /= pixelWidth;    //scaled to pixels
+			} else {
+				n *= pixelWidth;    //pixels to scaled
+				decimalPlaces = getDecimalPlaces(pixelWidth, n);
+			}
+			TextField numberField = (TextField)gd.getNumericFields().get(0);
+			numberField.setText(IJ.d2s(n, decimalPlaces));
+			if (unitsLabel != null) unitsLabel.setText(usePixels ? "pixels" : cal.getUnits());
+			boolean xyScaleDifferent = cal.scaled() && cal.pixelWidth != cal.pixelHeight;
+			if (xyScaleDifferent && usePixelsCbx != null) updateWarning(gd);
+		}
+		return !gd.invalidNumber();
+	}
+
+	private void updateWarning(GenericDialog gd) {
+		Checkbox usePixelsCbx = (Checkbox)gd.getCheckboxes().get(0);
+		MultiLineLabel warningLabel = (MultiLineLabel)gd.getMessage();
+		boolean showWarning = !usePixelsCbx.getState(); //warn if not pixels units
+		warningLabel.setText(showWarning ? "WARNING: x & y scales differ\nConversion to pixels uses x scale" : " \n ");
+	}
+
+	//decimal places for displaying the scaled enlarge/shrink value
+	private static int getDecimalPlaces(double pixelWidth, double number) {
+		if (number == (int)number || pixelWidth == 1) return 0;
+		int decimalPlaces = (int)(-Math.log10(pixelWidth)+1.9);
+		if (decimalPlaces < 0) decimalPlaces = 0;
+		if (decimalPlaces >9) decimalPlaces = 9;
+		return decimalPlaces;
+	}
+
+	public static Roi enlarge(Roi roi, double pixels) {
+		if (pixels==0)
+			return roi;
+		int type = roi.getType();
+		int n = (int)Math.round(pixels);
+		if (type==Roi.RECTANGLE || type==Roi.OVAL)
+			return enlargeRectOrOval(roi, n);
+		if (n<0)
+			return shrink(roi, -n);
+		Rectangle bounds = roi.getBounds();
+		int width = bounds.width;
+		int height = bounds.height;
+		width += 2*n + 2;
+		height += 2*n + 2;
+		ImageProcessor ip = new ByteProcessor(width, height);
+		ip.invert();
+		roi.setLocation(n+1, n+1);
+		ip.setColor(0);
+		ip.fill(roi);
+		ip.setThreshold(0, 0, ImageProcessor.NO_LUT_UPDATE);
+		Roi roi2 = (new ThresholdToSelection()).convert(ip);
+		Rectangle bounds2 = roi2.getBounds();
+		int xoffset = bounds2.x - (n+1);
+		int yoffset = bounds2.y - (n+1);
+		roi.setLocation(bounds.x, bounds.y);
+		FloatProcessor edm = new EDM().makeFloatEDM (ip, 0, false);
+		edm.setThreshold(0, n, ImageProcessor.NO_LUT_UPDATE);
+		roi2 = (new ThresholdToSelection()).convert(edm);
+		if (roi2==null)
+			return roi;
+		roi2.copyAttributes(roi);
+		roi2.setLocation(bounds.x-n+xoffset, bounds.y-n+yoffset);
+		if (roi.getStroke()!=null)
+			roi2.setStroke(roi.getStroke());
+		return roi2;
+	}
+
+	private static Roi enlargeRectOrOval(Roi roi, int n) {
+		Rectangle bounds = roi.getBounds();
+		bounds.x -= n;
+		bounds.y -= n;
+		bounds.width += 2*n;
+		bounds.height += 2*n;
+		if (bounds.width<=0 || bounds.height<=0)
+			return roi;
+		Roi roi2 = null;
+		if (roi.getType()==Roi.RECTANGLE)
+			roi2 = new Roi(bounds.x, bounds.y, bounds.width, bounds.height);
+		else
+			roi2 = new OvalRoi(bounds.x, bounds.y, bounds.width, bounds.height);
+		roi2.copyAttributes(roi);
+		return roi2;
+	}
+
+	private static Roi shrink(Roi roi, int n) {
+		Rectangle bounds = roi.getBounds();
+		int width = bounds.width + 2;
+		int height = bounds.height + 2;
+		ImageProcessor ip = new ByteProcessor(width, height);
+		roi.setLocation(1, 1);
+		ip.setColor(255);
+		ip.fill(roi);
+		roi.setLocation(bounds.x, bounds.y);
+		FloatProcessor edm = new EDM().makeFloatEDM (ip, 0, false);
+		edm.setThreshold(n+1, Float.MAX_VALUE, ImageProcessor.NO_LUT_UPDATE);
+		Roi roi2 = (new ThresholdToSelection()).convert(edm);
+		if (roi2==null)
+			return roi;
+		Rectangle bounds2 = roi2.getBounds();
+		if (bounds2.width<=0 && bounds2.height<=0)
+			return roi;
+		roi2.copyAttributes(roi);
+		roi2.setLocation(bounds.x+bounds2.x-1, bounds.y+bounds2.y-1);
+		return roi2;
+	}
+
+	public static Roi enlarge255(Roi roi, double pixels) {
+		if (pixels==0)
+			return roi;
+		int type = roi.getType();
+		int n = (int)Math.round(pixels);
+		if (type==Roi.RECTANGLE || type==Roi.OVAL)
+			return enlargeRectOrOval(roi, n);
+		if (n<0)
+			return shrink255(roi, -n);
+		Rectangle bounds = roi.getBounds();
+		int width = bounds.width;
+		int height = bounds.height;
+		width += 2*n + 2;
+		height += 2*n + 2;
+		ImageProcessor ip = new ByteProcessor(width, height);
+		ip.invert();
+		roi.setLocation(n+1, n+1);
+		ip.setColor(0);
+		ip.fill(roi);
+		ip.setThreshold(0, 0, ImageProcessor.NO_LUT_UPDATE);
+		Roi roi2 = (new ThresholdToSelection()).convert(ip);
+		Rectangle bounds2 = roi2.getBounds();
+		int xoffset = bounds2.x - (n+1);
+		int yoffset = bounds2.y - (n+1);
+		roi.setLocation(bounds.x, bounds.y);
+		boolean bb = Prefs.blackBackground;
+		Prefs.blackBackground = true;
+		new EDM().toEDM(ip);
+		Prefs.blackBackground = bb;
+		ip.setThreshold(0, n, ImageProcessor.NO_LUT_UPDATE);
+		roi2 = (new ThresholdToSelection()).convert(ip);
+		if (roi2==null)
+			return roi;
+		roi2.copyAttributes(roi);
+		roi2.setLocation(bounds.x-n+xoffset, bounds.y-n+yoffset);
+		if (roi.getStroke()!=null)
+			roi2.setStroke(roi.getStroke());
+		return roi2;
+	}
+
+	private static Roi shrink255(Roi roi, int n) {
+		Rectangle bounds = roi.getBounds();
+		int width = bounds.width + 2;
+		int height = bounds.height + 2;
+		ImageProcessor ip = new ByteProcessor(width, height);
+		roi.setLocation(1, 1);
+		ip.setColor(255);
+		ip.fill(roi);
+		roi.setLocation(bounds.x, bounds.y);
+		boolean bb = Prefs.blackBackground;
+		Prefs.blackBackground = true;
+		new EDM().toEDM(ip);
+		Prefs.blackBackground = bb;
+		ip.setThreshold(n+1, 255, ImageProcessor.NO_LUT_UPDATE);
+		Roi roi2 = (new ThresholdToSelection()).convert(ip);
+		if (roi2==null)
+			return roi;
+		Rectangle bounds2 = roi2.getBounds();
+		if (bounds2.width<=0 && bounds2.height<=0)
+			return roi;
+		roi2.copyAttributes(roi);
+		roi2.setLocation(bounds.x+bounds2.x-1, bounds.y+bounds2.y-1);
+		return roi2;
+	}
+
+}
diff --git a/src/ij/plugin/RoiInterpolator.java b/src/ij/plugin/RoiInterpolator.java
new file mode 100644
index 0000000..b5dacb2
--- /dev/null
+++ b/src/ij/plugin/RoiInterpolator.java
@@ -0,0 +1,105 @@
+package ij.plugin;
+import ij.IJ;
+import ij.ImagePlus;
+import ij.ImageStack;
+import ij.process.*;
+import ij.gui.Roi;
+import ij.plugin.filter.ThresholdToSelection;
+import ij.plugin.frame.RoiManager;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+
+/** This class interpolates between ROIs in the ROI Manager.
+ * @author Michael Doube
+ * @author Johannes Schindelin
+*/
+public class RoiInterpolator implements PlugIn {
+	int[][] idt;
+	int w, h;
+
+	public void run(String arg) {
+		RoiManager roiman = RoiManager.getInstance();
+		if (roiman==null || roiman.getCount()<2){
+			IJ.error("RoiInterpolator", "Please populate the ROI Manager with at least two ROIs");
+			return;
+		}
+		Roi[] rois = roiman.getRoisAsArray();
+		int xmax = 0;
+		int xmin = Integer.MAX_VALUE;
+		int ymax = 0;
+		int ymin = Integer.MAX_VALUE;
+		int zmax = 1;
+		int zmin = Integer.MAX_VALUE;
+		ArrayList<Integer> templateSlices = new ArrayList<Integer>();
+		for (Roi roi : rois){
+			int slice = roiman.getSliceNumber(roi.getName());
+			if (!templateSlices.contains(new Integer(slice)))
+				templateSlices.add(new Integer(slice));
+			if (slice==0) //ignore non-slice associated ROIs
+				continue;
+			zmin = Math.min(slice, zmin);
+			zmax = Math.max(slice, zmax);
+			Rectangle bounds = roi.getBounds();
+			xmin = Math.min(xmin, bounds.x);
+			ymin = Math.min(ymin, bounds.y);
+			xmax = Math.max(xmax, bounds.x + bounds.width);
+			ymax = Math.max(ymax, bounds.y + bounds.height);
+		}
+		if (templateSlices.size()<2) {
+			IJ.error("RoiInterpolator", "ROIs are all on the same slice, nothing to interpolate");
+			return;
+		}
+		//create the binary stack
+		final int stackW = xmax - xmin + 1;
+		final int stackH = ymax - ymin + 1;
+		final int nSlices = zmax - zmin + 1;
+		ImageStack stack = new ImageStack(stackW, stackH);
+		for (int s=0; s<nSlices; s++){
+			ByteProcessor bp = new ByteProcessor(stackW, stackH);
+			bp.setColor(255);
+			for (Roi roi : rois){
+				int slice = roiman.getSliceNumber(roi.getName());
+				if (slice==zmin+s){
+					Rectangle bounds = roi.getBounds();
+					roi.setLocation(bounds.x - xmin, bounds.y - ymin);
+					bp.setRoi(roi);
+					if (roi.getType() == Roi.RECTANGLE)
+						bp.fill();
+					else 
+						bp.fill(roi);
+				}
+			}
+			stack.addSlice(""+s, bp);
+		}
+		//do the binary interpolation
+		BinaryInterpolator bi = new BinaryInterpolator();
+		bi.run(stack);
+		ImagePlus binary = new ImagePlus("interpolated", stack);
+
+		//get the ROIs
+		ThresholdToSelection ts = new ThresholdToSelection();
+		ts.setup("", binary);
+		for (int s=0; s<nSlices; s++) {
+			if (templateSlices.contains(new Integer(s+zmin)))
+				continue;
+			ImageProcessor bp = stack.getProcessor(s+1);
+			int threshold = 255;
+			bp.setThreshold(threshold, threshold, ImageProcessor.NO_LUT_UPDATE);
+			Roi roi = ts.convert(bp);
+			if (roi==null) {
+				IJ.error("RoiInterpolator", "Unable to interpolate slice "+(s+1)+". More\nintermediate ROIs needed.");
+				return;
+			}
+			roi.setPosition(s+zmin);
+			Rectangle bounds = roi.getBounds();
+			roi.setLocation(bounds.x+xmin, bounds.y+ymin);
+			roiman.addRoi(roi);
+		}
+		for (Roi roi : rois){
+			Rectangle bounds = roi.getBounds();
+			roi.setLocation(bounds.x+xmin, bounds.y+ymin);
+		}
+		roiman.runCommand("sort");
+		IJ.showStatus("ROIs interpolated");
+	}
+}
diff --git a/src/ij/plugin/RoiReader.java b/src/ij/plugin/RoiReader.java
new file mode 100644
index 0000000..7c00596
--- /dev/null
+++ b/src/ij/plugin/RoiReader.java
@@ -0,0 +1,47 @@
+package ij.plugin;
+import ij.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.process.*;
+import java.io.*;
+import java.awt.*;
+
+/** Opens ImageJ, NIH Image and Scion Image for windows ROI outlines. 
+	RoiDecoder.java has a description of the file format.
+	@see ij.io.RoiDecoder
+	@see ij.plugin.filter.RoiWriter
+*/
+public class RoiReader implements PlugIn {
+	final int polygon=0, rect=1, oval=2, line=3,freeLine=4, segLine=5, noRoi=6,freehand=7, traced=8;
+
+	public void run(String arg) {
+		OpenDialog od = new OpenDialog("Open ROI...", arg);
+		String dir = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+			return;
+		try {
+			openRoi(dir, name);
+		} catch (IOException e) {
+			String msg = e.getMessage();
+			if (msg==null || msg.equals(""))
+				msg = ""+e;
+			IJ.error("ROI Reader", msg);
+		}
+	}
+
+	public void openRoi(String dir, String name) throws IOException {
+		String path = dir+name;
+		RoiDecoder rd = new RoiDecoder(path);
+		Roi roi = rd.getRoi();
+		Rectangle r = roi.getBounds();
+		ImagePlus img = WindowManager.getCurrentImage();
+		if (img==null || img.getWidth()<(r.x+r.width) || img.getHeight()<(r.y+r.height)) {
+			ImageProcessor ip =  new ByteProcessor(r.x+r.width+10, r.y+r.height+10);
+			img = new ImagePlus(name, ip);
+			img.show();
+		}
+		img.setRoi(roi);
+	}
+
+}
diff --git a/src/ij/plugin/RoiRotator.java b/src/ij/plugin/RoiRotator.java
new file mode 100644
index 0000000..c92dbac
--- /dev/null
+++ b/src/ij/plugin/RoiRotator.java
@@ -0,0 +1,128 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import java.awt.geom.*;
+
+/** This plugin implements the Edit/Selection/Rotate command. */
+public class RoiRotator implements PlugIn {
+	private static double defaultAngle = 15;
+	private static boolean rotateAroundImageCenter;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			IJ.error("Rotate", "This command requires a selection");
+			return;
+		}
+		double angle = showDialog(defaultAngle);
+		if (Double.isNaN(angle))
+			return;
+		if (!IJ.macroRunning())
+			defaultAngle = angle;
+		FloatPolygon center = roi.getRotationCenter();
+		double xcenter = center.xpoints[0];
+		double ycenter = center.ypoints[0];
+		if (rotateAroundImageCenter) {
+			xcenter = imp.getWidth()/2.0;
+			ycenter = imp.getHeight()/2.0;
+		}
+		Roi roi2 = rotate(roi, angle, xcenter, ycenter);
+		if (roi2==null && (roi instanceof ImageRoi))
+			return;
+		if (!rotateAroundImageCenter)
+			roi2.setRotationCenter(xcenter,ycenter);
+		Undo.setup(Undo.ROI, imp);
+		roi = (Roi)roi.clone();
+		imp.setRoi(roi2);
+		Roi.setPreviousRoi(roi);
+	}
+	
+	public double showDialog(double angle) {
+		GenericDialog gd = new GenericDialog("Rotate Selection");
+		int decimalPlaces = 0;
+		if ((int)angle!=angle)
+			decimalPlaces = 2;
+		if (Macro.getOptions()!=null)
+			rotateAroundImageCenter = false;
+		gd.addNumericField("Angle:", angle, decimalPlaces, 3, "degrees");
+		gd.addCheckbox("Rotate around image center", rotateAroundImageCenter);
+		gd.setInsets(5, 0, 0);
+		gd.addMessage("Enter negative angle to \nrotate counter-clockwise", null, Color.darkGray);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return Double.NaN;
+		rotateAroundImageCenter = gd.getNextBoolean();
+		return gd.getNextNumber();
+	}
+	
+	public static Roi rotate(Roi roi, double angle) {
+		if (roi instanceof ImageRoi) {
+			((ImageRoi)roi).rotate(angle);
+			return roi;
+		}
+		FloatPolygon center = roi.getRotationCenter();
+		double xcenter = center.xpoints[0];
+		double ycenter = center.ypoints[0];
+		Roi roi2 = rotate(roi, angle, xcenter, ycenter);
+		roi2.setRotationCenter(xcenter,ycenter);
+		return roi2;
+	}
+
+	public static Roi rotate(Roi roi, double angle, double xcenter, double ycenter) {
+		double theta = -angle*Math.PI/180.0;
+		if (roi instanceof ShapeRoi)
+			return rotateShape((ShapeRoi)roi, -theta, xcenter, ycenter);
+		FloatPolygon poly = roi.getFloatPolygon();
+		int type = roi.getType();
+		if (type==Roi.LINE) {
+			Line line = (Line)roi;
+			double x1=line.x1d;
+			double y1=line.y1d;
+			double x2=line.x2d;
+			double y2=line.y2d;
+			poly = new FloatPolygon();
+			poly.addPoint(x1, y1);
+			poly.addPoint(x2, y2);
+		}
+		for (int i=0; i<poly.npoints; i++) {
+			double dx = poly.xpoints[i]-xcenter;
+			double dy = ycenter-poly.ypoints[i];
+			double radius = Math.sqrt(dx*dx+dy*dy);
+			double a = Math.atan2(dy, dx);
+			poly.xpoints[i] = (float)(xcenter + radius*Math.cos(a+theta));
+			poly.ypoints[i] = (float)(ycenter - radius*Math.sin(a+theta));
+		}
+		Roi roi2 = null;
+		if (type==Roi.LINE)
+			roi2 = new Line(poly.xpoints[0], poly.ypoints[0], poly.xpoints[1], poly.ypoints[1]);
+		else if (type==Roi.POINT)
+			roi2 = new PointRoi(poly.xpoints, poly.ypoints,poly.npoints);
+		else {
+			if (type==Roi.RECTANGLE)
+				type = Roi.POLYGON;
+			if (type==Roi.RECTANGLE && poly.npoints>4) // rounded rectangle
+				type = Roi.FREEROI;
+			if (type==Roi.OVAL||type==Roi.TRACED_ROI)
+				type = Roi.FREEROI;
+			roi2 = new PolygonRoi(poly.xpoints, poly.ypoints,poly.npoints, type);
+		}
+		roi2.copyAttributes(roi);
+		return roi2;
+	}
+	
+	private static Roi rotateShape(ShapeRoi roi, double angle, double xcenter, double ycenter) {
+		Shape shape = roi.getShape();
+		AffineTransform at = new AffineTransform();
+		at.rotate(angle, xcenter, ycenter);
+		Rectangle r = roi.getBounds();
+		at.translate(r.x, r.y);
+		Shape shape2 = at.createTransformedShape(shape);
+		Roi roi2 = new ShapeRoi(shape2);
+		roi2.copyAttributes(roi);
+		return roi2;
+	}
+	
+}
diff --git a/src/ij/plugin/RoiScaler.java b/src/ij/plugin/RoiScaler.java
new file mode 100644
index 0000000..bbef31a
--- /dev/null
+++ b/src/ij/plugin/RoiScaler.java
@@ -0,0 +1,168 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.Measurements;
+import java.awt.*;
+import java.awt.geom.*;
+
+/** This plugin implements the Edit/Selection/Scale command. */
+public class RoiScaler implements PlugIn {
+	private static double defaultXScale = 1.5;
+	private static double defaultYScale = 1.5;
+	private double xscale;
+	private double yscale;
+	private boolean centered;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			IJ.error("Scale", "This command requires a selection");
+			return;
+		}
+		if (!IJ.isMacro() && !imp.okToDeleteRoi())
+			return;
+		if (!showDialog())
+			return;
+		if (!IJ.macroRunning()) {
+			defaultXScale = xscale;
+			defaultYScale = yscale;
+		}
+		Roi roi2 = scale(roi, xscale, yscale, centered);
+		if (roi2==null)
+			return;
+		Undo.setup(Undo.ROI, imp);
+		roi = (Roi)roi.clone();
+		imp.setRoi(roi2);
+		Roi.setPreviousRoi(roi);
+	}
+	
+	public boolean showDialog() {
+		GenericDialog gd = new GenericDialog("Scale Selection");
+		gd.addNumericField("X scale factor:", defaultXScale, 2, 4, "");
+		gd.addNumericField("Y scale factor:", defaultYScale, 2, 4, "");
+		gd.addCheckbox("Centered", false);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		xscale = gd.getNextNumber();
+		yscale = gd.getNextNumber();
+		centered = gd.getNextBoolean();
+		return true;
+	}
+	
+	public static Roi scale(Roi roi, double xscale, double yscale, boolean centered) {
+		if (roi instanceof ShapeRoi)
+			return scaleShape((ShapeRoi)roi, xscale, yscale, centered);
+		else if (roi instanceof TextRoi)
+			return scaleText((TextRoi)roi, xscale, yscale, centered);
+		else if (roi instanceof ImageRoi)
+			return scaleImage((ImageRoi)roi, xscale, yscale, centered);		
+		FloatPolygon poly = roi.getFloatPolygon();
+		int type = roi.getType();
+		if (type==Roi.LINE) {
+			Line line = (Line)roi;
+			double x1=line.x1d;
+			double y1=line.y1d;
+			double x2=line.x2d;
+			double y2=line.y2d;
+			poly = new FloatPolygon();
+			poly.addPoint(x1, y1);
+			poly.addPoint(x2, y2);
+		}
+		ImageStatistics stats = null;
+		if (centered) {
+			ImagePlus imp = roi.getImage();
+			if (imp==null) {
+				Rectangle r = roi.getBounds();
+				imp = IJ.createImage("Untitled", "8-bit black", r.x+r.width, r.y+r.height, 1);
+			}
+			ImageProcessor ip = imp.getProcessor();
+			ip.setRoi(roi);
+			stats = ImageStatistics.getStatistics(imp.getProcessor(), Measurements.CENTROID, null);
+			if (roi.isLine()) {
+				Rectangle r = roi.getBounds();
+				stats.xCentroid = r.x + Math.round(r.width/2.0);
+				stats.yCentroid = r.y + Math.round(r.height/2.0);
+			}
+		}
+		for (int i=0; i<poly.npoints; i++) {
+			if (centered) {
+				poly.xpoints[i] = (float)Math.round((poly.xpoints[i]-stats.xCentroid)*xscale+stats.xCentroid);
+				poly.ypoints[i] = (float)Math.round((poly.ypoints[i]-stats.yCentroid)*yscale+stats.yCentroid);
+			} else {
+				poly.xpoints[i] = (float)(poly.xpoints[i]*xscale);
+				poly.ypoints[i] = (float)(poly.ypoints[i]*yscale);
+			}
+		}
+		Roi roi2 = null;
+		if (type==Roi.LINE)
+			roi2 = new Line(poly.xpoints[0], poly.ypoints[0], poly.xpoints[1], poly.ypoints[1]);
+		else if (type==Roi.POINT)
+			roi2 = new PointRoi(poly.xpoints, poly.ypoints,poly.npoints);
+		else {
+			if (type==Roi.RECTANGLE)
+				type = Roi.POLYGON;
+			if (type==Roi.RECTANGLE && poly.npoints>4) // rounded rectangle
+				type = Roi.FREEROI;
+			if (type==Roi.OVAL||type==Roi.TRACED_ROI)
+				type = Roi.FREEROI;
+			roi2 = new PolygonRoi(poly.xpoints, poly.ypoints,poly.npoints, type);
+		}
+		roi2.copyAttributes(roi);
+		double width = roi.getStrokeWidth();
+		if (width!=0)
+			roi2.setStrokeWidth(width*xscale);
+		return roi2;
+	}
+	
+	private static Roi scaleShape(ShapeRoi roi, double xscale, double yscale, boolean centered) {
+		Rectangle r = roi.getBounds();
+		Shape shape = roi.getShape();
+		AffineTransform at = new AffineTransform();
+		at.scale(xscale, yscale);
+		if (!centered)
+			at.translate(r.x, r.y);
+		Shape shape2 = at.createTransformedShape(shape);
+		Roi roi2 = new ShapeRoi(shape2);
+		if (centered) {
+			int xbase = (int)(centered?r.x-(r.width*xscale-r.width)/2.0:r.x);
+			int ybase = (int)(centered?r.y-(r.height*yscale-r.height)/2.0:r.y);
+			roi2.setLocation(xbase, ybase);
+		}
+		roi2.copyAttributes(roi);
+		double width = roi.getStrokeWidth();
+		if (width!=0)
+			roi2.setStrokeWidth(width*xscale);
+		return roi2;
+	}
+	
+	private static Roi scaleText(TextRoi roi, double xscale, double yscale, boolean centered) {
+		Rectangle bounds = roi.getBounds();
+		int x = (int)Math.round(bounds.x*xscale);
+		int y = (int)Math.round(bounds.y*yscale);
+		Font font = roi.getCurrentFont();
+		font = font.deriveFont((float)(font.getSize()*yscale));
+		Roi roi2 = new TextRoi(x, y, roi.getText(), font);
+		roi2.copyAttributes(roi);
+		return roi2;
+	}
+	
+	private static Roi scaleImage(ImageRoi roi, double xscale, double yscale, boolean centered) {
+		roi = (ImageRoi)roi.clone();
+		ImageProcessor ip2 = roi.getProcessor();
+		//ip2.setInterpolationMethod(interpolationMethod);
+		int newWidth = (int)Math.round(ip2.getWidth()*xscale);
+		int newHeight = (int)Math.round(ip2.getHeight()*yscale);
+		ip2 = ip2.resize(newWidth, newHeight, true);
+		roi.setProcessor(ip2);
+		Rectangle bounds = roi.getBounds();
+		int x = (int)Math.round(bounds.x*xscale);
+		int y = (int)Math.round(bounds.y*yscale);
+		roi.setLocation(x,y);
+		roi.copyAttributes(roi);
+		return roi;
+	}
+
+}
diff --git a/src/ij/plugin/ScaleBar.java b/src/ij/plugin/ScaleBar.java
new file mode 100644
index 0000000..e0d59ed
--- /dev/null
+++ b/src/ij/plugin/ScaleBar.java
@@ -0,0 +1,760 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.measure.*;
+import java.awt.event.*;
+
+/** This plugin implements the Analyze/Tools/Scale Bar command.
+ * Divakar Ramachandran added options to draw a background 
+ * and use a serif font on 23 April 2006.
+ * Remi Berthoz added an option to draw vertical scale
+ * bars on 17 September 2021.
+*/
+public class ScaleBar implements PlugIn {
+
+	static final String[] locations = {"Upper Right", "Lower Right", "Lower Left", "Upper Left", "At Selection"};
+	static final int UPPER_RIGHT=0, LOWER_RIGHT=1, LOWER_LEFT=2, UPPER_LEFT=3, AT_SELECTION=4;
+	static final String[] colors = {"White","Black","Light Gray","Gray","Dark Gray","Red","Green","Blue","Yellow"};
+	static final String[] bcolors = {"None","Black","White","Dark Gray","Gray","Light Gray","Yellow","Blue","Green","Red"};
+	static final String[] checkboxLabels = {"Horizontal", "Vertical", "Bold Text", "Hide Text", "Serif Font", "Overlay"};
+	final static String SCALE_BAR = "|SB|";
+	
+	private static final ScaleBarConfiguration sConfig = new ScaleBarConfiguration();
+	private ScaleBarConfiguration config = new ScaleBarConfiguration(sConfig);
+
+	ImagePlus imp;
+	int hBarWidthInPixels;
+	int vBarHeightInPixels;
+	int roiX, roiY, roiWidth, roiHeight;
+	boolean userRoiExists;
+	boolean[] checkboxStates = new boolean[6];
+
+	Rectangle hBackground = new Rectangle();
+	Rectangle hBar = new Rectangle();
+	Rectangle hText = new Rectangle();
+	Rectangle vBackground = new Rectangle();
+	Rectangle vBar = new Rectangle();
+	Rectangle vText = new Rectangle();
+
+	/**
+	 * This method is called when the plugin is loaded. 'arg', which
+	 * may be blank, is the argument specified for this plugin in
+	 * IJ_Props.txt.
+	 */
+	public void run(String arg) {
+		imp = WindowManager.getCurrentImage();
+		if (imp == null) {
+			IJ.noImage();
+			return;
+		}
+		// Snapshot before anything, so we can revert if the user cancels the action.
+		imp.getProcessor().snapshot();
+
+		userRoiExists = parseCurrentROI();
+		boolean userOKed = askUserConfiguration(userRoiExists);
+
+		if (!userOKed) {
+			removeScalebar();
+			return;
+		}
+
+		if (!IJ.isMacro())
+			persistConfiguration();
+		updateScalebar(!config.labelAll);
+	 }
+
+	/**
+	 * Remove the scalebar drawn by this plugin.
+	 * 
+	 * If the scalebar was drawn without the overlay by another
+	 * instance of the plugin (it is drawn into the image), then
+	 * we cannot remove it.
+	 * 
+	 * If the scalebar was drawn using the overlay by another
+	 * instance of the plugin, then we can remove it.
+	 * 
+	 * With or without the overlay, we can remove a scalebar
+	 * drawn by this instance of the plugin.
+	 */
+	void removeScalebar() {
+		// Revert with Undo, in case "Use Overlay" is not ticked
+		imp.getProcessor().reset();
+		imp.updateAndDraw();
+		// Remove overlay drawn by this plugin, in case "Use Overlay" is ticked
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null) {
+			overlay.remove(SCALE_BAR);
+			imp.draw();
+		}
+	}
+
+	/**
+	 * If there is a user selected ROI, set the class variables {roiX}
+	 * and {roiY}, {roiWidth}, {roiHeight} to the corresponding
+	 * features of the ROI, and return true. Otherwise, return false.
+	 */
+    boolean parseCurrentROI() {
+        Roi roi = imp.getRoi();
+        if (roi == null) return false;
+
+        Rectangle r = roi.getBounds();
+        roiX = r.x;
+        roiY = r.y;
+		roiWidth = r.width;
+		roiHeight = r.height;
+        return true;
+    }
+
+	/**
+	 * There is no hard codded value for the width of the scalebar,
+	 * when the plugin is called for the first time in an ImageJ
+	 * instance, a defautl value for the width will be computed by
+	 * this method.
+	 */
+	void computeDefaultBarWidth(boolean currentROIExists) {
+		Calibration cal = imp.getCalibration();
+		ImageWindow win = imp.getWindow();
+		double mag = (win!=null)?win.getCanvas().getMagnification():1.0;
+		if (mag>1.0)
+			mag = 1.0;
+
+		double pixelWidth = cal.pixelWidth;
+		if (pixelWidth==0.0)
+			pixelWidth = 1.0;
+		double pixelHeight = cal.pixelHeight;
+		if (pixelHeight==0.0)
+			pixelHeight = 1.0;
+		double imageWidth = imp.getWidth()*pixelWidth;
+		double imageHeight = imp.getHeight()*pixelHeight;
+
+		if (currentROIExists && roiX>=0 && roiWidth>10) {
+			// If the user has a ROI, set the bar width according to ROI width.
+			config.hBarWidth = roiWidth*pixelWidth;
+		}
+		else if (config.hBarWidth<=0.0 || config.hBarWidth>0.67*imageWidth) {
+			// If the bar is of negative width or too wide for the image,
+			// set the bar width to 80 pixels.
+			config.hBarWidth = (80.0*pixelWidth)/mag;
+			if (config.hBarWidth>0.67*imageWidth)
+				// If 80 pixels is too much, do 2/3 of the image.
+				config.hBarWidth = 0.67*imageWidth;
+			if (config.hBarWidth>5.0)
+				// If the resulting size is larger than 5 units, round the value.
+				config.hBarWidth = (int) config.hBarWidth;
+		}
+
+		if (currentROIExists && roiY>=0 && roiHeight>10) {
+			config.vBarHeight = roiHeight*pixelHeight;
+		}
+		else if (config.vBarHeight<=0.0 || config.vBarHeight>0.67*imageHeight) {
+			config.vBarHeight = (80.0*pixelHeight)/mag;
+			if (config.vBarHeight>0.67*imageHeight)
+				// If 80 pixels is too much, do 2/3 of the image.
+				config.vBarHeight = 0.67*imageHeight;
+			if (config.vBarHeight>5.0)
+				// If the resulting size is larger than 5 units, round the value.
+				config.vBarHeight = (int) config.vBarHeight;
+		}
+	} 
+
+	/**
+	 * Genreate & draw the configuration dialog.
+	 * 
+	 * Return the value of dialog.wasOKed() when the user clicks OK
+	 * or Cancel.
+	 */
+	boolean askUserConfiguration(boolean currentROIExists) {
+		// Update the user configuration if there is an ROI, or if
+		// the defined bar width is negative (it is if it has never
+		// been set in this ImageJ instance).
+		if (currentROIExists) {
+			config.location = locations[AT_SELECTION];
+		}
+		if (IJ.isMacro())
+			config.updateFrom(new ScaleBarConfiguration());
+		if (config.hBarWidth <= 0 || config.vBarHeight <= 0 || currentROIExists) {
+			computeDefaultBarWidth(currentROIExists);
+		}
+
+		// Draw a first preview scalebar, with the default or presisted
+		// configuration.
+		updateScalebar(true);
+		
+		// Create & show the dialog, then return.
+		boolean multipleSlices = imp.getStackSize() > 1;
+		GenericDialog dialog = new BarDialog(getHUnit(), getVUnit(), config.hDigits, config.vDigits, multipleSlices);
+		DialogListener dialogListener = new BarDialogListener(multipleSlices);
+		dialog.addDialogListener(dialogListener);
+		dialog.showDialog();
+		return dialog.wasOKed();
+	}
+
+	/**
+	 * Store the active configuration into the static variable that
+	 * is persisted across calls of the plugin.
+	 * 
+	 * The "active" configuration is normally the one reflected by
+	 * the dialog.
+	 */
+	void persistConfiguration() {
+		sConfig.updateFrom(config);
+	}
+	
+	/**
+	 * Return the X unit strings defined in the image calibration.
+	 */
+	String getHUnit() {
+		String hUnits = imp.getCalibration().getXUnits();
+		if (hUnits.equals("microns"))
+			hUnits = IJ.micronSymbol+"m";
+		return hUnits;
+	}
+
+	/**
+	 * Return the Y unit strings defined in the image calibration.
+	 */
+	String getVUnit() {
+		String vUnits = imp.getCalibration().getYUnits();
+		if (vUnits.equals("microns"))
+			vUnits = IJ.micronSymbol+"m";
+		return vUnits;
+	}
+
+	/**
+	 * Create & draw the scalebar using an Overlay.
+	 */
+	Overlay createScaleBarOverlay() throws MissingRoiException {
+		Overlay overlay = new Overlay();
+
+		Color color = getColor();
+		Color bcolor = getBColor();
+		
+		int fontType = config.boldText?Font.BOLD:Font.PLAIN;
+		String face = config.serifFont?"Serif":"SanSerif";
+		Font font = new Font(face, fontType, config.fontSize);
+		ImageProcessor ip = imp.getProcessor();
+		ip.setFont(font);
+
+		setElementsPositions(ip);
+
+		if (bcolor != null) {
+			if (config.showHorizontal) {
+				Roi hBackgroundRoi = new Roi(hBackground.x, hBackground.y, hBackground.width, hBackground.height);
+				hBackgroundRoi.setFillColor(bcolor);
+				overlay.add(hBackgroundRoi, SCALE_BAR);
+			}
+			if (config.showVertical) {
+				Roi vBackgroundRoi = new Roi(vBackground.x, vBackground.y, vBackground.width, vBackground.height);
+				vBackgroundRoi.setFillColor(bcolor);
+				overlay.add(vBackgroundRoi, SCALE_BAR);
+			}
+		}
+
+		if (config.showHorizontal) {
+			Roi hBarRoi = new Roi(hBar.x, hBar.y, hBar.width, hBar.height);
+			hBarRoi.setFillColor(color);
+			overlay.add(hBarRoi, SCALE_BAR);
+		}
+		if (config.showVertical) {
+			Roi vBarRoi = new Roi(vBar.x, vBar.y, vBar.width, vBar.height);
+			vBarRoi.setFillColor(color);
+			overlay.add(vBarRoi, SCALE_BAR);
+		}
+
+		if (!config.hideText) {
+			if (config.showHorizontal) {
+				TextRoi hTextRoi = new TextRoi(hText.x, hText.y, getHLabel(), font);
+				hTextRoi.setStrokeColor(color);
+				overlay.add(hTextRoi, SCALE_BAR);
+			}
+			if (config.showVertical) {
+				TextRoi vTextRoi = new TextRoi(vText.x, vText.y + vText.height, getVLabel(), font);
+				vTextRoi.setStrokeColor(color);
+				vTextRoi.setAngle(90.0);
+				overlay.add(vTextRoi, SCALE_BAR);
+			}
+		}
+
+		return overlay;
+	}
+
+	/**
+	 * Returns the text to draw near the scalebar (<width> <unit>).
+	 */
+	String getHLabel() {
+		return IJ.d2s(config.hBarWidth, config.hDigits) + " " + getHUnit();
+	}
+
+	/**
+	 * Returns the text to draw near the scalebar (<height> <unit>).
+	 */
+	String getVLabel() {
+		return IJ.d2s(config.vBarHeight, config.vDigits) + " " + getVUnit();
+	}
+
+	/**
+	 * Returns the width of the box that contains the horizontal scalebar and
+	 * its label.
+	 */
+	int getHBoxWidthInPixels() {
+		updateFont();
+		ImageProcessor ip = imp.getProcessor();
+		int hLabelWidth = config.hideText ? 0 : ip.getStringWidth(getHLabel());
+		int hBoxWidth = Math.max(hBarWidthInPixels, hLabelWidth);
+		return (config.showHorizontal ? hBoxWidth : 0);
+	}
+
+	/**
+	 * Returns the height of the box that contains the horizontal scalebar and
+	 * its label.
+	 */
+	int getHBoxHeightInPixels() {
+		int hLabelHeight = config.hideText ? 0 : config.fontSize;
+		int hBoxHeight = config.barThicknessInPixels + (int) (hLabelHeight * 1.25);
+		return (config.showHorizontal ? hBoxHeight : 0);
+	}
+
+	/**
+	 * Returns the height of the box that contains the vertical scalebar and
+	 * its label.
+	 */
+	int getVBoxHeightInPixels() {
+		updateFont();
+		ImageProcessor ip = imp.getProcessor();
+		int vLabelHeight = config.hideText ? 0 : ip.getStringWidth(getVLabel());
+		int vBoxHeight = Math.max(vBarHeightInPixels, vLabelHeight);
+		return (config.showVertical ? vBoxHeight : 0);
+	}
+
+	/**
+	 * Returns the width of the box that contains the vertical scalebar and
+	 * its label.
+	 */
+	int getVBoxWidthInPixels() {
+		int vLabelWidth = config.hideText ? 0 : config.fontSize;
+		int vBoxWidth = config.barThicknessInPixels + (int) (vLabelWidth * 1.25);
+		return (config.showVertical ? vBoxWidth : 0);
+	}
+
+	/**
+	 * Returns the size of margins that should be displayed between the scalebar
+	 * elements and the image edge.
+	 */
+	int getOuterMarginSizeInPixels() {
+		int imageWidth = imp.getWidth();
+		int imageHeight = imp.getHeight();
+		return (imageWidth + imageHeight) / 100;
+	}
+
+	/**
+	 * Retruns the size of margins that should be displayed between the scalebar
+	 * elements and the edge of the element's backround.
+	 */
+	int getInnerMarginSizeInPixels() {
+		int maxWidth = Math.max(getHBoxWidthInPixels(), getVBoxHeightInPixels());
+		int margin = Math.max(maxWidth/20, 2);
+		return config.bcolor.equals("None") ? 0 : margin;
+	}
+
+	void updateFont() {
+		int fontType = config.boldText?Font.BOLD:Font.PLAIN;
+		String font = config.serifFont?"Serif":"SanSerif";
+		ImageProcessor ip = imp.getProcessor();
+		ip.setFont(new Font(font, fontType, config.fontSize));
+		ip.setAntialiasedText(true);
+	}
+
+	/**
+	 * Sets the positions x y of hBackground and vBackground based on
+	 * the current configuration.
+	 */
+	void setBackgroundBoxesPositions(ImageProcessor ip) throws MissingRoiException {
+		Calibration cal = imp.getCalibration();
+		hBarWidthInPixels = (int)(config.hBarWidth/cal.pixelWidth);
+		vBarHeightInPixels = (int)(config.vBarHeight/cal.pixelHeight);
+
+		boolean hTextTop = config.showVertical && (config.location.equals(locations[UPPER_LEFT]) || config.location.equals(locations[UPPER_RIGHT]));
+		
+		int imageWidth = imp.getWidth();
+		int imageHeight = imp.getHeight();
+		int hBoxWidth = getHBoxWidthInPixels();
+		int hBoxHeight = getHBoxHeightInPixels();
+		int vBoxWidth = getVBoxWidthInPixels();
+		int vBoxHeight = getVBoxHeightInPixels();
+		int outerMargin = getOuterMarginSizeInPixels();
+		int innerMargin = getInnerMarginSizeInPixels();
+		
+		hBackground.width = innerMargin + hBoxWidth + innerMargin;
+		hBackground.height = innerMargin + hBoxHeight + innerMargin;
+		vBackground.width = innerMargin + vBoxWidth + innerMargin;
+		vBackground.height = innerMargin + vBoxHeight + innerMargin;
+
+		if (config.location.equals(locations[UPPER_RIGHT])) {
+			hBackground.x = imageWidth - outerMargin - innerMargin - vBoxWidth + (config.showVertical ? config.barThicknessInPixels : 0) - hBoxWidth - innerMargin;
+			hBackground.y = outerMargin;
+			vBackground.x = imageWidth - outerMargin - innerMargin - vBoxWidth - innerMargin;
+			vBackground.y = outerMargin + (hTextTop ? hBoxHeight - config.barThicknessInPixels : 0);
+			hBackground.width += (config.showVertical ? vBoxWidth - config.barThicknessInPixels : 0);
+
+		} else if (config.location.equals(locations[LOWER_RIGHT])) {
+			hBackground.x = imageWidth - outerMargin - innerMargin - vBoxWidth - hBoxWidth + (config.showVertical ? config.barThicknessInPixels : 0) - innerMargin;
+			hBackground.y = imageHeight - outerMargin - innerMargin - hBoxHeight - innerMargin;
+			vBackground.x = imageWidth - outerMargin - innerMargin - vBoxWidth - innerMargin;
+			vBackground.y = imageHeight - outerMargin - innerMargin - hBoxHeight + (config.showHorizontal ? config.barThicknessInPixels : 0) - vBoxHeight - innerMargin;
+			vBackground.height += (config.showHorizontal ? hBoxHeight - config.barThicknessInPixels : 0);
+
+		} else if (config.location.equals(locations[UPPER_LEFT])) {
+			hBackground.x = outerMargin + (config.showVertical ? vBackground.width - 2*innerMargin - config.barThicknessInPixels : 0);
+			hBackground.y = outerMargin;
+			vBackground.x = outerMargin;
+			vBackground.y = outerMargin + (hTextTop ? hBoxHeight - config.barThicknessInPixels : 0);
+			hBackground.width += (config.showVertical ? vBoxWidth - config.barThicknessInPixels : 0);
+			hBackground.x -= (config.showVertical ? vBoxWidth - config.barThicknessInPixels : 0);
+
+		} else if (config.location.equals(locations[LOWER_LEFT])) {
+			hBackground.x = outerMargin + (config.showVertical ? vBackground.width - 2*innerMargin - config.barThicknessInPixels : 0);
+			hBackground.y = imageHeight - outerMargin - innerMargin - hBoxHeight - innerMargin;
+			vBackground.x = outerMargin;
+			vBackground.y = imageHeight - outerMargin - innerMargin - hBoxHeight + (config.showHorizontal ? config.barThicknessInPixels : 0) - vBoxHeight - innerMargin;
+			vBackground.height += (config.showHorizontal ? hBoxHeight - config.barThicknessInPixels : 0);
+
+		} else {
+			if (!userRoiExists)
+				throw new MissingRoiException();
+
+			hBackground.x = roiX;
+			hBackground.y = roiY;
+			vBackground.x = roiX;
+			vBackground.y = roiY;
+		}
+	}
+
+	/**
+	 * Sets the rectangles x y positions for scalebar elements (hBar, hText, vBar, vText),
+	 * based on the current configuration. Also sets the width and height of the rectangles.
+	 * 
+	 * The position of each rectangle is relative to hBackground and vBackground,
+	 * so setBackgroundBoxesPositions() must run before this method computes positions.
+	 * This method calls setBackgroundBoxesPositions().
+	 */
+	void setElementsPositions(ImageProcessor ip) throws MissingRoiException {
+
+		setBackgroundBoxesPositions(ip);
+
+		int hBoxWidth = getHBoxWidthInPixels();
+		int hBoxHeight = getHBoxHeightInPixels();
+
+		int vBoxWidth = getVBoxWidthInPixels();
+		int vBoxHeight = getVBoxHeightInPixels();
+
+		int innerMargin = getInnerMarginSizeInPixels();
+
+		boolean right = config.location.equals(locations[LOWER_RIGHT]) || config.location.equals(locations[UPPER_RIGHT]);
+		boolean upper = config.location.equals(locations[UPPER_RIGHT]) || config.location.equals(locations[UPPER_LEFT]);
+		boolean hTextTop = config.showVertical && upper;
+		
+		hBar.x = hBackground.x + innerMargin + (hBoxWidth - hBarWidthInPixels)/2 + (config.showVertical && !right && upper ? vBoxWidth - config.barThicknessInPixels : 0);
+		hBar.y = hBackground.y + innerMargin + (hTextTop ? hBoxHeight - config.barThicknessInPixels : 0);
+		hBar.width = hBarWidthInPixels;
+		hBar.height = config.barThicknessInPixels;
+
+		hText.height = config.hideText ? 0 : config.fontSize;
+		hText.width = config.hideText ? 0 : ip.getStringWidth(getHLabel());
+		hText.x = hBackground.x + innerMargin + (hBoxWidth - hText.width)/2 + (config.showVertical && !right && upper ? vBoxWidth - config.barThicknessInPixels : 0);
+		hText.y = hTextTop ? (hBackground.y + innerMargin - (int)(config.fontSize*0.25)) : (hBar.y + hBar.height);
+
+		vBar.width = config.barThicknessInPixels;
+		vBar.height = vBarHeightInPixels;
+		vBar.x = vBackground.x + (right ? innerMargin : vBackground.width - config.barThicknessInPixels - innerMargin);
+		vBar.y = vBackground.y + innerMargin + (vBoxHeight - vBar.height)/2;
+
+		vText.height = config.hideText ? 0 : ip.getStringWidth(getVLabel());
+		vText.width = config.hideText ? 0 : config.fontSize;
+		vText.x = right ? (vBar.x + vBar.width) : (vBar.x - vBoxWidth + config.barThicknessInPixels - (int)(config.fontSize*0.25));
+		vText.y = vBackground.y + innerMargin + (vBoxHeight - vText.height)/2;
+	}
+
+	Color getColor() {
+		Color c = Color.black;
+		if (config.color.equals(colors[0])) c = Color.white;
+		else if (config.color.equals(colors[2])) c = Color.lightGray;
+		else if (config.color.equals(colors[3])) c = Color.gray;
+		else if (config.color.equals(colors[4])) c = Color.darkGray;
+		else if (config.color.equals(colors[5])) c = Color.red;
+		else if (config.color.equals(colors[6])) c = Color.green;
+		else if (config.color.equals(colors[7])) c = Color.blue;
+		else if (config.color.equals(colors[8])) c = Color.yellow;
+	   return c;
+	}
+
+	// Div., mimic getColor to write getBColor for bkgnd	
+	Color getBColor() {
+		if (config.bcolor==null || config.bcolor.equals(bcolors[0])) return null;
+		Color bc = Color.white;
+		if (config.bcolor.equals(bcolors[1])) bc = Color.black;
+		else if (config.bcolor.equals(bcolors[3])) bc = Color.darkGray;
+		else if (config.bcolor.equals(bcolors[4])) bc = Color.gray;
+		else if (config.bcolor.equals(bcolors[5])) bc = Color.lightGray;
+		else if (config.bcolor.equals(bcolors[6])) bc = Color.yellow;
+		else if (config.bcolor.equals(bcolors[7])) bc = Color.blue;
+		else if (config.bcolor.equals(bcolors[8])) bc = Color.green;
+		else if (config.bcolor.equals(bcolors[9])) bc = Color.red;
+		return bc;
+	}
+
+	/**
+	 * Draw the scale bar, based on the current configuration.
+	 * 
+	 * If {previewOnly} is true, only the active slice will be
+	 * labeled with a scalebar. If it is false, all slices of
+	 * the stack will be labeled.
+	 * 
+	 * This method chooses whether to use an overlay or the
+	 * drawing tool to create the scalebar.
+	 */
+	void updateScalebar(boolean previewOnly) {
+		removeScalebar();
+
+		Overlay scaleBarOverlay;
+		try {
+			scaleBarOverlay = createScaleBarOverlay();
+		} catch (MissingRoiException e) {
+			return; // Simply don't draw the scalebar.
+		}
+
+		Overlay impOverlay = imp.getOverlay();
+		if (impOverlay==null) {
+			impOverlay = new Overlay();
+		}
+
+		if (config.useOverlay) {
+			for (Roi roi : scaleBarOverlay)
+				impOverlay.add(roi);
+			imp.setOverlay(impOverlay);
+		} else {
+			if (previewOnly) {
+				ImageProcessor ip = imp.getProcessor();
+				drawOverlayOnProcessor(scaleBarOverlay, ip);
+				imp.updateAndDraw();
+			} else {
+				ImageStack stack = imp.getStack();
+				for (int i=1; i<=stack.size(); i++) {
+					ImageProcessor ip = stack.getProcessor(i);
+					drawOverlayOnProcessor(scaleBarOverlay, ip);
+					imp.updateAndDraw();
+				}
+				imp.setStack(stack);
+			}
+		}
+	}
+
+	void drawOverlayOnProcessor(Overlay overlay, ImageProcessor processor) {
+		if (processor.getBitDepth() == 8 || processor.getBitDepth() == 24) {
+			// drawOverlay() only works for 8-bits and RGB
+			processor.drawOverlay(overlay);
+			return;
+		}
+		// Generate a buffer ImageProcessor, completely black.
+		// We will draw the overlay on it, then loop over each pixel,
+		// to replace drawn pixels in the original processor.
+		ImageProcessor ip = new ByteProcessor(imp.getWidth(), imp.getHeight());
+		ip.setCalibrationTable(processor.getCalibrationTable());
+		LUT lut = ip.getLut();
+		for (Roi roi : overlay) {
+			Color fillColor = roi.getFillColor();
+			if (fillColor != null) {
+				int i = processor.getBestIndex(fillColor);
+				roi.setFillColor(new Color(lut.getRed(i), lut.getGreen(i), lut.getBlue(i)));
+				// Below, when looping on each pixel of the buffer, we detect whether it was
+				// drawn by checking if the pixel value is greater than zero. Hence, we cannot
+				// put zero-valued pixels when the Roi is black, or these pixels will not
+				// be part of the drawing.
+				if (roi.getFillColor().equals(Color.BLACK)) roi.setFillColor(new Color(1, 1, 1));
+			}
+			Color strokeColor = roi.getStrokeColor();
+			if (strokeColor != null) {
+				int i = processor.getBestIndex(strokeColor);
+				roi.setStrokeColor(new Color(lut.getRed(i), lut.getGreen(i), lut.getBlue(i)));
+				if (roi.getStrokeColor().equals(Color.BLACK)) roi.setStrokeColor(new Color(1, 1, 1));
+			}
+		}
+		ip.drawOverlay(overlay);
+		for (int y = 0; y < ip.getHeight(); y++)
+			for (int x = 0; x < ip.getWidth(); x++) {
+				int p = ip.get(x, y);
+				if (p > 0) {
+					p = (int) (p * ((processor.getMax() - processor.getMin()) / 255d) + (float)processor.getMin());
+					if (processor.getBitDepth() == 32)
+						p = Float.floatToIntBits(p);
+					processor.putPixel(x, y, p);
+				}
+			}
+	}
+
+   class BarDialog extends GenericDialog {
+
+		BarDialog(String hUnits, String vUnits, int hDigits, int vDigits, boolean multipleSlices) {
+			super("Scale Bar");
+
+			addNumericField("Width in "+hUnits+": ", config.hBarWidth, hDigits);
+			addNumericField("Height in "+vUnits+": ", config.vBarHeight, vDigits);
+			addNumericField("Thickness in pixels: ", config.barThicknessInPixels, 0);
+			addNumericField("Font size: ", config.fontSize, 0);
+			addChoice("Color: ", colors, config.color);
+			addChoice("Background: ", bcolors, config.bcolor);
+			addChoice("Location: ", locations, config.location);
+			checkboxStates[0] = config.showHorizontal; checkboxStates[1] = config.showVertical;
+			checkboxStates[2] = config.boldText; checkboxStates[3] = config.hideText;
+			checkboxStates[4] = config.serifFont; checkboxStates[5] = config.useOverlay;
+			setInsets(10, 25, 0);
+			addCheckboxGroup(3, 2, checkboxLabels, checkboxStates);
+
+			// For simplicity of the itemStateChanged() method below,
+			// is is best to keep the "Label all slices" checkbox in
+			// the last position.
+			if (multipleSlices) {
+				setInsets(0, 25, 0);
+				addCheckbox("Label all slices", config.labelAll);
+			}
+		}
+   } //BarDialog inner class
+
+	class BarDialogListener implements DialogListener {
+
+		boolean multipleSlices;
+
+		public BarDialogListener(boolean multipleSlices) {
+			super();
+			this.multipleSlices = multipleSlices;
+		}
+
+		@Override
+		public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+			config.hBarWidth = gd.getNextNumber();
+			config.vBarHeight = gd.getNextNumber();
+			config.barThicknessInPixels = (int)gd.getNextNumber();
+			config.fontSize = (int)gd.getNextNumber();
+			config.color = gd.getNextChoice();
+			config.bcolor = gd.getNextChoice();
+			config.location = gd.getNextChoice();
+			config.showHorizontal = gd.getNextBoolean();
+			config.showVertical = gd.getNextBoolean();
+			config.boldText = gd.getNextBoolean();
+			config.hideText = gd.getNextBoolean();
+			config.serifFont = gd.getNextBoolean();
+			config.useOverlay = gd.getNextBoolean();
+			if (multipleSlices)
+				config.labelAll = gd.getNextBoolean();
+			if (!config.showHorizontal && !config.showVertical && IJ.isMacro()) {
+				// Previous versions of this plugin did not handle vertical scale bars:
+				// the macro syntax was different in that "height" meant "thickness" of
+				// the horizontal scalebar.
+				// If the conditional above is true, then the macro syntax is the old
+				// one, so we swap a few config variables.
+				config.showHorizontal = true;
+				config.barThicknessInPixels = (int)config.vBarHeight;
+				config.vBarHeight = 0.0;
+			}
+
+			String widthString = ((TextField) gd.getNumericFields().elementAt(0)).getText();
+			boolean hasDecimalPoint = false;
+			config.hDigits = 0;
+			for (int i = 0; i < widthString.length(); i++) {
+				if (hasDecimalPoint)
+					config.hDigits += 1;
+				if (widthString.charAt(i) == '.')
+					hasDecimalPoint = true;
+			}
+
+			String heightString = ((TextField) gd.getNumericFields().elementAt(1)).getText();
+			hasDecimalPoint = false;
+			config.vDigits = 0;
+			for (int i = 0; i < heightString.length(); i++) {
+				if (hasDecimalPoint)
+					config.vDigits += 1;
+				if (heightString.charAt(i) == '.')
+					hasDecimalPoint = true;
+			}
+
+			updateScalebar(true);
+			return true;
+		}
+	}
+
+   class MissingRoiException extends Exception {
+		MissingRoiException() {
+			super("Scalebar location is set to AT_SELECTION but there is no selection on the image.");
+		}
+   } //MissingRoiException inner class
+
+	static class ScaleBarConfiguration {
+	
+		private static int defaultBarHeight = 4;
+
+		boolean showHorizontal;
+		boolean showVertical;
+		double hBarWidth;
+		double vBarHeight;
+		int hDigits;  // The number of digits after the decimal point that the user input in the dialog for vBarWidth.
+		int vDigits;
+		int barThicknessInPixels;
+		String location;
+		String color;
+		String bcolor;
+		boolean boldText;
+		boolean hideText;
+		boolean serifFont;
+		boolean useOverlay;
+		int fontSize;
+		boolean labelAll;
+
+		/**
+		 * Create ScaleBarConfiguration with default values.
+		 */
+		ScaleBarConfiguration() {
+			this.showHorizontal = true;
+			this.showVertical = false;
+			this.hBarWidth = -1;
+			this.vBarHeight = -1;
+			this.barThicknessInPixels = defaultBarHeight;
+			this.location = locations[LOWER_RIGHT];
+			this.color = colors[0];
+			this.bcolor = bcolors[0];
+			this.boldText = true;
+			this.hideText = false;
+			this.serifFont = false;
+			this.useOverlay = true;
+			this.fontSize = 14;
+			this.labelAll = false;
+		}
+
+		/**
+		 * Copy constructor.
+		 */
+		ScaleBarConfiguration(ScaleBarConfiguration model) {
+			this.updateFrom(model);
+		}
+		
+		void updateFrom(ScaleBarConfiguration model) {
+			this.showHorizontal = model.showHorizontal;
+			this.showVertical = model.showVertical;
+			this.hBarWidth = model.hBarWidth;
+			this.vBarHeight = model.vBarHeight;
+			this.hDigits = model.hDigits;
+			this.vDigits = model.vDigits;
+			this.barThicknessInPixels = model.barThicknessInPixels;
+			this.location = locations[LOWER_RIGHT];
+			this.color = model.color;
+			this.bcolor = model.bcolor;
+			this.boldText = model.boldText;
+			this.serifFont = model.serifFont;
+			this.hideText = model.hideText;
+			this.useOverlay = model.useOverlay;
+			this.fontSize = model.fontSize;
+			this.labelAll = model.labelAll;
+		}
+	} //ScaleBarConfiguration inner class
+
+} //ScaleBar class
diff --git a/src/ij/plugin/Scaler.java b/src/ij/plugin/Scaler.java
new file mode 100644
index 0000000..82cfe52
--- /dev/null
+++ b/src/ij/plugin/Scaler.java
@@ -0,0 +1,452 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+
+/** This plugin implements the Image/Scale command. */
+public class Scaler implements PlugIn, TextListener, FocusListener {
+	private ImagePlus imp;
+	private static String xstr = "0.5";
+	private static String ystr = "0.5";
+	private String zstr = "1.0";
+	private static int newWidth, newHeight;
+	private int newDepth;
+	private boolean doZScaling;
+	private static boolean averageWhenDownsizing = true;
+	private static boolean newWindow = true;
+	private static int staticInterpolationMethod = ImageProcessor.BILINEAR;
+	private int interpolationMethod = staticInterpolationMethod;
+	private String[] methods = ImageProcessor.getInterpolationMethods();
+	private static boolean fillWithBackground;
+	private static boolean processStack = true;
+	private double xscale, yscale, zscale;
+	private String title = "Untitled";
+	private Vector fields;
+	private double bgValue;
+	private boolean constainAspectRatio = true;
+	private TextField xField, yField, zField, widthField, heightField, depthField;
+	private Rectangle r;
+	private Object fieldWithFocus;
+	private int oldDepth;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		Roi roi = imp.getRoi();
+		ImageProcessor ip = imp.getProcessor();
+		if (roi!=null && !roi.isArea())
+			ip.resetRoi();
+		if (!showDialog(ip))
+			return;
+		doZScaling = newDepth>0 && newDepth!=oldDepth;
+		if (doZScaling) {
+			newWindow = true;
+			processStack = true;
+		}
+		if ((ip.getWidth()>1 && ip.getHeight()>1) || newWindow)
+			ip.setInterpolationMethod(interpolationMethod);
+		else
+			ip.setInterpolationMethod(ImageProcessor.NONE);
+		ip.setBackgroundValue(bgValue);
+		imp.startTiming();
+		try {
+			if (newWindow && imp.getStackSize()>1 && processStack) {
+				ImagePlus imp2 = createNewStack(imp, ip, newWidth, newHeight, newDepth);
+				if (imp2!=null) {
+					imp2.show();
+					imp2.changes = true;
+				}
+			} else
+				scale(imp);
+		}
+		catch(OutOfMemoryError o) {
+			IJ.outOfMemory("Scale");
+		}
+		IJ.showProgress(1.0);
+		record(imp, newWidth, newHeight, newDepth, interpolationMethod);			
+	}
+	
+	/** Returns a scaled copy of this image or ROI, where the
+		 'options'  string can contain 'none', 'bilinear'. 'bicubic',
+		'slice' and 'constrain'.
+	*/
+	public static ImagePlus resize(ImagePlus imp, int dstWidth, int dstHeight, int dstDepth, String options) {
+		if (options==null)
+			options = "";
+		Scaler scaler = new Scaler();
+		if (options.contains("none"))
+			scaler.interpolationMethod = ImageProcessor.NONE;
+		if (options.contains("bicubic"))
+			scaler.interpolationMethod = ImageProcessor.BICUBIC;
+		if (scaler.xscale==0) {
+			scaler.xscale = (double)dstWidth/imp.getWidth();
+			scaler.yscale = (double)dstHeight/imp.getHeight();
+			scaler.zscale = (double)dstDepth/imp.getStackSize();
+		}
+		boolean processStack = imp.getStackSize()>1 && !options.contains("slice");
+		//return new ImagePlus("Untitled", ip.resize(dstWidth, dstHeight, useAveraging));
+		Roi roi = imp.getRoi();
+		ImageProcessor ip = imp.getProcessor();
+		if (roi!=null && !roi.isArea())
+			ip.resetRoi();
+		scaler.doZScaling = dstDepth!=1;
+		if (scaler.doZScaling)
+			scaler.processStack = true;
+		return scaler.createNewStack(imp, ip, dstWidth, dstHeight, dstDepth);
+	}
+	
+	private ImagePlus createNewStack(ImagePlus imp, ImageProcessor ip, int newWidth, int newHeight, int newDepth) {
+		int nSlices = imp.getStackSize();
+		int w=imp.getWidth(), h=imp.getHeight();
+		ImagePlus imp2 = imp.createImagePlus();
+		Rectangle r = ip.getRoi();
+		boolean crop = r.width!=imp.getWidth() || r.height!=imp.getHeight();
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(newWidth, newHeight);
+		boolean virtualStack = stack1.isVirtual();
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();
+		ImageProcessor ip1, ip2;
+		int method = interpolationMethod;
+		if (w==1 || h==1)
+			method = ImageProcessor.NONE;
+		for (int i=1; i<=nSlices; i++) {
+			IJ.showStatus("Scale: " + i + "/" + nSlices);
+			ip1 = stack1.getProcessor(i);
+			String label = stack1.getSliceLabel(i);
+			if (crop) {
+				ip1.setRoi(r);
+				ip1 = ip1.crop();
+			}
+			ip1.setInterpolationMethod(method);
+			ip2 = ip1.resize(newWidth, newHeight, averageWhenDownsizing);
+			if (ip2!=null)
+				stack2.addSlice(label, ip2);
+			IJ.showProgress(i, nSlices);
+		}
+		imp2.setStack(title, stack2);
+		if (virtualStack)
+			imp2.setDisplayRange(min, max);
+		Calibration cal = imp2.getCalibration();
+		if (cal.scaled()) {
+			cal.pixelWidth *= 1.0/xscale;
+			cal.pixelHeight *= 1.0/yscale;
+		}
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null && !imp.getHideOverlay() && !doZScaling)
+			imp2.setOverlay(overlay.scale(xscale, yscale));
+		IJ.showProgress(1.0);
+		int[] dim = imp.getDimensions();
+		imp2.setDimensions(dim[2], dim[3], dim[4]);
+		if (imp.isComposite()) {
+			imp2 = new CompositeImage(imp2, ((CompositeImage)imp).getMode());
+			((CompositeImage)imp2).copyLuts(imp);
+		}
+		if (imp.isHyperStack())
+			imp2.setOpenAsHyperStack(true);
+		if (doZScaling) {
+			Resizer resizer = new Resizer();
+			resizer.setAverageWhenDownsizing(averageWhenDownsizing);
+			imp2 = resizer.zScale(imp2, newDepth, interpolationMethod);
+		}
+		return imp2;
+	}
+
+	private void scale(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		if (newWindow) {
+			Rectangle r = ip.getRoi();
+			ImagePlus imp2 = imp.createImagePlus();
+			imp2.setProcessor(title, ip.resize(newWidth, newHeight, averageWhenDownsizing));
+			Calibration cal = imp2.getCalibration();
+			if (cal.scaled()) {
+				cal.pixelWidth *= 1.0/xscale;
+				cal.pixelHeight *= 1.0/yscale;
+			}
+			Overlay overlay = imp.getOverlay();
+			if (overlay!=null && !imp.getHideOverlay())
+				imp2.setOverlay(overlay.scale(xscale, yscale));
+			imp2.show();
+			imp.trimProcessor();
+			imp2.trimProcessor();
+			imp2.changes = true;
+		} else {
+			if (processStack && imp.getStackSize()>1) {
+				Undo.reset();
+				StackProcessor sp = new StackProcessor(imp.getStack(), ip);
+				sp.scale(xscale, yscale, bgValue);
+			} else {
+				ip.snapshot();
+				Undo.setup(Undo.FILTER, imp);
+				ip.setSnapshotCopyMode(true);
+				ip.scale(xscale, yscale);
+				ip.setSnapshotCopyMode(false);
+			}
+			imp.deleteRoi();
+			imp.updateAndDraw();
+			imp.changes = true;
+		}
+	}
+	
+	public static void record(ImagePlus imp, int w2, int h2, int d2, int method) {
+		if (!Recorder.scriptMode())
+			return;
+		String options = "";
+		if (method==ImageProcessor.NONE)
+			options = "none";
+		else if (method==ImageProcessor.BICUBIC)
+			options = "bicubic";
+		else
+			options = "bilinear";
+		Recorder.recordCall("imp = imp.resize("+w2+", "+h2+(d2>0&&d2!=imp.getStackSize()?", "+d2:"")+", \""+options+"\");");
+	}
+	
+	boolean showDialog(ImageProcessor ip) {
+		String options = Macro.getOptions();
+		boolean isMacro = options!=null;
+		if (isMacro) {
+			if (options.contains(" interpolate"))
+				options = options.replaceAll(" interpolate", " interpolation=Bilinear");
+			else if (!options.contains(" interpolation="))
+				options = options+" interpolation=None";
+			if (options.contains("width=")&&options.contains(" height=")) {
+				xstr = "-";
+				ystr = "-";
+				if (options.contains(" depth="))
+					zstr = "-";
+				else
+					zstr = "1.0";
+			}
+			Macro.setOptions(options);
+			interpolationMethod = ImageProcessor.BILINEAR;
+		}
+		int bitDepth = imp.getBitDepth();
+		int stackSize = imp.getStackSize();
+		boolean isStack = stackSize>1;
+		oldDepth = stackSize;
+		if (isStack && !isMacro) {
+			xstr = "1.0";
+			ystr = "1.0";
+			zstr = "1.0";
+		}
+		r = ip.getRoi();
+		int width = newWidth;
+		if (width==0) width = r.width;
+		int height = (int)Math.round(((double)width*r.height/r.width));
+		xscale = Tools.parseDouble(xstr, 0.0);
+		yscale = Tools.parseDouble(ystr, 0.0);
+		zscale = 1.0;
+		if (xscale!=0.0 && yscale!=0.0) {
+			width = (int)Math.round(r.width*xscale);
+			height = (int)Math.round(r.height*yscale);
+		} else {
+			xstr = "-";
+			ystr = "-";
+		}
+		GenericDialog gd = new GenericDialog("Scale");
+		gd.addStringField("X Scale:", xstr);
+		gd.addStringField("Y Scale:", ystr);
+		if (isStack)
+			gd.addStringField("Z Scale:", zstr);
+		gd.setInsets(5, 0, 5);
+		gd.addStringField("Width (pixels):", ""+width);
+		gd.addStringField("Height (pixels):", ""+height);
+		if (isStack) {
+			String label = "Depth (images):";
+			if (imp.isHyperStack()) {
+				int slices = imp.getNSlices();
+				int frames = imp.getNFrames();
+				if (slices==1&&frames>1) {
+					label = "Depth (frames):";
+					oldDepth = frames;
+				} else {
+					label = "Depth (slices):";
+					oldDepth = slices;
+				}
+			}
+			gd.addStringField(label, ""+oldDepth);
+		}
+		fields = gd.getStringFields();
+		if (fields!=null) {
+			for (int i=0; i<fields.size(); i++) {
+				((TextField)fields.elementAt(i)).addTextListener(this);
+				((TextField)fields.elementAt(i)).addFocusListener(this);
+			}
+			xField = (TextField)fields.elementAt(0);
+			yField = (TextField)fields.elementAt(1);
+			if (isStack) {
+				zField = (TextField)fields.elementAt(2);
+				widthField = (TextField)fields.elementAt(3);
+				heightField = (TextField)fields.elementAt(4);
+				depthField = (TextField)fields.elementAt(5);
+			} else {
+				widthField = (TextField)fields.elementAt(2);
+				heightField = (TextField)fields.elementAt(3);
+			}
+		}
+		fieldWithFocus = xField;
+		gd.addChoice("Interpolation:", methods, methods[interpolationMethod]);
+		if (bitDepth==8 || bitDepth==24)
+			gd.addCheckbox("Fill with background color", fillWithBackground);
+		gd.addCheckbox("Average when downsizing", averageWhenDownsizing);
+		boolean hyperstack = imp.isHyperStack() || imp.isComposite();
+		if (isStack && !hyperstack)
+			gd.addCheckbox("Process entire stack", processStack);
+		gd.addCheckbox("Create new window", newWindow);
+		title = WindowManager.getUniqueName(imp.getTitle());
+		gd.setInsets(10, 0, 0);
+		gd.addStringField("Title:", title, 12);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		xstr = gd.getNextString();
+		ystr = gd.getNextString();
+		xscale = Tools.parseDouble(xstr, 0.0);
+		yscale = Tools.parseDouble(ystr, 0.0);
+		if (isStack) {
+			zstr = gd.getNextString();
+			zscale = Tools.parseDouble(zstr, 0.0);
+		}
+		String wstr = gd.getNextString();
+		newWidth = (int)Math.round(Tools.parseDouble(wstr, 0));
+		newHeight = (int)Math.round(Tools.parseDouble(gd.getNextString(), 0));
+		if (newHeight!=0 && (wstr.equals("-") || wstr.equals("0")))
+			newWidth = (int)Math.round(newHeight * (double)r.width/r.height);
+		else if (newWidth!=0 && newHeight==0)
+			newHeight= (int)Math.round(newWidth * (double)r.height/r.width);
+		else if (newHeight!=0 && newWidth==0)
+			newWidth = (int)Math.round(newHeight * (double)r.width/r.height);
+		if (newWidth==0 || newHeight==0) {
+			IJ.error("Scaler", "Width or height is 0");
+			return false;
+		}
+		if (xscale>0.0 && yscale>0.0) {
+			newWidth = (int)Math.round(r.width*xscale);
+			newHeight = (int)Math.round(r.height*yscale);
+		}
+		if (isStack) {
+			newDepth = (int)Math.round(Tools.parseDouble(gd.getNextString(), 0));
+			if (zscale>0.0) {
+				int nSlices = stackSize;
+				if (imp.isHyperStack()) {
+					int slices = imp.getNSlices();
+					int frames = imp.getNFrames();
+					if (slices==1&&frames>1)
+						nSlices = frames;
+					else
+						nSlices = slices;
+				}
+				newDepth = (int)Math.round(nSlices*zscale);
+			}
+		}
+		interpolationMethod = gd.getNextChoiceIndex();
+		if (bitDepth==8 || bitDepth==24)
+			fillWithBackground = gd.getNextBoolean();
+		averageWhenDownsizing = gd.getNextBoolean();
+		if (isStack && !hyperstack)
+			processStack = gd.getNextBoolean();
+		if (hyperstack)
+			processStack = true;
+		newWindow = gd.getNextBoolean();
+		if (xscale==0.0) {
+			xscale = (double)newWidth/r.width;
+			yscale = (double)newHeight/r.height;
+		}
+		gd.setSmartRecording(true);
+		title = gd.getNextString();
+		if (fillWithBackground) {
+			Color bgc = Toolbar.getBackgroundColor();
+			if (bitDepth==8)
+				bgValue = ip.getBestIndex(bgc);
+			else if (bitDepth==24)
+				bgValue = bgc.getRGB();
+		} else
+			bgValue = 0.0;
+		if (!isMacro)
+			staticInterpolationMethod = interpolationMethod;
+		return true;
+	}
+
+	public void textValueChanged(TextEvent e) {
+		if (xField==null || yField==null)
+			return;
+		Object source = e.getSource();
+		double newXScale = xscale;
+		double newYScale = yscale;
+		double newZScale = zscale;
+		if (source==xField && fieldWithFocus==xField) {
+			String newXText = xField.getText();
+			newXScale = Tools.parseDouble(newXText,0);
+			if (newXScale==0) return;
+			if (newXScale!=xscale) {
+				int newWidth = (int)Math.round(newXScale*r.width);
+				widthField.setText(""+newWidth);
+				if (constainAspectRatio) {
+					yField.setText(newXText);
+					int newHeight = (int)Math.round(newXScale*r.height);
+					heightField.setText(""+newHeight);
+				}
+			}
+		} else if (source==yField && fieldWithFocus==yField) {
+			String newYText = yField.getText();
+			newYScale = Tools.parseDouble(newYText,0);
+			if (newYScale==0) return;
+			if (newYScale!=yscale) {
+				int newHeight = (int)Math.round(newYScale*r.height);
+				heightField.setText(""+newHeight);
+			}
+		} else if (source==zField && fieldWithFocus==zField) {
+			String newZText = zField.getText();
+			newZScale = Tools.parseDouble(newZText,0);
+			if (newZScale==0) return;
+			if (newZScale!=zscale) {
+				int nSlices = imp.getStackSize();
+				if (imp.isHyperStack()) {
+					int slices = imp.getNSlices();
+					int frames = imp.getNFrames();
+					if (slices==1&&frames>1)
+						nSlices = frames;
+					else
+						nSlices = slices;
+				}
+				int newDepth= (int)Math.round(newZScale*nSlices);
+				depthField.setText(""+newDepth);
+			}
+		} else if (source==widthField && fieldWithFocus==widthField) {
+			int newWidth = (int)Math.round(Tools.parseDouble(widthField.getText(), 0.0));
+			if (newWidth!=0) {
+				int newHeight = (int)Math.round(newWidth*(double)r.height/r.width);
+				heightField.setText(""+newHeight);
+				xField.setText("-");
+				yField.setText("-");
+				newXScale = 0.0;
+				newYScale = 0.0;
+			}
+       } else if (source==depthField && fieldWithFocus==depthField) {
+            int newDepth = (int)Math.round(Tools.parseDouble(depthField.getText(), 0.0));
+            if (newDepth!=0) {
+                zField.setText("-");
+                newZScale = 0.0;
+            }
+        }
+		xscale = newXScale;
+		yscale = newYScale;
+		zscale = newZScale;
+	}
+
+	public void focusGained(FocusEvent e) {
+		fieldWithFocus = e.getSource();
+		if (fieldWithFocus==widthField)
+			constainAspectRatio = true;
+		else if (fieldWithFocus==yField)
+			constainAspectRatio = false;
+	}
+
+	public void focusLost(FocusEvent e) {}
+
+}
diff --git a/src/ij/plugin/ScreenGrabber.java b/src/ij/plugin/ScreenGrabber.java
new file mode 100644
index 0000000..6718079
--- /dev/null
+++ b/src/ij/plugin/ScreenGrabber.java
@@ -0,0 +1,90 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+
+/** This plugin implements the Plugins/Utilities/Capture Screen
+    and Plugins/Utilities/Capture Image commands. Note that these
+    commands may not work on Linux if windows translucency or 
+    special effects are enabled in the windows manager. */
+public class ScreenGrabber implements PlugIn {
+	private static int delay = 10;
+
+	public void run(String arg) {
+		ImagePlus imp2 = null;
+		if (arg.equals("image") || arg.equals("flatten"))
+			imp2 = captureImage();
+		else if (arg.equals("delay"))
+			imp2 = captureDelayed();
+		else
+			imp2 = captureScreen();
+		if (imp2!=null)
+			imp2.show();
+	}
+	
+	private ImagePlus captureDelayed() {
+		GenericDialog gd = new GenericDialog("Delayed Capture");
+		gd.addNumericField("Delay (seconds):", delay, 0);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return null;
+		int delay = (int)gd.getNextNumber();
+		if (delay<0) return null;
+		if (delay>60) delay=60;
+		for (int i=0; i<delay; i++) {
+			IJ.wait(1000);
+			IJ.showStatus("Delayed capture: "+(i+1)+"/"+delay);
+			if (delay>4 && i==delay-2) IJ.beep();
+		}
+		return captureScreen();
+	}
+
+    
+	/** Captures the entire screen and returns it as an ImagePlus. */
+	public ImagePlus captureScreen() {
+		ImagePlus imp = null;
+		try {
+			Robot robot = new Robot();
+			Rectangle r = GUI.getScreenBounds(IJ.getInstance()); // screen showing "ImageJ" window
+			Image img = robot.createScreenCapture(r);
+			if (img!=null) imp = new ImagePlus("Screenshot", img);
+		} catch(Exception e) {}
+		return imp;
+	}
+
+	/** Captures the active image window and returns it as an ImagePlus. */
+	public ImagePlus captureImage() {
+		ImagePlus imp = IJ.getImage();
+		if (imp==null) {
+			IJ.noImage();
+			return null;
+		}
+		ImageWindow win = imp.getWindow();
+		if (win==null) return null;
+		win.toFront();
+		IJ.wait(500);
+		Point loc = win.getLocation();
+		ImageCanvas ic = win.getCanvas();
+		Rectangle bounds = ic.getBounds();
+		loc.x += bounds.x;
+		loc.y += bounds.y;
+		Rectangle r = new Rectangle(loc.x, loc.y, bounds.width, bounds.height);
+		ImagePlus imp2 = null;
+		Image img = null;
+		boolean wasHidden = ic.hideZoomIndicator(true);
+		IJ.wait(250);
+		try {
+			Robot robot = new Robot();
+			img = robot.createScreenCapture(r);
+		} catch(Exception e) { }
+		ic.hideZoomIndicator(wasHidden);
+		if (img!=null) {
+			String title = WindowManager.getUniqueName(imp.getTitle());
+			imp2 = new ImagePlus(title, img);
+		}
+		return imp2;
+	}
+
+}
+
diff --git a/src/ij/plugin/Selection.java b/src/ij/plugin/Selection.java
new file mode 100644
index 0000000..cfeb31f
--- /dev/null
+++ b/src/ij/plugin/Selection.java
@@ -0,0 +1,970 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.frame.*;
+import ij.macro.Interpreter;
+import ij.plugin.filter.*;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.event.KeyEvent;
+import java.util.Vector;
+import java.awt.geom.*;
+
+
+/** This plugin implements the commands in the Edit/Selection submenu. */
+public class Selection implements PlugIn, Measurements {
+	private ImagePlus imp;
+	private float[] kernel = {1f, 1f, 1f, 1f, 1f};
+	private float[] kernel3 = {1f, 1f, 1f};
+	private static int bandSize = 15; // pixels
+	private static Color linec, fillc;
+	private static int lineWidth = 1;
+	private static boolean smooth;
+	private static boolean adjust;
+
+	
+
+	public void run(String arg) {
+		imp = WindowManager.getCurrentImage();
+		if (arg.equals("add")) {
+			addToRoiManager(imp);
+			return;
+		}		
+		if (imp==null) {
+			if (!(IJ.isMacro()&&arg.equals("none")))
+				IJ.noImage();
+			return;
+		}
+		if (arg.equals("all")) {
+			if (imp.okToDeleteRoi()) {
+				imp.saveRoi();
+				imp.setRoi(0,0,imp.getWidth(),imp.getHeight());
+			}
+		} else if (arg.equals("none")) {
+			if (imp.okToDeleteRoi())
+				imp.deleteRoi();
+		} else if (arg.equals("restore"))
+			imp.restoreRoi();
+		else if (arg.equals("spline"))
+			fitSpline();
+		else if (arg.equals("interpolate"))
+			interpolate();
+		else if (arg.equals("circle"))
+			fitCircle(imp);
+		else if (arg.equals("ellipse"))
+			createEllipse(imp);
+		else if (arg.equals("hull"))
+			convexHull(imp);
+		else if (arg.equals("mask"))
+			createMask(imp);		
+		else if (arg.equals("from"))
+			createSelectionFromMask(imp);		
+		else if (arg.equals("inverse"))
+			invert(imp); 
+		else if (arg.equals("toarea"))
+			lineToArea(imp); 
+		else if (arg.equals("toline"))
+			areaToLine(imp); 
+		else if (arg.equals("properties"))
+			{setProperties("Properties ", imp.getRoi()); imp.draw();}
+		else if (arg.equals("band"))
+			makeBand(imp);
+		else if (arg.equals("tobox"))
+			toBoundingBox(imp); 
+		else if (arg.equals("rotate"))
+			rotate(imp); 
+		else if (arg.equals("enlarge"))
+			enlarge(imp); 
+		else if (arg.equals("rect"))
+			fitRectangle(imp); 
+	}
+	
+	private void rotate(ImagePlus imp) {
+		if (!imp.okToDeleteRoi()) return;
+		Roi roi = imp.getRoi();
+		if (IJ.macroRunning()) {
+			String options = Macro.getOptions();
+			if (options!=null && (options.indexOf("grid=")!=-1||options.indexOf("interpolat")!=-1)) {
+				IJ.run("Rotate... ", options); // run Image>Transform>Rotate
+				return;
+			}
+		}
+		(new RoiRotator()).run("");
+	}
+	
+	private void enlarge(ImagePlus imp) {
+		if (!imp.okToDeleteRoi()) return;
+		Roi roi = imp.getRoi();
+		if (roi!=null) {
+			Undo.setup(Undo.ROI, imp);
+			roi = (Roi)roi.clone();
+			(new RoiEnlarger()).run("");
+		} else
+			noRoi("Enlarge");
+	}
+
+	/*
+	if selection is closed shape, create a circle with the same area and centroid, otherwise use<br>
+	the Pratt method to fit a circle to the points that define the line or multi-point selection.<br>
+	Reference: Pratt V., Direct least-squares fitting of algebraic surfaces", Computer Graphics, Vol. 21, pages 145-152 (1987).<br>
+	Original code: Nikolai Chernov's MATLAB script for Newton-based Pratt fit.<br>
+	(http://www.math.uab.edu/~chernov/cl/MATLABcircle.html)<br>
+	Java version: https://github.com/mdoube/BoneJ/blob/master/src/org/doube/geometry/FitCircle.java<br>
+	Authors: Nikolai Chernov, Michael Doube, Ved Sharma
+	*/
+	void fitCircle(ImagePlus imp) {
+		if (!imp.okToDeleteRoi()) return;
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			noRoi("Fit Circle");
+			return;
+		}
+		
+		if (roi.isArea()) {	  //create circle with the same area and centroid
+			Undo.setup(Undo.ROI, imp);
+			ImageProcessor ip = imp.getProcessor();
+			ip.setRoi(roi);
+			ImageStatistics stats = ImageStatistics.getStatistics(ip, Measurements.AREA+Measurements.CENTROID, null);
+			double r = Math.sqrt(stats.pixelCount/Math.PI);
+			imp.deleteRoi();
+			int d = (int)Math.round(2.0*r);
+			Roi roi2 = new OvalRoi((int)Math.round(stats.xCentroid-r), (int)Math.round(stats.yCentroid-r), d, d);
+			transferProperties(roi, roi2);
+			imp.setRoi(roi2);
+			return;
+		}
+		
+		Polygon poly = roi.getPolygon();
+		int n=poly.npoints;
+		int[] x = poly.xpoints;
+		int[] y = poly.ypoints;
+		if (n<3) {
+			IJ.error("Fit Circle", "At least 3 points are required to fit a circle.");
+			return;
+		}
+		
+		// calculate point centroid
+		double sumx = 0, sumy = 0;
+		for (int i=0; i<n; i++) {
+			sumx = sumx + poly.xpoints[i];
+			sumy = sumy + poly.ypoints[i];
+		}
+		double meanx = sumx/n;
+		double meany = sumy/n;
+		
+		// calculate moments
+		double[] X = new double[n], Y = new double[n];
+		double Mxx=0, Myy=0, Mxy=0, Mxz=0, Myz=0, Mzz=0;
+		for (int i=0; i<n; i++) {
+			X[i] = x[i] - meanx;
+			Y[i] = y[i] - meany;
+			double Zi = X[i]*X[i] + Y[i]*Y[i];
+			Mxy = Mxy + X[i]*Y[i];
+			Mxx = Mxx + X[i]*X[i];
+			Myy = Myy + Y[i]*Y[i];
+			Mxz = Mxz + X[i]*Zi;
+			Myz = Myz + Y[i]*Zi;
+			Mzz = Mzz + Zi*Zi;
+		}
+		Mxx = Mxx/n;
+		Myy = Myy/n;
+		Mxy = Mxy/n;
+		Mxz = Mxz/n;
+		Myz = Myz/n;
+		Mzz = Mzz/n;
+		
+		// calculate the coefficients of the characteristic polynomial
+		double Mz = Mxx + Myy;
+		double Cov_xy = Mxx*Myy - Mxy*Mxy;
+		double Mxz2 = Mxz*Mxz;
+		double Myz2 = Myz*Myz;
+		double A2 = 4*Cov_xy - 3*Mz*Mz - Mzz;
+		double A1 = Mzz*Mz + 4*Cov_xy*Mz - Mxz2 - Myz2 - Mz*Mz*Mz;
+		double A0 = Mxz2*Myy + Myz2*Mxx - Mzz*Cov_xy - 2*Mxz*Myz*Mxy + Mz*Mz*Cov_xy;
+		double A22 = A2 + A2;
+		double epsilon = 1e-12; 
+		double ynew = 1e+20;
+		int IterMax= 20;
+		double xnew = 0;
+		int iterations = 0;
+		
+		// Newton's method starting at x=0
+		for (int iter=1; iter<=IterMax; iter++) {
+			iterations = iter;
+			double yold = ynew;
+			ynew = A0 + xnew*(A1 + xnew*(A2 + 4.*xnew*xnew));
+			if (Math.abs(ynew)>Math.abs(yold)) {
+				if (IJ.debugMode) IJ.log("Fit Circle: wrong direction: |ynew| > |yold|");
+				xnew = 0;
+				break;
+			}
+			double Dy = A1 + xnew*(A22 + 16*xnew*xnew);
+			double xold = xnew;
+			xnew = xold - ynew/Dy;
+			if (Math.abs((xnew-xold)/xnew) < epsilon)
+				break;
+			if (iter >= IterMax) {
+				if (IJ.debugMode) IJ.log("Fit Circle: will not converge");
+				xnew = 0;
+			}
+			if (xnew<0) {
+				if (IJ.debugMode) IJ.log("Fit Circle: negative root:  x = "+xnew);
+				xnew = 0;
+			}
+		}
+		if (IJ.debugMode) IJ.log("Fit Circle: n="+n+", xnew="+IJ.d2s(xnew,2)+", iterations="+iterations);
+		
+		// calculate the circle parameters
+		double DET = xnew*xnew - xnew*Mz + Cov_xy;
+		double CenterX = (Mxz*(Myy-xnew)-Myz*Mxy)/(2*DET);
+		double CenterY = (Myz*(Mxx-xnew)-Mxz*Mxy)/(2*DET);
+		double radius = Math.sqrt(CenterX*CenterX + CenterY*CenterY + Mz + 2*xnew);
+		if (Double.isNaN(radius)) {
+			IJ.error("Fit Circle", "Points are collinear.");
+			return;
+		}
+		CenterX = CenterX + meanx;
+		CenterY = CenterY + meany;
+		Undo.setup(Undo.ROI, imp);
+		imp.deleteRoi();
+		IJ.makeOval((int)Math.round(CenterX-radius), (int)Math.round(CenterY-radius), (int)Math.round(2*radius), (int)Math.round(2*radius));
+	}
+
+	void fitSpline() {
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			{noRoi("Spline"); return;}
+		int type = roi.getType();
+		boolean segmentedSelection = type==Roi.POLYGON||type==Roi.POLYLINE;
+		if (!(segmentedSelection||type==Roi.FREEROI||type==Roi.TRACED_ROI||type==Roi.FREELINE))
+			{IJ.error("Spline Fit", "Polygon or polyline selection required"); return;}
+		if (roi instanceof EllipseRoi)
+			return;
+		PolygonRoi p = (PolygonRoi)roi;
+		Undo.setup(Undo.ROI, imp);
+		if (!segmentedSelection && p.getNCoordinates()>3) {
+			if (p.subPixelResolution())
+				p = trimFloatPolygon(p, p.getUncalibratedLength());
+			else
+				p = trimPolygon(p, p.getUncalibratedLength());
+		}
+		String options = Macro.getOptions();
+		if (options!=null && options.indexOf("straighten")!=-1)
+			p.fitSplineForStraightening();
+		else if (options!=null && options.indexOf("remove")!=-1)
+			p.removeSplineFit();
+		else
+			p.fitSpline();
+		imp.draw();
+		LineWidthAdjuster.update(); 
+	}
+	
+	void interpolate() {
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			{noRoi("Interpolate"); return;}
+		if (roi.getType()==Roi.POINT)
+			return;
+		if (IJ.isMacro()&&Macro.getOptions()==null)
+			Macro.setOptions("interval=1");
+		GenericDialog gd = new GenericDialog("Interpolate");
+		gd.addNumericField("Interval:", 1.0, 1, 4, "pixel");
+		gd.addCheckbox("Smooth", IJ.isMacro()?false:smooth);
+		gd.addCheckbox("Adjust interval to match", IJ.isMacro()?false:adjust);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		double interval = gd.getNextNumber();
+		smooth = gd.getNextBoolean();
+		Undo.setup(Undo.ROI, imp);
+		adjust = gd.getNextBoolean();
+		int sign = adjust ? -1 : 1;
+		FloatPolygon poly = roi.getInterpolatedPolygon(sign*interval, smooth);
+		int t = roi.getType();
+		int type = roi.isLine()?Roi.FREELINE:Roi.FREEROI;
+		if (t==Roi.POLYGON && interval>1.0)
+			type = Roi.POLYGON;
+		if ((t==Roi.RECTANGLE||t==Roi.OVAL||t==Roi.FREEROI) && interval>=8.0)
+			type = Roi.POLYGON;
+		if ((t==Roi.LINE||t==Roi.FREELINE) && interval>=8.0)
+			type = Roi.POLYLINE;
+		if (t==Roi.POLYLINE && interval>=8.0)
+			type = Roi.POLYLINE;
+		ImageCanvas ic = imp.getCanvas();
+		if (poly.npoints<=150 && ic!=null && ic.getMagnification()>=12.0)
+			type = roi.isLine()?Roi.POLYLINE:Roi.POLYGON;
+		Roi p = new PolygonRoi(poly,type);
+		if (roi.getStroke()!=null)
+			p.setStrokeWidth(roi.getStrokeWidth());
+		p.setStrokeColor(roi.getStrokeColor());
+		p.setName(roi.getName());
+		transferProperties(roi, p);
+		imp.setRoi(p);
+	}
+	
+	private static void transferProperties(Roi roi1, Roi roi2) {
+		if (roi1==null || roi2==null)
+			return;
+		roi2.setStrokeColor(roi1.getStrokeColor());
+		if (roi1.getStroke()!=null)
+			roi2.setStroke(roi1.getStroke());
+		roi2.setDrawOffset(roi1.getDrawOffset());
+	}
+	
+	PolygonRoi trimPolygon(PolygonRoi roi, double length) {
+		int[] x = roi.getXCoordinates();
+		int[] y = roi.getYCoordinates();
+		int n = roi.getNCoordinates();
+		x = smooth(x, n);
+		y = smooth(y, n);
+		float[] curvature = getCurvature(x, y, n);
+		Rectangle r = roi.getBounds();
+		double threshold = rodbard(length);
+		//IJ.log("trim: "+length+" "+threshold);
+		double distance = Math.sqrt((x[1]-x[0])*(x[1]-x[0])+(y[1]-y[0])*(y[1]-y[0]));
+		x[0] += r.x; y[0]+=r.y;
+		int i2 = 1;
+		int x1,y1,x2=0,y2=0;
+		for (int i=1; i<n-1; i++) {
+			x1=x[i]; y1=y[i]; x2=x[i+1]; y2=y[i+1];
+			distance += Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)) + 1;
+			distance += curvature[i]*2;
+			if (distance>=threshold) {
+				x[i2] = x2 + r.x;
+				y[i2] = y2 + r.y;
+				i2++;
+				distance = 0.0;
+			}
+		}
+		int type = roi.getType()==Roi.FREELINE?Roi.POLYLINE:Roi.POLYGON;
+		if (type==Roi.POLYLINE && distance>0.0) {
+			x[i2] = x2 + r.x;
+			y[i2] = y2 + r.y;
+			i2++;
+		}		
+		PolygonRoi p = new PolygonRoi(x, y, i2, type);
+		if (roi.getStroke()!=null)
+			p.setStrokeWidth(roi.getStrokeWidth());
+		p.setStrokeColor(roi.getStrokeColor());
+		p.setName(roi.getName());
+		imp.setRoi(p);
+		return p;
+	}
+	
+	double rodbard(double x) {
+		// y = c*((a-x/(x-d))^(1/b)
+		// a=3.9, b=.88, c=712, d=44
+		double ex;
+		if (x == 0.0)
+			ex = 5.0;
+		else
+			ex = Math.exp(Math.log(x/700.0)*0.88);
+		double y = 3.9-44.0;
+		y = y/(1.0+ex);
+		return y+44.0;
+	}
+
+	int[] smooth(int[] a, int n) {
+		FloatProcessor fp = new FloatProcessor(n, 1);
+		for (int i=0; i<n; i++)
+			fp.putPixelValue(i, 0, a[i]);
+		GaussianBlur gb = new GaussianBlur();
+		gb.blur1Direction(fp, 2.0, 0.01, true, 0);
+		IJ.showProgress(1.0);
+		for (int i=0; i<n; i++)
+			a[i] = (int)Math.round(fp.getPixelValue(i, 0));
+		return a;
+	}
+	
+	float[] getCurvature(int[] x, int[] y, int n) {
+		float[] x2 = new float[n];
+		float[] y2 = new float[n];
+		for (int i=0; i<n; i++) {
+			x2[i] = x[i];
+			y2[i] = y[i];
+		}
+		ImageProcessor ipx = new FloatProcessor(n, 1, x2, null);
+		ImageProcessor ipy = new FloatProcessor(n, 1, y2, null);
+		ipx.convolve(kernel, kernel.length, 1);
+		ipy.convolve(kernel, kernel.length, 1);
+		float[] indexes = new float[n];
+		float[] curvature = new float[n];
+		for (int i=0; i<n; i++) {
+			indexes[i] = i;
+			curvature[i] = (float)Math.sqrt((x2[i]-x[i])*(x2[i]-x[i])+(y2[i]-y[i])*(y2[i]-y[i]));
+		}
+		return curvature;
+	}
+	
+	PolygonRoi trimFloatPolygon(PolygonRoi roi, double length) {
+		FloatPolygon poly = roi.getFloatPolygon();
+		float[] x = poly.xpoints;
+		float[] y = poly.ypoints;
+		int n = poly.npoints;
+		x = smooth(x, n);
+		y = smooth(y, n);
+		float[] curvature = getCurvature(x, y, n);
+		double threshold = rodbard(length);
+		//IJ.log("trim: "+length+" "+threshold);
+		double distance = Math.sqrt((x[1]-x[0])*(x[1]-x[0])+(y[1]-y[0])*(y[1]-y[0]));
+		int i2 = 1;
+		double x1,y1,x2=0,y2=0;
+		for (int i=1; i<n-1; i++) {
+			x1=x[i]; y1=y[i]; x2=x[i+1]; y2=y[i+1];
+			distance += Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)) + 1;
+			distance += curvature[i]*2;
+			if (distance>=threshold) {
+				x[i2] = (float)x2;
+				y[i2] = (float)y2;
+				i2++;
+				distance = 0.0;
+			}
+		}
+		int type = roi.getType()==Roi.FREELINE?Roi.POLYLINE:Roi.POLYGON;
+		if (type==Roi.POLYLINE && distance>0.0) {
+			x[i2] = (float)x2;
+			y[i2] = (float)y2;
+			i2++;
+		}		
+		PolygonRoi p = new PolygonRoi(x, y, i2, type);
+		if (roi.getStroke()!=null)
+			p.setStrokeWidth(roi.getStrokeWidth());
+		p.setStrokeColor(roi.getStrokeColor());
+		p.setDrawOffset(roi.getDrawOffset());
+		p.setName(roi.getName());
+		imp.setRoi(p);
+		return p;
+	}
+	
+	float[] smooth(float[] a, int n) {
+		FloatProcessor fp = new FloatProcessor(n, 1);
+		for (int i=0; i<n; i++)
+			fp.setf(i, 0, a[i]);
+		GaussianBlur gb = new GaussianBlur();
+		gb.blur1Direction(fp, 2.0, 0.01, true, 0);
+		for (int i=0; i<n; i++)
+			a[i] = fp.getf(i, 0);
+		return a;
+	}
+	
+	float[] getCurvature(float[] x, float[] y, int n) {
+		float[] x2 = new float[n];
+		float[] y2 = new float[n];
+		for (int i=0; i<n; i++) {
+			x2[i] = x[i];
+			y2[i] = y[i];
+		}
+		ImageProcessor ipx = new FloatProcessor(n, 1, x, null);
+		ImageProcessor ipy = new FloatProcessor(n, 1, y, null);
+		ipx.convolve(kernel, kernel.length, 1);
+		ipy.convolve(kernel, kernel.length, 1);
+		float[] indexes = new float[n];
+		float[] curvature = new float[n];
+		for (int i=0; i<n; i++) {
+			indexes[i] = i;
+			curvature[i] = (float)Math.sqrt((x2[i]-x[i])*(x2[i]-x[i])+(y2[i]-y[i])*(y2[i]-y[i]));
+		}
+		return curvature;
+	}
+
+	void createEllipse(ImagePlus imp) {
+		if (!imp.okToDeleteRoi()) return;
+		IJ.showStatus("Fitting ellipse");
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			{noRoi("Fit Ellipse"); return;}
+		if (roi.isLine())
+			{IJ.error("Fit Ellipse", "\"Fit Ellipse\" does not work with line selections"); return;}
+		ImageProcessor ip = imp.getProcessor();
+		ip.setRoi(roi);
+		int options = Measurements.CENTROID+Measurements.ELLIPSE;
+		ImageStatistics stats = ImageStatistics.getStatistics(ip, options, null);
+		double dx = stats.major*Math.cos(stats.angle/180.0*Math.PI)/2.0;
+		double dy = - stats.major*Math.sin(stats.angle/180.0*Math.PI)/2.0;
+		double x1 = stats.xCentroid - dx;
+		double x2 = stats.xCentroid + dx;
+		double y1 = stats.yCentroid - dy;
+		double y2 = stats.yCentroid + dy;
+		double aspectRatio = stats.minor/stats.major;
+		Undo.setup(Undo.ROI, imp);
+		imp.deleteRoi();
+		Roi roi2 = new EllipseRoi(x1,y1,x2,y2,aspectRatio);
+		transferProperties(roi, roi2);
+		imp.setRoi(roi2);
+	}
+
+	void convexHull(ImagePlus imp) {
+		if (!imp.okToDeleteRoi()) return;
+		long startTime = System.currentTimeMillis();
+		Roi roi = imp.getRoi();
+		if (roi == null) { IJ.error("Convex Hull", "Selection required"); return; }
+		if (roi instanceof Line) { IJ.error("Convex Hull", "Area selection, point selection, or segmented or free line required"); return; }
+		FloatPolygon p = roi.getFloatConvexHull();
+		if (p!=null) {
+			Undo.setup(Undo.ROI, imp);
+			imp.deleteRoi();
+			Roi roi2 = new PolygonRoi(p, roi.POLYGON);
+			transferProperties(roi, roi2);
+			imp.setRoi(roi2);
+			IJ.showTime(imp, startTime, "Convex Hull ", 1);
+		}
+	}
+	
+	// Finds the index of the upper right point that is guaranteed to be on convex hull
+	/*int findFirstPoint(int[] xCoordinates, int[] yCoordinates, int n, ImagePlus imp) {
+		int smallestY = imp.getHeight();
+		int x, y;
+		for (int i=0; i<n; i++) {
+			y = yCoordinates[i];
+			if (y<smallestY)
+			smallestY = y;
+		}
+		int smallestX = imp.getWidth();
+		int p1 = 0;
+		for (int i=0; i<n; i++) {
+			x = xCoordinates[i];
+			y = yCoordinates[i];
+			if (y==smallestY && x<smallestX) {
+				smallestX = x;
+				p1 = i;
+			}
+		}
+		return p1;
+	}*/
+	
+	void createMask(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		boolean useInvertingLut = Prefs.useInvertingLut;
+		Prefs.useInvertingLut = false;
+		boolean selectAll = roi!=null && roi.getType()==Roi.RECTANGLE && roi.getBounds().width==imp.getWidth()
+			&& roi.getBounds().height==imp.getHeight() && imp.isThreshold();
+		boolean overlay = imp.getOverlay()!=null && imp.getProcessor().getMinThreshold()==ImageProcessor.NO_THRESHOLD;
+		if (!overlay && (roi==null || selectAll)) {
+			createMaskFromThreshold(imp);
+			Prefs.useInvertingLut = useInvertingLut;
+			return;
+		}
+		if (roi==null && imp.getOverlay()==null) {
+			IJ.error("Create Mask", "Selection, overlay or threshold required");
+			return;
+		}
+		ByteProcessor mask = imp.createRoiMask();
+		if (!Prefs.blackBackground)
+			mask.invertLut();
+		mask.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+		ImagePlus maskImp = null;
+		Frame frame = WindowManager.getFrame("Mask");
+		if (frame!=null && (frame instanceof ImageWindow))
+			maskImp = ((ImageWindow)frame).getImagePlus();
+		if (maskImp!=null && maskImp.getBitDepth()==8) {
+			ImageProcessor ip = maskImp.getProcessor();
+			ip.copyBits(mask, 0, 0, Blitter.OR);
+			maskImp.setProcessor(ip);
+		} else {
+			maskImp = new ImagePlus("Mask", mask);
+			maskImp.show();
+		}
+		Calibration cal = imp.getCalibration();
+		if (cal.scaled()) {
+			Calibration cal2 = maskImp.getCalibration();
+			cal2.pixelWidth = cal.pixelWidth;
+			cal2.pixelHeight = cal.pixelHeight;
+			cal2.setUnit(cal.getUnit());
+		}
+		maskImp.updateAndRepaintWindow();
+		Prefs.useInvertingLut = useInvertingLut;
+		Recorder.recordCall("mask = imp.createRoiMask();");
+	}
+	
+	void createMaskFromThreshold(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.getMinThreshold()==ImageProcessor.NO_THRESHOLD) {
+			IJ.error("Create Mask", "Area selection, overlay or thresholded image required");
+			return;
+		}
+		ByteProcessor mask = imp.createThresholdMask();
+		if (!Prefs.blackBackground)
+			mask.invertLut();
+		mask.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+		ImagePlus maskImp = new ImagePlus("mask",mask);
+		Calibration cal = imp.getCalibration();
+		if (cal.scaled()) {
+			Calibration cal2 = maskImp.getCalibration();
+			cal2.pixelWidth = cal.pixelWidth;
+			cal2.pixelHeight = cal.pixelHeight;
+			cal2.setUnit(cal.getUnit());
+		}
+		maskImp.show();
+		Recorder.recordCall("mask = imp.createThresholdMask();");
+	}
+
+	void createSelectionFromMask(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		if (ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+			IJ.runPlugIn("ij.plugin.filter.ThresholdToSelection", "");
+			return;
+		}
+		if (!ip.isBinary()) {
+			IJ.error("Create Selection",
+				"This command creates a composite selection from\n"+
+				"a mask (8-bit binary image) or from an image\n"+
+				"thresholded using Image>Adjust>Threshold\n"+
+				"The current image is not a mask and has not\n"+
+				"been thresholded.");
+			return;
+		}
+		int threshold = ip.isInvertedLut()?255:0;
+		if (Prefs.blackBackground)
+			threshold = (threshold==255)?0:255;
+		ip.setThreshold(threshold, threshold, ImageProcessor.NO_LUT_UPDATE);
+		if (!IJ.isMacro())
+			IJ.log("Create Selection: threshold not set; assumed to be "+threshold+"-"+threshold);
+		IJ.runPlugIn("ij.plugin.filter.ThresholdToSelection", "");
+	}
+	
+	void invert(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		if (roi == null)
+			{run("all"); return;}
+		if (!roi.isArea())
+			{IJ.error("Inverse", "Area selection required"); return;}
+		Roi inverse = roi.getInverse(imp);
+		Undo.setup(Undo.ROI, imp);
+		imp.setRoi(inverse);
+	}
+	
+	private void lineToArea(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		if (roi==null || !roi.isLine())
+			{IJ.error("Line to Area", "Line selection required"); return;}
+		Undo.setup(Undo.ROI, imp);
+		Roi roi2 = lineToArea(roi);
+		imp.setRoi(roi2);
+		Roi.setPreviousRoi(roi);
+	}
+	
+	/** Converts a line selection into an area selection. */
+	public static Roi lineToArea(Roi roi) {
+		return Roi.convertLineToArea(roi);
+	}
+	
+	void areaToLine(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		if (roi==null || !roi.isArea()) {
+			IJ.error("Area to Line", "Area selection required");
+			return;
+		}
+		Undo.setup(Undo.ROI, imp);
+		Polygon p = roi.getPolygon();
+		FloatPolygon fp = (roi.subPixelResolution()) ? roi.getFloatPolygon() : null;
+		if (p==null && fp==null)
+			return;
+		int type1 = roi.getType();
+		if (type1==Roi.COMPOSITE) {
+			IJ.error("Area to Line", "Composite selections cannot be converted to lines.");
+			return;
+		}
+		if (fp==null && type1==Roi.TRACED_ROI) {
+			for (int i=0; i<p.npoints; i++) {
+				if (p.xpoints[i]>=imp.getWidth()) p.xpoints[i]=imp.getWidth()-1;
+				if (p.ypoints[i]>=imp.getHeight()) p.ypoints[i]=imp.getHeight()-1;
+			}
+		}
+		int type2 = Roi.POLYLINE;
+		if (type1==Roi.OVAL||type1==Roi.FREEROI||type1==Roi.TRACED_ROI
+		||((roi instanceof PolygonRoi)&&((PolygonRoi)roi).isSplineFit()))
+			type2 = Roi.FREELINE;
+		Roi roi2 = fp==null ? new PolygonRoi(p, type2) : new PolygonRoi(fp, type2);
+		transferProperties(roi, roi2);
+		Rectangle2D.Double bounds = roi.getFloatBounds();
+		roi2.setLocation(bounds.x - 0.5, bounds.y -0.5);	//area and line roi coordinates are 0.5 pxl different
+		imp.setRoi(roi2);
+	}
+
+	void toBoundingBox(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			noRoi("To Bounding Box");
+			return;
+		}
+		if (!imp.okToDeleteRoi())
+			return;
+		Undo.setup(Undo.ROI, imp);
+		Rectangle r = roi.getBounds();
+		imp.deleteRoi();
+		Roi roi2 = new Roi(r.x, r.y, r.width, r.height);
+		transferProperties(roi, roi2);
+		imp.setRoi(roi2);
+	}
+
+	void addToRoiManager(ImagePlus imp) {
+		if (IJ.macroRunning() &&  Interpreter.isBatchModeRoiManager())
+			IJ.error("run(\"Add to Manager\") may not work in batch mode macros");
+		Frame frame = WindowManager.getFrame("ROI Manager");
+		if (frame==null)
+			IJ.run("ROI Manager...");
+		if (imp==null) return;
+		Roi roi = imp.getRoi();
+		if (roi==null) return;
+		frame = WindowManager.getFrame("ROI Manager");
+		if (frame==null || !(frame instanceof RoiManager))
+			IJ.error("ROI Manager not found");
+		RoiManager rm = (RoiManager)frame;
+		boolean altDown= IJ.altKeyDown();
+		IJ.setKeyUp(IJ.ALL_KEYS);
+		if (altDown && !IJ.macroRunning())
+			IJ.setKeyDown(KeyEvent.VK_SHIFT);
+		if (roi.getState()==Roi.CONSTRUCTING) { //wait (up to 2 sec.) until ROI finished
+			long start = System.currentTimeMillis();
+			while (true) {
+				IJ.wait(10);
+				if (roi.getState()!=Roi.CONSTRUCTING)
+					break;
+				if ((System.currentTimeMillis()-start)>2000) {
+					IJ.beep();
+					IJ.error("Add to Manager", "Selection is not complete");
+					return;
+				}
+			}
+		}
+		if (Recorder.record && imp.getStackSize()>1) {
+			if (imp.isHyperStack()) {
+				int C = imp.getChannel();
+				int Z = imp.getSlice();
+				int T = imp.getFrame();
+				if (Recorder.scriptMode()) {
+					Recorder.recordCall("roi = imp.getRoi();");
+					Recorder.recordCall("roi.setPosition("+C+", "+Z+", "+T+");");
+				} else
+					Recorder.record("Roi.setPosition", C, Z, T);				
+			} else {
+				int position = imp.getCurrentSlice();
+				if (Recorder.scriptMode()) {
+					Recorder.recordCall("roi = imp.getRoi();");
+					Recorder.recordCall("roi.setPosition("+position+");");
+				} else
+					Recorder.record("Roi.setPosition", position);
+			}
+		}
+		rm.allowRecording(true);
+		rm.runCommand("add");
+		rm.allowRecording(false);
+		IJ.setKeyUp(IJ.ALL_KEYS);
+	}
+	
+	boolean setProperties(String title, Roi roi) {
+		if ((roi instanceof PointRoi) && Toolbar.getMultiPointMode() && IJ.altKeyDown()) {
+			((PointRoi)roi).displayCounts();
+			return true;
+		}
+		Frame f = WindowManager.getFrontWindow();
+		if (f!=null && f.getTitle().indexOf("3D Viewer")!=-1)
+			return false;
+		if (roi==null) {
+			IJ.error("This command requires a selection.");
+			return false;
+		}
+		RoiProperties rp = new RoiProperties(title, roi);
+		boolean ok = rp.showDialog();
+		if (IJ.debugMode)
+			IJ.log(roi.getDebugInfo());
+		return ok;
+	}
+	
+	private void makeBand(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			noRoi("Make Band");
+			return;
+		}
+		Roi roiOrig = roi;
+		if (!roi.isArea()) {
+			IJ.error("Make Band", "Area selection required");
+			return;
+		}
+		Calibration cal = imp.getCalibration();
+		double pixels = bandSize;
+		double size = pixels*cal.pixelWidth;
+		int decimalPlaces = 0;
+		if ((int)size!=size)
+			decimalPlaces = 2;
+		GenericDialog gd = new GenericDialog("Make Band");
+		gd.addNumericField("Band Size:", size, decimalPlaces, 4, cal.getUnits());
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		size = gd.getNextNumber();
+		if (Double.isNaN(size)) {
+			IJ.error("Make Band", "invalid number");
+			return;
+		}
+		int n = (int)Math.round(size/cal.pixelWidth); 
+		if (n >255) {
+			IJ.error("Make Band", "Cannot make bands wider that 255 pixels");
+			return;
+		}
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		Rectangle r = roi.getBounds();
+		ImageProcessor ip = roi.getMask();
+		if (ip==null) {
+			ip = new ByteProcessor(r.width, r.height);
+			ip.invert();
+		}
+		ImageProcessor mask = new ByteProcessor(width, height);
+		mask.insert(ip, r.x, r.y);
+		ImagePlus edm = new ImagePlus("mask", mask);
+		boolean saveBlackBackground = Prefs.blackBackground;
+		Prefs.blackBackground = false;
+		int saveType = EDM.getOutputType();
+		EDM.setOutputType(EDM.BYTE_OVERWRITE);
+		IJ.run(edm, "Distance Map", "");
+		EDM.setOutputType(saveType);
+		Prefs.blackBackground = saveBlackBackground;
+		ip = edm.getProcessor();
+		ip.setThreshold(0, n, ImageProcessor.NO_LUT_UPDATE);
+		int xx=-1, yy=-1;
+		for (int x=r.x; x<r.x+r.width; x++) {
+			for (int y=r.y; y<r.y+r.height; y++) {
+				if (ip.getPixel(x, y)<n) {
+					xx=x; yy=y;
+					break;
+				}
+			}
+			if (xx>=0||yy>=0)
+				break;
+		}
+		int count = IJ.doWand(edm, xx, yy, 0, null);
+		if (count<=0) {
+			IJ.error("Make Band", "Unable to make band");
+			return;
+		}
+		ShapeRoi roi2 = new ShapeRoi(edm.getRoi());
+		if (!(roi instanceof ShapeRoi))
+			roi = new ShapeRoi(roi);
+		ShapeRoi roi1 = (ShapeRoi)roi;
+		roi2 = roi2.not(roi1);
+		Undo.setup(Undo.ROI, imp);
+		transferProperties(roiOrig, roi2);
+		imp.setRoi(roi2);
+		bandSize = n;
+	}
+	
+	/*  Fits a minimum area rectangle into a ROI, by searching for the minimum area bounding rectangles
+	 *  among the ones having a side that is colinear with an edge of the convex hull.
+	 *	
+	 * 	Loosely based on:
+	 * 	H. Freeman and R. Shapira. 1975. Determining the minimum-area encasing rectangle for an arbitrary 
+	 * 	closed curve. Commun. ACM 18, 7 (July 1975), 409–413. DOI:https://doi.org/10.1145/360881.360919	
+	*/
+	private void fitRectangle(ImagePlus imp) {
+		if (!imp.okToDeleteRoi()) return;
+		long startTime = System.currentTimeMillis();
+		Roi roi = imp.getRoi();
+		if (roi == null)
+			{noRoi("Fit Rectangle"); return;}
+		if (roi instanceof Line || roi.isDrawingTool()) 
+			{IJ.error("Fit Rectangle", "Area selection, point selection, or segmented or free line required"); return;}
+		if (!roi.isArea()) {
+			// check number of points and colinearity before proceeding
+			FloatPolygon poly = roi.getFloatPolygon();
+			int n = poly.npoints;
+			if (n < 3)
+				{IJ.error("Fit Rectangle", "At least three points are required"); return;}
+			float[] x = poly.xpoints;
+			float[] y = poly.ypoints;
+			boolean colinear = true;
+			for(int i=2; i<n; i++) {
+				float prod = (x[i] - x[0]) * (y[i] - y[0]) - (x[i] - x[1]) * (y[i] - y[1]);
+				if (prod != 0)	colinear = false;	
+			}
+			if (colinear)
+				{IJ.error("Fit Rectangle", "Points are colinear"); return;}
+		}
+		FloatPolygon p = roi.getFloatConvexHull();
+		if (p!=null) {		
+			int np = p.npoints;
+			float[] xp = p.xpoints;
+			float[] yp = p.ypoints;
+			Rectangle r = roi.getBounds();
+			double minArea = 2 * r.width * r.height; // generous overestimation
+			double minFD = 0;
+			int imin = -1;
+			int i2min = -1;
+			int jmin = -1;
+			double min_hmin = 0;
+			double min_hmax = 0;
+			for (int i = 0; i < np; i++) {
+				double maxLD = 0;
+				int imax = -1;
+				int i2max = -1;
+				int jmax = -1;
+				int i2 = i + 1;
+				if(i == np-1) i2 = 0;
+				for (int j = 0; j < np; j++) {
+					// distance based on vector cross product
+					double d = Math.abs( ((xp[i2] - xp[i]) * (yp[j] - yp[i]) - (xp[j] - xp[i]) * (yp[i2] - yp[i])) / Math.sqrt(Math.pow(xp[i2] - xp[i], 2) + Math.pow(yp[i2] - yp [i], 2)) );
+					if (maxLD < d) {
+						maxLD = d;
+						imax = i;
+						jmax = j;
+						i2max = i2;
+					}
+				}
+				double hmin = 0;
+				double hmax = 0;
+				for (int k = 0; k < np; k++) { // rotating calipers
+					// projected distance based on vector dot product, includes sign
+					double hd = ((xp[i2max] - xp[imax]) * (xp[k] -  xp[imax]) + (yp[k] - yp[imax]) * (yp[i2max] - yp[imax])) / Math.sqrt(Math.pow(xp[i2max] - xp[imax], 2) + Math.pow(yp[i2max] - yp [imax], 2));
+					hmin = Math.min(hmin, hd);
+					hmax = Math.max(hmax, hd);
+				}
+				double area = maxLD * (hmax - hmin);
+				if (minArea > area) {
+					minArea = area;
+					minFD = maxLD;
+					min_hmin = hmin;
+					min_hmax = hmax;
+
+					imin = imax;
+					i2min = i2max;
+					jmin = jmax;
+				}
+			}
+			double pd = ((xp[i2min] - xp[imin]) * (yp[jmin] - yp[imin]) - (xp[jmin] - xp[imin]) * (yp[i2min] - yp[imin])) / Math.sqrt(Math.pow(xp[i2min] - xp[imin], 2) + Math.pow(yp[i2min] - yp [imin], 2)); // signed feret diameter
+			double pairAngle = Math.atan2( yp[i2min]- yp[imin], xp[i2min]- xp[imin]);
+			double minAngle = pairAngle + Math.PI/2;
+
+			// rectangle center and signed full height
+			double xm = xp[imin] + Math.cos(pairAngle) * (min_hmax + min_hmin)/2 + Math.cos(minAngle) * pd/2;
+			double ym = yp[imin] + Math.sin(pairAngle) * (min_hmax + min_hmin)/2 + Math.sin(minAngle) * pd/2;
+			double hm = min_hmax - min_hmin;
+			
+			if (minFD > Math.abs(hm)) { // ensure control axis is parallel to longer side
+				pairAngle = pairAngle - Math.PI/2;
+				minFD = Math.abs(hm);
+				hm = pd;
+				}
+			
+			if (pairAngle * hm > 0)	hm = -hm; // ensure first control point at the top
+	
+			double x1 = xm + Math.cos(pairAngle) * hm/2;
+			double y1 = ym + Math.sin(pairAngle) * hm/2;
+			double x2 = xm - Math.cos(pairAngle) * hm/2;
+			double y2 = ym - Math.sin(pairAngle) * hm/2;
+			Undo.setup(Undo.ROI, imp);
+			imp.deleteRoi();
+			Roi roi2 = new RotatedRectRoi(x1,  y1,  x2,  y2,  minFD);
+			transferProperties(roi, roi2);
+			imp.setRoi(roi2);
+			IJ.showTime(imp, startTime, "Fit Rectangle ", 1);
+		}
+	}
+	
+	void noRoi(String command) {
+		IJ.error(command, "This command requires a selection");
+	}
+
+}
diff --git a/src/ij/plugin/SimpleCommands.java b/src/ij/plugin/SimpleCommands.java
new file mode 100644
index 0000000..b992341
--- /dev/null
+++ b/src/ij/plugin/SimpleCommands.java
@@ -0,0 +1,274 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.Opener;
+import ij.text.TextWindow;
+import ij.measure.ResultsTable;
+import ij.plugin.frame.Editor;
+import java.awt.Desktop;
+import java.awt.Frame;
+import java.io.File;
+
+/** This plugin implements the Plugins/Utilities/Unlock, Image/Rename
+	and Plugins/Utilities/Search commands. */
+public class SimpleCommands implements PlugIn {
+	static String searchArg;
+    private static String[] choices = {"Locked Image", "Clipboard", "Undo Buffer"};
+    private static int choiceIndex = 0;
+
+	public void run(String arg) {
+		if (arg.equals("search"))
+			search();
+		else if (arg.equals("import")) 
+			Opener.openResultsTable("");
+		else if (arg.equals("table")) 
+			Opener.openTable("");
+		else if (arg.equals("rename"))
+			rename();	
+		else if (arg.equals("reset"))
+			reset();
+		else if (arg.equals("about"))
+			aboutPluginsHelp();
+		else if (arg.equals("install"))
+			installation();
+		else if (arg.equals("set"))
+			setSliceLabel();
+		else if (arg.equals("remove"))
+			removeStackLabels();
+		else if (arg.equals("itor"))
+			imageToResults();
+		else if (arg.equals("rtoi"))
+			resultsToImage();
+		else if (arg.equals("display"))
+			IJ.runMacroFile("ij.jar:ShowAllLuts", null);
+		else if (arg.equals("missing"))
+			showMissingPluginsMessage();
+		else if (arg.equals("fonts"))
+			showFonts();
+		else if (arg.equals("opencp"))
+			openControlPanel();
+		else if (arg.equals("magic"))
+			installMagicMontageTools();
+		else if (arg.equals("interactive"))
+			openInteractiveModeEditor();
+		else if (arg.startsWith("showdir"))
+			showDirectory(arg.replace("showdir", ""));
+		else if (arg.equals("measure"))
+			measureStack();
+	}
+	
+	private synchronized void showFonts() {
+		Thread t = new Thread(new Runnable() {
+			public void run() {IJ.runPlugIn("ij.plugin.Text", "");}
+		});
+		t.start();
+	}
+
+	private void reset() {
+		GenericDialog gd = new GenericDialog("");
+		gd.addChoice("Reset:", choices, choices[choiceIndex]);
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		choiceIndex = gd.getNextChoiceIndex();
+		switch (choiceIndex) {
+			case 0: unlock(); break;
+			case 1: resetClipboard(); break;
+			case 2: resetUndo(); break;
+		}
+	}
+	
+	private void unlock() {
+		ImagePlus imp = IJ.getImage();
+		boolean wasUnlocked = imp.lockSilently();
+		if (wasUnlocked)
+			IJ.showStatus("\""+imp.getTitle()+"\" is not locked");
+		else {
+			IJ.showStatus("\""+imp.getTitle()+"\" is now unlocked");
+			IJ.beep();
+		}
+		imp.unlock();
+	}
+
+	private void resetClipboard() {
+		ImagePlus.resetClipboard();
+		IJ.showStatus("Clipboard reset");
+	}
+	
+	private void resetUndo() {
+		Undo.setup(Undo.NOTHING, null);
+		IJ.showStatus("Undo reset");
+	}
+	
+	private void rename() {
+		ImagePlus imp = IJ.getImage();
+		GenericDialog gd = new GenericDialog("Rename");
+		gd.addStringField("Title:", imp.getTitle(), 30);
+		gd.showDialog();
+		if (!gd.wasCanceled())
+			imp.setTitle(gd.getNextString());
+	}
+		
+	private void search() {
+		searchArg = IJ.runMacroFile("ij.jar:Search", searchArg);
+	}
+		
+	private void installation() {
+		String url = IJ.URL+"/docs/install/";
+		if (IJ.isMacintosh())
+			url += "osx.html";
+		else if (IJ.isWindows())
+			url += "windows.html";
+		else if (IJ.isLinux())
+			url += "linux.html";
+		IJ.runPlugIn("ij.plugin.BrowserLauncher", url);
+	}
+	
+	private void aboutPluginsHelp() {
+		IJ.showMessage("\"About Plugins\" Submenu", 
+			"Plugins packaged as JAR files can add entries\n"+
+			"to this submenu. There is an example at\n \n"+
+			IJ.URL+"/plugins/jar-demo.html");
+	}
+	
+	private void setSliceLabel() {
+		ImagePlus imp = IJ.getImage();
+		ImageStack stack = imp.getStack();
+		int n = imp.getCurrentSlice();
+		String label = stack.getSliceLabel(n);
+		String label2 = label;
+		if (label2==null)
+			label2 = "";
+		GenericDialog gd = new GenericDialog("Set Slice Label ("+n+")");
+		gd.addStringField("Label:", label2, 30);
+		gd.showDialog();
+		if (!gd.wasCanceled()) {
+			label2 = gd.getNextString();
+			if (label2!=label) {
+				if (label2.length()==0)
+					label2 = null;
+				stack.setSliceLabel(label2, n);
+				imp.setProp("Slice_Label", label2);	
+				imp.repaintWindow();
+			}
+		}
+	}
+
+	private void removeStackLabels() {
+		ImagePlus imp = IJ.getImage();
+		ImageStack stack = imp.getStack();
+		int size = imp.getStackSize();
+		for (int i=1; i<=size; i++)
+			stack.setSliceLabel(null, i);
+		if (size==1)
+			imp.setProp("Slice_Label", null);				
+		imp.repaintWindow();
+	}
+	
+	private void imageToResults() {
+		ImagePlus imp = IJ.getImage();
+		ImageProcessor ip = imp.getProcessor();
+		ResultsTable rt = ResultsTable.createTableFromImage(ip);
+		rt.show("Results");
+	}
+	
+	private void resultsToImage() {
+		ResultsTable rt = ResultsTable.getResultsTable();
+		if (rt==null || rt.size()==0) {
+			IJ.error("Results to Image", "The Results table is empty");
+			return;
+		}
+		ImageProcessor ip = rt.getTableAsImage();
+		if (ip==null) return;
+		new ImagePlus("Results Table", ip).show();
+	}
+	
+	private void openControlPanel() {
+		Prefs.set("Control_Panel.@Main", "51 22 92 426");
+		Prefs.set("Control_Panel.Help.Examples", "144 107 261 373");
+		IJ.run("Control Panel...", "");
+	}
+
+	private void showMissingPluginsMessage() {
+		IJ.showMessage("Path Randomization", 
+			"Plugins were not loaded due to macOS Path Randomization.\n"+
+			"To work around this problem, move ImageJ.app out of the\n"+
+			"ImageJ folder and then copy it back. More information is at\n \n"+
+			IJ.URL+"/docs/install/osx.html#randomization");
+	}
+	
+	private void installMagicMontageTools() {
+		String name = "MagicMontageTools.txt";
+		String path = "/macros/"+name;
+		MacroInstaller mi = new MacroInstaller();
+		if (IJ.shiftKeyDown())
+			 Toolbar.showCode(name, mi.openFromIJJar(path));
+		else
+			try {
+				mi.installFromIJJar(path);
+			} catch (Exception e) {}
+	}
+	
+	private void openInteractiveModeEditor() {
+		Editor ed = new Editor();
+		ed.setSize(600, 500);
+		ed.create(Editor.INTERACTIVE_NAME, "");
+	}
+	
+	private void showDirectory(String arg) {
+		arg = arg.toLowerCase();
+		String path = IJ.getDir(arg);
+		if (path == null) {
+			if (arg.equals("image")) {
+				if (WindowManager.getCurrentImage()==null)
+					IJ.noImage();
+				else
+					IJ.error("No file is associated with front image");
+			} else
+				IJ.error("Folder not found: " + arg);
+			return;
+		}		
+		File dir = new File(path);
+		if (!dir.exists()) {
+			IJ.error("Folder not found: " + arg);
+			return;
+		}
+		if (arg.equals("image")&& IJ.getImage()!=null) {
+			File imgPath = new File(IJ.getDir("image"));
+			if (!imgPath.exists()) {
+				IJ.error("Image not found");
+				return;
+			}
+		}
+		if (IJ.debugMode) IJ.log("Show Folder: arg="+arg+", path="+path);
+		String msg1 = "";
+		if (IJ.isLinux()) try {
+			if (IJ.debugMode) IJ.log("  trying xdg-open "+path);
+			Runtime.getRuntime().exec(new String[] {"xdg-open", path} );
+			return;
+		} catch (Exception e2) {
+			msg1 = "xdg-open error: "+e2;
+		}
+		try {
+			if (IJ.debugMode) IJ.log("  trying Desktop.open "+dir);
+			Desktop desktop = Desktop.getDesktop();
+			desktop.open(dir);
+		} catch (Exception e) {
+			String msg2 = "Desktop.open error: "+e;
+			if (msg1.length()>0)
+				msg2 = msg1+"\n"+msg2;
+			IJ.error("Show Folder", msg2);
+		}
+	}
+
+	private void measureStack() {
+		ImagePlus imp = IJ.getImage();
+		if (imp.isLocked()) {
+			IJ.showStatus("Image is locked: \""+imp.getTitle()+"\"");
+			IJ.beep();
+		} else
+			IJ.runMacroFile("ij.jar:MeasureStack", null);
+		return;
+	}
+
+}
diff --git a/src/ij/plugin/Slicer.java b/src/ij/plugin/Slicer.java
new file mode 100644
index 0000000..ab7aee3
--- /dev/null
+++ b/src/ij/plugin/Slicer.java
@@ -0,0 +1,753 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+
+/** Implements the Image/Stacks/Reslice command. Known shortcomings: 
+	for FREELINE or POLYLINE ROI, spatial calibration is ignored: 
+	the image is sampled at constant _pixel_ increments (distance 1), so 
+	(if y/x aspect ratio != 1 in source image) one dimension in the output is not
+	homogeneous (i.e. pixelWidth not the same everywhere).
+*/
+public class Slicer implements PlugIn, TextListener, ItemListener {
+
+	private static final String[] starts = {"Top", "Left", "Bottom", "Right"};
+	private static String startAtS = starts[0];
+	private static boolean rotateS;
+	private static boolean flipS;
+	private static int sliceCountS = 1;
+	
+	private String startAt = starts[0];
+	private boolean rotate;
+	private boolean flip;
+	private int sliceCount = 1;
+	private boolean nointerpolate = Prefs.avoidResliceInterpolation;
+	private double inputZSpacing = 1.0;
+	private double outputZSpacing = 1.0;
+	private int outputSlices = 1;
+	private boolean noRoi;
+	private boolean rgb, notFloat;
+	private Vector fields, checkboxes;
+	private Label message;
+	private ImagePlus imp;
+	private double gx1, gy1, gx2, gy2, gLength;
+	private Color lineColor = new Color(1f, 1f, 0f, 0.4f);
+
+	// Variables used by getIrregularProfile and doIrregularSetup
+	private int n;
+	private double[] x;
+	private	double[] y;
+	private int xbase;
+	private int ybase;
+	private double length;
+	private double[] segmentLengths;
+	private double[] dx;
+	private double[] dy;
+
+	public void run(String arg) {
+		imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			IJ.noImage();
+			return;
+		}
+		int stackSize = imp.getStackSize();
+		Roi roi = imp.getRoi();
+		int roiType = roi!=null?roi.getType():0;
+		// stack required except for ROI = none or RECT
+		if (stackSize<2 && roi!=null && roiType!=Roi.RECTANGLE) {
+			IJ.error("Reslice...", "Stack required");
+			return;
+		}
+		// permissible ROI types: none,RECT,*LINE
+		if (roi!=null && roiType!=Roi.RECTANGLE && roiType!=Roi.LINE && roiType!=Roi.POLYLINE && roiType!=Roi.FREELINE) {
+			IJ.error("Reslice...", "Line or rectangular selection required");
+			return;
+		}
+		if (!showDialog(imp))
+			return;
+		long startTime = System.currentTimeMillis();
+		ImagePlus imp2 = null;
+		rgb = imp.getType()==ImagePlus.COLOR_RGB;
+		notFloat = !rgb && imp.getType()!=ImagePlus.GRAY32;
+		if (imp.isHyperStack())
+			imp2 = resliceHyperstack(imp);
+		else
+			imp2 = reslice(imp);
+		if (imp2==null)
+			return;
+		ImageProcessor ip = imp.getProcessor();
+		double min = ip.getMin();
+		double max = ip.getMax();
+		if (!rgb) imp2.getProcessor().setMinAndMax(min, max);
+		imp2.show();
+		if (noRoi)
+			imp.deleteRoi();
+		else
+			imp.draw();
+		IJ.showStatus(IJ.d2s(((System.currentTimeMillis()-startTime)/1000.0),2)+" seconds");
+	}
+
+	public ImagePlus reslice(ImagePlus imp) {
+		 ImagePlus imp2;
+		 Roi roi = imp.getRoi();
+		 int roiType = roi!=null?roi.getType():0;
+		 Calibration origCal = imp.getCalibration();
+		 boolean globalCalibration = false;
+		 if (nointerpolate) {// temporarily clear spatial calibration
+				globalCalibration = imp.getGlobalCalibration()!=null;
+				imp.setGlobalCalibration(null);
+				Calibration tmpCal = origCal.copy();
+				tmpCal.pixelWidth = 1.0;
+				tmpCal.pixelHeight = 1.0;
+				tmpCal.pixelDepth = 1.0;
+				imp.setCalibration(tmpCal);
+				inputZSpacing = 1.0;
+				if (roiType!=Roi.LINE)
+					outputZSpacing = 1.0;
+		 }
+		double zSpacing = inputZSpacing/imp.getCalibration().pixelWidth;
+		 if (roi==null || roiType==Roi.RECTANGLE || roiType==Roi.LINE) {
+				imp2 = resliceRectOrLine(imp);
+		 } else {// we assert roiType==Roi.POLYLINE || roiType==Roi.FREELINE
+				String status = imp.getStack().isVirtual()?"":null;
+				IJ.showStatus("Reslice...");
+				ImageProcessor ip2 = getSlice(imp, 0.0, 0.0, 0.0, 0.0, status);
+				imp2 = new ImagePlus("Reslice of "+imp.getShortTitle(), ip2);
+		 }
+		 if (nointerpolate) { // restore calibration
+		 		if (globalCalibration)
+					imp.setGlobalCalibration(origCal);
+				imp.setCalibration(origCal);
+		 }
+		 // create Calibration for new stack
+		 // start from previous cal and swap appropriate fields
+		 boolean horizontal = false;
+		 boolean vertical = false;
+		if (roi==null || roiType==Roi.RECTANGLE) {
+			if (startAt.equals(starts[0]) || startAt.equals(starts[2]))
+				horizontal = true;
+			else
+				vertical = true;
+		} 
+		if (roi!=null && roiType==Roi.LINE) {
+			Line l = (Line)roi;
+			horizontal  = (l.y2-l.y1)==0;
+			vertical = (l.x2-l.x1)==0;
+		}
+		if (imp2==null) return null;
+		imp2.setCalibration(imp.getCalibration());
+		Calibration cal = imp2.getCalibration();
+		if (horizontal) {
+			cal.pixelWidth = origCal.pixelWidth;
+			cal.pixelHeight = origCal.pixelDepth/zSpacing;
+			cal.pixelDepth = origCal.pixelHeight*outputZSpacing;
+		} else if (vertical) {
+			cal.pixelWidth = origCal.pixelHeight;
+			cal.pixelHeight = origCal.pixelDepth/zSpacing;
+			//cal.pixelWidth = origCal.pixelDepth/zSpacing;
+			//cal.pixelHeight = origCal.pixelHeight;
+			cal.pixelDepth = origCal.pixelWidth*outputZSpacing;;
+		} else { // oblique line, polyLine or freeline
+				if (origCal.pixelHeight==origCal.pixelWidth) {
+					cal.pixelWidth = origCal.pixelWidth;
+					cal.pixelHeight=origCal.pixelDepth/zSpacing;
+					cal.pixelDepth = origCal.pixelWidth*outputZSpacing;
+				} else {
+					cal.pixelWidth = cal.pixelHeight=cal.pixelDepth=1.0;
+					cal.setUnit("pixel");
+				}
+		 }
+		 double tmp;
+		 if (rotate) {// if rotated flip X and Y
+				tmp = cal.pixelWidth;
+				cal.pixelWidth = cal.pixelHeight;
+				cal.pixelHeight = tmp;
+		 }
+		 return imp2;
+	}
+
+	ImagePlus resliceHyperstack(ImagePlus imp) {
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		if (slices==1)
+			return resliceTimeLapseHyperstack(imp);
+		int c1 = imp.getChannel();
+		int z1 = imp.getSlice();
+		int t1 = imp.getFrame();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		ImagePlus imp2 = null;
+		ImageStack stack2 = null;
+		Roi roi = imp.getRoi();
+		for (int t=1; t<=frames; t++) {
+			for (int c=1; c<=channels; c++) {
+				ImageStack tmp1Stack = new ImageStack(width, height);
+				for (int z=1; z<=slices; z++) {
+					imp.setPositionWithoutUpdate(c, z, t);
+					tmp1Stack.addSlice(null, imp.getProcessor());
+				}
+				ImagePlus tmp1 = new ImagePlus("tmp", tmp1Stack);
+				tmp1.setCalibration(imp.getCalibration());
+				tmp1.setRoi(roi);
+				ImagePlus tmp2 = reslice(tmp1);
+				int slices2 = tmp2.getStackSize();
+				if (imp2==null) {
+					imp2 = tmp2.createHyperStack("Reslice of "+imp.getTitle(), channels, slices2, frames, tmp2.getBitDepth());
+					stack2 = imp2.getStack();
+				}
+				ImageStack tmp2Stack = tmp2.getStack();
+				for (int z=1; z<=slices2; z++) {
+					imp.setPositionWithoutUpdate(c, z, t);
+					int n2 = imp2.getStackIndex(c, z, t);
+					stack2.setPixels(tmp2Stack.getPixels(z), n2);
+				}
+			}
+		}
+		imp.setPosition(c1, z1, t1);
+		if (channels>1 && imp.isComposite()) {
+			imp2 = new CompositeImage(imp2, ((CompositeImage)imp).getMode());
+			((CompositeImage)imp2).copyLuts(imp);
+		}
+		return imp2;
+	}
+
+	ImagePlus resliceTimeLapseHyperstack(ImagePlus imp) {
+		int channels = imp.getNChannels();
+		int frames = imp.getNFrames();
+		int c1 = imp.getChannel();
+		int t1 = imp.getFrame();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		ImagePlus imp2 = null;
+		ImageStack stack2 = null;
+		Roi roi = imp.getRoi();
+		int z = 1;
+		for (int c=1; c<=channels; c++) {
+			ImageStack tmp1Stack = new ImageStack(width, height);
+			for (int t=1; t<=frames; t++) {
+				imp.setPositionWithoutUpdate(c, z, t);
+				tmp1Stack.addSlice(null, imp.getProcessor());
+			}
+			ImagePlus tmp1 = new ImagePlus("tmp", tmp1Stack);
+			tmp1.setCalibration(imp.getCalibration());
+			tmp1.setRoi(roi);
+			ImagePlus tmp2 = reslice(tmp1);
+			int frames2 = tmp2.getStackSize();
+			if (imp2==null) {
+				imp2 = tmp2.createHyperStack("Reslice of "+imp.getTitle(), channels, 1, frames2, tmp2.getBitDepth());
+				stack2 = imp2.getStack();
+			}
+			ImageStack tmp2Stack = tmp2.getStack();
+			for (int t=1; t<=frames2; t++) {
+				imp.setPositionWithoutUpdate(c, z, t);
+				int n2 = imp2.getStackIndex(c, z, t);
+				stack2.setPixels(tmp2Stack.getPixels(z), n2);
+			}
+		}
+		imp.setPosition(c1, 1, t1);
+		if (channels>1 && imp.isComposite()) {
+			imp2 = new CompositeImage(imp2, ((CompositeImage)imp).getMode());
+			((CompositeImage)imp2).copyLuts(imp);
+		}
+		return imp2;
+	}
+
+	boolean showDialog(ImagePlus imp) {
+		Calibration cal = imp.getCalibration();
+		if (cal.pixelDepth<0.0)
+			cal.pixelDepth = -cal.pixelDepth;
+		String units = cal.getUnits();
+		if (cal.pixelWidth==0.0)
+			cal.pixelWidth = 1.0;
+		inputZSpacing = cal.pixelDepth;
+		double outputSpacing = cal.pixelDepth;
+		Roi roi = imp.getRoi();
+		boolean line = roi!=null && roi.getType()==Roi.LINE;
+		if (line) saveLineInfo(roi);
+		String macroOptions = Macro.getOptions();
+		boolean macroRunning = macroOptions!=null;
+		if (macroRunning) {
+			if (macroOptions.indexOf("input=")!=-1)
+				macroOptions = macroOptions.replaceAll("slice=", "slice_count=");
+			macroOptions = macroOptions.replaceAll("slice=", "output=");
+			Macro.setOptions(macroOptions);
+			nointerpolate = false;
+		} else {
+			startAt = startAtS;
+			rotate = rotateS;
+			flip = flipS;
+			sliceCount = sliceCountS;
+		}
+		GenericDialog gd = new GenericDialog("Reslice");
+		gd.addNumericField("Output spacing ("+units+"):", outputSpacing, 3);
+		if (line) {
+			if (!IJ.isMacro()) outputSlices=sliceCount;
+			gd.addNumericField("Slice_count:", outputSlices, 0);
+		} else
+			gd.addChoice("Start at:", starts, startAt);
+		gd.addCheckbox("Flip vertically", flip);
+		gd.addCheckbox("Rotate 90 degrees", rotate);
+		gd.addCheckbox("Avoid interpolation", nointerpolate);
+		gd.setInsets(0, 32, 0);
+		gd.addMessage("(use 1 pixel spacing)");
+		gd.setInsets(15, 0, 0);
+		gd.addMessage("Voxel size: "+d2s(cal.pixelWidth)+"x"+d2s(cal.pixelHeight)
+			+"x"+d2s(cal.pixelDepth)+" "+cal.getUnit());
+		gd.setInsets(5, 0, 0);
+		gd.addMessage("Output size: "+getSize(cal.pixelDepth,outputSpacing,outputSlices)+"				");
+		fields = gd.getNumericFields();
+		if (!macroRunning) {
+			for (int i=0; i<fields.size(); i++)
+				((TextField)fields.elementAt(i)).addTextListener(this);
+		}
+		checkboxes = gd.getCheckboxes();
+		if (!macroRunning)
+			((Checkbox)checkboxes.elementAt(2)).addItemListener(this);
+		message = (Label)gd.getMessage();
+		gd.addHelp(IJ.URL+"/docs/menus/image.html#reslice");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		outputZSpacing = gd.getNextNumber()/cal.pixelWidth;
+		if (line) {
+			outputSlices = (int)gd.getNextNumber();
+			if (!IJ.isMacro()) sliceCount=outputSlices;
+			imp.setRoi(roi);
+		} else
+			startAt = gd.getNextChoice();
+		flip = gd.getNextBoolean();
+		rotate = gd.getNextBoolean();
+		nointerpolate = gd.getNextBoolean();
+		if (!macroRunning) {
+			Prefs.avoidResliceInterpolation = nointerpolate;
+			startAtS = startAt;
+			rotateS = rotate;
+			flipS = flip;
+			sliceCountS = sliceCount;
+		}
+		return true;
+	}
+	
+	String d2s(double n) {
+		String s;
+		if (n==(int)n)
+			s = ResultsTable.d2s(n, 0);
+		else
+			s = ResultsTable.d2s(n, 2);
+		if (s.indexOf(".")!=-1 && s.endsWith("0"))
+			s = s.substring(0, s.length()-1);
+		return s;
+	}
+
+	void saveLineInfo(Roi roi) {
+		 Line line = (Line)roi;
+		 gx1 = line.x1;
+		 gy1 = line.y1;
+		 gx2 = line.x2;
+		 gy2 = line.y2;
+		 gLength = line.getRawLength();
+	}
+
+	ImagePlus resliceRectOrLine(ImagePlus imp) {
+		 double x1 = 0.0;
+		 double y1 = 0.0;
+		 double x2 = 0.0;
+		 double y2 = 0.0;
+		 double xInc = 0.0;
+		 double yInc = 0.0;
+		 noRoi = false;
+
+		 Roi roi = imp.getRoi();
+		 if (roi==null) {
+				noRoi = true;
+				imp.setRoi(0, 0, imp.getWidth(), imp.getHeight());
+				roi = imp.getRoi();
+		 }
+		 if (roi.getType()==Roi.RECTANGLE) {
+				Rectangle r = roi.getBounds();
+				if (startAt.equals(starts[0])) { // top
+					x1 = r.x;
+					y1 = r.y;
+					x2 = r.x + r.width;
+					y2 = r.y;
+					xInc = 0.0;
+					yInc = outputZSpacing;
+					outputSlices =	(int)(r.height/outputZSpacing);
+				} else if (startAt.equals(starts[1])) { // left
+					x1 = r.x;
+					y1 = r.y;
+					x2 = r.x;
+					y2 = r.y + r.height;
+					xInc = outputZSpacing;
+					yInc = 0.0;
+					outputSlices =	(int)(r.width/outputZSpacing);
+				} else if (startAt.equals(starts[2])) { // bottom
+					x1 = r.x;
+					y1 = r.y + r.height-1;
+					x2 = r.x + r.width;
+					y2 = r.y + r.height-1;
+					xInc = 0.0;
+					yInc = -outputZSpacing;
+					outputSlices =	(int)(r.height/outputZSpacing);
+				} else if (startAt.equals(starts[3])) { // right
+					x1 = r.x + r.width-1;
+					y1 = r.y;
+					x2 = r.x + r.width-1;
+					y2 = r.y + r.height;
+					xInc = -outputZSpacing;
+					yInc = 0.0;
+					outputSlices =	(int)(r.width/outputZSpacing);
+				}
+		 } else if (roi.getType()==Roi.LINE) {
+				Line line = (Line)roi;
+				x1 = line.x1;
+				y1 = line.y1;
+				x2 = line.x2;
+				y2 = line.y2;
+				double dx = x2 - x1;
+				double dy = y2 - y1;
+				double nrm = Math.sqrt(dx*dx + dy*dy)/outputZSpacing;
+				xInc = -(dy/nrm);
+				yInc = (dx/nrm);
+		 } else
+				return null;
+
+		 if (outputSlices==0) {
+				IJ.error("Reslicer", "Output Z spacing ("+IJ.d2s(outputZSpacing,0)+" pixels) is too large.\n"
+					+"Is the voxel size in Image>Properties correct?.");
+				return null;
+		 }
+		 boolean virtualStack = imp.getStack().isVirtual();
+		 String status = null;
+		 ImagePlus imp2 = null;
+		 ImageStack stack2 = null;
+		 boolean isStack = imp.getStackSize()>1;
+		 IJ.resetEscape();
+		 boolean macro = IJ.isMacro();
+		 for (int i=0; i<outputSlices; i++)	{
+			if (virtualStack)
+				status = outputSlices>1?(i+1)+"/"+outputSlices+", ":"";
+			ImageProcessor ip = getSlice(imp, x1, y1, x2, y2, status);
+			if (macro)
+				IJ.showProgress(i,outputSlices-1);
+			else
+				drawLine(x1, y1, x2, y2, imp);
+			if (stack2==null) {
+				stack2 = createOutputStack(imp, ip);
+				if (stack2==null || stack2.getSize()<outputSlices) return null; // out of memory
+			}
+			stack2.setPixels(ip.getPixels(), i+1);
+			x1+=xInc; x2+=xInc; y1+=yInc; y2+=yInc;
+			if (IJ.escapePressed()) {
+				IJ.beep();
+				imp.draw();
+				IJ.showProgress(1.0);
+				return null;
+			}
+		 }
+		 if (macro) IJ.showProgress(1.0);
+		 return new ImagePlus("Reslice of "+imp.getShortTitle(), stack2);
+	}
+
+	ImageStack createOutputStack(ImagePlus imp, ImageProcessor ip) {
+		 int bitDepth = imp.getBitDepth();
+		 int w2=ip.getWidth(), h2=ip.getHeight(), d2=outputSlices;
+		 int flags = NewImage.FILL_BLACK + NewImage.CHECK_AVAILABLE_MEMORY;
+		 ImagePlus imp2 = NewImage.createImage("temp", w2, h2, d2, bitDepth, flags);
+		 if (imp2!=null && imp2.getStackSize()==d2)
+				IJ.showStatus("Reslice... (press 'Esc' to abort)");
+		 if (imp2==null)
+				return null;
+		 else {
+				ImageStack stack2 = imp2.getStack();
+				stack2.setColorModel(ip.getColorModel());
+				return stack2;
+		 }
+	}
+
+	ImageProcessor getSlice(ImagePlus imp, double x1, double y1, double x2, double y2, String status) {
+		 Roi roi = imp.getRoi();
+		 int roiType = roi!=null?roi.getType():0;
+		 ImageStack stack = imp.getStack();
+		 int stackSize = stack.size();
+		 ImageProcessor ip,ip2=null;
+		 float[] line = null;
+		 boolean ortho = (int)x1==x1&&(int)y1==y1&&x1==x2||y1==y2;
+		 for (int i=0; i<stackSize; i++) {
+				ip = stack.getProcessor(flip?stackSize-i:i+1);
+				if (roiType==Roi.POLYLINE || roiType==Roi.FREELINE)
+					line = getIrregularProfile(roi, ip);
+				else if (ortho)
+					line = getOrthoLine(ip, (int)x1, (int)y1, (int)x2, (int)y2, line);
+				else
+					line = getLine(ip, x1, y1, x2, y2, line);
+				if (rotate) {
+					if (i==0) ip2 = ip.createProcessor(stackSize, line.length);
+					putColumn(ip2, i, 0, line, line.length);
+				} else {
+					if (i==0) ip2 = ip.createProcessor(line.length, stackSize);
+					putRow(ip2, 0, i, line, line.length);
+				}
+				if (status!=null) IJ.showStatus("Slicing: "+status +i+"/"+stackSize);
+		 }
+		 Calibration cal = imp.getCalibration();
+		 double zSpacing = inputZSpacing/cal.pixelWidth;
+		 if (zSpacing!=1.0) {
+				ip2.setInterpolate(true);
+				if (rotate)
+					ip2 = ip2.resize((int)(stackSize*zSpacing), line.length);
+				else
+					ip2 = ip2.resize(line.length, (int)(stackSize*zSpacing));
+		 }
+		 return ip2;
+	}
+
+	public void putRow(ImageProcessor ip, int x, int y, float[] data, int length) {
+		 if (rgb) {
+				for (int i=0; i<length; i++)
+					ip.putPixel(x++, y, Float.floatToIntBits(data[i]));
+		 } else {
+				for (int i=0; i<length; i++)
+					ip.setf(x++, y, data[i]);
+		 }
+	}
+
+	public void putColumn(ImageProcessor ip, int x, int y, float[] data, int length) {
+		 if (rgb) {
+				for (int i=0; i<length; i++)
+					ip.putPixel(x, y++, Float.floatToIntBits(data[i]));
+		 } else {
+				for (int i=0; i<length; i++)
+					ip.setf(x, y++, data[i]);
+		 }
+	}
+
+	float[] getIrregularProfile(Roi roi, ImageProcessor ip) {
+		 if (x==null)
+				doIrregularSetup(roi);
+		 float[] values = new float[(int)length];
+		 double leftOver = 1.0;
+		 double distance = 0.0;
+		 int index;
+		 double oldx=xbase, oldy=ybase;
+		 for (int i=0; i<n; i++) {
+				double len = segmentLengths[i];
+				if (len==0.0)
+					continue;
+				double xinc = dx[i]/len;
+				double yinc = dy[i]/len;
+				double start = 1.0-leftOver;
+				double rx = xbase+x[i]+start*xinc;
+				double ry = ybase+y[i]+start*yinc;
+				double len2 = len - start;
+				int n2 = (int)len2;
+				for (int j=0; j<=n2; j++) {
+					index = (int)distance+j;
+					if (index<values.length) {
+						 if (notFloat)
+								values[index] = (float)ip.getInterpolatedPixel(rx, ry);
+						 else if (rgb) {
+								int rgbPixel = ((ColorProcessor)ip).getInterpolatedRGBPixel(rx, ry);
+								values[index] = Float.intBitsToFloat(rgbPixel&0xffffff);
+						 } else
+								values[index] = (float)ip.getInterpolatedValue(rx, ry);
+					}
+					rx += xinc;
+					ry += yinc;
+				}
+				distance += len;
+				leftOver = len2 - n2;
+		 }
+
+		 return values;
+
+	}
+
+	void doIrregularSetup(Roi roi) {
+		 n = ((PolygonRoi)roi).getNCoordinates();
+		 int[] ix = ((PolygonRoi)roi).getXCoordinates();
+		 int[] iy = ((PolygonRoi)roi).getYCoordinates();
+		 x = new double[n];
+		 y = new double[n];
+		 for (int i=0; i<n; i++) {
+				x[i] = ix[i];
+				y[i] = iy[i];
+		 }
+		 if (roi.getType()==Roi.FREELINE) {
+				// smooth line
+				for (int i=1; i<n-1; i++) {
+					x[i] = (x[i-1] + x[i] + x[i+1])/3.0+0.5;
+					y[i] = (y[i-1] + y[i] + y[i+1])/3.0+0.5;
+				}
+		 }
+		 Rectangle r = roi.getBounds();
+		 xbase = r.x;
+		 ybase = r.y;
+		 length = 0.0;
+		 double segmentLength;
+		 double xdelta, ydelta;
+		 segmentLengths = new double[n];
+		 dx = new double[n];
+		 dy = new double[n];
+		 for (int i=0; i<(n-1); i++) {
+				xdelta = x[i+1] - x[i];
+				ydelta = y[i+1] - y[i];
+				segmentLength = Math.sqrt(xdelta*xdelta+ydelta*ydelta);
+				length += segmentLength;
+				segmentLengths[i] = segmentLength;
+				dx[i] = xdelta;
+				dy[i] = ydelta;
+		 }
+	}
+
+	private float[] getLine(ImageProcessor ip, double x1, double y1, double x2, double y2, float[] data) {
+		 double dx = x2-x1;
+		 double dy = y2-y1;
+		 int n = (int)Math.round(Math.sqrt(dx*dx + dy*dy));
+		 if (data==null)
+				data = new float[n];
+		 double xinc = dx/n;
+		 double yinc = dy/n;
+		 double rx = x1;
+		 double ry = y1;
+		 for (int i=0; i<n; i++) {
+		 		if (notFloat)
+					data[i] = (float)ip.getInterpolatedPixel(rx, ry);
+				else if (rgb) {
+					int rgbPixel = ((ColorProcessor)ip).getInterpolatedRGBPixel(rx, ry);
+					data[i] = Float.intBitsToFloat(rgbPixel&0xffffff);
+				} else
+					data[i] = (float)ip.getInterpolatedValue(rx, ry);
+				rx += xinc;
+				ry += yinc;
+		 }
+		 return data;
+	}
+	
+	private float[] getOrthoLine(ImageProcessor ip, int x1, int y1, int x2, int y2, float[] data) {
+		int dx = x2-x1;
+		int dy = y2-y1;
+		int n = Math.max(Math.abs(dx), Math.abs(dy));
+		if (data==null)
+			data = new float[n];
+		int xinc = dx/n;
+		int yinc = dy/n;
+		for (int i=0; i<n; i++) {
+			if (rgb) {
+				int rgbPixel = ((ColorProcessor)ip).getPixel(x1, y1);
+				data[i] = Float.intBitsToFloat(rgbPixel&0xffffff);
+			} else
+				data[i] = ip.getf(x1,y1);
+			x1 += xinc;
+			y1 += yinc;
+		}
+		return data;
+	}
+
+	void drawLine(double x1, double y1, double x2, double y2, ImagePlus imp) {
+		 ImageCanvas ic = imp.getCanvas();
+		 if (ic==null)
+		 	return;
+		 Graphics g = ic.getGraphics();
+		 ((Graphics2D)g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,  RenderingHints.VALUE_ANTIALIAS_ON);
+		 g.setColor(lineColor);
+		 g.drawLine(ic.screenX((int)(x1+0.5)), ic.screenY((int)(y1+0.5)), ic.screenX((int)(x2+0.5)), ic.screenY((int)(y2+0.5)));
+	}
+
+	public void textValueChanged(TextEvent e) {
+		updateSize();
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		if (IJ.isMacOSX()) IJ.wait(100);
+		Checkbox cb = (Checkbox)checkboxes.elementAt(2);
+        nointerpolate = cb.getState();
+        updateSize();
+	}
+
+	void updateSize() {
+		 //double inSpacing = Tools.parseDouble(((TextField)fields.elementAt(0)).getText(),0.0);
+		 double outSpacing = Tools.parseDouble(((TextField)fields.elementAt(0)).getText(),0.0);
+		 int count = 0;
+		 boolean lineSelection = fields.size()==2;
+		 if (lineSelection) {
+				count = (int)Tools.parseDouble(((TextField)fields.elementAt(1)).getText(), 0.0);
+				if (count>0) makePolygon(count, outSpacing);
+		 }
+		 String size = getSize(inputZSpacing, outSpacing, count);
+		 message.setText("Output Size: "+size);
+	}
+
+	String getSize(double inSpacing, double outSpacing, int count) {
+		 int size = getOutputStackSize(inSpacing, outSpacing, count);
+		 int mem = getAvailableMemory();
+		 String available = mem!=-1?" ("+mem+"MB free)":"";
+		 if (message!=null)
+				message.setForeground(mem!=-1&&size>mem?Color.red:Color.black);
+		 if (size>0)
+				return size+"MB"+available;
+		 else
+				return "<1MB"+available;
+	}
+
+	void makePolygon(int count, double outSpacing) {
+		int[] x = new int[4];
+		int[] y = new int[4];
+		Calibration cal = imp.getCalibration();
+		double cx = cal.pixelWidth;	//corrects preview for x calibration
+		double cy = cal.pixelHeight;	//corrects preview for y calibration
+		x[0] = (int)gx1;
+		y[0] = (int)gy1;
+		x[1] = (int)gx2;
+		y[1] = (int)gy2;
+		double dx = gx2 - gx1;
+		double dy = gy2 - gy1;
+		double nrm = Math.sqrt(dx*dx + dy*dy)/outSpacing;
+		double xInc = -(dy/(cx*nrm));	//cx scales the x increment
+		double yInc = (dx/(cy*nrm));	//cy scales the y increment
+		x[2] = x[1] + (int)(xInc*count);
+		y[2] = y[1] + (int)(yInc*count);
+		x[3] = x[0] + (int)(xInc*count);
+		y[3] = y[0] + (int)(yInc*count);
+		imp.setRoi(new PolygonRoi(x, y, 4, PolygonRoi.FREEROI));
+	}
+
+	int getOutputStackSize(double inSpacing, double outSpacing, int count) {
+		Roi roi = imp.getRoi();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		if (roi!=null) {
+			Rectangle r = roi.getBounds();
+			width = r.width;
+			width = r.height;
+		}
+		int type = roi!=null?roi.getType():0;
+		int stackSize = imp.getStackSize();
+		double size = 0.0;
+		if (type==Roi.RECTANGLE) {
+			size = width*height*stackSize;
+			if (outSpacing>0&&!nointerpolate) size *= inSpacing/outSpacing;
+		} else
+			size = gLength*count*stackSize;
+		int bits = imp.getBitDepth();
+		switch (bits) {
+			case 16: size*=2; break;
+			case 24: case 32: size*=4; break;
+		}
+		return (int)Math.round(size/1048576.0);
+	}
+
+	int getAvailableMemory() {
+		 long max = IJ.maxMemory();
+		 if (max==0) return -1;
+		 long inUse = IJ.currentMemory();
+		 long available = max - inUse;
+		 return (int)((available+524288L)/1048576L);
+	}
+}
diff --git a/src/ij/plugin/SpecifyROI.java b/src/ij/plugin/SpecifyROI.java
new file mode 100644
index 0000000..4dcf0ba
--- /dev/null
+++ b/src/ij/plugin/SpecifyROI.java
@@ -0,0 +1,227 @@
+package ij.plugin;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.util.Tools;
+import ij.measure.Calibration;
+
+/**
+ *		This plugin implements the Edit/Selection/Specify command.<p>
+
+ *		New update, correctly handling existing oval ROIs, the case that 
+ *		"Centered" is already selected when the plugin starts, and always 
+ *		restoring the original ROI when the dialog is cancelled (JW, 2008/02/22)
+ *
+ *		Enhancing the original plugin created by Jeffrey Kuhn, this one takes,
+ *		in addition to width and height and the option to have an oval ROI from 
+ *		the original program, x & y coordinates, slice number, and the option to have
+ *		the x & y coordinates centered or in default top left corner of ROI.
+ *		The original creator is Jeffrey Kuhn, The University of Texas at Austin,
+ *		jkuhn@ccwf.cc.utexas.edu
+ *
+ *		@author Joachim Wesner
+ *		@author Anthony Padua
+ *		
+ */
+public class SpecifyROI implements PlugIn, DialogListener {
+	private static double width, height, xRoi, yRoi;
+	private static boolean oval;
+	private static boolean square;
+	private static boolean centered;
+	private static boolean scaledUnits;
+	private final static int WIDTH = 0, HEIGHT = 1, X_ROI = 2, Y_ROI = 3;	//sequence of NumericFields
+	private final static int OVAL = 0, SQUARE = 1, CENTERED = 2, SCALED_UNITS = 3; //sequence of Checkboxes
+	private static Rectangle prevRoi;
+	private static double prevPixelWidth = 1.0;
+	private int iSlice;
+	private boolean bAbort;
+	private ImagePlus imp;
+	private Vector fields, checkboxes;
+	private int stackSize;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		if (imp == null) return;
+		if (!imp.okToDeleteRoi())
+			return;
+		stackSize = imp.getStackSize();
+		Roi roi = imp.getRoi();
+		Calibration cal = imp.getCalibration();
+		if (roi!=null && roi.getBounds().equals(prevRoi) && cal.pixelWidth==prevPixelWidth)
+			roi = null;
+		if (roi!=null) {
+			boolean rectOrOval = roi!=null && (roi.getType()==Roi.RECTANGLE||roi.getType()==Roi.OVAL);
+			oval = rectOrOval && (roi.getType()==Roi.OVAL); // Handle existing oval ROI
+			Rectangle r = roi.getBounds();
+			width = r.width;
+			height = r.height;
+			xRoi = r.x;
+			yRoi = r.y;
+			if (scaledUnits && cal.scaled()) {
+				xRoi = xRoi*cal.pixelWidth;
+				yRoi = yRoi*cal.pixelHeight;
+				width = width*cal.pixelWidth;
+				height = height*cal.pixelHeight;
+			}
+			if (centered) { // Make xRoi and yRoi consistent when centered mode is active
+				xRoi += width/2.0;
+				yRoi += height/2.0; 
+			}
+		} else if (!validDialogValues()) {
+			width = imp.getWidth()/2;
+			height = imp.getHeight()/2;
+			xRoi = width/2;
+			yRoi = height/2;
+		}
+		iSlice = imp.getCurrentSlice();
+		showDialog();
+	}
+	
+	boolean validDialogValues() {
+		Calibration cal = imp.getCalibration();
+		double pw=cal.pixelWidth, ph=cal.pixelHeight;
+		if (width/pw<1 || height/ph<1)
+			return false;
+		if (xRoi/pw>imp.getWidth() || yRoi/ph>imp.getHeight())
+			return false;
+		return true;
+	}
+
+	/**
+	 *	Creates a dialog box, allowing the user to enter the requested
+	 *	width, height, x & y coordinates, slice number for a Region Of Interest,
+	 *	option for oval, and option for whether x & y coordinates to be centered.
+	 */
+	void showDialog() {
+		Calibration cal = imp.getCalibration();
+		int digits = 0;
+		if (scaledUnits && cal.scaled())
+			digits = 2;
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			drawRoi();
+		GenericDialog gd = new GenericDialog("Specify");
+		gd.addNumericField("Width:", width, digits);
+		gd.addNumericField("Height:", height, digits);
+		gd.addNumericField("X coordinate:", xRoi, digits);
+		gd.addNumericField("Y coordinate:", yRoi, digits);
+		if (stackSize>1)
+			gd.addNumericField("Slice:", iSlice, 0);
+		gd.addCheckbox("Oval", oval);
+		gd.addCheckbox("Constrain square/circle", square);
+		gd.addCheckbox("Centered",centered);
+		if (cal.scaled()) {
+			boolean unitsMatch = cal.getXUnit().equals(cal.getYUnit());
+			String units = unitsMatch ? cal.getUnits() : cal.getXUnit()+" x "+cal.getYUnit();
+			gd.addCheckbox("Scaled units ("+units+")", scaledUnits);
+		}
+		fields = gd.getNumericFields();
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			 if (roi==null)
+				imp.deleteRoi();
+			 else // *ALWAYS* restore initial ROI when cancelled
+				imp.setRoi(roi);
+		}
+	}
+	
+	void drawRoi() {
+		double xPxl = xRoi;
+		double yPxl = yRoi;
+		if (centered) {
+			xPxl -= width/2;
+			yPxl -= height/2;
+		}
+		double widthPxl = width;
+		double heightPxl = height;
+		Calibration cal = imp.getCalibration();
+		if (scaledUnits && cal.scaled()) {
+			xPxl /= cal.pixelWidth;
+			yPxl /= cal.pixelHeight;
+			widthPxl /= cal.pixelWidth;
+			heightPxl /= cal.pixelHeight;
+			prevPixelWidth = cal.pixelWidth;
+		}
+		Roi roi;
+		if (oval)
+			roi = new OvalRoi(xPxl, yPxl, widthPxl, heightPxl);
+		else
+			roi = new Roi(xPxl, yPxl, widthPxl, heightPxl);
+		imp.setRoi(roi);
+		prevRoi = roi.getBounds();
+		//prevPixelWidth = cal.pixelWidth;
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (IJ.isMacOSX()) IJ.wait(50);
+		Calibration cal = imp.getCalibration();
+		width = gd.getNextNumber();
+		height = gd.getNextNumber();
+		xRoi = gd.getNextNumber();	
+		yRoi = gd.getNextNumber();
+		if (stackSize>1)	
+			iSlice = (int) gd.getNextNumber(); 
+		oval = gd.getNextBoolean();
+		square = gd.getNextBoolean();
+		centered = gd.getNextBoolean();
+		if (cal.scaled())
+			scaledUnits = gd.getNextBoolean();
+		if (gd.invalidNumber() || width<=0 || height<=0)
+			return false;
+		//
+		Vector numFields = gd.getNumericFields();
+		Vector checkboxes = gd.getCheckboxes();
+		boolean newWidth = false, newHeight = false, newXY = false;
+		if (e!=null && e.getSource()==checkboxes.get(SQUARE) && square) {
+			width = 0.5*(width+height);				//make square: same width&height
+			height = width;
+			newWidth = true;
+			newHeight = true;
+		}
+		if (e!=null && e.getSource()==checkboxes.get(CENTERED)) {
+			double shiftBy = centered ? 0.5 : -0.5; //'centered' changed:
+			xRoi += shiftBy * width;				//shift x, y to keep roi the same
+			yRoi += shiftBy * height;
+			newXY = true;
+		}
+		if (square && width!=height && e!=null) {	//in 'square' mode, synchronize width&height
+			if (e.getSource()==numFields.get(WIDTH)) {
+				height = width;
+				newHeight = true;
+			} else if (e.getSource()==numFields.get(HEIGHT)) {
+				width = height;
+				newWidth = true;
+			}
+		}
+		if (e!=null && cal.scaled() && e.getSource()==checkboxes.get(SCALED_UNITS)) {
+			double xFactor = scaledUnits ? cal.pixelWidth : 1./cal.pixelWidth;
+			double yFactor = scaledUnits ? cal.pixelHeight : 1./cal.pixelHeight;
+			width *= xFactor;				 //transform everything to keep roi the same
+			height *= yFactor;
+			xRoi *= xFactor;
+			yRoi *= yFactor;
+			newWidth = true; newHeight = true; newXY = true;
+		}
+		int digits = (scaledUnits || (int)width!=width) ? 2 : 0;
+		if (newWidth)
+			((TextField)(numFields.get(WIDTH))).setText(IJ.d2s(width, digits));
+		if (newHeight)
+			((TextField)(numFields.get(HEIGHT))).setText(IJ.d2s(height, digits));
+		digits = (scaledUnits || (int)xRoi!=xRoi || (int)yRoi!=yRoi) ? 2 : 0;
+		if (newXY) {
+			((TextField)(numFields.get(X_ROI))).setText(IJ.d2s(xRoi, digits));
+			((TextField)(numFields.get(Y_ROI))).setText(IJ.d2s(yRoi, digits));
+		}
+
+		if (stackSize>1 && iSlice>0 && iSlice<=stackSize)
+			imp.setSlice(iSlice);
+		if (!newWidth && !newHeight	 && !newXY)	   // don't draw if an update will come immediately
+			drawRoi();
+		return true;
+	}
+
+}
diff --git a/src/ij/plugin/StackCombiner.java b/src/ij/plugin/StackCombiner.java
new file mode 100644
index 0000000..ad09c7f
--- /dev/null
+++ b/src/ij/plugin/StackCombiner.java
@@ -0,0 +1,159 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+
+/**
+	This plugin implements the Image/Stacks/Combine command.
+	It combines two stacks (w1xh1xd1 and w2xh2xd2) to create a new
+	w1+w2 x max(h1,h2) x max(d1,d2) stack. For example, a 256x256x40
+	and a 256x256x30 stack would be combined into one 512x256x40 stack.
+	If "Vertical" is checked, create a new max(w1+w2) x (h1+h2) x max(d1,d2) stack.
+	Unused areas in the combined stack are filled with the background color.
+*/
+public class StackCombiner implements PlugIn {
+		ImagePlus imp1;
+		ImagePlus imp2;
+		static boolean vertical;
+
+	public void run(String arg) {
+		if (!showDialog())
+			return;
+		if (imp1.getBitDepth()!=imp2.getBitDepth()) {
+			error();
+			return;
+		}
+		int[] dim1 = imp1.getDimensions();
+		int[] dim2 = imp2.getDimensions();
+		if (imp1.isHyperStack() || imp2.isHyperStack()) {
+			if (dim1[2]!=dim2[2] || dim1[3]!=dim2[3] || dim1[4]!=dim2[4]) {
+				IJ.error("StackCombiner", "Hyperstacks must have identical CZT dimensions");	
+				return;
+			}
+		}
+		ImageStack stack1 = imp1.getStack();
+		ImageStack stack2 = imp2.getStack();
+		ImageStack stack3 = vertical?combineVertically(stack1, stack2):combineHorizontally(stack1, stack2);
+		imp1.changes = false;
+		imp1.close();
+		imp2.changes = false;
+		imp2.close();
+		ImagePlus imp3 = imp1.createImagePlus();
+		imp3.setStack(stack3);
+		if (imp1.isHyperStack())
+			imp3.setDimensions(dim1[2],dim1[3],dim1[4]);
+		if (imp1.isComposite()) {
+			imp3 = new CompositeImage(imp3, imp1.getCompositeMode());
+			imp3.setDimensions(dim1[2],dim1[3],dim1[4]);
+		}
+		imp3.setTitle("Combined Stacks");
+		imp3.show();
+	}
+	
+	public ImageStack combineHorizontally(ImageStack stack1, ImageStack stack2) {
+		int d1 = stack1.getSize();
+		int d2 = stack2.getSize();
+		int d3 = Math.max(d1, d2);
+		int w1 = stack1.getWidth();
+		int h1 = stack1.getHeight();
+ 		int w2 = stack2.getWidth();
+		int h2 = stack2.getHeight();
+		int w3 = w1 + w2;
+		int h3 = Math.max(h1, h2);
+		ImageStack stack3 = new ImageStack(w3, h3, stack1.getColorModel());
+		ImageProcessor ip = stack1.getProcessor(1);
+		ImageProcessor ip1, ip2, ip3;
+		Color background = Toolbar.getBackgroundColor();
+ 		for (int i=1; i<=d3; i++) {
+ 			IJ.showProgress((double)i/d3);
+ 			ip3 = ip.createProcessor(w3, h3);
+ 			if (h1!=h2) {
+ 				ip3.setColor(background);
+ 				ip3.fill();
+ 			}
+ 			if  (i<=d1) {
+				ip3.insert(stack1.getProcessor(1),0,0);
+				if (stack2!=stack1)
+					stack1.deleteSlice(1);
+			}
+			if  (i<=d2) {
+				ip3.insert(stack2.getProcessor(1),w1,0);
+				stack2.deleteSlice(1);
+			}
+			stack3.addSlice(null, ip3);
+		}
+		return stack3;
+	}
+	
+	public ImageStack combineVertically(ImageStack stack1, ImageStack stack2) {
+		int d1 = stack1.getSize();
+		int d2 = stack2.getSize();
+		int d3 = Math.max(d1, d2);
+		int w1 = stack1.getWidth();
+		int h1 = stack1.getHeight();
+ 		int w2 = stack2.getWidth();
+		int h2 = stack2.getHeight();
+		int w3 = Math.max(w1, w2);
+		int h3 = h1 + h2;
+		ImageStack stack3 = new ImageStack(w3, h3, stack1.getColorModel());
+		ImageProcessor ip = stack1.getProcessor(1);
+		ImageProcessor ip1, ip2, ip3;
+ 		Color background = Toolbar.getBackgroundColor();
+ 		for (int i=1; i<=d3; i++) {
+ 			IJ.showProgress((double)i/d3);
+ 			ip3 = ip.createProcessor(w3, h3);
+			if (w1!=w2) {
+ 				ip3.setColor(background);
+ 				ip3.fill();
+			}
+			if  (i<=d1) {
+				ip3.insert(stack1.getProcessor(1),0,0);
+				if (stack2!=stack1)
+					stack1.deleteSlice(1);
+			}
+			if  (i<=d2) {
+				ip3.insert(stack2.getProcessor(1),0,h1);
+				stack2.deleteSlice(1);
+			}
+		stack3.addSlice(null, ip3);
+		}
+		return stack3;
+	}
+
+	boolean showDialog() {
+		int[] wList = WindowManager.getIDList();
+		if (wList==null || wList.length<2) {
+			error();
+			return false;
+		}
+		String[] titles = new String[wList.length];
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp = WindowManager.getImage(wList[i]);
+			titles[i] = imp!=null?imp.getTitle():"";
+		}
+		GenericDialog gd = new GenericDialog("Combiner");
+		gd.addChoice("Stack1:", titles, titles[0]);
+		gd.addChoice("Stack2:", titles, titles[1]);
+		gd.addCheckbox("Combine vertically", false);
+        gd.addHelp(IJ.URL+"/docs/menus/image.html#combine");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		int[] index = new int[3];
+		int index1 = gd.getNextChoiceIndex();
+		int index2 = gd.getNextChoiceIndex();
+		imp1 = WindowManager.getImage(wList[index1]);
+		imp2 = WindowManager.getImage(wList[index2]);
+		vertical = gd.getNextBoolean();
+		return true;
+	}
+
+	
+	void error() {
+		IJ.error("StackCombiner", "This command requires two stacks\n"
+			+"that are the same data type.");
+	}
+
+}
+
diff --git a/src/ij/plugin/StackEditor.java b/src/ij/plugin/StackEditor.java
new file mode 100644
index 0000000..e23f683
--- /dev/null
+++ b/src/ij/plugin/StackEditor.java
@@ -0,0 +1,331 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import ij.macro.Interpreter;
+import ij.io.FileInfo;
+import java.awt.*;
+import java.util.ArrayList;
+
+/** Implements the AddSlice, DeleteSlice and "Stack to Images" commands. */
+public class StackEditor implements PlugIn {
+	ImagePlus imp;
+	int nSlices, width, height;
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+    	nSlices = imp.getStackSize();
+    	width = imp.getWidth();
+    	height = imp.getHeight();
+    	
+    	if (arg.equals("add"))
+    		addSlice();
+    	else if (arg.equals("delete"))
+    		deleteSlice();
+    	else if (arg.equals("toimages"))
+    		convertStackToImages(imp);
+	}
+
+	void addSlice() {
+		if (imp.isHyperStack() || imp.isComposite()) {
+			addHyperstackChannelSliceOrFrame();
+			return;
+		}
+ 		if (!imp.lock()) return;
+		int id = 0;
+		ImageStack stack = imp.getStack();
+		if (stack.size()==1)
+			id = imp.getID();
+		ImageProcessor ip = imp.getProcessor();
+		int n = imp.getCurrentSlice();
+		if (IJ.altKeyDown()) n--; // insert in front of current slice
+		stack.addSlice(null, ip.createProcessor(width, height), n);
+		imp.setStack(null, stack);
+		imp.setSlice(n+1);
+		imp.unlock();
+		imp.changes = true;
+		if (id!=0) IJ.selectWindow(id); // prevents macros from failing
+	}
+	
+	void deleteSlice() {
+		if (nSlices<2)
+			{IJ.error("\"Delete Slice\" requires a stack"); return;}
+		if (imp.isHyperStack() || (imp.isComposite() && nSlices==imp.getNChannels())) {
+			deleteHyperstackChannelSliceOrFrame();
+			return;
+		}
+		if (!imp.lock()) return;
+		ImageStack stack = imp.getStack();
+		int n = imp.getCurrentSlice();
+ 		stack.deleteSlice(n);
+ 		if (stack.size()==1) {
+			String label = stack.getSliceLabel(1);
+ 			if (label!=null) imp.setProp("Slice_Label", label);
+ 		}
+		imp.setStack(null, stack);
+ 		if (n--<1) n = 1;
+		imp.setSlice(n);
+		imp.unlock();
+		imp.changes = true;
+	}
+
+	void addHyperstackChannelSliceOrFrame() {
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int c1 = imp.getChannel();
+		int z1 = imp.getSlice();
+		int t1 = imp.getFrame();
+		String[] choices = {"channel", "slice", "frame"};
+		String choice = choices[0];
+		if (frames>1 && slices==1)
+			choice = "frame";
+		else if (slices>1)
+			choice = "slice";
+		GenericDialog gd = new GenericDialog("Add");
+		gd.addChoice("Add", choices, choice);
+		gd.addCheckbox("Prepend", false);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		choice = gd.getNextChoice();
+		boolean prepend = gd.getNextBoolean();
+		if (!imp.lock())
+			return;
+		ImageStack stack = imp.getStack();
+		LUT[] luts = null;
+		if (choice.equals("frame")) { // add time point
+			int index = imp.getStackIndex(channels, slices, t1);
+			if (prepend)
+				index = 0;
+			for (int i=0; i<channels*slices; i++) {
+				ImageProcessor ip = stack.getProcessor(1).duplicate();
+				ip.setColor(0); ip.fill();
+				stack.addSlice(null, ip, index);
+			}
+			frames++;
+		} else if (choice.equals("slice")) { // add slice to all volumes
+			for (int t=frames; t>=1; t--) {
+				int index = imp.getStackIndex(channels, z1, t);
+				if (prepend)
+					index = (t-1)*channels*slices;
+				for (int i=0; i<channels; i++) {
+					ImageProcessor ip = stack.getProcessor(1).duplicate();
+					ip.setColor(0); ip.fill();
+					stack.addSlice(null, ip, index);
+				}
+			}
+			slices++;
+		} else if (choice.equals("channel")) { // add channel
+			if (imp.isComposite())
+				luts = ((CompositeImage)imp).getLuts();
+			int index = imp.getStackIndex(c1, slices, frames);
+			int minIndex = 1;
+			if (prepend) {
+				index = channels*slices*frames - channels;
+				minIndex = 0;
+				c1 = 0;
+			}
+			while (index>=minIndex) {
+				ImageProcessor ip = stack.getProcessor(1).duplicate();
+				ip.setColor(0); ip.fill();
+				stack.addSlice(null, ip, index);
+				index -= channels;
+			}
+			channels++;
+		}
+		imp.setStack(stack, channels, slices, frames);
+		if (luts!=null) {
+			LUT[] luts2 = new LUT[luts.length+1];
+			int index = 0;
+			for (int i=0; i<luts2.length; i++) {
+				if (i==c1)
+					luts2[i] = LUT.createLutFromColor(Color.white);
+				else 
+					luts2[i] = luts[index++];
+			}
+			CompositeImage cimp = (CompositeImage)imp;
+			for (int c=1; c<=channels; c++)
+				cimp.setChannelLut(luts2[c-1], c);
+			imp.updateAndDraw();
+		}
+		imp.unlock();
+		imp.repaintWindow();
+		if (prepend) {
+			imp.setPosition(channels, slices, frames);
+			imp.setPosition(1, 1, 1);
+		}
+		imp.changes = true;
+	}
+	
+	void deleteHyperstackChannelSliceOrFrame() {
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int c1 = imp.getChannel();
+		int z1 = imp.getSlice();
+		int t1 = imp.getFrame();
+		ArrayList list = new ArrayList();
+		if (channels>1) list.add("channel");
+		if (slices>1) list.add("slice");
+		if (frames>1) list.add("frame");
+		String[] choices = new String[list.size()];
+		list.toArray(choices);
+		String choice = choices[0];
+		if (frames>1 && slices==1)
+			choice = "frame";
+		else if (slices>1)
+			choice = "slice";
+    	String options = Macro.getOptions();
+		if (IJ.isMacro() && options!=null && !options.contains("delete=")) {
+			if (options.contains("delete"))
+    			Macro.setOptions("delete=frame");
+    		else
+    			Macro.setOptions("delete=slice");
+    	}
+		if (IJ.isMacro() && options==null && (imp.isComposite() && imp.getStackSize()==imp.getNChannels()))
+			Macro.setOptions("delete=channel");
+		GenericDialog gd = new GenericDialog("Delete");
+		gd.addChoice("Delete current", choices, choice);
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		choice = gd.getNextChoice();
+		if (!imp.lock()) return;
+		ImageStack stack = imp.getStack();
+		LUT[] luts = null;
+		if (choice.equals("frame")) { // delete time point
+			for (int z=slices; z>=1; z--) {
+				int index = imp.getStackIndex(channels, z, t1);
+				for (int i=0; i<channels; i++)
+					stack.deleteSlice(index-i);
+			}
+			frames--;
+		} else if (choice.equals("slice")) { // delete slice z1 from all volumes
+			for (int t=frames; t>=1; t--) {
+				int index = imp.getStackIndex(channels, z1, t);
+				for (int i=0; i<channels; i++)
+					stack.deleteSlice(index-i);
+			}
+			slices--;
+		} else if (choice.equals("channel")) { // delete channe c1
+			if (imp.isComposite())
+				luts = ((CompositeImage)imp).getLuts();
+			int index = imp.getStackIndex(c1, slices, frames);
+			while (index>0) {
+				stack.deleteSlice(index);
+				index -= channels;
+			}
+			channels--;
+		}
+		//imp.setDimensions(channels, slices, frames);
+		imp.setStack(stack, channels, slices, frames);
+		if (luts!=null) {
+			for (int i=c1-1; i<luts.length-1; i++)
+				luts[i] = luts[i+1];
+			CompositeImage cimp = (CompositeImage)imp;
+			for (int c=1; c<=channels; c++)
+				cimp.setChannelLut(luts[c-1], c);
+			imp.updateAndDraw();
+		}
+		imp.unlock();
+		imp.repaintWindow();
+		imp.changes = true;
+	}
+
+	public void convertImagesToStack() {
+		(new ImagesToStack()).run("");
+	}
+
+	public void convertStackToImages(ImagePlus imp) {
+		if (nSlices<2) {
+			IJ.wait(500);
+			imp = IJ.getImage();
+			nSlices = imp.getStackSize();
+		}
+		if (nSlices<2) {
+			IJ.error("\"Convert Stack to Images\" requires a stack\n"+imp);
+			return;
+		}
+		if (!imp.lock())
+			return;
+		ImageStack stack = imp.getStack();
+		int size = stack.size();
+		if (size>30 && !IJ.isMacro()) {
+			boolean ok = IJ.showMessageWithCancel("Convert to Images?",
+			"Are you sure you want to convert this\nstack to "
+			+size+" separate windows?");
+			if (!ok) {
+				imp.unlock();
+				return;
+			}
+		}
+		Calibration cal = imp.getCalibration();
+		CompositeImage cimg = imp.isComposite()?(CompositeImage)imp:null;
+		if (imp.getNChannels()!=imp.getStackSize()) cimg = null;
+		Overlay overlay = imp.getOverlay();
+		int lastImageID = 0;
+		for (int i=1; i<=size; i++) {
+			String label = stack.getShortSliceLabel(i);
+			if (label!=null && (label.contains("/") || label.contains("\\") || label.contains(":")))
+				label = null;
+			String title = label!=null&&!label.equals("")?label:getTitle(imp, i);
+			ImageProcessor ip = stack.getProcessor(i);
+			if (cimg!=null) {
+				LUT lut = cimg.getChannelLut(i);
+				if (lut!=null) {
+					ip.setColorModel(lut);
+					ip.setMinAndMax(lut.min, lut.max);
+				}
+			}
+			ImagePlus imp2 = new ImagePlus(title, ip);
+			imp2.setCalibration(cal);
+			String info = stack.getSliceLabel(i);
+			if (info!=null && !info.equals(label))
+				imp2.setProperty("Info", info);
+			imp2.setIJMenuBar(i==size);
+			if (overlay!=null) {
+				Overlay overlay2 = new Overlay();
+				for (int j=0; j<overlay.size(); j++) {
+					Roi roi = overlay.get(j);
+					if (roi.getPosition()==i) {
+						roi.setPosition(0);
+						overlay2.add((Roi)roi.clone());
+					}
+				}
+				if (overlay2.size()>0)
+					imp2.setOverlay(overlay2);
+			}
+			if (i==size)
+				lastImageID = imp2.getID();
+			imp2.show();
+		}
+		imp.changes = false;
+		ImageWindow win = imp.getWindow();
+		if (win!=null)
+			win.close();
+		else if (Interpreter.isBatchMode())
+			Interpreter.removeBatchModeImage(imp);
+		imp.unlock();
+	}
+
+	String getTitle(ImagePlus imp, int n) {
+		String digits = "00000000"+n;
+		return getShortTitle(imp)+"-"+digits.substring(digits.length()-4,digits.length());
+	}
+	
+	/** Returns a shortened version of image name that does not 
+		include spaces or a file name extension. */
+	private String getShortTitle(ImagePlus imp) {
+		String title = imp.getTitle();
+		int index = title.indexOf(' ');
+		if (index>-1)
+			title = title.substring(0, index);
+		index = title.lastIndexOf('.');
+		if (index>0)
+			title = title.substring(0, index);
+		return title;
+    }
+	
+}
+
diff --git a/src/ij/plugin/StackInserter.java b/src/ij/plugin/StackInserter.java
new file mode 100644
index 0000000..f3e9283
--- /dev/null
+++ b/src/ij/plugin/StackInserter.java
@@ -0,0 +1,78 @@
+package ij.plugin;
+import java.awt.*;
+import java.io.*;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+
+/** This plugin, which implements the Image/Stacks/Tools/Insert 
+	command, inserts an image or stack into another image or stack. */
+public class StackInserter implements PlugIn {
+
+	private static int index1;
+	private static int index2;
+	private static int x, y;
+			
+	public void run(String arg) {
+		int[] wList = WindowManager.getIDList();
+		if (wList==null) {
+			IJ.showMessage("Stack Inserter", "No windows are open.");
+			return;
+		}
+		if (wList.length==1) {
+			IJ.showMessage("Stack Inserter", "At least two windows must be open.");
+			return;
+		}
+		String[] titles = new String[wList.length];
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp = WindowManager.getImage(wList[i]);
+			if (imp!=null)
+				titles[i] = imp.getTitle();
+			else
+				titles[i] = "";
+		}
+		if (index1>=titles.length)index1 = 0;
+		if (index2>=titles.length)index2 = 0;
+		GenericDialog gd = new GenericDialog("Stack Inserter");
+		gd.addChoice("Source: ", titles, titles[index1]);
+		gd.addChoice("Destination: ", titles, titles[index2]);
+		gd.addNumericField("X Location: ", 0, 0);
+		gd.addNumericField("Y Location: ", 0, 0);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		index1 = gd.getNextChoiceIndex();
+		index2 = gd.getNextChoiceIndex();
+		x = (int)gd.getNextNumber();
+		y = (int)gd.getNextNumber();
+		String title1 = titles[index1];
+		String title2 = titles[index2];
+		ImagePlus imp1 = WindowManager.getImage(wList[index1]);
+		ImagePlus imp2 = WindowManager.getImage(wList[index2]);
+		if (imp1.getType()!= imp2.getType()) {
+			IJ.showMessage("Stack Inserter", "The source and destination must be the same type.");
+			return;
+		}
+		if (imp1== imp2) {
+			IJ.showMessage("Stack Inserter", "The source and destination must be different.");
+			return;
+		}
+		insert(imp1, imp2, x, y);
+	}
+	
+	public void insert(ImagePlus imp1, ImagePlus imp2, int x, int y) {
+		ImageStack stack1 = imp1.getStack();
+		ImageStack stack2 = imp2.getStack();
+		int size1 = stack1.getSize();
+		int size2 = stack2.getSize();
+		ImageProcessor ip1, ip2;
+		for (int i=1; i<=size2; i++) {
+			ip1 = stack1.getProcessor(i<=size1?i:size1);
+			ip2 = stack2.getProcessor(i);
+			ip2.insert(ip1, x, y);
+			stack2.setPixels(ip2.getPixels(), i);
+		}
+		imp2.setStack(null, stack2);
+	}
+
+}
diff --git a/src/ij/plugin/StackMaker.java b/src/ij/plugin/StackMaker.java
new file mode 100644
index 0000000..808b2c3
--- /dev/null
+++ b/src/ij/plugin/StackMaker.java
@@ -0,0 +1,80 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.*;
+import ij.util.Tools;
+
+/** The plugin implements the Image/Stacks/Tools/Montage to Stack command.
+	It creates a w*h image stack from an wxh image montage.
+	This is the opposite of what the "Make Montage" command does.
+	2010.04.20,TF: Final stack can be cropped to remove border around frames.
+*/
+public class StackMaker implements PlugIn {
+	private int rows;
+	private int columns;
+	private int border;
+
+	public void run(String arg) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			IJ.noImage();
+			return;
+		}
+		if (imp.getStackSize()>1) {
+			IJ.error("This command requires a montage");
+			return;
+		}		
+		String options = Macro.getOptions();
+		if (options!=null) {
+			options = options.replace("images_per_row=", "columns=");
+			options = options.replace("images_per_column=", "rows=");
+		}
+		columns = info("xMontage", imp, 2);
+		rows = info("yMontage", imp, 2);
+		String montageHeight = (String)imp.getProperty("yMontage");
+		if (montageHeight!=null)
+			rows = Integer.parseInt(montageHeight);
+		GenericDialog gd = new GenericDialog("Stack Maker");
+		gd.addNumericField("Columns: ", columns, 0);
+		gd.addNumericField("Rows: ", rows, 0);
+		gd.addNumericField("Border width: ", border, 0);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		columns = (int)gd.getNextNumber();
+		rows = (int)gd.getNextNumber();
+		border = (int)gd.getNextNumber();
+		if (rows==0 || columns==0)
+			return;
+		ImageStack stack = makeStack(imp.getProcessor(), rows, columns, border);
+		new ImagePlus("Stack", stack).show();
+	}
+	
+	private int info(String key, ImagePlus imp, int value) {
+		String svalue = imp.getStringProperty(key);
+		if (svalue!=null)
+			value = Integer.parseInt(svalue);
+		return value;
+	}
+	
+	public ImageStack makeStack(ImageProcessor ip, int rows, int columns, int border) {
+		int stackSize = rows*columns;
+		int width = ip.getWidth()/columns;
+		int height = ip.getHeight()/rows;
+		//IJ.log("makeStack: "+rows+" "+columns+" "+border+" "+width+" "+height);
+		ImageStack stack = new ImageStack(width, height);
+		for (int y=0; y<rows; y++)
+			for (int x=0; x<columns; x++) {
+				ip.setRoi(x*width, y*height, width, height);
+				stack.addSlice(null, ip.crop());
+			}
+		if (border>0) { 
+			int cropwidth = width-border-border/2;
+			int cropheight = height-border-border/2;
+			StackProcessor sp = new StackProcessor(stack,ip); 
+			stack = sp.crop(border, border, cropwidth, cropheight);
+		}
+		return stack;
+	}	 
+}
diff --git a/src/ij/plugin/StackPlotter.java b/src/ij/plugin/StackPlotter.java
new file mode 100644
index 0000000..0cddaf1
--- /dev/null
+++ b/src/ij/plugin/StackPlotter.java
@@ -0,0 +1,93 @@
+/**
+ * This plugin, which implements the Image/Stacks/Plot XY Profile command,
+ * generates a stack of plots with the same vertical scale.
+ * Source image is a stack or hyperstack.
+ * Line or rectangle selection is required.
+ * @author Jerome Parent
+*/
+
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import java.awt.*;
+
+public class StackPlotter implements PlugIn {
+	
+	private int channel = 1;
+	private int slice = 1;
+	private int frame = 1;
+	private int frames = 1;
+	
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		//Check if Roi is defined
+		if (imp.getRoi() == null) {
+			IJ.error("Stack Plotter", "Line or rectangular selection required");
+			return;
+		}
+		//Check if Image is a Stack
+		int dim = imp.getNDimensions();
+		if (dim < 3) {
+			IJ.error("Stack Plotter","This plugin requires a stack");
+			return;
+		}
+		//Get Stack size
+		int length = 0;
+		if (dim==3)
+			length = imp.getImageStackSize();
+		// Plot stack over frames information, improvement will be to select the dimension to plot over
+		boolean plotFrames = true;
+		if (dim>3) {
+			channel = imp.getChannel();
+			slice = imp.getSlice();
+			frame = imp.getFrame();
+			length = frames = imp.getNFrames();
+			if (dim==4 && length==1) {
+				plotFrames = false;
+				length = imp.getNSlices();
+			}
+		} else
+			slice = imp.getCurrentSlice();
+		
+		//Get a profile plot for each frame in the stack
+		//Store min and max value of all Profile across the stack
+		ProfilePlot[] pPlot = new ProfilePlot[length];
+		double ymin = 0;
+		double ymax = 0;
+		for (int i=0; i<length; i++) {
+			if (dim == 3) imp.setPosition(i+1);
+			if (dim > 3) {
+				if (plotFrames)
+					imp.setPosition(channel,slice,i+1);
+				else
+					imp.setPosition(channel,i+1,frame);
+			}
+			pPlot[i] =  new ProfilePlot(imp);
+			if (pPlot[i] == null) return;
+			if (pPlot[i].getMin() < ymin) ymin = pPlot[i].getMin();
+			if (pPlot[i].getMax() > ymax) ymax = pPlot[i].getMax();
+		}
+		//Save current Min and Max values of profile plot
+		double pp_min = ProfilePlot.getFixedMin();
+		double pp_max = ProfilePlot.getFixedMax();
+		//Set same Min Max values for all plots
+		ProfilePlot.setMinAndMax(ymin,ymax);
+		
+		//Make a profile stack
+		Plot plot = pPlot[0].getPlot();
+		Dimension size = plot.getSize();
+		ImageStack stack = new ImageStack(size.width,size.height);
+		for (int i=0; i< length; i++) {
+			plot = pPlot[i].getPlot();
+			stack.addSlice(plot.getProcessor());
+		}
+		ImagePlus output = new ImagePlus("Profile Plots",stack);
+		output.show();
+		output.setSlice(slice);
+		if (dim==3) imp.setPosition(slice);
+		if (dim>3) imp.setPosition(channel,slice,frame);
+		//reset profile plot Min and May
+		ProfilePlot.setMinAndMax(pp_min,pp_max);
+	}
+	
+}
diff --git a/src/ij/plugin/StackReducer.java b/src/ij/plugin/StackReducer.java
new file mode 100644
index 0000000..485828a
--- /dev/null
+++ b/src/ij/plugin/StackReducer.java
@@ -0,0 +1,99 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import java.awt.*;
+
+/** This plugin implements the Image/Stacks/Tools/Reduce command. */
+public class StackReducer implements PlugIn {
+	ImagePlus imp;
+	private static int factor = 2;
+	private boolean hyperstack, reduceSlices;
+
+	public void run(String arg) {
+		imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			{IJ.noImage(); return;}
+		ImageStack stack = imp.getStack();
+		int size = stack.size();
+		if (size==1 || (imp.getNChannels()==size&&imp.isComposite()))
+			{IJ.error("Stack or hyperstack required"); return;}
+		if (!showDialog(stack))
+			return;
+		if (hyperstack)
+			reduceHyperstack(imp, factor, reduceSlices);
+		else
+			reduceStack(imp, factor);
+	}
+
+	public boolean showDialog(ImageStack stack) {
+		hyperstack = imp.isHyperStack();
+		boolean showCheckbox = false;
+		if (hyperstack && imp.getNSlices()>1 && imp.getNFrames()>1)
+			showCheckbox = true;
+		else if (hyperstack && imp.getNSlices()>1)
+			reduceSlices = true;
+		int n = stack.size();
+		GenericDialog gd = new GenericDialog("Reduce Size");
+		gd.addNumericField("Reduction Factor:", factor, 0);
+		if (showCheckbox)
+			gd.addCheckbox("Reduce in Z-Dimension", false);
+		gd.showDialog();
+		if (gd.wasCanceled()) return false;
+		factor = (int) gd.getNextNumber();
+		if (showCheckbox)
+			reduceSlices = gd.getNextBoolean();
+		return true;
+	}
+	
+	public void reduceStack(ImagePlus imp, int factor) {
+		ImageStack stack = imp.getStack();
+		boolean virtual = stack.isVirtual();
+		int n = stack.size();
+		ImageStack stack2 = new ImageStack(stack.getWidth(), stack.getHeight());
+		for (int i=1; i<=n; i+=factor) {
+			if (virtual) IJ.showProgress(i, n);
+			stack2.addSlice(stack.getSliceLabel(i), stack.getProcessor(i));
+		}
+		imp.setStack(null, stack2);
+		if (virtual) {
+			IJ.showProgress(1.0);
+			imp.setTitle(imp.getTitle());
+		}
+		Calibration cal = imp.getCalibration();
+		if (cal.scaled()) cal.pixelDepth *= factor;
+	}
+	
+	public void reduceHyperstack(ImagePlus imp, int factor, boolean reduceSlices) {
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int zfactor = reduceSlices?factor:1;
+		int tfactor = reduceSlices?1:factor;
+		ImageStack stack = imp.getStack();
+		ImageStack stack2 = new ImageStack(imp.getWidth(), imp.getHeight());
+		boolean virtual = stack.isVirtual();
+		int slices2 = slices/zfactor + ((slices%zfactor)!=0?1:0);
+		int frames2 = frames/tfactor + ((frames%tfactor)!=0?1:0);
+		int n = channels*slices2*frames2;
+		int count = 1;
+		for (int t=1; t<=frames; t+=tfactor) {
+			for (int z=1; z<=slices; z+=zfactor) {
+				for (int c=1; c<=channels; c++) {
+					int i = imp.getStackIndex(c, z, t);
+					IJ.showProgress(i, n);
+					ImageProcessor ip = stack.getProcessor(imp.getStackIndex(c, z, t));
+					//IJ.log(count++ +"  "+i+" "+c+" "+z+" "+t);
+					stack2.addSlice(stack.getSliceLabel(i), ip);
+				}
+			}
+		}
+		imp.setStack(stack2, channels, slices2, frames2);
+		Calibration cal = imp.getCalibration();
+		if (cal.scaled()) cal.pixelDepth *= zfactor;
+		if (virtual) imp.setTitle(imp.getTitle());
+		IJ.showProgress(1.0);
+	}
+
+}
diff --git a/src/ij/plugin/StackReverser.java b/src/ij/plugin/StackReverser.java
new file mode 100644
index 0000000..1ee5e44
--- /dev/null
+++ b/src/ij/plugin/StackReverser.java
@@ -0,0 +1,45 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.measure.Calibration;
+
+/** This plugin implements the Image/Transform/Flip Z and
+	Image/Stacks/Tools/Reverse commands. */
+public class StackReverser implements PlugIn {
+	
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		if (imp.getStackSize()==1) {
+			IJ.error("Flip Z", "This command requires a stack");
+			return;
+		}
+		if (imp.isHyperStack()) {
+			IJ.error("Flip Z", "This command does not currently work with hyperstacks.");
+			return;
+		}
+		flipStack(imp);
+	}
+	
+	public void flipStack(ImagePlus imp) {
+		ImageStack stack = imp.getStack();
+		int n = stack.size();
+		if (n==1)
+			return;
+		Calibration cal = imp.getCalibration();
+		double min = cal.getCValue(imp.getDisplayRangeMin());
+		double max = cal.getCValue(imp.getDisplayRangeMax());
+ 		ImageStack stack2 = new ImageStack(imp.getWidth(), imp.getHeight(), n);
+ 		for (int i=1; i<=n; i++) {
+ 			stack2.setPixels(stack.getPixels(i), n-i+1);
+ 			stack2.setSliceLabel(stack.getSliceLabel(i), n-i+1);
+ 		}
+ 		stack2.setColorModel(stack.getColorModel());
+		imp.setStack(stack2);
+		if (imp.isComposite()) {
+			((CompositeImage)imp).reset();
+			imp.updateAndDraw();
+		}
+		IJ.setMinAndMax(imp, min, max);
+	}
+
+}
diff --git a/src/ij/plugin/StackWriter.java b/src/ij/plugin/StackWriter.java
new file mode 100644
index 0000000..a4961de
--- /dev/null
+++ b/src/ij/plugin/StackWriter.java
@@ -0,0 +1,264 @@
+package ij.plugin;
+import java.awt.*;
+import java.io.*;
+import java.text.DecimalFormat;	
+import java.util.*;
+import ij.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import ij.process.*;
+import ij.plugin.frame.Recorder;
+import ij.macro.Interpreter;
+import ij.util.Tools;
+
+/** This plugin, which saves the images in a stack as separate files, 
+	implements the File/Save As/Image Sequence command. */
+public class StackWriter implements PlugIn {
+	private static final String DIR_KEY = "save.sequence.dir";
+	private static String[] choices = {"BMP",  "FITS", "GIF", "JPEG", "PGM", "PNG", "Raw", "Text", "TIFF",  "ZIP"};
+	private static String staticFileType = "TIFF";
+	private String fileType = "TIFF";
+	private int ndigits = 4;
+	private boolean useLabels;
+	private boolean firstTime = true;
+	private int startAt;
+	private boolean hyperstack;
+	private int[] dim;
+	private ImagePlus imp;
+	private String directory;
+	private String format = "tiff";
+	private String name;
+	
+	/** Saves the specified image as a sequence of images. */
+	public static void save(ImagePlus imp, String directoryPath, String options) {
+		StackWriter sw = new StackWriter();
+		sw.imp = imp;
+		sw.format = Tools.getStringFromList(options, "format=", sw.format);
+		sw.name = Tools.getStringFromList(options, "name=");
+		sw.ndigits = (int)Tools.getNumberFromList(options, "digits=", sw.ndigits);
+		sw.useLabels = options.contains(" use");
+		sw.run(directoryPath);
+	}
+
+
+	public void run(String arg) {
+		if (imp==null)
+			imp = WindowManager.getCurrentImage();
+		if (imp==null || (imp!=null && imp.getStackSize()<2&&!IJ.isMacro())) {
+			IJ.error("Stack Writer", "This command requires a stack.");
+			return;
+		}
+		int stackSize = imp.getStackSize();
+		if (name==null) {
+			name = imp.getTitle();
+			int dotIndex = name.lastIndexOf(".");
+			if (dotIndex>=0)
+				name = name.substring(0, dotIndex);
+		}
+		hyperstack = imp.isHyperStack();
+		LUT[] luts = null;
+		int lutIndex = 0;
+		int nChannels = imp.getNChannels();
+		if (hyperstack) {
+			dim = imp.getDimensions();
+			if (imp.isComposite())
+				luts = ((CompositeImage)imp).getLuts();
+			if (firstTime && ndigits==4) {
+				ndigits = 3;
+				firstTime = false;
+			}
+		}
+		if (arg!=null && arg.length()>0)
+			directory = arg;
+		else {		
+			if (!showDialog(imp))
+				return;
+		}		
+		File d = new File(directory);
+		if (d==null || !d.isDirectory()) {
+			IJ.error("File>Save As>Image Sequence", "Directory not found: "+directory);
+			return;
+		}
+		int number = 0;
+		if (ndigits<1) ndigits = 1;
+		if (ndigits>8) ndigits = 8;
+		int maxImages = (int)Math.pow(10,ndigits);
+		if (stackSize>maxImages && !useLabels && !hyperstack) {
+			IJ.error("Stack Writer", "More than " + ndigits
+				+" digits are required to generate \nunique file names for "+stackSize+" images.");
+			return;			
+		}
+		if (format.equals("fits") && !FileSaver.okForFits(imp))
+			return;			
+		if (format.equals("text"))
+			format = "text image";
+		String extension = "." + format;
+		if (format.equals("tiff"))
+			extension = ".tif";
+		else if (format.equals("text image"))
+			extension = ".txt";					
+		Overlay overlay = imp.getOverlay();
+		boolean isOverlay = overlay!=null && !imp.getHideOverlay();
+		if (!(format.equals("jpeg")||format.equals("png")))
+			isOverlay = false;
+		ImageStack stack = imp.getStack();
+		ImagePlus imp2 = new ImagePlus();
+		imp2.setTitle(imp.getTitle());
+		Calibration cal = imp.getCalibration();
+		int nSlices = stack.size();
+		String path,label=null;
+		imp.lock();
+		for (int i=1; i<=nSlices; i++) {
+			IJ.showStatus("writing: "+i+"/"+nSlices);
+			IJ.showProgress(i, nSlices);
+			ImageProcessor ip = stack.getProcessor(i);
+			if (isOverlay) {
+				imp.setSliceWithoutUpdate(i);
+				ip = imp.flatten().getProcessor();
+			} else if (luts!=null && nChannels>1 && hyperstack) {
+				ip.setColorModel(luts[lutIndex++]);
+				if (lutIndex>=luts.length) lutIndex = 0;
+			}
+			imp2.setProcessor(null, ip);
+			String label2 = stack.getSliceLabel(i);
+			imp2.setProp("Slice_Label", null);
+			if (label2!=null) {
+				if (label2.contains("\n"))
+					imp2.setProperty("Info", label2);
+				else
+					imp2.setProp("Slice_Label", label2);;
+			} else {
+				Properties props = imp2.getProperties();
+				if (props!=null) props.remove("Info");
+			}
+			imp2.setCalibration(cal);
+			String digits = getDigits(number++);
+			if (useLabels) {
+				label = stack.getShortSliceLabel(i, 111);
+				if (label!=null && label.equals("")) label = null;
+				if (label!=null) label = label.replaceAll("/","-");
+			}
+			if (label==null)
+				path = directory+name+digits+extension;
+			else
+				path = directory+label+extension;
+			if (i==1) {
+				File f = new File(path);
+				if (f.exists()) {
+					if (!IJ.isMacro() && !IJ.showMessageWithCancel("Overwrite files?",
+						"One or more files will be overwritten if you click \"OK\".\n \n"+path)) {
+						imp.unlock();
+						IJ.showStatus("");
+						IJ.showProgress(1.0);
+						return;
+					}
+				}
+			}
+			if (Recorder.record)
+				Recorder.disablePathRecording();
+			imp2.setOverlay(null);
+			if (overlay!=null && format.equals("tiff")) {
+				Overlay overlay2 = overlay.duplicate();
+				overlay2.crop(i, i);
+				if (overlay2.size()>0) {
+					for (int j=0; j<overlay2.size(); j++) {
+						Roi roi = overlay2.get(j);
+						int pos = roi.getPosition();
+						if (pos==1)
+							roi.setPosition(i);
+					}
+					imp2.setOverlay(overlay2);
+				}
+			}
+			IJ.saveAs(imp2, format, path);
+		}
+		imp.unlock();
+		if (isOverlay) imp.setSlice(1);
+		IJ.showStatus("");
+	}
+	
+	private boolean showDialog(ImagePlus imp) {
+		String options = Macro.getOptions();
+		if (options!=null && options.contains("save="))  //macro
+			Macro.setOptions(options.replaceAll("save=", "dir="));
+		directory = Prefs.get(DIR_KEY, IJ.getDir("downloads")+"stack2/");
+		GenericDialog gd = new GenericDialog("Save Image Sequence");
+		if (!IJ.isMacro())
+			fileType = staticFileType;
+		gd.setInsets(5, 0, 0);
+		gd.addDirectoryField("Dir:", directory);		
+		gd.setInsets(2, 110, 5);
+		gd.addMessage("drag and drop target", IJ.font10, Color.darkGray);
+		gd.addChoice("Format:", choices, fileType);
+		gd.addStringField("Name:", name, 12);
+		if (!hyperstack)
+			gd.addNumericField("Start At:", startAt, 0);
+		gd.addNumericField("Digits (1-8):", ndigits, 0);
+		if (!hyperstack)
+			gd.addCheckbox("Use slice labels as file names", useLabels);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		directory = gd.getNextString();
+		directory = IJ.addSeparator(directory);
+		Prefs.set(DIR_KEY, directory);
+		gd.setSmartRecording(true);
+		fileType = gd.getNextChoice();
+		format = fileType.toLowerCase(Locale.US);
+		if (!IJ.isMacro())
+			staticFileType = fileType;
+		String name2 = gd.getNextString();
+		boolean nameChanged =  !name2.equals(name);
+		name = name2;
+		if (!hyperstack)
+			startAt = (int)gd.getNextNumber();
+		if (startAt<0) startAt = 0;
+		int ndigits2 = (int)gd.getNextNumber();
+		boolean ndigitsChanged = ndigits2!=ndigits;
+		ndigits = ndigits2;
+		if (!hyperstack)
+			useLabels = gd.getNextBoolean();
+		else
+			useLabels = false;
+		if (Recorder.record) {
+			String options2 = "format="+format;
+			if (nameChanged)
+				options2 += " name="+name;
+			if (ndigitsChanged)
+				options2 += " digits="+ndigits;
+			if (useLabels)
+				options2 += " use";			
+			String dir = Recorder.fixPath(directory);
+   			Recorder.recordCall("StackWriter.save(imp, \""+dir+"\", \""+options2+"\");");
+		}
+		return true;
+	}
+	
+	String getDigits(int n) {
+		if (hyperstack) {
+			int c = (n%dim[2])+1;
+			int z = ((n/dim[2])%dim[3])+1;
+			int t = ((n/(dim[2]*dim[3]))%dim[4])+1;
+			String cs="", zs="", ts="";
+			if (dim[2]>1) {
+				cs = "00000000"+c;
+				cs = "_c"+cs.substring(cs.length()-ndigits);
+			}
+			if (dim[3]>1) {
+				zs = "00000000"+z;
+				zs = "_z"+zs.substring(zs.length()-ndigits);
+			}
+			if (dim[4]>1) {
+				ts = "00000000"+t;
+				ts = "_t"+ts.substring(ts.length()-ndigits);
+			}
+			return ts+zs+cs;
+		} else {
+			String digits = "00000000"+(startAt+n);
+			return digits.substring(digits.length()-ndigits);
+		}
+	}
+	
+}
+
diff --git a/src/ij/plugin/Stack_Statistics.java b/src/ij/plugin/Stack_Statistics.java
new file mode 100644
index 0000000..de7fa50
--- /dev/null
+++ b/src/ij/plugin/Stack_Statistics.java
@@ -0,0 +1,54 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.plugin.filter.Analyzer;
+import ij.measure.*;
+import ij.gui.Roi;
+import java.awt.Rectangle;
+
+/** This plugin implements the Image/Stacks/Statistics command. */
+public class Stack_Statistics implements PlugIn {
+	
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		int measurements = Analyzer.getMeasurements();
+		Analyzer.setMeasurements(measurements | Measurements.LIMIT);
+		ImageStatistics stats = new StackStatistics(imp);
+		Analyzer.setMeasurements(measurements);
+		ResultsTable rt = Analyzer.getResultsTable();
+		rt.incrementCounter();
+		Roi roi = imp.getRoi();
+		if (roi!=null && !roi.isArea()) {
+			imp.deleteRoi();
+			roi = null;
+		}
+		double stackVoxels = 0.0;
+		double images = imp.getStackSize();
+		if (roi==null)
+			stackVoxels = imp.getWidth()*imp.getHeight()*images;
+		else if (roi.getType()==Roi.RECTANGLE) {
+			Rectangle r = roi.getBounds();
+			stackVoxels = r.width*r.height*images;
+		} else {
+			Analyzer.setMeasurements(measurements & ~Measurements.LIMIT);
+			ImageStatistics stats2 = new StackStatistics(imp);
+			Analyzer.setMeasurements(measurements);
+			stackVoxels = stats2.longPixelCount;
+		}
+		Calibration cal = imp.getCalibration();
+		String units = cal.getUnits();	
+		double scale = cal.pixelWidth*cal.pixelHeight*cal.pixelDepth;
+		rt.addValue("Voxels", stats.longPixelCount);
+		if (scale!=1.0)
+		rt.addValue("Volume("+units+"^3)", stats.longPixelCount*scale);
+		rt.addValue("%Volume", stats.longPixelCount*100.0/stackVoxels);
+		rt.addValue("Mean", stats.mean);
+		rt.addValue("StdDev", stats.stdDev);
+		rt.addValue("Min", stats.min);
+		rt.addValue("Max", stats.max);
+		rt.addValue("Mode", stats.dmode);
+		rt.addValue("Median", stats.median);
+		rt.show("Results");
+	}
+	
+}
diff --git a/src/ij/plugin/Startup.java b/src/ij/plugin/Startup.java
new file mode 100644
index 0000000..9a91e5e
--- /dev/null
+++ b/src/ij/plugin/Startup.java
@@ -0,0 +1,110 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.util.Vector;
+
+/** This plugin implements the Edit/Options/Startup command. */
+	public class Startup implements PlugIn, ItemListener {
+		private static String NAME = "RunAtStartup.ijm";
+		private GenericDialog gd;
+		private static final String[] code = {
+			"[Select from list]",
+			"Black background",
+			"Set default directory",
+			"Debug mode",
+			"10-bit (0-1023) range",
+			"12-bit (0-4095) range",
+			"Splash Screen",
+			"Bolder selections",
+			"Add to overlay",
+			"Flip FITS images"
+		};
+	private String macro = "";
+	private int originalLength;
+
+	public void run(String arg) {
+		macro = getStartupMacro();
+		String macro2 = macro;
+		if (!showDialog())
+			return;
+		if (!macro.equals(macro2)) {
+			if (!runMacro(macro))
+				return;
+			saveStartupMacro(macro);
+		}
+	}
+	
+	public String getStartupMacro() {
+		String macro = IJ.openAsString(IJ.getDirectory("macros")+NAME);
+		if (macro==null || macro.startsWith("Error:"))
+			return null;
+		else
+			return macro;
+	}
+		
+	private void saveStartupMacro(String macro) {
+		IJ.saveString(macro, IJ.getDirectory("macros")+NAME);
+	}
+
+	private boolean showDialog() {
+		gd = new GenericDialog("Startup Macro");
+		String text = "Macro code contained in this text area\nexecutes when ImageJ starts up.";
+		Font font = new Font("SansSerif", Font.PLAIN, 14);
+		gd.setInsets(5,15,0);
+		gd.addMessage(text, font);
+		gd.setInsets(5, 10, 0);
+		gd.addTextAreas(macro, null, 15, 50);
+		gd.addChoice("Add code:", code, code[0]);
+		Vector choices = gd.getChoices();
+		if (choices!=null) {
+			Choice choice = (Choice)choices.elementAt(0);
+			choice.addItemListener(this);
+		}
+		gd.showDialog();
+		macro = gd.getNextText();
+		return !gd.wasCanceled();
+	}
+	
+	private boolean runMacro(String macro) {
+		Interpreter interp = new Interpreter();
+		interp.run(macro, null);
+		if (interp.wasError())
+			return false;
+		else
+			return true;
+	}
+				
+	public void itemStateChanged(ItemEvent e) {
+		Choice choice = (Choice)e.getSource();
+		String item = choice.getSelectedItem();
+		String statement = null;
+		if (item.equals(code[1]))
+			statement = "setOption(\"BlackBackground\", true);\n";
+		else if (item.equals(code[2]))			
+			statement = "File.setDefaultDir(getDir(\"downloads\"));\n";
+		else if (item.equals(code[3]))
+			statement = "setOption(\"DebugMode\", true);\n";
+		else if (item.equals(code[4]))
+			statement = "call(\"ij.ImagePlus.setDefault16bitRange\", 10);\n";
+		else if (item.equals(code[5]))
+			statement = "call(\"ij.ImagePlus.setDefault16bitRange\", 12);\n";
+		else if (item.equals(code[6]))			
+			statement = "run(\"About ImageJ...\");\nwait(3000);\nclose(\"About ImageJ\");\n";
+		else if (item.equals(code[7]))			
+			statement = "Roi.setDefaultStrokeWidth(2);\n";
+		else if (item.equals(code[8]))
+			statement = "setOption(\"Add to overlay\", true);\n";
+		else if (item.equals(code[9]))
+			statement = "setOption(\"FlipFitsImages\", false);\n";
+		if (statement!=null) {
+			TextArea ta = gd.getTextArea1();
+			ta.insert(statement, ta.getCaretPosition());
+			if (IJ.isMacOSX()) ta.requestFocus();
+		}
+	}
+
+}
diff --git a/src/ij/plugin/Straightener.java b/src/ij/plugin/Straightener.java
new file mode 100644
index 0000000..d67dbba
--- /dev/null
+++ b/src/ij/plugin/Straightener.java
@@ -0,0 +1,230 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import java.awt.*;
+
+/** This plugin implements the Edit/Selection/Straighten command. */
+public class Straightener implements PlugIn {
+	static boolean processStack;
+
+ 	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		Roi roi = imp.getRoi();
+		boolean rotatedRectangle = roi!=null && (roi instanceof RotatedRectRoi);
+		if (roi==null || !(roi.isLine()||rotatedRectangle)) {
+			IJ.error("Straightener", "Line, or rotated rectangle, selection required");
+			return;
+		}
+		if (rotatedRectangle) {
+			IJ.run(imp, "Duplicate...", " ");
+			return;
+		}
+		if (!imp.lock()) return;
+		int width = (int)Math.round(roi.getStrokeWidth());
+		int originalWidth = width;
+		boolean isMacro = IJ.macroRunning() && Macro.getOptions()!=null;
+		int stackSize = imp.getStackSize();
+		if (stackSize==1) processStack = false;
+		String newTitle = WindowManager.getUniqueName(imp.getTitle());
+		if (width<=1 || isMacro || stackSize>1) {
+			if (width<=1) width = 20;
+			GenericDialog gd = new GenericDialog("Straightener");
+			gd.addStringField("Title:", newTitle, 15);
+			gd.addNumericField("Line Width:", width, 0, 3, "pixels");
+			if (stackSize>1)
+				gd.addCheckbox("Process Entire Stack", processStack);
+			gd.showDialog();
+			if (gd.wasCanceled()) {imp.unlock(); return;}
+			newTitle = gd.getNextString();
+			width = (int)gd.getNextNumber();
+			Line.setWidth(width);
+			if (stackSize>1)
+				processStack = gd.getNextBoolean();
+		}
+		roi = (Roi)imp.getRoi().clone();
+		int type = roi.getType();
+		if (type==Roi.FREELINE)
+			IJ.run(imp, "Fit Spline", "");
+		ImageProcessor ip2 = null;
+		ImagePlus imp2 = null;
+		if (processStack) {
+			ImageStack stack2 = straightenStack(imp, roi, width);
+			imp2 = new ImagePlus(newTitle, stack2);
+		} else {
+			ip2 = straighten(imp, roi, width);
+			imp2 = new ImagePlus(newTitle, ip2);
+		}
+		imp.unlock();
+		if (imp2==null)
+			return;
+		Calibration cal = imp.getCalibration();
+		if (cal.pixelWidth==cal.pixelHeight)
+			imp2.setCalibration(cal);
+		imp2.show();
+		if (isMacro) Line.setWidth(originalWidth);
+	}
+
+	public ImageProcessor straighten(ImagePlus imp, Roi roi, int width) {
+		ImageProcessor ip2;
+		if (imp.getBitDepth()==24 && roi.getType()!=Roi.LINE)
+			ip2 = straightenRGB(imp, width);
+		else if (imp.isComposite() && ((CompositeImage)imp).getMode()==IJ.COMPOSITE) {
+			if (roi.getType()==Roi.LINE)
+				ip2 = rotateCompositeLine(imp, width);
+			else
+				ip2 = straightenComposite(imp, width);
+		} else if (roi.getType()==Roi.LINE)
+			ip2 = rotateLine(imp, width);
+		else
+			ip2 = straightenLine(imp, width);
+		return ip2;
+	}
+
+	public ImageStack straightenStack(ImagePlus imp, Roi roi, int width) {
+		int current = imp.getCurrentSlice();
+		int n = imp.getStackSize();
+		ImageStack stack2 = null;
+		for (int i=1; i<=n; i++) {
+			IJ.showProgress(i, n);
+			imp.setSlice(i);
+			ImageProcessor ip2 = straighten(imp, roi, width);
+			if (stack2==null)
+				stack2 = new ImageStack(ip2.getWidth(), ip2.getHeight());
+			stack2.addSlice(null, ip2);
+		}
+		imp.setSlice(current);
+		return stack2;
+	}
+
+	public ImageProcessor straightenLine(ImagePlus imp, int width) {
+		Roi tempRoi = imp.getRoi();
+		if (tempRoi == null) return null;	//roi may have changed asynchronously
+		if (tempRoi instanceof Line) {
+			FloatPolygon fp = ((Line)tempRoi).getFloatPoints();
+			tempRoi = new PolygonRoi(fp.xpoints, fp.ypoints, 2, Roi.POLYLINE);
+		} else if (!(tempRoi instanceof PolygonRoi))
+			return null;
+		PolygonRoi roi = (PolygonRoi)tempRoi;
+		if (roi==null)
+			return null;
+		if (roi.getState()==Roi.CONSTRUCTING)
+			roi.exitConstructingMode();
+		if (roi.isSplineFit())
+			roi.removeSplineFit();
+		int type = roi.getType();
+		int n = roi.getNCoordinates();
+		double len = roi.getLength();
+		roi.fitSplineForStraightening();
+		if (roi.getNCoordinates()<2)
+			return null;
+		FloatPolygon p = roi.getFloatPolygon();
+		n = p.npoints;
+		ImageProcessor ip = imp.getProcessor();
+		ImageProcessor ip2 = new FloatProcessor(n, width);
+		//ImageProcessor distances = null;
+		//if (IJ.debugMode)  distances = new FloatProcessor(n, 1);
+		float[] pixels = (float[])ip2.getPixels();
+		double x1, y1;
+		// the following will be taken as the previous point; extrapolate back one pixel
+		double x2 = p.xpoints[0]-(p.xpoints[1]-p.xpoints[0]);
+		double y2 = p.ypoints[0]-(p.ypoints[1]-p.ypoints[0]);
+		if (width<=1)
+			ip2.putPixelValue(0, 0, ip.getInterpolatedValue(x2, y2));
+		for (int i=0; i<n; i++) {
+			if (!processStack&&(i%10)==0) IJ.showProgress(i, n);
+			x1=x2; y1=y2;
+			x2 = p.xpoints[i];
+			y2 = p.ypoints[i];
+			//if (distances!=null) distances.putPixelValue(i, 0, (float)Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)));
+			if (width==1) {
+				ip2.putPixelValue(i, 0, ip.getInterpolatedValue(x2, y2));
+				continue;
+			}
+			double dx = x2-x1;
+			double dy = y1-y2;
+            double length = (float)Math.sqrt(dx*dx+dy*dy);
+            dx /= length;
+            dy /= length;
+			//IJ.log(i+"  "+x2+"  "+dy+"  "+(dy*width/2f)+"   "+y2+"  "+dx+"   "+(dx*width/2f));
+			double x = x2-dy*(width-1)/2.0;
+			double y = y2-dx*(width-1)/2.0;
+			int j = 0;
+			int n2 = width;
+			do {
+				ip2.putPixelValue(i, j++, ip.getInterpolatedValue(x, y));;
+				//ip.drawDot((int)x, (int)y);
+				x += dy;
+				y += dx;
+			} while (--n2>0);
+		}
+		if (!processStack) IJ.showProgress(n, n);
+		if (type==Roi.FREELINE)
+			roi.removeSplineFit();
+		else
+			imp.draw();
+		if (imp.getBitDepth()!=24) {
+			ip2.setColorModel(ip.getColorModel());
+			ip2.resetMinAndMax();
+		}
+		return ip2;
+	}
+
+	public ImageProcessor rotateLine(ImagePlus imp, int width) {
+		Roi roi = imp.getRoi();
+		if (roi==null || roi.getType()!=Roi.LINE)
+			throw new IllegalArgumentException("Straight line selection expected");
+		ImageProcessor ip2 = imp.getBitDepth()==24?straightenRGB(imp, width):straightenLine(imp, width);
+		return ip2;
+	}
+
+	ImageProcessor straightenRGB(ImagePlus imp, int width) {
+		int w=imp.getWidth(), h=imp.getHeight();
+		int size = w*h;
+		byte[] r = new byte[size];
+        byte[] g = new byte[size];
+        byte[] b = new byte[size];
+		ColorProcessor cp = (ColorProcessor)imp.getProcessor();
+		cp.getRGB(r, g, b);
+		Roi roi = imp.getRoi();
+		if (roi == null) return null;
+        ImagePlus imp2 = new ImagePlus("red", new ByteProcessor(w, h, r, null));
+        imp2.setRoi((Roi)roi.clone());
+        ImageProcessor red = straightenLine(imp2, width);
+        if (red==null) return null;
+        imp2 = new ImagePlus("green", new ByteProcessor(w, h, g, null));
+        imp2.setRoi((Roi)roi.clone());
+        ImageProcessor green = straightenLine(imp2, width);
+        if (green==null) return null;
+        imp2 = new ImagePlus("blue", new ByteProcessor(w, h, b, null));
+        imp2.setRoi((Roi)roi.clone());
+        ImageProcessor blue = straightenLine(imp2, width);
+        if (blue==null) return null;
+        ColorProcessor cp2 = new ColorProcessor(red.getWidth(), red.getHeight());
+        red = red.convertToByte(false);
+        green = green.convertToByte(false);
+        blue = blue.convertToByte(false);
+        cp2.setRGB((byte[])red.getPixels(), (byte[])green.getPixels(), (byte[])blue.getPixels());
+        imp.setRoi(imp2.getRoi());
+        return cp2;
+ 	}
+
+	ImageProcessor straightenComposite(ImagePlus imp, int width) {
+		Image img = imp.getImage();
+		ImagePlus imp2 = new ImagePlus("temp", new ColorProcessor(img));
+		imp2.setRoi(imp.getRoi());
+		ImageProcessor ip2 = straightenRGB(imp2, width);
+        imp.setRoi(imp2.getRoi());
+        return ip2;
+	}
+
+	ImageProcessor rotateCompositeLine(ImagePlus imp, int width) {
+		Image img = imp.getImage();
+		ImagePlus imp2 = new ImagePlus("temp", new ColorProcessor(img));
+		imp2.setRoi(imp.getRoi());
+		ImageProcessor ip2 = rotateLine(imp2, width);
+		return ip2;
+	}
+
+}
diff --git a/src/ij/plugin/SubHyperstackMaker.java b/src/ij/plugin/SubHyperstackMaker.java
new file mode 100644
index 0000000..38e914e
--- /dev/null
+++ b/src/ij/plugin/SubHyperstackMaker.java
@@ -0,0 +1,184 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.GenericDialog;
+import ij.process.ImageProcessor;
+import ij.process.LUT;
+import java.util.ArrayList;
+import java.util.List;
+import java.awt.Color;
+
+/**
+ * This plugin is used by the Image/Stacks/Tools/Make Substack
+ * command to create substacks of hyperstacks.
+ *  
+ * @author Curtis Rueden
+ */
+public class SubHyperstackMaker implements PlugIn {
+
+	public void run(String arg) {
+		// verify input image is appropriate
+		ImagePlus input = WindowManager.getCurrentImage();
+		if (input == null) {
+			IJ.showMessage("No image open.");
+			return;
+		}
+		if (input.getStackSize() == 1) {
+			IJ.showMessage("Image is not a stack.");
+			return;
+		}
+		int cCount = input.getNChannels();
+		int zCount = input.getNSlices();
+		int tCount = input.getNFrames();
+		boolean hasC = cCount > 1;
+		boolean hasZ = zCount > 1;
+		boolean hasT = tCount > 1;
+
+		// prompt for C, Z and T ranges
+		GenericDialog gd = new GenericDialog("Subhyperstack Maker");
+		gd.addMessage("Enter a range (e.g. 2-14), a range with increment\n"
+			+ "(e.g. 1-100-2) or a list (e.g. 7,9,25,27)", null, Color.darkGray);
+		if (hasC) gd.addStringField("Channels:", "1-" + cCount, 40);
+		if (hasZ) gd.addStringField("Slices:", "1-" + zCount, 40);
+		if (hasT) gd.addStringField("Frames:", "1-" + tCount, 40);
+		gd.showDialog();
+		if (gd.wasCanceled()) return;
+		String cString = hasC ? gd.getNextString() : "1";
+		String zString = hasZ ? gd.getNextString() : "1";
+		String tString = hasT ? gd.getNextString() : "1";
+
+		// compute subhyperstack
+		ImagePlus output = makeSubhyperstack(input, cString, zString, tString);
+
+		// display result
+		output.show();
+	}
+
+	public static ImagePlus makeSubhyperstack(ImagePlus input, String cString, String zString, String tString) {
+		ArrayList<Integer> cList = parseList(cString, input.getNChannels());
+		ArrayList<Integer> zList = parseList(zString, input.getNSlices());
+		ArrayList<Integer> tList = parseList(tString, input.getNFrames());
+		return makeSubhyperstack(input, cList, zList, tList);
+	}
+
+	public static ImagePlus makeSubhyperstack(ImagePlus input, List<Integer> cList, List<Integer> zList, List<Integer> tList) {
+		// validate inputs
+		if (cList.size() == 0)
+			throw new IllegalArgumentException("Must specify at least one channel");
+		if (zList.size() == 0)
+			throw new IllegalArgumentException("Must specify at least one slice");
+		if (tList.size() == 0)
+			throw new IllegalArgumentException("Must specify at least one frame");
+
+		ImageStack inputStack = input.getImageStack();
+
+		int cCount = input.getNChannels();
+		int zCount = input.getNSlices();
+		int tCount = input.getNFrames();
+
+		for (int c : cList)
+			check("C", c, cCount);
+		for (int z : zList)
+			check("Z", z, zCount);
+		for (int t : tList)
+			check("T", t, tCount);
+
+		// create output image
+		String title = WindowManager.getUniqueName(input.getTitle());
+		ImagePlus output = IJ.createHyperStack(title, input.getWidth(), input.getHeight(), cList.size(), zList.size(), tList.size(), input.getBitDepth());
+		//ImagePlus output = input.createHyperStack(title, cList.size(), zList.size(), tList.size(), input.getBitDepth());	
+		ImageStack outputStack = output.getImageStack();
+
+		// add specified planes to subhyperstack
+		int oc = 0, oz, ot;
+		for (int c : cList) {
+			oc++;
+			oz = 0;
+			for (int z : zList) {
+				oz++;
+				ot = 0;
+				for (int t : tList) {
+					ot++;
+					int i = input.getStackIndex(c, z, t);
+					int oi = output.getStackIndex(oc, oz, ot);
+					String label = inputStack.getSliceLabel(i);
+					ImageProcessor ip = inputStack.getProcessor(i);
+					outputStack.setSliceLabel(label, oi);
+					outputStack.setPixels(ip.getPixels(), oi);
+					//IJ.log("  "+c + "  "+z+"  "+t+"  "+i +" "+oi+"  "+outputStack.getProcessor(1).getPixelValue(0,0));	
+				}
+			}
+		}
+		output.setStack(outputStack);
+
+		// propagate composite image settings, if appropriate
+		if (input instanceof CompositeImage) {
+			CompositeImage compositeInput = (CompositeImage) input;
+			CompositeImage compositeOutput =
+				new CompositeImage(output, compositeInput.getMode());
+			oc = 0;
+			for (int c : cList) {
+				oc++;
+				LUT table = compositeInput.getChannelLut(c);
+				compositeOutput.setChannelLut(table, oc);
+				compositeOutput.setPositionWithoutUpdate(oc, 1, 1);
+				compositeInput.setPositionWithoutUpdate(c, 1, 1);
+				double min = compositeInput.getDisplayRangeMin();
+				double max = compositeInput.getDisplayRangeMax();
+				compositeOutput.setDisplayRange(min, max);
+			}
+			output = compositeOutput;
+		}
+		output.setCalibration(input.getCalibration());
+		return output;
+	}
+
+	private static void check(String name, int index, int count) {
+		if (index < 1 || index > count) {
+			throw new IllegalArgumentException("Invalid " + name + " index: " +
+				index);
+		}
+	}
+
+	private static ArrayList<Integer> parseList(String planeString, int count) {
+		ArrayList<Integer> list = new ArrayList<Integer>();
+		for (String token : planeString.split("\\s*,\\s*")) {
+			int dash1 = token.indexOf("-");
+			int dash2 = token.lastIndexOf("-");
+			if (dash1 < 0) {
+				// single number
+				int index;
+				try {
+					index = Integer.parseInt(token);
+				} catch (NumberFormatException exc) {
+					throw new IllegalArgumentException("Invalid number: " + token);
+				}
+				if (index < 1 || index > count)
+					throw new IllegalArgumentException("Invalid number: " + token);
+				list.add(Integer.parseInt(token));
+			} else {
+				// range, with or without increment
+				int min, max, step;
+				try {
+					min = Integer.parseInt(token.substring(0, dash1));
+					if (dash1 == dash2) {
+						// range (e.g. 2-14)
+						max = Integer.parseInt(token.substring(dash1 + 1));
+						step = 1;
+					} else {
+						// range with increment (e.g. 1-100-2)
+						max = Integer.parseInt(token.substring(dash1 + 1, dash2));
+						step = Integer.parseInt(token.substring(dash2 + 1));
+					}
+				} catch (NumberFormatException exc) {
+					throw new IllegalArgumentException("Invalid range: " + token);
+				}
+				if (min < 1 || min > max || max > count || step < 1)
+					throw new IllegalArgumentException("Invalid range: " + token);
+				for (int index = min; index <= max; index += step)
+					list.add(index);
+			}
+		}
+		return list;
+	}
+
+}
diff --git a/src/ij/plugin/SubstackMaker.java b/src/ij/plugin/SubstackMaker.java
new file mode 100644
index 0000000..64057d1
--- /dev/null
+++ b/src/ij/plugin/SubstackMaker.java
@@ -0,0 +1,229 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.frame.Recorder;
+import ij.io.FileInfo;
+import java.awt.Color;
+
+/**
+ * This plugin implements the Image/Stacks/Tools/Make Substack command.
+ * What it does is extracts selected images from a stack to make a new substack.
+ * It takes three types of inputs: a range of images (e.g. 2-14), a range of images
+ * with an increment (e.g. 2-14-3), or a list of images (e.g. 7,9,25,27,34,132).
+ * It then copies those images from the active stack to a new stack in the order
+ * of listing or range.
+ *
+ * @author Anthony Padua
+ * @author Daniel Barboriak, MD
+ * @author Neuroradiology
+ * @author Duke University Medical Center
+ *
+ * @author Ved P. Sharma, Ph.D.
+ * @author Anatomy and Structural Biology
+ * @author Albert Einstein College of Medicine
+ *
+ */
+
+public class SubstackMaker implements PlugIn {
+	private static boolean staticDelete;
+	private boolean delete;
+	private boolean methodCall;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		if (imp.isHyperStack() || imp.isComposite()) {
+			(new SubHyperstackMaker()).run("");
+			return;
+		}
+		String userInput = showDialog();
+		if (userInput==null)
+			return;
+		ImagePlus imp2 = makeSubstack(imp, userInput);
+		if (imp2!=null)
+			imp2.show();
+	}
+
+	/**
+	 * Extracts selected slices from a stack to make a new substack.
+	 * Takes three types of inputs: a range of images (e.g. "2-14"), a range of
+	 * images with an increment (e.g. "2-14-3"), or a list of images (e.g. "7,9,25,27").
+	 * Precede with 'delete ' (e.g. "delete 2-14") and the slices will be deleted
+	 * from the stack.
+	*/
+	public static ImagePlus run(ImagePlus imp, String rangeOrList) {
+		SubstackMaker sm = new SubstackMaker();
+		sm.delete = rangeOrList.contains("delete ");
+		if (sm.delete)
+			rangeOrList = rangeOrList.replace("delete ","");
+		sm.methodCall = true;
+		ImagePlus imp2 = sm.makeSubstack(imp, rangeOrList);
+		if (sm.delete)
+			return imp;
+		else
+			return imp2;
+	}
+
+	public ImagePlus makeSubstack(ImagePlus imp, String userInput) {
+		String stackTitle = "Substack ("+userInput+")";
+		if (stackTitle.length()>25) {
+			int idxA = stackTitle.indexOf(",",18);
+			int idxB = stackTitle.lastIndexOf(",");
+			if(idxA>=1 && idxB>=1){
+				String strA = stackTitle.substring(0,idxA);
+				String strB = stackTitle.substring(idxB+1);
+				stackTitle = strA + ", ... " + strB;
+			}
+		}
+		ImagePlus imp2 = null;
+		try {
+			int idx1 = userInput.indexOf("-");
+			if (idx1>=1) {									// input displayed in range
+				String rngStart = userInput.substring(0, idx1);
+				String rngEnd = userInput.substring(idx1+1);
+				Integer obj = new Integer(rngStart);
+				int first = obj.intValue();
+				int inc = 1;
+				int idx2 = rngEnd.indexOf("-");
+				if (idx2>=1) {
+					String rngEndAndInc = rngEnd;
+					rngEnd = rngEndAndInc.substring(0, idx2);
+					String rngInc = rngEndAndInc.substring(idx2+1);
+					obj = new Integer(rngInc);
+					inc = obj.intValue();
+				}
+				obj = new Integer(rngEnd);
+				int last = obj.intValue();
+				imp2 = stackRange(imp, first, last, inc, stackTitle);
+			} else {
+				int count = 1; // count # of slices to extract
+				for (int j=0; j<userInput.length(); j++) {
+					char ch = Character.toLowerCase(userInput.charAt(j));
+					if (ch==',') {count += 1;}
+				}
+				int[] numList = new int[count];
+				for (int i=0; i<count; i++) {
+					int idx2 = userInput.indexOf(",");
+					if (idx2>0) {
+						String num = userInput.substring(0,idx2);
+						Integer obj = new Integer(num);
+						numList[i] = obj.intValue();
+						userInput = userInput.substring(idx2+1);
+					} else {
+						String num = userInput;
+						Integer obj = new Integer(num);
+						numList[i] = obj.intValue();
+					}
+				}
+				imp2 = stackList(imp, count, numList, stackTitle);
+			}
+		} catch (Exception e) {
+			IJ.error("Substack Maker", "Invalid input string:  \n \n  \""+userInput+"\"");
+		}
+		return imp2;
+	}
+	
+	String showDialog() {
+		String options = Macro.getOptions();
+		boolean isMacro = options!=null;
+		if (options!=null && !options.contains("slices=")) {
+			Macro.setOptions(options.replace("channels=", "slices="));
+			Macro.setOptions(options.replace("frames=", "slices="));
+		}
+		if (!isMacro) delete = staticDelete;
+		GenericDialog gd = new GenericDialog("Substack Maker");
+		gd.setInsets(10,45,0);
+		gd.addMessage("Enter a range (e.g. 2-14), a range with increment\n(e.g. 1-100-2) or a list (e.g. 7,9,25,27)", null, Color.darkGray);
+		gd.addStringField("Slices:", "", 40);
+		gd.addCheckbox("Delete slices from original stack", delete);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return null;
+		else {
+			String userInput = gd.getNextString();
+			delete = gd.getNextBoolean();
+			if (!isMacro) staticDelete = delete;
+			if (delete)
+				Recorder.recordCall("SubstackMaker.run(imp, \""+"delete "+userInput+"\");");
+			else
+				Recorder.recordCall("imp2 = SubstackMaker.run(imp, \""+userInput+"\");");
+			return userInput;
+		}
+	}
+
+	// extract specific slices
+	ImagePlus stackList(ImagePlus imp, int count, int[] numList, String stackTitle) throws Exception {
+		ImageStack stack = imp.getStack();
+		ImageStack stack2 = null;
+		boolean virtualStack = stack.isVirtual();
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();
+		Roi roi = imp.getRoi();
+		for (int i=0, j=0; i<count; i++) {
+			int currSlice = numList[i]-j;
+			ImageProcessor ip2 = stack.getProcessor(currSlice);
+			ip2.setRoi(roi);
+			if (!methodCall || !delete)
+				ip2 = ip2.crop();
+			if (stack2==null)
+				stack2 = new ImageStack(ip2.getWidth(), ip2.getHeight());
+			stack2.addSlice(stack.getSliceLabel(currSlice), ip2);
+			if (delete) {
+				stack.deleteSlice(currSlice);
+				j++;
+			}
+		}
+		if (delete) {
+			imp.setStack(stack);
+			// next three lines for updating the scroll bar
+			ImageWindow win = imp.getWindow();
+			StackWindow swin = (StackWindow) win;
+			if (swin!=null)
+				swin.updateSliceSelector();
+		}
+		ImagePlus impSubstack = imp.createImagePlus();
+		impSubstack.setStack(stackTitle, stack2);
+		if (virtualStack)
+			impSubstack.setDisplayRange(min, max);
+		return impSubstack;
+	}
+	
+	// extract range of slices
+	ImagePlus stackRange(ImagePlus imp, int first, int last, int inc, String title) throws Exception {
+		ImageStack stack = imp.getStack();
+		ImageStack stack2 = null;
+		boolean virtualStack = stack.isVirtual();
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();
+		Roi roi = imp.getRoi();
+		boolean showProgress = stack.size()>400 || stack.isVirtual();
+		for (int i= first, j=0; i<= last; i+=inc) {
+			if (showProgress) IJ.showProgress(i,last);
+			int currSlice = i-j;
+			ImageProcessor ip2 = stack.getProcessor(currSlice);
+			ip2.setRoi(roi);
+			ip2 = ip2.crop();
+			if (stack2==null)
+				stack2 = new ImageStack(ip2.getWidth(), ip2.getHeight());
+			stack2.addSlice(stack.getSliceLabel(currSlice), ip2);
+			if (delete) {
+				stack.deleteSlice(currSlice);
+				j++;
+			}
+		}
+		if (delete) {
+			imp.setStack(stack);
+			// next three lines for updating the scroll bar
+			ImageWindow win = imp.getWindow();
+			StackWindow swin = (StackWindow) win;
+			if (swin!=null)
+				swin.updateSliceSelector();
+		}
+		ImagePlus substack = imp.createImagePlus();
+		substack.setStack(title, stack2);
+		substack.setCalibration(imp.getCalibration());
+		if (virtualStack)
+			substack.setDisplayRange(min, max);
+		return substack;
+	}
+}
diff --git a/src/ij/plugin/SurfacePlotter.java b/src/ij/plugin/SurfacePlotter.java
new file mode 100644
index 0000000..5eb90f9
--- /dev/null
+++ b/src/ij/plugin/SurfacePlotter.java
@@ -0,0 +1,468 @@
+package ij.plugin;
+import ij.*;
+import ij.plugin.filter.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.math.*;
+import java.util.*;
+import ij.measure.*;
+
+
+public class SurfacePlotter implements PlugIn {
+
+	static final int fontSize = 14;
+	static int plotWidth = 350;
+	static int polygonMultiplier = 100;
+	static boolean oneToOne;
+	static boolean firstTime = true;
+	
+	static boolean showWireframe=false;
+	static boolean showGrayscale=true;
+	static boolean showAxis=true;
+	static boolean whiteBackground=false;
+	static boolean blackFill=false;
+	static boolean smooth = true;
+
+	ImagePlus img;
+	int[] x,y;
+	boolean invertedLut;
+	double angleInDegrees = 35;
+	double angle = (angleInDegrees/360.0)*2.0*Math.PI;
+	double angle2InDegrees = 15.0;
+	double angle2 = (angle2InDegrees/360.0)*2.0*Math.PI;
+	double yinc2 = Math.sin(angle2);
+	double p1x, p1y;  // left bottom corner
+	double p2x, p2y;  // center bottom corner
+	double p3x, p3y;  // right  bottom corner
+	
+	LookUpTable lut;
+	
+	public void run(String arg) {
+		img = WindowManager.getCurrentImage();
+		if (img==null)
+			{IJ.noImage(); return;}
+		if (img.getType()==ImagePlus.COLOR_RGB)
+			{IJ.error("Surface Plotter", "Grayscale or pseudo-color image required"); return;}
+		invertedLut = img.getProcessor().isInvertedLut();
+		if (firstTime) {
+			if (invertedLut)
+				whiteBackground	= true;
+			firstTime = false;			
+		}
+		if (!showDialog())
+			return;
+
+		int stackFlags = IJ.setupDialog(img, 0);
+		if(stackFlags == PlugInFilter.DONE)
+			return;
+		Date start = new Date();
+		lut = img.createLut();
+		
+		if (stackFlags==PlugInFilter.DOES_STACKS && img.getStack().getSize()>1){			
+			ImageStack stackSource = img.getStack();
+			ImageProcessor ip = stackSource.getProcessor(1);
+			ImageProcessor plot = makeSurfacePlot(ip);
+			ImageStack stack = new ImageStack(plot.getWidth(), plot.getHeight());
+			stack.setColorModel(plot.getColorModel());			
+			for (int i=1;i<=stackSource.getSize();i++)
+				stack.addSlice(null, plot.duplicate().getPixels());
+			stack.setPixels(plot.getPixels(), 1);
+			ImagePlus plots = new ImagePlus("Surface Plot", stack);
+			plots.show();
+			for (int i=2;i<=stackSource.getSize();i++) {
+				IJ.showStatus("Drawing slice " + i + "..." + " (" + (100*(i-1)/stackSource.getSize()) + "% done)");
+				ip = stackSource.getProcessor(i);
+				plot = makeSurfacePlot(ip);
+				ImageWindow win = plots.getWindow();
+				if (win!=null && win.isClosed()) break;
+				stack.setPixels(plot.getPixels(), i);
+				plots.setSlice(i);
+			}
+		} else {
+			ImageProcessor plot = makeSurfacePlot(img.getProcessor());
+			new ImagePlus("Surface Plot", plot).show();
+		}
+		
+		Date end = new Date();
+     		long lstart = start.getTime();
+      		long lend = end.getTime();
+      		long difference = lend - lstart;
+		IJ.register(SurfacePlotter.class);
+		IJ.showStatus("Done in "+difference+" msec." );
+	}
+	
+	boolean showDialog() {
+		GenericDialog gd = new GenericDialog("Surface Plotter");
+		//gd.addNumericField("Plot Width (pixels):", plotWidth, 0);
+		//gd.addNumericField("Angle (-90-90 degrees):", angleInDegrees, 0);
+		gd.addNumericField("Polygon Multiplier (10-200%):", polygonMultiplier, 0);
+		gd.addCheckbox("Draw_Wireframe", showWireframe);
+		gd.addCheckbox("Shade", showGrayscale);
+		gd.addCheckbox("Draw_Axis", showAxis);
+		gd.addCheckbox("Source Background is Lighter", whiteBackground);
+		gd.addCheckbox("Fill Plot Background with Black", blackFill);
+		gd.addCheckbox("One Polygon Per Line", oneToOne);
+		gd.addCheckbox("Smooth", smooth);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		//plotWidth = (int) gd.getNextNumber();
+		//angleInDegrees = gd.getNextNumber();
+		polygonMultiplier = (int)gd.getNextNumber();
+		showWireframe = gd.getNextBoolean();
+		showGrayscale = gd.getNextBoolean();
+		showAxis = gd.getNextBoolean();
+		whiteBackground = gd.getNextBoolean();
+		blackFill = gd.getNextBoolean();
+		oneToOne = gd.getNextBoolean();
+		smooth = gd.getNextBoolean();
+		if (showWireframe && !showGrayscale)
+			blackFill = false;
+		if (polygonMultiplier>400) polygonMultiplier = 400;
+		if (polygonMultiplier<10) polygonMultiplier = 10;
+		return true;
+	}
+	
+	public ImageProcessor makeSurfacePlot(ImageProcessor ip) {
+		ip = ip.duplicate();
+		Rectangle roi = img.getProcessor().getRoi();
+		ip.setRoi(roi);
+		if (!(ip instanceof ByteProcessor)) {
+			ip.setMinAndMax(img.getProcessor().getMin(), img.getProcessor().getMax());
+			ip = ip.convertToByte(true);
+			ip.setRoi(roi);
+		}
+		double angle = (angleInDegrees/360.0)*2.0*Math.PI;
+		int polygons = (int)(plotWidth*(polygonMultiplier/100.0)/4);
+		if (oneToOne)
+			polygons = roi.height;
+		double xinc = 0.8*plotWidth*Math.sin(angle)/polygons;
+		double yinc = 0.8*plotWidth*Math.cos(angle)/polygons;
+		IJ.showProgress(0.01);
+		ip.setInterpolate(!oneToOne);
+		ip = ip.resize(plotWidth, polygons);
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		double min = ip.getMin();
+		double max = ip.getMax();
+				
+		if(invertedLut) ip.invert();
+		if(whiteBackground) ip.invert();
+		if (smooth) ip.smooth();
+
+		x = new int[width+2];
+		y = new int[width+2];
+		double xstart = 10.0;
+		if (xinc<0.0)
+			xstart += Math.abs(xinc)*polygons;
+		ByteProcessor ipProfile =new ByteProcessor(width, (int)(256+width*yinc2));
+		ipProfile.setValue(255);
+		ipProfile.fill();
+		double ystart =  yinc2*width;
+		int ybase = (int)(ystart+0.5);
+		int windowWidth =(int)(plotWidth+polygons*Math.abs(xinc) + 20.0);
+		int windowHeight = (int)(ipProfile.getHeight()+polygons*yinc + 10.0);
+		
+		if(showAxis){
+			xstart += 50+20;
+			ystart += 10;
+			windowWidth += 60+20;
+			windowHeight += 20;
+			p1x = xstart;
+			p1y = ystart+255;
+			p2x = xstart+xinc*height;;
+			p2y = p1y+yinc*height;
+			p3x =  p2x+width-1;
+			p3y = p2y- yinc2*width;
+		}
+		
+		if(showGrayscale) {
+			int v;
+			int[] column = new int[255];
+			for(int row=0; row<255; row++) {
+				if(whiteBackground)
+					v = row;
+				else
+					v = 255-row;
+				column[row] = v;
+			}
+			int base = ipProfile.getHeight()-255;		
+			for(int col=0; col<width; col++) {
+				ipProfile.putColumn(col, base-(int)(yinc2*col+0.5), column, 255);
+			}
+		} else {
+			ipProfile.setValue(254);
+			ipProfile.fill();
+		}
+		
+		ipProfile.snapshot();
+		
+		ImageProcessor ip2 = new ByteProcessor(windowWidth, windowHeight);		
+		if(showGrayscale) {
+			ip2.setColorModel(ip.getColorModel());
+			if(invertedLut)
+				ip2.invertLut();	
+			fixLut(ip2);
+		}		
+		if(!blackFill)
+			ip2.setValue(255);
+		else
+			ip2.setValue(0);
+		ip2.fill();
+		
+		for (int row=0; row<height; row++) {
+			double[] profile = ip.getLine(0, row, width-1, row);
+			clearAboveProfile(ipProfile, profile, width, yinc2);
+			int ixstart = (int)(xstart+0.5);
+			int iystart = (int)(ystart+0.5);
+			
+			ip2.copyBits(ipProfile, ixstart, iystart-ybase, Blitter.COPY_TRANSPARENT);
+			ipProfile.reset();
+
+			if (showWireframe) {
+				ip2.setValue(0);
+				double ydelta = 0.0;
+				ip2.moveTo(ixstart, (int)(ystart+255.5 - profile[0]) );
+				for(int i=1; i<width; i++) {
+					ydelta += yinc2;
+					ip2.lineTo( ixstart+i,  (int) (ystart+255.5-(profile[i]+ydelta)));
+				}
+				ip2.drawLine(ixstart, iystart+255, ixstart + width-1, (int)( ystart+255.5-ydelta) );
+				ip2.drawLine( ixstart, iystart+255-(int) (profile[0]+0.5), ixstart, iystart+255 );
+				ip2.drawLine( ixstart+width-1, (int) ( ystart+255.5-ydelta),  ixstart+width-1, (int) (ystart+255.5-(profile[width-1]+ydelta)) );
+			}
+			
+			xstart += xinc;
+			ystart += yinc;
+			if ((row%10)==0) IJ.showProgress((double)row/height);
+		}
+
+		IJ.showProgress(1.0);		
+		
+		if(invertedLut) {
+			ip.invert();
+			ip.invertLut();
+		}
+		if(whiteBackground)
+			ip.invert();
+			
+		if (showAxis) {
+			if (!lut.isGrayscale() && showGrayscale)
+				ip2 = ip2.convertToRGB();			
+			drawAndLabelAxis(ip, ip2, roi);
+		}
+
+		if (img.getStackSize()==1)
+			ip2 = trimPlot(ip2, ybase);
+				
+		return ip2;
+	}
+
+	void drawAndLabelAxis(ImageProcessor ip, ImageProcessor ip2, Rectangle roi) {			
+		ip2.setFont(new Font("SansSerif", Font.PLAIN, fontSize));
+		if(!blackFill)	
+			ip2.setColor(Color.black);
+		else
+			ip2.setColor(Color.white);			
+		ip2.setAntialiasedText(true);
+		String s;
+		int w, h;
+		Calibration cal = img.getCalibration();
+
+		//z-axis & label
+		s = cal.getValueUnit();
+		if (s.equals("Gray Value"))
+			s = "";
+		w =  ip2.getFontMetrics().stringWidth(s);
+		drawAxis(ip2, (int) p1x, (int) p1y-255, (int) p1x, (int) p1y , s, 10, -1, 0, 1);
+		double min, max;
+		if (img.getBitDepth()==8) {
+			min = 0;
+			max = 255;
+		} else {
+			min = img.getProcessor().getMin();
+			max = img.getProcessor().getMax();
+		}
+		//IJ.log("");
+		//IJ.log(min+"  "+max+"  "+cal.getCValue((int)min)+"  "+cal.getCValue((int)max));
+		//ip2.putPixelValue(0,0,0);
+		//boolean zeroIsBlack
+		//IJ.log(ip2.getPixelValue(+"  "+max+"  "+cal.getCValue((int)min)+"  "+cal.getCValue((int)max));
+		if (cal.calibrated()) {
+			min = cal.getCValue((int)min);
+			max = cal.getCValue((int)max);
+		}
+		//if (invertedPixelValues)
+		//	{double t=max; max=min; min=t;}
+		ip2.setAntialiasedText(true);
+		s = String.valueOf( (double) Math.round(max*10)/10);
+		w =  ip.getFontMetrics().stringWidth(s);
+		h =  ip.getFontMetrics().getHeight();
+		ip2.drawString(s, (int) p1x-18-w, (int) p1y-255 +h/2);	//ybase+5+h+(int ( yinc2/xinc *10));
+		s = String.valueOf( (double) Math.round(min*10)/10);
+		w =  ip2.getFontMetrics().stringWidth(s);
+		ip2.drawString(s, (int) p1x-18-w, (int) p1y +h/2);
+		
+		//x-axis
+		boolean unitsMatch = cal.getXUnit().equals(cal.getYUnit());
+		String xunits = unitsMatch ? cal.getUnits() : cal.getYUnit(); // why swapped?
+		s = (double) Math.round(roi.height*cal.pixelHeight*10)/10+" "+xunits;
+		w =  ip2.getFontMetrics().stringWidth(s);
+		drawAxis(ip2, (int) p1x, (int) p1y, (int) p2x, (int) p2y, s, 10, -1, 1, 1);
+
+		//y-axis
+		String yunits = unitsMatch ? cal.getUnits() : cal.getXUnit(); // why swapped?
+		s = (double) Math.round(roi.width*cal.pixelWidth*10)/10+" "+yunits;
+		w =  ip2.getFontMetrics().stringWidth(s);
+		drawAxis(ip2, (int) p2x, (int) p2y, (int) p3x, (int) p3y, s, 10, 1, -1, 1);
+
+	}
+
+	void drawAxis(ImageProcessor ip, int x1, int y1, int x2, int y2, String label, int offset, int offsetXDirection, int offsetYDirection, int labelSide){
+		if(blackFill)
+			ip.setColor(Color.white);
+		else
+			ip.setColor(Color.black);		
+		
+		double m = -(double) (y2-y1)/(double) (x2-x1);
+		
+		if(m==0)
+			m=.0001;
+		double mTangent = -1/m;
+		double theta = Math.atan(mTangent);
+				
+		int dy = -offsetXDirection * (int) ( 7*Math.sin(theta) );
+		int dx = -offsetXDirection * (int) ( 7*Math.cos(theta) );
+		
+		x1 += offsetXDirection * (int) ( offset*Math.cos(theta) );
+		x2 += offsetXDirection * (int) ( offset*Math.cos(theta) );
+		
+		y1 += offsetYDirection * (int) ( offset*Math.sin(theta) );
+		y2 += offsetYDirection * (int) ( offset*Math.sin(theta) );		
+		
+		ip.drawLine(x1, y1, x2, y2);
+		
+		ip.drawLine(x1, y1, x1+dx, y1-dy);
+		ip.drawLine(x2, y2, x2+dx, y2-dy);
+		ImageProcessor ipText = drawString( ip, label, (int) (Math.atan(m)/2/Math.PI*360) );
+		if(blackFill)
+			ipText.invert();
+				
+		Blitter b;
+		if (ip instanceof ByteProcessor)
+			b = new ByteBlitter((ByteProcessor) ip);
+		else
+			b = new ColorBlitter((ColorProcessor) ip);
+		Color c = blackFill?Color.black:Color.white;
+		b.setTransparentColor(c);
+		int xloc = (x1+x2)/2-ipText.getWidth()/2  + offsetXDirection*labelSide*(int)(15*Math.cos(theta));
+		int yloc = (y1+y2)/2-ipText.getHeight()/2 + offsetYDirection*labelSide*(int)(15*Math.sin(theta));
+		b.copyBits(ipText, xloc, yloc, Blitter.COPY_TRANSPARENT);
+				
+		return;						
+	}	
+	
+	ImageProcessor drawString(ImageProcessor ip, String s, int a){
+		int w =  ip.getFontMetrics().stringWidth(s);
+		int h =  ip.getFontMetrics().getHeight();
+		int ipW, ipH;
+		
+		double r = Math.sqrt( (w/2)*(w/2) + (h/2)*(h/2) );
+		double aR = (a/360.0)*2.0*Math.PI;
+		double aBaseR = Math.acos( (w/2)/r );
+		
+		ipW = (int) Math.abs(r*Math.cos(aBaseR+aR));
+		ipH = (int) Math.abs(r*Math.sin(aBaseR+aR));
+		
+		if((int) Math.abs(r*Math.cos(-aBaseR+aR))>ipW)
+			ipW = (int) Math.abs(r*Math.cos(-aBaseR+aR));
+		if((int) Math.abs(r*Math.sin(-aBaseR+aR))>ipH)
+			ipH = (int) Math.abs(r*Math.sin(-aBaseR+aR));
+		
+		ipW *= 2;
+		ipH *= 2;
+		
+		int tW = w;
+		if(ipW>w)
+			tW = ipW;
+		ImageProcessor ipText = new ByteProcessor(tW, ipH);
+		ipText.setFont(new Font("SansSerif", Font.PLAIN, fontSize));
+		ipText.setColor(Color.white);
+		ipText.fill();
+		ipText.setColor(Color.black);
+		ipText.setAntialiasedText(true);
+		ipText.drawString(s, tW/2-w/2, ipH/2+h/2);
+		ipText.setInterpolate(true);
+		ipText.rotate(-a);
+		ipText.setRoi(tW/2-ipW/2, 0, ipW, ipH);
+		ipText = ipText.crop();
+		
+		//new ImagePlus("test", ipText).show();
+		//ip.copyBits(ipText, x, y, Blitter.COPY_TRANSPARENT);
+
+		return ipText;
+	}
+	
+	void clearAboveProfile(ImageProcessor ipProfile, double[] profile, int width, double yinc2) {
+		byte[] pixels = (byte[])ipProfile.getPixels();
+		double ydelta = 0.0;
+		int height = ipProfile.getHeight();
+		for(int x=0; x<width; x++) {
+			ydelta += yinc2;			
+			int top = height - (int)(profile[x]+ydelta);
+			for (int y=0,index=x; y<top; y++, index+=width)
+				pixels[index] = (byte)255;
+		}					
+	}
+
+	ImageProcessor trimPlot(ImageProcessor plot, int maxTrim) {
+		int background = plot.getPixel(0, 0);
+		int width = plot.getWidth();
+		int height = plot.getHeight();
+		int trim = maxTrim-5;
+		a: for (int y=0; y<(maxTrim-5); y++)
+			for (int x=0; x<width; x++)
+				if (plot.getPixel(x,y)!=background)
+					{trim = y-5; break a;}
+		if (trim>10) {
+			plot.setRoi(0, trim, width, height-trim);
+			plot = plot.crop();
+		}
+		return plot;		
+	}
+
+
+	void fixLut(ImageProcessor ip) {
+		if(!lut.isGrayscale() && lut.getMapSize() == 256){
+			
+			for(int y=0;y<ip.getHeight();y++){
+				for(int x=0;x<ip.getWidth();x++){
+					if(ip.getPixelValue(x, y)==0){
+						ip.putPixelValue(x, y, 1);
+					}else if(ip.getPixelValue(x, y)==255){
+						ip.putPixelValue(x, y, 254);
+					}
+			
+				}
+			}
+			
+			byte[] rLUT = lut.getReds();			//new byte[256];
+			byte[] gLUT = lut.getGreens();			//new byte[256];
+			byte[] bLUT = lut.getBlues();			//new byte[256];
+			
+			rLUT[0] = (byte)0;
+			gLUT[0] = (byte)0;
+			bLUT[0] = (byte)0;
+			rLUT[255] = (byte)255;
+			gLUT[255] = (byte)255;
+			bLUT[255] = (byte)255;
+			
+			ip.setColorModel(new IndexColorModel(8, 256, rLUT, gLUT, bLUT));
+			
+		}	
+	}
+	
+
+}
diff --git a/src/ij/plugin/Text.java b/src/ij/plugin/Text.java
new file mode 100644
index 0000000..3e1a34e
--- /dev/null
+++ b/src/ij/plugin/Text.java
@@ -0,0 +1,120 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import java.awt.*;
+import java.util.*;
+
+/** This plugin implements the Edit/Options/Fonts command and 
+	the dialog displayed when you double click on the text tool. */
+public class Text implements PlugIn, DialogListener {
+	private static final String LOC_KEY = "fonts.loc";
+	private static final String[] styles = {"Plain", "Bold", "Italic", "Bold+Italic"};
+	private static final String[] justifications = {"Left", "Center", "Right"};
+	private static GenericDialog gd;
+	private String font = TextRoi.getDefaultFontName();
+	private int fontSize = TextRoi.getDefaultFontSize();
+	private int style = TextRoi.getDefaultFontStyle();
+	private int justification = TextRoi.getGlobalJustification();
+	private int angle;
+	private boolean antialiased = TextRoi.isAntialiased();
+	private Color color = Toolbar.getForegroundColor();
+	private String colorName;
+
+ 	public synchronized void run(String arg) {
+ 		if (gd!=null && gd.isVisible())
+ 			gd.toFront();
+ 		else
+			showDialog();
+	}
+				
+	private void showDialog() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Roi roi = imp!=null?imp.getRoi():null;
+		TextRoi textRoi = roi!=null&&(roi instanceof TextRoi)?(TextRoi)roi:null;
+		String fillc = "None";
+		TextRoi.setDefaultFillColor(null);
+		TextRoi.setDefaultAngle(0.0);
+		if (textRoi!=null) {
+			Font font = textRoi.getCurrentFont();
+			fontSize = font.getSize();
+			angle = (int)textRoi.getAngle();
+			style = font.getStyle();
+			justification = textRoi.getJustification();
+			Color c = textRoi.getStrokeColor();
+			if (c!=null) color=c;
+			fillc = Colors.colorToString2(textRoi.getFillColor());
+			antialiased = textRoi.getAntiAlias();
+		}
+		colorName = Colors.colorToString2(color);
+		gd =GUI.newNonBlockingDialog("Fonts");
+		gd.addChoice("Font:", getFonts(), font);
+		gd.addChoice("Style:", styles, styles[style]);
+		gd.addChoice("Just:", justifications, justifications[justification]);
+		gd.addChoice("Color:", Colors.getColors(colorName), colorName);
+		gd.addChoice("Bkgd:", Colors.getColors("None",!"None".equals(fillc)?fillc:null), fillc);
+		gd.addSlider("Size:", 9, 200, fontSize);
+		gd.addSlider("Angle:", -90, 90, angle);
+		gd.addCheckbox("Antialiased text", antialiased);
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (IJ.debugMode) {
+			Dimension screen = IJ.getScreenSize();
+			IJ.log("Fonts: "+loc+" "+screen);
+		}
+		if (loc!=null) {
+			gd.centerDialog(false);
+			gd.setLocation (loc);
+		}
+		gd.addDialogListener(this);
+		gd.setOKLabel("Close");
+		gd.hideCancelButton();
+		gd.showDialog();
+		Prefs.saveLocation(LOC_KEY, gd.getLocation());
+	}
+
+	String[] getFonts() {
+		GraphicsEnvironment ge = GraphicsEnvironment.getLocalGraphicsEnvironment();
+		String[] fonts = ge.getAvailableFontFamilyNames();
+		ArrayList names = new ArrayList();
+		names.add("SansSerif");
+		names.add("Serif");
+		names.add("Monospaced");
+		for (int i=0; i<fonts.length; i++) {
+			String f = fonts[i];
+			if (f.length()<=20 && !(f.equals("SansSerif")||f.equals("Serif")||f.equals("Monospaced")))
+				names.add(f);
+		}
+		return (String[])names.toArray(new String[names.size()]);
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Roi roi = imp!=null?imp.getRoi():null;
+		TextRoi textRoi = roi!=null&&(roi instanceof TextRoi)?(TextRoi)roi:null;
+		font = gd.getNextChoice();
+		style = gd.getNextChoiceIndex();
+		justification = gd.getNextChoiceIndex();
+		String colorName2 = gd.getNextChoice();
+		String fillc = gd.getNextChoice();
+		fontSize = (int)gd.getNextNumber();
+		angle = (int)gd.getNextNumber();
+		antialiased = gd.getNextBoolean();
+		if (colorName!=null && !colorName2.equals(colorName)) {
+			Color color = Colors.decode(colorName2, null);
+			Toolbar.setForegroundColor(color);
+			colorName = colorName2;
+		}
+		TextRoi.setFont(font, fontSize, style, antialiased);
+		TextRoi.setGlobalJustification(justification);
+		Color fillColor = Colors.decode(fillc, null);
+		TextRoi.setDefaultFillColor(fillColor);
+		TextRoi.setDefaultAngle(angle);
+		if (textRoi!=null) {
+			textRoi.setAngle(angle);
+			textRoi.setJustification(justification);
+			textRoi.setFillColor(fillColor);
+			textRoi.setAntiAlias(antialiased);
+		}
+		return true;
+	}
+	
+} 
diff --git a/src/ij/plugin/TextFileReader.java b/src/ij/plugin/TextFileReader.java
new file mode 100644
index 0000000..477dcec
--- /dev/null
+++ b/src/ij/plugin/TextFileReader.java
@@ -0,0 +1,18 @@
+package ij.plugin;
+
+//import java.awt.*;
+//import java.awt.image.*;
+//import java.io.*;
+import ij.*;
+//import ij.io.*;
+//import ij.process.*;
+
+
+/** This plugin displays the contents of a text file in a window. */
+public class TextFileReader implements PlugIn {
+	
+	public void run(String arg) {
+		new ij.text.TextWindow(arg,400,450);
+	}
+
+}
diff --git a/src/ij/plugin/TextReader.java b/src/ij/plugin/TextReader.java
new file mode 100644
index 0000000..ee6a5bc
--- /dev/null
+++ b/src/ij/plugin/TextReader.java
@@ -0,0 +1,168 @@
+package ij.plugin;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import ij.*;
+import ij.io.*;
+import ij.process.*;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+
+
+/** This plugin opens a tab or comma delimeted text file as an image.
+	Modified to accept commas as delimiters on 4/22/08 by 
+	Jay Unruh, Stowers Institute for Medical Research. */
+public class TextReader implements PlugIn {
+    int words = 0, chars = 0, lines = 0, width=1;;
+    String directory, name, path;
+    boolean hideErrorMessages;
+    String firstTok;
+    
+	public void run(String arg) {
+		if (showDialog()) {
+			IJ.showStatus("Opening: " + path);
+			ImageProcessor ip = open(path);
+			if (ip!=null)
+				new ImagePlus(name, ip).show();
+			if (Recorder.record && Recorder.scriptMode()) {
+				String path2 = Recorder.fixPath(path);
+				Recorder.recordCall("imp = IJ.openImage(\""+path2+"\");");
+			}
+		}
+	}
+    
+    boolean showDialog() {
+        OpenDialog od = new OpenDialog("Open Text Image...", null);
+        directory = od.getDirectory();
+        name = od.getFileName();
+        if (name!=null)
+            path = directory + name;
+        return name!=null;
+    }
+    
+    /** Displays a file open dialog and opens the specified text file as a float image. */
+    public ImageProcessor open() {
+        if (showDialog())
+            return open(path);
+        else
+            return null;
+    }
+    
+    /** Opens the specified text file as a float image. */
+    public ImageProcessor open(String path) {
+        ImageProcessor ip = null;
+        try {
+            words = chars = lines = 0;
+            Reader r = new BufferedReader(new FileReader(path));
+            countLines(r);
+            r.close();
+            r = new BufferedReader(new FileReader(path));
+            //int width = words/lines;
+            if (width*lines==0)
+            	return null;
+            float[] pixels = new float[width*lines];
+            ip = new FloatProcessor(width, lines, pixels, null);
+            read(r, width*lines, pixels);
+            r.close();
+            int firstRowNaNCount = 0;
+            for (int i=0; i<width; i++) {
+            	if (i<pixels.length && Float.isNaN(pixels[i]))
+            		firstRowNaNCount++;
+            }
+            if (firstRowNaNCount==width && !("NaN".equals(firstTok)||"nan".equals(firstTok))) { // assume first row is header
+            	ip.setRoi(0, 1, width, lines-1);
+            	ip = ip.crop();
+            }
+            ip.resetMinAndMax();
+        }
+        catch (IOException e) {
+            String msg = e.getMessage();
+            if (msg==null || msg.equals(""))
+                msg = ""+e;
+			IJ.showProgress(1.0);
+            if (!hideErrorMessages) 
+            	IJ.error("Text Reader", msg);
+            ip = null;
+        }
+        return ip;
+    }
+    
+    public void hideErrorMessages() {
+        hideErrorMessages = true;
+    }
+
+    /** Returns the file name. */
+    public String getName() {
+        return name;
+    }
+
+    void countLines(Reader r) throws IOException {
+        StreamTokenizer tok = new StreamTokenizer(r);
+        int wordsPerLine=0, wordsInPreviousLine=0;
+        tok.resetSyntax();
+        tok.wordChars(43, 43);
+        tok.wordChars(45, 127);
+        tok.whitespaceChars(0, 42);
+        tok.whitespaceChars(44, 44);
+        //tok.wordChars(33, 127);
+        //tok.whitespaceChars(0, ' ');
+		tok.whitespaceChars(128, 255);
+        tok.eolIsSignificant(true);
+
+        while (tok.nextToken() != StreamTokenizer.TT_EOF) {
+            switch (tok.ttype) {
+                case StreamTokenizer.TT_EOL:
+                    lines++;
+                    if (wordsPerLine==0)
+                        lines--;  // ignore empty lines
+                    if (lines==1 && wordsPerLine>0)
+                        width = wordsPerLine;
+                    if (lines>1 && wordsPerLine!=0 && wordsPerLine!=wordsInPreviousLine)
+                        throw new IOException("Line "+lines+ " is not the same length as the first line.");
+                    if (wordsPerLine!=0)
+                        wordsInPreviousLine = wordsPerLine;
+                    wordsPerLine = 0;
+                    if (lines%20==0 && width>1 && lines<=width)
+                        IJ.showProgress(((double)lines/width)/2.0);
+                    break;
+                case StreamTokenizer.TT_WORD:
+                    words++;
+                    wordsPerLine++;
+                    break;
+            }
+        }
+        if (wordsPerLine==width) 
+            lines++; // last line does not end with EOL
+   }
+
+    void read(Reader r, int size, float[] pixels) throws IOException {
+        StreamTokenizer tok = new StreamTokenizer(r);
+        tok.resetSyntax();
+        tok.wordChars(43, 43);
+        tok.wordChars(45, 127);
+        tok.whitespaceChars(0, 42);
+        tok.whitespaceChars(44, 44);
+        //tok.wordChars(33, 127);
+        //tok.whitespaceChars(0, ' ');
+        tok.whitespaceChars(128, 255);
+        //tok.parseNumbers();
+
+        int i = 0;
+        int inc = size/20;
+        if (inc<1)
+            inc = 1;
+        while (tok.nextToken() != StreamTokenizer.TT_EOF) {
+            if (tok.ttype==StreamTokenizer.TT_WORD) {
+                if (i==0)
+                	firstTok = tok.sval;
+                pixels[i++] = (float)Tools.parseDouble(tok.sval, Double.NaN);
+                if (i==size)
+                    break;
+                if (i%inc==0)
+                    IJ.showProgress(0.5+((double)i/size)/2.0);
+            }
+        }
+        IJ.showProgress(1.0);
+    }
+
+}
diff --git a/src/ij/plugin/TextWriter.java b/src/ij/plugin/TextWriter.java
new file mode 100644
index 0000000..d61e068
--- /dev/null
+++ b/src/ij/plugin/TextWriter.java
@@ -0,0 +1,34 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.io.*;
+import ij.text.*;
+import ij.plugin.frame.Editor;
+import java.awt.*;
+
+/** This plugin implements the File/Save As/Text command, which saves the
+	contents of Editor windows and TextWindows (e.g., "Log" and "Results"). */
+public class TextWriter implements PlugIn {
+    
+	public void run(String arg) {
+		saveText();
+	}
+	
+	void saveText() {
+		Frame frame = WindowManager.getFrontWindow();
+		if (frame!=null && (frame instanceof TextWindow)) {
+			TextPanel tp = ((TextWindow)frame).getTextPanel();
+			tp.saveAs("");
+		} else if (frame!=null && (frame instanceof Editor)) {
+			Editor ed = (Editor)frame;
+			ed.saveAs();
+		} else {
+			IJ.error("Save As Text",
+				"This command requires a TextWindow, such\n"
+				+ "as the \"Log\" window, or an Editor window. Use\n"
+				+ "File>Save>Text Image to save an image as text.");
+		}
+	}
+	
+}
+
diff --git a/src/ij/plugin/ThreadLister.java b/src/ij/plugin/ThreadLister.java
new file mode 100644
index 0000000..57f60a2
--- /dev/null
+++ b/src/ij/plugin/ThreadLister.java
@@ -0,0 +1,93 @@
+package ij.plugin;
+import java.io.*;
+import ij.*;
+import ij.text.*;
+import javax.swing.SwingUtilities;
+
+/**
+* Displays thread information in a text window.
+*
+* This code is from the book _Java in a Nutshell_ by David Flanagan.
+* Written by David Flanagan.
+*/
+public class ThreadLister implements PlugIn {
+
+	public void run(String arg) {
+		if (IJ.getApplet()!=null)
+			return;
+		CharArrayWriter caw = new CharArrayWriter();
+		PrintWriter pw = new PrintWriter(caw);
+		try {
+			listAllThreads(pw);
+			new TextWindow("Threads", caw.toString(), 420, 420);
+		} catch
+			(Exception e) {}
+			
+		// cause an exception on the EDT
+		if (IJ.altKeyDown()) {
+			SwingUtilities.invokeLater(new Runnable() {
+			  public void run() {
+				((Object) null).toString();        
+			  }
+			});
+		}
+		// cause an exception off the EDT
+		//((Object) null).toString();
+
+	}
+
+
+    // Display info about a thread.
+    private static void print_thread_info(PrintWriter out, Thread t, 
+                          String indent) {
+        if (t == null) return;
+        out.print(indent + "Thread: " + t.getName() +
+                "  Priority: " + t.getPriority() +
+                (t.isDaemon()?" Daemon":"") +
+                (t.isAlive()?"":" Not Alive") + "\n");
+    }
+    
+    // Display info about a thread group and its threads and groups
+    private static void list_group(PrintWriter out, ThreadGroup g, 
+                       String indent) {
+        if (g == null) return;
+        int num_threads = g.activeCount();
+        int num_groups = g.activeGroupCount();
+        Thread[] threads = new Thread[num_threads];
+        ThreadGroup[] groups = new ThreadGroup[num_groups];
+        
+        g.enumerate(threads, false);
+        g.enumerate(groups, false);
+        
+        out.println(indent + "Thread Group: " + g.getName() + 
+                "  Max Priority: " + g.getMaxPriority() +
+                (g.isDaemon()?" Daemon":"") + "\n");
+        
+        for(int i = 0; i < num_threads; i++)
+            print_thread_info(out, threads[i], indent + "    ");
+        for(int i = 0; i < num_groups; i++)
+            list_group(out, groups[i], indent + "    ");
+    }
+    
+    // Find the root thread group and list it recursively
+    public static void listAllThreads(PrintWriter out) {
+        ThreadGroup current_thread_group;
+        ThreadGroup root_thread_group;
+        ThreadGroup parent;
+        
+        // Get the current thread group
+        current_thread_group = Thread.currentThread().getThreadGroup();
+        
+        // Now go find the root thread group
+        root_thread_group = current_thread_group;
+        parent = root_thread_group.getParent();
+        while(parent != null) {
+            root_thread_group = parent;
+            parent = parent.getParent();
+        }
+        
+        // And list it, recursively
+        list_group(out, root_thread_group, "");
+    }
+    
+}
diff --git a/src/ij/plugin/Thresholder.java b/src/ij/plugin/Thresholder.java
new file mode 100644
index 0000000..2f0ae35
--- /dev/null
+++ b/src/ij/plugin/Thresholder.java
@@ -0,0 +1,439 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.frame.Recorder;
+import ij.plugin.filter.PlugInFilter;
+import ij.plugin.frame.ThresholdAdjuster;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+
+/** This plugin implements the Process/Binary/Make Binary 
+	and Convert to Mask commands. */
+public class Thresholder implements PlugIn, Measurements, ItemListener {
+	
+	public static final String[] methods = AutoThresholder.getMethods();
+	public static final String[] backgrounds = {"Default", "Dark", "Light"};
+	private double minThreshold;
+	private double maxThreshold;
+	private boolean autoThreshold;
+	private boolean showLegacyDialog = true;
+	private static boolean fill1 = true;
+	private static boolean fill2 = true;
+	private static boolean useBW = true;
+	private boolean useLocal = true;
+	private boolean listThresholds;
+	private boolean convertToMask;
+	private String method = methods[0];
+	private String background = backgrounds[0];
+	private static boolean staticUseLocal = true;
+	private static boolean staticListThresholds;
+	private static String staticMethod = methods[0];
+	private static String staticBackground = backgrounds[0];
+	private ImagePlus imp;
+	private Vector choices;
+
+	public void run(String arg) {
+		convertToMask = arg.equals("mask");
+		if (arg.equals("skip") || convertToMask)
+			showLegacyDialog = false;
+		ImagePlus imp = IJ.getImage();
+		if (imp.getStackSize()==1) {
+			Undo.setup(Undo.TRANSFORM, imp);
+			applyThreshold(imp, false);
+		} else
+			convertStack(imp);
+		IJ.showProgress(1.0);
+	}
+	
+	void convertStack(ImagePlus imp) {
+		if (imp.getStack().isVirtual()) {
+			IJ.error("Thresholder", "This command does not work with virtual stacks.\nUse Image>Duplicate to convert to a normal stack.");
+			return;
+		}
+		showLegacyDialog = false;
+		boolean thresholdSet = imp.isThreshold();
+		this.imp = imp;
+		if (!IJ.isMacro()) {
+			method = staticMethod;
+			background = staticBackground;
+			useLocal = staticUseLocal;
+			listThresholds = staticListThresholds;
+			if (!thresholdSet)
+				updateThreshold(imp);
+		} else {
+			String macroOptions = Macro.getOptions();
+			if (macroOptions!=null && macroOptions.indexOf("slice ")!=-1)
+				Macro.setOptions(macroOptions.replaceAll("slice ", "only "));
+			useLocal = false;
+		}
+		boolean saveBlackBackground = Prefs.blackBackground;
+		boolean oneSlice = false;
+		GenericDialog gd = new GenericDialog("Convert Stack to Binary");
+		gd.addChoice("Method:", methods, method);
+		gd.addChoice("Background:", backgrounds, background);
+		gd.addCheckbox("Calculate threshold for each image", useLocal);
+		gd.addCheckbox("Only convert current image", oneSlice);
+		gd.addCheckbox("Black background (of binary masks)", Prefs.blackBackground);
+		gd.addCheckbox("List thresholds", listThresholds);
+		choices = gd.getChoices();
+		if (choices!=null) {
+			((Choice)choices.elementAt(0)).addItemListener(this);
+			((Choice)choices.elementAt(1)).addItemListener(this);
+		}
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		this.imp = null;
+		method = gd.getNextChoice();
+		background = gd.getNextChoice();
+		useLocal = gd.getNextBoolean();
+		oneSlice = gd.getNextBoolean();
+		Prefs.blackBackground = gd.getNextBoolean();
+		listThresholds = gd.getNextBoolean();
+		if (!IJ.isMacro()) {
+			staticMethod = method;
+			staticBackground = background;
+			staticUseLocal = useLocal;
+			staticListThresholds = listThresholds;
+		}
+		if (oneSlice) {
+			useLocal = false;
+			listThresholds = false;
+			if (oneSlice && imp.getBitDepth()!=8) {
+				IJ.error("Thresholder", "8-bit stack required to process a single slice.");
+				return;
+			}
+		}
+		Undo.reset();
+		if (useLocal)
+			convertStackToBinary(imp);
+		else
+			applyThreshold(imp, oneSlice);
+		Prefs.blackBackground = saveBlackBackground;
+		if (thresholdSet) {
+			if (imp.getProcessor().getLutUpdateMode()!=ImageProcessor.NO_LUT_UPDATE)
+				imp.getProcessor().resetThreshold();
+			imp.updateAndDraw();
+		}
+	}
+
+	private void applyThreshold(ImagePlus imp, boolean oneSlice) {
+		imp.deleteRoi();
+		ImageProcessor ip = imp.getProcessor();
+		ip.resetBinaryThreshold();  // remove any invisible threshold set by Make Binary or Convert to Mask
+		int type = imp.getType();
+		if (type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32) {
+			applyShortOrFloatThreshold(imp);
+			return;
+		}
+		if (!imp.lock()) return;
+		double saveMinThreshold = ip.getMinThreshold();
+		double saveMaxThreshold = ip.getMaxThreshold();
+		autoThreshold = saveMinThreshold==ImageProcessor.NO_THRESHOLD;
+					
+		boolean useBlackAndWhite = false;
+		boolean fill1 = true;
+		boolean fill2 = true;
+		String options = Macro.getOptions();
+		boolean modernMacro = options!=null && !(options.contains("thresholded")||options.contains("remaining"));
+		if (autoThreshold || modernMacro || (IJ.macroRunning()&&options==null))
+			showLegacyDialog = false;
+		int fcolor=255, bcolor=0;
+			
+		if (showLegacyDialog) {
+			GenericDialog gd = new GenericDialog("Make Binary");
+			gd.addCheckbox("Thresholded pixels to foreground color", fill1);
+			gd.addCheckbox("Remaining pixels to background color", fill2);
+			gd.addMessage("");
+			gd.addCheckbox("Black foreground, white background", useBW);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				{imp.unlock(); return;}
+			fill1 = gd.getNextBoolean();
+			fill2 = gd.getNextBoolean();
+			useBW = useBlackAndWhite = gd.getNextBoolean();
+			int savePixel = ip.getPixel(0,0);
+			if (useBlackAndWhite)
+				ip.setColor(Color.black);
+			else
+				ip.setColor(Toolbar.getForegroundColor());
+			ip.drawPixel(0,0);
+			fcolor = ip.getPixel(0,0);
+			if (useBlackAndWhite)
+				ip.setColor(Color.white);
+			else
+				ip.setColor(Toolbar.getBackgroundColor());
+			ip.drawPixel(0,0);
+			bcolor = ip.getPixel(0,0);
+			ip.setColor(Toolbar.getForegroundColor());
+			ip.putPixel(0,0,savePixel);
+		} else
+			convertToMask = true;
+
+		if (type==ImagePlus.COLOR_RGB) {
+			ImageProcessor ip2 = updateColorThresholdedImage(imp);
+			if (ip2!=null) {
+				imp.setProcessor(ip2);
+				autoThreshold =false;
+				saveMinThreshold = 255;
+				saveMaxThreshold = 255;
+				type = ImagePlus.GRAY8;
+			}
+		}
+		if (type!=ImagePlus.GRAY8)
+			convertToByte(imp);
+		ip = imp.getProcessor();
+		
+		if (autoThreshold)
+			autoThreshold(ip);
+		else {
+			if (Recorder.record && !Recorder.scriptMode() && (!IJ.isMacro()||Recorder.recordInMacros))
+				Recorder.record("//setThreshold", (int)saveMinThreshold, (int)saveMaxThreshold);
+ 			minThreshold = saveMinThreshold;
+ 			maxThreshold = saveMaxThreshold;
+		}
+
+		if (convertToMask && ip.isColorLut())
+			ip.setColorModel(ip.getDefaultColorModel());
+		ip.resetThreshold();
+
+		if (IJ.debugMode) IJ.log("Thresholder (apply): "+minThreshold+"-"+maxThreshold+" "+fcolor+" "+bcolor+" "+fill1+" "+fill2);
+		int[] lut = new int[256];
+		for (int i=0; i<256; i++) {
+			if (i>=minThreshold && i<=maxThreshold)
+				lut[i] = fill1?fcolor:(byte)i;
+			else {
+				lut[i] = fill2?bcolor:(byte)i;
+			}
+		}
+		if (imp.getStackSize()>1 && !oneSlice)
+			new StackProcessor(imp.getStack(), ip).applyTable(lut);
+		else
+			ip.applyTable(lut);
+		if (convertToMask && !oneSlice) {
+			boolean invertedLut = imp.isInvertedLut();
+			if ((invertedLut && Prefs.blackBackground) || (!invertedLut && !Prefs.blackBackground)) {
+				ip.invertLut();
+				if (!IJ.isMacro() && ThresholdAdjuster.isDarkBackground() && !invertedLut && !Prefs.blackBackground)
+					IJ.log("\"Black background\" not set in Process>Binary>Options; inverting LUT");
+				if (IJ.debugMode) IJ.log("Thresholder (inverting lut)");
+			}
+		}
+		if (fill1 && fill2 && ((fcolor==0&&bcolor==255)||(fcolor==255&&bcolor==0))) {
+			imp.getProcessor().setThreshold(fcolor, fcolor, ImageProcessor.NO_LUT_UPDATE);
+			if (IJ.debugMode) IJ.log("Thresholder: "+fcolor+"-"+fcolor+" ("+(Prefs.blackBackground?"black":"white")+" background)");
+		}
+		imp.updateAndRepaintWindow();
+		imp.unlock();
+	}
+	
+	private ImageProcessor updateColorThresholdedImage(ImagePlus imp) {
+		Object mask = imp.getProperty("Mask");
+		if (mask==null || !(mask instanceof ByteProcessor))
+			return null;
+		ImageProcessor maskIP = (ImageProcessor)mask;
+		if (maskIP.getWidth()!=imp.getWidth() || maskIP.getHeight()!=imp.getHeight())
+			return null;
+		Object originalImage = imp.getProperty("OriginalImage");
+		if (originalImage!=null && (originalImage instanceof ImagePlus)) {
+			ImagePlus imp2 = (ImagePlus)originalImage;
+			if (imp2.getBitDepth()==24 && imp2.getWidth()==imp.getWidth() && imp2.getHeight()==imp.getHeight()) {
+				imp.setProcessor(imp2.getProcessor());
+				Undo.setup(Undo.TRANSFORM, imp);
+			}
+		}
+		return maskIP;
+	}
+	
+	private void applyShortOrFloatThreshold(ImagePlus imp) {
+		if (!imp.lock()) return;
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		int size = width*height;
+		boolean isFloat = imp.getType()==ImagePlus.GRAY32;
+		int currentSlice =  imp.getCurrentSlice();
+		int nSlices = imp.getStackSize();
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(width, height);
+		ImageProcessor ip = imp.getProcessor();
+		float t1 = (float)ip.getMinThreshold();
+		float t2 = (float)ip.getMaxThreshold();
+		if (t1==ImageProcessor.NO_THRESHOLD) {
+			double min = ip.getMin();
+			double max = ip.getMax();
+			ip = ip.convertToByte(true);
+			autoThreshold(ip);
+			t1 = (float)(min + (max-min)*(minThreshold/255.0));
+			t2 = (float)(min + (max-min)*(maxThreshold/255.0));
+		}
+		float value;
+		ImageProcessor ip1, ip2;
+		IJ.showStatus("Converting to mask");
+		for (int i=1; i<=nSlices; i++) {
+			IJ.showProgress(i, nSlices);
+			String label = stack1.getSliceLabel(i);
+			ip1 = stack1.getProcessor(i);
+			ip2 = new ByteProcessor(width, height);
+			for (int j=0; j<size; j++) {
+				value = ip1.getf(j);
+				if (value>=t1 && value<=t2)
+					ip2.set(j, 255);
+				else
+					ip2.set(j, 0);
+			}
+			stack2.addSlice(label, ip2);
+		}
+		imp.setStack(null, stack2);
+		ImageStack stack = imp.getStack();
+		stack.setColorModel(LookUpTable.createGrayscaleColorModel(!Prefs.blackBackground));
+		imp.setStack(null, stack);
+		if (imp.isComposite()) {
+			CompositeImage ci = (CompositeImage)imp;
+			ci.setMode(IJ.GRAYSCALE);
+			ci.resetDisplayRanges();
+			ci.updateAndDraw();
+		}
+		imp.getProcessor().setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+		if (IJ.debugMode) IJ.log("Thresholder16: 255-255 ("+(Prefs.blackBackground?"black":"white")+" background)");
+		IJ.showStatus("");
+		imp.unlock();
+	}
+
+	void convertStackToBinary(ImagePlus imp) {
+		int nSlices = imp.getStackSize();
+		double[] minValues = listThresholds?new double[nSlices]:null;
+		double[] maxValues = listThresholds?new double[nSlices]:null;
+		int bitDepth = imp.getBitDepth();
+		if (bitDepth!=8) {
+			IJ.showStatus("Converting to byte");
+			ImageStack stack1 = imp.getStack();
+			ImageStack stack2 = new ImageStack(imp.getWidth(), imp.getHeight());
+			for (int i=1; i<=nSlices; i++) {
+				IJ.showProgress(i, nSlices);
+				String label = stack1.getSliceLabel(i);
+				ImageProcessor ip = stack1.getProcessor(i);
+				ip.resetMinAndMax();
+				if (listThresholds) {
+					minValues[i-1] = ip.getMin();
+					maxValues[i-1] = ip.getMax();
+				}
+				stack2.addSlice(label, ip.convertToByte(true));
+			}
+			imp.setStack(null, stack2);
+		}
+		ImageStack stack = imp.getStack();
+		IJ.showStatus("Auto-thresholding");
+		if (listThresholds)
+			IJ.log("Thresholding method: "+method);
+		for (int i=1; i<=nSlices; i++) {
+			IJ.showProgress(i, nSlices);
+			ImageProcessor ip = stack.getProcessor(i);
+			if (method.equals("Default") && background.equals("Default"))
+				ip.setAutoThreshold(ImageProcessor.ISODATA2, ImageProcessor.NO_LUT_UPDATE);
+			else
+				ip.setAutoThreshold(method, !background.equals("Light"), ImageProcessor.NO_LUT_UPDATE);
+			minThreshold = ip.getMinThreshold();
+			maxThreshold = ip.getMaxThreshold();
+			if (listThresholds) {
+				double t1 = minThreshold;
+				double t2 = maxThreshold;
+				if (bitDepth!=8) {
+					t1 = minValues[i-1] + (t1/255.0)*(maxValues[i-1]-minValues[i-1]);
+					t2 = minValues[i-1] + (t2/255.0)*(maxValues[i-1]-minValues[i-1]);
+				}
+				int digits = bitDepth==32?2:0;
+				IJ.log("  "+i+": "+IJ.d2s(t1,digits)+"-"+IJ.d2s(t2,digits));
+			}
+			int[] lut = new int[256];
+			for (int j=0; j<256; j++) {
+				if (j>=minThreshold && j<=maxThreshold)
+					lut[j] = (byte)255;
+				else
+					lut[j] = 0;
+			}
+			ip.applyTable(lut);
+		}
+		stack.setColorModel(LookUpTable.createGrayscaleColorModel(!Prefs.blackBackground));
+		imp.setStack(null, stack);
+		imp.getProcessor().setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+		if (imp.isComposite()) {
+			CompositeImage ci = (CompositeImage)imp;
+			ci.setMode(IJ.GRAYSCALE);
+			ci.resetDisplayRanges();
+			ci.updateAndDraw();
+		}
+		IJ.showStatus("");
+	}
+
+	void convertToByte(ImagePlus imp) {
+		ImageProcessor ip;
+		int currentSlice =  imp.getCurrentSlice();
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = imp.createEmptyStack();
+		int nSlices = imp.getStackSize();
+		String label;
+		for(int i=1; i<=nSlices; i++) {
+			label = stack1.getSliceLabel(i);
+			ip = stack1.getProcessor(i);
+			ip.setMinAndMax(0, 255);
+			stack2.addSlice(label, ip.convertToByte(true));
+		}
+		imp.setStack(null, stack2);
+		imp.setSlice(currentSlice);
+		imp.setCalibration(imp.getCalibration()); //update calibration
+	}
+	
+	/** Returns an 8-bit binary (0 and 255) threshold mask
+	 * that has the same dimensions as this image.
+	 * @see ij.process.ImageProcessor#createMask
+	 * @see ij.ImagePlus#createThresholdMask
+	 * @see ij.ImagePlus#createRoiMask
+	*/
+	public static ByteProcessor createMask(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		if (ip instanceof ColorProcessor)
+			throw new IllegalArgumentException("Non-RGB image requires");
+		if (ip.getMinThreshold()==ImageProcessor.NO_THRESHOLD)
+			throw new IllegalArgumentException("Image must be thresholded");
+		return ip.createMask();
+	}
+	
+	void autoThreshold(ImageProcessor ip) {
+		ip.setAutoThreshold(ImageProcessor.ISODATA2, ImageProcessor.NO_LUT_UPDATE);
+		minThreshold = ip.getMinThreshold();
+		maxThreshold = ip.getMaxThreshold();
+		if (IJ.debugMode) IJ.log("Thresholder (auto): "+minThreshold+"-"+maxThreshold);
+ 	}
+ 	
+ 	public static void setMethod(String method) {
+ 		staticMethod = method;
+ 	}
+
+ 	public static void setBackground(String background) {
+ 		staticBackground = background;
+ 	}
+
+	public void itemStateChanged(ItemEvent e) {
+		if (imp==null)
+			return;
+		Choice choice = (Choice)e.getSource();
+		if (choice==choices.elementAt(0))
+			method = choice.getSelectedItem();
+		else
+			background = choice.getSelectedItem();
+		updateThreshold(imp);
+	}
+	
+	private void updateThreshold(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		if (method.equals("Default") && background.equals("Default"))
+			ip.setAutoThreshold(ImageProcessor.ISODATA2, ImageProcessor.RED_LUT);
+		else
+			ip.setAutoThreshold(method, !background.equals("Light"), ImageProcessor.RED_LUT);
+		imp.updateAndDraw();
+	}
+
+}
diff --git a/src/ij/plugin/URLOpener.java b/src/ij/plugin/URLOpener.java
new file mode 100644
index 0000000..2e12f15
--- /dev/null
+++ b/src/ij/plugin/URLOpener.java
@@ -0,0 +1,198 @@
+package ij.plugin;
+import java.awt.*;
+import java.io.*;
+import java.net.URL;
+import java.util.*;
+import ij.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.plugin.frame.*;
+
+/** Opens TIFFs, ZIP compressed TIFFs, DICOMs, GIFs and JPEGs using a URL. 
+	TIFF file names must end in ".tif", ZIP file names must end 
+	in ".zip" and DICOM file names must end in ".dcm". 
+	Opens a Web page in the default browser if the URL ends with "/".
+*/
+public class URLOpener implements PlugIn {
+
+	private static String url = IJ.URL+"/images/clown.gif";
+
+	/** If 'urlOrName' is a URL, opens the image at that URL. If it is
+		a file name, opens the image with that name from the 'images.location'
+		URL in IJ_Props.txt. If it is blank, prompts for an image
+		URL and open the specified image. */
+	public void run(String urlOrName) {
+		if (!urlOrName.equals("")) {
+			if (urlOrName.equals("cache"))
+				cacheSampleImages();
+			else if (urlOrName.endsWith("StartupMacros.txt"))
+				openTextFile(urlOrName, true);
+			else {
+				double startTime = System.currentTimeMillis();
+				String url = urlOrName.indexOf("://")>0?urlOrName:Prefs.getImagesURL()+urlOrName;
+				ImagePlus imp = new ImagePlus(url);
+				if (Recorder.record)
+					Recorder.recordCall("imp = IJ.openImage(\""+url+"\");");
+				if (imp.getType()==ImagePlus.COLOR_RGB)
+					Opener.convertGrayJpegTo8Bits(imp);
+				WindowManager.checkForDuplicateName = true;
+				FileInfo fi = imp.getOriginalFileInfo();
+				if (fi!=null && fi.fileType==FileInfo.RGB48)
+					imp = new CompositeImage(imp, IJ.COMPOSITE);
+				else if (imp.getNChannels()>1 && fi!=null && fi.description!=null && fi.description.indexOf("mode=")!=-1) {
+					int mode = IJ.COLOR;
+					if (fi.description.indexOf("mode=composite")!=-1)
+						mode = IJ.COMPOSITE;
+					else if (fi.description.indexOf("mode=gray")!=-1)
+						mode = IJ.GRAYSCALE;
+					imp = new CompositeImage(imp, mode);
+				}
+				if (fi!=null && (fi.url==null || fi.url.length()==0)) {
+					fi.url = url;
+					imp.setFileInfo(fi);
+				}
+				imp.show(Opener.getLoadRate(startTime,imp));
+				String title = imp.getTitle();
+				if (title!=null && (title.startsWith("flybrain") || title.startsWith("t1-head")))
+					imp.setSlice(imp.getStackSize()/2);
+			}
+			return;
+		}
+		
+		GenericDialog gd = new GenericDialog("Enter a URL");
+		gd.setInsets(10, 32, 0);
+		gd.addMessage("Enter URL of an image, macro or web page", null, Color.darkGray);
+		gd.addStringField("URL:", url, 45);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		url = gd.getNextString();
+		url = url.trim();
+		if (url.indexOf("://")==-1)
+			url = "http://" + url;
+		if (url.endsWith("/"))
+			IJ.runPlugIn("ij.plugin.BrowserLauncher", url.substring(0, url.length()-1));
+		else if (url.endsWith(".html") || url.endsWith(".htm") || url.endsWith(".pdf") ||  url.indexOf(".html#")>0 || noExtension(url))
+			IJ.runPlugIn("ij.plugin.BrowserLauncher", url);
+		else if (url.endsWith(".txt")||url.endsWith(".ijm")||url.endsWith(".js")||url.endsWith(".java"))
+			openTextFile(url, false);
+		else if (url.endsWith(".jar")||url.endsWith(".class"))
+			IJ.open(url);
+		else {
+			IJ.showStatus("Opening: " + url);
+			double startTime = System.currentTimeMillis();
+			ImagePlus imp = new ImagePlus(url);
+			WindowManager.checkForDuplicateName = true;
+			FileInfo fi = imp.getOriginalFileInfo();
+			if (fi!=null && fi.fileType==FileInfo.RGB48)
+				imp = new CompositeImage(imp, IJ.COMPOSITE);
+			else if (imp.getNChannels()>1 && fi!=null && fi.description!=null && fi.description.indexOf("mode=")!=-1) {
+				int mode = IJ.COLOR;
+				if (fi.description.indexOf("mode=composite")!=-1)
+					mode = IJ.COMPOSITE;
+				else if (fi.description.indexOf("mode=gray")!=-1)
+					mode = IJ.GRAYSCALE;
+				imp = new CompositeImage(imp, mode);
+			}
+			if (fi!=null && (fi.url==null || fi.url.length()==0)) {
+				fi.url = url;
+				imp.setFileInfo(fi);
+			}
+			imp.show(Opener.getLoadRate(startTime,imp));
+		}
+		IJ.register(URLOpener.class);  // keeps this class from being GC'd
+	}
+	
+	boolean noExtension(String url) {
+		int lastSlash = url.lastIndexOf("/");
+		if (lastSlash==-1) lastSlash = 0;
+		int lastDot = url.lastIndexOf(".");
+		if (lastDot==-1 || lastDot<lastSlash || (url.length()-lastDot)>6)
+			return true;  // no extension
+		else
+			return false;
+	}
+	
+	void openTextFile(String urlString, boolean install) {
+		StringBuffer sb = null;
+		try {
+			URL url = new URL(urlString);
+			InputStream in = url.openStream();
+			BufferedReader br = new BufferedReader(new InputStreamReader(in));
+			sb = new StringBuffer() ;
+			String line;
+			while ((line=br.readLine()) != null)
+				sb.append (line + "\n");
+			in.close ();
+		} catch (IOException e) {
+			if  (!(install&&urlString.endsWith("StartupMacros.txt")))
+				IJ.error("URL Opener", ""+e);
+			sb = null;
+		}
+		if (sb!=null) {
+			if (install)
+				(new MacroInstaller()).install(new String(sb));
+			else {
+				int index = urlString.lastIndexOf("/");
+				if (index!=-1 && index<=urlString.length()-1)
+					urlString = urlString.substring(index+1);
+				(new Editor()).create(urlString, new String(sb));
+			}
+		}
+	}
+	
+	private void cacheSampleImages() {
+		String[] names = getSampleImageNames();
+		int n = names.length;
+		if (n==0) return;
+		String dir = IJ.getDirectory("imagej")+"samples";
+		File f = new File(dir);
+		if (!f.exists()) {
+			boolean ok = f.mkdir();
+			if (!ok) {
+				IJ.error("Unable to create directory:\n \n"+dir);
+				return;
+			}
+		}
+		IJ.resetEscape();
+		for (int i=0; i<n; i++) {
+			IJ.showStatus((i+1)+"/"+n+" ("+names[i]+")");
+			String url = Prefs. getImagesURL()+names[i];
+			byte[] data = PluginInstaller.download(url, null);
+			if (data==null) continue;
+			f = new File(dir,names[i]);
+			try {
+				FileOutputStream out = new FileOutputStream(f);
+				out.write(data, 0, data.length);
+				out.close();
+			} catch (IOException e) {
+				IJ.log(names[i]+": "+e);
+			}
+			if (IJ.escapePressed())
+				{IJ.beep(); break;};
+		}
+		IJ.showStatus("");
+	}
+	 
+	public static String[] getSampleImageNames() {
+		ArrayList list = new ArrayList();
+		Hashtable commands = Menus.getCommands();
+		Menu samplesMenu = Menus.getImageJMenu("File>Open Samples");
+		if (samplesMenu==null)
+			return new String[0];
+		for (int i=0; i<samplesMenu.getItemCount(); i++) {
+			MenuItem menuItem = samplesMenu.getItem(i);
+			if (menuItem.getActionListeners().length == 0) continue; // separator?
+			String label = menuItem.getLabel();
+			if (label.contains("Cache Sample Images")) continue;
+			String command = (String)commands.get(label);
+			if (command==null) continue;
+			String[] items = command.split("\"");
+			if (items.length!=3) continue;
+			String name = items[1];
+			list.add(name);
+		}
+		return (String[])list.toArray(new String[list.size()]);
+	}
+
+}
diff --git a/src/ij/plugin/WandToolOptions.java b/src/ij/plugin/WandToolOptions.java
new file mode 100644
index 0000000..0154224
--- /dev/null
+++ b/src/ij/plugin/WandToolOptions.java
@@ -0,0 +1,79 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.io.*;
+import ij.plugin.filter.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Vector;
+
+/** This plugin implements the Edit/Options/Wand Tool command. */
+public class WandToolOptions implements PlugIn, DialogListener {
+	private static final String[] modes = {"Legacy", "4-connected", "8-connected"};
+	private static String mode = modes[0];
+	private static double tolerance;
+	private ImagePlus imp;
+	private boolean showCheckbox;
+	private static int startx, starty;
+	private static int ID;
+
+ 	public void run(String arg) {
+ 		imp = WindowManager.getCurrentImage();
+ 		Roi roi = imp!=null?imp.getRoi():null;
+ 		boolean selection = roi!=null && (roi.getType()==Roi.TRACED_ROI||roi.getType()==Roi.POLYGON);
+ 		if (imp==null || (ID!=0&&imp.getID()!=ID) || !selection)
+ 			startx = starty = 0;
+ 		ID = imp!=null?imp.getID():0;
+ 		double sliderMax = 255;
+ 		int depth = imp!=null?imp.getBitDepth():0;
+ 		if (depth==16 || depth==32) {
+ 			sliderMax = imp.getProcessor().getMax();
+ 			if (depth==32) sliderMax+=0.0000000001;
+ 		}
+ 		showCheckbox = imp!=null && depth!=24 && WindowManager.getFrame("Threshold")==null && !imp.isThreshold();
+		GenericDialog gd = new GenericDialog("Wand Tool");
+		gd.addSlider("Tolerance: ", 0, sliderMax, tolerance);
+		gd.addChoice("Mode:", modes, mode);
+		if (showCheckbox)
+			gd.addCheckbox("Enable Thresholding", false);
+		gd.addCheckbox("Smooth if thresholded", Prefs.smoothWand);
+		if (showCheckbox) {
+			gd.setInsets(2,0,0);
+			gd.addMessage("Thresholded objects are traced and \"Tolerance\"\nis ignored when thresholding is enabled.");
+		}
+		gd.addDialogListener(this); 
+		gd.showDialog();
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (gd.wasCanceled())
+			return false;
+		tolerance = gd.getNextNumber();
+		mode = gd.getNextChoice();
+		if (showCheckbox) {
+			if (gd.getNextBoolean()) {
+				imp.deleteRoi();
+				IJ.run("Threshold...");
+			}
+		}
+		Prefs.smoothWand = gd.getNextBoolean();
+		if (startx>0||starty>0)
+			IJ.doWand(startx, starty, tolerance, mode+(Prefs.smoothWand?" smooth":""));
+		return true;
+	}
+
+	public static String getMode() {
+		return mode;
+	}
+
+	public static double getTolerance() {
+		return tolerance;
+	}
+	
+	public static final void setStart(int x, int y) {
+		startx = x;
+		starty = y;
+	}
+
+}
diff --git a/src/ij/plugin/WindowOrganizer.java b/src/ij/plugin/WindowOrganizer.java
new file mode 100644
index 0000000..04dcf6f
--- /dev/null
+++ b/src/ij/plugin/WindowOrganizer.java
@@ -0,0 +1,184 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.frame.ThresholdAdjuster;
+import java.awt.*;
+
+/** This class implements the Window menu's "Show All", "Main Window", "Cascade" and "Tile" commands. */
+public class WindowOrganizer implements PlugIn {
+
+	private static final int XSTART=4, YSTART=94, XOFFSET=8, YOFFSET=24,MAXSTEP=200,GAP=2;
+	private int titlebarHeight = IJ.isMacintosh()?40:20;
+
+	public void run(String arg) {
+		if (arg.equals("imagej"))
+			{showImageJ(); return;}
+		int[] wList = WindowManager.getIDList();
+		if (arg.equals("show"))
+			{showAll(wList); return;}
+		if (wList==null) {
+			IJ.noImage();
+			return;
+		}
+		if (arg.equals("tile"))
+			tileWindows(wList);
+		else
+			cascadeWindows(wList);
+	}
+	
+	void tileWindows(int[] wList) {
+		Rectangle screen = GUI.getMaxWindowBounds(IJ.getInstance());
+		int minWidth = Integer.MAX_VALUE;
+		int minHeight = Integer.MAX_VALUE;
+		boolean allSameSize = true;
+		int width=0, height=0;
+		double totalWidth = 0;
+		double totalHeight = 0;
+		for (int i=0; i<wList.length; i++) {
+			ImageWindow win = getWindow(wList[i]);
+			if (win==null)
+				continue;
+			if (win instanceof PlotWindow && !((PlotWindow)win).getPlot().isFrozen()) {
+				IJ.error("Tile", "Unfrozen plot windows cannot be tiled.");
+				return;
+			}
+			Dimension d = win.getSize();
+			int w = d.width;
+			int h = d.height + titlebarHeight;
+			if (i==0) {
+				width = w;
+				height = h;
+			}
+			if (w!=width || h!=height)
+				allSameSize = false;
+			if (w<minWidth)
+				minWidth = w;
+			if (h<minHeight)
+				minHeight = h;
+			totalWidth += w;
+			totalHeight += h;
+		}
+		int nPics = wList.length;
+		double averageWidth = totalWidth/nPics;
+		double averageHeight = totalHeight/nPics;
+		int tileWidth = (int)averageWidth;
+		int tileHeight = (int)averageHeight;
+ 		int hspace = screen.width - 2 * GAP;
+		if (tileWidth>hspace)
+			tileWidth = hspace;
+		int vspace = screen.height - YSTART;
+		if (tileHeight>vspace)
+			tileHeight = vspace;
+		int hloc, vloc;
+		boolean theyFit;
+		do {
+			hloc = XSTART;
+			vloc = YSTART;
+			theyFit = true;
+			int i = 0;
+			do {
+				i++;
+				if (hloc+tileWidth>screen.width) {
+					hloc = XSTART;
+					vloc = vloc + tileHeight;
+					if (vloc+tileHeight> screen.height)
+						theyFit = false;
+				}
+				hloc = hloc + tileWidth + GAP;
+			} while (theyFit && (i<nPics));
+			if (!theyFit) {
+				tileWidth = (int)(tileWidth*0.98 +0.5);
+				tileHeight = (int)(tileHeight*0.98+0.5);
+			}
+		} while (!theyFit);
+		int nColumns = (screen.width-XSTART)/(tileWidth+GAP);
+		int nRows = nPics/nColumns;
+		if ((nPics%nColumns)!=0)
+			nRows++;
+		hloc = XSTART;
+		vloc = YSTART;
+		
+		for (int i=0; i<nPics; i++) {
+			if (hloc+tileWidth>screen.width) {
+				hloc = XSTART;
+				vloc = vloc + tileHeight;
+			}
+			ImageWindow win = getWindow(wList[i]);
+			if (win!=null) {
+				win.setLocation(hloc + screen.x, vloc + screen.y);
+				ImageCanvas canvas = win.getCanvas();
+				while (win.getSize().width*0.85>=tileWidth && canvas.getMagnification()>0.03125)
+					canvas.zoomOut(0, 0);
+				win.toFront();
+				ImagePlus imp = win.getImagePlus();
+				if (imp!=null) imp.setIJMenuBar(i==nPics-1);
+			}
+			hloc += tileWidth + GAP;
+		}
+	}
+
+	ImageWindow getWindow(int id) {
+		ImageWindow win = null;
+		ImagePlus imp = WindowManager.getImage(id);
+		if (imp!=null)
+			win = imp.getWindow();
+		return win;
+	}		
+			
+	void cascadeWindows(int[] wList) {
+		Rectangle screen = GUI.getMaxWindowBounds(IJ.getInstance());
+		int x = XSTART;
+		int y = YSTART;
+		int xstep = 0;
+		int xstart = XSTART;
+		for (int i=0; i<wList.length; i++) {
+			ImageWindow win = getWindow(wList[i]);
+			if (win==null)
+				continue;
+			Dimension d = win.getSize();
+			if (i==0) {
+				xstep = (int)(d.width*0.8);
+				if (xstep>MAXSTEP)
+					xstep = MAXSTEP;
+			}
+			if (y+d.height*0.67>screen.height) {
+				xstart += xstep;
+				if (xstart+d.width*0.67>screen.width)
+					xstart = XSTART+XOFFSET;
+				x = xstart;
+				y = YSTART;
+			}
+			win.setLocation(x + screen.x, y + screen.y);
+			win.toFront();
+				x += XOFFSET;
+			y += YOFFSET;
+			ImagePlus imp = win.getImagePlus();
+			if (imp!=null) imp.setIJMenuBar(i==wList.length-1);
+		}
+	}
+	
+	void showImageJ() {
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null)
+			ij.toFront();
+	}
+
+	void showAll(int[] wList) {
+		if (wList!=null) {
+			for (int i=0; i<wList.length; i++) {
+				ImageWindow win = getWindow(wList[i]);
+				if (win!=null)
+					WindowManager.toFront(win);
+				
+			}
+		}
+		Window[] windows = WindowManager.getAllNonImageWindows();
+		if (windows!=null) {
+			for (int i=0; i<windows.length; i++)
+					WindowManager.toFront(windows[i]);
+		}
+		IJ.getInstance().toFront();
+	}
+
+}
diff --git a/src/ij/plugin/XYCoordinates.java b/src/ij/plugin/XYCoordinates.java
new file mode 100644
index 0000000..dcdb4f8
--- /dev/null
+++ b/src/ij/plugin/XYCoordinates.java
@@ -0,0 +1,174 @@
+package ij.plugin;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.util.Vector;
+import java.io.*;
+import ij.*;
+import ij.process.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.measure.ResultsTable;
+
+
+/** Writes the XY coordinates and pixel values of all non-background 
+	pixels to a tab-delimited text file. Backround is assumed to be the 
+	value of the pixel in the upper left corner of the image. */
+public class XYCoordinates implements PlugIn {
+
+	private static boolean processStack;
+	private static boolean invertY;
+	private static boolean suppress;
+
+	public void run(String arg) {
+		ImagePlus imp = IJ.getImage();
+		Roi roi = imp.getRoi();
+		String options = Macro.getOptions();
+		boolean legacyMacro = IJ.isMacro() && options!=null && options.contains("background=");
+		if (roi!=null && roi.isArea() && !legacyMacro) {
+			saveSelectionCoordinates(imp);
+			return;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		double background = ip.getPixelValue(0,0);
+		String bg = " \n";
+		boolean rgb = imp.getBitDepth()==24;
+		if (rgb) {
+			int c = ip.getPixel(0,0);
+			int r = (c&0xff0000)>>16;
+			int g = (c&0xff00)>>8;
+			int b = c&0xff;
+			bg = r+","+g+","+b;
+		    bg = " \n    Background value: " + bg + "\n";
+		}
+		imp.deleteRoi();
+		
+		int slices = imp.getStackSize();
+		String msg =
+			"This plugin writes to a text file the XY coordinates and\n"
+			+ "pixel value of all non-background pixels. Backround\n"
+			+ "defaults to be the value of the pixel in the upper\n"
+			+ "left corner of the image.\n \n"
+			+ "If there is a selection, this dialog is skipped and the\n"
+			+ "coordinates and values of pixels in the selection are saved.\n";
+				
+		GenericDialog gd = new GenericDialog("Save XY Coordinates");
+		gd.setInsets(0, 20, 0);
+		gd.addMessage(msg, null, Color.darkGray);
+		int digits = (int)background==background?0:4;
+		if (!rgb) {
+			gd.setInsets(5, 35, 3);
+			gd.addNumericField("Background value:", background, digits);
+		}
+		gd.setInsets(10, 35, 0);
+		gd.addCheckbox("Invert y coordinates off (0 at top of image)", invertY);
+		gd.setInsets(0, 35, 0);
+		gd.addCheckbox("Suppress Log output", suppress);
+		if (slices>1) {
+			gd.setInsets(0, 35, 0);
+			gd.addCheckbox("Process all "+slices+" images", processStack);
+		}
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		if (!rgb)
+			background = gd.getNextNumber();
+		invertY = gd.getNextBoolean();
+		suppress = gd.getNextBoolean();
+		if (slices>1)
+			processStack = gd.getNextBoolean();
+		else
+			processStack = false;
+		if (!processStack) slices = 1;
+
+		SaveDialog sd = new SaveDialog("Save Coordinates as Text...", imp.getTitle(), ".txt");
+		String name = sd.getFileName();
+		if (name == null)
+			return;
+		String directory = sd.getDirectory();
+		PrintWriter pw = null;
+		try {
+			FileOutputStream fos = new FileOutputStream(directory+name);
+			BufferedOutputStream bos = new BufferedOutputStream(fos);
+			pw = new PrintWriter(bos);
+		}
+		catch (IOException e) {
+			IJ.error("Save XY Coordinates", "Error saving coordinates:\n   "+e.getMessage());
+			return;
+		}
+
+		IJ.showStatus("Saving coordinates...");
+		int count = 0;
+		float v;
+		int c,r,g,b;
+		int type = imp.getType();
+		ImageStack stack = imp.getStack();
+		boolean nanBackground = Double.isNaN(background);
+		for (int z=0; z<slices; z++) {
+			if (slices>1) ip = stack.getProcessor(z+1);
+			String zstr = slices>1?z+"\t":"";
+			for (int i=0; i<height; i++) {
+				int y = invertY?i:height-1-i;
+				for (int x=0; x<width; x++) {
+					v = ip.getPixelValue(x,y);
+					if (v!=background && !(nanBackground&&Double.isNaN(v))) {
+						if (type==ImagePlus.GRAY32)
+							pw.println(x+"\t"+(invertY?y:height-1-y)+"\t"+zstr+v);
+						else if (rgb) {
+							c = ip.getPixel(x,y);
+							r = (c&0xff0000)>>16;
+							g = (c&0xff00)>>8;
+							b = c&0xff;
+							pw.println(x+"\t"+(invertY?y:height-1-y)+"\t"+zstr+r+"\t"+g+"\t"+b);
+						} else
+							pw.println(x+"\t"+(invertY?y:height-1-y)+"\t"+zstr+(int)v);
+						count++;
+					}
+				} // x
+				if (slices==1&&y%10==0) IJ.showProgress((double)(height-y)/height);
+			} // y
+			if (slices>1) IJ.showProgress(z+1, slices);
+			String img = slices>1?"-"+(z+1):"";
+			if (!suppress)
+				IJ.log(imp.getTitle() + img+": " + count + " pixels (" + IJ.d2s(count*100.0/(width*height)) + "%)\n");
+			count = 0;
+		} // z
+		IJ.showProgress(1.0);
+		IJ.showStatus("");
+		pw.close();
+	}
+	
+	private void saveSelectionCoordinates(ImagePlus imp) {
+		SaveDialog sd = new SaveDialog("Save Coordinates as Text...", imp.getTitle(), ".csv");
+		String name = sd.getFileName();
+		if (name == null)
+			return;
+		String dir = sd.getDirectory();
+		Roi roi = imp.getRoi();
+		ImageProcessor ip = imp.getProcessor();
+		ImageProcessor mask = roi.getMask();
+		Rectangle r = roi.getBounds();
+		ResultsTable rt = new ResultsTable();
+		boolean rgb = imp.getBitDepth()==24;
+		for (int y=0; y<r.height; y++) {
+			for (int x=0; x<r.width; x++) {
+				if (mask==null || mask.getPixel(x,y)!=0) {
+					rt.incrementCounter();
+					rt.addValue("X", r.x+x);
+					rt.addValue("Y", r.y+y);
+					if (rgb) {
+						int c = ip.getPixel(r.x+x,r.y+y);
+						rt.addValue("Red", (c&0xff0000)>>16);
+						rt.addValue("Green", (c&0xff00)>>8);
+						rt.addValue("Blue", c&0xff);
+					} else
+						rt.addValue("Value", ip.getPixelValue(r.x+x,r.y+y));
+				}
+			}
+		}
+		rt.save(dir+name);
+	}
+
+}
diff --git a/src/ij/plugin/XY_Reader.java b/src/ij/plugin/XY_Reader.java
new file mode 100644
index 0000000..63ee71f
--- /dev/null
+++ b/src/ij/plugin/XY_Reader.java
@@ -0,0 +1,58 @@
+package ij.plugin;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.measure.*;
+import ij.plugin.TextReader;
+
+/** This plugin implements the File/Import/XY Coordinates command. It reads a
+	two column text file, such as those created by File/Save As/XY Coordinates,
+	as a polygon ROI. The ROI is displayed in the current image or, if the image
+	is too small, in a new blank image.
+*/
+public class XY_Reader implements PlugIn {
+
+	public void run(String arg) {
+		TextReader tr = new TextReader();
+		ImageProcessor ip = tr.open();
+		if (ip==null)
+			return;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		if (width!=2 || height<3) {
+			IJ.showMessage("XY Reader", "Two column text file required");
+			return;
+		}
+		float[] x = new float[height];
+		float[] y = new float[height];
+		boolean allIntegers = true;
+		double length = 0.0;
+		for (int i=0; i<height; i++) {
+			x[i] = ip.getf(0, i);
+			y[i] = ip.getf(1, i);
+			if ((int)x[i]!=x[i] || (int)y[i]!=y[i])
+				allIntegers = false;
+			if (i>0) {
+				double dx = x[i] - x[i-1];
+				double dy = y[i] - y[i-1];
+				length += Math.sqrt(dx*dx+dy*dy);
+			}
+		}
+		Roi roi = null;
+		int type = length/x.length>10?Roi.POLYGON:Roi.FREEROI;
+		if (allIntegers)
+			roi = new PolygonRoi(Roi.toIntR(x), Roi.toIntR(y), height, type);
+		else
+			roi = new PolygonRoi(x, y, height, type);
+		Rectangle r = roi.getBoundingRect();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getWidth()<r.x+r.width || imp.getHeight()<r.y+r.height) {
+			new ImagePlus(tr.getName(), new ByteProcessor(Math.abs(r.x)+r.width+10, Math.abs(r.y)+r.height+10)).show();
+			imp = WindowManager.getCurrentImage();
+		}
+		if (imp!=null)
+			imp.setRoi(roi);
+	}
+	
+}
diff --git a/src/ij/plugin/ZAxisProfiler.java b/src/ij/plugin/ZAxisProfiler.java
new file mode 100644
index 0000000..ffbd96c
--- /dev/null
+++ b/src/ij/plugin/ZAxisProfiler.java
@@ -0,0 +1,261 @@
+package ij.plugin;
+import ij.plugin.*;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.filter.Analyzer;
+import ij.util.Tools;
+import java.awt.*;
+
+/** Implements the Image/Stacks/Plot Z-axis Profile command, 
+	which plots the selection mean gray value versus slice number.
+*/
+public class ZAxisProfiler implements PlugIn, Measurements, PlotMaker {
+	private static String[] choices = {"time", "z-axis"};
+	private static String choice = choices[0];
+	private boolean showingDialog;
+	private ImagePlus imp;
+	private boolean isPlotMaker;
+	private boolean timeProfile;
+	private boolean firstTime = true;
+	private String options;
+	
+	/** Returns a Plot of the selection mean gray value versus slice number. */
+	public static Plot getPlot(ImagePlus imp) {
+		return getPlot(imp, "time");
+	}
+
+	/** Returns a Plot of the selection mean versus slice number for the
+		specified hyperstack, where 'options' can be "time" or "z-axis". */
+	public static Plot getPlot(ImagePlus imp, String options) {
+		ZAxisProfiler zap = new ZAxisProfiler();
+		zap.imp = imp;
+		zap.options = options;
+		zap.isPlotMaker = true;
+		Plot plot = zap.getPlot();
+		return plot;
+	}
+
+	public void run(String arg) {
+		imp = IJ.getImage();
+		if (imp.getStackSize()<2) {
+			IJ.error("ZAxisProfiler", "This command requires a stack.");
+			return;
+		}
+		isPlotMaker = true;
+		Plot plot = getPlot();
+		if (plot!=null) {
+			if (isPlotMaker)
+				plot.setPlotMaker(this);
+			plot.show();
+		}
+	}
+		
+	public Plot getPlot() {
+		Roi roi = imp.getRoi();
+		ImageProcessor ip = imp.getProcessor();
+		double minThreshold = ip.getMinThreshold();
+		double maxThreshold = ip.getMaxThreshold();
+		float[] y;
+		boolean hyperstack = imp.isHyperStack();
+		if (hyperstack)
+			y = getHyperstackProfile(roi, minThreshold, maxThreshold);
+		else
+			y = getZAxisProfile(roi, minThreshold, maxThreshold);
+		if (y==null)
+			return null;
+		float[] x = new float[y.length];
+		
+		String xAxisLabel = showingDialog&&choice.equals(choices[0])?"Frame":"Slice";
+		Calibration cal = imp.getCalibration();
+		if (cal.scaled()) {
+			double c = 1.0f;
+			double origin = 0;
+			if (timeProfile) {
+				c = (float) cal.frameInterval;
+				boolean zeroInterval = c==0;
+				if (zeroInterval)
+					c = 1;
+				String timeUnit = zeroInterval?"Frame":"["+cal.getTimeUnit()+"]";
+				xAxisLabel = timeUnit;
+			} else {
+				c = (float) cal.pixelDepth;
+				boolean zeroDepth = c==0;
+				if (zeroDepth)
+					c = 1;
+				origin = cal.zOrigin;
+				String depthUnit = zeroDepth?"Slice":"["+cal.getZUnit()+"]";
+				xAxisLabel = depthUnit;
+			}
+			for (int i=0; i<x.length; i++)
+				x[i] = (float)((i-cal.zOrigin)*c);
+		} else {
+			for (int i=0; i<x.length; i++)
+				x[i] = i+1;
+		}
+		String title;
+		if (roi!=null) {
+			Rectangle r = roi.getBounds();
+			title = imp.getTitle()+"-"+r.x+"-"+r.y;
+		} else
+			title = imp.getTitle()+"-0-0";
+		//String xAxisLabel = showingDialog&&choice.equals(choices[0])?"Frame":"Slice";
+		Plot plot = new Plot(title, xAxisLabel, "Mean", x, y);
+		if (x.length<=60) {
+			plot.setColor(Color.red);
+			plot.addPoints(x, y, Plot.CIRCLE);
+			plot.setColor(Color.black);
+		}
+		double ymin = ProfilePlot.getFixedMin();
+		double ymax= ProfilePlot.getFixedMax();
+		if (!(ymin==0.0 && ymax==0.0)) {
+			double[] a = Tools.getMinMax(x);
+			double xmin=a[0]; double xmax=a[1];
+			plot.setLimits(xmin, xmax, ymin, ymax);
+		}
+		if (!firstTime) {
+			int pos = imp.getCurrentSlice();
+			int size = imp.getStackSize();
+			if (hyperstack) {
+				if (timeProfile) {
+					pos = imp.getT();
+					size = imp.getNFrames();
+				} else {
+					pos = imp.getZ();
+					size = imp.getNSlices();
+				}
+			}
+			double xx = (pos-1.0)/(size-1.0);
+			if (xx==0.0)
+				plot.setLineWidth(2);
+			plot.setColor(Color.blue);
+			plot.drawNormalizedLine(xx, 0, xx, 1.0);
+			plot.setColor(Color.black);
+			plot.setLineWidth(1);
+		}
+		firstTime = false;
+		return plot;
+	}
+	
+	public ImagePlus getSourceImage() {
+		return imp;
+	}
+
+	private float[] getHyperstackProfile(Roi roi, double minThreshold, double maxThreshold) {
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int c = imp.getC();
+		int z = imp.getZ();
+		int t = imp.getT();
+		int size = slices;
+		if (firstTime)
+			timeProfile = slices==1 && frames>1;
+		if (options==null && slices>1 && frames>1 && (!isPlotMaker ||firstTime)) {
+			showingDialog = true;
+			GenericDialog gd = new GenericDialog("Profiler");
+			gd.addChoice("Profile", choices, choice);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return null;
+			choice = gd.getNextChoice();
+			timeProfile = choice.equals(choices[0]);
+		}
+		if (options!=null)
+			timeProfile = frames>1 && !options.contains("z");
+		if (timeProfile)
+			size = frames;
+		else
+			size = slices;
+		float[] values = new float[size];
+		Calibration cal = imp.getCalibration();
+		ResultsTable rt = new ResultsTable();
+		Analyzer analyzer = new Analyzer(imp, rt);
+		int measurements = Analyzer.getMeasurements();
+		boolean showResults = !isPlotMaker && measurements!=0 && measurements!=LIMIT;
+		measurements |= MEAN;
+		if (showResults) {
+			if (!Analyzer.resetCounter())
+				return null;
+		}
+		ImageStack stack = imp.getStack();
+		boolean showProgress = size>400 || stack.isVirtual();
+		for (int i=1; i<=size; i++) {
+			if (showProgress)
+				IJ.showProgress(i,size);
+			int index = 1;
+			if (timeProfile)
+				index = imp.getStackIndex(c, z, i);
+			else
+				index = imp.getStackIndex(c, i, t);
+			ImageProcessor ip = stack.getProcessor(index);
+			if (minThreshold!=ImageProcessor.NO_THRESHOLD)
+				ip.setThreshold(minThreshold,maxThreshold,ImageProcessor.NO_LUT_UPDATE);
+			ip.setRoi(roi);
+			ImageStatistics stats = ImageStatistics.getStatistics(ip, measurements, cal);
+			analyzer.saveResults(stats, roi);
+			values[i-1] = (float)stats.mean;
+		}
+		if (showResults)
+			rt.show("Results");
+		return values;
+	}
+
+	private float[] getZAxisProfile(Roi roi, double minThreshold, double maxThreshold) {
+		ImageStack stack = imp.getStack();
+		if (firstTime) {
+			int slices = imp.getNSlices();
+			int frames = imp.getNFrames();
+			timeProfile = slices==1 && frames>1;
+		}
+		int size = stack.size();
+		boolean showProgress = size>400 || stack.isVirtual();
+		float[] values = new float[size];
+		Calibration cal = imp.getCalibration();
+		ResultsTable rt = new ResultsTable();
+		Analyzer analyzer = new Analyzer(imp, rt);
+		int measurements = Analyzer.getMeasurements();
+		boolean showResults = !isPlotMaker && measurements!=0 && measurements!=LIMIT;
+		boolean showingLabels = firstTime && showResults && ((measurements&LABELS)!=0 || (measurements&SLICE)!=0);
+		measurements |= MEAN;
+		if (showResults) {
+			if (!Analyzer.resetCounter())
+				return null;
+		}
+		boolean isLine = roi!=null && roi.isLine();
+		int current = imp.getCurrentSlice();
+		for (int i=1; i<=size; i++) {
+			if (showProgress)
+				IJ.showProgress(i,size);
+			if (showingLabels)
+				imp.setSlice(i);
+			ImageProcessor ip = stack.getProcessor(i);
+			if (minThreshold!=ImageProcessor.NO_THRESHOLD)
+				ip.setThreshold(minThreshold,maxThreshold,ImageProcessor.NO_LUT_UPDATE);
+			ip.setRoi(roi);
+			ImageStatistics stats = null;
+			if (isLine)
+				stats = getLineStatistics(roi, ip, measurements, cal);
+			else
+				stats = ImageStatistics.getStatistics(ip, measurements, cal);
+			analyzer.saveResults(stats, roi);
+			values[i-1] = (float)stats.mean;
+		}
+		if (showResults)
+			rt.show("Results");
+		if (showingLabels)
+			imp.setSlice(current);
+		return values;
+	}
+	
+	private ImageStatistics getLineStatistics(Roi roi, ImageProcessor ip, int measurements, Calibration cal) {
+		ImagePlus imp = new ImagePlus("", ip);
+		imp.setRoi(roi);
+		ProfilePlot profile = new ProfilePlot(imp);
+		double[] values = profile.getProfile();
+		ImageProcessor ip2 = new FloatProcessor(values.length, 1, values);
+		return ImageStatistics.getStatistics(ip2, measurements, cal);
+	}
+	
+}
+
diff --git a/src/ij/plugin/ZProjector.java b/src/ij/plugin/ZProjector.java
new file mode 100644
index 0000000..514ee15
--- /dev/null
+++ b/src/ij/plugin/ZProjector.java
@@ -0,0 +1,823 @@
+package ij.plugin; 
+import ij.*; 
+import ij.gui.*; 
+import ij.process.*;
+import ij.plugin.filter.*; 
+import ij.plugin.frame.Recorder;
+import ij.measure.Measurements;
+import java.lang.*; 
+import java.awt.*; 
+import java.awt.event.*; 
+import java.util.Arrays;
+
+/** This plugin performs a z-projection of the input stack. Type of
+    output image is same as type of input image.
+    @author Patrick Kelly <phkelly@ucsd.edu>
+*/
+public class ZProjector implements PlugIn {
+    public static final int AVG_METHOD = 0; 
+    public static final int MAX_METHOD = 1;
+    public static final int MIN_METHOD = 2;
+    public static final int SUM_METHOD = 3;
+	public static final int SD_METHOD = 4;
+	public static final int MEDIAN_METHOD = 5;
+	public static final String[] METHODS = 
+		{"Average Intensity", "Max Intensity", "Min Intensity", "Sum Slices", "Standard Deviation", "Median"}; 
+    private static final String METHOD_KEY = "zproject.method";
+    private int method = (int)Prefs.get(METHOD_KEY, AVG_METHOD);
+
+    private static final int BYTE_TYPE  = 0; 
+    private static final int SHORT_TYPE = 1; 
+    private static final int FLOAT_TYPE = 2;
+    
+    public static final String lutMessage =
+    	"Stacks with inverter LUTs may not project correctly.\n"
+    	+"To create a standard LUT, invert the stack (Edit/Invert)\n"
+    	+"and invert the LUT (Image/Lookup Tables/Invert LUT)."; 
+
+    /** Image to hold z-projection. */
+    private ImagePlus projImage = null; 
+
+    /** Image stack to project. */
+    private ImagePlus imp = null; 
+
+    /** Projection starts from this slice. */
+    private int startSlice = 1;
+    /** Projection ends at this slice. */
+    private int stopSlice = 1;
+    /** Project all time points? */
+    private boolean allTimeFrames = true;
+    
+    private String color = "";
+    private boolean isHyperstack;
+    private boolean simpleComposite;
+    private int increment = 1;
+    private int sliceCount;
+
+    public ZProjector() {
+    }
+
+    /** Construction of ZProjector with image to be projected. */
+    public ZProjector(ImagePlus imp) {
+		setImage(imp); 
+    }
+    
+    /** Performs projection on the entire stack using the specified method and returns
+    	 the result, where 'method' is "avg", "min", "max", "sum", "sd" or "median".
+    	 Add " all" to 'method' to project all hyperstack time points. */
+    public static ImagePlus run(ImagePlus imp, String method) {
+    	return run(imp, method, 1, imp.getStackSize());
+    }
+
+	/** Performs projection using the specified method and stack range, and returns
+		 the result, where 'method' is "avg", "min", "max", "sum", "sd" or "median".
+		Add " all" to 'method' to project all hyperstack time points. <br>
+		Example: http://imagej.nih.gov/ij/macros/js/ProjectionDemo.js
+	*/
+	 public static ImagePlus run(ImagePlus imp, String method, int startSlice, int stopSlice) {
+    	ZProjector zp = new ZProjector(imp);
+    	zp.setStartSlice(startSlice);
+    	zp.setStopSlice(stopSlice);
+    	zp.isHyperstack = imp.isHyperStack();
+    	if (zp.isHyperstack && startSlice==1 && stopSlice==imp.getStackSize())
+    		zp.setDefaultBounds();
+    	if (method==null) return null;
+    	method = method.toLowerCase();
+    	int m = -1;
+    	if (method.startsWith("av")) m = AVG_METHOD;
+    	else if (method.startsWith("max")) m = MAX_METHOD;
+    	else if (method.startsWith("min")) m = MIN_METHOD;
+    	else if (method.startsWith("sum")) m = SUM_METHOD;
+    	else if (method.startsWith("sd")) m = SD_METHOD;
+    	else if (method.startsWith("median")) m = MEDIAN_METHOD;
+    	if (m<0)
+    		throw new IllegalArgumentException("Invalid projection method: "+method);
+    	zp.allTimeFrames = method.contains("all");
+    	zp.setMethod(m);
+    	zp.doProjection(true);
+    	return zp.getProjection();
+    }
+
+    /** Explicitly set image to be projected. This is useful if
+	ZProjection_ object is to be used not as a plugin but as a
+	stand alone processing object.  */
+    public void setImage(ImagePlus imp) {
+    	this.imp = imp; 
+		startSlice = 1; 
+		stopSlice = imp.getStackSize(); 
+    }
+
+    public void setStartSlice(int slice) {
+		if (imp==null || slice < 1 || slice > imp.getStackSize())
+	    	return; 
+		startSlice = slice; 
+    }
+
+    public void setStopSlice(int slice) {
+		if (imp==null || slice < 1 || slice > imp.getStackSize())
+	    	return; 
+		stopSlice = slice; 
+    }
+
+	public void setMethod(int projMethod){
+		method = projMethod;
+	}
+    
+    /** Retrieve results of most recent projection operation.*/
+    public ImagePlus getProjection() {
+		return projImage; 
+    }
+
+    public void run(String arg) {
+		imp = IJ.getImage();
+		if (imp==null) {
+	    	IJ.noImage(); 
+	    	return; 
+		}
+
+		//  Make sure input image is a stack.
+		if(imp.getStackSize()==1) {
+	    	IJ.error("Z Project", "Stack required"); 
+	    	return; 
+		}
+	
+		//  Check for inverting LUT.
+		if (imp.getProcessor().isInvertedLut()) {
+	    	if (!IJ.showMessageWithCancel("ZProjection", lutMessage))
+	    		return; 
+		}
+
+		setDefaultBounds();
+			
+		// Build control dialog
+		GenericDialog gd = buildControlDialog(startSlice,stopSlice);
+		gd.showDialog(); 
+		if (gd.wasCanceled()) return; 
+
+		if (!imp.lock()) return;   // exit if in use
+		long tstart = System.currentTimeMillis();
+		gd.setSmartRecording(true);
+		int startSlice2 = startSlice;
+		int stopSlice2 = stopSlice;
+		setStartSlice((int)gd.getNextNumber());
+		setStopSlice((int)gd.getNextNumber()); 
+		boolean rangeChanged = startSlice!=startSlice2 || stopSlice!=stopSlice2;
+		startSlice2 = startSlice;
+		stopSlice2 = stopSlice;
+		gd.setSmartRecording(false);
+		method = gd.getNextChoiceIndex();
+		Prefs.set(METHOD_KEY, method);
+		if (isHyperstack)
+			allTimeFrames = imp.getNFrames()>1&&imp.getNSlices()>1?gd.getNextBoolean():false;
+		doProjection(true); 
+
+		if (arg.equals("") && projImage!=null) {
+			long tstop = System.currentTimeMillis();
+			if (simpleComposite) IJ.run(projImage, "Grays", "");
+			projImage.show("ZProjector: " +IJ.d2s((tstop-tstart)/1000.0,2)+" seconds");
+		}
+
+		imp.unlock();
+		IJ.register(ZProjector.class);
+		if (Recorder.scriptMode()) {
+			String m = getMethodAsString();
+			if (isHyperstack && allTimeFrames)
+				m = m + " all";
+			String range = "";
+			if (rangeChanged)
+				range = ","+startSlice2+","+stopSlice2;
+			Recorder.recordCall("imp = ZProjector.run(imp,\""+m+"\""+range+");");
+		}
+		
+    }
+    
+    private String getMethodAsString() {
+    	switch (method) {
+     		case AVG_METHOD: return "avg";
+    		case MAX_METHOD: return "max";
+    		case MIN_METHOD: return "min";
+    		case SUM_METHOD: return "sum";
+    		case SD_METHOD: return "sd";
+    		case MEDIAN_METHOD: return "median";
+    		default: return "avg";
+    	}
+    }
+    
+    private void setDefaultBounds() {
+		int stackSize = imp.getStackSize();
+    	int channels = imp.getNChannels();
+		int frames = imp.getNFrames();
+		int slices = imp.getNSlices();
+		isHyperstack = imp.isHyperStack()||( ij.macro.Interpreter.isBatchMode()&&((frames>1&&frames<stackSize)||(slices>1&&slices<stackSize)));
+		simpleComposite = channels==stackSize;
+		if (simpleComposite)
+			isHyperstack = false;
+		startSlice = 1; 
+		if (isHyperstack) {
+			int nSlices = imp.getNSlices();
+			if (nSlices>1)
+				stopSlice = nSlices;
+			else
+				stopSlice = imp.getNFrames();
+		} else
+			stopSlice  = stackSize;
+    }
+    
+    public void doRGBProjection() {
+		doRGBProjection(imp.getStack());
+    }
+
+	//Added by Marcel Boeglin 2013.09.23
+	public void doRGBProjection(boolean handleOverlay) {
+		doRGBProjection(imp.getStack());
+		Overlay overlay = imp.getOverlay();
+		if (handleOverlay && overlay!=null)
+			projImage.setOverlay(projectRGBHyperStackRois(overlay));
+	}
+
+    private void doRGBProjection(ImageStack stack) {
+        ImageStack[] channels = ChannelSplitter.splitRGB(stack, true);
+        ImagePlus red = new ImagePlus("Red", channels[0]);
+        ImagePlus green = new ImagePlus("Green", channels[1]);
+        ImagePlus blue = new ImagePlus("Blue", channels[2]);
+        imp.unlock();
+        ImagePlus saveImp = imp;
+        imp = red;
+		color = "(red)"; doProjection();
+		ImagePlus red2 = projImage;
+        imp = green;
+		color = "(green)"; doProjection();
+		ImagePlus green2 = projImage;
+        imp = blue;
+		color = "(blue)"; doProjection();
+		ImagePlus blue2 = projImage;
+        int w = red2.getWidth(), h = red2.getHeight(), d = red2.getStackSize();
+        if (method==SD_METHOD) {
+        	ImageProcessor r = red2.getProcessor();
+        	ImageProcessor g = green2.getProcessor();
+        	ImageProcessor b = blue2.getProcessor();
+        	double max = 0;
+        	double rmax = r.getStats().max; if (rmax>max) max=rmax;
+        	double gmax = g.getStats().max; if (gmax>max) max=gmax;
+        	double bmax = b.getStats().max; if (bmax>max) max=bmax;
+        	double scale = 255/max;
+        	r.multiply(scale); g.multiply(scale); b.multiply(scale);
+        	red2.setProcessor(r.convertToByte(false));
+        	green2.setProcessor(g.convertToByte(false));
+        	blue2.setProcessor(b.convertToByte(false));
+        }
+        RGBStackMerge merge = new RGBStackMerge();
+        ImageStack stack2 = merge.mergeStacks(w, h, d, red2.getStack(), green2.getStack(), blue2.getStack(), true);
+        imp = saveImp;
+        projImage = new ImagePlus(makeTitle(), stack2);
+    }
+
+    /** Builds dialog to query users for projection parameters.
+	@param start starting slice to display
+	@param stop last slice */
+    protected GenericDialog buildControlDialog(int start, int stop) {
+		GenericDialog gd = new GenericDialog("ZProjection"); 
+		gd.addNumericField("Start slice:",startSlice,0/*digits*/); 
+		gd.addNumericField("Stop slice:",stopSlice,0/*digits*/);
+		gd.addChoice("Projection type", METHODS, METHODS[method]); 
+		if (isHyperstack && imp.getNFrames()>1&& imp.getNSlices()>1)
+			gd.addCheckbox("All time frames", allTimeFrames); 
+		return gd; 
+    }
+
+    /** Performs actual projection using specified method. */
+    public void doProjection() {
+		if (imp==null)
+			return;
+		if (imp.getBitDepth()==24) {
+			doRGBProjection();
+			return;
+		}
+		sliceCount = 0;
+		if (method<AVG_METHOD || method>MEDIAN_METHOD)
+			method = AVG_METHOD;
+    	for (int slice=startSlice; slice<=stopSlice; slice+=increment)
+    		sliceCount++;
+		if (method==MEDIAN_METHOD) {
+			projImage = doMedianProjection();
+			return;
+		} 
+		
+		// Create new float processor for projected pixels.
+		FloatProcessor fp = new FloatProcessor(imp.getWidth(),imp.getHeight()); 
+		ImageStack stack = imp.getStack();
+		RayFunction rayFunc = getRayFunction(method, fp);
+		if (IJ.debugMode==true) {
+	    	IJ.log("\nProjecting stack from: "+startSlice
+		     	+" to: "+stopSlice); 
+		}
+
+		// Determine type of input image. Explicit determination of
+		// processor type is required for subsequent pixel
+		// manipulation.  This approach is more efficient than the
+		// more general use of ImageProcessor's getPixelValue and
+		// putPixel methods.
+		int ptype; 
+		if (stack.getProcessor(1) instanceof ByteProcessor) ptype = BYTE_TYPE; 
+		else if (stack.getProcessor(1) instanceof ShortProcessor) ptype = SHORT_TYPE; 
+		else if (stack.getProcessor(1) instanceof FloatProcessor) ptype = FLOAT_TYPE; 
+		else {
+	    	IJ.error("Z Project", "Non-RGB stack required"); 
+	    	return; 
+		}
+
+		// Do the projection
+		int sliceCount = 0;
+		for (int n=startSlice; n<=stopSlice; n+=increment) {
+			if (!isHyperstack) {
+	    		IJ.showStatus("ZProjection " + color +": " + n + "/" + stopSlice);
+	    		IJ.showProgress(n-startSlice, stopSlice-startSlice);
+	    	}
+	    	projectSlice(stack.getPixels(n), rayFunc, ptype);
+	    	sliceCount++;
+		}
+
+		// Finish up projection.
+		if (method==SUM_METHOD) {
+			if (imp.getCalibration().isSigned16Bit())
+				fp.subtract(sliceCount*32768.0);
+			fp.resetMinAndMax();
+			projImage = new ImagePlus(makeTitle(), fp);
+		} else if (method==SD_METHOD) {
+			rayFunc.postProcess();
+			fp.resetMinAndMax();
+			projImage = new ImagePlus(makeTitle(), fp); 
+		} else {
+			rayFunc.postProcess(); 
+			projImage = makeOutputImage(imp, fp, ptype);
+		}
+
+		if(projImage==null)
+	    	IJ.error("Z Project", "Error computing projection.");
+    }
+
+	//Added by Marcel Boeglin 2013.09.23
+	/** Performs actual projection using specified method.
+		If handleOverlay, adds stack overlay 
+		elements from startSlice to stopSlice to projection. */
+	public void doProjection(boolean handleOverlay) {
+		if (isHyperstack)
+			doHyperStackProjection(allTimeFrames);
+		else if (imp.getType()==ImagePlus.COLOR_RGB)
+			doRGBProjection(handleOverlay);
+		else {
+			doProjection();
+			Overlay overlay = imp.getOverlay();
+			if (handleOverlay && overlay!=null)
+				projImage.setOverlay(projectStackRois(overlay));
+		}
+		if (projImage!=null)
+			projImage.setCalibration(imp.getCalibration());
+	}
+	
+	//Added by Marcel Boeglin 2013.09.23
+	private Overlay projectStackRois(Overlay overlay) {
+		if (overlay==null) return null;
+		Overlay overlay2 = overlay.create();
+		Roi roi;
+		int s;
+		for (Roi r : overlay.toArray()) {
+			s = r.getPosition();
+			roi = (Roi)r.clone();
+			if (s>=startSlice && s<=stopSlice || s==0) {
+				roi.setPosition(s);
+				overlay2.add(roi);
+			}
+		}
+		return overlay2;
+	}
+
+	public void doHyperStackProjection(boolean allTimeFrames) {
+		int start = startSlice;
+		int stop = stopSlice;
+		int firstFrame = 1;
+		int lastFrame = imp.getNFrames();
+		if (!allTimeFrames)
+			firstFrame = lastFrame = imp.getFrame();
+		ImageStack stack = new ImageStack(imp.getWidth(), imp.getHeight());
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		if (slices==1) {
+			slices = imp.getNFrames();
+			firstFrame = lastFrame = 1;
+		}
+		int frames = lastFrame-firstFrame+1;
+		increment = channels;
+		boolean rgb = imp.getBitDepth()==24;
+		for (int frame=firstFrame; frame<=lastFrame; frame++) {
+			IJ.showStatus(""+ (frame-firstFrame) + "/" + (lastFrame-firstFrame));
+			IJ.showProgress(frame-firstFrame, lastFrame-firstFrame);
+			for (int channel=1; channel<=channels; channel++) {
+				startSlice = (frame-1)*channels*slices + (start-1)*channels + channel;
+				stopSlice = (frame-1)*channels*slices + (stop-1)*channels + channel;
+				if (rgb)
+					doHSRGBProjection(imp);
+				else
+					doProjection();
+				stack.addSlice(null, projImage.getProcessor());
+			}
+		}
+        projImage = new ImagePlus(makeTitle(), stack);
+        projImage.setDimensions(channels, 1, frames);
+        if (channels>1) {
+           	projImage = new CompositeImage(projImage, 0);
+        	((CompositeImage)projImage).copyLuts(imp);
+      		if (method==SUM_METHOD || method==SD_METHOD)
+        			((CompositeImage)projImage).resetDisplayRanges();
+        }
+        if (frames>1)
+        	projImage.setOpenAsHyperStack(true);
+		Overlay overlay = imp.getOverlay();
+		if (overlay!=null) {
+			startSlice = start;
+			stopSlice = stop;
+			if (imp.getType()==ImagePlus.COLOR_RGB)
+				projImage.setOverlay(projectRGBHyperStackRois(overlay));
+			else
+				projImage.setOverlay(projectHyperStackRois(overlay));
+		}
+        IJ.showProgress(1, 1);
+	}
+	
+	//Added by Marcel Boeglin 2013.09.22
+    private Overlay projectRGBHyperStackRois(Overlay overlay) {
+        if (overlay==null) return null;
+		int frames = projImage.getNFrames();
+		int t1 = imp.getFrame();
+        Overlay overlay2 = overlay.create();
+        Roi roi;
+        int c, z, t;
+		for (Roi r : overlay.toArray()) {
+			c = r.getCPosition();
+			z = r.hasHyperStackPosition()?r.getZPosition():0;
+			t = r.getTPosition();
+			roi = (Roi)r.clone();
+			if (z>=startSlice && z<=stopSlice || z==0 || c==0 || t==0) {
+				if (frames==1 && t!=t1 && t!=0)//current time frame
+					continue;
+				roi.setPosition(t);
+				overlay2.add(roi);
+			}
+		}
+		return overlay2;
+    }
+    
+	//Added by Marcel Boeglin 2013.09.22
+	private Overlay projectHyperStackRois(Overlay overlay) {
+		if (overlay==null) return null;
+		int t1 = imp.getFrame();
+		int channels = projImage.getNChannels();
+		int slices = 1;
+		int frames = projImage.getNFrames();
+		Overlay overlay2 = overlay.create();
+		Roi roi;
+		int c, z, t;
+		int size = channels * slices * frames;
+		for (Roi r : overlay.toArray()) {
+			c = r.getCPosition();
+			z = r.getZPosition();
+			t = r.getTPosition();
+			roi = (Roi)r.clone();
+			if (size==channels) {//current time frame
+				if (z>=startSlice && z<=stopSlice && t==t1 || c==0) {
+					roi.setPosition(c);
+					overlay2.add(roi);
+				}
+			}
+			else if (size==frames*channels) {//all time frames
+				if (z>=startSlice && z<=stopSlice)
+					roi.setPosition(c, 1, t);
+				else if (z==0)
+					roi.setPosition(c, 0, t);
+				else continue;
+				overlay2.add(roi);
+			}
+		}
+		return overlay2;
+	}
+
+	private void doHSRGBProjection(ImagePlus rgbImp) {
+		ImageStack stack = rgbImp.getStack();
+		ImageStack stack2 = new ImageStack(stack.getWidth(), stack.getHeight());
+		for (int i=startSlice; i<=stopSlice; i++)
+			stack2.addSlice(null, stack.getProcessor(i));
+		startSlice = 1;
+		stopSlice = stack2.getSize();
+		doRGBProjection(stack2);
+	}
+
+ 	private RayFunction getRayFunction(int method, FloatProcessor fp) {
+ 		switch (method) {
+ 			case AVG_METHOD: case SUM_METHOD:
+	    		return new AverageIntensity(fp, sliceCount); 
+			case MAX_METHOD:
+	    		return new MaxIntensity(fp);
+	    	case MIN_METHOD:
+	    		return new MinIntensity(fp); 
+			case SD_METHOD:
+	    		return new StandardDeviation(fp, sliceCount); 
+			default:
+	    		IJ.error("Z Project", "Unknown method.");
+	    		return null;
+	    }
+	}
+
+    /** Generate output image whose type is same as input image. */
+    private ImagePlus makeOutputImage(ImagePlus imp, FloatProcessor fp, int ptype) {
+		int width = imp.getWidth(); 
+		int height = imp.getHeight(); 
+		float[] pixels = (float[])fp.getPixels(); 
+		ImageProcessor oip=null; 
+
+		// Create output image consistent w/ type of input image.
+		int size = pixels.length;
+		switch (ptype) {
+			case BYTE_TYPE:
+				oip = imp.getProcessor().createProcessor(width,height);
+				byte[] pixels8 = (byte[])oip.getPixels(); 
+				for (int i=0; i<size; i++)
+					pixels8[i] = (byte)(pixels[i]+0.5f);
+				break;
+			case SHORT_TYPE:
+				oip = imp.getProcessor().createProcessor(width,height);
+				short[] pixels16 = (short[])oip.getPixels(); 
+				for(int i=0; i<size; i++)
+					pixels16[i] = (short)(pixels[i]+0.5f);
+				break;
+			case FLOAT_TYPE:
+				oip = new FloatProcessor(width, height, pixels, null);
+				break;
+		}
+	
+		// Adjust for display.
+	    // Calling this on non-ByteProcessors ensures image
+	    // processor is set up to correctly display image.
+	    oip.resetMinAndMax(); 
+
+		// Create new image plus object. Don't use
+		// ImagePlus.createImagePlus here because there may be
+		// attributes of input image that are not appropriate for
+		// projection.
+		return new ImagePlus(makeTitle(), oip); 
+    }
+
+    /** Handles mechanics of projection by selecting appropriate pixel
+	array type. We do this rather than using more general
+	ImageProcessor getPixelValue() and putPixel() methods because
+	direct manipulation of pixel arrays is much more efficient.  */
+	private void projectSlice(Object pixelArray, RayFunction rayFunc, int ptype) {
+		switch(ptype) {
+			case BYTE_TYPE:
+	    		rayFunc.projectSlice((byte[])pixelArray); 
+	    		break; 
+			case SHORT_TYPE:
+	    		rayFunc.projectSlice((short[])pixelArray); 
+	    		break; 
+			case FLOAT_TYPE:
+	    		rayFunc.projectSlice((float[])pixelArray); 
+	    		break; 
+		}
+    }
+    
+    String makeTitle() {
+    	String prefix = "AVG_";
+ 		switch (method) {
+ 			case SUM_METHOD: prefix = "SUM_"; break;
+			case MAX_METHOD: prefix = "MAX_"; break;
+	    	case MIN_METHOD: prefix = "MIN_"; break;
+			case SD_METHOD:  prefix = "STD_"; break;
+			case MEDIAN_METHOD:  prefix = "MED_"; break;
+	    }
+    	return WindowManager.makeUniqueName(prefix+imp.getTitle());
+    }
+
+	ImagePlus doMedianProjection() {
+		IJ.showStatus("Calculating median...");
+		ImageStack stack = imp.getStack();
+		ImageProcessor[] slices = new ImageProcessor[sliceCount];
+		int index = 0;
+		for (int slice=startSlice; slice<=stopSlice; slice+=increment)
+			slices[index++] = stack.getProcessor(slice);
+		ImageProcessor ip2 = slices[0].duplicate();
+		ip2 = ip2.convertToFloat();
+		float[] values = new float[sliceCount];
+		int width = ip2.getWidth();
+		int height = ip2.getHeight();
+		int inc = Math.max(height/30, 1);
+		for (int y=0; y<height; y++) {
+			if (y%inc==0) IJ.showProgress(y, height-1);
+			for (int x=0; x<width; x++) {
+				for (int i=0; i<sliceCount; i++)
+				values[i] = slices[i].getPixelValue(x, y);
+				ip2.putPixelValue(x, y, median(values));
+			}
+		}
+		if (imp.getBitDepth()==8)
+			ip2 = ip2.convertToByte(false);
+		IJ.showProgress(1, 1);
+		return new ImagePlus(makeTitle(), ip2);
+	}
+
+	float median(float[] a) {
+		Arrays.sort(a);
+		int middle = a.length/2;
+		if ((a.length&1)==0) //even
+			return (a[middle-1] + a[middle])/2f;
+		else
+			return a[middle];
+	}
+
+     /** Abstract class that specifies structure of ray
+	function. Preprocessing should be done in derived class
+	constructors.
+	*/
+    abstract class RayFunction {
+		/** Do actual slice projection for specific data types. */
+		public abstract void projectSlice(byte[] pixels);
+		public abstract void projectSlice(short[] pixels);
+		public abstract void projectSlice(float[] pixels);
+		
+		/** Perform any necessary post processing operations, e.g.
+	    	averging values. */
+		public void postProcess() {}
+
+    } // end RayFunction
+
+
+    /** Compute average intensity projection. */
+    class AverageIntensity extends RayFunction {
+     	private float[] fpixels;
+ 		private int num, len; 
+
+		/** Constructor requires number of slices to be
+	    	projected. This is used to determine average at each
+	    	pixel. */
+		public AverageIntensity(FloatProcessor fp, int num) {
+			fpixels = (float[])fp.getPixels();
+			len = fpixels.length;
+	    	this.num = num;
+		}
+
+		public void projectSlice(byte[] pixels) {
+	    	for(int i=0; i<len; i++)
+				fpixels[i] += (pixels[i]&0xff); 
+		}
+
+		public void projectSlice(short[] pixels) {
+	    	for(int i=0; i<len; i++)
+				fpixels[i] += pixels[i]&0xffff;
+		}
+
+		public void projectSlice(float[] pixels) {
+	    	for(int i=0; i<len; i++)
+				fpixels[i] += pixels[i]; 
+		}
+
+		public void postProcess() {
+			float fnum = num;
+	    	for(int i=0; i<len; i++)
+				fpixels[i] /= fnum;
+		}
+
+    } // end AverageIntensity
+
+
+     /** Compute max intensity projection. */
+    class MaxIntensity extends RayFunction {
+    	private float[] fpixels;
+ 		private int len; 
+
+		/** Simple constructor since no preprocessing is necessary. */
+		public MaxIntensity(FloatProcessor fp) {
+			fpixels = (float[])fp.getPixels();
+			len = fpixels.length;
+			for (int i=0; i<len; i++)
+				fpixels[i] = -Float.MAX_VALUE;
+		}
+
+		public void projectSlice(byte[] pixels) {
+	    	for(int i=0; i<len; i++) {
+				if ((pixels[i]&0xff)>fpixels[i])
+		    		fpixels[i] = (pixels[i]&0xff); 
+	    	}
+		}
+
+		public void projectSlice(short[] pixels) {
+	    	for(int i=0; i<len; i++) {
+				if ((pixels[i]&0xffff)>fpixels[i])
+		    		fpixels[i] = pixels[i]&0xffff;
+	    	}
+		}
+
+		public void projectSlice(float[] pixels) {
+	    	for (int i=0; i<len; i++) {
+				if (!Float.isNaN(pixels[i]) && pixels[i]>fpixels[i])
+		    		fpixels[i] = pixels[i]; 
+	    	}
+		}
+		
+    } // end MaxIntensity
+
+     /** Compute min intensity projection. */
+    class MinIntensity extends RayFunction {
+    	private float[] fpixels;
+ 		private int len; 
+
+		/** Simple constructor since no preprocessing is necessary. */
+		public MinIntensity(FloatProcessor fp) {
+			fpixels = (float[])fp.getPixels();
+			len = fpixels.length;
+			for (int i=0; i<len; i++)
+				fpixels[i] = Float.MAX_VALUE;
+		}
+
+		public void projectSlice(byte[] pixels) {
+	    	for(int i=0; i<len; i++) {
+				if((pixels[i]&0xff)<fpixels[i])
+		    		fpixels[i] = (pixels[i]&0xff); 
+	    	}
+		}
+
+		public void projectSlice(short[] pixels) {
+	    	for(int i=0; i<len; i++) {
+				if((pixels[i]&0xffff)<fpixels[i])
+		    		fpixels[i] = pixels[i]&0xffff;
+	    	}
+		}
+
+		public void projectSlice(float[] pixels) {
+	    	for(int i=0; i<len; i++) {
+				if(pixels[i]<fpixels[i])
+		    		fpixels[i] = pixels[i]; 
+	    	}
+		}
+		
+    } // end MaxIntensity
+
+
+    /** Compute standard deviation projection. */
+    class StandardDeviation extends RayFunction {
+    	private float[] result;
+    	private double[] sum, sum2;
+		private int num,len; 
+
+		public StandardDeviation(FloatProcessor fp, int num) {
+			result = (float[])fp.getPixels();
+			len = result.length;
+		    this.num = num;
+			sum = new double[len];
+			sum2 = new double[len];
+		}
+	
+		public void projectSlice(byte[] pixels) {
+			int v;
+		    for(int i=0; i<len; i++) {
+		    	v = pixels[i]&0xff;
+				sum[i] += v;
+				sum2[i] += v*v;
+			} 
+		}
+	
+		public void projectSlice(short[] pixels) {
+			double v;
+		    for(int i=0; i<len; i++) {
+		    	v = pixels[i]&0xffff;
+				sum[i] += v;
+				sum2[i] += v*v;
+			} 
+		}
+	
+		public void projectSlice(float[] pixels) {
+			double v;
+		    for(int i=0; i<len; i++) {
+		    	v = pixels[i];
+				sum[i] += v;
+				sum2[i] += v*v;
+			} 
+		}
+	
+		public void postProcess() {
+			double stdDev;
+			double n = num;
+		    for(int i=0; i<len; i++) {
+				if (num>1) {
+					stdDev = (n*sum2[i]-sum[i]*sum[i])/n;
+					if (stdDev>0.0)
+						result[i] = (float)Math.sqrt(stdDev/(n-1.0));
+					else
+						result[i] = 0f;
+				} else
+					result[i] = 0f;
+			}
+		}
+
+    } // end StandardDeviation
+
+}  // end ZProjection
+
+
diff --git a/src/ij/plugin/Zoom.java b/src/ij/plugin/Zoom.java
new file mode 100644
index 0000000..ff5061e
--- /dev/null
+++ b/src/ij/plugin/Zoom.java
@@ -0,0 +1,277 @@
+package ij.plugin;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+
+/** This plugin implements the commands in the Image/Zoom submenu. */
+public class Zoom implements PlugIn {
+
+	public static void toSelection(ImagePlus imp) {
+		Zoom zoom = new Zoom();
+		ImageCanvas ic = imp.getCanvas();
+		if (ic!=null)
+			zoom.zoomToSelection(imp, ic);
+	}
+
+	public static void set(ImagePlus imp, double magnification) {
+		Zoom zoom = new Zoom();
+		zoom.setZoom(imp, magnification, -1, -1);
+	}
+
+	public static void set(ImagePlus imp, double magnification, int x, int y) {
+		Zoom zoom = new Zoom();
+		zoom.setZoom(imp, magnification, x, y);
+	}
+	
+	public static void in(ImagePlus imp) {
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null) return;
+		waitUntilActivated(imp);
+		int x = ic.screenX(imp.getWidth()/2);
+		int y = ic.screenY(imp.getHeight()/2);
+		ic.zoomIn(x, y);
+		if (ic.getMagnification()<=1.0)
+			imp.repaintWindow();
+	}
+
+	public static void out(ImagePlus imp) {
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null) return;
+		waitUntilActivated(imp);
+		int x = ic.screenX(imp.getWidth()/2);
+		int y = ic.screenY(imp.getHeight()/2);
+		ic.zoomOut(x, y);
+		if (ic.getMagnification()<=1.0)
+			imp.repaintWindow();
+	}
+
+	public static void unzoom(ImagePlus imp) {
+		ImageCanvas ic = imp.getCanvas();
+		if (ic!=null) {
+			waitUntilActivated(imp);
+			ic.unzoom();
+		}
+	}
+	
+	public static void maximize(ImagePlus imp) {
+		ImageWindow win = imp.getWindow();
+		if (win!=null) {
+			waitUntilActivated(imp);
+			win.maximize();
+			IJ.wait(100);
+		}
+	}
+
+	private static void waitUntilActivated(ImagePlus imp) {
+		int count = 0;
+		boolean isCanvas = imp.getCanvas()!=null;
+		if (isCanvas) {
+			long t0 = System.currentTimeMillis();
+			while (!imp.windowActivated() && (System.currentTimeMillis()-t0)<=1000) {
+				IJ.wait(10);
+				count++;
+			}
+		}
+		if (IJ.debugMode)
+			IJ.log("Zoom: "+ count+" "+imp.windowActivated()+" "+isCanvas+" "+imp);
+    }
+
+	public void run(String arg) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			IJ.noImage();
+			return;
+		}
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null) return;
+		if (ic instanceof PlotCanvas && !((PlotCanvas)ic).isFrozen()) {
+			((PlotCanvas)ic).zoom(arg);
+			return;
+		}
+		Point loc = ic.getCursorLoc();
+		if (!ic.cursorOverImage()) {
+			Rectangle srcRect = ic.getSrcRect();
+			loc.x = srcRect.x + srcRect.width/2;
+			loc.y = srcRect.y + srcRect.height/2;
+		}
+		int x = ic.screenX(loc.x);
+		int y = ic.screenY(loc.y);
+    	if (arg.equals("in")) {
+    		waitUntilActivated(imp);
+			ic.zoomIn(x, y);
+			if (ic.getMagnification()<=1.0)
+				imp.repaintWindow();
+			Recorder.recordCall("Zoom.in(imp);");
+    	} else if (arg.equals("out")) {
+    		waitUntilActivated(imp);
+			ic.zoomOut(x, y);
+			if (ic.getMagnification()<1.0)
+				imp.repaintWindow();
+			Recorder.recordCall("Zoom.out(imp);");
+    	} else if (arg.equals("orig")) {
+			unzoom(imp);
+			Recorder.recordCall("Zoom.unzoom(imp);");
+    	} else if (arg.equals("100%")) {
+    	    waitUntilActivated(imp);
+    		ic.zoom100Percent();
+		} else if (arg.equals("to")) {
+			zoomToSelection(imp, ic);
+			Recorder.recordCall("Zoom.toSelection(imp);");
+		} else if (arg.equals("set")) {
+			setZoom(imp, -1, -1, -1);
+		} else if (arg.equals("max")) {
+			maximize(imp);
+			Recorder.recordCall("Zoom.maximize(imp);");
+		} else if (arg.equals("scale"))
+			scaleToFit(imp);
+	}
+		
+	void zoomToSelection(ImagePlus imp, ImageCanvas ic) {
+		waitUntilActivated(imp);
+		Roi roi = imp.getRoi();
+		ic.unzoom();
+		if (roi==null) return;
+		Rectangle w = imp.getWindow().getBounds();
+		Rectangle r = roi.getBounds();
+		double mag = ic.getMagnification();
+		int marginw = (int)((w.width - mag * imp.getWidth()));
+		int marginh = (int)((w.height - mag * imp.getHeight()));
+		int x = r.x+r.width/2;
+		int y = r.y+r.height/2;
+		mag = ic.getHigherZoomLevel(mag);
+		while (r.width*mag<w.width-marginw && r.height*mag<w.height-marginh) {
+			ic.zoomIn(ic.screenX(x), ic.screenY(y));
+			double cmag = ic.getMagnification();
+			if (cmag==32.0) break;
+			mag = ic.getHigherZoomLevel(cmag);
+			w = imp.getWindow().getBounds();
+		}
+	}
+	
+	/** Based on Albert Cardona's ZoomExact plugin:
+		http://albert.rierol.net/software.html */
+	void setZoom(ImagePlus imp, double mag, int x, int y) {
+		waitUntilActivated(imp);
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null)
+			return;
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		if (x==-1) {
+			x = width/2;
+			y = height/2;
+		}
+		Rectangle srcRect = ic.getSrcRect();
+		Roi roi = imp.getRoi();
+		boolean areaSelection = false;
+		if (roi!=null) {
+			Rectangle bounds = roi.getBounds();
+			x = bounds.x + bounds.width/2;
+			y = bounds.y + bounds.height/2;
+			areaSelection = roi.isArea();
+			if (areaSelection)
+				srcRect = bounds;
+		}
+		ImageWindow win = imp.getWindow();
+		int srcWidth = srcRect.width;
+		int srcHeight = srcRect.height;
+		if (mag==-1) {
+			GenericDialog gd = new GenericDialog("Set Zoom");
+			gd.addNumericField("Zoom:", ic.getMagnification() * 200, 0, 4, "%");
+			gd.addNumericField("X center:", x, 0, 5, "");
+			gd.addNumericField("Y center:", y, 0, 5, "");
+			if (areaSelection) {
+				gd.addNumericField("Width:", srcRect.width, 0, 5, "");
+				gd.addNumericField("Height:", srcRect.height, 0, 5, "");
+			}
+			gd.showDialog();
+			if (gd.wasCanceled()) return;
+			mag = gd.getNextNumber()/100.0;
+			int x2 = (int)gd.getNextNumber();
+			int y2 = (int)gd.getNextNumber();
+			boolean defaultLocation = x==x2 && y==y2;
+			x = x2;
+			y = y2;
+			if (areaSelection) {
+				srcWidth = (int)gd.getNextNumber();
+				srcHeight = (int)gd.getNextNumber();
+			}
+			if (defaultLocation)
+				Recorder.recordCall("Zoom.set(imp, "+mag+");");
+			else
+				Recorder.recordCall("Zoom.set(imp, "+mag+", "+x+", "+y+");");
+		}
+		if (x<0) x=0;
+		if (y<0) y=0;
+		String options = IJ.macroRunning()?Macro.getOptions():null;
+		boolean legacyMacro = areaSelection && options!=null && options.contains("x=") && !options.contains("width=");
+		Rectangle bounds = GUI.getMaxWindowBounds(win);
+		boolean smallImage = mag>1.0 && width*mag<bounds.width && height*mag<bounds.height;
+		if ((areaSelection||smallImage||srcWidth!=srcRect.width||srcHeight!=srcRect.height) && !legacyMacro) {
+			if (areaSelection && roi.getType()==Roi.RECTANGLE)
+				imp.deleteRoi();
+			Insets insets = win.getInsets();
+			int canvasWidth = (int)(srcWidth*mag+insets.right+insets.left+ImageWindow.HGAP*2);
+			int canvasHeight = (int)(srcHeight*mag+insets.top+insets.bottom+ImageWindow.VGAP*2+win.getSliderHeight());
+			ic.setSourceRect(new Rectangle(x-srcWidth/2,y-srcHeight/2,srcWidth,srcHeight));
+			ic.setMagnification(mag);
+			ic.setSize(new Dimension((int)(srcWidth*mag), (int)(srcHeight*mag)));
+			win.setSize(canvasWidth, canvasHeight);
+			return;
+		}
+		if (x>=width) x=width-1;
+		if (y>=height) y=height-1;
+		if (mag<=0.0) mag = 1.0;
+		ic.setMagnification(mag);
+		double newWidth = width*mag;
+		double newHeight = height*mag;
+		Dimension size = ic.getSize();
+		if (newWidth>=size.width && newHeight>=size.height) {
+			srcWidth = (int)Math.round(size.width/mag);
+			srcHeight = (int)Math.round(size.height/mag);
+			if ((int)(srcWidth*mag)<size.width)
+				srcWidth++;
+			if ((int)(srcHeight*mag)<size.height)
+				srcHeight++;
+			x = x-srcWidth/2;
+			y = y-srcHeight/2;
+			if (x+srcWidth>width)
+				x = width - srcWidth;
+			if (y+srcHeight>height)
+				y = height - srcHeight;
+			if (x<0) x=0;
+			if (y<0) y=0;
+			ic.setSourceRect(new Rectangle(x, y, srcWidth, srcHeight));
+		} else {
+			srcWidth = width;
+			srcHeight = height;
+			ic.setSize((int)newWidth, (int)newHeight);
+			ic.setSourceRect(new Rectangle(0, 0, srcWidth, srcHeight));
+			win.pack();
+		}
+		ic.repaint();
+		IJ.wait(100);
+	}
+	
+	private void scaleToFit(ImagePlus imp) {
+		waitUntilActivated(imp);
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null)
+			return;
+		if (ic.getScaleToFit()) {
+			ic.setScaleToFit(false);
+			ic.unzoom();
+			IJ.showStatus("Exiting scale to fit mode (resize with 'alt' key to scale to fit)");
+		} else {
+			ic.setScaleToFit(true);
+			ic.fitToWindow();
+			IJ.showStatus("Resize window to scale (use 'alt' key as shortcut)");
+		}
+
+	}
+	
+}
+
diff --git a/src/ij/plugin/filter/AVI_Writer.java b/src/ij/plugin/filter/AVI_Writer.java
new file mode 100644
index 0000000..e7be93e
--- /dev/null
+++ b/src/ij/plugin/filter/AVI_Writer.java
@@ -0,0 +1,631 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.plugin.Animator;
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import java.util.*;
+import javax.imageio.ImageIO;
+
+/**
+This plugin implements the File/Save As/AVI command.
+Supported formats:
+  Uncompressed 8-bit (gray or indexed color), 24-bit (RGB),
+  JPEG and PNG compression of individual frames
+  16-bit and 32-bit (float) images are converted to 8-bit
+The plugin is based on the FileAvi class written by William Gandler,
+part of Matthew J. McAuliffe's MIPAV program, available from
+http://mipav.cit.nih.gov/.
+2008-06-05: Support for jpeg and png-compressed output and
+composite images by Michael Schmid.
+2015-09-28: Writes AVI 2.0 if the file size would be above approx. 0.9 GB
+
+* The AVI format written looks like this:
+* RIFF AVI            RIFF HEADER, AVI CHUNK					
+*   | LIST hdrl       MAIN AVI HEADER
+*   | | avih          AVI HEADER
+*   | | LIST strl     STREAM LIST(s) (One per stream)
+*   | | | strh        STREAM HEADER (Required after above; fourcc type is 'vids' for video stream)
+*   | | | strf        STREAM FORMAT (for video: BitMapInfo; may also contain palette)
+*   | | | strn        STREAM NAME
+*   | | | indx        MAIN 'AVI 2.0' INDEX of 'ix00' indices
+*   | LIST movi       MOVIE DATA (maximum approx. 0.95 GB)
+*   | | 00db or 00dc  FRAME (b=uncompressed, c=compressed)
+*   | | 00db or 00dc  FRAME
+*   | | ...
+*   | | ix00          AVI 2.0-style index of frames within this 'movi' list
+* RIFF AVIX	          Only if required by size (this is AVI 2.0 extension)
+*   | LIST movi       MOVIE DATA (maximum approx. 0.95 GB)
+*   | | 00db or 00dc  FRAME
+*   | | ...
+*   | | ix00          AVI 2.0-style index of frames within this 'movi' list
+* RIFF AVIX	          further chunks, each approx 0.95 GB (AVI 2.0)
+* ...
+*/
+
+public class AVI_Writer implements PlugInFilter {
+    //four-character codes for compression
+    // Note: byte sequence in four-cc is reversed - ints in Intel (little endian) byte order.
+    // Note that compression codes BI_JPEG=4 and BI_PNG=5 are not understood by avi players
+    // (even not by MediaPlayer, even though these codes are specified by Microsoft).
+    public final static int  NO_COMPRESSION   = 0;            //no compression, also named BITMAPINFO.BI_RGB
+    public final static int  JPEG_COMPRESSION = 0x47504a4d;   //'MJPG' JPEG compression of individual frames
+    public final static int  PNG_COMPRESSION  = 0x20676e70;   //'png ' PNG compression of individual frames
+    private final static int FOURCC_00db = 0x62643030;        //'00db' uncompressed frame
+    private final static int FOURCC_00dc = 0x63643030;        //'00dc' compressed frame
+    private final static int MAX_INDX_SIZE = 3072;            //max length of index of indices 'indx'
+    private final static int JUNK_SIZE_THRESHOLD = 950*1024*1024;   //if size exceeds this, makes a new RIFF AVIX chunk
+    //compression options: dialog parameters
+    private int      compressionIndex = 2; //0=none, 1=PNG, 2=JPEG
+    private static int      jpegQuality = 90;    //0 is worst, 100 best (not currently used)
+    private final static String[] COMPRESSION_STRINGS = new String[] {"None", "PNG", "JPEG"};
+    private final static int[] COMPRESSION_TYPES = new int[] {NO_COMPRESSION, PNG_COMPRESSION, JPEG_COMPRESSION};
+
+    private ImagePlus imp;
+    private RandomAccessFile raFile;
+    private int             xDim,yDim;      //image size
+    private int             zDim;           //number of movie frames (stack size)
+    private int             bytesPerPixel;  //8 or 24
+    private int             frameDataSize;  //in bytes (uncompressed)
+    private int             biCompression;  //compression type (0, 'JPEG, 'PNG')
+    private int             linePad;        //no. of bytes to add for padding of data lines to 4*n length
+    private byte[]          bufferWrite;    //output buffer for image data
+    private BufferedImage   bufferedImage;  //data source for writing compressed images
+    private RaOutputStream  raOutputStream; //output stream for writing compressed images
+    private long[]          sizePointers =  //a stack of the pointers to the chunk sizes (pointers are
+                                new long[5];//  remembered to write the sizes later, when they are known)
+    private int             stackPointer;   //points to first free position in sizePointers stack
+    private int             endHeadPointer; //position of first 'movi' chunk, i.e., end of the space reserved for indx
+    // AVI-2 related:
+    private long            pointer2indx;   //points to main index-of-indices 'indx'
+    private int             nIndxEntries=0; //number of 'indx' entries
+    private long            pointer2indxNEntriesInUse;  //points to 'nEntriesInUse' of 'indx'
+    private long            pointer2indxNextEntry;   //points to next free slot of 'indx'
+
+    public int setup(String arg, ImagePlus imp) {
+        this.imp = imp;
+        return DOES_ALL+NO_CHANGES;
+    }
+
+    /** Asks for the compression type and filename; then saves as AVI file */
+    public void run(ImageProcessor ip) {
+        if (!showDialog(imp)) return;          //compression type dialog
+        SaveDialog sd = new SaveDialog("Save as AVI...", imp.getTitle(), ".avi");
+        String fileName = sd.getFileName();
+        if (fileName == null)
+            return;
+        String fileDir = sd.getDirectory();
+        FileInfo fi = imp.getOriginalFileInfo();
+        if (fi!=null && imp.getStack().isVirtual() && fileDir.equals(fi.directory) && fileName.equals(fi.fileName)) {
+            IJ.error("AVI Writer", "Virtual stacks cannot be saved in place.");
+            return;
+        }
+        try {
+            writeImage(imp, fileDir + fileName, COMPRESSION_TYPES[compressionIndex], jpegQuality);
+            IJ.showStatus("");
+        } catch (IOException e) {
+            IJ.error("AVI Writer", "An error occured writing the file.\n \n" + e);
+        }
+        IJ.showStatus("");
+    }
+
+    private boolean showDialog(ImagePlus imp) {
+    	String options = Macro.getOptions();
+    	if (options!=null) {
+    		if (!options.contains("compression="))
+    			options = "compression=JPEG "+options;
+    		options = options.replace("compression=Uncompressed", "compression=None");
+    		Macro.setOptions(options);
+    	}
+  		double fps = getFrameRate(imp);
+ 		int decimalPlaces = (int) fps == fps?0:1;
+        GenericDialog gd = new GenericDialog("Save as AVI...");
+        gd.addChoice("Compression:", COMPRESSION_STRINGS, COMPRESSION_STRINGS[compressionIndex]);
+		gd.addNumericField("Frame Rate:", fps, decimalPlaces, 3, "fps");
+        gd.showDialog();                            // user input (or reading from macro) happens here
+        if (gd.wasCanceled())                       // dialog cancelled?
+            return false;
+        compressionIndex = gd.getNextChoiceIndex();
+        fps = gd.getNextNumber();
+        if (fps<=0.5) fps = 0.5;
+		imp.getCalibration().fps = fps;
+		return true;
+    }
+
+    /** Writes an ImagePlus (stack) as AVI file. */
+    public void writeImage (ImagePlus imp, String path, int compression, int jpegQuality)
+            throws IOException {
+        if (compression!=NO_COMPRESSION && compression!=JPEG_COMPRESSION && compression!=PNG_COMPRESSION)
+            throw new IllegalArgumentException("Unsupported Compression 0x"+Integer.toHexString(compression));
+        this.biCompression = compression;
+        if (jpegQuality < 0) jpegQuality = 0;
+        if (jpegQuality > 100) jpegQuality = 100;
+        this.jpegQuality = jpegQuality;
+        File file = new File(path);
+        raFile = new RandomAccessFile(file, "rw");
+        raFile.setLength(0);
+        imp.startTiming();
+
+        //  G e t   s t a c k   p r o p e r t i e s
+        boolean isComposite = imp.isComposite();
+        boolean isHyperstack = imp.isHyperStack();
+        boolean isOverlay = imp.getOverlay()!=null && !imp.getHideOverlay();
+        xDim = imp.getWidth();   //image width
+        yDim = imp.getHeight();   //image height
+        zDim = imp.getStackSize(); //number of frames in video
+		boolean saveFrames=false, saveSlices=false, saveChannels=false;
+        int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		int channel = imp.getChannel();
+		int slice = imp.getSlice();
+		int frame = imp.getFrame();
+		if (isHyperstack || isComposite) {
+			if (frames>1) {
+				saveFrames = true;
+				zDim = frames;
+			} else if (slices>1) {
+				saveSlices = true;
+				zDim = slices;
+			} else if (channels>1) {
+				saveChannels = true;
+				zDim = channels;
+			} else
+				isHyperstack = false;
+		}
+
+        if (imp.getType()==ImagePlus.COLOR_RGB || isComposite || biCompression==JPEG_COMPRESSION || isOverlay)
+            bytesPerPixel = 3;  //color and JPEG-compressed files
+        else
+            bytesPerPixel = 1;  //gray 8, 16, 32 bit and indexed color: all written as 8 bit
+        boolean writeLUT = bytesPerPixel==1; // QuickTime reads the avi palette also for PNG
+        linePad = 0;
+        int minLineLength = bytesPerPixel*xDim;
+        if (biCompression==NO_COMPRESSION && minLineLength%4!=0)
+            linePad = 4 - minLineLength%4; //uncompressed lines written must be a multiple of 4 bytes
+        frameDataSize = (bytesPerPixel*xDim+linePad)*yDim;
+        int microSecPerFrame = (int)Math.round((1.0/getFrameRate(imp))*1.0e6);
+        int dwChunkId = biCompression==NO_COMPRESSION ? FOURCC_00db : FOURCC_00dc;
+        long sizeEstimate = bytesPerPixel*xDim*yDim*(long)zDim;
+        //boolean writeAVI2index = true;//frameDataSize*zDim > 1000000000;
+        int nAvixChunksEstimate = (int)(sizeEstimate/JUNK_SIZE_THRESHOLD);  //estimated number of AVIX junks
+        endHeadPointer = 4096+((nAvixChunksEstimate*16+1000)/1024)*1024;    //reserve plenty of space for 'indx'
+
+        //  W r i t e   A V I   f i l e   h e a d e r
+        writeString("RIFF");    // signature
+        chunkSizeHere();        // size of file (nesting level 0)
+        writeString("AVI ");    // RIFF type
+        writeString("LIST");    // first LIST chunk, which contains information on data decoding
+        chunkSizeHere();        // size of LIST (nesting level 1)
+        writeString("hdrl");    // LIST chunk type
+        writeString("avih");    // Write the avih sub-CHUNK
+        writeInt(0x38);         // length of the avih sub-CHUNK (38H) not including the
+                                // the first 8 bytes for avihSignature and the length
+        writeInt(microSecPerFrame); // dwMicroSecPerFrame - Write the microseconds per frame
+        writeInt(0);            // dwMaxBytesPerSec (maximum data rate of the file in bytes per second)
+        writeInt(0);            // dwPaddingGranularity (for header length?), previously dwReserved1, usually set to zero.
+        writeInt(0x10);         // dwFlags - just set the bit for AVIF_HASINDEX
+                                //   10H AVIF_HASINDEX: The AVI file has an idx1 chunk containing
+                                //   an index at the end of the file.  For good performance, all
+                                //   AVI files should contain an index.
+        writeInt(zDim);         // dwTotalFrames - total frame number
+        writeInt(0);            // dwInitialFrames -Initial frame for interleaved files.
+                                // Noninterleaved files should specify 0.
+        writeInt(1);            // dwStreams - number of streams in the file - here 1 video and zero audio.
+        writeInt(0);      // dwSuggestedBufferSize 
+         writeInt(xDim);         // dwWidth - image width in pixels
+        writeInt(yDim);         // dwHeight - image height in pixels
+        writeInt(0);            // dwReserved[4]
+        writeInt(0);
+        writeInt(0);
+        writeInt(0);
+
+        //  W r i t e   s t r e a m   i n f o r m a t i o n
+        writeString("LIST");    // List of stream headers
+        chunkSizeHere();        // size of LIST (nesting level 2)
+        writeString("strl");    // LIST chunk type: stream list
+        writeString("strh");    // stream header 
+        writeInt(56);           // Write the length of the strh sub-CHUNK
+        writeString("vids");    // fccType - type of data stream - here 'vids' for video stream
+        writeString("DIB ");    // 'DIB ' for Microsoft Device Independent Bitmap.
+        writeInt(0);            // dwFlags
+        writeInt(0);            // wPriority, wLanguage
+        writeInt(0);            // dwInitialFrames
+        writeInt(1);            // dwScale
+        writeInt((int)Math.round(getFrameRate(imp))); //  dwRate - frame rate for video streams
+        writeInt(0);            // dwStart - this field is usually set to zero
+        writeInt(zDim);         // dwLength - playing time of AVI file as defined by scale and rate
+                                // Set equal to the number of frames
+        writeInt(0);            // dwSuggestedBufferSize for reading the stream.
+                                // Typically, this contains a value corresponding to the largest chunk
+                                // in a stream.
+        writeInt(-1);           // dwQuality - encoding quality given by an integer between
+                                // 0 and 10,000.  If set to -1, drivers use the default
+                                // quality value.
+        writeInt(0);            // dwSampleSize. 0 means that each frame is in its own chunk
+        writeShort((short)0);   // left of rcFrame if stream has a different size than dwWidth*dwHeight(unused)
+        writeShort((short)0);   // top
+        writeShort((short)0);   // right
+        writeShort((short)0);   // bottom
+        // end of 'strh' chunk, stream format follows
+        writeString("strf");    // stream format chunk
+        chunkSizeHere();        // size of 'strf' chunk (nesting level 3)
+        writeInt(40);           // biSize - Write header size of BITMAPINFO header structure
+                                // Applications should use this size to determine which BITMAPINFO header structure is
+                                // being used.  This size includes this biSize field.
+        writeInt(xDim);         // biWidth - width in pixels
+        writeInt(yDim);         // biHeight - image height in pixels. (May be negative for uncompressed
+                                // video to indicate vertical flip).
+        writeShort(1);          // biPlanes - number of color planes in which the data is stored
+        writeShort((short)(8*bytesPerPixel)); // biBitCount - number of bits per pixel #
+        writeInt(biCompression); // biCompression - type of compression used (uncompressed: NO_COMPRESSION=0)
+        int biSizeImage =       // Image Buffer. Quicktime needs 3 bytes also for 8-bit png
+                (biCompression==NO_COMPRESSION)?0:xDim*yDim*bytesPerPixel;
+        writeInt(biSizeImage);  // biSizeImage (buffer size for decompressed mage) may be 0 for uncompressed data
+        writeInt(0);            // biXPelsPerMeter - horizontal resolution in pixels per meter
+        writeInt(0);            // biYPelsPerMeter - vertical resolution in pixels per meter
+        writeInt(writeLUT ? 256:0); // biClrUsed (color table size; for 8-bit only)
+        writeInt(0);            // biClrImportant - specifies that the first x colors of the color table
+                                // are important to the DIB.  If the rest of the colors are not available,
+                                // the image still retains its meaning in an acceptable manner.  When this
+                                // field is set to zero, all the colors are important, or, rather, their
+                                // relative importance has not been computed.
+        if (writeLUT)           // write color lookup table
+            writeLUT(imp.getProcessor());
+        chunkEndWriteSize();    //'strf' chunk finished (nesting level 3)
+        
+        writeString("strn");    // Use 'strn' to provide a zero terminated text string describing the stream
+        writeInt(16);           // length of the strn sub-CHUNK (must be even)
+        writeString("ImageJ AVI     \0"); //must be 16 bytes as given above (including the terminating 0 byte)
+        pointer2indx = raFile.getFilePointer();
+        writeString("indx");    // 'indx' chunk type: Index of indices
+        chunkSizeHere();        // size of 'indx' (nesting level 3)
+        writeShort(4);          // wLongsPerEntry = 4 ('Longs' are 32-bit here!)
+        writeByte(0);           // bIndexSubType=0
+        writeByte(0);           // bIndexType=0: AVI_INDEX_OF_INDEXES
+        pointer2indxNEntriesInUse = raFile.getFilePointer();
+        writeInt(0);            // nEntriesInUse, will be filled in later
+        writeInt(dwChunkId);    // dwChunkId, '00dc' or '00db'
+        writeInt(0); writeInt(0); writeInt(0); // dwReserved[3]
+        pointer2indxNextEntry = raFile.getFilePointer();
+        chunkEndWriteSize();    //'indx' chunk finished (nesting level 3), will be modified by writeMainIndxEntry
+        writeString("JUNK");    // write a JUNK chunk for padding (will be moved and shortened by writeMainIndxEntry)
+        chunkSizeHere();        // size of 'JUNK' for padding (nesting level 3)
+        raFile.seek(endHeadPointer);      // we continue here
+        chunkEndWriteSize();    // 'JUNK' finished (nesting level 3)
+        chunkEndWriteSize();    // LIST 'strl' finished (nesting level 2)
+        chunkEndWriteSize();    // LIST 'hdrl' finished (nesting level 1)
+
+        //  P r e p a r e   f o r   w r i t i n g   d a t a
+        if (biCompression == NO_COMPRESSION)
+            bufferWrite = new byte[frameDataSize];
+        else
+            raOutputStream = new RaOutputStream(raFile); //needed for writing compressed formats
+        //int maxChunkLength = 0;                 // needed for dwSuggestedBufferSize
+        int[] dataChunkOffset = new int[zDim];  // remember chunk positions...
+        int[] dataChunkLength = new int[zDim];  // ... and sizes for the index
+
+        int currentFilePart = 0;// 0 is inside RIFF AVI (AVI 1.0 compatible), >0 is RIFF AVIX (data chunk of AVI 2.0)
+
+        //  W r i t e   f r a m e   d a t a   a n d   i n d i c e s
+        boolean writeAVI2index = false; // see whether we need an AVI2 index (large files only)
+        int iFrame = 0;
+        while (iFrame < zDim) {
+            if (currentFilePart > 0) {  // open new RIFF AVIX chunk
+                writeString("RIFF");
+                chunkSizeHere();        // size of chunk (nesting level 0)
+                writeString("AVIX");    // RIFF type
+                //IJ.log("AVIX starts at iFrame="+iFrame);
+            }
+            writeString("LIST");        // this LIST chunk contains the AVI-2 style index and the actual data
+            chunkSizeHere();            // size of LIST (nesting level 1)
+            long moviPointer = raFile.getFilePointer();
+            writeString("movi");        // write LIST type 'movi'
+
+            int firstFrameInChunk = iFrame;
+
+            //   W r i t e   s i n g l e   f r a m e
+            while (iFrame<zDim) {
+                if (iFrame %10==0) {
+                    IJ.showProgress(iFrame, zDim);
+                    IJ.showStatus(iFrame+"/"+zDim);
+                }
+                ImageProcessor ip = null;      // get the image to write ...
+                if (isComposite || isHyperstack || isOverlay) {
+                    if (saveFrames)
+                        imp.setPositionWithoutUpdate(channel, slice, iFrame+1);
+                    else if (saveSlices)
+                        imp.setPositionWithoutUpdate(channel, iFrame+1, frame);
+                    else if (saveChannels)
+                        imp.setPositionWithoutUpdate(iFrame+1, slice, frame);
+                    ImagePlus imp2 = imp;
+                    if (isOverlay) {
+                        if (!(saveFrames||saveSlices||saveChannels))
+                            imp.setSliceWithoutUpdate(iFrame+1);
+                        imp2 = imp.flatten();
+                    }
+                    ip = new ColorProcessor(imp2.getImage());
+                } else
+                    ip = zDim==1 ? imp.getProcessor() : imp.getStack().getProcessor(iFrame+1);
+                int chunkPointer = (int)raFile.getFilePointer();
+                writeInt(dwChunkId);            // start writing chunk: '00db' or '00dc'
+                chunkSizeHere();                // size of '00db' or '00dc' chunk (nesting level 2)
+                if (biCompression == NO_COMPRESSION) {
+                    if (bytesPerPixel==1)
+                        writeByteFrame(ip);
+                    else
+                        writeRGBFrame(ip);
+                } else
+                    writeCompressedFrame(ip);
+                dataChunkOffset[iFrame] = (int)(chunkPointer - moviPointer);
+                dataChunkLength[iFrame] = (int)(raFile.getFilePointer() - chunkPointer - 8); //size excludes '00db' and size fields
+                chunkEndWriteSize();            // '00db' or '00dc' chunk finished (nesting level 2)
+                //if (IJ.escapePressed()) {
+                //    IJ.showStatus("Save as Avi INTERRUPTED");
+                //    break;
+                //}
+                iFrame++;
+                if (raFile.getFilePointer() - moviPointer > JUNK_SIZE_THRESHOLD)
+                    break;                      // make sure we don't get over 1GB
+            } // while (iFrame<zDim)
+            int nFramesInChunk = iFrame - firstFrameInChunk;
+
+            //  W r i t e   A V I - 2   I n d e x
+            if (iFrame < zDim)
+                writeAVI2index = true;      //can't write everything the first time? Then we need the AVI 2 format.
+            if (writeAVI2index) {
+                long ix00pointer = raFile.getFilePointer();
+                writeString("ix00");        // AVI 2.0 style index of frames within the chunk
+                chunkSizeHere();            // size of ix00 chunk (nesting level 2)
+                writeShort(2);              // wLongsPerEntry = 2 ('Longs' are 32-bit here!)
+                writeByte(0);               // bIndexSubType=0
+                writeByte(1);               // bIndexType=1: AVI_INDEX_OF_CHUNKS
+                writeInt(nFramesInChunk);   // nEntriesInUse
+                writeInt(dwChunkId);        // dwChunkId, '00dc' or '00db'
+                writeLong(moviPointer);     // qwBaseOffset
+                writeInt(0);                // dwReserved, first two are qwBaseOffset?
+                for (int z=firstFrameInChunk; z<iFrame; z++) {
+                    writeInt(dataChunkOffset[z]+8); //note: AVI--2 index points to chunk data, not chunk header
+                    writeInt(dataChunkLength[z]);   //length without chunk header
+                }
+                //IJ.log("write ix00: frames "+firstFrameInChunk+"-"+(iFrame-1)+" offset "+Long.toHexString(dataChunkOffset[firstFrameInChunk])+"-"+Long.toHexString(dataChunkOffset[iFrame-1]));
+                //enter this ix00 index to index of indices:
+                writeMainIndxEntry(ix00pointer, (int)(raFile.getFilePointer()-ix00pointer), nFramesInChunk);
+
+                chunkEndWriteSize();        // 'ix00' finished (nesting level 2)
+            }
+            chunkEndWriteSize();        // LIST 'movi' finished (nesting level 1)
+
+            //  W r i t e   A V I - 1   I n d e x
+            if (currentFilePart == 0) {
+                writeString("idx1");    // Write the idx1 chunk
+                chunkSizeHere();        // size of 'idx1' chunk (nesting level 1)
+                for (int z = 0; z < iFrame; z++) {
+                    writeInt(dwChunkId);// ckid field: '00db' or '00dc'
+                    writeInt(0x10);     // flags: select AVIIF_KEYFRAME
+                                 // AVIIF_KEYFRAME 0x00000010
+                                 // The flag indicates key frames in the video sequence.
+                                 // Key frames do not need previous video information to be decompressed.
+                                 // AVIIF_NOTIME 0x00000100 The CHUNK does not influence video timing (for
+                                 //   example a palette change CHUNK).
+                                 // AVIIF_LIST 0x00000001 marks a LIST CHUNK.
+                                 // AVIIF_TWOCC 2L
+                                 // AVIIF_COMPUSE 0x0FFF0000 These bits are for compressor use.
+                     writeInt(dataChunkOffset[z]); // offset to the chunk header (not data)
+                                 // offset can be relative to file start or 'movi'
+                     writeInt(dataChunkLength[z]); // length without chunk header
+                }  // for (z = 0; z < zDim; z++)
+                chunkEndWriteSize();    // 'idx1' finished (nesting level 1)
+            }
+            chunkEndWriteSize();    // 'RIFF' File finished (nesting level 0)
+            currentFilePart++;
+        } //while (iFrame < zDim)
+
+        if (!writeAVI2index) {      //delete main AVI 2 index prepared previously
+            raFile.seek(pointer2indx);
+            writeString("JUNK");        // overwrite 'indx'
+            chunkSizeHere();            // size of 'JUNK' for padding goes here
+            raFile.seek(endHeadPointer);// end of the padded range
+            chunkEndWriteSize();        // 'JUNK' finished              
+        }
+
+        raFile.close();
+        IJ.showProgress(1.0);
+		if (isComposite || isHyperstack)
+			imp.setPosition(channel, slice, frame);
+    }
+
+    /** Reserve space to write the size of chunk and remember the position
+     *  for a later call to chunkEndWriteSize().
+     *  Several levels of chunkSizeHere() and chunkEndWriteSize() may be nested.
+     */
+    private void chunkSizeHere() throws IOException {
+        sizePointers[stackPointer] = raFile.getFilePointer();
+        writeInt(0);    //for now, write 0 to reserve space for "size" item
+        stackPointer++;
+    }
+    
+    /** At the end of a chunk, calculate its size and write it to the
+     *  position remembered previously. Also pads to 2-byte boundaries.
+     */
+    private void chunkEndWriteSize() throws IOException {
+        stackPointer--;
+        long position = raFile.getFilePointer();
+        raFile.seek(sizePointers[stackPointer]);
+        writeInt((int)(position - (sizePointers[stackPointer]+4)));
+        raFile.seek(((position+1)/2)*2);    //pad to 2-byte boundary
+        //IJ.log("chunk at 0x"+Long.toHexString(sizePointers[stackPointer]-4)+"-0x"+Long.toHexString(position));
+    }
+
+    /** Enter a local index 'ix00' to 'indx', the index of indices */
+    private void writeMainIndxEntry(long ix00pointer, int dwSize, int nFrames) throws IOException {
+        if (pointer2indxNextEntry + 16 + 8 > MAX_INDX_SIZE) {
+            raFile.close();
+            throw new RuntimeException("AVI_Writer ERROR: Index Size Overflow");
+        }
+        long savePosition = raFile.getFilePointer();
+        raFile.seek(pointer2indxNextEntry);
+        writeLong(ix00pointer);
+        writeInt(dwSize);
+        writeInt(nFrames);
+        pointer2indxNextEntry += 16;
+        nIndxEntries++;
+        writeString("JUNK");        // write a JUNK chunk for padding
+        chunkSizeHere();            // size of 'JUNK' for padding goes here
+        raFile.seek(endHeadPointer);// end of the padded range
+        chunkEndWriteSize();        // 'JUNK' finished (nesting level 3)
+        raFile.seek(pointer2indx+4);
+        writeInt((int)(pointer2indxNextEntry - pointer2indx - 8)); //write new size of 'indx'
+        raFile.seek(pointer2indxNEntriesInUse);
+        writeInt(nIndxEntries);     //write new number of 'indx' entries
+        raFile.seek(savePosition);
+    }
+
+    /** Write Grayscale (or indexed color) data. Lines are  
+     *  padded to a length that is a multiple of 4 bytes. */
+    private void writeByteFrame(ImageProcessor ip) throws IOException {
+        ip = ip.convertToByte(true);
+        byte[] pixels = (byte[])ip.getPixels();
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        int c, offset, index = 0;
+        for (int y=height-1; y>=0; y--) {
+            offset = y*width;
+            for (int x=0; x<width; x++)
+                bufferWrite[index++] = pixels[offset++];
+            for (int i = 0; i<linePad; i++)
+                bufferWrite[index++] = (byte)0;
+        }
+        raFile.write(bufferWrite);
+    }
+
+    /** Write RGB data. Each 3-byte triplet in the bitmap array represents
+     *  blue, green, and red, respectively, for a pixel.  The color bytes are
+     *  in reverse order (Windows convention). Lines are padded to a length
+     *  that is a multiple of 4 bytes. */
+    private void writeRGBFrame(ImageProcessor ip) throws IOException {
+        ip = ip.convertToRGB();
+        int[] pixels = (int[])ip.getPixels();
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        int c, offset, index = 0;
+        for (int y=height-1; y>=0; y--) {
+            offset = y*width;
+            for (int x=0; x<width; x++) {
+                c = pixels[offset++];
+                bufferWrite[index++] = (byte)(c&0xff); // blue
+                bufferWrite[index++] = (byte)((c&0xff00)>>8); //green
+                bufferWrite[index++] = (byte)((c&0xff0000)>>16); // red
+            }
+            for (int i = 0; i<linePad; i++)
+                bufferWrite[index++] = (byte)0;
+        }
+        raFile.write(bufferWrite);
+    }
+
+    /** Write a frame as jpeg- or png-compressed image */
+	private void writeCompressedFrame(ImageProcessor ip) throws IOException {
+		//IJ.log("BufferdImage Type="+bufferedImage.getType()); // 1=RGB, 13=indexed
+		if (biCompression==JPEG_COMPRESSION) {
+			BufferedImage bi = getBufferedImage(ip);
+			ImageIO.write(bi, "jpeg", raOutputStream);
+		} else { //if (biCompression==PNG_COMPRESSION) {
+			BufferedImage bi = ip.getBufferedImage();
+			ImageIO.write(bi, "png", raOutputStream);
+		}
+	}
+
+	private BufferedImage getBufferedImage(ImageProcessor ip) {
+		BufferedImage bi = new BufferedImage(ip.getWidth(), ip.getHeight(), BufferedImage.TYPE_INT_RGB);
+		Graphics2D g = (Graphics2D)bi.getGraphics();
+		g.drawImage(ip.createImage(), 0, 0, null);
+		return bi;
+	}
+
+    /** Write the color table entries (for 8 bit grayscale or indexed color).
+     *  Byte order or LUT entries: blue byte, green byte, red byte, 0 byte */
+    private void writeLUT(ImageProcessor ip) throws IOException {
+        IndexColorModel cm = (IndexColorModel)(ip.getCurrentColorModel());
+        int mapSize = cm.getMapSize();
+        byte[] lutWrite = new byte[4*256];
+        for (int i = 0; i<256; i++) {
+            if (i<mapSize) {
+                lutWrite[4*i] = (byte)cm.getBlue(i);
+                lutWrite[4*i+1] = (byte)cm.getGreen(i);
+                lutWrite[4*i+2] = (byte)cm.getRed(i);
+                lutWrite[4*i+3] = (byte)0;
+            }
+        }
+        raFile.write(lutWrite);
+    }
+
+    private double getFrameRate(ImagePlus imp) {
+        double rate = imp.getCalibration().fps;
+        if (rate==0.0)
+            rate = Animator.getFrameRate();
+        if (rate<=0.5) rate = 0.5;
+        //if (rate>60.0) rate = 60.0;
+        return rate;
+    }
+
+    private void writeString(String s) throws IOException {
+        byte[] bytes =  s.getBytes("UTF8");
+        raFile.write(bytes);
+    }
+
+    /** Write 8-byte int with Intel (little-endian) byte order
+     * (note: RandomAccessFile.writeInt has other byte order than AVI) */
+    private void writeLong(long v) throws IOException {
+        for (int i=0; i<8; i++) {
+            raFile.write((int)(v & 0xFFL));
+            v = v>>>8;
+        }
+        //IJ.log("long: 0x"+Long.toHexString(v)+"="+v);
+    }
+
+    /** Write 4-byte int with Intel (little-endian) byte order
+     * (note: RandomAccessFile.writeInt has other byte order than AVI) */
+    private void writeInt(int v) throws IOException {
+        raFile.write(v & 0xFF);
+        raFile.write((v >>>  8) & 0xFF);
+        raFile.write((v >>> 16) & 0xFF);
+        raFile.write((v >>> 24) & 0xFF);
+        //IJ.log("int: 0x"+Integer.toHexString(v)+"="+v);
+    }
+
+    /** Write 2-byte short with Intel (little-endian) byte order
+     * (note: RandomAccessFile.writeShort has other byte order than AVI) */
+    private void writeShort(int v) throws IOException {
+        raFile.write(v & 0xFF);
+        raFile.write((v >>> 8) & 0xFF);
+    }
+
+    /** Write a byte */
+    private void writeByte(int v) throws IOException {
+        raFile.write(v & 0xFF);
+    }
+
+    /** An output stream directed to a RandomAccessFile (starting at the current position) */
+    class RaOutputStream extends OutputStream {
+        RandomAccessFile raFile;
+        RaOutputStream (RandomAccessFile raFile) {
+            this.raFile = raFile;
+        }
+        public void write (int b) throws IOException {
+            //IJ.log("stream: byte");
+            raFile.writeByte(b); //just for completeness, usually not used by image encoders
+        }
+        public void write (byte[] b) throws IOException {
+            //IJ.log("stream: array len="+b.length);
+            raFile.write(b);
+        }
+        public void write (byte[] b, int off, int len) throws IOException {
+            //IJ.log("stream: array="+b.length+" off="+off+" len="+len);
+            raFile.write(b, off, len);
+        }
+    }
+
+}
diff --git a/src/ij/plugin/filter/Analyzer.java b/src/ij/plugin/filter/Analyzer.java
new file mode 100644
index 0000000..285d634
--- /dev/null
+++ b/src/ij/plugin/filter/Analyzer.java
@@ -0,0 +1,1070 @@
+package ij.plugin.filter;
+import java.awt.*;
+import java.util.Vector;
+import java.util.Properties;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.text.*;
+import ij.plugin.MeasurementsWriter;
+import ij.plugin.Straightener;
+import ij.plugin.frame.RoiManager;
+import ij.util.Tools;
+import ij.macro.Interpreter;
+
+/** This plugin implements ImageJ's Analyze/Measure and Analyze/Set Measurements commands. */
+public class Analyzer implements PlugInFilter, Measurements {
+	
+	private static boolean drawLabels = true;
+	private String arg;
+	private ImagePlus imp;
+	private ResultsTable rt;
+	private int measurements;
+	private StringBuffer min,max,mean,sd;
+	private boolean disableReset;
+	private boolean resultsUpdated;
+	
+	// Order must agree with order of checkboxes in Set Measurements dialog box
+	private static final int[] list = {AREA,MEAN,STD_DEV,MODE,MIN_MAX,
+		CENTROID,CENTER_OF_MASS,PERIMETER,RECT,ELLIPSE,SHAPE_DESCRIPTORS, FERET,
+		INTEGRATED_DENSITY,MEDIAN,SKEWNESS,KURTOSIS,AREA_FRACTION,STACK_POSITION,
+		LIMIT,LABELS,INVERT_Y,SCIENTIFIC_NOTATION,ADD_TO_OVERLAY,NaN_EMPTY_CELLS};
+
+	private static final String MEASUREMENTS = "measurements";
+	private static final String MARK_WIDTH = "mark.width";
+	private static final String PRECISION = "precision";
+	//private static int counter;
+	private static boolean unsavedMeasurements;
+	public static Color darkBlue = new Color(0,0,160);
+	private static int systemMeasurements = Prefs.getInt(MEASUREMENTS,AREA+MEAN+MIN_MAX);
+	public static int markWidth;
+	public static int precision = Prefs.getInt(PRECISION,3);
+	private static float[] umeans = new float[MAX_STANDARDS];
+	private static ResultsTable systemRT = new ResultsTable();
+	private static int redirectTarget;
+	private static String redirectTitle = "";
+	private static ImagePlus redirectImage; // non-displayed images
+	static int firstParticle, lastParticle;
+	private static boolean summarized;
+	private static boolean switchingModes;
+	private static boolean showMin = true;
+	private static boolean showAngle = true;
+	
+	public Analyzer() {
+		rt = systemRT;
+		rt.showRowNumbers(true);
+		rt.setPrecision((systemMeasurements&SCIENTIFIC_NOTATION)!=0?-precision:precision);
+		rt.setNaNEmptyCells((systemMeasurements&NaN_EMPTY_CELLS)!=0);
+		measurements = systemMeasurements;
+	}
+	
+	/** Constructs a new Analyzer using the specified ImagePlus object
+		and the current measurement options and default results table. */
+	public Analyzer(ImagePlus imp) {
+		this();
+		this.imp = imp;
+	}
+	
+	/** Construct a new Analyzer using an ImagePlus object and a ResultsTable. */
+	public Analyzer(ImagePlus imp, ResultsTable rt) {
+		this(imp, Analyzer.getMeasurements(), rt);
+	}
+
+	/** Construct a new Analyzer using an ImagePlus object and private
+		measurement options and a ResultsTable. */
+	public Analyzer(ImagePlus imp, int measurements, ResultsTable rt) {
+		this.imp = imp;
+		this.measurements = measurements;
+		if (rt==null)
+			rt = new ResultsTable();
+		rt.setPrecision((systemMeasurements&SCIENTIFIC_NOTATION)!=0?-precision:precision);
+		rt.setNaNEmptyCells((systemMeasurements&NaN_EMPTY_CELLS)!=0);
+		this.rt = rt;
+	}
+	
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		IJ.register(Analyzer.class);
+		if (arg.equals("set")) {
+			doSetDialog();
+			return DONE;
+		} else if (arg.equals("sum")) {
+			summarize();
+			return DONE;
+		} else if (arg.equals("clear")) {
+			if (IJ.macroRunning())
+				unsavedMeasurements = false;
+			resetCounter();
+			return DONE;
+		} else
+			return DOES_ALL+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		measure();
+		Roi roi = imp.getRoi();
+		if (roi==null || roi.getType()!=Roi.POINT)
+			displayResults();
+		if ((measurements&ADD_TO_OVERLAY)!=0)
+			addRoiToOverlay();
+	}
+	
+	private void addRoiToOverlay() {
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			return;
+		roi = (Roi)roi.clone();
+		if (imp.getStackSize()>1) {
+			if (imp.isHyperStack()||imp.isComposite())
+				roi.setPosition(0, imp.getSlice(), imp.getFrame());
+			else
+				roi.setPosition(imp.getCurrentSlice());
+		}
+		if (roi.getName()==null)
+			roi.setName(""+rt.size());
+		//roi.setName(IJ.getString("Label:", "m"+rt.size()));
+		roi.setIgnoreClipRect(true);
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			overlay = new Overlay();
+		if (drawLabels)
+			overlay.drawLabels(true);
+		if (!overlay.getDrawNames())
+			overlay.drawNames(true);
+		overlay.setLabelColor(Color.white);
+		overlay.drawBackgrounds(true);
+		overlay.add(roi);
+		imp.setOverlay(overlay);
+		if (roi.getType()==Roi.COMPOSITE && Toolbar.getToolId()==Toolbar.OVAL && Toolbar.getBrushSize()>0)
+			imp.deleteRoi();  // delete ROIs created with the selection brush tool
+	}
+
+	void doSetDialog() {
+		String NONE = "None";
+		String[] titles;
+        int[] wList = WindowManager.getIDList();
+        if (wList==null) {
+        	titles = new String[1];
+            titles[0] = NONE;
+        } else {
+			titles = new String[wList.length+1];
+			titles[0] = NONE;
+			for (int i=0; i<wList.length; i++) {
+				ImagePlus imp = WindowManager.getImage(wList[i]);
+				titles[i+1] = imp!=null?imp.getTitle():"";
+			}
+		}
+		ImagePlus tImp = WindowManager.getImage(redirectTarget);
+		String target = tImp!=null?tImp.getTitle():NONE;
+		String macroOptions = Macro.getOptions();
+		if (macroOptions!=null && macroOptions.indexOf("circularity ")!=-1)
+			Macro.setOptions(macroOptions.replaceAll("circularity ", "shape "));
+		if (macroOptions!=null && macroOptions.indexOf("slice ")!=-1)
+			Macro.setOptions(macroOptions.replaceAll("slice ", "stack "));
+
+ 		GenericDialog gd = new GenericDialog("Set Measurements");
+		String[] labels = new String[18];
+		boolean[] states = new boolean[18];
+		labels[0]="Area"; states[0]=(systemMeasurements&AREA)!=0;
+		labels[1]="Mean gray value"; states[1]=(systemMeasurements&MEAN)!=0;
+		labels[2]="Standard deviation"; states[2]=(systemMeasurements&STD_DEV)!=0;
+		labels[3]="Modal gray value"; states[3]=(systemMeasurements&MODE)!=0;
+		labels[4]="Min & max gray value"; states[4]=(systemMeasurements&MIN_MAX)!=0;
+		labels[5]="Centroid"; states[5]=(systemMeasurements&CENTROID)!=0;
+		labels[6]="Center of mass"; states[6]=(systemMeasurements&CENTER_OF_MASS)!=0;
+		labels[7]="Perimeter"; states[7]=(systemMeasurements&PERIMETER)!=0;
+		labels[8]="Bounding rectangle"; states[8]=(systemMeasurements&RECT)!=0;
+		labels[9]="Fit ellipse"; states[9]=(systemMeasurements&ELLIPSE)!=0;
+		labels[10]="Shape descriptors"; states[10]=(systemMeasurements&SHAPE_DESCRIPTORS)!=0;
+		labels[11]="Feret's diameter"; states[11]=(systemMeasurements&FERET)!=0;
+		labels[12]="Integrated density"; states[12]=(systemMeasurements&INTEGRATED_DENSITY)!=0;
+		labels[13]="Median"; states[13]=(systemMeasurements&MEDIAN)!=0;
+		labels[14]="Skewness"; states[14]=(systemMeasurements&SKEWNESS)!=0;
+		labels[15]="Kurtosis"; states[15]=(systemMeasurements&KURTOSIS)!=0;
+		labels[16]="Area_fraction"; states[16]=(systemMeasurements&AREA_FRACTION)!=0;
+		labels[17]="Stack position"; states[17]=(systemMeasurements&STACK_POSITION)!=0;
+		gd.setInsets(0, 0, 0);
+		gd.addCheckboxGroup(10, 2, labels, states);
+		labels = new String[6];
+		states = new boolean[6];
+		labels[0]="Limit to threshold"; states[0]=(systemMeasurements&LIMIT)!=0;
+		labels[1]="Display label"; states[1]=(systemMeasurements&LABELS)!=0;
+		labels[2]="Invert Y coordinates"; states[2]=(systemMeasurements&INVERT_Y)!=0;
+		labels[3]="Scientific notation"; states[3]=(systemMeasurements&SCIENTIFIC_NOTATION)!=0;;
+		labels[4]="Add to overlay"; states[4]=(systemMeasurements&ADD_TO_OVERLAY)!=0;;
+		labels[5]="NaN empty cells"; states[5]=(systemMeasurements&NaN_EMPTY_CELLS)!=0;;
+		gd.setInsets(0, 0, 0);
+		gd.addCheckboxGroup(3, 2, labels, states);
+		gd.setInsets(15, 0, 0);
+        gd.addChoice("Redirect to:", titles, target);
+		gd.setInsets(5, 0, 0);
+		gd.addNumericField("Decimal places (0-9):", precision, 0, 2, "");
+		gd.addHelp(IJ.URL+"/docs/menus/analyze.html#set");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		int oldMeasurements = systemMeasurements;
+		setOptions(gd);
+		int index = gd.getNextChoiceIndex();
+		redirectTarget = index==0?0:wList[index-1];
+		redirectTitle = titles[index];
+		ImagePlus imp = WindowManager.getImage(redirectTarget);
+		redirectImage = imp!=null && imp.getWindow()==null?imp:null;
+
+		int prec = (int)gd.getNextNumber();
+		if (prec<0) prec = 0;
+		if (prec>9) prec = 9;
+		boolean notationChanged = (oldMeasurements&SCIENTIFIC_NOTATION)!=(systemMeasurements&SCIENTIFIC_NOTATION);
+		if (prec!=precision || notationChanged) {
+			precision = prec;
+			rt.setPrecision((systemMeasurements&SCIENTIFIC_NOTATION)!=0?-precision:precision);
+			if (rt.size()>0)
+				rt.show("Results");
+		}
+	}
+	
+	void setOptions(GenericDialog gd) {
+		int oldMeasurements = systemMeasurements;
+		int previous = 0;
+		boolean b = false;
+		for (int i=0; i<list.length; i++) {
+			//if (list[i]!=previous)
+			b = gd.getNextBoolean();
+			previous = list[i];
+			if (b)
+				systemMeasurements |= list[i];
+			else
+				systemMeasurements &= ~list[i];
+		}
+		if (rt!=null && rt.size()>1 && !IJ.isResultsWindow() && IJ.getInstance()!=null)
+			rt.reset();
+		if ((oldMeasurements&(~SCIENTIFIC_NOTATION))!=(systemMeasurements&(~SCIENTIFIC_NOTATION))&&IJ.isResultsWindow()) {
+				rt.setPrecision((systemMeasurements&SCIENTIFIC_NOTATION)!=0?-precision:precision);
+				clearSummary();
+				rt.update(systemMeasurements, imp, null);
+		}
+		if ((systemMeasurements&LABELS)==0)
+			systemRT.disableRowLabels();
+	}
+	
+	/** Measures the image or selection and adds the results to the default results table. */
+	public void measure() {
+		String lastHdr = rt.getColumnHeading(ResultsTable.LAST_HEADING);
+		if (lastHdr==null || lastHdr.charAt(0)!='M') {
+			if (!reset()) return;
+		}
+		firstParticle = lastParticle = 0;
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.getType()==Roi.POINT) {
+			measurePoint(roi);
+			return;
+		}
+		if (roi!=null && roi.isLine()) {
+			measureLength(roi);
+			return;
+		}
+		if (roi!=null && roi.getType()==Roi.ANGLE) {
+			measureAngle(roi);
+			return;
+		}
+		ImageStatistics stats;
+		if (isRedirectImage()) {
+			stats = getRedirectStats(measurements, roi);
+			if (stats==null) return;
+		} else
+			stats = imp.getStatistics(measurements);
+		if (!IJ.isResultsWindow() && IJ.getInstance()!=null)
+			reset();
+		saveResults(stats, roi);
+	}
+		
+	/*
+	void showHeadings() {
+		String[] headings = rt.getHeadings();
+		int columns = headings.length;
+		if (columns==0)
+			return;
+		IJ.log("Headings: "+headings.length+" "+rt.getColumnHeading(ResultsTable.LAST_HEADING));
+		for (int i=0; i<columns; i++) {
+			if (headings[i]!=null)
+				IJ.log("   "+i+" "+headings[i]+" "+rt.getColumnIndex(headings[i]));
+		}
+	}
+	*/
+	
+	boolean reset() {
+		boolean ok = true;
+		if (rt.size()>0 && !disableReset)
+			ok = resetCounter();
+		if (ok && rt.getColumnHeading(ResultsTable.LAST_HEADING)==null)
+			rt.setDefaultHeadings();
+		return ok;
+	}
+
+	/** Returns <code>true</code> if an image is selected in the "Redirect To:"
+		popup menu of the Analyze/Set Measurements dialog box. */
+	public static boolean isRedirectImage() {
+		return redirectTarget!=0;
+	}
+	
+	/** Set the "Redirect To" image. Pass 'null' as the 
+	    argument to disable redirected sampling. */
+	public static void setRedirectImage(ImagePlus imp) {
+		if (imp==null) {
+			redirectTarget = 0;
+			redirectTitle = null;
+			redirectImage = null;
+		} else {
+			redirectTarget = imp.getID();
+			redirectTitle = imp.getTitle();
+			if (imp.getWindow()==null)
+				redirectImage = imp;
+		}
+	}
+	
+	private ImagePlus getRedirectImageOrStack(ImagePlus cimp) {
+		ImagePlus rimp = getRedirectImage(cimp);
+		if (rimp!=null) {
+			int depth = rimp.getStackSize();
+			if (depth>1 && depth==cimp.getStackSize() && rimp.getCurrentSlice()!=cimp.getCurrentSlice())
+				rimp.setSlice(cimp.getCurrentSlice());
+		}
+		return rimp;
+	}
+
+	/** Returns the image selected in the "Redirect To:" popup
+		menu of the Analyze/Set Measurements dialog, or null
+		if "None" is selected, the image was not found or the 
+		image is not the same size as <code>currentImage</code>. */
+	public static ImagePlus getRedirectImage(ImagePlus cimp) {
+		ImagePlus rimp = WindowManager.getImage(redirectTarget);
+		if (rimp==null)
+			rimp = redirectImage;
+		if (rimp==null) {
+			IJ.error("Analyzer", "Redirect image (\""+redirectTitle+"\")\n"
+				+ "not found.");
+			redirectTarget = 0;
+			Macro.abort();
+			return null;
+		}
+		if (rimp.getWidth()!=cimp.getWidth() || rimp.getHeight()!=cimp.getHeight()) {
+			IJ.error("Analyzer", "Redirect image (\""+redirectTitle+"\") \n"
+				+ "is not the same size as the current image.");
+			Macro.abort();
+			return null;
+		}
+		return rimp;
+	}
+
+	ImageStatistics getRedirectStats(int measurements, Roi roi) {
+		ImagePlus redirectImp = getRedirectImageOrStack(imp);
+		if (redirectImp==null)
+			return null;
+		ImageProcessor ip = redirectImp.getProcessor();
+		if (imp.getTitle().equals("mask") && imp.getBitDepth()==8) {
+			ip.setMask(imp.getProcessor());
+			ip.setRoi(0, 0, imp.getWidth(), imp.getHeight());
+		} else
+			ip.setRoi(roi);
+		return ImageStatistics.getStatistics(ip, measurements, redirectImp.getCalibration());
+	}
+	
+	void measurePoint(Roi roi) {
+		if (rt.size()>0) {
+			if (!IJ.isResultsWindow())
+				reset();
+			int index = rt.getColumnIndex("X");
+			if ((index<0 || !rt.columnExists(index)) && rt.getLastColumn()<ResultsTable.LAST_HEADING) {
+				clearSummary();
+				rt.update(measurements, imp, roi);
+			}
+		}
+		FloatPolygon p = roi.getFloatPolygon();
+		ImagePlus imp2 = isRedirectImage()?getRedirectImageOrStack(imp):null;
+		if (imp2==null) imp2 = imp;
+		ImageStack stack = null;
+		if (imp2.getStackSize()>1)
+			stack = imp2.getStack();
+		PointRoi pointRoi = roi instanceof PointRoi?(PointRoi)roi:null;
+		for (int i=0; i<p.npoints; i++) {
+			int position = 0;
+			if (pointRoi!=null)
+				position = pointRoi.getPointPosition(i);
+			ImageProcessor ip = null;
+			if (stack!=null && position>0 && position<=stack.size())
+				ip = stack.getProcessor(position);
+			else
+				ip = imp2.getProcessor();
+			ip.setRoi((int)Math.round(p.xpoints[i]), (int)Math.round(p.ypoints[i]), 1, 1);
+			ImageStatistics stats = ImageStatistics.getStatistics(ip, measurements, imp2.getCalibration());
+			stats.xCenterOfMass = p.xpoints[i];
+			stats.yCenterOfMass = p.ypoints[i];
+			PointRoi point = new PointRoi(p.xpoints[i], p.ypoints[i]);
+			point.setPosition(position);
+			if (pointRoi!=null && pointRoi.getNCounters()>1) {
+				int[] counters = pointRoi.getCounters();
+				if (counters!=null && i<counters.length) {
+					int counter = counters[i]&0xff;
+					int count = pointRoi.getCount(counter);
+					int[] info = new int[2];
+					info[0] = counter;
+					info[1] = count;
+					point.setCounterInfo(info);
+				}
+			}
+			saveResults(stats, point);
+			if (rt==systemRT)
+				displayResults();
+		}
+	}
+	
+	void measureAngle(Roi roi) {
+		if (rt.size()>0) {
+			if (!IJ.isResultsWindow()) reset();
+			int index = rt.getColumnIndex("Angle");
+			if (index<0 || !rt.columnExists(index)) {
+				clearSummary();
+				rt.update(measurements, imp, roi);
+			}
+		}
+		ImageProcessor ip = imp.getProcessor();
+		ip.setRoi(roi.getPolygon());
+		ImageStatistics stats = new ImageStatistics();
+		saveResults(stats, roi);
+	}
+	
+	void measureLength(Roi roi) {
+		ImagePlus imp2 = isRedirectImage()?getRedirectImageOrStack(imp):null;
+		if (imp2!=null)
+			imp2.setRoi(roi);
+		else
+			imp2 = imp;
+		if (rt.size()>0) {
+			if (!IJ.isResultsWindow()) reset();
+			boolean update = false;
+			int index = rt.getColumnIndex("Length");
+			if (index<0 || !rt.columnExists(index))
+				update=true;
+			if (roi.getType()==Roi.LINE) {
+				index = rt.getColumnIndex("Angle");
+				if (index<0 || !rt.columnExists(index)) update=true;
+			}
+			if (update) {
+				clearSummary();
+				rt.update(measurements, imp2, roi);
+			}
+		}
+		if ((measurements&(AREA+MEAN+STD_DEV+MODE+MIN_MAX+CENTROID+MEDIAN))==0) {
+			incrementCounter();
+			rt.addValue("Length", roi.getLength());
+			if (roi.getType()==Roi.LINE && showAngle) {
+				Line line = (Line)roi;
+				rt.addValue("Angle", line.getFloatAngle(line.x1d,line.y1d,line.x2d,line.y2d));
+			}
+			if ((measurements&LABELS)!=0)
+				rt.addLabel("Label", getFileName());
+			return;
+		}
+		boolean straightLine = roi.getType()==Roi.LINE;
+		int lineWidth = (int)Math.round(roi.getStrokeWidth());
+		ImageProcessor ip2 = imp2.getProcessor();
+		double minThreshold = ip2.getMinThreshold();
+		double maxThreshold = ip2.getMaxThreshold();
+		int limit = (Analyzer.getMeasurements()&LIMIT)!=0?LIMIT:0;
+		boolean calibrated = imp2.getCalibration().calibrated();
+		Rectangle saveR = null;
+		Calibration globalCal = calibrated?imp2.getGlobalCalibration():null;
+		Calibration localCal = null;
+		if (globalCal!=null) {
+			imp2.setGlobalCalibration(null);
+			localCal = imp2.getCalibration().copy();
+			imp2.setCalibration(globalCal);
+		} if (lineWidth>1) {
+			saveR = ip2.getRoi();
+			ip2.setRoi(Roi.convertLineToArea(roi));
+		} else if (calibrated && limit!=0) {
+			Calibration cal = imp2.getCalibration().copy();
+			imp2.getCalibration().disableDensityCalibration();
+			ProfilePlot profile = new ProfilePlot(imp2);
+			imp2.setCalibration(cal);
+			double[] values = profile.getProfile();
+			if (values==null) return;
+			ip2 = new FloatProcessor(values.length, 1, values);
+			ip2 = convertToOriginalDepth(imp2, ip2);
+			ip2.setCalibrationTable(cal.getCTable());
+		} else {
+			ProfilePlot profile = new ProfilePlot(imp2);
+			double[] values = profile.getProfile();
+			if (values==null) return;
+			ip2 = new FloatProcessor(values.length, 1, values);
+			if (limit!=0)
+				ip2 = convertToOriginalDepth(imp2, ip2);
+		}
+		if (limit!=0 && minThreshold!=ImageProcessor.NO_THRESHOLD)
+			ip2.setThreshold(minThreshold,maxThreshold,ImageProcessor.NO_LUT_UPDATE);
+		ImageStatistics stats = ImageStatistics.getStatistics(ip2, AREA+MEAN+STD_DEV+MODE+MIN_MAX+MEDIAN+limit, imp2.getCalibration());
+		if (saveR!=null)
+			ip2.setRoi(saveR);
+		if ((roi instanceof Line) && (measurements&CENTROID)!=0) {
+			FloatPolygon p = ((Line)roi).getFloatPoints();
+			stats.xCentroid = p.xpoints[0] + (p.xpoints[1]-p.xpoints[0])/2.0;
+			stats.yCentroid = p.ypoints[0] + (p.ypoints[1]-p.ypoints[0])/2.0;
+			if (imp2!=null) {
+				Calibration cal = imp.getCalibration();
+				stats.xCentroid = cal.getX(stats.xCentroid);
+				stats.yCentroid = cal.getY(stats.yCentroid, imp2.getHeight());
+			}
+		}
+		saveResults(stats, roi);
+		if (globalCal!=null && localCal!=null) {
+			imp2.setGlobalCalibration(globalCal);
+			imp2.setCalibration(localCal);
+		}
+	}
+	
+	private ImageProcessor convertToOriginalDepth(ImagePlus imp, ImageProcessor ip) {
+		if (imp.getBitDepth()==8)
+			ip = ip.convertToByte(false);
+		else if (imp.getBitDepth()==16)
+			ip = ip.convertToShort(false);
+		return ip;
+	}
+
+	
+	/** Saves the measurements specified in the "Set Measurements" dialog,
+		or by calling setMeasurements(), in the default results table.
+	*/
+	public void saveResults(ImageStatistics stats, Roi roi) {
+		if (rt.getColumnHeading(ResultsTable.LAST_HEADING)==null)
+			reset();
+		clearSummary();
+		incrementCounter();
+		int counter = rt.size();
+		if (counter<=MAX_STANDARDS && !(stats.umean==0.0&&counter==1&&umeans!=null && umeans[0]!=0f)) {
+			if (umeans==null) umeans = new float[MAX_STANDARDS];
+			umeans[counter-1] = (float)stats.umean;
+		}
+		if ((measurements&LABELS)!=0)
+			rt.addLabel("Label", getFileName());
+		if ((measurements&AREA)!=0) rt.addValue(ResultsTable.AREA,stats.area);
+		if ((measurements&MEAN)!=0) rt.addValue(ResultsTable.MEAN,stats.mean);
+		if ((measurements&STD_DEV)!=0) rt.addValue(ResultsTable.STD_DEV,stats.stdDev);
+		if ((measurements&MODE)!=0) rt.addValue(ResultsTable.MODE, stats.dmode);
+		if ((measurements&MIN_MAX)!=0) {
+			if (showMin) rt.addValue(ResultsTable.MIN,stats.min);
+			rt.addValue(ResultsTable.MAX,stats.max);
+		}
+		if ((measurements&CENTROID)!=0) {
+			rt.addValue(ResultsTable.X_CENTROID,stats.xCentroid);
+			rt.addValue(ResultsTable.Y_CENTROID,stats.yCentroid);
+		}
+		if ((measurements&CENTER_OF_MASS)!=0) {
+			rt.addValue(ResultsTable.X_CENTER_OF_MASS,stats.xCenterOfMass);
+			rt.addValue(ResultsTable.Y_CENTER_OF_MASS,stats.yCenterOfMass);
+		}
+		if ((measurements&PERIMETER)!=0 || (measurements&SHAPE_DESCRIPTORS)!=0) {
+			double perimeter;
+			if (roi!=null)
+				perimeter = roi.getLength();
+			else
+				perimeter = imp!=null?imp.getWidth()*2+imp.getHeight()*2:0.0;
+			if ((measurements&PERIMETER)!=0) 
+				rt.addValue(ResultsTable.PERIMETER,perimeter);
+			if ((measurements&SHAPE_DESCRIPTORS)!=0) {
+				double circularity = perimeter==0.0?0.0:4.0*Math.PI*(stats.area/(perimeter*perimeter));
+				if (circularity>1.0) circularity = 1.0;
+				rt.addValue(ResultsTable.CIRCULARITY, circularity);
+				Polygon ch = null;
+				boolean isArea = roi==null || roi.isArea();
+				double convexArea = roi!=null?getArea(roi.getConvexHull()):stats.pixelCount;
+				rt.addValue(ResultsTable.ASPECT_RATIO, isArea?stats.major/stats.minor:0.0);
+				rt.addValue(ResultsTable.ROUNDNESS, isArea?4.0*stats.area/(Math.PI*stats.major*stats.major):0.0);
+				rt.addValue(ResultsTable.SOLIDITY, isArea?stats.pixelCount/convexArea:Double.NaN);
+				if (rt.size()==1) {
+					rt.setDecimalPlaces(ResultsTable.CIRCULARITY, precision);
+					rt.setDecimalPlaces(ResultsTable.ASPECT_RATIO, precision);
+					rt.setDecimalPlaces(ResultsTable.ROUNDNESS, precision);
+					rt.setDecimalPlaces(ResultsTable.SOLIDITY, precision);
+				}
+				//rt.addValue(ResultsTable.CONVEXITY, getConvexPerimeter(roi, ch)/perimeter);
+			}
+		}
+		if ((measurements&RECT)!=0) {
+			if (roi!=null && roi.isLine()) {
+				Rectangle bounds = roi.getBounds();
+				double rx = bounds.x;
+				double ry = bounds.y;
+				double rw = bounds.width;
+				double rh = bounds.height;
+				Calibration cal = imp!=null?imp.getCalibration():null;
+				if (cal!=null) {
+					rx = cal.getX(rx);
+					ry = cal.getY(ry, imp.getHeight());
+					rw *= cal.pixelWidth;
+					rh *= cal.pixelHeight;
+				}
+				rt.addValue(ResultsTable.ROI_X, rx);
+				rt.addValue(ResultsTable.ROI_Y, ry);
+				rt.addValue(ResultsTable.ROI_WIDTH, rw);
+				rt.addValue(ResultsTable.ROI_HEIGHT, rh);
+			} else {
+				rt.addValue(ResultsTable.ROI_X,stats.roiX);
+				rt.addValue(ResultsTable.ROI_Y,stats.roiY);
+				rt.addValue(ResultsTable.ROI_WIDTH,stats.roiWidth);
+				rt.addValue(ResultsTable.ROI_HEIGHT,stats.roiHeight);
+			}
+		}
+		if ((measurements&ELLIPSE)!=0) {
+			rt.addValue(ResultsTable.MAJOR,stats.major);
+			rt.addValue(ResultsTable.MINOR,stats.minor);
+			rt.addValue(ResultsTable.ANGLE,stats.angle);
+		}
+		if ((measurements&FERET)!=0) {
+			boolean extras = true;
+			double FeretDiameter=Double.NaN, feretAngle=Double.NaN, minFeret=Double.NaN,
+				feretX=Double.NaN, feretY=Double.NaN;
+			Roi roi2 = roi;
+			if (roi2==null && imp!=null)
+				roi2 = new Roi(0, 0, imp.getWidth(), imp.getHeight());
+			if (roi2!=null) {
+				double[] a = roi2.getFeretValues();
+				if (a!=null) {
+					FeretDiameter = a[0];
+					feretAngle = a[1];
+					minFeret = a[2];
+					feretX = a[3];
+					feretY = a[4];
+				}
+			}
+			rt.addValue(ResultsTable.FERET, FeretDiameter);
+			rt.addValue(ResultsTable.FERET_X, feretX);
+			rt.addValue(ResultsTable.FERET_Y, feretY);
+			rt.addValue(ResultsTable.FERET_ANGLE, feretAngle);
+			rt.addValue(ResultsTable.MIN_FERET, minFeret);
+		}
+		if ((measurements&INTEGRATED_DENSITY)!=0) {
+			rt.addValue(ResultsTable.INTEGRATED_DENSITY,stats.area*stats.mean);
+			rt.addValue(ResultsTable.RAW_INTEGRATED_DENSITY,stats.pixelCount*stats.umean);
+		}
+		if ((measurements&MEDIAN)!=0) rt.addValue(ResultsTable.MEDIAN, stats.median);
+		if ((measurements&SKEWNESS)!=0) rt.addValue(ResultsTable.SKEWNESS, stats.skewness);
+		if ((measurements&KURTOSIS)!=0) rt.addValue(ResultsTable.KURTOSIS, stats.kurtosis);
+		if ((measurements&AREA_FRACTION)!=0) rt.addValue(ResultsTable.AREA_FRACTION, stats.areaFraction);
+		if ((measurements&STACK_POSITION)!=0) {
+			boolean update = false;
+			if (imp!=null && (imp.isHyperStack()||imp.isComposite())) {
+				int[] position = imp.convertIndexToPosition(imp.getCurrentSlice());
+				if (imp.getNChannels()>1) {
+					int index = rt.getColumnIndex("Ch");
+					if (index<0 || !rt.columnExists(index)) update=true;
+					rt.addValue("Ch", position[0]);
+				}
+				if (imp.getNSlices()>1) {
+					int index = rt.getColumnIndex("Slice");
+					if (index<0 || !rt.columnExists(index)) update=true;
+					rt.addValue("Slice", position[1]);
+				}
+				if (imp.getNFrames()>1) {
+					int index = rt.getColumnIndex("Frame");
+					if (index<0 || !rt.columnExists(index)) update=true;
+					rt.addValue("Frame", position[2]);
+				}
+			} else {
+				int index = rt.getColumnIndex("Slice");
+				if (index<0 || !rt.columnExists(index)) update=true;
+				rt.addValue("Slice", imp!=null?imp.getCurrentSlice():1.0);
+			}
+			if (update && rt==systemRT && IJ.isResultsWindow())
+				rt.update(measurements, imp, roi);
+		}
+		if (roi!=null) {
+			if (roi.isLine()) {
+				rt.addValue("Length", roi.getLength());
+				if (roi.getType()==Roi.LINE && showAngle) {
+					Line line = (Line)roi;
+					rt.addValue("Angle", line.getFloatAngle(line.x1d,line.y1d,line.x2d,line.y2d));
+				}
+			} else if (roi.getType()==Roi.ANGLE) {
+				double angle = ((PolygonRoi)roi).getAngle();
+				if (Prefs.reflexAngle) angle = 360.0-angle;
+				rt.addValue("Angle", angle);
+			} else if (roi instanceof PointRoi)
+				savePoints((PointRoi)roi);
+		}
+		if ((measurements&LIMIT)!=0 && imp!=null && imp.getBitDepth()!=24) {
+			rt.addValue(ResultsTable.MIN_THRESHOLD, stats.lowerThreshold);
+			rt.addValue(ResultsTable.MAX_THRESHOLD, stats.upperThreshold);
+		}
+		if (roi instanceof RotatedRectRoi) {
+			double[] p = ((RotatedRectRoi)roi).getParams();
+			double dx = p[2] - p[0];
+			double dy = p[3] - p[1];
+			double length = Math.sqrt(dx*dx+dy*dy);
+			Calibration cal = imp!=null?imp.getCalibration():null;
+			double pw = 1.0;
+			if (cal!=null && cal.pixelWidth==cal.pixelHeight)
+				pw = cal.pixelWidth;
+			rt.addValue("RRLength", length*pw);
+			rt.addValue("RRWidth", p[4]*pw);
+		}
+		int group = roi!=null?roi.getGroup():0;
+		if (group>0) {
+			rt.addValue("Group", group);
+			String name = Roi.getGroupName(group);
+			if (name!=null)
+				rt.addValue("GroupName", name);				
+		}
+	}
+	
+	private void clearSummary() {
+		if (summarized && rt.size()>=4 && "Max".equals(rt.getLabel(rt.size()-1))) {
+			for (int i=0; i<4; i++)
+				rt.deleteRow(rt.size()-1);
+			rt.show("Results");
+			summarized = false;
+		}
+	}
+		
+	final double getArea(Polygon p) {
+		if (p==null) return Double.NaN;
+		int carea = 0;
+		int iminus1;
+		for (int i=0; i<p.npoints; i++) {
+			iminus1 = i-1;
+			if (iminus1<0) iminus1=p.npoints-1;
+			carea += (p.xpoints[i]+p.xpoints[iminus1])*(p.ypoints[i]-p.ypoints[iminus1]);
+		}
+		return (Math.abs(carea/2.0));
+	}
+		
+	void savePoints(PointRoi roi) {
+		if (imp==null) {
+			rt.addValue("X", 0.0);
+			rt.addValue("Y", 0.0);
+			return;
+		}
+		if ((measurements&AREA)!=0)
+			rt.addValue(ResultsTable.AREA,0);
+		FloatPolygon p = roi.getFloatPolygon();
+		ImageProcessor ip = imp.getProcessor();
+		Calibration cal = imp.getCalibration();
+		double x = p.xpoints[0];
+		double y = p.ypoints[0];
+		int ix=(int)x, iy=(int)y;
+		double value = ip.getPixelValue(ix,iy);
+		if (markWidth>0 && !Toolbar.getMultiPointMode()) {
+			ip.setColor(Toolbar.getForegroundColor());
+			ip.setLineWidth(markWidth);
+			ip.moveTo(ix,iy);
+			ip.lineTo(ix,iy);
+			imp.updateAndDraw();
+			ip.setLineWidth(Line.getWidth());
+		}
+		rt.addValue("X", cal.getX(x));
+		rt.addValue("Y", cal.getY(y, imp.getHeight()));
+		int position = roi.getPosition();
+		if (imp.isHyperStack() || imp.isComposite()) {
+			int channel = imp.getChannel();
+			int slice = imp.getSlice();
+			int frame = imp.getFrame();
+			if (position>0) {
+				int[] pos = imp.convertIndexToPosition(position);
+				channel = pos[0];
+				slice = pos[1];
+				frame = pos[2];
+			}
+			if (imp.getNChannels()>1)
+				rt.addValue("Ch", channel);
+			if (imp.getNSlices()>1)
+				rt.addValue("Slice", slice);
+			if (imp.getNFrames()>1)
+				rt.addValue("Frame", frame);
+		} else if (imp.getStackSize()>1) {
+			if (position==0)
+				position = imp.getCurrentSlice();
+			rt.addValue("Slice", position);
+		}
+		int[] info = roi.getCounterInfo();
+		if (info!=null) {
+			rt.addValue("Counter", info[0]);
+			rt.addValue("Count", info[1]);
+		}
+		if (imp.getProperty("FHT")!=null) {
+			double center = imp.getWidth()/2.0;
+			y = imp.getHeight()-y-1;
+			double r = Math.sqrt((x-center)*(x-center) + (y-center)*(y-center));
+			if (r<1.0) r = 1.0;
+			double theta = Math.atan2(y-center, x-center);
+			theta = theta*180.0/Math.PI;
+			if (theta<0) theta = 360.0+theta;
+			rt.addValue("R", (imp.getWidth()/r)*cal.pixelWidth);
+			rt.addValue("Theta", theta);
+		}
+	}
+
+	String getFileName() {
+		String s = "";
+		if (imp!=null) {
+			if (redirectTarget!=0) {
+				ImagePlus rImp = WindowManager.getImage(redirectTarget);
+				if (rImp==null) rImp = redirectImage;
+				if (rImp!=null) s = rImp.getTitle();				
+			} else
+				s = imp.getTitle();
+			//int len = s.length();
+			//if (len>4 && s.charAt(len-4)=='.' && !Character.isDigit(s.charAt(len-1)))
+			//	s = s.substring(0,len-4); 
+			Roi roi = imp.getRoi();
+			String roiName = roi!=null?roi.getName():null;
+			if (roiName!=null && !roiName.contains(".")) {
+				if (roiName.length()>30)
+					roiName = roiName.substring(0,27) + "...";
+				s += ":"+roiName;
+			}
+			if (imp.getStackSize()>1) {
+				ImageStack stack = imp.getStack();
+				int currentSlice = imp.getCurrentSlice();
+				String label = stack.getShortSliceLabel(currentSlice);
+				String colon = s.equals("")?"":":";
+				if (label!=null && !label.equals(""))
+					s += colon+label;
+				else
+					s += colon+currentSlice;
+			}
+		}
+		return s;
+	}
+	
+	/** Writes the last row in the system results table to the Results window. */
+	public void displayResults() {
+		if (rt.columnDeleted())
+			return;
+		int counter = rt.size();
+		if (counter==1)
+			IJ.setColumnHeadings(rt.getColumnHeadings());
+		TextPanel tp = IJ.isResultsWindow()?IJ.getTextPanel():null;
+		int lineCount = tp!=null?IJ.getTextPanel().getLineCount():0;
+		if (counter>lineCount+1) { // delete rt rows added by particle analyzer
+			int n = counter - lineCount - 1;
+			int index = lineCount;
+			for (int i=0; i<n; i++)
+				rt.deleteRow(index);
+			counter = rt.size();
+		}
+		if (!resultsUpdated && counter>1 && rt.getColumnIndex("Group")>=0 && rt.getValue("Group",counter-1)>0) {
+			rt.show("Results");
+			resultsUpdated = true;
+		} else
+			IJ.write(rt.getRowAsString(counter-1));
+	}
+
+	/** Redisplays the results table. */
+	public void updateHeadings() {
+		rt.show("Results");
+	}
+
+	/** Converts a number to a formatted string with a tab at the end. */
+	public String n(double n) {
+		String s;
+		if (Math.round(n)==n)
+			s = ResultsTable.d2s(n,0);
+		else
+			s = ResultsTable.d2s(n,precision);
+		return s+"\t";
+	}
+		
+	void incrementCounter() {
+		if (rt==null) rt = systemRT;
+		rt.incrementCounter();
+		unsavedMeasurements = true;
+	}
+	
+	public void summarize() {
+		if (summarized)
+			return;
+		int n = rt.size();
+		if (n<2)
+			return;
+		String[] headings = rt.getHeadings();
+		int columns = headings.length;
+		if (columns==0)
+			return;
+		int first = "Label".equals(headings[0])?1:0;
+		double[] min = new double[columns];
+		double[] max = new double[columns];
+		double[] sum = new double[columns];
+		double[] sum2 = new double[columns];
+		for (int i=0; i<columns; i++) {
+			min[i] = Double.MAX_VALUE;
+			max[i] = -Double.MAX_VALUE;
+		}
+		for (int row=0; row<n; row++) {
+			for (int col=first; col<columns; col++) {
+				double v = rt.getValue(headings[col], row);
+				if (v<min[col]) min[col]=v;
+				if (v>max[col]) max[col]=v;
+				sum[col]+=v;
+				sum2[col]+=v*v;
+			}
+		}
+		rt.incrementCounter(); rt.setLabel("Mean", n+0);
+		rt.incrementCounter(); rt.setLabel("SD", n+1);
+		rt.incrementCounter(); rt.setLabel("Min", n+2);
+		rt.incrementCounter(); rt.setLabel("Max", n+3);
+		for (int col=first; col<columns; col++) {
+			rt.setValue(headings[col], n+0, sum[col]/n);
+			rt.setValue(headings[col], n+1, Math.sqrt((sum2[col]-sum[col]*sum[col]/n)/(n-1)));
+			rt.setValue(headings[col], n+2, min[col]);
+			rt.setValue(headings[col], n+3, max[col]);
+		}
+		rt.show("Results");
+		summarized = true;
+	}
+
+	/** Returns the current measurement count. */
+	public static int getCounter() {
+		return systemRT.size();
+	}
+
+	/** Sets the measurement counter to zero. Displays a dialog that
+	    allows the user to save any existing measurements. Returns
+	    false if the user cancels the dialog.
+	*/
+	public synchronized static boolean resetCounter() {
+		TextPanel tp = IJ.isResultsWindow()?IJ.getTextPanel():null;
+		int counter = systemRT.size();
+		int lineCount = tp!=null?IJ.getTextPanel().getLineCount():0;
+		ImageJ ij = IJ.getInstance();
+		boolean macro = (IJ.macroRunning()&&!switchingModes) || Interpreter.isBatchMode();
+		switchingModes = false;
+		if (counter>0 && lineCount>0 && unsavedMeasurements && !macro && ij!=null && !ij.quitting()) {
+			YesNoCancelDialog d = new YesNoCancelDialog(ij, "ImageJ", "Save "+counter+" measurements?");
+			if (d.cancelPressed())
+				return false;
+			else if (d.yesPressed()) {
+				if (!(new MeasurementsWriter()).save(""))
+					return false;
+			}
+		}
+		umeans = null;
+		systemRT.reset();
+		RoiManager.resetMultiMeasureResults();
+		unsavedMeasurements = false;
+		if (tp!=null) tp.clear();
+		summarized = false;
+		return true;
+	}
+	
+	public static void setUnsavedMeasurements(boolean b) {
+		unsavedMeasurements = b;
+	}
+	
+	// Returns the measurement options defined in the Set Measurements dialog. */
+	public static int getMeasurements() {
+		return systemMeasurements;
+	}
+
+	/** Sets the system-wide measurement options. */
+	public static void setMeasurements(int measurements) {
+		systemMeasurements = measurements;
+	}
+
+	/** Sets the specified system-wide measurement option. */
+	public static void setMeasurement(int option, boolean state) {
+			if (state) {
+				systemMeasurements |= option;
+				if ((option&ADD_TO_OVERLAY)!=0)
+					drawLabels = true;
+			} else
+				systemMeasurements &= ~option;
+	}
+
+	/** Called once when ImageJ quits. */
+	public static void savePreferences(Properties prefs) {
+		prefs.put(MEASUREMENTS, Integer.toString(systemMeasurements));
+		//prefs.put(MARK_WIDTH, Integer.toString(markWidth));
+		prefs.put(PRECISION, Integer.toString(precision));	}
+
+	/** Returns an array containing the first 20 uncalibrated means. */
+	public static float[] getUMeans() {
+		return umeans;
+	}
+
+	/** Returns the default results table. This table should only
+		be displayed in a the "Results" window. */
+	public static ResultsTable getResultsTable() {
+		systemRT.showRowNumbers(true);
+		return systemRT;
+	}
+	
+	/** Returns the number of digits displayed to the right of decimal point. */
+	public static int getPrecision() {
+		return precision;
+	}
+
+	/** Sets the number of digits displayed to the right of decimal point. */
+	public static void setPrecision(int decimalPlaces) {
+		if (decimalPlaces<0) decimalPlaces = 0;
+		if (decimalPlaces>9) decimalPlaces = 9;
+		precision = decimalPlaces;
+	}
+
+	/** Returns an updated Y coordinate based on
+		the current "Invert Y Coordinates" flag. */
+	public static int updateY(int y, int imageHeight) {
+		if ((systemMeasurements&INVERT_Y)!=0)
+			y = imageHeight-y-1;
+		return y;
+	}
+	
+	/** Returns an updated Y coordinate based on
+		the current "Invert Y Coordinates" flag. */
+	public static double updateY(double y, int imageHeight) {
+		if ((systemMeasurements&INVERT_Y)!=0)
+			y = imageHeight-y-1;
+		return y;
+	}
+	
+	/** Sets the default headings ("Area", "Mean", etc.). */
+	public static void setDefaultHeadings() {
+		systemRT.setDefaultHeadings();
+	}
+
+	public static void setOption(String option, boolean b) {
+		if (option.contains("min"))
+			showMin = b;
+		else if (option.contains("angle"))
+			showAngle = b;
+	}
+	
+	public static boolean addToOverlay() {
+		return ((getMeasurements()&ADD_TO_OVERLAY)!=0);
+	}
+	
+	public static void setResultsTable(ResultsTable rt) {
+		TextPanel tp = IJ.isResultsWindow()?IJ.getTextPanel():null;
+		if (tp!=null)
+			tp.clear();
+		if (rt==null)
+			rt = new ResultsTable();
+		rt.setPrecision((systemMeasurements&SCIENTIFIC_NOTATION)!=0?-precision:precision);
+		rt.setNaNEmptyCells((systemMeasurements&NaN_EMPTY_CELLS)!=0);
+		systemRT = rt;
+		summarized = false;
+		umeans = null;
+		unsavedMeasurements = false;
+	}
+	
+	public static void drawLabels(boolean b) {
+		drawLabels = b;
+	}
+	
+	/** Used by RoiManager.multiMeasure() to suppress save as dialogs. */
+	public void disableReset(boolean b) {
+		disableReset = b;
+	}
+
+}
+	
diff --git a/src/ij/plugin/filter/BackgroundSubtracter.java b/src/ij/plugin/filter/BackgroundSubtracter.java
new file mode 100644
index 0000000..13b925a
--- /dev/null
+++ b/src/ij/plugin/filter/BackgroundSubtracter.java
@@ -0,0 +1,829 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.util.Tools;
+import java.awt.*;
+
+
+/** Implements ImageJ's Subtract Background command. Based on the concept of the
+rolling ball algorithm described in Stanley Sternberg's article, "Biomedical Image
+Processing", IEEE Computer, January 1983.
+
+Imagine that the 2D grayscale image has a third (height) dimension by the image
+value at every point in the image, creating a surface. A ball of given radius is
+rolled over the bottom side of this surface; the hull of the volume reachable by
+the ball is the background.
+
+With "Sliding Parabvoloid", the rolling ball is replaced by a sliding paraboloid
+of rotation with the same curvature at its apex as a ball of a given radius.
+A paraboloid has the advantage that suitable paraboloids can be found for any image
+values, even if the pixel values are much larger than a typical object size (in pixels).
+The paraboloid of rotation is approximated as parabolae in 4 directions: x, y and
+the two 45-degree directions. Lines of the image in these directions are processed
+by sliding a parabola against them. Obtaining the hull needs the parabola for a
+given direction to be applied multiple times (after doing the other directions);
+in this respect the current code is a compromise between accuracy and speed.
+
+For noise rejection, with the sliding paraboloid algorithm, a 3x3 maximum of the
+background is applied. With both, rolling ball and sliding paraboloid,
+the image used for calculating the background is slightly smoothened (3x3 average).
+This can result in negative values after background subtraction. This preprocessing
+can be disabled.
+
+In the sliding paraboloid algorithm, additional code has been added to avoid
+subtracting corner objects as a background (note that a paraboloid or ball would
+always touch the 4 corner pixels and thus make them background pixels).
+This code assumes that corner particles reach less than 1/4 of the image size
+into the image.
+
+Rolling ball code based on the NIH Image Pascal version by Michael Castle and Janice 
+Keller of the University of Michigan Mental Health Research Institute.
+Sliding Paraboloid by Michael Schmid, 2007.
+
+Version 10-Jan-2008
+*/
+public class BackgroundSubtracter implements ExtendedPlugInFilter, DialogListener {
+    /* parameters from the dialog: */
+    private static double staticRadius = 50;  // default rolling ball radius
+    private static boolean staticLightBackground = Prefs.get("bs.background", true);
+    private static boolean staticSeparateColors; // whether to create a separate background for each color channel
+    private static boolean staticCreateBackground;   // don't subtract background (e.g., for processing the background before subtracting)
+    private static boolean staticUseParaboloid; // use "Sliding Paraboloid" instead of rolling ball algorithm
+    private static boolean staticDoPresmooth = true; // smoothen the image before creating the background
+    private double radius = staticRadius;
+    private boolean lightBackground = staticLightBackground;
+    private boolean separateColors = staticSeparateColors;
+    private boolean createBackground = staticCreateBackground;
+    private boolean useParaboloid = staticUseParaboloid;
+    private boolean doPresmooth = staticDoPresmooth;
+    /* more class variables */
+    private boolean isRGB;              // whether we have an RGB image
+    private boolean previewing;
+    private final static int MAXIMUM = 0, MEAN = 1;         //filter types of filter3x3
+    private final static int X_DIRECTION = 0, Y_DIRECTION = 1,
+            DIAGONAL_1A = 2, DIAGONAL_1B = 3, DIAGONAL_2A = 4, DIAGONAL_2B = 5; //filter directions
+    private final static int DIRECTION_PASSES = 9; //number of passes for different directions
+    private int nPasses = DIRECTION_PASSES;
+    private int pass;
+    private int flags = DOES_ALL|FINAL_PROCESSING|KEEP_PREVIEW|PARALLELIZE_STACKS;
+    private boolean calledAsPlugin;
+
+
+    public int setup(String arg, ImagePlus imp) {
+        if (arg.equals("final")) {
+            imp.getProcessor().resetMinAndMax();
+            return DONE;
+        } else
+            return flags;
+    }
+
+    public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+        isRGB = imp.getProcessor() instanceof ColorProcessor;
+        calledAsPlugin = true;
+        String options = Macro.getOptions();
+        if  (options!=null) {  //macro
+            Macro.setOptions(options.replaceAll("white", "light"));
+            radius = 50;
+            lightBackground = false;
+            separateColors = false;
+            createBackground = false;
+            useParaboloid = false;
+            doPresmooth = true;
+        }
+        GenericDialog gd = new GenericDialog(command);
+        gd.addNumericField("Rolling ball radius:", radius, 1, 6, "pixels");
+        gd.addCheckbox("Light background", lightBackground);
+        if (isRGB) gd.addCheckbox("Separate colors", separateColors);
+        gd.addCheckbox("Create background (don't subtract)", createBackground);
+        gd.addCheckbox("Sliding paraboloid", useParaboloid);
+        gd.addCheckbox("Disable smoothing", !doPresmooth);
+        gd.addPreviewCheckbox(pfr);
+        gd.addDialogListener(this);
+        previewing = true;
+		gd.addHelp(IJ.URL+"/docs/menus/process.html#background");
+        gd.showDialog();
+        previewing = false;
+        if (gd.wasCanceled()) return DONE;
+        IJ.register(this.getClass());       //protect static class variables (filter parameters) from garbage collection
+        if ((imp.getProcessor() instanceof FloatProcessor) && !createBackground)
+            flags |= SNAPSHOT;              //FloatProcessors need the original to subtract it from the background
+        if  (options==null) { // not a macro
+            staticRadius = radius;
+            staticLightBackground = lightBackground;
+            staticSeparateColors = separateColors;
+            staticCreateBackground = createBackground;
+            staticUseParaboloid = useParaboloid;
+            staticDoPresmooth = doPresmooth;
+            Prefs.set("bs.background", lightBackground);
+        }
+        return IJ.setupDialog(imp, flags);  //ask whether to process all slices of stack (if a stack)
+    }
+
+    public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+        radius = gd.getNextNumber();
+        if (radius <= 0.0001 || gd.invalidNumber())
+            return false;
+        lightBackground = gd.getNextBoolean();
+        if (isRGB) separateColors = gd.getNextBoolean();
+        createBackground = gd.getNextBoolean();
+        useParaboloid = gd.getNextBoolean();
+        doPresmooth = !gd.getNextBoolean();
+        return true;
+    }
+
+    /** Background for any image type */
+    public void run(ImageProcessor ip) {
+        if (isRGB && !separateColors)
+            rollingBallBrightnessBackground((ColorProcessor)ip, radius, createBackground, lightBackground, useParaboloid, doPresmooth, true);
+        else
+            rollingBallBackground(ip, radius, createBackground, lightBackground, useParaboloid, doPresmooth, true);
+        if (previewing && (ip instanceof FloatProcessor || ip instanceof ShortProcessor)) {
+            ip.resetMinAndMax();
+        }
+    }
+
+    /** Depracated. For compatibility with previous ImageJ versions */
+    public void subtractRGBBackround(ColorProcessor ip, int ballRadius) {
+        rollingBallBrightnessBackground(ip, (double)ballRadius, false, lightBackground, false, true, true);
+    }
+    /** Depracated. For compatibility with previous ImageJ versions */
+    public void subtractBackround(ImageProcessor ip, int ballRadius) {
+        rollingBallBackground(ip, (double)ballRadius, false, lightBackground, false, true, true);
+    }
+
+    /** Create or subtract a background, based on the brightness of an RGB image (keeping
+     * the hue of each pixel unchanged)
+     * @param ip            The RGB image. On output, it will become the background-subtracted image or
+     *                      the background (depending on <code>createBackground</code>).
+     * @param radius        Radius of the rolling ball creating the background (actually a
+     *                      paraboloid of rotation with the same curvature)
+     * @param createBackground  Whether to create a background, not to subtract it.
+     * @param lightBackground   Whether the image has a light background.
+     * @param doPresmooth   Whether the image should be smoothened (3x3 mean) before creating
+     *                      the background. With smoothing, the background will not necessarily
+     *                      be below the image data.
+     * @param correctCorners    Whether the algorithm should try to detect corner particles to avoid
+     *                      subtracting them as a background.
+     */
+    public void rollingBallBrightnessBackground(ColorProcessor ip, double radius, boolean createBackground,
+            boolean lightBackground, boolean useParaboloid, boolean doPresmooth, boolean correctCorners) {
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        byte[] H = new byte[width*height];
+        byte[] S = new byte[width*height];
+        byte[] B = new byte[width*height];
+        ip.getHSB(H, S, B);
+        ByteProcessor bp = new ByteProcessor(width, height, B, null);
+        rollingBallBackground(bp, radius, createBackground, lightBackground, useParaboloid, doPresmooth, correctCorners);
+        ip.setHSB(H, S, (byte[])bp.getPixels());
+    }
+
+    /** Create or subtract a background, works for all image types. For RGB images, the
+     * background is subtracted from each channel separately
+     * @param ip            The image. On output, it will become the background-subtracted image or
+     *                      the background (depending on <code>createBackground</code>).
+     * @param radius        Radius of the rolling ball creating the background (actually a
+     *                      paraboloid of rotation with the same curvature)
+     * @param createBackground  Whether to create a background, not to subtract it.
+     * @param lightBackground   Whether the image has a light background.
+     * @param useParaboloid   Whether to use the "sliding paraboloid" algorithm.
+     * @param doPresmooth   Whether the image should be smoothened (3x3 mean) before creating
+     *                      the background. With smoothing, the background will not necessarily
+     *                      be below the image data.
+     * @param correctCorners    Whether the algorithm should try to detect corner particles to avoid
+     *                      subtracting them as a background.
+     */
+    public void rollingBallBackground(ImageProcessor ip, double radius, boolean createBackground,
+            boolean lightBackground, boolean useParaboloid, boolean doPresmooth, boolean correctCorners) {
+        boolean invertedLut = ip.isInvertedLut();
+        boolean invert = (invertedLut && !lightBackground) || (!invertedLut && lightBackground);
+        RollingBall ball = null;
+        if (!useParaboloid) ball = new RollingBall(radius);
+        FloatProcessor fp = null;
+        for (int channelNumber=0; channelNumber<ip.getNChannels(); channelNumber++) {
+            fp = ip.toFloat(channelNumber, fp);
+            if ((ip instanceof FloatProcessor) && !calledAsPlugin && !createBackground)
+                fp.snapshot();  //float images need a snapshot to subtract
+            if (useParaboloid)
+                slidingParaboloidFloatBackground(fp, (float)radius, invert, doPresmooth, correctCorners);
+            else
+                rollingBallFloatBackground(fp, (float)radius, invert, doPresmooth, ball);
+
+            if (createBackground)
+                ip.setPixels(channelNumber, fp);
+            else {                                          //subtract the background now
+                float[] bgPixels = (float[])fp.getPixels(); //currently holds the background
+                if (ip instanceof FloatProcessor) {         //here ip and fp are the same (bgPixels will be output)
+                    float[] snapshotPixels = (float[])fp.getSnapshotPixels(); //original data in the snapshot
+                    for (int p=0; p<bgPixels.length; p++)
+                        bgPixels[p] = snapshotPixels[p]-bgPixels[p];
+                //for all others, the image data are in ip, the background is in fp
+                } else if (ip instanceof ShortProcessor) {
+                    float offset = invert ? 65535.5f : 0.5f;//includes 0.5 for rounding when converting float to short
+                    short[] pixels = (short[])ip.getPixels();
+                    for (int p=0; p<bgPixels.length; p++) {
+                        float value = (pixels[p]&0xffff) - bgPixels[p] + offset;
+                        if (value<0f) value = 0f;
+
+                        if (value>65535f) value = 65535f;
+
+                        pixels[p] = (short)(value);
+                    }
+                } else if (ip instanceof ByteProcessor) {
+                    float offset = invert ? 255.5f : 0.5f;  //includes 0.5 for rounding when converting float to byte
+                    byte[] pixels = (byte[])ip.getPixels();
+                    for (int p=0; p<bgPixels.length; p++) {
+                        float value = (pixels[p]&0xff) - bgPixels[p] + offset;
+                        if (value<0f) value = 0f;
+
+                        if (value>255f) value = 255f;
+
+                        pixels[p] = (byte)(value);
+                    }
+                } else if (ip instanceof ColorProcessor) {
+                    float offset = invert ? 255.5f : 0.5f;
+                    int[] pixels = (int[])ip.getPixels();
+            		int shift = 16 - 8*channelNumber;
+
+            		int byteMask = 255<<shift;
+            		int resetMask = 0xffffffff^(255<<shift);
+
+                    for (int p=0; p<bgPixels.length; p++) {
+                        int pxl = pixels[p];
+                        float value = ((pxl&byteMask)>>shift) - bgPixels[p] + offset;
+                        if (value<0f) value = 0f;
+
+                        if (value>255f) value = 255f;
+                        pixels[p] = (pxl&resetMask) | ((int)value<<shift);
+
+                    }
+                }
+            }
+        }
+    }
+
+    //  S L I D E   P A R A B O L O I D   S E C T I O N
+
+    /** Create background for a float image by sliding a paraboloid over
+     * the image. */
+    void slidingParaboloidFloatBackground(FloatProcessor fp, float radius, boolean invert,
+            boolean doPresmooth, boolean correctCorners) {
+        float[] pixels = (float[])fp.getPixels();   //this will become the background
+        int width = fp.getWidth();
+        int height = fp.getHeight();
+        float[] cache = new float[Math.max(width, height)]; //work array for lineSlideParabola
+        int[] nextPoint = new int[Math.max(width, height)]; //work array for lineSlideParabola
+        float coeff2 = 0.5f/radius;                 //2nd-order coefficient of the polynomial approximating the ball
+        float coeff2diag = 1.f/radius;              //same for diagonal directions where step is sqrt2
+
+        showProgress(0.000001);                     //start the progress bar (only filter1D will increment it)
+        if (invert)
+            for (int i=0; i<pixels.length; i++)
+                pixels[i] = -pixels[i];
+
+        float shiftBy = 0;
+        if (doPresmooth) {
+            shiftBy = (float)filter3x3(fp, MAXIMUM);//3x3 maximum to remove dust etc.
+            showProgress(0.5);
+            filter3x3(fp, MEAN);                    //smoothing to remove noise
+            pass++;
+        }
+        if (correctCorners)
+            correctCorners(fp, coeff2, cache, nextPoint);   //modify corner data, avoids subtracting corner particles
+
+        /* Slide the parabola over the image in different directions */
+        /* Doing the diagonal directions at the end is faster (diagonal lines are denser,
+         * so there are more such lines, and the algorithm gets faster with each iteration) */
+        filter1D(fp, X_DIRECTION, coeff2, cache, nextPoint);
+        filter1D(fp, Y_DIRECTION, coeff2, cache, nextPoint);
+        filter1D(fp, X_DIRECTION, coeff2, cache, nextPoint);    //redo for better accuracy
+        filter1D(fp, DIAGONAL_1A, coeff2diag, cache, nextPoint);
+        filter1D(fp, DIAGONAL_1B, coeff2diag, cache, nextPoint);
+        filter1D(fp, DIAGONAL_2A, coeff2diag, cache, nextPoint);
+        filter1D(fp, DIAGONAL_2B, coeff2diag, cache, nextPoint);
+        filter1D(fp, DIAGONAL_1A, coeff2diag, cache, nextPoint);//redo for better accuracy
+        filter1D(fp, DIAGONAL_1B, coeff2diag, cache, nextPoint);
+
+        if (invert)
+            for (int i=0; i<pixels.length; i++)
+                pixels[i] = -(pixels[i] - shiftBy);
+        else if (doPresmooth)
+            for (int i=0; i<pixels.length; i++)
+                pixels[i] -= shiftBy;   //correct for shift by 3x3 maximum
+
+    }
+
+    /** Filter by subtracting a sliding parabola for all lines in one direction, x, y or one of
+     *  the two diagonal directions (diagonals are processed only for half the image per call). */
+    void filter1D(FloatProcessor fp, int direction, float coeff2, float[] cache, int[] nextPoint) {
+        float[] pixels = (float[])fp.getPixels();   //this will become the background
+        int width = fp.getWidth();
+        int height = fp.getHeight();
+        int startLine = 0;          //index of the first line to handle
+        int nLines = 0;             //index+1 of the last line to handle (initialized to avoid compile-time error)
+        int lineInc = 0;            //increment from one line to the next in pixels array
+        int pointInc = 0;           //increment from one point to the next along the line
+        int length = 0;             //length of the line
+        switch (direction) {
+            case X_DIRECTION:       //lines parallel to x direction
+                nLines = height;
+                lineInc = width;
+                pointInc = 1;
+                length = width;
+            break;
+            case Y_DIRECTION:       //lines parallel to y direction
+                nLines = width;
+                lineInc = 1;
+                pointInc = width;
+                length = height;
+            break;
+            case DIAGONAL_1A:       //lines parallel to x=y, starting at x axis
+                nLines = width-2;   //the algorithm makes no sense for lines shorter than 3 pixels
+                lineInc = 1;
+                pointInc = width + 1;
+            break;
+            case DIAGONAL_1B:       //lines parallel to x=y, starting at y axis
+                startLine = 1;
+                nLines = height-2;
+                lineInc = width;
+                pointInc = width + 1;
+            break;
+            case DIAGONAL_2A:       //lines parallel to x=-y, starting at x axis
+                startLine = 2;
+                nLines = width;
+                lineInc = 1;
+                pointInc = width - 1;
+            break;
+            case DIAGONAL_2B:       //lines parallel to x=-y, starting at x=width-1, y=variable
+                startLine = 0;
+                nLines = height-2;
+                lineInc = width;
+                pointInc = width - 1;
+            break;
+        }
+        for (int i=startLine; i<nLines; i++) {
+            if (i%50==0) {
+                if (Thread.currentThread().isInterrupted()) return;
+                showProgress(i/(double)nLines);
+            }
+            int startPixel = i*lineInc;
+            if (direction == DIAGONAL_2B) startPixel += width-1;
+            switch (direction) {
+                case DIAGONAL_1A: length = Math.min(height, width-i); break;
+                case DIAGONAL_1B: length = Math.min(width, height-i); break;
+                case DIAGONAL_2A: length = Math.min(height, i+1);     break;
+                case DIAGONAL_2B: length = Math.min(width, height-i); break;
+            }
+            lineSlideParabola(pixels, startPixel, pointInc, length, coeff2, cache, nextPoint, null);
+        }
+        pass++;
+    } //void filter1D
+
+    /** Process one straight line in the image by sliding a parabola along the line
+     *  (from the bottom) and setting the values to make all points reachable by
+     *  the parabola
+     * @param pixels    Image data, will be modified by parabolic interpolation
+     *                  where the parabola does not touch.
+     * @param start     Index of first pixel of the line in pixels array
+     * @param inc       Increment of index in pixels array
+     * @param length    Number of points the line consists of
+     * @param coeff2    2nd order coefficient of the polynomial describing the parabola,
+     *                  must be positive (although a parabola with negative curvature is
+     *                  actually used)
+     * @param cache     Work array, length at least <code>length</code>. Will usually remain
+     *                  in the CPU cache and may therefore speed up the code.
+     * @param nextPoint Work array. Will hold the index of the next point with sufficient local
+     *                  curvature to get touched by the parabola.
+     * @param correctedEdges Should be a 2-element array used for output or null.
+     * @return          The correctedEdges array (if non-null on input) with the two estimated
+     *                  edge pixel values corrected for edge particles.
+     */
+    static float[] lineSlideParabola(float[] pixels, int start, int inc, int length, float coeff2, float[] cache, int[] nextPoint, float[] correctedEdges) {
+        float minValue = Float.MAX_VALUE;
+        int lastpoint = 0;
+        int firstCorner = length-1;             // the first point except the edge that is touched
+        int lastCorner = 0;                     // the last point except the edge that is touched
+        float vPrevious1 = 0f;
+        float vPrevious2 = 0f;
+        float curvatureTest = 1.999f*coeff2;     //not 2: numeric scatter of 2nd derivative
+        /* copy data to cache, determine the minimum, and find points with local curvature such
+         * that the parabola can touch them - only these need to be examined futher on */
+        for (int i=0, p=start; i<length; i++, p+=inc) {
+            float v = pixels[p];
+            cache[i] = v;
+            if (v < minValue) minValue = v;
+            if (i >= 2 && vPrevious1+vPrevious1-vPrevious2-v < curvatureTest) {
+                nextPoint[lastpoint] = i-1;     // point i-1 may be touched
+                lastpoint = i-1;
+            }
+            vPrevious2 = vPrevious1;
+            vPrevious1 = v;
+        }
+        nextPoint[lastpoint] = length-1;
+        nextPoint[length-1] = Integer.MAX_VALUE;// breaks the search loop
+
+        int i1 = 0;                             // i1 and i2 will be the two points where the parabola touches
+        while (i1<length-1) {
+            float v1 = cache[i1];
+            float minSlope = Float.MAX_VALUE;
+            int i2 = 0;                         //(initialized to avoid compile-time error)
+            int searchTo = length;
+            int recalculateLimitNow = 0;        // when 0, limits for searching will be recalculated
+            /* find the second point where the parabola through point i1,v1 touches: */
+            for (int j=nextPoint[i1]; j<searchTo; j=nextPoint[j], recalculateLimitNow++) {
+                float v2 = cache[j];
+                float slope = (v2-v1)/(j-i1)+coeff2*(j-i1);
+                if (slope < minSlope) {
+                    minSlope = slope;
+                    i2 = j;
+                    recalculateLimitNow = -3;
+                }
+                if (recalculateLimitNow==0) {   //time-consuming recalculation of search limit: wait a bit after slope is updated
+                    double b = 0.5f*minSlope/coeff2;
+                    int maxSearch = i1+(int)(b+Math.sqrt(b*b+(v1-minValue)/coeff2)+1); //(numeric overflow may make this negative)
+                    if (maxSearch < searchTo && maxSearch > 0) searchTo = maxSearch;
+                }
+            }
+            if (i1 == 0) firstCorner = i2;
+            if (i2 == length-1) lastCorner = i1;
+            /* interpolate between the two points where the parabola touches: */
+            for (int j=i1+1, p=start+j*inc; j<i2; j++, p+=inc)
+                pixels[p] = v1 + (j-i1)*(minSlope - (j-i1)*coeff2);
+            i1 = i2;                            // continue from this new point
+        } //while (i1<length-1)
+        /* Now calculate estimated edge values without an edge particle, allowing for vignetting
+         * described as a 6th-order polynomial: */
+        if (correctedEdges != null) {
+            if (4*firstCorner >= length) firstCorner = 0; // edge particles must be < 1/4 image size
+            if (4*(length - 1 - lastCorner) >= length) lastCorner = length - 1;
+            float v1 = cache[firstCorner];
+            float v2 = cache[lastCorner];
+            float slope = (v2-v1)/(lastCorner-firstCorner); // of the line through the two outermost non-edge touching points
+            float value0 = v1 - slope * firstCorner;        // offset of this line
+            float coeff6 = 0;                               // coefficient of 6th order polynomial
+            float mid = 0.5f * (lastCorner + firstCorner);
+            for (int i=(length+2)/3; i<=(2*length)/3; i++) {// compare with mid-image pixels to detect vignetting
+                float dx = (i-mid)*2f/(lastCorner-firstCorner);
+                float poly6 = dx*dx*dx*dx*dx*dx - 1f;       // the 6th order polynomial, zero at firstCorner and lastCorner
+                if (cache[i] < value0 + slope*i + coeff6*poly6) {
+                    coeff6 = -(value0 + slope*i - cache[i])/poly6;
+                }
+            }
+            float dx = (firstCorner-mid)*2f/(lastCorner-firstCorner);
+            correctedEdges[0] = value0 + coeff6*(dx*dx*dx*dx*dx*dx - 1f) + coeff2*firstCorner*firstCorner;
+            dx = (lastCorner-mid)*2f/(lastCorner-firstCorner);
+            correctedEdges[1] = value0 + (length-1)*slope + coeff6*(dx*dx*dx*dx*dx*dx - 1f) + coeff2*(length-1-lastCorner)*(length-1-lastCorner);
+        }
+        return correctedEdges;
+    } //void lineSlideParabola
+
+    /** Detect corner particles and adjust corner pixels if a particle is there.
+     *  Analyzing the directions parallel to the edges and the diagonals, we
+     *  average over the 3 correction values (found for the 3 directions)
+     */
+    void correctCorners(FloatProcessor fp, float coeff2, float[] cache, int[] nextPoint) {
+        int width = fp.getWidth();
+        int height = fp.getHeight();
+        float[] pixels = (float[])fp.getPixels();
+        float[] corners = new float[4];         //(0,0); (xmax,0); (ymax,0); (xmax,ymax)
+        float[] correctedEdges = new float[2];
+        correctedEdges = lineSlideParabola(pixels, 0, 1, width, coeff2, cache, nextPoint, correctedEdges);
+        corners[0] = correctedEdges[0];
+        corners[1] = correctedEdges[1];
+        correctedEdges = lineSlideParabola(pixels, (height-1)*width, 1, width, coeff2, cache, nextPoint, correctedEdges);
+        corners[2] = correctedEdges[0];
+        corners[3] = correctedEdges[1];
+        correctedEdges = lineSlideParabola(pixels, 0, width, height, coeff2, cache, nextPoint, correctedEdges);
+        corners[0] += correctedEdges[0];
+        corners[2] += correctedEdges[1];
+        correctedEdges = lineSlideParabola(pixels, width-1, width, height, coeff2, cache, nextPoint, correctedEdges);
+        corners[1] += correctedEdges[0];
+        corners[3] += correctedEdges[1];
+        int diagLength = Math.min(width,height);        //length of a 45-degree line from a corner
+        float coeff2diag = 2 * coeff2;
+        correctedEdges = lineSlideParabola(pixels, 0, 1+width, diagLength, coeff2diag, cache, nextPoint, correctedEdges);
+        corners[0] += correctedEdges[0];
+        correctedEdges = lineSlideParabola(pixels, width-1, -1+width, diagLength, coeff2diag, cache, nextPoint, correctedEdges);
+        corners[1] += correctedEdges[0];
+        correctedEdges = lineSlideParabola(pixels, (height-1)*width, 1-width, diagLength, coeff2diag, cache, nextPoint, correctedEdges);
+        corners[2] += correctedEdges[0];
+        correctedEdges = lineSlideParabola(pixels, width*height-1, -1-width, diagLength, coeff2diag, cache, nextPoint, correctedEdges);
+        corners[3] += correctedEdges[0];
+        if (pixels[0] > corners[0]/3) pixels[0] = corners[0]/3;
+        if (pixels[width-1] > corners[1]/3) pixels[width-1] = corners[1]/3;
+        if (pixels[(height-1)*width] > corners[2]/3) pixels[(height-1)*width] = corners[2]/3;
+        if (pixels[width*height-1] > corners[3]/3) pixels[width*height-1] = corners[3]/3;
+        //new ImagePlus("corner corrected",fp.duplicate()).show();
+    } //void correctCorners
+
+    //  R O L L   B A L L   S E C T I O N
+
+    /** Create background for a float image by rolling a ball over
+     * the image. */
+    void rollingBallFloatBackground(FloatProcessor fp, float radius, boolean invert,
+            boolean doPresmooth, RollingBall ball) {
+        float[] pixels = (float[])fp.getPixels();   //this will become the background
+        boolean shrink = ball.shrinkFactor >1;
+
+        showProgress(0.0);
+        if (invert)
+            for (int i=0; i<pixels.length; i++)
+                pixels[i] = -pixels[i];
+        if (doPresmooth)
+            filter3x3(fp, MEAN);
+        double[] minmax = Tools.getMinMax(pixels);
+        if (Thread.currentThread().isInterrupted()) return;
+        FloatProcessor smallImage = shrink ? shrinkImage(fp, ball.shrinkFactor) : fp;
+        if (Thread.currentThread().isInterrupted()) return;
+        rollBall(ball, smallImage);
+        if (Thread.currentThread().isInterrupted()) return;
+        showProgress(0.9);
+        if (shrink)
+            enlargeImage(smallImage, fp, ball.shrinkFactor);
+        if (Thread.currentThread().isInterrupted()) return;
+
+        if (invert)
+            for (int i=0; i<pixels.length; i++)
+                pixels[i] = -pixels[i];
+        pass++;
+    }
+
+    /** Creates a lower resolution image for ball-rolling. */
+    FloatProcessor shrinkImage(FloatProcessor ip, int shrinkFactor) {
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        float[] pixels = (float[])ip.getPixels();
+        int sWidth = (width+shrinkFactor-1)/shrinkFactor;
+        int sHeight = (height+shrinkFactor-1)/shrinkFactor;
+        showProgress(0.1);
+        FloatProcessor smallImage = new FloatProcessor(sWidth, sHeight);
+        float[] sPixels = (float[])smallImage.getPixels();
+        float min, thispixel;
+        for (int ySmall=0; ySmall<sHeight; ySmall++) {
+            for (int xSmall=0; xSmall<sWidth; xSmall++) {
+                min = Float.MAX_VALUE;
+                for (int j=0, y=shrinkFactor*ySmall; j<shrinkFactor&&y<height; j++, y++) {
+                    for (int k=0, x=shrinkFactor*xSmall; k<shrinkFactor&&x<width; k++, x++) {
+                        thispixel = pixels[x+y*width];
+                        if (thispixel<min)
+                            min = thispixel;
+                    }
+                }
+                sPixels[xSmall+ySmall*sWidth] = min; // each point in small image is minimum of its neighborhood
+            }
+        }
+        //new ImagePlus("smallImage", smallImage).show();
+        return smallImage;
+    }
+
+    /** 'Rolls' a filtering object over a (shrunken) image in order to find the
+        image's smooth continuous background.  For the purpose of explaining this
+        algorithm, imagine that the 2D grayscale image has a third (height) dimension
+        defined by the intensity value at every point in the image.  The center of
+        the filtering object, a patch from the top of a sphere having radius BallRadius,
+        is moved along each scan line of the image so that the patch is tangent to the
+        image at one or more points with every other point on the patch below the
+        corresponding (x,y) point of the image.  Any point either on or below the patch
+        during this process is considered part of the background.  Shrinking the image
+        before running this procedure is advised for large ball radii because the
+        processing time increases with ball radius^2.
+    */
+    void rollBall(RollingBall ball, FloatProcessor fp) {
+        float[] pixels = (float[])fp.getPixels();   //the input pixels
+        int width = fp.getWidth();
+        int height = fp.getHeight();
+        float[] zBall = ball.data;
+        int ballWidth = ball.width;
+        int radius = ballWidth/2;
+        float[] cache = new float[width*ballWidth]; //temporarily stores the pixels we work on
+
+		Thread thread = Thread.currentThread();
+		long lastTime = System.currentTimeMillis();
+        for (int y=-radius; y<height+radius; y++) { //for all positions of the ball center:
+			long time = System.currentTimeMillis();
+			if (time-lastTime > 100) {
+				lastTime = time;
+				if (thread.isInterrupted()) return;
+				showProgress(0.1+0.8*y/(height+ballWidth));
+            }
+            int nextLineToWriteInCache = (y+radius)%ballWidth;
+            int nextLineToRead = y + radius;        //line of the input not touched yet
+            if (nextLineToRead<height) {
+                System.arraycopy(pixels, nextLineToRead*width, cache, nextLineToWriteInCache*width, width);
+                for (int x=0, p=nextLineToRead*width; x<width; x++,p++)
+                    pixels[p] = -Float.MAX_VALUE;   //unprocessed pixels start at minus infinity
+            }
+            int y0 = y-radius;                      //the first line to see whether the ball touches
+            if (y0 < 0) y0 = 0;
+            int yBall0 = y0-y+radius;               //y coordinate in the ball corresponding to y0
+            int yend = y+radius;                    //the last line to see whether the ball touches
+            if (yend>=height) yend = height-1;
+            for (int x=-radius; x<width+radius; x++) {
+                float z = Float.MAX_VALUE;          //the height of the ball (ball is in position x,y)
+                int x0 = x-radius;
+                if (x0 < 0) x0 = 0;
+                int xBall0 = x0-x+radius;
+                int xend = x+radius;
+                if (xend>=width) xend = width-1;
+                for (int yp=y0, yBall=yBall0; yp<=yend; yp++,yBall++) { //for all points inside the ball
+                    int cachePointer = (yp%ballWidth)*width+x0;
+                    for (int xp=x0, bp=xBall0+yBall*ballWidth; xp<=xend; xp++, cachePointer++, bp++) {
+                        float zReduced = cache[cachePointer] - zBall[bp];
+                        if (z > zReduced)           //does this point imply a greater height?
+                            z = zReduced;
+                    }
+                }
+                for (int yp=y0, yBall=yBall0; yp<=yend; yp++,yBall++) //raise pixels to ball surface
+                    for (int xp=x0, p=xp+yp*width, bp=xBall0+yBall*ballWidth; xp<=xend; xp++, p++, bp++) {
+                        float zMin = z + zBall[bp];
+                        if (pixels[p] < zMin)
+                            pixels[p] = zMin;
+                    }
+            // if (x>=0&&y>=0&&x<width&&y<height) bgPixels[x+y*width] = z; //debug, ball height output
+            }
+        }
+        
+        //new ImagePlus("bg rolled", fp.duplicate()).show();
+    }
+    
+    /** Uses bilinear interpolation to find the points in the full-scale background
+        given the points from the shrunken image background. (At the edges, it is
+        actually extrapolation.)
+    */                                 
+    void enlargeImage(FloatProcessor smallImage, FloatProcessor fp, int shrinkFactor) {
+        int width = fp.getWidth();
+        int height = fp.getHeight();
+        int smallWidth = smallImage.getWidth();
+        int smallHeight = smallImage.getHeight();
+        float[] pixels = (float[])fp.getPixels();
+        float[] sPixels = (float[])smallImage.getPixels();
+        int[] xSmallIndices = new int[width];         //index of first point in smallImage
+        float[] xWeights = new float[width];        //weight of this point
+        makeInterpolationArrays(xSmallIndices, xWeights, width, smallWidth, shrinkFactor);
+        int[] ySmallIndices = new int[height];
+        float[] yWeights = new float[height];
+        makeInterpolationArrays(ySmallIndices, yWeights, height, smallHeight, shrinkFactor);
+        float[] line0 = new float[width];
+        float[] line1 = new float[width];
+        for (int x=0; x<width; x++)                 //x-interpolation of the first smallImage line
+            line1[x] = sPixels[xSmallIndices[x]] * xWeights[x] +
+                    sPixels[xSmallIndices[x]+1] * (1f - xWeights[x]);
+        int ySmallLine0 = -1;                       //line0 corresponds to this y of smallImage
+        for (int y=0; y<height; y++) {
+            if (ySmallLine0 < ySmallIndices[y]) {
+                float[] swap = line0;               //previous line1 -> line0
+                line0 = line1;
+                line1 = swap;                       //keep the other array for filling with new data
+                ySmallLine0++;
+                int sYPointer = (ySmallIndices[y]+1)*smallWidth; //points to line0 + 1 in smallImage
+                for (int x=0; x<width; x++)         //x-interpolation of the new smallImage line -> line1
+                    line1[x] = sPixels[sYPointer+xSmallIndices[x]] * xWeights[x] +
+                            sPixels[sYPointer+xSmallIndices[x]+1] * (1f - xWeights[x]);
+            }
+            float weight = yWeights[y];
+            for (int x=0, p=y*width; x<width; x++,p++)
+                pixels[p] = line0[x]*weight + line1[x]*(1f - weight);
+        }
+    }
+
+    /** Create arrays of indices and weigths for interpolation.
+     <pre>
+     Example for shrinkFactor = 4:
+        small image pixel number         |       0       |       1       |       2       | ...
+        full image pixel number          | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 |10 |11 | ...
+        smallIndex for interpolation(0)  | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 2 | 2 | ...
+     (0) Note: This is smallIndex for the left pixel; for the right pixel used for interpolation
+               it is higher by one
+     </pre>
+     */
+    void makeInterpolationArrays(int[] smallIndices, float[] weights, int length, int smallLength, int shrinkFactor) {
+        for (int i=0; i<length; i++) {
+            int smallIndex = (i - shrinkFactor/2)/shrinkFactor;
+            if (smallIndex >= smallLength-1) smallIndex = smallLength - 2;
+            smallIndices[i] = smallIndex;
+            float distance = (i + 0.5f)/shrinkFactor - (smallIndex + 0.5f); //distance of pixel centers (in smallImage pixels)
+            weights[i] = 1f - distance;
+        }
+    }
+
+    //   C O M M O N   S E C T I O N   F O R   B O T H   A L G O R I T H M S
+
+    /** Replace the pixels by the mean or maximum in a 3x3 neighborhood.
+     *  No snapshot is required (less memory needed than e.g., fp.smooth()).
+     *  When used as maximum filter, it returns the average change of the
+     *  pixel value by this operation
+     */
+    double filter3x3(FloatProcessor fp, int type) {
+        int width = fp.getWidth();
+        int height = fp.getHeight();
+        double shiftBy = 0;
+        float[] pixels = (float[])fp.getPixels();
+        for (int y=0; y<height; y++)
+            shiftBy += filter3(pixels, width, y*width, 1, type);
+        for (int x=0; x<width; x++)
+            shiftBy += filter3(pixels, height, x, width, type);
+        return shiftBy/width/height;
+    }
+
+    /** Filter a line: maximum or average of 3-pixel neighborhood */
+    double filter3(float[] pixels, int length, int pixel0, int inc, int type) {
+        double shiftBy = 0;
+        float v3 = pixels[pixel0];  //will be pixel[i+1]
+        float v2 = v3;              //will be pixel[i]
+        float v1;                   //will be pixel[i-1]
+        for (int i=0, p=pixel0; i<length; i++,p+=inc) {
+            v1 = v2;
+            v2 = v3;
+            if (i<length-1) v3 = pixels[p+inc];
+            if (type == MAXIMUM) {
+                float max = v1 > v3 ? v1 : v3;
+                if (v2 > max) max = v2;
+                shiftBy += max - v2;
+                pixels[p] = max;
+            } else
+                pixels[p] = (v1+v2+v3)*0.33333333f;
+        }
+        return shiftBy;
+    }
+
+
+    public void setNPasses(int nPasses) {
+        if (isRGB && separateColors)
+        	nPasses *= 3;
+        if (useParaboloid)
+        	nPasses*= (doPresmooth) ? DIRECTION_PASSES+2 : DIRECTION_PASSES;
+        this.nPasses = nPasses;
+        pass = 0;
+    }
+
+    private void showProgress(double percent) {
+        if (nPasses <= 0) return;
+        percent = (double)pass/nPasses + percent/nPasses;
+        IJ.showProgress(percent);
+    }
+}
+
+//  C L A S S   R O L L I N G B A L L
+
+/** A rolling ball (or actually a square part thereof)
+ *  Here it is also determined whether to shrink the image
+ */
+class RollingBall {
+
+    float[] data;
+    int width;
+    int shrinkFactor;
+    
+    RollingBall(double radius) {
+        int arcTrimPer;
+        if (radius<=10) {
+            shrinkFactor = 1;
+            arcTrimPer = 24; // trim 24% in x and y
+        } else if (radius<=30) {
+            shrinkFactor = 2;
+            arcTrimPer = 24; // trim 24% in x and y
+        } else if (radius<=100) {
+            shrinkFactor = 4;
+            arcTrimPer = 32; // trim 32% in x and y
+        } else {
+            shrinkFactor = 8;
+            arcTrimPer = 40; // trim 40% in x and y
+        }
+        buildRollingBall(radius, arcTrimPer);
+    }
+    
+    /** Computes the location of each point on the rolling ball patch relative to the 
+    center of the sphere containing it.  The patch is located in the top half 
+    of this sphere.  The vertical axis of the sphere passes through the center of 
+    the patch.  The projection of the patch in the xy-plane below is a square.
+    */
+    void buildRollingBall(double ballradius, int arcTrimPer) {
+        double rsquare;     // rolling ball radius squared
+        int xtrim;          // # of pixels trimmed off each end of ball to make patch
+        int xval, yval;     // x,y-values on patch relative to center of rolling ball
+        double smallballradius; // radius of rolling ball (downscaled in x,y and z when image is shrunk)
+        int halfWidth;      // distance in x or y from center of patch to any edge (patch "radius")
+        
+        this.shrinkFactor = shrinkFactor;
+        smallballradius = ballradius/shrinkFactor;
+        if (smallballradius<1)
+            smallballradius = 1;
+        rsquare = smallballradius*smallballradius;
+        xtrim = (int)(arcTrimPer*smallballradius)/100; // only use a patch of the rolling ball
+        halfWidth = (int)Math.round(smallballradius - xtrim);
+        width = 2*halfWidth+1;
+        data = new float[width*width];
+
+        for (int y=0, p=0; y<width; y++)
+            for (int x=0; x<width; x++, p++) {
+                xval = x - halfWidth;
+                yval = y - halfWidth;
+                double temp = rsquare - xval*xval - yval*yval;
+                data[p] = temp>0. ? (float)(Math.sqrt(temp)) : 0f;
+                //-Float.MAX_VALUE might be better than 0f, but gives different results than earlier versions
+            }
+    }
+
+}
diff --git a/src/ij/plugin/filter/Benchmark.java b/src/ij/plugin/filter/Benchmark.java
new file mode 100644
index 0000000..56d706d
--- /dev/null
+++ b/src/ij/plugin/filter/Benchmark.java
@@ -0,0 +1,105 @@
+package ij.plugin.filter;
+import java.awt.*;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.text.*;
+/** Implements the Plugins/Utilities/Run Benchmark command when
+	the current image is 512x512 and RGB. Results and additional
+	benchmarks are available at<br> 
+	"http://imagej.nih.gov/ij/plugins/benchmarks.html". */
+public class Benchmark implements PlugInFilter{
+
+	String arg;
+	ImagePlus imp;
+	boolean showUpdates= true;
+	int counter;
+	
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL+NO_CHANGES+SNAPSHOT;
+	}
+
+	public void run(ImageProcessor ip) {
+		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
+		ip.setInterpolate(false);
+		for (int i=0; i <4; i++) {
+			ip.invert();
+			updateScreen(imp);
+		}
+		for (int i=0; i <4; i++) {
+			ip.flipVertical();
+			updateScreen(imp);
+		}
+		ip.flipHorizontal(); updateScreen(imp);
+		ip.flipHorizontal(); updateScreen(imp);
+		for (int i=0; i <6; i++) {
+			ip.smooth();
+			updateScreen(imp);
+		}
+		ip.reset();
+		for (int i=0; i <6; i++) {
+			ip.sharpen();
+			updateScreen(imp);
+		}
+		ip.reset();
+		ip.smooth(); updateScreen(imp);
+		ip.findEdges(); updateScreen(imp);
+		ip.invert(); updateScreen(imp);
+		ip.autoThreshold(); updateScreen(imp);
+		ip.reset();
+		ip.medianFilter(); updateScreen(imp);
+		for (int i=0; i <360; i +=15) {
+			ip.reset();
+			ip.rotate(i);
+			updateScreen(imp);
+		}
+		double scale = 1.5;
+		for (int i=0; i <8; i++) {
+			ip.reset();
+			ip.scale(scale, scale);
+			updateScreen(imp);
+			scale = scale*1.5;
+		}
+		for (int i=0; i <12; i++) {
+			ip.reset();
+			scale = scale/1.5;
+			ip.scale(scale, scale);
+			updateScreen(imp);
+		}
+		ip.reset();
+		updateScreen(imp);
+	}
+	
+	void updateScreen(ImagePlus imp) {
+		if (showUpdates)
+			imp.updateAndDraw();
+		IJ.showStatus((counter++) + "/"+72);
+	}
+
+	/*
+	void showBenchmarkResults() {
+		TextWindow tw = new TextWindow("ImageJ Benchmark", "", 450, 450);
+		tw.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		tw.append("Time in seconds needed to perform 62 image processing");
+		tw.append("operations on the 512x512 \"Mandrill\" image");
+		tw.append("---------------------------------------------------------");
+		tw.append(" 1.6   Pentium 4/3.0, WinXP  Java 1.3.1");
+		tw.append(" 2.4   PPC G5/2.0x2, MacOSX  Java 1.3.1");
+		tw.append(" 3.3   Pentium 4/1.4, Win2K  IE 5.0");
+		tw.append(" 5.3   Pentium 3/750, Win98  IE 5.0");
+		tw.append(" 5.6   Pentium 4/1.4, Win2K  JDK 1.3");
+		tw.append(" 6.0   Pentium 3/750, Win98  Netscape 4.7");
+		tw.append(" 8.6   PPC G4/400, MacOS     MRJ 2.2");
+		tw.append("  11   Pentium 2/400, Win95  JRE 1.1.8");
+		tw.append("  14   PPC G3/300, MacOS     MRJ 2.1");
+		tw.append("  38   PPC 604/132, MacOS    MRJ 2.1");
+		tw.append("  89   Pentium/100, Win95    JRE 1.1.6");
+		tw.append("  96   Pentium/400, Linux    Sun JDK 1.2.2 (17 with JIT)");
+		tw.append("");
+	}
+	*/
+
+}
+
+
diff --git a/src/ij/plugin/filter/Binary.java b/src/ij/plugin/filter/Binary.java
new file mode 100644
index 0000000..27163e6
--- /dev/null
+++ b/src/ij/plugin/filter/Binary.java
@@ -0,0 +1,191 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.frame.ThresholdAdjuster;
+import java.awt.*;
+
+/** Implements the Erode, Dilate, Open, Close, Outline, Skeletonize
+    and Fill Holes commands in the Process/Binary submenu. 
+    Gabriel Landini contributed the clever binary fill algorithm
+    that fills holes in objects by filling the background.
+    Version 2009-06-23 preview added, interations can be aborted by escape (Michael Schmid)
+*/
+public class Binary implements ExtendedPlugInFilter, DialogListener {
+    static final int MAX_ITERATIONS = 100;
+    static final String NO_OPERATION = "Nothing";
+    static final String[] outputTypes = {"Overwrite", "8-bit", "16-bit", "32-bit"};
+    static final String[] operations = {NO_OPERATION, "Erode", "Dilate", "Open", "Close", "Outline", "Fill Holes", "Skeletonize"};
+
+    //parameters / options
+    static int iterations = 1;      //iterations for erode, dilate, open, close
+    static int count = 1;           //nearest neighbor count for erode, dilate, open, close
+    String operation = NO_OPERATION;  //for dialog; will be copied to 'arg' for actual previewing
+
+    String arg;
+    ImagePlus imp;                  //null if only setting options with no preview possibility
+    PlugInFilterRunner pfr;
+    boolean doOptions;              //whether options dialog is required
+    boolean previewing;
+    boolean escapePressed;
+    int foreground, background;
+    int flags = DOES_8G | DOES_8C | SUPPORTS_MASKING | PARALLELIZE_STACKS | KEEP_PREVIEW | KEEP_THRESHOLD;
+    int nPasses;
+
+    public int setup(String arg, ImagePlus imp) {
+        this.arg = arg;
+        IJ.register(Binary.class);
+        doOptions = arg.equals("options");
+        if (doOptions) {
+            if (imp == null) return NO_IMAGE_REQUIRED;  //options dialog does not need a (suitable) image
+            ImageProcessor ip = imp.getProcessor();
+            if (!(ip instanceof ByteProcessor)) return NO_IMAGE_REQUIRED;
+            if (!((ByteProcessor)ip).isBinary()) return NO_IMAGE_REQUIRED;
+        }
+        return flags;
+    }
+
+    public int showDialog (ImagePlus imp, String command, PlugInFilterRunner pfr) {
+        if (doOptions) {
+            this.imp = imp;
+            this.pfr = pfr;
+            GenericDialog gd = new GenericDialog("Binary Options");
+            gd.addNumericField("Iterations (1-"+MAX_ITERATIONS+"):", iterations, 0, 3, "");
+            gd.addNumericField("Count (1-8):", count, 0, 3, "");
+            gd.addCheckbox("Black background", Prefs.blackBackground);
+            gd.addCheckbox("Pad edges when eroding", Prefs.padEdges);
+            gd.addChoice("EDM output:", outputTypes, outputTypes[EDM.getOutputType()]);
+            if (imp != null) {
+                gd.addChoice("Do:", operations, operation);
+                gd.addPreviewCheckbox(pfr);
+                gd.addDialogListener(this);
+                previewing = true;
+            }
+            gd.addHelp(IJ.URL+"/docs/menus/process.html#options");
+            gd.showDialog();
+            previewing = false;
+            if (gd.wasCanceled()) return DONE;
+            if (imp==null) {                 //options dialog only, no do/preview
+                dialogItemChanged(gd, null); //read dialog result
+                return DONE;
+            }
+            return operation.equals(NO_OPERATION) ? DONE : IJ.setupDialog(imp, flags);
+        } else {   //no dialog, 'arg' is operation type
+            if (!((ByteProcessor)imp.getProcessor()).isBinary()) {
+                IJ.error("8-bit binary (black and white only) image required.");
+                return DONE;
+            }
+            return IJ.setupDialog(imp, flags);
+        }
+    }
+
+    public boolean dialogItemChanged (GenericDialog gd, AWTEvent e) {
+        iterations = (int)gd.getNextNumber();
+        count = (int)gd.getNextNumber();
+        boolean bb = Prefs.blackBackground;
+        Prefs.blackBackground = gd.getNextBoolean();
+        if (Prefs.blackBackground!=bb)
+        	ThresholdAdjuster.update();
+        Prefs.padEdges = gd.getNextBoolean();
+        gd.setSmartRecording(EDM.getOutputType()==0);
+        EDM.setOutputType(gd.getNextChoiceIndex());
+        gd.setSmartRecording(false);
+        boolean isInvalid = gd.invalidNumber();
+        if (iterations<1) {iterations = 1; isInvalid = true;}
+        if (iterations>MAX_ITERATIONS) {iterations = MAX_ITERATIONS; isInvalid = true;}
+        if (count < 1)    {count = 1; isInvalid = true;}
+        if (count > 8)    {count = 8; isInvalid = true;}
+        if (isInvalid) return false;
+        if (imp != null) {
+            operation = gd.getNextChoice();
+            arg = operation.toLowerCase();
+        }
+        return true;
+    }
+
+    public void setNPasses (int nPasses) {
+    	this.nPasses = nPasses;
+    }
+
+    public void run (ImageProcessor ip) {
+        int fg = Prefs.blackBackground ? 255 : 0;
+        foreground = ip.isInvertedLut() ? 255-fg : fg;
+        background = 255 - foreground;
+        ip.setSnapshotCopyMode(true);
+        if (arg.equals("outline"))
+            outline(ip);
+        else if (arg.startsWith("fill"))
+            fill(ip, foreground, background);
+        else if (arg.startsWith("skel")) {
+            ip.resetRoi();
+            skeletonize(ip);
+        } else if (arg.equals("erode") || arg.equals("dilate"))
+            doIterations((ByteProcessor)ip, arg);
+        else if (arg.equals("open")) {
+            doIterations(ip, "erode");
+            doIterations(ip, "dilate");
+        } else if (arg.equals("close")) {
+            doIterations(ip, "dilate");
+            doIterations(ip, "erode");
+        }
+        ip.setSnapshotCopyMode(false);
+        ip.setBinaryThreshold();
+    }
+
+    void doIterations (ImageProcessor ip, String mode) {
+        if (escapePressed) return;
+        if (!previewing && iterations>1)
+            IJ.showStatus(arg+"... press ESC to cancel");
+        for (int i=0; i<iterations; i++) {
+            if (Thread.currentThread().isInterrupted()) return;
+            if (IJ.escapePressed()) {
+                escapePressed = true;
+                ip.reset();
+                return;
+            }
+            if (mode.equals("erode"))
+                ((ByteProcessor)ip).erode(count, background);
+            else
+                ((ByteProcessor)ip).dilate(count, background);
+        }
+    }
+    
+    void outline(ImageProcessor ip) {
+        if (Prefs.blackBackground) ip.invert();
+        ((ByteProcessor)ip).outline();
+        if (Prefs.blackBackground) ip.invert();
+    }
+
+	void skeletonize(ImageProcessor ip) {
+		int fg = Prefs.blackBackground?255:0;
+		if (ip.isInvertedLut())
+			fg = 255-fg;
+		((ByteProcessor)ip).skeletonize(fg);
+	}
+
+    // Binary fill by Gabriel Landini, G.Landini at bham.ac.uk
+    // 21/May/2008
+    void fill(ImageProcessor ip, int foreground, int background) {
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        FloodFiller ff = new FloodFiller(ip);
+        ip.setColor(127);
+        for (int y=0; y<height; y++) {
+            if (ip.getPixel(0,y)==background) ff.fill(0, y);
+            if (ip.getPixel(width-1,y)==background) ff.fill(width-1, y);
+        }
+        for (int x=0; x<width; x++){
+            if (ip.getPixel(x,0)==background) ff.fill(x, 0);
+            if (ip.getPixel(x,height-1)==background) ff.fill(x, height-1);
+        }
+        byte[] pixels = (byte[])ip.getPixels();
+        int n = width*height;
+        for (int i=0; i<n; i++) {
+        if (pixels[i]==127)
+            pixels[i] = (byte)background;
+        else
+            pixels[i] = (byte)foreground;
+        }
+    }
+
+}
diff --git a/src/ij/plugin/filter/Calibrator.java b/src/ij/plugin/filter/Calibrator.java
new file mode 100644
index 0000000..7a42921
--- /dev/null
+++ b/src/ij/plugin/filter/Calibrator.java
@@ -0,0 +1,486 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.util.*;
+import ij.io.*;
+import ij.plugin.TextReader;
+import ij.plugin.frame.Fitter;
+import java.awt.*;
+import java.util.*;
+import java.awt.event.*;
+import java.io.*;
+
+
+/** Implements the Analyze/Calibrate command. */
+public class Calibrator implements PlugInFilter, Measurements, ActionListener {
+
+	private static final String NONE = "None";
+	private static final String INVERTER = "Pixel Inverter";
+	private static final String UNCALIBRATED_OD = "Uncalibrated OD";
+	private static final String CUSTOM = "Custom";
+	private static boolean showSettings;
+	private boolean global1, global2;
+    private ImagePlus imp;
+	private int choiceIndex;
+	private String[] functions;
+	private	int nFits = Calibration.EXP_RECOVERY+1;   //don't set to CurveFitter.fitList.length; Calibration can't cope with it
+	private String curveFitError;
+	private int spacerIndex = nFits+1;
+	private int inverterIndex = nFits+2;
+	private int odIndex = nFits+3;
+	private int customIndex = nFits+4;
+	private static String xText = "";
+	private static String yText = "";
+	private static boolean importedValues;
+	private String unit;
+	private double lx=0.02, ly=0.1;
+	private int oldFunction;
+	private String sumResiduals, fitGoodness;
+	private Button open, save;
+	private GenericDialog gd;
+	private static boolean showPlotFlagSaved = true;
+	private boolean showPlotFlag;
+	private static String unitSaved = Calibration.DEFAULT_VALUE_UNIT;
+	private CurveFitter curveFitter;
+	
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL-DOES_RGB+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		global1 = imp.getGlobalCalibration()!=null;
+		if (!showDialog(imp))
+			return;
+		if (choiceIndex==customIndex) {
+			showPlot(null, null, imp.getCalibration(), null);
+			return;
+		} else if (imp.getType()==ImagePlus.GRAY32) {
+			if (choiceIndex==0)
+				imp.getCalibration().setValueUnit(unit);
+			else
+				IJ.error("Calibrate", "Function must be \"None\" for 32-bit images,\nbut you can change the Unit.");
+		} else
+			calibrate(imp);
+	}
+
+	public boolean showDialog(ImagePlus imp) {
+		String defaultChoice;
+		Calibration cal = imp.getCalibration();
+		functions = getFunctionList(cal.getFunction()==Calibration.CUSTOM);
+		int function = cal.getFunction();
+		oldFunction = function;
+		double[] p = cal.getCoefficients();
+		unit = cal.getValueUnit();
+		if (unit == Calibration.DEFAULT_VALUE_UNIT)
+		    unit = unitSaved;
+		if (function==Calibration.NONE)
+			defaultChoice=NONE;
+		else if (function<nFits&&function==Calibration.STRAIGHT_LINE&&p!=null&& p[0]==255.0&&p[1]==-1.0)
+			defaultChoice=INVERTER;
+		else if (function<nFits)
+			defaultChoice = CurveFitter.fitList[function];
+		else if (function==Calibration.UNCALIBRATED_OD)
+			defaultChoice=UNCALIBRATED_OD;
+		else if (function==Calibration.CUSTOM)
+			defaultChoice=CUSTOM;
+		else
+			defaultChoice=NONE;
+			
+		String tmpText = getMeans();
+		if (!importedValues && !tmpText.equals(""))	
+			xText = tmpText;	
+		gd = new GenericDialog("Calibrate...");
+		gd.addChoice("Function:", functions, defaultChoice);
+		gd.addStringField("Unit:", unit, 16);
+		gd.addTextAreas(xText, yText, 20, 14);
+		//gd.addMessage("Left column contains uncalibrated measured values,\n right column contains known values (e.g., OD).");
+		gd.addPanel(makeButtonPanel(gd));
+		gd.addCheckbox("Global calibration", IJ.isMacro()?false:global1);
+		gd.addCheckbox("Show plot", IJ.isMacro()?false:showPlotFlagSaved);
+		//gd.addCheckbox("Show Simplex Settings", showSettings);
+		gd.addHelp(IJ.URL+"/docs/menus/analyze.html#cal");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+		else {
+			choiceIndex = gd.getNextChoiceIndex();
+			unit = gd.getNextString();
+			xText = gd.getNextText();
+			yText = gd.getNextText();
+			global2 = gd.getNextBoolean();
+			showPlotFlag = gd.getNextBoolean();
+			//showSettings = gd.getNextBoolean();
+			showPlotFlagSaved = showPlotFlag;
+			unitSaved = unit;
+			return true;
+		}
+	}
+
+	/** Creates a panel containing "Open..." and "Save..." buttons. */
+	Panel makeButtonPanel(GenericDialog gd) {
+		Panel buttons = new Panel();
+    	buttons.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		open = new Button("Open...");
+		open.addActionListener(this);
+		buttons.add(open);
+		save = new Button("Save...");
+		save.addActionListener(this);
+		buttons.add(save);
+		return buttons;
+	}
+
+    /** Calibrate an image with the function type defined previously.
+     *  Sets the function to Calibration.NONE on error */
+	public void calibrate(ImagePlus imp) {
+		Calibration cal = imp.getCalibration();
+		Calibration calOrig = cal.copy();
+		int function = Calibration.NONE;
+		boolean is16Bits = imp.getType()==ImagePlus.GRAY16;
+		double[] parameters = null;
+		double[] x=null, y=null;
+		boolean zeroClip=false;
+		curveFitter = null;
+		if (choiceIndex<=0) {
+			if (oldFunction==Calibration.NONE&&!yText.equals("")&&!xText.equals("")) {
+				IJ.error("Calibrate", "Please select a function");
+			    return;
+			}
+			function = Calibration.NONE;
+		} else if (choiceIndex<=nFits) {
+			function = choiceIndex - 1;
+			x = getData(xText);
+			y = getData(yText);
+			if (cal.isSigned16Bit() || imp.getProperty("WasSigned")!=null) {
+				for (int i=0; i<x.length; i++)
+					x[i] += 32768;
+				imp.setProperty("WasSigned", "WasSigned");
+			}
+			if (!validateXValues(imp, x))
+				return;
+			if (!cal.calibrated() || y.length!=0 || function!=oldFunction) {
+				parameters = doCurveFitting(x, y, function);
+				if (parameters==null) { //minimization failed
+				    IJ.error(curveFitError);
+				    function = Calibration.NONE;
+					return;
+				}
+			}
+			if (!is16Bits && function!=Calibration.STRAIGHT_LINE) {
+				zeroClip = true;
+				for (int i=0; i<y.length; i++)
+					if (y[i]<0.0) zeroClip = false;
+			}
+		} else if (choiceIndex==inverterIndex) {
+			function = Calibration.STRAIGHT_LINE;
+			parameters = new double[2];
+			if (is16Bits)
+				parameters[0] = 65535;
+			else
+				parameters[0] = 255;
+			parameters[1] = -1.0;
+			unit = "Inverted Gray Value";
+		} else if (choiceIndex==odIndex) {
+			if (is16Bits) {
+				IJ.error("Calibrate", "Uncalibrated OD is not supported on 16-bit images.");
+				return;
+			}
+			function = Calibration.UNCALIBRATED_OD;
+			unit = "Uncalibrated OD";
+		}
+		cal.setFunction(function, parameters, unit, zeroClip);
+		if (function==Calibration.NONE)
+			cal.setValueUnit(unit);
+		if (!cal.equals(calOrig))
+			imp.setCalibration(cal);
+		int bitDepth = imp.getBitDepth();
+		imp.setGlobalCalibration(global2?cal:null);
+		if (function!=Calibration.NONE && bitDepth!=8 && imp.getNChannels()==1 && !(bitDepth==16&&imp.getDefault16bitRange()>0)) {
+			ImageStatistics stats = imp.getProcessor().getStats();
+			if (imp.getDisplayRangeMin()<stats.min || imp.getDisplayRangeMax()>stats.max) {
+				imp.resetDisplayRange();
+				imp.updateAndDraw();
+			}
+		}
+		if (global2 || global2!=global1)
+			WindowManager.repaintImageWindows();
+		else
+			imp.repaintWindow();
+		if (global2 && global2!=global1)
+			FileOpener.setShowConflictMessage(true);
+		if (function!=Calibration.NONE && showPlotFlag) {
+			if (curveFitter!=null)
+				Fitter.plot(curveFitter, bitDepth==8);
+			else
+				showPlot(x, y, cal, fitGoodness);
+		}
+	}
+	
+	private boolean validateXValues(ImagePlus imp, double[] x) {
+		int bitDepth = imp.getBitDepth();
+		if (bitDepth==32 || x==null)
+			return true;
+		int max = 255;
+		if (bitDepth==16)
+			max = 65535;
+		for (int i=0; i<x.length; i++) {
+			if (x[i]<0 || x[i]>max) {
+			    String title = (bitDepth==8?"8-bit":"16-bit") + " Calibration";
+				String msg = "Measured (uncalibrated) values in the left\ncolumn must be in the range 0-";
+				IJ.error(title, msg+max+".");
+				return false;
+			}
+		}
+		return true;
+	}
+
+	double[] doCurveFitting(double[] x, double[] y, int fitType) {
+		if (x.length!=y.length || y.length==0) {
+			IJ.error("Calibrate",
+				"To create a calibration curve, the left column must\n"
+				+"contain a list of measured mean pixel values and the\n"
+				+"right column must contain the same number of calibration\n"
+				+"standard values. Use the Measure command to add mean\n"
+				+"pixel value measurements to the left column.\n"
+				+" \n"
+				+"    Left column: "+x.length+" values\n"
+				+"    Right column: "+y.length+" values\n"
+				);
+			return null;
+		}
+		int n = x.length;
+		double xmin=0.0,xmax;
+		if (imp.getType()==ImagePlus.GRAY16)
+			xmax=65535.0; 
+		else
+			xmax=255.0;
+		double[] a = Tools.getMinMax(y);
+		double ymin=a[0], ymax=a[1]; 
+		CurveFitter cf = new CurveFitter(x, y);
+		cf.doFit(fitType, showSettings);
+		if (cf.getStatus() == Minimizer.INITIALIZATION_FAILURE) {
+		    curveFitError = cf.getStatusString();
+		    return null;
+		}
+        if (IJ.debugMode) IJ.log(cf.getResultString());
+		int np = cf.getNumParams();
+		double[] p = cf.getParams();
+		fitGoodness = IJ.d2s(cf.getRSquared(),6);
+		curveFitter = cf;
+		double[] parameters = new double[np];
+		for (int i=0; i<np; i++)
+			parameters[i] = p[i];
+		return parameters;									
+	}
+	
+	void showPlot(double[] x, double[] y, Calibration cal, String rSquared) {
+		if (!showPlotFlag || !cal.calibrated())
+			return;
+		int xmin,xmax,range;
+		float[] ctable = cal.getCTable();
+		if (ctable.length==256) { //8-bit image
+			xmin = 0;
+			xmax = 255;
+		} else {  // 16-bit image
+			xmin = 0;
+			xmax = 65535;
+		}
+		range = 256;
+		float[] px = new float[range];
+		float[] py = new float[range];
+		for (int i=0; i<range; i++)
+			px[i]=(float)((i/255.0)*xmax);
+		for (int i=0; i<range; i++)
+			py[i]=ctable[(int)px[i]];
+		double[] a = Tools.getMinMax(py);
+		double ymin = a[0];
+		double ymax = a[1];
+		int fit = cal.getFunction();
+		String unit = cal.getValueUnit();
+		Plot plot = new Plot("Calibration Function","pixel value",unit,px,py);
+		plot.setLimits(xmin,xmax,ymin,ymax);
+		if (x!=null&&y!=null&&x.length>0&&y.length>0)
+			plot.addPoints(x, y, PlotWindow.CIRCLE);
+		double[] p = cal.getCoefficients();
+		if (fit<=Calibration.LOG2) {
+			drawLabel(plot, CurveFitter.fList[fit]);
+			ly += 0.04;
+		}
+		if (p!=null) {
+			int np = p.length;
+			drawLabel(plot, "a="+IJ.d2s(p[0],6,10));
+			drawLabel(plot, "b="+IJ.d2s(p[1],6,10));
+			if (np>=3)
+				drawLabel(plot, "c="+IJ.d2s(p[2],6,10));
+			if (np>=4)
+				drawLabel(plot, "d="+IJ.d2s(p[3],6,10));
+			if (np>=5)
+				drawLabel(plot, "e="+IJ.d2s(p[4],6,10));
+			ly += 0.04;
+		}
+		if (rSquared!=null)
+			{drawLabel(plot, "R^2="+rSquared); rSquared=null;}
+		plot.show();
+	}
+	
+	void drawLabel(Plot plot, String label) {
+		plot.addLabel(lx, ly, label);
+		ly += 0.08;
+	}
+	
+
+	double sqr(double x) {return x*x;}
+
+	String[] getFunctionList(boolean custom) {
+		int n = nFits+4;
+		if (custom) n++;
+		String[] list = new String[n];
+		list[0] = NONE;
+		for (int i=0; i<nFits; i++)
+			list[1+i] = CurveFitter.fitList[i];
+		list[spacerIndex] = "-";
+		list[inverterIndex] = INVERTER;
+		list[odIndex] = UNCALIBRATED_OD;
+		if (custom) 
+			list[customIndex] = CUSTOM;
+		return list;
+ 	}
+	
+	String getMeans() {
+		float[] umeans = Analyzer.getUMeans();
+		int count = Analyzer.getCounter();
+		if (umeans==null || count==0)
+			return "";
+		if (count>MAX_STANDARDS)
+			count = MAX_STANDARDS;
+		String s = "";
+		for (int i=0; i<count; i++)
+			s += IJ.d2s(umeans[i],2)+"\n";
+		importedValues = false;
+		return s;
+	}
+
+	double[] getData(String xData) {
+		int len = xData.length();
+		StringBuffer sb = new StringBuffer(len);
+		for (int i=0; i<len; i++) {
+			char c = xData.charAt(i);
+			if ((c>='0'&&c<='9') || c=='-'  || c=='.' || c==',' || c=='\n' || c=='\r' || c==' ')
+				sb.append(c);
+		}
+		xData = sb.toString();
+
+		StringTokenizer st = new StringTokenizer(xData);
+		int nTokens = st.countTokens();
+		if (nTokens<1)
+			return new double[0];
+		int n = nTokens;
+		double data[] = new double[n];
+		for (int i=0; i<n; i++) {
+			data[i] = getNum(st);
+		}
+		return data;
+	}
+	
+	double getNum(StringTokenizer st) {
+		Double d;
+		String token = st.nextToken();
+		try {d = new Double(token);}
+		catch (NumberFormatException e){d = null;}
+		if (d!=null)
+			return(d.doubleValue());
+		else
+			return 0.0;
+	}
+	
+	void save() {
+		TextArea ta1 = gd.getTextArea1();
+		TextArea ta2 = gd.getTextArea2();
+		ta1.selectAll();
+		String text1 = ta1.getText();
+		ta1.select(0, 0);
+		ta2.selectAll();
+		String text2 = ta2.getText();
+		ta2.select(0, 0);
+		double[] x = getData(text1);
+		double[] y = getData(text2);
+		SaveDialog sd = new SaveDialog("Save as Text...", "calibration", ".txt");
+		String name = sd.getFileName();
+		if (name == null)
+			return;
+		String directory = sd.getDirectory();
+		PrintWriter pw = null;
+		try {
+			FileOutputStream fos = new FileOutputStream(directory+name);
+			BufferedOutputStream bos = new BufferedOutputStream(fos);
+			pw = new PrintWriter(bos);
+		}
+		catch (IOException e) {
+			IJ.error("" + e);
+			return;
+		}
+		IJ.wait(250);  // give system time to redraw ImageJ window
+		int n = Math.max(x.length, y.length);
+		for (int i=0; i<n; i++) {
+			String xs = x.length==0?"":i<x.length?""+x[i]:"0";
+			String ys = y.length==0?"":i<y.length?""+y[i]:"0";
+			pw.println(xs + "\t"+ ys);
+		}
+		pw.close();
+	}
+	
+	void open() {
+		OpenDialog od = new OpenDialog("Open Calibration...", "");
+		String directory = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+			return;
+		String path = directory + name;
+		TextReader tr = new TextReader();
+		ImageProcessor ip = tr.open(path);
+		if (ip==null)
+			return;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		if (!((width==1||width==2)&&height>1)) {
+			IJ.error("Calibrate", "This appears to not be a one or two column text file");
+			return;
+		}
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<height; i++) {
+			sb.append(""+ip.getPixelValue(0, i));
+			sb.append("\n");
+		}
+		String s1=null, s2=null;
+		if (width==2) {
+			s1 = new String(sb);
+			sb = new StringBuffer();
+			for (int i=0; i<height; i++) {
+				sb.append(""+ip.getPixelValue(1, i));
+				sb.append("\n");
+			}
+			s2 = new String(sb);
+		} else
+			s2 = new String(sb);
+		if (s1!=null) {
+			TextArea ta1 = gd.getTextArea1();
+			ta1.selectAll();
+			ta1.setText(s1);
+		}
+		TextArea ta2 = gd.getTextArea2();
+		ta2.selectAll();
+		ta2.setText(s2);
+		importedValues = true;
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		Object source = e.getSource();
+		if (source==save)
+			save();
+		else if (source==open)
+			open();
+	}
+	
+}
diff --git a/src/ij/plugin/filter/Convolver.java b/src/ij/plugin/filter/Convolver.java
new file mode 100644
index 0000000..19ce693
--- /dev/null
+++ b/src/ij/plugin/filter/Convolver.java
@@ -0,0 +1,458 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.plugin.TextReader;
+import ij.plugin.frame.Recorder;
+import ij.util.Tools;
+import java.awt.*;
+import java.util.*;
+import java.awt.event.*;
+import java.io.*;
+
+/** This plugin convolves images using user user defined kernels. */
+public class Convolver implements ExtendedPlugInFilter, DialogListener, ActionListener {
+
+	private ImagePlus imp;
+	private int kw, kh;
+	private boolean canceled;
+	private float[] kernel;
+	private boolean isLineRoi;
+	private Button open, save;
+	private GenericDialog gd;
+	private MultiLineLabel messageLabel;
+	private boolean normalize = true;
+	private int nSlices;
+	private int flags = DOES_ALL|CONVERT_TO_FLOAT|SUPPORTS_MASKING|KEEP_PREVIEW|FINAL_PROCESSING|SNAPSHOT;
+	private int nPasses = 1;
+	private boolean kernelError;
+	private PlugInFilterRunner pfr;
+	private Thread mainThread;
+	private int pass;
+	private static String defaultKernelText = "-1 -1 -1 -1 -1\n-1 -1 -1 -1 -1\n-1 -1 24 -1 -1\n-1 -1 -1 -1 -1\n-1 -1 -1 -1 -1\n";
+	private static boolean defaultNormalizeFlag = true;
+	private static String lastKernelText = defaultKernelText;
+	private static boolean lastNormalizeFlag = defaultNormalizeFlag;
+	private String kernelText = defaultKernelText;
+	private boolean normalizeFlag = defaultNormalizeFlag;
+
+	public int setup(String arg, ImagePlus imp) {
+ 		this.imp = imp;
+        mainThread = Thread.currentThread();
+		if (imp==null)
+			{IJ.noImage(); return DONE;}
+		if (arg.equals("final")&&imp.getRoi()==null) {
+			imp.getProcessor().resetMinAndMax();
+			imp.updateAndDraw();
+			return DONE;
+		}
+		IJ.resetEscape();
+		Roi roi = imp.getRoi();
+		isLineRoi= roi!=null && roi.isLine();
+		nSlices = imp.getStackSize();
+		if (imp.getStackSize()==1)
+			flags |= PARALLELIZE_IMAGES;
+		else
+			flags |= PARALLELIZE_STACKS;
+		imp.startTiming();
+		return flags;
+	}
+
+	public void run(ImageProcessor ip) {
+		if (canceled) return;
+		if (isLineRoi) ip.resetRoi();
+		if (!kernelError)
+			convolve(ip, kernel, kw, kh);
+	}
+
+	public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+		boolean interactive = Macro.getOptions()==null;
+		if (interactive) {
+			kernelText = lastKernelText;
+			normalizeFlag = lastNormalizeFlag;
+		}
+		gd = GUI.newNonBlockingDialog("Convolver...", imp);
+		gd.setInsets(5,20,0);
+		gd.addMessage(" \nKernel:"); //reserve two lines
+		messageLabel = (MultiLineLabel)gd.getMessage();
+		gd.setInsets(5,20,0);
+		gd.addTextAreas(kernelText, null, 10, 30);
+		gd.addPanel(makeButtonPanel(gd));
+		gd.addCheckbox("Normalize Kernel", normalizeFlag);
+		gd.addPreviewCheckbox(pfr);
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return DONE;
+		this.pfr = pfr;
+		if (interactive) {
+			lastKernelText = kernelText;
+			lastNormalizeFlag = normalizeFlag;
+		}
+		return IJ.setupDialog(imp, flags);
+	}
+
+    public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		kernelText = gd.getNextText();
+		normalizeFlag = gd.getNextBoolean();
+		normalize = normalizeFlag;
+		kernelError = !decodeKernel(kernelText);
+		if (!kernelError) {
+			IJ.showStatus("Convolve: "+kw+"x"+kh+" kernel");
+			return true;
+		} else
+			return !gd.isPreviewActive();
+    }
+
+    boolean decodeKernel(String text) {
+    	if (Macro.getOptions()!=null && !hasNewLine(text))
+    		return decodeSquareKernel(text);
+		String[] rows = Tools.split(text.trim(), "\n");
+		kh = rows.length;
+		if (kh==0) return false;
+		String[] values = Tools.split(rows[0].trim());
+		kw = values.length;
+		kernel = new float[kw*kh];
+		boolean done = gd.wasOKed();
+		int i = 0;
+		String err = null;
+		for (int y=0; y<kh; y++) {
+			values = Tools.split(rows[y]);
+			if (values.length!=kw)
+				err = "Row "+(y+1)+" is not the same length\nas the first row";
+			else
+				for (int x=0; x<kw; x++)
+					kernel[i++] = (float)Tools.parseDouble(values[x], 0.0);
+		}
+		if ((kw&1)!=1 || (kh&1)!=1)
+			err = "Kernel must have odd width and height.\nThis one is "+kw+"x"+kh+".";
+		if (err == null) {
+			messageLabel.setText(kw+"x"+kh+" kernel");
+		} else {
+			if (done)
+				IJ.error("Convolver", err);
+			else
+				messageLabel.setText(err);
+			return false;
+		}
+		return true;
+    }
+
+	boolean hasNewLine(String text) {
+		for (int i=0; i<text.length(); i++) {
+			if (text.charAt(i)=='\n') return true;
+		}
+		return false;
+	}
+
+    boolean decodeSquareKernel(String text) {
+		String[] values = Tools.split(text);
+		int n = values.length;
+		kw = (int)Math.sqrt(n);
+		kh = kw;
+		n = kw*kh;
+		kernel = new float[n];
+		for (int i=0; i<n; i++)
+			kernel[i] = (float)Tools.parseDouble(values[i]);
+		if (kw>=3 && (kw&1)==1) {
+			StringBuffer sb = new StringBuffer();
+			int i = 0;
+			for (int y=0; y<kh; y++) {
+				for (int x=0; x<kw; x++) {
+					sb.append(""+kernel[i++]);
+					if (x<kw-1) sb.append(" ");
+				}
+				sb.append("\n");
+			}
+			kernelText = new String(sb);
+			gd.getTextArea1().setText(new String(sb));
+			return true;
+		} else {
+			IJ.error("Kernel must be square with odd width. This one is "+kw+"x"+kh+".");
+			return false;
+		}
+	}
+
+	/** Creates a panel containing "Save...", "Save..." and "Preview" buttons. */
+	Panel makeButtonPanel(GenericDialog gd) {
+		Panel buttons = new Panel();
+    	buttons.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		open = new Button("Open...");
+		open.addActionListener(this);
+		buttons.add(open);
+		save = new Button("Save...");
+		save.addActionListener(this);
+		buttons.add(save);
+		return buttons;
+	}
+
+	/** Convolves <code>ip</code> with a kernel of width <code>kw</code> and
+		height <code>kh</code>. Returns false if the user cancels the operation. */
+	public boolean convolve(ImageProcessor ip, float[] kernel, int kw, int kh) {
+		if (canceled || kernel==null || kw*kh!=kernel.length)
+			return false;
+		if ((kw&1)!=1 || (kh&1)!=1)
+			throw new IllegalArgumentException("Kernel width or height not odd ("+kw+"x"+kh+")");
+		boolean notFloat = !(ip instanceof FloatProcessor);
+		ImageProcessor ip2 = ip;
+		if (notFloat) {
+			if (ip2 instanceof ColorProcessor)
+				throw new IllegalArgumentException("RGB images not supported");
+			ip2 = ip2.convertToFloat();
+		}
+		if (kw==1 || kh==1)
+			convolveFloat1D((FloatProcessor)ip2, kernel, kw, kh, normalize?getScale(kernel):1.0);
+		else
+			convolveFloat(ip2, kernel, kw, kh);
+		if (notFloat) {
+			if (ip instanceof ByteProcessor)
+				ip2 = ip2.convertToByte(false);
+			else
+				ip2 = ip2.convertToShort(false);
+			ip.setPixels(ip2.getPixels());
+		}
+		return !canceled;
+	}
+
+	/** If 'normalize' is true (the default), the convolve(), convolveFloat() and
+		convolveFloat1D() (4 argument version) methods divide each kernel
+		coefficient by the sum of the coefficients, preserving image brightness. */
+	public void setNormalize(boolean normalizeKernel) {
+		normalize = normalizeKernel;
+	}
+
+	/** Convolves the float image <code>ip</code> with a kernel of width
+		<code>kw</code> and height <code>kh</code>. Returns false if
+		the user cancels the operation by pressing 'Esc'. */
+	public boolean convolveFloat(ImageProcessor ip, float[] kernel, int kw, int kh) {
+		if (!(ip instanceof FloatProcessor))
+			throw new IllegalArgumentException("FloatProcessor required");
+		if (canceled) return false;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		Rectangle r = ip.getRoi();
+		int x1 = r.x;
+		int y1 = r.y;
+		int x2 = x1 + r.width;
+		int y2 = y1 + r.height;
+		int uc = kw/2;
+		int vc = kh/2;
+		float[] pixels = (float[])ip.getPixels();
+		float[] pixels2 = (float[])ip.getSnapshotPixels();
+		if (pixels2==null)
+			pixels2 = (float[])ip.getPixelsCopy();
+		double scale = normalize?getScale(kernel):1.0;
+        Thread thread = Thread.currentThread();
+        boolean isMainThread = thread==mainThread || thread.getName().indexOf("Preview")!=-1;
+        if (isMainThread) pass++;
+		double sum;
+		int offset, i;
+		boolean edgePixel;
+		int xedge = width-uc;
+		int yedge = height-vc;
+		long lastTime = System.currentTimeMillis();
+		for (int y=y1; y<y2; y++) {
+			long time = System.currentTimeMillis();
+			if (time-lastTime>100) {
+				lastTime = time;
+				if (thread.isInterrupted()) return false;
+				if (isMainThread) {
+					if (IJ.escapePressed()) {
+						canceled = true;
+						ip.reset();
+						ImageProcessor originalIp = imp.getProcessor();
+						if (originalIp.getNChannels() > 1)
+							originalIp.reset();
+						return false;
+					}
+					showProgress((y-y1)/(double)(y2-y1));
+				}
+			}
+			for (int x=x1; x<x2; x++) {
+				if (canceled) return false;
+				sum = 0.0;
+				i = 0;
+				edgePixel = y<vc || y>=yedge || x<uc || x>=xedge;
+				for (int v=-vc; v <= vc; v++) {
+					offset = x+(y+v)*width;
+					for(int u = -uc; u <= uc; u++) {
+						if (edgePixel) {
+ 							if (i>=kernel.length) // work around for JIT compiler bug on Linux
+ 								IJ.log("kernel index error: "+i);
+							sum += getPixel(x+u, y+v, pixels2, width, height)*kernel[i++];
+						} else
+							sum += pixels2[offset+u]*kernel[i++];
+					}
+		    	}
+				pixels[x+y*width] = (float)(sum*scale);
+			}
+    	}
+   		return true;
+   	 }
+
+	/** Convolves the image <code>ip</code> with a kernel of width
+		<code>kw</code> and height <code>kh</code>. */
+	public void convolveFloat1D(FloatProcessor ip, float[] kernel, int kw, int kh) {
+		convolveFloat1D(ip, kernel, kw, kh, normalize?getScale(kernel):1.0);
+	}
+
+	/** Convolves the image <code>ip</code> with a kernel of width
+		<code>kw</code> and height <code>kh</code>. */
+	public void convolveFloat1D(FloatProcessor ip, float[] kernel, int kw, int kh, double scale) {
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		Rectangle r = ip.getRoi();
+		int x1 = r.x;
+		int y1 = r.y;
+		int x2 = x1 + r.width;
+		int y2 = y1 + r.height;
+		int uc = kw/2;
+		int vc = kh/2;
+		float[] pixels = (float[])ip.getPixels();
+		float[] pixels2 = (float[])ip.getSnapshotPixels();
+		if (pixels2==null)
+			pixels2 = (float[])ip.getPixelsCopy();
+		boolean vertical = kw==1;
+
+		double sum;
+		int offset, i;
+		boolean edgePixel;
+		int xedge = width-uc;
+		int yedge = height-vc;
+		for(int y=y1; y<y2; y++) {
+			for(int x=x1; x<x2; x++) {
+				sum = 0.0;
+				i = 0;
+				if (vertical) {
+					edgePixel = y<vc || y>=yedge;
+					offset = x+(y-vc)*width;
+					for(int v=-vc; v<=vc; v++) {
+						if (edgePixel)
+							sum += getPixel(x+uc, y+v, pixels2, width, height)*kernel[i++];
+						else
+							sum += pixels2[offset+uc]*kernel[i++];
+						offset += width;
+					}
+				} else {
+					edgePixel = x<uc || x>=xedge;
+					offset = x+(y-vc)*width;
+					for(int u = -uc; u<=uc; u++) {
+						if (edgePixel)
+							sum += getPixel(x+u, y+vc, pixels2, width, height)*kernel[i++];
+						else
+							sum += pixels2[offset+u]*kernel[i++];
+					}
+				}
+				pixels[x+y*width] = (float)(sum*scale);
+			}
+    	}
+    }
+
+	public static double getScale(float[] kernel) {
+		double scale = 1.0;
+		double sum = 0.0;
+		for (int i=0; i<kernel.length; i++)
+			sum += kernel[i];
+		if (sum!=0.0)
+			scale = 1.0/sum;
+		return scale;
+	}
+
+	private float getPixel(int x, int y, float[] pixels, int width, int height) {
+		if (x<=0) x = 0;
+		if (x>=width) x = width-1;
+		if (y<=0) y = 0;
+		if (y>=height) y = height-1;
+		return pixels[x+y*width];
+	}
+
+	void save() {
+		TextArea ta1 = gd.getTextArea1();
+		ta1.selectAll();
+		String text = ta1.getText();
+		ta1.select(0, 0);
+		if (text==null || text.length()==0)
+			return;
+		text += "\n";
+		SaveDialog sd = new SaveDialog("Save as Text...", "kernel", ".txt");
+		String name = sd.getFileName();
+		if (name == null)
+			return;
+		String directory = sd.getDirectory();
+		PrintWriter pw = null;
+		try {
+			FileOutputStream fos = new FileOutputStream(directory+name);
+			BufferedOutputStream bos = new BufferedOutputStream(fos);
+			pw = new PrintWriter(bos);
+		}
+		catch (IOException e) {
+			IJ.error("" + e);
+			return;
+		}
+		IJ.wait(250);  // give system time to redraw ImageJ window
+		pw.print(text);
+		pw.close();
+	}
+
+	void open() {
+		OpenDialog od = new OpenDialog("Open Kernel...", "");
+		String directory = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+			return;
+		String path = directory + name;
+		TextReader tr = new TextReader();
+		ImageProcessor ip = tr.open(path);
+		if (ip==null)
+			return;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		if ((width&1)!=1 || (height&1)!=1) {
+			IJ.error("Convolver", "Kernel must be have odd width and height");
+			return;
+		}
+		StringBuffer sb = new StringBuffer();
+		boolean integers = true;
+		for (int y=0; y<height; y++) {
+			for (int x=0; x<width; x++) {
+				double v = ip.getPixelValue(x, y);
+				if ((int)v!=v)
+					integers = false;
+			}
+		}
+		for (int y=0; y<height; y++) {
+			for (int x=0; x<width; x++) {
+				if (x!=0) sb.append(" ");
+				double v = ip.getPixelValue(x, y);
+				if (integers)
+					sb.append(IJ.d2s(ip.getPixelValue(x, y),0));
+				else
+					sb.append(""+ip.getPixelValue(x, y));
+			}
+			if (y!=height-1)
+				sb.append("\n");
+		}
+		gd.getTextArea1().setText(new String(sb));
+	}
+
+	public void setNPasses(int nPasses) {
+		this.nPasses = nPasses;
+		pass = 0;
+	}
+
+    private void showProgress(double percent) {
+        percent = (double)(pass-1)/nPasses + percent/nPasses;
+        IJ.showProgress(percent);
+    }
+
+	public void actionPerformed(ActionEvent e) {
+		Object source = e.getSource();
+		Recorder.disablePathRecording();
+		if (source==save)
+			save();
+		else if (source==open)
+			open();
+	}
+
+}
diff --git a/src/ij/plugin/filter/Duplicater.java b/src/ij/plugin/filter/Duplicater.java
new file mode 100644
index 0000000..dbf6b20
--- /dev/null
+++ b/src/ij/plugin/filter/Duplicater.java
@@ -0,0 +1,33 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.plugin.Duplicator;
+
+/**
+* @deprecated
+* replaced by ij.plugin.Duplicator class
+*/
+public class Duplicater implements PlugInFilter {
+	ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+	}
+
+	public ImagePlus duplicateStack(ImagePlus imp, String newTitle) {
+		ImagePlus imp2 = (new Duplicator()).run(imp);
+		imp2.setTitle(newTitle);
+		return imp2;
+	}
+	
+	public ImagePlus duplicateSubstack(ImagePlus imp, String newTitle, int first, int last) {
+		ImagePlus imp2 = (new Duplicator()).run(imp, first, last);
+		imp2.setTitle(newTitle);
+		return imp2;
+	}
+
+}
diff --git a/src/ij/plugin/filter/EDM.java b/src/ij/plugin/filter/EDM.java
new file mode 100644
index 0000000..1c178bd
--- /dev/null
+++ b/src/ij/plugin/filter/EDM.java
@@ -0,0 +1,452 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.plugin.*;
+import ij.process.*;
+import ij.gui.*;
+
+/**
+ * This plugin implements the Euclidean Distance Map (EDM), Watershed,
+ * Ultimate Eroded Points and Voronoi commands in the Process/Binary submenu.
+ *
+ * - Euclidean Distance Map: The value of each pixel is the distance to the nearest
+ *   background pixel (for background pixels, the EDM is 0)
+ * - Ultimate Eroded Points  (UEPs) are maxima of the EDM. In the output, the points
+ *   are assigned the EDM value, which is equal to the radius of the largest circle
+ *   that fits into the particle, with the UEP as the center.
+ * - Watershed segmentation of the EDM splits particles at "necks"; starting at
+ *   maxima of the EDM.
+ * - 'Voronoi' splits the image by lines of points having equal distance to the
+ *   borders of the two nearest particles. Thus, the Voronoi cell of each particle
+ *   includes all points that are nearer to this particle than any other particle.
+ *   For the case of the priticles being single points, this is a Voronoi tessellation
+ *   (also known as Dirichlet tessellation).
+ *   In the output, the value inside the Voronoi cells is zero; the pixel values
+ *   of the dividing lines between the cells are equal to the distance to the two
+ *   nearest particles. This is similar to a medial axis transform of the background,
+ *   but there are no lines in inner holes of particles.
+ *
+ * Watershed, Ultimate Eroded Points and Voronoi are handled by the MaximumFinder 
+ * plugin applied to the EDM
+ * Note: These functions do not take ROIs into account.
+ * Setup is called with argument "" (empty string) for EDM,
+ * "watershed" for watershed segmentation, "points" for ultimate eroded points and
+ * "voronoi" for Voronoi segmentation of the background
+ *
+ * The EDM algorithm is similar to the 8SSEDT in
+ *   F. Leymarie, M. D. Levine, in: CVGIP Image Understanding, vol. 55 (1992), pp 84-94
+ *   http://dx.doi.org/10.1016/1049-9660(92)90008-Q
+ *
+ * The algorithm provides a fast approximation of the EDM, with the deviation from a
+ * full calculation being between -0.09 and 0. The algorithm is exact for distances<13.
+ * For d>=13, deviations from the true result can occur, but are very rare: typically
+ * the fraction of pixels deviating from the exact result is in the 10^-5 range, with
+ * most deviations between -0.03 and -0.04.
+ *
+ * Limitations:
+ * Maximum image diagonal for EDM: 46340 pixels (sqrt(2^31)); if the particles are
+ * dense enough it also works for width, height <=65534.
+ *
+ * Version 30-Apr-2008 Michael Schmid:  more accurate EDM algorithm,
+ *                                      16-bit and float output possible,
+ *                                      parallel processing for stacks
+ *                                      Voronoi output added
+ */
+public class EDM implements ExtendedPlugInFilter {
+    /** Output type: overwrite current 8-bit image */
+    public static final int BYTE_OVERWRITE = 0;
+    /** Output type: new 8-bit image */
+    public static final int BYTE = 1;
+    /** Output type: new 16-bit image */
+    public static final int SHORT = 2;
+    /** Output type: new 32-bit image */
+    public static final int FLOAT = 3;
+    /** Unit in old make16bitEDM: this pixel value corresponds to a distance of one pixel.
+     *  For compatibility only. */
+    public static final int ONE = 41;
+    /** In old make16bitEDM this pixel value corresponds to a pixel distance of sqrt(2) */
+    public static final int SQRT2 = 58; // ~ 41 * sqrt(2)
+    /** In old make16bitEDM this pixel value corresponds to a pixel distance of sqrt(5) */
+    public static final int SQRT5 = 92; // ~ 41 * sqrt(5)
+
+    private ImagePlus imp;              //input
+    private ImagePlus outImp;           //output if a new window is desired
+    private PlugInFilterRunner pfr;     //needed to extract the stack slice if needed
+    private String command;             //for showing status
+    private int outImageType;           //output type; BYTE_OVERWRITE, BYTE, SHORT or FLOAT
+    private ImageStack outStack;        //in case output should be a new stack
+    private int processType;            //can be EDM, WATERSHED, UEP, VORONOI
+    private MaximumFinder maxFinder = new MaximumFinder();    //we use only one MaximumFinder (nice progress bar)
+    private double progressDone;        //for progress bar, fraction of work done so far
+    private int nPasses;                //for progress bar, how many images to process (sequentially or parallel threads)
+    private boolean interrupted;        //whether watershed segmentation has been interrrupted by the user
+
+    private boolean background255;      //whether background for EDM is 255, not zero
+    private int flags = DOES_8G | PARALLELIZE_STACKS | FINAL_PROCESSING;
+    //processType can be:
+    private static final int EDM = 0, WATERSHED = 1, UEP = 2, VORONOI = 3;
+    //whether MaximumFinder is needed for processType:
+    private static final boolean[] USES_MAX_FINDER = new boolean[] {
+            false, true, true, true };
+    //whether watershed segmentation is needed for processType:
+    private static final boolean[] USES_WATERSHED = new boolean[] {
+            false, true, false, true };
+    //prefixes for titles of separate output images; for each processType:
+    private static final String[] TITLE_PREFIX = new String[] {
+            "EDM of ", null, "UEPs of ", "Voronoi of "};
+    private static final int NO_POINT = -1; //no nearest point in array of nearest points
+    private static final double MAXFINDER_TOLERANCE = 0.5; //reasonable values are 0.3 ... 0.8;
+                                    //segmentation is more aggressive with smaller values
+    /** Output type (BYTE_OVERWRITE, BYTE, SHORT or FLOAT) */
+    private static int outputType = BYTE_OVERWRITE;
+
+    /** Prepare for processing; also called at the very end with argument 'final'
+     *  to show any newly created output image.
+     */
+    public int setup (String arg, ImagePlus imp) {
+        if (arg.equals("final")) {
+            showOutput();
+            return DONE;
+        }
+        this.imp = imp;
+        //'arg' is processing type; default is 'EDM' (0)
+        if (arg.equals("watershed")) {
+            processType = WATERSHED;
+            flags += KEEP_THRESHOLD;
+        } else if (arg.equals("points"))
+            processType = UEP;
+        else if (arg.equals("voronoi"))
+            processType = VORONOI;
+
+        //output type
+        if (processType != WATERSHED)           //Watershed always has output BYTE_OVERWRITE=0
+            outImageType = outputType;          //otherwise use the static variable from setOutputType
+        if (outImageType != BYTE_OVERWRITE)
+            flags |= NO_CHANGES;
+
+        //check image and prepare
+        if (imp != null) {
+            ImageProcessor ip = imp.getProcessor();
+            if (!ip.isBinary()) {
+                IJ.error("8-bit binary image (0 and 255) required.");
+                return DONE;
+            }
+            ip.resetRoi();
+            //processing routines assume background=0; image may be otherwise
+            boolean invertedLut = imp.isInvertedLut();
+            background255 = (invertedLut && Prefs.blackBackground) || (!invertedLut && !Prefs.blackBackground);
+        }
+        return flags;
+    } //public int setup
+
+    /** Called by the PlugInFilterRunner after setup.
+     *  Asks the user in case of a stack and prepares a separate ouptut stack if required
+     */
+
+    public int showDialog (ImagePlus imp, String command, PlugInFilterRunner pfr) {
+        this.pfr = pfr;
+        int width = imp.getWidth();
+        int height= imp.getHeight();
+        //ask whether to process all slices of stack & prepare stack
+        //(if required) for writing into it in parallel threads
+        flags = IJ.setupDialog(imp, flags);
+        if ((flags&DOES_STACKS)!=0 && outImageType!=BYTE_OVERWRITE) {
+            outStack = new ImageStack(width, height, imp.getStackSize());
+            maxFinder.setNPasses(imp.getStackSize());
+        }
+        return flags;
+    } //public int showDialog
+
+    /** Called by the PlugInFilterRunner to process the image or one frame of a stack */
+    public void run (ImageProcessor ip) {
+        if (interrupted) return;
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+
+        int backgroundValue = (processType==VORONOI) ?
+                (background255 ? 0 : (byte)255) : //Voronoi needs EDM of the background
+                (background255 ? (byte)255 : 0);  //all others do EDM of the foreground
+        if (USES_WATERSHED[processType]) nPasses = 0; //watershed has its own progress bar
+        FloatProcessor floatEdm = makeFloatEDM(ip, backgroundValue, false);
+
+        ByteProcessor maxIp = null;
+        if (USES_MAX_FINDER[processType]) {
+            if (processType == VORONOI) floatEdm.multiply(-1); //Voronoi starts from minima of EDM
+            int maxOutputType = USES_WATERSHED[processType] ? MaximumFinder.SEGMENTED : MaximumFinder.SINGLE_POINTS;
+            boolean isEDM = processType!=VORONOI;
+            maxIp = maxFinder.findMaxima(floatEdm, MAXFINDER_TOLERANCE,
+                ImageProcessor.NO_THRESHOLD, maxOutputType, false, isEDM);
+            if (maxIp == null) {  //segmentation cancelled by user?
+                interrupted = true;
+                return;
+            } else if (processType != WATERSHED) {
+                if (processType == VORONOI) floatEdm.multiply(-1);
+                resetMasked(floatEdm, maxIp, processType == VORONOI ? -1 : 0);
+            }
+        }
+
+        ImageProcessor outIp = null;
+        if (processType==WATERSHED) {
+            if (background255) maxIp.invert();
+            ip.copyBits(maxIp, 0, 0, Blitter.COPY);
+            ip.setBinaryThreshold();
+        } else switch (outImageType) {          //for all these, output contains the values of the EDM
+            case FLOAT:
+                outIp = floatEdm;
+                break;
+            case SHORT:
+                floatEdm.setMinAndMax(0., 65535.);
+                outIp = floatEdm.convertToShort(true);
+                break;
+            case BYTE:
+                floatEdm.setMinAndMax(0., 255.);
+                outIp = floatEdm.convertToByte(true);
+                break;
+            case BYTE_OVERWRITE:
+                ip.setPixels(0, floatEdm);
+                if (floatEdm.getMax() > 255.)
+                    ip.resetMinAndMax();        //otherwise we have max of floatEdm
+        }
+
+        if (outImageType != BYTE_OVERWRITE) {   //new output image
+            if (outStack==null) {
+                outImp = new ImagePlus(TITLE_PREFIX[processType]+imp.getShortTitle(), outIp);
+            } else
+                outStack.setPixels(outIp.getPixels(), pfr.getSliceNumber());
+        }
+    } //public void run
+
+    /** Prepare the progress bar.
+     *  Without calling it or if nPasses=0, no progress bar will be shown.
+     *  @param nPasses Number of images that this EDM will process.
+     */
+    public void setNPasses (int nPasses) {
+        this.nPasses = nPasses;
+        progressDone = 0;
+        if (USES_MAX_FINDER[processType]) maxFinder.setNPasses(nPasses);
+    }
+
+    /** Converts a binary image into a 8-bit grayscale Euclidean Distance Map
+     *  (EDM). Each foreground (nonzero) pixel in the binary image is
+     *  assigned a value equal to its distance from the nearest
+     *  background (zero) pixel.
+     */
+    public void toEDM (ImageProcessor ip) {
+        ip.setPixels(0, makeFloatEDM(ip, 0, false));
+        ip.resetMinAndMax();
+    }
+
+    /** Do watershed segmentation based on the EDM of the
+     *  foreground objects (nonzero pixels) in an 8-bit image.
+     *  Particles are segmented by their shape; segmentation
+     *  lines added are background pixels (value = 0);
+     */
+    public void toWatershed (ImageProcessor ip) {
+        FloatProcessor floatEdm = makeFloatEDM(ip, 0, false);
+        ByteProcessor maxIp = maxFinder.findMaxima(floatEdm, MAXFINDER_TOLERANCE,
+                ImageProcessor.NO_THRESHOLD, MaximumFinder.SEGMENTED, false, true);
+        if (maxIp != null) ip.copyBits(maxIp, 0, 0, Blitter.AND);
+    }
+
+    /** Calculates a 16-bit grayscale Euclidean Distance Map for a binary 8-bit image.
+     * Each foreground (nonzero) pixel in the binary image is assigned a value equal to
+     * its distance from the nearest background (zero) pixel, multiplied by EDM.ONE.
+     * For compatibility with previous versions of ImageJ only.
+     */
+    public ShortProcessor make16bitEDM (ImageProcessor ip) {
+        FloatProcessor floatEdm = makeFloatEDM(ip, 0, false);
+        floatEdm.setMinAndMax(0, 65535./ONE);
+        return (ShortProcessor)floatEdm.convertToShort(true);
+    }
+
+    /**
+     * Creates the Euclidian Distance Map of a (binary) byte image.
+     * @param ip                The input image, not modified; must be a ByteProcessor.
+     * @param backgroundValue   Pixels in the input with this value are interpreted as background.
+     *                          Note: for pixel value 255, write either -1 or (byte)255.
+     * @param edgesAreBackground Whether out-of-image pixels are considered background
+     * @return                  The EDM, containing the distances to the nearest background pixel.
+     *                          Returns null if the thread is interrupted.
+     */
+    public FloatProcessor makeFloatEDM (ImageProcessor ip, int backgroundValue, boolean edgesAreBackground) {
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        FloatProcessor fp = new FloatProcessor(width, height);
+        byte[] bPixels = (byte[])ip.getPixels();
+        float[] fPixels = (float[])fp.getPixels();
+        final int progressInterval = 100;
+        int nProgressUpdates = height/progressInterval;  //how often the progress bar is updated when passing once through y range
+        double progressAddendum = (nProgressUpdates>0) ? 0.5/nProgressUpdates : 0;
+
+        for (int i=0; i<width*height; i++)
+            if (bPixels[i]!=backgroundValue) fPixels[i] = Float.MAX_VALUE;
+
+        int[][] pointBufs = new int[2][width];  //two buffers for two passes; low short contains x, high short y
+        int yDist = Integer.MAX_VALUE;          //this value is used only if edges are not background
+        // pass 1 & 2: increasing y
+        for (int x=0; x<width; x++) {
+            pointBufs[0][x] = NO_POINT;
+            pointBufs[1][x] = NO_POINT;
+        }
+        for (int y=0; y<height; y++) {
+            if (edgesAreBackground) yDist = y+1; //distance to nearest background point (along y)
+            edmLine(bPixels, fPixels, pointBufs, width, y*width, y, backgroundValue, yDist);
+            if (y%progressInterval == 0) {
+                if (Thread.currentThread().isInterrupted()) return null;
+                addProgress(progressAddendum);
+            }
+        }
+        //pass 3 & 4: decreasing y
+        for (int x=0; x<width; x++) {
+            pointBufs[0][x] = NO_POINT;
+            pointBufs[1][x] = NO_POINT;
+        }
+        for (int y=height-1; y>=0; y--) {
+            if (edgesAreBackground) yDist = height-y;
+            edmLine(bPixels, fPixels, pointBufs, width, y*width, y, backgroundValue, yDist);
+            if (y%progressInterval == 0) {
+                if (Thread.currentThread().isInterrupted()) return null;
+                addProgress(progressAddendum);
+            }
+        }
+
+        fp.sqrt();
+        return fp;
+    } //public FloatProcessor makeFloatEDM
+
+    // Handle a line; two passes: left-to-right and right-to-left
+    private void edmLine(byte[] bPixels, float[] fPixels, int[][] pointBufs, int width,
+            int offset, int y, int backgroundValue, int yDist) {
+        int[] points = pointBufs[0];        // the buffer for the left-to-right pass
+        int pPrev = NO_POINT;
+        int pDiag = NO_POINT;               // point at (-/+1, -/+1) to current one (-1,-1 in the first pass)
+        int pNextDiag;
+        boolean edgesAreBackground = yDist != Integer.MAX_VALUE;
+        int distSqr = Integer.MAX_VALUE;    // this value is used only if edges are not background
+        for (int x=0; x<width; x++, offset++) {
+            pNextDiag = points[x];
+            if (bPixels[offset] == backgroundValue) {
+                points[x] = x | y<<16;      // remember coordinates as a candidate for nearest background point
+            } else {                        // foreground pixel:
+                if (edgesAreBackground)
+                    distSqr = (x+1 < yDist) ? (x+1)*(x+1) : yDist*yDist; //distance from edge
+                float dist2 = minDist2(points, pPrev, pDiag, x, y, distSqr);
+                if (fPixels[offset] > dist2) fPixels[offset] = dist2;
+            }
+            pPrev = points[x];
+            pDiag = pNextDiag;
+        }
+        offset--; //now points to the last pixel in the line
+        points = pointBufs[1];              // the buffer for the right-to-left pass. Low short contains x, high short y
+        pPrev = NO_POINT;
+        pDiag = NO_POINT;
+        for (int x=width-1; x>=0; x--, offset--) {
+            pNextDiag = points[x];
+            if (bPixels[offset] == backgroundValue) {
+                points[x] = x | y<<16;      // remember coordinates as a candidate for nearest background point
+            } else {                        // foreground pixel:
+                if (edgesAreBackground)
+                    distSqr = (width-x < yDist) ? (width-x)*(width-x) : yDist*yDist;
+                float dist2 = minDist2(points, pPrev, pDiag, x, y, distSqr);
+                if (fPixels[offset] > dist2) fPixels[offset] = dist2;
+            }
+            pPrev = points[x];
+            pDiag = pNextDiag;
+        }
+    } //private void edmLine
+
+    // Calculates minimum distance^2 of x,y from the following three points:
+    //  - points[x] (nearest point found for previous line, same x)
+    //  - pPrev (nearest point found for same line, previous x), and
+    //  - pDiag (nearest point found for diagonal, i.e., previous line, previous x)
+    // Sets array element points[x] to the coordinates of the point having the minimum distance to x,y
+    // If the distSqr parameter is lower than the distance^2, then distSqr is used
+    // Returns to the minimum distance^2 obtained
+    private float minDist2 (int[] points, int pPrev, int pDiag, int x, int y, int distSqr) {
+        int p0 = points[x];              // the nearest background point for the same x in the previous line
+        int nearestPoint = p0;
+        if (p0 != NO_POINT) {
+            int x0 = p0& 0xffff; int y0 = (p0>>16)&0xffff;
+            int dist1Sqr = (x-x0)*(x-x0)+(y-y0)*(y-y0);
+            if (dist1Sqr < distSqr)
+                distSqr = dist1Sqr;
+        }
+        if (pDiag!=p0 && pDiag!=NO_POINT) {
+            int x1 = pDiag&0xffff; int y1 = (pDiag>>16)&0xffff;
+            int dist1Sqr = (x-x1)*(x-x1)+(y-y1)*(y-y1);
+            if (dist1Sqr < distSqr) {
+                nearestPoint = pDiag;
+                distSqr = dist1Sqr;
+            }
+        }
+        if (pPrev!=pDiag && pPrev!=NO_POINT) {
+            int x1 = pPrev& 0xffff; int y1 = (pPrev>>16)&0xffff;
+            int dist1Sqr = (x-x1)*(x-x1)+(y-y1)*(y-y1);
+            if (dist1Sqr < distSqr) {
+                nearestPoint = pPrev;
+                distSqr = dist1Sqr;
+            }
+        }
+        points[x] = nearestPoint;
+        return (float)distSqr;
+    } //private float minDist2
+
+    // overwrite ip with floatEdm converted to bytes
+    private void byteFromFloat(ImageProcessor ip, FloatProcessor floatEdm) {
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        byte[] bPixels = (byte[])ip.getPixels();
+        float[] fPixels = (float[])floatEdm.getPixels();
+        for (int i=0; i<width*height; i++) {
+            float v = fPixels[i];
+            bPixels[i] = v<255f ? (byte)(v+0.5) : (byte)255;
+        }
+    }
+
+    // set values in floatEdm to zero if pixel in mask equals 'resetOnThis'
+    private void resetMasked(FloatProcessor floatEdm, ImageProcessor mask, int resetOnThis) {
+        int width = mask.getWidth();
+        int height = mask.getHeight();
+        byte[] mPixels = (byte[])mask.getPixels();
+        float[] fPixels = (float[])floatEdm.getPixels();
+        for (int i=0; i<width*height; i++)
+            if (mPixels[i] == resetOnThis) fPixels[i] = 0;
+    }
+
+    // at the very end - show output image (if the is a separate one)
+    private void showOutput() {
+        if (interrupted) return;
+        if (outStack!=null) {
+            outImp = new ImagePlus(TITLE_PREFIX[processType]+imp.getShortTitle(), outStack);
+            int[] d = imp.getDimensions();
+            outImp.setDimensions(d[2], d[3], d[4]);
+            for (int i=1; i<=imp.getStackSize(); i++)
+                outStack.setSliceLabel(imp.getStack().getSliceLabel(i), i);
+        }
+        if (outImageType != BYTE_OVERWRITE) {
+            ImageProcessor ip = outImp.getProcessor();
+            if (!Prefs.blackBackground) ip.invertLut();
+            ip.resetMinAndMax();
+            outImp.show();
+        }
+    }
+
+    /** add work done in the meanwhile and show progress */
+    private void addProgress(double deltaProgress) {
+        if (nPasses == 0) return;
+        progressDone += deltaProgress;
+        IJ.showProgress(progressDone/nPasses);
+    }
+    
+    /** Sets the output type (BYTE_OVERWRITE, BYTE, SHORT or FLOAT) */
+    public static void setOutputType(int type) {
+        if (type<BYTE_OVERWRITE || type>FLOAT)
+            throw new IllegalArgumentException("Invalid type: "+type);
+        outputType = type;
+    }
+
+    /** Returns the current output type (BYTE_OVERWRITE, BYTE, SHORT or FLOAT) */
+    public static int getOutputType() {
+        return outputType;
+    }
+
+}
diff --git a/src/ij/plugin/filter/ExtendedPlugInFilter.java b/src/ij/plugin/filter/ExtendedPlugInFilter.java
new file mode 100644
index 0000000..923ca43
--- /dev/null
+++ b/src/ij/plugin/filter/ExtendedPlugInFilter.java
@@ -0,0 +1,73 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+
+/** ImageJ plugins that process an image may implement this interface.
+ *  In addition to the features of PlugInFilter, it is better suited
+ *  for filters that have a dialog asking for the options or filter
+ *  parameters. It also offers support for preview, for a smooth
+ *  progress bar when processing stacks and for calling back
+ *  the PlugInFilterRunner (needed, e.g., to get the slice number
+ *  when processing a stack in parallel threads).
+ *<p>
+ *  The sequence of calls to an ExtendedPlugInFilter is the following:
+ *<p>
+ *  - <code>setup(arg, imp)</code>:  The filter should return its flags.  <p>
+ *  - <code>showDialog(imp, command, pfr)</code>: The filter should display
+ *         the dialog asking for parameters (if any) and do all operations
+ *         needed to prepare for processing the individual image(s) (E.g.,
+ *         slices of a stack). For preview, a separate thread may call
+ *         <code>setNPasses(nPasses)</code> and <code>run(ip)</code> while
+ *         the dialog is displayed. The filter should return its flags.   <p>
+ *  - <code>setNPasses(nPasses)</code>: Informs the filter of the number
+ *         of calls of <code>run(ip)</code> that will follow.             <p>
+ *  - <code>run(ip)</code>: Processing of the image(s). With the
+ *         <code>CONVERT_TO_FLOAT</code> flag, this method will be called for
+ *         each color channel of an RGB image. With <code>DOES_STACKS</code>,
+ *         it will be called for each slice of a stack.                   <p>
+ *  - <code>setup("final", imp)</code>: called only if flag
+ *         <code>FINAL_PROCESSING</code> has been specified.
+ *<p>
+ * Flag <code>DONE</code> stops this sequence of calls.
+ */
+public interface ExtendedPlugInFilter extends PlugInFilter {
+
+    /**
+     * This method is called after <code>setup(arg, imp)</code> unless the
+     * <code>DONE</code> flag has been set.
+     * @param imp The active image already passed in the
+     * <code>setup(arg, imp)</code> call. It will be null, however, if
+     * the <code>NO_IMAGE_REQUIRED</code> flag has been set.
+     * @param command The command that has led to the invocation of
+     * the plugin-filter. Useful as a title for the dialog.
+     * @param pfr The PlugInFilterRunner calling this plugin-filter.
+     * It can be passed to a GenericDialog by <code>addPreviewCheckbox</code>
+     * to enable preview by calling the <code>run(ip)</code> method of this
+     * plugin-filter. <code>pfr</code> can be also used later for calling back
+     * the PlugInFilterRunner, e.g., to obtain the slice number
+     * currently processed by <code>run(ip)</code>.
+     * @return  The method should return a combination (bitwise OR)
+     * of the flags specified in interfaces <code>PlugInFilter</code> and
+     * <code>ExtendedPlugInFilter</code>.
+     */
+    public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr);
+
+    /**
+     * This method is called by ImageJ to inform the plugin-filter
+     * about the passes to its run method. During preview, the number of
+     * passes is one (or 3 for RGB images, if <code>CONVERT_TO_FLOAT</code>
+     * has been specified). When processing a stack, it is the number
+     * of slices to be processed (minus one, if one slice has been
+     * processed for preview before), and again, 3 times that number
+     * for RGB images processed with <code>CONVERT_TO_FLOAT</code>.
+     */
+    public void setNPasses(int nPasses);
+
+    /** Set this flag if the last preview image may be kept as a result.
+        For stacks, this flag can lead to out-of-sequence processing of the
+        slices, irrespective of the <code>PARALLELIZE_STACKS<code> flag.
+     */
+    public final int KEEP_PREVIEW = 0x1000000;
+
+	
+}
diff --git a/src/ij/plugin/filter/FFTCustomFilter.java b/src/ij/plugin/filter/FFTCustomFilter.java
new file mode 100644
index 0000000..c2c3eb6
--- /dev/null
+++ b/src/ij/plugin/filter/FFTCustomFilter.java
@@ -0,0 +1,182 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.ContrastEnhancer;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.util.*;
+
+
+/** This class implements the Process/FFT/Custom Filter command. */
+public class FFTCustomFilter implements  PlugInFilter, Measurements {
+
+	private ImagePlus imp;
+	private static int filterIndex = 1;
+	private int slice;
+	private int stackSize;	
+	private ImageProcessor filter;
+	private static boolean processStack;
+	private boolean padded;
+	private int originalWidth;
+	private int originalHeight;
+	private Rectangle rect = new Rectangle();
+
+	public int setup(String arg, ImagePlus imp) {
+ 		this.imp = imp;
+ 		if (imp==null) {
+ 			IJ.noImage();
+ 			return DONE;
+ 		}
+ 		this.stackSize = imp.getStackSize();
+		filter = getFilter();
+		if (filter==null)
+			return DONE;
+		if (imp.getProperty("FHT")!=null) {
+			IJ.error("FFT Custom Filter", "Spatial domain (non-FFT) image required");
+			return DONE;
+		} else
+			return processStack?DOES_ALL+DOES_STACKS:DOES_ALL;
+	}
+
+	public void run(ImageProcessor ip) {
+		slice++;
+		FHT fht = newFHT(ip);
+		if (slice==1)
+			filter = resizeFilter(filter, fht.getWidth());
+		((FHT)fht).transform();
+		customFilter(fht);		
+		doInverseTransform(fht, ip);
+		if (slice==1)
+			ip.resetMinAndMax();
+		if (slice==stackSize) {
+			new ContrastEnhancer().stretchHistogram(imp, 0.0);
+			imp.updateAndDraw();
+		}
+		IJ.showProgress(1.0);
+		if (Recorder.record && slice==1)
+			Recorder.recordCall("FFT.filter(imp,filter); //see Help/Examples/JavaScript/FFT Filter");
+	}
+	
+	void doInverseTransform(FHT fht, ImageProcessor ip) {
+		showStatus("Inverse transform");
+		fht.inverseTransform();
+		//if (fht.quadrantSwapNeeded)
+		//	fht.swapQuadrants();
+		fht.resetMinAndMax();
+		ImageProcessor ip2 = fht;
+		fht.setRoi(rect.x, rect.y, rect.width, rect.height);
+		ip2 = fht.crop();
+		int bitDepth = fht.originalBitDepth>0?fht.originalBitDepth:imp.getBitDepth();
+		switch (bitDepth) {
+			case 8: ip2 = ip2.convertToByte(true); break;
+			case 16: ip2 = ip2.convertToShort(true); break;
+			case 24:
+				showStatus("Setting brightness");
+				fht.rgb.setBrightness((FloatProcessor)ip2);
+				ip2 = fht.rgb; 
+				fht.rgb = null;
+				break;
+			case 32: break;
+		}
+		ip.insert(ip2, 0, 0);
+	}
+
+	FHT newFHT(ImageProcessor ip) {
+		FHT fht;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		int maxN = Math.max(width, height);
+		int size = 2;
+		while (size<1.5*maxN) size *= 2;		
+		rect.x = (int)Math.round((size-width)/2.0);
+		rect.y = (int)Math.round((size-height)/2.0);
+		rect.width = width;
+		rect.height = height;
+		FFTFilter fftFilter = new FFTFilter();
+		if (ip instanceof ColorProcessor) {
+			showStatus("Extracting brightness");
+			ImageProcessor ip2 = ((ColorProcessor)ip).getBrightness();
+			fht = new FHT(fftFilter.tileMirror(ip2, size, size, rect.x, rect.y));
+			fht.rgb = (ColorProcessor)ip.duplicate(); // save so we can later update the brightness
+		} else
+			fht = new FHT(fftFilter.tileMirror(ip, size, size, rect.x, rect.y));
+		fht.originalWidth = originalWidth;
+		fht.originalHeight = originalHeight;
+		fht.originalBitDepth = imp.getBitDepth();
+		return fht;
+	}
+	
+	void showStatus(String msg) {
+		if (stackSize>1)
+			IJ.showStatus("FFT: " + slice+"/"+stackSize);
+		else
+			IJ.showStatus(msg);
+	}
+		
+	void customFilter(FHT fht) {
+		int size = fht.getWidth();
+		showStatus("Filtering");
+		fht.swapQuadrants(filter);
+		float[] fhtPixels = (float[])fht.getPixels();
+		boolean isFloat = filter.getBitDepth()==32;
+		for (int i=0; i<fhtPixels.length; i++) {
+			if (isFloat)
+				fhtPixels[i] = fhtPixels[i]*filter.getf(i);
+			else
+				fhtPixels[i] = (float)(fhtPixels[i]*(filter.get(i)/255.0));
+		}
+		fht.swapQuadrants(filter);
+	}
+	
+	ImageProcessor getFilter() {
+		int[] wList = WindowManager.getIDList();
+		if (wList==null || wList.length<2) {
+			IJ.error("FFT", "A filter (as an open image) is required.");
+			return null;
+		}
+		String[] titles = new String[wList.length];
+		for (int i=0; i<wList.length; i++) {
+			ImagePlus imp = WindowManager.getImage(wList[i]);
+			titles[i] = imp!=null?imp.getTitle():"";
+		}
+		if (filterIndex<0 || filterIndex>=titles.length)
+			filterIndex = 1;
+		GenericDialog gd = new GenericDialog("FFT Filter");
+		gd.addChoice("Filter:", titles, titles[filterIndex]);
+		if (stackSize>1)
+			gd.addCheckbox("Process entire stack", processStack);
+		gd.addHelp(IJ.URL+"/docs/menus/process.html#fft-filter");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return null;
+		filterIndex = gd.getNextChoiceIndex();
+		if (stackSize>1)
+			processStack = gd.getNextBoolean();
+		ImagePlus filterImp = WindowManager.getImage(wList[filterIndex]);
+		if (filterImp==imp) {
+			IJ.error("FFT", "The filter cannot be the same as the image being filtered.");
+			return null;
+		}		
+		if (filterImp.getStackSize()>1) {
+			IJ.error("FFT", "The filter cannot be a stack.");
+			return null;
+		}		
+		ImageProcessor filter = filterImp.getProcessor();
+		if (filter!=null && filter.getBitDepth()!=32)		
+			filter =  filter.convertToByte(true);		
+		return filter;
+	}
+	
+	ImageProcessor resizeFilter(ImageProcessor ip, int maxN) {
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		if (width==maxN && height==maxN)
+			return ip;
+		showStatus("Scaling filter to "+ maxN + "x" + maxN);
+		return ip.resize(maxN, maxN);
+	}
+		
+}
+
diff --git a/src/ij/plugin/filter/FFTFilter.java b/src/ij/plugin/filter/FFTFilter.java
new file mode 100644
index 0000000..2922de1
--- /dev/null
+++ b/src/ij/plugin/filter/FFTFilter.java
@@ -0,0 +1,442 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.ContrastEnhancer;
+import java.awt.*;
+import java.util.*;
+
+/** 
+This class implements the Process/FFT/Bandpass Filter command. It is based on 
+Joachim Walter's FFT Filter plugin at "http://imagej.nih.gov/ij/plugins/fft-filter.html".
+2001/10/29: First Version (JW)
+2003/02/06: 1st bugfix (works in macros/plugins, works on stacks, overwrites image(=>filter)) (JW)
+2003/07/03: integrated into ImageJ, added "Display Filter" option (WSR)
+2007/03/26: 2nd bugfix (Fixed incorrect calculation of filter from structure sizes, which caused
+            the real structure sizes to be wrong by a factor of 0.75 to 1.5 depending on the image size.)
+*/
+public class FFTFilter implements  PlugInFilter, Measurements {
+
+	private ImagePlus imp;
+	private String arg;
+	private static int filterIndex = 1;
+	private FHT fht;
+	private int slice;
+	private int stackSize = 1;	
+	
+	private static double filterLargeDia = 40.0;
+	private static double  filterSmallDia = 3.0;
+	private static int choiceIndex = 0;
+	private static String[] choices = {"None","Horizontal","Vertical"};
+	private static String choiceDia = choices[0];
+	private static double toleranceDia = 5.0;
+	private static boolean doScalingDia = true;
+	private static boolean saturateDia = true;
+	private static boolean displayFilter;
+	private static boolean processStack;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+ 		this.imp = imp;
+ 		if (imp==null)
+ 			{IJ.noImage(); return DONE;}
+ 		stackSize = imp.getStackSize();
+		fht  = (FHT)imp.getProperty("FHT");
+		if (fht!=null) {
+			IJ.error("FFT Filter", "Spatial domain image required");
+			return DONE;
+		}
+		if (!showBandpassDialog(imp))
+			return DONE;
+		else
+			return processStack?DOES_ALL+DOES_STACKS+PARALLELIZE_STACKS:DOES_ALL;
+	}
+
+	public void run(ImageProcessor ip) {
+		slice++;
+		filter(ip);
+	}
+	
+	void filter(ImageProcessor ip) {
+		ImageProcessor ip2 = ip;
+		if (ip2 instanceof ColorProcessor) {
+			showStatus("Extracting brightness");
+			ip2 = ((ColorProcessor)ip2).getBrightness();
+		} 
+		Rectangle roiRect = ip2.getRoi();		
+		int maxN = Math.max(roiRect.width, roiRect.height);
+		double sharpness = (100.0 - toleranceDia) / 100.0;
+		boolean doScaling = doScalingDia;
+		boolean saturate = saturateDia;
+		
+		IJ.showProgress(1,20);
+
+		/* 	tile mirrored image to power of 2 size		
+			first determine smallest power 2 >= 1.5 * image width/height
+		  	factor of 1.5 to avoid wrap-around effects of Fourier Trafo */
+
+		int i=2;
+		while(i<1.5 * maxN) i *= 2;		
+        
+        // Calculate the inverse of the 1/e frequencies for large and small structures.
+        double filterLarge = 2.0*filterLargeDia / (double)i;
+        double filterSmall = 2.0*filterSmallDia / (double)i;
+        
+		// fit image into power of 2 size 
+		Rectangle fitRect = new Rectangle();
+		fitRect.x = (int) Math.round( (i - roiRect.width) / 2.0 );
+		fitRect.y = (int) Math.round( (i - roiRect.height) / 2.0 );
+		fitRect.width = roiRect.width;
+		fitRect.height = roiRect.height;
+		
+		// put image (ROI) into power 2 size image
+		// mirroring to avoid wrap around effects
+		showStatus("Pad to "+i+"x"+i);
+		ip2 = tileMirror(ip2, i, i, fitRect.x, fitRect.y);
+		IJ.showProgress(2,20);
+		
+		// transform forward
+		showStatus(i+"x"+i+" forward transform");
+		FHT fht = new FHT(ip2);
+		fht.setShowProgress(false);
+		fht.transform();
+		IJ.showProgress(9,20);
+		//new ImagePlus("after fht",ip2.crop()).show();	
+
+		// filter out large and small structures
+		showStatus("Filter in frequency domain");
+		filterLargeSmall(fht, filterLarge, filterSmall, choiceIndex, sharpness);
+		//new ImagePlus("filter",ip2.crop()).show();
+		IJ.showProgress(11,20);
+
+		// transform backward
+		showStatus("Inverse transform");
+		fht.inverseTransform();
+		IJ.showProgress(19,20);
+		//new ImagePlus("after inverse",ip2).show();	
+		
+		// crop to original size and do scaling if selected
+		showStatus("Crop and convert to original type");
+		fht.setRoi(fitRect);
+		ip2 = fht.crop();
+		if (doScaling) {
+			ImagePlus imp2 = new ImagePlus(imp.getTitle()+"-filtered", ip2);
+			new ContrastEnhancer().stretchHistogram(imp2, saturate?1.0:0.0);
+			ip2 = imp2.getProcessor();
+		}
+
+		// convert back to original data type
+		int bitDepth = imp.getBitDepth(); 
+		switch (bitDepth) {
+			case 8: ip2 = ip2.convertToByte(doScaling); break;
+			case 16: ip2 = ip2.convertToShort(doScaling); break;
+			case 24:
+				ip.snapshot();
+				showStatus("Setting brightness");
+				((ColorProcessor)ip).setBrightness((FloatProcessor)ip2);
+				break;
+			case 32: break;
+		}
+
+		// copy filtered image back into original image
+		if (bitDepth!=24) {
+			ip.snapshot();
+			ip.copyBits(ip2, roiRect.x, roiRect.y, Blitter.COPY);
+		}
+		ip.resetMinAndMax();
+		IJ.showProgress(20,20);
+	}
+	
+	void showStatus(String msg) {
+		if (stackSize>1 && processStack)
+			IJ.showStatus("FFT Filter: "+slice+"/"+stackSize);
+		else
+			IJ.showStatus(msg);
+	}
+
+	/** Puts ImageProcessor (ROI) into a new ImageProcessor of size width x height y at position (x,y).
+	The image is mirrored around its edges to avoid wrap around effects of the FFT. */
+	public ImageProcessor tileMirror(ImageProcessor ip, int width, int height, int x, int y) {
+		if (IJ.debugMode) IJ.log("FFT.tileMirror: "+width+"x"+height+" "+ip);
+		if (x < 0 || x > (width -1) || y < 0 || y > (height -1)) {
+			IJ.error("Image to be tiled is out of bounds.");
+			return null;
+		}
+		
+		ImageProcessor ipout = ip.createProcessor(width, height);
+		
+		ImageProcessor ip2 = ip.crop();
+		int w2 = ip2.getWidth();
+		int h2 = ip2.getHeight();
+				
+		//how many times does ip2 fit into ipout?
+		int i1 = (int) Math.ceil(x / (double) w2);
+		int i2 = (int) Math.ceil( (width - x) / (double) w2);
+		int j1 = (int) Math.ceil(y / (double) h2);
+		int j2 = (int) Math.ceil( (height - y) / (double) h2);		
+
+		//tile		
+		if ( (i1%2) > 0.5)
+			ip2.flipHorizontal();
+		if ( (j1%2) > 0.5)
+			ip2.flipVertical();
+					
+		for (int i=-i1; i<i2; i += 2) {
+			for (int j=-j1; j<j2; j += 2) {
+				ipout.insert(ip2, x-i*w2, y-j*h2);
+			}
+		}
+		
+		ip2.flipHorizontal();
+		for (int i=-i1+1; i<i2; i += 2) {
+			for (int j=-j1; j<j2; j += 2) {
+				ipout.insert(ip2, x-i*w2, y-j*h2);
+			}
+		}
+		
+		ip2.flipVertical();
+		for (int i=-i1+1; i<i2; i += 2) {
+			for (int j=-j1+1; j<j2; j += 2) {
+				ipout.insert(ip2, x-i*w2, y-j*h2);
+			}
+		}
+		
+		ip2.flipHorizontal();
+		for (int i=-i1; i<i2; i += 2) {
+			for (int j=-j1+1; j<j2; j += 2) {
+				ipout.insert(ip2, x-i*w2, y-j*h2);
+			}
+		}
+		
+		return ipout;
+	}		
+	
+
+	/*
+	filterLarge: down to which size are large structures suppressed?
+	filterSmall: up to which size are small structures suppressed?
+	filterLarge and filterSmall are given as fraction of the image size 
+				in the original (untransformed) image.
+	stripesHorVert: filter out: 0) nothing more  1) horizontal  2) vertical stripes
+				(i.e. frequencies with x=0 / y=0)
+	scaleStripes: width of the stripe filter, same unit as filterLarge
+	*/
+	void filterLargeSmall(ImageProcessor ip, double filterLarge, double filterSmall, int stripesHorVert, double scaleStripes) {
+		
+		int maxN = ip.getWidth();
+			
+		float[] fht = (float[])ip.getPixels();
+		float[] filter = new float[maxN*maxN];
+		for (int i=0; i<maxN*maxN; i++)
+			filter[i]=1f;		
+
+		int row;
+		int backrow;
+		float rowFactLarge;
+		float rowFactSmall;
+		
+		int col;
+		int backcol;
+		float factor;
+		float colFactLarge;
+		float colFactSmall;
+		
+		float factStripes;
+		
+		// calculate factor in exponent of Gaussian from filterLarge / filterSmall
+
+		double scaleLarge = filterLarge*filterLarge;
+		double scaleSmall = filterSmall*filterSmall;
+		scaleStripes = scaleStripes*scaleStripes;
+		//float FactStripes;
+
+		// loop over rows
+		for (int j=1; j<maxN/2; j++) {
+			row = j * maxN;
+			backrow = (maxN-j)*maxN;
+			rowFactLarge = (float) Math.exp(-(j*j) * scaleLarge);
+			rowFactSmall = (float) Math.exp(-(j*j) * scaleSmall);
+			
+
+			// loop over columns
+			for (col=1; col<maxN/2; col++){
+				backcol = maxN-col;
+				colFactLarge = (float) Math.exp(- (col*col) * scaleLarge);
+				colFactSmall = (float) Math.exp(- (col*col) * scaleSmall);
+				factor = (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall;
+				switch (stripesHorVert) {
+					case 1: factor *= (1 - (float) Math.exp(- (col*col) * scaleStripes)); break;// hor stripes
+					case 2: factor *= (1 - (float) Math.exp(- (j*j) * scaleStripes)); // vert stripes
+				}
+				
+				fht[col+row] *= factor;
+				fht[col+backrow] *= factor;
+				fht[backcol+row] *= factor;
+				fht[backcol+backrow] *= factor;
+				filter[col+row] *= factor;
+				filter[col+backrow] *= factor;
+				filter[backcol+row] *= factor;
+				filter[backcol+backrow] *= factor;
+			}
+		}
+
+		//process meeting points (maxN/2,0) , (0,maxN/2), and (maxN/2,maxN/2)
+		int rowmid = maxN * (maxN/2);
+		rowFactLarge = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleLarge);
+		rowFactSmall = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleSmall);	
+		factStripes = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleStripes);
+		
+		fht[maxN/2] *= (1 - rowFactLarge) * rowFactSmall; // (maxN/2,0)
+		fht[rowmid] *= (1 - rowFactLarge) * rowFactSmall; // (0,maxN/2)
+		fht[maxN/2 + rowmid] *= (1 - rowFactLarge*rowFactLarge) * rowFactSmall*rowFactSmall; // (maxN/2,maxN/2)
+		filter[maxN/2] *= (1 - rowFactLarge) * rowFactSmall; // (maxN/2,0)
+		filter[rowmid] *= (1 - rowFactLarge) * rowFactSmall; // (0,maxN/2)
+		filter[maxN/2 + rowmid] *= (1 - rowFactLarge*rowFactLarge) * rowFactSmall*rowFactSmall; // (maxN/2,maxN/2)
+
+		switch (stripesHorVert) {
+			case 1: fht[maxN/2] *= (1 - factStripes);
+					fht[rowmid] = 0;
+					fht[maxN/2 + rowmid] *= (1 - factStripes);
+					filter[maxN/2] *= (1 - factStripes);
+					filter[rowmid] = 0;
+					filter[maxN/2 + rowmid] *= (1 - factStripes);
+					break; // hor stripes
+			case 2: fht[maxN/2] = 0;
+					fht[rowmid] *=  (1 - factStripes);
+					fht[maxN/2 + rowmid] *= (1 - factStripes);
+					filter[maxN/2] = 0;
+					filter[rowmid] *=  (1 - factStripes);
+					filter[maxN/2 + rowmid] *= (1 - factStripes);
+					break; // vert stripes
+		}		
+		
+		//loop along row 0 and maxN/2	
+		rowFactLarge = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleLarge);
+		rowFactSmall = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleSmall);			
+		for (col=1; col<maxN/2; col++){
+			backcol = maxN-col;
+			colFactLarge = (float) Math.exp(- (col*col) * scaleLarge);
+			colFactSmall = (float) Math.exp(- (col*col) * scaleSmall);
+			
+			switch (stripesHorVert) {
+				case 0:
+					fht[col] *= (1 - colFactLarge) * colFactSmall;
+					fht[backcol] *= (1 - colFactLarge) * colFactSmall;
+					fht[col+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall;
+					fht[backcol+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall;
+					filter[col] *= (1 - colFactLarge) * colFactSmall;
+					filter[backcol] *= (1 - colFactLarge) * colFactSmall;
+					filter[col+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall;
+					filter[backcol+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall;	
+					break;			
+				case 1:
+					factStripes = (float) Math.exp(- (col*col) * scaleStripes);
+					fht[col] *= (1 - colFactLarge) * colFactSmall * (1 - factStripes);
+					fht[backcol] *= (1 - colFactLarge) * colFactSmall * (1 - factStripes);
+					fht[col+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+					fht[backcol+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+					filter[col] *= (1 - colFactLarge) * colFactSmall * (1 - factStripes);
+					filter[backcol] *= (1 - colFactLarge) * colFactSmall * (1 - factStripes);
+					filter[col+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+					filter[backcol+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+					break;
+				case 2:
+					factStripes = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleStripes); 
+					fht[col] = 0;
+					fht[backcol] = 0;
+					fht[col+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+					fht[backcol+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+					filter[col] = 0;
+					filter[backcol] = 0;
+					filter[col+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+					filter[backcol+rowmid] *= (1 - colFactLarge*rowFactLarge) * colFactSmall*rowFactSmall * (1 - factStripes);
+			}
+		}
+		
+		// loop along column 0 and maxN/2
+		colFactLarge = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleLarge);
+		colFactSmall = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleSmall);
+		for (int j=1; j<maxN/2; j++) {
+			row = j * maxN;
+			backrow = (maxN-j)*maxN;
+			rowFactLarge = (float) Math.exp(- (j*j) * scaleLarge);
+			rowFactSmall = (float) Math.exp(- (j*j) * scaleSmall);
+
+			switch (stripesHorVert) {
+				case 0:
+					fht[row] *= (1 - rowFactLarge) * rowFactSmall;
+					fht[backrow] *= (1 - rowFactLarge) * rowFactSmall;
+					fht[row+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall;
+					fht[backrow+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall;
+					filter[row] *= (1 - rowFactLarge) * rowFactSmall;
+					filter[backrow] *= (1 - rowFactLarge) * rowFactSmall;
+					filter[row+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall;
+					filter[backrow+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall;
+					break;
+				case 1:
+					factStripes = (float) Math.exp(- (maxN/2)*(maxN/2) * scaleStripes);
+					fht[row] = 0;
+					fht[backrow] = 0;
+					fht[row+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);
+					fht[backrow+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);
+					filter[row] = 0;
+					filter[backrow] = 0;
+					filter[row+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);
+					filter[backrow+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);
+					break;
+				case 2:
+					factStripes = (float) Math.exp(- (j*j) * scaleStripes);
+					fht[row] *= (1 - rowFactLarge) * rowFactSmall * (1 - factStripes);
+					fht[backrow] *= (1 - rowFactLarge) * rowFactSmall * (1 - factStripes);
+					fht[row+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);
+					fht[backrow+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);
+					filter[row] *= (1 - rowFactLarge) * rowFactSmall * (1 - factStripes);
+					filter[backrow] *= (1 - rowFactLarge) * rowFactSmall * (1 - factStripes);
+					filter[row+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);
+					filter[backrow+maxN/2] *= (1 - rowFactLarge*colFactLarge) * rowFactSmall*colFactSmall * (1 - factStripes);	
+			}
+		}
+		if (displayFilter && slice==1) {
+			FHT f = new FHT(new FloatProcessor(maxN, maxN, filter, null));
+			f.swapQuadrants();
+			new ImagePlus("Filter", f).show();
+		}
+	}	
+
+	boolean showBandpassDialog(ImagePlus imp) {
+		if (imp.getCompositeMode()==IJ.COMPOSITE)
+			processStack = true;
+		GenericDialog gd = new GenericDialog("FFT Bandpass Filter");
+		gd.addNumericField("Filter_large structures down to", filterLargeDia, 0, 4, "pixels");
+		gd.addNumericField("Filter_small structures up to", filterSmallDia, 0, 4, "pixels");
+		gd.addChoice("Suppress stripes:", choices, choiceDia);
+		gd.addNumericField("Tolerance of direction:", toleranceDia, 0, 2, "%");
+		gd.addCheckbox("Autoscale after filtering", doScalingDia);
+		gd.addCheckbox("Saturate image when autoscaling", saturateDia);
+		gd.addCheckbox("Display filter", displayFilter);
+		if (stackSize>1)
+			gd.addCheckbox("Process entire stack", processStack);	
+		gd.addHelp(IJ.URL+"/docs/menus/process.html#fft-bandpass");
+		gd.showDialog();
+		if(gd.wasCanceled())
+			return false;
+		if(gd.invalidNumber()) {
+			IJ.error("Error", "Invalid input number");
+			return false;
+		}				
+		filterLargeDia = gd.getNextNumber();
+		filterSmallDia = gd.getNextNumber();	
+		choiceIndex = gd.getNextChoiceIndex();
+		choiceDia = choices[choiceIndex];
+		toleranceDia = gd.getNextNumber();
+		doScalingDia = gd.getNextBoolean();
+		saturateDia = gd.getNextBoolean();
+		displayFilter = gd.getNextBoolean();
+		if (stackSize>1)
+			processStack = gd.getNextBoolean();
+		return true;
+	}
+
+}
+
diff --git a/src/ij/plugin/filter/Filler.java b/src/ij/plugin/filter/Filler.java
new file mode 100644
index 0000000..88027a1
--- /dev/null
+++ b/src/ij/plugin/filter/Filler.java
@@ -0,0 +1,257 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import java.awt.*;
+
+/** This plugin implements ImageJ's Fill, Clear, Clear Outside and Draw commands. */
+public class Filler implements PlugInFilter, Measurements {
+	
+	String arg;
+	Roi roi;
+	ImagePlus imp;
+	int sliceCount;
+	ImageProcessor mask;
+	boolean isTextRoi;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		if (imp!=null)
+			roi = imp.getRoi();			
+		isTextRoi = roi!=null && (roi instanceof TextRoi);
+	 	if (isTextRoi && (arg.equals("draw") || arg.equals("fill")) && ((TextRoi)roi).getAngle()!=0.0) {
+	 		String s = IJ.isMacOSX()?"command+b":"ctrl+b";
+	 		IJ.error("Draw rotated text by pressing "+s+" (Image>Overlay>Add Selection).");
+	 		return DONE;
+		}
+		IJ.register(Filler.class);
+		int baseCapabilities = DOES_ALL+ROI_REQUIRED;
+	 	if (arg.equals("clear")) {
+	 		if (roi!=null && roi.getType()==Roi.POINT) {
+	 			IJ.error("Clear", "Area selection required");
+	 			return DONE;
+	 		}
+	 		if (isTextRoi || isLineSelection())
+				return baseCapabilities;
+			else
+				return IJ.setupDialog(imp,baseCapabilities+SUPPORTS_MASKING);
+		} else if (arg.equals("draw"))
+				return IJ.setupDialog(imp,baseCapabilities);
+		else if (arg.equals("label")) {
+				if (Analyzer.firstParticle<Analyzer.lastParticle)
+					return baseCapabilities-ROI_REQUIRED;
+				else
+					return baseCapabilities;
+		} else if (arg.equals("outside"))
+				return IJ.setupDialog(imp,baseCapabilities);
+		else if (roi!=null && roi.getType()==Roi.POINT && arg.equals("fill")) {
+	 			IJ.error("Fill", "Area selection required");
+	 			return DONE;
+	 	} else
+			return IJ.setupDialog(imp,baseCapabilities+SUPPORTS_MASKING);
+	}
+
+	public void run(ImageProcessor ip) {
+	 	if (arg.equals("clear"))
+	 		clear(ip);
+	 	else if (isTextRoi && (arg.equals("draw") || arg.equals("fill")))
+	 		draw(ip);
+	 	else if (arg.equals("fill"))
+	 		fill(ip);
+	 	else if (arg.equals("draw"))
+			draw(ip);
+	 	else if (arg.equals("label"))
+			label(ip);
+	 	else if (arg.equals("outside"))
+	 		clearOutside(ip);
+	}
+
+	boolean isLineSelection() {
+		return roi!=null && roi.isLine();
+	}
+	
+	boolean isStraightLine() {
+		return roi!=null && roi.getType()==Roi.LINE;
+	}
+	
+	public void clear(ImageProcessor ip) {
+	 	ip.setGlobalBackgroundColor();
+		if (isLineSelection()) {
+			if (isStraightLine() && roi.getStrokeWidth()>1)
+				ip.fillPolygon(roi.getPolygon());
+			else
+				roi.drawPixels();
+		} else if (roi!=null && roi instanceof TextRoi)
+			((TextRoi)roi).clear(ip);
+		else
+	 		ip.fill(); // fill with background color
+		ip.setGlobalForegroundColor();
+	}
+		
+	/**
+	* @deprecated
+	* replaced by ImageProcessor.fill(Roi)
+	*/
+	public void fill(ImageProcessor ip) {
+		if (!IJ.isMacro() || !ip.fillValueSet())
+			ip.setGlobalForegroundColor();
+		if (isLineSelection()) {
+			if (isStraightLine() && roi.getStrokeWidth()>1 && !(roi instanceof Arrow)) {
+				Roi roi2=Roi.convertLineToArea(roi);
+				ip.setRoi(roi2);
+				ip.fill(roi2.getMask());
+				ip.setRoi(roi);
+			} else
+				roi.drawPixels(ip);
+		} else
+			ip.fill(); // fill with foreground color
+	}
+	 			 		
+	/**
+	* @deprecated
+	* replaced by ImageProcessor.draw(Roi)
+	*/
+	public void draw(ImageProcessor ip) {
+		ip.setGlobalForegroundColor();
+		roi.drawPixels(ip);
+		if (IJ.altKeyDown())
+			drawLabel(ip);
+ 	}
+
+	public void label(ImageProcessor ip) {
+		if (!IJ.isMacro()) {
+			IJ.error("Label", "To label a selection, enable \"Add to overlay\" in Analyze>\nSet Measurements and press 'm' (Analyze>Measure).");
+			return;
+		}
+		if (Analyzer.getCounter()==0) {
+			IJ.error("Label", "Measurement counter is zero");
+			return;
+		}
+		if (Analyzer.firstParticle<Analyzer.lastParticle)
+			drawParticleLabels(ip);
+		else {
+			ip.setColor(Toolbar.getForegroundColor());
+			ImageCanvas ic = imp.getCanvas();
+			if (ic!=null) {
+				double mag = ic.getMagnification();
+				if (mag<1.0) {
+					int lineWidth = 1;
+					lineWidth = (int)(lineWidth/mag);
+					ip.setLineWidth(lineWidth);
+				}
+			}
+			roi.drawPixels(ip);
+			ip.setLineWidth(1);
+			drawLabel(ip);
+		}
+	}
+
+	void drawParticleLabels(ImageProcessor ip) {
+		ResultsTable rt = ResultsTable.getResultsTable();
+		int count = rt.size();
+		int first = Analyzer.firstParticle;
+		int last = Analyzer.lastParticle;
+		if (count==0 || first>=count || last>=count)
+			return;
+		if (!rt.columnExists(ResultsTable.X_CENTROID)) {
+			IJ.error("Label", "\"Centroids\" required to label particles");
+			return;
+		}
+		for (int i=first; i<=last; i++) {
+			int x = (int)rt.getValueAsDouble(ResultsTable.X_CENTROID, i);		
+			int y = (int)rt.getValueAsDouble(ResultsTable.Y_CENTROID, i);		
+			drawLabel(imp, ip, i+1, new Rectangle(x,y,0,0));
+		}
+	}
+
+	void drawLabel(ImageProcessor ip) {
+		int count = Analyzer.getCounter();
+		if (count>0 && roi!=null)
+			drawLabel(imp, ip, count, roi.getBounds());
+	}
+
+	public void drawLabel(ImagePlus imp, ImageProcessor ip, int count, Rectangle r) {
+		Color foreground = Toolbar.getForegroundColor();
+		Color background = Toolbar.getBackgroundColor();
+		if (foreground.equals(background)) {
+			foreground = Color.black;
+			background = Color.white;
+		}
+		int size = 9;
+		ImageCanvas ic = imp.getCanvas();
+		if (ic!=null) {
+			double mag = ic.getMagnification();
+			if (mag<1.0)
+				size /= mag;
+		}
+		if (size==9 && r.width>50 && r.height>50)
+			size = 12;
+		ip.setFont(new Font("SansSerif", Font.PLAIN, size));
+		String label = "" + count;
+		int w =  ip.getStringWidth(label);
+		int x = r.x + r.width/2 - w/2;
+		int y = r.y + r.height/2 + Math.max(size/2,6);
+		FontMetrics metrics = ip.getFontMetrics();
+		int h =  metrics.getHeight();
+		ip.setColor(background);
+		ip.setRoi(x-1, y-h+2, w+1, h-3);
+		ip.fill();
+		ip.resetRoi();
+		ip.setColor(foreground);
+		ip.drawString(label, x, y);
+	} 
+
+	/**
+	* @deprecated
+	* replaced by ImageProcessor.fillOutside(Roi)
+	*/
+	public synchronized void clearOutside(ImageProcessor ip) {
+		if (isLineSelection()) {
+			IJ.error("\"Clear Outside\" does not work with line selections.");
+			return;
+		}
+ 		sliceCount++;
+ 		Rectangle r = ip.getRoi();
+ 		if (mask==null)
+ 			makeMask(ip, r);
+   		ip.setGlobalBackgroundColor();  		
+ 		int stackSize = imp.getStackSize();
+ 		if (stackSize>1)
+ 			ip.snapshot();
+		ip.fill();
+ 		ip.reset(mask);
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+ 		ip.setRoi(0, 0, r.x, height);
+ 		ip.fill();
+ 		ip.setRoi(r.x, 0, r.width, r.y);
+ 		ip.fill();
+ 		ip.setRoi(r.x, r.y+r.height, r.width, height-(r.y+r.height));
+ 		ip.fill();
+ 		ip.setRoi(r.x+r.width, 0, width-(r.x+r.width), height);
+ 		ip.fill();
+ 		ip.setRoi(r); // restore original ROI
+ 		if (sliceCount==stackSize) {
+			ip.setGlobalForegroundColor();
+			Roi roi = imp.getRoi();
+			imp.deleteRoi();
+			imp.updateAndDraw();
+			imp.setRoi(roi);
+		}
+	}
+
+	public void makeMask(ImageProcessor ip, Rectangle r) {
+ 		mask = ip.getMask();
+ 		if (mask==null) {
+ 			mask = new ByteProcessor(r.width, r.height);
+ 			mask.invert();
+ 		} else {
+ 			// duplicate mask (needed because getMask caches masks)
+ 			mask = mask.duplicate();
+ 		}
+ 		mask.invert();
+ 	}
+
+}
diff --git a/src/ij/plugin/filter/Filters.java b/src/ij/plugin/filter/Filters.java
new file mode 100644
index 0000000..89f6be5
--- /dev/null
+++ b/src/ij/plugin/filter/Filters.java
@@ -0,0 +1,99 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import java.awt.*;
+
+/** This plugin implements the Invert, Smooth, Sharpen, Find Edges, 
+	and Add Noise commands. */
+public class Filters implements PlugInFilter {
+	
+	private static double sd = Prefs.getDouble(Prefs.NOISE_SD, 25.0);
+	private String arg;
+	private ImagePlus imp;
+	private int slice;
+	private boolean canceled;
+	private boolean noRoi;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		if (imp!=null) {
+			Roi roi = imp.getRoi();
+			if (imp.getType()==ImagePlus.GRAY16 && arg.equals("invert")) {
+				imp.resetRoi();
+				roi = null;
+			}
+			if (roi!=null && !roi.isArea())
+				noRoi = true;
+		}
+		int flags = IJ.setupDialog(imp, DOES_ALL-DOES_8C+SUPPORTS_MASKING);
+		return flags;
+	}
+
+	public void run(ImageProcessor ip) {
+	
+		if (noRoi)
+			ip.resetRoi();
+	
+		if (arg.equals("invert")) {
+	 		ip.invert();
+	 		slice++;
+	 		if (imp.getBitDepth()==16 && imp.getStackSize()>1 && slice==imp.getStackSize())
+	 			imp.resetDisplayRange();
+	 		return;
+	 	}
+	 	
+		if (arg.equals("smooth")) {
+			ip.setSnapshotCopyMode(true);
+	 		ip.smooth();
+			ip.setSnapshotCopyMode(false);
+	 		return;
+	 	}
+	 	
+		if (arg.equals("sharpen")) {
+			ip.setSnapshotCopyMode(true);
+	 		ip.sharpen();
+			ip.setSnapshotCopyMode(false);
+	 		return;
+	 	}
+	 	
+		if (arg.equals("edge")) {
+			ip.setSnapshotCopyMode(true);
+			ip.findEdges();
+			ip.setSnapshotCopyMode(false);
+	 		return;
+		}
+						
+	 	if (arg.equals("add")) {
+	 		ip.noise(25.0);
+	 		return;
+	 	}
+	 	
+	 	if (arg.equals("noise")) {
+	 		if (canceled)
+	 			return;
+	 		slice++;
+	 		if (slice==1) {
+				GenericDialog gd = new GenericDialog("Gaussian Noise");
+				gd.addNumericField("Standard Deviation:", sd, 2);
+				gd.showDialog();
+				if (gd.wasCanceled()) {
+					canceled = true;
+					return;
+				}
+				sd = gd.getNextNumber();
+			}
+	 		ip.noise(sd);
+	 		IJ.register(Filters.class);
+	 		return;
+	 	}
+        	 	
+	}
+		
+	/** Returns the default standard deviation used by Process/Noise/Add Specified Noise. */
+	public static double getSD() {
+		return sd;
+	}
+	
+}
diff --git a/src/ij/plugin/filter/FractalBoxCounter.java b/src/ij/plugin/filter/FractalBoxCounter.java
new file mode 100644
index 0000000..028cdff
--- /dev/null
+++ b/src/ij/plugin/filter/FractalBoxCounter.java
@@ -0,0 +1,241 @@
+package ij.plugin.filter;
+import java.awt.*;
+import java.awt.image.*;
+import java.util.*;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.util.*;
+
+/**
+Calculate the so-called "capacity" fractal dimension.  The algorithm
+is called, in fractal parlance, the "box counting" method.  In the
+simplest terms, the routine counts the number of boxes of a given size
+needed to cover a one pixel wide, binary (black on white) border.
+The procedure is repeated for boxes that are 2 to 64 pixels wide. 
+The output consists of two columns labeled "size" and "count". A plot 
+is generated with the log of size on the x-axis and the log of count on
+the y-axis and the data is fitted with a straight line. The slope (S) 
+of the line is the negative of the fractal dimension, i.e. D=-S.
+
+A full description of the technique can be found in T. G. Smith,
+Jr., G. D. Lange and W. B. Marks, Fractal Methods and Results in Cellular Morphology,
+which appeared in J. Neurosci. Methods, 69:1123-126, 1996.
+
+---
+12/Jun/2006 G. Landini added "set is white" option, otherwise the plugin
+assumes that the object is always low-dimensional (i.e. the phase with
+the smallest number of pixels). Now it works fine for sets with D near to 2.0
+
+*/
+public class FractalBoxCounter implements PlugInFilter {
+	static String sizes = "2,3,4,6,8,12,16,32,64";
+	static boolean blackBackground;
+	int[] boxSizes;
+	float[] boxCountSums;
+	int maxBoxSize;
+	int[] counts;
+	Rectangle roi;
+	int foreground;
+	ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_8G+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+
+		GenericDialog gd = new GenericDialog("Fractal Box Counter");
+		gd.addStringField("Box Sizes:", sizes, 20);
+		gd.addCheckbox("Black Background", blackBackground);
+
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+
+		String s = gd.getNextString();
+
+		blackBackground = gd.getNextBoolean ();
+
+		if (s.equals(""))
+			return;
+		boxSizes = s2ints(s);
+		if (boxSizes==null || boxSizes.length<1)
+			return;
+		boxCountSums = new float[boxSizes.length];
+		sizes = s;
+		for (int i=0; i<boxSizes.length; i++)
+			maxBoxSize = Math.max(maxBoxSize, boxSizes[i]);
+		counts = new int[maxBoxSize*maxBoxSize+1];
+		imp.deleteRoi();
+		if (!ip.isBinary()) {
+			IJ.error("8-bit binary image (0 and 255) required.");
+			return;
+		}
+		if (blackBackground)
+			foreground = 255;
+		else
+			foreground = 0;
+		if (ip.isInvertedLut())
+			foreground = 255 - foreground;
+		doBoxCounts(ip);
+		IJ.register(FractalBoxCounter.class);  // keeps this class from being GC'd on 1.1 JVMs
+		return;
+	}
+
+	/** Breaks the specified string into an array
+	 of ints. Returns null if there is an error.*/
+	public int[] s2ints(String s) {
+		StringTokenizer st = new StringTokenizer(s, ", \t");
+		int nInts = st.countTokens();
+		int[] ints = new int[nInts];
+		for(int i=0; i<nInts; i++) {
+			try {ints[i] = Integer.parseInt(st.nextToken());}
+			catch (NumberFormatException e) {IJ.log(""+e); return null;}
+		}
+		return ints;
+	}
+
+	boolean FindMargins(ImageProcessor ip) {
+		if (IJ.debugMode) IJ.log("FindMargins");
+		int[] histogram = new int[256];
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		int left, right, top, bottom;
+
+		//Find left edge
+ 		left = -1;
+		do {
+			left++;
+			if (left>=width) {
+				IJ.error("No non-backround pixels found.");
+				return false;
+			}
+			ip.setRoi(left, 0, 1, height);
+			histogram = ip.getHistogram();
+		} while (histogram[foreground]==0);
+
+		//Find top edge
+		top = -1;
+		do {
+			top++;
+			ip.setRoi(left, top, width-left, 1);
+			histogram = ip.getHistogram();
+		} while (histogram[foreground]==0);
+
+		//Find right edge
+		right =width+1;
+		do {
+			right--;
+			ip.setRoi(right-1, top, 1, height-top);
+			histogram = ip.getHistogram();
+		} while (histogram[foreground]==0);
+
+		//Find bottom edge
+		bottom =height+1;
+		do {
+			bottom--;
+			ip.setRoi(left, bottom-1, right-left, 1);
+			histogram = ip.getHistogram();
+		} while (histogram[foreground]==0);
+
+		roi = new Rectangle(left, top, right-left, bottom-top);
+		return true;
+	}
+
+	int count(int size, ImageProcessor ip) {
+		int[] histogram = new int[256];
+		int count;
+		int x = roi.x;
+		int y = roi.y;
+		int w = (size<=roi.width)?size:roi.width;
+		int h = (size<=roi.height)?size:roi.height;
+		int right = roi.x+roi.width;
+		int bottom = roi.y+roi.height;
+		int maxCount = size*size;
+		
+		for (int i=1; i<=maxCount; i++)
+			counts[i] = 0;
+		boolean done = false;
+		do {
+			ip.setRoi(x, y, w, h);
+			histogram = ip.getHistogram();
+			counts[histogram[foreground]]++;
+			x+=size;
+			if (x+size>=right) {
+				w = right-x;
+				if (x>=right) {
+					w = size;
+					x = roi.x;
+					y += size;
+					if (y+size>=bottom)
+						h = bottom-y;
+					done = y>=bottom;
+				}
+			}
+		} while (!done);
+		int boxSum = 0;
+		int nBoxes;
+		for (int i=1; i<=maxCount; i++) {
+			nBoxes = counts[i];
+			if (nBoxes!=0)
+				boxSum += nBoxes;
+		}
+		return boxSum;
+	}
+	
+	double plot() {
+		int n = boxSizes.length;
+		float[] sizes = new float[boxSizes.length];
+		for (int i=0; i<n; i++)
+			sizes[i] = (float)Math.log(boxSizes[i]);
+		CurveFitter cf = new CurveFitter(Tools.toDouble(sizes), Tools.toDouble(boxCountSums));
+		cf.doFit(CurveFitter.STRAIGHT_LINE);
+		double[] p = cf.getParams();
+		double D = -p[1];
+		String label = "D="+IJ.d2s(D,4);
+		float[] px = new float[100];
+		float[] py = new float[100];
+		double[] a = Tools.getMinMax(sizes);
+		double xmin=a[0], xmax=a[1]; 
+		a = Tools.getMinMax(boxCountSums);
+		double ymin=a[0], ymax=a[1]; 
+		double inc = (xmax-xmin)/99.0;
+		double tmp = xmin;
+		for (int i=0; i<100; i++) {
+			px[i]=(float)tmp;
+			tmp += inc;
+		}
+		for (int i=0; i<100; i++)
+			py[i] = (float)cf.f(p, px[i]);
+		a = Tools.getMinMax(py);
+		ymin = Math.min(ymin, a[0]);
+		ymax = Math.max(ymax, a[1]);
+		Plot plot = new Plot("Plot", "log (box size)", "log (count)", px, py);
+		plot.setLimits(xmin,xmax,ymin,ymax);
+		plot.addPoints(sizes, boxCountSums, PlotWindow.CIRCLE);
+		plot.addLabel(0.8, 0.2, label);
+		plot.show();
+		return D;			
+	}
+
+	void doBoxCounts(ImageProcessor ip) {
+		if (!FindMargins(ip))
+			return;
+		ResultsTable rt=ResultsTable.getResultsTable();
+		rt.incrementCounter();
+		rt.setLabel(imp.getShortTitle(), rt.size()-1);
+		for (int i=0; i<boxSizes.length; i++) {
+			int boxSum = count(boxSizes[i], ip);
+			rt.addValue("C"+boxSizes[i], boxSum);
+			boxCountSums[i] = (float)Math.log(boxSum);
+		}
+		double D = plot();
+		rt.addValue("D", D);
+		rt.show("Results");
+		imp.deleteRoi();
+	}
+}
+
diff --git a/src/ij/plugin/filter/GaussianBlur.java b/src/ij/plugin/filter/GaussianBlur.java
new file mode 100644
index 0000000..ad0da5f
--- /dev/null
+++ b/src/ij/plugin/filter/GaussianBlur.java
@@ -0,0 +1,609 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.util.ThreadUtil;
+
+import java.awt.AWTEvent;
+import java.awt.Rectangle;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+/** This plug-in filter uses convolution with a Gaussian function for smoothing.
+ * 'Radius' means the radius of decay to exp(-0.5) ~ 61%, i.e. the standard
+ * deviation sigma of the Gaussian (this is the same as in Photoshop, but
+ * different from the 'Gaussian Blur' in ImageJ versions before 1.38u, where
+ * a value 2.5 times as much had to be entered.
+ * - Like all convolution operations in ImageJ, it assumes that out-of-image
+ * pixels have a value equal to the nearest edge pixel. This gives higher
+ * weight to edge pixels than pixels inside the image, and higher weight
+ * to corner pixels than non-corner pixels at the edge. Thus, when smoothing
+ * with very high blur radius, the output will be dominated by the edge
+ * pixels and especially the corner pixels (in the extreme case, with
+ * a blur radius of e.g. 1e20, the image will be raplaced by the average
+ * of the four corner pixels).
+ * - For increased speed, except for small blur radii, the lines (rows or
+ * columns of the image) are downscaled before convolution and upscaled
+ * to their original length thereafter.
+ * 
+ * Version 03-Jun-2007 M. Schmid with preview, progressBar stack-aware,
+ * snapshot via snapshot flag; restricted range for resetOutOfRoi
+ * 
+ * 20-Feb-2010 S. Saalfeld inner multi-threading, modified 29-Aug-2019 M. Schmid
+ *
+ */
+
+public class GaussianBlur implements ExtendedPlugInFilter, DialogListener {
+
+    /** for remembering till the next invocation */
+    private static double sigmaS = 2.0;
+    private static boolean sigmaScaledS = false;
+    /** the standard deviation of the Gaussian*/
+    private double sigma = sigmaS;
+    /** whether sigma is given in units corresponding to the pixel scale (not pixels)*/
+    private boolean sigmaScaled = sigmaScaledS;
+    /** The flags specifying the capabilities and needs */
+    private int flags = DOES_ALL|SUPPORTS_MASKING|KEEP_PREVIEW;
+    private ImagePlus imp;              // The ImagePlus of the setup call, needed to get the spatial calibration
+    private boolean hasScale = false;   // whether the image has an x&y scale
+    private int nPasses = 2;            // The number of passes (filter directions * color channels * stack slices)
+    private int nChannels = 1;        // The number of color channels
+    private int pass;                        // Current pass
+    private boolean noProgress;      // Do not show progress bar
+    private boolean calledAsPlugin;
+    
+    /** Method to return types supported
+     * @param arg unused
+     * @param imp The ImagePlus, used to get the spatial calibration
+     * @return Code describing supported formats etc.
+     * (see ij.plugin.filter.PlugInFilter & ExtendedPlugInFilter)
+     */
+    public int setup(String arg, ImagePlus imp) {
+        this.imp = imp;
+        if (imp!=null && imp.getRoi()!=null) {
+            Rectangle roiRect = imp.getRoi().getBoundingRect();
+            if (roiRect.y > 0 || roiRect.y+roiRect.height < imp.getDimensions()[1])
+                flags |= SNAPSHOT;                  // snapshot for pixels above and/or below roi rectangle
+        }
+        return flags;
+    }
+    
+    /** Ask the user for the parameters
+     */
+    public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+        calledAsPlugin = true;;
+        String options = Macro.getOptions();
+        boolean oldMacro = false;
+        nChannels = imp.getProcessor().getNChannels();
+        setNPasses(1);
+        if  (options!=null) {
+            if (options.indexOf("radius=") >= 0) {  // ensure compatibility with old macros
+                oldMacro = true;                    // specifying "radius=", not "sigma=
+                Macro.setOptions(options.replaceAll("radius=", "sigma="));
+            }
+        }
+		GenericDialog gd = GUI.newNonBlockingDialog(command, imp);
+        sigma = Math.abs(sigma);
+        gd.addNumericField("Sigma (Radius):", sigma, 2);
+        if (imp.getCalibration()!=null && !imp.getCalibration().getUnits().equals("pixels")) {
+            hasScale = true;
+            gd.addCheckbox("Scaled Units ("+imp.getCalibration().getUnits()+")", sigmaScaled);
+        } else
+            sigmaScaled = false;
+        gd.addPreviewCheckbox(pfr);
+        gd.addDialogListener(this);
+        gd.showDialog();                    // input by the user (or macro) happens here
+        if (gd.wasCanceled()) return DONE;
+        if (options==null) {                // interactive use: remember values as default for the next invocation
+            sigmaS = sigma;
+            sigmaScaledS = sigmaScaled;
+        }
+        if (oldMacro) sigma /= 2.5;         // for old macros, "radius" was 2.5 sigma
+        IJ.register(this.getClass());       // protect static class variables (parameters) from garbage collection
+        return IJ.setupDialog(imp, flags);  // ask whether to process all slices of stack (if a stack)
+    }
+
+    /** Listener to modifications of the input fields of the dialog */
+    public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+        sigma = gd.getNextNumber();
+        if (sigma < 0 || gd.invalidNumber())
+            return false;
+        if (hasScale)
+            sigmaScaled = gd.getNextBoolean();
+        return true;
+    }
+
+    /** Set the number of passes of the blur1Direction method. If called by the
+     *  PlugInFilterRunner of ImageJ, an ImagePlus is known and conversion of RGB images
+     *  to float as well as the two filter directions are taken into account.
+     *  Otherwise, the caller should set nPasses to the number of 1-dimensional
+     *  filter operations required.
+     */
+    public void setNPasses(int nPasses) {
+        this.nPasses = 2 * nChannels * nPasses;
+        pass = 0;
+    }
+
+    /** This method is invoked for each slice during execution
+     * @param ip The image subject to filtering. It must have a valid snapshot if
+     * the height of the roi is less than the full image height.
+     */
+    public void run(ImageProcessor ip) {
+        double sigmaX = sigmaScaled ? sigma/imp.getCalibration().pixelWidth : sigma;
+        double sigmaY = sigmaScaled ? sigma/imp.getCalibration().pixelHeight : sigma;
+        double accuracy = (ip instanceof ByteProcessor || ip instanceof ColorProcessor) ?
+            0.002 : 0.0002;
+        Rectangle roi = ip.getRoi();
+        blurGaussian(ip, sigmaX, sigmaY, accuracy);
+    }
+
+    /** Gaussian Filtering of an ImageProcessor. This method is for compatibility with the
+    * previous code (before 1.38r) and uses a low-accuracy kernel, only slightly better
+    * than the previous ImageJ code.
+    * The 'radius' in this call is different from the one used in ImageJ 1.38r and later.
+    * Therefore, use blurGaussian(ip, sigma, sigma, accuracy), where 'sigma' is equivalent
+    * to the 'sigma (radius)' of the Menu, and accuracy should be 0.02 unless better
+    * accuracy is desired.
+    */
+    @Deprecated
+    public boolean blur(ImageProcessor ip, double radius) {
+        Rectangle roi = ip.getRoi();
+        if (roi.height!=ip.getHeight() && ip.getMask()==null)
+            ip.snapshot();              // a snapshot is needed for out-of-Rectangle pixels
+        blurGaussian(ip, 0.4*radius, 0.4*radius, 0.01);
+        return true;
+    }
+
+	/** Gaussian Filtering of an ImageProcessor
+	* @param ip       The ImageProcessor to be filtered.
+	* @param sigma   Standard deviation of the Gaussian (pixels)
+	*
+	* @see ij.process.ImageProcessor#blurGaussian(double)
+	*/
+	public void blurGaussian(ImageProcessor ip, double sigma) {
+		double accuracy = (ip instanceof ByteProcessor||ip instanceof ColorProcessor)?0.002:0.0002;
+		blurGaussian(ip, sigma, sigma, accuracy);
+	}
+
+    /** Gaussian Filtering of an ImageProcessor
+     * @param ip       The ImageProcessor to be filtered.
+     * @param sigmaX   Standard deviation of the Gaussian in x direction (pixels)
+     * @param sigmaY   Standard deviation of the Gaussian in y direction (pixels)
+     * @param accuracy Accuracy of kernel, should not be above 0.02. Better (lower)
+     *    accuracy needs slightly more computing time.
+     */
+    public void blurGaussian(ImageProcessor ip, double sigmaX, double sigmaY, double accuracy) {
+        boolean hasRoi = ip.getRoi().height!=ip.getHeight() && sigmaX>0 && sigmaY>0;
+        if (hasRoi && !calledAsPlugin)
+        	ip.snapshot();
+        if (nPasses<=1)
+            nPasses = ip.getNChannels() * (sigmaX>0 && sigmaY>0 ? 2 : 1);
+        FloatProcessor fp = null;
+        for (int i=0; i<ip.getNChannels(); i++) {
+            fp = ip.toFloat(i, fp);
+            if (Thread.currentThread().isInterrupted()) return; // interruption for new parameters during preview?
+            blurFloat(fp, sigmaX, sigmaY, accuracy);
+            if (Thread.currentThread().isInterrupted()) return;
+            ip.setPixels(i, fp);
+        }
+        if (hasRoi)
+            resetOutOfRoi(ip, (int)Math.ceil(5*sigmaY)); // reset out-of-Rectangle pixels above and below roi
+        return;
+    }
+    
+    /** Gaussian Filtering of a FloatProcessor. This method does NOT include
+     *  resetOutOfRoi(ip), i.e., pixels above and below the roi rectangle will
+     *  be also subject to filtering in x direction and must be restored
+     *  afterwards (unless the full image height is processed).
+     * @param ip        The FloatProcessor to be filtered.
+     * @param sigmaX    Standard deviation of the Gaussian in x direction (pixels)
+     * @param sigmaY    Standard deviation of the Gaussian in y direction (pixels)
+     * @param accuracy  Accuracy of kernel, should not be above 0.02. Better (lower)
+     *                  accuracy needs slightly more computing time.
+     */
+    public void blurFloat(FloatProcessor ip, double sigmaX, double sigmaY, double accuracy) {
+        if (sigmaX > 0)
+            blur1Direction(ip, sigmaX, accuracy, true, (int)Math.ceil(5*sigmaY));
+        if (Thread.currentThread().isInterrupted()) return; // interruption for new parameters during preview?
+        if (sigmaY > 0)
+            blur1Direction(ip, sigmaY, accuracy, false, 0);
+        return;
+    }
+
+    /** Blur an image in one direction (x or y) by a Gaussian, using multiple threads on multiprocessor machines
+     * @param ip        The Image with the original data where also the result will be stored
+     * @param sigma     Standard deviation of the Gaussian
+     * @param accuracy  Accuracy of kernel, should not be > 0.02
+     * @param xDirection True for bluring in x direction, false for y direction
+     * @param extraLines Number of lines (parallel to the blurring direction) 
+     *                  below and above the roi bounds that should be processed.
+     */
+    public void blur1Direction( final FloatProcessor ip, final double sigma, final double accuracy,
+            final boolean xDirection, final int extraLines) {
+        
+        final int UPSCALE_K_RADIUS = 2;                     //number of pixels to add for upscaling
+        final double MIN_DOWNSCALED_SIGMA = 4.;             //minimum standard deviation in the downscaled image
+        final float[] pixels = (float[])ip.getPixels();
+        final int width = ip.getWidth();
+        final int height = ip.getHeight();
+        final Rectangle roi = ip.getRoi();
+        final int length = xDirection ? width : height;     //number of points per line (line can be a row or column)
+        final int pointInc = xDirection ? 1 : width;        //increment of the pixels array index to the next point in a line
+        final int lineInc = xDirection ? width : 1;         //increment of the pixels array index to the next line
+        final int lineFromA = (xDirection ? roi.y : roi.x) - extraLines;  //the first line to process
+        final int lineFrom;
+        if (lineFromA < 0) lineFrom = 0;
+        else lineFrom = lineFromA;
+        final int lineToA = (xDirection ? roi.y+roi.height : roi.x+roi.width) + extraLines; //the last line+1 to process
+        final int lineTo;
+        if (lineToA > (xDirection ? height:width)) lineTo = (xDirection ? height:width);
+        else lineTo = lineToA;
+        final int writeFrom = xDirection? roi.x : roi.y;    //first point of a line that needs to be written
+        final int writeTo = xDirection ? roi.x+roi.width : roi.y+roi.height;
+        
+        /* large radius (sigma): scale down, then convolve, then scale up */
+        final boolean doDownscaling = sigma > 2*MIN_DOWNSCALED_SIGMA + 0.5;
+        final int reduceBy = doDownscaling ?                //downscale by this factor
+                Math.min((int)Math.floor(sigma/MIN_DOWNSCALED_SIGMA), length)
+                : 1;
+        /* Downscaling and upscaling blur the image a bit - we have to correct the standard
+         * deviation for this:
+         * Downscaling gives std devation sigma = 1/sqrt(3); upscale gives sigma = 1/2 (in downscaled pixels).
+         * All sigma^2 values add to full sigma^2, which should be the desired value  */
+        final double sigmaGauss = doDownscaling ?
+                Math.sqrt(sigma*sigma/(reduceBy*reduceBy) - 1./3. - 1./4.)
+                : sigma;
+        final int maxLength = doDownscaling ?
+                (length+reduceBy-1)/reduceBy + 2*(UPSCALE_K_RADIUS + 1) //downscaled line can't be longer
+                : length;
+        final float[][] gaussKernel = makeGaussianKernel(sigmaGauss, accuracy, maxLength);
+        final int kRadius = gaussKernel[0].length*reduceBy;             //Gaussian kernel radius after upscaling
+        final int readFrom = (writeFrom-kRadius < 0) ? 0 : writeFrom-kRadius; //not including broadening by downscale&upscale
+        final int readTo = (writeTo+kRadius > length) ? length : writeTo+kRadius;
+        final int newLength = doDownscaling ?                           //line length for convolution
+                (readTo-readFrom+reduceBy-1)/reduceBy + 2*(UPSCALE_K_RADIUS + 1)
+                : length;
+        final int unscaled0 = readFrom - (UPSCALE_K_RADIUS + 1)*reduceBy; //input point corresponding to cache index 0
+        //the following is relevant for upscaling only
+        //IJ.log("reduce="+reduceBy+", newLength="+newLength+", unscaled0="+unscaled0+", sigmaG="+(float)sigmaGauss+", kRadius="+gaussKernel[0].length);
+        final float[] downscaleKernel = doDownscaling ? makeDownscaleKernel(reduceBy) : null;
+        final float[] upscaleKernel = doDownscaling ? makeUpscaleKernel(reduceBy) : null;
+
+        int numThreads1 = Math.min(Prefs.getThreads(), lineTo-lineFrom);
+        int numThreads2 = (int)((lineTo - lineFrom)*(long)(writeTo - writeFrom)*gaussKernel[0].length/
+                (doDownscaling ? 8000 : 16000)) + 1; //use fewer threads if a small task
+        final int numThreads = Math.min(numThreads1, numThreads2);
+        final Callable[] callables = new Callable[numThreads];
+        final AtomicInteger nextLine = new AtomicInteger(lineFrom);
+        final AtomicLong lastShowProgressTime = new AtomicLong(System.currentTimeMillis());
+           
+        for ( int t = 0; t < numThreads; t++ ) {
+            final float[] cache1 = new float[newLength];  //holds data before convolution (after downscaling, if any)
+            final float[] cache2 = doDownscaling ? new float[newLength] : null;  //holds data after convolution
+            
+            callables[t] = new Callable() {
+                final public Void call() { /*try{*/
+                    while (!Thread.currentThread().isInterrupted()) {
+                        int line = nextLine.getAndIncrement();
+                        if (line >= lineTo) break;
+                        int pixel0 = line*lineInc;
+                        if ((line&0x1f)==0) { //every 32 lines, check whether progress bar should be updated
+                            long time = System.currentTimeMillis();
+                            if (time - lastShowProgressTime.get() >110) {
+                                lastShowProgressTime.set(time);
+                                showProgress((double)(line-lineFrom)/(lineTo-lineFrom));
+                            }
+                        }
+                        if (doDownscaling) {
+                            downscaleLine(pixels, cache1, downscaleKernel, reduceBy, pixel0, unscaled0, length, pointInc, newLength);
+                            convolveLine(cache1, cache2, gaussKernel, 0, newLength, 1, newLength-1, 0, 1);
+                            upscaleLine(cache2, pixels, upscaleKernel, reduceBy, pixel0, unscaled0, writeFrom, writeTo, pointInc);
+                        } else {
+                            int p = pixel0 + readFrom*pointInc;
+                            for (int i=readFrom; i<readTo; i++ ,p+=pointInc)
+                                cache1[i] = pixels[p];
+                            convolveLine(cache1, pixels, gaussKernel, readFrom, readTo, writeFrom, writeTo, pixel0, pointInc);
+                        }
+                            
+                    }
+                    return null;
+                } /*catch(Exception ex) {IJ.handleException(ex);} }*/
+            };
+        }
+        ThreadUtil.startAndJoin(callables);
+            
+        showProgress(1.0);
+        pass++;
+        if (pass > nPasses) pass = 1;
+    }
+
+    /** Scale a line (row or column of a FloatProcessor or part thereof)
+     * down by a factor <code>reduceBy</code> and write the result into
+     * <code>cache</code>.
+     * Input line pixel # <code>unscaled0</code> will correspond to output
+     * line pixel # 0. <code>unscaled0</code> may be negative. Out-of-line
+     * pixels of the input are replaced by the edge pixels.
+     * @param pixels    input array
+     * @param cache     output array
+     * @param kernel    downscale kernel, runs form -1.5 to +1.5 in downscaled coordinates
+     * @param reduceBy  downscaling factor
+     * @param pixel0    index in pixels array corresponding to start of line or column
+     * @param unscaled0 index in input line corresponding to output line index 0, May be negative.
+     * @param length    length of full input line or column
+     * @param pointInc  spacing of values in input array (1 for lines, image width for columns)
+     * @param newLength length of downscaled data
+     */
+    final static private void downscaleLine(final float[] pixels, final float[] cache, final float[] kernel,
+            final int reduceBy, final int pixel0, final int unscaled0, final int length, final int pointInc, final int newLength) {
+        int p = pixel0 + pointInc*(unscaled0-reduceBy*3/2);  //pointer in pixels array
+        final int pLast = pixel0 + pointInc*(length-1);
+        for (int xout=-1; xout<=newLength; xout++) {
+            float sum0 = 0, sum1 = 0, sum2 = 0;
+            for (int x=0; x<reduceBy; x++, p+=pointInc) {
+                float v = pixels[p<pixel0 ? pixel0 : (p>pLast ? pLast : p)];
+                sum0 += v * kernel[x+2*reduceBy];
+                sum1 += v * kernel[x+reduceBy];
+                sum2 += v * kernel[x];
+            }
+            if (xout>0) cache[xout-1] += sum0;
+            if (xout>=0 && xout<newLength) cache[xout] += sum1;
+            if (xout+1<newLength) cache[xout+1] = sum2;
+        }
+    }
+    /** the above code is equivalent to the following one; but the above code is faster
+     *  - above: accesses each pixel in the pixels array only once
+     *  - below: accesses each pixel in the pixels array 3 times, more cache misses */
+    /*final static private void downscaleLine(final float[] pixels, final float[] cache, final float[] kernel,
+            final int reduceBy, final int pixel0, final int unscaled0, final int length, final int pointInc, final int newLength) {
+        final int xin = unscaled0 - reduceBy/2;
+        int p = pixel0 + pointInc*xin;
+        final int pLast = pixel0 + pointInc*(length-1);
+        for (int xout=0; xout<newLength; xout++) {
+            float v = 0;
+            for (int x=0; x<reduceBy; x++, p+=pointInc) {
+                int pp = p-pointInc*reduceBy;
+                v += kernel[x] * pixels[pp<pixel0 ? pixel0 : (pp>pLast ? pLast : pp)];
+                v += kernel[x+reduceBy] * pixels[p<pixel0 ? pixel0 : (p>pLast ? pLast : p)];
+                pp = p+pointInc*reduceBy;
+                v += kernel[x+2*reduceBy] * pixels[pp<pixel0 ? pixel0 : (pp>pLast ? pLast : pp)];
+            }
+            cache[xout] = v;
+        }
+    }*/
+
+    /* Create a kernel for downscaling. The kernel function preserves
+     * norm and 1st moment (i.e., position) and has fixed 2nd moment,
+     * (in contrast to linear interpolation).
+     * In scaled space, the length of the kernel runs from -1.5 to +1.5,
+     * and the standard deviation is 1/2.
+     * Array index corresponding to the kernel center is
+     * unitLength*3/2
+     */
+    final static private float[] makeDownscaleKernel (final int unitLength) {
+        final int mid = unitLength*3/2;
+        final float[] kernel = new float[3*unitLength];
+        for (int i=0; i<=unitLength/2; i++) {
+            final double x = i/(double)unitLength;
+            final float v = (float)((0.75-x*x)/unitLength);
+            kernel[mid-i] = v;
+            kernel[mid+i] = v;
+        }
+        for (int i=unitLength/2+1; i<(unitLength*3+1)/2; i++) {
+            final double x = i/(double)unitLength;
+            final float v = (float)((0.125 + 0.5*(x-1)*(x-2))/unitLength);
+            kernel[mid-i] = v;
+            kernel[mid+i] = v;
+        }
+        return kernel;
+    }
+
+    /** Scale a line up by factor <code>reduceBy</code> and write as a row
+     * or column (or part thereof) to the pixels array of a FloatProcessor.
+     */
+    final static private void upscaleLine (final float[] cache, final float[] pixels, final float[] kernel,
+            final int reduceBy, final int pixel0, final int unscaled0, final int writeFrom, final int writeTo, final int pointInc) {
+        int p = pixel0 + pointInc*writeFrom;
+        for (int xout = writeFrom; xout < writeTo; xout++, p+=pointInc) {
+            final int xin = (xout-unscaled0+reduceBy-1)/reduceBy; //the corresponding point in the cache (if exact) or the one above
+            final int x = reduceBy - 1 - (xout-unscaled0+reduceBy-1)%reduceBy;
+            pixels[p] = cache[xin-2]*kernel[x]
+                    + cache[xin-1]*kernel[x+reduceBy]
+                    + cache[xin]*kernel[x+2*reduceBy]
+                    + cache[xin+1]*kernel[x+3*reduceBy];
+        }
+    }
+
+    /** Create a kernel for upscaling. The kernel function is a convolution
+     *  of four unit squares, i.e., four uniform kernels with value +1
+     *  from -0.5 to +0.5 (in downscaled coordinates). The second derivative
+     *  of this kernel is smooth, the third is not. Its standard deviation
+     *  is 1/sqrt(3) in downscaled cordinates.
+     *  The kernel runs from [-2 to +2[, corresponding to array index
+     *  0 ... 4*unitLength (whereby the last point is not in the array any more).
+     */
+    final static private float[] makeUpscaleKernel (final int unitLength) {
+        final float[] kernel = new float[4*unitLength];
+        final int mid = 2*unitLength;
+        kernel[0] = 0;
+        for (int i=0; i<unitLength; i++) {
+            final double x = i/(double)unitLength;
+            final float v = (float)((2./3. -x*x*(1-0.5*x)));
+            kernel[mid+i] = v;
+            kernel[mid-i] = v;
+        }
+        for (int i=unitLength; i<2*unitLength; i++) {
+            final double x = i/(double)unitLength;
+            final float v = (float)((2.-x)*(2.-x)*(2.-x)/6.);
+            kernel[mid+i] = v;
+            kernel[mid-i] = v;
+        }
+        return kernel;
+    }
+
+    /** Convolve a line with a symmetric kernel and write to a separate array,
+     * possibly the pixels array of a FloatProcessor (as a row or column or part thereof)
+     *
+     * @param input     Input array containing the line
+     * @param pixels    Float array for output, can be the pixels of a FloatProcessor
+     * @param kernel    "One-sided" kernel array, kernel[0][n] must contain the kernel
+     *                  itself, kernel[1][n] must contain the running sum over all
+     *                  kernel elements from kernel[0][n+1] to the periphery.
+     *                  The kernel must be normalized, i.e. sum(kernel[0][n]) = 1
+     *                  where n runs from the kernel periphery (last element) to 0 and
+     *                  back. Normalization should include all kernel points, also these
+     *                  not calculated because they are not needed.
+     * @param readFrom  First array element of the line that must be read.
+     *                  <code>writeFrom-kernel.length</code> or 0.
+     * @param readTo    Last array element+1 of the line that must be read.
+     *                  <code>writeTo+kernel.length</code> or <code>input.length</code>
+     * @param writeFrom Index of the first point in the line that should be written
+     * @param writeTo   Index+1 of the last point in the line that should be written
+     * @param point0    Array index of first element of the 'line' in pixels (i.e., lineNumber * lineInc)
+     * @param pointInc  Increment of the pixels array index to the next point (for an ImageProcessor,
+     *                  it should be <code>1</code> for a row, <code>width</code> for a column)
+     */
+    final static private void convolveLine( final float[] input, final float[] pixels, final float[][] kernel, final int readFrom,
+            final int readTo, final int writeFrom, final int writeTo, final int point0, final int pointInc) {
+        final int length = input.length;
+        final float first = input[0];                 //out-of-edge pixels are replaced by nearest edge pixels
+        final float last = input[length-1];
+        final float[] kern = kernel[0];               //the kernel itself
+        final float kern0 = kern[0];
+        final float[] kernSum = kernel[1];            //the running sum over the kernel
+        final int kRadius = kern.length;
+        final int firstPart = kRadius < length ? kRadius : length;
+        int p = point0 + writeFrom*pointInc;
+        int i = writeFrom;
+        for (; i<firstPart; i++,p+=pointInc) {  //while the sum would include pixels < 0
+            float result = input[i]*kern0;
+            result += kernSum[i]*first;
+            if (i+kRadius>length) result += kernSum[length-i-1]*last;
+            for (int k=1; k<kRadius; k++) {
+                float v = 0;
+                if (i-k >= 0) v += input[i-k];
+                if (i+k<length) v+= input[i+k];
+                result += kern[k] * v;
+            }
+            pixels[p] = result;
+        }
+        final int iEndInside = length-kRadius<writeTo ? length-kRadius : writeTo;
+        for (;i<iEndInside;i++,p+=pointInc) {   //while only pixels within the line are be addressed (the easy case)
+            float result = input[i]*kern0;
+            for (int k=1; k<kRadius; k++)
+                result += kern[k] * (input[i-k] + input[i+k]);
+            pixels[p] = result;
+        }
+        for (; i<writeTo; i++,p+=pointInc) {    //while the sum would include pixels >= length 
+            float result = input[i]*kern0;
+            if (i<kRadius) result += kernSum[i]*first;
+            if (i+kRadius>=length) result += kernSum[length-i-1]*last;
+            for (int k=1; k<kRadius; k++) {
+                float v = 0;
+                if (i-k >= 0) v += input[i-k];
+                if (i+k<length) v+= input[i+k];
+                result += kern[k] * v;
+            }
+            pixels[p] = result;
+        }
+    }
+
+    /** Create a 1-dimensional normalized Gaussian kernel with standard deviation sigma
+     *  and the running sum over the kernel
+     *  Note: this is one side of the kernel only, not the full kernel as used by the
+     *  Convolver class of ImageJ.
+     *  To avoid a step due to the cutoff at a finite value, the near-edge values are
+     *  replaced by a 2nd-order polynomial with its minimum=0 at the first out-of-kernel
+     *  pixel. Thus, the kernel function has a smooth 1st derivative in spite of finite
+     *  length.
+     *
+     * @param sigma     Standard deviation, i.e. radius of decay to 1/sqrt(e), in pixels.
+     * @param accuracy  Relative accuracy; for best results below 0.01 when processing
+     *                  8-bit images. For short or float images, values of 1e-3 to 1e-4
+     *                  are better (but increase the kernel size and thereby the
+     *                  processing time). Edge smoothing will fail with very poor
+     *                  accuracy (above approx. 0.02)
+     * @param maxRadius Maximum radius of the kernel: Limits kernel size in case of
+     *                  large sigma, should be set to image width or height. For small
+     *                  values of maxRadius, the kernel returned may have a larger
+     *                  radius, however.
+     * @return          A 2*n array. Array[0][n] is the kernel, decaying towards zero,
+     *                  which would be reached at kernel.length (unless kernel size is
+     *                  limited by maxRadius). Array[1][n] holds the sum over all kernel
+     *                  values > n, including non-calculated values in case the kernel
+     *                  size is limited by <code>maxRadius</code>.
+     */
+    public float[][] makeGaussianKernel(final double sigma, final double accuracy, int maxRadius) {
+        int kRadius = (int)Math.ceil(sigma*Math.sqrt(-2*Math.log(accuracy)))+1;
+        if (maxRadius < 50) maxRadius = 50;         // too small maxRadius would result in inaccurate sum.
+        if (kRadius > maxRadius) kRadius = maxRadius;
+        float[][] kernel = new float[2][kRadius];
+        for (int i=0; i<kRadius; i++)               // Gaussian function
+            kernel[0][i] = (float)(Math.exp(-0.5*i*i/sigma/sigma));
+        if (kRadius < maxRadius && kRadius > 3) {   // edge correction
+            double sqrtSlope = Double.MAX_VALUE;
+            int r = kRadius;
+            while (r > kRadius/2) {
+                r--;
+                double a = Math.sqrt(kernel[0][r])/(kRadius-r);
+                if (a < sqrtSlope)
+                    sqrtSlope = a;
+                else
+                    break;
+            }
+            for (int r1 = r+2; r1 < kRadius; r1++)
+                kernel[0][r1] = (float)((kRadius-r1)*(kRadius-r1)*sqrtSlope*sqrtSlope);
+        }
+        double sum;                                 // sum over all kernel elements for normalization
+        if (kRadius < maxRadius) {
+            sum = kernel[0][0];
+            for (int i=1; i<kRadius; i++)
+                sum += 2*kernel[0][i];
+        } else
+            sum = sigma * Math.sqrt(2*Math.PI);
+        
+        double rsum = 0.5 + 0.5*kernel[0][0]/sum;
+        for (int i=0; i<kRadius; i++) {
+            double v = (kernel[0][i]/sum);
+            kernel[0][i] = (float)v;
+            rsum -= v;
+            kernel[1][i] = (float)rsum;
+            //IJ.log("k["+i+"]="+(float)v+" sum="+(float)rsum);
+        }
+        return kernel;
+    }
+
+	/** Set the processed pixels above and below the roi rectangle back to their
+	* previous value (i.e., snapshot buffer). This is necessary since ImageJ
+	* only restores out-of-roi pixels inside the enclosing rectangle of the roi
+	* (If the roi is non-rectangular and the SUPPORTS_MASKING flag is set).
+	* @param ip The image to be processed
+	* @param radius The range above and below the roi that should be processed
+	*/    
+	public static void resetOutOfRoi(ImageProcessor ip, int radius) {
+		Rectangle roi = ip.getRoi();
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		Object pixels = ip.getPixels();
+		Object snapshot = ip.getSnapshotPixels();
+		int y0 = roi.y-radius;    // the first line that should be reset
+		if (y0<0) y0 = 0;
+		for (int y=y0,p=width*y+roi.x; y<roi.y; y++,p+=width)
+			System.arraycopy(snapshot, p, pixels, p, roi.width);
+		int yEnd = roi.y+roi.height+radius; // the last line + 1 that should be reset
+		if (yEnd>height) yEnd = height;
+		for (int y=roi.y+roi.height,p=width*y+roi.x; y<yEnd; y++,p+=width)
+			System.arraycopy(snapshot, p, pixels, p, roi.width);
+	}
+    
+    private void showProgress(double percent) {
+    	if (noProgress) return;
+        percent = (pass + percent)/nPasses;
+        IJ.showProgress(percent);
+    }
+    
+    public void showProgress(boolean showProgressBar) {
+    	noProgress = !showProgressBar;
+    }
+    
+}
diff --git a/src/ij/plugin/filter/ImageMath.java b/src/ij/plugin/filter/ImageMath.java
new file mode 100644
index 0000000..92a8ab8
--- /dev/null
+++ b/src/ij/plugin/filter/ImageMath.java
@@ -0,0 +1,521 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.macro.*;
+import java.awt.*;
+
+/** This plugin implements ImageJ's Process/Math submenu. */
+public class ImageMath implements ExtendedPlugInFilter, DialogListener {
+	
+	public static final String MACRO_KEY = "math.macro";
+	private int flags = DOES_ALL|SUPPORTS_MASKING|KEEP_PREVIEW|PARALLELIZE_STACKS;
+	private String arg;
+	private ImagePlus imp;
+	private boolean canceled;	
+	private double lower=-1.0, upper=-1.0;
+	private String macro2;
+	private PlugInFilterRunner pfr;
+	private GenericDialog gd;
+	
+	private static double defaultAddValue = 25;
+	private static double defaultMulValue = 1.25;
+	private static double defaultMinValue = 0;
+	private static double defaultMaxValue = 255;
+	private static String defaultAndValue = "11110000";
+	private static double defaultGammaValue = 0.5;
+	private static String defaultMacro = Prefs.get(MACRO_KEY, "v=v+50*sin(d/10)");
+	
+	private static double lastAddValue = defaultAddValue;
+	private static double lastMulValue = defaultMulValue;
+	private static double lastMinValue = defaultMinValue;
+	private static double lastMaxValue = defaultMaxValue;
+	private static String lastAndValue = defaultAndValue;
+	private static double lastGammaValue = defaultGammaValue;
+	private static String lastMacro = defaultMacro;
+
+	private double addValue = defaultAddValue;
+	private double mulValue = defaultMulValue;
+	private double minValue = defaultMinValue;
+	private double maxValue = defaultMaxValue;
+	private String andValue = defaultAndValue;
+	private double gammaValue = defaultGammaValue;
+	private String macro = defaultMacro;
+	
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		IJ.register(ImageMath.class);
+		return flags;
+	}
+
+	public void run(ImageProcessor ip) {
+	 	if (canceled)
+	 		return;
+	 	if (arg.equals("add")) {
+			ip.add(addValue);
+		} else if (arg.equals("sub")) {
+			ip.subtract(addValue);
+		} else if (arg.equals("mul")) {
+			ip.multiply(mulValue);
+		} else if (arg.equals("div")) {
+	 		if (mulValue==0.0&&imp.getBitDepth()!=32)
+	 			return;
+	 		else
+				ip.multiply(1.0/mulValue);
+		} else if (arg.equals("and")) {
+	 		try {
+				ip.and(Integer.parseInt(andValue,2));
+			} catch (NumberFormatException e) {
+				andValue = defaultAndValue;
+				IJ.error("Binary number required");
+			}
+		} else if (arg.equals("or")) {
+	 		try {
+				ip.or(Integer.parseInt(andValue,2));
+			} catch (NumberFormatException e) {
+				andValue = defaultAndValue;
+				IJ.error("Binary number required");
+			}
+		} else if (arg.equals("xor")) {
+	 		try {
+				ip.xor(Integer.parseInt(andValue,2));
+			} catch (NumberFormatException e) {
+				andValue = defaultAndValue;
+				IJ.error("Binary number required");
+			}
+		} else if (arg.equals("min")) {
+	 		ip.min(minValue);
+			if (!(ip instanceof ByteProcessor))
+				ip.resetMinAndMax();
+		} else if (arg.equals("max")) {
+	 		ip.max(maxValue);
+			if (!(ip instanceof ByteProcessor))
+				ip.resetMinAndMax();
+		} else if (arg.equals("gamma")) {
+	 		if (gammaValue<0.05 || gammaValue>5.0) {
+		 		if (!previewing() && !canceled) {
+	 				canceled = true;
+	 				IJ.error("Gamma must be between 0.05 and 5.0");
+	 			}
+	 			gammaValue = defaultGammaValue;
+	 		} else
+				ip.gamma(gammaValue);
+ 		} else if (arg.equals("set")) {
+			ip.set(addValue);
+		} else if (arg.equals("log")) {
+			ip.log();
+		} else if (arg.equals("exp")) {
+			ip.exp();
+		} else if (arg.equals("sqr")) {
+			ip.sqr();
+		} else if (arg.equals("sqrt")) {
+			ip.sqrt();
+		} else if (arg.equals("reciprocal")) {
+			if (!isFloat(ip))
+				return;
+			float[] pixels = (float[])ip.getPixels();
+			for (int i=0; i<ip.getWidth()*ip.getHeight(); i++) {
+				if (pixels[i]==0f)
+					pixels[i] = Float.NaN;
+				else
+					pixels[i] = 1f/pixels[i];
+			}
+			ip.resetMinAndMax();
+		} else if (arg.equals("nan")) {
+	 		setBackgroundToNaN(ip);
+		} else if (arg.equals("abs")) {
+			if (!((ip instanceof FloatProcessor)||imp.getCalibration().isSigned16Bit())) {
+				IJ.error("32-bit or signed 16-bit image required");
+				canceled = true;
+			} else {
+				ip.abs();
+				ip.resetMinAndMax();
+			}
+		} else if (arg.equals("macro")) {
+			applyMacro(ip);
+		}
+
+	}
+	
+	boolean previewing() {
+		return gd!=null && gd.isPreviewActive();
+	}
+ 
+ 	boolean isFloat(ImageProcessor ip) {
+		if (!(ip instanceof FloatProcessor)) {
+			IJ.error("32-bit float image required");
+			canceled = true;
+			return false;
+		} else
+			return true;
+	}
+	
+	void getValue (String title, String prompt, double defaultValue, int digits) {
+		int places = Analyzer.getPrecision();
+		if (digits>0 || (int)defaultValue!=defaultValue)
+			digits = Math.max(places, 1);
+		gd = GUI.newNonBlockingDialog(title, imp);
+		gd.addNumericField(prompt, defaultValue, digits, 8, null);
+		gd.addPreviewCheckbox(pfr);
+		gd.addDialogListener(this);
+		gd.showDialog();
+	}
+
+	void getBinaryValue (String title, String prompt, String defaultValue) {
+		gd = GUI.newNonBlockingDialog(title, imp);
+		gd.addStringField(prompt, defaultValue);
+		gd.addPreviewCheckbox(pfr);
+		gd.addDialogListener(this);
+		gd.showDialog();
+	}
+
+	void getGammaValue (double defaultValue) {
+		gd = GUI.newNonBlockingDialog("Gamma", imp);
+		if (GraphicsEnvironment.isHeadless())
+			gd.addNumericField("Value:", defaultValue, 2);
+		else
+			gd.addSlider("Value:", 0.0, 5.0, defaultValue, 0.02);
+		gd.addPreviewCheckbox(pfr);
+		gd.addDialogListener(this);
+		gd.showDialog();
+	}
+
+	/** Set non-thresholded pixels in a float image to NaN. */
+	void setBackgroundToNaN(ImageProcessor ip) {
+		if (lower==-1.0 && upper==-1.0) {
+			lower = ip.getMinThreshold();
+			upper = ip.getMaxThreshold();
+			if (lower==ImageProcessor.NO_THRESHOLD || !(ip instanceof FloatProcessor)) {
+				String title = imp!=null?"\n\""+imp.getTitle()+"\"":"";
+				IJ.error("NaN Backround", "Thresholded 32-bit float image required:"+title);
+				canceled = true;
+				return;
+			}
+		}
+		if (!(ip instanceof FloatProcessor))
+			return;
+        float[] pixels = (float[])ip.getPixels();
+        int width = ip.getWidth();
+        int height = ip.getHeight();
+        double v;
+        for (int y=0; y<height; y++) {
+            for (int x=0; x<width; x++) {
+                  v = pixels[y*width+x];
+                  if (v<lower || v>upper)
+                      pixels[y*width+x] = Float.NaN;
+            }
+        }
+		ip.resetMinAndMax();
+		return;
+	}
+	
+	// first default: v = v+(sin(x/(w/25))+sin(y/(h/25)))*40
+	// a=round(a/10); if (a%2==0) v=0;
+	// cone: v=d
+	// translate: v=getPixel(x+10,y+10)
+	// flip vertically: v=getPixel(x,h-y-1)
+	// spiral: v=(sin(d/10+a*PI/180)+1)*128
+	// spiral on image: v=v+50*sin(a*PI/180+d/5)
+	// spiral rotation: a+=PI+d*PI/360; v=getPixel(d*cos(a)+w/2,d*sin(a)+h/2);
+	// v=sin(log(d)*8 + a) * sin(a*8)
+	// v=(a * 40.74 + d) % 32
+	// v=floor((a * 40.75 + 1) % 2)
+	// v=sin(x) * sin(y)
+	// v=cos(0.2*x) + sin(0.2*y)
+
+	private void applyMacro(ImageProcessor ip) {
+		if (macro2==null) return;
+		macro = macro2;
+		ip.setSliceNumber(pfr.getSliceNumber());	
+		boolean showProgress = pfr.getSliceNumber()==1 && !Interpreter.isBatchMode();
+		applyMacro(ip, macro, showProgress);
+		if (pfr.getSliceNumber()==1)
+			ip.resetMinAndMax();
+	}
+
+	public static void applyMacro(ImageProcessor ip, String macro, boolean showProgress) {
+		if (!macro.contains("="))
+			macro = "v="+macro;
+		ImagePlus temp = WindowManager.getTempCurrentImage();
+		WindowManager.setTempCurrentImage(new ImagePlus("",ip));
+		int PCStart = 23;
+		Program pgm = (new Tokenizer()).tokenize(macro);
+		boolean hasX = pgm.hasWord("x");
+		boolean hasA = pgm.hasWord("a");
+		boolean hasD = pgm.hasWord("d");
+		boolean hasGetPixel = pgm.hasWord("getPixel");
+		int w = ip.getWidth();
+		int h = ip.getHeight();
+		int w2 = w/2;
+		int h2 = h/2;
+		String code =
+			"var v,x,y,z,w,h,d,a;\n"+
+			"function dummy() {}\n"+
+			macro+";\n"; // code starts at program counter location 'PCStart'
+		Interpreter interp = new Interpreter();
+		interp.run(code, null);
+		if (interp.wasError()) {
+			WindowManager.setTempCurrentImage(temp);
+			return;
+		}
+		Prefs.set(MACRO_KEY, macro);
+		interp.setVariable("w", w);
+		interp.setVariable("h", h);
+		interp.setVariable("z", ip.getSliceNumber()-1);
+		int bitDepth = ip.getBitDepth();
+		Rectangle r = ip.getRoi();
+		int inc = r.height/50;
+		if (inc<1) inc = 1;
+		double v;
+		int index, v2;
+		if (bitDepth==8) {
+			byte[] pixels1 = (byte[])ip.getPixels();
+			byte[] pixels2 = pixels1;
+			if (hasGetPixel)
+				pixels2 = new byte[w*h];
+			for (int y=r.y; y<(r.y+r.height); y++) {
+				if (showProgress && y%inc==0)
+					IJ.showProgress(y-r.y, r.height);
+				interp.setVariable("y", y);
+				for (int x=r.x; x<(r.x+r.width); x++) {
+					index = y*w+x;
+					v = pixels1[index]&255;
+					interp.setVariable("v", v);
+					if (hasX) interp.setVariable("x", x);
+					if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
+					if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
+					interp.run(PCStart);
+					v2 = (int)interp.getVariable("v");
+					if (v2<0) v2 = 0;
+					if (v2>255) v2 = 255;
+					pixels2[index] = (byte)v2;
+				}
+			}
+			if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
+		} else if (bitDepth==24) {
+			int rgb, red, green, blue;
+			int[] pixels1 = (int[])ip.getPixels();
+			int[] pixels2 = pixels1;
+			if (hasGetPixel)
+				pixels2 = new int[w*h];
+			for (int y=r.y; y<(r.y+r.height); y++) {
+				if (showProgress && y%inc==0)
+					IJ.showProgress(y-r.y, r.height);
+				interp.setVariable("y", y);
+				for (int x=r.x; x<(r.x+r.width); x++) {
+					if (hasX) interp.setVariable("x", x);
+					if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
+					if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
+					index = y*w+x;
+					rgb = pixels1[index];
+					if (hasGetPixel) {
+						interp.setVariable("v", rgb);
+						interp.run(PCStart);
+						rgb = (int)interp.getVariable("v");
+					} else {
+						red = (rgb&0xff0000)>>16;
+						green = (rgb&0xff00)>>8;
+						blue = rgb&0xff;
+						interp.setVariable("v", red);
+						interp.run(PCStart);
+						red = (int)interp.getVariable("v");
+						if (red<0) red=0; if (red>255) red=255;
+						interp.setVariable("v", green);
+						interp.run(PCStart);
+						green= (int)interp.getVariable("v");
+						if (green<0) green=0; if (green>255) green=255;
+						interp.setVariable("v", blue);
+						interp.run(PCStart);
+						blue = (int)interp.getVariable("v");
+						if (blue<0) blue=0; if (blue>255) blue=255;
+						rgb = 0xff000000 | ((red&0xff)<<16) | ((green&0xff)<<8) | blue&0xff;
+					}
+					pixels2[index] = rgb;
+				}
+			}
+			if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
+		} else if (ip.isSigned16Bit()) {
+			for (int y=r.y; y<(r.y+r.height); y++) {
+				if (showProgress && y%inc==0)
+					IJ.showProgress(y-r.y, r.height);
+				interp.setVariable("y", y);
+				for (int x=r.x; x<(r.x+r.width); x++) {
+					v = ip.getPixelValue(x, y);
+					interp.setVariable("v", v);
+					if (hasX) interp.setVariable("x", x);
+					if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
+					if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
+					interp.run(PCStart);
+					ip.putPixelValue(x, y, interp.getVariable("v"));
+				}
+			}
+		} else if (bitDepth==16) {
+			short[] pixels1 = (short[])ip.getPixels();
+			short[] pixels2 = pixels1;
+			if (hasGetPixel)
+				pixels2 = new short[w*h];
+			for (int y=r.y; y<(r.y+r.height); y++) {
+				if (showProgress && y%inc==0)
+					IJ.showProgress(y-r.y, r.height);
+				interp.setVariable("y", y);
+				for (int x=r.x; x<(r.x+r.width); x++) {
+					index = y*w+x;
+					v = pixels1[index]&65535;
+					interp.setVariable("v", v);
+					if (hasX) interp.setVariable("x", x);
+					if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
+					if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
+					interp.run(PCStart);
+					v2 = (int)interp.getVariable("v");
+					if (v2<0) v2 = 0;
+					if (v2>65535) v2 = 65535;
+					pixels2[index] = (short)v2;
+				}
+			}
+			if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
+		} else {  //32-bit
+			float[] pixels1 = (float[])ip.getPixels();
+			float[] pixels2 = pixels1;
+			if (hasGetPixel)
+				pixels2 = new float[w*h];
+			for (int y=r.y; y<(r.y+r.height); y++) {
+				if (showProgress && y%inc==0)
+					IJ.showProgress(y-r.y, r.height);
+				interp.setVariable("y", y);
+				for (int x=r.x; x<(r.x+r.width); x++) {
+					index = y*w+x;
+					v = pixels1[index];
+					interp.setVariable("v", v);
+					if (hasX) interp.setVariable("x", x);
+					if (hasA) interp.setVariable("a", getA((h-y-1)-h2, x-w2));
+					if (hasD) interp.setVariable("d", getD(x-w2,y-h2));
+					interp.run(PCStart);
+					pixels2[index] = (float)interp.getVariable("v");
+				}
+			}
+			if (hasGetPixel) System.arraycopy(pixels2, 0, pixels1, 0, w*h);
+		}
+		if (showProgress)
+			IJ.showProgress(1.0);
+		WindowManager.setTempCurrentImage(temp);
+	}
+	
+	private static final double getD(int dx, int dy) {
+          return Math.sqrt(dx*dx + dy*dy);
+	}
+	
+	private static final double getA(int y, int x) {
+		double angle = Math.atan2(y, x);
+		if (angle<0) angle += 2*Math.PI;
+		return angle;
+	}
+
+	void getMacro(String macro) {
+		String options = Macro.getOptions();
+		if (options!=null && options.startsWith("v="))
+			Macro.setOptions("code="+options);
+		gd = GUI.newNonBlockingDialog("Expression Evaluator", imp);
+		gd.addStringField("Code:", macro, 42);
+		gd.setInsets(0,40,0);
+		gd.addMessage("v=pixel value, x,y&z=pixel coordinates, w=image width,\nh=image height, a=angle, d=distance from center\n");
+		gd.setInsets(5,40,0);
+		gd.addPreviewCheckbox(pfr);
+		gd.addDialogListener(this);
+		gd.addHelp(IJ.URL+"/docs/menus/process.html#math-macro");
+		gd.showDialog();
+	}
+
+    public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+		this.pfr = pfr;
+		boolean interactive = Macro.getOptions()==null;
+		if (interactive) {
+			addValue = lastAddValue;
+			mulValue = lastMulValue;
+			minValue = lastMinValue;
+			maxValue = lastMaxValue;
+			andValue = lastAndValue;
+			gammaValue = lastGammaValue;
+			macro = lastMacro;
+		}
+	 	if (arg.equals("macro"))
+			getMacro(macro);
+    	else if (arg.equals("add"))
+	 		getValue("Add", "Value: ", addValue, 0);
+	 	else if (arg.equals("sub"))
+	 		getValue("Subtract", "Value: ", addValue, 0);
+	 	else if (arg.equals("mul"))
+	 		getValue("Multiply", "Value: ", mulValue, 2);
+	 	else if (arg.equals("div"))
+	 		getValue("Divide", "Value: ", mulValue, 2);
+	 	else if (arg.equals("and"))
+	 		getBinaryValue("AND", "Value (binary): ", andValue);
+	 	else if (arg.equals("or"))
+	 		getBinaryValue("OR", "Value (binary): ", andValue);
+	 	else if (arg.equals("xor"))
+	 		getBinaryValue("XOR", "Value (binary): ", andValue);
+	 	else if (arg.equals("min"))
+	 		getValue("Min", "Value: ", minValue, 0);
+	 	else if (arg.equals("max"))
+	 		getValue("Max", "Value: ", maxValue, 0);
+	 	else if (arg.equals("gamma"))
+	 		getGammaValue(gammaValue);
+	 	else if (arg.equals("set")) {
+	 		boolean rgb = imp.getBitDepth()==24;
+	 		String prompt = rgb?"Value (0-255): ":"Value: ";
+	 		getValue("Set", prompt, addValue, 0);
+		}
+		if (gd!=null && gd.wasCanceled())
+			return DONE;
+		else {
+			if (interactive) {
+				lastAddValue = addValue;
+				lastMulValue = mulValue;
+				lastMinValue = minValue;
+				lastMaxValue = maxValue;
+				lastAndValue = andValue;
+				lastGammaValue = gammaValue;
+				lastMacro = macro2;
+			}
+			return IJ.setupDialog(imp, flags);
+		}
+   }
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+	 	if (arg.equals("macro")) {
+	 		String str = gd.getNextString();
+			if (previewing() && macro2!=null && !str.equals(macro2))
+				gd.getPreviewCheckbox().setState(false);
+			macro2 = str;
+    	} else if (arg.equals("add")||arg.equals("sub")||arg.equals("set"))
+			addValue = gd.getNextNumber();
+	 	else if (arg.equals("mul")||arg.equals("div"))
+	 		mulValue = gd.getNextNumber();
+	 	else if (arg.equals("and")||arg.equals("or")||arg.equals("xor"))
+	 		andValue = gd.getNextString();
+	 	else if (arg.equals("min"))
+	 		minValue = gd.getNextNumber();
+	 	else if (arg.equals("max"))
+	 		maxValue = gd.getNextNumber();
+	 	else if (arg.equals("gamma")) {
+	 		gammaValue = gd.getNextNumber();
+	 		if (gammaValue<0.05 || gammaValue>5.0) {
+	 			if (previewing()) {
+	 				IJ.showStatus("Gamma must be between 0.05 and 5.0");
+	 				gammaValue = defaultGammaValue;
+	 				return false;
+	 			}
+	 		}
+	 	}
+		canceled = gd.invalidNumber();
+		if (gd.wasOKed() && canceled) {
+			IJ.error("Value is invalid.");
+			return false;
+		}
+		return true;
+	}
+
+	public void setNPasses(int nPasses) {
+	}
+
+}
diff --git a/src/ij/plugin/filter/ImageProperties.java b/src/ij/plugin/filter/ImageProperties.java
new file mode 100644
index 0000000..2703a92
--- /dev/null
+++ b/src/ij/plugin/filter/ImageProperties.java
@@ -0,0 +1,352 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.io.FileOpener;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import ij.measure.Calibration;
+import ij.plugin.frame.Recorder;
+
+public class ImageProperties implements PlugInFilter, TextListener {
+	private final String SAME = "-";
+	ImagePlus imp;
+	static final int NANOMETER=0, MICROMETER=1, MILLIMETER=2, CENTIMETER=3,
+		 METER=4, KILOMETER=5, INCH=6, FOOT=7, MILE=8, PIXEL=9, OTHER_UNIT=10;
+	int oldUnitIndex;
+	double oldUnitsPerCm;
+	Vector nfields, sfields;
+	boolean duplicatePixelWidth = true;
+	String calUnit;
+	double calPixelWidth, calPixelHeight, calPixelDepth;
+	TextField pixelWidthField, pixelHeightField, pixelDepthField;
+	int textChangedCount;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		showDialog(imp);
+	}
+	
+	void showDialog(ImagePlus imp) {
+		String options = Macro.getOptions();
+		boolean legacyMacro = false;
+		if (options!=null ) {
+			String options2 = options.replaceAll(" depth=", " slices=");
+			options2 = options2.replaceAll(" interval=", " frame=");
+			Macro.setOptions(options2);
+			if (options.contains("unit="))
+				legacyMacro = true;
+		}
+		Calibration cal = imp.getCalibration();
+		Calibration calOrig = cal.copy();
+		oldUnitIndex = getUnitIndex(cal.getUnit());
+		oldUnitsPerCm = getUnitsPerCm(oldUnitIndex);
+		int stackSize = imp.getImageStackSize();
+		int channels = imp.getNChannels();
+		int slices = imp.getNSlices();
+		int frames = imp.getNFrames();
+		boolean global1 = imp.getGlobalCalibration()!=null;
+		boolean global2;
+		int digits = cal.pixelWidth<1.0||cal.pixelHeight<1.0||cal.pixelDepth<1.0?7:4;
+		String xunit = cal.getXUnit();
+		String yunit = cal.getYUnit();
+		String zunit = cal.getZUnit();
+		GenericDialog gd = new GenericDialog(imp.getTitle());
+		gd.addNumericField("Channels (c):", channels, 0);
+		gd.addNumericField("Slices (z):", slices, 0);
+		gd.addNumericField("Frames (t):", frames, 0);
+		gd.setInsets(0, 5, 0);
+		gd.addMessage("Note: c*z*t must equal "+stackSize, null, Color.darkGray);
+		gd.setInsets(15, 0, 0);
+		if (legacyMacro)
+			gd.addStringField("Unit of length:", cal.getUnit());
+		int fieldWidth = 9;
+		gd.addNumericField("Pixel_width:", cal.pixelWidth, digits, fieldWidth, null);		
+		gd.addToSameRow();
+		gd.addStringField("_", xunit, 5);				
+		gd.addNumericField("Pixel_height:", cal.pixelHeight, digits, fieldWidth, null);	
+		gd.addToSameRow();
+		gd.addStringField("_", yunit.equals(xunit)?SAME:yunit, 5);			
+		gd.addNumericField("Voxel_depth:", cal.pixelDepth, digits, fieldWidth, null);
+		gd.addToSameRow();
+		gd.addStringField("_", zunit.equals(xunit)?SAME:zunit, 5);			
+		gd.setInsets(10, 0, 5);
+		double interval = cal.frameInterval;
+		String intervalStr = IJ.d2s(interval, (int)interval==interval?0:2) + " " + cal.getTimeUnit();
+		gd.addStringField("Frame interval:", intervalStr);
+		String xo = cal.xOrigin==(int)cal.xOrigin?IJ.d2s(cal.xOrigin,0):IJ.d2s(cal.xOrigin,2);
+		String yo = cal.yOrigin==(int)cal.yOrigin?IJ.d2s(cal.yOrigin,0):IJ.d2s(cal.yOrigin,2);
+		String zo = "";
+		if (imp.getNSlices()>1) {
+			zo = cal.zOrigin==(int)cal.zOrigin?IJ.d2s(cal.zOrigin,0):IJ.d2s(cal.zOrigin,2);
+			zo = "," + zo;
+		}
+		gd.addStringField("Origin (pixels):", xo+","+yo+zo);
+		gd.setInsets(5, 20, 0);
+		gd.addCheckbox("Invert Y coordinates", cal.getInvertY());
+		gd.addCheckbox("Global", global1);
+		nfields = gd.getNumericFields();
+		if (nfields!=null) {
+			pixelWidthField  = (TextField)nfields.elementAt(3);
+			pixelHeightField  = (TextField)nfields.elementAt(4);
+			pixelDepthField  = (TextField)nfields.elementAt(5);
+			for (int i=0; i<nfields.size(); i++)
+				((TextField)nfields.elementAt(i)).addTextListener(this);
+        }
+        sfields = gd.getStringFields();
+        if (sfields!=null) {
+        	for (int i=0; i<sfields.size(); i++)
+            	((TextField)sfields.elementAt(i)).addTextListener(this);
+        }
+		calUnit = cal.getUnit();
+		calPixelWidth = cal.pixelWidth;
+		calPixelHeight = cal.pixelHeight;
+		calPixelDepth = cal.pixelDepth;
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+ 		channels = (int)gd.getNextNumber();
+ 		if (channels<1) channels = 1;
+ 		slices = (int)gd.getNextNumber();
+ 		if (slices<1) slices = 1;
+ 		frames = (int)gd.getNextNumber();
+ 		if (frames<1) frames = 1;
+ 		if (channels*slices*frames==stackSize)
+ 			imp.setDimensions(channels, slices, frames);
+ 		else
+ 			IJ.error("Properties", "The product of channels ("+channels+"), slices ("+slices
+ 				+")\n and frames ("+frames+") must equal the stack size ("+stackSize+").");
+		String unit = "";
+		if (legacyMacro)
+			unit = gd.getNextString();   
+ 		double pixelWidth = gd.getNextNumber();
+ 		String xunit2 = gd.getNextString();
+ 		double pixelHeight = gd.getNextNumber();
+ 		String yunit2 = gd.getNextString();
+ 		double pixelDepth = gd.getNextNumber();
+ 		String zunit2 = gd.getNextString();
+ 		boolean reset = false;
+ 		boolean xUnitChanged=false,yUnitChanged=false,zUnitChanged=false;
+ 		if (legacyMacro) {
+			if (!unit.equals(cal.getUnit())) {
+				cal.setYUnit(null);
+				cal.setZUnit(null);
+			}
+			cal.setUnit(unit);
+		} else {
+			xUnitChanged = !xunit2.equals(xunit);
+			if (xUnitChanged)
+				cal.setXUnit(xunit2);
+			yUnitChanged = !yunit2.equals(yunit) && !yunit2.equals(SAME);
+			if (yUnitChanged)
+				cal.setYUnit(yunit2);
+			zUnitChanged = !zunit2.equals(zunit) && !zunit2.equals(SAME);
+			if (zUnitChanged)
+				cal.setZUnit(zunit2);
+			unit = xunit2;			
+		}
+		if (unit.equals("") || unit.equalsIgnoreCase("none") || pixelWidth==0.0) {
+			// reset
+			cal.setUnit(null);
+			cal.pixelWidth = 1.0;
+			cal.pixelHeight = 1.0;
+			cal.pixelDepth = 1.0;
+		} else {
+			cal.pixelWidth = pixelWidth;
+			cal.pixelHeight = pixelHeight;
+			cal.pixelDepth = pixelDepth;
+		}
+		
+		gd.setSmartRecording(interval==0);
+		String frameInterval = validateInterval(gd.getNextString());
+		String[] intAndUnit = Tools.split(frameInterval, " -");
+		interval = Tools.parseDouble(intAndUnit[0]);
+		cal.frameInterval = Double.isNaN(interval)?0.0:interval;
+		String timeUnit = intAndUnit.length>=2?intAndUnit[1]:"sec";
+		if (timeUnit.equals("sec")&&cal.frameInterval<=2.0&&cal.frameInterval>=1.0/30.0)
+			cal.fps = 1.0/cal.frameInterval;
+		if (timeUnit.equals("usec"))
+			timeUnit = IJ.micronSymbol + "sec";
+		cal.setTimeUnit(timeUnit);
+
+		gd.setSmartRecording(cal.xOrigin==0&&cal.yOrigin==0&&cal.zOrigin==0);
+        String[] origin = Tools.split(gd.getNextString(), " ,");
+		gd.setSmartRecording(false);
+		double x = origin.length>=1?Tools.parseDouble(origin[0]):Double.NaN;
+		double y = origin.length>=2?Tools.parseDouble(origin[1]):Double.NaN;
+		double z = origin.length>=3?Tools.parseDouble(origin[2]):Double.NaN;
+		cal.xOrigin= Double.isNaN(x)?0.0:x;
+		cal.yOrigin= Double.isNaN(y)?cal.xOrigin:y;
+		cal.zOrigin= Double.isNaN(z)?0.0:z;
+ 		cal.setInvertY(gd.getNextBoolean());
+ 		global2 = gd.getNextBoolean();
+		if (!cal.equals(calOrig))
+			imp.setCalibration(cal);
+ 		imp.setGlobalCalibration(global2?cal:null);
+		if (global2 || global2!=global1)
+			WindowManager.repaintImageWindows();
+		else
+			imp.repaintWindow();
+		if (global2 && global2!=global1)
+			FileOpener.setShowConflictMessage(true);
+			
+		if (Recorder.record) {
+			if (Recorder.scriptMode()) {
+				if (xUnitChanged)
+					Recorder.recordCall("imp.getCalibration().setXUnit(\""+xunit2+"\");", true);
+				if (yUnitChanged)
+					Recorder.recordCall("imp.getCalibration().setYUnit(\""+yunit2+"\");", true);
+				if (zUnitChanged)
+					Recorder.recordCall("imp.getCalibration().setZUnit(\""+zunit2+"\");", true);
+			} else {
+				if (xUnitChanged)
+					Recorder.record("Stack.setXUnit", xunit2);
+				if (yUnitChanged)
+					Recorder.record("Stack.setYUnit", yunit2);
+				if (zUnitChanged)
+					Recorder.record("Stack.setZUnit", zunit2);
+			}
+		}
+
+	}
+	
+	String validateInterval(String interval) {
+		if (interval.indexOf(" ")!=-1)
+			return interval;
+		int firstLetter = -1;
+		for (int i=0; i<interval.length(); i++) {
+			char c = interval.charAt(i);
+			if (Character.isLetter(c)) {
+				firstLetter = i;
+				break;
+			}
+		}
+		if (firstLetter>0 && firstLetter<interval.length()-1)
+			interval = interval.substring(0,firstLetter)+" "+interval.substring(firstLetter, interval.length());
+		return interval;
+	}
+	
+	double getNewScale(String newUnit, double oldScale) {
+		//IJ.log("getNewScale: "+newUnit);
+		if (oldUnitsPerCm==0.0) return 0.0;
+		double newScale = 0.0;
+		int newUnitIndex = getUnitIndex(newUnit);
+		if (newUnitIndex!=oldUnitIndex) {
+			double newUnitsPerCm = getUnitsPerCm(newUnitIndex);
+			if (oldUnitsPerCm!=0.0 && newUnitsPerCm!=0.0) {
+				newScale = oldScale * (oldUnitsPerCm/newUnitsPerCm);
+			}
+		}
+		return newScale;
+	}
+	
+	static int getUnitIndex(String unit) {
+		unit = unit.toLowerCase(Locale.US);
+		if (unit.equals("cm")||unit.startsWith("cent"))
+			return CENTIMETER;
+		else if (unit.equals("mm")||unit.startsWith("milli"))
+			return MILLIMETER;
+		else if (unit.startsWith("inch"))
+			return INCH;
+		else if (unit.startsWith(""+IJ.micronSymbol)||unit.startsWith("u")||unit.startsWith("micro"))
+			return MICROMETER;
+		else if (unit.equals("nm")||unit.startsWith("nano"))
+			return NANOMETER;
+		else if (unit.equals("m") || unit.startsWith("meter"))
+			return METER;
+		else if (unit.equals("km")||unit.startsWith("kilo"))
+			return KILOMETER;
+		else if (unit.equals("ft")||unit.equals("foot")||unit.equals("feet"))
+			return FOOT;
+		else if (unit.equals("mi")||unit.startsWith("mile"))
+			return MILE;
+		else
+			return OTHER_UNIT;
+	}
+	
+	static double getUnitsPerCm(int unitIndex) {
+		switch (unitIndex) {
+			case NANOMETER: return  10000000.0;
+			case MICROMETER: return    10000.0;
+			case MILLIMETER: return       10.0;
+			case CENTIMETER: return        1.0;
+			case METER: return             0.01;
+			case KILOMETER: return         0.00001;
+			case INCH: return              0.3937;
+			case FOOT: return              0.0328083;
+			case MILE: return              0.000006213;
+			default: return                0.0;
+		}
+	}
+
+   	public void textValueChanged(TextEvent e) {
+   		textChangedCount++;
+		Object source = e.getSource();
+        
+        int channels = (int)Tools.parseDouble(((TextField)nfields.elementAt(2)).getText(),-99);
+        int depth = (int)Tools.parseDouble(((TextField)nfields.elementAt(3)).getText(),-99);
+        int frames = (int)Tools.parseDouble(((TextField)nfields.elementAt(4)).getText(),-99);
+        
+		double newPixelWidth = calPixelWidth;
+		String newWidthText = pixelWidthField.getText();
+		if (source==pixelWidthField)
+			newPixelWidth = Tools.parseDouble(newWidthText,-99);
+		double newPixelHeight = calPixelHeight;
+		if (source==pixelHeightField) {
+			String newHeightText = pixelHeightField.getText();
+			newPixelHeight = Tools.parseDouble(newHeightText,-99);
+			if (!newHeightText.equals(newWidthText))
+				duplicatePixelWidth = false;
+		}
+		double newPixelDepth = calPixelDepth;
+		if (source==pixelDepthField) {
+			String newDepthText = pixelDepthField.getText();
+			newPixelDepth = Tools.parseDouble(newDepthText,-99);
+			if (!newDepthText.equals(newWidthText))
+				duplicatePixelWidth = false;
+		}
+		if (textChangedCount==1 && (calPixelHeight!=1.0||calPixelDepth!=1.0))
+			duplicatePixelWidth = false;
+		if (source==pixelWidthField && newPixelWidth!=-99 && duplicatePixelWidth) {
+			pixelHeightField.setText(newWidthText);
+			pixelDepthField.setText(newWidthText);
+			calPixelHeight = calPixelWidth;
+			calPixelDepth = calPixelWidth;
+		}
+		calPixelWidth = newPixelWidth;
+		calPixelHeight = newPixelHeight;
+ 		calPixelDepth = newPixelDepth;
+ 		TextField unitField = (TextField)sfields.elementAt(0);
+ 		String newUnit = unitField.getText();
+ 		if (!newUnit.equals(calUnit)) {
+			double oldXScale = newPixelWidth!=0?1.0/newPixelWidth:0;
+			double oldYScale = newPixelHeight!=0?1.0/newPixelHeight:0;
+			double oldZScale = newPixelDepth!=0?1.0/newPixelDepth:0;
+			double newXScale = getNewScale(newUnit, oldXScale);
+			double newYScale = getNewScale(newUnit, oldYScale);
+			double newZScale = getNewScale(newUnit, oldZScale);
+			if (newXScale!=0.0) {
+				double w = 1.0/newXScale;
+				double h = 1.0/newYScale;
+				double d = 1.0/newZScale;
+				int digits = w<1.0||h<1.0||d<1.0?7:4;
+				pixelWidthField.setText(IJ.d2s(1/newXScale,digits));
+				pixelHeightField.setText(IJ.d2s(1/newYScale,digits));
+				pixelDepthField.setText(IJ.d2s(1/newZScale,digits));
+				calPixelWidth = 1.0/newXScale;
+				calPixelHeight = 1.0/newYScale;
+				calPixelDepth = 1.0/newZScale;
+				oldUnitIndex = getUnitIndex(newUnit);
+				oldUnitsPerCm = getUnitsPerCm(oldUnitIndex);
+			}
+			calUnit = newUnit;
+		}
+ 	}
+
+}
diff --git a/src/ij/plugin/filter/Info.java b/src/ij/plugin/filter/Info.java
new file mode 100644
index 0000000..e7116f0
--- /dev/null
+++ b/src/ij/plugin/filter/Info.java
@@ -0,0 +1,26 @@
+package ij.plugin.filter;
+import ij.ImagePlus;
+import ij.process.ImageProcessor;
+import ij.plugin.ImageInfo;
+
+/**
+* @deprecated
+* replaced by ij.plugin.ImageInfo
+*/
+public class Info implements PlugInFilter {
+    private ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+	}
+	
+	public String getImageInfo(ImagePlus imp, ImageProcessor ip) {
+		ImageInfo info = new ImageInfo();
+		return info.getImageInfo(imp);
+	}
+
+}
diff --git a/src/ij/plugin/filter/LineGraphAnalyzer.java b/src/ij/plugin/filter/LineGraphAnalyzer.java
new file mode 100644
index 0000000..73abe30
--- /dev/null
+++ b/src/ij/plugin/filter/LineGraphAnalyzer.java
@@ -0,0 +1,72 @@
+package ij.plugin.filter;
+import java.awt.Color;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.filter.ParticleAnalyzer;
+import ij.measure.*;
+import ij.util.*;
+
+/** Implements ImageJ's Analyze/Tools/Analyze Line Graph command. */
+public class LineGraphAnalyzer implements PlugInFilter, Measurements  {
+	ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_8G+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		analyze(imp);
+	}
+	
+	/** Uses ImageJ's particle analyzer to extract a set
+		of coordinate pairs from a digitized line graph. */
+	public void analyze(ImagePlus imp) {
+		ImageProcessor ip = imp.getProcessor();
+		ImageProcessor ip2 = ip.crop();
+		int width = ip2.getWidth();
+		int height = ip2.getHeight();
+		ip2.setColor(Color.white);
+		for (int i=1; i<width; i+=2) {
+			ip2.moveTo(i,0);
+			ip2.lineTo(i,height-1);
+		}
+		ip2 = ip2.rotateRight();
+		ImagePlus imp2 = imp.createImagePlus();
+		ip2.setThreshold(ip.getMinThreshold(), ip.getMaxThreshold(), ImageProcessor.NO_LUT_UPDATE);
+		imp2.setProcessor("Temp", ip2);
+		Calibration cal = imp2.getCalibration();
+		double pw = cal.pixelWidth;
+		double ph = cal.pixelHeight;
+		cal.pixelWidth = ph;
+		cal.pixelHeight = pw;
+		imp2.setCalibration(cal);
+		if (IJ.altKeyDown())
+			imp2.show();
+		int options = ParticleAnalyzer.SHOW_PROGRESS;
+		int measurements = CENTROID;
+		int minSize = 1;
+		int maxSize = Integer.MAX_VALUE;
+		ResultsTable rt = new ResultsTable();
+		ParticleAnalyzer pa = new ParticleAnalyzer(options, measurements, rt, minSize, maxSize);
+		if (!pa.analyze(imp2))
+			return;
+		float[] y = rt.getColumn(ResultsTable.X_CENTROID);
+		if (y==null)
+			return;				
+		float[] x = rt.getColumn(ResultsTable.Y_CENTROID);
+		double[] a = Tools.getMinMax(x);
+		double xmin=a[0], xmax=a[1];
+		a = Tools.getMinMax(y);
+		double ymin=a[0], ymax=a[1];
+		
+		String units = " ("+cal.getUnits()+")";
+		String xLabel = "X"+units;
+		String yLabel = "Y"+units;
+		Plot plot = new Plot("Line Graph", xLabel, yLabel, x, y);
+		plot.setLimits(0.0, width*ph, 0.0, height*pw);				
+		plot.show();				
+	}
+	
+}
diff --git a/src/ij/plugin/filter/LutApplier.java b/src/ij/plugin/filter/LutApplier.java
new file mode 100644
index 0000000..f52fa31
--- /dev/null
+++ b/src/ij/plugin/filter/LutApplier.java
@@ -0,0 +1,130 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.util.*;
+import ij.plugin.frame.ContrastAdjuster;
+import java.awt.*;
+import java.util.*;
+
+/** This plugin implements the Image/Lookup Tables/Apply LUT command. */
+public class LutApplier implements PlugInFilter {
+	ImagePlus imp;
+	int min, max;
+	boolean canceled;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		int baseOptions = DOES_8G+DOES_8C+DOES_16+DOES_RGB;
+		return baseOptions;
+	}
+
+	public void run(ImageProcessor ip) {
+		apply(imp, ip);
+	}
+	
+	void apply(ImagePlus imp, ImageProcessor ip) {
+        if (ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+            imp.unlock();
+			IJ.runPlugIn("ij.plugin.Thresholder", "skip");
+            return;
+        }
+		min = (int)imp.getDisplayRangeMin();
+		max = (int)imp.getDisplayRangeMax();
+		int depth = imp.getBitDepth();
+		if (!IJ.isMacro() && (depth==8||depth==24) && min==0 && max==255) {
+				IJ.error("Apply LUT", "The display range must first be updated\n"
+                +"using Image>Adjust>Brightness/Contrast\n"
+                +"or threshold levels defined using\n"
+                +"Image>Adjust>Threshold.");
+				return;
+		}
+		if (imp.getType()==ImagePlus.COLOR_RGB) {
+			if (imp.getStackSize()>1)
+				applyRGBStack(imp);
+			else {
+				ip.reset();
+				Undo.setup(Undo.TRANSFORM, imp);
+				ip.setMinAndMax(min, max);
+			}
+			((ColorProcessor)ip).caSnapshot(false);
+			resetContrastAdjuster();
+			return;
+		}
+		ip.resetMinAndMax();
+		int range = 256;
+		if (depth==16) {
+			range = 65536;
+			int defaultRange = imp.getDefault16bitRange();
+			if (defaultRange>0)
+				range = (int)Math.pow(2,defaultRange)-1;
+		}
+		int tableSize = depth==16?65536:256;
+		int[] table = new int[tableSize];
+		for (int i=0; i<tableSize; i++) {
+			if (i<=min)
+				table[i] = 0;
+			else if (i>=max)
+				table[i] = range-1;
+			else
+				table[i] = (int)(((double)(i-min)/(max-min))*range);
+		}
+		ImageProcessor mask = imp.getMask();
+		if (imp.getStackSize()>1) {
+			ImageStack stack = imp.getStack();
+			int flags = IJ.setupDialog(imp, 0);
+			if (flags==PlugInFilter.DONE) {
+				ip.setMinAndMax(min, max);
+				return;
+			}
+			if (flags==PlugInFilter.DOES_STACKS) {
+				int current = imp.getCurrentSlice();
+				for (int i=1; i<=imp.getStackSize(); i++) {
+					imp.setSlice(i);
+					ip = imp.getProcessor();
+					if (mask!=null) ip.snapshot();
+					ip.applyTable(table);
+					ip.reset(mask);
+				}
+				imp.setSlice(current);
+				Undo.reset();
+			} else {
+				ip.applyTable(table);
+				ip.reset(mask);
+			}
+		} else {
+			ip.applyTable(table);
+			ip.reset(mask);
+		}
+		if (depth==16)
+			imp.setDisplayRange(0,range-1);
+		resetContrastAdjuster();
+	}
+	
+	private void resetContrastAdjuster() {
+		ContrastAdjuster.update();
+	}
+
+	void applyRGBStack(ImagePlus imp) {
+		int current = imp.getCurrentSlice();
+		int n = imp.getStackSize();
+		if (!IJ.showMessageWithCancel("Update Entire Stack?",
+		"Apply brightness and contrast settings\n"+
+		"to all "+n+" slices in the stack?\n \n"+
+		"NOTE: There is no Undo for this operation.")) {
+			canceled = true;
+			return;
+		}
+		for (int i=1; i<=n; i++) {
+			if (i!=current) {
+				imp.setSlice(i);
+				ImageProcessor ip = imp.getProcessor();
+				ip.setMinAndMax(min, max);
+				IJ.showProgress((double)i/n);
+			}
+		}
+		imp.setSlice(current);
+	}
+	
+}
diff --git a/src/ij/plugin/filter/LutViewer.java b/src/ij/plugin/filter/LutViewer.java
new file mode 100644
index 0000000..a7a8711
--- /dev/null
+++ b/src/ij/plugin/filter/LutViewer.java
@@ -0,0 +1,162 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+//import ij.text.*;
+import ij.measure.ResultsTable;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.*;
+import java.util.ArrayList;
+
+/** Displays the active image's look-up table. */
+public class LutViewer implements PlugInFilter {
+
+	ImagePlus imp;
+	
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL+NO_UNDO+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		if (ip.getNChannels()==3) {
+			IJ.error("RGB images do not have LUTs.");
+			return;
+		}
+		int xMargin = 35;
+		int yMargin = 20;
+		int width = 256;
+		int height = 128;
+		int x, y, x1, y1, x2, y2;
+		int imageWidth, imageHeight;
+		int barHeight = 12;
+		boolean isGray;
+		double scale;
+
+        ip = imp.getChannelProcessor();
+        IndexColorModel cm = (IndexColorModel)ip.getColorModel();
+        LookUpTable lut = new LookUpTable(cm);
+		int mapSize = lut.getMapSize();
+		byte[] reds = lut.getReds();
+		byte[] greens = lut.getGreens();
+		byte[] blues = lut.getBlues();
+        isGray = lut.isGrayscale();
+
+		imageWidth = width + 2*xMargin;
+		imageHeight = height + 3*yMargin;
+		Image img = IJ.getInstance().createImage(imageWidth, imageHeight);
+		Graphics g = img.getGraphics();
+		g.setColor(Color.white);
+		g.fillRect(0, 0, imageWidth, imageHeight);
+		g.setColor(Color.black);
+		g.drawRect(xMargin, yMargin, width, height);
+
+		scale = 256.0/mapSize;
+		if (isGray)
+			g.setColor(Color.black);
+		else
+			g.setColor(Color.red);
+		x1 = xMargin;
+		y1 = yMargin + height - (reds[0]&0xff)/2;
+		for (int i = 1; i<256; i++) {
+			x2 = xMargin + i;
+			y2 = yMargin + height - (reds[(int)(i/scale)]&0xff)/2;
+			g.drawLine(x1, y1, x2, y2);
+			x1 = x2;
+			y1 = y2;
+		}
+
+		if (!isGray) {
+			g.setColor(Color.green);
+			x1 = xMargin;
+			y1 = yMargin + height - (greens[0]&0xff)/2;
+			for (int i = 1; i<256; i++) {
+				x2 = xMargin + i;
+				y2 = yMargin + height - (greens[(int)(i/scale)]&0xff)/2;
+				g.drawLine(x1, y1, x2, y2);
+				x1 = x2;
+				y1 = y2;
+			}
+		}
+
+		if (!isGray) {
+			g.setColor(Color.blue);
+			x1 = xMargin;
+			y1 = yMargin + height - (blues[0]&0xff)/2;
+			for (int i = 1; i<255; i++) {
+				x2 = xMargin + i;
+				y2 = yMargin + height - (blues[(int)(i/scale)]&0xff)/2;
+				g.drawLine(x1, y1, x2, y2);
+				x1 = x2;
+				y1 = y2;
+			}
+		}
+
+		x = xMargin;
+		y = yMargin + height + 2;
+		lut.drawColorBar(g, x, y, 256, barHeight);
+		
+		y += barHeight + 15;
+		g.setColor(Color.black);
+		g.drawString("0", x - 4, y);
+		g.drawString(""+(mapSize-1), x + width - 10, y);
+		g.drawString("255", 7, yMargin + 4);
+		g.dispose();
+		
+        ImagePlus imp = new ImagePlus("Look-Up Table", img);
+        //imp.show();
+        new LutWindow(imp, new ImageCanvas(imp), ip);
+    }
+
+} // LutViewer class
+
+class LutWindow extends ImageWindow implements ActionListener {
+
+	private Button button;
+	private ImageProcessor ip;
+
+	LutWindow(ImagePlus imp, ImageCanvas ic, ImageProcessor ip) {
+		super(imp, ic);
+		this.ip = ip;
+		addPanel();
+	}
+
+	void addPanel() {
+		Panel panel = new Panel();
+		panel.setLayout(new FlowLayout(FlowLayout.RIGHT));
+		button = new Button(" List... ");
+		button.addActionListener(this);
+		panel.add(button);
+		add(panel);
+		pack();
+	}
+	
+	public void actionPerformed(ActionEvent e) {
+		Object b = e.getSource();
+		if (b==button)
+			list(ip);
+	}
+
+	void list(ImageProcessor ip) {
+		IndexColorModel icm = (IndexColorModel)ip.getColorModel();
+		int size = icm.getMapSize();
+		byte[] r = new byte[size];
+		byte[] g = new byte[size];
+		byte[] b = new byte[size];
+		icm.getReds(r); 
+		icm.getGreens(g); 
+		icm.getBlues(b);		
+		ResultsTable rt = new ResultsTable();
+		for (int i=0; i<size; i++) {
+      		rt.setValue("Index", i, i);
+      		rt.setValue("Red", i, r[i]&255);
+      		rt.setValue("Green", i, g[i]&255);
+      		rt.setValue("Blue", i, b[i]&255);
+      	}
+		rt.show("LUT");
+	}
+
+} // LutWindow class
+
+
diff --git a/src/ij/plugin/filter/MaximumFinder.java b/src/ij/plugin/filter/MaximumFinder.java
new file mode 100644
index 0000000..73cf06c
--- /dev/null
+++ b/src/ij/plugin/filter/MaximumFinder.java
@@ -0,0 +1,1388 @@
+package ij.plugin.filter;
+import ij.plugin.filter.*;
+import ij.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.process.*;
+import ij.util.Tools;
+import java.awt.*;
+import java.util.*;
+
+/** This ImageJ plug-in filter finds the maxima (or minima) of an image.
+ * It can create a mask where the local maxima of the current image are
+ * marked (255; unmarked pixels 0).
+ * The plug-in can also create watershed-segmented particles: Assume a
+ * landscape of inverted heights, i.e., maxima of the image are now water sinks.
+ * For each point in the image, the sink that the water goes to determines which
+ * particle it belongs to.
+ * When finding maxima (not minima), pixels with a level below the lower threshold
+ * can be left unprocessed.
+ *
+ * Except for segmentation, this plugin works with area ROIs, including non-rectangular ROIs,
+ * which define the area where maxima are reported.
+ * Since this plug-in creates a separate output image it processes only single images or slices, no stacks.
+ *
+ * Notes:
+ * - When using one instance of MaximumFinder for more than one image in parallel threads,
+ *   all must images have the same width and height.
+ *
+ * version 09-Nov-2006 Michael Schmid
+ * version 21-Nov-2006 Wayne Rasband. Adds "Display Point Selection" option and "Count" output type.
+ * version 28-May-2007 Michael Schmid. Preview added, bugfix: minima of calibrated images, uses Arrays.sort
+ * version 07-Aug-2007 Fixed a bug that could delete particles when doing watershed segmentation of an EDM.
+ * version 21-Apr-2007 Adapted for float instead of 16-bit EDM; correct progress bar on multiple calls
+ * version 05-May-2009 Works for images>32768 pixels in width or height
+ * version 01-Nov-2009 Bugfix: extra lines in segmented output eliminated; watershed is also faster now
+ *                     Maximum points encoded in long array for sorting instead of separete objects that need gc
+ *                     New output type 'List'
+ * version 22-May-2011 Bugfix: Maximum search in EDM and float images with large dynamic range could omit maxima
+ * version 13-Sep-2013 added the findMaxima() and findMinima() functions for arrays (Norbert Vischer)
+ * version 20-Mar-2014 Watershed segmentation of EDM with tolerance>=1.0 does not kill fine particles
+ * version 11-Mar-2019 adds "strict" option, "noise tolerance" renamed to "prominence"
+ */
+
+public class MaximumFinder implements ExtendedPlugInFilter, DialogListener {
+    //filter params
+    /** prominence: maximum height difference between points that are not counted as separate maxima */
+    private static double tolerance = 10;
+    /** strict=off allows one maximum even if it is not higher than the prominence above all other pixels */
+    private static boolean strict = false;
+    /** Output type single points */
+    public final static int SINGLE_POINTS=0;
+    /** Output type all points around the maximum within the tolerance */
+    public final static int IN_TOLERANCE=1;
+    /** Output type watershed-segmented image */
+    public final static int SEGMENTED=2;
+    /** Do not create image, only mark points */
+    public final static int POINT_SELECTION=3;
+    /** Do not create an image, just list x, y of maxima in the Results table */
+    public final static int LIST=4;
+    /** Do not create an image, just count maxima and add count to Results table */
+    public final static int COUNT=5;
+    /** what type of output to create (see constants above)*/
+    private static int outputType;
+    /** what type of output to create was chosen in the dialog (see constants above)*/
+    private static int dialogOutputType = POINT_SELECTION;
+    /** output type names */
+    final static String[] outputTypeNames = new String[]
+        {"Single Points", "Maxima Within Tolerance", "Segmented Particles", "Point Selection", "List", "Count"};
+    /** whether to exclude maxima at the edge of the image*/
+    private static boolean excludeOnEdges;
+    /** whether to accept maxima only in the thresholded height range*/
+    private static boolean useMinThreshold;
+    /** whether to find darkest points on light background */
+    private static boolean lightBackground;
+    private boolean   oldMacro = false;             // till 1.52m, "strict" was the same as "excludeOnEdges" and "prominence" was called "noise tolerance"
+    private ImagePlus imp;                          // the ImagePlus of the setup call
+    private int flags = DOES_ALL|NO_CHANGES|NO_UNDO;// the flags (see interfaces PlugInFilter & ExtendedPlugInFilter)
+    private boolean   thresholded;                  // whether the input image has a threshold
+    private boolean   roiSaved;                     // whether the filter has changed the roi and saved the original roi
+    private boolean   previewing;                   // true while dialog is displayed (processing for preview)
+    private Vector    checkboxes;                   // a reference to the Checkboxes of the dialog
+    private boolean thresholdWarningShown = false;  // whether the warning "can't find minima with thresholding" has been shown
+    private Label     messageArea;                  // reference to the textmessage area for displaying the number of maxima
+    private double    progressDone;                 // for progress bar, fraction of work done so far
+    private int       nPasses = 0;                  // for progress bar, how many images to process (sequentially or parallel threads)
+    //the following are class variables for having shorter argument lists
+    private int       width, height;                // image dimensions
+    private int       intEncodeXMask;               // needed for encoding x & y in a single int (watershed): mask for x
+    private int       intEncodeYMask;               // needed for encoding x & y in a single int (watershed): mask for y
+    private int       intEncodeShift;               // needed for encoding x & y in a single int (watershed): shift of y
+    /** directions to 8 neighboring pixels, clockwise: 0=North (-y), 1=NE, 2=East (+x), ... 7=NW */
+    private int[]     dirOffset;                    // pixel offsets of neighbor pixels for direct addressing
+    private Polygon   xyCoordinates;                // maxima found by findMaxima() POINT_SELECTION, LIST, COUNT
+    final static int[] DIR_X_OFFSET = new int[] {  0,  1,  1,  1,  0, -1, -1, -1 };
+    final static int[] DIR_Y_OFFSET = new int[] { -1, -1,  0,  1,  1,  1,  0, -1 };
+    /** the following constants are used to set bits corresponding to pixel types */
+    final static byte MAXIMUM = (byte)1;            // marks local maxima (irrespective of noise tolerance)
+    final static byte LISTED = (byte)2;             // marks points currently in the list
+    final static byte PROCESSED = (byte)4;          // marks points processed previously
+    final static byte MAX_AREA = (byte)8;           // marks areas near a maximum, within the tolerance
+    final static byte EQUAL = (byte)16;             // marks contigous maximum points of equal level
+    final static byte MAX_POINT = (byte)32;         // marks a single point standing for a maximum
+    final static byte ELIMINATED = (byte)64;        // marks maxima that have been eliminated before watershed
+    /** type masks corresponding to the output types */
+    final static byte[] outputTypeMasks = new byte[] {MAX_POINT, MAX_AREA, MAX_AREA};
+    final static float SQRT2 = 1.4142135624f;
+
+
+    /** Method to return types supported
+     * @param arg   Not used by this plugin-filter
+     * @param imp   The image to be filtered
+     * @return      Code describing supported formats etc.
+     * (see ij.plugin.filter.PlugInFilter & ExtendedPlugInFilter)
+     */
+    public int setup(String arg, ImagePlus imp) {
+        this.imp = imp;
+        return flags;
+    }
+
+    public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+        ImageProcessor ip = imp.getProcessor();
+        ip.resetBinaryThreshold(); // remove any invisible threshold set by Make Binary or Convert to Mask
+        thresholded = ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD;
+        String options = Macro.getOptions();
+        if  (options!=null && options.indexOf("noise=") >= 0) { // ensure compatibility with old macros
+            oldMacro = true;                                    // specifying "noise=", not "prominence="
+            Macro.setOptions(options.replaceAll("noise=", "prominence="));
+        }
+        GenericDialog gd = new GenericDialog(command);
+        String unit = (imp.getCalibration()!=null)?imp.getCalibration().getValueUnit():null;
+        int digits = (ip instanceof FloatProcessor || unit != null) ? 2 : 0;
+        if (unit.equals("Gray Value")) unit = null;
+        gd.addNumericField("Prominence >",tolerance, digits, 6, unit);
+        gd.addCheckbox("Strict", strict);
+        gd.addCheckbox("Exclude edge maxima", excludeOnEdges);
+        if (thresholded)
+            gd.addCheckbox("Above lower threshold", useMinThreshold);
+        gd.addCheckbox("Light background", lightBackground);
+        gd.addChoice("Output type:", outputTypeNames, outputTypeNames[dialogOutputType]);
+        gd.addPreviewCheckbox(pfr, "Preview point selection");
+        gd.addMessage("    "); //space for number of maxima
+        messageArea = (Label)gd.getMessage();
+        gd.addDialogListener(this);
+        checkboxes = gd.getCheckboxes();
+        previewing = true;
+		gd.addHelp(IJ.URL+"/docs/menus/process.html#find-maxima");
+        gd.showDialog();          //input by the user (or macro) happens here
+        if (gd.wasCanceled())
+            return DONE;
+        previewing = false;
+        if (!dialogItemChanged(gd, null))   //read parameters
+            return DONE;
+        IJ.register(this.getClass());       //protect static class variables (parameters) from garbage collection
+        return flags;
+    } // boolean showDialog
+
+    /** Read the parameters (during preview or after showing the dialog) */
+    public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+        tolerance = gd.getNextNumber();
+        if (tolerance<0) tolerance = 0;
+        outputType = previewing ? POINT_SELECTION : dialogOutputType;
+        strict = gd.getNextBoolean();
+        excludeOnEdges = gd.getNextBoolean();
+        if (thresholded)
+            useMinThreshold = gd.getNextBoolean();
+        else
+            useMinThreshold = false;
+        lightBackground = gd.getNextBoolean();
+        dialogOutputType = gd.getNextChoiceIndex();
+        boolean invertedLut = imp.isInvertedLut();
+        if (useMinThreshold && ((invertedLut&&!lightBackground) || (!invertedLut&&lightBackground))) {
+            if (!thresholdWarningShown)
+                if (!IJ.showMessageWithCancel(
+                    "Find Maxima",
+                    "\"Above Lower Threshold\" option cannot be used\n"+
+                    "when finding minima (image with light background\n"+
+                    "or image with dark background and inverting LUT).")
+                    && !previewing)
+                return false;               // if faulty input is not detected during preview, "cancel" quits
+            thresholdWarningShown = true;
+            useMinThreshold = false;
+            ((Checkbox)(checkboxes.elementAt(1))).setState(false); //reset "Above Lower Threshold" checkbox
+        }
+        if (!gd.isPreviewActive() && messageArea!=null)
+            messageArea.setText("");        // no "nnn Maxima" message when not previewing
+        return (!gd.invalidNumber());
+    } // public boolean DialogItemChanged
+
+    /** Set his to the number of images to process (for the watershed progress bar only).
+     *  Don't call or set nPasses to zero if no progress bar is desired. */
+    public void setNPasses(int nPasses) {
+        this.nPasses = nPasses;
+    }
+
+    /** The plugin is inferred from ImageJ by this method
+     * @param ip The image where maxima (or minima) should be found
+     */
+    public void run(ImageProcessor ip) {
+        Roi roi = imp.getRoi();
+        if (outputType == POINT_SELECTION && !roiSaved) {
+            imp.saveRoi(); // save previous selection so user can restore it
+            roiSaved = true;
+        }
+        if (roi!=null && (!roi.isArea() || outputType==SEGMENTED)) {
+            imp.deleteRoi();
+            roi = null;
+        }
+        boolean invertedLut = imp.isInvertedLut();
+        double threshold = useMinThreshold?ip.getMinThreshold():ImageProcessor.NO_THRESHOLD;
+        if ((invertedLut&&!lightBackground) || (!invertedLut&&lightBackground)) {
+            threshold = ImageProcessor.NO_THRESHOLD;    //don't care about threshold when finding minima
+            float[] cTable = ip.getCalibrationTable();
+            ip = ip.duplicate();
+            if (cTable==null) {                 //invert image for finding minima of uncalibrated images
+                ip.invert();
+            } else {                            //we are using getPixelValue, so the CalibrationTable must be inverted
+                float[] invertedCTable = new float[cTable.length];
+                for (int i=cTable.length-1; i>=0; i--)
+                    invertedCTable[i] = -cTable[i];
+                ip.setCalibrationTable(invertedCTable);
+            }
+            ip.setRoi(roi);
+        }
+        ByteProcessor outIp = null;
+        boolean strictMode = oldMacro ? excludeOnEdges : strict;
+        outIp = findMaxima(ip, tolerance, strictMode, threshold, outputType, excludeOnEdges, false); //process the image
+        if (outIp == null) return;              //cancelled by user or previewing or no output image
+        if (!Prefs.blackBackground)             //normally, output has an inverted LUT, "active" pixels black (255) - like a mask
+            outIp.invertLut();
+        String resultName;
+        if (outputType == SEGMENTED)            //Segmentation required
+            resultName = " Segmented";
+        else
+            resultName = " Maxima";
+        String outname = imp.getTitle();
+        if (imp.getNSlices()>1)
+            outname += "("+imp.getCurrentSlice()+")";
+        outname += resultName;
+        if (WindowManager.getImage(outname)!=null)
+            outname = WindowManager.getUniqueName(outname);
+        ImagePlus maxImp = new ImagePlus(outname, outIp);
+        Calibration cal = imp.getCalibration().copy();
+        cal.disableDensityCalibration();
+        maxImp.setCalibration(cal);             //keep the spatial calibration
+        maxImp.show();
+     } //public void run
+     
+
+    /** Finds the image maxima and returns them as a Polygon, where
+     * poly.npoints is the number of maxima. There is an example at<br>
+     * http://imagej.nih.gov/ij/macros/js/FindMaxima.js.
+     * @param ip             The input image
+     * @param tolerance      Height tolerance: maxima are accepted only if protruding more than this value
+     *                       from the ridge to a higher maximum
+     * @param excludeOnEdges Whether to exclude edge maxima. Also determines whether strict mode is on, i.e.,
+     *                       whether the global maximum is accepted even if all other pixel are less than 'tolerance'
+     *                       below this level (In 1.52m and before, 'strict' and 'excludeOnEdges' were the same).
+     * @return         A Polygon containing the coordinates of the maxima, where poly.npoints 
+     *                       is the number of maxima. Note that poly.xpoints.length may be greater
+     *                       than the number of maxima.
+     */
+    public Polygon getMaxima(ImageProcessor ip, double tolerance, boolean excludeOnEdges) {
+		return getMaxima(ip, tolerance, excludeOnEdges, excludeOnEdges);
+    }
+
+    /** Finds the image maxima and returns them as a Polygon, where poly.npoints is
+     * the number of maxima.
+     * @param ip             The input image
+     * @param tolerance      Height tolerance: maxima are accepted only if protruding more than this value
+     *                       from the ridge to a higher maximum
+     * @param strict         When off, the global maximum is accepted even if all other pixel are less than
+     *                       'tolerance' below this level. With <code>excludeOnEdges=true</code>, 'strict' also
+     *                       means that the surounding of a maximum within 'tolerance' must not include an edge pixel
+     *                       (otherwise, it is enough that there is no edge pixel with the maximum value).
+     * @param excludeOnEdges Whether to exclude edge maxima. Also determines whether strict mode is on, i.e.,
+     *                       whether the global maximum is accepted even if all other pixel are less than 'tolerance'
+     *                       below this level (In 1.52m and before, 'strict' and 'excludeOnEdges' were the same).
+     * @return         A Polygon containing the coordinates of the maxima, where poly.npoints 
+     *                       is the number of maxima. Note that poly.xpoints.length may be greater
+     *                       than the number of maxima.
+     */
+    public Polygon getMaxima(ImageProcessor ip, double tolerance, boolean strict, boolean excludeOnEdges) {
+		findMaxima(ip, tolerance, strict, ImageProcessor.NO_THRESHOLD,
+			MaximumFinder.POINT_SELECTION, excludeOnEdges, false);
+		if (xyCoordinates==null)
+			return new Polygon();
+		else
+			return xyCoordinates;
+    }
+
+	/**
+	* Calculates peak positions of 1D array N.Vischer, 06-mar-2017
+	*
+	* @param xx Array containing peaks.
+	* @param tolerance Depth of a qualified valley must exceed tolerance.
+	* Tolerance must be >= 0. Flat tops are marked at their centers.
+	* @param  edgeMode 0=include, 1=exclude, 3=circular
+	* edgeMode = 0 (include edges) peak may be separated by one qualified valley and by a border.
+	* edgeMode = 1 (exclude edges) peak must be separated by two qualified valleys
+	* edgeMode = 2 (circular) array is regarded to be circular
+	* @return Positions of peaks, sorted with decreasing amplitude
+	*/
+	public static int[] findMaxima(double[] xx, double tolerance, int edgeMode ) {
+		final int INCLUDE_EDGE = 0;
+		final int CIRCULAR = 2;
+		int len = xx.length;
+		int origLen = len;
+		if (len<2)
+			return new int[0];
+		if (tolerance < 0)
+			tolerance = 0;
+		if(edgeMode==CIRCULAR){ 
+		    double[] cascade3 = new double[len * 3];
+		    for (int jj = 0; jj <len; jj++){
+			cascade3[jj] = xx[jj];
+			cascade3[jj + len] = xx[jj];
+			cascade3[jj + 2*len] = xx[jj];
+		    }
+		    len *= 3;
+		    xx = cascade3;
+		}
+		int[] maxPositions = new int[len];
+		double max = xx[0];
+		double min = xx[0];
+		int maxPos = 0;
+		int lastMaxPos = -1;
+		boolean leftValleyFound = (edgeMode == INCLUDE_EDGE);
+		int maxCount = 0;
+		for (int jj = 1; jj < len; jj++) {
+			double val = xx[jj];
+			if (val > min + tolerance)
+				leftValleyFound = true;
+			if (val > max && leftValleyFound) {
+				max = val;
+				maxPos = jj;
+			}
+			if (leftValleyFound)
+				lastMaxPos = maxPos;
+			if (val < max - tolerance && leftValleyFound) {
+				maxPositions[maxCount] = maxPos;
+				maxCount++;
+				leftValleyFound = false;
+				min = val;
+				max = val;
+			}
+			if (val < min) {
+				min = val;
+				if (!leftValleyFound)
+					max = val;
+			}
+		}
+		if (edgeMode == INCLUDE_EDGE) {
+			if (maxCount > 0 && maxPositions[maxCount - 1] != lastMaxPos)
+				maxPositions[maxCount++] = lastMaxPos;
+			if (maxCount == 0 && max - min >= tolerance)
+				maxPositions[maxCount++] = lastMaxPos;
+		}
+		int[] cropped = new int[maxCount];
+		System.arraycopy(maxPositions, 0, cropped, 0, maxCount);
+		maxPositions = cropped;
+		double[] maxValues = new double[maxCount];
+		for (int jj = 0; jj < maxCount; jj++) {
+			int pos = maxPositions[jj];
+			double midPos = pos;
+			while (pos < len - 1 && xx[pos] == xx[pos + 1]) {
+				midPos += 0.5;
+				pos++;
+			}
+			maxPositions[jj] = (int) midPos;
+			maxValues[jj] = xx[maxPositions[jj]];
+		}
+		int[] rankPositions = Tools.rank(maxValues);
+		int[] returnArr = new int[maxCount];
+		for (int jj = 0; jj < maxCount; jj++) {
+			int pos = maxPositions[rankPositions[jj]];
+			returnArr[maxCount - jj - 1] = pos;//use descending order
+		}
+		if(edgeMode == CIRCULAR){
+		    int count = 0;
+		    for(int jj = 0; jj < returnArr.length;jj++){
+			int pos = returnArr[jj] - origLen;
+			if(pos >= 0 && pos < origLen )//pick maxima from cascade center part
+			    returnArr[count++] = pos;
+		    }
+		    int[] returrn2Arr = new int[count];
+		    System.arraycopy(returnArr, 0, returrn2Arr, 0, count);
+		    returnArr = returrn2Arr;
+		    
+		}
+		return returnArr;
+	}
+	
+	public static int[] findMaxima(double[] xx, double tolerance, boolean excludeOnEdges) {
+	    int edgeBehavior = (excludeOnEdges) ? 1 : 0;
+	    return findMaxima(xx, tolerance, edgeBehavior);
+	}
+	 
+	/**
+	* Returns minimum positions of array xx, sorted with decreasing strength
+	*/
+	public static int[] findMinima(double[] xx, double tolerance, boolean excludeEdges ) {
+	    int edgeMode = (excludeEdges) ? 1 : 0;	
+	    return findMinima(xx, tolerance, edgeMode);
+	}
+		
+	public static int[] findMinima(double[] xx, double tolerance, int edgeMode) {
+		int len = xx.length;
+		double[] negArr = new double[len];
+		for (int jj = 0; jj < len; jj++)
+			negArr[jj] = -xx[jj];
+		int[] minPositions = findMaxima(negArr, tolerance, edgeMode);
+		return minPositions;
+	}	
+	
+     /** Find the maxima of an image.
+     * @param ip             The input image
+     * @param tolerance      Height tolerance: maxima are accepted only if protruding more than this value
+     *                       from the ridge to a higher maximum
+     * @param outputType     What to mark in output image: SINGLE_POINTS, IN_TOLERANCE or SEGMENTED.
+     *                       No output image is created for output types POINT_SELECTION, LIST and COUNT.
+     * @param excludeOnEdges Whether to exclude edge maxima. Also determines whether strict mode is on, i.e.,
+     *                       whether the global maximum is accepted even if all other pixel are less than 'tolerance'
+     *                       below this level (In 1.52m and before, 'strict' and 'excludeOnEdges' were the same).
+     * @return               A new byteProcessor with a normal (uninverted) LUT where the marked points
+     *                       are set to 255 (Background 0). Pixels outside of the roi of the input ip are not set.
+     *                       Returns null if outputType does not require an output or if cancelled by escape
+     */
+    public ByteProcessor findMaxima(ImageProcessor ip, double tolerance, int outputType, boolean excludeOnEdges) {
+    	return findMaxima(ip, tolerance, ImageProcessor.NO_THRESHOLD, outputType, excludeOnEdges, false);
+    }
+
+   /** Finds the maxima of an image (does not find minima).
+     *
+     * LIMITATIONS:          With outputType=SEGMENTED (watershed segmentation), some segmentation lines
+     *                       may be improperly placed if local maxima are suppressed by the tolerance.
+     *
+     * @param ip             The input image
+     * @param tolerance      Height tolerance: maxima are accepted only if protruding more than this value
+     *                       from the ridge to a higher maximum
+     * @param threshold      minimum height of a maximum (uncalibrated); for no minimum height set it to
+     *                       ImageProcessor.NO_THRESHOLD
+     * @param outputType     What to mark in output image: SINGLE_POINTS, IN_TOLERANCE or SEGMENTED.
+     *                       No output image is created for output types POINT_SELECTION, LIST and COUNT.
+     * @param excludeOnEdges Whether to exclude edge maxima. Also determines whether strict mode is on, i.e.,
+     *                       whether the global maximum is accepted even if all other pixel are less than 'tolerance'
+     *                       below this level (In 1.52m and before, 'strict' and 'excludeOnEdges' were the same).
+     * @param isEDM          Whether the image is a float Euclidian Distance Map.
+     * @return               A new byteProcessor with a normal (uninverted) LUT where the marked points
+     *                       are set to 255 (Background 0). Pixels outside of the roi of the input ip are not set.
+     *                       Returns null if outputType does not require an output or if cancelled by escape
+     */
+    public ByteProcessor findMaxima(ImageProcessor ip, double tolerance, double threshold,
+            int outputType, boolean excludeOnEdges, boolean isEDM) {
+        return findMaxima(ip, tolerance, excludeOnEdges, threshold, outputType, excludeOnEdges, isEDM);
+    }
+
+   /** Here the processing is done: Find the maxima of an image (does not find minima).
+     *
+     * LIMITATIONS:          With outputType=SEGMENTED (watershed segmentation), some segmentation lines
+     *                       may be improperly placed if local maxima are suppressed by the tolerance.
+     *
+     * @param ip             The input image
+     * @param tolerance      Height tolerance: maxima are accepted only if protruding more than this value
+     *                       from the ridge to a higher maximum
+     * @param strict         When off, the global maximum is accepted even if all other pixel are less than
+     *                       'tolerance' below this level. With <code>excludeOnEdges=true</code>, 'strict' also
+     *                       means that the surounding of a maximum within 'tolerance' must not include an edge pixel
+     *                       (otherwise, it is enough that there is no edge pixel with the maximum value).
+     * @param threshold      Minimum height of a maximum (uncalibrated); for no minimum height set it to
+     *                       ImageProcessor.NO_THRESHOLD
+     * @param outputType     What to mark in output image: SINGLE_POINTS, IN_TOLERANCE or SEGMENTED.
+     *                       No output image is created for output types POINT_SELECTION, LIST and COUNT.
+     * @param excludeOnEdges Whether to exclude edge maxima
+     * @param isEDM          Whether the image is a float Euclidian Distance Map.
+     * @return               A new byteProcessor with a normal (uninverted) LUT where the marked points
+     *                       are set to 255 (Background 0). Pixels outside of the roi of the input ip are not set.
+     *                       Returns null if outputType does not require an output or if cancelled by escape
+     */
+    public ByteProcessor findMaxima(ImageProcessor ip, double tolerance, boolean strict, double threshold,
+            int outputType, boolean excludeOnEdges, boolean isEDM) {
+        if (dirOffset == null) makeDirectionOffsets(ip);
+        Rectangle roi = ip.getRoi();
+        byte[] mask = ip.getMaskArray();
+        if (threshold!=ImageProcessor.NO_THRESHOLD && ip.getCalibrationTable()!=null &&
+                threshold>0 && threshold<ip.getCalibrationTable().length)
+            threshold = ip.getCalibrationTable()[(int)threshold];   //convert threshold to calibrated
+        ByteProcessor typeP = new ByteProcessor(width, height);     //will be a notepad for pixel types
+        byte[] types = (byte[])typeP.getPixels();
+        float globalMin = Float.MAX_VALUE;
+        float globalMax = -Float.MAX_VALUE;
+        for (int y=roi.y; y<roi.y+roi.height; y++) {         //find local minimum/maximum now
+            for (int x=roi.x; x<roi.x+roi.width; x++) {      //ImageStatistics won't work if we have no ImagePlus
+                float v = ip.getPixelValue(x, y);
+                if (globalMin>v) globalMin = v;
+                if (globalMax<v) globalMax = v;
+            }
+        }
+        boolean maximumPossible = globalMax>globalMin;
+        if (strict && globalMax - globalMin <= tolerance)
+            maximumPossible = false;
+
+        if (threshold !=ImageProcessor.NO_THRESHOLD)
+            threshold -= (globalMax-globalMin)*1e-6;//avoid rounding errors
+        //for segmentation, exclusion of edge maxima cannot be done now but has to be done after segmentation:
+        boolean excludeEdgesNow = excludeOnEdges && outputType!=SEGMENTED;
+
+        if (Thread.currentThread().isInterrupted()) return null;
+        IJ.showStatus("Getting sorted maxima...");
+        long[] maxPoints = maximumPossible ?
+                getSortedMaxPoints(ip, typeP, excludeEdgesNow, isEDM, globalMin, globalMax, threshold) : new long[0];
+        if (Thread.currentThread().isInterrupted()) return null;
+        IJ.showStatus("Analyzing  maxima...");
+        float maxSortingError = 0;
+        if (ip instanceof FloatProcessor)   //sorted sequence may be inaccurate by this value
+            maxSortingError = 1.1f * (isEDM ? SQRT2/2f : (globalMax-globalMin)/2e9f);
+        analyzeAndMarkMaxima(ip, typeP, maxPoints, excludeEdgesNow, isEDM, globalMin, tolerance, strict, outputType, maxSortingError);
+        //new ImagePlus("Pixel types",typeP.duplicate()).show();
+        if (outputType==POINT_SELECTION || outputType==LIST || outputType==COUNT)
+            return null;
+
+        ByteProcessor outIp;
+        byte[] pixels;
+        if (outputType == SEGMENTED) {
+            // Segmentation required, convert to 8bit (also for 8-bit images, since the calibration
+            // may have a negative slope). outIp has background 0, maximum areas 255
+            outIp = make8bit(ip, typeP, isEDM, globalMin, globalMax, threshold);
+            //if (IJ.debugMode) new ImagePlus("pixel types precleanup", typeP.duplicate()).show();
+            cleanupMaxima(outIp, typeP, maxPoints);     //eliminate all the small maxima (i.e. those outside MAX_AREA)
+            //if (IJ.debugMode) new ImagePlus("pixel types postcleanup", typeP).show();
+            //if (IJ.debugMode) new ImagePlus("pre-watershed", outIp.duplicate()).show();
+            if (!watershedSegment(outIp))               //do watershed segmentation
+                return null;                            //if user-cancelled, return
+            if (!isEDM) cleanupExtraLines(outIp);       //eliminate lines due to local minima (none in EDM)
+            watershedPostProcess(outIp);                //levels to binary image
+            if (excludeOnEdges) deleteEdgeParticles(outIp, typeP);
+        } else {                                        //outputType other than SEGMENTED
+            for (int i=0; i<width*height; i++)
+                types[i] = (byte)(((types[i]&outputTypeMasks[outputType])!=0)?255:0);
+            outIp = typeP;
+        }
+        byte[] outPixels = (byte[])outIp.getPixels();
+        if (roi!=null) {
+            for (int y=0, i=0; y<outIp.getHeight(); y++) { //delete everything outside roi
+                for (int x=0; x<outIp.getWidth(); x++, i++) {
+                    if (x<roi.x || x>=roi.x+roi.width || y<roi.y || y>=roi.y+roi.height) outPixels[i] = (byte)0;
+                    else if (mask !=null && (mask[x-roi.x + roi.width*(y-roi.y)]==0)) outPixels[i] = (byte)0;
+                }
+            }
+        }
+
+        return outIp;
+    } // public ByteProcessor findMaxima
+        
+    /** Find all local maxima (irrespective whether they finally qualify as maxima or not)
+     * @param ip    The image to be analyzed
+     * @param typeP A byte image, same size as ip, where the maximum points are marked as MAXIMUM
+     *              (do not use it as output: for rois, the points are shifted w.r.t. the input image)
+     * @param excludeEdgesNow Whether to exclude edge pixels
+     * @param isEDM     Whether ip is a float Euclidian distance map
+     * @param globalMin The minimum value of the image or roi
+     * @param threshold The threshold (calibrated) below which no pixels are processed. Ignored if ImageProcessor.NO_THRESHOLD
+     * @return          Maxima sorted by value. In each array element (long, i.e., 64-bit integer), the value
+     *                  is encoded in the upper 32 bits and the pixel offset in the lower 32 bit
+     * Note: Do not use the positions of the points marked as MAXIMUM in typeP, they are invalid for images with a roi.
+     */    
+    long[] getSortedMaxPoints(ImageProcessor ip, ByteProcessor typeP, boolean excludeEdgesNow,
+            boolean isEDM, float globalMin, float globalMax, double threshold) {
+        Rectangle roi = ip.getRoi();
+        byte[] types =  (byte[])typeP.getPixels();
+        int nMax = 0;  //counts local maxima
+        boolean checkThreshold = threshold!=ImageProcessor.NO_THRESHOLD;
+        Thread thread = Thread.currentThread();
+        //long t0 = System.currentTimeMillis();
+        for (int y=roi.y; y<roi.y+roi.height; y++) {         // find local maxima now
+            if (y%50==0 && thread.isInterrupted()) return null;
+            for (int x=roi.x, i=x+y*width; x<roi.x+roi.width; x++, i++) {      // for better performance with rois, restrict search to roi
+                float v = ip.getPixelValue(x,y);
+                float vTrue = isEDM ? trueEdmHeight(x,y,ip) : v;  // for EDMs, use interpolated ridge height
+                if (v==globalMin) continue;
+                if (excludeEdgesNow && (x==0 || x==width-1 || y==0 || y==height-1)) continue;
+                if (checkThreshold && v<threshold) continue;
+                boolean isMax = true;
+                /* check wheter we have a local maximum.
+                 Note: For an EDM, we need all maxima: those of the EDM-corrected values
+                 (needed by findMaxima) and those of the raw values (needed by cleanupMaxima) */
+                boolean isInner = (y!=0 && y!=height-1) && (x!=0 && x!=width-1); //not necessary, but faster than isWithin
+                for (int d=0; d<8; d++) {                         // compare with the 8 neighbor pixels
+                    if (isInner || isWithin(x, y, d)) {
+                        float vNeighbor = ip.getPixelValue(x+DIR_X_OFFSET[d], y+DIR_Y_OFFSET[d]);
+                        float vNeighborTrue = isEDM ? trueEdmHeight(x+DIR_X_OFFSET[d], y+DIR_Y_OFFSET[d], ip) : vNeighbor;
+                        if (vNeighbor > v && vNeighborTrue > vTrue) {
+                            isMax = false;
+                            break;
+                        }
+                    }
+                }
+                if (isMax) {
+                    types[i] = MAXIMUM;
+                    nMax++;
+                }
+            } // for x
+        } // for y
+        if (thread.isInterrupted()) return null;
+        //long t1 = System.currentTimeMillis();IJ.log("markMax:"+(t1-t0));
+        
+        float vFactor = (float)(2e9/(globalMax-globalMin)); //for converting float values into a 32-bit int
+        long[] maxPoints = new long[nMax];                  //value (int) is in the upper 32 bit, pixel offset in the lower
+        int iMax = 0;
+        for (int y=roi.y; y<roi.y+roi.height; y++)           //enter all maxima into an array
+            for (int x=roi.x, p=x+y*width; x<roi.x+roi.width; x++, p++)
+                if (types[p]==MAXIMUM) {
+                    float fValue = isEDM?trueEdmHeight(x,y,ip):ip.getPixelValue(x,y);
+                    int iValue = (int)((fValue-globalMin)*vFactor); //32-bit int, linear function of float value
+                    maxPoints[iMax++] = (long)iValue<<32|p;
+                }
+        //long t2 = System.currentTimeMillis();IJ.log("makeArray:"+(t2-t1));
+        if (thread.isInterrupted()) return null;
+        Arrays.sort(maxPoints);                                 //sort the maxima by value
+        //long t3 = System.currentTimeMillis();IJ.log("sort:"+(t3-t2));
+        return maxPoints;
+    } //getSortedMaxPoints
+
+   /** Check all maxima in list maxPoints, mark type of the points in typeP
+    * @param ip             the image to be analyzed
+    * @param typeP          8-bit image, here the point types are marked by type: MAX_POINT, etc.
+    * @param maxPoints      input: a list of all local maxima, sorted by height. Lower 32 bits are pixel offset
+    * @param excludeEdgesNow whether to avoid edge maxima
+    * @param isEDM          whether ip is a (float) Euclidian distance map
+    * @param globalMin      minimum pixel value in ip
+    * @param tolerance      minimum pixel value difference for two separate maxima
+    * @param maxSortingError sorting may be inaccurate, sequence may be reversed for maxima having values
+    *                       not deviating from each other by more than this (this could be a result of
+    *                       precision loss when sorting ints instead of floats, or because sorting does not
+    *                       take the height correction in 'trueEdmHeight' into account
+    * @param outputType 
+    */   
+   void analyzeAndMarkMaxima(ImageProcessor ip, ByteProcessor typeP, long[] maxPoints, boolean excludeEdgesNow,
+        boolean isEDM, float globalMin, double tolerance, boolean strict, int outputType, float maxSortingError) {
+        byte[] types =  (byte[])typeP.getPixels();
+        float[] edmPixels = isEDM ? (float[])ip.getPixels() : null;
+        int nMax = maxPoints.length;
+        int [] pList = new int[width*height];       //here we enter points starting from a maximum
+        xyCoordinates = null;
+        Roi roi = null;
+        boolean displayOrCount = outputType==POINT_SELECTION||outputType==LIST||outputType==COUNT;
+        if (displayOrCount) 
+            xyCoordinates = new Polygon();
+        if (imp!=null)
+            roi = imp.getRoi();	    
+      
+        for (int iMax=nMax-1; iMax>=0; iMax--) {    //process all maxima now, starting from the highest
+            if (iMax%100 == 0 && Thread.currentThread().isInterrupted()) return;
+            int offset0 = (int)maxPoints[iMax];     //type cast gets 32 lower bits, where pixel index is encoded
+            //int offset0 = maxPoints[iMax].offset;
+            if ((types[offset0]&PROCESSED)!=0)      //this maximum has been reached from another one, skip it
+                continue;
+            //we create a list of connected points and start the list at the current maximum
+            int x0 = offset0 % width;               
+            int y0 = offset0 / width;
+            float v0 = isEDM?trueEdmHeight(x0,y0,ip):ip.getPixelValue(x0,y0);
+            boolean sortingError;
+            do {                                    //repeat if we have encountered a sortingError
+                pList[0] = offset0;
+                types[offset0] |= (EQUAL|LISTED);   //mark first point as equal height (to itself) and listed
+                int listLen = 1;                    //number of elements in the list
+                int listI = 0;                      //index of current element in the list
+                boolean isEdgeMaximum = (x0==0 || x0==width-1 || y0==0 || y0==height-1);
+                sortingError = false;       //if sorting was inaccurate: a higher maximum was not handled so far
+                boolean maxPossible = true;         //it may be a true maximum
+                double xEqual = x0;                 //for creating a single point: determine average over the
+                double yEqual = y0;                 //  coordinates of contiguous equal-height points
+                int nEqual = 1;                     //counts xEqual/yEqual points that we use for averaging
+                do {                                //while neigbor list is not fully processed (to listLen)
+                    int offset = pList[listI];
+                    int x = offset % width;
+                    int y = offset / width;
+                    boolean isInner = (y!=0 && y!=height-1) && (x!=0 && x!=width-1); //not necessary, but faster than isWithin
+                    for (int d=0; d<8; d++) {       //analyze all neighbors (in 8 directions) at the same level
+                        int offset2 = offset+dirOffset[d];
+                        if ((isInner || isWithin(x, y, d)) && (types[offset2]&LISTED)==0) {
+                            if (isEDM && edmPixels[offset2]<=0)
+                                continue;   //ignore the background (non-particles)
+                            if ((types[offset2]&PROCESSED)!=0) {
+                                maxPossible = false; //we have reached a point processed previously, thus it is no maximum now
+                                break;
+                            }
+                            int x2 = x+DIR_X_OFFSET[d];
+                            int y2 = y+DIR_Y_OFFSET[d];
+                            float v2 = isEDM ? trueEdmHeight(x2, y2, ip) : ip.getPixelValue(x2, y2);
+                            if (v2 > v0 + maxSortingError) {
+                                maxPossible = false;    //we have reached a higher point, thus it is no maximum
+                                break;
+                            } else if (v2 >= v0-(float)tolerance) {
+                                if (v2 > v0) {          //maybe this point should have been treated earlier
+                                    sortingError = true;
+                                    offset0 = offset2;
+                                    v0 = v2;
+                                    x0 = x2;
+                                    y0 = y2;
+
+                                }
+                                pList[listLen] = offset2;
+                                listLen++;              //we have found a new point within the tolerance
+                                types[offset2] |= LISTED;
+                                if ((x2==0 || x2==width-1 || y2==0 || y2==height-1) && (strict || v2 >= v0)) {
+                                    isEdgeMaximum = true;
+                                    if (excludeEdgesNow) {
+                                        maxPossible = false;
+                                        break;          //we have an edge maximum
+                                    }
+                                }
+                                if (v2==v0) {           //prepare finding center of equal points (in case single point needed)
+                                    types[offset2] |= EQUAL;
+                                    xEqual += x2;
+                                    yEqual += y2;
+                                    nEqual ++;
+                                }
+                            }
+                        } // if isWithin & not LISTED
+                    } // for directions d
+                    listI++;
+                } while (listI < listLen);
+
+				if (sortingError)  {				  //if x0,y0 was not the true maximum but we have reached a higher one
+					for (listI=0; listI<listLen; listI++)
+						types[pList[listI]] = 0;	//reset all points encountered, then retry
+				} else {
+					int resetMask = ~(maxPossible?LISTED:(LISTED|EQUAL));
+					xEqual /= nEqual;
+					yEqual /= nEqual;
+					double minDist2 = 1e20;
+					int nearestI = 0;
+					for (listI=0; listI<listLen; listI++) {
+						int offset = pList[listI];
+						int x = offset % width;
+						int y = offset / width;
+						types[offset] &= resetMask;		//reset attributes no longer needed
+						types[offset] |= PROCESSED;		//mark as processed
+						if (maxPossible) {
+							types[offset] |= MAX_AREA;
+							if ((types[offset]&EQUAL)!=0) {
+								double dist2 = (xEqual-x)*(double)(xEqual-x) + (yEqual-y)*(double)(yEqual-y);
+								if (dist2 < minDist2) {
+									minDist2 = dist2;	//this could be the best "single maximum" point
+									nearestI = listI;
+								}
+							}
+						}
+					} // for listI
+					if (maxPossible) {
+						int offset = pList[nearestI];
+						types[offset] |= MAX_POINT;
+						if (displayOrCount && !(this.excludeOnEdges && isEdgeMaximum)) {
+							int x = offset % width;
+							int y = offset / width;
+							if (roi==null || roi.contains(x, y))
+								xyCoordinates.addPoint(x, y);
+						}
+					}
+				} //if !sortingError
+			} while (sortingError);				        //redo if we have encountered a higher maximum: handle it now.
+        } // for all maxima iMax
+        if (nMax == 0)                                  //no initial maxima at all? then consider all as 'within tolerance'
+            Arrays.fill(types, (byte)(PROCESSED|MAX_AREA));
+
+        if (Thread.currentThread().isInterrupted()) return;
+        if (displayOrCount) {
+            if (xyCoordinates == null) xyCoordinates = new Polygon();
+            int npoints = xyCoordinates.npoints;
+            if (outputType == POINT_SELECTION) {
+                if (imp!=null && npoints>0) {
+                	PointRoi points = new PointRoi(xyCoordinates);
+                	if (npoints<15 && points.getSize()<3)
+                		points.setSize(3);
+                	if (npoints==1)
+                 		points.setSize(4);               		
+                	imp.setRoi(points);
+                }
+            } else if (outputType==LIST) {
+                Analyzer.resetCounter();
+                ResultsTable rt = ResultsTable.getResultsTable();
+                for (int i=0; i<npoints; i++) {
+                    rt.incrementCounter();
+                    rt.addValue("X", xyCoordinates.xpoints[i]);
+                    rt.addValue("Y", xyCoordinates.ypoints[i]);
+                }
+                rt.show("Results");
+            } else if (outputType==COUNT) {
+                ResultsTable rt = ResultsTable.getResultsTable();
+                if (!IJ.isResultsWindow())
+                	rt = new ResultsTable();
+                rt.incrementCounter();
+                rt.setValue("Count", rt.size()-1, npoints);
+                int measurements = Analyzer.getMeasurements();
+                if ((measurements&Measurements.LABELS)!=0) {
+                    String s = imp.getTitle();
+                    String roiName = roi!=null?roi.getName():null;
+                    if (roiName!=null)
+                        s += ":"+roiName;
+                    if (imp.getStackSize()>1) {
+                        ImageStack stack = imp.getStack();
+                        int currentSlice = imp.getCurrentSlice();
+                        String label = stack.getShortSliceLabel(currentSlice);
+                        String colon = s.equals("")?"":":";
+                        if (label!=null && !label.equals(""))
+                            s += colon+label;
+                        else
+                            s += colon+currentSlice;
+                    }
+                    rt.setLabel(s, rt.size()-1);
+                }
+                rt.show("Results");
+            } 
+        }
+        if (previewing && messageArea!=null)
+            messageArea.setText((xyCoordinates==null ? 0 : xyCoordinates.npoints)+" Maxima");
+    } //void analyzeAndMarkMaxima
+
+   /** Create an 8-bit image by scaling the pixel values of ip to 1-254 (<lower threshold 0) and mark maximum areas as 255.
+    * For use as input for watershed segmentation
+    * @param ip         The original image that should be segmented
+    * @param typeP      Pixel types in ip
+    * @param isEDM      Whether ip is an Euclidian distance map
+    * @param globalMin  The minimum pixel value of ip
+    * @param globalMax  The maximum pixel value of ip
+    * @param threshold  Pixels of ip below this value (calibrated) are considered background. Ignored if ImageProcessor.NO_THRESHOLD
+    * @return           The 8-bit output image.
+    */
+    ByteProcessor make8bit(ImageProcessor ip, ByteProcessor typeP, boolean isEDM, float globalMin, float globalMax, double threshold) {
+        byte[] types = (byte[])typeP.getPixels();
+        double minValue;
+        if (isEDM) {
+            threshold = 0.5;
+            minValue = 1.;
+        } else
+            minValue = (threshold == ImageProcessor.NO_THRESHOLD)?globalMin:threshold;
+        double offset = minValue - (globalMax-minValue)*(1./253/2-1e-6); //everything above minValue should become >(byte)0
+        double factor = 253/(globalMax-minValue);
+        if (isEDM && factor>1)
+            factor = 1;   // with EDM, no better resolution
+        ByteProcessor outIp = new ByteProcessor(width, height);
+        //convert possibly calibrated image to byte without damaging threshold (setMinAndMax would kill threshold)
+        byte[] pixels = (byte[])outIp.getPixels();
+        long v;
+        for (int y=0, i=0; y<height; y++) {
+            for (int x=0; x<width; x++, i++) {
+                float rawValue = ip.getPixelValue(x, y);
+                if (threshold!=ImageProcessor.NO_THRESHOLD && rawValue<threshold)
+                    pixels[i] = (byte)0;
+                else if ((types[i]&MAX_AREA)!=0)
+                    pixels[i] = (byte)255;  //prepare watershed by setting "true" maxima+surroundings to 255
+                else {
+                    v = 1 + Math.round((rawValue-offset)*factor);
+                    if (v < 1) pixels[i] = (byte)1;
+                    else if (v<=254) pixels[i] = (byte)(v&255);
+                    else pixels[i] = (byte)254;
+                }
+            }
+        }
+        return outIp;
+    } // byteProcessor make8bit
+
+   /** Get estimated "true" height of a maximum or saddle point of a Euclidian Distance Map.
+     * This is needed since the point sampled is not necessarily at the highest position.
+     * For simplicity, we don't care about the Sqrt(5) distance here although this would be more accurate
+     * @param x     x-position of the point
+     * @param y     y-position of the point
+     * @param ip    the EDM (FloatProcessor)
+     * @return      estimated height
+     */
+    float trueEdmHeight(int x, int y, ImageProcessor ip) {
+        int xmax = width - 1;
+        int ymax = ip.getHeight() - 1;
+        float[] pixels = (float[])ip.getPixels();
+        int offset = x + y*width;
+        float v =  pixels[offset];
+        if (x==0 || y==0 || x==xmax || y==ymax || v==0) {
+            return v;                               //don't recalculate for edge pixels or background
+        } else {
+            float trueH = v + 0.5f*SQRT2;           //true height can never by higher than this
+            boolean ridgeOrMax = false;
+            for (int d=0; d<4; d++) {               //for all directions halfway around:
+                int d2 = (d+4)%8;                   //get the opposite direction and neighbors
+                float v1 = pixels[offset+dirOffset[d]];
+                float v2 = pixels[offset+dirOffset[d2]];
+                float h;
+                if (v>=v1 && v>=v2) {
+                    ridgeOrMax = true;
+                    h = (v1 + v2)/2;
+                } else {
+                    h = Math.min(v1, v2);
+                }
+                h += (d%2==0) ? 1 : SQRT2;          //in diagonal directions, distance is sqrt2
+                if (trueH > h) trueH = h;
+            }
+            if (!ridgeOrMax) trueH = v;
+            return trueH;
+        }
+    }
+    
+    /** eliminate unmarked maxima for use by watershed. Starting from each previous maximum,
+     * explore the surrounding down to successively lower levels until a marked maximum is
+     * touched (or the plateau of a previously eliminated maximum leads to a marked maximum).
+     * Then set all the points above this value to this value
+     * @param outIp     the image containing the pixel values
+     * @param typeP     the types of the pixels are marked here
+     * @param maxPoints array containing the coordinates of all maxima that might be relevant
+     */    
+    void cleanupMaxima(ByteProcessor outIp, ByteProcessor typeP, long[] maxPoints) {
+        byte[] pixels = (byte[])outIp.getPixels();
+        byte[] types = (byte[])typeP.getPixels();
+        int nMax = maxPoints.length;
+        int[] pList = new int[width*height];
+        for (int iMax = nMax-1; iMax>=0; iMax--) {
+            int offset0 = (int)maxPoints[iMax];     //type cast gets lower 32 bits where pixel offset is encoded
+            if ((types[offset0]&(MAX_AREA|ELIMINATED))!=0) continue;
+            int level = pixels[offset0]&255;
+            int loLevel = level+1;
+            pList[0] = offset0;                     //we start the list at the current maximum
+            types[offset0] |= LISTED;               //mark first point as listed
+            int listLen = 1;                        //number of elements in the list
+            int lastLen = 1;
+            int listI = 0;                          //index of current element in the list
+            boolean saddleFound = false;
+            while (!saddleFound && loLevel >0) {
+                loLevel--;
+                lastLen = listLen;                  //remember end of list for previous level
+                listI = 0;                          //in each level, start analyzing the neighbors of all pixels
+                do {                                //for all pixels listed so far
+                    int offset = pList[listI];
+                    int x = offset % width;
+                    int y = offset / width;
+                    boolean isInner = (y!=0 && y!=height-1) && (x!=0 && x!=width-1); //not necessary, but faster than isWithin
+                    for (int d=0; d<8; d++) {       //analyze all neighbors (in 8 directions) at the same level
+                        int offset2 = offset+dirOffset[d];
+                        if ((isInner || isWithin(x, y, d)) && (types[offset2]&LISTED)==0) {
+                            if ((types[offset2]&MAX_AREA)!=0 || (((types[offset2]&ELIMINATED)!=0) && (pixels[offset2]&255)>=loLevel)) {
+                                saddleFound = true; //we have reached a point touching a "true" maximum...
+                                break;              //...or a level not lower, but touching a "true" maximum
+                            } else if ((pixels[offset2]&255)>=loLevel && (types[offset2]&ELIMINATED)==0) {
+                                pList[listLen] = offset2;
+                                //xList[listLen] = x+DIR_X_OFFSET[d];
+                                //yList[listLen] = x+DIR_Y_OFFSET[d];
+                                listLen++;          //we have found a new point to be processed
+                                types[offset2] |= LISTED;
+                            }
+                        } // if isWithin & not LISTED
+                    } // for directions d
+                    if (saddleFound) break;         //no reason to search any further
+                    listI++;
+                } while (listI < listLen);
+            } // while !levelFound && loLevel>=0
+            for (listI=0; listI<listLen; listI++)   //reset attribute since we may come to this place again
+                types[pList[listI]] &= ~LISTED;
+            for (listI=0; listI<lastLen; listI++) { //for all points higher than the level of the saddle point
+                int offset = pList[listI];
+                pixels[offset] = (byte)loLevel;     //set pixel value to the level of the saddle point
+                types[offset] |= ELIMINATED;        //mark as processed: there can't be a local maximum in this area
+            }
+        } // for all maxima iMax
+    } // void cleanupMaxima
+
+    /** Delete extra structures form watershed of non-EDM images, e.g., foreground patches,
+     *  single dots and lines ending somewhere within a segmented particle
+     *  Needed for post-processing watershed-segmented images that can have local minima
+     *  @param ip 8-bit image with background = 0, lines between 1 and 254 and segmented particles = 255
+     */    
+    void cleanupExtraLines(ImageProcessor ip) {
+        byte[] pixels =  (byte[])ip.getPixels();
+        for (int y=0, i=0; y<height; y++) {
+            for (int x=0; x<width; x++,i++) {
+                int v = pixels[i];
+                if (v!=(byte)255 && v!=0) {
+                    int nRadii = nRadii(pixels, x, y);     //number of lines radiating
+                    if (nRadii==0)                              //single point or foreground patch?
+                        pixels[i] = (byte)255;
+                    else if (nRadii==1)
+                        removeLineFrom(pixels, x, y);
+                } // if v<255 && v>0
+            } // for x
+        } // for y
+    } // void cleanupExtraLines
+
+    /** delete a line starting at x, y up to the next (4-connected) vertex */
+    void removeLineFrom (byte[] pixels, int x, int y) {
+        //IJ.log("del line from "+x+","+y);
+        pixels[x + width*y] = (byte)255;                        //delete the first point
+        boolean continues;
+        do {
+            continues = false;
+            boolean isInner = (y!=0 && y!=height-1) && (x!=0 && x!=width-1); //not necessary, but faster than isWithin
+            for (int d=0; d<8; d+=2) {                          //analyze 4-connected neighbors
+                if (isInner || isWithin(x, y, d)) {
+                    int v = pixels[x + width*y + dirOffset[d]];
+                    if (v!=(byte)255 && v!=0) {
+                        int nRadii = nRadii(pixels, x+DIR_X_OFFSET[d], y+DIR_Y_OFFSET[d]);
+                        if (nRadii<=1) {                        //found a point or line end
+                            x += DIR_X_OFFSET[d];
+                            y += DIR_Y_OFFSET[d];
+                            pixels[x + width*y] = (byte)255;    //delete the point
+                            continues = nRadii==1;              //continue along that line
+                            break;
+                        }
+                    }
+                }
+            } // for directions d
+        } while (continues);
+        //IJ.log("deleted to "+x+","+y);
+    } // void removeLineFrom
+
+    /** Analyze the neighbors of a pixel (x, y) in a byte image; pixels <255 ("non-white") are
+     * considered foreground. Edge pixels are considered foreground.
+     * @param   ip
+     * @param   x coordinate of the point
+     * @param   y coordinate of the point
+     * @return  Number of 4-connected lines emanating from this point. Zero if the point is
+     *          embedded in either foreground or background
+     */
+    int nRadii (byte[] pixels, int x, int y) {
+        int offset = x + y*width;
+        int countTransitions = 0;
+        boolean prevPixelSet = true;
+        boolean firstPixelSet = true;           //initialize to make the compiler happy
+        boolean isInner = (y!=0 && y!=height-1) && (x!=0 && x!=width-1); //not necessary, but faster than isWithin
+        for (int d=0; d<8; d++) {               //walk around the point and note every no-line->line transition
+            boolean pixelSet = prevPixelSet;
+            if (isInner || isWithin(x, y, d)) {
+                boolean isSet = (pixels[offset+dirOffset[d]]!=(byte)255);
+                if ((d&1)==0) pixelSet = isSet; //non-diagonal directions: always regarded
+                else if (!isSet)                //diagonal directions may separate two lines,
+                    pixelSet = false;           //    but are insufficient for a 4-connected line
+            } else {
+                pixelSet = true;
+            }
+            if (pixelSet && !prevPixelSet)
+                countTransitions ++;
+            prevPixelSet = pixelSet;
+            if (d==0)
+                firstPixelSet = pixelSet;
+        }
+        if (firstPixelSet && !prevPixelSet)
+            countTransitions ++;
+        return countTransitions;
+    } // int nRadii
+
+    /** after watershed, set all pixels in the background and segmentation lines to 0
+     */
+    private void watershedPostProcess(ImageProcessor ip) {
+        //new ImagePlus("before postprocess",ip.duplicate()).show();
+        byte[] pixels = (byte[])ip.getPixels();
+        int size = ip.getWidth()*ip.getHeight();
+        for (int i=0; i<size; i++) {
+           if ((pixels[i]&255)<255)
+                pixels[i] = (byte)0;
+        }
+        //new ImagePlus("after postprocess",ip.duplicate()).show();
+    }
+
+    /** delete particles corresponding to edge maxima
+     * @param typeP Here the pixel types of the original image are noted,
+     * pixels with bit MAX_AREA at the edge are considered indicators of an edge maximum.
+     * @param ip the image resulting from watershed segmentaiton
+     * (foreground pixels, i.e. particles, are 255, background 0)
+     */
+    void deleteEdgeParticles(ByteProcessor ip, ByteProcessor typeP) {
+        byte[] pixels = (byte[])ip.getPixels();
+        byte[] types = (byte[])typeP.getPixels();
+        width = ip.getWidth();
+        height = ip.getHeight();
+        ip.setValue(0);
+        Wand wand = new Wand(ip);
+        for (int x=0; x<width; x++) {
+            int y = 0;
+            if ((types[x+y*width]&MAX_AREA) != 0 && pixels[x+y*width] != 0)
+                deleteParticle(x,y,ip,wand);
+            y = height - 1;
+            if ((types[x+y*width]&MAX_AREA) != 0 && pixels[x+y*width] != 0)
+                deleteParticle(x,y,ip,wand);            
+        }
+        for (int y=1; y<height-1; y++) {
+            int x = 0;
+            if ((types[x+y*width]&MAX_AREA) != 0 && pixels[x+y*width] != 0)
+                deleteParticle(x,y,ip,wand);
+            x = width - 1;
+            if ((types[x+y*width]&MAX_AREA) != 0 && pixels[x+y*width] != 0)
+                deleteParticle(x,y,ip,wand);            
+        }
+    } //void deleteEdgeParticles
+
+    /** delete a particle (set from value 255 to current fill value).
+     * Position x,y must be within the particle
+     */
+    void deleteParticle(int x, int y, ByteProcessor ip, Wand wand) {
+        wand.autoOutline(x, y, 255, 255);
+        if (wand.npoints==0) {
+            IJ.log("wand error selecting edge particle at x, y = "+x+", "+y);
+            return;
+        }
+        Roi roi = new PolygonRoi(wand.xpoints, wand.ypoints, wand.npoints, Roi.TRACED_ROI);
+        ip.snapshot();                  //prepare for reset outside of mask
+        ip.setRoi(roi);
+        ip.fill();
+        ip.reset(ip.getMask());
+    }
+
+    /** Do watershed segmentation on a byte image, with the start points (maxima)
+     * set to 255 and the background set to 0. The image should not have any local maxima
+     * other than the marked ones. Local minima will lead to artifacts that can be removed
+     * later. On output, all particles will be set to 255, segmentation lines remain at their
+     * old value.
+     * @param ip  The byteProcessor containing the image, with size given by the class variables width and height
+     * @return    false if canceled by the user (note: can be cancelled only if called by "run" with a known ImagePlus)
+     */    
+    private boolean watershedSegment(ByteProcessor ip) {
+        boolean debug = IJ.debugMode;
+        ImageStack movie=null;
+        if (debug) {
+            movie = new ImageStack(ip.getWidth(), ip.getHeight());
+            movie.addSlice("pre-watershed EDM", ip.duplicate());
+        }
+        byte[] pixels = (byte[])ip.getPixels();
+        // Create an array with the coordinates of all points between value 1 and 254
+        // This method, suggested by Stein Roervik (stein_at_kjemi-dot-unit-dot-no),
+        // greatly speeds up the watershed segmentation routine.
+        int[] histogram = ip.getHistogram();
+        int arraySize = width*height - histogram[0] -histogram[255];
+        int[] coordinates = new int[arraySize];    //from pixel coordinates, low bits x, high bits y
+        int highestValue = 0;
+        int maxBinSize = 0;
+        int offset = 0;
+        int[] levelStart = new int[256];
+        for (int v=1; v<255; v++) {
+            levelStart[v] = offset;
+            offset += histogram[v];
+            if (histogram[v] > 0) highestValue = v;
+            if (histogram[v] > maxBinSize) maxBinSize = histogram[v];
+        }
+        int[] levelOffset = new int[highestValue + 1];
+        for (int y=0, i=0; y<height; y++) {
+            for (int x=0; x<width; x++, i++) {
+                int v = pixels[i]&255;
+                if (v>0 && v<255) {
+                    offset = levelStart[v] + levelOffset[v];
+                    coordinates[offset] = x | y<<intEncodeShift;
+                    levelOffset[v] ++;
+                }
+           } //for x
+        } //for y
+        // Create an array of the points (pixel offsets) that we set to 255 in one pass.
+        // If we remember this list we need not create a snapshot of the ImageProcessor. 
+        int[] setPointList = new int[Math.min(maxBinSize, (width*height+2)/3)];
+        // now do the segmentation, starting at the highest level and working down.
+        // At each level, dilate the particle (set pixels to 255), constrained to pixels
+        // whose values are at that level and also constrained (by the fateTable)
+        // to prevent features from merging.
+        int[] table = makeFateTable();
+        IJ.showStatus("Segmenting (Esc to cancel)");
+        final int[] directionSequence = new int[] {7, 3, 1, 5, 0, 4, 2, 6}; // diagonal directions first
+        for (int level=highestValue; level>=1; level--) {
+            int remaining = histogram[level];  //number of points in the level that have not been processed
+            int idle = 0;
+            while (remaining>0 && idle<8) {
+                int sumN = 0;
+                int dIndex = 0;
+                do {                        // expand each level in 8 directions
+                    int n = processLevel(directionSequence[dIndex%8], ip, table,
+                            levelStart[level], remaining, coordinates, setPointList);
+                    //IJ.log("level="+level+" direction="+directionSequence[dIndex%8]+" remain="+remaining+"-"+n);
+                    remaining -= n;         // number of points processed
+                    sumN += n;
+                    if (n > 0) idle = 0;    // nothing processed in this direction?
+                    dIndex++;
+                } while (remaining>0 && idle++<8);
+                addProgress(sumN/(double)arraySize);
+                if (IJ.escapePressed()) {   // cancelled by the user
+                    IJ.beep();
+                    IJ.showProgress(1.0);
+                    return false;
+                }
+            }
+            if (remaining>0 && level>1) {   // any pixels that we have not reached?
+                int nextLevel = level;      // find the next level to process
+                do
+                    nextLevel--;
+                while (nextLevel>1 && histogram[nextLevel]==0);
+                // in principle we should add all unprocessed pixels of this level to the
+                // tasklist of the next level. This would make it very slow for some images,
+                // however. Thus we only add the pixels if they are at the border (of the
+                // image or a thresholded area) and correct unprocessed pixels at the very
+                // end by CleanupExtraLines
+                if (nextLevel > 0) {
+                    int newNextLevelEnd = levelStart[nextLevel] + histogram[nextLevel];
+                    for (int i=0, p=levelStart[level]; i<remaining; i++, p++) {
+                        int xy = coordinates[p];
+                        int x = xy&intEncodeXMask;
+                        int y = (xy&intEncodeYMask)>>intEncodeShift;
+                        int pOffset = x + y*width;
+                        if ((pixels[pOffset]&255)==255) IJ.log("ERROR");
+                        boolean addToNext = false;
+                        if (x==0 || y==0 || x==width-1 || y==height-1)
+                            addToNext = true;           //image border
+                        else for (int d=0; d<8; d++)
+                            if (isWithin(x, y, d) && pixels[pOffset+dirOffset[d]]==0) {
+                                addToNext = true;       //border of area below threshold
+                                break;
+                            }
+                        if (addToNext)
+                            coordinates[newNextLevelEnd++] = xy;
+                    }
+                    //IJ.log("level="+level+": add "+(newNextLevelEnd-levelStart[nextLevel+1])+" points to "+nextLevel);
+                    //tasklist for the next level to process becomes longer by this:
+                    histogram[nextLevel] = newNextLevelEnd - levelStart[nextLevel];
+                }
+            }
+            if (debug && (level>170 || level>100 && level<110 || level<10))
+                movie.addSlice("level "+level, ip.duplicate());
+        }
+        if (debug)
+            new ImagePlus("Segmentation Movie", movie).show();
+        return true;
+    } // boolean watershedSegment
+
+
+    /** dilate the UEP on one level by one pixel in the direction specified by step, i.e., set pixels to 255
+     * @param pass gives direction of dilation, see makeFateTable
+     * @param ip the EDM with the segmeted blobs successively getting set to 255
+     * @param table             The fateTable
+     * @param levelStart        offsets of the level in pixelPointers[]
+     * @param levelNPoints      number of points in the current level
+     * @param pixelPointers[]   list of pixel coordinates (x+y*width) sorted by level (in sequence of y, x within each level)
+     * @param xCoordinates      list of x Coorinates for the current level only (no offset levelStart)
+     * @return                  number of pixels that have been changed
+     */
+    private int processLevel(int pass, ImageProcessor ip, int[] fateTable,
+            int levelStart, int levelNPoints, int[] coordinates, int[] setPointList) {
+        int xmax = width - 1;
+        int ymax = height - 1;
+        byte[] pixels = (byte[])ip.getPixels();
+        //byte[] pixels2 = (byte[])ip2.getPixels();
+        int nChanged = 0;
+        int nUnchanged = 0;
+        for (int i=0, p=levelStart; i<levelNPoints; i++, p++) {
+            int xy = coordinates[p];
+            int x = xy&intEncodeXMask;
+            int y = (xy&intEncodeYMask)>>intEncodeShift;
+            int offset = x + y*width;
+            int index = 0;      //neighborhood pixel ocupation: index in fateTable
+            if (y>0 && (pixels[offset-width]&255)==255)
+                index ^= 1;
+            if (x<xmax && y>0 && (pixels[offset-width+1]&255)==255)
+                index ^= 2;
+            if (x<xmax && (pixels[offset+1]&255)==255)
+                index ^= 4;
+            if (x<xmax && y<ymax && (pixels[offset+width+1]&255)==255)
+                index ^= 8;
+            if (y<ymax && (pixels[offset+width]&255)==255)
+                index ^= 16;
+            if (x>0 && y<ymax && (pixels[offset+width-1]&255)==255)
+                index ^= 32;
+            if (x>0 && (pixels[offset-1]&255)==255)
+                index ^= 64;
+            if (x>0 && y>0 && (pixels[offset-width-1]&255)==255)
+                index ^= 128;
+            int mask = 1<<pass;
+            if ((fateTable[index]&mask)==mask)
+                setPointList[nChanged++] = offset;  //remember to set pixel to 255
+            else
+                coordinates[levelStart+(nUnchanged++)] = xy; //keep this pixel for future passes
+
+        } // for pixel i
+        //IJ.log("pass="+pass+", changed="+nChanged+" unchanged="+nUnchanged);
+        for (int i=0; i<nChanged; i++)
+            pixels[setPointList[i]] = (byte)255;
+        return nChanged;
+    } //processLevel
+
+    /** Creates the lookup table used by the watershed function for dilating the particles.
+     * The algorithm allows dilation in both straight and diagonal directions.
+     * There is an entry in the table for each possible 3x3 neighborhood:
+     *          x-1          x          x+1
+     *  y-1    128            1          2
+     *  y       64     pxl_unset_yet     4
+     *  y+1     32           16          8
+     * (to find throws entry, sum up the numbers of the neighboring pixels set; e.g.
+     * entry 6=2+4 if only the pixels (x,y-1) and (x+1, y-1) are set.
+     * A pixel is added on the 1st pass if bit 0 (2^0 = 1) is set,
+     * on the 2nd pass if bit 1 (2^1 = 2) is set, etc.
+     * pass gives the direction of rotation, with 0 = to top left (x--,y--), 1 to top,
+     * and clockwise up to 7 = to the left (x--).
+     * E.g. 4 = add on 3rd pass, 3 = add on either 1st or 2nd pass.
+     */
+    private int[] makeFateTable() {
+        int[] table = new int[256];
+        boolean[] isSet = new boolean[8];
+        for (int item=0; item<256; item++) {        //dissect into pixels
+            for (int i=0, mask=1; i<8; i++) {
+                isSet[i] = (item&mask)==mask;
+                mask*=2;
+            }
+            for (int i=0, mask=1; i<8; i++) {       //we dilate in the direction opposite to the direction of the existing neighbors
+                if (isSet[(i+4)%8]) table[item] |= mask;
+                mask*=2;
+            }
+            for (int i=0; i<8; i+=2)                //if side pixels are set, for counting transitions it is as good as if the adjacent edges were also set
+                if (isSet[i]) {
+                    isSet[(i+1)%8] = true;
+                    isSet[(i+7)%8] = true;
+                }
+            int transitions=0;
+            for (int i=0, mask=1; i<8; i++) {
+                if (isSet[i] != isSet[(i+1)%8])
+                    transitions++;
+            }
+            if (transitions>=4) {                   //if neighbors contain more than one region, dilation ito this pixel is forbidden
+                table[item] = 0;
+            } else {
+            }
+        }
+        return table;
+    } // int[] makeFateTable
+
+    /** create an array of offsets within a pixel array for directions in clockwise order:
+     * 0=(x,y-1), 1=(x+1,y-1), ... 7=(x-1,y)
+     * Also creates further class variables:
+     * width, height, and the following three values needed for storing coordinates in single ints for watershed:
+     * intEncodeXMask, intEncodeYMask and intEncodeShift.
+     * E.g., for width between 129 and 256, xMask=0xff and yMask = 0xffffff00 are bitwise masks
+     * for x and y, respectively, and shift=8 is the bit shift to get y from the y-masked value
+     * Returns as class variables: the arrays of the offsets to the 8 neighboring pixels
+     * and the array maskAndShift for watershed
+     */
+    void makeDirectionOffsets(ImageProcessor ip) {
+        width = ip.getWidth();
+        height = ip.getHeight();
+        int shift = 0, mult=1;
+        do {
+            shift++; mult*=2;
+        }
+        while (mult < width);
+        intEncodeXMask = mult-1;
+        intEncodeYMask = ~intEncodeXMask;
+        intEncodeShift = shift;
+        //IJ.log("masks (hex):"+Integer.toHexString(xMask)+","+Integer.toHexString(xMask)+"; shift="+shift);
+        dirOffset  = new int[] {-width, -width+1, +1, +width+1, +width, +width-1,   -1, -width-1 };
+        //dirOffset is created last, so check for it being null before makeDirectionOffsets
+        //(in case we have multiple threads using the same MaximumFinder)
+    }
+
+    /** returns whether the neighbor in a given direction is within the image
+     * NOTE: it is assumed that the pixel x,y itself is within the image!
+     * Uses class variables width, height: dimensions of the image
+     * @param x         x-coordinate of the pixel that has a neighbor in the given direction
+     * @param y         y-coordinate of the pixel that has a neighbor in the given direction
+     * @param direction the direction from the pixel towards the neighbor (see makeDirectionOffsets)
+     * @return          true if the neighbor is within the image (provided that x, y is within)
+     */
+    boolean isWithin(int x, int y, int direction) {
+        int xmax = width - 1;
+        int ymax = height -1;
+        switch(direction) {
+            case 0:
+                return (y>0);
+            case 1:
+                return (x<xmax && y>0);
+            case 2:
+                return (x<xmax);
+            case 3:
+                return (x<xmax && y<ymax);
+            case 4:
+                return (y<ymax);
+            case 5:
+                return (x>0 && y<ymax);
+            case 6:
+                return (x>0);
+            case 7:
+                return (x>0 && y>0);
+        }
+        return false;   //to make the compiler happy :-)
+    } // isWithin
+
+    /** add work done in the meanwhile and show progress */
+    private void addProgress(double deltaProgress) {
+        if (nPasses==0) return;
+        progressDone += deltaProgress;
+        IJ.showProgress(progressDone/nPasses);
+    }
+
+}
diff --git a/src/ij/plugin/filter/ParticleAnalyzer.java b/src/ij/plugin/filter/ParticleAnalyzer.java
new file mode 100644
index 0000000..85182c2
--- /dev/null
+++ b/src/ij/plugin/filter/ParticleAnalyzer.java
@@ -0,0 +1,1214 @@
+package ij.plugin.filter;
+import java.awt.*;
+import java.awt.image.IndexColorModel;
+import java.util.Properties;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.text.*;
+import ij.plugin.filter.Analyzer;
+import ij.plugin.frame.*;
+import ij.plugin.Colors;
+import ij.plugin.LutLoader;
+import ij.macro.Interpreter;
+import ij.util.Tools;
+
+/** Implements ImageJ's Analyze Particles command.
+	<p>
+	<pre>
+	for each line do
+		for each pixel in this line do
+			if the pixel value is "inside" the threshold range then
+				trace the edge to mark the object
+				do the measurement
+				fill the object with a color outside the threshold range
+			else
+				continue the scan
+	</pre>
+*/
+public class ParticleAnalyzer implements PlugInFilter, Measurements {
+
+	/** Display results in the ImageJ console. */
+	public static final int SHOW_RESULTS = 1;
+	
+	/** Obsolete, replaced by  DISPLAY_SUMMARY */
+	public static final int SHOW_SUMMARY = 2;
+	
+	/** Display image containing outlines of measured particles. */
+	public static final int SHOW_OUTLINES = 4;
+	
+	/** Do not measure particles touching edge of image. */
+	public static final int EXCLUDE_EDGE_PARTICLES = 8;
+	
+	/** Display image containing grayscales masks that identify measured particles. */
+	public static final int SHOW_ROI_MASKS = 16;
+	
+	/** Display a progress bar. */
+	public static final int SHOW_PROGRESS = 32;
+	
+	/** Clear "Results" window before starting. */
+	public static final int CLEAR_WORKSHEET = 64;
+	
+	/** Record starting coordinates so outline can be recreated later using doWand(x,y). */
+	public static final int RECORD_STARTS = 128;
+
+	/** Display a summary. */
+	public static final int DISPLAY_SUMMARY = 256;
+
+	/** Do not display particle outline image. */
+	public static final int SHOW_NONE = 512;
+
+	/** Flood fill to ignore interior holes. */
+	public static final int INCLUDE_HOLES = 1024;
+	
+	/** Add particles to ROI Manager. */
+	public static final int ADD_TO_MANAGER = 2048;
+
+	/** Display image containing binary masks of measured particles. */
+	public static final int SHOW_MASKS = 4096;
+
+	/** Use 4-connected particle tracing. */
+	public static final int FOUR_CONNECTED = 8192;
+
+	/** Replace original image with masks. */
+	public static final int IN_SITU_SHOW = 16384;
+
+	/** Display particle outlines as an overlay. */
+	public static final int SHOW_OVERLAY_OUTLINES = 32768;
+	
+	/** Display filled particle as an overlay. */
+	public static final int SHOW_OVERLAY_MASKS = 65536;
+
+	/** Use composite ROIs for particles with holes. */
+	public static final int COMPOSITE_ROIS = 131072;
+
+	/** Use "Overlay" checkbox to display overlay. */
+	public static final int OVERLAY = 262144;
+
+	static final String OPTIONS = "ap.options";
+	
+	static final int BYTE=0, SHORT=1, FLOAT=2, RGB=3;
+	static final double DEFAULT_MIN_SIZE = 0.0;
+	static final double DEFAULT_MAX_SIZE = Double.POSITIVE_INFINITY;
+	
+	private static double staticMinSize = 0.0;
+	private static double staticMaxSize = DEFAULT_MAX_SIZE;
+	private static boolean pixelUnits;
+	private static int staticOptions = Prefs.getInt(OPTIONS,CLEAR_WORKSHEET);
+	private static String[] showStrings = {"Nothing", "Outlines", "Bare Outlines", "Ellipses", "Masks", "Count Masks", "Overlay", "Overlay Masks"};
+	private static String[] showStrings2 = {"Nothing", "Overlay", "Overlay Masks", "Outlines", "Bare Outlines", "Ellipses", "Masks", "Count Masks"};
+	private static int[] showStringOrder = {0, 6, 7, 1, 2, 3, 4, 5};
+	private static double staticMinCircularity=0.0, staticMaxCircularity=1.0;
+		
+	protected static final int NOTHING=0, OUTLINES=1, BARE_OUTLINES=2, ELLIPSES=3, MASKS=4, ROI_MASKS=5,
+		OVERLAY_OUTLINES=6, OVERLAY_MASKS=7;
+	protected static int staticShowChoice;
+	protected ImagePlus imp;
+	protected ResultsTable rt;
+	protected Analyzer analyzer;
+	protected int slice;
+	protected boolean processStack;
+	protected boolean showResults,excludeEdgeParticles,showSizeDistribution,
+		resetCounter,showProgress, recordStarts, displaySummary, floodFill,
+		addToManager, inSituShow, compositeRois, showOverlay;
+		
+	private boolean showResultsTable = true;
+	private boolean showSummaryTable = true;
+	private double level1, level2;
+	private double minSize, maxSize;
+	private double minCircularity, maxCircularity;
+	private int showChoice;
+	private int options;
+	private int measurements;
+	private Calibration calibration;
+	private String arg;
+	private double fillColor;
+	private boolean thresholdingLUT;
+	private ImageProcessor drawIP;
+	private int width,height;
+	private boolean canceled;
+	private ImageStack outlines;
+	private IndexColorModel customLut;
+	private int particleCount;
+	private int maxParticleCount = 0;
+	private int totalCount;
+	private ResultsTable summaryTable;
+	private Wand wand;
+	private int imageType, imageType2;
+	private boolean roiNeedsImage;
+	private int minX, maxX, minY, maxY;
+	private ImagePlus redirectImp;
+	private ImageProcessor redirectIP;
+	private PolygonFiller pf;
+	private Roi saveRoi;
+	private int saveSlice;
+	private int beginningCount;
+	private Rectangle r;
+	private ImageProcessor mask;
+	private double totalArea;
+	private FloodFiller ff;
+	private Roi exclusionRoi;
+	private RoiManager roiManager;
+	private static RoiManager staticRoiManager;
+	private static ResultsTable staticResultsTable, staticSummaryTable;
+	private ImagePlus outputImage;
+	private boolean hideOutputImage;
+	private int roiType;
+	private int wandMode = Wand.LEGACY_MODE;
+	private Overlay overlay;
+	boolean blackBackground;
+	private static int defaultFontSize = 9;
+	private static int nextFontSize = defaultFontSize;
+	private static Color defaultFontColor = Color.red;
+	private static Color nextFontColor = defaultFontColor;
+	private static int nextLineWidth = 1;
+	private int fontSize = nextFontSize;
+	private Color fontColor = nextFontColor;
+	private int lineWidth = nextLineWidth;
+	private boolean noThreshold;
+	private boolean calledByPlugin;
+	private boolean hyperstack;
+	private static LUT glasbeyLut;
+
+			
+	/** Constructs a ParticleAnalyzer.
+		@param options	a flag word created by Oring SHOW_RESULTS, EXCLUDE_EDGE_PARTICLES, etc.
+		@param measurements a flag word created by ORing constants defined in the Measurements interface
+		@param rt		a ResultsTable where the measurements will be stored
+		@param minSize	the smallest particle size in pixels
+		@param maxSize	the largest particle size in pixels
+		@param minCirc	minimum circularity
+		@param maxCirc	maximum circularity
+	*/
+	public ParticleAnalyzer(int options, int measurements, ResultsTable rt, double minSize, double maxSize, double minCirc, double maxCirc) {
+		this.options = options;
+		this.measurements = measurements;
+		this.rt = rt;
+		if (this.rt==null)
+			this.rt = new ResultsTable();
+		this.minSize = minSize;
+		this.maxSize = maxSize;
+		this.minCircularity = minCirc;
+		this.maxCircularity = maxCirc;
+		slice = 1;
+		if ((options&SHOW_ROI_MASKS)!=0)
+			showChoice = ROI_MASKS;
+		if ((options&SHOW_OVERLAY_OUTLINES)!=0)
+			showChoice = OVERLAY_OUTLINES;
+		if ((options&SHOW_OVERLAY_MASKS)!=0)
+			showChoice = OVERLAY_MASKS;
+		if ((options&SHOW_OUTLINES)!=0)
+			showChoice = OUTLINES;
+		if ((options&SHOW_MASKS)!=0)
+			showChoice = MASKS;
+		if ((options&SHOW_NONE)!=0)
+			showChoice = NOTHING;
+		if ((options&FOUR_CONNECTED)!=0) {
+			wandMode = Wand.FOUR_CONNECTED;
+			options |= INCLUDE_HOLES;
+		}
+		nextFontSize = defaultFontSize;
+		nextFontColor = defaultFontColor;
+		nextLineWidth = 1;
+		calledByPlugin = true;
+	}
+	
+	/** Constructs a ParticleAnalyzer using the default min and max circularity values (0 and 1). */
+	public ParticleAnalyzer(int options, int measurements, ResultsTable rt, double minSize, double maxSize) {
+		this(options, measurements, rt, minSize, maxSize, 0.0, 1.0);
+	}
+
+	/** Default constructor */
+	public ParticleAnalyzer() {
+		slice = 1;
+	}
+	
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		IJ.register(ParticleAnalyzer.class);
+		if (imp==null) {
+			IJ.noImage();
+			return DONE;
+		}
+		if (imp.getBitDepth()==24 && !isThresholdedRGB(imp)) {
+			IJ.error("Particle Analyzer",
+			"RGB images must be thresholded using\n"
+			+"Image>Adjust>Color Threshold.");
+			return DONE;
+		}
+		if (!showDialog())
+			return DONE;
+		int baseFlags = DOES_ALL+NO_CHANGES+NO_UNDO;
+		int flags = IJ.setupDialog(imp, baseFlags);
+		processStack = (flags&DOES_STACKS)!=0;
+		slice = 0;
+		saveRoi = imp.getRoi();
+		saveSlice = imp.getCurrentSlice();
+		if (saveRoi!=null && saveRoi.isArea())
+			exclusionRoi = saveRoi;
+		imp.startTiming();
+		nextFontSize = defaultFontSize;
+		nextFontColor = defaultFontColor;
+		nextLineWidth = 1;
+		return flags;
+	}
+	
+	public void run(ImageProcessor ip) {
+		if (canceled)
+			return;
+		slice++;
+		if (imp.getStackSize()>1 && processStack)
+			imp.setSlice(slice);
+		if (imp.getType()==ImagePlus.COLOR_RGB) {
+			ip = (ImageProcessor)imp.getProperty("Mask");
+			ip.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+			ip.setRoi(imp.getRoi());
+		}		
+		if (!analyze(imp, ip))
+			canceled = true;
+		if (slice==imp.getStackSize()) {
+			imp.updateAndDraw();
+			if (saveRoi!=null) imp.setRoi(saveRoi);
+			if (processStack) imp.setSlice(saveSlice);
+		}
+	}
+	
+	/** Displays a modal options dialog. */
+	public boolean showDialog() {
+		Calibration cal = imp!=null?imp.getCalibration():(new Calibration());
+		double unitSquared = cal.pixelWidth*cal.pixelHeight;
+		if (pixelUnits)
+			unitSquared = 1.0;
+		String mOptions = Macro.getOptions();
+		if (mOptions!=null) {
+			boolean oldMacro = updateMacroOptions();
+			if (oldMacro) unitSquared = 1.0;
+			if (mOptions.contains("in_situ"))
+				inSituShow = true;
+			if (mOptions.contains("record"))
+				recordStarts = true;
+			staticMinSize = 0.0; staticMaxSize = DEFAULT_MAX_SIZE;
+			staticMinCircularity=0.0; staticMaxCircularity=1.0;
+			staticShowChoice = NOTHING;
+		}
+		GenericDialog gd = new GenericDialog("Analyze Particles");
+		minSize = staticMinSize;
+		maxSize = staticMaxSize;
+		minCircularity = staticMinCircularity;
+		maxCircularity = staticMaxCircularity;
+		showChoice = staticShowChoice;
+		if (maxSize==999999)
+			maxSize = DEFAULT_MAX_SIZE;
+		options = staticOptions;
+		String unit = cal.getUnit();
+		boolean scaled = cal.scaled();
+		String units = unit+"^2";
+		int places = 0;
+		double cmin = minSize*unitSquared;
+		if ((int)cmin!=cmin) places = 2;
+		double cmax = maxSize*unitSquared;
+		if ((int)cmax!=cmax && cmax!=DEFAULT_MAX_SIZE) places = 2;
+		String minStr = ResultsTable.d2s(cmin,places);
+		if (minStr.indexOf("-")!=-1) {
+			for (int i=places; i<=6; i++) {
+				minStr = ResultsTable.d2s(cmin, i);
+				if (minStr.indexOf("-")==-1) break;
+			}
+		}
+		String maxStr = ResultsTable.d2s(cmax, places);
+		if (maxStr.indexOf("-")!=-1) {
+			for (int i=places; i<=6; i++) {
+				maxStr = ResultsTable.d2s(cmax, i);
+				if (maxStr.indexOf("-")==-1) break;
+			}
+		}
+		if (scaled)
+			gd.setInsets(5, 0, 0);
+		gd.addStringField("Size ("+units+"):", minStr+"-"+maxStr, 12);
+		if (scaled) {
+			gd.setInsets(0, 40, 5);
+			gd.addCheckbox("Pixel units", pixelUnits);
+		}
+		gd.addStringField("Circularity:", IJ.d2s(minCircularity)+"-"+IJ.d2s(maxCircularity), 12);
+		gd.addChoice("Show:", showStrings2, showStrings[showChoice]);
+		String[] labels = new String[8];
+		boolean[] states = new boolean[8];
+		labels[0]="Display results"; states[0] = (options&SHOW_RESULTS)!=0;
+		labels[1]="Exclude on edges"; states[1]=(options&EXCLUDE_EDGE_PARTICLES)!=0;
+		labels[2]="Clear results"; states[2]=(options&CLEAR_WORKSHEET)!=0;
+		labels[3]="Include holes"; states[3]=(options&INCLUDE_HOLES)!=0;
+		labels[4]="Summarize"; states[4]=(options&DISPLAY_SUMMARY)!=0;
+		labels[5]="Overlay"; states[5]=(options&OVERLAY)!=0;
+		labels[6]="Add to Manager"; states[6]=(options&ADD_TO_MANAGER)!=0;
+		labels[7]="Composite ROIs"; states[7]=(options&COMPOSITE_ROIS)!=0;
+		gd.addCheckboxGroup(4, 2, labels, states);
+		gd.addHelp(IJ.URL+"/docs/menus/analyze.html#ap");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return false;
+			
+		gd.setSmartRecording(minSize==0.0&&maxSize==Double.POSITIVE_INFINITY);
+		String size = gd.getNextString(); // min-max size
+		if (scaled)
+			pixelUnits = gd.getNextBoolean();
+		if (pixelUnits)
+			unitSquared = 1.0;
+		else
+			unitSquared = cal.pixelWidth*cal.pixelHeight;
+		String[] minAndMax = Tools.split(size, " -");
+		double mins = minAndMax.length>=1?gd.parseDouble(minAndMax[0]):0.0;
+		double maxs = minAndMax.length==2?gd.parseDouble(minAndMax[1]):Double.NaN;
+		minSize = Double.isNaN(mins)?DEFAULT_MIN_SIZE:mins/unitSquared;
+		maxSize = Double.isNaN(maxs)?DEFAULT_MAX_SIZE:maxs/unitSquared;
+		if (minSize<DEFAULT_MIN_SIZE) minSize = DEFAULT_MIN_SIZE;
+		if (maxSize<minSize) maxSize = DEFAULT_MAX_SIZE;
+		staticMinSize = minSize;
+		staticMaxSize = maxSize;
+		
+		gd.setSmartRecording(minCircularity==0.0&&maxCircularity==1.0);
+		minAndMax = Tools.split(gd.getNextString(), " -"); // min-max circularity
+		double minc = minAndMax.length>=1?gd.parseDouble(minAndMax[0]):0.0;
+		double maxc = minAndMax.length==2?gd.parseDouble(minAndMax[1]):Double.NaN;
+		minCircularity = Double.isNaN(minc)?0.0:minc;
+		maxCircularity = Double.isNaN(maxc)?1.0:maxc;
+		if (minCircularity<0.0) minCircularity = 0.0;
+		if (minCircularity>maxCircularity && maxCircularity==1.0) minCircularity = 0.0;
+		if (minCircularity>maxCircularity) minCircularity = maxCircularity;
+		if (maxCircularity<minCircularity) maxCircularity = minCircularity;
+		if (minCircularity==1.0 && maxCircularity==1.0) minCircularity = 0.0;
+		staticMinCircularity = minCircularity;
+		staticMaxCircularity = maxCircularity;
+		
+		if (gd.invalidNumber()) {
+			IJ.error("Bins invalid.");
+			canceled = true;
+			return false;
+		}
+		gd.setSmartRecording(showChoice==0);
+		showChoice = showStringOrder[gd.getNextChoiceIndex()];
+		gd.setSmartRecording(false);
+		staticShowChoice = showChoice;
+		if (gd.getNextBoolean())
+			options |= SHOW_RESULTS; else options &= ~SHOW_RESULTS;
+		if (gd.getNextBoolean())
+			options |= EXCLUDE_EDGE_PARTICLES; else options &= ~EXCLUDE_EDGE_PARTICLES;
+		if (gd.getNextBoolean())
+			options |= CLEAR_WORKSHEET; else options &= ~CLEAR_WORKSHEET;
+		if (gd.getNextBoolean())
+			options |= INCLUDE_HOLES; else options &= ~INCLUDE_HOLES;
+		if (gd.getNextBoolean())
+			options |= DISPLAY_SUMMARY; else options &= ~DISPLAY_SUMMARY;
+		if (gd.getNextBoolean())
+			options |= OVERLAY; else options &= ~OVERLAY;
+		if (gd.getNextBoolean())
+			options |= ADD_TO_MANAGER; else options &= ~ADD_TO_MANAGER;
+		if (gd.getNextBoolean())
+			options |= COMPOSITE_ROIS; else options &= ~COMPOSITE_ROIS;
+		staticOptions = options;
+		options |= SHOW_PROGRESS;
+		if ((options&DISPLAY_SUMMARY)!=0)
+			Analyzer.setMeasurements(Analyzer.getMeasurements()|AREA);
+		return true;
+	}
+	
+	private boolean isThresholdedRGB(ImagePlus imp) {
+		Object obj = imp.getProperty("Mask");
+		if (obj==null || !(obj instanceof ImageProcessor))
+			return false;
+		ImageProcessor mask = (ImageProcessor)obj;
+		return mask.getWidth()==imp.getWidth() && mask.getHeight()==imp.getHeight();
+	}
+
+	boolean updateMacroOptions() {
+		String options = Macro.getOptions();
+		options = options.replace("show=[Overlay Outlines]", "show=Overlay");
+		Macro.setOptions(options);
+		int index = options.indexOf("maximum=");
+		if (index==-1)
+			return false;
+		index +=8;
+		int len = options.length();
+		while (index<len-1 && options.charAt(index)!=' ')
+			index++;
+		if (index==len-1)
+			return false;
+		int min = (int)Tools.parseDouble(Macro.getValue(options, "minimum", "1"));
+		int max = (int)Tools.parseDouble(Macro.getValue(options, "maximum", "999999"));
+		options = "size="+min+"-"+max+options.substring(index, len);
+		Macro.setOptions(options);
+		return true;
+	}
+
+	/** Performs particle analysis on the specified image. Returns
+		false if there is an error. */
+	public boolean analyze(ImagePlus imp) {
+		return analyze(imp, imp.getProcessor());
+	}
+
+	/** Performs particle analysis on the specified ImagePlus and
+		ImageProcessor. Returns false if there is an error. */
+	public boolean analyze(ImagePlus imp, ImageProcessor ip) {
+		if (this.imp==null) this.imp = imp;
+		showResults = (options&SHOW_RESULTS)!=0;
+		excludeEdgeParticles = (options&EXCLUDE_EDGE_PARTICLES)!=0;
+		resetCounter = (options&CLEAR_WORKSHEET)!=0;
+		showProgress = (options&SHOW_PROGRESS)!=0;
+		floodFill = (options&INCLUDE_HOLES)==0;
+		if ((options&RECORD_STARTS)!=0)
+			recordStarts = true;
+		showOverlay = (options&OVERLAY)!=0;
+		addToManager = (options&ADD_TO_MANAGER)!=0;
+		if (staticRoiManager!=null) {
+			addToManager = true;
+			roiManager = staticRoiManager;
+			staticRoiManager = null;
+		}
+		hyperstack = imp.isHyperStack();
+		if (staticResultsTable!=null) {
+			rt = staticResultsTable;
+			staticResultsTable = null;
+			showResultsTable = false;
+		}
+		if (staticSummaryTable!=null) {
+			summaryTable = staticSummaryTable;
+			staticSummaryTable = null;
+			showSummaryTable = false;
+		}
+		displaySummary = (options&DISPLAY_SUMMARY)!=0 ||  (options&SHOW_SUMMARY)!=0;
+		compositeRois = (options&COMPOSITE_ROIS)!=0;
+		outputImage = null;
+		ip.snapshot();
+		ip.setProgressBar(null);
+		if (Analyzer.isRedirectImage()) {
+			redirectImp = Analyzer.getRedirectImage(imp);
+			if (redirectImp==null) return false;
+			int depth = redirectImp.getStackSize();
+			if (depth>1 && depth==imp.getStackSize()) {
+				ImageStack redirectStack = redirectImp.getStack();
+				redirectIP = redirectStack.getProcessor(imp.getCurrentSlice());
+			} else
+				redirectIP = redirectImp.getProcessor();
+		} else if (imp.getType()==ImagePlus.COLOR_RGB) {
+			ImagePlus original = (ImagePlus)imp.getProperty("OriginalImage");
+			if (original!=null && original.getWidth()==imp.getWidth() && original.getHeight()==imp.getHeight()) {
+				redirectImp = original;
+				redirectIP = original.getProcessor();
+			}
+		}
+		if (!setThresholdLevels(imp, ip))
+			return false;
+		width = ip.getWidth();
+		height = ip.getHeight();
+		if (inSituShow && showChoice==NOTHING)
+			showChoice = OUTLINES;
+		if (!(showChoice==NOTHING||showChoice==OVERLAY_OUTLINES||showChoice==OVERLAY_MASKS)) {
+			blackBackground = Prefs.blackBackground && inSituShow;
+			if (slice==1)
+				outlines = new ImageStack(width, height);
+			if (showChoice==ROI_MASKS)
+				drawIP = new ShortProcessor(width, height);
+			else
+				drawIP = new ByteProcessor(width, height);
+			drawIP.setLineWidth(lineWidth);
+			if (showChoice==ROI_MASKS)
+				{} // Place holder for now...
+			else if (showChoice==MASKS&&!blackBackground)
+				drawIP.invertLut();
+			else if (showChoice==OUTLINES) {
+				if (!inSituShow) {
+					if (customLut==null)
+						makeCustomLut();
+					drawIP.setColorModel(customLut);
+				}
+				drawIP.setFont(new Font("SansSerif", Font.PLAIN, fontSize));
+				if (fontSize>12 && inSituShow)
+					drawIP.setAntialiasedText(true);
+			} 
+			outlines.addSlice(null, drawIP);
+
+			if (showChoice==ROI_MASKS || blackBackground) {
+				drawIP.setColor(Color.black);
+				drawIP.fill();
+				drawIP.setColor(Color.white);
+			} else {
+				drawIP.setColor(Color.white);
+				drawIP.fill();
+				drawIP.setColor(Color.black);
+			}
+		}
+		calibration = redirectImp!=null?redirectImp.getCalibration():imp.getCalibration();
+		
+		if (measurements==0)
+			measurements = Analyzer.getMeasurements();
+		measurements &= ~LIMIT;	 // ignore "Limit to Threshold"
+		if (rt==null) {
+			Frame table = WindowManager.getFrame("Results");
+			if (!showResults && table!=null) {
+				rt = new ResultsTable();
+				if (resetCounter && table instanceof TextWindow) {
+					IJ.run("Clear Results");
+					((TextWindow)table).close();
+					rt = Analyzer.getResultsTable();
+				}
+			} else
+				rt = Analyzer.getResultsTable();
+		}
+		analyzer = new Analyzer(imp, measurements, rt);
+		if (resetCounter && slice==1 && rt.size()>0) {
+			if (!Analyzer.resetCounter())
+				return false;
+		}
+		beginningCount = Analyzer.getCounter();
+
+		byte[] pixels = null;
+		if (ip instanceof ByteProcessor)
+			pixels = (byte[])ip.getPixels();
+		if (r==null) {
+			r = ip.getRoi();
+			mask = ip.getMask();
+			if (displaySummary) {
+				if (mask!=null)
+					totalArea = ImageStatistics.getStatistics(ip, AREA, calibration).area;
+				else
+					totalArea = r.width*calibration.pixelWidth*r.height*calibration.pixelHeight;
+			}
+		}
+		minX=r.x; maxX=r.x+r.width; minY=r.y; maxY=r.y+r.height;
+		if (r.width<width || r.height<height || mask!=null) {
+			if (!eraseOutsideRoi(ip, r, mask)) return false;
+		}
+		int offset;
+		double value;
+		int inc = Math.max(r.height/25, 1);
+		int mi = 0;
+		ImageWindow win = imp.getWindow();
+		if (win!=null)
+			win.running = true;
+		if (showChoice==ELLIPSES)
+			measurements |= ELLIPSE;
+		roiNeedsImage = (measurements&PERIMETER)!=0 || (measurements&SHAPE_DESCRIPTORS)!=0 || (measurements&FERET)!=0;
+		particleCount = 0;
+		wand = new Wand(ip);
+		pf = new PolygonFiller();
+		if (floodFill) {
+			ImageProcessor ipf = ip.duplicate();
+			ipf.setValue(fillColor);
+			ff = new FloodFiller(ipf);
+		}
+		roiType = Wand.allPoints()?Roi.FREEROI:Roi.TRACED_ROI;
+
+		boolean done = false;
+		for (int y=r.y; y<(r.y+r.height); y++) {
+			offset = y*width;
+			for (int x=r.x; x<(r.x+r.width); x++) {
+				if (pixels!=null)
+					value = pixels[offset+x]&255;
+				else if (imageType==SHORT)
+					value = ip.getPixel(x, y);
+				else
+					value = ip.getPixelValue(x, y);
+				if (value>=level1 && value<=level2 && !done) {
+					analyzeParticle(x, y, imp, ip);
+					done = level1==0.0&&level2==255.0&&imp.getBitDepth()==8;
+				}
+			}
+			if (showProgress && ((y%inc)==0))
+				IJ.showProgress((double)(y-r.y)/r.height);
+			if (win!=null)
+				canceled = !win.running;
+			if (canceled) {
+				Macro.abort();
+				break;
+			}
+		}
+		if (showProgress)
+			IJ.showProgress(1.0);
+		if (showResults && showResultsTable && rt.size()>0)
+			rt.updateResults();
+		imp.deleteRoi();
+		ip.resetRoi();
+		ip.reset();
+		if (displaySummary)
+			updateSliceSummary();
+		if (addToManager && roiManager!=null)
+			roiManager.setEditMode(imp, true);
+		maxParticleCount = (particleCount > maxParticleCount) ? particleCount : maxParticleCount;
+		totalCount += particleCount;
+		if (!canceled)
+			showResults();
+		return true;
+	}
+	
+	void updateSliceSummary() {
+		int slices = imp.getStackSize();
+		if (slices==1) {
+			Frame frame = WindowManager.getFrame("Summary");
+			if (frame!=null && (frame instanceof TextWindow)) {
+				TextWindow tw = (TextWindow)frame;
+				ResultsTable table = tw.getTextPanel().getResultsTable();
+				if (table!= null)
+					summaryTable = table;
+			}
+		} else {
+			Frame frame = WindowManager.getFrame("Summary of "+imp.getTitle());
+			if (frame!=null && (frame instanceof TextWindow)) {
+				TextWindow tw = (TextWindow)frame;
+				ResultsTable table = tw.getTextPanel().getResultsTable();
+				if (table!= null)
+					summaryTable = table;
+			}
+		}
+		if (summaryTable==null)
+			summaryTable = new ResultsTable();
+		float[] areas = rt.getColumn(ResultsTable.AREA);
+		if (areas==null)
+			areas = new float[0];
+		String label = imp.getTitle();
+		if (slices>1) {
+			if (processStack)
+				label = imp.getStack().getShortSliceLabel(slice);
+			else
+				label = imp.getStack().getShortSliceLabel(imp.getCurrentSlice());
+			label = label!=null&&!label.equals("")?label:""+slice;
+		}
+		summaryTable.incrementCounter();
+		summaryTable.addValue("Slice", label);
+
+		double sum = 0.0;
+		int start = areas.length-particleCount;
+		if (start<0)
+			return;
+		for (int i=start; i<areas.length; i++)
+			sum += areas[i];
+		int places = Analyzer.getPrecision();
+		Calibration cal = imp.getCalibration();
+		summaryTable.addValue("Count", particleCount);
+		summaryTable.addValue("Total Area", sum);
+		summaryTable.addValue("Average Size", sum/particleCount);
+		summaryTable.addValue("%Area", sum*100.0/totalArea);
+		addMeans(areas.length>0?start:-1);
+		String title = slices==1?"Summary":"Summary of "+imp.getTitle();
+		if (showSummaryTable)
+			summaryTable.show(title);
+	}
+
+ 	void addMeans(int start) {
+		if ((measurements&MEAN)!=0) addMean(ResultsTable.MEAN, start);
+		if ((measurements&MODE)!=0) addMean(ResultsTable.MODE, start);
+		if ((measurements&PERIMETER)!=0)
+			addMean(ResultsTable.PERIMETER, start);
+		if ((measurements&ELLIPSE)!=0) {
+			addMean(ResultsTable.MAJOR, start);
+			addMean(ResultsTable.MINOR, start);
+			addMean(ResultsTable.ANGLE, start);
+		}
+		if ((measurements&SHAPE_DESCRIPTORS)!=0) {
+			addMean(ResultsTable.CIRCULARITY, start);
+			addMean(ResultsTable.SOLIDITY, start);
+		}
+		if ((measurements&FERET)!=0) {
+			addMean(ResultsTable.FERET, start);
+			addMean(ResultsTable.FERET_X, start);
+			addMean(ResultsTable.FERET_Y, start);
+			addMean(ResultsTable.FERET_ANGLE, start);
+			addMean(ResultsTable.MIN_FERET, start);
+		}
+		if ((measurements&INTEGRATED_DENSITY)!=0)
+			addMean(ResultsTable.INTEGRATED_DENSITY, start);
+		if ((measurements&MEDIAN)!=0)
+			addMean(ResultsTable.MEDIAN, start);
+		if ((measurements&SKEWNESS)!=0)
+			addMean(ResultsTable.SKEWNESS, start);
+		if ((measurements&KURTOSIS)!=0)
+			addMean(ResultsTable.KURTOSIS, start);
+	}
+
+	private void addMean(int column, int start) {
+		double value = Double.NaN;
+		if (start!=-1) {
+			float[] c = column>=0?rt.getColumn(column):null;
+			if (c!=null) {
+				ImageProcessor ip = new FloatProcessor(c.length, 1, c, null);
+				if (ip==null) return;
+				ip.setRoi(start, 0, ip.getWidth()-start, 1);
+				ip = ip.crop();
+				ImageStatistics stats = new FloatStatistics(ip);
+				if (stats==null)
+					return;
+				value = stats.mean;
+			}
+		}
+		summaryTable.addValue(ResultsTable.getDefaultHeading(column), value);
+	}
+
+	boolean eraseOutsideRoi(ImageProcessor ip, Rectangle r, ImageProcessor mask) {
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		ip.setRoi(r);
+		if (excludeEdgeParticles && exclusionRoi!=null) {
+			ImageStatistics stats = ImageStatistics.getStatistics(ip, MIN_MAX, null);
+			if (fillColor>=stats.min && fillColor<=stats.max) {
+				double replaceColor = level1-1.0;
+				if (replaceColor<0.0 || replaceColor==fillColor) {
+					replaceColor = level2+1.0;
+					int maxColor = imageType==BYTE?255:65535;
+					if (replaceColor>maxColor || replaceColor==fillColor) {
+						IJ.error("Particle Analyzer", "Unable to remove edge particles");
+						return false;
+					}
+				}
+				for (int y=minY; y<maxY; y++) {
+					for (int x=minX; x<maxX; x++) {
+						int v  = ip.getPixel(x, y);
+						if (v==fillColor) ip.putPixel(x, y, (int)replaceColor);
+					}
+				}
+			}
+		}
+		ip.setValue(fillColor);		
+		if (mask!=null) {
+			mask = mask.duplicate();
+			mask.invert();
+			ip.fill(mask);
+		}		
+		ip.setRoi(0, 0, r.x, height);
+		ip.fill();
+		ip.setRoi(r.x, 0, r.width, r.y);
+		ip.fill();
+		ip.setRoi(r.x, r.y+r.height, r.width, height-(r.y+r.height));
+		ip.fill();
+		ip.setRoi(r.x+r.width, 0, width-(r.x+r.width), height);
+		ip.fill();
+		ip.resetRoi();
+		return true;
+	}
+
+	boolean setThresholdLevels(ImagePlus imp, ImageProcessor ip) {
+		double t1 = ip.getMinThreshold();
+		double t2 = ip.getMaxThreshold();
+		boolean invertedLut = imp.isInvertedLut();
+		boolean byteImage = ip instanceof ByteProcessor;
+		if (ip instanceof ShortProcessor)
+			imageType = SHORT;
+		else if (ip instanceof FloatProcessor)
+			imageType = FLOAT;
+		else
+			imageType = BYTE;
+		if (t1==ImageProcessor.NO_THRESHOLD) {
+			noThreshold = true;
+			ImageStatistics stats = imp.getRawStatistics();
+			if (imageType!=BYTE || (stats.histogram[0]+stats.histogram[255]!=stats.pixelCount)) {
+				IJ.error("Particle Analyzer",
+					"A threshold has not been set using the\n"
+					+"Image->Adjust->Threshold tool or the \n"
+					+"setThreshold(min,max) macro function.");
+				canceled = true;
+				return false;
+			}
+			level1 = 255;
+			level2 = 255;
+			fillColor = 64;
+			if (!Prefs.blackBackground && !imp.isInvertedLut()) {
+				level1 = 0;
+				level2 = 0;
+				fillColor = 192;
+			}
+			if (!IJ.isMacro())
+				IJ.log("ParticleAnalyzer: threshold not set; assumed to be "+(int)level1+"-"+(int)level2);
+		} else {
+			level1 = t1;
+			level2 = t2;
+			if (imageType==BYTE) {
+				if (level1>0)
+					fillColor = 0;
+				else if (level2<255)
+					fillColor = 255;
+			} else if (imageType==SHORT) {
+				if (level1>0)
+					fillColor = 0;
+				else if (level2<65535)
+					fillColor = 65535;
+			} else if (imageType==FLOAT)
+					fillColor = -Float.MAX_VALUE;
+			else
+				return false;
+		}
+		imageType2 = imageType;
+		if (redirectIP!=null) {
+			if (redirectIP instanceof ShortProcessor)
+				imageType2 = SHORT;
+			else if (redirectIP instanceof FloatProcessor)
+				imageType2 = FLOAT;
+			else if (redirectIP instanceof ColorProcessor)
+				imageType2 = RGB;
+			else
+				imageType2 = BYTE;
+		}
+		return true;
+	}
+		
+	void analyzeParticle(int x, int y, ImagePlus imp, ImageProcessor ip) {
+		ImageProcessor ip2 = redirectIP!=null?redirectIP:ip;
+		wand.autoOutline(x, y, level1, level2, wandMode);
+		if (wand.npoints==0)
+			{IJ.log("wand error: "+x+" "+y); return;}
+		Roi roi = new PolygonRoi(wand.xpoints, wand.ypoints, wand.npoints, roiType);
+		Rectangle r = roi.getBounds();
+		if (r.width>1 && r.height>1) {
+			PolygonRoi proi = (PolygonRoi)roi;
+			pf.setPolygon(proi.getXCoordinates(), proi.getYCoordinates(), proi.getNCoordinates());
+			ip2.setMask(pf.getMask(r.width, r.height));
+			if (floodFill) ff.particleAnalyzerFill(x, y, level1, level2, ip2.getMask(), r);
+		}
+		ip2.setRoi(r);
+		ip.setValue(fillColor);
+		ImageStatistics stats = getStatistics(ip2, measurements, calibration);
+		boolean include = true;
+		if (excludeEdgeParticles) {
+			if (r.x==minX||r.y==minY||r.x+r.width==maxX||r.y+r.height==maxY)
+				include = false;
+			if (exclusionRoi!=null && include) {
+				// Exclude particle if any point along boundary is not contained in roi.
+				Rectangle bounds = roi.getBounds();
+				int x1=bounds.x+wand.xpoints[wand.npoints-1];
+				int y1=bounds.y+wand.ypoints[wand.npoints-1];
+				int x2, y2;
+				for (int i=0; i<wand.npoints; i++) {
+					x2=bounds.x+wand.xpoints[i];
+					y2=bounds.y+wand.ypoints[i];
+					if (!exclusionRoi.contains(x2, y2))
+						{include = false; break;}
+					if ((x1==x2 && ip.getPixel(x1,y1-1)==fillColor) || (y1==y2 && ip.getPixel(x1-1,y1)==fillColor))
+						{include = false; break;}
+					x1=x2; y1=y2;
+				}
+			}
+		}
+		ImageProcessor mask = ip2.getMask();
+		if (compositeRois && floodFill && mask!=null) {
+			mask.setThreshold(255, 255, ImageProcessor.NO_LUT_UPDATE);
+			Roi roi2 = new ThresholdToSelection().convert(mask);
+			if (roi2!=null && (roi2 instanceof ShapeRoi)) {
+				roi2.setLocation(roi.getXBase(), roi.getYBase());
+				roi = roi2;
+			}
+		}
+		if (minCircularity>0.0 || maxCircularity!=1.0) {
+			double perimeter = roi.getLength();
+			double circularity = perimeter==0.0?0.0:4.0*Math.PI*(stats.pixelCount/(perimeter*perimeter));
+			if (circularity>1.0 && maxCircularity<=1.0) circularity = 1.0;
+			if (circularity<minCircularity || circularity>maxCircularity) include = false;
+		}
+		if (stats.pixelCount>=minSize && stats.pixelCount<=maxSize && include) {
+			particleCount++;
+			if (roiNeedsImage)
+				roi.setImage(imp);
+			stats.xstart=x; stats.ystart=y;
+			saveResults(stats, roi);
+			if (addToManager)
+				addToRoiManager(roi, mask, particleCount);
+			int saveShowChoice = showChoice;
+			if (showOverlay && showChoice==NOTHING)
+				showChoice = OVERLAY_OUTLINES;
+			if (showChoice!=NOTHING)
+				drawParticle(drawIP, roi, stats, mask);
+			showChoice = saveShowChoice;
+		}
+		ip.setRoi(r);
+		ip.fill(mask);
+	}
+
+	ImageStatistics getStatistics(ImageProcessor ip, int mOptions, Calibration cal) {
+		switch (imageType2) {
+			case BYTE:
+				return new ByteStatistics(ip, mOptions, cal);
+			case SHORT:
+				return new ShortStatistics(ip, mOptions, cal);
+			case FLOAT:
+				return new FloatStatistics(ip, mOptions, cal);
+			case RGB:
+				return new ColorStatistics(ip, mOptions, cal);
+			default:
+				return null;
+		}
+	}
+
+	/** Saves statistics for one particle in a results table. This is
+		a method subclasses can override. */
+	protected void saveResults(ImageStatistics stats, Roi roi) {
+		analyzer.saveResults(stats, roi);
+		if (maxCircularity>1.0 && rt.columnExists("Circ.") && rt.getValue("Circ.", rt.size()-1)==1.0) {
+			double perimeter = roi.getLength();
+			double circularity = perimeter==0.0?0.0:4.0*Math.PI*(stats.pixelCount/(perimeter*perimeter));
+			rt.addValue("Circ.", circularity);
+		}
+		if (recordStarts) {
+			rt.addValue("XStart", stats.xstart);
+			rt.addValue("YStart", stats.ystart);
+		}
+		if (showResultsTable && showResults)
+			rt.addResults();
+	}
+	
+	/** Adds the ROI to the ROI Manager. */
+	private void addToRoiManager(Roi roi, ImageProcessor mask, int particleNumber) {
+		if (roiManager==null) {
+			if (Macro.getOptions()!=null && Interpreter.isBatchMode())
+				roiManager = Interpreter.getBatchModeRoiManager();
+			if (roiManager==null) {
+				Frame frame = WindowManager.getFrame("ROI Manager");
+				if (frame==null)
+					IJ.run("ROI Manager...");
+				frame = WindowManager.getFrame("ROI Manager");
+				if (frame==null || !(frame instanceof RoiManager))
+					{addToManager=false; return;}
+				roiManager = (RoiManager)frame;
+			}
+			if (resetCounter)
+				roiManager.runCommand("reset");
+		}
+		if (imp.getStackSize()>1) {
+			int n = imp.getCurrentSlice();
+			if (hyperstack) {
+				int[] pos = imp.convertIndexToPosition(n);
+				roi.setPosition(pos[0],pos[1],pos[2]);
+			} else
+				roi.setPosition(n);
+		}
+		if (lineWidth!=1)
+			roi.setStrokeWidth(lineWidth);
+		roiManager.add(imp, roi, particleNumber);
+	}
+	
+	/** Draws a selected particle in a separate image.	This is
+		another method subclasses may want to override. */
+	protected void drawParticle(ImageProcessor drawIP, Roi roi, ImageStatistics stats, ImageProcessor mask) {
+		switch (showChoice) {
+			case MASKS: drawFilledParticle(drawIP, roi, mask); break;
+			case OUTLINES: case BARE_OUTLINES: case OVERLAY_OUTLINES: case OVERLAY_MASKS:
+				drawOutline(drawIP, roi, mask, rt.size()); break;
+			case ELLIPSES: drawEllipse(drawIP, stats, rt.size()); break;
+			case ROI_MASKS: drawRoiFilledParticle(drawIP, roi, mask, rt.size()); break;
+			default:
+		}
+	}
+
+	void drawFilledParticle(ImageProcessor ip, Roi roi, ImageProcessor mask) {
+		ip.setRoi(roi.getBounds());
+		ip.fill(mask);
+	}
+
+	void drawOutline(ImageProcessor ip, Roi roi, ImageProcessor mask, int count) {
+		if (showChoice==OVERLAY_OUTLINES || showChoice==OVERLAY_MASKS) {
+			if (overlay==null) {
+				overlay = new Overlay();
+				overlay.drawLabels(true);
+				overlay.setLabelFont(new Font("SansSerif", Font.PLAIN, fontSize));
+				overlay.setDraggable(false);
+			}
+			Roi roi2 = (Roi)roi.clone();
+			roi2.setStrokeColor(Color.cyan);
+			if (lineWidth!=1)
+				roi2.setStrokeWidth(lineWidth);
+			if (showChoice==OVERLAY_MASKS)
+				roi2.setFillColor(getMaskColor(count-1));
+			if (processStack || imp.getStackSize()>1) {
+				int currentSlice = slice;
+				if (!processStack)
+					currentSlice = imp.getCurrentSlice();
+				if (hyperstack) {
+					int[] pos = imp.convertIndexToPosition(currentSlice);
+					roi2.setPosition(pos[0],pos[1],pos[2]);
+				} else
+					roi2.setPosition(currentSlice);
+			}
+			if (showResults)
+				roi2.setName(""+count);
+			overlay.add(roi2);
+		} else {
+			Rectangle r = roi.getBounds();
+			if (!inSituShow)
+				ip.setValue(0.0);
+			if (roi instanceof PolygonRoi) {
+				int nPoints = ((PolygonRoi)roi).getNCoordinates();
+				int[] xp = ((PolygonRoi)roi).getXCoordinates();
+				int[] yp = ((PolygonRoi)roi).getYCoordinates();
+				int x=r.x, y=r.y;
+				ip.moveTo(x+xp[0], y+yp[0]);
+				for (int i=1; i<nPoints; i++)
+					ip.lineTo(x+xp[i], y+yp[i]);
+				ip.lineTo(x+xp[0], y+yp[0]);
+			} else
+				roi.drawPixels(ip);
+			if (showChoice!=BARE_OUTLINES) {
+				String s = ResultsTable.d2s(count,0);
+				ip.moveTo(r.x+r.width/2-ip.getStringWidth(s)/2, r.y+r.height/2+fontSize/2);
+				if (!inSituShow)
+					ip.setValue(1.0);
+				ip.drawString(s);
+			}
+		}
+	}
+
+	private static Color getMaskColor(int index) {
+		Color color = Color.cyan;
+		if (index<0) index=0;
+		if (glasbeyLut==null) {
+			String path = IJ.getDir("luts")+"Glasbey.lut";
+			glasbeyLut = LutLoader.openLut("noerror:"+path);
+			if (glasbeyLut==null) {
+				path = IJ.getDir("luts")+"glasbey.lut";
+				glasbeyLut = LutLoader.openLut("noerror:"+path);
+			}
+			if (glasbeyLut==null)
+				IJ.log("LUT not found: "+path);
+		}
+		if (glasbeyLut!=null)
+			color = new Color(glasbeyLut.getRGB(index+5)); // skip problematic white and black entries
+		return color;
+	}
+
+	void drawEllipse(ImageProcessor ip, ImageStatistics stats, int count) {
+		stats.drawEllipse(ip);
+	}
+
+	void drawRoiFilledParticle(ImageProcessor ip, Roi roi, ImageProcessor mask, int count) {
+		int grayLevel = (count < 65535) ? count : 65535;
+		ip.setValue((double) grayLevel); 
+		ip.setRoi(roi.getBounds());
+		ip.fill(mask);
+	}
+
+	void showResults() {
+		int count = rt.size();
+		// if (count==0) return;
+		boolean lastSlice = !processStack||slice==imp.getStackSize();
+		if ((showOverlay||showChoice==OVERLAY_OUTLINES||showChoice==OVERLAY_MASKS) && overlay!=null && count>0 && (!processStack||slice==imp.getStackSize())) {
+			if (processStack)
+				imp.setOverlay(overlay);
+			else {
+				Overlay overlay0 = imp.getOverlay();
+				if (overlay0==null || imp.getStackSize()==1)
+					imp.setOverlay(overlay);
+				else {
+					for (int i=0; i<overlay.size(); i++)
+						overlay0.add(overlay.get(i));
+					imp.setOverlay(overlay0);
+				}
+			}
+		} else if (outlines!=null && lastSlice) {
+			String title = imp!=null?imp.getTitle():"Outlines";
+			String prefix;
+			if (showChoice == MASKS)
+				prefix = "Mask of ";
+			else if (showChoice == ROI_MASKS)
+				prefix = "Count Masks of ";
+			else
+				prefix = "Drawing of ";
+			outlines.update(drawIP);
+			outputImage = new ImagePlus(prefix+title, outlines);
+			outputImage.setCalibration(imp.getCalibration());
+			if (inSituShow) {
+				if (imp.getStackSize()==1 && !Recorder.record)
+					Undo.setup(Undo.TRANSFORM, imp);
+				ImageStack outputStack = outputImage.getStack();
+				if (imp.getStackSize()>1 && outputStack.getSize()==1 && imp.getBitDepth()==8)
+					imp.setProcessor(outputStack.getProcessor(1));
+				else
+					imp.setStack(null, outputStack);
+			} else if (!hideOutputImage)
+				outputImage.show();
+		}
+		if (showResults && !processStack) {
+			if (showResultsTable && rt.size()>0) {
+				TextPanel tp = IJ.getTextPanel();
+				if (beginningCount>0 && tp!=null && tp.getLineCount()!=count)
+					rt.show("Results");
+			}
+			Analyzer.firstParticle = beginningCount;
+			Analyzer.lastParticle = Analyzer.getCounter()-1;
+		} else
+			Analyzer.firstParticle = Analyzer.lastParticle = 0;
+		if (showResults && rt.size()==0 && !(IJ.isMacro()||calledByPlugin) && (!processStack||slice==imp.getStackSize())) {
+			int digits = (int)level1==level1&&(int)level2==level2?0:2;
+			String range = IJ.d2s(level1,digits)+"-"+IJ.d2s(level2,digits);
+			String assummed = noThreshold?"assumed":"";
+			IJ.showMessage("Particle Analyzer", "No particles were detected. The "+assummed+"\nthreshold ("+range+") may not be correct.");
+		}
+	}
+	
+	/** Returns the "Outlines", "Masks", "Elipses" or "Count Masks" image,
+		or null if "Nothing" is selected in the "Show:" menu. */
+	public ImagePlus getOutputImage() {
+		return outputImage;
+	}
+
+	/** Set 'hideOutputImage' true to not display the "Show:" image. */
+	public void setHideOutputImage(boolean hideOutputImage) {
+		this.hideOutputImage = hideOutputImage;
+	}
+
+	/** Sets the size of the font used to label outlines in the next particle analyzer instance. */
+	public static void setFontSize(int size) {
+		nextFontSize = size;
+	}
+
+	/** Sets the color ("blue", "black", etc.) of the font used to label outlines in the next particle analyzer instance. */
+	public static void setFontColor(String color) {
+		nextFontColor = Colors.decode(color, defaultFontColor);
+	}
+
+	/** Sets the outline line width for the next ParticleAnalyzer instance. */
+	public static void setLineWidth(int width) {
+		nextLineWidth = width;
+	}
+	
+	/** Sets the RoiManager to be used by the next ParticleAnalyzer 
+		instance. There is a JavaScript example at
+		http://imagej.nih.gov/ij/macros/js/HiddenRoiManager.js
+	*/
+	public static void setRoiManager(RoiManager manager) {
+		staticRoiManager = manager;
+	}
+	
+	/** Sets the ResultsTable to be used by the next  
+		ParticleAnalyzer instance.	*/
+	public static void setResultsTable(ResultsTable rt) {
+		staticResultsTable = rt;
+	}
+
+	/** Sets the ResultsTable to be used by the next  
+		ParticleAnalyzer instance for the summary.	*/
+	public static void setSummaryTable(ResultsTable rt) {
+		staticSummaryTable = rt;
+	}
+
+	int getColumnID(String name) {
+		int id = rt.getFreeColumn(name);
+		if (id==ResultsTable.COLUMN_IN_USE)
+			id = rt.getColumnIndex(name);
+		return id;
+	}
+
+	void makeCustomLut() {
+		IndexColorModel cm = (IndexColorModel)LookUpTable.createGrayscaleColorModel(false);
+		byte[] reds = new byte[256];
+		byte[] greens = new byte[256];
+		byte[] blues = new byte[256];
+		cm.getReds(reds);
+		cm.getGreens(greens);
+		cm.getBlues(blues);
+		reds[1] =(byte)fontColor.getRed();
+		greens[1] = (byte)fontColor.getGreen();;
+		blues[1] = (byte)fontColor.getBlue();;
+		customLut = new IndexColorModel(8, 256, reds, greens, blues);
+	}
+
+	/** Called once when ImageJ quits. */
+	public static void savePreferences(Properties prefs) {
+		prefs.put(OPTIONS, Integer.toString(staticOptions));
+	}
+
+}
diff --git a/src/ij/plugin/filter/PlugInFilter.java b/src/ij/plugin/filter/PlugInFilter.java
new file mode 100644
index 0000000..45c144e
--- /dev/null
+++ b/src/ij/plugin/filter/PlugInFilter.java
@@ -0,0 +1,93 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+
+/** ImageJ plugins that process an image should implement this interface.
+ *  For filters that have a dialog asking for options or parameters as well
+ *  as for filters that have a progress bar and process stacks the
+ *  ExtendedPlugInFilter interface is recommended.
+ */
+public interface PlugInFilter {
+
+	/** This method is called once when the filter is loaded. 'arg',
+		which may be blank, is the argument specified for this plugin 
+		in IJ_Props.txt or in the plugins.config file of a jar archive
+        containing the plugin. 'imp' is the currently active image.
+		This method should return a flag word that specifies the
+		filters capabilities.
+        <p>
+        For Plugin-filters specifying the {@link #FINAL_PROCESSING} flag,
+        the setup method will be called again, this time with
+        arg = "final" after all other processing is done.
+     */
+	public int setup(String arg, ImagePlus imp);
+
+	/** Filters use this method to process the image. If the
+	 	{@link #DOES_STACKS} flag was set, it is called for each slice in
+	 	a stack. With {@link #CONVERT_TO_FLOAT}, the filter is called with
+        the image data converted to a FloatProcessor (3 times per
+        image for RGB images). ImageJ will lock the image before calling
+		this method and unlock it when the filter is finished.
+        For PlugInFilters specifying the {@link #NO_IMAGE_REQUIRED} flag
+        and not the {@link #DONE} flag, run(ip) is called once with the
+        argument <code>null</code>.
+     */
+	public void run(ImageProcessor ip);
+
+	/** Set this flag if the filter handles 8-bit grayscale images. */
+	public int DOES_8G = 1;
+	/** Set this flag if the filter handles 8-bit indexed color images. */
+	public int DOES_8C = 2;
+	/** Set this flag if the filter handles 16-bit images. */
+	public int DOES_16 = 4;
+	/** Set this flag if the filter handles float images. */
+	public int DOES_32 = 8;
+	/** Set this flag if the filter handles RGB images. */
+	public int DOES_RGB = 16;
+	/** Set this flag if the filter handles all types of images. */
+	public int DOES_ALL = DOES_8G+DOES_8C+DOES_16+DOES_32+DOES_RGB;
+	/** Set this flag if the filter wants its run() method to be
+		called for all the slices in a stack. */
+	public int DOES_STACKS = 32;
+	/** Set this flag if the filter wants ImageJ, for non-rectangular
+		ROIs, to restore that part of the image that's inside the bounding
+		rectangle but outside of the ROI. */
+	public int SUPPORTS_MASKING = 64;
+	/** Set this flag if the filter makes no changes to the pixel data and does not require undo. */
+	public int NO_CHANGES = 128;
+	/** Set this flag if the filter does not require undo. */
+	public int NO_UNDO = 256;
+	/** Set this flag if the filter does not require that an image be open. */
+	public int NO_IMAGE_REQUIRED = 512;
+	/** Set this flag if the filter requires an ROI. */
+	public int ROI_REQUIRED = 1024;
+	/** Set this flag if the filter requires a stack. */
+	public int STACK_REQUIRED = 2048;
+	/** Set this flag if the filter does not want its run method called. */
+	public int DONE = 4096;
+	/** Set this flag to have the ImageProcessor that is passed to the run() method 
+		converted  to a FloatProcessor. With  RGB images, the run() method is  
+		called three times, once for each channel. */
+	public int CONVERT_TO_FLOAT = 8192;
+	/** Set this flag if the filter requires a snapshot (copy of the pixels array). */
+	public int SNAPSHOT = 16384;
+    /** Set this flag if the filter wants to be called with arg = "dialog" after
+        being invocated the first time */
+    /** Set this flag if the slices of a stack may be processed in parallel threads */
+    public final int PARALLELIZE_STACKS = 32768;
+    /** Set this flag if the setup method of the filter should be called again after
+     *  the calls to the run(ip) have finished. The argument <code>arg</code> of setup
+     *  will be "final" in that case. */
+    public final int FINAL_PROCESSING = 65536;
+    /** Set this flag to keep the invisible binary threshold from being reset. */
+    public final int KEEP_THRESHOLD = 131072;
+    /** Set this flag if images may be processed in parallel threads. Overrides PARALLELIZE_STACKS.
+		The plugin's run() method is called in parallel threads, with the ROI rectangle of the
+		ImageProcessor set according to the area that should be processed. Use the
+		Edit/Options/Memory & Threads command to view or set the thread count. */
+    public final int PARALLELIZE_IMAGES = 262144;
+    /** Set this flag to prevent Undo from being reset when processing a stack. */
+    public final int NO_UNDO_RESET = 524288;
+
+    // flags 0x01000000 and above are reserved for ExtendedPlugInFilter
+}
diff --git a/src/ij/plugin/filter/PlugInFilterRunner.java b/src/ij/plugin/filter/PlugInFilterRunner.java
new file mode 100644
index 0000000..a488677
--- /dev/null
+++ b/src/ij/plugin/filter/PlugInFilterRunner.java
@@ -0,0 +1,634 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.filter.PlugInFilter.*;
+import ij.plugin.filter.*;
+import ij.measure.Calibration;
+import ij.macro.Interpreter;
+import java.awt.*;
+import java.util.*;
+
+public class PlugInFilterRunner implements Runnable, DialogListener {
+	private String command;					// the command, can be but need not be the name of the PlugInFilter
+	private Object theFilter;					// the instance of the PlugInFilter
+	private ImagePlus imp;
+	private int flags;							// the flags returned by the PlugInFilter
+	private Overlay originalOverlay;		// overlay before pressing 'preview', to revert
+	private boolean previewCheckboxOn;			// the state of the preview checkbox (true = on)
+	private boolean bgPreviewOn;		// tells the background thread that preview is allowed
+	private boolean bgKeepPreview;		// tells the background thread to keep the result of preview
+	private Thread previewThread;		 // the thread of the preview
+	private GenericDialog gd;			 // the dialog (if it registers here by setDialog)
+	private Checkbox previewCheckbox;	 // reference to the preview Checkbox of the dialog
+	private long previewTime;				// time (ms) needed for preview processing
+	private boolean ipChanged;			// whether the image data have been changed
+	private int processedAsPreview;			// the slice processed during preview (if non-zero)
+	private Object snapshotPixels;		// the snapshot to show we have one and for undo in case of parallel actions intervening
+	private Hashtable<Thread, int[]> slicesForThread;		// gives first&last slice that a given thread should process
+	private Hashtable<Thread, ImageProcessor> roisForThread;// gives ROI that a given thread should process
+	Hashtable sliceForThread = new Hashtable(); // here the stack slice currently processed is stored.
+	private int nPasses;						// the number of calls to the run(ip) method of the filter
+	private int pass;						// passes done so far
+	private boolean doStack;
+
+	/** The constructor runs a PlugInFilter or ExtendedPlugInFilter by calling its
+	 * setup, run, etc. methods. For details, see the documentation of interfaces
+	 * PlugInFilter and ExtendedPlugInFilter.
+	 * @param theFilter The PlugInFilter to be run
+	 * @param command	The command that has caused running the PlugInFilter
+	 * @param arg		The argument specified for this PlugInFilter in IJ_Props.txt or in the
+	 * plugins.config file of a .jar archive conatining a collection of plugins. <code>arg</code>
+	 * may be a string of length zero.
+	 */
+	public PlugInFilterRunner(Object theFilter, String command, String arg) {
+		this.theFilter = theFilter;
+		this.command = command;
+		imp = WindowManager.getCurrentImage();
+		flags = ((PlugInFilter)theFilter).setup(arg, imp);	// S E T U P
+		if ((flags&PlugInFilter.DONE)!=0) return;
+		if (!checkImagePlus(imp, flags, command)) return;	// check whether the PlugInFilter can handle this image type
+		if ((flags&PlugInFilter.NO_IMAGE_REQUIRED)!=0)
+			imp = null;									// if the plugin does not want an image, it should not get one
+		Roi roi = null;
+		if (imp != null) {
+			roi = imp.getRoi();
+			if (roi!=null) roi.endPaste();				// prepare the image: finish previous paste operation (if any)
+			if (!imp.lock())
+				return;					// exit if image is in use
+			nPasses = ((flags&PlugInFilter.CONVERT_TO_FLOAT)!=0) ? imp.getProcessor().getNChannels():1;
+		}
+		if (theFilter instanceof ExtendedPlugInFilter) { // calling showDialog required?
+			try {
+				flags = ((ExtendedPlugInFilter)theFilter).showDialog(imp, command, this);  // D I A L O G (may include preview)
+			} catch(Exception e) {
+				killPreview();
+				if (Macro.MACRO_CANCELED.equals(e.getMessage()))
+					throw new RuntimeException(Macro.MACRO_CANCELED);
+			}
+			if (snapshotPixels != null)
+				Undo.setup(Undo.FILTER, imp);			// ip has a snapshot that may be used for Undo
+			boolean keepPreviewFlag = (flags&ExtendedPlugInFilter.KEEP_PREVIEW)!=0;
+			if (keepPreviewFlag && imp!=null && previewThread!=null && ipChanged &&
+					previewCheckbox!=null && previewCheckboxOn) {
+				bgKeepPreview = true;
+				waitForPreviewDone();
+				processedAsPreview = imp.getCurrentSlice();
+			} else {
+				killPreview();
+				previewTime = 0;
+			}
+		} // if ExtendedPlugInFilter
+		if ((flags&PlugInFilter.DONE)!=0) {
+			if (imp != null)
+				imp.unlock();
+			return;
+		} else if (imp==null) {
+			((PlugInFilter)theFilter).run(null);		// not DONE, but NO_IMAGE_REQUIRED
+			return;
+		}
+		/* preparing for the run(ip) method of the PlugInFilter... */
+		int slices = imp.getStackSize();
+		//IJ.log("processedAsPreview="+processedAsPreview+"; slices="+slices+"; doesStacks="+((flags&PlugInFilter.DOES_STACKS)!=0));
+		if ((flags&PlugInFilter.PARALLELIZE_IMAGES)!=0)
+			flags &= ~PlugInFilter.PARALLELIZE_STACKS;
+		doStack = slices>1 && (flags&PlugInFilter.DOES_STACKS)!=0;
+		imp.startTiming();
+		if (doStack || processedAsPreview==0) {				// if processing during preview was not enough
+			//IJ.showStatus(command + (doStack ? " (Stack)..." : "..."));
+			ImageProcessor ip = imp.getProcessor();
+			pass = 0;
+			if (!doStack) {	   // single image
+				FloatProcessor fp = null;
+				prepareProcessor(ip, imp);
+				announceSliceNumber(imp.getCurrentSlice());
+				if (theFilter instanceof ExtendedPlugInFilter)
+					((ExtendedPlugInFilter)theFilter).setNPasses(nPasses);
+				if ((flags&PlugInFilter.NO_CHANGES)==0) {	// for filters modifying the image
+					boolean disableUndo = Prefs.disableUndo || (flags&PlugInFilter.NO_UNDO)!=0;
+					if (!disableUndo || ((ip instanceof ColorProcessor)&&WindowManager.getWindow("B&C")!=null)) {
+						ip.snapshot();
+						snapshotPixels = ip.getSnapshotPixels();
+					}
+				}
+				processOneImage(ip, fp, snapshotPixels);	// may also set class variable snapshotPixels
+				if ((flags&PlugInFilter.NO_CHANGES)==0) {	// (filters doing no modifications don't change undo status)
+					if (snapshotPixels != null) {
+						ip.setSnapshotPixels(snapshotPixels);
+						Undo.setup(Undo.FILTER, imp);
+					} else
+						Undo.reset();
+				}
+				if ((flags&PlugInFilter.NO_CHANGES)==0&&(flags&PlugInFilter.KEEP_THRESHOLD)==0)
+					ip.resetBinaryThreshold();
+			} else {  // stack
+				if ((flags&PlugInFilter.NO_UNDO_RESET)==0)
+					Undo.reset();	 // no undo for processing a complete stack
+				IJ.resetEscape();
+				int slicesToDo = processedAsPreview!=0 ? slices-1 : slices;
+				nPasses *= slicesToDo;
+				if (theFilter instanceof ExtendedPlugInFilter)
+					((ExtendedPlugInFilter)theFilter).setNPasses(nPasses);
+				int threads = 1;
+				if ((flags&PlugInFilter.PARALLELIZE_STACKS)!=0) {
+					threads = Prefs.getThreads(); // multithread support for multiprocessor machines
+					if (threads>slicesToDo) threads = slicesToDo;
+					if (threads>1) slicesForThread = new Hashtable<Thread, int[]>(threads-1);
+				}
+				int startSlice = 1;
+				for (int i=1; i<threads; i++) {				// setup the background threads
+					int endSlice = (slicesToDo*i)/threads;
+					if (processedAsPreview!=0 && processedAsPreview<=endSlice) endSlice++;
+					Thread bgThread = new Thread(this, command+" "+startSlice+"-"+endSlice);
+					slicesForThread.put(bgThread, new int[] {startSlice, endSlice});
+					bgThread.start();
+					//IJ.log("Stack: Thread for slices "+startSlice+"-"+endSlice+" started");
+					startSlice = endSlice+1;
+				}
+				//IJ.log("Stack: Slices "+startSlice+"-"+slices+" by main thread");
+				processStack(startSlice, slices);			// the current thread does the rest
+				if (slicesForThread != null) {
+					while (slicesForThread.size()>0) {	  // for all other threads:
+						Thread theThread = (Thread)slicesForThread.keys().nextElement();
+						try {
+							theThread.join();				// wait until thread has finished
+						} catch (InterruptedException e) {}
+						slicesForThread.remove(theThread);	// and remove it from the list.
+					}
+				}
+			}
+		} // end processing:
+		if ((flags&PlugInFilter.FINAL_PROCESSING)!=0 && !IJ.escapePressed())
+			((PlugInFilter)theFilter).setup("final", imp);
+		if (IJ.escapePressed()) {
+			IJ.showStatus(command + " INTERRUPTED");
+			IJ.showProgress(1,1);
+		} else
+			IJ.showTime(imp, imp.getStartTime()-previewTime, command + ": ", doStack?slices:1);
+		IJ.showProgress(1.0);
+		if (ipChanged) {
+			imp.changes = true;
+			imp.updateAndDraw();
+		}
+		ImageWindow win = imp.getWindow();
+		if (win!=null) {
+			win.running = false;
+			win.running2 = false;
+		}
+		imp.unlock();
+	}
+
+	/** Process a stack or part of it. The slice given by class variable
+	 *	processedAsPreview remains unchanged.
+	 * @param firstSlice Slice number of the first slice to be processed
+	 * @param endSlice	 Slice number of the last slice to be processed
+	 */
+	private void processStack(int firstSlice, int endSlice) {
+		ImageStack stack = imp.getStack();
+		ImageProcessor ip = stack.getProcessor(firstSlice);
+		prepareProcessor(ip, imp);
+		ip.setLineWidth(Line.getWidth());		//in contrast to imp.getProcessor, stack.getProcessor does not do this
+		FloatProcessor fp = null;
+		int slices = imp.getNSlices();
+		for (int i=firstSlice; i<=endSlice; i++) {
+			if (i != processedAsPreview) {
+				announceSliceNumber(i);
+				ip.setPixels(stack.getPixels(i));
+				ip.setSliceNumber(i);
+				ip.setSnapshotPixels(null);
+				processOneImage(ip, fp, null);
+				if (IJ.escapePressed()) {IJ.beep(); break;}
+			}
+		}
+	}
+
+	/** prepare an ImageProcessor by setting roi and CalibrationTable.
+	 */
+	private void prepareProcessor(ImageProcessor ip, ImagePlus imp) {
+		ImageProcessor mask = imp.getMask();
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.isArea())
+			ip.setRoi(roi);
+		else
+			ip.setRoi((Roi)null);
+		if (imp.getStackSize()>1) {
+			ImageProcessor ip2 = imp.getProcessor();
+			double min1 = ip2.getMinThreshold();
+			double max1 = ip2.getMaxThreshold();
+			double min2 = ip.getMinThreshold();
+			double max2 = ip.getMaxThreshold();
+			if (min1!=ImageProcessor.NO_THRESHOLD && (min1!=min2||max1!=max2))
+				ip.setThreshold(min1, max1, ImageProcessor.NO_LUT_UPDATE);
+		}
+		//float[] cTable = imp.getCalibration().getCTable();
+		//ip.setCalibrationTable(cTable);
+	}
+
+	/**
+	 * Process a single image with the PlugInFilter.
+	 * @param ip		The image data that should be processed
+	 * @param fp		A Floatprocessor as a target for conversion to Float. May be null.
+	 * @param snapshotPixels Valid snapshotPixels for the current ImageProcessor (null when processing a stack)
+	 * Class variables used: flags (input), snapshotPixels (set if a snapshot of ip
+	 * is taken), ipChanged (set if ip was probably changed).
+	 */
+	private void processOneImage(ImageProcessor ip, FloatProcessor fp, Object snapshotPixels) {
+		if ((flags&PlugInFilter.PARALLELIZE_IMAGES)!=0) {
+			processImageUsingThreads(ip, fp, snapshotPixels);
+			return;
+		}
+		Thread thread = Thread.currentThread();
+		boolean convertToFloat = (flags&PlugInFilter.CONVERT_TO_FLOAT)!=0 && !(ip instanceof FloatProcessor);
+		boolean doMasking = (flags&PlugInFilter.SUPPORTS_MASKING)!=0 && ip.getMask() != null;
+		if (snapshotPixels==null && (doMasking || ((flags&PlugInFilter.SNAPSHOT)!=0) && !convertToFloat)) {
+			ip.snapshot();
+			this.snapshotPixels = ip.getSnapshotPixels();
+		}
+		if (convertToFloat) {
+			for (int i=0; i<ip.getNChannels(); i++) {
+				fp = ip.toFloat(i, fp);
+				fp.setSliceNumber(ip.getSliceNumber());
+				if (thread.isInterrupted()) return;			// interrupt processing for preview?
+				if ((flags&PlugInFilter.SNAPSHOT)!=0) fp.snapshot();
+				if (doStack) IJ.showProgress(pass/(double)nPasses);
+				((PlugInFilter)theFilter).run(fp);
+				if (thread.isInterrupted()) return;
+				//IJ.log("slice="+getSliceNumber()+" pass="+pass+"/"+nPasses);
+				pass++;
+				if ((flags&PlugInFilter.NO_CHANGES)==0) {
+					ipChanged = true;
+					ip.setPixels(i, fp);
+				}
+			}
+		} else {
+			if ((flags&PlugInFilter.NO_CHANGES)==0) ipChanged = true;
+				if (doStack) IJ.showProgress(pass/(double)nPasses);
+			((PlugInFilter)theFilter).run(ip);
+			pass++;
+		}
+
+		if (thread.isInterrupted()) return;
+		if (doMasking) {
+			if (snapshotPixels != null)
+				ip.setSnapshotPixels(snapshotPixels); //in case something has intervened and destroyed the snapshot
+			ip.reset(ip.getMask());	 //restore image outside irregular roi
+		}
+   }
+
+	private void processImageUsingThreads(ImageProcessor ip, FloatProcessor fp, Object snapshotPixels) {
+		if (IJ.debugMode)
+			IJ.log("using threads: "+ip.getNChannels());
+		Thread thread = Thread.currentThread();
+		boolean convertToFloat = (flags&PlugInFilter.CONVERT_TO_FLOAT)!=0 && !(ip instanceof FloatProcessor);
+		boolean doMasking = (flags&PlugInFilter.SUPPORTS_MASKING)!=0 && ip.getMask() != null;
+		if (snapshotPixels==null && (doMasking || ((flags&PlugInFilter.SNAPSHOT)!=0) && !convertToFloat)) {
+			ip.snapshot();
+			this.snapshotPixels = ip.getSnapshotPixels();
+		}
+		if (convertToFloat) {
+			for (int i=0; i<ip.getNChannels(); i++) {
+				fp = ip.toFloat(i, fp);
+				fp.setSliceNumber(ip.getSliceNumber());
+				if (thread.isInterrupted()) return;			// interrupt processing for preview?
+				if ((flags&PlugInFilter.SNAPSHOT)!=0) fp.snapshot();
+				if (doStack) IJ.showProgress(pass/(double)nPasses);
+				processChannelUsingThreads(fp);
+				if (thread.isInterrupted()) return;
+				//IJ.log("slice="+getSliceNumber()+" pass="+pass+"/"+nPasses);
+				if ((flags&PlugInFilter.NO_CHANGES)==0) {
+					ipChanged = true;
+					ip.setPixels(i, fp);
+				}
+			}
+		} else {
+			if ((flags&PlugInFilter.NO_CHANGES)==0) ipChanged = true;
+				if (doStack) IJ.showProgress(pass/(double)nPasses);
+			processChannelUsingThreads(ip);
+		}
+		if (thread.isInterrupted()) return;
+		if (doMasking) {
+			if (snapshotPixels != null)
+				ip.setSnapshotPixels(snapshotPixels);
+			ip.reset(ip.getMask());	 //restore image outside irregular roi
+		}
+	}
+
+	/** process an image or a single color channel of an RGB image by splitting
+	 *	into ROIs and using a separate thread for each roi */
+	private void processChannelUsingThreads(ImageProcessor ip) {
+		ImageProcessor mask = ip.getMask();
+		Rectangle roi = ip.getRoi();
+		int threads = Prefs.getThreads();
+		if (IJ.debugMode)
+			IJ.log("processing channel: "+threads);
+		if (threads>roi.height) threads = roi.height;
+		if (threads>1) roisForThread = new Hashtable<Thread, ImageProcessor>(threads-1);
+		int y1 = roi.y;
+		for (int i=1; i<threads; i++) {
+			int y2 = roi.y+(roi.height*i)/threads-1;
+			Thread bgThread = new Thread(this, command+" "+y1+"-"+y2);
+			Rectangle roi2 = new Rectangle(roi.x, y1, roi.width, y2-y1+1);
+			roisForThread.put(bgThread, duplicateProcessor(ip, roi2));
+			bgThread.start();
+			if (IJ.debugMode)
+				IJ.log("  starting thread: "+y1+"-"+y2);
+			y1 = y2+1;
+		}
+		if (IJ.debugMode)
+			IJ.log("  main thread "+y1+"-"+(roi.y+roi.height));
+		Rectangle roi2 = new Rectangle(roi.x, y1, roi.width, roi.y+roi.height-y1);
+		((PlugInFilter)theFilter).run(duplicateProcessor(ip, roi2)); 	// current thread does the rest
+		pass++;
+		if (roisForThread != null) {
+			for (Enumeration<Thread> en = roisForThread.keys(); en.hasMoreElements();) {
+				Thread theThread = en.nextElement();
+				try {
+					theThread.join();		// wait until thread has finished
+				} catch (InterruptedException e) { // if preview cancelled:
+					interruptRoiThreads(roisForThread); //interrupt all threads and join
+					Thread.currentThread().interrupt(); //restore 'interrupted' state
+					break;
+				}
+			}
+		}
+		roisForThread = null;
+		ip.setMask(mask);  // restore ROI
+		ip.setRoi(roi);
+	}
+
+	ImageProcessor duplicateProcessor(ImageProcessor ip, Rectangle roi) {
+		ImageProcessor ip2 = (ImageProcessor)ip.clone();
+		ip2.setRoi(roi);
+		return ip2;
+	}
+
+	/** interrupt threads processing the rois of an image and wait till they have finished */
+	void interruptRoiThreads(Hashtable<Thread, ImageProcessor> roisForThread) {
+		if (roisForThread==null) return;	//class variable may become null in other thread
+		for (Enumeration<Thread> en = roisForThread.keys(); en.hasMoreElements();)
+			((Thread)en.nextElement()).interrupt(); //interrupt all threads
+		for (Enumeration<Thread> en = roisForThread.keys(); en.hasMoreElements();)
+			try {
+				((Thread)en.nextElement()).join();
+			} catch (Exception e){}
+	}
+
+	/** test whether an ImagePlus can be processed based on the flags specified
+	 *	and display an error message if not.
+	 */
+	private boolean checkImagePlus(ImagePlus imp, int flags, String cmd) {
+		boolean imageRequired = (flags&PlugInFilter.NO_IMAGE_REQUIRED)==0;
+		if (imageRequired && imp==null)
+			{IJ.noImage(); return false;}
+		if (imageRequired) {
+			if (imp.getProcessor()==null)
+				{wrongType(flags, cmd); return false;}
+			int type = imp.getType();
+			switch (type) {
+				case ImagePlus.GRAY8:
+					if ((flags&PlugInFilter.DOES_8G)==0)
+					{wrongType(flags, cmd); return false;}
+					break;
+				case ImagePlus.COLOR_256:
+					if ((flags&PlugInFilter.DOES_8C)==0)
+					{wrongType(flags, cmd); return false;}
+					break;
+				case ImagePlus.GRAY16:
+					if ((flags&PlugInFilter.DOES_16)==0)
+					{wrongType(flags, cmd); return false;}
+					break;
+				case ImagePlus.GRAY32:
+					if ((flags&PlugInFilter.DOES_32)==0)
+					{wrongType(flags, cmd); return false;}
+					break;
+				case ImagePlus.COLOR_RGB:
+					if ((flags&PlugInFilter.DOES_RGB)==0)
+					{wrongType(flags, cmd); return false;}
+					break;
+			}
+			if ((flags&PlugInFilter.ROI_REQUIRED)!=0 && imp.getRoi()==null)
+			{IJ.error(cmd, "This command requires a selection"); return false;}
+			if ((flags&PlugInFilter.STACK_REQUIRED)!=0 && imp.getStackSize()==1)
+			{IJ.error(cmd, "This command requires a stack"); return false;}
+		} // if imageRequired
+		return true;
+	}
+
+	/** Display an error message, telling the allowed image types
+	 */
+	static void wrongType(int flags, String cmd) {
+		String s = "\""+cmd+"\" requires an image of type:\n \n";
+		if ((flags&PlugInFilter.DOES_8G)!=0) s +=  "	8-bit grayscale\n";
+		if ((flags&PlugInFilter.DOES_8C)!=0) s +=  "	8-bit color\n";
+		if ((flags&PlugInFilter.DOES_16)!=0) s +=  "	16-bit grayscale\n";
+		if ((flags&PlugInFilter.DOES_32)!=0) s +=  "	32-bit (float) grayscale\n";
+		if ((flags&PlugInFilter.DOES_RGB)!=0) s += "	RGB color\n";
+		IJ.error(s);
+	}
+
+	/** Make the slice number accessible to the PlugInFilter by putting it
+	 * into the appropriate hashtable.
+	 */
+	private void announceSliceNumber(int slice) {
+		synchronized(sliceForThread){
+			Integer number = new Integer(slice);
+			sliceForThread.put(Thread.currentThread(), number);
+		}
+	}
+
+	/** Return the slice number currently processed by the calling thread.
+	 * @return The slice number. Returns -1 on error (when not processing).
+	 */
+	public int getSliceNumber() {
+		synchronized(sliceForThread){
+			Integer number = (Integer)sliceForThread.get(Thread.currentThread());
+			return (number == null) ? -1 : number.intValue();
+		}
+	}
+
+	/** The dispatcher for the background threads
+	 */
+	public void run() {
+		Thread thread = Thread.currentThread();
+		try {
+			if (thread==previewThread)
+				runPreview();
+			else if (roisForThread!=null && roisForThread.containsKey(thread)) {
+				ImageProcessor ip = (ImageProcessor)roisForThread.get(thread);
+				((PlugInFilter)theFilter).run(ip);
+				ip.setPixels(null);
+				ip.setSnapshotPixels(null);
+			} else if (slicesForThread!=null && slicesForThread.containsKey(thread)) {
+				int[] range = (int[])slicesForThread.get(thread);
+				processStack(range[0], range[1]);
+			} else
+				IJ.error("PlugInFilterRunner internal error:\nunsolicited background thread");
+		} catch (Exception err) {
+			if (thread==previewThread) {
+				gd.previewRunning(false);
+				IJ.wait(100); // needed on Macs
+				previewCheckbox.setState(false);
+				bgPreviewOn = false;
+				previewThread = null;
+			}
+			String msg = ""+err;
+			if (msg.indexOf(Macro.MACRO_CANCELED)==-1) {
+				IJ.beep();
+				IJ.log("ERROR: "+msg+"\nin "+thread.getName()+
+					"\nat "+(err.getStackTrace()[0])+"\nfrom "+(err.getStackTrace()[1]));
+			}
+		}
+	}
+
+	/** The background thread for preview */
+	private void runPreview() {
+		if (IJ.debugMode)
+			IJ.log("preview thread started; imp="+imp.getTitle());
+		Thread thread = Thread.currentThread();
+		ImageProcessor ip = imp.getProcessor();
+		Roi originalRoi = imp.getRoi();
+		originalOverlay = imp.getOverlay();
+		FloatProcessor fp = null;
+		prepareProcessor(ip, imp);
+		announceSliceNumber(imp.getCurrentSlice());
+		if (snapshotPixels==null && (flags&PlugInFilter.NO_CHANGES)==0) {
+			ip.snapshot();
+			snapshotPixels = ip.getSnapshotPixels();
+		}
+		boolean previewDataOk = false;
+		while(bgPreviewOn) {
+			if (previewCheckboxOn) gd.previewRunning(true); // visual feedback
+			interruptable: {
+				if (imp.getRoi() != originalRoi) {
+					imp.setRoi(originalRoi);		// restore roi; the PlugInFilter may have affected it
+					if (originalRoi!=null && originalRoi.isArea())
+						ip.setRoi(originalRoi);
+					else
+						ip.setRoi((Roi)null);
+				}
+				if (ipChanged) {					// restore image data if necessary
+					ip.setSnapshotPixels(snapshotPixels);
+					ip.reset();
+				}
+				ipChanged = false;
+				previewDataOk = false;
+				long startTime = System.currentTimeMillis();
+				pass = 0;
+				if (theFilter instanceof ExtendedPlugInFilter)
+					((ExtendedPlugInFilter)theFilter).setNPasses(nPasses); //this should reset pass in the filter
+				if (thread.isInterrupted())
+					break interruptable;
+				//IJ.log("process preview start now");
+				processOneImage(ip, fp, snapshotPixels); // P R O C E S S   (sets ipChanged)
+				IJ.showProgress(1.0);
+				if (thread.isInterrupted())
+					break interruptable;
+				previewDataOk = true;
+				previewTime = System.currentTimeMillis() - startTime;
+				imp.updateAndDraw();
+				if (IJ.debugMode)
+					IJ.log("preview processing done");
+			}
+			gd.previewRunning(false);				// optical feedback
+			IJ.showStatus("");						//delete last status messages from processing
+			synchronized(this) {
+				if (!bgPreviewOn)
+					break;							//thread should stop and possibly keep the data
+				try {
+					wait();							//wait for interrupted (don't keep preview) or notify (keep preview)
+				} catch (InterruptedException e) {
+					previewDataOk = false;
+				}
+			} // synchronized
+		} // while bgPreviewOn
+		if (thread.isInterrupted())
+			previewDataOk = false;					//interrupted always means "don't keep preview"
+		if (!previewDataOk || !bgKeepPreview) {		//no need to keep the result
+			imp.setRoi(originalRoi);				//restore roi
+			if (ipChanged) {						//revert the image data
+				ip.setSnapshotPixels(snapshotPixels);
+				ip.reset();
+				ipChanged = false;
+			}
+		}
+		imp.updateAndDraw();						//display current state of image (reset or result of preview)
+		sliceForThread.remove(thread);				//no need to announce the slice number any more
+	 }
+
+	/** stop the background process responsible for preview as fast as possible
+	 and wait until the preview thread has finished */
+	private void killPreview() {
+		if (previewThread == null) return;
+		synchronized (this) {
+			previewThread.interrupt();		//ask for premature finishing (interrupt first -> no keepPreview)
+			bgPreviewOn = false;				//tell a possible background thread to terminate when it has finished
+			if (roisForThread!=null)
+				interruptRoiThreads(roisForThread);
+		}
+		waitForPreviewDone();
+		imp.setOverlay(originalOverlay);
+	}
+
+	/** stop the background process responsible for preview and wait until the preview thread has finished */
+	private void waitForPreviewDone() {
+		if (previewThread.isAlive()) try {		//a NullPointerException is possible if the thread finishes in the meanwhile
+			previewThread.setPriority(Thread.currentThread().getPriority());
+		} catch (Exception e) {}
+		synchronized (this) {
+			bgPreviewOn = false;	 //tell a possible background thread to terminate
+			notify();							//(but finish processing unless interrupted)
+		}
+		try {previewThread.join();}				//wait until the background thread is done
+		catch (InterruptedException e){}
+		previewThread = null;
+	}
+
+	/* set the GenericDialog gd where the preview comes from (if gd is
+	 * suitable for listening, i.e., if it has a preview checkbox).
+	 */
+	public void setDialog(GenericDialog gd) {
+		if (gd != null && imp != null) {
+			previewCheckbox = gd.getPreviewCheckbox();
+			if (previewCheckbox != null) {
+				gd.addDialogListener(this);
+				this.gd = gd;
+			}
+		} //IJ.log("setDialog done");
+	}
+
+	/** The listener to any change in the dialog. It is used for preview.
+	 * It is invoked every time the user changes something in the dialog
+	 * (except OK and cancel buttons), provided that all previous
+	 * listeners (parameter checking) have returned true.
+	 *
+	 * @param e The event that has happened in the dialog. This method may
+	 *			be also called with e=null, e.g. to start preview already
+	 *			when the dialog appears.
+	 * @return	Always true. (The return value determines whether the
+	 *			dialog will enable the OK button)
+	 */
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		if (previewCheckbox == null || imp == null) return true;
+		previewCheckboxOn = previewCheckbox.getState();
+		if (previewCheckboxOn  && previewThread == null) {
+			bgPreviewOn = true;						//need to start a background thread for preview
+			previewThread = new Thread(this, command+" Preview");
+			int priority = Thread.currentThread().getPriority() - 2;
+			if (priority < Thread.MIN_PRIORITY) priority = Thread.MIN_PRIORITY;
+			previewThread.setPriority(priority);	//preview on lower priority than dialog
+			previewThread.start();
+			if (IJ.debugMode)
+				IJ.log(command+" Preview thread was started");
+			return true;
+		}
+		if (previewThread != null) {				//thread runs already
+			if (!previewCheckboxOn) {				//preview toggled off
+				killPreview();
+				return true;
+			} else
+				previewThread.interrupt();	//all other changes: restart calculating preview (with new parameters)
+		}
+		return true;
+	}
+
+}
diff --git a/src/ij/plugin/filter/Printer.java b/src/ij/plugin/filter/Printer.java
new file mode 100644
index 0000000..ce7dd84
--- /dev/null
+++ b/src/ij/plugin/filter/Printer.java
@@ -0,0 +1,154 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.util.Properties;
+import java.awt.print.*;
+
+/** This plugin implements the File/Page Setup and File/Print commands. */
+public class Printer implements PlugInFilter, Printable {
+	private ImagePlus imp;
+	private static double scaling = 100.0;
+	private static boolean drawBorder;
+	private static boolean center = true;
+	private static boolean label;
+	private static boolean printSelection;
+	private static boolean rotate;
+	private static boolean actualSize;
+	private static int fontSize = 12;
+
+	public int setup(String arg, ImagePlus imp) {
+		if (arg.equals("setup"))
+			{pageSetup(); return DONE;}
+		this.imp = imp;
+		IJ.register(Printer.class);
+		return DOES_ALL+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		print(imp);
+	}
+	
+	void pageSetup() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		Roi roi = imp!=null?imp.getRoi():null;
+		boolean isRoi = roi!=null && roi.isArea();
+		GenericDialog gd = new GenericDialog("Page Setup");
+		gd.addNumericField("Scale:", scaling, 0, 3, "%");
+		gd.addCheckbox("Draw border", drawBorder);
+		gd.addCheckbox("Center on page", center);
+		gd.addCheckbox("Print title", label);
+		if (isRoi)
+			gd.addCheckbox("Selection only", printSelection);
+		gd.addCheckbox("Rotate 90"+IJ.degreeSymbol, rotate);
+		gd.addCheckbox("Print_actual size", actualSize);
+		if (imp!=null)
+			gd.enableYesNoCancel(" OK ", "Print");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		scaling = gd.getNextNumber();
+		if (scaling<5.0) scaling = 5;
+		drawBorder = gd.getNextBoolean();
+		center = gd.getNextBoolean();
+		label = gd.getNextBoolean();
+		if (isRoi)
+			printSelection = gd.getNextBoolean();
+		else
+			printSelection = false;
+		rotate = gd.getNextBoolean();
+		actualSize = gd.getNextBoolean();
+		if (!gd.wasOKed() && imp!=null) {
+			this.imp = imp;
+			print(imp);
+		}
+	}
+
+	void print(ImagePlus imp) {
+		PrinterJob pj = PrinterJob.getPrinterJob();
+		pj.setPrintable(this);
+		//pj.pageDialog(pj.defaultPage());
+		if (IJ.macroRunning() || pj.printDialog()) {
+			imp.startTiming();
+			try {pj.print(); }
+			catch (PrinterException e) {
+				IJ.log(""+e);
+			}
+		}
+	}
+	
+	@Override
+	public int print(Graphics g, PageFormat pf, int pageIndex) {
+		if (pageIndex != 0) return NO_SUCH_PAGE;
+		Roi roi = imp.getRoi();
+		ImagePlus imp2 = imp;
+		if (imp2.getOverlay()!=null && !imp2.getHideOverlay()) {
+			imp2.deleteRoi();
+			imp2 = imp2.flatten();
+		}
+		ImageProcessor ip = imp2.getProcessor();
+		if (printSelection && roi!=null && roi.isArea() )
+			ip.setRoi(roi);
+			ip = ip.crop();
+		if (rotate)
+			ip = ip.rotateLeft();
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		int margin = 0;
+		if (drawBorder) margin = 1;
+		double scale = scaling/100.0;
+		int dstWidth = (int)(width*scale);
+		int dstHeight = (int)(height*scale);
+		int pageX = (int)pf.getImageableX();
+		int pageY = (int)pf.getImageableY();
+		int dstX = pageX+margin;
+		int dstY = pageY+margin;
+		Image img = ip.createImage();
+		double pageWidth = pf.getImageableWidth()-2*margin;
+		double pageHeight = pf.getImageableHeight()-2*margin;
+		if (label && pageWidth-dstWidth<fontSize+5) {
+			dstY += fontSize+5;
+			pageHeight -= fontSize+5;
+		}
+		if (actualSize) {
+			Calibration cal = imp.getCalibration();
+			int unitIndex = ImageProperties.getUnitIndex(cal.getUnit());
+			if (unitIndex!=ImageProperties.OTHER_UNIT) {
+				double unitsPerCm = ImageProperties.getUnitsPerCm(unitIndex);
+				double widthInCm = width*cal.pixelWidth/unitsPerCm;
+				double heightInCm = height*cal.pixelHeight/unitsPerCm;
+				dstWidth = (int)((widthInCm*(72*0.3937))*scale);
+				dstHeight = (int)((heightInCm*(72*0.3937))*scale);
+			}
+			if (center && dstWidth<pageWidth && dstHeight<pageHeight) {
+				dstX += (pageWidth-dstWidth)/2;
+				dstY += (pageHeight-dstHeight)/2;
+			}
+		} else if (dstWidth>pageWidth || dstHeight>pageHeight) {
+			// scale to fit page
+			double hscale = pageWidth/dstWidth;
+			double vscale = pageHeight/dstHeight;
+			double scale2 = hscale<=vscale?hscale:vscale;
+			dstWidth = (int)(dstWidth*scale2);
+			dstHeight = (int)(dstHeight*scale2);
+		} else if (center) {
+			dstX += (pageWidth-dstWidth)/2;
+			dstY += (pageHeight-dstHeight)/2;
+		}
+		g.drawImage(img, 
+			dstX, dstY, dstX+dstWidth, dstY+dstHeight,
+			0, 0, width, height, 
+			null);
+		if (drawBorder)
+			g.drawRect(dstX-1, dstY-1, dstWidth+1, dstHeight+1);
+		if (label) {
+			g.setFont(new Font("SanSerif", Font.PLAIN, fontSize));
+			g.setColor(Color.black);
+			g.drawString(imp.getTitle(), pageX+5, pageY+fontSize);
+		}
+		return PAGE_EXISTS;
+	}
+
+}
diff --git a/src/ij/plugin/filter/RGBStackSplitter.java b/src/ij/plugin/filter/RGBStackSplitter.java
new file mode 100644
index 0000000..8a94870
--- /dev/null
+++ b/src/ij/plugin/filter/RGBStackSplitter.java
@@ -0,0 +1,37 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.plugin.ChannelSplitter;
+
+/** Deprecated; replaced by ij.plugin.ChannelSplitter. */
+public class RGBStackSplitter implements PlugInFilter {
+	ImagePlus imp;
+	public ImageStack red, green, blue;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		(new ChannelSplitter()).run(arg);
+		return DONE;
+	}
+
+	public void run(ImageProcessor ip) {
+	}
+
+	/** Deprecated; replaced by ij.plugin.ChannelSplitter. */
+	public void split(ImagePlus imp) {
+		WindowManager.setTempCurrentImage(imp);
+		(new ChannelSplitter()).run("");
+	}
+
+	/** Deprecated; replaced by ChannelSplitter.splitRGB(). */
+	public void split(ImageStack rgb, boolean keepSource) {
+		ImageStack[] channels = ChannelSplitter.splitRGB(rgb, keepSource);
+		red = channels[0];
+		green = channels[1];
+		blue = channels[2];
+	}
+	
+}
+
+
+
diff --git a/src/ij/plugin/filter/RankFilters.java b/src/ij/plugin/filter/RankFilters.java
new file mode 100644
index 0000000..0acec37
--- /dev/null
+++ b/src/ij/plugin/filter/RankFilters.java
@@ -0,0 +1,947 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.plugin.ContrastEnhancer;
+import ij.util.ThreadUtil;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Arrays;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.*;
+
+
+/** This plugin implements the Mean, Minimum, Maximum, Variance, Median,
+ *	Remove Outliers, Remove NaNs and Despeckle commands.
+ */
+ // Version 2012-07-15 M. Schmid:	Fixes a bug that could cause preview not to work correctly
+ // Version 2012-12-23 M. Schmid:	Test for inverted LUT only once (not in each slice)
+ // Version 2014-10-10 M. Schmid:   Fixes a bug that caused Threshold=0 when calling from API
+ // Version 2019-07-26 M. Schmid:   Nonblocking dialog enabled
+ // Version 2020-07-17 M. Schmid:   bugfix: changing preview parameters could lead to partial filtering with different parameters.
+ //                                 Uses AtomicIntegers. Top-hat filter added
+
+public class RankFilters implements ExtendedPlugInFilter, DialogListener {
+	public static final int	 MEAN=0, MIN=1, MAX=2, VARIANCE=3, MEDIAN=4, OUTLIERS=5, DESPECKLE=6, REMOVE_NAN=7,
+			OPEN=8, CLOSE=9, TOP_HAT=10; //when adding a new filter, set HIGHEST_FILTER below.
+	public static final int BRIGHT_OUTLIERS = 0, DARK_OUTLIERS = 1;
+	private static final String[] outlierStrings = {"Bright","Dark"};
+	private static int HIGHEST_FILTER = TOP_HAT;
+	// Filter parameters
+	private int filterType;
+	private double radius;
+	private double threshold;        //this and the next for 'remove outliers' only
+	private int whichOutliers;
+	private boolean lightBackground = Prefs.get("bs.background", true); //this and the next for top hat only
+	private boolean dontSubtract;
+	// Remember filter parameters for the next time
+	private static double[] lastRadius = new double[HIGHEST_FILTER+1]; //separate for each filter type
+	private static double lastThreshold = 50.;
+	private static int lastWhichOutliers = BRIGHT_OUTLIERS;
+	private static boolean lastLightBackground = false;
+	private static boolean lastDontSubtract = false;
+	//
+	// F u r t h e r   c l a s s   v a r i a b l e s
+	int flags = DOES_ALL|SUPPORTS_MASKING|KEEP_PREVIEW;
+	private ImagePlus imp;
+	private int nPasses = 1;			// The number of passes (color channels * stack slices)
+	private PlugInFilterRunner pfr;
+	private int pass;
+	private boolean previewing = false;
+	// M u l t i t h r e a d i n g - r e l a t e d
+	private int numThreads = Prefs.getThreads();
+	// The current state of multithreaded processing is in class variables.
+	// Thus, stack parallelization must be done ONLY with one thread for the image
+	// (not using these class variables).
+	// Atomic objects are used to avoid caching (i.e., to ensure that always the current state of the variable is read).
+	private AtomicInteger highestYinCache = new AtomicInteger(Integer.MIN_VALUE);	// the highest line read into the cache so far
+	private AtomicInteger nThreadsWaiting = new AtomicInteger(0);			// number of threads waiting until they may read data
+	private AtomicBoolean copyingToCache  = new AtomicBoolean(false);		// whether a thread is currently copying data to the cache
+
+	/** OPEN, CLOSE, TOPHAT need more than one run of the underlying filter */
+	private boolean isMultiStepFilter(int filterType) {
+		return filterType>=OPEN && filterType<=TOP_HAT;
+	}
+
+	/** Setup of the PlugInFilter. Returns the flags specifying the capabilities and needs
+	 * of the filter.
+	 *
+	 * @param arg	Defines type of filter operation
+	 * @param imp	The ImagePlus to be processed
+	 * @return		Flags specifying further action of the PlugInFilterRunner
+	 */
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		if (arg.equals("mean"))
+			filterType = MEAN;
+		else if (arg.equals("min"))
+			filterType = MIN;
+		else if (arg.equals("max"))
+			filterType = MAX;
+		else if (arg.equals("variance")) {
+			filterType = VARIANCE;
+			flags |= FINAL_PROCESSING;
+		} else if (arg.equals("median"))
+			filterType = MEDIAN;
+		else if (arg.equals("outliers"))
+			filterType = OUTLIERS;
+		else if (arg.equals("despeckle"))
+			filterType = DESPECKLE;
+		else if (arg.equals("tophat"))
+			filterType = TOP_HAT;
+		else if (arg.equals("nan")) {
+			filterType = REMOVE_NAN;
+			if (imp!=null && imp.getBitDepth()!=32) {
+				IJ.error("RankFilters","\"Remove NaNs\" requires a 32-bit image");
+				return DONE;
+			}
+		} else if (arg.equals("final")) {	//after variance && tophat filter, adjust brightness&contrast
+			setDisplayRange(imp.getProcessor());
+		} else if (arg.equals("masks")) {
+			showMasks();
+			return DONE;
+		} else {
+			IJ.error("RankFilters","Argument missing or undefined: "+arg);
+			return DONE;
+		}
+		if (isMultiStepFilter(filterType) && imp!=null) {  //composite filter: 'open maxima' etc:
+			Roi roi = imp.getRoi();
+			if (roi!=null && !roi.getBounds().contains(new Rectangle(imp.getWidth(), imp.getHeight())))
+				//Roi < image? (actually tested: NOT (Roi>=image))
+				flags |= SNAPSHOT;			//snapshot for resetRoiBoundary, also for top-hat subtraction
+		}
+		return flags;
+	}
+
+	public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+		if (filterType == DESPECKLE) {
+			filterType = MEDIAN;
+			radius = 1.0;
+		} else {
+			GenericDialog gd = GUI.newNonBlockingDialog(command,imp);
+			radius = lastRadius[filterType]<=0 ? 2 :  lastRadius[filterType];
+			gd.addNumericField("Radius", radius, 1, 6, "pixels");
+			if (filterType==OUTLIERS) {
+				int digits = imp.getType() == ImagePlus.GRAY32 ? 2 : 0;
+				gd.addNumericField("Threshold", lastThreshold, digits);
+				gd.addChoice("Which outliers", outlierStrings, outlierStrings[lastWhichOutliers]);
+				gd.addHelp(IJ.URL+"/docs/menus/process.html#outliers");
+			} else if (filterType==REMOVE_NAN) {
+				gd.addHelp(IJ.URL+"/docs/menus/process.html#nans");
+			} else if (filterType==TOP_HAT) {
+				gd.addCheckbox("Light Background", lastLightBackground);
+				gd.addCheckbox("Don't subtract (grayscale open)", lastDontSubtract);
+			}
+			gd.addPreviewCheckbox(pfr);		//passing pfr makes the filter ready for preview
+			gd.addDialogListener(this);		//the DialogItemChanged method will be called on user input
+			previewing = true;
+			gd.showDialog();				//display the dialog; preview may run now
+			previewing = false;
+			if (gd.wasCanceled()) return DONE;
+			IJ.register(this.getClass());	//protect static class variables (filter parameters) from garbage collection
+			if (Macro.getOptions() == null) { //interactive only: remember parameters entered
+				lastRadius[filterType] = radius;
+				if (filterType == OUTLIERS) {
+					lastThreshold = threshold;
+					lastWhichOutliers = whichOutliers;
+				} else if (filterType==TOP_HAT) {
+					lastLightBackground = lightBackground;
+					lastDontSubtract = dontSubtract;
+				}
+			}
+		}
+		this.pfr = pfr;
+		flags = IJ.setupDialog(imp, flags); //ask whether to process all slices of stack (if a stack)
+		if ((flags&DOES_STACKS)!=0) {
+			int size = imp.getWidth() * imp.getHeight();
+			Roi roi = imp.getRoi();
+			if (roi != null) {
+				Rectangle roiRect = roi.getBounds();
+				size = roiRect.width * roiRect.height;
+			}
+			double workToDo = size*(double)radius;	//estimate computing time (arb. units)
+			if (filterType==MEAN || filterType==VARIANCE) workToDo *= 0.5;
+			else if (filterType==MEDIAN) workToDo *= radius*0.5;
+			if (workToDo < 1e6 && imp.getImageStackSize()>=2*numThreads) {
+				numThreads = 1;				//for fast operations, avoid overhead of multi-threading in each image
+				flags |= PARALLELIZE_STACKS;
+			}
+		}
+		return flags;
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		radius = gd.getNextNumber();
+		if (filterType == OUTLIERS) {
+			threshold = gd.getNextNumber();
+			whichOutliers = gd.getNextChoiceIndex();
+		} else if (filterType==TOP_HAT || filterType==OPEN || filterType==CLOSE) {
+			lightBackground = gd.getNextBoolean();
+			dontSubtract = gd.getNextBoolean();
+		}
+		int maxRadius = (filterType==MEDIAN || filterType==OUTLIERS || filterType==REMOVE_NAN) ? 100 : 1000;
+		if (gd.invalidNumber() || radius<0 || radius>maxRadius || (filterType==OUTLIERS && threshold <0))
+			return false;
+		if (filterType == TOP_HAT) {
+			if (dontSubtract)
+				flags &= ~FINAL_PROCESSING;	//grayscale open: keep display range
+			else
+				flags |= FINAL_PROCESSING;	//top-hat: readjust display range
+		}
+		return true;
+	}
+
+	public void run(ImageProcessor ip) {
+		rank(ip, radius, filterType, whichOutliers, (float)threshold, lightBackground, dontSubtract);
+		if (IJ.escapePressed())									// interrupted by user?
+			ip.reset();
+		else if (previewing && (flags&FINAL_PROCESSING)!=0)
+			setDisplayRange(ip);
+	}
+
+	/** Filters an image by any method except 'despecle', 'remove outliers', or top-hat
+	 *	@param ip	   The ImageProcessor that should be filtered (all 4 types supported)
+	 *	@param radius  Determines the kernel size, see Process>Filters>Show Circular Masks.
+	 *				   Must not be negative. No checking is done for large values that would
+	 *				   lead to excessive computing times.
+	 *	@param filterType May be MEAN, MIN, MAX, VARIANCE, or MEDIAN.
+	 */
+	public void rank(ImageProcessor ip, double radius, int filterType) {
+		rank(ip, radius, filterType, 0, 50f);
+	}
+
+	/** Filters an image by any method except 'despecle' and top-hat (for 'despeckle', use 'median' and radius=1)
+	 * @param ip The image subject to filtering
+	 * @param radius The kernel radius
+	 * @param filterType as defined above; DESPECKLE is not a valid type here; use median and
+	 *		  a radius of 1.0 instead
+	 * @param whichOutliers BRIGHT_OUTLIERS or DARK_OUTLIERS for 'outliers' filter
+	 * @param threshold Threshold for 'outliers' filter
+	 */
+	public void rank(ImageProcessor ip, double radius, int filterType, int whichOutliers, float threshold) {
+		rank(ip, radius, filterType, whichOutliers, threshold, false, false);
+	}
+
+	/** Filters an image by any method except 'despecle' (for 'despeckle', use 'median' and radius=1)
+	 * @param ip The image subject to filtering
+	 * @param radius The kernel radius
+	 * @param filterType as defined above; DESPECKLE is not a valid type here; use median and
+	 *		  a radius of 1.0 instead
+	 * @param whichOutliers BRIGHT_OUTLIERS or DARK_OUTLIERS for 'outliers' filter
+	 * @param threshold Threshold for 'outliers' filter
+	 * @param lightBackground for top-hat background subtraction, background is light, not dark
+	 * @param dontSubtract fpr top-hat filter, performs a grayscale open or close instead of top-hat,
+	 *        where the result of grayscale open/close is subtracted from the original.
+	 */
+	public void rank(ImageProcessor ip, double radius, int filterType, int whichOutliers, float threshold, boolean lightBackground, boolean dontSubtract) {
+		Rectangle roi = ip.getRoi();
+		ImageProcessor mask = ip.getMask();
+		Rectangle roi1 = null;
+		int[] lineRadii = makeLineRadii(radius);
+
+		boolean snapshotRequired = (filterType==TOP_HAT && !dontSubtract) ||
+			(isMultiStepFilter(filterType) && (roi.width!=ip.getWidth() || roi.height!=ip.getHeight()));
+		if (snapshotRequired && ip.getSnapshotPixels()==null)
+			ip.snapshot();
+
+		float minMaxOutliersSign = filterType==MIN || filterType==OPEN ? -1f : 1f; //open is minimum first
+		if (filterType == OUTLIERS)		//sign is -1 for high outliers: compare number with minimum
+			minMaxOutliersSign = (ip.isInvertedLut()==(whichOutliers==DARK_OUTLIERS)) ? -1f : 1f;
+
+		if (filterType == TOP_HAT) {
+			boolean invertedLut = ip.isInvertedLut();
+			boolean invert = (invertedLut && !lightBackground) || (!invertedLut && lightBackground);
+			minMaxOutliersSign = invert ? 1f : -1f;
+		}
+
+		ImageProcessor snapIp = null;
+		FloatProcessor fp = null, snapFp = null;
+		boolean isImagePart = (roi.width<ip.getWidth()) || (roi.height<ip.getHeight());
+		AtomicInteger nextY = new AtomicInteger();		// becomes negative when interrupted during preview or ESC pressed
+		if (filterType == TOP_HAT && !dontSubtract) {
+			snapIp = ip.createProcessor(ip.getWidth(), ip.getHeight());
+			snapIp.setPixels(ip.getSnapshotPixels());
+		}
+		for (int ch=0; ch<ip.getNChannels(); ch++) {
+			int filterType1 = filterType;
+			if (isMultiStepFilter(filterType)) { //open, close, top-hat
+				filterType1 = (minMaxOutliersSign == -1f) ? MIN : MAX;
+					if (isImagePart) { //composite filters ('open maxima' etc.) need larger area in first step
+					int kRadius = kRadius(lineRadii);
+					int kHeight = kHeight(lineRadii);
+					Rectangle roiClone = (Rectangle)roi.clone();
+					roiClone.grow(kRadius, kHeight/2);
+					roi1 = roiClone.intersection(new Rectangle(ip.getWidth(), ip.getHeight()));
+					ip.setRoi(roi1);
+				}
+			}
+			doFiltering(ip, lineRadii, filterType1, minMaxOutliersSign, threshold, ch, nextY);
+			if (isMultiStepFilter(filterType)) { //open, close, top-hat
+				ip.setRoi(roi);
+				ip.setMask(mask);
+				if (nextY.get() < 0) break;
+				int filterType2 = (minMaxOutliersSign == -1f) ? MAX : MIN;
+				doFiltering(ip, lineRadii, filterType2, -minMaxOutliersSign, threshold, ch, nextY);
+				if (isImagePart)
+					resetRoiBoundary(ip, roi, roi1);
+			}
+			if (nextY.get() < 0) break;
+
+			if (filterType == TOP_HAT && !dontSubtract) {   //top-hat filter: Subtract opened from input
+				float offset = 0;
+				if (minMaxOutliersSign == 1f && !(ip instanceof FloatProcessor))
+					offset = (float)ip.maxValue();          //background is maximum of possible range (255 or 65535)
+				fp = ip.toFloat(ch, fp);
+				snapFp = snapIp.toFloat(ch, snapFp);
+				float[] pixels = (float[])fp.getPixels();
+				float[] snapPixels = (float[])snapFp.getPixels();
+				int width = ip.getWidth();
+				for (int y=roi.y; y<roi.y+roi.height; y++)
+					for (int ix=0, p=y*width+roi.x; ix<roi.width; ix++, p++)
+						pixels[p] = snapPixels[p] - pixels[p] + offset;
+				ip.setPixels(ch, fp);
+			}
+		}
+
+	}
+
+	// Filter a grayscale image or one channel of an RGB image with several threads
+	// Implementation: each thread uses the same input buffer (cache), always works on the next unfiltered line
+	// Usually, one thread reads reads several lines into the cache, while the others are processing the data.
+	// 'nextY.get()' is set to a large negative number if the main thread has been interrupted (during preview) or ESC pressed.
+	// 'nextY' must not be a class variable because it is also used with one thread (with stack parallelization)
+	private void doFiltering(final ImageProcessor ip, final int[] lineRadii, final int filterType,
+			final float minMaxOutliersSign, final float threshold, final int colorChannel, final AtomicInteger nextY) {
+		Rectangle roi = ip.getRoi();
+		int width = ip.getWidth();
+		Object pixels = ip.getPixels();
+		int numThreads = Math.min(roi.height, this.numThreads);
+		if (numThreads==0)
+			return;
+
+		int kHeight = kHeight(lineRadii);
+		int kRadius	 = kRadius(lineRadii);
+		final int cacheWidth = roi.width+2*kRadius;
+		final int cacheHeight = kHeight + (numThreads>1 ? 2*numThreads : 0);
+		// 'cache' is the input buffer. Each line y in the image is mapped onto cache line y%cacheHeight
+		final float[] cache = new float[cacheWidth*cacheHeight];
+		highestYinCache.set(Math.max(roi.y-kHeight/2, 0) - 1); //this line+1 will be read into the cache first
+
+		final AtomicIntegerArray yForThread = new AtomicIntegerArray(numThreads);	//threads announce here which line they currently process
+		for (int i=0; i<numThreads; i++)
+			yForThread.set(i, -1);
+		nextY.set(roi.y);										//first thread started should begin at roi.y
+		Callable[] callables = new Callable[numThreads-1];
+		for (int i=0; i<numThreads-1; i++) {
+			final int threadNumber = i+1; // number 0 is reserved for main thread
+			callables[i] = new Callable<Void>() {
+				final public Void call() {
+					doFiltering(ip, lineRadii, cache, cacheWidth, cacheHeight,
+							filterType, minMaxOutliersSign, threshold, colorChannel,
+							yForThread, threadNumber, nextY);
+					return null;
+				}
+			};
+		}
+		Future[] futures = ThreadUtil.start(callables);
+
+		doFiltering(ip, lineRadii, cache, cacheWidth, cacheHeight,
+				filterType, minMaxOutliersSign, threshold, colorChannel,
+				yForThread, /*threadNumber=*/0, nextY);
+		ThreadUtil.joinAll(futures);
+		showProgress(1.0, ip instanceof ColorProcessor);
+		pass++;
+	}
+
+	// Filter a grayscale image or one channel of an RGB image using one thread
+	//
+	// Synchronization: unless a thread is waiting, we avoid the overhead of 'synchronized'
+	// statements. That's because a thread waiting for another one should be rare.
+	//
+	// Data handling: The area needed for processing a line is written into the array 'cache'.
+	// This is a stripe of sufficient width for all threads to have each thread processing one
+	// line, and some extra space if one thread is finished to start the next line.
+	// This array is padded at the edges of the image so that a surrounding with radius kRadius
+	// for each pixel processed is within 'cache'. Out-of-image
+	// pixels are set to the value of the nearest edge pixel. When adding a new line, the lines in
+	// 'cache' are not shifted but rather the smaller array with the start and end pointers of the
+	// kernel area is modified to point at the addresses for the next line.
+	//
+	// Algorithm: For mean and variance, except for very small radius, usually do not calculate the
+	// sum over all pixels. This sum is calculated for the first pixel of every line only. For the
+	// following pixels, add the new values and subtract those that are not in the sum any more.
+	// For min/max, also first look at the new values, use their maximum if larger than the old
+	// one. The look at the values not in the area any more; if it does not contain the old
+	// maximum, leave the maximum unchanged. Otherwise, determine the maximum inside the area.
+	// For outliers, calculate the median only if the pixel deviates by more than the threshold
+	// from any pixel in the area. Therfore min or max is calculated; this is a much faster
+	// operation than the median.
+	private void doFiltering(ImageProcessor ip, int[] lineRadii, float[] cache, int cacheWidth, int cacheHeight,
+			int filterType, float minMaxOutliersSign, float threshold, int colorChannel,
+			AtomicIntegerArray yForThread, int threadNumber, AtomicInteger nextY) {
+		if (nextY.get() < 0 || Thread.currentThread().isInterrupted()) return;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		Rectangle roi = ip.getRoi();
+
+		int kHeight = kHeight(lineRadii);
+		int kRadius	 = kRadius(lineRadii);
+		int kNPoints = kNPoints(lineRadii);
+
+		int xmin = roi.x - kRadius;
+		int xmax = roi.x + roi.width + kRadius;
+		int[]cachePointers = makeCachePointers(lineRadii, cacheWidth);
+
+		int padLeft = xmin<0 ? -xmin : 0;
+		int padRight = xmax>width? xmax-width : 0;
+		int xminInside = xmin>0 ? xmin : 0;
+		int xmaxInside = xmax<width ? xmax : width;
+		int widthInside = xmaxInside - xminInside;
+
+		boolean minOrMax = filterType == MIN || filterType == MAX;
+		boolean minOrMaxOrOutliers = minOrMax || filterType == OUTLIERS;
+		boolean sumFilter = filterType == MEAN || filterType == VARIANCE;
+		boolean medianFilter = filterType == MEDIAN || filterType == OUTLIERS;
+		double[] sums = sumFilter ? new double[2] : null;
+		float[] medianBuf1 = (medianFilter||filterType==REMOVE_NAN) ? new float[kNPoints] : null;
+		float[] medianBuf2 = (medianFilter||filterType==REMOVE_NAN) ? new float[kNPoints] : null;
+
+		boolean smallKernel = kRadius < 2;
+
+		Object pixels = ip.getPixels();
+		boolean isFloat = pixels instanceof float[];
+		float maxValue = isFloat ? Float.NaN : (float)ip.maxValue();
+		float[] values = isFloat ? (float[])pixels : new float[roi.width];
+
+		int numThreads = yForThread.length();
+		long lastTime = System.currentTimeMillis();
+		int previousY = kHeight/2-cacheHeight;
+		boolean rgb = ip instanceof ColorProcessor;
+
+		while (true) {
+			int y = nextY.getAndIncrement();		// y of the next line that needs processing
+			if (y >= 0)
+				yForThread.set(threadNumber, y);
+			//IJ.log("thread "+threadNumber+" @y="+y+" needs"+(y-kHeight/2)+"-"+(y+kHeight/2)+" highestYinC="+highestYinCache.get());
+			boolean threadFinished = y >= roi.y+roi.height || y < 0;	// y<0 if aborted
+			if (numThreads>1 && (nThreadsWaiting.get()>0 || threadFinished))		// 'if' is not synchronized to avoid overhead
+				//If nThreadsWaiting gets incremented to 1 after the 'if' by another thread, there will be no notifyAll.
+				//This is not an issue since the the other thread rechecking for a slow thread (synchronized, ~30 lines below)
+				//will not see the current thread being slow any more, so that other thread will not wait.
+				synchronized(this) {
+					notifyAll();					// we may have blocked another thread
+					//IJ.log("thread "+threadNumber+" @y="+y+" notifying");
+				}
+			if (threadFinished)
+				return;								// all done, break the loop
+
+			if (threadNumber==0) {					// main thread checks for abort and ProgressBar
+				long time = System.currentTimeMillis();
+				if (time-lastTime>100) {
+					lastTime = time;
+					showProgress((y-roi.y)/(double)(roi.height), rgb);
+					if (Thread.currentThread().isInterrupted() || (imp!= null && IJ.escapePressed())) {
+						nextY.set(Integer.MIN_VALUE);
+						synchronized(this) {notifyAll();}
+						return;
+					}
+				}
+			}
+
+			for (int i=0; i<cachePointers.length; i++)	//shift kernel pointers to new line
+				cachePointers[i] = (cachePointers[i] + cacheWidth*(y-previousY))%cache.length;
+			previousY = y;
+
+			if (numThreads>1) {							// thread synchronization
+				int slowestThreadY = arrayMinNonNegative(yForThread); // non-synchronized check to avoid overhead
+
+				if (y - slowestThreadY + kHeight > cacheHeight) {	// we would overwrite data needed by another thread
+					nThreadsWaiting.incrementAndGet();
+					synchronized(this) {
+						slowestThreadY = arrayMinNonNegative(yForThread); //recheck whether we have to wait
+						if (y - slowestThreadY + kHeight > cacheHeight) {
+							do {
+								//notifyAll();			// avoid deadlock: wake up others waiting
+								//IJ.log("Thread "+threadNumber+" waiting @y="+y+" slowest@y="+slowestThreadY);
+								try {
+									wait();
+									if (nextY.get() < 0) return;
+								} catch (InterruptedException e) {
+									nextY.set(Integer.MIN_VALUE);
+									notifyAll();
+									Thread.currentThread().interrupt(); //keep interrupted status (PlugInFilterRunner needs it)
+									return;
+								}
+								slowestThreadY = arrayMinNonNegative(yForThread);
+							} while (y - slowestThreadY + kHeight > cacheHeight);
+						} //if
+					}
+					nThreadsWaiting.decrementAndGet();
+				}
+			}
+
+			if (numThreads==1) {															// R E A D
+				int yStartReading = y==roi.y ? Math.max(roi.y-kHeight/2, 0) : y+kHeight/2;
+				for (int yNew = yStartReading; yNew<=y+kHeight/2; yNew++) { //only 1 line except at start
+					readLineToCacheOrPad(pixels, width, height, roi.y, xminInside, widthInside,
+							cache, cacheWidth, cacheHeight, padLeft, padRight, colorChannel, kHeight, yNew);
+				}
+			} else {										// if no other thread is copying or if the own thread needs the data
+				if (!copyingToCache.get() || highestYinCache.get() < y+kHeight/2) synchronized(cache) {
+					copyingToCache.set(true);				// copy as many new line(s) as possible into the cache
+					while (highestYinCache.get() < arrayMinNonNegative(yForThread) - kHeight/2 + cacheHeight - 1) {
+						int yNew = highestYinCache.get() + 1;
+						readLineToCacheOrPad(pixels, width, height, roi.y, xminInside, widthInside,
+							cache, cacheWidth, cacheHeight, padLeft, padRight, colorChannel, kHeight, yNew);
+						highestYinCache.set(yNew);
+					}
+					copyingToCache.set(false);
+				}
+			}
+
+			int cacheLineP = cacheWidth * (y % cacheHeight) + kRadius;	//points to pixel (roi.x, y)
+			filterLine(values, width, cache, cachePointers, kNPoints, cacheLineP, roi, y,	// F I L T E R
+					sums, medianBuf1, medianBuf2, minMaxOutliersSign, maxValue, isFloat, filterType,
+					smallKernel, sumFilter, minOrMax, minOrMaxOrOutliers, threshold);
+			if (!isFloat)		//Float images: data are written already during 'filterLine'
+				writeLineToPixels(values, pixels, roi.x+y*width, roi.width, colorChannel);	// W R I T E
+			//IJ.log("thread "+threadNumber+" @y="+y+" line done");
+		} // while (true); loop over y (lines)
+	}
+
+	//returns the minimum of the array, which may be modified concurrently, but not less than 0
+	private int arrayMinNonNegative(AtomicIntegerArray array) {
+		int min = Integer.MAX_VALUE;
+		for (int i=0; i<array.length(); i++) {
+			int v = array.get(i);
+			if (v < min) min = v;
+		}
+		return min<0 ? 0 : min;
+	}
+
+	private void filterLine(float[] values, int width, float[] cache, int[] cachePointers, int kNPoints, int cacheLineP, Rectangle roi, int y,
+			double[] sums, float[] medianBuf1, float[] medianBuf2, float minMaxOutliersSign, float maxValue, boolean isFloat, int filterType,
+			boolean smallKernel, boolean sumFilter, boolean minOrMax, boolean minOrMaxOrOutliers, float threshold) {
+			int valuesP = isFloat ? roi.x+y*width : 0;
+			float max = 0f;
+			float median = Float.isNaN(cache[cacheLineP]) ? 0 : cache[cacheLineP];	// a first guess
+			boolean fullCalculation = true;
+			for (int x=0; x<roi.width; x++, valuesP++) {							// x is with respect to roi.x
+				if (fullCalculation) {
+					fullCalculation = smallKernel;	//for small kernel, always use the full area, not incremental algorithm
+					if (minOrMaxOrOutliers)
+						max = getAreaMax(cache, x, cachePointers, 0, -Float.MAX_VALUE, minMaxOutliersSign);
+					if (minOrMax) {
+						values[valuesP] = max*minMaxOutliersSign;
+						continue;
+					}
+					else if (sumFilter)
+						getAreaSums(cache, x, cachePointers, sums);
+				} else {
+					if (minOrMaxOrOutliers) {
+						float newPointsMax = getSideMax(cache, x, cachePointers, true, minMaxOutliersSign);
+						if (newPointsMax >= max) { //compare with previous maximum 'max'
+							max = newPointsMax;
+						} else {
+							float removedPointsMax = getSideMax(cache, x, cachePointers, false, minMaxOutliersSign);
+							if (removedPointsMax >= max)
+								max = getAreaMax(cache, x, cachePointers, 1, newPointsMax, minMaxOutliersSign);
+						}
+						if (minOrMax) {
+							values[valuesP] = max*minMaxOutliersSign;
+							continue;
+						}
+					} else if (sumFilter) {
+						addSideSums(cache, x, cachePointers, sums);
+						if (Double.isNaN(sums[0])) //avoid perpetuating NaNs into remaining line
+							fullCalculation = true;
+					}
+				}
+				if (sumFilter) {
+					if (filterType == MEAN)
+						values[valuesP] = (float)(sums[0]/kNPoints);
+					else	{// Variance: sum of squares - square of sums
+						float value = (float)((sums[1] - sums[0]*sums[0]/kNPoints)/kNPoints);
+						if (value>maxValue) value = maxValue;
+                        if (value < 0) value = 0;   // numeric noise can cause values < 0
+						values[valuesP] = value;
+					}
+				} else if (filterType == MEDIAN) {
+					if (isFloat) {
+						median = Float.isNaN(values[valuesP]) ? Float.NaN : values[valuesP]; // a first guess
+						median = getNaNAwareMedian(cache, x, cachePointers, medianBuf1, medianBuf2, kNPoints, median);
+					} else
+						median = getMedian(cache, x, cachePointers, medianBuf1, medianBuf2, kNPoints, median);
+					values[valuesP] = median;
+				} else if (filterType == OUTLIERS) {
+					float v = cache[cacheLineP+x];
+					if (v*minMaxOutliersSign+threshold < max) {		//for low outliers: median can't be higher than max (minMaxOutliersSign is +1)
+						median = getMedian(cache, x, cachePointers, medianBuf1, medianBuf2, kNPoints, median);
+						if (v*minMaxOutliersSign+threshold < median*minMaxOutliersSign)
+							v = median;					//beyond threshold (below if minMaxOutliersSign=+1), replace outlier by median
+					}
+					values[valuesP] = v;
+				} else if (filterType == REMOVE_NAN) {	 //float only; then 'values' is pixels array
+					if (Float.isNaN(values[valuesP]))
+						values[valuesP] = getNaNAwareMedian(cache, x, cachePointers, medianBuf1, medianBuf2, kNPoints, median);
+					else
+						median = values[valuesP];	//initial guess for the next point
+				}
+			} // for x
+		}
+
+	/** Read a line into the cache (including padding in x).
+	 *	If y>=height, instead of reading new data, it duplicates the line y=height-1.
+	 *	If y==0, it also creates the data for y<0, as far as necessary, thus filling the cache with
+	 *	more than one line (padding by duplicating the y=0 row).
+	 */
+	private static void readLineToCacheOrPad(Object pixels, int width, int height, int roiY, int xminInside, int widthInside,
+			float[]cache, int cacheWidth, int cacheHeight, int padLeft, int padRight, int colorChannel,
+			int kHeight, int y) {
+		int lineInCache = y%cacheHeight;
+		if (y < height) {
+			readLineToCache(pixels, y*width, xminInside, widthInside,
+					cache, lineInCache*cacheWidth, padLeft, padRight, colorChannel);
+			if (y==0) for (int prevY = roiY-kHeight/2; prevY<0; prevY++) {	//for y<0, pad with y=0 border pixels
+				int prevLineInCache = cacheHeight+prevY;
+				System.arraycopy(cache, 0, cache, prevLineInCache*cacheWidth, cacheWidth);
+			}
+		} else
+			System.arraycopy(cache, cacheWidth*((height-1)%cacheHeight), cache, lineInCache*cacheWidth, cacheWidth);
+	}
+
+	/** Read a line into the cache (includes conversion to flaot). Pad with edge pixels in x if necessary */
+	private static void readLineToCache(Object pixels, int pixelLineP, int xminInside, int widthInside,
+								float[] cache, int cacheLineP, int padLeft, int padRight, int colorChannel) {
+		if (pixels instanceof byte[]) {
+			byte[] bPixels = (byte[])pixels;
+			for (int pp=pixelLineP+xminInside, cp=cacheLineP+padLeft; pp<pixelLineP+xminInside+widthInside; pp++,cp++)
+				cache[cp] = bPixels[pp]&0xff;
+		} else if (pixels instanceof short[]){
+			short[] sPixels = (short[])pixels;
+			for (int pp=pixelLineP+xminInside, cp=cacheLineP+padLeft; pp<pixelLineP+xminInside+widthInside; pp++,cp++)
+				cache[cp] = sPixels[pp]&0xffff;
+		} else if (pixels instanceof float[]) {
+			System.arraycopy(pixels, pixelLineP+xminInside, cache, cacheLineP+padLeft, widthInside);
+		} else {	//RGB
+			int[] cPixels = (int[])pixels;
+			int shift = 16 - 8*colorChannel;
+			int byteMask = 255<<shift;
+			for (int pp=pixelLineP+xminInside, cp=cacheLineP+padLeft; pp<pixelLineP+xminInside+widthInside; pp++,cp++)
+				cache[cp] = (cPixels[pp]&byteMask)>>shift;
+		}
+		for (int cp=cacheLineP; cp<cacheLineP+padLeft; cp++)
+			cache[cp] = cache[cacheLineP+padLeft];
+		for (int cp=cacheLineP+padLeft+widthInside; cp<cacheLineP+padLeft+widthInside+padRight; cp++)
+			cache[cp] = cache[cacheLineP+padLeft+widthInside-1];
+	}
+
+	/** Write a line to pixels arrax, converting from float (not for float data!)
+	 *	No checking for overflow/underflow
+	 */
+	private static void writeLineToPixels(float[] values, Object pixels, int pixelP, int length, int colorChannel) {
+		if (pixels instanceof byte[]) {
+			byte[] bPixels = (byte[])pixels;
+			for (int i=0, p=pixelP; i<length; i++,p++)
+				bPixels[p] = (byte)(((int)(values[i] + 0.5f))&0xff);
+		} else if (pixels instanceof short[]) {
+			short[] sPixels = (short[])pixels;
+			for (int i=0, p=pixelP; i<length; i++,p++)
+				sPixels[p] = (short)(((int)(values[i] + 0.5f))&0xffff);
+		} else {	//RGB
+			int[] cPixels = (int[])pixels;
+			int shift = 16 - 8*colorChannel;
+			int resetMask = 0xffffffff^(0xff<<shift);
+			for (int i=0, p=pixelP; i<length; i++,p++)
+				cPixels[p] = (cPixels[p]&resetMask) | (((int)(values[i] + 0.5f))<<shift);
+		}
+	}
+
+	/** Get max (or -min if sign=-1) within the kernel area.
+	 *	@param x between 0 and cacheWidth-1
+	 *	@param ignoreRight should be 0 for analyzing all data or 1 for leaving out the row at the right
+	 *	@param max should be -Float.MAX_VALUE or the smallest value the maximum can be */
+	private static float getAreaMax(float[] cache, int xCache0, int[] kernel, int ignoreRight, float max, float sign) {
+		for (int kk=0; kk<kernel.length; kk++) {	// y within the cache stripe (we have 2 kernel pointers per cache line)
+			for (int p=kernel[kk++]+xCache0; p<=kernel[kk]+xCache0-ignoreRight; p++) {
+				float v = cache[p]*sign;
+				if (max < v) max = v;
+			}
+		}
+		return max;
+	}
+
+	/** Get max (or -min if sign=-1) at the right border inside or left border outside the kernel area.
+	 *	x between 0 and cacheWidth-1 */
+	private static float getSideMax(float[] cache, int xCache0, int[] kernel, boolean isRight, float sign) {
+		float max = -Float.MAX_VALUE;
+		if (!isRight) xCache0--;
+		for (int kk= isRight ? 1 : 0; kk<kernel.length; kk+=2) {	// y within the cache stripe (we have 2 kernel pointers per cache line)
+			float v = cache[xCache0 + kernel[kk]]*sign;
+			if (max < v) max = v;
+		}
+		return max;
+	}
+
+	/** Get sum of values and values squared within the kernel area.
+	 *	x between 0 and cacheWidth-1
+	 *	Output is written to array sums[0] = sum; sums[1] = sum of squares */
+	private static void getAreaSums(float[] cache, int xCache0, int[] kernel, double[] sums) {
+		double sum=0, sum2=0;
+		for (int kk=0; kk<kernel.length; kk++) {	// y within the cache stripe (we have 2 kernel pointers per cache line)
+			for (int p=kernel[kk++]+xCache0; p<=kernel[kk]+xCache0; p++) {
+				double v = cache[p];
+				sum += v;
+				sum2 += v*v;
+			}
+		}
+		sums[0] = sum;
+		sums[1] = sum2;
+		return;
+	}
+
+	/** Add all values and values squared at the right border inside minus at the left border outside the kernal area.
+	 *	Output is added or subtracted to/from array sums[0] += sum; sums[1] += sum of squares  when at
+	 *	the right border, minus when at the left border */
+	private static void addSideSums(float[] cache, int xCache0, int[] kernel, double[] sums) {
+		double sum=0, sum2=0;
+		for (int kk=0; kk<kernel.length; /*k++;k++ below*/) {
+			double v = cache[kernel[kk++]+(xCache0-1)]; //this value is not in the kernel area any more
+			sum -= v;
+			sum2 -= v*v;
+			v = cache[kernel[kk++]+xCache0];            //this value comes into the kernel area
+			sum += v;
+			sum2 += v*v;
+		}
+		sums[0] += sum;
+		sums[1] += sum2;
+		return;
+	}
+
+	/** Get median of values within kernel-sized neighborhood. Kernel size kNPoints should be odd.
+	 */
+	private static float getMedian(float[] cache, int xCache0, int[] kernel,
+			float[] aboveBuf, float[]belowBuf, int kNPoints, float guess) {
+		int nAbove = 0, nBelow = 0;
+		for (int kk=0; kk<kernel.length; kk++) {
+			for (int p=kernel[kk++]+xCache0; p<=kernel[kk]+xCache0; p++) {
+				float v = cache[p];
+				if (v > guess) {
+					aboveBuf[nAbove] = v;
+					nAbove++;
+				}
+				else if (v < guess) {
+					belowBuf[nBelow] = v;
+					nBelow++;
+				}
+			}
+		}
+		int half = kNPoints/2;
+		if (nAbove>half)
+			return findNthLowestNumber(aboveBuf, nAbove, nAbove-half-1);
+		else if (nBelow>half)
+			return findNthLowestNumber(belowBuf, nBelow, half);
+		else
+			return guess;
+	}
+
+	/** Get median of values within kernel-sized neighborhood.
+	 *	NaN data values are ignored; the output is NaN only if there are only NaN values in the
+	 *	kernel-sized neighborhood */
+	private static float getNaNAwareMedian(float[] cache, int xCache0, int[] kernel,
+			float[] aboveBuf, float[]belowBuf, int kNPoints, float guess) {
+		int nAbove = 0, nBelow = 0;
+		for (int kk=0; kk<kernel.length; kk++) {
+			for (int p=kernel[kk++]+xCache0; p<=kernel[kk]+xCache0; p++) {
+				float v = cache[p];
+				if (Float.isNaN(v)) {
+					kNPoints--;
+				} else if (v > guess) {
+					aboveBuf[nAbove] = v;
+					nAbove++;
+				}
+				else if (v < guess) {
+					belowBuf[nBelow] = v;
+					nBelow++;
+				}
+			}
+		}
+		if (kNPoints == 0) return Float.NaN;	//only NaN data in the neighborhood?
+		int half = kNPoints/2;
+		if (nAbove>half)
+			return findNthLowestNumber(aboveBuf, nAbove, nAbove-half-1);
+		else if (nBelow>half)
+			return findNthLowestNumber(belowBuf, nBelow, half);
+		else
+			return guess;
+	}
+
+	/** Find the n-th lowest number in part of an array
+	 *	@param buf The input array. Only values 0 ... bufLength are read. <code>buf</code> will be modified.
+	 *	@param bufLength Number of values in <code>buf</code> that should be read
+	 *	@param n which value should be found; n=0 for the lowest, n=bufLength-1 for the highest
+	 *	@return the value */
+	public final static float findNthLowestNumber(float[] buf, int bufLength, int n) {
+		// Hoare's find, algorithm, based on http://www.geocities.com/zabrodskyvlada/3alg.html
+		// Contributed by Heinz Klar
+		int i,j;
+		int l=0;
+		int m=bufLength-1;
+		float med=buf[n];
+		float dum ;
+
+		while (l<m) {
+			i=l ;
+			j=m ;
+			do {
+				while (buf[i]<med) i++ ;
+				while (med<buf[j]) j-- ;
+				dum=buf[j];
+				buf[j]=buf[i];
+				buf[i]=dum;
+				i++ ; j-- ;
+			} while ((j>=n) && (i<=n)) ;
+			if (j<n) l=i ;
+			if (n<i) m=j ;
+			med=buf[n] ;
+		}
+	return med ;
+	}
+
+	/** Reset region between inner rectangle 'roi' and outer rectangle 'roi1' to the snapshot */
+	private void resetRoiBoundary(ImageProcessor ip, Rectangle roi, Rectangle roi1) {
+		int width = ip.getWidth();
+		Object pixels = ip.getPixels();
+		Object snapshot = ip.getSnapshotPixels();
+		for (int y=roi1.y, p = roi1.x+y*width; y<roi.y; y++,p+=width)
+			System.arraycopy(snapshot, p, pixels, p, roi1.width);
+		int leftWidth = roi.x - roi1.x;
+		int rightWidth = roi1.x+roi1.width - (roi.x+roi.width);
+		for (int y=roi.y, pL=roi1.x+y*width, pR=roi.x+roi.width+y*width; y<roi.y+roi.height; y++,pL+=width,pR+=width) {
+			if (leftWidth > 0)
+				System.arraycopy(snapshot, pL, pixels, pL, leftWidth);
+			if (rightWidth > 0)
+				System.arraycopy(snapshot, pR, pixels, pR, rightWidth);
+		}
+		for (int y=roi.y+roi.height, p = roi1.x+y*width; y<roi1.y+roi1.height; y++,p+=width)
+			System.arraycopy(snapshot, p, pixels, p, roi1.width);
+	}
+
+	/** @deprecated
+	 * Not needed any more, use the rank(ip, ...) method, which creates the kernel */
+	public void makeKernel(double radius) {
+		this.radius = radius;
+	}
+
+	/** Sets the display range after variance and top-hat (16-bit & floating-point images only) */
+	private void setDisplayRange(ImageProcessor ip) {
+		if ((ip instanceof ByteProcessor) || (ip instanceof ColorProcessor)) return;
+		new ContrastEnhancer().stretchHistogram(ip, 0.5);
+	}
+
+	/** Create a circular kernel (structuring element) of a given radius.
+	 *	@param radius
+	 *	Radius = 0.5 includes the 4 neighbors of the pixel in the center,
+	 *	radius = 1 corresponds to a 3x3 kernel size.
+	 *	@return the circular kernel
+	 *	The output is an array that gives the length of each line of the structuring element
+	 *	(kernel) to the left (negative) and to the right (positive):
+	 *	[0] left in line 0, [1] right in line 0,
+	 *	[2] left in line 2, ...
+	 *	The maximum (absolute) value should be kernelRadius.
+	 *	Array elements at the end:
+	 *	length-2: nPoints, number of pixels in the kernel area
+	 *	length-1: kernelRadius in x direction (kernel width is 2*kernelRadius+1)
+	 *	Kernel height can be calculated as (array length - 1)/2 (odd number);
+	 *	Kernel radius in y direction is kernel height/2 (truncating integer division).
+	 *	Note that kernel width and height are the same for the circular kernels used here,
+	 *	but treated separately for the case of future extensions with non-circular kernels.
+	 */
+	protected int[] makeLineRadii(double radius) {
+		if (radius>=1.5 && radius<1.75) //this code creates the same sizes as the previous RankFilters
+			radius = 1.75;
+		else if (radius>=2.5 && radius<2.85)
+			radius = 2.85;
+		int r2 = (int) (radius*radius) + 1;
+		int kRadius = (int)(Math.sqrt(r2+1e-10));
+		int kHeight = 2*kRadius + 1;
+		int[] kernel = new int[2*kHeight + 2];
+		kernel[2*kRadius]	= -kRadius;
+		kernel[2*kRadius+1] =  kRadius;
+		int nPoints = 2*kRadius+1;
+		for (int y=1; y<=kRadius; y++) {		//lines above and below center together
+			int dx = (int)(Math.sqrt(r2-y*y+1e-10));
+			kernel[2*(kRadius-y)]	= -dx;
+			kernel[2*(kRadius-y)+1] =  dx;
+			kernel[2*(kRadius+y)]	= -dx;
+			kernel[2*(kRadius+y)+1] =  dx;
+			nPoints += 4*dx+2;	//2*dx+1 for each line, above&below
+		}
+		kernel[kernel.length-2] = nPoints;
+		kernel[kernel.length-1] = kRadius;
+		//for (int i=0; i<kHeight;i++)IJ.log(i+": "+kernel[2*i]+"-"+kernel[2*i+1]);
+		return kernel;
+	}
+
+	//kernel height
+	private int kHeight(int[] lineRadii) {
+		return (lineRadii.length-2)/2;
+	}
+
+	//kernel radius in x direction. width is 2+kRadius+1
+	private int kRadius(int[] lineRadii) {
+		return lineRadii[lineRadii.length-1];
+	}
+
+	//number of points in kernal area
+	private int kNPoints(int[] lineRadii) {
+		return lineRadii[lineRadii.length-2];
+	}
+
+	//cache pointers for a given kernel
+	private int[] makeCachePointers(int[] lineRadii, int cacheWidth) {
+		int kRadius = kRadius(lineRadii);
+		int kHeight = kHeight(lineRadii);
+		int[] cachePointers = new int[2*kHeight];
+		for (int i=0; i<kHeight; i++) {
+			cachePointers[2*i]	 = i*cacheWidth+kRadius + lineRadii[2*i];
+			cachePointers[2*i+1] = i*cacheWidth+kRadius + lineRadii[2*i+1];
+		}
+		return cachePointers;
+	}
+
+	void showMasks() {
+		int w=150, h=150;
+		ImageStack stack = new ImageStack(w, h);
+		//for (double r=0.1; r<3; r+=0.01) {
+		for (double r=0.5; r<50; r+=0.5) {
+			ImageProcessor ip = new FloatProcessor(w,h,new int[w*h]);
+			float[] pixels = (float[])ip.getPixels();
+			int[] lineRadii = makeLineRadii(r);
+			int kHeight = kHeight(lineRadii);
+			int kRadius = kRadius(lineRadii);
+			int y0 = h/2-kHeight/2;
+			for (int i = 0, y = y0; i<kHeight; i++, y++)
+				for (int x = w/2+lineRadii[2*i], p = x+y*w; x <= w/2+lineRadii[2*i+1]; x++, p++)
+					pixels[p] = 1f;
+			stack.addSlice("radius="+r+", size="+(2*kRadius+1), ip);
+		}
+		new ImagePlus("Masks", stack).show();
+	}
+
+	/** This method is called by ImageJ to set the number of calls to run(ip)
+	 *	corresponding to 100% of the progress bar.
+	 *  Setting nPasses=0 suppresses the progress bar */
+	public void setNPasses (int nPasses) {
+		this.nPasses = nPasses;
+		pass = 0;
+	}
+
+	private void showProgress(double percent, boolean rgb) {
+		if (nPasses==0) return;
+		int nPasses2 = rgb?nPasses*3:nPasses;
+		percent = (double)pass/nPasses2 + percent/nPasses2;
+		IJ.showProgress(percent);
+	}
+
+}
diff --git a/src/ij/plugin/filter/RoiWriter.java b/src/ij/plugin/filter/RoiWriter.java
new file mode 100644
index 0000000..1ee2721
--- /dev/null
+++ b/src/ij/plugin/filter/RoiWriter.java
@@ -0,0 +1,54 @@
+package ij.plugin.filter;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.io.*;
+import ij.*;
+import ij.process.*;
+import ij.io.*;
+import ij.gui.*;
+
+/** Saves the current ROI outline to a file. RoiDecoder.java 
+	has a description of the file format.
+	@see ij.io.RoiDecoder
+	@see ij.plugin.RoiReader
+*/
+public class RoiWriter implements PlugInFilter {
+	ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL+ROI_REQUIRED+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		try {
+			saveRoi(imp);
+		} catch (IOException e) {
+			String msg = e.getMessage();
+			if (msg==null || msg.equals(""))
+				msg = ""+e;
+			IJ.error("ROI Writer", msg);
+		}
+	}
+
+	public void saveRoi(ImagePlus imp) throws IOException{
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			throw new IllegalArgumentException("ROI required");
+		String name = roi.getName();
+		if (name==null)
+			name = imp.getTitle();
+		SaveDialog sd = new SaveDialog("Save Selection...", name, ".roi");
+		name = sd.getFileName();
+		if (name == null)
+			return;
+		String dir = sd.getDirectory();
+		RoiEncoder re = new RoiEncoder(dir+name);
+		re.write(roi);
+		if (name.endsWith(".roi"))
+			name = name.substring(0, name.length()-4);
+		roi.setName(name);
+	}
+	
+}
diff --git a/src/ij/plugin/filter/Rotator.java b/src/ij/plugin/filter/Rotator.java
new file mode 100644
index 0000000..9f44cd2
--- /dev/null
+++ b/src/ij/plugin/filter/Rotator.java
@@ -0,0 +1,202 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import java.awt.*;
+import java.awt.geom.*;
+
+
+/** This plugin implements the Image/Rotate/Arbitrarily command. */
+public class Rotator implements ExtendedPlugInFilter, DialogListener {
+	public static final String GRID = "|GRID|";
+	private int flags = DOES_ALL|SUPPORTS_MASKING|PARALLELIZE_STACKS;
+	private static double angle = 15.0;
+	private static boolean fillWithBackground;
+	private static boolean enlarge;
+	private static int gridLines = 1;
+	private ImagePlus imp;
+	private int bitDepth;
+	private boolean canEnlarge;
+	private boolean isEnlarged;
+	private GenericDialog gd;
+	private PlugInFilterRunner pfr;
+	private String[] methods = ImageProcessor.getInterpolationMethods();
+	private static int interpolationMethod = ImageProcessor.BILINEAR;
+	private Overlay overlay;
+	private boolean done;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		if (imp!=null) {
+			bitDepth = imp.getBitDepth();
+			Roi roi = imp.getRoi();
+			if (roi!=null && roi.isLine())
+				roi = null;
+			Rectangle r = roi!=null?roi.getBounds():null;
+			canEnlarge = r==null || (r.x==0&&r.y==0&&r.width==imp.getWidth()&&r.height==imp.getHeight());
+			if (imp.getDisplayMode()==IJ.COMPOSITE) { // setup Undo for composite color stacks
+				Undo.setup(Undo.TRANSFORM, imp);
+				flags = flags | NO_UNDO_RESET;
+			}
+			overlay = imp.getOverlay();
+			Undo.saveOverlay(imp);
+			if (overlay==null)
+				overlay = new Overlay();
+		}
+		return flags;
+	}
+
+	public void run(ImageProcessor ip) {
+		if (enlarge && gd.wasOKed()) synchronized(this) {
+			if (!isEnlarged) {
+				enlargeCanvas();
+				isEnlarged=true;
+			}
+		}
+		if (isEnlarged) {	//enlarging may have made the ImageProcessor invalid, also for the parallel threads
+			int slice = pfr.getSliceNumber();
+			if (imp.getStackSize()==1)
+				ip = imp.getProcessor();
+			else
+				ip = imp.getStack().getProcessor(slice);
+		}
+		ip.setInterpolationMethod(interpolationMethod);
+		if (fillWithBackground) {
+			Color bgc = Toolbar.getBackgroundColor();
+			if (bitDepth==8)
+				ip.setBackgroundValue(ip.getBestIndex(bgc));
+			else if (bitDepth==24)
+				ip.setBackgroundValue(bgc.getRGB());
+		} else
+			ip.setBackgroundValue(0);
+		ip.rotate(angle);
+		if (!gd.wasOKed())
+			drawGridLines(gridLines);
+		if (overlay!=null && !imp.getHideOverlay()) {
+			Overlay overlay2 = overlay.rotate(angle, ip.getWidth()/2, ip.getHeight()/2);
+			if (overlay2!=null && overlay2.size()>0)
+				imp.setOverlay(overlay2);
+		}
+		if (isEnlarged && imp.getStackSize()==1) {
+			imp.changes = true;
+			imp.updateAndDraw();
+			Undo.setup(Undo.COMPOUND_FILTER_DONE, imp);
+		}
+		if (done) { // remove grid
+			Overlay ovly = imp.getOverlay();
+			if (ovly!=null) {
+				ovly.remove(GRID);
+				if (ovly.size()==0) imp.setOverlay(null);			
+			}
+		}
+	}
+
+	void enlargeCanvas() {
+		imp.unlock();
+		IJ.run(imp, "Select All", "");
+		IJ.run(imp, "Rotate...", "angle="+angle);
+		Roi roi = imp.getRoi();
+		Rectangle r = roi.getBounds();
+		if (r.width<imp.getWidth()) r.width = imp.getWidth();
+		if (r.height<imp.getHeight()) r.height = imp.getHeight();
+		IJ.showStatus("Rotate: Enlarging...");
+		if (imp.getStackSize()==1)
+			Undo.setup(Undo.COMPOUND_FILTER, imp);
+		IJ.run(imp, "Canvas Size...", "width="+r.width+" height="+r.height+" position=Center "+(fillWithBackground?"":"zero"));
+		IJ.showStatus("Rotating...");
+	}
+
+	void drawGridLines(int lines) {
+		if (overlay==null)
+			return;
+		overlay.remove(GRID);
+		if (lines==0)
+			return;
+		GeneralPath path = new GeneralPath();
+		float width = imp.getWidth();
+		float height = imp.getHeight();
+		float xinc = width/lines;
+		float yinc = height/lines;
+		float xstart = xinc/2f;
+		float ystart = yinc/2f;
+		for (int i=0; i<lines; i++) {
+			path.moveTo(xstart+xinc*i, 0f);
+			path.lineTo(xstart+xinc*i, height);
+			path.moveTo(0f, ystart+yinc*i);
+			path.lineTo(width, ystart+yinc*i);
+		}
+		Roi roi = new ShapeRoi(path);
+		roi.setName(GRID);
+		roi.setStrokeWidth(0);
+		overlay.add(roi);
+	}
+
+	public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+		this.pfr = pfr;
+		String macroOptions = Macro.getOptions();
+		if (macroOptions!=null) {
+			if (macroOptions.indexOf(" interpolate")!=-1)
+				macroOptions.replaceAll(" interpolate", " interpolation=Bilinear");
+			else if (macroOptions.indexOf(" interpolation=")==-1)
+				macroOptions = macroOptions+" interpolation=None";
+			Macro.setOptions(macroOptions);
+		}
+		gd = new GenericDialog("Rotate");
+		gd.addSlider("Angle:", -90, 90, angle, 0.1);
+		gd.addNumericField("Grid lines:", gridLines, 0);
+		gd.addChoice("Interpolation:", methods, methods[interpolationMethod]);
+		if (bitDepth==8 || bitDepth==24)
+			gd.addCheckbox("Fill with background color", fillWithBackground);
+		if (canEnlarge)
+			gd.addCheckbox("Enlarge image", enlarge);
+		else
+			enlarge = false;
+		gd.addPreviewCheckbox(pfr);
+		gd.addDialogListener(this);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			if (overlay.size()>0) {
+				overlay.remove(GRID);
+				imp.setOverlay(overlay);
+			}
+			return DONE;
+		}
+		Overlay ovly = imp.getOverlay();
+		if (ovly!=null) {
+			ovly.remove(GRID);
+			if (ovly.size()==0) imp.setOverlay(null);		
+		}
+		if (enlarge)
+			flags |= NO_CHANGES;			// undoable as a "compound filter"
+		else if (imp.getStackSize()==1)			
+			flags |= KEEP_PREVIEW;		// standard filter without enlarge
+		done = true;
+		return IJ.setupDialog(imp, flags);
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		angle = gd.getNextNumber();
+		//only check for invalid input to "angle", don't care about gridLines
+		if (gd.invalidNumber()) {
+			if (gd.wasOKed()) IJ.error("Angle is invalid.");
+			return false;
+		}
+		gridLines = (int)gd.getNextNumber();
+		interpolationMethod = gd.getNextChoiceIndex();
+		if (bitDepth==8 || bitDepth==24)
+			fillWithBackground = gd.getNextBoolean();
+		if (canEnlarge)
+			enlarge = gd.getNextBoolean();
+		return true;
+	}
+
+	/** Returns the current angle. */
+	public static double getAngle() {
+		return angle;
+	}
+
+	public void setNPasses(int nPasses) {
+	}
+
+}
+
diff --git a/src/ij/plugin/filter/SaltAndPepper.java b/src/ij/plugin/filter/SaltAndPepper.java
new file mode 100644
index 0000000..4089a5b
--- /dev/null
+++ b/src/ij/plugin/filter/SaltAndPepper.java
@@ -0,0 +1,44 @@
+package ij.plugin.filter;
+import java.awt.*;
+import java.util.*;
+import ij.*;
+import ij.process.*;
+
+/** Implements ImageJ's Process/Noise/Salt and Pepper command. */
+public class SaltAndPepper implements PlugInFilter {
+
+	Random r = new Random();
+
+	public int setup(String arg, ImagePlus imp) {
+		return IJ.setupDialog(imp, DOES_8G+DOES_8C+SUPPORTS_MASKING);
+	}
+
+	public void run(ImageProcessor ip) {
+		add(ip, 0.05);
+	}
+
+	public int rand(int min, int max) {
+		return min + r.nextInt(max-min);
+	}
+
+	public void add(ImageProcessor ip, double percent) {
+		Rectangle roi = ip.getRoi();
+		int n = (int)(percent*roi.width*roi.height);
+		byte[] pixels = (byte[])ip.getPixels();
+		int rx, ry;
+		int width = ip.getWidth();
+		int xmin = roi.x;
+		int xmax = roi.x+roi.width;
+		int ymin = roi.y;
+		int ymax = roi.y+roi.height;
+		for (int i=0; i<n/2; i++) {
+			rx = rand(xmin, xmax);
+			ry = rand(ymin, ymax);
+			pixels[ry*width+rx] = (byte)255;
+			rx = rand(xmin, xmax);
+			ry = rand(ymin, ymax);
+			pixels[ry*width+rx] = (byte)0;
+		}
+	}
+}
+
diff --git a/src/ij/plugin/filter/ScaleDialog.java b/src/ij/plugin/filter/ScaleDialog.java
new file mode 100644
index 0000000..f543309
--- /dev/null
+++ b/src/ij/plugin/filter/ScaleDialog.java
@@ -0,0 +1,191 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import ij.measure.*;
+import ij.util.Tools;
+import ij.io.FileOpener;
+import java.awt.*;
+import java.awt.event.*;
+
+/** Implements the Analyze/Set Scale command. */
+public class ScaleDialog implements PlugInFilter {
+
+    private ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		IJ.register(ScaleDialog.class);
+		return DOES_ALL+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		double measured = 0.0;
+		double known = 0.0;
+		double aspectRatio = 1.0;
+		String unit = "pixel";
+		boolean global1 = imp.getGlobalCalibration()!=null;
+		boolean global2;
+		Calibration cal = imp.getCalibration();
+		Calibration calOrig = cal.copy();
+		boolean isCalibrated = cal.scaled();
+		String length = "0.00";
+		
+		String scale = "<no scale>";
+		int digits = 2;
+		Roi roi = imp.getRoi();
+		if (roi!=null && (roi instanceof Line)) {
+			measured = ((Line)roi).getRawLength();
+			length = IJ.d2s(measured, 2);
+		}
+		if (isCalibrated) {
+			if (measured!=0.0)
+				known = measured*cal.pixelWidth;
+			else {
+				measured = 1.0/cal.pixelWidth;
+				known = 1.0;
+			}
+			double dscale = measured/known;
+			digits = Tools.getDecimalPlaces(dscale);
+			unit = cal.getUnit();
+			scale = IJ.d2s(dscale, digits)+" pixels/"+unit;
+			aspectRatio = cal.pixelHeight/cal.pixelWidth;
+		}
+		
+		digits = Tools.getDecimalPlaces(measured);
+		int asDigits = aspectRatio==1.0?1:3;
+		SetScaleDialog gd = new SetScaleDialog("Set Scale", scale, length);
+		gd.addNumericField("Distance in pixels:", measured, digits, 8, null);
+		gd.addNumericField("Known distance:", known, 2, 8, null);
+		gd.addNumericField("Pixel aspect ratio:", aspectRatio, asDigits, 8, null);
+		gd.addStringField("Unit of length:", unit);
+		gd.addPanel(makeButtonPanel(gd), GridBagConstraints.EAST, new Insets(5, 0, 0, 0));
+		gd.setInsets(0, 30, 0);
+		gd.addCheckbox("Global", global1);
+		gd.setInsets(10, 0, 0);
+		gd.addMessage("Scale: "+"12345.789 pixels per centimeter");
+		gd.addHelp(IJ.URL+"/docs/menus/analyze.html#scale");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		measured = gd.getNextNumber();
+		known = gd.getNextNumber();
+		if (aspectRatio==1.0)
+			gd.setSmartRecording(true);
+		aspectRatio = gd.getNextNumber();
+		gd.setSmartRecording(false);
+		unit = gd.getNextString();
+        if (unit.equals("A"))
+        	unit = ""+IJ.angstromSymbol;
+ 		global2 = gd.getNextBoolean();
+		if (measured==known && unit.equals("unit"))
+			unit = "pixel";
+		if (measured<=0.0 || known<=0.0 || unit.startsWith("pixel") || unit.startsWith("Pixel") || unit.equals("")) {
+			cal.pixelWidth = 1.0;
+			cal.pixelHeight = 1.0;
+			cal.pixelDepth = 1.0;
+			cal.setUnit("pixel");
+		} else {
+			if (gd.scaleChanged || IJ.macroRunning()) {
+				cal.pixelWidth = known/measured;
+				if (cal.pixelDepth==1.0)
+					cal.pixelDepth = cal.pixelWidth;
+			}
+			if (aspectRatio!=0.0)
+				cal.pixelHeight = cal.pixelWidth*aspectRatio;
+			else
+				cal.pixelHeight = cal.pixelWidth;
+			cal.setUnit(unit);
+		}
+		if (!cal.equals(calOrig)) {
+			imp.setCalibration(cal);
+			imp.changes = true;
+		}
+		imp.setGlobalCalibration(global2?cal:null);
+		if (global2 || global2!=global1)
+			WindowManager.repaintImageWindows();
+		else
+			imp.repaintWindow();
+		if (global2 && global2!=global1)
+			FileOpener.setShowConflictMessage(true);
+	}
+	
+	/** Creates a panel containing an "Unscale" button. */
+	Panel makeButtonPanel(SetScaleDialog gd) {
+		Panel panel = new Panel();
+    	panel.setLayout(new FlowLayout(FlowLayout.CENTER, 0, 0));
+		gd.unscaleButton = new Button("Click to Remove Scale");
+		gd.unscaleButton.addActionListener(gd);
+		panel.add(gd.unscaleButton);
+		return panel;
+	}
+
+}
+
+class SetScaleDialog extends GenericDialog {
+	static final String NO_SCALE = "<no scale>";
+	String initialScale;
+	Button unscaleButton;
+	String length;
+	boolean scaleChanged;
+
+	public SetScaleDialog(String title, String scale, String length) {
+		super(title);
+		initialScale = scale;
+		this.length = length;
+	}
+
+    protected void setup() {
+    	initialScale += "                   ";
+   		setScale(initialScale);
+    }
+ 	
+ 	public void textValueChanged(TextEvent e) {
+		Object source = e.getSource();
+		if (source==numberField.elementAt(0) || source==numberField.elementAt(1))
+			scaleChanged = true;
+ 		Double d = getValue(((TextField)numberField.elementAt(0)).getText());
+ 		if (d==null)
+ 			{setScale(NO_SCALE); return;}
+ 		double measured = d.doubleValue();
+ 		d = getValue(((TextField)numberField.elementAt(1)).getText());
+ 		if (d==null)
+ 			{setScale(NO_SCALE); return;}
+ 		double known = d.doubleValue();
+ 		String theScale;
+ 		String unit = ((TextField)stringField.elementAt(0)).getText();
+ 		boolean noUnit = unit.startsWith("pixel")||unit.startsWith("Pixel")||unit.equals("");
+ 		if (known>0.0 && noUnit && e.getSource()==numberField.elementAt(1)) {
+ 			unit = "unit";
+			((TextField)stringField.elementAt(0)).setText(unit);
+ 		}
+ 		boolean noScale = measured<=0||known<=0||noUnit;
+ 		if (noScale)
+ 			theScale = NO_SCALE;
+ 		else {
+ 			double scale = measured/known;
+			int digits = Tools.getDecimalPlaces(scale);
+ 			theScale = IJ.d2s(scale,digits)+(scale==1.0?" pixel/":" pixels/")+unit;
+ 		}
+ 		setScale(theScale);
+	}
+	
+	public void actionPerformed(ActionEvent e) { 
+		super.actionPerformed(e);
+		if (e.getSource()==unscaleButton) {
+			((TextField)numberField.elementAt(0)).setText(length);
+			((TextField)numberField.elementAt(1)).setText("0.00");
+			((TextField)numberField.elementAt(2)).setText("1.0");
+			((TextField)stringField.elementAt(0)).setText("pixel");
+			setScale(NO_SCALE);
+			scaleChanged = true;
+			if (IJ.isMacOSX())
+				{setVisible(false); setVisible(true);}
+		}
+	}
+
+	void setScale(String theScale) {
+ 		((Label)theLabel).setText("Scale: "+theScale);
+	}
+
+}
diff --git a/src/ij/plugin/filter/Shadows.java b/src/ij/plugin/filter/Shadows.java
new file mode 100644
index 0000000..c330fc6
--- /dev/null
+++ b/src/ij/plugin/filter/Shadows.java
@@ -0,0 +1,99 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import java.awt.*;
+
+/** Implements the commands in the Process/Shadows submenu. */
+public class Shadows implements PlugInFilter {
+	
+	String arg;
+	ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		if (imp!=null && imp.getStackSize()>1 && arg.equals("demo")) {
+			IJ.error("Shadows Demo does not work with stacks.");
+			return DONE;
+		}
+		return IJ.setupDialog(imp, DOES_ALL+SUPPORTS_MASKING);
+	}
+
+	public void run(ImageProcessor ip) {
+		if (arg.equals("demo")) {
+			int iterations = 20;
+			IJ.resetEscape();
+			for (int i=0; i<iterations; i++) {
+				north(ip); update(imp,ip,i,iterations);
+				northeast(ip); update(imp,ip,i,iterations);
+				east(ip); update(imp,ip,i,iterations);
+				southeast(ip); update(imp,ip,i,iterations);
+				south(ip); update(imp,ip,i,iterations);
+				southwest(ip); update(imp,ip,i,iterations);
+				west(ip); update(imp,ip,i,iterations);
+				northwest(ip); update(imp,ip,i,iterations);
+				if (IJ.escapePressed()) {
+					IJ.beep();
+					break;
+				};
+			}
+		}
+		else if (arg.equals("north")) north(ip);
+		else if (arg.equals("northeast")) northeast(ip);
+		else if (arg.equals("east")) east(ip);
+		else if (arg.equals("southeast")) southeast(ip);
+		else if (arg.equals("south")) south(ip);
+		else if (arg.equals("southwest")) southwest(ip);
+		else if (arg.equals("west")) west(ip);
+		else if (arg.equals("northwest")) northwest(ip);
+	}
+	
+	private static void update(ImagePlus imp, ImageProcessor ip, int i, int iterations) {
+		imp.updateAndDraw();
+		IJ.showStatus(i+"/"+iterations);
+		IJ.wait(50);
+		ip.reset();
+	}
+		
+		
+	public void north(ImageProcessor ip) {
+		int[] kernel = {1,2,1, 0,1,0,  -1,-2,-1};
+		ip.convolve3x3(kernel);
+	}
+
+	public void south(ImageProcessor ip) {
+		int[] kernel = {-1,-2,-1,  0,1,0,  1,2,1};
+		ip.convolve3x3(kernel);
+	}
+
+	public void east(ImageProcessor ip) {
+		int[] kernel = {-1,0,1,  -2,1,2,  -1,0,1};
+		ip.convolve3x3(kernel);
+	}
+
+	public void west(ImageProcessor ip) {
+		int[] kernel = {1,0,-1,  2,1,-2,  1,0,-1};
+		ip.convolve3x3(kernel);
+	}
+
+	public void northwest(ImageProcessor ip) {
+		int[] kernel = {2,1,0,  1,1,-1,  0,-1,-2};
+		ip.convolve3x3(kernel);
+	}
+
+	public void southeast(ImageProcessor ip) {
+		int[] kernel = {-2,-1,0,  -1,1,1,  0,1,2};
+		ip.convolve3x3(kernel);
+	}
+	
+	public void northeast(ImageProcessor ip) {
+		int[] kernel = {0,1,2,  -1,1,1,  -2,-1,0};
+		ip.convolve3x3(kernel);
+	}
+	
+	public void southwest(ImageProcessor ip) {
+		int[] kernel = {0,-1,-2,  1,1,-1,  2,1,0};
+		ip.convolve3x3(kernel);
+	}
+}
diff --git a/src/ij/plugin/filter/StackLabeler.java b/src/ij/plugin/filter/StackLabeler.java
new file mode 100644
index 0000000..7476787
--- /dev/null
+++ b/src/ij/plugin/filter/StackLabeler.java
@@ -0,0 +1,306 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.measure.Measurements;
+import java.awt.*;
+
+
+/** This plugin implements the Image/Stacks/Label command. */
+public class StackLabeler implements ExtendedPlugInFilter, DialogListener {
+	private static final String[] formats = {"0", "0000", "00:00", "00:00:00", "Text","Label"};
+	private static final int NUMBER=0, ZERO_PADDED_NUMBER=1, MIN_SEC=2, HOUR_MIN_SEC=3, TEXT=4, LABEL=5;
+	private static int format = (int)Prefs.get("label.format", NUMBER);
+	private int flags = DOES_ALL;
+	private ImagePlus imp;
+	private static int x = 5;
+	private static int y = 20;
+	private static int fontSize = 18;
+	private int maxWidth;
+	private Font font;
+	private static double start = 0;
+	private static double interval = 1;
+	private static String text = "";
+	private static int decimalPlaces = 0;
+	private static boolean useOverlay;
+	private static boolean useTextToolFont;
+	private int fieldWidth;
+	private Color color;
+	private int firstFrame, lastFrame, defaultLastFrame;
+	private Overlay overlay;
+	private Overlay baseOverlay;
+	private boolean previewing; 
+	private boolean virtualStack; 
+	private int yoffset;
+
+	public int setup(String arg, ImagePlus imp) {
+		if (imp!=null) {
+			virtualStack = imp.getStack().isVirtual();
+			if (virtualStack) useOverlay = true;
+			baseOverlay = imp.getOverlay();
+			flags += virtualStack?0:DOES_STACKS;
+			firstFrame=1; lastFrame=defaultLastFrame=imp.getStackSize();
+		}
+		this.imp = imp;
+		return flags;
+	}
+
+    public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+		ImageProcessor ip = imp.getProcessor();
+		Rectangle roi = ip.getRoi();
+		if (roi.width<ip.getWidth() || roi.height<ip.getHeight()) {
+			x = roi.x;
+			y = roi.y+roi.height;
+			fontSize = (int) ((roi.height - 1.10526)/0.934211);	
+			if (fontSize<7) fontSize = 7;
+			if (fontSize>80) fontSize = 80;
+		}
+		if (IJ.macroRunning()) {
+			format = NUMBER;
+			decimalPlaces = 0;
+		    interval=1;
+			text = "";
+			start = 0;
+			useOverlay = false;
+			useTextToolFont = false;
+			String options = Macro.getOptions();
+			if (options!=null) {
+				if (options.indexOf("interval=0")!=-1 && options.indexOf("format=")==-1)
+					format = TEXT;
+				if (options.indexOf(" slice=")!=-1) {
+					options = options.replaceAll(" slice=", " range=");
+					Macro.setOptions(options);
+				}
+			}
+		}
+		if (format<0||format>LABEL) format = NUMBER;
+		int defaultLastFrame = imp.getStackSize();
+		if (imp.isHyperStack()) {
+			if (imp.getNFrames()>1)
+				defaultLastFrame = imp.getNFrames();
+			else if (imp.getNSlices()>1)
+				defaultLastFrame = imp.getNSlices();
+		}
+		GenericDialog gd = new GenericDialog("Label Stacks");
+		gd.setInsets(2, 5, 0);
+		gd.addChoice("Format:", formats, formats[format]);
+		gd.addStringField("Starting value:", IJ.d2s(start,decimalPlaces));
+		gd.addStringField("Interval:", ""+IJ.d2s(interval,decimalPlaces));
+		gd.addNumericField("X location:", x, 0);
+		gd.addNumericField("Y location:", y, 0);
+		gd.addNumericField("Font size:", fontSize, 0);
+		gd.addStringField("Text:", text, 10);
+        addRange(gd, "Range:", 1, defaultLastFrame);
+		gd.setInsets(10,20,0);
+        gd.addCheckbox(" Use overlay", useOverlay);
+        gd.addCheckbox(" Use_text tool font", useTextToolFont);
+        gd.addPreviewCheckbox(pfr);
+        gd.addHelp(IJ.URL+"/docs/menus/image.html#label");
+        gd.addDialogListener(this);
+        previewing = true;
+		gd.showDialog();
+		previewing = false;
+		if (gd.wasCanceled())
+        	return DONE;
+        else
+        	return flags;
+    }
+
+	void addRange(GenericDialog gd, String label, int start, int end) {
+		gd.addStringField(label, start+"-"+end);
+	}
+	
+	double[] getRange(GenericDialog gd, int start, int end) {
+		String[] range = Tools.split(gd.getNextString(), " -");
+		double d1 = Tools.parseDouble(range[0]);
+		double d2 = range.length==2?Tools.parseDouble(range[1]):Double.NaN;
+		double[] result = new double[2];
+		result[0] = Double.isNaN(d1)?1:(int)d1;
+		result[1] = Double.isNaN(d2)?end:(int)d2;
+		if (result[0]<start) result[0] = start;
+		if (result[1]>end) result[1] = end;
+		if (result[0]>result[1]) {
+			result[0] = start;
+			result[1] = end;
+		}
+		return result;
+	}
+
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		format = gd.getNextChoiceIndex();
+		start = Tools.parseDouble(gd.getNextString());
+ 		String str = gd.getNextString();
+ 		interval = Tools.parseDouble(str);
+		x = (int)gd.getNextNumber();
+		y = (int)gd.getNextNumber();
+		fontSize = (int)gd.getNextNumber();
+		text = gd.getNextString();
+		double[] range = getRange(gd, 1, defaultLastFrame);
+		useOverlay = gd.getNextBoolean();
+		useTextToolFont = gd.getNextBoolean();
+		if (virtualStack) useOverlay = true;
+		firstFrame=(int)range[0]; lastFrame=(int)range[1];
+		int index = str.indexOf(".");
+		if (index!=-1)
+			decimalPlaces = str.length()-index-1;
+		else
+			decimalPlaces = 0;
+		if (gd.invalidNumber()) return false;
+		if (useTextToolFont)
+			font = new Font(TextRoi.getDefaultFontName(), TextRoi.getDefaultFontStyle(), fontSize);
+		else
+			font = new Font("SansSerif", Font.PLAIN, fontSize);
+		if (y<fontSize) y = fontSize+5;
+		ImageProcessor ip = imp.getProcessor();
+		ip.setFont(font);
+		int size = defaultLastFrame;
+		maxWidth = ip.getStringWidth(getString(size, interval, format));
+		fieldWidth = 1;
+		if (size>=10) fieldWidth = 2;
+		if (size>=100) fieldWidth = 3;
+		if (size>=1000) fieldWidth = 4;
+		if (size>=10000) fieldWidth = 5;
+		Prefs.set("label.format", format);
+        return true;
+    }
+	
+	public void run(ImageProcessor ip) {
+		int image = ip.getSliceNumber();
+		int n = image - 1;
+		if (imp.isHyperStack()) n = updateIndex(n);
+		if (virtualStack) {
+			int nSlices = imp.getStackSize();
+			if (previewing) nSlices = 1;
+			for (int i=1; i<=nSlices; i++) {
+				image=i; n=i-1;
+				if (imp.isHyperStack()) n = updateIndex(n);
+				drawLabel(ip, image, n);
+			}
+		} else {
+			if (previewing && overlay!=null) {
+				imp.setOverlay(baseOverlay);
+				overlay = null;
+			}
+			drawLabel(ip, image, n);
+		}
+	}
+	
+	int updateIndex(int n) {
+		if (imp.getNFrames()>1)
+			return (int)(n*((double)(imp.getNFrames())/imp.getStackSize()));
+		else if (imp.getNSlices()>1)
+			return (int)(n*((double)(imp.getNSlices())/imp.getStackSize()));
+		else
+			return n;
+	}
+	
+	void drawLabel(ImageProcessor ip, int image, int n) {
+		String s = getString(n, interval, format);
+		ip.setFont(font);
+		int textWidth = ip.getStringWidth(s);
+		if (color==null) {
+			color = Toolbar.getForegroundColor();
+			if ((color.getRGB()&0xffffff)==0) {
+				ip.setRoi(x, y-fontSize, maxWidth+textWidth, fontSize);
+				double mean = ImageStatistics.getStatistics(ip, Measurements.MEAN, null).mean;
+				if (mean<50.0 && !ip.isInvertedLut()) color=Color.white;
+				ip.resetRoi();
+			}
+		}
+		int frame = image;
+		int[] pos = new int[]{0, 0, 0};
+		if (imp.isHyperStack()) {
+			pos = imp.convertIndexToPosition(image);
+			if (imp.getNFrames()>1)
+				frame = pos[2];
+			else if (imp.getNSlices()>1)
+				frame = pos[1];
+		}
+		if (useOverlay) {
+			if (image==1) {
+				overlay = new Overlay();
+				if (baseOverlay!=null) {
+					for (int i=0; i<baseOverlay.size(); i++)
+						overlay.add(baseOverlay.get(i));
+				}
+				Roi roi = imp.getRoi();
+				Rectangle r = roi!=null?roi.getBounds():null;
+				yoffset = r!=null?r.height:fontSize;
+			}
+			if (frame>=firstFrame&&frame<=lastFrame) {
+				int xloc = format==LABEL?x:x+maxWidth-textWidth;
+				Roi roi = new TextRoi(xloc, y-yoffset, s, font);
+				roi.setStrokeColor(color);
+				roi.setNonScalable(true);
+				if (imp.isHyperStack())
+					roi.setPosition(pos[0], pos[1], pos[2]);
+				else
+					roi.setPosition(image);
+				overlay.add(roi);
+			}
+			if (image==imp.getStackSize()||previewing)
+				imp.setOverlay(overlay);
+		} else if (frame>=firstFrame&&frame<=lastFrame) {
+			ip.setColor(color); 
+			ip.setAntialiasedText(fontSize>=18);
+			int xloc = format==LABEL?x:x+maxWidth-textWidth;
+			ip.moveTo(xloc, y);
+			ip.drawString(s);
+		}
+	}
+	
+	String getString(int index, double interval, int format) {
+		double time = start + (index+1-firstFrame)*interval;
+		int itime = (int)Math.floor(time);
+		int sign = 1;
+		if (itime < 0) sign = -1;
+		itime = itime*sign;
+		String str = "";
+		switch (format) {
+			case NUMBER: str=IJ.d2s(time, decimalPlaces)+" "+text; break;
+			case ZERO_PADDED_NUMBER:
+				if (decimalPlaces==0)
+					str=zeroFill((int)time); 
+				else
+					str=IJ.d2s(time, decimalPlaces);
+				str = text +" " + str;
+				break;
+			case MIN_SEC:
+				str=pad((int)Math.floor((itime/60)%60))+":"+pad(itime%60)+" "+text;
+				if (sign == -1) str = "-"+str;
+				break;
+			case HOUR_MIN_SEC:
+				str=pad((int)Math.floor(itime/3600))+":"+pad((int)Math.floor((itime/60)%60))+":"+pad(itime%60)+" "+text;
+				if (sign == -1) str = "-"+str;
+				break;
+			case TEXT: 
+				str=text; 
+				break;
+			case LABEL:
+				if (0<=index && index<imp.getStackSize()) {
+					str = imp.getStack().getShortSliceLabel(index+1);
+					str = str==null?"null slice label ("+(index+1)+")":str;
+				} else
+					str="void";
+				break;
+		}
+		return str;
+	}
+
+	String pad(int n) {
+		String str = ""+n;
+		if (str.length()==1) str="0"+str;
+		return str;
+	}
+	
+	String  zeroFill(int n) {
+		String str = ""+n;
+		while (str.length()<fieldWidth)
+			str = "0" + str;
+		return str;
+	}
+		
+	public void setNPasses (int nPasses) {}
+
+}
diff --git a/src/ij/plugin/filter/ThresholdToSelection.java b/src/ij/plugin/filter/ThresholdToSelection.java
new file mode 100644
index 0000000..f1c6822
--- /dev/null
+++ b/src/ij/plugin/filter/ThresholdToSelection.java
@@ -0,0 +1,427 @@
+/*
+ * This plugin implements the Edit/Selection/Create Selection command.
+ * It is based on a proposal by Tom Larkworthy.
+ * Written and public domained in June 2006 by Johannes E. Schindelin
+*/
+package ij.plugin.filter;
+import ij.IJ;
+import ij.ImagePlus;
+import ij.gui.Roi;
+import ij.gui.ShapeRoi;
+import ij.process.*;
+
+import java.awt.Polygon;
+import java.awt.Rectangle;
+import java.awt.geom.Area;
+import java.awt.geom.GeneralPath;
+import java.util.ArrayList;
+
+public class ThresholdToSelection implements PlugInFilter {
+	ImagePlus image;
+	ImageProcessor ip;
+	float min, max;
+	int w, h;
+	boolean showStatus;
+	final static double PROGRESS_FRACTION_OUTLINING = 0.9;  //fraction of progress bar for the first phase (tracing outlines)
+	
+	public void run(ImageProcessor ip) {
+		showStatus = true;
+		image.setRoi(convert(ip));
+	}
+	
+	/** Returns a selection created from the thresholded pixels in the
+		specified image, or null if there are no thresholded pixels. */
+	public static Roi run(ImagePlus imp) {
+		ThresholdToSelection tts = new ThresholdToSelection();
+		return tts.convert(imp.getProcessor());
+	}
+	
+	/** Returns a selection created from the thresholded pixels in the
+		specified image, or null if there are no thresholded pixels. */
+	public Roi convert(ImageProcessor ip) {
+		this.ip = ip;
+		min = (float)ip.getMinThreshold();
+		max = (float)ip.getMaxThreshold();
+		w = ip.getWidth();
+		h = ip.getHeight();
+		return getRoi();
+	}
+
+	final boolean selected(int x, int y) {
+		float v = ip.getf(x,y);
+		return v>=min && v<=max;
+	}
+
+	/*
+	 * This class implements a Cartesian polygon in progress.
+	 * The edges are supposed to be parallel to the x or y axis.
+	 * It is implemented as a deque to be able to add points to both
+	 * sides.
+	 */
+	static class Outline {
+		int[] x, y;
+		int first, last, reserved;
+		final int GROW = 10;  // default extra (spare) space when enlarging arrays (similar performance with 6-20)
+
+		public Outline() {
+			reserved = GROW;
+			x = new int[reserved];
+			y = new int[reserved];
+			first = last = GROW / 2;
+		}
+
+		/** Makes sure that enough free space is available at the beginning and end of the list, by enlarging the arrays if required */
+		private void needs(int neededAtBegin, int neededAtEnd) {
+			if (neededAtBegin > first || neededAtEnd > reserved - last) {
+				int extraSpace = Math.max(GROW, Math.abs(x[last-1] - x[first])); //reserve more space for outlines that span large x range
+				int newSize = reserved + neededAtBegin + neededAtEnd + extraSpace;
+				int newFirst = neededAtBegin + extraSpace/2;
+				int[] newX = new int[newSize];
+				int[] newY = new int[newSize];
+				System.arraycopy(x, first, newX, newFirst, last-first);
+				System.arraycopy(y, first, newY, newFirst, last-first);
+				x = newX;
+				y = newY;
+				last += newFirst - first;
+				first = newFirst;
+				reserved = newSize;
+			}
+		}
+
+		/** Adds point x, y at the end of the list */
+		public void append(int x, int y) {
+			if (last-first>=2 && collinear(this.x[last-2], this.y[last-2], this.x[last-1], this.y[last-1], x , y)) {
+				this.x[last-1] = x; //replace previous point
+				this.y[last-1] = y;
+			} else {
+				needs(0, 1); //new point
+				this.x[last] = x;
+				this.y[last] = y;
+				last++;
+			}
+		}
+
+		/** Adds point x, y at the beginning of the list */
+		public void prepend(int x, int y) {
+			if (last-first>=2 && collinear(this.x[first+1], this.y[first+1], this.x[first], this.y[first], x , y)) {
+				this.x[first] = x; //replace previous point
+				this.y[first] = y;
+			} else {
+				needs(1, 0); //new point
+				first--;
+				this.x[first] = x;
+				this.y[first] = y;
+			}
+		}
+
+		/** Merge with another Outline by adding it at the end. Thereafter, the other outline must not be used any more. */
+		public void append(Outline o) {
+			int size = last - first;
+			int oSize = o.last - o.first;
+			if (size <= o.first && oSize > reserved - last) { // we don't have enough space in our own array but in that of 'o'
+				System.arraycopy(x, first, o.x, o.first - size, size); // so prepend our own data to that of 'o'
+				System.arraycopy(y, first, o.y, o.first - size, size);
+				x = o.x;
+				y = o.y;
+				first = o.first - size;
+				last = o.last;
+				reserved = o.reserved;
+			} else {  // append to our own array
+				needs(0, oSize);
+				System.arraycopy(o.x, o.first, x, last, oSize);
+				System.arraycopy(o.y, o.first, y, last, oSize);
+				last += oSize;
+			}
+		}
+
+		/** Merge with another Outline by adding it at the beginning. Thereafter, the other outline must not be used any more. */
+		public void prepend(Outline o) {
+			int size = last - first;
+			int oSize = o.last - o.first;
+			if (size <= o.reserved - o.last && oSize > first) { // we don't have enough space in our own array but in that of 'o'
+				System.arraycopy(x, first, o.x, o.last, size);  // so append our own data to that of 'o'
+				System.arraycopy(y, first, o.y, o.last, size);
+				x = o.x;
+				y = o.y;
+				first = o.first;
+				last = o.last + size;
+				reserved = o.reserved;
+			} else {  // prepend to our own array
+				needs(oSize, 0);
+				first -= oSize;
+				System.arraycopy(o.x, o.first, x, first, oSize);
+				System.arraycopy(o.y, o.first, y, first, oSize);
+			}
+		}
+
+		public Polygon getPolygon() {
+			// optimize out intermediate points of straight lines (created, e.g., by merging outlines)
+			int i, j=first+1;
+			for (i=first+1; i+1<last; j++) {
+				if (collinear(x[j - 1], y[j - 1], x[j], y[j], x[j + 1], y[j + 1])) {
+					// merge i + 1 into i
+					last--;
+					continue;
+				}
+				if (i != j) {
+					x[i] = x[j];
+					y[i] = y[j];
+				}
+				i++;
+			}
+			// wraparound
+			if (collinear(x[j - 1], y[j - 1], x[j], y[j], x[first], y[first]))
+				last--;
+			else {
+				x[i] = x[j];
+				y[i] = y[j];
+			}
+			if (last - first > 2 && collinear(x[last - 1], y[last - 1], x[first], y[first], x[first + 1], y[first + 1]))
+				first++;
+
+			int count = last - first;
+			int[] xNew = new int[count];
+			int[] yNew = new int[count];
+			System.arraycopy(x, first, xNew, 0, count);
+			System.arraycopy(y, first, yNew, 0, count);
+			return new Polygon(xNew, yNew, count);
+		}
+
+		/** Returns whether three points are on one straight line */
+		boolean collinear (int x1, int y1, int x2, int y2, int x3, int y3) {
+			return (x2-x1)*(y3-y2) == (y2-y1)*(x3-x2);
+		}
+
+		public String toString() {
+			String res = "[first:" + first + ",last:" + last +
+				",reserved:" + reserved + ":";
+			if (last > x.length) System.err.println("ERROR!");
+			int nmax = 10;	//don't print more coordinates than this
+			for (int i = first; i < last && i < x.length; i++) {
+				if (last-first > nmax && i-first > nmax/2) {
+					i = last - nmax/2;
+					res += "...";
+					nmax = last-first; //dont check again
+				} else
+					res += "(" + x[i] + "," + y[i] + ")";
+				}
+			return res + "]";
+		}
+	}
+
+	/*
+	 * Construct all outlines simultaneously by traversing the rows from top to bottom.
+	 * The points are added such that for each pair of consecutive points, the inner
+	 * part is on the left, i.e., the outline encloses filled areas in the
+	 * counterclockwise direction. The outline of empty areas (holes) runs clockwise.
+	 *
+	 * thisRow[x + 1] indicates whether the pixel at (x, y) is selected (inside threshold bounds).
+	 * prevRow[x + 1] indicates whether the pixel at (x, y - 1) is selected.
+	 *
+	 * outline[x] is the outline that is currently unclosed at the top-left corner of pixel(x, y);
+	 * outline[x + 1] is at the top-right corner of pixel(x, y).
+	 *
+	 * If the pixel (x, y - 1) has an outline at its bottom and right sides (merging in its
+	 * lower right corner) and this outline should continue as left & top edges of pixel (x + 1, y),
+	 * <code>xAfterLowerRightCorner</code> is set to x + 1 (the pixel coordinate where this
+	 * has to be taken into account), and <code>oAfterLowerRightCorner</code> is the outline that
+	 * should continue at the left side of pixel (xAfterLowerRightCorner, y) to higher y.
+	 * (Without the code with xAfterLowerRightCorner, etc., this case of 8-connected pixels
+	 * would result in disjunct outlines, e.g. a one-pixel-wide line with angle between
+	 * 0 and -90 deg would be converted to many separate rectangular segments).
+	 */
+	Roi getRoi() {
+		if (showStatus)
+			IJ.showStatus("Converting threshold to selection");
+		boolean[] prevRow, thisRow;
+		ArrayList polygons = new ArrayList();
+		Outline[] outline;
+		int progressInc = Math.max(h/50, 1);
+
+		prevRow = new boolean[w + 2];
+		thisRow = new boolean[w + 2];
+		outline = new Outline[w + 1];
+
+		for (int y = 0; y <= h; y++) {
+			boolean[] b = prevRow; prevRow = thisRow; thisRow = b;
+			int xAfterLowerRightCorner = -1;	   //x at right of 8-connected (not 4-connected) pixels NW-SE
+			Outline oAfterLowerRightCorner = null; //there, continue this outline towards south
+			thisRow[1] = y < h ? selected(0, y) : false;
+			for (int x = 0; x <= w; x++) {
+				if (y < h && x < w - 1)
+					thisRow[x + 2] = selected(x + 1, y);  //we need to read one pixel ahead
+				else if (x < w - 1)
+					thisRow[x + 2] = false;
+				//IJ.log(x+","+y+": "+thisRow[x + 1]+(x==xAfterLowerRightCorner ? " Corner" : "")+" left="+outline[x]+(x < w ? " right="+outline[x+1] : ""));
+				if (thisRow[x + 1]) {  // i.e., pixel (x,y) is selected
+					if (!prevRow[x + 1]) {
+						// Upper edge of selected area:
+						// - left and right outlines are null: new outline
+						// - left null: append (line to left)
+						// - right null: prepend (line to right), or prepend&append (after lower right corner, two borders from one corner)
+						// - left == right: close (end of hole above) unless we can continue at the right
+						// - left != right: merge (prepend) unless we can continue at the right
+						if (outline[x] == null) {
+							if (outline[x + 1] == null) {
+								outline[x + 1] = outline[x] = new Outline();
+								outline[x].append(x + 1, y);
+								outline[x].append(x, y);
+							} else {
+								outline[x] = outline[x + 1];  // line from top-right to top-left
+								outline[x + 1] = null;
+								outline[x].append(x, y);
+							}
+						} else if (outline[x + 1] == null) {
+							if (x == xAfterLowerRightCorner) {
+								outline[x + 1] = outline[x];
+								outline[x] = oAfterLowerRightCorner;
+								outline[x].append(x, y);
+								outline[x + 1].prepend(x + 1, y);
+							} else {
+								outline[x + 1] = outline[x];
+								outline[x] = null;
+								outline[x + 1].prepend(x + 1, y);
+							}
+						} else if (outline[x + 1] == outline[x]) {
+							if (x < w - 1 && y < h && x != xAfterLowerRightCorner
+									&& !thisRow[x + 2] && prevRow[x + 2]) { //at lower right corner & next pxl deselected
+								outline[x] = null;
+								//outline[x+1] unchanged
+								outline[x + 1].prepend(x + 1,y);
+								xAfterLowerRightCorner = x + 1;
+								oAfterLowerRightCorner = outline[x + 1];
+							} else {
+								//System.err.println("subtract " + outline[x]);
+								polygons.add(outline[x].getPolygon()); // MINUS (add inner hole)
+								outline[x + 1] = null;
+								outline[x] = (x == xAfterLowerRightCorner) ? oAfterLowerRightCorner : null;
+							}
+						} else {
+							outline[x].prepend(outline[x + 1]);		// merge
+							for (int x1 = 0; x1 <= w; x1++)
+								if (x1 != x + 1 && outline[x1] == outline[x + 1]) {
+									outline[x1] = outline[x];        // after merging, replace old with merged
+									outline[x + 1] = null;           // no line continues at the right
+									outline[x] = (x == xAfterLowerRightCorner) ? oAfterLowerRightCorner : null;
+									break;
+								}
+							if (outline[x + 1] != null)
+								throw new RuntimeException("assertion failed");							
+						}
+					}
+					if (!thisRow[x]) {
+						// left edge
+						if (outline[x] == null)
+							throw new RuntimeException("assertion failed");
+						outline[x].append(x, y + 1);
+					}
+				} else {  // !thisRow[x + 1], i.e., pixel (x,y) is deselected
+					if (prevRow[x + 1]) {
+						// Lower edge of selected area:
+						// - left and right outlines are null: new outline
+						// - left == null: prepend
+						// - right == null: append, or append&prepend (after lower right corner, two borders from one corner)
+						// - right == left: close unless we can continue at the right
+						// - right != left: merge (append) unless we can continue at the right
+						if (outline[x] == null) {
+							if (outline[x + 1] == null) {
+								outline[x] = outline[x + 1] = new Outline();
+								outline[x].append(x, y);
+								outline[x].append(x + 1, y);
+							} else {
+									outline[x] = outline[x + 1];
+									outline[x + 1] = null;
+									outline[x].prepend(x, y);
+							}
+						} else if (outline[x + 1] == null) {
+							if (x == xAfterLowerRightCorner) {
+								outline[x + 1] = outline[x];
+								outline[x] = oAfterLowerRightCorner;
+								outline[x].prepend(x, y);
+								outline[x + 1].append(x + 1, y);
+							} else {
+								outline[x + 1] = outline[x];
+								outline[x] = null;
+								outline[x + 1].append(x + 1, y);
+							}
+						} else if (outline[x + 1] == outline[x]) {
+							//System.err.println("add " + outline[x]);
+							if (x < w - 1 && y < h && x != xAfterLowerRightCorner
+									&& thisRow[x + 2] && !prevRow[x + 2]) { //at lower right corner & next pxl selected
+								outline[x] = null;
+								//outline[x+1] unchanged
+								outline[x + 1].append(x + 1,y);
+								xAfterLowerRightCorner = x + 1;
+								oAfterLowerRightCorner = outline[x + 1];
+							} else {
+								polygons.add(outline[x].getPolygon());   // PLUS (add filled outline)
+								outline[x + 1] = null;
+								outline[x] = x == xAfterLowerRightCorner ? oAfterLowerRightCorner : null;
+							}
+						} else {
+							if (x < w - 1 && y < h && x != xAfterLowerRightCorner
+									&& thisRow[x + 2] && !prevRow[x + 2]) { //at lower right corner && next pxl selected
+								outline[x].append(x + 1, y);
+								outline[x + 1].prepend(x + 1,y);
+								xAfterLowerRightCorner = x + 1;
+								oAfterLowerRightCorner = outline[x];
+								// outline[x + 1] unchanged (the one at the right-hand side of (x, y-1) to the top)
+								outline[x] = null;
+							} else {
+								outline[x].append(outline[x + 1]);         // merge
+								for (int x1 = 0; x1 <= w; x1++)
+									if (x1 != x + 1 && outline[x1] == outline[x + 1]) {
+										outline[x1] = outline[x];        // after merging, replace old with merged
+										outline[x + 1] = null;           // no line continues at the right
+										outline[x] = (x == xAfterLowerRightCorner) ? oAfterLowerRightCorner : null;
+										break;
+									}
+								if (outline[x + 1] != null)
+									throw new RuntimeException("assertion failed");
+							}
+						}
+					}
+					if (thisRow[x]) {
+						// right edge
+						if (outline[x] == null)
+							throw new RuntimeException("assertion failed");
+						outline[x].prepend(x, y + 1);
+					}
+				}
+			}
+			if (y%progressInc==0) {
+				if (Thread.currentThread().isInterrupted()) return null;
+				if (showStatus)
+					IJ.showProgress(y*(PROGRESS_FRACTION_OUTLINING/h));
+			}
+		}
+		
+		if (polygons.size()==0)
+			return null;
+		if (showStatus) IJ.showStatus("Converting threshold to selection...");
+		GeneralPath path = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
+		progressInc = Math.max(polygons.size()/10, 1);
+		for (int i = 0; i < polygons.size(); i++) {
+			path.append((Polygon)polygons.get(i), false);
+			if (Thread.currentThread().isInterrupted()) return null;
+			if (showStatus && i%progressInc==0)
+				IJ.showProgress(PROGRESS_FRACTION_OUTLINING + i*(1.-PROGRESS_FRACTION_OUTLINING)/polygons.size());
+		}
+
+		ShapeRoi shape = new ShapeRoi(path);
+		Roi roi = shape!=null ? shape.trySimplify():null; // try to convert to non-composite ROI
+		if (showStatus)
+			IJ.showProgress(1.0);
+		return roi;
+	}
+
+	public int setup(String arg, ImagePlus imp) {
+		image = imp;
+		return DOES_8G | DOES_16 | DOES_32 | NO_CHANGES;
+	}
+
+	/** Determines whether to show status messages and a progress bar */
+	public void showStatus(boolean showStatus) {
+		this.showStatus = showStatus;
+	}
+}
diff --git a/src/ij/plugin/filter/Transformer.java b/src/ij/plugin/filter/Transformer.java
new file mode 100644
index 0000000..27301e8
--- /dev/null
+++ b/src/ij/plugin/filter/Transformer.java
@@ -0,0 +1,92 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.awt.image.*;
+
+/** Implements the Flip and Rotate commands in the Image/Transform submenu. */
+public class Transformer implements PlugInFilter {	
+	private ImagePlus imp;
+	private String arg;
+	private Overlay overlay;
+	private boolean firstSlice = true;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		if (imp!=null)
+			overlay = imp.getOverlay();
+		if (arg.equals("fliph") || arg.equals("flipv"))
+			return IJ.setupDialog(imp, DOES_ALL+NO_UNDO);
+		else
+			return DOES_ALL+NO_UNDO+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		Calibration cal = imp.getCalibration();
+		boolean transformOrigin = cal.xOrigin!=0 || cal.yOrigin!=0;
+		if (arg.equals("fliph")) {
+			ip.flipHorizontal();
+			Rectangle r = ip.getRoi();
+			if (transformOrigin && r.x==0 && r.y==0 && r.width==ip.getWidth() && r.height==ip.getHeight())
+				cal.xOrigin = imp.getWidth()-1 - cal.xOrigin;
+			return;
+		}
+		if (arg.equals("flipv")) {
+			ip.flipVertical();
+			Rectangle r = ip.getRoi();
+			if (transformOrigin && r.x==0 && r.y==0 && r.width==ip.getWidth() && r.height==ip.getHeight())
+	    		cal.yOrigin = imp.getHeight()-1 - cal.yOrigin;
+			return;
+		}
+		if (arg.equals("right") || arg.equals("left")) {
+	    	StackProcessor sp = new StackProcessor(imp.getStack(), ip);
+	    	ImageStack s2 = null;
+			if (arg.equals("right")) {
+	    		s2 = sp.rotateRight();
+				rotateOverlay(90);
+	    		if (transformOrigin) {
+	    			double xOrigin = imp.getHeight()-1 - cal.yOrigin;
+	    			double yOrigin = cal.xOrigin;
+	    			cal.xOrigin = xOrigin;
+	    			cal.yOrigin = yOrigin;
+	    		}
+	    	} else {
+	    		s2 = sp.rotateLeft();
+				rotateOverlay(-90);
+	    		if (transformOrigin) {
+	    			double xOrigin = cal.yOrigin;
+	    			double yOrigin = imp.getWidth()-1 - cal.xOrigin;
+	    			cal.xOrigin = xOrigin;
+	    			cal.yOrigin = yOrigin;
+	    		}
+	    	}
+	    	imp.setStack(null, s2);
+	    	double pixelWidth = cal.pixelWidth;
+	    	cal.pixelWidth = cal.pixelHeight;
+	    	cal.pixelHeight = pixelWidth;
+			if (!cal.getXUnit().equals(cal.getYUnit())) {
+				String xUnit = cal.getXUnit();
+				cal.setXUnit(cal.getYUnit());
+				cal.setYUnit(xUnit);
+			}
+			return;
+		}
+	}
+	
+	private void rotateOverlay(int angle) {
+		if (overlay!=null && firstSlice) {
+			double xcenter = imp.getWidth()/2.0;
+			double ycenter = imp.getHeight()/2.0;
+			double diff1 = xcenter-ycenter;
+			double diff2 = ycenter-xcenter;
+			Overlay overlay2 = overlay.rotate(angle,xcenter,ycenter);
+			overlay2.translate(diff2,diff1);
+			imp.setOverlay(overlay2);
+		}
+		firstSlice = false;
+	}
+	
+}
diff --git a/src/ij/plugin/filter/Translator.java b/src/ij/plugin/filter/Translator.java
new file mode 100644
index 0000000..635674b
--- /dev/null
+++ b/src/ij/plugin/filter/Translator.java
@@ -0,0 +1,83 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import java.awt.*;
+import java.awt.geom.*;
+
+
+/** This plugin implements the Image/Translate command. */
+public class Translator implements ExtendedPlugInFilter, DialogListener {
+	private int flags = DOES_ALL|PARALLELIZE_STACKS;
+	private static double xOffset = 15;
+	private static double yOffset = 15;
+	private ImagePlus imp;
+	private GenericDialog gd;
+	private PlugInFilterRunner pfr;
+	private static int interpolationMethod = ImageProcessor.NONE;
+	private String[] methods = ImageProcessor.getInterpolationMethods();
+	private boolean previewing;
+	private Overlay origOverlay;
+	private boolean overlayOnly;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		if (imp!=null) {
+			origOverlay = imp.getOverlay();
+			Undo.saveOverlay(imp);
+		}
+		return flags;
+	}
+
+	public void run(ImageProcessor ip) {
+		ip.setInterpolationMethod(interpolationMethod);
+		if (!overlayOnly || origOverlay==null)
+			ip.translate(xOffset, yOffset);
+		if (origOverlay!=null) {
+			Overlay overlay = origOverlay.duplicate();
+			overlay.translate(xOffset, yOffset);
+			imp.setOverlay(overlay);
+		}
+	}
+
+	public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+		this.pfr = pfr;
+		int digits = xOffset==(int)xOffset&&yOffset==(int)yOffset?1:3;
+		if (IJ.isMacro())
+			interpolationMethod = ImageProcessor.NONE;
+		gd = new GenericDialog("Translate");
+		gd.addSlider("X offset:", -100, 100, xOffset, 0.1);
+		gd.addSlider("Y offset:", -100, 100, xOffset, 0.1);
+		gd.addChoice("Interpolation:", methods, methods[interpolationMethod]);
+		if (origOverlay!=null)
+			gd.addCheckbox("Overlay only", false);
+		gd.addPreviewCheckbox(pfr);
+		gd.addDialogListener(this);
+		previewing = true;
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			imp.setOverlay(origOverlay);
+			return DONE;
+		}
+		previewing = false;
+		return IJ.setupDialog(imp, flags);
+	}
+	
+	public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+		xOffset = gd.getNextNumber();
+		yOffset = gd.getNextNumber();
+		interpolationMethod = gd.getNextChoiceIndex();
+		if (origOverlay!=null)
+			overlayOnly = gd.getNextBoolean();
+		if (gd.invalidNumber()) {
+			if (gd.wasOKed()) IJ.error("Offset is invalid.");
+			return false;
+		}
+		return true;
+	}
+
+	public void setNPasses(int nPasses) {
+	}
+
+}
+
diff --git a/src/ij/plugin/filter/UnsharpMask.java b/src/ij/plugin/filter/UnsharpMask.java
new file mode 100644
index 0000000..22ff2f3
--- /dev/null
+++ b/src/ij/plugin/filter/UnsharpMask.java
@@ -0,0 +1,99 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.gui.GenericDialog;
+import ij.gui.DialogListener;
+import ij.process.*;
+import ij.plugin.filter.GaussianBlur;
+import ij.measure.Measurements;
+import java.awt.*;
+
+/** This plugin-filter implements ImageJ's Unsharp Mask command.
+ * Unsharp masking subtracts a blurred copy of the image and rescales the image
+ * to obtain the same contrast of large (low-frequency) structures as in the
+ * input image. This is equivalent to adding a high-pass filtered image and
+ * thus sharpens the image.
+ * "Radius (Sigma)" is the standard deviation (blur radius) of the Gaussian blur that
+ * is subtracted. "Mask Weight" determines the strength of filtering, where "Mask Weight"=1
+ * would be an infinite weight of the high-pass filtered image that is added.
+ */
+public class UnsharpMask implements ExtendedPlugInFilter, DialogListener {
+    private static double sigma = 1.0; // standard deviation of the Gaussian
+    private static double weight = 0.6; // weight of the mask
+    private final int flags = DOES_ALL|SUPPORTS_MASKING|CONVERT_TO_FLOAT|SNAPSHOT|KEEP_PREVIEW;
+    private GaussianBlur gb;
+
+    /** Method to return types supported
+     * @param arg Not used by this plugin
+     * @param imp The image to be filtered
+     * @return Code describing supported formats etc.
+     * (see ij.plugin.filter.PlugInFilter & ExtendedPlugInFilter)
+     */
+    public int setup(String arg, ImagePlus imp) {
+        return flags;
+    }
+    
+    /** This method is invoked for each slice or color channel. It filters
+     * an image by enhancing high-frequency components. Since this
+     * PlugInFilter specifies the CONVERT_TO_FLOAT and SNAPHOT
+     * flags, 'ip' is always a FloatProcessor with a valid snapshot.
+     * @param ip The image, slice or channel to filter
+     */
+    public void run(ImageProcessor ip) {
+        sharpenFloat((FloatProcessor)ip, sigma, (float)weight);
+    }
+    
+    /** Unsharp Mask filtering of a float image. 'fp' must have a valid snapshot. */
+    public void sharpenFloat(FloatProcessor fp, double sigma, float weight) {
+        if (gb == null) gb = new GaussianBlur();
+        gb.blurGaussian(fp, sigma, sigma, 0.01);
+        if (Thread.currentThread().isInterrupted()) return;
+        float[] pixels = (float[])fp.getPixels();
+        float[] snapshotPixels = (float[])fp.getSnapshotPixels();
+        int width = fp.getWidth();
+        Rectangle roi = fp.getRoi();
+        for (int y=roi.y; y<roi.y+roi.height; y++)
+            for (int x=roi.x, p=width*y+x; x<roi.x+roi.width; x++,p++)
+                pixels[p] = (snapshotPixels[p] - weight*pixels[p])/(1f - weight);
+    }
+
+    /** Ask the user for the parameters */
+    public int showDialog(ImagePlus imp, String command, PlugInFilterRunner pfr) {
+        String options = Macro.getOptions();
+        boolean oldMacro = false;    //for old macros, "gaussian radius" was 2.5 sigma
+        if  (options!=null) {
+            if (options.indexOf("gaussian=") >= 0) {
+                oldMacro = true;
+                Macro.setOptions(options.replaceAll("gaussian=", "radius="));
+            }
+        }
+        GenericDialog gd = new GenericDialog(command);
+        sigma = Math.abs(sigma);
+        if (weight<0) weight = 0;
+        if (weight>0.99) weight = 0.99; 
+        gd.addNumericField("Radius (Sigma)", sigma, 1, 6, "pixels");
+        gd.addNumericField("Mask Weight (0.1-0.9)", weight,2);
+        gd.addPreviewCheckbox(pfr);
+        gd.addDialogListener(this);
+        gd.showDialog();                        //input by the user (or macro) happens here
+        if (gd.wasCanceled()) return DONE;
+        if (oldMacro) sigma /= 2.5;
+        IJ.register(this.getClass());           //protect static class variables (parameters) from garbage collection
+        return IJ.setupDialog(imp, flags);      //ask whether to process all slices of stack (if a stack)
+    }
+
+    public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+        sigma = gd.getNextNumber();
+        weight = gd.getNextNumber();
+        if (sigma < 0 || weight < 0 || weight > 0.99 || gd.invalidNumber())
+            return false;
+        else return true;
+    }
+
+    /** Since most computing time is spent in GaussianBlur, forward the
+     * information about the number of passes to Gaussian Blur. The
+     * ProgressBar will be handled by GaussianBlur. */
+    public void setNPasses(int nPasses) {
+        if (gb == null) gb = new GaussianBlur();
+        gb.setNPasses(nPasses); 
+    }
+}
diff --git a/src/ij/plugin/filter/Writer.java b/src/ij/plugin/filter/Writer.java
new file mode 100644
index 0000000..27b2b3d
--- /dev/null
+++ b/src/ij/plugin/filter/Writer.java
@@ -0,0 +1,47 @@
+package ij.plugin.filter;
+import ij.*;
+import ij.process.*;
+import ij.io.*;
+
+
+/** Obsolete
+* @deprecated
+*/
+public class Writer implements PlugInFilter {
+	private String arg;
+    private ImagePlus imp;
+    
+	public int setup(String arg, ImagePlus imp) {
+		this.arg = arg;
+		this.imp = imp;
+		return DOES_ALL+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		if (arg.equals("tiff"))
+			new FileSaver(imp).saveAsTiff();
+		else if (arg.equals("gif"))
+			new FileSaver(imp).saveAsGif();
+		else if (arg.equals("jpeg"))
+			new FileSaver(imp).saveAsJpeg();
+		else if (arg.equals("text"))
+			new FileSaver(imp).saveAsText();
+		else if (arg.equals("lut"))
+			new FileSaver(imp).saveAsLut();
+		else if (arg.equals("raw"))
+			new FileSaver(imp).saveAsRaw();
+		else if (arg.equals("zip"))
+			new FileSaver(imp).saveAsZip();
+		else if (arg.equals("bmp"))
+			new FileSaver(imp).saveAsBmp();
+		else if (arg.equals("png"))
+			new FileSaver(imp).saveAsPng();
+		else if (arg.equals("pgm"))
+			new FileSaver(imp).saveAsPgm();
+		else if (arg.equals("fits"))
+			new FileSaver(imp).saveAsFits();
+	}
+	
+}
+
+
diff --git a/src/ij/plugin/filter/XYWriter.java b/src/ij/plugin/filter/XYWriter.java
new file mode 100644
index 0000000..37f66d6
--- /dev/null
+++ b/src/ij/plugin/filter/XYWriter.java
@@ -0,0 +1,65 @@
+package ij.plugin.filter;
+
+import java.awt.*;
+import java.awt.image.*;
+import java.util.Vector;
+import java.io.*;
+import ij.*;
+import ij.process.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.measure.*;
+import java.awt.geom.*;
+
+
+/** Saves the XY coordinates of the current ROI boundary. */
+public class XYWriter implements PlugInFilter {
+	ImagePlus imp;
+
+	public int setup(String arg, ImagePlus imp) {
+		this.imp = imp;
+		return DOES_ALL+ROI_REQUIRED+NO_CHANGES;
+	}
+
+	public void run(ImageProcessor ip) {
+		saveXYCoordinates(imp);
+	}
+
+	public void saveXYCoordinates(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		if (roi==null)
+			throw new IllegalArgumentException("ROI required");
+		SaveDialog sd = new SaveDialog("Save Coordinates as Text...", imp.getTitle(), ".txt");
+		String name = sd.getFileName();
+		if (name == null)
+			return;
+		String directory = sd.getDirectory();
+		PrintWriter pw = null;
+		try {
+			pw = new PrintWriter(new BufferedOutputStream(new FileOutputStream(directory+name)));
+		}
+		catch (IOException e) {
+			IJ.error("XYWriter", "Unable to save coordinates:\n   "+e.getMessage());
+			return;
+		}
+		
+		Calibration cal = imp.getCalibration();
+		String ls = System.getProperty("line.separator");
+		if (roi.subPixelResolution()) {
+			FloatPolygon p = roi.getFloatPolygon();
+			for (int i=0; i<p.npoints; i++)
+				pw.print(IJ.d2s((p.xpoints[i])*cal.pixelWidth,4) + "\t" + IJ.d2s((p.ypoints[i])*cal.pixelHeight,4) + ls);
+		} else {
+			Polygon p = roi.getPolygon();
+			boolean scaled = cal.scaled();
+			for (int i=0; i<p.npoints; i++) {
+				if (scaled)
+					pw.print(IJ.d2s((p.xpoints[i])*cal.pixelWidth,4) + "\t" + IJ.d2s((p.ypoints[i])*cal.pixelHeight,4) + ls);
+				else
+					pw.print((p.xpoints[i]) + "\t" + (p.ypoints[i]) + ls);
+			}
+		}
+		pw.close();
+	}
+
+}
diff --git a/src/ij/plugin/frame/Channels.java b/src/ij/plugin/frame/Channels.java
new file mode 100644
index 0000000..dfde35c
--- /dev/null
+++ b/src/ij/plugin/frame/Channels.java
@@ -0,0 +1,244 @@
+package ij.plugin.frame;
+import ij.*;
+import ij.plugin.*;
+import ij.gui.*;
+import java.awt.*;
+import java.awt.event.*;
+
+/** Displays the ImageJ Channels window. */
+public class Channels extends PlugInDialog implements PlugIn, ItemListener, ActionListener {
+
+	private static String[] modes = {"Composite", "Color", "Grayscale"};
+	private static String[] menuItems = {"Make Composite", "Convert to RGB", "Split Channels", "Merge Channels...",
+		"Edit LUT...", "-", "Red", "Green", "Blue", "Cyan", "Magenta", "Yellow", "Grays"};
+
+	private static String moreLabel = "More "+'\u00bb';
+	//private String[] title = {"Red", "Green", "Blue"};
+	private Choice choice;
+	private Checkbox[] checkbox;
+	private Button moreButton;
+	private static Channels instance;
+	private int id;
+	private static Point location;
+	private PopupMenu pm;
+
+	public Channels() {
+		super("Channels");
+		if (instance!=null) {
+			instance.toFront();
+			return;
+		}
+		ImageJ ij = IJ.getInstance();
+		WindowManager.addWindow(this);
+		instance = this;
+		GridBagLayout gridbag = new GridBagLayout();
+		GridBagConstraints c = new GridBagConstraints();
+		setLayout(gridbag);
+		int y = 0;
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.fill = GridBagConstraints.BOTH;
+		c.anchor = GridBagConstraints.CENTER;
+		int margin = 32;
+		if (IJ.isMacOSX())
+			margin = 20;
+		c.insets = new Insets(10, margin, 10, margin);
+		choice = new Choice();
+		for (int i=0; i<modes.length; i++)
+			choice.addItem(modes[i]);
+		choice.select(0);
+		choice.addItemListener(this);
+		choice.addKeyListener(ij);
+		add(choice, c);
+
+		CompositeImage ci = getImage();
+		int nCheckBoxes = ci!=null?ci.getNChannels():3;
+		if (nCheckBoxes>CompositeImage.MAX_CHANNELS)
+			nCheckBoxes = CompositeImage.MAX_CHANNELS;
+		checkbox = new Checkbox[nCheckBoxes];
+		for (int i=0; i<nCheckBoxes; i++) {
+			checkbox[i] = new Checkbox("Channel "+(i+1), true);
+			c.insets = new Insets(0, 25, i<nCheckBoxes-1?0:10, 5);
+			c.gridy = y++;
+			add(checkbox[i], c);
+			checkbox[i].addItemListener(this);
+			checkbox[i].addKeyListener(ij);
+		}
+
+		c.insets = new Insets(0, 15, 10, 15);
+		c.fill = GridBagConstraints.NONE;
+		c.gridy = y++;
+		moreButton = new Button(moreLabel);
+		moreButton.addActionListener(this);
+		moreButton.addKeyListener(ij);
+		add(moreButton, c);
+		update();
+
+		pm=new PopupMenu();
+		GUI.scalePopupMenu(pm);
+		for (int i=0; i<menuItems.length; i++)
+			addPopupItem(menuItems[i]);
+		add(pm);
+
+		addKeyListener(ij);  // ImageJ handles keyboard shortcuts
+		setResizable(false);
+		GUI.scale(this);
+		pack();
+		if (location==null) {
+			GUI.centerOnImageJScreen(this);
+			location = getLocation();
+		} else
+			setLocation(location);
+		show();
+	}
+	
+	public void update() {
+		CompositeImage ci = getImage();
+		if (ci==null || checkbox==null)
+			return;
+		int n = checkbox.length;
+		int nChannels = ci.getNChannels();
+		if (nChannels!=n && nChannels<=CompositeImage.MAX_CHANNELS) {
+			instance = null;
+			location = getLocation();
+			close();
+			new Channels();
+			return;
+		}
+		boolean[] active = ci.getActiveChannels();
+		for (int i=0; i<checkbox.length; i++)
+			checkbox[i].setState(active[i]);
+		int index = 0;
+		switch (ci.getMode()) {
+			case IJ.COMPOSITE: index=0; break;
+			case IJ.COLOR: index=1; break;
+			case IJ.GRAYSCALE: index=2; break;
+		}
+		choice.select(index);
+	}
+	
+	public static void updateChannels() {
+		if (instance!=null)
+			instance.update();
+	}
+	
+	void addPopupItem(String s) {
+		MenuItem mi=new MenuItem(s);
+		mi.addActionListener(this);
+		pm.add(mi);
+	}
+
+	CompositeImage getImage() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || !imp.isComposite())
+			return null;
+		else
+			return (CompositeImage)imp;
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return;
+		if (!imp.isComposite()) {
+			int channels = imp.getNChannels();
+			if (channels==1 && imp.getStackSize()<=4)
+				channels = imp.getStackSize();
+			if (imp.getBitDepth()==24 || (channels>1&&channels<CompositeImage.MAX_CHANNELS)) {
+				GenericDialog gd = new GenericDialog(imp.getTitle());
+				gd.addMessage("Convert to multi-channel composite image?");
+				gd.showDialog();
+				if (gd.wasCanceled())
+					return;
+				else
+					IJ.doCommand("Make Composite");					
+			} else {
+				IJ.error("Channels", "A composite image is required (e.g., "+moreLabel+" Open HeLa Cells),\nor create one using "+moreLabel+" Make Composite.");
+				return;
+			}
+		}
+		if (!imp.isComposite()) return;
+		CompositeImage ci = (CompositeImage)imp;
+		Object source = e.getSource();
+		if (source==choice) {
+			int index = ((Choice)source).getSelectedIndex();
+			switch (index) {
+				case 0: ci.setMode(IJ.COMPOSITE); break;
+				case 1: ci.setMode(IJ.COLOR); break;
+				case 2: ci.setMode(IJ.GRAYSCALE); break;
+			}
+			ci.updateAndDraw();
+			if (Recorder.record) {
+				String mode = null;
+				if (Recorder.scriptMode()) {
+					switch (index) {
+						case 0: mode="IJ.COMPOSITE"; break;
+						case 1: mode="IJ.COLOR"; break;
+						case 2: mode="IJ.GRAYSCALE"; break;
+					}
+					Recorder.recordCall("imp.setDisplayMode("+mode+");");
+				} else {
+					switch (index) {
+						case 0: mode="composite"; break;
+						case 1: mode="color"; break;
+						case 2: mode="grayscale"; break;
+					}
+					Recorder.record("Stack.setDisplayMode", mode);
+				}
+			}
+		} else if (source instanceof Checkbox) {
+			for (int i=0; i<checkbox.length; i++) {
+				Checkbox cb = (Checkbox)source;
+				if (cb==checkbox[i]) {
+					if (ci.getMode()==IJ.COMPOSITE) {
+						boolean[] active = ci.getActiveChannels();
+						active[i] = cb.getState();
+						if (Recorder.record) {
+							String str = "";
+							for (int c=0; c<ci.getNChannels(); c++)
+								str += active[c]?"1":"0";
+							if (Recorder.scriptMode())
+								Recorder.recordCall("imp.setActiveChannels(\""+str+"\");");
+							else
+								Recorder.record("Stack.setActiveChannels", str);
+						}
+					} else {
+						imp.setPosition(i+1, imp.getSlice(), imp.getFrame());
+						if (Recorder.record) {
+							if (Recorder.scriptMode())
+								Recorder.recordCall("imp.setC("+(i+1)+");");
+							else
+								Recorder.record("Stack.setChannel", i+1);
+						}
+					}
+					ci.updateAndDraw();
+					return;
+				}
+			}
+		}
+	}
+	
+	public void actionPerformed(ActionEvent e) {
+		String command = e.getActionCommand();
+		if (command==null) return;
+		if (command.equals(moreLabel)) {
+			Point bloc = moreButton.getLocation();
+			pm.show(this, bloc.x, bloc.y);
+		} else if (command.equals("Convert to RGB"))
+			IJ.doCommand("Stack to RGB");
+		else
+			IJ.doCommand(command);
+	}
+	
+	/** Obsolete; always returns null. */
+	public static Frame getInstance() {
+		return null;
+	}
+		
+	public void close() {
+		super.close();
+		instance = null;
+		location = getLocation();
+	}
+	
+}
diff --git a/src/ij/plugin/frame/ColorPicker.java b/src/ij/plugin/frame/ColorPicker.java
new file mode 100644
index 0000000..825ddd7
--- /dev/null
+++ b/src/ij/plugin/frame/ColorPicker.java
@@ -0,0 +1,414 @@
+package ij.plugin.frame;
+import ij.*;
+import ij.plugin.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Vector;
+import javax.swing.BoxLayout;
+import ij.process.*;
+import ij.gui.*;
+
+/** Implements the Image/Color/Color Picker command. */
+public class ColorPicker extends PlugInDialog {
+	public static int ybase = 2;
+	private int colorWidth = 22;
+	private int colorHeight = 16;
+	private int columns = 5;
+	private int rows = 20;
+	private static final String LOC_KEY = "cp.loc";
+	private static ColorPicker instance;
+	private ColorGenerator cg; 
+	private Canvas colorCanvas;
+	TextField colorField;
+	
+    public ColorPicker() {
+		super("CP");
+		if (instance!=null) {
+			instance.toFront();
+			return;
+		}
+		double scale = Prefs.getGuiScale();
+		instance = this;
+		WindowManager.addWindow(this);
+        int width = (int)(columns*colorWidth*scale);
+        int height = (int)((rows*colorHeight+ybase)*scale);
+        addKeyListener(IJ.getInstance());
+		setLayout(new BorderLayout());
+		cg = new ColorGenerator(width, height, new int[width*height]);
+        cg.drawColors(colorWidth, colorHeight, columns, rows);
+        colorCanvas = new ColorCanvas(width, height, this, cg, scale);
+        Panel panel = new Panel();
+		panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
+        panel.add(colorCanvas);
+		String hexColor = Colors.colorToString(Toolbar.getForegroundColor());
+        colorField = new TextField(hexColor+" ",7);
+        colorField.setEditable(false);
+        colorField.select(hexColor.length(),hexColor.length());
+        GUI.scale(colorField);
+        panel.add(colorField);
+        add(panel);
+		setResizable(false);
+		pack();
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null)
+			setLocation(loc);
+		else
+			GUI.centerOnImageJScreen(this);
+		show();
+	}
+    
+    public void close() {
+	 	super.close();
+		instance = null;
+		Prefs.saveLocation(LOC_KEY, getLocation());
+		IJ.notifyEventListeners(IJEventListener.COLOR_PICKER_CLOSED);
+	}
+	
+	public static void update() {
+		ColorPicker cp = instance;
+		if (cp!=null && cp.colorCanvas!=null) {
+			cp.cg.refreshBackground(false);
+			cp.cg.refreshForeground(false);
+			cp.colorCanvas.repaint();
+			cp.colorField.setText(Colors.colorToString(Toolbar.getForegroundColor()));
+		}
+	}
+	
+}
+
+class ColorGenerator extends ColorProcessor {
+	private int ybase = ColorPicker.ybase;
+    private int w, h;
+    private int[] colors = {0xff0000, 0x00ff00, 0x0000ff, 0xffffff, 0x00ffff, 0xff00ff, 0xffff00, 0x000000};
+
+    public ColorGenerator(int width, int height, int[] pixels) {
+        super(width, height, pixels);
+        setAntialiasedText(true);
+    }
+    
+    void drawColors(int colorWidth, int colorHeight, int columns, int rows) {
+        w = colorWidth;
+        h = colorHeight;
+        setColor(0xffffff);
+        setRoi(0, ybase, 110, 320);
+        fill();
+        drawRamp();
+        resetBW();
+        flipper();
+        //drawLine(0, 256, 110, 256);
+        
+        refreshBackground(false);
+        refreshForeground(false);
+
+        Color c;
+        float hue, saturation=1f, brightness=1f;
+        double w=colorWidth, h=colorHeight;
+        for (int x=2; x<10; x++) {
+            for (int y=0; y<32; y++) {
+                hue = (float)(y/(2*h)-.15);
+                if (x<6) { 
+                    saturation = 1f;
+                    brightness = (float)(x*4/w);
+                } else {
+                    saturation = 1f - ((float)((5-x)*-4/w));
+                    brightness = 1f;
+                }
+                c = Color.getHSBColor(hue, saturation, brightness);
+                setRoi(x*(int)(w/2), ybase+y*(int)(h/2), (int)w/2, (int)h/2);
+                setColor(c);
+                fill();
+            }
+        }
+        drawSpectrum(h);        
+        resetRoi();
+    }
+       
+    void drawColor(int x, int y, Color c) {
+        setRoi(x*w, y*h, w, h);
+        setColor(c);
+        fill();
+    }
+
+    public void refreshBackground(boolean backgroundInFront) {
+        //Boundary for Background Selection
+        setColor(0x444444);
+        drawRect((w*2)-12, ybase+276, (w*2)+4, (h*2)+4);
+        setColor(0x999999);
+        drawRect((w*2)-11, ybase+277, (w*2)+2, (h*2)+2);
+        setRoi((w*2)-10, ybase+278, w*2, h*2);//Paints the Background Color
+        Color bg = Toolbar.getBackgroundColor();
+        setColor(bg);
+        fill();
+        if (backgroundInFront)
+        	drawLabel("B", bg, w*4-18, ybase+278+h*2);
+    }
+
+    public void refreshForeground(boolean backgroundInFront) {
+        //Boundary for Foreground Selection
+        setColor(0x444444);
+        drawRect(8, ybase+266, (w*2)+4, (h*2)+4);
+        setColor(0x999999);
+        drawRect(9, ybase+267, (w*2)+2, (h*2)+2);
+        setRoi(10, ybase+268, w*2, h*2); //Paints the Foreground Color
+        Color fg = Toolbar.getForegroundColor();
+        setColor(fg);
+        fill();
+        if (backgroundInFront)
+        	drawLabel("F", fg, 12, ybase+268+14);
+    }
+    
+    private void drawLabel(String label, Color c, int x, int y) {
+		int intensity = (c.getRed()+c.getGreen()+c.getBlue())/3;
+		c = intensity<128?Color.white:Color.black;
+		setColor(c);
+		drawString(label, x, y);
+	}
+
+	void drawSpectrum(double h) {
+		Color c;
+		for ( int x=5; x<7; x++) {
+			for ( int y=0; y<32; y++) {
+				float hue = (float)(y/(2*h)-.15);        
+				c = Color.getHSBColor(hue, 1f, 1f);
+				setRoi(x*(int)(w/2), ybase+y*(int)(h/2), (int)w/2, (int)h/2);
+				setColor(c);
+				fill();
+			}
+		}
+		setRoi(55, ybase+32, 22, 16); //Solid red
+		setColor(0xff0000);
+		fill();
+		setRoi(55, ybase+120, 22, 16); //Solid green
+		setColor(0x00ff00);
+		fill();
+		setRoi(55, ybase+208, 22, 16); //Solid blue
+		setColor(0x0000ff);
+		fill();
+		setRoi(55, ybase+80, 22, 8); //Solid yellow
+		setColor(0xffff00);
+		fill();
+		setRoi(55, ybase+168, 22, 8); //Solid cyan
+		setColor(0x00ffff);
+		fill();
+		setRoi(55, ybase+248, 22, 8); //Solid magenta
+		setColor(0xff00ff);
+		fill();
+	}
+
+    void drawRamp() {
+        int r,g,b;
+        for (int x=0; x<w; x++) {
+             for (int y=0; y<(h*16); y++) {
+                r = g = b = (byte)y;
+                set(x, ybase+y, 0xff000000 | ((r<<16)&0xff0000) | ((g<<8)&0xff00) | (b&0xff));
+            }
+        }
+    }
+
+    void resetBW() {   //Paints the Color Reset Button
+        setColor(0x000000);
+        setRoi(92, ybase+300, 9, 7);
+        fill();
+        drawRect(88, ybase+297, 9, 7);
+        setColor(0xffffff);
+        setRoi(89, ybase+298, 7, 5);
+        fill();
+    }
+
+    void flipper() {   //Paints the Flipper Button
+        int xa = 90; 
+        int ya = ybase+272; 
+        setColor(0x000000);
+        drawLine(xa, ya, xa+9, ya+9);//Main Body
+        drawLine(xa+1, ya, xa+9, ya+8);
+        drawLine(xa, ya+1, xa+8, ya+9);
+        drawLine(xa, ya, xa, ya+5);//Upper Arrow
+        drawLine(xa+1, ya+1, xa+1, ya+6);
+        drawLine(xa, ya, xa+5, ya);
+        drawLine(xa+1, ya+1, xa+6, ya+1);
+        drawLine(xa+9, ya+9, xa+9, ya+4);//Lower Arrow
+        drawLine(xa+8, ya+8, xa+8, ya+3);
+        drawLine(xa+9, ya+9, xa+4, ya+9);
+        drawLine(xa+8, ya+8, xa+3, ya+8);
+    }
+    
+} 
+
+class ColorCanvas extends Canvas implements MouseListener, MouseMotionListener {
+	private static Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
+	private static Cursor crosshairCursor = new Cursor(Cursor.CROSSHAIR_CURSOR);
+	int ybase = ColorPicker.ybase;
+	Rectangle flipperRect = new Rectangle(86, ybase+268, 18, 18);
+	Rectangle resetRect = new Rectangle(84, ybase+293, 21, 18);
+	Rectangle foreground1Rect = new Rectangle(9, ybase+266, 45, 10);
+	Rectangle foreground2Rect = new Rectangle(9, ybase+276, 23, 25);
+	Rectangle background1Rect = new Rectangle(33, ybase+302, 45, 10);
+	Rectangle background2Rect = new Rectangle(56, ybase+277, 23, 25);
+	int width, height;
+	Vector colors;
+	boolean background;
+	long mouseDownTime;
+	ColorGenerator ip;
+	ColorPicker cp;
+	double scale;
+	String status = "";
+			
+	public ColorCanvas(int width, int height, ColorPicker cp, ColorGenerator ip, double scale) {
+		this.width=width; this.height=height;
+		this.ip = ip;
+		this.cp = cp;
+		addMouseListener(this);
+ 		addMouseMotionListener(this);
+        addKeyListener(IJ.getInstance());
+		setSize(width, height);
+		this.scale = scale;
+	}
+	
+	public Dimension getPreferredSize() {
+		return new Dimension(width, height);
+	}
+	
+	public void update(Graphics g) {
+		paint(g);
+	}
+	
+	public void paint(Graphics g) {
+		g.drawImage(ip.createImage(), 0, 0, (int)(ip.getWidth()*scale), (int)(ip.getHeight()*scale), null);
+	}
+
+	public void mousePressed(MouseEvent e) {
+		//IJ.log("mousePressed "+e);
+		ip.setLineWidth(1);
+		if (Toolbar.getToolId()==Toolbar.DROPPER)
+			IJ.setTool(Toolbar.RECTANGLE );
+		int x = (int)(e.getX()/scale);
+		int y = (int)(e.getY()/scale);
+		long difference = System.currentTimeMillis()-mouseDownTime;
+		boolean doubleClick = (difference<=250);
+		mouseDownTime = System.currentTimeMillis();
+		if (flipperRect.contains(x, y)) {
+			Color c = Toolbar.getBackgroundColor();
+			Toolbar.setBackgroundColor(Toolbar.getForegroundColor());
+			Toolbar.setForegroundColor(c);
+			Recorder.setForegroundColor(Toolbar.getForegroundColor());
+			Recorder.setBackgroundColor(Toolbar.getBackgroundColor());
+		} else if (resetRect.contains(x,y)) {
+			Toolbar.setForegroundColor(Color.white);
+			Toolbar.setBackgroundColor(Color.black);
+			Recorder.setForegroundColor(Color.white);
+			Recorder.setBackgroundColor(Color.black);
+		} else if ((background1Rect.contains(x,y)) || (background2Rect.contains(x,y))) {
+			background = true;
+			if (doubleClick) editColor();
+			ip.refreshForeground(background);
+			ip.refreshBackground(background);
+		} else if ((foreground1Rect.contains(x,y)) || (foreground2Rect.contains(x,y))) {
+			background = false;
+			if (doubleClick) editColor();
+			ip.refreshBackground(background);
+			ip.refreshForeground(background);
+		} else {
+			if (doubleClick)
+				editColor();
+			else {
+				setDrawingColor(x, y, background);
+			showStatus(" ", Toolbar.getForegroundColor().getRGB());
+			} 
+		}
+		Color color;
+		if (background) {
+			ip.refreshForeground(background);
+			ip.refreshBackground(background);
+			color= Toolbar.getBackgroundColor();
+		} else {
+			ip.refreshBackground(background);
+			ip.refreshForeground(background);
+			color= Toolbar.getForegroundColor();
+		}
+		cp.colorField.setText(Colors.colorToString(color));
+		showStatus(" ", color.getRGB());
+		repaint();
+	}
+
+	public void mouseMoved(MouseEvent e) {
+		int x = (int)(e.getX()/scale);
+		int y = (int)(e.getY()/scale);
+		if (flipperRect.contains(x, y))
+			showStatus("Click to flip foreground and background colors", 0);
+		else if (resetRect.contains(x,y))
+			showStatus("Click to reset foreground to white, background to black", 0);
+		else if (!background && (background1Rect.contains(x,y) || background2Rect.contains(x,y)))
+			showStatus("Click to switch to background selection mode ", 0);
+		else if (background && (foreground1Rect.contains(x,y) || foreground2Rect.contains(x,y)))
+			showStatus("Click to switch to foreground selection mode", 0);
+		else
+			showStatus("", ip.getPixel(x, y));
+	}
+
+	String pad(int n) {
+		String str = ""+n;
+		while (str.length()<3)
+		str = "0" + str;
+		return str;
+	}	
+
+	void setDrawingColor(int x, int y, boolean setBackground) {
+		int p = ip.getPixel(x, y);
+		int r = (p&0xff0000)>>16;
+		int g = (p&0xff00)>>8;
+		int b = p&0xff;
+		Color c = new Color(r, g, b);
+		if (setBackground) {
+			Toolbar.setBackgroundColor(c);
+			if (Recorder.record)
+				Recorder.setBackgroundColor(c);
+		} else {
+			Toolbar.setForegroundColor(c);
+			if (Recorder.record)
+				Recorder.setForegroundColor(c);
+		}
+	}
+
+	void editColor() {
+		Color c  = background?Toolbar.getBackgroundColor():Toolbar.getForegroundColor();
+		ColorChooser cc = new ColorChooser((background?"Background":"Foreground")+" Color", c, false);
+		c = cc.getColor();
+		if (background)
+			Toolbar.setBackgroundColor(c);
+		else
+			Toolbar.setForegroundColor(c);
+	}
+	
+	public void refreshColors() {
+		ip.refreshBackground(false);
+		ip.refreshForeground(false);
+		repaint();
+	}
+	
+	private void showStatus(String msg, int rgb) {
+		if (msg.length()>1)
+			IJ.showStatus(msg);
+		else {
+			int r = (rgb&0xff0000)>>16;
+			int g = (rgb&0xff00)>>8;
+			int b = rgb&0xff;
+			String hex = Colors.colorToString(new Color(r,g,b));
+			IJ.showStatus("red="+pad(r)+", green="+pad(g)+", blue="+pad(b)+" ("+hex+") "+msg);
+		}
+	}
+	
+	public void mouseExited(MouseEvent e) {
+		IJ.showStatus("");
+		setCursor(defaultCursor);
+	}
+
+	public void mouseEntered(MouseEvent e) {
+		setCursor(crosshairCursor);
+	}
+
+	public void mouseReleased(MouseEvent e) {}
+	public void mouseClicked(MouseEvent e) {}
+	public void mouseDragged(MouseEvent e) {}
+	
+}
+
diff --git a/src/ij/plugin/frame/ColorThresholder.java b/src/ij/plugin/frame/ColorThresholder.java
new file mode 100644
index 0000000..376f6df
--- /dev/null
+++ b/src/ij/plugin/frame/ColorThresholder.java
@@ -0,0 +1,1568 @@
+package ij.plugin.frame;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.util.*;
+import java.awt.event.*;
+import ij.measure.*;
+import ij.plugin.*;
+import ij.plugin.filter.ThresholdToSelection;
+
+
+/*	This plugin isolates pixels in an RGB image or stack according to a range of Hue.
+	Original PassBand2 by Bob Dougherty. Some code borrowed from ThresholdAdjuster by Wayne Rasband.
+
+	Version 0 5/12/2002.
+	Version 1 5/13			Filtered pixels set to foreground color.  Speed improved.
+	Version 2 5/13.			Fixed a bug in setting the restore pixels that was causing problems with stacks.
+							Explicitly get the foreground color from the toolbar in apply.
+
+	Modifications by G. Landini.
+		17/Feb/2004.	The changes are seen as the sliders/checkboxes are adjusted.
+				Added hue strip to histogram window, changed histogram scale factor
+		19/Feb/2004.	Added Saturation and Brightness histograms,
+				Added Pass/Stop checkboxes for each HSB channel.
+				Added threshold, added inversion of threshold
+				Cleaned some variables. Changed name to Threshold_HSB
+		22/Feb/2004	Threshold in RGB or HSB space
+				Changed name to Threshold_Colour, changed button names.
+				Added thresholding by "sampling". Hue band sampled selection may not'
+				always work if there are 0 valued histograms. Thread now finishes properly
+		23/Feb/2004	Java 1.4 on Mac OS X bug (thanks Wayne)
+		25/Feb/2004	Any type of ROI supported for [Sample]
+		26/Feb/2004	Modified ROI handling (thanks Wayne)
+		28/Feb/2004	Improved Hue sampling, changed histogram background colour
+		29/Feb/2004	Added CIE Lab colour space
+		6/Mar/2004	v1.4 Requires ImageJ 1.32c (thanks Wayne)
+		8/Mar/2004	v1.5 ColourProcessor bug (thanks Wayne), filter checkboxes detect a new image
+		23/Jun/2004	v1.6 Added YUV colour space
+		1/May/2006	v1.7 Minor changes to Lab coding, added macro recorder button
+		5/Jan/2007	v1.8 added warning and commented lines for back/foreground colours
+		2/Feb/2008	v1.9 closing does not apply the filter if Original was being displayed. Thanks for the hint Bob!
+ */
+
+/**  Selects pixels according to hsb or rgb components.  */
+public class ColorThresholder extends PlugInFrame implements PlugIn, Measurements,
+ ActionListener, AdjustmentListener, FocusListener, ItemListener, Runnable{
+
+	private static final int HSB=0, RGB=1, LAB=2, YUV=3;
+	private static final String[] colorSpaces = {"HSB", "RGB", "Lab", "YUV"};
+	private boolean flag = false;
+	private int colorSpace = HSB;
+	private Thread thread;
+	private static Frame instance;
+
+	private BandPlot plot = new BandPlot();
+	private BandPlot splot = new BandPlot();
+	private BandPlot bplot = new BandPlot();
+	private int sliderRange = 256;
+	private Panel panel, panelt;
+	private Button  originalB, filteredB, stackB, helpB, sampleB, resetallB, newB, macroB, selectB;
+	private Checkbox bandPassH, bandPassS, bandPassB, darkBackground;
+	private CheckboxGroup colourMode;
+	private Choice colorSpaceChoice, methodChoice, modeChoice;
+	private int previousImageID = -1;
+	private int previousSlice = -1;
+	private ImageJ ij;
+	private int minHue = 0, minSat = 0, minBri = 0;
+	private int maxHue = 255, maxSat = 255, maxBri = 255;
+	private Scrollbar minSlider, maxSlider, minSlider2, maxSlider2, minSlider3, maxSlider3;
+	private Label label1, label2, label3, label4, label5, label6, labelh, labels, labelb, labelf;
+	private boolean done;
+	private byte[] hSource, sSource, bSource;
+	private boolean applyingStack;
+
+	private static final int DEFAULT = 0;
+	private static String[] methodNames = AutoThresholder.getMethods();
+	private static String method = methodNames[DEFAULT];
+	private static AutoThresholder thresholder = new AutoThresholder();
+	private static final int RED=0, WHITE=1, BLACK=2, BLACK_AND_WHITE=3;
+	private static final String[] modes = {"Red", "White", "Black", "B&W"};
+	private static int mode = RED;	
+
+	private int numSlices;
+	private ImageStack stack;
+	private int width, height, numPixels;
+
+	public ColorThresholder() {
+		super("Threshold Color");
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		thread = new Thread(this, "BandAdjuster");
+		WindowManager.addWindow(this);
+		instance = this;
+
+		ij = IJ.getInstance();
+		Font font = IJ.font10;
+		GridBagLayout gridbag = new GridBagLayout();
+		GridBagConstraints c = new GridBagConstraints();
+		setLayout(gridbag);
+
+		int y = 0;
+		c.gridx = 0;
+		c.gridy = y;
+		c.gridwidth = 1;
+		c.weightx = 0;
+		c.insets = new Insets(5, 0, 0, 0);
+		labelh = new Label("Hue", Label.CENTER);
+		add(labelh, c);
+
+		c.gridx = 1;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = 0;
+		c.insets = new Insets(7, 0, 0, 0);
+		labelf = new Label("", Label.RIGHT);
+		add(labelf, c);
+
+		// plot
+		c.gridx = 0;
+		c.gridy = y;
+		c.gridwidth = 1;
+		c.fill = c.BOTH;
+		c.anchor = c.CENTER;
+		c.insets = new Insets(0, 5, 0, 0);
+		add(plot, c);
+
+		// checkboxes
+		bandPassH = new Checkbox("Pass");
+		bandPassH.addItemListener(this);
+		bandPassH.setState(true);
+		c.gridx = 1;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(5, 5, 0, 5);
+		add(bandPassH, c);
+
+		// minHue slider
+		minSlider = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, sliderRange);
+		GUI.fixScrollbar(minSlider);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?90:100;
+		c.fill = c.HORIZONTAL;
+		c.insets = new Insets(5, 5, 0, 0);
+
+		add(minSlider, c);
+		minSlider.addAdjustmentListener(this);
+		minSlider.setUnitIncrement(1);
+
+		// minHue slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?10:0;
+		c.insets = new Insets(5, 0, 0, 0);
+		label1 = new Label("       ", Label.LEFT);
+		label1.setFont(font);
+		add(label1, c);
+
+		// maxHue sliderHue
+		maxSlider = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, sliderRange);
+		GUI.fixScrollbar(maxSlider);
+		c.gridx = 0;
+		c.gridy = y;
+		c.gridwidth = 1;
+		c.weightx = 100;
+		c.insets = new Insets(5, 5, 0, 0);
+		add(maxSlider, c);
+		maxSlider.addAdjustmentListener(this);
+		maxSlider.setUnitIncrement(1);
+
+		// maxHue slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.gridy = y++;
+		c.weightx = 0;
+		c.insets = new Insets(5, 0, 0, 0);
+		label2 = new Label("       ", Label.LEFT);
+		label2.setFont(font);
+		add(label2, c);
+
+		//=====
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = 0;
+		c.insets = new Insets(10, 0, 0, 0);
+		labels = new Label("Saturation", Label.CENTER);
+		add(labels, c);
+
+		// plot
+		c.gridx = 0;
+		c.gridy = y;
+		c.gridwidth = 1;
+		c.fill = c.BOTH;
+		c.anchor = c.CENTER;
+		c.insets = new Insets(0, 5, 0, 0);
+		add(splot, c);
+
+		// checkboxes
+		bandPassS = new Checkbox("Pass");
+		bandPassS.addItemListener(this);
+		bandPassS.setState(true);
+		c.gridx = 1;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(5, 5, 0, 5);
+		add(bandPassS, c);
+
+		// minSat slider
+		minSlider2 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, sliderRange);
+		GUI.fixScrollbar(minSlider2);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?90:100;
+		c.fill = c.HORIZONTAL;
+		c.insets = new Insets(5, 5, 0, 0);
+		add(minSlider2, c);
+		minSlider2.addAdjustmentListener(this);
+		minSlider2.setUnitIncrement(1);
+
+		// minSat slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?10:0;
+		c.insets = new Insets(5, 0, 0, 0);
+		label3 = new Label("       ", Label.LEFT);
+		label3.setFont(font);
+		add(label3, c);
+
+		// maxSat slider
+		maxSlider2 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, sliderRange);
+		GUI.fixScrollbar(maxSlider2);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = 100;
+		c.insets = new Insets(5, 5, 0, 0);
+		add(maxSlider2, c);
+		maxSlider2.addAdjustmentListener(this);
+		maxSlider2.setUnitIncrement(1);
+
+		// maxSat slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.weightx = 0;
+		c.insets = new Insets(5, 0, 0, 0);
+		label4 = new Label("       ", Label.LEFT);
+		label4.setFont(font);
+		add(label4, c);
+
+		//=====
+		c.gridx = 0;
+		c.gridwidth = 1;
+		c.gridy = y++;
+		c.weightx = 0;
+		c.insets = new Insets(10, 0, 0, 0);
+		labelb = new Label("Brightness", Label.CENTER);
+		add(labelb, c);
+
+		c.gridx = 0;
+		c.gridwidth = 1;
+		c.gridy = y;
+		c.fill = c.BOTH;
+		c.anchor = c.CENTER;
+		c.insets = new Insets(0, 5, 0, 0);
+		add(bplot, c);
+
+		// checkboxes
+		bandPassB = new Checkbox("Pass");
+		bandPassB.addItemListener(this);
+		bandPassB.setState(true);
+		c.gridx = 1;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(5, 5, 0, 5);
+		add(bandPassB, c);
+
+		// minBri slider
+		minSlider3 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, sliderRange);
+		GUI.fixScrollbar(minSlider3);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?90:100;
+		c.fill = c.HORIZONTAL;
+		c.insets = new Insets(5, 5, 0, 0);
+		add(minSlider3, c);
+		minSlider3.addAdjustmentListener(this);
+		minSlider3.setUnitIncrement(1);
+
+		// minBri slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?10:0;
+		c.insets = new Insets(5, 0, 0, 0);
+		label5 = new Label("       ", Label.LEFT);
+		label5.setFont(font);
+		add(label5, c);
+
+		// maxBri slider
+		maxSlider3 = new Scrollbar(Scrollbar.HORIZONTAL, 0, 1, 0, sliderRange);
+		GUI.fixScrollbar(maxSlider3);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = 100;
+		c.insets = new Insets(5, 5, 0, 0);
+		add(maxSlider3, c);
+		maxSlider3.addAdjustmentListener(this);
+		maxSlider3.setUnitIncrement(1);
+
+		// maxBri slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.weightx = 0;
+		c.insets = new Insets(5, 0, 0, 0);
+		label6 = new Label("       ", Label.LEFT);
+		label6.setFont(font);
+		add(label6, c);
+
+		GridBagLayout gridbag2 = new GridBagLayout();
+		GridBagConstraints c2 = new GridBagConstraints();
+		int y2 = 0;
+		Panel panel = new Panel();
+		panel.setLayout(gridbag2);
+		
+		// threshoding method choice
+		c2.gridx = 0; c2.gridy = y2;
+		c2.anchor = GridBagConstraints.EAST;
+		c2.gridwidth = 1;
+		c2.insets = new Insets(5, 0, 0, 0);
+		Label theLabel = new Label("Thresholding method:");
+		gridbag2.setConstraints(theLabel, c2);
+		panel.add(theLabel);
+		methodChoice = new Choice();
+		for (int i=0; i<methodNames.length; i++)
+			methodChoice.addItem(methodNames[i]);
+		methodChoice.select(method);
+		methodChoice.addItemListener(this);
+		c2.gridx = 1; c2.gridy = y2;
+		c2.anchor = GridBagConstraints.WEST;
+		gridbag2.setConstraints(methodChoice, c2);
+		panel.add(methodChoice);
+		y2++;
+		
+		// display mode choice
+		c2.gridx = 0; c2.gridy = y2;
+		c2.anchor = GridBagConstraints.EAST;
+		c2.insets = new Insets(0, 0, 0, 0);
+		theLabel = new Label("Threshold color:");
+		gridbag2.setConstraints(theLabel, c2);
+		panel.add(theLabel);
+		modeChoice = new Choice();
+		for (int i=0; i<modes.length; i++)
+			modeChoice.addItem(modes[i]);
+		modeChoice.select(mode);
+		modeChoice.addItemListener(this);
+		c2.gridx = 1; c2.gridy = y2;
+		c2.anchor = GridBagConstraints.WEST;
+		gridbag2.setConstraints(modeChoice, c2);
+		panel.add(modeChoice);
+		y2++;
+
+		// color space choice
+		c2.gridx = 0; c2.gridy = y2;
+		c2.anchor = GridBagConstraints.EAST;
+		theLabel = new Label("Color space:");
+		gridbag2.setConstraints(theLabel, c2);
+		panel.add(theLabel);
+		colorSpaceChoice = new Choice();
+		for (int i=0; i<colorSpaces.length; i++)
+			colorSpaceChoice.addItem(colorSpaces[i]);
+		colorSpaceChoice.select(HSB);
+		colorSpaceChoice.addItemListener(this);
+		c2.gridx = 1; c2.gridy = y2;
+		c2.anchor = GridBagConstraints.WEST;
+		gridbag2.setConstraints(colorSpaceChoice, c2);
+		panel.add(colorSpaceChoice);
+		y2++;
+
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(5, 0, 0, 0);
+		c.anchor = GridBagConstraints.CENTER;
+		c.fill = GridBagConstraints.NONE;
+		add(panel, c);
+
+		//=====
+		panelt = new Panel();
+		boolean db = Prefs.get("cthresholder.dark", true);
+		darkBackground = new Checkbox("Dark background", db);
+		darkBackground.addItemListener(this);
+		panelt.add(darkBackground);
+
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(0, 0, 0, 0);
+		add(panelt, c);
+
+		// buttons
+		int trim = IJ.isMacOSX()?10:0;
+		panel = new Panel();
+		panel.setLayout(new GridLayout(0, 4, 0, 0));
+		originalB = new TrimmedButton("Original", trim);
+		//originalB.setEnabled(false);
+		originalB.addActionListener(this);
+		originalB.addKeyListener(ij);
+		panel.add(originalB);
+
+		filteredB = new TrimmedButton("Filtered", trim);
+		filteredB.setEnabled(false);
+		filteredB.addActionListener(this);
+		filteredB.addKeyListener(ij);
+		panel.add(filteredB);
+
+		selectB = new TrimmedButton("Select", trim);
+		selectB.addActionListener(this);
+		selectB.addKeyListener(ij);
+		panel.add(selectB);
+
+		sampleB = new TrimmedButton("Sample", trim);
+		sampleB.addActionListener(this);
+		sampleB.addKeyListener(ij);
+		panel.add(sampleB);
+		
+		stackB = new TrimmedButton("Stack", trim);
+		stackB.addActionListener(this);
+		stackB.addKeyListener(ij);
+		panel.add(stackB);
+
+		macroB = new TrimmedButton("Macro", trim);
+		macroB.addActionListener(this);
+		macroB.addKeyListener(ij);
+		panel.add(macroB);
+
+		helpB = new TrimmedButton("Help", trim);
+		helpB.addActionListener(this);
+		helpB.addKeyListener(ij);
+		panel.add(helpB);
+		
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(5, 5, 10, 5);
+		gridbag.setConstraints(panel, c);
+		add(panel);
+
+		addKeyListener(ij);  // ImageJ handles keyboard shortcuts
+		GUI.scale(this);
+		pack();
+		GUI.centerOnImageJScreen(this);
+		setVisible(true);
+
+		thread.start();
+		if (!checkImage()) return;
+		synchronized(this) {
+			notify();
+		}
+	}
+
+	public void run() {
+		while (!done) {
+			synchronized(this) {
+				try {wait();}
+				catch(InterruptedException e) {}
+				if (!done) {//RPD
+					ImagePlus imp = WindowManager.getCurrentImage();
+					if (imp!=null) {
+						reset(imp);
+						apply(imp);
+						imp.updateAndDraw();
+					}
+				}
+			}
+		}
+	}
+
+	public synchronized void adjustmentValueChanged(AdjustmentEvent e) {
+    	if (IJ.debugMode) IJ.log("ColorThresholder.adjustmentValueChanged ");
+		if (!checkImage()) return;
+		if (e.getSource() == minSlider)
+			adjustMinHue((int) minSlider.getValue());
+		else if (e.getSource() == maxSlider)
+			adjustMaxHue((int) maxSlider.getValue());
+		else if (e.getSource() == minSlider2)
+			adjustMinSat((int) minSlider2.getValue());
+		else if (e.getSource() == maxSlider2)
+			adjustMaxSat((int) maxSlider2.getValue());
+		else if (e.getSource() == minSlider3)
+			adjustMinBri((int) minSlider3.getValue());
+		else if (e.getSource() == maxSlider3)
+			adjustMaxBri((int) maxSlider3.getValue());
+		//originalB.setEnabled(true);
+		updateLabels();
+		updatePlot();
+		notify();
+	}
+
+	public synchronized void itemStateChanged(ItemEvent e) {
+		if (IJ.debugMode) IJ.log("ColorThresolder.itemStateChanged");
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return;
+		Object source = e.getSource();
+		if (source==methodChoice) {
+			method = methodChoice.getSelectedItem();
+		} else if (source==modeChoice) {
+			mode = modeChoice.getSelectedIndex();
+		} else if (source==colorSpaceChoice) {
+			colorSpace = ((Choice)source).getSelectedIndex();
+			flag = true;
+			//originalB.setEnabled(false);
+			filteredB.setEnabled(false);
+			minHue=minSat=minBri=0;
+			maxHue=maxSat=maxBri=255;
+			bandPassH.setState(true);
+			bandPassS.setState(true);
+			bandPassB.setState(true);
+		} else if (source==darkBackground) {
+		}
+		reset(imp);
+		if (source==methodChoice || source==colorSpaceChoice || source==darkBackground)
+			autoSetThreshold();
+		checkImage(); //new
+		updateNames();
+		notify();
+	}
+
+
+	public void focusGained(FocusEvent e){
+		if (IJ.debugMode) IJ.log("ColorThresolder.focusGained");
+		checkImage();
+	}
+
+	public void focusLost(FocusEvent e){}
+
+	public void actionPerformed(ActionEvent e) {
+		if (IJ.debugMode) IJ.log("ColorThresholder.actionPerformed");
+		Button b = (Button)e.getSource();
+		if (b==null) return;
+		boolean imageThere = b==sampleB || checkImage();
+		if (imageThere) {
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp==null) return;
+			if (b==originalB) {
+				reset(imp);
+				imp.setProperty("OriginalImage", null);
+				filteredB.setEnabled(true);
+			} else if (b==filteredB) {
+				reset(imp);
+				apply(imp);
+			} else if (b==sampleB) {
+				sample();
+				apply(imp);
+			} else if (b==selectB) {
+				createSelection();
+			} else if (b==stackB) {
+				applyStack();
+			} else if (b==macroB) {
+				generateMacro();
+				return;
+			} else if (b==helpB) {
+				showHelp();
+				return;
+			}
+			updatePlot();
+			updateLabels();
+			imp.updateAndDraw();
+		} else {
+			IJ.beep();
+			IJ.showStatus("No Image");
+		}
+		//notify();
+	}
+	
+	//Select button pressed
+	void createSelection() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return;
+		int saveMode = mode;
+		mode = BLACK_AND_WHITE;
+		apply(imp);
+		mode = saveMode;
+		ImageProcessor ip = imp.getProcessor().convertToByte(false);
+		int fg = Prefs.blackBackground?255:0;
+		ip.setThreshold(fg, fg, ImageProcessor.NO_LUT_UPDATE);
+		Roi roi = (new ThresholdToSelection()).convert(ip);
+		reset(imp);
+		imp.setRoi(roi);
+	}
+	
+	void generateMacro() {
+		if (!Recorder.record) {
+			IJ.error("Threshold Color", "Command recorder is not running");
+			return;
+		}
+		Recorder.recordString("// Color Thresholder "+IJ.getVersion()+"\n");
+		Recorder.recordString("// Autogenerated macro, single images only!\n");
+		Recorder.recordString("min=newArray(3);\n");
+		Recorder.recordString("max=newArray(3);\n");
+		Recorder.recordString("filter=newArray(3);\n");
+		Recorder.recordString("a=getTitle();\n");
+		if (colorSpace==HSB) {
+			Recorder.recordString("run(\"HSB Stack\");\n");
+			Recorder.recordString("run(\"Convert Stack to Images\");\n");
+			Recorder.recordString("selectWindow(\"Hue\");\n");
+			Recorder.recordString("rename(\"0\");\n");
+			Recorder.recordString("selectWindow(\"Saturation\");\n");
+			Recorder.recordString("rename(\"1\");\n");
+			Recorder.recordString("selectWindow(\"Brightness\");\n");
+			Recorder.recordString("rename(\"2\");\n");
+		} else {
+			if (colorSpace==LAB)
+				Recorder.recordString("call(\"ij.plugin.frame.ColorThresholder.RGBtoLab\");\n");
+			if (colorSpace==YUV)
+				Recorder.recordString("call(\"ij.plugin.frame.ColorThresholder.RGBtoYUV\");\n");
+			Recorder.recordString("run(\"RGB Stack\");\n");
+			Recorder.recordString("run(\"Convert Stack to Images\");\n");
+			Recorder.recordString("selectWindow(\"Red\");\n");
+			Recorder.recordString("rename(\"0\");\n");
+			Recorder.recordString("selectWindow(\"Green\");\n");
+			Recorder.recordString("rename(\"1\");\n");
+			Recorder.recordString("selectWindow(\"Blue\");\n");
+			Recorder.recordString("rename(\"2\");\n");
+		}
+		Recorder.recordString("min[0]="+minSlider.getValue()+";\n");
+		Recorder.recordString("max[0]="+maxSlider.getValue()+";\n");
+
+		if (bandPassH.getState())
+			Recorder.recordString("filter[0]=\"pass\";\n");
+		else
+			Recorder.recordString("filter[0]=\"stop\";\n");
+
+		Recorder.recordString("min[1]="+minSlider2.getValue()+";\n");
+		Recorder.recordString("max[1]="+maxSlider2.getValue()+";\n");
+
+		if (bandPassS.getState())
+			Recorder.recordString("filter[1]=\"pass\";\n");
+		else
+			Recorder.recordString("filter[1]=\"stop\";\n");
+		Recorder.recordString("min[2]="+minSlider3.getValue()+";\n");
+		Recorder.recordString("max[2]="+maxSlider3.getValue()+";\n");
+
+		if (bandPassB.getState())
+			Recorder.recordString("filter[2]=\"pass\";\n");
+		else
+			Recorder.recordString("filter[2]=\"stop\";\n");
+
+		Recorder.recordString("for (i=0;i<3;i++){\n");
+		Recorder.recordString("  selectWindow(\"\"+i);\n");
+		Recorder.recordString("  setThreshold(min[i], max[i]);\n");
+		Recorder.recordString("  run(\"Convert to Mask\");\n");
+		Recorder.recordString("  if (filter[i]==\"stop\")  run(\"Invert\");\n");
+		Recorder.recordString("}\n");
+		Recorder.recordString("imageCalculator(\"AND create\", \"0\",\"1\");\n");
+		Recorder.recordString("imageCalculator(\"AND create\", \"Result of 0\",\"2\");\n");
+		Recorder.recordString("for (i=0;i<3;i++){\n");
+		Recorder.recordString("  selectWindow(\"\"+i);\n");
+		Recorder.recordString("  close();\n");
+		Recorder.recordString("}\n");
+		Recorder.recordString("selectWindow(\"Result of 0\");\n");
+		Recorder.recordString("close();\n");
+		Recorder.recordString("selectWindow(\"Result of Result of 0\");\n");
+
+		//if(invert.getState())
+		//   Recorder.recordString("run(\"Invert\");\n");
+		Recorder.recordString("rename(a);\n");
+		Recorder.recordString("// Colour Thresholding-------------\n");
+	}
+	
+	void showHelp() {
+		IJ.showMessage("Help","Color Thresholder\n \n"+
+			"Modification of Bob Dougherty's BandPass2 plugin by G.Landini\n"+
+			"to threshold 24 bit RGB images based on HSB, RGB, CIE Lab \n"+
+			"or YUV components.\n \n"+
+			"[Pass]: Everything within range is thresholded, otherwise,\n"+
+			"everything outside range is thresholded.\n \n"+
+			"[Default] [Huang] [Intermodes] [etc.]: Selects the automatic\n"+
+			"thresholding method.\n \n"+
+			"[Red] [White] [Black] [B&W]: Selects the threshold color.\n \n"+
+			"[Dark background]: Auto-thresholding methods assume\n"+
+			"light features and dark background.\n \n"+
+			"[Original]: Shows the original image and updates the buffer\n"+
+			"when switching to another image.\n \n"+
+			"[Filtered]: Shows the filtered image.\n \n"+
+			"[Stack]: Processes the rest of the slices in the stack (if any)\n"+
+			"using the current settings.\n \n"+
+			"[Macro]: Creates a macro based on the current settings which\n"+
+			"is sent to the macro Recorder window, if open.\n \n"+
+			"[Sample]: (experimental) Sets the ranges of the filters based\n"+
+			"on the pixel value components in a user-defined ROI.\n \n"+
+			"[HSB] [RGB] [CIE Lab] [YUV]: Selects the color space.\n \n"+
+			"");
+	}
+
+	void sample() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getBitDepth()!=24)
+			return;
+		reset(imp);
+		byte[] hsSource,ssSource,bsSource;
+
+		int [] bin = new int[256];
+		int counter=0, pi=0, rangePassH = 0, rangeStopH = 0, rangePassL = 0, rangeStopL = 0, i, j;
+		int snumPixels=0;
+
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			IJ.error("Selection required");
+			return;
+		}
+
+		ImageProcessor mask = roi.getMask(); 
+
+		Rectangle r = roi.getBoundingRect();
+		//new ImagePlus("Mask", ipm).show(); // display the mask
+
+		ImageProcessor ip = imp.getProcessor();
+
+		// ROI size
+		if (mask==null) { //rectangular
+			snumPixels = r.width*r.height;
+		}
+		else{
+			snumPixels=0;
+			for (j=0; j<r.height; j++) {
+				for (i=0; i<r.width; i++) {
+					if (mask.getPixel(i,j)!=0) {
+						snumPixels++;
+					}
+				}
+			}
+		}
+
+		hsSource = new byte[snumPixels];
+		ssSource = new byte[snumPixels];
+		bsSource = new byte[snumPixels];
+		int [] pixs = new int[snumPixels];
+
+		// get pixel in ROI
+		if (mask==null) {
+			for (j=0; j<r.height; j++) {
+				for (i=0; i<r.width; i++) {
+					pixs[counter++] = ip.getPixel(i+r.x, j+r.y);
+				}
+			}
+		}
+		else{
+			for (j=0; j<r.height; j++) {
+				for (i=0; i<r.width; i++) {
+					if (mask.getPixel(i,j)!=0) { //v1.32c onwards
+						pixs[counter++] = ip.getPixel(i+r.x, j+r.y);
+					}
+				}
+			}
+		}
+		imp.deleteRoi();
+
+		//Get hsb or rgb from roi.
+		//1pixel wide to fit all pixels of a non-square ROI in a ColorProcessor:
+		ColorProcessor cp2 = new ColorProcessor(1, snumPixels, pixs);
+
+		int iminhue=256, imaxhue=-1, iminsat=256, imaxsat=-1, iminbri=256, imaxbri=-1;
+		int iminred=256, imaxred=-1, imingre=256, imaxgre=-1, iminblu=256, imaxblu=-1;
+
+		if(colorSpace==RGB)
+			cp2.getRGB(hsSource,ssSource,bsSource);
+		else if(colorSpace==HSB)
+			cp2.getHSB(hsSource,ssSource,bsSource);
+		else if(colorSpace==LAB)
+			getLab(cp2, hsSource,ssSource,bsSource);
+		else if(colorSpace==YUV)
+			getYUV(cp2, hsSource,ssSource,bsSource);
+
+
+		for (i = 0; i < snumPixels; i++){
+			bin[hsSource[i]&255]=1;
+			if ((hsSource[i]&255)>imaxhue) imaxhue=(hsSource[i]&255);
+			if ((hsSource[i]&255)<iminhue) iminhue=(hsSource[i]&255);
+			if ((ssSource[i]&255)>imaxsat) imaxsat=(ssSource[i]&255);
+			if ((ssSource[i]&255)<iminsat) iminsat=(ssSource[i]&255);
+			if ((bsSource[i]&255)>imaxbri) imaxbri=(bsSource[i]&255);
+			if ((bsSource[i]&255)<iminbri) iminbri=(bsSource[i]&255);
+			//IJ.showMessage("h:"+iminhue+"H:"+imaxhue+"s:"+iminsat+"S:"+imaxsat+"b:"+iminbri+"B:"+imaxbri);
+		}
+
+		if(colorSpace==HSB){ // get pass or stop filter whichever has a narrower range
+			int gap=0, maxgap=0, maxgapst=-1, maxgapen=-1, gapst=0 ;
+
+			if (bin[0]==0){
+				gapst=0;
+				gap=1;
+			}
+
+			for (i = 1; i < 256; i++){
+				//System.out.println("i:"+i+" bin:"+bin[i]);
+				if (bin[i]==0){
+					if (bin[i-1]>0){
+						gap=1;
+						gapst=i;
+					}
+					else {
+						gap++;
+					}
+					if (gap>maxgap){
+						maxgap=gap;
+						maxgapst=gapst;
+						maxgapen=i;
+					}
+				}
+			}
+
+			for (i = 0; i < 256; i++){
+				if (bin[i]>0){
+					rangePassL = i;
+					break;
+				}
+			}
+			for (i = 255; i >= 0; i--){
+				if (bin[i]>0){
+					rangePassH = i;
+					break;
+				}
+			}
+			if ((rangePassH-rangePassL)<maxgap){
+				bandPassH.setState(true);
+				iminhue=rangePassL;
+				imaxhue=rangePassH;
+			}
+			else{
+				bandPassH.setState(false);
+				iminhue=maxgapst;
+				imaxhue=maxgapen;
+			}
+		}
+		else {
+			bandPassH.setState(true);
+		}
+
+		adjustMinHue(iminhue);
+		minSlider.setValue(iminhue);
+		adjustMaxHue(imaxhue);
+		maxSlider.setValue(imaxhue);
+		adjustMinSat(iminsat);
+		minSlider2.setValue(iminsat);
+		adjustMaxSat(imaxsat);
+		maxSlider2.setValue(imaxsat);
+		adjustMinBri(iminbri);
+		minSlider3.setValue(iminbri);
+		adjustMaxBri(imaxbri);
+		maxSlider3.setValue(imaxbri);
+		//originalB.setEnabled(true);
+		//IJ.showStatus("done");
+	}
+
+
+	private boolean checkImage() {
+		if (IJ.debugMode) IJ.log("ColorThresholder.checkImage");
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getBitDepth()!=24) {
+			IJ.beep();
+			IJ.showStatus("No RGB image");
+			return false;
+		}
+		imp.deleteRoi();
+		boolean ok = setup(imp);
+		return ok;
+	}
+
+	boolean setup(ImagePlus imp) {
+		if (IJ.debugMode) IJ.log("ColorThresholder.setup");
+		ImageProcessor ip;
+		int type = imp.getType();
+		if (type!=ImagePlus.COLOR_RGB)
+			return false;
+		ip = imp.getProcessor();
+		int id = imp.getID();
+		int slice = imp.getCurrentSlice();
+		if ((id!=previousImageID)||(slice!=previousSlice)||(flag) ) {
+			Undo.reset();
+			flag = false; //if true, flags a change of colour model
+			numSlices = imp.getStackSize();
+			stack = imp.getStack();
+			width = stack.getWidth();
+			height = stack.getHeight();
+			numPixels = width*height;
+
+			hSource = new byte[numPixels];
+			sSource = new byte[numPixels];
+			bSource = new byte[numPixels];
+			
+			ImageProcessor mask = new ByteProcessor(width, height);
+			imp.setProperty("Mask", mask);
+
+			//Get hsb or rgb from image.
+			ColorProcessor cp = (ColorProcessor)ip;
+			IJ.showStatus("Converting colour space...");
+			if(colorSpace==RGB)
+				cp.getRGB(hSource,sSource,bSource);
+			else if(colorSpace==HSB)
+				cp.getHSB(hSource,sSource,bSource);
+			else if(colorSpace==LAB)
+				getLab(cp, hSource,sSource,bSource);
+			else if(colorSpace==YUV)
+				getYUV(cp, hSource,sSource,bSource);
+
+			IJ.showStatus("");
+
+			//Create a spectrum ColorModel for the Hue histogram plot.
+			Color c;
+			byte[] reds = new byte[256];
+			byte[] greens = new byte[256];
+			byte[] blues = new byte[256];
+			for (int i=0; i<256; i++) {
+				c = Color.getHSBColor(i/255f, 1f, 1f);
+				reds[i] = (byte)c.getRed();
+				greens[i] = (byte)c.getGreen();
+				blues[i] = (byte)c.getBlue();
+			}
+			ColorModel cm = new IndexColorModel(8, 256, reds, greens, blues);
+
+			//Make an image with just the hue from the RGB image and the spectrum LUT.
+			//This is just for a hue histogram for the plot.  Do not show it.
+			//ByteProcessor bpHue = new ByteProcessor(width,height,h,cm);
+			ByteProcessor bpHue = new ByteProcessor(width,height,hSource,cm);
+			ImagePlus impHue = new ImagePlus("Hue",bpHue);
+			//impHue.show();
+
+			ByteProcessor bpSat = new ByteProcessor(width,height,sSource,cm);
+			ImagePlus impSat = new ImagePlus("Sat",bpSat);
+			//impSat.show();
+
+			ByteProcessor bpBri = new ByteProcessor(width,height,bSource,cm);
+			ImagePlus impBri = new ImagePlus("Bri",bpBri);
+			//impBri.show();
+
+			plot.setHistogram(impHue, 0);
+			splot.setHistogram(impSat, 1);
+			bplot.setHistogram(impBri, 2);
+
+			if (!applyingStack)
+				autoSetThreshold();
+			imp.updateAndDraw();
+		}
+		previousImageID = id;
+		previousSlice = slice;
+		return ip!=null;
+	}
+
+	void autoSetThreshold() {
+		if (IJ.debugMode) IJ.log("ColorThresholder.autoSetThreshold");
+		boolean darkb = darkBackground!=null && darkBackground.getState();
+		switch (colorSpace) {
+			case HSB:
+				int[] histogram = bplot.getHistogram();
+				if (histogram==null) return;
+				int threshold = thresholder.getThreshold(method, histogram);
+				if (darkb) {
+					minBri = threshold+1;
+					maxBri = 255;
+				} else {
+					minBri = 0;
+					maxBri = threshold;
+				}
+				break;
+			case RGB:
+				int[] rhistogram = plot.getHistogram();
+				threshold = thresholder.getThreshold(method, rhistogram);
+				if (darkb) {
+					minHue = threshold+1;
+					maxHue = 255;
+				} else {
+					minHue = 0;
+					maxHue = threshold;
+				}
+				int[] ghistogram = splot.getHistogram();
+				threshold = thresholder.getThreshold(method, ghistogram);
+				if (darkb) {
+					minSat = threshold+1;
+					maxSat = 255;
+				} else {
+					minSat = 0;
+					maxSat = threshold;
+				}
+				int[] bhistogram = bplot.getHistogram();
+				threshold = thresholder.getThreshold(method, bhistogram);
+				if (darkb) {
+					minBri = threshold+1;
+					maxBri = 255;
+				} else {
+					minBri = 0;
+					maxBri = threshold;
+				}
+				break;
+			case LAB: case YUV:
+				histogram = plot.getHistogram();
+				threshold = thresholder.getThreshold(method, histogram);
+				if (darkb) {
+					minHue = threshold+1;
+					maxHue = 255;
+				} else {
+					minHue = 0;
+					maxHue = threshold;
+				}
+				break;
+		}
+		updateScrollBars();
+		updateLabels();
+		updatePlot();
+	}
+
+	void updatePlot() {
+		plot.minHue = minHue;
+		plot.maxHue = maxHue;
+		plot.repaint();
+		splot.minHue = minSat;
+		splot.maxHue = maxSat;
+		splot.repaint();
+		bplot.minHue = minBri;
+		bplot.maxHue = maxBri;
+		bplot.repaint();
+	}
+
+	void updateLabels() {
+		label1.setText(""+((int)minHue));
+		label2.setText(""+((int)maxHue));
+		label3.setText(""+((int)minSat));
+		label4.setText(""+((int)maxSat));
+		label5.setText(""+((int)minBri));
+		label6.setText(""+((int)maxBri));
+	}
+
+	void updateNames() {
+		if (colorSpace==RGB){
+			labelh.setText("Red");
+			labels.setText("Green");
+			labelb.setText("Blue");
+		} else if(colorSpace==HSB){
+			labelh.setText("Hue");
+			labels.setText("Saturation");
+			labelb.setText("Brightness");
+		} else if(colorSpace==LAB){
+			labelh.setText("L*");
+			labels.setText("a*");
+			labelb.setText("b*");
+		} else if(colorSpace==YUV){
+			labelh.setText("Y");
+			labels.setText("U");
+			labelb.setText("V");
+		}
+	}
+
+	void updateScrollBars() {
+		minSlider.setValue((int)minHue);
+		maxSlider.setValue((int)maxHue);
+		minSlider2.setValue((int)minSat);
+		maxSlider2.setValue((int)maxSat);
+		minSlider3.setValue((int)minBri);
+		maxSlider3.setValue((int)maxBri);
+	}
+
+	void adjustMinHue(int value) {
+		minHue = value;
+		if (maxHue<minHue) {
+			maxHue = minHue;
+			maxSlider.setValue((int)maxHue);
+		}
+	}
+
+	void adjustMaxHue(int value) {
+		maxHue = value;
+		if (minHue>maxHue) {
+			minHue = maxHue;
+			minSlider.setValue((int)minHue);
+		}
+	}
+
+	void adjustMinSat(int value) {
+		minSat = value;
+		if (maxSat<minSat) {
+			maxSat = minSat;
+			maxSlider2.setValue((int)maxSat);
+		}
+	}
+
+	void adjustMaxSat(int value) {
+		maxSat = value;
+		if (minSat>maxSat) {
+			minSat = maxSat;
+			minSlider2.setValue((int)minSat);
+		}
+	}
+
+	void adjustMinBri(int value) {
+		minBri = value;
+		if (maxBri<minBri) {
+			maxBri = minBri;
+			maxSlider3.setValue((int)maxBri);
+		}
+	}
+
+	void adjustMaxBri(int value) {
+		maxBri = value;
+		if (minBri>maxBri) {
+			minBri = maxBri;
+			minSlider3.setValue((int)minBri);
+		}
+	}
+
+	void apply(ImagePlus imp) {
+		if (IJ.debugMode) IJ.log("ColorThresholder.apply");
+		ImageProcessor fillMaskIP = (ImageProcessor)imp.getProperty("Mask");
+		if (fillMaskIP==null) return;
+		byte[] fillMask = (byte[])fillMaskIP.getPixels();
+		byte fill = (byte)255;
+		byte keep = (byte)0;
+
+		if (bandPassH.getState() && bandPassS.getState() && bandPassB.getState()){ //PPP All pass
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue < minHue)||(hue > maxHue)) || ((sat < minSat)||(sat > maxSat)) || ((bri < minBri)||(bri > maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		} else if(!bandPassH.getState() && !bandPassS.getState() && !bandPassB.getState()){ //SSS All stop
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue >= minHue)&&(hue <= maxHue)) || ((sat >= minSat)&&(sat <= maxSat)) || ((bri >= minBri)&&(bri <= maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		} else if(bandPassH.getState() && bandPassS.getState() && !bandPassB.getState()){ //PPS
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue < minHue)||(hue > maxHue)) || ((sat < minSat)||(sat > maxSat)) || ((bri >= minBri) && (bri <= maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		} else if(!bandPassH.getState() && !bandPassS.getState() && bandPassB.getState()){ //SSP
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue >= minHue) && (hue <= maxHue)) || ((sat >= minSat) && (sat <= maxSat)) || ((bri < minBri) || (bri > maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		} else if (bandPassH.getState() && !bandPassS.getState() && !bandPassB.getState()){ //PSS
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue < minHue) || (hue > maxHue)) || ((sat >= minSat) && (sat <= maxSat)) || ((bri >= minBri) && (bri <= maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		} else if(!bandPassH.getState() && bandPassS.getState() && bandPassB.getState()){ //SPP
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue >= minHue) && (hue <= maxHue))|| ((sat < minSat) || (sat > maxSat)) || ((bri < minBri) || (bri > maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		} else if (!bandPassH.getState() && bandPassS.getState() && !bandPassB.getState()){ //SPS
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue >= minHue)&& (hue <= maxHue)) || ((sat < minSat)||(sat > maxSat)) || ((bri >= minBri) && (bri <= maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		} else if(bandPassH.getState() && !bandPassS.getState() && bandPassB.getState()){ //PSP
+			for (int j = 0; j < numPixels; j++){
+				int hue = hSource[j]&0xff;
+				int sat = sSource[j]&0xff;
+				int bri = bSource[j]&0xff;
+				if (((hue < minHue) || (hue > maxHue)) || ((sat >= minSat)&&(sat <= maxSat)) || ((bri < minBri) || (bri > maxBri)))
+					fillMask[j] = keep;
+				else
+					fillMask[j] = fill;
+			}
+		}
+
+		ImageProcessor ip = imp.getProcessor();
+		if (ip==null) return;
+		if (mode==BLACK_AND_WHITE) {
+			int[] pixels = (int[])ip.getPixels();
+			int fcolor = Prefs.blackBackground?0xffffffff:0xff000000;
+			int bcolor = Prefs.blackBackground?0xff000000:0xffffffff;
+			for (int i=0; i<numPixels; i++) {
+				if (fillMask[i]!=0)
+					pixels[i] = fcolor;
+				else
+					pixels[i]= bcolor;
+			}
+		} else {
+			ip.setColor(thresholdColor());
+			ip.fill(fillMaskIP);
+		}
+	}
+	
+	Color thresholdColor() {
+		Color color = null;
+		switch (mode) {
+			case RED: color=Color.red; break;
+			case WHITE: color=Color.white; break;
+			case BLACK: color=Color.black; break;
+			case BLACK_AND_WHITE: color=Color.black; break;
+		}
+		return color;
+	}
+
+	void applyStack() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return;
+		applyingStack = true;
+		for (int i = 1; i <= numSlices; i++){
+			imp.setSlice(i);
+			if (!checkImage()) return;
+			apply(imp);
+		}
+		applyingStack = false;
+	}
+
+	// Restores the original pixel data
+	void reset(ImagePlus imp) {
+		if (IJ.debugMode) IJ.log("ColorThresholder.reset");
+		ImageProcessor ip = imp.getProcessor();
+		ImagePlus originalImage = (ImagePlus)imp.getProperty("OriginalImage");
+		if (originalImage==null) {
+			originalImage = imp.createImagePlus();
+			originalImage.setTitle(imp.getTitle()+" (Original)");
+			originalImage.setProcessor(ip.duplicate());
+			imp.setProperty("OriginalImage", originalImage);
+		}
+		if (originalImage.getBitDepth()==24) {
+			int[] restore = (int[])originalImage.getProcessor().getPixels();
+			int[] pixels = (int[])ip.getPixels();
+			for (int i=0; i<numPixels; i++)
+				pixels[i] = restore[i];
+		}
+	}
+
+    public void windowActivated(WindowEvent e) {
+    	if (IJ.debugMode) IJ.log("ColorThresholder.windowActivated ");
+    	ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || imp.getBitDepth()!=24) {
+			IJ.beep();
+			IJ.showStatus("No RGB image");
+		} else {
+			setup(imp);
+			//reset(imp);
+			filteredB.setEnabled(true);
+    	}
+	}
+
+	public void close() {
+		super.close();
+		instance = null;
+		done = true;
+		Prefs.set("cthresholder.dark", darkBackground.getState());
+		synchronized(this) {
+			notify();
+		}
+	}
+
+	/** Returns Lab in 3 byte arrays. */
+	public static void getLab(ImageProcessor ip, byte[] L, byte[] a, byte[] b) {
+		ColorSpaceConverter converter = new ColorSpaceConverter();
+		int[] pixels = (int[])ip.getPixels();
+		for (int i=0; i<pixels.length; i++) {
+			double[] values = converter.RGBtoLAB(pixels[i]);
+			int L1 = (int) (values[0] * 2.55);
+			int a1 = (int) (Math.floor((1.0625 * values[1] + 128) + 0.5));
+			int b1 = (int) (Math.floor((1.0625 * values[2] + 128) + 0.5));
+			L[i] = (byte)((int)(L1<0?0:(L1>255?255:L1)) & 0xff);
+			a[i] = (byte)((int)(a1<0?0:(a1>255?255:a1)) & 0xff);
+			b[i] = (byte)((int)(b1<0?0:(b1>255?255:b1)) & 0xff);
+		}
+	}
+		
+	public void getYUV(ImageProcessor ip, byte[] Y, byte[] U, byte[] V) {
+		// Returns YUV in 3 byte arrays.
+		
+		//RGB <--> YUV Conversion Formulas from http://www.cse.msu.edu/~cbowen/docs/yuvtorgb.html
+		//R = Y + (1.4075 * (V - 128));
+		//G = Y - (0.3455 * (U - 128) - (0.7169 * (V - 128));
+		//B = Y + (1.7790 * (U - 128);
+		//
+		//Y = R *  .299 + G *  .587 + B *  .114;
+		//U = R * -.169 + G * -.332 + B *  .500 + 128.;
+		//V = R *  .500 + G * -.419 + B * -.0813 + 128.;
+
+		int c, x, y, i=0, r, g, b;
+		double yf;
+
+		int width=ip.getWidth();
+		int height=ip.getHeight();
+
+		for(y=0;y<height; y++) {
+			for (x=0; x< width;x++){
+				c = ip.getPixel(x,y);
+
+				r = ((c&0xff0000)>>16);//R
+				g = ((c&0x00ff00)>>8);//G
+				b = ( c&0x0000ff); //B 
+
+				// Kai's plugin
+				yf = (0.299 * r  + 0.587 * g + 0.114 * b);
+				Y[i] = (byte)((int)Math.floor(yf + 0.5)) ;
+				U[i] = (byte)(128+(int)Math.floor((0.493 *(b - yf))+ 0.5)); 
+				V[i] = (byte)(128+(int)Math.floor((0.877 *(r - yf))+ 0.5)); 
+				
+				//Y[i] = (byte) (Math.floor( 0.299 * r + 0.587 * g + 0.114  * b)+.5);
+				//U[i] = (byte) (Math.floor(-0.169 * r - 0.332 * g + 0.500  * b + 128.0)+.5);
+				//V[i] = (byte) (Math.floor( 0.500 * r - 0.419 * g - 0.0813 * b + 128.0)+.5);
+				
+				i++;
+			}
+		}
+	}
+	
+	/** Converts the current image from RGB to CIE L*a*b* and stores the results 
+	* in the same RGB image R=L*, G=a*, B=b*. Values are therfore offset and rescaled.
+	*/
+	public static void RGBtoLab() {
+		ImagePlus imp = IJ.getImage();
+		if (imp.getBitDepth()==24)
+			imp.setProcessor(RGBtoLab(imp.getProcessor()));
+	}
+	
+	private static ImageProcessor RGBtoLab(ImageProcessor ip) {
+		int n = ip.getPixelCount();
+		byte[] L = new byte[n];
+		byte[] a = new byte[n];
+		byte[] b = new byte[n];
+		ColorThresholder.getLab(ip, L, a, b);
+		ColorProcessor cp = new ColorProcessor(ip.getWidth(),ip.getHeight());
+		cp.setRGB(L,a,b);
+		return cp;
+	}
+	
+	/** Converts the current image from RGB to YUV and stores 
+	* the results in the same RGB image R=Y, G=U, B=V.
+	* Author: Gabriel Landini,  G.Landini@bham.ac.uk
+	*/
+	public static void RGBtoYUV() {
+		ImagePlus imp = IJ.getImage();
+		if (imp.getBitDepth()==24) {
+			RGBtoYUV(imp.getProcessor());
+			imp.updateAndDraw();
+		}
+	}
+
+	static void RGBtoYUV(ImageProcessor ip) {
+		int xe = ip.getWidth();
+		int ye = ip.getHeight();
+		int c, x, y, i=0, Y, U, V, r, g, b;
+		double yf;
+
+		ImagePlus imp = WindowManager.getCurrentImage();
+
+		for(y=0;y<ye;y++){
+			for (x=0;x<xe;x++){
+				c=ip.getPixel(x,y);
+
+					r = ((c&0xff0000)>>16);//R
+					g = ((c&0x00ff00)>>8);//G
+					b = ( c&0x0000ff); //B 
+
+					// Kai's plugin
+					yf = (0.299 * r  + 0.587 * g + 0.114 * b);
+					Y = ((int)Math.floor(yf + 0.5)) ;
+					U = (128+(int)Math.floor((0.493 *(b - yf))+ 0.5)); 
+					V = (128+(int)Math.floor((0.877 *(r - yf))+ 0.5)); 
+
+					ip.putPixel(x,y, (((Y<0?0:Y>255?255:Y) & 0xff) << 16)+
+									 (((U<0?0:U>255?255:U) & 0xff) << 8) +
+								 	  ((V<0?0:V>255?255:V) & 0xff));
+				
+				ip.putPixel(x,y, ((Y & 0xff) <<16) + ((U & 0xff) << 8) + ( V & 0xff));
+			}
+		}
+	}
+
+
+	
+	class BandPlot extends Canvas implements Measurements, MouseListener {
+	
+		final int WIDTH = 256, HEIGHT=64;
+		double minHue = 0, minSat=0, minBri=0;
+		double maxHue = 255, maxSat= 255, maxBri=255;
+		int[] histogram;
+		Color[] hColors;
+		int hmax;
+		Image os;
+		Graphics osg;
+	
+		public BandPlot() {
+			addMouseListener(this);
+			setSize(WIDTH+1, HEIGHT+1);
+		}
+	
+		/** Overrides Component getPreferredSize(). Added to work
+		around a bug in Java 1.4 on Mac OS X.*/
+		public Dimension getPreferredSize() {
+			return new Dimension(WIDTH+1, HEIGHT+1);
+		}
+	
+		void setHistogram(ImagePlus imp, int j) {
+			ImageProcessor ip = imp.getProcessor();
+			ImageStatistics stats = ImageStatistics.getStatistics(ip, AREA+MODE, null);
+			int maxCount2 = 0;
+			histogram = stats.histogram;
+			for (int i = 0; i < stats.nBins; i++)
+				if ((histogram[i] > maxCount2) ) maxCount2 = histogram[i];
+				//if ((histogram[i] > maxCount2) && (i != stats.mode)) maxCount2 = histogram[i];
+	
+			hmax = (int)(maxCount2 * 1.15);//GL was 1.5
+			os = null;
+			ColorModel cm = ip.getColorModel();
+			if (!(cm instanceof IndexColorModel))
+				return;
+			IndexColorModel icm = (IndexColorModel)cm;
+			int mapSize = icm.getMapSize();
+			if (mapSize!=256)
+				return;
+			byte[] r = new byte[256];
+			byte[] g = new byte[256];
+			byte[] b = new byte[256];
+			icm.getReds(r);
+			icm.getGreens(g);
+			icm.getBlues(b);
+			hColors = new Color[256];
+	
+			if (colorSpace==RGB){
+				if (j==0){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(i&255, 0&255, 0&255);
+					}
+				else if (j==1){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(0&255, i&255, 0&255);
+				}
+				else if (j==2){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(0&255, 0&255, i&255);
+				}
+			}
+			else if (colorSpace==HSB){
+				if (j==0){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(r[i]&255, g[i]&255, b[i]&255);
+				}
+				else if (j==1){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(255&255, 255-i&255, 255-i&255);
+						//hColors[i] = new Color(192-i/4&255, 192+i/4&255, 192-i/4&255);
+				}
+				else if (j==2){
+					for (int i=0; i<256; i++)
+						//hColors[i] = new Color(i&255, i&255, 0&255);
+						hColors[i] = new Color(i&255, i&255, i&255);
+				}
+			}
+			else if (colorSpace==LAB){
+				if (j==0){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(i&255, i&255, i&255);
+				}
+				else if (j==1){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(i&255, 255-i&255, 0&255);
+				}
+				else if (j==2){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(i&255, i&255, 255-i&255);
+				}
+			}
+			else if (colorSpace==YUV){
+				if (j==0){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(i&255, i&255, i&255);
+				}
+				else if (j==1){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color((int)(36+(255-i)/1.4)&255, 255-i&255, i&255);
+				}
+				else if (j==2){
+					for (int i=0; i<256; i++)
+						hColors[i] = new Color(i&255, 255-i&255, (int)(83+(255-i)/2.87)&255);
+				}
+			}
+			
+		}
+		
+		int[] getHistogram() {
+			return histogram;
+		}
+	
+		public void update(Graphics g) {
+			paint(g);
+		}
+	
+		public void paint(Graphics g ) {
+			int hHist=0;
+			if (histogram!=null) {
+				if (os==null) {
+					os = createImage(WIDTH,HEIGHT);
+					osg = os.getGraphics();
+					//osg.setColor(Color.white);
+					osg.setColor(new Color(140,152,144));
+					osg.fillRect(0, 0, WIDTH, HEIGHT);
+					for (int i = 0; i < WIDTH; i++) {
+						if (hColors!=null) osg.setColor(hColors[i]);
+						hHist=HEIGHT - ((int)(HEIGHT * histogram[i])/hmax)-6;
+						osg.drawLine(i, HEIGHT, i, hHist);
+						osg.setColor(Color.black);
+						osg.drawLine(i, hHist, i, hHist);
+					}
+					osg.dispose();
+				}
+				if (os!=null) g.drawImage(os, 0, 0, this);
+			} else {
+				g.setColor(Color.white);
+				g.fillRect(0, 0, WIDTH, HEIGHT);
+			}
+			g.setColor(Color.black);
+			g.drawLine(0, HEIGHT -6, 256, HEIGHT-6);
+			g.drawRect(0, 0, WIDTH, HEIGHT);
+			g.drawRect((int)minHue, 1, (int)(maxHue-minHue), HEIGHT-7);
+		}
+	
+		public void mousePressed(MouseEvent e) {}
+		public void mouseReleased(MouseEvent e) {}
+		public void mouseExited(MouseEvent e) {}
+		public void mouseClicked(MouseEvent e) {}
+		public void mouseEntered(MouseEvent e) {}
+	} // BandPlot class
+
+} // BandAdjuster class
+
+
+
+
diff --git a/src/ij/plugin/frame/Commands.java b/src/ij/plugin/frame/Commands.java
new file mode 100644
index 0000000..d963671
--- /dev/null
+++ b/src/ij/plugin/frame/Commands.java
@@ -0,0 +1,192 @@
+package ij.plugin.frame;
+import ij.*;
+import ij.gui.*;
+import java.awt.*;
+import java.awt.event.*;
+
+
+/** This plugin implements the Plugins>Utiltiees>Recent Commands command. */
+public class Commands extends PlugInFrame implements ActionListener, ItemListener, CommandListener {
+	public static final String LOC_KEY = "commands.loc";
+	public static final String CMDS_KEY = "commands.cmds";
+		public static final int MAX_COMMANDS = 20;
+	private static Frame instance;
+	private static final String divider = "---------------";
+	private static final String[] commands = {
+		"Blobs",
+		"Open...",
+		"Show Info...",
+		"Close",
+		"Close All",
+		"Appearance...",
+		"Histogram",
+		"Gaussian Blur...",		
+		"Record...",
+		"Capture Screen",
+		"Find Commands..."
+	};
+	private List list;
+	private String command;
+	private Button button;
+
+	public Commands() {
+		super("Commands");
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		instance = this;
+		WindowManager.addWindow(this);
+		list = new List(MAX_COMMANDS);
+		list.addItemListener(this);
+		String cmds = Prefs.get(CMDS_KEY, null);
+		if (cmds!=null) {
+			String[] cmd = cmds.split(",");
+			int len = cmd.length<=MAX_COMMANDS?cmd.length:MAX_COMMANDS;
+			boolean isDivider = false;
+			for (int i=0; i<len; i++) {
+				if (divider.equals(cmd[i])) {
+					isDivider = true;
+					break;
+				}
+			}
+			if (isDivider) {
+				for (int i=0; i<len; i++)
+					list.add(cmd[i]);
+			} else
+				cmds = null;				
+		}
+		if (cmds==null)
+			reset();
+		ImageJ ij = IJ.getInstance();
+		addKeyListener(ij);
+		Executer.addCommandListener(this);
+		GUI.scale(list);
+		list.addKeyListener(ij);
+		GridBagLayout gridbag = new GridBagLayout();
+        GridBagConstraints c = new GridBagConstraints();
+        setLayout(gridbag);
+        c.insets = new Insets(0, 0, 0, 0); 
+        c.gridx = 0; c.gridy = 0; c.anchor = GridBagConstraints.WEST;
+        add(list,c); 
+		button = new Button("Edit");
+		button.addActionListener(this);
+		button.addKeyListener(ij);
+        //c.insets = new Insets(2, 6, 6, 6); 
+        c.gridx = 0; c.gridy = 2; c.anchor = GridBagConstraints.CENTER;
+        add(button, c);
+		pack();
+		Dimension size = getSize();
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null)
+			setLocation(loc);
+		show();
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		GenericDialog gd = new GenericDialog("Commands");
+		int dividerIndex = getDividerIndex();
+		StringBuilder sb = new StringBuilder(200);
+		sb.append("| ");	
+		for (int i=0; i<dividerIndex; i++) {
+			String cmd = list.getItem(i);
+			sb.append(cmd);
+			sb.append(" | ");
+		}
+		sb.append("Debug Mode | Hyperstack |");
+		String recentCommands = sb.toString();
+		gd.setInsets(5, 0, 0);
+		gd.addTextAreas(recentCommands, null, 5, 28);
+		int index = dividerIndex + 1;
+		int n = 1;
+		for (int i=index; i<list.getItemCount(); i++) {
+			gd.setInsets(2, 8, 0);
+			gd.addStringField("Cmd"+IJ.pad(n++,2)+":", list.getItem(i), 20);
+		}
+		gd.enableYesNoCancel(" OK ", "Reset");
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		else if (!gd.wasOKed()) {
+			boolean ok = IJ.showMessageWithCancel("Commands", "Are you sure you want to reset?");
+			if (ok) reset();
+        } else { 
+			for (int i=index; i<list.getItemCount(); i++)
+				list.replaceItem(gd.getNextString(),i);
+		}
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		//IJ.log("itemStateChanged: "+e);
+		if (e.getStateChange()==ItemEvent.SELECTED) {
+			int index = list.getSelectedIndex();
+			if (index<0)
+				return;
+			command = list.getItem(index);
+			if (!command.equals(divider)) {
+				if (command.equals("Debug Mode"))
+					IJ.runMacro("setOption('DebugMode')");
+				else if (command.equals("Hyperstack"))
+					IJ.runMacro("newImage('HyperStack', '8-bit color label', 400, 300, 3, 4, 25)");
+				else
+					IJ.doCommand(command);
+			}
+			list.deselect(index);
+		}
+	}
+	
+	public String commandExecuting(String cmd2) {
+		if ("Quit".equals(cmd2))
+			return cmd2;
+		String cmd1 = command;
+		if (cmd1==null || !cmd1.equals(cmd2)) {
+			try {
+				list.remove(cmd2);
+			} catch(Exception e) {}
+			if (list.getItemCount()>=MAX_COMMANDS)
+				list.remove(getDividerIndex()-1);
+			list.add(cmd2, 0);
+		}
+		command = null;
+		return cmd2;
+	}
+	
+	private int getDividerIndex() {
+		int index = 0;
+		for (int i=0; i<MAX_COMMANDS; i++) {
+			String cmd = list.getItem(i);
+			if (divider.equals(cmd)) {
+				index = i;
+				break;
+			}
+		}
+		return index;
+	}
+	
+	private void reset() {
+		list.clear();
+		list.add(divider);
+		int len = commands.length<MAX_COMMANDS?commands.length:MAX_COMMANDS-1;
+		for (int i=0; i<len; i++)
+			list.add(commands[i]);		
+	}
+	
+	/** Overrides PlugInFrame.close(). */
+	public void close() {
+		super.close();
+		instance = null;
+		Executer.removeCommandListener(this);
+		Prefs.saveLocation(LOC_KEY, getLocation());
+		StringBuilder sb = new StringBuilder(200);
+		for (int i=0; i<list.getItemCount(); i++) {
+			String cmd = list.getItem(i);
+			sb.append(cmd);
+			sb.append(",");
+		}
+		String cmds = sb.toString();
+		cmds = cmds.substring(0, cmds.length()-1);
+		//IJ.log("close: "+cmds); IJ.wait(5000);
+		Prefs.set(CMDS_KEY, cmds);
+	}
+
+}
diff --git a/src/ij/plugin/frame/ContrastAdjuster.java b/src/ij/plugin/frame/ContrastAdjuster.java
new file mode 100644
index 0000000..0cda73b
--- /dev/null
+++ b/src/ij/plugin/frame/ContrastAdjuster.java
@@ -0,0 +1,1363 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.*;
+import ij.*;
+import ij.plugin.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+
+/** This plugin implements the Brightness/Contrast, Window/level and
+	Color Balance commands, all in the Image/Adjust sub-menu. It
+	allows the user to interactively adjust the brightness  and
+	contrast of the active image. It is multi-threaded to
+	provide a more  responsive user interface. */
+public class ContrastAdjuster extends PlugInDialog implements Runnable,
+	ActionListener, AdjustmentListener, ItemListener {
+
+	public static final String LOC_KEY = "b&c.loc";
+	public static final String[] sixteenBitRanges = {"Automatic", "8-bit (0-255)", "10-bit (0-1023)",
+		"12-bit (0-4095)", "14-bit (0-16383)", "15-bit (0-32767)", "16-bit (0-65535)"};
+	static final int AUTO_THRESHOLD = 5000;
+	static final String[] channelLabels = {"Red", "Green", "Blue", "Cyan", "Magenta", "Yellow", "All"};
+	static final String[] altChannelLabels = {"Channel 1", "Channel 2", "Channel 3", "Channel 4", "Channel 5", "Channel 6", "All"};
+	static final int[] channelConstants = {4, 2, 1, 3, 5, 6, 7};
+
+	ContrastPlot plot = new ContrastPlot();
+	Thread thread;
+	private static ContrastAdjuster instance;
+
+	int minSliderValue=-1, maxSliderValue=-1, brightnessValue=-1, contrastValue=-1;
+	int sliderRange = 256;
+	boolean doAutoAdjust,doReset,doSet,doApplyLut;
+
+	Panel panel, tPanel;
+	Button autoB, resetB, setB, applyB;
+	int previousImageID;
+	int previousType;
+	int previousSlice = 1;
+	ImageJ ij;
+	double min, max;
+	double previousMin, previousMax;
+	double defaultMin, defaultMax;
+	int contrast, brightness;
+	boolean RGBImage;
+	Scrollbar minSlider, maxSlider, contrastSlider, brightnessSlider;
+	Label minLabel, maxLabel, windowLabel, levelLabel;
+	boolean done;
+	int autoThreshold;
+	GridBagLayout gridbag;
+	GridBagConstraints c;
+	int y = 0;
+	boolean windowLevel, balance;
+	Font monoFont = new Font("Monospaced", Font.PLAIN, 11);
+	Font sanFont = IJ.font12;
+	int channels = 7; // RGB
+	Choice choice;
+	private String blankMinLabel = "--------";
+	private String blankMaxLabel = "--------";
+	private double scale = Prefs.getGuiScale();
+	private int digits;
+
+	public ContrastAdjuster() {
+		super("B&C");
+	}
+
+	public void run(String arg) {
+		windowLevel = arg.equals("wl");
+		balance = arg.equals("balance");
+		if (windowLevel)
+			setTitle("W&L");
+		else if (balance) {
+			setTitle("Color");
+			channels = 4;
+		}
+
+		if (instance!=null) {
+			if (!instance.getTitle().equals(getTitle())) {
+				ContrastAdjuster ca = instance;
+				Prefs.saveLocation(LOC_KEY, ca.getLocation());
+				ca.close();
+			} else {
+				instance.toFront();
+				return;
+			}
+		}
+		instance = this;
+		IJ.register(ContrastAdjuster.class);
+		WindowManager.addWindow(this);
+
+		ij = IJ.getInstance();
+		gridbag = new GridBagLayout();
+		c = new GridBagConstraints();
+		setLayout(gridbag);
+		if (scale>1.0) {
+			sanFont = sanFont.deriveFont((float)(sanFont.getSize()*scale));
+			monoFont = monoFont.deriveFont((float)(monoFont.getSize()*scale));
+		}
+
+		// plot
+		c.gridx = 0;
+		y = 0;
+		c.gridy = y++;
+		c.fill = GridBagConstraints.BOTH;
+		c.anchor = GridBagConstraints.CENTER;
+		c.insets = new Insets(10, 10, 0, 10);
+		gridbag.setConstraints(plot, c);
+		add(plot);
+		plot.addKeyListener(ij);
+		// min and max labels
+
+		if (!windowLevel) {
+			panel = new Panel();
+			c.gridy = y++;
+			c.insets = new Insets(0, 10, 0, 10);
+			gridbag.setConstraints(panel, c);
+			panel.setLayout(new BorderLayout());
+			minLabel = new Label(blankMinLabel, Label.LEFT);
+			minLabel.setFont(monoFont);
+			if (IJ.debugMode) minLabel.setBackground(Color.yellow);
+			panel.add("West", minLabel);
+			maxLabel = new Label(blankMaxLabel, Label.RIGHT);
+			maxLabel.setFont(monoFont);
+			if (IJ.debugMode) maxLabel.setBackground(Color.yellow);
+			panel.add("East", maxLabel);
+			add(panel);
+			blankMinLabel = "        ";
+			blankMaxLabel = "        ";
+		}
+
+		// min slider
+		if (!windowLevel) {
+			minSlider = new Scrollbar(Scrollbar.HORIZONTAL, sliderRange/2, 1, 0, sliderRange);
+			GUI.fixScrollbar(minSlider);
+			c.gridy = y++;
+			c.insets = new Insets(2, 10, 0, 10);
+			gridbag.setConstraints(minSlider, c);
+			add(minSlider);
+			minSlider.addAdjustmentListener(this);
+			minSlider.addKeyListener(ij);
+			minSlider.setUnitIncrement(1);
+			minSlider.setFocusable(false); // prevents blinking on Windows
+			addLabel("Minimum", null);
+		}
+
+		// max slider
+		if (!windowLevel) {
+			maxSlider = new Scrollbar(Scrollbar.HORIZONTAL, sliderRange/2, 1, 0, sliderRange);
+			GUI.fixScrollbar(maxSlider);
+			c.gridy = y++;
+			c.insets = new Insets(2, 10, 0, 10);
+			gridbag.setConstraints(maxSlider, c);
+			add(maxSlider);
+			maxSlider.addAdjustmentListener(this);
+			maxSlider.addKeyListener(ij);
+			maxSlider.setUnitIncrement(1);
+			maxSlider.setFocusable(false);
+			addLabel("Maximum", null);
+		}
+
+		// brightness slider
+		brightnessSlider = new Scrollbar(Scrollbar.HORIZONTAL, sliderRange/2, 1, 0, sliderRange);
+		GUI.fixScrollbar(brightnessSlider);
+		c.gridy = y++;
+		c.insets = new Insets(windowLevel?12:2, 10, 0, 10);
+		gridbag.setConstraints(brightnessSlider, c);
+		add(brightnessSlider);
+		brightnessSlider.addAdjustmentListener(this);
+		brightnessSlider.addKeyListener(ij);
+		brightnessSlider.setUnitIncrement(1);
+		brightnessSlider.setFocusable(false);
+		if (windowLevel)
+			addLabel("Level: ", levelLabel=new TrimmedLabel("        "));
+		else
+			addLabel("Brightness", null);
+
+		// contrast slider
+		if (!balance) {
+			contrastSlider = new Scrollbar(Scrollbar.HORIZONTAL, sliderRange/2, 1, 0, sliderRange);
+			GUI.fixScrollbar(contrastSlider);
+			c.gridy = y++;
+			c.insets = new Insets(2, 10, 0, 10);
+			gridbag.setConstraints(contrastSlider, c);
+			add(contrastSlider);
+			contrastSlider.addAdjustmentListener(this);
+			contrastSlider.addKeyListener(ij);
+			contrastSlider.setUnitIncrement(1);
+			contrastSlider.setFocusable(false);
+			if (windowLevel)
+				addLabel("Window: ", windowLabel=new TrimmedLabel("        "));
+			else
+				addLabel("Contrast", null);
+		}
+
+		// color channel popup menu
+		if (balance) {
+			c.gridy = y++;
+			c.insets = new Insets(5, 10, 0, 10);
+			choice = new Choice();
+			addBalanceChoices();
+			gridbag.setConstraints(choice, c);
+			choice.addItemListener(this);
+			add(choice);
+		}
+
+		// buttons
+ 		if (scale>1.0) {
+			Font font = getFont();
+			if (font!=null)
+				font = font.deriveFont((float)(font.getSize()*scale));
+			else
+				font = new Font("SansSerif", Font.PLAIN, (int)(12*scale));
+			setFont(font);
+		}
+		int trim = IJ.isMacOSX()?20:0;
+		panel = new Panel();
+		panel.setLayout(new GridLayout(0,2, 0, 0));
+		autoB = new TrimmedButton("Auto",trim);
+		autoB.addActionListener(this);
+		autoB.addKeyListener(ij);
+		panel.add(autoB);
+		resetB = new TrimmedButton("Reset",trim);
+		resetB.addActionListener(this);
+		resetB.addKeyListener(ij);
+		panel.add(resetB);
+		setB = new TrimmedButton("Set",trim);
+		setB.addActionListener(this);
+		setB.addKeyListener(ij);
+		panel.add(setB);
+		applyB = new TrimmedButton("Apply",trim);
+		applyB.addActionListener(this);
+		applyB.addKeyListener(ij);
+		panel.add(applyB);
+		c.gridy = y++;
+		c.insets = new Insets(8, 5, 10, 5);
+		gridbag.setConstraints(panel, c);
+		add(panel);
+
+ 		addKeyListener(ij);  // ImageJ handles keyboard shortcuts
+		pack();
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null)
+			setLocation(loc);
+		else
+			GUI.centerOnImageJScreen(this);
+		if (IJ.isMacOSX()) setResizable(false);
+		show();
+
+		thread = new Thread(this, "ContrastAdjuster");
+		//thread.setPriority(thread.getPriority()-1);
+		thread.start();
+		setup();
+	}
+
+	void addBalanceChoices() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null && imp.isComposite()) {
+			for (int i=0; i<altChannelLabels.length; i++)
+				choice.addItem(altChannelLabels[i]);
+		} else {
+			for (int i=0; i<channelLabels.length; i++)
+				choice.addItem(channelLabels[i]);
+		}
+	}
+
+	void addLabel(String text, Label label2) {
+		if (label2==null&&IJ.isMacOSX()) text += "    ";
+		panel = new Panel();
+		c.gridy = y++;
+		int bottomInset = IJ.isMacOSX()?4:0;
+		c.insets = new Insets(0, 10, bottomInset, 0);
+		gridbag.setConstraints(panel, c);
+        panel.setLayout(new FlowLayout(label2==null?FlowLayout.CENTER:FlowLayout.LEFT, 0, 0));
+		Label label= new TrimmedLabel(text);
+		label.setFont(sanFont);
+		panel.add(label);
+		if (label2!=null) {
+			label2.setFont(monoFont);
+			label2.setAlignment(Label.LEFT);
+			panel.add(label2);
+		}
+		add(panel);
+	}
+
+	void setup() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			if (imp.getType()==ImagePlus.COLOR_RGB && imp.isLocked())
+				return;
+			setup(imp);
+			updatePlot();
+			updateLabels(imp);
+			imp.updateAndDraw();
+		}
+	}
+
+	public synchronized void adjustmentValueChanged(AdjustmentEvent e) {
+		Object source = e.getSource();
+		if (source==minSlider)
+			minSliderValue = minSlider.getValue();
+		else if (source==maxSlider)
+			maxSliderValue = maxSlider.getValue();
+		else if (source==contrastSlider)
+			contrastValue = contrastSlider.getValue();
+		else
+			brightnessValue = brightnessSlider.getValue();
+		notify();
+	}
+
+	public synchronized  void actionPerformed(ActionEvent e) {
+		Button b = (Button)e.getSource();
+		if (b==null) return;
+		if (b==resetB)
+			doReset = true;
+		else if (b==autoB)
+			doAutoAdjust = true;
+		else if (b==setB)
+			doSet = true;
+		else if (b==applyB)
+			doApplyLut = true;
+		notify();
+	}
+
+	ImageProcessor setup(ImagePlus imp) {
+		Roi roi = imp.getRoi();
+		if (roi!=null) roi.endPaste();
+		ImageProcessor ip = imp.getProcessor();
+		int type = imp.getType();
+		int slice = imp.getCurrentSlice();
+		RGBImage = type==ImagePlus.COLOR_RGB;
+		if (imp.getID()!=previousImageID || type!=previousType || slice!=previousSlice)
+			setupNewImage(imp, ip);
+		previousImageID = imp.getID();
+	 	previousType = type;
+	 	previousSlice = slice;
+	 	return ip;
+	}
+
+	void setupNewImage(ImagePlus imp, ImageProcessor ip)  {
+		Undo.reset();
+		previousMin = min;
+		previousMax = max;
+		boolean newRGBImage = RGBImage && !((ColorProcessor)ip).caSnapshot();
+	 	if (newRGBImage) {
+	 		ip.snapshot();
+	 		((ColorProcessor)ip).caSnapshot(true);
+	 	}
+		double min2 = imp.getDisplayRangeMin();
+		double max2 = imp.getDisplayRangeMax();
+		if (newRGBImage) {
+			min2=0.0;
+			max2=255.0;
+		}
+		int bitDepth = imp.getBitDepth();
+		if (bitDepth==16 || bitDepth==32) {
+			Roi roi = imp.getRoi();
+			imp.deleteRoi();
+			ImageStatistics stats = imp.getRawStatistics();
+			defaultMin = stats.min;
+			defaultMax = stats.max;
+			imp.setRoi(roi);
+		} else {
+			defaultMin = 0;
+			defaultMax = 255;
+		}
+		setMinAndMax(imp, min2, max2);
+		min = imp.getDisplayRangeMin();
+		max = imp.getDisplayRangeMax();
+		plot.defaultMin = defaultMin;
+		plot.defaultMax = defaultMax;
+		int valueRange = (int)(defaultMax-defaultMin);
+		int newSliderRange = valueRange;
+		if (newSliderRange>640 && newSliderRange<1280)
+			newSliderRange /= 2;
+		else if (newSliderRange>=1280)
+			newSliderRange /= 5;
+		if (newSliderRange<256) newSliderRange = 256;
+		if (newSliderRange>1024) newSliderRange = 1024;
+		double displayRange = max-min;
+		if (valueRange>=1280 && valueRange!=0 && displayRange/valueRange<0.25)
+			newSliderRange *= 1.6666;
+		if (newSliderRange!=sliderRange) {
+			sliderRange = newSliderRange;
+			updateScrollBars(null, true);
+		} else
+			updateScrollBars(null, false);
+		if (balance) {
+			if (imp.isComposite()) {
+				int channel = imp.getChannel();
+				if (channel<=4) {
+					choice.select(channel-1);
+					channels = channelConstants[channel-1];
+				}
+				if (choice.getItem(0).equals("Red")) {
+					choice.removeAll();
+					addBalanceChoices();
+				}
+			} else { // not composite
+				if (choice.getItem(0).equals("Channel 1")) {
+					choice.removeAll();
+					addBalanceChoices();
+				}
+			}
+		}
+		if (!doReset)
+			plotHistogram(imp);
+		autoThreshold = 0;
+		if (imp.isComposite())
+			IJ.setKeyUp(KeyEvent.VK_SHIFT);
+	}
+
+	void setMinAndMax(ImagePlus imp, double min, double max) {
+		boolean rgb = imp.getType()==ImagePlus.COLOR_RGB;
+		if (channels!=7 && rgb)
+			imp.setDisplayRange(min, max, channels);
+		else
+			imp.setDisplayRange(min, max);
+		if (rgb)
+			plotHistogram(imp);
+	}
+
+	void updatePlot() {
+		plot.min = min;
+		plot.max = max;
+		plot.repaint();
+	}
+
+	void updateLabels(ImagePlus imp) {
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();;
+		int type = imp.getType();
+		Calibration cal = imp.getCalibration();
+		boolean realValue = type==ImagePlus.GRAY32;
+		if (cal.calibrated()) {
+			min = cal.getCValue((int)min);
+			max = cal.getCValue((int)max);
+			realValue = true;
+		}
+		if (windowLevel) {
+			digits = realValue?2:0;
+			double window = max-min;
+			double level = min+(window)/2.0;
+			windowLabel.setText(IJ.d2s(window, digits));
+			levelLabel.setText(IJ.d2s(level, digits));
+		} else {
+			digits = realValue?4:0;
+			if (realValue) {
+				double s = min<0||max<0?0.1:1.0;
+				double amin = Math.abs(min);
+				double amax = Math.abs(max);
+				if (amin>99.0*s||amax>99.0*s) digits = 3;
+				if (amin>999.0*s||amax>999.0*s) digits = 2;
+				if (amin>9999.0*s||amax>9999.0*s) digits = 1;
+				if (amin>99999.0*s||amax>99999.0*s) digits = 0;
+				if (amin>9999999.0*s||amax>9999999.0*s) digits = -2;
+			}
+			String minString = IJ.d2s(min, min==0.0?0:digits) + blankMinLabel;
+			minLabel.setText(minString.substring(0,blankMinLabel.length()));
+			String maxString = blankMaxLabel + IJ.d2s(max, digits);
+			maxString = maxString.substring(maxString.length()-blankMaxLabel.length(), maxString.length());
+			maxLabel.setText(maxString);
+		}
+	}
+
+	void updateScrollBars(Scrollbar sb, boolean newRange) {
+		if (sb==null || sb!=contrastSlider) {
+			double mid = sliderRange/2;
+			double c = ((defaultMax-defaultMin)/(max-min))*mid;
+			if (c>mid)
+				c = sliderRange - ((max-min)/(defaultMax-defaultMin))*mid;
+			contrast = (int)c;
+			if (contrastSlider!=null) {
+				if (newRange)
+					contrastSlider.setValues(contrast, 1, 0,  sliderRange);
+				else
+					contrastSlider.setValue(contrast);
+			}
+		}
+		if (sb==null || sb!=brightnessSlider) {
+			double level = min + (max-min)/2.0;
+			double normalizedLevel = 1.0 - (level - defaultMin)/(defaultMax-defaultMin);
+			brightness = (int)(normalizedLevel*sliderRange);
+			if (newRange)
+				brightnessSlider.setValues(brightness, 1, 0,  sliderRange);
+			else
+				brightnessSlider.setValue(brightness);
+		}
+		if (minSlider!=null && (sb==null || sb!=minSlider)) {
+			if (newRange)
+				minSlider.setValues(scaleDown(min), 1, 0,  sliderRange);
+			else
+				minSlider.setValue(scaleDown(min));
+		}
+		if (maxSlider!=null && (sb==null || sb!=maxSlider)) {
+			if (newRange)
+				maxSlider.setValues(scaleDown(max), 1, 0,  sliderRange);
+			else
+				maxSlider.setValue(scaleDown(max));
+		}
+	}
+
+	int scaleDown(double v) {
+		if (v<defaultMin) v = defaultMin;
+		if (v>defaultMax) v = defaultMax;
+		return (int)((v-defaultMin)*(sliderRange-1.0)/(defaultMax-defaultMin));
+	}
+
+	/** Restore image outside non-rectangular roi. */
+  	void doMasking(ImagePlus imp, ImageProcessor ip) {
+		ImageProcessor mask = imp.getMask();
+		if (mask!=null) {
+			Rectangle r = ip.getRoi();
+			if (mask.getWidth()!=r.width||mask.getHeight()!=r.height) {
+				ip.setRoi(imp.getRoi());
+				mask = ip.getMask();
+			}
+			ip.reset(mask);
+		}
+	}
+
+	void adjustMin(ImagePlus imp, ImageProcessor ip, double minvalue) {
+		resetRGB(ip);
+		min = defaultMin + minvalue*(defaultMax-defaultMin)/(sliderRange-1.0);
+		if (max>defaultMax)
+			max = defaultMax;
+		if (min>max)
+			max = min;
+		setMinAndMax(imp, min, max);
+		if (min==max)
+			setThreshold(ip);
+		if (RGBImage) doMasking(imp, ip);
+		updateScrollBars(minSlider, false);
+	}
+
+	void adjustMax(ImagePlus imp, ImageProcessor ip, double maxvalue) {
+		resetRGB(ip);
+		max = defaultMin + maxvalue*(defaultMax-defaultMin)/(sliderRange-1.0);
+		//IJ.log("adjustMax: "+maxvalue+"  "+max);
+		if (min<defaultMin)
+			min = defaultMin;
+		if (max<min)
+			min = max;
+		setMinAndMax(imp, min, max);
+		if (min==max)
+			setThreshold(ip);
+		if (RGBImage) doMasking(imp, ip);
+		updateScrollBars(maxSlider, false);
+	}
+	
+	private void resetRGB(ImageProcessor ip) {
+		if (!(ip instanceof ColorProcessor))
+			return;
+		if (ip.getMin()==0 && ip.getMax()==255 && !((ColorProcessor)ip).caSnapshot()) {
+	 		ip.snapshot();
+	 		((ColorProcessor)ip).caSnapshot(true);
+		}
+	}
+
+	void adjustBrightness(ImagePlus imp, ImageProcessor ip, double bvalue) {
+		double center = defaultMin + (defaultMax-defaultMin)*((sliderRange-bvalue)/sliderRange);
+		double width = max-min;
+		min = center - width/2.0;
+		max = center + width/2.0;
+		setMinAndMax(imp, min, max);
+		if (min==max)
+			setThreshold(ip);
+		if (RGBImage) doMasking(imp, ip);
+		updateScrollBars(brightnessSlider, false);
+	}
+
+	void adjustContrast(ImagePlus imp, ImageProcessor ip, int cvalue) {
+		double slope;
+		double center = min + (max-min)/2.0;
+		double range = defaultMax-defaultMin;
+		double mid = sliderRange/2;
+		if (cvalue<=mid)
+			slope = cvalue/mid;
+		else
+			slope = mid/(sliderRange-cvalue);
+		if (slope>0.0) {
+			min = center-(0.5*range)/slope;
+			max = center+(0.5*range)/slope;
+		}
+		setMinAndMax(imp, min, max);
+		if (RGBImage) doMasking(imp, ip);
+		updateScrollBars(contrastSlider, false);
+	}
+
+	void reset(ImagePlus imp, ImageProcessor ip) {
+ 		if (RGBImage)
+			ip.reset();
+		int bitDepth = imp.getBitDepth();
+		if (bitDepth==16 || bitDepth==32) {
+			imp.resetDisplayRange();
+			defaultMin = imp.getDisplayRangeMin();
+			defaultMax = imp.getDisplayRangeMax();
+			plot.defaultMin = defaultMin;
+			plot.defaultMax = defaultMax;
+		}
+		min = defaultMin;
+		max = defaultMax;
+		setMinAndMax(imp, min, max);
+		updateScrollBars(null, false);
+		plotHistogram(imp);
+		autoThreshold = 0;
+	}
+
+	void plotHistogram(ImagePlus imp) {
+		ImageStatistics stats;
+		if (balance && (channels==4 || channels==2 || channels==1) && imp.getType()==ImagePlus.COLOR_RGB) {
+			int w = imp.getWidth();
+			int h = imp.getHeight();
+			byte[] r = new byte[w*h];
+			byte[] g = new byte[w*h];
+			byte[] b = new byte[w*h];
+			((ColorProcessor)imp.getProcessor()).getRGB(r,g,b);
+			byte[] pixels=null;
+			if (channels==4)
+				pixels = r;
+			else if (channels==2)
+				pixels = g;
+			else if (channels==1)
+				pixels = b;
+			ImageProcessor ip = new ByteProcessor(w, h, pixels, null);
+			stats = ImageStatistics.getStatistics(ip, 0, imp.getCalibration());
+		} else {
+			int range = imp.getType()==ImagePlus.GRAY16?ImagePlus.getDefault16bitRange():0;
+			if (range!=0 && imp.getProcessor().getMax()==Math.pow(2,range)-1 && !(imp.getCalibration().isSigned16Bit())) {
+				ImagePlus imp2 = new ImagePlus("Temp", imp.getProcessor());
+				stats = new StackStatistics(imp2, 256, 0, Math.pow(2,range));
+			} else
+				stats = imp.getStatistics();
+		}
+		Color color = Color.gray;
+		if (imp.isComposite() && !(balance&&channels==7))
+			color = ((CompositeImage)imp).getChannelColor();
+		plot.setHistogram(stats, color);
+	}
+
+	void apply(ImagePlus imp, ImageProcessor ip) {
+		if (balance && imp.isComposite())
+			return;
+		int bitDepth = imp.getBitDepth();
+		if ((bitDepth==8||bitDepth==16) && !IJ.isMacro()) {
+			String msg = "WARNING: the pixel values will\nchange if you click \"OK\".";
+			if (!IJ.showMessageWithCancel("Apply Lookup Table?", msg))
+				return;
+		}
+		String option = null;
+		if (RGBImage)
+			imp.unlock();
+		if (!imp.lock())
+			return;
+		if (RGBImage) {
+			if (imp.getStackSize()>1)
+				applyRGBStack(imp);
+			else
+				applyRGB(imp,ip);
+			return;
+		}
+		if (bitDepth==32) {
+			IJ.beep();
+			IJ.error("\"Apply\" does not work with 32-bit images");
+			imp.unlock();
+			return;
+		}
+		int range = 256;
+		if (bitDepth==16) {
+			range = 65536;
+			int defaultRange = imp.getDefault16bitRange();
+			if (defaultRange>0)
+				range = (int)Math.pow(2,defaultRange)-1;
+		}
+		int tableSize = bitDepth==16?65536:256;
+		int[] table = new int[tableSize];
+		int min = (int)imp.getDisplayRangeMin();
+		int max = (int)imp.getDisplayRangeMax();
+		if (IJ.debugMode) IJ.log("Apply: mapping "+min+"-"+max+" to 0-"+(range-1));
+		for (int i=0; i<tableSize; i++) {
+			if (i<=min)
+				table[i] = 0;
+			else if (i>=max)
+				table[i] = range-1;
+			else
+				table[i] = (int)(((double)(i-min)/(max-min))*range);
+		}
+		ip.setRoi(imp.getRoi());
+		if (imp.getStackSize()>1 && !imp.isComposite()) {
+			ImageStack stack = imp.getStack();
+			YesNoCancelDialog d = new YesNoCancelDialog(new Frame(),
+				"Entire Stack?", "Apply LUT to all "+stack.size()+" stack slices?");
+			if (d.cancelPressed())
+				{imp.unlock(); return;}
+			if (d.yesPressed()) {
+				if (imp.getStack().isVirtual()) {
+					imp.unlock();
+					IJ.error("\"Apply\" does not work with virtual stacks. Use\nImage>Duplicate to convert to a normal stack.");
+					return;
+				}
+				int current = imp.getCurrentSlice();
+				ImageProcessor mask = imp.getMask();
+				for (int i=1; i<=imp.getStackSize(); i++) {
+					imp.setSlice(i);
+					ip = imp.getProcessor();
+					if (mask!=null) ip.snapshot();
+					ip.applyTable(table);
+					ip.reset(mask);
+				}
+				imp.setSlice(current);
+				option = "stack";
+			} else {
+				ip.snapshot();
+				ip.applyTable(table);
+				ip.reset(ip.getMask());
+				option = "slice";
+			}
+		} else {
+			ip.snapshot();
+			ip.applyTable(table);
+			ip.reset(ip.getMask());
+		}
+		reset(imp, ip);
+		imp.changes = true;
+		imp.unlock();
+		if (Recorder.record) {
+			if (Recorder.scriptMode()) {
+				if (option==null) option = "";
+				Recorder.recordCall("IJ.run(imp, \"Apply LUT\", \""+option+"\");");
+			} else {
+				if (option!=null)
+					Recorder.record("run", "Apply LUT", option);
+				else
+					Recorder.record("run", "Apply LUT");
+			}
+		}
+	}
+
+	void applyRGB(ImagePlus imp, ImageProcessor ip) {
+		recordSetMinAndMax(ip.getMin(), ip.getMax());
+		ip.snapshot();
+		ip.setMinAndMax(0, 255);
+		reset(imp, ip);
+		/*
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();
+ 		ip.setRoi(imp.getRoi());
+ 		ip.reset();
+		if (channels!=7)
+			((ColorProcessor)ip).setMinAndMax(min, max, channels);
+		else
+			ip.setMinAndMax(min, max);
+		ip.reset(ip.getMask());
+		imp.changes = true;
+		previousImageID = 0;
+	 	((ColorProcessor)ip).caSnapshot(false);
+		setup();
+		if (Recorder.record) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("IJ.run(imp, \"Apply LUT\", \"\");");
+			else
+				Recorder.record("run", "Apply LUT");
+		}
+		*/
+	}
+
+	private void applyRGBStack(ImagePlus imp) {
+		double min = imp.getDisplayRangeMin();
+		double max = imp.getDisplayRangeMax();
+		if (IJ.debugMode) IJ.log("applyRGBStack: "+min+"-"+max);
+		int current = imp.getCurrentSlice();
+		int n = imp.getStackSize();
+		if (!IJ.showMessageWithCancel("Update Entire Stack?",
+		"Apply brightness and contrast settings\n"+
+		"to all "+n+" slices in the stack?\n \n"+
+		"NOTE: There is no Undo for this operation."))
+			return;
+ 		ImageProcessor mask = imp.getMask();
+ 		Rectangle roi = imp.getRoi()!=null?imp.getRoi().getBounds():null;
+ 		ImageStack stack = imp.getStack();
+		for (int i=1; i<=n; i++) {
+			IJ.showProgress(i, n);
+			IJ.showStatus(i+"/"+n);
+			if (i!=current) {
+				ImageProcessor ip = stack.getProcessor(i);
+				ip.setRoi(roi);
+				if (mask!=null) ip.snapshot();
+				if (channels!=7)
+					((ColorProcessor)ip).setMinAndMax(min, max, channels);
+				else
+					ip.setMinAndMax(min, max);
+				if (mask!=null) ip.reset(mask);
+			}
+		}
+		imp.setStack(null, stack);
+		imp.setSlice(current);
+		imp.changes = true;
+		previousImageID = 0;
+		setup();
+		if (Recorder.record) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("IJ.run(imp, \"Apply LUT\", \"stack\");");
+			else
+				Recorder.record("run", "Apply LUT", "stack");
+		}
+	}
+
+	void setThreshold(ImageProcessor ip) {
+		if (!(ip instanceof ByteProcessor))
+			return;
+		if (((ByteProcessor)ip).isInvertedLut())
+			ip.setThreshold(max, 255, ImageProcessor.NO_LUT_UPDATE);
+		else
+			ip.setThreshold(0, max, ImageProcessor.NO_LUT_UPDATE);
+	}
+
+	void autoAdjust(ImagePlus imp, ImageProcessor ip) {
+ 		if (RGBImage)
+			ip.reset();
+		ImageStatistics stats = imp.getRawStatistics();
+		int limit = stats.pixelCount/10;
+		int[] histogram = stats.histogram;
+		if (autoThreshold<10)
+			autoThreshold = AUTO_THRESHOLD;
+		else
+			autoThreshold /= 2;
+		int threshold = stats.pixelCount/autoThreshold;
+		int i = -1;
+		boolean found = false;
+		int count;
+		do {
+			i++;
+			count = histogram[i];
+			if (count>limit) count = 0;
+			found = count> threshold;
+		} while (!found && i<255);
+		int hmin = i;
+		i = 256;
+		do {
+			i--;
+			count = histogram[i];
+			if (count>limit) count = 0;
+			found = count > threshold;
+		} while (!found && i>0);
+		int hmax = i;
+		Roi roi = imp.getRoi();
+		if (hmax>=hmin) {
+			if (RGBImage) imp.deleteRoi();
+			min = stats.histMin+hmin*stats.binSize;
+			max = stats.histMin+hmax*stats.binSize;
+			if (min==max)
+				{min=stats.min; max=stats.max;}
+			setMinAndMax(imp, min, max);
+			if (RGBImage && roi!=null) imp.setRoi(roi);
+		} else {
+			reset(imp, ip);
+			return;
+		}
+		updateScrollBars(null, false);
+		if (Recorder.record) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("IJ.run(imp, \"Enhance Contrast\", \"saturated=0.35\");");
+			else
+				Recorder.record("run", "Enhance Contrast", "saturated=0.35");
+		}
+	}
+
+	void setMinAndMax(ImagePlus imp, ImageProcessor ip) {
+		min = imp.getDisplayRangeMin();
+		max = imp.getDisplayRangeMax();
+		Calibration cal = imp.getCalibration();
+		//int digits = (ip instanceof FloatProcessor)||cal.calibrated()?2:0;
+		double minValue = cal.getCValue(min);
+		double maxValue = cal.getCValue(max);
+		int channels = imp.getNChannels();
+		GenericDialog gd = new GenericDialog("Set Display Range");
+		gd.addNumericField("Minimum displayed value: ", minValue, digits, 7, "");
+		gd.addNumericField("Maximum displayed value: ", maxValue, digits, 7, "");
+		gd.addChoice("Unsigned 16-bit range:", sixteenBitRanges, sixteenBitRanges[get16bitRangeIndex()]);
+		String label = "Propagate to all other ";
+		label = imp.isComposite()?label+channels+" channel images":label+"open images";
+		gd.addCheckbox(label, false);
+		boolean allChannels = false;
+		if (imp.isComposite() && channels>1) {
+			label = "Propagate to the other ";
+			label = channels==2?label+"channel of this image":label+(channels-1)+" channels of this image";
+			gd.addCheckbox(label, allChannels);
+		}
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		minValue = gd.getNextNumber();
+		maxValue = gd.getNextNumber();
+		minValue = cal.getRawValue(minValue);
+		maxValue = cal.getRawValue(maxValue);
+		int rangeIndex = gd.getNextChoiceIndex();
+		int range1 = ImagePlus.getDefault16bitRange();
+		int range2 = set16bitRange(rangeIndex);
+		if (range1!=range2 && imp.getType()==ImagePlus.GRAY16 && !cal.isSigned16Bit()) {
+			reset(imp, ip);
+			minValue = imp.getDisplayRangeMin();
+			maxValue = imp.getDisplayRangeMax();
+		}
+		boolean propagate = gd.getNextBoolean();
+		if (imp.isComposite() && channels>1)
+			allChannels = gd.getNextBoolean();
+		if (maxValue>=minValue) {
+			min = minValue;
+			max = maxValue;
+			setMinAndMax(imp, min, max);
+			updateScrollBars(null, false);
+			if (RGBImage) doMasking(imp, ip);
+			if (allChannels) {
+				int channel = imp.getChannel();
+				for (int c=1; c<=channels; c++) {
+					imp.setPositionWithoutUpdate(c, imp.getSlice(), imp.getFrame());
+					imp.setDisplayRange(min, max);
+					//IJ.log("setDisplayRange: "+c+" "+min+" "+max);
+				}
+				((CompositeImage)imp).reset();
+				imp.setPosition(channel, imp.getSlice(), imp.getFrame());
+			}
+			if (propagate)
+				propagate(imp);
+			if (Recorder.record) {
+				if (imp.getBitDepth()==32)
+					recordSetMinAndMax(min, max);
+				else {
+					int imin = (int)min;
+					int imax = (int)max;
+					if (cal.isSigned16Bit()) {
+						imin = (int)cal.getCValue(imin);
+						imax = (int)cal.getCValue(imax);
+					}
+					recordSetMinAndMax(imin, imax);
+				}
+				if (range2>0) {
+					if (Recorder.scriptMode())
+						Recorder.recordCall("ImagePlus.setDefault16bitRange("+range2+");");
+					else
+						Recorder.recordString("call(\"ij.ImagePlus.setDefault16bitRange\", "+range2+");\n");
+				}
+			}
+		}
+	}
+
+	private void propagate(ImagePlus img) {
+		if (img.getBitDepth()==24) {
+			GenericDialog gd = new GenericDialog("Contrast Adjuster");
+			gd.addMessage( "Propagation of RGB images not supported. As a work-around,\nconvert images to multi-channel composite color.");
+			gd.hideCancelButton();
+			gd.showDialog();
+			return;
+		}
+		int[] list = WindowManager.getIDList();
+		if (list==null) return;
+		int nImages = list.length;
+		if (nImages<=1) return;
+		ImageProcessor ip = img.getProcessor();
+		double min = ip.getMin();
+		double max = ip.getMax();
+		int depth = img.getBitDepth();
+		if (depth==24) return;
+		int id = img.getID();
+		if (img.isComposite()) {
+			int nChannels = img.getNChannels();
+			for (int i=0; i<nImages; i++) {
+				ImagePlus img2 = WindowManager.getImage(list[i]);
+				if (img2==null) continue;
+				int nChannels2 = img2.getNChannels();
+				if (img2.isComposite() && img2.getBitDepth()==depth && img2.getID()!=id
+				&& img2.getNChannels()==nChannels && img2.getWindow()!=null) {
+					int channel = img2.getChannel();
+					for (int c=1; c<=nChannels; c++) {
+						LUT  lut = ((CompositeImage)img).getChannelLut(c);
+						img2.setPosition(c, img2.getSlice(), img2.getFrame());
+						img2.setDisplayRange(lut.min, lut.max);
+						img2.updateAndDraw();
+					}
+					img2.setPosition(channel, img2.getSlice(), img2.getFrame());
+				}
+			}
+		} else {
+			for (int i=0; i<nImages; i++) {
+				ImagePlus img2 = WindowManager.getImage(list[i]);
+				if (img2!=null && img2.getBitDepth()==depth && img2.getID()!=id
+				&& img2.getNChannels()==1 && img2.getWindow()!=null) {
+					ImageProcessor ip2 = img2.getProcessor();
+					ip2.setMinAndMax(min, max);
+					img2.updateAndDraw();
+				}
+			}
+		}
+    }
+
+	public static int get16bitRangeIndex() {
+		int range = ImagePlus.getDefault16bitRange();
+		int index = 0;
+		if (range==8) index = 1;
+		else if (range==10) index = 2;
+		else if (range==12) index = 3;
+		else if (range==14) index = 4;
+		else if (range==15) index = 5;
+		else if (range==16) index = 6;
+		return index;
+	}
+
+	public static int set16bitRange(int index) {
+		int range = 0;
+		if (index==1) range = 8;
+		else if (index==2) range = 10;
+		else if (index==3) range = 12;
+		else if (index==4) range = 14;
+		else if (index==5) range = 15;
+		else if (index==6) range = 16;
+		ImagePlus.setDefault16bitRange(range);
+		return range;
+	}
+
+	public static String[] getSixteenBitRanges() {
+		return sixteenBitRanges;
+	}
+
+	void setWindowLevel(ImagePlus imp, ImageProcessor ip) {
+		min = imp.getDisplayRangeMin();
+		max = imp.getDisplayRangeMax();
+		Calibration cal = imp.getCalibration();
+		int digits = (ip instanceof FloatProcessor)||cal.calibrated()?2:0;
+		double minValue = cal.getCValue(min);
+		double maxValue = cal.getCValue(max);
+		//IJ.log("setWindowLevel: "+min+" "+max);
+		double windowValue = maxValue - minValue;
+		double levelValue = minValue + windowValue/2.0;
+		GenericDialog gd = new GenericDialog("Set W&L");
+		gd.addNumericField("Window Center (Level): ", levelValue, digits);
+		gd.addNumericField("Window Width: ", windowValue, digits);
+		gd.addCheckbox("Propagate to all open images", false);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		levelValue = gd.getNextNumber();
+		windowValue = gd.getNextNumber();
+		minValue = levelValue-(windowValue/2.0);
+		maxValue = levelValue+(windowValue/2.0);
+		minValue = cal.getRawValue(minValue);
+		maxValue = cal.getRawValue(maxValue);
+		boolean propagate = gd.getNextBoolean();
+		if (maxValue>=minValue) {
+			min = minValue;
+			max = maxValue;
+			setMinAndMax(imp, minValue, maxValue);
+			updateScrollBars(null, false);
+			if (RGBImage) doMasking(imp, ip);
+			if (propagate)
+				propagate(imp);
+			if (Recorder.record) {
+				if (imp.getBitDepth()==32)
+					recordSetMinAndMax(min, max);
+				else {
+					int imin = (int)min;
+					int imax = (int)max;
+					if (cal.isSigned16Bit()) {
+						imin = (int)cal.getCValue(imin);
+						imax = (int)cal.getCValue(imax);
+					}
+					recordSetMinAndMax(imin, imax);
+				}
+			}
+		}
+	}
+
+	public static void recordSetMinAndMax(double min, double max) {
+		if ((int)min==min && (int)max==max) {
+			int imin=(int)min, imax = (int)max;
+			if (Recorder.scriptMode())
+				Recorder.recordCall("imp.setDisplayRange("+imin+", "+imax+");");
+			else
+				Recorder.record("setMinAndMax", imin, imax);
+		} else {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("imp.setDisplayRange("+IJ.d2s(min,2)+", "+IJ.d2s(max,2)+");");
+			else
+				Recorder.record("setMinAndMax", IJ.d2s(min,2), IJ.d2s(max,2));
+		}
+	}
+
+	static final int RESET=0, AUTO=1, SET=2, APPLY=3, THRESHOLD=4, MIN=5, MAX=6,
+		BRIGHTNESS=7, CONTRAST=8, UPDATE=9;
+
+	// Separate thread that does the potentially time-consuming processing
+	public void run() {
+		while (!done) {
+			synchronized(this) {
+				try {wait();}
+				catch(InterruptedException e) {}
+			}
+			doUpdate();
+		}
+	}
+
+	void doUpdate() {
+		ImagePlus imp;
+		ImageProcessor ip;
+		int action;
+		int minvalue = minSliderValue;
+		int maxvalue = maxSliderValue;
+		int bvalue = brightnessValue;
+		int cvalue = contrastValue;
+		if (doReset) action = RESET;
+		else if (doAutoAdjust) action = AUTO;
+		else if (doSet) action = SET;
+		else if (doApplyLut) action = APPLY;
+		else if (minSliderValue>=0) action = MIN;
+		else if (maxSliderValue>=0) action = MAX;
+		else if (brightnessValue>=0) action = BRIGHTNESS;
+		else if (contrastValue>=0) action = CONTRAST;
+		else return;
+		minSliderValue = maxSliderValue = brightnessValue = contrastValue = -1;
+		doReset = doAutoAdjust = doSet = doApplyLut = false;
+		imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			IJ.beep();
+			IJ.showStatus("No image");
+			return;
+		} else if (imp.getOverlay()!=null && imp.getOverlay().isCalibrationBar()) {
+			IJ.beep();
+			IJ.showStatus("Has calibration bar");
+			return;
+		}
+		ip = imp.getProcessor();
+		if (RGBImage && !imp.lock())
+			{imp=null; return;}
+		switch (action) {
+			case RESET:
+				reset(imp, ip);
+				if (Recorder.record) {
+						if (Recorder.scriptMode())
+							Recorder.recordCall("IJ.resetMinAndMax(imp);");
+						else
+							Recorder.record("resetMinAndMax");
+				}
+				break;
+			case AUTO: autoAdjust(imp, ip); break;
+			case SET: if (windowLevel) setWindowLevel(imp, ip); else setMinAndMax(imp, ip); break;
+			case APPLY: apply(imp, ip); break;
+			case MIN: adjustMin(imp, ip, minvalue); break;
+			case MAX: adjustMax(imp, ip, maxvalue); break;
+			case BRIGHTNESS: adjustBrightness(imp, ip, bvalue); break;
+			case CONTRAST: adjustContrast(imp, ip, cvalue); break;
+		}
+		updatePlot();
+		updateLabels(imp);
+		if ((IJ.shiftKeyDown()||(balance&&channels==7)) && imp.isComposite())
+			((CompositeImage)imp).updateAllChannelsAndDraw();
+		else
+			imp.updateChannelAndDraw();
+		if (RGBImage)
+			imp.unlock();
+	}
+
+    /** Overrides close() in PlugInDialog. */
+    public void close() {
+    	super.close();
+		instance = null;
+		done = true;
+		Prefs.saveLocation(LOC_KEY, getLocation());
+		synchronized(this) {
+			notify();
+		}
+	}
+
+	public void windowActivated(WindowEvent e) {
+		super.windowActivated(e);
+		Window owin = e.getOppositeWindow();
+		if (owin==null || !(owin instanceof ImageWindow))
+			return;
+		if (IJ.debugMode) IJ.log("windowActivated: "+owin);
+		if (IJ.isMacro()) {
+			// do nothing if macro and RGB image
+			ImagePlus imp2 = WindowManager.getCurrentImage();
+			if (imp2!=null && imp2.getBitDepth()==24) {
+				return;
+			}
+		}
+		previousImageID = 0; // user may have modified image
+		setup();
+		WindowManager.setWindow(this);
+	}
+	
+	public synchronized  void itemStateChanged(ItemEvent e) {
+		int index = choice.getSelectedIndex();
+		channels = channelConstants[index];
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null && imp.isComposite()) {
+			if (index+1<=imp.getNChannels())
+				imp.setPosition(index+1, imp.getSlice(), imp.getFrame());
+			else {
+				choice.select(channelLabels.length-1);
+				channels = 7;
+			}
+		} else {
+			imp.getProcessor().snapshot();
+			doReset = true;
+		}
+		notify();
+	}
+
+    /** Resets this ContrastAdjuster and brings it to the front. */
+    public void updateAndDraw() {
+        previousImageID = 0;
+        toFront();
+    }
+
+    /** Updates the ContrastAdjuster. */
+    public static void update() {
+		if (instance!=null) {
+			instance.previousImageID = 0;
+			instance.setup();
+		}
+    }
+
+} // ContrastAdjuster class
+
+
+class ContrastPlot extends Canvas implements MouseListener {
+
+	static final int WIDTH=128, HEIGHT=64;
+	double defaultMin = 0;
+	double defaultMax = 255;
+	double min = 0;
+	double max = 255;
+	int[] histogram;
+	int hmax;
+	Image os;
+	Graphics osg;
+	Color color = Color.gray;
+	double scale = Prefs.getGuiScale();
+	int width = WIDTH;
+	int height = HEIGHT;
+
+	public ContrastPlot() {
+		addMouseListener(this);
+		if (scale>1.0) {
+			width = (int)(width*scale);
+			height = (int)(height*scale);
+		}
+		setSize(width+1, height+1);
+	}
+
+    /** Overrides Component getPreferredSize(). Added to work
+    	around a bug in Java 1.4.1 on Mac OS X.*/
+    public Dimension getPreferredSize() {
+        return new Dimension(width+1, height+1);
+    }
+
+	void setHistogram(ImageStatistics stats, Color color) {
+		this.color = color;
+		histogram = stats.histogram;
+		if (histogram.length!=256) {
+			histogram=null;
+			return;
+		}
+		int maxCount = 0;
+		int mode = 0;
+		for (int i=0; i<256; i++) {
+			if (histogram[i]>maxCount) {
+				maxCount = histogram[i];
+				mode = i;
+			}
+		}
+		int maxCount2 = 0;
+		for (int i=0; i<256; i++) {
+			if ((histogram[i]>maxCount2) && (i!=mode))
+				maxCount2 = histogram[i];
+		}
+		hmax = stats.maxCount;
+		if ((hmax>(maxCount2*2)) && (maxCount2!=0)) {
+			hmax = (int)(maxCount2*1.5);
+			histogram[mode] = hmax;
+		}
+		os = null;
+	}
+
+	public void update(Graphics g) {
+		paint(g);
+	}
+
+	public void paint(Graphics g) {
+		int x1, y1, x2, y2;
+		double scale = (double)width/(defaultMax-defaultMin);
+		double slope = 0.0;
+		if (max!=min)
+			slope = height/(max-min);
+		if (min>=defaultMin) {
+			x1 = (int)(scale*(min-defaultMin));
+			y1 = height;
+		} else {
+			x1 = 0;
+			if (max>min)
+				y1 = height-(int)((defaultMin-min)*slope);
+			else
+				y1 = height;
+		}
+		if (max<=defaultMax) {
+			x2 = (int)(scale*(max-defaultMin));
+			y2 = 0;
+		} else {
+			x2 = width;
+			if (max>min)
+				y2 = height-(int)((defaultMax-min)*slope);
+			else
+				y2 = 0;
+		}
+		if (histogram!=null) {
+			if (os==null && hmax!=0) {
+				os = createImage(width,height);
+				osg = os.getGraphics();
+				osg.setColor(Color.white);
+				osg.fillRect(0, 0, width, height);
+				osg.setColor(color);
+				double scale2 = width/256.0;
+				for (int i = 0; i < 256; i++) {
+					int x =(int)(i*scale2);
+					osg.drawLine(x, height, x, height - ((int)(height*histogram[i])/hmax));
+				}
+				osg.dispose();
+			}
+			if (os!=null) g.drawImage(os, 0, 0, this);
+		} else {
+			g.setColor(Color.white);
+			g.fillRect(0, 0, width, height);
+		}
+		g.setColor(Color.black);
+ 		g.drawLine(x1, y1, x2, y2);
+ 		g.drawLine(x2, height-5, x2, height);
+ 		g.drawRect(0, 0, width, height);
+     }
+
+	public void mousePressed(MouseEvent e) {}
+	public void mouseReleased(MouseEvent e) {}
+	public void mouseExited(MouseEvent e) {}
+	public void mouseClicked(MouseEvent e) {}
+	public void mouseEntered(MouseEvent e) {}
+
+} // ContrastPlot class
+
+class TrimmedLabel extends Label {
+	int trim = IJ.isMacOSX()?0:6;
+
+    public TrimmedLabel(String title) {
+        super(title);
+    }
+
+    public Dimension getMinimumSize() {
+        return new Dimension(super.getMinimumSize().width, super.getMinimumSize().height-trim);
+    }
+
+    public Dimension getPreferredSize() {
+        return getMinimumSize();
+    }
+
+} // TrimmedLabel class
+
+
diff --git a/src/ij/plugin/frame/Editor.java b/src/ij/plugin/frame/Editor.java
new file mode 100644
index 0000000..e7edf8e
--- /dev/null
+++ b/src/ij/plugin/frame/Editor.java
@@ -0,0 +1,1773 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.util.*;
+import java.awt.datatransfer.*;																																																																																													
+import ij.*;
+import ij.gui.*;
+import ij.util.Tools;
+import ij.text.*;
+import ij.macro.*;
+import ij.plugin.MacroInstaller;
+import ij.plugin.Commands;
+import ij.plugin.Macro_Runner;
+import ij.plugin.JavaScriptEvaluator;
+import ij.io.SaveDialog;
+
+/** This is a simple TextArea based editor for editing and compiling plugins. */
+public class Editor extends PlugInFrame implements ActionListener, ItemListener,
+	TextListener, KeyListener, MouseListener, ClipboardOwner, MacroConstants, Runnable, Debugger {
+	
+	/** ImportPackage statements added in front of scripts. Contains no 
+	newlines so that lines numbers in error messages are not changed. */
+	public static String JavaScriptIncludes =
+		"importPackage(Packages.ij);"+
+		"importPackage(Packages.ij.gui);"+
+		"importPackage(Packages.ij.process);"+
+		"importPackage(Packages.ij.measure);"+
+		"importPackage(Packages.ij.util);"+
+		"importPackage(Packages.ij.macro);"+
+		"importPackage(Packages.ij.plugin);"+
+		"importPackage(Packages.ij.io);"+
+		"importPackage(Packages.ij.plugin.filter);"+
+		"importPackage(Packages.ij.plugin.frame);"+
+		"importPackage(Packages.ij.plugin.tool);"+
+		"importPackage(java.lang);"+
+		"importPackage(java.awt);"+
+		"importPackage(java.awt.image);"+
+		"importPackage(java.awt.geom);"+
+		"importPackage(java.util);"+
+		"importPackage(java.io);"+
+		"function print(s) {IJ.log(s);};";
+		
+	private static String JS_EXAMPLES =
+		"img = IJ.openImage(\"http://imagej.net/images/blobs.gif\")\n"
+ 		+"img = IJ.createImage(\"Untitled\", \"16-bit ramp\", 500, 500, 1)\n" 		
+ 		+"img.show()\n"
+ 		+"ip = img.getProcessor()\n"
+ 		+"ip.getStats()\n"
+ 		+"IJ.setAutoThreshold(img, \"IsoData\")\n"
+ 		+"IJ.run(img, \"Analyze Particles...\", \"show=Overlay display clear\")\n"
+		+"ip.invert()\n"
+ 		+"ip.blurGaussian(5)\n"	 
+ 		+"ip.get(10,10)\n"
+ 		+"ip.set(10,10,222)\n"
+ 		+"(To run, move cursor to end of a line and press 'enter'.\n"
+ 		+"Visible images are automatically updated.)\n";
+
+	public static final int MAX_SIZE=28000, XINC=10, YINC=18;
+	public static final int MONOSPACED=1, MENU_BAR=2, RUN_BAR=4, INSTALL_BUTTON=8;
+	public static final int MACROS_MENU_ITEMS = 15;
+	public static final String INTERACTIVE_NAME = "Interactive Interpreter";
+	static final String FONT_SIZE = "editor.font.size";
+	static final String FONT_MONO= "editor.font.mono";
+	static final String CASE_SENSITIVE= "editor.case-sensitive";
+	static final String DEFAULT_DIR= "editor.dir";
+	static final String INSERT_SPACES= "editor.spaces";
+	static final String TAB_INC= "editor.tab-inc";
+	private final static int MACRO=0, JAVASCRIPT=1, BEANSHELL=2, PYTHON=3;
+	private final static String[] languages = {"Macro", "JavaScript", "BeanShell", "Python"};
+	private final static String[] extensions = {".ijm", ".js", ".bsh", ".py"};	
+	public static Editor currentMacroEditor;
+	private TextArea ta;
+	private String path;
+	protected boolean changes;
+	private static String searchString = "";
+	private static boolean caseSensitive = Prefs.get(CASE_SENSITIVE, true);
+	private static int lineNumber = 1;
+	private static int xoffset, yoffset;
+	private static int nWindows;
+	private Menu fileMenu, editMenu;
+	private Properties p = new Properties();
+	private int[] macroStarts;
+	private String[] macroNames;
+	private MenuBar mb;
+	private Menu macrosMenu;
+	private int nMacros;
+	private Program pgm;
+	private int eventCount;
+	private String shortcutsInUse;
+	private int inUseCount;
+	private MacroInstaller installer;
+	private static String defaultDir = Prefs.get(DEFAULT_DIR, null);;
+	private boolean dontShowWindow;
+	private int[] sizes = {9, 10, 11, 12, 13, 14, 16, 18, 20, 24, 36, 48, 60, 72};
+	private int fontSizeIndex = (int)Prefs.get(FONT_SIZE, 6); // defaults to 16-point
+	private CheckboxMenuItem monospaced;
+	private static boolean wholeWords;
+	private boolean isMacroWindow;
+	private int debugStart, debugEnd;
+	private static TextWindow debugWindow;
+	private boolean step;
+	private int previousLine;
+	private static Editor instance;
+	private int runToLine;
+	private String downloadUrl;
+	private boolean downloading;
+	private FunctionFinder functionFinder;
+	private ArrayList undoBuffer = new ArrayList();
+	private boolean performingUndo;
+	private boolean checkForCurlyQuotes;
+	private static int tabInc = (int)Prefs.get(TAB_INC, 3);
+	private static boolean insertSpaces = Prefs.get(INSERT_SPACES, false);
+	private CheckboxMenuItem insertSpacesItem;
+	private boolean interactiveMode;
+	private Interpreter interpreter;
+	private JavaScriptEvaluator evaluator;
+	private int messageCount;
+	private String rejectMacrosMsg;
+	private Button runButton, installButton;
+	private Choice language;
+	
+	public Editor() {
+		this(24, 80, 0, MENU_BAR);
+	}
+
+	public Editor(String name) {
+		this(24, 80, 0, getOptions(name));
+	}
+
+	public Editor(int rows, int columns, int fontSize, int options) {
+		super("Editor");
+		WindowManager.addWindow(this);
+		addMenuBar(options);	
+		if ((options&RUN_BAR)!=0) {
+			Panel panel = new Panel(new FlowLayout(FlowLayout.LEFT, 0, 0));
+			runButton = new Button("Run");
+			runButton.addActionListener(this);
+			panel.setFont(new Font("SansSerif", Font.PLAIN, sizes[fontSizeIndex]));
+			panel.add(runButton);			
+			if ((options&INSTALL_BUTTON)!=0) {
+				installButton = new Button("Install");
+				installButton.addActionListener(this);
+				panel.add(installButton);
+			}			
+			language = new Choice();
+			for (int i=0; i<languages.length; i++)
+				language.addItem(languages[i]);
+			language.addItemListener(this);
+			panel.add(language);
+			add("North", panel);
+		}
+		ta = new TextArea(rows, columns);
+		ta.addTextListener(this);
+		ta.addKeyListener(this);
+		if (IJ.isLinux()) ta.setBackground(Color.white);
+ 		addKeyListener(IJ.getInstance());  // ImageJ handles keyboard shortcuts
+		ta.addMouseListener(this);  // ImageJ handles keyboard shortcuts
+		add(ta);
+		pack();
+		setFont();
+		positionWindow();
+		if (!IJ.isJava18() && !IJ.isLinux())
+			insertSpaces = false;
+	}
+	
+	private static int getOptions(String name) {
+		int options = MENU_BAR;
+		if (name==null)
+			return options;
+		if (name.endsWith(".ijm") || name.endsWith(".js") || name.endsWith(".bsh") || name.endsWith(".py"))
+			options |= RUN_BAR;
+		if (name.endsWith(".ijm"))
+			options |= INSTALL_BUTTON;
+		return options;
+	}
+	
+	void addMenuBar(int options) {
+		mb = new MenuBar();
+		if (Menus.getFontSize()!=0) ;
+			mb.setFont(Menus.getFont());
+		Menu m = new Menu("File");
+		m.add(new MenuItem("New...", new MenuShortcut(KeyEvent.VK_N, true)));
+		m.add(new MenuItem("Open...", new MenuShortcut(KeyEvent.VK_O)));
+		m.add(new MenuItem("Save", new MenuShortcut(KeyEvent.VK_S)));
+		m.add(new MenuItem("Save As..."));
+		m.add(new MenuItem("Revert"));
+		m.add(new MenuItem("Print..."));
+		m.addActionListener(this);
+		fileMenu = m;
+		mb.add(m);
+		
+		m = new Menu("Edit");
+		MenuItem item = null;
+		if (IJ.isWindows())
+			item = new MenuItem("Undo  Ctrl+Z");
+		else
+			item = new MenuItem("Undo",new MenuShortcut(KeyEvent.VK_Z));		
+		m.add(item);
+		m.addSeparator();		
+		if (IJ.isWindows())
+			item = new MenuItem("Cut  Ctrl+X");
+		else
+			item = new MenuItem("Cut",new MenuShortcut(KeyEvent.VK_X));
+		m.add(item);
+		if (IJ.isWindows())
+			item = new MenuItem("Copy  Ctrl+C");
+		else
+			item = new MenuItem("Copy", new MenuShortcut(KeyEvent.VK_C));
+		m.add(item);
+		if (IJ.isWindows())
+			item = new MenuItem("Paste  Ctrl+V");
+		else
+			item = new MenuItem("Paste",new MenuShortcut(KeyEvent.VK_V));
+		m.add(item);
+		m.addSeparator();
+		m.add(new MenuItem("Find...", new MenuShortcut(KeyEvent.VK_F)));
+		m.add(new MenuItem("Find Next", new MenuShortcut(KeyEvent.VK_G)));
+		m.add(new MenuItem("Go to Line...", new MenuShortcut(KeyEvent.VK_L)));
+		m.addSeparator();
+		m.add(new MenuItem("Select All", new MenuShortcut(KeyEvent.VK_A)));
+		m.add(new MenuItem("Balance", new MenuShortcut(KeyEvent.VK_B,false)));
+		m.add(new MenuItem("Detab..."));
+		insertSpacesItem = new CheckboxMenuItem("Tab Key Inserts Spaces");
+		insertSpacesItem.addItemListener(this);
+		insertSpacesItem.setState(insertSpaces);
+		m.add(insertSpacesItem);
+		m.add(new MenuItem("Zap Gremlins"));
+		m.add(new MenuItem("Copy to Image Info"));
+		m.addActionListener(this);
+		mb.add(m);
+		editMenu = m;
+		if ((options&MENU_BAR)!=0)
+			setMenuBar(mb);
+		
+		m = new Menu("Font");
+		m.add(new MenuItem("Make Text Smaller"));
+		m.add(new MenuItem("Make Text Larger"));
+		m.addSeparator();
+		monospaced = new CheckboxMenuItem("Monospaced Font", Prefs.get(FONT_MONO, false));
+		if ((options&MONOSPACED)!=0) monospaced.setState(true);
+		monospaced.addItemListener(this);
+		m.add(monospaced);
+		m.add(new MenuItem("Save Settings"));
+		m.addActionListener(this);
+		mb.add(m);
+		
+		m = Menus.getExamplesMenu(this);
+		mb.add(m);
+	}			
+			
+	public void positionWindow() {
+		Dimension screen = IJ.getScreenSize();
+		Dimension window = getSize();
+		if (window.width==0)
+			return;
+		int left = screen.width/2-window.width/2;
+		int top = screen.height/(IJ.isWindows()?6:5);
+		if (IJ.isMacOSX())
+			top = (screen.height-window.height)/4;
+		if (top<0) top = 0;
+		if (nWindows<=0 || xoffset>8*XINC)
+			{xoffset=0; yoffset=0;}
+		setLocation(left+xoffset, top+yoffset);
+		xoffset+=XINC; yoffset+=YINC;
+		nWindows++;
+	}
+
+	void setWindowTitle(String title) {
+		Menus.updateWindowMenuItem(getTitle(), title);
+		setTitle(title);
+	}
+	
+	public void create(String name, String text) {
+		ta.append(text);
+		if (IJ.isMacOSX()) IJ.wait(25); // needed to get setCaretPosition() on OS X
+		ta.setCaretPosition(0);
+		setWindowTitle(name);
+		boolean macroExtension = name.endsWith(".txt") || name.endsWith(".ijm");
+		if (macroExtension || name.endsWith(".js") || name.endsWith(".bsh") || name.endsWith(".py") || name.indexOf(".")==-1) {
+			macrosMenu = new Menu("Macros");			
+			macrosMenu.add(new MenuItem("Run Macro", new MenuShortcut(KeyEvent.VK_R)));
+			macrosMenu.add(new MenuItem("Evaluate Line", new MenuShortcut(KeyEvent.VK_Y)));
+			macrosMenu.add(new MenuItem("Abort Macro"));
+			macrosMenu.add(new MenuItem("Install Macros", new MenuShortcut(KeyEvent.VK_I)));
+			macrosMenu.add(new MenuItem("Macro Functions...", new MenuShortcut(KeyEvent.VK_M, true)));
+			macrosMenu.add(new MenuItem("Function Finder...", new MenuShortcut(KeyEvent.VK_F, true)));
+			macrosMenu.add(new MenuItem("Enter Interactive Mode"));
+			macrosMenu.add(new MenuItem("Assign to Repeat Cmd",new MenuShortcut(KeyEvent.VK_A, true)));
+			macrosMenu.addSeparator();
+			macrosMenu.add(new MenuItem("Evaluate Macro"));
+			macrosMenu.add(new MenuItem("Evaluate JavaScript", new MenuShortcut(KeyEvent.VK_J, false)));
+			macrosMenu.add(new MenuItem("Evaluate BeanShell", new MenuShortcut(KeyEvent.VK_B, true)));
+			macrosMenu.add(new MenuItem("Evaluate Python", new MenuShortcut(KeyEvent.VK_P, false)));
+			macrosMenu.add(new MenuItem("Show Log Window", new MenuShortcut(KeyEvent.VK_L, true)));
+			macrosMenu.addSeparator();
+			// MACROS_MENU_ITEMS must be updated if items are added to this menu
+			macrosMenu.addActionListener(this);
+			mb.add(macrosMenu);
+			if (!(name.endsWith(".js")||name.endsWith(".bsh")||name.endsWith(".py"))) {
+				Menu debugMenu = new Menu("Debug");			
+				debugMenu.add(new MenuItem("Debug Macro", new MenuShortcut(KeyEvent.VK_D)));
+				debugMenu.add(new MenuItem("Step", new MenuShortcut(KeyEvent.VK_E)));
+				debugMenu.add(new MenuItem("Trace", new MenuShortcut(KeyEvent.VK_T)));
+				debugMenu.add(new MenuItem("Fast Trace", new MenuShortcut(KeyEvent.VK_T,true)));
+				debugMenu.add(new MenuItem("Run"));
+				debugMenu.add(new MenuItem("Run to Insertion Point", new MenuShortcut(KeyEvent.VK_E, true)));
+				debugMenu.add(new MenuItem("Abort"));
+				debugMenu.addActionListener(this);
+				mb.add(debugMenu);
+			}
+		} else {
+			fileMenu.addSeparator();
+			fileMenu.add(new MenuItem("Compile and Run", new MenuShortcut(KeyEvent.VK_R)));
+		}
+		if (language!=null) {
+			for (int i=0; i<languages.length; i++) {
+				if (name.endsWith(extensions[i])) {
+					language.select(languages[i]);
+					break;
+				}
+			}		
+		}
+		if (text.startsWith("//@AutoInstall") && (name.endsWith(".ijm")||name.endsWith(".txt"))) {
+			boolean installInPluginsMenu = !name.contains("Tool.");
+			installMacros(text, installInPluginsMenu);
+			if ( text.startsWith("//@AutoInstallAndHide"))
+				dontShowWindow = true;		
+		}
+		if (IJ.getInstance()!=null && !dontShowWindow)
+			show();
+		if (dontShowWindow) {
+			dispose();
+			dontShowWindow = false;
+		}
+		if (name.equals(INTERACTIVE_NAME)) {
+			enterInteractiveMode();
+			String txt = ta.getText();
+			ta.setCaretPosition(txt.length());
+		}
+		WindowManager.setWindow(this);
+		checkForCurlyQuotes = true;
+		changes = false;
+	}
+
+	public void createMacro(String name, String text) {
+		create(name, text);
+	}
+	public void setRejectMacrosMsg(String msg ) {
+		rejectMacrosMsg = msg;
+	}
+	public String getRejectMacrosMsg() {
+		return rejectMacrosMsg;
+	}
+	
+	void installMacros(String text, boolean installInPluginsMenu) {
+		if (rejectMacrosMsg != null){
+			if (rejectMacrosMsg.length()> 0)
+					IJ.showMessage("", rejectMacrosMsg);
+			return;
+		}
+		String functions = Interpreter.getAdditionalFunctions();
+		if (functions!=null && text!=null) {
+			if (!(text.endsWith("\n") || functions.startsWith("\n")))
+				text = text + "\n" + functions;
+			else
+				text = text + functions;
+		}
+		installer = new MacroInstaller();
+		installer.setFileName(getTitle());
+		int nShortcuts = installer.install(text, macrosMenu);
+		if (installInPluginsMenu || nShortcuts>0)
+			installer.install(null);
+		dontShowWindow = installer.isAutoRunAndHide();
+		currentMacroEditor = this;
+	}
+		
+	/** Opens a file and replaces the text (if any) by the contents of the file. */
+	public void open(String dir, String name) {
+		path = dir+name;
+		File file = new File(path);
+		if (!file.exists()) {
+			IJ.error("File not found: "+path);
+			return;
+		}
+		try {
+			StringBuffer sb = new StringBuffer(5000);
+			BufferedReader r = new BufferedReader(new FileReader(file));
+			while (true) {
+				String s=r.readLine();
+				if (s==null)
+					break;
+				else
+					sb.append(s+"\n");
+			}
+			r.close();
+			if (ta!=null && ta.getText().length()>0) {
+				ta.setText("");  //delete previous contents (if any)
+				eventCount = 0;
+			}
+			create(name, new String(sb));
+			changes = false;
+		}
+		catch (Exception e) {
+			IJ.handleException(e);
+			return;
+		}
+	}
+
+	public String getText() {
+		if (ta==null)
+			return "";
+		else
+			return ta.getText();
+	}
+
+	public TextArea getTextArea() {
+		return ta;
+	}
+
+	public void display(String title, String text) {
+		ta.selectAll();
+		ta.replaceRange(text, ta.getSelectionStart(), ta.getSelectionEnd());
+		ta.setCaretPosition(0);
+		setWindowTitle(title);
+		changes = false;
+		if (IJ.getInstance()!=null)
+			show();
+		WindowManager.setWindow(this);
+	}
+
+	void save() {
+		if (path==null) {
+			saveAs(); 
+			return;
+		}
+		File f = new File(path);
+		if (f.exists() && !f.canWrite()) {
+			IJ.showMessage("Editor", "Unable to save because file is write-protected. \n \n" + path);
+			return;
+		}
+		String text = ta.getText();
+		char[] chars = new char[text.length()];
+		text.getChars(0, text.length(), chars, 0);
+		try {
+			BufferedReader br = new BufferedReader(new CharArrayReader(chars));
+			BufferedWriter bw = new BufferedWriter(new FileWriter(path));
+			while (true) {
+				String s = br.readLine();
+				if (s==null) break;
+				bw.write(s, 0, s.length());
+				bw.newLine();
+			}
+			bw.close();
+			IJ.showStatus(text.length()+" chars saved to " + path);
+			changes = false;
+		} catch
+			(IOException e) {}
+	}
+
+	void compileAndRun() {
+		if (path==null)
+			saveAs();
+		if (path!=null) {
+			save();
+			String text = ta.getText();
+			if (text.contains("implements PlugInFilter") && text.contains("IJ.run("))
+				IJ.log("<<Plugins that call IJ.run() should probably implement PlugIn, not PlugInFilter.>>");
+			IJ.runPlugIn("ij.plugin.Compiler", path);
+		}
+	}
+	
+	final void runMacro(boolean debug) {
+		if (path!=null)
+			Macro_Runner.setFilePath(path);
+		if (getTitle().endsWith(".js"))
+			{evaluateJavaScript(); return;}
+		else if (getTitle().endsWith(".bsh"))
+			{evaluateScript(".bsh"); return;}
+		else if (getTitle().endsWith(".py"))
+			{evaluateScript(".py"); return;}
+		int start = ta.getSelectionStart();
+		int end = ta.getSelectionEnd();
+		String text;
+		if (start==end)
+			text = ta.getText();
+		else
+			text = ta.getSelectedText();
+		Interpreter.abort();  // abort any currently running macro
+		if (checkForCurlyQuotes && text.contains("\u201D")) {
+			// replace curly quotes with standard quotes
+ 			text = text.replaceAll("\u201C", "\""); 
+			text = text.replaceAll("\u201D", "\"");
+			if (start==end)
+				ta.setText(text);
+			else {
+				String text2 = ta.getText();
+ 				text2 = text2.replaceAll("\u201C", "\""); 
+				text2 = text2.replaceAll("\u201D", "\"");
+				ta.setText(text2);
+			}
+			changes = true;
+			checkForCurlyQuotes = false;
+		}
+		currentMacroEditor = this;
+		new MacroRunner(text, debug?this:null);
+	}
+	
+	void evaluateMacro() {
+		String title = getTitle();
+		if (title.endsWith(".js")||title.endsWith(".bsh")||title.endsWith(".py"))
+			setWindowTitle(title.substring(0,title.length()-3)+".ijm");
+		runMacro(false);
+	}
+
+	void evaluateJavaScript() {
+		if (!getTitle().endsWith(".js"))
+			setWindowTitle(SaveDialog.setExtension(getTitle(), ".js"));
+		int start = ta.getSelectionStart();
+		int end = ta.getSelectionEnd();
+		String text;
+		if (start==end)
+			text = ta.getText();
+		else
+			text = ta.getSelectedText();
+		if (text.equals(""))
+			return;
+		boolean strictMode = false;
+		if (IJ.isJava18()) {
+			// text.matches("^( |\t)*(\"use strict\"|'use strict')");
+			String text40 = text.substring(0,Math.min(40,text.length()));
+			strictMode =  text40.contains("'use strict'") || text40.contains("\"use strict\"");
+		}
+		text = getJSPrefix("") + text;
+		if (IJ.isJava18()) {
+			text = "load(\"nashorn:mozilla_compat.js\");" + text;
+			if (strictMode)
+				text = "'use strict';" + text;
+		}
+		if (!(IJ.isMacOSX()&&!IJ.is64Bit())) {
+			// Use JavaScript engine built into Java 6 and later.
+			IJ.runPlugIn("ij.plugin.JavaScriptEvaluator", text);
+		} else {
+			Object js = IJ.runPlugIn("JavaScript", text);
+			if (js==null)
+				download("/download/tools/JavaScript.jar");
+		}
+	}
+
+	public void evaluateScript(String ext) {
+		if (downloading) {
+			IJ.beep();
+			IJ.showStatus("Download in progress");
+			return;
+		}
+		if (ext.endsWith(".js")) {
+			evaluateJavaScript();
+			return;
+		}
+		if (!getTitle().endsWith(ext))
+			setWindowTitle(SaveDialog.setExtension(getTitle(), ext));
+		int start = ta.getSelectionStart();
+		int end = ta.getSelectionEnd();
+		String text;
+		if (start==end)
+			text = ta.getText();
+		else
+			text = ta.getSelectedText();
+		if (text.equals("")) return;
+		String plugin, url;
+		if (ext.equals(".bsh")) {
+			plugin = "bsh";
+			url = "/plugins/bsh/BeanShell.jar";
+		} else {
+			// download Jython from http://imagej.nih.gov/ij/plugins/jython/
+			plugin = "Jython";
+			url = "/plugins/jython/Jython.jar";
+		}
+		Object obj = IJ.runPlugIn(plugin, text);
+		if (obj==null)
+			download(url);
+	}
+	
+	private void download(String url) {
+		this.downloadUrl = url;
+		Thread thread = new Thread(this, "Downloader");
+		thread.setPriority(Math.max(thread.getPriority()-2, Thread.MIN_PRIORITY));
+		thread.start();
+	}
+
+	void evaluateLine() {
+		int start = ta.getSelectionStart();
+		int end = ta.getSelectionEnd();
+		if (end>start)
+			{runMacro(false); return;}
+		String text = ta.getText();
+		while (start>0) {
+			start--;
+			if (text.charAt(start)=='\n')
+				{start++; break;}
+		}
+		while (end<text.length()-1) {
+			end++;
+			if (text.charAt(end)=='\n')
+				break;
+		}
+		ta.setSelectionStart(start);
+		ta.setSelectionEnd(end);
+		runMacro(false);
+	}
+
+	void print () {
+		PrintJob pjob = Toolkit.getDefaultToolkit().getPrintJob(this, "Cool Stuff", p);
+		if (pjob != null) {
+			Graphics pg = pjob.getGraphics( );
+			if (pg != null) {
+				String s = ta.getText();
+				printString(pjob, pg, s);
+				pg.dispose( );	
+			}
+			pjob.end( );
+		}
+	}
+
+	void printString (PrintJob pjob, Graphics pg, String s) {
+		int pageNum = 1;
+		int linesForThisPage = 0;
+		int linesForThisJob = 0;
+		int topMargin = 30;
+		int leftMargin = 30;
+		int bottomMargin = 30;
+		
+		if (!(pg instanceof PrintGraphics))
+			throw new IllegalArgumentException ("Graphics contextt not PrintGraphics");
+		if (IJ.isMacintosh()) {
+			topMargin = 0;
+			leftMargin = 0;
+			bottomMargin = 0;
+		}
+		StringReader sr = new StringReader (s);
+		LineNumberReader lnr = new LineNumberReader (sr);
+		String nextLine;
+		int pageHeight = pjob.getPageDimension().height - bottomMargin;
+		Font helv = new Font(getFontName(), Font.PLAIN, 10);
+		pg.setFont (helv);
+		FontMetrics fm = pg.getFontMetrics(helv);
+		int fontHeight = fm.getHeight();
+		int fontDescent = fm.getDescent();
+		int curHeight = topMargin;
+		try {
+			do {
+				nextLine = lnr.readLine();
+			   if (nextLine != null) {		   
+					nextLine = detabLine(nextLine);
+					if ((curHeight + fontHeight) > pageHeight) {
+						// New Page
+						pageNum++;
+						linesForThisPage = 0;
+						pg.dispose();
+						pg = pjob.getGraphics();
+						if (pg != null)
+							pg.setFont (helv);
+						curHeight = topMargin;
+					}
+					curHeight += fontHeight;
+					if (pg != null) {
+						pg.drawString (nextLine, leftMargin, curHeight - fontDescent);
+						linesForThisPage++;
+						linesForThisJob++;
+					} 
+				}
+			} while (nextLine != null);
+		} catch (EOFException eof) {
+	   // Fine, ignore
+		} catch (Throwable t) { // Anything else
+			IJ.handleException(t);
+		}
+	}
+	
+	String detabLine(String s) {
+		if (s.indexOf('\t')<0)
+			return s;
+		int tabSize = 4;
+		StringBuffer sb = new StringBuffer((int)(s.length()*1.25));
+		char c;
+		for (int i=0; i<s.length(); i++) {
+			c = s.charAt(i);
+			if (c=='\t') {
+				  for (int j=0; j<tabSize; j++)
+					  sb.append(' '); 
+		} else
+			sb.append(c);
+		 }
+		return sb.toString();
+	}	   
+
+	void undo() {
+		if (IJ.isWindows()) {
+			IJ.showMessage("Editor", "Press Ctrl-Z to undo");
+			return;
+		}
+		if (IJ.debugMode) IJ.log("Undo1: "+undoBuffer.size());
+		int position = ta.getCaretPosition();
+		if (undoBuffer.size()>1) {
+			undoBuffer.remove(undoBuffer.size()-1);
+			String text = (String)undoBuffer.get(undoBuffer.size()-1);
+			performingUndo = true;
+			ta.setText(text);
+			if (position<=text.length())
+				ta.setCaretPosition(position-offset(position));
+			if (IJ.debugMode) IJ.log("Undo2: "+undoBuffer.size()+" "+text);
+		}
+	}
+	
+	boolean copy() { 
+		String s; 
+		s = ta.getSelectedText();
+		Clipboard clip = getToolkit().getSystemClipboard();
+		if (clip!=null) {
+			StringSelection cont = new StringSelection(s);
+			clip.setContents(cont,this);
+			return true;
+		} else
+			return false;
+	}
+	  
+	void cut() {
+		if (copy()) {
+			int start = ta.getSelectionStart();
+			int end = ta.getSelectionEnd();
+			ta.replaceRange("", start-offset(start), end-offset(end-2>=start?end-2:start));
+			if (IJ.isMacOSX())
+				ta.setCaretPosition(start);
+		}	
+	}
+	
+	private void assignToRepeatCommand() {
+		String title = getTitle();
+		if (!(title.endsWith(".ijm")||title.endsWith(".txt")||!title.contains("."))) {
+			IJ.error("Assign to Repeat Command", "One or more lines of macro code required.");
+			return;
+		}
+		int start = ta.getSelectionStart();
+		int end = ta.getSelectionEnd();
+		String text;
+		if (start==end)
+			text = ta.getText();
+		else
+			text = ta.getSelectedText();
+		Executer.setAsRepeatCommand(text);
+	}
+
+	void paste() {
+		String s;
+		s = ta.getSelectedText();
+		Clipboard clipboard = getToolkit( ). getSystemClipboard(); 
+		Transferable clipData = clipboard.getContents(s);
+		try {
+			s = (String)(clipData.getTransferData(DataFlavor.stringFlavor));
+		} catch  (Exception e)  {
+			s  = e.toString( );
+		}
+		int start = ta.getSelectionStart( );
+		int end = ta.getSelectionEnd( );
+		ta.replaceRange(s, start-offset(start), end-offset(end-2>=start?end-2:start));
+		if (IJ.isMacOSX())
+			ta.setCaretPosition(start+s.length());
+		checkForCurlyQuotes = true;
+	}
+	
+	// workaround for TextArea.getCaretPosition() bug on Windows
+	private int offset(int pos) {
+		if (!IJ.isWindows())
+			return 0;
+		String text = ta.getText();
+		int rcount = 0;
+		for (int i=0; i<=pos; i++) {
+			if (text.charAt(i)=='\r')
+				rcount++;
+		}
+		if (IJ.debugMode) IJ.log("offset: "+pos+" "+rcount);
+		return pos-rcount>=0?rcount:0;
+	}
+
+	void copyToInfo() { 
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			IJ.noImage();
+			return;
+		}
+		int start = ta.getSelectionStart();
+		int end = ta.getSelectionEnd();
+		String text;
+		if (start==end)
+			text = ta.getText();
+		else
+			text = ta.getSelectedText();
+		imp.setProperty("Info", text);
+	}
+	
+	public void actionPerformed(ActionEvent e) {
+		String what = e.getActionCommand();
+		int flags = e.getModifiers();
+		boolean altKeyDown = (flags & Event.ALT_MASK)!=0;
+		if (e.getSource()==runButton) {
+			runMacro(false);
+			return;
+		} else if (e.getSource()==installButton) {
+			String text = ta.getText();
+			if (text.contains("macro \"") || text.contains("macro\""))
+				installMacros(text, true);
+			else
+				IJ.error("Editor", "File must contain at least one macro or macro tool.");
+			return;
+		} 
+		if ("Save".equals(what))
+			save();
+		else if ("Compile and Run".equals(what))
+				compileAndRun();
+		else if ("Run Macro".equals(what)) {
+			if (altKeyDown) {
+				enableDebugging();
+				runMacro(true);
+			} else
+				runMacro(false);
+		} else if ("Debug Macro".equals(what)) {
+				enableDebugging();
+				runMacro(true);
+		} else if ("Step".equals(what))
+			setDebugMode(STEP);
+		else if ("Trace".equals(what))
+			setDebugMode(TRACE);
+		else if ("Fast Trace".equals(what))
+			setDebugMode(FAST_TRACE);
+		else if ("Run".equals(what))
+			setDebugMode(RUN_TO_COMPLETION);
+		else if ("Run to Insertion Point".equals(what))
+			runToInsertionPoint();
+		else if ("Abort".equals(what) || "Abort Macro".equals(what)) {
+			Interpreter.abort();
+			IJ.beep();		
+		} else if ("Evaluate Line".equals(what))
+			evaluateLine();
+		else if ("Install Macros".equals(what))
+			installMacros(ta.getText(), true);
+		else if ("Macro Functions...".equals(what))
+			showMacroFunctions();
+		else if ("Function Finder...".equals(what))
+			functionFinder = new FunctionFinder(this);
+		else if ("Evaluate Macro".equals(what))
+			evaluateMacro();
+		else if ("Evaluate JavaScript".equals(what))
+			evaluateJavaScript();
+		else if ("Evaluate BeanShell".equals(what))
+			evaluateScript(".bsh");
+		else if ("Evaluate Python".equals(what))
+			evaluateScript(".py");
+		else if ("Show Log Window".equals(what))
+			showLogWindow();
+		else if ("Revert".equals(what))
+			revert();
+		else if ("Print...".equals(what))
+			print();
+		else if (what.startsWith("Undo"))
+		   undo();
+		else if (what.startsWith("Paste"))
+			paste();
+		else if (what.equals("Copy to Image Info"))
+			copyToInfo();
+		else if (what.startsWith("Copy"))
+			copy();
+		else if (what.startsWith("Cut"))
+		   cut();
+		else if ("Save As...".equals(what))
+			saveAs();
+		else if ("Select All".equals(what))
+			selectAll();
+		else if ("Find...".equals(what))
+			find(null);
+		else if ("Find Next".equals(what))
+			find(searchString);
+		else if ("Go to Line...".equals(what))
+			gotoLine();
+		else if ("Balance".equals(what))
+			balance();
+		else if ("Detab...".equals(what))
+			detab();
+		else if ("Zap Gremlins".equals(what))
+			zapGremlins();
+		else if ("Make Text Larger".equals(what))
+			changeFontSize(true);
+		else if ("Make Text Smaller".equals(what))
+			changeFontSize(false);
+		else if ("Save Settings".equals(what))
+			saveSettings();
+		else if ("New...".equals(what))
+			IJ.run("Text Window");
+		else if ("Open...".equals(what))
+			IJ.open();
+		else if (what.equals("Enter Interactive Mode"))
+			enterInteractiveMode();
+		else if (what.equals("Assign to Repeat Cmd"))
+			assignToRepeatCommand();
+		else if (what.endsWith(".ijm") || what.endsWith(".java") || what.endsWith(".js") || what.endsWith(".bsh") || what.endsWith(".py"))
+			openExample(what);
+		else {
+			if (altKeyDown) {
+				enableDebugging();
+				installer.runMacro(what, this);
+			} else
+				installer.runMacro(what, null);
+		}
+	}
+	
+	/** Opens an example from the Help/Examples menu
+		and runs if "Autorun Exampes" is checked. */
+	public static boolean openExample(String name) {
+		boolean isJava = name.endsWith(".java");
+		boolean isJavaScript = name.endsWith(".js");
+		boolean isBeanShell = name.endsWith(".bsh");
+		boolean isPython = name.endsWith(".py");
+		boolean isMacro = name.endsWith(".ijm");
+		if (!(isMacro||isJava||isJavaScript||isBeanShell||isPython))
+			return false;
+		boolean run = !isJava && !name.contains("_Tool") && Prefs.autoRunExamples;
+		int rows = 24;
+		int columns = 70;
+		int options = MENU_BAR + RUN_BAR;
+		if (isMacro)
+			options += INSTALL_BUTTON;
+		String text = null;
+		Editor ed = new Editor(rows, columns, 0, options);
+		String dir = "Macro/";
+		if (isJava)
+			dir = "Java/";
+		else if (isJavaScript)
+			dir = "JavaScript/";
+		else if (isBeanShell)
+			dir = "BeanShell/";
+		else if (isPython)
+			dir = "Python/";
+		String url = "http://wsr.imagej.net/download/Examples/"+dir+name;
+		text = IJ.openUrlAsString(url);
+		if (text.startsWith("<Error: ")) {
+			IJ.error("Open Example", text);
+			return true;
+		}
+		ed.create(name, text);
+		if (run)
+			ed.runMacro(false);
+		return true;
+	}
+	
+	protected void showMacroFunctions() {
+		String url= "/developer/macro/functions.html";
+		String selText = ta.getSelectedText().replace("\n", " ");
+		String[] selectedWords = Tools.split(selText, "/,(,[\"\'&+");
+		if (selectedWords.length==1 && selectedWords[0].length()>0) 
+			url += "#" +selectedWords[0];//append selection as hash tag
+		IJ.runPlugIn("ij.plugin.BrowserLauncher", IJ.URL+url);
+	}
+
+	final void runToInsertionPoint() {
+		Interpreter interp = Interpreter.getInstance();
+		if (interp==null)
+			IJ.beep();
+		else {
+			runToLine = getCurrentLine();
+			setDebugMode(RUN_TO_CARET);
+		}
+	}
+		
+	final int getCurrentLine() {
+		int pos = ta.getCaretPosition();
+		int currentLine = 0;
+		String text = ta.getText();
+		if (IJ.isWindows())
+			text = text.replaceAll("\r\n", "\n");
+		char[] chars = new char[text.length()];
+		chars = text.toCharArray();
+		int count=0;
+		int start=0, end=0;
+		int len = chars.length;
+		for (int i=0; i<len; i++) {
+			if (chars[i]=='\n') {
+				count++;
+				start = end;
+				end = i;
+				if (pos>=start && pos<end) {
+					currentLine = count;
+					break;
+				}
+			}
+		}
+		if (currentLine==0 && pos>end)
+			currentLine = count;
+		return currentLine;
+	}
+
+	final void enableDebugging() {
+			step = true;
+			int start = ta.getSelectionStart();
+			int end = ta.getSelectionEnd();
+			if (start==debugStart && end==debugEnd)
+				ta.select(start, start);
+	}
+	
+	final void setDebugMode(int mode) {
+		step = true;
+		Interpreter interp = Interpreter.getInstance();
+		if (interp!=null) {
+			if (interp.getDebugger()==null)
+				fixLineEndings();
+			interp.setDebugger(this);
+			interp.setDebugMode(mode);
+		}
+	}
+
+	public void textValueChanged(TextEvent e) {
+		String text = ta.getText();
+		//if (undo2==null || text.length()!=undo2.length()+1 || text.charAt(text.length()-1)=='\n')
+		int length = 0;
+		if (!performingUndo) {
+			for (int i=0; i<undoBuffer.size(); i++)
+				length += ((String)undoBuffer.get(i)).length();
+			if (length<2000000)
+				undoBuffer.add(text);
+			else {
+				for (int i=1; i<undoBuffer.size(); i++)
+					undoBuffer.set(i-1, undoBuffer.get(i));
+				undoBuffer.set(undoBuffer.size()-1, text);
+			}
+		}
+		performingUndo = false;
+		if (isMacroWindow) return;
+		// first few textValueChanged events may be bogus
+		eventCount++;
+		if (eventCount>2 || !IJ.isMacOSX() && eventCount>1)
+			changes = true;
+		if (IJ.isMacOSX()) // screen update bug work around
+			ta.setCaretPosition(ta.getCaretPosition());
+	}
+	
+	public void keyPressed(KeyEvent e) { } 	
+	public void mousePressed (MouseEvent e) {}
+	public void mouseExited (MouseEvent e) {}
+	public void mouseEntered (MouseEvent e) {}
+	
+	public void mouseReleased (MouseEvent e) {
+		showLinePos();
+	}
+	public void mouseClicked (MouseEvent e) {
+		showLinePos();
+	}
+
+	private void showLinePos() { // show line numbers in status bar (Norbert Vischer)
+		char[] chars = ta.getText().toCharArray();
+		if(chars.length > 1e6)
+				return;
+		int selStart = ta.getSelectionStart();
+		int selEnd = ta.getSelectionEnd();
+		int line=0;
+		int startLine = 1;
+		int endLine = 1;
+		for (int i=1; i<=chars.length; i++) {
+			if (chars[i-1]=='\n') line++;
+			if (i==selStart)
+				startLine=line + 1; 
+			if (i<=selEnd)
+				endLine=line + 1; 
+			if (i>=selEnd)
+				break;
+		}
+		String msg = "Line " + startLine;
+		if (startLine != endLine) {
+			msg += "-" + endLine;
+		}
+		IJ.showStatus(msg);
+	}
+				
+	public void keyReleased(KeyEvent e) {
+		int pos = ta.getCaretPosition();
+		showLinePos();
+		if (insertSpaces && pos>0 && e.getKeyCode()==KeyEvent.VK_TAB) {
+			String spaces = " ";
+			for (int i=1; i<tabInc; i++)
+				spaces += " ";
+			ta.replaceRange(spaces, pos-1, pos);
+		}
+		if (interactiveMode && e.getKeyChar()=='\n')
+			runMacro(e);
+	}
+	
+	private void runMacro(KeyEvent e) {
+		boolean isScript = getTitle().endsWith(".js");
+		String text = ta.getText();
+		int pos2 = ta.getCaretPosition()-2;
+		if (pos2<0) pos2=0;
+		int pos1 = 0;
+		for (int i=pos2; i>=0; i--) {
+			if (i==0 || text.charAt(i)=='\n') {
+				pos1 = i;
+				break;
+			}
+		}
+		if (isScript) {
+			if (evaluator==null) {
+				interpreter = null;
+				evaluator = new JavaScriptEvaluator();
+			}
+		} else {
+			if (interpreter==null) {
+				evaluator = null;
+				interpreter = new Interpreter();
+			}
+		}
+		String code = text.substring(pos1,pos2+1);
+		if (code.length()==0 || code.equals("\n"))
+			return;		
+		else if (code.length()<=6 && code.contains("help")) {
+			ta.appendText("  Type a statement (e.g., \"run('Invert')\") to run it.\n");			
+			ta.appendText("  Enter an expression (e.g., \"x/2\" or \"log(2)\") to evaluate it.\n");			
+			ta.appendText("  Move cursor to end of line and press 'enter' to repeat.\n");			
+			ta.appendText("  \"quit\" - exit interactive mode\n");			
+			ta.appendText("  "+(IJ.isMacOSX()?"cmd":"ctrl")+"+M - enter interactive mode\n");
+			if (isScript) {	
+				ta.appendText("  \"macro\" - switch language to macro\n");
+				ta.appendText("  \"examples\" - show JavaScript examples\n");	
+			} else {
+				ta.appendText("  "+(IJ.isMacOSX()?"cmd":"ctrl")+"+shift+F - open Function Finder\n");	
+				ta.appendText("  \"js\" - switch language to JavaScript\n");	
+			}
+		} else if (isScript && code.length()==9 && code.contains("examples")) {
+			ta.appendText(JS_EXAMPLES);					
+		} else if (code.length()<=3 && code.contains("js")) {
+			interactiveMode = false;
+			interpreter = null;
+			evaluator = null;
+			changeExtension(".js");
+			enterInteractiveMode();
+		} else if (code.length()<=6 && code.contains("macro")) {
+			interactiveMode = false;
+			interpreter = null;
+			evaluator = null;
+			changeExtension(".txt");
+			enterInteractiveMode();
+		} else if (code.length()<=6 && code.contains("quit")) {
+			interactiveMode = false;
+			interpreter = null;
+			evaluator = null;
+			ta.appendText("[Exiting interactive mode.]\n");
+		} else if (isScript) {
+			boolean updateImage = code.contains("ip.");
+			code = "load(\"nashorn:mozilla_compat.js\");"+JavaScriptIncludes+code;
+			String rtn = evaluator.eval(code);
+			if (rtn!=null && rtn.length()>0) {
+				int index = rtn.indexOf("at line number ");
+				if (index>-1)
+					rtn = rtn.substring(0,index);
+				insertText(rtn);	
+			}
+			if (updateImage && (rtn==null||rtn.length()==0)) {
+				ImagePlus imp = WindowManager.getCurrentImage();
+				if (imp!=null)
+					imp.updateAndDraw();
+			}
+		} else if (!code.startsWith("[Macro ")) {
+			String rtn = interpreter.eval(code);
+			if (rtn!=null)
+				insertText(rtn);
+		}
+	}
+	
+	private void changeExtension(String ext) {
+		String title = getTitle();
+		int index = title.indexOf(".");
+		if (index>-1)
+			title = title.substring(0,index);
+		setTitle(title+ext);
+	}
+	
+	private void enterInteractiveMode() {
+		if (interactiveMode)
+			return;
+		String title = getTitle();
+		if (ta!=null && ta.getText().length()>400 && !(title.startsWith("Untitled")||title.startsWith(INTERACTIVE_NAME))) {
+			GenericDialog gd = new GenericDialog("Enter Interactive Mode");
+			gd.addMessage("Enter mode that supports interactive\nediting and running of macros and scripts?");
+			gd.setOKLabel("Enter");
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return;
+		}
+		String language = title.endsWith(".js")?"JavaScript ":"Macro ";
+		messageCount++;
+		String help = messageCount<=2?" Type \"help\" for info.":"";
+		ta.appendText("["+language+"interactive mode."+help+"]\n");
+		interactiveMode = true;
+	}
+	
+	public void insertText(String text) {
+		if (ta==null) return;			
+		int start = ta.getSelectionStart( );
+		ta.replaceRange("  "+text+"\n", start, start);
+	}
+		
+	public void keyTyped(KeyEvent e) {
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		String cmd = e.getItem().toString();
+		if (e.getSource()==language) {
+			setExtension(cmd);
+			return;
+		}
+		CheckboxMenuItem item = (CheckboxMenuItem)e.getSource();
+		if ("Tab Key Inserts Spaces".equals(cmd)) {
+			insertSpaces = e.getStateChange()==1;
+			Prefs.set(INSERT_SPACES, insertSpaces);
+		} else
+			setFont();
+	}
+	
+	private void setExtension(String language) {
+		String title = getTitle();
+		int dot = title.lastIndexOf(".");
+		if (dot>=0)
+			title = title.substring(0, dot);
+		for (int i=0; i<languages.length; i++) {
+			if (language.equals(languages[i])) {
+				title += extensions[i];
+				break;
+			}
+		}
+		setWindowTitle(title);		
+	}
+
+	/** Override windowActivated in PlugInFrame to
+		prevent Mac menu bar from being installed. */
+	public void windowActivated(WindowEvent e) {
+			if (IJ.debugMode) IJ.log("Editor.windowActivated");
+			WindowManager.setWindow(this);
+			instance = this;
+	}
+
+	/** Overrides close() in PlugInFrame. */
+	public void close() {
+		boolean okayToClose = true;
+		ImageJ ij = IJ.getInstance();
+		if (!getTitle().equals("Errors") && changes && !IJ.isMacro() && ij!=null && !ij.quittingViaMacro()) {
+			String msg = "Save changes to \"" + getTitle() + "\"?";
+			YesNoCancelDialog d = new YesNoCancelDialog(this, "Editor", msg);
+			if (d.cancelPressed())
+				okayToClose = false;
+			else if (d.yesPressed())
+				save();
+		}
+		if (okayToClose) {
+			//setVisible(false);
+			dispose();
+			WindowManager.removeWindow(this);
+			nWindows--;
+			instance = null;
+			changes = false;
+			if (functionFinder!=null)
+				functionFinder.close();
+		}
+	}
+
+	public void saveAs() {
+		String name1 = getTitle();
+		if (name1.indexOf(".")==-1) name1 += ".txt";
+		if (defaultDir!=null && name1.endsWith(".java") && !defaultDir.startsWith(Menus.getPlugInsPath())) {
+			defaultDir = null;
+		}
+		if (defaultDir==null) {
+			if (name1.endsWith(".txt")||name1.endsWith(".ijm"))
+				defaultDir = Menus.getMacrosPath();
+			else
+				defaultDir = Menus.getPlugInsPath();
+		}
+		SaveDialog sd = new SaveDialog("Save As...", defaultDir, name1, null);
+		String name2 = sd.getFileName();
+		String dir = sd.getDirectory();
+		if (name2!=null) {
+			if (name2.endsWith(".java"))
+				updateClassName(name1, name2);
+			path = dir+name2;
+			save();
+			changes = false;
+			setWindowTitle(name2);
+			setDefaultDirectory(dir);
+			if (defaultDir!=null)
+				Prefs.set(DEFAULT_DIR, defaultDir);
+			if (Recorder.record)
+				Recorder.record("saveAs", "Text", path);
+		}
+	}
+	
+	protected void revert() {
+		if (!changes)
+			return;
+		String title = getTitle();
+		if (path==null || !(new File(path).exists()) || !path.endsWith(title)) {
+			IJ.showStatus("Cannot revert, no file "+getTitle());
+			return;
+		}
+		if (!IJ.showMessageWithCancel("Revert?", "Revert to saved version of\n\""+getTitle()+"\"?"))
+			return;
+		String directory = path.substring(0, path.length()-title.length());
+		open(directory, title);
+		undoBuffer = new ArrayList();
+	}
+
+	/** Changes a plugins class name to reflect a new file name. */
+	public void updateClassName(String oldName, String newName) {
+		if (newName.indexOf("_")<0)
+			IJ.showMessage("Plugin Editor", "Plugins without an underscore in their name will not\n"
+				+"be automatically installed when ImageJ is restarted.");
+		if (oldName.equals(newName) || !oldName.endsWith(".java") || !newName.endsWith(".java"))
+			return;
+		oldName = oldName.substring(0,oldName.length()-5);
+		newName = newName.substring(0,newName.length()-5);
+		String text1 = ta.getText();
+		int index = text1.indexOf("public class "+oldName);
+		if (index<0)
+			return;
+		String text2 = text1.substring(0,index+13)+newName+text1.substring(index+13+oldName.length(),text1.length());
+		ta.setText(text2);
+	}
+	
+	void find(String s) {
+		if (s==null) {
+			GenericDialog gd = new GenericDialog("Find", this);
+			gd.addStringField("Find: ", searchString, 20);
+			String[] labels = {"Case Sensitive", "Whole Words"};
+			boolean[] states = {caseSensitive, wholeWords};
+			gd.addCheckboxGroup(1, 2, labels, states);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return;
+			s = gd.getNextString();
+			caseSensitive = gd.getNextBoolean();
+			wholeWords = gd.getNextBoolean();
+			Prefs.set(CASE_SENSITIVE, caseSensitive);
+		}
+		if (s.equals(""))
+			return;
+		String text = ta.getText();
+		String s2 = s;
+		if (!caseSensitive) {
+			text = text.toLowerCase(Locale.US);
+			s = s.toLowerCase(Locale.US);
+		}
+		int index = -1;
+		if (wholeWords) {
+			int position = ta.getCaretPosition()+1;
+			while (true) {
+				index = text.indexOf(s, position);
+				if (index==-1) break;
+				if (isWholeWordMatch(text, s, index)) break;
+				position = index + 1;
+				if (position>=text.length()-1)
+					{index=-1; break;}
+			}
+		} else
+			index = text.indexOf(s, ta.getCaretPosition()+1);
+		searchString = s2;
+		if (index<0)
+			{IJ.beep(); return;}
+		ta.setSelectionStart(index);
+		ta.setSelectionEnd(index+s.length());
+	}
+	
+	boolean isWholeWordMatch(String text, String word, int index) {
+		char c = index==0?' ':text.charAt(index-1);
+		if (Character.isLetterOrDigit(c) || c=='_') return false;
+		c = index+word.length()>=text.length()?' ':text.charAt(index+word.length());
+		if (Character.isLetterOrDigit(c) || c=='_') return false;
+		return true;
+	}
+	
+	void gotoLine() {
+		GenericDialog gd = new GenericDialog("Go to Line", this);
+		gd.addNumericField("Go to line number: ", lineNumber, 0);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		int n = (int)gd.getNextNumber();
+		if (n<1) return;
+		String text = ta.getText();
+		char[] chars = new char[text.length()];
+		chars = text.toCharArray();
+		int count=1, loc=0;
+		for (int i=0; i<chars.length; i++) {
+			if (chars[i]=='\n') count++;
+			if (count==n)
+				{loc=i+1; break;}
+		}
+		ta.setCaretPosition(loc);
+		lineNumber = n;
+	}
+	
+	//extracts  characters  "({[]})" as string and removes inner pairs
+	private void balance() { //modified: N.Vischer
+		String text = ta.getText();
+		char[] chars = new char[text.length()];
+		chars = text.toCharArray();
+		maskComments(chars);
+		maskQuotes(chars);
+		int position = ta.getCaretPosition();
+		if (position == 0) {
+			IJ.error("Balance", "This command locates the pair of brackets, curly braces or\nparentheses that surround the insertion point.");
+			return;
+		}
+		int start = -1;
+		int stop = -1;
+		String leftBows = "";
+		for (int i = position -1 ; i >= 0; i--) {
+			char ch = chars[i];
+			if ("({[]})".indexOf(ch) >= 0) {
+				leftBows = ch + leftBows;
+				leftBows = leftBows.replace("[]", "");//skip nested pairs
+				leftBows = leftBows.replace("()", "");
+				leftBows = leftBows.replace("{}", "");
+				if (leftBows.equals ("[") || leftBows.equals ("{") || leftBows.equals ("(")) {
+					start = i;
+					break;
+				}
+			}
+		}
+		String rightBows = "";
+		for (int i = position ; i < chars.length; i++) {
+			char ch = chars[i];
+			if ("({[]})".indexOf(ch) >= 0) {
+				rightBows += ch;
+				rightBows = rightBows.replace("[]", "");//skip nested pairs
+				rightBows = rightBows.replace("()", "");
+				rightBows = rightBows.replace("{}", "");
+				String pair = leftBows + rightBows;
+				if (pair.equals("[]") ||  pair.equals("{}") || pair.equals("()")) {
+					stop = i;
+					break;
+				}
+			}
+		}
+		if (start == -1 || stop == -1) {
+			IJ.beep();
+			return;
+		}
+		ta.setSelectionStart(start);
+		ta.setSelectionEnd(stop + 1);
+		IJ.showStatus(chars.length + " " + position + " " + start + " " + stop);
+	}
+
+	// replaces contents of comments with blanks
+	private void maskComments(char[] chars) {
+		int n = chars.length;
+		boolean inSlashSlashComment = false;
+		boolean inSlashStarComment = false;
+		for (int i=0; i<n-1; i++) {
+			if (chars[i]=='/' && chars[i+1]=='/')
+				inSlashSlashComment = true;
+			if (chars[i]=='\n' )
+				inSlashSlashComment = false;
+			if (!inSlashSlashComment){
+				if (chars[i]=='/' && chars[i+1]=='*')
+					inSlashStarComment = true;
+				if (chars[i]=='*' && chars[i+1]=='/')
+					inSlashStarComment = false;
+			}
+			if (inSlashSlashComment||inSlashStarComment)
+				chars[i] = ' ';
+		}
+	}
+
+	// replaces contents of single and double quotes with blanks - N. Vischer
+	private void maskQuotes(char[] chars) {
+		int n = chars.length;
+		char quote = '\'';//single quote
+		for (int loop = 1; loop <= 2; loop++) {
+			if (loop == 2)
+				quote = '"';//double quote
+			boolean inQuotes = false;
+			int startMask = 0;
+			int stopMask = 0;
+			for (int i = 0; i < n - 1; i++) {
+				boolean escaped = i > 0 && chars[i - 1] == '\\';
+				if (chars[i] == '\n')
+					inQuotes = false;
+				if (chars[i] == quote && !escaped) {
+					if (!inQuotes) {
+						startMask = i;
+						inQuotes = true;
+					} else {
+						stopMask = i;
+						for (int jj = startMask; jj <= stopMask; jj++) {
+							chars[jj] = ' ';
+						}
+						inQuotes = false;
+					}
+				}
+			}
+		}
+	}
+	
+   //replaces contents of comments with blanks
+	private void rmaskComments(char[] chars) {
+		int n = chars.length;
+		boolean inSlashSlashComment = false;
+		boolean inSlashStarComment = false;
+		for (int i=0; i<n-1; i++) {
+			if (chars[i]=='/' && chars[i+1]=='/')
+				inSlashSlashComment = true;
+			if (chars[i]=='\n' )
+				inSlashSlashComment = false;
+			if (chars[i]=='/' && chars[i+1]=='*')
+				inSlashStarComment = true;
+			if (chars[i]=='*' && chars[i+1]=='/')
+				inSlashStarComment = false;
+			if (inSlashSlashComment||inSlashStarComment)
+				chars[i] = ' ';
+		}
+	}
+
+	void zapGremlins() {
+		String text = ta.getText();
+		char[] chars = new char[text.length()];
+		chars = text.toCharArray();
+		int count=0;
+		boolean inQuotes = false;
+		char quoteChar = 0;
+		for (int i=0; i<chars.length; i++) {
+			char c = chars[i];
+			if (!inQuotes && (c=='"' || c=='\'')) {
+				inQuotes = true;
+				quoteChar = c;
+			} else  {
+				if (inQuotes && (c==quoteChar || c=='\n'))
+				inQuotes = false;
+			}
+			if (!inQuotes && c!='\n' && c!='\t' && (c<32||c>127)) {
+				count++;
+				chars[i] = ' ';
+			}
+		}
+		if (count>0) {
+			text = new String(chars);
+			ta.setText(text);
+		}
+		if (count>0)
+			IJ.showMessage("Zap Gremlins", count+" invalid characters converted to spaces");
+		else
+			IJ.showMessage("Zap Gremlins", "No invalid characters found");
+	}
+	
+	
+	private void detab() {
+		GenericDialog gd = new GenericDialog("Detab", this);
+		gd.addNumericField("Spaces per tab: ", tabInc, 0);
+		gd.addCheckbox("Tab key inserts spaces: ", insertSpaces);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		int tabInc2 = tabInc;
+		tabInc = (int)gd.getNextNumber();
+		if (tabInc<1) tabInc=1;
+		if (tabInc>8) tabInc=8;
+		if (tabInc!=tabInc2)
+			Prefs.set(TAB_INC, tabInc);
+		boolean insertSpaces2 = insertSpaces;
+		insertSpaces = gd.getNextBoolean();
+		if (insertSpaces!=insertSpaces2) {
+			Prefs.set(INSERT_SPACES, insertSpaces);
+			insertSpacesItem.setState(insertSpaces);
+		}
+		int nb = 0;
+		int pos = 1;
+		String text = ta.getText();
+		if (text.indexOf('\t')<0)
+			return;
+		char[] chars = new char[text.length()];
+		chars = text.toCharArray();
+		StringBuffer sb = new StringBuffer((int)(chars.length*1.25));
+		for (int i=0; i<chars.length; i++) {
+			char c = chars[i];
+			if (c=='\t') {
+				nb = tabInc - ((pos-1)%tabInc);
+				while(nb>0) {
+					sb.append(' ');
+					++pos;
+					--nb;
+				}
+			} else if (c=='\n') {
+				sb.append(c);
+				pos = 1;
+			} else {
+				sb.append(c);
+				++pos;
+			}
+		}
+		ta.setText(sb.toString());
+	}
+
+	void selectAll() {
+		ta.selectAll();
+		showLinePos();
+	}
+    
+    void changeFontSize(boolean larger) {
+        int in = fontSizeIndex;
+        if (larger) {
+            fontSizeIndex++;
+            if (fontSizeIndex==sizes.length)
+                fontSizeIndex = sizes.length-1;
+        } else {
+            fontSizeIndex--;
+            if (fontSizeIndex<0)
+                fontSizeIndex = 0;
+        }
+        IJ.showStatus(sizes[fontSizeIndex]+" point");
+        setFont();
+    }
+    
+    void saveSettings() {
+		Prefs.set(FONT_SIZE, fontSizeIndex);
+		Prefs.set(FONT_MONO, monospaced.getState());
+		IJ.showStatus("Font settings saved (size="+sizes[fontSizeIndex]+", monospaced="+monospaced.getState()+")");
+    }
+    
+    void setFont() {
+        ta.setFont(new Font(getFontName(), Font.PLAIN, sizes[fontSizeIndex]));
+    }
+    
+    String getFontName() {
+    	return monospaced.getState()?"Monospaced":"SansSerif";
+    }
+	
+	public void setFont(Font font) {
+		ta.setFont(font);
+	}
+	
+	public int getFontSize() {
+		return sizes[fontSizeIndex];
+	}
+
+	public void append(String s) {
+		ta.append(s);
+	}
+
+	public void setIsMacroWindow(boolean mw) {
+		isMacroWindow = mw;
+	}
+
+	public static void setDefaultDirectory(String dir) {
+		dir = IJ.addSeparator(dir);
+		defaultDir = dir;
+	}
+	
+	public void lostOwnership (Clipboard clip, Transferable cont) {}
+	
+	public int debug(Interpreter interp, int mode) {
+		if (IJ.debugMode)
+			IJ.log("debug: "+interp.getLineNumber()+"  "+mode+"  "+interp);
+		if (mode==RUN_TO_COMPLETION)
+			return 0;
+		int n = interp.getLineNumber();
+		if (mode==RUN_TO_CARET) {
+			if (n==runToLine) {
+				mode = STEP;
+				interp.setDebugMode(mode);
+			} else
+				return 0;
+		}
+		if (!isVisible()) { // abort macro if user closes window
+			interp.abortMacro();
+			return 0;
+		}
+		if (n==previousLine) {
+			previousLine=0;
+			return 0;
+		}
+		Window win = WindowManager.getActiveWindow();
+		if (win!=this)
+			IJ.wait(50);
+		toFront();
+		previousLine = n;
+		String text = ta.getText();
+		if (IJ.isWindows())
+			text = text.replaceAll("\r\n", "\n");
+		char[] chars = new char[text.length()];
+		chars = text.toCharArray();
+		int count=1;
+		debugStart=0;
+		int len = chars.length;
+		debugEnd = len;
+		for (int i=0; i<len; i++) {
+			if (chars[i]=='\n') count++;
+			if (count==n && debugStart==0)
+				debugStart=i+1;
+			else if (count==n+1) {
+				debugEnd=i;
+				break;
+			}
+		}
+		//IJ.log("debug: "+debugStart+"  "+debugEnd+"  "+len+"  "+count);
+		if (debugStart==1) debugStart = 0;
+		if ((debugStart==0||debugStart==len) && debugEnd==len)
+			return 0; // skip code added with Interpreter.setAdditionalFunctions()
+		ta.select(debugStart, debugEnd);
+		if (debugWindow!=null && !debugWindow.isShowing()) {
+			interp.setDebugger(null);
+			debugWindow = null;
+		} else
+			debugWindow = interp.updateDebugWindow(interp.getVariables(), debugWindow);
+		if (debugWindow!=null) {
+			interp.updateArrayInspector();
+			toFront();
+		}
+		if (mode==STEP) {
+			step = false;
+			while (!step && !interp.done() && isVisible())
+				IJ.wait(5);
+		} else {
+			if (mode==FAST_TRACE)
+				IJ.wait(5);
+			else
+				IJ.wait(150);
+		}
+		return 0;
+	}
+		
+	public static Editor getInstance() {
+		return instance;
+	}
+	
+	public static String getJSPrefix(String arg) {
+		if (arg==null)
+			arg = "";
+		return JavaScriptIncludes+"function getArgument() {return \""+arg+"\";};";
+	}
+	
+	/** Changes Windows (CRLF) line separators to line feeds (LF). */
+	public void fixLineEndings() {
+		if (!IJ.isWindows())
+			return;
+		String text = ta.getText();
+		text = text.replaceAll("\r\n", "\n");
+		ta.setText(text);
+	}
+	
+	public void showLogWindow() {
+		Frame log = WindowManager.getFrame("Log");
+		if (log!=null)
+			log.toFront();
+		else
+			IJ.log("");
+	}
+
+	public boolean fileChanged() {
+		return changes;
+	}
+	
+	/** Downloads BeanShell or Jython interpreter using a separate thread. */
+	public void run() {
+		if (downloading || downloadUrl==null)
+			return;
+		downloading = true;
+		boolean ok = Macro_Runner.downloadJar(downloadUrl);
+		downloading = false;
+	}
+
+}
diff --git a/src/ij/plugin/frame/Fitter.java b/src/ij/plugin/frame/Fitter.java
new file mode 100644
index 0000000..87e1427
--- /dev/null
+++ b/src/ij/plugin/frame/Fitter.java
@@ -0,0 +1,328 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.*;
+import java.awt.datatransfer.*;	
+import ij.*;
+import ij.plugin.PlugIn;
+import ij.plugin.frame.*;
+import ij.text.*;
+import ij.gui.*;
+import ij.util.*;
+import ij.io.*;
+import ij.process.*;
+import ij.measure.*;
+
+/** ImageJ plugin that does curve fitting using the modified CurveFitter class.
+ *  Includes simplex settings dialog option.
+ *
+ * @author  Kieran Holland (email: holki659@student.otago.ac.nz)
+ *
+ * 2013-10-01: fit not in EventQueue, setStatusAndEsc, error if nonnumeric data
+ */
+public class Fitter extends PlugInFrame implements PlugIn, ItemListener, ActionListener, KeyListener, ClipboardOwner {
+
+	Choice fit;
+	Button doIt, open, apply;
+	Checkbox settings;
+	String fitTypeStr = CurveFitter.fitList[0];
+	TextArea textArea;
+
+	double[] dx = {0,1,2,3,4,5};
+	double[] dy = {0,.9,4.5,8,18,24};
+	double[] x,y;
+
+	static CurveFitter cf;
+	static int fitType = -1;
+	static String equation = "y = a + b*x + c*x*x";
+	static final int USER_DEFINED = -1;
+
+	public Fitter() {
+		super("Curve Fitter");
+		WindowManager.addWindow(this);
+		addKeyListener(this);
+		Panel panel = new Panel();
+		fit = new Choice();
+		for (int i=0; i<CurveFitter.fitList.length; i++)
+			fit.addItem(CurveFitter.fitList[CurveFitter.sortedTypes[i]]);
+		fit.addItem("*User-defined*");
+		fit.addItemListener(this);
+		panel.add(fit);
+		doIt = new Button(" Fit ");
+		doIt.addActionListener(this);
+		doIt.addKeyListener(this);
+		panel.add(doIt);
+		open = new Button("Open");
+		open.addActionListener(this);
+		panel.add(open);
+		apply = new Button("Apply");
+		apply.addActionListener(this);
+		panel.add(apply);
+		settings = new Checkbox("Show settings", false);
+		panel.add(settings);
+		add("North", panel);
+		String text = "";
+		for (int i=0; i<dx.length; i++)
+			text += IJ.d2s(dx[i],2)+"  "+IJ.d2s(dy[i],2)+"\n";
+		textArea = new TextArea("",15,30,TextArea.SCROLLBARS_VERTICAL_ONLY);
+		textArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		if (IJ.isLinux()) textArea.setBackground(Color.white);
+		textArea.append(text);
+		add("Center", textArea);
+		GUI.scale(this);
+		pack();
+		GUI.centerOnImageJScreen(this);
+		show();
+		IJ.register(Fitter.class);
+	}
+
+    /** Fit data in the textArea, show result in log and create plot.
+     *  @param fitType as defined in CurveFitter constants
+     *  @return false on error.
+     */
+	public boolean doFit(int fitType) {
+		if (!getData()) {
+            IJ.beep();
+			return false;
+		}
+		cf = new CurveFitter(x, y);
+		cf.setStatusAndEsc("Optimization: Iteration ", true);
+		try {
+            if (fitType==USER_DEFINED) {
+                String eqn = getEquation();
+                if (eqn==null) return false;
+                int params = cf.doCustomFit(eqn, null, settings.getState());
+                if (params==0) {
+                    IJ.beep();
+                    IJ.log("Bad formula; should be:\n   y = function(x, a, ...)");
+                    return false;
+                }
+            } else
+                cf.doFit(fitType, settings.getState());
+            if (cf.getStatus() == Minimizer.INITIALIZATION_FAILURE) {
+                IJ.beep();
+                IJ.showStatus(cf.getStatusString());
+                IJ.log("Curve Fitting Error:\n"+cf.getStatusString());
+                return false;
+            }
+            if (Double.isNaN(cf.getSumResidualsSqr())) {
+                IJ.beep();
+                IJ.showStatus("Error: fit yields Not-a-Number");
+                return false;
+            }
+            
+		} catch (Exception e) {
+            IJ.handleException(e);
+            return false;
+		}
+        IJ.log(cf.getResultString());
+		plot(cf);
+		this.fitType = fitType; 
+		return true;
+	}
+	
+	String getEquation() {
+		GenericDialog gd = new GenericDialog("Formula");
+		gd.addStringField("Formula:", equation, 38);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return null;
+		equation = gd.getNextString();
+		return equation;
+	}
+	
+	public static void plot(CurveFitter cf) {
+		plot(cf, false);
+	}
+	
+	public static void plot(CurveFitter cf, boolean eightBitCalibrationPlot) {
+		Plot plot = cf.getPlot(eightBitCalibrationPlot?256:100);
+		plot.show();									
+	}
+	
+	double sqr(double x) {return x*x;}
+	
+	boolean getData() {
+		textArea.selectAll();
+		String text = textArea.getText();
+		text = zapGremlins(text);
+		textArea.select(0,0);
+		StringTokenizer st = new StringTokenizer(text, " \t\n\r,");
+		int nTokens = st.countTokens();
+		if (nTokens<4 || (nTokens%2)!=0) {
+		    IJ.showStatus("Data error: min. two (x,y) pairs needed");
+			return false;
+		}
+		int n = nTokens/2;
+		x = new double[n];
+		y = new double[n];
+		for (int i=0; i<n; i++) {
+			String xString = st.nextToken();
+			String yString = st.nextToken();
+			x[i] = Tools.parseDouble(xString);
+			y[i] = Tools.parseDouble(yString);
+			if (Double.isNaN(x[i]) || Double.isNaN(y[i])) {
+				IJ.showStatus("Data error:  Bad number at "+i+": "+xString+" "+yString);
+				return false;
+			}
+		}
+		return true;
+	}
+
+	/** create a duplicate of an image where the fit function is applied to the pixel values */
+	void applyFunction() {
+		if (cf==null || fitType < 0) {
+			IJ.error("No function available");
+			return;
+		}
+		ImagePlus img = WindowManager.getCurrentImage();
+		if (img==null) {
+			IJ.noImage();
+			return;
+		}
+		if (img.getTitle().matches("y\\s=.*")) { //title looks like a fit function
+			IJ.error("First select the image to be transformed");
+			return;
+		}
+		double[] p = cf.getParams();
+		int width = img.getWidth();
+		int height = img.getHeight();
+		int size = width*height;
+		float[] data = new float[size];
+		ImageProcessor ip = img.getProcessor();
+		float value;
+		for (int y=0; y<height; y++) {
+			for (int x=0; x<width; x++) {
+				value = ip.getPixelValue(x,y);
+				data[y*width+x] = (float)cf.f(p, value);
+			}
+		}
+		ImageProcessor ip2 = new FloatProcessor(width, height, data, ip.getColorModel());
+		new ImagePlus(img.getTitle()+"-transformed", ip2).show();
+	}
+
+	void open() {
+		OpenDialog od = new OpenDialog("Open Text File...", "");
+		String directory = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+			return;
+		String path = directory + name;
+		textArea.selectAll();
+		textArea.setText("");
+		try {
+			BufferedReader r = new BufferedReader(new FileReader(directory+name));
+			while (true) {
+				String s=r.readLine();
+				if (s==null ||(s.length()>100))
+					break;
+				textArea.append(s+"\n");
+			}
+			r.close();
+		}
+		catch (Exception e) {
+			IJ.error(e.getMessage());
+			return;
+		}
+	}
+	
+	public void itemStateChanged(ItemEvent e) {
+		fitTypeStr = fit.getSelectedItem();
+	}
+	
+	public void actionPerformed(ActionEvent e) {
+		if (e.getSource() instanceof MenuItem) {
+			String cmd = e.getActionCommand();
+			if (cmd==null) return;
+			if (cmd.equals("Cut"))
+				cut();
+			else if (cmd.equals("Copy"))
+				copy();
+			else if (cmd.equals("Paste"))
+				paste();
+			return;
+		}
+		try {
+            if (e.getSource()==doIt) {
+                final int fitType = CurveFitter.getFitCode(fit.getSelectedItem());
+	            Thread thread = new Thread(
+	                new Runnable() {
+                        final public void run() {
+                            doFit(fitType);
+                        }
+                    }, "CurveFitting"
+                );
+                thread.setPriority(Thread.currentThread().getPriority());
+                thread.start();
+            } else if (e.getSource()==apply)
+                applyFunction();
+            else
+                open();
+		} catch (Exception ex) {IJ.log(""+ex);}
+	}
+	
+	String zapGremlins(String text) {
+		char[] chars = new char[text.length()];
+		chars = text.toCharArray();
+		int count=0;
+		for (int i=0; i<chars.length; i++) {
+			char c = chars[i];
+			if (c!='\n' && c!='\t' && (c<32||c>127)) {
+				count++;
+				chars[i] = ' ';
+			}
+		}
+		if (count>0)
+			return new String(chars);
+		else
+			return text;
+	}
+
+    public void keyTyped (KeyEvent e) {}
+    public void keyReleased (KeyEvent e) {}
+    public void keyPressed (KeyEvent e) {
+        if (e.getKeyCode() == KeyEvent.VK_ESCAPE)
+            IJ.getInstance().keyPressed(e);
+    }
+    
+	private boolean copy() { 
+		String s = textArea.getSelectedText();
+		Clipboard clip = getToolkit().getSystemClipboard();
+		if (clip!=null) {
+			StringSelection cont = new StringSelection(s);
+			clip.setContents(cont,this);
+			return true;
+		} else
+			return false;
+	}
+ 
+	  
+	private void cut() {
+		if (copy()) {
+			int start = textArea.getSelectionStart();
+			int end = textArea.getSelectionEnd();
+			textArea.replaceRange("", start, end);
+		}	
+	}
+
+	private void paste() {
+		String s;
+		s = textArea.getSelectedText();
+		Clipboard clipboard = getToolkit( ). getSystemClipboard(); 
+		Transferable clipData = clipboard.getContents(s);
+		try {
+			s = (String)(clipData.getTransferData(DataFlavor.stringFlavor));
+		} catch  (Exception e)  {
+			s  = e.toString( );
+		}
+		int start = textArea.getSelectionStart( );
+		int end = textArea.getSelectionEnd( );
+		textArea.replaceRange(s, start, end);
+		if (IJ.isMacOSX())
+			textArea.setCaretPosition(start+s.length());
+    }
+    
+	public void lostOwnership (Clipboard clip, Transferable cont) {}
+
+}
\ No newline at end of file
diff --git a/src/ij/plugin/frame/LineWidthAdjuster.java b/src/ij/plugin/frame/LineWidthAdjuster.java
new file mode 100644
index 0000000..d0a720b
--- /dev/null
+++ b/src/ij/plugin/frame/LineWidthAdjuster.java
@@ -0,0 +1,204 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.*;
+import ij.*;
+import ij.plugin.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.frame.Recorder;
+import ij.util.Tools;
+
+/** Adjusts the width of line selections.  */
+public class LineWidthAdjuster extends PlugInFrame implements PlugIn,
+	Runnable, AdjustmentListener, TextListener, ItemListener {
+
+	public static final String LOC_KEY = "line.loc";
+	int sliderRange = 300;
+	Scrollbar slider;
+	int value;
+	boolean setText;
+	static LineWidthAdjuster instance;
+	Thread thread;
+	boolean done;
+	TextField tf;
+	Checkbox checkbox;
+
+	public LineWidthAdjuster() {
+		super("Line Width");
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		WindowManager.addWindow(this);
+		instance = this;
+		slider = new Scrollbar(Scrollbar.HORIZONTAL, Line.getWidth(), 1, 1, sliderRange+1);
+		GUI.fixScrollbar(slider);
+		slider.setFocusable(false); // prevents blinking on Windows
+
+		Panel panel = new Panel();
+		int margin = IJ.isMacOSX()?5:0;
+		GridBagLayout grid = new GridBagLayout();
+		GridBagConstraints c  = new GridBagConstraints();
+		panel.setLayout(grid);
+		c.gridx = 0; c.gridy = 0;
+		c.gridwidth = 1;
+		c.ipadx = 100;
+		c.insets = new Insets(margin, 15, margin, 5);
+		c.anchor = GridBagConstraints.CENTER;
+		grid.setConstraints(slider, c);
+		panel.add(slider);
+		c.ipadx = 0;  // reset
+		c.gridx = 1;
+		c.insets = new Insets(margin, 5, margin, 15);
+		tf = new TextField(""+Line.getWidth(), 4);
+		tf.addTextListener(this);
+		grid.setConstraints(tf, c);
+		panel.add(tf);
+
+		c.gridx = 2;
+		c.insets = new Insets(margin, 25, margin, 5);
+		checkbox = new Checkbox("Spline fit", isSplineFit());
+		checkbox.addItemListener(this);
+		panel.add(checkbox);
+
+		add(panel, BorderLayout.CENTER);
+		slider.addAdjustmentListener(this);
+		slider.setUnitIncrement(1);
+
+		GUI.scale(this);
+		pack();
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null)
+			setLocation(loc);
+		else
+			GUI.centerOnImageJScreen(this);
+		setResizable(false);
+		show();
+		thread = new Thread(this, "LineWidthAdjuster");
+		thread.start();
+		setup();
+		addKeyListener(IJ.getInstance());
+	}
+
+	public synchronized void adjustmentValueChanged(AdjustmentEvent e) {
+		value = slider.getValue();
+		setText = true;
+		notify();
+	}
+
+    public  synchronized void textValueChanged(TextEvent e) {
+        int width = (int)Tools.parseDouble(tf.getText(), -1);
+		//IJ.log(""+width);
+        if (width==-1) return;
+        if (width<0) width=1;
+        if (width!=Line.getWidth()) {
+			slider.setValue(width);
+        	value = width;
+        	notify();
+        }
+    }
+	void setup() {
+	}
+
+	// Separate thread that does the potentially time-consuming processing
+	public void run() {
+		while (!done) {
+			synchronized(this) {
+				try {wait();}
+				catch(InterruptedException e) {}
+				if (done) return;
+			}
+			if (setText) tf.setText(""+value);
+			setText = false;
+			Line.setWidth(value);
+			updateRoi();
+		}
+	}
+
+	private static void updateRoi() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			Roi roi = imp.getRoi();
+			if (roi!=null && roi.isLine()) {
+				roi.updateWideLine(Line.getWidth());
+				imp.draw();
+				return;
+			}
+		}
+		Roi previousRoi = Roi.getPreviousRoi();
+		if (previousRoi==null) return;
+		int id = previousRoi.getImageID();
+		if (id>=0) return;
+		imp = WindowManager.getImage(id);
+		if (imp==null) return;
+		Roi roi = imp.getRoi();
+		if (roi!=null && roi.isLine()) {
+			roi.updateWideLine(Line.getWidth());
+			imp.draw();
+		}
+	}
+
+	boolean isSplineFit() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) return false;
+		Roi roi = imp.getRoi();
+		if (roi==null) return false;
+		if (!(roi instanceof PolygonRoi)) return false;
+		return ((PolygonRoi)roi).isSplineFit();
+	}
+
+    /** Overrides close() in PlugInFrame. */
+	public void close() {
+		super.close();
+		instance = null;
+		done = true;
+		Prefs.saveLocation(LOC_KEY, getLocation());
+		synchronized(this) {notify();}
+	}
+
+    public void windowActivated(WindowEvent e) {
+    	super.windowActivated(e);
+    	checkbox.setState(isSplineFit());
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		boolean selected = e.getStateChange()==ItemEvent.SELECTED;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			{checkbox.setState(false); return;};
+		Roi roi = imp.getRoi();
+		int type = roi!=null ? roi.getType() : -1;
+
+		if (roi==null || !(roi instanceof PolygonRoi) || type==Roi.FREEROI || type==Roi.FREELINE || type==Roi.ANGLE) {
+			checkbox.setState(false);
+			return;
+		};
+		PolygonRoi poly = (PolygonRoi)roi;
+		boolean splineFit = poly.isSplineFit();
+		if (selected && !splineFit) {
+			poly.fitSpline(); //this must not call roi.notifyListeners (live plot would trigger it continuously)
+			Prefs.splineFitLines = true;
+			imp.draw();
+			roi.notifyListeners(RoiListener.MODIFIED);
+		} else if (!selected && splineFit) {
+			poly.removeSplineFit();
+			Prefs.splineFitLines = false;
+			imp.draw();
+			roi.notifyListeners(RoiListener.MODIFIED);
+		}
+	}
+
+	public static void update() {
+		if (instance==null) return;
+		instance.checkbox.setState(instance.isSplineFit());
+		int sliderWidth = instance.slider.getValue();
+		int lineWidth = Line.getWidth();
+		if (lineWidth!=sliderWidth && lineWidth<=200) {
+			instance.slider.setValue(lineWidth);
+			instance.tf.setText(""+lineWidth);
+		}
+	}
+
+}
diff --git a/src/ij/plugin/frame/MemoryMonitor.java b/src/ij/plugin/frame/MemoryMonitor.java
new file mode 100644
index 0000000..ab53a4a
--- /dev/null
+++ b/src/ij/plugin/frame/MemoryMonitor.java
@@ -0,0 +1,134 @@
+package ij.plugin.frame;
+import ij.*;
+import ij.gui.*;
+import ij.process.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.event.*;
+
+/** This plugin continuously plots ImageJ's memory utilization. 
+	Click on the plot to force the JVM to do garbage collection. */
+public class MemoryMonitor extends PlugInFrame {
+	private static final double scale = Prefs.getGuiScale();
+ 	private static final int width = (int)(250*scale);
+ 	private static final int height = (int)(90*scale);
+	private static final String LOC_KEY = "memory.loc";
+	private static MemoryMonitor instance;
+	private Image image;
+	private Graphics2D g;
+	private int frames;
+	private double[] mem;
+	private int index;
+	private long value;
+ 	private double defaultMax = 20*1024*1024; // 20MB
+	private double max = defaultMax;
+	private long maxMemory = IJ.maxMemory();
+	private boolean done;
+
+	public MemoryMonitor() {
+		super("Memory");
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		instance = this;
+		WindowManager.addWindow(this);
+		
+		setLayout(new BorderLayout());
+		Canvas ic = new PlotCanvas();
+		ic.setSize(width, height);
+		add(ic);
+		setResizable(false);
+		pack();
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null)
+			setLocation(loc);
+		else
+			GUI.centerOnImageJScreen(this);
+		image = createImage(width,height);
+		g = (Graphics2D)image.getGraphics();
+		g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+		g.setColor(Color.white);
+		g.fillRect(0, 0, width, height);
+		g.setFont(new Font("SansSerif",Font.PLAIN,(int)(12*Prefs.getGuiScale())));
+		show();
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null) {
+			addKeyListener(ij);
+			ic.addKeyListener(ij);
+			ic.addMouseListener(ij);
+		}
+		mem = new double[width+1];
+		Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
+       	while (!done) {
+			updatePlot();
+         	addText();
+			ic.repaint();
+        	IJ.wait(50);
+       		frames++;
+		}
+	}
+	
+    void addText() {
+    	double value2 = (double)value/1048576L;
+    	String s = IJ.d2s(value2,value2>50?0:2)+"MB";
+    	if (maxMemory>0L) {
+			double percent = value*100/maxMemory;
+			s += " ("+(percent<1.0?"<1":IJ.d2s(percent,0)) + "%)";
+		}
+		g.drawString(s, 2, 15);
+		String images = ""+WindowManager.getImageCount();
+		g.drawString(images, width-(5+images.length()*8), 15);
+	}
+
+	void updatePlot() {
+		double used = IJ.currentMemory();
+		if (frames%10==0) value = (long)used;
+		if (used>0.86*max) max *= 2.0;
+		mem[index++] = used;
+		if (index==mem.length) index = 0;
+		double maxmax = 0.0;
+		for (int i=0; i<mem.length; i++) {
+			if (mem[i]>maxmax) maxmax= mem[i];
+		}
+		if (maxmax<defaultMax) max=defaultMax*2;
+		if (maxmax<defaultMax/2) max = defaultMax;
+		int index2 = index+1;
+		if (index2==mem.length) index2 = 0;
+		g.setColor(Color.white);
+		g.fillRect(0, 0, width, height);
+	 	g.setColor(Color.black);	
+		double scale = height/max;
+		int x1 = 0;
+		int y1 = height-(int)(mem[index2]*scale);
+		for (int x2=1; x2<width; x2++) {
+			index2++;
+			if (index2==mem.length) index2 = 0;
+			int y2 = height-(int)(mem[index2]*scale);
+			g.drawLine(x1, y1, x2, y2);
+			x1=x2; y1=y2;
+		}
+	}
+
+    public void close() {
+	 	super.close();
+		instance = null;
+		Prefs.saveLocation(LOC_KEY, getLocation());
+		done = true;
+	}
+	
+	class PlotCanvas extends Canvas {
+	
+		public void update(Graphics g) {
+			paint(g);
+		}
+		
+		public void paint(Graphics g) {
+			g.drawImage(image, 0, 0, null);
+		}
+		
+	} 
+
+}
+
+
diff --git a/src/ij/plugin/frame/PasteController.java b/src/ij/plugin/frame/PasteController.java
new file mode 100644
index 0000000..fef8216
--- /dev/null
+++ b/src/ij/plugin/frame/PasteController.java
@@ -0,0 +1,85 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import ij.*;
+import ij.plugin.*;
+import ij.gui.*;
+import ij.process.*;
+
+/** Implements ImageJ's Paste Control window. */
+public class PasteController extends PlugInFrame implements PlugIn, ItemListener {
+
+	private Panel panel;
+	private Choice pasteMode;
+	private static Frame instance;
+	
+	public PasteController() {
+		super("Paste Control");
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		WindowManager.addWindow(this);
+		instance = this;
+		IJ.register(PasteController.class);
+		setLayout(new FlowLayout(FlowLayout.CENTER, 2, 5));
+		
+		add(new Label(" Transfer Mode:"));
+		pasteMode = new Choice();
+		pasteMode.addItem("Copy");
+		pasteMode.addItem("Blend");
+		pasteMode.addItem("Difference");
+		pasteMode.addItem("Transparent-white");
+		pasteMode.addItem("Transparent-zero");
+		pasteMode.addItem("AND");
+		pasteMode.addItem("OR");
+		pasteMode.addItem("XOR");
+		pasteMode.addItem("Add");
+		pasteMode.addItem("Subtract");
+		pasteMode.addItem("Multiply");
+		pasteMode.addItem("Divide");
+		pasteMode.addItem("Min");
+		pasteMode.addItem("Max");
+		pasteMode.select("Copy");
+		pasteMode.addItemListener(this);
+		add(pasteMode);
+		Roi.setPasteMode(Blitter.COPY);
+
+		GUI.scale(this);
+		pack();
+		GUI.centerOnImageJScreen(this);
+		setResizable(false);
+		show();
+	}
+	
+	public void itemStateChanged(ItemEvent e) {
+		int index = pasteMode.getSelectedIndex();
+		int mode = Blitter.COPY;
+		switch (index) {
+			case 0: mode = Blitter.COPY; break;
+			case 1: mode = Blitter.AVERAGE; break;
+			case 2: mode = Blitter.DIFFERENCE; break;
+			case 3: mode = Blitter.COPY_TRANSPARENT; break;
+			case 4: mode = Blitter.COPY_ZERO_TRANSPARENT; break;
+			case 5: mode = Blitter.AND; break;
+			case 6: mode = Blitter.OR; break;
+			case 7: mode = Blitter.XOR; break;
+			case 8: mode = Blitter.ADD; break;
+			case 9: mode = Blitter.SUBTRACT; break;
+			case 10: mode = Blitter.MULTIPLY; break;
+			case 11: mode = Blitter.DIVIDE; break;
+			case 12: mode = Blitter.MIN; break;
+			case 13: mode = Blitter.MAX; break;
+		}
+		Roi.setPasteMode(mode);
+		if (Recorder.record)
+			Recorder.record("setPasteMode", pasteMode.getSelectedItem());
+		ImagePlus imp = WindowManager.getCurrentImage();
+	}
+	
+	public void close() {
+		super.close();
+		instance = null;
+	}
+	
+}
diff --git a/src/ij/plugin/frame/PlugInDialog.java b/src/ij/plugin/frame/PlugInDialog.java
new file mode 100644
index 0000000..35420bc
--- /dev/null
+++ b/src/ij/plugin/frame/PlugInDialog.java
@@ -0,0 +1,61 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import ij.gui.ImageWindow;
+import ij.*;
+import ij.plugin.*;
+
+/**  This is a non-modal dialog that plugins can extend. */
+public class PlugInDialog extends Dialog implements PlugIn, WindowListener, FocusListener {
+
+	public PlugInDialog(String title) {
+		super(IJ.isMacOSX()?IJ.getInstance():null,title);
+		enableEvents(AWTEvent.WINDOW_EVENT_MASK);
+		ImageJ ij = IJ.getInstance();
+		if (IJ.isMacOSX() && ij!=null) {
+			ij.toFront(); // needed for keyboard shortcuts to work
+			IJ.wait(250);
+		}
+		addWindowListener(this);
+ 		addFocusListener(this);
+		if (IJ.isLinux()) setBackground(ImageJ.backgroundColor);
+		if (ij!=null && !IJ.isMacOSX()) {
+			Image img = ij.getIconImage();
+			if (img!=null)
+				try {setIconImage(img);} catch (Exception e) {}
+		}
+	}
+	
+	public void run(String arg) {
+	}
+	
+    public void windowClosing(WindowEvent e) {
+    	if (e.getSource()==this) {
+    		close();
+    		if (Recorder.record)
+    			Recorder.record("run", "Close");
+    	}
+    }
+    
+    /** Closes this window. */
+    public void close() {
+		//setVisible(false);
+		dispose();
+		WindowManager.removeWindow(this);
+    }
+
+	public void windowActivated(WindowEvent e) {
+		WindowManager.setWindow(this);
+	}
+
+	public void focusGained(FocusEvent e) {
+		WindowManager.setWindow(this);
+	}
+
+    public void windowOpened(WindowEvent e) {}
+    public void windowClosed(WindowEvent e) {}
+    public void windowIconified(WindowEvent e) {}
+    public void windowDeiconified(WindowEvent e) {}
+    public void windowDeactivated(WindowEvent e) {}
+	public void focusLost(FocusEvent e) {}
+}
diff --git a/src/ij/plugin/frame/PlugInFrame.java b/src/ij/plugin/frame/PlugInFrame.java
new file mode 100644
index 0000000..8282cb3
--- /dev/null
+++ b/src/ij/plugin/frame/PlugInFrame.java
@@ -0,0 +1,63 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import ij.*;
+import ij.plugin.*;
+
+/**  This is a closeable window that plugins can extend. */
+public class PlugInFrame extends Frame implements PlugIn, WindowListener, FocusListener {
+
+	String title;
+	
+	public PlugInFrame(String title) {
+		super(title);
+		enableEvents(AWTEvent.WINDOW_EVENT_MASK);
+		this.title = title;
+		ImageJ ij = IJ.getInstance();
+		addWindowListener(this);
+ 		addFocusListener(this);
+		if (IJ.isLinux()) setBackground(ImageJ.backgroundColor);
+		if (ij!=null && !IJ.isMacOSX()) {
+			Image img = ij.getIconImage();
+			if (img!=null)
+				try {setIconImage(img);} catch (Exception e) {}
+		}
+	}
+	
+	public void run(String arg) {
+	}
+	
+    public void windowClosing(WindowEvent e) {
+    	if (e.getSource()==this) {
+    		close();
+    		if (Recorder.record)
+    			Recorder.record("run", "Close");
+    	}
+    }
+    
+    /** Closes this window. */
+    public void close() {
+		//setVisible(false);
+		dispose();
+		WindowManager.removeWindow(this);
+    }
+
+    public void windowActivated(WindowEvent e) {
+		if (Prefs.setIJMenuBar) {
+			this.setMenuBar(Menus.getMenuBar());
+			Menus.setMenuBarCount++;
+		}
+		WindowManager.setWindow(this);
+	}
+
+	public void focusGained(FocusEvent e) {
+		WindowManager.setWindow(this);
+	}
+
+    public void windowOpened(WindowEvent e) {}
+    public void windowClosed(WindowEvent e) {}
+    public void windowIconified(WindowEvent e) {}
+    public void windowDeiconified(WindowEvent e) {}
+    public void windowDeactivated(WindowEvent e) {}
+	public void focusLost(FocusEvent e) {}
+}
diff --git a/src/ij/plugin/frame/Recorder.java b/src/ij/plugin/frame/Recorder.java
new file mode 100644
index 0000000..bba6c73
--- /dev/null
+++ b/src/ij/plugin/frame/Recorder.java
@@ -0,0 +1,908 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.*;
+import java.io.*;
+import ij.*;
+import ij.plugin.*;
+import ij.plugin.frame.*; 
+import ij.text.*;
+import ij.gui.*;
+import ij.util.*;
+import ij.io.*;
+import ij.process.*;
+import ij.measure.*;
+
+/** This is ImageJ's macro recorder. */
+public class Recorder extends PlugInFrame implements PlugIn, ActionListener, ImageListener, ItemListener {
+
+	/** This variable is true if the recorder is running. */
+	public static boolean record;
+	
+	/** Set this variable true to allow recording within IJ.run() calls. */
+	public static boolean recordInMacros;
+
+	private final static int MACRO=0, JAVASCRIPT=1, BEANSHELL=2, PYTHON=3, JAVA=4;
+	private final static String[] modes = {"Macro", "JavaScript", "BeanShell", "Python", "Java"};
+	private Choice mode;
+	private Button makeMacro, help;
+	private TextField fileName;
+	private String fitTypeStr = CurveFitter.fitList[0];
+	private static TextArea textArea;
+	private static Recorder instance;
+	private static String commandName;
+	private static String commandOptions;
+	private static String defaultName = "Macro.ijm";
+	private static boolean recordPath = true;
+	private static boolean scriptMode;
+	private static boolean imageUpdated;
+	private static int imageID;
+	private static boolean fgColorSet, bgColorSet;
+	private static boolean bbSet;
+
+	public Recorder() {
+		this(true);	
+	}
+
+	public Recorder(boolean showFrame) {
+		super("Recorder");
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		WindowManager.addWindow(this);
+		instance = this;
+		record = true;
+		scriptMode = false;
+		recordInMacros = false;
+		Panel panel = new Panel(new FlowLayout(FlowLayout.LEFT, 0, 0));
+		panel.add(new Label("  Record:"));
+		mode = new Choice();
+		for (int i=0; i<modes.length; i++)
+			mode.addItem(modes[i]);
+		mode.addItemListener(this);
+		String m = Prefs.get("recorder.mode", modes[MACRO]);
+		if (m.equals("Plugin")) m=modes[JAVA];
+		mode.select(m);
+		panel.add(mode);
+		panel.add(new Label("    Name:"));
+		fileName = new TextField(defaultName, 15);
+		setFileName();
+		panel.add(fileName);
+		panel.add(new Label("   "));
+		makeMacro = new Button("Create");
+		makeMacro.addActionListener(this);
+		panel.add(makeMacro);
+		panel.add(new Label("   "));
+		help = new Button("?");
+		help.addActionListener(this);
+		panel.add(help);
+		add("North", panel);
+		textArea = new TextArea("", 15, 80, TextArea.SCROLLBARS_VERTICAL_ONLY);
+		textArea.setFont(new Font("Monospaced", Font.PLAIN, 12));
+		if (IJ.isLinux()) textArea.setBackground(Color.white);
+		add("Center", textArea);
+		GUI.scale(this);
+		pack();
+		GUI.centerOnImageJScreen(this);
+		if (showFrame)
+			show();
+		IJ.register(Recorder.class);
+		fgColorSet = bgColorSet = false;
+		bbSet = false;
+	}
+	
+	public static void record(String method) {
+		if (textArea==null)
+			return;
+		textArea.append(method+"();\n");
+	}
+
+	/** Starts recording a command. Does nothing if the recorder is
+		not open or the command being recorded has called IJ.run(). 
+	*/
+	public static void setCommand(String command) {
+		String threadName = Thread.currentThread().getName();
+		boolean isMacro = threadName.startsWith("Run$_");
+		if (threadName.contains("Popup Menu") || threadName.contains("Developer Menu"))
+			isMacro = false;
+		if (textArea==null || (isMacro&&!recordInMacros))
+			return;
+		commandName = command;
+		commandOptions = null;
+		recordPath = true;
+		imageUpdated = false;
+		imageID = 0;
+		if (scriptMode) {
+			ImagePlus imp = WindowManager.getCurrentImage();
+			imageID = imp!=null?imp.getID():0;
+			if (imageID!=0)
+				ImagePlus.addImageListener(instance);
+		}
+		//IJ.log("setCommand: "+command+" "+Thread.currentThread().getName());
+	}
+
+	/** Returns the name of the command currently being recorded, or null. */
+	public static String getCommand() {
+		return commandName;
+	}
+
+	/** Replaces '\' characters with '/'. */
+	public static String fixPath (String path) {
+		if (path==null)
+			path = "";
+		if (!IJ.isWindows())
+			return path;
+		StringBuilder sb = new StringBuilder();
+		for (int i=0; i<path.length(); i++) {
+			char c=path.charAt(i);
+			if (c=='\\')
+				sb.append("/");
+			else
+				sb.append(c);
+		}
+		return new String(sb);
+	}
+	
+	/** Replaces special characters in a String for creation of a quoted macro String. Does not add quotes. */
+	public static String fixString (String str) {
+		StringBuilder sb = new StringBuilder();
+		char c;
+		for (int i=0; i<str.length(); i++) {
+			c = str.charAt(i);
+			if (c =='\\' || c=='"')
+				sb.append("\\"+c);
+			else if (c == '\n')
+				sb.append("\\n");
+			else if (c < ' ' || c > '~' && c < 0xa0) {
+				sb.append('\\');
+				String octal = Integer.toString(c,8);
+				while (octal.length()<3)
+					octal = '0' + octal;
+				sb.append(octal);
+			} else
+				sb.append(c);
+		}
+		return new String(sb);
+	}
+	
+	public static void record(String method, String arg) {
+		if (IJ.debugMode) IJ.log("record: "+method+"  "+arg);
+		boolean sw = method.equals("selectWindow");
+		if (textArea!=null && !(scriptMode&&sw||commandName!=null&&sw)) {
+			if (scriptMode && method.equals("roiManager"))
+				textArea.append("rm.runCommand(imp,\""+arg+"\");\n");
+			else if (scriptMode && method.equals("run"))
+				textArea.append("IJ."+method+"(\""+arg+"\");\n");
+			else {
+				if (method.equals("setTool"))
+					method = "//"+(scriptMode?"IJ.":"")+method;
+				textArea.append(method+"(\""+arg+"\");\n");
+			}
+		}
+	}
+
+	public static void record(String method, String arg1, String arg2) {
+		if (textArea==null) return;
+		if (arg1.equals("Open")||arg1.equals("Save")||method.equals("saveAs"))
+			arg2 = fixPath(arg2);
+		if (scriptMode&&method.equals("roiManager"))
+			textArea.append("rm.runCommand(\""+arg1+"\", \""+arg2+"\");\n");
+		else {
+			if (scriptMode && method.equals("saveAs"))
+				method = "IJ." + method;
+			textArea.append(method+"(\""+arg1+"\", \""+arg2+"\");\n");
+		}
+	}
+	
+	public static void record(String method, String arg1, String arg2, String arg3) {
+		if (textArea==null) return;
+		textArea.append(method+"(\""+arg1+"\", \""+arg2+"\",\""+arg3+"\");\n");
+	}
+
+	public static void record(String method, int a1) {
+		if (textArea==null) return;
+		textArea.append(method+"("+a1+");\n");
+	}
+
+	public static void record(String method, int a1, int a2) {
+		if (textArea==null) return;
+		textArea.append(method+"("+a1+", "+a2+");\n");
+	}
+
+	public static void record(String method, int a1, int a2, String a3) {
+		if (textArea==null) return;
+		textArea.append(method+"("+a1+", "+a2+", \""+a3+"\");\n");
+	}
+
+	public static void record(String method, double a1, double a2) {
+		if (textArea==null) return;
+		int places = Math.abs(a1)<0.0001||Math.abs(a2)<0.0001?9:4;
+		textArea.append(method+"("+IJ.d2s(a1,places)+", "+IJ.d2s(a2,places)+");\n");
+	}
+
+	public static void record(String method, int a1, int a2, int a3) {
+		if (textArea==null) return;
+		if (scriptMode&&method.endsWith("groundColor")) method = "IJ."+method;
+		textArea.append(method+"("+a1+", "+a2+", "+a3+");\n");
+	}
+
+	public static void record(String method, String a1, int a2) {
+		textArea.append(method+"(\""+a1+"\", "+a2+");\n");
+	}
+
+	public static void record(String method, String args, int a1, int a2) {
+		if (textArea==null) return;
+		textArea.append(method+"(\""+args+"\", "+a1+", "+a2+");\n");
+	}
+
+	public static void record(String method, int a1, int a2, int a3, int a4) {
+		if (textArea==null) return;
+		if (scriptMode&&method.startsWith("make")) {
+			if (method.equals("makeRectangle"))
+				recordString("imp.setRoi("+a1+","+a2+","+a3+","+a4+");\n");
+			else if (method.equals("makeOval"))
+				recordString("imp.setRoi(new OvalRoi("+a1+","+a2+","+a3+","+a4+"));\n");
+			else if (method.equals("makeLine"))
+				recordString("imp.setRoi(new Line("+a1+","+a2+","+a3+","+a4+"));\n");
+			else if (method.equals("makeArrow"))
+				recordString("imp.setRoi(new Arrow("+a1+","+a2+","+a3+","+a4+"));\n");
+		} else {
+			if (method.equals("makeArrow")) {
+				ImagePlus imp = WindowManager.getCurrentImage();
+				Roi roi = imp!=null?imp.getRoi():null;
+				if (roi!=null && (roi instanceof Line)) {
+					Arrow arrow = (Arrow)roi;
+					String options = Arrow.styles[arrow.getStyle()];
+					if (arrow.getOutline())
+						options += " outline";
+					if (arrow.getDoubleHeaded())
+						options += " double";
+					if (arrow.getHeadSize()<=5)
+						options += " small";
+					else if (arrow.getHeadSize()>=15)
+						options += " large";
+					options = options.toLowerCase();
+					int strokeWidth = (int)arrow.getStrokeWidth();
+					textArea.append(method+"("+a1+", "+a2+", "+a3+", "+a4+", \""+options+"\");\n");
+					if (strokeWidth!=1)
+						textArea.append("Roi.setStrokeWidth("+strokeWidth+");\n");
+					Color color = arrow.getStrokeColor();
+					if (color!=null)
+						textArea.append("Roi.setStrokeColor(\""+Colors.colorToString(color)+"\");\n");
+					return;
+				}
+			}
+			textArea.append(method+"("+a1+", "+a2+", "+a3+", "+a4+");\n");
+		}
+	}
+
+	public static void record(String method, int a1, int a2, int a3, int a4, int a5) {
+		textArea.append(method+"("+a1+", "+a2+", "+a3+", "+a4+", "+a5+");\n");
+	}
+	
+	public static void record(String method, int a1, int a2, int a3, int a4, double a5) {
+		textArea.append(method+"("+a1+", "+a2+", "+a3+", "+a4+", "+IJ.d2s(a5,2)+");\n");
+	}
+
+	public static void record(String method, String path, String args, int a1, int a2, int a3, int a4, int a5) {
+		if (textArea==null)
+			return;
+		path = fixPath(path);
+		method = "//"+method;
+		textArea.append(method+"(\""+path+"\", "+"\""+args+"\", "+a1+", "+a2+", "+a3+", "+a4+", "+a5+");\n");
+	}
+	
+	public static void recordString(String str) {
+		if (textArea!=null)
+			textArea.append(str);
+	}
+	
+	public static void disableCommandRecording() {
+		commandName = null;
+	}
+	
+	public static void recordCall(String call) {
+		recordCall(call, false);
+	}
+	
+	public static void recordCall(String call, boolean recordCommand) {
+		if (IJ.debugMode) IJ.log("recordCall: "+call+"  "+commandName);
+		boolean isMacro = Thread.currentThread().getName().endsWith("Macro$") && !recordInMacros;
+		if (textArea!=null && scriptMode && !IJ.macroRunning() && !isMacro) {
+			if (javaMode() && call.startsWith("rm.setSelected")) {
+				call = call.replace("[", "new int[]{");
+				call = call.replace("])", "})");
+			}
+			if (javaMode() && call.startsWith("rt = "))
+				call = "ResultTable " + call;
+			textArea.append(call+"\n");
+			if (!recordCommand)
+				commandName = null;
+ 		}
+	}
+	
+	public static void recordCall(String className, String call) {
+		recordCall(javaMode()?className+" "+call:call);
+	}
+
+	public static void recordRoi(Roi roi) {
+		if (roi==null)
+			return;
+		Polygon polygon = roi.getPolygon();
+		recordRoi(polygon, roi.getType());
+	}
+
+	public static void recordRoi(Polygon p, int type) {
+		if (textArea==null)
+			return;
+		if (scriptMode)
+			{recordScriptRoi(p,type); return;}
+		if (type==Roi.ANGLE||type==Roi.POINT) {
+			String xarr = "newArray(", yarr="newArray(";
+			xarr += p.xpoints[0]+",";
+			yarr += p.ypoints[0]+",";
+			xarr += p.xpoints[1]+",";
+			yarr += p.ypoints[1]+",";
+			xarr += p.xpoints[2]+")";
+			yarr += p.ypoints[2]+")";
+			String typeStr= type==Roi.ANGLE?"angle":"point";
+			textArea.append("makeSelection(\""+typeStr+"\","+xarr+","+yarr+");\n");
+		} else {
+			String method = type>=Roi.LINE && type<=Roi.FREELINE?"makeLine":"makePolygon";
+			StringBuffer args = new StringBuffer();
+			for (int i=0; i<p.npoints; i++) {
+				args.append(p.xpoints[i]+",");
+				args.append(""+p.ypoints[i]);
+				if (i!=p.npoints-1) args.append(",");
+			}
+			textArea.append(method+"("+args.toString()+");\n");
+		}
+	}
+
+	public static void recordScriptRoi(Polygon p, int type) {
+		StringBuffer x = new StringBuffer();
+		for (int i=0; i<p.npoints; i++) {
+			x.append(p.xpoints[i]);
+			if (i!=p.npoints-1) x.append(",");
+		}
+		String xpoints = x.toString();
+		StringBuffer y = new StringBuffer();
+		for (int i=0; i<p.npoints; i++) {
+			y.append(p.ypoints[i]);
+			if (i!=p.npoints-1) y.append(",");
+		}
+		String ypoints = y.toString();
+		if (javaMode()) {
+			textArea.append("int[] xpoints = {"+xpoints+"};\n");
+			textArea.append("int[] ypoints = {"+ypoints+"};\n");
+		} else {
+			textArea.append("xpoints = ["+xpoints+"];\n");
+			textArea.append("ypoints = ["+ypoints+"];\n");
+		}
+		String typeStr = "POLYGON";
+		switch (type) {
+			case Roi.POLYLINE: typeStr = "POLYLINE"; break;
+			case Roi.ANGLE: typeStr = "ANGLE"; break;
+		}
+		typeStr = "Roi."+typeStr;
+		if (javaMode()) {
+			if (type==Roi.POINT)
+				textArea.append("imp.setRoi(new PointRoi(xpoints,ypoints,"+p.npoints+"));\n");
+			else
+				textArea.append("imp.setRoi(new PolygonRoi(xpoints,ypoints,"+p.npoints+","+typeStr+"));\n");
+		} else {
+			if (type==Roi.POINT)
+				textArea.append("imp.setRoi(new PointRoi(xpoints,ypoints));\n");
+			else
+				textArea.append("imp.setRoi(new PolygonRoi(xpoints,ypoints,"+typeStr+"));\n");
+		}
+	}
+	
+	private static boolean javaMode() {
+		if (instance==null)
+			return false;
+		String m = instance.mode.getSelectedItem();
+		return m.equals(modes[BEANSHELL]) || m.equals(modes[JAVA]);
+	}
+	
+	public static void recordOption(String key, String value) {
+		if (key==null) return;
+		key = fixString(key);
+		key = trimKey(key);
+		value = addQuotes(value);
+		checkForDuplicate(key+"=", value);
+		if (commandOptions==null)
+			commandOptions = key+"="+value;
+		else
+			commandOptions += " "+key+"="+value;
+	}
+
+	public static void recordOpen(String path) {
+		if (!record || path==null)
+			return;
+		path = fixPath(path);
+		String s = scriptMode?"imp = IJ.openImage":"open";
+		boolean openingLut = false;
+		if (scriptMode) {
+			if (isTextOrTable(path))
+				s = "IJ.open";
+			else if (path!=null && path.endsWith(".lut")) {
+				s = "lut = Opener.openLut";
+				openingLut = true;
+			}
+		}
+		textArea.append(s+"(\""+path+"\");\n");
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (openingLut && imp!=null && !imp.getTitle().endsWith(".lut"))
+			textArea.append("imp.setLut(lut);\n");
+	}
+	
+	public static void recordPath(String key, String path) {
+		if (key==null || !recordPath) {
+			recordPath = true;
+			return;
+		}
+		key = trimKey(key);
+		path = fixPath(path);
+		path = addQuotes(path);
+		if (commandOptions!=null && commandOptions.contains(key+"="+path))
+			return; // don't record duplicate
+		checkForDuplicate(key+"=", path);
+		if (commandOptions==null || commandOptions==" ")
+			commandOptions = key+"="+path;
+		else
+			commandOptions += " "+key+"="+path;
+	}
+
+	public static void recordOption(String key) {
+		if (key==null) return;
+		if (commandOptions==null && key.equals(" "))
+			commandOptions = " ";
+		else {
+			key = trimKey(key);
+			checkForDuplicate(" "+key, "");
+			if (commandOptions==null || commandOptions==" ")
+				commandOptions = key;
+			else
+				commandOptions += " "+key;
+		}
+	}
+	
+	static void checkForDuplicate(String key, String value) {
+		if (commandOptions!=null && commandName!=null && commandOptions.indexOf(key)!=-1 && (value.equals("") || commandOptions.indexOf(value)==-1)) {
+			if (key.endsWith("=")) key = key.substring(0, key.length()-1);
+			IJ.showMessage("Recorder", "Duplicate keyword:\n \n" 
+				+ "    Command: " + "\"" + commandName +"\"\n"
+				+ "    Keyword: " + "\"" + key +"\"\n"
+				+ "    Value: " + value+"\n \n"
+				+ "Add an underscore to the corresponding label\n"
+				+ "in the dialog to make the first word unique.");
+		}
+	}
+	
+	static String trimKey(String key) {
+		int index = key.indexOf(" ");
+		if (index>-1)
+			key = key.substring(0,index);
+		index = key.indexOf(":");
+		if (index>-1)
+			key = key.substring(0,index);
+		key = key.toLowerCase(Locale.US);
+		return key;
+	}
+
+	/** Writes the current command and options to the Recorder window. */
+	public static void saveCommand() {
+		String name = commandName;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		//IJ.log("saveCommand: "+name+"  "+isSaveAs()+" "+scriptMode+"  "+commandOptions);
+		if (name!=null) {
+			if (name.equals("Duplicate Image..."))
+				name = "Duplicate...";
+			if (name.equals("Make Binary") && imp!=null && imp.getStackSize()==1) {
+				name = "Convert to Mask";
+				commandOptions = null;
+			}
+			if (commandOptions==null && (name.equals("Fill")||name.equals("Clear")||name.equals("Draw"))) {
+				Roi roi = imp!=null?imp.getRoi():null;
+				if (!(roi!=null && (roi instanceof TextRoi) && (name.equals("Draw"))))
+					commandOptions = "slice";
+			}
+			if (!fgColorSet && (name.equals("Fill")||name.equals("Draw")))
+				setForegroundColor(Toolbar.getForegroundColor());
+			else if (!bgColorSet && (name.equals("Clear")||name.equals("Clear Outside")))
+				setBackgroundColor(Toolbar.getBackgroundColor());
+			if (!bbSet && (name.equals("Convert to Mask")||name.equals("Erode")
+			||name.equals("Dilate")||name.equals("Skeletonize")))
+				setBlackBackground();
+			if (name.equals("Add Shortcut by Name... "))
+				name = "Add Shortcut... ";
+			if (commandOptions!=null) {
+				if (name.equals("Open...") || name.equals("URL..."))
+					recordOpen(strip(commandOptions));
+				else if (name.equals("TIFF Virtual Stack...") && scriptMode) {
+					String s = "imp = IJ.openVirtual";
+					String path = strip(commandOptions);
+					textArea.append(s+"(\""+path+"\");\n");
+				} else if (isSaveAs()) {
+							if (name.endsWith("..."))
+									name= name.substring(0, name.length()-3);
+							if (name.equals("Save"))
+								name = "Tiff";
+							String path = strip(commandOptions);
+							String s = scriptMode?"IJ.saveAs(imp, ":"saveAs(";
+							textArea.append(s+"\""+name+"\", \""+path+"\");\n");
+				} else if (name.equals("Image..."))
+					appendNewImage(false);
+				else if (name.equals("Hyperstack...")||name.equals("New Hyperstack..."))
+					appendNewImage(true);
+				else if (name.equals("Set Slice..."))
+					textArea.append((scriptMode?"imp.":"")+"setSlice("+strip(commandOptions)+");\n");
+				else if (name.equals("Rename..."))
+					textArea.append((scriptMode?"imp.setTitle":"rename")+"(\""+strip(commandOptions)+"\");\n");
+				else if (name.equals("Wand Tool..."))
+					textArea.append("//run(\""+name+"\", \""+commandOptions+"\");\n");
+				else if (name.equals("Results... ")&&commandOptions.indexOf(".txt")==-1)
+					textArea.append((scriptMode?"IJ.":"")+"open(\""+strip(commandOptions)+"\");\n");
+				else if (name.equals("Results...")) // Save As>Results
+					;
+				else if (name.equals("Run...")) // Plugins>Macros>Run
+					;
+				else if (scriptMode && name.equals("Text Image... ")) // File>Import>Text Image
+					;
+				else {
+					if (name.equals("Calibrate...")) {
+						if (commandOptions.startsWith("function=None unit=[Gray Value]"))
+							commandOptions = commandOptions.substring(0,13);
+						else if (commandOptions.startsWith("function=None")) {
+							int index = commandOptions.indexOf(" text1=");
+							if (index>0)
+								commandOptions = commandOptions.substring(0,index);
+						}
+					}
+					String prefix = "run(";
+					if (scriptMode) {
+						boolean addImp = imageUpdated || (WindowManager.getCurrentImage()!=null
+							&&(name.equals("Properties... ")||name.equals("Fit Spline")||commandOptions.contains("save=")));
+						if (commandOptions.contains("open="))
+							addImp = false;
+						prefix = addImp?"IJ.run(imp, ":"IJ.run(";
+					}
+					textArea.append(prefix+"\""+name+"\", \""+commandOptions+"\");\n");
+					if (nonAscii(commandOptions)) {
+						if (commandOptions!=null && !commandOptions.contains("="+IJ.micronSymbol+"m"))
+							textArea.append("  <<warning: the options string contains one or more non-ascii characters>>\n");
+					}
+				}
+			} else {
+				Roi roi = imp!=null?imp.getRoi():null;
+				if (name.equals("Threshold...") || name.equals("Fonts...") || name.equals("Brightness/Contrast...") || name.equals("Channels Tool..."))
+					textArea.append((scriptMode?"//IJ.":"//")+"run(\""+name+"\");\n");
+				else if (name.equals("Start Animation [\\]"))
+					textArea.append("doCommand(\"Start Animation [\\\\]\");\n");
+				else if (name.equals("Blobs"))
+					textArea.append("run(\"Blobs (25K)\");\n");
+				else if (name.equals("Split Channels") && scriptMode) {
+					String text = "channels = ChannelSplitter.split(imp);\n";
+					if (javaMode())
+						text = "ImagePlus[] " + text;
+					textArea.append(text);
+				} else if (name.equals("Add to Manager"))
+					;
+				else if (name.equals("Find Commands..."))
+					;
+				else if (scriptMode && name.equals("Create Mask"))
+					;
+				else if (roi!=null && (roi instanceof TextRoi) && (name.equals("Draw")||name.equals("Add Selection...")))
+					textArea.append(((TextRoi)roi).getMacroCode(name, imp));
+				else {
+					if (IJ.altKeyDown() && (name.equals("Open Next")||name.equals("Plot Profile")))
+						textArea.append("setKeyDown(\"alt\"); ");
+					if (scriptMode) {
+						boolean addImp = imageUpdated ||
+							(imp!=null&&(name.equals("Select None")||name.equals("Draw")||name.equals("Fit Spline")||name.equals("Add Selection...")));
+						String prefix = addImp?"IJ.run(imp, ":"IJ.run(";
+						textArea.append(prefix+"\""+name+"\", \"\");\n");
+					} else
+						textArea.append("run(\""+name+"\");\n");
+				}
+			}
+		}
+		commandName = null;
+		commandOptions = null;
+		if (imageID!=0) {
+			ImagePlus.removeImageListener(instance);
+			imageID = 0;
+		}
+	}
+	
+	private static boolean nonAscii(String s) {
+		int len = s!=null?s.length():0;
+		for (int i=0; i<len; i++) {
+			if (s.charAt(i)>127)
+				return true;
+		}
+		return false;
+	}
+	
+	static boolean isTextOrTable(String path) {
+		return path.endsWith(".txt") || path.endsWith(".csv") || path.endsWith(".xls") || path.endsWith(".tsv");
+	}
+	
+	static boolean isSaveAs() {
+		return commandName.equals("Tiff...")
+			|| commandName.equals("Gif...")
+			|| commandName.equals("Jpeg...")
+			|| commandName.equals("Text Image...")
+			|| commandName.equals("ZIP...")
+			|| commandName.equals("Raw Data...")
+			|| commandName.equals("BMP...")
+			|| commandName.equals("PNG...")
+			|| commandName.equals("PGM...")
+			|| commandName.equals("FITS...")
+			|| commandName.equals("LUT...")
+			|| commandName.equals("Selection...")
+			|| commandName.equals("XY Coordinates...")
+			//|| commandName.equals("Results...")
+			|| commandName.equals("Text... ")
+			|| commandName.equals("Save");
+	}
+
+	static void appendNewImage(boolean hyperstack) {
+		String options = getCommandOptions() + " ";
+		//IJ.log("appendNewImage: "+options);
+		String title = Macro.getValue(options, "name", "Untitled");
+		String type = Macro.getValue(options, "type", "8-bit");
+		String fill = Macro.getValue(options, "fill", "");
+		if (!fill.equals(""))
+			type = type +" " + fill.toLowerCase();
+		if (hyperstack) {
+			String mode = Macro.getValue(options, "display", "");
+			if (!mode.equals(""))
+				type = type +" " + mode.toLowerCase() + "-mode";
+			if (options.contains(" label"))
+				type = type +" label";
+		}
+		int width = (int)Tools.parseDouble(Macro.getValue(options, "width", "512"));
+		int height = (int)Tools.parseDouble(Macro.getValue(options, "height", "512"));
+		String d1= ", " + (int)Tools.parseDouble(Macro.getValue(options, "slices", "1"));
+		String d2="", d3="";
+		if (hyperstack) {
+			d1 = ", " + (int)Tools.parseDouble(Macro.getValue(options, "channels", "1"));
+			d2 = ", " + (int)Tools.parseDouble(Macro.getValue(options, "slices", "1"));
+			d3 = ", " + (int)Tools.parseDouble(Macro.getValue(options, "frames", "1"));
+		}
+		textArea.append((scriptMode?"imp = IJ.createImage":"newImage")
+			+"(\""+title+"\", "+"\""+type+"\", "+width+", "+height+d1+d2+d3+");\n");
+	}
+
+	static String strip(String value) {
+		int index = value.indexOf('=');
+		if (index>=0)
+			value = value.substring(index+1);
+		if (value.startsWith("[")) {
+			int index2 = value.indexOf(']');
+			if (index2==-1) index2 = value.length();
+			value = value.substring(1, index2);
+		} else {
+			index = value.indexOf(' ');
+			if (index!=-1)
+				value = value.substring(0, index);
+		}
+		return value;
+	}
+
+	static String addQuotes(String value) {
+		if (value==null)
+			value = "";
+		int index = value.indexOf(' ');
+		if (index>-1)
+			value = "["+value+"]";
+		return value;
+	}
+	
+	/** Used by GenericDialog to determine if any options have been recorded. */
+	public static String getCommandOptions() {
+		return commandOptions;
+	}
+
+	/** Used by GenericDialog.notifyListeners() to clear the command options. */
+	public static void resetCommandOptions() {
+		commandOptions = null;
+	}
+
+	void createMacro() {
+		String text = textArea.getText();
+		if (text==null || text.equals("")) {
+			IJ.showMessage("Recorder", "A macro cannot be created until at least\none command has been recorded.");
+			return;
+		}
+		String name = fileName.getText();
+		Editor ed = new Editor(name);
+		boolean java = mode.getSelectedItem().equals(modes[JAVA]);
+		boolean beanshell = mode.getSelectedItem().equals(modes[BEANSHELL]);
+		boolean python = mode.getSelectedItem().equals(modes[PYTHON]);
+		int dotIndex = name.lastIndexOf(".");
+		if (scriptMode) { // JavaScript, BeanShell, Python  or Java
+			if (dotIndex>=0) name = name.substring(0, dotIndex);
+			if (text.indexOf("rm.")!=-1) {
+				text = (java?"RoiManager ":"")+ "rm = RoiManager.getRoiManager();\n"
+				+ text;
+			}
+			if (text.contains("overlay.add"))
+				text = (java?"Overlay ":"") + "overlay = new Overlay();\n" + text;
+			if ((text.contains("imp.")||text.contains("(imp")||text.contains("overlay.add")) && !text.contains("IJ.openImage")
+			&& !text.contains("IJ.openVirtual") && !text.contains("IJ.createImage"))
+				text = (java?"ImagePlus ":"") + "imp = IJ.getImage();\n" + text;
+			if (text.contains("overlay.add"))
+				text = text + "imp.setOverlay(overlay);\n";
+			if (text.indexOf("imp =")!=-1 && !(text.indexOf("IJ.getImage")!=-1||text.indexOf("IJ.saveAs")!=-1||text.indexOf("imp.close")!=-1))
+				text = text + "imp.show();\n";
+			if (python) {
+				text = text.replaceAll("new ", "");
+				text = text.replaceAll("\n//", "\n#");
+			}
+			if (java) {
+				name += ".java";
+				createPlugin(text, name);
+				return;
+			} else if (beanshell)
+				name += ".bsh";
+			else if (python)
+				name += ".py";
+			else
+				name += ".js";
+		} else { // ImageJ macro
+			if (!name.endsWith(".txt")) {
+				if (dotIndex>=0) name = name.substring(0, dotIndex);
+				name += ".ijm";
+			}
+		}
+		ed.createMacro(name, text);
+		fgColorSet = bgColorSet = false;
+		bbSet = false;
+	}
+	
+	void createPlugin(String text, String name) {
+		StringTokenizer st = new StringTokenizer(text, "\n");
+		int n = st.countTokens();
+		boolean impDeclared = false;
+		boolean lutDeclared = false;
+		String line;
+		StringBuffer sb = new StringBuffer();
+		for (int i=0; i<n; i++) {
+			line = st.nextToken();
+			if (line!=null && line.length()>3) {
+				sb.append("\t\t");
+				if (line.startsWith("imp =") && !impDeclared) {
+					sb.append("ImagePlus ");
+					impDeclared = true;
+				}
+				if (line.startsWith("lut =") && !lutDeclared) {
+					sb.append("LUT ");
+					lutDeclared = true;
+				}
+				sb.append(line);
+				sb.append('\n');
+			}
+		}
+		String text2 = new String(sb);
+		text2 = text2.replaceAll("print", "IJ.log");
+		NewPlugin np = (NewPlugin)IJ.runPlugIn("ij.plugin.NewPlugin", text2);
+		Editor ed = np.getEditor();
+		ed.updateClassName(ed.getTitle(), name);
+		ed.setTitle(name);
+	}
+
+	/** Temporarily disables path recording. */
+	public static void disablePathRecording() {
+		recordPath = false;
+	}
+	
+	public static boolean scriptMode() {
+		return scriptMode;
+	}
+	
+	public void actionPerformed(ActionEvent e) {
+		if (e.getSource()==makeMacro)
+			createMacro();
+		else if (e.getSource()==help)
+			showHelp();
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		setFileName();
+		Prefs.set("recorder.mode", mode.getSelectedItem());
+	}
+	
+	void setFileName() {
+		String name = mode.getSelectedItem();
+		scriptMode = !name.equals(modes[MACRO]);
+		if (name.equals(modes[MACRO]))
+			fileName.setText("Macro.ijm");
+		else if (name.equals(modes[JAVASCRIPT]))
+			fileName.setText("Script.js");
+		else if (name.equals(modes[BEANSHELL]))
+			fileName.setText("Script.bsh");
+		else if (name.equals(modes[PYTHON]))
+			fileName.setText("Script.py");
+		else
+			fileName.setText("My_Plugin.java");
+		fgColorSet = bgColorSet = false;
+		bbSet = false;
+	}
+
+	public void imageUpdated(ImagePlus imp) {
+		if (imp.getID()==imageID)
+			imageUpdated = true;
+	}
+
+	public void imageOpened(ImagePlus imp) { }
+
+	public void imageClosed(ImagePlus imp) { }
+
+    void showHelp() {
+    	IJ.showMessage("Recorder",
+			"Click \"Create\" to open recorded commands\n"  
+			+"as a macro in an editor window.\n" 
+			+" \n" 
+			+"In the editor:\n" 
+			+" \n"
+			+"    Type ctrl+R (Macros>Run Macro) to\n" 
+			+"    run the macro.\n"     
+			+" \n"    
+			+"    Use File>Save As to save it and\n" 
+			+"    ImageJ's Open command to open it.\n" 
+			+" \n"    
+			+"    To create a command, save in the plugins\n"  
+			+"    folder and run Help>Refresh Menus.\n"  
+		);
+    }
+    
+	public void close() {
+		super.close();
+		record = false;
+		textArea = null;
+		commandName = null;
+		instance = null;	
+	}
+
+	public String getText() {
+		if (textArea==null)
+			return "";
+		else
+			return textArea.getText();
+	}
+	
+	public static Recorder getInstance() {
+		return instance;
+	}
+	
+	public static void setForegroundColor(Color c) {
+		record("setForegroundColor", c.getRed(), c.getGreen(), c.getBlue());
+		fgColorSet = true;
+	}
+	
+	public static void setBackgroundColor(Color c) {
+		record("setBackgroundColor", c.getRed(), c.getGreen(), c.getBlue());
+		bgColorSet = true;
+	}
+	
+	public static void setBlackBackground() {
+		String bb = Prefs.blackBackground?"true":"false";
+		if (scriptMode)
+			recordString("Prefs.blackBackground = "+bb+";\n");
+		else
+			recordString("setOption(\"BlackBackground\", "+bb+");\n");
+		bbSet = true;
+	}
+	
+	/** Override windowActivated in PlugInFrame. */
+	public void windowActivated(WindowEvent e) {
+		if (IJ.isMacintosh() && !IJ.isJava17())
+			this.setMenuBar(Menus.getMenuBar());
+		WindowManager.setWindow(this);
+	}
+	
+}
diff --git a/src/ij/plugin/frame/RoiManager.java b/src/ij/plugin/frame/RoiManager.java
new file mode 100644
index 0000000..0fb8bdc
--- /dev/null
+++ b/src/ij/plugin/frame/RoiManager.java
@@ -0,0 +1,2852 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import java.io.*;
+import java.util.*;
+import java.awt.List;
+import java.util.zip.*;
+import java.awt.geom.*;
+
+import javax.swing.DefaultListModel;
+import javax.swing.JList;
+import javax.swing.JScrollPane;
+import javax.swing.ListSelectionModel;
+import javax.swing.ScrollPaneConstants;
+import javax.swing.event.ListSelectionEvent;
+import javax.swing.event.ListSelectionListener;
+
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.io.*;
+import ij.plugin.filter.*;
+import ij.plugin.Colors;
+import ij.plugin.OverlayLabels;
+import ij.plugin.FolderOpener;
+import ij.util.*;
+import ij.macro.*;
+import ij.measure.*;
+import ij.plugin.OverlayCommands;
+
+/** This plugin implements the Analyze/Tools/ROI Manager command. */
+public class RoiManager extends PlugInFrame implements ActionListener, ItemListener, MouseListener, MouseWheelListener, ListSelectionListener, Iterable<Roi> {
+	public static final String LOC_KEY = "manager.loc";
+	private static final String MULTI_CROP_DIR = "multi-crop.dir";
+	private static final int BUTTONS = 11;
+	private static final int DRAW=0, FILL=1, LABEL=2;
+	private static final int SHOW_ALL=0, SHOW_NONE=1, LABELS=2, NO_LABELS=3;
+	private static final int MENU=0, COMMAND=1;
+	private static final int IGNORE_POSITION=-999;  // ignore the ROI's built in position
+	private static final int CHANNEL=0, SLICE=1, FRAME=2, SHOW_DIALOG=3;
+	private static int rows = 15;
+	private static int lastNonShiftClick = -1;
+	private static boolean allowMultipleSelections = true;
+	private static String moreButtonLabel = "More "+'\u00bb';
+	private Panel panel;
+	private static Frame instance;
+	private static int colorIndex = 4;
+	private JList list;
+	private DefaultListModel listModel;
+	private ArrayList rois = new ArrayList();
+	private boolean canceled;
+	private boolean macro;
+	private boolean ignoreInterrupts;
+	private PopupMenu pm;
+	private Button moreButton, colorButton;
+	private Checkbox showAllCheckbox = new Checkbox("Show All", false);
+	private Checkbox labelsCheckbox = new Checkbox("Labels", false);
+	private Overlay overlayTemplate;
+
+	private static boolean measureAll = true;
+	private static boolean onePerSlice = true;
+	private static boolean restoreCentered;
+	private int prevID;
+	private boolean noUpdateMode;
+	private int defaultLineWidth = 1;
+	private Color defaultColor;
+	private boolean firstTime = true;
+	private boolean appendResults;
+	private static ResultsTable mmResults, mmResults2;
+	private int imageID;
+	private boolean allowRecording;
+	private boolean recordShowAll = true;
+	private boolean allowDuplicates;
+	private double translateX = 10.0;
+	private double translateY = 10.0;
+	private static String errorMessage;
+	private boolean multiCropShow = true;
+	private boolean multiCropSave;
+	private int multiCropFormatIndex;
+
+	/** Opens the "ROI Manager" window, or activates it if it is already open.
+	 * @see #RoiManager(boolean)
+	 * @see #getRoiManager
+	*/
+	public RoiManager() {
+		super("ROI Manager");
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		if (IJ.isMacro() && Interpreter.getBatchModeRoiManager()!=null) {
+			list = new JList();
+			listModel = new DefaultListModel();
+			list.setModel(listModel);
+			return;
+		}
+		instance = this;
+		list = new JList();
+		errorMessage = null;
+		showWindow();
+	}
+
+	/** Constructs an ROIManager without displaying it. The boolean argument is ignored. */
+	public RoiManager(boolean b) {
+		super("ROI Manager");
+		list = new JList();
+		listModel = new DefaultListModel();
+		list.setModel(listModel);
+		errorMessage = null;
+	}
+
+	void showWindow() {
+		ImageJ ij = IJ.getInstance();
+		addKeyListener(ij);
+		addMouseListener(this);
+		addMouseWheelListener(this);
+		WindowManager.addWindow(this);
+		//setLayout(new FlowLayout(FlowLayout.CENTER,5,5));
+		setLayout(new BorderLayout());
+		listModel = new DefaultListModel();
+		list.setModel(listModel);
+		GUI.scale(list);
+		list.setPrototypeCellValue("0000-0000-0000 ");
+		list.addListSelectionListener(this);
+		list.addKeyListener(ij);
+		list.addMouseListener(this);
+		list.addMouseWheelListener(this);
+		if (IJ.isLinux()) list.setBackground(Color.white);
+		JScrollPane scrollPane = new JScrollPane(list, ScrollPaneConstants.VERTICAL_SCROLLBAR_ALWAYS, ScrollPaneConstants.HORIZONTAL_SCROLLBAR_NEVER);
+		add("Center", scrollPane);
+		panel = new Panel();
+		int nButtons = BUTTONS;
+		panel.setLayout(new GridLayout(nButtons, 1, 5, 0));
+		addButton("Add [t]");
+		addButton("Update");
+		addButton("Delete");
+		addButton("Rename...");
+		addButton("Measure");
+		addButton("Deselect");
+		addButton("Properties...");
+		addButton("Flatten [F]");
+		addButton(moreButtonLabel);
+		showAllCheckbox.addItemListener(this);
+		panel.add(showAllCheckbox);
+		labelsCheckbox.addItemListener(this);
+		panel.add(labelsCheckbox);
+		add("East", panel);
+		addPopupMenu();
+		GUI.scale(this);
+		pack();
+		Dimension size = getSize();
+		if (size.width>270)
+			setSize(size.width-40, size.height);
+		list.remove(0);
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null)
+			setLocation(loc);
+		else
+			GUI.centerOnImageJScreen(this);
+		show();
+	}
+
+	void addButton(String label) {
+		Button b = new Button(label);
+		b.addActionListener(this);
+		b.addKeyListener(IJ.getInstance());
+		b.addMouseListener(this);
+		if (label.equals(moreButtonLabel)) moreButton = b;
+		panel.add(b);
+	}
+
+	void addPopupMenu() {
+		pm = new PopupMenu();
+		GUI.scalePopupMenu(pm);
+		addPopupItem("Open...");
+		addPopupItem("Save...");
+		addPopupItem("Fill");
+		addPopupItem("Draw");
+		addPopupItem("AND");
+		addPopupItem("OR (Combine)");
+		addPopupItem("XOR");
+		addPopupItem("Split");
+		addPopupItem("Add Particles");
+		addPopupItem("Multi Measure");
+		addPopupItem("Multi Plot");
+		addPopupItem("Multi Crop");
+		addPopupItem("Sort");
+		addPopupItem("Specify...");
+		addPopupItem("Remove Positions...");
+		addPopupItem("Labels...");
+		addPopupItem("List");
+		addPopupItem("Interpolate ROIs");
+		addPopupItem("Translate...");
+		addPopupItem("Help");
+		addPopupItem("Options...");
+		add(pm);
+	}
+
+	void addPopupItem(String s) {
+		MenuItem mi=new MenuItem(s);
+		mi.addActionListener(this);
+		pm.add(mi);
+	}
+
+	public void actionPerformed(ActionEvent e) {
+		String label = e.getActionCommand();
+		if (label==null)
+			return;
+		String command = label;
+		allowRecording = true;
+		if (command.equals("Add [t]"))
+			runCommand("add");
+		else if (command.equals("Update"))
+			update(true);
+		else if (command.equals("Delete"))
+			delete(false);
+		else if (command.equals("Rename..."))
+			rename(null);
+		else if (command.equals("Properties..."))
+			setProperties(null, -1, null);
+		else if (command.equals("Flatten [F]"))
+			flatten();
+		else if (command.equals("Measure"))
+			measure(getImage());
+		else if (command.equals("Open..."))
+			open(null);
+		else if (command.equals("Save...")) {
+			Thread t1 = new Thread(new Runnable() {
+				public void run() {
+					save(null);
+				}
+			});
+			t1.start();
+		} else if (command.equals("Fill"))
+			drawOrFill(FILL);
+		else if (command.equals("Draw"))
+			drawOrFill(DRAW);
+		else if (command.equals("Deselect"))
+			deselect();
+		else if (command.equals(moreButtonLabel)) {
+			Point ploc = panel.getLocation();
+			Point bloc = moreButton.getLocation();
+			pm.show(this, ploc.x, bloc.y);
+		} else if (command.equals("OR (Combine)")) {
+			new MacroRunner("roiManager(\"Combine\");");
+			if (Recorder.record) Recorder.record("roiManager", "Combine");
+		} else if (command.equals("Split"))
+			split();
+		else if (command.equals("AND"))
+			and();
+		else if (command.equals("XOR"))
+			xor();
+		else if (command.equals("Add Particles"))
+			addParticles();
+		else if (command.equals("Multi Measure"))
+			multiMeasure("");
+		else if (command.equals("Multi Plot"))
+			multiPlot();
+		else if (command.equals("Multi Crop"))
+			multiCrop();
+		else if (command.equals("Sort"))
+			sort();
+		else if (command.equals("Specify..."))
+			specify();
+		else if (command.equals("Remove Positions..."))
+			removePositions(SHOW_DIALOG);
+		else if (command.equals("Labels..."))
+			labels();
+		else if (command.equals("List"))
+			listRois();
+		else if (command.equals("Interpolate ROIs"))
+			interpolateRois();
+		else if (command.equals("Translate..."))
+			translate();
+		else if (command.equals("Help"))
+			help();
+		else if (command.equals("Options..."))
+			options();
+		else if (command.equals("\"Show All\" Color..."))
+			setShowAllColor();
+		allowRecording = false;
+	}
+
+	private void interpolateRois() {
+		IJ.runPlugIn("ij.plugin.RoiInterpolator", "");
+		if (record())
+			Recorder.record("roiManager", "Interpolate ROIs");
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+		Object source = e.getSource();
+		boolean showAllMode = showAllCheckbox.getState();
+		if (source==showAllCheckbox) {
+			if (firstTime && okToSet())
+				labelsCheckbox.setState(true);
+			showAll(showAllCheckbox.getState()?SHOW_ALL:SHOW_NONE);
+			if (Recorder.record && recordShowAll) {
+				if (showAllMode)
+						Recorder.record("roiManager", "Show All");
+					else
+						Recorder.record("roiManager", "Show None");
+			}
+			recordShowAll = true;
+			firstTime = false;
+			return;
+		}
+		if (source==labelsCheckbox) {
+			if (firstTime && okToSet())
+				showAllCheckbox.setState(true);
+			boolean editState = labelsCheckbox.getState();
+			boolean showAllState = showAllCheckbox.getState();
+			if (!showAllState && !editState)
+				showAll(SHOW_NONE);
+			else {
+				showAll(editState?LABELS:NO_LABELS);
+				if (Recorder.record) {
+					if (editState)
+						Recorder.record("roiManager", "Show All with labels");
+					else if (showAllState)
+						Recorder.record("roiManager", "Show All without labels");
+				}
+				if (editState && !showAllState && okToSet()) {
+					showAllCheckbox.setState(true);
+					recordShowAll = false;
+				}
+			}
+			firstTime = false;
+			return;
+		}
+	}
+
+	private boolean okToSet() {
+		return !(IJ.isMacOSX()&&IJ.isJava18());
+	}
+
+	void add(boolean shiftKeyDown, boolean altKeyDown) {
+		if (shiftKeyDown)
+			addAndDraw(altKeyDown);
+		else if (altKeyDown)
+			addRoi(true);
+		else
+			addRoi(false);
+	}
+
+	/** Adds the specified ROI. */
+	public void addRoi(Roi roi) {
+		allowDuplicates = true;
+		addRoi(roi, false, null, -1);
+	}
+
+	boolean addRoi(boolean promptForName) {
+		return addRoi(null, promptForName, null, IGNORE_POSITION);
+	}
+
+	boolean addRoi(Roi roi, boolean promptForName, Color color, int lineWidth) {
+		if (listModel==null)
+			IJ.log("<<Error: Uninitialized RoiManager>>");
+		ImagePlus imp = roi==null?getImage():WindowManager.getCurrentImage();
+		if (roi==null) {
+			if (imp==null)
+				return false;
+			roi = imp.getRoi();
+			if (roi==null) {
+				error("The active image does not have a selection.");
+				return false;
+			}
+		}
+		if ((roi instanceof PolygonRoi) && ((PolygonRoi)roi).getNCoordinates()==0)
+			return false;
+		if (color==null && roi.getStrokeColor()!=null)
+			color = roi.getStrokeColor();
+		else if (color==null && defaultColor!=null)
+			color = defaultColor;
+		boolean ignorePosition = false;
+		if (lineWidth==IGNORE_POSITION) {
+			ignorePosition = true;
+			lineWidth = -1;
+		}
+		if (lineWidth<0) {
+			int sw = (int)roi.getStrokeWidth();
+			lineWidth = sw>1?sw:defaultLineWidth;
+		}
+		if (lineWidth>100) lineWidth = 1;
+		int n = getCount();
+		int position = imp!=null&&!ignorePosition?roi.getPosition():0;
+		int saveCurrentSlice = imp!=null?imp.getCurrentSlice():0;
+		if (position>0 && position!=saveCurrentSlice) {
+			if (imp.lock())
+				imp.setSliceWithoutUpdate(position);
+			else
+				return false;	//can't lock image, must not change the stack slice
+		} else
+			position = 0;		//we need to revert to the original stack slice and unlock if position>0
+		if (n>0 && !IJ.isMacro() && imp!=null && !allowDuplicates) {
+			// check for duplicate
+			Roi roi2 = (Roi)rois.get(n-1);
+			if (roi2!=null) {
+				String label = (String)listModel.getElementAt(n-1);
+				int slice2 = getSliceNumber(roi2, label);
+				if (roi.equals(roi2) && (slice2==-1||slice2==imp.getCurrentSlice()) && imp.getID()==prevID && !Interpreter.isBatchMode()) {
+					if (position>0) {
+						imp.setSliceWithoutUpdate(saveCurrentSlice);
+						imp.unlock();
+					}
+					return false;
+				}
+			}
+		}
+		allowDuplicates = false;
+		prevID = imp!=null?imp.getID():0;
+		String name = roi.getName();
+		if (isStandardName(name))
+			name = null;
+		String label = name!=null?name:getLabel(imp, roi, -1);
+		if (promptForName)
+			label = promptForName(label);
+		if (label==null) {
+			if (position>0) {
+				imp.setSliceWithoutUpdate(saveCurrentSlice);
+				imp.unlock();
+			}
+			return false;
+		}
+		listModel.addElement(label);
+		roi.setName(label);
+		Roi roiCopy = (Roi)roi.clone();
+		if (ignorePosition && imp!=null && imp.getStackSize()>1 && imp.getWindow()!=null && isVisible()) {
+ 			// set ROI position to current stack position if image and RoiManager are visible
+			roiCopy.setPosition(imp);
+		}
+		if (lineWidth>1)
+			roiCopy.setStrokeWidth(lineWidth);
+		if (color!=null)
+			roiCopy.setStrokeColor(color);
+		rois.add(roiCopy);
+		updateShowAll();
+		if (record())
+			recordAdd(defaultColor, defaultLineWidth);
+		if (position>0) {
+			imp.setSliceWithoutUpdate(saveCurrentSlice);
+			imp.unlock();
+		}
+		return true;
+	}
+
+	void recordAdd(Color color, int lineWidth) {
+		if (Recorder.scriptMode())
+			Recorder.recordCall("rm.addRoi(roi);");
+		else if (color!=null && lineWidth==1)
+			Recorder.recordString("roiManager(\"Add\", \""+getHex(color)+"\");\n");
+		else if (lineWidth>1)
+			Recorder.recordString("roiManager(\"Add\", \""+getHex(color)+"\", "+lineWidth+");\n");
+		else
+			Recorder.record("roiManager", "Add");
+	}
+
+	String getHex(Color color) {
+		if (color==null) color = ImageCanvas.getShowAllColor();
+		String hex = Integer.toHexString(color.getRGB());
+		if (hex.length()==8) hex = hex.substring(2);
+		return hex;
+	}
+
+	/** Adds the specified ROI to the list. The second argument ('n') will
+	 * be used to form the first part of the ROI label if it is zero or greater.
+	 * @param roi		the Roi to be added
+	 * @param n		if zero or greater, will be used to form the first part of the label
+	*/
+	public void add(Roi roi, int n) {
+		add((ImagePlus)null, roi, n);
+	}
+
+	/** Adds the specified ROI to the list. The third argument ('n') will
+	 * be used to form the first part of the ROI label if it is zero or greater.
+	 * @param imp	the image associated with the ROI, or null
+	 * @param roi		the Roi to be added
+	 * @param n		if zero or greater, will be used to form the first part of the label
+	*/
+	public void add(ImagePlus imp, Roi roi, int n) {
+		if (IJ.debugMode && n<3 && roi!=null) IJ.log("RoiManager.add: "+n+" "+roi.getName());
+		if (roi==null)
+			return;
+		String label = roi.getName();
+		String label2 = label;
+		if (label==null)
+			label = getLabel(imp, roi, n);
+		else {
+			if (n>=0)
+				label = n+"-"+label;
+		}
+		if (label==null)
+			return;
+		listModel.addElement(label);
+		if (label2!=null)
+			roi.setName(label2);
+		else
+			roi.setName(label);
+		rois.add((Roi)roi.clone());
+	}
+
+	/** Replaces the ROI at the specified index. */
+	public void setRoi(Roi roi, int index) {
+    	if (index<0 || index>=rois.size())
+    		throw new IllegalArgumentException("setRoi: Index out of range");
+		rois.set(index, (Roi)roi.clone());
+		updateShowAll();
+	}
+
+	boolean isStandardName(String name) {
+		if (name==null)
+			return false;
+		int len = name.length();
+		if (len<9 || (len>0&&!Character.isDigit(name.charAt(0))))
+			return false;
+		boolean isStandard = false;
+		if (len>=14 && name.charAt(4)=='-' && name.charAt(9)=='-' )
+			isStandard = true;
+		else if (len>=17 && name.charAt(5)=='-' && name.charAt(11)=='-' )
+			isStandard = true;
+		else if (len>=9 && name.charAt(4)=='-')
+			isStandard = true;
+		else if (len>=11 && name.charAt(5)=='-')
+			isStandard = true;
+		return isStandard;
+	}
+
+	String getLabel(ImagePlus imp, Roi roi, int n) {
+		Rectangle r = roi.getBounds();
+		int xc = r.x + r.width/2;
+		int yc = r.y + r.height/2;
+		if (n>=0)
+			{xc = yc; yc=n;}
+		if (xc<0) xc = 0;
+		if (yc<0) yc = 0;
+		int digits = 4;
+		String xs = "" + xc;
+		if (xs.length()>digits) digits = xs.length();
+		String ys = "" + yc;
+		if (ys.length()>digits) digits = ys.length();
+		if (digits==4 && imp!=null && (imp.getStackSize()>=10000||imp.getHeight()>=10000))
+			digits = 5;
+		xs = "000000" + xc;
+		ys = "000000" + yc;
+		String label = ys.substring(ys.length()-digits) + "-" + xs.substring(xs.length()-digits);
+		if (imp!=null && imp.getStackSize()>1) {
+			int slice = imp.getCurrentSlice();
+			String zs = "000000" + slice;
+			label = zs.substring(zs.length()-digits) + "-" + label;
+		}
+		return label;
+	}
+
+	void addAndDraw(boolean altKeyDown) {
+		if (altKeyDown) {
+			if (!addRoi(true)) return;
+		} else if (!addRoi(false))
+			return;
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			Undo.setup(Undo.COMPOUND_FILTER, imp);
+			IJ.run(imp, "Draw", "slice");
+			Undo.setup(Undo.COMPOUND_FILTER_DONE, imp);
+		}
+		if (record()) Recorder.record("roiManager", "Add & Draw");
+	}
+
+	boolean delete(boolean replacing) {
+		int count = getCount();
+		if (count==0)
+			return error("The ROI Manager is empty.");
+		int index[] = getSelectedIndexes();
+		if (index.length==0 || (replacing&&count>1)) {
+			String msg = "Delete all items on the list?";
+			if (replacing)
+				msg = "Replace items on the list?";
+			canceled = false;
+			if (!IJ.isMacro() && !macro) {
+				YesNoCancelDialog d = new YesNoCancelDialog(this, "ROI Manager", msg);
+				if (d.cancelPressed())
+					{canceled = true; return false;}
+				if (!d.yesPressed()) return false;
+			}
+			index = getAllIndexes();
+		}
+		if (count==index.length && !replacing) {
+			rois.clear();
+			listModel.removeAllElements();
+		} else {
+			for (int i=count-1; i>=0; i--) {
+				boolean delete = false;
+				for (int j=0; j<index.length; j++) {
+					if (index[j]==i)
+						delete = true;
+				}
+				if (delete) {
+					if (EventQueue.isDispatchThread()) {
+ 						rois.remove(i);
+						listModel.remove(i);
+ 					} else
+ 						deleteOnEDT(i);
+				}
+			}
+		}
+		ImagePlus imp = WindowManager.getCurrentImage();
+		//if (count>1 && index.length==1 && imp!=null)
+		//	imp.deleteRoi();
+		updateShowAll();
+		if (record())
+			Recorder.record("roiManager", "Delete");
+		return true;
+	}
+
+	 // Delete ROI on event dispatch thread
+	 private void deleteOnEDT(final int i) {
+		try {
+			EventQueue.invokeAndWait(new Runnable() {
+				public void run() {
+					rois.remove(i);
+					listModel.remove(i);
+				}
+			});
+		} catch (
+			Exception e) {
+		}
+	}
+
+	boolean update(boolean clone) {
+		ImagePlus imp = getImage();
+		if (imp==null)
+			return false;
+		ImageCanvas ic = imp.getCanvas();
+		boolean showingAll = ic!=null &&  ic.getShowAllROIs();
+		Roi roi = imp.getRoi();
+		if (roi==null) {
+			error("The active image does not have a selection.");
+			return false;
+		}
+		int index = list.getSelectedIndex();
+		if (index<0 && !showingAll)
+			return error("Exactly one item in the list must be selected.");
+		if (index>=0) {
+			if (clone) {
+				String name = (String)listModel.getElementAt(index);
+				Roi roi2 = (Roi)roi.clone();
+				roi2.setPosition(imp);
+				roi.setName(name);
+				roi2.setName(name);
+				rois.set(index, roi2);
+			} else
+				rois.set(index, roi);
+		}
+		if (record()) Recorder.record("roiManager", "Update");
+		updateShowAll();
+		return true;
+	}
+
+	boolean rename(String name2) {
+		int index = list.getSelectedIndex();
+		if (index<0)
+			return error("Exactly one item in the list must be selected.");
+		String name = (String)listModel.getElementAt(index);
+		if (name2==null)
+			name2 = promptForName(name);
+		if (name2==null)
+			return false;
+		if (name2.equals(name))
+			return false;
+		Roi roi = (Roi)rois.get(index);
+		roi.setName(name2);
+		int position = getSliceNumber(name2);
+		if (position>0 && !roi.hasHyperStackPosition())
+			roi.setPosition(position);
+		rois.set(index, roi);
+		listModel.setElementAt(name2, index);
+		list.setSelectedIndex(index);
+		if (Prefs.useNamesAsLabels && labelsCheckbox.getState()) {
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null) imp.draw();
+		}
+		if (record())
+			Recorder.record("roiManager", "Rename", name2);
+		return true;
+	}
+
+	public void rename(int index, String newName) {
+		if (index<0 || index>=getCount())
+			throw new IllegalArgumentException("Index out of range: "+index);
+		Roi roi = (Roi)rois.get(index);
+		roi.setName(newName);
+		listModel.setElementAt(newName, index);
+	}
+
+	String promptForName(String name) {
+		GenericDialog gd = new GenericDialog("ROI Manager");
+		gd.addStringField("Rename As:", name, 20);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return null;
+		else
+			return gd.getNextString();
+	}
+
+	boolean restore(ImagePlus imp, int index, boolean setSlice) {
+		Roi roi = (Roi)rois.get(index);
+		if (imp==null || roi==null)
+			return false;
+			//IJ.log("restore: "+roi.getPosition()+"  "+roi.getZPosition()+"  "+imp.getNSlices()+"  "+imp.getStackSize());
+		if (setSlice) {
+			boolean hyperstack = imp.isHyperStack();
+			int position = roi.getPosition();
+			if (hyperstack && roi.hasHyperStackPosition())
+				imp.setPosition(roi.getCPosition(), roi.getZPosition(), roi.getTPosition());
+			else if (hyperstack && imp.getNSlices()==1)
+				imp.setPosition(imp.getChannel(), 1, position);
+			else if (hyperstack)
+				imp.setPosition(imp.getChannel(), position, imp.getChannel());
+			else if (roi.getZPosition()>0 && imp.getNSlices()==imp.getStackSize())
+				imp.setSlice(roi.getZPosition());
+			else if (position>0 && position<=imp.getStackSize())
+				imp.setSlice(position);
+			else {
+				String label = (String)listModel.getElementAt(index);
+				int n = getSliceNumber(roi, label);
+				if (n>=1 && n<=imp.getStackSize()) {
+					if (hyperstack) {
+						if (imp.getNSlices()>1 && n<=imp.getNSlices())
+							imp.setPosition(imp.getC(),n,imp.getT());
+						else if (imp.getNFrames()>1 && n<=imp.getNFrames())
+							imp.setPosition(imp.getC(),imp.getZ(),n);
+						else
+							imp.setPosition(n);
+					} else
+						imp.setSlice(n);
+				}
+			}
+		}	
+		if (showAllCheckbox.getState() && !restoreCentered && !noUpdateMode) {
+			roi.setImage(null);
+			imp.setRoi(roi);
+			return true;
+		}
+		Roi roi2 = (Roi)roi.clone();
+		Rectangle r = roi2.getBounds();
+		int width= imp.getWidth(), height=imp.getHeight();
+		if (restoreCentered) {
+			ImageCanvas ic = imp.getCanvas();
+			if (ic!=null) {
+				Rectangle r1 = ic.getSrcRect();
+				Rectangle r2 = roi2.getBounds();
+				roi2.setLocation(r1.x+r1.width/2-r2.width/2, r1.y+r1.height/2-r2.height/2);
+			}
+		}
+		if (r.x>=width || r.y>=height || (r.x+r.width)<0 || (r.y+r.height)<0) {
+			if (roi2.getType()!=Roi.POINT)
+				roi2.setLocation((width-r.width)/2, (height-r.height)/2);
+		}
+		if (noUpdateMode) {
+			imp.setRoi(roi2, false);
+			noUpdateMode = false;
+		} else
+			imp.setRoi(roi2, true);
+		return true;
+	}
+
+	private boolean restoreWithoutUpdate(ImagePlus imp, int index) {
+		noUpdateMode = true;
+		if (imp==null)
+			imp = getImage();
+		return restore(imp, index, false);
+	}
+
+	/** Returns the slice number associated with the specified name,
+		or -1 if the name does not include a slice number. */
+	public int getSliceNumber(String label) {
+		int slice = -1;
+		if (label.length()>=14 && label.charAt(4)=='-' && label.charAt(9)=='-')
+			slice = (int)Tools.parseDouble(label.substring(0,4),-1);
+		else if (label.length()>=17 && label.charAt(5)=='-' && label.charAt(11)=='-')
+			slice = (int)Tools.parseDouble(label.substring(0,5),-1);
+		else if (label.length()>=20 && label.charAt(6)=='-' && label.charAt(13)=='-')
+			slice = (int)Tools.parseDouble(label.substring(0,6),-1);
+		return slice;
+	}
+
+	/** Returns the slice number associated with the specified ROI or name,
+		or -1 if the ROI or name does not include a slice number. */
+	int getSliceNumber(Roi roi, String label) {
+		int slice = roi!=null?roi.getPosition():-1;
+		if (slice==0)
+			slice=-1;
+		if (slice==-1)
+			slice = getSliceNumber(label);
+		return slice;
+	}
+
+	/** Opens a single .roi file or a ZIP-compressed set of ROIs.
+	 *	Returns 'true' if the operation was succesful.
+	*/
+	public boolean open(String path) {
+		Macro.setOptions(null);
+		String name = null;
+		if (path==null || path.equals("")) {
+			OpenDialog od = new OpenDialog("Open Selection(s)...", "");
+			String directory = od.getDirectory();
+			name = od.getFileName();
+			if (name==null)
+				return false;
+			path = directory + name;
+		}
+		if (Recorder.record && !IJ.macroRunning()) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("rm.open(\""+path+"\");");
+			else
+				Recorder.record("roiManager", "Open", path);
+		}
+		boolean ok = false;
+		if (path.endsWith(".zip")) {
+			boolean wasRecording = Recorder.record;
+			Recorder.record = false;
+			ok = openZip(path);
+			Recorder.record = wasRecording;
+			return ok;
+		}
+		Opener o = new Opener();
+		if (name==null) name = o.getName(path);
+		Roi roi = o.openRoi(path);
+		if (roi!=null) {
+			if (roi.getName()!=null)
+				name = roi.getName();
+			if (name.endsWith(".roi"))
+				name = name.substring(0, name.length()-4);
+			listModel.addElement(name);
+			rois.add(roi);
+			errorMessage = null;
+			ok = true;
+		} else {
+			errorMessage = "Unable to open ROI at "+path;
+			ok = false;
+		}
+		updateShowAll();
+		return ok;
+	}
+
+	// Modified on 2005/11/15 by Ulrik Stervbo to only read .roi files and to not empty the current list
+	boolean openZip(String path) {
+		ZipInputStream in = null;
+		ByteArrayOutputStream out = null;
+		int nRois = 0;
+		errorMessage = null;
+		try {
+			in = new ZipInputStream(new FileInputStream(path));
+			byte[] buf = new byte[1024];
+			int len;
+			ZipEntry entry = in.getNextEntry();
+			while (entry!=null) {
+				String name = entry.getName();
+				if (name.endsWith(".roi")) {
+					out = new ByteArrayOutputStream();
+					while ((len = in.read(buf)) > 0)
+						out.write(buf, 0, len);
+					out.close();
+					byte[] bytes = out.toByteArray();
+					RoiDecoder rd = new RoiDecoder(bytes, name);
+					Roi roi = rd.getRoi();
+					if (roi!=null) {
+						name = name.substring(0, name.length()-4);
+						listModel.addElement(name);
+						rois.add(roi);
+						nRois++;
+					}
+				}
+				entry = in.getNextEntry();
+			}
+			in.close();
+		} catch (IOException e) {
+			errorMessage = e.toString();
+			error(errorMessage);
+		} finally {
+			if (in!=null)
+				try {in.close();} catch (IOException e) {}
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		if (nRois==0 && errorMessage==null) {
+			errorMessage = "This ZIP archive does not contain \".roi\" files: " + path;
+			error(errorMessage);
+		}
+		updateShowAll();
+		return errorMessage==null;
+	}
+
+	/** If one ROI is selected, it is saved as a .roi
+	 * file, if multiple (or no) ROIs are selected,
+	 * they are saved as a .zip ROI set. Returns 
+	 * 'true' if the save operation was succesful.
+	 * @see #setSelectedIndexes
+	*/
+	public boolean save(String path) {
+		if (getCount()==0)
+			return error("The selection list is empty.");
+		int[] indexes = getIndexes();
+		if (indexes.length>1)
+			return saveMultiple(indexes, path);
+		else
+			return saveOne(indexes, path);
+
+	}
+
+	boolean saveOne(int[] indexes, String path) {
+		if (indexes.length==0)
+			return error("The list is empty");
+		Roi roi = (Roi)rois.get(indexes[0]);
+		if (path==null) {
+			Macro.setOptions(null);
+			String name = (String) listModel.getElementAt(indexes[0]);
+			SaveDialog sd = new SaveDialog("Save Selection...", name, ".roi");
+			String name2 = sd.getFileName();
+			if (name2 == null)
+				return false;
+			String dir = sd.getDirectory();
+			if (!name2.endsWith(".roi")) name2 = name2+".roi";
+			String newName = name2.substring(0, name2.length()-4);
+			rois.set(indexes[0], roi);
+			roi.setName(newName);
+			listModel.setElementAt(newName, indexes[0]);
+			path = dir+name2;
+		}
+		RoiEncoder re = new RoiEncoder(path);
+		errorMessage = null;
+		try {
+			re.write(roi);
+		} catch (IOException e) {
+			errorMessage = e.getMessage();
+			IJ.error("ROI Manager", errorMessage);
+		}
+		if (Recorder.record && !IJ.isMacro()) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("rm.save(\""+path+"\");");
+			else
+				Recorder.record("roiManager", "Save", path);
+		}
+		return true;
+	}
+
+	boolean saveMultiple(int[] indexes, String path) {
+		Macro.setOptions(null);
+		if (path==null || path.equals("")) {
+			SaveDialog sd = new SaveDialog("Save ROIs...", "RoiSet", ".zip");
+			String name = sd.getFileName();
+			if (name == null)
+				return false;
+			if (!(name.endsWith(".zip") || name.endsWith(".ZIP")))
+				name = name + ".zip";
+			String dir = sd.getDirectory();
+			path = dir+name;
+		}
+		DataOutputStream out = null;
+		IJ.showStatus("Saving "+indexes.length+" ROIs "+" to "+path);
+		long t0 = System.currentTimeMillis();
+		String[] names = new String[listModel.size()];
+		for (int i=0; i<listModel.size(); i++)
+			names[i] = (String)listModel.getElementAt(i);
+		errorMessage = null;
+		try {
+			ZipOutputStream zos = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
+			out = new DataOutputStream(new BufferedOutputStream(zos));
+			RoiEncoder re = new RoiEncoder(out);
+			for (int i=0; i<indexes.length; i++) {
+				IJ.showProgress(i, indexes.length);
+				String label = getUniqueName(names, indexes[i]);
+				Roi roi = (Roi)rois.get(indexes[i]);
+				if (IJ.debugMode) IJ.log("saveMultiple: "+i+"  "+label+"  "+roi);
+				if (roi==null) continue;
+				if (!label.endsWith(".roi")) label += ".roi";
+				zos.putNextEntry(new ZipEntry(label));
+				re.write(roi);
+				out.flush();
+			}
+			out.close();
+		} catch (IOException e) {
+			errorMessage = ""+e;
+			error(errorMessage);
+			return false;
+		} finally {
+			if (out!=null)
+				try {out.close();} catch (IOException e) {}
+		}
+		double time = (System.currentTimeMillis()-t0)/1000.0;
+		IJ.showProgress(1.0);
+		IJ.showStatus(IJ.d2s(time,3)+" seconds, "+indexes.length+" ROIs, "+path);
+		if (Recorder.record && !IJ.isMacro()) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("rm.save(\""+path+"\");");
+			else
+				Recorder.record("roiManager", "Save", path);
+		}
+		return true;
+	}
+
+	String getUniqueName(String[] names, int index) {
+		String name = names[index];
+		int n = 1;
+		int index2 = getIndex(names, index, name);
+		while (index2!=-1) {
+			index2 = getIndex(names, index, name);
+			if (index2!=-1) {
+				int lastDash = name.lastIndexOf("-");
+				if (lastDash!=-1 && name.length()-lastDash<5)
+					name = name.substring(0, lastDash);
+				name = name+"-"+n;
+				n++;
+			}
+			index2 = getIndex(names, index, name);
+		}
+		names[index] = name;
+		return name;
+	}
+
+	private int getIndex(String[] names, int index, String name) {
+		int index2 = -1;
+		for (int i=0; i<names.length; i++) {
+			if (i!=index && names[i].equals(name))
+			return i;
+		}
+		return index2;
+	}
+
+	private void listRois() {
+		Roi[] list = getRoisAsArray();
+		OverlayCommands.listRois(list);
+		if (record())
+			Recorder.record("roiManager", "List");
+	}
+
+	boolean measure(ImagePlus imp) {
+		if (imp==null)
+			return false;
+		int[] indexes = getIndexes();
+		if (indexes.length==0) return false;
+		boolean allSliceOne = true;
+		if (imp.getStackSize() > 1) // do we have to change the stack slice for one of the rois?
+			for (int i=0; i<indexes.length; i++) {
+				Roi roi = (Roi)rois.get(indexes[i]);
+				String label = (String) listModel.getElementAt(indexes[i]);
+				if (getSliceNumber(roi,label)>1 || roi.hasHyperStackPosition()) {
+					allSliceOne=false;
+					break;
+				}
+			}
+		if (!allSliceOne)
+			if (!imp.lock()) return false;	// if we can't lock, we must not change the stack slice
+		int measurements = Analyzer.getMeasurements();
+		if (imp.getStackSize()>1)
+			Analyzer.setMeasurements(measurements|Measurements.SLICE);
+		int currentSlice = imp.getCurrentSlice();
+		Analyzer.setMeasurements(measurements&(~Measurements.ADD_TO_OVERLAY));
+		for (int i=0; i<indexes.length; i++) {
+			noUpdateMode = true;
+			if (restore(imp, indexes[i], !allSliceOne))
+				IJ.run(imp, "Measure", "");
+			else
+				break;
+		}
+		Analyzer.setMeasurements(measurements);
+		imp.setSlice(currentSlice);
+		if (indexes.length>1)
+			imp.deleteRoi();
+		if (record()) Recorder.record("roiManager", "Measure");
+		if (!allSliceOne)
+			imp.unlock();
+		return true;
+	}
+
+	/** This method measures the selected ROIs, or all ROIs if
+	 * none are selected, on all the slices of a stack and returns
+	 * a ResultsTable arranged with one row per slice.
+	 * @see <a href="http://imagej.nih.gov/ij/macros/js/MultiMeasureDemo.js">JavaScript example</a>
+	*/
+	public ResultsTable multiMeasure(ImagePlus imp) {
+		Roi[] rois = getSelectedRoisAsArray();
+		ResultsTable rt = multiMeasure(imp, rois, false);
+		imp.deleteRoi();
+		return rt;
+	}
+
+	/** This method performs measurements for several ROI's in a stack
+		and arranges the results with one line per slice.  By contrast, the
+		measure() method produces several lines per slice.	The results
+		from multiMeasure() may be easier to import into a spreadsheet
+		program for plotting or additional analysis. Based on the multi()
+		method in Bob Dougherty's Multi_Measure plugin
+		(http://www.optinav.com/Multi-Measure.htm).
+	*/
+	boolean multiMeasure(String cmd) {
+		ImagePlus imp = getImage();
+		if (imp==null) return false;
+		int[] indexes = getIndexes();
+		if (indexes.length==0) {
+			error("Multi-measure: no selection");
+			return false;
+		}
+		if (!imp.lock())
+			return false;
+		int measurements = Analyzer.getMeasurements();
+
+		int nSlices = imp.getStackSize();
+		if (cmd!=null)
+			appendResults = cmd.contains("append")?true:false;
+		if (IJ.isMacro()) {
+			if (cmd.startsWith("multi-measure")) {
+				measureAll = cmd.contains(" measure") && nSlices>1; // measure-all
+				onePerSlice = cmd.contains(" one");
+				appendResults = cmd.contains(" append");
+			} else {
+				if (nSlices>1)
+					measureAll = true;
+				onePerSlice = true;
+			}
+		} else {
+			GenericDialog gd = new GenericDialog("Multi Measure");
+			if (nSlices>1)
+				gd.addCheckbox("Measure all "+nSlices+" slices", measureAll);
+			gd.addCheckbox("One row per slice", onePerSlice);
+			gd.addCheckbox("Append results", appendResults);
+			int columns = getColumnCount(imp, measurements)*indexes.length;
+			String str = nSlices==1?"this option":"both options";
+			gd.setInsets(10, 25, 0);
+			gd.addMessage(
+				"Enabling "+str+" will result\n"+
+				"in a table with "+columns+" columns."
+			);
+			gd.showDialog();
+			if (gd.wasCanceled()) {
+				imp.unlock();
+				return false;
+			}
+			if (nSlices>1)
+				measureAll = gd.getNextBoolean();
+			onePerSlice = gd.getNextBoolean();
+			appendResults = gd.getNextBoolean();
+		}
+		if (!measureAll) nSlices = 1;
+		int currentSlice = imp.getCurrentSlice();
+
+		if (!onePerSlice) {
+			int measurements2 = nSlices>1?measurements|Measurements.SLICE:measurements;
+			ResultsTable rt = new ResultsTable();
+			rt.showRowNumbers(true);
+			if (appendResults && mmResults2!=null)
+				rt = mmResults2;
+			Analyzer analyzer = new Analyzer(imp, measurements2, rt);
+			analyzer.disableReset(true);
+			for (int slice=1; slice<=nSlices; slice++) {
+				if (nSlices>1) imp.setSliceWithoutUpdate(slice);
+				for (int i=0; i<indexes.length; i++) {
+					if (restoreWithoutUpdate(imp, indexes[i]))
+						analyzer.measure();
+					else
+						break;
+				}
+			}
+			mmResults2 = (ResultsTable)rt.clone();
+			rt.show("Results");
+			if (nSlices>1)
+				imp.setSlice(currentSlice);
+		} else {
+			Roi[] rois = getSelectedRoisAsArray();
+			if ("".equals(cmd)) { // run More>>Multi Measure command in separate thread
+				MultiMeasureRunner mmr = new MultiMeasureRunner();
+				mmr.multiMeasure(imp, rois, appendResults);
+			} else {
+				ResultsTable rtMulti = multiMeasure(imp, rois, appendResults);
+				mmResults = (ResultsTable)rtMulti.clone();
+				rtMulti.show("Results");
+				imp.setSlice(currentSlice);
+				if (indexes.length>1)
+					IJ.run("Select None");
+			}
+		}
+		if (record()) {
+			if (Recorder.scriptMode()) {
+				Recorder.recordCall("rt = rm.multiMeasure(imp);");
+				Recorder.recordCall("rt.show(\"Results\");");
+			} else {
+				if ((nSlices==1||measureAll) && onePerSlice && !appendResults)
+					Recorder.record("roiManager", "Multi Measure");
+				else {
+					String options = "";
+					if (measureAll)
+						options += " measure_all";
+					if (onePerSlice)
+						options += " one";
+					if (appendResults)
+						options += " append";
+					Recorder.record("roiManager", "multi-measure"+options);
+				}
+			}
+		}
+		imp.unlock();
+		return true;
+	}
+
+	private static ResultsTable multiMeasure(ImagePlus imp, Roi[] rois, boolean appendResults) {
+		int nSlices = imp.getStackSize();
+		Analyzer aSys = new Analyzer(imp); // System Analyzer
+		ResultsTable rtSys = Analyzer.getResultsTable();
+		ResultsTable rtMulti = new ResultsTable();
+		rtMulti.showRowNumbers(true);
+		if (appendResults && mmResults!=null)
+			rtMulti = mmResults;
+		rtSys.reset();
+		int currentSlice = imp.getCurrentSlice();
+		for (int slice=1; slice<=nSlices; slice++) {
+			int sliceUse = slice;
+			if (nSlices==1) sliceUse = currentSlice;
+			imp.setSliceWithoutUpdate(sliceUse);
+			rtMulti.incrementCounter();
+			if ((Analyzer.getMeasurements()&Measurements.LABELS)!=0)
+				rtMulti.addLabel("Label", imp.getTitle());
+			int roiIndex = 0;
+			for (int i=0; i<rois.length; i++) {
+				imp.setRoi(rois[i]);
+				roiIndex++;
+				aSys.measure();
+				for (int j=0; j<=rtSys.getLastColumn(); j++){
+					float[] col = rtSys.getColumn(j);
+					String head = rtSys.getColumnHeading(j);
+					String suffix = ""+roiIndex;
+					Roi roi = imp.getRoi();
+					if (roi!=null) {
+						String name = roi.getName();
+						if (name!=null && name.length()>0 && (name.length()<9||!Character.isDigit(name.charAt(0))))
+							suffix = "("+name+")";
+					}
+					if (head!=null && col!=null && !head.equals("Slice"))
+						rtMulti.addValue(head+suffix, rtSys.getValue(j,rtSys.getCounter()-1));
+				}
+			}
+			if (nSlices>1) IJ.showProgress(slice,nSlices);
+		}
+		return rtMulti;
+	}
+
+	int getColumnCount(ImagePlus imp, int measurements) {
+		ImageStatistics stats = imp.getStatistics(measurements);
+		ResultsTable rt = new ResultsTable();
+		rt.showRowNumbers(true);
+		Analyzer analyzer = new Analyzer(imp, measurements, rt);
+		analyzer.saveResults(stats, null);
+		int count = 0;
+		for (int i=0; i<=rt.getLastColumn(); i++) {
+			float[] col = rt.getColumn(i);
+			String head = rt.getColumnHeading(i);
+			if (head!=null && col!=null)
+				count++;
+		}
+		return count;
+	}
+
+	void multiPlot() {
+		ImagePlus imp = getImage();
+		if (imp==null) return;
+		int[] indexes = getIndexes();
+		int n = indexes.length;
+		if (n==0) return;
+		if (!imp.lock()) return;
+		Color[] colors = {Color.blue, Color.green, Color.magenta, Color.red, Color.cyan, Color.yellow};
+		if (n>colors.length) {
+			colors = new Color[n];
+			double c = 0;
+			double inc =150.0/n;
+			for (int i=0; i<n; i++) {
+				colors[i] = new Color((int)c, (int)c, (int)c);
+				c += inc;
+			}
+		}
+		int currentSlice = imp.getCurrentSlice();
+		double[][] x = new double[n][];
+		double[][] y = new double[n][];
+		double minY = Double.MAX_VALUE;
+		double maxY = -Double.MAX_VALUE;
+		double fixedMin = ProfilePlot.getFixedMin();
+		double fixedMax = ProfilePlot.getFixedMax();
+		boolean freeYScale = fixedMin==0.0 && fixedMax==0.0;
+		if (!freeYScale) {
+			minY = fixedMin;
+			maxY = fixedMax;
+		}
+		int maxX = 0;
+		Calibration cal = imp.getCalibration();
+		double xinc = cal.pixelWidth;
+		for (int i=0; i<indexes.length; i++) {
+			if (!restore(getImage(), indexes[i], true)) break;
+			Roi roi = imp.getRoi();
+			if (roi==null) break;
+			if (roi.isArea() && roi.getType()!=Roi.RECTANGLE)
+				IJ.run(imp, "Area to Line", "");
+			ProfilePlot pp = new ProfilePlot(imp, Prefs.verticalProfile||IJ.altKeyDown());
+			y[i] = pp.getProfile();
+			if (y[i]==null) break;
+			if (y[i].length>maxX) maxX = y[i].length;
+			if (freeYScale) {
+				double[] a = Tools.getMinMax(y[i]);
+				if (a[0]<minY) minY=a[0];
+				if (a[1]>maxY) maxY = a[1];
+			}
+			double[] xx = new double[y[i].length];
+			for (int j=0; j<xx.length; j++)
+				xx[j] = j*xinc;
+			x[i] = xx;
+		}
+		String xlabel = "Distance ("+cal.getUnits()+")";
+		Plot plot = new Plot("Profiles",xlabel, "Value", x[0], y[0]);
+		plot.setLimits(0, maxX*xinc, minY, maxY);
+		for (int i=1; i<indexes.length; i++) {
+			plot.setColor(colors[i]);
+			if (x[i]!=null)
+				plot.addPoints(x[i], y[i], Plot.LINE);
+		}
+		plot.setColor(colors[0]);
+		if (x[0]!=null)
+			plot.show();
+		imp.setSlice(currentSlice);
+		if (indexes.length>1)
+			IJ.run("Select None");
+		if (record()) Recorder.record("roiManager", "Multi Plot");
+		imp.unlock();
+	}
+		
+	private void multiCrop() {
+		ImagePlus imp = getImage();
+		if (imp==null)
+			return;
+		int[] indexes = getIndexes();
+		int n = indexes.length;
+		String directory = Prefs.get(MULTI_CROP_DIR, IJ.getDir("downloads")+"stack/");
+		String[] formats = {"tif", "png", "jpg"};
+		GenericDialog gd = new GenericDialog("Multi Crop");
+		gd.setInsets(5, 0, 0);
+		gd.addDirectoryField("Dir:", directory);		
+		gd.setInsets(2, 70, 10);
+		gd.addMessage("drag and drop target", IJ.font10, Color.darkGray);
+		gd.addChoice("Format:", formats, formats[multiCropFormatIndex]);
+		gd.addCheckbox("Show "+n+" cropped images:", multiCropShow);
+		gd.addCheckbox("Save "+n+" cropped images:", multiCropSave);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		directory = gd.getNextString();
+		directory = IJ.addSeparator(directory);
+		Prefs.set(MULTI_CROP_DIR, directory);
+		multiCropFormatIndex = gd.getNextChoiceIndex();
+		String format = formats[multiCropFormatIndex];	
+		multiCropShow = gd.getNextBoolean();
+		multiCropSave = gd.getNextBoolean();
+		String options = "";
+		if (multiCropShow) options += " show";
+		if (multiCropSave) {
+			options += " save";
+			options += " "+format;
+		}
+		if (record()) {
+			String dir = Recorder.fixPath(directory);
+			if (Recorder.scriptMode())			
+				Recorder.recordCall("rm.multiCrop(\""+dir+"\", \""+options+"\");");
+			else
+				Recorder.record("RoiManager.multiCrop", dir, options);
+		}
+		multiCrop(directory, options);
+	}
+	
+	public void multiCrop(String directory, String options) {
+		ImagePlus imp = getImage();
+		if (imp==null)
+			return;
+		Roi roiOrig = imp.getRoi();
+		Roi[] rois = getSelectedRoisAsArray();
+		ImagePlus[] images = imp.crop(rois);
+		if (options==null) options = "";
+		if (options.contains("show")) {
+			ImageStack stack = ImageStack.create(images);			
+			ImagePlus imgStack = new ImagePlus("CROPPED_"+getTitle(),stack);
+			Overlay overlay = Overlay.createStackOverlay(rois);
+			imgStack.setOverlay(overlay);
+			imgStack.show();
+			if (roiOrig==null)
+				imp.deleteRoi();
+		}
+		if (options.contains("save")) {
+			String format = "tif";
+			if (options.contains("png")) format = "png";
+			if (options.contains("jpg")) format = "jpg";
+			for (int i=0; i<images.length; i++) {
+				Rectangle bounds = rois[i].getBounds();
+				String title = IJ.pad(bounds.x,4)+"-"+IJ.pad(bounds.y,4);
+				String path = directory + title + "." + format;
+				IJ.saveAs(images[i], format, path);
+			}
+			/*
+			if (options.contains("show")) {
+				int width = 1;
+				int height = 1;
+				for (int i=0; i<rois.length; i++) {
+					Rectangle bounds = rois[i].getBounds();
+					if (bounds.width>width) width = bounds.width;
+					if (bounds.height>height) height = bounds.height;
+				}
+				imp = FolderOpener.open(directory, width, height, "virtual");
+				if (imp!=null) imp.show();
+			}
+			*/
+		}
+	}
+
+	/** Sets the group for the selected ROIs. */ 
+	public void setGroup(int group) {
+		int[] indexes = getIndexes();
+		for (int i: indexes) {
+			Roi roi = getRoi(i);
+			roi.setGroup(group);
+		}
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) imp.draw();
+	}
+
+	/** Sets the position for the selected ROIs. */ 
+	public void setPosition(int position) {
+		int[] indexes = getIndexes();
+		for (int i: indexes) {
+			Roi roi = getRoi(i);
+			roi.setPosition(position);
+		}
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) imp.draw();
+	}
+
+	/** Obsolete; replaced by RoiManager.setGroup() macro function. */
+	public static void setGroup(String group) {
+		RoiManager rm = getInstance();
+		if (rm==null) return;
+		int groupInt = (int)Tools.parseDouble(group,0);
+		if (groupInt>0)
+			rm.setGroup(groupInt);
+	}
+
+	boolean drawOrFill(int mode) {
+		int[] indexes = getIndexes();
+		ImagePlus imp = getImage();
+		if (imp==null) return false;
+		if (!imp.lock()) return false;
+		imp.deleteRoi();
+		ImageProcessor ip = imp.getProcessor();
+		ip.setColor(Toolbar.getForegroundColor());
+		ip.snapshot();
+		Undo.setup(Undo.FILTER, imp);
+		Filler filler = mode==LABEL?new Filler():null;
+		int slice = imp.getCurrentSlice();
+		for (int i=0; i<indexes.length; i++) {
+			Roi roi = (Roi)rois.get(indexes[i]);
+			int type = roi.getType();
+			if (roi==null) continue;
+			if (mode==FILL&&(type==Roi.POLYLINE||type==Roi.FREELINE||type==Roi.ANGLE))
+				mode = DRAW;
+			String name = (String) listModel.getElementAt(indexes[i]);
+			int slice2 = getSliceNumber(roi, name);
+			if (slice2>=1 && slice2<=imp.getStackSize()) {
+				imp.setSlice(slice2);
+				ip = imp.getProcessor();
+				ip.setColor(Toolbar.getForegroundColor());
+				if (slice2!=slice) Undo.reset();
+			}
+			switch (mode) {
+				case DRAW: roi.drawPixels(ip); break;
+				case FILL: ip.fill(roi); break;
+				case LABEL:
+					roi.drawPixels(ip);
+					filler.drawLabel(imp, ip, i+1, roi.getBounds());
+					break;
+			}
+		}
+		if (record() && (mode==DRAW||mode==FILL))
+			Recorder.record("roiManager", mode==DRAW?"Draw":"Fill");
+		if (showAllCheckbox.getState())
+			runCommand("show none");
+		imp.updateAndDraw();
+		imp.unlock();
+		return true;
+	}
+
+	void setProperties(Color color, int lineWidth, Color fillColor) {
+		boolean showDialog = color==null && lineWidth==-1 && fillColor==null;
+		int[] indexes = getIndexes();
+		int n = indexes.length;
+		if (n==0) return;
+		Roi rpRoi = null;
+		String rpName = null;
+		Font font = null;
+		int justification = TextRoi.LEFT;
+		String roiText = null;
+		double opacity = -1;
+		int pointType = -1;
+		int pointSize = -1;
+		int group = -1;
+		int position = -1;
+		if (showDialog) {
+			//String label = (String) listModel.getElementAt(indexes[0]);
+			rpRoi = (Roi)rois.get(indexes[0]);
+			if (n==1) {
+				fillColor =	 rpRoi.getFillColor();
+				rpName = rpRoi.getName();
+			}
+			if (rpRoi.getStrokeColor()==null)
+				rpRoi.setStrokeColor(Roi.getColor());
+			rpRoi = (Roi) rpRoi.clone();
+			if (n>1)
+				rpRoi.setName("range: "+(indexes[0]+1)+"-"+(indexes[n-1]+1));
+			rpRoi.setFillColor(fillColor);
+			RoiProperties rp = new RoiProperties("Properties ", rpRoi); // " "=show "List coordinates"
+			if (!rp.showDialog())
+				return;
+			// Recover parameters of the Property window that were stored in the "transient" roi
+			lineWidth = (int)rpRoi.getStrokeWidth();
+			defaultLineWidth = lineWidth;
+			color =	 rpRoi.getStrokeColor();
+			fillColor =	 rpRoi.getFillColor();
+			group = rpRoi.getGroup();
+			position = rpRoi.getPosition();
+			defaultColor = color;
+			if (rpRoi instanceof TextRoi) {
+				font = ((TextRoi)rpRoi).getCurrentFont();
+				justification = ((TextRoi)rpRoi).getJustification();
+				roiText = ((TextRoi)rpRoi).getText();
+			}
+			if (rpRoi instanceof ImageRoi)
+				opacity = ((ImageRoi)rpRoi).getOpacity();
+			if (rpRoi instanceof PointRoi) {
+				pointType = ((PointRoi)rpRoi).getPointType();
+				pointSize = ((PointRoi)rpRoi).getSize();
+			}
+		}
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (n==getCount() && n>1 && !IJ.isMacro() && imp!=null && imp.getWindow()!=null) {
+			GenericDialog gd = new GenericDialog("ROI Manager");
+			gd.addMessage("Apply changes to all "+n+" selections?");
+			gd.showDialog();
+			if (gd.wasCanceled()) return;
+		}
+		for (int i=0; i<n; i++) {
+			Roi roi = (Roi)rois.get(indexes[i]);
+			if (roi==null) continue;
+			if (color!=null)
+				roi.setStrokeColor(color);
+			if (lineWidth>=0)
+				roi.setStrokeWidth(lineWidth);
+			roi.setFillColor(fillColor);
+			if (group>=0)
+				roi.setGroup(group);
+			if (rpRoi!=null) {
+				if (rpRoi.hasHyperStackPosition())
+					roi.setPosition(rpRoi.getCPosition(), rpRoi.getZPosition(), rpRoi.getTPosition());
+				else
+					roi.setPosition(rpRoi.getPosition());
+			}
+			if ((roi instanceof TextRoi) && showDialog) {
+				roi.setImage(imp);
+				if (font!=null)
+					((TextRoi)roi).setCurrentFont(font);
+				((TextRoi)roi).setJustification(justification);
+				if (n==1) ((TextRoi)roi).setText(roiText);
+				roi.setImage(null);
+			}
+			if ((roi instanceof ImageRoi) && opacity!=-1)
+				((ImageRoi)roi).setOpacity(opacity);
+			if (roi instanceof PointRoi) {
+				if (pointType!=-1) ((PointRoi)roi).setPointType(pointType);
+				if (pointSize!=-1) ((PointRoi)roi).setSize(pointSize);
+			}
+		}
+		if (rpRoi!=null && rpName!=null && !rpRoi.getName().equals(rpName))
+			rename(rpRoi.getName());
+		ImageCanvas ic = imp!=null?imp.getCanvas():null;
+		Roi roi = imp!=null?imp.getRoi():null;
+		boolean showingAll = ic!=null &&  ic.getShowAllROIs();
+		if (roi!=null && (n==1||!showingAll)) {
+			if (lineWidth>=0) roi.setStrokeWidth(lineWidth);
+			if (color!=null) roi.setStrokeColor(color);
+			if (group>=0) roi.setGroup(group);
+			if (fillColor!=null) roi.setFillColor(fillColor);
+			if (roi!=null && (roi instanceof TextRoi)) {
+				((TextRoi)roi).setCurrentFont(font);
+				((TextRoi)roi).setJustification(justification);
+				((TextRoi)roi).setText(roiText);
+			}
+			if (roi!=null && (roi instanceof ImageRoi) && opacity!=-1)
+				((ImageRoi)roi).setOpacity(opacity);
+		}
+		if (lineWidth>1 && !showingAll && roi==null) {
+			showAll(SHOW_ALL);
+			showingAll = true;
+		}
+		if (imp!=null) imp.draw();
+		if (record()) {
+			if (group>=0) {
+				if (Recorder.scriptMode())
+					Recorder.recordCall("rm.setGroup("+group+");");
+				else
+					Recorder.record("RoiManager.setGroup", group);
+			}
+			if (position>=0) {
+				if (Recorder.scriptMode())
+					Recorder.recordCall("rm.setPosition("+position+");");
+				else
+					Recorder.record("RoiManager.setPosition", position);
+			}
+			if (fillColor!=null)
+				Recorder.record("roiManager", "Set Fill Color", Colors.colorToString(fillColor));
+			else {
+				if (group==0)
+					Recorder.record("roiManager", "Set Color", Colors.colorToString(color!=null?color:Color.red));
+				Recorder.record("roiManager", "Set Line Width", lineWidth);
+			}
+		}
+	}
+
+	void flatten() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			{IJ.noImage(); return;}
+		ImageCanvas ic = imp.getCanvas();
+		if ((ic!=null && ic.getShowAllList()==null) && imp.getOverlay()==null && imp.getRoi()==null)
+			error("Image does not have an overlay or ROI");
+		else
+			IJ.doCommand("Flatten"); // run Image>Flatten in separate thread
+	}
+
+	public boolean getDrawLabels() {
+		return labelsCheckbox.getState();
+	}
+
+	private void combine() {
+		ImagePlus imp = getImage();
+		if (imp==null)
+			return;
+		Roi[] rois = getSelectedRoisAsArray();
+		if (rois.length==1 && !IJ.isMacro()) {
+			error("More than one item must be selected, or none");
+			return;
+		}
+		if (countPointRois(rois)==rois.length)
+			combinePoints(imp, rois);
+		else
+			combineRois(imp, rois);
+	}
+
+	private int countPointRois(Roi[] rois) {
+		int nPointRois = 0;
+		for (Roi roi : rois)
+			if (roi.getType()==Roi.POINT)
+				nPointRois++;
+		return nPointRois;
+	}
+
+	private void combineRois(ImagePlus imp, Roi[] rois) {
+		if (rois.length==1) {
+		    Roi roi2 = (Roi)rois[0].clone();
+		    roi2.setPosition(0);
+		    roi2.setGroup(0);
+			imp.setRoi(roi2);
+			return;
+		}
+		IJ.resetEscape();
+		ShapeRoi s1=null, s2=null;
+		for (int i=0; i<rois.length; i++) {
+			IJ.showProgress(i, rois.length-1);
+			if (IJ.escapePressed()) {
+				IJ.showProgress(1.0);
+				return;
+			}
+			Roi roi = rois[i];
+			if (!roi.isArea() && roi.getType()!=Roi.POINT) 
+			 roi = Roi.convertLineToArea(roi);
+			if (s1==null) {
+				if (roi instanceof ShapeRoi)
+					s1 = (ShapeRoi)roi.clone();
+				else
+					s1 = new ShapeRoi(roi);
+				if (s1==null) return;
+			} else {
+				if (roi instanceof ShapeRoi)
+					s2 = (ShapeRoi)roi;
+				else
+					s2 = new ShapeRoi(roi);
+				if (s2==null) continue;
+				s1.or(s2);
+			}
+		}
+		if (s1!=null)
+			imp.setRoi(s1.trySimplify());
+	}
+
+	void combinePoints(ImagePlus imp, Roi[] rois) {
+		int n = rois.length;
+		FloatPolygon fp = new FloatPolygon();
+		for (int r=0; r<n; r++) {
+			FloatPolygon fpi = rois[r].getFloatPolygon();
+			for (int i=0; i<fpi.npoints; i++)
+				fp.addPoint(fpi.xpoints[i], fpi.ypoints[i]);
+		}
+		imp.setRoi(new PointRoi(fp));
+	}
+
+	/** calculates the intersection of area, line and point selections.
+	 *  If there is one PointRoi in the list of selected Rois, the points inside all selected area rois are kept.
+	 *  If more than one PointRoi is selected, the PointRois get converted to area rois with each pixel containing
+	 *  at least one point selected. */
+	void and() {
+		ImagePlus imp = getImage();
+		if (imp==null) return;
+		Roi[] rois = getSelectedRoisAsArray();
+		if (rois.length==1) {
+			error("More than one item must be selected, or none");
+			return;
+		}
+		int nPointRois = countPointRois(rois);
+		ShapeRoi s1=null;
+		PointRoi pointRoi = null;
+		for (Roi roi : rois) {
+			if (roi==null)
+				continue;
+			if (s1==null) {
+				if (nPointRois==1 && roi.getType() == Roi.POINT) {
+					pointRoi = (PointRoi)roi;
+					continue;  //PointRoi will be handled at the end
+				}
+				if (roi instanceof ShapeRoi)
+					s1 = (ShapeRoi)roi.clone();
+				else
+					s1 = new ShapeRoi(roi);
+				if (s1==null) continue;
+			} else {
+				if (nPointRois==1 && roi.getType()==Roi.POINT) {
+					pointRoi = (PointRoi)roi;
+					continue;  //PointRoi will be handled at the end
+				}
+				ShapeRoi s2 = null;
+				if (roi instanceof ShapeRoi)
+					s2 = (ShapeRoi)roi.clone();
+				else
+					s2 = new ShapeRoi(roi);
+				if (s2==null) continue;
+				s1.and(s2);
+			}
+		}
+		if (s1==null) return;
+		if (pointRoi!=null)
+			imp.setRoi(pointRoi.containedPoints(s1));
+		else
+			imp.setRoi(s1.trySimplify());
+		if (record())
+			Recorder.record("roiManager", "AND");
+	}
+
+	void xor() {
+		ImagePlus imp = getImage();
+		if (imp==null) return;
+		Roi[] rois = getSelectedRoisAsArray();
+		if (rois.length==1) {
+			error("More than one item must be selected, or none");
+			return;
+		}
+		Roi roi2 = Roi.xor(getSelectedRoisAsArray());
+		if (roi2!=null) imp.setRoi(roi2);
+		if (record()) Recorder.record("roiManager", "XOR");
+	}
+
+	void addParticles() {
+		String err = IJ.runMacroFile("ij.jar:AddParticles", null);
+		if (err!=null && err.length()>0)
+			error(err);
+	}
+
+	void sort() {
+		int n = listModel.size();
+		if (n==0)
+			return;
+		String[] labels = new String[n];
+		for (int i=0; i<n; i++)
+			labels[i] = (String)listModel.get(i);
+		int[] indices = Tools.rank(labels);
+		Roi[] rois2 = getRoisAsArray();
+		listModel.removeAllElements();
+		rois.clear();
+		for (int i=0; i<labels.length; i++) {
+			listModel.addElement(labels[indices[i]]);
+			rois.add(rois2[indices[i]]);
+		}
+		if (record()) Recorder.record("roiManager", "Sort");
+	}
+
+	void specify() {
+		try {IJ.run("Specify...");}
+		catch (Exception e) {return;}
+		runCommand("add");
+	}
+
+	private static boolean channel=false, slice=true, frame=false;
+
+	private void removePositions(int position) {
+		int[] indexes = getIndexes();
+		if (indexes.length==0)
+			return;
+		boolean removeChannels = position==CHANNEL;
+		boolean removeFrames = position==FRAME;
+		boolean removeSlices = !(removeChannels||removeFrames);
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (position==SHOW_DIALOG) {
+			if (imp!=null && !imp.isHyperStack()) {
+				channel=false; slice=true; frame=false;
+			}
+			if (imp!=null && imp.isHyperStack()) {
+				channel = slice = frame = false;
+				if (imp.getNSlices()>1)
+					slice = true;
+				if (imp.getNFrames()>1 && imp.getNSlices()==1)
+					frame = true;
+			}
+			Font font = new Font("SansSerif", Font.BOLD, 12);
+			GenericDialog gd = new GenericDialog("Remove");
+			gd.setInsets(5,15,0);
+			gd.addMessage("Remove positions for:      ", font);
+			gd.setInsets(6,25,0);
+			gd.addCheckbox("Channels:", channel);
+			gd.setInsets(0,25,0);
+			gd.addCheckbox("Slices:", slice);
+			gd.setInsets(0,25,0);
+			gd.addCheckbox("Frames:", frame);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return;
+			removeChannels = gd.getNextBoolean();
+			removeSlices = gd.getNextBoolean();
+			removeFrames = gd.getNextBoolean();
+		}
+		if (!removeChannels && !removeSlices && !removeFrames) {
+			slice = true;
+			return;
+		}
+		for (int i=0; i<indexes.length; i++) {
+			int index = indexes[i];
+			Roi roi = (Roi)rois.get(index);
+			String name = (String)listModel.getElementAt(index);
+			int n = getSliceNumber(name);
+			if (n>0) {
+				String name2 = name.substring(5, name.length());
+				roi.setName(name2);
+				rois.set(index, roi);
+				listModel.setElementAt(name2, index);
+			}
+			int c = roi.getCPosition();
+			int z = roi.getZPosition();
+			int t = roi.getTPosition();
+			if (c>0 || t>0) {
+				if (removeChannels) c = 0;
+				if (removeSlices) z = 0;
+				if (removeFrames) t = 0;
+				roi.setPosition(c, z, t);
+			} else
+				roi.setPosition(0);
+		}
+		if (imp!=null)
+			imp.draw();
+		if (record()) {
+			if (removeChannels) Recorder.record("roiManager", "Remove Channel Info");
+			if (removeSlices) Recorder.record("roiManager", "Remove Slice Info");
+			if (removeFrames) Recorder.record("roiManager", "Remove Frame Info");
+		}
+	}
+
+	private void help() {
+		String macro = "run('URL...', 'url="+IJ.URL+"/docs/menus/analyze.html#manager');";
+		new MacroRunner(macro);
+	}
+
+	private void labels() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			showAllCheckbox.setState(true);
+			labelsCheckbox.setState(true);
+			showAll(LABELS);
+		}
+		try {
+			IJ.run("Labels...");
+		} catch(Exception e) {}
+		Overlay defaultOverlay = OverlayLabels.createOverlay();
+		Prefs.useNamesAsLabels = defaultOverlay.getDrawNames();
+	}
+
+	private void options() {
+		Color c = ImageCanvas.getShowAllColor();
+		GenericDialog gd = new GenericDialog("Options");
+		//gd.addPanel(makeButtonPanel(gd), GridBagConstraints.CENTER, new Insets(5, 0, 0, 0));
+		gd.addCheckbox("Associate \"Show All\" ROIs with slices", Prefs.showAllSliceOnly);
+		gd.addCheckbox("Restore ROIs centered", restoreCentered);
+		gd.addCheckbox("Use ROI names as labels", Prefs.useNamesAsLabels);
+		gd.showDialog();
+		if (gd.wasCanceled()) {
+			if (c!=ImageCanvas.getShowAllColor())
+				ImageCanvas.setShowAllColor(c);
+			return;
+		}
+		Prefs.showAllSliceOnly = gd.getNextBoolean();
+		restoreCentered = gd.getNextBoolean();
+		Prefs.useNamesAsLabels = gd.getNextBoolean();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null) {
+			Overlay overlay = imp.getOverlay();
+			if (overlay==null) {
+				ImageCanvas ic = imp.getCanvas();
+				if (ic!=null)
+					overlay = ic.getShowAllList();
+			}
+			if (overlay!=null) {
+				overlay.drawNames(Prefs.useNamesAsLabels);
+				setOverlay(imp, overlay);
+			} else
+				imp.draw();
+		}
+		if (record()) {
+			Recorder.record("roiManager", "Associate", Prefs.showAllSliceOnly?"true":"false");
+			Recorder.record("roiManager", "Centered", restoreCentered?"true":"false");
+			Recorder.record("roiManager", "UseNames", Prefs.useNamesAsLabels?"true":"false");
+		}
+	}
+
+	Panel makeButtonPanel(GenericDialog gd) {
+		Panel panel = new Panel();
+		//buttons.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 0));
+		colorButton = new Button("\"Show All\" Color...");
+		colorButton.addActionListener(this);
+		panel.add(colorButton);
+		return panel;
+	}
+
+	void setShowAllColor() {
+			ColorChooser cc = new ColorChooser("\"Show All\" Color", ImageCanvas.getShowAllColor(),	 false);
+			ImageCanvas.setShowAllColor(cc.getColor());
+	}
+
+	void split() {
+		ImagePlus imp = getImage();
+		if (imp==null) return;
+		Roi roi = imp.getRoi();
+		if (roi==null || roi.getType()!=Roi.COMPOSITE) {
+			error("Image with composite selection required");
+			return;
+		}
+		boolean record = Recorder.record;
+		Recorder.record = false;
+		Roi[] rois = ((ShapeRoi)roi).getRois();
+		for (int i=0; i<rois.length; i++) {
+			imp.setRoi(rois[i]);
+			addRoi(false);
+		}
+		Recorder.record = record;
+		if (record()) Recorder.record("roiManager", "Split");
+	}
+
+	void showAll(int mode) {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			return;
+		boolean showAll = mode==SHOW_ALL;
+		if (showAll)
+			imageID = imp.getID();
+		if (mode==LABELS || mode==NO_LABELS)
+			showAll = true;
+		if (showAll) imp.deleteRoi();
+		if (mode==SHOW_NONE) {
+			removeOverlay(imp);
+			imageID = 0;
+		} else if (getCount()>0) {
+			Roi[] rois = getRoisAsArray();
+			Overlay overlay = newOverlay();
+			for (int i=0; i<rois.length; i++)
+				overlay.add(rois[i]);
+			setOverlay(imp, overlay);
+		}
+	}
+
+	void updateShowAll() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			return;
+		if (showAllCheckbox.getState()) {
+			if (getCount()>0) {
+				Roi[] rois = getRoisAsArray();
+				Overlay overlay = newOverlay();
+				for (int i=0; i<rois.length; i++)
+					overlay.add(rois[i]);
+				setOverlay(imp, overlay);
+			} else
+				removeOverlay(imp);
+		} else
+			removeOverlay(imp);
+	}
+
+	int[] getAllIndexes() {
+		int count = getCount();
+		int[] indexes = new int[count];
+		for (int i=0; i<count; i++)
+			indexes[i] = i;
+		return indexes;
+	}
+
+	ImagePlus getImage() {
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			error("There are no images open.");
+			return null;
+		} else
+			return imp;
+	}
+
+	boolean error(String msg) {
+		new MessageDialog(this, "ROI Manager", msg);
+		Macro.abort();
+		return false;
+	}
+
+	public void processWindowEvent(WindowEvent e) {
+		super.processWindowEvent(e);
+		if (e.getID()==WindowEvent.WINDOW_CLOSING) {
+			instance = null;
+		}
+		if (!IJ.isMacro())
+			ignoreInterrupts = false;
+	}
+
+	/** Returns a reference to the ROI Manager and opens
+		 the "ROI Manager" window if it is not already open. */
+	public static RoiManager getRoiManager() {
+		if (instance!=null)
+			return (RoiManager)instance;
+		else
+			return new RoiManager();
+	}
+
+	/** Returns a reference to the ROI Manager, or null if it is not open
+	 * and a batch mode macro is not running. If the ROI Manager
+	 * is not open and a batch mode macro is running,
+	 * returns the hidden batch mode RoiManager.
+	 * @see #getRoiManager
+	*/
+	public static RoiManager getInstance() {
+		if (instance==null && IJ.isMacro())
+			return Interpreter.getBatchModeRoiManager();
+		else
+			return (RoiManager)instance;
+	}
+
+	public static RoiManager getRawInstance() {
+		return (RoiManager)instance;
+	}
+
+	/** Returns a reference to the ROI Manager window or to the
+		macro batch mode RoiManager, or null if neither exists. */
+	public static RoiManager getInstance2() {
+		RoiManager rm = getInstance();
+		if (rm==null && IJ.isMacro())
+			rm = Interpreter.getBatchModeRoiManager();
+		return rm;
+	}
+
+	/** Obsolete
+	 * @deprecated
+	 * @see #getCount
+	 * @see #getRoisAsArray
+	*/
+	public Hashtable getROIs() {
+		Roi[] rois = getRoisAsArray();
+		Hashtable ht = new Hashtable();
+		for (int i=0; i<rois.length; i++)
+			ht.put((String)listModel.getElementAt(i), rois[i]);
+		return ht;
+	}
+
+	/** Obsolete
+	 * @deprecated
+	 * @see #getCount
+	 * @see #getRoisAsArray
+	 * @see #getSelectedIndex
+	*/
+	public List getList() {
+		List awtList = new List();
+		for (int i=0; i<getCount(); i++)
+			awtList.add((String)listModel.getElementAt(i));
+		int index = getSelectedIndex();
+		if (index>=0)
+			awtList.select(index);
+		return awtList;
+	}
+
+	/** Returns the ROI count. */
+	public int getCount() {
+		return listModel!=null?listModel.getSize():0;
+	}
+
+	/** Returns the count of selected ROIs. */
+	public int selected() {
+		return getSelectedIndexes().length;
+	}
+
+	/** Returns the index of the specified Roi, or -1 if it is not found. */
+    public int getRoiIndex(Roi roi) {
+		int n = getCount();
+		for (int i=0; i<n; i++) {
+			Roi roi2 = (Roi)rois.get(i);
+			if (roi==roi2)
+				return i;
+		}
+		return -1;
+    }
+
+	/** Returns the index of the first selected ROI or -1 if no ROI is selected. */
+	public int getSelectedIndex() {
+		return list.getSelectedIndex();
+    }
+
+	/** Returns a reference to the ROI at the specified index. */
+	public Roi getRoi(int index) {
+		if (index<0 || index>=getCount())
+			return null;
+		return (Roi)rois.get(index);
+	}
+
+	/** Returns the ROIs as an array. */
+	public synchronized Roi[] getRoisAsArray() {
+		Roi[] array = new Roi[rois.size()];
+		return (Roi[])rois.toArray(array);
+	}
+
+	/** Returns the selected ROIs as an array, or
+		all the ROIs if none are selected. */
+	public Roi[] getSelectedRoisAsArray() {
+		int[] indexes = getIndexes();
+		int n = indexes.length;
+		Roi[] array = new Roi[n];
+		for (int i=0; i<n; i++)
+			array[i] = (Roi)rois.get(indexes[i]);
+		return array;
+	}
+
+	/** Returns the name of the ROI with the specified index,
+		or null if the index is out of range.
+		See also: RoiManager.getName() macro function.
+	*/
+	public String getName(int index) {
+		if (index>=0 && index<getCount())
+			return	(String) listModel.getElementAt(index);
+		else
+			return null;
+	}
+
+	/** Returns the name of the ROI with the specified index.
+		Can be called from a macro using
+		<pre>call("ij.plugin.frame.RoiManager.getName", index)</pre>
+		Returns "null" if the Roi Manager is not open or index is
+		out of range.
+	*/
+	public static String getName(String index) {
+		int i = (int)Tools.parseDouble(index, -1);
+		RoiManager instance = getInstance2();
+		if (instance!=null && i>=0 && i<instance.getCount())
+			return	(String) instance.listModel.getElementAt(i);
+		else
+			return "null";
+	}
+
+	/** Executes the ROI Manager "Add", "Add & Draw", "Update", "Delete", "Measure", "Draw",
+		"Show All", "Show None", "Fill", "Deselect", "Select All", "Combine", "AND", "XOR", "Split",
+		"Sort" or "Multi Measure" command.	Returns false if <code>cmd</code>
+		is not one of these strings. */
+	public boolean runCommand(String cmd) {
+		cmd = cmd.toLowerCase();
+		macro = true;
+		boolean ok = true;
+		if (cmd.equals("add")) {
+			boolean shift = IJ.shiftKeyDown();
+			boolean alt = IJ.altKeyDown();
+			if (Interpreter.isBatchMode()) {
+				shift = false;
+				alt = false;
+			}
+			add(shift, alt);
+			if (IJ.isJava18()&&IJ.isMacOSX())
+				repaint();
+		} else if (cmd.equals("add & draw"))
+			addAndDraw(false);
+		else if (cmd.equals("update"))
+			update(true);
+		else if (cmd.equals("update2"))
+			update(false);
+		else if (cmd.equals("delete"))
+			delete(false);
+		else if (cmd.equals("measure")) {
+			if (EventQueue.isDispatchThread())
+				measure(getImage());
+			else try {
+				// run on event dispatching thread for greater speed on Windows
+				final ImagePlus imp = getImage();
+				EventQueue.invokeAndWait(new Runnable() {
+					public void run() {
+						measure(imp);
+					}
+				});
+			} catch (Exception e) {}
+		} else if (cmd.equals("draw"))
+			drawOrFill(DRAW);
+		else if (cmd.equals("fill"))
+			drawOrFill(FILL);
+		else if (cmd.equals("label"))
+			drawOrFill(LABEL);
+		else if (cmd.equals("and"))
+			and();
+		else if (cmd.equals("or") || cmd.equals("combine"))
+			combine();
+		else if (cmd.equals("xor"))
+			xor();
+		else if (cmd.equals("split"))
+			split();
+		else if (cmd.equals("sort"))
+			sort();
+		else if (cmd.startsWith("multi measure") || cmd.startsWith("multi-measure"))
+			multiMeasure(cmd);
+		else if (cmd.equals("multi plot"))
+			multiPlot();
+		else if (cmd.equals("show all")) {
+			if (WindowManager.getCurrentImage()!=null) {
+				showAll(SHOW_ALL);
+				showAllCheckbox.setState(true);
+			}
+		} else if (cmd.equals("show none")) {
+			if (WindowManager.getCurrentImage()!=null) {
+				showAll(SHOW_NONE);
+				showAllCheckbox.setState(false);
+			}
+		} else if (cmd.equals("show all with labels")) {
+			labelsCheckbox.setState(true);
+			showAll(LABELS);
+			showAllCheckbox.setState(true);
+			if (Interpreter.isBatchMode()) IJ.wait(250);
+		} else if (cmd.equals("show all without labels")) {
+			showAllCheckbox.setState(true);
+			labelsCheckbox.setState(false);
+			showAll(NO_LABELS);
+			if (Interpreter.isBatchMode()) IJ.wait(250);
+		} else if (cmd.equals("deselect")||cmd.indexOf("all")!=-1) {
+			if (IJ.isMacOSX()) ignoreInterrupts = true;
+			deselect();
+			IJ.wait(50);
+		} else if (cmd.equals("reset")) {
+			reset();
+		} else if (cmd.equals("debug")) {
+			//IJ.log("Debug: "+debugCount);
+			//for (int i=0; i<debugCount; i++)
+			//	IJ.log(debug[i]);
+		} else if (cmd.equals("enable interrupts")) {
+			ignoreInterrupts = false;
+		} else if (cmd.equals("remove channel info")) {
+			removePositions(CHANNEL);
+		} else if (cmd.equals("remove slice info")) {
+			removePositions(SLICE);
+		} else if (cmd.equals("remove frame info")) {
+			removePositions(FRAME);
+		} else if (cmd.equals("list")) {
+			listRois();
+		} else if (cmd.equals("interpolate rois")) {
+			interpolateRois();
+		} else
+			ok = false;
+		macro = false;
+		return ok;
+	}
+
+	/** Using the specified image, runs the ROI Manager "Add", "Add & Draw", "Update",
+		"Delete", "Measure", "Draw", "Show All", "Show None", "Fill", "Deselect", "Select All",
+		"Combine", "AND", "XOR", "Split", "Sort" or "Multi Measure" command. */
+	public boolean runCommand(ImagePlus imp, String cmd) {
+		WindowManager.setTempCurrentImage(imp);
+		boolean ok = runCommand(cmd);
+		WindowManager.setTempCurrentImage(null);
+		return ok;
+	}
+
+	/** Executes the ROI Manager "Open", "Save" or "Rename" command. Returns false if
+	<code>cmd</code> is not "Open", "Save" or "Rename", or if an error occurs. */
+	public boolean runCommand(String cmd, String name) {
+		cmd = cmd.toLowerCase();
+		macro = true;
+		if (cmd.equals("open")) {
+			boolean ok = open(Opener.makeFullPath(name));
+			macro = false;
+			return ok;
+		} else if (cmd.equals("save")) {
+			boolean ok = false;
+			if (name!=null && name.endsWith(".roi"))
+				ok = saveOne(getIndexes(), name);
+			else
+				ok = save(name, false);
+			return ok;
+		} else if (cmd.equals("save selected")) {
+			if (name!=null && name.endsWith(".roi"))
+				return saveOne(getIndexes(), name);
+			else
+				return save(name, true);
+		} else if (cmd.equals("rename")) {
+			rename(name);
+			macro = false;
+			return true;
+		} else if (cmd.equals("set color")) {
+			Color color = Colors.decode(name, Color.cyan);
+			setProperties(color, -1, null);
+			macro = false;
+			return true;
+		} else if (cmd.equals("set fill color")) {
+			Color fillColor = Colors.decode(name, Color.cyan);
+			setProperties(null, -1, fillColor);
+			macro = false;
+			return true;
+		} else if (cmd.equals("set line width")) {
+			int lineWidth = (int)Tools.parseDouble(name, 0);
+			if (lineWidth>=0)
+				setProperties(null, lineWidth, null);
+			macro = false;
+			return true;
+		} else if (cmd.equals("associate")) {
+			Prefs.showAllSliceOnly = name.equals("true")?true:false;
+			macro = false;
+			return true;
+		} else if (cmd.equals("centered")) {
+			restoreCentered = name.equals("true")?true:false;
+			macro = false;
+			return true;
+		} else if (cmd.equals("usenames")) {
+			Prefs.useNamesAsLabels = name.equals("true")?true:false;
+			macro = false;
+			if (labelsCheckbox.getState()) {
+				ImagePlus imp = WindowManager.getCurrentImage();
+				if (imp!=null) imp.draw();
+			}
+			return true;
+		}
+		return false;
+	}
+
+	/** Clears this RoiManager so that it contains no ROIs. */
+	public void reset() {
+		if (IJ.isMacOSX() && IJ.isMacro())
+			ignoreInterrupts = true;
+		listModel.removeAllElements();
+		overlayTemplate = null;
+		rois.clear();
+		updateShowAll();
+	}
+
+	private void translate() {
+		GenericDialog gd = new GenericDialog("Translate");
+		gd.addNumericField("X offset (pixels): ", translateX, 0);
+		gd.addNumericField("Y offset (pixels): ", translateY, 0);
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		translateX = gd.getNextNumber();
+		translateY = gd.getNextNumber();
+		translate(translateX, translateY);
+		if (record()) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("rm.translate("+translateX+", "+translateY+");");
+			else
+				Recorder.record("roiManager", "translate", (int)translateX, (int)translateY);
+		}
+	}
+
+	/** Moves the selected ROIs or all the ROIs if none are selected. */
+	public void translate(double dx, double dy) {
+		Roi[] rois = getSelectedRoisAsArray();
+		for (int i=0; i<rois.length; i++) {
+			Roi roi = rois[i];
+			Rectangle2D r = roi.getFloatBounds();
+			roi.setLocation(r.getX()+dx, r.getY()+dy);
+		}
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			imp.draw();
+	}
+
+	private boolean save(String name, boolean saveSelected) {
+		errorMessage = null;
+		if (!name.endsWith(".zip") && !name.equals("")) {
+			errorMessage = "Name must end with '.zip'";
+			return error(errorMessage);
+		}
+		if (getCount()==0)
+			return error("The list is empty");
+		int[] indexes = null;
+		if (saveSelected)
+			indexes = getIndexes();
+		else
+			indexes = getAllIndexes();
+		boolean ok = false;
+		if (name.equals(""))
+			ok = saveMultiple(indexes, null);
+		else
+			ok = saveMultiple(indexes, name);
+		macro = false;
+		return ok;
+	}
+
+	/** Adds the current selection to the ROI Manager, using the
+		specified color (a 6 digit hex string) and line width. */
+	public boolean runCommand(String cmd, String hexColor, double lineWidth) {
+		if (hexColor==null && lineWidth==1.0 && (IJ.altKeyDown()&&!Interpreter.isBatchMode()))
+			addRoi(true);
+		else {
+			Color color = hexColor!=null?Colors.decode(hexColor, Color.cyan):null;
+			addRoi(null, false, color, (int)Math.round(lineWidth));
+		}
+		return true;
+	}
+
+	/** Assigns the ROI at the specified index to the current image. */
+	public void select(int index) {
+		select(null, index);
+	}
+
+	/** Assigns the ROI at the specified index to 'imp'. */
+	public void select(ImagePlus imp, int index) {
+		if (index<0) {
+			deselect();
+			return;
+		}
+		int n = getCount();
+		if (index>=n) return;
+		boolean mm = list.getSelectionMode() == ListSelectionModel.MULTIPLE_INTERVAL_SELECTION;
+		if (mm)
+			list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
+		int delay = 1;
+		long start = System.currentTimeMillis();
+		while (true) {
+			if (list.isSelectedIndex(index))
+				break;
+			list.clearSelection();
+			list.setSelectedIndex(index);
+		}
+		if (imp==null)
+			imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			restore(imp, index, true);
+		if (mm)
+			list.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+	}
+
+	public void selectAndMakeVisible(ImagePlus imp, int index) {
+		select(imp, index);
+		list.ensureIndexIsVisible(index);
+	}
+
+	public void select(int index, boolean shiftKeyDown, boolean altKeyDown) {
+		if (!(shiftKeyDown||altKeyDown))
+			select(index);
+		ImagePlus imp = IJ.getImage();
+		if (imp==null)
+			return;
+		Roi previousRoi = imp.getRoi();
+		if (previousRoi==null) {
+			select(index);
+			return;
+		}
+		Roi.setPreviousRoi(previousRoi);
+		Roi roi = (Roi)rois.get(index);
+		if (roi!=null) {
+			roi.setImage(imp);
+			roi.update(shiftKeyDown, altKeyDown);
+		}
+	}
+
+	/** Selects all ROIs of a given group. */
+	public void selectGroup(int group) {
+		ArrayList<Integer>listSelected = new ArrayList<Integer>();
+		for (int i=0; i<getCount(); i++) {
+			Roi roi = getRoi(i);
+			if (roi.getGroup()==group)
+				listSelected.add(i);
+		}
+		int[] selected = new int[listSelected.size()];
+		for (int j=0; j<listSelected.size(); j++)
+			selected[j] = listSelected.get(j);
+		setSelectedIndexes(selected);
+	}
+
+	/** Obsolete; replaced by RoiManager.selectGroup() macro function. */
+	public static void selectGroup(String group) {
+		RoiManager rm = getInstance();
+		if (rm==null) return;
+		int groupInt = (int)Tools.parseDouble(group,0);
+		if (groupInt>0) rm.selectGroup(groupInt);
+	}
+
+	public void deselect() {
+		int n = getCount();
+		for (int i=0; i<n; i++)
+			list.clearSelection();
+		if (record()) Recorder.record("roiManager", "Deselect");
+		return;
+	}
+
+	/** Deselect the specified ROI if it is the only one selected. */
+	public void deselect(Roi roi) {
+		int[] indexes = getSelectedIndexes();
+		if (indexes.length==1 && listModel.getSize()>0) {
+			String label = (String)listModel.getElementAt(indexes[0]);
+			if (label.equals(roi.getName())) {
+				deselect();
+				repaint();
+			}
+		}
+	}
+
+	public void setEditMode(ImagePlus imp, boolean editMode) {
+		showAllCheckbox.setState(editMode);
+		labelsCheckbox.setState(editMode);
+		showAll(editMode?LABELS:SHOW_NONE);
+	}
+
+	/** Overrides PlugInFrame.close(). */
+	public void close() {
+		super.close();
+		instance = null;
+		resetMultiMeasureResults();
+		Prefs.saveLocation(LOC_KEY, getLocation());
+		if (!showAllCheckbox.getState() || IJ.macroRunning())
+			return;
+		int n = getCount();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null || (imp.getCanvas()!=null && imp.getCanvas().getShowAllList()==null))
+			return;
+		if (n>0) {
+			GenericDialog gd = new GenericDialog("ROI Manager");
+			gd.addMessage("Save the "+n+" displayed ROIs as an overlay?");
+			gd.setOKLabel("Discard");
+			gd.setCancelLabel("Save as Overlay");
+			gd.showDialog();
+			if (gd.wasCanceled())
+				moveRoisToOverlay(imp);
+			else
+				removeOverlay(imp);
+		} else
+			imp.draw();
+	}
+
+	/** Moves all the ROIs to the specified image's overlay. */
+	public void moveRoisToOverlay(ImagePlus imp) {
+		if (imp==null)
+			return;
+		Roi[] rois = getRoisAsArray();
+		int n = rois.length;
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			overlay = newOverlay();
+		for (int i=0; i<n; i++) {
+			Roi roi = (Roi)rois[i].clone();
+			if (!Prefs.showAllSliceOnly && !IJ.isMacro())
+				roi.setPosition(0);
+			//if (roi.getStrokeWidth()==1)
+			//	roi.setStrokeWidth(0);
+			overlay.add(roi);
+		}
+		if (overlayTemplate!=null)
+			overlay.drawLabels(overlayTemplate.getDrawLabels());
+		imp.setOverlay(overlay);
+		if (imp.getCanvas()!=null)
+			setOverlay(imp, null);
+	}
+
+	public void mousePressed (MouseEvent e) {
+		int x=e.getX(), y=e.getY();
+		if (e.isPopupTrigger() || e.isMetaDown())
+			pm.show(e.getComponent(),x,y);
+	}
+
+	public void mouseWheelMoved(MouseWheelEvent event) {
+		synchronized(this) {
+			int index = list.getSelectedIndex();
+			int rot = event.getWheelRotation();
+			if (rot<-1) rot = -1;
+			if (rot>1) rot = 1;
+			index += rot;
+			if (index<0) index = 0;
+			if (index>=getCount()) index = getCount();
+			//IJ.log(index+"  "+rot);
+			select(index);
+			if (IJ.isWindows())
+				list.requestFocusInWindow();
+			if (IJ.isJava18()&&IJ.isMacOSX())
+				repaint();
+		}
+	}
+
+	/** Selects multiple ROIs, where 'indexes' is an array of integers, each
+	* greater than or equal to 0 and less than the value returned by getCount().
+	* @see #getSelectedIndexes
+	* @see #getSelectedRoisAsArray
+	* @see #getCount
+	*/
+	public void setSelectedIndexes(int[] indexes) {
+		int count = getCount();
+		if (count==0) return;
+		for (int i=0; i<indexes.length; i++) {
+			if (indexes[i]<0) indexes[i]=0;
+			if (indexes[i]>=count) indexes[i]=count-1;
+		}
+		list.setSelectedIndices(indexes);
+	}
+
+	/** Returns an array of the selected indexes. */
+	public int[] getSelectedIndexes() {
+		return list.getSelectedIndices();
+	}
+
+	/** This is a macro-callable version of getSelectedIndexes().
+	 * Example: indexes=split(call("ij.plugin.frame.RoiManager.getIndexesAsString"));
+	*/
+	public static String getIndexesAsString() {
+		RoiManager rm = RoiManager.getInstance();
+		if (rm==null) return "";
+		String str = Arrays.toString(rm.getSelectedIndexes());
+		str = str.replaceAll(",","");
+		return str.substring(1,str.length()-1);
+	}
+
+	/** Returns an array of the selected indexes or all indexes if none are selected. */
+	public int[] getIndexes() {
+		int[] indexes = getSelectedIndexes();
+		if (indexes.length==0)
+			indexes = getAllIndexes();
+		return indexes;
+	}
+
+	/** Returns 'true' if the index is valid and the indexed ROI is selected. */
+	public boolean isSelected(int index) {
+		return index>=0 && index<listModel.getSize() && list.isSelectedIndex(index);
+	}
+
+	private Overlay newOverlay() {
+		Overlay overlay = OverlayLabels.createOverlay();
+		overlay.drawLabels(labelsCheckbox.getState());
+		if (overlay.getLabelFont()==null && overlay.getLabelColor()==null) {
+			overlay.setLabelColor(Color.white);
+			overlay.drawBackgrounds(true);
+		}
+		overlay.drawNames(Prefs.useNamesAsLabels);
+		if (overlayTemplate!=null) {
+			overlay.drawNames(overlayTemplate.getDrawNames());
+			overlay.drawBackgrounds(overlayTemplate.getDrawBackgrounds());
+			overlay.setLabelColor(overlayTemplate.getLabelColor());
+			overlay.setLabelFont(overlayTemplate.getLabelFont(), overlayTemplate.scalableLabels());
+		}
+		return overlay;
+	}
+
+	private void removeOverlay(ImagePlus imp) {
+		if (imp!=null && imp.getCanvas()!=null)
+			setOverlay(imp, null);
+	}
+
+	private void setOverlay(ImagePlus imp, Overlay overlay) {
+		if (imp==null)
+			return;
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null)
+			return;
+		ic.setShowAllList(overlay);
+		imp.draw();
+	}
+
+	private boolean record() {
+		return Recorder.record && allowRecording && !IJ.isMacro();
+	}
+
+	private boolean recordInEvent() {
+		return Recorder.record && !IJ.isMacro();
+	}
+
+	public void allowRecording(boolean allow) {
+		this.allowRecording = allow;
+	}
+
+	public void mouseReleased (MouseEvent e) {}
+	public void mouseClicked (MouseEvent e) {}
+	public void mouseEntered (MouseEvent e) {}
+	public void mouseExited (MouseEvent e) {}
+
+	public void valueChanged(ListSelectionEvent e) {
+		if (e.getValueIsAdjusting())
+			return;
+		if (getCount()==0) {
+			if (recordInEvent())
+				Recorder.record("roiManager", "Deselect");
+			return;
+		}
+		int[] selected = list.getSelectedIndices();
+		if (selected.length==0) {
+			imageID = 0;
+			return;
+		}
+		if (WindowManager.getCurrentImage()!=null) {
+			if (selected.length==1) {
+				ImagePlus imp = getImage();
+				if (imp!=null) {
+					Roi roi = imp.getRoi();
+					if (roi!=null)
+						Roi.setPreviousRoi(roi);
+				}
+				restore(imp, selected[0], true);
+				ResultsTable.selectRow(imp!=null?imp.getRoi():null);
+				imageID = imp!=null?imp.getID():0;
+			}
+			if (recordInEvent()) {
+				String arg = Arrays.toString(selected);
+				if (!arg.startsWith("[") || !arg.endsWith("]"))
+					return;
+				arg = arg.substring(1, arg.length()-1);
+				arg = arg.replace(" ", "");
+				if (Recorder.scriptMode()) {
+					if (selected.length==1)
+						Recorder.recordCall("rm.select("+arg+");");
+					else
+						Recorder.recordCall("rm.setSelectedIndexes(["+arg+"]);");
+				} else {
+					if (selected.length == 1)
+						Recorder.recordString("roiManager(\"Select\", " + arg + ");\n");
+					else
+						Recorder.recordString("roiManager(\"Select\", newArray(" + arg + "));\n");
+				}
+			}
+		}
+	}
+
+    public void windowActivated(WindowEvent e) {
+    	super.windowActivated(e);
+    	ImagePlus imp = WindowManager.getCurrentImage();
+    	if (imp!=null) {
+    		if (imageID!=0 && imp.getID()!=imageID) {
+    			showAll(SHOW_NONE);
+    			if (okToSet())
+					showAllCheckbox.setState(false);
+				deselect();
+				imageID = 0;
+    		}
+    	}
+	}
+
+	public static void resetMultiMeasureResults() {
+		mmResults = mmResults2 = null;
+	}
+
+	public void setOverlay(Overlay overlay) {
+		if (overlay==null) {
+			overlayTemplate = null;
+			return;
+		}
+		reset();
+		overlayTemplate = overlay.create();
+		setEditMode(null, false);
+		for (int i=0; i<overlay.size(); i++)
+			add(overlay.get(i), i+1);
+		setEditMode(null, true);
+		runCommand("show all");
+	}
+
+	/** Returns the most recent I/O error message, or null if there was no error. */
+	public static String getErrorMessage() {
+		return errorMessage;
+	}
+	
+	@Override
+	public String toString() {
+		return "RoiManager[size="+getCount()+", visible="+isVisible()+"]";
+	}
+
+	@Override
+	public Iterator<Roi> iterator() {
+
+		Iterator<Roi> it = new Iterator<Roi>() {
+			private int index = -1;
+			RoiManager rm = RoiManager.getInstance();
+
+			/** Returns 'true' if next element exists. */ 
+			@Override
+			public boolean hasNext() {
+				if (index+1<rm.getCount()) 
+					return true;
+				else 
+					return false;
+			}
+
+			/** Returns current ROI and updates pointer. */
+			@Override
+			public Roi next() {
+				if (index+1<rm.getCount())
+					return rm.getRoi(++index);
+				else
+					return null;
+			} 
+
+			@Override
+			public void remove() { 
+				throw new UnsupportedOperationException(); 
+			}
+		};
+		return it;
+	}
+
+	// This class runs the "Multi Measure" command in a separate thread
+	private class MultiMeasureRunner implements Runnable  {
+		private Thread thread;
+		private ImagePlus imp;
+		private Roi[] rois;
+		private boolean appendResults;
+
+		public void multiMeasure(ImagePlus imp, Roi[] rois, boolean appendResults) {
+			this.imp = imp;
+			this.rois = rois;
+			this.appendResults = appendResults;
+			thread = new Thread(this, "MultiMeasure");
+			thread.start();
+		}
+
+		public void run() {
+			int currentSlice = imp.getCurrentSlice();
+			ResultsTable rtMulti = RoiManager.multiMeasure(imp, rois, appendResults);
+			mmResults = (ResultsTable)rtMulti.clone();
+			rtMulti.show("Results");
+			imp.setSlice(currentSlice);
+			if (rois.length>1)
+				IJ.run("Select None");
+		}
+
+	}
+
+
+}
diff --git a/src/ij/plugin/frame/SyncWindows.java b/src/ij/plugin/frame/SyncWindows.java
new file mode 100644
index 0000000..71b5369
--- /dev/null
+++ b/src/ij/plugin/frame/SyncWindows.java
@@ -0,0 +1,1197 @@
+package ij.plugin.frame;
+import ij.*;
+import ij.gui.*;
+import ij.measure.Calibration;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.geom.*;
+import java.util.*;
+
+
+/** This class "synchronizes" mouse input in multiple windows. Once
+	several windows are synchronized, mouse events in any one of the
+	synchronized windows are propagated to the others.
+
+	Note, the notion of synchronization use by the SyncWindows class
+	here (i.e. multiple windows that all get the same mouse input) is
+	somewhat different than the use of the synchronize keyword in the
+	Java language. (In Java, synchronize has to do w/ critical section
+	access by multiple threads.)
+<p>
+	Optionally passes on change of z-slice of a stack to other stacks;
+
+	Optionally translates positions to different windows via offscreen
+	coordinates, i.e. correctly translates coordinates to windows with a
+	different zoom;
+
+	Updates the list of windows by click of a button;
+
+@author Patrick Kelly <phkelly@ucsd.edu>;
+Improved GUI, support of image coordinates and z-slices by Joachim Walter <correspondence@walter-witzenhausen.de>
+
+*/
+public class SyncWindows extends PlugInFrame implements
+	ActionListener, MouseMotionListener, MouseListener, DisplayChangeListener,
+	ItemListener, ImageListener, CommandListener {
+
+	/** Indices of synchronized image windows are maintained in this Vector. */
+	protected Vector vwins = null;
+
+	/* Manage mouse information.
+	   The mouse coordinates x and y are only changed by the methods of the
+	   MousMotionListener Interface. They are used by the MouseListener methods.
+	   This way, the coordinates that were valid before a MouseListener event
+	   (e.g. a Zoom) happened can be accessed. */
+	protected int oldX, oldY;
+	protected int x=0;
+	protected int y=0;
+
+	/** List of currently displayed windows retrieved from ImageJ
+	   window manager. */
+	protected java.awt.List wList;
+
+	/** Panel for GUI */
+	protected java.awt.Panel panel;
+
+	/** Checkboxes for user control. */
+	protected Checkbox cCursor, cSlice, cChannel, cFrame, cCoords, cScaling;
+
+	/** Buttons for user control. */
+	protected Button bSyncAll, bUnsyncAll;
+
+	/** Hashtable to map list ids to image window ids. */
+	protected Vector vListMap;
+
+	/** reference to current instance of ImageJ (to avoid repeated IJ.getInstance() s) */
+	protected final ImageJ ijInstance;
+
+	/*	Variables to store display values of current window.
+	 *	Translation by screenX/Y() and offScreenX/Y() does not work,
+	 *	because current window receives events (e.g. zooming) before this plugin.
+	 */
+	private double currentMag = 1;
+	private Rectangle currentSrcRect = new Rectangle(0,0,400,400);
+
+	// Control size of cursor box and clipping region. These could be
+	// changed to tune performance.
+	static final int RSZ = 16;
+	static final int SZ = RSZ/2;
+	static final int SCALE = 3;
+
+	private static SyncWindows instance;
+	private static Point location;
+
+	//--------------------------------------------------
+	/** Create window sync frame. Frame is shown via call to show() or
+		by invoking run method.	 */
+	public SyncWindows() {
+		this("Synchronize Windows");
+	}
+
+	public SyncWindows(String s) {
+		super(s);
+		ijInstance = IJ.getInstance();
+		if (instance!=null) {
+			WindowManager.toFront(instance);
+			return;
+		}
+		instance = this;
+		panel = controlPanel();
+		add(panel);
+		GUI.scale(this);
+		pack();
+		setResizable(false);
+		IJ.register(this.getClass());
+		if (location==null)
+			location = getLocation();
+		else
+			setLocation(location);
+		updateWindowList();
+		WindowManager.addWindow(this);
+		ImagePlus.addImageListener(this);
+		Executer.addCommandListener(this);
+		show();
+	}
+
+	public static void setC(ImageWindow source, int channel) {
+		SyncWindows syncWindows = instance;
+		if (syncWindows==null || !syncWindows.synced(source))
+			return;
+		DisplayChangeEvent event=new DisplayChangeEvent(source, DisplayChangeEvent.CHANNEL, channel);
+		syncWindows.displayChanged(event);
+	}
+
+	public static void setZ(ImageWindow source, int slice) {
+		SyncWindows syncWindows = instance;
+		if (syncWindows==null || !syncWindows.synced(source))
+			return;
+		DisplayChangeEvent event=new DisplayChangeEvent(source, DisplayChangeEvent.Z, slice);
+		syncWindows.displayChanged(event);
+	}
+
+	public static void setT(ImageWindow source, int frame) {
+		SyncWindows syncWindows = instance;
+		if (syncWindows==null || !syncWindows.synced(source))
+			return;
+		DisplayChangeEvent event = new DisplayChangeEvent(source, DisplayChangeEvent.T, frame);
+		syncWindows.displayChanged(event);
+	}
+
+	private boolean synced(ImageWindow source) {
+		if (source==null || vwins==null)
+			return false;
+		ImagePlus imp = source.getImagePlus();
+		if (imp==null)
+			return false;
+		return vwins.contains(new Integer(imp.getID()));
+	}
+
+	// --------------------------------------------------
+	/**
+	* Method to pass on changes of the z-slice of a stack.
+	*/
+	public void displayChanged(DisplayChangeEvent e) {
+		//if (e!=null) throw new IllegalArgumentException();
+		//IJ.log("displayChanged: "+e);
+		if (vwins == null) return;
+
+		Object source = e.getSource();
+		int type = e.getType();
+		int value = e.getValue();
+
+		ImagePlus imp;
+		ImageWindow iw;
+
+		// Current imagewindow
+		ImageWindow iwc = WindowManager.getCurrentImage().getWindow();
+
+		// pass on only if event comes from current window
+		if (!iwc.equals(source)) return;
+
+		// Change channel in other synchronized windows.
+		if (cChannel.getState() && type==DisplayChangeEvent.CHANNEL) {
+			for (int n=0; n<vwins.size();++n) {
+				imp = getImageFromVector(n);
+				if (imp!=null) {
+					iw = imp.getWindow();
+					if (!iw.equals(source))
+						imp.setC(value);
+				}
+			}
+		}
+
+		// Change slice in other synchronized windows.
+		if (cSlice.getState() && type==DisplayChangeEvent.Z) {
+			for (int n=0; n<vwins.size();++n) {
+				imp = getImageFromVector(n);
+				if (imp!=null) {
+					iw = imp.getWindow();
+					if (!iw.equals(source)) {
+						if (imp.getNSlices()==1 && imp.getNFrames()>1)
+							imp.setT(value);
+						else
+							imp.setZ(value);
+					}
+				}
+			}
+		}
+
+		// Change frame in other synchronized windows.
+		if (cFrame.getState() && type==DisplayChangeEvent.T) {
+			for(int n=0; n<vwins.size();++n) {
+				imp = getImageFromVector(n);
+				if (imp!=null) {
+					iw = imp.getWindow();
+					if (!iw.equals(source))
+						imp.setT(value);
+				}
+			}
+		}
+
+		// Store srcRect, Magnification and others of current ImageCanvas
+		ImageCanvas icc = iwc.getCanvas();
+		storeCanvasState(icc);
+	}
+
+
+	// --------------------------------------------------
+	//
+	// MouseMotionListener interface methods.
+	//
+
+	// --------------------------------------------------
+	/** Draws the "synchronize" cursor in each of the synchronized
+	 windows.  */
+	public void mouseMoved(MouseEvent e) {
+		if (!cCursor.getState()) return;
+		if (vwins == null) return;
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+		Point p;
+		Point oldp;
+		oldX = x; oldY = y;
+		x = e.getX();
+		y = e.getY();
+		p = new Point(x, y);
+
+		// get ImageCanvas that received event
+		ImageCanvas icc = (ImageCanvas) e.getSource();
+		ImageWindow iwc = (ImageWindow) icc.getParent();
+
+		// Draw new cursor box in each synchronized window.
+		// and pass on mouse moved event
+		for(int n=0; n<vwins.size();++n) {
+			// to keep ImageJ from freezing when a mouse event is processed on exit
+			if (ijInstance.quitting()) {
+				return;
+			}
+			imp = getImageFromVector(n);
+			if (imp != null) {
+				iw = imp.getWindow();
+				ic = iw.getCanvas();
+				if (cCoords.getState() && iw != iwc) {
+					p = getMatchingCoords(ic, icc, x, y);
+					oldp = getMatchingCoords(ic, icc, oldX, oldY);
+				} else {
+					p.x = x;
+					p.y = y;
+				}
+
+				// For PolygonRoi the cursor would overwrite the indicator lines.
+				Roi roi = imp.getRoi();
+				if (! (roi != null && roi instanceof PolygonRoi && roi.getState() == Roi.CONSTRUCTING) )
+					drawSyncCursor(imp, p.x, p.y);
+				if (iw != iwc)
+					ic.mouseMoved(adaptEvent(e, ic, p));
+			}
+		}
+		// Display correct values in ImageJ statusbar
+		iwc.getImagePlus().mouseMoved(icc.offScreenX(x), icc.offScreenY(y));
+
+		// Store srcRect, Magnification and others of current ImageCanvas
+		storeCanvasState(icc);
+	}
+
+	// --------------------------------------------------
+	/** Propagate mouse dragged events to all synchronized windows.	 */
+	public void mouseDragged(MouseEvent e) {
+		if (!cCursor.getState()) return;
+		if (vwins == null) return;
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+		Point p;
+		Point oldp;
+
+		oldX = x; oldY = y;
+		x = e.getX();
+		y = e.getY();
+
+		p = new Point(x, y);
+
+		// get ImageCanvas that received event
+		ImageCanvas icc = (ImageCanvas) e.getSource();
+		ImageWindow iwc = (ImageWindow) icc.getParent();
+
+		// Draw new cursor box in each synchronized window.
+		// and pass on mouse dragged event
+		for(int n=0; n<vwins.size();++n) {
+			// to keep ImageJ from freezing when a mouse event is processed on exit
+			if (ijInstance.quitting()) {
+				return;
+			}
+			imp = getImageFromVector(n);
+			if (imp != null) {
+				iw = imp.getWindow();
+				ic = iw.getCanvas();
+
+				if (cCoords.getState() && iw != iwc) {
+					p = getMatchingCoords(ic, icc, x, y);
+					oldp = getMatchingCoords(ic, icc, oldX, oldY);
+				} else {
+					p = new Point(x, y);
+				}
+
+				// For PolygonRoi the cursor would overwrite the indicator lines.
+				Roi roi = imp.getRoi();
+				if (! (roi != null && roi instanceof PolygonRoi && roi.getState() == Roi.CONSTRUCTING) )
+					drawSyncCursor(imp, p.x, p.y);
+
+				if(iw != iwc)
+					ic.mouseDragged(adaptEvent(e, ic, p));
+			}
+		}
+		// Store srcRect, Magnification and others of current ImageCanvas
+		storeCanvasState(icc);
+	}
+
+
+	// --------------------------------------------------
+	//
+	// MouseListener interface
+	//
+
+	// --------------------------------------------------
+	/** Propagate mouse clicked events to all synchronized windows. */
+	public void mouseClicked(MouseEvent e) {
+		if (!cCursor.getState()) return;
+		if (vwins == null) return;
+		// prevent popups popping up in all windows on right mouseclick
+		if (Toolbar.getToolId()!= Toolbar.MAGNIFIER &&
+			(e.isPopupTrigger() || (e.getModifiers() & MouseEvent.META_MASK)!=0)) return;
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+		Point p;
+		p = new Point(x,y);
+
+		// get ImageCanvas that received event
+		ImageCanvas icc = (ImageCanvas) e.getSource();
+		ImageWindow iwc = (ImageWindow) icc.getParent();
+
+		for(int n=0; n<vwins.size();++n) {
+			// to keep ImageJ from freezing when a mouse event is processed on exit
+			if (ijInstance.quitting()) {
+				return;
+			}
+			imp = getImageFromVector(n);
+			if (imp != null) {
+				iw = imp.getWindow();
+				if(iw != iwc) {
+					ic = iw.getCanvas();
+					if (cCoords.getState()) {
+						p = getMatchingCoords(ic, icc, x, y);
+					}
+					ic.mouseClicked(adaptEvent(e, ic, p));
+				}
+			}
+		}
+		// Store srcRect, Magnification and others of current ImageCanvas
+		storeCanvasState(icc);
+	}
+
+	// --------------------------------------------------
+	/** Propagate mouse entered events to all synchronized windows. */
+	public void mouseEntered(MouseEvent e) {
+		if (!cCursor.getState()) return;
+		if (vwins == null) return;
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+		Point p;
+		p = new Point(x,y);
+
+		// get ImageCanvas that received event
+		ImageCanvas icc = (ImageCanvas) e.getSource();
+		ImageWindow iwc = (ImageWindow) icc.getParent();
+
+		for(int n=0; n<vwins.size();++n) {
+			// to keep ImageJ from freezing when a mouse event is processed on exit
+			if (ijInstance.quitting()) {
+				return;
+			}
+			imp = getImageFromVector(n);
+			if (imp != null) {
+				iw = imp.getWindow();
+				if(iw != iwc) {
+					ic = iw.getCanvas();
+
+					if (cCoords.getState()) {
+						p = getMatchingCoords(ic, icc, x, y);
+					}
+					ic.mouseEntered(adaptEvent(e, ic, p));
+				}
+			}
+		}
+		// Store srcRect, Magnification and others of current ImageCanvas
+		storeCanvasState(icc);
+	}
+
+
+	// --------------------------------------------------
+	/** Propagate mouse exited events to all synchronized windows. */
+	public void mouseExited(MouseEvent e) {
+		if (!cCursor.getState()) return;
+		if (vwins == null) return;
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+		Point p;
+		p = new Point(x,y);
+
+		// get ImageCanvas that received event
+		ImageCanvas icc = (ImageCanvas) e.getSource();
+		ImageWindow iwc = (ImageWindow) icc.getParent();
+
+		for(int n=0; n<vwins.size();++n) {
+			// to keep ImageJ from freezing when a mouse event is processed on exit
+			if (ijInstance.quitting()) {
+				return;
+			}
+			imp = getImageFromVector(n);
+			if (imp != null) {
+				iw = imp.getWindow();
+				ic = iw.getCanvas();
+
+				if (cCoords.getState() && iw != iwc)
+					p = getMatchingCoords(ic, icc, x, y);
+				else {
+					p.x = x;
+					p.y = y;
+				}
+
+				setCursor(imp, null);
+				if (iw != iwc)
+					ic.mouseExited(adaptEvent(e, ic, p));
+			}
+		}
+		// Store srcRect, Magnification and others of current ImageCanvas
+		storeCanvasState(icc);
+	}
+
+
+	// --------------------------------------------------
+	/** Propagate mouse pressed events to all synchronized windows. */
+	public void mousePressed(MouseEvent e) {
+		if (!cCursor.getState()) return;
+		if (vwins == null) return;
+		// prevent popups popping up in all windows on right mouseclick
+		if (Toolbar.getToolId()!= Toolbar.MAGNIFIER &&
+			(e.isPopupTrigger() || (e.getModifiers() & MouseEvent.META_MASK)!=0)) return;
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+		Point p;
+		p = new Point(x,y);
+
+		// Current window already received mouse event.
+		// get ImageCanvas that received event
+		ImageCanvas icc = (ImageCanvas) e.getSource();
+		ImageWindow iwc = (ImageWindow) icc.getParent();
+
+		for(int n=0; n<vwins.size();++n) {
+			// to keep ImageJ from freezing when a mouse event is processed on exit
+			if (ijInstance.quitting()) {
+				return;
+			}
+			imp = getImageFromVector(n);
+			if (imp != null) {
+				iw = imp.getWindow();
+				ic = iw.getCanvas();
+				// Repaint to get rid of sync indicator.
+				ic.paint(ic.getGraphics());
+				if(iw != iwc) {
+					ic = iw.getCanvas();
+					if (cCoords.getState()) {
+						p = getMatchingCoords(ic, icc, x, y);
+					}
+					ic.mousePressed(adaptEvent(e, ic, p));
+				}
+			}
+		}
+		// Store srcRect, Magnification and others of current ImageCanvas
+		storeCanvasState(icc);
+	}
+
+	// --------------------------------------------------
+	/** Propagate mouse released events to all synchronized
+		windows. */
+	public void mouseReleased(MouseEvent e) {
+		if (!cCursor.getState()) return;
+		if (vwins == null) return;
+		// prevent popups popping up in all windows on right mouseclick
+		if (Toolbar.getToolId()!= Toolbar.MAGNIFIER &&
+			(e.isPopupTrigger() || (e.getModifiers() & MouseEvent.META_MASK)!=0)) return;
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+
+		int xloc = e.getX();
+		int yloc = e.getY();
+		Point p = new Point(xloc, yloc);
+
+		// get ImageCanvas that received event
+		ImageCanvas icc = (ImageCanvas) e.getSource();
+		ImageWindow iwc = (ImageWindow) icc.getParent();
+
+		for(int n=0; n<vwins.size();++n) {
+			// to keep ImageJ from freezing when a mouse event is processed on exit
+			if (ijInstance.quitting()) {
+				return;
+			}
+			imp = getImageFromVector(n);
+			if (imp != null) {
+				iw = imp.getWindow();
+				ic = iw.getCanvas();
+
+				if (cCoords.getState())
+					p = getMatchingCoords(ic, icc, xloc, yloc);
+
+				// Redraw to make sure sync cursor is drawn.
+				// For PolygonRoi the cursor would overwrite the indicator lines.
+				Roi roi = imp.getRoi();
+				if (! (roi != null && roi instanceof PolygonRoi && roi.getState() == Roi.CONSTRUCTING) )
+					drawSyncCursor(imp, p.x, p.y);
+				if(iw != iwc)
+					ic.mouseReleased(adaptEvent(e, ic, p));
+			}
+		}
+		// Store srcRect, Magnification and others of current ImageCanvas
+		storeCanvasState(icc);
+	}
+
+
+	// --------------------------------------------------
+	/** Implementation of ActionListener interface. */
+	public void actionPerformed(ActionEvent e) {
+		// Determine which button was pressed.
+		Object source = e.getSource();
+		if (source instanceof Button) {
+			Button bpressed = (Button)source;
+
+			 if(bpressed==bSyncAll) {
+				if (wList == null) return;
+				// Select all items on list.
+				Vector v = new Vector();
+				Integer I;
+				for(int i=0; i<wList.getItemCount();++i) {
+					wList.select(i);
+					I = (Integer)vListMap.elementAt(i);
+					v.addElement(I);
+				}
+				addWindows(v);
+			} else if(bpressed==bUnsyncAll) {
+				removeAllWindows();
+			}
+		} else if (wList != null && source == wList) {
+			// Doubleclick on entry in wList
+			addSelections();
+		}
+	}
+
+	// --------------------------------------------------
+	/** Item Listener method
+	 */
+	public void itemStateChanged(ItemEvent e) {
+	// safest way to get matching of selected windows in list and in plugin:
+	// deselect all windows in plugin and then select all in list
+	// A List often does not do what you expect.
+
+		if (wList != null && e.getSource() == wList) {
+			if(vwins != null) {
+			// unsynchronize all windows and remove from window list
+				Integer I;
+				for(int n = 0; n<vwins.size();++n) {
+					I = (Integer)vwins.elementAt(n);
+					removeWindow(I);
+				}
+				vwins.removeAllElements();
+			}
+			addSelections();
+		}
+
+		if (cCoords != null && e.getSource() == cCoords) {
+			if (cScaling != null && e.getStateChange() == ItemEvent.DESELECTED)
+					cScaling.setState(false);
+		}
+
+		if (cScaling != null && e.getSource() == cScaling) {
+			if (cCoords != null && e.getStateChange() == ItemEvent.SELECTED)
+					cCoords.setState(true);
+		}
+	}
+
+
+	// --------------------------------------------------
+	/** Override parent windowClosing method to clean up synchronized
+	resources on exit. */
+	public void windowClosing(WindowEvent e) {
+		if(e.getSource() == this) {
+			removeAllWindows();
+			ImagePlus.removeImageListener(this);
+			Executer.removeCommandListener(this);
+			close();
+		}
+	}
+
+	/** Implementation of ImageListener interface: update window list, if image is opened or closed */
+	public void imageOpened(ImagePlus imp) {
+		updateWindowList();
+	}
+
+	/** Implementation of ImageListener interface: update window list, if image is opened or closed */
+	public void imageClosed(ImagePlus imp) {
+		updateWindowList();
+	}
+
+	public void imageUpdated(ImagePlus imp) {
+	}
+
+	// --------------------------------------------------
+	/** Build window list display and button controls.
+	 *	Create Hashtable that connects list entries to window IDs.*/
+	protected Panel controlPanel() {
+		Panel p = new Panel();
+		BorderLayout layout = new BorderLayout();
+		layout.setVgap(3);
+		p.setLayout(layout);
+		p.add(buildWindowList(), BorderLayout.NORTH,0);
+		p.add(buildControlPanel(), BorderLayout.CENTER,1);
+		return p;
+	}
+
+	// --------------------------------------------------
+	/** Builds list of open ImageWindows */
+	protected Component buildWindowList() {
+		ImagePlus img;
+		ImageWindow iw;
+
+		// get IDList from WindowManager
+		int[] imageIDs = WindowManager.getIDList();
+
+		if(imageIDs != null) {
+			int size;
+			if (imageIDs.length < 10) {
+				size = imageIDs.length;
+			} else {
+				size = 10;
+			}
+
+			// Initialize window list and vector that maps list entries to window IDs.
+			wList = new java.awt.List(size, true);
+			vListMap = new Vector();
+
+			// Add Windows to list, select windows, that previously were selected
+			for(int n=0; n<imageIDs.length;++n) {
+				vListMap.addElement(new Integer(imageIDs[n]));
+				wList.add(WindowManager.getImage(imageIDs[n]).getTitle());
+				if ( vwins != null && vwins.contains(new Integer(imageIDs[n])) ) {
+					wList.select(n);
+				}
+			}
+			// clean vector of selected images (vwins) from images that have been closed,
+			if (vwins != null && vwins.size() != 0) {
+				for (int n=0; n<vwins.size(); ++n) {
+					if(! vListMap.contains(vwins.elementAt(n))) {
+						vwins.removeElementAt(n);
+						n -= 1;
+					}
+				}
+			}
+
+			wList.addItemListener(this);
+			wList.addActionListener(this);
+			return (Component)wList;
+		}
+		else {
+			Label label = new Label("No windows to select.");
+			wList = null;
+			vListMap = null;
+			vwins = null;
+			return (Component)label;
+		}
+	}
+
+	/** Builds panel containing control buttons. */
+	protected Panel buildControlPanel() {
+		GridLayout layout = new GridLayout(4,2);
+		layout.setVgap(2);
+		layout.setHgap(2);
+		Panel p = new Panel(layout);
+
+		// Checkbox: synchronize cursor
+		cCursor = new Checkbox("Sync cursor", true);
+		p.add(cCursor);
+
+		// Checkbox: propagate slice
+		cSlice = new Checkbox("Sync z-slices",true);
+		p.add(cSlice);
+
+//		TODO: Give functionality to Synchronize Channels and Synchronize t-Frames checkboxes.
+
+		// Checkbox: synchronize channels (for hyperstacks)
+		cChannel = new Checkbox("Sync channels", true);
+		p.add(cChannel);
+
+		// Checkbox: synchronize time-frames (for hyperstacks)
+		cFrame = new Checkbox("Sync t-frames", true);
+		p.add(cFrame);
+
+		// Checkbox: image coordinates
+		cCoords = new Checkbox("Image coordinates", true);
+		cCoords.addItemListener(this);
+		p.add(cCoords);
+
+		// Checkbox: image scaling (take pixel scale and offset into account)
+		cScaling = new Checkbox("Image scaling", false);
+		cScaling.addItemListener(this);
+		p.add(cScaling);
+
+
+
+		// Synchronize all windows.
+		bSyncAll = new Button("Synchronize All");
+		bSyncAll.addActionListener(this);
+		p.add(bSyncAll);
+
+		// Unsynchronize all windows.
+		bUnsyncAll = new Button("Unsynchronize All");
+		bUnsyncAll.addActionListener(this);
+		p.add(bUnsyncAll);
+
+		return p;
+	}
+
+	// --------------------------------------------------
+	/** Compute bounding rectangle given current and old cursor
+	locations. This is used to determine what part of image to
+	redraw. */
+	protected Rectangle boundingRect(int x, int y,
+		int oldX, int oldY) {
+		int dx = Math.abs(oldX - x)/2;
+		int dy = Math.abs(oldY - y)/2;
+
+		int xOffset = dx + SCALE * SZ;
+		int yOffset = dy + SCALE * SZ;
+
+		int xCenter = (x + oldX)/2;
+		int yCenter = (y + oldY)/2;
+
+		int xOrg = Math.max(xCenter - xOffset,0);
+		int yOrg = Math.max(yCenter - yOffset,0);
+
+		int w = 2 * xOffset;
+		int h = 2 * yOffset;
+
+		return new Rectangle(xOrg, yOrg, w, h);
+	}
+
+	/* Update the List of Windows in the GUI. Used by the "Update" button. */
+	protected void updateWindowList() {
+		// Don't build a new window list, while the old one is removed.
+		// When an StackWindow is replaced by an OpenStackWindow, updateWindowList
+		// is called again and the other components in the panel are removed, also.
+		Component newWindowList = buildWindowList();
+		GUI.scale(newWindowList);
+		panel.remove(0);
+		panel.add(newWindowList,BorderLayout.NORTH,0);
+		pack();
+	}
+
+	// --------------------------------------------------
+	private void addSelections() {
+		if(wList == null) return; // nothing to select
+
+		int[] listIndexes = wList.getSelectedIndexes();
+		Integer I;
+
+		Vector v = new Vector();
+		for(int n=0; n<listIndexes.length;++n) {
+			I = (Integer)vListMap.elementAt(listIndexes[n]);
+			v.addElement(I);
+		}
+
+		addWindows(v);
+	}
+
+	// --------------------------------------------------
+	/** Adds "this" object as mouse listener and mouse motion listener
+	to each of the windows in input array.	*/
+	private void addWindows(Vector v) {
+		Integer I;
+		ImagePlus imp;
+		ImageWindow iw;
+
+		//	Handle initial case of no windows.
+		if(vwins == null && v.size() > 0)
+			vwins = new Vector();
+
+		// Add all windows in vector to synchronized window list.
+		for(int n=0; n<v.size();++n) {
+			I = (Integer)v.elementAt(n);
+
+			// Make sure input window is not already on list.
+			if(!vwins.contains(I)) {
+				imp = WindowManager.getImage(I.intValue());
+				if (imp != null) {
+					iw = imp.getWindow();
+					iw.getCanvas().addMouseMotionListener(this);
+					iw.getCanvas().addMouseListener(this);
+					vwins.addElement(I);
+				}
+			}
+		}
+	}
+
+
+	// --------------------------------------------------
+	private void removeAllWindows() {
+		if(vwins != null) {
+			Integer I;
+			for(int n = 0; n<vwins.size();++n) {
+				I = (Integer)vwins.elementAt(n);
+				removeWindow(I);
+			}
+			// Remove all windows from window list.
+			vwins.removeAllElements();
+		}
+
+		// Deselect all elements on list (if present).
+		if (wList == null) return;
+		for(int n=0;n<wList.getItemCount();++n)
+			wList.deselect(n);
+	}
+
+
+	// --------------------------------------------------
+	/** Remove "this" object as mouse listener and mouse motion
+	*	listener from the window with ID I.
+	*/
+	private void removeWindow(Integer I) {
+		ImagePlus imp;
+		ImageWindow iw;
+		ImageCanvas ic;
+
+		imp = WindowManager.getImage(I.intValue());
+		if (imp != null) {
+			iw = imp.getWindow();
+			if (iw != null) {
+				ic = iw.getCanvas();
+				if (ic != null) {
+						ic.removeMouseListener(this);
+						ic.removeMouseMotionListener(this);
+						// Repaint to get rid of sync indicator.
+						ic.paint(ic.getGraphics());
+				}
+			}
+		}
+	}
+
+	/** Draw cursor that indicates windows are synchronized. */
+	private void drawSyncCursor(ImagePlus imp, int x, int y) {
+		ImageCanvas ic = imp.getCanvas();
+		if (ic==null) return;
+		double xpSZ = ic.offScreenXD(x+SZ);
+		double xmSZ = ic.offScreenXD(x-SZ);
+		double ypSZ = ic.offScreenYD(y+SZ);
+		double ymSZ = ic.offScreenYD(y-SZ);
+		double xp2 = ic.offScreenXD(x+2);
+		double xm2 = ic.offScreenXD(x-2);
+		double yp2 = ic.offScreenYD(y+2);
+		double ym2 = ic.offScreenYD(y-2);
+		GeneralPath path = new GeneralPath();
+		path.moveTo(xmSZ, ymSZ); path.lineTo(xm2, ym2);
+		path.moveTo(xpSZ, ypSZ); path.lineTo(xp2, yp2);
+		path.moveTo(xpSZ, ymSZ); path.lineTo(xp2, ym2);
+		path.moveTo(xmSZ, ypSZ); path.lineTo(xm2, yp2);
+		setCursor(imp, new ShapeRoi(path));
+	}
+
+	public synchronized void setCursor(ImagePlus imp, Roi cursor) {
+		Overlay overlay2 = imp.getOverlay();
+		if (overlay2!=null) {
+			for (int i = overlay2.size()-1; i>=0; i--) {
+				Roi roi2 = overlay2.get(i);
+				if (roi2.isCursor())
+					overlay2.remove(i);
+			}
+			if (cursor==null) {
+				imp.setOverlay(overlay2);
+				return;
+			}
+		} else
+			overlay2 = new Overlay();
+		if (cursor!=null) {
+			overlay2.add(cursor);
+			cursor.setStrokeColor(Color.red);
+			cursor.setStrokeWidth(2);
+			cursor.setNonScalable(true);
+			cursor.setIsCursor(true);
+			imp.setOverlay(overlay2);
+		}
+	}
+
+	/** Store srcRect and Magnification of the currently active ImageCanvas ic */
+	private void storeCanvasState(ImageCanvas ic) {
+		currentMag = ic.getMagnification();
+		currentSrcRect = new Rectangle(ic.getSrcRect());
+	}
+
+	// --------------------------------------------------
+	/** Get ImagePlus from Windows-Vector vwins. */
+	public ImagePlus getImageFromVector(int n) {
+		if (vwins == null || n<0 || vwins.size() < n+1) return null;
+
+		ImagePlus imp;
+		imp = WindowManager.getImage(((Integer)vwins.elementAt(n)).intValue());
+		if (imp.isLocked()) return null;	//must not touch locked windows
+		return imp;
+	}
+
+	/** Get the title of image n from Windows-Vector vwins. If the image ends with
+	 *	.tif, the extension is removed. */
+	public String getImageTitleFromVector(int n) {
+		if (vwins == null || n<0 || vwins.size() < n+1) return "";
+
+		ImagePlus imp;
+		imp = WindowManager.getImage(((Integer)vwins.elementAt(n)).intValue());
+		String title = imp.getTitle();
+		if (title.length()>=4 && (title.substring(title.length()-4)).equalsIgnoreCase(".tif")) {
+			title = title.substring(0, title.length()-4);
+		} else if (title.length()>=5 && (title.substring(title.length()-5)).equalsIgnoreCase(".tiff")) {
+			title = title.substring(0, title.length()-5);
+		}
+		return title;
+	}
+
+	/** Get index of "image" in vector of synchronized windows, if image is in vector.
+	 * Else return -1.
+	*/
+	public int getIndexOfImage(ImagePlus image) {
+		int index = -1;
+		ImagePlus imp;
+		if (vwins == null || vwins.size() == 0)
+			return index;
+
+		for (int n=0; n<vwins.size(); n++){
+			imp = WindowManager.getImage(((Integer)vwins.elementAt(n)).intValue());
+			if (imp == image) {
+				index = n;
+				break;
+			}
+		}
+		return index;
+	}
+
+	// --------------------------------------------------
+	/** Get Screen Coordinates for ImageCanvas ic matching
+	 *	the OffScreen Coordinates of the current ImageCanvas.
+	 *	(srcRect and magnification stored after each received event.)
+	 *	Input: The target ImageCanvas, the current ImageCanvas,
+	 *	x-ScreenCoordinate for current Canvas, y-ScreenCoordinate for current Canvas
+	 *	If the "ImageScaling" checkbox is selected, Scaling and Offset
+	 *	of the images are taken into account. */
+	protected Point getMatchingCoords(ImageCanvas ic, ImageCanvas icc, int x, int y) {
+
+		double xOffScreen = currentSrcRect.x + (x/currentMag);
+		double yOffScreen = currentSrcRect.y + (y/currentMag);
+
+		if (cScaling.getState()) {
+			Calibration cal = ((ImageWindow)ic.getParent()).getImagePlus().getCalibration();
+			Calibration curCal = ((ImageWindow)icc.getParent()).getImagePlus().getCalibration();
+
+			xOffScreen = ((xOffScreen-curCal.xOrigin)*curCal.pixelWidth)/cal.pixelWidth+cal.xOrigin;
+			yOffScreen = ((yOffScreen-curCal.yOrigin)*curCal.pixelHeight)/cal.pixelHeight+cal.yOrigin;
+		}
+
+		int xnew = ic.screenXD(xOffScreen);
+		int ynew = ic.screenYD(yOffScreen);
+
+		return new Point(xnew, ynew);
+	}
+
+	// --------------------------------------------------
+	/** Makes a new mouse event from MouseEvent e with the Canvas c
+	 *	as source and the coordinates of Point p as X and Y.*/
+	private MouseEvent adaptEvent(MouseEvent e, Component c, Point p) {
+		return new MouseEvent(c, e.getID(), e.getWhen(), e.getModifiers(),
+		   p.x, p.y, e.getClickCount(), e.isPopupTrigger());
+
+	}
+
+	public Insets getInsets() {
+		Insets i = super.getInsets();
+		return new Insets(i.top+10, i.left+10, i.bottom+10, i.right+10);
+	}
+
+	public void close() {
+		super.close();
+		instance = null;
+		location = getLocation();
+	}
+
+	public static SyncWindows getInstance() {
+		return instance;
+	}
+
+	public String commandExecuting(String command) {
+		if (vwins!=null && cScaling!=null && cScaling.getState() && ("In [+]".equals(command) || "Out [-]".equals(command))) {
+			ImagePlus imp = WindowManager.getCurrentImage();
+			ImageCanvas cic = imp!=null?imp.getCanvas():null;
+			if (cic==null)
+				return command;
+			Point loc = cic.getCursorLoc();
+			if (!cic.cursorOverImage()) {
+				Rectangle srcRect = cic.getSrcRect();
+				loc.x = srcRect.x + srcRect.width/2;
+				loc.y = srcRect.y + srcRect.height/2;
+			}
+			int sx = cic.screenX(loc.x);
+			int sy = cic.screenY(loc.y);
+			for (int i=0; i<vwins.size(); i++) {
+				imp = getImageFromVector(i);
+				if (imp!=null) {
+					ImageCanvas ic = imp.getCanvas();
+					if (ic!=cic) {
+						if ("In [+]".equals(command))
+							ic.zoomIn(sx, sy);
+						else
+							ic.zoomOut(sx, sy);
+						if (ic.getMagnification()<=1.0)
+							imp.repaintWindow();
+					}
+				}
+			}
+
+		}
+		return command;
+	}
+
+}	// SyncWindows_
+
+/** The Listener interface for receiving DisplayChange events.
+ *	The listener can be registered to an Object issuing DisplayChange events
+ *	by its addDisplayChangeListener method.
+ *	So far only OpenStackWindow used by SyncWindows is such an Object.
+ *	*/
+interface DisplayChangeListener extends java.util.EventListener {
+	public void displayChanged(DisplayChangeEvent e);
+}
+
+
+/* -------------------------------------------------------------------------
+/*
+/* CLASS DisplayChangeEvent
+/*
+/* ------------------------------------------------------------------------- */
+
+/** To be raised when a property of the image display has been changed */
+class DisplayChangeEvent extends EventObject {
+
+/** Type of change in display:
+ *	Coordinate X, Y, Z, the Zoom, time, color channel.
+ *	So far there is no need for properties other than Z.
+ */
+	public static final int X = 1;
+	public static final int Y = 2;
+	public static final int Z = 3;
+	public static final int ZOOM = 4;
+	public static final int T = 5;
+	public static final int CHANNEL = 6;
+
+	private int type;
+	private int value;
+
+	public DisplayChangeEvent(Object source, int type, int value) {
+		super(source);
+		this.type = type;
+		this.value = value;
+	}
+
+	public int getType() {
+		return type;
+	}
+
+	public void setType(int type) {
+		this.type = type;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public void setValue(int value) {
+		this.value = value;
+	}
+
+}
+
+
+/* -------------------------------------------------------------------------
+/*
+/* CLASS IJEventMulticaster
+/*
+/* ------------------------------------------------------------------------- */
+
+/**
+ * Multicaster for events special to ImageJ
+ * <p>
+ * Example how to implement an object, which fires DisplayChangeEvents using the
+ * IJEventMulticaster:
+ *
+ * <pre><code>
+ * public mySpecialWindow extends StackWindow {
+ *
+ *		DisplayChangeListener dclistener = null;
+ *
+ *		public synchronized void addDisplayChangeListener(DisplayChangeListener l) {
+ *			dclistener = IJEventMulticaster.add(dclistener, l);
+ *		}
+ *
+ *		public synchronized void removeDisplayChangeListener(DisplayChangeListener l) {
+ *			dclistener = IJEventMulticaster.remove(dclistener, l);
+ *		}
+ *
+ *		public void myEventFiringMethod(arguments) {
+ *			... code ...
+ *			if (dclistener != null) {
+ *				DisplayChangeEvent dcEvent = new DisplayChangeEvent(this, DisplayChangeEvent.Z, zSlice);
+ *				dclistener.displayChanged(dcEvent);
+ *			}
+ *			... code ...
+ *		}
+ *
+ *		... other methods ...
+ * }
+ * </code></pre>
+ *
+ * To put in a new event-listener (by changing this class or extending it):
+ * <p>
+ * - Add the listener to the "implements" list.
+ * <p>
+ * - Add the methods of this listener to pass on the events (like displayChanged).
+ * <p>
+ * - Add the methods "add" and "remove" with the corresponding listener type.
+ * <p>
+ *
+ * @author code taken from Sun's AWTEventMulticaster by J. Walter 2002-03-07
+ */
+
+class IJEventMulticaster extends AWTEventMulticaster implements DisplayChangeListener {
+
+	IJEventMulticaster(EventListener a, EventListener b) {
+		super(a,b);
+	}
+
+	/**
+	 * Handles the DisplayChange event by invoking the
+	 * displayChanged methods on listener-a and listener-b.
+	 * @param e the DisplayChange event
+	 */
+	public void displayChanged(DisplayChangeEvent e) {
+		((DisplayChangeListener)a).displayChanged(e);
+		((DisplayChangeListener)b).displayChanged(e);
+	}
+
+	/**
+	 * Adds DisplayChange-listener-a with DisplayChange-listener-b and
+	 * returns the resulting multicast listener.
+	 * @param a DisplayChange-listener-a
+	 * @param b DisplayChange-listener-b
+	 */
+	public static DisplayChangeListener add(DisplayChangeListener a, DisplayChangeListener b) {
+		return (DisplayChangeListener)addInternal(a, b);
+	}
+
+	/**
+	 * Removes the old DisplayChange-listener from DisplayChange-listener-l and
+	 * returns the resulting multicast listener.
+	 * @param l DisplayChange-listener-l
+	 * @param oldl the DisplayChange-listener being removed
+	 */
+	public static DisplayChangeListener remove(DisplayChangeListener l, DisplayChangeListener oldl) {
+		return (DisplayChangeListener)removeInternal(l, oldl);
+	}
+
+}
diff --git a/src/ij/plugin/frame/ThresholdAdjuster.java b/src/ij/plugin/frame/ThresholdAdjuster.java
new file mode 100644
index 0000000..56dd856
--- /dev/null
+++ b/src/ij/plugin/frame/ThresholdAdjuster.java
@@ -0,0 +1,1216 @@
+package ij.plugin.frame;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.image.*;
+import ij.*;
+import ij.plugin.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+import ij.plugin.filter.*;
+import ij.plugin.ChannelSplitter;
+import ij.plugin.Thresholder;
+
+/** Adjusts the lower and upper threshold levels of the active image. This
+	class is multi-threaded to provide a more responsive user interface. */
+public class ThresholdAdjuster extends PlugInDialog implements PlugIn, Measurements, Runnable,
+	ActionListener, AdjustmentListener, ItemListener, FocusListener, KeyListener, MouseWheelListener, ImageListener {
+
+	public static final String LOC_KEY = "threshold.loc";
+	public static final String MODE_KEY = "threshold.mode";
+	public static final String DARK_BACKGROUND = "threshold.dark";
+	public static final String RAW_VALUES = "threshold.raw";
+	static final int RED=0, BLACK_AND_WHITE=1, OVER_UNDER=2;
+	static final String[] modes = {"Red","B&W", "Over/Under"};
+	static final double defaultMinThreshold = 0;//85;
+	static final double defaultMaxThreshold = 255;//170;
+	static final int DEFAULT = 0;
+	static boolean fill1 = true;
+	static boolean fill2 = true;
+	static boolean useBW = true;
+	static boolean backgroundToNaN = true;
+	static ThresholdAdjuster instance;
+	static int mode = RED;
+	static String[] methodNames = AutoThresholder.getMethods();
+	static String method = methodNames[DEFAULT];
+	static AutoThresholder thresholder = new AutoThresholder();
+	ThresholdPlot plot = new ThresholdPlot();
+	Thread thread;  //background thread calculating and applying the threshold
+
+	int minValue = -1;  // min slider, 0-255
+	int maxValue = -1;
+	int sliderRange = 256;
+	boolean doAutoAdjust,doReset,doApplyLut,doStateChange,doSet,doBackground; //actions required from user interface
+
+	Panel panel;
+	Button autoB, resetB, applyB, setB;
+	int previousImageID;
+	int previousImageType;
+	int previousRoiHashCode;
+	double previousMin, previousMax;
+	int previousSlice;
+	boolean imageWasUpdated;
+	ImageJ ij;
+	double minThreshold, maxThreshold;  // 0-255
+	Scrollbar minSlider, maxSlider;
+	TextField minLabel, maxLabel;           // for current threshold
+	Label percentiles;
+	boolean done;
+	int lutColor;
+	Choice methodChoice, modeChoice;
+	Checkbox darkBackground, stackHistogram, rawValues;
+	boolean firstActivation = true;
+	boolean setButtonPressed;
+	boolean noReset = true;
+	boolean noResetChanged;
+	boolean enterPressed;
+
+	public ThresholdAdjuster() {
+		super("Threshold");
+		ImagePlus cimp = WindowManager.getCurrentImage();
+		if (cimp!=null && cimp.getBitDepth()==24) {
+			IJ.error("Threshold Adjuster",
+				"Image>Adjust>Threshold only works with grayscale images.\n \n"
+				+"You can:\n"
+				+"   Convert to grayscale: Image>Type>8-bit\n"
+				+"   Convert to RGB stack: Image>Type>RGB Stack\n"
+				+"   Convert to HSB stack: Image>Type>HSB Stack\n"
+				+"   Convert to 3 grayscale images: Image>Color>Split Channels\n"
+				+"   Do color thresholding: Image>Adjust>Color Threshold\n");
+			return;
+		}
+		if (instance!=null) {
+			instance.firstActivation = true;
+			instance.toFront();
+			instance.setup(cimp, true);
+			instance.updateScrollBars();
+			return;
+		}
+
+		WindowManager.addWindow(this);
+		instance = this;
+		mode = (int)Prefs.get(MODE_KEY, RED);
+		if (mode<RED || mode>OVER_UNDER) mode = RED;
+		setLutColor(mode);
+		IJ.register(PasteController.class);
+
+		ij = IJ.getInstance();
+		Font font = IJ.font10;
+		GridBagLayout gridbag = new GridBagLayout();
+		GridBagConstraints c = new GridBagConstraints();
+		setLayout(gridbag);
+
+		// plot
+		int y = 0;
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.fill = GridBagConstraints.BOTH;
+		c.anchor = GridBagConstraints.CENTER;
+		c.insets = new Insets(10, 10, 0, 10); //top left bottom right
+		add(plot, c);
+		plot.addKeyListener(ij);
+
+		// percentiles
+		c.gridx = 0;
+		c.gridy = y++;
+		c.insets = new Insets(1, 10, 0, 10);
+		percentiles = new Label("");
+		percentiles.setFont(font);
+		add(percentiles, c);
+
+		// minThreshold slider
+		minSlider = new Scrollbar(Scrollbar.HORIZONTAL, sliderRange/3, 1, 0, sliderRange);
+		GUI.fixScrollbar(minSlider);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?90:100;
+		c.fill = GridBagConstraints.HORIZONTAL;
+		c.insets = new Insets(1, 10, 0, 0);
+		add(minSlider, c);
+		minSlider.addAdjustmentListener(this);
+		minSlider.addMouseWheelListener(this);
+//		minSlider.addKeyListener(ij);
+		minSlider.setUnitIncrement(1);
+		minSlider.setFocusable(false);
+
+		// minThreshold slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.weightx = IJ.isMacintosh()?10:0;
+		c.insets = new Insets(5, 0, 0, 10);
+		String text = "000000";
+		int columns = 4;
+		minLabel = new TextField(text,columns);
+		minLabel.setFont(font);
+		add(minLabel, c);
+		minLabel.addFocusListener(this);
+		minLabel.addMouseWheelListener(this);
+		minLabel.addKeyListener(this);
+
+		// maxThreshold slider
+		maxSlider = new Scrollbar(Scrollbar.HORIZONTAL, sliderRange*2/3, 1, 0, sliderRange);
+		GUI.fixScrollbar(maxSlider);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 1;
+		c.weightx = 100;
+		c.insets = new Insets(2, 10, 0, 0);
+		add(maxSlider, c);
+		maxSlider.addAdjustmentListener(this);
+		maxSlider.addMouseWheelListener(this);
+//		maxSlider.addKeyListener(ij);
+		maxSlider.setUnitIncrement(1);
+		maxSlider.setFocusable(false);
+
+		// maxThreshold slider label
+		c.gridx = 1;
+		c.gridwidth = 1;
+		c.weightx = 0;
+		c.insets = new Insets(2, 0, 0, 10);
+		maxLabel = new TextField(text,columns);
+		maxLabel.setFont(font);
+		add(maxLabel, c);
+		maxLabel.addFocusListener(this);
+		maxLabel.addMouseWheelListener(this);
+		maxLabel.addKeyListener(this);
+
+		// choices
+		panel = new Panel();
+		methodChoice = new Choice();
+		for (int i=0; i<methodNames.length; i++)
+			methodChoice.addItem(methodNames[i]);
+		methodChoice.select(method);
+		methodChoice.addItemListener(this);
+		//methodChoice.addKeyListener(ij);
+		panel.add(methodChoice);
+		modeChoice = new Choice();
+		for (int i=0; i<modes.length; i++)
+			modeChoice.addItem(modes[i]);
+		modeChoice.select(mode);
+		modeChoice.addItemListener(this);
+		//modeChoice.addKeyListener(ij);
+		panel.add(modeChoice);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(8, 5, 0, 5);
+		c.anchor = GridBagConstraints.CENTER;
+		c.fill = GridBagConstraints.NONE;
+		add(panel, c);
+
+		// checkboxes
+		panel = new Panel();
+		panel.setLayout(new GridLayout(2, 2));
+		boolean db = Prefs.get(DARK_BACKGROUND, Prefs.blackBackground?true:false);
+		darkBackground = new Checkbox("Dark background");
+		darkBackground.setState(db);
+		darkBackground.addItemListener(this);
+		panel.add(darkBackground);
+		stackHistogram = new Checkbox("Stack histogram");
+		stackHistogram.setState(false);
+		stackHistogram.addItemListener(this);
+		panel.add(stackHistogram); 
+		rawValues = new Checkbox("Raw values");
+		rawValues.setState(Prefs.get(RAW_VALUES, false));
+		rawValues.addItemListener(this);
+		panel.add(rawValues);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(2, 5, 5, 0);
+		add(panel, c);
+
+		// buttons
+		int trim = IJ.isMacOSX()?11:0;
+		panel = new Panel();
+		int hgap = IJ.isMacOSX()?1:5;
+		panel.setLayout(new FlowLayout(FlowLayout.RIGHT,hgap,0));
+		autoB = new TrimmedButton("Auto",trim);
+		autoB.addActionListener(this);
+		autoB.addKeyListener(ij);
+		panel.add(autoB);
+		applyB = new TrimmedButton("Apply",trim);
+		applyB.addActionListener(this);
+		applyB.addKeyListener(ij);
+		panel.add(applyB);
+		resetB = new TrimmedButton("Reset",trim);
+		resetB.addActionListener(this);
+		resetB.addKeyListener(ij);
+		panel.add(resetB);
+		setB = new TrimmedButton("Set",trim);
+		setB.addActionListener(this);
+		setB.addKeyListener(ij);
+		panel.add(setB);
+		c.gridx = 0;
+		c.gridy = y++;
+		c.gridwidth = 2;
+		c.insets = new Insets(0, 5, 10, 5);
+		add(panel, c);
+
+ 		addKeyListener(ij);  // ImageJ handles keyboard shortcuts
+		GUI.scale(this);
+		pack();
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null)
+			setLocation(loc);
+		else
+			GUI.centerOnImageJScreen(this);
+		if (IJ.isMacOSX()) setResizable(false);
+		show();
+
+		thread = new Thread(this, "ThresholdAdjuster");
+		//thread.setPriority(thread.getPriority()-1);
+		thread.start();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		ImagePlus.addImageListener(this);
+		if (imp!=null) {
+			setup(imp, true);
+			updateScrollBars();
+		}
+	}
+
+	public synchronized void adjustmentValueChanged(AdjustmentEvent e) {
+		if (e.getSource()==minSlider)
+			minValue = minSlider.getValue();
+		else
+			maxValue = maxSlider.getValue();
+		enterPressed = false;
+		notify();
+	}
+
+	public synchronized void actionPerformed(ActionEvent e) {
+		Button b = (Button)e.getSource();
+		if (b==null) return;
+		if (b==resetB)
+			doReset = true;
+		else if (b==autoB)
+			doAutoAdjust = true;
+		else if (b==applyB)
+			doApplyLut = true;
+		else if (b==setB) {
+			doSet = true;
+			setButtonPressed = true;
+		}
+		notify();
+	}
+
+    public synchronized void focusLost(FocusEvent e) {
+        doSet = true;
+		notify();
+    }
+
+	public synchronized void mouseWheelMoved(MouseWheelEvent e)	{
+		if (e.getSource()==minSlider || e.getSource()==minLabel) {
+			minSlider.setValue(minSlider.getValue() + e.getWheelRotation());
+			minValue = minSlider.getValue();
+		} else {
+			maxSlider.setValue(maxSlider.getValue() + e.getWheelRotation());
+			maxValue = maxSlider.getValue();
+		}
+		notify();
+	}
+
+	public synchronized void keyPressed(KeyEvent e) {
+		if (e.getKeyCode() == KeyEvent.VK_ENTER) {
+			doSet = true;
+			enterPressed = true;
+		} else if(e.getKeyCode() == KeyEvent.VK_DOWN) {
+			if (e.getSource()==minLabel) {
+				minSlider.setValue(minSlider.getValue() - 1);
+				minValue = minSlider.getValue();
+			} else {
+				maxSlider.setValue(maxSlider.getValue() - 1);
+				maxValue = maxSlider.getValue();
+			}
+		} else if(e.getKeyCode() == KeyEvent.VK_UP) {
+			if (e.getSource()==minLabel) {
+				minSlider.setValue(minSlider.getValue() + 1);
+				minValue = minSlider.getValue();
+			} else {
+				maxSlider.setValue(maxSlider.getValue() + 1);
+				maxValue = maxSlider.getValue();
+			}
+		} else return;
+		notify();
+	}
+
+	public void keyReleased(KeyEvent e) {}
+	public void keyTyped(KeyEvent e) {}
+
+	public void imageUpdated(ImagePlus imp) {
+		if (imp.getID()==previousImageID && Thread.currentThread()!=thread)
+			imageWasUpdated = true;
+	}
+
+	public void imageOpened(ImagePlus imp) {}
+	public void imageClosed(ImagePlus imp) {}
+
+	void setLutColor(int mode) {
+		switch (mode) {
+			case RED:
+				lutColor = ImageProcessor.RED_LUT;
+				break;
+			case BLACK_AND_WHITE:
+				lutColor = ImageProcessor.BLACK_AND_WHITE_LUT;
+				break;
+			case OVER_UNDER:
+				lutColor = ImageProcessor.OVER_UNDER_LUT;
+				break;
+		}
+	}
+
+	public synchronized void itemStateChanged(ItemEvent e) {
+		Object source = e.getSource();
+		if (source==methodChoice) {
+			method = methodChoice.getSelectedItem();
+			doAutoAdjust = true;
+		} else if (source==modeChoice) {
+			mode = modeChoice.getSelectedIndex();
+			setLutColor(mode);
+			doStateChange = true;
+			if (Recorder.record) {
+				if (Recorder.scriptMode())
+					Recorder.recordCall("ThresholdAdjuster.setMode(\""+modes[mode]+"\");");
+				else
+					Recorder.recordString("call(\"ij.plugin.frame.ThresholdAdjuster.setMode\", \""+modes[mode]+"\");\n");
+			}
+		} else if (source==darkBackground) {
+			doBackground = true;
+		} else if (source==rawValues) {
+			ThresholdAdjuster.update();
+		} else
+			doAutoAdjust = true;
+		notify();
+	}
+
+	/** Called before each user interface action.
+	 *  Auto-thresholding is performed if there is currently no threshold and 'enableAutoThreshold' is true.
+	 *  Returns the ImageProcessor of the image that should be used, or null if no appropriate image.
+	*/
+	ImageProcessor setup(ImagePlus imp, boolean enableAutoThreshold) {
+		if (IJ.debugMode) IJ.log("ThresholdAdjuster.setup: enableAuto="+enableAutoThreshold);
+		if (imp==null)
+			return null;
+		ImageProcessor ip;
+		int type = imp.getType();
+		if (type==ImagePlus.COLOR_RGB || (imp.isComposite()&&((CompositeImage)imp).getMode()==IJ.COMPOSITE))
+			return null;
+		ip = imp.getProcessor();
+		boolean minMaxChange = false;
+		boolean not8Bits = type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32;
+		int slice = imp.getCurrentSlice();
+		if (not8Bits) {
+			if (ip.getMin()==plot.stackMin && ip.getMax()==plot.stackMax && !imageWasUpdated)
+				minMaxChange = false;
+			else if (ip.getMin()!=previousMin || ip.getMax()!=previousMax || imageWasUpdated) {
+				minMaxChange = true;
+	 			previousMin = ip.getMin();
+	 			previousMax = ip.getMax();
+	 		} else if (slice!=previousSlice)
+	 			minMaxChange = true;
+		}
+		int id = imp.getID();
+		int roiHashCode = roiHashCode(imp.getRoi());
+		if (minMaxChange || id!=previousImageID || type!=previousImageType ||
+				imageWasUpdated || roiHashCode!=previousRoiHashCode) {
+			minThreshold = ip.getMinThreshold();
+			maxThreshold = ip.getMaxThreshold();
+			boolean isThreshold = minThreshold != ImageProcessor.NO_THRESHOLD
+					&& ip.getCurrentColorModel() != ip.getColorModel(); //does not work???
+			if (not8Bits && minMaxChange && (!noReset || mode==OVER_UNDER)) {
+				double max1 = ip.getMax();
+				resetMinAndMax(ip);
+				if (maxThreshold==max1)
+					maxThreshold = ip.getMax();
+			}
+			ImageStatistics stats = plot.setHistogram(imp, entireStack(imp),rawValues.getState());
+			if (stats == null)
+				return null;
+			if (isThreshold) {
+				minThreshold = scaleDown(ip, minThreshold);
+				maxThreshold = scaleDown(ip, maxThreshold);
+			} else {
+				if (enableAutoThreshold && !isThreshold)
+					autoSetLevels(ip, stats);
+				else
+					minThreshold = ImageProcessor.NO_THRESHOLD;  //may be an invisible threshold after 'apply'
+			}
+			scaleUpAndSet(ip, minThreshold, maxThreshold);
+			updateLabels(imp, ip);
+			updatePercentiles(imp, ip);
+			updatePlot(ip);
+			//updateScrollBars();
+			imp.updateAndDraw();
+			imageWasUpdated = false;
+		}
+	 	previousImageID = id;
+	 	previousImageType = type;
+	 	previousRoiHashCode = roiHashCode;
+	 	previousSlice = slice;
+	 	firstActivation = false;
+	 	return ip;
+	}
+
+	private void resetMinAndMax(ImageProcessor ip) {
+		if (ip.getBitDepth()!=8 && (!noReset || mode==OVER_UNDER)) {
+			ImageStatistics stats = ip.getStats();
+			if (ip.getMin()!=stats.min || ip.getMax()!=stats.max) {
+				ip.resetMinAndMax();
+				ContrastAdjuster.update();
+			} else
+				ip.resetMinAndMax();
+		}
+	}
+
+	boolean entireStack(ImagePlus imp) {
+		return stackHistogram!=null && stackHistogram.getState() && imp.getStackSize()>1;
+	}
+
+	void autoSetLevels(ImageProcessor ip, ImageStatistics stats) {
+		if (stats==null || stats.histogram==null) {
+			minThreshold = defaultMinThreshold;
+			maxThreshold = defaultMaxThreshold;
+			return;
+		}
+		int modifiedModeCount = stats.histogram[stats.mode];
+		if (!method.equals(methodNames[DEFAULT]))
+			stats.histogram[stats.mode] = plot.originalModeCount;
+		int threshold = thresholder.getThreshold(method, stats.histogram);
+		stats.histogram[stats.mode] = modifiedModeCount;
+		if (thresholdHigh(ip))  // dark background for non-inverting LUT, or bright background for inverting LUT
+			{minThreshold=threshold+1; maxThreshold=255;}
+		else
+			{minThreshold=0; maxThreshold=threshold;}
+		if (minThreshold>255)
+			minThreshold = 255;
+		if (Recorder.record) {
+			boolean stack = stackHistogram!=null && stackHistogram.getState();
+			if (noReset && ip.getBitDepth()!=8) {
+				ImageStatistics stats2 = ip.getStats();
+				if (ip.getMin()>stats2.min || ip.getMax()<stats2.max)
+					ContrastAdjuster.recordSetMinAndMax(ip.getMin(),ip.getMax());
+			}
+			boolean darkb = darkBackground!=null && darkBackground.getState();
+			String options = method+(darkb?" dark":"")+(noReset?" no-reset":"")+(stack?" stack":"");
+			if (Recorder.scriptMode())
+				Recorder.recordCall("IJ.setAutoThreshold(imp, \""+options+"\");");
+			else
+				Recorder.record("setAutoThreshold", options);
+		}
+	}
+
+	/** Whether the (auto)-thresholded pixels should be those 
+	 * with high values, i.e., the background should be at low values.
+	 * (E.g. dark background and non-inverting LUT)
+	*/
+	boolean thresholdHigh(ImageProcessor ip) {
+		boolean darkb = darkBackground!=null && darkBackground.getState();
+		boolean invertedLut = ip.isInvertedLut();
+		return invertedLut ? !darkb : darkb;
+	}
+
+	/** Scales threshold levels in the range 0-255 to the actual levels. */
+	void scaleUpAndSet(ImageProcessor ip, double lower, double upper) {
+		ip.scaleAndSetThreshold(lower, upper, lutColor);
+	}
+
+	/** Scales a threshold level to the range 0-255. */
+	double scaleDown(ImageProcessor ip, double threshold) {
+		if (ip instanceof ByteProcessor)
+			return threshold;
+		double min = ip.getMin();
+		double max = ip.getMax();
+		if (max>min) {
+			double scaledThr = ((threshold-min)/(max-min))*255.0;
+			if (scaledThr < 0.0) scaledThr = 0.0;
+			if (scaledThr > 255.0) scaledThr = 255.0;
+			return scaledThr;
+		} else
+			return ImageProcessor.NO_THRESHOLD;
+	}
+
+	/** Scales a threshold level in the range 0-255 to the actual level. */
+	double scaleUp(ImageProcessor ip, double threshold) {
+		double min = ip.getMin();
+		double max = ip.getMax();
+		if (max>min)
+			return min + (threshold/255.0)*(max-min);
+		else
+			return ImageProcessor.NO_THRESHOLD;
+	}
+
+	void updatePlot(ImageProcessor ip) {
+		int min = (int)Math.round(minThreshold);
+		if (min<0) min=0;
+ 		if (min>255) min=255;
+ 		if (ip.getMinThreshold()==ImageProcessor.NO_THRESHOLD)
+			min = -1;
+ 		int max = (int)Math.round(maxThreshold);
+ 		if (max<0) max=0;
+ 		if (max>255) max=255;
+ 		plot.setThreshold(min,max);
+		plot.mode = mode;
+		plot.repaint();
+	}
+
+	void updatePercentiles(ImagePlus imp, ImageProcessor ip) {
+		if (percentiles==null)
+			return;
+		ImageStatistics stats = plot.stats;
+		int minThresholdInt = (int)Math.round(minThreshold);
+		if (minThresholdInt<0) minThresholdInt=0;
+		if (minThresholdInt>255) minThresholdInt=255;
+		int maxThresholdInt = (int)Math.round(maxThreshold);
+		if (maxThresholdInt<0) maxThresholdInt=0;
+		if (maxThresholdInt>255) maxThresholdInt=255;
+		if (stats!=null && stats.histogram!=null && stats.histogram.length==256
+		&& ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+			int[] histogram = stats.histogram;
+			int below = 0, inside = 0, above = 0;
+			int minValue=0, maxValue=255;
+			if (imp.getBitDepth()==16 && !entireStack(imp)) {   //16-bit histogram for better accuracy
+				ip.setRoi(imp.getRoi());
+				histogram = ip.getHistogram();
+				minThresholdInt = (int)Math.round(ip.getMinThreshold());
+				if (minThresholdInt<0) minThresholdInt=0;
+				maxThresholdInt = (int)Math.round(ip.getMaxThreshold());
+				if (maxThresholdInt>65535) maxThresholdInt=65535;
+				minValue=0; maxValue=histogram.length-1;
+			}
+			for (int i=minValue; i<minThresholdInt; i++)
+				below += histogram[i];
+			for (int i=minThresholdInt; i<=maxThresholdInt; i++)
+				inside += histogram[i];
+			for (int i=maxThresholdInt+1; i<=maxValue; i++)
+				above += histogram[i];
+			int total = below + inside + above;
+			//IJ.log("<"+minThresholdInt+":"+below+" in:"+inside+"; >"+maxThresholdInt+":"+above+" sum="+total);
+			if (mode==OVER_UNDER)
+				percentiles.setText("below: "+IJ.d2s(100.*below/total)+" %,  above: "+IJ.d2s(100.*above/total)+" %");
+			else
+				percentiles.setText(IJ.d2s(100.*inside/total)+" %");
+		} else
+			percentiles.setText("");
+	}
+
+	void updateLabels(ImagePlus imp, ImageProcessor ip) {
+		if (minLabel==null || maxLabel==null || enterPressed)
+			return;
+		double min = ip.getMinThreshold();
+		double max = ip.getMaxThreshold();
+		if (min==ImageProcessor.NO_THRESHOLD) {
+			minLabel.setText("");
+			maxLabel.setText("");
+		} else {
+			Calibration cal = imp.getCalibration();
+			boolean calibrated = cal.calibrated() && !rawValues.getState();
+			if (calibrated) {
+				min = cal.getCValue((int)min);
+				max = cal.getCValue((int)max);
+			}
+			if ((((int)min==min && (int)max==max && Math.abs(min)<1e6 && Math.abs(max)<1e6)) ||
+					(ip instanceof ShortProcessor && (cal.isSigned16Bit() || !calibrated))) {
+				minLabel.setText(ResultsTable.d2s(min,0));
+				maxLabel.setText(ResultsTable.d2s(max,0));
+			} else {
+				minLabel.setText(min==-1e30 ? "-1e30" : d2s(min));
+				maxLabel.setText(max== 1e30 ? "1e30" : d2s(max));
+			}
+		}
+	}
+
+	/** Converts a number to a String, such that it should not take much space (for the minLabel, maxLabel TextFields) */
+	String d2s(double x) {
+		return Math.abs(x)>=1e6 ? IJ.d2s(x,-2) : ResultsTable.d2s(x,2);  //the latter uses exp notation also for small x
+	}
+
+	void updateScrollBars() {
+		minSlider.setValue((int)minThreshold);
+		maxSlider.setValue((int)maxThreshold);
+	}
+
+	/** Restore image outside non-rectangular roi. */
+  	void doMasking(ImagePlus imp, ImageProcessor ip) {
+		ImageProcessor mask = imp.getMask();
+		if (mask!=null)
+			ip.reset(mask);
+	}
+
+	void adjustMinThreshold(ImagePlus imp, ImageProcessor ip, double value) {
+		if (IJ.altKeyDown() || IJ.shiftKeyDown() ) {
+			double width = maxThreshold-minThreshold;
+			if (width<1.0) width = 1.0;
+			minThreshold = value;
+			maxThreshold = minThreshold+width;
+			if ((minThreshold+width)>255) {
+				minThreshold = 255-width;
+				maxThreshold = minThreshold+width;
+				minSlider.setValue((int)minThreshold);
+			}
+			maxSlider.setValue((int)maxThreshold);
+			scaleUpAndSet(ip, minThreshold, maxThreshold);
+			return;
+		}
+		minThreshold = value;
+		if (maxThreshold<minThreshold) {
+			maxThreshold = minThreshold;
+			maxSlider.setValue((int)maxThreshold);
+		}
+		scaleUpAndSet(ip, minThreshold, maxThreshold);
+	}
+
+	void adjustMaxThreshold(ImagePlus imp, ImageProcessor ip, int cvalue) {
+		maxThreshold = cvalue;
+		if (minThreshold>maxThreshold) {
+			minThreshold = maxThreshold;
+			minSlider.setValue((int)minThreshold);
+		}
+		if (minThreshold < 0) {     //remove NO_THRESHOLD
+			minThreshold = 0;
+			minSlider.setValue((int)minThreshold);
+		}
+		scaleUpAndSet(ip, minThreshold, maxThreshold);
+		IJ.setKeyUp(KeyEvent.VK_ALT);
+		IJ.setKeyUp(KeyEvent.VK_SHIFT);
+	}
+
+	void reset(ImagePlus imp, ImageProcessor ip) {
+		if (noResetChanged) {
+			noResetChanged = false;
+			if ((noReset&&mode!=OVER_UNDER) || ip.getBitDepth()==8)
+				return;
+			if (!noReset) {
+				ImageStatistics stats = ip.getStats();
+				if (ip.getMin()==stats.min && ip.getMax()==stats.max)
+					return; // not contrast enhanced; no need to reset
+			}
+		}
+		ip.resetThreshold();
+		if (!noReset)
+			resetMinAndMax(ip);
+		ImageStatistics stats = plot.setHistogram(imp, entireStack(imp),rawValues.getState());
+		if (ip.getBitDepth()!=8 && entireStack(imp))
+			ip.setMinAndMax(stats.min, stats.max);
+		updateScrollBars();
+		if (Recorder.record) {
+			if (Recorder.scriptMode())
+				Recorder.recordCall("IJ.resetThreshold(imp);");
+			else
+				Recorder.record("resetThreshold");
+		}
+	}
+
+	/** Numeric input via 'Set' dialog or minLabel, maxLabel TextFields */
+	void doSet(ImagePlus imp, ImageProcessor ip) {
+		double level1 = ip.getMinThreshold();
+		double level2 = ip.getMaxThreshold();
+		Calibration cal = imp.getCalibration();
+		if (level1==ImageProcessor.NO_THRESHOLD) {
+			level1 = scaleUp(ip, defaultMinThreshold);
+			level2 = scaleUp(ip, defaultMaxThreshold);
+		}
+		boolean calibrated = cal.calibrated() && !rawValues.getState();
+		if (calibrated) {
+			level1 = cal.getCValue(level1);
+			level2 = cal.getCValue(level2);
+		}
+		if (setButtonPressed) {
+				int digits = (ip instanceof FloatProcessor)||(calibrated && !cal.isSigned16Bit()) ? Math.max(Analyzer.getPrecision(), 4) : 0;
+			GenericDialog gd = new GenericDialog("Set Threshold Levels");
+			gd.addNumericField("Lower threshold level: ", level1, Math.abs(level1)<1e7 ? digits : -4, 10, null);
+			gd.addNumericField("Upper threshold level: ", level2, Math.abs(level2)<1e7 ? digits : -4, 10, null);
+			gd.showDialog();
+			if (gd.wasCanceled()) {
+				setButtonPressed = false;
+				return;
+			}
+			level1 = gd.getNextNumber();
+			level2 = gd.getNextNumber();
+			setButtonPressed = false;
+		} else {
+			level1 = Tools.parseDouble(minLabel.getText(), level1);
+			level2 = Tools.parseDouble(maxLabel.getText(), level2);
+		}
+		enterPressed = false;
+		if (calibrated) {
+			level1 = cal.getRawValue(level1);
+			level2 = cal.getRawValue(level2);
+		}
+		if (level2<level1)
+			level2 = level1;
+		double minDisplay = ip.getMin();
+		double maxDisplay = ip.getMax();
+		if (noReset && (level1<minDisplay||level2>maxDisplay)) {
+			noReset = false;
+			noResetChanged = true;
+			//noResetButton.setState(false);
+		}
+		resetMinAndMax(ip);
+		double minValue = ip.getMin();
+		double maxValue = ip.getMax();
+		if (imp.getStackSize()==1) {
+			if (level1<minValue) level1 = minValue;
+			if (level2>maxValue) level2 = maxValue;
+		}
+		IJ.wait(500);
+		ip.setThreshold(level1, level2, lutColor);
+		ip.setSnapshotPixels(null); // disable undo
+		previousImageID = 0;
+		setup(imp, false);
+		updateScrollBars();
+		if (Recorder.record) {
+			if (imp.getBitDepth()==32) {
+				if (Recorder.scriptMode())
+					Recorder.recordCall("IJ.setThreshold(imp, "+IJ.d2s(ip.getMinThreshold(),4)+", "+IJ.d2s(ip.getMaxThreshold(),4)+");");
+				else
+					Recorder.record("setThreshold", ip.getMinThreshold(), ip.getMaxThreshold());
+			} else {
+				int min = (int)ip.getMinThreshold();
+				int max = (int)ip.getMaxThreshold();
+				if (cal.isSigned16Bit()) {
+					min = (int)cal.getCValue(level1);
+					max = (int)cal.getCValue(level2);
+					if (Recorder.scriptMode())
+						Recorder.recordCall("IJ.setThreshold(imp, "+min+", "+max+");");
+					else
+						Recorder.record("setThreshold", min, max);
+				}
+				if (Recorder.scriptMode())
+					Recorder.recordCall("IJ.setRawThreshold(imp, "+min+", "+max+", null);");
+				else {
+					if (calibrated)
+						Recorder.record("setThreshold", min, max, "raw");
+					else
+						Recorder.record("setThreshold", min, max);
+				}
+			}
+		}
+	}
+
+	void changeState(ImagePlus imp, ImageProcessor ip) {
+		scaleUpAndSet(ip, minThreshold, maxThreshold);
+		updateScrollBars();
+	}
+
+	void autoThreshold(ImagePlus imp, ImageProcessor ip) {
+		ip.resetThreshold();
+		previousImageID = 0;
+		setup(imp, true);
+		updateScrollBars();
+ 	}
+
+	/** User has clicked 'Dark background'.
+	 *  Switch only if the current thresholds are consistent with
+	 * the previous 'Dark background' state.
+	*/
+	void switchBackground(ImagePlus imp, ImageProcessor ip) {
+		if (minThreshold < 0) {     //remove NO_THRESHOLD
+			autoThreshold(imp, ip);
+			return;
+		}
+		if (thresholdHigh(ip)) {
+			if (minThreshold == 0) {
+				minThreshold = maxThreshold+1;
+				if (minThreshold > 255) minThreshold = 255;
+				maxThreshold = 255;
+			}
+		} else {
+			if (maxThreshold == 255) {
+				maxThreshold = minThreshold-1;
+				if (maxThreshold < 0) maxThreshold = 0;
+				minThreshold = 0;
+			}
+		}
+		minSlider.setValue((int)minThreshold);
+		maxSlider.setValue((int)maxThreshold);
+		scaleUpAndSet(ip, minThreshold, maxThreshold);
+	}
+
+ 	void apply(ImagePlus imp) {
+ 		if (imp.getProcessor().getMinThreshold()==ImageProcessor.NO_THRESHOLD) {
+ 			IJ.error("Thresholder", "Threshold is not set");
+ 			return;
+ 		}
+ 		try {
+ 			if (imp.getBitDepth()==32) {
+				YesNoCancelDialog d = new YesNoCancelDialog(null, "Thresholder",
+					"Convert to 8-bit mask or set background pixels to NaN?",  "Convert to Mask", "Set to NaN");
+				if (d.cancelPressed())
+					return;
+				else if (!d.yesPressed()) {
+					Recorder.recordInMacros = true;
+					IJ.run("NaN Background");
+					Recorder.recordInMacros = false;
+					return;
+				}
+			}
+			runThresholdCommand();
+ 		} catch (Exception e) {}
+ 	}
+
+ 	void runThresholdCommand() {
+		Thresholder.setMethod(method);
+		Thresholder.setBackground(darkBackground.getState()?"Dark":"Light");
+		if (Recorder.record) {
+			Recorder.setCommand("Convert to Mask");
+			(new Thresholder()).run("mask");
+			Recorder.saveCommand();
+		} else
+			(new Thresholder()).run("mask");
+	}
+
+	static final int RESET=0, AUTO=1, HIST=2, APPLY=3, STATE_CHANGE=4, MIN_THRESHOLD=5, MAX_THRESHOLD=6, SET=7, BACKGROUND=8;
+
+	// Separate thread that does the potentially time-consuming processing
+	public void run() {
+		while (!done) {
+			synchronized(this) {
+				if (!doAutoAdjust && !doReset && !doApplyLut && !doStateChange && !doSet && !doBackground && minValue<0 &&  maxValue<0) {
+					try {wait();}
+					catch(InterruptedException e) {}
+				}
+			}
+			doUpdate();
+		}
+	}
+
+	/** Triggered by the user interface, with the corresponding boolean, e.g., 'doAutoAdjust' */
+	void doUpdate() {
+		ImagePlus imp;
+		ImageProcessor ip;
+		int action;
+		int min = minValue;
+		int max = maxValue;
+		if (doReset)            { action = RESET;        doReset = false; }
+		else if (doAutoAdjust)  { action = AUTO;         doAutoAdjust = false; }
+		else if (doApplyLut)    { action = APPLY;        doApplyLut = false; }
+		else if (doStateChange) { action = STATE_CHANGE; doStateChange = false; }
+		else if (doSet)         { action = SET;          doSet = false; }
+		else if (doBackground)  { action = BACKGROUND;   doBackground = false; }
+		else if (minValue>=0)   { action = MIN_THRESHOLD; minValue = -1; }
+		else if (maxValue>=0)   { action = MAX_THRESHOLD; maxValue = -1; }
+		else return;
+
+		imp = WindowManager.getCurrentImage();
+		if (imp==null) {
+			IJ.beep();
+			IJ.showStatus("No image");
+			return;
+		}
+		ip = setup(imp, false);
+		if (ip==null) {
+			imp.unlock();
+			IJ.beep();
+			if (imp.isComposite())
+				IJ.showStatus("\"Composite\" mode images cannot be thresholded");
+			else
+				IJ.showStatus("RGB images cannot be thresholded");
+			return;
+		}
+		switch (action) {
+			case RESET: reset(imp, ip); break;
+			case AUTO: autoThreshold(imp, ip); break;
+			case APPLY: apply(imp); break;
+			case STATE_CHANGE: changeState(imp, ip); break;
+			case SET: doSet(imp, ip); break;
+			case MIN_THRESHOLD: adjustMinThreshold(imp, ip, min); break;
+			case MAX_THRESHOLD: adjustMaxThreshold(imp, ip, max); break;
+			case BACKGROUND: switchBackground(imp, ip); break;
+		}
+		updatePlot(ip);
+		updateLabels(imp, ip);
+		updatePercentiles(imp, ip);
+		ip.setLutAnimation(true);
+		imp.updateAndDraw();
+	}
+
+	/** Overrides close() in PlugInFrame. */
+    public void close() {
+    	super.close();
+		instance = null;
+		done = true;
+		Prefs.saveLocation(LOC_KEY, getLocation());
+		Prefs.set(MODE_KEY, mode);
+		Prefs.set(DARK_BACKGROUND, darkBackground.getState());
+		Prefs.set(RAW_VALUES, rawValues.getState());
+		synchronized(this) {
+			notify();
+		}
+	}
+
+    public void windowActivated(WindowEvent e) {
+    	super.windowActivated(e);
+    	plot.requestFocus();
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (!firstActivation && imp!=null) {
+			setup(imp, false);
+			updateScrollBars();
+		}
+	}
+
+	// Returns a hashcode for the specified ROI that typically changes
+	// if it is moved,  even though is still the same object.
+	int roiHashCode(Roi roi) {
+		return roi!=null?roi.getHashCode():0;
+	}
+
+	/** Notifies the ThresholdAdjuster that the image has changed.
+	 *  If the image has no threshold, it does not autothreshold the image.
+	*/
+	public static void update() {
+		if (instance!=null) {
+			ThresholdAdjuster ta = ((ThresholdAdjuster)instance);
+			ImagePlus imp = WindowManager.getCurrentImage();
+			if (imp!=null && ta.previousImageID==imp.getID()) {
+				if ((imp.getCurrentSlice()!=ta.previousSlice) && ta.entireStack(imp))
+					return;
+				ta.previousImageID = 0;
+				ta.setup(imp, false);
+				ta.updateScrollBars();
+			}
+		}
+	}
+	
+	public static boolean isDarkBackground() {
+		return instance!=null?instance.darkBackground.getState():false;
+	}
+
+
+	/** Returns the current thresholding method ("Default", "Huang", etc). */
+	public static String getMethod() {
+		return method;
+	}
+
+	/** Sets the thresholding method ("Default", "Huang", etc). */
+	public static void setMethod(String thresholdingMethod) {
+		boolean valid = false;
+		for (int i=0; i<methodNames.length; i++) {
+			if (methodNames[i].equals(thresholdingMethod)) {
+				valid = true;
+				break;
+			}
+		}
+		if (valid) {
+			method = thresholdingMethod;
+			if (instance!=null)
+				instance.methodChoice.select(method);
+		}
+	}
+
+	/** Returns the current mode ("Red","B&W" or"Over/Under"). */
+	public static String getMode() {
+		return modes[mode];
+	}
+
+	/** Sets the current mode ("Red","B&W" or"Over/Under"). */
+	public static void setMode(String tmode) {
+		if (instance!=null) synchronized (instance) {
+			ThresholdAdjuster ta = ((ThresholdAdjuster)instance);
+			if (modes[0].equals(tmode))
+				mode = 0;
+			else if (modes[1].equals(tmode))
+				mode = 1;
+			else if (modes[2].equals(tmode))
+				mode = 2;
+			else
+				return;
+			ta.setLutColor(mode);
+			ta.doStateChange = true;
+			ta.modeChoice.select(mode);
+			ta.notify();
+		}
+	}
+
+} // ThresholdAdjuster class
+
+
+class ThresholdPlot extends Canvas implements Measurements, MouseListener {
+	double scale = Prefs.getGuiScale();
+	int width = (int)Math.round(256*scale);
+	int height= (int)Math.round(48*scale);
+	int lowerThreshold = -1;
+ 	int upperThreshold = (int)Math.round(170*scale);
+
+	ImageStatistics stats;
+	int[] histogram;
+	Color[] hColors;
+	int hmax;               // maximum of histogram to display
+	Image os;
+	Graphics osg;
+	int mode;
+	int originalModeCount;
+	double stackMin, stackMax;
+	int imageID2;           // ImageID of previous call
+	boolean entireStack2;   // 'entireStack' of previous call
+	double mean2;
+
+	public ThresholdPlot() {
+		addMouseListener(this);
+		setSize(width+2, height+2);
+	}
+
+    /** Overrides Component getPreferredSize(). Added to work
+    	around a bug in Java 1.4.1 on Mac OS X.*/
+    public Dimension getPreferredSize() {
+        return new Dimension(width+2, height+2);
+    }
+
+	ImageStatistics setHistogram(ImagePlus imp, boolean entireStack, boolean rawValues) {
+		if (IJ.debugMode) IJ.log("ThresholdAdjuster:setHistogram: "+entireStack+" "+entireStack2);
+		double mean = entireStack?imp.getProcessor().getStats().mean:0.0;
+		if (entireStack && stats!=null && imp.getID()==imageID2
+		&& entireStack==entireStack2 && mean==mean2)
+			return stats;
+		mean2 = mean;
+		ImageProcessor ip = imp.getProcessor();
+		ColorModel cm = ip.getColorModel();
+		stats = null;
+		if (entireStack) {
+			if (imp.isHyperStack()) {
+				ImageStack stack = ChannelSplitter.getChannel(imp, imp.getChannel());
+				stats = new StackStatistics(new ImagePlus("", stack));
+			} else
+				stats = new StackStatistics(imp);
+		}
+		if (!(ip instanceof ByteProcessor)) {
+			if (entireStack) {
+				if (imp.getLocalCalibration().isSigned16Bit())
+					{stats.min += 32768; stats.max += 32768;}
+				stackMin = stats.min;
+				stackMax = stats.max;
+				ip.setMinAndMax(stackMin, stackMax);
+				imp.updateAndDraw();
+			} else {
+				stackMin = stackMax = 0.0;
+				if (entireStack2) {
+					ip.resetMinAndMax();
+					imp.updateAndDraw();
+				}
+			}
+			Calibration cal = imp.getCalibration();
+			boolean calibrated = cal.calibrated() && !rawValues;
+			if (ip instanceof FloatProcessor) {
+				int digits = Math.max(Analyzer.getPrecision(), 2);
+				IJ.showStatus("min="+IJ.d2s(ip.getMin(),digits)+", max="+IJ.d2s(ip.getMax(),digits));
+			} else {
+				int digits = calibrated && !cal.isSigned16Bit() ? 2 : 0;
+				double cmin = calibrated?cal.getCValue(ip.getMin()):ip.getMin();
+				double cmax = calibrated?cal.getCValue(ip.getMax()):ip.getMax();
+				IJ.showStatus("min="+IJ.d2s(cal.getCValue(cmin), digits)+", max="+IJ.d2s(cal.getCValue(cmax), digits));
+			}
+			ip = ip.convertToByte(true);
+			ip.setColorModel(ip.getDefaultColorModel());
+		}
+		Roi roi = imp.getRoi();
+		if (roi!=null && !roi.isArea()) roi = null;
+		ip.setRoi(roi);
+		if (stats==null)
+			stats = ip.getStats();
+		if (IJ.debugMode) IJ.log("  stats: "+stats);
+		int maxCount2 = 0;  // number of pixels in 2nd-highest bin, used for y scale if mode is too high
+		histogram = stats.histogram;
+		originalModeCount = histogram[stats.mode];
+		for (int i = 0; i < stats.nBins; i++)
+			if ((histogram[i] > maxCount2) && (i != stats.mode))
+				maxCount2 = histogram[i];
+		hmax = stats.maxCount;
+		if ((hmax>(maxCount2 * 1.5)) && (maxCount2 != 0))
+			hmax = (int)(maxCount2 * 1.2);
+		os = null;
+
+		if (!(cm instanceof IndexColorModel))
+			return null;
+		IndexColorModel icm = (IndexColorModel)cm;
+		int mapSize = icm.getMapSize();
+		if (mapSize!=256)
+			return null;
+		byte[] r = new byte[256];
+		byte[] g = new byte[256];
+		byte[] b = new byte[256];
+		icm.getReds(r);
+		icm.getGreens(g);
+		icm.getBlues(b);
+		hColors = new Color[256];
+		final int brightnessLimit = 1800; // 0 ... 2550 scale; brightness is reduced above
+		for (int i=0; i<256; i++) {     //avoid colors that are too bright (invisible)
+			int sum = 4*(r[i]&255) + 5*(g[i]&255) + (b[i]&255);
+			if (sum > brightnessLimit) {
+				r[i] = (byte)(((r[i]&255)*brightnessLimit*2)/(sum+brightnessLimit));
+				g[i] = (byte)(((g[i]&255)*brightnessLimit*2)/(sum+brightnessLimit));
+				b[i] = (byte)(((b[i]&255)*brightnessLimit*2)/(sum+brightnessLimit));
+			}
+			hColors[i] = new Color(r[i]&255, g[i]&255, b[i]&255);
+		}
+		imageID2 = imp.getID();
+		entireStack2 = entireStack;
+		return stats;
+	}
+
+	public void update(Graphics g) {
+		paint(g);
+	}
+
+	public void paint(Graphics g) {
+		if (g==null) return;
+		if (histogram!=null) {
+			if (os==null && hmax>0) {
+				os = createImage(width,height);
+				osg = os.getGraphics();
+				if (scale>1)
+					((Graphics2D)osg).setStroke(new BasicStroke((float)scale));
+				osg.setColor(Color.white);
+				osg.fillRect(0, 0, width, height);
+				osg.setColor(Color.gray);
+				double scale2 = width/256.0;
+				int barWidth = 1;
+				if (scale>1) barWidth=2;
+				if (scale>2) barWidth=3;
+				for (int i = 0; i < 256; i++) {
+					if (hColors!=null) osg.setColor(hColors[i]);
+					int x =(int)(i*scale2);
+					for (int j = 0; j<barWidth; j++)
+						osg.drawLine(x+j, height, x+j, height - ((int)(height*histogram[i]+hmax-1)/hmax));
+				}
+				osg.dispose();
+			}
+			if (os==null) return;
+			g.drawImage(os, 1, 1, this);
+		} else {
+			g.setColor(Color.white);
+			g.fillRect(1, 1, width, height);
+		}
+		g.setColor(Color.black);
+ 		g.drawRect(0, 0, width+1, height+1);
+ 		if (lowerThreshold==-1)
+ 			return;
+		if (mode==ThresholdAdjuster.OVER_UNDER) {
+			g.setColor(Color.blue);
+			g.drawRect(0, 0, lowerThreshold, height+1);
+			g.drawRect(0, 1, lowerThreshold, 1);
+			g.setColor(Color.green);
+			g.drawRect(upperThreshold+2, 0, width-upperThreshold-1, height+1);
+			g.drawLine(upperThreshold+2, 1, width+1,1);
+			return;
+		}
+		if (mode==ThresholdAdjuster.RED)
+			g.setColor(Color.red);
+		g.drawRect(lowerThreshold+1, 0, upperThreshold-lowerThreshold, height+1);
+		g.drawLine(lowerThreshold+1, 1, upperThreshold+1, 1);
+	}
+	
+	void setThreshold(int min, int max) {
+ 		lowerThreshold = (int)Math.round(min*scale);
+ 		upperThreshold = (int)Math.round(max*scale);
+	}
+
+	public void mousePressed(MouseEvent e) {}
+	public void mouseReleased(MouseEvent e) {}
+	public void mouseExited(MouseEvent e) {}
+	public void mouseClicked(MouseEvent e) {}
+	public void mouseEntered(MouseEvent e) {}
+
+} // ThresholdPlot class
\ No newline at end of file
diff --git a/src/ij/plugin/tool/ArrowTool.java b/src/ij/plugin/tool/ArrowTool.java
new file mode 100644
index 0000000..d8f8ebe
--- /dev/null
+++ b/src/ij/plugin/tool/ArrowTool.java
@@ -0,0 +1,69 @@
+package ij.plugin.tool;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class ArrowTool extends PlugInTool {
+	Roi arrow;
+
+	public void mousePressed(ImagePlus imp, MouseEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		int sx = e.getX();
+		int sy = e.getY();
+		int ox = ic.offScreenX(sx);
+		int oy = ic.offScreenY(sy);
+		Roi roi = imp.getRoi();
+		int handle = roi!=null?roi.isHandle(ox, oy):-1;
+		if (!(roi!=null && (roi instanceof Arrow) && (handle>=0||roi.contains(ox,oy)))) {
+			arrow = new Arrow(sx, sy, imp);
+			if (imp.okToDeleteRoi())
+				imp.setRoi(arrow, false);
+			e.consume();
+		}
+	}
+
+	public void mouseDragged(ImagePlus imp, MouseEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		int sx = e.getX();
+		int sy = e.getY();
+		int ox = ic.offScreenX(sx);
+		int oy = ic.offScreenY(sy);
+		Roi roi = imp.getRoi();
+		if (roi!=null && (roi instanceof Arrow) && roi.contains(ox,oy))
+			roi.mouseDragged(e);
+		else if (arrow!=null)
+			arrow.mouseDragged(e);
+		e.consume();
+	}
+
+	public void mouseReleased(ImagePlus imp, MouseEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		int sx = e.getX();
+		int sy = e.getY();
+		int ox = ic.offScreenX(sx);
+		int oy = ic.offScreenY(sy);
+		Roi roi = imp.getRoi();
+		if (arrow!=null && !(roi!=null && (roi instanceof Arrow) && roi.contains(ox,oy))) {
+			arrow.mouseReleased(e);
+			e.consume();
+		}
+	}
+
+	public void showOptionsDialog() {
+		IJ.doCommand("Arrow Tool...");
+	}
+
+	public String getToolIcon() {
+		return "C037L0ff0L74f0Lb8f0L74b8";
+	}
+
+	public String getToolName() {
+		return "Arrow Tool";
+	}
+	
+}
+
+
diff --git a/src/ij/plugin/tool/BrushTool.java b/src/ij/plugin/tool/BrushTool.java
new file mode 100644
index 0000000..f53ea78
--- /dev/null
+++ b/src/ij/plugin/tool/BrushTool.java
@@ -0,0 +1,324 @@
+package ij.plugin.tool;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.Colors;
+import java.awt.*;
+import java.awt.event.*;
+import java.util.Vector;
+
+// Versions
+// 2012-07-22 shift to confine horizontally or vertically, ctrl-shift to resize, ctrl to pick
+
+/** This class implements the Paintbrush Tool, which allows the user to draw on
+	 an image, or on an Overlay if "Paint on overlay" is enabled. */	
+public class BrushTool extends PlugInTool implements Runnable {
+	
+	private final static int UNCONSTRAINED=0, HORIZONTAL=1, VERTICAL=2, RESIZING=3, RESIZED=4, IDLE=5; //mode flags
+	private static String BRUSH_WIDTH_KEY = "brush.width";
+	private static String PENCIL_WIDTH_KEY = "pencil.width";
+	private static String CIRCLE_NAME = "brush-tool-overlay";
+	private static final String LOC_KEY = "brush.loc";
+	private static final String OVERLAY_KEY = "brush.overlay";
+	
+	private String widthKey;
+	private int width;
+	private ImageProcessor ip;
+	private int mode;  //resizing brush or motion constrained horizontally or vertically
+	private int xStart, yStart;
+	private int oldWidth;
+	private boolean isPencil;
+	private Overlay overlay;
+	private Options options;
+	private GenericDialog gd;
+	private ImageRoi overlayImage;
+	private boolean paintOnOverlay;
+	private static BrushTool brushInstance;
+
+	public void run(String arg) {
+		isPencil = "pencil".equals(arg);
+		widthKey = isPencil ? PENCIL_WIDTH_KEY : BRUSH_WIDTH_KEY;
+		width = (int)Prefs.get(widthKey, isPencil ? 1 : 5);
+		paintOnOverlay = Prefs.get(OVERLAY_KEY, false);
+		Toolbar.addPlugInTool(this);
+		if (!isPencil)
+			brushInstance = this;
+	}
+
+	public void mousePressed(ImagePlus imp, MouseEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		int x = ic.offScreenX(e.getX());
+		int y = ic.offScreenY(e.getY());
+		xStart = x;
+		yStart = y;
+		checkForOverlay(imp);
+		if (overlayImage!=null)
+			ip = overlayImage.getProcessor();
+		else
+			ip = imp.getProcessor();
+		int ctrlMask = IJ.isMacintosh() ? InputEvent.META_MASK : InputEvent.CTRL_MASK;
+		int resizeMask = InputEvent.SHIFT_MASK | ctrlMask;
+		if ((e.getModifiers() & resizeMask) == resizeMask) {
+			mode = RESIZING;
+			oldWidth = width;
+			return;
+		} else if ((e.getModifiers() & ctrlMask) != 0) {
+			boolean altKeyDown = (e.getModifiers() & InputEvent.ALT_MASK) != 0;
+			ic.setDrawingColor(x, y, altKeyDown); //pick color from image (ignore overlay)
+			if (!altKeyDown)
+				setColor(Toolbar.getForegroundColor());
+			mode = IDLE;
+			return;
+		}
+		mode = UNCONSTRAINED;
+		ip.snapshot();
+		Undo.setup(Undo.FILTER, imp);
+		ip.setLineWidth(width);
+		if (e.isAltDown()) {
+			if (overlayImage!=null)
+				ip.setColor(0); //erase
+			else
+				ip.setColor(Toolbar.getBackgroundColor());
+		} else
+			ip.setColor(Toolbar.getForegroundColor());
+		ip.moveTo(x, y);
+		if (!e.isShiftDown()) {
+			ip.lineTo(x, y);
+			if (overlayImage!=null) {
+				overlayImage.setProcessor(ip);
+				imp.draw();
+			} else
+				imp.updateAndDraw();
+		}
+	}
+	
+	private void checkForOverlay(ImagePlus imp) {
+		overlayImage = getOverlayImage(imp);
+		if (overlayImage==null && paintOnOverlay) {
+			ImageProcessor overlayIP = new ColorProcessor(imp.getWidth(), imp.getHeight());
+			ImageRoi imageRoi = new ImageRoi(0, 0, overlayIP);
+			imageRoi.setZeroTransparent(true);
+			imageRoi.setName("[Brush]");
+			Overlay overlay = imp.getOverlay();
+			if (overlay==null)
+				overlay = new Overlay();
+			overlay.add(imageRoi);
+			overlay.selectable(false);
+			imp.setOverlay(overlay);
+			overlayImage = imageRoi;
+		}
+	}
+
+	private ImageRoi getOverlayImage(ImagePlus imp) {
+		if (!paintOnOverlay)
+			return null;
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			return null;
+		Roi roi = overlay.get("[Brush]");
+		if (roi==null||!(roi instanceof ImageRoi))
+			return null;
+		Rectangle bounds = roi.getBounds();
+		if (bounds.x!=0||bounds.y!=0||bounds.width!=imp.getWidth()||bounds.height!=imp.getHeight())
+			return null;
+		return (ImageRoi)roi;
+	}
+
+	public void mouseDragged(ImagePlus imp, MouseEvent e) {
+		if (mode == IDLE) return;
+		ImageCanvas ic = imp.getCanvas();
+		int x = ic.offScreenX(e.getX());
+		int y = ic.offScreenY(e.getY());
+		if (mode == RESIZING) {
+			showToolSize(x-xStart, imp);
+			return;
+		}
+		if ((e.getModifiers() & InputEvent.SHIFT_MASK) != 0) { //shift constrains
+			if (mode == UNCONSTRAINED) {	//first movement with shift down determines direction
+				if (Math.abs(x-xStart) > Math.abs(y-yStart))
+					mode = HORIZONTAL;
+				else if (Math.abs(x-xStart) < Math.abs(y-yStart))
+					mode = VERTICAL;
+				else return; //constraint direction still unclear
+			}
+			if (mode == HORIZONTAL)
+				y = yStart;
+			else if (mode == VERTICAL)
+				x = xStart;
+		} else {
+			xStart = x;
+			yStart = y;
+			mode = UNCONSTRAINED;
+		}
+		ip.setLineWidth(width);
+		ip.lineTo(x, y);
+		if (overlayImage!=null) {
+			overlayImage.setProcessor(ip);
+			imp.draw();
+		} else
+			imp.updateAndDraw();
+	}
+
+	public void mouseReleased(ImagePlus imp, MouseEvent e) {
+		if (mode==RESIZING) {
+			if (overlay!=null && overlay.size()>0 && CIRCLE_NAME.equals(overlay.get(overlay.size()-1).getName())) {
+				overlay.remove(overlay.size()-1);
+				imp.setOverlay(overlay);
+			}
+			overlay = null;
+			if (e.isShiftDown()) {
+				setWidth(width);
+				Prefs.set(widthKey, width);
+			}
+		}
+	}
+
+	private void setWidth(int width) {
+		if (gd==null)
+			return;
+		Vector numericFields = gd.getNumericFields();
+		TextField widthField  = (TextField)numericFields.elementAt(0);
+		widthField.setText(""+width);
+		Vector sliders = gd.getSliders();
+		Scrollbar sb = (Scrollbar)sliders.elementAt(0);
+		sb.setValue(width);
+	}
+			
+	private void setColor(Color c) {
+		if (gd==null)
+			return;
+		String name = Colors.colorToString2(c);
+		if (name.length()>0) {
+			Vector choices = gd.getChoices();
+			Choice ch = (Choice)choices.elementAt(0);
+			ch.select(name);
+		}
+	}
+
+
+	private void showToolSize(int deltaWidth, ImagePlus imp) {
+		if (deltaWidth !=0) {
+			width = oldWidth + deltaWidth;
+			if (width<1) width=1;
+			Roi circle = new OvalRoi(xStart-width/2, yStart-width/2, width, width);
+			circle.setName(CIRCLE_NAME);
+			circle.setStrokeColor(Color.red);
+			overlay = imp.getOverlay();
+			if (overlay==null)
+				overlay = new Overlay();
+			else if (overlay.size()>0 && CIRCLE_NAME.equals(overlay.get(overlay.size()-1).getName()))
+				overlay.remove(overlay.size()-1);
+			overlay.add(circle);
+			imp.setOverlay(overlay);
+		}
+		IJ.showStatus((isPencil?"Pencil":"Brush")+" width: "+ width);
+	}
+	
+	public void showOptionsDialog() {
+		Thread thread = new Thread(this, "Brush Options");
+		thread.setPriority(Thread.NORM_PRIORITY);
+		thread.start();
+	}
+
+	public String getToolName() {
+		if (isPencil)
+			return "Pencil Tool";
+		else
+			return "Paintbrush Tool";
+	}
+
+	public String getToolIcon() {
+		// C123 is the foreground color
+		if (isPencil)
+			return "C037L4990L90b0Lc1c3L82a4Lb58bL7c4fDb4L494fC123L5a5dL6b6cD7b";
+		else
+			return "N02 C123H2i2g3e5c6b9b9e8g6h4i2i0 C037Lc07aLf09b P2i3e5c6b9b9e8g6h4i2i0";
+	}
+
+	public void run() {
+		new Options();
+	}
+
+	class Options implements DialogListener {
+
+		Options() {
+			if (gd != null) {
+				gd.toFront();
+				return;
+			}
+			options = this;
+			showDialog();
+		}
+		
+		public void showDialog() {
+			Color color = Toolbar.getForegroundColor();
+			String colorName = Colors.colorToString2(color);
+			String name = isPencil?"Pencil":"Brush";
+			gd = GUI.newNonBlockingDialog(name+" Options");
+			gd.addSlider(name+" width:", 1, 50, width);
+			//gd.addSlider("Transparency (%):", 0, 100, transparency);
+			gd.addChoice("Color:", Colors.getColors(colorName), colorName);
+			gd.addCheckbox("Paint on overlay", paintOnOverlay);
+			gd.addDialogListener(this);
+			gd.addHelp(getHelp());
+			Point loc = Prefs.getLocation(LOC_KEY);
+			if (loc!=null) {
+				gd.centerDialog(false);
+				gd.setLocation (loc);
+			}
+			gd.showDialog();
+			Prefs.saveLocation(LOC_KEY, gd.getLocation());
+			gd = null;
+		}
+
+		public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+			if (e!=null && e.toString().contains("Undo")) {
+				ImagePlus imp = WindowManager.getCurrentImage();
+				if (imp!=null) IJ.run("Undo");
+				return true;
+			}
+			width = (int)gd.getNextNumber();
+			if (gd.invalidNumber() || width<0)
+				width = (int)Prefs.get(widthKey, 1);
+			//transparency = (int)gd.getNextNumber();
+			//if (gd.invalidNumber() || transparency<0 || transparency>100)
+			//	transparency = 100;
+			String colorName = gd.getNextChoice();
+			paintOnOverlay = gd.getNextBoolean();
+			Color color = Colors.decode(colorName, null);
+			Toolbar.setForegroundColor(color);
+			Prefs.set(widthKey, width);
+			Prefs.set(OVERLAY_KEY, paintOnOverlay);
+			return true;
+		}
+	}
+	
+	public static void setBrushWidth(int width) {
+		if (brushInstance!=null) {
+			Color c = Toolbar.getForegroundColor();
+			brushInstance.setWidth(width);
+			Toolbar.setForegroundColor(c);
+		}
+	}
+	
+	private String getHelp() {
+		String ctrlString = IJ.isMacintosh()? "<i>cmd</i>":"<i>ctrl</i>";
+		return	
+			 "<html>"
+			+"<font size=+1>"
+			+"<b>Key modifiers</b>"
+			+"<ul>"
+			+"<li> <i>shift</i> to draw horizontal or vertical lines<br>"
+			+"<li> <i>alt</i> to draw in background color (or<br>to erase if painting on overlay<br>"
+			+"<li>"+ ctrlString+"<i>-shift-drag</i> to change "+(isPencil ? "pencil" : "brush")+" width<br>"
+			+"<li>"+ ctrlString+"<i>-click</i> to change (\"pick up\") the<br>"
+			+"drawing color, or use the Color<br>Picker (<i>shift-k</i>)<br>"
+			+"</ul>"
+			+"Use <i>Edit&gt;Selection&gt;Create Mask</i> to create<br>a mask from the painted overlay. "
+			+"Use<br><i>Image&gt;Overlay&gt;Remove Overlay</i> to remove<br>the painted overlay.<br>"
+			+" <br>"
+			+"</font>";
+	}
+
+
+}
\ No newline at end of file
diff --git a/src/ij/plugin/tool/MacroToolRunner.java b/src/ij/plugin/tool/MacroToolRunner.java
new file mode 100644
index 0000000..a2cba66
--- /dev/null
+++ b/src/ij/plugin/tool/MacroToolRunner.java
@@ -0,0 +1,38 @@
+package ij.plugin.tool;
+import ij.macro.Program;
+import ij.plugin.MacroInstaller;
+
+public class MacroToolRunner extends PlugInTool {
+	MacroInstaller installer;
+
+	public MacroToolRunner(MacroInstaller installer) {
+		this.installer = installer;
+	}
+	
+	public void runMacroTool(String name) {
+		if (installer!=null)
+			installer.runMacroTool(name);
+	}
+
+	public void runMenuTool(String name, String command) {
+		if (installer!=null)
+			installer.runMenuTool(name, command);
+	}
+
+	public Program getMacroProgram() {
+		if (installer!=null)
+			return installer.getProgram();
+		else
+			return null;
+	}
+	
+	public int getMacroCount() {
+		if (installer!=null)
+			return installer.getMacroCount();
+		else
+			return 0;
+	}
+
+}
+
+
diff --git a/src/ij/plugin/tool/OverlayBrushTool.java b/src/ij/plugin/tool/OverlayBrushTool.java
new file mode 100644
index 0000000..bec9b2b
--- /dev/null
+++ b/src/ij/plugin/tool/OverlayBrushTool.java
@@ -0,0 +1,255 @@
+package ij.plugin.tool;
+import ij.*;
+import ij.process.*;
+import ij.gui.*;
+import ij.plugin.Colors;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.BasicStroke;
+import java.awt.geom.*;
+import java.util.Vector;
+
+//Version history
+// 2012-07-14 shift to confine horizontally or vertically, ctrl-shift to resize
+// 2012-07-22 options allow width=0; width&transparency range checking, alt for BG, CTRL to pick color
+
+public class OverlayBrushTool extends PlugInTool implements Runnable {
+	private final static int UNCONSTRAINED=0, HORIZONTAL=1, VERTICAL=2, DO_RESIZE=3, RESIZED=4, IDLE=5; //mode flags
+	private static String WIDTH_KEY = "obrush.width";
+	private static final String LOC_KEY = "obrush.loc";
+	private static float width = (float)Prefs.get(WIDTH_KEY, 5);
+	private int transparency;
+	private BasicStroke stroke;
+	private GeneralPath path;
+	private int mode;  //resizing brush or motion constrained horizontally or vertically
+	private float xStart, yStart;
+	private float oldWidth = width;
+	private boolean newPath;
+	private Options options;
+	private GenericDialog gd;
+
+	public void mousePressed(ImagePlus imp, MouseEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		float x = (float)ic.offScreenXD(e.getX());
+		float y = (float)ic.offScreenYD(e.getY());
+		xStart = x;
+		yStart = y;
+		oldWidth = width;
+		int ctrlMask = IJ.isMacintosh() ? InputEvent.META_MASK : InputEvent.CTRL_MASK;
+		int resizeMask = InputEvent.SHIFT_MASK | ctrlMask;
+		if ((e.getModifiers() & resizeMask) == resizeMask) {
+			mode = DO_RESIZE;
+			return;
+		} else if ((e.getModifiers() & ctrlMask) != 0) {  //Pick the color from image or overlay
+			//Limitiation: no sub-pixel accuracy here.
+			//Don't use awt.robot to pick the color, it is influenced by screen color calibration
+			int[] rgbValues = imp.flatten().getPixel((int)x,(int)y);
+			Color color = new Color(rgbValues[0],rgbValues[1],rgbValues[2]);
+			boolean altKeyDown = (e.getModifiers() & InputEvent.ALT_MASK) != 0;
+			if (altKeyDown)
+				Toolbar.setBackgroundColor(color);
+			else {
+				Toolbar.setForegroundColor(color);
+				if (gd != null)
+					options.setColor(color);
+			}
+			mode = IDLE;
+			return;
+		}
+		mode = UNCONSTRAINED;	//prepare drawing
+		path = new GeneralPath();
+		path.moveTo(x, y);
+		newPath = true;
+		stroke = new BasicStroke(width, BasicStroke.CAP_ROUND/*CAP_BUTT*/, BasicStroke.JOIN_ROUND);
+	}
+
+	public void mouseDragged(ImagePlus imp, MouseEvent e) {
+		if (mode == IDLE) return;
+		ImageCanvas ic = imp.getCanvas();
+		float x = (float)ic.offScreenXD(e.getX());
+		float y = (float)ic.offScreenYD(e.getY());
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			overlay = new Overlay();
+		if (mode == DO_RESIZE || mode == RESIZED) {
+			changeBrushSize((float)(x-xStart), imp);
+			return;
+		}
+		if ((e.getModifiers() & InputEvent.SHIFT_MASK) != 0) { //shift constrains
+			if (mode == UNCONSTRAINED) {	//first movement with shift down determines direction
+				if (Math.abs(x-xStart) > Math.abs(y-yStart))
+					mode = HORIZONTAL;
+				else if (Math.abs(x-xStart) < Math.abs(y-yStart))
+					mode = VERTICAL;
+				else return; //constraint direction still unclear
+			}
+			if (mode == HORIZONTAL)
+				y = yStart;
+			else if (mode == VERTICAL)
+				x = xStart;
+		} else {
+			xStart = x;
+			yStart = y;
+			mode = UNCONSTRAINED;
+		}
+		path.lineTo(x, y);
+		ShapeRoi roi = new ShapeRoi(path);
+		boolean altKeyDown = (e.getModifiers() & InputEvent.ALT_MASK) != 0;
+		Color color = altKeyDown ? Toolbar.getBackgroundColor() : Toolbar.getForegroundColor();
+		float red = (float)(color.getRed()/255.0);
+		float green = (float)(color.getGreen()/255.0);
+		float blue = (float)(color.getBlue()/255.0);
+		float alpha = (float)((100-transparency)/100.0);
+		roi.setStrokeColor(new Color(red, green, blue, alpha));
+		roi.setStroke(stroke);
+		if (newPath) {
+			overlay.add(roi);
+			newPath = false;
+		} else {
+			overlay.remove(overlay.size()-1);
+			overlay.add(roi);
+		}
+		imp.setOverlay(overlay);
+	}
+
+	public void mouseReleased(ImagePlus imp, MouseEvent e) {
+		if (mode == RESIZED) {
+			Overlay overlay = imp.getOverlay();
+			overlay.remove(overlay.size()-1); //delete brush resizing circle
+			imp.setOverlay(overlay);
+			Prefs.set(WIDTH_KEY, width);
+			if (gd!=null)
+				options.setWidth(width);
+		} else if (newPath)		// allow drawing a single dot
+			mouseDragged(imp, e);
+	}
+
+	private void changeBrushSize(float deltaWidth, ImagePlus imp) {
+		if (deltaWidth!=0) {
+			Overlay overlay = imp.getOverlay();
+			width = oldWidth + deltaWidth;
+			if (width < 0) width = 0;
+			Roi circle = new OvalRoi(xStart-width/2, yStart-width/2, width, width);
+			circle.setStrokeColor(Color.red);
+			overlay = imp.getOverlay();
+			if (overlay==null)
+				overlay = new Overlay();
+			if (mode == RESIZED)
+				overlay.remove(overlay.size()-1);
+			overlay.add(circle);
+			imp.setOverlay(overlay);
+		}
+		IJ.showStatus("Overlay Brush width: "+IJ.d2s(width));
+		mode = RESIZED;
+	}
+
+	public void showOptionsDialog() {
+		Thread thread = new Thread(this, "Brush Options");
+		thread.setPriority(Thread.NORM_PRIORITY);
+		thread.start();
+	}
+
+	public String getToolName() {
+		return "Overlay Brush Tool";
+	}
+
+	public String getToolIcon() {
+		return "C037La077Ld098L6859L4a2fL2f4fL3f99L5e9bL9b98L6888L5e8dL888cC123P2f7f9ebdcaf70";
+	}
+
+	public void run() {
+		new Options();
+	}
+	
+	public static void setWidth(double brushWidth) {
+		width = (float)brushWidth;
+	}
+	
+		
+	class Options implements DialogListener {
+
+		Options() {
+			if (gd != null) {
+				gd.toFront();
+				return;
+			}
+			options = this;
+			if (IJ.debugMode) IJ.log("Options: true");
+			showDialog();
+		}
+
+		//set 'width' textfield and adjust scrollbar
+		void setWidth(float width) {
+			Vector numericFields = gd.getNumericFields();
+			TextField widthField  = (TextField)numericFields.elementAt(0);
+			widthField.setText(IJ.d2s(width,1));
+			Vector sliders = gd.getSliders();
+			Scrollbar sb = (Scrollbar)sliders.elementAt(0);
+			sb.setValue((int)(width+0.5f));
+		}
+
+		void setColor(Color c) {
+			String name = Colors.getColorName(c, "");
+			if (name.length() > 0) {
+				Vector choices = gd.getChoices();
+				Choice ch = (Choice)choices.elementAt(0);
+				ch.select(name);
+			}
+		}
+
+		public void showDialog() {
+			Color color = Toolbar.getForegroundColor();
+			String colorName = Colors.colorToString2(color);
+			gd = GUI.newNonBlockingDialog("Overlay Brush Options");
+			gd.addSlider("Brush width:", 0, 50, width);
+			gd.addSlider("Transparency:", 0, 100, transparency);
+			gd.addChoice("Color:", Colors.getColors(colorName), colorName);
+			gd.setInsets(10, 0, 0);
+			String ctrlString = IJ.isMacintosh()? "CMD":"CTRL";
+			gd.addMessage("SHIFT for horizontal or vertical lines\n"+
+					"ALT to draw in background color\n"+
+					ctrlString+"-SHIFT-drag to change brush width\n"+
+					ctrlString+"-click to change foreground color\n",
+					null, Color.darkGray);
+			gd.hideCancelButton();
+			gd.addHelp("");
+			gd.setHelpLabel("Undo");
+			gd.setOKLabel("Close");
+			gd.addDialogListener(this);
+			Point loc = Prefs.getLocation(LOC_KEY);
+			if (loc!=null) {
+				gd.centerDialog(false);
+				gd.setLocation (loc);
+			}
+			gd.showDialog();
+			Prefs.saveLocation(LOC_KEY, gd.getLocation());
+			if (IJ.debugMode) IJ.log("Options: false");
+			gd = null;
+		}
+
+		public boolean dialogItemChanged(GenericDialog gd, AWTEvent e) {
+			if (e!=null && e.toString().contains("Undo")) {
+				ImagePlus imp = WindowManager.getCurrentImage();
+				if (imp==null) return true;
+				Overlay overlay = imp.getOverlay();
+				if (overlay!=null && overlay.size()>0) {
+					overlay.remove(overlay.size()-1);
+					imp.draw();
+				}
+				return true;
+			}
+			width = (float)gd.getNextNumber();
+			if (gd.invalidNumber() || width<0)
+				width = (float)Prefs.get(WIDTH_KEY, 5);
+			transparency = (int)gd.getNextNumber();
+			if (gd.invalidNumber() || transparency<0 || transparency>100)
+				transparency = 100;
+			String colorName = gd.getNextChoice();
+			Color color = Colors.decode(colorName, null);
+			Toolbar.setForegroundColor(color);
+			Prefs.set(WIDTH_KEY, width);
+			return true;
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/ij/plugin/tool/PixelInspectionTool.java b/src/ij/plugin/tool/PixelInspectionTool.java
new file mode 100644
index 0000000..d175df8
--- /dev/null
+++ b/src/ij/plugin/tool/PixelInspectionTool.java
@@ -0,0 +1,549 @@
+package ij.plugin.tool;
+import ij.*;
+import ij.plugin.frame.PlugInFrame;
+import ij.process.*;
+import ij.measure.*;
+import ij.plugin.filter.Analyzer;
+import ij.gui.*;
+import ij.util.Tools;
+import java.awt.*;
+import java.awt.event.*;
+import java.awt.datatransfer.*;
+import java.awt.geom.*;
+
+/**
+ * This plugin continuously displays the pixel values of the cursor and
+ * its surroundings. It is usefule for examining how a filter changes the 
+ * data (also during preview).
+ *
+ * If the Pixel Inspector Window is in the foreground, "c" with any modifier
+ * keys (CTRL-C etc) copies the current data into the clipboard (tab-delimited).
+ * The arrow keys nudge the position.
+ *
+ * Preferences (Press the Prefs button at top left):
+ *
+ * Radius determines the size of the window, 3x3 for radius=1, etc.
+ * The Pixel Inspector window must be closed and opened to get the new
+ * size.
+ * Readout for grayscale 8&16 bit images can be raw, calibrated or
+ * hexadecimal.
+ * Readout for RGB images can ge R,G,B triples, gray value or hexadecimal.
+ * For copying the data to clipboard, it can be selected whether the position
+ * (x,y) is not not written, written in the first line or in the same way
+ * as the header lines of the Pixel Inspector panel.
+ *
+ * Limitations and known problems:
+ *
+ * x and y coordinates are always uncalibrated pixel numbers.
+ *
+ * Some image operations do not update the display.
+ *
+ * Michael Schmid
+ * Version 2007-Dec-06 - bugs fixed:
+ *		did not always follow cursor
+ *		nudge could make the display hang
+ *		pixel value calibration was sometimes ignored
+ * Version 2007-Dec-14 - supports exponential format for large/small data values
+ */
+public class  PixelInspectionTool extends PlugInTool {
+	PixelInspector pi;
+
+	public void mousePressed(ImagePlus imp, MouseEvent e) {
+		drawOutline(imp, e);
+	}
+
+	public void mouseDragged(ImagePlus imp, MouseEvent e) {
+		drawOutline(imp, e);
+	}
+
+	public void showOptionsDialog() {
+		if (pi!=null) pi.showDialog();		
+	}
+
+	void drawOutline(ImagePlus imp, MouseEvent e) {
+		ImageCanvas ic = imp.getCanvas();
+		int x = ic.offScreenX(e.getX());
+		int y = ic.offScreenY(e.getY());
+		int radius = PixelInspector.radius;
+		int size = radius*2+1;
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			overlay = new Overlay();
+		Roi roi = null;
+		int index = PixelInspector.getIndex(overlay, PixelInspector.TITLE);
+		if (index>=0) {
+			roi = overlay.get(index);
+			Rectangle r = roi.getBounds();
+			if (r.width!=size || r.height!=size) {
+				overlay.remove(index);
+				roi = null;
+			}
+			if (roi!=null)
+				roi.setLocation(x-radius, y-radius);
+		}
+		if (roi==null) {
+			roi = new Roi(x-radius, y-radius, size, size);
+			roi.setName(PixelInspector.TITLE);
+			roi.setStrokeColor(Color.red);
+			overlay.add(roi);
+		}
+		imp.setOverlay(overlay);
+		if (pi==null) {
+			if (PixelInspector.instance!=null)
+				PixelInspector.instance.close();
+			pi = new PixelInspector(imp, this);
+		}
+		pi.update(imp, PixelInspector.POSITION_UPDATE, x, y);
+	}
+
+	public String getToolName() {
+		return "Pixel Inspection Tool";
+	}
+
+	public String getToolIcon() {
+		return "Cb00T3b09PT8b09xC037L2e0cL0c02L0220L20d0Pd0f2fcde2e0BccP125665210";
+	}
+
+}
+
+
+class PixelInspector extends PlugInFrame
+		implements ImageListener, KeyListener, MouseListener, Runnable {
+	//ImageListener: listens to changes of image data
+	//KeyListener: for fix/unfix key
+	//MouseListener: for "Prefs" label
+	//Runnable: for background thread
+
+	/* Preferences and related */
+	static final String PREFS_KEY="pixelinspector."; //key in IJ_Prefs.txt
+	static int radius = (int)Prefs.get(PREFS_KEY+"radius", 3);
+	private static final String LOC_KEY = "inspector.loc";
+	final static int MAX_RADIUS = 10;//the largest radius possible (ImageJ can hang if too large)
+	int grayDisplayType = 0;		//how to display 8-bit&16-bit grayscale pixels
+	final static String[] GRAY_DISPLAY_TYPES = {"Raw","Calibrated","Hex"};
+	final static int GRAY_RAW = 0, GRAY_CAL = 1, GRAY_HEX = 2;
+	int rgbDisplayType = 0;			//how to display rgb pixels
+	final static String[] RGB_DISPLAY_TYPES = {"R,G,B","Gray Value","Hex"};
+	final static int RGB_RGB = 0, RGB_GRAY = 1, RGB_HEX = 2;
+	int copyType = 0;				//what to copy to the clipboard
+	final static String[] COPY_TYPES = {"Data Only","x y and Data","Header and Data"};
+	final static int COPY_DATA = 0, COPY_XY = 1, COPY_HEADER = 2;
+	int colorNumber = 0;			//color of the position marker in fixed mode
+	final static String[] COLOR_STRINGS = {"red","orange","yellow","green","cyan","blue","magenta",};
+	final static Color[] COLORS = {Color.RED, Color.ORANGE, Color.YELLOW, Color.GREEN, Color.CYAN, Color.BLUE, Color.MAGENTA};
+	int fixKey = '!';				//the key (keycode+0x10000 or char) for fixing/unfixing the position
+	final static int KEYCODE_OFFSET = 0x10000;	//we add this to keycodes to separate them from key characters
+	/* current status */
+	private int x0,y0;				//the current position
+	int nextUpdate;					//type of next update
+	final static int POSITION_UPDATE = 1, FULL_UPDATE = 2;
+	static final String TITLE = "Pixel Inspector";
+	static PixelInspector instance;
+	PixelInspectionTool tool;
+
+	ImageJ ij;
+	ImagePlus imp;					//the ImagePlus that we listen to
+	int id;					        //the image ID
+	int bitDepth;                 //the image bit depth
+	int digits;						//decimal fraction digits to display
+	boolean expMode;				//whether to display the data in exp format
+	ImageCanvas canvas;				//the canvas of imp
+	Thread bgThread;				//thread for output (in the background)
+	Label[] labels;					//the display fields
+	//Label prefsLabel = new Label("Prefs\u2026");
+	Label prefsLabel = new Label("Prefs");
+	
+
+	/* Initialization, preparing the window (panel) **/
+	public PixelInspector(ImagePlus imp, PixelInspectionTool tool) {
+		super("Pixel Values");
+		instance = this;
+		this.imp = imp;
+		this.tool = tool;
+		ij = IJ.getInstance();
+		if (ij == null) return;		//it won't work with the ImageJ applet
+		if (imp==null) {
+			IJ.noImage(); return;
+		}
+		id = imp.getID();
+		bitDepth = imp.getBitDepth();
+		//setTitle("Pixels of "+imp.getTitle());
+		WindowManager.addWindow(this);
+		//readPreferences();
+		prefsLabel.addMouseListener(this);
+		addKeyListener(this);
+		init();
+		Point loc = Prefs.getLocation(PREFS_KEY+"loc");
+		if (loc!=null)
+			setLocation(loc);
+		else
+			GUI.centerOnImageJScreen(this);
+		setResizable(false);
+		show();
+		toFront();
+		addImageListeners();
+											//thread for output in the background
+		bgThread = new Thread(this, "Pixel Inspector");
+		bgThread.start();
+		bgThread.setPriority(Math.max(bgThread.getPriority()-3, Thread.MIN_PRIORITY));
+		update(FULL_UPDATE);				//the first data display
+	}
+
+	private void init() {
+		removeAll();
+		int size = 2*radius+2;			   //number of columns and rows
+		labels = new Label[size*size];
+		for (int i=1; i<labels.length; i++) //make the labels (display fields)
+			labels[i] = new Label();
+		initializeLabels();					//fill the labels with spaceholders
+		setLayout(new GridLayout(size, size, 0, 0));
+		for (int row=0,p=0; row<size; row++) {
+			for (int col=0; col<size; col++,p++) {
+				if (row == 0 && col == 0)
+					add(prefsLabel);
+				else
+					add(labels[p]);
+			}
+		}
+		GUI.scale(this);
+		pack();
+	}
+
+	public void close() {
+		super.close();			   //also does WindowManager.removeWindow(this);
+		Prefs.saveLocation(PREFS_KEY+"loc", getLocation());
+		removeImageListeners();
+		 synchronized(this) {				 //terminate the background thread
+			bgThread.interrupt();
+		}
+		instance = null;
+		tool.pi = null;
+		removeOutline();
+	}
+
+	private void removeOutline() {
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null) return;
+		int index = getIndex(overlay, TITLE);
+		if (index>=0) {
+			overlay.remove(index);
+			imp.setOverlay(overlay);
+		}
+	}
+
+	private void addImageListeners() {
+		imp.addImageListener(this);
+		ImageWindow win = imp.getWindow();
+		if (win == null) close();
+		canvas = win.getCanvas();
+		canvas.addKeyListener(this);
+	}
+
+	private void removeImageListeners() {
+		imp.removeImageListener(this);
+		canvas.removeKeyListener(this);
+	}
+
+	//ImageListener
+	public void imageUpdated(ImagePlus imp) { update(FULL_UPDATE); }
+	public void imageOpened(ImagePlus imp) {}
+	public void imageClosed(ImagePlus imp) {}
+
+	//KeyListener
+	public void keyPressed(KeyEvent e) {
+		boolean thisPanel = e.getSource() instanceof PixelInspector;
+		if (thisPanel && e.getKeyCode()==KeyEvent.VK_C) { 
+			copyToClipboard();
+			return;
+		}
+		if (e.getKeyCode()==KeyEvent.VK_UP && y0 > 0) {
+			y0--; update(FULL_UPDATE);
+		} else if (e.getKeyCode()==KeyEvent.VK_DOWN && y0<imp.getHeight()-1) {
+			y0++; update(FULL_UPDATE);
+		} else if (e.getKeyCode()==KeyEvent.VK_LEFT && x0>0) {
+			x0--; update(FULL_UPDATE);
+		} else if (e.getKeyCode()==KeyEvent.VK_RIGHT && x0<imp.getWidth()-1) {
+			x0++; update(FULL_UPDATE);
+		} else if (e.getSource() instanceof Button)
+			ij.keyPressed(e);  //forward other keys from the panel to ImageJ
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null) return;
+		int index = getIndex(overlay, TITLE);
+		if (index>=0) {
+			overlay.remove(index);
+			Roi roi = new Roi(x0-radius, y0-radius, radius*2+1, radius*2+1);
+			roi.setName(TITLE);
+			roi.setStrokeColor(Color.red);
+			overlay.add(roi);
+			imp.setOverlay(overlay);	
+	   }
+	}
+
+	public void mousePressed(MouseEvent e) {
+		showDialog();
+	}   
+	public void mouseEntered(MouseEvent e) {}   
+	public void mouseExited(MouseEvent e) {}   
+	public void mouseClicked(MouseEvent e) {}   
+	public void mouseReleased(MouseEvent e) {}   
+
+	/** In the Overlay class in imageJ 1.46g and later. */
+	static int getIndex(Overlay overlay, String name) {
+		if (name==null) return -1;
+		Roi[] rois = overlay.toArray();
+		for (int i=rois.length-1; i>=0; i--) {
+			if (name.equals(rois[i].getName()))
+				return i;
+		}
+		return -1;
+	}
+
+	public void keyReleased(KeyEvent e) {}
+	public void keyTyped(KeyEvent e) {}
+
+	void update(ImagePlus imp, int whichUpdate, int x, int y) {
+		if (imp!=this.imp) {
+			removeImageListeners();
+			removeOutline();
+			this.imp = imp;
+			addImageListeners();
+			//setTitle("Pixels of "+imp.getTitle());
+		}
+		this.x0 = x;
+		this.y0 = y;
+		update(whichUpdate);
+	}
+
+	synchronized void update(int whichUpdate) {
+		if (nextUpdate < whichUpdate)
+			nextUpdate = whichUpdate;
+		notify();		//wake up the background thread
+	}
+
+	// the background thread for updating the table
+	public void run() {
+		boolean doFullUpdate = false;
+		while (true) {
+			if (doFullUpdate) {
+				setCalibration();
+			}
+			writeNumbers();
+			IJ.wait(50);
+
+			synchronized(this) {
+				if (nextUpdate == 0) {
+					try {wait();}				//notify wakes up the thread
+					catch(InterruptedException e) { //interrupted tells the thread to exit
+						return;
+					}
+				} else {
+					doFullUpdate = nextUpdate == FULL_UPDATE;
+					nextUpdate = 0;
+				}
+			}
+		} //while (true)
+	}
+
+	/** get the surrounding pixels and display them */
+	void writeNumbers() {
+		if (imp.getID()!=id || imp.getBitDepth()!=bitDepth) {	//has the image changed?
+			removeImageListeners();
+			addImageListeners();
+			initializeLabels();
+			this.pack();
+			id = imp.getID();
+			bitDepth = imp.getBitDepth();
+			nextUpdate = FULL_UPDATE;
+			return;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		if (ip == null) return;
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		int x0 = this.x0;		//class variables may change asynchronously, fixed values needed here
+		int y0 = this.y0;
+		int p = 1;	  //pointer in labels array
+		for (int x = x0-radius; x <= x0+radius; x++,p++)
+			labels[p].setText(x>=0&&x<width ? Integer.toString(x) : " ");
+		for (int y = y0-radius; y <= y0+radius; y++) {
+			boolean yInside = y>=0&&y<height;
+			int yDisplay =	(Analyzer.getMeasurements() & Measurements.INVERT_Y)!=0 ? height-y-1 : y;
+			labels[p].setText(yInside ? Integer.toString(yDisplay) : " ");
+			p++;
+			for (int x = x0-radius; x <= x0+radius; x++,p++) {
+				if (x>=0&&x<width&&yInside) {
+					if (ip instanceof ColorProcessor && rgbDisplayType == RGB_RGB) {
+						int c = ip.getPixel(x,y);
+						int r = (c&0xff0000)>>16;
+						int g = (c&0xff00)>>8;
+						int b = c&0xff;
+						labels[p].setText(r+","+g+","+b);
+					} else if (ip instanceof ColorProcessor && rgbDisplayType == RGB_HEX)
+						labels[p].setText(int2hex(ip.getPixel(x,y),6));
+					else if ((ip instanceof ByteProcessor || ip instanceof ShortProcessor) && grayDisplayType == GRAY_RAW)
+						labels[p].setText(Integer.toString(ip.getPixel(x,y)));
+					else if ((ip instanceof ByteProcessor || ip instanceof ShortProcessor) && grayDisplayType == GRAY_HEX)
+						labels[p].setText(int2hex(ip.getPixel(x,y), ip instanceof ByteProcessor ? 2 : 4));
+					else
+						labels[p].setText(stringOf(ip.getPixelValue(x,y), digits, expMode));
+				} else
+					labels[p].setText(" ");
+			}
+		} //for y
+	}
+
+	/** initialize content of the labels to make sure we have enough space */
+	void initializeLabels() {
+		Color bgColor = new Color(0xcccccc);	//background for row/column header
+		String placeHolder = "000000.00";		//how much space to reserve (enough for float, calibrated, rgb)
+		ImageProcessor ip = imp.getProcessor();
+		if (ip instanceof ByteProcessor && grayDisplayType==GRAY_RAW) {
+			placeHolder = "000";
+		} else if (ip instanceof ByteProcessor || ip instanceof ShortProcessor) {
+			if (grayDisplayType == GRAY_RAW || grayDisplayType == GRAY_HEX)
+				placeHolder = "00000";			//minimum space, needed for header (max 99k pixels)
+		} else if (ip instanceof ColorProcessor) {
+			if (rgbDisplayType == RGB_RGB)
+				placeHolder = "000,000,000";
+			if (rgbDisplayType == RGB_GRAY)
+				placeHolder = "000.00";
+			else if (rgbDisplayType == RGB_HEX)
+				placeHolder = "CCCCCC";
+		}
+		if (placeHolder.length()<5 && (ip.getWidth()>9999 || ip.getHeight()>9999))
+			placeHolder = "00000";
+		if (placeHolder.length()<4 && (ip.getWidth()>999 || ip.getHeight()>999))
+			placeHolder = "0000";
+		int p = 0;								//pointer in labels array
+		int size = 2*radius+1;
+		for (int y = 0; y<size+1; y++) {		//header line and data lines
+			if (y > 0)							//no label in top-left corner
+				labels[p].setText(placeHolder);
+			p++;
+			for (int x = 0; x<size; x++,p++)
+				labels[p].setText(placeHolder);
+		}
+		labels[radius+1].setForeground(Color.RED); //write current position in red
+		labels[(2*radius+2)*(radius+1)].setForeground(Color.RED);
+		labels[(2*radius+2)*(radius+1)+radius+1].setForeground(Color.RED);
+		for (int i=0; i<size; i++) {			//header lines have a darker background
+			labels[i+1].setBackground(bgColor);
+			labels[(2*radius+2)*(i+1)].setBackground(bgColor);		
+		}
+		for (int i=1; i<labels.length; i++)
+			labels[i].setAlignment(Label.RIGHT);
+	}
+
+	/* set the pixel value calibration of the ImageProcessor and the output format */
+	void setCalibration() {
+		Calibration cal = imp.getCalibration();
+		float[] cTable = cal.getFunction()==Calibration.NONE ? null : cal.getCTable();
+		ImageProcessor ip = imp.getProcessor();
+		if (ip != null) ip.setCalibrationTable(cTable);
+		if (ip instanceof FloatProcessor || cTable != null) {
+			float[] data = (ip instanceof FloatProcessor) ? (float[])ip.getPixels() : cTable;
+			double[] minmax = Tools.getMinMax(data);
+			double maxDataValue = Math.max(Math.abs(minmax[0]), Math.abs(minmax[1]));
+			digits = (int)(6-Math.log(maxDataValue)/Math.log(10));
+			if (maxDataValue==0.0)
+				digits = 6;
+			expMode = digits<-1 || digits>7;
+			if (Math.min(minmax[0], minmax[1]) < 0)
+				digits--; //more space needed for minus sign
+		} else {
+			digits = 2;
+			expMode = false;
+		}
+	}
+
+	/** Converts a number to a string in decimal or exp format.
+	 *	The number of digits is chosen to make the value fit into
+	 *	a cell the size of "000000.00"
+	 */
+	String stringOf(float v, int digits, boolean expMode) {
+		if (expMode) {
+			int exp = (int)Math.floor(Math.log(Math.abs(v))/Math.log(10));
+			double mant = v/Math.pow(10,exp);
+			digits = (exp > 0 && exp < 10) ? 5 : 4;
+			if (v<0) digits--;		//space needed for minus
+			return IJ.d2s(mant,digits)+"e"+exp;
+		} else
+			return IJ.d2s(v, digits);
+	}
+
+	void copyToClipboard() {
+		final char delim = '\t';
+		int size = 2*radius+1;
+		int p = 1;
+		StringBuffer sb = new StringBuffer();
+		if (copyType == COPY_XY) {
+			sb.append(labels[radius+1].getText()); sb.append(delim);
+			sb.append(labels[(2*radius+2)*(radius+1)].getText()); sb.append('\n');
+		} else if (copyType == COPY_HEADER) {
+			for (int x=0; x<size; x++,p++) {
+				sb.append(delim);
+				sb.append(labels[p].getText());
+			}
+			sb.append('\n');
+		}
+		p = size + 1;
+		for (int y=0; y<size; y++) {
+			if (copyType == COPY_HEADER) {
+				sb.append(labels[p].getText()); sb.append(delim);
+			}
+			p++;
+			for (int x=0; x<size; x++,p++) {
+				if (x > 0)
+					sb.append(delim);
+				sb.append(labels[p].getText());
+			}
+			sb.append('\n');
+		}
+		String s = new String(sb);
+		Clipboard clip = getToolkit().getSystemClipboard();
+		if (clip==null) return;
+		StringSelection contents = new StringSelection(s);
+		clip.setContents(contents, contents);
+		IJ.showStatus(size*size+" pixel values copied to clipboard");
+	}
+
+	/** Preferences dialog */
+	void showDialog() {
+		GenericDialog gd = new GenericDialog("Pixel Inspector Prefs...");
+		gd.addNumericField("Radius:", radius, 0, 6, "(1-"+MAX_RADIUS+")");
+		gd.addChoice("Grayscale readout:",GRAY_DISPLAY_TYPES,GRAY_DISPLAY_TYPES[grayDisplayType]);
+		gd.addChoice("RGB readout:",RGB_DISPLAY_TYPES,RGB_DISPLAY_TYPES[rgbDisplayType]);
+		gd.addChoice("Copy to clipboard:", COPY_TYPES, COPY_TYPES[copyType]);
+		gd.addMessage("Use arrow keys to move red outline.\nPress 'c' to copy data to clipboard.", null, Color.darkGray);
+		Point loc = Prefs.getLocation(LOC_KEY);
+		if (loc!=null) {
+			gd.centerDialog(false);
+			gd.setLocation (loc);
+		}
+		gd.showDialog();
+		if (gd.wasCanceled())
+			return;
+		radius = (int)gd.getNextNumber();
+		if (radius<1) radius=1;
+		if (radius>MAX_RADIUS) radius=MAX_RADIUS;
+		grayDisplayType = gd.getNextChoiceIndex();
+		rgbDisplayType = gd.getNextChoiceIndex();
+		copyType = gd.getNextChoiceIndex();
+		boolean keyOK = false;
+		init();
+		update(POSITION_UPDATE);
+		Prefs.set(PREFS_KEY+"radius", radius);
+		Prefs.saveLocation(LOC_KEY, gd.getLocation());
+	}
+
+	static String int2hex(int i, int digits) {
+		boolean addHexSign = digits<6;
+		char[] buf = new char[addHexSign ? digits+1 : digits];
+		for (int pos=buf.length-1; pos>=buf.length-digits; pos--) {
+			buf[pos] = Tools.hexDigits[i&0xf];
+			i >>>= 4;
+			if (addHexSign) buf[0] = 'x';
+		}
+		return new String(buf);
+	}
+}
diff --git a/src/ij/plugin/tool/PlugInTool.java b/src/ij/plugin/tool/PlugInTool.java
new file mode 100644
index 0000000..0c282a0
--- /dev/null
+++ b/src/ij/plugin/tool/PlugInTool.java
@@ -0,0 +1,56 @@
+package ij.plugin.tool;
+import ij.ImagePlus;
+import ij.plugin.PlugIn;
+import ij.macro.Program;
+import ij.gui.Toolbar;
+import java.awt.event.*;
+
+public abstract class PlugInTool implements PlugIn {
+
+	public void run(String arg) {
+		Toolbar.addPlugInTool(this);
+	}
+	
+	public void mousePressed(ImagePlus imp, MouseEvent e) {e.consume();}
+
+	public void mouseReleased(ImagePlus imp, MouseEvent e) {e.consume();}
+
+	public void mouseClicked(ImagePlus imp, MouseEvent e) {e.consume();}
+
+	public void mouseDragged(ImagePlus imp, MouseEvent e) {e.consume();}
+	
+	public void mouseMoved(ImagePlus imp, MouseEvent e) { }
+	
+	public void mouseEntered(ImagePlus imp, MouseEvent e) {e.consume();}
+
+	public void mouseExited(ImagePlus imp, MouseEvent e) {e.consume();}
+	
+	public void showPopupMenu(MouseEvent e, Toolbar tb) { }
+
+	/** Return the tool name. */
+	public String getToolName() {
+		return getClass().getName().replace('_', ' ');
+	}
+	
+	/** Return the string encoding of the tool icon. See
+		http://rsb.info.nih.gov/ij/developer/macro/macros.html#icons
+		The default icon is the first letter of the tool name.
+	*/
+	public String getToolIcon() {
+		String letter = getToolName();
+		if (letter!=null && letter.length()>0)
+			letter = letter.substring(0,1);
+		else
+			letter = "P";
+		return "C037T5f16"+letter;
+	}
+	
+	public void showOptionsDialog() {
+	}
+
+	/** These methods are overridden by MacroToolRunner. */
+	public void runMacroTool(String name) { }
+	public void runMenuTool(String name, String command) { }
+	public Program getMacroProgram() {return null;}
+
+}
diff --git a/src/ij/plugin/tool/RoiRotationTool.java b/src/ij/plugin/tool/RoiRotationTool.java
new file mode 100644
index 0000000..7f00873
--- /dev/null
+++ b/src/ij/plugin/tool/RoiRotationTool.java
@@ -0,0 +1,146 @@
+/* 
+ * This plugin implements the "Selection Rotator" tool, which 
+ * can be used to interactively rotate selections.
+ *
+ * @author: 	Peter Haub, Oct. 2015, phaub@dipsystems.de
+ */
+
+package ij.plugin.tool;
+import ij.*;
+import ij.gui.*;
+import ij.plugin.RoiRotator;
+import ij.plugin.tool.PlugInTool;
+import ij.plugin.frame.Recorder;
+import java.awt.*;
+import java.awt.event.*;
+
+public class RoiRotationTool extends PlugInTool {
+	ImageCanvas ic = null;
+	int startX=0, startY=0;
+	Roi roi, newRoi;
+	int centerX, centerY, xNew, yNew, dx1, dy1, dx2, dy2;
+	double l, l1, l2, dx, dy, phi, phi1, phi2;
+	boolean isImageRoi;
+	Rectangle bounds;
+	ImagePlus imp2;
+	
+	static final int UPDOWNROTATION=0, CIRCULARROTATION=1;
+	int defaultRotationMode = CIRCULARROTATION;
+	
+	public void mousePressed(ImagePlus imp, MouseEvent e) {
+		if (imp == null) return;
+		imp2 = imp;
+		ic = imp.getCanvas();
+		if (ic == null) return;
+		roi = imp.getRoi();
+		if (roi==null) {
+			IJ.beep();
+			IJ.showStatus("No selection");
+			return;
+		}
+		
+		startX = ic.offScreenX(e.getX());
+		startY = ic.offScreenY(e.getY());
+		
+		if (defaultRotationMode == UPDOWNROTATION){
+			centerX = imp.getWidth()/2;
+			centerY = imp.getHeight()/2;
+		} else {
+			double[] centroid = roi.getContourCentroid();
+			centerX = (int)Math.round(centroid[0]);
+			centerY = (int)Math.round(centroid[1]);
+		}
+	}
+	
+	public void mouseDragged(ImagePlus imp, MouseEvent e) {
+		if (imp == null || ic == null) return;
+		roi = imp.getRoi();
+		if (roi == null) return;
+		isImageRoi = roi instanceof ImageRoi;
+		if (isImageRoi)
+			((ImageRoi)roi).setZeroTransparent(true);
+		
+		if ( e.isAltDown() || e.isShiftDown() )
+			moveRoi(e.getX(), e.getY());
+		else
+			rotateRoi(e.getX(), e.getY());
+	}
+		
+	public void mouseReleased(ImagePlus imp, MouseEvent e) {
+		if (Recorder.record) {
+			Roi roi = imp.getRoi();
+			int n = roi.getPolygon().npoints;
+			if (n<=20 && roi.getType()!=Roi.LINE)
+				Recorder.recordRoi(roi);
+			else if (n>20)
+				Recorder.recordString("// Selection has "+n+" points, too many to record.\n");
+		}
+	}
+
+	public void showOptionsDialog() {
+		IJ.log("PlugInTool MouseRoiRotator Peter Haub dipsystems.de 10'2015");
+	}
+
+	public String getToolName() {
+		return "Selection Rotator (press alt or shift to move)";
+	}
+	
+	public String getToolIcon() {
+		return "C037D06D15D16D24D25D26D27D28D29D2aD33D34D35D36D37D3bD3cD42D43D44D45D46D47D48D4cD4dDb1Db2Db6Db7Db8Db9DbaDbbDbcDc2Dc3Dc7Dc8Dc9DcaDcbDd4Dd5Dd6Dd7Dd8Dd9DdaDe8De9Df8CabcD05D14D17D18D19D1aD23D2bD2cD32D3dD41D51D52D53D54D55D56D57D58Da6Da7Da8Da9DaaDabDacDadDbdDc1DccDd2Dd3DdbDe4De5De6De7DeaDf9";
+	}
+
+	void rotateRoi(int sx, int sy){		
+		xNew = ic.offScreenX(sx);
+		yNew = ic.offScreenY(sy);
+		
+		dx1 = centerX - xNew;
+		dy1 = centerY - yNew;
+		dx2 = centerX - startX;	
+		dy2 = centerY - startY;
+		
+		if (defaultRotationMode == UPDOWNROTATION){
+			l1 = Math.sqrt(dx1*dx1 + dy1*dy1);
+			l2 = Math.sqrt(dx2*dx2 + dy2*dy2);
+			l = (l1 + l2)/2.0;
+			dy = yNew - startY;
+					
+			if (l==0 || dy==0)  return;
+			phi = Math.atan2(dy, l);
+		}
+		else{
+			phi1 = Math.atan2(dy1, dx1);	
+			phi2 = Math.atan2(dy2, dx2);
+			phi = phi1 - phi2;
+			if (phi == 0 || phi == Double.NaN) return;
+		}
+		
+		startX = xNew;	
+		startY = yNew;
+		
+		newRoi = RoiRotator.rotate(roi, phi*180/Math.PI);
+		if (isImageRoi)
+			imp2.draw();
+		else
+			imp2.setRoi(newRoi);
+	}
+
+	void moveRoi(int sx, int sy){
+		xNew = ic.offScreenX(sx);
+		yNew = ic.offScreenY(sy);
+		
+		dx1 = xNew - startX;
+		dy1 = yNew - startY;
+		
+		if (dx1==0 && dy2==0)  return;
+		startX = xNew;	
+		startY = yNew;
+		
+		dx = roi.getXBase() + dx1;
+		dy = roi.getYBase() + dy1;
+		roi.setLocation(dx, dy);
+		
+		imp2.draw();
+	}
+	
+}
+
diff --git a/src/ij/process/AutoThresholder.java b/src/ij/process/AutoThresholder.java
new file mode 100644
index 0000000..55fe946
--- /dev/null
+++ b/src/ij/process/AutoThresholder.java
@@ -0,0 +1,1246 @@
+package ij.process;
+import ij.IJ;
+import java.util.Arrays;
+
+/** Autothresholding methods (limited to 256 bin histograms) from the Auto_Threshold plugin 
+    (http://fiji.sc/Auto_Threshold) by G.Landini at bham dot ac dot uk). */
+public class AutoThresholder {
+	private static String[] mStrings;
+			
+	public enum Method {
+		Default, 
+		Huang,
+		Intermodes,
+		IsoData, 
+		IJ_IsoData,
+		Li, 
+		MaxEntropy, 
+		Mean, 
+		MinError, 
+		Minimum,
+		Moments, 
+		Otsu, 
+		Percentile, 
+		RenyiEntropy, 
+		Shanbhag, 
+		Triangle, 
+		Yen
+	};
+
+	public static String[] getMethods() {
+		if (mStrings==null) {
+			Method[] mVals = Method.values();
+			mStrings = new String[mVals.length];
+			for (int i=0; i<mVals.length; i++)
+				mStrings[i] = mVals[i].name();
+		}
+		return mStrings;
+	}
+	
+	/** Calculates and returns a threshold using the specified
+		method and 256 bin histogram. */
+	public int getThreshold(Method method, int[] histogram) {
+		if (histogram==null)
+			throw new IllegalArgumentException("Histogram is null");
+		if (histogram.length!=256)
+			throw new IllegalArgumentException("Histogram length not 256");
+		int threshold = 0;
+		switch (method) {
+			case Default: threshold =  defaultIsoData(histogram); break;
+			case IJ_IsoData: threshold =  IJIsoData(histogram); break;
+			case Huang: threshold = Huang(histogram); break;
+			case Intermodes: threshold = Intermodes(histogram); break;
+			case IsoData: threshold = IsoData(histogram); break;
+			case Li: threshold = Li(histogram); break;
+			case MaxEntropy: threshold = MaxEntropy(histogram); break;
+			case Mean: threshold = Mean(histogram); break;
+			case MinError: threshold = MinErrorI(histogram); break;
+			case Minimum: threshold = Minimum(histogram); break;
+			case Moments: threshold = Moments(histogram); break;
+			case Otsu: threshold = Otsu(histogram); break;
+			case Percentile: threshold = Percentile(histogram); break;
+			case RenyiEntropy: threshold = RenyiEntropy(histogram); break;
+			case Shanbhag: threshold = Shanbhag(histogram); break;
+			case Triangle: threshold = Triangle(histogram); break;
+			case Yen: threshold = Yen(histogram); break;
+		}
+		if (threshold==-1) threshold = 0;
+		return threshold;
+	}
+
+	public int getThreshold(String mString, int[] histogram) {
+		// throws an exception if unknown argument
+		int index = mString.indexOf(" ");
+		if (index!=-1)
+			mString = mString.substring(0, index);
+		Method method = Method.valueOf(Method.class, mString); 
+		return getThreshold(method, histogram);
+	}
+	
+	int Huang(int [] data ) {
+		// Implements Huang's fuzzy thresholding method 
+		// Uses Shannon's entropy function (one can also use Yager's entropy function) 
+		// Huang L.-K. and Wang M.-J.J. (1995) "Image Thresholding by Minimizing  
+		// the Measures of Fuzziness" Pattern Recognition, 28(1): 41-51
+		// M. Emre Celebi  06.15.2007
+		// Ported to ImageJ plugin by G. Landini from E Celebi's fourier_0.8 routines
+		int threshold=-1;
+		int ih, it;
+		int first_bin;
+		int last_bin;
+		double sum_pix;
+		double num_pix;
+		double term;
+		double ent;  // entropy 
+		double min_ent; // min entropy 
+		double mu_x;
+
+		/* Determine the first non-zero bin */
+		first_bin=0;
+		for (ih = 0; ih < 256; ih++ ) {
+			if ( data[ih] != 0 ) {
+				first_bin = ih;
+				break;
+			}
+		}
+
+		/* Determine the last non-zero bin */
+		last_bin=255;
+		for (ih = 255; ih >= first_bin; ih-- ) {
+			if ( data[ih] != 0 ) {
+				last_bin = ih;
+				break;
+			}
+		}
+		term = 1.0 / ( double ) ( last_bin - first_bin );
+		double [] mu_0 = new double[256];
+		sum_pix = num_pix = 0;
+		for ( ih = first_bin; ih < 256; ih++ ){
+			sum_pix += (double)ih * data[ih];
+			num_pix += data[ih];
+			/* NUM_PIX cannot be zero ! */
+			mu_0[ih] = sum_pix / num_pix;
+		}
+
+		double [] mu_1 = new double[256];
+		sum_pix = num_pix = 0;
+		for ( ih = last_bin; ih > 0; ih-- ){
+			sum_pix += (double)ih * data[ih];
+			num_pix += data[ih];
+			/* NUM_PIX cannot be zero ! */
+			mu_1[ih - 1] = sum_pix / ( double ) num_pix;
+		}
+
+		/* Determine the threshold that minimizes the fuzzy entropy */
+		threshold = -1;
+		min_ent = Double.MAX_VALUE;
+		for ( it = 0; it < 256; it++ ){
+			ent = 0.0;
+			for ( ih = 0; ih <= it; ih++ ) {
+				/* Equation (4) in Ref. 1 */
+				mu_x = 1.0 / ( 1.0 + term * Math.abs ( ih - mu_0[it] ) );
+				if ( !((mu_x  < 1e-06 ) || ( mu_x > 0.999999))) {
+					/* Equation (6) & (8) in Ref. 1 */
+					ent += data[ih] * ( -mu_x * Math.log ( mu_x ) - ( 1.0 - mu_x ) * Math.log ( 1.0 - mu_x ) );
+				}
+			}
+
+			for ( ih = it + 1; ih < 256; ih++ ) {
+				/* Equation (4) in Ref. 1 */
+				mu_x = 1.0 / ( 1.0 + term * Math.abs ( ih - mu_1[it] ) );
+				if ( !((mu_x  < 1e-06 ) || ( mu_x > 0.999999))) {
+					/* Equation (6) & (8) in Ref. 1 */
+					ent += data[ih] * ( -mu_x * Math.log ( mu_x ) - ( 1.0 - mu_x ) * Math.log ( 1.0 - mu_x ) );
+				}
+			}
+			/* No need to divide by NUM_ROWS * NUM_COLS * LOG(2) ! */
+			if ( ent < min_ent ) {
+				min_ent = ent;
+				threshold = it;
+			}
+		}
+		return threshold;
+	}
+
+	boolean bimodalTest(double [] y) {
+		int len=y.length;
+		boolean b = false;
+		int modes = 0;
+ 
+		for (int k=1;k<len-1;k++){
+			if (y[k-1] < y[k] && y[k+1] < y[k]) {
+				modes++;
+				if (modes>2)
+					return false;
+			}
+		}
+		if (modes == 2)
+			b = true;
+		return b;
+	}
+
+	int Intermodes(int[] data ) {
+		// J. M. S. Prewitt and M. L. Mendelsohn, "The analysis of cell images," in
+		// Annals of the New York Academy of Sciences, vol. 128, pp. 1035-1053, 1966.
+		// ported to ImageJ plugin by G.Landini from Antti Niemisto's Matlab code (GPL)
+		// Original Matlab code Copyright (C) 2004 Antti Niemisto
+		// See http://www.cs.tut.fi/~ant/histthresh/ for an excellent slide presentation
+		// and the original Matlab code.
+		//
+		// Assumes a bimodal histogram. The histogram needs is smoothed (using a
+		// running average of size 3, iteratively) until there are only two local maxima.
+		// j and k
+		// Threshold t is (j+k)/2.
+		// Images with histograms having extremely unequal peaks or a broad and
+		// flat valleys are unsuitable for this method.
+		
+		int minbin=-1, maxbin=-1;
+		for (int i=0; i<data.length; i++)
+			if (data[i]>0) maxbin = i;
+		for (int i=data.length-1; i>=0; i--)
+			if (data[i]>0) minbin = i;
+		int length = (maxbin-minbin)+1;
+		double [] hist = new double[length];
+		for (int i=minbin; i<=maxbin; i++)
+			hist[i-minbin] = data[i];
+			
+		int iter = 0;
+		int threshold=-1;
+		while (!bimodalTest(hist) ) {
+			 //smooth with a 3 point running mean filter
+			double previous=0, current=0, next=hist[0];
+			for (int i=0; i<length-1; i++) {
+				previous = current;
+				current = next;
+				next = hist[i + 1];
+				hist[i] = (previous+current+next)/3;
+			}
+			hist[length-1] = (current+next)/3;
+			iter++;
+			if (iter>10000) {
+				threshold = -1;
+				IJ.log("Intermodes Threshold not found after 10000 iterations.");
+				return threshold;
+			}
+		}
+
+		// The threshold is the mean between the two peaks.
+		int tt=0;
+		for (int i=1; i<length - 1; i++) {
+			if (hist[i-1] < hist[i] && hist[i+1] < hist[i]){
+				tt += i;
+				//IJ.log("mode:" +i);
+			}
+		}
+		threshold = (int) Math.floor(tt/2.0);
+		return threshold+minbin;
+	}
+
+	int IsoData(int[] data ) {
+		// Also called intermeans
+		// Iterative procedure based on the isodata algorithm [T.W. Ridler, S. Calvard, Picture 
+		// thresholding using an iterative selection method, IEEE Trans. System, Man and 
+		// Cybernetics, SMC-8 (1978) 630-632.] 
+		// The procedure divides the image into objects and background by taking an initial threshold,
+		// then the averages of the pixels at or below the threshold and pixels above are computed. 
+		// The averages of those two values are computed, the threshold is incremented and the 
+		// process is repeated until the threshold is larger than the composite average. That is,
+		//  threshold = (average background + average objects)/2
+		// The code in ImageJ that implements this function is the getAutoThreshold() method in the ImageProcessor class. 
+		//
+		// From: Tim Morris (dtm@ap.co.umist.ac.uk)
+		// Subject: Re: Thresholding method?
+		// posted to sci.image.processing on 1996/06/24
+		// The algorithm implemented in NIH Image sets the threshold as that grey
+		// value, G, for which the average of the averages of the grey values
+		// below and above G is equal to G. It does this by initialising G to the
+		// lowest sensible value and iterating:
+
+		// L = the average grey value of pixels with intensities < G
+		// H = the average grey value of pixels with intensities > G
+		// is G = (L + H)/2?
+		// yes => exit
+		// no => increment G and repeat
+		//
+		int i, l, totl, g=0;
+		double toth, h;
+		for (i = 1; i < 256; i++) {
+			if (data[i] > 0){
+				g = i + 1;
+				break;
+			}
+		}
+		while (true){
+			l = 0;
+			totl = 0;
+			for (i = 0; i < g; i++) {
+				 totl = totl + data[i];
+				 l = l + (data[i] * i);
+			}
+			h = 0;
+			toth = 0;
+			for (i = g + 1; i < 256; i++){
+				toth += data[i];
+				h += ((double)data[i]*i);
+			}
+			if (totl > 0 && toth > 0){
+				l /= totl;
+				h /= toth;
+				if (g == (int) Math.round((l + h) / 2.0))
+					break;
+			}
+			g++;
+			if (g > 254)
+				return -1;
+		}
+		return g;
+	}
+	
+	int defaultIsoData(int[] data) {
+		// This is the modified IsoData method used by the "Threshold" widget in "Default" mode
+		int n = data.length;
+		int[] data2 = new int[n];
+		int mode=0, maxCount=0;
+		for (int i=0; i<n; i++) {
+			int count = data[i];
+			data2[i] = data[i];
+			if (data2[i]>maxCount) {
+				maxCount = data2[i];
+				mode = i;
+			}
+		}
+		int maxCount2 = 0;
+		for (int i = 0; i<n; i++) {
+			if ((data2[i]>maxCount2) && (i!=mode))
+				maxCount2 = data2[i];
+		}
+		int hmax = maxCount;
+		if ((hmax>(maxCount2*2)) && (maxCount2!=0)) {
+			hmax = (int)(maxCount2 * 1.5);
+			data2[mode] = hmax;
+		}
+		return IJIsoData(data2);
+	}
+
+	int IJIsoData(int[] data) {
+		// This is the original ImageJ IsoData implementation, here for backward compatibility.
+		int level;
+		int maxValue = data.length - 1;
+		double result, sum1, sum2, sum3, sum4;
+		int count0 = data[0];
+		data[0] = 0; //set to zero so erased areas aren't included
+		int countMax = data[maxValue];
+		data[maxValue] = 0;
+		int min = 0;
+		while ((data[min]==0) && (min<maxValue))
+			min++;
+		int max = maxValue;
+		while ((data[max]==0) && (max>0))
+			max--;
+		if (min>=max) {
+			data[0]= count0; data[maxValue]=countMax;
+			level = data.length/2;
+			return level;
+		}
+		int movingIndex = min;
+		int inc = Math.max(max/40, 1);
+		do {
+			sum1=sum2=sum3=sum4=0.0;
+			for (int i=min; i<=movingIndex; i++) {
+				sum1 += (double)i*data[i];
+				sum2 += data[i];
+			}
+			for (int i=(movingIndex+1); i<=max; i++) {
+				sum3 += (double)i*data[i];
+				sum4 += data[i];
+			}			
+			result = (sum1/sum2 + sum3/sum4)/2.0;
+			movingIndex++;
+		} while ((movingIndex+1)<=result && movingIndex<max-1);
+		data[0]= count0; data[maxValue]=countMax;
+		level = (int)Math.round(result);
+		return level;
+	}
+
+
+	int Li(int [] data ) {
+		// Implements Li's Minimum Cross Entropy thresholding method
+		// This implementation is based on the iterative version (Ref. 2) of the algorithm.
+		// 1) Li C.H. and Lee C.K. (1993) "Minimum Cross Entropy Thresholding" 
+		//    Pattern Recognition, 26(4): 617-625
+		// 2) Li C.H. and Tam P.K.S. (1998) "An Iterative Algorithm for Minimum 
+		//    Cross Entropy Thresholding"Pattern Recognition Letters, 18(8): 771-776
+		// 3) Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding 
+		//    Techniques and Quantitative Performance Evaluation" Journal of 
+		//    Electronic Imaging, 13(1): 146-165 
+		//    http://citeseer.ist.psu.edu/sezgin04survey.html
+		// Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
+		int threshold;
+		double num_pixels;
+		double sum_back; /* sum of the background pixels at a given threshold */
+		double sum_obj;  /* sum of the object pixels at a given threshold */
+		double num_back; /* number of background pixels at a given threshold */
+		double num_obj;  /* number of object pixels at a given threshold */
+		double old_thresh;
+		double new_thresh;
+		double mean_back; /* mean of the background pixels at a given threshold */
+		double mean_obj;  /* mean of the object pixels at a given threshold */
+		double mean;  /* mean gray-level in the image */
+		double tolerance; /* threshold tolerance */
+		double temp;
+
+		tolerance=0.5;
+		num_pixels = 0;
+		for (int ih = 0; ih < 256; ih++ ) 
+			num_pixels += data[ih];
+
+		/* Calculate the mean gray-level */
+		mean = 0.0;
+		for (int ih = 0 + 1; ih < 256; ih++ ) //0 + 1?
+			mean += (double)ih * data[ih];
+		mean /= num_pixels;
+		/* Initial estimate */
+		new_thresh = mean;
+
+		do {
+			old_thresh = new_thresh;
+			threshold = (int) (old_thresh + 0.5);	/* range */
+			/* Calculate the means of background and object pixels */
+			/* Background */
+			sum_back = 0;
+			num_back = 0;
+			for (int ih = 0; ih <= threshold; ih++ ) {
+				sum_back += (double)ih * data[ih];
+				num_back += data[ih];
+			}
+			mean_back = ( num_back == 0 ? 0.0 : ( sum_back / ( double ) num_back ) );
+			/* Object */
+			sum_obj = 0;
+			num_obj = 0;
+			for (int ih = threshold + 1; ih < 256; ih++ ) {
+				sum_obj += (double)ih * data[ih];
+				num_obj += data[ih];
+			}
+			mean_obj = ( num_obj == 0 ? 0.0 : ( sum_obj / ( double ) num_obj ) );
+
+			/* Calculate the new threshold: Equation (7) in Ref. 2 */
+			//new_thresh = simple_round ( ( mean_back - mean_obj ) / ( Math.log ( mean_back ) - Math.log ( mean_obj ) ) );
+			//simple_round ( double x ) {
+			// return ( int ) ( IS_NEG ( x ) ? x - .5 : x + .5 );
+			//}
+			//
+			//#define IS_NEG( x ) ( ( x ) < -DBL_EPSILON ) 
+			//DBL_EPSILON = 2.220446049250313E-16
+			temp = ( mean_back - mean_obj ) / ( Math.log ( mean_back ) - Math.log ( mean_obj ) );
+
+			if (temp < -2.220446049250313E-16)
+				new_thresh = (int) (temp - 0.5);
+			else
+				new_thresh = (int) (temp + 0.5);
+			/*  Stop the iterations when the difference between the
+			new and old threshold values is less than the tolerance */
+		}
+		while ( Math.abs ( new_thresh - old_thresh ) > tolerance );
+		return threshold;
+	}
+
+	int MaxEntropy(int [] data ) {
+		// Implements Kapur-Sahoo-Wong (Maximum Entropy) thresholding method
+		// Kapur J.N., Sahoo P.K., and Wong A.K.C. (1985) "A New Method for
+		// Gray-Level Picture Thresholding Using the Entropy of the Histogram"
+		// Graphical Models and Image Processing, 29(3): 273-285
+		// M. Emre Celebi
+		// 06.15.2007
+		// Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
+		int threshold=-1;
+		int ih, it;
+		int first_bin;
+		int last_bin;
+		double tot_ent;  /* total entropy */
+		double max_ent;  /* max entropy */
+		double ent_back; /* entropy of the background pixels at a given threshold */
+		double ent_obj;  /* entropy of the object pixels at a given threshold */
+		double [] norm_histo = new double[256]; /* normalized histogram */
+		double [] P1 = new double[256]; /* cumulative normalized histogram */
+		double [] P2 = new double[256]; 
+
+		double total =0;
+		for (ih = 0; ih < 256; ih++ ) 
+			total+=data[ih];
+
+		for (ih = 0; ih < 256; ih++ )
+			norm_histo[ih] = data[ih]/total;
+
+		P1[0]=norm_histo[0];
+		P2[0]=1.0-P1[0];
+		for (ih = 1; ih < 256; ih++ ){
+			P1[ih]= P1[ih-1] + norm_histo[ih];
+			P2[ih]= 1.0 - P1[ih];
+		}
+
+		/* Determine the first non-zero bin */
+		first_bin=0;
+		for (ih = 0; ih < 256; ih++ ) {
+			if ( !(Math.abs(P1[ih])<2.220446049250313E-16)) {
+				first_bin = ih;
+				break;
+			}
+		}
+
+		/* Determine the last non-zero bin */
+		last_bin=255;
+		for (ih = 255; ih >= first_bin; ih-- ) {
+			if ( !(Math.abs(P2[ih])<2.220446049250313E-16)) {
+				last_bin = ih;
+				break;
+			}
+		}
+
+		// Calculate the total entropy each gray-level
+		// and find the threshold that maximizes it 
+		max_ent = Double.MIN_VALUE;
+
+		for ( it = first_bin; it <= last_bin; it++ ) {
+			/* Entropy of the background pixels */
+			ent_back = 0.0;
+			for ( ih = 0; ih <= it; ih++ )  {
+				if ( data[ih] !=0 ) {
+					ent_back -= ( norm_histo[ih] / P1[it] ) * Math.log ( norm_histo[ih] / P1[it] );
+				}
+			}
+
+			/* Entropy of the object pixels */
+			ent_obj = 0.0;
+			for ( ih = it + 1; ih < 256; ih++ ){
+				if (data[ih]!=0){
+				ent_obj -= ( norm_histo[ih] / P2[it] ) * Math.log ( norm_histo[ih] / P2[it] );
+				}
+			}
+
+			/* Total entropy */
+			tot_ent = ent_back + ent_obj;
+
+			// IJ.log(""+max_ent+"  "+tot_ent);
+			if ( max_ent < tot_ent ) {
+				max_ent = tot_ent;
+				threshold = it;
+			}
+		}
+		return threshold;
+	}
+
+	int Mean(int [] data ) {
+		// C. A. Glasbey, "An analysis of histogram-based thresholding algorithms,"
+		// CVGIP: Graphical Models and Image Processing, vol. 55, pp. 532-537, 1993.
+		//
+		// The threshold is the mean of the greyscale data
+		int threshold = -1;
+		double tot=0, sum=0;
+		for (int i=0; i<256; i++){
+			tot+= data[i];
+			sum+=((double)i*data[i]);
+		}
+		threshold =(int) Math.floor(sum/tot);
+		return threshold;
+	}
+
+	int MinErrorI(int [] data ) {
+		// Kittler and J. Illingworth, "Minimum error thresholding," Pattern Recognition, vol. 19, pp. 41-47, 1986.
+		// C. A. Glasbey, "An analysis of histogram-based thresholding algorithms," CVGIP: Graphical Models and Image Processing, vol. 55, pp. 532-537, 1993.
+		// Ported to ImageJ plugin by G.Landini from Antti Niemisto's Matlab code (GPL)
+		// Original Matlab code Copyright (C) 2004 Antti Niemisto
+		// See http://www.cs.tut.fi/~ant/histthresh/ for an excellent slide presentation
+		// and the original Matlab code.
+
+		int threshold = Mean(data); //Initial estimate for the threshold is found with the MEAN algorithm.
+		int Tprev =-2;
+		double mu, nu, p, q, sigma2, tau2, w0, w1, w2, sqterm, temp;
+		//int counter=1;
+		while (threshold!=Tprev){
+			//Calculate some statistics.
+			mu = B(data, threshold)/A(data, threshold);
+			nu = (B(data, data.length - 1)-B(data, threshold))/(A(data, data.length - 1)-A(data, threshold));
+			p = A(data, threshold)/A(data, data.length - 1);
+			q = (A(data, data.length - 1)-A(data, threshold)) / A(data, data.length - 1);
+			sigma2 = C(data, threshold)/A(data, threshold)-(mu*mu);
+			tau2 = (C(data, data.length - 1)-C(data, threshold)) / (A(data, data.length - 1)-A(data, threshold)) - (nu*nu);
+
+			//The terms of the quadratic equation to be solved.
+			w0 = 1.0/sigma2-1.0/tau2;
+			w1 = mu/sigma2-nu/tau2;
+			w2 = (mu*mu)/sigma2 - (nu*nu)/tau2 + Math.log10((sigma2*(q*q))/(tau2*(p*p)));
+
+			//If the next threshold would be imaginary, return with the current one.
+			sqterm = (w1*w1)-w0*w2;
+			if (sqterm < 0) {
+				IJ.log("MinError(I): not converging.");
+				return threshold;
+			}
+
+			//The updated threshold is the integer part of the solution of the quadratic equation.
+			Tprev = threshold;
+			temp = (w1+Math.sqrt(sqterm))/w0;
+
+			if (Double.isNaN(temp))
+				threshold = Tprev;
+			else
+				threshold =(int) Math.floor(temp);
+		}
+		return threshold;
+	}
+
+	private double A(int[] y, int j) {
+		if (j>=y.length) j=y.length-1;
+		double x = 0;
+		for (int i=0;i<=j;i++)
+			x+=y[i];
+		return x;
+	}
+
+	private double B(int[] y, int j) {
+		if (j>=y.length) j=y.length-1;
+		double x = 0;
+		for (int i=0;i<=j;i++)
+			x+=i*y[i];
+		return x;
+	}
+
+	private double C(int[] y, int j) {
+		if (j>=y.length) j=y.length-1;
+		double x = 0;
+		for (int i=0;i<=j;i++)
+			x+=i*i*y[i];
+		return x;
+	}
+
+	int Minimum(int [] data ) {
+		// J. M. S. Prewitt and M. L. Mendelsohn, "The analysis of cell images," in
+		// Annals of the New York Academy of Sciences, vol. 128, pp. 1035-1053, 1966.
+		// ported to ImageJ plugin by G.Landini from Antti Niemisto's Matlab code (GPL)
+		// Original Matlab code Copyright (C) 2004 Antti Niemisto
+		// See http://www.cs.tut.fi/~ant/histthresh/ for an excellent slide presentation
+		// and the original Matlab code.
+		//
+		// Assumes a bimodal histogram. The histogram needs is smoothed (using a
+		// running average of size 3, iteratively) until there are only two local maxima.
+		// Threshold t is such that yt-1 > yt <= yt+1.
+		// Images with histograms having extremely unequal peaks or a broad and
+		// flat valleys are unsuitable for this method.
+		int iter =0;
+		int threshold = -1;
+		double [] iHisto = new double [256];
+		for (int i=0; i<256; i++)
+			iHisto[i]=(double) data[i];
+		double [] tHisto = new double[iHisto.length] ;
+
+		while (!bimodalTest(iHisto) ) {
+			 //smooth with a 3 point running mean filter
+			for (int i=1; i<255; i++)
+				tHisto[i]= (iHisto[i-1] + iHisto[i] +iHisto[i+1])/3;
+			tHisto[0] = (iHisto[0]+iHisto[1])/3; //0 outside
+			tHisto[255] = (iHisto[254]+iHisto[255])/3; //0 outside
+			System.arraycopy(tHisto, 0, iHisto, 0, iHisto.length) ;
+			iter++;
+			if (iter>10000) {
+				threshold = -1;
+				IJ.log("Minimum: threshold not found after 10000 iterations.");
+				return threshold;
+			}
+		}
+		// The threshold is the minimum between the two peaks.
+		for (int i=1; i<255; i++) {
+			if (iHisto[i-1] > iHisto[i] && iHisto[i+1] >= iHisto[i]) {
+				threshold = i;
+				break;
+			}
+		}
+		return threshold;
+	}
+
+	int Moments(int [] data ) {
+		//  W. Tsai, "Moment-preserving thresholding: a new approach," Computer Vision,
+		// Graphics, and Image Processing, vol. 29, pp. 377-393, 1985.
+		// Ported to ImageJ plugin by G.Landini from the the open source project FOURIER 0.8
+		// by  M. Emre Celebi , Department of Computer Science,  Louisiana State University in Shreveport
+		// Shreveport, LA 71115, USA
+		//  http://sourceforge.net/projects/fourier-ipal
+		//  http://www.lsus.edu/faculty/~ecelebi/fourier.htm
+		double total =0;
+		double m0=1.0, m1=0.0, m2 =0.0, m3 =0.0, sum =0.0, p0=0.0;
+		double cd, c0, c1, z0, z1;	/* auxiliary variables */
+		int threshold = -1;
+
+		double [] histo = new  double [256];
+
+		for (int i=0; i<256; i++)
+			total+=data[i];
+
+		for (int i=0; i<256; i++)
+			histo[i]=(double)(data[i]/total); //normalised histogram
+
+		/* Calculate the first, second, and third order moments */
+		for ( int i = 0; i < 256; i++ ) {
+			double di = i;
+			m1 += di * histo[i];
+			m2 += di * di * histo[i];
+			m3 += di * di * di * histo[i];
+		}
+		/* 
+		First 4 moments of the gray-level image should match the first 4 moments
+		of the target binary image. This leads to 4 equalities whose solutions 
+		are given in the Appendix of Ref. 1 
+		*/
+		cd = m0 * m2 - m1 * m1;
+		c0 = ( -m2 * m2 + m1 * m3 ) / cd;
+		c1 = ( m0 * -m3 + m2 * m1 ) / cd;
+		z0 = 0.5 * ( -c1 - Math.sqrt ( c1 * c1 - 4.0 * c0 ) );
+		z1 = 0.5 * ( -c1 + Math.sqrt ( c1 * c1 - 4.0 * c0 ) );
+		p0 = ( z1 - m1 ) / ( z1 - z0 );  /* Fraction of the object pixels in the target binary image */
+
+		// The threshold is the gray-level closest  
+		// to the p0-tile of the normalized histogram 
+		sum=0;
+		for (int i=0; i<256; i++){
+			sum+=histo[i];
+			if (sum>p0) {
+				threshold = i;
+				break;
+			}
+		}
+		return threshold;
+	}
+
+	int Otsu(int [] data ) {
+		// Otsu's threshold algorithm
+		// C++ code by Jordan Bevik <Jordan.Bevic@qtiworld.com>
+		// ported to ImageJ plugin by G.Landini
+		int k,kStar;  // k = the current threshold; kStar = optimal threshold
+		double N1, N;    // N1 = # points with intensity <=k; N = total number of points
+		double BCV, BCVmax; // The current Between Class Variance and maximum BCV
+		double num, denom;  // temporary bookeeping
+		double Sk;  // The total intensity for all histogram points <=k
+		double S, L=256; // The total intensity of the image
+
+		// Initialize values:
+		S = N = 0;
+		for (k=0; k<L; k++){
+			S += (double)k * data[k];	// Total histogram intensity
+			N += data[k];		// Total number of data points
+		}
+
+		Sk = 0;
+		N1 = data[0]; // The entry for zero intensity
+		BCV = 0;
+		BCVmax=0;
+		kStar = 0;
+
+		// Look at each possible threshold value,
+		// calculate the between-class variance, and decide if it's a max
+		for (k=1; k<L-1; k++) { // No need to check endpoints k = 0 or k = L-1
+			Sk += (double)k * data[k];
+			N1 += data[k];
+
+			// The float casting here is to avoid compiler warning about loss of precision and
+			// will prevent overflow in the case of large saturated images
+			denom = (double)( N1) * (N - N1); // Maximum value of denom is (N^2)/4 =  approx. 3E10
+
+			if (denom != 0 ){
+				// Float here is to avoid loss of precision when dividing
+				num = ( (double)N1 / N ) * S - Sk; 	// Maximum value of num =  255*N = approx 8E7
+				BCV = (num * num) / denom;
+			}
+			else
+				BCV = 0;
+
+			if (BCV >= BCVmax){ // Assign the best threshold found so far
+				BCVmax = BCV;
+				kStar = k;
+			}
+		}
+		// kStar += 1;	// Use QTI convention that intensity -> 1 if intensity >= k
+		// (the algorithm was developed for I-> 1 if I <= k.)
+		return kStar;
+	}
+
+
+	int Percentile(int [] data ) {
+		// W. Doyle, "Operation useful for similarity-invariant pattern recognition,"
+		// Journal of the Association for Computing Machinery, vol. 9,pp. 259-267, 1962.
+		// ported to ImageJ plugin by G.Landini from Antti Niemisto's Matlab code (GPL)
+		// Original Matlab code Copyright (C) 2004 Antti Niemisto
+		// See http://www.cs.tut.fi/~ant/histthresh/ for an excellent slide presentation
+		// and the original Matlab code.
+
+		int iter =0;
+		int threshold = -1;
+		double ptile= 0.5; // default fraction of foreground pixels
+		double [] avec = new double [256];
+
+		for (int i=0; i<256; i++)
+			avec[i]=0.0;
+
+		double total =partialSum(data, 255);
+		double temp = 1.0;
+		for (int i=0; i<256; i++){
+			avec[i]=Math.abs((partialSum(data, i)/total)-ptile);
+			//IJ.log("Ptile["+i+"]:"+ avec[i]);
+			if (avec[i]<temp) {
+				temp = avec[i];
+				threshold = i;
+			}
+		}
+		return threshold;
+	}
+
+
+	double partialSum(int [] y, int j) {
+		double x = 0;
+		for (int i=0;i<=j;i++)
+			x+=y[i];
+		return x;
+	}
+
+
+	int RenyiEntropy(int [] data ) {
+		// Kapur J.N., Sahoo P.K., and Wong A.K.C. (1985) "A New Method for
+		// Gray-Level Picture Thresholding Using the Entropy of the Histogram"
+		// Graphical Models and Image Processing, 29(3): 273-285
+		// M. Emre Celebi
+		// 06.15.2007
+		// Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
+
+		int threshold; 
+		int opt_threshold;
+
+		int ih, it;
+		int first_bin;
+		int last_bin;
+		int tmp_var;
+		int t_star1, t_star2, t_star3;
+		int beta1, beta2, beta3;
+		double alpha;/* alpha parameter of the method */
+		double term;
+		double tot_ent;  /* total entropy */
+		double max_ent;  /* max entropy */
+		double ent_back; /* entropy of the background pixels at a given threshold */
+		double ent_obj;  /* entropy of the object pixels at a given threshold */
+		double omega;
+		double [] norm_histo = new double[256]; /* normalized histogram */
+		double [] P1 = new double[256]; /* cumulative normalized histogram */
+		double [] P2 = new double[256]; 
+
+		double total =0;
+		for (ih = 0; ih < 256; ih++ ) 
+			total+=data[ih];
+
+		for (ih = 0; ih < 256; ih++ )
+			norm_histo[ih] = data[ih]/total;
+
+		P1[0]=norm_histo[0];
+		P2[0]=1.0-P1[0];
+		for (ih = 1; ih < 256; ih++ ){
+			P1[ih]= P1[ih-1] + norm_histo[ih];
+			P2[ih]= 1.0 - P1[ih];
+		}
+
+		/* Determine the first non-zero bin */
+		first_bin=0;
+		for (ih = 0; ih < 256; ih++ ) {
+			if ( !(Math.abs(P1[ih])<2.220446049250313E-16)) {
+				first_bin = ih;
+				break;
+			}
+		}
+
+		/* Determine the last non-zero bin */
+		last_bin=255;
+		for (ih = 255; ih >= first_bin; ih-- ) {
+			if ( !(Math.abs(P2[ih])<2.220446049250313E-16)) {
+				last_bin = ih;
+				break;
+			}
+		}
+
+		/* Maximum Entropy Thresholding - BEGIN */
+		/* ALPHA = 1.0 */
+		/* Calculate the total entropy each gray-level
+		and find the threshold that maximizes it 
+		*/
+		threshold =0; // was MIN_INT in original code, but if an empty image is processed it gives an error later on.
+		max_ent = 0.0;
+
+		for ( it = first_bin; it <= last_bin; it++ ) {
+			/* Entropy of the background pixels */
+			ent_back = 0.0;
+			for ( ih = 0; ih <= it; ih++ )  {
+				if ( data[ih] !=0 ) {
+					ent_back -= ( norm_histo[ih] / P1[it] ) * Math.log ( norm_histo[ih] / P1[it] );
+				}
+			}
+
+			/* Entropy of the object pixels */
+			ent_obj = 0.0;
+			for ( ih = it + 1; ih < 256; ih++ ){
+				if (data[ih]!=0){
+				ent_obj -= ( norm_histo[ih] / P2[it] ) * Math.log ( norm_histo[ih] / P2[it] );
+				}
+			}
+
+			/* Total entropy */
+			tot_ent = ent_back + ent_obj;
+
+			// IJ.log(""+max_ent+"  "+tot_ent);
+
+			if ( max_ent < tot_ent ) {
+				max_ent = tot_ent;
+				threshold = it;
+			}
+		}
+		t_star2 = threshold;
+
+		/* Maximum Entropy Thresholding - END */
+		threshold =0; //was MIN_INT in original code, but if an empty image is processed it gives an error later on.
+		max_ent = 0.0;
+		alpha = 0.5;
+		term = 1.0 / ( 1.0 - alpha );
+		for ( it = first_bin; it <= last_bin; it++ ) {
+			/* Entropy of the background pixels */
+			ent_back = 0.0;
+			for ( ih = 0; ih <= it; ih++ )
+				ent_back += Math.sqrt ( norm_histo[ih] / P1[it] );
+
+			/* Entropy of the object pixels */
+			ent_obj = 0.0;
+			for ( ih = it + 1; ih < 256; ih++ )
+				ent_obj += Math.sqrt ( norm_histo[ih] / P2[it] );
+
+			/* Total entropy */
+			tot_ent = term * ( ( ent_back * ent_obj ) > 0.0 ? Math.log ( ent_back * ent_obj ) : 0.0);
+
+			if ( tot_ent > max_ent ){
+				max_ent = tot_ent;
+				threshold = it;
+			}
+		}
+
+		t_star1 = threshold;
+
+		threshold = 0; //was MIN_INT in original code, but if an empty image is processed it gives an error later on.
+		max_ent = 0.0;
+		alpha = 2.0;
+		term = 1.0 / ( 1.0 - alpha );
+		for ( it = first_bin; it <= last_bin; it++ ) {
+			/* Entropy of the background pixels */
+			ent_back = 0.0;
+			for ( ih = 0; ih <= it; ih++ )
+				ent_back += ( norm_histo[ih] * norm_histo[ih] ) / ( P1[it] * P1[it] );
+
+			/* Entropy of the object pixels */
+			ent_obj = 0.0;
+			for ( ih = it + 1; ih < 256; ih++ )
+				ent_obj += ( norm_histo[ih] * norm_histo[ih] ) / ( P2[it] * P2[it] );
+
+			/* Total entropy */
+			tot_ent = term *( ( ent_back * ent_obj ) > 0.0 ? Math.log(ent_back * ent_obj ): 0.0 );
+
+			if ( tot_ent > max_ent ){
+				max_ent = tot_ent;
+				threshold = it;
+			}
+		}
+
+		t_star3 = threshold;
+
+		/* Sort t_star values */
+		if ( t_star2 < t_star1 ){
+			tmp_var = t_star1;
+			t_star1 = t_star2;
+			t_star2 = tmp_var;
+		}
+		if ( t_star3 < t_star2 ){
+			tmp_var = t_star2;
+			t_star2 = t_star3;
+			t_star3 = tmp_var;
+		}
+		if ( t_star2 < t_star1 ) {
+			tmp_var = t_star1;
+			t_star1 = t_star2;
+			t_star2 = tmp_var;
+		}
+
+		/* Adjust beta values */
+		if ( Math.abs ( t_star1 - t_star2 ) <= 5 )  {
+			if ( Math.abs ( t_star2 - t_star3 ) <= 5 ) {
+				beta1 = 1;
+				beta2 = 2;
+				beta3 = 1;
+			}
+			else {
+				beta1 = 0;
+				beta2 = 1;
+				beta3 = 3;
+			}
+		}
+		else {
+			if ( Math.abs ( t_star2 - t_star3 ) <= 5 ) {
+				beta1 = 3;
+				beta2 = 1;
+				beta3 = 0;
+			}
+			else {
+				beta1 = 1;
+				beta2 = 2;
+				beta3 = 1;
+			}
+		}
+		//IJ.log(""+t_star1+" "+t_star2+" "+t_star3);
+		/* Determine the optimal threshold value */
+		omega = P1[t_star3] - P1[t_star1];
+		opt_threshold = (int) (t_star1 * ( P1[t_star1] + 0.25 * omega * beta1 ) + 0.25 * t_star2 * omega * beta2  + t_star3 * ( P2[t_star3] + 0.25 * omega * beta3 ));
+
+		return opt_threshold;
+	}
+
+
+	int Shanbhag(int [] data ) {
+		// Shanhbag A.G. (1994) "Utilization of Information Measure as a Means of
+		//  Image Thresholding" Graphical Models and Image Processing, 56(5): 414-419
+		// Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
+		int threshold;
+		int ih, it;
+		int first_bin;
+		int last_bin;
+		double term;
+		double tot_ent;  /* total entropy */
+		double min_ent;  /* max entropy */
+		double ent_back; /* entropy of the background pixels at a given threshold */
+		double ent_obj;  /* entropy of the object pixels at a given threshold */
+		double [] norm_histo = new double[256]; /* normalized histogram */
+		double [] P1 = new double[256]; /* cumulative normalized histogram */
+		double [] P2 = new double[256]; 
+
+		double total =0;
+		for (ih = 0; ih < 256; ih++ ) 
+			total+=data[ih];
+
+		for (ih = 0; ih < 256; ih++ )
+			norm_histo[ih] = data[ih]/total;
+
+		P1[0]=norm_histo[0];
+		P2[0]=1.0-P1[0];
+		for (ih = 1; ih < 256; ih++ ){
+			P1[ih]= P1[ih-1] + norm_histo[ih];
+			P2[ih]= 1.0 - P1[ih];
+		}
+
+		/* Determine the first non-zero bin */
+		first_bin=0;
+		for (ih = 0; ih < 256; ih++ ) {
+			if ( !(Math.abs(P1[ih])<2.220446049250313E-16)) {
+				first_bin = ih;
+				break;
+			}
+		}
+
+		/* Determine the last non-zero bin */
+		last_bin=255;
+		for (ih = 255; ih >= first_bin; ih-- ) {
+			if ( !(Math.abs(P2[ih])<2.220446049250313E-16)) {
+				last_bin = ih;
+				break;
+			}
+		}
+
+		// Calculate the total entropy each gray-level
+		// and find the threshold that maximizes it 
+		threshold =-1;
+		min_ent = Double.MAX_VALUE;
+
+		for ( it = first_bin; it <= last_bin; it++ ) {
+			/* Entropy of the background pixels */
+			ent_back = 0.0;
+			term = 0.5 / P1[it];
+			for ( ih = 1; ih <= it; ih++ )  { //0+1?
+				ent_back -= norm_histo[ih] * Math.log ( 1.0 - term * P1[ih - 1] );
+			}
+			ent_back *= term;
+
+			/* Entropy of the object pixels */
+			ent_obj = 0.0;
+			term = 0.5 / P2[it];
+			for ( ih = it + 1; ih < 256; ih++ ){
+				ent_obj -= norm_histo[ih] * Math.log ( 1.0 - term * P2[ih] );
+			}
+			ent_obj *= term;
+
+			/* Total entropy */
+			tot_ent = Math.abs ( ent_back - ent_obj );
+
+			if ( tot_ent < min_ent ) {
+				min_ent = tot_ent;
+				threshold = it;
+			}
+		}
+		return threshold;
+	}
+
+
+	int Triangle(int [] data ) {
+		//  Zack, G. W., Rogers, W. E. and Latt, S. A., 1977,
+		//  Automatic Measurement of Sister Chromatid Exchange Frequency,
+		// Journal of Histochemistry and Cytochemistry 25 (7), pp. 741-753
+		//
+		//  modified from Johannes Schindelin plugin
+		// 
+		// find min and max
+		int min = 0, dmax=0, max = 0, min2=0;
+		for (int i = 0; i < data.length; i++) {
+			if (data[i]>0){
+				min=i;
+				break;
+			}
+		}
+		if (min>0) min--; // line to the (p==0) point, not to data[min]
+
+		// The Triangle algorithm cannot tell whether the data is skewed to one side or another.
+		// This causes a problem as there are 2 possible thresholds between the max and the 2 extremes
+		// of the histogram.
+		// Here I propose to find out to which side of the max point the data is furthest, and use that as
+		//  the other extreme.
+		for (int i = 255; i >0; i-- ) {
+			if (data[i]>0){
+				min2=i;
+				break;
+			}
+		}
+		if (min2<255) min2++; // line to the (p==0) point, not to data[min]
+
+		for (int i =0; i < 256; i++) {
+			if (data[i] >dmax) {
+				max=i;
+				dmax=data[i];
+			}
+		}
+		// find which is the furthest side
+		//IJ.log(""+min+" "+max+" "+min2);
+		boolean inverted = false;
+		if ((max-min)<(min2-max)){
+			// reverse the histogram
+			//IJ.log("Reversing histogram.");
+			inverted = true;
+			int left  = 0;          // index of leftmost element
+			int right = 255; // index of rightmost element
+			while (left < right) {
+				// exchange the left and right elements
+				int temp = data[left]; 
+				data[left]  = data[right]; 
+				data[right] = temp;
+				// move the bounds toward the center
+				left++;
+				right--;
+			}
+			min=255-min2;
+			max=255-max;
+		}
+
+		if (min == max){
+			//IJ.log("Triangle:  min == max.");
+			return min;
+		}
+
+		// describe line by nx * x + ny * y - d = 0
+		double nx, ny, d;
+		// nx is just the max frequency as the other point has freq=0
+		nx = data[max];   //-min; // data[min]; //  lowest value bmin = (p=0)% in the image
+		ny = min - max;
+		d = Math.sqrt(nx * nx + ny * ny);
+		nx /= d;
+		ny /= d;
+		d = nx * min + ny * data[min];
+
+		// find split point
+		int split = min;
+		double splitDistance = 0;
+		for (int i = min + 1; i <= max; i++) {
+			double newDistance = nx * i + ny * data[i] - d;
+			if (newDistance > splitDistance) {
+				split = i;
+				splitDistance = newDistance;
+			}
+		}
+		split--;
+
+		if (inverted) {
+			// The histogram might be used for something else, so let's reverse it back
+			int left  = 0; 
+			int right = 255;
+			while (left < right) {
+				int temp = data[left]; 
+				data[left]  = data[right]; 
+				data[right] = temp;
+				left++;
+				right--;
+			}
+			return (255-split);
+		}
+		else
+			return split;
+	}
+
+
+	int Yen(int [] data ) {
+		// Implements Yen  thresholding method
+		// 1) Yen J.C., Chang F.J., and Chang S. (1995) "A New Criterion 
+		//    for Automatic Multilevel Thresholding" IEEE Trans. on Image 
+		//    Processing, 4(3): 370-378
+		// 2) Sezgin M. and Sankur B. (2004) "Survey over Image Thresholding 
+		//    Techniques and Quantitative Performance Evaluation" Journal of 
+		//    Electronic Imaging, 13(1): 146-165
+		//    http://citeseer.ist.psu.edu/sezgin04survey.html
+		//
+		// M. Emre Celebi
+		// 06.15.2007
+		// Ported to ImageJ plugin by G.Landini from E Celebi's fourier_0.8 routines
+		int threshold;
+		int ih, it;
+		double crit;
+		double max_crit;
+		double [] norm_histo = new double[256]; /* normalized histogram */
+		double [] P1 = new double[256]; /* cumulative normalized histogram */
+		double [] P1_sq = new double[256]; 
+		double [] P2_sq = new double[256]; 
+
+		double total =0;
+		for (ih = 0; ih < 256; ih++ ) 
+			total+=data[ih];
+
+		for (ih = 0; ih < 256; ih++ )
+			norm_histo[ih] = data[ih]/total;
+
+		P1[0]=norm_histo[0];
+		for (ih = 1; ih < 256; ih++ )
+			P1[ih]= P1[ih-1] + norm_histo[ih];
+
+		P1_sq[0]=norm_histo[0]*norm_histo[0];
+		for (ih = 1; ih < 256; ih++ )
+			P1_sq[ih]= P1_sq[ih-1] + norm_histo[ih] * norm_histo[ih];
+
+		P2_sq[255] = 0.0;
+		for ( ih = 254; ih >= 0; ih-- )
+			P2_sq[ih] = P2_sq[ih + 1] + norm_histo[ih + 1] * norm_histo[ih + 1];
+
+		/* Find the threshold that maximizes the criterion */
+		threshold = -1;
+		max_crit = Double.MIN_VALUE;
+		for ( it = 0; it < 256; it++ ) {
+			crit = -1.0 * (( P1_sq[it] * P2_sq[it] )> 0.0? Math.log( P1_sq[it] * P2_sq[it]):0.0) +  2 * ( ( P1[it] * ( 1.0 - P1[it] ) )>0.0? Math.log(  P1[it] * ( 1.0 - P1[it] ) ): 0.0);
+			if ( crit > max_crit ) {
+				max_crit = crit;
+				threshold = it;
+			}
+		}
+		return threshold;
+	}
+
+}
+
diff --git a/src/ij/process/BinaryInterpolator.java b/src/ij/process/BinaryInterpolator.java
new file mode 100644
index 0000000..6df28df
--- /dev/null
+++ b/src/ij/process/BinaryInterpolator.java
@@ -0,0 +1,240 @@
+package ij.process;
+import ij.IJ;
+import ij.ImagePlus;
+import ij.ImageStack;
+import ij.gui.Roi;
+import ij.plugin.filter.ThresholdToSelection;
+
+/*
+ * This plugin takes a binary stack as input, where some slices are
+ * labeled (i.e. contain white regions), and some are not. The unlabaled
+ * regions are interpolated by weighting the signed integer distance
+ * transformed labeled slices.
+ * 
+ * from:
+ * http://fiji.sc/cgi-bin/gitweb.cgi?p=fiji.git;a=blob_plain;f=src-plugins/VIB-lib/vib/BinaryInterpolator.java;h=f6a610659ad624d13f94639bc5c0149712071f9f;hb=refs/heads/master
+ */
+
+public class BinaryInterpolator {
+	int[][] idt;
+	int w, h;
+
+	public void run(ImagePlus image, Roi[] rois) {
+		w = image.getWidth();
+		h = image.getHeight();
+		ImageStack stack = new ImageStack(w, h);
+		int firstIndex = -1, lastIndex = -1;
+		for(int i = 1; i < rois.length; i++) {
+			if(rois[i] != null) {
+				firstIndex = (firstIndex == -1) ? i : firstIndex;
+				lastIndex = i;
+			}
+		}
+		if (firstIndex == -1) {
+			IJ.error("There must be at least one selection in order to interpolate.");
+			return;
+		}
+
+		for(int i = firstIndex; i <= lastIndex; i++) {
+			ByteProcessor bp = new ByteProcessor(w, h);
+			if(rois[i] != null) {
+				bp.copyBits(rois[i].getMask(), 
+							rois[i].getBounds().x, 
+							rois[i].getBounds().y, 
+							ij.process.Blitter.ADD);
+			}
+			stack.addSlice("", bp);
+		}
+		run(stack);
+		ImagePlus roiImage = new ImagePlus("bla", stack);
+		
+		ThresholdToSelection ts = new ThresholdToSelection();
+		ts.setup("", roiImage);
+		for(int i = firstIndex; i <= lastIndex; i++) {
+			ImageProcessor bp = stack.getProcessor(1);
+			stack.deleteSlice(1);
+			int threshold = 255;
+			bp.setThreshold(threshold, threshold, ImageProcessor.NO_LUT_UPDATE);
+			ts.run(bp);
+			rois[i] = roiImage.getRoi();
+		}
+	}
+
+	public void run(ImageStack stack) {	
+		int sliceCount = stack.size();
+		if (sliceCount < 3) {
+			IJ.error("Too few slices to interpolate!");
+			return;
+		}
+
+		IJ.showStatus("getting signed integer distance transform");
+		w = stack.getWidth();
+		h = stack.getHeight();
+		idt = new int[sliceCount][];
+		int first = sliceCount, last = -1;
+
+		for (int z = 0; z < sliceCount; z++) {
+			idt[z] = getIDT(stack.getProcessor(z + 1).getPixels());
+			if (idt[z] != null) {
+				if (z < first)
+					first = z;
+				last = z;
+			}
+		 }
+
+		if (first == last || last < 0) {
+			IJ.error("Not enough to interpolate");
+			return;
+		}
+
+		IJ.showStatus("calculating weights");
+		int current = 0, next = first;
+		for (int z = first; z < last; z++) {
+			if (z == next) {
+				current = z;
+				for (next = z + 1; idt[next] == null; next++);
+				continue;
+			}
+
+			byte[] p =
+				(byte[])stack.getProcessor(z + 1).getPixels();
+			for (int i = 0; i < w * h; i++)
+				if (0 <= idt[current][i] * (next - z)
+						+ idt[next][i] * (z - current))
+					p[i] = (byte)255;
+			IJ.showProgress(z - first + 1, last - z);
+		}
+	}
+
+	/*
+	 * The following calculates the signed integer distance transform.
+	 * Distance transform means that each pixel is assigned the distance
+	 * to the boundary.
+	 * IDT means that the distance is not the Euclidean, but the minimal
+	 * sum of neighbour distances with 3 for horizontal and neighbours,
+	 * and 4 for diagonal neighbours (in 3d, the 3d diagonal neighbour
+	 * would be 5).
+	 * Signed means that the outside pixels have a negative sign.
+	 */
+	class IDT {
+		int[] result;
+
+		IDT() {
+			result = new int[w * h];
+			int infinity = (w + h) * 9;
+
+			for (int i = 0; i < result.length; i++)
+				result[i] = infinity;
+		}
+
+		int init(byte[] p) {
+			int count = 0;
+
+			for (int j = 0; j < h; j++)
+				for (int i = 0; i < w; i++) {
+					int idx = i + w * j;
+					if (isBoundary(p, i, j)) {
+						result[idx] = 0;
+						count++;
+					} else if (isJustOutside(p, i, j))
+						result[idx] = -1;
+				}
+			return count;
+		}
+
+		final void idt(int x, int y, int dx, int dy) {
+			if (x + dx < 0 || y + dy < 0 ||
+					x + dx >= w || y + dy >= h)
+				return;
+			int value = result[x + dx + w * (y + dy)];
+			int distance = (dx == 0 || dy == 0 ? 3 : 4);
+			value += distance * (value < 0 ? -1 : 1);
+			if (Math.abs(result[x + w * y]) > Math.abs(value))
+				result[x + w * y] = value;
+		}
+
+		void propagate() {
+			for (int j = 0; j < h; j++)
+				for (int i = 0; i < w; i++) {
+					idt(i, j, -1, 0);
+					idt(i, j, -1, -1);
+					idt(i, j, 0, -1);
+				}
+
+			for (int j = h - 1; j >= 0; j--)
+				for (int i = w - 1; i >= 0; i--) {
+					idt(i, j, +1, 0);
+					idt(i, j, +1, +1);
+					idt(i, j, 0, +1);
+				}
+
+			for (int i = w - 1; i >= 0; i--)
+				for (int j = h - 1; j >= 0; j--) {
+					idt(i, j, +1, 0);
+					idt(i, j, +1, +1);
+					idt(i, j, 0, +1);
+				}
+
+			for (int i = 0; i < w; i++)
+				for (int j = 0; j < h; j++) {
+					idt(i, j, -1, 0);
+					idt(i, j, -1, -1);
+					idt(i, j, 0, -1);
+				}
+		}
+	}
+
+	int[] getIDT(Object pixels) {
+		IDT idt = new IDT();
+		if (idt.init((byte[])pixels) == 0)
+			return null;
+		idt.propagate();
+		return idt.result;
+	}
+
+	final boolean isBoundary(byte[] pixels, int x, int y) {
+		if (pixels[x + w * y] == 0)
+			return false;
+		if (x <= 0 || pixels[x - 1 + w * y] == 0)
+			return true;
+		if (x >= w - 1 || pixels[x + 1 + w * y] == 0)
+			return true;
+		if (y <= 0 || pixels[x + w * (y - 1)] == 0)
+			return true;
+		if (y >= h - 1 || pixels[x + w * (y + 1)] == 0)
+			return true;
+		if (x <= 0 || y <= 0 || pixels[x - 1 + w * (y - 1)] == 0)
+			return true;
+		if (x <= 0 || y >= h - 1 || pixels[x - 1 + w * (y + 1)] == 0)
+			return true;
+		if (x >= w - 1 || y <= 0 || pixels[x + 1 + w * (y - 1)] == 0)
+			return true;
+		if (x >= w - 1 || y >= h - 1 ||
+				pixels[x + 1 + w * (y + 1)] == 0)
+			return true;
+		return false;
+	}
+
+	final boolean isJustOutside(byte[] pixels, int x, int y) {
+		if (pixels[x + w * y] != 0)
+			return false;
+		if (x > 0 && pixels[x - 1 + w * y] != 0)
+			return true;
+		if (x < w - 1 && pixels[x + 1 + w * y] != 0)
+			return true;
+		if (y > 0 && pixels[x + w * (y - 1)] != 0)
+			return true;
+		if (y < h - 1 && pixels[x + w * (y + 1)] != 0)
+			return true;
+		if (x > 0 && y > 0 && pixels[x - 1 + w * (y - 1)] != 0)
+			return true;
+		if (x > 0 && y < h - 1 && pixels[x - 1 + w * (y + 1)] != 0)
+			return true;
+		if (x < w - 1 && y > 0 && pixels[x + 1 + w * (y - 1)] != 0)
+			return true;
+		if (x < w - 1 && y < h - 1 &&
+				pixels[x + 1 + w * (y + 1)] != 0)
+			return true;
+		return false;
+	}
+}
diff --git a/src/ij/process/BinaryProcessor.java b/src/ij/process/BinaryProcessor.java
new file mode 100644
index 0000000..3277096
--- /dev/null
+++ b/src/ij/process/BinaryProcessor.java
@@ -0,0 +1,256 @@
+package ij.process;
+import java.awt.*;
+
+/** This class processes binary images. */
+public class BinaryProcessor extends ByteProcessor {
+
+	private ByteProcessor parent;
+	private int foreground;
+	
+	/** Creates a BinaryProcessor from a ByteProcessor. The ByteProcessor
+		must contain a binary image (pixels values are either 0 or 255).
+		Backgound is assumed to be white. */
+	public BinaryProcessor(ByteProcessor ip) {
+		super(ip.getWidth(), ip.getHeight(), (byte[])ip.getPixels(), ip.getColorModel());
+		setRoi(ip.getRoi());
+		parent = ip;
+	}
+
+	static final int OUTLINE=0;
+	
+	void process(int type, int count) {
+		int p1, p2, p3, p4, p5, p6, p7, p8, p9;
+		int bgColor = 255;
+		if (parent.isInvertedLut())
+			bgColor = 0;
+
+		byte[] pixels2 = (byte[])parent.getPixelsCopy();
+		int offset, v=0, sum;
+        int rowOffset = width;
+		for (int y=yMin; y<=yMax; y++) {
+			offset = xMin + y * width;
+			p2 = pixels2[offset-rowOffset-1]&0xff;
+			p3 = pixels2[offset-rowOffset]&0xff;
+			p5 = pixels2[offset-1]&0xff;
+			p6 = pixels2[offset]&0xff;
+			p8 = pixels2[offset+rowOffset-1]&0xff;
+			p9 = pixels2[offset+rowOffset]&0xff;
+
+			for (int x=xMin; x<=xMax; x++) {
+				p1 = p2; p2 = p3;
+				p3 = pixels2[offset-rowOffset+1]&0xff;
+				p4 = p5; p5 = p6;
+				p6 = pixels2[offset+1]&0xff;
+				p7 = p8; p8 = p9;
+				p9 = pixels2[offset+rowOffset+1]&0xff;
+
+				switch (type) {
+					case OUTLINE:
+						v = p5;
+						if (v!=bgColor) {
+							if (!(p1==bgColor || p2==bgColor || p3==bgColor || p4==bgColor
+								|| p6==bgColor || p7==bgColor || p8==bgColor || p9==bgColor))
+									v = bgColor;
+						}
+						break;
+				}
+				
+				pixels[offset++] = (byte)v;
+			}
+		}
+	}
+
+	// 2012/09/16: 3,0 1->0
+	// 2012/09/16: 24,0 2->0
+	private static int[] table  =
+		//0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1
+		 {0,0,0,0,0,0,1,3,0,0,3,1,1,0,1,3,0,0,0,0,0,0,0,0,0,0,2,0,3,0,3,3,
+		  0,0,0,0,0,0,0,0,3,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,3,0,2,2,
+		  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		  2,0,0,0,0,0,0,0,2,0,0,0,2,0,0,0,3,0,0,0,0,0,0,0,3,0,0,0,3,0,2,0,
+		  0,0,3,1,0,0,1,3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+		  3,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		  2,3,1,3,0,0,1,3,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		  2,3,0,1,0,0,0,1,0,0,0,0,0,0,0,0,3,3,0,1,0,0,0,0,2,2,0,0,2,0,0,0};
+		  
+	// 2013/12/02: 16,6 2->0
+	// 2013/12/02: 24,5 0->2
+	private static int[] table2  =
+		  //0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1
+		 {0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2,2,0,0,0,0,
+		  0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,2,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,
+		  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		  0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,
+		  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,
+		  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+		  0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+
+
+	/** Converts objects in a binary image with pixel values of
+		'forground' (255 or 0) to single pixel skeletons.
+		Uses a lookup table to repeatably removes pixels from the
+		edges of objects in a binary image, reducing them to single
+		pixel wide skeletons. There is an entry in the table for each
+		of the 256 possible 3x3 neighborhood configurations. An entry
+		of '1' means delete pixel on first pass, '2' means delete pixel on
+		second pass, and '3' means delete on either pass. Pixels are
+		removed from the right and bottom edges of objects on the first
+		pass and from the left and top edges on the second pass. A
+		graphical representation of the 256 neighborhoods indexed by
+		the table is available at
+		"http://imagej.nih.gov/ij/images/skeletonize-table.gif".
+	*/
+	public void skeletonize(int foreground) {
+		if (!(foreground==255||foreground==0))
+			throw new IllegalArgumentException("Skeletonize: foreground must be 255 or 0");
+		this.foreground = foreground;
+		boolean edgePixels = hasEdgePixels();
+		BinaryProcessor ip2 = expand(edgePixels);
+		ip2.skeletonize2(foreground);
+		shrink(ip2, edgePixels);
+	}
+
+	/** Converts black objects in a binary image to single pixel skeletons. */
+	 public void skeletonize() {
+		int fg = parent.isInvertedLut()?255:0;
+	 	skeletonize(fg);
+    }
+
+	private void  skeletonize2(int foreground) {
+	 	this.foreground = foreground;
+		int pass = 0;
+		int pixelsRemoved;
+		resetRoi();
+		int background = 255 - foreground;
+		setColor(background);
+		moveTo(0,0); lineTo(0,height-1);
+		moveTo(0,0); lineTo(width-1,0);
+		moveTo(width-1,0); lineTo(width-1,height-1);
+		moveTo(0,height-1); lineTo(width/*-1*/,height-1);
+		ij.ImageStack movie=null;
+		boolean debug = ij.IJ.debugMode;
+		if (debug) movie = new ij.ImageStack(width, height);
+		if (debug) movie.addSlice("-", duplicate());
+		do {
+			snapshot();
+			pixelsRemoved = thin(pass++, table);
+			if (debug) movie.addSlice(""+(pass-1), duplicate());
+			snapshot();
+			pixelsRemoved += thin(pass++, table);
+			if (debug) movie.addSlice(""+(pass-1), duplicate());
+		} while (pixelsRemoved>0);
+		do { // use a second table to remove "stuck" pixels
+			snapshot();
+			pixelsRemoved = thin(pass++, table2);
+			if (debug) movie.addSlice("2-"+(pass-1), duplicate());
+			snapshot();
+			pixelsRemoved += thin(pass++, table2);
+			if (debug) movie.addSlice("2-"+(pass-1), duplicate());
+		} while (pixelsRemoved>0);
+		if (debug) new ij.ImagePlus("Skel Movie", movie).show();
+	}
+
+    private boolean hasEdgePixels() {
+        int width = getWidth();
+        int height = getHeight();
+        boolean edgePixels = false;
+        for (int x=0; x<width; x++) { // top edge
+            if (getPixel(x, 0)==foreground)
+                edgePixels = true;
+        }
+        for (int x=0; x<width; x++) { // bottom edge
+            if (getPixel(x, height-1)==foreground)
+                edgePixels = true;
+        }
+        for (int y=0; y<height; y++) { // left edge
+            if (getPixel(0, y)==foreground)
+                edgePixels = true;
+        }
+        for (int y=0; y<height; y++) { // right edge
+            if (getPixel(width-1, y)==foreground)
+                edgePixels = true;
+        }
+        return edgePixels;
+    }
+    
+    private BinaryProcessor expand(boolean hasEdgePixels) {
+        if (hasEdgePixels) {
+            ByteProcessor ip2 = (ByteProcessor)createProcessor(getWidth()+2, getHeight()+2);
+            BinaryProcessor bp = new BinaryProcessor(ip2);
+            if (foreground==0) {
+                bp.setColor(255);
+                bp.fill();
+            }
+            bp.insert(this, 1, 1);
+            //new ImagePlus("ip2", ip2).show();
+            return bp;
+        } else
+            return this;
+    }
+
+    private void shrink(ImageProcessor ip2, boolean hasEdgePixels) {
+        if (hasEdgePixels) {
+            int width = getWidth();
+            int height = getHeight();
+            for (int y=0; y<height; y++)
+                for (int x=0; x<width; x++)
+                    putPixel(x, y, ip2.getPixel(x+1, y+1));
+        }
+    }
+
+	int thin(int pass, int[] table) {
+		int bgColor = foreground==255?0:-1;
+		int p1, p2, p3, p4, p5, p6, p7, p8, p9;
+		byte[] pixels2 = (byte[])getPixelsCopy();
+		int v, index, code;
+        int offset, rowOffset = width;
+        int pixelsRemoved = 0;
+        int count = 100;
+		for (int y=yMin; y<=yMax; y++) {
+			offset = xMin + y * width;
+			for (int x=xMin; x<=xMax; x++) {
+				p5 = pixels2[offset];
+				v = p5;
+				if (v!=bgColor) {
+					p1 = pixels2[offset-rowOffset-1];
+					p2 = pixels2[offset-rowOffset];
+					p3 = pixels2[offset-rowOffset+1];
+					p4 = pixels2[offset-1];
+					p6 = pixels2[offset+1];
+					p7 = pixels2[offset+rowOffset-1];
+					p8 = pixels2[offset+rowOffset];
+					p9 = pixels2[offset+rowOffset+1];
+					index = 0;
+					if (p1!=bgColor) index |= 1;
+					if (p2!=bgColor) index |= 2;
+					if (p3!=bgColor) index |= 4;
+					if (p6!=bgColor) index |= 8;
+					if (p9!=bgColor) index |= 16;
+					if (p8!=bgColor) index |= 32;
+					if (p7!=bgColor) index |= 64;
+					if (p4!=bgColor) index |= 128;
+					code = table[index];
+					if ((pass&1)==1) { //odd pass
+						if (code==2||code==3) {
+							v = bgColor;
+							pixelsRemoved++;
+						}
+					} else { //even pass
+						if (code==1||code==3) {
+							v = bgColor;
+							pixelsRemoved++;
+						}
+					}
+				}
+				pixels[offset++] = (byte)v;
+			}
+		}
+		return pixelsRemoved;
+	}
+	
+	public void outline() {
+		process(OUTLINE, 0);
+	}
+	
+}
diff --git a/src/ij/process/Blitter.java b/src/ij/process/Blitter.java
new file mode 100644
index 0000000..1f13978
--- /dev/null
+++ b/src/ij/process/Blitter.java
@@ -0,0 +1,60 @@
+package ij.process;
+import java.awt.Color;
+
+/** ImageJ bit blitting classes must implement this interface. */
+public interface Blitter {
+
+	/** dst=src */
+	public static final int COPY = 0;
+	
+	/** dst=255-src (8-bits and RGB) */
+	public static final int COPY_INVERTED = 1;
+	
+	/** Copies with white pixels transparent. */
+	public static final int COPY_TRANSPARENT = 2;
+	
+	/** dst=dst+src */
+	public static final int ADD = 3;
+	
+	/** dst=dst-src */
+	public static final int SUBTRACT = 4;
+		
+	/** dst=src*src */
+	public static final int MULTIPLY = 5;
+	
+	/** dst=dst/src */
+	public static final int DIVIDE = 6;
+	
+	/** dst=(dst+src)/2 */
+	public static final int AVERAGE = 7;
+	
+	/** dst=abs(dst-src) */
+	public static final int DIFFERENCE = 8;
+	
+	/** dst=dst AND src */
+	public static final int AND = 9;
+	
+	/** dst=dst OR src */
+	public static final int OR = 10;
+	
+	/** dst=dst XOR src */
+	public static final int XOR = 11;
+	
+	/** dst=min(dst,src) */
+	public static final int MIN = 12;
+	
+	/** dst=max(dst,src) */
+	public static final int MAX = 13;
+	
+	/** Copies with zero pixels transparent. */
+	public static final int COPY_ZERO_TRANSPARENT = 14;
+
+
+	/** Sets the transparent color used in the COPY_TRANSPARENT
+		mode (default is Color.white). */
+	public void setTransparentColor(Color c);
+
+	/** Copies the image in 'src' to (x,y) using the specified mode. */
+	public void copyBits(ImageProcessor src, int x, int y, int mode);
+
+}
diff --git a/src/ij/process/ByteBlitter.java b/src/ij/process/ByteBlitter.java
new file mode 100644
index 0000000..a461d18
--- /dev/null
+++ b/src/ij/process/ByteBlitter.java
@@ -0,0 +1,169 @@
+package ij.process;
+import java.awt.*;
+
+/** This class does bit blitting of byte images. */
+public class ByteBlitter implements Blitter {
+
+	private ByteProcessor ip;
+	private int width, height;
+	private byte[] pixels;
+	private int transparent = 255;
+	
+	/** Constructs a ByteBlitter from a ByteProcessor. */
+	public ByteBlitter(ByteProcessor ip) {
+		this.ip = ip;
+		width = ip.getWidth();
+		height = ip.getHeight();
+		pixels = (byte[])ip.getPixels();
+	}
+
+	public void setTransparentColor(Color c) {
+		transparent = ip.getBestIndex(c);
+	}
+	
+	/** Copies the byte image in 'ip' to (x,y) using the specified mode. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		Rectangle r1, r2;
+		int srcIndex, dstIndex;
+		int xSrcBase, ySrcBase;
+		byte[] srcPixels;
+		
+		int srcWidth = ip.getWidth();
+		int srcHeight = ip.getHeight();
+		r1 = new Rectangle(srcWidth, srcHeight);
+		r1.setLocation(xloc, yloc);
+		r2 = new Rectangle(width, height);
+		if (!r1.intersects(r2))
+			return;
+		if (ip instanceof ColorProcessor) {
+			int[] pixels32 = (int[])ip.getPixels();
+			int size = ip.getWidth()*ip.getHeight();
+			srcPixels = new byte[size];
+			if (this.ip.isInvertedLut())
+				for (int i=0; i<size; i++)
+					srcPixels[i] = (byte)(255-pixels32[i]&255);
+			else 
+				for (int i=0; i<size; i++)
+					srcPixels[i] = (byte)(pixels32[i]&255);
+		} else {
+			ip = ip.convertToByte(true);
+			srcPixels = (byte [])ip.getPixels();
+		}
+		r1 = r1.intersection(r2);
+		xSrcBase = (xloc<0)?-xloc:0;
+		ySrcBase = (yloc<0)?-yloc:0;
+		int src, dst;
+		for (int y=r1.y; y<(r1.y+r1.height); y++) {
+			srcIndex = (y-yloc)*srcWidth + (r1.x-xloc);
+			dstIndex = y * width + r1.x;
+			switch (mode) {
+				case COPY:
+					for (int i=r1.width; --i>=0;)
+						pixels[dstIndex++] = srcPixels[srcIndex++];
+					break;
+				case COPY_INVERTED:
+					for (int i=r1.width; --i>=0;)
+						pixels[dstIndex++] = (byte)(255-srcPixels[srcIndex++]&255);
+					break;
+				case COPY_TRANSPARENT:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&255;
+						if (src==transparent)
+							dst = pixels[dstIndex];
+						else
+							dst = src;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case COPY_ZERO_TRANSPARENT:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&255;
+						if (src==0)
+							dst = pixels[dstIndex];
+						else
+							dst = src;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case ADD:
+					for (int i=r1.width; --i>=0;) {
+						dst = (srcPixels[srcIndex++]&255)+(pixels[dstIndex]&255);
+						if (dst>255) dst = 255;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case AVERAGE:
+					for (int i=r1.width; --i>=0;) {
+						dst = ((srcPixels[srcIndex++]&255)+(pixels[dstIndex]&255))/2;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case SUBTRACT:
+					for (int i=r1.width; --i>=0;) {
+						dst = (pixels[dstIndex]&255)-(srcPixels[srcIndex++]&255);
+						if (dst<0) dst = 0;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case DIFFERENCE:
+					for (int i=r1.width; --i>=0;) {
+						dst = (pixels[dstIndex]&255)-(srcPixels[srcIndex++]&255);
+						if (dst<0) dst = -dst;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case MULTIPLY:
+					for (int i=r1.width; --i>=0;) {
+						dst = (srcPixels[srcIndex++]&255)*(pixels[dstIndex]&255);
+						if (dst>255) dst = 255;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case DIVIDE:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&255;
+						if (src==0)
+							dst = 255;
+						else
+							dst = (pixels[dstIndex]&255)/src;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case AND:
+					for (int i=r1.width; --i>=0;) {
+						dst = srcPixels[srcIndex++]&pixels[dstIndex];
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case OR:
+					for (int i=r1.width; --i>=0;) {
+						dst = srcPixels[srcIndex++]|pixels[dstIndex];
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case XOR:
+					for (int i=r1.width; --i>=0;) {
+						dst = srcPixels[srcIndex++]^pixels[dstIndex];
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case MIN:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&255;
+						dst = pixels[dstIndex]&255;
+						if (src<dst) dst = src;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+				case MAX:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&255;
+						dst = pixels[dstIndex]&255;
+						if (src>dst) dst = src;
+						pixels[dstIndex++] = (byte)dst;
+					}
+					break;
+			}
+		}
+	}
+}
diff --git a/src/ij/process/ByteProcessor.java b/src/ij/process/ByteProcessor.java
new file mode 100644
index 0000000..54b75b0
--- /dev/null
+++ b/src/ij/process/ByteProcessor.java
@@ -0,0 +1,1302 @@
+package ij.process;
+
+import java.util.*;
+import java.awt.*;
+import java.awt.image.*;
+import ij.gui.*;
+import ij.Prefs;
+
+/**
+This is an 8-bit image and methods that operate on that image. Based on the ImageProcessor class
+from "KickAss Java Programming" by Tonny Espeset.
+*/
+public class ByteProcessor extends ImageProcessor {
+
+	static final int ERODE=10, DILATE=11;
+	protected byte[] pixels;
+	protected byte[] snapshotPixels;
+	private int bgColor = 255; //white
+	private boolean bgColorSet;
+	private int min=0, max=255;
+    private int binaryCount, binaryBackground;
+
+	/**Creates a ByteProcessor from an AWT Image. */
+	public ByteProcessor(Image img) {
+		width = img.getWidth(null);
+		height = img.getHeight(null);
+		resetRoi();
+		pixels = new byte[width * height];
+		PixelGrabber pg = new PixelGrabber(img, 0, 0, width, height, false);
+		try {
+			pg.grabPixels();
+		} catch (InterruptedException e) {
+			System.err.println(e);
+		};
+   		cm = pg.getColorModel();
+		if (cm instanceof IndexColorModel)
+			pixels = (byte[])(pg.getPixels());
+		if ((cm instanceof IndexColorModel) && ((IndexColorModel)cm).getTransparentPixel()!=-1) {
+			IndexColorModel icm = (IndexColorModel)cm;
+			int mapSize = icm.getMapSize();
+			byte[] reds = new byte[mapSize];
+			byte[] greens = new byte[mapSize];
+			byte[] blues = new byte[mapSize];	
+			icm.getReds(reds); 
+			icm.getGreens(greens); 
+			icm.getBlues(blues);
+			cm = new IndexColorModel(8, mapSize, reds, greens, blues);
+		}
+	}
+
+	/**Creates a blank ByteProcessor of the specified dimensions. */
+	public ByteProcessor(int width, int height) {
+		this(width, height, new byte[width*height], null);
+	}
+
+	/**Creates a ByteProcessor from a byte array. */
+	public ByteProcessor(int width, int height, byte[] pixels) {
+		this(width, height, pixels, null);
+	}
+
+	/**Creates a ByteProcessor from a pixel array and IndexColorModel. */
+	public ByteProcessor(int width, int height, byte[] pixels, ColorModel cm) {
+		if (pixels!=null && width*height!=pixels.length)
+			throw new IllegalArgumentException(WRONG_LENGTH);
+		this.width = width;
+		this.height = height;
+		resetRoi();
+		this.pixels = pixels;
+		this.cm = cm;
+	}
+
+	/** Creates a ByteProcessor from a TYPE_BYTE_GRAY BufferedImage. */
+	public ByteProcessor(BufferedImage bi) {
+		if (bi.getType()!=BufferedImage.TYPE_BYTE_GRAY)
+			throw new IllegalArgumentException("Type!=TYPE_BYTE_GRAYY");
+		WritableRaster raster = bi.getRaster();
+		DataBuffer buffer = raster.getDataBuffer();
+		pixels = ((DataBufferByte) buffer).getData();
+		width = raster.getWidth();
+		height = raster.getHeight();
+		resetRoi();
+	}
+
+	/** Creates a ByteProcessor from an ImageProcessor. 16-bit and 32-bit
+	 * pixel data are scaled from min-max to 0-255 if 'scale' is true.
+	 * @see ImageProcessor#convertToByteProcessor
+	 * @see ImageProcessor#convertToShortProcessor
+	 * @see ImageProcessor#convertToFloatProcessor
+	 * @see ImageProcessor#convertToColorProcessor
+	*/
+	public ByteProcessor(ImageProcessor ip, boolean scale) {
+		ImageProcessor bp;
+		if (ip instanceof ByteProcessor)
+			bp = ip.duplicate();
+		else
+			bp = ip.convertToByte(scale);
+		this.width = bp.getWidth();
+		this.height = bp.getHeight();
+		resetRoi();
+		this.pixels = (byte[])bp.getPixels();
+		this.cm = bp.getCurrentColorModel();
+	}
+
+	public Image createImage() {
+		if (cm==null)
+			cm = getDefaultColorModel();
+		return createBufferedImage();
+	}
+
+	Image createBufferedImage() {
+		if (raster==null) {
+			SampleModel sm = getIndexSampleModel();
+			DataBuffer db = new DataBufferByte(pixels, width*height, 0);
+			raster = Raster.createWritableRaster(sm, db, null);
+		}
+		if (image==null || cm!=cm2) {
+			if (cm==null) cm=getDefaultColorModel();
+			image = new BufferedImage(cm, raster, false, null);
+			cm2 = cm;
+		}
+		return image;
+	}
+	
+	/** Returns this image as a BufferedImage. */
+	public BufferedImage getBufferedImage() {
+		if (isDefaultLut()) {
+			BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_GRAY);
+			Graphics g = bi.createGraphics();
+			g.drawImage(createImage(), 0, 0, null);
+			return bi;
+		} else
+			return (BufferedImage)createBufferedImage();
+	}
+
+	/** Returns a new, blank ByteProcessor with the specified width and height. */
+	public ImageProcessor createProcessor(int width, int height) {
+		ImageProcessor ip2;
+		ip2 =  new ByteProcessor(width, height, new byte[width*height], getColorModel());
+		if (baseCM!=null)
+			ip2.setMinAndMax(min, max);
+		ip2.setInterpolationMethod(interpolationMethod);
+		return ip2;
+	}
+
+	public ImageProcessor crop() {
+		ImageProcessor ip2 = createProcessor(roiWidth, roiHeight);
+		byte[] pixels2 = (byte[])ip2.getPixels();
+		for (int ys=roiY; ys<roiY+roiHeight; ys++) {
+			int offset1 = (ys-roiY)*roiWidth;
+			int offset2 = ys*width+roiX;
+			for (int xs=0; xs<roiWidth; xs++)
+				pixels2[offset1++] = pixels[offset2++];
+		}
+        return ip2;
+	}
+	
+	/** Returns a duplicate of this image. */ 
+	public ImageProcessor duplicate() { 
+		ImageProcessor ip2 = createProcessor(width, height); 
+		byte[] pixels2 = (byte[])ip2.getPixels(); 
+		System.arraycopy(pixels, 0, pixels2, 0, width*height); 
+		return ip2; 
+	} 
+
+	/**Make a snapshot of the current image.*/
+	public void snapshot() {
+		snapshotWidth=width;
+		snapshotHeight=height;
+		if (snapshotPixels==null || (snapshotPixels!=null && snapshotPixels.length!=pixels.length))
+			snapshotPixels = new byte[width * height];
+		System.arraycopy(pixels, 0, snapshotPixels, 0, width*height);
+	}
+	
+	/** Reset the image from snapshot.*/
+	public void reset() {
+		if (snapshotPixels!=null)
+			System.arraycopy(snapshotPixels,0,pixels,0,width*height);
+	}
+	
+	/** Swaps the pixel and snapshot (undo) arrays. */
+	public void swapPixelArrays() {
+		if (snapshotPixels==null) return;	
+		byte pixel;
+		for (int i=0; i<pixels.length; i++) {
+			pixel = pixels[i];
+			pixels[i] = snapshotPixels[i];
+			snapshotPixels[i] = pixel;
+		}
+	}
+
+	/** Restore pixels that are within roi but not part of mask. */
+	public void reset(ImageProcessor mask) {
+		if (mask==null || snapshotPixels==null)
+			return;	
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]==0)
+					pixels[i] = snapshotPixels[i];
+				i++;
+			}
+		}
+	}
+
+	public void setSnapshotPixels(Object pixels) {
+		snapshotPixels = (byte[])pixels;
+		snapshotWidth=width;
+		snapshotHeight=height;
+	}
+
+	public Object getSnapshotPixels() {
+		return snapshotPixels;
+	}
+
+	/** Sets pixels that are within roi and part of the mask to the foreground
+		color. Does nothing if the mask is not the same size as the ROI. */
+	public void fill(ImageProcessor mask) {
+		if (mask==null)
+			{fill(); return;}
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		int roiX=this.roiX, roiY=this.roiY;
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight) {
+			mask = getMask();
+			if (mask==null||mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+				return;
+		}
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]!=0)
+					pixels[i] = (byte)fgColor;
+				i++;
+			}
+		}
+	}
+
+	public int getPixel(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			return pixels[y*width+x]&0xff;
+		else
+			return 0;
+	}
+	
+	public final int get(int x, int y) {
+		return pixels[y*width+x]&0xff;
+	}
+	
+	public final void set(int x, int y, int value) {
+		pixels[y*width+x] = (byte)value;
+	}
+	
+	public final int get(int index) {
+		return pixels[index]&0xff;
+	}
+	
+	public final void set(int index, int value) {
+		pixels[index] = (byte)value;
+	}
+	
+	public final float getf(int x, int y) {
+		return pixels[y*width+x]&0xff;
+	}
+	
+	public final void setf(int x, int y, float value) {
+		pixels[y*width+x] = (byte)(value+0.5f);
+	}
+	
+	public final float getf(int index) {
+		return pixels[index]&0xff;
+	}
+	
+	public final void setf(int index, float value) {
+		pixels[index] = (byte)value;
+	}
+
+	static double oldx, oldy;
+
+	/** Uses the current interpolation method (BILINEAR or BICUBIC) 
+		to calculate the pixel value at real coordinates (x,y). */
+	public double getInterpolatedPixel(double x, double y) {
+		if (interpolationMethod==BICUBIC)
+			return getBicubicInterpolatedPixel(x, y, this);
+		else {
+			if (x<0.0) x = 0.0;
+			if (x>=width-1.0) x = width-1.001;
+			if (y<0.0) y = 0.0;
+			if (y>=height-1.0) y = height-1.001;
+			return getInterpolatedPixel(x, y, pixels);
+		}
+	}
+
+	final public int getPixelInterpolated(double x, double y) {
+		if (interpolationMethod==BILINEAR) {
+			if (x<0.0 || y<0.0 || x>=width-1 || y>=height-1)
+				return 0;
+			else
+				return (int)Math.round(getInterpolatedPixel(x, y, pixels));
+		} else if (interpolationMethod==BICUBIC) {
+			int value = (int)(getBicubicInterpolatedPixel(x, y, this)+0.5);
+			if (value<0) value = 0;
+			if (value>255) value = 255;
+			return value;
+		} else
+			return getPixel((int)(x+0.5), (int)(y+0.5));
+	}
+	
+ 	public float getPixelValue(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			if (cTable==null)
+				return pixels[y*width + x]&0xff;
+			else
+				return cTable[pixels[y*width + x]&0xff];
+		} else
+			return Float.NaN;
+	}
+
+	/** Sets the foreground drawing color. */
+	public void setColor(Color color) {
+		drawingColor = color;
+		fgColor = getBestIndex(color);
+		fillValueSet = true;
+	}
+
+	/** Sets the default fill/draw value, where 0<=value<=255. */
+	public void setValue(double value) {
+		fgColor = (int)value;
+		if (fgColor<0) fgColor = 0;
+		if (fgColor>255) fgColor = 255;
+		fillValueSet = true;
+	}
+
+	/** Returns the foreground fill/draw value. */
+	public double getForegroundValue() {
+		return fgColor;
+	}
+
+	/** Sets the background fill value, where 0<=value<=255. */
+	public void setBackgroundValue(double value) {
+		bgColor = (int)value;
+		if (bgColor<0) bgColor = 0;
+		if (bgColor>255) bgColor = 255;
+		bgColorSet = true;
+	}
+
+	/** Returns the background fill value. */
+	public double getBackgroundValue() {
+		return bgColor;
+	}
+
+	/** Stores the specified real value at (x,y). Does
+		nothing if (x,y) is outside the image boundary.
+		Values outside the range 0-255 are clamped. */
+	public void putPixelValue(int x, int y, double value) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			if (value>255.0)
+				value = 255.0;
+			else if (value<0.0)
+				value = 0.0;
+			pixels[y*width + x] = (byte)(value+0.5);
+		}
+	}
+
+	/** Stores the specified value at (x,y). Does
+		nothing if (x,y) is outside the image boundary.
+		Values outside the range 0-255 are clamped. */
+	public final void putPixel(int x, int y, int value) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			if (value>255) value = 255;
+			if (value<0) value = 0;
+			pixels[y*width + x] = (byte)value;
+		}
+	}
+
+	/** Draws a pixel in the current foreground color. */
+	public void drawPixel(int x, int y) {
+		if (x>=clipXMin && x<=clipXMax && y>=clipYMin && y<=clipYMax)
+			pixels[y*width + x] = (byte)fgColor;
+	}
+
+	/**	Returns a reference to the byte array containing this image's
+		pixel data. To avoid sign extension, the pixel values must be
+		accessed using a mask (e.g. int i = pixels[j]&0xff). */
+	public Object getPixels() {
+		return (Object)pixels;
+	}
+
+	/** Returns a copy of the pixel data. Or returns a reference to the
+		snapshot buffer if it is not null and 'snapshotCopyMode' is true.
+		@see ImageProcessor#snapshot
+		@see ImageProcessor#setSnapshotCopyMode
+	*/
+	public Object getPixelsCopy() {
+		if (snapshotPixels!=null && snapshotCopyMode) {
+			snapshotCopyMode = false;
+			return snapshotPixels;
+		} else {
+			byte[] pixels2 = new byte[width*height];
+        	System.arraycopy(pixels, 0, pixels2, 0, width*height);
+			return pixels2;
+		}
+	}
+
+	public void setPixels(Object pixels) {
+		if (pixels!=null && this.pixels!=null && (((byte[])pixels).length!=this.pixels.length))
+			throw new IllegalArgumentException("");
+		this.pixels = (byte[])pixels;
+		resetPixels(pixels);
+		if (pixels==null) snapshotPixels = null;
+		raster = null;
+		image = null;
+	}
+	
+	/** Returns the smallest displayed pixel value. */
+	public double getMin() {
+		return min;
+	}
+
+	/** Returns the largest displayed pixel value. */
+	public double getMax() {
+		return max;
+	}
+
+	/** Maps the entries in this image's LUT from min-max to 0-255. */
+	public void setMinAndMax(double min, double max) {
+		if (max<min)
+			return;
+		this.min = (int)Math.round(min);
+		this.max = (int)Math.round(max);
+		if (rLUT1==null) {
+			if (cm==null)
+				makeDefaultColorModel();
+			baseCM = cm;
+			IndexColorModel m = (IndexColorModel)cm;
+			rLUT1 = new byte[256]; gLUT1 = new byte[256]; bLUT1 = new byte[256];
+			m.getReds(rLUT1); m.getGreens(gLUT1); m.getBlues(bLUT1); 
+			rLUT2 = new byte[256]; gLUT2 = new byte[256]; bLUT2 = new byte[256];
+		}
+		if (rLUT2==null)
+			return;
+		int index;
+		for (int i=0; i<256; i++) {
+			if (i<min) {
+				rLUT2[i] = rLUT1[0];
+				gLUT2[i] = gLUT1[0];
+				bLUT2[i] = bLUT1[0];
+			} else if (i>max) {
+				rLUT2[i] = rLUT1[255];
+				gLUT2[i] = gLUT1[255];
+				bLUT2[i] = bLUT1[255];
+			} else {
+				index = i-this.min;
+				index = (int)(256.0*index/(max-min));
+				if (index < 0)
+					index = 0;
+				if (index > 255)
+					index = 255;
+				rLUT2[i] = rLUT1[index];
+				gLUT2[i] = gLUT1[index];
+				bLUT2[i] = bLUT1[index];
+			}
+		}
+		cm = new IndexColorModel(8, 256, rLUT2, gLUT2, bLUT2);
+		minThreshold = NO_THRESHOLD;
+	}
+
+	/** Resets this image's LUT. */
+	public void resetMinAndMax() {
+		setMinAndMax(0, 255);
+	}
+
+	public void setThreshold(double minThreshold, double maxThreshold, int lutUpdate) {
+		super.setThreshold(minThreshold, maxThreshold, lutUpdate);
+		if (this.minThreshold<0.0 && this.minThreshold!=NO_THRESHOLD)
+			this.minThreshold = 0.0;
+		if (this.maxThreshold>255.0)
+			this.maxThreshold = 255.0;
+	}
+
+	/** Copies the image contained in 'ip' to (xloc, yloc) using one of
+		the transfer modes defined in the Blitter interface. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		boolean temporaryFloat = ip.getBitDepth()==32 && (mode==Blitter.MULTIPLY || mode==Blitter.DIVIDE);
+		if (temporaryFloat) {
+			FloatProcessor ipFloat = this.convertToFloatProcessor();
+			new FloatBlitter(ipFloat).copyBits(ip, xloc, yloc, mode);
+			setPixels(1, ipFloat);
+		} else {
+			ip = ip.convertToByte(true);
+			new ByteBlitter(this).copyBits(ip, xloc, yloc, mode);
+		}
+	}
+
+	/* Filters start here */
+
+	public void applyTable(int[] lut) {
+		int lineStart, lineEnd;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			lineStart = y * width + roiX;
+			lineEnd = lineStart + roiWidth;
+			for (int i=lineEnd; --i>=lineStart;)
+				pixels[i] = (byte)lut[pixels[i]&0xff];
+		}
+	}
+
+    public void convolve3x3(int[] kernel) {
+        int v1, v2, v3;    //input pixel values around the current pixel
+        int v4, v5, v6;
+        int v7, v8, v9;
+        int scale = 0;
+		int k1=kernel[0], k2=kernel[1], k3=kernel[2],
+		k4=kernel[3], k5=kernel[4], k6=kernel[5],
+		k7=kernel[6], k8=kernel[7], k9=kernel[8];
+		for (int i=0; i<kernel.length; i++)
+			scale += kernel[i];
+		if (scale==0) scale = 1;
+        byte[] pixels2 = (byte[])getPixelsCopy();
+        int xEnd = roiX + roiWidth;
+        int yEnd = roiY + roiHeight;
+        for (int y=roiY; y<yEnd; y++) {
+            int p  = roiX + y*width;            //points to current pixel
+            int p6 = p - (roiX>0 ? 1 : 0);      //will point to v6, currently lower
+            int p3 = p6 - (y>0 ? width : 0);    //will point to v3, currently lower
+            int p9 = p6 + (y<height-1 ? width : 0); // ...  to v9, currently lower
+            v2 = pixels2[p3]&0xff;
+            v5 = pixels2[p6]&0xff;
+            v8 = pixels2[p9]&0xff;
+            if (roiX>0) { p3++; p6++; p9++; }
+            v3 = pixels2[p3]&0xff;
+            v6 = pixels2[p6]&0xff;
+            v9 = pixels2[p9]&0xff;
+			for (int x=roiX; x<xEnd; x++,p++) {
+				if (x<width-1) { p3++; p6++; p9++; }
+				v1 = v2; v2 = v3;
+				v3 = pixels2[p3]&0xff;
+				v4 = v5; v5 = v6;
+				v6 = pixels2[p6]&0xff;
+				v7 = v8; v8 = v9;
+				v9 = pixels2[p9]&0xff;
+				int sum = k1*v1 + k2*v2 + k3*v3
+						+ k4*v4 + k5*v5 + k6*v6
+						+ k7*v7 + k8*v8 + k9*v9;
+				sum = (sum+scale/2)/scale;   //add scale/2 to round
+				if (sum>255) sum = 255;
+				if (sum<0) sum = 0;
+				pixels[p] = (byte)sum;
+			}
+        }
+    }
+
+	/** Filters using a 3x3 neighborhood. The p1, p2, etc variables, which
+		contain the values of the pixels in the neighborhood, are arranged
+		as follows:
+		<pre>
+		    p1 p2 p3
+		    p4 p5 p6
+		    p7 p8 p9
+		</pre>
+	*/
+	public void filter(int type) {
+		int p1, p2, p3, p4, p5, p6, p7, p8, p9;
+		byte[] pixels2 = (byte[])getPixelsCopy();
+		if (width==1) {
+        	filterEdge(type, pixels2, roiHeight, roiX, roiY, 0, 1);
+        	return;
+		}
+		int offset, sum1, sum2=0, sum=0;
+        int[] values = new int[10];
+        if (type==MEDIAN_FILTER) values = new int[10];
+        int rowOffset = width;
+        int count;
+        int binaryForeground = 255 - binaryBackground;
+		for (int y=yMin; y<=yMax; y++) {
+			offset = xMin + y * width;
+			p2 = pixels2[offset-rowOffset-1]&0xff;
+			p3 = pixels2[offset-rowOffset]&0xff;
+			p5 = pixels2[offset-1]&0xff;
+			p6 = pixels2[offset]&0xff;
+			p8 = pixels2[offset+rowOffset-1]&0xff;
+			p9 = pixels2[offset+rowOffset]&0xff;
+
+			for (int x=xMin; x<=xMax; x++) {
+				p1 = p2; p2 = p3;
+				p3 = pixels2[offset-rowOffset+1]&0xff;
+				p4 = p5; p5 = p6;
+				p6 = pixels2[offset+1]&0xff;
+				p7 = p8; p8 = p9;
+				p9 = pixels2[offset+rowOffset+1]&0xff;
+
+				switch (type) {
+					case BLUR_MORE:
+						sum = (p1+p2+p3+p4+p5+p6+p7+p8+p9+4)/9;
+						break;
+					case FIND_EDGES: // 3x3 Sobel filter
+	        			sum1 = p1 + 2*p2 + p3 - p7 - 2*p8 - p9;
+	        			sum2 = p1  + 2*p4 + p7 - p3 - 2*p6 - p9;
+	        			sum = (int)Math.sqrt(sum1*sum1 + sum2*sum2);
+	        			if (sum> 255) sum = 255;
+						break;
+					case MEDIAN_FILTER:
+						values[1]=p1; values[2]=p2; values[3]=p3; values[4]=p4; values[5]=p5;
+						values[6]=p6; values[7]=p7; values[8]=p8; values[9]=p9;
+						sum = findMedian(values);
+						break;
+					case MIN:
+						sum = p5;
+						if (p1<sum) sum = p1;
+						if (p2<sum) sum = p2;
+						if (p3<sum) sum = p3;
+						if (p4<sum) sum = p4;
+						if (p6<sum) sum = p6;
+						if (p7<sum) sum = p7;
+						if (p8<sum) sum = p8;
+						if (p9<sum) sum = p9;
+						break;
+					case MAX:
+						sum = p5;
+						if (p1>sum) sum = p1;
+						if (p2>sum) sum = p2;
+						if (p3>sum) sum = p3;
+						if (p4>sum) sum = p4;
+						if (p6>sum) sum = p6;
+						if (p7>sum) sum = p7;
+						if (p8>sum) sum = p8;
+						if (p9>sum) sum = p9;
+						break;
+					case ERODE:
+						if (p5==binaryBackground)
+							sum = binaryBackground;
+						else {
+							count = 0;
+							if (p1==binaryBackground) count++;
+							if (p2==binaryBackground) count++;
+							if (p3==binaryBackground) count++;
+							if (p4==binaryBackground) count++;
+							if (p6==binaryBackground) count++;
+							if (p7==binaryBackground) count++;
+							if (p8==binaryBackground) count++;
+							if (p9==binaryBackground) count++;							
+							if (count>=binaryCount)
+								sum = binaryBackground;
+							else
+							sum = binaryForeground;
+						}
+						break;
+					case DILATE:
+						if (p5==binaryForeground)
+							sum = binaryForeground;
+						else {
+							count = 0;
+							if (p1==binaryForeground) count++;
+							if (p2==binaryForeground) count++;
+							if (p3==binaryForeground) count++;
+							if (p4==binaryForeground) count++;
+							if (p6==binaryForeground) count++;
+							if (p7==binaryForeground) count++;
+							if (p8==binaryForeground) count++;
+							if (p9==binaryForeground) count++;							
+							if (count>=binaryCount)
+								sum = binaryForeground;
+							else
+								sum = binaryBackground;
+						}
+						break;
+				}
+				
+				pixels[offset++] = (byte)sum;
+			}
+		}
+        if (xMin==1) filterEdge(type, pixels2, roiHeight, roiX, roiY, 0, 1);
+        if (yMin==1) filterEdge(type, pixels2, roiWidth, roiX, roiY, 1, 0);
+        if (xMax==width-2) filterEdge(type, pixels2, roiHeight, width-1, roiY, 0, 1);
+        if (yMax==height-2) filterEdge(type, pixels2, roiWidth, roiX, height-1, 1, 0);
+	}
+
+	void filterEdge(int type, byte[] pixels2, int n, int x, int y, int xinc, int yinc) {
+		int p1, p2, p3, p4, p5, p6, p7, p8, p9;
+        int sum=0, sum1, sum2;
+        int count;
+        int binaryForeground = 255 - binaryBackground;
+		int bg = binaryBackground;
+		int fg = binaryForeground;
+		
+		for (int i=0; i<n; i++) {
+			if ((!Prefs.padEdges && type==ERODE) || type==DILATE) {
+				p1=getEdgePixel0(pixels2,bg,x-1,y-1); p2=getEdgePixel0(pixels2,bg,x,y-1); p3=getEdgePixel0(pixels2,bg,x+1,y-1);
+				p4=getEdgePixel0(pixels2,bg,x-1,y); p5=getEdgePixel0(pixels2,bg,x,y); p6=getEdgePixel0(pixels2,bg,x+1,y);
+				p7=getEdgePixel0(pixels2,bg,x-1,y+1); p8=getEdgePixel0(pixels2,bg,x,y+1); p9=getEdgePixel0(pixels2,bg,x+1,y+1);
+			}  else if (Prefs.padEdges && type==ERODE) {
+				p1=getEdgePixel1(pixels2,fg, x-1,y-1); p2=getEdgePixel1(pixels2,fg,x,y-1); p3=getEdgePixel1(pixels2,fg,x+1,y-1);
+				p4=getEdgePixel1(pixels2,fg, x-1,y); p5=getEdgePixel1(pixels2,fg,x,y); p6=getEdgePixel1(pixels2,fg,x+1,y);
+				p7=getEdgePixel1(pixels2,fg,x-1,y+1); p8=getEdgePixel1(pixels2,fg,x,y+1); p9=getEdgePixel1(pixels2,fg,x+1,y+1);
+			} else {
+				p1=getEdgePixel(pixels2,x-1,y-1); p2=getEdgePixel(pixels2,x,y-1); p3=getEdgePixel(pixels2,x+1,y-1);
+				p4=getEdgePixel(pixels2,x-1,y); p5=getEdgePixel(pixels2,x,y); p6=getEdgePixel(pixels2,x+1,y);
+				p7=getEdgePixel(pixels2,x-1,y+1); p8=getEdgePixel(pixels2,x,y+1); p9=getEdgePixel(pixels2,x+1,y+1);
+			}
+            switch (type) {
+                case BLUR_MORE:
+                    sum = (p1+p2+p3+p4+p5+p6+p7+p8+p9+4)/9;
+                    break;
+                case FIND_EDGES: // 3x3 Sobel filter
+                    sum1 = p1 + 2*p2 + p3 - p7 - 2*p8 - p9;
+                    sum2 = p1  + 2*p4 + p7 - p3 - 2*p6 - p9;
+                    sum = (int)Math.sqrt(sum1*sum1 + sum2*sum2);
+                    if (sum> 255) sum = 255;
+                    break;
+                case MIN:
+                    sum = p5;
+                    if (p1<sum) sum = p1;
+                    if (p2<sum) sum = p2;
+                    if (p3<sum) sum = p3;
+                    if (p4<sum) sum = p4;
+                    if (p6<sum) sum = p6;
+                    if (p7<sum) sum = p7;
+                    if (p8<sum) sum = p8;
+                    if (p9<sum) sum = p9;
+                    break;
+                case MAX:
+                    sum = p5;
+                    if (p1>sum) sum = p1;
+                    if (p2>sum) sum = p2;
+                    if (p3>sum) sum = p3;
+                    if (p4>sum) sum = p4;
+                    if (p6>sum) sum = p6;
+                    if (p7>sum) sum = p7;
+                    if (p8>sum) sum = p8;
+                    if (p9>sum) sum = p9;
+                    break;
+				case ERODE:
+					if (p5==binaryBackground)
+						sum = binaryBackground;
+					else {
+						count = 0;
+						if (p1==binaryBackground) count++;
+						if (p2==binaryBackground) count++;
+						if (p3==binaryBackground) count++;
+						if (p4==binaryBackground) count++;
+						if (p6==binaryBackground) count++;
+						if (p7==binaryBackground) count++;
+						if (p8==binaryBackground) count++;
+						if (p9==binaryBackground) count++;							
+						if (count>=binaryCount)
+							sum = binaryBackground;
+						else
+						sum = binaryForeground;
+					}
+					break;
+				case DILATE:
+					if (p5==binaryForeground)
+						sum = binaryForeground;
+					else {
+						count = 0;
+						if (p1==binaryForeground) count++;
+						if (p2==binaryForeground) count++;
+						if (p3==binaryForeground) count++;
+						if (p4==binaryForeground) count++;
+						if (p6==binaryForeground) count++;
+						if (p7==binaryForeground) count++;
+						if (p8==binaryForeground) count++;
+						if (p9==binaryForeground) count++;							
+						if (count>=binaryCount)
+							sum = binaryForeground;
+						else
+							sum = binaryBackground;
+					}
+					break;
+            }
+            pixels[x+y*width] = (byte)sum;
+            x+=xinc; y+=yinc;
+        }
+    }
+
+	final int getEdgePixel(byte[] pixels2, int x, int y) {
+		if (x<=0) x = 0;
+		if (x>=width) x = width-1;
+		if (y<=0) y = 0;
+		if (y>=height) y = height-1;
+		return pixels2[x+y*width]&255;
+	}
+
+	final int getEdgePixel1(byte[] pixels2, int foreground, int x, int y) {
+		if (x<0 || x>width-1 || y<0 || y>height-1)
+            return foreground;
+        else
+            return pixels2[x+y*width]&255;
+	}
+
+	final int getEdgePixel0(byte[] pixels2, int background, int x, int y) {
+		if (x<0 || x>width-1 || y<0 || y>height-1)
+            return background;
+        else
+            return pixels2[x+y*width]&255;
+	}
+
+	public void erode() {
+		if (isInvertedLut())
+			filter(MIN);
+		else
+			filter(MAX);
+	}
+	
+	public void dilate() {
+		if (isInvertedLut())
+			filter(MAX);
+		else
+			filter(MIN);
+	}
+
+	public void erode(int count, int background) {
+        binaryCount = count;
+        binaryBackground = background;
+        filter(ERODE);
+	}
+
+	public void dilate(int count, int background) {
+        binaryCount = count;
+        binaryBackground = background;
+        filter(DILATE);
+	}
+
+	public void outline() {
+		new BinaryProcessor(this).outline();
+	}
+	
+	/** Converts black objects in a binary image to single pixel skeletons. */
+	public void skeletonize() {
+		new BinaryProcessor(this).skeletonize();
+	}
+	
+	/** Converts objects with pixel values of 'forground' (255 or 0) 
+		in a binary imager to single pixel skeletons.
+	*/
+	public void skeletonize(int foreground) {
+		new BinaryProcessor(this).skeletonize(foreground);
+	}
+
+	private final int findMedian (int[] values) {
+	//Finds the 5th largest of 9 values
+		for (int i = 1; i <= 4; i++) {
+			int max = 0;
+			int mj = 1;
+			for (int j = 1; j <= 9; j++)
+				if (values[j] > max) {
+					max = values[j];
+					mj = j;
+				}
+			values[mj] = 0;
+		}
+		int max = 0;
+		for (int j = 1; j <= 9; j++)
+			if (values[j] > max)
+				max = values[j];
+		return max;
+	}
+
+	public void medianFilter() {
+		filter(MEDIAN_FILTER);
+	}
+
+
+    /** Adds pseudorandom, Gaussian ("normally") distributed values, with
+    	mean 0.0 and the specified standard deviation, to this image or ROI. */
+	public void noise(double standardDeviation) {
+		if (rnd==null)
+			rnd = new Random();
+		if (!Double.isNaN(seed))
+			rnd.setSeed((int)seed);
+		seed = Double.NaN;
+		int v, ran;
+		boolean inRange;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				inRange = false;
+				do {
+					ran = (int)Math.round(rnd.nextGaussian()*standardDeviation);
+					v = (pixels[i] & 0xff) + ran;
+					inRange = v>=0 && v<=255;
+					if (inRange) pixels[i] = (byte)v;
+				} while (!inRange);
+				i++;
+			}
+		}
+    }
+    
+
+	/** Scales the image or selection using the specified scale factors.
+		@see ImageProcessor#setInterpolate
+	*/
+	public void scale(double xScale, double yScale) {
+		double xCenter = roiX + roiWidth/2.0;
+		double yCenter = roiY + roiHeight/2.0;
+		int xmin, xmax, ymin, ymax;
+		if (!bgColorSet && isInvertedLut()) bgColor = 0;
+		
+		if ((xScale>1.0) && (yScale>1.0)) {
+			//expand roi
+			xmin = (int)(xCenter-(xCenter-roiX)*xScale);
+			if (xmin<0) xmin = 0;
+			xmax = xmin + (int)(roiWidth*xScale) - 1;
+			if (xmax>=width) xmax = width - 1;
+			ymin = (int)(yCenter-(yCenter-roiY)*yScale);
+			if (ymin<0) ymin = 0;
+			ymax = ymin + (int)(roiHeight*yScale) - 1;
+			if (ymax>=height) ymax = height - 1;
+		} else {
+			xmin = roiX;
+			xmax = roiX + roiWidth - 1;
+			ymin = roiY;
+			ymax = roiY + roiHeight - 1;
+		}
+		byte[] pixels2 = (byte[])getPixelsCopy();
+		ImageProcessor ip2 = null;
+		if (interpolationMethod==BICUBIC) {
+			ip2 = new ByteProcessor(getWidth(), getHeight(), pixels2, null);
+			ip2.setBackgroundValue(getBackgroundValue());
+		}
+		boolean checkCoordinates = (xScale < 1.0) || (yScale < 1.0);
+		int index1, index2, xsi, ysi;
+		double ys, xs;
+		if (interpolationMethod==BICUBIC) {
+			for (int y=ymin; y<=ymax; y++) {
+				ys = (y-yCenter)/yScale + yCenter;
+				index1 = y*width + xmin;
+				index2 = width*(int)ys;
+				for (int x=xmin; x<=xmax; x++) {
+					xs = (x-xCenter)/xScale + xCenter;
+					int value = (int)(getBicubicInterpolatedPixel(xs, ys, ip2)+0.5);
+					if (value<0) value = 0;
+					if (value>255) value = 255;
+					pixels[index1++] = (byte)value;
+				}
+			}
+		} else {
+			double xlimit = width-1.0, xlimit2 = width-1.001;
+			double ylimit = height-1.0, ylimit2 = height-1.001;
+			for (int y=ymin; y<=ymax; y++) {
+				ys = (y-yCenter)/yScale + yCenter;
+				ysi = (int)ys;
+				if (ys<0.0) ys = 0.0;			
+				if (ys>=ylimit) ys = ylimit2;
+				index1 = y*width + xmin;
+				index2 = width*(int)ys;
+				for (int x=xmin; x<=xmax; x++) {
+					xs = (x-xCenter)/xScale + xCenter;
+					xsi = (int)xs;
+					if (checkCoordinates && ((xsi<xmin) || (xsi>xmax) || (ysi<ymin) || (ysi>ymax)))
+						pixels[index1++] = (byte)bgColor;
+					else {
+						if (interpolationMethod==BILINEAR) {
+							if (xs<0.0) xs = 0.0;
+							if (xs>=xlimit) xs = xlimit2;
+							pixels[index1++] =(byte)((int)(getInterpolatedPixel(xs, ys, pixels2)+0.5)&255);
+						} else
+							pixels[index1++] = pixels2[index2+xsi];
+					}
+				}
+			}
+		}
+	}
+
+	/** Uses bilinear interpolation to find the pixel value at real coordinates (x,y). */
+	private final double getInterpolatedPixel(double x, double y, byte[] pixels) {
+		int xbase = (int)x;
+		int ybase = (int)y;
+		double xFraction = x - xbase;
+		double yFraction = y - ybase;
+		int offset = ybase * width + xbase;
+		int lowerLeft = pixels[offset]&255;
+		int lowerRight = pixels[offset + 1]&255;
+		int upperRight = pixels[offset + width + 1]&255;
+		int upperLeft = pixels[offset + width]&255;
+		double upperAverage = upperLeft + xFraction * (upperRight - upperLeft);
+		double lowerAverage = lowerLeft + xFraction * (lowerRight - lowerLeft);
+		return lowerAverage + yFraction * (upperAverage - lowerAverage);
+	}
+
+	/** Creates a new ByteProcessor containing a scaled copy of this image or selection.
+		@see ij.process.ImageProcessor#setInterpolate
+	*/
+	public ImageProcessor resize(int dstWidth, int dstHeight) {
+		if (roiWidth==dstWidth && roiHeight==dstHeight)
+			return crop();
+		if ((width==1||height==1) && interpolationMethod!=NONE)
+			return resizeLinearly(dstWidth, dstHeight);
+		double srcCenterX = roiX + roiWidth/2.0;
+		double srcCenterY = roiY + roiHeight/2.0;
+		double dstCenterX = dstWidth/2.0;
+		double dstCenterY = dstHeight/2.0;
+		double xScale = (double)dstWidth/roiWidth;
+		double yScale = (double)dstHeight/roiHeight;
+		if (interpolationMethod!=NONE) {
+			if (dstWidth!=width) dstCenterX+=xScale/4.0;
+			if (dstHeight!=height) dstCenterY+=yScale/4.0;
+		}
+		ImageProcessor ip2 = createProcessor(dstWidth, dstHeight);
+		byte[] pixels2 = (byte[])ip2.getPixels();
+		int inc = getProgressIncrement(dstWidth,dstHeight);
+		double xs, ys;
+		int index1, index2;
+		if (interpolationMethod==BICUBIC) {
+			for (int y=0; y<=dstHeight-1; y++) {
+				if (inc!=0&&y%inc==0) showProgress((double)y/dstHeight);
+				ys = (y-dstCenterY)/yScale + srcCenterY;
+				index1 = width*(int)ys;
+				index2 = y*dstWidth;
+				for (int x=0; x<=dstWidth-1; x++) {
+					xs = (x-dstCenterX)/xScale + srcCenterX;
+					int value = (int)(getBicubicInterpolatedPixel(xs, ys, this)+0.5);
+					if (value<0) value = 0;
+					if (value>255) value = 255;
+					pixels2[index2++] = (byte)value;
+				}
+			}
+		} else {
+			double xlimit = width-1.0, xlimit2 = width-1.001;
+			double ylimit = height-1.0, ylimit2 = height-1.001;
+			for (int y=0; y<=dstHeight-1; y++) {
+				if (inc!=0&&y%inc==0) showProgress((double)y/dstHeight);
+				ys = (y-dstCenterY)/yScale + srcCenterY;
+				if (interpolationMethod==BILINEAR) {
+					if (ys<0.0) ys = 0.0;
+					if (ys>=ylimit) ys = ylimit2;
+				}
+				index1 = width*(int)ys;
+				index2 = y*dstWidth;
+				for (int x=0; x<=dstWidth-1; x++) {
+					xs = (x-dstCenterX)/xScale + srcCenterX;
+					if (interpolationMethod==BILINEAR) {
+						if (xs<0.0) xs = 0.0;
+						if (xs>=xlimit) xs = xlimit2;
+						pixels2[index2++] = (byte)((int)(getInterpolatedPixel(xs, ys, pixels)+0.5)&255);
+					} else
+						pixels2[index2++] = pixels[index1+(int)xs];
+				}
+			}
+		}
+		if (inc!=0) showProgress(1.0);
+		return ip2;
+	}
+
+	/** Rotates the image or ROI 'angle' degrees clockwise.
+		@see ImageProcessor#setInterpolationMethod
+	*/
+	public void rotate(double angle) {
+        if (angle%360==0)
+        	return;
+		byte[] pixels2 = (byte[])getPixelsCopy();
+		ImageProcessor ip2 = null;
+		if (interpolationMethod==BICUBIC) {
+			ip2 = new ByteProcessor(getWidth(), getHeight(), pixels2, null);
+			ip2.setBackgroundValue(getBackgroundValue());
+		}
+		double centerX = roiX + (roiWidth-1)/2.0;
+		double centerY = roiY + (roiHeight-1)/2.0;
+		int xMax = roiX + this.roiWidth - 1;
+		if (!bgColorSet && isInvertedLut()) bgColor = 0;
+		
+		double angleRadians = -angle/(180.0/Math.PI);
+		double ca = Math.cos(angleRadians);
+		double sa = Math.sin(angleRadians);
+		double tmp1 = centerY*sa-centerX*ca;
+		double tmp2 = -centerX*sa-centerY*ca;
+		double tmp3, tmp4, xs, ys;
+		int index, ixs, iys;
+		double dwidth=width, dheight=height;
+		double xlimit = width-1.0, xlimit2 = width-1.001;
+		double ylimit = height-1.0, ylimit2 = height-1.001;
+		
+		if (interpolationMethod==BICUBIC) {
+			for (int y=roiY; y<(roiY + roiHeight); y++) {
+				index = y*width + roiX;
+				tmp3 = tmp1 - y*sa + centerX;
+				tmp4 = tmp2 + y*ca + centerY;
+				for (int x=roiX; x<=xMax; x++) {
+					xs = x*ca + tmp3;
+					ys = x*sa + tmp4;
+					int value = (int)(getBicubicInterpolatedPixel(xs, ys, ip2)+0.5);
+					if (value<0) value = 0;
+					if (value>255) value = 255;
+					pixels[index++] = (byte)value;
+				}
+			}
+		} else {
+			for (int y=roiY; y<(roiY + roiHeight); y++) {
+				index = y*width + roiX;
+				tmp3 = tmp1 - y*sa + centerX;
+				tmp4 = tmp2 + y*ca + centerY;
+				for (int x=roiX; x<=xMax; x++) {
+					xs = x*ca + tmp3;
+					ys = x*sa + tmp4;
+					if ((xs>=-0.01) && (xs<dwidth) && (ys>=-0.01) && (ys<dheight)) {
+						if (interpolationMethod==BILINEAR) {
+							if (xs<0.0) xs = 0.0;
+							if (xs>=xlimit) xs = xlimit2;
+							if (ys<0.0) ys = 0.0;			
+							if (ys>=ylimit) ys = ylimit2;
+							pixels[index++] = (byte)(getInterpolatedPixel(xs, ys, pixels2)+0.5);
+						} else {
+							ixs = (int)(xs+0.5);
+							iys = (int)(ys+0.5);
+							if (ixs>=width) ixs = width - 1;
+							if (iys>=height) iys = height -1;
+							pixels[index++] = pixels2[width*iys+ixs];
+						}
+					} else
+						pixels[index++] = (byte)bgColor;
+				}
+			}
+		}
+	}
+
+	public void flipVertical() {
+		int index1,index2;
+		byte tmp;
+		for (int y=0; y<roiHeight/2; y++) {
+			index1 = (roiY+y)*width+roiX;
+			index2 = (roiY+roiHeight-1-y)*width+roiX;
+			for (int i=0; i<roiWidth; i++) {
+				tmp = pixels[index1];
+				pixels[index1++] = pixels[index2];
+				pixels[index2++] = tmp;
+			}
+		}
+	}
+	
+	public int[] getHistogram() {
+		if (mask!=null)
+			return getHistogram(mask);
+		int[] histogram = new int[256];
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				int v = pixels[i++] & 0xff;
+				histogram[v]++;
+			}
+		}
+		return histogram;
+	}
+
+	public int[] getHistogram(ImageProcessor mask) {
+		int rx=roiX, ry=roiY, rw=roiWidth, rh=roiHeight;
+		if (mask.getWidth()!=rw||mask.getHeight()!=rh)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		int v;
+		int[] histogram = new int[256];
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=ry, my=0; y<(ry+rh); y++, my++) {
+			int i = y*width + rx;
+			int mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mpixels[mi++]!=0) {
+					v = pixels[i] & 0xff;
+					histogram[v]++;
+				}
+				i++;
+			}
+		}
+		return histogram;
+	}
+
+	/** Sets pixels less than or equal to level to 0 and all other pixels to 255. */
+	public void threshold(int level) {
+		for (int i=0; i<width*height; i++) {
+			if ((pixels[i] & 0xff) <= level)
+				pixels[i] = 0;
+			else
+				pixels[i] = (byte)255;
+		}
+	}
+
+	public void applyLut() {
+		if (rLUT2==null)
+			return;
+		if (isInvertedLut())
+			for (int i=0; i<width*height; i++)
+				pixels[i] = (byte)(255 - rLUT2[pixels[i]&0xff]);
+		else
+			for (int i=0; i<width*height; i++)
+				pixels[i] = rLUT2[pixels[i] & 0xff];
+		setMinAndMax(0, 255);
+	}
+
+	/** Performs a convolution operation using the specified kernel. */
+	public void convolve(float[] kernel, int kernelWidth, int kernelHeight) {
+		ImageProcessor ip2 = convertToFloat();
+		ip2.setRoi(getRoi());
+		new ij.plugin.filter.Convolver().convolve(ip2, kernel, kernelWidth, kernelHeight);
+		ip2 = ip2.convertToByte(false);
+		byte[] pixels2 = (byte[])ip2.getPixels();
+		System.arraycopy(pixels2, 0, pixels, 0, pixels.length);
+	}
+	
+	public FloatProcessor[] toFloatProcessors() {
+		FloatProcessor[] fp = new FloatProcessor[1];
+		fp[0] = (FloatProcessor)convertToFloat();
+		return fp;
+	}
+	
+	public void setFromFloatProcessors(FloatProcessor[]  fp) {
+		ImageProcessor ip2 = fp[0].convertToByte(false);
+		setPixels(ip2.getPixels());
+	}
+
+	public float[][] toFloatArrays() {
+		float[][] a = new float[1][];
+		//ImageProcessor fp = crop();
+		ImageProcessor fp = convertToFloat();
+		a[0] = (float[])fp.getPixels();
+		return a;
+	}
+	
+	public void setFromFloatArrays(float[][] arrays) {
+		ImageProcessor ip2 = new FloatProcessor(roiWidth, roiHeight, arrays[0], null);
+		ip2 = ip2.convertToByte(false);
+		setPixels(ip2.getPixels());
+		//insert(ip2, roiX, roiY); 
+	}
+
+	/** Returns a FloatProcessor with the same image, no scaling or calibration
+	*  (pixel values 0 to 255).
+	*  The roi, mask, lut (ColorModel), threshold, min&max are
+	*  also set for the FloatProcessor
+	*  @param channelNumber   Ignored (needed for compatibility with ColorProcessor.toFloat)
+	*  @param fp              Here a FloatProcessor can be supplied, or null. The FloatProcessor
+	*                         is overwritten by this method (re-using its pixels array 
+	*                         improves performance).
+	*  @return A FloatProcessor with the converted image data
+	*/
+	public FloatProcessor toFloat(int channelNumber, FloatProcessor fp) {
+		int size = width*height;
+		if (fp == null || fp.getWidth()!=width || fp.getHeight()!=height)
+			fp = new FloatProcessor(width, height, new float[size], cm);
+		float[] fPixels = (float[])fp.getPixels();
+		for (int i=0; i<size; i++)
+			fPixels[i] = pixels[i]&0xff;
+		fp.setRoi(getRoi());
+		fp.setMask(mask);
+		fp.setMinAndMax(min, max);
+		fp.setThreshold(minThreshold, maxThreshold, ImageProcessor.NO_LUT_UPDATE);
+		return fp;
+	}
+	
+	/** Sets the pixels from a FloatProcessor, no scaling.
+	*  Also the min&max values are taken from the FloatProcessor.
+	*  @param channelNumber   Ignored (needed for compatibility with ColorProcessor.toFloat)
+	*  @param fp              The FloatProcessor where the image data are read from.
+	*/
+	public void setPixels(int channelNumber, FloatProcessor fp) {
+		float[] fPixels = (float[])fp.getPixels();
+		float value;
+		int size = width*height;
+		for (int i=0; i<size; i++) {
+			value = fPixels[i] + 0.5f;
+			if (value<0f) value = 0f;
+			if (value>255f) value = 255f;
+			pixels[i] = (byte)value;
+		}
+		setMinAndMax(fp.getMin(), fp.getMax());
+	}
+	
+	/** Returns 'true' if this is a binary image (8-bit-image with only 0 and 255). */
+	public boolean isBinary() {
+		for (int i=0; i<width*height; i++) {
+			if (pixels[i]!=0 && pixels[i]!=(byte)255)
+				return false;
+		}
+		return true;
+	}
+	
+	public int getBitDepth() {
+		return 8;
+	}
+	
+	/** Returns a binary mask, or null if a threshold is not set. */
+	public ByteProcessor createMask() {
+		if (getMinThreshold()==NO_THRESHOLD)
+			return null;
+		int minThreshold = (int)getMinThreshold();
+		int maxThreshold = (int)getMaxThreshold();
+		ByteProcessor mask = new ByteProcessor(width, height);
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int i=0; i<pixels.length; i++) {
+			int value = pixels[i]&0xff;
+			if (value>=minThreshold && value<=maxThreshold)
+				mpixels[i] = (byte)255;
+		}
+		return mask;
+	}
+	
+	byte[] create8BitImage() {
+		return pixels;
+	}
+
+}
+
diff --git a/src/ij/process/ByteStatistics.java b/src/ij/process/ByteStatistics.java
new file mode 100644
index 0000000..fe033cf
--- /dev/null
+++ b/src/ij/process/ByteStatistics.java
@@ -0,0 +1,177 @@
+package ij.process;
+import ij.measure.Calibration;
+
+/** 8-bit image statistics, including histogram. */
+public class ByteStatistics extends ImageStatistics {
+
+	/** Construct an ImageStatistics object from a ByteProcessor
+		using the standard measurement options (area, mean,
+		mode, min and max) and no calibration. */
+	public ByteStatistics(ImageProcessor ip) {
+		this(ip, AREA+MEAN+MODE+MIN_MAX, null);
+	}
+
+	/** Constructs a ByteStatistics object from a ByteProcessor using
+		the specified measurement and calibration. */
+	public ByteStatistics(ImageProcessor ip, int mOptions, Calibration cal) {
+		ByteProcessor bp = (ByteProcessor)ip;
+		histogram = bp.getHistogram();
+		setup(ip, cal);
+		double minT = ip.getMinThreshold();
+		int minThreshold,maxThreshold;
+		boolean limitToThreshold = (mOptions&LIMIT)!=0;
+		if (!limitToThreshold || minT==ImageProcessor.NO_THRESHOLD) {
+			minThreshold=0;
+			maxThreshold=255;
+		} else {
+			minThreshold = (int)minT;
+			maxThreshold = (int)ip.getMaxThreshold();
+		}
+		if (limitToThreshold)
+			saveThreshold(minThreshold, maxThreshold, cal);
+		float[] cTable = cal!=null?cal.getCTable():null;
+		if (cTable!=null)
+			getCalibratedStatistics(minThreshold,maxThreshold,cTable);
+		else
+			getRawStatistics(minThreshold,maxThreshold);
+		if ((mOptions&MIN_MAX)!=0) {
+			if (pixelCount==0)
+				min = max = Double.NaN;
+			else if (cTable!=null)
+				getCalibratedMinAndMax(minThreshold, maxThreshold, cTable);
+			else
+				getRawMinAndMax(minThreshold, maxThreshold);
+		}
+		if ((mOptions&ELLIPSE)!=0 || (mOptions&SHAPE_DESCRIPTORS)!=0)
+			fitEllipse(ip, mOptions);
+		else if ((mOptions&CENTROID)!=0)
+			getCentroid(ip, minThreshold, maxThreshold);
+		if ((mOptions&(CENTER_OF_MASS|SKEWNESS|KURTOSIS))!=0)
+			calculateMoments(ip, minThreshold, maxThreshold, cTable);
+		if ((mOptions&MEDIAN)!=0)
+			calculateMedian(histogram, minThreshold, maxThreshold, cal);
+		if ((mOptions&AREA_FRACTION)!=0)
+			calculateAreaFraction(ip, histogram);
+	}
+
+	void getCalibratedStatistics(int minThreshold, int maxThreshold, float[] cTable) {
+		int count;
+		double value;
+		double sum = 0;
+		double sum2 = 0.0;
+		double isum = 0.0;
+		
+		for (int i=minThreshold; i<=maxThreshold; i++) {
+			count = histogram[i];
+			value = cTable[i];
+			if (count>0 && !Double.isNaN(value)) {
+				pixelCount += count;
+				sum += value*count;
+				isum += i*count;
+				sum2 += (value*value)*count;
+				if (count>maxCount) {
+					maxCount = count;
+					mode = i;
+				}
+			}
+		}
+		area = pixelCount*pw*ph;
+		mean = sum/pixelCount;
+		umean = isum/pixelCount;
+		dmode = cTable[mode];
+		calculateStdDev(pixelCount,sum,sum2);
+		histMin = 0.0;
+		histMax = 255.0;
+	}
+	
+	void getCentroid(ImageProcessor ip, int minThreshold, int maxThreshold) {
+		byte[] pixels = (byte[])ip.getPixels();
+		byte[] mask = ip.getMaskArray();
+		boolean limit = minThreshold>0 || maxThreshold<255;
+		double xsum=0, ysum=0;
+		int count=0,i,mi,v;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null||mask[mi++]!=0) {
+					if (limit) {
+						v = pixels[i]&255;
+						if (v>=minThreshold&&v<=maxThreshold) {
+							count++;
+							xsum+=x;
+							ysum+=y;
+						}
+					} else {
+						count++;
+						xsum+=x;
+						ysum+=y;
+					}
+				}
+				i++;
+			}
+		}
+		xCentroid = xsum/count+0.5;
+		yCentroid = ysum/count+0.5;
+		if (cal!=null) {
+			xCentroid = cal.getX(xCentroid);
+			yCentroid = cal.getY(yCentroid, height);
+		}
+	}
+
+	void calculateMoments(ImageProcessor ip,  int minThreshold, int maxThreshold, float[] cTable) {
+		byte[] pixels = (byte[])ip.getPixels();
+		byte[] mask = ip.getMaskArray();
+		int v, i, mi;
+		double dv, dv2, sum1=0.0, sum2=0.0, sum3=0.0, sum4=0.0, xsum=0.0, ysum=0.0;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					v = pixels[i]&255;
+					if (v>=minThreshold&&v<=maxThreshold) {
+						dv = ((cTable!=null)?cTable[v]:v)+Double.MIN_VALUE;
+						dv2 = dv*dv;
+						sum1 += dv;
+						sum2 += dv2;
+						sum3 += dv*dv2;
+						sum4 += dv2*dv2;
+						xsum += x*dv;
+						ysum += y*dv;
+					}
+				}
+				i++;
+			}
+		}
+	    double mean2 = mean*mean;
+	    double variance = sum2/pixelCount - mean2;
+	    double sDeviation = Math.sqrt(variance);
+	    skewness = ((sum3 - 3.0*mean*sum2)/pixelCount + 2.0*mean*mean2)/(variance*sDeviation);
+	    kurtosis = (((sum4 - 4.0*mean*sum3 + 6.0*mean2*sum2)/pixelCount - 3.0*mean2*mean2)/(variance*variance)-3.0);
+		xCenterOfMass = xsum/sum1+0.5;
+		yCenterOfMass = ysum/sum1+0.5;
+		if (cal!=null) {
+			xCenterOfMass = cal.getX(xCenterOfMass);
+			yCenterOfMass = cal.getY(yCenterOfMass, height);
+		}
+	}
+	
+	void getCalibratedMinAndMax(int minThreshold, int maxThreshold, float[] cTable) {
+		if (pixelCount==0)
+			{min=0.0; max=0.0; return;}
+		min = Double.MAX_VALUE;
+		max = -Double.MAX_VALUE;
+		double v = 0.0;
+		for (int i=minThreshold; i<=maxThreshold; i++) {
+			if (histogram[i]>0) {
+				v = cTable[i];
+				if (v<min)
+					min = v;
+				if (v>max)
+					max = v;
+			}
+		}
+	}
+	
+}
diff --git a/src/ij/process/ColorBlitter.java b/src/ij/process/ColorBlitter.java
new file mode 100644
index 0000000..16b3a4a
--- /dev/null
+++ b/src/ij/process/ColorBlitter.java
@@ -0,0 +1,139 @@
+package ij.process;
+import java.awt.*;
+import java.awt.image.*;
+
+/** This class does bit blitting of RGB images. */
+public class ColorBlitter implements Blitter {
+
+	private ColorProcessor ip;
+	private int width, height;
+	private int[] pixels;
+	private int transparent = 0xffffff;
+	
+	/** Constructs a ColorBlitter from a ColorProcessor. */
+	public ColorBlitter(ColorProcessor ip) {
+		this.ip = ip;
+		width = ip.getWidth();
+		height = ip.getHeight();
+		pixels = (int[])ip.getPixels();
+	}
+
+	public void setTransparentColor(Color c) {
+		transparent = c.getRGB()&0xffffff;
+	}
+
+	/** Copies the RGB image in 'ip' to (x,y) using the specified mode. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		int srcIndex, dstIndex;
+		int xSrcBase, ySrcBase;
+		int[] srcPixels;
+		
+		int srcWidth = ip.getWidth();
+		int srcHeight = ip.getHeight();
+		Rectangle rect1 = new Rectangle(srcWidth, srcHeight);
+		rect1.setLocation(xloc, yloc);
+		Rectangle rect2 = new Rectangle(width, height);
+		if (!rect1.intersects(rect2))
+			return;
+		if (ip instanceof ByteProcessor) {
+			byte[] pixels8 = (byte[])ip.getPixels();
+			ColorModel cm = ip.getColorModel();
+			if (ip.isInvertedLut())
+				cm = ip.getDefaultColorModel();
+			int size = ip.getWidth()*ip.getHeight();
+			srcPixels = new int[size];
+			int v;
+			for (int i=0; i<size; i++)
+				srcPixels[i] = cm.getRGB(pixels8[i]&255);
+		} else
+			srcPixels = (int[])ip.getPixels();
+		rect1 = rect1.intersection(rect2);
+		xSrcBase = (xloc<0)?-xloc:0;
+		ySrcBase = (yloc<0)?-yloc:0;
+		int c1, c2, r1, g1, b1, r2, g2, b2;
+		int src, dst;
+		
+		if (mode==COPY||mode==COPY_TRANSPARENT|| mode==COPY_ZERO_TRANSPARENT) {
+			for (int y=rect1.y; y<(rect1.y+rect1.height); y++) {
+				srcIndex = (y-yloc)*srcWidth + (rect1.x-xloc);
+				dstIndex = y * width + rect1.x;
+				int trancolor = mode==COPY_ZERO_TRANSPARENT?0:transparent;
+				if (mode==COPY) {
+					for (int i=rect1.width; --i>=0;)
+						pixels[dstIndex++] = srcPixels[srcIndex++];
+				} else {
+					for (int i=rect1.width; --i>=0;) {
+						src = srcPixels[srcIndex++];
+						dst = pixels[dstIndex];
+						pixels[dstIndex++] = (src&0xffffff)==trancolor?dst:src;
+					}
+				} 
+			}
+			return;
+		}
+		
+		for (int y=rect1.y; y<(rect1.y+rect1.height); y++) {
+			srcIndex = (y-yloc)*srcWidth + (rect1.x-xloc);
+			dstIndex = y * width + rect1.x;
+			for (int i=rect1.width; --i>=0;) {
+				c1 = srcPixels[srcIndex++];
+				r1 = (c1&0xff0000)>>16;
+				g1 = (c1&0xff00)>>8;
+				b1 = c1&0xff;
+				c2 = pixels[dstIndex];
+				r2 = (c2&0xff0000)>>16;
+				g2 = (c2&0xff00)>>8;
+				b2 = c2&0xff;
+				switch (mode) {
+					case COPY_INVERTED:
+						break;
+					case ADD:
+							r2=r1+r2; g2=g1+g2; b2=b1+b2;
+							if (r2>255) r2=255; if (g2>255) g2=255; if (b2>255) b2=255;
+						break;
+					case AVERAGE:
+							r2=(r1+r2)/2; g2=(g1+g2)/2; b2=(b1+b2)/2;
+						break;
+					case SUBTRACT:
+							r2=r2-r1; g2=g2-g1; b2=b2-b1;
+							if (r2<0) r2=0; if (g2<0) g2=0; if (b2<0) b2=0;
+						break;
+					case DIFFERENCE:
+							r2=r2-r1; if (r2<0) r2=-r2;
+							g2=g2-g1; if (g2<0) g2=-g2;
+							b2=b2-b1; if (b2<0) b2=-b2;
+						break;
+					case MULTIPLY:
+							r2=r1*r2; g2=g1*g2; b2=b1*b2;
+							if (r2>255) r2=255; if (g2>255) g2=255; if (b2>255) b2=255;
+						break;
+					case DIVIDE:
+							if (r1==0) r2=255; else r2=r2/r1;
+							if (g1==0) g2=255; else g2=g2/g1;
+							if (b1==0) b2=255; else b2=b2/b1;
+						break;
+					case AND:
+						r2=r1&r2; g2=g1&g2; b2=b1&b2;
+						break;
+					case OR:
+						r2=r1|r2; g2=g1|g2; b2=b1|b2;
+						break;
+					case XOR:
+						r2=r1^r2; g2=g1^g2; b2=b1^b2;
+						break;
+					case MIN:
+						if (r1<r2) r2 = r1;
+						if (g1<g2) g2 = g1;
+						if (b1<b2) b2 = b1;
+						break;
+					case MAX:
+						if (r1>r2) r2 = r1;
+						if (g1>g2) g2 = g1;
+						if (b1>b2) b2 = b1;
+						break;
+				}
+				pixels[dstIndex++] = 0xff000000 + (r2<<16) + (g2<<8) + b2;
+			}
+		}
+	}
+}
diff --git a/src/ij/process/ColorProcessor.java b/src/ij/process/ColorProcessor.java
new file mode 100644
index 0000000..efbafb9
--- /dev/null
+++ b/src/ij/process/ColorProcessor.java
@@ -0,0 +1,1459 @@
+package ij.process;
+
+import java.util.*;
+import java.awt.*;
+import java.awt.image.*;
+import ij.gui.*;
+import ij.ImageStack;
+
+/**
+This is an 32-bit RGB image and methods that operate on that image.. Based on the ImageProcessor class from
+"KickAss Java Programming" by Tonny Espeset (1996).
+*/
+public class ColorProcessor extends ImageProcessor {
+
+	protected int[] pixels;
+	protected int[] snapshotPixels = null;
+	private int bgColor = 0xffffffff; //white
+	protected int min=0, max=255;
+	private WritableRaster rgbRaster;
+	private SampleModel rgbSampleModel;
+	private boolean caSnapshot;
+	
+	// Weighting factors used by getPixelValue(), getHistogram() and convertToByte().
+	// Enable "Weighted RGB Conversion" in <i>Edit/Options/Conversions</i>
+	// to use 0.299, 0.587 and 0.114.
+	private static double rWeight=1d/3d, gWeight=1d/3d,	bWeight=1d/3d; 
+	private double[] weights; // Overrides rWeight, etc. when set by setWeights()
+	 
+	/**Creates a ColorProcessor from an AWT Image or BufferedImage. */
+	public ColorProcessor(Image img) {
+		width = img.getWidth(null);
+		height = img.getHeight(null);
+		pixels = new int[width * height];
+		PixelGrabber pg = new PixelGrabber(img, 0, 0, width, height, pixels, 0, width);
+		try {
+			pg.grabPixels();
+		} catch (InterruptedException e){};
+		createColorModel();
+		fgColor = 0xff000000; //black
+		resetRoi();
+	}
+
+	/**Creates a blank ColorProcessor of the specified dimensions. */
+	public ColorProcessor(int width, int height) {
+		this(width, height, new int[width*height]);
+	}
+	
+	/**Creates a ColorProcessor from a pixel array. */
+	public ColorProcessor(int width, int height, int[] pixels) {
+		if (pixels!=null && width*height!=pixels.length)
+			throw new IllegalArgumentException(WRONG_LENGTH);
+		this.width = width;
+		this.height = height;
+		createColorModel();
+		fgColor = 0xff000000; //black
+		resetRoi();
+		this.pixels = pixels;
+	}
+
+	void createColorModel() {
+		cm = new DirectColorModel(24, 0xff0000, 0xff00, 0xff);
+	}
+	
+	public Image createImage() {
+		return createBufferedImage();
+	}
+
+	Image createBufferedImage() {
+		if (rgbSampleModel==null)
+			rgbSampleModel = getRGBSampleModel();
+		if (rgbRaster==null) {
+			DataBuffer dataBuffer = new DataBufferInt(pixels, width*height, 0);
+			rgbRaster = Raster.createWritableRaster(rgbSampleModel, dataBuffer, null);
+		}
+		if (image==null) {
+			image = new BufferedImage(cm, rgbRaster, false, null);
+		}
+		return image;
+	}
+
+	SampleModel getRGBSampleModel() {
+		WritableRaster wr = cm.createCompatibleWritableRaster(1, 1);
+		SampleModel sampleModel = wr.getSampleModel();
+		sampleModel = sampleModel.createCompatibleSampleModel(width, height);
+		return sampleModel;
+	}
+
+	public void setColorModel(ColorModel cm) {
+		if (cm!=null && (cm instanceof IndexColorModel))
+			throw new IllegalArgumentException("RGB images do not support IndexColorModels");
+		this.cm = cm;
+		rgbSampleModel = null;
+		rgbRaster = null;
+	}
+
+	/** Returns a new, blank ColorProcessor with the specified width and height. */
+	public ImageProcessor createProcessor(int width, int height) {
+		ImageProcessor ip2 = new ColorProcessor(width, height);
+		ip2.setInterpolationMethod(interpolationMethod);
+		return ip2;
+	}
+
+	public Color getColor(int x, int y) {
+		int c = pixels[y*width+x];
+		int r = (c&0xff0000)>>16;
+		int g = (c&0xff00)>>8;
+		int b = c&0xff;
+		return new Color(r,g,b);
+	}
+
+	/** Sets the foreground color. */
+	public void setColor(Color color) {
+		fgColor = color.getRGB();
+		drawingColor = color;
+		fillValueSet = true;
+	}
+
+	/** Sets the fill/draw color, where <code>color</code> is an RGB int. */
+	public void setColor(int color) {
+		fgColor = color;
+		fillValueSet = true;
+	}
+
+	/** Sets the default fill/draw value, where <code>value</code> is interpreted as an RGB int. */
+	public void setValue(double value) {
+		fgColor = (int)value;
+		fillValueSet = true;
+	}
+
+	/** Returns the foreground fill/draw value. */
+	public double getForegroundValue() {
+		return fgColor;
+	}
+
+	/** Sets the background fill value, where <code>value</code> is interpreted as an RGB int. */
+	public void setBackgroundValue(double value) {
+		bgColor = (int)value;
+	}
+
+	/** Returns the background fill value. */
+	public double getBackgroundValue() {
+		return bgColor;
+	}
+
+	/** Returns the smallest displayed pixel value. */
+	public double getMin() {
+		return min;
+	}
+
+
+	/** Returns the largest displayed pixel value. */
+	public double getMax() {
+		return max;
+	}
+
+
+	/** Uses a table look-up to map the pixels in this image from min-max to 0-255. */
+	public void setMinAndMax(double min, double max) {
+		setMinAndMax(min, max, 7);
+	}
+
+	public void setMinAndMax(double min, double max, int channels) {
+		if (max<min)
+			return;
+		this.min = (int)min;
+		this.max = (int)max;
+		int v;
+		int[] lut = new int[256];
+		for (int i=0; i<256; i++) {
+			v = i-this.min;
+			v = (int)(256.0*v/(max-min));
+			if (v < 0)
+				v = 0;
+			if (v > 255)
+				v = 255;
+			lut[i] = v;
+		}
+		reset();
+		if (channels==7)
+			applyTable(lut);
+		else
+			applyTable(lut, channels);
+	}
+	
+	public void snapshot() {
+		snapshotWidth = width;
+		snapshotHeight = height;
+		if (snapshotPixels==null || (snapshotPixels!=null && snapshotPixels.length!=pixels.length))
+			snapshotPixels = new int[width * height];
+		System.arraycopy(pixels, 0, snapshotPixels, 0, width*height);
+		caSnapshot = false;
+	}
+
+
+	public void reset() {
+		if (snapshotPixels!=null)
+			System.arraycopy(snapshotPixels, 0, pixels, 0, width*height);
+	}
+
+
+	public void reset(ImageProcessor mask) {
+		if (mask==null || snapshotPixels==null)
+			return;	
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]==0)
+					pixels[i] = snapshotPixels[i];
+				i++;
+			}
+		}
+	}
+	
+	/** Used by the ContrastAdjuster */
+	public void caSnapshot(boolean set) {
+		caSnapshot = set;
+	}
+
+	/** Used by the ContrastAdjuster */
+	public boolean caSnapshot() {
+		return caSnapshot;
+	}
+	
+	/** Swaps the pixel and snapshot (undo) arrays. */
+	public void swapPixelArrays() {
+		if (snapshotPixels==null)
+			return;	
+		int pixel;
+		for (int i=0; i<pixels.length; i++) {
+			pixel = pixels[i];
+			pixels[i] = snapshotPixels[i];
+			snapshotPixels[i] = pixel;
+		}
+		caSnapshot = false;
+	}
+
+	public void setSnapshotPixels(Object pixels) {
+		if (caSnapshot && pixels==null)
+			return;
+		snapshotPixels = (int[])pixels;
+		snapshotWidth=width;
+		snapshotHeight=height;
+		caSnapshot = false;
+	}
+
+	/** Returns a reference to the snapshot pixel array. Used by the ContrastAdjuster. */
+	public Object getSnapshotPixels() {
+		return snapshotPixels;
+	}
+
+	/** Fills pixels that are within roi and part of the mask.
+		Does nothing if the mask is not the same as the the ROI. */
+	public void fill(ImageProcessor mask) {
+		if (mask==null)
+			{fill(); return;}
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		int roiX=this.roiX, roiY=this.roiY;
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			return;
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]!=0)
+					pixels[i] = fgColor;
+				i++;
+			}
+		}
+	}
+
+	/** Returns a copy of the pixel data. Or returns a reference to the
+		snapshot buffer if it is not null and 'snapshotCopyMode' is true.
+		@see ImageProcessor#snapshot
+		@see ImageProcessor#setSnapshotCopyMode
+	*/
+	public Object getPixelsCopy() {
+		if (snapshotPixels!=null && snapshotCopyMode) {
+			snapshotCopyMode = false;
+			return snapshotPixels;
+		} else {
+			int[] pixels2 = new int[width*height];
+        	System.arraycopy(pixels, 0, pixels2, 0, width*height);
+			return pixels2;
+		}
+	}
+
+	public int getPixel(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			return pixels[y*width+x];
+		else
+			return 0;
+	}
+
+	public final int get(int x, int y) {
+		return pixels[y*width+x];
+	}
+
+	public final void set(int x, int y, int value) {
+		pixels[y*width + x] = value;
+	}
+
+	public final int get(int index) {
+		return pixels[index];
+	}
+	public final void set(int index, int value) {
+		pixels[index] = value;
+	}
+
+	public final float getf(int x, int y) {
+		return pixels[y*width+x];
+	}
+
+	public final void setf(int x, int y, float value) {
+		pixels[y*width + x] = (int)value;
+	}
+
+	public final float getf(int index) {
+		return pixels[index];
+	}
+
+	public final void setf(int index, float value) {
+		pixels[index] = (int)value;
+	}
+
+    /** Returns the 3 samples for the pixel at (x,y) in an array of int.
+		Returns zeros if the the coordinates are not in bounds. iArray
+		is an optional preallocated array. */
+	public int[] getPixel(int x, int y, int[] iArray) {
+		if (iArray==null) iArray = new int[3];
+		int c = getPixel(x, y);
+		iArray[0] = (c&0xff0000)>>16;
+		iArray[1] = (c&0xff00)>>8;
+		iArray[2] = c&0xff;
+		return iArray;
+	}
+
+	/** Sets a pixel in the image using a 3 element (R, G and B)
+		int array of samples. */
+	public final void putPixel(int x, int y, int[] iArray) {
+		int r=iArray[0], g=iArray[1], b=iArray[2];
+		putPixel(x, y, (r<<16)+(g<<8)+b);
+	}
+
+ 	/** Calls getPixelValue(x,y). */
+	public double getInterpolatedPixel(double x, double y) {
+		int ix = (int)(x+0.5);
+		int iy = (int)(y+0.5);
+		if (ix<0) ix = 0;
+		if (ix>=width) ix = width-1;
+		if (iy<0) iy = 0;
+		if (iy>=height) iy = height-1;
+		return getPixelValue(ix, iy);
+	}
+
+	final public int getPixelInterpolated(double x,double y) {
+		if (x<0.0 || y<0.0 || x>=width-1 || y>=height-1)
+			return 0;
+		else
+			return getInterpolatedPixel(x, y, pixels);
+	}
+
+	/** Stores the specified value at (x,y). */
+	public final void putPixel(int x, int y, int value) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			pixels[y*width + x] = value;
+	}
+
+	/** Stores the specified real grayscale value at (x,y).
+		Does nothing if (x,y) is outside the image boundary.
+		The value is clamped to be in the range 0-255. */
+	public void putPixelValue(int x, int y, double value) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			if (value>255.0)
+				value = 255;
+			else if (value<0.0)
+				value = 0.0;
+			int gray = (int)(value+0.5);
+			pixels[y*width + x] = 0xff000000 + (gray<<16) + (gray<<8) + gray;
+
+		}
+	}
+
+	/** Converts the specified pixel to grayscale using the
+		formula g=(r+g+b)/3 and returns it as a float. 
+		Call setWeightingFactors() to specify different conversion
+		factors. */
+	public float getPixelValue(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			int c = pixels[y*width+x];
+			int r = (c&0xff0000)>>16;
+			int g = (c&0xff00)>>8;
+			int b = c&0xff;
+			if (weights!=null)
+				return (float)(r*weights[0] + g*weights[1] + b*weights[2]);
+			else
+				return (float)(r*rWeight + g*gWeight + b*bWeight);
+		}
+		else 
+			return Float.NaN;
+	}
+
+
+	/** Draws a pixel in the current foreground color. */
+	public void drawPixel(int x, int y) {
+		if (x>=clipXMin && x<=clipXMax && y>=clipYMin && y<=clipYMax)
+			pixels[y*width + x] = fgColor;
+	}
+
+
+	/**	Returns a reference to the int array containing
+		this image's pixel data. */
+	public Object getPixels() {
+		return (Object)pixels;
+	}
+
+
+	public void setPixels(Object pixels) {
+		this.pixels = (int[])pixels;
+		resetPixels(pixels);
+		if (pixels==null)
+			snapshotPixels = null;
+		rgbRaster = null;
+		image = null;
+		caSnapshot = false;
+	}
+
+
+	/** Returns hue, saturation and brightness in 3 byte arrays. */
+	public void getHSB(byte[] H, byte[] S, byte[] B) {
+		int c, r, g, b;
+		float[] hsb = new float[3];
+		for (int i=0; i < width*height; i++) {
+			c = pixels[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			hsb = Color.RGBtoHSB(r, g, b, hsb);
+			H[i] = (byte)((int)(hsb[0]*255.0));
+			S[i] = (byte)((int)(hsb[1]*255.0));
+			B[i] = (byte)((int)(hsb[2]*255.0));
+		}
+	}
+	
+	/** Returns hue, saturation and brightness in 3 float arrays. */
+	public void getHSB(float[] H, float[] S, float[] B) {
+		int c, r, g, b;
+		float[] hsb = new float[3];
+		for (int i=0; i < width*height; i++) {
+			c = pixels[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			hsb = Color.RGBtoHSB(r, g, b, hsb);
+			H[i] = hsb[0];
+			S[i] = hsb[1];
+			B[i] = hsb[2];
+		}
+	}
+
+	/** Returns an ImageStack with three 8-bit slices,
+	    representing hue, saturation and brightness */
+	public ImageStack getHSBStack() {
+		int width = getWidth();
+		int height = getHeight();
+		byte[] H = new byte[width*height];
+		byte[] S = new byte[width*height];
+		byte[] B = new byte[width*height];
+		getHSB(H, S, B);
+		ColorModel cm = getDefaultColorModel();
+		ImageStack stack = new ImageStack(width, height, cm);
+		stack.addSlice("Hue", H);
+		stack.addSlice("Saturation", S);
+		stack.addSlice("Brightness", B);
+		return stack;
+	}
+
+	/** Returns an ImageStack with three 32-bit slices,
+	    representing hue, saturation and brightness */
+	public ImageStack getHSB32Stack() {
+		int width = getWidth();
+		int height = getHeight();
+		float[] H = new float[width*height];
+		float[] S = new float[width*height];
+		float[] B = new float[width*height];
+		getHSB(H, S, B);
+		ColorModel cm = getDefaultColorModel();
+		ImageStack stack = new ImageStack(width, height, cm);
+		stack.addSlice("Hue", H);
+		stack.addSlice("Saturation", S);
+		stack.addSlice("Brightness", B);
+		return stack;
+	}
+
+	/** Returns brightness as a FloatProcessor. */
+	public FloatProcessor getBrightness() {
+		int c, r, g, b;
+		int size = width*height;
+		float[] brightness = new float[size];
+		float[] hsb = new float[3];
+		for (int i=0; i<size; i++) {
+			c = pixels[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			hsb = Color.RGBtoHSB(r, g, b, hsb);
+			brightness[i] = hsb[2];
+		}
+		return new FloatProcessor(width, height, brightness, null);
+	}
+
+	/** Returns the red, green and blue planes as 3 byte arrays. */
+	public void getRGB(byte[] R, byte[] G, byte[] B) {
+		int c, r, g, b;
+		for (int i=0; i < width*height; i++) {
+			c = pixels[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			R[i] = (byte)r;
+			G[i] = (byte)g;
+			B[i] = (byte)b;
+		}
+	}
+
+	/** Returns the specified plane (1=red, 2=green, 3=blue, 4=alpha) as a byte array. */
+	public byte[] getChannel(int channel) {
+		ByteProcessor bp = getChannel(channel, null);
+		return (byte[])bp.getPixels();
+	}
+	
+	/** Returns the specified plane (1=red, 2=green, 3=blue, 4=alpha) as a ByteProcessor. */
+	public ByteProcessor getChannel(int channel, ByteProcessor bp) {
+		int size = width*height;
+		if (bp == null || bp.getWidth()!=width || bp.getHeight()!=height)
+			bp = new ByteProcessor(width, height);
+		byte[] bPixels = (byte[])bp.getPixels();
+		int shift = 16 - 8*(channel-1);
+		if (channel==4) shift=24;
+		for (int i=0; i<size; i++)
+			bPixels[i] = (byte)(pixels[i]>>shift);
+		return bp;
+	}
+	
+	/** Sets the pixels of one color channel from a ByteProcessor.
+	*  @param channel  Determines the color channel, 1=red, 2=green, 3=blue, 4=alpha
+	*  @param bp  The ByteProcessor where the image data are read from.
+	*/
+	public void setChannel(int channel, ByteProcessor bp) {
+		byte[] bPixels = (byte[])bp.getPixels();
+		int value;
+		int size = width*height;
+		int shift = 16 - 8*(channel-1);
+		if (channel==4) shift=24;
+		int resetMask = 0xffffffff^(255<<shift);
+		for (int i=0; i<size; i++)
+			pixels[i] = (pixels[i]&resetMask) | ((bPixels[i]&255)<<shift);
+	}
+
+	/** Sets the current pixels from 3 byte arrays (reg, green, blue). */
+	public void setRGB(byte[] R, byte[] G, byte[] B) {
+		int c, r, g, b;
+		for (int i=0; i < width*height; i++)
+			pixels[i] = 0xff000000 | ((R[i]&0xff)<<16) | ((G[i]&0xff)<<8) | B[i]&0xff;
+	}
+
+
+	/** Sets the current pixels from 3 byte arrays (hue, saturation and brightness). */
+	public void setHSB(byte[] H, byte[] S, byte[] B) {
+		float hue, saturation, brightness;
+		for (int i=0; i < width*height; i++) {
+			hue = (float)((H[i]&0xff)/255.0);
+			saturation = (float)((S[i]&0xff)/255.0);
+			brightness = (float)((B[i]&0xff)/255.0);
+			pixels[i] = Color.HSBtoRGB(hue, saturation, brightness);
+		}
+	}
+
+	/** Sets the current pixels from 3 float arrays (hue, saturation and brightness). */
+	public void setHSB(float[] H, float[] S, float[] B) {
+		for (int i=0; i < width*height; i++)
+			pixels[i] = Color.HSBtoRGB(H[i], S[i], B[i]);
+	}
+	
+	/** Updates the brightness using the pixels in the specified FloatProcessor). */
+	public void setBrightness(FloatProcessor fp) {
+		int c, r, g, b;
+		int size = width*height;
+		float[] hsb = new float[3];
+		float[] brightness = (float[])fp.getPixels();
+		if (brightness.length!=size)
+			throw new IllegalArgumentException("fp is wrong size");
+		for (int i=0; i<size; i++) {
+			c = pixels[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			hsb = Color.RGBtoHSB(r, g, b, hsb);
+			float bvalue = brightness[i];
+			if (bvalue<0f) bvalue = 0f;
+			if (bvalue>1.0f) bvalue = 1.0f;
+			pixels[i] = Color.HSBtoRGB(hsb[0], hsb[1], bvalue);
+		}
+	}
+	
+	/** Copies the image contained in 'ip' to (xloc, yloc) using one of
+		the transfer modes defined in the Blitter interface. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		ip = ip.convertToRGB();
+		new ColorBlitter(this).copyBits(ip, xloc, yloc, mode);
+	}
+
+	/* Filters start here */
+
+	public void applyTable(int[] lut) {
+		int c, r, g, b;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				c = pixels[i];
+				r = lut[(c&0xff0000)>>16];
+				g = lut[(c&0xff00)>>8];
+				b = lut[c&0xff];
+				pixels[i] = 0xff000000 + (r<<16) + (g<<8) + b;
+				i++;
+			}
+		}
+	}
+	
+	public void applyTable(int[] lut, int channels) {
+		int c, r=0, g=0, b=0;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				c = pixels[i];
+				if (channels==4) {
+					r = lut[(c&0xff0000)>>16];
+					g = (c&0xff00)>>8;
+					b = c&0xff;
+				} else if (channels==2) {
+					r = (c&0xff0000)>>16;
+					g = lut[(c&0xff00)>>8];
+					b = c&0xff;
+				} else if (channels==1) {
+					r = (c&0xff0000)>>16;
+					g = (c&0xff00)>>8;
+					b = lut[c&0xff];
+				} else if ((channels&6)==6) {
+					r = lut[(c&0xff0000)>>16];
+					g = lut[(c&0xff00)>>8];
+					b = c&0xff;
+				} else if ((channels&5)==5) {
+					r = lut[(c&0xff0000)>>16];
+					g = (c&0xff00)>>8;
+					b = lut[c&0xff];
+				} else if ((channels&3)==3) {
+					r = (c&0xff0000)>>16;
+					g = lut[(c&0xff00)>>8];
+					b = lut[c&0xff];
+				}
+				pixels[i] = 0xff000000 + (r<<16) + (g<<8) + b;
+				i++;
+			}
+		}
+	}
+
+	/** Fills the current rectangular ROI. */
+	public void fill() {
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++)
+				pixels[i++] = fgColor;
+		}
+	}
+	
+	public static final int RGB_NOISE=0, RGB_MEDIAN=1, RGB_FIND_EDGES=2,
+		RGB_ERODE=3, RGB_DILATE=4, RGB_THRESHOLD=5, RGB_ROTATE=6,
+		RGB_SCALE=7, RGB_RESIZE=8, RGB_TRANSLATE=9, RGB_MIN=10, RGB_MAX=11;
+
+ 	/** Performs the specified filter on the red, green and blue planes of this image. */
+ 	public void filterRGB(int type, double arg) {
+ 		filterRGB(type, arg, 0.0);
+ 	}
+
+ 	final ImageProcessor filterRGB(int type, double arg, double arg2) {
+		showProgress(0.01);
+		byte[] R = new byte[width*height];
+		byte[] G = new byte[width*height];
+		byte[] B = new byte[width*height];
+		getRGB(R, G, B);
+		Rectangle roi = new Rectangle(roiX, roiY, roiWidth, roiHeight);
+		
+		ByteProcessor r = new ByteProcessor(width, height, R, null);
+		r.setRoi(roi);
+		ByteProcessor g = new ByteProcessor(width, height, G, null);
+		g.setRoi(roi);
+		ByteProcessor b = new ByteProcessor(width, height, B, null);
+		b.setRoi(roi);
+		r.setBackgroundValue((bgColor&0xff0000)>>16);
+		g.setBackgroundValue((bgColor&0xff00)>>8);
+		b.setBackgroundValue(bgColor&0xff);
+		r.setInterpolationMethod(interpolationMethod);
+		g.setInterpolationMethod(interpolationMethod);
+		b.setInterpolationMethod(interpolationMethod);
+		
+		showProgress(0.15);
+		switch (type) {
+			case RGB_NOISE:
+				r.noise(arg); showProgress(0.40);
+				g.noise(arg); showProgress(0.65);
+				b.noise(arg); showProgress(0.90);
+				break;
+			case RGB_MEDIAN:
+				r.medianFilter(); showProgress(0.40);
+				g.medianFilter(); showProgress(0.65);
+				b.medianFilter(); showProgress(0.90);
+				break;
+			case RGB_FIND_EDGES:
+				r.findEdges(); showProgress(0.40);
+				g.findEdges(); showProgress(0.65);
+				b.findEdges(); showProgress(0.90);
+				break;
+			case RGB_ERODE:
+				r.erode(); showProgress(0.40);
+				g.erode(); showProgress(0.65);
+				b.erode(); showProgress(0.90);
+				break;
+			case RGB_DILATE:
+				r.dilate(); showProgress(0.40);
+				g.dilate(); showProgress(0.65);
+				b.dilate(); showProgress(0.90);
+				break;
+			case RGB_THRESHOLD:
+				r.autoThreshold(); showProgress(0.40);
+				g.autoThreshold(); showProgress(0.65);
+				b.autoThreshold(); showProgress(0.90);
+				break;
+			case RGB_ROTATE:
+				ij.IJ.showStatus("Rotating red");
+				r.rotate(arg); showProgress(0.40);
+				ij.IJ.showStatus("Rotating green");
+				g.rotate(arg); showProgress(0.65);
+				ij.IJ.showStatus("Rotating blue");
+				b.rotate(arg); showProgress(0.90);
+				break;
+			case RGB_SCALE:
+				ij.IJ.showStatus("Scaling red");
+				r.scale(arg, arg2); showProgress(0.40);
+				ij.IJ.showStatus("Scaling green");
+				g.scale(arg, arg2); showProgress(0.65);
+				ij.IJ.showStatus("Scaling blue");
+				b.scale(arg, arg2); showProgress(0.90);
+				break;
+			case RGB_RESIZE:
+				int w=(int)arg, h=(int)arg2;
+				ij.IJ.showStatus("Resizing red");
+				ImageProcessor r2 = r.resize(w, h); showProgress(0.40);
+				ij.IJ.showStatus("Resizing green");
+				ImageProcessor g2 = g.resize(w, h); showProgress(0.65);
+				ij.IJ.showStatus("Resizing blue");
+				ImageProcessor b2 = b.resize(w, h); showProgress(0.90);
+				R = (byte[])r2.getPixels();
+				G = (byte[])g2.getPixels();
+				B = (byte[])b2.getPixels();
+				ColorProcessor ip2 = new ColorProcessor(w, h);
+				ip2.setRGB(R, G, B);
+				showProgress(1.0);
+				return ip2;
+			case RGB_TRANSLATE:
+				ij.IJ.showStatus("Translating red");
+				r.translate(arg, arg2); showProgress(0.40);
+				ij.IJ.showStatus("Translating green");
+				g.translate(arg, arg2); showProgress(0.65);
+				ij.IJ.showStatus("Translating blue");
+				b.translate(arg, arg2); showProgress(0.90);
+				break;
+			case RGB_MIN:
+				r.filter(MIN); showProgress(0.40);
+				g.filter(MIN); showProgress(0.65);
+				b.filter(MIN); showProgress(0.90);
+				break;
+			case RGB_MAX:
+				r.filter(MAX); showProgress(0.40);
+				g.filter(MAX); showProgress(0.65);
+				b.filter(MAX); showProgress(0.90);
+				break;
+		}
+		
+		R = (byte[])r.getPixels();
+		G = (byte[])g.getPixels();
+		B = (byte[])b.getPixels();
+		
+		setRGB(R, G, B);
+		showProgress(1.0);
+		return null;
+	}
+
+	public void noise(double range) {
+		filterRGB(RGB_NOISE, range);
+	}
+
+	public void medianFilter() {
+    	filterRGB(RGB_MEDIAN, 0.0);
+	}
+	
+	public void findEdges() {
+    	filterRGB(RGB_FIND_EDGES, 0.0);
+	}		
+		
+	public void erode() {
+    	filterRGB(RGB_ERODE, 0.0);
+	}
+			
+	public void dilate() {
+    	filterRGB(RGB_DILATE, 0.0);
+
+	}
+			
+	public void autoThreshold() {
+   		filterRGB(RGB_THRESHOLD, 0.0);
+	}
+	
+	/** Scales the image or selection using the specified scale factors.
+		@see ImageProcessor#setInterpolate
+	*/
+	public void scale(double xScale, double yScale) {
+        if (interpolationMethod==BICUBIC) {
+        	filterRGB(RGB_SCALE, xScale, yScale);
+        	return;
+        }
+		double xCenter = roiX + roiWidth/2.0;
+		double yCenter = roiY + roiHeight/2.0;
+		int xmin, xmax, ymin, ymax;
+		
+		if ((xScale>1.0) && (yScale>1.0)) {
+			//expand roi
+			xmin = (int)(xCenter-(xCenter-roiX)*xScale);
+			if (xmin<0) xmin = 0;
+			xmax = xmin + (int)(roiWidth*xScale) - 1;
+			if (xmax>=width) xmax = width - 1;
+			ymin = (int)(yCenter-(yCenter-roiY)*yScale);
+			if (ymin<0) ymin = 0;
+			ymax = ymin + (int)(roiHeight*yScale) - 1;
+			if (ymax>=height) ymax = height - 1;
+		} else {
+			xmin = roiX;
+			xmax = roiX + roiWidth - 1;
+			ymin = roiY;
+			ymax = roiY + roiHeight - 1;
+		}
+		int[] pixels2 = (int[])getPixelsCopy();
+		boolean checkCoordinates = (xScale < 1.0) || (yScale < 1.0);
+		int index1, index2, xsi, ysi;
+		double ys, xs;
+		double xlimit = width-1.0, xlimit2 = width-1.001;
+		double ylimit = height-1.0, ylimit2 = height-1.001;
+		for (int y=ymin; y<=ymax; y++) {
+			ys = (y-yCenter)/yScale + yCenter;
+			ysi = (int)ys;
+			if (ys<0.0) ys = 0.0;			
+			if (ys>=ylimit) ys = ylimit2;
+			index1 = y*width + xmin;
+			index2 = width*(int)ys;
+			for (int x=xmin; x<=xmax; x++) {
+				xs = (x-xCenter)/xScale + xCenter;
+				xsi = (int)xs;
+				if (checkCoordinates && ((xsi<xmin) || (xsi>xmax) || (ysi<ymin) || (ysi>ymax)))
+					pixels[index1++] = bgColor;
+				else {
+					if (interpolationMethod==BILINEAR) {
+						if (xs<0.0) xs = 0.0;
+						if (xs>=xlimit) xs = xlimit2;
+						pixels[index1++] = getInterpolatedPixel(xs, ys, pixels2);
+					} else
+						pixels[index1++] = pixels2[index2+xsi];
+				}
+			}
+			if (y%20==0)
+			showProgress((double)(y-ymin)/height);
+		}
+		showProgress(1.0);
+	}
+
+	public ImageProcessor crop() {
+		int[] pixels2 = new int[roiWidth*roiHeight];
+		for (int ys=roiY; ys<roiY+roiHeight; ys++) {
+			int offset1 = (ys-roiY)*roiWidth;
+			int offset2 = ys*width+roiX;
+			for (int xs=0; xs<roiWidth; xs++)
+				pixels2[offset1++] = pixels[offset2++];
+		}
+		ColorProcessor cp2 = new ColorProcessor(roiWidth, roiHeight, pixels2);
+		return cp2;
+	}
+	
+	/** Returns a duplicate of this image. */ 
+	public ImageProcessor duplicate() { 
+		int[] pixels2 = new int[width*height]; 
+		System.arraycopy(pixels, 0, pixels2, 0, width*height); 
+		return new ColorProcessor(width, height, pixels2); 
+	} 
+
+	/** Uses bilinear interpolation to find the pixel value at real coordinates (x,y). */
+	public int getInterpolatedRGBPixel(double x, double y) {
+		if (width==1||height==1)
+			return getPixel((int)x, (int)y);
+		if (x<0.0) x = 0.0;
+		if (x>=width-1.0)
+			x = width-1.001;
+		if (y<0.0) y = 0.0;
+		if (y>=height-1.0) y = height-1.001;
+		return getInterpolatedPixel(x, y, pixels);
+	}
+
+	/** Uses bilinear interpolation to find the pixel value at real coordinates (x,y). */
+	private final int getInterpolatedPixel(double x, double y, int[] pixels) {
+		int xbase = (int)x;
+		int ybase = (int)y;
+		double xFraction = x - xbase;
+		double yFraction = y - ybase;
+		int offset = ybase * width + xbase;
+		
+		int lowerLeft = pixels[offset];
+		int rll = (lowerLeft&0xff0000)>>16;
+		int gll = (lowerLeft&0xff00)>>8;
+		int bll = lowerLeft&0xff;
+		
+		int lowerRight = pixels[offset + 1];
+		int rlr = (lowerRight&0xff0000)>>16;
+		int glr = (lowerRight&0xff00)>>8;
+		int blr = lowerRight&0xff;
+
+		int upperRight = pixels[offset + width + 1];
+		int rur = (upperRight&0xff0000)>>16;
+		int gur = (upperRight&0xff00)>>8;
+		int bur = upperRight&0xff;
+
+		int upperLeft = pixels[offset + width];
+		int rul = (upperLeft&0xff0000)>>16;
+		int gul = (upperLeft&0xff00)>>8;
+		int bul = upperLeft&0xff;
+		
+		int r, g, b;
+		double upperAverage, lowerAverage;
+		upperAverage = rul + xFraction * (rur - rul);
+		lowerAverage = rll + xFraction * (rlr - rll);
+		r = (int)(lowerAverage + yFraction * (upperAverage - lowerAverage)+0.5);
+		upperAverage = gul + xFraction * (gur - gul);
+		lowerAverage = gll + xFraction * (glr - gll);
+		g = (int)(lowerAverage + yFraction * (upperAverage - lowerAverage)+0.5);
+		upperAverage = bul + xFraction * (bur - bul);
+		lowerAverage = bll + xFraction * (blr - bll);
+		b = (int)(lowerAverage + yFraction * (upperAverage - lowerAverage)+0.5);
+
+		return 0xff000000 | ((r&0xff)<<16) | ((g&0xff)<<8) | b&0xff;
+	}
+
+	/** Creates a new ColorProcessor containing a scaled copy of this image or selection.
+		@see ImageProcessor#setInterpolate
+	*/
+	public ImageProcessor resize(int dstWidth, int dstHeight) {
+		if (roiWidth==dstWidth && roiHeight==dstHeight)
+			return crop();
+		if (interpolationMethod!=NONE && (width==1||height==1)) {
+				ByteProcessor r2 = (ByteProcessor)getChannel(1,null).resizeLinearly(dstWidth, dstHeight);
+				ByteProcessor g2 = (ByteProcessor)getChannel(2,null).resizeLinearly(dstWidth, dstHeight);
+				ByteProcessor b2 = (ByteProcessor)getChannel(3,null).resizeLinearly(dstWidth, dstHeight);
+				ColorProcessor ip2 = new ColorProcessor(dstWidth, dstHeight);
+				ip2.setChannel(1, r2); ip2.setChannel(2, g2); ip2.setChannel(3, b2);
+				return ip2;
+		}
+        if (interpolationMethod==BICUBIC)
+        	return filterRGB(RGB_RESIZE, dstWidth, dstHeight);
+		double srcCenterX = roiX + roiWidth/2.0;
+		double srcCenterY = roiY + roiHeight/2.0;
+		double dstCenterX = dstWidth/2.0;
+		double dstCenterY = dstHeight/2.0;
+		double xScale = (double)dstWidth/roiWidth;
+		double yScale = (double)dstHeight/roiHeight;
+		double xlimit = width-1.0, xlimit2 = width-1.001;
+		double ylimit = height-1.0, ylimit2 = height-1.001;
+		if (interpolationMethod==BILINEAR) {
+			if (dstWidth!=width) dstCenterX+=xScale/4.0;
+			if (dstHeight!=height) dstCenterY+=yScale/4.0;
+		}
+		ImageProcessor ip2 = createProcessor(dstWidth, dstHeight);
+		int[] pixels2 = (int[])ip2.getPixels();
+		double xs, ys;
+		int index1, index2;
+		for (int y=0; y<=dstHeight-1; y++) {
+			ys = (y-dstCenterY)/yScale + srcCenterY;
+			if (interpolationMethod==BILINEAR) {
+				if (ys<0.0) ys = 0.0;
+				if (ys>=ylimit) ys = ylimit2;
+			}
+			index1 = width*(int)ys;
+			index2 = y*dstWidth;
+			for (int x=0; x<=dstWidth-1; x++) {
+				xs = (x-dstCenterX)/xScale + srcCenterX;
+				if (interpolationMethod==BILINEAR) {
+					if (xs<0.0) xs = 0.0;
+					if (xs>=xlimit) xs = xlimit2;
+					pixels2[index2++] = getInterpolatedPixel(xs, ys, pixels);
+				} else
+		  			pixels2[index2++] = pixels[index1+(int)xs];
+			}
+			if (y%20==0)
+			showProgress((double)y/dstHeight);
+		}
+		showProgress(1.0);
+		return ip2;
+	}
+	
+	/** Uses averaging to creates a new ColorProcessor containing 
+		a downsized copy of this image or selection. */
+	public ImageProcessor makeThumbnail(int width2, int height2, double smoothFactor) {
+		return resize(width2, height2, true);
+	}
+
+	/** Rotates the image or ROI 'angle' degrees clockwise.
+		@see ImageProcessor#setInterpolationMethod
+	*/
+	public void rotate(double angle) {
+        if (angle%360==0)
+        	return;
+        if (interpolationMethod==BICUBIC) {
+        	filterRGB(RGB_ROTATE, angle);
+        	return;
+        }
+		int[] pixels2 = (int[])getPixelsCopy();
+		double centerX = roiX + (roiWidth-1)/2.0;
+		double centerY = roiY + (roiHeight-1)/2.0;
+		int xMax = roiX + this.roiWidth - 1;
+		
+		double angleRadians = -angle/(180.0/Math.PI);
+		double ca = Math.cos(angleRadians);
+		double sa = Math.sin(angleRadians);
+		double tmp1 = centerY*sa-centerX*ca;
+		double tmp2 = -centerX*sa-centerY*ca;
+		double tmp3, tmp4, xs, ys;
+		int index, ixs, iys;
+		double dwidth = width, dheight=height;
+		double xlimit = width-1.0, xlimit2 = width-1.001;
+		double ylimit = height-1.0, ylimit2 = height-1.001;
+		
+		for (int y=roiY; y<(roiY + roiHeight); y++) {
+			index = y*width + roiX;
+			tmp3 = tmp1 - y*sa + centerX;
+			tmp4 = tmp2 + y*ca + centerY;
+			for (int x=roiX; x<=xMax; x++) {
+				xs = x*ca + tmp3;
+				ys = x*sa + tmp4;
+				if ((xs>=-0.01) && (xs<dwidth) && (ys>=-0.01) && (ys<dheight)) {
+					if (interpolationMethod==BILINEAR) {
+						if (xs<0.0) xs = 0.0;
+						if (xs>=xlimit) xs = xlimit2;
+						if (ys<0.0) ys = 0.0;			
+						if (ys>=ylimit) ys = ylimit2;
+				  		pixels[index++] = getInterpolatedPixel(xs, ys, pixels2);
+				  	} else {
+				  		ixs = (int)(xs+0.5);
+				  		iys = (int)(ys+0.5);
+				  		if (ixs>=width) ixs = width - 1;
+				  		if (iys>=height) iys = height -1;
+						pixels[index++] = pixels2[width*iys+ixs];
+					}
+				} else
+					pixels[index++] = bgColor;
+			}
+			if (y%30==0)
+			showProgress((double)(y-roiY)/roiHeight);
+		}
+		showProgress(1.0);
+	}
+	
+	public void flipVertical() {
+		int index1,index2;
+		int tmp;
+		for (int y=0; y<roiHeight/2; y++) {
+			index1 = (roiY+y)*width+roiX;
+			index2 = (roiY+roiHeight-1-y)*width+roiX;
+			for (int i=0; i<roiWidth; i++) {
+				tmp = pixels[index1];
+				pixels[index1++] = pixels[index2];
+				pixels[index2++] = tmp;
+			}
+		}
+	}
+	
+	/** 3x3 convolution contributed by Glynne Casteel. */
+	public void convolve3x3(int[] kernel) {
+		int p1, p2, p3, p4, p5, p6, p7, p8, p9;
+		int k1=kernel[0], k2=kernel[1], k3=kernel[2],
+		    k4=kernel[3], k5=kernel[4], k6=kernel[5],
+		    k7=kernel[6], k8=kernel[7], k9=kernel[8];
+
+		int scale = 0;
+		for (int i=0; i<kernel.length; i++)
+			scale += kernel[i];
+		if (scale==0) scale = 1;
+		int inc = roiHeight/25;
+		if (inc<1) inc = 1;
+		
+		int[] pixels2 = (int[])getPixelsCopy();
+		int offset;
+		int rsum = 0, gsum = 0, bsum = 0;
+        int rowOffset = width;
+		for (int y=yMin; y<=yMax; y++) {
+			offset = xMin + y * width;
+			p1 = 0;
+			p2 = pixels2[offset-rowOffset-1];
+			p3 = pixels2[offset-rowOffset];
+			p4 = 0;
+			p5 = pixels2[offset-1];
+			p6 = pixels2[offset];
+			p7 = 0;
+			p8 = pixels2[offset+rowOffset-1];
+			p9 = pixels2[offset+rowOffset];
+
+			for (int x=xMin; x<=xMax; x++) {
+				p1 = p2; p2 = p3;
+				p3 = pixels2[offset-rowOffset+1];
+				p4 = p5; p5 = p6;
+				p6 = pixels2[offset+1];
+				p7 = p8; p8 = p9;
+				p9 = pixels2[offset+rowOffset+1];
+
+				rsum = k1*((p1 & 0xff0000) >> 16)
+				     + k2*((p2 & 0xff0000) >> 16)
+				     + k3*((p3 & 0xff0000) >> 16)
+				     + k4*((p4 & 0xff0000) >> 16)
+				     + k5*((p5 & 0xff0000) >> 16)
+				     + k6*((p6 & 0xff0000) >> 16)
+				     + k7*((p7 & 0xff0000) >> 16)
+				     + k8*((p8 & 0xff0000) >> 16)
+				     + k9*((p9 & 0xff0000) >> 16);
+				rsum /= scale;
+				if(rsum>255) rsum = 255;
+				if(rsum<0) rsum = 0;
+
+				gsum = k1*((p1 & 0xff00) >> 8)
+				     + k2*((p2 & 0xff00) >> 8)
+				     + k3*((p3 & 0xff00) >> 8)
+				     + k4*((p4 & 0xff00) >> 8)
+				     + k5*((p5 & 0xff00) >> 8)
+				     + k6*((p6 & 0xff00) >> 8)
+				     + k7*((p7 & 0xff00) >> 8)
+				     + k8*((p8 & 0xff00) >> 8)
+				     + k9*((p9 & 0xff00) >> 8);
+				gsum /= scale;
+				if(gsum>255) gsum = 255;
+				else if(gsum<0) gsum = 0;
+
+				bsum = k1*(p1 & 0xff)
+				     + k2*(p2 & 0xff)
+				     + k3*(p3 & 0xff)
+				     + k4*(p4 & 0xff)
+				     + k5*(p5 & 0xff)
+				     + k6*(p6 & 0xff)
+				     + k7*(p7 & 0xff)
+				     + k8*(p8 & 0xff)
+				     + k9*(p9 & 0xff);
+				bsum /= scale;
+				if (bsum>255) bsum = 255;
+				if (bsum<0) bsum = 0; 
+
+				pixels[offset++] = 0xff000000
+				                 | ((rsum << 16) & 0xff0000)
+				                 | ((gsum << 8 ) & 0xff00)
+				                 |  (bsum        & 0xff);
+			}
+			if (y%inc==0)
+				showProgress((double)(y-roiY)/roiHeight);
+		}
+		showProgress(1.0);
+	}
+
+	/** A 3x3 filter operation, where the argument (ImageProcessor.BLUR_MORE,  FIND_EDGES, 
+	     MEDIAN_FILTER, MIN or MAX) determines the filter type. */
+	public void filter(int type) {
+		if (type == FIND_EDGES)
+			filterRGB(RGB_FIND_EDGES, 0, 0);
+		else if (type == MEDIAN_FILTER)
+			filterRGB(RGB_MEDIAN, 0, 0);
+		else if (type == MIN)
+			filterRGB(RGB_MIN, 0, 0);
+		else if (type == MAX)
+			filterRGB(RGB_MAX, 0, 0);
+		else
+		    blurMore();
+	}
+
+	/** BLUR MORE: 3x3 unweighted smoothing is implemented directly, does not convert the image to three ByteProcessors. */
+	private void blurMore() {
+		int p1 = 0, p2, p3, p4 = 0, p5, p6, p7 = 0, p8, p9;
+		
+		int[] prevRow = new int[width];
+		int[] thisRow = new int[width];
+		int[] nextRow = new int[width];
+		System.arraycopy(pixels, Math.max(roiY-1,0)*width, thisRow, 0, width);
+		System.arraycopy(pixels, roiY*width, nextRow, 0, width);
+		for (int y=roiY; y<roiY+roiHeight; y++) {
+			int[] tmp = prevRow;
+			prevRow = thisRow;
+			thisRow = nextRow;
+			nextRow = tmp;
+			if (y < height-1)
+				System.arraycopy(pixels, (y+1)*width, nextRow, 0, width);
+			else
+				nextRow = thisRow;
+			int offset = roiX + y*width;
+
+			p2 = prevRow[roiX==0 ? roiX : roiX-1];
+			p3 = prevRow[roiX];
+			p5 = thisRow[roiX==0 ? roiX : roiX-1];
+			p6 = thisRow[roiX];
+			p8 = nextRow[roiX==0 ? roiX : roiX-1];
+			p9 = nextRow[roiX];
+
+			for (int x=roiX; x<roiX+roiWidth; x++) {
+				p1 = p2; p2 = p3;
+				p4 = p5; p5 = p6;
+				p7 = p8; p8 = p9;
+				if (x < width-1) {
+					p3 = prevRow[x+1];
+					p6 = thisRow[x+1];
+					p9 = nextRow[x+1];
+				}
+				int rsum = (p1 & 0xff0000) + (p2 & 0xff0000) + (p3 & 0xff0000) + (p4 & 0xff0000) + (p5 & 0xff0000)
+					+ (p6 & 0xff0000) + (p7 & 0xff0000) + (p8 & 0xff0000) + (p9 & 0xff0000);
+				int gsum = (p1 & 0xff00) + (p2 & 0xff00) + (p3 & 0xff00) + (p4 & 0xff00) + (p5 & 0xff00)
+					+ (p6 & 0xff00) + (p7 & 0xff00) + (p8 & 0xff00) + (p9 & 0xff00);
+				int bsum = (p1 & 0xff) + (p2 & 0xff) + (p3 & 0xff) + (p4 & 0xff) + (p5 & 0xff)
+					+ (p6 & 0xff) + (p7 & 0xff) + (p8 & 0xff) + (p9 & 0xff);
+				pixels[offset++] = 0xff000000 | (((rsum+(4<<16))/9) & 0xff0000) | (((gsum+(4<<8))/9) & 0xff00) | ((bsum+4)/9);
+			}
+			if (roiHeight*roiWidth>1000000 && (y&0xff)==0)
+				showProgress((double)(y-roiY)/roiHeight);
+		}
+		showProgress(1.0);
+	}
+
+	public int[] getHistogram() {
+		if (mask!=null)
+			return getHistogram(mask);
+		double rw=rWeight, gw=gWeight, bw=bWeight;
+		if (weights!=null)
+			{rw=weights[0]; gw=weights[1]; bw=weights[2];}
+		int c, r, g, b, v;
+		int[] histogram = new int[256];
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				c = pixels[i++];
+				r = (c&0xff0000)>>16;
+				g = (c&0xff00)>>8;
+				b = c&0xff;
+				v = (int)(r*rw + g*gw + b*bw + 0.5);
+				histogram[v]++;
+			}
+		}
+		return histogram;
+	}
+
+
+	public int[] getHistogram(ImageProcessor mask) {
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		double rw=rWeight, gw=gWeight, bw=bWeight;
+		if (weights!=null)
+			{rw=weights[0]; gw=weights[1]; bw=weights[2];}
+		byte[] mpixels = (byte[])mask.getPixels();
+		int c, r, g, b, v;
+		int[] histogram = new int[256];
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]!=0) {
+					c = pixels[i];
+					r = (c&0xff0000)>>16;
+					g = (c&0xff00)>>8;
+					b = c&0xff;
+					v = (int)(r*rw + g*gw + b*bw + 0.5);
+					histogram[v]++;
+				}
+				i++;
+			}
+		}
+		return histogram;
+	}
+
+	public synchronized boolean weightedHistogram() {
+		if (weights!=null && (weights[0]!=1d/3d||weights[1]!=1d/3d||weights[2]!=1d/3d))
+			return true;
+		if (rWeight!=1d/3d || gWeight!=1d/3d || bWeight!=1d/3d)
+			return true;
+		return false;
+	}
+
+	/** Performs a convolution operation using the specified kernel. */
+	public void convolve(float[] kernel, int kernelWidth, int kernelHeight) {
+		int size = width*height;
+		byte[] r = new byte[size];
+		byte[] g = new byte[size];
+		byte[] b = new byte[size];
+		getRGB(r,g,b);
+		ImageProcessor rip = new ByteProcessor(width, height, r, null);
+		ImageProcessor gip = new ByteProcessor(width, height, g, null);
+		ImageProcessor bip = new ByteProcessor(width, height, b, null);
+		ImageProcessor ip2 = rip.convertToFloat();
+		Rectangle roi = getRoi();
+		ip2.setRoi(roi);
+		ip2.convolve(kernel, kernelWidth, kernelHeight);
+		ImageProcessor r2 = ip2.convertToByte(false);
+		ip2 = gip.convertToFloat();
+		ip2.setRoi(roi);
+		ip2.convolve(kernel, kernelWidth, kernelHeight);
+		ImageProcessor g2 = ip2.convertToByte(false);
+		ip2 = bip.convertToFloat();
+		ip2.setRoi(roi);
+		ip2.convolve(kernel, kernelWidth, kernelHeight);
+		ImageProcessor b2 = ip2.convertToByte(false);
+		setRGB((byte[])r2.getPixels(), (byte[])g2.getPixels(), (byte[])b2.getPixels());
+   	}
+
+	/** Sets the weighting factors used by getPixelValue(), getHistogram()
+		and convertToByte() to do color conversions. The default values are
+		1/3, 1/3 and 1/3. Check "Weighted RGB Conversions" in
+		<i>Edit/Options/Conversions</i> to use 0.299, 0.587 and 0.114.
+		@see #getWeightingFactors
+		@see #setRGBWeights
+	*/
+	public static void setWeightingFactors(double rFactor, double gFactor, double bFactor) {
+		rWeight = rFactor;
+		gWeight = gFactor;
+		bWeight = bFactor;
+	}
+
+	/** Returns the three weighting factors used by getPixelValue(), 
+		getHistogram() and convertToByte() to do color conversions.
+		@see #setWeightingFactors
+		@see #getRGBWeights
+	*/
+	public static double[] getWeightingFactors() {
+		double[] weights = new double[3];
+		weights[0] = rWeight;
+		weights[1] = gWeight;
+		weights[2] = bWeight;
+		return weights;
+	}
+	
+	/** This is a thread-safe (non-static) version of setWeightingFactors(). */
+	public void setRGBWeights(double rweight, double gweight, double bweight) {
+		weights = new double[3];
+		weights[0] = rweight;
+		weights[1] = gweight;
+		weights[2] = bweight;
+	}
+
+	/** This is a thread-safe (non-static) version of setWeightingFactors(). */
+	public void setRGBWeights(double[] weights) {
+		this.weights = weights;
+	}
+	
+	/** Returns the values set by setRGBWeights(), or null if setRGBWeights() has not been called. */
+	public double[] getRGBWeights() {
+		return weights;
+	}
+
+	/** Always returns false since RGB images do not use LUTs. */
+	public boolean isInvertedLut() {
+		return false;
+	}
+	
+	/** Returns 'true' if this is a grayscale image. */
+	public final boolean isGrayscale() {
+		int c, r, g, b;
+		for (int i=0; i<pixels.length; i++) {
+			c = pixels[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			if (r!=g || r!=b) return false;
+		}
+		return true;
+	}
+
+	/** Always returns 0 since RGB images do not use LUTs. */
+	public int getBestIndex(Color c) {
+		return 0;
+	}
+	
+	/** Does nothing since RGB images do not use LUTs. */
+	public void invertLut() {
+	}
+	
+	public void updateComposite(int[] rgbPixels, int channel) {
+	}
+
+	/** Not implemented. */
+	public void threshold(int level) {}
+	
+	/** Returns the number of color channels (3). */
+	public int getNChannels() {
+		return 3;
+	}
+	
+	/** Returns a FloatProcessor with one color channel of the image.
+	*  The roi and mask are also set for the FloatProcessor.
+	*  @param channelNumber   Determines the color channel, 0=red, 1=green, 2=blue
+	*  @param fp              Here a FloatProcessor can be supplied, or null. The FloatProcessor
+	*                         is overwritten by this method (re-using its pixels array 
+	*                         improves performance).
+	*  @return A FloatProcessor with the converted image data of the color channel selected
+	*/
+	public FloatProcessor toFloat(int channelNumber, FloatProcessor fp) {
+		int size = width*height;
+		if (fp == null || fp.getWidth()!=width || fp.getHeight()!=height)
+			fp = new FloatProcessor(width, height, new float[size], null);
+		float[] fPixels = (float[])fp.getPixels();
+		int shift = 16 - 8*channelNumber;
+		int byteMask = 255<<shift;
+		for (int i=0; i<size; i++)
+			fPixels[i] = (pixels[i]&byteMask)>>shift;
+		fp.setRoi(getRoi());
+		fp.setMask(mask);
+		fp.setMinAndMax(0, 255);
+		return fp;
+	}
+	
+	/** Sets the pixels of one color channel from a FloatProcessor.
+	*  @param channelNumber   Determines the color channel, 0=red, 1=green, 2=blue
+	*  @param fp              The FloatProcessor where the image data are read from.
+	*/
+	public void setPixels(int channelNumber, FloatProcessor fp) {
+		float[] fPixels = (float[])fp.getPixels();
+		float value;
+		int size = width*height;
+		int shift = 16 - 8*channelNumber;
+		int resetMask = 0xffffffff^(255<<shift);
+		for (int i=0; i<size; i++) {
+			value = fPixels[i] + 0.5f;
+			if (value<0f) value = 0f;
+			if (value>255f) value = 255f;
+			pixels[i] = (pixels[i]&resetMask) | ((int)value<<shift);
+		}
+	}
+	
+	public int getBitDepth() {
+		return 24;
+	}
+
+}
+
diff --git a/src/ij/process/ColorSpaceConverter.java b/src/ij/process/ColorSpaceConverter.java
new file mode 100644
index 0000000..a63176f
--- /dev/null
+++ b/src/ij/process/ColorSpaceConverter.java
@@ -0,0 +1,484 @@
+package ij.process;
+import ij.*;
+import ij.process.*;
+import java.awt.Color;
+
+/**
+* ColorSpaceConverter
+* @author dvs, hlp
+* Created Jan 15, 2004
+* Version 3 posted on ImageJ Mar 12, 2006 by Duane Schwartzwald
+*	vonschwartzwalder at mac.com
+* Version 4 created Feb. 27, 2007
+*   by Harry Parker, harrylparker at yahoo dot com,
+*   corrects RGB to XYZ (and LAB) conversion.
+*/
+public class ColorSpaceConverter {
+
+	/**
+	 * reference white in XYZ coordinates
+	 */
+	public double[] D50 = {96.4212, 100.0, 82.5188};
+	public double[] D55 = {95.6797, 100.0, 92.1481};
+	public double[] D65 = {95.0429, 100.0, 108.8900};
+	public double[] D75 = {94.9722, 100.0, 122.6394};
+	public double[] whitePoint = D65;
+
+	/**
+	 * reference white in xyY coordinates
+	 */
+	public double[] chromaD50 = {0.3457, 0.3585, 100.0};
+	public double[] chromaD55 = {0.3324, 0.3474, 100.0};
+	public double[] chromaD65 = {0.3127, 0.3290, 100.0};
+	public double[] chromaD75 = {0.2990, 0.3149, 100.0};
+	public double[] chromaWhitePoint = chromaD65;
+
+	/**
+	 * sRGB to XYZ conversion matrix
+	 */
+	public double[][] M = {{0.4124, 0.3576,  0.1805},
+							 {0.2126, 0.7152,  0.0722},
+							 {0.0193, 0.1192,  0.9505}};
+
+	/**
+	 * XYZ to sRGB conversion matrix
+	 */
+	public double[][] Mi = {{ 3.2406, -1.5372, -0.4986},
+							 {-0.9689,	1.8758,	 0.0415},
+							 { 0.0557, -0.2040,	 1.0570}};
+
+	/**
+	 * Default constructor; uses D65 for the white point
+	 */
+	public ColorSpaceConverter() {
+	  whitePoint = D65;
+	  chromaWhitePoint = chromaD65;
+	}
+
+	/**
+	 * Constructor for setting a non-default white point
+	 * @param white "d50", "d55", "d65" or "d75"
+	 */
+	public ColorSpaceConverter(String white) {
+		whitePoint = D65;
+		chromaWhitePoint = chromaD65;
+		if (white.equalsIgnoreCase("d50")) {
+			whitePoint = D50;
+			chromaWhitePoint = chromaD50;
+		} else if (white.equalsIgnoreCase("d55")) {
+			whitePoint = D55;
+			chromaWhitePoint = chromaD55;
+		} else if (white.equalsIgnoreCase("d65")) {
+			whitePoint = D65;
+			chromaWhitePoint = chromaD65;
+		} else if (white.equalsIgnoreCase("d75")) {
+			whitePoint = D75;
+			chromaWhitePoint = chromaD75;
+		} else
+			throw new IllegalArgumentException("Invalid white point");
+	}
+
+	/**
+	 * @param H Hue angle/360 (0..1)
+	 * @param S Saturation (0..1)
+	 * @param B Value (0..1)
+	 * @return RGB values
+	 */
+	public int[] HSBtoRGB(double H, double S, double B) {
+	  int[] result = new int[3];
+	  int rgb = Color.HSBtoRGB((float) H, (float) S, (float) B);
+	  result[0] = (rgb >> 16) & 0xff;
+	  result[1] = (rgb >> 8) & 0xff;
+	  result[2] = (rgb >> 0) & 0xff;
+	  return result;
+	}
+
+	public int[] HSBtoRGB(double[] HSB) {
+	  return HSBtoRGB(HSB[0], HSB[1], HSB[2]);
+	}
+
+	/**
+	 * Convert LAB to RGB.
+	 * @param L
+	 * @param a
+	 * @param b
+	 * @return RGB values
+	 */
+	public int[] LABtoRGB(double L, double a, double b) {
+	  return XYZtoRGB(LABtoXYZ(L, a, b));
+	}
+
+	/**
+	 * @param Lab
+	 * @return RGB values
+	 */
+	public int[] LABtoRGB(double[] Lab) {
+	  return XYZtoRGB(LABtoXYZ(Lab));
+	}
+
+	/**
+	 * Convert LAB to XYZ.
+	 * @param L
+	 * @param a
+	 * @param b
+	 * @return XYZ values
+	 */
+	public double[] LABtoXYZ(double L, double a, double b) {
+	  double[] result = new double[3];
+
+	  double y = (L + 16.0) / 116.0;
+	  double y3 = Math.pow(y, 3.0);
+	  double x = (a / 500.0) + y;
+	  double x3 = Math.pow(x, 3.0);
+	  double z = y - (b / 200.0);
+	  double z3 = Math.pow(z, 3.0);
+
+	  if (y3 > 0.008856) {
+		y = y3;
+	  }
+	  else {
+		y = (y - (16.0 / 116.0)) / 7.787;
+	  }
+	  if (x3 > 0.008856) {
+		x = x3;
+	  }
+	  else {
+		x = (x - (16.0 / 116.0)) / 7.787;
+	  }
+	  if (z3 > 0.008856) {
+		z = z3;
+	  }
+	  else {
+		z = (z - (16.0 / 116.0)) / 7.787;
+	  }
+
+	  result[0] = x * whitePoint[0];
+	  result[1] = y * whitePoint[1];
+	  result[2] = z * whitePoint[2];
+
+	  return result;
+	}
+
+	/**
+	 * Convert LAB to XYZ.
+	 * @param Lab
+	 * @return XYZ values
+	 */
+	public double[] LABtoXYZ(double[] Lab) {
+	  return LABtoXYZ(Lab[0], Lab[1], Lab[2]);
+	}
+
+	/**
+	 * @param R Red in range 0..255
+	 * @param G Green in range 0..255
+	 * @param B Blue in range 0..255
+	 * @return HSB values: H is 0..360 degrees / 360 (0..1), S is 0..1, B is 0..1
+	 */
+	public double[] RGBtoHSB(int R, int G, int B) {
+	  double[] result = new double[3];
+	  float[] hsb = new float[3];
+	  Color.RGBtoHSB(R, G, B, hsb);
+	  result[0] = hsb[0];
+	  result[1] = hsb[1];
+	  result[2] = hsb[2];
+	  return result;
+	}
+
+	public double[] RGBtoHSB(int[] RGB) {
+	  return RGBtoHSB(RGB[0], RGB[1], RGB[2]);
+	}
+
+	/**
+	 * @param rgb RGB value
+	 * @return Lab values
+	 */
+	public double[] RGBtoLAB(int rgb) {
+		int r = (rgb&0xff0000)>>16;
+		int g = (rgb&0xff00)>>8;
+		int b = rgb&0xff;
+		return XYZtoLAB(RGBtoXYZ(r,g,b));
+	}
+
+	/**
+	 * @param RGB
+	 * @return Lab values
+	 */
+	public double[] RGBtoLAB(int[] RGB) {
+	  return XYZtoLAB(RGBtoXYZ(RGB));
+	}
+
+	/**
+	 * Convert RGB to XYZ
+	 * @param R
+	 * @param G
+	 * @param B
+	 * @return XYZ in double array.
+	 */
+	public double[] RGBtoXYZ(int R, int G, int B) {
+	  double[] result = new double[3];
+
+	  // convert 0..255 into 0..1
+	  double r = R / 255.0;
+	  double g = G / 255.0;
+	  double b = B / 255.0;
+
+	  // assume sRGB
+	  if (r <= 0.04045) {
+		r = r / 12.92;
+	  }
+	  else {
+		r = Math.pow(((r + 0.055) / 1.055), 2.4);
+	  }
+	  if (g <= 0.04045) {
+		g = g / 12.92;
+	  }
+	  else {
+		g = Math.pow(((g + 0.055) / 1.055), 2.4);
+	  }
+	  if (b <= 0.04045) {
+		b = b / 12.92;
+	  }
+	  else {
+		b = Math.pow(((b + 0.055) / 1.055), 2.4);
+	  }
+
+	  r *= 100.0;
+	  g *= 100.0;
+	  b *= 100.0;
+
+	  // [X Y Z] = [r g b][M]
+	  result[0] = (r * M[0][0]) + (g * M[0][1]) + (b * M[0][2]);
+	  result[1] = (r * M[1][0]) + (g * M[1][1]) + (b * M[1][2]);
+	  result[2] = (r * M[2][0]) + (g * M[2][1]) + (b * M[2][2]);
+
+	  return result;
+	}
+
+	/**
+	 * Convert RGB to XYZ
+	 * @param RGB
+	 * @return XYZ in double array.
+	 */
+	public double[] RGBtoXYZ(int[] RGB) {
+	  return RGBtoXYZ(RGB[0], RGB[1], RGB[2]);
+	}
+
+	/**
+	 * @param x
+	 * @param y
+	 * @param Y
+	 * @return XYZ values
+	 */
+	public double[] xyYtoXYZ(double x, double y, double Y) {
+	  double[] result = new double[3];
+	  if (y == 0) {
+		result[0] = 0;
+		result[1] = 0;
+		result[2] = 0;
+	  }
+	  else {
+		result[0] = (x * Y) / y;
+		result[1] = Y;
+		result[2] = ((1 - x - y) * Y) / y;
+	  }
+	  return result;
+	}
+
+	/**
+	 * @param xyY
+	 * @return XYZ values
+	 */
+	public double[] xyYtoXYZ(double[] xyY) {
+	  return xyYtoXYZ(xyY[0], xyY[1], xyY[2]);
+	}
+
+	/**
+	 * Convert XYZ to LAB.
+	 * @param X
+	 * @param Y
+	 * @param Z
+	 * @return Lab values
+	 */
+	public double[] XYZtoLAB(double X, double Y, double Z) {
+
+	  double x = X / whitePoint[0];
+	  double y = Y / whitePoint[1];
+	  double z = Z / whitePoint[2];
+
+	  if (x > 0.008856) {
+		x = Math.pow(x, 1.0 / 3.0);
+	  }
+	  else {
+		x = (7.787 * x) + (16.0 / 116.0);
+	  }
+	  if (y > 0.008856) {
+		y = Math.pow(y, 1.0 / 3.0);
+	  }
+	  else {
+		y = (7.787 * y) + (16.0 / 116.0);
+	  }
+	  if (z > 0.008856) {
+		z = Math.pow(z, 1.0 / 3.0);
+	  }
+	  else {
+		z = (7.787 * z) + (16.0 / 116.0);
+	  }
+
+	  double[] result = new double[3];
+
+	  result[0] = (116.0 * y) - 16.0;
+	  result[1] = 500.0 * (x - y);
+	  result[2] = 200.0 * (y - z);
+
+	  return result;
+	}
+
+	/**
+	 * Convert XYZ to LAB.
+	 * @param XYZ
+	 * @return Lab values
+	 */
+	public double[] XYZtoLAB(double[] XYZ) {
+	  return XYZtoLAB(XYZ[0], XYZ[1], XYZ[2]);
+	}
+
+	/**
+	 * Convert XYZ to RGB.
+	 * @param X
+	 * @param Y
+	 * @param Z
+	 * @return RGB in int array.
+	 */
+	public int[] XYZtoRGB(double X, double Y, double Z) {
+	  int[] result = new int[3];
+
+	  double x = X / 100.0;
+	  double y = Y / 100.0;
+	  double z = Z / 100.0;
+
+	  // [r g b] = [X Y Z][Mi]
+	  double r = (x * Mi[0][0]) + (y * Mi[0][1]) + (z * Mi[0][2]);
+	  double g = (x * Mi[1][0]) + (y * Mi[1][1]) + (z * Mi[1][2]);
+	  double b = (x * Mi[2][0]) + (y * Mi[2][1]) + (z * Mi[2][2]);
+
+	  // assume sRGB
+	  if (r > 0.0031308) {
+		r = ((1.055 * Math.pow(r, 1.0 / 2.4)) - 0.055);
+	  }
+	  else {
+		r = (r * 12.92);
+	  }
+	  if (g > 0.0031308) {
+		g = ((1.055 * Math.pow(g, 1.0 / 2.4)) - 0.055);
+	  }
+	  else {
+		g = (g * 12.92);
+	  }
+	  if (b > 0.0031308) {
+		b = ((1.055 * Math.pow(b, 1.0 / 2.4)) - 0.055);
+	  }
+	  else {
+		b = (b * 12.92);
+	  }
+
+	  r = (r < 0) ? 0 : r;
+	  g = (g < 0) ? 0 : g;
+	  b = (b < 0) ? 0 : b;
+
+	  // convert 0..1 into 0..255
+	  result[0] = (int) Math.round(r * 255);
+	  result[1] = (int) Math.round(g * 255);
+	  result[2] = (int) Math.round(b * 255);
+
+	  return result;
+	}
+
+	/**
+	 * Convert XYZ to RGB
+	 * @param XYZ in a double array.
+	 * @return RGB in int array.
+	 */
+	public int[] XYZtoRGB(double[] XYZ) {
+	  return XYZtoRGB(XYZ[0], XYZ[1], XYZ[2]);
+	}
+
+	/**
+	 * @param X
+	 * @param Y
+	 * @param Z
+	 * @return xyY values
+	 */
+	public double[] XYZtoxyY(double X, double Y, double Z) {
+	  double[] result = new double[3];
+	  if ((X + Y + Z) == 0) {
+		result[0] = chromaWhitePoint[0];
+		result[1] = chromaWhitePoint[1];
+		result[2] = chromaWhitePoint[2];
+	  } else {
+		result[0] = X / (X + Y + Z);
+		result[1] = Y / (X + Y + Z);
+		result[2] = Y;
+	  }
+	  return result;
+	}
+
+	/**
+	 * @param XYZ
+	 * @return xyY values
+	 */
+	public double[] XYZtoxyY(double[] XYZ) {
+	  return XYZtoxyY(XYZ[0], XYZ[1], XYZ[2]);
+	}
+ 	
+	/** Converts an RGB image into a Lab stack. */
+	public ImagePlus RGBToLab(ImagePlus img) {
+		ColorProcessor cp = (ColorProcessor)img.getProcessor();
+		ColorSpaceConverter converter = new ColorSpaceConverter();
+		int[] pixels = (int[])cp.getPixels();
+		int w = cp.getWidth();
+		int h = cp.getHeight();
+		ImageStack stack = new ImageStack(w,h);
+		FloatProcessor L = new FloatProcessor(w,h);
+		FloatProcessor a = new FloatProcessor(w,h);
+		FloatProcessor b = new FloatProcessor(w,h);
+		stack.addSlice("L*",L);
+		stack.addSlice("a*",a);
+		stack.addSlice("b*",b);
+		for (int i=0; i<pixels.length; i++) {
+			double[] values = converter.RGBtoLAB(pixels[i]);
+			L.setf(i,(float)values[0]);
+			a.setf(i,(float)values[1]);
+			b.setf(i,(float)values[2]);
+		}
+		ImagePlus img2 = new ImagePlus("Lab_"+img.getTitle(),stack);
+		CompositeImage img3 = new CompositeImage(img2,IJ.GRAYSCALE);
+		img3.resetDisplayRanges();
+		return img3;
+	}
+
+	/** Converts a Lab stack into an RGB image. */
+	public ImagePlus LabToRGB(ImagePlus img) {
+		int w = img.getWidth();
+		int h = img.getHeight();
+		ImageStack stack = img.getStack();
+		FloatProcessor L = (FloatProcessor)stack.getProcessor(1);
+		FloatProcessor a = (FloatProcessor)stack.getProcessor(2);
+		FloatProcessor b = (FloatProcessor)stack.getProcessor(3);
+		ColorProcessor cp = new ColorProcessor(w, h);
+		ColorSpaceConverter converter = new ColorSpaceConverter();
+		int[] values = new int[3];
+		double[] dvalues = new double[3];
+		for (int y=0; y<h; y++) {
+			for (int x=0; x<w; x++) {
+				dvalues[0] = L.getf(x,y);
+				dvalues[1] = a.getf(x,y);
+				dvalues[2] = b.getf(x,y);
+				values = converter.LABtoRGB(dvalues);
+				cp.putPixel(x,y,values);
+			}
+		}
+		ImagePlus img2 = new ImagePlus(img.getTitle(), cp);
+		return img2;
+	}
+
+}
\ No newline at end of file
diff --git a/src/ij/process/ColorStatistics.java b/src/ij/process/ColorStatistics.java
new file mode 100644
index 0000000..f3627c4
--- /dev/null
+++ b/src/ij/process/ColorStatistics.java
@@ -0,0 +1,144 @@
+package ij.process;
+import ij.measure.Calibration;
+
+/** RGB image statistics, including histogram. */
+public class ColorStatistics extends ImageStatistics {
+
+	/** Construct an ImageStatistics object from a ColorProcessor
+		using the standard measurement options (area, mean,
+		mode, min and max). */
+	public ColorStatistics(ImageProcessor ip) {
+		this(ip, AREA+MEAN+MODE+MIN_MAX, null);
+	}
+
+	/** Constructs a ColorStatistics object from a ColorProcessor using
+		the specified measurement options.
+	*/
+	public ColorStatistics(ImageProcessor ip, int mOptions, Calibration cal) {
+		setup(ip, cal);
+		if (ip instanceof IntProcessor) {
+			getIntStatistics(ip);
+			return;
+		}
+		ColorProcessor cp = (ColorProcessor)ip;
+		histogram = cp.getHistogram();
+		getRawStatistics(0,255);
+		if ((mOptions&MIN_MAX)!=0)
+			getRawMinAndMax(0,255);
+		if ((mOptions&ELLIPSE)!=0 || (mOptions&SHAPE_DESCRIPTORS)!=0)
+			fitEllipse(ip, mOptions);
+		else if ((mOptions&CENTROID)!=0)
+			getCentroid(ip);
+		if ((mOptions&(CENTER_OF_MASS|SKEWNESS|KURTOSIS))!=0)
+			calculateMoments(ip);
+		if ((mOptions&MEDIAN)!=0)
+			calculateMedian(histogram, 0, 255, cal);
+	}
+
+	void calculateMoments(ImageProcessor ip) {
+		byte[] mask = ip.getMaskArray();
+		int i, mi;
+		double v, v2, sum1=0.0, sum2=0.0, sum3=0.0, sum4=0.0, xsum=0.0, ysum=0.0;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					v = ip.getPixelValue(x, y);
+						v2 = v*v;
+						sum1 += v;
+						sum2 += v2;
+						sum3 += v*v2;
+						sum4 += v2*v2;
+						xsum += x*v;
+						ysum += y*v;
+				}
+				i++;
+			}
+		}
+	    double mean2 = mean*mean;
+	    double variance = sum2/pixelCount - mean2;
+	    double sDeviation = Math.sqrt(variance);
+	    skewness = ((sum3 - 3.0*mean*sum2)/pixelCount + 2.0*mean*mean2)/(variance*sDeviation);
+	    kurtosis = (((sum4 - 4.0*mean*sum3 + 6.0*mean2*sum2)/pixelCount - 3.0*mean2*mean2)/(variance*variance)-3.0);
+		xCenterOfMass = xsum/sum1+0.5;
+		yCenterOfMass = ysum/sum1+0.5;
+		if (cal!=null) {
+			xCenterOfMass = cal.getX(xCenterOfMass);
+			yCenterOfMass = cal.getY(yCenterOfMass, height);
+		}
+	}
+	
+	void getIntStatistics(ImageProcessor ip) {
+		int v;
+		int[] pixels = (int[])ip.getPixels();
+		nBins = ip.getHistogramSize();
+		histogram = new int[nBins];
+		double sum = 0;
+		double sum2 = 0;
+		byte[] mask = ip.getMaskArray();
+		
+		// Find image min and max
+		int roiMin = Integer.MAX_VALUE;
+		int roiMax = -Integer.MAX_VALUE;
+		for (int y=ry, my=0; y<(ry+rh); y++, my++) {
+			int i = y * width + rx;
+			int mi = my * rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					v = pixels[i];
+					if (v<roiMin)
+						roiMin = v;
+					if (v>roiMax)
+						roiMax = v;
+				}
+				i++;
+			}
+		}
+		min = roiMin; max = roiMax;
+		binSize = (max-min)/nBins;
+		histMin = min; 
+		histMax = max;
+
+		// Generate histogram
+		double scale = nBins/(max-min);
+		int index;
+		pixelCount = 0;
+		for (int y=ry, my=0; y<(ry+rh); y++, my++) {
+			int i = y * width + rx;
+			int mi = my * rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					v = pixels[i];
+					pixelCount++;
+					sum += v;
+					sum2 += v*v;
+					index = (int)(scale*(v-min));
+					if (index>=nBins)
+						index = nBins-1;
+					histogram[index]++;
+				}
+				i++;
+			}
+		}
+		area = pixelCount*pw*ph;
+		mean = sum/pixelCount;
+		umean = mean;
+		calculateStdDev(pixelCount, sum, sum2);
+		
+        // calculate mode
+        int count;
+        maxCount = 0;
+        for (int i = 0; i < nBins; i++) {
+        	count = histogram[i];
+            if (count > maxCount) {
+                maxCount = count;
+                mode = i;
+            }
+        }
+        dmode = histMin+mode*binSize;
+        if (binSize!=1.0)
+        	dmode += binSize/2.0;        	
+	}
+
+}
diff --git a/src/ij/process/DownsizeTable.java b/src/ij/process/DownsizeTable.java
new file mode 100644
index 0000000..0f73d18
--- /dev/null
+++ b/src/ij/process/DownsizeTable.java
@@ -0,0 +1,130 @@
+package ij.process;
+import java.util.Arrays;
+
+/** A table for easier downsizing by convolution with a kernel.
+ *	Supports the interpolation methods of ImageProcessor: none, bilinear, bicubic
+ *	Convention used: The left edges of the first pixel are the same for source and destination.
+ *	E.g. when downsizing by a factor of 2, pixel 0 of the destination
+ *	takes the space of pixels 0 and 1 of the source.
+ *
+ *	Example for use: Downsizing row 0 of 'pixels' from 'roi.width' to 'destinationWidth'.
+ *	The input range is given by the roi rectangle.
+ *	Output is written to row 0 of 'pixels2' (width: 'destinationWidth')
+ <code>
+	DownSizeTable dt = new DownSizeTable(width, roi.x, roi.width, destinationWidth, ImageProcessor.BICUBIC);
+	int tablePointer = 0;
+	for (int srcPoint=dt.srcStart, srcPoint<=dt.srcEnd; srcPoint++) {
+		float v = pixels[srcPoint];
+		for (int i=0; i<dt.kernelSize; i++, tablePointer++)
+			pixels2[dt.indices[tablePointer]] += v * dt.weights[tablePointer];
+ </code>
+ */
+public class DownsizeTable {
+	/** Number of kernel points per source data point */
+	public final int kernelSize;
+	/** index of the first point of the source data that should be accessed */
+	public final int srcStart;
+	/** index of the last point of the source data that should be accessed */
+	public final int srcEnd;
+	/** For each source point between srcStart and srcEnd, indices of destination
+	 *	points where the data should be added.
+	 *	Arranged in blocks of 'kernelSize' points. E.g. for kernelSize=2, array
+	 *	elements 0,1 are for point srcStart, 2,3 for point srcStart+1, etc. */
+	public final int[] indices;
+	/** For each source point, weights for adding it to the destination point
+	 *	given in the corresponding element of 'indices' */
+	public final float[] weights;
+	/** Kernel sizes corresponding to the interpolation methods NONE, BILINEAR, BICUBIC */
+	private final static int[] kernelSizes = new int[] {1, 2, 4};
+	private final int srcOrigin, srcLength;
+	private final double scale;			//source/destination pixel numbers
+	private final int interpolationMethod;
+	private final static int UNUSED=-1; //marks unused entries in 'indices' array
+
+
+	/** Create a table for 1-dimensional downscaling interpolation.
+	 *	Interpolation is done by 
+	 * @param srcSize	 Size of source data, i.e., width or height of input image
+	 * @param srcOrigin	 Index of first pixel of source data that corresponds to an ouput pixel,
+	 *					 0 or origin of source rectangle if only a roi is scaled
+	 * @param srcLength	 Number of pixels of source data that should correspond to output, i.e.,
+	 *					 width or height of source roi
+	 * @param dstSize	 Number of destination pixels.
+	 * @param interpolationMethod One of the methods defined in ImageProcessor: NONE, BILINEAR, BICUBIC
+	 */
+	DownsizeTable(int srcSize, int srcOrigin, int srcLength, int dstSize, int interpolationMethod) {
+		this.srcOrigin = srcOrigin;
+		this.srcLength = srcLength;
+		this.interpolationMethod = interpolationMethod;
+		this.scale = srcLength / (double)dstSize;
+		this.kernelSize = kernelSizes[interpolationMethod];
+		int srcStartUncorr = (int)(Math.ceil(1e-8+srcIndex(-0.5*kernelSize))); //may be <0
+		srcStart = srcStartUncorr < 0 ? 0 : srcStartUncorr;	   //corrected value, avoids pointing out of array
+		int srcEndUncorr = (int)(Math.floor(1e-8+srcIndex(dstSize-1 + 0.5*kernelSize)));
+		srcEnd = srcEndUncorr >=srcSize ? srcSize-1 : srcEndUncorr;
+		int arraySize = (srcEnd - srcStart + 1) * kernelSize;
+		indices = new int[arraySize];
+		weights = new float[arraySize];
+		Arrays.fill(indices, UNUSED);
+		//IJ.log("src size="+srcSize+" range="+srcStart+"-"+srcEnd+" array:"+arraySize+" scale="+(float)scale);
+
+		for (int dst=0; dst<dstSize; dst++) {
+			double sum = 0;
+			int lowestS = (int)(Math.ceil(1e-8+srcIndex(dst-0.5*kernelSize)));
+			int highestS = (int)(Math.floor(-1e-8+srcIndex(dst+0.5*kernelSize)));
+			for (int src=lowestS; src<=highestS; src++) {
+				//out of bounds policy is 'use value of edge pixel'.
+				//We therfore replace an out-of-bounds pixel by the edge pixel:
+				int s = src < 0 ? 0 : (src >= srcSize ? srcSize-1 : src);
+				int p = (s-srcStart)*kernelSize;// points to first value in 'indices' and 'weights'
+												// arrays reserved for this source pixel
+				while(indices[p]!=UNUSED && indices[p]!=dst)
+					p++;					//position used for other destination pixel, try the next one
+				//if(p-(s-srcStart)*kernelSize>=kernelSize)IJ.log(srcSize+">"+dstSize+": too long: src="+src+" dst="+dst);
+				indices[p] = dst;
+				float weight = kernel(dst - dstIndex(src));
+				sum += weight;
+				weights[p] += weight;
+				//IJ.log("src="+src+"("+s+") to "+dst+" w="+weight+" p="+p);
+			}
+			//normalize: sum of weights contributing to this destination pixel should be 1
+			int iStart = (lowestS-srcStart)*kernelSize;
+			if (iStart < 0) iStart = 0;
+			int iStop = (highestS-srcStart)*kernelSize+(kernelSize-1);
+			if (iStop>=indices.length) iStop = indices.length-1;
+			//IJ.log("normalize "+iStart+"-"+iStop+" sum="+sum);
+			for (int i=iStart; i<=iStop; i++)
+				if (indices[i] == dst)
+					weights[i] = (float)(weights[i]/sum);
+		}
+		for (int i=0; i<indices.length; i++)
+			if (indices[i]==UNUSED)
+				indices[i] = 0;		//set unused entries to pixel 0 (weight is 0 anyhow), then they do no harm
+	}
+	// Converts a destination pixel coordinate (index) to the corresponding
+	// source coordinate
+	// All coordinates refer to the centers of the pixel
+	// Also for fractional indices, e.g. dstIndex = i-0.5 for left edge of pixel.
+	// The output is also fractional (not converted to int)
+	// No check for source array bounds, may result in a value <0 or >= array size.
+	private double srcIndex(double dstIndex) {
+		return srcOrigin-0.5 + (dstIndex+0.5)*scale;
+	}
+	// Converts the coordinate (index) of a source pixel to the destination pixel
+	private double dstIndex(int srcIndex) {
+		return (srcIndex-srcOrigin+0.5)/scale - 0.5;
+	}
+	// Calculates the kernel value. Only valid within +/- 0.5*kernelSize
+	protected float kernel(double x) {
+		switch (interpolationMethod) {
+			case ImageProcessor.NONE:
+				return 1f;
+			case ImageProcessor.BILINEAR:
+				return 1f - (float)Math.abs(x);
+			case ImageProcessor.BICUBIC:
+				return (float)ImageProcessor.cubic(x);
+		}
+		return Float.NaN;
+	}
+
+}
diff --git a/src/ij/process/EllipseFitter.java b/src/ij/process/EllipseFitter.java
new file mode 100644
index 0000000..517df38
--- /dev/null
+++ b/src/ij/process/EllipseFitter.java
@@ -0,0 +1,346 @@
+package ij.process;
+import ij.*;
+import ij.gui.*;
+import java.awt.*;
+import ij.plugin.filter.*;
+
+/*
+Best-fitting ellipse routines by:
+
+  Bob Rodieck
+  Department of Ophthalmology, RJ-10
+  University of Washington, 
+  Seattle, WA, 98195
+
+Notes on best-fitting ellipse:
+
+  Consider some arbitrarily shaped closed profile, which we wish to
+  characterize in a quantitative manner by a series of terms, each 
+  term providing a better approximation to the shape of the profile.  
+  Assume also that we wish to include the orientation of the profile 
+  (i.e. which way is up) in our characterization. 
+
+  One approach is to view the profile as formed by a series harmonic 
+  components, much in the same way that one can decompose a waveform
+  over a fixed interval into a series of Fourier harmonics over that 
+  interval. From this perspective the first term is the mean radius,
+  or some related value (i.e. the area).  The second term is the 
+  magnitude and phase of the first harmonic, which is equivalent to the
+  best-fitting ellipse.  
+
+  What constitutes the best-fitting ellipse?  First, it should have the
+  same area.  In statistics, the measure that attempts to characterize some
+  two-dimensional distribution of data points is the 'ellipse of 
+  concentration' (see Cramer, Mathematical Methods of Statistics, 
+  Princeton Univ. Press, 945, page 283).  This measure equates the second
+  order central moments of the ellipse to those of the distribution, 
+  and thereby effectively defines both the shape and size of the ellipse. 
+
+  This technique can be applied to a profile by assuming that it constitutes
+  a uniform distribution of points bounded by the perimeter of the profile.
+  For most 'blob-like' shapes the area of the ellipse is close to that
+  of the profile, differing by no more than about 4%. We can then make
+  a small adjustment to the size of the ellipse, so as to give it the 
+  same area as that of the profile.  This is what is done here, and 
+  therefore this is what we mean by 'best-fitting'. 
+
+  For a real pathologic case, consider a dumbell shape formed by two small
+  circles separated by a thin line. Changing the distance between the
+  circles alters the second order moments, and thus the size of the ellipse 
+  of concentration, without altering the area of the profile. 
+
+public class Ellipse_Fitter implements PlugInFilter {
+	public int setup(String arg, ImagePlus imp) {
+		return DOES_ALL;
+	}
+	public void run(ImageProcessor ip) {
+		EllipseFitter ef = new EllipseFitter();
+		ef.fit(ip);
+		IJ.log(IJ.d2s(ef.major)+" "+IJ.d2s(ef.minor)+" "+IJ.d2s(ef.angle)+" "+IJ.d2s(ef.xCenter)+" "+IJ.d2s(ef.yCenter));
+		ef.drawEllipse(ip);
+	}
+}
+*/
+
+
+/** This class fits an ellipse to an ROI. */
+public class EllipseFitter {
+
+	static final double HALFPI = 1.5707963267949;
+	
+	/** X centroid */
+	public double xCenter;
+
+	/** X centroid */
+	public double  yCenter;
+	
+	/** Length of major axis */
+	public double major;
+	
+	/** Length of minor axis */
+	public double minor;
+	
+	/** Angle in degrees */
+	public double angle;
+	
+	/** Angle in radians */
+	public double theta;
+	
+	/** Initialized by makeRoi() */
+	public int[] xCoordinates;
+	/** Initialized by makeRoi() */
+	public int[] yCoordinates;
+	/** Initialized by makeRoi() */
+	public int nCoordinates = 0;
+
+	
+	private int bitCount;
+	private double  xsum, ysum, x2sum, y2sum, xysum;
+	private byte[] mask;
+	private int left, top, width, height;
+ 	private double   n;
+	private double   xm, ym;   //mean values
+	private double   u20, u02, u11;  //central moments
+	private ImageProcessor ip;
+	//private double pw, ph;
+	private boolean record;
+
+	/** Fits an ellipse to the current ROI. The 'stats' argument, currently not used, 
+		can be null. The fit parameters are returned in public fields. */
+	public void fit(ImageProcessor ip, ImageStatistics stats) {
+		this.ip = ip;
+		mask = ip.getMaskArray();
+		Rectangle r = ip.getRoi();
+		left = r.x;
+		top = r.y;
+		width = r.width;
+		height = r.height;
+		getEllipseParam();
+	}
+	
+	void getEllipseParam() {
+		double    sqrtPi = 1.772453851;
+		double    a11, a12, a22, m4, z, scale, tmp, xoffset, yoffset;
+		double    RealAngle;
+
+		if (mask==null) {
+			major = (width*2) / sqrtPi;
+			minor = (height*2) / sqrtPi; // * Info->PixelAspectRatio;
+			angle = 0.0;
+			theta = 0.0;
+			if (major < minor) {
+				tmp = major;
+				major = minor;
+				minor = tmp;
+				angle = 90.0;
+				theta = Math.PI/2.0;
+			}
+			xCenter = left + width / 2.0;
+			yCenter = top + height / 2.0;
+			return;
+		}
+
+		computeSums();
+		getMoments();
+		m4 = 4.0 * Math.abs(u02 * u20 - u11 * u11);
+		if (m4 < 0.000001)
+			m4 = 0.000001;
+		a11 = u02 / m4;
+		a12 = u11 / m4;
+		a22 = u20 / m4;
+		xoffset = xm;
+		yoffset = ym;
+
+		tmp = a11 - a22;
+		if (tmp == 0.0)
+			tmp = 0.000001;
+		theta = 0.5 * Math.atan(2.0 * a12 / tmp);
+		if (theta < 0.0)
+			theta += HALFPI;
+		if (a12 > 0.0)
+			theta += HALFPI;
+		else if (a12 == 0.0) {
+			if (a22 > a11) {
+				theta = 0.0;
+				tmp = a22;
+				a22 = a11;
+				a11 = tmp;
+			} else if (a11 != a22)
+				theta = HALFPI;
+		}
+		tmp = Math.sin(theta);
+		if (tmp == 0.0)
+			tmp = 0.000001;
+		z = a12 * Math.cos(theta) / tmp;
+		major = Math.sqrt (1.0 / Math.abs(a22 + z));
+		minor = Math.sqrt (1.0 / Math.abs(a11 - z));
+		scale = Math.sqrt (bitCount / (Math.PI * major * minor)); //equalize areas
+		major = major*scale*2.0;
+		minor = minor*scale*2.0;
+		angle = 180.0 * theta / Math.PI;
+		if (angle == 180.0)
+			angle = 0.0;
+ 		if (major < minor) {
+			tmp = major;
+			major = minor;
+			minor = tmp;
+		}
+		xCenter = left + xoffset + 0.5;
+		yCenter = top + yoffset + 0.5;
+	}
+
+	void computeSums () {
+		xsum = 0.0;
+		ysum = 0.0;
+		x2sum = 0.0;
+		y2sum = 0.0;
+		xysum = 0.0;
+		int bitcountOfLine;
+		double   xe, ye;
+		int xSumOfLine;
+ 		for (int y=0; y<height; y++) {
+ 			bitcountOfLine = 0;
+ 			xSumOfLine = 0;
+			int offset = y*width;
+			for (int x=0; x<width; x++) {
+				if (mask[offset+x] != 0) {
+					bitcountOfLine++;
+					xSumOfLine += x;
+					x2sum += x * x;
+				}
+			} 
+ 			xsum += xSumOfLine;
+			ysum += bitcountOfLine * y;
+			ye = y;
+			xe = xSumOfLine;
+			xysum += xe*ye;
+			y2sum += ye*ye*bitcountOfLine;
+			bitCount += bitcountOfLine;
+		}
+	}
+
+	void getMoments () {
+		double   x1, y1, x2, y2, xy;
+
+		if (bitCount == 0)
+			return;
+
+		x2sum += 0.08333333 * bitCount;
+		y2sum += 0.08333333 * bitCount;
+		n = bitCount;
+		x1 = xsum/n;
+ 		y1 = ysum / n;
+		x2 = x2sum / n;
+		y2 = y2sum / n;
+		xy = xysum / n;
+		xm = x1;
+		ym = y1;
+		u20 = x2 - (x1 * x1);
+		u02 = y2 - (y1 * y1);
+		u11 = xy - x1 * y1;
+	}
+	
+	/* 
+	basic equations:
+
+		a: major axis
+		b: minor axis
+		t: theta, angle of major axis, clockwise with respect to x axis. 
+
+		g11*x^2 + 2*g12*x*y + g22*y^2 = 1       -- equation of ellipse
+
+		g11:= ([cos(t)]/a)^2 + ([sin(t)]/b)^2
+		g12:= (1/a^2 - 1/b^2) * sin(t) * cos(t)
+		g22:= ([sin(t)]/a)^2 + ([cos(t)]/b)^2
+
+		solving for x:      x:= k1*y  sqrt( k2*y^2 + k3 )
+
+		where:  k1:= -g12/g11
+		k2:= (g12^2 - g11*g22)/g11^2
+		k3:= 1/g11
+
+		ymax or ymin occur when there is a single value for x, that is when:    
+		k2*y^2 + k3 = 0    
+	*/
+	
+	/** Draws the ellipse on the specified image. */
+	public void drawEllipse(ImageProcessor ip) {
+		if (major==0.0 && minor==0.0)
+			return;
+		int xc = (int)Math.round(xCenter);
+		int yc = (int)Math.round(yCenter);
+		int maxY = ip.getHeight();
+		int xmin, xmax;
+		double sint, cost, rmajor2, rminor2, g11, g12, g22, k1, k2, k3;
+		int x, xsave, ymin, ymax;
+		int[] txmin = new int[maxY];
+		int[] txmax = new int[maxY];
+		double j1, j2, yr;
+
+		sint = Math.sin(theta);
+		cost = Math.cos(theta);
+		rmajor2 = 1.0 / sqr(major/2);
+		rminor2 = 1.0 / sqr(minor/2);
+		g11 = rmajor2 * sqr(cost) + rminor2 * sqr(sint);
+		g12 = (rmajor2 - rminor2) * sint * cost;
+		g22 = rmajor2 * sqr(sint) + rminor2 * sqr(cost);
+		k1 = -g12 / g11;
+		k2 = (sqr(g12) - g11 * g22) / sqr(g11);
+		k3 = 1.0 / g11;
+		ymax = (int)Math.floor(Math.sqrt(Math.abs(k3 / k2)));
+		if (ymax>maxY)
+			ymax = maxY;
+		if (ymax<1)
+			ymax = 1;
+		ymin = -ymax;
+ 		// Precalculation and use of symmetry speed things up
+		for (int y=0; y<=ymax; y++) {
+			//GetMinMax(y, aMinMax);
+			j2 = Math.sqrt(k2 * sqr(y) + k3);
+			j1 = k1 * y;
+			txmin[y] = (int)Math.round(j1 - j2);
+			txmax[y] = (int)Math.round(j1 + j2);
+		}
+		if (record) {
+			xCoordinates[nCoordinates] = xc + txmin[ymax - 1];
+			yCoordinates[nCoordinates] = yc + ymin;
+			nCoordinates++;
+		} else
+			ip.moveTo(xc + txmin[ymax - 1], yc + ymin);
+		for (int y=ymin; y<ymax; y++) {
+			x = y<0?txmax[-y]:-txmin[y];
+			if (record) {
+				xCoordinates[nCoordinates] = xc + x;
+				yCoordinates[nCoordinates] = yc + y;
+				nCoordinates++;
+			} else
+				ip.lineTo(xc + x, yc + y);
+		}
+		for (int y=ymax; y>ymin; y--) {
+			x = y<0?txmin[-y]:-txmax[y];
+			if (record) {
+				xCoordinates[nCoordinates] = xc + x;
+				yCoordinates[nCoordinates] = yc + y;
+				nCoordinates++;
+			} else
+				ip.lineTo(xc + x, yc + y);
+		}
+	}
+	
+	/** Generates the xCoordinates, yCoordinates public arrays 
+		that can be used to create an ROI. */
+	public void makeRoi(ImageProcessor ip) {
+		record = true;
+		int size = ip.getHeight()*3;
+		xCoordinates = new int[size];
+		yCoordinates = new int[size];
+		nCoordinates = 0;
+		drawEllipse(ip);
+		record = false;
+	}
+	
+	private double sqr(double x) {
+		return x*x;
+	}
+
+}
diff --git a/src/ij/process/FHT.java b/src/ij/process/FHT.java
new file mode 100644
index 0000000..13d36bb
--- /dev/null
+++ b/src/ij/process/FHT.java
@@ -0,0 +1,662 @@
+package ij.process;
+import ij.*;
+import ij.plugin.FFT;
+import ij.plugin.ContrastEnhancer;
+import java.awt.image.ColorModel; 
+
+/**
+This class contains a Java implementation of the Fast Hartley
+Transform. It is based on Pascal code in NIH Image contributed 
+by Arlo Reeves (http://imagej.nih.gov/ij/docs/ImageFFT/).
+The Fast Hartley Transform was restricted by U.S. Patent No. 4,646,256, 
+but was placed in the public domain by Stanford University in 1995 
+and is now freely available.
+*/
+public class FHT extends FloatProcessor {
+	private boolean isFrequencyDomain;
+	private int maxN;
+	private float[] C;
+	private float[] S;
+	private int[] bitrev;
+	private float[] tempArr;
+	private boolean showProgress;
+
+	
+	/** Used by the FFT class. */
+	public boolean quadrantSwapNeeded;
+	/** Used by the FFT class. */
+	public ColorProcessor rgb;
+	/** Used by the FFT class. */
+	public int originalWidth;
+	/** Used by the FFT class. */
+	public int originalHeight;
+	/** Used by the FFT class. */
+	public int originalBitDepth;
+	/** Used by the FFT class. */
+	public ColorModel originalColorModel;
+	/** Used by the FFT class. */
+	public double powerSpectrumMean;
+
+	/** Constructs a FHT object from an ImageProcessor. Byte, short and RGB images 
+		are converted to float. Float images are duplicated. */
+	public FHT(ImageProcessor ip) {
+		this(ip, false);
+	}
+
+	public FHT(ImageProcessor ip, boolean isFrequencyDomain) {
+		super(ip.getWidth(), ip.getHeight(), (float[])((ip instanceof FloatProcessor)?ip.duplicate().getPixels():ip.convertToFloat().getPixels()), null);
+		this.isFrequencyDomain = isFrequencyDomain;
+		maxN = getWidth();
+		resetRoi();
+	}
+
+	public FHT() {
+		super(8,8); //create dummy FloatProcessor
+	}
+
+	/** Returns true of this FHT contains a square image with a width that is a power of two. */
+	public boolean powerOf2Size() {
+		int i=2;
+		while(i<width) i *= 2;
+		return i==width && width==height;
+	}
+
+	/** Performs a forward transform, converting this image into the frequency domain. 
+		The image contained in this FHT must be square and its width must be a power of 2. */
+	public void transform() {
+		transform(false);
+	}
+
+	/** Performs an inverse transform, converting this image into the space domain. 
+		The image contained in this FHT must be square and its width must be a power of 2. */
+	public void inverseTransform() {
+		transform(true);
+	}
+	
+	public static int NO_WINDOW=0, HAMMING=1, HANN=2, FLATTOP=3; // fourier1D window function types
+
+	/** Calculates the Fourier amplitudes of an array, based on a 1D Fast Hartley Transform.
+	* With no Window function, if the array size is a power of 2, the input function
+	* should be either periodic or the data at the beginning and end of the array should
+	* approach the same value (the periodic continuation should be smooth).
+	* With no Window function, if the array size is not a power of 2, the
+	* data should decay towards 0 at the beginning and end of the array.
+	* For data that do not fulfill these conditions, a window function can be used to
+	* avoid artifacts from the edges. See http://en.wikipedia.org/wiki/Window_function.
+	*
+	* Supported window functions: Hamming, Hann ("raised cosine"), flat-top. Flat-top
+	* refers to the HFT70 function in the report cited below, it is named for its
+	* response in the frequency domain: a single-frequency sinewave becomes a peak with
+	* a short plateau of 3 roughly equal Fourier amplitudes. It is optimized for
+	* measuring amplitudes of signals with well-separated sharp frequencies.
+	* All window functions will reduce the frequency resolution; this is especially
+	* pronounced for the flat-top window.
+	*
+	* Normalization is done such that the peak height in the Fourier transform
+	* (roughly) corresponds to the RMS amplitude of a sinewave (i.e., amplitude/sqrt(2)),
+	* and the first Fourier amplitude corresponds to DC component (average value of
+	* the data). If the sine frequency falls between two discrete frequencies of the
+	* Fourier transform, peak heights can deviate from the true RMS amplitude by up to
+	* approx. 36, 18, 15, and 0.1% for no window function, Hamming, Hann and flat-top
+	* window functions, respectively.
+	* When calculating the power spectrum from the square of the output, note that the
+	* result is quantitative only if the input array size is a power of 2; then the
+	* spectral density of the power spectrum must be divided by 1.3628 for the Hamming,
+	* 1.5 for the Hann, and 3.4129 for the flat-top window.
+	*
+	* For more details about window functions, see:
+	* G. Heinzel, A. Rdiger, and R. Schilling
+	* Spectrum and spectral density estimation by the discrete Fourier transform (DFT),
+	* including a comprehensive list of window functions and some new flat-top windows.
+	* Technical Report, MPI f. Gravitationsphysik, Hannover, 2002; http://edoc.mpg.de/395068
+	*
+	* @param data Input array; its size need not be a power of 2. The input is not modified..
+	* @param windowType may be NO_WINDOW, then the input array is used as it is.
+	* Otherwise, it is multiplied by a window function, which can be HAMMING, HANN or
+	* FLATTOP.
+	* @return Array with the result, i.e., the RMS amplitudes for each frequency.
+	* The output array size is half the size of the 2^n-sized array used for the FHT;
+	* array element [0]corresponds to frequency zero (the "DC component"). The first
+	* nonexisting array element, result[result.length] would correspond to a frequency
+	* of 1 cycle per 2 input points, i.e., the Nyquist frequency. In other words, if
+	* the spacing of the input data points is dx, results[i] corresponds to a frequency
+	* of i/(2*results.length*dx).
+	*/
+	public float[] fourier1D(float[] data, int windowType) {
+		int n = data.length;
+		int size = 2;
+		while (size<n) size *= 2; // find power of 2 where the data fit
+		float[] y = new float[size]; // leave the original data untouched, work on a copy
+		System.arraycopy(data, 0, y, 0, n); // pad to 2^n-size
+		double sum = 0;
+		if (windowType != NO_WINDOW) {
+			for (int x=0; x<n; x++) { //calculate non-normalized window function
+				double z = (x + 0.5) * (2 * Math.PI / n);
+				double w = 0;
+				if (windowType == HAMMING)
+					w = 0.54 - 0.46 * Math.cos(z);
+				else if (windowType == HANN)
+					w = 1. - Math.cos(z);
+				else if (windowType == FLATTOP)
+					w = 1. - 1.90796 * Math.cos(z) + 1.07349 * Math.cos(2*z) - 0.18199 * Math.cos(3*z);
+				else
+					throw new IllegalArgumentException("Invalid Fourier Window Type");
+				y[x] *= w;
+				sum += w;
+			}
+		} else
+			sum = n;
+		for (int x=0; x<n; x++) //normalize
+			y[x] *= (1./sum);
+		transform1D(y); //transform
+		float[] result = new float[size/2];
+		result[0] = (float)Math.sqrt(y[0]*y[0]);
+		for (int x=1; x<size/2; x++)
+			result[x] = (float)Math.sqrt(y[x]*y[x]+y[size-x]*y[size-x]);
+		return result;
+	}
+
+	/** Performs an optimized 1D Fast Hartley Transform (FHT) of an array.
+	 *  Array size must be a power of 2.
+	 *  Note that all amplitudes in the output 'x' are multiplied by the array length.
+	 *  Therefore, to get the power spectrum, for 1 <=i < N/2, use
+	 *  ps[i] = (x[i]*x[i]+x[maxN-i]*x[maxN-i])/(maxN*maxN), where maxN is the array length.
+	 *  To get the real part of the complex FFT, for i=0 use x[0]/maxN,
+	 *  and for i>0, use (x[i]+x[maxN-i])/(2*maxN).
+	 *  The imaginary part of the complex FFT, with i>0, is given by (x[i]-x[maxN-i])/(2*maxN)
+	 *  The coefficients of cosine and sine are like the real and imaginary values above,
+	 *  but you have to divide by maxN instead of 2*maxN.
+	 */
+	public void transform1D(float[] x) {
+		int n = x.length;
+		if (S==null || n!=maxN) {
+			if (!isPowerOf2(n))
+				throw new IllegalArgumentException("Not power of 2 length: "+n);
+			initializeTables(n);
+		}
+		dfht3(x, 0, false, n);
+	}
+
+    /** Performs an inverse 1D Fast Hartley Transform (FHT) of an array */
+	public void inverseTransform1D(float[] fht) {
+		int n = fht.length;
+		if (S==null || n!=maxN) {
+			if (!isPowerOf2(n))
+				throw new IllegalArgumentException("Not power of 2 length: "+n);
+			initializeTables(n);
+		}
+		dfht3(fht, 0, true, n);
+	}
+
+	void transform(boolean inverse) {
+		if (!powerOf2Size())
+			throw new  IllegalArgumentException("Image not power of 2 size or not square: "+width+"x"+height);
+		setShowProgress(true);
+		maxN = width;
+		if (S==null)
+			initializeTables(maxN);
+		float[] fht = (float[])getPixels();
+	 	rc2DFHT(fht, inverse, maxN);
+		isFrequencyDomain = !inverse;
+	}
+	
+	void initializeTables(int maxN) {
+	    if (maxN>0x40000000)
+	        throw new  IllegalArgumentException("Too large for FHT:  "+maxN+" >2^30");
+		makeSinCosTables(maxN);
+		makeBitReverseTable(maxN);
+		tempArr = new float[maxN];
+	}
+
+	void makeSinCosTables(int maxN) {
+		int n = maxN/4;
+		C = new float[n];
+		S = new float[n];
+		double theta = 0.0;
+		double dTheta = 2.0 * Math.PI/maxN;
+		for (int i=0; i<n; i++) {
+			C[i] = (float)Math.cos(theta);
+			S[i] = (float)Math.sin(theta);
+			theta += dTheta;
+		}
+	}
+	
+	void makeBitReverseTable(int maxN) {
+		bitrev = new int[maxN];
+		int nLog2 = log2(maxN);
+		for (int i=0; i<maxN; i++)
+			bitrev[i] = bitRevX(i, nLog2);
+	}
+
+	/** Performs a 2D FHT (Fast Hartley Transform). */
+	public void rc2DFHT(float[] x, boolean inverse, int maxN) {
+		if (S==null) initializeTables(maxN);
+		for (int row=0; row<maxN; row++)
+			dfht3(x, row*maxN, inverse, maxN);		
+		progress(0.4);
+		transposeR(x, maxN);
+		progress(0.5);
+		for (int row=0; row<maxN; row++)		
+			dfht3(x, row*maxN, inverse, maxN);
+		progress(0.7);
+		transposeR(x, maxN);
+		progress(0.8);
+
+		int mRow, mCol;
+		float A,B,C,D,E;
+		for (int row=0; row<=maxN/2; row++) { // Now calculate actual Hartley transform
+			for (int col=0; col<=maxN/2; col++) {
+				mRow = (maxN - row) % maxN;
+				mCol = (maxN - col)  % maxN;
+				A = x[row * maxN + col];	//  see Bracewell, 'Fast 2D Hartley Transf.' IEEE Procs. 9/86
+				B = x[mRow * maxN + col];
+				C = x[row * maxN + mCol];
+				D = x[mRow * maxN + mCol];
+				E = ((A + D) - (B + C)) / 2;
+				x[row * maxN + col] = A - E;
+				x[mRow * maxN + col] = B + E;
+				x[row * maxN + mCol] = C + E;
+				x[mRow * maxN + mCol] = D - E;
+			}
+		}
+		progress(0.95);
+	}
+	
+	void progress(double percent) {
+		if (showProgress)
+			IJ.showProgress(percent);
+	}
+	
+	/** Performs an optimized 1D FHT of an array or part of an array.
+	 *  @param x        Input array; will be overwritten by the output in the range given by base and maxN.
+	 *  @param base     First index from where data of the input array should be read.
+	 *  @param inverse  True for inverse transform.
+	 *  @param maxN     Length of data that should be transformed; this must be always
+	 *                  the same for a given FHT object.
+	 *  Note that all amplitudes in the output 'x' are multiplied by maxN.
+	 */
+	public void dfht3(float[] x, int base, boolean inverse, int maxN) {
+		int i, stage, gpNum, gpIndex, gpSize, numGps, Nlog2;
+		int bfNum, numBfs;
+		int Ad0, Ad1, Ad2, Ad3, Ad4, CSAd;
+		float rt1, rt2, rt3, rt4;
+
+		if (S==null) initializeTables(maxN);
+		Nlog2 = log2(maxN);
+		BitRevRArr(x, base, Nlog2, maxN);	//bitReverse the input array
+		gpSize = 2;     //first & second stages - do radix 4 butterflies once thru
+		numGps = maxN / 4;
+		for (gpNum=0; gpNum<numGps; gpNum++)  {
+			Ad1 = gpNum * 4;
+			Ad2 = Ad1 + 1;
+			Ad3 = Ad1 + gpSize;
+			Ad4 = Ad2 + gpSize;
+			rt1 = x[base+Ad1] + x[base+Ad2];   // a + b
+			rt2 = x[base+Ad1] - x[base+Ad2];   // a - b
+			rt3 = x[base+Ad3] + x[base+Ad4];   // c + d
+			rt4 = x[base+Ad3] - x[base+Ad4];   // c - d
+			x[base+Ad1] = rt1 + rt3;      // a + b + (c + d)
+			x[base+Ad2] = rt2 + rt4;      // a - b + (c - d)
+			x[base+Ad3] = rt1 - rt3;      // a + b - (c + d)
+			x[base+Ad4] = rt2 - rt4;      // a - b - (c - d)
+		 }
+
+		if (Nlog2 > 2) {
+			 // third + stages computed here
+			gpSize = 4;
+			numBfs = 2;
+			numGps = numGps / 2;
+			for (stage=2; stage<Nlog2; stage++) {
+				for (gpNum=0; gpNum<numGps; gpNum++) {
+					Ad0 = gpNum * gpSize * 2;
+					Ad1 = Ad0;     // 1st butterfly is different from others - no mults needed
+					Ad2 = Ad1 + gpSize;
+					Ad3 = Ad1 + gpSize / 2;
+					Ad4 = Ad3 + gpSize;
+					rt1 = x[base+Ad1];
+					x[base+Ad1] = x[base+Ad1] + x[base+Ad2];
+					x[base+Ad2] = rt1 - x[base+Ad2];
+					rt1 = x[base+Ad3];
+					x[base+Ad3] = x[base+Ad3] + x[base+Ad4];
+					x[base+Ad4] = rt1 - x[base+Ad4];
+					for (bfNum=1; bfNum<numBfs; bfNum++) {
+					// subsequent BF's dealt with together
+						Ad1 = bfNum + Ad0;
+						Ad2 = Ad1 + gpSize;
+						Ad3 = gpSize - bfNum + Ad0;
+						Ad4 = Ad3 + gpSize;
+
+						CSAd = bfNum * numGps;
+						rt1 = x[base+Ad2] * C[CSAd] + x[base+Ad4] * S[CSAd];
+						rt2 = x[base+Ad4] * C[CSAd] - x[base+Ad2] * S[CSAd];
+
+						x[base+Ad2] = x[base+Ad1] - rt1;
+						x[base+Ad1] = x[base+Ad1] + rt1;
+						x[base+Ad4] = x[base+Ad3] + rt2;
+						x[base+Ad3] = x[base+Ad3] - rt2;
+
+					} /* end bfNum loop */
+				} /* end gpNum loop */
+				gpSize *= 2;
+				numBfs *= 2;
+				numGps = numGps / 2;
+			} /* end for all stages */
+		} /* end if Nlog2 > 2 */
+
+		if (inverse)  {
+			for (i=0; i<maxN; i++)
+			x[base+i] = x[base+i] / maxN;
+		}
+	}
+
+	void transposeR (float[] x, int maxN) {
+		int   r, c;
+		float  rTemp;
+
+		for (r=0; r<maxN; r++)  {
+			for (c=r; c<maxN; c++) {
+				if (r != c)  {
+					rTemp = x[r*maxN + c];
+					x[r*maxN + c] = x[c*maxN + r];
+					x[c*maxN + r] = rTemp;
+				}
+			}
+		}
+	}
+	
+	int log2 (int x) {
+		int count = 31;
+		while (!btst(x, count))
+			count--;
+		return count;
+	}
+
+	
+	private boolean btst (int  x, int bit) {
+		return ((x & (1<<bit)) != 0);
+	}
+
+	void BitRevRArr (float[] x, int base, int bitlen, int maxN) {
+		for (int i=0; i<maxN; i++)
+			tempArr[i] = x[base+bitrev[i]];
+		for (int i=0; i<maxN; i++)
+			x[base+i] = tempArr[i];
+	}
+
+	private int bitRevX (int  x, int bitlen) {
+		int  temp = 0;
+		for (int i=0; i<=bitlen; i++)
+			if ((x & (1<<i)) !=0)
+				temp  |= (1<<(bitlen-i-1));
+		return temp;
+	}
+
+	private int bset (int x, int bit) {
+		x |= (1<<bit);
+		return x;
+	}
+
+	/** Returns an 8-bit power spectrum, log-scaled to 1-254. The image in this
+		FHT is assumed to be in the frequency domain. */
+	public ImageProcessor getPowerSpectrum () {
+		if (!isFrequencyDomain)
+			throw new  IllegalArgumentException("Frequency domain image required");
+		int base;
+		float  r, scale;
+		float min = Float.MAX_VALUE;
+  		float max = Float.MIN_VALUE;
+   		float[] fps = new float[maxN*maxN];
+ 		byte[] ps = new byte[maxN*maxN];
+		float[] fht = (float[])getPixels();
+
+  		for (int row=0; row<maxN; row++) {
+			fht2ps(row, maxN, fht, fps);
+			base = row * maxN;
+			for (int col=0; col<maxN; col++) {
+				r = fps[base+col];
+				if (r<min)
+					min = r;
+				if (r>max)
+					max = r;
+			}
+		}
+
+		max = (float)Math.log(max);
+		min = (float)Math.log(min);
+		if (Float.isNaN(min) || max-min>50)
+			min = max - 50; //display range not more than approx e^50
+		scale = (float)(253.999/(max-min));
+		
+		//long t0 = System.currentTimeMillis();
+		for (int row=0; row<maxN; row++) {
+			base = row*maxN;
+			for (int col=0; col<maxN; col++) {
+				r = fps[base+col];
+				r = ((float)Math.log(r)-min)*scale;
+				if (Float.isNaN(r) || r<0)
+					r = 0f;
+				ps[base+col] = (byte)(r+1f); // 1 is min value
+			}
+		}
+		//long t1 = System.currentTimeMillis();
+		//IJ.log(""+(t1-t0));
+		ImageProcessor ip = new ByteProcessor(maxN, maxN, ps);
+		swapQuadrants(ip);
+		return ip;
+	}
+	
+	/** Returns the unscaled 32-bit power spectrum. */
+	public FloatProcessor getRawPowerSpectrum() {
+		if (!isFrequencyDomain)
+			throw new  IllegalArgumentException("Frequency domain image required");
+   		float[] fps = new float[maxN*maxN];
+		float[] fht = (float[])getPixels();
+  		for (int row=0; row<maxN; row++)
+			fht2ps(row, maxN, fht, fps);
+		return new FloatProcessor(maxN, maxN, fps);
+	}
+
+	/** Power Spectrum of one row from 2D Hartley Transform. */
+ 	private void fht2ps(int row, int maxN, float[] fht, float[] ps) {
+ 		int base = row*maxN;
+		int l;
+		for (int c=0; c<maxN; c++) {
+			l = ((maxN-row)%maxN) * maxN + (maxN-c)%maxN;
+			ps[base+c] = (sqr(fht[base+c]) + sqr(fht[l]))/2f;
+ 		}
+	}
+
+	/** Converts this FHT to a complex Fourier transform and returns it as a two slice stack.
+	*	Author: Joachim Wesner
+	*/
+	public ImageStack getComplexTransform() {
+		if (!isFrequencyDomain)
+			throw new  IllegalArgumentException("Frequency domain image required");
+		float[] fht = (float[])getPixels();
+		float[] re = new float[maxN*maxN];
+		float[] im = new float[maxN*maxN];
+		for (int i=0; i<maxN; i++) {
+			FHTreal(i, maxN, fht, re);
+			FHTimag(i, maxN, fht, im);
+		}
+		swapQuadrants(new FloatProcessor(maxN, maxN, re));
+		swapQuadrants(new FloatProcessor(maxN, maxN, im));
+		ImageStack stack = new ImageStack(maxN, maxN);
+		stack.addSlice("Real", re);
+		stack.addSlice("Imaginary", im);
+		return stack;
+	}
+
+	/**	 FFT real value of one row from 2D Hartley Transform.
+	*	Author: Joachim Wesner
+	*/
+      void FHTreal(int row, int maxN, float[] fht, float[] real) {
+            int base = row*maxN;
+            int offs = ((maxN-row)%maxN) * maxN;
+            for (int c=0; c<maxN; c++) {
+                  real[base+c] = (fht[base+c] + fht[offs+((maxN-c)%maxN)])*0.5f;
+            }
+      }
+
+
+	/** FFT imag value of one row from 2D Hartley Transform.
+	*	Author: Joachim Wesner
+	*/
+      void FHTimag(int row, int maxN, float[] fht, float[] imag) {
+            int base = row*maxN;
+            int offs = ((maxN-row)%maxN) * maxN;
+            for (int c=0; c<maxN; c++) {
+                  imag[base+c] = (-fht[base+c] + fht[offs+((maxN-c)%maxN)])*0.5f;
+            }
+      }
+
+	ImageProcessor calculateAmplitude(float[] fht, int maxN) {
+   		float[] amp = new float[maxN*maxN];
+   		for (int row=0; row<maxN; row++) {
+			amplitude(row, maxN, fht, amp);
+		}
+		ImageProcessor ip = new FloatProcessor(maxN, maxN, amp, null);
+		swapQuadrants(ip);
+		return ip;
+	}
+
+	/** Amplitude of one row from 2D Hartley Transform. */
+ 	void amplitude(int row, int maxN, float[] fht, float[] amplitude) {
+ 		int base = row*maxN;
+		int l;
+		for (int c=0; c<maxN; c++) {
+			l = ((maxN-row)%maxN) * maxN + (maxN-c)%maxN;
+			amplitude[base+c] = (float)Math.sqrt(sqr(fht[base+c]) + sqr(fht[l]));
+ 		}
+	}
+
+	private float sqr(float x) {
+		return x*x;
+	}
+
+	/**	Swap quadrants 1 and 3 and 2 and 4 of the specified ImageProcessor 
+		so the power spectrum origin is at the center of the image.
+		<pre>
+		    2 1
+		    3 4
+		</pre>
+	*/
+ 	public void swapQuadrants(ImageProcessor ip) {
+ 		FFT.swapQuadrants(ip);
+	}
+
+	/**	Swap quadrants 1 and 3 and 2 and 4 of the image
+		contained in this FHT. */
+ 	public void swapQuadrants () {
+ 		swapQuadrants(this);
+ 	}
+ 	
+	void changeValues(ImageProcessor ip, int v1, int v2, int v3) {
+		byte[] pixels = (byte[])ip.getPixels();
+		int v;
+		for (int i=0; i<pixels.length; i++) {
+			v = pixels[i]&255;
+			if (v>=v1 && v<=v2)
+				pixels[i] = (byte)v3;
+		}
+	}
+
+	/** Returns the image resulting from the point by point Hartley multiplication
+		of this image and the specified image. Both images are assumed to be in
+		the frequency domain. Multiplication in the frequency domain is equivalent 
+		to convolution in the space domain. */
+	public FHT multiply(FHT fht) {
+		return multiply(fht, false);
+	}
+
+	/** Returns the image resulting from the point by point Hartley conjugate 
+		multiplication of this image and the specified image. Both images are 
+		assumed to be in the frequency domain. Conjugate multiplication in
+		the frequency domain is equivalent to correlation in the space domain. */
+	public FHT conjugateMultiply(FHT fht) {
+		return multiply(fht, true);
+	}
+
+	FHT multiply(FHT fht, boolean  conjugate) {
+		int rowMod, cMod, colMod;
+		double h2e, h2o;
+		float[] h1 = (float[])getPixels();
+		float[] h2 = (float[])fht.getPixels();
+		float[] tmp = new float[maxN*maxN];
+		for (int r =0; r<maxN; r++) {
+			rowMod = (maxN - r) % maxN;
+			for (int c=0; c<maxN; c++) {
+				colMod = (maxN - c) % maxN;
+				h2e = (h2[r * maxN + c] + h2[rowMod * maxN + colMod]) / 2;
+				h2o = (h2[r * maxN + c] - h2[rowMod * maxN + colMod]) / 2;
+				if (conjugate) 
+					tmp[r * maxN + c] = (float)(h1[r * maxN + c] * h2e - h1[rowMod * maxN + colMod] * h2o);
+				else
+					tmp[r * maxN + c] = (float)(h1[r * maxN + c] * h2e + h1[rowMod * maxN + colMod] * h2o);
+			}
+		}
+		FHT fht2 =  new FHT(new FloatProcessor(maxN, maxN, tmp, null));
+		fht2.isFrequencyDomain = true;
+		return fht2;
+	}
+		
+	/** Returns the image resulting from the point by point Hartley division
+		of this image by the specified image. Both images are assumed to be in
+		the frequency domain. Division in the frequency domain is equivalent 
+		to deconvolution in the space domain. */
+	public FHT divide(FHT fht) {
+		int rowMod, cMod, colMod;
+		double mag, h2e, h2o;
+		float[] h1 = (float[])getPixels();
+		float[] h2 = (float[])fht.getPixels();
+		float[] out = new float[maxN*maxN];
+		for (int r=0; r<maxN; r++) {
+			rowMod = (maxN - r) % maxN;
+			for (int c=0; c<maxN; c++) {
+				colMod = (maxN - c) % maxN;
+				mag =h2[r*maxN+c] * h2[r*maxN+c] + h2[rowMod*maxN+colMod] * h2[rowMod*maxN+colMod];
+				if (mag<1e-20)
+					mag = 1e-20;
+				h2e = (h2[r*maxN+c] + h2[rowMod*maxN+colMod]);
+				h2o = (h2[r*maxN+c] - h2[rowMod*maxN+colMod]);
+				double tmp = (h1[r*maxN+c] * h2e - h1[rowMod*maxN+colMod] * h2o);
+				out[r*maxN+c] = (float)(tmp/mag);
+			}
+		}
+		FHT fht2 = new FHT(new FloatProcessor(maxN, maxN, out, null));
+		fht2.isFrequencyDomain = true;
+		return fht2;
+	}
+			
+	/** Enables/disables display of the progress bar during transforms. */
+	public void setShowProgress(boolean showProgress) {
+		this.showProgress = showProgress;
+	}
+	
+	/** Returns a clone of this FHT. */
+	public FHT getCopy() {
+		ImageProcessor ip = super.duplicate();
+		FHT fht = new FHT(ip);
+		fht.isFrequencyDomain = isFrequencyDomain;
+		fht.quadrantSwapNeeded = quadrantSwapNeeded;
+		fht.rgb = rgb;
+		fht.originalWidth = originalWidth;
+		fht.originalHeight = originalHeight;
+		fht.originalBitDepth = originalBitDepth;		
+		fht.originalColorModel = originalColorModel;		
+		fht.powerSpectrumMean = powerSpectrumMean;		
+		return fht;
+	}
+		
+	public static boolean isPowerOf2(int n) {
+		int i=2;
+		while(i<n) i *= 2;
+		return i==n;
+	}
+
+	/** Returns a string containing information about this FHT. */
+	public String toString() {
+		return "FHT, " + getWidth() + "x"+getHeight() + ", fd=" + isFrequencyDomain;
+	}
+	
+}
diff --git a/src/ij/process/FloatBlitter.java b/src/ij/process/FloatBlitter.java
new file mode 100644
index 0000000..42b06ef
--- /dev/null
+++ b/src/ij/process/FloatBlitter.java
@@ -0,0 +1,141 @@
+package ij.process;
+import ij.Prefs;
+import java.awt.*;
+
+/** This class does bit blitting of 32-bit floating-point images. */
+public class FloatBlitter implements Blitter {
+
+	public static float divideByZeroValue;
+	
+	private FloatProcessor ip;
+	private int width, height;
+	private float[] pixels;
+	
+	static {
+		divideByZeroValue = (float)Prefs.getDouble(Prefs.DIV_BY_ZERO_VALUE, Float.POSITIVE_INFINITY);
+		if (divideByZeroValue==Float.MAX_VALUE)
+			divideByZeroValue = Float.POSITIVE_INFINITY;
+	}
+	
+	/** Constructs a FloatBlitter from a FloatProcessor. */
+	public FloatBlitter(FloatProcessor ip) {
+		this.ip = ip;
+		width = ip.getWidth();
+		height = ip.getHeight();
+		pixels = (float[])ip.getPixels();
+	}
+
+	public void setTransparentColor(Color c) {
+	}
+
+	/** Copies the float image in 'ip' to (x,y) using the specified mode. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		Rectangle r1, r2;
+		int srcIndex, dstIndex;
+		int xSrcBase, ySrcBase;
+		float[] srcPixels;
+		
+		if (!(ip instanceof FloatProcessor))
+			ip = ip.convertToFloat();
+		int srcWidth = ip.getWidth();
+		int srcHeight = ip.getHeight();
+		r1 = new Rectangle(srcWidth, srcHeight);
+		r1.setLocation(xloc, yloc);
+		r2 = new Rectangle(width, height);
+		if (!r1.intersects(r2))
+			return;
+		srcPixels = (float [])ip.getPixels();
+		r1 = r1.intersection(r2);
+		xSrcBase = (xloc<0)?-xloc:0;
+		ySrcBase = (yloc<0)?-yloc:0;
+		boolean useDBZValue = !Float.isInfinite(divideByZeroValue);
+		float src, dst;
+		for (int y=r1.y; y<(r1.y+r1.height); y++) {
+			srcIndex = (y-yloc)*srcWidth + (r1.x-xloc);
+			dstIndex = y * width + r1.x;
+			switch (mode) {
+				case COPY: case COPY_INVERTED: case COPY_TRANSPARENT:
+					for (int i=r1.width; --i>=0;)
+						pixels[dstIndex++] = srcPixels[srcIndex++];
+					break;
+				case COPY_ZERO_TRANSPARENT:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++];
+						if (src==0f)
+							dst = pixels[dstIndex];
+						else
+							dst = src;
+						pixels[dstIndex++] = dst;
+					}
+					break;
+				case ADD:
+					for (int i=r1.width; --i>=0; srcIndex++, dstIndex++)
+						pixels[dstIndex] = srcPixels[srcIndex]+pixels[dstIndex];
+					break;
+				case AVERAGE:
+					for (int i=r1.width; --i>=0;) {
+						dst =(srcPixels[srcIndex++]+pixels[dstIndex])/2;
+						pixels[dstIndex++] = dst;
+					}
+					break;
+				case DIFFERENCE:
+					for (int i=r1.width; --i>=0; srcIndex++, dstIndex++) {
+						dst = pixels[dstIndex]-srcPixels[srcIndex];
+						pixels[dstIndex] = dst<0?-dst:dst;
+					}
+					break;
+				case SUBTRACT:
+					for (int i=r1.width; --i>=0; srcIndex++, dstIndex++)
+						pixels[dstIndex] = pixels[dstIndex]-srcPixels[srcIndex];
+					break;
+				case MULTIPLY:
+					for (int i=r1.width; --i>=0; srcIndex++, dstIndex++)
+						pixels[dstIndex] = srcPixels[srcIndex]*pixels[dstIndex];
+					break;
+				case DIVIDE:
+					for (int i=r1.width; --i>=0; srcIndex++, dstIndex++) {
+							src = srcPixels[srcIndex];
+							if (useDBZValue && src==0.0)
+								pixels[dstIndex] = divideByZeroValue;
+							else
+								pixels[dstIndex] = pixels[dstIndex]/src;
+						}
+					break;
+				case AND:
+					for (int i=r1.width; --i>=0;) {
+						dst = (int)srcPixels[srcIndex++]&(int)pixels[dstIndex];
+						pixels[dstIndex++] = dst;
+					}
+					break;
+				case OR:
+					for (int i=r1.width; --i>=0;) {
+						dst = (int)srcPixels[srcIndex++]|(int)pixels[dstIndex];
+						pixels[dstIndex++] = dst;
+					}
+					break;
+				case XOR:
+					for (int i=r1.width; --i>=0;) {
+						dst = (int)srcPixels[srcIndex++]^(int)pixels[dstIndex];
+						pixels[dstIndex++] = dst;
+					}
+					break;
+				case MIN:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++];
+						dst = pixels[dstIndex];
+						if (src<dst) dst = src;
+						pixels[dstIndex++] = dst;
+					}
+					break;
+				case MAX:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++];
+						dst = pixels[dstIndex];
+						if (src>dst) dst = src;
+						pixels[dstIndex++] = dst;
+					}
+					break;
+			}
+		}
+	}
+}
diff --git a/src/ij/process/FloatPolygon.java b/src/ij/process/FloatPolygon.java
new file mode 100644
index 0000000..7fb7a02
--- /dev/null
+++ b/src/ij/process/FloatPolygon.java
@@ -0,0 +1,237 @@
+package ij.process;
+import java.awt.Rectangle;
+import java.awt.Polygon;
+import java.awt.geom.Rectangle2D;
+
+/** Used by the Roi classes to return float coordinate arrays and to
+	determine if a point is inside or outside of spline fitted selections. */
+public class FloatPolygon {
+	private Rectangle bounds;
+	private float minX, minY, maxX, maxY;
+
+	/** The number of points. */
+	public int npoints;
+
+	/* The array of x coordinates. */
+	public float xpoints[];
+
+	/* The array of y coordinates. */
+	public float ypoints[];
+
+	/** Constructs an empty FloatPolygon. */ 
+	public FloatPolygon() {
+		npoints = 0;
+		xpoints = new float[10];
+		ypoints = new float[10];
+	}
+
+	/** Constructs a FloatPolygon from x and y arrays. */ 
+	public FloatPolygon(float xpoints[], float ypoints[]) {
+		if (xpoints.length!=ypoints.length)
+			throw new IllegalArgumentException("xpoints.length!=ypoints.length");
+		this.npoints = xpoints.length;
+		this.xpoints = xpoints;
+		this.ypoints = ypoints;
+	}
+
+	/** Constructs a FloatPolygon from x and y arrays. */ 
+	public FloatPolygon(float xpoints[], float ypoints[], int npoints) {
+		this.npoints = npoints;
+		this.xpoints = xpoints;
+		this.ypoints = ypoints;
+	}
+		
+	/** Returns 'true' if the point (x,y) is inside this polygon. This is a Java
+	 *  version of the remarkably small C program by W. Randolph Franklin at
+	 *  http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html#The%20C%20Code
+	 * 
+	 *  In the absence of numerical errors, x coordinates exactly at a boundary are taken as if
+	 *  in the area immediately at the left of the boundary. For horizontal boundaries,
+	 *  y coordinates exactly at the border are taken as if in the area immediately above it
+	 *  (i.e., in decreasing y direction).
+	 *  The ImageJ convention of an offset of 0.5 pixels between pixel centers and outline
+	 *  coordinates is not taken into consideration; this method returns the purely
+	 *  geometrical relationship.
+	 */
+	public boolean contains(double x, double y) {
+		boolean inside = false;
+		for (int i=0, j=npoints-1; i<npoints; j=i++) {
+			if (((ypoints[i]>=y)!=(ypoints[j]>=y)) &&
+					(x>((double)xpoints[j]-xpoints[i])*((double)y-ypoints[i])/((double)ypoints[j]-ypoints[i])+(double)xpoints[i]))
+				inside = !inside;
+		}
+		return inside;
+	}
+
+	/** A version of contains() that accepts float arguments. */
+	public boolean contains(float x, float y) {
+		return contains((double)x, (double)y);
+	}
+
+	public Rectangle getBounds() {
+		if (npoints==0)
+			return new Rectangle();
+		if (bounds==null)
+			calculateBounds(xpoints, ypoints, npoints);
+		return bounds.getBounds();
+	}
+
+	public Rectangle2D.Double getFloatBounds() {
+		if (npoints==0)
+			return new Rectangle2D.Double();
+		if (bounds==null)
+			calculateBounds(xpoints, ypoints, npoints);
+		return new Rectangle2D.Double(minX, minY, maxX-minX, maxY-minY);
+	}
+
+	void calculateBounds(float[] xpoints, float[] ypoints, int npoints) {
+		minX = Float.MAX_VALUE;
+		minY = Float.MAX_VALUE;
+		maxX = Float.MIN_VALUE;
+		maxY = Float.MIN_VALUE;
+		for (int i=0; i<npoints; i++) {
+			float x = xpoints[i];
+			minX = Math.min(minX, x);
+			maxX = Math.max(maxX, x);
+			float y = ypoints[i];
+			minY = Math.min(minY, y);
+			maxY = Math.max(maxY, y);
+		}
+		int iMinX = (int)Math.floor(minX);
+		int iMinY = (int)Math.floor(minY);
+		bounds = new Rectangle(iMinX, iMinY, (int)(maxX-iMinX+0.5), (int)(maxY-iMinY+0.5));
+	}
+
+	public void addPoint(float x, float y) {
+		if (npoints==xpoints.length) {
+			float[] tmp = new float[npoints*2];
+			System.arraycopy(xpoints, 0, tmp, 0, npoints);
+			xpoints = tmp;
+			tmp = new float[npoints*2];
+			System.arraycopy(ypoints, 0, tmp, 0, npoints);
+			ypoints = tmp;
+		}
+		xpoints[npoints] = x;
+		ypoints[npoints] = y;
+		npoints++;
+		bounds = null;
+	}
+
+	public void addPoint(double x, double y) {
+		addPoint((float)x, (float)y);
+	}
+	
+	public FloatPolygon duplicate() {
+		int n = this.npoints;
+		float[] xpoints = new float[n];
+		float[] ypoints = new float[n];
+		System.arraycopy(this.xpoints, 0, xpoints, 0, n);
+		System.arraycopy(this.ypoints, 0, ypoints, 0, n);	
+		return new FloatPolygon(xpoints, ypoints, n);
+	}
+	
+	/* Returns the length of this polygon or line. */
+	public double getLength(boolean isLine) {
+		double dx, dy;
+		double length = 0.0;
+		for (int i=0; i<(npoints-1); i++) {
+			dx = xpoints[i+1]-xpoints[i];
+			dy = ypoints[i+1]-ypoints[i];
+			length += Math.sqrt(dx*dx+dy*dy);
+		}
+		if (!isLine) {
+			dx = xpoints[0]-xpoints[npoints-1];
+			dy = ypoints[0]-ypoints[npoints-1];
+			length += Math.sqrt(dx*dx+dy*dy);
+		}
+		return length;
+	}
+
+	/** Uses the gift wrap algorithm to find the convex hull of all points in
+	 *  this FloatPolygon and returns it as a new FloatPolygon.
+	 *  The sequence of the points on the convex hull is counterclockwise. */
+	public FloatPolygon getConvexHull() {
+		float[] xx = new float[npoints];
+		float[] yy = new float[npoints];
+		int n2 = 0;
+		float smallestY = Float.MAX_VALUE;
+		for (int i=0; i<npoints; i++) {
+			float y = ypoints[i];
+			if (y<smallestY)
+			smallestY = y;
+		}
+		float smallestX = Float.MAX_VALUE;
+		int p1 = 0;               // find the starting point: among all points with the smallest y, the one with the smallest x
+		for (int i=0; i<npoints; i++) {
+			float x = xpoints[i];
+			float y = ypoints[i];
+			if (y==smallestY && x<smallestX) {
+				smallestX = x;
+				p1 = i;
+			}
+		}
+		int pstart = p1;          // the start point is always on the convex hull
+		int count = 0;
+		do {
+			double x1 = xpoints[p1];
+			double y1 = ypoints[p1];
+			int p2 = p1;
+			double x2=0, y2=0;
+			do {
+				p2++; if (p2==npoints) p2 = 0;
+				if (p2 == p1) break;           // all points have the same coordinates as p1
+				x2 = xpoints[p2];              // p2 is a candidate for the convex hull
+				y2 = ypoints[p2];
+			} while (x2 == x1 && y2 == y1);    // make sure p2 is not identical to p1
+
+			int p3 = p2+1; if (p3==npoints) p3 = 0;
+			if (p2 != p1) do {
+				double x3 = xpoints[p3];
+				double y3 = ypoints[p3];
+				//The following is the cross product r12 x r23 = (x2-x1)*(y3-y2) - (y2-y1)*(x3-x2),
+				//where r12 and r23 are the vectors from p1 to p2 and p2 to p3, respectively.
+				//It is positive if the path from p1 via p2 to p3 bends clockwise at p2
+				double determinate = x1*(y2-y3)-y1*(x2-x3)+(y3*x2-y2*x3);
+				boolean collinearAndFurther = false;
+				if (determinate == 0 && p3 != p2) { //avoid collinear points on the hull: take longest possible side length
+					double d2sqr = sqr(x2-x1) + sqr(y2-y1);
+					double d3sqr = sqr(x3-x1) + sqr(y3-y1);
+					collinearAndFurther = d3sqr > d2sqr;
+				}
+				if (determinate > 0 || collinearAndFurther) {
+					x2=x3; y2=y3; p2=p3;       // p2 is not on the convex hull, p3 becomes the new candidate
+				}
+				p3 ++; if (p3==npoints) p3 = 0;
+			} while (p3 != p1);                // all points have been checked whether they are the next one on the convex hull
+
+			xx[n2] = (float)x1;                // save p1 as a point on the convex hull
+			yy[n2] = (float)y1;
+			n2++;
+
+			if (p2 == p1) break;               // happens only if there was only one unique point
+			p1 = p2;
+			if (n2 > 1 && xpoints[p1]==xx[0] && ypoints[p1]==yy[0]) break; //all done but pstart was missed because of duplicate points
+		} while (p1!=pstart);
+		return new FloatPolygon(xx, yy, n2);
+	}
+	
+	public synchronized void translate(double x, double y) {
+		float fx = (float)x;
+		float fy = (float)y;
+		for (int i=0; i<npoints; i++) {
+			xpoints[i] += fx;
+			ypoints[i] += fy;
+		}
+	}
+
+	private double sqr(double x) {return x*x;}
+	
+    private double crossProduct(double x1, double y1, double x2, double y2) {
+        return (double)x1*y2 - (double)x2*y1;
+    }
+
+	public String toString() {
+		return "FloatPolygon[npoints="+npoints+"]";
+	}
+	
+}
diff --git a/src/ij/process/FloatProcessor.java b/src/ij/process/FloatProcessor.java
new file mode 100644
index 0000000..6090ed2
--- /dev/null
+++ b/src/ij/process/FloatProcessor.java
@@ -0,0 +1,1154 @@
+package ij.process;
+
+import java.util.*;
+import java.awt.*;
+import java.awt.image.*;
+import ij.gui.*;
+
+/** This is an 32-bit floating-point image and methods that operate on that image. */
+public class FloatProcessor extends ImageProcessor {
+
+	private float min, max, snapshotMin, snapshotMax;
+	private float[] pixels;
+	protected byte[] pixels8;
+	private float[] snapshotPixels = null;
+	private float fillColor =  Float.MAX_VALUE;
+	private boolean fixedScale = false;
+	private float bgValue;
+
+	/** Creates a new FloatProcessor using the specified pixel array. */
+	public FloatProcessor(int width, int height, float[] pixels) {
+		this(width, height, pixels, null);
+	}
+
+	/** Creates a new FloatProcessor using the specified pixel array and ColorModel. */
+	public FloatProcessor(int width, int height, float[] pixels, ColorModel cm) {
+		if (pixels!=null && width*height!=pixels.length)
+			throw new IllegalArgumentException(WRONG_LENGTH);
+		this.width = width;
+		this.height = height;
+		this.pixels = pixels;
+		this.cm = cm;
+		resetRoi();
+	}
+
+	/** Creates a blank FloatProcessor using the default grayscale LUT that
+		displays zero as black. Call invertLut() to display zero as white. */
+	public FloatProcessor(int width, int height) {
+		this(width, height, new float[width*height], null);
+	}
+
+	/** Creates a FloatProcessor from an int array using the default grayscale LUT. */
+	public FloatProcessor(int width, int height, int[] pixels) {
+		this(width, height);
+		for (int i=0; i<pixels.length; i++)
+			this.pixels[i] = (float)(pixels[i]);
+	}
+	
+	/** Creates a FloatProcessor from a double array using the default grayscale LUT. */
+	public FloatProcessor(int width, int height, double[] pixels) {
+		this(width, height);
+		for (int i=0; i<pixels.length; i++)
+			this.pixels[i] = (float)pixels[i];
+	}
+	
+	/** Creates a FloatProcessor from a 2D float array using the default LUT. */
+	public FloatProcessor(float[][] array) {
+		width = array.length;
+		height = array[0].length;
+		pixels = new float[width*height];
+		int i=0;
+		for (int y=0; y<height; y++) {
+			for (int x=0; x<width; x++) {
+				pixels[i++] = array[x][y];
+			}
+		}
+		resetRoi();
+	}
+
+	/** Creates a FloatProcessor from a 2D int array. */
+	public FloatProcessor(int[][] array) {
+		width = array.length;
+		height = array[0].length;
+		pixels = new float[width*height];
+		int i=0;
+		for (int y=0; y<height; y++) {
+			for (int x=0; x<width; x++) {
+				pixels[i++] = (float)array[x][y];
+			}
+		}
+		resetRoi();
+	}
+
+	/**
+	Calculates the minimum and maximum pixel value for the entire image. 
+	Returns without doing anything if fixedScale has been set true as a result
+	of calling setMinAndMax(). In this case, getMin() and getMax() return the
+	fixed min and max defined by setMinAndMax(), rather than the calculated min
+	and max.
+	@see #getMin()
+	@see #getMin()
+	*/
+	public void findMinAndMax() {
+		if (fixedScale)
+			return;
+		float min = Float.MAX_VALUE;
+		float max = -Float.MAX_VALUE;
+		int i = 0;
+		for (; i<width*height; i++) {
+			if (!(Float.isNaN(pixels[i])||Float.isInfinite(pixels[i]))) {
+				min = max = pixels[i];
+				i++;
+				break;
+			}
+		}
+		for (; i<width*height; i++) {
+			float value = pixels[i];
+			if (!Float.isInfinite(value)) {
+				if (value<min)
+					min = value;
+				else if (value>max)
+					max = value;
+			}
+		}
+		this.min = min; this.max = max;
+		minMaxSet = true;
+	}
+
+	/** Sets the min and max variables that control how real
+	 * pixel values are mapped to 0-255 screen values. Use
+	 * resetMinAndMax() to enable auto-scaling;
+	 * @see ij.plugin.frame.ContrastAdjuster 
+	*/
+	public void setMinAndMax(double minimum, double maximum) {
+		if (minimum==0.0 && maximum==0.0) {
+			resetMinAndMax();
+			return;
+		}
+		min = (float)minimum;
+		max = (float)maximum;
+		fixedScale = true;
+		minMaxSet = true;
+		resetThreshold();
+	}
+
+	/** Recalculates the min and max values used to scale pixel
+		values to 0-255 for display. This ensures that this 
+		FloatProcessor is set up to correctly display the image. */
+	public void resetMinAndMax() {
+		fixedScale = false;
+		findMinAndMax();
+		resetThreshold();
+	}
+
+	/** Returns the smallest displayed pixel value. */
+	public double getMin() {
+		if (!minMaxSet) findMinAndMax();
+		return min;
+	}
+
+	/** Returns the largest displayed pixel value. */
+	public double getMax() {
+		if (!minMaxSet) findMinAndMax();
+		return max;
+	}
+
+	/** Create an 8-bit AWT image by scaling pixels in the range min-max to 0-255. */
+	public Image createImage() {
+		if (!minMaxSet)
+			findMinAndMax();
+		boolean firstTime = pixels8==null;
+		boolean thresholding = minThreshold!=NO_THRESHOLD && lutUpdateMode<NO_LUT_UPDATE;
+		//ij.IJ.log("createImage: "+firstTime+"  "+lutAnimation+"  "+thresholding);
+		if (firstTime || !lutAnimation)
+			create8BitImage(thresholding&&lutUpdateMode==RED_LUT);
+		if (cm==null)
+			makeDefaultColorModel();
+		if (thresholding) {
+			int size = width*height;
+			double value;
+			if (lutUpdateMode==BLACK_AND_WHITE_LUT) {
+				for (int i=0; i<size; i++) {
+					value = pixels[i];
+					if (value>=minThreshold && value<=maxThreshold)
+						pixels8[i] = (byte)255;
+					else
+						pixels8[i] = (byte)0;
+				}
+			} else { // threshold red
+				for (int i=0; i<size; i++) {
+					value = pixels[i];
+					if (value>=minThreshold && value<=maxThreshold)
+						pixels8[i] = (byte)255;
+				}
+			}
+		}
+		return createBufferedImage();
+	}
+		
+	// creates 8-bit image by linearly scaling from float to 8-bits
+	private byte[] create8BitImage(boolean thresholding) {
+		int size = width*height;
+		if (pixels8==null)
+			pixels8 = new byte[size];
+		double value;
+		int ivalue;
+		double min2 = getMin();
+		double max2 = getMax();
+		double scale = 255.0/(max2-min2);
+		int maxValue = thresholding?254:255;
+		for (int i=0; i<size; i++) {
+			value = pixels[i]-min2;
+			if (value<0.0) value=0.0;
+			ivalue = (int)(value*scale+0.5);
+			if (ivalue>maxValue) ivalue = maxValue;
+			pixels8[i] = (byte)ivalue;
+		}
+		return pixels8;
+	}
+	
+	@Override
+	byte[] create8BitImage() {
+		return create8BitImage(false);
+	}
+		
+	Image createBufferedImage() {
+		if (raster==null) {
+			SampleModel sm = getIndexSampleModel();
+			DataBuffer db = new DataBufferByte(pixels8, width*height, 0);
+			raster = Raster.createWritableRaster(sm, db, null);
+		}
+		if (image==null || cm!=cm2) {
+			if (cm==null) cm = getDefaultColorModel();
+			image = new BufferedImage(cm, raster, false, null);
+			cm2 = cm;
+		}
+		lutAnimation = false;
+		return image;
+	}
+		
+	/** Returns this image as an 8-bit BufferedImage. */
+	public BufferedImage getBufferedImage() {
+		return convertToByte(true).getBufferedImage();
+	}
+
+	/** Returns a new, blank FloatProcessor with the specified width and height. */
+	public ImageProcessor createProcessor(int width, int height) {
+		ImageProcessor ip2 = new FloatProcessor(width, height, new float[width*height], getColorModel());
+		ip2.setMinAndMax(getMin(), getMax());
+		ip2.setInterpolationMethod(interpolationMethod);
+		return ip2;
+	}
+
+	public void snapshot() {
+		snapshotWidth=width;
+		snapshotHeight=height;
+		snapshotMin=(float)getMin();
+		snapshotMax=(float)getMax();
+		if (snapshotPixels==null || (snapshotPixels!=null && snapshotPixels.length!=pixels.length))
+			snapshotPixels = new float[width * height];
+		System.arraycopy(pixels, 0, snapshotPixels, 0, width*height);
+	}
+	
+	public void reset() {
+		if (snapshotPixels==null)
+			return;
+		min=snapshotMin;
+		max=snapshotMax;
+		minMaxSet = true;
+		System.arraycopy(snapshotPixels,0,pixels,0,width*height);
+	}
+	
+	public void reset(ImageProcessor mask) {
+		if (mask==null || snapshotPixels==null)
+			return; 
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]==0)
+					pixels[i] = snapshotPixels[i];
+				i++;
+			}
+		}
+	}
+
+	/** Swaps the pixel and snapshot (undo) arrays. */
+	public void swapPixelArrays() {
+		if (snapshotPixels==null) return;	
+		float pixel;
+		for (int i=0; i<pixels.length; i++) {
+			pixel = pixels[i];
+			pixels[i] = snapshotPixels[i];
+			snapshotPixels[i] = pixel;
+		}
+	}
+
+	public void setSnapshotPixels(Object pixels) {
+		snapshotPixels = (float[])pixels;
+		snapshotWidth=width;
+		snapshotHeight=height;
+	}
+
+	public Object getSnapshotPixels() {
+		return snapshotPixels;
+	}
+
+	/** Returns a pixel value that must be converted using
+		Float.intBitsToFloat(). */
+	public int getPixel(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			return Float.floatToIntBits(pixels[y*width+x]);
+		else
+			return 0;
+	}
+
+	public final int get(int x, int y) {
+		return Float.floatToIntBits(pixels[y*width+x]);
+	}
+
+	public final void set(int x, int y, int value) {
+		pixels[y*width + x] = Float.intBitsToFloat(value);
+	}
+
+	public final int get(int index) {
+		return Float.floatToIntBits(pixels[index]);
+	}
+
+	public final void set(int index, int value) {
+		pixels[index] = Float.intBitsToFloat(value);
+	}
+
+	public final float getf(int x, int y) {
+		return pixels[y*width+x];
+	}
+
+	public final void setf(int x, int y, float value) {
+		pixels[y*width + x] = value;
+	}
+
+	public final float getf(int index) {
+		return pixels[index];
+	}
+	
+	public final void setf(int index, float value) {
+		pixels[index] = value;
+	}
+
+	/** Returns the value of the pixel at (x,y) in a
+		one element int array. iArray is an optiona
+		preallocated array. */
+	public int[] getPixel(int x, int y, int[] iArray) {
+		if (iArray==null) iArray = new int[1];
+		iArray[0] = (int)getPixelValue(x, y);
+		return iArray;
+	}
+
+	/** Sets a pixel in the image using a one element int array. */
+	public final void putPixel(int x, int y, int[] iArray) {
+		putPixelValue(x, y, iArray[0]);
+	}
+
+	/** Uses the current interpolation method (BILINEAR or BICUBIC) 
+		to calculate the pixel value at real coordinates (x,y). */
+	public double getInterpolatedPixel(double x, double y) {
+		if (interpolationMethod==BICUBIC)
+			return getBicubicInterpolatedPixel(x, y, this);
+		else {
+			if (x<0.0) x = 0.0;
+			if (x>=width-1.0) x = width-1.001;
+			if (y<0.0) y = 0.0;
+			if (y>=height-1.0) y = height-1.001;
+			return getInterpolatedPixel(x, y, pixels);
+		}
+	}
+		
+	final public int getPixelInterpolated(double x, double y) {
+		if (interpolationMethod==BILINEAR) {
+			if (x<0.0 || y<0.0 || x>=width-1 || y>=height-1)
+				return 0;
+			else
+				return Float.floatToIntBits((float)getInterpolatedPixel(x, y, pixels));
+		} else if (interpolationMethod==BICUBIC)
+			return Float.floatToIntBits((float)getBicubicInterpolatedPixel(x, y, this));
+		else
+			return getPixel((int)(x+0.5), (int)(y+0.5));
+	}
+
+	/** Stores the specified value at (x,y). The value is expected to be a
+		float that has been converted to an int using Float.floatToIntBits(). */
+	public final void putPixel(int x, int y, int value) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			pixels[y*width + x] = Float.intBitsToFloat(value);
+	}
+
+	/** Stores the specified real value at (x,y). */
+	public void putPixelValue(int x, int y, double value) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			pixels[y*width + x] = (float)value;
+	}
+
+	/** Returns the value of the pixel at (x,y) as a float. */
+	public float getPixelValue(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			return pixels[y*width + x];
+		else
+			return Float.NaN;
+	}
+
+	/** Draws a pixel in the current foreground color. */
+	public void drawPixel(int x, int y) {
+		if (x>=clipXMin && x<=clipXMax && y>=clipYMin && y<=clipYMax)
+			putPixel(x, y, Float.floatToIntBits(fillColor));
+	}
+
+	/** Returns a reference to the float array containing
+		this image's pixel data. */
+	public Object getPixels() {
+		return (Object)pixels;
+	}
+
+	/** Returns a copy of the pixel data. Or returns a reference to the
+		snapshot buffer if it is not null and 'snapshotCopyMode' is true.
+		@see ImageProcessor#snapshot
+		@see ImageProcessor#setSnapshotCopyMode
+	*/
+	public Object getPixelsCopy() {
+		if (snapshotCopyMode && snapshotPixels!=null) {
+			snapshotCopyMode = false;
+			return snapshotPixels;
+		} else {
+			float[] pixels2 = new float[width*height];
+			System.arraycopy(pixels, 0, pixels2, 0, width*height);
+			return pixels2;
+		}
+	}
+
+	public void setPixels(Object pixels) {
+		this.pixels = (float[])pixels;
+		resetPixels(pixels);
+		if (pixels==null) snapshotPixels = null;
+		if (pixels==null) pixels8 = null;
+	}
+
+	/** Copies the image contained in 'ip' to (xloc, yloc) using one of
+		the transfer modes defined in the Blitter interface. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		ip = ip.convertToFloat();
+		new FloatBlitter(this).copyBits(ip, xloc, yloc, mode);
+	}
+
+	public void applyTable(int[] lut) {}
+
+	private void process(int op, double value) {
+		float c, v1, v2;
+		//boolean resetMinMax = roiWidth==width && roiHeight==height && !(op==FILL);
+		c = (float)value;
+		float min2=0f, max2=0f;
+		if (op==INVERT)
+			{min2=(float)getMin(); max2=(float)getMax();}
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				v1 = pixels[i];
+				switch(op) {
+					case INVERT:
+						v2 = max2 - (v1 - min2);
+						break;
+					case FILL:
+						v2 = fillColor;
+						break;
+					case SET:
+						v2 = c;
+						break;
+					case ADD:
+						v2 = v1 + c;
+						break;
+					case MULT:
+						v2 = v1 * c;
+						break;
+					case GAMMA:
+						if (v1<=0f)
+							v2 = 0f;
+						else
+							v2 = (float)Math.exp(c*Math.log(v1));
+						break;
+					case LOG:
+						v2 = (float)Math.log(v1);
+						break;
+					case EXP:
+						v2 = (float)Math.exp(v1);
+						break;
+					case SQR:
+							v2 = v1*v1;
+						break;
+					case SQRT:
+						if (v1<=0f)
+							v2 = 0f;
+						else
+							v2 = (float)Math.sqrt(v1);
+						break;
+					case ABS:
+							v2 = (float)Math.abs(v1);
+						break;
+					case MINIMUM:
+						if (v1<value)
+							v2 = (float)value;
+						else
+							v2 = v1;
+						break;
+					case MAXIMUM:
+						if (v1>value)
+							v2 = (float)value;
+						else
+							v2 = v1;
+						break;
+					 default:
+						v2 = v1;
+				}
+				pixels[i++] = v2;
+			}
+		}
+	}
+
+	/** Each pixel in the image is inverted using p=max-(p-min), where 'min'
+		and 'max' are the display range limits set using setMinAndMax(). */
+	public void invert() {
+		process(INVERT, 0.0);
+	}
+	
+	public void add(int value) {process(ADD, value);}
+	public void add(double value) {process(ADD, value);}
+	public void set(double value) {process(SET, value);}
+	public void multiply(double value) {process(MULT, value);}
+	public void and(int value) {}
+	public void or(int value) {}
+	public void xor(int value) {}
+	public void gamma(double value) {process(GAMMA, value);}
+	public void log() {process(LOG, 0.0);}
+	public void exp() {process(EXP, 0.0);}
+	public void sqr() {process(SQR, 0.0);}
+	public void sqrt() {process(SQRT, 0.0);}
+	public void abs() {process(ABS, 0.0);}
+	public void min(double value) {process(MINIMUM, value);}
+	public void max(double value) {process(MAXIMUM, value);}
+
+
+	/** Fills the current rectangular ROI. */
+	public void fill() {process(FILL, 0.0);}
+
+	/** Fills pixels that are within roi and part of the mask.
+		Does nothing if the mask is not the same as the the ROI. */
+	public void fill(ImageProcessor mask) {
+		if (mask==null)
+			{fill(); return;}
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		int roiX=this.roiX, roiY=this.roiY;
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			return;
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]!=0)
+					pixels[i] = fillColor;
+				i++;
+			}
+		}
+	}
+
+	/** Does 3x3 convolution. */
+	public void convolve3x3(int[] kernel) {
+		filter3x3(CONVOLVE, kernel);
+	}
+
+	/** Filters using a 3x3 neighborhood. */
+	public void filter(int type) {
+		filter3x3(type, null);
+	}
+
+	/** 3x3 filter operations, code partly based on 3x3 convolution code
+	 *	contributed by Glynne Casteel. */
+	void filter3x3(int type, int[] kernel) {
+		float v1, v2, v3;			//input pixel values around the current pixel
+		float v4, v5, v6;
+		float v7, v8, v9;
+		float k1=0f, k2=0f, k3=0f;	//kernel values (used for CONVOLVE only)
+		float k4=0f, k5=0f, k6=0f;
+		float k7=0f, k8=0f, k9=0f;
+		float scale = 0f;
+		if (type==CONVOLVE) {
+			k1=kernel[0]; k2=kernel[1]; k3=kernel[2];
+			k4=kernel[3]; k5=kernel[4]; k6=kernel[5];
+			k7=kernel[6]; k8=kernel[7]; k9=kernel[8];
+			for (int i=0; i<kernel.length; i++)
+				scale += kernel[i];
+			if (scale==0) scale = 1f;
+			scale = 1f/scale; //multiplication factor (multiply is faster than divide)
+		}
+		
+		float[] pixels2 = (float[])getPixelsCopy();
+		//float[] pixels2 = (float[])getPixelsCopy();
+		int xEnd = roiX + roiWidth;
+		int yEnd = roiY + roiHeight;
+		for (int y=roiY; y<yEnd; y++) {
+			int p  = roiX + y*width;			//points to current pixel
+			int p6 = p - (roiX>0 ? 1 : 0);		//will point to v6, currently lower
+			int p3 = p6 - (y>0 ? width : 0);	//will point to v3, currently lower
+			int p9 = p6 + (y<height-1 ? width : 0); // ...	to v9, currently lower
+			v2 = pixels2[p3];
+			v5 = pixels2[p6];
+			v8 = pixels2[p9];
+			if (roiX>0) { p3++; p6++; p9++; }
+			v3 = pixels2[p3];
+			v6 = pixels2[p6];
+			v9 = pixels2[p9];
+
+			switch (type) {
+				case BLUR_MORE:
+				for (int x=roiX; x<xEnd; x++,p++) {
+					if (x<width-1) { p3++; p6++; p9++; }
+					v1 = v2; v2 = v3;
+					v3 = pixels2[p3];
+					v4 = v5; v5 = v6;
+					v6 = pixels2[p6];
+					v7 = v8; v8 = v9;
+					v9 = pixels2[p9];
+					pixels[p] = (v1+v2+v3+v4+v5+v6+v7+v8+v9)*0.11111111f; //0.111... = 1/9
+				}
+				break;
+				case FIND_EDGES:
+				for (int x=roiX; x<xEnd; x++,p++) {
+					if (x<width-1) { p3++; p6++; p9++; }
+					v1 = v2; v2 = v3;
+					v3 = pixels2[p3];
+					v4 = v5; v5 = v6;
+					v6 = pixels2[p6];
+					v7 = v8; v8 = v9;
+					v9 = pixels2[p9];
+					float sum1 = v1 + 2*v2 + v3 - v7 - 2*v8 - v9;
+					float sum2 = v1	 + 2*v4 + v7 - v3 - 2*v6 - v9;
+					pixels[p] = (float)Math.sqrt(sum1*sum1 + sum2*sum2);
+				}
+				break;
+				case CONVOLVE:
+				for (int x=roiX; x<xEnd; x++,p++) {
+					if (x<width-1) { p3++; p6++; p9++; }
+					v1 = v2; v2 = v3;
+					v3 = pixels2[p3];
+					v4 = v5; v5 = v6;
+					v6 = pixels2[p6];
+					v7 = v8; v8 = v9;
+					v9 = pixels2[p9];
+					float sum = k1*v1 + k2*v2 + k3*v3
+							  + k4*v4 + k5*v5 + k6*v6
+							  + k7*v7 + k8*v8 + k9*v9;
+					sum *= scale;
+					pixels[p] = sum;
+				}
+				break;
+			}
+		}
+	}
+
+	/** Rotates the image or ROI 'angle' degrees clockwise.
+		@see ImageProcessor#setInterpolate
+	*/
+	public void rotate(double angle) {
+		float[] pixels2 = (float[])getPixelsCopy();
+		ImageProcessor ip2 = null;
+		if (interpolationMethod==BICUBIC)
+			ip2 = new FloatProcessor(getWidth(), getHeight(), pixels2, null);
+		double centerX = roiX + (roiWidth-1)/2.0;
+		double centerY = roiY + (roiHeight-1)/2.0;
+		int xMax = roiX + this.roiWidth - 1;
+		
+		double angleRadians = -angle/(180.0/Math.PI);
+		double ca = Math.cos(angleRadians);
+		double sa = Math.sin(angleRadians);
+		double tmp1 = centerY*sa-centerX*ca;
+		double tmp2 = -centerX*sa-centerY*ca;
+		double tmp3, tmp4, xs, ys;
+		int index, ixs, iys;
+		
+		if (interpolationMethod==BICUBIC) {
+			for (int y=roiY; y<(roiY + roiHeight); y++) {
+				index = y*width + roiX;
+				tmp3 = tmp1 - y*sa + centerX;
+				tmp4 = tmp2 + y*ca + centerY;
+				for (int x=roiX; x<=xMax; x++) {
+					xs = x*ca + tmp3;
+					ys = x*sa + tmp4;
+					pixels[index++] = (float)getBicubicInterpolatedPixel(xs, ys, ip2);
+				}
+			}
+		} else {
+			double dwidth=width,dheight=height;
+			double xlimit = width-1.0, xlimit2 = width-1.001;
+			double ylimit = height-1.0, ylimit2 = height-1.001;
+			for (int y=roiY; y<(roiY + roiHeight); y++) {
+				index = y*width + roiX;
+				tmp3 = tmp1 - y*sa + centerX;
+				tmp4 = tmp2 + y*ca + centerY;
+				for (int x=roiX; x<=xMax; x++) {
+					xs = x*ca + tmp3;
+					ys = x*sa + tmp4;
+					if ((xs>=-0.01) && (xs<dwidth) && (ys>=-0.01) && (ys<dheight)) {
+						if (interpolationMethod==BILINEAR) {
+							if (xs<0.0) xs = 0.0;
+							if (xs>=xlimit) xs = xlimit2;
+							if (ys<0.0) ys = 0.0;			
+							if (ys>=ylimit) ys = ylimit2;
+							pixels[index++] = (float)getInterpolatedPixel(xs, ys, pixels2);
+						} else {
+							ixs = (int)(xs+0.5);
+							iys = (int)(ys+0.5);
+							if (ixs>=width) ixs = width - 1;
+							if (iys>=height) iys = height -1;
+							pixels[index++] = pixels2[width*iys+ixs];
+						}
+					} else
+						pixels[index++] = bgValue;
+				}
+			}
+		}
+	}
+
+	public void flipVertical() {
+		int index1,index2;
+		float tmp;
+		for (int y=0; y<roiHeight/2; y++) {
+			index1 = (roiY+y)*width+roiX;
+			index2 = (roiY+roiHeight-1-y)*width+roiX;
+			for (int i=0; i<roiWidth; i++) {
+				tmp = pixels[index1];
+				pixels[index1++] = pixels[index2];
+				pixels[index2++] = tmp;
+			}
+		}
+	}
+	
+	public void noise(double standardDeviation) {
+		if (rnd==null)
+			rnd = new Random();
+		if (!Double.isNaN(seed))
+			rnd.setSeed((int) seed);
+		seed = Double.NaN;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				float RandomBrightness = (float)(rnd.nextGaussian()*standardDeviation);
+				pixels[i] = pixels[i] + RandomBrightness;
+				i++;
+			}
+		}
+		resetMinAndMax();
+	}
+
+	public ImageProcessor crop() {
+		ImageProcessor ip2 = createProcessor(roiWidth, roiHeight);
+		float[] pixels2 = (float[])ip2.getPixels();
+		for (int ys=roiY; ys<roiY+roiHeight; ys++) {
+			int offset1 = (ys-roiY)*roiWidth;
+			int offset2 = ys*width+roiX;
+			for (int xs=0; xs<roiWidth; xs++)
+				pixels2[offset1++] = pixels[offset2++];
+		}
+		return ip2;
+	}
+	
+	/** Returns a duplicate of this image. */ 
+	public ImageProcessor duplicate() {
+		ImageProcessor ip2 = createProcessor(width, height); 
+		float[] pixels2 = (float[])ip2.getPixels(); 
+		System.arraycopy(pixels, 0, pixels2, 0, width*height); 
+		return ip2; 
+	} 
+
+	/** Scales the image or selection using the specified scale factors.
+		@see ImageProcessor#setInterpolate
+	*/
+	public void scale(double xScale, double yScale) {
+		double xCenter = roiX + roiWidth/2.0;
+		double yCenter = roiY + roiHeight/2.0;
+		int xmin, xmax, ymin, ymax;
+		
+		if ((xScale>1.0) && (yScale>1.0)) {
+			//expand roi
+			xmin = (int)(xCenter-(xCenter-roiX)*xScale);
+			if (xmin<0) xmin = 0;
+			xmax = xmin + (int)(roiWidth*xScale) - 1;
+			if (xmax>=width) xmax = width - 1;
+			ymin = (int)(yCenter-(yCenter-roiY)*yScale);
+			if (ymin<0) ymin = 0;
+			ymax = ymin + (int)(roiHeight*yScale) - 1;
+			if (ymax>=height) ymax = height - 1;
+		} else {
+			xmin = roiX;
+			xmax = roiX + roiWidth - 1;
+			ymin = roiY;
+			ymax = roiY + roiHeight - 1;
+		}
+		float[] pixels2 = (float[])getPixelsCopy();
+		ImageProcessor ip2 = null;
+		if (interpolationMethod==BICUBIC)
+			ip2 = new FloatProcessor(getWidth(), getHeight(), pixels2, null);
+		boolean checkCoordinates = (xScale < 1.0) || (yScale < 1.0);
+		int index1, index2, xsi, ysi;
+		double ys, xs;
+		if (interpolationMethod==BICUBIC) {
+			for (int y=ymin; y<=ymax; y++) {
+				ys = (y-yCenter)/yScale + yCenter;
+				index1 = y*width + xmin;
+				for (int x=xmin; x<=xmax; x++) {
+					xs = (x-xCenter)/xScale + xCenter;
+					pixels[index1++] = (float)getBicubicInterpolatedPixel(xs, ys, ip2);
+				}
+			}
+		} else {
+			double xlimit = width-1.0, xlimit2 = width-1.001;
+			double ylimit = height-1.0, ylimit2 = height-1.001;
+			for (int y=ymin; y<=ymax; y++) {
+				ys = (y-yCenter)/yScale + yCenter;
+				ysi = (int)ys;
+				if (ys<0.0) ys = 0.0;			
+				if (ys>=ylimit) ys = ylimit2;
+				index1 = y*width + xmin;
+				index2 = width*(int)ys;
+				for (int x=xmin; x<=xmax; x++) {
+					xs = (x-xCenter)/xScale + xCenter;
+					xsi = (int)xs;
+					if (checkCoordinates && ((xsi<xmin) || (xsi>xmax) || (ysi<ymin) || (ysi>ymax)))
+						pixels[index1++] = (float)getMin();
+					else {
+						if (interpolationMethod==BILINEAR) {
+							if (xs<0.0) xs = 0.0;
+							if (xs>=xlimit) xs = xlimit2;
+							pixels[index1++] = (float)getInterpolatedPixel(xs, ys, pixels2);
+						} else
+							pixels[index1++] = pixels2[index2+xsi];
+					}
+				}
+			}
+		}
+	}
+
+	/** Uses bilinear interpolation to find the pixel value at real coordinates (x,y). */
+	private final double getInterpolatedPixel(double x, double y, float[] pixels) {
+		int xbase = (int)x;
+		int ybase = (int)y;
+		double xFraction = x - xbase;
+		double yFraction = y - ybase;
+		int offset = ybase * width + xbase;
+		double lowerLeft = pixels[offset];
+		double lowerRight = pixels[offset + 1];
+		double upperRight = pixels[offset + width + 1];
+		double upperLeft = pixels[offset + width];
+		double upperAverage;
+		if (Double.isNaN(upperLeft ) && xFraction>=0.5)
+			upperAverage = upperRight;
+		else if (Double.isNaN(upperRight) && xFraction<0.5 )
+			upperAverage = upperLeft;
+		else
+			upperAverage = upperLeft + xFraction * (upperRight-upperLeft);
+		double lowerAverage;
+		if (Double.isNaN(lowerLeft) && xFraction>=0.5)
+			lowerAverage = lowerRight;
+		else if (Double.isNaN(lowerRight) && xFraction<0.5 )
+			lowerAverage = lowerLeft;
+		else
+			lowerAverage = lowerLeft + xFraction * (lowerRight-lowerLeft);
+		if (Double.isNaN(lowerAverage) && yFraction>=0.5)
+			return upperAverage;
+		else if (Double.isNaN(upperAverage) && yFraction<0.5 )
+			return lowerAverage;
+		else
+			return lowerAverage + yFraction * (upperAverage-lowerAverage);
+	}
+
+	/*
+	private final double getInterpolatedPixel(double x, double y, float[] pixels) {
+		int xbase = (int)x;
+		int ybase = (int)y;
+		double xFraction = x - xbase;
+		double yFraction = y - ybase;
+		int offset = ybase * width + xbase;
+		double lowerLeft = pixels[offset];
+		double lowerRight = pixels[offset + 1];
+		double upperRight = pixels[offset + width + 1];
+		double upperLeft = pixels[offset + width];
+		double upperAverage = upperLeft + xFraction * (upperRight - upperLeft);
+		double lowerAverage = lowerLeft + xFraction * (lowerRight - lowerLeft);
+		return lowerAverage + yFraction * (upperAverage - lowerAverage);
+	}
+	*/
+
+	/** Creates a new FloatProcessor containing a scaled copy of this image or selection. */
+	public ImageProcessor resize(int dstWidth, int dstHeight) {
+		if (roiWidth==dstWidth && roiHeight==dstHeight)
+			return crop();
+		if ((width==1||height==1) && interpolationMethod!=NONE)
+			return resizeLinearly(dstWidth, dstHeight);
+		double srcCenterX = roiX + roiWidth/2.0;
+		double srcCenterY = roiY + roiHeight/2.0;
+		double dstCenterX = dstWidth/2.0;
+		double dstCenterY = dstHeight/2.0;
+		double xScale = (double)dstWidth/roiWidth;
+		double yScale = (double)dstHeight/roiHeight;
+		if (interpolationMethod!=NONE) {
+			if (dstWidth!=width) dstCenterX+=xScale/4.0;
+			if (dstHeight!=height) dstCenterY+=yScale/4.0;
+		}
+		int inc = getProgressIncrement(dstWidth,dstHeight);
+		ImageProcessor ip2 = createProcessor(dstWidth, dstHeight);
+		float[] pixels2 = (float[])ip2.getPixels();
+		double xs, ys;
+		if (interpolationMethod==BICUBIC) {
+			for (int y=0; y<=dstHeight-1; y++) {
+				if (inc>0&&y%inc==0) showProgress((double)y/dstHeight);
+				ys = (y-dstCenterY)/yScale + srcCenterY;
+				int index = y*dstWidth;
+				for (int x=0; x<=dstWidth-1; x++) {
+					xs = (x-dstCenterX)/xScale + srcCenterX;
+					pixels2[index++] = (float)getBicubicInterpolatedPixel(xs, ys, this);
+				}
+			}
+		} else {
+			double xlimit = width-1.0, xlimit2 = width-1.001;
+			double ylimit = height-1.0, ylimit2 = height-1.001;
+			int index1, index2;
+			for (int y=0; y<=dstHeight-1; y++) {
+				if (inc>0&&y%inc==0) showProgress((double)y/dstHeight);
+				ys = (y-dstCenterY)/yScale + srcCenterY;
+				if (interpolationMethod==BILINEAR) {
+					if (ys<0.0) ys = 0.0;
+					if (ys>=ylimit) ys = ylimit2;
+				}
+				index1 = width*(int)ys;
+				index2 = y*dstWidth;
+				for (int x=0; x<=dstWidth-1; x++) {
+					xs = (x-dstCenterX)/xScale + srcCenterX;
+					if (interpolationMethod==BILINEAR) {
+						if (xs<0.0) xs = 0.0;
+						if (xs>=xlimit) xs = xlimit2;
+						pixels2[index2++] = (float)getInterpolatedPixel(xs, ys, pixels);
+					} else
+						pixels2[index2++] = pixels[index1+(int)xs];
+				}
+			}
+		}
+		if (inc>0) showProgress(1.0);
+		return ip2;
+	}
+	
+	FloatProcessor downsize(int dstWidth, int dstHeight, String msg) {
+		FloatProcessor ip2 = this;
+		if (msg!=null)
+			ij.IJ.showStatus("downsizing in x"+msg);
+		if (dstWidth<roiWidth) {	  //downsizing in x
+			ip2 = ip2.downsize1D(dstWidth, roiHeight, true);
+			ip2.setRoi(0, 0, dstWidth, roiHeight);	//prepare roi for resizing in y
+		}
+		if (msg!=null)
+			ij.IJ.showStatus("downsizing in y"+msg);
+		if (dstHeight<roiHeight)	  //downsizing in y
+			ip2 = ip2.downsize1D(ip2.getRoi().width, dstHeight, false);
+		if (ip2.getWidth()!=dstWidth || ip2.getHeight()!=dstHeight)
+			ip2 = (FloatProcessor)ip2.resize(dstWidth, dstHeight);	//do any upsizing if required
+		return ip2;
+	}
+	
+	// Downsizing in one direction.
+	private FloatProcessor downsize1D(int dstWidth, int dstHeight, boolean xDirection) {
+		int srcPointInc = xDirection ? 1 : width;	//increment of array index for next point along direction
+		int srcLineInc = xDirection ? width : 1;	//increment of array index for next line to be downscaled
+		int dstPointInc = xDirection ? 1 : dstWidth;
+		int dstLineInc = xDirection ? dstWidth : 1;
+		int srcLine0 = xDirection ? roiY : roiX;
+		int dstLines = xDirection ? dstHeight : dstWidth;
+		DownsizeTable dt = xDirection ?
+			new DownsizeTable(getWidth(), roiX, roiWidth, dstWidth, interpolationMethod) : 
+			new DownsizeTable(getHeight(), roiY, roiHeight, dstHeight, interpolationMethod);
+		FloatProcessor ip2 = (FloatProcessor)createProcessor(dstWidth, dstHeight);
+		float[] pixels = (float[])getPixels();
+		float[] pixels2 = (float[])ip2.getPixels();
+		for (int srcLine=srcLine0, dstLine=0; dstLine<dstLines; srcLine++,dstLine++) {
+			int dstLineOffset = dstLine * dstLineInc;
+			int tablePointer = 0;
+			for (int srcPoint=dt.srcStart, p=srcPoint*srcPointInc+srcLine*srcLineInc;
+			srcPoint<=dt.srcEnd; srcPoint++, p+=srcPointInc) {
+				float v = pixels[p];
+				for (int i=0; i<dt.kernelSize; i++, tablePointer++)
+				pixels2[dstLineOffset+dt.indices[tablePointer]*dstPointInc] += v * dt.weights[tablePointer];
+			}
+		}
+		return ip2;
+	}
+
+	/** This method is from Chapter 16 of "Digital Image Processing:
+		An Algorithmic Introduction Using Java" by Burger and Burge
+		(http://www.imagingbook.com/). */
+	public double getBicubicInterpolatedPixel(double x0, double y0, ImageProcessor ip2) {
+		int u0 = (int) Math.floor(x0);	//use floor to handle negative coordinates too
+		int v0 = (int) Math.floor(y0);
+		if (u0<=0 || u0>=width-2 || v0<=0 || v0>=height-2)
+			return ip2.getBilinearInterpolatedPixel(x0, y0);
+		double q = 0;
+		for (int j = 0; j <= 3; j++) {
+			int v = v0 - 1 + j;
+			double p = 0;
+			for (int i = 0; i <= 3; i++) {
+				int u = u0 - 1 + i;
+				p = p + ip2.getf(u,v) * cubic(x0 - u);
+			}
+			q = q + p * cubic(y0 - v);
+		}
+		return q;
+	}
+	
+	/** Sets the foreground fill/draw color. */
+	public void setColor(Color color) {
+		drawingColor = color;
+		int bestIndex = getBestIndex(color);
+		if (bestIndex>0 && getMin()==0.0 && getMax()==0.0) {
+			fillColor = bestIndex;
+			setMinAndMax(0.0,255.0);
+		} else if (bestIndex==0 && getMin()>0.0 && (color.getRGB()&0xffffff)==0)
+			fillColor = 0f;
+		else
+			fillColor = (float)(getMin() + (getMax()-getMin())*(bestIndex/255.0));
+		fillValueSet = true;
+	}
+	
+	/** Sets the default fill/draw value. */
+	public void setValue(double value) {
+		fillColor = (float)value;
+		fillValueSet = true;
+	}
+	
+	/** Returns the foreground fill/draw value. */
+	public double getForegroundValue() {
+		return fillColor;
+	}
+
+	public void setBackgroundValue(double value) {
+		bgValue = (float)value;
+	}
+
+	public double getBackgroundValue() {
+		return bgValue;
+	}
+
+	public void setLutAnimation(boolean lutAnimation) {
+		this.lutAnimation = false;
+	}
+	
+	public void setThreshold(double minThreshold, double maxThreshold, int lutUpdate) {
+		if (minThreshold==NO_THRESHOLD) {
+			resetThreshold();
+			return;
+		}
+		if (getMax()>getMin()) {
+			if (lutUpdate==OVER_UNDER_LUT) {
+				double minT = ((minThreshold-getMin())/(getMax()-getMin())*255.0);
+				double maxT = ((maxThreshold-getMin())/(getMax()-getMin())*255.0);
+				super.setThreshold(minT, maxT, lutUpdate); // update LUT
+			} else {
+				lutUpdateMode = lutUpdate;
+				if (rLUT1==null) {
+					if (cm==null)
+						makeDefaultColorModel();
+					baseCM = cm;
+					IndexColorModel m = (IndexColorModel)cm;
+					rLUT1 = new byte[256]; gLUT1 = new byte[256]; bLUT1 = new byte[256];
+					m.getReds(rLUT1); m.getGreens(gLUT1); m.getBlues(bLUT1);
+					rLUT2 = new byte[256]; gLUT2 = new byte[256]; bLUT2 = new byte[256];
+				}
+				if (lutUpdateMode==RED_LUT)
+					cm = getThresholdColorModel();
+				else
+					cm = getDefaultColorModel();
+			}
+		} else
+			super.resetThreshold();
+		this.minThreshold = minThreshold;
+		this.maxThreshold = maxThreshold;
+	}
+
+	/** Performs a convolution operation using the specified kernel. */
+	public void convolve(float[] kernel, int kernelWidth, int kernelHeight) {
+		snapshot();
+		new ij.plugin.filter.Convolver().convolve(this, kernel, kernelWidth, kernelHeight);
+	}
+
+	/** Returns a 256 bin histogram of the current ROI or of the entire image if there is no ROI. */
+	public int[] getHistogram() {
+		return getStatistics().histogram;
+	}
+
+	/** Not implemented. */
+	public void threshold(int level) {}
+	/** Not implemented. */
+	public void autoThreshold() {}
+	/** Not implemented. */
+	public void medianFilter() {}
+	/** Not implemented. */
+	public void erode() {}
+	/** Not implemented. */
+	public void dilate() {}
+
+	/** Returns this FloatProcessor.
+	*  @param channelNumber	  Ignored (needed for compatibility with ColorProcessor.toFloat)
+	*  @param fp			  Ignored (needed for compatibility with the other ImageProcessor types).
+	*  @return This FloatProcessor
+	*/
+	public FloatProcessor toFloat(int channelNumber, FloatProcessor fp) {
+		return this;
+	}
+	
+	/** Sets the pixels, and min&max values from a FloatProcessor.
+	*  Also the	 values are taken from the FloatProcessor.
+	*  @param channelNumber	  Ignored (needed for compatibility with ColorProcessor.toFloat)
+	*  @param fp			  The FloatProcessor where the image data are read from.
+	*/
+	public void setPixels(int channelNumber, FloatProcessor fp) {
+		if (fp.getPixels() != getPixels())
+		setPixels(fp.getPixels());
+		setMinAndMax(fp.getMin(), fp.getMax());
+	}
+	
+	/** Returns the smallest possible positive nonzero pixel value. */
+	public double minValue() {
+		return Float.MIN_VALUE;
+	}
+
+	/** Returns the largest possible positive finite pixel value. */
+	public double maxValue() {
+		return Float.MAX_VALUE;
+	}
+	
+	public int getBitDepth() {
+		return 32;
+	}
+	
+	/** Returns a binary mask, or null if a threshold is not set. */
+	public ByteProcessor createMask() {
+		if (getMinThreshold()==NO_THRESHOLD)
+			return null;
+		float minThreshold = (float)getMinThreshold();
+		float maxThreshold = (float)getMaxThreshold();
+		ByteProcessor mask = new ByteProcessor(width, height);
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int i=0; i<pixels.length; i++) {
+			if (pixels[i]>=minThreshold && pixels[i]<=maxThreshold)
+				mpixels[i] = (byte)255;
+		}
+		return mask;
+	}
+	
+}
+
diff --git a/src/ij/process/FloatStatistics.java b/src/ij/process/FloatStatistics.java
new file mode 100644
index 0000000..3609278
--- /dev/null
+++ b/src/ij/process/FloatStatistics.java
@@ -0,0 +1,264 @@
+package ij.process;
+import ij.measure.Calibration;
+import java.util.Arrays;
+
+/** 32-bit (float) image statistics, including histogram. */
+public class FloatStatistics extends ImageStatistics {
+
+	/** Constructs an ImageStatistics object from a FloatProcessor
+		using the standard measurement options (area, mean,
+		mode, min and max). */
+	public FloatStatistics(ImageProcessor ip) {
+		this(ip, AREA+MEAN+MODE+MIN_MAX, null);
+	}
+
+	/** Constructs a FloatStatistics object from a FloatProcessor
+		using the specified measurement options.
+	*/
+	public FloatStatistics(ImageProcessor ip, int mOptions, Calibration cal) {
+		this.width = ip.getWidth();
+		this.height = ip.getHeight();
+		setup(ip, cal);
+		double minT = ip.getMinThreshold();
+		double minThreshold,maxThreshold;
+		boolean limitToThreshold = (mOptions&LIMIT)!=0;
+		if (!limitToThreshold || minT==ImageProcessor.NO_THRESHOLD) {
+			minThreshold=-Float.MAX_VALUE;
+			maxThreshold=Float.MAX_VALUE;
+		} else {
+			minThreshold=minT;
+			maxThreshold=ip.getMaxThreshold();
+		}
+		if (limitToThreshold)
+			saveThreshold(minThreshold, maxThreshold, cal);
+		getStatistics(ip, minThreshold, maxThreshold);
+		if ((mOptions&MODE)!=0)
+			getMode();
+		if ((mOptions&ELLIPSE)!=0 || (mOptions&SHAPE_DESCRIPTORS)!=0)
+			fitEllipse(ip, mOptions);
+		else if ((mOptions&CENTROID)!=0)
+			getCentroid(ip, minThreshold, maxThreshold);
+		if ((mOptions&(CENTER_OF_MASS|SKEWNESS|KURTOSIS))!=0)
+			calculateMoments(ip, minThreshold, maxThreshold);
+		if ((mOptions&MEDIAN)!=0)
+			getMedian(ip, minThreshold, maxThreshold);
+		if ((mOptions&AREA_FRACTION)!=0)
+			calculateAreaFraction(ip);
+	}
+
+	void getStatistics(ImageProcessor ip, double minThreshold, double maxThreshold) {
+		double v;
+		float[] pixels = (float[])ip.getPixels();
+		nBins = ip.getHistogramSize();
+		histMin = ip.getHistogramMin();
+		histMax = ip.getHistogramMax();
+		histogram = new int[nBins];
+		double sum = 0;
+		double sum2 = 0;
+		byte[] mask = ip.getMaskArray();
+		
+		// Find image min and max
+		double roiMin = Double.MAX_VALUE;
+		double roiMax = -Double.MAX_VALUE;
+		for (int y=ry, my=0; y<(ry+rh); y++, my++) {
+			int i = y * width + rx;
+			int mi = my * rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					v = pixels[i];
+					if (v>=minThreshold && v<=maxThreshold) {
+						if (v<roiMin)
+							roiMin = v;
+						if (v>roiMax)
+							roiMax = v;
+					}
+				}
+				i++;
+			}
+		}
+		min = roiMin; max = roiMax;
+		if (histMin==0.0 && histMax==0.0) {
+			histMin = min; 
+			histMax = max;
+		} else {
+			if (min<histMin)
+				min = histMin;
+			if (max>histMax)
+				max = histMax;
+		}
+		binSize = (histMax-histMin)/nBins;
+
+		// Generate histogram
+		double scale = nBins/(histMax-histMin);
+		int index;
+		pixelCount = 0;
+		for (int y=ry, my=0; y<(ry+rh); y++, my++) {
+			int i = y * width + rx;
+			int mi = my * rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					v = pixels[i];
+					if (v>=minThreshold && v<=maxThreshold && v>=histMin && v<=histMax) {
+						pixelCount++;
+						sum += v;
+						sum2 += v*v;
+						index = (int)(scale*(v-histMin));
+						if (index>=nBins)
+							index = nBins-1;
+						histogram[index]++;
+					}
+				}
+				i++;
+			}
+		}
+		area = pixelCount*pw*ph;
+		mean = sum/pixelCount;
+		umean = mean;
+		calculateStdDev(pixelCount, sum, sum2);
+	}
+
+	void getMode() {
+        int count;
+        maxCount = 0;
+        for (int i = 0; i < nBins; i++) {
+        	count = histogram[i];
+            if (count > maxCount) {
+                maxCount = count;
+                mode = i;
+            }
+        }
+        dmode = histMin+mode*binSize;
+        if (binSize!=1.0)
+        	dmode += binSize/2.0;        	
+	}
+
+	void calculateMoments(ImageProcessor ip, double minThreshold, double maxThreshold) {
+		float[] pixels = (float[])ip.getPixels();
+		byte[] mask = ip.getMaskArray();
+		int i, mi;
+		double v, v2, sum1=0.0, sum2=0.0, sum3=0.0, sum4=0.0, xsum=0.0, ysum=0.0;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					v = pixels[i]+Double.MIN_VALUE;
+					if (v>=minThreshold && v<=maxThreshold) {
+						v2 = v*v;
+						sum1 += v;
+						sum2 += v2;
+						sum3 += v*v2;
+						sum4 += v2*v2;
+						xsum += x*v;
+						ysum += y*v;
+					}
+				}
+				i++;
+			}
+		}
+	    double mean2 = mean*mean;
+	    double variance = sum2/pixelCount - mean2;
+	    double sDeviation = Math.sqrt(variance);
+	    skewness = ((sum3 - 3.0*mean*sum2)/pixelCount + 2.0*mean*mean2)/(variance*sDeviation);
+	    kurtosis = (((sum4 - 4.0*mean*sum3 + 6.0*mean2*sum2)/pixelCount - 3.0*mean2*mean2)/(variance*variance)-3.0);
+		xCenterOfMass = xsum/sum1+0.5;
+		yCenterOfMass = ysum/sum1+0.5;
+		if (cal!=null) {
+			xCenterOfMass = cal.getX(xCenterOfMass);
+			yCenterOfMass = cal.getY(yCenterOfMass, height);
+		}
+	}
+
+	void getCentroid(ImageProcessor ip, double minThreshold, double maxThreshold) {
+		float[] pixels = (float[])ip.getPixels();
+		byte[] mask = ip.getMaskArray();
+		double count=0.0, xsum=0.0, ysum=0.0, v;
+		int i, mi;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null||mask[mi++]!=0) {
+					v = pixels[i];
+					if (v>=minThreshold && v<=maxThreshold) {
+						count++;
+						xsum+=x;
+						ysum+=y;
+					}
+				}
+				i++;
+			}
+		}
+		xCentroid = xsum/count+0.5;
+		yCentroid = ysum/count+0.5;
+		if (cal!=null) {
+			xCentroid = cal.getX(xCentroid);
+			yCentroid = cal.getY(yCentroid, height);
+		}
+	}
+
+	void calculateAreaFraction(ImageProcessor ip) {
+		int sum = 0;
+		int total = 0;
+		float t1 = (float)ip.getMinThreshold();
+		float t2 = (float)ip.getMaxThreshold();
+		float v;
+		float[] pixels = (float[])ip.getPixels();
+		boolean noThresh = t1==ImageProcessor.NO_THRESHOLD;
+		byte[] mask = ip.getMaskArray();
+		int i, mi;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null||mask[mi++]!=0) {
+					v = pixels[i];
+					total++;
+					if (noThresh) {
+						if (v!=0f) sum++;
+					} else if (v>=t1 && v<=t2)
+						sum++;
+				}
+				i++;
+			}
+		}
+		areaFraction = sum*100.0/total;
+	}
+	
+	void getMedian(ImageProcessor ip, double minThreshold, double maxThreshold) {
+		if (pixelCount==0) {
+			median = Double.NaN;
+			return;
+		}
+		float[] pixels = (float[])ip.getPixels();
+		float[] pixels2 = new float[pixelCount];
+		byte[] mask = ip.getMaskArray();
+		int i, mi;
+		float v;
+		int count = 0;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null||mask[mi++]!=0) {
+					v = pixels[i];
+					if (v>=minThreshold && v<=maxThreshold) {
+						if (count==pixels2.length) {
+							median = Double.NaN;
+							return;
+						}
+						pixels2[count++] = v;
+					}
+				}
+				i++;
+			}
+		}
+		Arrays.sort(pixels2);
+		int middle = pixels2.length/2;
+		if ((pixels2.length&1)==0) //even
+			median = (pixels2[middle-1] + pixels2[middle])/2f;
+		else
+			median = pixels2[middle];
+	}
+
+}
diff --git a/src/ij/process/FloodFiller.java b/src/ij/process/FloodFiller.java
new file mode 100644
index 0000000..d8f13fe
--- /dev/null
+++ b/src/ij/process/FloodFiller.java
@@ -0,0 +1,222 @@
+package ij.process;
+import ij.*;
+import ij.gui.Toolbar;
+import java.awt.Rectangle;
+
+
+/**	This class, which does flood filling, is used by the floodFill() macro function and
+	by the particle analyzer
+	The Wikipedia at "http://en.wikipedia.org/wiki/Flood_fill" has a good 
+	description of the algorithm used here as well as examples in C and Java. 
+*/
+public class FloodFiller {
+	int maxStackSize = 500; // will be increased as needed
+	int[] xstack = new int[maxStackSize];
+	int[] ystack = new int[maxStackSize];
+	int stackSize;
+	ImageProcessor ip;
+	int max;
+	boolean isFloat;
+  
+	public FloodFiller(ImageProcessor ip) {
+		this.ip = ip;
+		isFloat = ip instanceof FloatProcessor;
+	}
+
+	/** Does a 4-connected flood fill using the current fill/draw
+		value, which is defined by ImageProcessor.setValue(). */
+	public boolean fill(int x, int y) {
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		int color = ip.getPixel(x, y);
+		fillLine(ip, x, x, y);
+		int newColor = ip.getPixel(x, y);
+		ip.putPixel(x, y, color);
+		if (color==newColor) return false;
+		stackSize = 0;
+		push(x, y);
+		while(true) {   
+			x = popx(); 
+			if (x ==-1) return true;
+			y = popy();
+			if (ip.getPixel(x,y)!=color) continue;
+			int x1 = x; int x2 = x;
+			while (ip.getPixel(x1,y)==color && x1>=0) x1--; // find start of scan-line
+			x1++;
+			while (ip.getPixel(x2,y)==color && x2<width) x2++;  // find end of scan-line                 
+			x2--;
+			fillLine(ip, x1,x2,y); // fill scan-line
+			boolean inScanLine = false;
+			for (int i=x1; i<=x2; i++) { // find scan-lines above this one
+				if (!inScanLine && y>0 && ip.getPixel(i,y-1)==color)
+					{push(i, y-1); inScanLine = true;}
+				else if (inScanLine && y>0 && ip.getPixel(i,y-1)!=color)
+					inScanLine = false;
+			}
+			inScanLine = false;
+			for (int i=x1; i<=x2; i++) { // find scan-lines below this one
+				if (!inScanLine && y<height-1 && ip.getPixel(i,y+1)==color)
+					{push(i, y+1); inScanLine = true;}
+				else if (inScanLine && y<height-1 && ip.getPixel(i,y+1)!=color)
+					inScanLine = false;
+			}
+		}        
+	}
+	
+	/** Does a 8-connected flood fill using the current fill/draw
+		value, which is defined by ImageProcessor.setValue(). */
+	public boolean fill8(int x, int y) {
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		int color = ip.getPixel(x, y);
+		int wm1=width-1;
+		int hm1=height-1; 
+		fillLine(ip, x, x, y);
+		int newColor = ip.getPixel(x, y);
+		ip.putPixel(x, y, color);
+		if (color==newColor) return false;
+		stackSize = 0;
+		push(x, y);
+		while(true) {   
+			x = popx(); 
+			if (x==-1) return true;
+			y = popy();
+			int x1 = x; int x2 = x;
+			if(ip.getPixel(x1,y)==color){ 
+				while (ip.getPixel(x1,y)==color && x1>=0) x1--; // find start of scan-line
+				x1++;
+				while (ip.getPixel(x2,y)==color && x2<width) x2++;  // find end of scan-line
+				x2--;
+				fillLine(ip, x1,x2,y); // fill scan-line
+			} 
+			if(y>0){
+				if (x1>0){
+					if (ip.getPixel(x1-1,y-1)==color){
+						push(x1-1,y-1);
+					}
+				}
+				if (x2<wm1){
+					if (ip.getPixel(x2+1,y-1)==color){
+						push(x2+1,y-1);
+					}
+				}
+			}
+			if(y<hm1){
+				if (x1>0){
+					if (ip.getPixel(x1-1,y+1)==color){
+						push(x1-1,y+1);
+					}
+				}
+				if (x2<wm1){
+					if (ip.getPixel(x2+1,y+1)==color){
+						push(x2+1,y+1);
+					}
+				}
+			}
+			boolean inScanLine = false;
+			for (int i=x1; i<=x2; i++) { // find scan-lines above this one
+				if (!inScanLine && y>0 && ip.getPixel(i,y-1)==color)
+					{push(i, y-1); inScanLine = true;}
+				else if (inScanLine && y>0 && ip.getPixel(i,y-1)!=color)
+					inScanLine = false;
+			}
+			inScanLine = false;
+			for (int i=x1; i<=x2; i++) {// find scan-lines below this one
+				if (!inScanLine && y<hm1 && ip.getPixel(i,y+1)==color)
+					{push(i, y+1); inScanLine = true;}
+				else if (inScanLine && y<hm1 && ip.getPixel(i,y+1)!=color)
+					inScanLine = false;
+			}
+		}
+	}
+	
+	int count=0;
+	
+	/** This method is used by the particle analyzer to remove interior holes from particle masks. */
+	public void particleAnalyzerFill(int x, int y, double level1, double level2, ImageProcessor mask, Rectangle bounds) {
+		int width = ip.getWidth();
+		int height = ip.getHeight();
+		//IJ.log("ff: "+x+" "+y+" "+level1+" "+level2+" "+ip+" "+mask+" "+bounds);
+		if (x==0&&y==0&&level1==0.0&&level2==255.0&&ip.getBitDepth()==8) {
+			ip.fill();
+			return;
+		}
+		mask.setColor(0);
+		mask.fill();
+		mask.setColor(255);
+		stackSize = 0;
+		push(x, y);
+		while(true) {   
+			x = popx(); 
+			if (x ==-1) return;
+			y = popy();
+			if (!inParticle(x,y,level1,level2)) continue;
+			int x1 = x; int x2 = x;
+			while (inParticle(x1,y,level1,level2) && x1>=0) x1--; // find start of scan-line
+			x1++;
+			while (inParticle(x2,y,level1,level2) && x2<width) x2++;  // find end of scan-line                 
+			x2--;
+			fillLine(mask, x1-bounds.x, x2-bounds.x, y-bounds.y); // fill scan-line i mask
+			fillLine(ip,x1,x2,y); // fill scan-line in image
+			boolean inScanLine = false;
+			if (x1>0) x1--; if (x2<width-1) x2++;
+			for (int i=x1; i<=x2; i++) { // find scan-lines above this one
+				if (!inScanLine && y>0 && inParticle(i,y-1,level1,level2))
+					{push(i, y-1); inScanLine = true;}
+				else if (inScanLine && y>0 && !inParticle(i,y-1,level1,level2))
+					inScanLine = false;
+			}
+			inScanLine = false;
+			for (int i=x1; i<=x2; i++) { // find scan-lines below this one
+				if (!inScanLine && y<height-1 && inParticle(i,y+1,level1,level2))
+					{push(i, y+1); inScanLine = true;}
+				else if (inScanLine && y<height-1 && !inParticle(i,y+1,level1,level2))
+					inScanLine = false;
+			}
+		} 
+	}
+	
+	final boolean inParticle(int x, int y, double level1, double level2) {
+		if (isFloat)
+			return ip.getPixelValue(x,y)>=level1 &&  ip.getPixelValue(x,y)<=level2;
+		else {
+            int v = ip.getPixel(x,y);
+			return v>=level1 && v<=level2;
+        }
+	}
+	
+	final void push(int x, int y) {
+		stackSize++;
+		if (stackSize==maxStackSize) {
+			int[] newXStack = new int[maxStackSize*2];
+			int[] newYStack = new int[maxStackSize*2];
+			System.arraycopy(xstack, 0, newXStack, 0, maxStackSize);
+			System.arraycopy(ystack, 0, newYStack, 0, maxStackSize);
+			xstack = newXStack;
+			ystack = newYStack;
+			maxStackSize *= 2;
+		}
+		xstack[stackSize-1] = x;
+		ystack[stackSize-1] = y;
+	}
+	
+	final int popx() {
+		if (stackSize==0)
+			return -1;
+		else
+            return xstack[stackSize-1];
+	}
+
+	final int popy() {
+        int value = ystack[stackSize-1];
+        stackSize--;
+        return value;
+	}
+
+	final void fillLine(ImageProcessor ip, int x1, int x2, int y) {
+		if (x1>x2) {int t = x1; x1=x2; x2=t;}
+		for (int x=x1; x<=x2; x++)
+            ip.drawPixel(x, y);
+	}
+
+}
diff --git a/src/ij/process/ImageConverter.java b/src/ij/process/ImageConverter.java
new file mode 100644
index 0000000..c3b76e9
--- /dev/null
+++ b/src/ij/process/ImageConverter.java
@@ -0,0 +1,303 @@
+package ij.process;
+
+import java.awt.*;
+import java.awt.image.*;
+import ij.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.frame.Recorder;
+
+/** This class converts an ImagePlus object to a different type. */
+public class ImageConverter {
+	private ImagePlus imp;
+	private int type;
+	//private static boolean doScaling = Prefs.getBoolean(Prefs.SCALE_CONVERSIONS,true);
+	private static boolean doScaling = true;
+
+	/** Constructs an ImageConverter based on an ImagePlus object. */
+	public ImageConverter(ImagePlus imp) {
+		this.imp = imp;
+		type = imp.getType();
+	}
+
+	/** Converts this ImagePlus to 8-bit grayscale. */
+	public synchronized void convertToGray8() {
+		if (imp.getStackSize()>1) {
+			new StackConverter(imp).convertToGray8();
+			return;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		if (type==ImagePlus.GRAY16 || type==ImagePlus.GRAY32) {
+			imp.setProcessor(null, ip.convertToByte(doScaling));
+			imp.setCalibration(imp.getCalibration()); //update calibration
+			record();
+		} else if (type==ImagePlus.COLOR_RGB)
+	    	imp.setProcessor(null, ip.convertToByte(doScaling));
+		else if (ip.isPseudoColorLut()) {
+			boolean invertedLut = ip.isInvertedLut();
+			ip.setColorModel(LookUpTable.createGrayscaleColorModel(invertedLut));
+	    	imp.updateAndDraw();
+		} else {
+			ip = new ColorProcessor(imp.getImage());
+	    	imp.setProcessor(null, ip.convertToByte(doScaling));
+	    }
+	    ImageProcessor ip2 = imp.getProcessor();
+		if (Prefs.useInvertingLut && ip2 instanceof ByteProcessor && !ip2.isInvertedLut()&& !ip2.isColorLut()) {
+			ip2.invertLut();
+			ip2.invert();
+		}
+	}
+
+	/** Converts this ImagePlus to 16-bit grayscale. */
+	public void convertToGray16() {
+		if (type==ImagePlus.GRAY16)
+			return;
+		if (!(type==ImagePlus.GRAY8||type==ImagePlus.GRAY32||type==ImagePlus.COLOR_RGB))
+			throw new IllegalArgumentException("Unsupported conversion");
+		if (imp.getStackSize()>1) {
+			new StackConverter(imp).convertToGray16();
+			return;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		if (type==ImagePlus.GRAY32)
+			record();
+		imp.trimProcessor();
+		imp.setProcessor(null, ip.convertToShort(doScaling));
+		imp.setCalibration(imp.getCalibration()); //update calibration
+	}
+	
+	private void record() {
+		if (Recorder.record) {
+			Boolean state = ImageConverter.getDoScaling();
+			if (Recorder.scriptMode())
+				Recorder.recordCall("ImageConverter.setDoScaling("+state+");", true);
+			else
+				Recorder.	recordString("setOption(\"ScaleConversions\", "+state+");\n");
+		}
+	}
+
+	/** Converts this ImagePlus to 32-bit grayscale. */
+	public void convertToGray32() {
+		if (type==ImagePlus.GRAY32)
+			return;
+		if (!(type==ImagePlus.GRAY8||type==ImagePlus.GRAY16||type==ImagePlus.COLOR_RGB))
+			throw new IllegalArgumentException("Unsupported conversion");
+		Calibration cal = imp.getCalibration();
+		double min = cal.getCValue(imp.getDisplayRangeMin());
+		double max = cal.getCValue(imp.getDisplayRangeMax());
+		if (imp.getStackSize()>1) {
+			new StackConverter(imp).convertToGray32();
+			IJ.setMinAndMax(imp, min, max);
+			return;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		imp.trimProcessor();
+		imp.setProcessor(null, ip.convertToFloat());
+		imp.setCalibration(cal); //update calibration
+		IJ.setMinAndMax(imp, min, max);
+	}
+
+	/** Converts this ImagePlus to RGB. */
+	public void convertToRGB() {
+		if (imp.getBitDepth()==24)
+			return;
+		if (imp.getStackSize()>1) {
+			new StackConverter(imp).convertToRGB();
+			return;
+		}
+		ImageProcessor ip = imp.getProcessor();
+		imp.setProcessor(null, ip.convertToRGB());
+		imp.setCalibration(imp.getCalibration()); //update calibration
+	}
+	
+	/** Converts an RGB image to an RGB (red, green and blue) stack. */
+	public void convertToRGBStack() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("Image must be RGB");
+
+		//convert to RGB Stack
+		ColorProcessor cp;
+		if (imp.getType()==ImagePlus.COLOR_RGB)
+			cp = (ColorProcessor)imp.getProcessor();
+		else
+			cp = new ColorProcessor(imp.getImage());
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		byte[] R = new byte[width*height];
+		byte[] G = new byte[width*height];
+		byte[] B = new byte[width*height];
+		cp.getRGB(R, G, B);
+		imp.trimProcessor();
+		
+		// Create stack and select Red channel
+		ColorModel cm = LookUpTable.createGrayscaleColorModel(false);
+		ImageStack stack = new ImageStack(width, height, cm);
+		stack.addSlice("Red", R);
+		stack.addSlice("Green", G);
+		stack.addSlice("Blue", B);
+		imp.setStack(null, stack);
+		imp.setDimensions(3, 1, 1);
+		if (imp.isComposite())
+			((CompositeImage)imp).setMode(IJ.GRAYSCALE);
+	}
+
+	/** Converts an RGB image to a HSB (hue, saturation and brightness) stack. */
+	public void convertToHSB() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("Image must be RGB");;
+		ColorProcessor cp;
+		if (imp.getType()==ImagePlus.COLOR_RGB)
+			cp = (ColorProcessor)imp.getProcessor();
+		else
+			cp = new ColorProcessor(imp.getImage());
+		ImageStack stack = cp.getHSBStack();
+		imp.trimProcessor();
+		imp.setStack(null, stack);
+		imp.setDimensions(3, 1, 1);
+	}
+	
+	/** Converts an RGB image to a 32-bit HSB (hue, saturation and brightness) stack. */
+	public void convertToHSB32() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("Image must be RGB");;
+		ColorProcessor cp;
+		if (imp.getType()==ImagePlus.COLOR_RGB)
+			cp = (ColorProcessor)imp.getProcessor();
+		else
+			cp = new ColorProcessor(imp.getImage());
+		ImageStack stack = cp.getHSB32Stack();
+		imp.trimProcessor();
+		imp.setStack(null, stack);
+		imp.setDimensions(3, 1, 1);
+	}
+
+	/** Converts an RGB image to a Lab stack. */
+	public void convertToLab() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("Image must be RGB");
+		ColorSpaceConverter converter = new ColorSpaceConverter();
+  		ImagePlus imp2 = converter.RGBToLab(imp);
+  		Point loc = null;
+  		ImageWindow win = imp.getWindow();
+		if (win!=null)
+			loc = win.getLocation();
+		ImageWindow.setNextLocation(loc);
+		imp2.show();
+		imp.hide();
+  		imp2.copyAttributes(imp);
+  		imp.changes = false;
+  		imp.close();
+	}
+
+	/** Converts a 2 or 3 slice 8-bit stack to RGB. */
+	public void convertRGBStackToRGB() {
+		int stackSize = imp.getStackSize();
+		if (stackSize<2 || stackSize>3 || type!=ImagePlus.GRAY8)
+			throw new IllegalArgumentException("2 or 3 slice 8-bit stack required");
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		ImageStack stack = imp.getStack();
+		byte[] R = (byte[])stack.getPixels(1);
+		byte[] G = (byte[])stack.getPixels(2);
+		byte[] B;
+		if (stackSize>2)
+			B = (byte[])stack.getPixels(3);
+		else
+			B = new byte[width*height];
+		imp.trimProcessor();
+		ColorProcessor cp = new ColorProcessor(width, height);
+		cp.setRGB(R, G, B);
+		if (imp.isInvertedLut())
+			cp.invert();
+		imp.setImage(cp.createImage());
+		imp.killStack();
+		if (IJ.isLinux())
+			imp.setTitle(imp.getTitle());
+	}
+
+	/** Converts a 3-slice (hue, saturation, brightness) 8-bit stack to RGB. */
+	public void convertHSBToRGB() {
+		if (imp.getStackSize()!=3)
+			throw new IllegalArgumentException("3-slice 8-bit stack required");
+		ImageStack stack = imp.getStack();
+		byte[] H = (byte[])stack.getPixels(1);
+		byte[] S = (byte[])stack.getPixels(2);
+		byte[] B = (byte[])stack.getPixels(3);
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		imp.trimProcessor();
+		ColorProcessor cp = new ColorProcessor(width, height);
+		cp.setHSB(H, S, B);
+		imp.setImage(cp.createImage());
+		imp.killStack();
+		if (IJ.isLinux())
+			imp.setTitle(imp.getTitle());
+	}
+	
+	/** Converts a 3-slice (hue, saturation, brightness) 32-bit stack to RGB. */
+	public void convertHSB32ToRGB() {
+		if (imp.getStackSize()!=3)
+			throw new IllegalArgumentException("3-slice 8-bit stack required");
+		ImageStack stack = imp.getStack();
+		float[] H = (float[])stack.getPixels(1);
+		float[] S = (float[])stack.getPixels(2);
+		float[] B = (float[])stack.getPixels(3);
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		imp.trimProcessor();
+		ColorProcessor cp = new ColorProcessor(width, height);
+		cp.setHSB(H, S, B);
+		imp.setImage(cp.createImage());
+		imp.killStack();
+		if (IJ.isLinux())
+			imp.setTitle(imp.getTitle());
+	}
+
+	/** Converts a Lab stack to RGB. */
+	public void convertLabToRGB() {
+		if (imp.getStackSize()!=3)
+			throw new IllegalArgumentException("3-slice 32-bit stack required");
+		ColorSpaceConverter converter = new ColorSpaceConverter();
+		ImagePlus imp2 = converter.LabToRGB(imp);
+		imp2.setCalibration(imp.getCalibration());
+		imp.setImage(imp2);
+	}
+
+	/** Converts an RGB image to 8-bits indexed color. 'nColors' must
+		be greater than 1 and less than or equal to 256. */
+	public void convertRGBtoIndexedColor(int nColors) {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("Image must be RGB");
+		if (nColors<2) nColors = 2;
+		if (nColors>256) nColors = 256;
+		
+		// get RGB pixels
+		IJ.showProgress(0.1);
+		IJ.showStatus("Grabbing pixels");
+		int width = imp.getWidth();
+		int height = imp.getHeight();
+		ImageProcessor ip = imp.getProcessor();
+	 	ip.snapshot();
+		int[] pixels = (int[])ip.getPixels();
+		imp.trimProcessor();
+		
+		// convert to 8-bits
+		long start = System.currentTimeMillis();
+		MedianCut mc = new MedianCut(pixels, width, height);
+		ImageProcessor ip2 = mc.convertToByte(nColors);
+	    imp.setProcessor(null, ip2);
+	    imp.setTypeToColor256();
+	}
+	
+	/** Set true to scale to 0-255 when converting short to byte or float
+		to byte and to 0-65535 when converting float to short. */
+	public static void setDoScaling(boolean scaleConversions) {
+		doScaling = scaleConversions;
+		IJ.register(ImageConverter.class); 
+	}
+
+	/** Returns true if scaling is enabled. */
+	public static boolean getDoScaling() {
+		return doScaling;
+	}
+}
diff --git a/src/ij/process/ImageProcessor.java b/src/ij/process/ImageProcessor.java
new file mode 100644
index 0000000..a6f54be
--- /dev/null
+++ b/src/ij/process/ImageProcessor.java
@@ -0,0 +1,2835 @@
+package ij.process;
+import java.util.*;
+import java.awt.*;
+import java.awt.image.*;
+import java.awt.geom.Rectangle2D;
+import java.awt.font.GlyphVector;
+import ij.gui.*;
+import ij.util.*;
+import ij.plugin.filter.GaussianBlur;
+import ij.plugin.Binner;
+import ij.process.AutoThresholder.Method;
+import ij.Prefs;
+import ij.measure.Measurements;
+
+/**
+This abstract class is the superclass for classes that process
+the four data types (byte, short, float and RGB) supported by ImageJ.
+An ImageProcessor contains the pixel data of a 2D image and
+some basic methods to manipulate it.
+@see ByteProcessor
+@see ShortProcessor
+@see FloatProcessor
+@see ColorProcessor
+@see ij.ImagePlus
+@see ij.ImageStack
+*/
+public abstract class ImageProcessor implements Cloneable {
+
+	/** Value of pixels included in masks. */
+	public static final int BLACK = 0xFF000000;
+
+	/** Value returned by getMinThreshold() when thresholding is not enabled. */
+	public static final double NO_THRESHOLD = -808080.0;
+
+	/** Left justify text. */
+	public static final int LEFT_JUSTIFY = 0;
+	/** Center justify text. */
+	public static final int CENTER_JUSTIFY = 1;
+	/** Right justify text. */
+	public static final int RIGHT_JUSTIFY = 2;
+
+	/** Isodata thresholding method */
+	public static final int ISODATA = 0;
+
+	/** Modified isodata method used in Image/Adjust/Threshold tool */
+	public static final int ISODATA2 = 1;
+
+	/** Interpolation methods */
+	public static final int NEAREST_NEIGHBOR=0, NONE=0, BILINEAR=1, BICUBIC=2;
+
+	public static final int BLUR_MORE=0, FIND_EDGES=1, MEDIAN_FILTER=2, MIN=3, MAX=4, CONVOLVE=5;
+	static public final int RED_LUT=0, BLACK_AND_WHITE_LUT=1, NO_LUT_UPDATE=2, OVER_UNDER_LUT=3;
+	static final int INVERT=0, FILL=1, ADD=2, MULT=3, AND=4, OR=5,
+		XOR=6, GAMMA=7, LOG=8, MINIMUM=9, MAXIMUM=10, SQR=11, SQRT=12, EXP=13, ABS=14, SET=15;
+	static final String WRONG_LENGTH = "width*height!=pixels.length";
+
+	int fgColor = 0;
+	protected int lineWidth = 1;
+	protected int cx, cy; //current drawing coordinates
+	protected Font font = ij.IJ.font12;
+	protected FontMetrics fontMetrics;
+	protected boolean antialiasedText;
+	protected boolean boldFont;
+	private static String[] interpolationMethods;
+	// Over/Under tresholding colors
+	private static int overRed, overGreen=255, overBlue;
+	private static int underRed, underGreen, underBlue=255;
+	private static boolean useBicubic;
+	private int sliceNumber;
+	private Overlay overlay;
+	private boolean noReset;
+
+    ProgressBar progressBar;
+	protected int width, snapshotWidth;
+	protected int height, snapshotHeight;
+	protected int roiX, roiY, roiWidth, roiHeight;
+	protected int xMin, xMax, yMin, yMax;
+	boolean snapshotCopyMode;
+	ImageProcessor mask;
+	protected ColorModel baseCM; // base color model
+	protected ColorModel cm;
+	protected byte[] rLUT1, gLUT1, bLUT1; // base LUT
+	protected byte[] rLUT2, gLUT2, bLUT2; // LUT as modified by setMinAndMax and setThreshold
+	protected boolean interpolate;  // replaced by interpolationMethod
+	protected int interpolationMethod = NONE;
+	protected double minThreshold=NO_THRESHOLD, maxThreshold=NO_THRESHOLD;
+	protected int histogramSize = 256;
+	protected double histogramMin, histogramMax;
+	protected float[] cTable;
+	protected boolean lutAnimation;
+	protected MemoryImageSource source; //unused
+	protected Image img;
+	protected boolean newPixels; // unused
+	protected Color drawingColor = Color.black;
+	protected int clipXMin, clipXMax, clipYMin, clipYMax; // clip rect used by drawTo, drawLine, drawDot and drawPixel
+	protected int justification = LEFT_JUSTIFY;
+	protected int lutUpdateMode;
+	protected WritableRaster raster;
+	protected BufferedImage image;
+	protected BufferedImage fmImage;
+	protected Graphics2D fmGraphics;
+	protected ColorModel cm2;
+	protected SampleModel sampleModel;
+	protected static IndexColorModel defaultColorModel;
+	protected boolean minMaxSet;
+	protected static double seed = Double.NaN;
+	protected static Random rnd;
+	protected boolean fillValueSet;
+
+	protected void showProgress(double percentDone) {
+		if (progressBar!=null)
+        	progressBar.show(percentDone);
+	}
+
+	/** @deprecated */
+	protected void hideProgress() {
+		showProgress(1.0);
+	}
+
+	/** Returns the width of this image in pixels. */
+	public int getWidth() {
+		return width;
+	}
+
+	/** Returns the height of this image in pixels. */
+	public int getHeight() {
+		return height;
+	}
+
+    /** Returns the bit depth, 8, 16, 24 (RGB) or 32. RGB images actually use 32 bits per pixel. */
+    public int getBitDepth() {
+    	Object pixels = getPixels();
+    	if (pixels==null)
+    		return 0;
+    	else if (pixels instanceof byte[])
+    		return 8;
+    	else if (pixels instanceof short[])
+    		return 16;
+    	else if (pixels instanceof int[])
+    		return 24;
+    	else if (pixels instanceof float[])
+    		return 32;
+    	else
+    		return 0;
+    }
+
+    /** Returns this processor's color model. For non-RGB processors,
+ 		this is the base lookup table (LUT), not the one that may have
+		been modified by setMinAndMax() or setThreshold(). */
+	public ColorModel getColorModel() {
+		if (cm==null)
+			makeDefaultColorModel();
+		if (baseCM!=null)
+			return baseCM;
+		else
+			return cm;
+	}
+
+	private IndexColorModel getIndexColorModel() {
+		ColorModel cm2 = baseCM;
+		if (cm2==null)
+			cm2 = cm;
+		if (cm2!=null && (cm2 instanceof IndexColorModel))
+			return (IndexColorModel)cm2;
+		else
+			return null;
+	}
+
+	/** Returns the current color model, which may have
+		been modified by setMinAndMax() or setThreshold(). */
+	public ColorModel getCurrentColorModel() {
+		if (cm==null) makeDefaultColorModel();
+		return cm;
+	}
+
+	/** Sets the color model. Must be an IndexColorModel (aka LUT)
+		for all processors except the ColorProcessor. */
+	public void setColorModel(ColorModel cm) {
+		if (cm!=null && !(cm instanceof IndexColorModel))
+			throw new IllegalArgumentException("IndexColorModel required");
+		if (cm!=null && cm instanceof LUT)
+			cm = ((LUT)cm).getColorModel();
+		this.cm = cm;
+		baseCM = null;
+		rLUT1 = rLUT2 = null;
+		inversionTested = false;
+		minThreshold = NO_THRESHOLD;
+	}
+
+	public LUT getLut() {
+		ColorModel cm2 = getColorModel();
+		if (cm2!=null && (cm2 instanceof IndexColorModel))
+			return new LUT((IndexColorModel)cm2, getMin(), getMax());
+		else
+			return null;
+	}
+
+	public void setLut(LUT lut) {
+		if (lut==null)
+			setColorModel(null);
+		else {
+			setColorModel(lut.getColorModel());
+			if (lut.min!=0.0 || lut.max!=0.0)
+				setMinAndMax(lut.min, lut.max);
+		}
+	}
+
+
+	protected void makeDefaultColorModel() {
+		cm = getDefaultColorModel();
+	}
+
+	/** Inverts the values in this image's LUT (indexed color model).
+		Does nothing if this is a ColorProcessor. */
+	public void invertLut() {
+		IndexColorModel icm = (IndexColorModel)getColorModel();
+		int mapSize = icm.getMapSize();
+		byte[] reds = new byte[mapSize];
+		byte[] greens = new byte[mapSize];
+		byte[] blues = new byte[mapSize];
+		byte[] reds2 = new byte[mapSize];
+		byte[] greens2 = new byte[mapSize];
+		byte[] blues2 = new byte[mapSize];
+		icm.getReds(reds);
+		icm.getGreens(greens);
+		icm.getBlues(blues);
+		for (int i=0; i<mapSize; i++) {
+			reds2[i] = (byte)(reds[mapSize-i-1]&255);
+			greens2[i] = (byte)(greens[mapSize-i-1]&255);
+			blues2[i] = (byte)(blues[mapSize-i-1]&255);
+		}
+		ColorModel cm = new IndexColorModel(8, mapSize, reds2, greens2, blues2);
+		double min=getMin(), max=getMax();
+		setColorModel(cm);
+		setMinAndMax(min, max);
+	}
+
+	/** Returns the LUT index that's the best match for this color. */
+	public int getBestIndex(Color c) {
+    	IndexColorModel icm;
+		if (cm==null)
+			makeDefaultColorModel();
+		if (minThreshold!=NO_THRESHOLD) {
+			double saveMin = getMinThreshold();
+			double saveMax = getMaxThreshold();
+			resetThreshold();
+			icm = (IndexColorModel)cm;
+			setThreshold(saveMin, saveMax, lutUpdateMode);
+		} else
+    		icm = (IndexColorModel)cm;
+		int mapSize = icm.getMapSize();
+		byte[] rLUT = new byte[mapSize];
+    	byte[] gLUT = new byte[mapSize];
+		byte[] bLUT = new byte[mapSize];
+    	icm.getReds(rLUT);
+    	icm.getGreens(gLUT);
+    	icm.getBlues(bLUT);
+		int minDistance = Integer.MAX_VALUE;
+		int distance;
+		int minIndex = 0;
+		int r1 = c.getRed();
+		int g1 = c.getGreen();
+		int b1 = c.getBlue();
+		if (!(r1==g1&&g1==b1&&r1==b1) && icm==defaultColorModel) {
+			double[] w = ColorProcessor.getWeightingFactors();
+			r1 = (int)Math.round(3*r1*w[0]);
+			g1 = (int)Math.round(3*g1*w[1]);
+			b1 = (int)Math.round(3*b1*w[2]);
+		}
+		int r2,b2,g2;
+    	for (int i=0; i<mapSize; i++) {
+			r2 = rLUT[i]&0xff; g2 = gLUT[i]&0xff; b2 = bLUT[i]&0xff;
+    		distance = (r2-r1)*(r2-r1)+(g2-g1)*(g2-g1)+(b2-b1)*(b2-b1);
+			//ij.IJ.log("  "+i+" "+minIndex+" "+distance+"   "+(rLUT[i]&255)+" "+(gLUT[i]&255)+" "+(bLUT[i]&255));
+    		if (distance<minDistance) {
+    			minDistance = distance;
+    			minIndex = i;
+    		}
+    		if (minDistance==0.0)
+    			break;
+    	}
+    	return minIndex;
+	}
+
+	protected boolean inversionTested = false;
+	protected boolean invertedLut;
+
+	/** Returns true if this image uses an inverting LUT
+		that displays zero as white and 255 as black. */
+	public boolean isInvertedLut() {
+		if (inversionTested)
+			return invertedLut;
+		IndexColorModel icm = getIndexColorModel();
+		if (icm==null)
+			return false;
+		boolean hasAscendingStep = false;
+		int v1, v2;
+		for (int i=1; i<255; i++) {
+			v1 = icm.getRed(i-1)+icm.getGreen(i-1)+icm.getBlue(i-1);
+			v2 = icm.getRed(i)+icm.getGreen(i)+icm.getBlue(i);
+			if (v1<v2) {
+				hasAscendingStep = true;
+				break;
+			}
+		}
+		invertedLut = !hasAscendingStep;
+		inversionTested = true;
+		return invertedLut;
+	}
+
+	/** Returns 'true' if this is an image with a grayscale LUT or an
+	 * RGB image with identical red, green and blue channels.
+	*/
+	public boolean isGrayscale() {
+		return !isColorLut();
+	}
+
+	/** Returns true if this image uses a color LUT. */
+	public boolean isColorLut() {
+		IndexColorModel icm = getIndexColorModel();
+		if (icm==null)
+			return false;
+		int mapSize = icm.getMapSize();
+		byte[] reds = new byte[mapSize];
+		byte[] greens = new byte[mapSize];
+		byte[] blues = new byte[mapSize];
+		icm.getReds(reds);
+		icm.getGreens(greens);
+		icm.getBlues(blues);
+		boolean isColor = false;
+		for (int i=0; i<mapSize; i++) {
+			if ((reds[i] != greens[i]) || (greens[i] != blues[i])) {
+				isColor = true;
+				break;
+			}
+		}
+		return isColor;
+	}
+
+	/** Returns true if this image uses a pseudocolor or grayscale LUT,
+		in other words, is this an image that can be filtered. */
+    public boolean isPseudoColorLut() {
+		IndexColorModel icm = getIndexColorModel();
+		if (icm==null)
+			return false;
+		if (getMinThreshold()!=NO_THRESHOLD)
+			return true;
+		int mapSize = icm.getMapSize();
+		if (mapSize!=256)
+			return false;
+		byte[] reds = new byte[mapSize];
+		byte[] greens = new byte[mapSize];
+		byte[] blues = new byte[mapSize];
+		icm.getReds(reds);
+		icm.getGreens(greens);
+		icm.getBlues(blues);
+		int r, g, b, d;
+		int r2=reds[0]&255, g2=greens[0]&255, b2=blues[0]&255;
+		double sum=0.0, sum2=0.0;
+		for (int i=0; i<mapSize; i++) {
+			r=reds[i]&255; g=greens[i]&255; b=blues[i]&255;
+			d=r-r2; sum+=d; sum2+=d*d;
+			d=g-g2; sum+=d; sum2+=d*d;
+			d=b-b2; sum+=d; sum2+=d*d;
+			r2=r; g2=g; b2=b;
+		}
+		double stdDev = (768*sum2-sum*sum)/768.0;
+		if (stdDev>0.0)
+			stdDev = Math.sqrt(stdDev/(767.0));
+		else
+			stdDev = 0.0;
+		boolean isPseudoColor = stdDev<20.0;
+		if ((int)stdDev==67) isPseudoColor = true; // "3-3-2 RGB" LUT
+		return isPseudoColor;
+	}
+
+	/** Returns true if the image is using the default grayscale LUT. */
+	public boolean isDefaultLut() {
+		if (cm==null)
+			makeDefaultColorModel();
+    	IndexColorModel icm = getIndexColorModel();
+    	if (icm==null)
+    		return false;
+		int mapSize = icm.getMapSize();
+		if (mapSize!=256)
+			return false;
+		byte[] reds = new byte[mapSize];
+		byte[] greens = new byte[mapSize];
+		byte[] blues = new byte[mapSize];
+		icm.getReds(reds);
+		icm.getGreens(greens);
+		icm.getBlues(blues);
+		boolean isDefault = true;
+		for (int i=0; i<mapSize; i++) {
+			if ((reds[i]&255)!=i || (greens[i]&255)!=i || (blues[i]&255)!=i) {
+				isDefault = false;
+				break;
+			}
+		}
+		return isDefault;
+	}
+
+	/** Sets the default fill/draw value to the pixel
+		value closest to the specified color. */
+	public abstract void setColor(Color color);
+
+	/** Sets the default fill/draw value. */
+	public void setColor(int value) {
+		setValue(value);
+	}
+
+	/** Sets the default fill/draw value. */
+	public void setColor(double value) {
+		setValue(value);
+	}
+
+	/** Sets the default fill/draw value. */
+	public abstract void setValue(double value);
+	
+	/** Returns the default fill/draw value. */
+	public abstract double getForegroundValue();
+
+	/** Returns 'true' if the fill/draw value has been set. */
+	public boolean fillValueSet() {
+		return fillValueSet;
+	}
+
+	/** Sets the background fill value used by the rotate() and scale() methods. */
+	public abstract void setBackgroundValue(double value);
+
+	/** Returns the background fill value. */
+	public abstract double getBackgroundValue();
+	
+	/** Sets the global (Color Picker) foreground color
+	 * as the fill/draw color.
+	 * @see ij.gui.Toolbar#setForegroundColor(Color)
+	 * @see ij.gui.Toolbar#setForegroundValue(double)
+	*/
+	public void setGlobalForegroundColor() {
+		double value = Toolbar.getForegroundValue();
+		if (Double.isNaN(value))
+			setColor(Toolbar.getForegroundColor());
+		else
+			setValue(value);
+	}
+
+	/** Sets the global (Color Picker) background color
+	 * as the fill/draw color.
+	 * @see ij.gui.Toolbar#setBackgroundColor(Color)
+	 * @see ij.gui.Toolbar#setBackgroundValue(double)
+	*/
+	public void setGlobalBackgroundColor() {
+		double value = Toolbar.getBackgroundValue();
+		if (Double.isNaN(value))
+			setColor(Toolbar.getBackgroundColor());
+		else
+			setValue(value);
+	}
+
+	/** Returns the smallest displayed pixel value. */
+	public abstract double getMin();
+
+	/** Returns the largest displayed pixel value. */
+	public abstract double getMax();
+
+	/** This image will be displayed by mapping pixel values in the
+	 * range min-max to screen values in the range 0-255. For
+	 * byte images, this mapping is done by updating the LUT. For
+	 * short and float images, it's done by generating 8-bit AWT
+	 * images. For RGB images, it's done by changing the pixel values.
+	 * With signed 16-bit images, use IJ.setMinAndMax(imp,min,max).
+	 * @see ij.IJ#setMinAndMax(ij.ImagePlus,double,double)
+	*/
+	public abstract void setMinAndMax(double min, double max);
+
+	/** For short and float images, recalculates the min and max
+		image values needed to correctly display the image. For
+		ByteProcessors, resets the LUT. */
+	public void resetMinAndMax() {}
+
+	/** Sets the lower and upper threshold levels using NO_LUT_UPDATE. */
+	public void setThreshold(double minThreshold, double maxThreshold) {
+		setThreshold(minThreshold, maxThreshold, NO_LUT_UPDATE);
+	}
+
+	/** Sets the lower and upper threshold levels. The 'lutUpdate' argument
+		can be RED_LUT, BLACK_AND_WHITE_LUT, OVER_UNDER_LUT or NO_LUT_UPDATE.
+		Thresholding of RGB images is not supported. */
+	public void setThreshold(double minThreshold, double maxThreshold, int lutUpdate) {
+		//ij.IJ.log("setThreshold: "+" "+minThreshold+" "+maxThreshold+" "+lutUpdate);
+		if (this instanceof ColorProcessor)
+			return;
+		this.minThreshold = minThreshold;
+		this.maxThreshold = maxThreshold;
+		lutUpdateMode = lutUpdate;
+		if (minThreshold==NO_THRESHOLD) {
+			resetThreshold();
+			return;
+		}
+		if (lutUpdate==NO_LUT_UPDATE)
+			return;
+		if (rLUT1==null) {
+			if (cm==null)
+				makeDefaultColorModel();
+			baseCM = cm;
+			IndexColorModel m = (IndexColorModel)cm;
+			rLUT1 = new byte[256]; gLUT1 = new byte[256]; bLUT1 = new byte[256];
+			m.getReds(rLUT1); m.getGreens(gLUT1); m.getBlues(bLUT1);
+			rLUT2 = new byte[256]; gLUT2 = new byte[256]; bLUT2 = new byte[256];
+		}
+		int t1 = (int)minThreshold;
+		int t2 = (int)maxThreshold;
+		int index;
+		if (lutUpdate==RED_LUT)
+			for (int i=0; i<256; i++) {
+				if (i>=t1 && i<=t2) {
+					rLUT2[i] = (byte)255;
+					gLUT2[i] = (byte)0;
+					bLUT2[i] = (byte)0;
+				} else {
+					rLUT2[i] = rLUT1[i];
+					gLUT2[i] = gLUT1[i];
+					bLUT2[i] = bLUT1[i];
+				}
+			}
+		else if (lutUpdate==BLACK_AND_WHITE_LUT) {
+			// updated in v1.43i by Gabriel Lindini to use blackBackground setting
+			byte  foreground = Prefs.blackBackground?(byte)255:(byte)0;
+			byte background = (byte)(255 - foreground);
+			for (int i=0; i<256; i++) {
+				if (i>=t1 && i<=t2) {
+					rLUT2[i] = foreground;
+					gLUT2[i] = foreground;
+					bLUT2[i] = foreground;
+				} else {
+					rLUT2[i] = background;
+					gLUT2[i] =background;
+					bLUT2[i] =background;
+				}
+			}
+		} else {
+			for (int i=0; i<256; i++) {
+				if (i>=t1 && i<=t2) {
+					rLUT2[i] = rLUT1[i];
+					gLUT2[i] = gLUT1[i];
+					bLUT2[i] = bLUT1[i];
+				} else if (i>t2) {
+					rLUT2[i] = (byte)overRed;
+					gLUT2[i] = (byte)overGreen;
+					bLUT2[i] = (byte)overBlue;
+				} else {
+					rLUT2[i] = (byte)underRed;
+					gLUT2[i] = (byte)underGreen;
+					bLUT2[i] = (byte)underBlue;
+				}
+			}
+		}
+		cm = new IndexColorModel(8, 256, rLUT2, gLUT2, bLUT2);
+	}
+
+	/** Automatically sets the lower and upper threshold levels, where 'method'
+	 * must be "Default", "Huang", "Intermodes", "IsoData", "IJ_IsoData", "Li",
+	 * "MaxEntropy", "Mean", "MinError", "Minimum", "Moments", "Otsu",
+	 * "Percentile", "RenyiEntropy", "Shanbhag", "Triangle" or "Yen". The
+	 * 'method' string may also include the keywords 'dark' (dark background)
+	 * 'red' (red LUT, the default), 'b&w' (black and white LUT), 'over/under' (over/under LUT) or
+	 * 'no-lut' (no LUT changes), for example "Huang dark b&w". The display range
+	 * of 16-bit and 32-bit images is not reset if the 'method' string contains 'no-reset'.
+	 * @see ImageProcessor#resetThreshold
+	 * @see ImageProcessor#setThreshold
+	 * @see ImageProcessor#createMask
+	*/
+	public void setAutoThreshold(String method) {
+		if (method==null)
+			throw new IllegalArgumentException("Null method");
+		boolean darkBackground = method.contains("dark");
+		noReset = method.contains("no-reset");
+		int lut = RED_LUT;
+		if (method.contains("b&w"))
+			lut = BLACK_AND_WHITE_LUT;
+		if (method.contains("over"))
+			lut = OVER_UNDER_LUT;
+		if (method.contains("no-lut"))
+			lut = NO_LUT_UPDATE;
+		int index = method.indexOf(" ");
+		if (index!=-1)
+			method = method.substring(0, index);
+		setAutoThreshold(method, darkBackground, lut);
+		noReset = false;
+	}
+
+	public void setAutoThreshold(String mString, boolean darkBackground, int lutUpdate) {
+		Method m = null;
+		try {
+			m = Method.valueOf(Method.class, mString);
+		} catch(Exception e) {
+			m = null;
+		}
+		if (m==null)
+			throw new IllegalArgumentException("Invalid method (\""+mString+"\")");
+		setAutoThreshold(m, darkBackground, lutUpdate);
+	}
+
+	public void setAutoThreshold(Method method, boolean darkBackground) {
+		setAutoThreshold(method, darkBackground, RED_LUT);
+	}
+
+	public void setAutoThreshold(Method method, boolean darkBackground, int lutUpdate) {
+		if (method==null || (this instanceof ColorProcessor))
+			return;
+		double min=0.0, max=0.0;
+		boolean notByteData = !(this instanceof ByteProcessor);
+		ImageProcessor ip2 = this;
+		if (notByteData) {
+			ImageProcessor mask = ip2.getMask();
+			Rectangle rect = ip2.getRoi();
+			if (!noReset || lutUpdate==OVER_UNDER_LUT)
+				ip2.resetMinAndMax();
+			noReset = false;
+			min = ip2.getMin(); max = ip2.getMax();
+			ip2 = ip2.convertToByte(true);
+			ip2.setMask(mask);
+			ip2.setRoi(rect);
+		}
+		ImageStatistics stats = ip2.getStats();
+		AutoThresholder thresholder = new AutoThresholder();
+		int threshold = thresholder.getThreshold(method, stats.histogram);
+		double lower, upper;
+		if (darkBackground) {
+			if (isInvertedLut())
+				{lower=0.0; upper=threshold;}
+			else
+				{lower=threshold+1; upper=255.0;}
+		} else {
+			if (isInvertedLut())
+				{lower=threshold+1; upper=255.0;}
+			else
+				{lower=0.0; upper=threshold;}
+		}
+		if (lower>255) lower = 255;
+		scaleAndSetThreshold(lower, upper, lutUpdate);
+	}
+
+	/** Automatically sets the lower and upper threshold levels, where 'method'
+		 must be ISODATA or ISODATA2 and 'lutUpdate' must be RED_LUT,
+		 BLACK_AND_WHITE_LUT, OVER_UNDER_LUT or NO_LUT_UPDATE.
+	*/
+	public void setAutoThreshold(int method, int lutUpdate) {
+		if (method<0 || method>ISODATA2)
+			throw new IllegalArgumentException("Invalid thresholding method");
+		if (this instanceof ColorProcessor)
+			return;
+		boolean notByteData = !(this instanceof ByteProcessor);
+		ImageProcessor ip2 = this;
+		if (notByteData) {
+			ImageProcessor mask = ip2.getMask();
+			Rectangle rect = ip2.getRoi();
+			resetMinAndMax();
+			ip2 = convertToByte(true);
+			ip2.setMask(mask);
+			ip2.setRoi(rect);
+		}
+		ImageStatistics stats = ip2.getStats();
+		int[] histogram = stats.histogram;
+		int originalModeCount = histogram[stats.mode];
+		if (method==ISODATA2) {
+			int maxCount2 = 0;
+			for (int i = 0; i<stats.nBins; i++) {
+				if ((histogram[i] > maxCount2) && (i!=stats.mode))
+					maxCount2 = histogram[i];
+			}
+			int hmax = stats.maxCount;
+			if ((hmax>(maxCount2 * 2)) && (maxCount2 != 0)) {
+				hmax = (int)(maxCount2 * 1.5);
+				histogram[stats.mode] = hmax;
+        		}
+		}
+		int threshold = ip2.getAutoThreshold(stats.histogram);
+		histogram[stats.mode] = originalModeCount;
+		float[] hist = new float[256];
+		for (int i=0; i<256; i++)
+			hist[i] = stats.histogram[i];
+		FloatProcessor fp = new FloatProcessor(256, 1, hist, null);
+		GaussianBlur gb = new GaussianBlur();
+		gb.blur1Direction(fp, 2.0, 0.01, true, 0);
+		float maxCount=0f, sum=0f, mean, count;
+		int mode = 0;
+		for (int i=0; i<256; i++) {
+			count = hist[i];
+			sum += count;
+			if (count>maxCount) {
+				maxCount = count;
+				mode = i;
+			}
+		}
+		double avg = sum/256.0;
+		double lower, upper;
+		if (maxCount/avg>1.5) {
+			if ((stats.max-mode)>(mode-stats.min))
+				{lower=threshold; upper=255.0;}
+			else
+				{lower=0.0; upper=threshold;}
+		} else {
+			if (isInvertedLut())
+				{lower=threshold; upper=255.0;}
+			else
+				{lower=0.0; upper=threshold;}
+		}
+		scaleAndSetThreshold(lower, upper, lutUpdate);
+
+	}
+
+	/** Set the threshold using a 0-255 range. For 16-bit and 32-bit images,
+	 *  this range is taken as relative with respect to the range between the
+	 *  current display min and max, but lower=0 and upper=255 are set to the
+	 * full-range limits of 16-bit images and -/+1e30 for float images.
+	*/
+	public void scaleAndSetThreshold(double lower, double upper, int lutUpdate) {
+		int bitDepth = getBitDepth();
+		if (bitDepth!=8 && lower!=NO_THRESHOLD) {
+			double min = getMin();
+			double max = getMax();
+			if (max>min) {
+				if (lower==0.0) {
+					if (bitDepth==32)
+						lower = Math.min(min, -1e30); // can't set to -Float.MAX_VALUE; causes FloodFiller.particleAnalyzerFill to hang;
+				} else
+					lower = min + (lower/255.0)*(max-min);
+				if (upper==255.0) {
+					if (bitDepth==16)
+						upper = 65535;
+					else if (bitDepth==32)
+						upper = Math.max(max, 1e30);
+				} else
+					upper = min + (upper/255.0)*(max-min);
+			} else
+				lower = upper = min;
+		}
+		setThreshold(lower, upper, lutUpdate);
+	}
+
+	/** Disables thresholding. */
+	public void resetThreshold() {
+		minThreshold = NO_THRESHOLD;
+		if (baseCM!=null) {
+			cm = baseCM;
+			baseCM = null;
+		}
+		rLUT1 = rLUT2 = null;
+		inversionTested = false;
+	}
+
+	/** Returns the lower threshold level. Returns NO_THRESHOLD
+		if thresholding is not enabled. */
+	public double getMinThreshold() {
+		return minThreshold;
+	}
+
+	/** Returns the upper threshold level. */
+	public double getMaxThreshold() {
+		return maxThreshold;
+	}
+
+	/** Returns the LUT update mode, which can be RED_LUT, BLACK_AND_WHITE_LUT,
+		OVER_UNDER_LUT or NO_LUT_UPDATE. */
+	public int getLutUpdateMode() {
+		return lutUpdateMode;
+	}
+
+	/* Sets the threshold levels (non-visible) of an 8-bit mask based on
+		the state of Prefs.blackBackground and isInvertedLut().
+		@see ImageProcessor#resetBinaryThreshold
+	*/
+	public void setBinaryThreshold() {
+		//ij.IJ.log("setMaskThreshold1");
+		if (!(this instanceof ByteProcessor)) return;
+		double t1=255.0, t2=255.0;
+		boolean invertedLut = isInvertedLut();
+		if ((invertedLut&&ij.Prefs.blackBackground) || (!invertedLut&&!ij.Prefs.blackBackground)) {
+			t1 = 0.0;
+			t2 = 0.0;
+		}
+		//ij.IJ.log("setMaskThreshold2 "+t1+" "+t2);
+		setThreshold(t1, t2, ImageProcessor.NO_LUT_UPDATE);
+	}
+
+	/** Resets the threshold if minThreshold=maxThreshold and lutUpdateMode=NO_LUT_UPDATE.
+		This removes the invisible threshold set by the MakeBinary and Convert to Mask commands.
+		@see ImageProcessor#setBinaryThreshold
+	*/
+	public void resetBinaryThreshold() {
+		if (minThreshold==maxThreshold && lutUpdateMode==NO_LUT_UPDATE)
+			resetThreshold();
+	}
+
+	/** Defines a rectangular region of interest and sets the mask
+		to null if this ROI is not the same size as the previous one.
+		@see ImageProcessor#resetRoi
+	*/
+	public void setRoi(Rectangle roi) {
+		if (roi==null)
+			resetRoi();
+		else
+			setRoi(roi.x, roi.y, roi.width, roi.height);
+	}
+
+	/** Defines a rectangular region of interest and sets the mask to
+		null if this ROI is not the same size as the previous one.
+		@see ImageProcessor#resetRoi
+	*/
+	public void setRoi(int x, int y, int rwidth, int rheight) {
+		if (x<0 || y<0 || x+rwidth>width || y+rheight>height) {
+			//find intersection of roi and this image
+			Rectangle r1 = new Rectangle(x, y, rwidth, rheight);
+			Rectangle r2 = r1.intersection(new Rectangle(0, 0, width, height));
+			if (r2.width<=0 || r2.height<=0) {
+				roiX=0; roiY=0; roiWidth=0; roiHeight=0;
+				xMin=0; xMax=0; yMin=0; yMax=0;
+				mask=null;
+				return;
+			}
+			if (mask!=null && mask.getWidth()==rwidth && mask.getHeight()==rheight) {
+				Rectangle r3 = new Rectangle(0, 0, r2.width, r2.height);
+				if (x<0) r3.x = -x;
+				if (y<0) r3.y = -y;
+				mask.setRoi(r3);
+				if (mask!=null)
+					mask = mask.crop();
+			}
+			roiX=r2.x; roiY=r2.y; roiWidth=r2.width; roiHeight=r2.height;
+		} else {
+			roiX=x; roiY=y; roiWidth=rwidth; roiHeight=rheight;
+		}
+		if (mask!=null && (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight))
+			mask = null;
+		//setup limits for 3x3 filters
+		xMin = Math.max(roiX, 1);
+		xMax = Math.min(roiX + roiWidth - 1, width - 2);
+		yMin = Math.max(roiY, 1);
+		yMax = Math.min(roiY + roiHeight - 1, height - 2);
+	}
+
+	/** Defines a non-rectangular region of interest that will consist of a
+		rectangular ROI and a mask. After processing, call <code>reset(mask)</code>
+		to restore non-masked pixels. Here is an example:
+		<pre>
+		ip.setRoi(new OvalRoi(50, 50, 100, 50));
+		ip.fill();
+		ip.reset(ip.getMask());
+		</pre>
+		The example assumes <code>snapshot()</code> has been called, which is the case
+		for code executed in the <code>run()</code> method of plugins that implement the
+		<code>PlugInFilter</code> interface.
+		@see ij.ImagePlus#getRoi
+	*/
+	public void setRoi(Roi roi) {
+		if (roi==null)
+			resetRoi();
+		else {
+			if ((roi instanceof PointRoi) && roi.size()==1) {
+				setMask(null);
+				FloatPolygon p = roi.getFloatPolygon();
+				setRoi((int)p.xpoints[0], (int)p.ypoints[0], 1, 1);
+			} else {
+				setMask(roi.getMask());
+				setRoi(roi.getBounds());
+			}
+		}
+	}
+
+	/** Defines a polygonal region of interest that will consist of a
+		rectangular ROI and a mask. After processing, call <code>reset(mask)</code>
+		to restore non-masked pixels. Here is an example:
+		<pre>
+		Polygon p = new Polygon();
+		p.addPoint(50, 0); p.addPoint(100, 100); p.addPoint(0, 100);
+		ip.setRoi(triangle);
+		ip.invert();
+		ip.reset(ip.getMask());
+		</pre>
+		The example assumes <code>snapshot()</code> has been called, which is the case
+		for code executed in the <code>run()</code> method of plugins that implement the
+		<code>PlugInFilter</code> interface.
+		@see ij.gui.Roi#getPolygon
+		@see ImageProcessor#drawPolygon
+		@see ImageProcessor#fillPolygon
+	*/
+	public void setRoi(Polygon roi) {
+		if (roi==null)
+			{resetRoi(); return;}
+		Rectangle bounds = roi.getBounds();
+		for (int i=0; i<roi.npoints; i++) {
+			roi.xpoints[i] -= bounds.x;
+			roi.ypoints[i] -= bounds.y;
+		}
+		PolygonFiller pf = new PolygonFiller();
+		pf.setPolygon(roi.xpoints, roi.ypoints, roi.npoints);
+		ImageProcessor mask = pf.getMask(bounds.width, bounds.height);
+		setMask(mask);
+		setRoi(bounds);
+		for (int i=0; i<roi.npoints; i++) {
+			roi.xpoints[i] += bounds.x;
+			roi.ypoints[i] += bounds.y;
+		}
+	}
+
+	/** Sets the ROI (Region of Interest) and clipping rectangle to the entire image. */
+	public void resetRoi() {
+		roiX=0; roiY=0; roiWidth=width; roiHeight=height;
+		xMin=1; xMax=width-2; yMin=1; yMax=height-2;
+		mask=null;
+		clipXMin=0; clipXMax=width-1; clipYMin=0; clipYMax=height-1;
+	}
+
+	/** Returns a Rectangle that represents the current
+		region of interest. */
+	public Rectangle getRoi() {
+		return new Rectangle(roiX, roiY, roiWidth, roiHeight);
+	}
+
+	/** Defines a byte mask that limits processing to an
+		irregular ROI. Background pixels in the mask have
+		a value of zero. */
+	public void setMask(ImageProcessor mask) {
+		this.mask = mask;
+	}
+
+	/** For images with irregular ROIs, returns a mask, otherwise,
+		returns null. Pixels outside the mask have a value of zero. */
+	public ImageProcessor getMask() {
+		return mask;
+	}
+
+	/** Returns a reference to the mask pixel array, or null if there is no mask. */
+	public byte[] getMaskArray() {
+		return mask!=null?(byte[])mask.getPixels():null;
+	}
+
+	/** Assigns a progress bar to this processor. Set 'pb' to
+		null to disable the progress bar. */
+	public void setProgressBar(ProgressBar pb) {
+		progressBar = pb;
+	}
+
+	/** This method has been replaced by setInterpolationMethod(). */
+	public void setInterpolate(boolean interpolate) {
+		this.interpolate = interpolate;
+		if (interpolate)
+			interpolationMethod = useBicubic?BICUBIC:BILINEAR;
+		else
+			interpolationMethod = NONE;
+	}
+
+	/** Use this method to set the interpolation method (NONE,
+		 BILINEAR or BICUBIC) used by scale(), resize() and rotate(). */
+	public void setInterpolationMethod(int method) {
+		if (method<NONE || method>BICUBIC)
+			throw new IllegalArgumentException("Invalid interpolation method");
+		interpolationMethod = method;
+		interpolate = method!=NONE?true:false;
+	}
+
+	/** Returns the current interpolation method (NONE, BILINEAR or BICUBIC). */
+	public int getInterpolationMethod() {
+		return interpolationMethod;
+	}
+
+	public static String[] getInterpolationMethods() {
+		if (interpolationMethods==null)
+			interpolationMethods = new String[] {"None", "Bilinear", "Bicubic"};
+		return interpolationMethods;
+	}
+
+	/** Returns the value of the interpolate field. */
+	public boolean getInterpolate() {
+		return interpolate;
+	}
+
+	/** @deprecated */
+	public boolean isKillable() {
+		return false;
+	}
+
+	private void process(int op, double value) {
+		double SCALE = 255.0/Math.log(255.0);
+		int v;
+
+		int[] lut = new int[256];
+		for (int i=0; i<256; i++) {
+			switch(op) {
+				case INVERT:
+					v = 255 - i;
+					break;
+				case FILL:
+					v = fgColor;
+					break;
+				case SET:
+					v = (int)value;
+					break;
+				case ADD:
+					v = i + (int)value;
+					break;
+				case MULT:
+					v = (int)Math.round(i * value);
+					break;
+				case AND:
+					v = i & (int)value;
+					break;
+				case OR:
+					v = i | (int)value;
+					break;
+				case XOR:
+					v = i ^ (int)value;
+					break;
+				case GAMMA:
+					v = (int)(Math.exp(Math.log(i/255.0)*value)*255.0);
+					break;
+				case LOG:
+					if (i==0)
+						v = 0;
+					else
+						v = (int)(Math.log(i) * SCALE);
+					break;
+				case EXP:
+					v = (int)(Math.exp(i/SCALE));
+					break;
+				case SQR:
+						v = i*i;
+					break;
+				case SQRT:
+						v = (int)Math.sqrt(i);
+					break;
+				case MINIMUM:
+					if (i<value)
+						v = (int)value;
+					else
+						v = i;
+					break;
+				case MAXIMUM:
+					if (i>value)
+						v = (int)value;
+					else
+						v = i;
+					break;
+				 default:
+				 	v = i;
+			}
+			if (v < 0)
+				v = 0;
+			if (v > 255)
+				v = 255;
+			lut[i] = v;
+		}
+		applyTable(lut);
+    }
+
+	/**
+	 * Returns an array containing the pixel values along the
+	 * line starting at (x1,y1) and ending at (x2,y2). Pixel
+	 * values are sampled using getInterpolatedValue(double,double)
+	 * if interpolation is enabled or getPixelValue(int,int) if it is not.
+	 * For byte and short images, returns calibrated values if a
+	 * calibration table has been set using setCalibrationTable().
+	 * The length of the returned array, minus one, is approximately
+	 * equal to the length of the line.
+	 * @see ImageProcessor#setInterpolate
+	 * @see ImageProcessor#getPixelValue
+	 * @see ImageProcessor#getInterpolatedValue
+	*/
+	public double[] getLine(double x1, double y1, double x2, double y2) {
+		double dx = x2-x1;
+		double dy = y2-y1;
+		int n = (int)Math.round(Math.sqrt(dx*dx + dy*dy));
+		double xinc = n>0?dx/n:0;
+		double yinc = n>0?dy/n:0;
+		if (!((xinc==0&&n==height) || (yinc==0&&n==width)))
+			n++;
+		double[] data = new double[n];
+		double rx = x1;
+		double ry = y1;
+		if (interpolate) {
+			for (int i=0; i<n; i++) {
+				data[i] = getInterpolatedValue(rx, ry);
+				rx += xinc;
+				ry += yinc;
+			}
+		} else {
+			for (int i=0; i<n; i++) {
+				data[i] = getPixelValue((int)Math.round(rx), (int)Math.round(ry));
+				rx += xinc;
+				ry += yinc;
+			}
+		}
+		return data;
+	}
+
+	/** Returns the pixel values along the horizontal line starting at (x,y). */
+	public void getRow(int x, int y, int[] data, int length) {
+		for (int i=0; i<length; i++)
+			data[i] = getPixel(x++, y);
+	}
+
+	/** Returns the pixel values along the horizontal line starting at (x,y). */
+	public float[] getRow(int x, int y, float[] data, int length) {
+		if (data==null)
+			data = new float[length];
+		for (int i=0; i<length; i++)
+			data[i] = getf(x++, y);
+		return data;
+	}
+
+	/** Returns the pixel values down the column starting at (x,y). */
+	public void getColumn(int x, int y, int[] data, int length) {
+		for (int i=0; i<length; i++)
+			data[i] = getPixel(x, y++);
+	}
+
+	/** Inserts the pixels contained in 'data' into a
+		horizontal line starting at (x,y). */
+	public void putRow(int x, int y, int[] data, int length) {
+		for (int i=0; i<length; i++)
+			putPixel(x++, y, data[i]);
+	}
+
+	/** Inserts the pixels contained in 'data' into a
+		horizontal line starting at (x,y). */
+	public void putRow(int x, int y, float[] data, int length) {
+		for (int i=0; i<length; i++)
+			setf(x++, y, data[i]);
+	}
+
+	/** Inserts the pixels contained in 'data' into a
+		column starting at (x,y). */
+	public void putColumn(int x, int y, int[] data, int length) {
+		//if (x>=0 && x<width && y>=0 && (y+length)<=height)
+		//	((ShortProcessor)this).putColumn2(x, y, data, length);
+		//else
+			for (int i=0; i<length; i++)
+				putPixel(x, y++, data[i]);
+	}
+
+	/**
+	Sets the current drawing location.
+	@see ImageProcessor#lineTo
+	@see ImageProcessor#drawString
+	*/
+	public void moveTo(int x, int y) {
+		cx = x;
+		cy = y;
+	}
+
+	/** Sets the line width used by lineTo() and drawDot(). */
+	public void setLineWidth(int width) {
+		lineWidth = width;
+		if (lineWidth<1) lineWidth = 1;
+	}
+
+	/** Returns the current line width. */
+	public int getLineWidth() {
+		return lineWidth;
+	}
+
+	/** Draws a line from the current drawing location to (x2,y2). */
+	public void lineTo(int x2, int y2) {
+		int xMin = clipXMin-lineWidth/2-1;  //need not draw dots outside of this rect
+		int xMax = clipXMax+lineWidth/2+1;
+		int yMin = clipYMin-lineWidth/2-1;
+		int yMax = clipYMax+lineWidth/2+1;
+		int dx = x2-cx;
+		int dy = y2-cy;
+		int absdx = dx>=0?dx:-dx;
+		int absdy = dy>=0?dy:-dy;
+		int n = absdy>absdx?absdy:absdx;
+		double xinc = dx!=0 ? (double)dx/n : 0; //single point (dx=dy=n=0): avoid division by zero
+		double yinc = dy!=0 ? (double)dy/n : 0;
+		double x = cx;
+		double y = cy;
+		cx = x2; cy = y2;       //keep end point as starting for the next lineTo
+		int i1 = 0;
+		if (dx>0)
+			i1 = Math.max(i1, (int)((xMin-x)/xinc));
+		else if (dx<0)
+			i1 = Math.max(i1, (int)((xMax-x)/xinc));
+		else if (x<xMin || x>xMax)
+			return; // vertical line outside y range
+		if (dy>0)
+			i1 = Math.max(i1, (int)((yMin-y)/yinc));
+		else if (dy<0)
+			i1 = Math.max(i1, (int)((yMax-y)/yinc));
+		else if (y<yMin || y>yMax)
+			return; // horizontal line outside y range
+		int i2 = n;
+		if (dx>0)
+			i2 = Math.min(i2, (int)((xMax-x)/xinc));
+		else if (dx<0)
+			i2 = Math.min(i2, (int)((xMin-x)/xinc));
+		if (dy>0)
+			i2 = Math.min(i2, (int)((yMax-y)/yinc));
+		else if (dy<0)
+			i2 = Math.min(i2, (int)((yMin-y)/yinc));
+		x += i1*xinc;
+		y += i1*yinc;
+		for (int i=i1; i<=i2; i++) {
+			if (lineWidth==1)
+				drawPixel((int)Math.round(x), (int)Math.round(y));
+			else if (lineWidth==2)
+				drawDot2((int)Math.round(x), (int)Math.round(y));
+			else
+				drawDot((int)Math.round(x), (int)Math.round(y));
+			x += xinc;
+			y += yinc;
+		}
+	}
+
+	/** Draws a line from (x1,y1) to (x2,y2). */
+	public void drawLine(int x1, int y1, int x2, int y2) {
+		moveTo(x1, y1);
+		lineTo(x2, y2);
+	}
+
+	/* Draws a line using the Bresenham's algorithm that is 4-connected instead of 8-connected.<br>
+		Based on code from http://stackoverflow.com/questions/5186939/algorithm-for-drawing-a-4-connected-line<br>
+		Author: Gabriel Landini (G.Landini at bham.ac.uk)
+	*/
+	 public void drawLine4(int x1, int y1, int x2, int y2) {
+		int dx = Math.abs(x2 - x1);
+		int dy = Math.abs(y2 - y1);
+		int sgnX = x1 < x2 ? 1 : -1;
+		int sgnY = y1 < y2 ? 1 : -1;
+		int e = 0;
+		for (int i=0; i < dx+dy; i++) {
+			putPixel(x1, y1, fgColor);
+			int e1 = e + dy;
+			int e2 = e - dx;
+			if (Math.abs(e1) < Math.abs(e2)) {
+				x1 += sgnX;
+				e = e1;
+			} else {
+				y1 += sgnY;
+				e = e2;
+			}
+		}
+		putPixel(x2, y2, fgColor);
+	}
+
+	/** Draws a rectangle. */
+	public void drawRect(int x, int y, int width, int height) {
+		if (width<1 || height<1)
+			return;
+		if (lineWidth==1) {
+			moveTo(x, y);
+			lineTo(x+width-1, y);
+			lineTo(x+width-1, y+height-1);
+			lineTo(x, y+height-1);
+			lineTo(x, y);
+		} else {
+			moveTo(x, y);
+			lineTo(x+width, y);
+			lineTo(x+width, y+height);
+			lineTo(x, y+height);
+			lineTo(x, y);
+		}
+	}
+
+	/** Fills a rectangle. */
+	public void fillRect(int x, int y, int width, int height) {
+		setRoi(x, y, width, height);
+		fill();
+		resetRoi();
+	}
+
+	/** Draws an elliptical shape. */
+	public void drawOval(int x, int y, int width, int height) {
+		if ((long)width*height>4L*this.width*this.height)
+			return;
+		OvalRoi oval = new OvalRoi(x, y, width, height);
+		drawPolygon(oval.getPolygon());
+	}
+
+	/** Fills an elliptical shape. */
+	public void fillOval(int x, int y, int width, int height) {
+		if ((long)width*height>4L*this.width*this.height)
+			return;
+		OvalRoi oval = new OvalRoi(x, y, width, height);
+		fillPolygon(oval.getPolygon());
+	}
+
+	/** Draws a polygon. */
+	public void drawPolygon(Polygon p) {
+		moveTo(p.xpoints[0], p.ypoints[0]);
+		for (int i=0; i<p.npoints; i++)
+			lineTo(p.xpoints[i], p.ypoints[i]);
+		lineTo(p.xpoints[0], p.ypoints[0]);
+	}
+
+	/** Fills a polygon. */
+	public void fillPolygon(Polygon p) {
+		setRoi(p);
+		fill(getMask());
+		resetRoi();
+	}
+
+	/** @deprecated */
+	public void drawDot2(int x, int y) {
+		drawPixel(x, y);
+		drawPixel(x-1, y);
+		drawPixel(x, y-1);
+		drawPixel(x-1, y-1);
+	}
+
+    /** Draws a dot using the current line width and fill/draw value. */
+	public void drawDot(int xcenter, int ycenter) {
+		double r = lineWidth/2.0;
+		int xmin=(int)(xcenter-r+0.5), ymin=(int)(ycenter-r+0.5);
+		int xmax=xmin+lineWidth, ymax=ymin+lineWidth;
+		//if (xcenter<clipXMin || ycenter<clipYMin || xcenter>clipXMax || ycenter>clipYMax ) {
+		if (xmin<clipXMin || ymin<clipYMin || xmax>clipXMax || ymax>clipYMax ) {
+			// draw edge dot
+			double r2 = r*r;
+			r -= 0.5;
+			double xoffset=xmin+r, yoffset=ymin+r;
+			double xx, yy;
+			for (int y=ymin; y<ymax; y++) {
+				for (int x=xmin; x<xmax; x++) {
+					xx = x-xoffset; yy = y-yoffset;
+					if (xx*xx+yy*yy<=r2)
+						drawPixel(x, y);
+				}
+			}
+		} else {
+			if (dotMask==null || lineWidth!=dotMask.getWidth()) {
+				OvalRoi oval = new OvalRoi(0, 0, lineWidth, lineWidth);
+				dotMask = oval.getMask();
+			}
+			setRoi(xmin, ymin, lineWidth, lineWidth);
+			fill(dotMask);
+			roiX=0; roiY=0; roiWidth=width; roiHeight=height;
+			xMin=1; xMax=width-2; yMin=1; yMax=height-2;
+			mask=null;
+		}
+	}
+
+    private ImageProcessor dotMask;
+
+	private void setupFontMetrics() {
+		if (fontMetrics==null) {
+			fmImage=new BufferedImage(1, 1, BufferedImage.TYPE_INT_RGB);
+			fmGraphics = (Graphics2D)fmImage.getGraphics();
+			fmGraphics.setFont(font);
+			Java2.setAntialiasedText(fmGraphics, antialiasedText);
+			fontMetrics = fmGraphics.getFontMetrics(font);
+		}
+	}
+
+	/** Draws a string at the current drawing location using the current fill/draw value.
+	 *  Draws multiple lines if the string contains newline characters.
+	 *  The current x coordinate is the left/center/right end of the string for
+	 *  left/center/right justification.
+	 *  The current y coordinate determines the bottommost position of the string,
+	 *  including the descent of the font (i.e., characters reaching below the baseline)
+	 *  For multi-line strings, the y coordinate applies to the first line.
+	 *  The y of the drawing position is incremented by the height of one text line,
+	 *  i.e. points at the drawing position for the next text line */
+	public void drawString(String s) {
+		if (s==null || s.equals("")) return;
+		setupFontMetrics();
+		if (s.indexOf("\n")==-1)
+			drawString2(s);
+		else {
+			String[] s2 = Tools.split(s, "\n");
+			for (int i=0; i<s2.length; i++)
+				drawString2(s2[i]);
+		}
+	}
+
+	/** Draws a single-line string at the current drawing location cx, cy and
+	 *  adds the line height (FontMetrics.getHeight) to the current y coordinate 'cy' */
+	private void drawString2(String s) {
+		int w =  getStringWidth(s);
+		int cxx = cx;
+		if (justification==CENTER_JUSTIFY)
+			cxx -= w/2;
+		else if (justification==RIGHT_JUSTIFY)
+			cxx -= w;
+		int h =  fontMetrics.getHeight();
+		if (w<=0 || h<=0) return;
+		Image bi = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
+		Graphics g = bi.getGraphics();
+		FontMetrics metrics = g.getFontMetrics(font);
+		int fontHeight = metrics.getHeight();
+		int descent = metrics.getDescent();
+		g.setFont(font);
+
+		if (antialiasedText && cxx>=0 && cy-h>=0) {
+			Java2.setAntialiasedText(g, true);
+			setRoi(cxx, cy-h, w, h);
+			ImageProcessor ip = crop();
+			resetRoi();
+			if (ip.getWidth()==0||ip.getHeight()==0)
+				return;
+			g.drawImage(ip.createImage(), 0, 0, null);
+			g.setColor(drawingColor);
+			g.drawString(s, 0, h-descent);
+			g.dispose();
+			ip = new ColorProcessor(bi);
+			if (this instanceof ByteProcessor) {
+				ip = ip.convertToByte(false);
+				if (isInvertedLut()) ip.invert();
+			}
+			//new ij.ImagePlus("ip",ip).show();
+			insert(ip, cxx, cy-h);
+			cy += h;
+			return;
+		}
+
+		Java2.setAntialiasedText(g, false);
+		g.setColor(Color.white);
+		g.fillRect(0, 0, w, h);
+		g.setColor(Color.black);
+		g.drawString(s, 0, h-descent);
+		g.dispose();
+		ImageProcessor ip = new ColorProcessor(bi);
+		ImageProcessor textMask = ip.convertToByte(false);
+		byte[] mpixels = (byte[])textMask.getPixels();
+		//new ij.ImagePlus("textmask",textMask).show();
+		textMask.invert();
+		if (cxx<width && cy-h<height) {
+			setMask(textMask);
+			setRoi(cxx,cy-h,w,h);
+			fill(getMask());
+		}
+		resetRoi();
+		cy += h;
+	}
+
+	/** Draws a string at the specified location using the current fill/draw value.
+	 *  Draws multiple lines if the string contains newline characters.
+	 *  The x coordinate is the left/center/right end of the string for left/center/right
+	 *  justification.
+	 *  The y coordinate determines the bottommost position of the string,
+	 *  including the descent of the font (i.e., characters reaching below the baseline)
+	 *  For multi-line strings, the y coordinate applies to the first line. */
+	public void drawString(String s, int x, int y) {
+		moveTo(x, y);
+		drawString(s);
+	}
+
+	/** Draws a string at the specified location with a filled background.
+		A JavaScript example is available at
+			http://imagej.nih.gov/ij/macros/js/DrawTextWithBackground.js
+	*/
+	public void drawString(String s, int x, int y, Color background) {
+		Color foreground = drawingColor;
+		FontMetrics metrics = getFontMetrics();
+		int w = 0;
+		int h = metrics.getAscent() + metrics.getDescent();
+		int y2 = y;
+		if (s.indexOf("\n")!=-1) {
+			String[] s2 = Tools.split(s, "\n");
+			for (int i=0; i<s2.length; i++) {
+				int w2 = getStringWidth(s2[i]);
+				if (w2>w) w = w2;
+			}
+			int h2 = metrics.getHeight();
+			y2 += h2*(s2.length-1);
+			h += h2*(s2.length-1);
+		} else
+			w = getStringWidth(s);
+		int x2 = x;
+		if (justification==CENTER_JUSTIFY)
+			x2 -= w/2;
+		else if (justification==RIGHT_JUSTIFY)
+			x2 -= w;
+		setColor(background);
+		setRoi(x2, y2-h, w, h);
+		fill();
+		resetRoi();
+		setColor(foreground);
+		drawString(s, x, y);
+	}
+
+	/** Sets the justification used by drawString(), where <code>justification</code>
+		is CENTER_JUSTIFY, RIGHT_JUSTIFY or LEFT_JUSTIFY. The default is LEFT_JUSTIFY. */
+	public void setJustification(int justification) {
+		if (justification<LEFT_JUSTIFY || justification>RIGHT_JUSTIFY)
+			justification = LEFT_JUSTIFY;
+		this.justification = justification;
+	}
+
+	/** Sets the font used by drawString(). */
+	public void setFont(Font font) {
+		this.font = font;
+		boldFont = font.isBold();
+		setupFontMetrics();
+		fmGraphics.setFont(font);
+		Java2.setAntialiasedText(fmGraphics, antialiasedText);
+		fontMetrics = fmGraphics.getFontMetrics(font);
+	}
+	
+	/** Sets the size of the font used by drawString(). */
+	public void setFontSize(int size) {
+		setFont(font.deriveFont(font.getStyle(), size));
+		if (size>15)
+			setAntialiasedText(true);
+	}
+
+
+	/** Specifies whether or not text is drawn using antialiasing. Antialiased
+		test requires an 8 bit or RGB image. Antialiasing does not
+		work with 8-bit images that are not using 0-255 display range. */
+	public void setAntialiasedText(boolean antialiasedText) {
+		setupFontMetrics();
+		if (antialiasedText && (((this instanceof ByteProcessor)&&getMin()==0.0&&getMax()==255.0) || (this instanceof ColorProcessor)))
+			this.antialiasedText = true;
+		else
+			this.antialiasedText = false;
+		Java2.setAntialiasedText(fmGraphics, this.antialiasedText);
+		fontMetrics = fmGraphics.getFontMetrics(font);
+	}
+
+	/** Returns the width in pixels of the specified string, including any background
+	 *  space (whitespace) between the x drawing coordinate and the string, not necessarily
+	 *  including all whitespace at the right. */
+	public int getStringWidth(String s) {
+		// Note that fontMetrics.getStringBounds often underestimates the width (worst for italic fonts on Macs)
+		// On the other hand, GlyphVector.getPixelBounds (returned by this.getStringBounds)
+		// does not include the full character width of e.g. the '1' character, which would make
+		// lists of right-justified numbers such as the y axis of plots look ugly.
+		// Thus, the maximum of both methods is returned.
+		Rectangle2D rect = getStringBounds(s);
+		return (int)Math.max(fontMetrics.getStringBounds(s, fmGraphics).getWidth(), rect.getX()+rect.getWidth());
+	}
+
+	/** Returns a rectangle enclosing the pixels affected by drawString
+	 *  assuming it is drawn at (x=0, y=0). As drawString draws above the drawing location,
+	 *  the y coordinate of the rectangle is negative. */
+	public Rectangle getStringBounds(String s) {
+		setupFontMetrics();
+		GlyphVector gv = font.createGlyphVector(fmGraphics.getFontRenderContext(), s);
+		Rectangle2D rect = gv.getPixelBounds(null, 0.f, -fontMetrics.getDescent());
+		return new Rectangle((int)rect.getX(), (int)rect.getY(), (int)rect.getWidth(), (int)rect.getHeight());
+	}
+
+	/** Returns the current font. */
+	public Font getFont() {
+		return font;
+	}
+
+	/** Returns the current FontMetrics. */
+	public FontMetrics getFontMetrics() {
+		setupFontMetrics();
+		return fontMetrics;
+	}
+
+	/** Replaces each pixel with the 3x3 neighborhood mean. */
+	public void smooth() {
+		if (width>1)
+			filter(BLUR_MORE);
+	}
+
+	/** Sharpens the image or ROI using a 3x3 convolution kernel. */
+	public void sharpen() {
+		if (width>1) {
+			int[] kernel = {-1, -1, -1,
+		                -1, 12, -1,
+		                -1, -1, -1};
+			convolve3x3(kernel);
+		}
+	}
+
+	/** Finds edges in the image or ROI using a Sobel operator. */
+	public void findEdges() {
+		if (width>1)
+			filter(FIND_EDGES);
+	}
+
+	/** Flips the image or ROI vertically. */
+	public abstract void flipVertical();
+
+	/** Flips the image or ROI horizontally. */
+	public void flipHorizontal() {
+		int[] col1 = new int[roiHeight];
+		int[] col2 = new int[roiHeight];
+		for (int x=0; x<roiWidth/2; x++) {
+			getColumn(roiX+x, roiY, col1, roiHeight);
+			getColumn(roiX+roiWidth-x-1, roiY, col2, roiHeight);
+			putColumn(roiX+x, roiY, col2, roiHeight);
+			putColumn(roiX+roiWidth-x-1, roiY, col1, roiHeight);
+		}
+	}
+
+	/** Rotates the entire image 90 degrees clockwise. Returns
+		a new ImageProcessor that represents the rotated image. */
+	public ImageProcessor rotateRight() {
+		int width2 = height;
+		int height2 = width;
+        ImageProcessor ip2 = createProcessor(width2, height2);
+		int[] arow = new int[width];
+		for (int row=0; row<height; row++) {
+			getRow(0, row, arow, width);
+			ip2.putColumn(width2-row-1, 0, arow, height2);
+		}
+        return ip2;
+	}
+
+	/** Rotates the entire image 90 degrees counter-clockwise. Returns
+		a new ImageProcessor that represents the rotated image. */
+	public ImageProcessor rotateLeft() {
+		int width2 = height;
+		int height2 = width;
+        ImageProcessor ip2 = createProcessor(width2, height2);
+		int[] arow = new int[width];
+		int[] arow2 = new int[width];
+		for (int row=0; row<height; row++) {
+			getRow(0, row, arow, width);
+			for (int i=0; i<width; i++) {
+				arow2[i] = arow[width-i-1];
+			}
+			ip2.putColumn(row, 0, arow2, height2);
+		}
+        return ip2;
+	}
+
+	/** Inserts the image contained in 'ip' at (xloc, yloc). */
+	public void insert(ImageProcessor ip, int xloc, int yloc) {
+		copyBits(ip, xloc, yloc, Blitter.COPY);
+	}
+
+	/** Returns a string containing information about this ImageProcessor. */
+	public String toString() {
+		return ("ip[width="+width+", height="+height+", bits="+getBitDepth()+", min="+getMin()+", max="+getMax()+"]");
+	}
+
+	/** Fills the image or ROI bounding rectangle with the current fill/draw value. Use
+	*	fill(Roi) or fill(ip.getMask()) to fill non-rectangular selections.
+	*	@see #setColor(Color)
+	*	@see #setValue(double)
+	*	@see #fill(Roi)
+	*/
+	public void fill() {
+		process(FILL, 0.0);
+	}
+
+	/** Fills pixels that are within the ROI bounding rectangle and part of
+	*	the mask (i.e. pixels that have a value=BLACK in the mask array).
+	*	Use ip.getMask() to acquire the mask.
+	*	Throws and IllegalArgumentException if the mask is null or
+	*	the size of the mask is not the same as the size of the ROI.
+	*	@see #setColor(Color)
+	*	@see #setValue(double)
+	*	@see #getMask
+	*	@see #fill(Roi)
+	*/
+	public abstract void fill(ImageProcessor mask);
+
+	/**	 Fills the ROI with the current fill/draw value.
+	*	@see #setColor(Color)
+	*	@see #setValue(double)
+	*	@see #fill(Roi)
+	*/
+	public void fill(Roi roi) {
+		if (roi!=null && roi.isLine()) {
+			if ((roi instanceof Line) && roi.getStrokeWidth()>1 && !(roi instanceof Arrow))
+				fillPolygon(roi.getPolygon());
+			else
+				roi.drawPixels(this);
+			return;
+		}
+		ImageProcessor m = getMask();
+		Rectangle r = getRoi();
+		setRoi(roi);
+		fill(getMask());
+		setMask(m);
+		setRoi(r);
+	}
+
+	/** Fills outside an Roi. */
+	public void fillOutside(Roi roi) {
+		if (roi==null || !roi.isArea()) return;
+		ImageProcessor m = getMask();
+		Rectangle r = getRoi();
+		ShapeRoi s1, s2;
+		if (roi instanceof ShapeRoi)
+			s1 = (ShapeRoi)roi;
+		else
+			s1 = new ShapeRoi(roi);
+		s2 = new ShapeRoi(new Roi(0,0, width, height));
+		setRoi(s2.xor(s1));
+		fill(getMask());
+		setMask(m);
+		setRoi(r);
+	}
+
+	/** Draws the specified ROI on this image using the line
+		width and color defined by ip.setLineWidth() and ip.setColor().
+		@see ImageProcessor#drawRoi
+	*/
+	public void draw(Roi roi) {
+		roi.drawPixels(this);
+	}
+
+	/** Draws the specified ROI on this image using the stroke
+		width, stroke color and fill color defined by roi.setStrokeWidth,
+		roi.setStrokeColor() and roi.setFillColor(). Works   with RGB
+		images. Does not work with 16-bit and float images.
+		@see ImageProcessor#draw
+		@see ImageProcessor#drawOverlay
+	*/
+	public void drawRoi(Roi roi) {
+		Image img = createImage();
+		Graphics g = img.getGraphics();
+		ij.ImagePlus imp = roi.getImage();
+		if (imp!=null) {
+			roi.setImage(null);
+			roi.drawOverlay(g);
+			roi.setImage(imp);
+		} else
+			roi.drawOverlay(g);
+	}
+
+	/** Draws the specified Overlay on this image. Works best
+		with RGB images. Does not work with 16-bit and float
+		images. Requires Java 1.6.
+		@see ImageProcessor#drawRoi
+	*/
+	public void drawOverlay(Overlay overlay) {
+		 Roi[] rois = overlay.toArray();
+		 for (int i=0; i<rois.length; i++)
+		 	drawRoi(rois[i]);
+	}
+
+	/** Set a lookup table used by getPixelValue(), getLine() and
+		convertToFloat() to calibrate pixel values. The length of
+		the table must be 256 for byte images and 65536 for short
+		images. RGB and float processors do not do calibration.
+		@see ij.measure.Calibration#setCTable
+	*/
+	public void setCalibrationTable(float[] cTable) {
+		this.cTable = cTable;
+	}
+
+	/** Returns the calibration table or null. */
+	public float[] getCalibrationTable() {
+		return cTable;
+	}
+
+	/** Set the number of bins to be used for histograms of float images. */
+	public void setHistogramSize(int size) {
+		histogramSize = size;
+		if (histogramSize<1) histogramSize = 1;
+	}
+
+	/** Returns the number of float image histogram bins. The bin
+		count is fixed at 256 for the other three data types. */
+	public int getHistogramSize() {
+		return histogramSize;
+	}
+
+	/** Set the range used for histograms of float images. The image range is
+		used if both <code>histMin</code> and <code>histMax</code> are zero. */
+	public void setHistogramRange(double histMin, double histMax) {
+		if (histMin>histMax) {
+			histMin = 0.0;
+			histMax = 0.0;
+		}
+		histogramMin = histMin;
+		histogramMax = histMax;
+	}
+
+	/**	Returns the minimum histogram value used for histograms of float images. */
+	public double getHistogramMin() {
+		return histogramMin;
+	}
+
+	/**	Returns the maximum histogram value used for histograms of float images. */
+	public double getHistogramMax() {
+		return histogramMax;
+	}
+
+	/** Returns a reference to this image's pixel array. The
+		array type (byte[], short[], float[] or int[]) varies
+		depending on the image type. */
+	public abstract Object getPixels();
+
+	/** Returns a copy of the pixel data. Or returns a reference to the
+		snapshot buffer if it is not null and 'snapshotCopyMode' is true.
+		@see ImageProcessor#snapshot
+		@see ImageProcessor#setSnapshotCopyMode
+	*/
+	public abstract Object getPixelsCopy();
+
+	/** Returns the value of the pixel at (x,y). For RGB images, the
+	 * argb values are packed in an int. For float images, the
+	 * the value must be converted using Float.intBitsToFloat().
+	 * Returns zero if either the x or y coodinate is out of range.
+	 * Use <i>getValue(x,y)</i> to get calibrated values from
+	 * 8-bit and 16-bit images, to get intensity values from RGB
+	 * images and to get float values from 32-bit images.
+	 * @see ImageProcessor#getValue
+	*/
+	public abstract int getPixel(int x, int y);
+
+	/** This is a faster version of getPixel() that does not do bounds checking. */
+	public abstract int get(int x, int y);
+
+	public abstract int get(int index);
+
+	/** This is a faster version of putPixel() that does not clip
+		out of range values and does not do bounds checking. */
+	public abstract void set(int x, int y, int value);
+
+	public abstract void set(int index, int value);
+
+	/** Returns the value of the pixel at (x,y) as a float. Faster
+	    than getPixelValue() because no bounds checking is done. */
+	public abstract float getf(int x, int y);
+
+	public abstract float getf(int index);
+
+	/** Sets the value of the pixel at (x,y) to 'value'. Does no bounds
+	    checking or clamping, making it faster than putPixel(). Due to the lack
+	    of bounds checking, (x,y) coordinates outside the image may cause
+	    an exception. Due to the lack of clamping, values outside the 0-255
+	    range (for byte) or 0-65535 range (for short) are not handled correctly.
+	*/
+	public abstract void setf(int x, int y, float value);
+
+	public abstract void setf(int index, float value);
+
+	public int getPixelCount() {
+		return width*height;
+	}
+
+	/** Returns a copy of the pixel data as a 2D int array with
+		dimensions [x=0..width-1][y=0..height-1]. With RGB
+		images, the returned values are in packed ARGB format.
+		With float images, the returned values must be converted
+		to float using Float.intBitsToFloat(). */
+	public int[][] getIntArray() {
+		int[][] a = new int [width][height];
+		for(int y=0; y<height; y++) {
+			for(int x=0; x<width; x++)
+				a[x][y]=get(x,y);
+		}
+		return a;
+	}
+
+	/** Replaces the pixel data with contents of the specified 2D int array. */
+	public void setIntArray(int[][] a) {
+		for(int y=0; y<height; y++) {
+			for(int x=0; x<width; x++)
+				set(x, y, a[x][y]);
+		}
+	}
+
+	/** Returns a copy of the pixel data as a 2D float
+		array with dimensions [x=0..width-1][y=0..height-1]. */
+	public float[][] getFloatArray() {
+		float[][] a = new float[width][height];
+		for(int y=0; y<height; y++) {
+			for(int x=0; x<width; x++)
+				a[x][y]=getf(x,y);
+		}
+		return a;
+	}
+
+	/** Replaces the pixel data with contents of the specified 2D float array. */
+	public void setFloatArray(float[][] a) {
+		for(int y=0; y<height; y++) {
+			for(int x=0; x<width; x++)
+				setf(x, y, a[x][y]);
+		}
+	}
+
+	/** Experimental */
+	public void getNeighborhood(int x, int y, double[][] arr) {
+		int nx=arr.length;
+		int ny=arr[0].length;
+		int nx2 = (nx-1)/2;
+		int ny2 = (ny-1)/2;
+	 	if (x>=nx2 && y>=ny2 && x<width-nx2-1 && y<height-ny2-1) {
+			int index = (y-ny2)*width + (x-nx2);
+			for (int y2=0; y2<ny; y2++) {
+	 			for (int x2=0; x2<nx; x2++)
+					arr[x2][y2] = getf(index++);
+				index += (width - nx);
+			}
+		} else {
+			for (int y2=0; y2<ny; y2++) {
+	 			for (int x2=0; x2<nx; x2++)
+					arr[x2][y2] = getPixelValue(x2, y2);
+			}
+		}
+	}
+
+    /** Returns the samples for the pixel at (x,y) in an int array.
+	 * RGB pixels have three samples, all others have one.
+	 * Returns zeros if the the coordinates are not in bounds.
+	 * iArray is an optional preallocated array.
+	*/
+	public int[] getPixel(int x, int y, int[] iArray) {
+		if (iArray==null) iArray = new int[1];
+		iArray[0] = getPixel(x, y);
+		return iArray;
+	}
+
+	/** Sets a pixel in the image using an int array of samples.
+		RGB pixels have three samples, all others have one. */
+	public void putPixel(int x, int y, int[] iArray) {
+		putPixel(x, y, iArray[0]);
+	}
+
+	/** Uses the current interpolation method (bilinear or bicubic)
+		to find the pixel value at real coordinates (x,y). */
+	public abstract double getInterpolatedPixel(double x, double y);
+
+	/** Uses the current interpolation method to find the pixel value at real coordinates (x,y).
+		For RGB images, the argb values are packed in an int. For float images,
+		the value must be converted using Float.intBitsToFloat().  Returns zero
+		if the (x, y) is not inside the image. */
+	public abstract int getPixelInterpolated(double x, double y);
+
+	/** Uses bilinear interpolation to find the pixel value at real coordinates (x,y).
+		Returns zero if the (x, y) is not inside the image. */
+	public final double getInterpolatedValue(double x, double y) {
+		if (useBicubic)
+			return getBicubicInterpolatedPixel(x, y, this);
+		if (x<0.0 || x>=width-1.0 || y<0.0 || y>=height-1.0) {
+			if (x<-1.0 || x>=width || y<-1.0 || y>=height)
+				return 0.0;
+			else
+				return getInterpolatedEdgeValue(x, y);
+		}
+		int xbase = (int)x;
+		int ybase = (int)y;
+		double xFraction = x - xbase;
+		double yFraction = y - ybase;
+		if (xFraction<0.0) xFraction = 0.0;
+		if (yFraction<0.0) yFraction = 0.0;
+		double lowerLeft = getPixelValue(xbase, ybase);
+		double lowerRight = getPixelValue(xbase+1, ybase);
+		double upperRight = getPixelValue(xbase+1, ybase+1);
+		double upperLeft = getPixelValue(xbase, ybase+1);
+		double upperAverage = upperLeft + xFraction * (upperRight - upperLeft);
+		double lowerAverage = lowerLeft + xFraction * (lowerRight - lowerLeft);
+		return lowerAverage + yFraction * (upperAverage - lowerAverage);
+	}
+
+	/** This method is from Chapter 16 of "Digital Image Processing:
+		An Algorithmic Introduction Using Java" by Burger and Burge
+		(http://www.imagingbook.com/). */
+	public double getBicubicInterpolatedPixel(double x0, double y0, ImageProcessor ip2) {
+		int u0 = (int) Math.floor(x0);	//use floor to handle negative coordinates too
+		int v0 = (int) Math.floor(y0);
+		if (u0<=0 || u0>=width-2 || v0<=0 || v0>=height-2)
+			return ip2.getBilinearInterpolatedPixel(x0, y0);
+		double q = 0;
+		for (int j = 0; j <= 3; j++) {
+			int v = v0 - 1 + j;
+			double p = 0;
+			for (int i = 0; i <= 3; i++) {
+				int u = u0 - 1 + i;
+				p = p + ip2.get(u,v) * cubic(x0 - u);
+			}
+			q = q + p * cubic(y0 - v);
+		}
+		return q;
+	}
+
+	final double getBilinearInterpolatedPixel(double x, double y) {
+		if (x>=-1 && x<width && y>=-1 && y<height) {
+			int method = interpolationMethod;
+			interpolationMethod = BILINEAR;
+			double value = getInterpolatedPixel(x, y);
+			interpolationMethod = method;
+			return value;
+		} else
+			return getBackgroundValue();
+	}
+
+	static final double a = 0.5; // Catmull-Rom interpolation
+	public static final double cubic(double x) {
+		if (x < 0.0) x = -x;
+		double z = 0.0;
+		if (x < 1.0)
+			z = x*x*(x*(-a+2.0) + (a-3.0)) + 1.0;
+		else if (x < 2.0)
+			z = -a*x*x*x + 5.0*a*x*x - 8.0*a*x + 4.0*a;
+		return z;
+	}
+
+	private final double getInterpolatedEdgeValue(double x, double y) {
+		int xbase = (int)x;
+		int ybase = (int)y;
+		double xFraction = x - xbase;
+		double yFraction = y - ybase;
+		if (xFraction<0.0) xFraction = 0.0;
+		if (yFraction<0.0) yFraction = 0.0;
+		double lowerLeft = getEdgeValue(xbase, ybase);
+		double lowerRight = getEdgeValue(xbase+1, ybase);
+		double upperRight = getEdgeValue(xbase+1, ybase+1);
+		double upperLeft = getEdgeValue(xbase, ybase+1);
+		double upperAverage = upperLeft + xFraction * (upperRight - upperLeft);
+		double lowerAverage = lowerLeft + xFraction * (lowerRight - lowerLeft);
+		return lowerAverage + yFraction * (upperAverage - lowerAverage);
+	}
+
+	private float getEdgeValue(int x, int y) {
+		if (x<=0) x = 0;
+		if (x>=width) x = width-1;
+		if (y<=0) y = 0;
+		if (y>=height) y = height-1;
+		return getPixelValue(x, y);
+	}
+
+	/** Stores the specified value at (x,y). Does
+		nothing if (x,y) is outside the image boundary.
+		For 8-bit and 16-bit images, out of range values
+		are clamped. For RGB images, the
+		argb values are packed in 'value'. For float images,
+		'value' is expected to be a float converted to an int
+		using Float.floatToIntBits(). */
+	public abstract void putPixel(int x, int y, int value);
+
+
+	/** Returns the value of the pixel at <i>(x,y)</i>, a calibrated
+	 * value from 8-bit and 16-bit images, an intensity value
+	 * from RGB images and a double value from 32-bit images.
+	 * This is an alias for getPixelValue(x,y).
+	 * @see ImageProcessor#getPixel
+	 * @see ImageProcessor#getPixelValue
+	*/
+	public double getValue(int x, int y) {
+		return getPixelValue(x,y);
+	}
+
+	/** Returns the value of the pixel at (x,y). For byte and short
+	 * images, returns a calibrated value if a calibration table
+	 * has been set using setCalibraionTable(). For RGB images,
+	 * returns the luminance value.
+	*/
+	public abstract float getPixelValue(int x, int y);
+
+	/** Stores the specified value at (x,y). */
+	public abstract void putPixelValue(int x, int y, double value);
+
+	/** Sets the pixel at (x,y) to the current fill/draw value. */
+	public abstract void drawPixel(int x, int y);
+
+	/** Sets a new pixel array for the image. The length of the array must be equal to width*height.
+		Use setSnapshotPixels(null) to clear the snapshot buffer. */
+	public abstract void setPixels(Object pixels);
+
+	/** Copies the image contained in 'ip' to (xloc, yloc) using one of
+		the transfer modes defined in the Blitter interface. */
+	public abstract void copyBits(ImageProcessor ip, int xloc, int yloc, int mode);
+
+	/** Transforms the image or ROI using a lookup table. The
+		length of the table must be 256 for byte images and
+		65536 for short images. RGB and float images are not
+		supported. */
+	public abstract void applyTable(int[] lut);
+
+	/** Inverts the image or ROI. */
+	public void invert() {process(INVERT, 0.0);}
+
+	/** Adds 'value' to each pixel in the image or ROI. */
+	public void add(int value) {process(ADD, value);}
+
+	/** Adds 'value' to each pixel in the image or ROI. */
+	public void add(double value) {process(ADD, value);}
+
+	/** Subtracts 'value' from each pixel in the image or ROI. */
+	public void subtract(double value) {
+		add(-value);
+	}
+
+	/** Multiplies each pixel in the image or ROI by 'value'. */
+	public void multiply(double value) {process(MULT, value);}
+
+	/** Assigns 'value' to each pixel in the image or ROI. */
+	public void set(double value) {process(SET, value);}
+
+	/** Binary AND of each pixel in the image or ROI with 'value'. */
+	public void and(int value) {process(AND, value);}
+
+	/** Binary OR of each pixel in the image or ROI with 'value'. */
+	public void or(int value) {process(OR, value);}
+
+	/** Binary exclusive OR of each pixel in the image or ROI with 'value'. */
+	public void xor(int value) {process(XOR, value);}
+
+	/** Performs gamma correction of the image or ROI. */
+	public void gamma(double value) {process(GAMMA, value);}
+
+	/** Does a natural logarithmic (base e) transform of the image or ROI. */
+	public void log() {process(LOG, 0.0);}
+
+	/** Does a natural logarithmic (base e) transform of the image or ROI. */
+	public void ln() {log();}
+
+	/** Performs a exponential transform on the image or ROI. */
+	public void exp() {process(EXP, 0.0);}
+
+	/** Performs a square transform on the image or ROI. */
+	public void sqr() {process(SQR, 0.0);}
+
+	/** Performs a square root transform on the image or ROI. */
+	public void sqrt() {process(SQRT, 0.0);}
+
+	/** If this is a 32-bit or signed 16-bit image, performs an
+		absolute value transform, otherwise does nothing. */
+	public void abs() {}
+
+	/** Pixels less than 'value' are set to 'value'. */
+	public void min(double value) {process(MINIMUM, value);}
+
+	/** Pixels greater than 'value' are set to 'value'. */
+	public void max(double value) {process(MAXIMUM, value);}
+
+	/** Returns a copy of this image is the form of an AWT Image. */
+	public abstract Image createImage();
+
+	/** Returns this image as a BufferedImage. */
+	public BufferedImage getBufferedImage() {
+		BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+		Graphics2D g = (Graphics2D)bi.getGraphics();
+		g.drawImage(createImage(), 0, 0, null);
+		return bi;
+	}
+
+	/** Returns a new, blank processor with the specified width and height. */
+	public abstract ImageProcessor createProcessor(int width, int height);
+
+	/** Makes a copy of this image's pixel data that can be
+		later restored using reset() or reset(mask).
+		@see ImageProcessor#reset
+		@see ImageProcessor#reset(ImageProcessor)
+	*/
+	public abstract void snapshot();
+
+	/** Restores the pixel data from the snapshot (undo) buffer. */
+	public abstract void reset();
+
+	/** Swaps the pixel and snapshot (undo) buffers. */
+	public abstract void swapPixelArrays();
+
+	/** Restores pixels from the snapshot buffer that are
+		within the rectangular roi but not part of the mask. */
+	public abstract void reset(ImageProcessor mask);
+
+	/** Sets a new pixel array for the snapshot (undo) buffer. */
+	public abstract void setSnapshotPixels(Object pixels);
+
+	/** Returns a reference to the snapshot (undo) buffer, or null. */
+	public abstract Object getSnapshotPixels();
+
+	/** Convolves the image or ROI with the specified
+		3x3 integer convolution kernel. */
+	public abstract void convolve3x3(int[] kernel);
+
+	/** A 3x3 filter operation, where the argument (BLUR_MORE,  FIND_EDGES,
+	     MEDIAN_FILTER, MIN or MAX) determines the filter type. */
+	public abstract void filter(int type);
+
+	/** A 3x3 median filter. Requires 8-bit or RGB image. */
+	public abstract void medianFilter();
+
+    /** Adds pseudorandom, Gaussian ("normally") distributed values, with
+    	mean 0.0 and the specified standard deviation, to this image or ROI. */
+    public abstract void noise(double standardDeviation);
+
+	/** Returns a new processor containing an image
+		that corresponds to the current ROI. */
+	public abstract ImageProcessor crop();
+
+	/** Sets pixels less than or equal to level to 0 and all other
+		pixels to 255. Only works with 8-bit and 16-bit images. */
+	public abstract void threshold(int level);
+
+	/** Returns a duplicate of this image. */
+	public abstract ImageProcessor duplicate();
+
+	/** Scales the image by the specified factors. Does not
+		change the image size.
+		@see ImageProcessor#setInterpolate
+		@see ImageProcessor#resize
+	*/
+	public abstract void scale(double xScale, double yScale);
+
+	/** Returns a new ImageProcessor containing a scaled copy of this image or ROI.
+		@see ij.process.ImageProcessor#setInterpolate
+	*/
+	public abstract ImageProcessor resize(int dstWidth, int dstHeight);
+
+	/** Returns a new ImageProcessor containing a scaled copy
+		of this image or ROI, with the aspect ratio maintained. */
+	public ImageProcessor resize(int dstWidth) {
+		return resize(dstWidth, (int)(dstWidth*((double)roiHeight/roiWidth)));
+	}
+
+	/** Returns a new ImageProcessor containing a scaled copy of this image or ROI.
+		@param dstWidth   Image width of the resulting ImageProcessor
+		@param dstHeight  Image height of the resulting ImageProcessor
+		@param useAverging  True means that the averaging occurs to avoid
+			aliasing artifacts; the kernel shape for averaging is determined by
+			the interpolationMethod. False if subsampling without any averaging
+			should be used on downsizing.  Has no effect on upsizing.
+		@see ImageProcessor#setInterpolationMethod
+		Author: Michael Schmid
+	*/
+	public ImageProcessor resize(int dstWidth, int dstHeight, boolean useAverging) {
+		Rectangle r = getRoi();
+		int rWidth = r.width;
+		int rHeight = r.height;
+		if ((dstWidth>=rWidth && dstHeight>=rHeight) || !useAverging)
+			return resize(dstWidth, dstHeight);  //upsizing or downsizing without averaging
+		else {  //downsizing with averaging in at least one direction: convert to float
+			ImageProcessor ip2 = createProcessor(dstWidth, dstHeight);
+			FloatProcessor fp = null;
+			int channels = getNChannels();
+			boolean showStatus = getProgressIncrement(width,height)>0;
+			boolean showProgress = showStatus && channels>1;
+			if (showProgress) showProgress(0.15);
+			for (int channelNumber=0; channelNumber<channels; channelNumber++) {
+				fp = toFloat(channelNumber, fp);
+				fp.setInterpolationMethod(interpolationMethod);
+				fp.setRoi(getRoi());
+				String msg = showStatus?" ("+(channelNumber+1)+"/"+channels+")":null;
+				FloatProcessor fp2 = fp.downsize(dstWidth, dstHeight, msg);
+				ip2.setPixels(channelNumber, fp2);
+			    if (showProgress) showProgress(0.40+0.25*channelNumber);
+			}
+			if (showProgress) showProgress(1.0);
+			return ip2;
+		}
+	}
+
+	/** Use linear interpolation to resize images that have a width or height of one. */
+	protected ImageProcessor resizeLinearly(int width2, int height2) {
+		int bitDepth = getBitDepth();
+		ImageProcessor ip1 = this;
+		boolean rotate = width==1;
+		if (rotate) {
+			ip1=ip1.rotateLeft();
+			int w2 = width2;
+			width2 = height2;
+			height2 = w2;
+		}
+		ip1 = ip1.convertToFloat();
+		int width1 = ip1.getWidth();
+		int height1 = ip1.getHeight();
+		ImageProcessor ip2 = ip1.createProcessor(width2, height2);
+        double scale = (double)(width1-1)/(width2-1);
+		float[] data1 = new float[width1];
+		float[] data2 = new float[width2];
+        ip1.getRow(0, 0, data1, width1);
+		double fraction;
+		for (int x=0; x<width2; x++) {
+			int x1 = (int)(x*scale);
+			int x2 = x1+1;
+			if (x2==width1) x2=width1-1;
+			fraction = x*scale - x1;
+			//ij.IJ.log(x+" "+x1+" "+x2+" "+fraction+" "+width1+" "+width2);
+			data2[x] = (float)((1.0-fraction)*data1[x1] + fraction*data1[x2]);
+		}
+		for (int y=0; y<height2; y++)
+        	ip2.putRow(0, y, data2, width2);
+        if (bitDepth==8)
+			ip2 = ip2.convertToByte(false);
+		else if (bitDepth==16)
+			ip2 = ip2.convertToShort(false);
+		if (rotate)
+			ip2=ip2.rotateRight();
+        return ip2;
+	}
+
+	/** Returns a copy of this image that has been reduced in size using binning. */
+	public ImageProcessor bin(int shrinkFactor) {
+		return new Binner().shrink(this, shrinkFactor, shrinkFactor, 0);
+	}
+
+	/** Rotates the image or selection 'angle' degrees clockwise.
+		@see ImageProcessor#setInterpolationMethod
+		@see ImageProcessor#setBackgroundValue
+	*/
+  	public abstract void rotate(double angle);
+
+	/**  Moves the image or selection vertically or horizontally by a specified
+	      number of pixels. Positive x values move the image or selection to the
+	      right, negative values move it to the left. Positive y values move the
+	      image or selection down, negative values move it up.
+	*/
+  	public void translate(double xOffset, double yOffset) {
+  		ImageProcessor ip2 = this.duplicate();
+  		ip2.setBackgroundValue(0.0);
+		boolean integerOffsets = xOffset==(int)xOffset && yOffset==(int)yOffset;
+  		if (integerOffsets || interpolationMethod==NONE) {
+			for (int y=roiY; y<(roiY + roiHeight); y++) {
+				for (int x=roiX; x<(roiX + roiWidth); x++)
+					putPixel(x, y, ip2.getPixel(x-(int)xOffset, y-(int)yOffset));
+			}
+		} else {
+			if (interpolationMethod==BICUBIC && (this instanceof ColorProcessor))
+				((ColorProcessor)this).filterRGB(ColorProcessor.RGB_TRANSLATE, xOffset, yOffset);
+			else {
+				for (int y=roiY; y<(roiY + roiHeight); y++) {
+					for (int x=roiX; x<(roiX + roiWidth); x++)
+						putPixel(x, y, ip2.getPixelInterpolated(x-xOffset, y-yOffset));
+				}
+			}
+		}
+  	}
+
+	/**
+	* @deprecated
+	* replaced by translate(x,y)
+	*/
+  	public void translate(int xOffset, int yOffset, boolean eraseBackground) {
+		translate(xOffset, yOffset);
+  	}
+
+	/** Returns the histogram of the image or ROI. Returns
+		a luminosity histogram for RGB images and null
+		for float images.
+		<p>
+		For 8-bit and 16-bit images, returns an array with one entry for each possible
+		value that a pixel can have, from 0 to 255 (8-bit image) or 0-65535 (16-bit image).
+		Thus, the array size is 256 or 65536, and the bin width in uncalibrated units is 1.
+		<p>
+		For RGB images, the brightness is evaluated using the color weights (which would result in a
+		float value) and rounded to an int. This gives 256 bins. FloatProcessor.getHistogram is not
+		implemented (returns null).
+	*/
+	public abstract int[] getHistogram();
+
+	/** Returns the histogram of the image or ROI, using the specified number of bins. */
+	public int[] getHistogram(int nBins) {
+		ImageProcessor ip;
+		if (((this instanceof ByteProcessor)||(this instanceof ColorProcessor)) && nBins!=256)
+			ip = convertToShort(false);
+		else
+			ip = this;
+		ip.setHistogramSize(nBins);
+		ip.setHistogramRange(0.0, 0.0);
+		ImageStatistics stats = ImageStatistics.getStatistics(ip);
+		ip.setHistogramSize(256);
+		return stats.histogram;
+	}
+
+	/** Erodes the image or ROI using a 3x3 maximum filter. Requires 8-bit or RGB image. */
+	public abstract void erode();
+
+	/** Dilates the image or ROI using a 3x3 minimum filter. Requires 8-bit or RGB image. */
+	public abstract void dilate();
+
+	/** For 16 and 32 bit processors, set 'lutAnimation' true
+		to have createImage() use the cached 8-bit version
+		of the image. */
+	public void setLutAnimation(boolean lutAnimation) {
+		this.lutAnimation = lutAnimation;
+	}
+
+	void resetPixels(Object pixels) {
+		if (pixels==null) {
+			if (img!=null) {
+				img.flush();
+				img = null;
+			}
+		}
+	}
+
+	/** Returns an 8-bit version of this image as a ByteProcessor. */
+	public ImageProcessor convertToByte(boolean doScaling) {
+		TypeConverter tc = new TypeConverter(this, doScaling);
+		return tc.convertToByte();
+	}
+
+	/** Returns a 16-bit version of this image as a ShortProcessor. */
+	public ImageProcessor convertToShort(boolean doScaling) {
+		TypeConverter tc = new TypeConverter(this, doScaling);
+		return tc.convertToShort();
+	}
+
+	/** Returns a 32-bit float version of this image as a FloatProcessor.
+		For byte and short images, converts using a calibration function
+		if a calibration table has been set using setCalibrationTable(). */
+	public ImageProcessor convertToFloat() {
+		TypeConverter tc = new TypeConverter(this, false);
+		return tc.convertToFloat(cTable);
+	}
+
+	/** Returns an RGB version of this image as a ColorProcessor. */
+	public ImageProcessor convertToRGB() {
+		TypeConverter tc = new TypeConverter(this, true);
+		return tc.convertToRGB();
+	}
+
+	/** Returns an 8-bit version of this image as a ByteProcessor. 16-bit and 32-bit
+	 * pixel data are scaled from min-max to 0-255.
+	*/
+	public ByteProcessor convertToByteProcessor() {
+		return convertToByteProcessor(true);
+	}
+
+	/** Returns an 8-bit version of this image as a ByteProcessor. 16-bit and 32-bit
+	 * pixel data are scaled from min-max to 0-255 if 'scale' is true.
+	*/
+	public ByteProcessor convertToByteProcessor(boolean scale) {
+		ByteProcessor bp;
+		if (this instanceof ByteProcessor)
+			bp = (ByteProcessor)this.duplicate();
+		else
+			bp = (ByteProcessor)this.convertToByte(scale);
+		return bp;
+	}
+
+	/** Returns a 16-bit version of this image as a ShortProcessor. 32-bit
+	 * pixel data are scaled from min-max to 0-255.
+	*/
+	public ShortProcessor convertToShortProcessor() {
+		return convertToShortProcessor(true);
+	}
+
+	/** Returns a 16-bit version of this image as a ShortProcessor. 32-bit
+	 * pixel data are scaled from min-max to 0-255 if 'scale' is true.
+	*/
+	public ShortProcessor convertToShortProcessor(boolean scale) {
+		ShortProcessor sp;
+		if (this instanceof ShortProcessor)
+			sp = (ShortProcessor)this.duplicate();
+		else
+			sp = (ShortProcessor)this.convertToShort(scale);
+		return sp;
+	}
+
+	/** Returns a 32-bit float version of this image as a FloatProcessor.
+		For byte and short images, converts using a calibration function
+		if a calibration table has been set using setCalibrationTable(). */
+	public FloatProcessor convertToFloatProcessor() {
+		FloatProcessor fp;
+		if (this instanceof FloatProcessor)
+			fp = (FloatProcessor)this.duplicate();
+		else
+			fp = (FloatProcessor)this.convertToFloat();
+		return fp;
+	}
+
+	/** Returns an RGB version of this image as a ColorProcessor. */
+	public ColorProcessor convertToColorProcessor() {
+		ColorProcessor cp;
+		if (this instanceof ColorProcessor)
+			cp = (ColorProcessor)this.duplicate();
+		else
+			cp = (ColorProcessor)this.convertToRGB();
+		return cp;
+	}
+
+	/** Performs a convolution operation using the specified kernel.
+	KernelWidth and kernelHeight must be odd. */
+	public abstract void convolve(float[] kernel, int kernelWidth, int kernelHeight);
+
+	/** Converts the image to binary using an automatically determined threshold.
+		For byte and short images, converts to binary using an automatically determined
+		threshold. For RGB images, converts each channel to binary. For
+		float images, does nothing.
+	*/
+	public void autoThreshold() {
+		threshold(getAutoThreshold());
+	}
+
+	/** Returns a pixel value (threshold) that can be used to divide the image into objects
+		and background. It does this by taking a test threshold and computing the average
+		of the pixels at or below the threshold and pixels above. It then computes the average
+		of those two, increments the threshold, and repeats the process. Incrementing stops
+		when the threshold is larger than the composite average. That is, threshold = (average
+		background + average objects)/2. This description was posted to the ImageJ mailing
+		list by Jordan Bevic. */
+	public int getAutoThreshold() {
+		return getAutoThreshold(getHistogram());
+	}
+
+	/**	This is a version of getAutoThreshold() that uses a histogram passed as an argument. */
+	public int getAutoThreshold(int[] histogram) {
+		int level;
+		int maxValue = histogram.length - 1;
+		double result, sum1, sum2, sum3, sum4;
+
+		int count0 = histogram[0];
+		histogram[0] = 0; //set to zero so erased areas aren't included
+		int countMax = histogram[maxValue];
+		histogram[maxValue] = 0;
+		int min = 0;
+		while ((histogram[min]==0) && (min<maxValue))
+			min++;
+		int max = maxValue;
+		while ((histogram[max]==0) && (max>0))
+			max--;
+		if (min>=max) {
+			histogram[0]= count0; histogram[maxValue]=countMax;
+			level = histogram.length/2;
+			return level;
+		}
+
+		int movingIndex = min;
+		int inc = Math.max(max/40, 1);
+		do {
+			sum1=sum2=sum3=sum4=0.0;
+			for (int i=min; i<=movingIndex; i++) {
+				sum1 += (double)i*histogram[i];
+				sum2 += histogram[i];
+			}
+			for (int i=(movingIndex+1); i<=max; i++) {
+				sum3 += (double)i*histogram[i];
+				sum4 += histogram[i];
+			}
+			result = (sum1/sum2 + sum3/sum4)/2.0;
+			movingIndex++;
+		} while ((movingIndex+1)<=result && movingIndex<max-1);
+
+		histogram[0]= count0; histogram[maxValue]=countMax;
+		level = (int)Math.round(result);
+		return level;
+	}
+
+	/** Updates the clipping rectangle used by lineTo(), drawLine(), drawDot() and drawPixel().
+		The clipping rectangle is reset by passing a null argument or by calling resetRoi(). */
+	public void setClipRect(Rectangle clipRect) {
+		if (clipRect==null) {
+			clipXMin = 0;
+			clipXMax = width-1;
+			clipYMin = 0;
+			clipYMax = height-1;
+		} else {
+			clipXMin = clipRect.x;
+			clipXMax = clipRect.x + clipRect.width - 1;
+			clipYMin = clipRect.y;
+			clipYMax = clipRect.y + clipRect.height - 1;
+			if (clipXMin<0) clipXMin = 0;
+			if (clipXMax>=width) clipXMax = width-1;
+			if (clipYMin<0) clipYMin = 0;
+			if (clipYMax>=height) clipYMax = height-1;
+		}
+	}
+
+	protected String maskSizeError(ImageProcessor mask) {
+		return "Mask size ("+mask.getWidth()+"x"+mask.getHeight()+") != ROI size ("+
+			roiWidth+"x"+roiHeight+")";
+	}
+
+	protected SampleModel getIndexSampleModel() {
+		if (sampleModel==null) {
+			IndexColorModel icm = getDefaultColorModel();
+			WritableRaster wr = icm.createCompatibleWritableRaster(1, 1);
+			sampleModel = wr.getSampleModel();
+			sampleModel = sampleModel.createCompatibleSampleModel(width, height);
+		}
+		return sampleModel;
+	}
+
+	/** Returns the default grayscale IndexColorModel. */
+	public IndexColorModel getDefaultColorModel() {
+		if (defaultColorModel==null) {
+			byte[] r = new byte[256];
+			byte[] g = new byte[256];
+			byte[] b = new byte[256];
+			for(int i=0; i<256; i++) {
+				r[i]=(byte)i;
+				g[i]=(byte)i;
+				b[i]=(byte)i;
+			}
+			defaultColorModel = new IndexColorModel(8, 256, r, g, b);
+		}
+		return defaultColorModel;
+	}
+
+	/**	The getPixelsCopy() method returns a reference to the
+		snapshot buffer if it is not null and 'snapshotCopyMode' is true.
+		@see ImageProcessor#getPixelsCopy
+		@see ImageProcessor#snapshot
+	*/
+	public void setSnapshotCopyMode(boolean b) {
+		snapshotCopyMode = b;
+	}
+
+	/** Returns the number of color channels in the image. The color channels can be
+	*  accessed by toFloat(channelNumber, fp) and written by setPixels(channelNumber, fp).
+	* @return 1 for grayscale images, 3 for RGB images
+	*/
+	public int getNChannels() {
+		return 1;   /* superseded by ColorProcessor */
+	}
+
+	/** Returns a FloatProcessor with the image or one color channel thereof.
+	*  The roi and mask are also set for the FloatProcessor.
+	*  @param channelNumber   Determines the color channel, 0=red, 1=green, 2=blue. Ignored for
+	*                         grayscale images.
+	*  @param fp     Here a FloatProcessor can be supplied, or null. The FloatProcessor
+	*                         is overwritten when converting data (re-using its pixels array
+	*                         improves performance).
+	*  @return A FloatProcessor with the converted image data of the color channel selected
+	*/
+	public abstract FloatProcessor toFloat(int channelNumber, FloatProcessor fp);
+
+	/** Sets the pixels (of one color channel for RGB images) from a FloatProcessor.
+	*  @param channelNumber   Determines the color channel, 0=red, 1=green, 2=blue.Ignored for
+	*                         grayscale images.
+	*  @param fp              The FloatProcessor where the image data are read from.
+	*/
+	public abstract void setPixels(int channelNumber, FloatProcessor fp);
+
+	/** Returns the minimum possible pixel value. */
+	public double minValue() {
+		return 0.0;
+	}
+
+	/** Returns the maximum possible pixel value. */
+	public double maxValue() {
+		return 255.0;
+	}
+
+	/** CompositeImage calls this method to generate an updated color image. */
+	public void updateComposite(int[] rgbPixels, int channel) {
+		int redValue, greenValue, blueValue;
+		int size = width*height;
+		if (bytes==null || !lutAnimation)
+			bytes = create8BitImage();
+		if (cm==null)
+			makeDefaultColorModel();
+		if (reds==null || cm!=cm2)
+			updateLutBytes();
+		switch (channel) {
+			case 1: // update red channel
+				for (int i=0; i<size; i++)
+					rgbPixels[i] = (rgbPixels[i]&0xff00ffff) | reds[bytes[i]&0xff];
+				break;
+			case 2: // update green channel
+				for (int i=0; i<size; i++)
+					rgbPixels[i] = (rgbPixels[i]&0xffff00ff) | greens[bytes[i]&0xff];
+				break;
+			case 3: // update blue channel
+				for (int i=0; i<size; i++)
+					rgbPixels[i] = (rgbPixels[i]&0xffffff00) | blues[bytes[i]&0xff];
+				break;
+			case 4: // get first channel
+				for (int i=0; i<size; i++) {
+					redValue = reds[bytes[i]&0xff];
+					greenValue = greens[bytes[i]&0xff];
+					blueValue = blues[bytes[i]&0xff];
+					rgbPixels[i] = redValue | greenValue | blueValue;
+				}
+				break;
+			case 5: // merge next channel
+				int pixel;
+				for (int i=0; i<size; i++) {
+					pixel = rgbPixels[i];
+					redValue = (pixel&0x00ff0000) + reds[bytes[i]&0xff];
+					greenValue = (pixel&0x0000ff00) + greens[bytes[i]&0xff];
+					blueValue = (pixel&0x000000ff) + blues[bytes[i]&0xff];
+					if (redValue>16711680) redValue = 16711680;
+					if (greenValue>65280) greenValue = 65280;
+					if (blueValue>255) blueValue = 255;
+					rgbPixels[i] = redValue | greenValue | blueValue;
+				}
+				break;
+		}
+		lutAnimation = false;
+	}
+
+	// method and variables used by updateComposite()
+	byte[]  create8BitImage() {return null;}
+	private byte[] bytes;
+	private int[] reds, greens, blues;
+
+	void updateLutBytes() {
+		IndexColorModel icm = (IndexColorModel)cm;
+		int mapSize = icm.getMapSize();
+		if (reds==null || reds.length!=mapSize) {
+			reds = new int[mapSize];
+			greens = new int[mapSize];
+			blues = new int[mapSize];
+		}
+		byte[] tmp = new byte[mapSize];
+		icm.getReds(tmp);
+		for (int i=0; i<mapSize; i++) reds[i] = (tmp[i]&0xff)<<16;
+		icm.getGreens(tmp);
+		for (int i=0; i<mapSize; i++) greens[i] = (tmp[i]&0xff)<<8;
+		icm.getBlues(tmp);
+		for (int i=0; i<mapSize; i++) blues[i] = tmp[i]&0xff;
+		cm2 = cm;
+	}
+
+	/** Sets the upper Over/Under threshold color. Can be called from a macro,
+		e.g., call("ij.process.ImageProcessor.setOverColor", 0,255,255). */
+	public static void setOverColor(int red, int green, int blue) {
+		overRed=red; overGreen=green; overBlue=blue;
+	}
+
+	/** Set the lower Over/Under thresholding color. */
+	public static void setUnderColor(int red, int green, int blue) {
+		underRed=red; underGreen=green; underBlue=blue;
+	}
+
+	/** Returns 'true' if this is a binary image (8-bit-image with only 0 and 255). */
+	public boolean isBinary() {
+		return false;
+	}
+
+	/** Returns 'true' if this is a signed 16-bit image. */
+	public boolean isSigned16Bit() {
+		return false;
+	}
+
+	/* This method is experimental and may be removed. */
+	public static void setUseBicubic(boolean b) {
+		useBicubic = b;
+	}
+
+	/** Calculates and returns uncalibrated statistics for this image or ROI,
+	 * including histogram, area, mean, min and max, standard deviation,
+	 * and mode. Use the setRoi(Roi) method to limit statistics to
+	 * a non-rectangular area.
+	 * @return an {@link ij.process.ImageStatistics} object
+	 * @see #setRoi(Roi)
+	 * @see #getStatistics
+	 * @see ij.ImagePlus#getStatistics
+	*/
+	public ImageStatistics getStats() {
+		return ImageStatistics.getStatistics(this);
+	}
+
+	/** Calculates and returns complete uncalibrated (raw)
+	 * statistics for this image or ROI but it is up to 70 times
+	 * slower than getStats(). Use the setRoi(Roi) method to
+	 * limit statistics to a non-rectangular area.
+	 * @return an {@link ij.process.ImageStatistics} object
+	 * @see #setRoi(Roi)
+	 * @see #getStats
+	 * @see ij.ImagePlus#getAllStatistics
+	*/
+	public ImageStatistics getStatistics() {
+		return ImageStatistics.getStatistics(this, Measurements.ALL_STATS, null);
+	}
+
+	/** Blurs the image by convolving with a Gaussian function. */
+	public void blurGaussian(double sigma) {
+		resetRoi();
+		GaussianBlur gb = new GaussianBlur();
+		gb.showProgress(false);
+        gb.blurGaussian(this, sigma);
+	}
+
+	/** Uses the Process/Math/Macro command to apply macro code to this image. */
+	public void applyMacro(String macro) {
+		ij.plugin.filter.ImageMath.applyMacro(this, macro, false);
+	}
+
+	/* Returns the PlugInFilter slice number. */
+	public int getSliceNumber() {
+		if (sliceNumber<1)
+			return 1;
+		else
+			return sliceNumber;
+	}
+
+	/** PlugInFilterRunner uses this method to set the slice number. */
+	public void setSliceNumber(int slice) {
+		sliceNumber = slice;
+	}
+
+	/** Returns a shallow copy of this ImageProcessor, where this
+	* image and the copy share pixel data. Use the duplicate() method
+	* to create a copy that does not share the pixel data.
+	* @see ImageProcessor#duplicate
+	*/
+	public Object clone() {
+		try {
+			return super.clone();
+		} catch (CloneNotSupportedException e) {
+			return null;
+		}
+	}
+
+	/** This method is used to display virtual stack overlays. */
+	public void setOverlay(Overlay overlay) {
+		this.overlay = overlay;
+	}
+
+	public Overlay getOverlay() {
+		return overlay;
+	}
+
+	protected int getProgressIncrement(int w, int h) {
+		if (progressBar==null)
+			return 0;
+		int inc = 0;
+		int threshold = 15000000;
+		if (interpolationMethod==BICUBIC)
+			threshold = 5000000;
+		boolean isBig = w*h>threshold;
+		if (isBig) {
+			inc = h/30;
+			if (inc<1) inc=1;
+		}
+		return inc;
+	}
+
+	public static void setRandomSeed(double randomSeed) {
+		seed = randomSeed;
+	}
+
+	/** Returns a binary mask, or null if a threshold is not set or this is an RGB image.
+	 * @see ij.ImagePlus#createThresholdMask
+	 * @see ij.ImagePlus#createRoiMask
+	*/
+	public ByteProcessor createMask() {
+		return null;
+	}
+
+	protected IndexColorModel getThresholdColorModel() {
+		byte[] r = new byte[256];
+		byte[] g = new byte[256];
+		byte[] b = new byte[256];
+		for(int i=0; i<255; i++) {
+			r[i]=(byte)i;
+			g[i]=(byte)i;
+			b[i]=(byte)i;
+		}
+		r[255] = (byte)255;
+		g[255] = (byte)0;
+		b[255] = (byte)0;
+		return new IndexColorModel(8, 256, r, g, b);
+	}
+	
+}
diff --git a/src/ij/process/ImageStatistics.java b/src/ij/process/ImageStatistics.java
new file mode 100644
index 0000000..d03db2d
--- /dev/null
+++ b/src/ij/process/ImageStatistics.java
@@ -0,0 +1,329 @@
+package ij.process;
+import ij.measure.*;
+import java.awt.*;
+
+/** Statistics, including the histogram, of an image or selection. */
+public class ImageStatistics implements Measurements {
+
+	/** Use the hIstogram() method to get the histogram as a double  array. */
+	public int[] histogram;
+	
+	/** Int pixel count (limited to 2^31-1) */
+	public int pixelCount;
+	/** Long pixel count */
+	public long longPixelCount;	
+	
+	/** Mode */
+	public double dmode;
+	/** Mode of 256 bin histogram (counts limited to 2^31-1) */	
+	public int mode;
+		
+	public double area;
+	public double min;
+	public double max;
+	public double mean;
+	public double median;
+	public double stdDev;
+	public double skewness;
+	public double kurtosis;
+	public double xCentroid;
+	public double yCentroid;
+	public double xCenterOfMass;
+	public double yCenterOfMass;
+	public double roiX, roiY, roiWidth, roiHeight;
+	/** Uncalibrated mean */
+	public double umean;
+	/** Length of major axis of fitted ellipse */
+	public double major;
+	/** Length of minor axis of fitted ellipse */
+	public double minor;
+	/** Angle in degrees of fitted ellipse */
+	public double angle;
+	/** Bin width 1 histogram of 16-bit images */
+	public int[] histogram16;
+	/** Long histogram; use getHIstogram() to retrieve. */
+	protected long[] longHistogram;
+	public double areaFraction;
+	/** Used internally by AnalyzeParticles */
+	public int xstart, ystart;
+	/** Used by HistogramWindow */
+	public boolean stackStatistics;
+	/** Minimum threshold when "Limit to threshold" enabled */
+	public double lowerThreshold = Double.NaN;	
+	/** Maximum threshold when "Limit to threshold" enabled */
+	public double upperThreshold = Double.NaN;	
+	public double histMin;
+	public double histMax;
+	public int histYMax;
+	public int maxCount;
+	public int nBins = 256;
+	public double binSize = 1.0;
+	
+	protected int width, height;
+	protected int rx, ry, rw, rh;
+	protected double pw, ph;
+	protected Calibration cal;
+	
+	EllipseFitter ef;
+
+	
+	/** Calculates and returns uncalibrated (raw) statistics for the
+	 * specified image, including histogram, area, mean, min and
+	 * max, standard deviation and mode.  Use ImageProcessor.setRoi(x,y,width,height)
+	 * to limit statistics to a rectangular area and ImageProcessor.setRoi(Roi)
+	 * to limit to a non-rectangular area.
+	 * @see ij.process.ImageProcessor#setRoi(int,int,int,int)
+	 * @see ij.process.ImageProcessor#setRoi(Roi)
+	 * @see ij.process.ImageProcessor#getStats
+	*/
+	public static ImageStatistics getStatistics(ImageProcessor ip) {
+		return getStatistics(ip, AREA+MEAN+STD_DEV+MODE+MIN_MAX+RECT, null);
+	}
+
+	/** Calculates and returns statistics for the specified
+	 * image using the specified measurent options
+	 * and calibration. Use ImageProcessor.setRoi(x,y,width,height)
+	 * to limit statistics to a rectangular area and ImageProcessor.setRoi(Roi)
+	 * to limit to a non-rectangular area.
+	 * @see ij.process.ImageProcessor#setRoi(int,int,int,int)
+	 * @see ij.process.ImageProcessor#setRoi(Roi)
+	 * @see ij.measure.Measurements
+	*/
+	public static ImageStatistics getStatistics(ImageProcessor ip, int mOptions, Calibration cal) {
+		Object pixels = ip.getPixels();
+		if (pixels instanceof byte[])
+			return new ByteStatistics(ip, mOptions, cal);
+		else if (pixels instanceof short[])
+			return new ShortStatistics(ip, mOptions, cal);
+		else if (pixels instanceof int[])
+			return new ColorStatistics(ip, mOptions, cal);
+		else if (pixels instanceof float[])
+			return new FloatStatistics(ip, mOptions, cal);
+		else
+			throw new IllegalArgumentException("Pixels are not byte, short, int or float");
+	}
+
+	void getRawMinAndMax(int minThreshold, int maxThreshold) {
+		int min = minThreshold;
+		while ((histogram[min] == 0) && (min < 255))
+			min++;
+		this.min = min;
+		int max = maxThreshold;
+		while ((histogram[max] == 0) && (max > 0))
+			max--;
+		this.max = max;
+	}
+
+	void getRawStatistics(int minThreshold, int maxThreshold) {
+		int count;
+		double value;
+		double sum = 0.0;
+		double sum2 = 0.0;
+		
+		for (int i=minThreshold; i<=maxThreshold; i++) {
+			count = histogram[i];
+			longPixelCount += count;
+			sum += (double)i*count;
+			value = i;
+			sum2 += (value*value)*count;
+			if (count>maxCount) {
+				maxCount = count;
+				mode = i;
+			}
+		}
+		pixelCount = (int)longPixelCount;
+		area = longPixelCount*pw*ph;
+		mean = sum/longPixelCount;
+		umean = mean;
+		dmode = mode;
+		calculateStdDev(longPixelCount, sum, sum2);
+		histMin = 0.0;
+		histMax = 255.0;
+	}
+	
+	void calculateStdDev(double n, double sum, double sum2) {
+		if (n>0.0) {
+			stdDev = (n*sum2-sum*sum)/n;
+			if (stdDev>0.0)
+				stdDev = Math.sqrt(stdDev/(n-1.0));
+			else
+				stdDev = 0.0;
+		} else
+			stdDev = 0.0;
+	}
+		
+	void setup(ImageProcessor ip, Calibration cal) {
+		width = ip.getWidth();
+		height = ip.getHeight();
+		this.cal = cal;
+		Rectangle roi = ip.getRoi();
+		if (roi != null) {
+			rx = roi.x;
+			ry = roi.y;
+			rw = roi.width;
+			rh = roi.height;
+		}
+		else {
+			rx = 0;
+			ry = 0;
+			rw = width;
+			rh = height;
+		}
+		
+		if (cal!=null) {
+			pw = cal.pixelWidth;
+			ph = cal.pixelHeight;
+		} else {
+			pw = 1.0;
+			ph = 1.0;
+		}
+		
+		roiX = cal!=null?cal.getX(rx):rx;
+		roiY = cal!=null?cal.getY(ry, height):ry;
+		roiWidth = rw*pw;
+		roiHeight = rh*ph;
+	}
+	
+	void getCentroid(ImageProcessor ip) {
+		byte[] mask = ip.getMaskArray();
+		int count=0, mi;
+		double xsum=0.0, ysum=0.0;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null||mask[mi++]!=0) {
+					count++;
+					xsum += x;
+					ysum += y;
+				}
+			}
+		}
+		xCentroid = xsum/count+0.5;
+		yCentroid = ysum/count+0.5;
+		if (cal!=null) {
+			xCentroid = cal.getX(xCentroid);
+			yCentroid = cal.getY(yCentroid, height);
+		}
+	}
+	
+	void fitEllipse(ImageProcessor ip, int mOptions) {
+		ImageProcessor originalMask = null;
+		boolean limitToThreshold = (mOptions&LIMIT)!=0 && ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD;
+		if (limitToThreshold) {
+			ImageProcessor mask = ip.getMask();
+			Rectangle r = ip.getRoi();
+			if (mask==null) {
+				mask = new ByteProcessor(r.width, r.height);
+				mask.invert();
+			} else {
+				originalMask = mask;
+				mask = mask.duplicate();
+			}
+			int n = r.width*r.height;
+			double t1 = ip.getMinThreshold();
+			double t2 = ip.getMaxThreshold();
+			double value;
+			for (int y=0; y<r.height; y++) {
+				for (int x=0; x<r.width; x++) {
+					value = ip.getf(r.x+x, r.y+y);
+					if (value<t1 || value>t2)
+						mask.setf(x, y, 0f);
+				}
+			}
+			ip.setMask(mask);
+		}
+		if (ef==null)
+			ef = new EllipseFitter();
+		ef.fit(ip, this);
+		if (limitToThreshold) {
+			if (originalMask==null)
+				ip.setMask(null);
+			else
+				ip.setMask(originalMask);
+		}
+		double psize = (Math.abs(pw-ph)/pw)<.01?pw:0.0;
+		major = ef.major*psize;
+		minor = ef.minor*psize;
+		angle = ef.angle;
+		xCentroid = ef.xCenter;
+		yCentroid = ef.yCenter;
+		if (cal!=null) {
+			xCentroid = cal.getX(xCentroid);
+			yCentroid = cal.getY(yCentroid, height);
+		}
+	}
+	
+	public void drawEllipse(ImageProcessor ip) {
+		if (ef!=null)
+			ef.drawEllipse(ip);
+	}
+	
+	void calculateMedian(int[] hist, int first, int last, Calibration cal) {
+		//ij.IJ.log("calculateMedian: "+first+"  "+last+"  "+hist.length+"  "+pixelCount);
+		if (pixelCount==0 || first<0 || last>hist.length) {
+			median = Double.NaN;
+			return;
+		}
+		double sum = 0;
+		int i = first-1;
+		double halfCount = pixelCount/2.0;
+		do {
+			sum += hist[++i];
+		} while (sum<=halfCount && i<last);
+		median = cal!=null?cal.getCValue(i):i;
+	}
+	
+	void calculateAreaFraction(ImageProcessor ip, int[] hist) {
+		int sum = 0;
+		int total = 0;
+		int t1 = (int)Math.round(ip.getMinThreshold());
+		int t2 = (int)Math.round(ip.getMaxThreshold());
+		if (t1==ImageProcessor.NO_THRESHOLD) {
+			for (int i=0; i<hist.length; i++)
+				total += hist[i];
+			sum = total - hist[0];
+		} else {
+			for (int i=0; i<hist.length; i++) {
+				if (i>=t1 && i<=t2)
+					sum += hist[i];
+				total += hist[i];
+			}
+		}
+		areaFraction = sum*100.0/total;
+	}
+	
+	/** Returns the histogram as an array of doubles. */
+	public double[] histogram() {
+		double[] hist = new double[histogram.length];
+		for (int i=0; i<hist.length; i++) {
+			if (longHistogram!=null)
+				hist[i] = longHistogram[i];
+			else
+				hist[i] = histogram[i];
+		}
+		return hist;
+	}
+
+	/** Returns the histogram as an array of longs. */
+	public long[] getHistogram() {
+		double[] hist = histogram();
+		long[] hist2 = new long[hist.length];
+		for (int i=0; i<hist.length; i++)
+			hist2[i] = (long)hist[i];
+		return hist2;
+	}
+	
+	public String toString() {
+		return "stats[count="+pixelCount+", mean="+mean+", min="+min+", max="+max+"]";
+	}
+	
+	protected void saveThreshold(double minThreshold, double maxThreshold, Calibration cal) {
+		if (cal!=null) {
+			minThreshold = cal.getCValue(minThreshold);
+			maxThreshold = cal.getCValue(maxThreshold);
+		}
+		lowerThreshold = minThreshold;
+		upperThreshold = maxThreshold;
+	}
+
+}
diff --git a/src/ij/process/IntProcessor.java b/src/ij/process/IntProcessor.java
new file mode 100644
index 0000000..2dcea18
--- /dev/null
+++ b/src/ij/process/IntProcessor.java
@@ -0,0 +1,165 @@
+package ij.process;
+
+import java.util.*;
+import java.awt.*;
+import java.awt.image.*;
+
+
+/** This is an extended ColorProcessor that supports signed 32-bit int images. */
+public class IntProcessor extends ColorProcessor {
+	private byte[] pixels8;
+
+	/**Creates a blank IntProcessor with the specified dimensions. */
+	public IntProcessor(int width, int height) {
+		this(width, height, new int[width*height]);
+	}
+
+	/**Creates an IntProcessor from a pixel array. */
+	public IntProcessor(int width, int height, int[] pixels) {
+		super(width, height, pixels);
+		makeDefaultColorModel();
+	}
+
+	/** Create an 8-bit AWT image by scaling pixels in the range min-max to 0-255. */
+	@Override
+	public Image createImage() {
+		if (!minMaxSet)
+			findMinAndMax();
+		boolean firstTime = pixels8==null;
+		boolean thresholding = minThreshold!=NO_THRESHOLD && lutUpdateMode<NO_LUT_UPDATE;
+		//ij.IJ.log("createImage: "+firstTime+"  "+lutAnimation+"  "+thresholding);
+		if (firstTime || !lutAnimation)
+			create8BitImage(thresholding&&lutUpdateMode==RED_LUT);
+		if (cm==null)
+			makeDefaultColorModel();
+		if (thresholding) {
+			int t1 = (int)minThreshold;
+			int t2 = (int)maxThreshold;
+			int size = width*height;
+			int value;
+			if (lutUpdateMode==BLACK_AND_WHITE_LUT) {
+				for (int i=0; i<size; i++) {
+					value = (pixels[i]&0xffff);
+					if (value>=t1 && value<=t2)
+						pixels8[i] = (byte)255;
+					else
+						pixels8[i] = (byte)0;
+				}
+			} else { // threshold red
+				for (int i=0; i<size; i++) {
+					value = (pixels[i]&0xffff);
+					if (value>=t1 && value<=t2)
+						pixels8[i] = (byte)255;
+				}
+			}
+		}
+		return createBufferedImage();
+	}
+	
+	// creates 8-bit image by linearly scaling from float to 8-bits
+	private byte[] create8BitImage(boolean thresholding) {
+		int size = width*height;
+		if (pixels8==null)
+			pixels8 = new byte[size];
+		double value;
+		int ivalue;
+		double min2 = getMin();
+		double max2 = getMax();
+		double scale = 255.0/(max2-min2);
+		int maxValue = thresholding?254:255;
+		for (int i=0; i<size; i++) {
+			value = pixels[i]-min2;
+			if (value<0.0) value=0.0;
+			ivalue = (int)(value*scale+0.5);
+			if (ivalue>maxValue) ivalue = maxValue;
+			pixels8[i] = (byte)ivalue;
+		}
+		return pixels8;
+	}
+
+	@Override
+	byte[] create8BitImage() {
+		return create8BitImage(false);
+	}
+
+	Image createBufferedImage() {
+		if (raster==null) {
+			SampleModel sm = getIndexSampleModel();
+			DataBuffer db = new DataBufferByte(pixels8, width*height, 0);
+			raster = Raster.createWritableRaster(sm, db, null);
+		}
+		if (image==null || cm!=cm2) {
+			if (cm==null) cm = getDefaultColorModel();
+			image = new BufferedImage(cm, raster, false, null);
+			cm2 = cm;
+		}
+		lutAnimation = false;
+		return image;
+	}
+
+	/** Returns this image as an 8-bit BufferedImage . */
+	public BufferedImage getBufferedImage() {
+		return convertToByte(true).getBufferedImage();
+	}
+	
+	@Override
+	public void setColorModel(ColorModel cm) {
+		if (cm!=null && !(cm instanceof IndexColorModel))
+			throw new IllegalArgumentException("IndexColorModel required");
+		if (cm!=null && cm instanceof LUT)
+			cm = ((LUT)cm).getColorModel();
+		this.cm = cm;
+		baseCM = null;
+		rLUT1 = rLUT2 = null;
+		inversionTested = false;
+		minThreshold = NO_THRESHOLD;
+	}
+	
+	@Override
+	public float getPixelValue(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			return (float)pixels[y*width+x];
+		else 
+			return Float.NaN;
+	}
+
+	/** Returns the number of channels (1). */
+	@Override
+	public int getNChannels() {
+		return 1;
+	}
+	
+	public void findMinAndMax() {
+		int size = width*height;
+		int value;
+		int min = pixels[0];
+		int max = pixels[0];
+		for (int i=1; i<size; i++) {
+			value = pixels[i];
+			if (value<min)
+				min = value;
+			else if (value>max)
+				max = value;
+		}
+		this.min = min;
+		this.max = max;
+		minMaxSet = true;
+	}
+
+	@Override
+	public void resetMinAndMax() {
+		findMinAndMax();
+		resetThreshold();
+	}
+	
+	@Override
+	public void setMinAndMax(double minimum, double maximum, int channels) {
+		min = (int)minimum;
+		max = (int)maximum;
+		minMaxSet = true;
+		resetThreshold();
+	}
+
+}
+
+
diff --git a/src/ij/process/LUT.java b/src/ij/process/LUT.java
new file mode 100644
index 0000000..179aa5f
--- /dev/null
+++ b/src/ij/process/LUT.java
@@ -0,0 +1,111 @@
+package ij.process;
+import ij.IJ;
+import ij.plugin.Colors;
+import java.awt.image.*;
+import java.awt.Color;
+
+	/** This is an indexed color model that allows an
+		lower and upper bound to be specified. */
+    public class LUT extends IndexColorModel implements Cloneable {
+		public static final String nameKey = "CurrentLUT";
+		public double min, max;
+		private IndexColorModel cm;
+	
+    /** Constructs a LUT from red, green and blue byte arrays, which must have a length of 256. */
+    public LUT(byte r[], byte g[], byte b[]) {
+    	this(8, 256, r, g, b);
+	}
+	
+    /** Constructs a LUT from red, green and blue byte arrays, where 'bits' 
+    	must be 8 and 'size' must be less than or equal to 256. */
+    public LUT(int bits, int size, byte r[], byte g[], byte b[]) {
+    	super(bits, size, r, g, b);
+	}
+	
+	public LUT(IndexColorModel cm, double min, double max) {
+		super(8, cm.getMapSize(), getReds(cm), getGreens(cm), getBlues(cm));
+		this.min = min;
+		this.max = max;
+	}
+	
+	static byte[] getReds(IndexColorModel cm) {
+		byte[] reds=new byte[256]; cm.getReds(reds); return reds;
+	}
+	
+	static byte[] getGreens(IndexColorModel cm) {
+		byte[] greens=new byte[256]; cm.getGreens(greens); return greens;
+	}
+	
+	static byte[] getBlues(IndexColorModel cm) {
+		byte[] blues=new byte[256]; cm.getBlues(blues); return blues;
+	}
+
+	public IndexColorModel getColorModel() {
+		if (cm==null) {
+			byte[] reds=new byte[256]; getReds(reds);
+			byte[] greens=new byte[256]; getGreens(greens);
+			byte[] blues=new byte[256]; getBlues(blues);
+			cm = new IndexColorModel(8, getMapSize(), reds, greens, blues);
+		}
+		return cm;
+	}
+		
+	public byte[] getBytes() {
+		int size = getMapSize();
+		if (size!=256) return null;
+		byte[] bytes = new byte[256*3];
+		for (int i=0; i<256; i++) bytes[i] = (byte)getRed(i);
+		for (int i=0; i<256; i++) bytes[256+i] = (byte)getGreen(i);
+		for (int i=0; i<256; i++) bytes[512+i] = (byte)getBlue(i);
+		return bytes;
+	}
+	
+	public LUT createInvertedLut() {
+		int mapSize = getMapSize();
+		byte[] reds = new byte[mapSize];
+		byte[] greens = new byte[mapSize];
+		byte[] blues = new byte[mapSize];	
+		byte[] reds2 = new byte[mapSize];
+		byte[] greens2 = new byte[mapSize];
+		byte[] blues2 = new byte[mapSize];	
+		getReds(reds); 
+		getGreens(greens); 
+		getBlues(blues);
+		for (int i=0; i<mapSize; i++) {
+			reds2[i] = (byte)(reds[mapSize-i-1]&255);
+			greens2[i] = (byte)(greens[mapSize-i-1]&255);
+			blues2[i] = (byte)(blues[mapSize-i-1]&255);
+		}
+		return new LUT(8, mapSize, reds2, greens2, blues2);
+	}
+	
+	/** Creates a color LUT from a Color. */
+	public static LUT createLutFromColor(Color color) {
+		byte[] rLut = new byte[256];
+		byte[] gLut = new byte[256];
+		byte[] bLut = new byte[256];
+		int red = color.getRed();
+		int green = color.getGreen();
+		int blue = color.getBlue();
+		double rIncr = ((double)red)/255d;
+		double gIncr = ((double)green)/255d;
+		double bIncr = ((double)blue)/255d;
+		for (int i=0; i<256; ++i) {
+			rLut[i] = (byte)(i*rIncr);
+			gLut[i] = (byte)(i*gIncr);
+			bLut[i] = (byte)(i*bIncr);
+		}
+		return new LUT(rLut, gLut, bLut);
+	}
+
+	public synchronized Object clone() {
+		try {return super.clone();}
+		catch (CloneNotSupportedException e) {return null;}
+	}
+	
+	public  String toString() {
+		return "rgb[0]="+Colors.colorToString(new Color(getRGB(0)))+", rgb[255]="
+			+Colors.colorToString(new Color(getRGB(255)))+", min="+IJ.d2s(min,4)+", max="+IJ.d2s(max,4);
+	}
+
+}
diff --git a/src/ij/process/MedianCut.java b/src/ij/process/MedianCut.java
new file mode 100644
index 0000000..4201bc4
--- /dev/null
+++ b/src/ij/process/MedianCut.java
@@ -0,0 +1,404 @@
+package ij.process;
+
+import java.awt.*;
+import java.awt.image.*;
+import ij.*; //??
+
+/** Converts an RGB image to 8-bit index color using Heckbert's median-cut
+    color quantization algorithm. Based on median.c by Anton Kruger from the
+    September, 1994 issue of Dr. Dobbs Journal.
+*/
+public class MedianCut {
+	
+	static final int MAXCOLORS = 256;	// maximum # of output colors
+	static final int HSIZE = 32768;		// size of image histogram
+	private int[] hist;					// RGB histogram and reverse color lookup table
+	private int[] histPtr;				// points to colors in "hist"
+	private Cube[] list;				// list of cubes
+	private int[] pixels32;
+	private int width, height;
+	private IndexColorModel cm; 
+
+	public MedianCut(int[] pixels, int width, int height) {
+		int color16;
+
+		pixels32 = pixels;
+		this.width = width;
+		this.height = height;
+		
+		//build 32x32x32 RGB histogram
+		IJ.showProgress(0.3);
+		IJ.showStatus("Building 32x32x32 RGB histogram");
+		hist = new int[HSIZE];
+		for (int i=0; i<width*height; i++) {
+			color16 = rgb(pixels32[i]);
+			hist[color16]++;
+		}
+	}
+	
+	public MedianCut(ColorProcessor ip) {
+		this((int[])ip.getPixels(), ip.getWidth(), ip.getHeight());
+	}
+	
+	int getColorCount() {
+		int count = 0;
+		for (int i=0; i<HSIZE; i++)
+			if (hist[i]>0) count++;
+		return count;
+	}
+	
+
+	Color getModalColor() {
+		int max=0;
+		int c = 0;
+		for (int i=0; i<HSIZE; i++)
+			if (hist[i]>max) {
+				max = hist[i];
+				c = i;
+			}
+		return new Color(red(c), green(c), blue(c));
+	}
+	
+
+	// Convert from 24-bit to 15-bit color
+	private final int rgb(int c) {
+		int r = (c&0xf80000)>>19;
+		int g = (c&0xf800)>>6;
+		int b = (c&0xf8)<<7;
+		return b | g | r;
+	}
+	
+	// Get red component of a 15-bit color
+	private final int red(int x) {
+		return (x&31)<<3;
+	}
+	
+	// Get green component of a 15-bit color
+	private final int green(int x) {
+		return (x>>2)&0xf8;
+	}
+	
+	// Get blue component of a 15-bit color
+	private final int blue(int x) {
+		return (x>>7)&0xf8;
+	}
+
+
+	/** Uses Heckbert's median-cut algorithm to divide the color space defined by
+	"hist" into "maxcubes" cubes. The centroids (average value) of each cube
+	are are used to create a color table. "hist" is then updated to function
+	as an inverse color map that is used to generate an 8-bit image. */
+	public Image convert(int maxcubes) {
+		ImageProcessor ip = convertToByte(maxcubes);
+		return ip.createImage();
+	}
+
+	/** This is a version of convert that returns a ByteProcessor. */
+	public ImageProcessor convertToByte(int maxcubes) {
+		int lr, lg, lb;
+		int i, median, color;
+		int count;
+		int k, level, ncubes, splitpos;
+		int num, width;
+		int longdim=0;	//longest dimension of cube
+		Cube cube, cubeA, cubeB;
+		
+		// Create initial cube
+		IJ.showStatus("Median cut");
+		list = new Cube[MAXCOLORS];
+		histPtr = new int[HSIZE];
+		ncubes = 0;
+		cube = new Cube();
+		for (i=0,color=0; i<=HSIZE-1; i++) {
+			if (hist[i] != 0) {
+				histPtr[color++] = i;
+				cube.count = cube.count + hist[i];
+			}
+		}
+		cube.lower = 0; cube.upper = color-1;
+		cube.level = 0;
+		Shrink(cube);
+		list[ncubes++] = cube;
+
+		//Main loop
+		while (ncubes < maxcubes) { 
+
+			// Search the list of cubes for next cube to split, the lowest level cube
+			level = 255; splitpos = -1; 
+			for (k=0; k<=ncubes-1; k++) {
+				if (list[k].lower == list[k].upper)  
+					;	// single color; cannot be split
+				else if (list[k].level < level) {
+					level = list[k].level;
+					splitpos = k;
+				}
+			}
+			if (splitpos == -1)	// no more cubes to split
+				break;
+
+			// Find longest dimension of this cube
+			cube = list[splitpos];
+			lr = cube.rmax - cube.rmin;
+			lg = cube.gmax - cube.gmin;
+			lb = cube.bmax - cube.bmin;
+			if (lr >= lg && lr >= lb) longdim = 0;
+			if (lg >= lr && lg >= lb) longdim = 1;
+			if (lb >= lr && lb >= lg) longdim = 2;
+			
+			// Sort along "longdim"
+			reorderColors(histPtr, cube.lower, cube.upper, longdim);
+			quickSort(histPtr, cube.lower, cube.upper);
+			restoreColorOrder(histPtr, cube.lower, cube.upper, longdim);
+
+			// Find median
+			count = 0;
+			for (i=cube.lower;i<=cube.upper-1;i++) {
+				if (count >= cube.count/2) break;
+				color = histPtr[i];
+				count = count + hist[color];
+			}
+			median = i;
+
+			// Now split "cube" at the median and add the two new
+			// cubes to the list of cubes.
+			cubeA = new Cube();
+			cubeA.lower = cube.lower; 
+			cubeA.upper = median-1;
+			cubeA.count = count;
+			cubeA.level = cube.level + 1;
+			Shrink(cubeA);
+			list[splitpos] = cubeA;				// add in old slot
+
+			cubeB = new Cube();
+			cubeB.lower = median; 
+			cubeB.upper = cube.upper; 
+			cubeB.count = cube.count - count;
+			cubeB.level = cube.level + 1;
+			Shrink(cubeB);
+			list[ncubes++] = cubeB;				// add in new slot */
+			if (ncubes%15==0)
+				IJ.showProgress(0.3 + (0.6*ncubes)/maxcubes);
+		}
+
+		// We have enough cubes, or we have split all we can. Now
+		// compute the color map, the inverse color map, and return
+		// an 8-bit image.
+		IJ.showProgress(0.9);
+		makeInverseMap(hist, ncubes);
+		IJ.showProgress(0.95);
+		return makeImage();
+	}
+	
+	void Shrink(Cube cube) {
+	// Encloses "cube" with a tight-fitting cube by updating the
+	// (rmin,gmin,bmin) and (rmax,gmax,bmax) members of "cube".
+
+		int r, g, b;
+		int color;
+		int rmin, rmax, gmin, gmax, bmin, bmax;
+
+		rmin = 255; rmax = 0;
+		gmin = 255; gmax = 0;
+		bmin = 255; bmax = 0;
+		for (int i=cube.lower; i<=cube.upper; i++) {
+			color = histPtr[i];
+			r = red(color);
+			g = green(color);
+			b = blue(color);
+			if (r > rmax) rmax = r;
+			if (r < rmin) rmin = r;
+			if (g > gmax) gmax = g;
+			if (g < gmin) gmin = g;
+			if (b > bmax) bmax = b;
+			if (b < bmin) bmin = b;
+		}
+		cube.rmin = rmin; cube.rmax = rmax;
+		cube.gmin = gmin; cube.gmax = gmax;
+		cube.bmin = bmin; cube.bmax = bmax;
+	}
+
+
+	void makeInverseMap(int[] hist, int ncubes) {
+	// For each cube in the list of cubes, computes the centroid
+	// (average value) of the colors enclosed by that cube, and
+	// then loads the centroids in the color map. Next loads
+	// "hist" with indices into the color map
+
+		int r, g, b;
+		int color;
+		float rsum, gsum, bsum;
+		Cube cube;
+		byte[] rLUT = new byte[256];
+		byte[] gLUT = new byte[256];
+		byte[] bLUT = new byte[256];
+
+		IJ.showStatus("Making inverse map");
+		for (int k=0; k<=ncubes-1; k++) {
+			cube = list[k];
+			rsum = gsum = bsum = (float)0.0;
+			for (int i=cube.lower; i<=cube.upper; i++) {
+				color = histPtr[i];
+				r = red(color);
+				rsum += (float)r*(float)hist[color];
+				g = green(color);
+				gsum += (float)g*(float)hist[color];
+				b = blue(color);
+				bsum += (float)b*(float)hist[color];
+			}
+
+			// Update the color map
+			r = (int)(rsum/(float)cube.count);
+			g = (int)(gsum/(float)cube.count);
+			b = (int)(bsum/(float)cube.count);
+			if (r==248 && g==248 && b==248)
+				r=g=b=255;  // Restore white (255,255,255)
+			rLUT[k] = (byte)r;
+			gLUT[k] = (byte)g;
+			bLUT[k] = (byte)b;
+		}
+		cm = new IndexColorModel(8, ncubes, rLUT, gLUT, bLUT);
+		
+		// For each color in each cube, load the corre- 
+		// sponding slot in "hist" with the centroid of the cube.
+		for (int k=0; k<=ncubes-1; k++) {
+			cube = list[k];
+			for (int i=cube.lower; i<=cube.upper; i++) {
+				color = histPtr[i];
+				hist[color] = k;
+			}
+		}
+	}
+	
+
+	void reorderColors(int[] a, int lo, int hi, int longDim) {
+	// Change the ordering of the 5-bit colors in each word of int[]
+	// so we can sort on the 'longDim' color
+	
+		int c, r, g, b;
+		switch (longDim) {
+			case 0: //red
+				for (int i=lo; i<=hi; i++) {
+					c = a[i];
+					r = c & 31;
+					a[i] = (r<<10) | (c>>5);
+					}
+				break;
+			case 1: //green
+				for (int i=lo; i<=hi; i++) {
+					c = a[i];
+					r = c & 31;
+					g = (c>>5) & 31;
+					b = c>>10;
+					a[i] = (g<<10) | (b<<5) | r;
+					}
+				break;
+			case 2: //blue; already in the needed order
+				break;
+		}
+	}
+	
+
+	void restoreColorOrder(int[] a, int lo, int hi, int longDim) {
+	// Restore the 5-bit colors to the original order
+	
+		int c, r, g, b;
+		switch (longDim){
+			case 0: //red
+				for (int i=lo; i<=hi; i++) {
+					c = a[i];
+					r = c >> 10;
+					a[i] = ((c&1023)<<5) | r;
+				}
+				break;
+			case 1: //green
+				for (int i=lo; i<=hi; i++) {
+					c = a[i];
+					r = c & 31;
+					g = c>>10;
+					b = (c>>5) & 31;
+					a[i] = (b<<10) | (g<<5) | r;
+				}
+				break;
+			case 2: //blue
+				break;
+		}
+	}
+	
+	
+	void quickSort(int a[], int lo0, int hi0) {
+   // Based on the QuickSort method by James Gosling from Sun's SortDemo applet
+   
+      int lo = lo0;
+      int hi = hi0;
+      int mid, t;
+
+      if ( hi0 > lo0) {
+         mid = a[ ( lo0 + hi0 ) / 2 ];
+         while( lo <= hi ) {
+            while( ( lo < hi0 ) && ( a[lo] < mid ) )
+               ++lo;
+            while( ( hi > lo0 ) && ( a[hi] > mid ) )
+               --hi;
+            if( lo <= hi ) {
+		      t = a[lo]; 
+		      a[lo] = a[hi];
+		      a[hi] = t;
+               ++lo;
+               --hi;
+            }
+         }
+         if( lo0 < hi )
+            quickSort( a, lo0, hi );
+         if( lo < hi0 )
+            quickSort( a, lo, hi0 );
+
+      }
+   }
+
+
+	ImageProcessor makeImage() {
+	// Generate 8-bit image
+	
+		Image img8;
+		byte[] pixels8;
+		int color16;
+		
+		IJ.showStatus("Creating 8-bit image");
+	    pixels8 = new byte[width*height];
+	    for (int i=0; i<width*height; i++) {
+	    	color16 = rgb(pixels32[i]);
+	    	pixels8[i] = (byte)hist[color16];
+	    }
+	    ImageProcessor ip = new ByteProcessor(width, height, pixels8, cm);
+        IJ.showProgress(1.0);
+		return ip;
+	}
+	
+	
+} //class MedianCut
+
+
+class Cube {			// structure for a cube in color space
+	int  lower;			// one corner's index in histogram
+	int  upper;			// another corner's index in histogram
+	int  count;			// cube's histogram count
+	int  level;			// cube's level
+	int  rmin, rmax;
+	int  gmin, gmax;
+	int  bmin, bmax;
+	
+	Cube() {
+		count = 0;
+	}   
+
+	public String toString() {
+		String s = "lower=" + lower + " upper=" + upper;
+		s = s + " count=" + count + " level=" + level;
+		s = s + " rmin=" + rmin + " rmax=" + rmax;
+		s = s + " gmin=" + gmin + " gmax=" + gmax;
+		s = s + " bmin=" + bmin + " bmax=" + bmax;
+		return s;
+	}
+	
+}
+
diff --git a/src/ij/process/PolygonFiller.java b/src/ij/process/PolygonFiller.java
new file mode 100644
index 0000000..afa41f6
--- /dev/null
+++ b/src/ij/process/PolygonFiller.java
@@ -0,0 +1,291 @@
+package ij.process;
+import ij.*;
+import ij.gui.*;
+import java.awt.Rectangle;
+
+
+/** This class fills polygons using the scan-line filling algorithm
+	described at "http://www.cs.rit.edu/~icss571/filling/".
+
+	Note that by ImageJ convention, outline and pixel coordinates are shifted by 0.5:
+	Pixel (0,0) is enclosed by the rectangle between (0,0) and (1,1); thus all 0.5
+	is added to all polygon coordinates when comparing to pixel coordinates.
+
+	After applying this offset, rounding is done such that points
+	exactly on the left boundary are considered outside, points
+	exactly on the right boundary inside.
+	Points exactly on a horizontal boundary are considered ouside for
+	the boundary with lower y and inside for the boundary with the higher y.
+	(actually, the boundary is slightly shifted to the left (in x) to ensure
+	correct rounding in spite of the final numeric accuracy)
+*/
+public class PolygonFiller {
+	int BLACK=0xff000000, WHITE=0xffffffff;
+	int edges; // number of edges
+	int activeEdges; // number of  active edges
+
+	// the polygon
+	int[] x;                 // x coordinates of polygon vertices (null when using float values)
+	int[] y;                 // y coordinates
+	float[] xf, yf;          // floating-point coordinates, may be given instead of integer 'x'
+	double xOffset, yOffset; // offset that has to be added to xf, yf
+	int n;                   // number of coordinates (polygon vertices)
+
+	// edge table
+	double[] ex;       // x coordinates
+	int[] ey1;         // upper y coordinates
+	int[] ey2;         // lower y coordinates
+	double[] eslope;   // inverse slopes (1/m)
+	int yMin, yMax;    // lowest and highest of all ey1, ey2;
+
+	// sorted edge table (indexes into edge table) (currently not used)
+	int[] sedge;
+
+	// active edge table (indexes into edge table)
+	int[] aedge;
+
+	/** Constructs a PolygonFiller. */
+	public PolygonFiller() {
+	}
+
+	/** Constructs a PolygonFiller using the specified polygon with integer coordinates. */
+	public PolygonFiller(int[] x, int[] y, int n) {
+		setPolygon(x, y, n);
+	}
+
+	/** Constructs a PolygonFiller using the specified polygon with floating-point coordinates. */
+	public PolygonFiller(float[] xf, float[] yf, int n, double xOffset, double yOffset) {
+		setPolygon(xf, yf, n, xOffset, yOffset);
+	}
+
+	/** Specifies the polygon to be filled. */
+	public void setPolygon(int[] x, int[] y, int n) {
+		this.x = x;
+		this.y = y;
+		this.n = n;
+	}
+
+	/** Specifies the polygon to be filled in case of float coordinates.
+	 *  In this case, multiple polygons separated by one set of NaN coordinates each.
+	 */
+	public void setPolygon(float[] xf, float[] yf, int n, double xOffset, double yOffset) {
+		x = y = null;
+		this.xf = xf;
+		this.yf = yf;
+		this.n = n;
+		this.xOffset = xOffset;
+		this.yOffset = yOffset;
+	}
+
+	 void allocateArrays(int n) {
+		if (ex==null || n>ex.length) {
+			ex = new double[n];
+			ey1 = new int[n];
+			ey2 = new int[n];
+			sedge = new int[n];
+			aedge = new int[n];
+			eslope = new double[n];
+		}
+	}
+
+	/** Generates the edge table for all non-horizontal lines:
+	 *  ey1, ey2: min & max y value
+	 *  eslope: inverse slope dx/dy
+	 *  ex: x value at ey1, corrected for half-pixel shift between outline&pixel coordinates
+	 *  sedge: list of sorted edges is prepared (not sorted yet) */
+	void buildEdgeTable() {
+		yMin = Integer.MAX_VALUE;
+		yMax = Integer.MIN_VALUE;
+		edges = 0;
+		int polyStart = 0;	  //index where the polygon has started (i.e., 0 unless we have multiple ploygons separated by NaN)
+		for (int i=0; i<n; i++) {
+			int iplus1 = i==n-1 ? polyStart : i+1;
+			if (x != null) {  //using int arrays
+				int y1 = y[i];  int y2 = y[iplus1];
+				int x1 = x[i];  int x2 = x[iplus1];
+				if (y1==y2)
+					continue; //ignore horizontal lines
+				if (y1>y2) {  //swap ends to ensure y1<y2
+					int tmp = y1;
+					y1 = y2;  y2 = tmp;
+					tmp = x1;
+					x1 = x2;  x2 = tmp;
+				}
+				double slope = (double)(x2 - x1)/(y2 - y1);
+				ex[edges] = x1 + 0.5*slope + 1e-8;  // x at the y1 pixel coordinate
+				ey1[edges] = y1;
+				ey2[edges] = y2;
+				eslope[edges] = slope;
+				if (y1 < yMin) yMin = y1;
+				if (y2 > yMax) yMax = y2;
+			} else {          //using float arrays
+				if (Float.isNaN(xf[iplus1])) //after the last point, close the polygon
+					iplus1 = polyStart;
+				if (Float.isNaN(xf[i])) {    //when a new polygon follows, remember the start point for closing it
+					polyStart = i + 1;
+					continue;
+				}
+				double y1f = yf[i] + yOffset;  double y2f = yf[iplus1] + yOffset;
+				double x1f = xf[i] + xOffset;  double x2f = xf[iplus1] + xOffset;
+				int y1 = (int)Math.round(y1f);
+				int y2 = (int)Math.round(y2f);
+				//IJ.log("x, y="+xf[i]+","+yf[i]+"+ offs="+xOffset+","+yOffset+"->"+x1f+","+y1f+" int="+y1);
+				if (y1==y2 || (y1<=0 && y2<=0))
+					continue; //ignore horizontal lines or lines that don't reach the first row of pixels
+				if (y1>y2) {  //swap ends to ensure y1<y2
+					int tmp = y1;
+					y1 = y2;  y2 = tmp;
+					double ftmp = y1f;
+					y1f = y2f;  y2f = ftmp;
+					ftmp = x1f;
+					x1f = x2f;  x2f = ftmp;
+				}
+				double slope = (x2f - x1f)/(y2f - y1f);
+				ex[edges] = x1f + (y1 - y1f + 0.5)*slope + 1e-8; // x at the y1 pixel coordinate
+				ey1[edges] = y1;
+				ey2[edges] = y2;
+				eslope[edges] = slope;
+				if (y1 < yMin) yMin = y1;
+				if (y2 > yMax) yMax = y2;
+			}
+			edges++;
+		}
+		for (int i=0; i<edges; i++)
+			sedge[i] = i;
+		activeEdges = 0;
+	}
+
+	/** Fills the polygon using the ImageProcessor's current drawing color. */
+	public void fill(ImageProcessor ip, Rectangle r) {
+		ip.fill(getMask(r.width, r.height));
+	}
+
+	/** Returns a byte mask containing a filled version of the polygon. */
+	public ImageProcessor getMask(int width, int height) {
+		ByteProcessor mask = new ByteProcessor(width, height);
+		fillByteProcessorMask(mask);
+		return mask;
+	}
+
+	/** Fills the ByteProcessor with 255 inside the polygon */
+	public void fillByteProcessorMask(ByteProcessor mask) {
+		int width = mask.getWidth();
+		int height = mask.getHeight();
+		byte[] pixels = (byte[])mask.getPixels();
+		allocateArrays(n);
+		buildEdgeTable();
+		//printEdges();
+		int x1, x2, offset, index;
+		int yStart = yMin>0 ? yMin : 0;
+		if (yMin != 0)
+			shiftXValuesAndActivate(yStart);
+		//IJ.log("yMin="+yMin+" yStart="+yStart+" nActive="+activeEdges);
+		for (int y=yStart; y<Math.min(height, yMax+1); y++) {
+			removeInactiveEdges(y);
+			activateEdges(y);
+			offset = y*width;
+			for (int i=0; i<activeEdges; i+=2) {
+				x1 = (int)(ex[aedge[i]]+0.5);
+				if (x1<0) x1=0;
+				if (x1>width) x1 = width;
+				x2 = (int)(ex[aedge[i+1]]+0.5);
+				if (x2<0) x2=0;
+				if (x2>width) x2 = width;
+				for (int x=x1; x<x2; x++)
+					pixels[offset+x] = -1; // 255 (white)
+			}
+			updateXCoordinates();
+		}
+	}
+
+	/** Shifts the x coordinates of all edges according to their slopes
+	 *  as required for starting at the given y value and prepares the
+	 *  list of active edges as it would have resulted from procesing
+	 *  the previous lines */
+	void shiftXValuesAndActivate(int yStart) {
+		for (int i=0; i<edges; i++) {
+			int index = sedge[i];
+			if (ey1[index] < yStart && ey2[index] >= yStart) {
+				ex[index] += eslope[index] * (yStart - ey1[index]);
+				aedge[activeEdges++] = index;
+			}
+		}
+		sortActiveEdges();
+	}
+
+	/** Updates the x coordinates in the active edges list and sorts the list if necessary. */
+	void updateXCoordinates() {
+		int index;
+		double x1=-Double.MAX_VALUE, x2;
+		boolean sorted = true;
+		for (int i=0; i<activeEdges; i++) {
+			index = aedge[i];
+			x2 = ex[index] + eslope[index];
+			ex[index] = x2;
+			if (x2<x1) sorted = false;
+			x1 = x2;
+		}
+		if (!sorted)
+			sortActiveEdges();
+	}
+
+	/** Sorts the active edges list by x coordinate using a selection sort. */
+	void sortActiveEdges() {
+		int min, tmp;
+		for (int i=0; i<activeEdges; i++) {
+			min = i;
+			for (int j=i; j<activeEdges; j++)
+				if (ex[aedge[j]] <ex[aedge[min]]) min = j;
+			tmp=aedge[min];
+			aedge[min] = aedge[i];
+			aedge[i]=tmp;
+		}
+	}
+
+	/** Removes edges from the active edge table that are no longer needed. */
+	void removeInactiveEdges(int y) {
+		int i = 0;
+		while (i<activeEdges) {
+			int index = aedge[i];
+			if (y<ey1[index] || y>=ey2[index]) {
+				for (int j=i; j<activeEdges-1; j++)
+					aedge[j] = aedge[j+1];
+				activeEdges--;
+			} else
+				i++;
+		}
+	}
+
+	/** Adds edges to the active edge table. */
+	void activateEdges(int y) {
+		for (int i=0; i<edges; i++) {
+			int edge =sedge[i];
+			if (y==ey1[edge]) {
+				int index = 0;
+				while (index<activeEdges && ex[edge]>ex[aedge[index]])
+					index++;
+				for (int j=activeEdges-1; j>=index; j--)
+					aedge[j+1] = aedge[j];
+				aedge[index] = edge;
+				activeEdges++;
+			}
+		}
+	}
+
+	/** Display the contents of the edge table*/
+	void printEdges() {
+		for (int i=0; i<edges; i++) {
+			int index = i;
+			IJ.log(i+": x="+IJ.d2s(ex[index])+" y="+ey1[index]+" to "+ey2[index] + " sl=" + IJ.d2s(eslope[index],2) );
+		}
+	}
+
+	/** Display the contents of the active edge table*/
+	void printActiveEdges() {
+		for (int i=0; i<activeEdges; i++) {
+			int index =aedge[i];
+			IJ.log(i+": x="+IJ.d2s(ex[index])+" y="+ey1[index]+" to "+ey2[index] + " sl=" + IJ.d2s(eslope[index],2) );
+		}
+	}
+
+}
diff --git a/src/ij/process/ShortBlitter.java b/src/ij/process/ShortBlitter.java
new file mode 100644
index 0000000..ea62dfb
--- /dev/null
+++ b/src/ij/process/ShortBlitter.java
@@ -0,0 +1,145 @@
+package ij.process;
+import java.awt.*;
+
+/** This class does bit blitting of 16-bit images. */
+public class ShortBlitter implements Blitter {
+
+	private ShortProcessor ip;
+	private int width, height;
+	private short[] pixels;
+	
+	public void setTransparentColor(Color c) {
+	}
+
+	/** Constructs a ShortBlitter from a ShortProcessor. */
+	public ShortBlitter(ShortProcessor ip) {
+		this.ip = ip;
+		width = ip.getWidth();
+		height = ip.getHeight();
+		pixels = (short[])ip.getPixels();
+	}
+
+	/** Copies the 16-bit image in 'ip' to (x,y) using the specified mode. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		Rectangle r1, r2;
+		int srcIndex, dstIndex;
+		int xSrcBase, ySrcBase;
+		short[] srcPixels;
+		
+		int srcWidth = ip.getWidth();
+		int srcHeight = ip.getHeight();
+		r1 = new Rectangle(srcWidth, srcHeight);
+		r1.setLocation(xloc, yloc);
+		r2 = new Rectangle(width, height);
+		if (!r1.intersects(r2))
+			return;
+		srcPixels = (short [])ip.getPixels();
+//new ij.ImagePlus("srcPixels", new ShortProcessor(srcWidth, srcHeight, srcPixels, null)).show();
+		r1 = r1.intersection(r2);
+		xSrcBase = (xloc<0)?-xloc:0;
+		ySrcBase = (yloc<0)?-yloc:0;
+		int src, dst;
+		for (int y=r1.y; y<(r1.y+r1.height); y++) {
+			srcIndex = (y-yloc)*srcWidth + (r1.x-xloc);
+			dstIndex = y * width + r1.x;
+			switch (mode) {
+				case COPY: case COPY_INVERTED: case COPY_TRANSPARENT:
+					for (int i=r1.width; --i>=0;)
+						pixels[dstIndex++] = srcPixels[srcIndex++];
+					break;
+				case COPY_ZERO_TRANSPARENT:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&0xffff;
+						if (src==0)
+							dst = pixels[dstIndex];
+						else
+							dst = src;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case ADD:
+					for (int i=r1.width; --i>=0;) {
+						dst = (srcPixels[srcIndex++]&0xffff)+(pixels[dstIndex]&0xffff);
+						if (dst<0) dst = 0;
+						if (dst>65535) dst = 65535;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case AVERAGE:
+					for (int i=r1.width; --i>=0;) {
+						dst = ((srcPixels[srcIndex++]&0xffff)+(pixels[dstIndex]&0xffff))/2;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case DIFFERENCE:
+					for (int i=r1.width; --i>=0;) {
+						dst = (pixels[dstIndex]&0xffff)-(srcPixels[srcIndex++]&0xffff);
+						if (dst<0) dst = -dst;
+						if (dst>65535) dst = 65535;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case SUBTRACT:
+					for (int i=r1.width; --i>=0;) {
+						dst = (pixels[dstIndex]&0xffff)-(srcPixels[srcIndex++]&0xffff);
+						if (dst<0) dst = 0;
+						if (dst>65535) dst = 65535;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case MULTIPLY:
+					for (int i=r1.width; --i>=0;) {
+						dst = (srcPixels[srcIndex++]&0xffff)*(pixels[dstIndex]&0xffff);
+						if (dst<0) dst = 0;
+						if (dst>65535) dst = 65535;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case DIVIDE:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&0xffff;
+						if (src==0)
+							dst = 65535;
+						else
+							dst = (pixels[dstIndex]&0xffff)/src;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case AND:
+					for (int i=r1.width; --i>=0;) {
+						dst = srcPixels[srcIndex++]&pixels[dstIndex]&0xffff;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case OR:
+					for (int i=r1.width; --i>=0;) {
+						dst = srcPixels[srcIndex++]|pixels[dstIndex];
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case XOR:
+					for (int i=r1.width; --i>=0;) {
+						dst = srcPixels[srcIndex++]^pixels[dstIndex];
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case MIN:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&0xffff;
+						dst = pixels[dstIndex]&0xffff;
+						if (src<dst) dst = src;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+				case MAX:
+					for (int i=r1.width; --i>=0;) {
+						src = srcPixels[srcIndex++]&0xffff;
+						dst = pixels[dstIndex]&0xffff;
+						if (src>dst) dst = src;
+						pixels[dstIndex++] = (short)dst;
+					}
+					break;
+			}
+		}
+	}
+}
diff --git a/src/ij/process/ShortProcessor.java b/src/ij/process/ShortProcessor.java
new file mode 100644
index 0000000..449d2f8
--- /dev/null
+++ b/src/ij/process/ShortProcessor.java
@@ -0,0 +1,1270 @@
+ package ij.process;
+
+import java.util.*;
+import java.awt.*;
+import java.awt.image.*;
+import ij.gui.*;
+
+/** ShortProcessors contain a 16-bit unsigned image
+	and methods that operate on that image. */
+public class ShortProcessor extends ImageProcessor {
+
+	private int min, max, snapshotMin, snapshotMax;
+	private short[] pixels;
+	private byte[] pixels8;
+	private short[] snapshotPixels;
+	private byte[] LUT;
+	private boolean fixedScale;
+	private int bgValue;
+
+
+	/** Creates a new ShortProcessor using the specified pixel array and ColorModel.
+		Set 'cm' to null to use the default grayscale LUT. */
+	public ShortProcessor(int width, int height, short[] pixels, ColorModel cm) {
+		if (pixels!=null && width*height!=pixels.length)
+			throw new IllegalArgumentException(WRONG_LENGTH);
+		init(width, height, pixels, cm);
+	}
+
+	/** Creates a blank ShortProcessor using the default grayscale LUT that
+		displays zero as black. Call invertLut() to display zero as white. */
+	public ShortProcessor(int width, int height) {
+		this(width, height, new short[width*height], null);
+	}
+	
+	/** Creates a ShortProcessor from a TYPE_USHORT_GRAY BufferedImage. */
+	public ShortProcessor(BufferedImage bi) {
+		if (bi.getType()!=BufferedImage.TYPE_USHORT_GRAY)
+			throw new IllegalArgumentException("Type!=TYPE_USHORT_GRAY");
+		WritableRaster raster = bi.getRaster();
+		DataBuffer buffer = raster.getDataBuffer();
+		short[] data = ((DataBufferUShort) buffer).getData();
+		//short[] data2 = new short[data.length];
+		//System.arraycopy(data, 0, data2, 0, data.length);
+		init(raster.getWidth(), raster.getHeight(), data, null);
+	}
+
+	void init(int width, int height, short[] pixels, ColorModel cm) {
+		this.width = width;
+		this.height = height;
+		this.pixels = pixels;
+		this.cm = cm;
+		resetRoi();
+	}
+
+	/**
+	* @deprecated
+	* 16 bit images are normally unsigned but signed images can be simulated by
+	* subtracting 32768 and using a calibration function to restore the original values.
+	*/
+	public ShortProcessor(int width, int height, short[] pixels, ColorModel cm, boolean unsigned) {
+		this(width, height, pixels, cm);
+	}
+
+	/** Obsolete. 16 bit images are normally unsigned but signed images can be used by
+		subtracting 32768 and using a calibration function to restore the original values. */
+	public ShortProcessor(int width, int height,  boolean unsigned) {
+		this(width, height);
+	}
+	
+	public void findMinAndMax() {
+		if (fixedScale || pixels==null)
+			return;
+		int size = width*height;
+		int value;
+		int min = pixels[0]&0xffff;
+		int max = pixels[0]&0xffff;
+		for (int i=1; i<size; i++) {
+			value = pixels[i]&0xffff;
+			if (value<min)
+				min = value;
+			else if (value>max)
+				max = value;
+		}
+		this.min = min;
+		this.max = max;
+		minMaxSet = true;
+	}
+
+	/** Create an 8-bit AWT image by scaling pixels in the range min-max to 0-255. */
+	public Image createImage() {
+		if (!minMaxSet)
+			findMinAndMax();
+		boolean firstTime = pixels8==null;
+		boolean thresholding = minThreshold!=NO_THRESHOLD && lutUpdateMode<NO_LUT_UPDATE;
+		//ij.IJ.log("createImage: "+firstTime+"  "+lutAnimation+"  "+thresholding);
+		if (firstTime || !lutAnimation)
+			create8BitImage(thresholding&&lutUpdateMode==RED_LUT);
+		if (cm==null)
+			makeDefaultColorModel();
+		if (thresholding) {
+			int t1 = (int)minThreshold;
+			int t2 = (int)maxThreshold;
+			int size = width*height;
+			int value;
+			if (lutUpdateMode==BLACK_AND_WHITE_LUT) {
+				for (int i=0; i<size; i++) {
+					value = (pixels[i]&0xffff);
+					if (value>=t1 && value<=t2)
+						pixels8[i] = (byte)255;
+					else
+						pixels8[i] = (byte)0;
+				}
+			} else { // threshold red
+				for (int i=0; i<size; i++) {
+					value = (pixels[i]&0xffff);
+					if (value>=t1 && value<=t2)
+						pixels8[i] = (byte)255;
+				}
+			}
+		}
+		return createBufferedImage();
+	}
+	
+	// create 8-bit image by linearly scaling from 16-bits to 8-bits
+	private byte[] create8BitImage(boolean thresholding) {
+		int size = width*height;
+		if (pixels8==null)
+			pixels8 = new byte[size];
+		int value;
+		int min2=(int)getMin(), max2=(int)getMax();
+		int maxValue = 255;
+		double scale = 256.0/(max2-min2+1);
+		if (thresholding) {
+			maxValue = 254;
+			scale = 255.0/(max2-min2+1);
+		}
+		for (int i=0; i<size; i++) {
+			value = (pixels[i]&0xffff)-min2;
+			if (value<0) value = 0;
+			value = (int)(value*scale+0.5);
+			if (value>maxValue) value = maxValue;
+			pixels8[i] = (byte)value;
+		}
+		return pixels8;
+	}
+
+	@Override
+	byte[] create8BitImage() {
+		return create8BitImage(false);
+	}
+
+	Image createBufferedImage() {
+		if (raster==null) {
+			SampleModel sm = getIndexSampleModel();
+			DataBuffer db = new DataBufferByte(pixels8, width*height, 0);
+			raster = Raster.createWritableRaster(sm, db, null);
+		}
+		if (image==null || cm!=cm2) {
+			if (cm==null) cm = getDefaultColorModel();
+			image = new BufferedImage(cm, raster, false, null);
+			cm2 = cm;
+		}
+		lutAnimation = false;
+		return image;
+	}
+
+	/** Returns this image as an 8-bit BufferedImage . */
+	public BufferedImage getBufferedImage() {
+		return convertToByte(true).getBufferedImage();
+	}
+
+	/** Returns a copy of this image as a TYPE_USHORT_GRAY BufferedImage. */
+	public BufferedImage get16BitBufferedImage() {
+        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_USHORT_GRAY);
+        Raster raster = bi.getData();
+        DataBufferUShort db = (DataBufferUShort)raster.getDataBuffer();
+        System.arraycopy(getPixels(), 0, db.getData(), 0, db.getData().length);
+        bi.setData(raster);
+        return bi;
+	}
+
+	/** Returns a new, blank ShortProcessor with the specified width and height. */
+	public ImageProcessor createProcessor(int width, int height) {
+		ImageProcessor ip2 = new ShortProcessor(width, height, new short[width*height], getColorModel());
+		ip2.setMinAndMax(getMin(), getMax());
+		ip2.setInterpolationMethod(interpolationMethod);
+		return ip2;
+	}
+
+	public void snapshot() {
+		snapshotWidth=width;
+		snapshotHeight=height;
+		snapshotMin=(int)getMin();
+		snapshotMax=(int)getMax();
+		if (snapshotPixels==null || (snapshotPixels!=null && snapshotPixels.length!=pixels.length))
+			snapshotPixels = new short[width * height];
+		System.arraycopy(pixels, 0, snapshotPixels, 0, width*height);
+	}
+	
+	public void reset() {
+		if (snapshotPixels==null)
+			return;
+	    min=snapshotMin;
+		max=snapshotMax;
+		minMaxSet = true;
+        System.arraycopy(snapshotPixels, 0, pixels, 0, width*height);
+	}
+	
+	public void reset(ImageProcessor mask) {
+		if (mask==null || snapshotPixels==null)
+			return;	
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]==0)
+					pixels[i] = snapshotPixels[i];
+				i++;
+			}
+		}
+	}
+
+	/** Swaps the pixel and snapshot (undo) arrays. */
+	public void swapPixelArrays() {
+		if (snapshotPixels==null) return;	
+		short pixel;
+		for (int i=0; i<pixels.length; i++) {
+			pixel = pixels[i];
+			pixels[i] = snapshotPixels[i];
+			snapshotPixels[i] = pixel;
+		}
+	}
+
+	public void setSnapshotPixels(Object pixels) {
+		snapshotPixels = (short[])pixels;
+		snapshotWidth=width;
+		snapshotHeight=height;
+	}
+
+	public Object getSnapshotPixels() {
+		return snapshotPixels;
+	}
+
+	/** Returns the smallest displayed pixel value. */
+	public double getMin() {
+		if (!minMaxSet) findMinAndMax();
+		return min;
+	}
+
+	/** Returns the largest displayed pixel value. */
+	public double getMax() {
+		if (!minMaxSet) findMinAndMax();
+		return max;
+	}
+
+	/**
+	Sets the min and max variables that control how real
+	pixel values are mapped to 0-255 screen values. With
+	signed 16-bit images, use IJ.setMinAndMax(imp,min,max).
+	@see #resetMinAndMax
+	@see ij.plugin.frame.ContrastAdjuster 
+	@see ij.IJ#setMinAndMax(ij.ImagePlus,double,double)
+	*/
+	public void setMinAndMax(double minimum, double maximum) {
+		if (minimum==0.0 && maximum==0.0) {
+			resetMinAndMax();
+			return;
+		}
+		if (minimum<0.0)
+			minimum = 0.0;
+		if (maximum>65535.0)
+			maximum = 65535.0;
+		min = (int)minimum;
+		max = (int)maximum;
+		fixedScale = true;
+		minMaxSet = true;
+		resetThreshold();
+	}
+	
+	/** Recalculates the min and max values used to scale pixel
+		values to 0-255 for display. This ensures that this 
+		ShortProcessor is set up to correctly display the image. */
+	public void resetMinAndMax() {
+		fixedScale = false;
+		findMinAndMax();
+		resetThreshold();
+	}
+
+	public int getPixel(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height)
+			return pixels[y*width+x]&0xffff;
+		else
+			return 0;
+	}
+
+	public final int get(int x, int y) {
+		return pixels[y*width+x]&0xffff;
+	}
+
+	public final void set(int x, int y, int value) {
+		pixels[y*width+x] = (short)value;
+	}
+
+	public final int get(int index) {
+		return pixels[index]&0xffff;
+	}
+
+	public final void set(int index, int value) {
+		pixels[index] = (short)value;
+	}
+
+	public final float getf(int x, int y) {		
+		return pixels[y*width+x]&0xffff;
+	}
+
+	public final void setf(int x, int y, float value) {
+		pixels[y*width + x] = (short)(value+0.5f);
+	}
+
+	public final float getf(int index) {
+		return pixels[index]&0xffff;
+	}
+
+	public final void setf(int index, float value) {
+		pixels[index] = (short)value;
+	}
+
+	/** Uses the current interpolation method (BILINEAR or BICUBIC)
+		to calculate the pixel value at real coordinates (x,y). */
+	public double getInterpolatedPixel(double x, double y) {
+		if (interpolationMethod==BICUBIC)
+			return getBicubicInterpolatedPixel(x, y, this);
+		else {
+			if (x<0.0) x = 0.0;
+			if (x>=width-1.0) x = width-1.001;
+			if (y<0.0) y = 0.0;
+			if (y>=height-1.0) y = height-1.001;
+			return getInterpolatedPixel(x, y, pixels);
+		}
+	}
+
+	final public int getPixelInterpolated(double x, double y) {
+		if (interpolationMethod==BILINEAR) {
+			if (x<0.0 || y<0.0 || x>=width-1 || y>=height-1)
+				return 0;
+			else
+				return (int)Math.round(getInterpolatedPixel(x, y, pixels));
+		} else if (interpolationMethod==BICUBIC) {
+			int value = (int)(getBicubicInterpolatedPixel(x, y, this)+0.5);
+			if (value<0) value = 0;
+			if (value>65535) value = 65535;
+			return value;
+		} else
+			return getPixel((int)(x+0.5), (int)(y+0.5));
+	}
+
+	/** Stores the specified value at (x,y). Does
+		nothing if (x,y) is outside the image boundary.
+		Values outside the range 0-65535 are clipped.
+	*/
+	public final void putPixel(int x, int y, int value) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			if (value>65535) value = 65535;
+			if (value<0) value = 0;
+			pixels[y*width + x] = (short)value;
+		}
+	}
+
+	/** Stores the specified real value at (x,y). Does nothing
+		if (x,y) is outside the image boundary. Values outside 
+		the range 0-65535 (-32768-32767 for signed images)
+		are clipped. Support for signed values requires a calibration
+		table, which is set up automatically with PlugInFilters.
+	*/
+	public void putPixelValue(int x, int y, double value) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			if (cTable!=null&&cTable[0]==-32768f) // signed image
+				value += 32768.0;
+			if (value>65535.0)
+				value = 65535.0;
+			else if (value<0.0)
+				value = 0.0;
+			pixels[y*width + x] = (short)(value+0.5);
+		}
+	}
+
+	/** Draws a pixel in the current foreground color. */
+	public void drawPixel(int x, int y) {
+		if (x>=clipXMin && x<=clipXMax && y>=clipYMin && y<=clipYMax)
+			putPixel(x, y, fgColor);
+	}
+
+	/** Returns the value of the pixel at (x,y) as a float. For signed
+		images, returns a signed value if a calibration table has
+		been set using setCalibrationTable() (this is done automatically 
+		in PlugInFilters). */
+	public float getPixelValue(int x, int y) {
+		if (x>=0 && x<width && y>=0 && y<height) {
+			if (cTable==null)
+				return pixels[y*width + x]&0xffff;
+			else
+				return cTable[pixels[y*width + x]&0xffff];
+		} else
+			return Float.NaN;
+	}
+
+	/**	Returns a reference to the short array containing this image's
+		pixel data. To avoid sign extension, the pixel values must be
+		accessed using a mask (e.g. int i = pixels[j]&0xffff). */
+ 	public Object getPixels() {
+		return (Object)pixels;
+	}
+
+	/** Returns a copy of the pixel data. Or returns a reference to the
+		snapshot buffer if it is not null and 'snapshotCopyMode' is true.
+		@see ImageProcessor#snapshot
+		@see ImageProcessor#setSnapshotCopyMode
+	*/
+	public Object getPixelsCopy() {
+		if (snapshotPixels!=null && snapshotCopyMode) {
+			snapshotCopyMode = false;
+			return snapshotPixels;
+		} else {
+			short[] pixels2 = new short[width*height];
+        	System.arraycopy(pixels, 0, pixels2, 0, width*height);
+			return pixels2;
+		}
+	}
+
+	public void setPixels(Object pixels) {
+		this.pixels = (short[])pixels;
+		resetPixels(pixels);
+		if (pixels==null) snapshotPixels = null;
+		if (pixels==null) pixels8 = null;
+		raster = null;
+	}
+
+	void getRow2(int x, int y, int[] data, int length) {
+		int value;
+		for (int i=0; i<length; i++)
+			data[i] = pixels[y*width+x+i]&0xffff;
+	}
+	
+	void putColumn2(int x, int y, int[] data, int length) {
+		int value;
+		for (int i=0; i<length; i++)
+			pixels[(y+i)*width+x] = (short)data[i];
+	}
+	
+	/** Copies the image contained in 'ip' to (xloc, yloc) using one of
+		the transfer modes defined in the Blitter interface. */
+	public void copyBits(ImageProcessor ip, int xloc, int yloc, int mode) {
+		boolean temporaryFloat = ip.getBitDepth()==32 && (mode==Blitter.MULTIPLY || mode==Blitter.DIVIDE);
+		if (temporaryFloat) {
+			FloatProcessor ipFloat = this.convertToFloatProcessor();
+			new FloatBlitter(ipFloat).copyBits(ip, xloc, yloc, mode);
+			setPixels(1, ipFloat);
+		} else {
+			ip = ip.convertToShort(false);
+			new ShortBlitter(this).copyBits(ip, xloc, yloc, mode);
+		}
+	}
+	
+	/** Transforms the pixel data using a 65536 entry lookup table. */
+	public void applyTable(int[] lut) {
+		if (lut.length!=65536)
+			throw new IllegalArgumentException("lut.length!=65536");
+		int lineStart, lineEnd, v;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			lineStart = y * width + roiX;
+			lineEnd = lineStart + roiWidth;
+			for (int i=lineEnd; --i>=lineStart;) {
+				v = lut[pixels[i]&0xffff];
+				pixels[i] = (short)v;
+			}
+		}
+		findMinAndMax();
+	}
+
+	private void process(int op, double value) {
+		int v1, v2;
+		double range = getMax()-getMin();
+		//boolean resetMinMax = roiWidth==width && roiHeight==height && !(op==FILL);
+		int offset = isSigned16Bit()?32768:0;
+		int min2 = (int)getMin() - offset;
+		int max2 = (int)getMax() - offset;
+		int fgColor2 = fgColor - offset;
+		int intValue = (int)value;
+		
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				v1 = (pixels[i]&0xffff) - offset;
+				switch(op) {
+					case INVERT:
+						v2 = max2 - (v1 - min2);
+						//v2 = 65535 - (v1+offset);
+						break;
+					case FILL:
+						v2 = fgColor2;
+						break;
+					case SET:
+						v2 = intValue;
+						break;
+					case ADD:
+						v2 = v1 + intValue;
+						break;
+					case MULT:
+						v2 = (int)Math.round(v1*value);
+						break;
+					case AND:
+						v2 = v1 & intValue;
+						break;
+					case OR:
+						v2 = v1 | intValue;
+						break;
+					case XOR:
+						v2 = v1 ^ intValue;
+						break;
+					case GAMMA:
+						if (range<=0.0 || v1==min2)
+							v2 = v1;
+						else					
+							v2 = (int)(Math.exp(value*Math.log((v1-min2)/range))*range+min2);
+						break;
+					case LOG:
+						if (v1<=0)
+							v2 = 0;
+						else 
+							v2 = (int)(Math.log(v1)*(max2/Math.log(max2)));
+						break;
+					case EXP:
+						v2 = (int)(Math.exp(v1*(Math.log(max2)/max2)));
+						break;
+					case SQR:
+						double d1 = v1;
+						v2 = (int)(d1*d1);
+						break;
+					case SQRT:
+						v2 = (int)Math.sqrt(v1);
+						break;
+					case ABS:
+						v2 = (int)Math.abs(v1);
+						break;
+					case MINIMUM:
+						if (v1<value)
+							v2 = intValue;
+						else
+							v2 = v1;
+						break;
+					case MAXIMUM:
+						if (v1>value)
+							v2 = intValue;
+						else
+							v2 = v1;
+						break;
+					 default:
+					 	v2 = v1;
+				}
+				v2 += offset;
+				if (v2 < 0)
+					v2 = 0;
+				if (v2 > 65535)
+					v2 = 65535;
+				pixels[i++] = (short)v2;
+			}
+		}
+    }
+    
+	public void invert() {
+		int range = 65536;
+		int defaultRange = ij.ImagePlus.getDefault16bitRange();
+		if (defaultRange>0 && !isSigned16Bit())
+			range = (int)Math.pow(2,defaultRange);
+		setMinAndMax(0, range-1);
+		process(INVERT, 0.0);
+		resetMinAndMax();
+	}
+
+	public void add(int value) {process(ADD, value);}
+	public void add(double value) {process(ADD, value);}
+	public void set(double value) {process(SET, value);}
+	public void multiply(double value) {process(MULT, value);}
+	public void and(int value) {process(AND, value);}
+	public void or(int value) {process(OR, value);}
+	public void xor(int value) {process(XOR, value);}
+	public void gamma(double value) {process(GAMMA, value);}
+	public void log() {process(LOG, 0.0);}
+	public void exp() {process(EXP, 0.0);}
+	public void sqr() {process(SQR, 0.0);}
+	public void sqrt() {process(SQRT, 0.0);}
+	public void abs() {process(ABS, 0.0);}
+	public void min(double value) {process(MINIMUM, value);}
+	public void max(double value) {process(MAXIMUM, value);}
+
+	/** Fills the current rectangular ROI. */
+	public void fill() {
+		process(FILL, 0.0);
+	}
+
+	/** Fills pixels that are within roi and part of the mask.
+		Does nothing if the mask is not the same as the ROI. */
+	public void fill(ImageProcessor mask) {
+		if (mask==null)
+			{fill(); return;}
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		int roiX=this.roiX, roiY=this.roiY;
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			return;
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]!=0)
+					pixels[i] = (short)fgColor;
+				i++;
+			}
+		}
+	}
+
+	/** Does 3x3 convolution. */
+	public void convolve3x3(int[] kernel) {
+		filter3x3(CONVOLVE, kernel);
+	}
+
+	/** Filters using a 3x3 neighborhood. */
+	public void filter(int type) {
+		filter3x3(type, null);
+	}
+
+    /** 3x3 filter operations, code partly based on 3x3 convolution code
+     *  contributed by Glynne Casteel. */
+    void filter3x3(int type, int[] kernel) {
+        int v1, v2, v3;           //input pixel values around the current pixel
+        int v4, v5, v6;
+        int v7, v8, v9;
+        int k1=0, k2=0, k3=0;  //kernel values (used for CONVOLVE only)
+        int k4=0, k5=0, k6=0;
+        int k7=0, k8=0, k9=0;
+        int scale = 0;
+        if (type==CONVOLVE) {
+            k1=kernel[0]; k2=kernel[1]; k3=kernel[2];
+            k4=kernel[3]; k5=kernel[4]; k6=kernel[5];
+            k7=kernel[6]; k8=kernel[7]; k9=kernel[8];
+            for (int i=0; i<kernel.length; i++)
+                scale += kernel[i];
+            if (scale==0) scale = 1;
+        }
+
+        short[] pixels2 = (short[])getPixelsCopy();
+        int xEnd = roiX + roiWidth;
+        int yEnd = roiY + roiHeight;
+        for (int y=roiY; y<yEnd; y++) {
+            int p  = roiX + y*width;            //points to current pixel
+            int p6 = p - (roiX>0 ? 1 : 0);      //will point to v6, currently lower
+            int p3 = p6 - (y>0 ? width : 0);    //will point to v3, currently lower
+            int p9 = p6 + (y<height-1 ? width : 0); // ...  to v9, currently lower
+            v2 = pixels2[p3]&0xffff;
+            v5 = pixels2[p6]&0xffff;
+            v8 = pixels2[p9]&0xffff;
+            if (roiX>0) { p3++; p6++; p9++; }
+            v3 = pixels2[p3]&0xffff;
+            v6 = pixels2[p6]&0xffff;
+            v9 = pixels2[p9]&0xffff;
+
+            switch (type) {
+                case BLUR_MORE:
+                for (int x=roiX; x<xEnd; x++,p++) {
+                    if (x<width-1) { p3++; p6++; p9++; }
+                    v1 = v2; v2 = v3;
+                    v3 = pixels2[p3]&0xffff;
+                    v4 = v5; v5 = v6;
+                    v6 = pixels2[p6]&0xffff;
+                    v7 = v8; v8 = v9;
+                    v9 = pixels2[p9]&0xffff;
+                    pixels[p] = (short)((v1+v2+v3+v4+v5+v6+v7+v8+v9+4)/9);
+                }
+                break;
+                case FIND_EDGES:
+                for (int x=roiX; x<xEnd; x++,p++) {
+                    if (x<width-1) { p3++; p6++; p9++; }
+                    v1 = v2; v2 = v3;
+                    v3 = pixels2[p3]&0xffff;
+                    v4 = v5; v5 = v6;
+                    v6 = pixels2[p6]&0xffff;
+                    v7 = v8; v8 = v9;
+                    v9 = pixels2[p9]&0xffff;
+                    double sum1 = v1 + 2*v2 + v3 - v7 - 2*v8 - v9;
+                    double sum2 = v1  + 2*v4 + v7 - v3 - 2*v6 - v9;
+                    double result = Math.sqrt(sum1*sum1 + sum2*sum2);
+                    if (result>65535.0) result = 65535.0;
+                    pixels[p] = (short)result;
+                }
+                break;
+                case CONVOLVE:
+                for (int x=roiX; x<xEnd; x++,p++) {
+                    if (x<width-1) { p3++; p6++; p9++; }
+                    v1 = v2; v2 = v3;
+                    v3 = pixels2[p3]&0xffff;
+                    v4 = v5; v5 = v6;
+                    v6 = pixels2[p6]&0xffff;
+                    v7 = v8; v8 = v9;
+                    v9 = pixels2[p9]&0xffff;
+                    int sum = k1*v1 + k2*v2 + k3*v3
+                            + k4*v4 + k5*v5 + k6*v6
+                            + k7*v7 + k8*v8 + k9*v9;
+                    sum = (sum+scale/2)/scale;   //scale/2 for rounding
+                    if(sum>65535) sum = 65535;
+                    if(sum<0) sum = 0;
+                    pixels[p] = (short)sum;
+                }
+                break;
+            }
+        }
+    }
+
+	/** Rotates the image or ROI 'angle' degrees clockwise.
+		@see ImageProcessor#setInterpolate
+	*/
+	public void rotate(double angle) {
+		short[] pixels2 = (short[])getPixelsCopy();
+		ImageProcessor ip2 = null;
+		if (interpolationMethod==BICUBIC)
+			ip2 = new ShortProcessor(getWidth(), getHeight(), pixels2, null);
+		double centerX = roiX + (roiWidth-1)/2.0;
+		double centerY = roiY + (roiHeight-1)/2.0;
+		int xMax = roiX + this.roiWidth - 1;
+		
+		double angleRadians = -angle/(180.0/Math.PI);
+		double ca = Math.cos(angleRadians);
+		double sa = Math.sin(angleRadians);
+		double tmp1 = centerY*sa-centerX*ca;
+		double tmp2 = -centerX*sa-centerY*ca;
+		double tmp3, tmp4, xs, ys;
+		int index, ixs, iys;
+		double dwidth=width,dheight=height;
+		double xlimit = width-1.0, xlimit2 = width-1.001;
+		double ylimit = height-1.0, ylimit2 = height-1.001;
+		// zero is 32768 for signed images
+		int background = isSigned16Bit()?bgValue+32768:bgValue; 
+		
+		if (interpolationMethod==BICUBIC) {
+			for (int y=roiY; y<(roiY + roiHeight); y++) {
+				index = y*width + roiX;
+				tmp3 = tmp1 - y*sa + centerX;
+				tmp4 = tmp2 + y*ca + centerY;
+				for (int x=roiX; x<=xMax; x++) {
+					xs = x*ca + tmp3;
+					ys = x*sa + tmp4;
+					int value = (int)(getBicubicInterpolatedPixel(xs, ys, ip2)+0.5);
+					if (value<0) value = 0;
+					if (value>65535) value = 65535;
+					pixels[index++] = (short)value;
+				}
+			}
+		} else {
+			for (int y=roiY; y<(roiY + roiHeight); y++) {
+				index = y*width + roiX;
+				tmp3 = tmp1 - y*sa + centerX;
+				tmp4 = tmp2 + y*ca + centerY;
+				for (int x=roiX; x<=xMax; x++) {
+					xs = x*ca + tmp3;
+					ys = x*sa + tmp4;
+					if ((xs>=-0.01) && (xs<dwidth) && (ys>=-0.01) && (ys<dheight)) {
+						if (interpolationMethod==BILINEAR) {
+							if (xs<0.0) xs = 0.0;
+							if (xs>=xlimit) xs = xlimit2;
+							if (ys<0.0) ys = 0.0;			
+							if (ys>=ylimit) ys = ylimit2;
+							pixels[index++] = (short)(getInterpolatedPixel(xs, ys, pixels2)+0.5);
+						} else {
+							ixs = (int)(xs+0.5);
+							iys = (int)(ys+0.5);
+							if (ixs>=width) ixs = width - 1;
+							if (iys>=height) iys = height -1;
+							pixels[index++] = pixels2[width*iys+ixs];
+						}
+					} else
+						pixels[index++] = (short)background;
+				}
+			}
+		}
+	}
+
+	public void flipVertical() {
+		int index1,index2;
+		short tmp;
+		for (int y=0; y<roiHeight/2; y++) {
+			index1 = (roiY+y)*width+roiX;
+			index2 = (roiY+roiHeight-1-y)*width+roiX;
+			for (int i=0; i<roiWidth; i++) {
+				tmp = pixels[index1];
+				pixels[index1++] = pixels[index2];
+				pixels[index2++] = tmp;
+			}
+		}
+	}
+	
+	/** Scales the image or selection using the specified scale factors.
+		@see ImageProcessor#setInterpolationMethod
+	*/
+	public void scale(double xScale, double yScale) {
+		double xCenter = roiX + roiWidth/2.0;
+		double yCenter = roiY + roiHeight/2.0;
+		int xmin, xmax, ymin, ymax;
+		if ((xScale>1.0) && (yScale>1.0)) {
+			//expand roi
+			xmin = (int)(xCenter-(xCenter-roiX)*xScale);
+			if (xmin<0) xmin = 0;
+			xmax = xmin + (int)(roiWidth*xScale) - 1;
+			if (xmax>=width) xmax = width - 1;
+			ymin = (int)(yCenter-(yCenter-roiY)*yScale);
+			if (ymin<0) ymin = 0;
+			ymax = ymin + (int)(roiHeight*yScale) - 1;
+			if (ymax>=height) ymax = height - 1;
+		} else {
+			xmin = roiX;
+			xmax = roiX + roiWidth - 1;
+			ymin = roiY;
+			ymax = roiY + roiHeight - 1;
+		}
+		short[] pixels2 = (short[])getPixelsCopy();
+		ImageProcessor ip2 = null;
+		if (interpolationMethod==BICUBIC)
+			ip2 = new ShortProcessor(getWidth(), getHeight(), pixels2, null);
+		boolean checkCoordinates = (xScale < 1.0) || (yScale < 1.0);
+		short min2 = (short)getMin();
+		int index1, index2, xsi, ysi;
+		double ys, xs;
+		if (interpolationMethod==BICUBIC) {
+			for (int y=ymin; y<=ymax; y++) {
+				ys = (y-yCenter)/yScale + yCenter;
+				int index = y*width + xmin;
+				for (int x=xmin; x<=xmax; x++) {
+					xs = (x-xCenter)/xScale + xCenter;
+					int value = (int)(getBicubicInterpolatedPixel(xs, ys, ip2)+0.5);
+					if (value<0) value=0; if (value>65535) value=65535;
+					pixels[index++] = (short)value;
+				}
+			}
+		} else {
+			double xlimit = width-1.0, xlimit2 = width-1.001;
+			double ylimit = height-1.0, ylimit2 = height-1.001;
+			for (int y=ymin; y<=ymax; y++) {
+				ys = (y-yCenter)/yScale + yCenter;
+				ysi = (int)ys;
+				if (ys<0.0) ys = 0.0;			
+				if (ys>=ylimit) ys = ylimit2;
+				index1 = y*width + xmin;
+				index2 = width*(int)ys;
+				for (int x=xmin; x<=xmax; x++) {
+					xs = (x-xCenter)/xScale + xCenter;
+					xsi = (int)xs;
+					if (checkCoordinates && ((xsi<xmin) || (xsi>xmax) || (ysi<ymin) || (ysi>ymax)))
+						pixels[index1++] = min2;
+					else {
+						if (interpolationMethod==BILINEAR) {
+							if (xs<0.0) xs = 0.0;
+							if (xs>=xlimit) xs = xlimit2;
+							pixels[index1++] = (short)(getInterpolatedPixel(xs, ys, pixels2)+0.5);
+						} else
+							pixels[index1++] = pixels2[index2+xsi];
+					}
+				}
+			}
+		}
+	}
+
+	/** Uses bilinear interpolation to find the pixel value at real coordinates (x,y). */
+	private final double getInterpolatedPixel(double x, double y, short[] pixels) {
+		int xbase = (int)x;
+		int ybase = (int)y;
+		double xFraction = x - xbase;
+		double yFraction = y - ybase;
+		int offset = ybase * width + xbase;
+		int lowerLeft = pixels[offset]&0xffff;
+		int lowerRight = pixels[offset + 1]&0xffff;
+		int upperRight = pixels[offset + width + 1]&0xffff;
+		int upperLeft = pixels[offset + width]&0xffff;
+		double upperAverage = upperLeft + xFraction * (upperRight - upperLeft);
+		double lowerAverage = lowerLeft + xFraction * (lowerRight - lowerLeft);
+		return lowerAverage + yFraction * (upperAverage - lowerAverage);
+	}
+
+	/** Creates a new ShortProcessor containing a scaled copy of this image or selection. */
+	public ImageProcessor resize(int dstWidth, int dstHeight) {
+		if (roiWidth==dstWidth && roiHeight==dstHeight)
+			return crop();
+		if ((width==1||height==1) && interpolationMethod!=NONE)
+			return resizeLinearly(dstWidth, dstHeight);
+		double srcCenterX = roiX + roiWidth/2.0;
+		double srcCenterY = roiY + roiHeight/2.0;
+		double dstCenterX = dstWidth/2.0;
+		double dstCenterY = dstHeight/2.0;
+		double xScale = (double)dstWidth/roiWidth;
+		double yScale = (double)dstHeight/roiHeight;
+		if (interpolationMethod!=NONE) {
+			if (dstWidth!=width) dstCenterX+=xScale/4.0;
+			if (dstHeight!=height) dstCenterY+=yScale/4.0;
+		}
+		int inc = getProgressIncrement(dstWidth,dstHeight);
+		ImageProcessor ip2 = createProcessor(dstWidth, dstHeight);
+		short[] pixels2 = (short[])ip2.getPixels();
+		double xs, ys;
+		if (interpolationMethod==BICUBIC) {
+			for (int y=0; y<=dstHeight-1; y++) {
+				if (inc>0&&y%inc==0) showProgress((double)y/dstHeight);
+				ys = (y-dstCenterY)/yScale + srcCenterY;
+				int index2 = y*dstWidth;
+				for (int x=0; x<=dstWidth-1; x++) {
+					xs = (x-dstCenterX)/xScale + srcCenterX;
+					int value = (int)(getBicubicInterpolatedPixel(xs, ys, this)+0.5);
+					if (value<0) value=0; if (value>65535) value=65535;
+					pixels2[index2++] = (short)value;
+				}
+			}
+		} else {
+			double xlimit = width-1.0, xlimit2 = width-1.001;
+			double ylimit = height-1.0, ylimit2 = height-1.001;
+			int index1, index2;
+			for (int y=0; y<=dstHeight-1; y++) {
+				if (inc>0&&y%inc==0) showProgress((double)y/dstHeight);
+				ys = (y-dstCenterY)/yScale + srcCenterY;
+				if (interpolationMethod==BILINEAR) {
+					if (ys<0.0) ys = 0.0;
+					if (ys>=ylimit) ys = ylimit2;
+				}
+				index1 = width*(int)ys;
+				index2 = y*dstWidth;
+				for (int x=0; x<=dstWidth-1; x++) {
+					xs = (x-dstCenterX)/xScale + srcCenterX;
+					if (interpolationMethod==BILINEAR) {
+						if (xs<0.0) xs = 0.0;
+						if (xs>=xlimit) xs = xlimit2;
+						pixels2[index2++] = (short)(getInterpolatedPixel(xs, ys, pixels)+0.5);
+					} else
+						pixels2[index2++] = pixels[index1+(int)xs];
+				}
+			}
+		}
+		if (inc>0) showProgress(1.0);
+		return ip2;
+	}
+
+	public ImageProcessor crop() {
+		ImageProcessor ip2 = createProcessor(roiWidth, roiHeight);
+		short[] pixels2 = (short[])ip2.getPixels();
+		for (int ys=roiY; ys<roiY+roiHeight; ys++) {
+			int offset1 = (ys-roiY)*roiWidth;
+			int offset2 = ys*width+roiX;
+			for (int xs=0; xs<roiWidth; xs++)
+				pixels2[offset1++] = pixels[offset2++];
+		}
+        return ip2;
+	}
+	
+	/** Returns a duplicate of this image. */ 
+	public ImageProcessor duplicate() { 
+		ImageProcessor ip2 = createProcessor(width, height); 
+		short[] pixels2 = (short[])ip2.getPixels(); 
+		System.arraycopy(pixels, 0, pixels2, 0, width*height); 
+		return ip2; 
+	} 
+
+	/** Sets the foreground fill/draw color. */
+	public void setColor(Color color) {
+		drawingColor = color;
+		int bestIndex = getBestIndex(color);
+		if (bestIndex>0 && getMin()==0.0 && getMax()==0.0) {
+			setValue(bestIndex);
+			setMinAndMax(0.0,255.0);
+		} else if (bestIndex==0 && getMin()>0.0 && (color.getRGB()&0xffffff)==0) {
+			if (isSigned16Bit())
+				setValue(32768);
+			else
+				setValue(0.0);
+		} else
+			fgColor = (int)(getMin() + (getMax()-getMin())*(bestIndex/255.0));
+		fillValueSet = true;
+	}
+	
+	/** Sets the default fill/draw value, where 0<=value<=65535). */
+	public void setValue(double value) {
+			fgColor = (int)value;
+			if (fgColor<0) fgColor = 0;
+			if (fgColor>65535) fgColor = 65535;
+			fillValueSet = true;
+	}
+
+	/** Returns the foreground fill/draw value. */
+	public double getForegroundValue() {
+		return fgColor;
+	}
+
+	public void setBackgroundValue(double value) {
+		bgValue = (int)value;
+		if (bgValue<0) bgValue = 0;
+		if (bgValue>65535) bgValue = 65535;
+	}
+
+	public double getBackgroundValue() {
+		return bgValue;
+	}
+
+	/** Returns 65,536 bin histogram of the current ROI, which
+		can be non-rectangular. */
+	public int[] getHistogram() {
+		if (mask!=null)
+			return getHistogram(mask);
+		int roiX=this.roiX, roiY=this.roiY;
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		int[] histogram = new int[65536];
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y*width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++)
+					histogram[pixels[i++]&0xffff]++;
+		}
+		return histogram;
+	}
+
+	int[] getHistogram(ImageProcessor mask) {
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		int roiX=this.roiX, roiY=this.roiY;
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		byte[] mpixels = (byte[])mask.getPixels();
+		int[] histogram = new int[65536];
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int i = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				if (mpixels[mi++]!=0)
+					histogram[pixels[i]&0xffff]++;
+				i++;
+			}
+		}
+		return histogram;
+	}
+
+	/** Creates a histogram of length maxof(max+1,256). For small 
+		images or selections, computations using these histograms 
+		are faster compared to 65536 element histograms. */
+	int[] getHistogram2() {
+		if (mask!=null)
+			return getHistogram2(mask);
+		int roiX=this.roiX, roiY=this.roiY;
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		int max = 0;
+		int value;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int index = y*width + roiX;
+			for (int i=0; i<roiWidth; i++) {
+				value = pixels[index++]&0xffff;
+				if (value>max)
+					max = value;
+			}
+		}
+		int size = max + 1;
+		if (size<256) size = 256;
+		int[] histogram = new int[size];
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int index = y*width + roiX;
+			for (int i=0; i<roiWidth; i++)
+					histogram[pixels[index++]&0xffff]++;
+		}
+		return histogram;
+	}
+
+	private int[] getHistogram2(ImageProcessor mask) {
+		if (mask.getWidth()!=roiWidth||mask.getHeight()!=roiHeight)
+			throw new IllegalArgumentException(maskSizeError(mask));
+		int roiX=this.roiX, roiY=this.roiY;
+		int roiWidth=this.roiWidth, roiHeight=this.roiHeight;
+		byte[] mpixels = (byte[])mask.getPixels();		
+		int max = 0;
+		int value;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int index = y*width + roiX;
+			for (int i=0; i<roiWidth; i++) {
+				value = pixels[index++]&0xffff;
+				if (value>max)
+					max = value;
+			}
+		}
+		int size = max + 1;
+		if (size<256) size = 256;
+		int[] histogram = new int[size];
+		for (int y=roiY, my=0; y<(roiY+roiHeight); y++, my++) {
+			int index = y * width + roiX;
+			int mi = my * roiWidth;
+			for (int i=0; i<roiWidth; i++) {
+				if (mpixels[mi++]!=0)
+					histogram[pixels[index]&0xffff]++;
+				index++;
+			}
+		}
+		return histogram;
+	}
+	
+	public void setLutAnimation(boolean lutAnimation) {
+		this.lutAnimation = false;
+	}
+	
+	public void setThreshold(double minThreshold, double maxThreshold, int lutUpdate) {
+		if (minThreshold==NO_THRESHOLD) {
+			resetThreshold();
+			return;
+		}
+		if (minThreshold<0.0) minThreshold = 0.0;
+		if (maxThreshold>65535.0) maxThreshold = 65535.0;
+		int min2=(int)getMin(), max2=(int)getMax();
+		if (max2>min2) {
+			if (lutUpdate==OVER_UNDER_LUT) {
+				double minT = ((minThreshold-getMin())/(getMax()-getMin())*255.0);
+				double maxT = ((maxThreshold-getMin())/(getMax()-getMin())*255.0);
+				super.setThreshold(minT, maxT, lutUpdate); // update LUT
+			} else {
+				lutUpdateMode = lutUpdate;
+				if (rLUT1==null) {
+					if (cm==null)
+						makeDefaultColorModel();
+					baseCM = cm;
+					IndexColorModel m = (IndexColorModel)cm;
+					rLUT1 = new byte[256]; gLUT1 = new byte[256]; bLUT1 = new byte[256];
+					m.getReds(rLUT1); m.getGreens(gLUT1); m.getBlues(bLUT1);
+					rLUT2 = new byte[256]; gLUT2 = new byte[256]; bLUT2 = new byte[256];
+				}
+				if (lutUpdateMode==RED_LUT)
+					cm = getThresholdColorModel();
+				else
+					cm = getDefaultColorModel();
+			}
+		} else
+			super.resetThreshold();
+		this.minThreshold = Math.round(minThreshold);
+		this.maxThreshold = Math.round(maxThreshold);
+		//ij.IJ.log("setThreshold: "+lutUpdateMode+" "+this.minThreshold+" "+this.maxThreshold);
+	}
+	
+	/** Performs a convolution operation using the specified kernel. */
+	public void convolve(float[] kernel, int kernelWidth, int kernelHeight) {
+		ImageProcessor ip2 = convertToFloat();
+		ip2.setRoi(getRoi());
+		new ij.plugin.filter.Convolver().convolve(ip2, kernel, kernelWidth, kernelHeight);
+		ip2 = ip2.convertToShort(false);
+		short[] pixels2 = (short[])ip2.getPixels();
+		System.arraycopy(pixels2, 0, pixels, 0, pixels.length);
+	}
+
+    /** Adds pseudorandom, Gaussian ("normally") distributed values, with
+    	mean 0.0 and the specified standard deviation, to this image or ROI. */
+    public void noise(double standardDeviation) {
+		if (rnd==null)
+			rnd = new Random();
+		if (!Double.isNaN(seed))
+			rnd.setSeed((int) seed);
+		seed = Double.NaN;
+		int v, ran;
+		boolean inRange;
+		for (int y=roiY; y<(roiY+roiHeight); y++) {
+			int i = y * width + roiX;
+			for (int x=roiX; x<(roiX+roiWidth); x++) {
+				inRange = false;
+				do {
+					ran = (int)Math.round(rnd.nextGaussian()*standardDeviation);
+					v = (pixels[i] & 0xffff) + ran;
+					inRange = v>=0 && v<=65535;
+					if (inRange) pixels[i] = (short)v;
+				} while (!inRange);
+				i++;
+			}
+		}
+		resetMinAndMax();
+    }
+    
+	public void threshold(int level) {
+		for (int i=0; i<width*height; i++) {
+			if ((pixels[i]&0xffff)<=level)
+				pixels[i] = 0;
+			else
+				pixels[i] = (short)255;
+		}
+		findMinAndMax();
+	}
+
+	/** Returns a FloatProcessor with the same image, no scaling or calibration
+	*  (pixel values 0 to 65535).
+	*  The roi, mask, lut (ColorModel), threshold, min&max are
+	*  also set for the FloatProcessor
+	*  @param channelNumber   Ignored (needed for compatibility with ColorProcessor.toFloat)
+	*  @param fp              Here a FloatProcessor can be supplied, or null. The FloatProcessor
+	*                         is overwritten by this method (re-using its pixels array 
+	*                         improves performance).
+	*  @return A FloatProcessor with the converted image data
+	*/
+	public FloatProcessor toFloat(int channelNumber, FloatProcessor fp) {
+		int size = width*height;
+		if (fp == null || fp.getWidth()!=width || fp.getHeight()!=height)
+			fp = new FloatProcessor(width, height, new float[size], cm);
+		float[] fPixels = (float[])fp.getPixels();
+		for (int i=0; i<size; i++)
+			fPixels[i] = pixels[i]&0xffff;
+		fp.setRoi(getRoi());
+		fp.setMask(mask);
+		fp.setMinAndMax(getMin(), getMax());
+		fp.setThreshold(minThreshold, maxThreshold, ImageProcessor.NO_LUT_UPDATE);
+		return fp;
+	}
+	
+	/** Sets the pixels from a FloatProcessor, no scaling.
+	*  Also the min&max values are taken from the FloatProcessor.
+	*  @param channelNumber   Ignored (needed for compatibility with ColorProcessor.toFloat)
+	*  @param fp              The FloatProcessor where the image data are read from.
+	*/
+	public void setPixels(int channelNumber, FloatProcessor fp) {
+		float[] fPixels = (float[])fp.getPixels();
+		float value;
+		int size = width*height;
+		for (int i=0; i<size; i++) {
+			value = fPixels[i] + 0.5f;
+			if (value<0f) value = 0f;
+			if (value>65535f) value = 65535f;
+			pixels[i] = (short)value;
+		}
+		setMinAndMax(fp.getMin(), fp.getMax());
+	}
+		
+	/** Returns the maximum possible pixel value. */
+	public double maxValue() {
+		return 65535.0;
+	}
+
+	public int getBitDepth() {
+		return 16;
+	}
+
+	/** Returns 'true' if this is a signed 16-bit image. */
+	public boolean isSigned16Bit() {
+		return cTable!=null && cTable[0]==-32768f && cTable[1]==-32767f;
+	}
+	
+	/** Returns a binary mask, or null if a threshold is not set. */
+	public ByteProcessor createMask() {
+		if (getMinThreshold()==NO_THRESHOLD)
+			return null;
+		int minThreshold = (int)getMinThreshold();
+		int maxThreshold = (int)getMaxThreshold();
+		ByteProcessor mask = new ByteProcessor(width, height);
+		byte[] mpixels = (byte[])mask.getPixels();
+		for (int i=0; i<pixels.length; i++) {
+			int value = pixels[i]&0xffff;
+			if (value>=minThreshold && value<=maxThreshold)
+				mpixels[i] = (byte)255;
+		}
+		return mask;
+	}
+	
+	/** Not implemented. */
+	public void medianFilter() {}
+	/** Not implemented. */
+	public void erode() {}
+	/** Not implemented. */
+	public void dilate() {}
+
+}
+
diff --git a/src/ij/process/ShortStatistics.java b/src/ij/process/ShortStatistics.java
new file mode 100644
index 0000000..ab647a9
--- /dev/null
+++ b/src/ij/process/ShortStatistics.java
@@ -0,0 +1,224 @@
+package ij.process;
+import ij.measure.Calibration;
+import java.awt.Rectangle;
+
+/** 16-bit image statistics, including histogram. */
+public class ShortStatistics extends ImageStatistics {
+
+	/** Construct an ImageStatistics object from a ShortProcessor
+		using the standard measurement options (area, mean,
+		mode, min and max). */
+	public ShortStatistics(ImageProcessor ip) {
+		this(ip, AREA+MEAN+MODE+MIN_MAX, null);
+	}
+
+	/** Constructs a ShortStatistics object from a ShortProcessor using
+		the specified measurement options. The 'cal' argument, which
+		can be null, is currently ignored. */
+	public ShortStatistics(ImageProcessor ip, int mOptions, Calibration cal) {
+		this.width = ip.getWidth();
+		this.height = ip.getHeight();
+		setup(ip, cal);
+		nBins = 256;
+		double minT = ip.getMinThreshold();
+		int minThreshold,maxThreshold;
+		boolean limitToThreshold = (mOptions&LIMIT)!=0;
+		if (!limitToThreshold || minT==ImageProcessor.NO_THRESHOLD) {
+			minThreshold=0;
+			maxThreshold=65535;
+		} else {
+			minThreshold=(int)minT;
+			maxThreshold=(int)ip.getMaxThreshold();
+		}
+		if (limitToThreshold)
+			saveThreshold(minThreshold, maxThreshold, cal);
+		Rectangle r = ip.getRoi();
+		boolean smallRoi = r.width*r.height<250000;		
+		int[] hist = smallRoi&&(ip instanceof ShortProcessor)?((ShortProcessor)ip).getHistogram2():ip.getHistogram();
+		if (maxThreshold>hist.length-1)
+			maxThreshold = hist.length-1;
+		histogram16 = hist;
+		float[] cTable = cal!=null?cal.getCTable():null;
+		getRawMinAndMax(hist, minThreshold, maxThreshold);
+		histMin = min;
+		histMax = max;
+		getStatistics(ip, hist, (int)min, (int)max, cTable);
+		if ((mOptions&MODE)!=0)
+			getMode();
+		if ((mOptions&ELLIPSE)!=0 || (mOptions&SHAPE_DESCRIPTORS)!=0)
+			fitEllipse(ip, mOptions);
+		else if ((mOptions&CENTROID)!=0)
+			getCentroid(ip, minThreshold, maxThreshold);
+		if ((mOptions&(CENTER_OF_MASS|SKEWNESS|KURTOSIS))!=0)
+			calculateMoments(ip, minThreshold, maxThreshold, cTable);
+		if ((mOptions&MIN_MAX)!=0 && cTable!=null)
+			getCalibratedMinAndMax(hist, (int)min, (int)max, cTable);
+		if ((mOptions&MEDIAN)!=0) {
+			if (pixelCount>0)
+				calculateMedian(hist, minThreshold, maxThreshold, cal);
+			else
+				median = Double.NaN;
+		}
+		if ((mOptions&AREA_FRACTION)!=0)
+			calculateAreaFraction(ip, hist);
+	}
+
+	void getRawMinAndMax(int[] hist, int minThreshold, int maxThreshold) {
+		int min = minThreshold;
+		if (min<hist.length) {
+			while ((hist[min]==0) && (min<hist.length-1))
+				min++;
+		}
+		this.min = min;
+		int max = maxThreshold;
+		while ((hist[max]==0) && (max>0))
+			max--;
+		this.max = max;
+	}
+
+	void getStatistics(ImageProcessor ip, int[] hist, int min, int max, float[] cTable) {
+		int count;
+		double value;
+		double sum = 0.0;
+		double sum2 = 0.0;
+		nBins = ip.getHistogramSize();
+		histMin = ip.getHistogramMin();
+		histMax = ip.getHistogramMax();
+		if (histMin==0.0 && histMax==0.0) {
+			histMin = min; 
+			histMax = max;
+		} else {
+			if (min<histMin) min = (int)histMin;
+			if (max>histMax) max = (int)histMax;
+		}
+		binSize = (histMax-histMin)/nBins;
+		double scale = 1.0/binSize;
+		int hMin = (int)histMin;
+		histogram = new int[nBins]; // 256 bin histogram
+		int index;
+        int maxCount = 0;
+				
+		for (int i=min; i<=max; i++) {
+			count = hist[i];
+            if (count>maxCount) {
+                maxCount = count;
+                dmode = i;
+            }
+			pixelCount += count;
+			value = cTable==null?i:cTable[i];
+			sum += value*count;
+			sum2 += (value*value)*count;
+			index = (int)(scale*(i-hMin));
+			if (index>=nBins)
+				index = nBins-1;
+			histogram[index] += count;
+		}
+		area = pixelCount*pw*ph;
+		mean = sum/pixelCount;
+		umean = mean;
+		calculateStdDev(pixelCount, sum, sum2);
+        if (cTable!=null)
+        	dmode = cTable[(int)dmode];
+	}
+	
+	void getMode() {
+        int count;
+        maxCount = 0;
+        for (int i=0; i<nBins; i++) {
+        	count = histogram[i];
+            if (count > maxCount) {
+                maxCount = count;
+                mode = i;
+            }
+        }
+	}
+
+	void getCentroid(ImageProcessor ip, int minThreshold, int maxThreshold) {
+		short[] pixels = (short[])ip.getPixels();
+		byte[] mask = ip.getMaskArray();
+		boolean limit = minThreshold>0 || maxThreshold<65535;
+		int count=0, i, mi, v;
+		double xsum=0.0, ysum=0.0;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null||mask[mi++]!=0) {
+					if (limit) {
+						v = pixels[i]&0xffff;
+						if (v>=minThreshold&&v<=maxThreshold) {
+							count++;
+							xsum+=x;
+							ysum+=y;
+						}
+					} else {
+						count++;
+						xsum+=x;
+						ysum+=y;
+					}
+				}
+				i++;
+			}
+		}
+		xCentroid = xsum/count+0.5;
+		yCentroid = ysum/count+0.5;
+		if (cal!=null) {
+			xCentroid = cal.getX(xCentroid);
+			yCentroid = cal.getY(yCentroid, height);
+		}
+	}
+
+	void calculateMoments(ImageProcessor ip,  int minThreshold, int maxThreshold, float[] cTable) {
+		short[] pixels = (short[])ip.getPixels();
+		byte[] mask = ip.getMaskArray();
+		int i, mi, iv;
+		double v, v2, sum1=0.0, sum2=0.0, sum3=0.0, sum4=0.0, xsum=0.0, ysum=0.0;
+		for (int y=ry,my=0; y<(ry+rh); y++,my++) {
+			i = y*width + rx;
+			mi = my*rw;
+			for (int x=rx; x<(rx+rw); x++) {
+				if (mask==null || mask[mi++]!=0) {
+					iv = pixels[i]&0xffff;
+					if (iv>=minThreshold&&iv<=maxThreshold) {
+						v = cTable!=null?cTable[iv]:iv;
+						v2 = v*v;
+						sum1 += v;
+						sum2 += v2;
+						sum3 += v*v2;
+						sum4 += v2*v2;
+						xsum += x*v;
+						ysum += y*v;
+					}
+				}
+				i++;
+			}
+		}
+	    double mean2 = mean*mean;
+	    double variance = sum2/pixelCount - mean2;
+	    double sDeviation = Math.sqrt(variance);
+	    skewness = ((sum3 - 3.0*mean*sum2)/pixelCount + 2.0*mean*mean2)/(variance*sDeviation);
+	    kurtosis = (((sum4 - 4.0*mean*sum3 + 6.0*mean2*sum2)/pixelCount - 3.0*mean2*mean2)/(variance*variance)-3.0);
+		xCenterOfMass = xsum/sum1+0.5;
+		yCenterOfMass = ysum/sum1+0.5;
+		if (cal!=null) {
+			xCenterOfMass = cal.getX(xCenterOfMass);
+			yCenterOfMass = cal.getY(yCenterOfMass, height);
+		}
+	}
+
+	void getCalibratedMinAndMax(int[] hist, int minValue, int maxValue, float[] cTable) {
+		min = Double.MAX_VALUE;
+		max = -Double.MAX_VALUE;
+		double v = 0.0;
+		for (int i=minValue; i<=maxValue; i++) {
+			if (hist[i]>0) {
+				v = cTable[i];
+				if (v<min)
+					min = v;
+				if (v>max)
+					max = v;
+			}
+		}
+	}
+
+}
diff --git a/src/ij/process/StackConverter.java b/src/ij/process/StackConverter.java
new file mode 100644
index 0000000..2ab0fb5
--- /dev/null
+++ b/src/ij/process/StackConverter.java
@@ -0,0 +1,313 @@
+package ij.process;
+
+import java.awt.*;
+import java.awt.image.*;
+import ij.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.RGBStackConverter;
+
+/** This class does stack type conversions. */
+public class StackConverter {
+	ImagePlus imp;
+	int type, nSlices, width, height;
+
+	public StackConverter(ImagePlus imp) {
+		this.imp = imp;
+		type = imp.getType();
+		nSlices = imp.getStackSize();
+		if (nSlices<2)
+			throw new IllegalArgumentException("Stack required");
+		width = imp.getWidth();
+		height = imp.getHeight();
+	}
+	
+	/** Converts this Stack to 8-bit grayscale. */
+	public void convertToGray8() {
+		ImageStack stack1 = imp.getStack();
+		int currentSlice =  imp.getCurrentSlice();
+		ImageProcessor ip = imp.getProcessor();
+		boolean colorLut = ip.isColorLut();
+		boolean pseudoColorLut = colorLut && ip.isPseudoColorLut();
+		boolean composite = imp.isComposite();
+		if (type==ImagePlus.GRAY8 && pseudoColorLut && !composite) {
+ 			boolean invertedLut = ip.isInvertedLut();
+			ip.setColorModel(LookUpTable.createGrayscaleColorModel(invertedLut));
+			stack1.setColorModel(ip.getColorModel());
+	    	imp.updateAndDraw();
+			return;
+		}
+		if (!composite && (type==ImagePlus.COLOR_RGB||type==ImagePlus.COLOR_256||colorLut)) {
+			convertRGBToGray8();
+			imp.setSlice(currentSlice);
+			return;
+		}
+		
+		ImageStack stack2 = new ImageStack(width, height);
+		Image img;
+		String label;
+		double min = ip.getMin();
+		double max = ip.getMax();
+	    int inc = nSlices/20;
+	    if (inc<1) inc = 1;
+	    LUT[] luts = composite?((CompositeImage)imp).getLuts():null;
+		for(int i=1; i<=nSlices; i++) {
+			label = stack1.getSliceLabel(1);
+			ip = stack1.getProcessor(1);
+			stack1.deleteSlice(1);
+			if (luts!=null) {
+				int index = (i-1)%luts.length;
+				min = luts[index].min;
+				max = luts[index].max;
+			}
+			ip.setMinAndMax(min, max);
+			boolean scale = ImageConverter.getDoScaling();
+			stack2.addSlice(label, ip.convertToByte(scale));
+			if ((i%inc)==0) {
+				IJ.showProgress((double)i/nSlices);
+				IJ.showStatus("Converting to 8-bits: "+i+"/"+nSlices);
+			}
+		}
+		imp.setStack(null, stack2);
+		imp.setCalibration(imp.getCalibration()); //update calibration
+		if (imp.isComposite()) {
+			((CompositeImage)imp).resetDisplayRanges();
+			((CompositeImage)imp).updateAllChannelsAndDraw();
+		}
+		imp.setSlice(currentSlice);
+		IJ.showProgress(1.0);
+	}
+
+	/** Converts an RGB or 8-bit color stack to 8-bit grayscale. */
+	void convertRGBToGray8() {
+		ImageStack stack1 = imp.getStack();
+		if (stack1 instanceof PlotVirtualStack) {
+			((PlotVirtualStack)stack1).setBitDepth(8);
+			imp.setStack(stack1);
+			return;
+		}
+		ImageStack stack2 = new ImageStack(width, height);
+		ImageProcessor ip;
+		Image img;
+		String label;
+	    int inc = nSlices/20;
+	    if (inc<1) inc = 1;
+		for(int i=1; i<=nSlices; i++) {
+			label = stack1.getSliceLabel(1);
+			ip = stack1.getProcessor(1);
+			stack1.deleteSlice(1);
+			if (ip instanceof ByteProcessor)
+				ip = new ColorProcessor(ip.createImage());
+			boolean scale = ImageConverter.getDoScaling();
+			stack2.addSlice(label, ip.convertToByte(scale));
+			if ((i%inc)==0) {
+				IJ.showProgress((double)i/nSlices);
+				IJ.showStatus("Converting to 8-bits: "+i+"/"+nSlices);
+			}
+		}
+		imp.setStack(null, stack2);
+		IJ.showProgress(1.0);
+	}
+
+	/** Converts this Stack to 16-bit grayscale. */
+	public void convertToGray16() {
+		if (type==ImagePlus.GRAY16)
+			return;
+		if (!(type==ImagePlus.GRAY8 || type==ImagePlus.GRAY32))
+			throw new IllegalArgumentException("Unsupported conversion");
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(width, height);
+		String label;
+	    int inc = nSlices/20;
+	    if (inc<1) inc = 1;
+	    boolean scale = type==ImagePlus.GRAY32 && ImageConverter.getDoScaling();
+	    ImageProcessor ip1, ip2;
+		for(int i=1; i<=nSlices; i++) {
+			label = stack1.getSliceLabel(1);
+			ip1 = stack1.getProcessor(1);
+			ip2 = ip1.convertToShort(scale);
+			stack1.deleteSlice(1);
+			stack2.addSlice(label, ip2);
+			if ((i%inc)==0) {
+				IJ.showProgress((double)i/nSlices);
+				IJ.showStatus("Converting to 16-bits: "+i+"/"+nSlices);
+			}
+		}
+		IJ.showProgress(1.0);
+		imp.setStack(null, stack2);
+	}
+
+	/** Converts this Stack to 32-bit (float) grayscale. */
+	public void convertToGray32() {
+		if (type==ImagePlus.GRAY32)
+			return;
+		if (!(type==ImagePlus.GRAY8||type==ImagePlus.GRAY16||type==ImagePlus.COLOR_RGB))
+			throw new IllegalArgumentException("Unsupported conversion");
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(width, height);
+		String label;
+	    int inc = nSlices/20;
+	    if (inc<1) inc = 1;
+	    ImageProcessor ip1, ip2;
+	    Calibration cal = imp.getCalibration();
+		for(int i=1; i<=nSlices; i++) {
+			label = stack1.getSliceLabel(1);
+			ip1 = stack1.getProcessor(1);
+			ip1.setCalibrationTable(cal.getCTable());
+			ip2 = ip1.convertToFloat();
+			stack1.deleteSlice(1);
+			stack2.addSlice(label, ip2);
+			if ((i%inc)==0) {
+				IJ.showProgress((double)i/nSlices);
+				IJ.showStatus("Converting to 32-bits: "+i+"/"+nSlices);
+			}
+		}
+		IJ.showProgress(1.0);
+		imp.setStack(null, stack2);
+		imp.setCalibration(imp.getCalibration()); //update calibration
+		if (type==ImagePlus.COLOR_RGB) {
+			imp.resetDisplayRange();
+			imp.updateAndDraw();
+		}
+	}
+
+	/** Converts the Stack to RGB. */
+	public void convertToRGB() {
+		int z = imp.getNSlices();
+		int t = imp.getNFrames();
+		if (imp.isComposite()) {
+			RGBStackConverter.convertToRGB(imp);
+			return;
+		}
+		ImageStack stack1 = imp.getStack();
+		if (stack1 instanceof PlotVirtualStack) {
+			((PlotVirtualStack)stack1).setBitDepth(24);
+			imp.setStack(stack1);
+			return;
+		}
+		ImageStack stack2 = new ImageStack(width, height);
+		String label;
+	    int inc = nSlices/20;
+	    if (inc<1) inc = 1;
+	    ImageProcessor ip1, ip2;
+	    Calibration cal = imp.getCalibration();
+		for(int i=1; i<=nSlices; i++) {
+			label = stack1.getSliceLabel(i);
+			ip1 = stack1.getProcessor(i);
+			ip2 = ip1.convertToRGB();
+			stack2.addSlice(label, ip2);
+			if ((i%inc)==0) {
+				IJ.showProgress((double)i/nSlices);
+				IJ.showStatus("Converting to RGB: "+i+"/"+nSlices);
+			}
+		}
+		IJ.showProgress(1.0);
+		imp.setStack(null, stack2);
+		imp.setDimensions(1, z, t);
+		imp.setCalibration(imp.getCalibration()); //update calibration
+	}
+
+	/** Converts the stack (which must be RGB) to a 
+		3 channel (red, green and blue) hyperstack. */
+	public void convertToRGBHyperstack() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("RGB stack required");
+		new ij.plugin.CompositeConverter().run("composite");
+	}
+
+	/** Converts the stack (which must be RGB) to a 3 channel 
+		(hue, saturation and brightness) hyperstack. */
+	public void convertToHSBHyperstack() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("RGB stack required");
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(width,height);
+		int nSlices = stack1.getSize();
+		Calibration cal = imp.getCalibration();
+		int inc = nSlices/20;
+		if (inc<1) inc = 1;
+		for(int i=1; i<=nSlices; i++) {
+			String label = stack1.getSliceLabel(i);
+			ColorProcessor cp = (ColorProcessor)stack1.getProcessor(i);
+			ImageStack stackHSB = cp.getHSBStack();
+			stack2.addSlice(label,stackHSB.getProcessor(1));
+			stack2.addSlice(label,stackHSB.getProcessor(2));
+			stack2.addSlice(label,stackHSB.getProcessor(3));
+			if ((i%inc)==0) {
+				IJ.showProgress((double)i/nSlices);
+				IJ.showStatus("Converting to HSB: "+i+"/"+nSlices);
+			}
+		}
+		IJ.showProgress(1.0);
+		imp.setStack(null,stack2);
+		imp.setProp("HSB_Stack", "true");
+		imp.setCalibration(cal);
+		imp.setDimensions(3, nSlices, 1);
+		CompositeImage ci = new CompositeImage(imp, IJ.GRAYSCALE);
+		ci.show();
+		imp.hide();
+	}
+
+	/** Converts the stack (which must be RGB) to a 3 channel 
+		(hue, saturation and brightness) 32-bit hyperstack. */
+	public void convertToHSB32Hyperstack() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("RGB stack required");
+		ImageStack stack1 = imp.getStack();
+		ImageStack stack2 = new ImageStack(width,height);
+		int nSlices = stack1.getSize();
+		Calibration cal = imp.getCalibration();
+		int inc = nSlices/20;
+		if (inc<1) inc = 1;
+		for(int i=1; i<=nSlices; i++) {
+			String label = stack1.getSliceLabel(i);
+			ColorProcessor cp = (ColorProcessor)stack1.getProcessor(i);
+			ImageStack stackHSB = cp.getHSB32Stack();
+			stack2.addSlice(label,stackHSB.getProcessor(1));
+			stack2.addSlice(label,stackHSB.getProcessor(2));
+			stack2.addSlice(label,stackHSB.getProcessor(3));
+			if ((i%inc)==0) {
+				IJ.showProgress((double)i/nSlices);
+				IJ.showStatus("Converting to HSB: "+i+"/"+nSlices);
+			}
+		}
+		IJ.showProgress(1.0);
+		imp.setStack(null,stack2);
+		imp.setCalibration(cal);
+		imp.setDimensions(3, nSlices, 1);
+		CompositeImage ci = new CompositeImage(imp, IJ.GRAYSCALE);
+		ci.show();
+		imp.hide();
+	}
+	
+	/** Converts the stack (which must be RGB) to a 3 channel 
+		Lab hyperstack. */
+	public void convertToLabHyperstack() {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("RGB stack required");
+		if (imp!=null)
+			throw new IllegalArgumentException("Stacks currently not supported");
+	}
+
+	/** Converts the stack to 8-bits indexed color. 'nColors' must
+		be greater than 1 and less than or equal to 256. */
+	public void convertToIndexedColor(int nColors) {
+		if (type!=ImagePlus.COLOR_RGB)
+			throw new IllegalArgumentException("RGB stack required");
+		ImageStack stack = imp.getStack();
+		int size = stack.size();
+		ImageProcessor montage = new ColorProcessor(width*size, height);
+        for (int i=0; i<size; i++)
+            montage.insert(stack.getProcessor(i+1), i*width, 0);
+        MedianCut mc = new MedianCut((ColorProcessor)montage);
+        montage = mc.convertToByte(nColors);
+        ImageStack stack2 = new ImageStack(width, height);
+        for (int i=0; i<size; i++) {
+            montage.setRoi(i*width, 0, width, height);
+            stack2.addSlice(null, montage.crop());
+        }
+		imp.setStack(null, stack2);
+		imp.setTypeToColor256();
+	}
+
+}
diff --git a/src/ij/process/StackProcessor.java b/src/ij/process/StackProcessor.java
new file mode 100644
index 0000000..203c289
--- /dev/null
+++ b/src/ij/process/StackProcessor.java
@@ -0,0 +1,369 @@
+package ij.process;
+import java.awt.*;
+import ij.*;
+import ij.process.*;
+import ij.macro.Interpreter;
+import ij.util.ArrayUtil;
+import ij.plugin.Filters3D;
+import java.util.concurrent.atomic.AtomicInteger;
+
+
+/** This class processes stacks. */
+public class StackProcessor {
+    public final static int FILTER_MEAN=Filters3D.MEAN, FILTER_MEDIAN=Filters3D.MEDIAN, FILTER_MIN=Filters3D.MIN,
+		FILTER_MAX=Filters3D.MAX, FILTER_VAR=Filters3D.VAR, FILTER_MAXLOCAL=Filters3D.MAXLOCAL;
+
+    private ImageStack stack;
+    private ImageProcessor ip;
+	int nSlices;
+	double xScale, yScale;
+	int[] table;
+	double fillValue;
+	float[] voxels;
+	    
+    /** Constructs a StackProcessor from a stack. */
+    public StackProcessor(ImageStack stack) {
+    	this(stack, null);
+    }
+
+    /** Constructs a StackProcessor from a stack. 'ip' is the
+    	processor that will be used to process the slices. 
+    	'ip' can be null when using crop(). */
+    public StackProcessor(ImageStack stack, ImageProcessor ip) {
+    	this.stack = stack;
+    	this.ip = ip;
+    	nSlices = stack.size();
+ 	    if (nSlices>1 && ip!=null)
+ 	    	ip.setProgressBar(null);
+   }
+	
+	static final int FLIPH=0, FLIPV=1, SCALE=2, INVERT=3, APPLY_TABLE=4, SCALE_WITH_FILL=5;
+	
+	void process(int command) {
+	    String s = "";
+ 	   	ImageProcessor ip2 = stack.getProcessor(1);
+    	switch (command) {
+    		case FLIPH: case FLIPV: s="Flip: "; break;
+    		case SCALE: s="Scale: "; break;
+    		case SCALE_WITH_FILL: s="Scale: "; ip2.setBackgroundValue(fillValue); break;
+    		case INVERT: s="Invert: "; break;
+    		case APPLY_TABLE: s="Apply: "; break;
+    	}
+    	if (ip==null)
+    		ip = ip2;
+ 	   	ip2.setRoi(this.ip.getRoi());
+	    ip2.setInterpolate(this.ip.getInterpolate());
+	    for (int i=1; i<=nSlices; i++) {
+    		showStatus(s,i,nSlices);
+	    	ip2.setPixels(stack.getPixels(i));
+	    	if (nSlices==1 && i==1 && command==SCALE)
+	    		ip2.snapshot();
+	    	switch (command) {
+	    		case FLIPH: ip2.flipHorizontal(); break;
+	    		case FLIPV: ip2.flipVertical(); break;
+	    		case SCALE: case SCALE_WITH_FILL: ip2.scale(xScale, yScale); break;
+	    		case INVERT: ip2.invert(); break;
+	    		case APPLY_TABLE: ip2.applyTable(table); break;
+	    	}
+			IJ.showProgress((double)i/nSlices);
+	    }
+		IJ.showProgress(1.0);
+	}
+
+	public void invert() {
+		process(INVERT);
+	}
+	
+	public void flipHorizontal() {
+		process(FLIPH);
+	}
+	
+	public void flipVertical() {
+		process(FLIPV);
+	}
+	
+	public void applyTable(int[] table) {
+		this.table = table;
+		process(APPLY_TABLE);
+	}
+
+	public void scale(double xScale, double yScale) {
+		this.xScale = xScale;
+		this.yScale = yScale;
+		process(SCALE);
+ 	}
+
+	public void scale(double xScale, double yScale, double fillValue) {
+		this.xScale = xScale;
+		this.yScale = yScale;
+		this.fillValue = fillValue;
+		process(SCALE_WITH_FILL);
+ 	}
+
+	/** Creates a new stack with dimensions 'newWidth' x 'newHeight'.
+		To reduce memory requirements, the orginal stack is deleted
+		as the new stack is created. */
+	public ImageStack resize(int newWidth, int newHeight) {
+		return resize(newWidth, newHeight, false);
+	}
+
+	public ImageStack resize(int newWidth, int newHeight, boolean averageWhenDownsizing) {
+	    ImageStack stack2 = new ImageStack(newWidth, newHeight);
+ 		ImageProcessor ip2;
+ 		Rectangle roi = ip!=null?ip.getRoi():null;
+    	if (ip==null)
+    		ip = stack.getProcessor(1).duplicate();
+		try {
+	    	for (int i=1; i<=nSlices; i++) {
+    			showStatus("Resize: ",i,nSlices);
+	    		ip.setPixels(stack.getPixels(1));
+	    		String label = stack.getSliceLabel(1);
+	    		stack.deleteSlice(1);
+				ip2 = ip.resize(newWidth, newHeight, averageWhenDownsizing);
+				if (ip2!=null)
+					stack2.addSlice(label, ip2);
+				IJ.showProgress((double)i/nSlices);
+	    	}
+			IJ.showProgress(1.0);
+		} catch(OutOfMemoryError o) {
+			while(stack.size()>1)
+				stack.deleteLastSlice();
+			IJ.outOfMemory("StackProcessor.resize");
+			IJ.showProgress(1.0);
+		}
+		return stack2;
+	}
+
+	/** Crops the stack to the specified rectangle. */
+	public ImageStack crop(int x, int y, int width, int height) {
+	    ImageStack stack2 = new ImageStack(width, height);
+ 		ImageProcessor ip2;
+		for (int i=1; i<=nSlices; i++) {
+			ImageProcessor ip1 = stack.getProcessor(1);
+			ip1.setRoi(x, y, width, height);
+			String label = stack.getSliceLabel(1);
+			stack.deleteSlice(1);
+			ip2 = ip1.crop();
+			stack2.addSlice(label, ip2);
+			IJ.showProgress((double)i/nSlices);
+		}
+		IJ.showProgress(1.0);
+		return stack2;
+	}
+
+	ImageStack rotate90Degrees(boolean clockwise) {
+ 	    ImageStack stack2 = new ImageStack(stack.getHeight(), stack.getWidth());
+ 		ImageProcessor ip2;
+    	if (ip==null)
+    		ip = stack.getProcessor(1).duplicate();
+    	for (int i=1; i<=nSlices; i++) {
+    		showStatus("Rotate: ",i,nSlices);
+    		ip.setPixels(stack.getPixels(1));
+    		String label = stack.getSliceLabel(1);
+    		stack.deleteSlice(1);
+			if (clockwise)
+				ip2 = ip.rotateRight();
+			else
+				ip2 = ip.rotateLeft();
+			if (ip2!=null)
+				stack2.addSlice(label, ip2);
+			if (!Interpreter.isBatchMode())
+				IJ.showProgress((double)i/nSlices);
+    	}
+		if (!Interpreter.isBatchMode())
+			IJ.showProgress(1.0);
+		return stack2;
+	}
+	
+	public ImageStack rotateRight() {
+		return rotate90Degrees(true);
+ 	}
+ 	
+	public ImageStack rotateLeft() {
+		return rotate90Degrees(false);
+ 	}
+ 	
+ 	public void copyBits(ImageProcessor src, int xloc, int yloc, int mode) {
+ 		copyBits(src, null, xloc, yloc, mode);
+ 	}
+
+ 	public void copyBits(ImageStack src, int xloc, int yloc, int mode) {
+ 		copyBits(null, src, xloc, yloc, mode);
+ 	}
+
+ 	private void copyBits(ImageProcessor srcIp, ImageStack srcStack, int xloc, int yloc, int mode) {
+	    int inc = nSlices/20;
+	    if (inc<1) inc = 1;
+	    boolean stackSource = srcIp==null;
+	    for (int i=1; i<=nSlices; i++) {
+	    	if (stackSource)
+	    		srcIp = srcStack.getProcessor(i);
+ 	    	ImageProcessor dstIp = stack.getProcessor(i);
+	    	dstIp.copyBits(srcIp, xloc, yloc, mode);
+			if ((i%inc) == 0) IJ.showProgress((double)i/nSlices);
+	    }
+		IJ.showProgress(1.0);
+ 	}
+ 	
+ 	void showStatus(String s, int n, int total) {
+ 		IJ.showStatus(s+n+"/"+total);
+ 	}	
+ 	
+    /**
+     * Thomas Boudier Create a kernel neighorhood as an ellipsoid
+     *
+     * @param radx Radius x of the ellipsoid
+     * @param rady Radius x of the ellipsoid
+     * @param radz Radius x of the ellipsoid
+     * @return The kernel as an array
+     */
+    private int[] createKernelEllipsoid(float radx, float rady, float radz) {
+        int vx = (int) Math.ceil(radx);
+        int vy = (int) Math.ceil(rady);
+        int vz = (int) Math.ceil(radz);
+        int[] ker = new int[(2 * vx + 1) * (2 * vy + 1) * (2 * vz + 1)];
+        double dist;
+
+        double rx2 = radx * radx;
+        double ry2 = rady * rady;
+        double rz2 = radz * radz;
+
+        if (rx2 != 0) {
+            rx2 = 1.0 / rx2;
+        } else {
+            rx2 = 0;
+        }
+        if (ry2 != 0) {
+            ry2 = 1.0 / ry2;
+        } else {
+            ry2 = 0;
+        }
+        if (rz2 != 0) {
+            rz2 = 1.0 / rz2;
+        } else {
+            rz2 = 0;
+        }
+
+        int idx = 0;
+        for (int k = -vz; k <= vz; k++) {
+            for (int j = -vy; j <= vy; j++) {
+                for (int i = -vx; i <= vx; i++) {
+                    dist = ((double) (i * i)) * rx2 + ((double) (j * j)) * ry2 + ((double) (k * k)) * rz2;
+                    if (dist <= 1.0) {
+                        ker[idx] = 1;
+                    } else {
+                        ker[idx] = 0;
+                    }
+                    idx++;
+                }
+            }
+        }
+
+        return ker;
+    }
+
+    /**
+     * 3D filter using threads
+     *
+     * @param out
+     * @param radx Radius of mean filter in x
+     * @param rady Radius of mean filter in y
+     * @param radz Radius of mean filter in z
+     * @param zmin
+     * @param zmax
+     * @param filter
+     */
+    public void filter3D(ImageStack out, float radx, float rady, float radz, int zmin, int zmax, int filter) {
+        int[] ker = this.createKernelEllipsoid(radx, rady, radz);
+        int nb = 0;
+        for (int i=0; i<ker.length; i++)
+            nb += ker[i];
+        if (zmin<0)
+            zmin = 0;
+        if (zmax>stack.size())
+            zmax = stack.size();
+        int sizex = stack.getWidth();
+        int sizey = stack.getHeight();
+        double value;
+        for (int z=zmin; z<zmax; z++) {
+            if (zmin==0) IJ.showProgress(z+1, zmax);
+            for (int y=0; y<sizey; y++) {
+                for (int x=0; x<sizex; x++) {
+                    ArrayUtil tab = getNeighborhood(ker, nb, x, y, z, radx, rady, radz);
+                    switch (filter) {
+						case FILTER_MEAN:
+							out.setVoxel(x, y, z, tab.getMean()); break;
+						case FILTER_MEDIAN:
+							out.setVoxel(x, y, z, tab.medianSort()); break;
+						case FILTER_MIN:
+							out.setVoxel(x, y, z, tab.getMinimum()); break;
+						case FILTER_MAX:
+							out.setVoxel(x, y, z, tab.getMaximum()); break;
+						case FILTER_VAR:
+							out.setVoxel(x, y, z, tab.getVariance()); break;
+						case FILTER_MAXLOCAL:
+							value = stack.getVoxel(x, y, z);
+							if (tab.isMaximum(value))
+								out.setVoxel(x, y, z, value);
+							else
+								out.setVoxel(x, y, z, 0);
+							break;
+                    } //switch
+                }  //x
+            } //y
+        } //z
+    }
+
+    /*
+    private ArrayUtil getNeighborhood(int[] ker, int nbval, int x, int y, int z, float radx, float rady, float radz) {
+        int vx = (int)Math.ceil(radx);
+        int vy = (int)Math.ceil(rady);
+        int vz = (int)Math.ceil(radz);
+        int x0=x-vx, y0=y-vy, z0=z-vz;
+        int w=vx*2, h=vy*2, d=vz*2;
+		if (x0<0 || x0+w>stack.getWidth() || y0<0 || y0+h>stack.getHeight() || z0<0 || z0+d>stack.size())
+			return getEdgeNeighborhood(ker, nbval, x, y, z, radx, rady, radz);
+        voxels = stack.getVoxels(x0, y0, z0, w, h, d, voxels);
+		return new ArrayUtil(voxels);
+    }
+    */
+
+    /**
+     * Gets the neighboring attribute of the Image3D with a kernel as a array
+     *
+     * @param ker The kernel array (>0 ok)
+     * @param nbval The number of non-zero values
+     * @param x Coordinate x of the pixel
+     * @param y Coordinate y of the pixel
+     * @param z Coordinate z of the pixel
+     * @param radx Radius x of the neighboring
+     * @param radz Radius y of the neighboring
+     * @param rady Radius z of the neighboring
+     * @return The values of the nieghbor pixels inside an array
+     */
+    private ArrayUtil getNeighborhood(int[] ker, int nbval, int x, int y, int z, float radx, float rady, float radz) {
+        ArrayUtil pix = new ArrayUtil(nbval);
+        int vx = (int) Math.ceil(radx);
+        int vy = (int) Math.ceil(rady);
+        int vz = (int) Math.ceil(radz);
+        int index = 0;
+        int c = 0;
+        int sizex = stack.getWidth();
+        int sizey = stack.getHeight();
+        int sizez = stack.size();
+        for (int k = z - vz; k <= z + vz; k++) {
+            for (int j = y - vy; j <= y + vy; j++) {
+                for (int i = x - vx; i <= x + vx; i++) {
+					if (ker[c]>0 && i>=0 && j>=0 && k>=0 && i<sizex && j<sizey && k<sizez) {
+						pix.putValue(index, (float)stack.getVoxel(i, j, k));
+						index++;
+					}
+                    c++;
+                }
+            }
+        }
+        pix.setSize(index);
+        return pix;
+    }
+    
+ }
diff --git a/src/ij/process/StackStatistics.java b/src/ij/process/StackStatistics.java
new file mode 100644
index 0000000..1e6dccc
--- /dev/null
+++ b/src/ij/process/StackStatistics.java
@@ -0,0 +1,359 @@
+package ij.process;
+import ij.*;
+import ij.gui.*;
+import ij.measure.*;
+import ij.plugin.filter.Analyzer;
+import java.awt.*;
+
+/** Statistics, including the histogram, of a stack. */
+public class StackStatistics extends ImageStatistics {
+	
+	/** Creates a StackStatistics object from a stack, using 256 
+		histogram bins and the entire stack pixel value range. */
+	public StackStatistics(ImagePlus imp) {
+		this(imp, 256, 0.0, imp.getBitDepth()==8||imp.getBitDepth()==24?256.0:0.0);
+	}
+
+	/** Creates a StackStatistics object from a stack, using the specified 
+		histogram bin count and x-axis range (pixel value tange). */
+	public StackStatistics(ImagePlus imp, int nBins, double xMin, double xMax) {
+		int bits = imp.getBitDepth();
+		stackStatistics = true;
+		if ((bits==8||bits==24) && nBins==256 && xMin==0.0 && xMax==256.0)
+			sum8BitHistograms(imp);
+		else if (bits==16 && nBins==256 && xMin==0.0 && xMax==0.0 && !imp.getCalibration().calibrated())
+			sum16BitHistograms(imp);
+		else
+			doCalculations(imp, nBins, xMin, xMax);
+	}
+
+    void doCalculations(ImagePlus imp,  int bins, double histogramMin, double histogramMax) {
+       ImageProcessor ip = imp.getProcessor();
+		boolean limitToThreshold = (Analyzer.getMeasurements()&LIMIT)!=0;
+		double minThreshold = -Float.MAX_VALUE;
+		double maxThreshold = Float.MAX_VALUE;
+        Calibration cal = imp.getCalibration();
+		if (limitToThreshold && ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+			minThreshold=cal.getCValue(ip.getMinThreshold());
+			maxThreshold=cal.getCValue(ip.getMaxThreshold());
+		}
+    	nBins = bins;
+    	histMin = histogramMin;
+    	histMax = histogramMax;
+        ImageStack stack = imp.getStack();
+        int size = stack.size();
+        ip.setRoi(imp.getRoi());
+        byte[] mask = ip.getMaskArray();
+        float[] cTable = imp.getCalibration().getCTable();
+        longHistogram = new long[nBins];
+        double v;
+        double sum = 0;
+        double sum2 = 0;
+        int width, height;
+        int rx, ry, rw, rh;
+        double pw, ph;
+        
+        width = ip.getWidth();
+        height = ip.getHeight();
+        Rectangle roi = ip.getRoi();
+        if (roi != null) {
+            rx = roi.x;
+            ry = roi.y;
+            rw = roi.width;
+            rh = roi.height;
+        } else {
+            rx = 0;
+            ry = 0;
+            rw = width;
+            rh = height;
+        }
+        
+        pw = 1.0;
+        ph = 1.0;
+        roiX = rx*pw;
+        roiY = ry*ph;
+        roiWidth = rw*pw;
+        roiHeight = rh*ph;
+        boolean fixedRange = histMin!=0 || histMax!=0.0;
+        
+        // calculate min and max
+		double roiMin = Double.MAX_VALUE;
+		double roiMax = -Double.MAX_VALUE;
+		for (int slice=1; slice<=size; slice++) {
+			IJ.showStatus("Calculating stack histogram...");
+			IJ.showProgress(slice/2, size);
+			ip = stack.getProcessor(slice);
+			//ip.setCalibrationTable(cTable);
+			for (int y=ry, my=0; y<(ry+rh); y++, my++) {
+				int i = y * width + rx;
+				int mi = my * rw;
+				for (int x=rx; x<(rx+rw); x++) {
+					if (mask==null || mask[mi++]!=0) {
+						v = ip.getPixelValue(x,y);
+						if (v>=minThreshold && v<=maxThreshold) {
+							if (v<roiMin)
+								roiMin = v;
+							if (v>roiMax)
+								roiMax = v;
+						}
+					}
+					i++;
+				}
+			}
+		 }
+		min = roiMin;
+		max = roiMax;
+		if (fixedRange) {
+			if (min<histMin) min = histMin;
+			if (max>histMax) max = histMax;
+		} else {
+			histMin = min; 
+			histMax =  max;
+		}
+       
+        // Generate histogram
+        double scale = nBins/( histMax-histMin);
+        pixelCount = 0;
+        int index;
+        boolean first = true;
+        for (int slice=1; slice<=size; slice++) {
+            IJ.showProgress(size/2+slice/2, size);
+            ip = stack.getProcessor(slice);
+            ip.setCalibrationTable(cTable);
+            for (int y=ry, my=0; y<(ry+rh); y++, my++) {
+                int i = y * width + rx;
+                int mi = my * rw;
+                for (int x=rx; x<(rx+rw); x++) {
+                    if (mask==null || mask[mi++]!=0) {
+                        v = ip.getPixelValue(x,y);
+						if (v>=minThreshold && v<=maxThreshold && v>=histMin && v<=histMax) {
+							longPixelCount++;
+							sum += v;
+							sum2 += v*v;
+							index = (int)(scale*(v-histMin));
+							if (index>=nBins)
+								index = nBins-1;
+							longHistogram[index]++;
+						}
+                    }
+                    i++;
+                }
+            }
+        }
+        pixelCount = (int)longPixelCount;
+        area = longPixelCount*pw*ph;
+        mean = sum/longPixelCount;
+        calculateStdDev(longPixelCount, sum, sum2);
+        histMin = cal.getRawValue(histMin); 
+        histMax =  cal.getRawValue(histMax);
+        binSize = (histMax-histMin)/nBins;
+        int bits = imp.getBitDepth();
+        if (histMin==0.0 && histMax==256.0 && (bits==8||bits==24))
+        	histMax = 255.0;
+        dmode = getMode(cal);
+		copyHistogram(nBins);
+		median = getMedian(longHistogram, (int)minThreshold, (int)maxThreshold, cal);
+        IJ.showStatus("");
+        IJ.showProgress(1.0);
+    }
+    
+	void sum8BitHistograms(ImagePlus imp) {
+		Calibration cal = imp.getCalibration();
+		boolean limitToThreshold = (Analyzer.getMeasurements()&LIMIT)!=0;
+		int minThreshold = 0;
+		int maxThreshold = 255;
+		ImageProcessor ip = imp.getProcessor();
+		if (limitToThreshold && ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+			minThreshold = (int)ip.getMinThreshold();
+			maxThreshold = (int)ip.getMaxThreshold();
+		}
+		ImageStack stack = imp.getStack();
+		Roi roi = imp.getRoi();
+		longHistogram = new long[256];
+		int n = stack.size();
+		for (int slice=1; slice<=n; slice++) {
+			IJ.showProgress(slice, n);
+			ip = stack.getProcessor(slice);
+			if (roi!=null) ip.setRoi(roi);
+			int[] hist = ip.getHistogram();
+			for (int i=0; i<256; i++)
+				longHistogram[i] += hist[i];
+		}
+		pw=1.0; ph=1.0;
+		getRawStatistics(longHistogram, minThreshold, maxThreshold);
+		getRawMinAndMax(longHistogram, minThreshold, maxThreshold);
+		copyHistogram(256);
+		median = getMedian(longHistogram, minThreshold, maxThreshold, cal);
+		IJ.showStatus("");
+		IJ.showProgress(1.0);
+	}
+	
+	private void copyHistogram(int nbins) {
+		histogram = new int[nbins];
+		for (int i=0; i<nbins; i++) {
+			long count = longHistogram[i];
+			if (count<=Integer.MAX_VALUE)
+				histogram[i] = (int)count;
+			else
+				histogram[i] = Integer.MAX_VALUE;
+		}
+	}
+
+	void getRawStatistics(long[] histogram, int minThreshold, int maxThreshold) {
+		long count;
+		long longMaxCount = 0L;
+		double value;
+		double sum = 0.0;
+		double sum2 = 0.0;
+		
+		for (int i=minThreshold; i<=maxThreshold; i++) {
+			count = histogram[i];
+			longPixelCount += count;
+			sum += (double)i*count;
+			value = i;
+			sum2 += (value*value)*count;
+			if (count>longMaxCount) {
+				longMaxCount = count;
+				mode = i;
+			}
+		}
+		maxCount = (int)longMaxCount;
+		pixelCount = (int)longPixelCount;
+		area = longPixelCount*pw*ph;
+		mean = sum/longPixelCount;
+		umean = mean;
+		dmode = mode;
+		calculateStdDev(longPixelCount, sum, sum2);
+		histMin = 0.0;
+		histMax = 255.0;
+	}
+
+	void getRawMinAndMax(long[] histogram, int minThreshold, int maxThreshold) {
+		int min = minThreshold;
+		while ((histogram[min]==0L) && (min<255))
+			min++;
+		this.min = min;
+		int max = maxThreshold;
+		while ((histogram[max]==0L) && (max>0))
+			max--;
+		this.max = max;
+	}
+
+	void sum16BitHistograms(ImagePlus imp) {
+		Calibration cal = imp.getCalibration();
+		boolean limitToThreshold = (Analyzer.getMeasurements()&LIMIT)!=0;
+		int minThreshold = 0;
+		int maxThreshold = 65535;
+		ImageProcessor ip = imp.getProcessor();
+		if (limitToThreshold && ip.getMinThreshold()!=ImageProcessor.NO_THRESHOLD) {
+			minThreshold = (int)ip.getMinThreshold();
+			maxThreshold = (int)ip.getMaxThreshold();
+		}
+		ImageStack stack = imp.getStack();
+		Roi roi = imp.getRoi();
+		long[] hist16 = new long[65536];
+		int n = stack.size();
+		for (int slice=1; slice<=n; slice++) {
+			IJ.showProgress(slice, n);
+			IJ.showStatus(slice+"/"+n);
+			ip = stack.getProcessor(slice);
+			if (roi!=null) ip.setRoi(roi);
+			int[] hist = ip.getHistogram();
+			for (int i=0; i<65536; i++)
+				hist16[i] += hist[i];
+		}
+		pw=1.0; ph=1.0;
+		getRaw16BitMinAndMax(hist16, minThreshold, maxThreshold);
+		get16BitStatistics(hist16, (int)min, (int)max);
+		median = getMedian(hist16, minThreshold, maxThreshold, cal);
+		histogram16 = new int[65536];
+		for (int i=0; i<65536; i++) {
+			long count = hist16[i];
+			if (count<=Integer.MAX_VALUE)
+				histogram16[i] = (int)count;
+			else
+				histogram16[i] = Integer.MAX_VALUE;
+		}
+		IJ.showStatus("");
+		IJ.showProgress(1.0);
+	}
+	
+	void getRaw16BitMinAndMax(long[] hist, int minThreshold, int maxThreshold) {
+		int min = minThreshold;
+		while ((hist[min]==0) && (min<65535))
+			min++;
+		this.min = min;
+		int max = maxThreshold;
+		while ((hist[max]==0) && (max>0))
+			max--;
+		this.max = max;
+	}
+
+	void get16BitStatistics(long[] hist, int min, int max) {
+		long count;
+		double value;
+		double sum = 0.0;
+		double sum2 = 0.0;
+		nBins = 256;
+		histMin = min; 
+		histMax = max;
+		binSize = (histMax-histMin)/nBins;
+		double scale = 1.0/binSize;
+		int hMin = (int)histMin;
+		longHistogram = new long[nBins]; // 256 bin histogram
+		int index;
+        maxCount = 0;
+		for (int i=min; i<=max; i++) {
+			count = hist[i];
+			longPixelCount += count;
+			value = i;
+			sum += value*count;
+			sum2 += (value*value)*count;
+			index = (int)(scale*(i-hMin));
+			if (index>=nBins)
+				index = nBins-1;
+			longHistogram[index] += count;
+		}
+		copyHistogram(nBins);
+		pixelCount = (int)longPixelCount;
+		area = longPixelCount*pw*ph;
+		mean = sum/longPixelCount;
+		umean = mean;
+		dmode = getMode(null);
+		calculateStdDev(longPixelCount, sum, sum2);
+	}
+
+   double getMode(Calibration cal) {
+        long count;
+        long longMaxCount = 0L;
+        for (int i=0; i<nBins; i++) {
+            count = longHistogram[i];
+            if (count>longMaxCount) {
+                longMaxCount = count;
+                mode = i;
+            }
+        }
+		if (longMaxCount<=Integer.MAX_VALUE)
+			maxCount = (int)longMaxCount;
+		else
+			maxCount = Integer.MAX_VALUE;
+        double tmode = histMin+mode*binSize;
+        if (cal!=null) tmode = cal.getCValue(tmode);
+        return tmode;
+    }
+    
+    double getMedian(long[] hist, int first, int last, Calibration cal) {
+		//ij.IJ.log("getMedian: "+first+"  "+last+"  "+hist.length+"  "+pixelCount);
+		if (pixelCount==0 || first<0 || last>hist.length)
+			return Double.NaN;
+		double sum = 0;
+		int i = first-1;
+		double halfCount = pixelCount/2.0;
+		do {
+			sum += hist[++i];
+		} while (sum<=halfCount && i<last);
+		return cal!=null?cal.getCValue(i):i;
+	}
+
+   
+}
diff --git a/src/ij/process/TypeConverter.java b/src/ij/process/TypeConverter.java
new file mode 100644
index 0000000..a5f2eff
--- /dev/null
+++ b/src/ij/process/TypeConverter.java
@@ -0,0 +1,255 @@
+package ij.process;
+import java.awt.*;
+import java.awt.image.*;
+import ij.*;
+import ij.gui.*;
+import ij.measure.*;
+
+/** This class converts an ImageProcessor to another data type. */
+public class TypeConverter {
+
+	private static final int BYTE=0, SHORT=1, FLOAT=2, RGB=3;
+	private ImageProcessor ip;
+	private int type;
+	boolean doScaling = true;
+	int width, height;
+
+	public TypeConverter(ImageProcessor ip, boolean doScaling) {
+		this.ip = ip;
+		this.doScaling = doScaling;
+		if (ip instanceof ByteProcessor)
+			type = BYTE;
+		else if (ip instanceof ShortProcessor)
+			type = SHORT;
+		else if (ip instanceof FloatProcessor)
+			type = FLOAT;
+		else
+			type = RGB;
+		width = ip.getWidth();
+		height = ip.getHeight();
+	}
+
+	/** Converts processor to a ByteProcessor. */
+	public ImageProcessor convertToByte() {
+		switch (type) {
+			case BYTE:
+				return ip;
+			case SHORT:
+				return convertShortToByte();
+			case FLOAT:
+				return convertFloatToByte();
+			case RGB:
+				return convertRGBToByte();
+			default:
+				return null;
+		}
+	}
+
+	/** Converts a ShortProcessor to a ByteProcessor. */
+	ByteProcessor convertShortToByte() {
+		int size = width*height;
+		short[] pixels16 = (short[])ip.getPixels();
+		byte[] pixels8 = new byte[size];
+		if (doScaling) {
+			int value, min=(int)ip.getMin(), max=(int)ip.getMax();
+			double scale = 256.0/(max-min+1);
+			for (int i=0; i<size; i++) {
+				value = (pixels16[i]&0xffff)-min;
+				if (value<0) value = 0;
+				value = (int)(value*scale+0.5);
+				if (value>255) value = 255;
+				pixels8[i] = (byte)value;
+			}
+			return new ByteProcessor(width, height, pixels8, ip.getCurrentColorModel());
+		} else {
+			int value;
+			for (int i=0; i<size; i++) {
+				value = pixels16[i]&0xffff;
+				if (value>255) value = 255;
+				pixels8[i] = (byte)value;
+			}
+			return new ByteProcessor(width, height, pixels8, ip.getColorModel());
+		}
+	}
+
+	/** Converts a FloatProcessor to a ByteProcessor. */
+	ByteProcessor convertFloatToByte() {
+		if (doScaling) {
+			byte[] pixels8 = ip.create8BitImage();
+			ByteProcessor bp = new ByteProcessor(ip.getWidth(), ip.getHeight(), pixels8);
+			bp.setColorModel(ip.getColorModel());
+			return bp;
+		} else {
+			ByteProcessor bp = new ByteProcessor(width, height);
+			bp.setPixels(0, (FloatProcessor)ip);
+			bp.setColorModel(ip.getColorModel());
+			bp.resetMinAndMax();		//don't take min&max from ip
+			return bp;
+		}
+	}
+
+	/** Converts a ColorProcessor to a ByteProcessor. 
+		The pixels are converted to grayscale using the formula
+		g=r/3+g/3+b/3. Call ColorProcessor.setRGBWeights() 
+		to do weighted conversions. */
+	ByteProcessor convertRGBToByte() {
+		if (ip.getNChannels()==1 && doScaling) {
+			byte[] pixels8 = ip.create8BitImage();
+			ByteProcessor bp = new ByteProcessor(ip.getWidth(), ip.getHeight(), pixels8);
+			bp.setColorModel(ip.getColorModel());
+			return bp;
+		}
+		int[] pixels32 = (int[])ip.getPixels();
+		double[] w = ColorProcessor.getWeightingFactors();
+		if (((ColorProcessor)ip).getRGBWeights()!=null)
+			w = ((ColorProcessor)ip).getRGBWeights();
+		double rw=w[0], gw=w[1], bw=w[2];
+		byte[] pixels8 = new byte[width*height];
+		int c, r, g, b;
+		for (int i=0; i < width*height; i++) {
+			c = pixels32[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			pixels8[i] = (byte)(r*rw + g*gw + b*bw + 0.5);
+		}
+		return new ByteProcessor(width, height, pixels8, null);
+	}
+	
+	/** Converts a ColorProcessor to a FloatProcessor. 
+		The pixels are converted to grayscale using the formula
+		g=r/3+g/3+b/3. Call ColorProcessor.setRGBWeights() 
+		to do weighted conversions. */
+	FloatProcessor convertRGBToFloat() {
+		int[] pixels = (int[])ip.getPixels();
+		double[] w = ColorProcessor.getWeightingFactors();
+		if (((ColorProcessor)ip).getRGBWeights()!=null)
+			w = ((ColorProcessor)ip).getRGBWeights();
+		double rw=w[0], gw=w[1], bw=w[2];
+		float[] pixels32 = new float[width*height];
+		int c, r, g, b;
+		for (int i=0; i < width*height; i++) {
+			c = pixels[i];
+			r = (c&0xff0000)>>16;
+			g = (c&0xff00)>>8;
+			b = c&0xff;
+			pixels32[i] = (float)(r*rw + g*gw + b*bw);
+		}
+		return new FloatProcessor(width, height, pixels32);
+	}
+
+	/** Converts processor to a ShortProcessor. */
+	public ImageProcessor convertToShort() {
+		switch (type) {
+			case BYTE:
+				return convertByteToShort();
+			case SHORT:
+				return ip;
+			case FLOAT:
+				return convertFloatToShort();
+			case RGB:
+				ip = convertRGBToByte();
+				return convertByteToShort();
+			default:
+				return null;
+		}
+	}
+
+	/** Converts a ByteProcessor to a ShortProcessor. */
+	ShortProcessor convertByteToShort() {
+		byte[] pixels8 = (byte[])ip.getPixels();
+		short[] pixels16 = new short[width * height];
+		for (int i=0,j=0; i<width*height; i++)
+			pixels16[i] = (short)(pixels8[i]&0xff);
+	    return new ShortProcessor(width, height, pixels16, ip.getColorModel());
+	}
+
+	/** Converts a FloatProcessor to a ShortProcessor. */
+	ShortProcessor convertFloatToShort() {
+		float[] pixels32 = (float[])ip.getPixels();
+		short[] pixels16 = new short[width*height];
+		double min = ip.getMin();
+		double max = ip.getMax();
+		double scale;
+		if ((max-min)==0.0)
+			scale = 1.0;
+		else
+			scale = 65535.0/(max-min);
+		double value;
+		for (int i=0,j=0; i<width*height; i++) {
+			if (doScaling)
+				value = (pixels32[i]-min)*scale;
+			else
+				value = pixels32[i];
+			if (value<0.0) value = 0.0;
+			if (value>65535.0) value = 65535.0;
+			pixels16[i] = (short)(value+0.5);
+		}
+	    return new ShortProcessor(width, height, pixels16, ip.getColorModel());
+	}
+
+	/** Converts processor to a FloatProcessor. */
+	public ImageProcessor convertToFloat(float[] ctable) {
+		switch (type) {
+			case BYTE:
+				return convertByteToFloat(ctable);
+			case SHORT:
+				return convertShortToFloat(ctable);
+			case FLOAT:
+				return ip;
+			case RGB:
+				return convertRGBToFloat();
+			default:
+				return null;
+		}
+	}
+
+	/** Converts a ByteProcessor to a FloatProcessor. Applies a
+	 * calibration function if the 'cTable' is not null.
+	 * @see ImageProcessor.setCalibrationTable
+	 */
+	FloatProcessor convertByteToFloat(float[] cTable) {
+		int n = width*height;
+		byte[] pixels8 = (byte[])ip.getPixels();
+		float[] pixels32 = new float[n];
+		int value;
+		if (cTable!=null && cTable.length==256) {
+			for (int i=0; i<n; i++)
+				pixels32[i] = cTable[pixels8[i]&255];
+		} else {
+			for (int i=0; i<n; i++)
+				pixels32[i] = pixels8[i]&255;
+		}
+	    ColorModel cm = ip.getColorModel();
+	    return new FloatProcessor(width, height, pixels32, cm);
+	}
+
+	/** Converts a ShortProcessor to a FloatProcessor. Applies a
+		calibration function if the calibration table is not null.
+		@see ImageProcessor.setCalibrationTable
+	 */
+	FloatProcessor convertShortToFloat(float[] cTable) {
+		short[] pixels16 = (short[])ip.getPixels();
+		float[] pixels32 = new float[width*height];
+		int value;
+		if (cTable!=null && cTable.length==65536)
+			for (int i=0; i<width*height; i++)
+				pixels32[i] = cTable[pixels16[i]&0xffff];
+		else
+			for (int i=0; i<width*height; i++)
+				pixels32[i] = pixels16[i]&0xffff;
+	    ColorModel cm = ip.getColorModel();
+	    return new FloatProcessor(width, height, pixels32, cm);
+	}
+	
+	/** Converts processor to a ColorProcessor. */
+	public ImageProcessor convertToRGB() {
+		if (type==RGB)
+			return ip;
+		else {
+			ImageProcessor ip2 = ip.convertToByte(doScaling);
+			return new ColorProcessor(ip2.createImage());
+		}
+	}
+
+}
diff --git a/src/ij/text/TableListener.java b/src/ij/text/TableListener.java
new file mode 100644
index 0000000..fde9ead
--- /dev/null
+++ b/src/ij/text/TableListener.java
@@ -0,0 +1,11 @@
+package ij.text;
+
+	/** Plugins that implement this interface are notified when
+		a table is opened, closed or updated. The 
+		Plugins/Utilities/Monitor Events command uses this interface.
+	*/
+	public interface TableListener {
+
+	public void TableUpdated(TextPanel table, String event, int row);
+
+}
diff --git a/src/ij/text/TextCanvas.java b/src/ij/text/TextCanvas.java
new file mode 100644
index 0000000..9325756
--- /dev/null
+++ b/src/ij/text/TextCanvas.java
@@ -0,0 +1,197 @@
+package ij.text;
+import ij.util.Java2;
+import java.awt.*;
+import java.awt.event.*;
+
+class TextCanvas extends Canvas {
+
+	TextPanel tp;
+	Font fFont;
+	FontMetrics fMetrics;
+	Graphics gImage;
+	Image iImage;
+	boolean antialiased;
+
+	TextCanvas(TextPanel tp) {
+		this.tp = tp;
+		addMouseListener(tp);
+		addMouseMotionListener(tp);
+		addKeyListener(tp);
+		addMouseWheelListener(tp);
+	}
+
+    public void setBounds(int x, int y, int width, int height) {
+    	super.setBounds(x, y, width, height);
+		tp.adjustVScroll();
+		tp.adjustHScroll();
+    	iImage = null;
+    }
+
+	public void update(Graphics g) {
+		paint(g);
+	}
+  
+	public void paint(Graphics g) {
+		if (tp==null || g==null) return;
+		Dimension d = getSize();
+		int iWidth = d.width;
+		int iHeight = d.height;
+		
+		if (iWidth<=0 || iHeight<=0) return;
+		g.setColor(Color.lightGray);
+		if (iImage==null)
+			makeImage(iWidth,iHeight);
+		if (tp.iRowHeight==0 || (tp.iColWidth.length>0 && tp.iColWidth[0]==0&&tp.iRowCount>0)) {
+			tp.iRowHeight=fMetrics.getHeight()+2;
+			for (int i=0; i<tp.iColCount; i++)
+				calcAutoWidth(i);
+			tp.adjustHScroll();
+			tp.adjustVScroll();
+		}
+		gImage.setColor(Color.white);
+		gImage.fillRect(0,0,iWidth,iHeight);
+		if (tp.headings)
+			drawColumnLabels(iWidth);
+		int y=tp.iRowHeight+1-tp.iY;
+		int j=0;
+		while (y<tp.iRowHeight+1) {
+			j++;
+			y+=tp.iRowHeight;
+		}
+		tp.iFirstRow=j;
+		y=tp.iRowHeight+1;
+		for (;y<iHeight && j<tp.iRowCount; j++,y+=tp.iRowHeight) {
+			int x=-tp.iX;
+			for (int i=0;i<tp.iColCount;i++) {
+				if (i>=tp.iColWidth.length) break;
+				int w = tp.iColWidth[i];
+				Color b=Color.white,t=Color.black;
+				if (j>=tp.selStart && j<=tp.selEnd) {
+					int w2 = w;
+					if (tp.iColCount==1)
+						w2 = iWidth;
+					b=Color.black;
+					t=Color.white;
+					gImage.setColor(b);
+					gImage.fillRect(x,y,w2-1,tp.iRowHeight);
+				}
+				gImage.setColor(t);
+				char[] chars = getChars(i,j);
+				if (chars!=null)
+					gImage.drawChars(chars,0,chars.length,x+2,y+tp.iRowHeight-5);
+				x+=w;
+			}
+		}
+		if (iImage!=null)
+			g.drawImage(iImage,0,0,null);
+	}
+  
+ 	void makeImage(int iWidth, int iHeight) {
+		iImage=createImage(iWidth, iHeight);
+		if (gImage!=null)
+			gImage.dispose();
+		gImage=iImage.getGraphics();
+		gImage.setFont(fFont);
+		Java2.setAntialiasedText(gImage, antialiased);
+		if(fMetrics==null)
+			fMetrics=gImage.getFontMetrics();
+	}
+
+ 	void drawColumnLabels(int iWidth) {
+		gImage.setColor(Color.darkGray);
+		gImage.drawLine(0,tp.iRowHeight,iWidth,tp.iRowHeight);
+		int x=-tp.iX;
+		for (int i=0; i<tp.iColCount; i++) {
+			int w=tp.iColWidth[i];
+			gImage.setColor(Color.lightGray);
+			gImage.fillRect(x+1,0,w,tp.iRowHeight);
+			gImage.setColor(Color.black);
+			if (tp.sColHead[i]!=null)
+				gImage.drawString(tp.sColHead[i],x+2,tp.iRowHeight-5);
+			if (tp.iColCount>0) {
+				gImage.setColor(Color.darkGray);
+				gImage.drawLine(x+w-1,0,x+w-1,tp.iRowHeight-1);
+				gImage.setColor(Color.white);
+				gImage.drawLine(x+w,0,x+w,tp.iRowHeight-1);
+			}
+			x+=w;
+		}
+		gImage.setColor(Color.lightGray);
+		gImage.fillRect(0,0,1,tp.iRowHeight);
+		gImage.fillRect(x+1,0,iWidth-x,tp.iRowHeight);
+		//gImage.drawLine(0,0,0,iRowHeight-1);
+		gImage.setColor(Color.darkGray);
+		gImage.drawLine(0,0,iWidth,0);
+	}
+	
+	synchronized char[] getChars(int column, int row) {
+		if (tp==null || tp.vData==null)
+			return null;
+		if (row>=tp.vData.size())
+			return null;
+		char[] chars = row<tp.vData.size()?(char[])(tp.vData.elementAt(row)):null;
+		if (chars==null || chars.length==0)
+			return null;
+		
+		if (tp.iColCount==1)
+			return chars;
+	    
+	    int start = 0;
+	    int tabs = 0;
+	    int length = chars.length;
+	    
+	    while (column>tabs) {
+	    	if (chars[start]=='\t')
+	    		tabs++;
+	    	start++;
+	    	if (start>=length)
+	    		return null;
+	    };
+	    if (start<0 || start>=chars.length) {
+			System.out.println("start="+start+", chars.length="+chars.length);	    	
+	    	return null;
+	    }
+	    if (chars[start]=='\t')
+	    	return null;
+	    
+	    int end = start;
+	    while (chars[end]!='\t' && end<(length-1))
+	    	end++;
+	    if (chars[end]=='\t')
+	    	end--;
+	    	
+	    char[] chars2 = new char[end-start+1];
+	    for (int i=0,j=start; i<chars2.length; i++,j++) {
+	    	chars2[i] = chars[j];
+	    } 
+		return chars2;
+	}
+	
+	void calcAutoWidth(int column) {
+		if (tp.sColHead==null || column>=tp.iColWidth.length || gImage==null)
+			return;
+		if (fMetrics==null)
+			fMetrics=gImage.getFontMetrics();
+		int w=15;
+		int maxRows = 20;
+		if (column==0 && tp.sColHead[0].equals(" "))
+			w += 5;
+		else {
+			char[] chars = tp.sColHead[column].toCharArray();
+			w = Math.max(w,fMetrics.charsWidth(chars,0,chars.length));
+		}
+		int rowCount = Math.min(tp.iRowCount, maxRows);
+		for (int row=0; row<rowCount; row++) {
+			char[] chars = getChars(column,row);
+			if (chars!=null)
+				w = Math.max(w,fMetrics.charsWidth(chars,0,chars.length));
+		}
+		//System.out.println("calcAutoWidth: "+column+"  "+tp.iRowCount);
+		char[] chars = tp.iRowCount>0?getChars(column, tp.iRowCount-1):null;
+		if (chars!=null)
+			w = Math.max(w,fMetrics.charsWidth(chars,0,chars.length));
+		if (column<tp.iColWidth.length)
+			tp.iColWidth[column] = w+15;
+	}
+
+}
diff --git a/src/ij/text/TextPanel.java b/src/ij/text/TextPanel.java
new file mode 100644
index 0000000..0c72e32
--- /dev/null
+++ b/src/ij/text/TextPanel.java
@@ -0,0 +1,1129 @@
+package ij.text;
+import java.awt.*;
+import java.io.*;
+import java.awt.event.*;
+import java.util.*;
+import java.awt.datatransfer.*;
+import ij.*;
+import ij.plugin.filter.Analyzer;
+import ij.io.SaveDialog;
+import ij.measure.*;
+import ij.util.Tools;
+import ij.plugin.frame.Recorder;
+import ij.gui.*;
+import ij.macro.Interpreter;
+
+
+/**
+This is an unlimited size text panel with tab-delimited,
+labeled and resizable columns. It is based on the hGrid
+class at
+    http://www.lynx.ch/contacts/~/thomasm/Grid/index.html.
+*/
+public class TextPanel extends Panel implements AdjustmentListener,
+	MouseListener, MouseMotionListener, KeyListener,  ClipboardOwner,
+	ActionListener, MouseWheelListener, Runnable {
+
+	static final int DOUBLE_CLICK_THRESHOLD = 650;
+	// height / width
+	int iGridWidth,iGridHeight;
+	int iX,iY;
+	// data
+	String[] sColHead;
+	Vector vData;
+	int[] iColWidth;
+	int iColCount,iRowCount;
+	int iRowHeight,iFirstRow;
+	// scrolling
+	Scrollbar sbHoriz,sbVert;
+	int iSbWidth,iSbHeight;
+	boolean bDrag;
+	int iXDrag,iColDrag;
+
+	boolean headings = true;
+	String title = "";
+	String labels;
+	KeyListener keyListener;
+	Cursor resizeCursor = new Cursor(Cursor.E_RESIZE_CURSOR);
+  	Cursor defaultCursor = new Cursor(Cursor.DEFAULT_CURSOR);
+	int selStart=-1, selEnd=-1,selOrigin=-1, selLine=-1;
+	TextCanvas tc;
+	PopupMenu pm;
+	boolean columnsManuallyAdjusted;
+	long mouseDownTime;
+    String filePath;
+    ResultsTable rt;
+    boolean unsavedLines;
+    String searchString;
+    Menu fileMenu, editMenu;
+    boolean menusExtended;
+    boolean saveAsCSV;
+
+
+	/** Constructs a new TextPanel. */
+	public TextPanel() {
+		tc = new TextCanvas(this);
+		setLayout(new BorderLayout());
+		add("Center",tc);
+		sbHoriz=new Scrollbar(Scrollbar.HORIZONTAL);
+		GUI.fixScrollbar(sbHoriz);
+		sbHoriz.addAdjustmentListener(this);
+		sbHoriz.setFocusable(false); // prevents scroll bar from blinking on Windows
+		add("South", sbHoriz);
+		sbVert=new Scrollbar(Scrollbar.VERTICAL);
+		GUI.fixScrollbar(sbVert);
+		sbVert.addAdjustmentListener(this);
+		sbVert.setFocusable(false);
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null) {
+			sbHoriz.addKeyListener(ij);
+			sbVert.addKeyListener(ij);
+		}
+		add("East", sbVert);
+		addPopupMenu();
+	}
+
+	/** Constructs a new TextPanel. */
+	public TextPanel(String title) {
+		this();
+		this.title = title;
+		if (title.equals("Results")) {
+			pm.addSeparator();
+			addPopupItem("Clear Results");
+			addPopupItem("Summarize");
+			addPopupItem("Distribution...");
+			addPopupItem("Set Measurements...");
+		}
+	}
+
+	void addPopupMenu() {
+		pm = new PopupMenu();
+		GUI.scalePopupMenu(pm);
+		addPopupItem("Save As...");
+		pm.addSeparator();
+		addPopupItem("Cut");
+		addPopupItem("Copy");
+		addPopupItem("Clear");
+		addPopupItem("Select All");
+		add(pm);
+	}
+
+	void addPopupItem(String s) {
+		MenuItem mi=new MenuItem(s);
+		mi.addActionListener(this);
+		pm.add(mi);
+	}
+
+	/**
+	Clears this TextPanel and sets the column headings to
+	those in the tab-delimited 'headings' String. Set 'headings'
+	to "" to use a single column with no headings.
+	*/
+	public synchronized void setColumnHeadings(String labels) {
+		//if (count++==5) throw new IllegalArgumentException();
+		boolean sameLabels = labels.equals(this.labels);
+		this.labels = labels;
+		if (labels.equals("")) {
+			iColCount = 1;
+			sColHead=new String[1];
+			sColHead[0] = "";
+		} else {
+			if (labels.endsWith("\t"))
+				this.labels = labels.substring(0, labels.length()-1);
+			sColHead = this.labels.split("\t");
+        	iColCount = sColHead.length;
+		}
+		flush();
+		vData=new Vector();
+		if (!(iColWidth!=null && iColWidth.length==iColCount && sameLabels && iColCount!=1)) {
+			iColWidth=new int[iColCount];
+			columnsManuallyAdjusted = false;
+		}
+		iRowCount=0;
+		resetSelection();
+		adjustHScroll();
+		tc.repaint();
+	}
+
+	/** Returns the column headings as a tab-delimited string. */
+	public String getColumnHeadings() {
+		return labels==null?"":labels;
+	}
+
+	public synchronized void updateColumnHeadings(String labels) {
+		this.labels = labels;
+		if (labels.equals("")) {
+			iColCount = 1;
+			sColHead=new String[1];
+			sColHead[0] = "";
+		} else {
+			if (labels.endsWith("\t"))
+				this.labels = labels.substring(0, labels.length()-1);
+			sColHead = this.labels.split("\t");
+        	iColCount = sColHead.length;
+			iColWidth=new int[iColCount];
+			columnsManuallyAdjusted = false;
+		}
+	}
+
+	public void setFont(Font font, boolean antialiased) {
+		tc.fFont = font;
+		tc.iImage = null;
+		tc.fMetrics = null;
+		tc.antialiased = antialiased;
+		iColWidth[0] = 0;
+		if (isShowing()) updateDisplay();
+	}
+
+	/** Adds a single line to the end of this TextPanel. */
+	public void appendLine(String text) {
+		if (vData==null)
+			setColumnHeadings("");
+		char[] chars = text.toCharArray();
+		vData.addElement(chars);
+		iRowCount++;
+		if (isShowing()) {
+			if (iColCount==1 && tc.fMetrics!=null) {
+				iColWidth[0] = Math.max(iColWidth[0], tc.fMetrics.charsWidth(chars,0,chars.length));
+				adjustHScroll();
+			}
+			updateDisplay();
+			unsavedLines = true;
+		}
+	}
+
+	/** Adds one or more lines to the end of this TextPanel. */
+	public void append(String text) {
+		if (text==null) text="null";
+		if (vData==null)
+			setColumnHeadings("");
+		if (text.length()==1 && text.equals("\n"))
+			text = "";
+		String[] lines = text.split("\n");
+		for (int i=0; i<lines.length; i++)
+			appendWithoutUpdate(lines[i]);
+		if (isShowing()) {
+			updateDisplay();
+			unsavedLines = true;
+		}
+	}
+
+	/** Adds strings contained in an ArrayList to the end of this TextPanel. */
+	public void append(ArrayList list) {
+		if (list==null) return;
+		if (vData==null) setColumnHeadings("");
+		for (int i=0; i<list.size(); i++)
+			appendWithoutUpdate((String)list.get(i));
+		if (isShowing()) {
+			updateDisplay();
+			unsavedLines = true;
+		}
+	}
+
+	/** Adds a single line to the end of this TextPanel without updating the display. */
+	public void appendWithoutUpdate(String data) {
+		if (vData!=null) {
+			char[] chars = data.toCharArray();
+			vData.addElement(chars);
+			iRowCount++;
+		}
+	}
+
+	public void updateDisplay() {
+		iY=iRowHeight*(iRowCount+1);
+		adjustVScroll();
+		if (iColCount>1 && iRowCount<=10 && !columnsManuallyAdjusted)
+			iColWidth[0] = 0; // forces column width calculation
+		tc.repaint();
+	}
+
+	String getCell(int column, int row) {
+		if (column<0||column>=iColCount||row<0||row>=iRowCount)
+			return null;
+		return new String(tc.getChars(column, row));
+	}
+
+	synchronized void adjustVScroll() {
+		if(iRowHeight==0) return;
+		Dimension d = tc.getSize();
+		int value = iY/iRowHeight;
+		int visible = d.height/iRowHeight;
+		int maximum = iRowCount+1;
+		if (visible<0) visible=0;
+		if (visible>maximum) visible=maximum;
+		if (value>(maximum-visible)) value=maximum-visible;
+		sbVert.setValues(value,visible,0,maximum);
+		iY=iRowHeight*value;
+	}
+
+	synchronized void adjustHScroll() {
+		if (iRowHeight==0) return;
+		Dimension d = tc.getSize();
+		int w=0;
+		for (int i=0; i<iColCount; i++)
+			w+=iColWidth[i];
+		iGridWidth=w;
+		sbHoriz.setValues(iX,d.width,0,iGridWidth);
+		iX=sbHoriz.getValue();
+	}
+
+	public void adjustmentValueChanged (AdjustmentEvent e) {
+		iX=sbHoriz.getValue();
+ 		iY=iRowHeight*sbVert.getValue();
+		tc.repaint();
+ 	}
+
+	private void showLinePos() { // show line numbers in status bar (Norbert Visher)
+		int startLine = getSelectionStart() +1;
+		int endLine = getSelectionEnd() + 1;
+		String msg = "Line " + startLine;
+		if (startLine != endLine) {
+			msg += "-" + endLine;
+		}
+		if (!msg.equals("Line 0"))
+			IJ.showStatus(msg);
+	}
+	
+	public void mousePressed (MouseEvent e) {
+		int x=e.getX(), y=e.getY();
+		if (e.isPopupTrigger() || e.isMetaDown())
+			pm.show(e.getComponent(),x,y);
+ 		else if (e.isShiftDown())
+			extendSelection(x, y);
+		else {
+ 			select(x, y);
+ 			handleDoubleClick();
+ 		}
+	}
+
+	void handleDoubleClick() {//Marcel Boeglin 2019.10.07
+		boolean overlayList = title.startsWith("Overlay Elements of ");
+		if (selStart<0 || selStart!=selEnd || (iColCount!=1&&!overlayList))
+			return;
+		boolean doubleClick = System.currentTimeMillis()-mouseDownTime<=DOUBLE_CLICK_THRESHOLD;
+		mouseDownTime = System.currentTimeMillis();
+		if (doubleClick) {
+			char[] chars = (char[])(vData.elementAt(selStart));
+			String s = new String(chars);
+			if (overlayList) {
+				String owner = title.substring(20, title.length());
+				String[] titles = WindowManager.getImageTitles();
+				for (int i=0; i<titles.length; i++) {
+					String t = titles[i];
+					if (titles[i].equals(owner)) {
+						ImagePlus imp = WindowManager.getImage(owner);
+						WindowManager.setTempCurrentImage(imp);//?
+						Frame frame = imp.getWindow();
+						frame.toFront();
+						if (frame.getState()==Frame.ICONIFIED)
+							frame.setState(Frame.NORMAL);
+						handleDoubleClickInOverlayList(s);
+						break;
+					}
+				}
+				return;
+			}
+			int index = s.indexOf(": ");
+			if (index>-1 && !s.endsWith(": "))
+				s = s.substring(index+2); // remove sequence number added by ListFilesRecursively
+			if (s.indexOf(File.separator)!=-1 ||  s.indexOf(".")!=-1) {
+				filePath = s;
+				Thread thread = new Thread(this, "Open");
+				thread.setPriority(thread.getPriority()-1);
+				thread.start();
+			}
+		}
+	}
+
+	private void handleDoubleClickInOverlayList(String s) {//Marcel Boeglin 2019.10.09
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp==null)
+			return;
+		Overlay overlay = imp.getOverlay();
+		if (overlay==null)
+			return;
+		String[] columns = s.split("\t");
+		int index = (int)Tools.parseDouble(columns[0]);
+		Roi roi = overlay.get(index);
+		if (imp.isHyperStack()) {
+			int c = roi.getCPosition();
+			int z = roi.getZPosition();
+			int t = roi.getTPosition();
+			c = c==0?imp.getChannel():c;
+			z = z==0?imp.getSlice():z;
+			t = t==0?imp.getFrame():t;
+			imp.setPosition(c, z, t);
+		} else {
+			int p = roi.getPosition();
+			if (p>=1 && p<=imp.getStackSize())
+				imp.setPosition(p);
+		}
+		imp.setRoi(roi);
+	}
+	
+    /** For better performance, open double-clicked files on
+    	separate thread instead of on event dispatch thread. */
+    public void run() {
+        if (filePath!=null) IJ.open(filePath);
+    }
+
+	public void mouseExited (MouseEvent e) {
+		if(bDrag) {
+			setCursor(defaultCursor);
+			bDrag=false;
+		}
+	}
+
+	public void mouseMoved (MouseEvent e) {
+		int x=e.getX(), y=e.getY();
+		if(y<=iRowHeight) {
+			int xb=x;
+			x=x+iX-iGridWidth;
+			int i=iColCount-1;
+			for(;i>=0;i--) {
+				if(x>-7 && x<7) break;
+				x+=iColWidth[i];
+			}
+			if(i>=0) {
+				if(!bDrag) {
+					setCursor(resizeCursor);
+					bDrag=true;
+					iXDrag=xb-iColWidth[i];
+					iColDrag=i;
+				}
+				return;
+			}
+		}
+		if(bDrag) {
+			setCursor(defaultCursor);
+			bDrag=false;
+		}
+	}
+
+	public void mouseDragged (MouseEvent e) {
+		if (e.isPopupTrigger() || e.isMetaDown())
+			return;
+		int x=e.getX(), y=e.getY();
+		if(bDrag && x<tc.getSize().width) {
+			int w=x-iXDrag;
+			if(w<0) w=0;
+			iColWidth[iColDrag]=w;
+			columnsManuallyAdjusted = true;
+			adjustHScroll();
+			tc.repaint();
+		} else {
+			extendSelection(x, y);
+		}
+	}
+
+ 	public void mouseReleased (MouseEvent e) {
+			showLinePos();
+	}
+	public void mouseClicked (MouseEvent e) {}
+	public void mouseEntered (MouseEvent e) {}
+
+	public void mouseWheelMoved(MouseWheelEvent event) {
+		synchronized(this) {
+			int rot = event.getWheelRotation();
+			sbVert.setValue(sbVert.getValue()+rot);
+			iY=iRowHeight*sbVert.getValue();
+			tc.repaint();
+		}
+	}
+
+	private void scroll(int inc) {
+		synchronized(this) {
+			sbVert.setValue(sbVert.getValue()+inc);
+			iY=iRowHeight*sbVert.getValue();
+			tc.repaint();
+		}
+	}
+
+	/** Unused keyPressed and keyTyped events will be passed to 'listener'.*/
+	public void addKeyListener(KeyListener listener) {
+		keyListener = listener;
+	}
+
+	public void addMouseListener(MouseListener listener) {
+		tc.addMouseListener(listener);
+	}
+
+	public void keyPressed(KeyEvent e) {
+		int key = e.getKeyCode();
+		if (key==KeyEvent.VK_BACK_SPACE || key==KeyEvent.VK_DELETE)
+			clearSelection();
+		else if (key==KeyEvent.VK_UP)
+			scroll(-1);
+		else if (key==KeyEvent.VK_DOWN)
+			scroll(1);
+		else if (keyListener!=null&&key!=KeyEvent.VK_S&& key!=KeyEvent.VK_C && key!=KeyEvent.VK_X
+		&& key!=KeyEvent.VK_A && key!=KeyEvent.VK_F && key!=KeyEvent.VK_G)
+			keyListener.keyPressed(e);
+	}
+
+	public void keyReleased (KeyEvent e) {
+		IJ.setKeyUp(e.getKeyCode());
+		showLinePos();
+	}
+
+	public void keyTyped (KeyEvent e) {
+		if (keyListener!=null)
+			keyListener.keyTyped(e);
+	}
+
+	public void actionPerformed (ActionEvent e) {
+		String cmd=e.getActionCommand();
+		doCommand(cmd);
+	}
+
+ 	void doCommand(String cmd) {
+ 		if (cmd==null)
+ 			return;
+		if (cmd.equals("Save As..."))
+			saveAs("");
+		else if (cmd.equals("Cut"))
+			cutSelection();
+		else if (cmd.equals("Copy"))
+			copySelection();
+		else if (cmd.equals("Clear"))
+			doClear();
+		else if (cmd.equals("Select All"))
+			selectAll();
+		else if (cmd.equals("Find..."))
+			find(null);
+		else if (cmd.equals("Find Next"))
+			find(searchString);
+		else if (cmd.equals("Rename..."))
+			rename(null);
+		else if (cmd.equals("Duplicate..."))
+			duplicate();
+		else if (cmd.equals("Summarize"))
+			IJ.doCommand("Summarize");
+		else if (cmd.equals("Distribution..."))
+			IJ.doCommand("Distribution...");
+		else if (cmd.equals("Clear Results"))
+			IJ.doCommand("Clear Results");
+		else if (cmd.equals("Set Measurements..."))
+			IJ.doCommand("Set Measurements...");
+ 		else if (cmd.equals("Options..."))
+			IJ.doCommand("Input/Output...");
+ 		else if (cmd.equals("Apply Macro..."))
+			new ResultsTableMacros(rt);
+ 		else if (cmd.equals("Sort..."))
+			sort();
+ 		else if (cmd.equals("Plot..."))
+			new PlotContentsDialog(title, getOrCreateResultsTable()).showDialog(getParent() instanceof Frame ? (Frame)getParent() : null);
+	}
+
+ 	public void lostOwnership (Clipboard clip, Transferable cont) {}
+
+	private void find(String s) {
+		int first = 0;
+		if (s==null) {
+			GenericDialog gd = new GenericDialog("Find...", getTextWindow());
+			gd.addStringField("Find: ", searchString, 20);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return;
+			s = gd.getNextString();
+		} else {
+			if (selEnd>=0 && selEnd<iRowCount-1)
+				first = selEnd + 1;
+			else {
+				IJ.beep();
+				return;
+			}
+		}
+		if (s.equals(""))
+			return;
+		boolean found = false;
+		for (int i=first; i<iRowCount; i++) {
+			String line = new String((char[])(vData.elementAt(i)));
+			if (line.contains(s)) {
+				setSelection(i, i);
+				found = true;
+				first = i + 1;
+				break;
+			}
+		}
+		if (!found) {
+			IJ.beep();
+			first = 0;
+		}
+		searchString = s;
+	}
+
+	private TextWindow getTextWindow() {
+		Component comp = getParent();
+		if (comp==null || !(comp instanceof TextWindow))
+			return null;
+		else
+			return (TextWindow)comp;
+	}
+
+	void rename(String title2) {
+		ResultsTable rt2 = getOrCreateResultsTable();
+		if (rt2==null)
+			return;
+		if (title2!=null && title2.equals(""))
+			title2 = null;
+		TextWindow tw = getTextWindow();
+		if (tw==null)
+			return;
+		if (title2==null) {
+			GenericDialog gd = new GenericDialog("Rename", tw);
+			gd.addStringField("Title:", getNewTitle(title), 20);
+			gd.showDialog();
+			if (gd.wasCanceled())
+				return;
+			title2 = gd.getNextString();
+		}
+		String title1 = title;
+		if (title!=null && title.equals("Results")) {
+			IJ.setTextPanel(null);
+			Analyzer.setUnsavedMeasurements(false);
+			Analyzer.setResultsTable(null);
+			Analyzer.resetCounter();
+		}
+		if (title2.equals("Results")) {
+			//tw.setVisible(false);
+			tw.dispose();
+			WindowManager.removeWindow(tw);
+			flush();
+			rt2.show("Results");
+		} else {
+			tw.setTitle(title2);
+			int mbSize = tw.mb!=null?tw.mb.getMenuCount():0;
+			if (mbSize>0 && tw.mb.getMenu(mbSize-1).getLabel().equals("Results"))
+				tw.mb.remove(mbSize-1);
+			title = title2;
+			rt2.show(title);
+		}
+		Menus.updateWindowMenuItem(title1, title2);
+		if (Recorder.record) {
+			if (Recorder.scriptMode())
+				Recorder.recordString("IJ.renameResults(\""+title1+"\", \""+title2+"\");\n");
+			else
+				Recorder.record("Table.rename", title1, title2);
+		}
+	}
+
+	void duplicate() {
+		ResultsTable rt2 = getOrCreateResultsTable();
+		if (rt2==null)
+			return;
+		rt2 = (ResultsTable)rt2.clone();
+		String title2 = IJ.getString("Title:", getNewTitle(title));
+		if (!title2.equals("")) {
+			if (title2.equals("Results")) title2 = "Results2";
+			rt2.show(title2);
+		}
+	}
+
+	private String getNewTitle(String oldTitle) {
+		if (oldTitle==null)
+			return "Table2";
+		String title2 = oldTitle;
+		if (title2.endsWith("-1") || title2.endsWith("-2"))
+			title2 = title2.substring(0,title.length()-2);
+		String title3 = title2+"-1";
+		if (title3.equals(oldTitle))
+			title3 = title2+"-2";
+        return title3;
+	}
+
+	void select(int x,int y) {
+		Dimension d = tc.getSize();
+		if(iRowHeight==0 || x>d.width || y>d.height)
+			return;
+     	int r=(y/iRowHeight)-1+iFirstRow;
+     	int lineWidth = iGridWidth;
+		if (iColCount==1 && tc.fMetrics!=null && r>=0 && r<iRowCount) {
+			char[] chars = (char[])vData.elementAt(r);
+			lineWidth = Math.max(tc.fMetrics.charsWidth(chars,0,chars.length), iGridWidth);
+		}
+      	if (r>=0 && r<iRowCount && x<lineWidth) {
+			selOrigin = r;
+			selStart = r;
+			selEnd = r;
+		} else {
+			resetSelection();
+			selOrigin = r;
+			if (r>=iRowCount)
+				selOrigin = iRowCount-1;
+		}
+		tc.repaint();
+		selLine=r;
+		Interpreter interp = Interpreter.getInstance();
+		if (interp!=null && title.equals("Debug"))
+			interp.showArrayInspector(r);
+	}
+
+	void extendSelection(int x,int y) {
+		Dimension d = tc.getSize();
+		if(iRowHeight==0 || x>d.width || y>d.height)
+			return;
+     	int r=(y/iRowHeight)-1+iFirstRow;
+     	if(r>=0 && r<iRowCount) {
+			if (r<selOrigin) {
+				selStart = r;
+				selEnd = selOrigin;
+
+			} else {
+				selStart = selOrigin;
+				selEnd = r;
+			}
+		}
+		tc.repaint();
+		selLine=r;
+	}
+
+    /** Converts a y coordinate in pixels into a row index. */
+    public int rowIndex(int y) {
+        if (y > tc.getSize().height)
+        	return -1;
+        else
+        	return (y/iRowHeight)-1+iFirstRow;
+    }
+
+	/**
+	Copies the current selection to the system clipboard.
+	Returns the number of characters copied.
+	*/
+	public int copySelection() {
+		if (Recorder.record && title.equals("Results"))
+			Recorder.record("String.copyResults");
+		if (selStart==-1 || selEnd==-1)
+			return copyAll();
+		StringBuffer sb = new StringBuffer();
+		ResultsTable rt2 = getResultsTable();
+		boolean hasRowNumers = rt2!=null && rt2.showRowNumbers();
+		if (Prefs.copyColumnHeaders && labels!=null && !labels.equals("") && selStart==0 && selEnd==iRowCount-1) {
+			if (hasRowNumers && Prefs.noRowNumbers) {
+				String s = labels;
+				int index = s.indexOf("\t");
+				if (index!=-1)
+					s = s.substring(index+1, s.length());
+				sb.append(s);
+			} else
+				sb.append(labels);
+			sb.append('\n');
+		}
+		for (int i=selStart; i<=selEnd; i++) {
+			char[] chars = (char[])(vData.elementAt(i));
+			String s = new String(chars);
+			if (s.endsWith("\t"))
+				s = s.substring(0, s.length()-1);
+			if (hasRowNumers && Prefs.noRowNumbers && labels!=null && !labels.equals("")) {
+				int index = s.indexOf("\t");
+				if (index!=-1)
+					s = s.substring(index+1, s.length());
+				sb.append(s);
+			} else
+				sb.append(s);
+			if (i<selEnd || selEnd>selStart) sb.append('\n');
+		}
+		String s = new String(sb);
+		Clipboard clip = getToolkit().getSystemClipboard();
+		if (clip==null) return 0;
+		StringSelection cont = new StringSelection(s);
+		clip.setContents(cont,this);
+		if (s.length()>0) {
+			IJ.showStatus((selEnd-selStart+1)+" lines copied to clipboard");
+			if (this.getParent() instanceof ImageJ)
+				Analyzer.setUnsavedMeasurements(false);
+		}
+		return s.length();
+	}
+
+	int copyAll() {
+		selectAll();
+		int count = selEnd - selStart + 1;
+		if (count>0)
+			copySelection();
+		resetSelection();
+		unsavedLines = false;
+		return count;
+	}
+
+	void cutSelection() {
+		if (selStart==-1 || selEnd==-1)
+			selectAll();
+		copySelection();
+		clearSelection();
+	}
+
+	/** Implements the Clear command. */
+	public void doClear() {
+		if (getLineCount()>0 && selStart!=-1 && selEnd!=-1)
+			clearSelection();
+		else if ("Results".equals(title))
+			IJ.doCommand("Clear Results");
+		else {
+			selectAll();
+			clearSelection();
+		}
+	}
+
+	/** Deletes the selected lines. */
+	public void clearSelection() {
+		if (selStart==-1 || selEnd==-1) {
+			if (getLineCount()>0)
+				IJ.error("Text selection required");
+			return;
+		}
+		if (Recorder.record) {
+			if (Recorder.scriptMode())
+				Recorder.recordString("IJ.deleteRows("+selStart+", "+selEnd+");\n");
+			else {
+				if ("Results".equals(title))
+					Recorder.record("Table.deleteRows", selStart, selEnd);
+				else
+					Recorder.record("Table.deleteRows", selStart, selEnd, title);
+			}
+		}
+		int first=selStart, last=selEnd, rows=iRowCount;
+		if (selStart==0 && selEnd==(iRowCount-1)) {
+			vData.removeAllElements();
+			iRowCount = 0;
+			if (rt!=null) {
+				if (IJ.isResultsWindow() && IJ.getTextPanel()==this) {
+					Analyzer.setUnsavedMeasurements(false);
+					Analyzer.resetCounter();
+				} else
+					rt.reset();
+			}
+		} else {
+			int rowCount = iRowCount;
+			boolean atEnd = rowCount-selEnd<8;
+			int count = selEnd-selStart+1;
+			for (int i=0; i<count; i++) {
+				vData.removeElementAt(selStart);
+				iRowCount--;
+			}
+			if (rt!=null && rowCount==rt.size()) {
+				for (int i=0; i<count; i++)
+					rt.deleteRow(selStart);
+				rt.show(title);
+				if (!atEnd) {
+					iY = 0;
+					tc.repaint();
+				}
+			}
+		}
+		ImagePlus imp = WindowManager.getCurrentImage();
+		if (imp!=null)
+			Overlay.updateTableOverlay(imp, first, last, rows);
+		selStart=-1; selEnd=-1; selOrigin=-1; selLine=-1;
+		adjustVScroll();
+		tc.repaint();
+	}
+
+	/** Deletes all the lines. */
+	public synchronized void clear() {
+		if (vData==null) return;
+		vData.removeAllElements();
+		iRowCount = 0;
+		selStart=-1; selEnd=-1; selOrigin=-1; selLine=-1;
+		adjustVScroll();
+		tc.repaint();
+	}
+
+	/** Selects all the lines in this TextPanel. */
+	public void selectAll() {
+		if (selStart==0 && selEnd==iRowCount-1) {
+			resetSelection();
+			IJ.showStatus("");
+			return;
+		}
+		selStart = 0;
+		selEnd = iRowCount-1;
+		selOrigin = 0;
+		tc.repaint();
+		selLine=-1;
+		showLinePos();
+	}
+
+	/** Clears the selection, if any. */
+	public void resetSelection() {
+		selStart=-1;
+		selEnd=-1;
+		selOrigin=-1;
+		selLine=-1;
+		if (iRowCount>0)
+			tc.repaint();
+	}
+
+	/** Creates a selection and insures that it is visible. */
+	public void setSelection (int startLine, int endLine) {
+		if (startLine>endLine) endLine = startLine;
+		if (startLine<0) startLine = 0;
+		if (endLine<0) endLine = 0;
+		if (startLine>=iRowCount) startLine = iRowCount-1;
+		if (endLine>=iRowCount) endLine = iRowCount-1;
+		selOrigin = startLine;
+		selStart = startLine;
+		selEnd = endLine;
+		int vstart = sbVert.getValue();
+		int visible = sbVert.getVisibleAmount()-1;
+		if (startLine<vstart) {
+			sbVert.setValue(startLine);
+			iY=iRowHeight*startLine;
+		} else if (endLine>=vstart+visible) {
+			vstart = endLine - visible + 1;
+			if (vstart<0) vstart = 0;
+			sbVert.setValue(vstart);
+			iY=iRowHeight*vstart;
+		}
+		tc.repaint();
+	}
+
+
+
+	/** Writes all the text in this TextPanel to a file. */
+	public void save(PrintWriter pw) {
+		resetSelection();
+		if (labels!=null && !labels.equals("")) {
+			String labels2 = labels;
+			if (saveAsCSV)
+				labels2 = labels2.replaceAll("\t",",");
+			pw.println(labels2);
+		}
+		for (int i=0; i<iRowCount; i++) {
+			char[] chars = (char[])(vData.elementAt(i));
+			String s = new String(chars);
+			if (s.endsWith("\t"))
+				s = s.substring(0, s.length()-1);
+			if (saveAsCSV)
+				s = s.replaceAll("\t",",");
+			pw.println(s);
+		}
+		unsavedLines = false;
+	}
+
+	/** Saves the text in this TextPanel to a file. Set 'path' to "" to
+	 * display a "save as" dialog. Returns 'false' if the user cancels
+	 * the dialog.
+	*/
+	public boolean saveAs(String path) {
+		boolean isResults = IJ.isResultsWindow() && IJ.getTextPanel()==this;
+		boolean summarized = false;
+		if (isResults) {
+			String lastLine = iRowCount>=2?getLine(iRowCount-2):null;
+			summarized = lastLine!=null && lastLine.startsWith("Max");
+		}
+		String fileName = null;
+		if (rt!=null && rt.size()>0 && !summarized) {
+			if (path==null || path.equals("")) {
+				IJ.wait(10);
+				String name = isResults?"Results":title;
+				SaveDialog sd = new SaveDialog("Save Table", name, Prefs.defaultResultsExtension());
+				fileName = sd.getFileName();
+				if (fileName==null)
+					return false;
+				path = sd.getDirectory() + fileName;
+			}
+			rt.saveAndRename(path);
+			TextWindow tw = getTextWindow();
+			String title2 = rt.getTitle();
+			if (tw!=null && !"Results".equals(title)) {
+				tw.setTitle(title2);
+				Menus.updateWindowMenuItem(title, title2);
+				title = title2;
+			}
+		} else {
+			if (path.equals("")) {
+				IJ.wait(10);
+				boolean hasHeadings = !getColumnHeadings().equals("");
+				String ext = isResults||hasHeadings?Prefs.defaultResultsExtension():".txt";
+				SaveDialog sd = new SaveDialog("Save as Text", title, ext);
+				String file = sd.getFileName();
+				if (file==null)
+					return false;
+				path = sd.getDirectory() + file;
+			}
+			PrintWriter pw = null;
+			try {
+				FileOutputStream fos = new FileOutputStream(path);
+				BufferedOutputStream bos = new BufferedOutputStream(fos);
+				pw = new PrintWriter(bos);
+			}
+			catch (IOException e) {
+				IJ.error("Save As>Text", e.getMessage());
+				return true;
+			}
+			saveAsCSV = path.endsWith(".csv");
+			save(pw);
+			saveAsCSV = false;
+			pw.close();
+		}
+		if (isResults) {
+			Analyzer.setUnsavedMeasurements(false);
+			if (Recorder.record && !IJ.isMacro())
+				Recorder.record("saveAs", "Results", path);
+		} else if (rt!=null) {
+			if (Recorder.record && !IJ.isMacro())
+				Recorder.record("saveAs", "Results", path);
+		} else {
+			if (Recorder.record && !IJ.isMacro())
+				Recorder.record("saveAs", "Text", path);
+		}
+		IJ.showStatus("");
+		return true;
+	}
+
+	/** Returns all the text as a string. */
+	public synchronized String getText() {
+		if (vData==null)
+			return "";
+		StringBuffer sb = new StringBuffer();
+		if (labels!=null && !labels.equals("")) {
+			sb.append(labels);
+			sb.append('\n');
+		}
+		for (int i=0; i<iRowCount; i++) {
+			if (vData==null) break;
+			char[] chars = (char[])(vData.elementAt(i));
+			sb.append(chars);
+			sb.append('\n');
+		}
+		return new String(sb);
+	}
+
+	public void setTitle(String title) {
+		this.title = title;
+	}
+
+	/** Returns the number of lines of text in this TextPanel. */
+	public int getLineCount() {
+		return iRowCount;
+	}
+
+	/** Returns the specified line as a string. The argument
+		must be greater than or equal to zero and less than
+		the value returned by getLineCount(). */
+	public String getLine(int index) {
+		if (index<0 || index>=iRowCount)
+			throw new IllegalArgumentException("index out of range: "+index);
+		return new String((char[])(vData.elementAt(index)));
+	}
+
+	/** Replaces the contents of the specified line, where 'index'
+		must be greater than or equal to zero and less than
+		the value returned by getLineCount(). */
+	public void setLine(int index, String s) {
+		if (index<0 || index>=iRowCount)
+			throw new IllegalArgumentException("index out of range: "+index);
+		if (vData!=null) {
+			vData.setElementAt(s.toCharArray(), index);
+			tc.repaint();
+		}
+	}
+
+	/** Returns the index of the first selected line, or -1
+		if there is no slection. */
+	public int getSelectionStart() {
+		return selStart;
+	}
+
+	/** Returns the index of the last selected line, or -1
+		if there is no slection. */
+	public int getSelectionEnd() {
+		return selEnd;
+	}
+
+	/** Sets the ResultsTable associated with this TextPanel. */
+	public void setResultsTable(ResultsTable rt) {
+		if (IJ.debugMode) IJ.log("setResultsTable: "+rt);
+		this.rt = rt;
+		if (!menusExtended)
+			extendMenus();
+	}
+
+	/** Returns the ResultsTable associated with this TextPanel, or null. */
+	public ResultsTable getResultsTable() {
+		if (IJ.debugMode) IJ.log("getResultsTable: "+rt);
+		return rt;
+	}
+
+	/** Returns the ResultsTable associated with this TextPanel, or
+		attempts to create one and returns the created table. */
+	public ResultsTable getOrCreateResultsTable() {
+		if ((rt==null||rt.size()==0) && iRowCount>0 && labels!=null && !labels.equals("")) {
+			String tmpDir = IJ.getDir("temp");
+			if (tmpDir==null) {
+				if (IJ.debugMode) IJ.log("getOrCreateResultsTable: tmpDir null");
+				return null;
+			}
+			String path = tmpDir+"temp-table.csv";
+			saveAs(path);
+			try {
+				rt = ResultsTable.open(path);
+				new File(path).delete();
+			} catch (Exception e) {
+				rt = null;
+				if (IJ.debugMode) IJ.log("getOrCreateResultsTable: "+e);
+			}
+		}
+		if (IJ.debugMode) IJ.log("getOrCreateResultsTable: "+rt);
+		return rt;
+	}
+
+	private void extendMenus() {
+		pm.addSeparator();
+		addPopupItem("Rename...");
+		addPopupItem("Duplicate...");
+		addPopupItem("Apply Macro...");
+		addPopupItem("Sort...");
+		addPopupItem("Plot...");
+		if (fileMenu!=null) {
+			fileMenu.add("Rename...");
+			fileMenu.add("Duplicate...");
+		}
+		if (editMenu!=null) {
+			editMenu.addSeparator();
+			editMenu.add("Apply Macro...");
+		}
+		menusExtended = true;
+	}
+
+	public void scrollToTop() {
+		sbVert.setValue(0);
+		iY = 0;
+		for (int i=0; i<iColCount; i++)
+			tc.calcAutoWidth(i);
+		adjustHScroll();
+		tc.repaint();
+	}
+
+	void flush() {
+		if (vData!=null)
+			vData.removeAllElements();
+		vData = null;
+	}
+	
+	private void sort() {
+		ResultsTable rt2 = getOrCreateResultsTable();
+		if (rt2==null)
+			return;
+		String[] headers = rt2.getHeadings();
+		String[] headers2 = headers;
+		if (headers[0].equals("Label")) {
+			headers = new String[headers.length-1];
+			for (int i=0; i<headers.length; i++)
+				headers[i] = headers2[i+1];
+		}
+		GenericDialog gd = new GenericDialog("Sort Table");
+		gd.addChoice ("Column: ", headers, headers[0]);
+		gd.showDialog();
+		if (gd.wasCanceled()) 
+			return;
+		String column = gd.getNextChoice();
+		rt2.sort(column);
+		rt2.show(title);
+		scrollToTop();
+		if (Recorder.record)
+			Recorder.record("Table.sort", column);
+	}
+
+}
diff --git a/src/ij/text/TextWindow.java b/src/ij/text/TextWindow.java
new file mode 100644
index 0000000..eec9794
--- /dev/null
+++ b/src/ij/text/TextWindow.java
@@ -0,0 +1,368 @@
+package ij.text;
+import ij.*;
+import ij.io.*;
+import ij.gui.*;
+import ij.plugin.filter.Analyzer;
+import ij.macro.Interpreter;
+import ij.measure.ResultsTable;
+import java.awt.*;
+import java.io.*;
+import java.awt.event.*;
+import java.util.ArrayList;
+
+/** Uses a TextPanel to displays text in a window.
+	@see TextPanel
+*/
+public class TextWindow extends Frame implements ActionListener, FocusListener, ItemListener {
+
+	public static final String LOC_KEY = "results.loc";
+	public static final String WIDTH_KEY = "results.width";
+	public static final String HEIGHT_KEY = "results.height";
+	public static final String LOG_LOC_KEY = "log.loc";
+	public static final String LOG_WIDTH_KEY = "log.width";
+	public static final String LOG_HEIGHT_KEY = "log.height";
+	public static final String DEBUG_LOC_KEY = "debug.loc";
+	static final String FONT_SIZE = "tw.font.size";
+	static final String FONT_ANTI= "tw.font.anti";
+	TextPanel textPanel;
+    CheckboxMenuItem antialiased;
+	int[] sizes = {9, 10, 11, 12, 13, 14, 16, 18, 20, 24, 36, 48, 60, 72};
+	int fontSize = (int)Prefs.get(FONT_SIZE, 5);
+	MenuBar mb;
+	private static Font font;
+ 
+	/**
+	* Opens a new single-column text window.
+	* @param title	the title of the window
+	* @param text		the text initially displayed in the window
+	* @param width	the width of the window in pixels
+	* @param height	the height of the window in pixels
+	*/
+	public TextWindow(String title, String text, int width, int height) {
+		this(title, "", text, width, height);
+	}
+
+	/**
+	* Opens a new multi-column text window.
+	* @param title	title of the window
+	* @param headings	the tab-delimited column headings
+	* @param text		text initially displayed in the window
+	* @param width	width of the window in pixels
+	* @param height	height of the window in pixels
+	*/
+	public TextWindow(String title, String headings, String text, int width, int height) {
+		super(title);
+		textPanel = new TextPanel(title);
+		textPanel.setColumnHeadings(headings);
+		if (text!=null && !text.equals(""))
+			textPanel.append(text);
+		create(title, textPanel, width, height);
+	}
+
+	/**
+	* Opens a new multi-column text window.
+	* @param title	title of the window
+	* @param headings	tab-delimited column headings
+	* @param text		ArrayList containing the text to be displayed in the window
+	* @param width	width of the window in pixels
+	* @param height	height of the window in pixels
+	*/
+	public TextWindow(String title, String headings, ArrayList text, int width, int height) {
+		super(title);
+		textPanel = new TextPanel(title);
+		textPanel.setColumnHeadings(headings);
+		if (text!=null)
+			textPanel.append(text);
+		create(title, textPanel, width, height);
+	}
+
+	private void create(String title, TextPanel textPanel, int width, int height) {
+		enableEvents(AWTEvent.WINDOW_EVENT_MASK);
+		if (IJ.isLinux()) setBackground(ImageJ.backgroundColor);
+		add("Center", textPanel);
+		addKeyListener(textPanel);
+		ImageJ ij = IJ.getInstance();
+		if (ij!=null) {
+			textPanel.addKeyListener(ij);
+			if (!IJ.isMacOSX()) {
+				Image img = ij.getIconImage();
+				if (img!=null)
+					try {setIconImage(img);} catch (Exception e) {}
+			}
+		}
+ 		addFocusListener(this);
+ 		addMenuBar();
+		setFont();
+		WindowManager.addWindow(this);
+		Point loc=null;
+		int w=0, h=0;
+		if (title.equals("Results")) {
+			loc = Prefs.getLocation(LOC_KEY);
+			w = (int)Prefs.get(WIDTH_KEY, 0.0);
+			h = (int)Prefs.get(HEIGHT_KEY, 0.0);
+		} else if (title.equals("Log")) {
+			loc = Prefs.getLocation(LOG_LOC_KEY);
+			w = (int)Prefs.get(LOG_WIDTH_KEY, 0.0);
+			h = (int)Prefs.get(LOG_HEIGHT_KEY, 0.0);
+		} else if (title.equals("Debug")) {
+			loc = Prefs.getLocation(DEBUG_LOC_KEY);
+			w = width;
+			h = height;
+		}
+		if (loc!=null&&w>0 && h>0) {
+			setSize(w, h);
+			setLocation(loc);
+		} else {
+			setSize(width, height);
+			if (!IJ.debugMode)
+				GUI.centerOnImageJScreen(this);
+		}
+		show();
+		WindowManager.setWindow(this);
+	}
+
+	/**
+	* Opens a new text window containing the contents of a text file.
+	* @param path		the path to the text file
+	* @param width	the width of the window in pixels
+	* @param height	the height of the window in pixels
+	*/
+	public TextWindow(String path, int width, int height) {
+		super("");
+		enableEvents(AWTEvent.WINDOW_EVENT_MASK);
+		textPanel = new TextPanel();
+		textPanel.addKeyListener(IJ.getInstance());
+		add("Center", textPanel);
+		if (openFile(path)) {
+			WindowManager.addWindow(this);
+			setSize(width, height);
+			show();
+			WindowManager.setWindow(this);
+		} else
+			dispose();
+	}
+	
+	void addMenuBar() {
+		mb = new MenuBar();
+		if (Menus.getFontSize()!=0)
+			mb.setFont(Menus.getFont());
+		Menu m = new Menu("File");
+		m.add(new MenuItem("Save As...", new MenuShortcut(KeyEvent.VK_S)));
+		if (getTitle().equals("Results")) {
+			m.add(new MenuItem("Rename..."));
+			m.add(new MenuItem("Duplicate..."));
+		}
+		m.addActionListener(this);
+		mb.add(m);
+		textPanel.fileMenu = m;
+		m = new Menu("Edit");
+		m.add(new MenuItem("Cut", new MenuShortcut(KeyEvent.VK_X)));
+		m.add(new MenuItem("Copy", new MenuShortcut(KeyEvent.VK_C)));
+		m.add(new MenuItem("Clear"));
+		m.add(new MenuItem("Select All", new MenuShortcut(KeyEvent.VK_A)));
+		m.addSeparator();
+		m.add(new MenuItem("Find...", new MenuShortcut(KeyEvent.VK_F)));
+		m.add(new MenuItem("Find Next", new MenuShortcut(KeyEvent.VK_G)));
+		m.addActionListener(this);
+		mb.add(m);
+		textPanel.editMenu = m;
+		m = new Menu("Font");
+		m.add(new MenuItem("Make Text Smaller"));
+		m.add(new MenuItem("Make Text Larger"));
+		m.addSeparator();
+		antialiased = new CheckboxMenuItem("Antialiased", Prefs.get(FONT_ANTI, IJ.isMacOSX()?true:false));
+		antialiased.addItemListener(this);
+		m.add(antialiased);
+		m.add(new MenuItem("Save Settings"));
+		m.addActionListener(this);
+		mb.add(m);
+		if (getTitle().equals("Results")) {
+			m = new Menu("Results");
+			m.add(new MenuItem("Clear Results"));
+			m.add(new MenuItem("Summarize"));
+			m.add(new MenuItem("Distribution..."));
+			m.add(new MenuItem("Set Measurements..."));
+			m.add(new MenuItem("Sort..."));
+			m.add(new MenuItem("Plot..."));
+			m.add(new MenuItem("Options..."));
+			m.addActionListener(this);
+			mb.add(m);
+		}
+		setMenuBar(mb);
+	}
+
+	/**
+	Adds one or more lines of text to the window.
+	@param text		The text to be appended. Multiple
+					lines should be separated by \n.
+	*/
+	public void append(String text) {
+		textPanel.append(text);
+	}
+	
+	void setFont() {
+		if (font!=null)
+       		textPanel.setFont(font, antialiased.getState());
+       	else
+       		textPanel.setFont(new Font("SanSerif", Font.PLAIN, sizes[fontSize]), antialiased.getState());
+	}
+	
+	boolean openFile(String path) {
+		OpenDialog od = new OpenDialog("Open Text File...", path);
+		String directory = od.getDirectory();
+		String name = od.getFileName();
+		if (name==null)
+			return false;
+		path = directory + name;
+		
+		IJ.showStatus("Opening: " + path);
+		try {
+			BufferedReader r = new BufferedReader(new FileReader(directory + name));
+			load(r);
+			r.close();
+		}
+		catch (Exception e) {
+			IJ.error(e.getMessage());
+			return true;
+		}
+		textPanel.setTitle(name);
+		setTitle(name);
+		IJ.showStatus("");
+		return true;
+	}
+	
+	/** Returns a reference to this TextWindow's TextPanel. */
+	public TextPanel getTextPanel() {
+		return textPanel;
+	}
+	
+	/** Returns the ResultsTable associated with this TextWindow, or null. */
+	public ResultsTable getResultsTable() {
+		return textPanel!=null?textPanel.getResultsTable():null;
+	}
+
+
+	/** Appends the text in the specified file to the end of this TextWindow. */
+	public void load(BufferedReader in) throws IOException {
+		int count=0;
+		while (true) {
+			String s=in.readLine();
+			if (s==null) break;
+			textPanel.appendLine(s);
+		}
+	}
+
+	public void actionPerformed(ActionEvent evt) {
+		String cmd = evt.getActionCommand();
+		if (cmd.equals("Make Text Larger"))
+			changeFontSize(true);
+		else if (cmd.equals("Make Text Smaller"))
+			changeFontSize(false);
+		else if (cmd.equals("Save Settings"))
+			saveSettings();
+		else
+			textPanel.doCommand(cmd);
+	}
+
+	public void processWindowEvent(WindowEvent e) {
+		super.processWindowEvent(e);
+		int id = e.getID();
+		if (id==WindowEvent.WINDOW_CLOSING)
+			close();	
+		else if (id==WindowEvent.WINDOW_ACTIVATED && !"Log".equals(getTitle()))
+			WindowManager.setWindow(this);
+	}
+
+	public void itemStateChanged(ItemEvent e) {
+        setFont();
+	}
+
+	public void close() {
+		close(true);
+	}
+	
+	/** Closes this TextWindow. Display a "save changes" dialog
+		if this is the "Results" window and 'showDialog' is true. */
+	public void close(boolean showDialog) {
+		if (getTitle().equals("Results")) {
+			if (showDialog && !Analyzer.resetCounter())
+				return;
+			IJ.setTextPanel(null);
+			Prefs.saveLocation(LOC_KEY, getLocation());
+			Dimension d = getSize();
+			Prefs.set(WIDTH_KEY, d.width);
+			Prefs.set(HEIGHT_KEY, d.height);
+		} else if (getTitle().equals("Log")) {
+			Prefs.saveLocation(LOG_LOC_KEY, getLocation());
+			Dimension d = getSize();
+			Prefs.set(LOG_WIDTH_KEY, d.width);
+			Prefs.set(LOG_HEIGHT_KEY, d.height);
+			IJ.setDebugMode(false);
+			IJ.log("\\Closed");
+			IJ.notifyEventListeners(IJEventListener.LOG_WINDOW_CLOSED);
+		} else if (getTitle().equals("Debug")) {
+			Prefs.saveLocation(DEBUG_LOC_KEY, getLocation());
+		} else if (textPanel!=null && textPanel.rt!=null) {
+			if (!saveContents()) return;
+		}
+		//setVisible(false);
+		dispose();
+		WindowManager.removeWindow(this);
+		textPanel.flush();
+	}
+	
+	public void rename(String title) {
+		textPanel.rename(title);
+	}
+	
+	boolean saveContents() {
+		int lineCount = textPanel.getLineCount();
+		if (!textPanel.unsavedLines) lineCount = 0;
+		ImageJ ij = IJ.getInstance();
+		boolean macro = IJ.macroRunning() || Interpreter.isBatchMode();
+		boolean isResults = getTitle().contains("Results");
+		if (lineCount>0 && !macro && ij!=null && !ij.quitting() && isResults) {
+			YesNoCancelDialog d = new YesNoCancelDialog(this, getTitle(), "Save "+lineCount+" measurements?");
+			if (d.cancelPressed())
+				return false;
+			else if (d.yesPressed()) {
+				if (!textPanel.saveAs(""))
+					return false;
+			}
+		}
+		textPanel.rt.reset();
+		return true;
+	}
+	
+	void changeFontSize(boolean larger) {
+        int in = fontSize;
+        if (larger) {
+            fontSize++;
+            if (fontSize==sizes.length)
+                fontSize = sizes.length-1;
+        } else {
+            fontSize--;
+            if (fontSize<0)
+                fontSize = 0;
+        }
+        IJ.showStatus(sizes[fontSize]+" point");
+        font = null;
+        setFont();
+    }
+    
+    public static void setFont(String name, int style, int size) {
+    	font = new Font(name,style,size);
+    }
+
+	void saveSettings() {
+		Prefs.set(FONT_SIZE, fontSize);
+		Prefs.set(FONT_ANTI, antialiased.getState());
+		IJ.showStatus("Font settings saved (size="+sizes[fontSize]+", antialiased="+antialiased.getState()+")");
+	}
+	
+	public void focusGained(FocusEvent e) {
+	}
+
+	public void focusLost(FocusEvent e) {}
+
+}
diff --git a/src/ij/util/ArrayUtil.java b/src/ij/util/ArrayUtil.java
new file mode 100644
index 0000000..7b715e8
--- /dev/null
+++ b/src/ij/util/ArrayUtil.java
@@ -0,0 +1,164 @@
+package ij.util;
+import java.util.Arrays;
+
+public class ArrayUtil {
+	private int size;
+	float[] values;
+	boolean sorted;
+
+	public void setSize(int si) {
+		size = si;
+	}
+
+	/**
+	 * constructeur
+	 *
+	 * @param size number of elements
+	 */
+	public ArrayUtil(int size) {
+		this.size = size;
+		values = new float[size];
+		sorted = false;
+	}
+	
+	/**
+	 * constructeur
+	 *
+	 * @param data float array
+	 */
+	public ArrayUtil(float[] data) {
+		this.size = data.length;
+		sorted = false;
+		values = data;
+	}
+
+	/**
+	 * put a value to a index
+	 *
+	 * @param pos position in the array
+	 * @param value value to put
+	 * @return false if position does not exist
+	 */
+	public boolean putValue(int pos, float value) {
+		if (pos<size) {
+			values[pos] = value;
+			sorted = false;
+			return true;
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Average value
+	 * @return average value
+	 */
+	public double getMean() {
+		double total = 0;
+		for (int i=0; i<size; i++)
+			total += values[i];
+		return total/size;
+	}
+
+	/**
+	 * The median (sorted array)
+	 * @return mediane
+	 */
+	public double medianSort() {
+		if (!sorted)
+			sort();
+		if (size % 2==1)
+			return values[size/2];
+		else
+			return (0.5f * (values[size/2 - 1] + values[size/2]));
+	}
+
+	public void sort() {
+		if (size<values.length) {
+			float[] tosort = new float[size];
+			System.arraycopy(values, 0, tosort, 0, size);
+			Arrays.sort(tosort);
+			System.arraycopy(tosort, 0, values, 0, size);
+		} else
+			Arrays.sort(values);
+		sorted = true;
+	}
+
+	public boolean isMaximum(double val) {
+		int i = 0;
+		boolean maxok = true;
+		while ((i<size) && (values[i]<=val)) {
+			i++;
+		}
+		if (i < size) {
+			maxok = false;
+		}
+		return maxok;
+	}
+
+	/**
+	 * The minimum value
+	 *
+	 * @return min value
+	 */
+	public double getMinimum() {
+		double min = values[0];
+		for (int i = 1; i < size; i++) {
+			if (values[i] < min) {
+				min = values[i];
+			}
+		}
+		return min;
+	}
+
+	/**
+	 * The maximum value
+	 *
+	 * @return max value
+	 */
+	public double getMaximum() {
+		double max = values[0];
+		for (int i = 1; i < size; i++) {
+			if (values[i] > max) {
+				max = values[i];
+			}
+		}
+		return max;
+	}
+
+	/**
+	 * Variance value 
+	 *
+	 * @return variance
+	 */
+	public double getVariance() {
+	   if (size == 1) {
+			return 0;
+		}
+
+		double total = 0;
+		double total2 = 0;
+
+		for (int i = 0; i < size; i++) {
+			total += values[i];
+			total2 += values[i] * values[i];
+		}
+
+		double var = (double) ((total2 - (total * total / size)) / (size - 1));
+		return var;
+	}
+	
+	
+	/**
+	 * information to be displayed
+	 *
+	 * @return text
+	 */
+	public String toString() {
+		String str = "{" + values[0];
+		for (int i = 1; i < size; i++) {
+			str = str + ", " + values[i];
+		}
+		return str + "}";
+	}
+}
diff --git a/src/ij/util/DicomTools.java b/src/ij/util/DicomTools.java
new file mode 100644
index 0000000..d48082e
--- /dev/null
+++ b/src/ij/util/DicomTools.java
@@ -0,0 +1,169 @@
+package ij.util;
+import ij.*;
+import ij.process.*;
+import ij.plugin.DICOM;
+
+/** DICOM utilities */
+public class DicomTools {
+	private static final int MAX_DIGITS = 5;
+	private static String[] sliceLabels;
+
+	/** Sorts a DICOM stack by image number. */
+	public static ImageStack sort(ImageStack stack) {
+		if (IJ.debugMode) IJ.log("Sorting by DICOM image number");
+		if (stack.size()==1) return stack;
+		String[] strings = getSortStrings(stack, "0020,0013");
+		if (strings==null) return stack;
+		StringSorter.sort(strings);
+		ImageStack stack2 = null;
+		if (stack.isVirtual())
+			stack2 = ((VirtualStack)stack).sortDicom(strings, sliceLabels, MAX_DIGITS);
+		else
+			stack2 = sortStack(stack, strings);
+		return stack2!=null?stack2:stack;
+	}
+	
+	private static ImageStack sortStack(ImageStack stack, String[] strings) {
+		ImageProcessor ip = stack.getProcessor(1);
+		ImageStack stack2 = new ImageStack(ip.getWidth(), ip.getHeight(), ip.getColorModel());
+		for (int i=0; i<stack.size(); i++) {
+			int slice = (int)Tools.parseDouble(strings[i].substring(strings[i].length()-MAX_DIGITS), 0.0);
+			if (slice==0) return null;
+			stack2.addSlice(sliceLabels[slice-1], stack.getPixels(slice));
+		}
+		stack2.update(stack.getProcessor(1));
+		return stack2;
+	}
+
+	private static String[] getSortStrings(ImageStack stack, String tag) {
+		double series = getSeriesNumber(getSliceLabel(stack,1));
+		int n = stack.size();
+		boolean checkRescaleSlope = (stack instanceof VirtualStack)?((VirtualStack)stack).getBitDepth()==16:false;
+		if (Prefs.ignoreRescaleSlope)
+			checkRescaleSlope = false;
+		boolean showError = false;
+		String[] values = new String[n];
+		sliceLabels = new String[n];
+		for (int i=1; i<=n; i++) {
+			String tags = getSliceLabel(stack,i);
+			if (tags==null) return null;
+			sliceLabels[i-1] = tags;
+			double value = getNumericTag(tags, tag);
+			if (Double.isNaN(value)) {
+				if (IJ.debugMode) IJ.log("  "+tag+"  tag missing in slice "+i);
+				if (showError) rescaleSlopeError(stack);
+				return null;
+			}
+			if (getSeriesNumber(tags)!=series) {
+				if (IJ.debugMode) IJ.log("  all slices must be part of the same series");
+				if (showError) rescaleSlopeError(stack);
+				return null;
+			}
+			values[i-1] = toString(value, MAX_DIGITS) + toString(i, MAX_DIGITS);
+			if (checkRescaleSlope) {
+				double rescaleSlope = getNumericTag(tags, "0028,1053");
+				if (rescaleSlope!=1.0)
+					showError = true;
+			}
+		}
+		if (showError) rescaleSlopeError(stack);
+		return values;
+	}
+	
+	private static void rescaleSlopeError(ImageStack stack) {
+		((VirtualStack)stack).setBitDepth(32);
+	}
+
+	private static String toString(double value, int width) {
+		String s = "       " + IJ.d2s(value,0);
+		return s.substring(s.length()-MAX_DIGITS);
+	}
+	
+	private static String getSliceLabel(ImageStack stack, int n) {
+		String info = stack.getSliceLabel(n);
+		if ((info==null || info.length()<100) && stack.isVirtual()) {
+			String dir = ((VirtualStack)stack).getDirectory();
+			String name = ((VirtualStack)stack).getFileName(n);
+			DICOM reader = new DICOM();
+			info = reader.getInfo(dir+name);
+			if (info!=null)
+				info = name + "\n" + info;
+		}
+		return info;
+	}
+
+	/** Calculates the voxel depth of the specified DICOM stack based 
+		on the distance between the first and last slices. */
+	public static double getVoxelDepth(ImageStack stack) {
+		if (stack.isVirtual()) stack.getProcessor(1);
+		String pos0 = getTag(stack.getSliceLabel(1), "0020,0032");
+		String posn = null;
+		double voxelDepth = -1.0;
+		if (pos0!=null) {
+			String[] xyz = pos0.split("\\\\");
+			if (xyz.length!=3) return voxelDepth;
+			double z0 = Double.parseDouble(xyz[2]);
+			if (stack.isVirtual()) stack.getProcessor(stack.size());
+			posn = getTag(stack.getSliceLabel(stack.size()), "0020,0032");
+			if (posn==null) return voxelDepth;
+			xyz = posn.split("\\\\");
+			if (xyz.length!=3) return voxelDepth;
+			double zn = Double.parseDouble(xyz[2]);
+			voxelDepth = Math.abs((zn - z0) / (stack.size() - 1));
+		}
+		if (IJ.debugMode) IJ.log("DicomTools.getVoxelDepth: "+voxelDepth+"  "+pos0+"  "+posn);
+		return voxelDepth;
+	}
+
+	/** Returns the value (as a string) of the specified DICOM tag id (in the form "0018,0050")
+		of the specified image or stack slice. Returns null if the tag id is not found. */
+	public static String getTag(ImagePlus imp, String id) {
+		String metadata = null;
+		if (imp.getStackSize()>1) {
+			ImageStack stack = imp.getStack();
+			String label = stack.getSliceLabel(imp.getCurrentSlice());
+			if (label!=null && label.indexOf('\n')>0) metadata = label;
+		}
+		if (metadata==null)
+			metadata = (String)imp.getProperty("Info");
+		return getTag(metadata, id);
+	}
+	
+	/** Returns the name of the specified DICOM tag id. */
+	public static String getTagName(String id) {
+		return DICOM.getTagName(id);
+	}
+		
+	private static double getSeriesNumber(String tags) {
+		double series = getNumericTag(tags, "0020,0011");
+		if (Double.isNaN(series)) series = 0;
+		return series;
+	}
+
+	private static double getNumericTag(String hdr, String tag) {
+		String value = getTag(hdr, tag);
+		if (value==null) return Double.NaN;
+		int index3 = value.indexOf("\\");
+		if (index3>0)
+			value = value.substring(0, index3);
+		return Tools.parseDouble(value);
+	}
+
+	private static String getTag(String hdr, String tag) {
+		if (hdr==null) return null;
+		int index1 = hdr.indexOf(tag);
+		if (index1==-1) return null;
+		//IJ.log(hdr.charAt(index1+11)+"   "+hdr.substring(index1,index1+20));
+		if (hdr.charAt(index1+11)=='>') {
+			// ignore tags in sequences
+			index1 = hdr.indexOf(tag, index1+10);
+			if (index1==-1) return null;
+		}
+		index1 = hdr.indexOf(":", index1);
+		if (index1==-1) return null;
+		int index2 = hdr.indexOf("\n", index1);
+		String value = hdr.substring(index1+1, index2);
+		return value;
+	}
+
+}
diff --git a/src/ij/util/FloatArray.java b/src/ij/util/FloatArray.java
new file mode 100644
index 0000000..6d144dd
--- /dev/null
+++ b/src/ij/util/FloatArray.java
@@ -0,0 +1,99 @@
+package ij.util;
+
+/** This class implements an expandable float array similar
+ * to an ArrayList or Vector but more efficient.
+ *  Calls to this class are not synchronized.
+ * @author Michael Schmid
+*/
+ public class FloatArray {
+	private int size;
+	private float[] data;
+
+	/** Creates a new expandable array with an initial capacity of 100. */
+	public FloatArray() {
+		this(100);
+	}
+
+	/** Creates a new expandable array with specified initial capacity.
+	 * @throws IllegalArgumentException if the specified initial capacity is less than zero */
+	public FloatArray(int initialCapacity) {
+		if (initialCapacity < 0) throw new IllegalArgumentException("Illegal FloatArray Capacity: "+initialCapacity);
+		data = new float[initialCapacity];
+	}
+
+	/** Returns the number of elements in the array. */
+	public int size() {
+		return size;
+	}
+
+	/** Removes all elements form this FloatArray. */
+	public void clear() {
+		size = 0;
+	}
+
+	/** Returns a float array containing all elements of this FloatArray. */
+	public float[] toArray() {
+		float[] out = new float[size];
+		System.arraycopy(data, 0, out, 0, size);
+		return out;
+	}
+
+	/** Returns the element at the specified position in this FloatArray.
+	 *  @throws IndexOutOfBoundsException - if index is out of range (<code>index < 0 || index >= size()</code>). */
+	public float get(int index) {
+		if (index<0 || index>= size) throw new IndexOutOfBoundsException("FloatArray Index out of Bounds: "+index);
+		return data[index];
+	}
+
+	/** Returns the last element of this FloatArray.
+	 *  @throws IndexOutOfBoundsException - if this FloatArray is empty */
+	public float getLast() {
+		return get(size-1);
+	}
+
+	/** Replaces the element at the specified position with the value given. 
+	 *  @return the value previously at the specified position.
+	 *  @throws IndexOutOfBoundsException - if index is out of range (<code>index < 0 || index >= size()</code>). */
+	public float set(int index, float value) {
+		if (index<0 || index>= size) throw new IndexOutOfBoundsException("FloatArray Index out of Bounds: "+index);
+		float previousValue = data[index];
+		data[index] = value;
+		return previousValue;
+	}
+
+	/** Appends the specified value to the end of this FloatArray. Returns the number of elements after adding. */
+	public int add(float value) {
+		if (size >= data.length) {
+			float[] newData = new float[size*2 + 50];
+			System.arraycopy(data, 0, newData, 0, size);
+			data = newData;
+		}
+		data[size++] = value;
+		return size;
+	}
+
+	/** Appends the first n values from the specified array to this FloatArray. Returns the number of elements after adding. */
+	public int add(float[] a, int n) {
+		if (size + n > data.length) {
+			float[] newData = new float[size*2 + n + 50];
+			System.arraycopy(data, 0, newData, 0, size);
+			data = newData;
+		}
+		System.arraycopy(a, 0, data, size, n);
+		size += n;
+		return size;
+	}
+
+	/** Deletes the last <code>n</code> element from this FloatArray. <code>n</code> may be larger than the number of elements; in that
+	 *  case, all elements are removed. */
+	public void removeLast(int n) {
+		size -= Math.min(n, size);
+	}
+
+	/** Trims the capacity of this FloatArray instance to be its current size,
+	 *  minimizing the storage of the FloatArray instance. */
+	public void trimToSize() {
+		data = toArray();
+	}
+	
+}
diff --git a/src/ij/util/FontUtil.java b/src/ij/util/FontUtil.java
new file mode 100644
index 0000000..9b91158
--- /dev/null
+++ b/src/ij/util/FontUtil.java
@@ -0,0 +1,56 @@
+package ij.util;
+import java.text.*;
+import java.awt.*;
+
+/** This class contains static utility methods for replacing fonts that are not available on the
+ *  current system.
+ */
+
+public class FontUtil {
+
+	/** Returns a font with the given family name or, if not available, a similar font, e.g. Helvetica replaced by Arial */
+	public static Font getFont(String fontFamilyName, int style, float size) {
+		Font font = new Font(fontFamilyName, style, (int)size);
+		if (!font.getFamily().startsWith(fontFamilyName)) {
+			String[] similarFonts = getSimilarFontsList(fontFamilyName);
+			font = getFont(similarFonts, style, (int)size);
+		}
+		if (size != (int)size)
+			font = font.deriveFont(size);
+		return font;
+	}
+
+	/** Returns the font for first element of the 'fontNames' array, where a Font Family Name starts with this name.
+	 *	E.g. if fontNames = {"Times New Roman", "Serif" and the system has no "Times New Roman", but finds "Serif",
+	 *	it would return a "Serif" font with suitable style and size */
+	private static Font getFont(String[] fontNames, int style, int size) {
+		int iSize = (int)size;
+		Font font = null;
+		for (String fontName : fontNames) {
+			font = new Font(fontName, style, iSize);
+			if (font.getFamily().startsWith(fontName))
+				break;
+		}
+		return font;
+	}
+
+	/** For a few basic font types, gets a list of replacement font families
+	 *	Note that java's 'SansSerif' has wider characters (significantly different metrics) than the other
+	 *	sans-serif fonts in the list; thus it should be considered a fallback option only.
+	 *	Also note that some fonts (Times, Helvetica, Courier, Monospace, Serif) tend to truncate some
+	 *	diacritical marks when using FontMetrics.getHeight (as ImageJ does), e.g. the ring of the
+	 *  Angstrom symbol Å may be clipped (at least on Java 1.6/Mac)
+	 */
+	public static String[] getSimilarFontsList(String fontFamily) {
+		if (fontFamily.indexOf("Times")>=0 || fontFamily.indexOf("Serif")>=0)
+			return new String[]{"Times New Roman", "Times", "Liberation Serif", "Serif"};
+		else if (fontFamily.indexOf("Arial")>=0 || fontFamily.indexOf("Helvetica")>=0 || fontFamily.indexOf("Sans")>=0)
+			return new String[]{"Arial", "Helvetica", "Helvetica Neue", "Liberation Sans", "SansSerif"};
+		else if (fontFamily.indexOf("Courier")>=0 || fontFamily.indexOf("Mono")>=0)
+			return new String[]{"Courier New", "Courier", "Liberation Mono", "Monospaced"};
+		else
+			return new String[]{fontFamily};
+	}
+
+
+}
diff --git a/src/ij/util/IJMath.java b/src/ij/util/IJMath.java
new file mode 100644
index 0000000..66d5707
--- /dev/null
+++ b/src/ij/util/IJMath.java
@@ -0,0 +1,34 @@
+package ij.util;
+
+public class IJMath {
+
+	static double A = 0.05857895078654250866288;
+	static double B = -0.00626245895772819579;
+	static double C = -0.00299946450696036814;
+	static double D = 0.289389696496082416;
+	static double E = 0.0539962589851632982;
+	static double F = 0.00508516909930653109;
+	static double G = 0.000215969713046142876;
+	static double H = -0.000225663858340491571;
+	static double I = -3.06833213472529049e-7;
+
+	/* This approximation of the error function erf has maximum absolute and relative errors below 1e-12
+	 * Except for low and high x, it is based on the type erf(x) = sgn(x) * sqrt(1-exp(-x^2*f(x)),
+	 * with the function f(x) having a smooth transition from 4/pi = 1.273... at x=0 to 1 at high x */
+	public static double erf(double x) {
+		double x2 = sqr(x);
+		if (x2 < 1e-8)
+			return (2/Math.sqrt(Math.PI))*x*(1+x2*(-1./3.+x2*(1./10.)));  // Taylor series for low x
+		double erf = x2 > 36 ? 1 :  //the polynomials go crazy for some large x2; erf(6) is 1 - 2e-17, less than ulp from 1
+				Math.sqrt(1 - Math.exp(-sqr(x*((2/Math.sqrt(Math.PI) - A) + A *
+				(1 + x2*x2*(B + x2*(C + x2*(H + x2*I)))) /
+				(1 + x2*(D + x2*(E + x2*(F + x2*G))))
+				))));
+		return x>0 ? erf : -erf; //could be Math.copySign in Java 1.6 & up
+	}
+
+	static double sqr(double x) {
+		return x*x;
+	}
+	
+}
diff --git a/src/ij/util/Java2.java b/src/ij/util/Java2.java
new file mode 100644
index 0000000..59c2e5b
--- /dev/null
+++ b/src/ij/util/Java2.java
@@ -0,0 +1,55 @@
+package ij.util;
+import ij.*;
+import ij.Prefs;
+import java.awt.*;
+import javax.swing.*;
+
+/**
+This class contains static methods that use the Java 2 API. They are isolated 
+here to prevent errors when ImageJ is running on Java 1.1 JVMs.
+*/
+public class Java2 {
+
+	private static boolean lookAndFeelSet;
+
+	public static void setAntialiased(Graphics g, boolean antialiased) {
+			Graphics2D g2d = (Graphics2D)g;
+			if (antialiased)
+				g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+			else
+				g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
+	}
+
+	public static void setAntialiasedText(Graphics g, boolean antialiasedText) {
+			Graphics2D g2d = (Graphics2D)g;
+			if (antialiasedText)
+				g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
+			else
+				g2d.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+	}
+
+	public static int getStringWidth(String s, FontMetrics fontMetrics, Graphics g) {
+			java.awt.geom.Rectangle2D r = fontMetrics.getStringBounds(s, g);
+			return (int)r.getWidth();
+	}
+
+	public static void setBilinearInterpolation(Graphics g, boolean bilinearInterpolation) {
+			Graphics2D g2d = (Graphics2D)g;
+			if (bilinearInterpolation)
+				g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+			else
+				g2d.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+	}
+	
+	/** Sets the Swing look and feel to the system look and feel (Windows only). */
+	public static void setSystemLookAndFeel() {
+		if (lookAndFeelSet || !IJ.isWindows()) return;
+		try {
+			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+		} catch(Throwable t) {}
+		lookAndFeelSet = true;
+		IJ.register(Java2.class);
+	}
+
+}
+
diff --git a/src/ij/util/StringSorter.java b/src/ij/util/StringSorter.java
new file mode 100644
index 0000000..9b4a626
--- /dev/null
+++ b/src/ij/util/StringSorter.java
@@ -0,0 +1,110 @@
+package ij.util;
+
+/** A simple QuickSort for String arrays. */
+public class StringSorter {
+	
+	/** Sorts the array. */
+	public static void sort(String[] a) {
+		if (!alreadySorted(a))
+			sort(a, 0, a.length - 1);
+	}
+	
+	static void sort(String[] a, int from, int to) {
+		int i = from, j = to;
+		String center = a[ (from + to) / 2 ];
+		do {
+			while ( i < to && center.compareTo(a[i]) > 0 ) i++;
+			while ( j > from && center.compareTo(a[j]) < 0 ) j--;
+			if (i < j) {String temp = a[i]; a[i] = a[j]; a[j] = temp; }
+			if (i <= j) { i++; j--; }
+		} while(i <= j);
+		if (from < j) sort(a, from, j);
+		if (i < to) sort(a,  i, to);
+	}
+		
+	static boolean alreadySorted(String[] a) {
+		for ( int i=1; i<a.length; i++ ) {
+			if (a[i].compareTo(a[i-1]) < 0 )
+			return false;
+		}
+		return true;
+	}
+	
+	/** Sorts file names containing numerical components.
+	* Author: Norbert Vischer
+	*/
+	public static String[] sortNumerically(String[] list) {
+		int n = list.length;
+		String[] paddedList = getPaddedNames(list);
+		String[] sortedList = new String[n];
+		int[] indexes = Tools.rank(paddedList);
+		for (int i = 0; i < n; i++)
+			sortedList[i] = list[indexes[i]];
+		return sortedList;
+	}
+
+	// Pads individual numeric string components with zeroes for correct sorting
+	private static String[] getPaddedNames(String[] names) {
+		int nNames = names.length;
+		String[] paddedNames = new String[nNames];
+		int maxLen = 0;
+		for (int jj = 0; jj < nNames; jj++) {
+			if (names[jj].length() > maxLen) {
+				maxLen = names[jj].length();
+			}
+		}
+		int maxNums = maxLen / 2 + 1;//calc array sizes
+		int[][] numberStarts = new int[names.length][maxNums];
+		int[][] numberLengths = new int[names.length][maxNums];
+		int[] maxDigits = new int[maxNums];
+
+		//a) record position and digit count of 1st, 2nd, .. n-th number in string
+		for (int jj = 0; jj < names.length; jj++) {
+			String name = names[jj];
+			boolean inNumber = false;
+			int nNumbers = 0;
+			int nDigits = 0;
+			for (int pos = 0; pos < name.length(); pos++) {
+				boolean isDigit = name.charAt(pos) >= '0' && name.charAt(pos) <= '9';
+				if (isDigit) {
+					nDigits++;
+					if (!inNumber) {
+						numberStarts[jj][nNumbers] = pos;
+						inNumber = true;
+					}
+				}
+				if (inNumber && (!isDigit || (pos == name.length() - 1))) {
+					inNumber = false;
+					if (maxDigits[nNumbers] < nDigits) {
+						maxDigits[nNumbers] = nDigits;
+					}
+					numberLengths[jj][nNumbers] = nDigits;
+					nNumbers++;
+					nDigits = 0;
+				}
+			}
+		}
+		
+		//b) perform padding
+		for (int jj = 0; jj < names.length; jj++) {
+			String name = names[jj];
+			int numIndex = 0;
+			StringBuilder destName = new StringBuilder();
+			for (int srcPtr = 0; srcPtr < name.length(); srcPtr++) {
+				if (srcPtr == numberStarts[jj][numIndex]) {
+					int numLen = numberLengths[jj][numIndex];
+					if (numLen > 0) {
+						for (int pad = 0; pad < (maxDigits[numIndex] - numLen); pad++) {
+							destName.append('0');
+						}
+					}
+					numIndex++;
+				}
+				destName.append(name.charAt(srcPtr));
+			}
+			paddedNames[jj] = destName.toString();
+		}
+		return paddedNames;
+	}
+
+}
diff --git a/src/ij/util/ThreadUtil.java b/src/ij/util/ThreadUtil.java
new file mode 100644
index 0000000..022c35f
--- /dev/null
+++ b/src/ij/util/ThreadUtil.java
@@ -0,0 +1,149 @@
+package ij.util;
+import java.util.concurrent.*;
+
+public class ThreadUtil {
+	
+	/** Start all given threads and wait on each of them until all are done.
+	 * From Stephan Preibisch's Multithreading.java class. See:
+	 * http://repo.or.cz/w/trakem2.git?a=blob;f=mpi/fruitfly/general/MultiThreading.java;hb=HEAD
+	 * @param threads 
+	 */
+	public static void startAndJoin(Thread[] threads) {
+		for (int ithread = 0; ithread < threads.length; ++ithread) {
+			threads[ithread].setPriority(Thread.NORM_PRIORITY);
+			threads[ithread].start();
+		}
+
+		try {
+			for (int ithread = 0; ithread < threads.length; ++ithread) {
+				threads[ithread].join();
+			}
+		} catch (InterruptedException ie) {
+			throw new RuntimeException(ie);
+		}
+	}
+
+	public static Thread[] createThreadArray(int nb) {
+		if (nb == 0) {
+			nb = getNbCpus();
+		}
+		Thread[] threads = new Thread[nb];
+
+		return threads;
+	}
+
+	public static Thread[] createThreadArray() {
+		return createThreadArray(0);
+	}
+
+	public static int getNbCpus() {
+		return Runtime.getRuntime().availableProcessors();
+	}
+
+	/*--------------------------------------------------------------------------*/
+	/* The following is for parallelization using a ThreadPool, which avoids the
+	 * overhead of creating threads, and is therefore faster if each thread has
+	 * only a short task to perform */
+
+	/** The threadPoolExecutor holds at least as many threads for parallel execution as the number of
+	 *  processors; additional threads are added as required. These additional threads will be
+	 *  terminated if idle for 120 seconds. */
+	public static ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
+			Runtime.getRuntime().availableProcessors(),	//minimum number of threads
+			Integer.MAX_VALUE,							//maximum number of threads
+			120,										//unused threads are terminated after this time
+			TimeUnit.SECONDS,
+			new SynchronousQueue<Runnable>()			//requests will be processed immediately (not a real queue)
+			);
+
+	/** Starts all callables for parallel execution (using a ThreadPoolExecutor)
+	 *  and waits until each of them has finished.
+	 *  If the current thread is interrupted, each of the callables gets
+	 *  cancelled and interrupted. Also in that case, waits until all callables have
+	 *  finished. The 'interrupted' status of the current thread is
+	 *  preserved, as required for preview in an ImageJ ExtendedPlugInFilter.
+	 *  Note that ImageJ requires that all callables can run concurrently,
+	 *  and none of them must stay in the queue while others run.
+	 *  (This is required by the RankFilters, where the threads are not independent)
+	 *  @param callables Array of tasks. If no return value is needed,
+	 *  best use <code>Callable<Void></code> (then the <code>Void call()</code> method
+	 *  should return null). If the array size is 1, the <code>call()</code> method
+	 *  is executed in the current thread.
+	 *  @return Array of the <code>java.util.concurrent.Future</code>s,
+	 *  corresponding to the callables. If the call methods of the callables
+	 *  return results, the get() methods of these Futures may be used to get the results.
+	 */
+	public static Future[] startAndJoin(Callable[] callables) {
+		if (callables.length == 1) {	//special case: call in current thread and create a Future
+			Object callResult = null;
+			try {
+				callResult = callables[0].call();
+			} catch (Exception e) {
+				ij.IJ.handleException(e);
+			}
+			final Object result = callResult;
+			Future[] futures = new Future[] {
+				new Future() {
+					public boolean cancel(boolean mayInterruptIfRunning) {return false;}
+					public Object get() {return result;}
+					public Object get(long timeout, TimeUnit unit) {return result;}
+					public boolean isCancelled() {return false;}
+					public boolean isDone() {return true;}
+				}	
+			};
+			return futures;
+		} else {
+			Future[] futures = start(callables);
+			joinAll(futures);
+			return futures;
+		}
+	}
+
+	/** Starts all callables for parallel execution (using a ThreadPoolExecutor)
+	 *  without waiting for the results.
+	 *  @param callables Array of tasks; these might be <code>Callable<Void></code>
+	 *  if no return value is needed (then the <code>call</code> methods should
+	 *  return null).
+	 *  @return Array of the <code>java.util.concurrent.Future</code>s,
+	 *  corresponding to the callables. The futures may be used to wait for
+	 *  completion of the callables or cancel them.
+	 *  If the call methods of the callables return results, these Futures
+	 *  may be used to get the results.
+	 */
+	public static Future[] start(Callable[] callables) {
+		Future[] futures = new Future[callables.length];
+		for (int i=0; i<callables.length; i++)
+			futures[i] = threadPoolExecutor.submit(callables[i]);
+		return futures;
+	}
+
+	/** Waits for completion of all <code>Callable</code>s corresponding to the
+	 *  <code>Future</code>s given.
+	 *  If the current thread is interrupted, each of the <code>Callable</code>s
+	 *  gets cancelled and interrupted. Also in that case, this method waits
+	 *  until all callables have finished.
+	 *  The 'interrupted' status of the current thread is preserved,
+	 *  as required for preview in an ImageJ ExtendedPlugInFilter.
+	 */
+	public static void joinAll(Future[] futures) {
+		boolean interrupted = false;
+		for (int i=0; i<futures.length; i++) {
+			Future f = futures[i];
+			try {
+				f.get();
+			} catch (InterruptedException e) {
+				interrupted = true;
+				for (int j=i; j<futures.length; j++)
+					futures[j].cancel(true);
+				i--;  //we still have to wait for completion of this one
+			} catch (CancellationException e) { //cancellation is allowed, e.g. during preview
+			} catch (Exception eOther) {
+				ij.IJ.log("Error in thread called by "+Thread.currentThread().getName()+":\n"+eOther);
+			}
+		}
+		if (interrupted) {
+			Thread.currentThread().interrupt();
+			threadPoolExecutor.purge();
+		}
+	}
+}
diff --git a/src/ij/util/Tools.java b/src/ij/util/Tools.java
new file mode 100644
index 0000000..c925bc6
--- /dev/null
+++ b/src/ij/util/Tools.java
@@ -0,0 +1,465 @@
+package ij.util;
+import ij.process.*;
+import java.awt.Color;
+import java.util.*;
+import java.io.*;
+import java.util.Comparator;
+import java.nio.channels.FileChannel;
+import java.nio.file.*;
+import java.security.MessageDigest;
+
+
+/** This class contains static utility methods. */
+ public class Tools {
+	/** This array contains the 16 hex digits '0'-'F'. */
+	public static final char[] hexDigits = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
+
+	/** Converts a Color to an 7 byte hex string starting with '#'. */
+	public static String c2hex(Color c) {
+		int i = c.getRGB();
+		char[] buf7 = new char[7];
+		buf7[0] = '#';
+		for (int pos=6; pos>=1; pos--) {
+			buf7[pos] = hexDigits[i&0xf];
+			i >>>= 4;
+		}
+		return new String(buf7);
+	}
+
+	/** Converts a float to an 9 byte hex string starting with '#'. */
+	public static String f2hex(float f) {
+		int i = Float.floatToIntBits(f);
+		char[] buf9 = new char[9];
+		buf9[0] = '#';
+		for (int pos=8; pos>=1; pos--) {
+			buf9[pos] = hexDigits[i&0xf];
+			i >>>= 4;
+		}
+		return new String(buf9);
+	}
+
+	/** Converts an int to a zero-padded hex string of fixed length 'digits'.
+	 *  If the number is too high, it gets truncated, keeping only the lowest 'digits' characters. */
+	public static String int2hex(int i, int digits) {
+		char[] buf = new char[digits];
+		for (int pos=buf.length-1; pos>=0; pos--) {
+			buf[pos] = hexDigits[i&0xf];
+			i >>>= 4;
+		}
+		return new String(buf);
+	}
+
+	public static ImageStatistics getStatistics(double[] a) {
+		ImageProcessor ip = new FloatProcessor(a.length, 1, a);
+		return ip.getStats();
+	}
+
+	public static double[] getMinMax(double[] a) {
+		double min = a[0];
+		double max = a[0];
+		double value;
+		for (int i=1; i<a.length; i++) {
+			value = a[i];
+			if (value<min)
+				min = value;
+			else if (value>max)
+				max = value;
+		}
+		double[] minAndMax = new double[2];
+		minAndMax[0] = min;
+		minAndMax[1] = max;
+		return minAndMax;
+	}
+
+	public static double[] getMinMax(float[] a) {
+		double min = a[0];
+		double max = a[0];
+		double value;
+		for (int i=1; i<a.length; i++) {
+			value = a[i];
+			if (value<min)
+				min = value;
+			else if (value>max)
+				max = value;
+		}
+		double[] minAndMax = new double[2];
+		minAndMax[0] = min;
+		minAndMax[1] = max;
+		return minAndMax;
+	}
+
+	/** Converts the float array 'a' to a double array. */
+	public static double[] toDouble(float[] a) {
+		int len = a.length;
+		double[] d = new double[len];
+		for (int i=0; i<len; i++)
+			d[i] = a[i];
+		return d;
+	}
+
+	/** Converts the double array 'a' to a float array. */
+	public static float[] toFloat(double[] a) {
+		if (a==null)
+			return null;
+		int len = a.length;
+		float[] f = new float[len];
+		for (int i=0; i<len; i++)
+			f[i] = (float)a[i];
+		return f;
+	}
+
+	/** Adds a number to all array elements */
+	public static void addToArray(float[] a, float value) {
+		for (int i=0; i<a.length; i++)
+			a[i] += value;
+	}
+
+	/** Converts carriage returns to line feeds. */
+	public static String fixNewLines(String s) {
+		if (s==null)
+			return null;
+		char[] chars = s.toCharArray();
+		for (int i=0; i<chars.length; i++)
+			{if (chars[i]=='\r') chars[i] = '\n';}
+		return new String(chars);
+	}
+
+	/**
+	* Returns a double containg the value represented by the
+	* specified <code>String</code>.
+	*
+	* @param      s   the string to be parsed.
+	* @param      defaultValue   the value returned if <code>s</code>
+	*	does not contain a parsable double
+	* @return     The double value represented by the string argument or
+	*	<code>defaultValue</code> if the string does not contain a parsable double
+	*/
+	public static double parseDouble(String s, double defaultValue) {
+		if (s==null)
+			return defaultValue;
+		try {
+			defaultValue = Double.parseDouble(s);
+		} catch (NumberFormatException e) {}
+		return defaultValue;
+	}
+
+	/**
+	* Returns a double containg the value represented by the
+	* specified <code>String</code>.
+	*
+	* @param      s   the string to be parsed.
+	* @return     The double value represented by the string argument or
+	*	Double.NaN if the string does not contain a parsable double
+	*/
+	public static double parseDouble(String s) {
+		return parseDouble(s, Double.NaN);
+	}
+
+	/** Returns the number of decimal places needed to display a
+		number, or -2 if exponential notation should be used. */
+	public static int getDecimalPlaces(double n) {
+		if ((int)n==n || Double.isNaN(n))
+			return 0;
+		String s = ""+n;
+		if (s.contains("E"))
+			return -2;
+		while (s.endsWith("0"))
+			s = s.substring(0,s.length()-1);
+		int index = s.indexOf(".");
+		if (index==-1) return 0;
+		int digits = s.length() - index - 1;
+		if (digits>4) digits=4;
+		return digits;
+	}
+
+	/** Returns the number of decimal places needed to display two numbers,
+		or -2 if exponential notation should be used. */
+	public static int getDecimalPlaces(double n1, double n2) {
+		if ((int)n1==n1 && (int)n2==n2)
+			return 0;
+		int digits = getDecimalPlaces(n1);
+		int digits2 = getDecimalPlaces(n2);
+		if (digits==0)
+			return digits2;
+		if (digits2==0)
+			return digits;
+		if (digits<0 || digits2<0)
+			return digits;
+		if (digits2>digits)
+			digits = digits2;
+		return digits;
+	}
+
+	/** Splits a string into substrings using the default delimiter set,
+	which is " \t\n\r" (space, tab, newline and carriage-return). */
+	public static String[] split(String str) {
+		return split(str, " \t\n\r");
+	}
+
+	/** Splits a string into substring using the characters
+	contained in the second argument as the delimiter set. */
+	public static String[] split(String str, String delim) {
+		if (delim.equals("\n"))
+			return splitLines(str);
+		StringTokenizer t = new StringTokenizer(str, delim);
+		int tokens = t.countTokens();
+		String[] strings;
+		if (tokens>0) {
+			strings = new String[tokens];
+			for(int i=0; i<tokens; i++)
+				strings[i] = t.nextToken();
+		} else
+			strings = new String[0];
+		return strings;
+	}
+
+	static String[] splitLines(String str) {
+		Vector v = new Vector();
+		try {
+			BufferedReader br  = new BufferedReader(new StringReader(str));
+			String line;
+			while (true) {
+				line = br.readLine();
+				if (line == null) break;
+				v.addElement(line);
+			}
+			br.close();
+		} catch(Exception e) { }
+		String[] lines = new String[v.size()];
+		v.copyInto((String[])lines);
+		return lines;
+	}
+
+	/** Returns a sorted list of indices of the specified double array.
+		Modified from: http://stackoverflow.com/questions/951848 by N.Vischer.
+	*/
+	public static int[] rank(double[] values) {
+		int n = values.length;
+		final Integer[] indexes = new Integer[n];
+		final Double[] data = new Double[n];
+		for (int i=0; i<n; i++) {
+			indexes[i] = new Integer(i);
+			data[i] = new Double(values[i]);
+		}
+		Arrays.sort(indexes, new Comparator<Integer>() {
+			public int compare(final Integer o1, final Integer o2) {
+				return data[o1].compareTo(data[o2]);
+			}
+		});
+		int[] indexes2 = new int[n];
+		for (int i=0; i<n; i++)
+			indexes2[i] = indexes[i].intValue();
+		return indexes2;
+	}
+
+	/** Returns a sorted list of indices of the specified String array. */
+	public static int[] rank(final String[] data) {
+		int n = data.length;
+		final Integer[] indexes = new Integer[n];
+		for (int i=0; i<n; i++)
+			indexes[i] = new Integer(i);
+		Arrays.sort(indexes, new Comparator<Integer>() {
+			public int compare(final Integer o1, final Integer o2) {
+				return data[o1].compareToIgnoreCase(data[o2]);
+			}
+		});
+		int[] indexes2 = new int[n];
+		for (int i=0; i<n; i++)
+			indexes2[i] = indexes[i].intValue();
+		return indexes2;
+	}
+
+	/** Returns an array linearly resampled to a different length. */
+	public static double[] resampleArray(double[] y1, int len2) {
+		int len1 = y1.length;
+		double factor =  (double)(len2-1)/(len1-1);
+		double[] y2 = new double[len2];
+		if(len1 == 0){
+		    return y2;
+		}
+		if(len1 == 1){
+		    for (int jj=0; jj<len2; jj++)
+			    y2[jj] = y1[0];
+		    return(y2);
+		}
+		double[] f1 = new double[len1];//fractional positions
+		double[] f2 = new double[len2];
+		for (int jj=0; jj<len1; jj++)
+			f1[jj] = jj*factor;
+		for (int jj=0; jj<len2; jj++)
+			f2[jj] = jj/factor;
+		for (int jj=0; jj<len2-1; jj++) {
+			double pos = f2[jj];
+			int leftPos = (int)Math.floor(pos);
+			int rightPos = (int)Math.floor(pos)+1;
+			double fraction = pos-Math.floor(pos);
+			double value = y1[leftPos] + fraction*(y1[rightPos]-y1[leftPos]);
+			y2[jj] = value;
+		}
+		y2[len2-1] = y1[len1-1];
+		return y2;
+	}
+
+	/** Opens a text file in ij.jar as a String (example path: "/macros/Circle_Tool.txt"). */
+	public static String openFromIJJarAsString(String path) {
+		return (new ij.plugin.MacroInstaller()).openFromIJJar(path);
+	}
+
+	/** Copies the contents of the file at 'path1' to 'path2', returning an error message
+		(as a non-empty string) if there is an error. Based on the method with the
+		same name in Tobias Pietzsch's TifBenchmark class.
+	*/
+	public static String copyFile(String path1, String path2) {
+		File f1 = new File(path1);
+		File f2 = new File(path2);
+		try {
+			if (!f1.exists() )
+				return "Source file does not exist";
+			if (!f2.exists() )
+				f2.createNewFile();
+			long time = f1.lastModified();
+			FileInputStream stream1 = new FileInputStream(f1);
+			FileChannel channel1 = stream1.getChannel();
+			FileOutputStream stream2 = new FileOutputStream(f2);
+			final FileChannel channel2 = stream2.getChannel();
+			if (channel2!=null && channel1!=null )
+				channel2.transferFrom(channel1, 0, channel1.size());
+			channel1.close();
+			stream1.close();
+			channel2.close();
+			stream2.close();
+			f2.setLastModified(time);
+		} catch(Exception e) {
+			return e.getMessage();
+		}
+		return "";
+	}
+
+	/** Retrieves a number form a list of key-number pairs like "value1=1234.5 area=1.2e6".
+	 *  The "=" (if present) must be part of the 'key' string. Delimiters may be commas, semicolons or whitespace.
+	 *  There must be no whitespace between key and number.
+	 *  Returns Double.NaN if 'list' is null, if the key is not found, if the number is 'NaN' or invalid. */
+	public static double getNumberFromList(String list, String key) {
+		return getNumberFromList(list, key, Double.NaN);
+	}
+
+	public static double getNumberFromList(String list, String key, double defaultValue) {
+		if (list == null) return defaultValue;
+		int i = list.indexOf(key);
+		if (i < 0) return defaultValue;
+		int start = i + key.length();
+		int n = start;
+		while (n < list.length() && !isDelimiter(list.charAt(n))) n++;
+		double value = parseDouble(list.substring(start, n));
+		return Double.isNaN(value)?defaultValue:value;
+	}
+
+	/** Retrieves a String form a list of key-number pairs like "value1="abc" str='the Text'".
+	 *  The "=" (if present) must be part of the 'key' string.
+	 *  Strings containing commas, semicolons or whitespace must be enclosed in single or double quotes.
+	 *  There must be no whitespace between key and quotes or key and unquoted String.
+	 *  Strings must not contain a key. In case of doubt, e.g., replace the '=' with '\='
+	 *  Escape sequences with backslashes are recognized, also backslash-u???? for unicode.
+	 *  Returns null if 'list' is null or if the key is not found */
+	public static String getStringFromList(String list, String key) {
+		return getStringFromList(list, key, null);
+	}
+
+	public static String getStringFromList(String list, String key, String defaultValue) {
+		if (list == null) return defaultValue;
+		int i = list.indexOf(key);
+		if (i < 0) return defaultValue;
+		int start = i + key.length();
+		if (list.length() == start) return "";
+		char quote = list.charAt(start);
+		boolean hasQuotes = quote == '\'' || quote == '\"';
+		if (hasQuotes) start++;
+		String str = decodeEscaped(list.substring(start), hasQuotes ? quote : (char)-2);
+		if (str==null)
+			str = defaultValue;
+		return str;
+	}
+
+	/** Decodes backslash-escaped characters from the String until the character 'delim' is found.
+	 *  With 'delim'=-1, does not search for a delimiter, with 'delim'=(char)-2, (unescaped)
+	 *  whitespace, commas and semicolons are interpreted as delimiters.
+	 *  Also decodes unicode backslash-u???? characters */
+	public static String decodeEscaped(String str, char delim) {
+		StringBuilder sb = new StringBuilder();
+		for (int i=0; i<str.length(); i++) {
+			char c = str.charAt(i);
+			if ((delim == (char)-2 && isDelimiter(c)) || c == delim) break;
+			if (c == '\\' && i+1 < str.length()) {    //escaped by backslash
+				i++;
+				c = str.charAt(i);
+				if (c == 'u' && i+4 < str.length())
+					try {
+						c = (char)Integer.parseInt(str.substring(i+1, i+5), 16);
+						i += 4;
+					} catch (NumberFormatException e) {}
+				else
+					c = withBackslash(c);           // decodes backslash-t for tab etc.
+			}
+			sb.append(c);
+		}
+		return sb.toString();
+	}
+
+	private static boolean isDelimiter(char c) {
+		return Character.isWhitespace(c) || c==',' || c==';';
+	}
+
+	/** Returns the escaped character if there was a preceding backslash.
+	 *  Returns 'c' if there is no known escape sequence backslash-c */
+	private static char withBackslash(char c) {
+		switch (c) {
+			case 'b': return '\b';
+			case 't': return '\t';
+			case 'f': return '\f';
+			case 'r': return '\r';
+			case 'n': return '\n';
+			default: return c;
+		}
+	}
+	
+	/** Returns the checksum of a string or file, or "0" if no success.
+	The 'method' argument must be "MD5" or "SHA-256".
+	*/
+	public static String getHash(String method, boolean fromFile, String pathOrString) {
+		method = method.toUpperCase();
+		boolean md5 = method.contains("MD5");
+		boolean sha_256 = method.contains("SHA-256");
+		try {
+			MessageDigest digest = null;
+			if (md5)
+				digest = MessageDigest.getInstance("MD5");
+			else if(sha_256)
+				 digest = MessageDigest.getInstance("SHA-256");
+			else
+				return "0";
+			Path path = Paths.get(pathOrString);
+			byte[] encodedhash;
+			if (fromFile)
+				encodedhash = digest.digest(Files.readAllBytes(path));
+			else
+				encodedhash = digest.digest(pathOrString.getBytes());
+
+			return bytesToHex(encodedhash);
+
+		} catch (Exception e) {}
+		return "0";
+	}
+
+	private static String bytesToHex(byte[] hash) {
+		StringBuilder hexString = new StringBuilder(2 * hash.length);
+		for (int i = 0; i < hash.length; i++) {
+			String hex = Integer.toHexString(0xff & hash[i]);
+			if (hex.length() == 1) {
+				hexString.append('0');
+			}
+			hexString.append(hex);
+		}
+		return hexString.toString();
+	}
+
+}
diff --git a/src/ij/util/WildcardMatch.java b/src/ij/util/WildcardMatch.java
new file mode 100644
index 0000000..cbe06ea
--- /dev/null
+++ b/src/ij/util/WildcardMatch.java
@@ -0,0 +1,201 @@
+package ij.util;
+
+/**
+ * This class allows for simple wildcard pattern matching. Possible
+ * patterns allow to match single characters ('?') or any count of
+ * characters ('*').<p>
+ * Wildcard characters can be escaped (default: by an '\').<p>
+ * This class always matches for the whole word.<p>
+ * Examples:
+ * <pre>
+ * WildcardMatch wm = new WildcardMatch();
+ * System.out.println(wm.match("CfgOptions.class", "C*.class"));	  // true
+ * System.out.println(wm.match("CfgOptions.class", "?gOpti*c?as?"));  // false
+ * System.out.println(wm.match("CfgOptions.class", "??gOpti*c?ass")); // true
+ * System.out.println(wm.match("What's this?",	   "What*\\?"));	  // true
+ * System.out.println(wm.match("What's this?",	   "What*?"));		  // true
+ * System.out.println(wm.match("A \\ backslash", "*\\\\?back*"));	  // true
+ * </pre>
+ */
+public class WildcardMatch {
+
+	public WildcardMatch() {
+	}
+
+	public WildcardMatch(char singleChar, char multipleChars) {
+		this.sc = singleChar;
+		this.mc = multipleChars;
+	}
+
+	/**
+	 * Sets new characters to be used as wildcard characters, overriding the
+	 * the default of '?' for any single character match and '*' for any
+	 * amount of characters, including 0 characters.
+	 * @param singleChar The char used to match exactly ONE character.
+	 * @param multipleChars The char used to match any amount of characters
+	 * including o characters.
+	 */
+	public void setWildcardChars(char singleChar, char multipleChars) {
+		this.sc = singleChar;
+		this.mc = multipleChars;
+	}
+
+	/**
+	 * Sets the new character to be used as an escape character, overriding the
+	 * the default of '\'.
+	 * @param escapeChar The char used to match escape wildcard characters.
+	 */
+	public void setEscapeChar(char escapeChar) {
+		this.ec = escapeChar;
+	}
+
+	/**
+	 * Returns the character used to specify exactly one character.
+	 * @return Wildcard character matching any single character.
+	 */
+	public char getSingleWildcardChar() {
+		return sc;
+	}
+
+	/**
+	 * Returns the character used to specify any amount of characters.
+	 * @return Wildcard character matching any count of characters.
+	 */
+	public char getMultipleWildcardChar() {
+		return mc;
+	}
+
+	/**
+	 * Returns the character used to escape the wildcard functionality of a
+	 * wildcard character. If two escape characters are used in sequence, they
+	 * mean the escape character itself. It defaults to '\'.
+	 * @return Escape character.
+	 */
+	public char getEscapeChar() {
+		return ec;
+	}
+
+	/**
+	 * Makes pattern matching case insensitive.
+	 * @param caseSensitive false for case insensitivity. Default is case
+	 * sensitive match.
+	 */
+	public void setCaseSensitive(boolean caseSensitive) {
+		this.caseSensitive = caseSensitive;
+	}
+
+	/**
+	 * Returns the current state of case sensitivity.
+	 * @return true for case sensitive pattern matching, false otherwise.
+	 */
+	public boolean getCaseSensitive() {
+		return caseSensitive;
+	}
+	boolean preceededByMultipleChar = false;
+
+	/**
+	 * Matches a string against a pattern with wildcards. Two wildcard types
+	 * are supported: single character match (defaults to '?') and ANY
+	 * character match ('*'), matching any count of characters including 0.
+	 * Wildcard characters may be escaped by an escape character, which
+	 * defaults to '\'.
+	 * @param s The string, in which the search should be performed.
+	 * @param pattern The search pattern string including wildcards.
+	 * @return true, if string 's' matches 'pattern'.
+	 */
+	public boolean match(String s, String pattern) {
+		preceededByMultipleChar = false;
+		isEscaped = false;
+		if (!caseSensitive) {
+			pattern = pattern.toLowerCase();
+			s = s.toLowerCase();
+		}
+		int offset = 0;
+
+		while (true) {
+			String ps = getNextSubString(pattern);
+			int len = ps.length();
+			pattern = pattern.substring(len + escCnt);
+
+			if (len > 0 && isWildcard(ps.charAt(0)) && escCnt == 0) {
+				offset = getWildcardOffset(ps.charAt(0));
+				if (isSingleWildcardChar(ps.charAt(0))) {
+					s = s.substring(1);
+// This is not yet enough: If a '*' precedes '?', 's' might be SHORTER
+// than seen here, for this we need preceededByMultipleChar variable...
+				}
+				if (pattern.length() == 0) {
+					return s.length() <= offset || preceededByMultipleChar;
+				}
+			} else {
+				int idx = s.indexOf(ps);
+				if (idx < 0 || (idx > offset && !preceededByMultipleChar)) {
+					return false;
+				}
+				s = s.substring(idx + len);
+				preceededByMultipleChar = false;
+			}
+			if (pattern.length() == 0) {
+				return s.length() == 0;
+			}
+		}
+	}
+	private char sc = '?';
+	private char mc = '*';
+	private char ec = '\\'; // Escape character
+	private boolean caseSensitive = true;
+	private boolean isEscaped = false;
+	private int escCnt = 0;
+
+	private String getNextSubString(String pat) {
+		escCnt = 0;
+		if ("".equals(pat)) {
+			return "";
+		}
+		if (isWildcard(pat.charAt(0))) {
+			// if '?' is preceeded by '*', we need special considerations:
+			if (pat.length() > 1 && !isSingleWildcardChar(pat.charAt(0)) && isSingleWildcardChar(pat.charAt(1))) {
+				preceededByMultipleChar = true;
+			}
+			return pat.substring(0, 1);
+		} else {
+			String s = "";
+			int i = 0;
+			while (i < pat.length() && !isWildcard(pat.charAt(i), isEscaped)) {
+				if (pat.charAt(i) == ec) {
+					isEscaped = !isEscaped;
+					if (!isEscaped) {
+						s += pat.charAt(i);
+					}
+					escCnt++;
+				} else if (isWildcard(pat.charAt(i))) {
+					isEscaped = false;
+					s += pat.charAt(i);
+				} else {
+					s += pat.charAt(i);
+				}
+				i++;
+			}
+			return s;
+		}
+	}
+
+	private boolean isWildcard(char c, boolean isEsc) {
+		return !isEsc && isWildcard(c);
+	}
+
+	private boolean isSingleWildcardChar(char c) {
+		return c == sc;
+	}
+
+	private boolean isWildcard(char c) {
+		return c == mc || c == sc;
+	}
+
+	private int getWildcardOffset(char c) {
+		if (c == mc) {
+			return Integer.MAX_VALUE;
+		}
+		return 0;
+	}
+}
\ No newline at end of file