Question

I’m using processing in conjunction with the kinect to capture point cloud data. My sketch writes the vector locations of the points from the kinect to an array, and uses the PrintWriter class to create text files which store all the points from each frame in separate text files. It includes a conditional that is supposed to stop the print writer from writing, but it continues to write, and eventually hangs up. Any ideas as to what might be wrong? Here’s my code:

When recording:

PVector realWorldPoint; //stores each point as a vector
PVector[] frame = new PVector[arrayLength]; //stores all of the vectors/real world points in an array
int index = 0;

for(int y=0;y < context.depthHeight();y+=steps) //height = 480
{
    for(int x=0;x < context.depthWidth();x+=steps) //width = 640
    {
      if (isRecording == true){
        int offset = x + y * context.depthWidth();
        realWorldPoint = context.depthMapRealWorld()[offset];
        frame[index] = realWorldPoint;
        recording.add(frame);
        index++;
      }
    }
}

AND when saving:

if (isRecording == true){
  isRecording = false;
  println("Stopped Recording");
  Enumeration e = recording.elements();
  int i = 0;
  while (e.hasMoreElements()) {

    // Create one directory
    boolean success = (new File("out"+currentFile)).mkdir(); 
    PrintWriter output = createWriter("out"+currentFile+"/frame" + i++ +".txt");
    PVector [] frame = (PVector []) e.nextElement();

    for (int j = 0; j < frame.length; j++) {
     output.println(j + ", " + frame[j].x + ", " + frame[j].y + ", " + frame[j].z );
    }
    output.flush(); // Write the remaining data
    output.close(); //Doesn't seem to close
  }
  println("done recording"); //NEVER EXECUTES
}

These are big files (about 12,000 lines a piece), and I’m creating about 30 of these a second. Maybe it’s just overloading it so the stop never registers? Also, not sure about the enumeration – this was copied from someone else’s code, but I don’t see documentation on this data type.

Answer 1

I’m not sure why your program doesn’t terminate, but storing the depth data as plain text is definitely a bad idea. Writing 30 files with 12,000 lines each every second is clearly a lot of work, causing many context switches between application and OS.

As an alternative approach to save the data, I suggest writing the frames to a file using the original binary format. This would save a lot of space and write time, since x- and y-coordinates are implied by the structure of the frame, and the z coordinate doesn’t take up 1 byte per digit.

An additional improvement would involve assembling what you’re going to write in memory and writing it to the file at once. Right now, it’s up to the PrintWriter, when to actually write the files to disk – there is no guarantee that it will wait for a call to flush.

According to this, you used Enumeration correctly, so I don’t think there is a problem with that.

Conclusion: It’s likely that the write load causes the program to hang. You will know once writing the data becomes more efficient.