3dpcp/.svn/pristine/45/45e2e25572e2899c2bcc3e7f1bdd3c3604393dd7.svn-base
2012-10-15 19:05:06 +02:00

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);
}