Add webapp files

SingleTreePointCloudLoader.py

@@ -0,0 +1,50 @@
+import laspy
+import torch
+import numpy as np
+import open3d as o3d
+from torch.utils.data import Dataset
+
+def random_sample(point, npoint):
+    if len(point) > npoint:
+        sampled_indices = np.random.choice(len(point), npoint, replace=False)
+        point = point[sampled_indices]
+    else:
+        padding = np.zeros((npoint - len(point), 3))
+        point = np.vstack((point, padding))
+    return point
+
+
+class SingleTreePointCloudLoader(Dataset):
+    def __init__(self, file, file_type, npoints=2048):
+        self.file = file
+        self.npoints = npoints
+        self.list_of_points = []
+        self.list_of_labels = []
+        
+        if file_type == 'pcd':
+            pcd = o3d.io.read_point_cloud(self.file)
+            point = np.asarray(pcd.points)
+        else:
+            las_file = laspy.read(self.file)
+            point = np.vstack((las_file.x, las_file.y, las_file.z)).transpose()
+            
+        point_set = random_sample(point, self.npoints)
+        point_set = torch.tensor(point_set, dtype=torch.float32)
+        self.list_of_points.append(point_set)
+        self.list_of_labels.append(np.array([-1]).astype(np.int32))
+        
+    def __len__(self):
+        return 1
+    
+    def __getitem__(self, index):
+        point_set, label = self.list_of_points[index], self.list_of_labels[index]
+        return point_set, label[0]
+
+
+if __name__ == '__main__':
+    dataset = SingleTreePointCloudLoader(file='E:/Important PDFs/Wildlife Institute of India/PointNet ML/Pointnet_Pointnet2_pytorch-master/data/tree_species')
+    dataloader = torch.utils.data.DataLoader(dataset, batch_size=8, shuffle=True, num_workers=0)
+
+    for point, label in dataloader:
+        print(point.shape)
+        print(label.shape)

app.py

