FHWS/IndoorMap
Archived
2
0
Fork 0
Code Issues 10 Pull Requests Releases Wiki Activity

Merge branch 'master' of https://git.frank-ebner.de/FHWS/IndoorMap

Browse Source
This commit is contained in:
FrankE
2017-03-12 16:49:12 +01:00
parent 8180764809 87d57ef134
commit 62d4a278e9
18 changed files with 531 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
mapview/2D/MV2DElementFloorOutlinePolygon.h
View File

@@ -53,13 +53,14 @@ public:
switch (fo.method) {
case Floorplan::OutlineMethod::ADD:
brush.setStyle(Qt::BrushStyle::SolidPattern);
brush.setColor(QColor(0,0,0,24));
brush.setColor( fo.outdoor ? QColor(0,255,0,32) : QColor(0,0,0,24) ); // outdoor = green
break;
case Floorplan::OutlineMethod::REMOVE:
brush.setStyle(Qt::BrushStyle::DiagCrossPattern);
brush.setColor(QColor(0,0,0));
break;
default:
// should not happen
brush.setStyle(Qt::BrushStyle::SolidPattern);
brush.setColor(QColor(255,0,0));
}

2
mapview/2D/MV2DElementFloorUnderlay.h
View File

@@ -92,7 +92,7 @@ public:
// if the to-be-displayed image is smaller than the input-one, use a pre-computed downscaled version
if (scaledArea < origArea) {
if (scaledArea < origArea*0.75) {
// does the cached downscaled image needs rebuild? (size changed)
if (imgScaled.width() != sw || imgScaled.height() != sh) {
imgScaled = img.scaled(sw, sh, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

119
mapview/2D/MV2DElementGroundTruthPoint.h Normal file
View File

@@ -0,0 +1,119 @@
#ifndef MV2DELEMENTGROUNDTRUTHPOINT_H
#define MV2DELEMENTGROUNDTRUTHPOINT_H
#include "MV2DElement.h"
#include "HasMoveableNodes.h"
#include "MapViewElementHelper.h"
#include <Indoor/floorplan/v2/Floorplan.h>
#include "../../UIHelper.h"
class MV2DElementGroundTruthPoint : public MV2DElement, public HasMoveableNodes {
private:
//bool sel = false;
Floorplan::GroundTruthPoint* gtp;
public:
/** ctor with the AP to render/edit */
MV2DElementGroundTruthPoint(Floorplan::GroundTruthPoint* gtp) : gtp(gtp) {;}
/** get the element's 3D bounding box */
BBox2 getBoundingBox() const override {
BBox2 bbox;
bbox.add(Point2(gtp->pos.x, gtp->pos.y));
bbox.grow(Point2(0.1, 0.1));
return bbox;
}
/** get the element's minimal distance (nearest whatsoever) to the given point */
ClickDist getMinDistanceXY(const Point2 p) const override {
return ClickDist(p.getDistance(gtp->pos), ClickDistType::DIRECT);
}
/** repaint me */
void paint(Painter& p) override {
static const QPixmap& pixmapUnfocused = UIHelper::getPixmapColored("gtp", CFG::UNFOCUS_COLOR, 16);
static const QPixmap& pixmapFocused = UIHelper::getPixmapColored("gtp", CFG::FOCUS_COLOR, 16);
static const QPixmap& pixmapSel = UIHelper::getPixmapColored("gtp", CFG::SEL_COLOR, 16);
if (selectedUserIdx == 0) {
// p.setPenBrush(Qt::black, CFG::SEL_COLOR);
// p.drawCircle(gtp->pos);
p.drawPixmap(gtp->pos, pixmapSel);
} else if (hasFocus()) {
// p.setPenBrush(Qt::black, Qt::NoBrush);
// p.drawCircle(gtp->pos);
p.drawPixmap(gtp->pos, pixmapFocused);
} else {
// p.setPenBrush(Qt::gray, Qt::NoBrush);
// p.drawCircle(gtp->pos);
p.drawPixmap(gtp->pos, pixmapUnfocused);
}
// label
p.setPenBrush(Qt::black, Qt::NoBrush);
p.drawDot(gtp->pos);
if (p.getScaler().getScale() >= 10) {
const std::string str = std::to_string(gtp->id);
p.p->drawText(p.getScaler().xms(gtp->pos.x) + 10, p.getScaler().yms(gtp->pos.y) + 5, str.c_str());
}
}
virtual std::vector<MoveableNode> getMoveableNodes() const override {
return { MoveableNode(0, gtp->pos) };
}
virtual void onNodeMove(MapView2D* v, const int userIdx, const Point2 newPos) override {
(void) v;
if (userIdx == 0) {gtp->pos = newPos;}
}
/** mouse pressed at the given point */
virtual void mousePressed(MapView2D* v, const Point2 p) override {
(void) v;
(void) p;
}
/** mouse moved to the given point */
virtual void mouseMove(MapView2D* v, const Point2 p) override {
(void) v;
(void) p;
// if (sel) {
// const Point2 p = v->getScaler().snap(_p);
// gtp->pos.x = p.x;
// gtp->pos.y = p.y;
// }
}
/** mouse released */
virtual void mouseReleased(MapView2D* v, const Point2 p) override {
(void) v;
(void) p;
}
virtual bool keyPressEvent(MapView2D* v, QKeyEvent *e) override {
(void) v;
(void) e;
return false;
}
virtual void onFocus() override {
;
}
virtual void onUnfocus() override {
;
}
};
#endif // MV2DELEMENTGROUNDTRUTHPOINT_H

35
mapview/2D/tools/ToolSelector.h
View File

@@ -299,12 +299,47 @@ private:
return true;
}
if (e->key() == Qt::Key_Up || e->key() == Qt::Key_Down || e->key() == Qt::Key_Left || e->key() == Qt::Key_Right) {
moveNodes(m, focused, e->key());
}
}
return false;
}
void moveNodes(MapView2D* v, MapModelElement* focused, const int key) {
MV2DElement* me = focused->getMV2D();
if (!me) {return;}
HasMoveableNodes* elem = dynamic_cast<HasMoveableNodes*>(me);
if (!elem) {return;}
// no node selected? -> done
if (elem->getSelectedNode() == -1) {return;}
// get current value
MoveableNode& node = elem->getMoveableNodes()[elem->getSelectedNode()];
Point2 pos = node.pos;
// adjust the node
switch(key) {
case Qt::Key_Up: pos.y += 0.1; break;
case Qt::Key_Down: pos.y -= 0.1; break;
case Qt::Key_Left: pos.x -= 0.1; break;
case Qt::Key_Right: pos.x += 0.1; break;
}
// snap the position
pos = v->getScaler().snap(pos);
// move
elem->onNodeMove(v, elem->getSelectedNode(), pos);
}
signals:
/** map element was selected */

15
mapview/3DGrid/GridRenderer.h
View File

@@ -21,18 +21,25 @@ private:
struct Color {
float r,g,b;
Color() : r(1), g(0), b(0) {;}
Color(float r, float g, float b) : r(r), g(g), b(b) {;}
};
Color colors[4] = {
Color(0.3, 0.3, 0.3), Color(0,0,1), Color(0,0,1), Color(0,0.65,0)
};
/** node color depending on the node's type. see ctor */
Color colors[200];
public:
/** ctor */
GridRenderer() {
;
colors[GridNode::TYPE_FLOOR] = Color(0.4, 0.4, 0.4);
colors[GridNode::TYPE_STAIR] = Color(0,0,1);
colors[GridNode::TYPE_ELEVATOR] = Color(0,0,1);
colors[GridNode::TYPE_DOOR] = Color(0.0, 0.0, 0.0);
colors[GridNode::TYPE_OUTDOOR] = Color(0.0, 0.5, 0.0);
}

2
mapview/3DGrid/MyNode.h
View File

@@ -8,6 +8,8 @@ struct MyNode : public GridNode, public GridPoint, public GridNodeImportance {
MyNode(float x, float y, float z) : GridPoint(x,y,z) {;}
float walkImportance;
};
#endif // MYNODE_H

2
mapview/model/MMFloor.h
View File

@@ -11,6 +11,7 @@
#include "MMFloorPOIs.h"
#include "MMFloorStairs.h"
#include "MMFloorElevators.h"
#include "MMFloorGroundTruthPoints.h"
#include "IHasParams.h"
@@ -45,6 +46,7 @@ public:
new MMFloorPOIs(this, floor);
new MMFloorStairs(this, floor);
new MMFloorElevators(this, floor);
new MMFloorGroundTruthPoints(this, floor);
}

