Pickalo: Leveraging 6D Pose Estimation and Deep Stereo Matching for Industrial Bin Picking

Abstract

Bin picking in industrial environments remains challenging due to the high cost of industrial 3D sensors and the typical requirement of structured-light projectors. We present Pickalo, a modular pipeline designed to reduce the setup complexity of industrial bin-picking by leveraging 6D pose estimation and deep stereo matching. To maximize scene coverage, a wrist-mounted RGB-D camera actively explores the bin from multiple viewpoints. At each viewpoint, raw stereo streams are processed using BridgeDepth to obtain refined depth maps suitable for accurate collision reasoning. Object instances are segmented with a Mask-RCNN model trained on photorealistic synthetic data and localized using the zero-shot SAM-6D pose estimator. A pose buffer module fuses the observations over time, handling object symmetries and reducing pose noise. Offline, we generate and curate large sets of antipodal grasp candidates per object, while online, a utility-based ranking and fast collision checking are queried for the grasp planning. Deployed on a UR5e with a parallel-jaw gripper and an Intel RealSense D435i, Pickalo achieves up to 600 mean picks per hour with 96–99% grasp success over 30 min runs on densely filled euroboxes. Ablation studies demonstrate the benefits of enhanced depth estimation and of the pose buffer for long-term stability and throughput in realistic industrial conditions.

1. Introduction

Despite decades of research, bin picking remains a central challenge in industrial automation. The task requires a robot to detect, localize, and extract objects from a cluttered container under varying object poses. Conventionally, bin-picking systems adopt classical vision techniques such as 2D–3D feature matching, template matching, and vote-based pose estimation [1,2,3,4,5]. These approaches are either not robust enough or assume access to high-quality depth data, typically obtained from industrial-grade stereo cameras. Such sensors produce dense point clouds with rich geometric detail, enabling registration algorithms to reliably align object models with observations, even under partial occlusion. However, these industrial-grade sensors require a complex and expensive setup, posing a barrier to user adoption.

Transformer-based architectures paved the way for bin-picking applications with lower-fidelity sensors and less constrained environments [6,7,8]. The latest foundation models for pose estimation [9,10,11] have demonstrated strong generalization to unseen object categories with minimal task-specific setup. On the other hand, deep stereo matching models [12,13,14] aim to reconstruct accurate depth images, effectively narrowing down the gap between consumer-grade cameras and specialized high-end hardware.

As the performance of pose estimation algorithms is highly dependent on the depth quality [15,16], in this work, we focus on enhancing the quality of the depth input. Furthermore, we propose a pose buffer mechanism to increase the robustness of pose estimation and prove that consumer-grade cameras can be adopted in industrial bin picking without sacrificing performance.

The presented grasping pipeline follows a modular architecture, favoring available open-source packages when possible. Accuracy and timing constraints imposed by an industrial bin-picking application are explicitly considered. We conduct extensive and realistic evaluations across three different classes of objects. Moreover, we evaluate the robustness of our solution under industrial operating conditions, adopting standard eurobox bins loaded at their nominal capacity. Figure 1 illustrates the experimental setup adopted for the experiments. Key contributions of this paper are:

Figure 1. The experimental setup consists of a UR5e manipulator with a consumer-grade camera attached to the wrist. The bin is a standard eurobox heavily filled with small metallic objects.

• System integration: We design a modular bin-picking system that integrates consumer-grade RGB-D sensing with existing depth-enhancement and zero-shot 6D pose-estimation foundation models, together with perception-aware grasp planning.
• New mechanism: We propose the pose buffer, a temporal multi-view pose-fusion mechanism that associates observations across viewpoints, explicitly accounts for object symmetries, and filters unconfirmed estimates. It improves pose consistency and accuracy under occlusion. The pose buffer internally builds the estimated state of the bin, retaining information regarding the multi-view consistency of poses and the presence of objects not visible from the current point of view.
• Experimental validation: We provide ablation studies of depth enhancement and pose buffer and validate the full system in highly cluttered industrial bin-picking experiments over extended operating cycles, achieving 96–99% picking success across the evaluated objects.

