error in image callback: 'dict' object has no attribute 'name'

[haniraid]

Hi evrybody. so im trying to creat a node and run Zoedepth using robomaster s1 monocular camera. the robot is connected and evrything is set and the script is like below, notice that im using torch==2.4.1 ubuntu 20.04 timm==0.6.13 but running the script im getting this error self.zoe.load_state_dict(torch.load(weights_path, map_location=self.DEVICE), strict=False) [INFO] [1726359598.098118317] [depth_estimation_node]: Weights loaded from /home/raidhani/ros2_ws/src/MiDaS/weights/dpt_large_384.pt [INFO] [1726359598.105714726] [depth_estimation_node]: Received image with dimensions: (360, 640, 3) [INFO] [1726359598.108058095] [depth_estimation_node]: Resized image to: (384, 512, 3) [ERROR] [1726359603.679989582] [depth_estimation_node]: Error in image callback: 'dict' object has no attribute 'name' [INFO] [1726359603.681861777] [depth_estimation_node]: Received image with dimensions: (360, 640, 3) [INFO] [1726359603.683620926] [depth_estimation_node]: Resized image to: (384, 512, 3)

script used: #!/usr/bin/env python3

import rclpy from rclpy.node import Node from sensor_msgs.msg import Image from cv_bridge import CvBridge import cv2 import torch from PIL import Image as PilImage import json from zoedepth.utils.misc import colorize from zoedepth.models.zoedepth_nk.zoedepth_nk_v1 import ZoeDepthNK

class DepthEstimationNode(Node): def init(self): super().init('depth_estimation_node')

    # Set up a subscriber to the camera topic
    self.subscription = self.create_subscription(
        Image,
        '/camera/image_color',
        self.image_callback,
        10)
    self.subscription

    # Create a cv_bridge object for converting ROS images to OpenCV format
    self.bridge = CvBridge()

    # Force CPU usage
    self.DEVICE = "cpu"
    
    # Path to the configuration file
    config_path = "/home/raidhani/ZoeDepth/zoedepth/models/zoedepth_nk/config_zoedepth_nk.json"
    weights_path = "/home/raidhani/ros2_ws/src/MiDaS/weights/dpt_large_384.pt"
    
    # Load the JSON config
    try:
        with open(config_path, 'r') as f:
            config = json.load(f)
            self.get_logger().info(f"Successfully loaded config from {config_path}")
    except FileNotFoundError:
        self.get_logger().error(f"Configuration file not found at {config_path}")
        return

    # Extract model configuration and debug the contents
    try:
        model_conf = config.get('model', None)
        if not model_conf:
            raise ValueError(f"Model configuration not found in {config_path}")
        
        self.get_logger().info(f"Raw model configuration: {model_conf}")

        # Ensure 'bin_conf' contains valid entries and log each entry
        valid_bin_conf = []
        for conf in model_conf['bin_conf']:
            if isinstance(conf, dict):
                if 'name' in conf:
                    self.get_logger().info(f"Valid bin_conf entry found: {conf}")
                    valid_bin_conf.append(conf)
                else:
                    self.get_logger().error(f"Invalid entry (missing 'name'): {conf}")
            else:
                self.get_logger().error(f"Invalid bin_conf entry (not a dict): {conf}")
        
        if not valid_bin_conf:
            raise ValueError(f"No valid 'bin_conf' entries found in {config_path}")

        # Update model configuration with valid bin_conf
        model_conf['bin_conf'] = valid_bin_conf
        self.get_logger().info(f"Filtered model configuration: {model_conf}")
    except (KeyError, ValueError) as e:
        self.get_logger().error(f"Error processing model configuration: {e}")
        return

    # Build the model using the valid model configuration
    try:
        self.zoe = ZoeDepthNK.build(bin_conf=model_conf['bin_conf']).to(self.DEVICE)
        self.get_logger().info("Model successfully built.")
    except KeyError as e:
        self.get_logger().error(f"Missing key in model configuration: {e}")
        return
    except Exception as e:
        self.get_logger().error(f"Error building the model: {e}")
        return

    # Load the weights into the model with strict=False to ignore mismatches
    try:
        self.zoe.load_state_dict(torch.load(weights_path, map_location=self.DEVICE), strict=False)
        self.get_logger().info(f"Weights loaded from {weights_path}")
    except FileNotFoundError:
        self.get_logger().error(f"Weights file not found at {weights_path}")
        return
    except RuntimeError as e:
        self.get_logger().error(f"Error loading weights: {e}")
        return

def image_callback(self, msg):
    # Ensure that the model has been built before processing images
    if not hasattr(self, 'zoe'):
        self.get_logger().error("Model has not been initialized.")
        return

    try:
        # Convert ROS image to OpenCV format
        cv_image = self.bridge.imgmsg_to_cv2(msg, desired_encoding='rgb8')
        self.get_logger().info(f"Received image with dimensions: {cv_image.shape}")

        # Resize image
        target_size = (512, 384)
        cv_image_resized = cv2.resize(cv_image, target_size)
        self.get_logger().info(f"Resized image to: {cv_image_resized.shape}")

        # Convert to PIL image
        pil_image = PilImage.fromarray(cv_image_resized)

        # Run depth inference
        depth_numpy = self.zoe.infer_pil(pil_image)

        # Colorize depth for visualization
        colored_depth = colorize(depth_numpy)

        # Show the depth image
        cv2.imshow("Depth", colored_depth)
        cv2.waitKey(1)

    except Exception as e:
        self.get_logger().error(f"Error in image callback: {e}")

def main(args=None): rclpy.init(args=args) try: depth_estimation_node = DepthEstimationNode() rclpy.spin(depth_estimation_node) except Exception as e: print(f"Error running the node: {e}") finally: rclpy.shutdown()

if name == 'main': main()

[TZECHIN6]

Are you trying to transform a normal RGB camera to RGBD camera? and use it in ros2 environment?

Below is my workflow, and I am trying to implement it:

1. Capture RGB images from your camera.
2. Generate a depth map using an AI model.
3. Convert the RGB and depth data into a PointCloud2 message.
4. Publish the message in ROS2.

just come across this depth estimation model.