289 lines
7.8 KiB
Text
289 lines
7.8 KiB
Text
/*
|
|
* sharedScan implementation
|
|
*
|
|
* Copyright (C) Thomas Escher, Kai Lingemann
|
|
*
|
|
* Released under the GPL version 3.
|
|
*
|
|
*/
|
|
|
|
#include "scanserver/sharedScan.h"
|
|
|
|
#include <iostream>
|
|
using std::cout;
|
|
using std::cerr;
|
|
using std::endl;
|
|
#include <string>
|
|
|
|
#include "scanserver/clientInterface.h"
|
|
|
|
|
|
|
|
SharedScan::SharedScan(const ip::allocator<void, SegmentManager> & allocator,
|
|
const SharedStringSharedPtr& dir_path_ptr, const char *io_identifier,
|
|
IOType iotype) :
|
|
m_dir_path_ptr(dir_path_ptr),
|
|
m_io_identifier(io_identifier, allocator),
|
|
m_iotype(iotype),
|
|
m_prefetch(0),
|
|
m_max_dist(0.0), m_min_dist(0.0),
|
|
m_height_top(0.0), m_height_bottom(0.0),
|
|
m_range_mutator_param(0.0),
|
|
m_range_mutator_param_set(false),
|
|
m_range_param_set(false), m_height_param_set(false),
|
|
m_reduction_parameters(allocator),
|
|
m_show_parameters(allocator),
|
|
m_octtree_parameters(allocator),
|
|
m_load_frames_file(true),
|
|
m_frames(allocator)
|
|
{
|
|
// until boost-1.47 ipc-strings can do garbage with g++-4.4 -O2 and higher (optimizations and versions)
|
|
std::string bugfix(io_identifier);
|
|
m_io_identifier[bugfix.length()] = '\0';
|
|
|
|
// COs are allocated in the ServerScan-ctor
|
|
}
|
|
|
|
SharedScan::~SharedScan()
|
|
{
|
|
// TODO
|
|
// get segment manager and deconstruct all available data fields
|
|
// TODO: Delete COs if notzero and notify CM?
|
|
}
|
|
|
|
bool SharedScan::operator==(const SharedScan& r) const
|
|
{
|
|
return (m_io_identifier == r.m_io_identifier) && (*m_dir_path_ptr == *r.m_dir_path_ptr) && m_iotype == r.m_iotype;
|
|
}
|
|
|
|
void SharedScan::setRangeParameters(double max_dist, double min_dist)
|
|
{
|
|
// if a non-first set differs from the previous ones, invalidate all COs
|
|
if(m_range_param_set) {
|
|
if(max_dist != m_max_dist || min_dist != m_min_dist) {
|
|
invalidateFull();
|
|
invalidateReduced();
|
|
invalidateShow();
|
|
}
|
|
}
|
|
m_max_dist = max_dist;
|
|
m_min_dist = min_dist;
|
|
m_range_param_set = true;
|
|
}
|
|
|
|
void SharedScan::setHeightParameters(double top, double bottom)
|
|
{
|
|
// if a non-first set differs from the previous ones, invalidate all COs
|
|
if(m_height_param_set) {
|
|
if(top != m_height_top || bottom != m_height_bottom) {
|
|
invalidateFull();
|
|
invalidateReduced();
|
|
invalidateShow();
|
|
}
|
|
}
|
|
m_height_top = top;
|
|
m_height_bottom = bottom;
|
|
m_height_param_set = true;
|
|
}
|
|
|
|
void SharedScan::setRangeMutationParameters(double range)
|
|
{
|
|
// if a non-first set differs from the previous ones, invalidate all COs
|
|
if(m_range_mutator_param_set) {
|
|
if(range != m_range_mutator_param) {
|
|
invalidateFull();
|
|
invalidateReduced();
|
|
invalidateShow();
|
|
}
|
|
}
|
|
m_range_mutator_param = range;
|
|
m_range_mutator_param_set = true;
|
|
}
|
|
|
|
void SharedScan::setReductionParameters(const char* params)
|
|
{
|
|
// if a non-first set differs from the previous ones, invalidate reduced COs
|
|
if(!m_reduction_parameters.empty() && m_reduction_parameters != params) {
|
|
invalidateReduced();
|
|
}
|
|
m_reduction_parameters = params;
|
|
}
|
|
|
|
void SharedScan::setShowReductionParameters(const char* params)
|
|
{
|
|
// if a non-first set differs from the previous ones, invalidate reduced COs
|
|
if(!m_show_parameters.empty() && m_show_parameters != params) {
|
|
invalidateShow();
|
|
}
|
|
m_show_parameters = params;
|
|
}
|
|
|
|
void SharedScan::setOcttreeParameters(const char* params)
|
|
{
|
|
// if a non-first set differs from the previous ones, invalidate reduced COs
|
|
if(!m_octtree_parameters.empty() && m_octtree_parameters != params) {
|
|
m_octtree->invalidate<SharedScan::onInvalidation>();
|
|
}
|
|
m_octtree_parameters = params;
|
|
}
|
|
|
|
PointFilter SharedScan::getPointFilter() const
|
|
{
|
|
PointFilter r;
|
|
if(m_range_param_set)
|
|
r.setRange(m_max_dist, m_min_dist);
|
|
if(m_height_param_set)
|
|
r.setHeight(m_height_top, m_height_bottom);
|
|
if(m_range_mutator_param_set)
|
|
r.setRangeMutator(m_range_mutator_param);
|
|
|
|
return r;
|
|
}
|
|
|
|
void SharedScan::invalidateFull()
|
|
{
|
|
m_xyz->invalidate<SharedScan::onInvalidation>();
|
|
m_rgb->invalidate<SharedScan::onInvalidation>();
|
|
}
|
|
|
|
void SharedScan::invalidateReduced()
|
|
{
|
|
m_xyz_reduced->invalidate<SharedScan::onInvalidation>();
|
|
m_xyz_reduced_original->invalidate<SharedScan::onInvalidation>();
|
|
}
|
|
|
|
void SharedScan::invalidateShow()
|
|
{
|
|
m_show_reduced->invalidate<SharedScan::onInvalidation>();
|
|
m_octtree->invalidate<SharedScan::onInvalidation>();
|
|
}
|
|
|
|
void SharedScan::clearFrames()
|
|
{
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->clearFrames(this);
|
|
// don't try to load again from the still existing files
|
|
m_load_frames_file = false;
|
|
}
|
|
|
|
void SharedScan::addFrame(double* transformation, unsigned int type)
|
|
{
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->addFrame(this, transformation, type);
|
|
}
|
|
|
|
const FrameVector& SharedScan::getFrames()
|
|
{
|
|
// on a restart with existing frame files try to load these
|
|
if(m_frames.empty() && m_load_frames_file == true) {
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->loadFramesFile(this);
|
|
// don't try to load again if frames are still empty
|
|
m_load_frames_file = false;
|
|
}
|
|
return m_frames;
|
|
}
|
|
|
|
void SharedScan::saveFrames()
|
|
{
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->saveFramesFile(this);
|
|
// we just saved the file, no need to read it
|
|
m_load_frames_file = false;
|
|
}
|
|
|
|
double* SharedScan::getPose()
|
|
{
|
|
if(m_pose == 0) {
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->getPose(this);
|
|
}
|
|
return m_pose.get();
|
|
}
|
|
|
|
DataXYZ SharedScan::getXYZ() {
|
|
return m_xyz.get()->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataRGB SharedScan::getRGB() {
|
|
return m_rgb->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataReflectance SharedScan::getReflectance() {
|
|
return m_reflectance->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataTemperature SharedScan::getTemperature() {
|
|
return m_temperature->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataAmplitude SharedScan::getAmplitude() {
|
|
return m_amplitude->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataType SharedScan::getType() {
|
|
return m_type->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataDeviation SharedScan::getDeviation() {
|
|
return m_deviation->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataXYZ SharedScan::getXYZReduced() {
|
|
return m_xyz_reduced->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataXYZ SharedScan::createXYZReduced(unsigned int size) {
|
|
// size is in units of double[3], scale to bytes
|
|
return m_xyz_reduced->createCacheData<SharedScan::onAllocation>(size*3*sizeof(double));
|
|
}
|
|
|
|
|
|
DataReflectance SharedScan::createReflectance(unsigned int size) {
|
|
// size is in units of double[1], scale to bytes
|
|
return m_reflectance->createCacheData<SharedScan::onAllocation>(size*1*sizeof(double));
|
|
}
|
|
|
|
|
|
DataXYZ SharedScan::getXYZReducedOriginal() {
|
|
return m_xyz_reduced_original->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataXYZ SharedScan::createXYZReducedOriginal(unsigned int size) {
|
|
// size is in units of double[3], scale to bytes
|
|
return m_xyz_reduced_original->createCacheData<SharedScan::onAllocation>(size*3*sizeof(double));
|
|
}
|
|
|
|
TripleArray<float> SharedScan::getXYZReducedShow() {
|
|
return m_show_reduced->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
TripleArray<float> SharedScan::createXYZReducedShow(unsigned int size) {
|
|
return m_show_reduced->createCacheData<SharedScan::onAllocation>(size*3*sizeof(float));
|
|
}
|
|
|
|
DataPointer SharedScan::getOcttree() {
|
|
return m_octtree->getCacheData<SharedScan::onCacheMiss>();
|
|
}
|
|
|
|
DataPointer SharedScan::createOcttree(unsigned int size) {
|
|
return m_octtree->createCacheData<SharedScan::onAllocation>(size);
|
|
}
|
|
|
|
void SharedScan::onCacheMiss(CacheObject* obj)
|
|
{
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->loadCacheObject(obj);
|
|
}
|
|
|
|
void SharedScan::onAllocation(CacheObject* obj, unsigned int size)
|
|
{
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->allocateCacheObject(obj, size);
|
|
}
|
|
|
|
void SharedScan::onInvalidation(CacheObject* obj)
|
|
{
|
|
ClientInterface* client = ClientInterface::getInstance();
|
|
client->invalidateCacheObject(obj);
|
|
}
|