@@ -0,0 +1,148 @@
+import gc
+import laspy
+import torch
+import tempfile
+import numpy as np
+import open3d as o3d
+import streamlit as st
+import plotly.graph_objs as go
+
+import pointnet2_cls_msg as pn2
+from utils import calculate_dbh, calc_canopy_volume, CLASSES
+from SingleTreePointCloudLoader import SingleTreePointCloudLoader
+gc.enable()
+
+with st.spinner("Loading PointNet++ model..."):
+    checkpoint = torch.load('checkpoints/best_model.pth', map_location=torch.device('cuda'))
+    classifier = pn2.get_model(num_class=4, normal_channel=False)
+    classifier.load_state_dict(checkpoint['model_state_dict'])
+    classifier.eval()
+
+st.title("Tree Species Identification")
+
+uploaded_file = st.file_uploader(
+    label="Upload Point Cloud Data", 
+    type=['laz', 'las', 'pcd'], 
+    help="Please upload trees with ground points removed"
+)
+Z_THRESHOLD = st.slider(
+    label="Z-Threshold(%)", 
+    min_value=5, 
+    max_value=100, 
+    value=50, 
+    step=1, 
+    help="Please select a Z-Threshold for canopy volume calculation"
+)
+DBH_HEIGHT = st.slider(
+    label="DBH Height(m)", 
+    min_value=1.3,
+    max_value=1.4,
+    value=1.4,
+    step=0.01,
+    help="Enter height used for DBH calculation"
+)
+proceed = None
+
+if uploaded_file:
+    try:
+        with st.spinner("Reading point cloud file..."):
+            file_type = uploaded_file.name.split('.')[-1].lower()
+            with tempfile.NamedTemporaryFile(delete=False, suffix=f".{uploaded_file.name.split('.')[-1]}") as tmp:
+                tmp.write(uploaded_file.read())
+                temp_file_path = tmp.name
+            
+            if file_type == 'pcd':
+                pcd = o3d.io.read_point_cloud(temp_file_path)
+                points = np.asarray(pcd.points)
+            else:
+                point_cloud = laspy.read(temp_file_path)
+                points = np.vstack((point_cloud.x, point_cloud.y, point_cloud.z)).transpose()
+                
+        proceed = st.button("Run model")
+    except Exception as e:
+        st.error(f"An error occured: {str(e)}")
+
+if proceed:
+    try:
+        with st.spinner("Calculating tree inventory..."):
+            dbh, trunk_points = calculate_dbh(points, DBH_HEIGHT)
+            
+            z_min = np.min(points[:, 2])
+            z_max = np.max(points[:, 2])
+            height = z_max - z_min
+            
+            canopy_volume, canopy_points = calc_canopy_volume(points, Z_THRESHOLD, height, z_min)
+                
+        with st.spinner("Visualizing point cloud..."):
+            fig = go.Figure()
+            fig.add_trace(go.Scatter3d(
+                x=points[:, 0],
+                y=points[:, 1],
+                z=points[:, 2],
+                mode='markers',
+                marker=dict(
+                    size=0.5,
+                    color=points[:, 2], 
+                    colorscale='Viridis', 
+                    opacity=1.0, 
+                ),
+                name='Tree'
+            ))
+            fig.add_trace(go.Scatter3d(
+                x=canopy_points[:, 0], 
+                y=canopy_points[:, 1], 
+                z=canopy_points[:, 2], 
+                mode='markers', 
+                marker=dict(
+                    size=2, 
+                    color='blue', 
+                    opacity=0.8, 
+                ),
+                name='Canopy points'
+            ))
+            fig.add_trace(go.Scatter3d(
+                x=trunk_points[:, 0], 
+                y=trunk_points[:, 1], 
+                z=trunk_points[:, 2], 
+                mode='markers', 
+                marker=dict(
+                    size=2, 
+                    color='red', 
+                    opacity=0.9, 
+                ),
+                name='DBH'
+            ))
+            fig.update_layout(
+                margin=dict(l=0, r=0, b=0, t=0),
+                scene=dict(
+                    xaxis_title="X",
+                    yaxis_title="Y",
+                    zaxis_title="Z",
+                    aspectmode='data'
+                )
+            )
+            st.plotly_chart(fig, use_container_width=True)
+            
+            
+        with st.spinner("Running inference..."):
+            testFile = SingleTreePointCloudLoader(temp_file_path, file_type)
+            testFileLoader = torch.utils.data.DataLoader(testFile, batch_size=8, shuffle=False, num_workers=0)
+            point_set, _ = next(iter(testFileLoader))
+            point_set = point_set.transpose(2, 1)
+            
+            with torch.no_grad():
+                logits, _ = classifier(point_set)
+                probabilities = torch.softmax(logits, dim=-1)
+                predicted_class = torch.argmax(probabilities, dim=-1).item()
+                confidence_score = (probabilities.numpy().tolist())[0][predicted_class] * 100
+                predicted_label = CLASSES[predicted_class]
+            
+        st.write(f"**Predicted class: {predicted_label}**")
+        # st.write(f"Class Probabilities: {probabilities.numpy().tolist()}")
+        st.write(f"**Confidence score: {confidence_score:.2f}%**")
+        st.write(f"**Height of tree: {height:.2f}m**")
+        st.write(f"**Canopy volume: {canopy_volume:.2f}m\u00b3**")
+        st.write(f"**DBH: {dbh:.2f}m**")
+        
+    except Exception as e:
+        st.error(f"An error occured: {str(e)}")

checkpoints/best_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:241e6ebaa818ecd1def1406bc3fa60702e49287e11bac30d4fcd8dd4b3c40b04
+size 21010087

pointnet2_cls_msg.py

