blur_spot.h

Go to the documentation of this file.

/* Author(s):     Francois Mauger <mauger@lpccaen.in2p3.fr>
 * Creation date: 2012-03-22
 * Last modified: 2014-07-08
 *
 * License:
 *   GPL 3.0
 * Description:
 *
 *  Classes that represent various spot patterns :
 *   - point-like spot (no blur)
 *   - spot blured on a segment (blur impact on a wire)
 *   - spot blured as a stain (blur impact on a surface)
 *   - spot blured as a tiny volume (blur 3D-vertex: 'gazeous drop/cloud/bubble')
 *
 */

#ifndef GEOMTOOLS_BLUR_SPOT_H
#define GEOMTOOLS_BLUR_SPOT_H 1

// Third party:
// - Boost:
#include <boost/serialization/access.hpp>
#include <boost/random/normal_distribution.hpp>
// - Bayeux/datatools:
#include <datatools/i_serializable.h>
#include <datatools/i_tree_dump.h>
#include <datatools/properties.h>
// - Bayeux/mygsl:
#include <mygsl/rng.h>

// This project:
#include <geomtools/geomtools_config.h>
#include <geomtools/utils.h>
#include <geomtools/placement.h>
#include <geomtools/i_object_3d.h>
#include <geomtools/i_wires_3d_rendering.h>
#include <geomtools/base_hit.h>

namespace geomtools {

  /*
   *
   *   <---> tolerance
   *     :
   *   ..*..  point like spot +/- tolerance in 3D
   *     :\
   *       placement
   *
   *
   *     :           zerror  :
   *   ..++++++++++*++++++++++..    blur_spot (1D)
   *     :        /          :
   *          placement
   *
   *
   *     :     xerror    :
   * y ..+++++++++++++++++..
   * e ..+++++++++++++++++..
   * r ..++++++++*++++++++..   blur_spot (2D)
   * r ..+++++++++\+++++++..
   * o ..++++++++++\++++++..
   * r   :          \    :
   *             placement
   *
   *
   *      <no representation>  for blur_spot (3D)
   *
   *
   */
  class blur_spot
    : public base_hit
    , public i_wires_3d_rendering
  {
  public:

    enum blur_dimension_type {
      DIMENSION_INVALID = -1,
      DIMENSION_ZERO    =  0,
      dimension_zero    =  DIMENSION_ZERO,
      DIMENSION_ONE     =  1,
      dimension_one     =  DIMENSION_ONE,
      DIMENSION_TWO     =  2,
      dimension_two     =  DIMENSION_TWO,
      DIMENSION_THREE   =  3,
      dimension_three   =  DIMENSION_THREE
    };

    enum mode_type {
      MODE_INTERVAL = 0,
      mode_interval = MODE_INTERVAL,
      MODE_GAUSSIAN = 1,
      mode_gaussian = MODE_GAUSSIAN
    };

    enum store_mask_type {
      STORE_PLACEMENT = datatools::bit_mask::bit03
    };

    static const double DEFAULT_VALUE;

    static const double DEFAULT_NSIGMA;

    double get_tolerance() const;

    void set_tolerance(double tolerance_);

    bool is_dimension_zero() const;

    bool is_dimension_one() const;

    bool is_dimension_two() const;

    bool is_dimension_three() const;

    void set_blur_dimension(int);

    int get_blur_dimension() const;

    blur_spot();

    blur_spot(int8_t dimension_,
              double tolerance_ = DEFAULT_VALUE);

    void set_position(const vector_3d & position_);

    placement & grab_placement();

    const placement & get_placement() const;

    void set_placement(const placement & placement_);

    void invalidate_placement();

    const vector_3d & get_position() const;

    const rotation_3d & get_rotation() const;

    const rotation_3d & get_inverse_rotation() const;

    virtual ~blur_spot();

    virtual void invalidate();

    void reset();

    virtual bool is_valid() const;

    double get_x_error() const;

    void set_x_error(double);

    double get_y_error() const;

    void set_y_error(double);

    double get_z_error() const;

    void set_z_error(double);

    void set_errors(double,
                    double = std::numeric_limits<double>::quiet_NaN(),
                    double = std::numeric_limits<double>::quiet_NaN());

    template <class Randomizer>
    void randomize_boost(Randomizer & ran_,
                         vector_3d & random_point_,
                         int mode_ = MODE_INTERVAL) const;

    void randomize_mygsl(mygsl::rng & ran_,
                         vector_3d & random_point_,
                         int mode_ = MODE_INTERVAL) const;

    bool match(const vector_3d & position_,
               int mode_ = MODE_INTERVAL,
               double nsigma1_or_tolerance_ = DEFAULT_VALUE,
               double nsigma2_or_tolerance_ = DEFAULT_VALUE,
               double nsigma3_or_tolerance_ = DEFAULT_VALUE) const;

    virtual void generate_wires_self(wires_type & wires_,
                                     uint32_t options_ = 0) const;

    virtual void tree_dump(std::ostream & out_    = std::clog,
                           const std::string & title_  = "",
                           const std::string & indent_ = "",
                           bool inherit_               = false) const;

    void print() const;

  protected:

    bool _match_0d(const vector_3d & position_,
                   double tolerance_ = DEFAULT_VALUE) const;

    bool _match_1d(const vector_3d & position_,
                   int mode_ = MODE_INTERVAL,
                   double nsigma1_or_tolerance_ = DEFAULT_VALUE,
                   double nsigma2_or_tolerance_ = DEFAULT_VALUE) const;

    bool _match_2d(const vector_3d & position_,
                   int mode_ = MODE_INTERVAL,
                   double nsigma1_or_tolerance_ = DEFAULT_VALUE,
                   double nsigma2_or_tolerance_ = DEFAULT_VALUE,
                   double nsigma3_or_tolerance_ = DEFAULT_VALUE) const;

    bool _match_3d(const vector_3d & position_,
                   int mode_ = MODE_INTERVAL,
                   double nsigma1_or_tolerance_ = DEFAULT_VALUE,
                   double nsigma2_or_tolerance_ = DEFAULT_VALUE,
                   double nsigma3_or_tolerance_ = DEFAULT_VALUE) const;

  private:

    int8_t    _blur_dimension_;          
    double    _tolerance_;               
    placement _placement_;               
    double _x_error_;                    
    double _y_error_;                    
    double _z_error_;                    

    DATATOOLS_SERIALIZATION_DECLARATION()

    
    DR_CLASS_RTTI()
    
    GEOMTOOLS_HIT_REGISTRATION_INTERFACE(blur_spot)
                                         
  };

