Stack.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
// 
#ifndef STACK_HPP
#define STACK_HPP
 
#include <Config.hpp>
#include <GL.hpp>
 
#include <Geometry.hpp>
#include <MGXViewer/qglviewer.h>
#include <Store.hpp>
 
namespace mgx 
{
  class SetupProcess;
 
  class mgx_EXPORT Stack {
    friend class SetupProcess;
  
  public:
    Stack(int id);
  
    Stack(const Stack& copy);
  
    ~Stack();
  
    int id() const {
      return _id;
    }
  
    void setId(int i) {
      _id = i;
    }
  
    int userId() const {
      return _id + 1;
    }
  
    const Store* main() const {
      return _main;
    }
    Store* main() {
      return _main;
    }
    void setMain(Store* m);
  
    const Store* work() const {
      return _work;
    }
    Store* work() {
      return _work;
    }
    void setWork(Store* w);
  
    const Store* currentStore() const {
      return _current;
    }
    Store* currentStore() {
      return _current;
    }
  
    Point3u size() const {
      return _size;
    }
    BoundingBox3i boundingBox() const {
      return BoundingBox3i(Point3i(), Point3i(size()));
    }
  
    Point3f step() const
    {
      return multiply(_step, scale());
    }
    // Point3f step() const { return _step * scale(); }// old
    size_t storeSize() const {
      return size_t(_size.x()) * _size.y() * _size.z();
    }
    bool empty() const {
      return _size == Point3u();
    }
  
    Point3f scale() const {
      return (_showScale ? _scale : Point3f(1.0, 1.0, 1.0));
    }
    // float scale() const { return (_showScale ? _scale : 1.0f); }
    Point3f origin() const {
      return multiply(scale(), _origin);
    }
    // Point3f origin() const { return scale()*_origin; }
    void setScale(Point3f s) {
      _scale = s;
    }
    // void setScale(float s) { _scale = s; }
    void setOrigin(const Point3f& s);
  
    void setSize(const Point3u& s);
    void setStep(const Point3f& s);
  
    bool showScale() const {
      return _showScale;
    }
    void setShowScale(bool s) {
      _showScale = s;
    }
  
    bool tieScales() const {
      return _tieScales;
    }
    void setTieScales(bool s) {
      _tieScales = s;
    }
  
    bool showTrans() const {
      return _showTrans;
    }
    void setShowTrans(bool s) {
      _showTrans = s;
    }
    bool showBBox() const {
      return _showBBox;
    }
    void setShowBBox(bool s) {
      _showBBox = s;
    }
  
    Matrix4f worldToImage() const;
  
    Matrix4f imageToWorld() const;
  
    Matrix4f worldToImageVector() const;
  
    Matrix4f imageToWorldVector() const;
  
    template <typename T> Point3f imageToWorld(const Vector<3, T>& img) const
    {
      return multiply(Point3f(img) + Point3f(.5f, .5f, .5f), step()) + origin();
    }
  
    template <typename T> Vector<3, T> worldToImage(Point3f wrld) const
    {
      return Vector<3, T>((wrld - origin()) / step() - Point3f(.5f, .5f, .5f));
    }
  
    template <typename T> Point3f imageToWorldVector(const Vector<3, T>& img) const
    {
      return multiply(Point3f(img), step());
    }
  
    template <typename T> Vector<3, T> worldToImageVector(Point3f wrld) const
    {
      return Vector<3, T>(wrld / step());
    }
  
    template <typename T> BoundingBox3f imageToWorld(const BoundingBox<3, T>& img) const
    {
      return BoundingBox3f(imageToWorld(img.pmin()), imageToWorld(img.pmax()));
    }
  
    template <typename T> BoundingBox<3, T> worldToImage(const BoundingBox3f& wrld) const
    {
      return BoundingBox<3, T>(worldToImage<T>(wrld.pmin()), worldToImage<T>(wrld.pmax()));
    }
  