@@ -0,0 +1,49 @@
+import torch.nn as nn
+import torch.nn.functional as F
+from pointnet2_utils import PointNetSetAbstractionMsg, PointNetSetAbstraction
+
+
+class get_model(nn.Module):
+    def __init__(self,num_class,normal_channel=True):
+        super(get_model, self).__init__()
+        in_channel = 3 if normal_channel else 0
+        self.normal_channel = normal_channel
+        self.sa1 = PointNetSetAbstractionMsg(512, [0.1, 0.2, 0.4], [16, 32, 128], in_channel,[[32, 32, 64], [64, 64, 128], [64, 96, 128]])
+        self.sa2 = PointNetSetAbstractionMsg(128, [0.2, 0.4, 0.8], [32, 64, 128], 320,[[64, 64, 128], [128, 128, 256], [128, 128, 256]])
+        self.sa3 = PointNetSetAbstraction(None, None, None, 640 + 3, [256, 512, 1024], True)
+        self.fc1 = nn.Linear(1024, 512)
+        self.bn1 = nn.BatchNorm1d(512)
+        self.drop1 = nn.Dropout(0.4)
+        self.fc2 = nn.Linear(512, 256)
+        self.bn2 = nn.BatchNorm1d(256)
+        self.drop2 = nn.Dropout(0.5)
+        self.fc3 = nn.Linear(256, num_class)
+
+    def forward(self, xyz):
+        B, _, _ = xyz.shape
+        if self.normal_channel:
+            norm = xyz[:, 3:, :]
+            xyz = xyz[:, :3, :]
+        else:
+            norm = None
+        l1_xyz, l1_points = self.sa1(xyz, norm)
+        l2_xyz, l2_points = self.sa2(l1_xyz, l1_points)
+        l3_xyz, l3_points = self.sa3(l2_xyz, l2_points)
+        x = l3_points.view(B, 1024)
+        x = self.drop1(F.relu(self.bn1(self.fc1(x))))
+        x = self.drop2(F.relu(self.bn2(self.fc2(x))))
+        x = self.fc3(x)
+        x = F.log_softmax(x, -1)
+
+
+        return x,l3_points
+
+
+class get_loss(nn.Module):
+    def __init__(self):
+        super(get_loss, self).__init__()
+
+    def forward(self, pred, target, trans_feat):
+        total_loss = F.nll_loss(pred, target)
+
+        return total_loss

pointnet2_utils.py

