VisualNavigation--3D 环境 ai2thor keyboard

import ai2thor
from ai2thor.controller import Controller


def ai2thor_attr_print(ai2thor_display=False):
    if ai2thor_display:
        print(ai2thor)
        # < module 'ai2thor'>
        print(dir(ai2thor))
        # ['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__',
        # '__spec__', '__version__', '_builds', '_quality_settings', '_version', 'controller', 'docker',
        # 'downloader', 'interact', 'server', 'util']
        print(len(dir(ai2thor)))
        # 19

        help(ai2thor)


def ai2thor_controller_attr_print(ai2thor_controller_display=False):
    if ai2thor_controller_display:
        print(ai2thor.controller)
        # <module 'ai2thor.controller'>
        print(dir(ai2thor.controller))
        # ['BFSController', 'BFSSearchPoint', 'BUILDS', 'Controller', 'DEFAULT_QUALITY', 'DefaultActions',
        # 'DepthFormat', 'InteractiveControllerPrompt', 'QUALITY_SETTINGS', 'Queue', 'RECEPTACLE_OBJECTS',
        # '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__',
        # 'ai2thor', 'atexit', 'copy', 'defaultdict', 'deque', 'distance', 'fcntl', 'get_term_character', 'io',
        # 'json', 'key_for_point', 'logger', 'logging', 'makedirs', 'math', 'np', 'os', 'platform', 'process_alive',
        # 'product', 'queue_get', 'random', 're', 'shlex', 'shutil', 'signal', 'subprocess', 'sys', 'termios',
        # 'threading', 'time', 'tty', 'uuid', 'zipfile']
        print(len(dir(ai2thor.controller)))
        # 53

        # which objects could be placed in a receptacle
        # print(ai2thor.controller.RECEPTACLE_OBJECTS)

        help(ai2thor.controller)


def Controller_attr_print(Controller_display=False):
    if Controller_display:
        print(Controller)
        # <class 'ai2thor.controller.Controller'>
        print(dir(Controller))
        # '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__enter__', '__eq__', '__exit__',
        # '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__',
        # '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
        # '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_start_server_thread',
        # '_start_unity_thread', 'base_dir', 'build_name', 'build_url', 'check_docker', 'check_x_display',
        # 'download_binary', 'executable_path', 'interact', 'lock_release', 'multi_step_physics',
        # 'next_interact_command', 'prune_releases', 'random_initialize', 'releases_dir', 'reset', 'robothor_scenes',
        # 'scene_names', 'scenes_in_build', 'start', 'step', 'stop', 'stop_container', 'stop_unity', 'unity_command',
        # 'unlock_release']
        print(len(dir(Controller)))
        # 55

        # print([e for e in dir(Controller) if not e.startswith('_')])

        help(Controller)
        # Controller(quality='Ultra', fullscreen=False, headless=False, port=0, start_unity=True,
        # local_executable_path=None, width=300, height=300, x_display=None, host='127.0.0.1',
        # scene='FloorPlan_Train1_1', image_dir='.', save_image_per_frame=False, docker_enabled=False,
        # depth_format=<DepthFormat.Meters: (0,)>, add_depth_noise=False, download_only=False,
        # **unity_initialization_parameters)


def event_data_print(event_display=False):
    global event
    if event_display:
        # print(event)
        print(dir(event))
        # ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
        # '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__',
        # '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
        # '__str__', '__subclasshook__', '__weakref__', '_image_depth', 'add_image', 'add_image_classes',
        # 'add_image_depth', 'add_image_depth_robot', 'add_image_flows', 'add_image_ids', 'add_image_normals',
        # 'add_third_party_camera_image', 'add_third_party_image_classes', 'add_third_party_image_depth',
        # 'add_third_party_image_flows', 'add_third_party_image_ids', 'add_third_party_image_normals',
        # 'class_detections2D', 'class_masks', 'class_segmentation_frame', 'color_to_object_id', 'cv2image',
        # 'cv2img', 'depth_frame', 'events', 'flow_frame', 'frame', 'get_object', 'image_data',
        # 'instance_detections2D', 'instance_masks', 'instance_segmentation_frame', 'metadata', 'normals_frame',
        # 'object_id_to_color', 'objects_by_type', 'pose', 'pose_discrete', 'process_colors', 'process_colors_ids',
        # 'process_visible_bounds2D', 'screen_height', 'screen_width', 'third_party_camera_frames',
        # 'third_party_class_segmentation_frames', 'third_party_depth_frames', 'third_party_flows_frames',
        # 'third_party_instance_segmentation_frames', 'third_party_normals_frames']
        print(len(dir(event)))
        # 72

        # event.metadata
        print(type(event.metadata))
        # <class 'dict'>
        print(event.metadata)
        print(event.metadata.keys())
        # dict_keys(['objects', 'isSceneAtRest', 'agent', 'hand', 'fov', 'isStanding', 'cameraPosition',
        # 'cameraOrthSize', 'thirdPartyCameras', 'collided', 'collidedObjects', 'inventoryObjects', 'sceneName',
        # 'lastAction', 'errorMessage', 'errorCode', 'lastActionSuccess', 'screenWidth', 'screenHeight', 'agentId',
        # 'colors', 'colorBounds', 'reachablePositions', 'flatSurfacesOnGrid', 'distances', 'normals',
        # 'isOpenableGrid', 'segmentedObjectIds', 'objectIdsInBox', 'actionIntReturn', 'actionFloatReturn',
        # 'actionStringsReturn', 'actionFloatsReturn', 'actionVector3sReturn', 'visibleRange', 'actionReturn',
        # 'currentTime'])
        print(len(event.metadata.keys()))
        # 37

        # event.metadata['objects']
        print(type(event.metadata['objects']))
        # <class 'list'>
        print(event.metadata['objects'])
        # how many objects in current scene
        print(len(event.metadata['objects']))
        # 75
        print(type(event.metadata['objects'][0]))
        # <class 'dict'>
        print(event.metadata['objects'][0].keys())
        # dict_keys(['name', 'position', 'rotation', 'cameraHorizon', 'visible', 'receptacle', 'toggleable',
        # 'isToggled', 'breakable', 'isBroken', 'canFillWithLiquid', 'isFilledWithLiquid', 'dirtyable', 'isDirty',
        # 'canBeUsedUp', 'isUsedUp', 'cookable', 'isCooked', 'ObjectTemperature', 'canChangeTempToHot',
        # 'canChangeTempToCold', 'sliceable', 'isSliced', 'openable', 'isOpen', 'pickupable', 'isPickedUp', 'mass',
        # 'salientMaterials', 'receptacleObjectIds', 'distance', 'objectType', 'objectId', 'parentReceptacle',
        # 'parentReceptacles', 'currentTime', 'isMoving', 'objectBounds'])
        print(len(event.metadata['objects'][0].keys()))
        # 38


