HiMamba-Net: a Hilbert-serialized Mamba network for 3D point cloud instance segmentation

Abstract

Instance-level segmentation of large-scale 3D point clouds is a fundamental yet challenging task due to complex spatial structures, severe occlusions, and long-range dependencies. These challenges are particularly pronounced in field-scale agricultural scenes, where dense planting, irregular point distributions, and repetitive plant geometries limit the effectiveness of existing point cloud segmentation methods. This paper proposes HiMamba-Net, a Hilbert-serialized Mamba-based framework for efficient and spatially coherent instance segmentation of agricultural point clouds. The core contribution lies in a spatial serialization strategy that leverages Hilbert space-filling curves to preserve geometric locality while enabling linear-complexity sequential modeling via selective state space models. HiMamba-Net integrates patch-based local feature extraction, multi-scale graph context aggregation, and spatially ordered sequence modeling through SAMamba blocks to capture both local structures and global dependencies effectively. A multi-task learning scheme jointly optimizes semantic segmentation, discriminative instance embeddings, and offset regression to achieve accurate instance separation. Experiments on the Crops3D dataset demonstrate that HiMamba-Net outperforms the evaluated baseline methods, achieving 91.8% mIoU and 91.9% mAP for semantic and instance segmentation, respectively. Ablation studies further validate the contribution of Hilbert serialization and selective state space modeling. These results indicate that spatially coherent serialization combined with linear-complexity sequence modeling provides an effective approach for large-scale 3D point cloud instance segmentation.

Introduction

Accurate 3D understanding of crop point clouds is a fundamental prerequisite for field phenotyping, precision agriculture, and autonomous robotic operations^1,2. Compared with 2D imagery, 3D point clouds preserve geometric structure under complex illumination conditions and enable direct measurement of plant traits such as height, canopy volume, and organ-level morphology^3,4. However, agricultural field scenes present unique challenges for 3D perception: crops are densely planted with severe self-occlusion and inter-plant overlap, backgrounds are cluttered with soil and residues, and point density is highly non-uniform due to varying acquisition distances and scanning angles^5,6. These factors make instance-level segmentation—the task of delineating individual plants—substantially more challenging than semantic segmentation.

Deep learning on point sets has achieved remarkable progress in generic 3D understanding. Early methods such as PointNet and PointNet++^7,8 established permutation-invariant learning and hierarchical feature abstraction for point clouds. Subsequent graph-based and convolution-inspired approaches, including DGCNN and PointCNN^9,10, further improved local geometric modeling by explicitly exploiting neighborhood structures. While effective in many scenarios, these methods primarily emphasize local feature aggregation and often struggle to capture long-range dependencies efficiently in large-scale point clouds.

Recent architectures have explored alternative inductive biases to alleviate these limitations. Curve-based representations¹¹, residual MLP designs¹², and Transformer-style models^13,14 enhance global context modeling but typically incur high computational costs or quadratic complexity. State Space Models (SSMs) have recently emerged as an efficient alternative for long-range dependency modeling with linear complexity, as demonstrated by PointMamba¹⁵. Related efforts such as DeLA¹⁶ further improve scalability through decoupled local aggregation and large-kernel attention. Despite these advances, effectively adapting such models to agricultural instance segmentation remains non-trivial.

Agricultural field plots often contain numerous plants with repetitive structures and heavy occlusion, requiring both fine-grained local detail preservation and robust global context reasoning⁵. Moreover, accurate instance separation demands precise boundary cues beyond semantic classification, particularly when adjacent plants touch or overlap^17,18. Practical deployment further requires efficient processing of high-resolution field scans containing hundreds of thousands to millions of points^19,20. These challenges underscore the need for a modeling paradigm that preserves spatial coherence, captures long-range dependencies, and scales efficiently to large point clouds.

Despite recent progress, existing methods exhibit specific architectural bottlenecks when applied to dense agricultural field scans. Graph-based methods such as DGCNN and PointCNN rely on k-nearest neighbor graph construction at each layer, whose quadratic memory complexity becomes prohibitive for field scans exceeding one million points and whose local receptive fields fail to bridge inter-plant distances under heavy occlusion. PointMamba employs octree-based serialization to impose a fixed traversal order on unordered points; however, octree boundaries frequently bisect densely planted crops, placing geometrically adjacent points from the same plant into distant sequence positions and thereby degrading the continuity of the SSM hidden state across plant boundaries. Transformer-based methods such as the Stratified Transformer achieve strong accuracy but incur attention complexity, making them computationally impractical for large-scale field-scale acquisition containing several million points per scan. These observations motivate the need for a serialization strategy that preserves geometric locality more faithfully and a sequence model that operates with linear complexity.

To address these challenges, HiMamba-Net is introduced as a Hilbert-serialized Mamba-based 3D point cloud modeling framework for instance segmentation in agricultural scenes. Patch-wise geometric features are first extracted and serialized into a spatially coherent one-dimensional sequence using a Hilbert space-filling curve, preserving geometric locality during sequence construction. The resulting sequence is processed by selective State Space modeling blocks, enabling efficient long-range dependency modeling with linear computational complexity. A multi-task prediction head that integrates semantic segmentation, discriminative instance embedding learning, and offset refinement is employed to generate accurate instance masks in dense field-scale point clouds.

The main contributions of this work are summarized as follows:

• HiMamba-Net is a Hilbert-serialized Mamba-based 3D point cloud modeling framework that unifies patch-based local feature learning, spatially coherent serialization, and selective State Space modeling for efficient global context aggregation in agricultural instance segmentation.

• A multi-task prediction head is designed to jointly optimize semantic segmentation, discriminative instance embeddings, and offset refinement, enabling robust instance separation under strong occlusion and tight inter-plant spacing.

• Extensive experiments on the Crops3D and Crops3D_IS benchmarks with three representative crop species (maize, potato, and rapeseed) demonstrate consistent improvements over state-of-the-art methods including PointNet/PointNet++, DGCNN, PointCNN, CurveNet, PointMLP, PCT, Stratified Transformer, PointMamba, and DeLA.

The remainder of this paper is organized as follows. The Related Work section reviews existing point cloud learning methods for semantic and instance segmentation. The Proposed Method section elaborates on the HiMamba-Net framework. The Experiments section presents experimental results and ablation studies. Finally, the Conclusions section summarizes the key findings and discusses future research directions.

