class GenericBuilder:
def __init__(self, job, log_dir, finished_queue, cv):
self.log_dir = log_dir
self.job = job
self.finished_queue = finished_queue
if self.job.type == 'image_classification':
self.network = ImageClassifier(self.job, self.log_dir,
self.finished_queue, cv)
elif self.job.type == 'object_detection':
self.network = ObjectDetector(self.job, log_dir,
self.finished_queue, cv)
elif self.job.type == 'structured_prediction':
# TODO: Structured data predictor should be built
pass
elif self.job.type == 'structured_classification':
# TODO: Structured classifier should be built
pass
elif self.job.type == 'custom':
# TODO: Custom built nn should be built
pass
else:
raise Exception()
def build(self):
self.network.build()
self.model = self.network.model
def __init__(self):
super(CameraReader, self).__init__()
# self.cam = cv2.VideoCapture(0)
self.cam = cv2.VideoCapture("/home/dek/my_video-1.mkv")
self.width = int(self.cam.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.objdet = ObjectDetector()
def __init__(self):
self.camera = cv2.VideoCapture(-1)
self.camera.set(3, 320)
self.camera.set(4, 240)
self.camera.set(5, 60)
self.tracker = LaneTracker(self)
self.detector = ObjectDetector(self)
self.mot = None
def startDetection(self):
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Information)
msgBox.setText("Do you confirm these coordiations?")
msgBox.setWindowTitle("Confirmation")
msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
returnValue = msgBox.exec()
if returnValue == QMessageBox.Ok:
detector = ObjectDetector(self.output)
detector.detect_motion()
def get_blur_experiment_results(video, blur):
cam = cv2.VideoCapture(args.movie)
width = int(cam.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
objdet = ObjectDetector(args.path_to_ckpt, args.path_to_labels,
args.num_classes)
detection_counts = [] # Just the raw number of detections
weighted_detection_counts = [] # Sum the scores
ret, frame = cam.read()
while ret == True:
img = frame # Aliased, but lets us turn off as necessary.
img = cv2.GaussianBlur(img, (blur, blur), 0) # Magic happens here
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
h, w, _ = img.shape
expand = np.expand_dims(img, axis=0)
result = objdet.detect(expand)
boxes = []
detection_counts.append(0)
weighted_detection_counts.append(0)
for i in range(result['num_detections']):
if result['detection_scores'][i] > 0.6:
class_ = result['detection_classes'][i]
box = result['detection_boxes'][i]
score = result['detection_scores'][i]
y1, x1 = int(box[0] * h), int(box[1] * w)
y2, x2 = int(box[2] * h), int(box[3] * w)
boxes.append((class_, score, x1, y1, x2, y2))
# Less efficient, but keeps it all in the same place.
weighted_detection_counts[-1] += score
detection_counts[-1] += 1
for box in boxes:
class_, score, x1, y1, x2, y2 = box
w1 = x2 - x1
h1 = y2 - y1
cv2.rectangle(img, (x1, y1), (x2, y2), (255, 0, 0), 2)
cv2.putText(img, "%s: %5.2f" % (layers[class_ - 1], score),
(x1, y1), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 0), 2)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
cv2.imshow('image', img)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
ret, frame = cam.read()
return np.array(detection_counts), np.array(weighted_detection_counts)
def __init__(self):
super(MainWindow, self).__init__()
self.scene = QtWidgets.QGraphicsScene(self)
self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QColor(131, 213, 247)))
self.scene.setSceneRect(0, 0, WIDTH, HEIGHT)
self.machine = QtSvg.QGraphicsSvgItem('../static/assets/burger_chute.svg')
self.scene.addItem(self.machine)
self.machine.setScale(2)
self.machine.setPos(1000,0)
self.setFixedSize(WIDTH,HEIGHT)
self.setScene(self.scene)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.cam = cv2.VideoCapture(0)
self.cam.set(cv2.CAP_PROP_FRAME_WIDTH, CAMERA_WIDTH)
self.cam.set(cv2.CAP_PROP_FRAME_HEIGHT, CAMERA_HEIGHT)
# # self.cam = cv2.VideoCapture(filename)
self.width = int(self.cam.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.cam_pixmap = None
self.aruco_dict = cv2.aruco.Dictionary_get(cv2.aruco.DICT_6X6_1000)
self.parameters = cv2.aruco.DetectorParameters_create()
rms, self.mtx, self.dist, rvecs, tvecs = pickle.load(open("calib.pkl","rb"))
self.objdet = ObjectDetector()
self.burger_pixmap = None
self.rectified_pixmap = None
font = QtGui.QFont('Arial', 75)
self.label_text = self.scene.addText("", font)
self.label_text.setDefaultTextColor(QtCore.Qt.red)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.camera)
self.timer.start(0)
self.counter = 0
self.burger_classifier = BurgerClassifier()
font = QtGui.QFont('Arial', 100)
self.explanation_text = self.scene.addText("test", font)
self.explanation_text.setHtml("Design your own burger!")
self.explanation_text.setPos(0, 100)
font = QtGui.QFont('Arial', 60)
self.detail_text = self.scene.addText("test", font)
self.detail_text.setHtml("Place burger layers on the white board<br>Then show the board to the camera<br>Can the computer recognize burgers?<br>Can you fool the computer with a bad burger?")
self.detail_text.setPos(0, 250)
class CameraReader(QtCore.QThread):
signal = QtCore.Signal(QtGui.QImage, object)
def __init__(self):
super(CameraReader, self).__init__()
self.cam = cv2.VideoCapture(0)
self.width = long(self.cam.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH))
self.height = long(self.cam.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT))
self.objdet = ObjectDetector()
def run(self):
while True:
ret, img = self.cam.read()
expand = np.expand_dims(img, axis=0)
result = self.objdet.detect(expand)
image = QtGui.QImage(img.data, self.width, self.height,
QtGui.QImage.Format_RGB888).rgbSwapped()
boxes = []
for i in range(result['num_detections']):
if result['detection_scores'][i] > 0.5:
class_ = result['detection_classes'][i]
box = result['detection_boxes'][i]
y1, x1 = box[0] * self.width, box[1] * self.height
y2, x2 = box[2] * self.width, box[3] * self.height
boxes.append((class_, x1, y1, x2, y2))
self.signal.emit(image, boxes)
class CameraReader(QtCore.QThread):
signal = QtCore.pyqtSignal(QtGui.QImage, object)
def __init__(self):
super(CameraReader, self).__init__()
# self.cam = cv2.VideoCapture(0)
self.cam = cv2.VideoCapture("/home/dek/my_video-1.mkv")
self.width = int(self.cam.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.objdet = ObjectDetector()
def run(self):
while True:
ret, img = self.cam.read()
expand = np.expand_dims(img, axis=0)
result, category_index = self.objdet.detect(expand)
image = QtGui.QImage(img.data, self.width, self.height,
QtGui.QImage.Format_RGB888).rgbSwapped()
w, h = self.width, self.height
boxes = []
for i in range(result['num_detections']):
if result['detection_scores'][i] > 0.4:
class_ = result['detection_classes'][i]
box = result['detection_boxes'][i]
score = result['detection_scores'][i]
y1, x1 = box[0] * h, box[1] * w
y2, x2 = box[2] * h, box[3] * w
boxes.append((category_index[class_]['name'], score, x1,
y1, x2, y2))
self.signal.emit(image, boxes)
class AutonomousCar(object):
def __init__(self):
self.camera = cv2.VideoCapture(-1)
self.camera.set(3, 320)
self.camera.set(4, 240)
self.camera.set(5, 60)
self.tracker = LaneTracker(self)
self.detector = ObjectDetector(self)
self.mot = None
def run(self):
"""nb_modules == number of modules to use, excluding the network module."""
with MODI_Connector(1) as m:
self.mot = m.motors[0]
i = 0
while self.camera.isOpened():
_, image_lane = self.camera.read()
h, w = image_lane.shape[:2]
m = cv2.getRotationMatrix2D((w / 2, h / 2), 180, 1)
image_lane = cv2.warpAffine(image_lane, m, (w, h))
image_objs = image_lane.copy()
i += 1
image_objs = self.process_object(image_objs)
show_image('Detected Objects', image_objs)
image_lane = self.process_lane(image_lane)
show_image('Lane Lines', image_lane)
if cv2.waitKey(1) & 0xFF == ord('q'):
mot.set_torque(0, 0)
self.camera.release()
cv2.destroyAllWindows()
break
def process_object(self, image):
image = self.detector.process_objects_on_road(image)
return image
def process_lane(self, image):
image = self.tracker.follow_lane(image)
return image
def turn_left(self):
self.mot.set_torque(30, 30)
def turn_right(self):
self.mot.set_torque(-30, -30)
def go_straight(self):
self.mot.set_torque(20, 20)
time.sleep(0.01)
def stop(self):
self.mot.set_torque(0, 0)
time.sleep(0.01)
def train_model(restore):
""" Distributed function"""
num_classes = max(len(DotaDataset.get_labels_dict()),
len(VedaiDataset.get_labels_dict()))
detector = ObjectDetector(num_classes, restore)
detector.train(DotaDataset, config.INIT_SCHEDULE)
detector.init_optimizer()
detector.train(VedaiDataset, config.TRAINED_SCHEDULE)
def __init__(self, framework, weights_file_name, model_file_name,
classes_file_name, input_width, input_height, mean_value,
scale_factor, bgr, threshold):
ObjectDetector.__init__(self, weights_file_name)
self.model_file_name = model_file_name
self.classes_file_name = classes_file_name
self.net = cv2.dnn.readNet(model_file_name, weights_file_name,
framework)
self.input_size = (input_width, input_height)
self.mean_value = mean_value
self.scale_factor = scale_factor
self.threshold = threshold
if bgr == 'bgr':
self.reorder_channels = False
elif bgr == 'rgb':
self.reorder_channels = True
else:
raise ValueError('Unsupported channel sequence')
def get_object_detector() -> ObjectDetector:
object_detector = ObjectDetector()
LOG.info('initializing camera parameters')
if config.CALIBRATE_FRAME and os.path.isfile(config.CALIBRATE_FRAME):
LOG.info('using existing frame for calibration %s',
config.CALIBRATE_FRAME)
frame = cv2.imread(config.CALIBRATE_FRAME)
else:
LOG.info('capturing frame from source')
frame = capture_from_vid(source=0, width=1920, height=1080)
object_detector.init_camera_parameters(frame, viz=False)
LOG.info('camera parameters (rvec: %s, tvec: %s)', object_detector.rvec,
object_detector.tvec)
return object_detector
def read_cam():
detector = ObjectDetector()
# OpenCV main loop
vid_center = VideoStream(src=0).start()
while True:
windowName = "car detection"
cv2.namedWindow(windowName, cv2.WINDOW_NORMAL)
cv2.resizeWindow(windowName, 416, 416)
cv2.moveWindow(windowName, 0, 0)
cv2.setWindowTitle(windowName, "car detection")
while True:
# -----------------------------------------------------
# Check to see if the user closed the window
if cv2.getWindowProperty(windowName, 0) < 0:
# This will fail if the user closed the window; get printed to the console
break
image = vid_center.read()
# -----------------------------------------------------
# run the network and detection
result = detector.detect_object(image, visualize=True)
displayBuf = np.array(result)
# show the stuff
# -----------------------------------------------------
cv2.imshow(windowName, displayBuf)
key = cv2.waitKey(10)
if key == 27: # ESC key
cv2.destroyAllWindows()
break
def detect_and_output():
result_file = base_folder + '/input_json.json'
model_path = 'VOC2012model_v1.hdf5'
recognizer = ObjectDetector(model_path)
results = []
for sub_folder in os.listdir(base_folder):
for filename in os.listdir(base_folder + '/' + sub_folder):
extension = os.path.splitext(filename)[1]
if extension != '.jpg':
continue
img = Image.open(base_folder + '/' + sub_folder + '/' + filename)
sizes = [img.size]
array = [img_to_array(img.resize((300, 300)))]
array = preprocess_input(np.array(array))
result = recognizer.recognize(
DetectionJob(array=array, sizes=sizes, paths=[base_folder]))
results.append({
"filename": sub_folder + '/' + filename,
"result": result
})
with open(result_file, 'w') as f:
f.write(json.dumps(results))
def main():
dataset = VedaiDataset(for_training=False)
loader = DataLoader(
dataset,
batch_size=1,
collate_fn=get_transform_collate_fn(for_training=False))
num_classes = len(VedaiDataset.get_labels_dict())
detector = ObjectDetector(num_classes, restore=True)
labels_dict = dataset.get_labels_dict()
all_ground_truths, all_detections = [], []
mAPs = []
for images, targets in loader:
ground_truths, detections = detector.get_ground_truths_and_detections(
images, targets, labels_dict)
mAP = get_mean_average_precision(ground_truths, detections)
mAPs.append(mAP)
all_ground_truths.extend(ground_truths)
all_detections.extend(detections)
mAP = get_mean_average_precision(all_ground_truths, all_detections)
logging.info("mAP for validation set: %.2f%%", mAP * 100.)
mAP = sum(mAPs) / len(mAPs)
logging.info("Individual mAP for validation set: %.2f%%", mAP * 100.)
def run_capture_loop(capture, object_detector: ObjectDetector, result_queue):
LOG.info('running capture loop...')
while True:
then = time.time()
ret, frame = capture.read()
timestamp = time.time() # frame timestamp
_, labels, positions, heights, widths = object_detector.estimate_pose(
frame, viz=False)
if LOG.isEnabledFor(logging.DEBUG):
LOG.info('object_detection took %.4f s', time.time() - then)
for i in range(len(labels)):
position = positions[i]
label = labels[i]
height = float(heights[i])
width = float(widths[i])
message = {
'Timestamp': timestamp,
'Type': label,
'Position': {
'X': float(position[0]),
'Y': float(position[1]),
'Z': float(position[2])
},
'Shape': [{
'X': width,
'Y': 0.0,
'Z': height
}]
}
LOG.debug('queueing message %s', message)
result_queue.put(message)
import numpy as np
from PIL import Image
from data_provider import IntegralImageDataProvider
from integral_image import get_integral_image, integral_window
from object_detector import ObjectDetector
from viola_jones_classifier import ViolaJonesCascadeClassifier
if __name__ == '__main__':
test_positive_dir = 'C:/Users/Admin/Desktop/AI/data/multi/face/'
test_negative_dir = 'C:/Users/Admin/Desktop/AI/data/multi/non-face/'
test_data_provider = IntegralImageDataProvider(test_positive_dir, test_negative_dir, 19, 19,
max_positive=0, max_negative=None)
save_file = 'C:/Users/Admin/Desktop/AI/my_classifier_3_6_12_24_48_96_192_multi'
test_file = 'C:/Users/Admin/Desktop/AI/2.jpg'
# c = ViolaJonesCascadeClassifier.train_new_classifier(test_data_provider, (3,6,12,24,48,96,192), save_file)
# c.save(save_file)
c = ViolaJonesCascadeClassifier.load(save_file)
# err = c.test(test_data_provider)
# print(err)
ObjectDetector(c).parallel_detect_objects(Image.open(test_file), 'RED')
class Widget(QtWidgets.QWidget):
def __init__(self):
super(Widget, self).__init__()
self.scene = QtWidgets.QGraphicsScene()
self.scene.setSceneRect(0, 0, WIDTH, HEIGHT)
self.scene.changed.connect(self.changed)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.classify)
self.timer.start(250)
self.view = QGraphicsView(self.scene)
self.view.setFixedSize(WIDTH, HEIGHT)
self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setMouseTracking(True)
# pixmap = QtGui.QPixmap("my_photo-1-crop.jpg")
# topbun_webcam = QGraphicsPixmapItem(pixmap)
# topbun_webcam.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# topbun_webcam.setScale(2)
# self.scene.addItem(topbun_webcam)
# lettuce = QGraphicsSvgItem("../../../assets/lettuce.svg")
# lettuce.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# lettuce.setScale(2)
# self.scene.addItem(lettuce)
self.image_widget = QtWidgets.QLabel(self)
self.image_widget.setFixedSize(WIDTH, HEIGHT)
self.icons = QtWidgets.QWidget(self)
self.icons.setFixedSize(128, 6 * 64)
self.iconsLayout = QtWidgets.QVBoxLayout()
self.icons.setLayout(self.iconsLayout)
self.topbun = QSvgWidget("../../../static/assets/topbun.svg")
self.lettuce = QSvgWidget("../../../static/assets/lettuce.svg")
self.tomato = QSvgWidget("../../../static/assets/tomato.svg")
self.cheese = QSvgWidget("../../../static/assets/cheese.svg")
self.patty = QSvgWidget("../../../static/assets/patty.svg")
self.bottombun = QSvgWidget("../../../static/assets/bottombun.svg")
self.banana = QSvgWidget("../../../static/assets/banana.svg")
self.book = QSvgWidget("../../../static/assets/book.svg")
self.shoe = QSvgWidget("../../../static/assets/shoe.svg")
self.iconsLayout.addWidget(self.topbun)
self.iconsLayout.addWidget(self.lettuce)
self.iconsLayout.addWidget(self.tomato)
self.iconsLayout.addWidget(self.cheese)
self.iconsLayout.addWidget(self.patty)
self.iconsLayout.addWidget(self.bottombun)
self.iconsLayout.addWidget(self.banana)
self.iconsLayout.addWidget(self.book)
self.iconsLayout.addWidget(self.shoe)
self.buttons = QtWidgets.QWidget(self)
self.buttonsLayout = QtWidgets.QHBoxLayout()
self.buttons.setLayout(self.buttonsLayout)
self.buttonA = QtWidgets.QPushButton("Classify")
self.buttonA.clicked.connect(self.buttonAClicked)
self.buttonsLayout.addWidget(self.buttonA)
self.layout = QtWidgets.QHBoxLayout(self)
self.layout.addWidget(self.icons)
# self.layout.addWidget(self.buttons)
self.layout.addWidget(self.view)
self.layout.addWidget(self.image_widget)
self.setLayout(self.layout)
self.objdet = ObjectDetector()
def topbun_clicked(self, *args):
print(args)
def buttonAClicked(self, *args):
self.classify()
def changed(self):
self.classify()
def classify(self):
image = QtGui.QImage(QtCore.QSize(WIDTH, HEIGHT),
QtGui.QImage.Format_RGB888)
image.fill(QtCore.Qt.white)
painter = QtGui.QPainter(image)
self.scene.render(painter)
painter.end()
bits = image.constBits().asstring(HEIGHT * WIDTH * 3)
img = np.fromstring(bits, dtype=np.uint8).reshape(HEIGHT, WIDTH, 3)
# image = canny(img)
expand = np.expand_dims(img, axis=0)
result = self.objdet.detect(expand)
boxes = []
for i in range(result['num_detections']):
if result['detection_scores'][i] > 0.4:
class_ = result['detection_classes'][i]
box = result['detection_boxes'][i]
score = result['detection_scores'][i]
y1, x1 = box[0] * HEIGHT, box[1] * WIDTH
y2, x2 = box[2] * HEIGHT, box[3] * WIDTH
boxes.append((class_, score, x1, y1, x2, y2))
pixmap = QtGui.QPixmap.fromImage(image)
p = QtGui.QPainter()
p.begin(pixmap)
for box in boxes:
p.setPen(QtCore.Qt.red)
class_, score, x1, y1, x2, y2 = box
w = x2 - x1
h = y2 - y1
p.drawRect(x1, y1, w, h)
p.drawText(x1, y1, "%s: %5.2f" % (labels[class_], score))
p.end()
self.image_widget.setPixmap(pixmap)
class MainWindow(QtWidgets.QGraphicsView):
def __init__(self):
super(MainWindow, self).__init__()
self.scene = QtWidgets.QGraphicsScene(self)
self.scene.setBackgroundBrush(QtGui.QBrush(QtGui.QColor(131, 213, 247)))
self.scene.setSceneRect(0, 0, WIDTH, HEIGHT)
self.machine = QtSvg.QGraphicsSvgItem('../static/assets/burger_chute.svg')
self.scene.addItem(self.machine)
self.machine.setScale(2)
self.machine.setPos(1000,0)
self.setFixedSize(WIDTH,HEIGHT)
self.setScene(self.scene)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.cam = cv2.VideoCapture(0)
self.cam.set(cv2.CAP_PROP_FRAME_WIDTH, CAMERA_WIDTH)
self.cam.set(cv2.CAP_PROP_FRAME_HEIGHT, CAMERA_HEIGHT)
# # self.cam = cv2.VideoCapture(filename)
self.width = int(self.cam.get(cv2.CAP_PROP_FRAME_WIDTH))
self.height = int(self.cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
self.cam_pixmap = None
self.aruco_dict = cv2.aruco.Dictionary_get(cv2.aruco.DICT_6X6_1000)
self.parameters = cv2.aruco.DetectorParameters_create()
rms, self.mtx, self.dist, rvecs, tvecs = pickle.load(open("calib.pkl","rb"))
self.objdet = ObjectDetector()
self.burger_pixmap = None
self.rectified_pixmap = None
font = QtGui.QFont('Arial', 75)
self.label_text = self.scene.addText("", font)
self.label_text.setDefaultTextColor(QtCore.Qt.red)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.camera)
self.timer.start(0)
self.counter = 0
self.burger_classifier = BurgerClassifier()
font = QtGui.QFont('Arial', 100)
self.explanation_text = self.scene.addText("test", font)
self.explanation_text.setHtml("Design your own burger!")
self.explanation_text.setPos(0, 100)
font = QtGui.QFont('Arial', 60)
self.detail_text = self.scene.addText("test", font)
self.detail_text.setHtml("Place burger layers on the white board<br>Then show the board to the camera<br>Can the computer recognize burgers?<br>Can you fool the computer with a bad burger?")
self.detail_text.setPos(0, 250)
def imageTo(self, image):
pixmap = QtGui.QPixmap.fromImage(image)
pixmap = pixmap.transformed(QtGui.QTransform().scale(-1, 1))
if self.cam_pixmap is None:
self.cam_pixmap = self.scene.addPixmap(pixmap)
self.cam_pixmap.setPos(QtCore.QPointF(50, 2160-720-50))
else:
self.cam_pixmap.setPixmap(pixmap)
def imageTo2Clear(self):
if self.rectified_pixmap is not None:
self.scene.removeItem(self.rectified_pixmap)
self.rectified_pixmap = None
self.label_text.setPlainText("")
if self.burger_pixmap is not None:
self.scene.removeItem(self.burger_pixmap)
self.burger_pixmap = None
self.label_text.setPlainText("")
def imageTo2(self, image2, boxes):
pixmap2 = QtGui.QPixmap.fromImage(image2)
boxes = self.analyzeBoxes(boxes)
if boxes is None:
return
p = QtGui.QPainter()
p.begin(pixmap2)
for box in boxes:
p.setPen(QtCore.Qt.red)
class_, score, x1, y1, x2, y2 = box
w = x2-x1
h = y2-y1
p.drawRect(QtCore.QRect(QtCore.QPoint(x1, y1), QtCore.QSize(w, h)))
p.drawText(x1, y1, "%s: %5.2f" % (labels[class_], score))
p.end()
pixmap2 = pixmap2.scaled(pixmap2.width()*2, pixmap2.height()*2)
if self.rectified_pixmap == None:
self.rectified_pixmap = self.scene.addPixmap(pixmap2)
self.rectified_pixmap.setPos(QtCore.QPointF(3840 - pixmap2.width(), 2160-pixmap2.height()))
else:
self.rectified_pixmap.setPixmap(pixmap2)
def analyzeBoxes(self, boxes):
all_intersections = []
for i in range(len(boxes)):
first = boxes[i]
first_rect = QtCore.QRectF(QtCore.QPointF(first[2], first[3]), QtCore.QPointF(first[4], first[5]))
intersections = []
for j in range(i+1, len(boxes)):
second = boxes[j]
second_rect = QtCore.QRectF(QtCore.QPointF(second[2], second[3]), QtCore.QPointF(second[4], second[5]))
if first_rect.intersects(second_rect):
intersections.append((first, second))
if intersections != []:
all_intersections.append(intersections)
nonoverlapping_boxes = set(boxes)
if len(all_intersections):
for intersections in all_intersections:
for intersection in intersections:
first, second = intersection
if first[1] > second[1]:
if second in nonoverlapping_boxes:
nonoverlapping_boxes.remove(second)
else:
if first in nonoverlapping_boxes:
nonoverlapping_boxes.remove(first)
boxes = nonoverlapping_boxes
ordered_boxes = sorted(nonoverlapping_boxes, key=lambda x: boxCenter(x)[1])
ordered_boxes_with_gaps = []
for i in range(len(ordered_boxes)):
box = ordered_boxes[i]
bc = boxCenter(box[2:])
ordered_boxes_with_gaps.append(box)
if i < len(ordered_boxes) - 1:
nextBox = ordered_boxes[i+1]
dy = nextBox[3] - box[5]
nbc = boxCenter(nextBox[2:])
height = 50
if dy > height:
pos = int(dy / height)
width = (((box[4] - box[2]) + (nextBox[4] - nextBox[2]))/2)/2
centerX = (box[4] + nextBox[2]) / 2
for j in range(1, pos):
currPosY = box[5] + ((height+5)*j)
newBox = (0, 1.0, centerX - width, currPosY - height/2, centerX + width, currPosY + height/2)
ordered_boxes_with_gaps.append(newBox)
if len(ordered_boxes_with_gaps) == 6:
break
if len(ordered_boxes_with_gaps) == 6:
break
classes_ = [box[0] for box in ordered_boxes_with_gaps]
while len(classes_) < 6:
classes_.insert(0, 0)
burger_renderer = BurgerRenderer(classes_, 720, 720, renderEmpty=True)
image = burger_renderer.image
image_128 = burger_renderer.image.scaled(128, 128).convertToFormat(QtGui.QImage.Format_RGB888)
bits = image_128.constBits().asstring(128*128*3)
img = np.fromstring(bits, dtype=np.uint8).reshape(128, 128, 3)
pixmap3 = QtGui.QPixmap.fromImage(image)
if self.burger_pixmap is None:
self.burger_pixmap = self.scene.addPixmap(pixmap3)
self.burger_pixmap.setPos(QtCore.QPointF(1370, 190))
else:
self.burger_pixmap.setPixmap(pixmap3)
if len(classes_) != 6:
print("Wrong size:", len(classes_))
return None
result = self.burger_classifier.classify(classes_)[0]
if result[1] > 0.5:
label = 'burger'
self.label_text.setPlainText("BURGER")
self.label_text.setPos(1500,1150)
self.label_text.setDefaultTextColor(QtCore.Qt.green)
else:
label = 'notburger'
self.label_text.setHtml("NOT<br>BURGER")
self.label_text.setPos(1500,1150)
self.label_text.setDefaultTextColor(QtCore.Qt.red)
# self.image3_text.setText("P(burger) = %5.2f P(notburger) = %5.2f (%s" % (result[1], result[0], label))
# label = label_burger(classes_)
return ordered_boxes_with_gaps
def camera(self):
ret, img = self.cam.read()
if ret == True:
h, w, _ = img.shape
newcameramtx, roi=cv2.getOptimalNewCameraMatrix(self.mtx, self.dist, (w,h), 1, (w,h))
dst = cv2.undistort(img, self.mtx, self.dist, None, newcameramtx)
# # crop the image
x, y, w2, h2 = roi
dst = dst[y:y+h2, x:x+w2]
img = np.ascontiguousarray(dst, dst.dtype)
h3, w3, _ = img.shape
img2 = img.copy()
corners, ids, rejectedImgPoints = cv2.aruco.detectMarkers(img2, self.aruco_dict, parameters=self.parameters)
cv2.aruco.drawDetectedMarkers(img2, corners, ids)
for corner in corners:
rvec, tvec, _ = cv2.aruco.estimatePoseSingleMarkers(corner, 0.195, newcameramtx, self.dist)
try:
cv2.aruco.drawAxis(img2, newcameramtx, self.dist, rvec, tvec, 0.1)
except cv2.error:
print( "bad matrix")
d = {}
boxes = []
image2 = QtGui.QImage(self.width, self.height, QtGui.QImage.Format_RGB888)
boxes = []
if ids is None:
image = QtGui.QImage(img2.data, w3, h3, w3*3, QtGui.QImage.Format_RGB888).rgbSwapped()
self.imageTo(image)
self.imageTo2Clear()
return
else:
short_ids = [id_[0] for id_ in ids]
for i, corner in enumerate(corners):
d[short_ids[i]] = corner
if len(d.keys()) != 4:
image = QtGui.QImage(img2.data, w3, h3, w3*3, QtGui.QImage.Format_RGB888).rgbSwapped()
self.imageTo(image)
self.imageTo2Clear()
return
ul = d[0][0][0]
ur = d[1][0][0]
lr = d[2][0][0]
ll = d[3][0][0]
pts = np.array([ul, ur, lr, ll], np.int32)
pts = pts.reshape((-1,1,2))
cv2.polylines(img,[pts],True,(255,0,255))
image = QtGui.QImage(img2.data, w3, h3, w3*3, QtGui.QImage.Format_RGB888).rgbSwapped()
self.imageTo(image)
orig_width = ur[0] - ul[0]
orig_height = ll[1] - ul[1]
# ratio = orig_width / float(orig_height)
destCorners = np.array([ [0, 0], [WARPED_WIDTH, 0], [WARPED_WIDTH, WARPED_HEIGHT], [0, WARPED_HEIGHT]], dtype=np.float32)
srcCorners = np.array([ul, ur, lr, ll], dtype=np.float32)
pt = cv2.getPerspectiveTransform(srcCorners, destCorners)
warped = cv2.warpPerspective(img, pt, (WARPED_WIDTH, WARPED_HEIGHT))
cv2.imwrite("rectified/%05d.png" % self.counter, warped)
expand = np.expand_dims(warped, axis=0)
result = self.objdet.detect(expand)
for i in range(result['num_detections']):
if result['detection_scores'][i] > 0.5:
class_ = result['detection_classes'][i]
box = result['detection_boxes'][i]
score = result['detection_scores'][i]
y1, x1 = box[0] * WARPED_HEIGHT, box[1] * WARPED_WIDTH
y2, x2 = box[2] * WARPED_HEIGHT, box[3] * WARPED_WIDTH
boxes.append((class_, score, x1, y1, x2, y2))
warped_image = QtGui.QImage(warped.data, WARPED_WIDTH, WARPED_HEIGHT, 3*WARPED_WIDTH, QtGui.QImage.Format_RGB888).rgbSwapped()
self.imageTo2(warped_image, boxes)
self.counter += 1
def __init__(self):
super(Widget, self).__init__()
self.scene = QtWidgets.QGraphicsScene()
self.scene.setSceneRect(0, 0, WIDTH, HEIGHT)
self.scene.changed.connect(self.changed)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.classify)
self.timer.start(250)
self.view = QGraphicsView(self.scene)
self.view.setFixedSize(WIDTH,HEIGHT)
self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setMouseTracking(True)
# pixmap = QtGui.QPixmap("my_photo-1-crop.jpg")
# topbun_webcam = QGraphicsPixmapItem(pixmap)
# topbun_webcam.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# topbun_webcam.setScale(2)
# self.scene.addItem(topbun_webcam)
# lettuce = QGraphicsSvgItem("../../../assets/lettuce.svg")
# lettuce.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# lettuce.setScale(2)
# self.scene.addItem(lettuce)
self.image_widget = QtWidgets.QLabel(self)
self.image_widget.setFixedSize(WIDTH,HEIGHT)
self.icons = QtWidgets.QWidget(self)
self.icons.setFixedSize(128, 6*64)
self.iconsLayout = QtWidgets.QVBoxLayout()
self.icons.setLayout(self.iconsLayout)
self.topbun = QSvgWidget("../../../static/assets/topbun.svg")
self.lettuce = QSvgWidget("../../../static/assets/lettuce.svg")
self.tomato = QSvgWidget("../../../static/assets/tomato.svg")
self.cheese = QSvgWidget("../../../static/assets/cheese.svg")
self.patty = QSvgWidget("../../../static/assets/patty.svg")
self.bottombun = QSvgWidget("../../../static/assets/bottombun.svg")
self.banana = QSvgWidget("../../../static/assets/banana.svg")
self.book = QSvgWidget("../../../static/assets/book.svg")
self.shoe = QSvgWidget("../../../static/assets/shoe.svg")
self.iconsLayout.addWidget(self.topbun)
self.iconsLayout.addWidget(self.lettuce)
self.iconsLayout.addWidget(self.tomato)
self.iconsLayout.addWidget(self.cheese)
self.iconsLayout.addWidget(self.patty)
self.iconsLayout.addWidget(self.bottombun)
self.iconsLayout.addWidget(self.banana)
self.iconsLayout.addWidget(self.book)
self.iconsLayout.addWidget(self.shoe)
self.buttons = QtWidgets.QWidget(self)
self.buttonsLayout = QtWidgets.QHBoxLayout()
self.buttons.setLayout(self.buttonsLayout)
self.buttonA = QtWidgets.QPushButton("Classify")
self.buttonA.clicked.connect(self.buttonAClicked)
self.buttonsLayout.addWidget(self.buttonA)
self.layout = QtWidgets.QHBoxLayout(self)
self.layout.addWidget(self.icons)
# self.layout.addWidget(self.buttons)
self.layout.addWidget(self.view)
self.layout.addWidget(self.image_widget)
self.setLayout(self.layout)
self.objdet = ObjectDetector()
def main():
''' input '''
# choose the input stream
#captureSource = 0 # webcam
#captureSource = 'video/video_116.mp4'
#captureSource = 'video/video_205.mp4'
captureSource = 'video/video_white.mp4'
cap = cv2.VideoCapture(captureSource)
''' some background subtractor with default params '''
# bgSubtractor = cv2.bgsegm.createBackgroundSubtractorMOG(history=200, nmixtures=5, backgroundRatio=0.7, noiseSigma=0)
# bgSubtractor = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=16, detectShadows=True)
# bgSubtractor = cv2.bgsegm.createBackgroundSubtractorGMG(initializationFrames=120, decisionThreshold=0.8)
# bgSubtractor = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400.0, detectShadows=True)
# bgSubtractor = CompositeBackgroundSubtractor(bgSubtractor1, bgSubtractor2, ...)
''' list of background subtractors '''
backgroundSubtractors = [
cv2.createBackgroundSubtractorMOG2(
history=200, varThreshold=25,
detectShadows=True), # good for video/video_116.mp4
cv2.createBackgroundSubtractorKNN(
history=500, dist2Threshold=500.0,
detectShadows=True), # good for video/video_205.mp4
CompositeBackgroundSubtractor(
cv2.bgsegm.createBackgroundSubtractorMOG(history=600,
nmixtures=3,
backgroundRatio=0.2,
noiseSigma=2.3),
cv2.createBackgroundSubtractorMOG2(
history=200, varThreshold=14,
detectShadows=True)) # good for video/video_white.mp4
]
''' pipeline steps applied after background subtraction '''
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
pipeline = ProcessPipeline()
pipeline \
.add(cv2.medianBlur, ksize=5) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(fillHoles) \
.add(cv2.erode, kernel=kernel) \
.add(cv2.erode, kernel=kernel)
''' detectors creation and beginning of video analysis '''
detectors = [
ObjectDetector(bgSub, pipeline) for bgSub in backgroundSubtractors
]
show = True
oneSkipOnly = False
while True:
''' handle input: esc to quit; space to pause/start; "n" to go one frame at a time '''
k = cv2.waitKey(30) & 0xff
if k == 27:
break
elif k == ord(' ') or oneSkipOnly:
show = not show
oneSkipOnly = False
elif k == ord('n'):
show = True
oneSkipOnly = True
if not show:
if oneSkipOnly:
show = False
continue
''' reading next frame '''
ret, frame = cap.read()
if not ret:
break
frame = imutils.resize(frame, width=512)
frame = cv2.flip(frame, 1)
''' detection '''
color = (255, 0, 0) # blue
outputFrames = [
draw_bboxes(frame, detector.detect(frame), color)
for detector in detectors
]
''' show frames '''
imgOutput = mergeImgs(
[[*detector.pipeline.intermediateOutputsBGR, outputFrame]
for detector, outputFrame in zip(detectors, outputFrames)])
imgOutput = cv2.resize(imgOutput, (1920, 1000))
cv2.imshow('frame', imgOutput)
cap.release()
cv2.destroyAllWindows()
def main():
"""
メイン関数
実行時の引数としてモデルファイルのパスを受け取る
"""
camera = None
client = None
try:
parser = argparse.ArgumentParser(
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--model',
help='File path of .tflite file.',
required=True)
parser.add_argument('--label',
help='File path of label file.',
required=True)
args = parser.parse_args()
# AWS IoT Coreを設定する
cfg = configparser.ConfigParser()
cfg.read('config.ini', encoding='utf-8')
port = cfg['DEFAULT'].getint('PORT')
cert = cfg['DEFAULT'].get('CERT')
rootCA = cfg['DEFAULT'].get('ROOT_CA')
key = cfg['DEFAULT'].get('KEY')
endpoint = cfg['DEFAULT'].get('ENDPOINT')
topic = cfg['DEFAULT'].get('TOPIC')
client = mqtt.Client(protocol=mqtt.MQTTv311)
client.tls_set(ca_certs=rootCA,
certfile=cert,
keyfile=key,
cert_reqs=ssl.CERT_REQUIRED,
tls_version=ssl.PROTOCOL_TLSv1_2,
ciphers=None)
client.connect(endpoint, port=port, keepalive=60)
client.loop_start()
# カメラを接続する
camera = cv2.VideoCapture(0)
camera.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
tpe = ThreadPoolExecutor()
detector = ObjectDetector(args.model, args.label)
annotations = None
number = 1 # 保存時の名前用
pre = time()
while True:
# 撮影する
_, image_array = camera.read()
# 物体検出を行う (スレッドを立てる)
now = time()
if now - pre > 2:
annotations = tpe.submit(detect, image_array, detector, number)
pre = now
number += 1
with open('/tmp/persons.json') as f:
load = json.load(f)
count = load['count']
message = {
'ID':
'SRC',
'people_num':
count,
'timestamp':
datetime.datetime.fromtimestamp(now).strftime(
'%Y-%m-%d %H:%M:%S')
}
client.publish(topic, json.dumps(message))
# プレビューを表示する
if annotations != None:
for annotation in annotations.result():
xmin, ymin, xmax, ymax = annotation[0]
cv2.rectangle(image_array, (xmin, ymin), (xmax, ymax),
(0, 0, 255))
cv2.putText(image_array,
f'{annotation[1]}: {annotation[2]}',
(xmin, ymin), cv2.FONT_HERSHEY_SIMPLEX, 1,
(0, 0, 0))
cv2.imshow('preview', image_array)
# ループ内にwaitKeyは必要
if cv2.waitKey(1) == ord('q'):
break
except Exception as e:
print(e)
finally:
cv2.destroyAllWindows()
if camera != None:
camera.release()
if client != None:
client.disconnect()
interesting_classes)
mjpg_frame = object_detector.draw_frame(frame, boxes, classes,
scores)
web_server.frame_available(mjpg_frame)
#new_frame_queue.put(frame.copy())
except Exception:
logging.exception("Unknown failure processing frame.")
# Clean up
video.release()
#pool.close()
#pool.join()
if __name__ == '__main__':
object_detector = ObjectDetector(PATH_TO_CKPT, PATH_TO_LABELS, USE_CORAL,
USE_TPU, 1296, 730, MIN_CONF_THRESHOLD)
web_server = WebServer(WEB_PORT)
#manager = Manager()
#new_frame_queue = manager.Queue()
motion_detector = MotionDetector(0, 1296, 0, 730, 1296, 730)
web_server.start()
while (True):
try:
start_video()
except Exception:
logging.exception("Failure processing video.")
time.sleep(120)
#pool = Pool(1)
def main():
''' input '''
# choose the input stream
#captureSource = "video/video_116.mp4"
#captureSource = "video/video_205.mp4"
captureSource = "video/video_white.mp4"
#captureSource = 0 # webcam
cap = cv2.VideoCapture(captureSource)
''' trackers typology '''
# choose the tracker
trackerName = "CSRT" # "MOSSE" | "KCF" | "CSRT"
tm = TrackerManager(trackerName, maxFailures=20)
''' parameters '''
# try to change these parameters
period = 1 # length of the period: only on the first frame of the period we detect objects (instead, we track them in every frame)
maintainDetected = True # True if in transition frames, in case of overlapping bboxes, we want to keep those of the detector (False if we want to keep those of the tracker)
frameWidth = 512
''' some background subtractor with default params '''
# bgSubtractor = cv2.bgsegm.createBackgroundSubtractorMOG(history=200, nmixtures=5, backgroundRatio=0.7, noiseSigma=0)
# bgSubtractor = cv2.createBackgroundSubtractorMOG2(history=500, varThreshold=16, detectShadows=True)
# bgSubtractor = cv2.bgsegm.createBackgroundSubtractorGMG(initializationFrames=120, decisionThreshold=0.8)
# bgSubtractor = cv2.createBackgroundSubtractorKNN(history=500, dist2Threshold=400.0, detectShadows=True)
# bgSubtractor = CompositeBackgroundSubtractor(bgSubtractor1, bgSubtractor2, ...)
''' background subtractor '''
# define a background subtractor to be used for object detection
#bgSubtractor = cv2.createBackgroundSubtractorMOG2(history=200, varThreshold=25, detectShadows=True) # good for video/video_116.mp4
bgSubtractor = cv2.createBackgroundSubtractorKNN(
history=500, dist2Threshold=500.0,
detectShadows=True) # good for video/video_205.mp4
# bgSubtractor = CompositeBackgroundSubtractor(
# cv2.bgsegm.createBackgroundSubtractorMOG(history=600, nmixtures=3, backgroundRatio=0.2, noiseSigma=2.3),
# cv2.createBackgroundSubtractorMOG2(history=200, varThreshold=14, detectShadows=True)) # good for video/video_white.mp4
''' pipeline '''
# define the pipeline of functions to be executed on the b/w image, after the background subtraction and before getting bounding rects of contours
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (7, 7))
pipeline = ProcessPipeline()
pipeline \
.add(cv2.medianBlur, ksize=5) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(cv2.dilate, kernel=kernel) \
.add(fillHoles) \
.add(cv2.erode, kernel=kernel) \
.add(cv2.erode, kernel=kernel) \
''' create object detector and face detector '''
od = ObjectDetector(bgSubtractor, pipeline)
fd = FaceDetector()
''' auto-definition of output folder '''
outputDir = "output"
if captureSource == 0:
outputDir = os.path.join(outputDir, "webcam")
else:
outputDir = os.path.join(outputDir,
captureSource[:captureSource.find(".")])
outputDir = os.path.join(outputDir, trackerName)
print("Tracking video '%s' with tracker %s" % (captureSource, trackerName))
''' cycle begins '''
frameNumber = 0
frames = 0
seconds = 0
eta = 0.05
totalTime = 0
show = True
oneSkipOnly = False
while True:
''' handle input: esc to quit; space to pause/start; "n" to go one frame at a time '''
k = cv2.waitKey(30) & 0xff
if k == 27:
break
elif k == ord(' ') or oneSkipOnly:
show = not show
oneSkipOnly = False
elif k == ord('n'):
show = True
oneSkipOnly = True
if not show:
if oneSkipOnly:
show = False
continue
start = timer()
''' reading next frame '''
ret, frameOrig = cap.read()
if not ret:
break
frameOrig = cv2.flip(frameOrig, 1)
frame = imutils.resize(frameOrig, width=frameWidth)
scale = frameOrig.shape[1] / frameWidth
detectedObjects = []
if frameNumber % period == 0:
''' detection by background subtraction '''
detectedObjects = od.detect(frame)
''' objects tracking, faces detection'''
''' tracking '''
success, objects = tm.update(frame,
detectedObjects,
maintainDetected=maintainDetected)
objIDs = tm.getIDs()
tm.removeDeadTrackers()
failed_objects = [obj for suc, obj in zip(success, objects) if not suc]
failed_objIDs = [
objID for suc, objID in zip(success, objIDs) if not suc
]
succ_objIDs = [objID for suc, objID in zip(success, objIDs) if suc]
objects = [obj for suc, obj in zip(success, objects) if suc]
''' detection of faces '''
faces_bboxes = fd.detectFaces(frameOrig, objects, objIDs, scale=scale)
''' images merging and show '''
frameOrig = draw_bboxes(frameOrig,
objects, (255, 0, 0),
succ_objIDs,
scale=scale)
frameOrig = draw_bboxes(frameOrig,
failed_objects, (0, 0, 255),
failed_objIDs,
scale=scale)
frameOrig = draw_bboxes(frameOrig, faces_bboxes, (0, 255, 0))
frameOrig = cv2.resize(frameOrig, (640, 640))
cv2.imshow('frame', frameOrig)
''' some stats '''
frameNumber += 1
end = timer()
frames = eta + (1 - eta) * frames
seconds = eta * (end - start) + (1 - eta) * seconds
print(
"\rFrame: %04d FPS: %03d Active trackers: %02d Failed trackers: %02d "
% (frameNumber, int(
frames // seconds), len(objects), len(failed_objects)),
end="")
totalTime += end - start
cap.release()
cv2.destroyAllWindows()
''' save on disk '''
fd.dump(outputDir)
avgFPS = str(round(frameNumber / totalTime, 2))
print("\rAverage FPS: " + avgFPS)
with open(os.path.join(outputDir, "info.txt"), "w") as file:
bgSubClsName = str(bgSubtractor.__class__)
bgSubClsName = bgSubClsName[bgSubClsName.index("'") +
1:bgSubClsName.rindex("'")]
file.write("tracker: " + trackerName + "\n")
file.write("background subtractor: " + bgSubClsName + "\n")
file.write("average FPS: " + avgFPS + "\n")
sp.set_transform(t)
car.apply_control(carla.VehicleControl(throttle=0, steer=0))
#Set controll parameters
K = np.array([.01, 0.15]).reshape((1, 2))
L = 3.5
#Wait for car to be ready
time.sleep(1)
#Import and create instances of modules
from lidar import Lidar
lidar = Lidar(world, car)
from object_detector import ObjectDetector
object_detector = ObjectDetector(lidar, 1)
from route_planner import RoutePlanner
route_planner = RoutePlanner([r[0] for r in route], .5)
lidar.start()
from controller import Controller
ctrl = Controller(K, L, world.debug)
previous_time = -1
while True:
tck = world.wait_for_tick(1)
t = car.get_transform()
v = car.get_velocity()
v = np.sqrt(v.x**2 + v.y**2 + v.z**2)
from threading import Thread
from video import VideoObject #, VideoWriter
#import requests
from PIL import Image
from io import BytesIO
import base64
import json, os
import glob
import numpy as np
import settings
import cv2
#from bbox_visualiser import draw_bboxes_on_image
#import concurrent.futures
from object_detector import ObjectDetector
_OBD = ObjectDetector()
def send_request_object(frame):
frame = np.asarray(frame)
#buff = BytesIO()
#Image.fromarray(frame).save(buff, format='png')
#files = {'image': buff.getvalue()}
#r=requests.post(settings.OBJECT_URL,files=files)
D = _OBD.inference(frame)
print("[OBJECT] Done")
return D
def get_req_handled(method, frame, cache_file):
def __init__(self):
super(Widget, self).__init__()
self.scene = QtWidgets.QGraphicsScene()
self.scene.setSceneRect(0, 0, WIDTH, HEIGHT)
self.scene.changed.connect(self.changed)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.classify)
self.timer.start(250)
self.view = QGraphicsView(self.scene)
self.view.setFixedSize(WIDTH, HEIGHT)
self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setMouseTracking(True)
# pixmap = QtGui.QPixmap("my_photo-1-crop.jpg")
# topbun_webcam = QGraphicsPixmapItem(pixmap)
# topbun_webcam.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# topbun_webcam.setScale(2)
# self.scene.addItem(topbun_webcam)
# lettuce = QGraphicsSvgItem("../../../assets/lettuce.svg")
# lettuce.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# lettuce.setScale(2)
# self.scene.addItem(lettuce)
self.image_widget = QtWidgets.QLabel(self)
self.image_widget.setFixedSize(WIDTH, HEIGHT)
self.icons = QtWidgets.QWidget(self)
self.icons.setFixedSize(128, 6 * 64)
self.iconsLayout = QtWidgets.QVBoxLayout()
self.icons.setLayout(self.iconsLayout)
self.topbun = QSvgWidget("../../../static/assets/topbun.svg")
self.lettuce = QSvgWidget("../../../static/assets/lettuce.svg")
self.tomato = QSvgWidget("../../../static/assets/tomato.svg")
self.cheese = QSvgWidget("../../../static/assets/cheese.svg")
self.patty = QSvgWidget("../../../static/assets/patty.svg")
self.bottombun = QSvgWidget("../../../static/assets/bottombun.svg")
self.banana = QSvgWidget("../../../static/assets/banana.svg")
self.book = QSvgWidget("../../../static/assets/book.svg")
self.shoe = QSvgWidget("../../../static/assets/shoe.svg")
self.iconsLayout.addWidget(self.topbun)
self.iconsLayout.addWidget(self.lettuce)
self.iconsLayout.addWidget(self.tomato)
self.iconsLayout.addWidget(self.cheese)
self.iconsLayout.addWidget(self.patty)
self.iconsLayout.addWidget(self.bottombun)
self.iconsLayout.addWidget(self.banana)
self.iconsLayout.addWidget(self.book)
self.iconsLayout.addWidget(self.shoe)
self.buttons = QtWidgets.QWidget(self)
self.buttonsLayout = QtWidgets.QHBoxLayout()
self.buttons.setLayout(self.buttonsLayout)
self.buttonA = QtWidgets.QPushButton("Classify")
self.buttonA.clicked.connect(self.buttonAClicked)
self.buttonsLayout.addWidget(self.buttonA)
self.layout = QtWidgets.QHBoxLayout(self)
self.layout.addWidget(self.icons)
# self.layout.addWidget(self.buttons)
self.layout.addWidget(self.view)
self.layout.addWidget(self.image_widget)
self.setLayout(self.layout)
self.objdet = ObjectDetector()
parser = argparse.ArgumentParser()
parser.add_argument("--movie", type=str, default="movie.mp4", help="Movie file to run prediction on")
parser.add_argument("--write_output", type=bool, default=False, help="Whether to write output")
parser.add_argument("--output_dir", type=str, default="movie", help="Directory to write output to")
args = parser.parse_args()
from layers import layers
if not os.path.exists(args.movie):
print("Movie file %s missing" % args.movie)
sys.exit(1)
cam = cv2.VideoCapture(args.movie)
width = int(cam.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
objdet = ObjectDetector()
counter = 0
ret, img = cam.read()
while ret == True:
img = cv2.rotate(img, cv2.ROTATE_90_CLOCKWISE)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
h, w, _ = img.shape
expand = np.expand_dims(img, axis=0)
result = objdet.detect(expand)
boxes = []
for i in range(result['num_detections']):
if result['detection_scores'][i] > 0.75:
class_ = result['detection_classes'][i]
help="Whether the model was optimized with TRT")
args = parser.parse_args()
if args.movie is not "" and not os.path.exists(args.movie):
print("Movie file %s missing" % args.movie)
sys.exit(1)
if args.movie is not "":
cam = cv2.VideoCapture(args.movie)
else:
cam = cv2.VideoCapture(0)
args.movie = "movie.mkv"
width = int(cam.get(cv2.CAP_PROP_FRAME_WIDTH))
height = int(cam.get(cv2.CAP_PROP_FRAME_HEIGHT))
objdet = TFObjectDetector(args.path_to_model, args.path_to_labels, args.trt)
model_name = os.path.splitext(os.path.basename(args.path_to_model))[0]
movie_name = os.path.splitext(os.path.basename(args.movie))[0]
if args.write_movie:
out_path = os.path.join(os.path.dirname(args.movie),
"_".join([movie_name, model_name, "boxes"]))
movie_path = "%s.mkv" % out_path
print("Writing movie to", movie_path)
writer = cv2.VideoWriter(movie_path, cv2.VideoWriter_fourcc(*"MJPG"),
int(cam.get(cv2.CAP_PROP_FPS)), (width, height))
# Quit if there was a problem
if not writer.isOpened():
print("Unable to open video!")
cv2.waitKey(0)
cv2.destroyAllWindows()
if __name__ == '__main__':
# load text line recongize model
config_file = sys.argv[1]
rpn_model_path = sys.argv[2]
rcnn_model_path = sys.argv[3]
classes = sys.argv[4].split(',')
net = sys.argv[5]
#classes = ['background', 'text', 'seal', 'photo']
detector = ObjectDetector(rpn_model_path,
rcnn_model_path,
config_file,
classes,
conf_thresh=0.01,
net=net)
while True:
path = raw_input("Image path (press 0 to exit):")
if path == '0':
break
if not os.path.isfile(path):
print("Image not exists!")
continue
img = cv2.imread(path)
# detect text regions
class Widget(QtWidgets.QWidget):
def __init__(self):
super(Widget, self).__init__()
self.scene = QtWidgets.QGraphicsScene()
self.scene.setSceneRect(0, 0, WIDTH, HEIGHT)
self.scene.changed.connect(self.changed)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.classify)
self.timer.start(250)
self.view = QGraphicsView(self.scene)
self.view.setFixedSize(WIDTH,HEIGHT)
self.view.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.view.setMouseTracking(True)
# pixmap = QtGui.QPixmap("my_photo-1-crop.jpg")
# topbun_webcam = QGraphicsPixmapItem(pixmap)
# topbun_webcam.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# topbun_webcam.setScale(2)
# self.scene.addItem(topbun_webcam)
# lettuce = QGraphicsSvgItem("../../../assets/lettuce.svg")
# lettuce.setFlags(QtWidgets.QGraphicsItem.ItemIsMovable)
# lettuce.setScale(2)
# self.scene.addItem(lettuce)
self.image_widget = QtWidgets.QLabel(self)
self.image_widget.setFixedSize(WIDTH,HEIGHT)
self.icons = QtWidgets.QWidget(self)
self.icons.setFixedSize(128, 6*64)
self.iconsLayout = QtWidgets.QVBoxLayout()
self.icons.setLayout(self.iconsLayout)
self.topbun = QSvgWidget("../../../static/assets/topbun.svg")
self.lettuce = QSvgWidget("../../../static/assets/lettuce.svg")
self.tomato = QSvgWidget("../../../static/assets/tomato.svg")
self.cheese = QSvgWidget("../../../static/assets/cheese.svg")
self.patty = QSvgWidget("../../../static/assets/patty.svg")
self.bottombun = QSvgWidget("../../../static/assets/bottombun.svg")
self.banana = QSvgWidget("../../../static/assets/banana.svg")
self.book = QSvgWidget("../../../static/assets/book.svg")
self.shoe = QSvgWidget("../../../static/assets/shoe.svg")
self.iconsLayout.addWidget(self.topbun)
self.iconsLayout.addWidget(self.lettuce)
self.iconsLayout.addWidget(self.tomato)
self.iconsLayout.addWidget(self.cheese)
self.iconsLayout.addWidget(self.patty)
self.iconsLayout.addWidget(self.bottombun)
self.iconsLayout.addWidget(self.banana)
self.iconsLayout.addWidget(self.book)
self.iconsLayout.addWidget(self.shoe)
self.buttons = QtWidgets.QWidget(self)
self.buttonsLayout = QtWidgets.QHBoxLayout()
self.buttons.setLayout(self.buttonsLayout)
self.buttonA = QtWidgets.QPushButton("Classify")
self.buttonA.clicked.connect(self.buttonAClicked)
self.buttonsLayout.addWidget(self.buttonA)
self.layout = QtWidgets.QHBoxLayout(self)
self.layout.addWidget(self.icons)
# self.layout.addWidget(self.buttons)
self.layout.addWidget(self.view)
self.layout.addWidget(self.image_widget)
self.setLayout(self.layout)
self.objdet = ObjectDetector()
def topbun_clicked(self, *args):
print(args)
def buttonAClicked(self, *args):
self.classify()
def changed(self):
self.classify()
def classify(self):
image = QtGui.QImage(QtCore.QSize(WIDTH, HEIGHT), QtGui.QImage.Format_RGB888)
image.fill(QtCore.Qt.white)
painter = QtGui.QPainter(image)
self.scene.render(painter)
painter.end()
bits = image.constBits().asstring(HEIGHT*WIDTH*3)
img = np.fromstring(bits, dtype=np.uint8).reshape(HEIGHT, WIDTH, 3)
# image = canny(img)
expand = np.expand_dims(img, axis=0)
result = self.objdet.detect(expand)
boxes = []
for i in range(result['num_detections']):
if result['detection_scores'][i] > 0.4:
class_ = result['detection_classes'][i]
box = result['detection_boxes'][i]
score = result['detection_scores'][i]
y1, x1 = box[0] * HEIGHT, box[1] * WIDTH
y2, x2 = box[2] * HEIGHT, box[3] * WIDTH
boxes.append((class_, score, x1, y1, x2, y2))
pixmap = QtGui.QPixmap.fromImage(image)
p = QtGui.QPainter()
p.begin(pixmap)
for box in boxes:
p.setPen(QtCore.Qt.red)
class_, score, x1, y1, x2, y2 = box
w = x2-x1
h = y2-y1
p.drawRect(x1, y1, w, h)
p.drawText(x1, y1, "%s: %5.2f" % (labels[class_], score))
p.end ()
self.image_widget.setPixmap(pixmap)
import pickle
from moviepy.editor import VideoFileClip
from object_detector import ObjectDetector
import config
if __name__ == '__main__':
print('Processing video frames')
with open('./trained_model/model.pkl', 'rb') as f:
svc = pickle.load(f)
with open('./trained_model/xscaler.pkl', 'rb') as f:
X_scaler = pickle.load(f)
detector = ObjectDetector(config.feature_config,
config.sliding_windows_config, svc, X_scaler)
video_output = 'output_images/project_video_output.mp4'
clip1 = VideoFileClip('project_video.mp4')
#clip1 = VideoFileClip('test_video.mp4')
clip1_output = clip1.fl_image(
detector.process) #NOTE: this function expects color images!!
clip1_output.write_videofile(video_output, audio=False)
print('Video processing completed')
from object_detector import ObjectDetector
detector = ObjectDetector()
image_path = "/home/mathieu/Bureau/All Vinelab projects/Standalone experiments/OpenImages_object_detection/test_images/" \
"shutterstock_159281780.jpg"
print(detector.get_labels(image_path))
