This page was created by the IDL library routine
mk_html_help. For more information on
this routine, refer to the IDL Online Help Navigator
or type:
? mk_html_help
Last modified: Tue Aug 19 13:49:34 2008.
NAME:
AdjustPosition
PURPOSE:
This is a program for interactively adjusting the plot position
coordinates. The result of the function is a four-element floating
point array of normalized coordinates, suitable for passing to the
POSITION keyword of most IDL graphics commands.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Graphics
CALLING SEQUENCE:
position = AdjustPosition(startingPosition)
OPTIONAL INPUTS:
startingPosition - A four-element array of normalized coordinates
of the form [x0, y0, x1, y1].
OUTPUTS:
position - The adjusted plot position. A four-element array of normalized coordinates.
INPUT KEYWORDS:
GROUP_LEADER - The group leader of this program. This keyword
is required to ensure modal operation when calling from
another widget program.
TITLE - The title of the window. "Adjust Plot Position in Window..." by default.
XOFFSET - The X offset of the program on the display. Calculated from the
upper left-hand corner of the display.
YOFFSET - The Y offset of the program on the display. Calculated from the
upper left-hand corner of the display.
OUTPUT KEYWORDS:
CANCEL - Returns a 1 if the user selects the Cancel button. Returns 0 otherwise.
Note that if the use cancels, the "position" parameter is set to the value of
the "startingPosition" parameter.
DEPENDENCIES:
Reqires FSC_FIELD and FSC_PLOTWINDOW from the Coyote Library:
http://www.dfanning.com/programs/fsc_field.pro
http://www.dfanning.com/programs/fsc_plotwindow.pro
MODIFICATION HISTORY:
Written by David Fanning, March 2001.
(See adjustposition.pro)
NAME:
ANNOTATEWINDOW
PURPOSE:
The purpose of this routine is to allow the user to annotate or make
measurements on a graphics window. A copy of the graphics window is
created and placed into an annotation window. The user can create
various kinds of file output from within the annotation window.
Select the annotation tool from the tool bar at the top of the annotate
window. Click and drag in the window to draw the annotation. (The text
tool requires you to click in the window to start typing. Be sure to
hit a carriage return at the end of typing to "set" the text in the
window.) Click anywhere inside the tool to "select" it. Most tools
allow you to move and edit the shape of the annotation after selection.
Right click inside a selected annotation to access properties of that
annotation, such as grouping, moving an annotation forward to backward,
deleting the object, etc. Click the "Other Properties" button to access
individual properties for the annotations. For example, if you mis-spelled
some text, you would click on the text to select it. Right click to access
it's select menu, select the Other Properties button, and find the text
field in this pop-up dialog to change the spelling of the text.
AUTHORS:
FANNING SOFTWARE CONSULTING BURRIDGE COMPUTING
1645 Sheely Drive 18 The Green South
Fort Collins Warborough, Oxon
CO 80526 USA OX10 7DN, ENGLAND
Phone: 970-221-0438 Phone: +44 (0)1865 858279
E-mail: davidf@dfanning.com E-mail: davidb@burridgecomputing.co.uk
CATEGORY:
Catalyst Applications.
SYNTAX:
AnnotateWindow, theBackground
ARGUMENTS:
theBackground: This can either be the window index number of a graphics window,
or it can be an 8-bit or 24-bit image variable. If this argument
is undefined, the program tries to obtain a background image
from the current graphics window. Note that if the graphics window
contains a black background (the normal situation for many IDL
graphics windows), this will be reproduced *exactly* in PostScript
output. This is NOT the same as most PostScript output. If you
intend to create PostScript output of your annotated window, it
may be better to create graphics windows with white backgrounds.
Device, Decomposed=0, Get_Decomposed=currentState
TVLCT, [0, 255], [0,255], [0, 255], !D.Table_Size-3
Plot, findgen(11), Color=!D.Table_Size-3, Background=!D.Table_Size-2
Device, Decomposed=currentState
AnnotateWindow
KEYWORDS:
BG_COLOR: The name of a background color. This is used only if there is a margin
around the background image. By default, "white". The background color
will always be "white" if the output is sent to a PostScript file. (See list
of color names below.)
COLOR: The name of the foreground color for the annotations. By default "Light Coral"
as something that might contrast enough with any background. (See list
of color names below.)
NOMARGIN: There is a 10% margin added to the background image, unless this keyword
is set, in which case the background image will fill the annotation window.
XRANGE: The TapeMeasure tool will report the distance in normalized coordinate space
by default. Use this keyword to specify a two-element array that represents
the minimum and maximum X range of the background image.
YRANGE: The TapeMeasure tool will report the distance in normalized coordinate space
by default. Use this keyword to specify a two-element array that represents
the minimum and maximum Y range of the background image.
RESTRICTIONS:
Requires the Catalyst Library from Fanning Software Consulting, Inc., or a catalyst.sav file
to be restored prior to use. A Catalyst save file may be download from Coyote's Guide to IDL
Programming. Be sure to download a version compatible with your IDL license.
http://www.dfanning.com/programs/catalyst.sav (for IDL 6.1 or higher)
The following color names can be used for the BG_COLOR and COLOR keywords:
Active Almond Antique White Aquamarine Beige Bisque
Black Blue Blue Violet Brown Burlywood Cadet Blue
Charcoal Chartreuse Chocolate Coral Cornflower Blue Cornsilk
Crimson Cyan Dark Goldenrod Dark Gray Dark Green Dark Khaki
Dark Orchid Dark Red Dark Salmon Dark Slate Blue Deep Pink Dodger Blue
Edge Face Firebrick Forest Green Frame Gold
Goldenrod Gray Green Green Yellow Highlight Honeydew
Hot Pink Indian Red Ivory Khaki Lavender Lawn Green
Light Coral Light Cyan Light Gray Light Salmon Light Sea Green Light Yellow
Lime Green Linen Magenta Maroon Medium Gray Medium Orchid
Moccasin Navy Olive Olive Drab Orange Orange Red
Orchid Pale Goldenrod Pale Green Papaya Peru Pink
Plum Powder Blue Purple Red Rose Rosy Brown
Royal Blue Saddle Brown Salmon Sandy Brown Sea Green Seashell
Selected Shadow Sienna Sky Blue Slate Blue Slate Gray
Snow Spring Green Steel Blue Tan Teal Text
Thistle Tomato Turquoise Violet Violet Red Wheat
White Yellow
EXAMPLE:
To annotate a medical image:
filename = Filepath(Subdirectory=['examples','data'], 'mr_knee.dcm')
image = Read_DICOM(filename)
AnnotateWindow, Rebin(image, 512, 512), XRange=[0,5], YRange=[0,5]
Remember to right-click on any annotation object to access that objects properties.
This is the way you would change a mis-spelled text label, add units to a measurement,
change the color of an annotation object, etc.
Also remember that you MUST type a carriage return when using the Text Tool to
"set" the text into the annotation window.
MODIFICATION_HISTORY:
Written by: David W. Fanning, 25 July 2005.
Improved documentation header. 11 August 2005. DWF.
(See annotatewindow.pro)
NAME:
ARCSAMPLE
PURPOSE:
Given X and Y points that describe a closed curve in 2D space,
this function returns an output curve that is sampled a specified
number of times at approximately equal arc distances.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
ArcSample, x_in, y_in, x_out, y_out
INPUT_PARAMETERS:
x_in: The input X vector of points.
y_in: The input Y vector of points.
OUTPUT_PARAMETERS:
x_out: The output X vector of points.
y_out: The output Y vector of points.
KEYWORDS:
POINTS: The number of points in the output vectors. Default: 50.
PHASE: A scalar between 0.0 and 1.0, for fine control of where interpolates
are sampled. Default: 0.0.
MODIFICATION HISTORY:
Written by David W. Fanning, 1 December 2003, based on code supplied
to me by Craig Markwardt.
(See arcsample.pro)
NAME:
ASINHSCL
PURPOSE:
This is a utility routine to perform an inverse hyperbolic sine
function intensity transformation on an image. I think of this
as a sort of "tuned" gamma or power-law function. The algorithm,
and notion of "asinh magnitudes", comes from a paper by Lupton,
et. al, in The Astronomical Journal, 118:1406-1410, 1999 September.
I've relied on the implementation of Erin Sheldon, found here:
http://cheops1.uchicago.edu/idlhelp/sdssidl/plotting/tvasinh.html
I'm also grateful of discussions with Marshall Perrin on the IDL
newsgroup with respect to the meaning of the "softening parameter", beta,
and for finding (and fixing!) small problems with the code.
Essentially this transformation allow linear scaling of noise values,
and logarithmic scaling of signal values, since there is a small
linear portion of the curve and a much large logarithmic portion of
the curve. (See the EXAMPLE section for some tips on how to view this
transformation curve.)
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
outputImage = ASINHSCL(image)
ARGUMENTS:
image: The image or signal to be scaled. Written for 2D images, but arrays
of any size are treated alike.
KEYWORDS:
BETA: This keyword corresponds to the "softening parameter" in the Lupon et. al paper.
This factor determines the input level at which linear behavior sets in. Beta
should be set approximately equal to the amount of "noise" in the input signal.
IF BETA=0 there is a very small linear portion of the curve; if BETA=200 the
curve is essentially all linear. The default value of BETA is set to 3, which
is appropriate for a small amount of noise in your signal. The value is always
positive.
NEGATIVE: If set, the "negative" of the result is returned.
MAX: Any value in the input image greater than this value is
set to this value before scaling.
MIN: Any value in the input image less than this value is
set to this value before scaling.
OMAX: The output image is scaled between OMIN and OMAX. The
default value is 255.
OMIN: The output image is scaled between OMIN and OMAX. The
default value is 0.
RETURN VALUE:
outputImage: The output, scaled into the range OMIN to OMAX. A byte array.
COMMON BLOCKS:
None.
EXAMPLES:
Plot, ASinhScl(Indgen(256), Beta=0.0), LineStyle=0
OPlot, ASinhScl(Indgen(256), Beta=0.1), LineStyle=1
OPlot, ASinhScl(Indgen(256), Beta=1.0), LineStyle=2
OPlot, ASinhScl(Indgen(256), Beta=10.), LineStyle=3
OPlot, ASinhScl(Indgen(256), Beta=100), LineStyle=4
RESTRICTIONS:
Requires SCALE_VECTOR from the Coyote Library:
http://www.dfanning.com/programs/scale_vector.pro
Incorporates ASINH from the NASA Astronomy Library and renamed ASINHSCL_ASINH.
http://idlastro.gsfc.nasa.gov/homepage.html
MODIFICATION HISTORY:
Written by: David W. Fanning, 24 February 2006.
Removed ALPHA keyword and redefined the BETA keyword to correspond
to the "softening parameter" of Lupton et. al., following the
suggestions of Marshall Perrin. 25 April 2006. DWF.
(See asinhscl.pro)
NAME:
ASPECT
PURPOSE:
This function calculates and returns the normalized position
coordinates necessary to put a plot with a specified aspect ratio
into the currently active graphics window. It works on the display
output window as well as in a PostScript output window.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
Graphics
CALLING SEQUENCE:
position = ASPECT(aspectRatio)
INPUTS:
aspectRatio: A floating point value that is the desired aspect
ratio (ratio of heigth to width) of the plot in the current
graphics output window. If this parameter is missing, an aspect
ratio of 1.0 (a square plot) is assumed.
KEYWORD PARAMETERS:
MARGIN: The margin around the edges of the plot. The value must be
a floating point value between 0.0 and 0.5. It is expressed in
normalized coordinate units. The default margin is 0.15.
WINDOWASPECT: The aspect ratio of the target window. If not provided,
the value is obtained from the current graphics window.
OUTPUTS:
position: A four-element floating array of normalized coordinates.
The order of the elements is [x0, y0, x1, y1], similar to the
!P.POSITION system variable or the POSITION keyword on any IDL
graphic command.
EXAMPLE:
To create a plot with an aspect ratio of 1:2 and a margin of
0.10 around the edge of the output window, do this:
plotPosition = ASPECT(0.5, Margin=0.10)
PLOT, Findgen(11), POSITION=plotPosition
Notice this can be done in a single IDL command, like this:
PLOT, Findgen(11), POSITION=ASPECT(0.5, Margin=0.10)
MODIFICATION HISTORY:
Written by: David Fanning, November 1996.
Added better error checking, 18 Feb 1997, DWF.
Added WindowAspect keyword. 10 Feb 2000. DWF
Added double precision tolerance for aspectRatio. 9 NOV 2001 BT
(See aspect.pro)
NAME:
BINARY
PURPOSE:
This function is used to display a binary representation of byte,
integer, and long integer values.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
Utilities
CALLING SEQUENCE:
output = Binary(theNumber)
RETURN VALUE:
output: A string array of 0s and 1s to be printed (normally), in a
binary representation of the number. The number is represented with
the highest bits on the left and the lowest bits on the right,
when printed with the PRINT command.
ARGUMENTS:
theNumber: The number for which the user wants a binary representation.
It must be BYTE, INT, or LONG.
KEYWORDRS:
COLOR: If this keyword is set, the binary representation always
contains 24 bits of output.
SEPARATE: If this keyword is set, the output is separated with space
between each group of eight bits.
EXAMPLE:
IDL> Print, Binary(24B)
0 0 0 1 1 0 0 0
IDL> Print, Binary(24L)
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 1 0 0 0
IDL> Print, Binary(24L, /COLOR)
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0
IDL> Print, Binary(24L, /COLOR, /SEPARATE)
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0
MODIFICATION HISTORY:
Written by: David W. Fanning, November 10, 2007.
Fixed a problem with error handling. 13 March 2008. DWF.
(See binary.pro)
NAME:
BITGET
PURPOSE:
Returns the bit value (0 or 1) of a specified bit in a supplied number.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
bitValue = BitGet(number, bit)
INPUT_PARAMETERS:
number: The input number. Should be a scalar integer. If not, it is converted to
one by rounding.
bit: The number of the bit you are interested in. A value between 0 and 63.
If not supplied, all 64 bit values of the number are returned. May be
an array of bit numbers.
OUTPUT_PARAMETERS:
bitValue: The value, 0 or 1, of the specified bit in the number.
KEYWORDS:
SILENT: If set, suppresses informational messages regarding rounding operations.
MODIFICATION HISTORY:
Written by David W. Fanning, 14 June 2006.
(See bitget.pro)
NAME:
Blob_Analyzer::FitEllipse
PURPOSE:
This function fits an ellipse to a particular blob and returns information
about the fit to the user.
CALLING SEQUENCE:
ellipsePts = theBlobs -> FitEllipse(indexNumber)
RETURN VALUE:
ellipsePts: A [2,n] array containing the XY points of the fitted ellipse. The values
are in scaled units unless the NOSCALE keyword is set, in which case the
values are in DEVICE units.
ARGUMENTS:
indexNumber: The index number of the blob. Indices start at 0 and go to n-1.
INPUT KEYWORDS:
NOSCALE: Set this keyword if you would prefer that lengths and positions NOT be
scaled in the output of this function. If not scaled, results are in pixel
or device coordinates. The default is to scale all output.
NPOINTS: The number of points in the ellipse. By default, 120.
OUTPUT KEYWORDRS:
AXES: A two-element array containing the lengths of the major and minor axes,
respectively. Lenghts are scaled unless the NOSCALE keyword is set.
CENTER: A two-element array containing the [x,y] values of the center of the ellipse.
Values are scaled unless the NOSCALE keyword is set.
ORIENTATION: The orientation of the ellipse. The value is in degrees counter-clockwise of
the postive X direction. Note that a value of 60 is the same as a value of 240.
In other words, there is no direction associated with this value.
SEMIAXES: A two-element array containing the lengths of the semi-major and semi-minor axes,
respectively. Lenghts are scaled unless the NOSCALE keyword is set. (Half the length
of AXES.
(See blob_analyzer__define.pro)
NAME:
Blob_Analyzer::GetIndices
PURPOSE:
This function returns the indices of a blob to the caller.
CALLING SEQUENCE:
indices = theBlobs -> GetIndices(indexNumber)
RETURN VALUE:
indices: A vector of blob indices that describes the blob in the original image.
ARGUMENTS:
indexNumber: The index number of the blob. Indices start at 0 and go to n-1.
INPUT KEYWORDS:
None.
OUTPUT KEYWORDRS:
COUNT: The number of indices in the indices vector.
XSIZE: The X size of the image from which the blob is taken.
YSIZE: The Y size of the image from which the blob is taken.
(See blob_analyzer__define.pro)
NAME:
Blob_Analyzer::GetStats
PURPOSE:
This function returns statistics of the blob in question.
CALLING SEQUENCE:
statistics = theBlobs -> GetStats(indexNumber)
RETURN VALUE:
statistics: A structure of statistics that is defined like this.
stats = {INDEX: indexNumber, $ ; The index number of this blob.
COUNT: N_Elements(indices), $ ; The number of indices in this blob.
PERIMETER_PTS: boundaryPts, $ ; A [2,n] array of points that describe the blob perimeter.
PIXEL_AREA: pixelArea, $ ; The area as calculated by pixels in the blob.
PERIMETER_AREA: perimeterArea, $ ; The area as calculated by the blob perimeter. (Smaller than pixel area.)
CENTER: centroid[0:1], $ ; The [x,y] array that identifies the centroid of the blob.
PERIMETER_LENGTH: perimeter_length, $ ; The perimenter length (scaled unless the NOSCALE keyword is set).
SCALE: scale, $ ; The [xscale, yscale] array used in scaling.
MINCOL: Min(xyindices[0,*]), $ ; The minimum column index in the blob.
MAXCOL: Max(xyindices[0,*]), $ ; The maximum column index in the blob.
MINROW: Min(xyindices[1,*]), $ ; The minimum row index in the blob.
MAXROW: Max(xyindices[1,*])} ; The maximum row index in the blob.
ARGUMENTS:
indexNumber: The index number of the blob. Indices start at 0 and go to n-1.
INPUT KEYWORDS:
NOSCALE: Set this keyword if you would prefer that lengths and positions NOT be
scaled in the output of this function. If not scaled, results are in pixel
or device coordinates. The default is to scale all output.
OUTPUT KEYWORDRS:
INDICES: A vector of blob indices that describes the blob in the original image.
XYINDICES: A 2xN array of column/row indices that describes teh blob in the original image.
NOTES:
The statistics are calculated by calling FIND_BOUNDARY from the Coyote Library. This program
uses a chain-code algorithm to calculate the perimeter and report the blob area using either of
two methods: a strict pixel area (counts the number of pixels in the blob times the scale factor
and takes the total), or it uses the perimeter to calculate an area using the method described in
Russ, The Image Processing Handbook, 2nd Edition, pp490+. The perimeter area is almost always less
than the pixel area.
(See blob_analyzer__define.pro)
NAME:
Blob_Analyzer::INIT
PURPOSE:
This function initializes the Blob_Analyzer object.
CALLING SEQUENCE:
theBlobs = Obj_New('Blob_Analyzer', image)
ARGUMENTS:
image: A two-dimensional image array. To make this program memory efficient,
a copy of the image is *not* stored in the object. You will be responsible
for image operations outside this program.
KEYWORDS:
ALL_NEIGHBORS: Set this keyword to look at all eight neighbors when searching
for connectivity. The default is to look for four neighbors on
each side of the starting pixel. Passed directly to LABEL_REGION.
MASK: A two-dimensional array, the same size as image, that identifies the
foreground and background pixels in the image. Applying the mask
should result in a bi-level image of 0s and 1s, where 1 identifies the
blobs you wish to analyze. If a mask is not provided, the mask is created
like this:
mask = image > 0
SCALE: A one- or two-dimensional given the pixel scaling parameters. By default [1.0, 1.0].
If passed a scalar, the scale parameter is applied to both the X and Y directions of
each pixel. Statistical output is reported with scaling unless the NOSCALE keyword
is set. Scaling also effects the data that is output from the various methods.
(See blob_analyzer__define.pro)
NAME:
Blob_Analyzer::NumberOfBlobs
PURPOSE:
This function returns the number of blobs in the input image.
CALLING SEQUENCE:
numBlobs = theBlobs -> NumberOfBlobs()
RETURN VALUE:
numBlobs: The number of blobs in the input image.
ARGUMENTS:
None.
KEYWORDS:
None.
(See blob_analyzer__define.pro)
NAME:
Blob_Analyzer::ReportStats
PURPOSE:
This function reports statistics on blobs in the image.
CALLING SEQUENCE:
theBlobs -> ReportStats
ARGUMENTS:
None.
INPUT KEYWORDS:
FILENAME: The name of a file to contain the statistical output.
NOSCALE: Set this keyword if you would prefer that lengths and positions NOT be
scaled in the output of this function. If not scaled, results are in pixel
or device coordinates. The default is to scale all output.
TOFILE: Normally the report is sent to standard ouput. If this keyword is set,
the output is sent to a file.
OUTPUT KEYWORDRS:
None.
EXAMPLE:
Here is an example of statistical output from the example program below.
INDEX NUM_PIXELS CENTER_X CENTER_Y PIXEL_AREA PERIMETER_AREA PERIMETER_LENGTH MAJOR_AXIS MINOR_AXIS ANGLE
0 426 107.89 9.78 106.50 98.00 37.56 12.15 11.29 -8.05
1 580 151.97 10.22 145.00 134.25 49.21 17.49 11.77 -0.99
2 812 266.29 15.36 203.00 190.75 52.56 17.88 14.65 -107.48
3 1438 204.53 43.29 359.50 344.13 70.23 21.68 21.12 -76.47
(See blob_analyzer__define.pro)
NAME:
BLOB_ANALYZER__DEFINE
PURPOSE:
The purpose of this routine is to create a system for analyzing
regions of interest (ROIs) or (more commonly) "blobs" inside images.
In particular, given a suitable image (this will require judgement on
your part), the program will automatically select "blobs" or connected
regions in the image and make it possible for you to analyze these
blobs. An example program is provided to show you one way the program
can be used.
The code is a wrapper, essentially, for LABEL_REGION and HISTOGRAM, with
a couple of my other image processing routines (FIND_BOUNDARY and FIT_ELLIPSE)
used in a supporting role.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Analysis, Image Processing
CALLING SEQUENCE:
analyzer = Obj_New("BLOB_ANALYZER", image)
INPUTS:
image: A two-dimensional image array. To make this program memory efficient,
a copy of the image is *not* stored in the object. You will be responsible
for image operations outside this program.
KEYWORDS:
ALL_NEIGHBORS: Set this keyword to look at all eight neighbors when searching
for connectivity. The default is to look for four neighbors on
each side of the starting pixel. Passed directly to LABEL_REGION.
MASK: A two-dimensional array, the same size as image, that identifies the
foreground and background pixels in the image. Applying the mask
should result in a bi-level image of 0s and 1s, where 1 identifies the
blobs you wish to analyze. If a mask is not provided, the mask is created
like this:
mask = image > 0
SCALE: A one- or two-dimensional given the pixel scaling parameters. By default [1.0, 1.0].
If passed a scalar, the scale parameter is applied to both the X and Y directions of
each pixel. Statistical output is reported with scaling unless the NOSCALE keyword
is set. Scaling also effects the data that is output from the various methods.
OBJECT METHODS:
The following methods are provided. Please see the documentation header for each method for
information on arguments and keywords that can be used with the method.
FitEllipse: This method fits an ellipse to the blob. It returns information about the fitted
ellipse, including the points that all the ellipse to be drawn.
GetIndices: This method returns the indices for a particular blob in the image.
GetStats: This method returns a structure containing statistics for a particular blob in the image.
The structure is defined as follows:
stats = {INDEX: indexNumber, $ ; The index number of this blob.
COUNT: N_Elements(indices), $ ; The number of indices in this blob.
PERIMETER_PTS: boundaryPts, $ ; A [2,n] array of points that describe the blob perimeter.
PIXEL_AREA: pixelArea, $ ; The area as calculated by pixels in the blob.
PERIMETER_AREA: perimeterArea, $ ; The area as calculated by the blob perimeter. (Smaller than pixel area.)
CENTER: centroid[0:1], $ ; The [x,y] array that identifies the centroid of the blob.
PERIMETER_LENGTH: perimeter_length, $ ; The perimenter length (scaled unless the NOSCALE keyword is set).
SCALE: scale, $ ; The [xscale, yscale] array used in scaling.
MINCOL: Min(xyindices[0,*]), $ ; The minimum column index in the blob.
MAXCOL: Max(xyindices[0,*]), $ ; The maximum column index in the blob.
MINROW: Min(xyindices[1,*]), $ ; The minimum row index in the blob.
MAXROW: Max(xyindices[1,*])} ; The maximum row index in the blob.
NumberOfBlobs: The number of blobs identified in the image.
ReportStats: This methods reports statistics on every identified blob in the image. The
report can be sent to the display (the default) or to a file. The format for
the report works for most images, but you may have to change the format or override
this method for your particular image. The reported statistics are basically the
output of the GetStats and FitEllipse methods.
Here is an example of statistical output from the example program below.
INDEX NUM_PIXELS CENTER_X CENTER_Y PIXEL_AREA PERIMETER_AREA PERIMETER_LENGTH MAJOR_AXIS MINOR_AXIS ANGLE
0 426 107.89 9.78 106.50 98.00 37.56 12.15 11.29 -8.05
1 580 151.97 10.22 145.00 134.25 49.21 17.49 11.77 -0.99
2 812 266.29 15.36 203.00 190.75 52.56 17.88 14.65 -107.48
3 1438 204.53 43.29 359.50 344.13 70.23 21.68 21.12 -76.47
RESTRICTIONS:
Requires programs from the Coyote Library. At the very least, those below are required.
It is *highly* recommended that you install the entire library. FIT_ELLIPSE has been
changed specifically for this release, so by sure you get a copy of that with this
source code.
http://www.dfanning.com/programs/coyoteprograms.zip
ERROR_MESSAGE http://www.dfanning.com/programs/error_message.pro
FIND_BOUNDARY http://www.dfanning.com/programs/find_boundary.pro
FIT_ELLIPSE http://www.dfanning.com/programs/fit_ellipse.pro
The program currently works only with 2D bi-level images.
EXAMPLE:
To run an example program. Compile the file and type "example" at the IDL command line.
IDL> .compile blob_analyzer__define
IDL> example
MODIFICATION HISTORY:
Written by David W. Fanning, Fanning Software Consulting, 17 August 2008.
Ideas taken from discussion with Ben Tupper and Ben's program HBB_ANALYZER.
(See blob_analyzer__define.pro)
NAME:
CAPFIRSTLETTER
PURPOSE:
Given a string, separates the parts by white space, commas,
semi-colons, or colons. Each part has the first letter capitalized.
The returned string has the capitalized parts separated by a space.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
capitalizedString = CatFirstLetter(theString)
AUGUMENTS:
theString: The input string.
RETURN_VALUE:
capitalizedString: The capitalized output string. There is a space between parts
(words) of the input string.
KEYWORDS:
None.
MODIFICATION HISTORY:
Written by David W. Fanning, 29 July 2005.
(See capfirstletter.pro)
NAME:
CENTERTLB
PURPOSE:
This is a utility routine to position a widget program
on the display at an arbitrary location. By default the
widget is centered on the display.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
CenterTLB, tlb, [x, y, /NOCENTER, /DEVICE]
REQUIRED INPUTS:
tlb: The top-level base identifier of the widget program. This must
be a valid widget ID.
OPTIONAL INPUTS:
x: Set this equal to a normalized position for the center
of the widget as measured from the left-hand side of the screen.
The default value is 0.5 (the center) Setting this equal to 1.0
places the widget at the far right-hand side of the screen.
y: Set this equal to a normalized position for the center
of the widget as measured from the bottom of the screen.
The default value is 0.5 (the center) Setting this equal to 1.0
places the widget at the top of the screen.
KEYWORDS:
DEVICE: Normally, the x and y parameters are specified in normalized
coordinates. If this keyword is set, they are taken to be in DEVICE
coordinates.
NOCENTER: By default, the center of the widget is positioned at the
location specified by the x and y parameters. If NOCENTER is set
to a non-zero value, then the upper left corner of the widget
is postioned at the specifed location.
PROCEDURE:
The program should be called after all the widgets have
been created, but just before the widget hierarchy is realized.
It uses the top-level base geometry along with the display size
to calculate offsets for the top-level base that will center the
top-level base on the display.
COMMENT:
Regardless of the values set for x, y and NOCENTER, the widget
is not permitted to run off the display.
MODIFICATION HISTORY:
Written by: Dick Jackson, 12 Dec 98.
Modified to use device-independent Get_Screen_Size
function. 31 Jan 2000. DWF.
Added x, y, NOCENTER and run-off protection. 26 Jan 2001. BT.
Added a maximum value of 1280 for X screen size. This helps
center the widget on a single monitor when using dual
monitor settings with some graphics cards. 3 Feb 2003. DWF.
Added DEVICE keyword. 4 January 2006. DWF.
(See centertlb.pro)
NAME:
Checkerboard
PURPOSE:
This function returns a 2D image, with boxes of alternating colors.
Checkerboard images are useful in certain types of image processing
procedures and for making blended image masks.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Image Processing
CALLING SEQUENCE:
board = Checkerboard()
RETURN VALUE:
board: A 2D long array of alternating colored boxes.
ARGUMENTS:
boxes: The number of boxes of alternating colors on each side
of the resulting image. Must be an even integer greater
than or equal to two. Optional. Default is 8 (normal
checkerboard).
INPUT KEYWORDS:
BLACK: The value of the "black" boxes. By default, 0.
WHITE: The value of the "white" boxes. By default, 255.
XSIZE: The X size of the returned image. By default, 400.
YSIZE: The Y size of the returned image. By default, 400.
COMMON BLOCKS:
None.
RESTRICTIONS:
Requires FSC_COLOR from the Coyote Library.
http://www.dfanning.com/programs/fsc_color.pro
EXAMPLE:
IDL> TVImage, Checkerboard()
MODIFICATION HISTORY:
Written by David W. Fanning, 26 September 2007, based on suggestions
of JD Smith on IDL newsgroup 25-26 Septermber 2007.
(See checkerboard.pro)
NAME:
CHGCOLOR
PURPOSE:
The purpose of this routine is to allow the user to change
the color at a particular color index. The user is able to
mix their own color by manipulating red, green, and blue
sliders. This routine is ideal for changing axes or background
colors of a plot, for example. The routine works on 8-bit,
16-bit, and 24-bit displays.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Widgets, Colors.
CALLING SEQUENCE:
CHGCOLOR, index
REQUIRED INPUTS:
INDEX: The color index to be changed. It must be a value
between 0 and 255.
KEYWORD PARAMETERS:
LABEL: Text that goes next to the color window. The default is
"Resulting Color".
GROUP_LEADER: The group leader for this program. When the group leader
is destroyed, this program will be destroyed.
NOTIFYID: A a 2 column by n row array that contains the IDs of widgets
that should be notified when CHGCOLOR changes a color. The first
column of the array contains widgets that should be notified. The
second column contains IDs of widgets that are at the top of the
hierarch in which the corresponding widgets in the first column
are located. (The purpose of the top widget IDs is to make it
possible for the widget in the first column to get the "info"
structure of the widget program.) An CHGCOLOR_LOAD event will be
sent to the widget identified in the first column. The event
structure is defined like this:
event = {CHGCOLOR_LOAD, ID:0L, TOP:0L, HANDLER:0L, $
r:(!D.N_COLORS < 256), g:(!D.N_COLORS < 256), b:(!D.N_COLORS < 256)}
The ID field will be filled out with NOTIFYID(0, n) and the TOP
field will be filled out with NOTIFYID(1, n).
TITLE: This is the window title. It is "Modify Drawing Color" by
default. The program is registered with the name "chgcolor " plus
the TITLE string. The register name is checked before the widgets
are defined. This gives you the opportunity to have multiple copies
of CHGCOLOR operating simultaneously. (For example, one will change
the background color and one will change the plotting color.)
XOFFSET: This is the X offset of the program on the display. The
program will be placed approximately in the middle of the display
by default.
YOFFSET: This is the Y offset of the program on the display. The
program will be placed approximately in the middle of the display
by default.
COMMON BLOCKS:
None.
SIDE EFFECTS:
Color at the specified index is changed. Events are sent to widgets
if the NOTIFYID keyword is used.
RESTRICTIONS:
None.
EXAMPLE:
To change the background color of a plot, type:
CHGCOLOR, !P.Background
To see a more complete example, look at the program SLICE
in the Coyote Software Library:
ftp://ftp.frii.com/pub/dfanning/outgoing/idl_examples
MODIFICATION HISTORY:
Written by David Fanning, 23 April 97.
12 May 97, Fixed a bug in the way colors were loaded when
a tracking event occurred. DWF
13 May 97, Added a JUST_REGISTER keyword and set it up for
running in IDL 5.0 as a non-blocking widget.
27 Sept 98. Fixed problems caused by IDL 5.1 color changes.
27 Sept 98. Removed JUST_REGISTER keyword. Made widget non-blocking.
03 Nov 98. Modified layout and added slider ganging. DWF.
(See chgcolor.pro)
NAME:
CIndex
PURPOSE:
This is a program for viewing the current colors in the
colortable with their index numbers overlayed on each color.
On 24-bit systems you must click the cursor in the graphics window
to see the colors in the current color table.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY: Graphics
CALLING SEQUENCE: CIndex
INPUTS: None.
INPUT KEYWORDS:
BREWER: If this keyword is set, the BREWER colors will be loaded with the
Change Colors button. (Assuming the brewer color table file, fsc_brewer.tbl,
has been installed.
OUTPUTS: None
OPTIONAL OUTPUTS: None
OUTPUT KEYWORDS:
NOTIFYID: A two-element array containing the Change Colors button widget
identifier and the identifier of the top-level base widget. This
array is meant to be sent to an XCOLORS routine via its NOTIFYID
keyword. This will allow instant updating of the CINDEX interface.
COMMON BLOCKS: None
SIDE EFFECTS: None
RESTRICTIONS: Reqires XCOLORS and TVIMAGE from the Coyote Library:
http://www.dfanning.com/programs/xcolors.pro
http://www.dfanning.com/programs/tvimage.pro
PROCEDURE:
Draws a 31x25 set of small rectangles in 256 different colors.
Writes the color index number on top of each rectangle.
MODIFICATION HISTORY: Written by David Fanning, May 1995
Widgetized and made it work in 24-bit color. Colors are
updated by clicking in window. 22 Oct 98. DWF
Replace POLYFILL with TV command to avoid underflow error in
Z-buffer. 8 March 99. DWF
Fixed a problem with 24-bit devices with color decomposition ON. 15 Feb 2000. DWF.
Added the NOTIFYID keyword, 15 Dec 2005. DWF.
Added BREWER keyword, 19 May 2008. DWF.
(See cindex.pro)
NAME:
CLIPBOARD
PURPOSE:
The purpose of this program is to copy the contents of a
graphics window to the clipboard for subsequent pasting into
applications such as Photoshop or Powerpoint.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
Graphics.
CALLING SEQUENCE:
CLIPBOARD, window_index
OPTIONAL INPUTS:
window_index: The window index number of the graphics window to
copy. If absent, the current graphics window is used
by default.
KEYWORDS:
All COLOR_QUAN keywords are allowed. In particular, if you are
taking snapshots of line plots with few colors in them, you may
get better results by calling the program with the CUBE=6 keyword
set. Otherwise, white colors can sometimes be a bit gray.
OUTPUTS:
None.
COMMON BLOCKS:
None.
DEPENDENCIES:
Uses the IDLgrClipboard object introduced in IDL 5.2(?).
PROCEDURE:
Copies the window contents to a clipboard object.
EXAMPLE:
IDL> Window
IDL> Plot, Findgen(11)
IDL> CLIPBOARD
RESTRICTIONS:
May not work for all applications. Applications tested successfully
include: Framemaker, Powerpoint, Photoshop, Excel, Microsoft Word.
Converts 24-bit images to 2D images with color tables.
MODIFICATION HISTORY:
Written by: David W. Fanning, 24 October 2001.
Added _EXTRA keyword to pass COLOR_QUAN keywords along. 28 Oct 2002. DWF.
(See clipboard.pro)
NAME:
CLIPSCL
PURPOSE:
This is a utility routine to perform linear scaling (similar to BYTSCL)
on image arrays. If differs from BYTSCL only in that a user-specified
percentage of pixels can be clipped from the image histogram, prior to
scaling. By default, two percent of the pixels are clipped. Clipping
occurs at both ends of the image histogram.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
scaledImage = CLIPSCL(image, clipPercent)
ARGUMENTS:
image: The image to be scaled. Written for 2D images, but arrays
of any size are treated alike.
clipPercent: The percent of image clipping. Optional argument is set
to 2 by default. Must be value between 0 and 49. Clipping
occurs from both ends of image histogram, so a clip of 2
linearly scales approximately 96% of the image histogram.
Clipping percents are approximations only, and depend
entirely on the distribution of pixels in the image. For
interactive scaling, see XSTRETCH.
INPUT KEYWORDS:
NEGATIVE: If set, the "negative" of the result is returned.
OMAX: The output image is scaled between OMIN and OMAX. The
default value is 255.
OMIN: The output image is scaled between OMIN and OMAX. The
default value is 0.
OUTPUT KEYWORDS:
THRESHOLD: A two-element array containing the image thresholds for clipping.
RETURN VALUE:
scaledImage: The output, scaled into the range OMIN to OMAX. A byte array.
COMMON BLOCKS:
None.
EXAMPLES:
LoadCT, 0 ; Gray-scale colors.
image = LoadData(22) ; Load image.
TV, ClipScl(image, 4)
RESTRICTIONS:
Requires SCALE_VECTOR from the Coyote Library:
http://www.dfanning.com/programs/scale_vector.pro
MODIFICATION HISTORY:
Written by: David W. Fanning, 6 September 2007.
(See clipscl.pro)
NAME:
COLOR24
PURPOSE:
The purpose of this function is to convert a RGB color triple
into the equivalent 24-bit long integer. The 24-bit integer
can be decomposed into the appropriate color by interpreting
the lowest 8 bits as red, the middle 8 bits as green, and the
highest 8 bits as blue.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
Graphics, Color Specification.
CALLING SEQUENCE:
color = COLOR24(rgb_triple)
INPUTS:
RGB_TRIPLE: A three-element column or row array representing
a color triple. Or an N-by-three element array of color triples.
The values of the elements must be between 0 and 255.
KEYWORD PARAMETERS:
None.
COMMON BLOCKS:
None.
SIDE EFFECTS:
None.
RESTRICTIONS:
None.
EXAMPLE:
To convert the color triple for the color YELLOW,
(255, 255, 0), to the hexadecimal value '00FFFF'x
or the decimal number 65535, type:
color = COLOR24([255, 255, 0])
This routine was written to be used with device-independent
color programs like GETCOLOR.
MODIFICATION HISTORY:
Written by: David Fanning, 3 February 96.
Completely revised the algorithm to accept color arrays. 19 October 2000. DWF.
(See color24.pro)
NAME:
COLORBAR
PURPOSE:
The purpose of this routine is to add a color bar to the current
graphics window.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
Graphics, Widgets.
CALLING SEQUENCE:
COLORBAR
INPUTS:
None.
KEYWORD PARAMETERS:
ANNOTATECOLOR: The name of the "annotation color" to use. The names are those for
FSC_COLOR, and using the keyword implies that FSC_COLOR is also in
your !PATH. If this keyword is used, the annotation color is loaded
*after* the color bar is displayed. The color will be represented
as theColor = FSC_COLOR(ANNOTATECOLOR, COLOR). This keyword is provide
to maintain backward compatibility, but also to solve the problem of
and extra line in the color bar when this kind of syntax is used in
conjunction with the indexed (DEVICE, DECOMPOSED=0) model is used:
LoadCT, 33
TVImage, image
Colorbar, Color=FSC_Color('firebrick')
The proper syntax for device-independent color is like this:
LoadCT, 33
TVImage, image
Colorbar, AnnotateColor='firebrick', Color=255
BOTTOM: The lowest color index of the colors to be loaded in
the bar.
CHARSIZE: The character size of the color bar annotations. Default is !P.Charsize.
COLOR: The color index of the bar outline and characters. Default
is !P.Color..
DIVISIONS: The number of divisions to divide the bar into. There will
be (divisions + 1) annotations. The default is 6.
FONT: Sets the font of the annotation. Hershey: -1, Hardware:0, True-Type: 1.
FORMAT: The format of the bar annotations. Default is '(I0)'.
INVERTCOLORS: Setting this keyword inverts the colors in the color bar.
MAXRANGE: The maximum data value for the bar annotation. Default is
NCOLORS.
MINRANGE: The minimum data value for the bar annotation. Default is 0.
MINOR: The number of minor tick divisions. Default is 2.
NCOLORS: This is the number of colors in the color bar.
NODISPLAY: COLORBAR uses FSC_COLOR to specify some of it colors. Normally,
FSC_COLOR loads "system" colors as part of its palette of colors.
In order to do so, it has to create an IDL widget, which in turn
has to make a connection to the windowing system. If your program
is being run without a window connection, then this program will
fail. If you can live without the system colors (and most people
don't even know they are there, to tell you the truth), then setting
this keyword will keep them from being loaded, and you can run
COLORBAR without a display.
POSITION: A four-element array of normalized coordinates in the same
form as the POSITION keyword on a plot. Default is
[0.88, 0.10, 0.95, 0.90] for a vertical bar and
[0.10, 0.88, 0.90, 0.95] for a horizontal bar.
RANGE: A two-element vector of the form [min, max]. Provides an
alternative way of setting the MINRANGE and MAXRANGE keywords.
REVERSE: Setting this keyword reverses the colors in the colorbar.
RIGHT: This puts the labels on the right-hand side of a vertical
color bar. It applies only to vertical color bars.
TICKNAMES: A string array of names or values for the tick marks.
TITLE: This is title for the color bar. The default is to have
no title.
TOP: This puts the labels on top of the bar rather than under it.
The keyword only applies if a horizontal color bar is rendered.
VERTICAL: Setting this keyword give a vertical color bar. The default
is a horizontal color bar.
COMMON BLOCKS:
None.
SIDE EFFECTS:
Color bar is drawn in the current graphics window.
RESTRICTIONS:
The number of colors available on the graphics display device (not the
PostScript device) is used unless the NCOLORS keyword is used.
Requires the FSC_COLOR program from the Coyote Library:
http://www.dfanning.com/programs/fsc_color.pro
EXAMPLE:
To display a horizontal color bar above a contour plot, type:
LOADCT, 5, NCOLORS=100
CONTOUR, DIST(31,41), POSITION=[0.15, 0.15, 0.95, 0.75], $
C_COLORS=INDGEN(25)*4, NLEVELS=25
COLORBAR, NCOLORS=100, POSITION=[0.15, 0.85, 0.95, 0.90]
MODIFICATION HISTORY:
Written by: David W. Fanning, 10 JUNE 96.
10/27/96: Added the ability to send output to PostScript. DWF
11/4/96: Substantially rewritten to go to screen or PostScript
file without having to know much about the PostScript device
or even what the current graphics device is. DWF
1/27/97: Added the RIGHT and TOP keywords. Also modified the
way the TITLE keyword works. DWF
7/15/97: Fixed a problem some machines have with plots that have
no valid data range in them. DWF
12/5/98: Fixed a problem in how the colorbar image is created that
seemed to tickle a bug in some versions of IDL. DWF.
1/12/99: Fixed a problem caused by RSI fixing a bug in IDL 5.2. Sigh... DWF.
3/30/99: Modified a few of the defaults. DWF.
3/30/99: Used NORMAL rather than DEVICE coords for positioning bar. DWF.
3/30/99: Added the RANGE keyword. DWF.
3/30/99: Added FONT keyword. DWF
5/6/99: Many modifications to defaults. DWF.
5/6/99: Removed PSCOLOR keyword. DWF.
5/6/99: Improved error handling on position coordinates. DWF.
5/6/99. Added MINOR keyword. DWF.
5/6/99: Set Device, Decomposed=0 if necessary. DWF.
2/9/99: Fixed a problem caused by setting BOTTOM keyword, but not NCOLORS. DWF.
8/17/99. Fixed a problem with ambiguous MIN and MINOR keywords. DWF
8/25/99. I think I *finally* got the BOTTOM/NCOLORS thing sorted out. :-( DWF.
10/10/99. Modified the program so that current plot and map coordinates are
saved and restored after the colorbar is drawn. DWF.
3/18/00. Moved a block of code to prevent a problem with color decomposition. DWF.
4/28/00. Made !P.Font default value for FONT keyword. DWF.
9/26/00. Made the code more general for scalable pixel devices. DWF.
1/16/01. Added INVERTCOLORS keyword. DWF.
5/11/04. Added TICKNAME keyword. DWF.
9/29/05. Added REVERSE keywords, which does the *exact* same thing as
INVERTCOLORS, but I can never remember the latter keyword name. DWF.
1/2/07. Added ANNOTATECOLOR keyword. DWF.
4/14/07. Changed the default FORMAT to I0. DWF.
5/1/07. Unexpected consequence of default format change is colorbar annotations
no longer match contour plot levels. Changed to explicit formating of
colorbar axis labels before PLOT command. DWF.
5/25/07. Previous change has unanticipated effect on color bars using
logarithmic scaling, which is not really supported, but I have an
article on my web page describing how to do it: http://www.dfanning.com/graphics_tips/logcb.html.
Thus, I've fixed the program to accommodate log scaling, while still not OFFICIALLY
supporting it. DWF.
10/3/07. Method used to calculate TICKNAMES produces incorrect values in certain cases when
the min and max range values are integers. Now force range values to be floats. DWF.
10/17/07. Accidentaly use of INTERP keyword in CONGRID results in wrong bar values for
low NCOLORS numbers when INVERTCOLORS or REVERSE keyword is used. Removed INTERP keyword. DWF.
11/10/07. Finished fixing program to accommodate log scaling in ALL possible permutations. DWF.
8 Feb 2008. Added CRONJOB keyword and decided to use month names when I write the date. DWF.
8 Feb 2008. Renamed CRONJOB to NODISPLAY to better reflect its purpose. DWF.
21 May 2008. Changed the default CHARSIZE to !P.CHARSIZE from 1.0. DWF.
(See colorbar.pro)
NAME:
COLORBAR__DEFINE
PURPOSE:
The purpose of this routine is to implement a COLORBAR object
class. The ColorBar is rendered in the direct graphics system.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Graphics.
CALLING SEQUENCE:
colorbar = Obj_New("COLORBAR")
INPUTS:
All inputs to the program are via keyword parameters.
KEYWORD PARAMETERS:
Background: Background color. This is the color with which the colorbar is
erased. The default color is !P.Background.
Bottom: Bottom color index of colors allocated to colorbar.
Charsize: Character size of annotation. Default is 1.0.
Color: Color of annotation and outline. Default is !P.Color.
Font: Font to use for annotation. Default is -1, Hershey fonts.
Format: Format of annotation. Default is "(F8.2)".
Major: The number of major tick intervals. Default is 5.
Minor: The number of minor tick intervals. Default is 2.
MinusOne: Set this keyword to choose MinusOne keyword on the Congrid command
that resizes the colorbar into the window.
NColors: The number of colors allocated to colorbar. Default is (256 <
!D.N_Colors).
Neighbor: Set to indicate Nearest Neighbor sampling for Congrid. Default is
0 (Bilinear).
Position: The position of colorbar in normalized coordinates. Default for a
horizontal colorbar is [0.15, 0.88, 0.85, 0.95]. Default for a
vertical colorbar is [0.88, 0.15, 0.95, 0.85]. These defaults are
designed for a 400 by 400 window.
Range: The data range on colorbar. Default is [0, 255].
TickLen: The length of tick marks. Default is -0.1
TickV: Locations for the tick marks in data units. This is the same as
the [XY]TickV keyword. Default is to do what IDL would do
normally.
Vertical: Set this keyword if you want a vertical colorbar. Default is
horizontal.
XEraseBox: A five-element vector of X points (normalized) for erasing the
colorbar plot. Normally this keyword will not have to be used.
The program uses the plot REGION for erasing. But larger
character sizes can result in annotation going outside the
region enclosed by the plot. If that is the case, then use this
keyword along with YEraseBox to specify a larger-than-normal
erasure area. The points are sent to the POLYFILL command for
erasing.
POLYFILL, xEraseBox, yEraseBox, /Normal, Color=background
YEraseBox: A five-element vector of Y points (normalized) for erasing the
colorbar plot.
OBJECT METHODS:
Clamp: This procedure method allows the color bar range to be "clamped"
to a particular data range.
Draw: This procedure method draws the colorbar in the display window. The
ERASE keyword to this method will erase the current colorbar (by
calling the ERASE method) before drawing the colorbar in the display
window.
colorbar->Draw
Erase: This procedure method erases the colorbar object in the window. It
accomplishes this by performing a POLYFILL in the background color.
This method is primarily useful for interactive graphics display
devices.
colorbar->Erase
GetProperty: This procedure method allows one to obtain the current state
of the object via the keyword parameters listed above.
colorbar->GetProperty, Range=currentRange, Title=currentTitle
Print, currentRange, currentTitle
SetProperty: This procedure method allows one to set the properties of the
colorbar object via the keywords described above. In addition,
a DRAW and ERASE keyword are provided so that the colorbar can
be immediately drawn when the new property is set.
colorbar->SetProperty, Range=[500, 15000], /Erase, /Draw
COMMON BLOCKS:
None.
SIDE EFFECTS:
The display window is not erased first.
RESTRICTIONS:
None.
EXAMPLE:
To create a colorbar, use it, then destroy it, type:
colorbar = Obj_New("COLORBAR", Title='Colorbar Values', Range=[0,1000],$
Format='(I4)')
Window
LoadCT, 5
colorbar->Draw
colorbar->SetProperty, Range=[0,500], /Erase, /Draw
Obj_Destroy, colorbar
MODIFICATION HISTORY:
Written by: David Fanning, Fanning Software Consulting,
26 November 1998.
Added Horizontal keyword to SetProperty method and fixed problem in
going from Vertical to Horizontal color bars. 29 Nov 1998. DWF.
Added LoadCT method and current color table index to object.
6 December 1998.
Fixed a bug dealing with nearest neighbor resampling. 30 Mar 1999. DWF.
Fixed a bug with how NCOLORS and BOTTOM keywords interacted.
29 Aug 1999. DWF.
10 Oct 99. Modified the program so that current plot and map coordinates
are saved and restored after the colorbar is drawn. DWF.
26 May 2000 Added {XY}TICKV capability to the draw method. This
required adding TickV to the object data structure, and to the
INIT, GetProperty and SetProperty methods.
Changed default tick length to -0.1. DWF (and Jack Saba)
18 Nov 2001. Added Clamp method. DWF.
(See colorbar__define.pro)
NAME:
ColorButtonBitmap
PURPOSE:
The purpose of this program is to create a 24-bit bitmap that can be used to
create a colored widget button.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Widget Programming
CALLING SEQUENCE:
bitmap = ColorButtonBitmap(theText)
button = Widget_Button(tlb, Value=bitmap)
REQUIRED INPUTS:
theText - The text you wish to have on the button.
OUTPUTS:
bitmap - A 3xMxN byte array, representing a 24-bit image that is used
as a button value.
OPTIONAL KEYWORDS:
BGCOLOR - The name of the background color. For example, 'Yellow', 'Tan', etc.
The name must be compatible with names appropriate for FSC_COLOR.
FGCOLOR - The name of the foreground color. For example, 'Navy', 'Black', etc.
The name must be compatible with names appropriate for FSC_COLOR.
DEPENDENCIES:
Reqires FSC_COLOR from the Coyote Library:
http://www.dfanning.com/programs/fsc_color.pro
EXAMPLE:
tlb = Widget_Base(/Row, /Exclusive)
button1 = Widget_Button(tlb, Value=ColorButtonBitmap('Button 1')) ; Normal button.
button2 = Widget_Button(tlb, Value=ColorButtonBitmap('Button 2', FGCOLOR='YELLOW', BGCOLOR='NAVY'))
button3 = Widget_Button(tlb, Value=ColorButtonBitmap('Button 3', BGCOLOR='YELLOW', FGCOLOR='NAVY'))
Widget_Control, tlb, /Realize
MODIFICATION HISTORY:
Written by David Fanning, May 25, 2007 based on code named BitmapForButtonText supplied to the IDL
newsgroup by Dick Jackson: http://www.dfanning.com/tip_examples/bitmapforbuttontext.pro.
(See colorbuttonbitmap.pro)
NAME:
CONTRASTZOOM
PURPOSE:
The purpose of this program is to demonstrate how to
zoom an image "in place" and how to window and level
(set "contrast and brightness") an image using object
graphics functionality. The exercise involves using
multiple views in an object graphics scene, and being
able to interact with different views in different ways.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Widgets, Object Graphics.
CALLING SEQUENCE:
ContrastZoom, image
REQUIRED INPUTS:
None. The image "mr_knee.dcm" from the examples/data directory
is used if no data is supplied in call.
OPTIONAL INPUTS
image: A 2D image array of any data type.
OPTIONAL KEYWORD PARAMETERS:
COLORTABLE: The number of a color table to use as the image palette.
Color table 0 (grayscale) is used as a default.
GROUP_LEADER: The group leader for this program. When the group leader
is destroyed, this program will be destroyed.
COMMON BLOCKS:
None.
SIDE EFFECTS:
None.
RESTRICTIONS:
None. The Coyote Library program VCOLORBAR is included.
EXAMPLE:
To use this program with your 8-bit image data and a red-temperature
color scale, type:
IDL> ContrastZoom, image, Colortable=3
NOTES:
The left image is used to "zoom" into a portion of the image.
The aspect ratio of the sub-image is always preserved. To see
the entire image, click and release the mouse button in this
window.
The center image is used to adjust the contrast and brightness
(sometimes called the "window" and "level" of the image. Click and
drag the mouse vertically to set contrast. Click and drag the mouse
horizontally to set brightness. To return to original values (25%
contrast and 75% brightness), click and release in the center image.
The color bars shows the image values of the image.
MODIFICATION HISTORY:
Written by David Fanning, 18 November 2001.
Added second colorbar to show the relationship of the clamped
colors to the overall image values. 19 November 2001. DWF.
(See contrastzoom.pro)
NAME:
CONVERT_TO_TYPE
PURPOSE:
Converts its input argument to a specified data type.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
result = Convert_To_Type(input, type)
INPUT_PARAMETERS:
input: The input data to be converted.
type: The data type. Accepts values as given by Size(var, /TNAME) or Size(var, /TYPE).
OUTPUT_PARAMETERS:
result: The input data is converted to specified data type.
KEYWORDS:
None.
RESTRICTIONS:
Data types STRUCT, POINTER, and OBJREF are not allowed.
MODIFICATION HISTORY:
Written by David W. Fanning, 19 February 2006.
(See convert_to_type.pro)
NAME:
CTLOAD
PURPOSE:
This is a drop-in replacement for the ITTVIS-supplied program LOADCT.
The same keywords used with LOADCT apply. In addition, a REVERSE keyword
is supplied to reverse the color table vectors, and a CLIP keyword is
supplied to be able to clip the normal LOADCT color table. This is
extremely useful if you wish to use a reduced number of colors. Also,
all color table loading is handled silently. (To fix a major pet-peeve
of mine.)
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
CTLOAD, table
AUGUMENTS:
table: Optional table number to load. Integer from 0 to the number of
tables in the file, minus 1. Default value is 0.
KEYWORDS:
BOTTOM: The first color table index. Set to 0 by default.
BREWER: Set this keyword if you wish to use the Brewer Colors, as
implemented by Mike Galloy in the file brewer.tbl, and implemented
here as fsc_brewer.tbl. See these references:
Brewer Colors: http://www.personal.psu.edu/cab38/ColorBrewer/ColorBrewer_intro.html
Mike Galloy Implementation: http://michaelgalloy.com/2007/10/30/colorbrewer.html
This program will look first in the $IDL_DIR/resource/colors directory for
the color table file, and failing to find it there will look in the same
directory that the source code of this program is located, then in the IDL path.
Finally, if it still can't find the file, it will ask you to locate it.
If you can't find it, the program will simply return without loading a color table.
NOTE: YOU WILL HAVE TO DOWNLOAD THE FSC_BREWER.TBL FILE FROM THE COYOTE LIBRARY AND
PLACE IT IN ONE OF THE THREE PLACES OUTLINED ABOVE:
http://www.dfanning.com/programs/fsc_brewer.tbl
CLIP: A one- or two-element integer array that indicates how to clip
the original color table vectors. This is useful if you are
restricting the number of colors, and do not which to have
black or white (the usual color table end members) in the
loaded color table. CLIP[0] is the lower bound. (A scalar
value of CLIP is treated as CLIP[0].) CLIP[1] is the upper
bound. For example, to load a blue-temperature color bar
with only blue colors, you might type this:
IDL> CTLOAD, 1, CLIP=[110,240]
IDL> CINDEX
Or, alternatively, if you wanted to include white at the upper
end of the color table:
IDL> CTLOAD, 1, CLIP=110
IDL> CINDEX
RGB_TABLE: If this keyword is set to a named variable, the color table
is returned as an [NCOLORS,3] array and no colors are loaded
in the display.
FILE: The name of a color table file to open. By default colors1.tbl in
the IDL directory.
GET_NAMES: If set to a named variable, the names of the color tables are returned
and no colors are loaded in the display. Note that RGB_TABLE cannot be
used concurrently with GET_NAMES. Use two separate calls if you want both.
NCOLORS: The number of colors loaded. By default, !D.TABLE_SIZE.
REVERSE: If this keyword is set, the color table vectors are reversed.
SILENT: This keyword is provided ONLY for compatibility with LOADCT. *All*
color table manipulations are handled silently.
EXAMPLES:
Suppose you wanted to create a color table that displayed negative values with
red-temperature values and positive values with blue-temperature values, and you
would like the red-temperature values to be reversed in the color table (so dark
colors adjoin in the color table and indicate values near zero). You could do this:
CTLoad, 0
CTLoad, 3, /REVERSE, CLIP=[32,240], BOTTOM=1, NCOLORS=10
CTLoad, 1, CLIP=[64, 245], BOTTOM=11, NCOLORS=10
Colorbar, NCOLORS=20, BOTTOM=1, DIV=10, RANGE=[-10,10]
Here is an example that shows the difference between LOADCT and CTLOAD:
ERASE, COLOR=FSC_COLOR('Charcoal)
LoadCT, 5, NCOLORS=8
Colorbar, NCOLORS=8, DIVISIONS=8, POSITION=[0.1, 0.65, 0.9, 0.75], XMINOR=0, XTICKLEN=1
CTLoad, 5, NCOLORS=8, CLIP=[16, 240]
Colorbar, NCOLORS=8, DIVISIONS=8, POSITION=[0.1, 0.35, 0.9, 0.45], XMINOR=0, XTICKLEN=1
MODIFICATION HISTORY:
Written by David W. Fanning, 30 October 2007.
Added ability to read Brewer Color Table file, if available, with BREWER keyword. 14 May 2008. DWF.
Small change in the way the program looks for the Brewer file. 8 July 2008. DWF.
(See ctload.pro)
NAME:
CW_DRAWCOLOR
PURPOSE:
This compound widget is used to place a label or color name next
to a color patch. Clicking on the color patch allows the user
to select another color
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Graphics
CALLING SEQUENCE:
colorpatchID = CW_DrawColor(parent)
REQUIRED INPUTS:
parent - The identifier of a parent base widget.
OUTPUTS:
colorpatchID - The widget identifier of the top-level base of this compound widget
INPUT KEYWORDS:
COLOR - The name of the color to be displayed. Color names come from PickColorName.
COLUMN - Set this keyword to stack widgets in a column. Default is in a row.
EVENT_FUNC - The name of an event handler function for this compound widget.
EVENT_PRO -The name of an event handler procedure for this compound widget.
INDEX - An index number where the color should be loaded. !D.Table_Size-2, by default.
FILENAME - An optional input to pickcolorname specifying different
colors. See pickcolorname description for the file format.
LABEL_LEFT - Set this keyword to have the label text aligned on the left of the label. Default is to center.
LABEL_RIGHT - Set this keyword to have the label text aligned on the right of the label. Default is to center.
LABELSIZE - This is the X size of the label widget (containing the label) in device coordinates. Default is natural size.
LABELTEXT - This is the text on the label. Example, "Background Color", etc.
TITLE - This is the title on the PickColorName program that allows the user to select another color.
UVALUE - A user value for the widget.
XSIZE - The xsize (in pixel units) of the color patch. By default, 20.
YSIZE - The xsize (in pixel units) of the color patch. By default, 20.
OUTPUT KEYWORDS:
OBJECT - The object reference. Use this to call methods, etc.
OBJECT PROCEDURE METHODS:
Set_Value -- this method takes one argument, the new color name.
It will change the color of the widget if it has
already been realized.
Get_Value -- this method returns the color name the widget is displaying
DEPENDENCIES:
Reqires FSC_COLOR and PICKCOLORNAME from the Coyote Library:
http://www.dfanning.com/programs/fsc_color.pro
http://www.dfanning.com/programs/pickcolorname.pro
MODIFICATION HISTORY:
Written by David W. Fanning, March 2001.
Fixed a problem with self object cleanup. 7 March 2006. DWF.
Allow addition to already realized widget hierarchies, October 2007. L. Anderson.
Added set_value and get_value methods to the widget can be
updated after being realized. October 2007. L. Anderson.
Added option to pass filename on to pickcolorname. October
2007. L. Anderson
(See cw_drawcolor.pro)
NAME:
DBLTOSTR
PURPOSE:
This is a program for converting a double precision numerical value
to a string. It was originally offered by BioPhys on the IDL newsgroup.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utility
CALLING SEQUENCE:
stringValue = DblToStr(value)
INPUTS:
value - A double-precision or floating point value to be converted to a string.
OUTPUTS:
stringValue - The converted string value.
KEYWORDS:
None.
RESTRICTIONS:
Assumes 14 significant digits of precision.
MODIFICATION HISTORY:
Written by BioPhys and offered to the IDL newsgroup, 7 November 2005.
Slightly modified and renamed by David Fanning, 30 November, 2005.
(See dbltostr.pro)
NAME:
DIRPATH
PURPOSE:
The purpose of this function is to return a device-independent
name of a directory. It is similar to the IDL-supplied FILEPATH
routine, except that a file name is not required.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
Utility.
CALLING SEQUENCE:
IDL> theDirectory = DIRPATH('examples')
IDL> Print, theDirectory
C:\IDL\IDL56\examples
INPUTS:
subDirectory: This is a string argument containing the name of the
sub-directory you wish to use. It can be a string
array of sub-directory names. By default, the subDirectory
is set to ['examples', 'data']. To only return the Root_Directory,
set the subDirectory to a null string ("").
KEYWORDS:
ROOT_DIRECTORY: The name of the root directory to use. By default,
the root directory is set to !DIR.
OUTPUTS:
The machine-independent directory path.
MODIFICATION HISTORY:
Written by: David W. Fanning, 28 April 2003.
(See dirpath.pro)
NAME:
DRAWCOLORS
FILENAME:
drawcolors__define.pro
PURPOSE:
The purpose of this object program is provide a flexible way
to handle and select drawing colors. The program combines
features of two previous programs: GetColor and PickColor,
as well as adding features of its own. Sixteen original
colors are supplied, but users can create any color they
wish using the tools provided.
By default, these 16 colors are defined: Black, Magenta, Cyan, Yellow,
Green, Red, Blue, Navy, Aqua, Pink, Orchid, Sky, Beige, Charcoal, Gray, White.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
2642 Bradbury Court
Fort Collins, CO 80521 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
General programming.
CALLING SEQUENCE:
colors = Obj_New('DRAWCOLORS')
OPTIONAL INPUT PARAMETERS:
IDL> colors = Obj_New('DRAWCOLORS', red, green, blue, names)
RED -- A 16-element byte vector of red values for the drawing colors.
GREEN -- A 16-element byte vector of green values for the drawing colors.
BLUE -- A 16-element byte vector of blue values for the drawing colors.
NAMES -- A 16-element string vector of names for the drawing colors.
By default, these colors are defined: Black, Magenta, Cyan, Yellow,
Green, Red, Blue, Navy, Aqua, Pink, Orchid, Sky, Beige, Charcoal, Gray, White.
COMMON BLOCKS:
None.
RESTRICTIONS:
If you are going to use the XCOLORS method, you will need
the XColors program from the Coyote library:
http://www.dfanning.com/programs/xcolors.pro
The program is set up to handle 16 drawing colors. You may
modify the program to have a different number, but you will
have to modify the code in two places: (1) in the drawcolors__define
module and (2) in the INIT method.
FUNCTION METHODS:
COLOR24 ***************************************************************************
Purpose:
Turns a color triple into the equivalent 24-bit color integer value that
can be decomposed into the color.
Definition:
FUNCTION DrawColors::Color24, theColor
Parameters:
theColor -- A 3-element vector, representing a color triple.
Example:
yellow = colors->GetColor("yellow")
yellow24 = colors->Color24(yellow)
GETCOLOR ***************************************************************************
Purpose:
Returns the color triple, color index number, or the
24-bit integer representation, of the asked for color. In
normal operation, the colors are: Black, Magenta, Cyan, Yellow,
Green, Red, Blue, Navy, Aqua, Pink, Orchid, Sky, Beige, Charcoal,
Gray, and White.
Definition:
FUNCTION DrawColors::GetColor, theColor, startIndex, INDEXNUMBER=indexnumber, $
TRUECOLOR=truecolor, AutoDetermine=autodetermine
Parameters:
theColor -- A string representing the "name" of the color. If the name
can't be resolved or found, the first color is returned.
startIndex -- If present, and INDEXNUMBER is set, the colors are loaded at
this index number. Otherwise, the self.startIndex is used.
Keywords:
AUTODETERMINE -- If this keyword is set. the state of DECOMPOSITION is
determined (IDL 5.2 and higher) and either the INDEXNUMBER or
TRUECOLOR keyword is set appropriately. If the decomposition state
cannot be determined, the INDEXNUMBER keyword is set.
INDEXNUMBER -- If this keyword is set the colors are loaded and the
index number of the color is returned.
TRUECOLOR -- If this keyword is set, the color triple is converted into
a 24-bit integer before being returned. This keyword is ignored
if the INDEXNUMBER keyword is set.
Examples:
drawColor = colors->GetColor("yellow")
drawColor = colors->GetColor("blue", /Indexnumber)
drawColor = colors->GetColor("sky", /Truecolor)
GETCOLORS **************************************************************************
Purpose:
Returns the color triples, the color index numbers of, or the
24-bit integer representations of, all the colors.
Definition:
FUNCTION DrawColors::GetColors, startindex, INDEXNUMBER=indexnumber, $
TRUECOLOR=truecolor, Structure=structure
Parameters:
startIndex -- If present, and INDEXNUMBER is set, the colors are loaded at
this index number. If absent, startIndex = self.startIndex.
Keywords:
INDEXNUMBER -- If this keyword is set the colors are loaded and the
index numbers of all the colors are returned.
STRUCTURE -- If this keyword is set, the return value is a structure,
where each field of the structure is a color name and the value
of each field is either a color triple, an index number, or a
24-bit color value, depending upon the state of other keywords.
TRUECOLOR -- If this keyword is set, the color triples are converted to
24-bit integers before being returned. This keyword is ignored
if the INDEXNUMBER keyword is set.
Examples:
drawColors = colors->GetColors() ; drawColors is a 16-by-3 byte array.
drawColors = colors->GetColors(/IndexNumber) ; drawColors is a 16-element array of color indices.
drawColors = colors->GetColors(/TrueColor) ; drawColors is a 16-element array of 24-bit integers.
drawColors = colors->GetColors(/IndexNumber, /Structure) ; drawColors is a structure of index numbers.
Plot, data, Color=drawColors.yellow, Background=drawColors.charcoal
SELECT **************************************************************************
Purpose:
Puts up a blocking or modal widget dialog, allowing the user to select
from one of the 16 predefined colors available, or to mix their own color.
The user-defined color triple is returned as a result of the function.
Definition:
FUNCTION DrawColors::Select, Color=currentColor, StartIndex=startIndex, $
Title=title, Group_Leader=groupLeader, Cancel=cancelled, TrueColor=truecolor
Keywords:
CANCEL -- An output keyword that will return a value of 1 if the CANCEL
button is selected or if program operation is interrupted in any way.
COLOR -- The index number in the color table, where the current color
will be mixed. In other words, this color index will change when
the program is on the display. It will be restored to its previous
or entry color when the program exits.
GROUP_LEADER -- The group leader for the program. This keyword *must*
be set if calling this method from within a widget program if you
expect MODAL program operation.
NAME -- If this keyword is set, the return value of the function is
the "name" of the color.
STARTINDEX -- This is the starting index in the color table where the
16 predetermined colors will be loaded. The original colors will
be restored when the program exits. By default, this is set to
!D.Table-Size - (NCOLORS + 1).
TITLE -- The title of the program. By default: "Pick a Color"
TRUECOLOR -- If this keyword is set, the return value of the function
is a 24-bit eqivalent integer rather than the color triple.
Examples:
newColor = colors->Select() ; A blocking widget.
newColor = color->Select(Group_Leader=event.top, Cancel=cancelled)
IF NOT cancelled THEN TVLCT, newColor, info.dataColor
PROCEDURE METHODS:
GETPROPERTY ***********************************************************************
Purpose:
Allows the user to obtain the current properties of the object.
Definition:
PRO DrawColors::GetProperty, NAMES=names, RED=red, GREEN=green, BLUE=blue, $
STARTINDEX=startindex, NCOLORS=ncolors
Keywords:
NAMES -- Returns the current names of the colors as a string array.
RED -- Returns the current red values of the colors.
GREEN -- Returns the current green values of the colors.
BLUE -- Returns the current blue values of the colors.
STARTINDEX -- Returns the current starting index in the color table.
NCOLORS -- Returns the number of colors.
Example:
colors->GetProperty, Names=colorNames
Print, colorNames
LOADCOLORS ************************************************************************
Purpose:
Loads the predefined colors at a starting index.
Definition:
PRO DrawColors::LoadColors, startindex
Parameters:
STARTINDEX -- The starting color index in the color table. If not provided,
is set to !D.Table_Size - (self.ncolors + 1).
Example:
colors->LoadColors, 16
ORIGINALCOLORS *********************************************************************
Purpose:
Reloads the original 16 colors and their names
Definition:
PRO DrawColors::OriginalColors
Parameters:
None
Example:
colors->OriginalColors
REFRESH ***************************************************************************
Purpose:
Refreshes the modal GUI with the current drawing colors.
Definition:
PRO DrawColors::Refresh
Parameters:
None
Example:
colors->Refresh
SETPROPERTY ***********************************************************************
Purpose:
Allows the user to set the current properties of the object.
Definition:
PRO DrawColors::SetProperty, NAMES=names, RED=red, GREEN=green, BLUE=blue, $
STARTINDEX=startindex, NCOLORS=ncolors
Keywords:
NAMES -- The current names of the colors as a string array.
RED -- The current red values of the colors.
GREEN -- The current green values of the colors.
BLUE -- The current blue values of the colors.
STARTINDEX -- The current starting index in the color table.
NCOLORS -- The number of colors.
Example:
colorNames = 'Color ' + StrTrim(SIndGen(16),2)
colors->SetProperty, Names=colorNames
XCOLORS ***************************************************************************
Purpose:
Allows the user to select 16 new colors for the program by
using the XCOLORS program. The XColors program must be
somewhere in your !PATH.
Definition:
PRO DrawColors::XColors
Parameters:
None
Example:
colors->XColors
TUTORIAL:
Here is a short tutorial in how this object can be used. Note
that this doesn't exhaust all the possibilities.
1. Create the object.
IDL> colors = Obj_New("DrawColors")
2. Find out what colors it knows about.
IDL> colors->GetProperty, Names=colorNames
IDL> Print, colorNames
3. Ask for a color by name and load it at a color
index. Draw a plot in that color.
IDL> yellow = colors->GetColor("yellow")
IDL> TVLCT, yellow, 200
IDL> Device, Decomposed=0
IDL> Plot, Findgen(11), Color=200
4. Do the same thing, but in DECOMPOSED color.
IDL> Device, Decomposed=1
IDL> green = colors->GetColor("green", /TrueColor)
IDL> Plot, Findgen(11), Color=green
5. Find the color index number of the sky blue color.
IDL> Device, Decomposed=0
IDL> skyIndex = colors->GetColor("sky", /IndexNumber)
IDL> Plot, Findgen(11), Color=skyIndex
6. Load all 16 drawing colors at color index 32.
IDL> colors->LoadColors, 32
IDL> CIndex ; If them, if you have CINDEX from my library.
7. Get a structure of colors, with each field set to
the appropriate index number of its associated color.
IDL> Device, Decomposed=0
IDL> col = colors->GetColors(/IndexNumber, /Structure)
IDL> Plot, Findgen(11), Color=col.yellow, Background=col.charcoal
8. Allow the user to select a color from a GUI, then
load it and use it.
IDL> Device, Decomposed=0
IDL> theColor = colors->Select(Cancel=cancelled)
IDL> IF NOT cancelled THEN TVLCT, theColor, 10
IDL> Plot, Findgen(11), Color=10
9. Allow the user to choose 16 new drawing colors.
(Requires my XCOLORS program.)
IDL> colors->XColors
IDL> theseColors = colors->Select()
10. Let the object decide according to the device decomposition
state whether to return an index number or 24-bit value
for the color.
IDL> Plot, Findgen(11), Color=colors->GetColor('beige', /Autodetermine)
11. Call the GUI from within a widget program and load the
new color.
newcolor = info.colors->Select(Group_Leader=event.top, $
Cancel=cancelled)
IF NOT cancelled THEN TVLCT, newcolor, info.drawColor
12. Destroy the object.
IDL> Obj_Destroy, colors
MODIFICATION HISTORY:
Written by: David Fanning, 9 NOV 1999.
Added AUTODETERMINE keyword to the GetColor method. 10 NOV 1999. DWF.
Added NAME keyword to SELECT method. 18 MAR 2000. DWF.
Fixed a small bug in choosing the current color. 20 April 2000. DWF.
(See drawcolors__define.pro)
NAME:
DRAWCOUNTIES
PURPOSE:
Draws state counties in the USA from county shape files.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
DrawCounties, countyFile
ARGUMENTS:
countyFile: The name of the input shapefile containing county boundaries.
Must be defined, for example, 'co1990p020.shp'.
KEYWORDS:
ATTRIBUTE_NAME: The name of the attribute in the file that you wish to draw.
By default, this is set to the attribute name "STATE".
(In some shapefiles, the attribute might be named "STATE_ABBR".)
If you are unsure of the attribute names in your shapefile,
use the Coyote Library program SHAPEINFO to browse the file
ahead of time.
COLORS: The name of a color to draw the state outline or polygon in. This
may be a string array of the same size as STATENAMES. Color names
correspond to the colors available in FSC_COLOR. By default, "Sky Blue".
LINESTYLE: The normal LINESTYLE keyword index to choose plotting linestyles.
By default, set to 0 and solid lines. May be a vector of the same
size as STATENAMES.
STATENAMES: The names of the states you wish to draw counties for. Normally, these
are two-element state abbreviations, but this will depend upon the entity
attributes in your shape file. If this keyword is undefined, then the counties
in all the states will be drawn. If you are unsure of the entity names, use the
Coyote Library program SHAPEINFO to browse the file ahead of time.
THICK: The line thickness. By default, 1.0.
RESTRICTIONS:
It is assumed a map projection command has been issued and is in effect at
the time this program is called.
If STATENAMES is undefined, all states are drawn, but only a single value
for COLORS, LINESTYLE, and THICK is allowed.
Required Coyote Library programs:
Error_Message
FSC_Color
EXAMPLE:
Create a map with Nevada in yellow and other state's counties in blue.
Window, XSize=500, YSize=500, Title='County Boundaries'
Map_Set, 37.5, -120, /Albers, /IsoTropic, Limit=[30, -125, 45, -108], $
Position=[0.05, 0.05, 0.95, 0.95]
Erase, COLOR=FSC_Color('ivory')
Map_Grid, LatDel = 2.0, LonDel = 2.0, /Box_Axes, Color=FSC_Color('charcoal')
colors = [Replicate('dodger blue', 6), 'indian red']
DrawCounties, , 'co1990p020.shp', Statenames=['CA', 'OR', 'WA', 'AZ', 'UT', 'ID', 'NV'], $
Colors=colors
MODIFICATION HISTORY:
Written by David W. Fanning, 24 June 2004.
(See drawcounties.pro)
NAME:
DRAWSTATES
PURPOSE:
Draws states in the USA in outline or as solid-color polygons
from a state shapefile.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
DrawStates, stateFile
ARGUMENTS:
stateFile: The name of the input shapefile containing state boundaries.
If undefined, the "states.shp" file in the IDL distribution is used.
KEYWORDS:
ATTRIBUTE_NAME: The name of the attribute in the file that you wish to draw.
By default, this is set to the attribute name "STATE_ABBR".
(In some shapefiles, the attribute might be named "STATE".)
If you are unsure of the attribute names in your shapefile,
use the Coyote Library program SHAPEINFO to browse the file
ahead of time.
COLORS: The name of a color to draw the state outline or polygon in. This
may be a string array of the same size as STATENAMES. Color names
correspond to the colors available in FSC_COLOR. By default, "Sky Blue".
FILL: Normally, the state outline is drawn. If this keyword is set,
the polygon representing the state is filled with a solid color.
May be a vector of the same size as STATENAMES.
LINESTYLE: The normal LINESTYLE keyword index to choose plotting linestyles.
By default, set to 0 and solid lines. May be a vector of the same
size as STATENAMES.
STATENAMES: The names of the states you wish to draw. Normally, these are two-element
state abbreviations, but this will depend upon the entity attributes in your
shapefile. If this keyword is undefined, then all the states in the
file will be drawn. If you are unsure of the entity names, use the
Coyote Library program SHAPEINFO to browse the file ahead of time.
THICK: The line thickness. By default, 1.0.
RESTRICTIONS:
It is assumed a map projection command has been issued and is in effect at
the time this program is called.
If STATENAMES is undefined, all states are drawn, but only a single value
for COLORS, FILL, LINESTYLE, and THICK is allowed.
Required Coyote Library programs:
Error_Message
FSC_Color
EXAMPLE:
Window, XSize=700, YSize=800
Map_Set, 37.5, -117.5, /Albers, /IsoTropic, Limit=[30, -125, 45, -108], Position=[0.05, 0.05, 0.95, 0.95]
Erase, Color=FSC_Color('ivory')
DrawStates, Statenames=['CA', 'OR', 'WA', 'AZ', 'UT', 'ID'], Thick=1, $
Colors=['firebrick', 'indian red', 'indian red', 'indian red', 'steel blue', 'indian red'], $
Fill = [1,0,0,0,1,0]
Map_Grid, LatDel = 2.0, LonDel = 2.0, /Box_Axes, Color=FSC_Color('charcoal')
MODIFICATION HISTORY:
Written by David W. Fanning, 2 April 2005.
(See drawstates.pro)
NAME:
ERROR_MESSAGE
PURPOSE:
The purpose of this function is to have a device-independent
error messaging function. The error message is reported
to the user by using DIALOG_MESSAGE if widgets are
supported and MESSAGE otherwise.
In general, the ERROR_MESSAGE function is not called directly.
Rather, it is used in a CATCH error handler. Errors are thrown
to ERROR_MESSAGE with the MESSAGE command. A typical CATCH error
handler is shown below.
Catch, theError
IF theError NE 0 THEN BEGIN
Catch, /Cancel
ok = Error_Message()
RETURN
ENDIF
Error messages would get into the ERROR_MESSAGE function by
throwing an error with the MESSAGE command, like this:
IF test NE 1 THEN Message, 'The test failed.'
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com/
CATEGORY:
Utility.
CALLING SEQUENCE:
ok = Error_Message(the_Error_Message)
INPUTS:
the_Error_Message: This is a string argument containing the error
message you want reported. If undefined, this variable is set
to the string in the !Error_State.Msg system variable.
KEYWORDS:
ERROR: Set this keyword to cause Dialog_Message to use the ERROR
reporting dialog. Note that a bug in IDL causes the ERROR dialog
to be used whether this keyword is set to 0 or 1!
INFORMATIONAL: Set this keyword to cause Dialog_Message to use the
INFORMATION dialog instead of the WARNING dialog. Note that a bug
in IDL causes the ERROR dialog to be used if this keyword is set to 0!
TITLE: Set this keyword to the title of the DIALOG_MESSAGE window. By
default the keyword is set to 'System Error' unless !ERROR_STATE.NAME
equals "IDL_M_USER_ERR", in which case it is set to "Trapped Error'.
TRACEBACK: Setting this keyword results in an error traceback
being printed to standard output with the PRINT command. Set to
1 (ON) by default. Use TRACEBACK=0 to turn this functionality off.
OUTPUTS:
Currently the only output from the function is the string "OK".
RESTRICTIONS:
The WARNING Dialog_Message dialog is used by default.
EXAMPLE:
To handle an undefined variable error:
IF N_Elements(variable) EQ 0 THEN $
ok = Error_Message('Variable is undefined')
MODIFICATION HISTORY:
Written by: David W. Fanning, 27 April 1999.
Added the calling routine's name in the message and NoName keyword. 31 Jan 2000. DWF.
Added _Extra keyword. 10 February 2000. DWF.
Forgot to add _Extra everywhere. Fixed for MAIN errors. 8 AUG 2000. DWF.
Adding call routine's name to Traceback Report. 8 AUG 2000. DWF.
Added ERROR, INFORMATIONAL, and TITLE keywords. 19 SEP 2002. DWF.
Removed the requirement that you use the NONAME keyword with the MESSAGE
command when generating user-trapped errors. 19 SEP 2002. DWF.
Added distinctions between trapped errors (errors generated with the
MESSAGE command) and IDL system errors. Note that if you call ERROR_MESSAGE
directly, then the state of the !ERROR_STATE.NAME variable is set
to the *last* error generated. It is better to access ERROR_MESSAGE
indirectly in a Catch error handler from the MESSAGE command. 19 SEP 2002. DWF.
Change on 19 SEP 2002 to eliminate NONAME requirement did not apply to object methods.
Fixed program to also handle messages from object methods. 30 JULY 2003. DWF.
Removed obsolete STR_SEP and replaced with STRSPLIT. 27 Oct 2004. DWF.
Made a traceback the default case without setting TRACEBACK keyword. 19 Nov 2004. DWF.
Added check for window connection specifically for CRON jobs. 6 May 2008. DWF.
(See error_message.pro)
NAME:
FIND_BOUNDARY
PURPOSE:
This program finds the boundary points about a region of interest (ROI)
represented by pixel indices. It uses a "chain-code" algorithm for finding
the boundary pixels.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Graphics, math.
CALLING SEQUENCE:
boundaryPts = Find_Boundary(indices, XSize=xsize, YSize=ysize)
OPTIONAL INPUTS:
indices - A 1D vector of pixel indices that describe the ROI. For example,
the indices may be returned as a result of the WHERE function.
OUTPUTS:
boundaryPts - A 2-by-n points array of the X and Y points that describe the
boundary. The points are scaled if the SCALE keyword is used.
INPUT KEYWORDS:
SCALE - A one-element or two-element array of the pixel scale factors, [xscale, yscale],
used to calculate the perimeter length or area of the ROI. The SCALE keyword is
NOT applied to the boundary points. By default, SCALE=[1,1].
XSIZE - The X size of the window or array from which the ROI indices are taken.
Set to !D.X_Size by default.
YSIZE - The Y size of the window or array from which the ROI indices are taken.
Set to !D.Y_Size by default.
OUTPUT KEYWORDS:
AREA - A named variable that contains the pixel area represented by the input pixel indices,
scaled by the SCALE factors.
CENTER - A named variable that contains a two-element array containing the center point or
centroid of the ROI. The centroid is the position in the ROI that the ROI would
balance on if all the index pixels were equally weighted. The output is a two-element
floating-point array in device coordinate system, unless the SCALE keyword is used,
in which case the values will be in the scaled coordinate system.
PERIM_AREA - A named variable that contains the (scaled) area represented by the perimeter
points, as indicated by John Russ in _The Image Processing Handbook, 2nd Edition_ on
page 490. This is the same "perimeter" that is returned by IDLanROI in its
ComputeGeometry method, for example. In general, the perimeter area will be
smaller than the pixel area.
PERIMETER - A named variable that will contain the perimeter length of the boundary
upon returning from the function, scaled by the SCALE factors.
EXAMPLE:
LoadCT, 0, /Silent
image = BytArr(400, 300)+125
image[125:175, 180:245] = 255B
indices = Where(image EQ 255)
Window, XSize=400, YSize=300
TV, image
PLOTS, Find_Boundary(indices, XSize=400, YSize=300, Perimeter=length), $
/Device, Color=FSC_Color('red')
Print, length
230.0
DEPENDENCIES:
Requires ERROR_MESSAGE from the Coyote Library.
http://www.dfanning.com/programs/error_message.pro
MODIFICATION HISTORY:
Written by David W. Fanning, April 2002. Based on an algorithm written by Guy
Blanchard and provided by Richard Adams.
Fixed a problem with distinction between solitary points and
isolated points (a single point connected on a diagonal to
the rest of the mask) in which the program can't get back to
the starting pixel. 2 Nov 2002. DWF
Added the ability to return the perimeter length with PERIMETER and
SCALE keywords. 2 Nov 2002. DWF.
Added AREA keyword to return area enclosed by boundary. 2 Nov 2002. DWF.
Fixed a problem with POLYFILLV under-reporting the area by removing
POLYFILLV and using a pixel counting method. 10 Dec 2002. DWF.
Added the PERIM_AREA and CENTER keywords. 15 December 2002. DWF.
Replaced the ERROR_MESSAGE routine with the latest version. 15 December 2002. DWF.
Fixed a problem in which XSIZE and YSIZE have to be specified as integers to work. 6 March 2006. DWF.
(See find_boundary.pro)
NAME:
Fit_Ellipse
PURPOSE:
This program fits an ellipse to an ROI given by a vector of ROI indices.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Graphics, math.
CALLING SEQUENCE:
ellipsePts = Fit_Ellipse(indices)
OPTIONAL INPUTS:
indices - A 1D vector of pixel indices that describe the ROI. For example,
the indices may be returned as a result of the WHERE function.
OUTPUTS:
ellipsePts - A 2-by-npoints array of the X and Y points that describe the
fitted ellipse. The points are in the device coodinate system.
INPUT KEYWORDS:
NPOINTS - The number of points in the fitted ellipse. Set to 120 by default.
SCALE - A two-element array that gives the scaling parameters for each X and Y pixel, respectively.
Set to [1.0,1.0] by default.
XSIZE - The X size of the window or array from which the ROI indices are taken.
Set to !D.X_Size by default.
YSIZE - The Y size of the window or array from which the ROI indices are taken.
Set to !D.Y_Size by default.
OUTPUT KEYWORDS:
CENTER -- Set to a named variable that contains the X and Y location of the center
of the fitted ellipse in device coordinates.
ORIENTATION - Set to a named variable that contains the orientation of the major
axis of the fitted ellipse. The direction is calculated in degrees
counter-clockwise from the X axis.
AXES - A two element array that contains the length of the major and minor
axes of the fitted ellipse, respectively.
SEMIAXES - A two element array that contains the length of the semi-major and semi-minor
axes of the fitted ellipse, respectively. (This is simple AXES/2.)
EXAMPLE:
LoadCT, 0, /Silent
image = BytArr(400, 300)+125
image[125:175, 180:245] = 255B
indices = Where(image EQ 255)
Window, XSize=400, YSize=300
TV, image
PLOTS, Fit_Ellipse(indices, XSize=400, YSize=300), /Device, Color=FSC_Color('red')
MODIFICATION HISTORY:
Written by David W. Fanning, April 2002. Based on algorithms provided by Craig Markwardt
and Wayne Landsman in his TVEllipse program.
Added SCALE keyword and modified the algorithm to use memory more efficiently.
I no longer have to make huge arrays. The arrays are only as big as the blob
being fitted. 17 AUG 2008. DWF.
(See fit_ellipse.pro)
NAME:
FLOATS_EQUAL
PURPOSE:
The purpose of this function is to compare to floating-point values or
arrays to determine if the values or arrays are equal. Arrays are equal
if they have the same number of elements, and each element is equal.
AUTHOR:
FANNING SOFTWARE CONSULTING
David Fanning, Ph.D.
1645 Sheely Drive
Fort Collins, CO 80526 USA
Phone: 970-221-0438
E-mail: davidf@dfanning.com
Coyote's Guide to IDL Programming: http://www.dfanning.com
CATEGORY:
Utilities
CALLING SEQUENCE:
result = FLOATS_EQUAL(array_1, array_2)
ARGUMENTS:
array_1 Any single or double precision value or array. Required parameter.
array_2 Any single or double precision value or array. Required parameter.
KEYWORDS:
ULP UNIT in the LAST PLACE. It is the gap or difference between two
floating point numbers in the last digit that can distinguish the
two numbers. Must be a positive integer. Set to 1 by default. Set
to a larger value if you suspect accumulative round-off errors