nxmap.h

//C Copyright (C) 2000-2006 Kevin Cowtan and University of York
//L
//L  This library is free software and is distributed under the terms
//L  and conditions of version 2.1 of the GNU Lesser General Public
//L  Licence (LGPL) with the following additional clause:
//L
//L     `You may also combine or link a "work that uses the Library" to
//L     produce a work containing portions of the Library, and distribute
//L     that work under terms of your choice, provided that you give
//L     prominent notice with each copy of the work that the specified
//L     version of the Library is used in it, and that you include or
//L     provide public access to the complete corresponding
//L     machine-readable source code for the Library including whatever
//L     changes were used in the work. (i.e. If you make changes to the
//L     Library you must distribute those, but you do not need to
//L     distribute source or object code to those portions of the work
//L     not covered by this licence.)'
//L
//L  Note that this clause grants an additional right and does not impose
//L  any additional restriction, and so does not affect compatibility
//L  with the GNU General Public Licence (GPL). If you wish to negotiate
//L  other terms, please contact the maintainer.
//L
//L  You can redistribute it and/or modify the library under the terms of
//L  the GNU Lesser General Public License as published by the Free Software
//L  Foundation; either version 2.1 of the License, or (at your option) any
//L  later version.
//L
//L  This library is distributed in the hope that it will be useful, but
//L  WITHOUT ANY WARRANTY; without even the implied warranty of
//L  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//L  Lesser General Public License for more details.
//L
//L  You should have received a copy of the CCP4 licence and/or GNU
//L  Lesser General Public License along with this library; if not, write
//L  to the CCP4 Secretary, Daresbury Laboratory, Warrington WA4 4AD, UK.
//L  The GNU Lesser General Public can also be obtained by writing to the
//L  Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
//L  MA 02111-1307 USA


#ifndef CLIPPER_NXMAP
#define CLIPPER_NXMAP


#include "derivs.h"


namespace clipper
{


  class NXmap_base
  {
  public:
    bool is_null() const;

    const Grid& grid() const { return grid_; }
    const RTop<>& operator_orth_grid() const { return rt_orth_grid; }
    const RTop<>& operator_grid_orth() const { return rt_grid_orth; }

    inline Coord_orth coord_orth( const Coord_map& cm ) const
      { return Coord_orth( rt_grid_orth*cm ); }

    inline Coord_map coord_map( const Coord_orth& co ) const
      { return Coord_map ( rt_orth_grid*co ); }

    bool in_map( const Coord_grid& pos ) const { return grid_.in_grid( pos ); }
    template<class I> bool in_map( const Coord_map& cm ) const;

    int multiplicity( const Coord_grid& ) const { return 1; }


    class Map_reference_base
    {
    public:
      inline const NXmap_base& base_nxmap() const { return *map_; }
      inline const int& index() const { return index_; }
      inline bool last() const { return ( index_ >= map_->grid_.size() ); }
    protected:
      const NXmap_base* map_;
      int index_;
    };


    class Map_reference_index : public Map_reference_base
    {
    public:
      Map_reference_index() {}
      explicit Map_reference_index( const NXmap_base& map )
        { map_ = &map; index_ = 0; }
      Map_reference_index( const NXmap_base& map, const Coord_grid& pos )
        { map_ = &map; index_ = map_->grid_.index( pos ); }
      inline Coord_grid coord() const
        { return map_->grid_.deindex(index_); }
      inline const Coord_orth coord_orth() const
        { return map_->coord_orth( coord().coord_map() ); }
      inline Map_reference_index& set_coord( const Coord_grid& pos )
        { index_ = map_->grid_.index( pos ); return *this; }
      inline Map_reference_index& next() { index_++; return *this; }
      /* Use for e.g. peak search. Valid for -1 <= du/dv/dw <= 1 only.
         \param du/dv/dw Coordinate offset. \return Map index. */
      inline int index_offset(const int& du,const int& dv,const int& dw) const {
        return index_ + du*map_->du + dv*map_->dv + dw*map_->dw;
      }
      // inherited functions listed for documentation purposes
      //-- const NXmap_base& base_nxmap() const;
      //-- const int& index() const;
      //-- bool last() const;
    };


    class Map_reference_coord : public NXmap_base::Map_reference_base
    {
    public:
      Map_reference_coord() {}
      explicit Map_reference_coord( const NXmap_base& map )
        { map_ = &map; }
      Map_reference_coord( const NXmap_base& map, const Coord_grid& pos )
        { map_ = &map; set_coord( pos ); }
      inline Coord_grid coord() const { return pos_; }
      inline const Coord_orth coord_orth() const
        { return map_->coord_orth( coord().coord_map() ); }
      inline Map_reference_coord& set_coord( const Coord_grid& pos )
        { pos_ = pos; index_ = map_->grid_.index( pos_ ); return *this; }

      inline Map_reference_coord& next() {
        index_++;
        pos_ = map_->grid_.deindex(index_);
        return *this;
      }
      // Increment u,v,w
      inline Map_reference_coord& next_u() { pos_.u()++; index_ += map_->du; return *this; }  
      inline Map_reference_coord& next_v() { pos_.v()++; index_ += map_->dv; return *this; }  
      inline Map_reference_coord& next_w() { pos_.w()++; index_ += map_->dw; return *this; }  
      inline Map_reference_coord& prev_u() { pos_.u()--; index_ -= map_->du; return *this; }  
      inline Map_reference_coord& prev_v() { pos_.v()--; index_ -= map_->dv; return *this; }  
      inline Map_reference_coord& prev_w() { pos_.w()--; index_ -= map_->dw; return *this; }  

