IProcessorEx.hpp

#ifndef DM_PROCESSOR_IPROCESSOR_EX_HPP_INCLUDED
#define DM_PROCESSOR_IPROCESSOR_EX_HPP_INCLUDED

#ifdef _MSC_VER
  #pragma once
#endif

#include "DM/config.hpp"
#include "DM/Handle.hpp"
#include "DM/IFilter.hpp"
#include "DM/IAddInfoLayout.hpp"
#include "DM/IDatamanager.hpp"
#include "DM/ISpatialQueryDescriptor.hpp"
#include "DM/IControlObject.hpp"
#include "DM/IMessageOutput.hpp"

#include "DM/Processor/IKernelEx.hpp"
#include "DM/Processor/AutoLink.hpp" //enable autolink

DM_NAMESPACE_BEGIN


/// \brief Statistic interface to object that can be retrieved after a IProcessorEx run
class DM_PS_API IProcessStats : public ObjectBase
{
protected:
  virtual ~IProcessStats() {}

public:
  virtual int64_t pointsProccessed()  const = 0;  ///< overall points processed (which fullfill the optional limit criterion): pointsProccessed = pointsFiltered + pointsUsed
  virtual int64_t pointsFiltered()    const = 0;  ///< number of points that where filtered by the (optional) process filter
  virtual int64_t pointsChanged()     const = 0;  ///< number of points that passed the (optional) process filter and have been changed by the kernel object
  virtual int64_t pointsUnchanged()   const = 0;  ///< number of points that passed the (optional) process filter and have NOT been changed by the kernel object
  virtual int64_t pointsUsed()        const = 0;  ///< number of points that passed the (optional) process filter: pointsUsed = pointsChanged +  pointsUnchanged

  //statistic about spatial data selection
  virtual int64_t neighborsMin() const = 0;
  virtual int64_t neighborsMax() const = 0;
  virtual double  neighborsMean() const = 0;
  virtual double  neighborsSigma() const = 0;
  virtual int64_t pointsZeroNeighbors()   const = 0;  ///< number of points that have no neighbors at all
  virtual int64_t pointsSingleNeighbors() const = 0;  //<  number of points that have only a single neighbor
};

typedef Handle< IProcessStats > ProcessStatsHandle;

/// \brief Extended processor/kernel concept
/**
  Compared to the simple processor/kernel the exteneded version handles all spatial neighborhood queries (also no spatial queries), supports 
  processing and spatial selection filters, as well as, addinfo layout setting for processing and neighborhood points. Furthermore, an optional 
  processing limit (currently only 2d) can be applied. After the runThreaded function was called a detailed statistic object can be accessed 

  (see getStats and IProcessStats for details). Progress control support is also implemented (see setControlObject)
  The code uses template functions and specialised code to bypass unneeded functions resulting in optimal performance.
  
  Hence, the extended processor concept reduces the necessary kernel code to an absolute minimum supporting efficient module development
*/
class DM_PS_API IProcessorEx : public ObjectBase
{
public:
  static IProcessorEx* New(IDatamanager &manager, SpatialQueryDescriptorHandle query, 
                           FilterHandle processFilter, AddInfoLayoutHandle processLayout, bool processLayoutReadOnly,
                           FilterHandle spatialFilter, AddInfoLayoutHandle spatialLayout, bool spatialLayoutReadOnly);
  static IProcessorEx* New(IDatamanager &manager, const IWindow &processLimit, SpatialQueryDescriptorHandle query, 
                           FilterHandle processFilter, AddInfoLayoutHandle processLayout, bool processLayoutReadOnly,
                           FilterHandle spatialFilter, AddInfoLayoutHandle spatialLayout, bool spatialLayoutReadOnly);
protected:
  virtual ~IProcessorEx() {}

public:
  /// set and optional control object
  virtual void setControlObject(ControlObjectHandle control) = 0;
  /// get the current control object
  virtual ControlObjectHandle getControlObject() const = 0;

  /// \brief start processing with the given kernel object
  /// \param[in]  kernel          processing kernel object (will be cloned for each processing thread)
  /// \param[in]  threads         number of processing thread (0 -> use logical number of cpus  of the current machine)
  /// \param[in]  messageOutput   optional message callback object to recieve warnings and errors 
  virtual void runThreaded(IPointKernelEx &kernel, int threads = 0, MessageOutputHandle messageOutput = MessageOutputHandle()) = 0;

  /// get processing statistic object (after the runThreaded function was called)
  virtual ProcessStatsHandle getStats() const = 0;
};

typedef Handle< IProcessorEx > ProcessorExHandle;


DM_NAMESPACE_END

#endif //DM_PROCESSOR_IPROCESSOR_HPP_INCLUDED