mask.h

Go to the documentation of this file.

/*
 *  mask.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef MASK_H
#define MASK_H

#include "nest.h"
#include "topology_names.h"
#include "position.h"
#include "dictdatum.h"
#include "dictutils.h"
#include "exceptions.h"
#include "topologymodule.h"

namespace nest
{
  class TopologyModule;

  class AbstractMask
  {
  public:
    virtual ~AbstractMask()
      {}

    virtual bool inside(const std::vector<double_t> &) const = 0;

    virtual DictionaryDatum get_dict() const
      { throw KernelException("Can not convert mask to dict"); }

    virtual AbstractMask * intersect_mask(const AbstractMask & other) const = 0;

    virtual AbstractMask * union_mask(const AbstractMask & other) const = 0;

    virtual AbstractMask * minus_mask(const AbstractMask & other) const = 0;

  };

  typedef lockPTRDatum<AbstractMask, &TopologyModule::MaskType> MaskDatum;

  template<int D>
  class Mask : public AbstractMask
  {
  public:
    ~Mask()
      {}

    virtual bool inside(const Position<D> &) const = 0;

    bool inside(const std::vector<double_t> &pt) const;

    virtual bool inside(const Box<D> &) const = 0;

    virtual bool outside(const Box<D> &b) const;

    virtual Box<D> get_bbox() const = 0;

    virtual Mask * clone() const = 0;

    AbstractMask * intersect_mask(const AbstractMask & other) const;
    AbstractMask * union_mask(const AbstractMask & other) const;
    AbstractMask * minus_mask(const AbstractMask & other) const;
  };

  template<int D>
  class AllMask : public Mask<D>
  {
  public:

    ~AllMask()
      {}

    using Mask<D>::inside;

    bool inside(const Position<D> &) const
      { return true; }

    bool inside(const Box<D> &) const
      { return true; }

    bool outside(const Box<D> &) const
      { return false; }

    Box<D> get_bbox() const
      {
        const double inf = std::numeric_limits<double>::infinity();
        return Box<D>(Position<D>(-inf,-inf), Position<D>(inf,inf));
      }

    Mask<D> * clone() const
      { return new AllMask(); }
  };

  template<int D>
  class BoxMask : public Mask<D>
  {
  public:

    BoxMask(const DictionaryDatum&);

    BoxMask(const Position<D>& lower_left, const Position<D>& upper_right);

    ~BoxMask()
      {}

    using Mask<D>::inside;

    bool inside(const Position<D> &p) const;

    bool inside(const Box<D> &b) const;

    bool outside(const Box<D> &b) const;

    Box<D> get_bbox() const;

    DictionaryDatum get_dict() const;

    Mask<D> * clone() const;

    static Name get_name();

  protected:
    Position<D> lower_left_;
    Position<D> upper_right_;
  };

  template<int D>
  class BallMask : public Mask<D>
  {
  public:
    BallMask(Position<D> center, double_t radius) :
      center_(center), radius_(radius)
      {}

    BallMask(const DictionaryDatum&);

    ~BallMask()
      {}

    using Mask<D>::inside;

    bool inside(const Position<D> &p) const;

    bool inside(const Box<D> &) const;

    bool outside(const Box<D> &b) const;

    Box<D> get_bbox() const;

    DictionaryDatum get_dict() const;

    Mask<D> * clone() const;

    static Name get_name();

  protected:
    Position<D> center_;
    double_t radius_;
  };

  template<int D>
  class IntersectionMask : public Mask<D> {
  public:

    IntersectionMask(const Mask<D> &m1, const Mask<D> &m2):
      mask1_(m1.clone()), mask2_(m2.clone())
      {}

    IntersectionMask(const IntersectionMask &m):
      Mask<D>(m), mask1_(m.mask1_->clone()), mask2_(m.mask2_->clone())
      {}

    ~IntersectionMask()
      { delete mask1_; delete mask2_; }

    bool inside(const Position<D> &p) const;

    bool inside(const Box<D> &b) const;

    bool outside(const Box<D> &b) const;

    Box<D> get_bbox() const;

    Mask<D> * clone() const;

  protected:
    Mask<D> *mask1_, *mask2_;
  };

  template<int D>
  class UnionMask : public Mask<D> {
  public:

    UnionMask(const Mask<D> &m1, const Mask<D> &m2):
      mask1_(m1.clone()), mask2_(m2.clone())
      {}

    UnionMask(const UnionMask &m):
      Mask<D>(m), mask1_(m.mask1_->clone()), mask2_(m.mask2_->clone())
      {}

    ~UnionMask()
      { delete mask1_; delete mask2_; }

    bool inside(const Position<D> &p) const;

    bool inside(const Box<D> &b) const;

    bool outside(const Box<D> &b) const;

    Box<D> get_bbox() const;

    Mask<D> * clone() const;

  protected:
    Mask<D> *mask1_, *mask2_;
  };

  template<int D>
  class DifferenceMask : public Mask<D> {
  public:

    DifferenceMask(const Mask<D> &m1, const Mask<D> &m2):
      mask1_(m1.clone()), mask2_(m2.clone())
      {}

    DifferenceMask(const DifferenceMask &m):
      Mask<D>(m), mask1_(m.mask1_->clone()), mask2_(m.mask2_->clone())
      {}

    ~DifferenceMask()
      { delete mask1_; delete mask2_; }

    bool inside(const Position<D> &p) const;

    bool inside(const Box<D> &b) const;

    bool outside(const Box<D> &b) const;

    Box<D> get_bbox() const;

    Mask<D> * clone() const;

  protected:
    Mask<D> *mask1_, *mask2_;
  };


  template<int D>
  class ConverseMask : public Mask<D> {
  public:
    ConverseMask(const Mask<D> &m): m_(m.clone()) {}

    ConverseMask(const ConverseMask &m): Mask<D>(m), m_(m.m_->clone()) {}

    ~ConverseMask()
      { delete m_; }

    bool inside(const Position<D> &p) const;

    bool inside(const Box<D> &b) const;

    bool outside(const Box<D> &b) const;

    Box<D> get_bbox() const;

    Mask<D> * clone() const;

  protected:
    Mask<D> *m_;
  };


  template<int D>
  class AnchoredMask : public Mask<D> {
  public:
    AnchoredMask(const Mask<D> &m, Position<D> anchor): m_(m.clone()), anchor_(anchor) {}

    AnchoredMask(const AnchoredMask &m): Mask<D>(m), m_(m.m_->clone()), anchor_(m.anchor_) {}

    ~AnchoredMask()
      { delete m_; }

    bool inside(const Position<D> &p) const;

    bool inside(const Box<D> &b) const;

    bool outside(const Box<D> &b) const;

    Box<D> get_bbox() const;

    DictionaryDatum get_dict() const;

    Mask<D> * clone() const;

  protected:
    Mask<D> *m_;
    Position<D> anchor_;
  };

  template<>
  inline
  Name BoxMask<2>::get_name()
  {
    return names::rectangular;
  }

  template<>
  inline
  Name BoxMask<3>::get_name()
  {
    return names::box;
  }

  template<int D>
  BoxMask<D>::BoxMask(const DictionaryDatum& d)
  {
    lower_left_ = getValue<std::vector<double_t> >(d, names::lower_left);
    upper_right_ = getValue<std::vector<double_t> >(d, names::upper_right);
    if ( not ( lower_left_ < upper_right_ ) )
      throw BadProperty("topology::BoxMask<D>: "
                        "Upper right must be strictly to the right and above lower left.");
  }

  template<int D>
  inline
  BoxMask<D>::BoxMask(const Position<D>& lower_left, const Position<D>&upper_right):
    lower_left_(lower_left), upper_right_(upper_right)
  {}
  
  template<>
  inline
  Name BallMask<2>::get_name()
  {
    return names::circular;
  }

  template<>
  inline
  Name BallMask<3>::get_name()
  {
    return names::spherical;
  }

  template<int D>
  BallMask<D>::BallMask(const DictionaryDatum& d)
  {
    radius_ = getValue<double_t>(d, names::radius);
    if ( radius_ <= 0 )
      throw BadProperty("topology::BallMask<D>: "
                        "radius > 0 required.");

    if (d->known(names::anchor)) {
      center_ = getValue<std::vector<double_t> >(d, names::anchor);
    }
  }

} // namespace nest

#endif