Removed paths as members of Actors and replaced with Path class

sami-hatna66 · sami-hatna66 · commit 370355e4682f · 2022-06-24T14:54:48.000+01:00
diff --git a/external/Actor.cpp b/external/Actor.cpp
@@ -1,8 +1,8 @@
 #include "Actor.hpp"
 
-Actor::Actor(vecType pPos, vecType pVelocity, float pDesiredSpeed, std::array<vecType, PATHALLOCATIONSIZE> pPath, int pPathSize, float pMass, float pRadius, bool pAtDestination, std::array<int, 3> pColor, bool pHeatmapEnabled):
+Actor::Actor(vecType pPos, vecType pVelocity, float pDesiredSpeed, int pPathId, float pMass, float pRadius, bool pAtDestination, std::array<int, 3> pColor, bool pHeatmapEnabled):
     pos(pPos), velocity(pVelocity), desiredSpeed(pDesiredSpeed),
-    path(pPath), pathSize(pPathSize), mass(pMass), radius(pRadius), 
+    pathId(pPathId), mass(pMass), radius(pRadius), 
     atDestination(pAtDestination), color(pColor), heatmapEnabled(pHeatmapEnabled) {
         variation = {0, 0};
         destinationIndex = 0;
@@ -20,12 +20,12 @@ SYCL_EXTERNAL float Actor::getDesiredSpeed() const {
     return desiredSpeed;
 }
 
-SYCL_EXTERNAL std::array<vecType, PATHALLOCATIONSIZE> Actor::getPath() const {
-    return path;
+SYCL_EXTERNAL int Actor::getPathId() const {
+    return pathId;
 }
 
-SYCL_EXTERNAL vecType Actor::getDestination() const {
-    return path[destinationIndex];
+SYCL_EXTERNAL int Actor::getDestinationIndex() const {
+    return destinationIndex;
 }
 
 SYCL_EXTERNAL vecType Actor::getVariation() const {
@@ -64,10 +64,6 @@ SYCL_EXTERNAL void Actor::setDesiredSpeed(float newDesiredSpeed) {
     desiredSpeed = newDesiredSpeed;
 }
 
-SYCL_EXTERNAL void Actor::setPath(std::array<vecType, PATHALLOCATIONSIZE> newPath) {
-    path = newPath;
-}
-
 SYCL_EXTERNAL void Actor::setVariation(vecType newVariation) {
     variation = newVariation;
 }
@@ -80,11 +76,11 @@ SYCL_EXTERNAL void Actor::setColor(std::array<int, 3> newColor) {
     color = newColor;
 }
 
-SYCL_EXTERNAL void Actor::checkAtDestination() {
-    std::array<float, 4> destinationBoundingBox = {path[destinationIndex][0] + 0.2f, 
-                                                   path[destinationIndex][0] - 0.2f,
-                                                   path[destinationIndex][1] + 0.2f, 
-                                                   path[destinationIndex][1] - 0.2f};
+SYCL_EXTERNAL void Actor::checkAtDestination(vecType destination, int pathSize) {
+    std::array<float, 4> destinationBoundingBox = {destination[0] + 0.2f, 
+                                                   destination[0] - 0.2f,
+                                                   destination[1] + 0.2f, 
+                                                   destination[1] - 0.2f};
     if (pos[0] <= destinationBoundingBox[0] && pos[0] >= destinationBoundingBox[1]
         && pos[1] <= destinationBoundingBox[2] && pos[1] >= destinationBoundingBox[3]) {
             if (destinationIndex >= PATHALLOCATIONSIZE - 1 || destinationIndex >= pathSize - 1) {
diff --git a/external/Actor.hpp b/external/Actor.hpp
@@ -7,16 +7,14 @@
 #include <vector>
 #include <sycl/sycl.hpp>
 #include "VectorMaths.hpp"
-
-const int PATHALLOCATIONSIZE = 10;
+#include "Path.hpp"
 
 class Actor {
 private:
     vecType pos;
     vecType velocity;
     float desiredSpeed;
-    std::array<vecType, PATHALLOCATIONSIZE> path;
-    int pathSize;
+    int pathId;
     int destinationIndex;
     vecType variation;
     float mass;
@@ -25,14 +23,14 @@ class Actor {
     std::array<int, 3> color;
     bool heatmapEnabled;
 
-public:    
-    Actor(vecType pPos, vecType pVelocity, float pdesiredSpeed, std::array<vecType, PATHALLOCATIONSIZE> pPath, int pathSize, float pMass, float pRadius, bool pAtDestination, std::array<int, 3> pColor, bool pHeatmapEnabled);
+public:
+    Actor(vecType pPos, vecType pVelocity, float pdesiredSpeed, int pPathId, float pMass, float pRadius, bool pAtDestination, std::array<int, 3> pColor, bool pHeatmapEnabled);
     
     SYCL_EXTERNAL vecType getPos() const;
     SYCL_EXTERNAL vecType getVelocity() const;
     SYCL_EXTERNAL float getDesiredSpeed() const;
-    SYCL_EXTERNAL std::array<vecType, PATHALLOCATIONSIZE> getPath() const;
-    SYCL_EXTERNAL vecType getDestination() const;
+    SYCL_EXTERNAL int getPathId() const;
+    SYCL_EXTERNAL int getDestinationIndex() const;
     SYCL_EXTERNAL vecType getVariation() const;
     SYCL_EXTERNAL float getMass() const;
     SYCL_EXTERNAL float getRadius() const;
@@ -43,12 +41,11 @@ class Actor {
     SYCL_EXTERNAL void setPos(vecType newPos);
     SYCL_EXTERNAL void setVelocity(vecType newVelocity);
     SYCL_EXTERNAL void setDesiredSpeed(float newDesiredSpeed);
-    SYCL_EXTERNAL void setPath(std::array<vecType, PATHALLOCATIONSIZE> newPath);
     SYCL_EXTERNAL void setVariation(vecType newVariation);
     SYCL_EXTERNAL void setAtDestination(bool param);
     SYCL_EXTERNAL void setColor(std::array<int, 3> newColor);
 
-    SYCL_EXTERNAL void checkAtDestination();
+    SYCL_EXTERNAL void checkAtDestination(vecType destination, int pathSize);
     void refreshVariation();
 };
 
diff --git a/external/CMakeLists.txt b/external/CMakeLists.txt
@@ -1 +1 @@
-add_library(external Actor.cpp Room.cpp MathHelper.cpp DifferentialEq.cpp VectorMaths.cpp Heatmap.cpp ParseInputFile.cpp)
+add_library(external Actor.cpp Room.cpp Path.cpp MathHelper.cpp DifferentialEq.cpp VectorMaths.cpp Heatmap.cpp ParseInputFile.cpp)
diff --git a/external/DifferentialEq.cpp b/external/DifferentialEq.cpp
@@ -1,17 +1,20 @@
 #include "DifferentialEq.hpp"
 
-SYCL_EXTERNAL void differentialEq(int currentIndex, sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors, sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls, sycl::stream out) {
+SYCL_EXTERNAL void differentialEq(int currentIndex, sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors, sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls, sycl::accessor<Path, 1, sycl::access::mode::read> paths, sycl::stream out) {
     Actor* currentActor = &actors[currentIndex];
 
     vecType pos = currentActor->getPos();
 
     float mi = currentActor->getMass();
     float v0i = currentActor->getDesiredSpeed();
-    vecType e0i = normalize(getDirectionVector(currentActor->getPos(), currentActor->getDestination()));
+    vecType destination = paths[currentActor->getPathId()].getCheckpoints()[currentActor->getDestinationIndex()];
+    vecType e0i = normalize(getDirectionVector(currentActor->getPos(), destination));
     vecType vi = currentActor->getVelocity();
 
     vecType personalImpulse = mi * (((v0i * e0i) - vi) / Ti);
 
+    out << pos[0] << ", " << pos[1] << "   ->   " << destination[0] << ", " << destination[1] << sycl::endl;
+    
     vecType peopleForces = {0, 0};
     for (int x = 0; x < actors.size(); x++) {
         Actor neighbour = actors[x];
@@ -61,5 +64,5 @@ SYCL_EXTERNAL void differentialEq(int currentIndex, sycl::accessor<Actor, 1, syc
     currentActor->setVelocity(vi + acceleration * TIMESTEP);
     currentActor->setPos(pos + currentActor->getVelocity() * TIMESTEP);
 
-    currentActor->checkAtDestination();
+    currentActor->checkAtDestination(destination, paths[currentActor->getPathId()].getPathSize());
 }
diff --git a/external/DifferentialEq.hpp b/external/DifferentialEq.hpp
@@ -8,6 +8,7 @@
 #include "MathHelper.hpp"
 #include "VectorMaths.hpp"
 #include "Heatmap.hpp"
+#include "Path.hpp"
 
 constexpr float Ai = 200;
 constexpr float Bi = 0.08;
@@ -17,6 +18,6 @@ constexpr float Ti = 0.5;
 
 constexpr float TIMESTEP = 0.001;
 
-SYCL_EXTERNAL void differentialEq(int currentIndex, sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors, sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls, sycl::stream out);
+SYCL_EXTERNAL void differentialEq(int currentIndex, sycl::accessor<Actor, 1, sycl::access::mode::read_write> actors, sycl::accessor<std::array<vecType, 2>, 1, sycl::access::mode::read> walls, sycl::accessor<Path, 1, sycl::access::mode::read> paths, sycl::stream out);
 
 #endif
diff --git a/external/MathHelper.hpp b/external/MathHelper.hpp
@@ -6,6 +6,7 @@
 #include <sycl/sycl.hpp>
 #include "VectorMaths.hpp"
 
+
 SYCL_EXTERNAL vecType getDirectionVector(vecType a, vecType b);
 
 SYCL_EXTERNAL vecType velFromSpeedAndDir(float speed, vecType direction);
diff --git a/external/ParseInputFile.cpp b/external/ParseInputFile.cpp
@@ -6,6 +6,7 @@ void validateParameters(rapidjson::Document& jsonDoc) {
     if (!jsonDoc.HasMember("config")) missingParameters += "config ";
     if (!jsonDoc.HasMember("room")) missingParameters += "room ";
     if (!jsonDoc.HasMember("actors")) missingParameters += "actors ";
+    if (!jsonDoc.HasMember("paths")) missingParameters += "paths ";
     
     if (missingParameters != "") {
         throw JSONException("Missing these parameters: " + missingParameters);
@@ -21,25 +22,28 @@ void validateParameters(rapidjson::Document& jsonDoc) {
 
         if (!jsonDoc["room"].HasMember("walls")) missingParameters += "walls ";
 
-        if (jsonDoc["actors"].GetArray().Size() > 0) {
-            auto actorParams = {
-                "pos", "velocity", "desiredSpeed", "path",
-                "mass", "radius", "heatmapEnabled"
-            };
-            for (auto& a : jsonDoc["actors"].GetArray()) { 
-                for (auto p : actorParams) {
-                    if (!a.HasMember(p)) missingParameters += std::string(p) + " ";
-                }
+        auto actorParams = {
+            "pos", "velocity", "desiredSpeed", "pathId", "mass",
+            "radius", "atDestination", "color", "heatmapEnabled"
+        };
+        for (auto& a : jsonDoc["actors"].GetArray()) { 
+            for (auto p : actorParams) {
+                if (!a.HasMember(p)) missingParameters += std::string(p) + " ";
             }
         }
+        
+        for (auto& p : jsonDoc["paths"].GetArray()) {
+            if (!p.HasMember("id")) missingParameters += "id ";
+            if (!p.HasMember("checkpoints")) missingParameters += "checkpoints ";
+        }
 
         if (missingParameters != "") {
             throw JSONException("Missing these parameters: " + missingParameters);
         }
     }
 }
 
-void parseInputFile(std::string filename, std::vector<Actor> &actors, Room &room, int &WIDTH, int &HEIGHT, int &SCALE, int &DELAY) {
+void parseInputFile(std::string filename, std::vector<Actor> &actors, Room &room, std::vector<Path> &paths, int &WIDTH, int &HEIGHT, int &SCALE, int &DELAY) {
     std::ifstream jsonFile(filename);
     if (!jsonFile.is_open()) {
         throw JSONException("Error opening file " + filename);
@@ -68,20 +72,27 @@ void parseInputFile(std::string filename, std::vector<Actor> &actors, Room &room
     }
     room.setWalls(walls);
 
+    // Paths
+    auto jsonPaths = jsonDoc["paths"].GetArray();
+    for (auto& p : jsonPaths) {
+        int id = p["id"].GetInt();
+        auto jsonCheckpoints = p["checkpoints"].GetArray();
+        std::array<vecType, PATHALLOCATIONSIZE> checkpoints;
+        for (int i = 0; i < jsonCheckpoints.Size(); i++) {
+            checkpoints[i] = vecType({jsonCheckpoints[i][0].GetFloat(), jsonCheckpoints[i][1].GetFloat()});
+        }
+        int pathSize = jsonCheckpoints.Size();
+        paths.push_back(Path(id, checkpoints, pathSize));
+    }
+
     // Actor
     auto jsonActors = jsonDoc["actors"].GetArray();
     for (auto& a : jsonActors) {
         vecType pos = {a["pos"][0].GetFloat(), a["pos"][1].GetFloat()};
         vecType velocity = {a["velocity"][0].GetFloat(), a["velocity"][1].GetFloat()};
         float desiredSpeed = a["desiredSpeed"].GetFloat();
-        
-        auto jsonPath = a["path"].GetArray();
-        std::array<vecType, PATHALLOCATIONSIZE> path;
-        for (int x = 0; x < jsonPath.Size(); x++) {
-            path[x] = {jsonPath[x][0].GetFloat(), jsonPath[x][1].GetFloat()};
-        }
-
-        int pathSize = jsonPath.Size();
+        int pathId = a["pathId"].GetInt();
+        int pathSize = paths[pathId].getPathSize();
         int mass = a["mass"].GetInt();
         float radius = a["radius"].GetFloat();
         bool atDestination = a["atDestination"].GetBool();
@@ -91,6 +102,6 @@ void parseInputFile(std::string filename, std::vector<Actor> &actors, Room &room
 
         bool heatmapEnabled = a["heatmapEnabled"].GetBool();
 
-        actors.push_back(Actor(pos, velocity, desiredSpeed, path, pathSize, mass, radius, atDestination, color, heatmapEnabled));
+        actors.push_back(Actor(pos, velocity, desiredSpeed, pathId, mass, radius, atDestination, color, heatmapEnabled));
     }
 }   
diff --git a/external/ParseInputFile.hpp b/external/ParseInputFile.hpp
@@ -12,6 +12,7 @@
 #include "VectorMaths.hpp"
 #include "Actor.hpp"
 #include "Room.hpp"
+#include "Path.hpp"
 
 class JSONException : public std::runtime_error {
 public:
@@ -20,6 +21,6 @@ class JSONException : public std::runtime_error {
 
 void validateParameters(rapidjson::Document& jsonDoc);
 
-void parseInputFile(std::string filename, std::vector<Actor> &actors, Room &room, int &WIDTH, int &HEIGHT, int &SCALE, int &DELAY);
+void parseInputFile(std::string filename, std::vector<Actor> &actors, Room &room, std::vector<Path> &paths, int &WIDTH, int &HEIGHT, int &SCALE, int &DELAY);
 
 #endif
diff --git a/external/Path.cpp b/external/Path.cpp
@@ -0,0 +1,23 @@
+#include "Path.hpp"
+
+Path::Path(int pId, std::array<vecType, PATHALLOCATIONSIZE> pCheckpoints, int pPathSize) : id(pId), checkpoints(pCheckpoints), pathSize(pPathSize) {}
+
+SYCL_EXTERNAL int Path::getId() const {
+    return id;
+}
+
+SYCL_EXTERNAL std::array<vecType, PATHALLOCATIONSIZE> Path::getCheckpoints() const {
+    return checkpoints;
+}
+
+SYCL_EXTERNAL int Path::getPathSize() const {
+    return pathSize;
+}
+
+void Path::setId(int newId) {
+    id = newId;
+} 
+
+void Path::setCheckpoints(std::array<vecType, PATHALLOCATIONSIZE> newCheckpoints) {
+    checkpoints = newCheckpoints;
+}
diff --git a/external/Path.hpp b/external/Path.hpp
@@ -0,0 +1,27 @@
+#ifndef Path_hpp
+#define Path_hpp
+
+#include <iostream>
+#include <array>
+#include <sycl/sycl.hpp>
+#include "VectorMaths.hpp"
+
+const int PATHALLOCATIONSIZE = 10;
+
+class Path {
+private:
+    int id;
+    std::array<vecType, PATHALLOCATIONSIZE> checkpoints;
+    int pathSize;
+public:
+    Path(int pId, std::array<vecType, PATHALLOCATIONSIZE> pCheckpoints, int pPathSize);
+
+    SYCL_EXTERNAL int getId() const;
+    SYCL_EXTERNAL std::array<vecType, PATHALLOCATIONSIZE> getCheckpoints() const;
+    SYCL_EXTERNAL int getPathSize() const;
+
+    void setId(int newId);
+    void setCheckpoints(std::array<vecType, PATHALLOCATIONSIZE> newCheckpoints);
+};
+
+#endif
diff --git a/input/InputFileGenerator.py b/input/InputFileGenerator.py
diff --git a/input/evacuateRoom.json b/input/evacuateRoom.json
diff --git a/input/fourSquare.json b/input/fourSquare.json
diff --git a/input/twoExitsTwoGroups.json b/input/twoExitsTwoGroups.json
diff --git a/src/main.cpp b/src/main.cpp

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-add_library(external Actor.cpp Room.cpp MathHelper.cpp DifferentialEq.cpp VectorMaths.cpp Heatmap.cpp ParseInputFile.cpp)`
	`1`	`+add_library(external Actor.cpp Room.cpp Path.cpp MathHelper.cpp DifferentialEq.cpp VectorMaths.cpp Heatmap.cpp ParseInputFile.cpp)`