@@ -0,0 +1,315 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from time import time
+import numpy as np
+
+def timeit(tag, t):
+    print("{}: {}s".format(tag, time() - t))
+    return time()
+
+def pc_normalize(pc):
+    l = pc.shape[0]
+    centroid = np.mean(pc, axis=0)
+    pc = pc - centroid
+    m = np.max(np.sqrt(np.sum(pc**2, axis=1)))
+    pc = pc / m
+    return pc
+
+def square_distance(src, dst):
+    """
+    Calculate Euclid distance between each two points.
+
+    src^T * dst = xn * xm + yn * ym + zn * zm；
+    sum(src^2, dim=-1) = xn*xn + yn*yn + zn*zn;
+    sum(dst^2, dim=-1) = xm*xm + ym*ym + zm*zm;
+    dist = (xn - xm)^2 + (yn - ym)^2 + (zn - zm)^2
+         = sum(src**2,dim=-1)+sum(dst**2,dim=-1)-2*src^T*dst
+
+    Input:
+        src: source points, [B, N, C]
+        dst: target points, [B, M, C]
+    Output:
+        dist: per-point square distance, [B, N, M]
+    """
+    B, N, _ = src.shape
+    _, M, _ = dst.shape
+    dist = -2 * torch.matmul(src, dst.permute(0, 2, 1))
+    dist += torch.sum(src ** 2, -1).view(B, N, 1)
+    dist += torch.sum(dst ** 2, -1).view(B, 1, M)
+    return dist
+
+
+def index_points(points, idx):
+    """
+
+    Input:
+        points: input points data, [B, N, C]
+        idx: sample index data, [B, S]
+    Return:
+        new_points:, indexed points data, [B, S, C]
+    """
+    device = points.device
+    B = points.shape[0]
+    view_shape = list(idx.shape)
+    view_shape[1:] = [1] * (len(view_shape) - 1)
+    repeat_shape = list(idx.shape)
+    repeat_shape[0] = 1
+    batch_indices = torch.arange(B, dtype=torch.long).to(device).view(view_shape).repeat(repeat_shape)
+    new_points = points[batch_indices, idx, :]
+    return new_points
+
+
+def farthest_point_sample(xyz, npoint):
+    """
+    Input:
+        xyz: pointcloud data, [B, N, 3]
+        npoint: number of samples
+    Return:
+        centroids: sampled pointcloud index, [B, npoint]
+    """
+    device = xyz.device
+    B, N, C = xyz.shape
+    centroids = torch.zeros(B, npoint, dtype=torch.long).to(device)
+    distance = torch.ones(B, N).to(device) * 1e10
+    farthest = torch.randint(0, N, (B,), dtype=torch.long).to(device)
+    batch_indices = torch.arange(B, dtype=torch.long).to(device)
+    for i in range(npoint):
+        centroids[:, i] = farthest
+        centroid = xyz[batch_indices, farthest, :].view(B, 1, 3)
+        dist = torch.sum((xyz - centroid) ** 2, -1)
+        mask = dist < distance
+        distance[mask] = dist[mask]
+        farthest = torch.max(distance, -1)[1]
+    return centroids
+
+
+def query_ball_point(radius, nsample, xyz, new_xyz):
+    """
+    Input:
+        radius: local region radius
+        nsample: max sample number in local region
+        xyz: all points, [B, N, 3]
+        new_xyz: query points, [B, S, 3]
+    Return:
+        group_idx: grouped points index, [B, S, nsample]
+    """
+    device = xyz.device
+    B, N, C = xyz.shape
+    _, S, _ = new_xyz.shape
+    group_idx = torch.arange(N, dtype=torch.long).to(device).view(1, 1, N).repeat([B, S, 1])
+    sqrdists = square_distance(new_xyz, xyz)
+    group_idx[sqrdists > radius ** 2] = N
+    group_idx = group_idx.sort(dim=-1)[0][:, :, :nsample]
+    group_first = group_idx[:, :, 0].view(B, S, 1).repeat([1, 1, nsample])
+    mask = group_idx == N
+    group_idx[mask] = group_first[mask]
+    return group_idx
+
+
+def sample_and_group(npoint, radius, nsample, xyz, points, returnfps=False):
+    """
+    Input:
+        npoint:
+        radius:
+        nsample:
+        xyz: input points position data, [B, N, 3]
+        points: input points data, [B, N, D]
+    Return:
+        new_xyz: sampled points position data, [B, npoint, nsample, 3]
+        new_points: sampled points data, [B, npoint, nsample, 3+D]
+    """
+    B, N, C = xyz.shape
+    S = npoint
+    fps_idx = farthest_point_sample(xyz, npoint) # [B, npoint, C]
+    new_xyz = index_points(xyz, fps_idx)
+    idx = query_ball_point(radius, nsample, xyz, new_xyz)
+    grouped_xyz = index_points(xyz, idx) # [B, npoint, nsample, C]
+    grouped_xyz_norm = grouped_xyz - new_xyz.view(B, S, 1, C)
+
+    if points is not None:
+        grouped_points = index_points(points, idx)
+        new_points = torch.cat([grouped_xyz_norm, grouped_points], dim=-1) # [B, npoint, nsample, C+D]
+    else:
+        new_points = grouped_xyz_norm
+    if returnfps:
+        return new_xyz, new_points, grouped_xyz, fps_idx
+    else:
+        return new_xyz, new_points
+
+
+def sample_and_group_all(xyz, points):
+    """
+    Input:
+        xyz: input points position data, [B, N, 3]
+        points: input points data, [B, N, D]
+    Return:
+        new_xyz: sampled points position data, [B, 1, 3]
+        new_points: sampled points data, [B, 1, N, 3+D]
+    """
+    device = xyz.device
+    B, N, C = xyz.shape
+    new_xyz = torch.zeros(B, 1, C).to(device)
+    grouped_xyz = xyz.view(B, 1, N, C)
+    if points is not None:
+        new_points = torch.cat([grouped_xyz, points.view(B, 1, N, -1)], dim=-1)
+    else:
+        new_points = grouped_xyz
+    return new_xyz, new_points
+
+
+class PointNetSetAbstraction(nn.Module):
+    def __init__(self, npoint, radius, nsample, in_channel, mlp, group_all):
+        super(PointNetSetAbstraction, self).__init__()
+        self.npoint = npoint
+        self.radius = radius
+        self.nsample = nsample
+        self.mlp_convs = nn.ModuleList()
+        self.mlp_bns = nn.ModuleList()
+        last_channel = in_channel
+        for out_channel in mlp:
+            self.mlp_convs.append(nn.Conv2d(last_channel, out_channel, 1))
+            self.mlp_bns.append(nn.BatchNorm2d(out_channel))
+            last_channel = out_channel
+        self.group_all = group_all
+
+    def forward(self, xyz, points):
+        """
+        Input:
+            xyz: input points position data, [B, C, N]
+            points: input points data, [B, D, N]
+        Return:
+            new_xyz: sampled points position data, [B, C, S]
+            new_points_concat: sample points feature data, [B, D', S]
+        """
+        xyz = xyz.permute(0, 2, 1)
+        if points is not None:
+            points = points.permute(0, 2, 1)
+
+        if self.group_all:
+            new_xyz, new_points = sample_and_group_all(xyz, points)
+        else:
+            new_xyz, new_points = sample_and_group(self.npoint, self.radius, self.nsample, xyz, points)
+        # new_xyz: sampled points position data, [B, npoint, C]
+        # new_points: sampled points data, [B, npoint, nsample, C+D]
+        new_points = new_points.permute(0, 3, 2, 1) # [B, C+D, nsample,npoint]
+        for i, conv in enumerate(self.mlp_convs):
+            bn = self.mlp_bns[i]
+            new_points =  F.relu(bn(conv(new_points)))
+
+        new_points = torch.max(new_points, 2)[0]
+        new_xyz = new_xyz.permute(0, 2, 1)
+        return new_xyz, new_points
+
+
+class PointNetSetAbstractionMsg(nn.Module):
+    def __init__(self, npoint, radius_list, nsample_list, in_channel, mlp_list):
+        super(PointNetSetAbstractionMsg, self).__init__()
+        self.npoint = npoint
+        self.radius_list = radius_list
+        self.nsample_list = nsample_list
+        self.conv_blocks = nn.ModuleList()
+        self.bn_blocks = nn.ModuleList()
+        for i in range(len(mlp_list)):
+            convs = nn.ModuleList()
+            bns = nn.ModuleList()
+            last_channel = in_channel + 3
+            for out_channel in mlp_list[i]:
+                convs.append(nn.Conv2d(last_channel, out_channel, 1))
+                bns.append(nn.BatchNorm2d(out_channel))
+                last_channel = out_channel
+            self.conv_blocks.append(convs)
+            self.bn_blocks.append(bns)
+
+    def forward(self, xyz, points):
+        """
+        Input:
+            xyz: input points position data, [B, C, N]
+            points: input points data, [B, D, N]
+        Return:
+            new_xyz: sampled points position data, [B, C, S]
+            new_points_concat: sample points feature data, [B, D', S]
+        """
+        xyz = xyz.permute(0, 2, 1)
+        if points is not None:
+            points = points.permute(0, 2, 1)
+
+        B, N, C = xyz.shape
+        S = self.npoint
+        new_xyz = index_points(xyz, farthest_point_sample(xyz, S))
+        new_points_list = []
+        for i, radius in enumerate(self.radius_list):
+            K = self.nsample_list[i]
+            group_idx = query_ball_point(radius, K, xyz, new_xyz)
+            grouped_xyz = index_points(xyz, group_idx)
+            grouped_xyz -= new_xyz.view(B, S, 1, C)
+            if points is not None:
+                grouped_points = index_points(points, group_idx)
+                grouped_points = torch.cat([grouped_points, grouped_xyz], dim=-1)
+            else:
+                grouped_points = grouped_xyz
+
+            grouped_points = grouped_points.permute(0, 3, 2, 1)  # [B, D, K, S]
+            for j in range(len(self.conv_blocks[i])):
+                conv = self.conv_blocks[i][j]
+                bn = self.bn_blocks[i][j]
+                grouped_points =  F.relu(bn(conv(grouped_points)))
+            new_points = torch.max(grouped_points, 2)[0]  # [B, D', S]
+            new_points_list.append(new_points)
+
+        new_xyz = new_xyz.permute(0, 2, 1)
+        new_points_concat = torch.cat(new_points_list, dim=1)
+        return new_xyz, new_points_concat
+
+
+class PointNetFeaturePropagation(nn.Module):
+    def __init__(self, in_channel, mlp):
+        super(PointNetFeaturePropagation, self).__init__()
+        self.mlp_convs = nn.ModuleList()
+        self.mlp_bns = nn.ModuleList()
+        last_channel = in_channel
+        for out_channel in mlp:
+            self.mlp_convs.append(nn.Conv1d(last_channel, out_channel, 1))
+            self.mlp_bns.append(nn.BatchNorm1d(out_channel))
+            last_channel = out_channel
+
+    def forward(self, xyz1, xyz2, points1, points2):
+        """
+        Input:
+            xyz1: input points position data, [B, C, N]
+            xyz2: sampled input points position data, [B, C, S]
+            points1: input points data, [B, D, N]
+            points2: input points data, [B, D, S]
+        Return:
+            new_points: upsampled points data, [B, D', N]
+        """
+        xyz1 = xyz1.permute(0, 2, 1)
+        xyz2 = xyz2.permute(0, 2, 1)
+
+        points2 = points2.permute(0, 2, 1)
+        B, N, C = xyz1.shape
+        _, S, _ = xyz2.shape
+
+        if S == 1:
+            interpolated_points = points2.repeat(1, N, 1)
+        else:
+            dists = square_distance(xyz1, xyz2)
+            dists, idx = dists.sort(dim=-1)
+            dists, idx = dists[:, :, :3], idx[:, :, :3]  # [B, N, 3]
+
+            dist_recip = 1.0 / (dists + 1e-8)
+            norm = torch.sum(dist_recip, dim=2, keepdim=True)
+            weight = dist_recip / norm
+            interpolated_points = torch.sum(index_points(points2, idx) * weight.view(B, N, 3, 1), dim=2)
+
+        if points1 is not None:
+            points1 = points1.permute(0, 2, 1)
+            new_points = torch.cat([points1, interpolated_points], dim=-1)
+        else:
+            new_points = interpolated_points
+
+        new_points = new_points.permute(0, 2, 1)
+        for i, conv in enumerate(self.mlp_convs):
+            bn = self.mlp_bns[i]
+            new_points = F.relu(bn(conv(new_points)))
+        return new_points