Videos are available at https://mesh-iit.github.io/project-jl2-camozzi/ (accessed on 10 October 2026).

2. Related Works

This section reviews state-of-the-art methods for robotic bin picking. We analyze their strengths and limitations with respect to industrial constraints such as clutter, sensor cost, and deployment complexity.

2.1. Grasp Detection Algorithms

Grasp detection approaches aim to directly predict feasible grasp poses for a robot gripper from sensor input. As they bypass explicit object modeling and can be trained to map sensor data directly to grasp poses, end-to-end grasp detection methods are particularly attractive in cluttered, variable bin-picking settings. Bui et al. [17] present a network that generates six-DoF antipodal grasps from a point cloud of a cluttered bin, using a convolutional neural network (CNN) to identify and rank possible grasp poses. Sun et al. [6] propose a grasp detection framework that performs industrial bin picking using a low-cost sensor. Fang et al. [18] take a different approach with AnyGrasp, which fuses spatial and temporal information to improve grasp robustness across sequential frames. Despite the promising results, all these solutions were tested in simplified cases that do not resemble industrial scenarios. In addition, the goal of these methods is usually to find any stable grasp, which is insufficient when the downstream task demands a specific pickup orientation for quality control or precise placement. This motivates our decision to choose an alternative strategy based on the full six-DoF pose estimation of the objects.

2.2. 6D Object Pose Estimation

Explicitly estimating object poses provides a clearer and more comprehensive description of the bin’s state, which can be leveraged to plan grasps more effectively. In particular, explicit pose estimation allows pose refinement over time and outlier detection based on time consistency.

Convolution Neural Networks have proven to be effective for 6D pose estimation [19,20,21]. Li et al. [22] integrated the CNN-based pose estimator proposed in [23] to grasp texture-less metallic parts relying solely on simulation data. Their sim-to-real pipeline (S2R-Pick) automatically renders photorealistic scenes, producing a vast labeled dataset for training. However, the dependence on large training datasets hinders the usability and scalability of this solution. Foundation models [9,10,11], on the other hand, can perform zero-shot pose estimation and do not require a training step when the target object is changed, facilitating their adoption. Our grasping pipeline is based on SAM-6D [11], an open-source, versatile, and lightweight foundation model to estimate poses of novel objects.

2.3. Multi-View Consistency and Depth Quality

Industrial objects are often metallic and textureless, posing a problem for consumer-grade depth cameras. For this reason, structured-light projectors and expensive optical systems are typically employed to mitigate depth degradation caused by light reflections. Recent works [15,24] have proposed adopting multi-view strategies to improve the quality of the perceived depth. However, in this work, we prove emerging foundation models for deep stereo matching are simpler and more effective. BridgeDepth by Guan et al. [14] bridge monocular and stereo depth estimation, aligning context information given by mono-depth estimation with classical stereo disparity to produce dense and accurate depth maps. During our experiments, we observed that adopting BridgeDepth reduced depth noise and reflection-related problems, increasing the number of detected objects and reducing the collisions caused by the presence of unseen objects. Furthermore, in contrast to multi-view acquisition, deep stereo matching does not increase the complexity of the acquisition scheme in terms of robot motion and precise camera synchronization. To keep pose estimation consistent across time, we employ a pose buffer module (Section 3.4), that handles object symmetries as done in [25]. In [26], a multi-view approach was adopted before each grasp attempt to mitigate the risk of object miss-detection. In our solution, instead, we enforce multi-view consistency across multiple grasping iteration while the system operates. The presented approach allows Pickalo to reach a mean pick per hour (MPPH) of 600 objects, with a success rate over $96\%$ in dense clutter using only a consumer-grade camera.

3. Methodology