      inline Map_reference_coord& operator =( const Coord_grid& pos )
        { return set_coord( pos ); }
      // inherited functions listed for documentation purposes
      //-- const NXmap_base& base_nxmap() const;
      //-- const int& index() const;
      //-- bool last() const;
    protected:
      Coord_grid pos_;
    };

    Map_reference_index first() const { return Map_reference_index( *this ); }
    Map_reference_coord first_coord() const { return Map_reference_coord( *this ); }

  protected:
    Grid grid_;               
    RTop<> rt_orth_grid; 
    RTop<> rt_grid_orth; 
    int du, dv, dw;           

    NXmap_base();
    void init( const Grid& grid, const RTop<>& rt );
    void init( const Cell& cell, const Grid_sampling& grid, const Grid_range& grid_extent );

    friend class NXmap_base::Map_reference_base;
    friend class NXmap_base::Map_reference_index;
    friend class NXmap_base::Map_reference_coord;
  };





  template<class T> class NXmap : public NXmap_base
  {
  public:
    NXmap() {}
    NXmap( const Grid& grid, const RTop<>& rt );
    NXmap( const Cell& cell, const Grid_sampling& grid, const Grid_range& grid_extent );
    void init( const Grid& grid, const RTop<>& rt );
    void init( const Cell& cell, const Grid_sampling& grid, const Grid_range& grid_extent );

    inline const T& operator[] (const NXmap_base::Map_reference_index i) const
      { return list[i.index()]; }
    inline T& operator[] (const NXmap_base::Map_reference_index i)
      { return list[i.index()]; }

    inline const T& operator[] (const NXmap_base::Map_reference_coord i) const
      { return list[i.index()]; }
    inline T& operator[] (const NXmap_base::Map_reference_coord i)
      { return list[i.index()]; }

    inline const T& get_data( const Coord_grid& pos ) const
      { return list[ grid_.index( pos ) ]; }
    inline void set_data( const Coord_grid& pos, const T& val )
      { list[ grid_.index( pos ) ] = val; }

    template<class I> T interp( const Coord_map& pos ) const;
    template<class I> void interp_grad( const Coord_map& pos, T& val, Grad_map<T>& grad ) const;
    template<class I> void interp_curv( const Coord_map& pos, T& val, Grad_map<T>& grad, Curv_map<T>& curv ) const;

    // inherited functions listed for documentation purposes
    //-- const Grid& grid() const;
    //-- const RTop<> operator_orth_grid() const;
    //-- const RTop<> operator_grid_orth() const;
    //-- const Coord_orth coord_orth( const Coord_map&  cg ) const;
    //-- const Coord_map  coord_map ( const Coord_orth& co ) const;
    //-- const Map_reference_index first();
    //-- const Map_reference_coord first_coord();

    const T& operator =( const T& value );
    const NXmap<T>& operator +=( const NXmap<T>& other );
    const NXmap<T>& operator -=( const NXmap<T>& other );

  private:
    std::vector<T> list;
  };



  // template fucntion definitions

  template<class I> bool NXmap_base::in_map( const Coord_map& cm ) const
    { return I::can_interp( *this, cm ); }

  template<class T> NXmap<T>::NXmap( const Grid& grid, const RTop<>& rt )
    { init( grid, rt ); }

  template<class T> NXmap<T>::NXmap( const Cell& cell, const Grid_sampling& grid, const Grid_range& grid_extent )
    { init( cell, grid, grid_extent ); }

  template<class T> void NXmap<T>::init( const Grid& grid, const RTop<>& rt )
    { NXmap_base::init( grid, rt ); list.resize( grid.size() ); }

  template<class T> void NXmap<T>::init( const Cell& cell, const Grid_sampling& grid, const Grid_range& grid_extent )
    { NXmap_base::init( cell, grid, grid_extent ); list.resize( grid_extent.size() ); }


  template<class T> template<class I> T NXmap<T>::interp( const Coord_map& pos ) const
  {
    T val;
    I::interp( *this, pos, val );
    return val;
  }


  template<class T> template<class I> void NXmap<T>::interp_grad( const Coord_map& pos, T& val, Grad_map<T>& grad ) const
  {
    I::interp_grad( *this, pos, val, grad );
  }


  template<class T> template<class I> void NXmap<T>::interp_curv( const Coord_map& pos, T& val, Grad_map<T>& grad, Curv_map<T>& curv ) const
  {
    I::interp_curv( *this, pos, val, grad, curv );
  }


  template<class T> const T& NXmap<T>::operator =( const T& value )
  {
    // copy value into map
    Map_reference_index im;
    for ( im = first(); !im.last(); im.next() ) list[im.index()] = value;
    return value;
  }


  template<class T> const NXmap<T>& NXmap<T>::operator +=( const NXmap<T>& other )
  {
    if ( grid() != other.grid() )
      Message::message( Message_fatal( "NXmap: map mismatch in +=" ) );
    Map_reference_index im;
    for ( im = first(); !im.last(); im.next() ) list[im.index()] += other[im];
    return (*this);
  }

  template<class T> const NXmap<T>& NXmap<T>::operator -=( const NXmap<T>& other )
  {
    if ( grid() != other.grid() )
      Message::message( Message_fatal( "NXmap: map mismatch in -=" ) );
    Map_reference_index im;
    for ( im = first(); !im.last(); im.next() ) list[im.index()] -= other[im];
    return (*this);
  }


} // namespace clipper

#endif