Exemplo n.º 1
0
    def start(self):
        """
        Start the recording and tracking.
        
        :returns: The recording was started status code
        """
        if not hasattr(self.params, 'destPath'):
            return False
        vidExt = os.path.splitext(self.params.destPath)[1]
        if vidExt not in VIDEO_FORMATS:
            print(('Unknow format: {}'.format(vidExt)))
            return False

        self.positions = []  # reset between runs
        self.distancesFromArena = []

        bgStart = self.params.bgFrameIdx
        nBackgroundFrames = self.params.nBgFrames
        trackFrom = self.params.startFrameIdx
        trackTo = self.params.endFrameIdx if (
            self.params.endFrameIdx > 0) else None

        threshold = self.params.detectionThreshold
        minArea = self.params.objectsMinArea
        maxArea = self.params.objectsMaxArea
        teleportationThreshold = self.params.teleportationThreshold

        nSds = self.params.nSds
        clearBorders = self.params.clearBorders
        normalise = self.params.normalise
        extractArena = self.params.extractArena

        self.tracker = GuiTracker(
            self,
            srcFilePath=None,
            destFilePath=self.params.destPath,
            threshold=threshold,
            minArea=minArea,
            maxArea=maxArea,
            teleportationThreshold=teleportationThreshold,
            bgStart=bgStart,
            trackFrom=trackFrom,
            trackTo=trackTo,
            nBackgroundFrames=nBackgroundFrames,
            nSds=nSds,
            clearBorders=clearBorders,
            normalise=normalise,
            plot=True,
            fast=False,
            extractArena=extractArena,
            cameraCalibration=self.params.calib,
            callback=None)
        self.stream = self.tracker  # To comply with BaseInterface
        self._setDisplay()
        self._updateImgProvider()

        self.tracker.setRoi(self.roi)

        self.timer.start(self.timerSpeed)
        return True
Exemplo n.º 2
0
    def load(self):
        """
        Load the video and create the GuiTracker object
        Also registers the analysis image providers (for the analysis tab) with QT
        """
        self.tracker = GuiTracker(self,
                                  srcFilePath=self.params.srcPath,
                                  destFilePath=None,
                                  nBackgroundFrames=1,
                                  plot=True,
                                  fast=False,
                                  cameraCalibration=self.params.calib,
                                  callback=None)
        self.stream = self.tracker  # To comply with BaseInterface
        self.tracker.roi = self.roi

        self.nFrames = self.tracker._stream.nFrames - 1
        self.currentFrameIdx = self.tracker._stream.currentFrameIdx

        if self.params.endFrameIdx == -1:
            self.params.endFrameIdx = self.nFrames

        self._setDisplay()
        self._setDisplayMax()
        self._updateImgProvider()
 def start(self):
     """
     Start the recording and tracking.
     
     :returns: The recording was started status code
     """
     if not hasattr(self.params, 'destPath'):
         return False
     vidExt = os.path.splitext(self.params.destPath)[1]
     if vidExt not in VIDEO_FORMATS:
         print('Unknow format: {}'.format(vidExt))
         return False
     
     self.positions = [] # reset between runs
     self.distancesFromArena = []
     
     bgStart = self.params.bgFrameIdx
     nBackgroundFrames = self.params.nBgFrames
     trackFrom = self.params.startFrameIdx
     trackTo = self.params.endFrameIdx if (self.params.endFrameIdx > 0) else None
     
     threshold = self.params.detectionThreshold
     minArea = self.params.objectsMinArea
     maxArea = self.params.objectsMaxArea
     teleportationThreshold = self.params.teleportationThreshold
     
     nSds = self.params.nSds
     clearBorders = self.params.clearBorders
     normalise = self.params.normalise
     extractArena = self.params.extractArena
     
     self.tracker = GuiTracker(self, srcFilePath=None, destFilePath=self.params.destPath,
                             threshold=threshold, minArea=minArea, maxArea=maxArea,
                             teleportationThreshold=teleportationThreshold,
                             bgStart=bgStart, trackFrom=trackFrom, trackTo=trackTo,
                             nBackgroundFrames=nBackgroundFrames, nSds=nSds,
                             clearBorders=clearBorders, normalise=normalise,
                             plot=True, fast=False, extractArena=extractArena,
                             cameraCalibration=self.params.calib,
                             callback=None)
     self.stream = self.tracker # To comply with BaseInterface
     self._setDisplay()
     self._updateImgProvider()
     
     self.tracker.setRoi(self.roi)
     
     self.timer.start(self.timerSpeed)
     return True
    def load(self):
        """
        Load the video and create the GuiTracker object
        Also registers the analysis image providers (for the analysis tab) with QT
        """
        self.tracker = GuiTracker(self, srcFilePath=self.params.srcPath, destFilePath=None,
                                nBackgroundFrames=1, plot=True,
                                fast=False, cameraCalibration=self.params.calib,
                                callback=None)
        self.stream = self.tracker # To comply with BaseInterface
        self.tracker.roi = self.roi

        self.nFrames = self.tracker._stream.nFrames - 1
        self.currentFrameIdx = self.tracker._stream.currentFrameIdx
        
        if self.params.endFrameIdx == -1:
            self.params.endFrameIdx = self.nFrames
        
        self._setDisplay()
        self._setDisplayMax()
        self._updateImgProvider()
