Upload 13 files

.gitignore

@@ -0,0 +1,150 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer checkpoints
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+.idea
+__pycache__
+LinuxNoEditor
+WindowsNoEditor
+
+data
+output
+archive
+misc/*.jpg
+misc/*.png
+misc/*.npy
+misc/logs
+misc/*.h5
+*.h5
+misc/logs/*
+*.ipynb_checkpoints
+misc/depth_nvidia_model_logs
+credential.json
+
+.DS_Store

.gitmodules

@@ -0,0 +1,15 @@
+[submodule "ROAR_Jetson"]
+	path = ROAR_Jetson
+	url = https://github.com/augcog/ROAR_Jetson.git
+[submodule "ROAR_Sim"]
+	path = ROAR_Sim
+	url = https://github.com/augcog/ROAR_Sim.git
+[submodule "ROAR_Gym"]
+	path = ROAR_Gym
+	url = https://github.com/augcog/ROAR_Gym.git
+[submodule "ROAR_iOS"]
+	path = ROAR_iOS
+	url = https://github.com/wuxiaohua1011/ROAR-iOS
+[submodule "ROAR_Junior_Racing"]
+	path = ROAR_Junior_Racing
+	url = https://github.com/augcog/ROAR-Junior-Racing.git

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

handshake.py

@@ -0,0 +1,47 @@
+import logging
+from ROAR.utilities_module.utilities import get_ip
+import qrcode
+import cv2
+import numpy as np
+import socket
+
+
+def showIPUntilAckUDP():
+    img = np.array(qrcode.make(f"{get_ip()}").convert('RGB'))
+    success = False
+    addr = None
+
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.settimeout(0.1)
+
+    try:
+        s.bind((get_ip(), 8008))
+        while success is False:
+            try:
+                cv2.imshow("Scan this code to connect to phone", img)
+                k = cv2.waitKey(1) & 0xff
+                seg, addr = s.recvfrom(1024)  # this command might timeout
+
+                if k == ord('q') or k == 27:
+                    s.close()
+                    break
+                addr = addr
+                success = True
+                for i in range(10):
+                    print("data sent")
+                    s.sendto(b"hi", addr)
+            except socket.timeout as e:
+                logging.info(f"Please tap on the ip address to scan QR code. ({get_ip()}:{8008}). {e}")
+    except Exception as e:
+        logging.error(f"Unable to bind socket: {e}")
+    finally:
+        s.close()
+        cv2.destroyWindow("Scan this code to connect to phone")
+    return success, addr[0]
+
+
+logging.basicConfig(format='%(levelname)s - %(asctime)s - %(name)s '
+                           '- %(message)s',
+                    datefmt="%H:%M:%S",
+                    level=logging.DEBUG)
+print(showIPUntilAckUDP())

handshake_client.py

@@ -0,0 +1,7 @@
+import socket
+from ROAR.utilities_module.utilities import get_ip
+
+s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+s.connect((get_ip(), 8008))
+s.send(b'data')
+print("sent")

handshake_server.py

@@ -0,0 +1,48 @@
+import logging
+from ROAR.utilities_module.utilities import get_ip
+import qrcode
+import cv2
+import numpy as np
+import socket
+from ROAR.utilities_module.utilities import get_ip
+
+import socket
+
+
+def showIPUntilAck():
+    img = np.array(qrcode.make(f"{get_ip()}").convert('RGB'))
+    success = False
+    addr = None
+
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+    try:
+        s.bind((get_ip(), 8008))
+        s.settimeout(1)
+        while True:
+            try:
+                s.listen()
+
+                cv2.imshow("Scan this code to connect to phone", img)
+                k = cv2.waitKey(1) & 0xff
+                if k == ord('q') or k == 27:
+                    s.close()
+                    break
+                conn, addr = s.accept()
+                addr = addr[0]
+                if conn:
+                    s.close()
+                    success = True
+                    break
+            except socket.timeout as e:
+                logging.info(f"Please tap on the ip address to scan QR code. ({get_ip()}:{8008}). {e}")
+    except Exception as e:
+        logging.error(f"Unable to bind socket: {e}")
+    finally:
+        s.close()
+        cv2.destroyWindow("Scan this code to connect to phone")
+    return success, addr
+
+
+print(showIPUntilAck())

mkdocs.yml

@@ -0,0 +1,65 @@
+site_name: ROAR Documentation
+site_description: Robot Open Autonomous Racing is a platform/competition dedicated to teaching students to gain a holistic view and hands-on(virtual) experiences about building a high-performance fully-autonomous 1/10 scale RC car from scratch.
+nav:
+    - About:
+      - Introduction: introduction.md
+      - Architecture: architecture.md
+      - Coordinate: coordinate.md
+    - Quick Start: quickstart.md
+    - Code Documentations:
+        - Bridges:
+            - Bridge: code_documentations/Bridges/bridges.md
+            - Carla Bridge: code_documentations/Bridges/carla_bridge.md
+            - Jetson Bridge: code_documentations/Bridges/jetson_bridge.md
+        - ROAR:
+            - Agent Module: code_documentations/ROAR/agent_module.md
+            - Configurations: code_documentations/ROAR/config.md
+            - Control Module: code_documentations/ROAR/controller_module.md
+            - Perception Module: code_documentations/ROAR/perception_module.md
+            - Planning Module: code_documentations/ROAR/planning_module.md
+            - Utilities Module: code_documentations/ROAR/utilities_module.md
+            - Visualization Module: code_documentations/ROAR/visualization.md
+        - ROAR Simulation:
+            - Carla Client:
+                - Carla Runner: code_documentations/ROAR_Sim/carla_client.md
+                - Util:
+                    - Camera Manager: code_documentations/ROAR_Sim/camera.md
+                    - Hud: code_documentations/ROAR_Sim/hud.md
+                    - Keyboard Controls: code_documentations/ROAR_Sim/kbc.md
+                    - Sensors: code_documentations/ROAR_Sim/sensors.md
+                    - Utilities: code_documentations/ROAR_Sim/util.md
+                    - World: code_documentations/ROAR_Sim/world.md
+            - Configurations: code_documentations/ROAR_Sim/conf.md
+        - Runner Sim: code_documentations/runner_sim.md
+    - Competition Instruction: competition_instruction.md
+    - FAQ: faq.md
+
+
+markdown_extensions:
+  - admonition
+  - codehilite:
+      guess_lang: false
+  - pymdownx.superfences
+  - pymdownx.tasklist
+  - pymdownx.emoji
+  - pymdownx.tabbed
+  - toc:
+      permalink: "¤"
+
+
+theme:
+  name: material
+
+plugins:
+  - search
+  - mkdocstrings:
+      handlers:
+        python:
+          rendering:
+            show_root_heading: no
+            show_category_heading: false
+            show_if_no_docstring: yes
+            show_source: true
+            show_root_toc_entry: false
+            show_object_full_path: no
+

readme.md

@@ -0,0 +1,13 @@
+# Robot Open Autonomous Racing (ROAR)
+
+### To Contribute
+- Please click the [Fork](https://docs.github.com/en/free-pro-team@latest/github/getting-started-with-github/fork-a-repo) button on the upper right corner and submit a pull request to master branch.
+    - For a more in-depth tutorial on recommended setup [video](https://youtu.be/VA13dAZ9iAw)
+- Please follow suggested guidelines on Pull Request. 
+
+### Quick start
+For quick start documentation, please visit our documentation site: [https://augcog.github.io/ROAR/quickstart/](https://augcog.github.io/ROAR/quickstart/)
+
+
+### Enter the Competition
+Visit [https://augcog.github.io/ROAR/competition_instruction/](https://augcog.github.io/ROAR/competition_instruction/)

requirements.txt

@@ -0,0 +1,33 @@
+addict==2.4.0
+certifi==2021.10.8
+charset-normalizer==2.0.7
+cycler==0.11.0
+fonttools==4.28.4
+idna==3.3
+joblib==1.1.0
+kiwisolver==1.3.2
+matplotlib==3.5.1
+numpy==1.21.3
+open3d==0.14.1
+opencv-contrib-python==4.5.4.58
+opencv-python==4.5.4.58
+packaging==21.3
+pandas==1.3.5
+Pillow==8.4.0
+pydantic==1.8.2
+pygame==2.0.3
+pyparsing==3.0.6
+python-dateutil==2.8.2
+pytz==2021.3
+PyYAML==6.0
+qrcode==7.3.1
+requests==2.26.0
+scikit-learn==1.0.1
+scipy==1.7.1
+simple-websocket-server==0.4.1
+six==1.16.0
+threadpoolctl==3.0.0
+tqdm==4.62.3
+typing-extensions==3.10.0.2
+urllib3==1.26.7
+websocket-client==1.2.1

runner_competition_evaluator.py

@@ -0,0 +1,99 @@
+import logging, warnings
+import numpy as np
+from ROAR_Sim.configurations.configuration import Configuration as CarlaConfig
+from ROAR.configurations.configuration import Configuration as AgentConfig
+from pathlib import Path
+from ROAR.agent_module.pure_pursuit_agent \
+    import PurePursuitAgent
+from ROAR_Sim.carla_client.carla_runner import CarlaRunner
+from typing import Tuple
+from prettytable import PrettyTable
+from ROAR.agent_module.michael_pid_agent import PIDAgent
+
+
+def compute_score(carla_runner: CarlaRunner) -> Tuple[float, int, int]:
+    """
+    Calculates the score of the vehicle upon completion of the track based on certain metrics
+    Args:
+        carla_runner ():
+
+    Returns:
+        time_elapsed:
+        num_collision: number of collisions during simulation
+        laps_completed: Number of laps completed
+
+    """
+    time_elapsed: float = carla_runner.end_simulation_time - carla_runner.start_simulation_time
+    num_collision: int = carla_runner.agent_collision_counter
+    laps_completed = 0 if carla_runner.completed_lap_count < 0 else carla_runner.completed_lap_count
+
+    return time_elapsed, num_collision, laps_completed
+
+
+def run(agent_class, agent_config_file_path: Path, carla_config_file_path: Path,
+        num_laps: int = 10) -> Tuple[float, int, int]:
+    """
+    Run the agent along the track and produce a score based on certain metrics
+    Args:
+        num_laps: int number of laps that the agent should run
+        agent_class: the participant's agent
+        agent_config_file_path: agent configuration path
+        carla_config_file_path: carla configuration path
+    Returns:
+        float between 0 - 1 representing scores
+    """
+
+    agent_config: AgentConfig = AgentConfig.parse_file(agent_config_file_path)
+    carla_config = CarlaConfig.parse_file(carla_config_file_path)
+
+    # hard code agent config such that it reflect competition requirements
+    agent_config.num_laps = num_laps
+    carla_runner = CarlaRunner(carla_settings=carla_config,
+                               agent_settings=agent_config,
+                               npc_agent_class=PurePursuitAgent,
+                               competition_mode=True,
+                               lap_count=num_laps)
+    try:
+        my_vehicle = carla_runner.set_carla_world()
+        agent = agent_class(vehicle=my_vehicle, agent_settings=agent_config)
+        carla_runner.start_game_loop(agent=agent, use_manual_control=False)
+        return compute_score(carla_runner)
+    except Exception as e:
+        print(f"something bad happened during initialization: {e}")
+        carla_runner.on_finish()
+        logging.error(f"{e}. Might be a good idea to restart Server")
+        return 0, 0, False
+
+
+def suppress_warnings():
+    logging.basicConfig(format='%(levelname)s - %(asctime)s - %(name)s '
+                               '- %(message)s',
+                        level=logging.INFO)
+    logging.getLogger("matplotlib").setLevel(logging.WARNING)
+    warnings.simplefilter("ignore")
+    np.set_printoptions(suppress=True)
+
+
+def main():
+    suppress_warnings()
+    agent_class = PIDAgent
+    num_trials = 10
+    total_score_array = []
+    num_laps = 1
+    table = PrettyTable()
+    table.field_names = ["time_elapsed (sec)", "num_collisions", "laps completed"]
+
+    for i in range(num_trials):
+        print(f"runner_competition_evaluator -> Trial: {i}")
+        scores = run(agent_class=agent_class,
+                     agent_config_file_path=Path("./ROAR/configurations/carla/carla_agent_configuration.json"),
+                     carla_config_file_path=Path("./ROAR_Sim/configurations/configuration.json"),
+                     num_laps=num_laps)
+        total_score_array.append(scores[0])
+        table.add_row(scores)
+    table.add_row((f"AVG for {num_trials} trials = {np.average(total_score_array)}", "N/A", "N/A"))
+    print(table)
+
+
+if __name__ == "__main__":
+    main()

runner_ios.py

@@ -0,0 +1,151 @@
+import time
+from pathlib import Path
+from ROAR_iOS.ios_runner import iOSRunner
+from ROAR.configurations.configuration import Configuration as AgentConfig
+from ROAR_iOS.config_model import iOSConfig
+from ROAR_Unity.unity_runner import iOSUnityRunner
+from ROAR.agent_module.forward_only_agent import ForwardOnlyAgent
+from ROAR.agent_module.special_agents.recording_agent import RecordingAgent
+from ROAR.utilities_module.vehicle_models import Vehicle
+import logging
+import argparse
+from misc.utils import str2bool
+from ROAR.utilities_module.utilities import get_ip
+import qrcode
+import cv2
+import numpy as np
+import socket
+import json
+import requests
+
+
+class mode_list(list):
+    # list subclass that uses lower() when testing for 'in'
+    def __contains__(self, other):
+        return super(mode_list, self).__contains__(other.lower())
+
+
+def showIPUntilAckUDP():
+    port = 8890
+    img = np.array(qrcode.make(f"{get_ip(),port}").convert('RGB'))
+    success = False
+    addr = None
+
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.settimeout(0.1)
+
+    try:
+        s.bind((get_ip(), port))
+        while success is False:
+            try:
+                cv2.imshow("Scan this code to connect to phone", img)
+                k = cv2.waitKey(1) & 0xff
+                seg, addr = s.recvfrom(1024)  # this command might timeout
+
+                if k == ord('q') or k == 27:
+                    s.close()
+                    break
+                addr = addr
+                success = True
+                for i in range(10):
+                    s.sendto(b"hi", addr)
+            except socket.timeout as e:
+                logging.info(f"Please tap on the ip address to scan QR code. ({get_ip()}:{8008}). {e}")
+    except Exception as e:
+        logging.error(f"Unable to bind socket: {e}")
+    finally:
+        s.close()
+        cv2.destroyWindow("Scan this code to connect to phone")
+    return success, addr[0]
+
+
+def showIPUntilAck():
+    port = 40001
+    img = np.array(qrcode.make(f"{get_ip()},{port}").convert('RGB'))
+    success = False
+    addr = None
+
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+    try:
+        s.bind((get_ip(), port))
+        s.settimeout(1)
+        while True:
+            try:
+                s.listen()
+
+                cv2.imshow("Scan this code to connect to phone", img)
+                k = cv2.waitKey(1) & 0xff
+                if k == ord('q') or k == 27:
+                    s.close()
+                    break
+                conn, addr = s.accept()
+                addr = addr[0]
+                if conn:
+                    s.close()
+                    success = True
+                    break
+            except socket.timeout as e:
+                logging.info(f"Please tap on the ip address to scan QR code. ({get_ip()}:{8008}). {e}")
+    except Exception as e:
+        logging.error(f"Unable to bind socket: {e}")
+    finally:
+        s.close()
+        cv2.destroyWindow("Scan this code to connect to phone")
+    return success, addr
+
+
+def is_glove_online(host, port):
+    r = requests.get(url=f"http://{host}:{port}", timeout=1)
+    if r.status_code == 200:
+        return True
+    return False
+
+
+if __name__ == '__main__':
+    choices = mode_list(['ar', 'vr'])
+    logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                        datefmt="%H:%M:%S", level=logging.DEBUG)
+    logging.getLogger("matplotlib").setLevel(logging.WARNING)
+    logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-auto", action='store_true', help="Enable auto control")
+    parser.add_argument("-m", "--mode", choices=choices, help="AR or VR [WARNING not implemented yet!]", default="vr")
+    parser.add_argument("-r", "--reconnect", action='store_true', help="Scan QR code to attach phone to PC")
+    parser.add_argument("-u", "--use_unity", action='store_true',
+                        help="Use unity as rendering and control service")
+    parser.add_argument("-g", "--use_glove", help="use glove based controller by supplying its ip address!")
+    args = parser.parse_args()
+
+    try:
+        agent_config_file_path = Path("ROAR/configurations/iOS/iOS_agent_configuration.json")
+        ios_config_file_path = Path("ROAR_iOS/configurations/ios_config.json")
+        agent_config = AgentConfig.parse_file(agent_config_file_path)
+        ios_config: iOSConfig = iOSConfig.parse_file(ios_config_file_path)
+        ios_config.ar_mode = True if args.mode == "ar" else False
+        if args.use_glove:
+            try:
+                is_glove_online(args.use_glove, port=81)
+                ios_config.glove_ip_addr = args.use_glove
+                ios_config.should_use_glove = True
+            except requests.exceptions.ConnectTimeout as e:
+                print(f"ERROR. Cannot find Glove at that ip address {args.use_glove}. Shutting down...")
+                exit(0)
+        else:
+            ios_config.should_use_glove = False
+
+        success = False
+        if args.reconnect:
+            success, addr = showIPUntilAck()
+            if success:
+                ios_config.ios_ip_addr = addr
+                json.dump(ios_config.dict(), ios_config_file_path.open('w'), indent=4)
+                time.sleep(2)
+        if success or args.reconnect is False:
+            agent = ForwardOnlyAgent(vehicle=Vehicle(), agent_settings=agent_config, should_init_default_cam=True)
+            runner = iOSUnityRunner(agent=agent, ios_config=ios_config, is_unity=args.use_unity)
+            runner.start_game_loop(auto_pilot=args.auto)
+    except Exception as e:
+        print(f"Something bad happened: {e}")

runner_jetson.py

@@ -0,0 +1,85 @@
+from ROAR_Jetson.jetson_runner import JetsonRunner
+from ROAR.utilities_module.vehicle_models import Vehicle
+from ROAR_Jetson.configurations.configuration import Configuration as JetsonConfig
+from ROAR.configurations.configuration import Configuration as AgentConfig
+# from ROAR.agent_module.floodfill_based_lane_follower import FloodfillBasedLaneFollower
+# from ROAR.agent_module.michael_pid_agent import PIDAgent
+# from ROAR.agent_module.jetson_pure_pursuit_agent import PurePursuitAgent
+# from ROAR.agent_module.special_agents.waypoint_generating_agent import WaypointGeneratigAgent
+# from ROAR.agent_module.forward_only_agent import ForwardOnlyAgent
+# from ROAR.agent_module.lane_detection_agent import LaneDetectionAgent
+from ROAR.agent_module.occupancy_map_agent import OccupancyMapAgent
+# from ROAR.agent_module.special_agents.recording_agent import RecordingAgent
+from ROAR.agent_module.michael_pid_agent import PIDAgent
+from pathlib import Path
+import logging
+import warnings
+import numpy as np
+import os
+import json
+import sys
+import serial
+import argparse
+
+
+def main(auto=False):
+    try:
+        agent_config = AgentConfig.parse_file(Path("./ROAR_Jetson/configurations/agent_configuration.json"))
+        jetson_config = JetsonConfig.parse_file(Path("./ROAR_Jetson/configurations/configuration.json"))
+
+        try:
+            prepare(jetson_config=jetson_config)
+        except Exception as e:
+            logging.error(f"Ignoring Error during setup: {e}")
+        agent = OccupancyMapAgent(vehicle=Vehicle(), agent_settings=agent_config, should_init_default_cam=False)
+        jetson_runner = JetsonRunner(agent=agent, jetson_config=jetson_config)
+        jetson_runner.start_game_loop(use_manual_control=not auto)
+    except Exception as e:
+        print(f"Something bad happened {e}")
+
+
+def prepare(jetson_config: JetsonConfig):
+    if 'win' in sys.platform:
+        # windows, just detect whether arduino exist on COM4
+        s = serial.Serial(jetson_config.win_serial_port)
+        status = s.isOpen()
+    else:
+        # assume that this is going to be a unix based system
+        status = allow_dev_access(read_password(Path(jetson_config.jetson_sudo_password_file_path)))
+    assert status is True, "Port not successfully opened"
+
+
+def read_password(jetson_sudo_setup_f_path: Path):
+    d = json.load(fp=jetson_sudo_setup_f_path.open("r"))
+    return d["sudo_password"]
+
+
+def allow_dev_access(pwd):
+    command = 'chmod 777 /dev/ttyACM0'
+    p = os.system(f'echo {pwd}|sudo -S {command}')
+    return True if p == 0 else False
+
+
+def str2bool(v):
+    if isinstance(v, bool):
+        return v
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--debug", default=False, help="debug flag", type=str2bool)
+    parser.add_argument("--auto", default=False, help="enable or disable auto drive", type=str2bool)
+    args = parser.parse_args()
+    logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+                        datefmt="%H:%M:%S", level=logging.DEBUG if args.debug is True else logging.INFO)
+    logging.getLogger("Vive Tracker Client [tracker_1]").setLevel(logging.WARNING)
+    logging.getLogger("matplotlib").setLevel(logging.WARNING)
+    warnings.simplefilter("ignore")
+    np.set_printoptions(suppress=True)
+    main(args.auto)

runner_sim.py

@@ -0,0 +1,48 @@
+import logging
+from pathlib import Path
+from ROAR_Sim.configurations.configuration import Configuration as CarlaConfig
+from ROAR_Sim.carla_client.carla_runner import CarlaRunner
+from ROAR.agent_module.pure_pursuit_agent import PurePursuitAgent
+from ROAR.configurations.configuration import Configuration as AgentConfig
+import argparse
+from misc.utils import str2bool
+from ROAR.agent_module.michael_pid_agent import PIDAgent
+from ROAR.agent_module.forward_only_agent import ForwardOnlyAgent
+
+
+def main(args):
+    """Starts game loop"""
+    agent_config = AgentConfig.parse_file(Path("./ROAR/configurations/carla/carla_agent_configuration.json"))
+    carla_config = CarlaConfig.parse_file(Path("./ROAR_Sim/configurations/configuration.json"))
+
+    carla_runner = CarlaRunner(carla_settings=carla_config,
+                               agent_settings=agent_config,
+                               npc_agent_class=PurePursuitAgent)
+    try:
+        my_vehicle = carla_runner.set_carla_world()
+        agent = ForwardOnlyAgent(vehicle=my_vehicle,
+                         agent_settings=agent_config)
+        carla_runner.start_game_loop(agent=agent,
+                                     use_manual_control=not args.auto)
+
+    except Exception as e:
+        logging.error(f"Something bad happened during initialization: {e}")
+        carla_runner.on_finish()
+        logging.error(f"{e}. Might be a good idea to restart Server")
+
+
+if __name__ == "__main__":
+    logging.basicConfig(format='%(levelname)s - %(asctime)s - %(name)s '
+                               '- %(message)s',
+                        datefmt="%H:%M:%S",
+                        level=logging.DEBUG)
+    logging.getLogger(" streaming client").setLevel(logging.WARNING)
+    import warnings
+
+    warnings.filterwarnings("ignore", module="carla")
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--auto", type=str2bool, default=False, help="True to use auto control")
+
+    warnings.filterwarnings("ignore", module="carla")
+    args = parser.parse_args()
+    main(args)