Our approach is illustrated in Figure 2. The pipeline presents a modular architecture that adopts state-of-the-art perception models and proposes simple but effective solutions for industrial bin picking. In this section, we illustrate the key components of our architecture and the reasons behind their success.

Figure 2. Overview of the presented pipeline. A stereo-pair image is acquired and processed by the depth estimation block to obtain an enhanced depth reconstruction. The resulting depth is aligned to the left RGB frame and provided to the 6D pose estimation model, together with the object CAD model. The scene state is reconstructed by combining pose estimates across multiple views, occupied voxels, and static objects. An example of the scene representation is shown in the top-right corner. Given the scene state, the grasp planning ranks and tests pre-computed grasp annotations to find a collision-free grasping trajectory.

3.1. Pose Camera Selection

In contrast to classical industrial scenarios relying on fixed cameras, we adopt an eye-in-hand camera mounted on the robot’s wrist. In our experience, viewpoint variation helps to mitigate occlusion and ensure full bin scanning coverage. We employ a strategy that samples camera poses, at optimal sensor distance, from a hemisphere centered at the bin origin. To ensure uniform coverage and viewpoint variability, reachable camera poses are ordered, maximizing the distance from previously selected viewpoints.

3.2. Depth Map Acquisition

Standard RGB-D sensors often produce inaccurate depth maps, especially in the presence of reflective metallic objects [24]. To address this problem, we adopt BridgeDepth, a lightweight deep stereo matching framework that merges the advantages of stereo matching with the context understanding of monocular depth estimation [14]. Our experiments demonstrate that BridgeDepth produces sufficiently accurate depth maps and is robust to variations in lighting conditions. A qualitative depth comparison is shown in Figure 3. Moreover, being open source and with a striking accuracy-runtime trade-off, BridgeDepth is a perfect candidate for our grasping pipeline. To the best of our knowledge, this work is the first one to test the effect of deep stereo matching on an industrial bin-picking scenario.

Figure 3. RealSense on the (left). BridgeDepth on the (right).

BridgeDepth outperforms alternatives, such as the multi-view acquisition proposed in [24], in which a more accurate depth map was reconstructed from multiple depth images and a per-pixel voting system. In our experiments, multi-view depth estimation proved to be slower, due to the extra robot motion, and less accurate, as it targeted reflection inaccuracies without improving general depth quality.

3.3. 6D Object Pose Estimation

Object pose estimation (OPE) is the core element of our robotic bin-picking applications. Our perception pipeline is based on SAM-6D [11], an open-source approach for 6D pose estimation of unseen objects. Due to the time constraints imposed by the industrial requirements, the original implementation of SAM6D was adapted as described below.

Instance Segmentation. SAM-6D is based on Segment Anything Model [27], a zero-shot foundation model for instance segmentation that, despite its generalization capabilities, proves to be too slow for industrial purposes. As runtime performance is key in industrial scenarios, we substituted the instance segmentation model with a custom Mask R-CNN backbone. This choice makes an upfront training step required for the segmentation backbone. To facilitate usability, we created an automated pipeline that, starting from the CAD model, generates a training dataset using BlenderProc [28] and trains the Mask R-CNN backbone [29]. Starting from each CAD model, our automated BlenderProc pipeline generates approximately 1000 synthetic images per object class. For each scene, multiple instances are initialized at random positions and orientations above the bin and allowed to settle under gravity, producing physically plausible poses, dense stacking, and occlusions. The Mask R-CNN model with a ResNet50 backbone is fine-tuned for 20 epochs using SGD as optimizer, a learning rate of 0.00125, a batch size of 8 and an input resolution of (640, 480).

Pose Estimation. We adopted the same pose estimation module presented in SAM-6D, as our experiments proved this method to be reliable, fast, and accurate. However, to improve the effectiveness of the system under severe clutter, we introduced a simpler but effective pose rejection filter.

