Partage de technologie

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Effet de test

Caméra à lumière structurée Mech-Mind

Les caméras à lumière structurée de Mech Mind, en particulier la série Mech-Eye, sont des caméras 3D de haute précision de qualité industrielle qui sont largement utilisées dans l'automatisation industrielle, la navigation robotisée, l'inspection qualité et d'autres domaines. Ce qui suit est une analyse détaillée de la caméra à lumière structurée Mech Mind :

1. Présentation du produit

Les caméras à lumière structurée de Mech Mind, telles que Mech-Eye PRO, utilisent une technologie de lumière structurée à grande vitesse pour offrir une excellente résistance à la lumière ambiante tout en conservant une précision et une vitesse élevées. Ces caméras contiennent généralement de riches modules d'algorithmes de vision et peuvent être appliquées à de nombreux scénarios pratiques typiques, tels que le chargement et le déchargement de pièces de fabrication, le positionnement de haute précision, l'assemblage, le serrage de vis et la recherche universitaire.

2. Principe de fonctionnement

La caméra à lumière structurée de Mech Mind utilise principalement le principe de projection de lumière structurée. Ils projettent des motifs spécifiques (tels qu'une lumière structurée générée par des lasers) sur l'objet photographié, et le contour et la forme de l'objet sont capturés par l'appareil photo. Cette technologie permet de calculer avec précision la position et la forme d'un objet en analysant la réflexion et la réfraction de la lumière sur l'objet.

3. Caractéristiques du produit

1. Haute précision : La caméra à lumière structurée de Mech Mind peut obtenir des modèles tridimensionnels de haute précision en peu de temps. Pour différents objets, des informations de forme précises peuvent être obtenues en une seule prise. Par exemple, la répétabilité en un seul point dans la direction Z du Mech-Eye PRO peut atteindre 0,05 mm (à 1,0 m).
2. grande vitesse: La caméra dispose de capacités d'acquisition et de traitement de données rapides. Par exemple, le temps d'acquisition typique de Mech-Eye PRO est de 0,3 à 0,6 seconde.
3. Grand champ de vision et grande profondeur de champ: Certains modèles, tels que la caméra 3D Mech-Eye Deep, ont les caractéristiques d'un grand champ de vision et d'une grande profondeur de champ, et peuvent être appliqués à une variété de types d'empilement courants.
4. Forte résistance à la lumière ambiante: La caméra à lumière structurée de Mech Mind peut toujours conserver d'excellents effets d'imagerie sous de fortes interférences de lumière ambiante (telles que > 20 000 lx).
5. Déploiement flexible: La caméra est adaptée à la plupart des grandes marques de robots au pays et à l'étranger, et peut réaliser un contrôle complet du mouvement des robots adaptés.
6. Ouvert et facile à utiliser: La caméra fournit une interface utilisateur conviviale et une API ouverte pour faciliter le développement et l’intégration secondaires des utilisateurs.
7. Stable et fiable: Les caméras à lumière structurée de Mech Mind ont une stabilité et une fiabilité élevées, comme le temps moyen entre pannes (MTBF) de Mech-Eye PRO ≥ 40 000 heures.

4. Domaines d'application

Les caméras à lumière structurée de Mech Mind sont largement utilisées dans les domaines de l'automobile, de l'aviation, de la fabrication de moules, de l'automatisation industrielle et dans d'autres domaines. Dans le domaine automobile, ils peuvent obtenir rapidement et avec précision les informations sur la forme de la surface de la carrosserie ; dans le domaine de l'aviation, ils peuvent obtenir les informations sur la forme tridimensionnelle de l'avion, fournissant ainsi un support de données précis pour la conception et la fabrication de l'avion. .

5. Résumé

Les caméras à lumière structurée de Mech Mind jouent un rôle important dans des domaines tels que l'automatisation industrielle et la navigation robotique en raison de leur haute précision, de leur vitesse élevée, de leur grand champ de vision, de leur grande profondeur de champ, de leur forte résistance à la lumière ambiante, ainsi que de leur stabilité et de leur fiabilité. Avec l’avancement continu de la technologie et l’expansion continue des scénarios d’application, les caméras à lumière structurée de Mech Mind devraient démontrer leur valeur unique dans davantage de domaines.

Mettre en place un environnement de développement Python

Créer un environnement virtuel

Téléchargez le package opencv-python

Téléchargez le package de capture de caméra Mecamander

pip install MechEyeAPI
pip install python-opencv

Analyse des étapes

Connecter la caméra

def ConnectCamera(self):
    camera_infos = Camera.discover_cameras()
    if len(camera_infos) != 1:
        print("相机连接出现异常，检查网线")
        return
    error_status = self.camera.connect(camera_infos[0])
    if not error_status.is_ok():
        show_error(error_status)
        return

Déconnecter la caméra

def DisConnectCamera(self):
    self.camera.disconnect()
    print("Disconnected from the camera successfully.")

Collectez des images 2D et des images 3D

def connect_and_capture(self):
 
    # Obtain the 2D image resolution and the depth map resolution of the camera.
    resolution = CameraResolutions()
    show_error(self.camera.get_camera_resolutions(resolution))
    print_camera_resolution(resolution)
 
    time1 = time.time()
    # Obtain the 2D image.
    frame2d = Frame2D()
    show_error(self.camera.capture_2d(frame2d))
    row, col = 222, 222
    color_map = frame2d.get_color_image()
    print("The size of the 2D image is {} (width) * {} (height).".format(
        color_map.width(), color_map.height()))
    rgb = color_map[row * color_map.width() + col]
    print("The RGB values of the pixel at ({},{}) is R:{},G:{},B{}n".
          format(row, col, rgb.b, rgb.g, rgb.r))
 
    Image2d = color_map.data()
 
    time2 = time.time()
    print('grab 2d image : '+str((time2-time1)*1000)+'ms')
 
 
    # if not confirm_capture_3d():
    #     return
 
    # Obtain the depth map.
    frame3d = Frame3D()
    show_error(self.camera.capture_3d(frame3d))
    depth_map = frame3d.get_depth_map()
    print("The size of the depth map is {} (width) * {} (height).".format(
        depth_map.width(), depth_map.height()))
    depth = depth_map[row * depth_map.width() + col]
    print("The depth value of the pixel at ({},{}) is depth :{}mmn".
          format(row, col, depth.z))
    Image3d = depth_map.data()
    time3 = time.time()
    print('grab depth image : '+str((time3-time2)*1000)+'ms')
 
 
    return Image2d,Image3d
    # Obtain the point cloud.
    # point_cloud = frame3d.get_untextured_point_cloud()
    # print("The size of the point cloud is {} (width) * {} (height).".format(
    #     point_cloud.width(), point_cloud.height()))
    # point_xyz = point_cloud[row * depth_map.width() + col]
    # print("The coordinates of the point corresponding to the pixel at ({},{}) is X: {}mm , Y: {}mm, Z: {}mmn".
    #       format(row, col, point_xyz.x, point_xyz.y, point_xyz.z))

Code de test complet

# With this sample, you can connect to a camera and obtain the 2D image, depth map, and point cloud data.
import time
 
from mecheye.shared import *
from mecheye.area_scan_3d_camera import *
from mecheye.area_scan_3d_camera_utils import *
import cv2
 
 
class ConnectAndCaptureImages(object):
    def __init__(self):
        self.camera = Camera()
 
    def connect_and_capture(self):
 
        # Obtain the 2D image resolution and the depth map resolution of the camera.
        resolution = CameraResolutions()
        show_error(self.camera.get_camera_resolutions(resolution))
        print_camera_resolution(resolution)
 
        time1 = time.time()
        # Obtain the 2D image.
        frame2d = Frame2D()
        show_error(self.camera.capture_2d(frame2d))
        row, col = 222, 222
        color_map = frame2d.get_color_image()
        print("The size of the 2D image is {} (width) * {} (height).".format(
            color_map.width(), color_map.height()))
        rgb = color_map[row * color_map.width() + col]
        print("The RGB values of the pixel at ({},{}) is R:{},G:{},B{}n".
              format(row, col, rgb.b, rgb.g, rgb.r))
 
        Image2d = color_map.data()
 
        time2 = time.time()
        print('grab 2d image : '+str((time2-time1)*1000)+'ms')
 
 
        # if not confirm_capture_3d():
        #     return
 
        # Obtain the depth map.
        frame3d = Frame3D()
        show_error(self.camera.capture_3d(frame3d))
        depth_map = frame3d.get_depth_map()
        print("The size of the depth map is {} (width) * {} (height).".format(
            depth_map.width(), depth_map.height()))
        depth = depth_map[row * depth_map.width() + col]
        print("The depth value of the pixel at ({},{}) is depth :{}mmn".
              format(row, col, depth.z))
        Image3d = depth_map.data()
        time3 = time.time()
        print('grab depth image : '+str((time3-time2)*1000)+'ms')
 
 
        return Image2d,Image3d
        # Obtain the point cloud.
        # point_cloud = frame3d.get_untextured_point_cloud()
        # print("The size of the point cloud is {} (width) * {} (height).".format(
        #     point_cloud.width(), point_cloud.height()))
        # point_xyz = point_cloud[row * depth_map.width() + col]
        # print("The coordinates of the point corresponding to the pixel at ({},{}) is X: {}mm , Y: {}mm, Z: {}mmn".
        #       format(row, col, point_xyz.x, point_xyz.y, point_xyz.z))
 
    def main(self):
        # List all available cameras and connect to a camera by the displayed index.
        if find_and_connect(self.camera):
            d2,d3 = self.connect_and_capture()
            self.camera.disconnect()
            print("Disconnected from the camera successfully.")
        return d2,d3
 
    def GrabImages(self):
        d2, d3 = self.connect_and_capture()
        return d2, d3
 
    def ConnectCamera(self):
        camera_infos = Camera.discover_cameras()
        if len(camera_infos) != 1:
            print("相机连接出现异常，检查网线")
            return
        error_status = self.camera.connect(camera_infos[0])
        if not error_status.is_ok():
            show_error(error_status)
            return
    def DisConnectCamera(self):
        self.camera.disconnect()
        print("Disconnected from the camera successfully.")
 
 
 
 
 
if __name__ == '__main__':
 
    #pip install MechEyeAPI
 
    print('初始化相机对象')
    MechMindGraber = ConnectAndCaptureImages()
    # d2,d3 = a.main()
    print('连接相机')
    MechMindGraber.ConnectCamera()
 
    for i in range(60):
        print(str(i)+'rn')
        print('采集亮度图和深度图')
        d2,d3  = MechMindGraber.GrabImages()
 
 
    cv2.imshow('1',d2)
    cv2.waitKey()
    cv2.imshow('1', d3)
    cv2.waitKey()
    print('断开连接')
    MechMindGraber.DisConnectCamera()