pycityagent 1.1.9__tar.gz → 1.1.11__tar.gz

{pycityagent-1.1.9 → pycityagent-1.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycityagent
-Version: 1.1.9
+Version: 1.1.11
 Summary: LLM-based城市模拟器agent构建库
 Author-email: Yuwei Yan <pinkgranite86@gmail.com>
 License: MIT License

{pycityagent-1.1.9 → pycityagent-1.1.11}/pycityagent/__init__.py

@@ -6,5 +6,6 @@ from .simulator import Simulator
 from .agent import Agent
 from .agent_citizen import CitizenAgent
 from .agent_func import FuncAgent
+from .agent_group import GroupAgent
 
-__all__ = [Simulator, Agent, CitizenAgent, FuncAgent]
+__all__ = [Simulator, Agent, CitizenAgent, FuncAgent, GroupAgent]

{pycityagent-1.1.9 → pycityagent-1.1.11}/pycityagent/ac/__init__.py

@@ -5,4 +5,4 @@ from .action import *
 from .hub_actions import *
 from .sim_actions import *
 
-__all__ = [ActionController, Action, HubAction, SimAction, SendUserMessage, SendStreetview, SendPop, PositionUpdate, ShowPath, ShowPosition, SetSchedule, SendAgentMessage]
+__all__ = [ActionController, Action, HubAction, SimAction, SendUserMessage, SendStreetview, SendPop, ShowPath, ShowPosition, SetSchedule, SendAgentMessage]

{pycityagent-1.1.9 → pycityagent-1.1.11}/pycityagent/ac/citizen_actions/trip.py

@@ -13,10 +13,9 @@ class TripAction(Action):
     async def Forward(self):
         now = self._agent.Scheduler.now
         if now.is_set:
-            # TODO: 目前仅支持传输一张图片至前端
             '''之前已经将schedule同步至模拟器了'''
-            if self._agent.Hub != None:
-                self._agent.Hub.Update(streetview=self._agent.Brain.Sence.sence_buffer['streetview'][0])
+            if self._agent.Hub != None and self._agent.Brain.Sence.sence_buffer['streetview'] != None:
+                self._agent.Hub.Update(streetview=self._agent.Brain.Sence.sence_buffer['streetview'])
         else:
             '''同步schedule至模拟器'''
             self._agent.Scheduler.now.is_set = True

pycityagent-1.1.11/pycityagent/ac/hub_actions.py

@@ -0,0 +1,295 @@
+"""AppHub关联Action定义"""
+
+from typing import Callable, Optional, Any, Union
+from geojson import Feature, FeatureCollection, Point, LineString
+from shapely.geometry import mapping
+from pycitysim.apphub import AgentMessage
+from .action import HubAction
+from PIL.Image import Image
+from ..utils import *
+
+class SendUserMessage(HubAction):
+    """
+    发送用户可见信息
+    Send messages to user
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, messages: Optional[list[AgentMessage]] = None):
+        if not messages == None:
+            self._agent.Hub.Update(messages = messages)
+        elif self._source != None:
+            messages = self.get_source()
+            if messages != None:
+                self._agent.Hub.Update(messages = messages)
+        else:
+            print("Error: without input data")
+
+class SendStreetview(HubAction):
+    """
+    发送街景图片至前端
+    Send streetview to frontend
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, images: Optional[list[Image]] = None):
+        if not images == None:
+            self._agent.Hub.Update(streetview = images)
+        elif self._source != None:
+            images = self.get_source()
+            if images != None:
+                self._agent.Hub.Update(streetview = images)
+        else:
+            print("Error: without input data")
+
+class SendPop(HubAction):
+    """
+    发送Pop信息 - agent头顶气泡信息
+    Send pop message to frontend, pop message shows above the target agent
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, pop:Optional[str] = None):
+        if not pop == None:
+            self._agent.Hub.Update(pop = pop)
+        elif self._source != None:
+            pop = self.get_source()
+            if pop != None:
+                self._agent.Hub.Update(pop = pop)
+        else:
+            print("Error: without input data")
+
+class PositionUpdate(HubAction):
+    """
+    同步当前agent的位置信息
+    Send the position of current agent to frontend
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, longlat: Optional[list[float]] = None):
+        if longlat != None:
+            self._agent.Hub.Update(longlat = longlat)
+        elif self._source != None:
+            longlat = self.get_source()
+            if longlat != None:
+                self._agent.Hub.Update(longlat = longlat)
+        else:
+            print("Error: without input data")
+
+class ShowPosition(HubAction):
+    """
+    在地图上展示特定地点
+    Show a position in frontend map
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, position: Union[int, list[float]], properties: Optional[dict]=None):
+        """
+        Args:
+        - position (Union[int, list[float]])
+            - int: 表示poi id
+            - list[float]: 具体的position经纬度坐标
+        - properties (Optional[dict]): 支持用户添加自定义属性, 默认为None
+            - 例如: {'description': "莲花超市"}
+        """
+        if isinstance(position, int):
+            # poi
+            if position in self._agent._simulator.map.pois:
+                poi = self._agent._simulator.map.pois[position]
+                lnglat_p = poi['shapely_lnglat']
+                position_feature = Feature(geometry=lnglat_p, properties=properties)
+                self._agent.Hub.ShowGeo(FeatureCollection([position_feature]))
+            else:
+                print("Error: wrong position (wrong poi id)")
+        else:
+            # longitude latitude
+            position_feature = Feature(geometry=Point(position), properties=properties)
+            self._agent.Hub.ShowGeo(FeatureCollection([position_feature]))
+
+class ShowAoi(HubAction):
+    """
+    在地图上显示Aoi
+    Show aoi in map
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, aoi_id:int, properties: Optional[dict]=None):
+        """
+        Args:
+        - aoi_id (int): Aoi id
+        - properties (Optional[dict]): 支持用户添加自定义属性, 默认为None
+            - 例如: {'description': "我居住的小区"}
+        """
+        properties_default = {
+            "stroke-width": 2,
+            "stroke-opacity": 1,
+            "fill": "#ff2600",
+            "fill-opacity": 0.5
+        }
+        if properties != None:
+            properties_default.update(properties)
+        if aoi_id in self._agent._simulator.map.aois:
+            aoi = self._agent._simulator.map.aois[aoi_id]
+            lnglat_poly = aoi['shapely_lnglat']
+            aoi_feature = Feature(geometry=lnglat_poly, properties=properties_default)
+            self._agent.Hub.ShowGeo(FeatureCollection([aoi_feature]))
+        else:
+            print("Error: wrong aoi id")
+
+class ShowPath(HubAction):
+    """
+    在地图上展示路径信息
+    Show a path in frontend map
+    """
+    def __init__(self, agent, source: str = None, before: Callable[[list], Any] = None) -> None:
+        super().__init__(agent, source, before)
+
+    async def Forward(self, 
+                      path: Optional[Union[int, list[list[float]]]]=None, 
+                      start_end: Optional[Union[float, tuple[float, float]]]=None, 
+                      direction: Optional[str]='front', 
+                      properties: Optional[dict]=None):
+        """
+        Args:
+        - path (Optional[Union[int, list[list[float]]]]): 如果为None, 从Reason池中基于source拿取数据
+            - int: lane id
+            - list[list[float]]: path node
+        - start_end: (Optional[Union[float, tuple[float, float]]]): 指定显示范围, 如path是list[list[float]]形式则无效
+            - float: 如果仅包含一个float, 则展示从指定位置开始到path结尾的位置
+            - tuple[float, end]: 分别表示起点与终点
+        - direction (str): 指定前进方向, 支持['front', 'back'], 默认为'front'
+        - properties (Optional[dict]): 支持用户添加自定义属性, 默认为None
+        """
+        properties_default = {'stroke-width': 10, 'stroke-opacity': 0.5}
+        if properties != None:
+            properties_default.update(properties)
+        if path != None:
+            if isinstance(path, int):
+                # lane id
+                if path in self._agent._simulator.map.lanes:
+                    lane = self._agent._simulator.map.lanes[path]
+                    nodes = lane['center_line']['nodes']
+                    path_ls = mapping(lane['shapely_lnglat'])
+                    path_ls['coordinates'] = list(path_ls['coordinates'])
+                    for i in range(len(path_ls['coordinates'])):
+                        path_ls['coordinates'][i] = list(path_ls['coordinates'][i])
+                    # start-end与direction处理
+                    if isinstance(start_end, float):
+                        # start
+                        if direction == 'back':
+                            key_index = get_keyindex_in_lane(nodes, start_end, 'back')
+                            path_ls['coordinates'] = path_ls['coordinates'][:key_index+1]
+                            path_ls['coordinates'].reverse()
+                        else:
+                            key_index = get_keyindex_in_lane(nodes, start_end)
+                            path_ls['coordinates'] = path_ls['coordinates'][key_index:]
+
+                        path_ls['coordinates'][0] = [
+                                self._agent.motion['position']['longlat_position']['longitude'],
+                                self._agent.motion['position']['longlat_position']['latitude']
+                            ]
+                    elif isinstance(start_end, tuple) and len(start_end) == 2:
+                        # start - end
+                        start = start_end[0]
+                        end = start_end[1]
+                        if direction == 'back':
+                            keyIndex_s = get_keyindex_in_lane(nodes, start, 'back')
+                            keyIndex_e = get_keyindex_in_lane(nodes, end, 'back')
+                            path_ls['coordinates'] = path_ls['coordinates'][keyIndex_e:keyIndex_s+1]
+                            path_ls['coordinates'].reverse()
+                            xy = get_xy_in_lane(nodes, end, 'back')
+                            longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                            path_ls['coordinates'].append([longlat[0], longlat[1]])
+                        else:
+                            keyIndex_s = get_keyindex_in_lane(nodes, start)
+                            keyIndex_e = get_keyindex_in_lane(nodes, end)
+                            path_ls['coordinates'] = path_ls['coordinates'][keyIndex_s:keyIndex_e+1]
+                            xy = get_xy_in_lane(nodes, end)
+                            longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                            path_ls['coordinates'].append([longlat[0], longlat[1]])
+                        path_ls['coordinates'][0] = [
+                                    self._agent.motion['position']['longlat_position']['longitude'],
+                                    self._agent.motion['position']['longlat_position']['latitude']
+                                ]
+                    path_feature = Feature(geometry=path_ls, properties=properties_default)
+                    self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+                else:
+                    print("Error: wrong path (wrong lane id)")
+            else:
+                # list point
+                path_ls = LineString(path)
+                path_feature = Feature(geometry=path_ls, properties=properties_default)
+                self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+        elif self._source != None:
+            path_coll = self.get_source()
+            if path_coll != None:
+                path = path_coll['path']
+                start_end = path_coll['start_end']
+                direction = path_coll['direction']
+                properties = path_coll['properties']
+                if properties != None:
+                    properties_default.update(properties)
+                if isinstance(path, int):
+                    # lane id
+                    if path in self._agent._simulator.map.lanes:
+                        lane = self._agent._simulator.map.lanes[path]
+                        nodes = lane['center_line']['nodes']
+                        path_ls = mapping(lane['shapely_lnglat'])
+                        path_ls['coordinates'] = list(path_ls['coordinates'])
+                        for i in range(len(path_ls['coordinates'])):
+                            path_ls['coordinates'][i] = list(path_ls['coordinates'][i])
+                        # start-end与direction处理
+                        if isinstance(start_end, float):
+                            # start
+                            if direction == 'back':
+                                key_index = get_keyindex_in_lane(nodes, start_end, 'back')
+                                path_ls['coordinates'] = path_ls['coordinates'][:key_index+1]
+                                path_ls['coordinates'].reverse()
+                            else:
+                                key_index = get_keyindex_in_lane(nodes, start_end)
+                                path_ls['coordinates'] = path_ls['coordinates'][key_index:]
+
+                            path_ls['coordinates'][0] = [
+                                    self._agent.motion['position']['longlat_position']['longitude'],
+                                    self._agent.motion['position']['longlat_position']['latitude']
+                                ]
+                        elif isinstance(start_end, tuple) and len(start_end) == 2:
+                            # start - end
+                            start = start_end[0]
+                            end = start_end[1]
+                            if direction == 'back':
+                                keyIndex_s = get_keyindex_in_lane(nodes, start, 'back')
+                                keyIndex_e = get_keyindex_in_lane(nodes, end, 'back')
+                                path_ls['coordinates'] = path_ls['coordinates'][keyIndex_e:keyIndex_s+1]
+                                path_ls['coordinates'].reverse()
+                                xy = get_xy_in_lane(nodes, end, 'back')
+                                longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                                path_ls['coordinates'].append([longlat[0], longlat[1]])
+                            else:
+                                keyIndex_s = get_keyindex_in_lane(nodes, start)
+                                keyIndex_e = get_keyindex_in_lane(nodes, end)
+                                path_ls['coordinates'] = path_ls['coordinates'][keyIndex_s:keyIndex_e+1]
+                                xy = get_xy_in_lane(nodes, end)
+                                longlat = self._agent._simulator.map.xy2lnglat(x=xy[0], y=xy[1])
+                                path_ls['coordinates'].append([longlat[0], longlat[1]])
+                            path_ls['coordinates'][0] = [
+                                        self._agent.motion['position']['longlat_position']['longitude'],
+                                        self._agent.motion['position']['longlat_position']['latitude']
+                                    ]
+                        path_feature = Feature(geometry=path_ls, properties=properties_default)
+                        self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+                    else:
+                        print("Error: wrong path (wrong lane id)")
+                else:
+                    # list point
+                    path_ls = LineString(path)
+                    path_feature = Feature(geometry=path_ls, properties=properties_default)
+                    self._agent.Hub.ShowGeo(FeatureCollection([path_feature]))
+        else:
+            print("Error: without input")