Pose Rejection Filter. The pose rejection filter verifies whether an estimated object pose is physically consistent with the observed depth data. Let $B{B}_c=(u_c,v_c)$ be the center of a bounding box in the image plane and $z_{mean}$ the mean depth value of pixels within the corresponding segmentation mask. We project the bounding box center into 3D space using the camera matrix K:

$${}^{c}t_{\mathit{BB}}=z_{mean}{K}^{-1}{\left[u_c,v_c,1\right]}^T$$

(1)

${}^{c}t_{\mathit{BB}}$ expresses the mean distance of the visible part of the object perceived by the depth image. Let ${}^{c}t_{\mathit{obj}}$ be the translation vector of the estimated centroid of the object expressed in the camera frame. A pose candidate is rejected if:

$$∥{}^{c}t_{\mathit{BB}}∥<∥{}^{c}t_{\mathit{obj}}∥.$$

(2)

where $∥·∥$ represents the Euclidean norm. The pose rejection filter effectively removes estimated poses for which the segmented point cloud is matched with the rear surface of the object, leading the estimated pose to be closer to the camera than the observed depth map. During experiments, this error was observed any time an object buried in the bin was surrounded by neighbor objects, causing the model to mistakenly consider the lateral faces of the neighbors as the lateral faces of the target object.

3.4. Pose Buffer

To create a consistent scene representation relying on the imperfect pose estimations, we introduce the pose buffer. The pose buffer is a temporal buffer that associates pose estimates of the same object across multiple views over different time instances. Let ${}^{w}H_i^k\in SE\left(3\right)$ be the homogeneous transformation describing the pose of object i at iteration k in the world frame. For simplicity, we denote ${}^{w}H_i^k$= $p_i^k=(R_i^k,t_i^k)$.

Pose Averaging. The pose buffer aggregates a history of estimates $\{p_i^0,\dots ,p_i^k\}$ and computes a more robust pose estimate ${\widehat{p}}_i$ using Euclidean and quaternion averaging [30] for translation and rotations, respectively.

Data Aggregation. An incoming pose $p^k=(R^k,t^k)$ is associated with an existing object i in memory if:

$$\begin{array}{cc}\hfill {\cos }^{-1}\left((Tr(R^k{\widehat{R}}_i^T)-1)/2\right)& <{\theta }_{thresh}\hfill \\ \hfill {∥t^k-{\widehat{t}}_i∥}_2& <{\delta }_{thresh}\hfill \end{array}$$

(3)

where ${\widehat{p}}_i=({\widehat{R}}_i,{\widehat{t}}_i)$ is the estimated pose of object i at the current state, $Tr(·)$ is the trace operator, and ${\theta }_{thresh}$ and ${\delta }_{thresh}$ represent the maximum angular and Euclidean distances, respectively. In our experiments, we used 10 degrees and $0.0075$ meters as values for ${\theta }_{thresh}$ and ${\delta }_{thresh}$, respectively.

Object Symmetries. The handling of the object symmetries draws inspiration from the work done in [25,31]. We define $\mathcal{R}(l,p)$ as the visual appearance of object l rendered in pose p. The symmetry group $S\left(l\right)$ is defined as the set of transformations that leave the visual appearance invariant:

$$S\left(l\right)=\{S\in SE(3)\mid \forall p,\mathcal{R}(l,p)=\mathcal{R}(l,S·p\left)\right\}$$

(4)

$S\left(l\right)$ is automatically computed offline starting from the object’s model. In particular, we rotate the vertices composing the object’s mesh around its axes and verify whether the resulting cloud of vertices is identical to the initial one.

To find out if a new pose estimate $p^k$ matches one of the m previously detected object poses present in the memory, the system checks if:

$$\begin{array}{cc}\hfill \exists i& \in \{0,\dots ,m-1\},S\in S\left(l\right)\mathrm{such}\mathrm{that}\hfill \\ \hfill & \mathcal{R}(l,{\widehat{p}}_i)=\mathcal{R}(l,S·p^k)\hfill \end{array}$$