Related work

Point cloud learning for semantic segmentation

Early deep learning approaches for point cloud segmentation focus on learning permutation-invariant representations from unordered point sets. PointNet⁷ pioneered this field by aggregating per-point features via symmetric max pooling, establishing the fundamental framework for direct point cloud processing. PointNet++⁸ extends this idea with hierarchical neighborhood grouping and multi-scale set abstraction to capture local geometry, improving segmentation accuracy in complex scenes. Graph-based learning further improves local context modeling. DGCNN⁹ introduces dynamic graph construction and EdgeConv operations, enabling adaptive neighborhood feature extraction by computing edge features in dynamically updated k-nearest neighbor graphs. PointCNN¹⁰ learns X-transformations that reweight and permute points to make convolution applicable to irregular point sets, achieving strong performance through learned canonical orderings. These methods provide strong foundations for semantic segmentation and have been widely adopted in agricultural applications^21,22. More broadly, graph-based representation learning has demonstrated strong applicability across domains beyond 3D vision, including multi-view biological data clustering²³ and biological network alignment²⁴, underscoring the versatility of GNN architectures for structured data analysis.

Recent work explores alternative architectural paradigms for improved efficiency and accuracy. CurveNet¹¹ models curve structures by aggregating features along walk-through paths to better capture surface continuity, which benefits fine-grained geometric understanding of plant organs⁶. PointMLP¹² demonstrates that well-designed residual MLP blocks, coupled with local geometric encoding, can achieve strong performance with a simple and efficient design without graph construction overhead. Transformer-inspired models have also been successfully applied to point clouds. PCT¹³ employs self-attention mechanisms to capture global interactions among all points, enabling holistic scene understanding. ST¹⁴ stratifies attention computation with key-point selection and local self-attention to improve scalability while maintaining global receptive fields, achieving competitive performance on multiple benchmarks. DeLA¹⁶ proposes an efficient decoupled local aggregation strategy with deformable large kernel attention, enabling fast learning on large-scale point clouds with millions of points.

In agricultural contexts, semantic segmentation has been applied to various tasks including plant organ segmentation^2,21,25, canopy extraction^26,27, and field-scale crop monitoring^5,22,28. These applications demonstrate the effectiveness of deep learning-based semantic segmentation for high-throughput plant phenotyping and precision agriculture.

Point cloud instance segmentation

Instance segmentation extends semantic segmentation by separating individual object instances within the same semantic category, typically requiring both discriminative instance representations and boundary refinement. A common paradigm is to learn point-wise embeddings and then apply clustering in the embedding space, where points from the same instance are pulled together and different instances are pushed apart²⁹. This paradigm is especially relevant to agricultural field plots, where multiple plants share similar appearance and are spatially adjacent^5,30.

In agricultural applications, instance segmentation has been applied to individual plant separation^2,4, leaf instance segmentation^17,18,31, and organ-level phenotyping^6,32,33. Recent methods combine semantic segmentation with instance embedding learning to achieve accurate instance separation. For example, Organ3DNet² integrates a Sparse 3D Convolutional Network as encoder with a Transformer decoder for organ-level instance segmentation. SOY3DSEG⁴ employs an improved Point Transformer with dynamic multi-stage sampling for full-growth-cycle soybean segmentation. MRSliceNet³¹ proposes multi-scale recursive slicing and context fusion for leaf instance segmentation. Advanced reconstruction techniques such as PlantSegNeRF³⁴ enable high-precision instance point cloud generation from multi-view images.

Beyond crop plants, instance segmentation has been extended to other agricultural targets including individual tree extraction from forest point clouds^30,35–37, fruit detection and pose estimation^38–40, livestock body part segmentation^19,41,42, farmland boundary extraction⁴³, and precision pruning applications⁴⁴. Specialized methods for organ-level extraction such as phytomer segmentation⁴⁵, point cloud completion techniques⁴⁶, and visual SLAM systems⁴⁷ further support automated phenotyping workflows. These diverse applications highlight the broad applicability of instance segmentation techniques in precision agriculture and smart farming scenarios.

Efficient long-range modeling with state space models

While self-attention provides powerful global modeling, its quadratic complexity can be a bottleneck for dense point clouds with millions of points. State Space Models (SSMs) offer an attractive alternative with linear-time sequence modeling through continuous-time state representations¹⁵. PointMamba¹⁵ adapts selective SSMs to point cloud analysis through bidirectional processing and position encoding, demonstrating competitive performance with improved efficiency compared to Transformer-based methods. The selective mechanism enables input-dependent parameter updates, allowing the model to focus on relevant spatial information adaptively.

However, applying SSMs to unordered point clouds requires careful consideration of spatial serialization strategies. Different ordering schemes can significantly impact model performance by either preserving or disrupting spatial locality¹⁵. Motivated by these advances and challenges, our HiMamba-Net combines spatially coherent serialization via Hilbert space-filling curves with selective SSM blocks to capture long-range dependencies in field-scale crop point clouds efficiently. The Hilbert curve ordering ensures that spatially proximate points appear consecutively in the sequence, enabling SSMs to exploit geometric locality while maintaining linear computational complexity.

Methodology

This section presents the technical details of HiMamba-Net, a Hilbert-serialized Mamba-based 3D point cloud modeling framework for instance segmentation of agricultural crops. The section begins with an overview of the overall architecture, followed by detailed descriptions of each key module.

Framework overview

HiMamba-Net comprises five key modules: in-patch feature extraction, multi-scale graph context feature learning, Hilbert curve-based serialization, SAMamba blocks, and task-specific prediction heads, as illustrated in Fig. 1.

Fig. 1.

Overall architecture of HiMamba-Net. The framework consists of in-patch feature extraction, multi-scale graph context learning, Hilbert curve serialization, SAMamba blocks, and task-specific prediction heads.

The architecture begins with in-patch feature extraction that employs K-Nearest Neighbor (KNN) grouping to partition the input point cloud into local patches. Each patch undergoes feature embedding and repeat operations to extract local geometric representations. An MLP block processes neighborhood patches, followed by max pooling to aggregate local features, generating patch-level embeddings that capture fine-grained geometric details.

