polyscope 2.0.0__tar.gz → 2.1.0__tar.gz

{polyscope-2.0.0/src/polyscope.egg-info → polyscope-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyscope
-Version: 2.0.0
+Version: 2.1.0
 Summary: Polyscope: A viewer and user interface for 3D data.
 Home-page: https://polyscope.run
 Author: Nicholas Sharp

{polyscope-2.0.0 → polyscope-2.1.0}/deps/polyscope/include/polyscope/persistent_value.h

@@ -46,14 +46,13 @@ public:
   PersistentValue(const std::string& name_, T value_) : name(name_), value(value_) {
     if (detail::getPersistentCacheRef<T>().cache.find(name) != detail::getPersistentCacheRef<T>().cache.end()) {
       value = detail::getPersistentCacheRef<T>().cache[name];
-      holdsDefaultValue = false;
+      holdsDefaultValue_ = false;
     } else {
       // Update cache value
       detail::getPersistentCacheRef<T>().cache[name] = value;
     }
   }
 
-  // Ensure in cache on deletion (see not above reference conversion)
   ~PersistentValue() {}
 
   // Don't want copy or move constructors, only operators
@@ -85,32 +84,48 @@ public:
   // NOTE if you write via this reference, the value will not _actually_ be cached until
   // manuallyChanged() is called, rather than immediately (ugly, but seems necessary to use with imgui)
   T& get() { return value; }
+
+  // Mark that a value has been directly written via the get() reference, and should be cached
   void manuallyChanged() { set(value); }
 
+  // clears any cached value, but does not change the current value of the variable
+  void clearCache() {
+    detail::getPersistentCacheRef<T>().cache.erase(name);
+    holdsDefaultValue_ = true;
+  }
+
   // Explicit setter, which takes care of storing in cache
   void set(T value_) {
     value = value_;
     detail::getPersistentCacheRef<T>().cache[name] = value;
-    holdsDefaultValue = false;
+    holdsDefaultValue_ = false;
   }
 
   // Passive setter, will change value without marking in cache; does nothing if some value has already been directly
   // set (equivalent to constructing with a different value).
   void setPassive(T value_) {
-    if (holdsDefaultValue) {
+    if (holdsDefaultValue_) {
       value = value_;
       detail::getPersistentCacheRef<T>().cache[name] = value;
     }
   }
 
+  bool holdsDefaultValue() const { return holdsDefaultValue_; }
+
   // Make all template variants friends, so conversion can access private members
   template <typename>
   friend class PersistentValue;
 
+protected:
+  // the name of the value
   const std::string name;
+
+  // the value
   T value;
-  bool holdsDefaultValue = true; // True if the value was set on construction and never changed. False if it was pulled
-                                 // from cache or has ever been explicitly set
+
+  // True if the value was set on construction or passively and never changed. False if
+  // it was pulled from cache or has ever been explicitly set
+  bool holdsDefaultValue_ = true;
 };
 
 // clang-format off

{polyscope-2.0.0 → polyscope-2.1.0}/deps/polyscope/include/polyscope/scalar_quantity.h

@@ -67,8 +67,9 @@ protected:
   // === Visualization parameters
 
   // Affine data maps and limits
-  std::pair<float, float> vizRange; // TODO make these persistent
   std::pair<double, double> dataRange;
+  PersistentValue<float> vizRangeMin;
+  PersistentValue<float> vizRangeMax;
   Histogram hist;
 
   // Parameters

{polyscope-2.0.0 → polyscope-2.1.0}/deps/polyscope/include/polyscope/scalar_quantity.ipp

@@ -8,6 +8,8 @@ template <typename QuantityT>
 ScalarQuantity<QuantityT>::ScalarQuantity(QuantityT& quantity_, const std::vector<float>& values_, DataType dataType_)
     : quantity(quantity_), values(&quantity, quantity.uniquePrefix() + "values", valuesData), valuesData(values_),
       dataType(dataType_), dataRange(robustMinMax(values.data, 1e-5)),
+      vizRangeMin(quantity.uniquePrefix() + "vizRangeMin", -777.), // set later,
+      vizRangeMax(quantity.uniquePrefix() + "vizRangeMax", -777.), // including clearing cache
       cMap(quantity.uniquePrefix() + "cmap", defaultColorMap(dataType)),
       isolinesEnabled(quantity.uniquePrefix() + "isolinesEnabled", false),
       isolineWidth(quantity.uniquePrefix() + "isolineWidth",
@@ -17,7 +19,12 @@ ScalarQuantity<QuantityT>::ScalarQuantity(QuantityT& quantity_, const std::vecto
 {
   hist.updateColormap(cMap.get());
   hist.buildHistogram(values.data);
-  resetMapRange();
+
+  if (vizRangeMin.holdsDefaultValue()) { // min and max should always have same cache state
+    // dynamically compute a viz range from the data min/max
+    // note that this also clears the persistent value's cahce, so it's like it was never set
+    resetMapRange();
+  }
 }
 
 template <typename QuantityT>
@@ -62,7 +69,7 @@ void ScalarQuantity<QuantityT>::buildScalarUI() {
 
 
   // Draw the histogram of values
-  hist.colormapRange = vizRange;
+  hist.colormapRange = std::pair<float, float>(vizRangeMin.get(), vizRangeMax.get());
   float windowWidth = ImGui::GetWindowWidth();
   float histWidth = 0.75 * windowWidth;
   hist.buildUI(histWidth);
@@ -77,36 +84,47 @@ void ScalarQuantity<QuantityT>::buildScalarUI() {
     float imPad = ImGui::GetStyle().ItemSpacing.x;
     ImGui::PushItemWidth((histWidth - imPad) / 2);
     float speed = (dataRange.second - dataRange.first) / 100.;
+    bool changed = false;
 
     switch (dataType) {
     case DataType::STANDARD: {
 
-      ImGui::DragFloat("##min", &vizRange.first, speed, dataRange.first, vizRange.second, "%.5g",
-                       ImGuiSliderFlags_NoRoundToFormat);
+      changed = changed || ImGui::DragFloat("##min", &vizRangeMin.get(), speed, dataRange.first, vizRangeMax.get(),
+                                            "%.5g", ImGuiSliderFlags_NoRoundToFormat);
       ImGui::SameLine();
-      ImGui::DragFloat("##max", &vizRange.second, speed, vizRange.first, dataRange.second, "%.5g",
-                       ImGuiSliderFlags_NoRoundToFormat);
+      changed = changed || ImGui::DragFloat("##max", &vizRangeMax.get(), speed, vizRangeMin.get(), dataRange.second,
+                                            "%.5g", ImGuiSliderFlags_NoRoundToFormat);
 
     } break;
     case DataType::SYMMETRIC: {
       float absRange = std::max(std::abs(dataRange.first), std::abs(dataRange.second));
 
-      if (ImGui::DragFloat("##min", &vizRange.first, speed, -absRange, 0.f, "%.5g", ImGuiSliderFlags_NoRoundToFormat)) {
-        vizRange.second = -vizRange.first;
+      if (ImGui::DragFloat("##min", &vizRangeMin.get(), speed, -absRange, 0.f, "%.5g",
+                           ImGuiSliderFlags_NoRoundToFormat)) {
+        vizRangeMax.get() = -vizRangeMin.get();
+        changed = true;
       }
       ImGui::SameLine();
-      if (ImGui::DragFloat("##max", &vizRange.second, speed, 0.f, absRange, "%.5g", ImGuiSliderFlags_NoRoundToFormat)) {
-        vizRange.first = -vizRange.second;
+      if (ImGui::DragFloat("##max", &vizRangeMax.get(), speed, 0.f, absRange, "%.5g",
+                           ImGuiSliderFlags_NoRoundToFormat)) {
+        vizRangeMin.get() = -vizRangeMax.get();
+        changed = true;
       }
 
     } break;
     case DataType::MAGNITUDE: {
-      ImGui::DragFloat("##max", &vizRange.second, speed, 0.f, dataRange.second, "%.5g",
-                       ImGuiSliderFlags_NoRoundToFormat);
+      changed = changed || ImGui::DragFloat("##max", &vizRangeMax.get(), speed, 0.f, dataRange.second, "%.5g",
+                                            ImGuiSliderFlags_NoRoundToFormat);
 
     } break;
     }
 
+    if (changed) {
+      vizRangeMin.manuallyChanged();
+      vizRangeMax.manuallyChanged();
+      requestRedraw();
+    }
+
     ImGui::PopItemWidth();
   }
 
@@ -162,8 +180,8 @@ std::vector<std::string> ScalarQuantity<QuantityT>::addScalarRules(std::vector<s
 
 template <typename QuantityT>
 void ScalarQuantity<QuantityT>::setScalarUniforms(render::ShaderProgram& p) {
-  p.setUniform("u_rangeLow", vizRange.first);
-  p.setUniform("u_rangeHigh", vizRange.second);
+  p.setUniform("u_rangeLow", vizRangeMin.get());
+  p.setUniform("u_rangeHigh", vizRangeMax.get());
 
   if (isolinesEnabled.get()) {
     p.setUniform("u_modLen", getIsolineWidth());
@@ -175,17 +193,23 @@ template <typename QuantityT>
 QuantityT* ScalarQuantity<QuantityT>::resetMapRange() {
   switch (dataType) {
   case DataType::STANDARD:
-    vizRange = dataRange;
+    vizRangeMin = dataRange.first;
+    vizRangeMax = dataRange.second;
     break;
   case DataType::SYMMETRIC: {
     double absRange = std::max(std::abs(dataRange.first), std::abs(dataRange.second));
-    vizRange = std::make_pair(-absRange, absRange);
+    vizRangeMin = -absRange;
+    vizRangeMax = absRange;
   } break;
   case DataType::MAGNITUDE:
-    vizRange = std::make_pair(0., dataRange.second);
+    vizRangeMin = 0.;
+    vizRangeMax = dataRange.second;
     break;
   }
 
+  vizRangeMin.clearCache();
+  vizRangeMax.clearCache();
+
   requestRedraw();
   return &quantity;
 }
@@ -214,13 +238,14 @@ std::string ScalarQuantity<QuantityT>::getColorMap() {
 
 template <typename QuantityT>
 QuantityT* ScalarQuantity<QuantityT>::setMapRange(std::pair<double, double> val) {
-  vizRange = val;
+  vizRangeMin = val.first;
+  vizRangeMax = val.second;
   requestRedraw();
   return &quantity;
 }
 template <typename QuantityT>
 std::pair<double, double> ScalarQuantity<QuantityT>::getMapRange() {
-  return vizRange;
+  return std::pair<float, float>(vizRangeMin.get(), vizRangeMax.get());
 }
 template <typename QuantityT>
 std::pair<double, double> ScalarQuantity<QuantityT>::getDataRange() {

{polyscope-2.0.0 → polyscope-2.1.0}/deps/polyscope/include/polyscope/surface_mesh.h

@@ -423,6 +423,12 @@ template <class V, class F>
 SurfaceMesh* registerSurfaceMesh(std::string name, const V& vertexPositions, const F& faceIndices);
 template <class V, class F>
 SurfaceMesh* registerSurfaceMesh2D(std::string name, const V& vertexPositions, const F& faceIndices);
+
+// register functions that also set perms
+// these are kept mainly for backward compatability, prefer setting perms after registering
+template <class V, class F, class P>
+SurfaceMesh* registerSurfaceMesh(std::string name, const V& vertexPositions, const F& faceIndices,
+                                 const std::array<std::pair<P, size_t>, 3>& perms);
 template <class V, class F, class P>
 SurfaceMesh* registerSurfaceMesh(std::string name, const V& vertexPositions, const F& faceIndices,
                                  const std::array<std::pair<P, size_t>, 5>& perms);

{polyscope-2.0.0 → polyscope-2.1.0}/deps/polyscope/include/polyscope/surface_mesh.ipp

@@ -40,6 +40,26 @@ SurfaceMesh* registerSurfaceMesh2D(std::string name, const V& vertexPositions, c
   return registerSurfaceMesh(name, positions3D, faceIndices);
 }
 
+template <class V, class F, class P>
+SurfaceMesh* registerSurfaceMesh(std::string name, const V& vertexPositions, const F& faceIndices,
+                                 const std::array<std::pair<P, size_t>, 3>& perms) {
+  SurfaceMesh* mesh = registerSurfaceMesh(name, vertexPositions, faceIndices);
+  if (mesh) {
+    mesh->setAllPermutations(perms);
+  }
+  return mesh;
+}
+
+template <class V, class F, class P>
+SurfaceMesh* registerSurfaceMesh(std::string name, const V& vertexPositions, const F& faceIndices,
+                                 const std::array<std::pair<P, size_t>, 5>& perms) {
+  SurfaceMesh* mesh = registerSurfaceMesh(name, vertexPositions, faceIndices);
+  if (mesh) {
+    mesh->setAllPermutations(perms);
+  }
+  return mesh;
+}
+
 template <class V>
 void SurfaceMesh::updateVertexPositions(const V& newPositions) {
   validateSize(newPositions, vertexDataSize, "newPositions");

{polyscope-2.0.0 → polyscope-2.1.0}/deps/polyscope/src/volume_grid_scalar_quantity.cpp

@@ -71,9 +71,9 @@ void VolumeGridNodeScalarQuantity::buildCustomUI() {
 
     // Set isovalue
     ImGui::PushItemWidth(120);
-    if (ImGui::SliderFloat("##Radius", &isosurfaceLevel.get(), vizRange.first, vizRange.second, "%.4e")) {
+    if (ImGui::SliderFloat("##Radius", &isosurfaceLevel.get(), vizRangeMin.get(), vizRangeMax.get(), "%.4e")) {
       // Note: we intentionally do this rather than calling setIsosurfaceLevel(), because that function immediately
-      // recomputes the level set mesh, which is too expensive during user interaction
+      // recomputes the levelset mesh, which is too expensive during user interaction
       isosurfaceLevel.manuallyChanged();
     }
     ImGui::PopItemWidth();

polyscope-2.1.0/deps/polyscope/test/src/misc_test.cpp

@@ -0,0 +1,43 @@
+// Copyright 2017-2023, Nicholas Sharp and the Polyscope contributors. https://polyscope.run
+
+#include "polyscope_test.h"
+
+// ============================================================
+// =============== Scalar Quantity Tests
+// ============================================================
+
+// We test these on a point cloud because it is convenient, but really we are testing the scalar quantity
+
+TEST_F(PolyscopeTest, TestScalarQuantity) {
+  auto psPoints = registerPointCloud();
+
+  std::vector<double> vScalar(psPoints->nPoints(), 7.);
+  auto q1 = psPoints->addScalarQuantity("vScalar", vScalar);
+  q1->setEnabled(true);
+  polyscope::show(3);
+
+  // get map range
+  std::pair<double, double> newRange = {-1., 1.};
+  q1->setMapRange(newRange);
+  EXPECT_EQ(newRange, q1->getMapRange());
+
+
+  polyscope::show(3);
+
+  polyscope::removeAllStructures();
+}
+
+// ============================================================
+// =============== Materials tests
+// ============================================================
+
+TEST_F(PolyscopeTest, FlatMaterialTest) {
+  auto psMesh = registerTriangleMesh();
+
+  // Test the flat material, it uses custom rules & uniforms and thus is different from others
+  psMesh->setMaterial("flat");
+  EXPECT_EQ(psMesh->getMaterial(), "flat");
+  polyscope::show(3);
+
+  polyscope::removeAllStructures();
+}

{polyscope-2.0.0 → polyscope-2.1.0}/setup.py

@@ -9,7 +9,7 @@ from setuptools import setup, Extension
 from setuptools.command.build_ext import build_ext
 from distutils.version import LooseVersion
 
-__version__ = '2.0.0'
+__version__ = '2.1.0'
 
 class CMakeExtension(Extension):
     def __init__(self, name, sourcedir='', exclude_arch=False):

{polyscope-2.0.0 → polyscope-2.1.0}/src/cpp/utils.h

@@ -196,7 +196,9 @@ py::class_<ScalarQ> bindScalarQuantity(py::module& m, std::string name) {
   return bindQuantity<ScalarQ>(m, name.c_str())
       .def("set_color_map", &ScalarQ::setColorMap, "Set color map")
       .def("set_map_range", &ScalarQ::setMapRange, "Set map range")
-      .def("set_isoline_width", &ScalarQ::setIsolineWidth, "Set isoline width");
+      .def("set_isolines_enabled", &ScalarQ::setIsolinesEnabled)
+      .def("set_isoline_width", &ScalarQ::setIsolineWidth, "Set isoline width")
+      .def("set_isoline_darkness", &ScalarQ::setIsolineDarkness);
 }
 
 template <typename VolumeMeshVertexScalarQuantity>

{polyscope-2.0.0 → polyscope-2.1.0}/src/polyscope/common.py

@@ -62,6 +62,21 @@ def process_scalar_args(structure, quantity, scalar_args):
     val = check_and_pop_arg(scalar_args, 'cmap')
     if val is not None:
         quantity.set_color_map(val)
+    
+    val = check_and_pop_arg(scalar_args, 'isolines_enabled')
+    if val is not None:
+        quantity.set_isolines_enabled(val)
+    
+    val = check_and_pop_arg(scalar_args, 'isoline_width')
+    val_relative = check_and_pop_arg(scalar_args, 'isoline_width_relative')
+    if val is not None:
+        if val_relative is None: 
+            val_relative = False
+        quantity.set_isoline_width(val, val_relative)
+    
+    val = check_and_pop_arg(scalar_args, 'isoline_darkness')
+    if val is not None:
+        quantity.set_isoline_darkness(val)
 
 
 # Process args, removing them from the dict if they are present

{polyscope-2.0.0 → polyscope-2.1.0}/src/polyscope/core.py

@@ -466,7 +466,7 @@ class CameraParameters:
                 int(dims[0]), int(dims[1]),
                 str_to_image_origin(image_origin)
             )
-        return out_rays.reshape(dims[0], dims[1], 3)
+        return out_rays.reshape(dims[1], dims[0], 3)
 
     def generate_camera_ray_corners(self): 
         return self.instance.generate_camera_ray_corners()

{polyscope-2.0.0 → polyscope-2.1.0}/src/polyscope/volume_grid.py

@@ -169,7 +169,7 @@ class VolumeGrid(Structure):
         check_all_args_processed(self, q, scalar_args)
    
 
-def register_volume_grid(name, bound_low, bound_high, node_dims, enabled=None, color=None, edge_color=None, edge_width=None, cube_size_factor=None, material=None, transparency=None):
+def register_volume_grid(name, node_dims, bound_low, bound_high, enabled=None, color=None, edge_color=None, edge_width=None, cube_size_factor=None, material=None, transparency=None):
 
     """Register a new volume grid"""
 

{polyscope-2.0.0 → polyscope-2.1.0/src/polyscope.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: polyscope
-Version: 2.0.0
+Version: 2.1.0
 Summary: Polyscope: A viewer and user interface for 3D data.
 Home-page: https://polyscope.run
 Author: Nicholas Sharp

polyscope-2.0.0/deps/polyscope/test/src/misc_test.cpp

@@ -1,18 +0,0 @@
-// Copyright 2017-2023, Nicholas Sharp and the Polyscope contributors. https://polyscope.run
-
-#include "polyscope_test.h"
-
-// ============================================================
-// =============== Materials tests
-// ============================================================
-
-TEST_F(PolyscopeTest, FlatMaterialTest) {
-  auto psMesh = registerTriangleMesh();
-
-  // Test the flat material, it uses custom rules & uniforms and thus is different from others
-  psMesh->setMaterial("flat");
-  EXPECT_EQ(psMesh->getMaterial(), "flat");
-  polyscope::show(3);
-
-  polyscope::removeAllStructures();
-}