(5)

If a match is found, the new pose $p^k$ is added to the list of previous estimates $\{p_i^0,\dots ,p_i^{k-1}\}$ of object i, and ${\widehat{p}}_i$ is updated.

Pose validation. The pose buffer exposes only the pose estimates linked to objects observed in the latest iteration, and for which there are at least two sample observations. In addition, pose estimates are subject to invalidation if new observations do not confirm the presence of the object. These mechanisms ensure that the poses used in downstream tasks are reliable and up-to-date, e.g., they have not been invalidated during the latest object extraction.

3.5. Scene Representation

The system combines the information coming from the pose buffer and the depth estimation to build an accurate bin state representation. This representation is composed of:

• Target Objects: The mesh of the objects of interest at their estimated locations according to the pose buffer.
• Static Objects: Whose poses are determined through an initial calibration, such as the table and the bin.
• Occupied Voxels: Regions of space detected as occupied by the estimated depth but not associated with the former two categories.

The scene representation is used by the grasp planning to access the validated pose estimates, to access the collision information, and to generate valid grasping trajectories.

3.6. Grasp Planning

From each estimated object pose, we test possible offline-generated grasp candidates, which are then converted into collision-free robot trajectories for object extraction.

Grasp planning is divided into three stages: offline generation of grasp candidates, online ranking, and collision check.

Generation of Grasp Candidates. Grasp candidates are generated offline for each object category to create a database of feasible end-effector poses. The generation process draws inspiration from [32] and follows a geometry-driven approach:

• Antipodal Sampling: We specify a target number N of grasp candidates. The algorithm samples points on the object’s mesh surface and performs ray-tracing along the direction of the surface normals. A pair of points is considered a candidate for grasping if their normals are antipodal within a specified angular tolerance, ensuring a stable force-closure grasp.
• Frame Definition: For every identified antipodal pair, the corresponding gripper pose is computed. The closing axis is defined by the line connecting the contact points. The approach vector is constrained to be orthogonal to the closing axis and oriented outward, away from the object’s geometric center.
• Mesh Collision Check: Finally, the algorithm validates the candidate pose against the specific geometry of the gripper. We perform a collision check between the CAD model of the gripper fingers and the object mesh. To ensure a collision-free approach, candidates resulting in an intersection between the gripper and the object are discarded.

The resulting dataset of generated grasp candidates can be easily inspected and manually refined to accommodate specific industrial needs.

Grasp Ranking Strategy. During the online phase, we instantiate candidate grasps for every detected object instance. Since checking inverse kinematics (IK) and collisions for thousands of candidates is computationally expensive, we rank the candidates to prioritize those most likely to succeed. We define a utility score $S\left(g\right)$ for a grasp g, computed as a weighted sum of four metrics:

$$S\left(g\right)=w_1{S}_{align}+w_2{S}_{yaw}+w_3{S}_{conf}+w_4{S}_{height}$$

(6)

where $w_1,w_2,w_3,w_4$ are weights in $[0,1]$, and their sum is equal to 1.

• Vertical Alignment ($S_{align}$): We prioritize grasps where the approach vector aligns with gravity. Let $z_{ee}$ be the gripper’s approach vector expressed in the world frame and $z_g$ the gravity unit vector.

  $$S_{align}={\displaystyle \frac{1+z_{ee}·z_g}{2}}$$

  (7)
  This term is maximized when the gripper approaches the object vertically downwards.
• Yaw Deviation ($S_{yaw}$): We penalize the rotation of the gripper around the vertical axis to minimize the motion of the wrist joint. This is computed similarly to $S_{align}$ but compares the gripper’s lateral axis against the bin’s principal axis.
• Pose Confidence ($S_{conf}$): A normalized score derived from the pose buffer, prioritizing objects detected with higher certainty.
• Stacking Height ($S_{height}$): A normalized height value, prioritizing objects on top of the pile to minimize possible collisions.

Collision Check. Given the ranked list of grasping poses, we want to generate a collision-free trajectory to extract the target object. To ensure safety while maintaining a high success rate, the collision check module implements a two-stage hierarchical validation process:

• Static Pose Validation: The system first verifies if the robot can reach the target grasp configuration without any collisions. In this stage, all collision constraints are active. The robot must not collide with the bin, the objects, or the occupied voxels. If this check fails, the grasp candidate is immediately discarded.
• Full Trajectory Validation: For candidates passing the static check, a motion planner generates a path to reach and extract the target object. During this phase, strict collision checking is maintained against the static environment (bin and table). However, collision constraints with occupied voxels are relaxed. This modification allows the gripper to slightly touch neighboring objects while reaching the target grasp pose. Given the nature of the metallic objects we are dealing with, we deem occasional incidental contacts acceptable.

Experimental data demonstrate that if a valid solution exists, it is found within the top $18\%$ of the ranked grasps in $99\%$ of the cases. Based on this observation, we evaluate only the top $18\%$ percent of the ranked list. If no solution is found within this subset, the system marks the current scene as unfeasible for immediate grasping and triggers a re-acquisition routine from a new viewpoint. If a feasible trajectory is found, the search is terminated, and the joint trajectory is sent to the robot controller, which executes it in open loop.

During execution, failures are monitored through the position and velocity of the gripper’s fingers. If slippage is detected, the robot retracts, the bin state is updated to reflect the failed attempt, and the pipeline restarts with a new acquisition.

Figure 4 and Figure 5 present, respectively, an example of the value of the utility score $S\left(g\right)$ for a selected subset of grasps and the subsequent collision check that verifies trajectory validity from the highest ranked grasp to the lowest until a successful grasp is correctly found.

Figure 4. Example of various grasping poses with the corresponding utility scores $S\left(g\right)$ given in percentage. The grasping poses are sorted in descending order.

Figure 5. The sorted grasp poses are checked following the ranking order until a feasible grasp pose is found. Grasp poses leading to a collision are discarded.

3.7. Masked Time

To reduce idle time in our system, we distribute tasks across multiple threads. The robot motion is parallelized to the perception and planning phase, as illustrated in Figure 6. The camera acquisition determines the beginning of a new iteration k. The incoming new image is passed to the object pose estimation block, while the robot executes the grasping trajectory computed at the previous iteration step. During the robot motion, once the estimated poses become available, the scene representation is updated, and the grasp planner is triggered. At the end of the release phase, the robot acquires a new image, and a new cycle begins.

Figure 6. The grasping pipeline is parallelized to elaborate the perception and planning blocks for the current iteration, while the robot executes the grasping and releasing trajectories computed at the previous iteration.

4. Experiments

4.1. Experimental Setup

The experimental testbed consisted of the hardware components listed below. While specific models are detailed for reproducibility, the pipeline’s modular design enables the substitution of alternative components. Interestingly, the system has already been tested on a platform with reduced computational power, which caused a minor impact on the cycle time due to masked time that leverages the robot motion to compensate for computational delays.

• Manipulator: Universal Robots UR5e (6-DoF).
• Camera: Intel RealSense D435i depth camera.
• Computing: Intel Core i9 (14th Gen), 128 GB RAM, and RTX 4090 GPU.

The system validation mirrored the actual complexity of industrial scenarios. Our setup was tested with no constraints on the bin state or ambient illumination, and against arbitrarily full containers. This approach addresses a gap in the literature, where methods are often tested on sparse scenes, with fixed lighting, or without standard bins, effectively bypassing the complexities of object occlusion and environmental variability. As illustrated in Figure 7, we used three sets of industrial components featuring highly reflective surfaces and complex geometries.

Figure 7. Test objects used in the evaluation: (A) square, (B) cylindrical, and (C) complex geometry.