Multi-scale graph context features are constructed by extracting representations at different granularities. Hilbert Curve Sort prioritizes xyz coordinates to order patches based on spatial locality, organizing 3D patches into a sequence that preserves neighborhood relationships. This spatial ordering enables subsequent sequential processing while maintaining geometric coherence.

The SAMamba block serves as the core component, extending the vanilla Mamba architecture with spatial-aware enhancements for point cloud processing. The block integrates: (1) depthwise convolution (DWConv) for local feature refinement, (2) 2D-SSM module with spatial attention mechanism for capturing global spatial dependencies, and (3) residual connections with layer normalization for stable training. This enhanced architecture employs a gating mechanism to control information flow, enabling selective feature propagation through linear transformations while maintaining linear computational complexity.

The serialization and SAMamba processing are repeated N times to progressively refine features at multiple scales, capturing both local geometric patterns and global structural relationships across the entire point cloud. Finally, the task head generates predictions through linear projection layers, producing instance segmentation masks that delineate individual crop plants within agricultural field plots.

In-patch feature extraction

The in-patch feature extraction module processes the input point cloud through local neighborhood aggregation to capture fine-grained geometric features. Given the input point cloud , where N denotes the number of points and each point represents the 3D coordinates. When available, additional features such as RGB color information augment the representation, forming where C represents the number of additional feature channels.

For each point , its K-nearest neighbors are identified using Euclidean distance in 3D space:

1

where returns the indices of the K nearest neighbors of point . The neighborhood forms a local patch centered at , capturing the local geometric structure. Each patch undergoes feature transformation through an embedding layer that projects the coordinates into a higher-dimensional space:

2

where represents a learnable embedding function implemented as an MLP, and D is the feature dimension.

The local patch features are processed through an MLP block followed by max pooling to extract representative features:

3

4

where and denote fully connected layers, represents batch normalization, and applies the rectified linear activation function. The max pooling operation aggregates features across the K neighbors, producing a permutation-invariant representation. The aggregated features form the initial patch-level representation that encodes local geometric properties such as surface normals, curvature, and local density variations, serving as input to the subsequent multi-scale feature learning module.

Multi-scale graph context feature learning

To capture both local geometric patterns and global structural relationships, multi-scale feature learning is employed through graph-based context aggregation. This module constructs hierarchical representations that progressively coarsen the point cloud while preserving essential geometric information. Farthest Point Sampling (FPS) generates multiple levels of point subsets with decreasing cardinality:

5

where is the original point cloud, L denotes the number of hierarchical levels, and represents the number of points at level l. FPS ensures uniform coverage of the 3D space while reducing computational complexity.

At each scale l, a k-nearest neighbor graph is constructed where vertices correspond to sampled points and edges connect each point to its K nearest neighbors:

6

Features are propagated across the graph structure through graph convolutional operations that aggregate information from neighboring nodes:

7

where denotes learnable weight matrices, represents the activation function, and is the cardinality of the neighborhood. Features from different scales are concatenated and projected to form enriched representations:

8

where represents features at scale l, and denotes concatenation with appropriate interpolation to align dimensions.

Hilbert curve-based spatial serialization

A critical challenge in applying sequential models to 3D point clouds is the inherent unordered nature of point sets. To address this challenge, Hilbert space-filling curves are employed to serialize 3D points into a 1D sequence while preserving spatial locality. The 3D Hilbert curve recursively subdivides the bounding box of the point cloud into octants, visiting each octant according to a fixed pattern that maximizes spatial continuity. For points with coordinates , the Hilbert index is computed as:

9

where determines the resolution of the space-filling curve. The Hilbert index provides a total ordering of points. Points are sorted according to their Hilbert indices to form a spatially coherent sequence:

10

where π denotes the permutation that reorders points, and represents the serialized sequence. This ordering ensures that spatially proximate points appear consecutively in the sequence, enabling sequential models to exploit geometric locality. The patch-level features are reordered according to π to form a sequential representation:

11

This serialized representation bridges the gap between unordered point clouds and sequential processing architectures, enabling the application of State Space Models while maintaining geometric coherence.

A natural alternative to Hilbert serialization is the Morton (Z-order) space-filling curve, which encodes 3D coordinates by interleaving their binary representations. While computationally simpler, Z-order curves suffer from systematic locality discontinuities at axis-aligned boundaries: a point near one boundary of a sub-octant and its geometrically adjacent neighbour across that boundary can receive Hilbert-equivalent indices that differ by up to , producing abrupt long-distance jumps in the 1D sequence. Hilbert curves circumvent this problem through their recursive U-shaped traversal pattern, which is specifically designed to minimise the maximum distance between consecutively indexed positions. Formally, for a d-dimensional Hilbert curve of order p, the maximum jump in sequence position between any two points within Euclidean distance r is bounded by , whereas the corresponding bound for Z-order is , a factor of d worse¹⁵. In the context of SSM processing, this locality gap is particularly consequential: the hidden state in Equation (10) propagates information forward through the sequence, so large positional jumps cause the state to carry irrelevant spatial context, degrading segmentation quality at plant boundaries. Empirical evidence supporting this analysis is provided in the extended ablation study.

SAMamba block with state space models

The SAMamba (Spatial Attention Mamba) block serves as the core module for modeling long-range dependencies in the serialized point cloud sequence. Building upon the Mamba architecture¹⁵, SAMamba introduces key enhancements specifically designed for agricultural point cloud processing: depthwise convolution (DWConv) for local feature refinement and spatial attention mechanisms for adaptive feature selection. These modifications enable SAMamba to capture global spatial relationships with linear computational complexity while addressing the quadratic complexity limitation of traditional self-attention mechanisms. Given the input sequence , the evolution of hidden states is modeled through continuous-time state space equations:

12

13

where represents the hidden state, is the input, is the output, and , , , are state space matrices.

To process discrete point cloud sequences, the continuous system is discretized using the zero-order hold (ZOH) method with step size Δ:

14

where and are discrete-time matrices. The discrete recurrence relation becomes:

15

Following the Mamba architecture, input-dependent selection mechanisms are introduced where the SSM parameters , , and Δ are conditioned on the input:

16

where denotes linear projections. This selective mechanism enables the model to adaptively focus on relevant spatial information based on local geometric characteristics. The overall architecture of the vanilla Mamba block is illustrated in Fig. 2, which serves as the foundation for the enhanced SAMamba design.

