def pipelines():
from os import listdir
from os.path import isfile, join, basename, splitext
onlyfiles = [
join(PIPELINE_FOLDER, f) for f in listdir(PIPELINE_FOLDER)
if isfile(join(PIPELINE_FOLDER, f))
]
pipelines = []
for f in onlyfiles:
if not f.endswith(".ini"):
continue
conf = Configuration(f)
pipeline_metadata = {
"basename": splitext(basename(f))[0],
"name": conf.get("name"),
"description": conf.get("description"),
"author": conf.get("author")
}
svg_file = f.replace(".ini", ".svg")
if os.path.isfile(svg_file):
with open(svg_file, "rb") as image_file:
encoded_string = base64.b64encode(
image_file.read()).decode('utf-8')
pipeline_metadata[
"icon"] = "data:image/svg+xml;base64," + encoded_string
pipelines.append(pipeline_metadata)
response = make_response(json.dumps(pipelines))
response.headers['Content-Type'] = 'application/json'
return response
def init(self):
'''
@description:
intializes:
- configurations
- db connections
'''
Configuration.initialize()
values = Configuration.values()
self.dbconn = SQLUtils(
host=values['mysql-db']['sms_api_config']['host'],
port=values['mysql-db']['sms_api_config']['port'],
database=values['mysql-db']['sms_api_config']['db'],
user=values['mysql-db']['sms_api_config']['user'],
password=values['mysql-db']['sms_api_config']['password'])
self.redisconn = gredis.client.Connection(
address=str(values['redis_servers']['sms_api']['host']),
port=int(values['redis_servers']['sms_api']['port']))
self.redisconn.connect()
print '-------'
print 'redis:'
print 'port: %s' % values['redis_servers']['sms_api']['port']
print 'host: %s' % values['redis_servers']['sms_api']['host']
print '\n'
print 'sql:'
print 'port: %s' % values['mysql-db']['sms_api_config']['host']
print 'host: %s' % values['mysql-db']['sms_api_config']['port']
print 'db: %s' % values['mysql-db']['sms_api_config']['db']
print 'user: %s' % values['mysql-db']['sms_api_config']['user']
print 'password: %s' % values['mysql-db']['sms_api_config']['password']
print '-------'
def __init__(self, config={}, port_num=19997):
self.VrepEnvBase_config = Configuration(default_config)
self.VrepEnvBase_config.update(config)
print ('Program started')
vrep.simxFinish(-1) # just in case, close all opened connections
self.clientID = vrep.simxStart('127.0.0.1', port_num, True,
True, 5000, 5) # Connect to V-REP
if self.clientID != -1:
print ('Connected to remote API server')
vrep.simxStartSimulation(
self.clientID, vrep.simx_opmode_oneshot_wait)
vrep.simxSynchronous(self.clientID, True)
# Now try to retrieve data in a blocking fashion (i.e. a service
# call):
res, objs = vrep.simxGetObjects(
self.clientID, vrep.sim_handle_all, vrep.simx_opmode_blocking)
if res == vrep.simx_return_ok:
print ('Number of objects in the scene: ', len(objs))
else:
print ('Remote API function call returned with error code: ', res)
print("connected through port number: {}".format(port_num))
# used to connect multiple clients in synchronous mode http://www.coppeliarobotics.com/helpFiles/en/remoteApiModusOperandi.htm
return_code, iteration = vrep.simxGetIntegerSignal(self.clientID, "iteration", vrep.simx_opmode_streaming)
time.sleep(2)
def __init__(self, config={}, helper=None, py_logger=None, tb_logger=None):
#### common setup ####
self.config = Configuration({'NuScenesAgent_config': {}})
self.config.update(config)
super().__init__(config=self.config['NuScenesAgent_config'],
helper=helper,
py_logger=py_logger,
tb_logger=tb_logger)
self.name = 'SceneGraphics'
#######
self.map_layers = [
'road_divider',
'lane_divider',
'drivable_area',
#'road_segment',
#'road_block',
'lane',
#'ped_crossing',
'walkway',
#'stop_line',
#'carpark_area',
#'traffic_light'
]
self.plot_list = [
'ego', 'other_cars', 'pedestrian', 'cam', 'map_info',
'labeled_map', 'sensing_patch', 'sensor_info'
]
def init(self):
'''
@description:
intializes:
- configurations
- db connections
'''
Configuration.initialize()
values = Configuration.values()
self.dbconn = SQLUtils(
host=values['mysql-db']['sms_api_config']['host'],
port=values['mysql-db']['sms_api_config']['port'],
database=values['mysql-db']['sms_api_config']['db'],
user=values['mysql-db']['sms_api_config']['user'],
password=values['mysql-db']['sms_api_config']['password'])
def __init__(self):
self.configuration = Configuration()
self.torrentAPIHandler = TorrentAPIHandler()
self.file_handler = FileHandler()
self.audit = Audit(type(self).__name__)
self.torrent_list = []
self.utorrent_client = None
def __init__(self, config: Configuration, owner: str, repo: str):
super().__init__(config)
self.releases = self.git_release.format(owner, repo)
self.header = {
'Authorization': 'Basic ' + config.gh_auth(),
"User-Agent": "PostmanRuntime/7.23.0"
}
def __init__(self):
"""
Tworzy instancję serwera.
"""
self.__configuration = Configuration()
TCPServer.__init__(
self, (self.__configuration.host, self.__configuration.port),
ClientServerHandler)
def __init__(self, plist_path):
"""
:param plist_path: plist 文件路径
"""
super().__init__(plist_path)
self.app_config = Configuration(self.content,
conf=EnvEnum.CONFIGURATION.value)
self.export_plist_path = f'{EnvEnum.SCRIPT_PATH.value}/plist/{self.app_config.method}.plist'
self.icon_url = f'{EnvEnum.SCRIPT_URL.value}{self.app_config.icon_path}'
def __init__(self, workDirectory=""):
"""
Pobiera konfigurację serwera oraz zapisuje katalog roboczy. Tworzy też pustą listę plikó do usunięcia.
Args:
workDirectory (Optional(str)): Katalog roboczy (id użytkownika, nazwa grupy)
"""
self.__configuration = Configuration()
self.__dir = "".join(["/", workDirectory])
self.__usedFiles = []
def __init__(self, *args, **kwargs):
super(PipelinesModel, self).__init__(*args, **kwargs)
pipeline_folder = "resources/pipelines"
self.pipelines = []
onlyfiles = [
join(pipeline_folder, f) for f in listdir(pipeline_folder)
if isfile(join(pipeline_folder, f))
]
for f in onlyfiles:
if not f.endswith(".ini"):
continue
pipeline_conf = Configuration(f)
pipeline_metadata = {
"filename": f,
"basename": splitext(basename(f))[0],
"name": pipeline_conf.get("name"),
"description": pipeline_conf.get("description"),
"author": pipeline_conf.get("author")
}
self.pipelines.append(pipeline_metadata)
def __init__(self, subtitle):
self.configuration = Configuration()
self.file_handler = FileHandler()
self.title = subtitle[0:len(subtitle)-4]
self.subtitle = subtitle
self.subtitle_path = self.set_subtitle_path()
self.magnet_link = ''
self.directory = ''
self.video_file = ''
self.video_path = ''
self.ready = False
self.done = False
def __init__(self, environment):
# Logging configuration
logging.basicConfig()
self.logger = logging.getLogger()
self.logger.setLevel(logging.INFO)
# Application configuration
self.config = Configuration(self.logger, environment)
# Tools configuration
self.kugawana_tool = KugawanaInventoryTool(self.config.slack_bot_token)
self.sc = SlackClient(self.config.slack_app_token)
def __init__(self, global_conf, pipeline_file ):
self.pipeline_conf = Configuration(pipeline_file)
self.filters = []
self.pipeline = self.pipeline_conf.sections()
self.source = ImageSource()
self.source.configure(global_conf, "source", self.pipeline_conf)
# the input format for the first filter element
input_format = "image"
for pipeline_section in self.pipeline:
print(pipeline_section)
# ignore the common section
if pipeline_section == "common":
continue
# ignore the source section
if pipeline_section == "source":
continue
instance = clazz.instance_by_name(pipeline_section)
instance.configure(global_conf, pipeline_section, self.pipeline_conf)
# try to load an image/icon for the give filter
python_file = inspect.getfile(instance.__class__)
svg_file = python_file.replace(".py", ".svg")
if os.path.isfile(svg_file):
with open(svg_file, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
instance.icon = "data:image/svg+xml;base64,"+encoded_string
# check that the output format if the predecessor filter matches with the input if this
# filter
meta = instance.meta()
if not meta["input"] == input_format:
print("Filter '{}' is unable to process input format '{}'. Expected was '{}'".format(python_file, input_format, meta["input"] ))
print("Wrong pipeline definition. Exit")
exit_process()
# the output if this filter is the input of the next filter
input_format = meta["output"]
self.filters.append(instance)
def __init__(self, config: Configuration):
super().__init__(config)
credentials = ServicePrincipalCredentials(config.az_client(),
config.secret(),
tenant=config.az_tenant())
self.client = ContainerServiceClient(credentials,
config.az_subscription())
self.rg = config.az_resource_group()
self.aks = config.aks()
def __init__(self, pipeline_file):
QObject.__init__(self)
self.pipeline_conf = Configuration(pipeline_file)
self.filters = []
self.pipeline = self.pipeline_conf.sections()
icon_file = pipeline_file.replace(".ini", ".png")
if os.path.isfile(icon_file):
self.icon_path = icon_file
# the input format for the first filter element
input_format = None
for pipeline_section in self.pipeline:
# ignore the common section
if pipeline_section == "common":
continue
instance = clazz.instance_by_name(pipeline_section, pipeline_section, self.pipeline_conf)
instance.index = len(self.filters)
# check that the output format if the predecessor filter matches with the input if this
# filter
meta = instance.meta()
if not input_format==None and not meta["input"] == input_format:
print("Filter '{}' is unable to process input format '{}'. Expected was '{}'".format(python_file, input_format, meta["input"]))
print("Wrong pipeline definition. Exit")
exit_process()
instance.param_changed.connect(self.process)
# the output if this filter is the input of the next filter
input_format = meta["output"]
self.filters.append(instance)
def __init__(self, environment, token, user_id, callback_id, form,
response_url):
# Logging configuration
logging.basicConfig()
self.logger = logging.getLogger()
self.logger.setLevel(logging.INFO)
# Application configuration
self.config = Configuration(self.logger, environment)
# Tools configuration
self.sc = SlackClient(self.config.slack_app_token)
# Interactive messages informations
self.token = token
self.user_id = user_id
self.callback_id = callback_id
self.form = form
self.response_url = response_url
def getUDIDforEmails():
slack_token = Configuration().slack_token
print('--- INFO: Connect to Slack')
slack = Slacker(slack_token)
udids_and_emails = {}
print('--- INFO: Call Slack API to list Users')
response = slack.users.list()
users = response.body['members']
for user in users:
if not user['deleted']:
try:
email = user['profile']['email']
except KeyError:
email = "*****@*****.**"
udids_and_emails[email] = user['id']
return udids_and_emails
def __init__(self, environment, token, user_id, command, parameter,
response_url, trigger_id):
# Logging configuration
logging.basicConfig()
self.logger = logging.getLogger()
self.logger.setLevel(logging.INFO)
# Application configuration
self.config = Configuration(self.logger, environment)
# Tools configuration
self.sc = SlackClient(self.config.slack_app_token)
# Slash command informations
self.token = token
self.user_id = user_id
self.command = command
self.parameter = parameter
self.response_url = response_url
self.trigger_id = trigger_id
def __init__(self):
"""
Tworzy całe CA. Wczytuje konfiguracje CA z pliku. Ładuje lub (w przypadku gdy nie istnieją)
tworzy certyfikat i klucz prywatny.
Args:
certificatesDir (str): Katalog, w którym będą trzymane certyfikaty użytkowników.
keysDir (str): Katalog, w któym będą trzymane klucze publiczne użytkowników.
Raises:
IOError: Jeśli nie można utworzyć klucza, albo odczytać go z pliku.
"""
self.__configuration = Configuration()
if not self.__checkFiles():
self.__certificate, self.__keys = self.__newCaCertificate()
else:
self.__certificate = self.__loadCertificateFromFile(
self.__configuration.certificateFile)
self.__keys = self.__loadPrivateKeyFromFile(
self.__configuration.keysFile)
if not self.__keys:
raise IOError
def launch(self, event):
# Manage 'challenge' from Slack to validate the lambda.
if "challenge" in event:
return event["challenge"]
slack_event = event['event']
# Ignore message from bot.
if not "bot_id" in slack_event \
and slack_event['type'] == 'user_change' \
and 'XfELFP2WL9' in slack_event['user']['profile']['fields']:
# Application configuration
config = Configuration(self.logger, self.environment)
# Check input token
if not event['token'] in config.slack_event_token:
return "403 Forbidden"
self.logger.info(slack_event['user']['real_name'] + " gets " +
slack_event['user']['profile']['fields']
['XfELFP2WL9']['value'] + " certification!")
user_udid = slack_event['user']['id']
user_level_name = re.search(
' \((.+?) level\)', slack_event['user']['profile']['fields']
['XfELFP2WL9']['value'].lower()).group(1)
user = User.get(user_udid)
level = Level.getByName(user_level_name)
if user and level:
for user_certification in user.user_certifications:
user_certification.passesCertification(level)
return "200 OK"
class VideoPipeline:
def __init__(self, global_conf, pipeline_file ):
self.pipeline_conf = Configuration(pipeline_file)
self.filters = []
self.pipeline = self.pipeline_conf.sections()
self.source = ImageSource()
self.source.configure(global_conf, "source", self.pipeline_conf)
# the input format for the first filter element
input_format = "image"
for pipeline_section in self.pipeline:
print(pipeline_section)
# ignore the common section
if pipeline_section == "common":
continue
# ignore the source section
if pipeline_section == "source":
continue
instance = clazz.instance_by_name(pipeline_section)
instance.configure(global_conf, pipeline_section, self.pipeline_conf)
# try to load an image/icon for the give filter
python_file = inspect.getfile(instance.__class__)
svg_file = python_file.replace(".py", ".svg")
if os.path.isfile(svg_file):
with open(svg_file, "rb") as image_file:
encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
instance.icon = "data:image/svg+xml;base64,"+encoded_string
# check that the output format if the predecessor filter matches with the input if this
# filter
meta = instance.meta()
if not meta["input"] == input_format:
print("Filter '{}' is unable to process input format '{}'. Expected was '{}'".format(python_file, input_format, meta["input"] ))
print("Wrong pipeline definition. Exit")
exit_process()
# the output if this filter is the input of the next filter
input_format = meta["output"]
self.filters.append(instance)
def meta(self):
meta_info = []
for instance in self.filters:
menu = self.pipeline_conf.get_boolean("menu", instance.conf_section)
meta =instance.meta()
meta["menu"]= menu
meta_info.append(meta)
return {
"name":self.pipeline_conf.get("name"),
"description":self.pipeline_conf.get("description"),
"author":self.pipeline_conf.get("author"),
"filters":meta_info
}
def filter_count(self):
return len(self.filters)
def override_source_image(self, value):
self.source.set_image(value)
def get_source_image(self):
return self.source.get_image()
def set_parameter(self, index, name, value):
self.filters[index].set_parameter(name, value)
@perf_tracker()
def gcode(self, contour_3d):
return self.filters[len(self.filters)-1].gcode(contour_3d)
def process(self):
result = []
image = self.get_source_image()
cnt = []
for instance in self.filters:
start = time.process_time()
try:
print("Running filter: ", type(instance))
image, cnt = instance.process(image, cnt)
end = time.process_time()
print(instance.meta()["name"], end - start)
print("Contour Count:", len(cnt))
cnt = ensure_3D_contour(cnt)
if image is None:
print("unable to read image from filter: "+instance.meta()["name"])
break
if len(image.shape) != 3:
print("Image must have 3 color channels. Filter '{}' must return RGB image for further processing".format(instance.conf_section))
result.append({"filter": instance.conf_section, "image":image, "contour": cnt })
print("------------------------")
except Exception as exc:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
print(type(instance), exc)
return result
def stop(self):
for instance in self.filters:
instance.stop()
import cv2 from utils.configuration import Configuration import os import numpy as np from utils.image import image_resize from processing.image.black_white import Filter as Filter1 from processing.image.skeletonize import Filter as Filter2 TEST_IMAGE = "./test-images/Jeannette_Logo.png" configuration_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "config", "configuration.ini")) conf = Configuration(configuration_dir) filter1 = Filter1() filter1.threshold = 128 filter2 = Filter2() img = cv2.imread(TEST_IMAGE, cv2.IMREAD_COLOR) img = image_resize(img, height=600) img1, cnt = filter1.process(img, None) img2, cnt = filter2.process(img1, None) img = 255 - cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) img1 = 255 - cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY) img2 = 255 - cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY) # calculate the watershed distance
def main(argv):
## Create and load client configuration
cfg_ = Configuration()
cfg_.load(CONFIG_FILE)
print cfg_
## Create UnrealCV client and connect
ucv_client_ = ucv.connect_client(cfg_.m_unrealengine_host,
cfg_.m_unrealengine_port)
## Load sequence configuration file and properties and save description
seq_ = Sequence()
seq_.load(cfg_.m_sequence_filename)
print seq_
seq_.save("../data/" + seq_.m_name + "/sequence.json")
## Generate camera description
cam_ = Camera()
cam_.m_fx = cfg_.m_camera_fx
cam_.m_fy = cfg_.m_camera_fy
cam_.m_cx = cfg_.m_camera_cx
cam_.m_cy = cfg_.m_camera_cy
cam_.m_fov = cfg_.m_camera_fov
cam_.m_depthmin = cfg_.m_camera_depthmin
cam_.m_depthmax = cfg_.m_camera_depthmax
print cam_
cam_.save("../data/" + seq_.m_name + "/camera.json")
## Generate objects description
object_list_ = ucv_client_.request("vget /objects").split(' ')
objects_ = {}
objects_["total_number"] = len(object_list_)
objects_["objects"] = {}
print("There are " + str(objects_["total_number"]) +
" objects in this scene...")
### Load object instance to object class mapping
instance_class_ = {}
with open("../config/instance_class.json") as f:
instance_class_ = json.load(f)
### Load class information
classes_ = {}
with open("../config/classes.json") as f:
classes_json_ = json.load(f)
for i_classid in classes_json_.keys():
obj_class_ = ObjectClass()
obj_class_.parse_json(classes_json_[i_classid])
classes_[i_classid] = obj_class_
### Describe each object
for i_objname in object_list_:
object_ = SceneObject()
object_.m_instance_name = i_objname
print("Getting color for {0}".format(i_objname))
object_color_ = Color(
ucv_client_.request("vget /object/{0}/color".format(i_objname)))
print("Object {0} has color {1}".format(i_objname, object_color_))
object_.m_instance_color = object_color_
if i_objname in instance_class_:
object_.m_class = classes_[instance_class_[i_objname]]
else:
object_.m_class = classes_["none"]
objects_["objects"][i_objname] = object_.to_json()
with open("../data/" + seq_.m_name + "/objects.json", 'w') as f:
json.dump(objects_, f, indent=2)
## Get frames
for i in range(seq_.m_total_frames):
print("Getting frame {0} out of {1}...".format(i, seq_.m_total_frames))
if i < FRAME_START:
print("Skipping frame " + str(i))
continue
frame_ = seq_.m_frames[i]
frame_id_ = frame_["id"]
frame_timestamp_ = frame_["timestamp"]
frame_camera_ = frame_["camera"]
frame_objects_ = frame_["objects"]
print frame_timestamp_
res_camera_ = ucv.place_camera(ucv_client_, frame_camera_)
while (res_camera_ is None):
print("ERROR: Trying to place camera again...")
ucv_client_.disconnect()
ucv_client_ = ucv.connect_client(cfg_.m_unrealengine_host,
cfg_.m_unrealengine_port)
res_camera_ = ucv.place_camera(ucv_client_, frame_camera_)
ucv.place_objects(ucv_client_, frame_objects_)
frame_rgb_ = cli_rgb.get_rgb(ucv_client_)
while (frame_rgb_ is None):
print("ERROR: Trying to get RGB frame again...")
ucv_client_.disconnect()
ucv_client_ = ucv.connect_client(cfg_.m_unrealengine_host,
cfg_.m_unrealengine_port)
frame_rgb_ = cli_rgb.get_rgb(ucv_client_)
frame_rgb_im_ = Image.fromarray(frame_rgb_)
frame_rgb_im_.save("../data/" + seq_.m_name + "/rgb/" + frame_id_ +
".png")
frame_mask_ = cli_sgm.get_object_mask(ucv_client_)
while (frame_mask_ is None):
print("ERROR: Trying to get mask frame again...")
ucv_client_.disconnect()
ucv_client_ = ucv.connect_client(cfg_.m_unrealengine_host,
cfg_.m_unrealengine_port)
frame_mask_ = cli_sgm.get_object_mask(ucv_client_)
frame_mask_im_ = Image.fromarray(frame_mask_)
frame_mask_im_.save("../data/" + seq_.m_name + "/mask/" + frame_id_ +
".png")
frame_depth_ = cli_dpt.get_depth(ucv_client_)
while (frame_depth_ is None):
print("ERROR: Trying to get depth frame again...")
ucv_client_.disconnect()
ucv_client_ = ucv.connect_client(cfg_.m_unrealengine_host,
cfg_.m_unrealengine_port)
frame_depth_ = cli_dpt.get_depth(ucv_client_)
frame_depth_im_ = Image.fromarray(frame_depth_)
cli_utils.save_16bit_png(
frame_depth_,
"../data/" + seq_.m_name + "/depth/" + frame_id_ + ".png",
cam_.m_depthmin, cam_.m_depthmax)
import os
import base64
import time
from flask import Flask, render_template, make_response, send_file, request
from utils.webgui import FlaskUI # get the FlaskUI class
from pipeline import VideoPipeline
from grbl import GrblWriter
from utils.configuration import Configuration
configuration_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "config",
"configuration.ini"))
conf = Configuration(configuration_dir)
POOL_TIME = conf.get_int("image-read-ms") / 1000 # convert to Seconds
PIPELINE_FOLDER = os.path.abspath(
os.path.join(os.path.dirname(__file__), conf.get("pipelines")))
SERIAL_PORT = conf.get("serial-port")
SERIAL_BAUD = conf.get_int("serial-baud")
grbl = GrblWriter(SERIAL_PORT, SERIAL_BAUD)
log = logging.getLogger('werkzeug')
log.setLevel(logging.ERROR)
app = Flask(__name__)
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0
ui = FlaskUI(app=app, port=8080)
import time from config import config_dict from datasets.generateData import generate_dataset from net.generateNet import generate_net import torch.optim as optim from net.sync_batchnorm.replicate import patch_replication_callback from torch.utils.data import DataLoader from utils.configuration import Configuration from utils.finalprocess import writelog from utils.imutils import img_denorm from utils.DenseCRF import dense_crf from utils.test_utils import single_gpu_test from utils.imutils import onehot cfg = Configuration(config_dict, False) def ClassLogSoftMax(f, category): exp = torch.exp(f) exp_norm = exp/torch.sum(exp*category, dim=1, keepdim=True) softmax = exp_norm*category logsoftmax = torch.log(exp_norm)*category return softmax, logsoftmax def test_net(): period = 'val' dataset = generate_dataset(cfg, period=period, transform='none') def worker_init_fn(worker_id): np.random.seed(1 + worker_id) dataloader = DataLoader(dataset, batch_size=1,
from utils.save_video_ffmpeg import VideoSaver
save_directory = "play_results"
image_extension = "png"
zoom_factor = 10
framerate = 5
if __name__ == "__main__":
# Loads configuration file
parser = argparse.ArgumentParser()
parser.add_argument("--config", type=str, required=True)
arguments = parser.parse_args()
config_path = arguments.config
configuration = Configuration(config_path)
configuration.check_config()
configuration.create_directory_structure()
config = configuration.get_config()
logger = Logger(config)
search_name = config["model"]["architecture"]
model = getattr(importlib.import_module(search_name), 'model')(config)
model.cuda()
datasets = {}
dataset_splits = DatasetSplitter.generate_splits(config)
transformations = TransformsGenerator.get_final_transforms(config)
### How to start to work with A.R.M.O.R
1. helm repository is hosted here: https://yaroslavnikolaev.github.io/A.R.M.O.R./
2. Deploy to your central cluster or to
'''
COLLECTORS = '''
### ARMOR supports following collectors:
<table style="width:100%"> <tr> <th>Application</th> <th>Armor annotation key</th> <th>Description</th> </tr>
'''
STORAGES = '''\n### ARMOR supports following storages:
- Prometheus \n'''
if __name__ == '__main__':
'''Automatically generate Readme.md'''
configuration = Configuration()
factory = CollectorFactory(configuration)
with open("./docs/README.md", "w") as readme:
readme.write(INTRO)
readme.write(STRUCTURE)
readme.write(HOWTO)
readme.write(COLLECTORS)
# todo add description to collectors and storages use __doc__
description = ""
for key in sorted(factory.collectors.keys()):
application = key.split(".")[-1]
readme.write(
f'''<tr> <th>{application}</th> <th>armor.io/{key}</th> <th>{description}</th> </tr>\n'''
)
readme.write("""</table> \n""")
readme.write(STORAGES)
class SceneGraphics(NuScenesAgent):
def __init__(self, config={}, helper=None, py_logger=None, tb_logger=None):
#### common setup ####
self.config = Configuration({'NuScenesAgent_config': {}})
self.config.update(config)
super().__init__(config=self.config['NuScenesAgent_config'],
helper=helper,
py_logger=py_logger,
tb_logger=tb_logger)
self.name = 'SceneGraphics'
#######
self.map_layers = [
'road_divider',
'lane_divider',
'drivable_area',
#'road_segment',
#'road_block',
'lane',
#'ped_crossing',
'walkway',
#'stop_line',
#'carpark_area',
#'traffic_light'
]
self.plot_list = [
'ego', 'other_cars', 'pedestrian', 'cam', 'map_info',
'labeled_map', 'sensing_patch', 'sensor_info'
]
def update_all_info(self):
pass
def make_video_from_images(self,
image_dir: str = None,
video_save_dir: str = None,
video_layout=None):
if video_layout is None:
video_layout = {
'figsize': (15, 15),
'nb_rows': 6,
'nb_cols': 6,
'components': {
'birdseye': [[0, 4], [0, 6]],
'camera': [[4, 6], [0, 6]]
}
}
img_fn_list = [
str(p).split('/')[-1] for p in Path(image_dir).rglob('*.png')
]
component_img_list = {}
for k, v in video_layout['components'].items():
img_list = [
p for p in img_fn_list if k in p and 'checkpoint' not in p
]
idx = np.argsort(np.array([int(p[:2]) for p in img_list]))
img_list = np.array(img_list)[idx]
nb_images = len(img_list)
component_img_list[k] = img_list
fig = plt.figure(figsize=video_layout['figsize'],
constrained_layout=False)
gs = fig.add_gridspec(nrows=video_layout['nb_rows'],
ncols=video_layout['nb_cols'],
wspace=0.01)
axes = {}
for k, v in video_layout['components'].items():
ax = fig.add_subplot(gs[v[0][0]:v[0][1], v[1][0]:v[1][1]])
ax.axis('off')
axes[k] = ax
camera = Camera(fig)
for i in tqdm.tqdm(range(nb_images)):
for k, v in component_img_list.items():
axes[k].imshow(plt.imread(os.path.join(image_dir, v[i])))
camera.snap()
animation = camera.animate()
if video_save_dir is not None:
animation.save(video_save_dir + '/video.mp4')
return animation
def plot_ego_scene(
self,
ego_centric=True,
sample_token: str = None,
instance_token: str = None,
scene_token: str = None,
idx: str = "",
save_pkl_dir: str = None,
save_img_dir: str = None,
sensor_info=None,
text_box=False,
plot_list=None,
ego_traj=None,
ado_traj=None,
contour=None,
read_from_cached=False,
paper_ready=False,
other_images_to_be_saved=None,
render_additional=None,
plot_human_ego=True,
patch_margin=30,
):
'''
ego_traj = {
<name>: {
'traj': <traj>,
'color': <color>
}
}
ado_traj = {
<instance_token>: {
"traj_dist": [[mean, cov], [], ...],
"frame": <"local" or "global">,
"pos": <np.ndarray or list>, # global coordinate of origin
"quat": <np.ndarray or list> # global rotation of origin
}
}
'''
if sample_token is not None and scene_token is not None:
raise ValueError(
"only one of sample_token or scene_token should be provided")
if scene_token is not None:
sample_token = self.nusc.get('scene',
scene_token)['first_sample_token']
sample = self.nusc.get('sample', sample_token)
if plot_list is None:
plot_list = self.plot_list
if sensor_info is not None:
plot_list += ['sensing_patch']
self.plot_list += ['sensing_patch']
# this decides whether plotting in ego_centric or sim_ego_centric
sim_ego_pose = None
if ego_traj is not None:
if 'sim_ego' in ego_traj.keys():
sim_ego = ego_traj['sim_ego']
if sim_ego is not None:
sim_ego_pose = {'translation': sim_ego['pos']}
fig, ax, other = self.plot_agent_scene(
ego_centric=ego_centric,
sample_token=sample_token,
instance_token=instance_token,
sensor_info=sensor_info,
text_box=text_box,
plot_list=plot_list,
ego_traj=ego_traj,
read_from_cached=read_from_cached,
paper_ready=paper_ready,
render_additional=render_additional,
plot_human_ego=plot_human_ego,
patch_margin=patch_margin,
sim_ego_pose=sim_ego_pose)
#### plot sim ego ####
if sim_ego_pose is not None:
self.plot_elements(sim_ego['pos'],
sim_ego['yaw'],
'sim_ego',
ax,
animated_agent=paper_ready)
#### plot ado traj ####
if ado_traj is not None:
self.plot_trajectory_distributions(ax, ado_traj)
#### plot contour ####
if contour is not None:
self.plot_contour(ax, contour)
#### save stuff ####
if save_pkl_dir is not None:
p = os.path.join(save_pkl_dir, idx + "_" + sample_token + ".pkl")
with open(p, 'wb') as f:
cloudpickle.dump(ax, f)
if save_img_dir is not None:
p = os.path.join(save_img_dir,
idx + "_" + sample_token + "_birdseye.png")
#fig.savefig(p, dpi=300, quality=95)
fig.savefig(p)
if 'cam' in plot_list:
p = os.path.join(save_img_dir,
idx + "_" + sample_token + "_camera.png")
#other['sfig'].savefig(p, dpi=300, quality=95)
other['sfig'].savefig(p)
if other_images_to_be_saved is not None:
for k, v in other_images_to_be_saved.items():
p = os.path.join(
save_img_dir,
idx + "_" + sample_token + "_" + k + ".png")
if isinstance(v, np.ndarray):
plt.imsave(p, v)
elif isinstance(v, matplotlib.figure.Figure):
plt.savefig(p)
return fig, ax, other
def plot_agent_scene(
self,
ego_centric: bool = False,
ego_traj=None,
instance_token: str = None,
sample_token: str = None,
map_layers=None,
sensor_info=None,
sensing_patch=None,
predictions=None,
agent_state_dict=None,
plot_list=None,
legend=False,
text_box=False,
show_axis=True,
render_ego_pose_range=False,
paper_ready=False,
read_from_cached=False,
plot_agent_trajs=True,
animated_agent=False,
bfig=None, # for birdseye image
bax=None,
sfig=None, # for camera
sax=None,
render_additional=None,
plot_human_ego=True,
patch_margin=30,
sim_ego_pose=None,
save_image_ax=False):
if paper_ready:
legend = False
text_box = False
show_axis = False
render_ego_pose_range = False
plot_agent_trajs = False
animated_agent = True
#show_axis = True
if map_layers is None:
map_layers = self.map_layers
if plot_list is None:
plot_list = self.plot_list
sample = self.nusc.get('sample', sample_token)
scene = self.nusc.get('scene', sample['scene_token'])
scene_log = self.nusc.get('log', scene['log_token'])
nusc_map = NuScenesMap(dataroot=self.dataroot,
map_name=scene_log['location'])
patch_margin = patch_margin
min_diff_patch = 30
if not ego_centric:
agent_future = self.helper.get_future_for_agent(
instance_token,
sample_token,
self.na_config['pred_horizon'],
in_agent_frame=False,
just_xy=True)
agent_past = self.helper.get_past_for_agent(
instance_token,
sample_token,
self.na_config['obs_horizon'],
in_agent_frame=False,
just_xy=True)
#### set plot patch ####
if agent_future.shape[0] > 0:
p = agent_future[0]
else:
p = agent_past[-1]
my_patch = (
p[0] - patch_margin,
p[1] - patch_margin,
p[0] + patch_margin,
p[1] + patch_margin,
)
# min_patch = np.floor(agent_future.min(axis=0) - patch_margin)
# max_patch = np.ceil(agent_future.max(axis=0) + patch_margin)
# diff_patch = max_patch - min_patch
# if any(diff_patch < min_diff_patch):
# center_patch = (min_patch + max_patch) / 2
# diff_patch = np.maximum(diff_patch, min_diff_patch)
# min_patch = center_patch - diff_patch / 2
# max_patch = center_patch + diff_patch / 2
# my_patch = (min_patch[0], min_patch[1], max_patch[0], max_patch[1])
else:
sample_data = self.nusc.get('sample_data',
sample['data']['CAM_FRONT'])
ego_pose = self.nusc.get('ego_pose', sample_data['ego_pose_token'])
my_patch = (
ego_pose['translation'][0] - patch_margin,
ego_pose['translation'][1] - patch_margin,
ego_pose['translation'][0] + patch_margin,
ego_pose['translation'][1] + patch_margin,
)
if sim_ego_pose is not None:
my_patch = (
sim_ego_pose['translation'][0] - patch_margin,
sim_ego_pose['translation'][1] - patch_margin,
sim_ego_pose['translation'][0] + patch_margin,
sim_ego_pose['translation'][1] + patch_margin,
)
#### read from saved path if present ####
read_img = False
if read_from_cached:
scene_path = os.path.join(
scene_img_dir,
scene['name'] + "-token-" + sample['scene_token'])
p_scene = Path(scene_img_dir)
saved_scene_list = [
str(f) for f in p_scene.iterdir() if f.is_dir()
]
if scene_path in saved_scene_list:
p_sample = Path(scene_path)
for f in p_sample.iterdir():
if sample_token in str(f):
ax = cloudpickle.load(
open(os.path.join(scene_path, str(f)), 'rb'))
fig = plt.figure(figsize=(10, 10))
fig._axstack.add('ax', ax)
read_img = True
if not read_img:
fig, ax = nusc_map.render_map_patch(
my_patch,
map_layers,
figsize=(10, 10),
render_egoposes_range=render_ego_pose_range,
render_legend=legend,
fig=bfig,
axes=bax)
if not ego_centric:
ax.set_title(scene['name'] + " instance_token: " +
instance_token + ", sample_token: " +
sample_token + "\n" + ", decription " +
scene['description'])
else:
ax.set_title(scene['name'] + ", sample_token: " +
sample_token + "\n" + ", decription " +
scene['description'])
#### label map ####
if 'labeled_map' in plot_list:
records_within_patch = nusc_map.get_records_in_patch(
my_patch, nusc_map.non_geometric_layers, mode='within')
self.label_map(ax,
nusc_map,
records_within_patch['stop_line'],
text_box=text_box)
#### Plot ego ####
if 'ego' in plot_list:
ego_pos, ego_quat = self.plot_ego(
ax,
sample,
ego_traj=ego_traj,
animated_agent=animated_agent,
plot_ego=plot_human_ego)
#### Plot other agents ####
if 'pedestrian' in plot_list or 'other_cars' in plot_list:
road_agents_in_patch = self.plot_road_agents(
ax,
instance_token,
sample,
plot_list,
text_box,
sensor_info,
my_patch,
plot_traj=plot_agent_trajs,
animated_agent=animated_agent)
##################
# Car to predict #
##################
if not ego_centric:
agent_pos, agent_quat = self.plot_car_to_predict(
ax, agent_future, agent_past, instance_token, sample_token,
text_box, predictions, agent_state_dict)
#### plot all_info ####
if 'map_info' in self.plot_list:
if not ego_centric:
self.plot_map_info(ax, agent_pos, nusc_map, text_box=text_box)
else:
self.plot_map_info(ax, ego_pos, nusc_map, text_box=text_box)
#### plot sensor info ###
if sensor_info is not None and 'sensor_info' in plot_list:
self.plot_sensor_info(ax,
sensor_info=sensor_info,
text_box=text_box)
#### render map layers on camera images ####
if 'cam' in plot_list:
#sfig, sax = plt.subplots(nrows=2, ncols=3, sharex=True, sharey=True, figsize=(9,16))
layer_names = [
'road_segment', 'lane', 'ped_crossing', 'walkway', 'stop_line',
'carpark_area'
]
layer_names = []
#cam_names = ['CAM_FRONT_LEFT', 'CAM_FRONT', 'CAM_FRONT_RIGHT',
# 'CAM_BACK_RIGHT', 'CAM_BACK', 'CAM_BACK_LEFT']
cam_names = ['CAM_FRONT']
k = 0
if sfig is None:
if len(cam_names) == 6:
sfig, sax = plt.subplots(nrows=2, ncols=3)
for i in range(2):
for j in range(3):
sax[i, j].xaxis.set_visible(False)
sax[i, j].yaxis.set_visible(False)
cam_fig, cam_ax = nusc_map.render_map_in_image(
self.nusc,
sample_token,
layer_names=layer_names,
camera_channel=cam_names[k],
ax=sax[i, j])
k += 1
elif len(cam_names) == 1:
cam_fig, cam_ax = plt.subplots()
cam_ax.xaxis.set_visible(False)
cam_ax.yaxis.set_visible(False)
nusc_map.render_map_in_image(self.nusc,
sample_token,
layer_names=layer_names,
camera_channel=cam_names[k],
ax=cam_ax)
else:
raise ValueError('')
if sfig is not None:
sfig.tight_layout(pad=0)
sfig.set_figheight(7)
sfig.set_figwidth(15)
# for car_info in road_agents_in_patch['vehicles']:
# instance_token = car_info['instance_token']
# # render annotations inside patch
# ann = self.helper.get_sample_annotation(instance_token, sample_token)
# ann_fig, ann_ax = self.nusc.render_annotation(ann['token'])
# if sensing_patch is not None and self.in_shapely_polygon(car_info['translation'], sensing_patch):
# ann_ax.set_title("Sensed")
else:
sfig, sax = None, None
cam_fig, cam_ax = None, None
#### render additional outside information ####
if render_additional is not None:
self.render_additional(ax, render_additional)
if not show_axis:
plt.axis('off')
plt.grid('off')
ax.grid(False)
ax.set_aspect('equal')
other = {
'cam_fig': cam_fig,
'cam_ax': cam_ax,
'sfig': sfig,
'sax': sax
}
return fig, ax, other
def render_additional(self, ax, render_dict: dict = None):
if 'lines' in render_dict.keys():
# lines = [
# {
# 'start': <2x1 vector>,
# 'end': <2x1 vector>
# 'color': <color>
# },
# {
# 'traj': <2xn vector>,
# 'color': <color>,
# 'marker': <marker>
# }
# ]
for l in render_dict['lines']:
if 'start' in l.keys():
ax.plot([l['start'][0], l['end'][0]],
[l['start'][1], l['end'][1]],
c=l['color'])
elif 'traj' in l.keys():
ax.plot(l['traj'][:, 0],
l['traj'][:, 1],
c=l['color'],
linestyle=l['marker'])
if 'scatters' in render_dict.keys():
# scatters = [
# {
# 'traj': <nx2 matrix>,
# 'color': <color>
# }
# ]
for s in render_dict['scatters']:
ax.scatter(s['traj'][:, 0],
s['traj'][:, 1],
color=s['color'],
s=30,
zorder=700)
if 'text_boxes' in render_dict.keys():
# text_boxes = [
# {
# 'text_string': <str>,
# 'pos': np.ndarray
# }
# ]
for textbox in render_dict['text_boxes']:
self.plot_text_box(ax, textbox['text_string'], textbox['pos'])
def in_my_patch(self, pos, my_patch):
if pos[0] > my_patch[0] and pos[1] > my_patch[1] and pos[0] < my_patch[
2] and pos[1] < my_patch[3]:
return True
else:
return False
def plot_center_lanes(self):
pass
def plot_elements(self,
pos: np.ndarray,
heading: float,
object_type="current_car",
ax=None,
label: str = "",
attribute: str = "",
animated_agent=False):
'''pos is the global coordinate of the object
heading is in degrees
object_type can be 'current_car' 'other_car', 'pedestrian'
'''
if object_type == 'current_car':
obj = robot
elif object_type == 'other_cars':
obj = cars[0]
elif object_type == 'ego':
obj = cars[4]
elif object_type == 'sim_ego':
obj = cars[2]
elif object_type == 'pedestrian':
obj = ped
else:
raise ValueError('object type not supported')
if object_type != 'pedestrian':
r_img = rotate(obj, angle=90, axes=(1, 0))
r_img = rotate(r_img, angle=-heading, axes=(1, 0))
if object_type == 'current_car':
oi = OffsetImage(r_img, zoom=0.02, zorder=700)
color = 'green'
elif object_type == 'other_cars':
oi = OffsetImage(r_img, zoom=0.035, zorder=700)
color = 'blue'
elif object_type == 'ego':
oi = OffsetImage(r_img, zoom=0.015, zorder=700)
color = 'red'
elif object_type == 'sim_ego':
oi = OffsetImage(r_img, zoom=0.015, zorder=700)
color = 'yellow'
veh_box = AnnotationBbox(oi, (pos[0], pos[1]), frameon=False)
veh_box.zorder = 700
if animated_agent:
ax.add_artist(veh_box)
else:
ax.scatter(pos[0],
pos[1],
marker='H',
color=color,
s=100,
zorder=700)
else:
ax.scatter(pos[0], pos[1], marker='*', color='green', s=100)
def plot_text_box(self,
ax,
text_string: str,
pos: np.ndarray,
facecolor: str = 'wheat'):
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
ax.text(pos[0],
pos[1],
text_string,
fontsize=10,
bbox=props,
zorder=800)
def plot_contour(self, ax, contour):
X = contour['X']
Y = contour['Y']
Z = contour['Z']
levels = contour['levels']
transform = contour['transform']
X_global = X
Y_global = Y
# if transform is not None:
# Coord_local = np.concatenate([np.expand_dims(X, axis=0),
# np.expand_dims(Y, axis=0)], axis=0)
# coord_global = convert_local_coords_to_global(Coord_local.reshape(2, -1).T, transform['translation'], transform['rotation'])
# X_global = []
# Y_global = []
# for i in range(0, coord_global.shape[0], X.shape[1]):
# X_global.append(coord_global[i:i+X.shape[1], 0].tolist())
# Y_global.append(coord_global[i:i+X.shape[1], 1].tolist())
# X_global = np.array(X_global)
# Y_global = np.array(Y_global)
cp = ax.contourf(X_global,
Y_global,
Z,
levels,
zorder=100,
alpha=0.5,
cmap='Reds',
linewidths=3)
def plot_sensor_info(self,
ax,
sensor_info,
text_box=True,
plot_ado_connection_lines=False):
#### plot sensing patch ####
sensing_patch = sensor_info['sensing_patch']['polygon']
polygon = matplotlib.patches.Polygon(
np.array(list(sensing_patch.exterior.coords)),
fill=True,
fc='green',
alpha=0.3,
#edgecolor='green',
#linestyle='--',
linewidth=2)
if 'sensing_patch' in self.plot_list:
ax.add_patch(polygon)
#### plot ego ####
ego_info = sensor_info['ego_info']
ego_pos = ego_info['translation'][:2]
ego_quat = ego_info['rotation_quat']
#### plot agents ####
agent_info = sensor_info['agent_info']
if plot_ado_connection_lines:
for agent in agent_info:
agent_pos = agent['translation'][:2]
ax.plot([ego_pos[0], agent_pos[0]], [ego_pos[1], agent_pos[1]],
c='black')
#### plot map info ####
def plot_map_info(self, ax, agent_pos, nusc_map, text_box=True):
closest_lane_id = nusc_map.get_closest_lane(agent_pos[0],
agent_pos[1],
radius=2)
closest_lane_record = nusc_map.get_lane(closest_lane_id)
closest_lane_poses = np.array(
arcline_path_utils.discretize_lane(closest_lane_record,
resolution_meters=1))
incoming_lane_ids = nusc_map.get_incoming_lane_ids(closest_lane_id)
incoming_lane_data = []
for incoming_lane_id in incoming_lane_ids:
i_record = nusc_map.get_lane(incoming_lane_id)
i_poses = np.array(
arcline_path_utils.discretize_lane(i_record,
resolution_meters=1))
incoming_lane_data.append({'record': i_record, 'poses': i_poses})
outgoing_lane_ids = nusc_map.get_outgoing_lane_ids(closest_lane_id)
outgoing_lane_data = []
for outgoing_lane_id in outgoing_lane_ids:
o_record = nusc_map.get_lane(outgoing_lane_id)
o_poses = np.array(
arcline_path_utils.discretize_lane(o_record,
resolution_meters=1))
outgoing_lane_data.append({'record': o_record, 'poses': o_poses})
map_info = {
'closest_lane': {
'record': closest_lane_record,
'poses': closest_lane_poses
},
'incoming_lanes': incoming_lane_data,
'outgoing_lanes': outgoing_lane_data
}
for k, v in viewitems(map_info):
if k == 'stop_line':
for d in v:
bd = d['bounding_box']
center = [(bd[0] + bd[2]) / 2, (bd[1] + bd[3]) / 2]
if text_box:
self.plot_text_box(
ax, 'detected_' + d['record']['stop_line_type'],
center, 'blue')
elif k == 'closest_lane':
p = np.array(v['poses'])
ax.plot(p[:, 0],
p[:, 1],
linestyle="-.",
linewidth=2,
color='yellow')
elif k == 'incoming_lanes':
for d in v:
p = np.array(d['poses'])
ax.plot(p[:, 0],
p[:, 1],
linestyle="-.",
linewidth=2,
color='brown')
elif k == 'outgoing_lanes':
for d in v:
p = np.array(d['poses'])
ax.plot(p[:, 0],
p[:, 1],
linestyle="-.",
linewidth=2,
color='white')
else:
raise ValueError(f'info type {k} not supported')
def plot_car_to_predict(self,
ax,
agent_future: np.ndarray,
agent_past: np.ndarray,
instance_token: str,
sample_token: str,
text_box: bool = True,
predictions: list = None,
agent_state_dict: dict = None):
'''
predictions = {
'name': {'data': <data>, 'color': <coloar>, 'frame': <frame>, 'style':'.'}
}
'''
## plot car ####
ann = self.helper.get_sample_annotation(instance_token, sample_token)
category = ann['category_name']
if len(ann['attribute_tokens']) != 0:
attribute = self.nusc.get('attribute',
ann['attribute_tokens'][0])['name']
else:
attribute = ""
agent_yaw = Quaternion(ann['rotation'])
agent_yaw = quaternion_yaw(agent_yaw)
agent_yaw = angle_of_rotation(agent_yaw)
agent_yaw = np.rad2deg(agent_yaw)
self.plot_elements([ann['translation'][0], ann['translation'][1]],
agent_yaw, 'current_car', ax)
if text_box:
self.plot_text_box(
ax, category,
[ann['translation'][0] + 1.2, ann['translation'][1]])
self.plot_text_box(
ax, attribute,
[ann['translation'][0] + 1.2, ann['translation'][1] + 1.2])
if agent_state_dict is not None:
state_str = ""
for k, v in agent_state_dict.items():
state_str += f"{k[0]}:{v:.2f}, "
self.plot_text_box(
ax, state_str,
[ann['translation'][0] + 1.2, ann['translation'][1] + 3.2])
agent_pos = [ann['translation'][0], ann['translation'][1]]
agent_yaw_deg = agent_yaw
# plot ground truth
if len(agent_future) > 0:
ax.scatter(agent_future[:, 0],
agent_future[:, 1],
s=20,
c='yellow',
alpha=1.0,
zorder=200)
if len(agent_past) > 0:
ax.scatter(agent_past[:, 0],
agent_past[:, 1],
s=20,
c='k',
alpha=0.5,
zorder=200)
# plot predictions
if predictions is not None:
for k, v in viewitems(predictions):
if v['frame'] == 'local':
v['data'] = convert_local_coords_to_global(
v['data'], np.array(agent_pos),
np.array(ann['rotation']))
if 'style' not in v.keys():
v['style'] = '.'
if v['style'] == '.':
ax.scatter(v['data'][:, 0],
v['data'][:, 1],
s=20,
c=v['color'],
alpha=1.0,
zorder=2)
elif v['style'] == '-':
ax.plot(v['data'][:, 0],
v['data'][:, 1],
c=v['color'],
alpha=1.0,
zorder=2)
else:
raise ValueError('style not supported')
return agent_pos, ann['rotation']
def label_map(self, ax, nusc_map, map_records, text_box=True):
#### Label map ####
for record_token in map_records:
bd = nusc_map.get_bounds('stop_line', record_token)
center = [(bd[0] + bd[2]) / 2, (bd[1] + bd[3]) / 2]
record = nusc_map.get('stop_line', record_token)
stop_line_type = record['stop_line_type']
if text_box:
self.plot_text_box(ax, stop_line_type, center, 'white')
def plot_ego(self,
ax,
sample,
ego_traj=None,
animated_agent=False,
plot_ego=True):
sample_data = self.nusc.get('sample_data', sample['data']['CAM_FRONT'])
ego_pose = self.nusc.get('ego_pose', sample_data['ego_pose_token'])
pos = [ego_pose['translation'][0], ego_pose['translation'][1]]
ego_yaw = Quaternion(ego_pose['rotation'])
ego_yaw = quaternion_yaw(ego_yaw)
ego_yaw = angle_of_rotation(ego_yaw)
ego_yaw = np.rad2deg(ego_yaw)
if plot_ego:
self.plot_elements(pos,
ego_yaw,
'ego',
ax,
animated_agent=animated_agent)
if ego_traj is not None:
for name, traj_dict in ego_traj.items():
ax.scatter(traj_dict['traj'][:, 0],
traj_dict['traj'][:, 1],
c=traj_dict['color'],
s=60,
zorder=80)
return pos, ego_pose['rotation']
def plot_trajectory_distributions(self, ax, traj_dist_dict):
'''
traj_dist_dict = {
<instance_sample_token>: {"traj_dist": [[mean, cov], [], ...],
"frame": <"local" or "global">,
"pos": <np.ndarray or list>, # global coordinate of origin
"quat": <np.ndarray or list> # global rotation of origin
}
}
'''
for k, v in traj_dist_dict.items():
traj_dist = v['traj_dist']
for dist in traj_dist:
mean, cov = dist
if v['frame'] == 'local':
mean = convert_local_coords_to_global(
np.array(mean), v['pos'], v['quat'])
x, y = np.random.multivariate_normal(mean, cov, size=100).T
sns.kdeplot(x=x, y=y, cmap='Blues', ax=ax)
def plot_road_agents(self,
ax,
fig,
sample,
plot_list,
text_box,
sensor_info,
my_patch,
plot_traj=False,
contour_func=None,
animated_agent=False):
road_agents_in_patch = {'pedestrians': [], 'vehicles': []}
for ann_token in sample['anns']:
ann = self.nusc.get('sample_annotation', ann_token)
category = ann['category_name']
if len(ann['attribute_tokens']) != 0:
attribute = self.nusc.get('attribute',
ann['attribute_tokens'][0])['name']
else:
attribute = ""
pos = [ann['translation'][0], ann['translation'][1]]
instance_token = ann['instance_token']
sample_token = sample['token']
#### Plot other agents ####
valid_agent = False
if 'other_cars' in plot_list and 'vehicle' in category and 'parked' not in attribute and self.in_my_patch(
pos, my_patch):
valid_agent = True
agent_yaw = Quaternion(ann['rotation'])
agent_yaw = quaternion_yaw(agent_yaw)
agent_yaw = angle_of_rotation(agent_yaw)
agent_yaw = np.rad2deg(agent_yaw)
self.plot_elements(pos,
agent_yaw,
'other_cars',
ax,
animated_agent=animated_agent)
car_info = {
'instance_token': ann['instance_token'],
'category': category,
'attribute': attribute,
'translation': pos,
'rotation_quat': ann['rotation'],
'rotation_deg': agent_yaw
}
road_agents_in_patch['vehicles'].append(car_info)
if text_box:
self.plot_text_box(
ax, category,
[ann['translation'][0] + 1.2, ann['translation'][1]])
self.plot_text_box(ax, attribute, [
ann['translation'][0] + 1.2,
ann['translation'][1] - 1.2
])
self.plot_text_box(ax, ann['instance_token'], [
ann['translation'][0] + 1.2,
ann['translation'][1] + 1.2
])
#### Plot pedestrians ####
if 'pedestrian' in plot_list and 'pedestrian' in category and not 'stroller' in category and not 'wheelchair' in category and self.in_my_patch(
pos, my_patch):
valid_agent = True
agent_yaw = Quaternion(ann['rotation'])
agent_yaw = quaternion_yaw(agent_yaw)
agent_yaw = angle_of_rotation(agent_yaw)
agent_yaw = np.rad2deg(agent_yaw)
self.plot_elements(pos, agent_yaw, 'pedestrian', ax)
if text_box:
self.plot_text_box(
ax, category,
[ann['translation'][0] + 1.2, ann['translation'][1]])
self.plot_text_box(ax, attribute, [
ann['translation'][0] + 1.2,
ann['translation'][1] - 1.2
])
if valid_agent and plot_traj:
agent_future = self.helper.get_future_for_agent(
instance_token,
sample_token,
self.na_config['pred_horizon'],
in_agent_frame=False,
just_xy=True)
agent_past = self.helper.get_past_for_agent(
instance_token,
sample_token,
self.na_config['obs_horizon'],
in_agent_frame=False,
just_xy=True)
if len(agent_future) > 0:
ax.scatter(agent_future[:, 0],
agent_future[:, 1],
s=10,
c='y',
alpha=1.0,
zorder=200)
if len(agent_past) > 0:
ax.scatter(agent_past[:, 0],
agent_past[:, 1],
s=10,
c='k',
alpha=0.2,
zorder=200)
return road_agents_in_patch
def print_status(event):
"""Wypisuje aktualnie przetwarzaną przez program parę login i hasło, zwraca None.
Argumenty:
event -- zdarzenie informujące moduł attack o wypisaniu informacji
"""
event.set()
p_timer = threading.Timer(config["info_time"], print_status, [event])
p_timer.setDaemon(True)
if config["info_time"] != 0:
p_timer.start()
if __name__ == '__main__':
configUtils = Configuration()
parser = configUtils.getOpt()
session_filename_1 = configUtils.getConfig()["session_attack"]
session_filename_2 = configUtils.getConfig()["session_queue1"]
session_filename_3 = configUtils.getConfig()["session_queue2"]
session_filename_4 = configUtils.getConfig()["session_config"]
(options, args) = parser.parse_args()
if options.restore == True:
restore_session()
msg = _("Odzyskanie sesji")
if verbose:
print(datetime.today().isoformat(' ') + ": " + msg)
log.info(datetime.today().isoformat(' ') + ": " + msg)
main()
class VideoPipeline(QObject):
processed = Signal(object)
def __init__(self, pipeline_file):
QObject.__init__(self)
self.pipeline_conf = Configuration(pipeline_file)
self.filters = []
self.pipeline = self.pipeline_conf.sections()
icon_file = pipeline_file.replace(".ini", ".png")
if os.path.isfile(icon_file):
self.icon_path = icon_file
# the input format for the first filter element
input_format = None
for pipeline_section in self.pipeline:
# ignore the common section
if pipeline_section == "common":
continue
instance = clazz.instance_by_name(pipeline_section, pipeline_section, self.pipeline_conf)
instance.index = len(self.filters)
# check that the output format if the predecessor filter matches with the input if this
# filter
meta = instance.meta()
if not input_format==None and not meta["input"] == input_format:
print("Filter '{}' is unable to process input format '{}'. Expected was '{}'".format(python_file, input_format, meta["input"]))
print("Wrong pipeline definition. Exit")
exit_process()
instance.param_changed.connect(self.process)
# the output if this filter is the input of the next filter
input_format = meta["output"]
self.filters.append(instance)
def meta(self):
meta_info = []
for instance in self.filters:
menu = self.pipeline_conf.get_boolean("menu", instance.conf_section)
meta = instance.meta()
meta["menu"] = menu
meta_info.append(meta)
return {
"name": self.pipeline_conf.get("name"),
"description": self.pipeline_conf.get("description"),
"author": self.pipeline_conf.get("author"),
"filters": meta_info
}
def filter(self, index):
return self.filters[index]
def filter_count(self):
return len(self.filters)
def gcode(self, contour_3d):
return self.filters[len(self.filters) - 1].gcode(contour_3d)
def process(self):
result = []
image = None
cnt = []
for instance in self.filters:
try:
image, cnt = instance.process(image, cnt)
result.append({"filter": instance.conf_section, "image": image, "contour": cnt})
print("------------------------")
except Exception as exc:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
print(type(instance), exc)
self.processed.emit(result)