def key_press(key):
    global human_agent_action, human_wants_restart, stop_requested

    if key == 'R' or key == 'r':  # r/R
        human_wants_restart = True
    elif key == 'Q' or key == 'q':  # q/Q
        stop_requested = True
    elif key == '1':
        human_agent_action = 'MoveAhead'
    elif key == '2':
        human_agent_action = 'MoveBack'
    elif key == '3':
        human_agent_action = 'MoveRight'
    elif key == '4':
        human_agent_action = 'MoveLeft'
    elif key == '5':
        human_agent_action = 'RotateRight'
    elif key == '6':
        human_agent_action = 'RotateLeft'
    elif key == '7':
        human_agent_action = 'LookUp'
    elif key == '8':
        human_agent_action = 'LookDown'
    elif key == 'O' or key == 'o':
        human_agent_action = 'OpenObject'
    elif key == 'C' or key == 'c':
        human_agent_action = 'CloseObject'
    elif key == 'P' or key == 'p':
        human_agent_action = 'PickupObject'
    elif key == 'L' or key == 'l':
        human_agent_action = 'PutObject'
    else:
        print('Your entered key not supported!')
        key_again = input("input your action:")
        key_press(key_again)


def visible_objects_print(visible_objects_diaplay=False, visible_distance_display=False, visible_name_dispaly=False):
    global event
    visible_array = []
    if visible_objects_diaplay:
        if visible_distance_display and visible_name_dispaly:
            for o in event.metadata['objects']:
                if o['visible']:
                    # difference between name and objectId
                    name = o['name'].split('_')[0]
                    object_id = o['objectId'].split('|')[0]
                    distance = o['distance']
                    visible_array.append((name, object_id, distance))
            print("All visible objects and distance:\n", visible_array)
        elif visible_distance_display and not visible_name_dispaly:
            for o in event.metadata['objects']:
                if o['visible']:
                    object_id = o['objectId'].split('|')[0]
                    distance = o['distance']
                    visible_array.append((object_id, distance))
            print("All visible objects and distance:\n", visible_array)
        else:
            for o in event.metadata['objects']:
                if o['visible']:
                    object_id = o['objectId'].split('|')[0]
                    visible_array.append((object_id))
            print("All visible objects:\n", visible_array)


def open_object(distance_display=False, receptacle_objects_display=False):
    global env, event
    openable_objects = []
    openable_distance = []
    openable_objects_distance = []

    # what objects could open
    for o in event.metadata['objects']:
        if o['visible'] and o['openable'] and not o['isOpen']:
            openable_objects.append(o['objectId'])
            openable_distance.append(o['distance'])
            openable_objects_distance.append((o['objectId'], o['distance']))

    # select on object to open
    if len(openable_objects) == 0:
        print('No objects can open now!')
    else:
        if distance_display:
            print('openable objects and distance:', openable_objects_distance)
        else:
            print('openable objects:', openable_objects)
        open_obj = input("input open object:")
        if open_obj not in openable_objects:
            print('Wrong input object to open!')
            return
        else:
            event = env.step(action='OpenObject', objectId=open_obj, raise_for_failure=True)

        # display what objects contained in opened object
        if receptacle_objects_display:
            receptacle_objects = []
            for o in event.metadata['objects']:
                if o['objectId'] == open_obj:
                    receptacle_objects = o['receptacleObjectIds']
                    # print(receptacle_objects)
            visible_info = []
            for obj in receptacle_objects:
                for o in event.metadata['objects']:
                    if o['objectId'] == obj:
                        visible_info.append((o['objectId'], o['visible'], o['distance']))
            print('receptacle objects and visible and distance:', visible_info)