Fig. 2.

Architecture of the vanilla Mamba block. The diagram shows the sequential processing flow through linear projection, SSM module, depthwise convolution (Conv1D), and final linear projection with residual connection. This structure forms the basis for the SAMamba enhancements.

To effectively process 2D spatial arrangements after serialization, the 1D SSM is extended to 2D-SSM by incorporating spatial attention mechanisms. The features are first reshaped and processed through depthwise convolutions for local feature refinement:

17

where denotes layer normalization. Subsequently, the 2D-SSM applies spatial attention to capture cross-dimensional dependencies:

18

where denotes the sigmoid activation function, ⊙ represents element-wise multiplication, and the attention mechanism acts as a gating function that selectively propagates relevant features.

The SAMamba block employs residual connections to facilitate gradient flow:

19

20

where is the Gaussian Error Linear Unit activation function. The feed-forward network further refines the features with position-wise transformations.

Fig. 3.

Architecture of the State Space Model component in SAMamba, showing the selective mechanism with input-dependent parameters (, , ), state transition matrix A, and gating function (σ).

Multiple SAMamba blocks are stacked to progressively refine features at different abstraction levels. Each block operates on the serialized representation, capturing increasingly global spatial patterns:

21

where denotes the number of SAMamba blocks. The hierarchical feature refinement enables the model to capture both fine-grained local patterns and coarse-grained global structures.

Instance segmentation task head

The task head transforms the refined SAMamba features into instance segmentation predictions through a combination of semantic segmentation, instance embedding, and clustering-based grouping. The semantic branch predicts point-wise class labels to distinguish crop points from background:

22

where C denotes the number of semantic classes (background, maize, potato, rapeseed in our case), and represents the predicted semantic probabilities for each point.

To differentiate individual plant instances, features are projected into an embedding space where points from the same instance cluster together:

23

where is the embedding dimension, and applies L2 normalization to ensure embeddings lie on the unit hypersphere, facilitating distance-based clustering.

HDBSCAN (Hierarchical Density-Based Spatial Clustering of Applications with Noise) is employed to group embeddings into instances:

24

where denotes the set of point indices belonging to instance k, K is the number of detected instances, ε is the neighborhood radius, and specifies the minimum cluster size. HDBSCAN adaptively determines the number of instances without requiring pre-specification.

To refine instance boundaries, spatial offsets are predicted to shift each point toward its instance center:

25

where represents the predicted 3D offset for each point. The offset-shifted coordinates improve instance compactness:

26

Training strategy and loss function

HiMamba-Net is trained end-to-end using a multi-task loss function that jointly optimizes semantic segmentation, instance embedding, and offset prediction. Batch normalization and dropout are employed to stabilize training and prevent overfitting.

The total training objective combines three complementary loss terms:

27

where , , and are weighting hyperparameters that balance the contribution of each loss component.

The semantic loss employs weighted cross-entropy to handle class imbalance between crop and background points:

28

where denotes the ground truth semantic class for point , is the predicted probability for the true class, and represents the inverse frequency weight for class c.

Following the discriminative loss formulation, the instance loss encourages intra-instance compactness and inter-instance separation in the embedding space:

29

where the pull term attracts embeddings to their cluster center:

30

is the mean embedding of instance k. The push term repels different cluster centers:

31

where denotes the hinge function, and δ is the margin hyperparameter. The regularization term prevents embedding magnitudes from growing unbounded:

32

The offset loss employs smooth L1 loss to encourage accurate center prediction:

33

where denotes the number of crop points (excluding background), is the ground truth offset from point to its instance center , and is defined as:

34

The model is optimized using AdamW optimizer with learning rate scheduling. Cosine annealing with warm restarts is employed to facilitate convergence and escape local minima.

Experiments

Experimental setup

Datasets

Experiments are conducted on the Crops3D dataset⁴⁸, a real-world 3D point cloud dataset specifically designed for agricultural scenarios. The dataset exhibits three core characteristics: diversity, realism, and complexity, making it a challenging benchmark for point cloud instance segmentation tasks. The Crops3D dataset encompasses eight crop species (cabbage, cotton, maize, potato, rapeseed, rice, tomato, wheat) and three field-scale plots (maize field, potato field, rapeseed field). It contains 1230 samples that capture crops at different growth stages, including seedling, tasseling, and grain-filling stages for maize, as well as full growth cycles for tomato.

The dataset integrates multiple point cloud acquisition technologies to adapt to different crop morphologies: Terrestrial Laser Scanning (TLS) for tall field crops, Structure from Motion (SfM) and Multi-View Stereo (MVS) for outdoor plants, and structured light scanning for indoor cultivation. All point clouds are annotated using CloudCompare software with scalar field (SF) attributes to distinguish semantic categories including background (soil, pot), stem, leaf, and fruit. The annotation consistency was verified by seven domain experts, with mean Intersection over Union (mIoU) exceeding 0.91 and accuracy exceeding 0.97, providing reliable ground truth for model training and evaluation.

The experiments focus on the Crops3D_IS sub-dataset designed for field-scale individual plant instance segmentation. Three representative crop species are selected: maize (complex multi-organ structure), potato (dense foliage under row-planting), and rapeseed (dense canopy with irregular spatial distribution). The dataset is split into training (70%), validation (15%), and testing sets (15%) following standard practices to ensure unbiased evaluation. Each point cloud contains between 50 K to 3M points with XYZ coordinates and RGB color information, providing rich geometric and appearance features for segmentation.

Implementation details

HiMamba-Net is implemented using PyTorch and all models are trained on NVIDIA RTX 3090 GPUs with 24GB memory. The input point clouds are normalized to unit spheres and augmented with random rotation, scaling (0.8–1.2), and jittering (σ=0.01) during training to improve robustness. The AdamW optimizer is employed with an initial learning rate of 0.001, cosine annealing learning rate scheduling with warm restarts, and weight decay of 0.0001. The batch size is set to 8 for training and 1 for testing. Each experiment is repeated three times with different random seeds (42, 2023, 2024), and the average performance with standard deviations is reported.

