/home/kitware/dashboards/avogadro/libavogadro/src/cube.h

/**********************************************************************
  Cube - Primitive class to encapsulate volumetric data

    Copyright (c) 2008-2009 Marcus D. Hanwell
    Copyright (c) 2009 Geoff Hutchison

  This file is part of the Avogadro molecular editor project.
  For more information, see <http://avogadro.openmolecules.net/>

  Avogadro 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.

  Avogadro 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 this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.
 **********************************************************************/

 #ifndef CUBE_H
 #define CUBE_H

#include <avogadro/primitive.h>

#include <vector>

// Forward declarations
class QReadWriteLock;

namespace Avogadro {

  class Molecule;

  class CubePrivate;
  class A_EXPORT Cube : public Primitive
  {
  Q_OBJECT

  public:
    Cube(QObject *parent=0);
    ~Cube();

    enum Type{
      VdW,
      ESP,
      ElectronDensity,
      MO,
      FromFile,
      None
    };

    Eigen::Vector3d min() const { return m_min; }

    Eigen::Vector3d max() const { return m_max; }

    Eigen::Vector3d spacing() const { return m_spacing; }

    Eigen::Vector3i dimensions() const { return m_points; }

    bool setLimits(const Eigen::Vector3d &min, const Eigen::Vector3d &max,
                   const Eigen::Vector3i &points);

    bool setLimits(const Eigen::Vector3d &min, const Eigen::Vector3d &max,
                   double spacing);

    bool setLimits(const Eigen::Vector3d &min, const Eigen::Vector3i &dim,
                   double spacing);

    bool setLimits(const Cube &cube);

    bool setLimits(const Molecule *mol, double spacing, double padding);

    std::vector<double> * data();

    bool setData(const std::vector<double> &values);

    bool addData(const std::vector<double> &values);

    unsigned int closestIndex(const Eigen::Vector3d &pos) const;

    Eigen::Vector3i indexVector(const Eigen::Vector3d &pos) const;

    Eigen::Vector3d position(unsigned int index) const;

    double value(int i, int j, int k) const;

    double value(const Eigen::Vector3i &pos) const;

    float valuef(const Eigen::Vector3f &pos) const;

    double value(const Eigen::Vector3d &pos) const;

    bool setValue(int i, int j, int k, double value);

    bool setValue(unsigned int i, double value);

    double minValue() const { return m_minValue; }

    double maxValue() const { return m_maxValue; }

    void setName(QString name) { m_name = name; }
    QString name() const { return m_name; }

    void setCubeType(Type type) { m_cubeType = type; }
    Type cubeType() { return m_cubeType; }

    QReadWriteLock *lock() const;

    friend class Molecule;

  protected:
    std::vector<double> m_data;
    Eigen::Vector3d m_min, m_max, m_spacing;
    Eigen::Vector3i m_points;
    double m_minValue, m_maxValue;
    QString m_name;
    Type    m_cubeType;
    QReadWriteLock *m_lock;
    Q_DECLARE_PRIVATE(Cube)
  };

  inline bool Cube::setValue(unsigned int i, double value)
  {
    if (i < m_data.size()) {
      m_data[i] = value;
      if (value > m_maxValue) m_maxValue = value;
      if (value < m_minValue) m_minValue = value;
      return true;
    }
    else
      return false;
  }

} // End namespace Avogadro

 #endif