61
mapview/model/MMFloorGroundTruthPoint.h Normal file
View File

@@ -0,0 +1,61 @@
#ifndef MMFLOORGROUNDTRUTHPOINT_H
#define MMFLOORGROUNDTRUTHPOINT_H
#include "MapModelElement.h"
#include "IHasParams.h"
#include "../2D/MV2DElementGroundTruthPoint.h"
#include <Indoor/floorplan/v2/Floorplan.h>
class MMFloorGroundTruthPoint : public MapModelElement, public IHasParams {
private:
Floorplan::Floor* floor;
Floorplan::GroundTruthPoint* gtp;
MV2DElementGroundTruthPoint mv2d;
public:
MMFloorGroundTruthPoint(MapLayer* parent, Floorplan::Floor* floor, Floorplan::GroundTruthPoint* gtp) : MapModelElement(parent), floor(floor), gtp(gtp), mv2d(gtp) {
;
}
virtual int getNumParams() const override {
return 2;
}
virtual Param getParamDesc(const int idx) const override {
switch(idx) {
case 0: return Param("id", ParamType::INT);
case 1: return Param("position", ParamType::POINT2);
}
throw 1;
}
virtual ParamValue getParamValue(const int idx) const override {
switch(idx) {
case 0: return gtp->id; //TODO: this value can be changed and isn't set incremental within the indoormap
case 1: return gtp->pos;
}
throw 1;
}
virtual void setParamValue(const int idx, const ParamValue& val) const override {
switch(idx) {
case 0: gtp->id = val.toInt(); break;
case 1: gtp->pos = val.toPoint2(); break;
}
}
MV2DElement* getMV2D() const override {return (MV2DElement*) &mv2d;}
void deleteMe() const override {
parent->removeElement(this);
floor->gtpoints.erase(std::remove(floor->gtpoints.begin(), floor->gtpoints.end(), gtp), floor->gtpoints.end());
}
};
#endif // MMFLOORGROUNDTRUTHPOINT_H