The key hyperparameters are configured as follows: K=32 for K-nearest neighbor grouping, embedding dimension D=256, number of SAMamba blocks N=4, Hilbert curve order=5, multi-scale levels L=3, and HDBSCAN parameters (min_cluster_size=50, min_samples=10, ε=0.5). Loss function weights are set to λ_sem=1.0, λ_inst=1.0, and λ_off=0.5 after hyperparameter tuning on the validation set. Training converges within 200 epochs with early stopping patience of 20 epochs.

The selection rationale for critical hyperparameters is as follows. The neighbourhood size K=32 was determined via grid search over on the validation split; K=16 under-captures fine leaf geometry while K=64 increases memory footprint without measurable accuracy gain. The embedding dimension D=256 follows established practice in point cloud instance segmentation¹⁵ and was validated against : increasing to 512 raised GPU memory by 1.9× with only +0.3% mIoU improvement. The number of SAMamba blocks N=4 was selected by evaluating ; N=4 achieved the best validation mIoU and exhibited the fastest convergence, whereas N=6 showed marginal improvement (+0.2%) at 1.4× inference cost. The Hilbert curve order of 5 was determined through ablation: order=4 shows a measurable resolution degradation while order=6 provides negligible accuracy gain at the cost of substantially longer preprocessing time. The HDBSCAN min_cluster_size=50 was set conservatively below the empirically observed minimum per-plant point count of 83 in the training split; ε =0.5 was calibrated such that the embedding-space margin δ in Equation (22) is satisfied for at least 97% of instance pairs on the validation set. The loss weight (half of the semantic and instance weights) was chosen because the offset branch converges more slowly in early training epochs, and down-weighting it stabilises the initial learning dynamics without degrading final boundary accuracy.

Agricultural field scans frequently contain noise from dust particles, sensor artifacts, and multi-path reflections, which introduce isolated outlier points far from the main scene. Since Hilbert serialization normalises point coordinates to the unit cube using the scene bounding box, extreme outliers that expand this box degrade grid resolution and compress all legitimate plant points into a small fraction of the Hilbert index range. To mitigate this, a statistical outlier removal (SOR) filter is applied before Hilbert index computation: points whose mean distance to their k-nearest neighbours exceeds are discarded. In the Crops3D_IS dataset, SOR removes on average 0.8% of points per scan and reduces the effective bounding box diagonal by 3.1% with negligible computational overhead. Additionally, the bounding box is computed from the 1 st and 99th percentile of point coordinates rather than the strict extremes, providing further robustness against residual outliers.

Evaluation metrics

Standard metrics are employed for both semantic and instance segmentation tasks to comprehensively evaluate model performance.

For semantic segmentation, mean Accuracy (mAcc) and mean Intersection over Union (mIoU) are used:

35

36

where C denotes the number of semantic classes, , , and represent true positives, false positives, and false negatives for class c, respectively. Higher values indicate better segmentation performance.

For instance segmentation, Average Precision (AP) at different IoU thresholds is adopted:

37

where τ denotes the IoU threshold (0.25, 0.50, 0.75), N is the number of predicted instances, and is the indicator function. AP@0.25, AP@0.50, and mean AP (mAP) averaged across all thresholds are reported to comprehensively assess instance detection and segmentation quality.

Baseline methods

HiMamba-Net is compared against state-of-the-art point cloud segmentation methods covering diverse architectural paradigms. Among the classic approaches, PointNet⁷ establishes the foundation by learning permutation-invariant features through shared MLPs and symmetric max pooling. PointNet++⁸ extends this with hierarchical set abstraction and multi-scale grouping for robust local-to-global feature learning. DGCNN⁹ introduces EdgeConv operations over dynamically updated k-nearest neighbor graphs to capture local geometric structures adaptively. PointCNN¹⁰ generalizes convolutions to irregular point sets through learned X-transformations that provide canonical orderings while maintaining permutation invariance.

More recent architectures explore different design philosophies. PointMLP¹² demonstrates that simple residual MLP architectures with geometric affine modules can achieve competitive performance without complex graph operations. CurveNet¹¹ aggregates walk-through features along curve structures generated by random walks to better capture surface continuity and fine-grained geometric variations. Transformer-based methods have also gained attention, with PCT¹³ applying self-attention mechanisms for global point interactions and Stratified Transformer (ST)¹⁴ employing stratified key-point selection combined with local self-attention for efficient global modeling.

PointMamba¹⁵ adapts selective state space models (SSMs) to point cloud analysis through bidirectional processing, octree-based serialization, and learnable position encoding, achieving linear computational complexity for long-range dependency modeling. DeLA¹⁶ introduces a decoupled local aggregation strategy with deformable large kernel attention for efficient feature extraction on large-scale point clouds. Additionally, comparisons include dedicated instance segmentation approaches that jointly optimize semantic segmentation and instance grouping through end-to-end learning frameworks with specialized instance embedding and clustering modules.

These baselines represent current best practices in point cloud understanding, covering both foundational architectures and recent advances, ensuring rigorous benchmarking across semantic and instance segmentation tasks in challenging agricultural field scenarios.

Main results

Semantic segmentation performance

Table 1 presents the semantic segmentation performance comparison across all baseline methods on the three selected crop species. The average mAcc and mIoU values over three independent runs with different random seeds (42, 2023, 2024) are reported, along with per-class IoU for maize, potato, and rapeseed to demonstrate class-specific performance patterns. The overall comparisons and per-crop breakdowns are visualized in Fig. 4 and Fig. 5, respectively.

Table 1.

Semantic segmentation performance comparison on Crops3D dataset. mAcc and mIoU are averaged across all semantic classes. Per-class IoU is reported for three representative crops. Best results are in bold, second-best are underlined.

Method	mAcc	mIoU	IoU (Maize)	IoU (Potato)	IoU (Rapeseed)
PointNet	0.893	0.709	0.527	0.450	0.873
PointNet++	0.924	0.767	0.676	0.426	0.938
DGCNN	0.930	0.790	0.620	0.538	0.967
PointCNN	0.937	0.801	0.683	0.567	0.949
CurveNet	0.927	0.777	0.660	0.502	0.951
PointMLP	0.918	0.759	0.633	0.466	0.951
ST	0.975	0.904	0.856	0.833	0.985
PointMamba	0.930	0.802	0.768	0.577	0.957
DeLA	0.949	0.832	0.723	0.639	0.971
HiMamba-Net	0.981±0.003	0.918±0.005	0.879±0.008	0.861±0.012	0.991±0.002

