227 lines
7.6 KiB
Text
227 lines
7.6 KiB
Text
/**
|
|
* @file
|
|
* @brief IO of a 3D scan for leica ASCII file format with relectance values.
|
|
* @author Sven Albrecht. Institute of Computer Science, University of Osnabrueck, Germany.
|
|
*/
|
|
|
|
#ifndef __SCAN_IO_CAD_H__
|
|
#define __SCAN_IO_CAD_H__
|
|
|
|
#include <string>
|
|
using std::string;
|
|
#include <vector>
|
|
using std::vector;
|
|
#include <fstream>
|
|
#include <limits>
|
|
#include <algorithm>
|
|
#include <locale>
|
|
|
|
#include "scan_io.h"
|
|
|
|
#include <boost/program_options.hpp>
|
|
#include <boost/filesystem.hpp>
|
|
|
|
namespace po = boost::program_options; // to reduce typing effort
|
|
namespace fs = boost::filesystem; // to reduce typing effort
|
|
|
|
/**
|
|
* @brief 3D scan loader for 1 UOS Scan and multiple .stl files
|
|
*
|
|
* The compiled class is available as shared object file
|
|
*/
|
|
class ScanIO_CAD : public ScanIO {
|
|
|
|
// default values for parameters / flags / etc
|
|
// sampling parameters
|
|
static constexpr bool STD_STORE_CAD = false; // don't save sampling
|
|
static constexpr float STD_SAMPLE_DIST = 0.5f; // point distance of 0.5 (cm)
|
|
static constexpr bool STD_RND_SAMP = true; // use random sampling
|
|
// coordinate order
|
|
static constexpr unsigned int STD_X_INDEX = 0; // cad x coord = uos x coord
|
|
static constexpr unsigned int STD_Y_INDEX = 2; // cad y coord = uos z coord
|
|
static constexpr unsigned int STD_Z_INDEX = 1; // cad z coord = uos y coord
|
|
// scale factors
|
|
static constexpr float STD_SCALE_FACTOR = 0.1f; // general scale factor
|
|
static constexpr float STD_X_SCALE = 0.1f; // scale for x axis
|
|
static constexpr float STD_Y_SCALE = 0.1f; // scale for y axis
|
|
static constexpr float STD_Z_SCALE = 0.1f; // scale for z axis
|
|
static constexpr bool STD_COMBINE_SCALES = false; // combine scale factors?
|
|
static constexpr bool STD_INVERT_AXIS = false; // default inversion for axes
|
|
|
|
|
|
public:
|
|
|
|
/**
|
|
* @brief Default constructor to initialize the member varibales with
|
|
* their default values.
|
|
*/
|
|
ScanIO_CAD(void);
|
|
|
|
virtual int readScans(int start, int end, string &dir, int maxDist,
|
|
int minDist, double *euler, vector<Point> &ptss);
|
|
|
|
private:
|
|
|
|
|
|
/**
|
|
* @brief method to read a scan in regular UOS .3d file format
|
|
*
|
|
* @param scan_in the (opened) filestream for the .3d file
|
|
* @param maxDist the maximal distance threshold from the origin for points
|
|
* @param minDist the minimal distance threshold from the origin for points
|
|
* @param points the vector containing the read scan points
|
|
*
|
|
*/
|
|
void read3DScan (std::ifstream &scan_in, int maxDist, int minDist, vector<Point> &points);
|
|
|
|
/**
|
|
* @brief function to create a surface sampling from a given .stl file
|
|
*
|
|
* @param scan_in the (opened) filestream for the .stl file
|
|
* @param points the vector containing the resultant surface sample
|
|
* @return true if the surface sample could be created, false otherwise
|
|
*/
|
|
bool createSamplingFromSTL (std::ifstream &scan_in, vector<Point> &points);
|
|
/**
|
|
* @brief Function to check if a opened .stl file contains binary or
|
|
* ASCII data.
|
|
*
|
|
* @param scan_in reference to the (opened) filestream for the .stl file
|
|
*
|
|
* @return true if the filestream contains an ASCII encoded .stl file,
|
|
* false otherwise
|
|
*/
|
|
bool hasASCIIHeader (std::ifstream &scan_in);
|
|
|
|
/**
|
|
* @brief Function to parse an ASCII encoded .stl file and create a
|
|
* 3D surface sampling of it.
|
|
*
|
|
* @param scan_in the (opened) filestream containint the .stl information
|
|
* @param points used to store the 3D points of the surface sampling
|
|
* @return true if the file could be parsed successfully, false otherwise
|
|
*/
|
|
bool parseASCII (std::ifstream &scan_in, vector<Point> &points);
|
|
|
|
/**
|
|
* @brief Function to parse an binary encoded .stl file and create a
|
|
* 3D surface sampling of it.
|
|
*
|
|
* @param scan_in the (opened) filestream containint the .stl information
|
|
* @param points used to store the 3D points of the surface sampling
|
|
* @return true if the file could be parsed successfully, false otherwise
|
|
*/
|
|
bool parseBinary (std::ifstream &scan_in, vector<Point> &points);
|
|
|
|
/**
|
|
* @brief Method to create a point sampling of a face (i.e. triangle).
|
|
*
|
|
* @param vertex1 the first corner of the triangle
|
|
* @param vertex2 the second corner of the triangle
|
|
* @param vertex3 the third corner of the triangle
|
|
* @param points reference to the Point vector, where the sample points
|
|
* are stored
|
|
*/
|
|
void createSampingForFace (float* vertex1, float* vertex2,
|
|
float* vertex3, vector<Point> &points);
|
|
|
|
/**
|
|
* @brief Method to store the point sampling to the UOS .3d file format.
|
|
* The resultant .3d file will have the same name as the original .stl
|
|
* file apart from the file extension.
|
|
*
|
|
* @param filename the name of the .stl file
|
|
* @param points a reference to the vector containing the point
|
|
* information to be stored
|
|
*/
|
|
void storeSamplingTo3D (std::string filename, vector<Point> &points);
|
|
|
|
/**
|
|
* @brief Computes the dot product of two 3D vectors given as float*.
|
|
*
|
|
* @param vec1 the first 3D vector as a float array
|
|
* @param vec2 the second 3D vector as a float array
|
|
*
|
|
* @return the dot product of the two vectors
|
|
*/
|
|
static float dotProd (const float* vec1, const float* vec2);
|
|
|
|
/**
|
|
* @brief Method to parse a config file.
|
|
* The config file needs to have INI file similar syntax. If a parsing
|
|
* error occurs a help with all available options will be printed to the
|
|
* console and the program will terminate without matching
|
|
*
|
|
* @param config A filestream to the config file
|
|
*/
|
|
void parseConfig (std::ifstream &config);
|
|
|
|
/**
|
|
* @brief Utility method to convert the data of a point in CAD coordinates
|
|
* to the slam coordinate system.
|
|
* This can involve the change of coordinate order, axis direction and
|
|
* scaling (of all or single coordinates), depending on the configuration
|
|
* passed via config file.
|
|
* @param raw_data A 3D point read from the CAD file as a float array
|
|
* @param vertex The resulting 3D point after all specified
|
|
* operations have taken place
|
|
*/
|
|
void copyRawData2Vertex (float *raw_data, float *vertex);
|
|
|
|
// member variables to hold the indices used in data conversion
|
|
unsigned int x_index;
|
|
unsigned int y_index;
|
|
unsigned int z_index;
|
|
|
|
// bools to determine if an axis should be inverted during data conversion
|
|
bool invert_x;
|
|
bool invert_y;
|
|
bool invert_z;
|
|
|
|
// scale factors (global and individual) for data conversion
|
|
float scale_factor;
|
|
float x_scale;
|
|
float y_scale;
|
|
float z_scale;
|
|
|
|
// determines if individual scale factors should be used
|
|
bool individual_scale;
|
|
// determines if individual scaling should be combined with
|
|
// the global scale factor
|
|
bool combine_scales;
|
|
|
|
// determines if random sampling should be used for surface sampling
|
|
bool random_sampling;
|
|
|
|
// determines if the sampled CAD model is stored as a .3d file
|
|
bool store_cad;
|
|
// sets the distance between sample points (determines sample density)
|
|
float sample_point_dist;
|
|
|
|
// option description for easier parsing of config
|
|
po::options_description _op_descr;
|
|
po::variables_map _vmap;
|
|
|
|
std::vector<fs::path> _stl_files;
|
|
size_t _stl_files_pos;
|
|
|
|
/**
|
|
* @brief Method to set up the option description.
|
|
* All allowed parameters with their default values should be
|
|
* initialized here.
|
|
*/
|
|
void setUpOptionDescription (void);
|
|
|
|
void parseDirForAllSTL (std::string &directory_name);
|
|
|
|
bool getNextSTLFromDir (fs::path &stl_file);
|
|
};
|
|
|
|
// Since this shared object file is loaded on the fly, we
|
|
// need class factories
|
|
|
|
// the types of the class factories
|
|
typedef ScanIO* create_sio();
|
|
typedef void destroy_sio(ScanIO*);
|
|
|
|
#endif
|