46
mapview/model/MMFloorGroundTruthPoints.h Normal file
View File

@@ -0,0 +1,46 @@
#ifndef MMFLOORGROUNDTRUTHPOINTS_H
#define MMFLOORGROUNDTRUTHPOINTS_H
#include "MapLayer.h"
#include "MMFloorGroundTruthPoint.h"
#include <Indoor/floorplan/v2/Floorplan.h>
/**
* layer that contains all of one floor's GroundTruthPoints
*/
class MMFloorGroundTruthPoints : public MapLayer {
Floorplan::Floor* floor;
public:
/** ctor with the floor */
MMFloorGroundTruthPoints(MapLayer* parent, Floorplan::Floor* floor) : MapLayer(parent, MapLayerType::FLOOR_GROUND_TRUTH_POINTS), floor(floor) {
// the POIs
for (Floorplan::GroundTruthPoint* gtp : floor->gtpoints) {
addElement(new MMFloorGroundTruthPoint(this, floor, gtp));
}
}
/** get the corresponding floor from the underlying model */
Floorplan::Floor* getFloor() {return floor;}
//TODO: check
void createGroundTruthPoint(Floorplan::GroundTruthPoint* gtp) {
// add to underlying model
floor->gtpoints.push_back(gtp);
// add to myself as element
addElement(new MMFloorGroundTruthPoint(this, floor, gtp));
}
std::string getLayerName() const override {return "GroundTruthPoints";}
};
#endif // MMFLOORGROUNDTRUTHPOINTS_H

5
mapview/model/MMFloorOutlinePolygon.h
View File

@@ -39,12 +39,13 @@ public:
//MV3DElement* getMV3D() const override {return (MV3DElement*) &mv3d;}
virtual int getNumParams() const override {
return 1;
return 2;
}
virtual Param getParamDesc(const int idx) const override {
switch(idx) {
case 0: return Param("name", ParamType::STRING);
case 1: return Param("outdoor", ParamType::BOOL);
}
throw 1;
}
@@ -52,6 +53,7 @@ public:
virtual ParamValue getParamValue(const int idx) const override {
switch(idx) {
case 0: return fo->name;
case 1: return fo->outdoor;
}
throw 1;
}
@@ -59,6 +61,7 @@ public:
virtual void setParamValue(const int idx, const ParamValue& val) const override {
switch(idx) {
case 0: fo->name = val.toString(); break;
case 1: fo->outdoor = val.toBool(); break;
}
}

