def __init__(self, **kwargs):
super(Editor, self).__init__(**kwargs)
self.cam_show = True
self.detector = Detector()
self.img1 = Image(size_hint=(1.0, 0.8))
self.showData = ShowData()
def __init__(self):
self.detector = Detector()
self.model = TrainNetwork().load_trained_model()
self.cap = cv2.VideoCapture(0)
if not self.cap.isOpened():
print('Webcam is not open.')
exit()
def __init__(self):
super(PeopleObjectDetectionNode, self).__init__()
# init the node
rospy.init_node('people_object_detection', anonymous=False)
# Get the parameters
(model_name, num_of_classes, label_file, camera_namespace,
video_name) = self.get_parameters()
# Create Detector
self._detector = Detector(model_name, num_of_classes, label_file)
self._bridge = CvBridge()
# Advertise the result of Object Detector
self.pub_detections = rospy.Publisher(
'people_object_detection/detections', DetectionArray, queue_size=1)
# Advertise the result of Object Detector
self.pub_detections_image = rospy.Publisher(
'people_object_detection/detections_image', Image, queue_size=1)
self.read_from_video()
# spin
rospy.spin()
def main(video=0, dowsample=True):
print('QUAD Vision, Python:', version, ' OpenCV:', cv2.__version__)
vid = Video(video,
'ORB Detection testing',
delay=1,
fast=False,
skip=20,
downsample=downsample)
detector = Detector()
if ros_mode:
import rospy
from sensor_msgs.msg import Image
from cv_bridge import CvBridge, CvBridgeError
from quad.msg import Target_coordinates
pub_detection = rospy.Publisher('detection',
Target_coordinates,
queue_size=5)
pub_frame = rospy.Publisher('annotated_frame',
msg.image,
queue_size=15)
rospy.init_node('detection', anonymous=True)
rospy.init_node('annotated_frame', anonymous=True)
# Detection profiles
detector.load_profile(profiles.idea_orange)
# detector.load_profile(profiles.quadbox_black)
# detector.load_profile(profiles.quadbox_white)
# detector.load_profile(profiles.idea_red)
# detector.load_profile(profiles.sim_drone)
vid.skip(20)
t = Timer('Detection')
while vid.next():
frame = vid.img
t.start() # start timer
img, confidence, x, y = detector.detect(frame)
print('Detection:', confidence, x, y)
t.end()
vid.display(img)
if ros_mode:
detection = Target_coordinates()
detection.confidence = confidence
detection.x = x
detection.y = y
try:
pub_detection.publish(detection)
except CvBridgeError as e:
print(e)
# ros_img = CvBridge.cv2_to_imgmsg(img, encoding="passthrough")
# pub_frame.publish(ros_img)
vid.close()
t.output()
def analyze_mic_data():
from detection import Detector
detector = Detector()
def callback(pred):
# idx,conf = pred
if pred > 0.6:
print(pred, 'what up')
detector.start(callback)
def extract_regions_in_folder(img_names, img_folder, output_folder):
not_found_face = 0
detector = Detector()
for img_name in tqdm(img_names):
cropped_img = detector.get_eye_area_roi(os.path.join(img_folder, img_name))
if cropped_img is not False:
cv2.imwrite(str(output_folder/img_name), cropped_img, [int(cv2.IMWRITE_JPEG_QUALITY), 90])
else:
not_found_face += 1
print('The detector could not detect faces in {} images'.format(not_found_face))
return
def __init__(self):
cv2.setNumThreads(4)
self.weathercock_id = 17
roe = rospy.get_param(
"~roe", {
'min': {
"x": -4,
"y": -4,
"t": -3.14
},
'max': {
"x": 4,
"y": 4,
"t": 6.292
}
})
self.weathercock_stabilisation_time = rospy.get_param(
"~weathercock_stabilisation_time", 30)
self.roe_min = [roe["min"]["x"], roe["min"]["x"], roe["min"]["t"]]
self.roe_max = [roe["max"]["x"], roe["max"]["y"], roe["max"]["t"]]
self.d = Detector.Detector()
rospy.set_param('isWeathercockSouth', False)
self.is_set = False
# subscribed Topic
self.img_topic = "camera/image_raw/compressed"
self.remaining_time_topic = "/remaining_time"
self.pose_subscriber = rospy.Subscriber("odom",
Odometry,
callback=self.callback,
queue_size=1)
def __init__(self):
self.p = Plateau.Plateau((600, 400), 'resources/img', 200, 42,
np.array([[300, 250, 0]]))
self.f = PinholeFrame.PinholeFrame(
id_=1, parameters='resources/parameters_webcam_victor.txt')
self.d = Detector.Detector()
self.Rref, self.Tref = None, None
self.initialized = False
def main():
args = parse_args()
det = Detector(model_path = args.model_path, model=args.model_type, ctx=args.ctx)
if args.output_path:
out_file = args.output_path
else:
out_file = pjoin(cfg.data_folder, 'videos', f'{args.model_type}_{args.th}.mp4')
predict_frames(args.input_file, out_file, det, th=args.th)
class TLD_IVMIT:
def __init__(self, frame, window, init_frames_count = 20):
self.buffer = [cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)]
self.position = Position(self.buffer, *window)
self.learning_component = LearningComponent(self.position.calculate_patch())
self.detector = Detector(self.position, self.learning_component)
self.tracker = Tracker(self.position)
self.is_visible = True
self.integrator = Integrator(self.learning_component)
self.init_frames_count = init_frames_count
self.detected_windows = None
self.tracked_window = None
def start(self, frame):
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
if self.init_frames_count == 0:
start = time()
self.tracked_window = self.tracker.track(frame, self.position)
self.buffer[0] = frame
print "Tracking:", time()- start
start = time()
self.detected_windows = self.detector.detect(self.position, self.tracked_window is not None)
print "Detected windows count:", len(self.detected_windows)
print "Detection:", time()- start
start = time()
# filtered_detected_windows = [(window, patch, proba) for window, patch, proba in self.detected_windows if proba > 0.7]
single_window, self.is_visible = self.integrator.get_single_window(self.position, self.detected_windows, self.tracked_window)
print "Integration:", time()- start
if self.is_visible:
self.position.update(*single_window)
# start = time()
# self.learning_component.n_expert()
# self.learning_component.p_expert()
# print "Update training set:", time()- start
else:
self.tracked_window = self.tracker.track(frame, self.position)
self.buffer[0] = frame
if self.tracked_window is not None:
i = 0
while i < 5:
self.position.update(x=np.random.randint(0,self.buffer[0].shape[1]-self.position.width))
if self.position.is_correct() and windows_intersection(self.position.get_window(), self.tracked_window) == 0:
self.learning_component.update_negatives(self.position.calculate_patch())
i += 1
self.position.update(*self.tracked_window)
self.learning_component.update_positives(self.position.calculate_patch())
self.init_frames_count -= 1
else:
self.init_frames_count = 0
self.is_visible = False
return self.position
def __init__(self):
"""
Class to run HSR lego task
"""
self.robot = hsrb_interface.Robot()
self.rgbd_map = RGBD2Map()
self.omni_base = self.robot.get('omni_base')
self.whole_body = self.robot.get('whole_body')
self.side = 'BOTTOM'
self.cam = RGBD()
self.com = COM()
self.com.go_to_initial_state(self.whole_body)
self.grasp_count = 0
self.helper = Helper(cfg)
self.br = tf.TransformBroadcaster()
self.tl = TransformListener()
self.gp = GraspPlanner()
self.gripper = Crane_Gripper(self.gp, self.cam, self.com.Options,
self.robot.get('gripper'))
self.suction = Suction_Gripper(self.gp, self.cam, self.com.Options,
self.robot.get('suction'))
self.gm = GraspManipulator(self.gp, self.gripper, self.suction,
self.whole_body, self.omni_base, self.tl)
self.dl = DataLogger("stats_data/model_base", cfg.EVALUATE)
self.web = Web_Labeler(cfg.NUM_ROBOTS_ON_NETWORK)
model_path = 'main/output_inference_graph.pb'
label_map_path = 'main/object-detection.pbtxt'
self.det = Detector(model_path, label_map_path)
print "after thread"
def __init__(self, frame, window, init_frames_count = 20):
self.buffer = [cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)]
self.position = Position(self.buffer, *window)
self.learning_component = LearningComponent(self.position.calculate_patch())
self.detector = Detector(self.position, self.learning_component)
self.tracker = Tracker(self.position)
self.is_visible = True
self.integrator = Integrator(self.learning_component)
self.init_frames_count = init_frames_count
self.detected_windows = None
self.tracked_window = None
def main():
args = parse_args()
det = Detector(model_path=args.model_path, model=args.model_type, ctx=args.ctx)
if args.output_path:
out_file = args.output_path
else:
fn = os.path.basename(args.input_file)
fn = fn.split('.')[0]
out_file = f'{fn}_{args.model_type}_{args.th}.mp4'
predict_frames(args.input_file, out_file, det, th=args.th)
def test_load(self):
ava_datasets = Detector.list_datasets()
for dataset_name in ava_datasets:
models = Detector.list_models(dataset_name)
for model_name in models:
try:
classes = dcfg.classes
det = Detector(model=model_name,
dataset=dataset_name,
ctx='cpu',
classes=classes)
except:
classes = dcfg.classes_grasp
det = Detector(model=model_name,
dataset=dataset_name,
ctx='cpu',
classes=classes)
gdet = GDetector()
def add_extra_images(self):
"""
If --extra flag exists, adds images from extra-images dir to dataset
:return: tuple of list dataset images, dataset labels
"""
detector = Detector()
print('\nAdding extra images...')
for emotion_index, emotion in enumerate(EMOTIONS):
print('\nEmotion', emotion)
files = glob.glob('{}\\{}\\*'.format(EXTRA_DIR, emotion))
total = len(files)
for i, f in enumerate(files):
image = cv2.imread(f)
detected_faces = detector.detect_faces(image)
for face in detected_faces:
self.images.append(face)
self.emotions.append(
PrepareData._emotion_to_vec(emotion_index))
self.count.append(emotion_index)
print('Progress: {}/{} {:.2f}%'.format(i, total,
i * 100.0 / total))
def main():
"""Create a trained feature set.
1. Extract features from a cropped image set
2. Evaluate features on labelled training data
3. Remove features with high false positive rate
4. Evaluate features again on same data
"""
trainer = Trainer()
detector = Detector(750)
trainer.set_detector(detector)
# feat = load_features('data/gazebo1_932.dat')
# trainer.set_features(feat)
trainer.load_data('train/gazebo/pos_info_PreyEmptyWorld.dat')
trainer.load_data('train/gazebo/pos_info_PurplePrey1.dat')
trainer.load_data('train/gazebo/pos_info_PurplePrey2.dat')
trainer.load_data('train/gazebo/sim2.dat')
# trainer.load_data('train/quadbox/white_courtyard1.dat')
# trainer.load_data('train/quadbox/white_courtyard2.dat')
# trainer.load_data('train/quadbox/black_drone_court.dat')
# trainer.load_data('train/quadbox/pos_info.txt')
# trainer.load_data('train/idea2/pos_info_red-inclass.dat')
# trainer.load_data('train/idea2/red2m.dat')
# trainer.load_data('train/idea2/courtyard323.dat')
# trainer.load_data('train/idea2/orange10am.dat')
# trainer.load_data('train/idea2/orange7_30am.dat')
# trainer.load_data('train/pos_info_Courtyard_multi.dat')
# trainer.load_data('train/idea2/orange9am.dat')
# trainer.subsample_data(2)
trainer.train_and_test(.8)
trainer.evaluate(1)
trainer.feature_selection()
# trainer.evaluate(subsample=0.4)
# trainer.feature_selection()
# trainer.evaluate(subsample=0.7)
trainer.save_features('sim2')
return
trainer.train_and_test(show=False)
trainer.feature_selection()
trainer.evaluate(show=False)
trainer.save_features('ir_2')
return
def __init__(self):
path_calibration_camera = rospy.get_param(
"~calib_file", 'resources/parameters_fisheye_pi_simu.txt')
rospy.loginfo(
f"loading camera calibration from {path_calibration_camera}")
self.f = FisheyeFrame.FisheyeFrame(id_=0,
parameters=path_calibration_camera,
balance=0.5)
self.d = Detector.Detector()
self.r_origin, self.t_origin = [[0, 0, 0]], [[0, 0, 0]]
self.origin_id = 42
self.initialized = False
self.marker_sizes = {
0: 0.07,
1: 0.07,
2: 0.07,
3: 0.07,
4: 0.07,
5: 0.07,
6: 0.07,
7: 0.07,
8: 0.07,
9: 0.07,
10: 0.07,
42: 0.10
}
self.image_pub_undistort = rospy.Publisher(
"aruco_to_pose/debug/undistort/compressed",
CompressedImage,
queue_size=1)
self.robots_pose_pub = []
for i in range(0, 11):
self.robots_pose_pub.append(
rospy.Publisher(f"/pose_robots/{i}", PoseStamped,
queue_size=1))
# subscribed Topic
self.img_subscriber = rospy.Subscriber("camera/image_raw/compressed",
CompressedImage,
self.callback,
queue_size=1)
self.segmentation_text.set(
'\nSegmentation:\n{:20}\n'.format(classlabel))
log.basicConfig(format="[ %(levelname)s ] %(message)s",
level=log.INFO,
stream=sys.stdout)
#prepare classifier pathes @@@ todo create a main method and hand it over or extend the gui
#expects the model and a label file there:
clabelspath = './openvino/labels.txt'
cmodelpath = './openvino/model_leaf_01.xml'
#slabelspath='./openvino/voc.names'
smodelpath = './openvino/model_leaf_segmentation_02.xml'
#dlabelspath='./openvino/voc.names'
dmodelpath = './openvino/model_leaf_detection_01.xml'
#needed on intel desktop
#device='CPU'
#cpu_extension='/opt/intel/openvino/inference_engine/samples/build/intel64/Release/lib/libcpu_extension.so'
#needed on raspberry + nsc2
device = 'MYRIAD'
cpu_extension = ''
#init the classifier
imagepath = "./leaf_test.jpg"
classifier = Classifier(cmodelpath, device, cpu_extension, clabelspath)
segmentationDetector = Segmentation(smodelpath, device, cpu_extension)
boundingboxDetector = Detector(dmodelpath, device, cpu_extension)
gui = Gui(classifier, segmentationDetector, boundingboxDetector, imagepath)
class PeopleObjectDetectionNode(object):
"""docstring for PeopleObjectDetectionNode."""
def __init__(self):
super(PeopleObjectDetectionNode, self).__init__()
# init the node
rospy.init_node('people_object_detection', anonymous=False)
# Get the parameters
(model_name, num_of_classes, label_file, camera_namespace,
video_name) = self.get_parameters()
# Create Detector
self._detector = Detector(model_name, num_of_classes, label_file)
self._bridge = CvBridge()
# Advertise the result of Object Detector
self.pub_detections = rospy.Publisher(
'people_object_detection/detections', DetectionArray, queue_size=1)
# Advertise the result of Object Detector
self.pub_detections_image = rospy.Publisher(
'people_object_detection/detections_image', Image, queue_size=1)
self.read_from_video()
# spin
rospy.spin()
def read_from_video(self):
video_name = -1
cap = cv2.VideoCapture(video_name)
while (cap.isOpened()):
ret, frame = cap.read()
if frame is not None:
image_message = self._bridge.cv2_to_imgmsg(frame, "bgr8")
#self._sub = rospy.Subscriber('image', Image, self.rgb_callback, queue_size=1)
self.rgb_callback(image_message)
else:
break
cap.release()
cv2.destroyAllWindows()
print("Video has been processed!")
self.shutdown()
def get_parameters(self):
"""
Gets the necessary parameters from parameter server
Args:
Returns:
(tuple) (model name, num_of_classes, label_file)
"""
rospy.set_param("~model_name", 'ssd_mobilenet_v1_coco_11_06_2017')
rospy.set_param("~num_of_classes", '90')
rospy.set_param("~label_file", 'mscoco_label_map.pbtxt')
rospy.set_param("~camera_namespace", 'no')
rospy.set_param("~video_name", '-1')
#rospy.set_param("~num_workers",'-1')
model_name = rospy.get_param("~model_name")
num_of_classes = rospy.get_param("~num_of_classes")
label_file = rospy.get_param("~label_file")
camera_namespace = rospy.get_param("~camera_namespace")
video_name = rospy.get_param("~video_name")
#num_workers = rospy.get_param("~num_workers")
return (model_name, num_of_classes, label_file, \
camera_namespace,video_name)
def shutdown(self):
"""
Shuts down the node
"""
rospy.signal_shutdown("See ya!")
def rgb_callback(self, data):
"""
Callback for RGB images
"""
try:
# Convert image to numpy array
cv_image = self._bridge.imgmsg_to_cv2(data, "bgr8")
# Detect
(output_dict, category_index) = self._detector.detect(cv_image)
# Create the message
msg = utils.create_detection_msg(data, output_dict, category_index,
self._bridge)
# Draw bounding boxes
image_processed = self._detector.visualize(cv_image, output_dict)
# Convert numpy image into sensor img
msg_im = self._bridge.cv2_to_imgmsg(image_processed,
encoding="passthrough")
cv2.imshow("Image window", image_processed)
cv2.waitKey(3)
# Publish the messages
self.pub_detections.publish(msg)
self.pub_detections_image.publish(msg_im)
except CvBridgeError as e:
print(e)
def multi_target_tracking(seq, figure=None, gen_dect=False):
print('Sequence: %d' % (seq))
velo_dir = os.path.join(ROOT_DIR, 'velodyne', '%04d' % seq)
_, num_velo_files = load_list_from_folder(velo_dir)
str_frame = 0
num_frames = num_velo_files
save_file_dir = os.path.join(ROOT_DIR, 'results', '%04d' % seq)
save_img_dir = os.path.join(save_file_dir, 'img')
mkdir_if_missing(save_file_dir)
mkdir_if_missing(save_img_dir)
# initial classes
z_range = [5, -8]
dist_range = [50, 2]
roi_e = ROIExtractor(z_range[0], z_range[1], dist_range[0], dist_range[1])
gd_seg = GroundSeg()
ngc_detector = Detector()
tracker = MOTracker()
for frame in range(str_frame, str_frame + num_frames):
print('frame: %d' % (frame))
velo_file = os.path.join(velo_dir, '%06d.bin' % (frame))
save_path = os.path.join(save_img_dir, '%06d.png' % (frame))
dect_dir = os.path.join(save_file_dir, 'dect', '%06d' % (frame))
mkdir_if_missing(dect_dir)
gd_pc_file = os.path.join(dect_dir, 'gd_pc.npy')
clusters_list_file = os.path.join(dect_dir, 'clusters_list.npy')
ngd_other_file = os.path.join(dect_dir, 'ngd_other.npy')
dects_file = os.path.join(dect_dir, 'dects.npy')
flag = is_path_exists(gd_pc_file) & is_path_exists(
clusters_list_file) & is_path_exists(
ngd_other_file) & is_path_exists(dects_file)
# generate / get detections at current frame
if not flag or gen_dect:
pc = load_velo_scan(velo_file)
# region of interest extraction
pc = roi_e.roi_extract(pc)
# ground and non-ground segmentation
gd_pc, ngd_pc = gd_seg.segment(pc)
clusters_list, ngd_other = ngc_detector.clustering(ngd_pc,
filter=True)
dect_boxes_2d = ngc_detector.bounding_box_2d(
clusters_list, criterion='variance') # [(4x2)]
np.save(gd_pc_file, gd_pc)
np.save(clusters_list_file, clusters_list)
np.save(ngd_other_file, ngd_other)
np.save(dects_file, dect_boxes_2d)
else:
# load detection results
gd_pc = np.load(gd_pc_file)
clusters_list = np.load(clusters_list_file, allow_pickle=True)
clusters_list = list(clusters_list)
ngd_other = np.load(ngd_other_file)
dect_boxes_2d = np.load(dects_file)
# tracking
tracks = tracker.update(dect_boxes_2d)
if figure != None:
fig = mlab_show(figure,
gd_pc,
ngd_pc_=[clusters_list, ngd_other],
ngd_bb_2d=dect_boxes_2d,
tracks=tracks)
mlab.savefig(save_path, figure=fig)
from flask import Response
from flask import Flask
from flask import render_template
from threading import Thread, Lock
import datetime
import time
from queue import Queue
import cv2
from detection import Detector
app = Flask(__name__)
img_queue = Queue()
detector = Detector(img_queue)
@app.route('/')
@app.route('/index')
def index():
return render_template('index.html')
@app.route('/video_feed')
def video_feed():
return Response(pull_image(), mimetype="multipart/x-mixed-replace; boundary=frame")
def pull_image():
while True:
frame = img_queue.get()
if frame is None:
continue
# encode the frame in JPEG format
(flag, encodedImage) = cv2.imencode(".jpg", frame)
def __init__(self, Detector=Detector()):
self.Detector = Detector
class Editor(BoxLayout):
def __init__(self, **kwargs):
super(Editor, self).__init__(**kwargs)
self.cam_show = True
self.detector = Detector()
self.img1 = Image(size_hint=(1.0, 0.8))
self.showData = ShowData()
def start_cam(self, src=0):
self._cap = cv2.VideoCapture(src)
while not self._cap.isOpened():
pass
self.cam_show = True
print('cam started!')
self.count = 0
self.fps = 0
self.start_time = time.time()
def close_cam(self):
self.cam_show = False
self._cap.release()
def update(self, dt):
if self._cap.isOpened() is False:
return
_, img = self._cap.read()
# get pose
pose_img, send_pose = self.detector.detect(img)
self.showData.set_text(send_pose)
show_img = cv2.flip(pose_img, 0)
# set texture
texture1 = Texture.create(size=(show_img.shape[1], show_img.shape[0]),
colorfmt='bgr')
texture1.blit_buffer(show_img.tostring(),
colorfmt='bgr',
bufferfmt='ubyte')
# show the results
if self.cam_show:
self.img1.texture = texture1
else:
self.img1.texture = None
self.count += 1
if self.count == 10:
self.calc_fps()
def calc_fps(self):
self.fps = 10 / (time.time() - self.start_time)
self.count = 0
self.start_time = time.time()
# event handle
def connect_zmq(self, ip_id, port_id):
self.detector.disconnect_zmq()
ip = ip_id.text
port = int(port_id.text)
print('connect zmq')
self.detector.connect_zmq(ip, port)
def cam_load(self, src):
print('cam load', src.text)
self.close_cam()
if src.text.find('mp4') != -1 or src.text.find('m4a') != -1:
self.start_cam(src.text)
else:
self.start_cam(int(src.text))
def toggle_cam_show(self, cb):
print(cb.active)
self.cam_show = cb.active
def change_scale(self, k):
rk = round(k.value, 2)
self.detector.set_scale_factor(rk)
print('scale changed to', rk)
def change_pose_num(self, k):
ik = int(k.value)
self.detector.set_pose_num(ik)
print('pose num changed to', ik)
def change_min_pose_score(self, k):
rk = round(k.value, 2)
print('min pose score changed to', rk)
def change_min_part_score(self, k):
rk = round(k.value, 2)
print('min part score changed to', rk)
def real_data_generator(labels,
width,
height,
augmenter=None,
area_threshold=0.5,
):
labels = labels.copy()
for index in itertools.cycle(range(len(labels))):
image_filepath, lines = labels[index]
image = tools.read(image_filepath)
if augmenter is not None:
image, lines = tools.augment(boxes=lines,
boxes_format='lines',
image=image,
area_threshold=area_threshold,
augmenter=augmenter)
image, scale = tools.fit(image,
width=width,
height=height,
mode='letterbox',
return_scale=True)
lines = tools.adjust_boxes(boxes=lines, boxes_format='lines', scale=scale)
confidence_mask = np.zeros((image.shape[0], image.shape[1]), np.float32)
confidences = []
# character_bboxes = np.array([]).reshape(0, 4, 2)
# new_words = []
lines_label = []
detector = Detector()
if len(lines)==1:
lines = lines[0]
for i, line in enumerate(lines):
word_label = []
word_bbox, word = line[0], line[1]
word = word.replace(',', '')
word_bbox = np.float32(word_bbox)
if len(word_bbox) > 0:
for _ in range(len(word_bbox)):
if word == '###' or len(word.strip()) == 0:
cv2.fillPoly(confidence_mask, [np.int32(word_bbox)], (0))
pursedo_bboxes, bbox_region_scores, confidence = inference_character_box(detector,
image,
word,
word_bbox)
confidences.append(confidence)
cv2.fillPoly(confidence_mask, [np.int32(word_bbox)], (confidence))
for j in range(len(pursedo_bboxes)):
if j>len(word)-1:
continue
word_label.append((pursedo_bboxes[j], word[j]))
lines_label.append(word_label)
# new_words.append(word)
# character_bboxes = np.concatenate((character_bboxes, pursedo_bboxes), 0)
# character_bboxes.append(pursedo_bboxes)
yield image, lines_label, 1
init_frames_count = 100
max_train_count = 2*init_frames_count
max_test_count = max_train_count
start_time = time.time()
positive_samples = get_samples(folder, pos_list, samples_subfolder, max_train_count+max_test_count)
negative_samples = get_samples(folder, neg_list, "", 5*max_train_count+max_test_count)
positive_patches = [Position(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY), 0, 0, frame.shape[1], frame.shape[0]).calculate_patch() for frame in positive_samples]
negative_patches = [Position(cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY), 0, 0, frame.shape[1], frame.shape[0]).calculate_patch() for frame in negative_samples]
print "Positive samples:", len(positive_samples)
print "Negative samples:", len(negative_samples)
print "Generate training set:", time.time() - start_time
print
start_time = time.time()
learning_component = LearningComponent(positive_patches[0])
detector = Detector(learning_component)
for patch in positive_patches[1:max_train_count]:
learning_component.update_positives(patch)
for patch in negative_patches[:5*max_train_count]:
learning_component.update_negatives(patch)
print "Update training set:", time.time() - start_time
print
start_time = time.time()
detector.ensemble_classifier.relearn()
print "Learn detector:", time.time() - start_time
print
for param in xrange(10):
print "Param:", param/10.0
detector.threshold_patch_variance = 0.3
class PrepareData:
"""
Class for prepare dataset
"""
def __init__(self):
self.images = []
self.emotions = []
self.count = []
self.detector = Detector()
def create_dataset_from_csv(self):
"""
Create dataset from fer2013 dataset csv file
:return: tuple of list dataset images, dataset labels
"""
print('\nCreating dataset...')
data = pd.read_csv(CSV_FILE_NAME)
total = data.shape[0]
for i, row in data.iterrows():
image = PrepareData._data_to_image(row['pixels'])
emotion = PrepareData._emotion_to_vec(row['emotion'])
detected_faces = self.detector.detect_faces(image,
fer2013_image=True)
for face in detected_faces:
self.images.append(face)
self.emotions.append(emotion)
self.count.append(row['emotion'])
print('Progress: {}/{} {:.2f}%'.format(i, total,
i * 100.0 / total))
return self.images, self.emotions, self.count
def add_extra_images(self):
"""
If --extra flag exists, adds images from extra-images dir to dataset
:return: tuple of list dataset images, dataset labels
"""
detector = Detector()
print('\nAdding extra images...')
for emotion_index, emotion in enumerate(EMOTIONS):
print('\nEmotion', emotion)
files = glob.glob('{}\\{}\\*'.format(EXTRA_DIR, emotion))
total = len(files)
for i, f in enumerate(files):
image = cv2.imread(f)
detected_faces = detector.detect_faces(image)
for face in detected_faces:
self.images.append(face)
self.emotions.append(
PrepareData._emotion_to_vec(emotion_index))
self.count.append(emotion_index)
print('Progress: {}/{} {:.2f}%'.format(i, total,
i * 100.0 / total))
@staticmethod
def _data_to_image(data):
"""
Private method. Convert csv row of pixels to image
:param data: row of pixels from csv file
:return:
"""
data_image = [int(pixel) for pixel in data.split(' ')]
image = np.asarray(data_image).reshape(IMG_SIZE, IMG_SIZE)
image = cv2.resize(image.astype('uint8'), (IMG_SIZE, IMG_SIZE))
# image = image.astype('float32') / 255.
return image
@staticmethod
def _emotion_to_vec(x):
"""
Private method. Convert num of emotion to emotions labels array([0., 0., 0. ,1., 0., 0., 0.,])
:param x: num of emotion
:return: array
"""
d = np.zeros(len(EMOTIONS))
d[x] = 1.0
return d
import numpy as np
routes = web.RouteTableDef()
async def read_image(request):
reader = await request.multipart()
field = await reader.next()
data = await field.read(decode=False)
img = Image.open(BytesIO(data))
return img
detector = Detector('half_h416_w416.pt', (416, 416), 0.85, 0.3)
detector_bag = Detector('half_h416_w416_bag.pt', (416, 416), 0.85, 0.3)
feature = Feature('r92m91.pt')
attribute = Attribut('model.pth', .7)
@routes.post('/det')
async def det(request):
img = await read_image(request)
img = np.array(img)
ret = await detector(img)
return web.json_response(ret)
@routes.post('/det_bag')
async def det(request):
img = await read_image(request)
parser.add_argument('--batch_size',
type=int,
default=32,
help='number of workers')
parser.add_argument('--time', action='store_true')
args = parser.parse_args()
img_paths = glob(args.img_folder + "/*")
model = SimpleVGG(2)
if torch.cuda.is_available():
model.cuda()
model.load_state_dict(torch.load(args.model_weights))
model.eval()
detector_default = Detector()
detector_cnn = Detector(cnn=True)
if args.time:
all_time = 0.0
n = 0
from time import time
for img_path in img_paths:
cropped_img = detector_default.get_eye_area_roi(img_path)
if cropped_img is False:
cropped_img = detector_cnn.get_eye_area_roi(img_path)
if cropped_img is not False:
if args.time:
begin = time()
predict = inference_on_single_image(cropped_img, model,
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
def drawLandmarks(image, landmarks, text=False):
for index, mark in enumerate(landmarks):
cv2.circle(image, tuple(mark), 3, color=(0, 255, 255))
if text:
cv2.putText(image,
str(index),
tuple(mark),
fontFace=cv2.FONT_HERSHEY_SIMPLEX,
fontScale=0.4,
color=(0, 0, 255))
if __name__ == '__main__':
from detection import Detector
detector = Detector()
image = cv2.imread("images/test/face.jpg")
faces = detector.dlibDetection(image)
for face in faces:
masks = getMasks(
image,
face,
(0, 67),
)
cv2.imshow("Masked", image)
cv2.waitKey(0)
class Recognizer:
"""
Class of recognizer. Recognize emotions on image using trained model
"""
def __init__(self):
self.detector = Detector()
self.model = TrainNetwork().load_trained_model()
self.cap = cv2.VideoCapture(0)
if not self.cap.isOpened():
print('Webcam is not open.')
exit()
def recognize(self, frame):
"""
Recognize emotions on frame for each face
:param frame: input frame from webcam
:return: tuple of list faces and predictions
"""
detected_faces = self.detector.detect_faces(frame)
predictions = []
for face in detected_faces:
face = face.reshape([-1, IMG_SIZE, IMG_SIZE, 1])
prediction = self.model.predict(face)
print(EMOTIONS[np.argmax(prediction[0])])
predictions.append(prediction[0])
return detected_faces, predictions
def run(self):
"""
Gets frames from webcam and push it to recognizer
Stops by CTRL+C
:return:
"""
predictions = []
times = []
try:
while self.cap.isOpened():
sleep(0.5)
_, frame = self.cap.read()
faces, preds = self.recognize(frame)
for f, p in zip(faces, preds):
predictions.append(p)
times.append(datetime.now().time())
Recognizer._save_recognized_image(frame, p, datetime.now())
except KeyboardInterrupt:
self.cap.release()
return times, predictions
@staticmethod
def _save_recognized_image(face, prediction, dt):
"""
Saves image from webcam with face(user data)
:param face: face image
:param prediction: emotion prediction
:param dt: datetime
:return:
"""
if not os.path.exists(os.path.join(os.getcwd(), USER_DATA_DIR)):
os.mkdir(USER_DATA_DIR)
emotion = EMOTIONS[np.argmax(prediction)]
def __init__(self):
self.images = []
self.emotions = []
self.count = []
self.detector = Detector()
def __init__(self, model_detection, model_finemapping, model_seq_rec):
Detector.__init__(self, model_detection, model_finemapping)
Recognizer.__init__(self, model_seq_rec)
# labels=train,
# augmenter=None,
# **generator_kwargs
# )
# validation_image_generator = datasets.get_detector_image_generator(
# labels=validation,
# **generator_kwargs
# )
# print(len(train))
# print(len(validation))
# print(next(training_image_generator))
"""
word to char
"""
detector = Detector()
augmenter = imgaug.augmenters.Sequential([
imgaug.augmenters.Affine(
scale=(1.0, 1.2),
rotate=(-5, 5)
),
imgaug.augmenters.GaussianBlur(sigma=(0, 0.5)),
imgaug.augmenters.Multiply((0.8, 1.2), per_channel=0.2)
])
dataset = prepare_dataset('../ICDAR2017/training_images/')
data_loader = get_detector_ws_image_generator(dataset,
width=640,
height=640,
augmenter=None,
