[seiscomp, scanloc] Install, add .gitignore

include/seiscomp/gui/map/imagetree.h

@@ -0,0 +1,254 @@
+/***************************************************************************
+ * Copyright (C) gempa GmbH                                                *
+ * All rights reserved.                                                    *
+ * Contact: gempa GmbH (seiscomp-dev@gempa.de)                             *
+ *                                                                         *
+ * GNU Affero General Public License Usage                                 *
+ * This file may be used under the terms of the GNU Affero                 *
+ * Public License version 3.0 as published by the Free Software Foundation *
+ * and appearing in the file LICENSE included in the packaging of this     *
+ * file. Please review the following information to ensure the GNU Affero  *
+ * Public License version 3.0 requirements will be met:                    *
+ * https://www.gnu.org/licenses/agpl-3.0.html.                             *
+ *                                                                         *
+ * Other Usage                                                             *
+ * Alternatively, this file may be used in accordance with the terms and   *
+ * conditions contained in a signed written agreement between you and      *
+ * gempa GmbH.                                                             *
+ ***************************************************************************/
+
+
+#ifndef SEISCOMP_GUI_MAP_IMAGETREE_H
+#define SEISCOMP_GUI_MAP_IMAGETREE_H
+
+
+#ifndef Q_MOC_RUN
+#include <seiscomp/core/interfacefactory.h>
+#include <seiscomp/core/baseobject.h>
+#endif
+#include <seiscomp/gui/core/maps.h>
+
+#include <QImage>
+
+
+namespace Seiscomp {
+namespace Gui {
+namespace Map {
+
+
+DEFINE_SMARTPOINTER(TextureCache);
+class ImageTree;
+
+
+struct SC_GUI_API TileIndex {
+	typedef uint64_t Storage;
+	enum Traits {
+		Invalid = uint64_t(-1),
+		MaxLevel = 29,
+		LevelBits = 5,
+		RowBits = MaxLevel,
+		ColumnBits = MaxLevel
+	};
+
+	Storage id;
+
+	TileIndex();
+	TileIndex(uint8_t level, uint32_t row, uint32_t column);
+
+	uint8_t level() const;
+	uint32_t row() const;
+	uint32_t column() const;
+
+	TileIndex parent() const;
+
+	bool operator==(const TileIndex &other) const;
+	bool operator!=(const TileIndex &other) const;
+	bool operator<(const TileIndex &other) const;
+
+	operator bool() const;
+};
+
+
+std::ostream &operator<<(std::ostream &os, const TileIndex &index);
+
+
+DEFINE_SMARTPOINTER(TileStore);
+class SC_GUI_API TileStore : public Core::BaseObject {
+	public:
+		enum LoadResult {
+			OK,
+			Deferred,
+			Error
+		};
+
+		TileStore();
+
+	public:
+		const QSize &tileSize() const { return _tilesize; }
+
+		//! Sets the parent image tree that gets notificiations about
+		//! state changed, e.g. finishedLoading.
+		void setImageTree(ImageTree *tree);
+
+	public:
+		virtual int maxLevel() const = 0;
+
+		//! Opens a tile repository and sets the desc flags accordingly
+		//! if necessary.
+		virtual bool open(MapsDesc &desc) = 0;
+
+		/**
+		 * @brief Load a tile for a given index.
+		 * Loading can happen synchronously or asynchronously. The later case
+		 * should return the status LoadResult::Deferred and an invalid
+		 * image. If a deferred image could not be loaded by the store it
+		 * should then call invalidate with the failed index.
+		 * @param img The image to be populated.
+		 * @param tile The tile index
+		 * @return Success flag.
+		 */
+		virtual LoadResult load(QImage &img, const TileIndex &tile) = 0;
+
+		//! Return a unique ID for a node
+		virtual QString getID(const TileIndex &tile) const = 0;
+
+		//! Validate the existance of a tile
+		virtual bool validate(int level, int column, int row) const = 0;
+
+		virtual bool hasPendingRequests() const = 0;
+
+		//! Refresh the image store, e.g. invalidate its cache
+		virtual void refresh() = 0;
+
+
+	protected:
+		//! Async notification that a tile has been loaded.
+		void finishedLoading(QImage &img, const TileIndex &tile);
+
+		//! Async notification that a tile has been loaded.
+		void loadingComplete(QImage &img, TileIndex tile);
+		//! Async notification that loading a tile has been aborted
+		void loadingCancelled(TileIndex tile);
+
+		//! Invalidates the tile of a particular node
+		void invalidate(const TileIndex &tile);
+
+
+	protected:
+		ImageTree *_tree;
+		QSize      _tilesize;
+
+};
+
+
+DEFINE_INTERFACE_FACTORY(TileStore);
+
+#define REGISTER_TILESTORE_INTERFACE(Class, Service) \
+Seiscomp::Core::Generic::InterfaceFactory<Seiscomp::Gui::Map::TileStore, Class> __##Class##InterfaceFactory__(Service)
+
+
+DEFINE_SMARTPOINTER(ImageTree);
+class SC_GUI_API ImageTree : public QObject, public Core::BaseObject {
+	Q_OBJECT
+
+	public:
+		ImageTree(const MapsDesc &desc);
+		~ImageTree();
+
+
+	public:
+		bool valid() const { return _store.get(); }
+
+		//! This function was introduced in API 1.1
+		bool hasPendingRequests() const { return _store && _store->hasPendingRequests(); }
+
+		//! Returns the currently attached cache instance.
+		//! If no cache is yet attached a new cache is
+		//! created and stored in the object.
+		TextureCache *getCache();
+
+		//! Empties the texture cache and tells the store to do a refresh
+		//! as well.
+		//! This function was introduced in API 1.1.
+		void refresh();
+
+
+	public:
+		void finishedLoading(QImage &img, const TileIndex &tile);
+		void loadingComplete(QImage &img, TileIndex tile);
+		void loadingCancelled(TileIndex tile);
+		void invalidate(const TileIndex &tile);
+
+
+	signals:
+		void tilesUpdated();
+
+		//! Emitted when all tiles are loaded and no asynchronous requests
+		//! are still pending.
+		//! This signal was introduced in API 1.1.
+		void tilesComplete();
+
+
+	protected:
+		TextureCachePtr _cache;
+		TileStorePtr    _store;
+		bool            _isMercatorProjected;
+		size_t          _cacheSize;
+
+
+	friend class TileStore;
+};
+
+
+inline TileIndex::TileIndex() : id(Invalid) {}
+inline TileIndex::TileIndex(uint8_t level, uint32_t row, uint32_t column) {
+	id = ((Storage(level) & ((1 << LevelBits) - 1)) << (RowBits + ColumnBits)) |
+	     ((Storage(row) & ((1 << RowBits) - 1)) << ColumnBits) |
+	     (Storage(column) & ((1 << ColumnBits) - 1));
+}
+
+inline uint8_t TileIndex::level() const {
+	return (id >> (RowBits + ColumnBits)) & ((1 << LevelBits) - 1);
+}
+
+inline uint32_t TileIndex::row() const {
+	return (id >> ColumnBits) & ((1 << RowBits) - 1);
+}
+
+inline uint32_t TileIndex::column() const {
+	return id & ((1 << ColumnBits) - 1);
+}
+
+inline TileIndex TileIndex::parent() const {
+	auto l = level();
+	return l ? TileIndex(l-1, row() >> 1, column() >> 1) : TileIndex();
+}
+
+inline bool TileIndex::operator==(const TileIndex &other) const {
+	return id == other.id;
+}
+
+inline bool TileIndex::operator!=(const TileIndex &other) const {
+	return id != other.id;
+}
+
+inline bool TileIndex::operator<(const TileIndex &other) const {
+	return id < other.id;
+}
+
+inline TileIndex::operator bool() const {
+	return id != Invalid;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const TileIndex &index) {
+	os << static_cast<int>(index.level()) << "/" << index.row() << "/" << index.column();
+	return os;
+}
+
+
+}
+}
+}
+
+
+#endif