{"id":644,"date":"2025-04-12T12:00:08","date_gmt":"2025-04-12T19:00:08","guid":{"rendered":"https:\/\/www.ferzkopp.net\/wordpress\/?p=644"},"modified":"2025-04-12T14:24:21","modified_gmt":"2025-04-12T21:24:21","slug":"estimating-tree-age-with-image-analysis-and-stats","status":"publish","type":"post","link":"https:\/\/www.ferzkopp.net\/wordpress\/2025\/04\/12\/estimating-tree-age-with-image-analysis-and-stats\/","title":{"rendered":"Tree Age from Image Analysis and Statistics"},"content":{"rendered":"\n\n\n
\n
Can one use an image of tree rings to estimate its age by analyzing circular patterns and brightness variations? Let’s pull up Python and find out …<\/div>\n
 <\/div>\n<\/div>\n

<\/p>\n\n\n\n

I found a nice snapshot of a cut tree that I took during a winter forest walk in my picture archive, and had the idea to automate the process of counting the tree rings in order to estimate the age of the tree when it was harvested.<\/p>\n

\"\"<\/a><\/p>\n

Using VS Code, GitHub Copilot and some time to tinker and experiment, I wrote the some code to perform this analysis. The resulting Python program applies image processing techniques, detects circular features, and performs statistical analysis on the detected markers for such an estimation. It is by no means perfect – specifically finding the center of the rings proved challenging and error prone. The resulting estimates are, well, approximate.<\/p>\n

The source code, input and process images, and additional samples to process can be downloaded here:<\/p>\n

https:\/\/github.com\/ferzkopp\/TreeRingAnalysis<\/a><\/p>\n\n\n\n

The program uses the following workflow:<\/p>\n

\n
    1. Load and preprocess the image (e.g., Gaussian blur, HSV conversion).<\/div>\n
    2. Perform color analysis and binarize the image based on percentile brightness thresholds.<\/div>\n
    3. Detect the center of circular features using gradient decent optimization.<\/div>\n
    4. Analyze pixel brightness along many radial lines from the detected center.<\/div>\n
    5. Apply frequency filtering and detect peaks\/troughs in the series of brightness values along the rays.<\/div>\n
    6. Visualize and save results, including marker overlays and statistical plots.<\/div>\n
    7. Estimate the tree’s age based on statistical metrics of the set of detected peaks\/troughs.<\/div>\n<\/div>\n\n\n\n

Let’s walk through each step.<\/em><\/p>\n\n\n\n

Since the source images may be small, the first step is an optional scaling<\/strong> operation to make sure it has  at least 3000 pixels in width. <\/code><\/p>\n

\n
if image.shape[1] < 3000:<\/code><\/div>\n
    scale_factor = 3000 \/ image.shape[1]<\/code><\/div>\n
    new_width = 3000<\/code><\/div>\n
    new_height = int(image.shape[0] * scale_factor)<\/code><\/div>\n
  image = cv2.resize(image, (new_width, new_height), interpolation=cv2.INTER_CUBIC)<\/code><\/div>\n<\/div>\n

and to remove the noise some blurring is applied<\/p>\n

\n
blurred_image = image.copy()<\/code><\/div>\n
blurred_image = cv2.GaussianBlur(blurred_image, (7, 7), 0)<\/code><\/div>\n
blurred_image = cv2.GaussianBlur(blurred_image, (5, 5), 0)<\/code><\/div>\n
blurred_image = cv2.GaussianBlur(blurred_image, (3, 3), 0)<\/code><\/div>\n<\/div>\n
 <\/div>\n
This image is then used for two processes: (a) finding an approximate center of the rings, and (b) analyzing the rings using rays emanating from this center.<\/div>\n\n\n\n

Finding the center of the concentric rings – a task that is easy for a human looking at the image of a tree – is surprisingly difficult for an algorithm due to the nature of the image with noise, low contrast, vertical variations, and other inconsistencies. I tried initially several algorithms suggested by a quick Copilot query such as Hough Transform, Radial Symmetry Transform and Template Matching before settling on a gradient decent search<\/strong> using a cost function that is designed to find the center of concentric structures (like tree rings) based on edge data in the image.<\/p>\n

\n
# Cost function to evaluate the center<\/code><\/div>\n
def cost_function(center, edges):<\/code><\/div>\n
    x_center, y_center = center<\/code><\/div>\n
    y_indices, x_indices = np.where(edges > 0)  # Get edge points<\/code><\/div>\n
    radii = np.sqrt((x_indices - x_center)**2 + (y_indices - y_center)**2)<\/code><\/div>\n
    mean_radius = np.mean(radii)<\/code><\/div>\n
    cost = np.sum((radii - mean_radius)**2)  # Minimize the deviation from the mean radius<\/code><\/div>\n
    return cost<\/code><\/div>\n
\n
# Gradient descent to find the best center<\/code><\/div>\n
def find_best_center(edges, initial_center):<\/code><\/div>\n
    result = minimize(<\/code><\/div>\n
        cost_function,<\/code><\/div>\n
        initial_center,<\/code><\/div>\n
        args=(edges,),<\/code><\/div>\n
        method='Powell'<\/code><\/div>\n
    )<\/code><\/div>\n
    return result.x<\/code><\/div>\n

The input to this step is a “binarized” image that shows the rings around the center as bright pixels. The following processing was performed to create such a black and white image:<\/div>\n