{pycityagent-1.1.9 → pycityagent-1.1.11}/pycityagent/agent.py

@@ -22,9 +22,11 @@ class AgentType:
 
     - Citizen = 1, 指城市居民类型agent——行动受城市规则限制
     - Func = 2, 功能型agent——行动规则宽松——本质上模拟器无法感知到Func类型的agent
+    - Group = 3, 群体智能体
     """
     Citizen = 1
     Func = 2
+    Group = 3
 
 class Template:
     """

{pycityagent-1.1.9 → pycityagent-1.1.11}/pycityagent/agent_citizen.py

@@ -4,6 +4,8 @@ from pycityagent.urbanllm import UrbanLLM
 from .urbanllm import UrbanLLM
 from .agent import Agent, AgentType
 from .image.image import CitizenImage
+from .hubconnector import Waypoint
+import time
 
 class CitizenAgent(Agent):
     """
@@ -54,6 +56,8 @@ class CitizenAgent(Agent):
         - Schedule Init
         """
 
+        self._history_trajectory: list[Waypoint] = []
+
     def Bind(self):
         """
         - 将智能体绑定到AppHub
@@ -124,8 +128,12 @@ class CitizenAgent(Agent):
             await self._simulator.GetTime()
             # * 2. 拉取Agent最新状态
             resp = await self._client.person_service.GetPerson({'person_id':self._id})
-            self.base = resp['base']
-            self.motion = resp['motion']
+            self.base = resp['person']['base']
+            self.motion = resp['person']['motion']
+            longitude = self.motion['position']['longlat_position']['longitude']
+            latitude = self.motion['position']['longlat_position']['latitude']
+            if self.state == 'trip':
+                self._history_trajectory.append(Waypoint([longitude, latitude], int(time.time())))
             # * 3. Brain工作流
             await self._brain.Run()
             # * 4. Commond Controller工作流

pycityagent-1.1.11/pycityagent/agent_func.py

@@ -0,0 +1,216 @@
+"""FuncAgent: 功能性智能体及其定义"""
+
+from typing import Union
+from pycityagent.urbanllm import UrbanLLM
+from .urbanllm import UrbanLLM
+from .agent import Agent, AgentType
+from .image.image import Image
+from .ac.hub_actions import PositionUpdate
+from .utils import *
+from .hubconnector import Waypoint
+
+class FuncAgent(Agent):
+    """
+    Fuctional Agent
+    功能型Agent
+    """
+
+    def __init__(
+            self, 
+            name:str, 
+            server:str, 
+            soul:UrbanLLM=None, 
+            simulator=None, 
+        ) -> None:
+        """
+        初始化 Init
+
+        Args:
+        - name (str): 智能体名称; name of your agent
+        - id (int): 智能体Id; id of your agent
+        - server (str): 模拟器grpc服务地址; server address of simulator
+        - soul (UrbanLLM): 基础模型模块; base model
+        - simulator (Simulator): 模拟器对象; simulator
+        """
+
+        super().__init__(name, server, AgentType.Func, soul, simulator)
+        self._image = Image(self)
+        """
+        - Func Agent画像——支持自定义内容
+        """
+
+        self.motion = {'id': id, 'position': {}, 'direction': 0}
+        """
+        Func Agent状态信息——与agent的sence高度相关
+        Keys:
+        - id (int): 即agent id
+        - position (https://cityproto.sim.fiblab.net/#city.geo.v2.Position): 即agent当前的位置描述信息
+            - lane_position (dict): 当position中包含该key时表示agent当前位于lane上——与aoi_position不可同时存在
+                - lane_id (int)
+                - s (double)
+            - aoi_position (dict): 当position中包含该key时表示agent当前位于aoi中——与lane_position不可同时存在
+                - aoi_id (int)
+                - poi_id (optional[int])
+            - longlat_position (dict): WGS84经纬度坐标位置
+                - longitude (double): 经度
+                - latitude (double): 纬度
+                - z (optional[double]): 高程信息
+            - xy_position (dict): 坐标系表示的位置
+                - x (double)
+                - y (double)
+                - z (double)
+        - direction (double): 朝向-方向角
+        """
+
+        self._posUpdate = PositionUpdate(self)
+        self._history_trajectory:list[Waypoint] = []
+
+    async def set_position_aoi(self, aoi_id:int):
+        """
+        - 将agent的位置设定到指定aoi
+
+        Args:
+        - aoi_id (int): AOI id
+        """
+        if aoi_id in self._simulator.map.aois:
+            if 'aoi_position' in self.motion['position'].keys() and aoi_id == self.motion['position']['aoi_position']['aoi_id']:
+                return
+            aoi = self._simulator.map.aois[aoi_id]
+            self.motion['position'] = {}
+            self.motion['position']['aoi_position'] = {'aoi_id': aoi_id}
+            self.motion['position']['longlat_position'] = {'longitude': aoi['shapely_lnglat'].centroid.coords[0][0], 'latitude': aoi['shapely_lnglat'].centroid.coords[0][1]}
+            # self._history_trajectory.append([self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+            x, y = self._simulator.map.lnglat2xy(lng=self.motion['position']['longlat_position']['longitude'], 
+                                                 lat=self.motion['position']['longlat_position']['latitude'])
+            self.motion['position']['xy_position'] = {'x': x, 'y': y}
+            await self._posUpdate.Forward(longlat=[self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+        else:
+            print("Error: wrong aoi id")
+
+    async def set_position_lane(self, lane_id:int, s:float=0.0, direction:Union[float, str]='front'):
+        """
+        - 将agent的位置设定到指定lane
+        
+        Args:
+        - lane_id (int): Lane id
+        - s (float): distance from the start point of the lane, default None, if None, then set to the start point
+        - direction (Union[float, str]): agent方向角, 默认值为'front'
+            - float: 直接设置为给定方向角(atan2计算得到)
+            - str: 可选项['front', 'back'], 指定agent的行走方向
+                - 对于driving lane而言, 只能朝一个方向通行, 只能是'front'
+                - 对于walking lane而言, 可以朝两个方向通行, 可以是'front'或'back'
+        """
+        if lane_id in self._simulator.map.lanes:
+            if 'lane_position' in self.motion['position'].keys() and lane_id == self.motion['position']['lane_position']['lane_id']:
+                return
+            lane = self._simulator.map.lanes[lane_id]
+            if s > lane['length']:
+                print("Error: 's' too large")
+            self.motion['position'] = {}
+            self.motion['position']['lane_position'] = {'lane_id': lane_id, 's': s}
+            nodes = lane['center_line']['nodes']
+            x, y = get_xy_in_lane(nodes, s)
+            longlat = self._simulator.map.xy2lnglat(x=x, y=y)
+            self.motion['position']['longlat_position'] = {
+                'longitude': longlat[0],
+                'latitude': longlat[1]
+            }
+            self.motion['position']['xy_position'] = {
+                'x': x,
+                'y': y
+            }
+            if isinstance(direction, float):
+                self.motion['direction'] = direction
+            else:
+                # 计算方向角
+                direction_ = get_direction_by_s(nodes, s, direction)
+                self.motion['direction'] = direction_      
+            # self._history_trajectory.append([self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])              
+            await self._posUpdate.Forward(longlat=[self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+        else:
+            print("Error: wrong lane id")
+
+    async def set_position_poi(self, poi_id:int, hub:bool=True):
+        """
+        - 将agent的位置设定到指定poi
+
+        Args:
+        - poi_id (int): Poi id
+        """
+        if poi_id in self._simulator.map.pois:
+            poi = self._simulator.map.pois[poi_id]
+            aoi_id = poi['aoi_id']
+            if 'aoi_position' in self.motion['position'].keys() and aoi_id == self.motion['position']['aoi_position']['aoi_id']:
+                return
+            x = poi['position']['x']
+            y = poi['position']['y']
+            longlat = self._simulator.map.xy2lnglat(x=x, y=y)
+            self.motion['position'] = {}
+            self.motion['position']['aoi_position'] = {'aoi_id': aoi_id}
+            self.motion['position']['longlat_position'] = {
+                'longitude': longlat[0],
+                'latitude': longlat[1]
+            }
+            self.motion['position']['xy_position'] = {
+                'x': x,
+                'y': y
+            }
+            # self._history_trajectory.append([self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+            if hub:
+                await self._posUpdate.Forward(longlat=[self.motion['position']['longlat_position']['longitude'], self.motion['position']['longlat_position']['latitude']])
+        else:
+            print("Error: wrong poi id")
+
+    def Bind(self):
+        """
+        - 将智能体绑定到AppHub
+        - Bind the Agent with AppHub
+        """
+        if self._hub_connector == None:
+            print("ERROR: connect with apphub first")
+        else:
+            self._hub_connector.InsertFuncAgent()
+
+    def set_image(self, image: Image):
+        """
+        - 设置image——支持自由扩展Image
+        """
+        self._image = image
+
+    async def Step(self, log:bool):
+        """
+        单步Agent执行流
+        Single step entrance
+        (Not recommended, use Run() method)
+
+        Args:
+        - log (bool): 是否输出log信息. Whether console log message
+        """
+        # * 1. 模拟器时间更新
+        await self._simulator.GetTime()
+        # * 2. Brain工作流
+        await self._brain.Run()
+        # * 3. Commond Controller工作流
+        command = await self._cc.Run()
+        # * 4. State Transformer工作流
+        self._st.trigger(command)
+        # * 5. Action Controller工作流
+        if self._step_with_action:
+            await self._ac.Run()
+        if log:
+            print(f"---------------------- SIM TIME: {self._simulator.time} ----------------------")
+            self.show_yourself()
+    
+    def show_yourself(self):
+        """
+        - Log信息输出
+        - Pring log message
+        """
+        pass
+
+    @property
+    def Image(self):
+        """
+        - The Agent's Image
+        """
+        return self._image