worked on 3D viz

scaling, moving by finger
some fixes / improvement

mapview/2D/MapView2D.cpp

@@ -101,50 +101,29 @@ void MapView2D::mouseReleaseEvent(QMouseEvent* e) {
 
 // android
 bool MapView2D::event(QEvent* event) {
-
 	if (event->type() == QEvent::Gesture) {
 		return gestureEvent(static_cast<QGestureEvent*>(event));
 	} else {
 		return QWidget::event(event);
 	}
-
 }
 
 bool MapView2D::gestureEvent(QGestureEvent* event) {
-	//qCDebug(lcExample) << "gestureEvent():" << event;
 	if (QGesture *swipe = event->gesture(Qt::SwipeGesture)) {
         //swipeTriggered(static_cast<QSwipeGesture *>(swipe));
 	} else if (QGesture *pan = event->gesture(Qt::PanGesture))
         panTriggered(static_cast<QPanGesture *>(pan));
+		return true;
 	if (QGesture *pinch = event->gesture(Qt::PinchGesture)) {
 		pinchTriggered(static_cast<QPinchGesture *>(pinch));
+		return true;
 	}
-	return true;
+	return false;
 }
 
 void MapView2D::pinchTriggered(QPinchGesture* gesture) {
-
 	tools.pinchTriggered(this, gesture);
 	update();
-
-//	QPinchGesture::ChangeFlags changeFlags = gesture->changeFlags();
-//	if (changeFlags & QPinchGesture::RotationAngleChanged) {
-////		qreal rotationDelta = gesture->rotationAngle() - gesture->lastRotationAngle();
-////		rotationAngle += rotationDelta;
-////		qCDebug(lcExample) << "pinchTriggered(): rotate by" <<
-////			rotationDelta << "->" << rotationAngle;
-//	}
-//	if (changeFlags & QPinchGesture::ScaleFactorChanged) {
-////		currentStepScaleFactor = gesture->totalScaleFactor();
-////		qCDebug(lcExample) << "pinchTriggered(): zoom by" <<
-////			gesture->scaleFactor() << "->" << currentStepScaleFactor;
-//		std::cout << gesture->totalScaleFactor() << std::endl;
-//	}
-//	if (gesture->state() == Qt::GestureFinished) {
-////		scaleFactor *= currentStepScaleFactor;
-////		currentStepScaleFactor = 1;
-//	}
-//	update();
 }
 
 void MapView2D::panTriggered(QPanGesture* gesture) {

mapview/3D/MapView3D.cpp

@@ -11,6 +11,9 @@
 #include "../3D/navMesh/NavMeshModel.h"
 #include "../3D/navMesh/NavMeshRenderer.h"
 
+#include "../3D/floorplan/FloorplanRenderer.h"
+#include "../3D/floorplan/FloorplanRendererModel.h"
+
 #include <QPushButton>
 
 MapView3D::MapView3D(QWidget *parent) : QOpenGLWidget(parent) {
@@ -29,6 +32,9 @@ MapView3D::MapView3D(QWidget *parent) : QOpenGLWidget(parent) {
 
 	gridRenderer = new GridRenderer();
 
+	floorplanRenderer = new FloorplanRenderer();
+	floorplanRendererModel = new FloorplanRendererModel();
+
 	QString style = "QPushButton:checked{\
 			background-color: rgb(200, 200, 230);\
 			border: none; \
@@ -68,6 +74,18 @@ MapView3D::MapView3D(QWidget *parent) : QOpenGLWidget(parent) {
 		emit onShow3DNavMesh(btnNavMesh->isChecked());
 	});
 
+	// android
+	setAttribute(Qt::WA_AcceptTouchEvents, true);
+	grabGesture(Qt::PanGesture);
+	grabGesture(Qt::PinchGesture);
+
+	auto format = QSurfaceFormat();
+	//format.setVersion(4,3);
+	format.setSamples(4);
+	//format.setProfile(QSurfaceFormat::CoreProfile);
+
+	setFormat(format);
+
 }
 
 
@@ -84,22 +102,17 @@ void MapView3D::initializeGL() {
 
 	// additional settings
 	glEnable(GL_DEPTH_TEST);
-	glClearColor(1,1,1,1);
+	glClearColor(0.9, 0.9, 1.0, 1.0);
 
 }
 
 void MapView3D::paintGL() {
-
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
 	draw();
-
 }
 
 void MapView3D::resizeGL(int width, int height) {
-
 	glViewport(0, 0, width, height);
-
 }
 
 
@@ -117,18 +130,22 @@ void MapView3D::mouseMoveEvent(QMouseEvent* e) {
 		rot.z -= dx/2.0f;
 		rot.x -= dy/2.0f;
 	} else if (mouse.btn == 4) {
-		//Point3 vec(-dx / width() * 2 * viewport.size.x, 0, +dy / height() * 2 * viewport.size.y);
-		Point3 vec(-dx / width() * 2 * viewport.size.x, +dy / height() * 2 * viewport.size.y, 0);
-		//Point3 vec(-dx * 2 / width() , 0, +dy * 2 / height());
-		vec = vec.rot(-rot.x/180*M_PI, -rot.y/180*M_PI, -rot.z/180*M_PI);
-		vec /= scale;
-		center += vec;
+		moveXY(dx, dy);
 	}
 	mouse.x = e->x();
 	mouse.y = e->y();
 	update();
 }
 
