FracLac 2.5p is a plugin for ImageJ that analyzes digital images for specialized measures of the box counting fractal dimension, the {@link analyzer.FLMain#doMF generalized dimension spectrum}, different types of lacunarity, and other {@link analyzer.CircStats#measureHullandCircle morphometrics}. The essential algorithm of the plugin is outlined in the javadoc for the {@link analyzer.FLMain FracLac} class and the class that loads it, {@link GUI.FL_}.

montage of biological cells created with ImageJ and analyzed with FracLac using a local dimension scan with the subarea size set to correspond to the size of images making up the montage. Colours show different fractal dimensions of each cell contour.

Use it to measure difficult to describe geometrical forms where the details of design are as important as gross morphology.

Running the Plugin

FracLac runs under ImageJ. The software is packaged as .jar file. To install it, place the current FracLac jar file in the plugins directory of ImageJ and restart ImageJ. Run FracLac through the "Plugins: Fractal Analysis" menu. Before the first scan, the user must select either a multifractal, regular box count, subscan, or sliding box lacunarity scan from the buttons on the FracLac panel. For subsequent analyses, the user can click an analysis button to reuse settings, or a setup button to change them.

Use

FracLac is suitable for analyzing images of biological cells and textures, for instance. It has been tested extensively on control images, including various quadric fractals, Koch fractals, Sierpinski and Menger fat fractals, multifractals (Henon Maps), diffusion limited aggregates, and Euclidean forms, with typically low deviations from expected and high r² values for the fractal dimension. It works on binary files (black pixels on a white background, or white pixels on a black background), so images must be thresholded prior to analysis to ensure that only the pixels of interest are assessed. It also works on grayscale images (2006).

Inputs:

• Open images, rois on open images, or single or multiple unopened image files
• binary images, generally, as single pixel wide outlines or textures
• grayscale images (e.g., of biological tissue, soil, etc.)
• user inputs for operating parameters

Outputs:

• Summarized data, data analysis, and raw data text files (saveable ImageJ results windows)
• Saveable graphics showing colour-coded local fractal dimensions, multifractal spectra, and lacunarity graphs
• Saveable image legend
• Saveable graphics showing the grids in a scan

Needs:

• {@link ImageJ}
• Java 1.5

Help and User's Guides

History and Development

Features

Box Counting with Various Sampling Methods including local connected and local dimensions

• standard {@link analyzer.ScannerFL box counting} fractal dimensions
• graphs and {@link analyzer.FracStats#FindDfStats regression statistics}
• Average fractal dimensions and measures of {@link Utilities.Statistics#coefVar variability} over {@link analyzer.Vars#iGRIDS multiple scans}
• a {@link analyzer.FracStats#SmoothedLinearStatsSmallest smoothing correction} for the lack of prior knowledge of the scaling ratio
• a {@link fraclac.utilities.ArrayMethods#filterMin?MaxCover most efficient} covering dimension
• automatically {@link analyzer.FLMain#MakeNewBoxSizes optimized} scans of each image
• data for {@link analyzer.DataProcessor#recordRawData mass related dimensions}

Calculations: The Box Counting Fractal Dimension Measures Complexity

• DF =-lim[logN_ε/logε]
• calculated as the slope of the regression line for the log-log plot of box count on the y-axis and ε on the x
• where N_ε is the count of all the boxes that contained any pixels at a certain grid calibre, ε
• ε is nominally {@link analyzer.FLMain#BOXSIZES box size}/Length or box size/maximum image {@link analyzer.Vars#GreaterOfHtAndWd dimension}
• for mass and grayscale dimensions, instead of N_ε, mass or intensity_εis used.
• For the 2d variation for grayscale images, the fractal dimension, (D_g) is calculated from the slope of the log vs log plot of ln[(max-min)*r²] against r, where r is box size and D_g=(3-slope/2)
• ΛDF=lim[ln σ/ln ε] -(lim[ln λ/ln ε]/2)
• for local connected and local (not connected) dimensions, each pixel is analyzed according to its circular or square environment and along with data, images or text images coded according to the environment of each pixel are returned

Multifractal Spectra and Generalized Dimensions

1. FracLac delivers distributions of {@link analyzer.FLsetup#GetSubScanInputs local} dimensions over an image, including colour coding showing how the distribution of complexity changes with the scale at which it is assessed (in addition to {@link analyzer.FLMain#MultifractalDataProcessor multifractal} spectra)
2. {@link analyzer.FLMain#doMF Multifractal} spectra data and graphs: D_Q, τ, α, ƒ(α)
3. customized sampling over {@link analyzer.FLMain#SetFourCorners different orientations} and {@link analyzer.Vars#GridPositions shifted positions} as well as {@link Utilities.FLutil#SmoothedArray data smoothing} {@link Utilities.FLutil#minMassCover and minimizing}
4. pseudorandom {@link analyzer.Vars#RandomMassSample mass} sampling (for example, manipulable with respect to {@link analyzer.Vars#FACTOR pixels sampled}, and so on)

Calculations for multifractal data

• D_Q=lim[lnI_Q,ε/lnε^-1]/(1-Q)
• I_Q,ε=∑[P_i^Q],
• For Q=1, let ε approach 1, and D_Q=-lim[∑P_i*ln[P_i]/lnε]
• The probability distribution is found from the number of pixels, M, that were contained in each i^th element at ε required to cover an object:
  • P_i,ε = M_i,ε/∑M_ε
• Thus, P_iis from the probability distribution of mass for all boxes (i) at this ε
  where ∑P_i =1
• According to the method of Chhabra and Jensen (Phys. Rev . Lett. 62: 1327, 1989):
  • μ_i=P_i^Q/∑ P_i^Q
  • α = ∑[μ*lnP_i]/lnε
  • ƒ(α_Q)=∑[μ_i*lnμ _i]/lnε
  • τ_Q=(Q-1)*D_Q
  • and ƒ(α_Q)= Qα_Q-τ_Q

Lacunarity (Λ)

• FracLac returns lacunarity based on the {@link analyzer.FLData#CountPrefactorLacOverAll?s prefactor}
• lacunarity based on the coefficient of variation in {@link analyzer.FLData#MassLacAt? pixel density} and a binned {@link analyzer.DataProcessor#BinnedProbabilityLacunarity distribution}

Calculations: LACUNARITY measures heterogeneity

• Lacunarity=Λ=slope[ln λ/ln ε]*or ∑ λ/N_λ where λ=1+(σ/μ)²

1. Λ_{all grid positions} = ∑λ/N_λ
2. λ_{grid position}=∑λ_ε /N_λε
3. Slope Λ=-lim[ln λ_ε/ln ε] found as the slope of the {@link analyzer.FracStats#PowerRegression log-log regression line}
4. λ_ε = 1+(σ/μ)², where σ = the standard deviation of the pixel distribution at ε, and μ = the mean
5. Fλ & FΛ = calculated using foreground pixels only
6. Eλ & EΛ = calculated using all image pixels
7. BPDλ & BPDΛ = calculated using a {@link analyzer.DataProcessor#BinnedProbabilityLacunarity binned probability distribution}
8. All of the above are based on different sampling:
   • {@link analyzer.FLMain#Scan nonoverlapping} scanning in regular box counting
   • overlapping and potentially exhaustive sampling in {@link analyzer.FLMain#GetSLACData sliding box scans}

Other Morphometrics

• FracLac calculates the span ratio, the vertical ({@link analyzer.Vars#MaxOverMinRadii bottom} and {@link analyzer.Vars#MaxRadius top}) and the horizontal ( {@link analyzer.Vars#CVRadii left} and {@link analyzer.Vars#MeanRadii right}) axes, and the perimeter and area of the {@link analyzer.CircStats#measureHullandCircle convex hull} enclosing the image. It also delivers the minimum bounding circle and a measure of {@link analyzer.Vars#circularity} based on the convex hull.

Working Structure:

• The plugin runs from a {@link GUI.FL_#ShowPanelOfButtons panel}
  1. One settings button on the panel sets up {@link analyzer.FLsetup#getBCInputs box counts}, another {@link analyzer.FLsetup#GetSubScanInputs subscans}, another {@link analyzer.FLsetup#getMFInputs multifractal} scans, and another {@link analyzer.FLsetup#getSLacInputs sliding box lacunarity scans}.
  2. The action buttons get the {@link GUI.FL_#DoActiveImageListener current image or ROI} or {@link GUI.FL_#DoRois ROI Manager} or {@link GUI.FL_#OpenAndScanFilesWithoutShowingThem select files} to open then {@link GUI.FL_#DoActiveImage analyze} the image.

Types of Scans

Images

Stacks and ROIs

• FracLac scans as many slices as an image has, and can scan rois (user set or from the ROI Manager) or entire images. ROIs are repeated through all slices of a stack. The actual type of image to scan is set by the user.

Binary Images

• In a binary scan, only black or else white pixels, whichever are less numerous or else whichever the user specifies, are counted. Boxes containing pixels and the mass (number of pixels) per box are recorded for each box at each ε for each {@link analyzer.Vars#GridPositions location}.

Threshholded Images

• FracLac converts images to binary by calling ImageJ's thresholding method if the option to automatically threshold is selected.

Grayscale Images

• In a grayscale scan, the difference between the maximum and minimum gray values is recorded for each box at each ε for each location. Grayscale images are converted to rgb, padded with a filler colour, then reconverted to grayscale for analysis.

Nonoverlapping vs Overlapping

1. Scans are non-overlapping if no boxes within a series of εs overlap; that is, they are laid as a contiguous square grid.
2. In overlapping scans, each box of size ε is slid by {@link analyzer.Vars#SLIDEX} horizontally and {@link analyzer.Vars#SLIDEY} vertically until the entire image is covered at a box size. Thus, samples within one scan of this type can overlap, as opposed to fixed grid scans that cannot.

Non-Overlapping or Fixed-Grid Scan, 1 origin

• The most basic scan uses one series of εs at one location, where one grid of each calibre in the series is always positioned starting at the top left corner of the image.

Non-Overlapping, Multiple Origins Scan

• The same series of εs is applied from multiple starting locations, with each smaller size within a series always starting at the same position, in a non-overlapping scan. The grid positions are randomly chosen, usually from between the top left corner and the edge of the screen (a border is added to images to ensure there is space to do this). For block scans, the origins are chosen from within the image's borders.

Multifractal Scan

• The first four grids in a multifractal scan are oriented so that the last box at each size of each scan falls at the four corners of the image, similar to rotating by 90° each time. Scans after these are randomly chosen based on the top left corner. This is a non-overlapping scan.

Overlapping Sliding Lacunarity Scan

• If SLIDEX and SLIDEY are 1, a sliding box lacunarity scan is exhaustive. This scan can be modified to stay within the image's borders or extend past them.

Subarea Scan

• A subarea scan does several fixed grid (non-overlapping) scans over an image. If the subareas option is selected, FracLac calculates a distribution of these local fractal dimensions over smaller subareas of the image then delivers a colour-coded graphic as well as text values of these local dimensions. The option to open multiple files is not allowed in this mode.

Related Documentation

• Current FracLac plugin and User's Guide.
• {@link FracLac page}
• ImageJ Documentation and User's Guide.
• For a java progamming language overview, see programming language documentation.
• For further information or to send comments, bugs, and feature requests contact {@link the author}

IDE: NetBeans IDE 5.5