How to write the position (x,y) of the object being tracked into text file?
<p>I am trying to record the position(x,y) of the object being tracked into text file.
I am using opencv and c++ visual 2010. till now i can save a data but this data is the initial position but repeated. i want it to save the actual position at every frame.</p>

<p>In short, how can i write the exact data writen by PutText() on the screen but to a file?
see what puttext() write to the screen</p>

<pre><code> //write the position of the object to the screen
 putText(framein,"Tracking object at (" +   intToString(x)+","+intToString(y)+")",Point(x,y),1,1,Scalar(255,0,0),2);
</code></pre>

<p>I think the problem is in this portion:</p>

<pre><code>//save position
ofstream file_;
file_.open("position.txt");
file_ &lt;&lt;"these are the position pattern made by the foreground object \n";
for( int count = -1; count &lt; 10000; count++ )
{
    file_ &lt;&lt;"X:"&lt;&lt;intToString(x)&lt;&lt;"  "&lt;&lt;"Y:"&lt;&lt;intToString(y)&lt;&lt;"\n";


}
file_.close();  
</code></pre>

<p>the full code is this:</p>

<pre><code> #include &lt; opencv2/opencv.hpp&gt;
 #include &lt; opencv2/core/core.hpp&gt;
 #include &lt; opencv2/highgui/highgui.hpp&gt;
 #include &lt; opencv2/video/background_segm.hpp&gt;
 #include &lt; opencv2/imgproc/imgproc.hpp&gt;
 #include &lt; opencv2/video/video.hpp&gt;
//#include &lt; opencv2/videoio.hpp&gt;
//#include &lt; opencv2/imgcodecs.hpp&gt;
//C
#include &lt;stdio.h&gt;
//C++
#include &lt;iostream&gt;
#include &lt;sstream&gt;
#include &lt;fstream&gt;

using namespace cv;
using namespace std;

//global variables
cv::Mat fg_mask;
cv::Mat frame;
cv::Mat binaryImage;
cv::Mat ContourImg;
Ptr&lt;BackgroundSubtractor&gt; pMOG; //MOG Background subtractor
int keyboard; //input from keyboard
//we'll have just one object to search for
//and keep track of its position.
int theObject[2] = {0,0};
//bounding rectangle of the object, we will use the center of this as its    position.
Rect objectBoundingRectangle = Rect(0,0,0,0);
//our sensitivity value to be used 
const static int SENSITIVITY_VALUE = 50;