Fig. 4.

Semantic segmentation performance comparison. (a) Mean Accuracy (mAcc). (b) Mean IoU (mIoU).

Fig. 5.

Per-crop IoU comparison. (a) Maize. (b) Potato. (c) Rapeseed.

HiMamba-Net achieves the best semantic segmentation performance across all three crop species in our experiments, outperforming the second-best baseline by 0.6% in mAcc and 1.4% in mIoU on average. This improvement suggests that the Hilbert curve-based serialization combined with State Space Models is effective in capturing both local geometric patterns and global spatial dependencies. The performance improvement is particularly notable for challenging crops: HiMamba-Net improves maize IoU by 2.3% (0.879 vs 0.856) and potato IoU by 2.8% (0.861 vs 0.833) compared to ST, indicating improved capability in handling dense planting, occlusion, and complex plant structures commonly observed in field-scale agricultural scenarios.

Notably, rapeseed achieves the highest IoU across all methods (exceeding 0.95) due to its relatively consistent canopy structure, while maize and potato present greater challenges with complex geometry and stronger self-occlusion. The substantial performance gap between classic methods and recent approaches highlights the importance of effective long-range dependency modeling and hierarchical feature aggregation for agricultural point cloud segmentation. The performance of HiMamba-Net can be attributed to three key design choices: (1) Hilbert curve serialization preserves spatial locality while enabling sequential modeling, (2) selective State Space Models capture global dependencies with linear complexity, and (3) multi-scale graph context features provide geometric representations at different granularities.

Instance segmentation performance

Table 2 presents the instance segmentation performance comparison between HiMamba-Net and state-of-the-art instance segmentation methods. Performance is evaluated at multiple IoU thresholds (0.25, 0.50, 0.75) and mean AP (mAP) averaged across all thresholds is reported to comprehensively assess instance detection and segmentation quality.

Table 2.

Instance segmentation performance comparison on Crops3D_IS dataset. AP is evaluated at IoU thresholds of 0.25, 0.50, and 0.75. mAP is the average across all thresholds. Best results are in bold, second-best are underlined.

Method	AP@0.25	AP@0.50	AP@0.75	mAP
OneFormer3D	0.981	0.945	0.751	0.889
Mask3D	0.871	0.865	0.789	0.825
PointNet++	0.742	0.698	0.563	0.668
DGCNN	0.803	0.761	0.627	0.730
ST	0.943	0.921	0.783	0.882
PointMamba	0.857	0.823	0.692	0.791
DeLA	0.906	0.884	0.738	0.843
HiMamba-Net	0.992±0.002	0.958±0.004	0.806±0.006	0.919±0.004

Fig. 6.

Instance segmentation performance comparison. (a) AP@0.25. (b) AP@0.50. (c) AP@0.75. (d) mAP.

Fig. 7.

Performance comparison across semantic and instance segmentation metrics.

HiMamba-Net achieves the highest instance segmentation performance in our experiments, outperforming the second-best method by 3.0% in mAP (0.919 vs 0.889). The improvement is particularly notable at stricter IoU thresholds: HiMamba-Net achieves 80.6% AP@0.75, surpassing the second-best by 5.5 percentage points (0.806 vs 0.751). This suggests that the discriminative embedding loss combined with offset prediction can refine instance boundaries effectively, producing improved segmentation masks compared to alternative approaches.

Among the baseline methods, dedicated instance segmentation architectures such as OneFormer3D and Mask3D demonstrate strong performance, while methods combining semantic segmentation with HDBSCAN clustering show varying results depending on the quality of learned features. Notably, ST achieves competitive performance (mAP=0.882), indicating that high-quality semantic features can provide a strong foundation for instance grouping. HiMamba-Net jointly optimizes semantic segmentation, instance embedding, and offset prediction, combining the strengths of both direct instance prediction and embedding-based clustering while maintaining computational efficiency through linear-complexity State Space Models.

To further characterise real-world efficiency, the 58.1 ms per-sample inference time is decomposed into individual pipeline stages measured on an NVIDIA RTX 3090 GPU: Hilbert index computation 7.2 ms (12.4%); in-patch feature extraction 13.8 ms (23.7%); multi-scale graph construction and aggregation 9.4 ms (16.2%); SAMamba block forward pass () 19.7 ms (33.9%); HDBSCAN post-processing 8.0 ms (13.8%). The SAMamba forward pass is the dominant stage, while Hilbert preprocessing contributes only 12.4% of total latency, confirming that the serialization overhead is modest relative to feature learning.

Generalization to standard 3D benchmarks

To assess whether the core HiMamba-Net architecture generalises beyond the agricultural domain, supplementary experiments are conducted on two widely adopted indoor semantic segmentation benchmarks: S3DIS Area-5⁴⁹ and ScanNet v2⁵⁰. For both evaluations, the instance segmentation head (discriminative embedding and offset regression branches) is disabled; only the backbone (in-patch feature extraction, multi-scale graph context, Hilbert serialization, and SAMamba blocks) together with the semantic classification head are retained and trained from scratch on each benchmark without any Crops3D pre-training. This setup directly isolates the generalizability of the core Hilbert-serialized SSM design from the agricultural task-specific components.

Table 3 reports mean class accuracy (mAcc) and mIoU on S3DIS Area-5 alongside ScanNet v2 mIoU, compared against ten representative methods. All methods in the table use only 3D geometric inputs without auxiliary 2D images to ensure a fair comparison.

Table 3.

Semantic segmentation results on S3DIS Area-5 and ScanNet v2. All methods use only 3D geometric inputs. HiMamba-Net is evaluated with the semantic head only (no instance branch), trained from scratch on each benchmark without Crops3D pre-training. Rows ordered by S3DIS mIoU. Best results in bold; HiMamba-Net underlined. “—” denotes results not reported in the original publications.

Method	S3DIS mAcc (%)	S3DIS mIoU (%)	ScanNet mIoU (%)
PointNet++8	—	53.5	53.3
LAE-Conv51	—	66.3	46.9
Decoupling52	—	66.6	68.4
KPConv53	72.8	67.1	69.2
JSENet54	—	67.7	69.9
PTv155	76.5	70.4	70.6
PointNeXt56	76.8	70.5	71.5
HiMamba-Net	76.3	70.8	71.4
SemiGMMPoint57	78.7	71.2	71.5
PointMetaBase58	—	71.3	72.8
PTv259	77.9	71.6	75.4

