WIP: Isolayer updates

examples/amr_volume_rendering_isocontours.py

@@ -0,0 +1,14 @@
+import yt
+import yt_idv
+
+ds = yt.load_sample("IsolatedGalaxy")
+
+rc = yt_idv.render_context(height=800, width=800, gui=True)
+sg = rc.add_scene(ds, "density", no_ghost=True)
+sg.components[0].render_method = 'isocontours'
+
+# default behavior will treat these values as base-10 exponents
+sg.components[0].iso_layers[0] = -29.0
+sg.components[0].iso_tolerance[0] = 1.0 # tolerance in percent
+
+rc.run()

yt_idv/scene_components/base_component.py

@@ -29,11 +29,6 @@ class SceneComponent(traitlets.HasTraits):
  priority = traitlets.CInt(0)
  visible = traitlets.Bool(True)
  use_db = traitlets.Bool(False) # use depth buffer
- iso_tolerance = traitlets.CFloat(-1) # the tolerance for finding isocontours
- iso_tol_is_pct = traitlets.Bool(False) # if True, the tolerance is a fraction
- iso_log = traitlets.Bool(True) # if True, iso values are base 10 exponents
- iso_layers = traitlets.List() # the target values for isocontours
- iso_layers_alpha = traitlets.List() # the transparency of isocontours
  display_bounds = traitlets.Tuple(
  traitlets.CFloat(),
  traitlets.CFloat(),
@@ -109,28 +104,9 @@ def render_gui(self, imgui, renderer, scene):
  _ = add_popup_help(imgui, "Click to reset the colorbounds of the current view.")
  changed = changed or _
 
- if self.render_method == "isocontours":
- _ = self._render_isolayer_inputs(imgui)
- changed = changed or _
 
  return changed
 
- @traitlets.observe("iso_log")
- def _switch_iso_log(self, change):
- # if iso_log, then the user is setting 10**x, otherwise they are setting
- # x directly. So when toggling this checkbox we convert the existing
- # values between the two forms.
- if change["old"]:
- # if True, we were taking the log, but now are not:
- self.iso_tolerance = 10**self.iso_tolerance
- new_iso_layers = [10**iso_val for iso_val in self.iso_layers]
- self.iso_layers = new_iso_layers
- else:
- # we were not taking the log but now we are, so convert to the exponent
- self.iso_tolerance = np.log10(self.iso_tolerance)
- new_iso_layers = [np.log10(iso_val) for iso_val in self.iso_layers]
- self.iso_layers = new_iso_layers
-
  @traitlets.default("display_name")
  def _default_display_name(self):
  return self.name
@@ -149,14 +125,6 @@ def _change_render_method(self, change):
  self.colormap_vertex = new_combo["second_vertex"]
  self.colormap_fragment = new_combo["second_fragment"]
 
- @traitlets.observe("render_method")
- def _add_initial_isolayer(self, change):
- # this adds an initial isocontour entry when the render method
- # switches to isocontours and if there are no layers yet.
- if change["new"] == "isocontours" and len(self.iso_layers) == 0:
- self.iso_layers.append(0.0)
- self.iso_layers_alpha.append(1.0)
-
  @traitlets.default("fb")
  def _fb_default(self):
  return Framebuffer()
@@ -253,17 +221,7 @@ def program2(self):
  self._program2_invalid = False
  return self._program2
 
- def _set_iso_uniforms(self, p):
- # these could be handled better by watching traits.
- p._set_uniform("iso_num_layers", int(len(self.iso_layers)))
- isolayervals = self._get_sanitized_iso_layers()
- p._set_uniform("iso_layers", isolayervals)
- p._set_uniform("iso_layer_tol", self._get_sanitized_iso_tol())
- avals = np.zeros((32,), dtype="float32")
- avals[: len(self.iso_layers)] = np.array(self.iso_layers_alpha)
- p._set_uniform("iso_alphas", avals)
- p._set_uniform("iso_min", float(self.data.min_val))
- p._set_uniform("iso_max", float(self.data.max_val))
+
 
  def run_program(self, scene):
  # Store this info, because we need to render into a framebuffer that is the
@@ -276,8 +234,6 @@ def run_program(self, scene):
  with self.program1.enable() as p:
  scene.camera._set_uniforms(scene, p)
  self._set_uniforms(scene, p)
- if self.render_method == "isocontours":
- self._set_iso_uniforms(p)
  with self.data.vertex_array.bind(p):
  self.draw(scene, p)
 
@@ -306,65 +262,6 @@ def run_program(self, scene):
  def draw(self, scene, program):
  raise NotImplementedError
 
- def _get_sanitized_iso_layers(self, normalize=True):
- # returns an array of the isocontour layer values, padded with 0s out
- # to max number of contours (32).
- iso_vals = np.asarray(self.iso_layers)
- if self.iso_log:
- iso_vals = 10**iso_vals
-
- if normalize:
- iso_vals = self.data._normalize_by_min_max(iso_vals)
-
- full_array = np.zeros(32, dtype="float32")
- full_array[: len(self.iso_layers)] = iso_vals
- return full_array
-
- def _get_sanitized_iso_tol(self):
- # isocontour selection conditions:
- #
- # absolute difference
- # d - c <= eps
- # or percent difference
- # (d - c) / c * 100 <= eps_pct
- #
- # where d is a raw data value, c is the target isocontour, eps
- # is an absolute difference, eps_f is a percent difference
- #
- # The data textures available on the shaders are normalized values:
- # d_ = (d - min) / (max - min)
- # where max and min are the global min and max values across the entire
- # volume (e.g., over all blocks, not within a block)
- #
- # So in terms of normalized values, the absoulte difference condition
- # becomes
- # d_ - c_ <= eps / (max - min)
- # where c_ is the target value normalized in the same way as d_.
- #
- # And the percent difference becomes
- # (d_ - c_) * (max - min) / c * 100 <= eps_pct
- # or
- # d_ - c_ <= eps_pct / 100 * c / (max - min)
- # so that the allowed tolerance is a function of the raw target value
- # and so will vary with each layer.
-
- if self.iso_log:
- # the tol value is an exponent, convert
- tol = 10 ** float(self.iso_tolerance)
- else:
- tol = float(self.iso_tolerance)
- # always normalize tolerance
- tol = tol / self.data.val_range
-
- if self.iso_tol_is_pct:
- # tolerance depends on the layer value
- tol = tol * 0.01
- raw_layers = self._get_sanitized_iso_layers(normalize=False)
- final_tol = raw_layers * tol
- else:
- final_tol = np.full((32,), tol, dtype="float32")
- return final_tol
-
  def _recompile_shader(self) -> bool:
  # removes existing shaders, invalidates shader programs
  shaders = (
@@ -381,77 +278,6 @@ def _recompile_shader(self) -> bool:
  self._program1_invalid = self._program2_invalid = True
  return True
 
- def _render_isolayer_inputs(self, imgui) -> bool:
- changed = False
- if imgui.tree_node("Isocontours"):
- _, self.iso_log = imgui.checkbox("set exponent", self.iso_log)
- _ = add_popup_help(
- imgui, "If checked, will treat isocontour values as base-10 exponents."
- )
- changed = changed or _
-
- imgui.columns(2, "iso_tol_cols", False)
-
- _, self.iso_tolerance = imgui.input_float(
- "tol",
- self.iso_tolerance,
- flags=imgui.INPUT_TEXT_ENTER_RETURNS_TRUE,
- )
- _ = add_popup_help(imgui, "The tolerance for selecting an isocontour.")
- changed = changed or _
-
- imgui.next_column()
- _, self.iso_tol_is_pct = imgui.checkbox("%", self.iso_tol_is_pct)
- _ = add_popup_help(imgui, "If checked, the tolerance is a percent.")
- changed = changed or _
- imgui.columns(1)
-
- if imgui.button("Add Layer"):
- if len(self.iso_layers) < 32:
- changed = True
- self.iso_layers.append(0.0)
- self.iso_layers_alpha.append(1.0)
- _ = self._construct_isolayer_table(imgui)
- changed = changed or _
- imgui.tree_pop()
- return changed
-
- def _construct_isolayer_table(self, imgui) -> bool:
- imgui.columns(3, "iso_layers_cols", False)
-
- i = 0
- changed = False
- while i < len(self.iso_layers):
- _, self.iso_layers[i] = imgui.input_float(
- f"Layer {i + 1}",
- self.iso_layers[i],
- flags=imgui.INPUT_TEXT_ENTER_RETURNS_TRUE,
- )
- _ = add_popup_help(imgui, "The value of the isocontour layer.")
- changed = changed or _
-
- imgui.next_column()
- _, self.iso_layers_alpha[i] = imgui.input_float(
- f"alpha {i}",
- self.iso_layers_alpha[i],
- flags=imgui.INPUT_TEXT_ENTER_RETURNS_TRUE,
- )
- _ = add_popup_help(imgui, "The opacity of the isocontour layer.")
- changed = changed or _
-
- imgui.next_column()
- if imgui.button("Remove##rl" + str(i + 1)):
- self.iso_layers.pop(i)
- self.iso_layers_alpha.pop(i)
- i -= 1
- _ = True
- changed = changed or _
- imgui.next_column()
- i += 1
- imgui.columns(1)
-
- return changed
-
  def _reset_cmap_bounds(self):
  data = self.fb.data
  if self.use_db:

yt_idv/scene_components/blocks.py

@@ -7,11 +7,12 @@
 from yt_idv.gui_support import add_popup_help
 from yt_idv.opengl_support import TransferFunctionTexture
 from yt_idv.scene_components.base_component import SceneComponent
+from yt_idv.scene_components.isolayers import Isolayers
 from yt_idv.scene_data.block_collection import BlockCollection
 from yt_idv.shader_objects import component_shaders
 
 
-class BlockRendering(SceneComponent):
+class BlockRendering(SceneComponent, Isolayers):
  """
  A class that renders block data. It may do this in one of several ways,
  including mesh outline. This allows us to render a single collection of
@@ -120,6 +121,9 @@ def render_gui(self, imgui, renderer, scene):
  changed = changed or _
  _ = add_popup_help(imgui, "The normal vector of the slicing plane.")
  changed = changed or _
+ elif self.render_method == "isocontours":
+ _ = self._render_isolayer_inputs(imgui)
+ changed = changed or _
 
  return changed
 
@@ -149,3 +153,5 @@ def _set_uniforms(self, scene, shader_program):
  shader_program._set_uniform("tf_log", float(self.tf_log))
  shader_program._set_uniform("slice_normal", np.array(self.slice_normal))
  shader_program._set_uniform("slice_position", np.array(self.slice_position))
+ if self.render_method == "isocontours":
+ self._set_iso_uniforms(shader_program)