Merge pull request #501 from Kitware/fix-mag-computation

fix(DataArray): Add magnitude range computation

Author: jourdain

Sources/Common/Core/DataArray/index.js

@@ -2,34 +2,61 @@ import macro from 'vtk.js/Sources/macro';
 import Constants from 'vtk.js/Sources/Common/Core/DataArray/Constants';
 
 const { DefaultDataType } = Constants;
-const { vtkErrorMacro } = macro;
 const TUPLE_HOLDER = [];
 
 // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
-function computeRange(values, component = 0, tuple = 1) {
-  const range = { min: Number.MAX_VALUE, max: -Number.MAX_VALUE };
+function createRangeHelper() {
+  let min = Number.MAX_VALUE;
+  let max = -Number.MAX_VALUE;
+  let count = 0;
+  let sum = 0;
+
+  return {
+    add(value) {
+      if (min > value) {
+        min = value;
+      }
+      if (max < value) {
+        max = value;
+      }
+      count++;
+      sum += value;
+    },
+    get() {
+      return { min, max, count, sum, mean: sum / count };
+    },
+    getRange() {
+      return { min, max };
+    },
+  };
+}
+
+function computeRange(values, component = 0, numberOfComponents = 1) {
+  const helper = createRangeHelper();
+  const size = values.length;
+  let value = 0;
 
   if (component < 0) {
     // Compute magnitude
-    vtkErrorMacro('vtkDataArray: Compute magnitude - NOT IMPLEMENTED');
-    return range;
+    for (let i = 0; i < size; i += numberOfComponents) {
+      value = 0;
+      for (let j = 0; j < numberOfComponents; j++) {
+        value += values[i + j] * values[i + j];
+      }
+      value **= 0.5;
+      helper.add(value);
+    }
+    return helper.getRange();
   }
 
-  const size = values.length;
-  for (let i = component; i < size; i += tuple) {
-    const value = values[i];
-    if (range.min > value) {
-      range.min = value;
-    }
-    if (range.max < value) {
-      range.max = value;
-    }
+  for (let i = component; i < size; i += numberOfComponents) {
+    helper.add(values[i]);
   }
 
-  return range;
+  return helper.getRange();
 }
 
 function ensureRangeSize(rangeArray, size = 0) {
@@ -55,6 +82,7 @@ function getDataType(typedArray) {
 export const STATIC = {
   computeRange,
   getDataType,
+  createRangeHelper,
 };
 
 // ----------------------------------------------------------------------------
@@ -93,7 +121,7 @@ function vtkDataArray(publicAPI, model) {
 
   publicAPI.getData = () => model.values;
 
-  publicAPI.getRange = (componentIndex = 0) => {
+  publicAPI.getRange = (componentIndex = -1) => {
     const rangeIdx =
       componentIndex < 0 ? model.numberOfComponents : componentIndex;
     let range = null;

Sources/Interaction/Widgets/PiecewiseGaussianWidget/index.js

@@ -127,6 +127,30 @@ function computeOpacities(gaussians, sampling = 256) {
 
 // ----------------------------------------------------------------------------
 
+function applyGaussianToPiecewiseFunction(
+  gaussians,
+  sampling,
+  rangeToUse,
+  piecewiseFunction
+) {
+  const opacities = computeOpacities(gaussians, sampling);
+  const nodes = [];
+  const delta = (rangeToUse[1] - rangeToUse[0]) / (opacities.length - 1);
+  const midpoint = 0.5;
+  const sharpness = 0;
+  for (let index = 0; index < opacities.length; index++) {
+    const x = rangeToUse[0] + delta * index;
+    const y = opacities[index];
+    nodes.push({ x, y, midpoint, sharpness });
+  }
+
+  piecewiseFunction.removeAllPoints();
+  piecewiseFunction.set({ nodes }, true);
+  piecewiseFunction.sortAndUpdateRange();
+}
+
+// ----------------------------------------------------------------------------
+
 function drawChart(
   ctx,
   area,
@@ -332,12 +356,13 @@ function listenerSelector(condition, ok, ko) {
 // ----------------------------------------------------------------------------
 
 export const STATIC = {
+  applyGaussianToPiecewiseFunction,
   computeOpacities,
+  createListener,
   drawChart,
-  normalizeCoordinates,
   findGaussian,
-  createListener,
   listenerSelector,
+  normalizeCoordinates,
 };
 
 // ----------------------------------------------------------------------------

Sources/macro.js

@@ -886,6 +886,7 @@ export function debounce(func, wait, immediate) {
 //  getProxySection() => List of properties for UI generation
 // ----------------------------------------------------------------------------
 let nextProxyId = 1;
+const ROOT_GROUP_NAME = '__root__';
 
 export function proxy(publicAPI, model, sectionName, uiDescription = []) {
   const parentDelete = publicAPI.delete;
@@ -894,9 +895,30 @@ export function proxy(publicAPI, model, sectionName, uiDescription = []) {
   model.proxyId = `${nextProxyId++}`;
   publicAPI.getProxyId = () => model.proxyId;
 
+  // group properties
+  const groupChildrenNames = {};
+  function registerProperties(descriptionList, currentGroupName) {
+    if (!groupChildrenNames[currentGroupName]) {
+      groupChildrenNames[currentGroupName] = [];
+    }
+    const childrenNames = groupChildrenNames[currentGroupName];
+
+    for (let i = 0; i < descriptionList.length; i++) {
+      childrenNames.push(descriptionList[i].name);
+
+      if (descriptionList[i].children && descriptionList[i].children.length) {
+        registerProperties(
+          descriptionList[i].children,
+          descriptionList[i].name
+        );
+      }
+    }
+  }
+  registerProperties(uiDescription, ROOT_GROUP_NAME);
+
   // list
-  const propertyNames = uiDescription.map((p) => p.name);
-  publicAPI.listProxyProperties = () => propertyNames;
+  publicAPI.listProxyProperties = (gName = ROOT_GROUP_NAME) =>
+    groupChildrenNames[gName];
 
   // ui handling
   const ui = uiDescription.map((i) => Object.assign({}, i));
@@ -981,13 +1003,20 @@ export function proxy(publicAPI, model, sectionName, uiDescription = []) {
   };
 
   // extract values
-  function getProperties() {
+  function getProperties(groupName = ROOT_GROUP_NAME) {
     const values = [];
     const id = model.proxyId;
+    const propertyNames = publicAPI.listProxyProperties(groupName) || [];
     for (let i = 0; i < propertyNames.length; i++) {
       const name = propertyNames[i];
-      const value = publicAPI[`get${capitalize(name)}`]();
-      values.push({ id, name, value });
+      const method = publicAPI[`get${capitalize(name)}`];
+      const value = method ? method() : undefined;
+      const prop = { id, name, value };
+      const children = getProperties(name);
+      if (children.length) {
+        prop.children = children;
+      }
+      values.push(prop);
     }
     return values;
   }