#!/usr/bin/env python
# -*- coding: utf-8 -*-
# detection.py
#
# Author: Yann KOETH
# Created: Mon Jul 14 13:51:02 2014 (+0200)
# Last-Updated: Thu Jul 24 13:50:06 2014 (+0200)
# By: Yann KOETH
# Update #: 2186
#
import sys
import os
import cv2
import time
import numpy as np
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtWidgets import (QApplication, QWidget, QFileDialog, QPushButton,
QHBoxLayout, QVBoxLayout, QScrollArea, QColorDialog,
QLabel, QLineEdit, QListWidget, QComboBox,
QSplitter, QGroupBox, QTextEdit, QAbstractItemView,
QFrame, QSizePolicy, QSlider)
from PyQt5.QtGui import QImage, QPixmap, QColor, QIcon, QPalette
from window_ui import WindowUI
import detector
from detector import Detector, ClassifierParameters
import common
from tree import Tree
class MediaThread(QtCore.QThread):
def __init__(self, mw):
super(MediaThread, self).__init__(mw)
self.mw = mw
self.stopped = False
self.capture = None
self.nextFrame = False
self.mutex = QtCore.QMutex()
self.mode = None
def stop(self):
"""Stop media thread.
"""
with QtCore.QMutexLocker(self.mutex):
self.stopped = True
def clean(self):
"""Clean media thread.
"""
self.wait()
del self.capture
self.capture = None
def setNextFrameMode(self, enable):
self.nextFrame = enable
def main(self, mode, path):
"""Main loop.
"""
if not self.capture or not self.capture.isOpened() or self.mode != mode:
self.capture = cv2.VideoCapture(path)
self.mode = mode
if not self.capture.isOpened():
print "Couldn't read media " + path
while self.capture.isOpened():
if self.stopped:
break
ret, frame = self.capture.read()
if frame is None:
#self.capture = cv2.VideoCapture(path)
#ret, frame = self.capture.read()
if frame is None:
break
if mode == self.mw.SOURCE_CAMERA:
cv2.flip(frame, 1, frame)
self.mw.displayImage(frame)
QApplication.processEvents()
if self.nextFrame:
self.setNextFrameMode(False)
break
def run(self):
"""Method Override.
"""
with QtCore.QMutexLocker(self.mutex):
self.stopped = False
mode = self.mw.getSourceMode()
path = self.mw.sourcePath.text() if mode == self.mw.SOURCE_FILE else 0
if mode == self.mw.SOURCE_FILE and not path:
print 'File path is empty'
else:
self.main(mode, path)
self.mw.togglePlayButton(play=False)
class Window(QWidget, WindowUI):
SOURCE_FILE = 'File'
SOURCE_CAMERA = 'Camera'
DISPLAY_INPUT = 'Input'
DISPLAY_PREPROCESSED = 'Pre-processed'
SHAPE_RECT = 'Rectangle'
SHAPE_ELLIPSE = 'Ellipse'
FILL_NONE = 'None'
FILL_OUTLINE = 'Outline'
FILL_COLOR = 'Color'
FILL_BLUR = 'Blur'
FILL_IMAGE = 'Image'
FILL_MASK = 'Mask'
BG_INPUT = 'Input'
BG_COLOR = 'Color'
BG_TRANSPARENT = 'Transparent'
BG_IMAGE = 'Image'
__sourceModes = [SOURCE_FILE, SOURCE_CAMERA]
__displayModes = [DISPLAY_INPUT, DISPLAY_PREPROCESSED]
__shapeModes = [SHAPE_RECT, SHAPE_ELLIPSE]
__fillModes = [FILL_NONE, FILL_OUTLINE, FILL_BLUR, FILL_IMAGE, FILL_MASK, FILL_COLOR]
__bgModes = [BG_INPUT, BG_COLOR, BG_TRANSPARENT, BG_IMAGE]
IMAGE_FILTERS = '*.jpg *.png *.jpeg *.bmp'
VIDEO_FILTERS = '*.avi *.mp4 *.mov'
MASK_PATH = 'other/mask.png'
debugSignal = QtCore.pyqtSignal(object, int)
def __init__(self, parent=None):
super(Window, self).__init__(parent)
self.detector = Detector()
self.mediaThread = MediaThread(self)
sys.stdout = common.EmittingStream(textWritten=self.normalOutputWritten)
self.debugSignal.connect(self.debugTable)
self.currentFrame = None
self.bgColor = QColor(255, 255, 255)
self.bgPath = ''
self.classifiersParameters = {}
self.setupUI()
self.populateUI()
self.connectUI()
self.initUI()
def __del__(self):
sys.stdout = sys.__stdout__
def keyPressEvent(self, e):
if e.key() == QtCore.Qt.Key_Escape:
self.close()
def populateUI(self):
self.availableObjectsList.addItems(Detector.getDefaultAvailableObjects())
for sourceMode in self.__sourceModes:
self.sourceCBox.addItem(sourceMode)
for displayMode in self.__displayModes:
self.displayCBox.addItem(displayMode)
for shapeMode in self.__shapeModes:
self.shapeCBox.addItem(shapeMode)
for fillMode in self.__fillModes:
self.fillCBox.addItem(fillMode)
for bgMode in self.__bgModes:
self.bgCBox.addItem(bgMode)
model = QtGui.QStandardItemModel(self)
func = lambda node, parent: self.populateTree(node, parent)
Detector.getDefaultObjectsTree().map(model, func)
self.objectsTree.setModel(model)
def connectUI(self):
self.hsplitter.splitterMoved.connect(self.splitterMoved)
self.vsplitter.splitterMoved.connect(self.splitterMoved)
self.showDetails.clicked[bool].connect(self.toggleDebugInfo)
self.addButton.clicked.connect(self.addObject)
self.removeButton.clicked.connect(self.removeObject)
self.sourceCBox.currentIndexChanged.connect(self.togglePath)
self.sourcePathButton.clicked.connect(self.loadMedia)
self.playButton.clicked.connect(self.play)
self.refreshButton.clicked.connect(self.refresh)
self.nextFrameButton.clicked.connect(self.nextFrame)
self.objectsTree.customSelectionChanged.connect(self.showClassifierParameters)
self.colorPicker.clicked.connect(self.colorDialog)
self.classifierName.textChanged.connect(self.updateClassifierParameters)
self.scaleFactor.valueChanged.connect(self.updateScaleFactor)
self.minNeighbors.valueChanged.connect(self.updateMinNeighbors)
self.minWidth.valueChanged.connect(self.updateMinWidth)
self.minHeight.valueChanged.connect(self.updateMinHeight)
self.shapeCBox.currentIndexChanged.connect(self.updateShape)
self.fillCBox.currentIndexChanged.connect(self.updateFill)
self.autoNeighbors.clicked.connect(self.calcNeighbors)
self.stabilize.stateChanged.connect(self.updateStabilize)
self.tracking.stateChanged.connect(self.updateTracking)
self.showName.stateChanged.connect(self.updateShowName)
self.fillPath.clicked.connect(self.loadFillPath)
self.bgColorPicker.clicked.connect(self.bgColorDialog)
self.bgPathButton.clicked.connect(self.bgPathDialog)
self.bgCBox.currentIndexChanged.connect(self.toggleBgParams)
def initUI(self):
self.showClassifierParameters(None, None)
self.equalizeHist.setChecked(True)
self.toggleFillPath()
self.toggleBgParams(self.bgCBox.currentIndex())
common.setPickerColor(self.bgColor, self.bgColorPicker)
self.togglePlayButton(False)
########################################################
# Utils
def getIcon(self, color):
"""Returns a colored icon.
"""
pixmap = QPixmap(14, 14)
pixmap.fill(color)
return QIcon(pixmap)
def populateTree(self, node, parent):
"""Create a QTreeView node under 'parent'.
"""
item = QtGui.QStandardItem(node)
h, s, v = Detector.getDefaultHSVColor(node)
color = QColor()
color.setHsvF(h, s, v)
item.setIcon(self.getIcon(color))
# Unique hash for QStandardItem
key = hash(item)
while key in self.classifiersParameters:
key += 1
item.setData(key)
cp = ClassifierParameters(item.data(), node, node, color,
self.SHAPE_RECT, self.FILL_OUTLINE)
self.classifiersParameters[key] = cp
parent.appendRow(item)
return item
def getMask(self, pixmap, x, y, w, h, shape, overlay,
bg=QtCore.Qt.transparent, fg=QtCore.Qt.black, progressive=False):
"""Create a shape mask with the same size of pixmap.
"""
mask = QPixmap(pixmap.width(), pixmap.height())
mask.fill(bg)
path = QtGui.QPainterPath()
if progressive:
progressive = QPixmap(pixmap.width(), pixmap.height())
progressive.fill(QtCore.Qt.transparent)
progressiveMask = QPixmap(self.MASK_PATH)
progressiveMask = progressiveMask.scaled(w, h, QtCore.Qt.IgnoreAspectRatio)
progressivePainter = QtGui.QPainter(progressive)
progressivePainter.drawPixmap(x, y, progressiveMask)
del progressivePainter
fg = QtGui.QBrush(progressive)
painter = QtGui.QPainter(mask)
if shape == self.SHAPE_ELLIPSE:
path.addEllipse(x, y, w, h)
painter.fillPath(path, fg)
elif shape == self.SHAPE_RECT:
painter.fillRect(x, y, w, h, fg)
painter.setCompositionMode(QtGui.QPainter.CompositionMode_SourceAtop)
if overlay:
painter.drawPixmap(0, 0, overlay)
return mask
def drawTracking(self, painter, tracking, scale):
"""Draw lines between each position in tracking list.
"""
if not tracking:
return
hashTable = {}
# Group tracks by item hash
for track in tracking:
for rect, hash in track:
x, y, w, h = common.scaleRect(rect, scale)
x, y = x + w / 2, y + h / 2
if hash in hashTable:
hashTable[hash].append((x, y))
else:
hashTable[hash] = [(x, y)]
# Draw
for hash, points in hashTable.iteritems():
prev = None
for point in points:
if prev:
x1, y1 = point
x2, y2 = prev
painter.drawLine(x1, y1, x2, y2)
prev = point
def drawBackground(self, pixmap):
"""Draw background in pixmap.
"""
w, h = pixmap.width(), pixmap.height()
mode = self.__bgModes[self.bgCBox.currentIndex()]
source = QPixmap(pixmap)
painter = QtGui.QPainter(pixmap)
if mode == self.BG_COLOR:
painter.fillRect(0, 0, w, h, self.bgColor)
if mode == self.BG_TRANSPARENT or mode == self.BG_IMAGE or mode == self.BG_INPUT:
painter.drawPixmap(0, 0, common.checkerboard(pixmap.size()))
if mode == self.BG_IMAGE and self.bgPath:
bgPixmap = QPixmap(self.bgPath)
if not bgPixmap.isNull():
bgPixmap = bgPixmap.scaled(w, h, QtCore.Qt.IgnoreAspectRatio)
painter.drawPixmap(0, 0, bgPixmap)
if mode == self.BG_INPUT:
painter.drawPixmap(0, 0, source)
def fillMask(self, pixmap, painter, roi, param, source):
"""Draw mask in roi.
"""
x, y, w, h = roi
masked = self.getMask(pixmap, x, y, w, h, param.shape,
source, progressive=True)
painter.drawPixmap(0, 0, masked)
def fillBlur(self, pixmap, painter, roi, param, source):
"""Draw blur in roi.
"""
x, y, w, h = roi
blurred = self.getMask(pixmap, x, y, w, h, param.shape,
common.blurPixmap(pixmap, 20))
painter.drawPixmap(0, 0, blurred)
def fillImage(self, pixmap, painter, roi, param, source):
"""Draw image in roi.
"""
x, y, w, h = roi
fillPixmap = QPixmap(param.fillPath)
if not fillPixmap.isNull():
fillPixmap = fillPixmap.scaled(w, h, QtCore.Qt.IgnoreAspectRatio)
mask = self.getMask(pixmap, x, y, w, h, param.shape, None,
QtCore.Qt.white, QtCore.Qt.black)
painter.setClipRegion(QtGui.QRegion(QtGui.QBitmap(mask)))
painter.drawPixmap(x, y, fillPixmap)
painter.setClipping(False)
def fillColor(self, pixmap, painter, roi, param, source):
"""Draw color in roi.
"""
x, y, w, h = roi
if param.shape == self.SHAPE_ELLIPSE:
path = QtGui.QPainterPath()
path.addEllipse(x, y, w, h)
painter.fillPath(path, param.color)
elif param.shape == self.SHAPE_RECT:
painter.fillRect(x, y, w, h, param.color)
def fillOutline(self, pixmap, painter, roi, param, source):
"""Draw outline in roi.
"""
x, y, w, h = roi
drawFunc = painter.drawRect
if param.shape == self.SHAPE_ELLIPSE:
drawFunc = painter.drawEllipse
drawFunc(x, y, w, h)
def drawRects(self, source, rectsTree, scale):
"""Draw rectangles in 'rectsTree' on 'source'.
"""
pixmap = QPixmap(source)
self.drawBackground(pixmap)
def drawRect(node, parentHash):
painter = QtGui.QPainter(pixmap)
roi, param, tracking = node.data
x, y, w, h = common.scaleRect(roi, scale)
painter.setPen(param.color)
funcTable = {
self.FILL_MASK: self.fillMask,
self.FILL_BLUR: self.fillBlur,
self.FILL_IMAGE: self.fillImage,
self.FILL_COLOR: self.fillColor,
self.FILL_OUTLINE: self.fillOutline
}
for fill, func in funcTable.iteritems():
if param.fill == fill:
func(pixmap, painter, (x, y, w, h), param, source)
if param.tracking:
self.drawTracking(painter, tracking, scale)
if param.showName:
painter.drawText(x, y, param.name)
return param.hash
h, w = pixmap.height(), pixmap.width()
rectsTree.map(None, drawRect)
painter = QtGui.QPainter(source)
painter.drawPixmap(0, 0, pixmap)
def debugTable(self, args, append=False):
"""Display debug info into table.
"""
rows = len(args)
if not append:
self.debugCursor = self.debugText.textCursor()
format = QtGui.QTextTableFormat()
constraints = [QtGui.QTextLength(QtGui.QTextLength.FixedLength,
size) for arg, size in args]
format.setColumnWidthConstraints(constraints)
format.setBorder(0)
format.setCellPadding(2)
format.setCellSpacing(0)
self.debugCursor.insertTable(1, rows, format)
scroll = self.debugText.verticalScrollBar()
for arg, size in args:
if arg:
self.debugCursor.insertText(arg)
self.debugCursor.movePosition(QtGui.QTextCursor.NextCell)
scroll.setSliderPosition(scroll.maximum())
def debugEmitter(self, args, append=False):
"""Debug signal to allow threaded debug infos.
"""
self.debugSignal.emit(args, append)
def detect(self, img, autoNeighbors=False, autoNeighborsParam=None):
"""Detect objects in img.
"""
self.currentFrame = img
item = None
indexes = self.objectsTree.selectedIndexes()
if autoNeighbors and indexes:
item = self.objectsTree.model().itemFromIndex(indexes[0])
# Detect on full size image
tree, extracted = common.getObjectsTree(self.objectsTree,
self.classifiersParameters,
indexes, item)
equalizeHist = self.equalizeHist.isChecked()
rectsTree = self.detector.detect(img, tree, equalizeHist,
self.debugEmitter, extracted, autoNeighborsParam)
return rectsTree
def displayImage(self, img):
"""Display numpy 'img' in 'mediaLabel'.
"""
rectsTree = self.detect(img)
displayMode = self.__displayModes[self.displayCBox.currentIndex()]
if displayMode == self.DISPLAY_PREPROCESSED:
img = self.detector.preprocessed
pixmap = common.np2Qt(img)
w = float(pixmap.width())
# Scale image
pixmap = common.fitImageToScreen(pixmap)
scaleFactor = pixmap.width() / w
# Draw scaled rectangles
self.drawRects(pixmap, rectsTree, scaleFactor)
self.mediaLabel.setPixmap(pixmap)
self.mediaLabel.setFixedSize(pixmap.size())
def displayMedia(self, path):
"""Load and display media.
"""
if self.mediaThread.isRunning():
self.mediaThread.stop()
self.mediaThread.wait()
sourceMode = self.__sourceModes[self.sourceCBox.currentIndex()]
self.mediaThread.start()
self.togglePlayButton(True)
def getSourceMode(self):
"""Return the current source mode.
"""
return self.__sourceModes[self.sourceCBox.currentIndex()]
def getCurrentClassifierParameters(self):
"""Return current classifier parameters.
"""
index = self.objectsTree.currentIndex()
item = index.model().itemFromIndex(index)
param = self.classifiersParameters[item.data()]
return item, param
def toggleFillPath(self):
"""Display fill path dialog button if needed.
"""
index = self.fillCBox.currentIndex()
fillMode = self.__fillModes[index]
if fillMode == self.FILL_IMAGE:
self.fillPath.show()
else:
self.fillPath.hide()
def togglePlayButton(self, play=True):
"""Switch between play and pause icons.
"""
if play is True:
self.playButton.setIcon(QIcon('assets/pause.png'))
else:
self.playButton.setIcon(QIcon('assets/play.png'))
########################################################
# Signals handlers
def normalOutputWritten(self, text):
"""Append text to debug infos.
"""
cursor = self.debugText.textCursor()
cursor.movePosition(QtGui.QTextCursor.End)
cursor.insertText(text)
self.debugText.setTextCursor(cursor)
QApplication.processEvents()
def play(self):
"""Play current media.
"""
if self.mediaThread.isRunning():
self.mediaThread.stop()
self.mediaThread.wait()
else:
self.displayMedia(self.sourcePath.text())
def refresh(self):
"""Refresh current media.
"""
if self.mediaThread.isRunning():
self.mediaThread.stop()
self.mediaThread.clean()
self.displayMedia(self.sourcePath.text())
def nextFrame(self):
"""Go to next frame of current media.
"""
self.mediaThread.setNextFrameMode(True)
self.displayMedia(self.sourcePath.text())
def loadFillPath(self):
"""Display file dialog to choose fill image.
"""
filters = self.tr('Image (' + self.IMAGE_FILTERS + ')')
path, filters = QFileDialog.getOpenFileName(self, self.tr('Open file'),
'.', filters)
if path:
item, param = self.getCurrentClassifierParameters()
param.fillPath = path
def loadMedia(self):
"""Load image or video.
"""
filters = ""
filters = self.tr('Image (' + self.IMAGE_FILTERS + self.VIDEO_FILTERS + ')')
path, filters = QFileDialog.getOpenFileName(self, self.tr('Open file'), '.',
filters)
if path:
self.sourcePath.setText(path)
self.mediaThread.stop()
self.mediaThread.clean()
self.displayMedia(path)
def togglePath(self, index):
"""Hide path for camera mode.
"""
if self.__sourceModes[index] == self.SOURCE_CAMERA:
self.sourcePath.hide()
self.sourcePathButton.hide()
self.displayMedia(self.sourcePath.text())
else:
self.sourcePath.show()
self.sourcePathButton.show()
def colorDialog(self):
"""Open color dialog to pick a color.
"""
color = QColorDialog.getColor()
if color.isValid():
common.setPickerColor(color, self.colorPicker)
self.updateClassifierParameters(color=color)
def bgColorDialog(self):
"""Open color dialog to pick a color.
"""
color = QColorDialog.getColor()
if color.isValid():
self.bgColor = color
common.setPickerColor(color, self.bgColorPicker)
def bgPathDialog(self):
"""Open file dialog to select background image.
"""
filters = self.tr('Image (' + self.IMAGE_FILTERS + ')')
path, filters = QFileDialog.getOpenFileName(self, self.tr('Open file'),
'.', filters)
if path:
self.bgPath = path
def toggleBgParams(self, index):
"""Hide / Show color picker and button path for background.
"""
mode = self.__bgModes[index]
if mode == self.BG_COLOR:
self.bgColorPicker.show()
else:
self.bgColorPicker.hide()
if mode == self.BG_IMAGE:
self.bgPathButton.show()
else:
self.bgPathButton.hide()
def calcNeighbors(self):
"""Automatically calculate minimum neighbors.
"""
running = False
if self.mediaThread.isRunning():
running = True
self.mediaThread.stop()
self.mediaThread.wait()
self.detect(self.currentFrame, autoNeighbors=True,
autoNeighborsParam=self.autoNeighborsParam.value())
self.showClassifierParameters(None, None)
if running:
self.displayMedia(self.sourcePath.text())
else:
self.displayImage(self.currentFrame)
def updateClassifierParameters(self, name=None, color=None):
"""Update classifier parameters.
"""
item, param = self.getCurrentClassifierParameters()
if name:
item.setText(name)
param.name = name
if color:
item.setIcon(self.getIcon(color))
param.color = color
def updateStabilize(self, checked):
"""Update stabilize classifier parameter.
"""
running = False
if self.mediaThread.isRunning():
running = True
self.mediaThread.stop()
self.mediaThread.wait()
item, param = self.getCurrentClassifierParameters()
param.stabilize = checked
self.detect(self.currentFrame)
if running:
self.displayMedia(self.sourcePath.text())
else:
self.displayImage(self.currentFrame)
def updateTracking(self, checked):
"""Update tracking classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
param.tracking = checked
def updateScaleFactor(self, value):
"""Update scale factor classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
param.scaleFactor = value
def updateShape(self, index):
"""Update shape classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
param.shape = self.__shapeModes[index]
def updateFill(self, index):
"""Update fill classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
param.fill = self.__fillModes[index]
self.toggleFillPath()
def updateShowName(self, checked):
"""Update show name classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
param.showName = checked
def updateMinNeighbors(self, value):
"""Update min neighbors classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
param.minNeighbors = value
def updateMinWidth(self, value):
"""Update minimum width classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
w, h = param.minSize
param.minSize = (value, h)
def updateMinHeight(self, value):
"""Update minimum height classifier parameter.
"""
item, param = self.getCurrentClassifierParameters()
w, h = param.minSize
param.minSize = (w, value)
def showClassifierParameters(self, selected, deselected):
"""Show the selected classifier parameters.
"""
selectedCount = len(self.objectsTree.selectedIndexes())
if selectedCount == 1:
self.displayBox.setEnabled(True)
self.parametersBox.setEnabled(True)
index = self.objectsTree.currentIndex()
item = index.model().itemFromIndex(index)
param = self.classifiersParameters[item.data()]
self.classifierName.setText(param.name)
common.setPickerColor(param.color, self.colorPicker)
self.classifierType.setText('(' + param.classifier + ')')
self.scaleFactor.setValue(param.scaleFactor)
self.minNeighbors.setValue(param.minNeighbors)
w, h = param.minSize
self.minWidth.setValue(w)
self.minHeight.setValue(h)
self.shapeCBox.setCurrentIndex(self.__shapeModes.index(param.shape))
self.fillCBox.setCurrentIndex(self.__fillModes.index(param.fill))
self.stabilize.setChecked(param.stabilize)
self.showName.setChecked(param.showName)
self.tracking.setChecked(param.tracking)
else:
self.displayBox.setEnabled(False)
self.parametersBox.setEnabled(False)
def addObject(self):
"""Add object to detect.
"""
selected = self.availableObjectsList.selectedItems()
for item in selected:
row = (self.availableObjectsList.row(item) + 1) % self.availableObjectsList.count()
self.availableObjectsList.setCurrentRow(row)
node = item.text()
self.populateTree(node, self.objectsTree.model())
def removeObject(self):
"""Remove object to detect.
"""
selected = self.objectsTree.selectedIndexes()
while selected and selected[0].model():
index = selected[0]
item = index.model().itemFromIndex(index)
del self.classifiersParameters[item.data()]
if item.parent():
index.model().removeRow(item.row(), item.parent().index())
else:
index.model().removeRow(item.row())
selected = self.objectsTree.selectedIndexes()
def splitterMoved(self, pos, index):
"""Avoid segfault when QListWidget has focus and
is going to be collapsed.
"""
focusedWidget = QApplication.focusWidget()
if focusedWidget:
focusedWidget.clearFocus()
def toggleDebugInfo(self, pressed):
"""Toggle debug infos widget.
"""
if pressed:
self.debugText.show()
self.showDetails.setText(self.tr('Details <<<'))
else:
self.debugText.hide()
self.showDetails.setText(self.tr('Details >>>'))
def main():
app = QApplication(sys.argv)
app.setStyle(QtWidgets.QStyleFactory.create("Fusion"))
p = app.palette()
p.setColor(QPalette.Base, QColor(40, 40, 40))
p.setColor(QPalette.Window, QColor(55, 55, 55))
p.setColor(QPalette.Button, QColor(49, 49, 49))
p.setColor(QPalette.Highlight, QColor(135, 135, 135))
p.setColor(QPalette.ButtonText, QColor(155, 155, 155))
p.setColor(QPalette.WindowText, QColor(155, 155, 155))
p.setColor(QPalette.Text, QColor(155, 155, 155))
p.setColor(QPalette.Disabled, QPalette.Base, QColor(49, 49, 49))
p.setColor(QPalette.Disabled, QPalette.Text, QColor(90, 90, 90))
p.setColor(QPalette.Disabled, QPalette.Button, QColor(42, 42, 42))
p.setColor(QPalette.Disabled, QPalette.ButtonText, QColor(90, 90, 90))
p.setColor(QPalette.Disabled, QPalette.Window, QColor(49, 49, 49))
p.setColor(QPalette.Disabled, QPalette.WindowText, QColor(90, 90, 90))
app.setPalette(p)
QApplication.addLibraryPath(QApplication.applicationDirPath() + "/../PlugIns")
main = Window()
main.setWindowTitle('Detection')
main.setWindowIcon(QtGui.QIcon('assets/icon.png'))
main.show()
try:
sys.exit(app.exec_())
except KeyboardInterrupt:
pass
if __name__ == '__main__':
main()
