From 0d22d91470feff88824d0b88b8911566e635057a Mon Sep 17 00:00:00 2001 From: k-a-z-u Date: Wed, 25 Jul 2018 16:21:47 +0200 Subject: [PATCH] started working on walling, dooring and windowing refactoring --- floorplan/3D/Builder.h | 21 ++++- floorplan/3D/Lines.h | 69 +++++++++++++++++ floorplan/3D/WallsViaCuttedQuads.h | 71 ++++++++++++++--- floorplan/3D/misc.h | 9 +++ floorplan/v2/Floorplan.h | 53 +++++++++++-- floorplan/v2/FloorplanReader.h | 33 ++++++++ floorplan/v2/FloorplanWriter.h | 37 ++++++++- geo/GPCPolygon2.h | 116 +++++++++++++++++++++------- wifi/estimate/ray3/WifiRayTrace3D.h | 7 +- 9 files changed, 368 insertions(+), 48 deletions(-) create mode 100644 floorplan/3D/Lines.h diff --git a/floorplan/3D/Builder.h b/floorplan/3D/Builder.h index 58c3b59..ecab29a 100644 --- a/floorplan/3D/Builder.h +++ b/floorplan/3D/Builder.h @@ -36,7 +36,7 @@ namespace Floorplan3D { bool exportObjects = true; bool exportPillars = true; bool exportWallTops = false; - bool center = true; + bool center = false; //Walls* walls = new WallsViaCubes(); //Walls* walls = new WallsViaCuttedQuads(); @@ -92,6 +92,11 @@ namespace Floorplan3D { // process each obstacle within the floor if (f->obstacles.enabled) { + if (1 == 1) { + const std::vector tmp = getLines(f); + res.insert(res.end(), tmp.begin(), tmp.end()); + } + if (1 == 1) { const std::vector tmp = getWalls(f); res.insert(res.end(), tmp.begin(), tmp.end()); @@ -140,6 +145,20 @@ namespace Floorplan3D { WallsViaCuttedQuads walls; + for (const Floorplan::FloorObstacle* obs : f->obstacles) { + const Floorplan::FloorObstacleWall* wall = dynamic_cast(obs); + if (wall) {walls.add(f, wall);} + } + + return walls.get(); + + } + + /** get all old walls (lines) */ + std::vector getLines(const Floorplan::Floor* f) { + + WallsViaCubes walls; + for (const Floorplan::FloorObstacle* obs : f->obstacles) { const Floorplan::FloorObstacleLine* line = dynamic_cast(obs); if (line) {walls.add(f, line, nullptr);} diff --git a/floorplan/3D/Lines.h b/floorplan/3D/Lines.h new file mode 100644 index 0000000..8c8b848 --- /dev/null +++ b/floorplan/3D/Lines.h @@ -0,0 +1,69 @@ +#ifndef FLOORPLAN_3D_LINES_H +#define FLOORPLAN_3D_LINES_H + +#include "Walls.h" +#include "misc.h" +#include "primitives/Cube.h" + +namespace Floorplan3D { + + /** + * simply use one 3D cube per wall + * if walls intersect in the 2D view, cubes will also intersect + */ + class LinesViaCubes : public Walls { + + Cube::Part cubeParts = (Cube::Part) 63; // leftright,topbottom,rearfront + + std::vector vec; + + public: + + void clear() override { + vec.clear(); + } + + void add(const Floorplan::Floor* f, const Floorplan::FloorObstacleLine* fol, const Floorplan::FloorObstacleDoor* aboveDoor) override { + + FloorPos fpos(f); + + const float thickness_m = fol->thickness_m; + const Point2 from = (!aboveDoor) ? (fol->from) : (aboveDoor->from); + const Point2 to = (!aboveDoor) ? (fol->to) : (aboveDoor->to); + const Point2 cen2 = (from+to)/2; + + const float rad = std::atan2(to.y - from.y, to.x - from.x); + const float deg = rad * 180 / M_PI; + + // cube's destination center + const float _height = (fol->height_m > 0) ? (fol->height_m) : (fpos.height); // use either floor's height or user height + const double height = (!aboveDoor) ? (_height) : (fpos.height - aboveDoor->height); + const double cenZ = (!aboveDoor) ? (fpos.z1 + height/2) : (fpos.z1 + aboveDoor->height + height/2);// (fpos.z2 - (fpos.height - aboveDoor->height) / 2); + const Point3 pos(cen2.x, cen2.y, cenZ); + + // div by 2.01 to prevent overlapps and z-fighting + const float sx = from.getDistance(to) / 2; + const float sy = thickness_m / 2; + const float sz = height / 2.01f; // prevent overlaps + const Point3 size(sx, sy, sz); + const Point3 rot(0,0,deg); + + // build + Cube cube(pos, size, rot, cubeParts); + + // done + Obstacle3D res(getType(fol), fol->material); + res.triangles = cube.getTriangles(); + vec.push_back(res); + + } + + const std::vector& get() override { + return vec; + } + + }; + +} + +#endif // FLOORPLAN_3D_LINES_H diff --git a/floorplan/3D/WallsViaCuttedQuads.h b/floorplan/3D/WallsViaCuttedQuads.h index b91b25a..227bad2 100644 --- a/floorplan/3D/WallsViaCuttedQuads.h +++ b/floorplan/3D/WallsViaCuttedQuads.h @@ -5,7 +5,7 @@ #include "../../geo/Polygon2.h" #include "../../geo/GPCPolygon2.h" -#include "Walls.h" +//#include "Walls.h" #include "misc.h" #include @@ -17,7 +17,7 @@ namespace Floorplan3D { * interpret walls als quads (polygons) * intersect them with each other to prevent overlaps */ - class WallsViaCuttedQuads : public Walls { + class WallsViaCuttedQuads { private: @@ -27,13 +27,13 @@ namespace Floorplan3D { bool error = false; /** original line from floorplan */ - const Floorplan::FloorObstacleLine* line; + const Floorplan::FloorObstacleWall* line; /** outlines after applying thickness */ Line2 l1; Line2 l2; - Wall(const Floorplan::FloorObstacleLine* line) : line(line) { + Wall(const Floorplan::FloorObstacleWall* line) : line(line) { const Point2 from = line->from; const Point2 to = line->to; @@ -137,18 +137,17 @@ namespace Floorplan3D { public: - void clear() override { + void clear() { walls.clear(); } - void add(const Floorplan::Floor* f, const Floorplan::FloorObstacleLine* fol, const Floorplan::FloorObstacleDoor* aboveDoor) override { - if (fol->type != Floorplan::ObstacleType::WALL) {return;} - if (aboveDoor) {return;} + void add(const Floorplan::Floor* f, const Floorplan::FloorObstacleWall* fow) { + if (fow->type != Floorplan::ObstacleType::WALL) {return;} this->floor = f; - walls.push_back(Wall(fol)); + walls.push_back(Wall(fow)); } - virtual const std::vector& get() override { + virtual const std::vector& get() { std::vector tmp = walls; tmp = cutConnected(tmp); tmp = cutProtruding(tmp); @@ -226,6 +225,9 @@ namespace Floorplan3D { auto unFlattenFront = [o,t,a] (const Point3 p) {return Point3(p.x, +t, p.y).rotZ(a)+o;}; auto unFlattenBack = [o,t,a] (const Point3 p) {return Point3(p.x, -t, p.y).rotZ(a)+o;}; + auto unFlattenFront2 = [o,t,a] (const Point2 p) {return Point3(p.x, +t, p.y).rotZ(a)+o;}; + auto unFlattenBack2 = [o,t,a] (const Point2 p) {return Point3(p.x, -t, p.y).rotZ(a)+o;}; + const Point2 fp1 = flatten(p1); const Point2 fp2 = flatten(p2); const Point2 fp3 = flatten(p3); @@ -248,7 +250,20 @@ namespace Floorplan3D { GPCPolygon2 gpBack; gpBack.add(back); - for (const Floorplan::FloorObstacleWallDoor* door : wall.line->doors) { + // sort doors by their position within the wall (first comes first) + std::vector doors = wall.line->doors; + auto compDoors = [] (const Floorplan::FloorObstacleWallDoor* d1, Floorplan::FloorObstacleWallDoor* d2) { + return d1->atLinePos < d2->atLinePos; + }; + std::sort(doors.begin(), doors.end(), compDoors); + + + TriangleStrip strip; + + strip.add(p1); + strip.add(p4); + + for (const Floorplan::FloorObstacleWallDoor* door : doors) { Polygon2 pDoor; const Point2 pds = door->getStart(wall.line); @@ -270,8 +285,41 @@ namespace Floorplan3D { gpFront.remove(pDoor); gpBack.remove(pDoor); + strip.add(unFlattenFront2(pDoor[0])); + strip.add(unFlattenBack2(pDoor[0])); + + strip.add(unFlattenFront2(pDoor[3])); + strip.add(unFlattenBack2(pDoor[3])); + + strip.add(unFlattenFront2(pDoor[2])); + strip.add(unFlattenBack2(pDoor[2])); + + strip.add(unFlattenFront2(pDoor[1])); + strip.add(unFlattenBack2(pDoor[1])); + } + strip.add(p2); + strip.add(p3); + strip.add(p2u); + strip.add(p3u); + strip.add(p1u); + strip.add(p4u); + strip.add(p1); + strip.add(p4); + + for (Triangle3 t : strip.toTriangles()) { + t.reverse(); + obs.triangles.push_back(t); + } + +// std::vector ptsToConnect3; +// for (const Point2 p2 : ptsToConnect) { +// const Point3 p3 = unf +// } + + + // Frontseite triangulieren std::vector triasFront = gpFront.getTriangles(); for (Triangle3 tria : triasFront) { @@ -280,6 +328,7 @@ namespace Floorplan3D { obs.triangles.push_back(tria); } + // Rückseite triangulieren std::vector triasBack = gpBack.getTriangles(); for (Triangle3 tria : triasBack) { diff --git a/floorplan/3D/misc.h b/floorplan/3D/misc.h index 9eac973..35edbe8 100644 --- a/floorplan/3D/misc.h +++ b/floorplan/3D/misc.h @@ -23,6 +23,15 @@ namespace Floorplan3D { } } + static Obstacle3D::Type getType(const Floorplan::FloorObstacleWall* l) { + switch (l->type) { + case Floorplan::ObstacleType::WALL: return Obstacle3D::Type::WALL; + case Floorplan::ObstacleType::WINDOW: return Obstacle3D::Type::WINDOW; + case Floorplan::ObstacleType::HANDRAIL: return Obstacle3D::Type::HANDRAIL; + default: return Obstacle3D::Type::UNKNOWN; + } + } + static Obstacle3D::Type getType(const Floorplan::FloorObstacleCircle* c) { (void) c; return Obstacle3D::Type::WALL; diff --git a/floorplan/v2/Floorplan.h b/floorplan/v2/Floorplan.h index a98ef2b..d11dd0f 100644 --- a/floorplan/v2/Floorplan.h +++ b/floorplan/v2/Floorplan.h @@ -157,6 +157,12 @@ namespace Floorplan { _END, }; + /** available window types */ + enum class WindowType { + UNKNOWN, + _END, + }; + /** all supported material types */ enum class Material { UNKNOWN, @@ -193,6 +199,7 @@ namespace Floorplan { struct Elevator; struct GroundTruthPoint; struct FloorObstacleWallDoor; + struct FloorObstacleWallWindow; struct FloorOutline : public std::vector { bool enabled = true; @@ -351,7 +358,6 @@ namespace Floorplan { Point2 to; float thickness_m; float height_m = 0; // 0 = floor's height - std::vector doors; FloorObstacleLine(const ObstacleType type, const Material material, const Point2 from, const Point2 to, const float thickness_m = 0.2f, const float height_m = 0) : FloorObstacle(material), type(type), from(from), to(to), thickness_m(thickness_m), height_m(height_m) {;} FloorObstacleLine(const ObstacleType type, const Material material, const float x1, const float y1, const float x2, const float y2, const float thickness_m = 0.2f, const float height_m = 0) : FloorObstacle(material), type(type), from(x1,y1), to(x2,y2), thickness_m(thickness_m), height_m(height_m) {;} }; @@ -378,7 +384,21 @@ namespace Floorplan { float getSize() const {return (to-from).length();} }; - /** door obstacle */ + + /** wall obstacle */ + struct FloorObstacleWall: public FloorObstacle { + ObstacleType type; + Point2 from; + Point2 to; + float thickness_m; + float height_m = 0; // 0 = floor's height + std::vector doors; + std::vector windows; + FloorObstacleWall(const ObstacleType type, const Material material, const Point2 from, const Point2 to, const float thickness_m = 0.2f, const float height_m = 0) : FloorObstacle(material), type(type), from(from), to(to), thickness_m(thickness_m), height_m(height_m) {;} + FloorObstacleWall(const ObstacleType type, const Material material, const float x1, const float y1, const float x2, const float y2, const float thickness_m = 0.2f, const float height_m = 0) : FloorObstacle(material), type(type), from(x1,y1), to(x2,y2), thickness_m(thickness_m), height_m(height_m) {;} + }; + + /** wall->door obstacle */ struct FloorObstacleWallDoor : public FloorObstacle { DoorType type; float atLinePos; @@ -386,17 +406,40 @@ namespace Floorplan { float height; bool leftRight = false; bool inOut = false; - FloorObstacleWallDoor(const DoorType type, const Material material, const float atLinePos, const float width, const float height) : FloorObstacle(material), type(type), atLinePos(atLinePos), width(width), height(height) {;} - Point2 getStart(const FloorObstacleLine* wall) const { + FloorObstacleWallDoor(const DoorType type, const Material material, const float atLinePos, const float width, const float height, const bool lr = false, const bool io = false) : FloorObstacle(material), type(type), atLinePos(atLinePos), width(width), height(height), leftRight(lr), inOut(io) {;} + Point2 getStart(const FloorObstacleWall* wall) const { const Point2 dir = wall->to - wall->from; return wall->from + dir * atLinePos; } - Point2 getEnd(const FloorObstacleLine* wall) const { + Point2 getEnd(const FloorObstacleWall* wall) const { const Point2 dir = wall->to - wall->from; return getStart(wall) + dir.normalized() * (leftRight ? -width : +width); } }; + /** wall->window obstacle */ + struct FloorObstacleWallWindow : public FloorObstacle { + WindowType type; + float atLinePos; + float startsAtHeight; + float width; + float height; + bool leftRight = false; + bool inOut = false; + FloorObstacleWallWindow(const WindowType type, const Material material, const float atLinePos, const float startsAtHeight, const float width, const float height, const bool lr = false, const bool io = false) : FloorObstacle(material), type(type), atLinePos(atLinePos), startsAtHeight(startsAtHeight), width(width), height(height), leftRight(lr), inOut(io) {;} + Point2 getStart(const FloorObstacleWall* wall) const { + const Point2 dir = wall->to - wall->from; + const Point2 cen = wall->from + dir * atLinePos; + return cen - dir.normalized() * width/2; + } + Point2 getEnd(const FloorObstacleWall* wall) const { + const Point2 dir = wall->to - wall->from; + const Point2 cen = wall->from + dir * atLinePos; + return cen + dir.normalized() * width/2; + } + }; + + /** 3D obstacle */ struct FloorObstacleObject : public FloorObstacle { std::string file; diff --git a/floorplan/v2/FloorplanReader.h b/floorplan/v2/FloorplanReader.h index f7dd458..e101961 100644 --- a/floorplan/v2/FloorplanReader.h +++ b/floorplan/v2/FloorplanReader.h @@ -388,6 +388,7 @@ namespace Floorplan { // if (std::string("window") == n->Name()) {obstacles.push_back(parseFloorObstacleWindow(n));} // if (std::string("pillar") == n->Name()) {obstacles.push_back(parseFloorObstaclePillar(n));} //if (std::string("obstacle") == n->Name()) {obstacles.push_back(parseFloorObstacleLine(n));} // OLD + if (std::string("wall") == n->Name()) {obstacles.push_back(parseFloorObstacleWall(n));} if (std::string("line") == n->Name()) {obstacles.push_back(parseFloorObstacleLine(n));} if (std::string("circle") == n->Name()) {obstacles.push_back(parseFloorObstacleCircle(n));} if (std::string("door") == n->Name()) {obstacles.push_back(parseFloorObstacleDoor(n));} @@ -396,6 +397,38 @@ namespace Floorplan { return obstacles; } + /** parse one wall */ + static FloorObstacleWall* parseFloorObstacleWall(const XMLElem* el) { + + FloorObstacleWall* wall = new FloorObstacleWall( + parseObstacleType(el->Attribute("type")), + parseMaterial(el->Attribute("material")), + el->FloatAttribute("x1"), el->FloatAttribute("y1"), + el->FloatAttribute("x2"), el->FloatAttribute("y2"), + (el->FloatAttribute("thickness") > 0) ? (el->FloatAttribute("thickness")) : (0.15), // default wall thickness in m + el->FloatAttribute("height") + ); + + // doors + FOREACH_NODE(n, el) { + if (std::string("door") == n->Name()) { + FloorObstacleWallDoor* door = new FloorObstacleWallDoor( + parseDoorType(n->Attribute("type")), + parseMaterial(n->Attribute("material")), + n->FloatAttribute("at"), + n->FloatAttribute("width"), + n->FloatAttribute("height"), + n->BoolAttribute("lr"), + n->BoolAttribute("io") + ); + wall->doors.push_back(door); + } + } + + return wall; + + } + /** parse one line */ static FloorObstacleLine* parseFloorObstacleLine(const XMLElem* el) { return new FloorObstacleLine( diff --git a/floorplan/v2/FloorplanWriter.h b/floorplan/v2/FloorplanWriter.h index 42e6478..34bb14c 100644 --- a/floorplan/v2/FloorplanWriter.h +++ b/floorplan/v2/FloorplanWriter.h @@ -311,6 +311,8 @@ namespace Floorplan { for (FloorObstacle* fo : mf->obstacles) { if (dynamic_cast(fo)) { addFloorObstacleLine(doc, obstacles, (FloorObstacleLine*)fo); + } else if (dynamic_cast(fo)) { + addFloorObstacleWall(doc, obstacles, (FloorObstacleWall*)fo); } else if (dynamic_cast(fo)) { addFloorObstacleCircle(doc, obstacles, (FloorObstacleCircle*)fo); } else if (dynamic_cast(fo)) { @@ -324,7 +326,40 @@ namespace Floorplan { } - /** write a line obstacle (wall, handrail, ..) */ + /** write a wall obstacle (wall) */ + static void addFloorObstacleWall(XMLDoc& doc, XMLElem* obstacles, FloorObstacleWall* wall) { + + XMLElem* oWall = doc.NewElement("wall"); + obstacles->InsertEndChild(oWall); + + oWall->SetAttribute("material", toString(wall->material).c_str()); + oWall->SetAttribute("type", toString(wall->type).c_str()); + oWall->SetAttribute("x1", wall->from.x); + oWall->SetAttribute("y1", wall->from.y); + oWall->SetAttribute("x2", wall->to.x); + oWall->SetAttribute("y2", wall->to.y); + oWall->SetAttribute("thickness", wall->thickness_m); + if (wall->height_m != 0) {oWall->SetAttribute("height", wall->height_m);} + + // doors? + for (const FloorObstacleWallDoor* door : wall->doors) { + + XMLElem* oDoor = doc.NewElement("door"); + oWall->InsertEndChild(oDoor); + + oDoor->SetAttribute("type", toString(door->type).c_str()); + oDoor->SetAttribute("material", toString(door->material).c_str()); + oDoor->SetAttribute("at", door->atLinePos); + oDoor->SetAttribute("width", door->width); + oDoor->SetAttribute("height", door->height); + oDoor->SetAttribute("io", door->inOut); + oDoor->SetAttribute("lr", door->leftRight); + + } + + } + + /** write a line obstacle (old walls, handrail, ..) */ static void addFloorObstacleLine(XMLDoc& doc, XMLElem* obstacles, FloorObstacleLine* line) { XMLElem* obstacle = doc.NewElement("line"); obstacle->SetAttribute("material", toString(line->material).c_str()); diff --git a/geo/GPCPolygon2.h b/geo/GPCPolygon2.h index 5729f03..cdbee8c 100644 --- a/geo/GPCPolygon2.h +++ b/geo/GPCPolygon2.h @@ -5,6 +5,60 @@ #include "Polygon2.h" #include "Triangle3.h" +class TriangleStrip { + +private: + std::vector pts; + +public: + + void add(const Point3 p) { + pts.push_back(p); + } + + void set(const std::vector& pts) { + this->pts = pts; + } + + void toTriangles(std::vector& trias) const { + + // https://en.wikipedia.org/wiki/Triangle_strip + // GL_TRIANGLE_STRIP + // Draws a series of triangles (three-sided polygons) using vertices v0, v1, v2, then v2, v1, v3 (note the order), then v2, v3, v4, and so on. The ordering is to ensure that the triangles are all drawn with the same orientation so that the strip can correctly form part of a surface. + // For odd n, vertices n, n+1, and n+2 define triangle n. For even n, vertices n+1, n, and n+2 define triangle n. N-2 triangles are drawn. + + + + for (size_t j = 2; j < pts.size(); ++j) { + + + if (j % 2 == 0) { + Triangle3 tria( + pts[j-2], + pts[j-1], + pts[j] + ); + trias.push_back(tria); + } else { + Triangle3 tria( + pts[j-1], + pts[j-2], + pts[j] + ); + trias.push_back(tria); + } + } + + } + + std::vector toTriangles() const { + std::vector trias; + toTriangles(trias); + return trias; + } + +}; + class GPCPolygon2 { struct GPCPolygon : gpc_polygon { @@ -113,35 +167,43 @@ public: for (int i = 0; i < res.num_strips; ++i) { gpc_vertex_list lst = res.strip[i]; - for (int j = 2; j < lst.num_vertices; ++j) { - - gpc_vertex& v1 = lst.vertex[j - 2]; - gpc_vertex& v2 = lst.vertex[j - 1]; - gpc_vertex& v3 = lst.vertex[j]; - - // https://en.wikipedia.org/wiki/Triangle_strip - // GL_TRIANGLE_STRIP - // Draws a series of triangles (three-sided polygons) using vertices v0, v1, v2, then v2, v1, v3 (note the order), then v2, v3, v4, and so on. The ordering is to ensure that the triangles are all drawn with the same orientation so that the strip can correctly form part of a surface. - // For odd n, vertices n, n+1, and n+2 define triangle n. For even n, vertices n+1, n, and n+2 define triangle n. N-2 triangles are drawn. - - if (j % 2 == 0) { - Triangle3 tria( - Point3(v1.x, v1.y, z), - Point3(v2.x, v2.y, z), - Point3(v3.x, v3.y, z) - ); - trias.push_back(tria); - } else { - Triangle3 tria( - Point3(v2.x, v2.y, z), - Point3(v1.x, v1.y, z), - Point3(v3.x, v3.y, z) - ); - trias.push_back(tria); - } - + TriangleStrip strip; + for (int j = 0; j < lst.num_vertices; ++j) { + gpc_vertex& v = lst.vertex[j]; + strip.add(Point3(v.x, v.y, z)); } + strip.toTriangles(trias); + +// for (int j = 2; j < lst.num_vertices; ++j) { + +// gpc_vertex& v1 = lst.vertex[j - 2]; +// gpc_vertex& v2 = lst.vertex[j - 1]; +// gpc_vertex& v3 = lst.vertex[j]; + +// // https://en.wikipedia.org/wiki/Triangle_strip +// // GL_TRIANGLE_STRIP +// // Draws a series of triangles (three-sided polygons) using vertices v0, v1, v2, then v2, v1, v3 (note the order), then v2, v3, v4, and so on. The ordering is to ensure that the triangles are all drawn with the same orientation so that the strip can correctly form part of a surface. +// // For odd n, vertices n, n+1, and n+2 define triangle n. For even n, vertices n+1, n, and n+2 define triangle n. N-2 triangles are drawn. + +// if (j % 2 == 0) { +// Triangle3 tria( +// Point3(v1.x, v1.y, z), +// Point3(v2.x, v2.y, z), +// Point3(v3.x, v3.y, z) +// ); +// trias.push_back(tria); +// } else { +// Triangle3 tria( +// Point3(v2.x, v2.y, z), +// Point3(v1.x, v1.y, z), +// Point3(v3.x, v3.y, z) +// ); +// trias.push_back(tria); +// } + + + //} } diff --git a/wifi/estimate/ray3/WifiRayTrace3D.h b/wifi/estimate/ray3/WifiRayTrace3D.h index 0934382..b848d79 100644 --- a/wifi/estimate/ray3/WifiRayTrace3D.h +++ b/wifi/estimate/ray3/WifiRayTrace3D.h @@ -14,8 +14,8 @@ #include "DataMap3.h" #include "../../../geo/Ray3.h" #include "MaterialOptions.h" -#include "Obstacle3.h" -#include "ModelFactory.h" +#include "../../../floorplan/3D/Obstacle3.h" +#include "../../../floorplan/3D/Builder.h" //#include "ObstacleTree.h" @@ -33,6 +33,7 @@ // 3D // http://graphics.stanford.edu/courses/cs148-10-summer/docs/2006--degreve--reflection_refraction.pdf +using namespace Floorplan3D; namespace Ray3D { @@ -199,7 +200,7 @@ namespace Ray3D { // allocate dm.resize(bbox, gs); - ModelFactory fac(map); + Builder fac(map); std::vector obstacles = fac.getMesh().elements; // build bounding volumes