example_reconstructmesdk_scan_tilt.cpp

Content

Shows how to use to tilt moter of a Microsoft Kinect for Windows while scanning.

Boost is only used to generate examples and is not necessary for working with this SDK.

#include <boost/test/unit_test.hpp>

#include <reconstructmesdk/reme.h>
#include <stdio.h>
#include <conio.h>

BOOST_AUTO_TEST_SUITE(example_reconstructmesdk)

void perform_tilt(reme_context_t c, reme_sensor_t s, reme_options_t o, int angle);

BOOST_AUTO_TEST_CASE(scan_tilt)
{
  puts("Key mapping");
  puts("x: quit scanning");
  puts("r: reset volume to empty state");
  puts("f: tilt +10 degrees");
  puts("b: tilt -10 degrees");
  puts("All keys need to be pressed with the command line in the foreground");

  // Create a new context
  reme_context_t c;
  reme_context_create(&c);

  // Compile for OpenCL device using defaults
  reme_context_compile(c);

  // Create a new volume
  reme_volume_t v;
  reme_volume_create(c, &v);

  // Create a new sensor
  reme_sensor_t s;
  reme_sensor_create(c, "mskinect", true, &s);
  reme_sensor_open(c, s);
  reme_sensor_set_prescan_position(c, s, REME_SENSOR_POSITION_INFRONT);
  
  // Bind capture options
  reme_options_t o;
  reme_options_create(c, &o);
  reme_sensor_bind_capture_options(c, o, s);

  // Set tilt angle to zero
  reme_options_clear(c, o);
  reme_options_set_int(c, o, "tilt_angle", 0);
  reme_sensor_apply_capture_options(c, s, o);

  // Bind tracking options
  reme_options_t ot;
  reme_options_create(c, &ot);
  reme_context_bind_reconstruction_options(c, ot);

  reme_viewer_t viewer;
  reme_viewer_create_image(c, "This is ReconstructMeSDK", &viewer);

  reme_image_t imgs[2];
  reme_image_create(c, &imgs[0]);
  reme_image_create(c, &imgs[1]);

  reme_viewer_add_image(c, v, imgs[0]);
  reme_viewer_add_image(c, v, imgs[1]);

  bool continue_scanning = true;

  // After each tilt we skip a couple of frames
  int skip_frame_counter = 0;
  while (continue_scanning && REME_SUCCESS(reme_sensor_grab(c, s))) {

    // Keyboard handling
    if (_kbhit()) { 
      char k = _getch();
      switch(k) {

        // Key 'r' resets the volume to empty state
        case 'r': {
          reme_volume_reset(c, v);
          reme_sensor_reset(c, s);
          break;
                  }

        // Key 'f' tilt +10 degrees
        case 'f': {
          perform_tilt(c, s, o, 10);
          reme_sensor_set_trackhint(c, s, REME_SENSOR_TRACKHINT_USE_GLOBAL);
          break;
                  }

        // Key 'b' tilt -10 degrees
        case 'b': {
          perform_tilt(c, s, o, -10);
          reme_sensor_set_trackhint(c, s, REME_SENSOR_TRACKHINT_USE_GLOBAL);
          skip_frame_counter = 10;
          break;
                  }

        case 'x': {
          continue_scanning = false;
          break;
                  }

      }
    }

    // Prepare image and depth data
    reme_sensor_prepare_images(c, s);

    if (skip_frame_counter == 0) {
      if (REME_SUCCESS(reme_sensor_track_position(c, s))) {
        reme_sensor_update_volume(c, s);
      }
    } else {
      skip_frame_counter -= 1;
    }

    // Update the viewer
    reme_sensor_get_image(c, s, REME_IMAGE_DEPTH, imgs[0]);
    reme_sensor_get_image(c, s, REME_IMAGE_VOLUME, imgs[1]);
    reme_viewer_update(c, viewer);

  }

  // Print pending errors
  reme_context_print_errors(c);

  // Make sure to release all memory acquired
  reme_context_destroy(&c);

}

// Perform the tilt and compensate for it. 
// After tilting a couple of frames should be skipped to compensate for bad data.
void perform_tilt(reme_context_t c, reme_sensor_t s, reme_options_t o, int angle)
{
  // Read current angle
  reme_sensor_bind_capture_options(c, s, o);
  int prev_angle;
  reme_options_get_int(c, o, "tilt_angle", &prev_angle);
          
  // Apply tilt
  reme_options_clear(c, o);
  reme_options_set_int(c, o, "tilt_angle", prev_angle + angle);
  reme_sensor_apply_capture_options(c, s, o);

  // Read tilt angle again to determine to determine actual movement
  reme_sensor_bind_capture_options(c, s, o);
  int new_angle;
  reme_options_get_int(c, o, "tilt_angle", &new_angle);

  // Compensate for tilt in sensor position
  float pos[16];
  reme_sensor_get_position(c, s, pos);
  reme_transform_compensate_tilt(c, pos, new_angle - prev_angle, pos);
  reme_sensor_set_position(c, s, pos);
}

BOOST_AUTO_TEST_SUITE_END()