Marble

ViewportParams.h
Go to the documentation of this file.
1// SPDX-License-Identifier: LGPL-2.1-or-later
2//
3// SPDX-FileCopyrightText: 2007 Inge Wallin <ingwa@kde.org>
4// SPDX-FileCopyrightText: 2008 Jens-Michael Hoffmann <jensmh@gmx.de>
5//
6
7#ifndef MARBLE_VIEWPORTPARAMS_H
8#define MARBLE_VIEWPORTPARAMS_H
9
10
11/** @file
12 * This file contains the headers for ViewportParams.
13 *
14 * @author Inge Wallin <inge@lysator.liu.se>
15 */
16
17#include <QSize>
18
19#include "GeoDataCoordinates.h"
20#include "Quaternion.h"
21#include "MarbleGlobal.h"
22#include "marble_export.h"
23
24class QPolygonF;
25class QPainterPath;
26
27namespace Marble
28{
29
30class GeoDataLatLonAltBox;
31class GeoDataLatLonBox;
32class GeoDataLineString;
33class AbstractProjection;
34class ViewportParamsPrivate;
35
36/**
37 * @short A public class that controls what is visible in the viewport of a Marble map.
38 *
39 */
40
41class MARBLE_EXPORT ViewportParams
42{
43 public:
45 explicit ViewportParams( Projection projection,
46 qreal centerLongitude = 0, qreal centerLatitude = 0,
47 int radius = 2000,
48 const QSize &size = QSize( 100, 100 ) );
50
51 // Getters and setters
52 Projection projection() const;
53 const AbstractProjection *currentProjection() const;
54 void setProjection(Projection newProjection);
55
56 int polarity() const;
57
58 const GeoDataLatLonAltBox& viewLatLonAltBox() const;
59
60 GeoDataLatLonAltBox latLonAltBox( const QRect &screenRect ) const;
61
62 // Calculates an educated guess for the average angle in radians covered per pixel.
63 // Given a certain resolution it doesn't make much sense
64 // - to display an object that covers an angle that is smaller than that.
65 // - to display two points as distinct points if they are separated by a
66 // an angular distance that is smaller. Instead only one point should be shown.
67 // So this method helps to filter out details.
68 // It's somewhat related to https://en.wikipedia.org/wiki/Angular_resolution
69
70 qreal angularResolution() const;
71
72 // Determines whether a geographical feature is big enough so that it should
73 // represent a single point on the screen already.
74 // See angularResolution()
75
76 bool resolves ( const GeoDataLatLonBox &latLonBox, qreal pixel = 2.0 ) const;
77
78 bool resolves ( const GeoDataLatLonAltBox &latLonAltBox, qreal pixel = 2.0, qreal altitude = 10000.0 ) const;
79
80 // Determines whether two points are located enough apart so that it makes
81 // sense to display them as distinct points. If this is not the case
82 // calculation and drawing of one point can be skipped as only a single
83 // point will be displayed on the screen.
84
85 bool resolves ( const GeoDataCoordinates &coord1, const GeoDataCoordinates &coord2 ) const;
86
87 int radius() const;
88
89 /**
90 * @brief Change the radius of the planet
91 * @param radius Size of the planet radius in pixel. Non-positive values are ignored.
92 */
93 void setRadius(int radius);
94
95 void centerOn( qreal lon, qreal lat );
96 void setHeading( qreal heading );
97
98 Quaternion planetAxis() const;
99 const matrix &planetAxisMatrix() const;
100
101 int width() const;
102 int height() const;
103 QSize size() const;
104
105 void setWidth(int newWidth);
106 void setHeight(int newHeight);
107 void setSize(const QSize& newSize);
108
109 qreal centerLongitude() const;
110 qreal centerLatitude() const;
111
112 /**
113 * @brief Get the screen coordinates corresponding to geographical coordinates in the map.
114 * @param lon the lon coordinate of the requested pixel position in radians
115 * @param lat the lat coordinate of the requested pixel position in radians
116 * @param x the x coordinate of the pixel is returned through this parameter
117 * @param y the y coordinate of the pixel is returned through this parameter
118 * @return @c true if the geographical coordinates are visible on the screen
119 * @c false if the geographical coordinates are not visible on the screen
120 *
121 * @see ViewportParams
122 */
123 bool screenCoordinates( const qreal lon, const qreal lat,
124 qreal &x, qreal &y ) const;
125
126 /**
127 * @brief Get the screen coordinates corresponding to geographical coordinates in the map.
128 *
129 * @param geopoint the point on earth, including altitude, that we want the coordinates for.
130 * @param x the x coordinate of the pixel is returned through this parameter
131 * @param y the y coordinate of the pixel is returned through this parameter
132 * @param globeHidesPoint whether the point gets hidden on the far side of the earth
133 *
134 * @return @c true if the geographical coordinates are visible on the screen
135 * @c false if the geographical coordinates are not visible on the screen
136 *
137 * @see ViewportParams
138 */
139 bool screenCoordinates( const GeoDataCoordinates &geopoint,
140 qreal &x, qreal &y,
141 bool &globeHidesPoint ) const;
142
143 // Will just call the virtual version with a dummy globeHidesPoint.
144 bool screenCoordinates( const GeoDataCoordinates &geopoint,
145 qreal &x, qreal &y ) const;
146
147 /**
148 * @brief Get the coordinates of screen points for geographical coordinates in the map.
149 *
150 * @param coordinates the point on earth, including altitude, that we want the coordinates for.
151 * @param x the x coordinates of the pixels are returned through this parameter
152 * @param y the y coordinate of the pixel is returned through this parameter
153 * @param pointRepeatNum the amount of times that a single geographical
154 point gets represented on the map
155 * @param size the size of the point
156 * @param globeHidesPoint whether the point gets hidden on the far side of the earth
157 *
158 * @return @c true if the geographical coordinates are visible on the screen
159 * @c false if the geographical coordinates are not visible on the screen
160 *
161 * @see ViewportParams
162 */
163 bool screenCoordinates( const GeoDataCoordinates &coordinates,
164 qreal *x, qreal &y, int &pointRepeatNum,
165 const QSizeF& size,
166 bool &globeHidesPoint ) const;
167
168
169 bool screenCoordinates( const GeoDataLineString &lineString,
170 QVector<QPolygonF*> &polygons ) const;
171
172 /**
173 * @brief Get the earth coordinates corresponding to a pixel in the map.
174 * @param x the x coordinate of the pixel
175 * @param y the y coordinate of the pixel
176 * @param lon the longitude angle is returned through this parameter
177 * @param lat the latitude angle is returned through this parameter
178 * @param unit the unit of the angles for lon and lat.
179 * @return @c true if the pixel (x, y) is within the globe
180 * @c false if the pixel (x, y) is outside the globe, i.e. in space.
181 */
182 bool geoCoordinates( const int x, const int y,
183 qreal &lon, qreal &lat,
184 GeoDataCoordinates::Unit unit = GeoDataCoordinates::Degree ) const;
185
186 qreal heading() const;
187 bool mapCoversViewport() const;
188
189 QPainterPath mapShape() const;
190
191 QRegion mapRegion() const;
192
193 /**
194 * @return The current point of focus, e.g. the point that is not moved
195 * when changing the zoom level. If not set, it defaults to the
196 * center point.
197 * @see centerCoordinates setFocusPoint resetFocusPoint
198 */
199 GeoDataCoordinates focusPoint() const;
200
201 /**
202 * @brief Change the point of focus, overridding any previously set focus point.
203 * @param focusPoint New focus point
204 * @see focusPoint resetFocusPoint
205 */
206 void setFocusPoint(const GeoDataCoordinates &focusPoint);
207
208 /**
209 * @brief Invalidate any focus point set with @ref setFocusPoint.
210 * @see focusPoint setFocusPoint
211 */
212 void resetFocusPoint();
213
214 private:
215 Q_DISABLE_COPY( ViewportParams )
216 ViewportParamsPrivate * const d;
217};
218
219}
220
221#endif
A base class for all projections in Marble.
A 3d point representation.
Unit
enum used constructor to specify the units used
A class that defines a 3D bounding box for geographic data.
A class that defines a 2D bounding box for geographic data.
A LineString that allows to store a contiguous set of line segments.
A public class that controls what is visible in the viewport of a Marble map.
Q_INVOKABLE void setProjection(uint proj)
Binds a QML item to a specific geodetic location in screen coordinates.
Projection
This enum is used to choose the projection shown in the view.
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Fri May 17 2024 11:49:24 by doxygen 1.10.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.