4.2. Grasp Pipeline Performance

To quantitatively evaluate the system’s operational efficiency and grasp reliability, we adopted the following set of performance metrics:

• Mean Picks per Hour (MPPH): A standard metric to evaluate system throughput.
• Success Rate (SR): The percentage of successful grasp executions over the total grasping attempts. We considered a grasp to be successful if the object was safely grasped from the source bin and released in the target bin, regardless of its final pose.
• Early Exit Rate (EER): The percentage of iterations where execution halted because no valid, collision-free grasp candidate could be identified.

Table 1 summarizes the results over 1000 pipeline iterations. The system maintains high throughput (MPPH) and very high reliability ($\mathrm{SR}>96\%$) across all categories; however, object geometry influences performance.

Table 1. Performance metrics across object categories (1000 iterations).

Obj.	MPPH	SR (%)	EER (%)
A	577.85	98.84	4.22
B	615.89	97.73	0.62
C	611.83	96.12	2.98

Object A (square) offers stable grasp poses for a parallel-jaw gripper, resulting in a high SR. However, its shape causes objects to stack tightly, occluding collision-free approach vectors and leading to a higher EER. In contrast, Object B (cylindrical) resists stacking, resulting in a minimal EER, though the curved surface offers slightly less grasp stability. Finally, Object C represents the most challenging case due to its weight and complex geometry; while it offers many potential grasp poses, the limited contact surface area in certain grasping configurations results in a lower overall success rate.

4.3. Ablation Study

To validate the individual contributions of specific components within our pipeline, we conducted an ablation study focusing on two key aspects: the depth estimation method and the impact of the pose buffer.

Depth Estimation. We compared the performance of raw depth input from the Intel RealSense D435i against the BridgeDepth method using Object B over three duration intervals (5, 10, and 30 min). The results are summarized in Table 2.

Table 2. Ablation: RealSense Depth (RS) vs. BridgeDepth (BD). Best result for each time interval is shown in bold.

Time	Method	MPPH	SR (%)	EER (%)
5 min	RS	629.9	96.9	0.9
	BD	615.9	97.7	0.6
10 min	RS	605.4	92.7	1.6
	BD	621.6	97.7	0.3
30 min	RS	557.5	88.5	4.9
	BD	598.3	96.3	2.4

The RealSense baseline exhibits slightly higher throughput (MPPH) during the first 5 min, primarily due to the absence of model inference latency. However, it suffers from significant performance degradation over longer durations. By the 30 min mark, the RealSense success rate (SR) drops to 88.5%, while the Early Exit Rate (EER) reaches 4.9%. This degradation is attributed to the lower quality of the raw depth, which contains holes and artifacts. These inconsistencies lead to missed object detections and erroneous collision checks (higher EER), as well as inaccurate pose estimations (lower SR). In contrast, BridgeDepth demonstrates superior long-term stability. At 30 min, it maintains an SR of 96.3% compared to 88.5% of the baseline.

Pose Buffer. To measure the specific impact of the pose buffer module, we analyzed the system while enabling or disabling the pose buffer module; we named the two conditions “With Memory” and “No Memory”, respectively.

For the study we adopted the XYZ-IBD dataset [33]. The XYZ-IBD dataset shares similarity with our setup, such as multiple identical textureless industrial parts, dense clutter, and ambiguous object appearances. First, we evaluated the accuracy of the pose estimation using object class “000010”. This object closely resembles the industrial objects used in our experiments. We estimated the poses of the object instances across 50 images without the temporal buffer, calculating the average translation and rotation errors relative to the ground truth. We then repeated the test, enabling the temporal buffer, and fusing pose estimates from different viewpoints as described in Section 3.4. The translation and rotation errors were computed using the same distance metrics introduced in the pose buffer association condition (Equation (3)). As shown in Figure 8, the pose buffer reduces both the pose average error and the standard deviation.