def close_object(distance_display=False):
    global env, event
    closable_objects = []
    closable_objects_distance = []
    for o in event.metadata['objects']:
        if o['visible'] and o['isOpen']:
            closable_objects.append(o['objectId'])
            closable_objects_distance.append((o['objectId'], o['distance']))
    if len(closable_objects) == 0:
        print('No opened object to close now!')
    else:
        if distance_display:
            print('closable objects and distance:', closable_objects_distance)
        else:
            print('closable object:', closable_objects)
        close_obj = input("input close object:")
        if close_obj not in closable_objects:
            print('Wrong input object to close!')
            return
        else:
            event = env.step(action='CloseObject', objectId=close_obj)


def pickup_object(distance_display=False):
    global env, event
    pickupable_objects = []
    pichupable_objects_distance = []
    for o in event.metadata['objects']:
        if o['visible'] and o['pickupable']:
            pickupable_objects.append(o['objectId'])
            pichupable_objects_distance.append((o['objectId'], o['distance']))
    if len(pickupable_objects) == 0:
        print('No objects to pickup now!')
    else:
        if distance_display:
            print('pickupable objects and distace:', pichupable_objects_distance)
        else:
            print('pickupable objects:', pickupable_objects)
        pick_obj = input('input pickup object:')
        if pick_obj not in pickupable_objects:
            print('Wrong input object to pickup!')
            return
        else:
            event = env.step(action='PickupObject', objectId=pick_obj)


def put_object(distance_display=False):
    global env, event
    putable_objects = []
    putable_objects_distance = []
    for o in event.metadata['objects']:
        if o['visible'] and o['isPickedUp']:
            putable_objects.append(o['objectId'])
            putable_objects_distance.append((o['objectId'], o['distance']))
    # select object to put
    if len(putable_objects) == 0:
        print('No pickuped object to put now!')
    else:
        if distance_display:
            print('putable objects and distance:', putable_objects_distance)
        else:
            print('putable object:', putable_objects)
        put_obj = input("input put object:")
        if put_obj not in putable_objects:
            print('Wrong input object to put!')
            return
        else:
            # select one receptacle to put
            receptacle_objects = []
            for o in event.metadata['objects']:
                # to do: maybe have some bug
                if o['visible'] and o['receptacle']:
                    if o['openable'] and not o['isOpen']:
                        break
                    elif o['openable'] and o['isopen']:
                        receptacle_objects.append(o['objectId'])
                    else:
                        receptacle_objects.append(o['objectId'])
            print('receptacle objects:', receptacle_objects)
            rec_obj = input('input receptacle object:')
            if rec_obj not in receptacle_objects:
                print('Wrong input receptacle!')
                return
            else:
                event = env.step(action='PutObject', objectId=put_obj, receptacleObjectId=rec_obj)


if __name__ == '__main__':
    # ai2thor
    ai2thor_attr_print(ai2thor_display=False)

    # ai2thor.controller
    ai2thor_controller_attr_print(ai2thor_controller_display=False)

    # ai2thor.controller.Controller
    Controller_attr_print(Controller_display=False)

    # all scenes
    # Kitchens: FloorPlan1 - FloorPlan30
    # Living rooms: FloorPlan201 - FloorPlan230
    # Bedrooms: FloorPlan301 - FloorPlan330
    # Bathrooms: FloorPLan401 - FloorPlan430

    scene_name = 'FloorPlan1'
    # ai2thor initialization
    env = Controller(scene=scene_name, gridSize=0.25, width=600, height=600, visibilityDistance=5)
    # to do: how many valid actions in Controller.step()
    event = env.step(action='Initialize')

    # print event information
    event_data_print(event_display=False)

    human_agent_action = None
    human_wants_restart = False
    stop_requested = False

    print("\nLoading scene {}".format(scene_name))
    print('Using [1,2,3,4,5,6,7,8,r/R,q/Q,o/O,c/C,p/P,l/L] to interact with scene.')

    while True:
        key = input("input your action:")
        key_press(key)
        if stop_requested:
            env.stop()
            break
        elif human_wants_restart:
            print('Environment reset!')
            env.reset(scene=scene_name)
            human_wants_restart = False
            human_agent_action = None
        else:
            print(human_agent_action)
            if human_agent_action == 'OpenObject':
                open_object(distance_display=True, receptacle_objects_display=True)
            elif human_agent_action == 'CloseObject':
                close_object(distance_display=True)
            elif human_agent_action == 'PickupObject':
                pickup_object(distance_display=True)
            elif human_agent_action == 'PutObject':
                put_object(distance_display=True)
            else:
                visible_display = True
                event = env.step(action=human_agent_action)
                event_data_print(event_display=False)
                # print current visible objects
                visible_objects_print(visible_objects_diaplay=True, visible_distance_display=True,
                                      visible_name_dispaly=False)
    print('ai2thor stopped.')