Subversion Repositories public iLand

/********************************************************************************************
**    iLand - an individual based forest landscape and disturbance model
**    http://iland.boku.ac.at
**    Copyright (C) 2009-  Werner Rammer, Rupert Seidl
**
**    This program 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 3 of the License, or
**    (at your option) any later version.
**
**    This program 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, see <http://www.gnu.org/licenses/>.
********************************************************************************************/
#include "global.h"
#include "viewport.h"


/** @class Viewport
  Handles coordinaive transforation between grids (based on real-world metric coordinates).
  The visible part of the grid is defined by the "viewport" (defaults to 100% of the grid).
  The result coordinates are mapped into a "ScreenRect", which is a pixel-based viewing window.
*/

/// toWorld() converts the pixel-information (e.g. by an mouse event) to the corresponding real world coordinates (defined by viewport).
const QPointF Viewport::toWorld(const QPoint pixel)
{
    QPointF p;
    p.setX( pixel.x()/m_scale_worldtoscreen +  m_delta_worldtoscreen.x());
    p.setY( (m_screen.height() - pixel.y()  )/m_scale_worldtoscreen + m_delta_worldtoscreen.y() );
    return p;

}

/// toScreen() converts world coordinates in screen coordinates using the defined viewport.
const QPoint Viewport::toScreen(const QPointF p)
{
    QPoint pixel;
    pixel.setX( qRound( (p.x()-m_delta_worldtoscreen.x())* m_scale_worldtoscreen ) );
    pixel.setY( m_screen.height() - 1 -  qRound( (p.y()-m_delta_worldtoscreen.y() ) * m_scale_worldtoscreen ));
    return pixel;
}

/// sets the screen rect; this also modifies the viewport.
void Viewport::setScreenRect(const QRect &viewrect)
{
    if (m_screen!=viewrect) {
        m_screen = viewrect;
        m_viewport = viewrect;
        zoomToAll();
    }
}

/// show the full extent of the world.
void Viewport::zoomToAll()
{
    // calculate move/scale so that world-rect maps entirely onto screen
    double scale_x = m_screen.width() /  m_world.width(); // pixel per meter in x
    double scale_y = m_screen.height() / m_world.height(); // pixel per meter in y
    double scale = qMin(scale_x, scale_y);
    QPointF d;
    if (scale_x < scale_y) {
        // x-axis fills the screen; center in y-axis
        d.setX(m_world.left());
        int py_mid = m_screen.height()/2;
        double world_mid = m_world.center().y();
        d.setY( world_mid - py_mid/scale );
    } else {
        d.setY(m_world.top());
        int px_mid = m_screen.width()/2;
        double world_mid = m_world.center().x();
        d.setX( world_mid - px_mid/scale );
    }
    m_delta_worldtoscreen = d;
    m_scale_worldtoscreen = scale;
    m_viewport.setBottomLeft(toWorld(m_screen.topLeft()));
    m_viewport.setTopRight(toWorld(m_screen.bottomRight()));
}

/// zoom using a factor of @p factor. Values > 1 means zoom out, < 1 zoom in. (factor=1 would have no effect).
/// after zooming, the world-point under the mouse @p screen_point is still under the mouse.
void Viewport::zoomTo(const QPoint &screen_point, const double factor)
{
    QPointF focus_point = toWorld(screen_point); // point under the mouse

    m_viewport.setWidth(m_viewport.width() * factor);
    m_viewport.setHeight(m_viewport.height() * factor);

    m_scale_worldtoscreen /= factor;

    // get scale/delta
    QPointF new_focus = toWorld(screen_point);
    m_delta_worldtoscreen -= (new_focus - focus_point);

    m_viewport.setBottomLeft(toWorld(m_screen.topLeft()));
    m_viewport.setTopRight(toWorld(m_screen.bottomRight()));

    //qDebug() <<"oldf"<< new_focus << "newf" << focus_point << "m_delta" << m_delta_worldtoscreen << "m_scale:" << m_scale_worldtoscreen << "viewport:"<<m_viewport;
}

/// move the viewport. @p screen_from and @p screen_to give mouse positions (in pixel) from dragging the mouse.
void Viewport::moveTo(const QPoint &screen_from, const QPoint &screen_to)
{
    QPointF p1 = toWorld(screen_from);
    QPointF p2 = toWorld(screen_to);
    m_delta_worldtoscreen -= (p2-p1);
    // correct the viewport
    m_viewport.setBottomLeft(toWorld(m_screen.topLeft()));
    m_viewport.setTopRight(toWorld(m_screen.bottomRight()));
}

/// set 'world_center' as the new center point of the viewport
void Viewport::setViewPoint(const QPointF &world_center, const double px_per_meter)
{
    QPoint p = toScreen(world_center); // point where world_center would be
    QPoint target = m_screen.center();
    moveTo(p,target);
    double px_p_m = qMax(px_per_meter, 0.001);
    double factor =  m_scale_worldtoscreen / px_p_m;
    zoomTo(target, factor);
}

bool Viewport::isVisible(const QPointF &world_coord) const
{
    return m_viewport.contains(world_coord);
}
bool Viewport::isVisible(const QRectF &world_rect) const
{
    return m_viewport.contains(world_rect)
            || m_viewport.intersects(world_rect);
}