karmaDet's profile - activity

I am trying to track a detected object and the code I am using as follows:

           // if there is a detection
    if (detectedObjectRectanglesPreviousFrame.size() != 0)
    {
        cout << "#: " << detectedObjectRectanglesPreviousFrame.size() << endl;

        //-----------------------------------------------------------
        KalmanFilter KF(4, 2, 0);
        Mat_<float> state(4, 1); /* (x, y, Vx, Vy) */
        Mat processNoise(4, 1, CV_32F);
        Mat_<float> measurement(2, 1);
        measurement.setTo(Scalar(0));
        //-----------------------------------------------------------

        for (int i = 0; i < detectedObjectRectanglesPreviousFrame.size(); i++)
        {
            // Get the center coordinates of the detected object
            int trackedX = detectedObjectRectanglesPreviousFrame[i].x + detectedObjectRectanglesPreviousFrame[i].width / 2;
            int trackedY = detectedObjectRectanglesPreviousFrame[i].y + detectedObjectRectanglesPreviousFrame[i].height / 2;
            cout << "P" << Point(trackedX, trackedY) << endl;

            // if this is the first detection, initialize kalman filter
            if (firstDetection == true)
            {
                //---------------------------------------------------------------------------------------------
                KF.statePre.at<float>(0) = trackedX;
                KF.statePre.at<float>(1) = trackedY;
                KF.statePre.at<float>(2) = 0;
                KF.statePre.at<float>(3) = 0;
                KF.transitionMatrix = *(Mat_<float>(4, 4) << 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
                //KF.transitionMatrix = *(Mat_<float>(4, 4) << 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1);

                setIdentity(KF.transitionMatrix);
                setIdentity(KF.measurementMatrix);
                setIdentity(KF.processNoiseCov, Scalar::all(1e-4));
                setIdentity(KF.measurementNoiseCov, Scalar::all(1e-4));
                setIdentity(KF.errorCovPost, Scalar::all(.1));

                points_vector.clear();
                kalman_vector.clear();
                //---------------------------------------------------------------------------------------------

                cout << "First time-> Initialize: " << trackedX << "," << trackedY << endl;
                firstDetection = false;
            }
            // if not, start tracking
            else
            {
                //---------------------------------------------------------------------------------------------
                Mat prediction = KF.predict();
                Point predictPt(prediction.at<float>(0), prediction.at<float>(1));

                KF.statePre.copyTo(KF.statePost);
                KF.errorCovPre.copyTo(KF.errorCovPost);

                measurement(0) = trackedX;
                measurement(1) = trackedY;

                Point measPt(measurement(0), measurement(1));
                points_vector.push_back(measPt);

                Mat estimated = KF.correct(measurement);
                Point statePt(estimated.at<float>(0), estimated.at<float>(1));
                kalman_vector.push_back(statePt);

                for (int i = 0; i < kalman_vector.size() - 1; i++)
                {
                    line(sourceFrame, kalman_vector[i], kalman_vector[i + 1], Scalar(0, 255, 0), 1);
                }

                for (int j = 0; j < kalman_vector.size(); j++)
                {
                    cout << "Kalman Vector Element: " << kalman_vector[j] << endl;
                }
                //---------------------------------------------------------------------------------------------
            }
        }
    }

And unfortunately, the output I am getting is :

 #: 1
P[261, 259]
First time-> Initialize: 261,259
#: 1
P[260, 259]
Kalman Vector Element: [0, 0]
#: 1
P[258, 260]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
#: 1
P[254, 263]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
#: 1
P[255, 263]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
#: 1
P[254, 262]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
#: 1
P[252, 262]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
#: 1
P[252, 263]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]
Kalman Vector Element: [0, 0]

As you can ... (more)

I am trying to get the coordinate differences of two detected objects in consecutive frames (typical tracking-filtering stuff), I was wondering how can I make use of the previous frame. Here is how my program flow looks like:

captureIn >> sourceFrame;

// do some image processing
processedFrame = process(sourceFrame);
// give me the coordinates of the objects
detectedObjectCoordinates = getCoordinatesOfDetectedObjects(processedFrame);

// Now I want to have a function here as:
isSame = isSameObject(detectedObjectCoordinatesFirstFrame, detectedObjectCoordinatesSecondFrame);

So that I can know whether the detected object is the same object. How to though process consecutive frames, is what I wonder.

Any thoughts on this?

Note: Using OpenCV 2.8.11 with C++.

EDIT: OK, I did some improvement on the code. What I try to do is, trying to eliminate the false positives in a detection algorithm over the frames. To do that, I hold each detection in an object called "obstacle" with a field of "frame consistency". So, if an obstacle has a frame consistency of 5 or more, it is a true positive, otherwise it is a false positive. I try to implement this idea but somehow i keep getting the same frame consistency. Here is the code that I am using:

bool firstDetection = true;

while (true)
{
    // if it is the first launch, get obstacles by doing image processing, otherwise get it from the previous frame's obstacle vector
    if (firstDetection == true)
    {
        captureIn >> sourceFrame;
        if (sourceFrame.empty())
            break;

        // Do some stuff
        process(sourceFrame, clearedFrame, tools, horizonROIFrame, horizonDetector, preProcessedFrame, absoluteGradientY, markedFrame, searchFrame, processFrame);
       // Get the obstacles into the first vector
        detectedObstaclesPreviousFrame = tools->createBoundingBoxesAroundContours(processFrame, clearedFrame);
        firstDetection = false;
    }
    else
    {
        // If it is not the first detection, then put the current one into previous one
        detectedObstaclesPreviousFrame = detectedObstaclesCurrentFrame;
    }

    // Get the second frame
    captureIn >> nextFrame;
    if (nextFrame.empty())
        break;


    // Do the same stuff on this frame as well
    process(nextFrame, clearedFrame, tools, horizonROIFrame, horizonDetector, preProcessedFrame, absoluteGradientY, markedFrame, searchFrame, processFrame);
    //  // Get the obstacles into the second vector this time
    detectedObstaclesCurrentFrame = tools->createBoundingBoxesAroundContours(processFrame, clearedFrame);

    // If there is a detection for both frames ( so that their vectors aren't empty )
    if (detectedObstaclesPreviousFrame.size() != 0)
    {
        if (detectedObstaclesCurrentFrame.size() != 0)
        {
            // Loop over both detection arrays
            for (int a = 0; a < detectedObstaclesPreviousFrame.size(); a++)
            {
                for (int b = 0; b < detectedObstaclesCurrentFrame.size(); b++)
                {
                    // Check if the objects are the same, if not, it means we have another detection here
                    // If they are the same obstacle, increase one's frameconsistency
                    if (isSameObstacle(detectedObstaclesPreviousFrame[a], detectedObstaclesCurrentFrame[b]) == true)
                    {       detectedObstaclesCurrentFrame[b].setFrameConsistency(detectedObstaclesCurrentFrame[b].getFrameConsistency() + 1);
                        cout << "F.C: " << detectedObstaclesCurrentFrame[b].getFrameConsistency() << endl;
                    }
                }
            }
        }

However the output I get is:

F.C: 1
F.C: 1
F.C: 2
F.C: 2
F.C: 1
F.C: 1
F.C: 2
F.C: 2
F.C: 1
F.C: 1
F.C: 2
F.C: 2
F.C: 1
F.C: 1
F.C: 2
F.C: 2
F.C: 1
F.C: 1

Which means it does not even save the frameconsistency of the detected object. I am stuck at this point, any thoughts on it? I tried to ... (more)