Exemplo n.º 5
0
class RecorderIface(TrackerIface):
    """
    This class extends the TrackerIface to provide video acquisition and live detection (tracking).
    It uses openCV to run the camera and thus should work with any camera supported by openCV.
    It uses the first available USB/firewire camera unless the platform is a raspberry pi,
    in which case it will use the pi camera.
    """
    @pyqtSlot()
    def load(self):  # TODO: check if worth keeping
        pass

    @pyqtSlot(result=QVariant)
    def start(self):
        """
        Start the recording and tracking.
        
        :returns: The recording was started status code
        """
        if not hasattr(self.params, 'destPath'):
            return False
        vidExt = os.path.splitext(self.params.destPath)[1]
        if vidExt not in VIDEO_FORMATS:
            print(('Unknow format: {}'.format(vidExt)))
            return False

        self.positions = []  # reset between runs
        self.distancesFromArena = []

        bgStart = self.params.bgFrameIdx
        nBackgroundFrames = self.params.nBgFrames
        trackFrom = self.params.startFrameIdx
        trackTo = self.params.endFrameIdx if (
            self.params.endFrameIdx > 0) else None

        threshold = self.params.detectionThreshold
        minArea = self.params.objectsMinArea
        maxArea = self.params.objectsMaxArea
        teleportationThreshold = self.params.teleportationThreshold

        nSds = self.params.nSds
        clearBorders = self.params.clearBorders
        normalise = self.params.normalise
        extractArena = self.params.extractArena

        self.tracker = GuiTracker(
            self,
            srcFilePath=None,
            destFilePath=self.params.destPath,
            threshold=threshold,
            minArea=minArea,
            maxArea=maxArea,
            teleportationThreshold=teleportationThreshold,
            bgStart=bgStart,
            trackFrom=trackFrom,
            trackTo=trackTo,
            nBackgroundFrames=nBackgroundFrames,
            nSds=nSds,
            clearBorders=clearBorders,
            normalise=normalise,
            plot=True,
            fast=False,
            extractArena=extractArena,
            cameraCalibration=self.params.calib,
            callback=None)
        self.stream = self.tracker  # To comply with BaseInterface
        self._setDisplay()
        self._updateImgProvider()

        self.tracker.setRoi(self.roi)

        self.timer.start(self.timerSpeed)
        return True

    def getSamplingFreq(self):
        """
        Return the sampling frequency (note this is a maximum and can be limited by a slower CPU)
        """
        return 1.0 / (self.timerSpeed / 1000.0)  # timer speed in ms

    @pyqtSlot(result=QVariant)
    def camDetected(self):
        """
        Check if a camera is available
        """
        cap = cv2.VideoCapture(0)
        detected = False
        if cap.isOpened():
            detected = True
        cap.release()
        return detected

    def getImg(self):
        self.display.reload()
Exemplo n.º 6
0
class TrackerIface(BaseInterface):
    """
    This class implements the BaseInterface to provide a qml interface
    to the GuiTracker object of the tracking module.
    """
    def __init__(self, app, context, parent, params, displayName, providerName,
                 analysisProvider1, analysisProvider2):
        BaseInterface.__init__(self, app, context, parent, params, displayName,
                               providerName)

        self.positions = []
        self.roi = None
        self.analysisImageProvider = analysisProvider1
        self.analysisImageProvider2 = analysisProvider2

    @pyqtSlot(QVariant, result=QVariant)
    def getRow(self, idx):
        """
        Get the data (position and distancesFromArena) at row idx
        
        :param int idx: The index of the row to return
        """
        idx = int(idx)
        if 0 <= idx < len(self.positions):
            row = [idx] + list(self.positions[idx]) + list(
                self.distancesFromArena[idx])
            return [str(e) for e in row]
        else:
            return -1

    @pyqtSlot()
    def load(self):
        """
        Load the video and create the GuiTracker object
        Also registers the analysis image providers (for the analysis tab) with QT
        """
        self.tracker = GuiTracker(self,
                                  srcFilePath=self.params.srcPath,
                                  destFilePath=None,
                                  nBackgroundFrames=1,
                                  plot=True,
                                  fast=False,
                                  cameraCalibration=self.params.calib,
                                  callback=None)
        self.stream = self.tracker  # To comply with BaseInterface
        self.tracker.roi = self.roi

        self.nFrames = self.tracker._stream.nFrames - 1
        self.currentFrameIdx = self.tracker._stream.currentFrameIdx

        if self.params.endFrameIdx == -1:
            self.params.endFrameIdx = self.nFrames

        self._setDisplay()
        self._setDisplayMax()
        self._updateImgProvider()

    @pyqtSlot()
    def start(self):
        """
        Start the tracking of the loaded video with the parameters from self.params
        """
        self.positions = []  # reset between runs
        self.distancesFromArena = []

        self.tracker._stream.bgStartFrame = self.params.bgFrameIdx
        nBackgroundFrames = self.params.nBgFrames
        self.tracker._stream.bgEndFrame = self.params.bgFrameIdx + nBackgroundFrames - 1
        self.tracker.trackFrom = self.params.startFrameIdx
        self.tracker.trackTo = self.params.endFrameIdx if (
            self.params.endFrameIdx > 0) else None

        self.tracker.threshold = self.params.detectionThreshold
        self.tracker.minArea = self.params.objectsMinArea
        self.tracker.maxArea = self.params.objectsMaxArea
        self.tracker.teleportationThreshold = self.params.teleportationThreshold

        self.tracker.nSds = self.params.nSds
        self.tracker.clearBorders = self.params.clearBorders
        self.tracker.normalise = self.params.normalise
        self.tracker.extractArena = self.params.extractArena

        self.tracker.setRoi(self.roi)

        self.timer.start(self.timerSpeed)

    @pyqtSlot()
    def stop(self):
        """
        The qt slot to self._stop()
        """
        self._stop('Recording stopped manually')

    def _stop(self, msg):
        """
        Stops the tracking gracefully
        
        :param string msg: The message to print upon stoping
        """
        self.timer.stop()
        self.tracker._stream.stopRecording(msg)

    @pyqtSlot(QVariant, QVariant, QVariant, QVariant, QVariant)
    def setRoi(self, width, height, x, y, diameter):
        """
        Sets the ROI (in which to check for the specimen) from the one drawn in QT
        Scaling is applied to match the (resolution difference) between the representation 
        of the frames in the GUI (on which the user draws the ROI) and the internal representation
        used to compute the position of the specimen.
        
        :param width: The width of the image representation in the GUI
        :param height: The height of the image representation in the GUI
        :param x: The center of the roi in the first dimension
        :param y: The center of the roi in the second dimension
        :param diameter: The diameter of the ROI
        """
        if hasattr(self, 'tracker'):
            streamWidth, streamHeight = self.tracker._stream.size  # flipped for openCV
            horizontalScalingFactor = streamWidth / width
            verticalScalingFactor = streamHeight / height

            radius = diameter / 2.0
            scaledX = (x + radius) * horizontalScalingFactor
            scaledY = (y + radius) * verticalScalingFactor
            scaledRadius = radius * horizontalScalingFactor

            self.roi = Circle((scaledX, scaledY), scaledRadius)

    @pyqtSlot()
    def removeRoi(self):
        self.roi = None

    @pyqtSlot(QVariant)
    def save(self, defaultDest):
        """
        Save the data (positions and distancesFromArena) as a csv style file
        """
        diag = QFileDialog()
        if defaultDest:
            defaultDest = os.path.splitext(defaultDest)[0] + '.csv'
        else:
            defaultDest = os.getenv('HOME')
        destPath = diag.getSaveFileName(parent=diag,
                                        caption='Save file',
                                        directory=defaultDest,
                                        filter="Text (*.txt *.dat *.csv)",
                                        initialFilter="Text (*.csv)")
        destPath = destPath[0]
        if destPath:
            self.write(destPath)

    def write(self, dest):
        """
        The method called by save() to write the csv file
        """
        with open(dest, 'w') as outFile:
            writer = csv.writer(outFile,
                                delimiter=',',
                                quotechar='|',
                                quoting=csv.QUOTE_MINIMAL)
            for fid, row in enumerate(self.positions):
                writer.writerow([fid] + list(row))

    @pyqtSlot(QVariant)
    def setFrameType(self, outputType):
        """
        Set the type of frame to display. (As source, difference with background or binary mask)
        
        :param string outputType: The type of frame to display. One of ['Raw', 'Diff', 'Mask']
        """
        self.outputType = outputType.lower()

    @pyqtSlot()
    def analyseAngles(self):
        """
        Compute and plot the angles between the segment Pn -> Pn+1 and Pn+1 -> Pn+2
        """
        fig, ax = plt.subplots()
        angles = video_analysis.getAngles(self.positions)
        video_analysis.plotAngles(angles, self.getSamplingFreq())
        self.analysisImageProvider._fig = fig

    @pyqtSlot()
    def analyseDistances(self):
        """
        Compute and plot the distances between the points Pn and Pn+1
        """
        fig, ax = plt.subplots()
        distances = video_analysis.posToDistances(self.positions)
        video_analysis.plotDistances(distances, self.getSamplingFreq())
        self.analysisImageProvider2._fig = fig

    @pyqtSlot()
    def saveAnglesFig(self):
        """
        Save the graph as a png or jpeg image
        """
        diag = QFileDialog()
        destPath = diag.getSaveFileName(parent=diag,
                                        caption='Save file',
                                        directory=os.getenv('HOME'),
                                        filter="Image (*.png *.jpg)")
        destPath = destPath[0]
        if destPath:
            imsave(destPath, self.analysisImageProvider.getArray())

    def getSamplingFreq(self):
        return self.tracker._stream.fps

    def getImg(self):
        if self.tracker._stream.currentFrameIdx < self.nFrames:
            self.display.reload()
            self._updateDisplayIdx()
        else:
            self._stop('End of recording reached')
class RecorderIface(TrackerIface):
    """
    This class extends the TrackerIface to provide video acquisition and live detection (tracking).
    It uses openCV to run the camera and thus should work with any camera supported by openCV.
    It uses the first available USB/firewire camera unless the platform is a raspberry pi,
    in which case it will use the pi camera.
    """

    @pyqtSlot()
    def load(self): # TODO: check if worth keeping
        pass
        
    @pyqtSlot(result=QVariant)
    def start(self):
        """
        Start the recording and tracking.
        
        :returns: The recording was started status code
        """
        if not hasattr(self.params, 'destPath'):
            return False
        vidExt = os.path.splitext(self.params.destPath)[1]
        if vidExt not in VIDEO_FORMATS:
            print('Unknow format: {}'.format(vidExt))
            return False
        
        self.positions = [] # reset between runs
        self.distancesFromArena = []
        
        bgStart = self.params.bgFrameIdx
        nBackgroundFrames = self.params.nBgFrames
        trackFrom = self.params.startFrameIdx
        trackTo = self.params.endFrameIdx if (self.params.endFrameIdx > 0) else None
        
        threshold = self.params.detectionThreshold
        minArea = self.params.objectsMinArea
        maxArea = self.params.objectsMaxArea
        teleportationThreshold = self.params.teleportationThreshold
        
        nSds = self.params.nSds
        clearBorders = self.params.clearBorders
        normalise = self.params.normalise
        extractArena = self.params.extractArena
        
        self.tracker = GuiTracker(self, srcFilePath=None, destFilePath=self.params.destPath,
                                threshold=threshold, minArea=minArea, maxArea=maxArea,
                                teleportationThreshold=teleportationThreshold,
                                bgStart=bgStart, trackFrom=trackFrom, trackTo=trackTo,
                                nBackgroundFrames=nBackgroundFrames, nSds=nSds,
                                clearBorders=clearBorders, normalise=normalise,
                                plot=True, fast=False, extractArena=extractArena,
                                cameraCalibration=self.params.calib,
                                callback=None)
        self.stream = self.tracker # To comply with BaseInterface
        self._setDisplay()
        self._updateImgProvider()
        
        self.tracker.setRoi(self.roi)
        
        self.timer.start(self.timerSpeed)
        return True
        
    def getSamplingFreq(self):
        """
        Return the sampling frequency (note this is a maximum and can be limited by a slower CPU)
        """
        return 1.0 / (self.timerSpeed / 1000.0) # timer speed in ms
        
    @pyqtSlot(result=QVariant)
    def camDetected(self):
        """
        Check if a camera is available
        """
        cap = cv2.VideoCapture(0)
        detected = False
        if cap.isOpened():
            detected = True
        cap.release()
        return detected

    def getImg(self):
        self.display.reload()
