diff --git a/edgemesh.cpp b/edgemesh.cpp
index f479978..c2b845f 100755
--- a/edgemesh.cpp
+++ b/edgemesh.cpp
@@ -6,9 +6,9 @@
 
 Eigen::MatrixX2i VCGEdgeMesh::getEigenEdges() const { return eigenEdges; }
 
-std::vector<vcg::Point2i> VCGEdgeMesh::getEdges()
+std::vector<vcg::Point2i> VCGEdgeMesh::computeEdges()
 {
-    getEdges(eigenEdges);
+    computeEdges(eigenEdges);
     std::vector<vcg::Point2i> edges(eigenEdges.rows());
     for (int ei = 0; ei < eigenEdges.rows(); ei++) {
         edges[ei] = vcg::Point2i(eigenEdges(ei, 0), eigenEdges(ei, 1));
@@ -16,9 +16,10 @@ std::vector<vcg::Point2i> VCGEdgeMesh::getEdges()
     return edges;
 }
 
-Eigen::MatrixX3d VCGEdgeMesh::getEigenVertices() {
-    getVertices(eigenVertices);
-  return eigenVertices;
+Eigen::MatrixX3d VCGEdgeMesh::getEigenVertices() const
+{
+    //    getVertices(eigenVertices);
+    return eigenVertices;
 }
 
 Eigen::MatrixX3d VCGEdgeMesh::getEigenEdgeNormals() const {
@@ -182,8 +183,8 @@ bool VCGEdgeMesh::createSpanGrid(const size_t desiredWidth,
   vcg::tri::Allocator<VCGEdgeMesh>::DeleteVertex(
       *this, vert[(desiredHeight + 1) * (desiredWidth + 1) - 1]);
   vcg::tri::Allocator<VCGEdgeMesh>::CompactVertexVector(*this);
-  getEdges(eigenEdges);
-  getVertices(eigenVertices);
+  computeEdges(eigenEdges);
+  computeVertices(eigenVertices);
   //  vcg::tri::Allocator<VCGEdgeMesh>::CompactEdgeVector(*this);
 
   //  const size_t numberOfEdges =
@@ -214,8 +215,8 @@ bool VCGEdgeMesh::load(const std::filesystem::__cxx11::path &meshFilePath)
         return false;
     }
 
-    getEdges(eigenEdges);
-    getVertices(eigenVertices);
+    computeEdges(eigenEdges);
+    computeVertices(eigenVertices);
     vcg::tri::UpdateTopology<VCGEdgeMesh>::VertexEdge(*this);
     label = std::filesystem::path(meshFilePath).stem().string();
 
@@ -299,25 +300,24 @@ Eigen::MatrixX3d VCGEdgeMesh::getNormals() const {
 
   return vertexNormals;
 }
-void VCGEdgeMesh::getEdges(Eigen::MatrixX3d &edgeStartingPoints,
-                           Eigen::MatrixX3d &edgeEndingPoints) const {
-  edgeStartingPoints.resize(EN(), 3);
-  edgeEndingPoints.resize(EN(), 3);
-  for (int edgeIndex = 0; edgeIndex < EN(); edgeIndex++) {
-    const VCGEdgeMesh::EdgeType &edge = this->edge[edgeIndex];
-    edgeStartingPoints.row(edgeIndex) =
-        edge.cP(0).ToEigenVector<Eigen::Vector3d>();
-    edgeEndingPoints.row(edgeIndex) =
-        edge.cP(1).ToEigenVector<Eigen::Vector3d>();
-  }
+void VCGEdgeMesh::computeEdges(Eigen::MatrixX3d &edgeStartingPoints,
+                               Eigen::MatrixX3d &edgeEndingPoints) const
+{
+    edgeStartingPoints.resize(EN(), 3);
+    edgeEndingPoints.resize(EN(), 3);
+    for (int edgeIndex = 0; edgeIndex < EN(); edgeIndex++) {
+        const VCGEdgeMesh::EdgeType &edge = this->edge[edgeIndex];
+        edgeStartingPoints.row(edgeIndex) = edge.cP(0).ToEigenVector<Eigen::Vector3d>();
+        edgeEndingPoints.row(edgeIndex) = edge.cP(1).ToEigenVector<Eigen::Vector3d>();
+    }
 }
 
 VCGEdgeMesh::VCGEdgeMesh() {}
 
 void VCGEdgeMesh::updateEigenEdgeAndVertices() {
 #ifdef POLYSCOPE_DEFINED
-  getEdges(eigenEdges);
-  getVertices(eigenVertices);
+    computeEdges(eigenEdges);
+    computeVertices(eigenVertices);
 #endif
 }
 
@@ -325,13 +325,15 @@ bool VCGEdgeMesh::copy(VCGEdgeMesh &mesh) {
   vcg::tri::Append<VCGEdgeMesh, VCGEdgeMesh>::MeshCopy(*this, mesh);
   label = mesh.getLabel();
   eigenEdges = mesh.getEigenEdges();
-  if (eigenEdges.rows() == 0) {
-    getEdges(eigenEdges);
-  }
+  //  assert(eigenEdges.rows() != 0);
+  //  if (eigenEdges.rows() == 0) {
+  //    getEdges(eigenEdges);
+  //  }
   eigenVertices = mesh.getEigenVertices();
-  if (eigenVertices.rows() == 0) {
-    getVertices(eigenVertices);
-  }
+  //  assert(eigenVertices.rows() != 0);
+  //  if (eigenVertices.rows() == 0) {
+  //    getVertices(eigenVertices);
+  //  }
   vcg::tri::UpdateTopology<VCGEdgeMesh>::VertexEdge(*this);
 
   return true;
@@ -399,7 +401,8 @@ void VCGEdgeMesh::deleteDanglingVertices(vcg::tri::Allocator<VCGEdgeMesh>::Point
     updateEigenEdgeAndVertices();
 }
 
-void VCGEdgeMesh::getVertices(Eigen::MatrixX3d &vertices) {
+void VCGEdgeMesh::computeVertices(Eigen::MatrixX3d &vertices)
+{
     vertices = Eigen::MatrixX3d();
     vertices.resize(VN(), 3);
     for (int vi = 0; vi < VN(); vi++) {
@@ -412,21 +415,21 @@ void VCGEdgeMesh::getVertices(Eigen::MatrixX3d &vertices) {
     }
 }
 
-void VCGEdgeMesh::getEdges(Eigen::MatrixX2i &edges) {
-  edges = Eigen::MatrixX2i();
-  edges.resize(EN(), 2);
-  for (int edgeIndex = 0; edgeIndex < EN(); edgeIndex++) {
-    const VCGEdgeMesh::EdgeType &edge = this->edge[edgeIndex];
-    assert(!edge.IsD());
-    auto vp0 = edge.cV(0);
-    auto vp1 = edge.cV(1);
-    assert(vcg::tri::IsValidPointer(*this, vp0) &&
-           vcg::tri::IsValidPointer(*this, vp1));
-    const size_t vi0 = vcg::tri::Index<VCGEdgeMesh>(*this, vp0);
-    const size_t vi1 = vcg::tri::Index<VCGEdgeMesh>(*this, vp1);
-    assert(vi0 != -1 && vi1 != -1);
-    edges.row(edgeIndex) = Eigen::Vector2i(vi0, vi1);
-  }
+void VCGEdgeMesh::computeEdges(Eigen::MatrixX2i &edges)
+{
+    edges = Eigen::MatrixX2i();
+    edges.resize(EN(), 2);
+    for (int edgeIndex = 0; edgeIndex < EN(); edgeIndex++) {
+        const VCGEdgeMesh::EdgeType &edge = this->edge[edgeIndex];
+        assert(!edge.IsD());
+        auto vp0 = edge.cV(0);
+        auto vp1 = edge.cV(1);
+        assert(vcg::tri::IsValidPointer(*this, vp0) && vcg::tri::IsValidPointer(*this, vp1));
+        const size_t vi0 = vcg::tri::Index<VCGEdgeMesh>(*this, vp0);
+        const size_t vi1 = vcg::tri::Index<VCGEdgeMesh>(*this, vp1);
+        assert(vi0 != -1 && vi1 != -1);
+        edges.row(edgeIndex) = Eigen::Vector2i(vi0, vi1);
+    }
 }
 
 void VCGEdgeMesh::printVertexCoordinates(const size_t &vi) const {
@@ -456,7 +459,7 @@ polyscope::CurveNetwork *VCGEdgeMesh::registerForDrawing(
         const glm::vec3 desiredColor_glm(desiredColor.value()[0],
                                          desiredColor.value()[1],
                                          desiredColor.value()[2]);
-        polyscopeHandle_edgeMesh->setColor(desiredColor_glm);
+        polyscopeHandle_edgeMesh->setColor(/*glm::normalize(*/ desiredColor_glm /*)*/);
     }
 
     return polyscopeHandle_edgeMesh;
diff --git a/edgemesh.hpp b/edgemesh.hpp
index ebd7ed8..de8cd51 100755
--- a/edgemesh.hpp
+++ b/edgemesh.hpp
@@ -40,8 +40,8 @@ protected:
     Eigen::MatrixX3d eigenVertices;
     Eigen::MatrixX3d eigenEdgeNormals;
 
-    void getEdges(Eigen::MatrixX2i &edges);
-    void getVertices(Eigen::MatrixX3d &vertices);
+    void computeEdges(Eigen::MatrixX2i &edges);
+    void computeVertices(Eigen::MatrixX3d &vertices);
 
 public:
     VCGEdgeMesh();
@@ -65,7 +65,7 @@ public:
     virtual void deleteDanglingVertices(
         vcg::tri::Allocator<VCGEdgeMesh>::PointerUpdater<VertexPointer> &pu);
 
-    void getEdges(Eigen::MatrixX3d &edgeStartingPoints, Eigen::MatrixX3d &edgeEndingPoints) const;
+    void computeEdges(Eigen::MatrixX3d &edgeStartingPoints, Eigen::MatrixX3d &edgeEndingPoints) const;
 
     Eigen::MatrixX3d getNormals() const;
 
@@ -81,9 +81,9 @@ public:
     void createSpiral(const float &degreesOfArm, const size_t &numberOfSamples);
 
     Eigen::MatrixX2i getEigenEdges() const;
-    std::vector<vcg::Point2i> getEdges();
+    std::vector<vcg::Point2i> computeEdges();
 
-    Eigen::MatrixX3d getEigenVertices();
+    Eigen::MatrixX3d getEigenVertices() const;
     Eigen::MatrixX3d getEigenEdgeNormals() const;
     void printVertexCoordinates(const size_t &vi) const;
 #ifdef POLYSCOPE_DEFINED