HiMamba-Net achieves 70.8% mIoU on S3DIS Area-5 and 71.4% on ScanNet v2, placing it fourth overall on S3DIS and fifth on ScanNet among the ten compared methods. The result is notably consistent across two benchmarks with different scene characteristics—S3DIS covers large-scale office buildings while ScanNet covers diverse residential and commercial interiors—indicating that the model’s performance reflects genuine architectural transferability rather than overfitting to a specific scene distribution.

Among the methods with Transformer-style global attention (PTv1, PTv2, PointNeXt), HiMamba-Net achieves competitive mIoU despite relying on linear-complexity SSMs rather than quadratic self-attention. Compared to PTv1, which is architecturally most comparable in depth and parameter scale, HiMamba-Net achieves 0.4% higher mIoU on S3DIS, suggesting that Hilbert-based serialization provides an effective inductive bias for spatial locality even in indoor environments with structured room geometry. The gap to the top-performing PTv2 (−0.8% on S3DIS, −4.0% on ScanNet) is expected: PTv2 incorporates grouped vector attention and partition-based pooling specifically optimised for general indoor scene understanding, whereas HiMamba-Net’s design priorities—linear-complexity processing, stability under irregular agricultural point density, and a multi-task instance head—introduce trade-offs that are most beneficial in the intended agricultural setting. These results confirm that the Hilbert-serialized SSM backbone generalises across domains and provides competitive 3D scene understanding, while the full HiMamba-Net framework delivers its strongest performance on the agricultural tasks it was designed for.

Ablation study

To systematically validate the contribution of each component, ablation studies are conducted on the maize and potato subsets by removing individual modules while keeping other components unchanged. Seven variants are evaluated: (1) w/o Hilbert Serialization (random point ordering), (2) Z-order Serialization (Morton curve replacing Hilbert), (3) w/o SAMamba (replacing SAMamba blocks with standard Transformer), (4) w/o Multi-Scale (single-scale features only), (5) w/o Instance Loss (semantic segmentation only), (6) w/o Offset Branch (no boundary refinement), and (7) Z-order Serialization as an intermediate comparison between random ordering and Hilbert ordering. The ablation comparisons are visualized in Fig. 8.

Table 4.

Ablation study results on maize and potato subsets. Performance degradation indicates each component’s contribution. Results show mIoU for semantic segmentation and mAP for instance segmentation. Z-order serialization is included as an additional comparison to isolate the benefit of Hilbert curve ordering over Morton-order alternatives.

Variant	mIoU	mAP
Full HiMamba-Net	0.918	0.919
w/o Hilbert Serialization (random)	0.886 (−3.5%)	0.891 (−3.0%)
Z-order Serialization (Morton)	0.907 (−1.2%)	0.904 (−1.6%)
w/o SAMamba Blocks	0.891 (−2.9%)	0.896 (−2.5%)
w/o Multi-Scale Features	0.902 (−1.7%)	0.907 (−1.3%)
w/o Instance Embedding Loss	0.915 (−0.3%)	0.857 (−6.7%)
w/o Offset Prediction	0.913 (−0.5%)	0.889 (−3.3%)

Fig. 8.

Ablation study results. (a) Performance scores across variants. (b) mIoU degradation. (c) mAP degradation.

The Z-order serialization variant achieves 90.7% mIoU and 90.4% mAP, substantially outperforming random ordering (88.6%/89.1%) but falling 1.2%/1.6% short of Hilbert ordering. This confirms that spatial coherence in serialization is beneficial for SSM processing, and that Hilbert curves provide a measurably superior locality-preserving property compared to Morton curves, consistent with the theoretical analysis presented in the Hilbert Curve-Based Spatial Serialization section.

The Hilbert curve order parameter p controls the spatial resolution of the serialization grid ( voxels). Table 5 reports the effect of varying p on segmentation performance and serialization preprocessing time.

Table 5.

Effect of Hilbert curve order p on segmentation performance and serialization preprocessing time. At p=3, the coarse grid causes multiple distinct points to share the same Hilbert index, losing geometric resolution. At p=6, the accuracy gain over p=5 is negligible (0.3%/0.1%) while preprocessing cost more than doubles. Order p=5 provides the best accuracy-efficiency trade-off.

Order	Grid Resolution	mIoU	mAP	Preprocess (ms)
p=3		0.879	0.882	11.3
p=4		0.904	0.906	21.7
p=5 (ours)		0.918	0.919	31.4
p=6		0.921	0.920	78.6

The ablation study provides insights into the contribution of each component. Hilbert curve serialization has the most significant impact on semantic segmentation performance, with its removal causing 3.5% mIoU degradation (0.886 vs 0.918). This supports the use of space-filling curve-based ordering, which preserves spatial locality while enabling sequential processing. Random point ordering disrupts the inherent geometric structure, forcing the SAMamba blocks to learn spatial relationships without the spatial continuity provided by Hilbert indexing. The performance drop indicates that effective spatial serialization is important for applying State Space Models to unordered point clouds.

The SAMamba blocks constitute the second most important component, with their removal causing 2.9% mIoU degradation when replaced with standard Transformer layers. This finding suggests that selective State Space Models can provide effective long-range dependency modeling compared to quadratic-complexity self-attention mechanisms. The SSM’s linear computational complexity enables processing of larger spatial contexts while maintaining efficiency, which is beneficial for dense agricultural point clouds with millions of points. The selective mechanism adaptively focuses on relevant spatial regions based on local geometric characteristics.

Multi-scale graph context features contribute moderately but consistently, with single-scale processing causing 1.7% mIoU degradation. This validates the importance of hierarchical feature aggregation for capturing both fine-grained geometric details and coarse-grained structural patterns. Agricultural crops exhibit multi-scale characteristics—leaves display intricate surface variations at fine scales, while overall plant architecture manifests at coarser scales. The multi-scale design enables the model to reason about geometric patterns across different spatial resolutions simultaneously, which is essential for accurate organ-level segmentation.