utils.py

@@ -0,0 +1,121 @@
+import numpy as np
+from sklearn.cluster import DBSCAN
+from scipy.spatial import ConvexHull
+from scipy.optimize import least_squares
+
+CLASSES = [
+    'Betula_pendula',
+    'Fagus_sylvatica', 
+    'Picea_abies',
+    'Pinus_sylvestris'
+]
+
+def fit_circle(x, y):
+    """Fit a circle to given x, y points."""
+    def calc_radius(params):
+        cx, cy, r = params
+        return np.sqrt((x - cx)**2 + (y - cy)**2) - r
+
+    # Initial guess for circle parameters: center (mean x, mean y), radius
+    x_m, y_m = np.mean(x), np.mean(y)
+    r_initial = np.mean(np.sqrt((x - x_m)**2 + (y - y_m)**2))
+    initial_params = [x_m, y_m, r_initial]
+
+    # Use least squares optimization to fit the circle
+    result = least_squares(calc_radius, initial_params)
+    cx, cy, r = result.x
+    return cx, cy, r
+    
+def remove_noise(points, eps=0.05, min_samples=10):
+    """
+    Remove noise from points using DBSCAN clustering.
+
+    Args:
+        points (numpy.ndarray): Array of shape (N, 3) with columns [x, y, z].
+        eps (float): Maximum distance between two samples to consider them as in the same neighborhood.
+        min_samples (int): Minimum number of points to form a dense region.
+    
+    Returns:
+        numpy.ndarray: Denoised points.
+    """
+    clustering = DBSCAN(eps=eps, min_samples=min_samples).fit(points)
+    labels = clustering.labels_
+    largest_cluster = labels == np.argmax(np.bincount(labels[labels >= 0]))
+    return points[largest_cluster]
+
+def calculate_dbh(points, dbh_height=1.3, height_buffer=0.1, eps=0.05, min_samples=10):
+    """
+    Calculate the Diameter at Breast Height (DBH) of a tree from point cloud data.
+
+    Args:
+        points (numpy.ndarray): Array of shape (N, 3) with columns [x, y, z].
+        dbh_height (float): Height at which DBH is measured (default is 1.3 meters).
+        height_buffer (float): Range around dbh_height to include points (default is ±0.1 meters).
+    
+    Returns:
+        float: DBH in meters.
+    """
+    z_min, z_max = dbh_height - height_buffer, dbh_height + height_buffer
+    trunk_points = points[(points[:, 2] >= (z_min)) & (points[:, 2] <= (z_max))]
+    
+    if trunk_points.shape[0] < 3:
+        raise ValueError("Not enough points to calculate DBH.")
+    
+    # Remove noise
+    denoised_points = remove_noise(trunk_points[:, :2], eps=eps, min_samples=min_samples)
+    denoised_points = np.hstack((denoised_points, np.full((denoised_points.shape[0], 1), dbh_height)))
+
+    if denoised_points.shape[0] < 3:
+        raise ValueError("Not enough points left after noise removal.")
+    
+    # Fit a circle to the trunk points
+    x, y = denoised_points[:, 0], denoised_points[:, 1]
+    cx, cy, radius = fit_circle(x, y)
+    
+    # Generate points along the fitted circle for visualization
+    theta = np.linspace(0, 2 * np.pi, 100)
+    circle_x = cx + radius * np.cos(theta)
+    circle_y = cy + radius * np.sin(theta)
+    circle_points = np.column_stack((circle_x, circle_y, np.full_like(circle_x, dbh_height)))
+    
+    # Calculate DBH (Diameter = 2 * radius)
+    dbh = 2 * radius
+    return dbh, circle_points
+
+def calc_canopy_volume(points, threshold, height, z_min):
+    '''
+    Calculates the canopy points for a given point cloud data of a tree
+    and calculates the volume using the Qhull algorithm
+    
+    Args:
+        points: point cloud data
+        threshold: z_threshold in percentage
+        height, z_min
+        
+    Returns:
+        canopy_volume, canopy_points
+    '''
+    canopy_points = points[points[:, 2] > z_min + 0.2 * height]
+    z_threshold = np.percentile(canopy_points[:, 2], threshold)
+    canopy_points = canopy_points[canopy_points[:, 2] >= z_threshold]
+    clustering = DBSCAN(eps=1.0, min_samples=10).fit(canopy_points[:, :3])
+    labels = clustering.labels_
+    canopy_points = canopy_points[labels != -1]
+    
+    if canopy_points.shape[0] < 4:
+        canopy_volume = None
+    else:
+        '''
+        Uses the QuickHull algorithm which uses a divide-and-conquer approach.
+        It selects the 2 leftmost and rightmost points on a 2D plane; 
+        These are part of the ConvexHull.
+        Then it selects the point farthest away from the line joining the 
+        above 2 points and adds it to the ConvexHull.
+        The points enclosed within that shape cannot be part of the 
+        ConvexHull and are ignored. This process is then repeated until 
+        all points are either part of the ConvexHull or contained inside it.
+        '''
+        hull = ConvexHull(canopy_points)
+        canopy_volume = hull.volume
+    
+    return canopy_volume, canopy_points