Python Detector.detect方法代码示例

# 需要导入模块: from detector import Detector [as 别名]
# 或者: from detector.Detector import detect [as 别名]
class Tracker(object):
  """
  This is the main program which gives a high-level view
  of all the running subsystems. It connects camera input with
  output in form of "actions" (such as keyboard shortcuts on the users behalf).
  This is done by locating a hand in an image and detecting features,
  like the number of fingers, and trying to match that data with a
  known gesture.
  """

  def __init__(self):
    """
    Configuration
    """

    # Camera settings
    self.FRAME_WIDTH = 341
    self.FRAME_HEIGHT = 256
    self.flip_camera = True # Mirror image
    self.camera = cv2.VideoCapture(1)

    # ...you can also use a test video for input
    #video = "/Users/matthiasendler/Code/snippets/python/tracker/final/assets/test_video/10.mov"
    #self.camera = cv2.VideoCapture(video)
    #self.skip_input(400) # Skip to an interesting part of the video

    if not self.camera.isOpened():
        print "couldn't load webcam"
        return
    #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, self.FRAME_WIDTH)
    #self.camera.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, self.FRAME_HEIGHT)

    self.filters_dir = "filters/" # Filter settings in trackbar
    self.filters_file = "filters_default"

    # Load filter settings
    current_config = self.filters_dir + self.filters_file
    self.filters = Filters(current_config)

    # No actions will be triggered in test mode
    # (can be used to adjust settings at runtime)
    self.test_mode = False

    # Create a hand detector
    # In fact, this is a wrapper for many detectors
    # to increase detection confidence
    self.detector = Detector(self.filters.config)

    # Knowledge base for all detectors
    self.kb = KB()
    # Create gesture recognizer.
    # A gesture consists of a motion and a hand state.
    self.gesture = Gesture()

    # The action module executes keyboard and mouse commands
    self.action = Action()

    # Show output of detectors
    self.output = Output()

    self.run()

  def run(self):
    """
    In each step: Read the input image and keys,
    process it and react on it (e.g. with an action).
    """
    while True:
      img = self.get_input()
      hand = self.process(img)
      ref = self.action.get_reference_point()
      self.output.show(img, hand, ref)

  def process(self, img):
    """
    Process input
    """
    # Run detection
    hand = self.detector.detect(img)
    # Store result in knowledge base
    self.kb.update(hand)
    if not self.test_mode:
      # Try to interprete as gesture
      self.interprete(hand)
    return hand

  def interprete(self, hand):
    """
    Try to interprete the input as a gesture
    """
    self.gesture.add_hand(hand)
    operation = self.gesture.detect_gesture()
    self.action.execute(operation)

  def get_input(self):
    """
    Get input from camera and keyboard
    """
    self.get_key()
    _, img = self.camera.read()
#.........这里部分代码省略.........

# 需要导入模块: from detector import Detector [as 别名]
# 或者: from detector.Detector import detect [as 别名]
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)
#.........这里部分代码省略.........

# 需要导入模块: from detector import Detector [as 别名]
# 或者: from detector.Detector import detect [as 别名]
class Tracker(object):
    def __init__(self, config, logger):
        self.config = config
        self.logger = logger
        self.camera = Camera(config, logger)
        self.detector = Detector(self.camera)
        self.logger.debug('Tracker started')

    def track(self):
        #Process(target=self.handle_pan, args=()).start()
        #Process(target=self.handle_tilt, args=()).start()

        while True:
            self.detector.detect()

    def handle_pan(self):
        self.process(self.camera.pan,
                     self.camera.pan_q_cur_pos,
                     self.camera.pan_q_des_pos,
                     self.camera.pan_q_speed,
                     'pan')

    def handle_tilt(self):
        self.process(self.camera.tilt,
                     self.camera.tilt_q_cur_pos,
                     self.camera.tilt_q_des_pos,
                     self.camera.tilt_q_speed,
                     'tilt')

    def process(self, servo, cur_queue, desired_queue, speed_queue, type):
        speed = 0.1
        cur_pos = int(self.config.fetch('{0}_start'.format(type)))
        desired_pos = cur_pos + 1
        self.log('Process for {0} direction started at position {1}'.format(type, cur_pos), type)
        while True:
            time.sleep(speed)
            if cur_queue.empty():
                self.log('Current position queue empty. Saving current position ({0}) in queue.'.format(cur_pos), type)
                cur_queue.put(cur_pos)
            if not desired_queue.empty():
                self.log('Desired position queue empty. Saving desired position ({0}) in queue.'.format(desired_pos), type)
                desired_pos = desired_queue.get()
            if not speed_queue.empty():
                _speed = speed_queue.get()
                speed = 0.1 / _speed
                self.log('Speed queue not empty. Found speed {0}, took current speed to {1}'.format(_speed, speed), type)
            if cur_pos < desired_pos:
                cur_pos += 1
                cur_queue.put(cur_pos)
                self.log(
                    'Current position smaller than desired position ({0}). '
                    'Incremented current position and moved servo to {1}'.format(desired_pos, cur_pos), type)
                servo.move(servo.assure_min(cur_pos))
                if not cur_queue.empty():
                    cur_queue.get()
            else:  # cur_pos > desired_pos
                self.log(
                    'Current position bigger than desired position ({0}). '
                    'Decremented current position and moved servo to {1}'.format(desired_pos, cur_pos), type)
                cur_pos -= 1
                cur_queue.put(cur_pos)
                servo.move(servo.assure_max(cur_pos))
                if not cur_queue.empty():
                    cur_queue.get()
            if cur_pos == desired_pos:
                speed = 1

    def log(self, message, direction):
        self.logger.debug('[{0}] {1}'.format(direction, message))