Compute vector scaling correctly

Packages/vcs/vcs/VTKPlots.py

@@ -546,9 +546,9 @@ def isopened(self):
 
     def geometry(self, *args):
         if len(args) == 0:
-            return self._geometry;
+            return self._geometry
         if len(args) < 2:
-            raise TypeError("Function takes zero or two <width, height> " \
+            raise TypeError("Function takes zero or two <width, height> "
                             "or more than two arguments. Got " + len(*args))
         x = args[0]
         y = args[1]

Packages/vcs/vcs/vcsvtk/vectorpipeline.py

@@ -84,25 +84,53 @@ def _plotInternal(self):
         arrow.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
         arrow.FilledOff()
 
+        polydata = self._vtkPolyDataFilter.GetOutput()
+        vectors = polydata.GetPointData().GetVectors()
+        vectorsRangeX = vectors.GetRange(0)
+        vectorsRangeY = vectors.GetRange(1)
+        vectorsRange = []
+        vectorsRange.insert(0, vectorsRangeY[0] if (vectorsRangeX[0] > vectorsRangeY[0])
+                            else vectorsRangeX[0])
+        vectorsRange.insert(1, vectorsRangeY[1] if (vectorsRangeX[1] > vectorsRangeY[1])
+                            else vectorsRangeX[1])
+
+        scalarArray = vtk.vtkDoubleArray()
+        scalarArray.SetNumberOfComponents(1)
+        scalarArray.SetNumberOfValues(vectors.GetNumberOfTuples())
+
+        oldRange = vectorsRange[1] - vectorsRange[0]
+        oldRange = 1.0 if oldRange == 0.0 else oldRange
+
+        # New range min, max.
+        newRangeValues = [0.0, 1.0]
+
+        newRange = newRangeValues[1] - newRangeValues[0]
+
+        for i in range(0, vectors.GetNumberOfTuples()):
+            norm = vtk.vtkMath.Norm(vectors.GetTuple(i))
+            newValue = (((norm - vectorsRange[0]) * newRange) / oldRange) + newRangeValues[0]
+            scalarArray.SetValue(i, newValue)
+
+        polydata.GetPointData().SetScalars(scalarArray)
+
         glyphFilter = vtk.vtkGlyph2D()
-        glyphFilter.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
+        # glyphFilter.SetInputConnection(self._vtkPolyDataFilter.GetOutputPort())
+        glyphFilter.SetInputData(polydata)
         glyphFilter.SetInputArrayToProcess(1, 0, 0, 0, "vector")
         glyphFilter.SetSourceConnection(arrow.GetOutputPort())
         glyphFilter.SetVectorModeToUseVector()
 
         # Rotate arrows to match vector data:
         glyphFilter.OrientOn()
+        glyphFilter.ScalingOn()
 
         # Scale to vector magnitude:
-        glyphFilter.SetScaleModeToScaleByVector()
+        # NOTE: Currently we compute our own scaling factor since VTK does
+        # it by clamping the values > max to max  and values < min to min
+        # and not remap the range.
+        glyphFilter.SetScaleModeToScaleByScalar()
         glyphFilter.SetScaleFactor(scale * 2.0 * self._gm.scale)
 
-        # These are some unfortunately named methods. It does *not* clamp the
-        # scale range to [min, max], but rather remaps the range
-        # [min, max] --> [0, 1].
-        glyphFilter.ClampingOn()
-        glyphFilter.SetRange(0.01, 1.0)
-
         mapper = vtk.vtkPolyDataMapper()
 
         glyphFilter.Update()