string intToString(int number){

//this function has a number input and string output
std::stringstream ss;
ss &lt;&lt; number;
return ss.str();
 }
 void searchForMovement(Mat binaryImage, Mat &amp;framein){
//notice how we use the '&amp;' operator for objectDetected and cameraFeed. This    is because we wish
 //to take the values passed into the function and manipulate them, rather t  han just working with a copy.
 //eg. we draw to the cameraFeed to be displayed in the main() function.
bool objectDetected = false;
Mat temp;
binaryImage.copyTo(temp);
//these two vectors needed for output of findContours
vector&lt; vector&lt;Point&gt; &gt; contours;
vector&lt;Vec4i&gt; hierarchy;
//find contours of filtered image using openCV findContours function
//findContours(temp,contours,hierarchy,CV_RETR_CCOMP,CV_CHAIN_APPROX_SIMPLE );// retrieves all contours
findContours(temp,contours,hierarchy,CV_RETR_EXTERNAL,CV_CHAIN_APPROX_SIMPLE );// retrieves external contours

//if contours vector is not empty, we have found some objects
if(contours.size()&gt;0)objectDetected=true;
else objectDetected = false;

 if(objectDetected){
    //the largest contour is found at the end of the contours vector
    //we will simply assume that the biggest contour is the object we are looking for.
    vector&lt; vector&lt;Point&gt; &gt; largestContourVec;
    largestContourVec.push_back(contours.at(contours.size()-1));
    //make a bounding rectangle around the largest contour then find its centroid
    //this will be the object's final estimated position.
    objectBoundingRectangle = boundingRect(largestContourVec.at(0));
    int xpos = objectBoundingRectangle.x+objectBoundingRectangle.width/2;
    int ypos = objectBoundingRectangle.y+objectBoundingRectangle.height/2;

    //update the objects positions by changing the 'theObject' array values
    theObject[0] = xpos , theObject[1] = ypos;
}
//make some temp x and y variables so we dont have to type out so much
int x = theObject[0];
int y = theObject[1];

//draw some crosshairs around the object
circle(framein,Point(x,y),20,Scalar(0,255,0),2);
line(framein,Point(x,y),Point(x,y-25),Scalar(0,255,0),2);
line(framein,Point(x,y),Point(x,y+25),Scalar(0,255,0),2);
line(framein,Point(x,y),Point(x-25,y),Scalar(0,255,0),2);
line(framein,Point(x,y),Point(x+25,y),Scalar(0,255,0),2);

//write the position of the object to the screen
putText(framein,"Tracking object at (" + intToString(x)+","+intToString(y)+")",Point(x,y),1,1,Scalar(255,0,0),2);

//save position
ofstream file_;
file_.open("position.txt");
file_ &lt;&lt;"these are the position pattern made by the foreground object \n";
for( int count = -1; count &lt; 10000; count++ )
{
    file_ &lt;&lt;"X:"&lt;&lt;intToString(x)&lt;&lt;"  "&lt;&lt;"Y:"&lt;&lt;intToString(y)&lt;&lt;"\n";


}
file_.close();
//std::cin.get();


  }

   void morphOps(Mat &amp;thresh){

    //create structuring element that will be used to "dilate" and "erode" image.
   //the element chosen here is a 3px by 3px rectangle

  Mat erodeElement = getStructuringElement( MORPH_RECT,Size(2,2)); //3x3
  //dilate with larger element so make sure object is nicely visible
  Mat dilateElement = getStructuringElement( MORPH_RECT,Size(1,1)); //8x8

    erode(thresh,thresh,erodeElement);
   erode(thresh,thresh,erodeElement);


   dilate(thresh,thresh,dilateElement);
   dilate(thresh,thresh,dilateElement);

   }
 int main(int, char**)
 {
//some boolean variables for added functionality
bool objectDetected = false;
//these two can be toggled by pressing 'd' or 't'
bool debugMode = true;
bool trackingEnabled = true;
//pause and resume code
bool pause = false;
//video capture object.
VideoCapture capture;
while(1){

    //we can loop the video by re-opening the capture every time the video reaches its last frame

    capture.open("Video_003.avi");
    //capture.open(0);

    if(!capture.isOpened()){
        cout&lt;&lt;"ERROR ACQUIRING VIDEO FEED\n";   
        getchar();
        return -1;
    }
    double fps = capture.get(CV_CAP_PROP_FPS); //get the frames per seconds of the video
     cout &lt;&lt; "Frame per seconds : " &lt;&lt; fps &lt;&lt; endl;

pMOG = new BackgroundSubtractorMOG();

 //morphology element  
 Mat element = getStructuringElement(MORPH_RECT, Size(7, 7), Point(3,3) );

int count = -1;

 //check if the video has reach its last frame.
    //we add '-1' because we are reading two frames from the video at a time.
    //if this is not included, we get a memory error!
    while(capture.get(CV_CAP_PROP_POS_FRAMES) &lt;capture.get(CV_CAP_PROP_FRAME_COUNT)-1){
    // Get frame from camera
        capture.read(frame);
    // Update counter
    ++count;
    //Resize  
 resize(frame, frame, Size(frame.size().width/2, frame.size().height/2) );
    //Blur  
    blur(frame, frame, Size(5,5) );

    // Background subtraction
    pMOG-&gt;operator()(frame, fg_mask,0.05);

    ////////
    //pre procesing  
    //1 point delete    
     morphologyEx(fg_mask, binaryImage, CV_MOP_CLOSE, element);  

     // threshold
     //threshold intensity image at a given sensitivity value
             cv::threshold(binaryImage,binaryImage,SENSITIVITY_VALUE,255,THRESH_BINARY);
        morphOps(binaryImage);

     if(debugMode==true){

    imshow("frame", frame);
    imshow("fg_mask", fg_mask);
    imshow("final", binaryImage);
    }else{
            //if not in debug mode, destroy the windows so we don't see them anymore
            cv::destroyWindow("frame");
            cv::destroyWindow("fg_mask");
            cv::destroyWindow("final");
     }

     //if tracking enabled, search for contours in our thresholded image
        if(trackingEnabled){

            searchForMovement(binaryImage,frame);

     //Find contour  
  ContourImg = binaryImage.clone();  
  //less blob delete  
  vector&lt; vector&lt; Point&gt; &gt; contours;  

   findContours(ContourImg,  
        contours, // a vector of contours  
       CV_RETR_EXTERNAL, // retrieve the external contours  
       CV_CHAIN_APPROX_NONE); // all pixels of each contours  


 vector&lt; Rect &gt; output;  
  vector&lt; vector&lt; Point&gt; &gt;::iterator itc= contours.begin();  
  while (itc!=contours.end()) {  

 //Create bounding rect of object  
 //rect draw on origin image  
 Rect mr= boundingRect(Mat(*itc));  
 rectangle(frame, mr, CV_RGB(255,0,0));  
 ++itc;  
  }  
        }
        imshow("frame", frame);
    // Save foreground mask
    string name = "mask_" + std::to_string(static_cast&lt;long long&gt;(count)) + ".png";
    imwrite("D:\\SO\\temp\\" + name, fg_mask);

    switch(waitKey(10)){

        case 27: //'esc' key has been pressed, exit program.
            return 0;
        case 116: //'t' has been pressed. this will toggle tracking
            trackingEnabled = !trackingEnabled;
            if(trackingEnabled == false) cout&lt;&lt;"Tracking disabled."&lt;&lt;endl;
            else cout&lt;&lt;"Tracking enabled."&lt;&lt;endl;
            break;
        case 100: //'d' has been pressed. this will debug mode
            debugMode = !debugMode;
            if(debugMode == true) cout&lt;&lt;"Debug mode enabled."&lt;&lt;endl;
            else cout&lt;&lt;"Debug mode disabled."&lt;&lt;endl;
            break;
        case 112: //'p' has been pressed. this will pause/resume the code.
            pause = !pause;
            if(pause == true){ cout&lt;&lt;"Code paused, press 'p' again to resume"&lt;&lt;endl;
            while (pause == true){
                //stay in this loop until 
                switch (waitKey()){
                    //a switch statement inside a switch statement? Mind blown.
                case 112: 
                    //change pause back to false
                    pause = false;
                    cout&lt;&lt;"Code Resumed"&lt;&lt;endl;
                    break;
                }

}
// the camera will be deinitialized automatically in VideoCapture destructor

            }
    }
    }
    //release the capture before re-opening and looping again.
    capture.release();
    }
     return 0;
    }
</code></pre>