For instance segmentation, the discriminative embedding loss emerges as the most critical component, with its removal causing 6.7% mAP degradation (0.857 vs 0.919). Without explicit instance embedding optimization, the model relies solely on semantic predictions followed by post-hoc clustering, which struggles to separate spatially adjacent plants. The pull-push loss formulation effectively enforces intra-instance compactness and inter-instance separation in the embedding space, enabling HDBSCAN to reliably group points into distinct instances. Offset prediction contributes additional refinement (3.3% mAP improvement), shifting points toward instance centers to improve boundary localization, particularly beneficial for occluded regions where semantic predictions alone provide insufficient separation cues.

Visualization analysis

To provide qualitative insights into HiMamba-Net’s segmentation performance, representative results from each crop species are visualized. Figure 9 presents qualitative comparisons between ground truth annotations and HiMamba-Net predictions for maize, potato, and rapeseed samples, highlighting the model’s capability to accurately delineate individual plant instances even under challenging conditions such as occlusion, dense planting, and complex morphological structures.

Fig. 9.

Instance segmentation results on three crop species. (a) Maize original point cloud; (b) Maize ground truth; (c) Maize prediction (HiMamba-Net); (d) Potato original point cloud; (e) Potato ground truth; (f) Potato prediction (HiMamba-Net); (g) Rapeseed original point cloud; (h) Rapeseed ground truth; (i) Rapeseed prediction (HiMamba-Net).

The visualizations show HiMamba-Net’s performance across diverse crop morphologies and planting configurations. For maize (a-c), the model segments individual plants in dense field plots with complex multi-organ structures including stems, leaves, tassels, and developing ears. The predictions generally match ground truth annotations with clear instance boundaries, handling leaf overlap between adjacent plants. For potato (d-f), HiMamba-Net delineates individual plants arranged in regular row patterns, maintaining segmentation quality even for occluded plants at field boundaries. The linear planting configuration presents challenges for spatial serialization, which the Hilbert curve approach addresses. For rapeseed (g-i), the model achieves good segmentation despite the crop’s dense canopy structure and irregular spatial distribution. The predictions show limited over-segmentation or under-segmentation errors, with instance boundaries following plant structures in regions with overlapping foliage.

Failure case analysis

To provide a transparent assessment of model limitations, representative failure cases are examined in Fig. 10. Two dominant failure modes are identified.

Fig. 10.

Failure case analysis. (a–c) Over-segmentation: (a) maize original point cloud; (b) ground truth; (c) over-segmentation prediction—a single plant is incorrectly split into multiple instances due to heavy self-occlusion at intermediate canopy heights. (d–f) Under-segmentation: (d) rapeseed original point cloud; (e) ground truth; (f) under-segmentation prediction—spatially adjacent plants with overlapping canopies are merged into a single predicted instance.

Over-segmentation occurs when a single plant is incorrectly fragmented into multiple predicted instances. This failure is most prevalent for mature maize plants whose leaves extend over a wide vertical range. When the leaves of a single plant are heavily occluded by neighbouring plants at intermediate heights, the per-point embeddings in the occluded region become less discriminative, causing the HDBSCAN clustering step to split one plant into two or more sub-instances along the vertical axis. This is visualised in Fig. 10(a–c), where a single maize plant is partitioned into vertically separated fragments with distinct instance colours.

Under-segmentation is observed in dense rapeseed plots where neighbouring plants have extensive canopy overlap. When the spatial embeddings of two or more adjacent plants converge in the embedding space due to their geometric similarity and physical contact, HDBSCAN merges them into a single predicted instance. Fig. 10(d–f) illustrates this case, where several spatially adjacent rapeseed plants are assigned a single instance colour despite being distinct organisms in the ground truth.

These failure patterns suggest two directions for future improvement: (1) incorporating height-stratified attention or vertical-aware positional encodings to distinguish vertically overlapping plant parts, and (2) adopting learned, instance-adaptive clustering thresholds rather than fixed HDBSCAN parameters to handle varying inter-plant distances across planting densities.

Conclusion and future work

This paper presents HiMamba-Net, a Hilbert-serialized Mamba-based 3D point cloud modeling framework for agricultural crop instance segmentation. The proposed approach addresses key challenges in 3D point cloud understanding by effectively bridging the gap between unordered point sets and sequential processing architectures through space-filling curve ordering that preserves spatial locality.

Experiments on the Crops3D dataset with three crop species demonstrate that HiMamba-Net outperforms the evaluated baselines across both semantic and instance segmentation tasks, achieving 91.8% mIoU and 91.9% mAP respectively. The experimental results highlight three main characteristics: improved segmentation accuracy through spatial serialization and long-range dependency modeling, computational efficiency via linear-complexity State Space Models, and consistent performance across diverse crop morphologies. Ablation studies validate the importance of each component, with Hilbert serialization and SAMamba blocks being the main contributors to performance. The model maintains reasonable computational efficiency with 18.4M parameters and 58.1ms inference time.

Several limitations warrant acknowledgment, including sensitivity to Hilbert curve ordering resolution, computational overhead for preprocessing, and generalization challenges across different crop species. Preprocessing robustness against sensor noise is addressed via a statistical outlier removal step described in the Implementation Details, and a per-stage inference time breakdown is provided in the Experimental Results section. Future research should address remaining limitations through learnable serialization strategies, computational acceleration via GPU optimization and model quantization, cross-species validation experiments, integration of probabilistic instance prediction capabilities, and incorporation of temporal information for multi-temporal crop monitoring. Extending the framework to other precision agriculture tasks including yield prediction, disease detection, growth stage classification, and robotic applications represent promising directions for broader impact in smart farming systems.

Author contributions

K.Z. conceived the research idea and conducted the mathematical derivations. K.Z. and D.S. developed the code and conducted the experiments. K.Z., D.S., and Y.G. wrote the manuscript. O.G. supervised the project and acquired funding together with S.R. S.R. provided project administration. All authors reviewed the manuscript.

Data availability

The datasets used in this study are publicly available. The Crops3D dataset can be accessed through the github repository at https://github.com/clawCa/Crops3D.

Code availability

The source code and implementation details of the proposed framework are publicly available on GitHub at https://github.com/datashare768/HiMamba-Net. Additionally, the archived version of the codebase and associated research materials are accessible via Zenodo at https://doi.org/10.5281/zenodo.20729443.

Declarations

Competing interests

The authors declare no competing interests.