1
mapview/model/MapLayer.h
View File

@@ -24,6 +24,7 @@ enum class MapLayerType {
FLOOR_UNDERLAYS,
FLOOR_POIS,
FLOOR_STAIRS,
FLOOR_GROUND_TRUTH_POINTS
};

76
mapview/model/MapModel.h
View File

@@ -86,6 +86,82 @@ public:
}
float snap(const float val) {
const float s = 0.1;
return std::round(val / s) * s;
}
/** resize everything within the floorplay by the given factor */
void resize(const float sx, const float sy, const float sz, const float ox, const float oy, const float oz) {
for (Floorplan::Floor* f : im->floors) {
f->atHeight = snap(f->atHeight * sz);
f->height = snap(f->height * sz);
for (Floorplan::FloorOutlinePolygon* poly : f->outline) {
for (Point2& p : poly->poly.points) {
p.x = snap(p.x * sx + ox);
p.y = snap(p.y * sy + oy);
}
}
for (Floorplan::AccessPoint* ap : f->accesspoints) {
ap->pos.x = snap(ap->pos.x * sx + ox);
ap->pos.y = snap(ap->pos.y * sy + oy);
ap->pos.z = snap(ap->pos.z * sz + oz);
}
for (Floorplan::Beacon* b : f->beacons) {
b->pos.x = snap(b->pos.x * sx + ox);
b->pos.y = snap(b->pos.y * sy + oy);
b->pos.z = snap(b->pos.z * sz + oz);
}
for (Floorplan::POI* p : f->pois) {
p->pos.x = snap(p->pos.x * sx + ox);
p->pos.y = snap(p->pos.y * sy + oy);
}
for (Floorplan::FingerprintLocation* fpl : f->fpLocations) {
fpl->posOnFloor.x = snap(fpl->posOnFloor.x * sx + ox);
fpl->posOnFloor.y = snap(fpl->posOnFloor.y * sy + oy);
fpl->heightAboveFloor = snap(fpl->heightAboveFloor * sz + oz);
}
for (Floorplan::FloorObstacle* o : f->obstacles) {
Floorplan::FloorObstacleLine* line = dynamic_cast<Floorplan::FloorObstacleLine*>(o);
Floorplan::FloorObstacleDoor* door = dynamic_cast<Floorplan::FloorObstacleDoor*>(o);
if (line) {
line->from.x = snap(line->from.x * sx + ox);
line->from.y = snap(line->from.y * sy + oy);
line->to.x = snap(line->to.x * sx + ox);
line->to.y = snap(line->to.y * sy + oy);
} else if (door) {
door->from.x = snap(door->from.x * sx + ox);
door->from.y = snap(door->from.y * sy + oy);
door->to.x = snap(door->to.x * sx + ox);
door->to.y = snap(door->to.y * sy + oy);
}
}
for (Floorplan::Stair* s : f->stairs) {
Floorplan::StairFreeform* stair = dynamic_cast<Floorplan::StairFreeform*>(s);
for (Floorplan::StairPart& sp : stair->parts) {
sp.width = snap(sp.width * sx);
sp.end.x = snap(sp.end.x * sx + ox);
sp.end.y = snap(sp.end.y * sy + oy);
sp.end.z = snap(sp.end.z * sz + oz);
sp.start.x = snap(sp.start.x * sx + ox);
sp.start.y = snap(sp.start.y * sy + oy);
sp.start.z = snap(sp.start.z * sz + oz);
}
}
for (Floorplan::Elevator* e : f->elevators) {
e->center.x = snap(e->center.x * sx + ox);
e->center.y = snap(e->center.y * sy + oy);
e->width = snap(e->width * sx);
e->depth = snap(e->depth * sx);
}
}
}
void onLayerChanged(MapLayer* layer) override {
for (MapModelListener* l : listeners) {l->onLayerChanged(layer);}
}