    Point3f worldToImagef(const Point3f& a) const {
      return worldToImage<float>(a);
    }
    Point3i worldToImagei(const Point3f& a) const {
      return worldToImage<int>(a);
    }
    Point3u worldToImageu(const Point3f& a) const {
      return worldToImage<uint>(a);
    }
  
    BoundingBox3f worldToImagef(const BoundingBox3f& a) const {
      return worldToImage<float>(a);
    }
    BoundingBox3i worldToImagei(const BoundingBox3f& a) const {
      return worldToImage<int>(a);
    }
    BoundingBox3u worldToImageu(const BoundingBox3f& a) const {
      return worldToImage<uint>(a);
    }
  
    Point3f worldToImageVectorf(const Point3f& a) const {
      return worldToImageVector<float>(a);
    }
    Point3i worldToImageVectori(const Point3f& a) const {
      return worldToImageVector<int>(a);
    }
    Point3u worldToImageVectoru(const Point3f& a) const {
      return worldToImageVector<uint>(a);
    }
  
    Point3f abstractToWorld(const Point3f& p) const
    {
      return divide(p, scale()) * _texScale;
    }
  
    Point3f worldSize() const {
      return imageToWorldVector(_size);
    }
  
    bool boundsOK(int x, int y, int z) const
    {
      if(x < 0 or y < 0 or z < 0 or x >= int(_size.x()) or y >= int(_size.y()) or z >= int(_size.z()))
        return false;
      else
        return true;
    }
  
    size_t offset(uint x, uint y, uint z) const {
      return (size_t(z) * _size.y() + y) * _size.x() + x;
    }
  
    size_t offset(Point3i ipos) const {
      return (size_t(ipos.z()) * _size.y() + ipos.y()) * _size.x() + ipos.x();
    }
  
    Point3u position(size_t offset) const
    {
      uint x = offset % _size.x();
      offset = (offset - x) / _size.x();
      uint y = offset % _size.y();
      uint z = (offset - y) / _size.y();
      return Point3u(x, y, z);
    }
  
    void center();
  
    const qglviewer::ManipulatedFrame& frame() const {
      return _frame;
    }
  
    qglviewer::ManipulatedFrame& frame() {
      return _frame;
    }
  
    const qglviewer::ManipulatedFrame& trans() const {
      return _trans;
    }
    qglviewer::ManipulatedFrame& trans() {
      return _trans;
    }
  
    qglviewer::ManipulatedFrame& getFrame() {
      return (_showTrans ? _trans : _frame);
    }
  
    const qglviewer::ManipulatedFrame& getFrame() const {
      return (_showTrans ? _trans : _frame);
    }
  
    int viewLabel() const {
      return _CurrLabel;
    }
    void setLabel(int l)
    {
      _CurrLabel = l;
    }
    int nextLabel()
    {
      _CurrLabel++;
      if(_CurrLabel > ((1 << 16) - 1))
        _CurrLabel = 1;
      return _CurrLabel;
    }
 
    void setMainAsCurrent() {
      _current = _main;
    }
    void setWorkAsCurrent() {
      _current = _work;
    }
    void setNoneAsCurrent() {
      _current = 0;
    }
  
    void setCurrentStore(Store* store) {
      _current = (store == _main or store == _work) ? store : 0;
    }
  
    void reset();
  
  private:
    void resetModified();
    void updateSizes();
    void resetCurrent();
    Store* _main, *_work, *_current;
    Point3f _scale;
    // float _scale;
    Point3f _origin;
    float _texScale;
    Point3u _size;
    Point3f _step;
    qglviewer::ManipulatedFrame _frame;
    qglviewer::ManipulatedFrame _trans;
    bool changed_frame, changed_trans;
    int _id;
    int _CurrLabel;
    bool _showScale, _showTrans, _showBBox, _tieScales;
  };
}
 
#endif