def main(): service_name = 'SkeletonsDetector.Detect' op = load_options() sd = RPCSkeletonsDetector(op) log = Logger(name=service_name) channel = Channel(op.broker_uri) log.info('Connected to broker {}', op.broker_uri) provider = ServiceProvider(channel) provider.add_interceptor(LogInterceptor()) max_batch_size = max(100, op.zipkin_batch_size) exporter = ZipkinExporter( service_name=service_name, host_name=op.zipkin_host, port=op.zipkin_port, transport=BackgroundThreadTransport(max_batch_size=max_batch_size), ) tracing = TracingInterceptor(exporter=exporter) provider.delegate(topic='SkeletonsDetector.Detect', function=partial(RPCSkeletonsDetector.detect, sd), request_type=Image, reply_type=ObjectAnnotations) provider.run()
def load_options(): log = Logger(name='LoadOptions') op_file = sys.argv[1] if len(sys.argv) > 1 else 'options.json' try: with open(op_file, 'r') as f: try: op = Parse(f.read(), SkeletonsHeatmapOptions()) log.info('Options: \n{}', op) except Exception as ex: log.critical('Unable to load options from \'{}\'. \n{}', op_file, ex) sys.exit(-1) except: log.critical('Unable to load options from \'{}\'', op_file) sys.exit(-1) except Exception as ex: log.critical('Unable to open file \'{}\'', op_file) sys.exit(-1) message = op.DESCRIPTOR.full_name # validation if op.period_ms < 200: message += " 'period_ms' field must be equal or greater than 200. " message += "Given {}".format(op.period_ms) raise Exception(message) if op.period_ms > 1000: message += " 'period_ms' field must be equal or less than 1000. " message += "Given {}".format(op.period_ms) raise Exception(message) return op
class BrokerEvents(object): def __init__(self, broker_uri, management_uri, log_level): self.log = Logger(name="BrokerEvents", level=log_level) self.log.debug("broker_uri='{}'", broker_uri) self.channel = Channel(broker_uri) self.subscription = Subscription(self.channel) self.subscription.subscribe(topic="binding.*") self.log.debug("management_uri='{}'", management_uri) self.consumers = self.query_consumers_http(management_uri) def run(self): while True: msg = self.channel.consume() self.log.debug("topic='{}' metadata={}", msg.topic, msg.metadata) if msg.metadata["destination_kind"] != "queue" or \ msg.metadata["source_name"] != "is": continue event = msg.topic.split('.')[-1] topic = msg.metadata["routing_key"] queue = msg.metadata["destination_name"] if event == "created": self.consumers.info[topic].consumers.append(queue) elif event == "deleted": self.consumers.info[topic].consumers.remove(queue) if len(self.consumers.info[topic].consumers) == 0: del self.consumers.info[topic] self.log.info("event='{}' topic='{}' queue='{}'", event, topic, queue) self.channel.publish( Message(content=self.consumers), topic="BrokerEvents.Consumers", ) @staticmethod def query_consumers_http(management_uri): reply = requests.get(management_uri + "/api/bindings") if reply.status_code != 200: why = "Failed to query management API, code={}".format( reply.status_code) raise RuntimeError(why) bindings = reply.json() bindings = [ b for b in bindings if b["destination_type"] == "queue" and b["source"] == "is" ] consumers = ConsumerList() for b in bindings: consumers.info[b["routing_key"]].consumers.append(b["destination"]) return consumers
def main(): service_name = "FaceDetector.Detection" log = Logger(name=service_name) op = load_options() face_detector = FaceDetector(op.model) channel = StreamChannel(op.broker_uri) log.info('Connected to broker {}', op.broker_uri) exporter = create_exporter(service_name=service_name, uri=op.zipkin_uri) subscription = Subscription(channel=channel, name=service_name) subscription.subscribe(topic='CameraGateway.*.Frame') while True: msg, dropped = channel.consume_last(return_dropped=True) tracer = Tracer(exporter, span_context=msg.extract_tracing()) span = tracer.start_span(name='detection_and_render') detection_span = None with tracer.span(name='unpack'): im = msg.unpack(Image) im_np = to_np(im) with tracer.span(name='detection') as _span: camera_id = get_topic_id(msg.topic) faces = face_detector.detect(im_np) detection_span = _span with tracer.span(name='pack_and_publish_detections'): faces_msg = Message() faces_msg.topic = 'FaceDetector.{}.Detection'.format(camera_id) faces_msg.inject_tracing(span) faces_msg.pack(faces) channel.publish(faces_msg) with tracer.span(name='render_pack_publish'): img_rendered = draw_detection(im_np, faces) rendered_msg = Message() rendered_msg.topic = 'FaceDetector.{}.Rendered'.format(camera_id) rendered_msg.pack(to_image(img_rendered)) channel.publish(rendered_msg) span.add_attribute('Detections', len(faces.objects)) tracer.end_span() info = { 'detections': len(faces.objects), 'dropped_messages': dropped, 'took_ms': { 'detection': round(span_duration_ms(detection_span), 2), 'service': round(span_duration_ms(span), 2) } } log.info('{}', str(info).replace("'", '"'))
def load_options(): log = Logger(name='LoadingOptions') op_file = sys.argv[1] if len(sys.argv) > 1 else 'options.json' try: with open(op_file, 'r') as f: try: op = Parse(f.read(), GestureRecognizierOptions()) log.info('GestureRecognizierOptions: \n{}', op) return op except Exception as ex: log.critical('Unable to load options from \'{}\'. \n{}', op_file, ex) except Exception as ex: log.critical('Unable to open file \'{}\'', op_file)
def load_options(): log = Logger(name='LoadOptions') op_file = sys.argv[1] if len(sys.argv) > 1 else 'options.json' try: with open(op_file, 'r') as f: try: op = Parse(f.read(), ObjectAnnotationsTransformerOptions()) log.info('Options: \n{}', op) except Exception as ex: log.critical('Unable to load options from \'{}\'. \n{}', op_file, ex) except: log.critical('Unable to load options from \'{}\'', op_file) except Exception as ex: log.critical('Unable to open file \'{}\'', op_file) return op
def load_options(): log = Logger(name='LoadingOptions') op_file = sys.argv[1] if len(sys.argv) > 1 else 'options.json' try: with open(op_file, 'r') as f: try: op = Parse(f.read(), Options()) mem_frac = op.per_process_gpu_memory_fraction if mem_frac < 0.0 or mem_frac > 1.0: log.critical("Invalid value for 'per_process_gpu_memory_fraction': {}. Must be in [0.0, 1.0]", mem_frac) log.info('Options: \n{}', op) return op except Exception as ex: log.critical('Unable to load options from \'{}\'. \n{}', op_file, ex) except: log.critical('Unable to load options from \'{}\'', op_file) except Exception as ex: log.critical('Unable to open file \'{}\'', op_file)
def main(): log = Logger(name="Parser") parser = argparse.ArgumentParser(description='Broker events service') parser.add_argument('--config', dest='config', type=str, default="config.json", help='path to configuration file') args = parser.parse_args() with open(args.config) as f: config = json.load(f) log.info("{}", config) service = BrokerEvents( broker_uri=config["broker_uri"], management_uri=config["management_uri"], log_level=logging.getLevelName(config["log_level"]), ) service.run()
def main(): service_name = 'FaceDetector.Detect' log = Logger(name=service_name) op = load_options() detector = RPCFaceDetector(op.model) channel = Channel(op.broker_uri) log.info('Connected to broker {}', op.broker_uri) provider = ServiceProvider(channel) provider.add_interceptor(LogInterceptor()) exporter = create_exporter(service_name=service_name, uri=op.zipkin_uri) tracing = TracingInterceptor(exporter=exporter) provider.add_interceptor(tracing) provider.delegate(topic='FaceDetector.Detect', function=detector.detect, request_type=Image, reply_type=ObjectAnnotations) provider.run()
def main(): service_name = 'SkeletonsDetector.Detection' re_topic = re.compile(r'CameraGateway.(\w+).Frame') op = load_options() sd = SkeletonsDetector(op) log = Logger(name=service_name) channel = StreamChannel(op.broker_uri) log.info('Connected to broker {}', op.broker_uri) max_batch_size = max(100, op.zipkin_batch_size) exporter = ZipkinExporter( service_name=service_name, host_name=op.zipkin_host, port=op.zipkin_port, transport=BackgroundThreadTransport(max_batch_size=max_batch_size), ) subscription = Subscription(channel=channel, name=service_name) subscription.subscribe('CameraGateway.*.Frame') while True: msg, dropped = channel.consume(return_dropped=True) tracer = Tracer(exporter, span_context=msg.extract_tracing()) span = tracer.start_span(name='detection_and_render') detection_span = None with tracer.span(name='unpack'): im = msg.unpack(Image) im_np = get_np_image(im) with tracer.span(name='detection') as _span: skeletons = sd.detect(im_np) detection_span = _span with tracer.span(name='pack_and_publish_detections'): sks_msg = Message() sks_msg.topic = re_topic.sub(r'SkeletonsDetector.\1.Detection', msg.topic) sks_msg.inject_tracing(span) sks_msg.pack(skeletons) channel.publish(sks_msg) with tracer.span(name='render_pack_publish'): im_rendered = draw_skeletons(im_np, skeletons) rendered_msg = Message() rendered_msg.topic = re_topic.sub(r'SkeletonsDetector.\1.Rendered', msg.topic) rendered_msg.pack(get_pb_image(im_rendered)) channel.publish(rendered_msg) span.add_attribute('Detections', len(skeletons.objects)) tracer.end_span() log.info('detections = {:2d}, dropped_messages = {:2d}', len(skeletons.objects), dropped) log.info('took_ms = {{ detection: {:5.2f}, service: {:5.2f}}}', span_duration_ms(detection_span), span_duration_ms(span))
def load_options(): log = Logger(name='LoadOptions') op_file = sys.argv[1] if len(sys.argv) > 1 else 'options.json' try: with open(op_file, 'r') as f: try: op = Parse(f.read(), options_pb2.RobotGatewayOptions()) log.info('Options: \n{}', op) except Exception as ex: log.critical('Unable to load options from \'{}\'. \n{}', op_file, ex) except: log.critical('Unable to load options from \'{}\'', op_file) except Exception as ex: log.critical('Unable to open file \'{}\'', op_file) message = op.DESCRIPTOR.full_name # validation if op.robot_parameters.sampling_rate < 0.1: message += " 'sampling_rate' field must be equal or greater than 0.1. " message += "Given {}".format(op.robot_parameters.sampling_rate) raise Exception(message) return op
parser = argparse.ArgumentParser( description='Utility to capture a sequence of images from multiples cameras') parser.add_argument('--person', '-p', type=int, required=True, help='ID to identity person') parser.add_argument('--gesture', '-g', type=int, required=True, help='ID to identity gesture') args = parser.parse_args() person_id = args.person gesture_id = args.gesture if str(gesture_id) not in gestures: log.critical("Invalid GESTURE_ID: {}. \nAvailable gestures: {}", gesture_id, json.dumps(gestures, indent=2)) if person_id < 1 or person_id > 999: log.critical("Invalid PERSON_ID: {}. Must be between 1 and 999.", person_id) log.info("PERSON_ID: {} GESTURE_ID: {}", person_id, gesture_id) cameras = [int(cam_config.id) for cam_config in options.cameras] video_files = { cam_id: os.path.join(options.folder, 'p{:03d}g{:02d}c{:02d}.mp4'.format( person_id, gesture_id, cam_id)) for cam_id in cameras } json_files = { cam_id: os.path.join(options.folder, 'p{:03d}g{:02d}c{:02d}_2d.json'.format( person_id, gesture_id, cam_id)) for cam_id in cameras } json_locaizations_file = os.path.join(options.folder, 'p{:03d}g{:02d}_3d.json'.format( person_id, gesture_id))
type=int, required=True, help='ID to identity gesture') args = parser.parse_args() person_id = args.person gesture_id = args.gesture if str(gesture_id) not in gestures: log.critical("Invalid GESTURE_ID: {}. \nAvailable gestures: {}", gesture_id, json.dumps(gestures, indent=2)) if person_id < 1 or person_id > 999: log.critical("Invalid PERSON_ID: {}. Must be between 1 and 999.", person_id) log.info("PERSON_ID: {} GESTURE_ID: {}", person_id, gesture_id) cameras = [int(cam_config.id) for cam_config in options.cameras] video_files = { cam_id: os.path.join( options.folder, 'p{:03d}g{:02d}c{:02d}.mp4'.format(person_id, gesture_id, cam_id)) for cam_id in cameras } json_files = { cam_id: os.path.join( options.folder, 'p{:03d}g{:02d}c{:02d}_2d.json'.format(person_id, gesture_id, cam_id)) for cam_id in cameras } json_locaizations_file = os.path.join(
from is_wire.core import Logger from gateway import RobotGateway from driver import PepperRobotDriver import json import sys import os log = Logger("Service") config_path = "conf.json" if len(sys.argv) != 2 else sys.argv[1] with open(config_path) as f: config = json.load(f) log.info("config_file @'{}':\n{}", config_path, json.dumps(config, indent=4)) def env_or_default(env, default): value = os.environ[env] if env in os.environ else default log.info("{}='{}'".format(env, value)) return value broker_uri = env_or_default("BROKER_URI", config["broker_uri"]) robot_uri = env_or_default("ROBOT_URI", str(config["robot_uri"])) robot_id = env_or_default("ROBOT_ID", config["robot_id"]) driver = PepperRobotDriver(robot_uri=robot_uri, parameters=config["driver_params"]) service = RobotGateway(driver=driver) service.run(id=robot_id, broker_uri=broker_uri)
from google.protobuf.wrappers_pb2 import FloatValue from is_msgs.common_pb2 import SamplingSettings from is_msgs.image_pb2 import ImageSettings, Resolution, ColorSpace, ColorSpaces uri = 'amqp://10.10.2.15:30000' channel = Channel(uri) subscription = Subscription(channel) log = Logger(name='SetConfig') camera_id = 0 """ Loading CameraConfig protobuf from a json file """ with open('camera_config.json', 'r') as f: try: set_config = Parse(f.read(), CameraConfig()) log.info('CameraConfig:\n{}', set_config) except Exception as ex: log.critical('Unable to camera settings. \n{}', ex) """ Another way to create a CameraConfig message """ set_config = CameraConfig( sampling=SamplingSettings(frequency=FloatValue(value=5.0)), image=ImageSettings( resolution=Resolution(width=720, height=540), color_space=ColorSpace(value=ColorSpaces.Value('GRAY')))) msg = Message() msg.reply_to = subscription msg.topic = 'CameraGateway.{}.SetConfig'.format(camera_id) msg.pack(set_config)
from is_wire.core import Channel, Subscription, Message, Logger from is_msgs.common_pb2 import Position import os from sys import argv, exit log = Logger(name="client") uri = os.environ[ "BROKER_URI"] if "BROKER_URI" in os.environ else "amqp://10.10.2.20:30000" log.info("uri={}", uri) if len(argv) != 3: log.error("Usage: python navigate.py <X> <Y>") exit(-1) channel = Channel(uri) subscription = Subscription(channel) position = Position() position.x = float(argv[1]) position.y = float(argv[2]) channel.publish(message=Message(content=position, reply_to=subscription), topic="RobotGateway.0.NavigateTo") reply = channel.consume(timeout=1.0) log.info("status={}", reply.status)
from is_wire.core import Channel, Subscription, Message, Logger from is_wire.core.wire.status import StatusCode from is_msgs.common_pb2 import FieldSelector from is_msgs.camera_pb2 import CameraConfigFields, CameraConfig from google.protobuf.json_format import Parse uri = 'amqp://10.10.2.15:30000' channel = Channel(uri) subscription = Subscription(channel) log = Logger(name='GetConfig') camera_id = 0 get_config = FieldSelector() get_config.fields.append(CameraConfigFields.Value('SAMPLING_SETTINGS')) get_config.fields.append(CameraConfigFields.Value('IMAGE_SETTINGS')) msg = Message() msg.topic = 'CameraGateway.{}.GetConfig'.format(camera_id) msg.reply_to = subscription msg.pack(get_config) channel.publish(msg) while True: msg = channel.consume() if msg.status.code == StatusCode.OK: config = msg.unpack(CameraConfig) log.info('Configuration received from camera \'{}\'\n{}', camera_id, config) else: log.warn('Can\'t apply configuration:\n{}', msg.status) sys.exit(0)
class CameraGateway(object): def __init__(self, driver): self.driver = driver self.logger = Logger("CameraGateway") def get_config(self, field_selector, ctx): fields = field_selector.fields camera_config = CameraConfig() if CameraConfigFields.Value("ALL") in fields or \ CameraConfigFields.Value("SAMPLING_SETTINGS") in fields: get_val(self.driver.get_sampling_rate, camera_config.sampling.frequency, "value") get_val(self.driver.get_delay, camera_config.sampling.delay, "value") if CameraConfigFields.Value("ALL") in fields or \ CameraConfigFields.Value("IMAGE_SETTINGS") in fields: get_obj(self.driver.get_resolution, camera_config.image.resolution) get_obj(self.driver.get_image_format, camera_config.image.format) get_val(self.driver.get_color_space, camera_config.image.color_space, "value") get_obj(self.driver.get_region_of_interest, camera_config.image.region) if CameraConfigFields.Value("ALL") in fields or \ CameraConfigFields.Value("CAMERA_SETTINGS") in fields: get_obj(self.driver.get_brightness, camera_config.camera.brightness) get_obj(self.driver.get_exposure, camera_config.camera.exposure) get_obj(self.driver.get_focus, camera_config.camera.focus) get_obj(self.driver.get_gain, camera_config.camera.gain) get_obj(self.driver.get_gamma, camera_config.camera.gamma) get_obj(self.driver.get_hue, camera_config.camera.hue) get_obj(self.driver.get_iris, camera_config.camera.iris) get_obj(self.driver.get_saturation, camera_config.camera.saturation) get_obj(self.driver.get_sharpness, camera_config.camera.sharpness) get_obj(self.driver.get_shutter, camera_config.camera.shutter) get_obj(self.driver.get_white_balance_bu, camera_config.camera.white_balance_bu) get_obj(self.driver.get_white_balance_rv, camera_config.camera.white_balance_rv) get_obj(self.driver.get_zoom, camera_config.camera.zoom) return camera_config def set_config(self, camera_config, ctx): if camera_config.HasField("sampling"): if camera_config.sampling.HasField("frequency"): self.driver.set_sampling_rate( camera_config.sampling.frequency.value) if camera_config.sampling.HasField("delay"): self.driver.set_delay(camera_config.sampling.delay.value) if camera_config.HasField("image"): if camera_config.image.HasField("resolution"): self.driver.set_resolution(camera_config.image.resolution) if camera_config.image.HasField("format"): self.driver.set_image_format(camera_config.image.format) if camera_config.image.HasField("color_space"): self.driver.set_color_space( camera_config.image.color_space.value) if camera_config.image.HasField("region"): self.driver.set_region_of_interest(camera_config.image.region) if camera_config.HasField("camera"): if camera_config.camera.HasField("brightness"): self.driver.set_brightness(camera_config.camera.brightness) if camera_config.camera.HasField("exposure"): self.driver.set_exposure(camera_config.camera.exposure) if camera_config.camera.HasField("focus"): self.driver.set_focus(camera_config.camera.focus) if camera_config.camera.HasField("gain"): self.driver.set_gain(camera_config.camera.gain) if camera_config.camera.HasField("gamma"): self.driver.set_gamma(camera_config.camera.gamma) if camera_config.camera.HasField("hue"): self.driver.set_hue(camera_config.camera.hue) if camera_config.camera.HasField("iris"): self.driver.set_iris(camera_config.camera.iris) if camera_config.camera.HasField("saturation"): self.driver.set_saturation(camera_config.camera.saturation) if camera_config.camera.HasField("sharpness"): self.driver.set_sharpness(camera_config.camera.sharpness) if camera_config.camera.HasField("shutter"): self.driver.set_shutter(camera_config.camera.shutter) if camera_config.camera.HasField("white_balance_bu"): self.driver.set_white_balance_bu( camera_config.camera.white_balance_bu) if camera_config.camera.HasField("white_balance_rv"): self.driver.set_white_balance_rv( camera_config.camera.white_balance_rv) if camera_config.camera.HasField("zoom"): self.driver.set_zoom(camera_config.camera.zoom) return Empty() def run(self, id, broker_uri): service_name = "CameraGateway.{}".format(id) channel = Channel(broker_uri) server = ServiceProvider(channel) logging = LogInterceptor() server.add_interceptor(logging) server.delegate(topic=service_name + ".GetConfig", request_type=FieldSelector, reply_type=CameraConfig, function=self.get_config) server.delegate(topic=service_name + ".SetConfig", request_type=CameraConfig, reply_type=Empty, function=self.set_config) self.driver.start_capture() self.logger.info("Listening for requests") while True: image = self.driver.grab_image() channel.publish(Message(content=image), topic=service_name + ".Frame") pose = self.driver.get_pose() frameTransList = FrameTransformations() frameTransList.tfs.extend([pose]) channel.publish(Message(content=frameTransList), topic=service_name + ".FrameTransformations") try: message = channel.consume(timeout=0) if server.should_serve(message): server.serve(message) except socket.timeout: pass
import os import json from subprocess import Popen, PIPE, STDOUT from is_wire.core import Logger log = Logger(name="SplitSamples") if not os.path.exists("samples"): log.critical("'samples' folder not found") if not os.path.exists("samples/spots.json"): log.critical("'samples/spots.json' file not found") with open("samples/spots.json", 'r') as f: spots = json.load(f) ffmpeg_command = "ffmpeg -y -i gestures.MOV -ss {ss:.2f} -t {t:.2f} -an samples/{gesture:02d}.MOV" for spot in spots: g_id = int(spot['gesture']) command = ffmpeg_command.format(ss=spot['ss'], t=spot['t'], gesture=g_id) process = Popen(command.split(), stdout=PIPE, stderr=STDOUT) log.info("{}", command) if process.wait() == 0: log.info("{} | {:.2f} + {:.2f}", g_id, spot['ss'], spot['t']) else: log.error("Failed to split video gesture: {}", g_id)
def main(): service_name = 'GestureRecognizer.Recognition' log = Logger(name=service_name) op = load_options() channel = Channel(op.broker_uri) log.info('Connected to broker {}', op.broker_uri) exporter = create_exporter(service_name=service_name, uri=op.zipkin_uri) subscription = Subscription(channel=channel, name=service_name) for group_id in list(op.group_ids): subscription.subscribe( 'SkeletonsGrouper.{}.Localization'.format(group_id)) model = GestureRecognizer("model_gesture1_72.00.pth") log.info('Initialize the model') unc = Gauge('uncertainty_total', "Uncertainty about predict") unc.set(0.0) start_http_server(8000) buffer = list() predict_flag = False mean = lambda x: (sum(x) / len(x)) while True: msg = channel.consume() tracer = Tracer(exporter, span_context=msg.extract_tracing()) span = tracer.start_span(name='detection_and_info') annotations = msg.unpack(ObjectAnnotations) skeleton = select_skeletons(annotations=annotations, min_keypoints=op.skeletons.min_keypoints, x_range=op.skeletons.x_range, y_range=op.skeletons.y_range) if skeleton is None: tracer.end_span() continue skl = Skeleton(skeleton) skl_normalized = skl.normalize() pred, prob, uncertainty = model.predict(skl_normalized) if pred == 0 and predict_flag is False: pass elif pred != 0 and predict_flag is False: initial_time = time.time() predict_flag = True buffer.append(uncertainty) elif pred != 0 and predict_flag is True: buffer.append(uncertainty) elif pred == 0 and predict_flag is True: predict_flag = False exec_time = time.time() - initial_time if exec_time >= op.exec_time: unc.set(mean(buffer)) log.info("execution_ms: {}, buffer_mean: {}", (exec_time * 1000), mean(buffer)) buffer = [] tracer.end_span() info = { 'prediction': pred, 'probability': prob, 'uncertainty': uncertainty, 'took_ms': { 'service': round(span_duration_ms(span), 2) } } log.info('{}', str(info).replace("'", '"'))
options = load_options('../global_options.json') log = Logger() with open('../{}_datasets.json'.format(options['dataset_group']), 'r') as f: datasets_data = json.load(f) datasets = datasets_data['datasets'] model = datasets_data['model'] cameras = datasets_data['cameras'] width, height = datasets_data['resolution']['width'], datasets_data[ 'resolution']['height'] for dataset in datasets: dataset_folder = os.path.join(options['data_folder'], dataset) for camera in cameras: log.info("[Starting][{}] camera \'{}\'", dataset, camera) filename = os.path.join( dataset_folder, '{}_pose_2d_detected_00_{:02d}'.format(model, camera)) reader = ProtobufReader(filename) filename = os.path.join(dataset_folder, '{}_2d_detector_{}'.format(model, camera)) writer = ProtobufWriter(filename) sid = 0 while True: sks = reader.next(Skeletons()) if not sks: log.info("[Done][{}] camera \'{}\' with {} sequences", dataset, camera, sid + 1) break
n_annotations = {} for video_file in video_files: base_name = video_file.split('.')[0] annotation_file = '{}_2d.json'.format(base_name) annotation_path = os.path.join(options.folder, annotation_file) video_path = os.path.join(options.folder, video_file) cap = cv2.VideoCapture(video_path) n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) if os.path.exists(annotation_path): # check if all annotations were done with open(annotation_path, 'r') as f: annotations_data = json.load(f) n_annotations_on_file = len(annotations_data['annotations']) if n_annotations_on_file == n_frames: log.info( "Video '{}' already annotated at '{}' with {} annotations", video_file, annotations_data['created_at'], n_annotations_on_file) continue pending_videos.append(video_file) n_annotations[base_name] = n_frames if len(pending_videos) == 0: log.info("Exiting...") sys.exit(-1) channel = Channel(options.broker_uri) subscription = Subscription(channel) requests = {} annotations_received = defaultdict(dict) state = State.MAKE_REQUESTS
help='ID to identity gesture') args = parser.parse_args() person_id = args.person gesture_id = args.gesture if str(gesture_id) not in gestures: log.critical("Invalid GESTURE_ID: {}. \nAvailable gestures: {}", gesture_id, json.dumps(gestures, indent=2)) sys.exit(-1) if person_id < 1 or person_id > 999: log.critical("Invalid PERSON_ID: {}. Must be between 1 and 999.", person_id) sys.exit(-1) log.info("PERSON_ID: {} GESTURE_ID: {}", person_id, gesture_id) options = load_options(print_options=False) if not os.path.exists(options.folder): os.makedirs(options.folder) sequence = 'p{:03d}g{:02d}'.format(person_id, gesture_id) sequence_folder = os.path.join(options.folder, sequence) if os.path.exists(sequence_folder): log.warn( 'Path to PERSON_ID={} GESTURE_ID={} already exists.\nWould you like to proceed? All data will be deleted! [y/n]', person_id, gesture_id) key = input() if key == 'y': shutil.rmtree(sequence_folder)
return op # Carrega parametros do robo e endereco do broker do arquivo Json op_config = load_options() ATSPlog = Logger(name='unpack') service_name = "RobotGateway.{}".format(op_config.robot_parameters.id) sonar_topic = "RobotGateway.{}.SonarScan".format(op_config.robot_parameters.id) pose_topic = "RobotGateway.{}.Pose".format(op_config.robot_parameters.id) # instania channel passando endereco do broker # estabelece conexao com o broker channel = Channel(op_config.broker_uri) ATSPlog.info("event=ChannelInitDone") # Inscreve nos topicos que deseja receber mensagem subscription = Subscription(channel) subscription.subscribe(pose_topic) subscription.subscribe(sonar_topic) ATSPlog.info("SubscriptionsDone") # Envia mensagem de getConfig get_req = Message(reply_to=subscription) # Salva correlation_id do request cor_id = get_req.correlation_id # print("cor_id: ", cor_id) # Broadcast message to anyone interested (subscribed) channel.publish(message=get_req, topic=service_name + ".GetConfig")
class RobotGateway(object): def __init__(self, driver): self.driver = driver self.logger = Logger("RobotGateway") def get_config(self, field_selector, ctx): robot_config = RobotConfig() get_obj(self.driver.get_speed, robot_config.speed) return robot_config def set_config(self, robot_config, ctx): if robot_config.HasField("speed"): self.driver.set_speed(robot_config.speed) return Empty() def navigate_to(self, position, ctx): self.driver.navigate_to(position.x, position.y) return Empty() def move_to(self, pose, ctx): self.driver.move_to(pose.position.x, pose.position.y, pose.orientation.yaw) return Empty() def pause_awareness(self, req, ctx): self.driver.pause_awareness() return Empty() def resume_awareness(self, req, ctx): self.driver.resume_awareness() return Empty() def set_awareness(self, req, ctx): self.driver.set_awareness(req["enabled"]) return Empty() #def set_awareness_off(self, req, ctx): # self.driver.set_awareness_off() # return Empty() def run(self, id, broker_uri): service_name = "RobotGateway.{}".format(id) channel = Channel(broker_uri) server = ServiceProvider(channel) logging = LogInterceptor() server.add_interceptor(logging) server.delegate(topic=service_name + ".GetConfig", request_type=FieldSelector, reply_type=RobotConfig, function=self.get_config) server.delegate(topic=service_name + ".SetConfig", request_type=RobotConfig, reply_type=Empty, function=self.set_config) server.delegate(topic=service_name + ".NavigateTo", request_type=Position, reply_type=Empty, function=self.navigate_to) server.delegate(topic=service_name + ".MoveTo", request_type=Pose, reply_type=Empty, function=self.move_to) server.delegate(topic=service_name + ".PauseAwareness", request_type=Empty, reply_type=Empty, function=self.pause_awareness) server.delegate(topic=service_name + ".ResumeAwareness", request_type=Empty, reply_type=Empty, function=self.resume_awareness) server.delegate(topic=service_name + ".SetAwareness", request_type=Struct, reply_type=Empty, function=self.set_awareness) #server.delegate( # topic=service_name + ".SetAwarenessOff", # request_type=Empty, # reply_type=Empty, # function=self.set_awareness_off) self.logger.info("Listening for requests") while True: pose = self.driver.get_base_pose() frameTransList = FrameTransformations() frameTransList.tfs.extend([pose]) self.logger.debug("Publishing pose") channel.publish(Message(content=frameTransList), topic=service_name + ".FrameTransformations") try: message = channel.consume(timeout=0) if server.should_serve(message): server.serve(message) except socket.timeout: pass
'--id', '-i', type=int, required=False, help='Camera ID', default=0) parser.add_argument( '--device', '-d', type=int, required=False, help='Camera device. 0 for /dev/video0', default=0) parser.add_argument( '--fps', '-f', type=int, required=False, help='FPS', default=10) parser.add_argument( '--uri', '-u', type=str, required=False, help='broker_uri', default='amqp://localhost:5672') args = parser.parse_args() device = args.device fps = args.fps broker_uri = args.uri cap = VideoCapture(device) if cap.isOpened(): log.info('Connected to device: /dev/video{}'.format(device)) else: log.error('Coudn\'t find device: /dev/video{}'.format(device)) exit() log.info('Camera FPS set to {}'.format(fps)) cap.set(CAP_PROP_FPS, fps) channel = StreamChannel(broker_uri) log.info('Connected to broker {}', broker_uri) log.info('Starting to capture') while True: ret, frame = cap.read()
log = Logger(name='Client') channel = Channel('amqp://localhost:5672') request_manager = RequestManager(channel, min_requests=15, max_requests=30, log_level=Logger.INFO) poses = [(Pose(position=Position(x=i, y=2 * i)), i) for i in range(100)] while True: while request_manager.can_request() and len(poses) > 0: pose, pose_id = poses.pop() request_manager.request(content=pose, topic="GetPosition", timeout_ms=1000, metadata=pose_id) log.info('{:>6s} msg_id={}', " >>", pose_id) received_msgs = request_manager.consume_ready(timeout=1.0) for msg, metadata in received_msgs: position = msg.unpack(Position) log.info('{:<6s} msg_id={}', "<< ", metadata) if request_manager.all_received() and len(poses) == 0: log.info("All received. Exiting.") break
def main(): service_name = "CameraGateway" log = Logger(service_name) options = load_options() camera = CameraGateway(fps=options["fps"]) publish_channel = Channel(options['broker_uri']) rpc_channel = Channel(options['broker_uri']) server = ServiceProvider(rpc_channel) logging = LogInterceptor() server.add_interceptor(logging) server.delegate(topic=service_name + ".*.GetConfig", request_type=FieldSelector, reply_type=CameraConfig, function=camera.get_config) server.delegate(topic=service_name + ".*.SetConfig", request_type=CameraConfig, reply_type=Empty, function=camera.set_config) exporter = create_exporter(service_name=service_name, uri=options["zipkin_uri"]) while True: # iterate through videos listed for video in options['videos']: # id of the first sequence of videos person_id = video['person_id'] gesture_id = video['gesture_id'] # getting the path of the 4 videos video_files = { cam_id: os.path.join( options['folder'], 'p{:03d}g{:02d}c{:02d}.mp4'.format(person_id, gesture_id, cam_id)) for cam_id in options["cameras_id"] } for iteration in range(video['iterations']): info = { "person": person_id, "gesture": gesture_id, "iteration": iteration } log.info('{}', str(info).replace("'", '"')) # object that let get images from multiples videos files video_loader = FramesLoader(video_files) # iterate through all samples on video while True: time_initial = time.time() # listen server for messages about change try: message = rpc_channel.consume(timeout=0) if server.should_serve(message): server.serve(message) except socket.timeout: pass frame_id, frames = video_loader.read() for cam in sorted(frames.keys()): tracer = Tracer(exporter) span = tracer.start_span(name='frame') pb_image = to_pb_image(frames[cam]) msg = Message(content=pb_image) msg.inject_tracing(span) topic = 'CameraGateway.{}.Frame'.format(cam) publish_channel.publish(msg, topic=topic) tracer.end_span() took_ms = (time.time() - time_initial) * 1000 dt = (1 / camera.fps) - (took_ms / 1000) if dt > 0: time.sleep(dt) info = { "sample": frame_id, "took_ms": took_ms, "wait_ms": dt * 1000 } log.info('{}', str(info).replace("'", '"')) if frame_id >= (video_loader.num_samples - 1): video_loader.release() del video_loader gc.collect() break if options['loop'] is False: break
current_timestamps[topic_id] = DT.utcfromtimestamp( msg.created_at).isoformat() if device == "webcam": # save images if start_save and not sequence_saved: filename = os.path.join( sequence_folder, "{:02d}_{:03d}_{:05d}.jpeg".format(int(label_id), int(subject_id), n_sample)) with open(filename, "wb") as f: f.write(images_data[topic_id]) timestamps[topic_id].append(current_timestamps[topic_id]) n_sample += 1 log.info("Sample {} saves", n_sample) # display images if n_sample % display_rate == 0: display_image = cv2.imdecode(data, cv2.IMREAD_COLOR) draw_info_bar(display_image, info_bar_text, 50, 50, draw_circle=start_save and not sequence_saved) cv2.imshow("", display_image) current_timestamps = {} key = cv2.waitKey(1) if key == ord("s"):