IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Chroniqueur Actualités

    Homme Profil pro
    Dirigeant
    Inscrit en
    Juin 2016
    Messages
    3 160
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Bénin

    Informations professionnelles :
    Activité : Dirigeant
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Juin 2016
    Messages : 3 160
    Points : 66 279
    Points
    66 279
    Par défaut Une compagnie ferroviaire japonaise lance un géant robot humanoïde pour réparer les lignes électriques
    Une compagnie ferroviaire japonaise va utiliser un robot humanoïde géant pour réparer les lignes électriques
    et effectuer certaines tâches de maintenance

    La West Japan Rail Company (JR West) a publié une vidéo de son nouveau robot humanoïde multitâche. Monté au bout d'une grue, ce torse de robot de style Gundam imite les mouvements des bras et de la tête d'un pilote humain. Ce dernier contrôle le robot à distance et voit à travers les yeux du robot grâce à des lunettes de réalité virtuelle. L'entreprise a déclaré que la mission principale du robot est "d'améliorer la productivité et la sécurité", en permettant aux travailleurs de soulever et de manipuler naturellement des équipements lourds autour du système ferroviaire sans les exposer à des risques de chocs électriques ou de chute.

    De nombreuses entreprises, y compris Tesla d'Elon Musk, travaillent actuellement sur la conception de robots humanoïdes qui devraient se charger à l'avenir des tâches considérées comme dangereuses pour l'homme. Si la plupart des exemplaires existants sont encore à l'étape de prototypes de laboratoire, la JR West a dévoilé le sien le mois dernier. La société a déclaré qu'elle développe cette machine en partenariat avec Human Machinery Co et Nippon Signal Co. Elle envisage de les déployer prochainement pour assurer des travaux de maintenance et de réparation sur les réseaux électriques le long des lignes ferroviaires.

    Alors, comment fonctionne-t-il ? Tout d'abord, contrairement aux robots humanoïdes présentés par d'autres entreprises, le robot de JR West est dépourvu de "jambes". Il est doté d'un torse de type humain et d'une paire de mains pour effectuer toute une série de tâches, comme le nettoyage des lignes électriques à l'aide d'une brosse multiangle spécialement conçue. Cependant, il ne s'agit pas seulement d'un robot de nettoyage, mais aussi d'un robot capable d'effectuer des tâches de maintenance à l'aide de ses mains en forme de pinces, compatibles avec une multitude d'autres outils. Il n'est pas autonome et reprend les gestes de son contrôleur.



    Au sommet du torse se trouve une paire de caméras numériques qui servent d'yeux à l'opérateur humain qui manipule le robot à l'aide d'un casque de réalité virtuelle (RV). Grâce au suivi des mouvements, l'opérateur contrôle les mouvements des caméras sur le robot, tandis qu'une paire de poignées l'aide à contrôler les bras et les mains du robot. Si une force extérieure agit sur les bras, elle est relayée aux commandes du pilote, qui peut alors prendre les mesures nécessaires. Et grâce à la grue hydraulique qui sous-tend le torse, le robot peut soulever des objets lourds. JR West a déclaré que le robot devrait améliorer la sécurité des travailleurs.

    Bien que fonctionnel, il est encore un prototype. JR West a annoncé que le premier robot de ce type sera mis au travail à plein temps en 2024. Il y aura probablement d'autres dérivés de ces robots qui aideront à libérer les humains des tâches à haut risque impliquant des lignes électriques et des travaux à des hauteurs considérables. Une vidéo publiée sur Twitter montre le robot soulevant et positionnant des composants de taille raisonnable, ainsi que nettoyant des structures ferroviaires aériennes à l'aide de la brosse spéciale à angles multiples. Il saisit tous ces outils dans ce qui ressemble à ses "mains" relativement simples.

    Le robot fait preuve d'un degré raisonnable de dextérité, bien qu'il fonctionne à une vitesse assez lente. Selon des experts, en général, toute tentative de donner à un robot une apparence humanoïde fait penser qu'il ne fonctionne probablement pas aussi bien qu'il pourrait le faire s'il n'avait pas l'air humanoïde. Mais dans ce cas, ils estiment que c'est logique : « le pilote peut rapidement acquérir une sensation cinétique pour faire fonctionner le robot, puisque ses bras et sa tête sont à des endroits familiers les uns par rapport aux autres ». Le robot de JR West a une conception légèrement différente de celle du robot Atlas de Boston Dynamics.

    Atlas est un des robots phares de Boston Dynamics (le plus célèbre est le robot quadrupède "Spot" de la société). Atlas est un robot bipède capable de faire du sprint, des exercices de gymnastique, du parcours d'obstacles (ou l'art du déplacement : une discipline sportive acrobatique qui consiste à franchir des obstacles urbains ou naturels, par des mouvements rapides et agiles et sans l'aide de matériel), des saltos arrière, et bien d'autres. Il peut également ouvrir des portes pour laisser entrer une armée d'autres Atlas. Dévoilé en juillet 2013, Atlas a été conçu pour exécuter diverses tâches, principalement de recherche et sauvetage.

    Le robot de JR West est également différent du robot humanoïde sur lequel travaille Tesla. Baptisé Tesla Bot, le robot humanoïde du constructeur américain de véhicules électriques est un robot qui mesure environ 1,72 m, pèse environ 56,7 kg et devrait être capable de porter environ 20 kg ou de soulever de terre une charge d'environ 68 kg. Le robot a pour ambition de « libérer l'humain des tâches dangereuses, répétitives et ennuyeuses ». « Il est destiné à être amical, bien sûr, et à naviguer dans un monde construit pour les humains », a déclaré Elon Musk, PDG de Tesla, lors de la conférence "Tesla AI Day" l'année dernière.

    Selon les déclarations de Musk, un prototype fonctionnel pourrait être présenté l'an prochain. Toutefois, Musk n'a pas précisé s'il serait vendu ni à quel prix. Le robot devrait avoir un écran positionné à la place du visage pour afficher « des informations utiles. Musk estime que le robot aurait un impact « profond » sur l'économie. Il a déclaré que le travail physique serait un choix à l'avenir et qu'un revenu de base universel serait nécessaire. Cette année, il a déclaré qu'à long terme, la demande pour ce type de robots devrait exploser, de sorte le Tesla Bot pourrait devenir plus important que l'activité automobile de la société.

    Source : JR West

    Et vous ?

    Quel est votre avis sur le sujet ?
    Que pensez-vous du robot humanoïde de JR West ?
    Pensez-vous que la demande pour ces robots explosera à l'avenir ?

    Voir aussi

    Elon Musk affirme que le robot humanoïde de Tesla est le produit le plus important sur lequel l'entreprise travaille, et qu'il pourrait à terme dépasser son activité automobile

    Boston Dynamics montre les progrès de ses robots dans une vidéo où plusieurs de ses modèles dansent, un moyen idéal de clôturer avec le sourire une année éprouvante

    Regardez Atlas, le robot humanoïde de Boston Dynamics, réussir un parcours d'obstacles, les ingénieurs développent de nouveaux mouvements inspirés des comportements humains

    Elon Musk dévoile son projet Tesla Bot, un robot humanoïde dont un prototype fonctionnel est attendu pour 2022, le débat sur le revenu universel est relancé

  2. #2
    Chroniqueur Actualités
    Avatar de Patrick Ruiz
    Homme Profil pro
    Redacteur web
    Inscrit en
    Février 2017
    Messages
    1 997
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Cameroun

    Informations professionnelles :
    Activité : Redacteur web
    Secteur : Communication - Médias

    Informations forums :
    Inscription : Février 2017
    Messages : 1 997
    Points : 54 803
    Points
    54 803
    Par défaut Une compagnie ferroviaire japonaise lance un géant robot humanoïde pour réparer les lignes électriques
    Une compagnie ferroviaire japonaise lance un géant robot humanoïde pour réparer les lignes électriques
    Et ravive le débat sur les tentatives de remplacement total des humains par des robots

    L’entreprise West Japan Railways utilise un robot humanoïde géant pour entretenir les voies ferrées et effectuer d'autres tâches critiques. L’objectif : protéger le personnel contre les chutes et combler les pénuries de main d’œuvre dans un pays vieillissant. Le tableau ravive le débat sur les tentatives de mise à contribution des robots dans divers secteurs de la société.

    Jinki Ittai Co, un développeur de technologies robotiques, et Nippon Signal Co, une entreprise spécialisée dans les technologies de l'information et l'électricité dans les infrastructures, ont développé conjointement la machine. Son opérateur, assis dans un cockpit sur le camion, voit à travers les yeux du robot grâce à des caméras et actionne à distance ses puissants membres et mains. Avec une portée verticale de 12 mètres, la machine peut utiliser divers accessoires afin de porter des objets pesant jusqu'à 40 kg, tenir un pinceau pour peindre ou utiliser une tronçonneuse.


    Cette machine devrait permettre aux personnes de tous les sexes et de tous les âges de travailler à l'entretien des chemins de fer. La mécanisation contribue à l'objectif d'élimination des accidents du travail dus à des chocs électriques ou des chutes, et permet en sus d'améliorer la sécurité.

    L’initiative n’est pas sans faire penser à l’utilisation de chiens-robots pour perquisitionner les laboratoires de drogue. C’est la vie humaine qui est protégée en mettant à contribution des kits matériels - à la présentation visuelle similaire à celle d’un chien sur pattes – programmables via une API fournie par le constructeur Boston Dynamics.

    Ce type de mise en œuvre desdits robots consiste en général en de la détection et suivi d’objets. Dans ce cas, il y a collecte des images provenant de deux caméras avant et effectue une détection d’objet sur une classe spécifiée. Cette détection utilise Tensorflow via le tensorflow_object_detector. Il accepte n'importe quel modèle Tensorflow et permet au développeur de spécifier un sous-ensemble de classes de détection incluses dans le modèle. Il effectue cet ensemble d'opérations pour un nombre prédéfini d'itérations, en bloquant pendant une durée prédéfinie entre chaque itération. L'application détermine ensuite l'emplacement de la détection la plus fiable de la classe spécifiée et se dirige vers l'objet.

    L’application est organisée en trois ensembles de processus Python communiquant avec le robot Spot. Le diagramme des processus est illustré ci-dessous. Le processus principal communique avec le robot Spot via GRPC et reçoit constamment des images. Ces images sont poussées dans la RAW_IMAGES_QUEUE et lues par les processus Tensorflow. Ces processus détectent des objets dans les images et poussent l'emplacement dans PROCESSED_BOXES_QUEUE. Le thread principal détermine alors l'emplacement de l'objet et envoie des commandes au robot pour qu'il se dirige vers l'objet.

    Code Python : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
    304
    305
    306
    307
    308
    309
    310
    311
    312
    313
    314
    315
    316
    317
    318
    319
    320
    321
    322
    323
    324
    325
    326
    327
    328
    329
    330
    331
    332
    333
    334
    335
    336
    337
    338
    339
    340
    341
    342
    343
    344
    345
    346
    347
    348
    349
    350
    351
    352
    353
    354
    355
    356
    357
    358
    359
    360
    361
    362
    363
    364
    365
    366
    367
    368
    369
    370
    371
    372
    373
    374
    375
    376
    377
    378
    379
    380
    381
    382
    383
    384
    385
    386
    387
    388
    389
    390
    391
    392
    393
    394
    395
    396
    397
    398
    399
    400
    401
    402
    403
    404
    405
    406
    407
    408
    409
    410
    411
    412
    413
    414
    415
    416
    417
    418
    419
    420
    421
    422
    423
    424
    425
    426
    427
    428
    429
    430
    431
    432
    433
    434
    435
    436
    437
    438
    439
    440
    441
    442
    443
    444
    445
    446
    447
    448
    449
    450
    451
    452
    453
    454
    455
    456
    457
    458
    459
    460
    461
    462
    463
    464
    465
    466
    467
    468
    469
    470
    471
    472
    473
    474
    475
    476
    477
    478
    479
    480
    481
    482
    483
    484
    485
    486
    487
    488
    489
    490
    491
    492
    493
    494
    495
    496
    497
    498
    499
    500
    501
    502
    503
    504
    505
    506
    507
    508
    509
    510
    511
    512
    513
    514
    515
    516
    517
    518
    519
    520
    521
    522
    523
    524
    525
    526
    527
    528
    529
    530
    531
    532
    533
    534
    535
    536
    537
    538
    539
    540
    541
    542
    543
    544
    545
    546
    547
    548
    549
    550
    551
    552
    553
    554
    555
    556
    557
    558
    559
    560
    561
    562
    563
    564
    565
    566
    567
    568
    569
    570
    571
    572
    573
    574
    575
    576
    577
    578
    579
    580
    581
    582
    583
    584
    585
    586
    587
    588
    589
    590
    591
    592
    593
    594
    595
    596
    597
    598
    599
    600
    601
    602
    603
    604
    605
    606
    607
    608
    609
    610
    611
    612
    613
    614
    615
    616
    617
    618
    619
    620
    621
    622
    623
    624
    625
    626
    627
    628
    629
    630
    631
    632
    633
    634
    635
    636
    637
    638
    639
    640
    641
    642
    643
    644
    645
    646
    647
    648
    649
    650
    651
    652
    653
    654
    655
    656
    657
    658
    659
    660
    661
    662
    663
    664
    665
    666
    667
    668
    669
    670
    671
    672
    673
    674
    675
    676
    677
    678
    679
    680
    681
    682
    683
    684
    685
    686
    687
    688
    689
    690
    691
    692
    693
    694
    695
    696
    697
    698
    699
    700
    701
    702
    703
    704
    705
    706
    707
    708
    709
    710
    711
    712
    713
    714
    715
    716
    717
    718
    719
    720
    721
    722
    723
    724
    725
    726
    727
    728
    729
    730
    731
    732
    733
    734
    735
    736
    737
    738
    739
    740
    741
    742
    743
    744
    745
    746
    747
    748
    749
    750
    751
    752
    753
    754
    755
    756
    757
    758
    759
    760
    761
    762
    763
    764
    765
    766
    767
    768
    769
    770
    771
    772
    773
    774
    775
    776
    777
    778
    779
    780
    781
    782
    783
    784
    785
    786
    787
    788
    789
    790
    791
    792
    793
    794
    795
    796
    797
    798
    799
    800
    801
    802
    803
    804
    805
    806
    807
    808
    809
    810
    811
    812
    813
    814
    815
    816
    817
    818
    819
    820
    821
    822
    823
    824
    825
    826
    827
    828
    829
    830
    831
    832
    833
    834
    835
    836
    837
    838
    839
    # Copyright (c) 2023 Boston Dynamics, Inc.  All rights reserved.
    #
    # Downloading, reproducing, distributing or otherwise using the SDK Software
    # is subject to the terms and conditions of the Boston Dynamics Software
    # Development Kit License (20191101-BDSDK-SL).
     
    """Tutorial to show how to use the Boston Dynamics API to detect and follow an object"""
    import argparse
    import io
    import json
    import math
    import os
    import signal
    import sys
    import time
    from multiprocessing import Barrier, Process, Queue, Value
    from queue import Empty, Full
    from threading import BrokenBarrierError, Thread
     
    import cv2
    import numpy as np
    from PIL import Image
    from scipy import ndimage
    from tensorflow_object_detection import DetectorAPI
     
    import bosdyn.client
    import bosdyn.client.util
    from bosdyn import geometry
    from bosdyn.api import geometry_pb2 as geo
    from bosdyn.api import image_pb2, trajectory_pb2
    from bosdyn.api.image_pb2 import ImageSource
    from bosdyn.api.spot import robot_command_pb2 as spot_command_pb2
    from bosdyn.client.async_tasks import AsyncPeriodicQuery, AsyncTasks
    from bosdyn.client.frame_helpers import (GROUND_PLANE_FRAME_NAME, VISION_FRAME_NAME, get_a_tform_b,
                                             get_vision_tform_body)
    from bosdyn.client.image import ImageClient
    from bosdyn.client.lease import LeaseClient, LeaseKeepAlive
    from bosdyn.client.math_helpers import Quat, SE3Pose
    from bosdyn.client.robot_command import (CommandFailedError, CommandTimedOutError,
                                             RobotCommandBuilder, RobotCommandClient, blocking_stand)
    from bosdyn.client.robot_state import RobotStateClient
     
    LOGGER = bosdyn.client.util.get_logger()
     
    SHUTDOWN_FLAG = Value('i', 0)
     
    # Don't let the queues get too backed up
    QUEUE_MAXSIZE = 10
     
    # This is a multiprocessing.Queue for communication between the main process and the
    # Tensorflow processes.
    # Entries in this queue are in the format:
     
    # {
    #     'source': Name of the camera,
    #     'world_tform_cam': transform from VO to camera,
    #     'world_tform_gpe':  transform from VO to ground plane,
    #     'raw_image_time': Time when the image was collected,
    #     'cv_image': The decoded image,
    #     'visual_dims': (cols, rows),
    #     'depth_image': depth image proto,
    #     'system_cap_time': Time when the image was received by the main process,
    #     'image_queued_time': Time when the image was done preprocessing and queued
    # }
    RAW_IMAGES_QUEUE = Queue(QUEUE_MAXSIZE)
     
    # This is a multiprocessing.Queue for communication between the Tensorflow processes and
    # the bbox print process. This is meant for running in a containerized environment with no access
    # to an X display
    # Entries in this queue have the following fields in addition to those in :
    # {
    #   'processed_image_start_time':  Time when the image was received by the TF process,
    #   'processed_image_end_time':  Time when the image was processing for bounding boxes
    #   'boxes': list of detected bounding boxes for the processed image
    #   'classes': classes of objects,
    #   'scores': confidence scores,
    # }
    PROCESSED_BOXES_QUEUE = Queue(QUEUE_MAXSIZE)
     
    # Barrier for waiting on Tensorflow processes to start, initialized in main()
    TENSORFLOW_PROCESS_BARRIER = None
     
    COCO_CLASS_DICT = {
        1: 'person',
        2: 'bicycle',
        3: 'car',
        4: 'motorcycle',
        5: 'airplane',
        6: 'bus',
        7: 'train',
        8: 'truck',
        9: 'boat',
        10: 'trafficlight',
        11: 'firehydrant',
        13: 'stopsign',
        14: 'parkingmeter',
        15: 'bench',
        16: 'bird',
        17: 'cat',
        18: 'dog',
        19: 'horse',
        20: 'sheep',
        21: 'cow',
        22: 'elephant',
        23: 'bear',
        24: 'zebra',
        25: 'giraffe',
        27: 'backpack',
        28: 'umbrella',
        31: 'handbag',
        32: 'tie',
        33: 'suitcase',
        34: 'frisbee',
        35: 'skis',
        36: 'snowboard',
        37: 'sportsball',
        38: 'kite',
        39: 'baseballbat',
        40: 'baseballglove',
        41: 'skateboard',
        42: 'surfboard',
        43: 'tennisracket',
        44: 'bottle',
        46: 'wineglass',
        47: 'cup',
        48: 'fork',
        49: 'knife',
        50: 'spoon',
        51: 'bowl',
        52: 'banana',
        53: 'apple',
        54: 'sandwich',
        55: 'orange',
        56: 'broccoli',
        57: 'carrot',
        58: 'hotdog',
        59: 'pizza',
        60: 'donut',
        61: 'cake',
        62: 'chair',
        63: 'couch',
        64: 'pottedplant',
        65: 'bed',
        67: 'diningtable',
        70: 'toilet',
        72: 'tv',
        73: 'laptop',
        74: 'mouse',
        75: 'remote',
        76: 'keyboard',
        77: 'cellphone',
        78: 'microwave',
        79: 'oven',
        80: 'toaster',
        81: 'sink',
        82: 'refrigerator',
        84: 'book',
        85: 'clock',
        86: 'vase',
        87: 'scissors',
        88: 'teddybear',
        89: 'hairdrier',
        90: 'toothbrush'
    }
     
    # Mapping from visual to depth data
    VISUAL_SOURCE_TO_DEPTH_MAP_SOURCE = {
        'frontleft_fisheye_image': 'frontleft_depth_in_visual_frame',
        'frontright_fisheye_image': 'frontright_depth_in_visual_frame'
    }
    ROTATION_ANGLES = {
        'back_fisheye_image': 0,
        'frontleft_fisheye_image': -78,
        'frontright_fisheye_image': -102,
        'left_fisheye_image': 0,
        'right_fisheye_image': 180
    }
     
     
    def _update_thread(async_task):
        while True:
            async_task.update()
            time.sleep(0.01)
     
     
    class AsyncImage(AsyncPeriodicQuery):
        """Grab image."""
     
        def __init__(self, image_client, image_sources):
            # Period is set to be about 15 FPS
            super(AsyncImage, self).__init__('images', image_client, LOGGER, period_sec=0.067)
            self.image_sources = image_sources
     
        def _start_query(self):
            return self._client.get_image_from_sources_async(self.image_sources)
     
     
    class AsyncRobotState(AsyncPeriodicQuery):
        """Grab robot state."""
     
        def __init__(self, robot_state_client):
            # period is set to be about the same rate as detections on the CORE AI
            super(AsyncRobotState, self).__init__('robot_state', robot_state_client, LOGGER,
                                                  period_sec=0.02)
     
        def _start_query(self):
            return self._client.get_robot_state_async()
     
     
    def get_source_list(image_client):
        """Gets a list of image sources and filters based on config dictionary
     
        Args:
            image_client: Instantiated image client
        """
     
        # We are using only the visual images with their corresponding depth sensors
        sources = image_client.list_image_sources()
        source_list = []
        for source in sources:
            if source.image_type == ImageSource.IMAGE_TYPE_VISUAL:
                # only append if sensor has corresponding depth sensor
                if source.name in VISUAL_SOURCE_TO_DEPTH_MAP_SOURCE:
                    source_list.append(source.name)
                    source_list.append(VISUAL_SOURCE_TO_DEPTH_MAP_SOURCE[source.name])
        return source_list
     
     
    def capture_images(image_task, sleep_between_capture):
        """ Captures images and places them on the queue
     
        Args:
            image_task (AsyncImage): Async task that provides the images response to use
            sleep_between_capture (float): Time to sleep between each image capture
        """
        while not SHUTDOWN_FLAG.value:
            get_im_resp = image_task.proto
            start_time = time.time()
            if not get_im_resp:
                continue
            depth_responses = {
                img.source.name: img
                for img in get_im_resp
                if img.source.image_type == ImageSource.IMAGE_TYPE_DEPTH
            }
            entry = {}
            for im_resp in get_im_resp:
                if im_resp.source.image_type == ImageSource.IMAGE_TYPE_VISUAL:
                    source = im_resp.source.name
                    depth_source = VISUAL_SOURCE_TO_DEPTH_MAP_SOURCE[source]
                    depth_image = depth_responses[depth_source]
     
                    acquisition_time = im_resp.shot.acquisition_time
                    image_time = acquisition_time.seconds + acquisition_time.nanos * 1e-9
     
                    try:
                        image = Image.open(io.BytesIO(im_resp.shot.image.data))
                        source = im_resp.source.name
     
                        image = ndimage.rotate(image, ROTATION_ANGLES[source])
                        if im_resp.shot.image.pixel_format == image_pb2.Image.PIXEL_FORMAT_GREYSCALE_U8:
                            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)  # Converted to RGB for TF
                        tform_snapshot = im_resp.shot.transforms_snapshot
                        frame_name = im_resp.shot.frame_name_image_sensor
                        world_tform_cam = get_a_tform_b(tform_snapshot, VISION_FRAME_NAME, frame_name)
                        world_tform_gpe = get_a_tform_b(tform_snapshot, VISION_FRAME_NAME,
                                                        GROUND_PLANE_FRAME_NAME)
                        entry[source] = {
                            'source': source,
                            'world_tform_cam': world_tform_cam,
                            'world_tform_gpe': world_tform_gpe,
                            'raw_image_time': image_time,
                            'cv_image': image,
                            'visual_dims': (im_resp.shot.image.cols, im_resp.shot.image.rows),
                            'depth_image': depth_image,
                            'system_cap_time': start_time,
                            'image_queued_time': time.time()
                        }
                    except Exception as exc:  # pylint: disable=broad-except
                        print(f'Exception occurred during image capture {exc}')
            try:
                RAW_IMAGES_QUEUE.put_nowait(entry)
            except Full as exc:
                print(f'RAW_IMAGES_QUEUE is full: {exc}')
            time.sleep(sleep_between_capture)
     
     
    def start_tensorflow_processes(num_processes, model_path, detection_class, detection_threshold,
                                   max_processing_delay):
        """Starts Tensorflow processes in parallel.
     
        It does not keep track of the processes once they are started because they run indefinitely
        and are never joined back to the main process.
     
        Args:
            num_processes (int): Number of Tensorflow processes to start in parallel.
            model_path (str): Filepath to the Tensorflow model to use.
            detection_class (int): Detection class to detect
            detection_threshold (float): Detection threshold to apply to all Tensorflow detections.
            max_processing_delay (float): Allowed delay before processing an incoming image.
        """
        processes = []
        for _ in range(num_processes):
            process = Process(
                target=process_images, args=(
                    model_path,
                    detection_class,
                    detection_threshold,
                    max_processing_delay,
                ), daemon=True)
            process.start()
            processes.append(process)
        return processes
     
     
    def process_images(model_path, detection_class, detection_threshold, max_processing_delay):
        """Starts Tensorflow and detects objects in the incoming images.
     
        Args:
            model_path (str): Filepath to the Tensorflow model to use.
            detection_class (int): Detection class to detect
            detection_threshold (float): Detection threshold to apply to all Tensorflow detections.
            max_processing_delay (float): Allowed delay before processing an incoming image.
        """
     
        odapi = DetectorAPI(path_to_ckpt=model_path)
        num_processed_skips = 0
     
        if TENSORFLOW_PROCESS_BARRIER is None:
            return
     
        try:
            TENSORFLOW_PROCESS_BARRIER.wait()
        except BrokenBarrierError as exc:
            print(f'Error waiting for Tensorflow processes to initialize: {exc}')
            return False
     
        while not SHUTDOWN_FLAG.value:
            try:
                entry = RAW_IMAGES_QUEUE.get_nowait()
            except Empty:
                time.sleep(0.1)
                continue
            for _, capture in entry.items():
                start_time = time.time()
                processing_delay = time.time() - capture['raw_image_time']
                if processing_delay > max_processing_delay:
                    num_processed_skips += 1
                    print(f'skipped image because it took {processing_delay}')
                    continue  # Skip image due to delay
     
                image = capture['cv_image']
                boxes, scores, classes, _ = odapi.process_frame(image)
                confident_boxes = []
                confident_object_classes = []
                confident_scores = []
                if len(boxes) == 0:
                    print('no detections founds')
                    continue
                for box, score, box_class in sorted(zip(boxes, scores, classes), key=lambda x: x[1],
                                                    reverse=True):
                    if score > detection_threshold and box_class == detection_class:
                        confident_boxes.append(box)
                        confident_object_classes.append(COCO_CLASS_DICT[box_class])
                        confident_scores.append(score)
                        image = cv2.rectangle(image, (box[1], box[0]), (box[3], box[2]), (255, 0, 0), 2)
     
                capture['processed_image_start_time'] = start_time
                capture['processed_image_end_time'] = time.time()
                capture['boxes'] = confident_boxes
                capture['classes'] = confident_object_classes
                capture['scores'] = confident_scores
                capture['cv_image'] = image
            try:
                PROCESSED_BOXES_QUEUE.put_nowait(entry)
            except Full as exc:
                print(f'PROCESSED_BOXES_QUEUE is full: {exc}')
        print('tf process ending')
        return True
     
     
    def get_go_to(world_tform_object, robot_state, mobility_params, dist_margin=0.5):
        """Gets trajectory command to a goal location
     
        Args:
            world_tform_object (SE3Pose): Transform from vision frame to target object
            robot_state (RobotState): Current robot state
            mobility_params (MobilityParams): Mobility parameters
            dist_margin (float): Distance margin to target
        """
        vo_tform_robot = get_vision_tform_body(robot_state.kinematic_state.transforms_snapshot)
        print(f'robot pos: {vo_tform_robot}')
        delta_ewrt_vo = np.array(
            [world_tform_object.x - vo_tform_robot.x, world_tform_object.y - vo_tform_robot.y, 0])
        norm = np.linalg.norm(delta_ewrt_vo)
        if norm == 0:
            return None
        delta_ewrt_vo_norm = delta_ewrt_vo / norm
        heading = _get_heading(delta_ewrt_vo_norm)
        vo_tform_goal = np.array([
            world_tform_object.x - delta_ewrt_vo_norm[0] * dist_margin,
            world_tform_object.y - delta_ewrt_vo_norm[1] * dist_margin
        ])
        se2_pose = geo.SE2Pose(position=geo.Vec2(x=vo_tform_goal[0], y=vo_tform_goal[1]), angle=heading)
        tag_cmd = RobotCommandBuilder.synchro_se2_trajectory_command(se2_pose,
                                                                     frame_name=VISION_FRAME_NAME,
                                                                     params=mobility_params)
        return tag_cmd
     
     
    def _get_heading(xhat):
        zhat = [0.0, 0.0, 1.0]
        yhat = np.cross(zhat, xhat)
        mat = np.array([xhat, yhat, zhat]).transpose()
        return Quat.from_matrix(mat).to_yaw()
     
     
    def set_default_body_control():
        """Set default body control params to current body position"""
        footprint_R_body = geometry.EulerZXY()
        position = geo.Vec3(x=0.0, y=0.0, z=0.0)
        rotation = footprint_R_body.to_quaternion()
        pose = geo.SE3Pose(position=position, rotation=rotation)
        point = trajectory_pb2.SE3TrajectoryPoint(pose=pose)
        traj = trajectory_pb2.SE3Trajectory(points=[point])
        return spot_command_pb2.BodyControlParams(base_offset_rt_footprint=traj)
     
     
    def get_mobility_params():
        """Gets mobility parameters for following"""
        vel_desired = .75
        speed_limit = geo.SE2VelocityLimit(
            max_vel=geo.SE2Velocity(linear=geo.Vec2(x=vel_desired, y=vel_desired), angular=.25))
        body_control = set_default_body_control()
        mobility_params = spot_command_pb2.MobilityParams(vel_limit=speed_limit, obstacle_params=None,
                                                          body_control=body_control,
                                                          locomotion_hint=spot_command_pb2.HINT_TROT)
        return mobility_params
     
     
    def depth_to_xyz(depth, pixel_x, pixel_y, focal_length, principal_point):
        """Calculate the transform to point in image using camera intrinsics and depth"""
        x = depth * (pixel_x - principal_point.x) / focal_length.x
        y = depth * (pixel_y - principal_point.y) / focal_length.y
        z = depth
        return x, y, z
     
     
    def remove_ground_from_depth_image(raw_depth_image, focal_length, principal_point, world_tform_cam,
                                       world_tform_gpe, ground_tolerance=0.04):
        """ Simple ground plane removal algorithm. Uses ground height
            and does simple z distance filtering.
     
        Args:
            raw_depth_image (np.array): Depth image
            focal_length (Vec2): Focal length of camera that produced the depth image
            principal_point (Vec2): Principal point of camera that produced the depth image
            world_tform_cam (SE3Pose): Transform from VO to camera frame
            world_tform_gpe (SE3Pose): Transform from VO to GPE frame
            ground_tolerance (float): Distance in meters to add to the ground plane
        """
        new_depth_image = raw_depth_image
     
        # same functions as depth_to_xyz, but converted to np functions
        indices = np.indices(raw_depth_image.shape)
        xs = raw_depth_image * (indices[1] - principal_point.x) / focal_length.x
        ys = raw_depth_image * (indices[0] - principal_point.y) / focal_length.y
        zs = raw_depth_image
     
        # create xyz point cloud
        camera_tform_points = np.stack([xs, ys, zs], axis=2)
        # points in VO frame
        world_tform_points = world_tform_cam.transform_cloud(camera_tform_points)
        # array of booleans where True means the point was below the ground plane plus tolerance
        world_tform_points_mask = (world_tform_gpe.z - world_tform_points[:, :, 2]) < ground_tolerance
        # remove data below ground plane
        new_depth_image[world_tform_points_mask] = 0
        return new_depth_image
     
     
    def get_distance_to_closest_object_depth(x_min, x_max, y_min, y_max, depth_scale, raw_depth_image,
                                             histogram_bin_size=0.50, minimum_number_of_points=10,
                                             max_distance=8.0):
        """Make a histogram of distances to points in the cloud and take the closest distance with
        enough points.
     
        Args:
            x_min (int): minimum x coordinate (column) of object to find
            x_max (int): maximum x coordinate (column) of object to find
            y_min (int): minimum y coordinate (row) of object to find
            y_max (int): maximum y coordinate (row) of object to find
            depth_scale (float): depth scale of the image to convert from sensor value to meters
            raw_depth_image (np.array): matrix of depth pixels
            histogram_bin_size (float): size of each bin of distances
            minimum_number_of_points (int): minimum number of points before returning depth
            max_distance (float): maximum distance to object in meters
        """
        num_bins = math.ceil(max_distance / histogram_bin_size)
     
        # get a sub-rectangle of the bounding box out of the whole image, then flatten
        obj_depths = (raw_depth_image[y_min:y_max, x_min:x_max]).flatten()
        obj_depths = obj_depths / depth_scale
        obj_depths = obj_depths[obj_depths != 0]
     
        hist, hist_edges = np.histogram(obj_depths, bins=num_bins, range=(0, max_distance))
     
        edges_zipped = zip(hist_edges[:-1], hist_edges[1:])
        # Iterate over the histogram and return the first distance with enough points.
        for entry, edges in zip(hist, edges_zipped):
            if entry > minimum_number_of_points:
                filtered_depths = obj_depths[(obj_depths > edges[0]) & (obj_depths < edges[1])]
                if len(filtered_depths) == 0:
                    continue
                return np.mean(filtered_depths)
     
        return max_distance
     
     
    def rotate_about_origin_degrees(origin, point, angle):
        """
        Rotate a point counterclockwise by a given angle around a given origin.
     
        Args:
            origin (tuple): Origin to rotate the point around
            point (tuple): Point to rotate
            angle (float): Angle in degrees
        """
        return rotate_about_origin(origin, point, math.radians(angle))
     
     
    def rotate_about_origin(origin, point, angle):
        """
        Rotate a point counterclockwise by a given angle around a given origin.
     
        Args:
            origin (tuple): Origin to rotate the point around
            point (tuple): Point to rotate
            angle (float): Angle in radians
        """
        orig_x, orig_y = origin
        pnt_x, pnt_y = point
     
        ret_x = orig_x + math.cos(angle) * (pnt_x - orig_x) - math.sin(angle) * (pnt_y - orig_y)
        ret_y = orig_y + math.sin(angle) * (pnt_x - orig_x) + math.cos(angle) * (pnt_y - orig_y)
        return int(ret_x), int(ret_y)
     
     
    def get_object_position(world_tform_cam, world_tform_gpe, visual_dims, depth_image, bounding_box,
                            rotation_angle):
        """
        Extract the bounding box, then find the mode in that region.
     
        Args:
            world_tform_cam (SE3Pose): SE3 transform from world to camera frame
            visual_dims (Tuple): (cols, rows) tuple from the visual image
            depth_image (ImageResponse): From a depth camera corresponding to the visual_image
            bounding_box (list): Bounding box from tensorflow
            rotation_angle (float): Angle (in degrees) to rotate depth image to match cam image rotation
        """
     
        # Make sure there are two images.
        if visual_dims is None or depth_image is None:
            # Fail.
            return
     
        # Rotate bounding box back to original frame
        points = [(bounding_box[1], bounding_box[0]), (bounding_box[3], bounding_box[0]),
                  (bounding_box[3], bounding_box[2]), (bounding_box[1], bounding_box[2])]
     
        origin = (visual_dims[0] / 2, visual_dims[1] / 2)
     
        points_rot = [rotate_about_origin_degrees(origin, point, rotation_angle) for point in points]
     
        # Get the bounding box corners.
        y_min = max(0, min([point[1] for point in points_rot]))
        x_min = max(0, min([point[0] for point in points_rot]))
        y_max = min(visual_dims[1], max([point[1] for point in points_rot]))
        x_max = min(visual_dims[0], max([point[0] for point in points_rot]))
     
        # Check that the bounding box is valid.
        if (x_min < 0 or y_min < 0 or x_max > visual_dims[0] or y_max > visual_dims[1]):
            print(f'Bounding box is invalid: ({x_min}, {y_min}) | ({x_max}, {y_max})')
            print(f'Bounds: ({visual_dims[0]}, {visual_dims[1]})')
            return
     
        # Unpack the images.
        try:
            if depth_image.shot.image.pixel_format == image_pb2.Image.PIXEL_FORMAT_DEPTH_U16:
                dtype = np.uint16
            else:
                dtype = np.uint8
            img = np.fromstring(depth_image.shot.image.data, dtype=dtype)
            if depth_image.shot.image.format == image_pb2.Image.FORMAT_RAW:
                img = img.reshape(depth_image.shot.image.rows, depth_image.shot.image.cols)
            else:
                img = cv2.imdecode(img, -1)
            depth_image_pixels = img
            depth_image_pixels = remove_ground_from_depth_image(
                depth_image_pixels, depth_image.source.pinhole.intrinsics.focal_length,
                depth_image.source.pinhole.intrinsics.principal_point, world_tform_cam, world_tform_gpe)
            # Get the depth data from the region in the bounding box.
            max_distance = 8.0
            depth = get_distance_to_closest_object_depth(x_min, x_max, y_min, y_max,
                                                         depth_image.source.depth_scale,
                                                         depth_image_pixels, max_distance=max_distance)
     
            if depth >= max_distance:
                # Not enough depth data.
                print('Not enough depth data.')
                return False
            else:
                print(f'distance to object: {depth}')
     
            center_x = round((x_max - x_min) / 2.0 + x_min)
            center_y = round((y_max - y_min) / 2.0 + y_min)
     
            tform_x, tform_y, tform_z = depth_to_xyz(
                depth, center_x, center_y, depth_image.source.pinhole.intrinsics.focal_length,
                depth_image.source.pinhole.intrinsics.principal_point)
            camera_tform_obj = SE3Pose(tform_x, tform_y, tform_z, Quat())
     
            return world_tform_cam * camera_tform_obj
        except Exception as exc:  # pylint: disable=broad-except
            print(f'Error getting object position: {exc}')
            return
     
     
    def _check_model_path(model_path):
        if model_path is None or \
        not os.path.exists(model_path) or \
        not os.path.isfile(model_path):
            print(f'ERROR, could not find model file {model_path}')
            return False
        return True
     
     
    def _check_and_load_json_classes(config_path):
        if os.path.isfile(config_path):
            with open(config_path) as json_classes:
                global COCO_CLASS_DICT  # pylint: disable=global-statement
                COCO_CLASS_DICT = json.load(json_classes)
     
     
    def _find_highest_conf_source(processed_boxes_entry):
        highest_conf_source = None
        max_score = 0
        for key, capture in processed_boxes_entry.items():
            if 'scores' in capture.keys():
                if len(capture['scores']) > 0 and capture['scores'][0] > max_score:
                    highest_conf_source = key
                    max_score = capture['scores'][0]
        return highest_conf_source
     
     
    def signal_handler(signal, frame):
        print('Interrupt caught, shutting down')
        SHUTDOWN_FLAG.value = 1
     
     
    def main():
        """Command line interface."""
     
        parser = argparse.ArgumentParser()
        parser.add_argument(
            '--model-path', default='/model.pb', help=
            ('Local file path to the Tensorflow model, example pre-trained models can be found at '
             'https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/tf1_detection_zoo.md'
            ))
        parser.add_argument('--classes', default='/classes.json', type=str,
                            help='File containing json mapping of object class IDs to class names')
        parser.add_argument('--number-tensorflow-processes', default=1, type=int,
                            help='Number of Tensorflow processes to run in parallel')
        parser.add_argument('--detection-threshold', default=0.7, type=float,
                            help='Detection threshold to use for Tensorflow detections')
        parser.add_argument(
            '--sleep-between-capture', default=0.2, type=float,
            help=('Seconds to sleep between each image capture loop iteration, which captures '
                  'an image from all cameras'))
        parser.add_argument(
            '--detection-class', default=1, type=int,
            help=('Detection classes to use in the Tensorflow model.'
                  'Default is to use 1, which is a person in the Coco dataset'))
        parser.add_argument(
            '--max-processing-delay', default=7.0, type=float,
            help=('Maximum allowed delay for processing an image. '
                  'Any image older than this value will be skipped'))
        parser.add_argument('--test-mode', action='store_true',
                            help='Run application in test mode, don\'t execute commands')
     
        bosdyn.client.util.add_base_arguments(parser)
        bosdyn.client.util.add_payload_credentials_arguments(parser)
        options = parser.parse_args()
        signal.signal(signal.SIGINT, signal_handler)
        try:
            # Make sure the model path is a valid file
            if not _check_model_path(options.model_path):
                return False
     
            # Check for classes json file, otherwise use the COCO class dictionary
            _check_and_load_json_classes(options.classes)
     
            global TENSORFLOW_PROCESS_BARRIER  # pylint: disable=global-statement
            TENSORFLOW_PROCESS_BARRIER = Barrier(options.number_tensorflow_processes + 1)
            # Start Tensorflow processes
            tf_processes = start_tensorflow_processes(options.number_tensorflow_processes,
                                                      options.model_path, options.detection_class,
                                                      options.detection_threshold,
                                                      options.max_processing_delay)
     
            # sleep to give the Tensorflow processes time to initialize
            try:
                TENSORFLOW_PROCESS_BARRIER.wait()
            except BrokenBarrierError as exc:
                print(f'Error waiting for Tensorflow processes to initialize: {exc}')
                return False
            # Start the API related things
     
            # Create robot object with a world object client
            sdk = bosdyn.client.create_standard_sdk('SpotFollowClient')
            robot = sdk.create_robot(options.hostname)
     
            if options.payload_credentials_file:
                robot.authenticate_from_payload_credentials(
                    *bosdyn.client.util.get_guid_and_secret(options))
            else:
                bosdyn.client.util.authenticate(robot)
     
            # Time sync is necessary so that time-based filter requests can be converted
            robot.time_sync.wait_for_sync()
     
            # Verify the robot is not estopped and that an external application has registered and holds
            # an estop endpoint.
            assert not robot.is_estopped(), 'Robot is estopped. Please use an external E-Stop client,' \
                                            ' such as the estop SDK example, to configure E-Stop.'
     
            # Create the sdk clients
            robot_state_client = robot.ensure_client(RobotStateClient.default_service_name)
            robot_command_client = robot.ensure_client(RobotCommandClient.default_service_name)
            lease_client = robot.ensure_client(LeaseClient.default_service_name)
            image_client = robot.ensure_client(ImageClient.default_service_name)
            source_list = get_source_list(image_client)
            image_task = AsyncImage(image_client, source_list)
            robot_state_task = AsyncRobotState(robot_state_client)
            task_list = [image_task, robot_state_task]
            _async_tasks = AsyncTasks(task_list)
            print('Detect and follow client connected.')
     
            lease = lease_client.take()
            lease_keep = LeaseKeepAlive(lease_client)
            # Power on the robot and stand it up
            resp = robot.power_on()
            try:
                blocking_stand(robot_command_client)
            except CommandFailedError as exc:
                print(f'Error ({exc}) occurred while trying to stand. Check robot surroundings.')
                return False
            except CommandTimedOutError as exc:
                print(f'Stand command timed out: {exc}')
                return False
            print('Robot powered on and standing.')
            params_set = get_mobility_params()
     
            # This thread starts the async tasks for image and robot state retrieval
            update_thread = Thread(target=_update_thread, args=[_async_tasks])
            update_thread.daemon = True
            update_thread.start()
            # Wait for the first responses.
            while any(task.proto is None for task in task_list):
                time.sleep(0.1)
     
            # Start image capture process
            image_capture_thread = Process(target=capture_images,
                                           args=(image_task, options.sleep_between_capture),
                                           daemon=True)
            image_capture_thread.start()
            while not SHUTDOWN_FLAG.value:
                # This comes from the tensorflow processes and limits the rate of this loop
                try:
                    entry = PROCESSED_BOXES_QUEUE.get_nowait()
                except Empty:
                    continue
                # find the highest confidence bounding box
                highest_conf_source = _find_highest_conf_source(entry)
                if highest_conf_source is None:
                    # no boxes or scores found
                    continue
                capture_to_use = entry[highest_conf_source]
                raw_time = capture_to_use['raw_image_time']
                time_gap = time.time() - raw_time
                if time_gap > options.max_processing_delay:
                    continue  # Skip image due to delay
     
                # Find the transform to the highest confidence object using the depth sensor
                get_object_position_start = time.time()
                robot_state = robot_state_task.proto
                world_tform_gpe = get_a_tform_b(robot_state.kinematic_state.transforms_snapshot,
                                                VISION_FRAME_NAME, GROUND_PLANE_FRAME_NAME)
                world_tform_object = get_object_position(
                    capture_to_use['world_tform_cam'], world_tform_gpe, capture_to_use['visual_dims'],
                    capture_to_use['depth_image'], capture_to_use['boxes'][0],
                    ROTATION_ANGLES[capture_to_use['source']])
                get_object_position_end = time.time()
                print(f'system_cap_time: {capture_to_use["system_cap_time"]}, '
                      f'image_queued_time: {capture_to_use["image_queued_time"]}, '
                      f'processed_image_start_time: {capture_to_use["processed_image_start_time"]}, '
                      f'processed_image_end_time: {capture_to_use["processed_image_end_time"]}, '
                      f'get_object_position_start_time: {get_object_position_start}, '
                      f'get_object_position_end_time: {get_object_position_end}, ')
     
                # get_object_position can fail if there is insufficient depth sensor information
                if not world_tform_object:
                    continue
     
                scores = capture_to_use['scores']
                print(f'Position of object with confidence {scores[0]}: {world_tform_object}')
                print(f'Process latency: {time.time() - capture_to_use["system_cap_time"]}')
                tag_cmd = get_go_to(world_tform_object, robot_state, params_set)
                end_time = 15.0
                if tag_cmd is not None:
                    if not options.test_mode:
                        print('executing command')
                        robot_command_client.robot_command(lease=None, command=tag_cmd,
                                                           end_time_secs=time.time() + end_time)
                    else:
                        print('Running in test mode, skipping command.')
     
            # Shutdown lease keep-alive and return lease gracefully.
            lease_keep.shutdown()
            lease_client.return_lease(lease)
            return True
        except Exception as exc:  # pylint: disable=broad-except
            LOGGER.error('Spot Tensorflow Detector threw an exception: %s', exc)
            # Shutdown lease keep-alive and return lease gracefully.
            return False 
     
     
    if __name__ == '__main__':
        if not main():
            sys.exit(1)

    Ce sont les tentatives de mise au rebut total des humains au profit de la machine qui continuent à faire couler beaucoup d’encre

    La technologie des caisses dites automatiques devait révolutionner le shopping. Mais, tant pour les consommateurs que pour les commerçants, elle n’a pas tenu ses promesses comme l’illustre le cas McDonald’s.

    « Ça n’a rien apporté de ce qu’elle promettait », souligne Christopher Andrews, professeur associé et président de sociologie à l’université Drew, aux États-Unis, et auteur de The Overworked Consumer: Self-Checkouts, Supermarkets, and the Do-It-Yourself Economy. « Les magasins voyaient cela comme la nouvelle frontière… S’ils pouvaient faire croire au consommateur que [la caisse automatique] était un moyen préférable de faire ses courses, alors ils pourraient réduire les coûts de main-d’œuvre. Mais ils se rendent compte que les gens ont besoin d’aide pour le faire, ou qu’ils vont voler des choses. Ils ont fini par se rendre compte qu’ils ne font pas d’économies, ils perdent de l’argent ».

    De nombreuses entreprises de vente au détail ont investi des millions - voire des milliards - de dollars dans la technologie des caisses automatiques, qui, selon Andrews, a été développée pour la première fois dans les années 1980, et a commencé à apparaître dans les magasins dans les années 1990. Elles ne sont pas exactement bon marché à installer dans les magasins : certains experts estiment qu’un système de quatre bornes peut coûter six chiffres. Malgré le coût pour les installer, de nombreux détaillants font marche arrière sur la technologie. Target, par exemple, limite le nombre d’articles que les clients des caisses automatiques peuvent acheter en une seule fois. Walmart a supprimé certaines bornes de caisse automatique dans certains magasins pour dissuader les vols. Au Royaume-Uni, la chaîne de supermarchés Booths a également réduit le nombre de bornes de libre-service dans ses magasins, car les clients disent qu’elles sont lentes et peu fiables. Dollar General, l’une des entreprises de vente au détail qui connaît la plus forte croissance aux États-Unis, revoit également sa stratégie.

    En 2022, la chaîne de magasins à prix réduit a misé fortement sur la technologie des caisses automatiques - il n’est pas rare de voir un ou deux employés seulement s’occuper d’un magasin entier de Dollar General dans certaines régions. Mais la société a annoncé en janvier 2024 qu’elle allait réduire le nombre de caisses automatiques dans ses magasins, après avoir constaté que les clients préféraient interagir avec un caissier humain. « Nous avons appris que nos clients apprécient vraiment le contact humain », a déclaré Todd Vasos, le PDG de Dollar General, lors d’une conférence téléphonique avec les analystes.

    Les clients ne sont pas les seuls à être mécontents de la technologie des caisses automatiques. Les employés des magasins se plaignent également du stress supplémentaire qu’elle leur impose, car ils doivent surveiller plusieurs machines à la fois, tout en gérant les autres tâches du magasin. Certains syndicats ont même lancé des campagnes pour inciter les clients à boycotter les caisses automatiques, afin de protéger les emplois des caissiers. Selon une étude de l’université d’Oxford, les caissiers sont parmi les métiers les plus menacés par l’automatisation, avec un risque de 97% de voir leur travail remplacé par des machines.

    Il y a plusieurs raisons possibles de cet échec, selon les experts. Tout d’abord, il y a le problème de la conception. Les machines sont souvent mal adaptées aux besoins des clients, qui doivent scanner des codes-barres illisibles, taper des codes PLU spécifiques, peser des articles, payer avec des cartes ou des espèces, et placer leurs achats dans des sacs. Le moindre faux pas peut déclencher une alerte sonore et un message d’erreur, comme « article inattendu dans la zone de conditionnement », qui nécessite l’intervention d’un employé. Les clients peuvent se sentir frustrés, confus ou gênés par ces incidents, qui ralentissent le processus de paiement.

    Ensuite, il y a le problème de la confiance. Les clients peuvent avoir l’impression que les machines essaient de les tromper, en leur facturant des articles en double, en leur refusant des réductions ou en leur imposant des frais supplémentaires. Les commerçants, quant à eux, doivent faire face au risque de vol, qui est plus élevé avec les caisses automatiques qu’avec les caisses traditionnelles. Selon une étude de l’université de Leicester, au Royaume-Uni, le taux de perte dans les magasins avec des caisses automatiques était de 4%, contre 1,47% dans les magasins sans. Les chercheurs ont attribué ce phénomène à la facilité avec laquelle les clients peuvent tromper les machines, en scannant des articles moins chers à la place de ceux qu’ils achètent, en ne scannant pas certains articles du tout, ou en utilisant des codes de réduction frauduleux.

    Enfin, il y a le problème de la relation. Les clients peuvent se sentir déshumanisés par les machines, qui leur parlent avec une voix synthétique et leur donnent des instructions impersonnelles. Ils peuvent aussi regretter l’absence d’interaction sociale avec un caissier humain, qui peut leur sourire, leur faire la conversation ou leur donner des conseils. Les caissiers, de leur côté, peuvent se sentir dévalorisés par les machines, qui leur font perdre leur rôle de service à la clientèle et les transforment en simples surveillants ou réparateurs. Les machines peuvent aussi créer un sentiment de concurrence ou de menace, car elles représentent une possible substitution de leur travail.

    Certains services s’appuient même sur les humains pour simuler l’intelligence artificielle

    Lors de l’ouverture de l’Amazon Go Grocery, le premier supermarché automatisé et sans caissiers à Seattle, « Just Walk Out » avait fait l’objet de présentation en tant que « technologie d’achat la plus avancée au monde. » Bien que le service dans ces supermarchés semblait entièrement automatisé, il s'appuyait sur plus de 1000 personnes en Inde qui regardaient et étiquetaient des vidéos pour assurer la facturation « automatique ». En d’autres termes, les caissiers étaient en réalité hors du site, et ils observaient les clients pendant leurs achats. Les rapports y relatifs font état de ce que l’entreprise a décidé de conserver sa « technologie » dans un petit nombre de magasins Fresh au Royaume-Uni et la retirer de ces derniers aux USA.

    Just Walk Out a été introduit pour la première fois en 2016. Cette technologie avait fait l'objet de présentation comme la plus importante et la plus audacieuse d'Amazon en matière d'achats de produits d'épicerie. La technologie semblait incroyable jusqu'à ce qu'on en découvre les dessous. En effet, les clients mettaient souvent des heures à recevoir leurs reçus après avoir quitté le magasin, en grande partie parce que les caissiers délocalisés visionnaient à nouveau les vidéos et attribuaient les articles à différents clients. Le système de scanners et de caméras vidéo dans chaque magasin est en sus très coûteux. D’où la décision d’Amazon d’abandonner cette « technologie » en commençant par ses magasins Fresh aux USA.

    Et vous ?

    Quels sont les secteurs d’activités pour lesquels il fait sens de mettre à contribution les robots et l’intelligence artificielle ?
    Quels sont les domaines pour lesquelles les tentatives de mise au rebut total des humains au profit des machines et de l’intelligence artificielle continueront de poser problème pour de nombreuses années encore ?

    Voir aussi :

    57 % des travailleurs dans l'industrie technologique dans la Silicon Valley ont déclaré être en burn out, d'après une enquête
    Les chercheurs en intelligence artificielle peuvent-ils gagner jusqu'à 1 million $ par an dans la Silicon Valley ? un aperçu des salaires
    La bulle technologique de la Silicon Valley est plus grande qu'elle ne l'était en 2000, mais sa fin approche selon des analystes
    Contribuez au club : Corrections, suggestions, critiques, ... : Contactez le service news et Rédigez des actualités

  3. #3
    Membre régulier
    Homme Profil pro
    mécanicien
    Inscrit en
    Mai 2024
    Messages
    54
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Lot (Midi Pyrénées)

    Informations professionnelles :
    Activité : mécanicien

    Informations forums :
    Inscription : Mai 2024
    Messages : 54
    Points : 74
    Points
    74
    Par défaut
    Quels sont les domaines pour lesquelles les tentatives de mise au rebut total des humains au profit des machines et de l’intelligence artificielle continueront de poser problème pour de nombreuses années encore ?
    Hmm, ça c'est une vraie question biaisée se référant à l'économie pyramidale de la rentabilité et de la maximisation des profits.

    Quels sont les secteurs d’activités pour lesquels il fait sens de mettre à contribution les robots et l’intelligence artificielle ?
    Tous les secteurs dans le cas d'une mise à contribution mais c'est d'une autre économie dont il s'agit.

  4. #4
    Membre éclairé

    Profil pro
    Inscrit en
    Mai 2003
    Messages
    315
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2003
    Messages : 315
    Points : 748
    Points
    748
    Billets dans le blog
    1
    Par défaut
    Je suis assez dubitatif sur le caractère optimal d'une forme humanoïde pour ce genre de travaux, comparé à une simple échelle avec des pinces, et des caméras directement dans les pinces plutôt que sur une tête à distance. Mais bon, si ça leur fait plaisir, moi aussi lol

  5. #5
    Nouveau Candidat au Club
    Femme Profil pro
    Webmarketer
    Inscrit en
    Juillet 2024
    Messages
    1
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 26
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : Webmarketer
    Secteur : Communication - Médias

    Informations forums :
    Inscription : Juillet 2024
    Messages : 1
    Points : 1
    Points
    1
    Par défaut
    Avec l’intelligence artificielle les robots s'améliorent de plus en plus. Pourquoi ne pas les confier les tâches ingrates ou qui peuvent nuire à notre intégrité (militaire, éboueur, ...)

  6. #6
    Membre extrêmement actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    1 907
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 1 907
    Points : 6 065
    Points
    6 065
    Par défaut Ce n'est pas un robot mais une machine de chantier!!!!!!!!
    Prenez la peine de regarder la vidéo et vous constaterez par vous-même qu'il ne s'agit pas d'un robot fonctionnant de manière autonome via une IA ou n'importe quel autre processus informatique!!!!!!

    Sur la voie de chemin de fer, au sol, en-dessous de ce pseudo-robot, il y a un opérateur affairé sur un boitier de commande bleu avec 2 câbles qui relient le boitier au... pseudo-robot!!!!!!!!!!!!!!!!!!!!

    Allez sur un chantier de BTP, vous verrez plein de "robots" de ce type, ils sont de couleur jaune et se nomment des "grues de levage"... Et oui, il y a longtemps que les conducteurs de grue ne grimpent plus dans l'engin 20 mètres au-dessus du sol, la grue est commandée depuis le sol à l'aide d'une télécommande.

    Il serait temps que les médias fasse la différence entre un simple programme informatique et de l'IA, entre un robot et simple outils télécommandé par un opérateur!!!!

  7. #7
    Expert éminent sénior

    Homme Profil pro
    Directeur des systèmes d'information
    Inscrit en
    Avril 2002
    Messages
    2 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 64
    Localisation : Luxembourg

    Informations professionnelles :
    Activité : Directeur des systèmes d'information
    Secteur : Finance

    Informations forums :
    Inscription : Avril 2002
    Messages : 2 828
    Points : 19 156
    Points
    19 156
    Par défaut
    C'est marqué dans la news, que tu n'a sans doute pas lue, qu'il y a un opérateur.

    En effet il ne s'agit pas d'un robot totalement autonome, ce que la news explique très bien, mais il y a un logiciel et son fonctionnement est donc partiellement automatisé, de toute façon l'usage du terme « robot » s'est galvaudé pour prendre des sens plus larges : automate distributeur, dispositif électro-mécanique de forme humaine ou animale, logiciel servant d'adversaire sur les plateformes de jeu, bot informatique.

    Donc ici même si on était sur ça : "dispositif électro-mécanique de forme humaine " ça reste du point de vue des gens un "robot", mais c'est bien plus qu'une simple "machine de chantier", vu qu'il y a des logiciels complexes pour le faire fonctionner.
    Ne prenez pas la vie au sérieux, vous n'en sortirez pas vivant ...

  8. #8
    Membre extrêmement actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    1 907
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 1 907
    Points : 6 065
    Points
    6 065
    Par défaut
    Citation Envoyé par Pierre Louis Chevalier Voir le message
    C'est marqué dans la news, que tu n'a sans doute pas lue, qu'il y a un opérateur.

    En effet il ne s'agit pas d'un robot totalement autonome, ce que la news explique très bien, mais il y a un logiciel et son fonctionnement est donc partiellement automatisé, de toute façon l'usage du terme « robot » s'est galvaudé pour prendre des sens plus larges : automate distributeur, dispositif électro-mécanique de forme humaine ou animale, logiciel servant d'adversaire sur les plateformes de jeu, bot informatique.

    Donc ici même si on était sur ça : "dispositif électro-mécanique de forme humaine " ça reste du point de vue des gens un "robot", mais c'est bien plus qu'une simple "machine de chantier", vu qu'il y a des logiciels complexes pour le faire fonctionner.
    A la différence de vous et des 5 gugusses qui ont voté négativement mon commentaire, je suis actif dans la robotique et l'on a pas affaire ici à un robot. Pour votre gouverne, la présence d'un logiciel n'est pas le critère qui fait d'une machine télécommandée et contrôlée par l'humain un robot!!!

    Alors je vous invite a continuer à noter mon commentaire négativement, vous ne faites que prouver votre ignorance totale du domaine!

    Mais bon, commenter ce que l'on ne connait pas est devenu maintenant à la mode dans les forum et autres réseaux sociaux...

  9. #9
    Expert éminent sénior

    Homme Profil pro
    Directeur des systèmes d'information
    Inscrit en
    Avril 2002
    Messages
    2 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 64
    Localisation : Luxembourg

    Informations professionnelles :
    Activité : Directeur des systèmes d'information
    Secteur : Finance

    Informations forums :
    Inscription : Avril 2002
    Messages : 2 828
    Points : 19 156
    Points
    19 156
    Par défaut
    Je comprends ce que tu dis mais la réponse est expliquée plus haut je la reposte encore vu que tu réponds aux messages et aux news sans les lires manifestement : Définition Robot.

    Toi tu es la :
    Les premiers robots industriels apparaissent, malgré leur coût élevé, au début des années 1970. Ils sont destinés à exécuter certaines tâches répétitives, éprouvantes ou toxiques pour un opérateur humain : peinture ou soudage des carrosseries automobiles. Aujourd'hui, l'évolution de l'électronique et de l'informatique permet de développer des robots plus précis, plus rapides ou avec une meilleure autonomie. Industriels, militaires ou spécialistes chirurgicaux rivalisent d'inventivité pour mettre au point des robots assistants les aidant dans la réalisation de tâches délicates ou dangereuses.
    Oui mais ensuite :
    L'usage du terme « robot » s'est galvaudé pour prendre des sens plus larges : automate distributeur, dispositif électro-mécanique de forme humaine ou animale, logiciel servant d'adversaire sur les plateformes de jeu, bot informatique.
    En terme grand public on en est la dans cet exemple : "dispositif électro-mécanique de forme humaine".
    Tu as parfaitement le droit de penser qu'en tant qu'ingénieur informatique ça n'est pas un robot, mais c'est ta vision ingénieur pas la vision générale et grand public.

    Dans cette vidéo par exemple selon ton point de vue cette machine pilotée par un opérateur ne serait pas un "robot", et pourtant l'INRIA appelle bien cette chose un 'Robot' . Donc si tu veux élargir ton commentaire au reste de la planète, tu peux par exemple commencer en tant que "génie expert en robotique" (et si on en crois tes autres messages : expert en tout) par traiter l'INRIA de bande de bons à rien ignares et incompétents si ça te fais plaisir, tu es libre

    Ne prenez pas la vie au sérieux, vous n'en sortirez pas vivant ...

  10. #10
    Membre extrêmement actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Octobre 2017
    Messages
    1 907
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : Octobre 2017
    Messages : 1 907
    Points : 6 065
    Points
    6 065
    Par défaut
    Citation Envoyé par Pierre Louis Chevalier Voir le message

    Dans cette vidéo par exemple selon ton point de vue cette machine pilotée par un opérateur ne serait pas un "robot", et pourtant l'INRIA appelle bien cette chose un 'Robot' . Donc si tu veux élargir ton commentaire au reste de la planète, tu peux par exemple commencer en tant que "génie expert en robotique" (et si on en crois tes autres messages : expert en tout) par traiter l'INRIA de bande de bons à rien ignares et incompétents si ça te fais plaisir, tu es libre

    Ta réponse est parfaitement futile.

    1. J'ai pas besoin de ta reconnaissance, la reconnaissance d'un mec pour qui la présence d'un logiciel est LE critère pour indiquer qu'il s'agit d'un robot ou non. A ce propos, ta voiture qui fonctionne à l'aide de plusieurs logiciels embarqués, c'est un robot?

    2. Ce forum n'est pas destiné au "grand public"... Quand Mme Michu ma boulangère voit des robots partout, je l'excuse, pas ceux qui se disent travailler dans la technique!

    3. Je n'ai dit à aucun moment être un "génie expert en robotique" mais à la différence de toi, j'ai fait de nombreux projets en robotique. Je ne sors pas de l'INRIA mais d'une école d'ingénieurs de niveau universitaire qui est classée dans les meilleurs écoles du monde sans comparaison possible avec ton INRIA. Je ne suis pas non plus un mec qui se dit "ingénieur en informatique" ou "développeur informatique" parce qu'il pond des sites internet (il ne faut se fier au libellé que l'on donne à son profil, il y en a bien qui se disent "Directeur informatique". J'en connais d'ailleurs qui porte officiellement ce titre en étant le seul collaborateur de département informatique de leur entreprise ). On est clairement pas actif dans le même monde: Il y a les vrais ingénieurs qui font appel à de l'informatique comme outils et il y a les bidouilleurs en informatique qui se disent "ingénieur"... Deux termes identiques qui ne décrivent clairement pas le même métier!


    Info à tous les lecteurs de ces lignes: Connaître 2 ou 3 langages de programmation ne fait pas de vous un "ingénieur" mais juste un "développeur"... Quand votre employeur vous donne du titre d'ingénieur, c'est comme les médailles à l'armée, c'est juste honorifique et cela évite de vous payer un vrai salaire!!! Un ingénieur a par définition une connaissance technique large et multi-domaine!

    Alors je te laisse à tes convictions: Si tu veux voir des robots là ou il n'y en a pas, cela ne va pas m'empêcher de dormir...

  11. #11
    Expert éminent sénior

    Homme Profil pro
    Directeur des systèmes d'information
    Inscrit en
    Avril 2002
    Messages
    2 828
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 64
    Localisation : Luxembourg

    Informations professionnelles :
    Activité : Directeur des systèmes d'information
    Secteur : Finance

    Informations forums :
    Inscription : Avril 2002
    Messages : 2 828
    Points : 19 156
    Points
    19 156
    Par défaut
    Ca n'est pas moi qui "vois des robots partout", personnellement je m'en tape, je t'explique juste à juste titre pourquoi par exemple wikipédia et le monde entier, y compris des ingénieurs et des chercheurs sont arrivés à ça c'est tout : Robot -> 'dispositif électro-mécanique de forme humaine'.

    Je respecte ton point de vue qui est tout à fait compréhensible, mais c'est pas pour autant que tu dois te sentir obligé de traiter le monde entier d'abrutis ignares et incompétents parce qu'on aurais pas "ton énorme expérience en robotique"
    Ne prenez pas la vie au sérieux, vous n'en sortirez pas vivant ...

  12. #12
    Expert éminent sénior
    Homme Profil pro
    Responsable Données
    Inscrit en
    Janvier 2009
    Messages
    5 240
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 50
    Localisation : France, Hérault (Languedoc Roussillon)

    Informations professionnelles :
    Activité : Responsable Données

    Informations forums :
    Inscription : Janvier 2009
    Messages : 5 240
    Points : 12 872
    Points
    12 872
    Par défaut
    Et du coup, ce que j'ai utilisé ce week-end pour faire mes gnocchis, c'est un robot pâtissier, ou un vulgaire batteur ?


    Tatayo.

  13. #13
    Membre extrêmement actif
    Homme Profil pro
    Inscrit en
    Janvier 2014
    Messages
    1 522
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Janvier 2014
    Messages : 1 522
    Points : 5 802
    Points
    5 802
    Par défaut
    Citation Envoyé par tatayo Voir le message
    Et du coup, ce que j'ai utilisé ce week-end pour faire mes gnocchis, c'est un robot pâtissier, ou un vulgaire batteur ?


    Tatayo.
    C'est une "machine de chantier ! espèce d'ignare incompétent qui comprend rien à la robotique ! "

    « L’humour est une forme d'esprit railleuse qui s'attache à souligner le caractère comique, ridicule, absurde ou insolite de certains aspects de la réalité »

Discussions similaires

  1. Réponses: 7
    Dernier message: 14/11/2019, 08h43
  2. Réponses: 3
    Dernier message: 28/04/2009, 00h42
  3. Réponses: 6
    Dernier message: 09/12/2008, 09h45
  4. Réponses: 2
    Dernier message: 01/12/2006, 10h09
  5. Réponses: 1
    Dernier message: 07/06/2006, 18h56

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo