def helpBtn(self):
    msg = ft.QMessageBox(self)
    msg.setText(
        """Manual Tracking allows you to track a flame with a point-and-click method.

    'Tracking points #' defines the number of mouse clicks to record for each frame before moving to the next one (the default is one click per frame). By clicking on 'Start tracking', a pop-up window will show the first frame (press 'Esc' to exit at any time, but note that the progress will be lost). The following frames will show the horizontal lines corresponding to the points clicked. These lines can be hidden by unchecking 'Show tracking lines' before starting the analysis. After the tracking, the position vs time and spread rate vs time values will be shown in the windows in the 'Analysis box' when the slider in the 'Preview box' is used. The 'Flame direction' determines the positive increment of the flame location along the horizontal coordinate.

    If there is a flashing or strobe light in the recorded video, you can click on 'Pick bright region' to choose a rectangular region (in the same way that the ROI is selected) that is illuminated when the light is on and dark when it is off. Note that this region is independent from the ROI specified in the 'Preview box', and will show up of the left window in the 'Analysis box'. From the dropdown menu, select the option 'Frames light on' to consider only the frames where the light is on, or 'Frames light off' to consider only the frames without the light. By default all the frames are considered.

    By clicking on 'Absolute values', the x-axis of the tracked data will be shifted to the origin.

    Click on 'Save data' to export a csv file with all the tracking results (position in pixel and mm for each point tracked, and their corresponding spread rate).
    """)
    msg.exec()
def HSVTracking(self):
    scale = True
    if not self.scaleIn.text():
        scale = False
        msg = ft.QMessageBox(self)
        msg.setText('The scale [px/mm] has not been specified')
        # if self.pyqtVer == '5':
        #     msg.exec_()
        # elif self.pyqtVer == '6':
        msg.exec()

    firstFrame = int(self.firstFrameIn.text())
    lastFrame = int(self.lastFrameIn.text())
    self.connectivity = self.connectivityGroup.checkedAction()
    self.connectivity = self.connectivity.text()
    currentFrame = firstFrame
    self.xRight_px = list()
    self.xLeft_px = list()
    self.xRight_mm = list()
    self.xLeft_mm = list()
    flameLength_mm = list()
    self.frameCount = list()
    flameArea = list()

    if self.exportVideo_HT.isChecked() or self.exportTrackOverlay_HT.isChecked(
    ):
        fps = (float(self.vFps)) / (int(self.skipFrameIn.text()) + 1)
        vName = self.fPath + '-trackedVideo.' + str(
            self.vFormat
        )  # alternative: 'output.{}'.format(vFormat);   self.fNameLbl.text()
        fourcc = ft.cv2.VideoWriter_fourcc(*self.codec)
        size = (int(self.roiThreeIn.text()), int(self.roiFourIn.text()))
        # open and set properties
        vout = ft.cv2.VideoWriter()
        vout.open(vName, fourcc, fps, size, True)

    if scale:  #this condition prevents crashes in case the scale is not specified
        xAxis_lbl1 = self.xAxis_lbl1.currentText()
        yAxis_lbl1 = self.yAxis_lbl1.currentText()
        xAxis_lbl2 = self.xAxis_lbl2.currentText()
        yAxis_lbl2 = self.yAxis_lbl2.currentText()
        while (currentFrame < lastFrame):
            # print('Frame #:', currentFrame)
            frame, frameCrop = ft.checkEditing(self, currentFrame)

            if self.filterLight_HT.isChecked() == True:
                if self.lightROI_HT_recorded == True:
                    # looking for frames with a light on (which would increase the red and green channel values of the background)
                    low = ([5, 5, 10]
                           )  # blueLow, greenLow, redLow (see color tracking)
                    high = ([255, 255, 255])  # blueHigh, greenHigh, redHigh
                    low = ft.np.array(
                        low, dtype='uint8')  #this conversion is necessary
                    high = ft.np.array(high, dtype='uint8')
                    currentLightROI = frame[self.lightROI_HT[1]:(
                        self.lightROI_HT[1] +
                        self.lightROI_HT[3]), self.lightROI_HT[0]:(
                            self.lightROI_HT[0] + self.lightROI_HT[2])]
                    newMask = ft.cv2.inRange(currentLightROI, low, high)
                    frame_light = ft.cv2.bitwise_and(currentLightROI,
                                                     currentLightROI,
                                                     mask=newMask)
                    grayFrame_light = ft.cv2.cvtColor(frame_light,
                                                      ft.cv2.COLOR_BGR2GRAY)
                    (thresh_light,
                     frameBW_light) = ft.cv2.threshold(grayFrame_light, 0, 255,
                                                       ft.cv2.THRESH_BINARY)
                    flamePx_light = ft.np.where(frameBW_light == [255])  #beta
                    area_lightROI = int(self.lightROI_HT[3] *
                                        self.lightROI_HT[2])
                else:
                    msg = ft.QMessageBox(self)
                    msg.setText(
                        'Before the tracking, please click on "Pick a bright region" to select a region where the light is visible.'
                    )
                    # if self.pyqtVer == '5':
                    #     msg.exec_()
                    # elif self.pyqtVer == '6':
                    msg.exec()
                    break

                if len(
                        flamePx_light[0]
                ) < 0.5 * area_lightROI:  #if the bright area is larger than the ROI area
                    getFilteredFrame(self, frameCrop)
                    print('frame counted')
                else:
                    currentFrame = currentFrame + 1 + int(
                        self.skipFrameIn.text())
                    print('frame not counted')
                    continue
            else:
                getFilteredFrame(self, frameCrop)

            self.xRight_px.append(self.xRight)
            self.xLeft_px.append(self.xLeft)
            self.xRight_mm.append(self.xRight / float(self.scaleIn.text()))
            self.xLeft_mm.append(self.xLeft / float(self.scaleIn.text()))
            flameArea.append(self.flameArea)
            self.frameCount.append(currentFrame)
            if self.exportVideo_HT.isChecked(
            ) and not self.exportTrackOverlay_HT.isChecked():
                vout.write(self.currentFrameRGB_HT)
            elif self.exportTrackOverlay_HT.isChecked():
                #CAS Add Track lines over cropped video
                trackframe = ft.np.copy(frameCrop)  # frame is 1080 x 1920
                trackframe[:,
                           min(
                               self.xRight - 1 - int(self.roiOneIn.text(
                               )), ft.np.size(trackframe, 1)
                           )] = 255  # white out line to mark where tracked flame, using relative distance
                vout.write(trackframe)

            # print('Progress: ', round((currentFrame - firstFrame)/(lastFrame - firstFrame) * 10000)/100, '%')
            print('Progress: ',
                  round((currentFrame - firstFrame) /
                        (lastFrame - firstFrame) * 10000) / 100,
                  '%',
                  '(Frame #: ',
                  currentFrame,
                  ')',
                  end='\r')
            currentFrame = currentFrame + 1 + int(self.skipFrameIn.text())

        try:
            self.flameArea = [
                areaN / (float(self.scaleIn.text())**2) for areaN in flameArea
            ]
            self.flameArea = ft.np.round(self.flameArea, 3)
            self.flameArea = self.flameArea.tolist()
            self.timeCount = [
                frameN / float(self.vFpsLbl.text())
                for frameN in self.frameCount
            ]
        except:
            pass

            # CAS Add tracking line from flameTracker.py
            #if self.HSVTrackingValue == True:
            #    # Start tracking for export
            #    #HSVTracking(self)
            #    # #findFlameEdges_HT(self, frameBW, flamePx)
            #    getHSVFilteredFrame(self, currentFrame)
            #    trackframe = frameCrop # frame is 1080 x 1920
            #    import numpy
            #    #print(type(frame), numpy.size(frame, 0), 'x', numpy.size(frame, 1))
            #    #print(type(frameCrop), numpy.size(frameCrop, 0), 'x', numpy.size(frameCrop, 1))
            #    trackframe[:, min(self.xRight-1 - int(self.roiOneIn.text()), numpy.size(trackframe,1))] = 255 # white out line to mark where tracked flame, using relative distance
            #    #if self.xRight-1 > numpy.size(trackframe,1):
            #    #    print('xRight would have errored here with value:', self.xRight)
            #    #cv2.imshow('Frame_With_255_TrackLine', trackframe)

        for i in range(len(self.xRight_mm)):
            flameLength_mm.append(abs(self.xRight_mm[i] - self.xLeft_mm[i]))

        flameLength_mm = ft.np.round(flameLength_mm, 2)
        self.flameLength_mm = flameLength_mm.tolist()
        print('Progress: 100 % - Tracking completed')
        self.msgLabel.setText('Tracking completed')

        if self.exportVideo_HT.isChecked(
        ) or self.exportTrackOverlay_HT.isChecked():
            vout.release()
            self.msgLabel.setText('Tracking completed and video created.')

        # the following approach to calculate the spread rate is the same one used for lumaTracking
        movAvgPt = int(
            self.movAvgIn_HT.text()
        )  #this number is half of the interval considered for the spread rate (movAvgPt = 2 means I am considering a total of 5 points (my point, 2 before and 2 after))
        self.spreadRateRight = list()
        self.spreadRateLeft = list()

        if movAvgPt == 0:
            for i in range(len(self.timeCount) - 1):
                xCoeffRight = ft.np.polyfit(self.timeCount[(i):(i + 2)],
                                            self.xRight_mm[(i):(i + 2)], 1)
                xCoeffLeft = ft.np.polyfit(self.timeCount[(i):(i + 2)],
                                           self.xLeft_mm[(i):(i + 2)], 1)
                self.spreadRateRight.append(xCoeffRight[0])
                self.spreadRateLeft.append(xCoeffLeft[0])
            #repeat the last value
            self.spreadRateRight.append(xCoeffRight[0])
            self.spreadRateLeft.append(xCoeffLeft[0])
        else:  #here we calculate the instantaneous spread rate based on the moving avg. I also included the initial and final points
            for i in range(len(self.timeCount)):
                if i - movAvgPt < 0:
                    xCoeffRight = ft.np.polyfit(
                        self.timeCount[0:(i + movAvgPt + 1)],
                        self.xRight_mm[0:(i + movAvgPt + 1)], 1)
                    xCoeffLeft = ft.np.polyfit(
                        self.timeCount[0:(i + movAvgPt + 1)],
                        self.xLeft_mm[0:(i + movAvgPt + 1)], 1)
                    self.spreadRateRight.append(xCoeffRight[0])
                    self.spreadRateLeft.append(xCoeffLeft[0])
                elif i >= movAvgPt:
                    xCoeffRight = ft.np.polyfit(
                        self.timeCount[(i - movAvgPt):(i + movAvgPt + 1)],
                        self.xRight_mm[(i - movAvgPt):(i + movAvgPt + 1)], 1)
                    xCoeffLeft = ft.np.polyfit(
                        self.timeCount[(i - movAvgPt):(i + movAvgPt + 1)],
                        self.xLeft_mm[(i - movAvgPt):(i + movAvgPt + 1)], 1)
                    self.spreadRateRight.append(xCoeffRight[0])
                    self.spreadRateLeft.append(xCoeffLeft[0])
                elif i + movAvgPt > len(self.timeCount):
                    xCoeffRight = ft.np.polyfit(
                        self.timeCount[(i - movAvgPt):],
                        self.xRight_mm[(i - movAvgPt):], 1)
                    xCoeffLeft = ft.np.polyfit(self.timeCount[(i - movAvgPt):],
                                               self.xLeft_mm[(i - movAvgPt):],
                                               1)
                    self.spreadRateRight.append(xCoeffRight[0])
                    self.spreadRateLeft.append(xCoeffLeft[0])

        self.spreadRateRight = ft.np.round(self.spreadRateRight, 3)
        self.spreadRateRight = self.spreadRateRight.tolist()
        self.spreadRateLeft = ft.np.round(self.spreadRateLeft, 3)
        self.spreadRateLeft = self.spreadRateLeft.tolist()

        self.plot1_HT.setLabel('left', str(yAxis_lbl1), color='black', size=14)
        self.plot1_HT.setLabel('bottom',
                               str(xAxis_lbl1),
                               color='black',
                               size=14)

        self.plot1_HT.getAxis('bottom').setPen(color=(0, 0, 0))
        self.plot1_HT.getAxis('left').setPen(color=(0, 0, 0))
        self.plot1_HT.addLegend(
            offset=[1, 0.1]
        )  # background color modified in line 122 and 123 of Versions/3.7/lib/python3.7/site-packages/pyqtgraph/graphicsItems
        self.plot2_HT.setLabel('left', str(yAxis_lbl2), color='black', size=14)
        self.plot2_HT.setLabel('bottom',
                               str(xAxis_lbl2),
                               color='black',
                               size=14)

        self.plot2_HT.getAxis('bottom').setPen(color=(0, 0, 0))
        self.plot2_HT.getAxis('left').setPen(color=(0, 0, 0))
        self.plot2_HT.addLegend(
            offset=[1, 0.1]
        )  # background color modified in line 122 and 123 of Versions/3.7/lib/python3.7/site-packages/pyqtgraph/graphicsItems

        xPlot1, yRight1, yLeft1 = selectAxes(self, xAxis_lbl1, yAxis_lbl1)
        xPlot2, yRight2, yLeft2 = selectAxes(self, xAxis_lbl2, yAxis_lbl2)

        if yAxis_lbl1 == 'Flame length [mm]':
            HSVTrackingPlot(self.plot1_HT, xPlot1, yRight1, 'flame length',
                            'o', 'b')
        elif yAxis_lbl1 == 'Flame area [mm2]':
            HSVTrackingPlot(self.plot1_HT, xPlot1, yRight1, 'flame area', 'o',
                            'b')
        else:
            HSVTrackingPlot(self.plot1_HT, xPlot1, yRight1, 'right edge', 'o',
                            'b')
            HSVTrackingPlot(self.plot1_HT, xPlot1, yLeft1, 'left edge', 't',
                            'r')

        if yAxis_lbl2 == 'Flame length [mm]':
            HSVTrackingPlot(self.plot2_HT, xPlot2, yRight2, 'flame length',
                            'o', 'b')
        elif yAxis_lbl2 == 'Flame area [mm2]':
            HSVTrackingPlot(self.plot2_HT, xPlot2, yRight2, 'flame area', 'o',
                            'b')
        else:
            HSVTrackingPlot(self.plot2_HT, xPlot2, yRight2, 'right edge', 'o',
                            'b')
            HSVTrackingPlot(self.plot2_HT, xPlot2, yLeft2, 'left edge', 't',
                            'r')

        self.win1_HT.setCurrentIndex(
            1)  #to activate the preview tab in the analysis box
        self.win2_HT.setCurrentIndex(1)
def startTracking(self):
    global clk, nClicks  #, flameDir
    # select the variables to plot based on user input
    xAxis_lbl1 = self.xAxis_lbl1.currentText()
    yAxis_lbl1 = self.yAxis_lbl1.currentText()
    xAxis_lbl2 = self.xAxis_lbl2.currentText()
    yAxis_lbl2 = self.yAxis_lbl2.currentText()

    self.plot1_MT.clear()
    self.plot1_MT.setLabel('left', str(yAxis_lbl1), color='black', size=14)
    self.plot1_MT.setLabel('bottom', str(xAxis_lbl1), color='black', size=14)
    self.plot1_MT.getAxis('bottom').setPen(color=(0, 0, 0))
    self.plot1_MT.getAxis('left').setPen(color=(0, 0, 0))
    self.plot1_MT.addLegend(offset=[1, 0.1])

    firstFrame = int(self.firstFrameIn.text())
    lastFrame = int(self.lastFrameIn.text())

    # scale = True

    #Set up the first frame for analysis and clk for the mouse event
    currentFrame = firstFrame

    clk = False  # False unless the mouse is clicked
    posX = dict()
    posX_mm = dict()
    posY = dict()
    posY_mm = dict()
    frameCount = dict()
    timeCount = dict()

    # find out how many points to be selected in each frame
    try:
        nClicks = int(self.nClicksLbl.text())
    except:
        nClicks = 1
        self.msgLabel.setText('Clicks not specified (=1)')

    while (currentFrame < lastFrame):
        print('Frame #:', currentFrame, end='\r')

        if not self.scaleIn.text():
            # scale = False
            msg = ft.QMessageBox(self)
            msg.setText('The scale [px/mm] has not been specified')
            msg.exec()
            break

        frame, frameCrop = ft.checkEditing(self, currentFrame)

        if self.lightROI_MT_recorded == True:
            # looking for frames with a light on (which would increase the red and green channel values of the background)
            # low and high are the thresholds for each color channel
            low = ([5, 5, 10])  # blueLow, greenLow, redLow
            high = ([255, 255, 255])  # blueHigh, greenHigh, redHigh
            low = ft.np.array(low,
                              dtype='uint8')  #this conversion is necessary
            high = ft.np.array(high, dtype='uint8')

            currentLightROI = frame[self.lightROI_MT[1]:(self.lightROI_MT[1] +
                                                         self.lightROI_MT[3]),
                                    self.lightROI_MT[0]:(self.lightROI_MT[0] +
                                                         self.lightROI_MT[2])]
            newMask = ft.cv2.inRange(currentLightROI, low, high)
            frame_light = ft.cv2.bitwise_and(currentLightROI,
                                             currentLightROI,
                                             mask=newMask)
            grayFrame_light = ft.cv2.cvtColor(frame_light,
                                              ft.cv2.COLOR_BGR2GRAY)
            (thresh_light,
             BW_light) = ft.cv2.threshold(grayFrame_light, 0, 255,
                                          ft.cv2.THRESH_BINARY)
            flamePx_light = ft.np.where(BW_light == [255])
            area_light = int(self.lightROI_MT[3] * self.lightROI_MT[2])

            # if lightStatus == 'lightOff':
            if self.filterLight_MT.currentText() == 'Frames light off':
                if len(flamePx_light[0]) > 0.5 * area_light:  #avoid this frame
                    currentFrame = currentFrame + 1 + int(
                        self.skipFrameIn.text())
                    continue
            # elif lightStatus == 'lightOn':
            elif self.filterLight_MT.currentText() == 'Frames light on':
                if len(flamePx_light[0]) < 0.5 * area_light:  #avoid this frame
                    currentFrame = currentFrame + 1 + int(
                        self.skipFrameIn.text())
                    continue

        # create the window and the line over the first point clicked
        ft.cv2.namedWindow('manualTracking', ft.cv2.WINDOW_AUTOSIZE)
        ft.cv2.setWindowTitle('manualTracking', f'MT, frame #: {currentFrame}')
        # ft.cv2.namedWindow(f'ManualTracking; frame #: {currentFrame}', ft.cv2.WINDOW_AUTOSIZE)
        ft.cv2.setMouseCallback('manualTracking', click)
        # ft.cv2.setMouseCallback(f'ManualTracking; frame #: {currentFrame}', click)

        #if currentFrame > firstFrame:
        if len(posY) > 0:
            for n in range(nClicks):
                if self.showLines_MT.isChecked() == True:
                    ft.cv2.line(frameCrop, (0, int(posY[str(n + 1)][0])), (int(
                        self.roiThreeIn.text()), int(posY[str(n + 1)][0])),
                                (0, 245, 184), 2)

        ft.cv2.imshow('manualTracking', frameCrop)
        # ft.cv2.imshow(f'ManualTracking; frame #: {currentFrame}',frameCrop)

        self.msgLabel.setText('Tracking started, press (Esc) to quit.')
        for n in range(nClicks):
            # wait for the mouse event or 'escape' key
            while (True):
                if clk == True:
                    clk = False
                    # the zero location changes based on the flame direction

                    if self.directionBox.currentText() == 'Left to right':
                        xClick = xPos + int(self.roiOneIn.text())
                    elif self.directionBox.currentText() == 'Right to left':
                        xClick = self.vWidth - int(self.roiOneIn.text()) - xPos
                    break

                if ft.cv2.waitKey(1) == 27:  #ord('q')
                    ft.cv2.destroyAllWindows()
                    return

            # update each position and frame list for the current click
            if str(n + 1) in posX:
                posX[str(n + 1)].append(xClick)
                posX_mm[str(n + 1)].append(xClick / float(self.scaleIn.text()))
                posY[str(n + 1)].append(yPos)
                posY_mm[str(n + 1)].append(yPos / float(self.scaleIn.text()))
                if n == 0:  #frames and time are the same for all the clicks
                    frameCount[str(n + 1)].append(currentFrame)
                    timeCount[str(n + 1)].append(currentFrame /
                                                 float(self.vFpsLbl.text()))

            else:
                posX[str(n + 1)] = [xClick]
                posX_mm[str(n + 1)] = [xClick / float(self.scaleIn.text())]
                posY[str(n + 1)] = [yPos]
                posY_mm[str(n + 1)] = [yPos / float(self.scaleIn.text())]
                if n == 0:  #frames and time are the same for all the clicks
                    frameCount[str(n + 1)] = [currentFrame]
                    timeCount[str(n + 1)] = [
                        currentFrame / float(self.vFpsLbl.text())
                    ]

        currentFrame = currentFrame + 1 + int(self.skipFrameIn.text())
    print('Tracking completed')
    self.msgLabel.setText('Tracking completed')

    if len(timeCount) == 0:
        msg = ft.QMessageBox(self)
        msg.setText(
            'No frames were detected, please check ROI size and light settings.'
        )
        msg.exec()

    ft.cv2.destroyAllWindows()

    self.posX_px = posX
    self.posX_plot = posX_mm
    self.frames_plot = frameCount
    self.time_plot = timeCount
    # moving average of the spread rate values
    self.spreadRate = dict()
    # if scale:
    for n in range(nClicks):
        for i in range(len(timeCount['1']) - 1):
            xCoeff = ft.np.polyfit(timeCount['1'][(i):(i + 2)],
                                   posX_mm[str(n + 1)][(i):(i + 2)], 1)
            spreadRate = xCoeff[0]
            if str(n + 1) in self.spreadRate:
                self.spreadRate[str(n + 1)].append(spreadRate)
            else:
                self.spreadRate[str(n + 1)] = [spreadRate]
        #repeat the last value
        self.spreadRate[str(n + 1)].append(xCoeff[0])

    self.lbl2_MT.clear()
    self.lbl2_MT.addLegend(
        offset=[1, 0.1]
    )  # background color modified in line 122 and 123 of python3.7/site-packages/pyqtgraph/graphicsItems
    color = ['b', 'r', 'k', 'g', 'c', 'y']
    for n in range(nClicks):
        name = 'click{}'.format([n + 1])
        try:
            clr = color[n]
        except:
            if n > len(color):
                self.msgLabel.setText('Not enough colors for plotting.')

        xPlot1, yPlot1 = selectAxes(self, xAxis_lbl1, yAxis_lbl1, n)
        xPlot2, yPlot2 = selectAxes(self, xAxis_lbl2, yAxis_lbl2, n)
        # manualTrackingPlot(self.lbl1_MT, self.time_plot['1'], self.posX_plot[str(n+1)], name, 'o', clr)
        manualTrackingPlot(self.plot1_MT, xPlot1, yPlot1, name, 'o', clr)
        # manualTrackingPlot(self.lbl2_MT, self.time_plot['1'], self.spreadRate[str(n+1)], name, 'o', clr)
        manualTrackingPlot(self.lbl2_MT, xPlot2, yPlot2, name, 'o', clr)

    self.plot1_MT.show()
    self.win1_MT.setCurrentIndex(1)
def RGBTracking(self):
    scale = True
    if not self.scaleIn.text():
        scale = False
        msg = ft.QMessageBox(self)
        msg.setText('The scale [px/mm] has not been specified')
        msg.exec()

    firstFrame = int(self.firstFrameIn.text())
    lastFrame = int(self.lastFrameIn.text())
    self.connectivity = self.connectivityGroup.checkedAction()
    self.connectivity = self.connectivity.text()

    currentFrame = firstFrame
    self.xRight_px = list()
    self.xLeft_px = list()
    self.xRight_mm = list()
    self.xLeft_mm = list()
    flameLength_mm = list()
    self.frameCount = list()
    flameArea = list()

    if self.exportVideo_RT.isChecked():
        fps = (float(self.vFps)) / (int(self.skipFrameIn.text()) + 1)
        vName = self.fPath + '-trackedVideo.' + str(self.vFormat)
        fourcc = ft.cv2.VideoWriter_fourcc(*self.codec)
        size = (int(self.roiThreeIn.text()), int(self.roiFourIn.text()))
        # open and set properties
        vout = ft.cv2.VideoWriter()
        vout.open(vName, fourcc, fps, size, True)

    if scale:  #this condition prevents crashes in case the scale is not specified
        xAxis_lbl1 = self.xAxis_lbl1.currentText()
        yAxis_lbl1 = self.yAxis_lbl1.currentText()
        xAxis_lbl2 = self.xAxis_lbl2.currentText()
        yAxis_lbl2 = self.yAxis_lbl2.currentText()
        while (currentFrame < lastFrame):
            # print('Frame #:', currentFrame)
            frame, frameCrop = ft.checkEditing(self, currentFrame)
            if self.filterLight_RT.isChecked() == True:
                if self.lightROI_RT_recorded == True:  #beta
                    # looking for frames with a light on (which would increase the red and green channel values of the background)
                    low = ([5, 5, 10])  # blueLow, greenLow, redLow
                    high = ([255, 255, 255])  # blueHigh, greenHigh, redHigh
                    low = ft.np.array(
                        low, dtype='uint8')  #this conversion is necessary
                    high = ft.np.array(high, dtype='uint8')
                    currentLightROI = frame[self.lightROI_RT[1]:(
                        self.lightROI_RT[1] +
                        self.lightROI_RT[3]), self.lightROI_RT[0]:(
                            self.lightROI_RT[0] + self.lightROI_RT[2])]
                    newMask = ft.cv2.inRange(currentLightROI, low, high)
                    frame_light = ft.cv2.bitwise_and(currentLightROI,
                                                     currentLightROI,
                                                     mask=newMask)
                    grayFrame_light = ft.cv2.cvtColor(frame_light,
                                                      ft.cv2.COLOR_BGR2GRAY)
                    (thresh_light,
                     frameBW_light) = ft.cv2.threshold(grayFrame_light, 0, 255,
                                                       ft.cv2.THRESH_BINARY)
                    flamePx_light = ft.np.where(frameBW_light == [255])  #beta
                    area_lightROI = int(self.lightROI_RT[3] *
                                        self.lightROI_RT[2])
                else:
                    msg = ft.QMessageBox(self)
                    msg.setText(
                        'Before the tracking, please click on "Pick a bright region" to select a region where the light is visible.'
                    )
                    msg.exec()
                    break

                if len(
                        flamePx_light[0]
                ) < 0.5 * area_lightROI:  #if the bright area is larger than the ROI area
                    getFilteredFrame(self, frameCrop)
                else:
                    currentFrame = currentFrame + 1 + int(
                        self.skipFrameIn.text())
                    continue
            else:
                getFilteredFrame(self, frameCrop)

            self.xRight_px.append(self.xRight)
            self.xLeft_px.append(self.xLeft)
            self.xRight_mm.append(self.xRight / float(self.scaleIn.text()))
            self.xLeft_mm.append(self.xLeft / float(self.scaleIn.text()))
            flameArea.append(self.flameArea)
            self.frameCount.append(currentFrame)
            if self.exportVideo_RT.isChecked():
                vout.write(self.currentFrameRGB_RT)
            print('Progress: ',
                  round((currentFrame - firstFrame) /
                        (lastFrame - firstFrame) * 10000) / 100,
                  '%',
                  '(Frame #: ',
                  currentFrame,
                  ')',
                  end='\r')
            currentFrame = currentFrame + 1 + int(self.skipFrameIn.text())

        try:
            self.flameArea = [
                areaN / (float(self.scaleIn.text())**2) for areaN in flameArea
            ]
            self.flameArea = ft.np.round(self.flameArea, 3)
            self.flameArea = self.flameArea.tolist()
            self.timeCount = [
                frameN / float(self.vFpsLbl.text())
                for frameN in self.frameCount
            ]
        except:
            pass

        for i in range(len(self.xRight_mm)):
            flameLength_mm.append(abs(self.xRight_mm[i] - self.xLeft_mm[i]))

        flameLength_mm = ft.np.round(flameLength_mm, 2)
        self.flameLength_mm = flameLength_mm.tolist()
        print('Progress: 100 % - Tracking completed')
        self.msgLabel.setText('Tracking completed')

        if self.exportVideo_RT.isChecked():
            vout.release()
            self.msgLabel.setText('Tracking completed and video created.')

        # the following approach to calculate the spread rate is the same one used for lumaTracking
        movAvgPt = int(
            self.movAvgIn_RT.text()
        )  #this number is half of the interval considered for the spread rate (movAvgPt = 2 means I am considering a total of 5 points (my point, 2 before and 2 after))
        self.spreadRateRight = list()
        self.spreadRateLeft = list()

        if movAvgPt == 0:
            for i in range(len(self.timeCount) - 1):
                xCoeffRight = ft.np.polyfit(self.timeCount[(i):(i + 2)],
                                            self.xRight_mm[(i):(i + 2)], 1)
                xCoeffLeft = ft.np.polyfit(self.timeCount[(i):(i + 2)],
                                           self.xLeft_mm[(i):(i + 2)], 1)
                self.spreadRateRight.append(xCoeffRight[0])
                self.spreadRateLeft.append(xCoeffLeft[0])
            #repeat the last value
            self.spreadRateRight.append(xCoeffRight[0])
            self.spreadRateLeft.append(xCoeffLeft[0])
        else:  #here we calculate the instantaneous spread rate based on the moving avg. I also included the initial and final points
            for i in range(len(self.timeCount)):
                if i - movAvgPt < 0:
                    xCoeffRight = ft.np.polyfit(
                        self.timeCount[0:(i + movAvgPt + 1)],
                        self.xRight_mm[0:(i + movAvgPt + 1)], 1)
                    xCoeffLeft = ft.np.polyfit(
                        self.timeCount[0:(i + movAvgPt + 1)],
                        self.xLeft_mm[0:(i + movAvgPt + 1)], 1)
                    self.spreadRateRight.append(xCoeffRight[0])
                    self.spreadRateLeft.append(xCoeffLeft[0])
                elif i >= movAvgPt:
                    xCoeffRight = ft.np.polyfit(
                        self.timeCount[(i - movAvgPt):(i + movAvgPt + 1)],
                        self.xRight_mm[(i - movAvgPt):(i + movAvgPt + 1)], 1)
                    xCoeffLeft = ft.np.polyfit(
                        self.timeCount[(i - movAvgPt):(i + movAvgPt + 1)],
                        self.xLeft_mm[(i - movAvgPt):(i + movAvgPt + 1)], 1)
                    self.spreadRateRight.append(xCoeffRight[0])
                    self.spreadRateLeft.append(xCoeffLeft[0])
                elif i + movAvgPt > len(self.timeCount):
                    xCoeffRight = ft.np.polyfit(
                        self.timeCount[(i - movAvgPt):],
                        self.xRight_mm[(i - movAvgPt):], 1)
                    xCoeffLeft = ft.np.polyfit(self.timeCount[(i - movAvgPt):],
                                               self.xLeft_mm[(i - movAvgPt):],
                                               1)
                    self.spreadRateRight.append(xCoeffRight[0])
                    self.spreadRateLeft.append(xCoeffLeft[0])

        self.spreadRateRight = ft.np.round(self.spreadRateRight, 3)
        self.spreadRateRight = self.spreadRateRight.tolist()
        self.spreadRateLeft = ft.np.round(self.spreadRateLeft, 3)
        self.spreadRateLeft = self.spreadRateLeft.tolist()

        self.plot1_RT.setLabel('left', str(yAxis_lbl1), color='black', size=14)
        self.plot1_RT.setLabel('bottom',
                               str(xAxis_lbl1),
                               color='black',
                               size=14)
        self.plot1_RT.getAxis('bottom').setPen(color=(0, 0, 0))
        self.plot1_RT.getAxis('left').setPen(color=(0, 0, 0))
        self.plot1_RT.addLegend(offset=[1, 0.1])
        self.plot2_RT.setLabel('left', str(yAxis_lbl2), color='black', size=14)
        self.plot2_RT.setLabel('bottom',
                               str(xAxis_lbl2),
                               color='black',
                               size=14)
        self.plot2_RT.getAxis('bottom').setPen(color=(0, 0, 0))
        self.plot2_RT.getAxis('left').setPen(color=(0, 0, 0))
        self.plot2_RT.addLegend(offset=[1, 0.1])

        xPlot1, yRight1, yLeft1 = selectAxes(self, xAxis_lbl1, yAxis_lbl1)
        xPlot2, yRight2, yLeft2 = selectAxes(self, xAxis_lbl2, yAxis_lbl2)

        if yAxis_lbl1 == 'Flame length [mm]':
            RGBTrackingPlot(self.plot1_RT, xPlot1, yRight1, 'flame length',
                            'o', 'b')
        elif yAxis_lbl1 == 'Flame area [mm2]':
            RGBTrackingPlot(self.plot1_RT, xPlot1, yRight1, 'flame area', 'o',
                            'b')
        else:
            RGBTrackingPlot(self.plot1_RT, xPlot1, yRight1, 'right edge', 'o',
                            'b')
            RGBTrackingPlot(self.plot1_RT, xPlot1, yLeft1, 'left edge', 't',
                            'r')

        if yAxis_lbl2 == 'Flame length [mm]':
            RGBTrackingPlot(self.plot2_RT, xPlot2, yRight2, 'flame length',
                            'o', 'b')
        elif yAxis_lbl2 == 'Flame area [mm2]':
            RGBTrackingPlot(self.plot2_RT, xPlot2, yRight2, 'flame area', 'o',
                            'b')
        else:
            RGBTrackingPlot(self.plot2_RT, xPlot2, yRight2, 'right edge', 'o',
                            'b')
            RGBTrackingPlot(self.plot2_RT, xPlot2, yLeft2, 'left edge', 't',
                            'r')

        self.win1_RT.setCurrentIndex(
            1)  #to activate the preview tab in the analysis box
        self.win2_RT.setCurrentIndex(1)