  template <class BoostRandomizer>
  void blur_spot::randomize_boost(BoostRandomizer & ran_,
                                  vector_3d & random_point_,
                                  int mode_) const
  {
    if (is_dimension_zero()) {
      random_point_ = _placement_.get_translation();
      return;
    }
    vector_3d local_pos(0.0, 0.0, 0.0);
    if (is_dimension_one()) {
      if (mode_ == MODE_INTERVAL) {
        local_pos.setZ(_z_error_ * ( -1. + 2 * ran_()));
      } else {
        boost::random::normal_distribution<double> gauss_random;
        local_pos.setZ(gauss_random(ran_, boost::random::normal_distribution<double>::param_type(0.0, _z_error_)));
      }
    } else if (is_dimension_two()) {
      if (mode_ == MODE_INTERVAL) {
        local_pos.setX(_x_error_ * ( -1. + 2 * ran_()));
        local_pos.setY(_y_error_ * ( -1. + 2 * ran_()));
      } else {
        boost::random::normal_distribution<double> gauss_random;
        local_pos.setX(gauss_random(ran_, boost::random::normal_distribution<double>::param_type(0.0, _x_error_)));
        local_pos.setY(gauss_random(ran_, boost::random::normal_distribution<double>::param_type(0.0, _y_error_)));
      }
    } else if (is_dimension_three()) {
      if (mode_ == MODE_INTERVAL) {
        local_pos.setX(_x_error_ * ( -1. + 2 * ran_()));
        local_pos.setY(_y_error_ * ( -1. + 2 * ran_()));
        local_pos.setZ(_z_error_ * ( -1. + 2 * ran_()));
      } else {
        boost::random::normal_distribution<double> gauss_random;
        local_pos.setX(gauss_random(ran_, boost::random::normal_distribution<double>::param_type(0.0, _x_error_)));
        local_pos.setY(gauss_random(ran_, boost::random::normal_distribution<double>::param_type(0.0, _y_error_)));
        local_pos.setZ(gauss_random(ran_, boost::random::normal_distribution<double>::param_type(0.0, _z_error_)));
      }
    }
    _placement_.child_to_mother(local_pos, random_point_);
    return;
  }

} // end of namespace geomtools

#include <boost/serialization/export.hpp>
BOOST_CLASS_EXPORT_KEY2(geomtools::blur_spot, "geomtools::blur_spot")

// Activate reflection layer for the blur_spot class :
DR_CLASS_INIT(::geomtools::blur_spot)

// Class version:
// 2014-07-03 FM: Now inherits from geomtools::base_hit :
#include <boost/serialization/version.hpp>
BOOST_CLASS_VERSION(geomtools::blur_spot, 1)

#endif // GEOMTOOLS_BLUR_SPOT_H

// Local Variables: --
// mode: c++ --
// c-file-style: "gnu" --
// tab-width: 2 --
// End: --