GLView2D.h

/*
 * #%L
 * OME-QTWIDGETS C++ library for display of OME-Files pixel data and metadata.
 * %%
 * Copyright © 2014 - 2015 Open Microscopy Environment:
 *   - Massachusetts Institute of Technology
 *   - National Institutes of Health
 *   - University of Dundee
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 * %%
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of any organization.
 * #L%
 */

#ifndef OME_QTWIDGETS_GLVIEW2D_H
#define OME_QTWIDGETS_GLVIEW2D_H

#include <ome/files/FormatReader.h>

#include <ome/compat/memory.h>

#include <ome/qtwidgets/glm.h>
#include <ome/qtwidgets/GLWindow.h>
#include <ome/qtwidgets/gl/Image2D.h>
#include <ome/qtwidgets/gl/Grid2D.h>
#include <ome/qtwidgets/gl/Axis2D.h>

#include <QElapsedTimer>

namespace ome
{
  namespace qtwidgets
  {

    class GLView2D : public GLWindow
    {
      Q_OBJECT

    public:
      enum MouseMode
        {
          MODE_ZOOM,  
          MODE_PAN,   
          MODE_ROTATE 
        };

      GLView2D(ome::compat::shared_ptr<ome::files::FormatReader>  reader,
               ome::files::dimension_size_type                    series,
               QWidget                                                *parent = 0);

      ~GLView2D();

      QSize minimumSizeHint() const;

      QSize sizeHint() const;

    public slots:
      void
      setZoom(int zoom);

      void
      setXTranslation(int xtran);

      void
      setYTranslation(int ytran);

      void
      setZRotation(int angle);

      void
      setChannelMin(int min);

      void
      setChannelMax(int max);

      void
      setPlane(ome::files::dimension_size_type plane);

      void
      setMouseMode(MouseMode mode);

    public:
      ome::compat::shared_ptr<ome::files::FormatReader>
      getReader();

      ome::files::dimension_size_type
      getSeries();

      int
      getZoom() const;

      int
      getXTranslation() const;

      int
      getYTranslation() const;

      int
      getZRotation() const;

      int
      getChannelMin() const;

      int
      getChannelMax() const;

      ome::files::dimension_size_type
      getPlane() const;

      MouseMode
      getMouseMode() const;

    signals:
      void
      zoomChanged(int zoom);

      void
      xTranslationChanged(int xtran);

      void
      yTranslationChanged(int ytran);

      void
      zRotationChanged(int angle);

      void
      channelMinChanged(int min);

      void
      channelMaxChanged(int max);

      void
      planeChanged(ome::files::dimension_size_type plane);

    protected:
      void
      initialize();

      using GLWindow::render;

      void
      render();

      void
      resize();

      void
      mousePressEvent(QMouseEvent *event);

      void
      mouseMoveEvent(QMouseEvent *event);

      void
      timerEvent (QTimerEvent *event);

    private:
      struct Camera
      {
        enum ProjectionType
          {
            ORTHOGRAPHIC, 
            PERSPECTIVE   
          };

        Camera():
          projectionType(ORTHOGRAPHIC),
          zoom(0),
          xTran(0),
          yTran(0),
          zRot(0),
          model(1.0f),
          view(1.0f),
          projection(1.0f)
        {}

        ProjectionType projectionType;
        int zoom;
        int xTran;
        int yTran;
        int zRot;
        glm::mat4 model;
        glm::mat4 view;
        glm::mat4 projection;

        float
        zoomfactor() const
        {
          return std::pow(10.0f, static_cast<float>(zoom)/1024.0f); 
        }

        float
        rotation() const
        {
          return glm::radians(-static_cast<float>(zRot)/16.0f);
        }

        glm::mat4
        mvp() const
        {
          return projection * view * model;
        }
      };

      Camera camera;
      MouseMode mouseMode;
      QElapsedTimer etimer;
      glm::vec3 cmin;
      glm::vec3 cmax;
      ome::files::dimension_size_type plane;
      ome::files::dimension_size_type oldplane;
      QPoint lastPos;
      gl::Image2D *image;
      gl::Axis2D *axes;
      gl::Grid2D *grid;
      ome::compat::shared_ptr<ome::files::FormatReader> reader;
      ome::files::dimension_size_type series;
    };

  }
}

#endif // OME_QTWIDGETS_GLVIEW2D_H

/*
 * Local Variables:
 * mode:C++
 * End:
 */