+void MapView3D::moveXY(float dx, float dy) {
+	//Point3 vec(-dx / width() * 2 * viewport.size.x, 0, +dy / height() * 2 * viewport.size.y);
+	Point3 vec(-dx / width() * 2 * viewport.size.x, +dy / height() * 2 * viewport.size.y, 0);
+	//Point3 vec(-dx * 2 / width() , 0, +dy * 2 / height());
+	vec = vec.rot(-rot.x/180*M_PI, -rot.y/180*M_PI, -rot.z/180*M_PI);
+	vec /= scale;
+	center += vec;
+}
+
 void MapView3D::mouseReleaseEvent(QMouseEvent* e) {
 	(void) e;
 	update();
@@ -140,14 +157,52 @@ void MapView3D::wheelEvent(QWheelEvent* e) {
 	update();
 }
 
+// android
+bool MapView3D::event(QEvent* event) {
+	if (event->type() == QEvent::Gesture) {
+		return gestureEvent(static_cast<QGestureEvent*>(event));
+	//} else if (event->type() == QEvent::TouchBegin) {
+	//	return true;
+	//} else if (event->type() == QEvent::TouchUpdate) {
+	//	return true;
+	} else {
+		return QWidget::event(event);
+	}
+}
+
+bool MapView3D::gestureEvent(QGestureEvent* event) {
+	if (QGesture *swipe = event->gesture(Qt::SwipeGesture)) {
+		//swipeTriggered(static_cast<QSwipeGesture *>(swipe));
+	} else if (QGesture *pan = event->gesture(Qt::PanGesture))
+		panTriggered(static_cast<QPanGesture *>(pan));
+		return true;
+	if (QGesture *pinch = event->gesture(Qt::PinchGesture)) {
+		pinchTriggered(static_cast<QPinchGesture *>(pinch));
+		return true;
+	}
+	return false;
+}
+
+void MapView3D::pinchTriggered(QPinchGesture* gesture) {
+	update();
+}
+
+void MapView3D::panTriggered(QPanGesture* gesture) {
+	moveXY(gesture->delta().x(), gesture->delta().y());
+	update();
+}
+
+
+
+
 
 void MapView3D::setShowFloorplan(bool show) {
 
 	this->showFloorplan = show;
+	if (!show) {update(); return;}
 
-	//if (gridModel) {delete gridModel; gridModel = nullptr;}
-	//if (navMeshModel) {delete navMeshModel; navMeshModel = nullptr;}
-	update();
+	// refresh
+	layerChange();
 
 }
 
@@ -193,26 +248,32 @@ void MapView3D::setShowNavMesh(bool show) {
 
 }
 
+void MapView3D::layerChange() {
+
+	// todo: layers??
+	Floorplan::IndoorMap* im = getModel()->getMap();
+	this->floorplanRendererModel->rebuild(im);
+	update();
+
+}
+
 #include "misc/Shader.h"
 
 void MapView3D::draw() {
 
 	static RenderSettings rs = RenderSettings(new Shader());
 
-
-
 	// view
 	QMatrix4x4 V;
 
-	V.translate(0,0,-30);
+	V.translate(0,0,-50);	// above the building
 	V.scale(scale.x, scale.y, scale.z);
 	V.rotate(rot.x, 1.0, 0.0, 0.0);
 	V.rotate(rot.y, 0.0, 1.0, 0.0);
 	V.rotate(rot.z, 0.0, 0.0, 1.0);
 	V.translate(center.x, center.y, center.z);
 
-//	V.lookAt(QVector3D(30,-25,25), QVector3D(30,10,0), QVector3D(0,1,0));
-
+	float far = 200;	// TODO
 
 	// projection
 	QMatrix4x4 P;
@@ -223,30 +284,34 @@ void MapView3D::draw() {
 		float h = height() / 30;
 		viewport.size.x = w;
 		viewport.size.y = h;
-		P.perspective(45.0f, aspect, 0.01, 100);
+		P.perspective(45.0f, aspect, 0.01, far);
 	} else {
 		// default size: 50 * 50/aspect meters
 		float w = 50.0f;
 		float h = 50.0f * height() / width();
 		viewport.size.x = w;
 		viewport.size.y = h;
-		P.ortho(-w, +w, -h, +h, 0.1f, +100);
+		P.ortho(-w, +w, -h, +h, 0.1f, +far);
 	}
 
 	rs.shader->bind();
 	rs.shader->setViewMatrix(V);
 	rs.shader->setProjectionMatrix(P);
 
-	// solid floorplan parts
-	if (showFloorplan) {
-
-		std::vector<MapModelElement*> elements = getModel()->getVisibleElements();
-		for (MapModelElement* el : elements) {
-			if (el->getMV3D() && !el->getMV3D()->isTransparent()) {el->getMV3D()->render(rs);}
-		}
-
+	if (floorplanRenderer && floorplanRendererModel) {
+		floorplanRenderer->renderSolid(rs, floorplanRendererModel->getTriaSolid() );
 	}
 
+//	// solid floorplan parts
+//	if (showFloorplan) {
+
+//		std::vector<MapModelElement*> elements = getModel()->getVisibleElements();
+//		for (MapModelElement* el : elements) {
+//			if (el->getMV3D() && !el->getMV3D()->isTransparent()) {el->getMV3D()->render(rs);}
+//		}
+
+//	}
+
 //	if (showGrid && gridModel) {
 //		gridRenderer->paintGL(gridModel->getGrid());
 //	}
@@ -255,14 +320,18 @@ void MapView3D::draw() {
 		navMeshRenderer->render(rs, navMeshModel->getNavMesh(), this);
 	}
 
-	// transparant floorplan parts
-	if (showFloorplan) {
+//	// transparant floorplan parts
+//	if (showFloorplan) {
 
-		std::vector<MapModelElement*> elements = getModel()->getVisibleElements();
-		for (MapModelElement* el : elements) {
-			if (el->getMV3D() && el->getMV3D()->isTransparent()) {el->getMV3D()->render(rs);}
-		}
+//		std::vector<MapModelElement*> elements = getModel()->getVisibleElements();
+//		for (MapModelElement* el : elements) {
+//			if (el->getMV3D() && el->getMV3D()->isTransparent()) {el->getMV3D()->render(rs);}
+//		}
 
+//	}
+
+	if (floorplanRenderer && floorplanRendererModel) {
+		floorplanRenderer->renderTransp(rs, floorplanRendererModel->getTriaTransp() );
 	}
 
 

mapview/3D/MapView3D.h

@@ -13,6 +13,8 @@ class GridModel;
 class GridRenderer;
 class NavMeshRenderer;
 class NavMeshModel;
+class FloorplanRenderer;
+class FloorplanRendererModel;
 
 class MapView3D : public QOpenGLWidget {
 
@@ -30,13 +32,17 @@ public:
 		update();
 	}
 
-	void layerChange() {
-		update();
-	}
+	/** redraw on layer change */
+	void layerChange();
+
 
 	/** get the underlying data-model */
 	MapModel* getModel() {return model;}
 
+
+	/** get the renderer to use for the floorplan */
+	FloorplanRenderer* getFloorplanRenderer() {return floorplanRenderer;}
+
 	/** get the renderer to use for the grid */
 	GridRenderer* getGridRenderer() {return gridRenderer;}
 
@@ -67,6 +73,9 @@ private:
 	/** the underlying data-model */
 	MapModel* model = nullptr;
 
+	FloorplanRenderer* floorplanRenderer = nullptr;
+	FloorplanRendererModel* floorplanRendererModel = nullptr;
+
 	GridModel* gridModel = nullptr;
 	GridRenderer* gridRenderer = nullptr;
 
@@ -104,6 +113,16 @@ protected:
 	void mouseReleaseEvent(QMouseEvent* e);
 	void wheelEvent(QWheelEvent* e);
 
+	// android
+	bool event(QEvent *e) override;
+	bool gestureEvent(QGestureEvent* event);
+	void pinchTriggered(QPinchGesture* gesture);
+	void panTriggered(QPanGesture* gesture);
+
+private:
+
+	void moveXY(float dx, float dy);
+
 signals:
 
 	void onShow3DFloorplan(bool show);

mapview/3D/floorplan/FloorplanRenderer.h

@@ -0,0 +1,72 @@
+#ifndef FLOORPLANRENDERER_H
+#define FLOORPLANRENDERER_H
+
+#include <unordered_set>
+#include <Indoor/navMesh/NavMesh.h>
+#include <Indoor/navMesh/NavMeshTriangle.h>
+#include <Indoor/navMesh/NavMeshType.h>
+
+#include <QPainter>
+#include <QOpenGLWidget>
+
+#include "../misc/Renderable3D.h"
+#include "../misc/Shader.h"
+#include "../misc/TriangleData.h"
+
+#include <Indoor/wifi/estimate/ray3/ModelFactory.h>
+
+#include "RenderTriangle.h"
+
+class FloorplanRenderer {
+
+public:
+
+	/** ctor */
+	FloorplanRenderer()  {
+		;
+	}
+
+	/** render the given grid using GL commands */
+	void renderSolid(const RenderSettings& rs, const RenderTriangle& rt) {
+
+		rs.shader->bind();
+		rs.shader->setModelMatrix(QMatrix4x4());
+
+		rs.shader->setVertices(rt.getVertices().data());
+		rs.shader->setNormals(rt.getNormals().data());
+		rs.shader->setVertexColor(rt.getRGBA().data());
+		glDrawArrays(GL_TRIANGLES, 0, rt.getVertices().size()/3);
+		rs.shader->unsetVertices();
+		rs.shader->unsetNormals();
+		rs.shader->unsetVertexColor();
+
+		rs.shader->release();
+
+	}
+
+	/** render the given grid using GL commands */
+	void renderTransp(const RenderSettings& rs, const RenderTriangle& rt) {
+
+		glEnable(GL_BLEND);
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+		rs.shader->bind();
+		rs.shader->setModelMatrix(QMatrix4x4());
+
+		rs.shader->setVertices(rt.getVertices().data());
+		rs.shader->setNormals(rt.getNormals().data());
+		rs.shader->setVertexColor(rt.getRGBA().data());
+		glDrawArrays(GL_TRIANGLES, 0, rt.getVertices().size()/3);
+		rs.shader->unsetVertices();
+		rs.shader->unsetNormals();
+		rs.shader->unsetVertexColor();
+
+		rs.shader->release();
+
+		glDisable(GL_BLEND);
+
+	}
+
+};
+
+#endif // FLOORPLANRENDERER_H

mapview/3D/floorplan/FloorplanRendererModel.h

@@ -0,0 +1,110 @@
+#ifndef FLOORPLANRENDERERMODEL_H
+#define FLOORPLANRENDERERMODEL_H
+
+#include <Indoor/floorplan/v2/Floorplan.h>
+#include <Indoor/navMesh/NavMesh.h>
+#include <Indoor/navMesh/NavMeshFactory.h>
+#include <Indoor/navMesh/NavMeshFactoryListener.h>
+#include <Indoor/wifi/estimate/ray3/ModelFactory.h>
+
+#include "RenderTriangle.h"
+
+/**
+ * model for rendering the floorplan
+ */
+class FloorplanRendererModel {
+
+private:
+
+	Floorplan::IndoorMap* im;
+	Ray3D::FloorplanMesh mesh;
+
+	RenderTriangle triaSolid;
+	RenderTriangle triaTransp;
+
+	struct Material {
+		int r, g, b, a;
+		Material(int r, int g, int b, int a) : r(r), g(g), b(b), a(a) {;}
+	};
+
+	const std::vector<Material> mats = {
+
+		Material(0,128,0,255),		// ground outdoor
+		Material(64,64,64,255),		// ground outdoor
+		Material(255,96,96,255),	// stair
+		Material(220,220,220,255),	// handrail
+
+		Material(200,200,255,96),	// door (glass)
+		Material(200,160,150,255),	// door (wood)
+
+		Material(128,128,128,255),	// concrete
+		Material(200,200,255,96),	// glass
+
+		Material(200,200,200,255),	// default
+
+	};
+
+	int getMaterial(const Ray3D::Obstacle3D& o) const {
+
+		if (o.type == Ray3D::Obstacle3D::Type::GROUND_OUTDOOR)									{return 0;}
+		if (o.type == Ray3D::Obstacle3D::Type::GROUND_INDOOR)									{return 1;}
+		if (o.type == Ray3D::Obstacle3D::Type::STAIR)											{return 2;}
+		if (o.type == Ray3D::Obstacle3D::Type::HANDRAIL)										{return 3;}
+
+		if (o.type == Ray3D::Obstacle3D::Type::DOOR && o.mat == Floorplan::Material::GLASS)		{return 4;}
+		if (o.type == Ray3D::Obstacle3D::Type::DOOR)											{return 5;}
+
+		if (o.mat == Floorplan::Material::CONCRETE)												{return 6;}
+		if (o.mat == Floorplan::Material::GLASS)												{return 7;}
+
+		return 8;
+
+	}
+
+
+public:
+
+	/** ctor */
+	FloorplanRendererModel() {
+		;
+	}
+
+	Ray3D::FloorplanMesh& getMesh() {
+		return mesh;
+	}
+
+	const RenderTriangle& getTriaSolid() {
+		return triaSolid;
+	}
+
+	const RenderTriangle& getTriaTransp() {
+		return triaTransp;
+	}
+
+	void rebuild(Floorplan::IndoorMap* im) {
+
+		// rebuild the mesh
+		Ray3D::ModelFactory fac(im);
+		mesh = fac.getMesh();
+
+		triaTransp.clear();
+		triaSolid.clear();
+
+		for (const Ray3D::Obstacle3D& obs : mesh.elements) {
+			const int matID = getMaterial(obs);
+			const Material& mat = mats[matID];
+			for (const Triangle3& tria : obs.triangles) {
+				const Point3 n = cross(tria.p2-tria.p1, tria.p3-tria.p1).normalized();
+				if (mat.a != 255) {
+					triaTransp.addTriangle(tria.p1, tria.p2, tria.p3, n, mat.r/255.0f, mat.g/255.0f, mat.b/255.0f, mat.a/255.0f);
+				} else {
+					triaSolid.addTriangle(tria.p1, tria.p2, tria.p3, n, mat.r/255.0f, mat.g/255.0f, mat.b/255.0f, mat.a/255.0f);
+				}
+			}
+		}
+
+	}
+
+};
+
+#endif // FLOORPLANRENDERERMODEL_H

mapview/3D/floorplan/RenderTriangle.h

@@ -0,0 +1,78 @@
+#ifndef RENDERTRIANGLE_H
+#define RENDERTRIANGLE_H
+
+
+#include <vector>
+#include <Indoor/geo/Point3.h>
+
+class RenderTriangle  {
+
+	std::vector<float> vertices;
+	std::vector<float> normals;
+	std::vector<float> rgba;
+
+public:
+
+	void addTriangle(Point3 p1, Point3 p2, Point3 p3) {
+
+		vertices.insert(vertices.end(), {p1.x, p1.y, p1.z});
+		vertices.insert(vertices.end(), {p2.x, p2.y, p2.z});
+		vertices.insert(vertices.end(), {p3.x, p3.y, p3.z});
+
+	}
+
+	void addTriangle(Point3 p1, Point3 p2, Point3 p3, const Point3 n) {
+
+		vertices.insert(vertices.end(), {p1.x, p1.y, p1.z});
+		vertices.insert(vertices.end(), {p2.x, p2.y, p2.z});
+		vertices.insert(vertices.end(), {p3.x, p3.y, p3.z});
+
+		normals.insert(normals.end(), {n.x, n.y, n.z});
+		normals.insert(normals.end(), {n.x, n.y, n.z});
+		normals.insert(normals.end(), {n.x, n.y, n.z});
+
+	}
+
+	void addTriangle(Point3 p1, Point3 p2, Point3 p3, const Point3 n, const float r, const float g, const float b, const float a) {
+
+		vertices.insert(vertices.end(), {p1.x, p1.y, p1.z});
+		vertices.insert(vertices.end(), {p2.x, p2.y, p2.z});
+		vertices.insert(vertices.end(), {p3.x, p3.y, p3.z});
+
+		normals.insert(normals.end(), {n.x, n.y, n.z});
+		normals.insert(normals.end(), {n.x, n.y, n.z});
+		normals.insert(normals.end(), {n.x, n.y, n.z});
+
+		rgba.insert(rgba.end(), {r,g,b,a});
+		rgba.insert(rgba.end(), {r,g,b,a});
+		rgba.insert(rgba.end(), {r,g,b,a});
+
+	}
+
+
+	void addLine(Point3 p1, Point3 p2, const float r, const float g, const float b, const float a) {
+
+		vertices.insert(vertices.end(), {p1.x, p1.y, p1.z});
+		vertices.insert(vertices.end(), {p2.x, p2.y, p2.z});
+
+		rgba.insert(rgba.end(), {r,g,b,a});
+		rgba.insert(rgba.end(), {r,g,b,a});
+
+	}
+
+	void clear() {
+		vertices.clear();
+		normals.clear();
+		rgba.clear();
+	}
+
+	const std::vector<float>& getVertices() const {return vertices;}
+
+	const std::vector<float>& getNormals() const {return normals;}
+
+	const std::vector<float>& getRGBA() const {return rgba;}
+
+};
+
+
+#endif // RENDERTRIANGLE_H

mapview/3D/misc/Polygon.h

@@ -1,6 +1,7 @@
 #ifndef POLYGON_H
 #define POLYGON_H
 
+
 #include <Indoor/floorplan/v2/Floorplan.h>
 #include "../../../lib/gpc/gpc.h"
 

mapview/3D/misc/TriangleData.h

@@ -45,7 +45,6 @@ public:
 		rgba.insert(rgba.end(), {r,g,b,a});
 		rgba.insert(rgba.end(), {r,g,b,a});
 		rgba.insert(rgba.end(), {r,g,b,a});
-		rgba.insert(rgba.end(), {r,g,b,a});
 
 	}
 

mapview/model/MMFloor.h

@@ -50,6 +50,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		floor->enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	/** ctor. new floor. */
 	MMFloor(MapLayer* parent) : MapLayer(parent), floor(nullptr) {
 		throw "not yet implemented";
@@ -58,12 +67,6 @@ public:
 	/** get the underlying model */
 	Floorplan::Floor& getFloor() {return *floor;}
 
-	virtual void setVisible(const bool visible) override {
-		floor->enabled = visible;
-		MapLayer::setVisible(visible);
-	}
-
-
 	std::string getLayerName() const override {return floor->name;}
 
 	virtual int getNumParams() const override {

mapview/model/MMFloorAccessPoints.h

@@ -27,6 +27,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->accesspoints.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->accesspoints.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	std::string getLayerName() const override {return "APs";}
 
 	//TODO: check

mapview/model/MMFloorBeacons.h

@@ -27,6 +27,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->beacons.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->beacons.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	std::string getLayerName() const override {return "Beacons";}
 
 	//TODO: check

mapview/model/MMFloorElevators.h

@@ -29,6 +29,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->elevators.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->elevators.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	std::string getLayerName() const override {return "Elevators";}
 
 	//TODO: check

mapview/model/MMFloorFingerprints.h

@@ -27,6 +27,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->fpLocations.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->fpLocations.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	/** get the corresponding floor from the underlying model */
 	Floorplan::Floor* getFloor() {return floor;}
 

mapview/model/MMFloorGroundTruthPoints.h

@@ -25,6 +25,15 @@ public:
 
     }
 
+	bool isVisible() const override {
+		return floor->gtpoints.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->gtpoints.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
     /** get the corresponding floor from the underlying model */
     Floorplan::Floor* getFloor() {return floor;}
 

mapview/model/MMFloorObstacles.h

@@ -35,6 +35,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->obstacles.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->obstacles.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	/** get the corresponding floor from the underlying model */
 	Floorplan::Floor* getFloor() {return floor;}
 

mapview/model/MMFloorOutline.h

@@ -36,6 +36,14 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->outline.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->outline.enabled = visible;
+		onVisibilityChanged(visible);
+	}
 
 	/** get the corresponding floor from the underlying model */
 	Floorplan::Floor* getFloor() {return floor;}

mapview/model/MMFloorPOIs.h

@@ -25,6 +25,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->pois.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->pois.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	/** get the corresponding floor from the underlying model */
 	Floorplan::Floor* getFloor() {return floor;}
 

mapview/model/MMFloorStairs.h

@@ -30,6 +30,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->stairs.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->stairs.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	MMFloorStair* create(Floorplan::StairFreeform* stair) {
 
 		// add to underlying model

mapview/model/MMFloorUnderlays.h

@@ -28,6 +28,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return floor->underlays.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		this-> floor->underlays.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	//TODO: check
 	void createImage(const Point2 center) {
 

mapview/model/MMFloors.h

@@ -13,6 +13,7 @@ class MMFloors : public MapLayer {
 
 private:
 
+	bool visible = true;
 	Floorplan::IndoorMap* map;
 
 public:
@@ -27,6 +28,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return visible;
+	}
+
+	void setVisible(const bool visible) override {
+		this->visible = visible;
+		onVisibilityChanged(visible);
+	}
+
 	std::string getLayerName() const override {return "floors";}
 
 	/** get the underlying model */

mapview/model/MMRegistration.h

@@ -27,6 +27,15 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return map->earthReg.enabled;
+	}
+
+	void setVisible(const bool visible) override {
+		map->earthReg.enabled = visible;
+		onVisibilityChanged(visible);
+	}
+
 	//TODO: check
 	MMRegistrationPoint* create(Floorplan::EarthPosMapPos* reg) {
 

mapview/model/MMRoot.h

@@ -29,6 +29,14 @@ public:
 
 	}
 
+	bool isVisible() const override {
+		return true;
+	}
+
+	void setVisible(const bool) override {
+		throw "error";
+	}
+
 	/** get the underlying model */
 	Floorplan::IndoorMap* getMap() {return map;}
 

mapview/model/MapLayer.h

@@ -50,17 +50,17 @@ protected:
 	MapLayerType type;
 
 	/** whether this layer is visible */
-	bool visible;
+	//bool visible;
 
 public:
 
 	/** ctor */
-	MapLayer(MapLayer* parent) : parent(parent), type(MapLayerType::UNKNOWN), visible(true) {
+	MapLayer(MapLayer* parent) : parent(parent), type(MapLayerType::UNKNOWN) {
 		if (parent) {parent->addSublayer(this);}	// attach myself as child of my parent
 	}
 
 	/** ctor */
-	MapLayer(MapLayer* parent, MapLayerType type) : parent(parent), type(type), visible(true) {
+	MapLayer(MapLayer* parent, MapLayerType type) : parent(parent), type(type) {
 		if (parent) {parent->addSublayer(this);}	// attach myself as child of my parent
 	}
 
@@ -104,14 +104,15 @@ public:
 	void removeSublayer(const MapLayer* layer) { sublayers.erase(std::remove(sublayers.begin(), sublayers.end(), layer), sublayers.end()); }
 
 	/** is this layer currently visible? */
-	bool isVisible() const {return visible;}
+//	bool isVisible() const {return visible;}
+	virtual bool isVisible() const = 0;
 
 	/** make this layer visible */
-	virtual void setVisible(const bool visible) {
-		this->visible = visible;
-		onVisibilityChanged(visible);
-	}
-
+//	virtual void setVisible(const bool visible) {
+//		this->visible = visible;
+//		onVisibilityChanged(visible);
+//	}
+	virtual void setVisible(const bool visible) = 0;
 
 	/** get all sub-layers within this layer */
 	const std::vector<MapLayer*>& getSubLayers() const {return sublayers;}
@@ -145,7 +146,7 @@ public:
 		}
 	}
 
-private:
+protected:
 
 	void onElemAdded(MapModelElement* e) {
 		if (parent) {parent->onElemAdded(e);}
@@ -182,6 +183,14 @@ public:
 
 	std::string getLayerName() const override {return "root";}
 
+	bool isVisible() const override {
+		return true;
+	}
+
+	void setVisible(const bool visible) override {
+		throw "error";
+	}
+
 };
 
 

mapview/model/MapLayers.h

@@ -1,72 +0,0 @@
-#ifndef MAPLAYERFLOOR_H
-#define MAPLAYERFLOOR_H
-
-#include "MapLayer.h"
-#include <Indoor/floorplan/v2/Floorplan.h>
-
-#include "../model/MMFloorObstacleLine.h"
-#include "../model/MMFloorObstacleCircle.h"
-#include "../model/MMFloorOutlinePolygon.h"
-#include "../model/MMFloorBeacon.h"
-
-
-/*
-class MapLayerFloorOutlineAdd : public TypedMapLayer {
-private:
-	Floorplan::Floor& floor;
-public:
-	MapLayerFloorOutlineAdd(MapLayer* parent, Floorplan::Floor& floor) : TypedMapLayer(parent, MapLayerType::FLOOR_GROUND_ADD), floor(floor) {;}
-	std::string getLayerName() const override {return "add";}
-	Floorplan::Floor& getFloor() {return floor;}
-	std::vector<MapModelElement*> getElements() const override {
-		std::vector<MapModelElement*> vec;
-		for (Floorplan::FloorOutlinePolygon& p : floor.outline.add) {vec.push_back(new MapViewElementFloorOutlinePolygon(floor, p, MapViewElementFloorOutlinePolygon::Type::ADD));}
-		return vec;
-	}
-	void create(const Floorplan::FloorOutlinePolygon& poly) {
-		floor.outline.add.push_back(poly);
-	}
-	virtual size_t getNumElements() const override {return floor.outline.add.size();}
-};
-
-class MapLayerFloorOutlineRemove : public TypedMapLayer {
-private:
-	Floorplan::Floor& floor;
-public:
-	MapLayerFloorOutlineRemove(MapLayer* parent, Floorplan::Floor& floor) : TypedMapLayer(parent, MapLayerType::FLOOR_GROUND_REMOVE), floor(floor) {;}
-	std::string getLayerName() const override {return "remove";}
-	Floorplan::Floor& getFloor() {return floor;}
-	std::vector<MapModelElement*> getElements() const override {
-		std::vector<MapModelElement*> vec;
-		for (Floorplan::FloorOutlinePolygon& p : floor.outline.remove) {vec.push_back(new MapViewElementFloorOutlinePolygon(floor, p, MapViewElementFloorOutlinePolygon::Type::REMOVE));}
-		return vec;
-	}
-	void create(const Floorplan::FloorOutlinePolygon& poly) {
-		floor.outline.remove.push_back(poly);
-	}
-	virtual size_t getNumElements() const override {return floor.outline.remove.size();}
-};
-
-
-
-
-
-class MapLayerFloorOutlinePolygon : public TypedMapLayer {
-private:
-	Floorplan::Floor& floor;
-public:
-	MapLayerFloorOutlinePolygon(MapLayer* parent, Floorplan::Floor& floor) : TypedMapLayer(parent, MapLayerType::FLOOR_GROUND), floor(floor) {
-		new MapLayerFloorOutlineAdd(this, floor);
-		new MapLayerFloorOutlineRemove(this, floor);
-	}
-	std::string getLayerName() const override {return "ground";}
-	Floorplan::Floor& getFloor() {return floor;}
-};
-*/
-
-
-
-
-
-
-#endif // MAPLAYERFLOOR_H