Figure 8. Error distribution of the object pose estimation, enabling and disabling the pose buffer module. The translation and angular error represent the average distance between the estimated pose and the ground truth pose given by the XYZ-IBD dataset.

Next, we compared the full pipeline performance using Object B over three time intervals (5, 10, and 30 min). The results, shown in Table 3, highlight the critical role of the pose buffer in optimizing grasp execution.

Table 3. Ablation: No Memory (NM) vs. With Memory (WM). Best result for each time interval is shown in bold.

Time	Method	MPPH	SR (%)	EER (%)
5 min	NM	565.3	86.8	0.0
	WM	615.9	97.7	0.6
10 min	NM	557.9	84.9	0.0
	WM	621.6	97.7	0.3
30 min	NM	553.9	84.2	0.0
	WM	598.3	96.3	2.4

The inclusion of the temporal buffer module consistently boosts performance, increasing MPPH by 10–12% and the success rate by 11–13 percentage points. Notably, the “No Memory” configuration exhibits a near-zero Early Exit Rate, which is a direct consequence of our scoring criteria. When the module is active, an object is only considered graspable if it has been estimated at least twice, including in the most recent iteration. Conversely, without memory, every pose estimation is immediately treated as a potential grasp. Consequently, while the “No Memory” system attempts to grasp more objects (yielding a lower Early Exit Rate), it encounters significantly more errors. This results in a lower success rate (84–87%) compared to the system with memory (>96%), which successfully filters out unreliable attempts.

4.4. Bin-Emptying Performance

Finally, we performed an in-depth analysis of the performance of our system over time, emptying the bin. We conducted 30 independent runs, each lasting 30 min on Object B. Every run began with a bin filled with approximately 350 objects. To evaluate the pipeline’s performance relative to the bin’s level, we recorded the system’s state every 5 min. The experimental data are presented in the following figures, organized into three subplots. Each subplot’s data are segmented into 5 min intervals, resulting in six violin plots. Each plot visualizes the distribution of the 30 data points (one from each experimental run) and integrates the median value.

Figure 9 shows the high performance of our pipeline, which achieves a median of 600 MPPH and a 97% success rate even after 30 min. The plots also clearly illustrate how these metrics change in relation to the bin’s fill level. As mentioned, we started with approximately 350 objects in the bin. A pick rate of 600 picks per hour means that approximately 300 objects were removed during each run, almost emptying the bin. Both the MPPH and EER plots show that performance worsens over time, particularly in the last 10 min and even more so in the final 5. This is because the objects remaining at the end are usually harder to grasp due to their location near the bin’s borders, which are difficult for our gripper to access, due to its size. This difficulty significantly increases the Early Exit Rate and consequently decreases the MPPH. The success rate also decreases slightly, as the grasps attempted in these final-stage scenarios are inherently riskier.

Figure 9. Experimental result s showing the performance of the pipeline, recorded at intervals of five minutes.

5. Conclusions

Pickalo addresses the challenge of deploying high-throughput and cost-effective bin picking in realistic industrial conditions. The combination of multi-view scene reconstruction, 6D pose estimation, and depth enhancement proved to be effective in reconstructing the content of the bin, enabling seamless grasp planning and accurate collision avoidance. Ablation studies confirmed that both the pose buffer module and the depth processing played key roles in the system’s reliability. Across the three evaluated object categories, the system achieved grasp success rates ranging from $96\%$ to $99\%$, with approximately 600 mean picks per hour. During the 30 min bin-emptying experiments, Pickalo maintained a median grasp success rate of $97\%$, demonstrating stable performance as the bin approached an almost empty state. The ablation studies further confirmed that BridgeDepth and the pose buffer improve both grasp reliability and throughput. The modularity of the approach allows inspection of partial results of each module, facilitating tracking of potential errors during deployment. Finally, modularity also enables improvement of the pipeline as better foundation models become available.