287 lines
8.3 KiB
Text
287 lines
8.3 KiB
Text
/*
|
|
* scan_io_rxp implementation
|
|
*
|
|
* Copyright (C) Thomas Escher, Kai Lingemann, Andreas Nuechter
|
|
*
|
|
* Released under the GPL version 3.
|
|
*
|
|
*/
|
|
|
|
/**
|
|
* @file
|
|
* @brief Implementation of reading 3D scans
|
|
* @author Kai Lingemann. Institute of Computer Science, University of Osnabrueck, Germany.
|
|
* @author Andreas Nuechter. Institute of Computer Science, University of Osnabrueck, Germany.
|
|
* @author Thomas Escher
|
|
*/
|
|
|
|
#include "scanio/scan_io_rxp.h"
|
|
#include "riegl/scanlib.hpp"
|
|
|
|
#include <iostream>
|
|
using std::cout;
|
|
using std::cerr;
|
|
using std::endl;
|
|
#include <vector>
|
|
|
|
#ifdef _MSC_VER
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
#include <boost/filesystem/operations.hpp>
|
|
#include <boost/filesystem/fstream.hpp>
|
|
using namespace boost::filesystem;
|
|
|
|
#include "slam6d/globals.icc"
|
|
|
|
using namespace scanlib;
|
|
using namespace std;
|
|
using namespace std::tr1;
|
|
|
|
|
|
|
|
#define DATA_PATH_PREFIX "scan"
|
|
#define DATA_PATH_SUFFIX ".rxp"
|
|
#define POSE_PATH_PREFIX "scan"
|
|
#define POSE_PATH_SUFFIX ".pose"
|
|
|
|
/*
|
|
TODO: this file is still work in progress for change to the new scanserver workflow
|
|
this ScanIO has to distinguish a multi scan file and a directory of single scan files and is currently very messy handling these with the importer class
|
|
*/
|
|
|
|
|
|
|
|
std::list<std::string> ScanIO_rxp::readDirectory(const char* dir_path, unsigned int start, unsigned int end)
|
|
{
|
|
std::list<std::string> identifiers;
|
|
|
|
path pose(dir_path);
|
|
if(is_regular_file(pose)) {
|
|
// TODO: create identifiers for this case
|
|
// a) from start to end, requires sanity checks and goodwill of user
|
|
// b) iterate through the file and get last index
|
|
// c) check last index by other means through the riegl api?
|
|
// TEMP: implementing a) without sanity checks :)
|
|
for(unsigned int i = start; i < end; ++i) {
|
|
identifiers.push_back(to_string(i,3));
|
|
}
|
|
} else {
|
|
for(unsigned int i = start; i <= end; ++i) {
|
|
// identifier is /d/d/d (000-999)
|
|
std::string identifier(to_string(i,3));
|
|
// scan consists of data (.3d) and pose (.pose) files
|
|
path data(dir_path);
|
|
data /= path(std::string(DATA_PATH_PREFIX) + identifier + DATA_PATH_SUFFIX);
|
|
path pose(dir_path);
|
|
pose /= path(std::string(POSE_PATH_PREFIX) + identifier + POSE_PATH_SUFFIX);
|
|
// stop if part of a scan is missing or end by absence is detected
|
|
if(!exists(data) || !exists(pose))
|
|
break;
|
|
identifiers.push_back(identifier);
|
|
}
|
|
}
|
|
return identifiers;
|
|
}
|
|
|
|
void ScanIO_rxp::readPose(const char* dir_path, const char* identifier, double* pose)
|
|
{
|
|
unsigned int i;
|
|
|
|
path pose_path(dir_path);
|
|
|
|
// if the directory actually marks a (multi scan) file, return zero pose
|
|
// TODO: test if pose_path gets constructed correctly, see removal of trailing / in the old code
|
|
if(is_regular_file(pose_path.string())) {
|
|
for(i = 0; i < 6; ++i) pose[i] = 0.0;
|
|
return;
|
|
}
|
|
|
|
pose_path /= path(std::string(POSE_PATH_PREFIX) + identifier + POSE_PATH_SUFFIX);
|
|
if(!exists(pose_path))
|
|
throw std::runtime_error(std::string("There is no pose file for [") + identifier + "] in [" + dir_path + "]");
|
|
|
|
// open pose file
|
|
boost::filesystem::ifstream pose_file(pose_path);
|
|
|
|
// if the file is open, read contents
|
|
if(pose_file.good()) {
|
|
// read 6 plain doubles
|
|
for(i = 0; i < 6; ++i) pose_file >> pose[i];
|
|
pose_file.close();
|
|
|
|
// convert angles from deg to rad
|
|
for(i = 3; i < 6; ++i) pose[i] = rad(pose[i]);
|
|
} else {
|
|
throw std::runtime_error(std::string("Pose file could not be opened for [") + identifier + "] in [" + dir_path + "]");
|
|
}
|
|
}
|
|
|
|
bool ScanIO_rxp::supports(IODataType type)
|
|
{
|
|
return !!(type & (DATA_XYZ | DATA_REFLECTANCE | DATA_AMPLITUDE | DATA_DEVIATION | DATA_TYPE));
|
|
}
|
|
|
|
void ScanIO_rxp::readScan(const char* dir_path, const char* identifier, PointFilter& filter, std::vector<double>* xyz, std::vector<unsigned char>* rgb, std::vector<float>* reflectance, std::vector<float>* amplitude, std::vector<int>* type, std::vector<float>* deviation)
|
|
{
|
|
|
|
path data_path(dir_path);
|
|
|
|
// distinguish file and directory
|
|
if(is_regular_file(data_path)) {
|
|
stringstream str(identifier);
|
|
int scan_index;
|
|
str >> scan_index;
|
|
// first clean up if they "directory" has changed
|
|
// second case of resetting: rewinding index in case of non-sequential index access
|
|
if(old_path != dir_path || (imp != 0 && imp->getCurrentScan() > scan_index)) {
|
|
// TODO: I'm assuming here that I can simply do this
|
|
if(rc != 0) { rc->close(); }
|
|
if(dec != 0) { delete dec; dec = 0; }
|
|
if(imp != 0) { delete imp; imp = 0; }
|
|
// TODO ^
|
|
}
|
|
// create directory-persistent decoder
|
|
if (!dec) {
|
|
// remember path
|
|
old_path = dir_path;
|
|
|
|
// create new connection
|
|
rc = basic_rconnection::create(data_path.string());
|
|
rc->open();
|
|
|
|
// decoder splits the binary file into readable chunks
|
|
dec = new decoder_rxpmarker(rc);
|
|
// importer interprets the chunks
|
|
// TODO: this won't really work because filter is gone and xyz too and everything breaks
|
|
// probably set new filter and xyz in the importer
|
|
imp = new importer(filter, scan_index, xyz, reflectance, amplitude, type, deviation);
|
|
}
|
|
|
|
// set new filter and vectors
|
|
imp->set(filter, xyz, reflectance, amplitude, type, deviation);
|
|
|
|
buffer buf;
|
|
|
|
// skip the first scans
|
|
if(imp->getCurrentScan() < scan_index) {
|
|
for(dec->get(buf); !dec->eoi(); dec->get(buf)) {
|
|
imp->dispatch(buf.begin(), buf.end());
|
|
if(imp->getCurrentScan() >= scan_index) break;
|
|
}
|
|
}
|
|
if(dec->eoi()) return;
|
|
int cscan = imp->getCurrentScan();
|
|
// iterate over chunks, until the next scan is reached
|
|
for(dec->get(buf); !dec->eoi(); dec->get(buf)) {
|
|
imp->dispatch(buf.begin(), buf.end());
|
|
if(imp->getCurrentScan() != cscan) break;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// error handling
|
|
data_path /= path(std::string(DATA_PATH_PREFIX) + identifier + DATA_PATH_SUFFIX);
|
|
if(!exists(data_path))
|
|
throw std::runtime_error(std::string("There is no scan file for [") + identifier + "] in [" + dir_path + "]");
|
|
|
|
if(xyz != 0) {
|
|
string data_path_str;
|
|
data_path_str = "file://" + data_path.string();
|
|
rc = basic_rconnection::create(data_path_str);
|
|
rc->open();
|
|
|
|
// decoder splits the binary file into readable chunks
|
|
dec = new decoder_rxpmarker(rc);
|
|
// importer interprets the chunks
|
|
imp = new importer(filter, 0, xyz, reflectance, amplitude, type, deviation);
|
|
|
|
// iterate over chunks
|
|
buffer buf;
|
|
for(dec->get(buf); !dec->eoi(); dec->get(buf)) {
|
|
imp->dispatch(buf.begin(), buf.end());
|
|
}
|
|
|
|
//done
|
|
rc->close();
|
|
// TODO: clean up all these pointers, aren't they dangling?
|
|
}
|
|
}
|
|
|
|
void importer::on_echo_transformed(echo_type echo)
|
|
{
|
|
// for multi scan files, ignore those before start
|
|
if (currentscan < start) return;
|
|
|
|
// targets is a member std::vector that contains all
|
|
// echoes seen so far, i.e. the current echo is always
|
|
// indexed by target_count-1.
|
|
target& t(targets[target_count - 1]);
|
|
|
|
double point[3];
|
|
point[0] = t.vertex[1]*-100.0;
|
|
point[1] = t.vertex[2]*100.0;
|
|
point[2] = t.vertex[0]*100.0;
|
|
|
|
if(filter->check(point)) {
|
|
if(xyz) {
|
|
for(unsigned int i = 0; i < 3; ++i) xyz->push_back(point[i]);
|
|
}
|
|
if(reflectance) reflectance->push_back(t.reflectance);
|
|
if(amplitude) amplitude->push_back(t.amplitude);
|
|
if(deviation) deviation->push_back(t.deviation);
|
|
if(type) {
|
|
if(pointcloud::first == echo) type->push_back(0);
|
|
else if(pointcloud::interior == echo) type->push_back(1);
|
|
else if(pointcloud::last == echo) type->push_back(10);
|
|
else if(pointcloud::single == echo) type->push_back(9);
|
|
}
|
|
}
|
|
|
|
/*
|
|
// target.reflectance
|
|
// target.amplitude
|
|
// target.deviation
|
|
// target.time
|
|
// target.vertex point coordinates
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* class factory for object construction
|
|
*
|
|
* @return Pointer to new object
|
|
*/
|
|
#ifdef _MSC_VER
|
|
extern "C" __declspec(dllexport) ScanIO* create()
|
|
#else
|
|
extern "C" ScanIO* create()
|
|
#endif
|
|
{
|
|
return new ScanIO_rxp;
|
|
}
|
|
|
|
|
|
/**
|
|
* class factory for object construction
|
|
*
|
|
* @return Pointer to new object
|
|
*/
|
|
#ifdef _MSC_VER
|
|
extern "C" __declspec(dllexport) void destroy(ScanIO *sio)
|
|
#else
|
|
extern "C" void destroy(ScanIO *sio)
|
|
#endif
|
|
{
|
|
delete sio;
|
|
}
|
|
|
|
#ifdef _MSC_VER
|
|
BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, LPVOID lpReserved)
|
|
{
|
|
return TRUE;
|
|
}
|
|
#endif
|