D_B=limε→0[log N_ε⁄log ε]
where the limit is found as the slope of the regression line

• mean D_B
• slope-corrected D_B
• most efficient covering D_B
• mass dimension using overlapping grid samples
• subarea D_Bs
• D_LC local connected fractal dimension
• Multifractal Analysis
• Grayscale D_Bs

See an example of a 32-segment quadric fractal highlighting the basic self-similar nature of a fractal here.

D_F = log N _ε/log ε
where N=the number of new parts and ε is the scale

D = limε→0 [log N_ε⁄log ε]

• limε→0 is found as the slope of the regression line
• g is grid orientation; ε is scale; σ is the standard deviation and μ the mean for pixels per box at some ε
• λ=(σ/μ)²

Options for Grayscale Scans

1. Differential
2. Differential Volume Variation
3. Differential Volume Variation Plus 1

Types of Fractal Dimension Reported for Grayscale Images

• D_B
• D_M
• D_x̄

All Grayscale Pixels are Meaningful

Indeed, if we analyzed grayscale images in the same way as binary, we would soon grow very, very bored with the results. The program would invariably tally every box it ever laid on a grayscale image, because all grayscale pixels, therefore all the pixels in every box, are meaningful. The mass approach would be as boring, because the program would invariably record that every box is full, learning nothing about the relative fullness of each. On the whole, since every count at any box size or scale (ε) would just give the number of boxes that fit across the entire image, and tell us that each box was filled, the single result of any log-log examination would always be the noble and beautiful but rather uninteresting and inaccurate integer dimensions.

Fortunately, FracLac does grayscale scans differently from binary, to find the meaning of the meaningful pixels. The data gathering box counting algorithms are the same, but the measuring mechanisms are not. It assumes grayscale images exist in a pseudo-3d space, where a pixel is not always either on or off but somewhere along a scale of on-ness and off-ness, that the world of computer graphics divides discretely from 0 (black) to 255 (white). This quantifiability can be thought of as a way to measure texture if we think in 3d and let the gray value (intensity) be a proxy for volume. Visualize this by picturing the screen as a 2d grid with i rows and j columns, and each pixel at i,j rising up as a little prism, or mountain, or spheroid, or mushroom cloud, or whatever you would like to use for your landscape, to the relative height defined by the intensity.

Intensity Differences

To picture how FracLac does this, consider the image you surely made in your head when you read the previous paragraph about the texture of each pixel. Now, revisualize that scene, examining the image using, instead of individual pixels, boxes. Using boxes, you see one pillar or mushroom cloud rising not from each pixel, but from each box; change your scale of enquiry, your grid calibre, and you get, for each identically sized box in your new grid, a new shape rising up from the base of each box. Keep changing the grid size, and you keep getting one shape rising from every box, but the volume is changing. If you look at it with boxes the size of the image, you see but one large pillar or whatever shape you chose.

This gives us a way to find a fractal dimension (D) from a grayscale image. To help you understand that, let me give a quick summary: a box counting fractal dimension is a scaling rule that was inferred from the relationship between the number of parts (N) we count in some pattern and the relative size (f) of the measurer we use to count them. (f would be 1/3 if we multiplied the original pattern's size by 1/3 to get the measuring size). Read about it in the links later, but for now, know that the rule is N = f^-D, and we solve for D using logs: -D = log N/log f. There is also a mass-related box-counting D, which relates N to the contents of the parts we measure, such as the sum or average of a feature measured at each box. And that is what happens with grayscale images and I. So, for purposes of knowing what we are talking about, here is how FracLac would identify the thing it would count and measure, the shape rising from a box, for some I at a box size ε and location i,j:

δI_i,j,ε = Maximum Pixel Intensity_(i,j,ε) − Minimum Pixel Intensity_(i,j,ε)
(Eq. 1) I_i,j,ε = δI_i,j,ε
(Eq. 2) I_i,j,ε = 1 + δI_i,j,ε

Gray Fractal Dimension Types

• D_B, from the log-log regression line of the sum of all I_i,j,ε vs ε
• D_M, from the log-log regression line of the mean of all I_i,j,ε vs ε
• D_x̄, from an average cover over all grids then calculated as for D_B

User Options for Grayscale Scans

Option 1: Differential

Option 2: Differential Volume Variation

From this estimate of volume, FracLac calculates the log-log slope of V_εagainst ε, then uses a method based on the semi-variogram method (Mark and Aronson; Mandelbrot; Sarkur and Charduri), to calculate the fractal dimension. Basically, the method assumes that the slope is equivalent to twice something called the Hausdorff-Besicovitch dimension, and that D can be calculated as below: V_ε= ∑I_i,j,εε²
S = limε→0(ln V_ε/ln 1/ε) = slope of the regression line
D_Bgray = 3 - (S/2)

Option 3: Differential Volume Variation Plus 1

sliding grid scan and Setting sliding box lacunarity options.

A_g=1/(e^{y intercept_g})

A = [G∑g=1A_g]⁄G

PΛ=G∑g=1[[{A_g/A}-1]²]/G

This value is reported in the results table as the mean y-intercept lacunarity for box counts and for pixel masses. The mean y-intercept is also recorded in the results table.

1. setting up an image and making some preliminary measurements (e.g., the convex hull),
2. applying a sampling element (grids, boxes, ovals) to the prepared image and counting,
3. calculating various parameters,
4. displaying or saving the results.

D_B=Grids∑G=1D_B(G)×Grids^-1

1. Smoothed D_B(biggest): a filter that shrinks the series by starting at the smallest box size and keeping only counts greater than the successor going from smallest to largest size. This filter obscures scaling and tends to bring the D closer to 1 when relatively large box sizes are used, but the effect depends on the image and the series of box sizes used.
2. Smoothed D_B(small): a filter that shrinks the series by starting at the largest size and keeping only counts smaller than the successor, which assumes that increases in count with increases in size should be ignored and that the smallest possible box for a given count holds density most efficiently. Thus, the smoothed D_B(small), in essence, can be used to correct for box sizes that are too large (see discussion of limits in box counting options)

• big D_Bs
• small D_Bs
• number of box sizes for big and small

D(Q=0) ≥ D(Q=1) ≥ D(Q=2)

1. Type a number > 0 for Number of Bins in the options panel for the scan you are doing
2. Select whether or not to generate a file showing the probability distribution data by selecting Print Mass vs Frequency Distributions

m=((B×B∑ b=1 LnS_b×LnC_b)−(B∑ b=1 LnS_b×B∑ b=1 LnC_b))
÷
((B×B∑b=1 LnS²)−B∑ b=1 LnS_b×B∑ b=1 LnS_b))

Prefactor lacunarity

Hover over the image of a diffusion limited aggregate to switch between blue & purple binary and black & white binary. But know that you would have to convert your image to black and white binary (e.g., using ImageJ's threshold function) to process it with FracLac.