def create_exporter(service_name, uri):
""" Funtion to create the exporter in the Zipkin instrumentation.
Parameters
----------
service_name: str
Name of the service the will appear on zipkin.
uri: str
Zipkin URI.
Returns
-------
ZipkinExporter
The OpenCensus Zipkin Trace Exporter is a trace exporter that exports data to Zipkin.
"""
log = Logger(name="CreateExporter")
zipkin_ok = re.match("http:\\/\\/([a-zA-Z0-9\\.]+)(:(\\d+))?", uri)
if not zipkin_ok:
log.critical(
"Invalid zipkin uri \"{}\", expected http://<hostname>:<port>",
uri)
exporter = ZipkinExporter(service_name=service_name,
host_name=zipkin_ok.group(1),
port=zipkin_ok.group(3),
transport=AsyncTransport)
return exporter
def create_exporter(service_name, uri):
log = Logger(name="CreateExporter")
zipkin_ok = re.match("http:\\/\\/([a-zA-Z0-9\\.]+)(:(\\d+))?", uri)
if not zipkin_ok:
log.critical(
"Invalid zipkin uri \"{}\", expected http://<hostname>:<port>",
uri)
exporter = ZipkinExporter(service_name=service_name,
host_name=zipkin_ok.group(1),
port=zipkin_ok.group(3),
transport=AsyncTransport)
return exporter
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(), 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
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 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='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
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)
DEADLINE_SEC = 15.0
class State(Enum):
MAKE_REQUESTS = 1
RECV_REPLIES = 2
CHECK_END_OF_VIDEO_AND_SAVE = 3
CHECK_FOR_TIMEOUTED_REQUESTS = 4
EXIT = 5
log = Logger(name='Request2dSkeletons')
options = load_options(print_options=False)
if not os.path.exists(options.folder):
log.critical("Folder '{}' doesn't exist", options.folder)
sys.exit(-1)
files = next(os.walk(options.folder))[2] # only files from first folder level
video_files = list(filter(lambda x: x.endswith('.mp4'), files))
pending_videos = []
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):
comprimento_medio_perna_direita)
file_results.write("\n")
file_results.write("Altura média: %5.3f m" %
altura_media) #(sum(altura_pessoa)/len(altura_pessoa)))
file_results.write("\n")
file_results.close()
log = Logger(name='WatchVideos')
with open('keymap.json', 'r') as f:
keymap = json.load(f)
options = load_options(print_options=False)
if not os.path.exists(options.folder):
log.critical("Folder '{}' doesn't exist", options.folder)
with open('gestures.json', 'r') as f:
gestures = json.load(f)
gestures = OrderedDict(sorted(gestures.items(), key=lambda kv: int(kv[0])))
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',
import re
import sys
import cv2
import time
import numpy as np
from is_msgs.image_pb2 import Image, ObjectAnnotations
from is_wire.core import Channel, Subscription, Message, Logger
from is_wire.core import Tracer, ZipkinExporter, BackgroundThreadTransport
log = Logger(name='Publisher')
broker_uri = 'amqp://localhost:5672'
if len(sys.argv) > 2:
log.critical('Invalid arguments. Try: python requester.py <BROKER_URI>')
if len(sys.argv) > 1:
broker_uri = sys.argv[1]
channel = Channel(broker_uri)
subscription = Subscription(channel)
exporter = ZipkinExporter(
service_name='SkeletonsDetectorRequester',
host_name='localhost',
port=9411,
transport=BackgroundThreadTransport(max_batch_size=100),
)
image = cv2.imread('../image.png')
tracer = Tracer(exporter)
with tracer.span(name='image') as span:
cimage = cv2.imencode(ext='.jpeg', img=image, params=[cv2.IMWRITE_JPEG_QUALITY, 80])
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)
channel.publish(msg)
sequence = "{:03d}".format(int(subject_id))
sequence_folder = os.path.join(labels_folders[label_id], sequence)
if os.path.exists(sequence_folder):
log.warn(
'Path to SUBJECT_ID={} LABEL={} ({}) already exists.\n \
Would you like to proceed? All data will be deleted! [y/n]', subject_id,
label_id, labels[label_id])
key = input()
if key == 'y':
shutil.rmtree(sequence_folder)
elif key == 'n':
sys.exit(0)
else:
log.critical('Invalid command \'{}\', exiting.', key)
sys.exit(-1)
os.makedirs(sequence_folder)
channel = Channel(op.broker_uri)
subscription = Subscription(channel)
if device == "webcam":
# subscribe to one camera
subscription.subscribe('CameraGateway.{}.Frame'.format(cam.id))
elif device == "cameras":
# subscribe to multiple cameras
for c in cam:
subscription.subscribe('CameraGateway.{}.Frame'.format(c.id))
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))
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)
import re
import sys
import cv2
import numpy as np
import time
from is_msgs.image_pb2 import Image
from is_wire.core import Channel, Message, Logger
from is_wire.core import Tracer, ZipkinExporter, BackgroundThreadTransport
log = Logger(name='Publisher')
topic_id = 0
broker_uri = 'amqp://localhost:5672'
if len(sys.argv) != 3 and len(sys.argv) != 1:
log.critical(
'Invalid arguments. Try: python publisher.py <BROKER_URI> <TOPIC_ID>')
if len(sys.argv) > 1:
broker_uri = sys.argv[1]
topic_id = sys.argv[2]
channel = Channel(broker_uri)
exporter = ZipkinExporter(
service_name='CameraGateway.{}'.format(topic_id),
host_name='localhost',
port=9411,
transport=BackgroundThreadTransport(max_batch_size=100),
)
image = cv2.imread('../image.png')
for k in range(10):
import json
import numpy as np
from functools import reduce
from is_msgs.image_pb2 import ObjectAnnotations
from google.protobuf.wrappers_pb2 import Int64Value
from utils.io import ProtobufReader
from utils.options import load_options
from is_wire.core import Logger
import matplotlib as mpl
import matplotlib.pyplot as plt
log = Logger()
options = load_options('../global_options.json')
if len(sys.argv) != 2:
log.critical(
"Enter an options file. python3 make-heatmap.py <OPTIONS_FILE>")
with open(sys.argv[1], 'r') as f:
hm_options = json.load(f)
dataset = hm_options['dataset']
dataset_folder = os.path.join(options['data_folder'], dataset)
model = hm_options['model']
source = hm_options['source']
filename = os.path.join(dataset_folder,
'{}_3d_{}_grouped'.format(model, source))
reader = ProtobufReader(filename)
def get_coordinate(sk, axis, mean=False):
def reducer(p):
