class DrawArea(QGLWidget):
def __init__(self):
self._drawer = Drawer()
super().__init__()
self.setMinimumSize(600, 480)
self.resize(600, 480)
def paintGL(self):
self._drawer.paint()
def initializeGL(self):
self.qglClearColor(QtGui.QColor(25, 25, 25))
glLineWidth(1)
self.qglColor(QtGui.QColor(255, 0, 0))
def resizeGL(self, w, h):
glViewport(0, 0, w, h)
def get_drawer(self):
return self._drawer
def mousePressEvent(self, event):
candidate_point = Point2D(
(2 * event.x() - self.width()) / self.width(),
(2 * (self.height() - event.y()) - self.height()) / self.height())
self._drawer.handle_candidate(candidate_point)
self.updateGL()
def __makeTable(self, personal=False):
'''
Creates a table of the schedule and returns that in a string.
Description:
Arranges 'classes' and 'num_day' in 'day' list, each entiry is an list
of classes that happen on that day. The 'num_day' is used to tell the
Drawer what day it is.
return: None
'''
# Json file has Course and group number
filters = Filter(self.jsonData)
drawer = Drawer()
day = []
date = self.classes[
0].date # The date of the first element in list so it can start comparing with others
class_list = []
for entiry in self.classes:
if not personal or filters.checkGroup(entiry):
# Sees if the schedule changed to a new day
if (date < entiry.date):
day.append({
'num_day': date.weekday(),
'classes': class_list
})
class_list = []
date = entiry.date # Adds new date for different day
class_list.append(entiry)
day.append({'num_day': date.weekday(), 'classes': class_list})
string = ""
for value in day:
string += drawer.drawTable(classes=value['classes'],
num_day=value['num_day'])
self.daysSchedual.append(string)
model = Xception(weights='imagenet')
input_size = (299, 299)
def decode(model, img_tensor):
preds = model.predict(img_tensor)
preds = decode_predictions(preds, top=1)[0][0]
preds = [preds[1], preds[2]]
return preds
preprocess_input = preprocess_input
# Init drawer and xai_tool
drawer = Drawer()
xai_tool = XAITool(model, input_size, decode, preprocess_input)
cap = cv2.VideoCapture(0)
while (True):
ret_run, frame = cap.read()
xai_dict = xai_tool.vidCapRun(frame, -1)
if ('predictions' in xai_dict):
drawer.singleThread(frame, xai_dict['heatmap'],
xai_dict['activations'], xai_tool.layers[-1], -1,
xai_dict['predictions'])
else:
drawer.singleThread(frame, xai_dict['heatmap'],
xai_dict['activations'], xai_tool.layers[-1], -1)
# TEMP
# cap = cv2.VideoCapture(0)
# ret_run, frame = cap.read()
from conmech.problem_solver import Static as StaticProblemSolver
from conmech.problems import Static
from examples.p_slope_contact_law import PSlopeContactLaw
from utils.drawer import Drawer
p_slope = 1.
@dataclass()
class StaticSetup(Static):
grid_height:...= 1
cells_number:...= (2, 5)
inner_forces:...= np.array([-0.2, -0.2])
outer_forces:...= np.array([0, 0])
mu_coef:...= 4
lambda_coef:...= 4
contact_law:...= PSlopeContactLaw
@staticmethod
def friction_bound(u_nu):
return 0
if __name__ == '__main__':
setup = StaticSetup()
runner = StaticProblemSolver(setup, 'direct')
state = runner.solve(verbose=True)
Drawer(state).draw()
from detector import Detector
from AIC2018_iamai.ReID.ReID_CNN.Model_Wrapper_reid import ResNet_Loader
import torch
import torch.nn as nn
from torch.autograd import Variable
from torchvision import transforms
from PIL import Image
import numpy as np
from utils.drawer import Drawer
import time
image_ext = ['jpg', 'jpeg', 'png', 'webp']
video_ext = ['mp4', 'mov', 'avi', 'mkv']
time_stats = ['tot', 'load', 'pre', 'net', 'dec', 'post', 'merge', 'display']
drawer = Drawer()
cos = nn.CosineSimilarity(dim=1, eps=1e-6)
def euclidean_distance(qf, gf):
gf = gf.transpose(0, 1)
m = qf.shape[0]
n = gf.shape[0]
dist_mat = torch.pow(qf, 2).sum(dim=1, keepdim=True).expand(m, n) + \
torch.pow(gf, 2).sum(dim=1, keepdim=True).expand(n, m).t()
dist_mat.addmm_(1, -2, qf, gf.t())
return dist_mat.cpu().numpy()
def cosine_similarity(qf, gf):
gf = gf.transpose(0, 1)
from utils.drawer import Drawer
from utils.xai_tool import XAITool
from time import time
# For multi-threading
from threading import Thread, Lock
# Setting up the input for the tool
# model is a keras model
# input_size is a tuple of (x, y) which contains the dims of the input image of the CNN
# decode_predictions is the function keras uses to decode the prediction
# preprocess_input is the function keras uses to process the images before passing them into the model. NOTE: this is an optional arg
# Initialising relevant classes and shared vars
drawer = Drawer()
cap = cv2.VideoCapture(0)
shared_dict = {
'frame': None,
'heatmap': None,
'activations': None,
'predictions': None,
'select_layers_list': None,
}
data_lock = Lock()
def xaiProcessing():
# Need to import the keras mdoel in the thread itself
from keras.applications.xception import Xception, decode_predictions, preprocess_input
model = Xception(weights='imagenet')
def __init__(self):
self._drawer = Drawer()
super().__init__()
self.setMinimumSize(600, 480)
self.resize(600, 480)
system_configs.update_config(
configs["system"]
) # Update config.py based on retrieved 'system' parameters
db_configs.update_config(
configs["db"]) # Update db/base.py based on retrieved 'db' parameters
print("system config...")
pprint.pprint(system_configs.full) # Show 'system' parameters in terminal
print("db config...")
pprint.pprint(db_configs.full) # Show 'db' parameters in terminal
print("loading parameters at iteration: {}".format(
args.testiter)) # Show args.testiter in terminal
print("building neural network...")
nnet = NetworkFactory() # Initialise CenterNet's neural network
print("loading parameters...")
nnet.load_params(args.testiter) # To locate CenterNet's pretrained model
drawer = Drawer() # Initialise Drawer to add bboxes in frames later
#nnet.cpu() # Uncomment if using cpu
nnet.cuda() # Comment if using cpu
nnet.eval_mode()
if args.file_dir[args.file_dir.rfind('.') + 1:].lower() in video_ext:
show_video(args.file_dir, nnet, drawer, args.score_min, args.save)
else:
show_image(args.file_dir, nnet, drawer, args.score_min, args.save)
def main():
# Configs
args = get_args()
cfg = Config(args.config)
pose_kwargs = cfg.POSE
clf_kwargs = cfg.CLASSIFIER
tracker_kwargs = cfg.TRACKER
# Initiate video/webcam
source = args.source if args.source else 0
video = Video(source)
## Initiate trtpose, deepsort and action classifier
pose_estimator = get_pose_estimator(**pose_kwargs)
if args.task != 'pose':
tracker = get_tracker(**tracker_kwargs)
if args.task == 'action':
action_classifier = get_classifier(**clf_kwargs)
## initiate drawer and text for visualization
drawer = Drawer(draw_numbers=args.draw_kp_numbers)
user_text = {
'text_color': 'green',
'add_blank': True,
'Mode': args.task,
# MaxDist: cfg.TRACKER.max_dist,
# MaxIoU: cfg.TRACKER.max_iou_distance,
}
# loop over the video frames
for bgr_frame in video:
rgb_frame = cv2.cvtColor(bgr_frame, cv2.COLOR_BGR2RGB)
# predict pose estimation
start_pose = time.time()
predictions = pose_estimator.predict(rgb_frame, get_bbox=True) # return predictions which include keypoints in trtpose order, bboxes (x,y,w,h)
# if no keypoints, update tracker's memory and it's age
if len(predictions) == 0 and args.task != 'pose':
debug_img = bgr_frame
tracker.increment_ages()
else:
# draw keypoints only if task is 'pose'
if args.task != 'pose':
# Tracking
# start_track = time.time()
predictions = utils.convert_to_openpose_skeletons(predictions)
predictions, debug_img = tracker.predict(rgb_frame, predictions,
debug=args.debug_track)
# end_track = time.time() - start_track
# Action Recognition
if len(predictions) > 0 and args.task == 'action':
predictions = action_classifier.classify(predictions)
end_pipeline = time.time() - start_pose
# add user's desired text on render image
user_text.update({
'Frame': video.frame_cnt,
'Speed': '{:.1f}ms'.format(end_pipeline*1000),
})
# draw predicted results on bgr_img with frame info
render_image = drawer.render_frame(bgr_frame, predictions, **user_text)
if video.frame_cnt == 1 and args.save_folder:
# initiate writer for saving rendered video.
output_suffix = get_suffix(args, cfg)
output_path = video.get_output_file_path(
args.save_folder, suffix=output_suffix)
writer = video.get_writer(render_image, output_path, fps=30)
if args.debug_track and args.task != 'pose':
debug_output_path = output_path[:-4] + '_debug.avi'
debug_writer = video.get_writer(debug_img, debug_output_path)
print(f'[INFO] Saving video to : {output_path}')
# show frames
try:
if args.debug_track and args.task != 'pose':
debug_writer.write(debug_img)
utils.show(debug_img, window='debug_tracking')
if args.save_folder:
writer.write(render_image)
utils.show(render_image, window='webcam' if isinstance(source, int) else osp.basename(source))
except StopIteration:
break
if args.debug_track and args.task != 'pose':
debug_writer.release()
if args.save_folder and len(predictions) > 0:
writer.release()
video.stop()
thresh=od_thresh,
weights=od_weights,
config=od_config,
classes_path=od_classes,
)
print("----------OD started----------")
# assuming 7fps & 70nn_budget, tracker looks into 10secs in the past.
tracker = Tracker(max_age=30,
nn_budget=70,
override_track_class=None,
clock=clock)
print("----------Tracker started----------")
GPUtil.showUtilization()
drawer = Drawer()
display = not args.nodisplay
ptz_exists = bool(int(env.get('PTZ_EXISTS', 0)))
ptz = None
if ptz_exists:
from utils.ptzer import PTZ
from utils.ui_controller import ui_controller
manual_override = {"p": 0, "t": 0, "z": 0, "override": False}
if display:
ui_thread = Thread(target=ui_controller, args=(manual_override, ))
ptz_host_url = env.get('PTZ_HOST_URL')
assert ptz_host_url
ptz = PTZ(ptz_host_url, flip=flip, manual_override=manual_override)
def start(self, fromStep, totalSteps, lr, modeltype, time):
result = open(
os.path.join(config.modeloutputFile, time + "training_result.csv"),
"w")
result.write(
"model_name, epochs, learning-rate, train_loss, test_acc\n")
result.close()
result = open(
os.path.join(config.modeloutputFile, time + "training_result.csv"),
"a+")
for i in range(fromStep, fromStep + totalSteps + 1):
result = open(
os.path.join(config.modeloutputFile,
time + "training_result.csv"), "a+")
for i in range(config.datanumber):
inputs, heatmaps = self.dataTrainProvider[i].drawn()
res = self.sess.run(
[self.trainLoss[i], self.updater[i], self.summaryMerge],
feed_dict={
self.inputImage: inputs,
self.heatmapGT: heatmaps,
self.learningRate: lr
})
self.fileWriter.add_summary(res[2], i)
print(str(i) + " -- TRAIN" + str(i) + " : " + str(res[0]))
a = str(res[0])
result.write("{},{},{},{}\n".format(modeltype, i, lr, a))
if i % Trainer.SAVE_EVERY == 0:
checkpoint_path = os.path.join(self.savePath, 'model')
self.saver.save(self.sess, checkpoint_path, global_step=i)
if i % Trainer.TEST_EVERY == 0:
inputs, heatmaps = self.dataValProvider[0].drawn()
res = self.sess.run(
[self.output, self.summaryMerge],
feed_dict={
self.inputImage: inputs,
self.heatmapGT: heatmaps,
self.learningRate: 0
})
fullscreen_bbox = BBox(0, 1, 0, 1)
distances = []
for batch_id in range(inputs.shape[0]):
pose_gt, _ = Pose2DInterface.our_approach_postprocessing(
heatmaps[batch_id, :, :, :], fullscreen_bbox,
self.inputSize)
pose_pred, _ = Pose2DInterface.our_approach_postprocessing(
res[0][batch_id, :, :, :], fullscreen_bbox,
self.inputSize)
# pose_pred
# all labeled gt joints are used in the loss,
# if not detected by the prediction joint location (-1,-1) => (0.5,0.5)
tmp = pose_pred.get_joints()
tmp[~pose_pred.get_active_joints(), :] = 0.5
pose_pred = Pose2D(tmp)
distances.append(pose_gt.distance_to(pose_pred))
summary = tf.Summary(value=[
tf.Summary.Value(tag="testset_accuracy",
simple_value=mean(distances))
])
self.fileWriter.add_summary(summary, i)
result.write("{},{},{},{},{}\n".format(modeltype, i, lr, a,
mean(distances)))
if i % Trainer.VIZ_EVERY == 0:
inputs, heatmaps = self.dataValProvider[0].drawn()
res = self.sess.run(
[self.output, self.summaryMerge],
feed_dict={
self.inputImage: inputs,
self.heatmapGT: heatmaps,
self.learningRate: 0
})
currHeatmaps = res[0][0, :, :, :]
currImage = self._imageFeatureToImage(inputs[0, :, :, :])
currHeatmapViz = self._heatmapVisualisation(currHeatmaps)
currHeatmapViz = currHeatmapViz.reshape(
(1, currHeatmapViz.shape[0], currHeatmapViz.shape[0], 1))
currPose = self._toPose(currHeatmaps)
skeletonViz = np.expand_dims(
Drawer.draw_2d_pose(currImage, currPose), 0)
tmp = tf.summary.image("skeleton_" + str(i),
skeletonViz).eval(session=self.sess)
self.fileWriter.add_summary(tmp, i)
tmp = tf.summary.image("heatmap_predicted_" + str(i),
currHeatmapViz).eval(session=self.sess)
self.fileWriter.add_summary(tmp, i)
result.close()
preds = decode_predictions(preds, top=1)[0][0]
preds = [preds[1], preds[2]]
return preds
return decode
# Custom preprocess input function if you have one
# def preprocess_input(img_tensor):
# img_tensor = img_tensor / 255
# return img_tensor
decode = createDecoder(target_labels)
# Init classes
drawer = Drawer()
cap = cv2.VideoCapture(0)
xai_tool = XVisTool(model,
input_size,
decoder_func=decode,
preprocess_img_func=preprocess_input)
# Showing the default
ori_img = xai_tool.setStillImg(img_path)
xai_dict = xai_tool.stillImgRun(-1)
layers = xai_tool.layers
drawer.singleThread(ori_img, xai_dict['heatmap'], xai_dict['activations'],
[layers[-1], -1], xai_dict['predictions'])
cv2.imshow('XVis Single', drawer.mask)
cv2.waitKey(100)
def test():
setup = Setup()
runner = SimulationRunner(setup)
solver = runner.run()
Drawer(solver).draw()
except:
print("")
parser.print_help()
sys.exit(0)
# load the object detection network
net = jetson.inference.detectNet(opt.network, sys.argv, opt.threshold)
# create video sources & outputs
input = jetson.utils.videoSource(opt.input_URI, argv=sys.argv)
output = jetson.utils.videoOutput(opt.output_URI, argv=sys.argv + is_headless)
# assuming 7fps & 70nn_budget, tracker looks into 10secs in the past.
nn_budget = 70
tracker = Tracker(max_age=30, nn_budget=nn_budget, override_track_class=None)
drawer = Drawer()
# process frames until the user exits
while True:
tic = time.time()
# capture the next image
img = input.Capture()
np_source = jetson.utils.cudaToNumpy(img)
np_source = cv2.cvtColor(np_source, cv2.COLOR_RGBA2BGR)
# detect objects in the image (with overlay)
#detections = net.Detect(img, overlay=opt.overlay)
detections = net.Detect(img, overlay='none')
chosen_track = None
# print the detections
print("detected {:d} objects in image".format(len(detections)))
raw_dets = []
vidInfo = stream.init_src()
# print(f'vid info: {vidInfo}')
if which_od == 'yolov4':
objDet = YOLOV4(score=0.5,
bgr=True,
model_image_size=(608, 608),
max_batch_size=4,
half=True)
elif which_od == 'yolov4_trt':
objDet = YOLOV4_TRT(
score=0.5,
bgr=True,
engine_path='pytorch_YOLOv4/trt_weights/yolov4_1_608_608.trt')
drawer = Drawer()
show_win_name = 'GRAB YOUR HUMAN'
cv2.namedWindow(show_win_name, cv2.WINDOW_NORMAL)
start_whole = time.time()
try:
for frame_count in itertools.count():
if stream.stopped:
break
frame = stream.read()
frame_draw = copy.deepcopy(frame)
dets = objDet.get_detections_dict([frame], classes=['person'])[0]
# print(dets)
drawer.draw_bbs(frame_draw, dets)