class TrackerIface(BaseInterface):
    """
    This class implements the BaseInterface to provide a qml interface
    to the GuiTracker object of the tracking module.
    """
    def __init__(self, app, context, parent, params, displayName, providerName, analysisProvider1, analysisProvider2):
        BaseInterface.__init__(self, app, context, parent, params, displayName, providerName)
        
        self.positions = []
        self.roi = None
        self.analysisImageProvider = analysisProvider1
        self.analysisImageProvider2 = analysisProvider2

    @pyqtSlot(QVariant, result=QVariant)
    def getRow(self, idx):
        """
        Get the data (position and distancesFromArena) at row idx
        
        :param int idx: The index of the row to return
        """
        idx = int(idx)
        if 0 <= idx < len(self.positions):
            row = [idx] + list(self.positions[idx]) + list(self.distancesFromArena[idx])
            return [str(e) for e in row]
        else:
            return -1

    @pyqtSlot()
    def load(self):
        """
        Load the video and create the GuiTracker object
        Also registers the analysis image providers (for the analysis tab) with QT
        """
        self.tracker = GuiTracker(self, srcFilePath=self.params.srcPath, destFilePath=None,
                                nBackgroundFrames=1, plot=True,
                                fast=False, cameraCalibration=self.params.calib,
                                callback=None)
        self.stream = self.tracker # To comply with BaseInterface
        self.tracker.roi = self.roi

        self.nFrames = self.tracker._stream.nFrames - 1
        self.currentFrameIdx = self.tracker._stream.currentFrameIdx
        
        if self.params.endFrameIdx == -1:
            self.params.endFrameIdx = self.nFrames
        
        self._setDisplay()
        self._setDisplayMax()
        self._updateImgProvider()

    @pyqtSlot()
    def start(self):
        """
        Start the tracking of the loaded video with the parameters from self.params
        """
        self.positions = [] # reset between runs
        self.distancesFromArena = []
        
        self.tracker._stream.bgStartFrame = self.params.bgFrameIdx
        nBackgroundFrames = self.params.nBgFrames
        self.tracker._stream.bgEndFrame = self.params.bgFrameIdx + nBackgroundFrames - 1
        self.tracker.trackFrom = self.params.startFrameIdx
        self.tracker.trackTo = self.params.endFrameIdx if (self.params.endFrameIdx > 0) else None
        
        self.tracker.threshold = self.params.detectionThreshold
        self.tracker.minArea = self.params.objectsMinArea
        self.tracker.maxArea = self.params.objectsMaxArea
        self.tracker.teleportationThreshold = self.params.teleportationThreshold
        
        self.tracker.nSds = self.params.nSds
        self.tracker.clearBorders = self.params.clearBorders
        self.tracker.normalise = self.params.normalise
        self.tracker.extractArena = self.params.extractArena
        
        self.tracker.setRoi(self.roi)
            
        self.timer.start(self.timerSpeed)

    @pyqtSlot()
    def stop(self):
        """
        The qt slot to self._stop()
        """
        self._stop('Recording stopped manually')
        
    def _stop(self, msg):
        """
        Stops the tracking gracefully
        
        :param string msg: The message to print upon stoping
        """
        self.timer.stop()
        self.tracker._stream.stopRecording(msg)
        
    @pyqtSlot(QVariant, QVariant, QVariant, QVariant, QVariant)
    def setRoi(self, width, height, x, y, diameter):
        """
        Sets the ROI (in which to check for the specimen) from the one drawn in QT
        Scaling is applied to match the (resolution difference) between the representation 
        of the frames in the GUI (on which the user draws the ROI) and the internal representation
        used to compute the position of the specimen.
        
        :param width: The width of the image representation in the GUI
        :param height: The height of the image representation in the GUI
        :param x: The center of the roi in the first dimension
        :param y: The center of the roi in the second dimension
        :param diameter: The diameter of the ROI
        """
        if hasattr(self, 'tracker'):
            streamWidth, streamHeight = self.tracker._stream.size # flipped for openCV
            horizontalScalingFactor = streamWidth / width
            verticalScalingFactor = streamHeight / height
            
            radius = diameter / 2.0
            scaledX = (x + radius) * horizontalScalingFactor
            scaledY = (y + radius) * verticalScalingFactor
            scaledRadius = radius * horizontalScalingFactor
            
            self.roi = Circle((scaledX, scaledY), scaledRadius)

    @pyqtSlot()
    def removeRoi(self):
        self.roi = None

    @pyqtSlot(QVariant)
    def save(self, defaultDest):
        """
        Save the data (positions and distancesFromArena) as a csv style file
        """
        diag = QFileDialog()
        if defaultDest:
            defaultDest = os.path.splitext(defaultDest)[0] + '.csv'
        else:
            defaultDest = os.getenv('HOME')
        destPath = diag.getSaveFileName(parent=diag,
                                    caption='Save file',
                                    directory=defaultDest,
                                    filter="Text (*.txt *.dat *.csv)", 
                                    initialFilter="Text (*.csv)")
        destPath = destPath[0]
        if destPath:
            self.write(destPath)
    
    def write(self, dest):
        """
        The method called by save() to write the csv file
        """
        with open(dest, 'w') as outFile:
            writer = csv.writer(outFile, delimiter=',', quotechar='|', quoting=csv.QUOTE_MINIMAL)
            for fid, row in enumerate(self.positions):
                writer.writerow([fid]+list(row))

    @pyqtSlot(QVariant)
    def setFrameType(self, outputType):
        """
        Set the type of frame to display. (As source, difference with background or binary mask)
        
        :param string outputType: The type of frame to display. One of ['Raw', 'Diff', 'Mask']
        """
        self.outputType = outputType.lower()

    @pyqtSlot()
    def analyseAngles(self):
        """
        Compute and plot the angles between the segment Pn -> Pn+1 and Pn+1 -> Pn+2
        """
        fig, ax = plt.subplots()
        angles = video_analysis.getAngles(self.positions)
        video_analysis.plotAngles(angles, self.getSamplingFreq())
        self.analysisImageProvider._fig = fig

    @pyqtSlot()
    def analyseDistances(self):
        """
        Compute and plot the distances between the points Pn and Pn+1
        """
        fig, ax = plt.subplots()
        distances = video_analysis.posToDistances(self.positions)
        video_analysis.plotDistances(distances, self.getSamplingFreq())
        self.analysisImageProvider2._fig = fig

    @pyqtSlot()
    def saveAnglesFig(self):
        """
        Save the graph as a png or jpeg image
        """
        diag = QFileDialog()
        destPath = diag.getSaveFileName(parent=diag,
                                    caption='Save file',
                                    directory=os.getenv('HOME'), 
                                    filter="Image (*.png *.jpg)")
        destPath = destPath[0]
        if destPath:
            imsave(destPath, self.analysisImageProvider.getArray())

    def getSamplingFreq(self):
        return self.tracker._stream.fps

    def getImg(self):
        if self.tracker._stream.currentFrameIdx < self.nFrames:
            self.display.reload()
            self._updateDisplayIdx()
        else:
            self._stop('End of recording reached')