example_reconstructmesdk_marker.cpp

Content

This short example shows how to use ReconstructMe SDK together with markers to intuitively position the reconstruction volume. The example reproduces what is shown in our preview video below.

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

#include <boost/test/unit_test.hpp>
#include <stdio.h>
#include <conio.h>
#include <iostream>

#include <reconstructmesdk/reme.h>
BOOST_AUTO_TEST_SUITE(example_reconstructmesdk)
BOOST_AUTO_TEST_CASE(marker_detection) {

    puts("Key mapping");
    puts("s: start scanning. Marker needs to be fully visible in sensor.");
    puts("x: done scanning");    
    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);
    reme_context_set_log_callback(c, reme_default_log_callback, 0);

    // Create a license object
    reme_license_t l;
    reme_license_create(c, &l);
    reme_error_t e = reme_license_authenticate(c, l, "license.txt.sgn");

    // Create options
    reme_options_t o;
    reme_options_create(c, &o);

    // Specify the volume dimensions. We set it in such a way that 
    // when the marker is detected and it becomes the origin of the world,
    // the volume floats centric above the marker and cuts away floor data.
    reme_context_bind_reconstruction_options(c, o);
    reme_options_set_int(c, o, "volume.minimum_corner.x", -200);
    reme_options_set_int(c, o, "volume.minimum_corner.y", -200);
    reme_options_set_int(c, o, "volume.minimum_corner.z", 2);

    reme_options_set_int(c, o, "volume.maximum_corner.x", 200);
    reme_options_set_int(c, o, "volume.maximum_corner.y", 200);
    reme_options_set_int(c, o, "volume.maximum_corner.z", 402);
    reme_options_set_bool(c, o, "data_integration.use_colors", true);

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

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

    // Create a new sensor. For marker detection depth to aux alignment should be enabled,
    // which it is by default.
    reme_sensor_t s;
    reme_sensor_create(c, "openni;mskinect;file", true, &s);
    reme_sensor_open(c, s);

    // Create a marker detector attached to the sensor.
    reme_marker_detector_t md;
    reme_marker_detector_create(c, s, &md);
    reme_marker_detector_bind_options(c, md, o);
    reme_options_set_real(c, o, "marker_size", 90.f); 
    reme_marker_detector_apply_options(c, md, o);

    // Use color in rendering volume image
    reme_sensor_bind_render_options(c, s, o);
    reme_options_set(c, o, "shade_mode", "SHADE_COLORS");
    reme_sensor_apply_render_options(c, s, o);

    // Create viewer and start reconstruction
    reme_viewer_t viewer;
    reme_viewer_create_image(c, "This is ReconstructMe SDK", &viewer);

    reme_image_t volume, aux;
    reme_image_create(c, &volume);
    reme_image_create(c, &aux);

    reme_viewer_add_image(c, viewer, aux);
    reme_viewer_add_image(c, viewer, volume);

    bool done = false;
    bool scan = false;
    bool first = false;
    float marker_pos[16];
    while (!done && REME_SUCCESS(reme_sensor_grab(c, s))) {
        if (_kbhit()) {
            char k = _getch();
            switch (k) {
            case 'x':
                done = true;
                break;
            case 's':
                scan = !scan;
                first = scan;
                break;
            }
        }

        reme_sensor_prepare_images(c, s);
        reme_sensor_get_image(c, s, REME_IMAGE_AUX, aux);
        reme_sensor_get_image(c, s, REME_IMAGE_VOLUME, volume);
        
        if (!scan) {
            // When not yet scanning we search for the marker
            int nmarkers = 0;
            reme_marker_detector_find(c, md, &nmarkers);

            // When we have at least one marker found, we just remember its position
            // and mark it in the image for debug viewing.
            if (nmarkers > 0) {
                reme_marker_detector_get_position(c, md, 0, marker_pos);
                reme_marker_detector_draw_info(c, md, 0, aux);
            }
        } else {
            if (first) {
                // Scanning just started, use remembered marker pose to position camera.
                float inv_marker_pos[16];
                reme_transform_invert(c, marker_pos, inv_marker_pos);
                reme_sensor_set_position(c, s, inv_marker_pos);
                reme_volume_reset(c, v);
                first = false;
            } else {
                // Scanning is already running for a while, do the standard reme thing.
                 if (REME_SUCCESS(reme_sensor_track_position(c, s))) {
                      reme_sensor_update_volume(c, s);
                 }
            }
        }

        reme_viewer_update(c, viewer);
    }

    // Close and destroy the sensor, it is not needed anymore
    reme_sensor_close(c, s);
    reme_sensor_destroy(c, &s);

    // Create surface from volume
    reme_surface_t m;
    reme_surface_create(c, &m);
    reme_surface_generate(c, m, v);

    // Remove small unconnected parts
    reme_surface_cleanup(c, m);

    // Fill holes and make mesh watertight
    reme_surface_poisson(c, m);

    // Prepare to cut the bottom of the surface
    reme_csg_t csg;
    reme_csg_create(c, v, &csg);

    // Keep the color volume, but clear the geometric volume.
    reme_volume_reset_selectively(c, v, true, false);

    // Insert the watertight mesh
    reme_csg_update_with_surface(c, csg, REME_SET_UNION, m);

    // Cut with plane at height 0, parallel to xy.
    float cut_plane[4] = {0, 0, 1, 0};
    reme_csg_update_with_planes(c, csg, REME_SET_SUBTRACTION, cut_plane, 1);

    // In case anything is sticking out of the volume (e.g on top), close it now.
    reme_csg_close_volume_borders(c, csg);

    // Generate the final mesh.
    reme_surface_generate(c, m, v);
    reme_surface_colorize_vertices(c, m, v);
    reme_surface_inpaint_vertices(c, m);

    // Save mesh
    reme_surface_save_to_file(c, m, "test.ply");

    // Visualize resulting surface
    reme_viewer_t viewer_surface;
    reme_viewer_create_surface(c, m, "This is ReconstructMeSDK", &viewer_surface);
    reme_viewer_wait(c, viewer_surface);

    reme_surface_destroy(c, &m);

    // Print pending errors
    reme_context_print_errors(c);

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

}

BOOST_AUTO_TEST_CASE(marker_creation) 
{
    reme_context_t c;
    reme_context_create(&c);

    // Image to hold marker template image
    reme_image_t marker;
    reme_image_create(c, &marker);

    // Marker detector that supplies template image. Note that 
    // the marker detector need to be a valid one.
    reme_marker_detector_t md = -1;
    reme_marker_detector_generate_template_image(c, md, 213, marker);

    // Save image for later printing.
    reme_image_save_to_file(c, marker, "marker_213.png");

    // Display marker inline for debugging purposes.
    reme_viewer_t v;
    reme_viewer_create_image(c, "Marker Viewer", &v);
    reme_viewer_add_image(c, v, marker);
    reme_viewer_update(c, v);
    reme_viewer_wait(c, v);

}

BOOST_AUTO_TEST_SUITE_END()