Exemplo n.º 1
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(
         self, module_manager,
         vtk.vtkGlyph2D(), 'Processing.',
         ('vtkDataSet', 'vtkPolyData'), ('vtkPolyData',),
         replaceDoc=True,
         inputFunctions=None, outputFunctions=None)
Exemplo n.º 2
0
    def render(self):
        """
        Glyphs the input polydata points with the requested shape and
        replaces the input polydata with glyphed output polydata with
        colored cells
        """

        self.glyph = vtk.vtkPolyData()
        pts = vtk.vtkPoints()
        pts.Allocate(6, 6)
        self.glyph.SetPoints(pts)
        verts = vtk.vtkCellArray()
        verts.Allocate(verts.EstimateSize(1, 1), 1)
        self.glyph.SetVerts(verts)
        lines = vtk.vtkCellArray()
        lines.Allocate(lines.EstimateSize(4, 2), 2)
        self.glyph.SetLines(lines)
        polys = vtk.vtkCellArray()
        polys.Allocate(polys.EstimateSize(1, 4), 4)
        self.glyph.SetPolys(polys)

        self.paint()
        self.transform_glyph()

        self.glyph2D = vtk.vtkGlyph2D()
        self.glyph2D.OrientOff()
        self.glyph2D.ScalingOff()
        self.glyph2D.SetScaleModeToDataScalingOff()
        self.glyph2D.SetInputData(self.patternPolyData)
        self.glyph2D.SetSourceData(self.glyph)
        self.glyph2D.Update()
        self.patternPolyData.DeepCopy(self.glyph2D.GetOutput())
Exemplo n.º 3
0
 def __init__(self, module_manager):
     SimpleVTKClassModuleBase.__init__(self,
                                       module_manager,
                                       vtk.vtkGlyph2D(),
                                       'Processing.',
                                       ('vtkDataSet', 'vtkPolyData'),
                                       ('vtkPolyData', ),
                                       replaceDoc=True,
                                       inputFunctions=None,
                                       outputFunctions=None)
Exemplo n.º 4
0
def main():
    colors = vtk.vtkNamedColors()

    points = vtk.vtkPoints()
    points.InsertNextPoint(0, 0, 0)
    points.InsertNextPoint(1, 1, 0)
    points.InsertNextPoint(2, 2, 0)

    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)

    # Create anything you want here, we will use a polygon for the demo.
    polygonSource = vtk.vtkRegularPolygonSource()  # default is 6 sides

    glyph2D = vtk.vtkGlyph2D()
    glyph2D.SetSourceConnection(polygonSource.GetOutputPort())
    glyph2D.SetInputData(polydata)
    glyph2D.Update()

    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(glyph2D.GetOutputPort())
    mapper.Update()

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)
    actor.GetProperty().SetColor(colors.GetColor3d('Salmon'))

    # Visualize
    renderer = vtk.vtkRenderer()
    renderWindow = vtk.vtkRenderWindow()
    renderWindow.AddRenderer(renderer)
    renderWindowInteractor = vtk.vtkRenderWindowInteractor()
    renderWindowInteractor.SetRenderWindow(renderWindow)

    renderer.AddActor(actor)
    renderer.SetBackground(colors.GetColor3d('SlateGray'))

    style = vtk.vtkInteractorStyleImage()
    renderWindowInteractor.SetInteractorStyle(style)

    renderWindow.SetWindowName('Glyph2D')
    renderWindow.Render()
    renderWindowInteractor.Start()
Exemplo n.º 5
0
    def __init__(self, parent = None):
        super(VTKFrame, self).__init__(parent)

        self.vtkWidget = QVTKRenderWindowInteractor(self)
        vl = QtGui.QVBoxLayout(self)
        vl.addWidget(self.vtkWidget)
        vl.setContentsMargins(0, 0, 0, 0)
 
        self.ren = vtk.vtkRenderer()
        self.ren.SetBackground(0.1, 0.2, 0.4)
        self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()
 
        points = vtk.vtkPoints()
        points.InsertNextPoint(0, 0, 0)
        points.InsertNextPoint(1, 1, 0)
        points.InsertNextPoint(2, 2, 0)

        polyData = vtk.vtkPolyData()
        polyData.SetPoints(points)

        # Create anything you want here, we will use a polygon for the demo.
        polygonSource = vtk.vtkRegularPolygonSource() #default is 6 sides
        glyph2D = vtk.vtkGlyph2D()
        glyph2D.SetSourceConnection(polygonSource.GetOutputPort())
        glyph2D.SetInput(polyData)
        glyph2D.Update()
 
        # Create a mapper
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(glyph2D.GetOutputPort())
 
        # Create an actor
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)
 
        self.ren.AddActor(actor)
        self.ren.ResetCamera()

        self._initialized = False
Exemplo n.º 6
0
    def __init__(self, parent=None):
        super(VTKFrame, self).__init__(parent)

        self.vtkWidget = QVTKRenderWindowInteractor(self)
        vl = QtGui.QVBoxLayout(self)
        vl.addWidget(self.vtkWidget)
        vl.setContentsMargins(0, 0, 0, 0)

        self.ren = vtk.vtkRenderer()
        self.ren.SetBackground(0.1, 0.2, 0.4)
        self.vtkWidget.GetRenderWindow().AddRenderer(self.ren)
        self.iren = self.vtkWidget.GetRenderWindow().GetInteractor()

        points = vtk.vtkPoints()
        points.InsertNextPoint(0, 0, 0)
        points.InsertNextPoint(1, 1, 0)
        points.InsertNextPoint(2, 2, 0)

        polyData = vtk.vtkPolyData()
        polyData.SetPoints(points)

        # Create anything you want here, we will use a polygon for the demo.
        polygonSource = vtk.vtkRegularPolygonSource()  #default is 6 sides
        glyph2D = vtk.vtkGlyph2D()
        glyph2D.SetSourceConnection(polygonSource.GetOutputPort())
        glyph2D.SetInput(polyData)
        glyph2D.Update()

        # Create a mapper
        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(glyph2D.GetOutputPort())

        # Create an actor
        actor = vtk.vtkActor()
        actor.SetMapper(mapper)

        self.ren.AddActor(actor)
        self.ren.ResetCamera()

        self._initialized = False
    def __init__(self, curveNode, sliceNode):
        VTKObservationMixin.__init__(self)

        self.glyphScale = 0.5

        self.intersectionPoints_XY = vtk.vtkPolyData()

        self.glyphSource = slicer.vtkMarkupsGlyphSource2D()
        self.glyphSource.SetGlyphType(
            slicer.vtkMarkupsGlyphSource2D.GlyphCrossDot)

        self.glypher = vtk.vtkGlyph2D()
        self.glypher.SetInputData(self.intersectionPoints_XY)
        self.glypher.SetScaleFactor(1.0)
        self.glypher.SetSourceConnection(self.glyphSource.GetOutputPort())

        self.mapper = vtk.vtkPolyDataMapper2D()
        self.mapper.SetInputConnection(self.glypher.GetOutputPort())
        self.mapper.ScalarVisibilityOff()
        mapperCoordinate = vtk.vtkCoordinate()
        mapperCoordinate.SetCoordinateSystemToDisplay()
        self.mapper.SetTransformCoordinate(mapperCoordinate)

        self.property = vtk.vtkProperty2D()
        self.property.SetColor(0.4, 1.0, 1.0)
        self.property.SetPointSize(3.)
        self.property.SetLineWidth(3.)
        self.property.SetOpacity(1.)

        self.actor = vtk.vtkActor2D()
        self.actor.SetMapper(self.mapper)
        self.actor.SetProperty(self.property)

        self.curveNode = curveNode
        self.sliceNode = sliceNode

        self.visibility = True
Exemplo n.º 8
0
def prepMarker(renWin,marker,cmap=None):
  n=prepPrimitive(marker)
  if n==0:
    return []
  actors=[]
  for i in range(n):
    g = vtk.vtkGlyph2D()
    markers = vtk.vtkPolyData()
    x = marker.x[i]
    y = marker.y[i]
    c = marker.color[i]
    N = max(len(x),len(y))
    for a in [x,y]:
      while len(a)<n:
        a.append(a[-1])
    pts = vtk.vtkPoints()
    for j in range(N):
      pts.InsertNextPoint(x[j],y[j],0.)
    geo,pts = project(pts,marker.projection,marker.worldcoordinate)
    markers.SetPoints(pts)

    #  Type
    ## Ok at this point generates the source for glpyh
    gs, pd = prepGlyph(g, marker, index=i)
    g.SetInputData(markers)

    a = vtk.vtkActor()
    m = vtk.vtkPolyDataMapper()
    m.SetInputConnection(g.GetOutputPort())
    m.Update()
    a.SetMapper(m)
    p = a.GetProperty()
    setMarkerColor(p, marker, c, cmap)
    actors.append((g, gs, pd, a, geo))

  return actors
Exemplo n.º 9
0
    def plot(self, data1, data2, tmpl, gm, grid, transform):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        geo = None  # to make flake8 happy
        returned = {}
        taxis = data1.getTime()
        if data1.ndim > 2:
            zaxis = data1.getAxis(-3)
        else:
            zaxis = None

        # Ok get3 only the last 2 dims
        data1 = self._context().trimData2D(data1)
        data2 = self._context().trimData2D(data2)

        gridGenDict = vcs2vtk.genGridOnPoints(data1, gm, deep=False, grid=grid,
                                              geo=transform)
        for k in ['vtk_backend_grid', 'xm', 'xM', 'ym', 'yM', 'continents',
                  'wrap', 'geo']:
            exec("%s = gridGenDict['%s']" % (k, k))
        grid = gridGenDict['vtk_backend_grid']
        self._dataWrapModulo = gridGenDict['wrap']

        returned["vtk_backend_grid"] = grid
        returned["vtk_backend_geo"] = geo
        missingMapper = vcs2vtk.putMaskOnVTKGrid(data1, grid, None, False,
                                                 deep=False)

        # None/False are for color and cellData
        # (sent to vcs2vtk.putMaskOnVTKGrid)
        returned["vtk_backend_missing_mapper"] = (missingMapper, None, False)

        w = vcs2vtk.generateVectorArray(data1, data2, grid)

        grid.GetPointData().AddArray(w)

        # Vector attempt
        l = gm.line
        if l is None:
            l = "default"
        try:
            l = vcs.getline(l)
            lwidth = l.width[0]  # noqa
            lcolor = l.color[0]
            lstyle = l.type[0]  # noqa
        except:
            lstyle = "solid"  # noqa
            lwidth = 1.  # noqa
            lcolor = 0
        if gm.linewidth is not None:
            lwidth = gm.linewidth  # noqa
        if gm.linecolor is not None:
            lcolor = gm.linecolor

        arrow = vtk.vtkGlyphSource2D()
        arrow.SetGlyphTypeToArrow()
        arrow.FilledOff()

        glyphFilter = vtk.vtkGlyph2D()
        glyphFilter.SetInputData(grid)
        glyphFilter.SetInputArrayToProcess(1, 0, 0, 0, "vectors")
        glyphFilter.SetSourceConnection(arrow.GetOutputPort())
        glyphFilter.SetVectorModeToUseVector()

        # Rotate arrows to match vector data:
        glyphFilter.OrientOn()

        # Scale to vector magnitude:
        glyphFilter.SetScaleModeToScaleByVector()
        glyphFilter.SetScaleFactor(2. * 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()
        mapper.SetInputConnection(glyphFilter.GetOutputPort())
        act = vtk.vtkActor()
        act.SetMapper(mapper)

        cmap = self._context().canvas.getcolormapname()
        cmap = vcs.elements["colormap"][cmap]
        r, g, b = cmap.index[lcolor]
        act.GetProperty().SetColor(r / 100., g / 100., b / 100.)

        x1, x2, y1, y2 = vcs.utils.getworldcoordinates(gm, data1.getAxis(-1),
                                                       data1.getAxis(-2))

        act = vcs2vtk.doWrap(act, [x1, x2, y1, y2], self._dataWrapModulo)
        self._context().fitToViewport(act, [tmpl.data.x1, tmpl.data.x2,
                                            tmpl.data.y1, tmpl.data.y2],
                                      [x1, x2, y1, y2],
                                      priority=tmpl.data.priority,
                                      create_renderer=True)

        returned.update(
            self._context().renderTemplate(tmpl, data1, gm, taxis, zaxis))

        if self._context().canvas._continents is None:
            continents = False
        if continents:
            projection = vcs.elements["projection"][gm.projection]
            self._context().plotContinents(x1, x2, y1, y2, projection,
                                           self._dataWrapModulo, tmpl)

        returned["vtk_backend_actors"] = [[act, [x1, x2, y1, y2]]]
        returned["vtk_backend_glyphfilters"] = [glyphFilter]
        returned["vtk_backend_luts"] = [[None, None]]

        return returned
Exemplo n.º 10
0
    def _plotInternal(self):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        projection = vcs.elements["projection"][self._gm.projection]
        taxis = self._originalData1.getTime()

        if self._originalData1.ndim > 2:
            zaxis = self._originalData1.getAxis(-3)
        else:
            zaxis = None

        # Streamline color
        if (not self._gm.coloredbyvector):
            ln_tmp = self._gm.linetype
            if ln_tmp is None:
                ln_tmp = "default"
            try:
                ln_tmp = vcs.getline(ln_tmp)
                lwidth = ln_tmp.width[0]  # noqa
                lcolor = ln_tmp.color[0]
                lstyle = ln_tmp.type[0]  # noqa
            except Exception:
                lstyle = "solid"  # noqa
                lwidth = 1.  # noqa
                lcolor = [0., 0., 0., 100.]
            if self._gm.linewidth is not None:
                lwidth = self._gm.linewidth  # noqa
            if self._gm.linecolor is not None:
                lcolor = self._gm.linecolor

        self._vtkPolyDataFilter.Update()
        polydata = self._vtkPolyDataFilter.GetOutput()

        dataLength = polydata.GetLength()

        if (not self._gm.evenlyspaced):
            # generate random seeds in a circle centered in the center of
            # the bounding box for the data.

            # by default vtkPointSource uses a global random source in vtkMath which is
            # seeded only once. It makes more sense to seed a random sequence each time you draw
            # the streamline plot.
            pointSequence = vtk.vtkMinimalStandardRandomSequence()
            pointSequence.SetSeedOnly(1177)  # replicate the seed from vtkMath

            seed = vtk.vtkPointSource()
            seed.SetNumberOfPoints(self._gm.numberofseeds)
            seed.SetCenter(polydata.GetCenter())
            seed.SetRadius(dataLength / 2.0)
            seed.SetRandomSequence(pointSequence)
            seed.Update()
            seedData = seed.GetOutput()

            # project all points to Z = 0 plane
            points = seedData.GetPoints()
            for i in range(0, points.GetNumberOfPoints()):
                p = list(points.GetPoint(i))
                p[2] = 0
                points.SetPoint(i, p)

        if (self._gm.integratortype == 0):
            integrator = vtk.vtkRungeKutta2()
        elif (self._gm.integratortype == 1):
            integrator = vtk.vtkRungeKutta4()
        else:
            if (self._gm.evenlyspaced):
                warnings.warn(
                    "You cannot use RungeKutta45 for evenly spaced streamlines."
                    "Using RungeKutta4 instead")
                integrator = vtk.vtkRungeKutta4()
            else:
                integrator = vtk.vtkRungeKutta45()

        if (self._gm.evenlyspaced):
            streamer = vtk.vtkEvenlySpacedStreamlines2D()
            streamer.SetStartPosition(self._gm.startseed)
            streamer.SetSeparatingDistance(self._gm.separatingdistance)
            streamer.SetSeparatingDistanceRatio(
                self._gm.separatingdistanceratio)
            streamer.SetClosedLoopMaximumDistance(
                self._gm.closedloopmaximumdistance)
        else:
            # integrate streamlines on normalized vector so that
            # IntegrationTime stores distance
            streamer = vtk.vtkStreamTracer()
            streamer.SetSourceData(seedData)
            streamer.SetIntegrationDirection(self._gm.integrationdirection)
            streamer.SetMinimumIntegrationStep(self._gm.minimumsteplength)
            streamer.SetMaximumIntegrationStep(self._gm.maximumsteplength)
            streamer.SetMaximumError(self._gm.maximumerror)
            streamer.SetMaximumPropagation(dataLength *
                                           self._gm.maximumstreamlinelength)

        streamer.SetInputData(polydata)
        streamer.SetInputArrayToProcess(0, 0, 0, 0, "vector")
        streamer.SetIntegrationStepUnit(self._gm.integrationstepunit)
        streamer.SetInitialIntegrationStep(self._gm.initialsteplength)
        streamer.SetMaximumNumberOfSteps(self._gm.maximumsteps)
        streamer.SetTerminalSpeed(self._gm.terminalspeed)
        streamer.SetIntegrator(integrator)

        # add arc_length to streamlines
        arcLengthFilter = vtk.vtkAppendArcLength()
        arcLengthFilter.SetInputConnection(streamer.GetOutputPort())

        arcLengthFilter.Update()
        streamlines = arcLengthFilter.GetOutput()

        # glyph seed points
        contour = vtk.vtkContourFilter()
        contour.SetInputConnection(arcLengthFilter.GetOutputPort())
        contour.SetValue(0, 0.001)
        if (streamlines.GetNumberOfPoints()):
            r = streamlines.GetPointData().GetArray("arc_length").GetRange()
            numberofglyphsoneside = self._gm.numberofglyphs // 2
            for i in range(1, numberofglyphsoneside):
                contour.SetValue(i, r[1] / numberofglyphsoneside * i)
        else:
            warnings.warn(
                "No streamlines created. "
                "The 'startseed' parameter needs to be inside the domain and "
                "not over masked data.")
        contour.SetInputArrayToProcess(0, 0, 0, 0, "arc_length")

        # arrow glyph source
        glyph2DSource = vtk.vtkGlyphSource2D()
        glyph2DSource.SetGlyphTypeToTriangle()
        glyph2DSource.SetRotationAngle(-90)
        glyph2DSource.SetFilled(self._gm.filledglyph)

        # arrow glyph adjustment
        transform = vtk.vtkTransform()
        transform.Scale(1., self._gm.glyphbasefactor, 1.)
        transformFilter = vtk.vtkTransformFilter()
        transformFilter.SetInputConnection(glyph2DSource.GetOutputPort())
        transformFilter.SetTransform(transform)
        transformFilter.Update()
        glyphLength = transformFilter.GetOutput().GetLength()

        #  drawing the glyphs at the seed points
        glyph = vtk.vtkGlyph2D()
        glyph.SetInputConnection(contour.GetOutputPort())
        glyph.SetInputArrayToProcess(1, 0, 0, 0, "vector")
        glyph.SetSourceData(transformFilter.GetOutput())
        glyph.SetScaleModeToDataScalingOff()
        glyph.SetScaleFactor(dataLength * self._gm.glyphscalefactor /
                             glyphLength)
        glyph.SetColorModeToColorByVector()

        glyphMapper = vtk.vtkPolyDataMapper()
        glyphMapper.SetInputConnection(glyph.GetOutputPort())
        glyphActor = vtk.vtkActor()
        glyphActor.SetMapper(glyphMapper)

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(streamer.GetOutputPort())
        act = vtk.vtkActor()
        act.SetMapper(mapper)

        # color the streamlines and glyphs
        cmap = self.getColorMap()
        if (self._gm.coloredbyvector):
            numLevels = len(self._contourLevels) - 1
            while len(self._contourColors) < numLevels:
                self._contourColors.append(self._contourColors[-1])

            lut = vtk.vtkLookupTable()
            lut.SetNumberOfTableValues(numLevels)
            for i in range(numLevels):
                r, g, b, a = self.getColorIndexOrRGBA(cmap,
                                                      self._contourColors[i])
                lut.SetTableValue(i, r / 100., g / 100., b / 100., a / 100.)
            lut.SetVectorModeToMagnitude()
            if numpy.allclose(self._contourLevels[0], -1.e20):
                lmn = self._vectorRange[0]
            else:
                lmn = self._contourLevels[0][0]
            if numpy.allclose(self._contourLevels[-1], 1.e20):
                lmx = self._vectorRange[1]
            else:
                lmx = self._contourLevels[-1][-1]
            lut.SetRange(lmn, lmx)

            mapper.ScalarVisibilityOn()
            mapper.SetLookupTable(lut)
            mapper.UseLookupTableScalarRangeOn()
            mapper.SetScalarModeToUsePointFieldData()
            mapper.SelectColorArray("vector")

            glyphMapper.ScalarVisibilityOn()
            glyphMapper.SetLookupTable(lut)
            glyphMapper.UseLookupTableScalarRangeOn()
            glyphMapper.SetScalarModeToUsePointFieldData()
            glyphMapper.SelectColorArray("VectorMagnitude")
        else:
            mapper.ScalarVisibilityOff()
            glyphMapper.ScalarVisibilityOff()
            if isinstance(lcolor, (list, tuple)):
                r, g, b, a = lcolor
            else:
                r, g, b, a = cmap.index[lcolor]
            act.GetProperty().SetColor(r / 100., g / 100., b / 100.)
            glyphActor.GetProperty().SetColor(r / 100., g / 100., b / 100.)

        plotting_dataset_bounds = self.getPlottingBounds()
        vp = self._resultDict.get('ratio_autot_viewport', [
            self._template.data.x1, self._template.data.x2,
            self._template.data.y1, self._template.data.y2
        ])

        dataset_renderer, xScale, yScale = self._context().fitToViewport(
            act,
            vp,
            wc=plotting_dataset_bounds,
            geoBounds=self._vtkDataSetBoundsNoMask,
            geo=self._vtkGeoTransform,
            priority=self._template.data.priority,
            create_renderer=True)
        glyph_renderer, xScale, yScale = self._context().fitToViewport(
            glyphActor,
            vp,
            wc=plotting_dataset_bounds,
            geoBounds=self._vtkDataSetBoundsNoMask,
            geo=self._vtkGeoTransform,
            priority=self._template.data.priority,
            create_renderer=False)

        kwargs = {
            'vtk_backend_grid': self._vtkDataSet,
            'dataset_bounds': self._vtkDataSetBounds,
            'plotting_dataset_bounds': plotting_dataset_bounds,
            "vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask,
            'vtk_backend_geo': self._vtkGeoTransform
        }
        if ('ratio_autot_viewport' in self._resultDict):
            kwargs["ratio_autot_viewport"] = vp
        self._resultDict.update(self._context().renderTemplate(
            self._template, self._data1, self._gm, taxis, zaxis, **kwargs))
        if (self._gm.coloredbyvector):
            self._resultDict.update(self._context().renderColorBar(
                self._template, self._contourLevels, self._contourColors, None,
                self.getColorMap()))

        if self._context().canvas._continents is None:
            self._useContinents = False
        if self._useContinents:
            continents_renderer, xScale, yScale = self._context(
            ).plotContinents(plotting_dataset_bounds, projection,
                             self._dataWrapModulo, vp,
                             self._template.data.priority, **kwargs)
        self._resultDict["vtk_backend_actors"] = [[
            act, plotting_dataset_bounds
        ]]
        self._resultDict["vtk_backend_luts"] = [[None, None]]
Exemplo n.º 11
0
def prepMarker(renWin,ren,marker,cmap=None):
  n=prepPrimitive(marker)
  if n==0:
    return
  for i in range(n):
    ## Creates the glyph
    g = vtk.vtkGlyph2D()
    markers = vtk.vtkPolyData()
    x = marker.x[i]
    y=marker.y[i]
    c=marker.color[i]
    s=marker.size[i]/float(max(marker.worldcoordinate))*10.
    t=marker.type[i]
    N = max(len(x),len(y))
    for a in [x,y]:
      while len(a)<n:
        a.append(a[-1])
    pts = vtk.vtkPoints()
    for j in range(N):
      pts.InsertNextPoint(x[j],y[j],0.)
    markers.SetPoints(pts)

    #  Type
    ## Ok at this point generates the source for glpyh
    gs = vtk.vtkGlyphSource2D()
    pd = None
    if t=='dot':
      gs.SetGlyphTypeToCircle()
      gs.FilledOn()
    elif t=='circle':
      gs.SetGlyphTypeToCircle()
      gs.FilledOff()
    elif t=='plus':
      gs.SetGlyphTypeToCross()
      gs.FilledOff()
    elif t=='cross':
      gs.SetGlyphTypeToCross()
      gs.SetRotationAngle(45)
      gs.FilledOff()
    elif t[:6]=='square':
      gs.SetGlyphTypeToSquare()
      gs.FilledOff()
    elif t[:7]=='diamond':
      gs.SetGlyphTypeToDiamond()
      gs.FilledOff()
    elif t[:8]=='triangle':
      gs.SetGlyphTypeToTriangle()
      if t[9]=="d":
        gs.SetRotationAngle(180)
      elif t[9]=="l":
        gs.SetRotationAngle(90)
      elif t[9]=="r":
        gs.SetRotationAngle(-90)
      elif t[9]=="u":
        gs.SetRotationAngle(0)
    elif t == "hurricane":
      s =s/100.
      ds = vtk.vtkDiskSource()
      ds.SetInnerRadius(.55*s)
      ds.SetOuterRadius(1.01*s)
      ds.SetCircumferentialResolution(90)
      ds.SetRadialResolution(30)
      gf = vtk.vtkGeometryFilter()
      gf.SetInputConnection(ds.GetOutputPort())
      gf.Update()
      pd1 = gf.GetOutput()
      apd = vtk.vtkAppendPolyData()
      apd.AddInputData(pd1)
      pts = vtk.vtkPoints()
      pd = vtk.vtkPolyData()
      polygons = vtk.vtkCellArray()
      add_angle = numpy.pi/360.
      coords = []
      angle1 = .6*numpy.pi
      angle2 = .88*numpy.pi
      while angle1<=angle2:
        coords.append([s*2+2*s*numpy.cos(angle1),2*s*numpy.sin(angle1)])
        angle1+=add_angle
      angle1=.79*numpy.pi
      angle2=.6*numpy.pi
      while angle1>=angle2:
        coords.append([s*2.25+s*4*numpy.cos(angle1),-s*2+s*4*numpy.sin(angle1)])
        angle1-=add_angle
      poly = genPoly(coords,pts,filled=True)
      polygons.InsertNextCell(poly)
      coords=[]
      angle1 = 1.6*numpy.pi
      angle2 = 1.9*numpy.pi
      while angle1 <= angle2:
        coords.append( [- s*2 + s*2*numpy.cos(angle1),s*2*numpy.sin(angle1)])
        angle1 += add_angle
      angle1 = 1.8*numpy.pi
      angle2 = 1.6*numpy.pi
      while angle1 >= angle2:
        coords.append( [- s*2.27 + s*4*numpy.cos(angle1), s*2 + s*4*numpy.sin(angle1)])
        angle1 -= add_angle
      poly = genPoly(coords,pts,filled=True)
      polygons.InsertNextCell(poly)
      pd.SetPoints(pts)
      pd.SetPolys(polygons)
      apd.AddInputData(pd)
      apd.Update()
      g.SetSourceData(apd.GetOutput())
    elif t in ["w%.2i" % x for x in range(203)]:
      ## WMO marker
      params = wmo[t]
      pts = vtk.vtkPoints()
      pd = vtk.vtkPolyData()
      polys = vtk.vtkCellArray()
      lines = vtk.vtkCellArray()
      #Lines first
      for l in params["line"]:
        coords = numpy.array(zip(*l))*s/30.
        line = genPoly(coords.tolist(),pts,filled=False)
        lines.InsertNextCell(line)
      for l in params["poly"]:
        coords = numpy.array(zip(*l))*s/30.
        line = genPoly(coords.tolist(),pts,filled=True)
        polys.InsertNextCell(line)
      pd.SetPoints(pts)
      pd.SetPolys(polys)
      pd.SetLines(lines)
      g.SetSourceData(pd)
    else:
      warnings.warn("unknown marker type: %s, using dot" % t)
      gs.SetGlyphTypeToCircle()
      gs.FilledOn()
    if t[-5:]=="_fill":
      gs.FilledOn()
    gs.SetScale(s)
    gs.Update()


    if pd is None:
      g.SetSourceConnection(gs.GetOutputPort())
    g.SetInputData(markers)

    a = vtk.vtkActor()
    m = vtk.vtkPolyDataMapper()
    m.SetInputConnection(g.GetOutputPort())
    m.Update()
    a.SetMapper(m)
    p = a.GetProperty()
    #Color
    if cmap is None:
      if marker.colormap is not None:
        cmap = marker.colormap
      else:
        cmap = 'default'
    if isinstance(cmap,str):
      cmap = vcs.elements["colormap"][cmap]
    color = cmap.index[c]
    p.SetColor([C/100. for C in color])
    ren.AddActor(a)
    fitToViewport(a,ren,marker.viewport,marker.worldcoordinate)
  return 
Exemplo n.º 12
0
def prepMarker(renWin,marker,cmap=None):
  n=prepPrimitive(marker)
  if n==0:
    return
  actors=[]
  for i in range(n):
    ## Creates the glyph
    g = vtk.vtkGlyph2D()
    markers = vtk.vtkPolyData()
    x = marker.x[i]
    y=marker.y[i]
    c=marker.color[i]
    s=marker.size[i]*.5
    t=marker.type[i]
    N = max(len(x),len(y))
    for a in [x,y]:
      while len(a)<n:
        a.append(a[-1])
    pts = vtk.vtkPoints()
    geo,pts = project(pts,marker.projection,marker.worldcoordinate)
    for j in range(N):
      pts.InsertNextPoint(x[j],y[j],0.)
    markers.SetPoints(pts)

    #  Type
    ## Ok at this point generates the source for glpyh
    gs = vtk.vtkGlyphSource2D()
    pd = None
    if t=='dot':
      gs.SetGlyphTypeToCircle()
      gs.FilledOn()
    elif t=='circle':
      gs.SetGlyphTypeToCircle()
      gs.FilledOff()
    elif t=='plus':
      gs.SetGlyphTypeToCross()
      gs.FilledOff()
    elif t=='cross':
      gs.SetGlyphTypeToCross()
      gs.SetRotationAngle(45)
      gs.FilledOff()
    elif t[:6]=='square':
      gs.SetGlyphTypeToSquare()
      gs.FilledOff()
    elif t[:7]=='diamond':
      gs.SetGlyphTypeToDiamond()
      gs.FilledOff()
    elif t[:8]=='triangle':
      gs.SetGlyphTypeToTriangle()
      gs.FilledOff()
      if t[9]=="d":
        gs.SetRotationAngle(180)
      elif t[9]=="l":
        gs.SetRotationAngle(90)
      elif t[9]=="r":
        gs.SetRotationAngle(-90)
      elif t[9]=="u":
        gs.SetRotationAngle(0)
    elif t == "hurricane":
      s =s/5.
      ds = vtk.vtkDiskSource()
      ds.SetInnerRadius(.55*s)
      ds.SetOuterRadius(1.01*s)
      ds.SetCircumferentialResolution(90)
      ds.SetRadialResolution(30)
      gf = vtk.vtkGeometryFilter()
      gf.SetInputConnection(ds.GetOutputPort())
      gf.Update()
      pd1 = gf.GetOutput()
      apd = vtk.vtkAppendPolyData()
      apd.AddInputData(pd1)
      pts = vtk.vtkPoints()
      pd = vtk.vtkPolyData()
      polygons = vtk.vtkCellArray()
      add_angle = numpy.pi/360.
      coords = []
      angle1 = .6*numpy.pi
      angle2 = .88*numpy.pi
      while angle1<=angle2:
        coords.append([s*2+2*s*numpy.cos(angle1),2*s*numpy.sin(angle1)])
        angle1+=add_angle
      angle1=.79*numpy.pi
      angle2=.6*numpy.pi
      while angle1>=angle2:
        coords.append([s*2.25+s*4*numpy.cos(angle1),-s*2+s*4*numpy.sin(angle1)])
        angle1-=add_angle
      poly = genPoly(coords,pts,filled=True)
      polygons.InsertNextCell(poly)
      coords=[]
      angle1 = 1.6*numpy.pi
      angle2 = 1.9*numpy.pi
      while angle1 <= angle2:
        coords.append( [- s*2 + s*2*numpy.cos(angle1),s*2*numpy.sin(angle1)])
        angle1 += add_angle
      angle1 = 1.8*numpy.pi
      angle2 = 1.6*numpy.pi
      while angle1 >= angle2:
        coords.append( [- s*2.27 + s*4*numpy.cos(angle1), s*2 + s*4*numpy.sin(angle1)])
        angle1 -= add_angle
      poly = genPoly(coords,pts,filled=True)
      polygons.InsertNextCell(poly)
      pd.SetPoints(pts)
      pd.SetPolys(polygons)
      apd.AddInputData(pd)
      apd.Update()
      g.SetSourceData(apd.GetOutput())
    elif t[:4] == "star":
      np = 5
      points = starPoints(.001 * s, 0, 0, np)

      pts = vtk.vtkPoints()
      # Add all perimeter points
      for point in points:
        pts.InsertNextPoint((point[0], point[1], 0))

      center_id = len(points)

      # Add center point
      pts.InsertNextPoint((0,0,0))

      polygons = vtk.vtkCellArray()
      for ind in range(0, np*2, 2):
        poly = vtk.vtkPolygon()
        pid = poly.GetPointIds()
        pid.SetNumberOfIds(4)
        pid.SetId(0, ind)
        pid.SetId(1, (ind - 1) % len(points))
        pid.SetId(2, center_id)
        pid.SetId(3, (ind + 1) % len(points))
        polygons.InsertNextCell(poly)

      pd = vtk.vtkPolyData()

      pd.SetPoints(pts)
      pd.SetPolys(polygons)

      g.SetSourceData(pd)
    elif t in ["w%.2i" % x for x in range(203)]:
      ## WMO marker
      params = wmo[t]
      pts = vtk.vtkPoints()
      pd = vtk.vtkPolyData()
      polys = vtk.vtkCellArray()
      lines = vtk.vtkCellArray()
      s*=3
      #Lines first
      for l in params["line"]:
        coords = numpy.array(zip(*l))*s/30.
        line = genPoly(coords.tolist(),pts,filled=False)
        lines.InsertNextCell(line)
      for l in params["poly"]:
        coords = numpy.array(zip(*l))*s/30.
        line = genPoly(coords.tolist(),pts,filled=True)
        polys.InsertNextCell(line)
      geo,pts = project(pts,marker.projection,marker.worldcoordinate)
      pd.SetPoints(pts)
      pd.SetPolys(polys)
      pd.SetLines(lines)
      g.SetSourceData(pd)
    else:
      warnings.warn("unknown marker type: %s, using dot" % t)
      gs.SetGlyphTypeToCircle()
      gs.FilledOn()
    if t[-5:]=="_fill":
      gs.FilledOn()

    if pd is None:
      # Use the difference in x to scale the point, as later we'll use the
      # x range to correct the aspect ratio:
      dx = marker.worldcoordinate[1] - marker.worldcoordinate[0]
      s *= abs(float(dx))/500.
    gs.SetScale(s)
    gs.Update()

    if pd is None:
      g.SetSourceConnection(gs.GetOutputPort())
    g.SetInputData(markers)

    a = vtk.vtkActor()
    m = vtk.vtkPolyDataMapper()
    m.SetInputConnection(g.GetOutputPort())
    m.Update()
    a.SetMapper(m)
    p = a.GetProperty()
    #Color
    if cmap is None:
      if marker.colormap is not None:
        cmap = marker.colormap
      else:
        cmap = 'default'
    if isinstance(cmap,str):
      cmap = vcs.elements["colormap"][cmap]
    color = cmap.index[c]
    p.SetColor([C/100. for C in color])
    actors.append((g,gs,pd,a,geo))


  return actors
Exemplo n.º 13
0
        points.InsertNextPoint(j * 3, i * 3, 0)

        polydata = vtk.vtkPolyData()
        polydata.SetPoints(points)

        glyphSource = vtk.vtkGlyphSource2D()

        glyphSource.SetGlyphType(i)
        glyphSource.FilledOff()
        glyphSource.SetResolution(25)
        glyphSource.SetScale(fixedScales[j - 1])

        if GLYPH_TYPES[i] == 'VTK_TRIANGLE_GLYPH':
            glyphSource.SetRotationAngle(90)

        glyph2D = vtk.vtkGlyph2D()
        glyph2D.SetSourceConnection(glyphSource.GetOutputPort())
        glyph2D.SetInputData(polydata)
        glyph2D.Update()

        mapper = vtk.vtkPolyDataMapper()
        mapper.SetInputConnection(glyph2D.GetOutputPort())
        mapper.Update()

        actor = vtk.vtkActor()
        actor.SetMapper(mapper)

        actors.append(actor)

# Set up the renderer, render window, and interactor.
renderer = vtk.vtkRenderer()
Exemplo n.º 14
0
vectors.SetNumberOfTuples(numPoints)
vectors.SetName("vectors")
for i in range(numPoints):
    vectors.InsertTuple3(i, dx[i], dy[i], 0.0)

# construct the grid
grid = vtk.vtkUnstructuredGrid()
grid.SetPoints(points)
grid.GetPointData().AddArray(vectors)
grid.GetPointData().SetActiveVectors("vectors")

# make the arrow source
arrow = vtk.vtkArrowSource()

# make the glyph
glyph = vtk.vtkGlyph2D()
glyph.ScalingOn()
glyph.SetScaleModeToScaleByVector()
glyph.SetColorModeToColorByVector()
glyph.SetScaleFactor(0.5)
glyph.SetSource(arrow.GetOutput())
glyph.SetInput(grid)
glyph.ClampingOff()

# set up a stripper for faster rendering
stripper = vtk.vtkStripper()
stripper.SetInput(glyph.GetOutput())

# get the maximum norm of the data
maxNorm = grid.GetPointData().GetVectors().GetMaxNorm()
Exemplo n.º 15
0
    def __init__(self, filename, parent=None):
        QtGui.QMainWindow.__init__(self, parent)

        # Initiate the UI as defined by Qt Designer
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)

        self.poly_data = None

        self.node_ids = None
        self.element_ids = None
        self.node_count = 0

        self.read_data(filename)

        self.ui.txt_msg.appendPlainText("Model Loaded.")

        # initialize colors
        self.eidcolor = (0, 0.5, 0.5)
        self.edgecolor = (0, 0, 0)
        self.bgcolor1 = (0, 0, 1)
        self.bgcolor2 = (0.8, 0.8, 1)
        self.perspective = 0
        self.solid = 1

        self.idFilter = vtk.vtkIdFilter()
        self.idFilter.SetInputData(self.poly_data)
        self.idFilter.SetIdsArrayName("OriginalIds")
        self.idFilter.Update()

        self.surfaceFilter = vtk.vtkDataSetSurfaceFilter()
        self.surfaceFilter.SetInputConnection(self.idFilter.GetOutputPort())
        self.surfaceFilter.Update()

        self.input = self.surfaceFilter.GetOutput()

        self.renderer = vtk.vtkRenderer()
        #self.renderer2 = vtk_widget.vtkRenderer()

        viewport = [0.0,0.0,0.15,0.15]
        #self.renderer2.SetViewport(viewport)
        #self.renderer2.Transparent()

        self.renderWindowInteractor = QVTKRenderWindowInteractor(self.ui.frame)
        self.renderWindowInteractor.GetRenderWindow().AddRenderer(self.renderer)
        #self.renderWindowInteractor.GetRenderWindow().AddRenderer(self.renderer2)
        self.renderWindowInteractor.GetRenderWindow().SetAlphaBitPlanes(1)

        self.axes = CoordinateAxes(self.renderWindowInteractor)

        self.ui.vl.addWidget(self.renderWindowInteractor)

        self.iren = vtk.vtkRenderWindowInteractor()
        self.iren = self.renderWindowInteractor.GetRenderWindow().GetInteractor()

        self.mapper = vtk.vtkPolyDataMapper()
        self.mapper.SetInputData(self.input)
        self.mapper.ScalarVisibilityOff()

        self.actor = vtk.vtkActor()
        self.actor.SetMapper(self.mapper)
        self.actor.GetProperty().SetPointSize(2)
        self.actor.GetProperty().EdgeVisibilityOn()
        self.actor.GetProperty().SetColor(self.eidcolor)
        self.actor.GetProperty().SetEdgeColor(self.edgecolor)

        self.camera = vtk.vtkCamera()
        #self.camera2 = vtk_widget.vtkCamera()


        # trial... add glyph
        pd = vtk.vtkPolyData()
        pts = vtk.vtkPoints()
        scalars = vtk.vtkFloatArray()
        vectors = vtk.vtkFloatArray()
        vectors.SetNumberOfComponents(3)
        pd.SetPoints(pts)
        pd.GetPointData().SetScalars(scalars)
        pd.GetPointData().SetVectors(vectors)
        pts.InsertNextPoint(30, 30, 0.0)
        scalars.InsertNextValue(1)
        vectors.InsertNextTuple3(1, 1, 0.0)

        # Create simple PolyData for glyph table
        cs = vtk.vtkCubeSource()
        cs.SetXLength(0.5)
        cs.SetYLength(1)
        cs.SetZLength(2)
        # Set up the glyph filter
        glyph = vtk.vtkGlyph3D()
        #glyph.SetInputConnection(elev.GetOutputPort())


        point_list = vtk.vtkPoints()
        point_list.InsertNextPoint([30, 30, 0])
        poly_data = vtk.vtkPolyData()
        poly_data.SetPoints(point_list)

        idFilter = vtk.vtkIdFilter()
        idFilter.SetInputData(poly_data)
        idFilter.SetIdsArrayName("OriginalIds")
        idFilter.Update()

        surfaceFilter = vtk.vtkDataSetSurfaceFilter()
        surfaceFilter.SetInputConnection(idFilter.GetOutputPort())
        surfaceFilter.Update()


        # Here is where we build the glyph table
        # that will be indexed into according to the IndexMode
        glyph.SetSourceData(0,cs.GetOutput())
        #glyph.SetInputConnection(surfaceFilter.GetOutputPort())
        glyph.SetInputData(pd)
        glyph.SetIndexModeToScalar()
        glyph.SetRange(0, 1)
        glyph.SetScaleModeToDataScalingOff()
        glyph.OrientOn()
        mapper3 = vtk.vtkPolyDataMapper()
        mapper3.SetInputConnection(glyph.GetOutputPort())
        mapper3.SetScalarModeToUsePointFieldData()
        mapper3.SetColorModeToMapScalars()
        mapper3.ScalarVisibilityOn()
        mapper3.SetScalarRange(0, 1)
        actor3 = vtk.vtkActor()
        actor3.SetMapper(mapper3)
        #actor3.GetProperty().SetBackgroundOpacity(0.5)        


        gs = vtk.vtkGlyphSource2D()
        gs.SetGlyphTypeToCircle()
        gs.SetScale(25)
        gs.FilledOff()
        #gs.CrossOn()
        gs.Update()

        # Create a table of glyphs
        glypher = vtk.vtkGlyph2D()
        glypher.SetInputData(pd)
        glypher.SetSourceData(0, gs.GetOutput())
        glypher.SetIndexModeToScalar()
        glypher.SetRange(0, 1)
        glypher.SetScaleModeToDataScalingOff()
        mapper = vtk.vtkPolyDataMapper2D()
        mapper.SetInputConnection(glypher.GetOutputPort())
        mapper.SetScalarRange(0, 1)
        actor2D = vtk.vtkActor2D()
        actor2D.SetMapper(mapper)


        self.renderer.AddActor(self.actor)
        #self.renderer.AddActor(mapper)
        #self.renderer2.AddActor(actor3)


        self.renderer.SetBackground(self.bgcolor1)
        self.renderer.SetBackground2(self.bgcolor2)
        self.renderer.GradientBackgroundOn()

        self.renderer.SetActiveCamera(self.camera)
        self.renderer.ResetCamera()

        #self.camera.ZoomOff()        

        #self.renderer2.SetActiveCamera(self.camera)
        #self.renderer2.ResetCamera()
        #self.renderer2.SetBackground(0,0,0)

        #self.renderer2.GetProperty().SetBackgroundOpacity(0.5)
        #self.renderer2.SetLayer(1)


        #self.renderer2.Clear()

        self.areaPicker = vtk.vtkAreaPicker()
        self.renderWindowInteractor.SetPicker(self.areaPicker)

        self.style = MyInteractorStyle()
        self.style.SetPoints(self.input)
        self.style.SetDefaultRenderer(self.renderer)
        self.style.Data = self.idFilter.GetOutput()
        self.style.camera = self.camera
        self.style.node_ids = self.node_ids
        self.style.element_ids = self.element_ids
        self.style.node_count = self.node_count
        self.style.window = self
        self.style.print_message = self.ui.txt_msg.appendPlainText
        self.renderWindowInteractor.SetInteractorStyle(self.style)

        self.renderWindowInteractor.Start()

        # screenshot code:e
        #self.w2if = vtk_widget.vtkWindowToImageFilter()
        #self.w2if.SetInput(self.renWin)
        #self.w2if.Update()

        self.show()
        self.iren.Initialize()
        #self.iren.Start()



        # Setup Connections
        self.ui.btn_bgcolor1.clicked.connect(self.on_color1)
        self.ui.btn_bgcolor2.clicked.connect(self.on_color2)
        self.ui.btn_edgecolor.clicked.connect(self.on_edgecolor)
        self.ui.btn_elementcolor.clicked.connect(self.on_elementcolor)
        self.ui.btn_nofillededge.clicked.connect(self.on_nofillededge)
        self.ui.btn_switch.clicked.connect(self.on_switch)
        self.ui.btn_perspectivetoggle.clicked.connect(self.on_toggleperspective)
        self.ui.btn_saveimg.clicked.connect(self.on_saveimg)
        self.ui.btn_togglewire.clicked.connect(self.on_togglewire)

        # Setup a shortcuts
        self.setusrstyle = QtGui.QShortcut(self)
        self.setusrstyle.setKey(("CTRL+c"))
        self.setusrstyle.activated.connect(self.on_copyimg)
Exemplo n.º 16
0
    def _plotInternal(self):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        projection = vcs.elements["projection"][self._gm.projection]
        taxis = self._originalData1.getTime()
        scaleFactor = 1.0

        if self._originalData1.ndim > 2:
            zaxis = self._originalData1.getAxis(-3)
        else:
            zaxis = None

        scale = 1.0
        lat = None
        lon = None

        latAccessor = self._data1.getLatitude()
        lonAccessor = self._data1.getLongitude()
        if latAccessor:
            lat = latAccessor[:]
        if lonAccessor:
            lon = lonAccessor[:]

        if self._vtkGeoTransform is not None:
            newv = vtk.vtkDoubleArray()
            newv.SetNumberOfComponents(3)
            newv.InsertTypedTuple(0, [lon.min(), lat.min(), 0])
            newv.InsertTypedTuple(1, [lon.max(), lat.max(), 0])

            vcs2vtk.projectArray(newv, projection, self._vtkDataSetBounds)
            dimMin = [0, 0, 0]
            dimMax = [0, 0, 0]

            newv.GetTypedTuple(0, dimMin)
            newv.GetTypedTuple(1, dimMax)

            maxDimX = max(dimMin[0], dimMax[0])
            maxDimY = max(dimMin[1], dimMax[1])

            if lat.max() != 0.0:
                scale = abs((maxDimY / lat.max()))

            if lon.max() != 0.0:
                temp = abs((maxDimX / lon.max()))
                if scale < temp:
                    scale = temp
        else:
            scale = 1.0

        # Vector attempt
        l = self._gm.linetype
        if l is None:
            l = "default"
        try:
            l = vcs.getline(l)
            lwidth = l.width[0]  # noqa
            lcolor = l.color[0]
            lstyle = l.type[0]  # noqa
        except:
            lstyle = "solid"  # noqa
            lwidth = 1.  # noqa
            lcolor = [0., 0., 0., 100.]
        if self._gm.linewidth is not None:
            lwidth = self._gm.linewidth  # noqa
        if self._gm.linecolor is not None:
            lcolor = self._gm.linecolor

        arrow = vtk.vtkGlyphSource2D()
        arrow.SetGlyphTypeToArrow()
        arrow.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
        arrow.FilledOff()

        polydata = self._vtkPolyDataFilter.GetOutput()
        vectors = polydata.GetPointData().GetVectors()

        if self._gm.scaletype == 'constant' or\
           self._gm.scaletype == 'constantNNormalize' or\
           self._gm.scaletype == 'constantNLinear':
            scaleFactor = scale * 2.0 * self._gm.scale
        else:
            scaleFactor = 1.0

        glyphFilter = vtk.vtkGlyph2D()
        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()

        glyphFilter.SetScaleModeToScaleByVector()

        if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'linear' or\
           self._gm.scaletype == 'constantNNormalize' or self._gm.scaletype == 'constantNLinear':

            # Find the min and max vector magnitudes
            maxNorm = vectors.GetMaxNorm()

            if maxNorm == 0:
                maxNorm = 1.0

            if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'constantNNormalize':
                scaleFactor /= maxNorm

            if self._gm.scaletype == 'linear' or self._gm.scaletype == 'constantNLinear':
                minNorm = None
                maxNorm = None

                noOfComponents = vectors.GetNumberOfComponents()
                for i in range(0, vectors.GetNumberOfTuples()):
                    norm = vtk.vtkMath.Norm(vectors.GetTuple(i),
                                            noOfComponents)

                    if (minNorm is None or norm < minNorm):
                        minNorm = norm
                    if (maxNorm is None or norm > maxNorm):
                        maxNorm = norm

                if maxNorm == 0:
                    maxNorm = 1.0

                scalarArray = vtk.vtkDoubleArray()
                scalarArray.SetNumberOfComponents(1)
                scalarArray.SetNumberOfValues(vectors.GetNumberOfTuples())

                oldRange = maxNorm - minNorm
                oldRange = 1.0 if oldRange == 0.0 else oldRange

                # New range min, max.
                newRangeValues = self._gm.scalerange
                newRange = newRangeValues[1] - newRangeValues[0]

                for i in range(0, vectors.GetNumberOfTuples()):
                    norm = vtk.vtkMath.Norm(vectors.GetTuple(i),
                                            noOfComponents)
                    newValue = (((norm - minNorm) * newRange) /
                                oldRange) + newRangeValues[0]
                    scalarArray.SetValue(i, newValue)
                    polydata.GetPointData().SetScalars(scalarArray)

                # Scale to vector magnitude:
                # 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(scaleFactor)

        mapper = vtk.vtkPolyDataMapper()

        glyphFilter.Update()
        data = glyphFilter.GetOutput()

        mapper.SetInputData(data)
        mapper.ScalarVisibilityOff()
        act = vtk.vtkActor()
        act.SetMapper(mapper)

        cmap = self.getColorMap()
        if isinstance(lcolor, (list, tuple)):
            r, g, b, a = lcolor
        else:
            r, g, b, a = cmap.index[lcolor]
        act.GetProperty().SetColor(r / 100., g / 100., b / 100.)

        plotting_dataset_bounds = vcs2vtk.getPlottingBounds(
            vcs.utils.getworldcoordinates(self._gm, self._data1.getAxis(-1),
                                          self._data1.getAxis(-2)),
            self._vtkDataSetBounds, self._vtkGeoTransform)
        x1, x2, y1, y2 = plotting_dataset_bounds
        if self._vtkGeoTransform is None:
            wc = plotting_dataset_bounds
        else:
            xrange = list(act.GetXRange())
            yrange = list(act.GetYRange())
            wc = [xrange[0], xrange[1], yrange[0], yrange[1]]

        vp = self._resultDict.get('ratio_autot_viewport', [
            self._template.data.x1, self._template.data.x2,
            self._template.data.y1, self._template.data.y2
        ])
        # look for previous dataset_bounds different than ours and
        # modify the viewport so that the datasets are alligned
        # Hack to fix the case when the user does not specify gm.datawc_...
        # if geo is None:
        #     for dp in vcs.elements['display'].values():
        #         if (hasattr(dp, 'backend')):
        #             prevWc = dp.backend.get('dataset_bounds', None)
        #             if (prevWc):
        #                 middleX = float(vp[0] + vp[1]) / 2.0
        #                 middleY = float(vp[2] + vp[3]) / 2.0
        #                 sideX = float(vp[1] - vp[0]) / 2.0
        #                 sideY = float(vp[3] - vp[2]) / 2.0
        #                 ratioX = float(prevWc[1] - prevWc[0]) / float(wc[1] - wc[0])
        #                 ratioY = float(prevWc[3] - prevWc[2]) / float(wc[3] - wc[2])
        #                 sideX = sideX / ratioX
        #                 sideY = sideY / ratioY
        #                 vp = [middleX - sideX, middleX + sideX, middleY - sideY, middleY + sideY]

        dataset_renderer, xScale, yScale = self._context().fitToViewport(
            act,
            vp,
            wc=wc,
            priority=self._template.data.priority,
            create_renderer=True)
        kwargs = {
            'vtk_backend_grid': self._vtkDataSet,
            'dataset_bounds': self._vtkDataSetBounds,
            'plotting_dataset_bounds': plotting_dataset_bounds,
            "vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask,
            'vtk_backend_geo': self._vtkGeoTransform
        }
        if ('ratio_autot_viewport' in self._resultDict):
            kwargs["ratio_autot_viewport"] = vp
        self._resultDict.update(self._context().renderTemplate(
            self._template, self._data1, self._gm, taxis, zaxis, **kwargs))

        if self._context().canvas._continents is None:
            self._useContinents = False
        if self._useContinents:
            continents_renderer, xScale, yScale = self._context(
            ).plotContinents(plotting_dataset_bounds, projection,
                             self._dataWrapModulo, vp,
                             self._template.data.priority, **kwargs)
        self._resultDict["vtk_backend_actors"] = [[
            act, plotting_dataset_bounds
        ]]
        self._resultDict["vtk_backend_glyphfilters"] = [glyphFilter]
        self._resultDict["vtk_backend_luts"] = [[None, None]]
Exemplo n.º 17
0
gs3.Update()
gs4 = vtk.vtkGlyphSource2D()
gs4.SetGlyphTypeToDiamond()
gs4.SetScale(20)
gs4.FilledOn()
gs4.DashOn()
gs4.CrossOff()
gs4.Update()
gs5 = vtk.vtkGlyphSource2D()
gs5.SetGlyphTypeToThickArrow()
gs5.SetScale(20)
gs5.FilledOn()
gs5.CrossOff()
gs5.Update()
# Create a table of glyphs
glypher = vtk.vtkGlyph2D()
glypher.SetInputData(pd)
glypher.SetSourceData(0, gs.GetOutput())
glypher.SetSourceData(1, gs1.GetOutput())
glypher.SetSourceData(2, gs2.GetOutput())
glypher.SetSourceData(3, gs3.GetOutput())
glypher.SetSourceData(4, gs4.GetOutput())
glypher.SetSourceData(5, gs5.GetOutput())
glypher.SetIndexModeToScalar()
glypher.SetRange(0, 5)
glypher.SetScaleModeToDataScalingOff()
mapper = vtk.vtkPolyDataMapper2D()
mapper.SetInputConnection(glypher.GetOutputPort())
mapper.SetScalarRange(0, 5)
glyphActor = vtk.vtkActor2D()
glyphActor.SetMapper(mapper)
Exemplo n.º 18
0
    def _plotInternal(self):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        projection = vcs.elements["projection"][self._gm.projection]
        zaxis, taxis = self.getZandT()
        scale = 1.0

        if self._vtkGeoTransform is not None:
            lat = None
            lon = None

            latAccessor = self._data1.getLatitude()
            lonAccessor = self._data1.getLongitude()
            if latAccessor:
                lat = latAccessor[:]
            if lonAccessor:
                lon = lonAccessor[:]
            newv = vtk.vtkDoubleArray()
            newv.SetNumberOfComponents(3)
            newv.InsertTypedTuple(0, [lon.min(), lat.min(), 0])
            newv.InsertTypedTuple(1, [lon.max(), lat.max(), 0])

            vcs2vtk.projectArray(newv, projection, self._vtkDataSetBounds)
            dimMin = [0, 0, 0]
            dimMax = [0, 0, 0]

            newv.GetTypedTuple(0, dimMin)
            newv.GetTypedTuple(1, dimMax)

            maxDimX = max(dimMin[0], dimMax[0])
            maxDimY = max(dimMin[1], dimMax[1])

            if lat.max() != 0.0:
                scale = abs((maxDimY / lat.max()))

            if lon.max() != 0.0:
                temp = abs((maxDimX / lon.max()))
                if scale < temp:
                    scale = temp
        else:
            scale = 1.0

        # Vector attempt
        ltp_tmp = self._gm.linetype
        if ltp_tmp is None:
            ltp_tmp = "default"
        try:
            ltp_tmp = vcs.getline(ltp_tmp)
            lwidth = ltp_tmp.width[0]  # noqa
            lcolor = ltp_tmp.color[0]
            lstyle = ltp_tmp.type[0]  # noqa
        except Exception:
            lstyle = "solid"  # noqa
            lwidth = 1.  # noqa
            lcolor = [0., 0., 0., 100.]
        if self._gm.linewidth is not None:
            lwidth = self._gm.linewidth  # noqa
        if self._gm.linecolor is not None:
            lcolor = self._gm.linecolor

        arrow = vtk.vtkGlyphSource2D()
        arrow.SetGlyphTypeToArrow()
        arrow.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
        arrow.FilledOff()

        plotting_dataset_bounds = self.getPlottingBounds()
        x1, x2, y1, y2 = plotting_dataset_bounds
        vp = self._resultDict.get('ratio_autot_viewport', [
            self._template.data.x1, self._template.data.x2,
            self._template.data.y1, self._template.data.y2
        ])

        # The unscaled continent bounds were fine in the presence of axis
        # conversion, so save them here
        adjusted_plotting_bounds = vcs2vtk.getProjectedBoundsForWorldCoords(
            plotting_dataset_bounds, self._gm.projection)
        continentBounds = vcs2vtk.computeDrawAreaBounds(
            adjusted_plotting_bounds)

        # Transform the input data
        T = vtk.vtkTransform()
        T.Scale(self._context_xScale, self._context_yScale, 1.)
        self._vtkDataSetFittedToViewport = vcs2vtk.applyTransformationToDataset(
            T, self._vtkDataSetFittedToViewport)
        self._vtkDataSetBoundsNoMask = self._vtkDataSetFittedToViewport.GetBounds(
        )

        polydata = self._vtkDataSetFittedToViewport

        # view and interactive area
        view = self._context().contextView
        area = vtk.vtkInteractiveArea()
        view.GetScene().AddItem(area)

        drawAreaBounds = vcs2vtk.computeDrawAreaBounds(
            self._vtkDataSetBoundsNoMask, self._context_flipX,
            self._context_flipY)

        [renWinWidth, renWinHeight] = self._context().renWin.GetSize()
        geom = vtk.vtkRecti(int(round(vp[0] * renWinWidth)),
                            int(round(vp[2] * renWinHeight)),
                            int(round((vp[1] - vp[0]) * renWinWidth)),
                            int(round((vp[3] - vp[2]) * renWinHeight)))

        vcs2vtk.configureContextArea(area, drawAreaBounds, geom)

        # polydata = tmpMapper.GetInput()
        plotting_dataset_bounds = self.getPlottingBounds()

        vectors = polydata.GetPointData().GetVectors()

        if self._gm.scaletype == 'constant' or\
           self._gm.scaletype == 'constantNNormalize' or\
           self._gm.scaletype == 'constantNLinear':
            scaleFactor = scale * self._gm.scale
        else:
            scaleFactor = 1.0

        glyphFilter = vtk.vtkGlyph2D()
        glyphFilter.SetInputArrayToProcess(1, 0, 0, 0, "vector")
        glyphFilter.SetSourceConnection(arrow.GetOutputPort())
        glyphFilter.SetVectorModeToUseVector()

        # Rotate arrows to match vector data:
        glyphFilter.OrientOn()
        glyphFilter.ScalingOn()

        glyphFilter.SetScaleModeToScaleByVector()

        maxNormInVp = None
        minNormInVp = None
        # Find the min and max vector magnitudes
        (minNorm, maxNorm) = vectors.GetRange(-1)
        if maxNorm == 0:
            maxNorm = 1.0

        if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'linear' or\
           self._gm.scaletype == 'constantNNormalize' or self._gm.scaletype == 'constantNLinear':
            if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'constantNNormalize':
                scaleFactor /= maxNorm

            if self._gm.scaletype == 'linear' or self._gm.scaletype == 'constantNLinear':
                noOfComponents = vectors.GetNumberOfComponents()
                scalarArray = vtk.vtkDoubleArray()
                scalarArray.SetNumberOfComponents(1)
                scalarArray.SetNumberOfValues(vectors.GetNumberOfTuples())

                oldRange = maxNorm - minNorm
                oldRange = 1.0 if oldRange == 0.0 else oldRange

                # New range min, max.
                newRangeValues = self._gm.scalerange
                newRange = newRangeValues[1] - newRangeValues[0]

                for i in range(0, vectors.GetNumberOfTuples()):
                    norm = vtk.vtkMath.Norm(vectors.GetTuple(i),
                                            noOfComponents)
                    newValue = (((norm - minNorm) * newRange) /
                                oldRange) + newRangeValues[0]
                    scalarArray.SetValue(i, newValue)

                polydata.GetPointData().SetScalars(scalarArray)
                maxNormInVp = newRangeValues[1] * scaleFactor
                minNormInVp = newRangeValues[0] * scaleFactor

                # Scale to vector magnitude:
                # 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()

        if (maxNormInVp is None):
            maxNormInVp = maxNorm * scaleFactor
            # minNormInVp is left None, as it is displayed only for linear scaling.

        cmap = self.getColorMap()
        if isinstance(lcolor, (list, tuple)):
            r, g, b, a = lcolor
        else:
            r, g, b, a = cmap.index[lcolor]
        # act.GetProperty().SetColor(r / 100., g / 100., b / 100.)
        vtk_color = [int((c / 100.) * 255) for c in [r, g, b, a]]

        # Using the scaled data, set the glyph filter input
        glyphFilter.SetScaleFactor(scaleFactor)
        glyphFilter.SetInputData(polydata)
        glyphFilter.Update()
        # and set the arrows to be rendered.

        data = glyphFilter.GetOutput()

        floatValue = vtk.vtkFloatArray()
        floatValue.SetNumberOfComponents(1)
        floatValue.SetName("LineWidth")
        floatValue.InsertNextValue(lwidth)
        data.GetFieldData().AddArray(floatValue)

        item = vtk.vtkPolyDataItem()
        item.SetPolyData(data)

        item.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_CELL_DATA)

        colorArray = vtk.vtkUnsignedCharArray()
        colorArray.SetNumberOfComponents(4)
        for i in range(data.GetNumberOfCells()):
            colorArray.InsertNextTypedTuple(vtk_color)

        item.SetMappedColors(colorArray)
        area.GetDrawAreaItem().AddItem(item)

        kwargs = {
            'vtk_backend_grid':
            self._vtkDataSet,
            'dataset_bounds':
            self._vtkDataSetBounds,
            'plotting_dataset_bounds':
            plotting_dataset_bounds,
            "vtk_dataset_bounds_no_mask":
            self._vtkDataSetBoundsNoMask,
            'vtk_backend_geo':
            self._vtkGeoTransform,
            "vtk_backend_draw_area_bounds":
            continentBounds,
            "vtk_backend_viewport_scale":
            [self._context_xScale, self._context_yScale]
        }
        if ('ratio_autot_viewport' in self._resultDict):
            kwargs["ratio_autot_viewport"] = vp
        self._resultDict.update(self._context().renderTemplate(
            self._template, self._data1, self._gm, taxis, zaxis, **kwargs))

        # assume that self._data1.units has the proper vector units
        unitString = None
        if (hasattr(self._data1, 'units')):
            unitString = self._data1.units

        if self._vtkGeoTransform:
            worldWidth = self._vtkDataSetBoundsNoMask[
                1] - self._vtkDataSetBoundsNoMask[0]
        else:
            worldWidth = self._vtkDataSetBounds[1] - self._vtkDataSetBounds[0]

        worldToViewportXScale = (vp[1] - vp[0]) / worldWidth
        maxNormInVp *= worldToViewportXScale
        if (minNormInVp):
            minNormInVp *= worldToViewportXScale
        vcs.utils.drawVectorLegend(self._context().canvas,
                                   self._template.legend,
                                   lcolor,
                                   lstyle,
                                   lwidth,
                                   unitString,
                                   maxNormInVp,
                                   maxNorm,
                                   minNormInVp,
                                   minNorm,
                                   reference=self._gm.reference)

        kwargs['xaxisconvert'] = self._gm.xaxisconvert
        kwargs['yaxisconvert'] = self._gm.yaxisconvert
        if self._data1.getAxis(-1).isLongitude() and self._data1.getAxis(
                -2).isLatitude():
            self._context().plotContinents(
                self._plot_kargs.get("continents", self._useContinents),
                plotting_dataset_bounds, projection, self._dataWrapModulo, vp,
                self._template.data.priority, **kwargs)
        self._resultDict["vtk_backend_actors"] = [[
            item, plotting_dataset_bounds
        ]]
        self._resultDict["vtk_backend_glyphfilters"] = [glyphFilter]
        self._resultDict["vtk_backend_luts"] = [[None, None]]
Exemplo n.º 19
0
  def plotVector(self,data1,data2,tmpl,gm,ren):
    self.setLayer(ren,tmpl.data.priority)
    ug,xm,xM,ym,yM,continents,wrap = vcs2vtk.genUnstructuredGrid(data1,data2,gm)
    if ug.IsA("vtkUnstructuredGrid"):
        c2p = vtk.vtkCellDataToPointData()
        c2p.SetInputData(ug)
        c2p.Update()
        #For contouring duplicate points seem to confuse it
        cln = vtk.vtkCleanUnstructuredGrid()
        cln.SetInputConnection(c2p.GetOutputPort())

    missingMapper = vcs2vtk.putMaskOnVTKGrid(data1,ug,None)

    u=numpy.ma.ravel(data1)
    v=numpy.ma.ravel(data2)
    sh = list(u.shape)
    sh.append(1)
    u = numpy.reshape(u,sh)
    v = numpy.reshape(v,sh)
    z = numpy.zeros(u.shape)
    w = numpy.concatenate((u,v),axis=1)
    w = numpy.concatenate((w,z),axis=1)
    w = VN.numpy_to_vtk(w,deep=True)
    w.SetName("vectors")
    ug.GetPointData().AddArray(w)
    ## Vector attempt
    arrow = vtk.vtkArrowSource()
    l = gm.line
    if l is None:
        l = "default"
    try:
      l = vcs.getline(l)
      lwidth = l.width[0]
      lcolor = l.color[0]
      lstyle = l.type[0]
    except:
      lstyle = "solid"
      lwidth = 1.
      lcolor = 0
    if gm.linewidth is not None:
        lwidth = gm.linewidth
    if gm.linecolor is not None:
        lcolor = gm.linecolor


    arrow.SetTipRadius(.1*lwidth)
    arrow.SetShaftRadius(.03*lwidth)
    arrow.Update()
    glyphFilter = vtk.vtkGlyph2D()
    glyphFilter.SetSourceConnection(arrow.GetOutputPort())
    glyphFilter.OrientOn()
    glyphFilter.SetVectorModeToUseVector()
    glyphFilter.SetInputArrayToProcess(1,0,0,0,"vectors")
    glyphFilter.SetScaleFactor(2.*gm.scale)
    if ug.IsA("vtkUnstructuredGrid"):
        glyphFilter.SetInputConnection(cln.GetOutputPort())
    else:
        glyphFilter.SetInputData(ug)

    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(glyphFilter.GetOutputPort())
    act = vtk.vtkActor()
    act.SetMapper(mapper)
    try:
      cmap = vcs.elements["colormap"][cmap]
    except:
      cmap = vcs.elements["colormap"][self.canvas.getcolormapname()]
    r,g,b = cmap.index[lcolor]
    act.GetProperty().SetColor(r/100.,g/100.,b/100.)
    x1,x2,y1,y2 = vcs2vtk.getRange(gm,xm,xM,ym,yM)
    act = vcs2vtk.doWrap(act,[x1,x2,y1,y2],wrap)
    vcs2vtk.fitToViewport(act,ren,[tmpl.data.x1,tmpl.data.x2,tmpl.data.y1,tmpl.data.y2],[x1,x2,y1,y2])
    if tmpl.data.priority!=0:
        ren.AddActor(act)
    self.renderTemplate(ren,tmpl,data1,gm)
    if self.canvas._continents is None:
      continents = False
    if continents:
        projection = vcs.elements["projection"][gm.projection]
        self.plotContinents(x1,x2,y1,y2,projection,wrap,ren,tmpl)
Exemplo n.º 20
0
    def _plotInternal(self):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        projection = vcs.elements["projection"][self._gm.projection]
        taxis = self._originalData1.getTime()
        scaleFactor = 1.0

        if self._originalData1.ndim > 2:
            zaxis = self._originalData1.getAxis(-3)
        else:
            zaxis = None

        scale = 1.0
        lat = None
        lon = None

        latAccessor = self._data1.getLatitude()
        lonAccessor = self._data1.getLongitude()
        if latAccessor:
            lat = latAccessor[:]
        if lonAccessor:
            lon = lonAccessor[:]

        if self._vtkGeoTransform is not None:
            newv = vtk.vtkDoubleArray()
            newv.SetNumberOfComponents(3)
            newv.InsertTypedTuple(0, [lon.min(), lat.min(), 0])
            newv.InsertTypedTuple(1, [lon.max(), lat.max(), 0])

            vcs2vtk.projectArray(newv, projection, self._vtkDataSetBounds)
            dimMin = [0, 0, 0]
            dimMax = [0, 0, 0]

            newv.GetTypedTuple(0, dimMin)
            newv.GetTypedTuple(1, dimMax)

            maxDimX = max(dimMin[0], dimMax[0])
            maxDimY = max(dimMin[1], dimMax[1])

            if lat.max() != 0.0:
                scale = abs((maxDimY / lat.max()))

            if lon.max() != 0.0:
                temp = abs((maxDimX / lon.max()))
                if scale < temp:
                    scale = temp
        else:
            scale = 1.0

        # Vector attempt
        ltp_tmp = self._gm.linetype
        if ltp_tmp is None:
            ltp_tmp = "default"
        try:
            ltp_tmp = vcs.getline(ltp_tmp)
            lwidth = ltp_tmp.width[0]  # noqa
            lcolor = ltp_tmp.color[0]
            lstyle = ltp_tmp.type[0]  # noqa
        except Exception:
            lstyle = "solid"  # noqa
            lwidth = 1.  # noqa
            lcolor = [0., 0., 0., 100.]
        if self._gm.linewidth is not None:
            lwidth = self._gm.linewidth  # noqa
        if self._gm.linecolor is not None:
            lcolor = self._gm.linecolor

        arrow = vtk.vtkGlyphSource2D()
        arrow.SetGlyphTypeToArrow()
        arrow.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
        arrow.FilledOff()

        polydata = self._vtkPolyDataFilter.GetOutput()
        vectors = polydata.GetPointData().GetVectors()

        if self._gm.scaletype == 'constant' or\
           self._gm.scaletype == 'constantNNormalize' or\
           self._gm.scaletype == 'constantNLinear':
            scaleFactor = scale * self._gm.scale
        else:
            scaleFactor = 1.0

        glyphFilter = vtk.vtkGlyph2D()
        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()

        glyphFilter.SetScaleModeToScaleByVector()

        maxNormInVp = None
        minNormInVp = None
        # Find the min and max vector magnitudes
        (minNorm, maxNorm) = vectors.GetRange(-1)
        if maxNorm == 0:
            maxNorm = 1.0

        if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'linear' or\
           self._gm.scaletype == 'constantNNormalize' or self._gm.scaletype == 'constantNLinear':
            if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'constantNNormalize':
                scaleFactor /= maxNorm

            if self._gm.scaletype == 'linear' or self._gm.scaletype == 'constantNLinear':
                noOfComponents = vectors.GetNumberOfComponents()
                scalarArray = vtk.vtkDoubleArray()
                scalarArray.SetNumberOfComponents(1)
                scalarArray.SetNumberOfValues(vectors.GetNumberOfTuples())

                oldRange = maxNorm - minNorm
                oldRange = 1.0 if oldRange == 0.0 else oldRange

                # New range min, max.
                newRangeValues = self._gm.scalerange
                newRange = newRangeValues[1] - newRangeValues[0]

                for i in range(0, vectors.GetNumberOfTuples()):
                    norm = vtk.vtkMath.Norm(vectors.GetTuple(i),
                                            noOfComponents)
                    newValue = (((norm - minNorm) * newRange) /
                                oldRange) + newRangeValues[0]
                    scalarArray.SetValue(i, newValue)
                    polydata.GetPointData().SetScalars(scalarArray)
                maxNormInVp = newRangeValues[1] * scaleFactor
                minNormInVp = newRangeValues[0] * scaleFactor

                # Scale to vector magnitude:
                # 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(scaleFactor)
        if (maxNormInVp is None):
            maxNormInVp = maxNorm * scaleFactor
            # minNormInVp is left None, as it is displayed only for linear scaling.

        mapper = vtk.vtkPolyDataMapper()

        glyphFilter.Update()
        data = glyphFilter.GetOutput()

        mapper.SetInputData(data)
        mapper.ScalarVisibilityOff()
        act = vtk.vtkActor()
        act.SetMapper(mapper)

        cmap = self.getColorMap()
        if isinstance(lcolor, (list, tuple)):
            r, g, b, a = lcolor
        else:
            r, g, b, a = cmap.index[lcolor]
        act.GetProperty().SetColor(r / 100., g / 100., b / 100.)

        plotting_dataset_bounds = self.getPlottingBounds()
        vp = self._resultDict.get('ratio_autot_viewport', [
            self._template.data.x1, self._template.data.x2,
            self._template.data.y1, self._template.data.y2
        ])
        dataset_renderer, xScale, yScale = self._context().fitToViewport(
            act,
            vp,
            wc=plotting_dataset_bounds,
            geoBounds=self._vtkDataSetBoundsNoMask,
            geo=self._vtkGeoTransform,
            priority=self._template.data.priority,
            create_renderer=True)
        kwargs = {
            'vtk_backend_grid': self._vtkDataSet,
            'dataset_bounds': self._vtkDataSetBounds,
            'plotting_dataset_bounds': plotting_dataset_bounds,
            "vtk_dataset_bounds_no_mask": self._vtkDataSetBoundsNoMask,
            'vtk_backend_geo': self._vtkGeoTransform
        }
        if ('ratio_autot_viewport' in self._resultDict):
            kwargs["ratio_autot_viewport"] = vp
        self._resultDict.update(self._context().renderTemplate(
            self._template, self._data1, self._gm, taxis, zaxis, **kwargs))

        # assume that self._data1.units has the proper vector units
        unitString = None
        if (hasattr(self._data1, 'units')):
            unitString = self._data1.units

        worldToViewportXScale = (vp[1] - vp[0]) /\
            (self._vtkDataSetBoundsNoMask[1] - self._vtkDataSetBoundsNoMask[0])
        maxNormInVp *= worldToViewportXScale
        if (minNormInVp):
            minNormInVp *= worldToViewportXScale
        vcs.utils.drawVectorLegend(self._context().canvas,
                                   self._template.legend, lcolor, lstyle,
                                   lwidth, unitString, maxNormInVp, maxNorm,
                                   minNormInVp, minNorm)

        if self._context().canvas._continents is None:
            self._useContinents = False
        if self._useContinents:
            continents_renderer, xScale, yScale = self._context(
            ).plotContinents(plotting_dataset_bounds, projection,
                             self._dataWrapModulo, vp,
                             self._template.data.priority, **kwargs)
        self._resultDict["vtk_backend_actors"] = [[
            act, plotting_dataset_bounds
        ]]
        self._resultDict["vtk_backend_glyphfilters"] = [glyphFilter]
        self._resultDict["vtk_backend_luts"] = [[None, None]]
Exemplo n.º 21
0
  def plotVector(self,data1,data2,tmpl,gm):
    ug,xm,xM,ym,yM,continents,wrap,geo,cellData = vcs2vtk.genGrid(data1,data2,gm)
    if cellData:
        c2p = vtk.vtkCellDataToPointData()
        c2p.SetInputData(ug)
        c2p.Update()
        #For contouring duplicate points seem to confuse it
        if ug.IsA("vtkUnstructuredGrid"):
            cln = vtk.vtkCleanUnstructuredGrid()
            cln.SetInputConnection(c2p.GetOutputPort())

    missingMapper = vcs2vtk.putMaskOnVTKGrid(data1,ug,None,cellData)

    u=numpy.ma.ravel(data1)
    v=numpy.ma.ravel(data2)
    sh = list(u.shape)
    sh.append(1)
    u = numpy.reshape(u,sh)
    v = numpy.reshape(v,sh)
    z = numpy.zeros(u.shape)
    w = numpy.concatenate((u,v),axis=1)
    w = numpy.concatenate((w,z),axis=1)
    w = VN.numpy_to_vtk(w,deep=True)
    w.SetName("vectors")
    ug.GetPointData().AddArray(w)
    ## Vector attempt
    arrow = vtk.vtkArrowSource()
    l = gm.line
    if l is None:
        l = "default"
    try:
      l = vcs.getline(l)
      lwidth = l.width[0]
      lcolor = l.color[0]
      lstyle = l.type[0]
    except:
      lstyle = "solid"
      lwidth = 1.
      lcolor = 0
    if gm.linewidth is not None:
        lwidth = gm.linewidth
    if gm.linecolor is not None:
        lcolor = gm.linecolor


    arrow.SetTipRadius(.1*lwidth)
    arrow.SetShaftRadius(.03*lwidth)
    arrow.Update()
    glyphFilter = vtk.vtkGlyph2D()
    glyphFilter.SetSourceConnection(arrow.GetOutputPort())
    glyphFilter.OrientOn()
    glyphFilter.SetVectorModeToUseVector()
    glyphFilter.SetInputArrayToProcess(1,0,0,0,"vectors")
    glyphFilter.SetScaleFactor(2.*gm.scale)
    if cellData:
        if ug.IsA("vtkUnstructuredGrid"):
            glyphFilter.SetInputConnection(cln.GetOutputPort())
        else:
            glyphFilter.SetInputConnection(c2p.GetOutputPort())
    else:
        glyphFilter.SetInputData(ug)

    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(glyphFilter.GetOutputPort())
    act = vtk.vtkActor()
    act.SetMapper(mapper)
    try:
      cmap = vcs.elements["colormap"][cmap]
    except:
      cmap = vcs.elements["colormap"][self.canvas.getcolormapname()]
    r,g,b = cmap.index[lcolor]
    act.GetProperty().SetColor(r/100.,g/100.,b/100.)
    x1,x2,y1,y2 = vcs2vtk.getRange(gm,xm,xM,ym,yM)
    act = vcs2vtk.doWrap(act,[x1,x2,y1,y2],wrap)
    ren=vtk.vtkRenderer()
    self.renWin.AddRenderer(ren)
    self.setLayer(ren,tmpl.data.priority)
    vcs2vtk.fitToViewport(act,ren,[tmpl.data.x1,tmpl.data.x2,tmpl.data.y1,tmpl.data.y2],[x1,x2,y1,y2])
    if tmpl.data.priority!=0:
        ren.AddActor(act)
    self.renderTemplate(tmpl,data1,gm)
    if self.canvas._continents is None:
      continents = False
    if continents:
        projection = vcs.elements["projection"][gm.projection]
        self.plotContinents(x1,x2,y1,y2,projection,wrap,tmpl)
Exemplo n.º 22
0
  def plotVector(self,data1,data2,tmpl,gm):
    #Preserve time and z axis for plotting these inof in rendertemplate
    taxis = data1.getTime()
    if data1.ndim>2:
        zaxis = data1.getAxis(-3)
    else:
        zaxis = None
    data1 = self.trimData2D(data1) # Ok get3 only the last 2 dims
    data2 = self.trimData2D(data2)
    ug,xm,xM,ym,yM,continents,wrap,geo = vcs2vtk.genGridOnPoints(data1,data2,gm,deep=False)
    missingMapper = vcs2vtk.putMaskOnVTKGrid(data1,ug,None,False,deep=False)

    u=numpy.ma.ravel(data1)
    v=numpy.ma.ravel(data2)
    sh = list(u.shape)
    sh.append(1)
    u = numpy.reshape(u,sh)
    v = numpy.reshape(v,sh)
    z = numpy.zeros(u.shape)
    w = numpy.concatenate((u,v),axis=1)
    w = numpy.concatenate((w,z),axis=1)

    # HACK The grid returned by vtk2vcs.genGrid is not the same size as the
    # data array. I'm not sure where the issue is...for now let's just zero-pad
    # data array so that we can at least test rendering until Charles gets
    # back from vacation:
    wLen = len(w)
    numPts = ug.GetNumberOfPoints()
    if wLen != numPts:
        warnings.warn("!!! Warning during vector plotting: Number of points does not "\
              "match the number of vectors to be glyphed (%s points vs %s "\
              "vectors). The vectors will be padded/truncated to match for "\
              "rendering purposes, but the resulting image should not be "\
              "trusted."%(numPts, wLen))
        newShape = (numPts,) + w.shape[1:]
        w = numpy.ma.resize(w, newShape)

    w = vcs2vtk.numpy_to_vtk_wrapper(w,deep=False)
    w.SetName("vectors")
    ug.GetPointData().AddArray(w)

    ## Vector attempt
    l = gm.line
    if l is None:
        l = "default"
    try:
      l = vcs.getline(l)
      lwidth = l.width[0]
      lcolor = l.color[0]
      lstyle = l.type[0]
    except:
      lstyle = "solid"
      lwidth = 1.
      lcolor = 0
    if gm.linewidth is not None:
        lwidth = gm.linewidth
    if gm.linecolor is not None:
        lcolor = gm.linecolor

    # Strip out masked points.
    if ug.IsA("vtkStructuredGrid"):
        if ug.GetCellBlanking():
            visArray = ug.GetCellVisibilityArray()
            visArray.SetName("BlankingArray")
            ug.GetCellData().AddArray(visArray)
            thresh = vtk.vtkThreshold()
            thresh.SetInputData(ug)
            thresh.ThresholdByUpper(0.5)
            thresh.SetInputArrayToProcess(0, 0, 0,
                                          "vtkDataObject::FIELD_ASSOCIATION_CELLS",
                                          "BlankingArray")
            thresh.Update()
            ug = thresh.GetOutput()
        elif ug.GetPointBlanking():
            visArray = ug.GetPointVisibilityArray()
            visArray.SetName("BlankingArray")
            ug.GetPointData().AddArray(visArray)
            thresh = vtk.vtkThreshold()
            thresh.SetInputData(ug)
            thresh.SetUpperThreshold(0.5)
            thresh.SetInputArrayToProcess(0, 0, 0,
                                          "vtkDataObject::FIELD_ASSOCIATION_POINTS",
                                          "BlankingArray")
            thresh.Update()
            ug = thresh.GetOutput()

    arrow = vtk.vtkGlyphSource2D()
    arrow.SetGlyphTypeToArrow()
    arrow.FilledOff()

    glyphFilter = vtk.vtkGlyph2D()
    glyphFilter.SetSourceConnection(arrow.GetOutputPort())
    glyphFilter.SetVectorModeToUseVector()

    # Rotate arrows to match vector data:
    glyphFilter.OrientOn()

    # Scale to vector magnitude:
    glyphFilter.SetScaleModeToScaleByVector()

    # 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]. Bump
    # up min so that near-zero vectors will not be rendered, as these tend to
    # come out randomly oriented.
    glyphFilter.ClampingOn()
    glyphFilter.SetRange(0.01, 1.0)

    glyphFilter.SetInputArrayToProcess(1,0,0,0,"vectors")
    glyphFilter.SetScaleFactor(2.*gm.scale)

    #if cellData:
    #    if ug.IsA("vtkUnstructuredGrid"):
    #        glyphFilter.SetInputConnection(cln.GetOutputPort())
    #    else:
    #        glyphFilter.SetInputConnection(c2p.GetOutputPort())
    #else:
    #    glyphFilter.SetInputData(ug)
    glyphFilter.SetInputData(ug)

    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(glyphFilter.GetOutputPort())
    act = vtk.vtkActor()
    act.SetMapper(mapper)
    try:
      cmap = vcs.elements["colormap"][cmap]
    except:
      cmap = vcs.elements["colormap"][self.canvas.getcolormapname()]
    r,g,b = cmap.index[lcolor]
    act.GetProperty().SetColor(r/100.,g/100.,b/100.)
    x1,x2,y1,y2 = vcs2vtk.getRange(gm,xm,xM,ym,yM)
    act = vcs2vtk.doWrap(act,[x1,x2,y1,y2],wrap)
    ren = self.createRenderer()
    self.renWin.AddRenderer(ren)
    self.setLayer(ren,tmpl.data.priority)
    vcs2vtk.fitToViewport(act,ren,[tmpl.data.x1,tmpl.data.x2,tmpl.data.y1,tmpl.data.y2],[x1,x2,y1,y2])
    if tmpl.data.priority!=0:
        ren.AddActor(act)
    self.renderTemplate(tmpl,data1,gm,taxis,zaxis)
    if self.canvas._continents is None:
      continents = False
    if continents:
        projection = vcs.elements["projection"][gm.projection]
        self.plotContinents(x1,x2,y1,y2,projection,wrap,tmpl)
Exemplo n.º 23
0
    def plot(self, data1, data2, tmpl, gm, grid, transform):
        """Overrides baseclass implementation."""
        #Preserve time and z axis for plotting these inof in rendertemplate
        returned = {}
        taxis = data1.getTime()
        if data1.ndim > 2:
            zaxis = data1.getAxis(-3)
        else:
            zaxis = None

        data1 = self._context.trimData2D(data1) # Ok get3 only the last 2 dims
        data2 = self._context.trimData2D(data2)

        gridGenDict = vcs2vtk.genGridOnPoints(data1, gm, deep=False, grid=grid,
                                              geo=transform)
        for k in ['vtk_backend_grid', 'xm', 'xM', 'ym', 'yM', 'continents',
                  'wrap', 'geo']:
            exec("%s = gridGenDict['%s']" % (k, k))
        grid = gridGenDict['vtk_backend_grid']

        returned["vtk_backend_grid"] = grid
        returned["vtk_backend_geo"] = geo
        missingMapper = vcs2vtk.putMaskOnVTKGrid(data1, grid, None, False,
                                                 deep=False)

        # None/False are for color and cellData
        # (sent to vcs2vtk.putMaskOnVTKGrid)
        returned["vtk_backend_missing_mapper"] = (missingMapper, None, False)

        w = vcs2vtk.generateVectorArray(data1, data2, grid)

        grid.GetPointData().AddArray(w)

        ## Vector attempt
        l = gm.line
        if l is None:
            l = "default"
        try:
          l = vcs.getline(l)
          lwidth = l.width[0]
          lcolor = l.color[0]
          lstyle = l.type[0]
        except:
          lstyle = "solid"
          lwidth = 1.
          lcolor = 0
        if gm.linewidth is not None:
            lwidth = gm.linewidth
        if gm.linecolor is not None:
            lcolor = gm.linecolor

        grid = vcs2vtk.stripGrid(grid)

        arrow = vtk.vtkGlyphSource2D()
        arrow.SetGlyphTypeToArrow()
        arrow.FilledOff()

        glyphFilter = vtk.vtkGlyph2D()
        glyphFilter.SetInputData(grid)
        glyphFilter.SetInputArrayToProcess(1, 0, 0, 0, "vectors")
        glyphFilter.SetSourceConnection(arrow.GetOutputPort())
        glyphFilter.SetVectorModeToUseVector()

        # Rotate arrows to match vector data:
        glyphFilter.OrientOn()

        # Scale to vector magnitude:
        glyphFilter.SetScaleModeToScaleByVector()
        glyphFilter.SetScaleFactor(2. * 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()
        mapper.SetInputConnection(glyphFilter.GetOutputPort())
        act = vtk.vtkActor()
        act.SetMapper(mapper)

        cmap = vcs.elements["colormap"][self._context.canvas.getcolormapname()]
        r, g, b = cmap.index[lcolor]
        act.GetProperty().SetColor(r / 100.,g / 100.,b / 100.)

        x1, x2, y1, y2 = vcs.utils.getworldcoordinates(gm, data1.getAxis(-1),
                                                       data1.getAxis(-2))

        act = vcs2vtk.doWrap(act, [x1,x2,y1,y2], wrap)
        ren = self._context.fitToViewport(act, [tmpl.data.x1, tmpl.data.x2,
                                                tmpl.data.y1, tmpl.data.y2],
                                          [x1, x2, y1, y2],
                                          priority=tmpl.data.priority)

        returned.update(
              self._context.renderTemplate(tmpl, data1, gm, taxis, zaxis))

        if self._context.canvas._continents is None:
          continents = False
        if continents:
            projection = vcs.elements["projection"][gm.projection]
            self._context.plotContinents(x1, x2, y1, y2, projection, wrap, tmpl)

        returned["vtk_backend_actors"] = [[act, [x1,x2,y1,y2]],]
        returned["vtk_backend_glyphfilters"] = [glyphFilter,]
        returned["vtk_backend_luts"] = [[None, None],]

        return returned
    points.InsertNextPoint(j*3, i*3, 0)

    polydata = vtk.vtkPolyData()
    polydata.SetPoints(points)

    glyphSource = vtk.vtkGlyphSource2D()

    glyphSource.SetGlyphType(i)
    glyphSource.FilledOff()
    glyphSource.SetResolution(25)
    glyphSource.SetScale(fixedScales[j-1])

    if GLYPH_TYPES[i] == 'VTK_TRIANGLE_GLYPH':
      glyphSource.SetRotationAngle(90)

    glyph2D = vtk.vtkGlyph2D()
    glyph2D.SetSourceConnection(glyphSource.GetOutputPort())
    glyph2D.SetInputData(polydata)
    glyph2D.Update()

    mapper = vtk.vtkPolyDataMapper()
    mapper.SetInputConnection(glyph2D.GetOutputPort())
    mapper.Update()

    actor = vtk.vtkActor()
    actor.SetMapper(mapper)

    actors.append(actor)

# Set up the renderer, render window, and interactor.
renderer = vtk.vtkRenderer()
Exemplo n.º 25
0
    def _plotInternal(self):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        projection = vcs.elements["projection"][self._gm.projection]
        taxis = self._originalData1.getTime()
        scaleFactor = 1.0

        if self._originalData1.ndim > 2:
            zaxis = self._originalData1.getAxis(-3)
        else:
            zaxis = None

        scale = 1.0
        lat = None
        lon = None

        latAccessor = self._data1.getLatitude()
        lonAccessor = self._data1.getLongitude()
        if latAccessor:
            lat = latAccessor[:]
        if lonAccessor:
            lon = lonAccessor[:]

        if self._vtkGeoTransform is not None:
            newv = vtk.vtkDoubleArray()
            newv.SetNumberOfComponents(3)
            newv.InsertTypedTuple(0, [lon.min(), lat.min(), 0])
            newv.InsertTypedTuple(1, [lon.max(), lat.max(), 0])

            vcs2vtk.projectArray(newv, projection, self._vtkDataSetBounds)
            dimMin = [0, 0, 0]
            dimMax = [0, 0, 0]

            newv.GetTypedTuple(0, dimMin)
            newv.GetTypedTuple(1, dimMax)

            maxDimX = max(dimMin[0], dimMax[0])
            maxDimY = max(dimMin[1], dimMax[1])

            if lat.max() != 0.0:
                scale = abs((maxDimY / lat.max()))

            if lon.max() != 0.0:
                temp = abs((maxDimX / lon.max()))
                if scale < temp:
                    scale = temp
        else:
            scale = 1.0

        # Vector attempt
        l = self._gm.line
        if l is None:
            l = "default"
        try:
            l = vcs.getline(l)
            lwidth = l.width[0]  # noqa
            lcolor = l.color[0]
            lstyle = l.type[0]  # noqa
        except:
            lstyle = "solid"  # noqa
            lwidth = 1.  # noqa
            lcolor = 0
        if self._gm.linewidth is not None:
            lwidth = self._gm.linewidth  # noqa
        if self._gm.linecolor is not None:
            lcolor = self._gm.linecolor

        arrow = vtk.vtkGlyphSource2D()
        arrow.SetGlyphTypeToArrow()
        arrow.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
        arrow.FilledOff()

        polydata = self._vtkPolyDataFilter.GetOutput()
        vectors = polydata.GetPointData().GetVectors()

        if self._gm.scaletype == 'constant' or\
           self._gm.scaletype == 'constantNNormalize' or\
           self._gm.scaletype == 'constantNLinear':
            scaleFactor = scale * 2.0 * self._gm.scale
        else:
            scaleFactor = 1.0

        glyphFilter = vtk.vtkGlyph2D()
        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()

        glyphFilter.SetScaleModeToScaleByVector()

        if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'linear' or\
           self._gm.scaletype == 'constantNNormalize' or self._gm.scaletype == 'constantNLinear':

            # Find the min and max vector magnitudes
            maxNorm = vectors.GetMaxNorm()

            if maxNorm == 0:
                maxNorm = 1.0

            if self._gm.scaletype == 'normalize' or self._gm.scaletype == 'constantNNormalize':
                scaleFactor /= maxNorm

            if self._gm.scaletype == 'linear' or self._gm.scaletype == 'constantNLinear':
                minNorm = None
                maxNorm = None

                noOfComponents = vectors.GetNumberOfComponents()
                for i in range(0, vectors.GetNumberOfTuples()):
                    norm = vtk.vtkMath.Norm(vectors.GetTuple(i), noOfComponents)

                    if (minNorm is None or norm < minNorm):
                        minNorm = norm
                    if (maxNorm is None or norm > maxNorm):
                        maxNorm = norm

                if maxNorm == 0:
                    maxNorm = 1.0

                scalarArray = vtk.vtkDoubleArray()
                scalarArray.SetNumberOfComponents(1)
                scalarArray.SetNumberOfValues(vectors.GetNumberOfTuples())

                oldRange = maxNorm - minNorm
                oldRange = 1.0 if oldRange == 0.0 else oldRange

                # New range min, max.
                newRangeValues = self._gm.scalerange
                newRange = newRangeValues[1] - newRangeValues[0]

                for i in range(0, vectors.GetNumberOfTuples()):
                    norm = vtk.vtkMath.Norm(vectors.GetTuple(i), noOfComponents)
                    newValue = (((norm - minNorm) * newRange) / oldRange) + newRangeValues[0]
                    scalarArray.SetValue(i, newValue)
                    polydata.GetPointData().SetScalars(scalarArray)

                # Scale to vector magnitude:
                # 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(scaleFactor)

        mapper = vtk.vtkPolyDataMapper()

        glyphFilter.Update()
        data = glyphFilter.GetOutput()

        mapper.SetInputData(data)
        mapper.ScalarVisibilityOff()
        act = vtk.vtkActor()
        act.SetMapper(mapper)

        cmap = self.getColorMap()
        r, g, b, a = cmap.index[lcolor]
        act.GetProperty().SetColor(r / 100., g / 100., b / 100.)

        plotting_dataset_bounds = vcs2vtk.getPlottingBounds(
            vcs.utils.getworldcoordinates(self._gm,
                                          self._data1.getAxis(-1),
                                          self._data1.getAxis(-2)),
            self._vtkDataSetBounds, self._vtkGeoTransform)
        x1, x2, y1, y2 = plotting_dataset_bounds
        if self._vtkGeoTransform is None:
            wc = plotting_dataset_bounds
        else:
            xrange = list(act.GetXRange())
            yrange = list(act.GetYRange())
            wc = [xrange[0], xrange[1], yrange[0], yrange[1]]

        vp = self._resultDict.get('ratio_autot_viewport',
                                  [self._template.data.x1, self._template.data.x2,
                                   self._template.data.y1, self._template.data.y2])
        # look for previous dataset_bounds different than ours and
        # modify the viewport so that the datasets are alligned
        # Hack to fix the case when the user does not specify gm.datawc_...
        # if geo is None:
        #     for dp in vcs.elements['display'].values():
        #         if (hasattr(dp, 'backend')):
        #             prevWc = dp.backend.get('dataset_bounds', None)
        #             if (prevWc):
        #                 middleX = float(vp[0] + vp[1]) / 2.0
        #                 middleY = float(vp[2] + vp[3]) / 2.0
        #                 sideX = float(vp[1] - vp[0]) / 2.0
        #                 sideY = float(vp[3] - vp[2]) / 2.0
        #                 ratioX = float(prevWc[1] - prevWc[0]) / float(wc[1] - wc[0])
        #                 ratioY = float(prevWc[3] - prevWc[2]) / float(wc[3] - wc[2])
        #                 sideX = sideX / ratioX
        #                 sideY = sideY / ratioY
        #                 vp = [middleX - sideX, middleX + sideX, middleY - sideY, middleY + sideY]

        dataset_renderer, xScale, yScale = self._context().fitToViewport(
            act, vp,
            wc=wc,
            priority=self._template.data.priority,
            create_renderer=True)
        kwargs = {'vtk_backend_grid': self._vtkDataSet,
                  'dataset_bounds': self._vtkDataSetBounds,
                  'plotting_dataset_bounds': plotting_dataset_bounds,
                  'vtk_backend_geo': self._vtkGeoTransform}
        if ('ratio_autot_viewport' in self._resultDict):
            kwargs["ratio_autot_viewport"] = vp
        self._resultDict.update(self._context().renderTemplate(
            self._template, self._data1,
            self._gm, taxis, zaxis, **kwargs))

        if self._context().canvas._continents is None:
            self._useContinents = False
        if self._useContinents:
            continents_renderer, xScale, yScale = self._context().plotContinents(
                plotting_dataset_bounds, projection,
                self._dataWrapModulo, vp, self._template.data.priority,
                vtk_backend_grid=self._vtkDataSet,
                dataset_bounds=self._vtkDataSetBounds)
        self._resultDict["vtk_backend_actors"] = [[act, plotting_dataset_bounds]]
        self._resultDict["vtk_backend_glyphfilters"] = [glyphFilter]
        self._resultDict["vtk_backend_luts"] = [[None, None]]
xform = vtk.vtkTransformCoordinateSystems()
xform.SetInputConnection(sphere.GetOutputPort())
xform.SetInputCoordinateSystemToWorld()
xform.SetOutputCoordinateSystemToDisplay()
xform.SetViewport(ren1)

gs = vtk.vtkGlyphSource2D()
gs.SetGlyphTypeToCircle()
gs.SetScale(20)
gs.FilledOff()
gs.CrossOn()
gs.Update()

# Create a table of glyphs
glypher = vtk.vtkGlyph2D()
glypher.SetInputConnection(xform.GetOutputPort())
glypher.SetSourceData(0, gs.GetOutput())
glypher.SetScaleModeToDataScalingOff()

mapper = vtk.vtkPolyDataMapper2D()
mapper.SetInputConnection(glypher.GetOutputPort())

glyphActor = vtk.vtkActor2D()
glyphActor.SetMapper(mapper)

# Add the actors to the renderer, set the background and size
#
ren1.AddActor(glyphActor)
ren1.SetBackground(0, 0, 0)
Exemplo n.º 27
0
    def plot(self, data1, data2, tmpl, grid, transform):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        geo = None  # to make flake8 happy
        projection = vcs.elements["projection"][self._gm.projection]
        returned = {}
        taxis = data1.getTime()
        if data1.ndim > 2:
            zaxis = data1.getAxis(-3)
        else:
            zaxis = None

        # Ok get3 only the last 2 dims
        data1 = self._context().trimData2D(data1)
        data2 = self._context().trimData2D(data2)

        scale = 1.0
        lat = None
        lon = None

        latAccessor = data1.getLatitude()
        lonAccesrsor = data1.getLongitude()
        if latAccessor:
            lat = latAccessor[:]
        if lonAccesrsor:
            lon = lonAccesrsor[:]

        gridGenDict = vcs2vtk.genGridOnPoints(data1, self._gm, deep=False, grid=grid,
                                              geo=transform, data2=data2)

        data1 = gridGenDict["data"]
        data2 = gridGenDict["data2"]
        geo = gridGenDict["geo"]

        for k in ['vtk_backend_grid', 'xm', 'xM', 'ym', 'yM', 'continents',
                  'wrap', 'geo']:
            exec("%s = gridGenDict['%s']" % (k, k))
        grid = gridGenDict['vtk_backend_grid']
        self._dataWrapModulo = gridGenDict['wrap']

        if geo is not None:
            newv = vtk.vtkDoubleArray()
            newv.SetNumberOfComponents(3)
            newv.InsertTupleValue(0, [lon.min(), lat.min(), 0])
            newv.InsertTupleValue(1, [lon.max(), lat.max(), 0])

            vcs2vtk.projectArray(newv, projection,
                                 [gridGenDict['xm'], gridGenDict['xM'],
                                  gridGenDict['ym'], gridGenDict['yM']])
            dimMin = [0, 0, 0]
            dimMax = [0, 0, 0]

            newv.GetTupleValue(0, dimMin)
            newv.GetTupleValue(1, dimMax)

            maxDimX = max(dimMin[0], dimMax[0])
            maxDimY = max(dimMin[1], dimMax[1])

            if lat.max() != 0.0:
                scale = abs((maxDimY / lat.max()))

            if lon.max() != 0.0:
                temp = abs((maxDimX / lon.max()))
                if scale < temp:
                    scale = temp
        else:
            scale = 1.0

        returned["vtk_backend_grid"] = grid
        returned["vtk_backend_geo"] = geo
        missingMapper = vcs2vtk.putMaskOnVTKGrid(data1, grid, None, False,
                                                 deep=False)

        # None/False are for color and cellData
        # (sent to vcs2vtk.putMaskOnVTKGrid)
        returned["vtk_backend_missing_mapper"] = (missingMapper, None, False)

        w = vcs2vtk.generateVectorArray(data1, data2, grid)

        grid.GetPointData().AddArray(w)

        # Vector attempt
        l = self._gm.line
        if l is None:
            l = "default"
        try:
            l = vcs.getline(l)
            lwidth = l.width[0]  # noqa
            lcolor = l.color[0]
            lstyle = l.type[0]  # noqa
        except:
            lstyle = "solid"  # noqa
            lwidth = 1.  # noqa
            lcolor = 0
        if self._gm.linewidth is not None:
            lwidth = self._gm.linewidth  # noqa
        if self._gm.linecolor is not None:
            lcolor = self._gm.linecolor

        arrow = vtk.vtkGlyphSource2D()
        arrow.SetGlyphTypeToArrow()
        arrow.SetOutputPointsPrecision(vtk.vtkAlgorithm.DOUBLE_PRECISION)
        arrow.FilledOff()

        glyphFilter = vtk.vtkGlyph2D()
        glyphFilter.SetInputData(grid)
        glyphFilter.SetInputArrayToProcess(1, 0, 0, 0, "vectors")
        glyphFilter.SetSourceConnection(arrow.GetOutputPort())
        glyphFilter.SetVectorModeToUseVector()

        # Rotate arrows to match vector data:
        glyphFilter.OrientOn()

        # Scale to vector magnitude:
        glyphFilter.SetScaleModeToScaleByVector()
        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()
        data = glyphFilter.GetOutput()

        mapper.SetInputData(data)
        act = vtk.vtkActor()
        act.SetMapper(mapper)

        cmap = self.getColorMap()
        r, g, b, a = cmap.index[lcolor]
        act.GetProperty().SetColor(r / 100., g / 100., b / 100.)

        x1, x2, y1, y2 = vcs.utils.getworldcoordinates(self._gm, data1.getAxis(-1),
                                                       data1.getAxis(-2))
        if geo is None:
            wc = [x1, x2, y1, y2]
        else:
            xrange = list(act.GetXRange())
            yrange = list(act.GetYRange())
            wc = [xrange[0], xrange[1], yrange[0], yrange[1]]

        act = vcs2vtk.doWrap(act, wc, self._dataWrapModulo)

        self._context().fitToViewport(act, [tmpl.data.x1, tmpl.data.x2,
                                            tmpl.data.y1, tmpl.data.y2],
                                      wc=wc,
                                      priority=tmpl.data.priority,
                                      create_renderer=True)

        returned.update(self._context().renderTemplate(tmpl, data1,
                                                       self._gm, taxis, zaxis))

        if self._context().canvas._continents is None:
            continents = False
        if continents:
            self._context().plotContinents(x1, x2, y1, y2, projection,
                                           self._dataWrapModulo, tmpl)

        returned["vtk_backend_actors"] = [[act, [x1, x2, y1, y2]]]
        returned["vtk_backend_glyphfilters"] = [glyphFilter]
        returned["vtk_backend_luts"] = [[None, None]]

        return returned
Exemplo n.º 28
0
def prepMarker(renWin, ren, marker, cmap=None):
    n = prepPrimitive(marker)
    if n == 0:
        return
    for i in range(n):
        ## Creates the glyph
        g = vtk.vtkGlyph2D()
        markers = vtk.vtkPolyData()
        x = marker.x[i]
        y = marker.y[i]
        c = marker.color[i]
        s = marker.size[i] / float(max(marker.worldcoordinate)) * 10.
        t = marker.type[i]
        N = max(len(x), len(y))
        for a in [x, y]:
            while len(a) < n:
                a.append(a[-1])
        pts = vtk.vtkPoints()
        geo, pts = project(pts, marker.projection, marker.worldcoordinate)
        for j in range(N):
            pts.InsertNextPoint(x[j], y[j], 0.)
        markers.SetPoints(pts)

        #  Type
        ## Ok at this point generates the source for glpyh
        gs = vtk.vtkGlyphSource2D()
        pd = None
        if t == 'dot':
            gs.SetGlyphTypeToCircle()
            gs.FilledOn()
        elif t == 'circle':
            gs.SetGlyphTypeToCircle()
            gs.FilledOff()
        elif t == 'plus':
            gs.SetGlyphTypeToCross()
            gs.FilledOff()
        elif t == 'cross':
            gs.SetGlyphTypeToCross()
            gs.SetRotationAngle(45)
            gs.FilledOff()
        elif t[:6] == 'square':
            gs.SetGlyphTypeToSquare()
            gs.FilledOff()
        elif t[:7] == 'diamond':
            gs.SetGlyphTypeToDiamond()
            gs.FilledOff()
        elif t[:8] == 'triangle':
            gs.SetGlyphTypeToTriangle()
            if t[9] == "d":
                gs.SetRotationAngle(180)
            elif t[9] == "l":
                gs.SetRotationAngle(90)
            elif t[9] == "r":
                gs.SetRotationAngle(-90)
            elif t[9] == "u":
                gs.SetRotationAngle(0)
        elif t == "hurricane":
            s = s / 10.
            ds = vtk.vtkDiskSource()
            ds.SetInnerRadius(.55 * s)
            ds.SetOuterRadius(1.01 * s)
            ds.SetCircumferentialResolution(90)
            ds.SetRadialResolution(30)
            gf = vtk.vtkGeometryFilter()
            gf.SetInputConnection(ds.GetOutputPort())
            gf.Update()
            pd1 = gf.GetOutput()
            apd = vtk.vtkAppendPolyData()
            apd.AddInputData(pd1)
            pts = vtk.vtkPoints()
            pd = vtk.vtkPolyData()
            polygons = vtk.vtkCellArray()
            add_angle = numpy.pi / 360.
            coords = []
            angle1 = .6 * numpy.pi
            angle2 = .88 * numpy.pi
            while angle1 <= angle2:
                coords.append([
                    s * 2 + 2 * s * numpy.cos(angle1),
                    2 * s * numpy.sin(angle1)
                ])
                angle1 += add_angle
            angle1 = .79 * numpy.pi
            angle2 = .6 * numpy.pi
            while angle1 >= angle2:
                coords.append([
                    s * 2.25 + s * 4 * numpy.cos(angle1),
                    -s * 2 + s * 4 * numpy.sin(angle1)
                ])
                angle1 -= add_angle
            poly = genPoly(coords, pts, filled=True)
            polygons.InsertNextCell(poly)
            coords = []
            angle1 = 1.6 * numpy.pi
            angle2 = 1.9 * numpy.pi
            while angle1 <= angle2:
                coords.append([
                    -s * 2 + s * 2 * numpy.cos(angle1),
                    s * 2 * numpy.sin(angle1)
                ])
                angle1 += add_angle
            angle1 = 1.8 * numpy.pi
            angle2 = 1.6 * numpy.pi
            while angle1 >= angle2:
                coords.append([
                    -s * 2.27 + s * 4 * numpy.cos(angle1),
                    s * 2 + s * 4 * numpy.sin(angle1)
                ])
                angle1 -= add_angle
            poly = genPoly(coords, pts, filled=True)
            polygons.InsertNextCell(poly)
            pd.SetPoints(pts)
            pd.SetPolys(polygons)
            apd.AddInputData(pd)
            apd.Update()
            g.SetSourceData(apd.GetOutput())
        elif t in ["w%.2i" % x for x in range(203)]:
            ## WMO marker
            params = wmo[t]
            pts = vtk.vtkPoints()
            pd = vtk.vtkPolyData()
            polys = vtk.vtkCellArray()
            lines = vtk.vtkCellArray()
            #Lines first
            for l in params["line"]:
                coords = numpy.array(zip(*l)) * s / 30.
                line = genPoly(coords.tolist(), pts, filled=False)
                lines.InsertNextCell(line)
            for l in params["poly"]:
                coords = numpy.array(zip(*l)) * s / 30.
                line = genPoly(coords.tolist(), pts, filled=True)
                polys.InsertNextCell(line)
            geo, pts = project(pts, marker.projection, marker.worldcoordinate)
            pd.SetPoints(pts)
            pd.SetPolys(polys)
            pd.SetLines(lines)
            g.SetSourceData(pd)
        else:
            warnings.warn("unknown marker type: %s, using dot" % t)
            gs.SetGlyphTypeToCircle()
            gs.FilledOn()
        if t[-5:] == "_fill":
            gs.FilledOn()
        gs.SetScale(s)
        gs.Update()

        if pd is None:
            g.SetSourceConnection(gs.GetOutputPort())
        g.SetInputData(markers)

        a = vtk.vtkActor()
        m = vtk.vtkPolyDataMapper()
        m.SetInputConnection(g.GetOutputPort())
        m.Update()
        a.SetMapper(m)
        p = a.GetProperty()
        #Color
        if cmap is None:
            if marker.colormap is not None:
                cmap = marker.colormap
            else:
                cmap = 'default'
        if isinstance(cmap, str):
            cmap = vcs.elements["colormap"][cmap]
        color = cmap.index[c]
        p.SetColor([C / 100. for C in color])
        ren.AddActor(a)
        fitToViewport(a,
                      ren,
                      marker.viewport,
                      wc=marker.worldcoordinate,
                      geo=geo)
    return
Exemplo n.º 29
0
for i in range(m.shape[0]):
  lst = vtk.vtkIdList()
  for j in range(4):
    lst.InsertNextId(i*4+j)
  ## ??? TODO ??? when 3D use CUBE?
  ug.InsertNextCell(vtk.VTK_QUAD,lst)

#ug.GetPointData().SetVectors(data)

if p.debug:
  vcs2vtk.dump2VTK(ug)

## Vector attempt
arrow = vtk.vtkArrowSource()
arrow.Update()
glyphFilter = vtk.vtkGlyph2D()
glyphFilter.SetSourceConnection(arrow.GetOutputPort())
glyphFilter.OrientOn()
glyphFilter.SetVectorModeToUseVector()
glyphFilter.SetInputArrayToProcess(1,0,0,0,"vectors")
glyphFilter.SetScaleFactor(2)
glyphFilter.SetInputData(ug)


#Data range
mn,mx = s.min(),s.max()

#Ok now we have grid and data let's use the mapper
mapper = vtk.vtkPolyDataMapper()

mapper.SetInputConnection(glyphFilter.GetOutputPort())
Exemplo n.º 30
0
import readline
import rlcompleter
readline.parse_and_bind("tab: complete")
import vtk
import vcs2vtk

renWin = vtk.vtkRenderWindow()
ren = vtk.vtkRenderer()
renWin.AddRenderer(ren)

## glyph
g=vtk.vtkGlyph2D()

##Glytph Source

##Locations
pts = vtk.vtkPoints()
pts.InsertNextPoint(0,0,0)
pts.InsertNextPoint(5,0,0)
pts.InsertNextPoint(10,0,0)
pd = vtk.vtkPolyData()
pd.SetPoints(pts)
g.SetInputData(pd)


##Glyph Source (triangle here)
psrc = vtk.vtkPoints()
psrc.InsertNextPoint(0,0,0)
psrc.InsertNextPoint(1,0,0)
psrc.InsertNextPoint(0.5,1,0)
psrc.InsertNextPoint(0,0,0)
Exemplo n.º 31
0
    def _plotInternal(self):
        """Overrides baseclass implementation."""
        # Preserve time and z axis for plotting these inof in rendertemplate
        projection = vcs.elements["projection"][self._gm.projection]

        zaxis, taxis = self.getZandT()

        # Streamline color
        if (not self._gm.coloredbyvector):
            ln_tmp = self._gm.linetype
            if ln_tmp is None:
                ln_tmp = "default"
            try:
                ln_tmp = vcs.getline(ln_tmp)
                lwidth = ln_tmp.width[0]  # noqa
                lcolor = ln_tmp.color[0]
                lstyle = ln_tmp.type[0]  # noqa
            except Exception:
                lstyle = "solid"  # noqa
                lwidth = 1.  # noqa
                lcolor = [0., 0., 0., 100.]
            if self._gm.linewidth is not None:
                lwidth = self._gm.linewidth  # noqa
            if self._gm.linecolor is not None:
                lcolor = self._gm.linecolor

        # The unscaled continent bounds were fine in the presence of axis
        # conversion, so save them here
        continentBounds = vcs2vtk.computeDrawAreaBounds(
            self._vtkDataSetBoundsNoMask, self._context_flipX,
            self._context_flipY)

        # Only scaling the data in the presence of axis conversion changes
        # the seed points in any other cases, and thus results in plots
        # different from the baselines but still fundamentally sound, it
        # seems.  Always scaling the data results in no differences in the
        # plots between Context2D and the old baselines.

        # Transform the input data
        T = vtk.vtkTransform()
        T.Scale(self._context_xScale, self._context_yScale, 1.)

        self._vtkDataSetFittedToViewport = vcs2vtk.applyTransformationToDataset(
            T, self._vtkDataSetFittedToViewport)
        self._vtkDataSetBoundsNoMask = self._vtkDataSetFittedToViewport.GetBounds(
        )

        polydata = self._vtkDataSetFittedToViewport
        plotting_dataset_bounds = self.getPlottingBounds()
        x1, x2, y1, y2 = plotting_dataset_bounds
        vp = self._resultDict.get('ratio_autot_viewport', [
            self._template.data.x1, self._template.data.x2,
            self._template.data.y1, self._template.data.y2
        ])

        # view and interactive area
        view = self._context().contextView
        area = vtk.vtkInteractiveArea()
        view.GetScene().AddItem(area)

        drawAreaBounds = vcs2vtk.computeDrawAreaBounds(
            self._vtkDataSetBoundsNoMask, self._context_flipX,
            self._context_flipY)

        [renWinWidth, renWinHeight] = self._context().renWin.GetSize()
        geom = vtk.vtkRecti(int(round(vp[0] * renWinWidth)),
                            int(round(vp[2] * renWinHeight)),
                            int(round((vp[1] - vp[0]) * renWinWidth)),
                            int(round((vp[3] - vp[2]) * renWinHeight)))

        vcs2vtk.configureContextArea(area, drawAreaBounds, geom)

        dataLength = polydata.GetLength()

        if (not self._gm.evenlyspaced):
            # generate random seeds in a circle centered in the center of
            # the bounding box for the data.

            # by default vtkPointSource uses a global random source in vtkMath which is
            # seeded only once. It makes more sense to seed a random sequence each time you draw
            # the streamline plot.
            pointSequence = vtk.vtkMinimalStandardRandomSequence()
            pointSequence.SetSeedOnly(1177)  # replicate the seed from vtkMath

            seed = vtk.vtkPointSource()
            seed.SetNumberOfPoints(self._gm.numberofseeds)
            seed.SetCenter(polydata.GetCenter())
            seed.SetRadius(dataLength / 2.0)
            seed.SetRandomSequence(pointSequence)
            seed.Update()
            seedData = seed.GetOutput()

            # project all points to Z = 0 plane
            points = seedData.GetPoints()
            for i in range(0, points.GetNumberOfPoints()):
                p = list(points.GetPoint(i))
                p[2] = 0
                points.SetPoint(i, p)

        if (self._gm.integratortype == 0):
            integrator = vtk.vtkRungeKutta2()
        elif (self._gm.integratortype == 1):
            integrator = vtk.vtkRungeKutta4()
        else:
            if (self._gm.evenlyspaced):
                warnings.warn(
                    "You cannot use RungeKutta45 for evenly spaced streamlines."
                    "Using RungeKutta4 instead")
                integrator = vtk.vtkRungeKutta4()
            else:
                integrator = vtk.vtkRungeKutta45()

        if (self._gm.evenlyspaced):
            streamer = vtk.vtkEvenlySpacedStreamlines2D()
            startseed = self._gm.startseed \
                if self._gm.startseed else polydata.GetCenter()
            streamer.SetStartPosition(startseed)
            streamer.SetSeparatingDistance(self._gm.separatingdistance)
            streamer.SetSeparatingDistanceRatio(
                self._gm.separatingdistanceratio)
            streamer.SetClosedLoopMaximumDistance(
                self._gm.closedloopmaximumdistance)
        else:
            # integrate streamlines on normalized vector so that
            # IntegrationTime stores distance
            streamer = vtk.vtkStreamTracer()
            streamer.SetSourceData(seedData)
            streamer.SetIntegrationDirection(self._gm.integrationdirection)
            streamer.SetMinimumIntegrationStep(self._gm.minimumsteplength)
            streamer.SetMaximumIntegrationStep(self._gm.maximumsteplength)
            streamer.SetMaximumError(self._gm.maximumerror)
            streamer.SetMaximumPropagation(dataLength *
                                           self._gm.maximumstreamlinelength)

        streamer.SetInputData(polydata)
        streamer.SetInputArrayToProcess(0, 0, 0, 0, "vector")
        streamer.SetIntegrationStepUnit(self._gm.integrationstepunit)
        streamer.SetInitialIntegrationStep(self._gm.initialsteplength)
        streamer.SetMaximumNumberOfSteps(self._gm.maximumsteps)
        streamer.SetTerminalSpeed(self._gm.terminalspeed)
        streamer.SetIntegrator(integrator)

        # add arc_length to streamlines
        arcLengthFilter = vtk.vtkAppendArcLength()
        arcLengthFilter.SetInputConnection(streamer.GetOutputPort())

        arcLengthFilter.Update()
        streamlines = arcLengthFilter.GetOutput()

        # glyph seed points
        contour = vtk.vtkContourFilter()
        contour.SetInputConnection(arcLengthFilter.GetOutputPort())
        contour.SetValue(0, 0.001)
        if (streamlines.GetNumberOfPoints()):
            r = streamlines.GetPointData().GetArray("arc_length").GetRange()
            numberofglyphsoneside = self._gm.numberofglyphs // 2
            for i in range(1, numberofglyphsoneside):
                contour.SetValue(i, r[1] / numberofglyphsoneside * i)
        else:
            warnings.warn(
                "No streamlines created. "
                "The 'startseed' parameter needs to be inside the domain and "
                "not over masked data.")
        contour.SetInputArrayToProcess(0, 0, 0, 0, "arc_length")

        # arrow glyph source
        glyph2DSource = vtk.vtkGlyphSource2D()
        glyph2DSource.SetGlyphTypeToTriangle()
        glyph2DSource.SetRotationAngle(-90)
        glyph2DSource.SetFilled(self._gm.filledglyph)

        # arrow glyph adjustment
        transform = vtk.vtkTransform()
        transform.Scale(1., self._gm.glyphbasefactor, 1.)
        transformFilter = vtk.vtkTransformFilter()
        transformFilter.SetInputConnection(glyph2DSource.GetOutputPort())
        transformFilter.SetTransform(transform)
        transformFilter.Update()
        glyphLength = transformFilter.GetOutput().GetLength()

        #  drawing the glyphs at the seed points
        glyph = vtk.vtkGlyph2D()
        glyph.SetInputConnection(contour.GetOutputPort())
        glyph.SetInputArrayToProcess(1, 0, 0, 0, "vector")
        glyph.SetSourceData(transformFilter.GetOutput())
        glyph.SetScaleModeToDataScalingOff()
        glyph.SetScaleFactor(dataLength * self._gm.glyphscalefactor /
                             glyphLength)
        glyph.SetColorModeToColorByVector()

        glyphMapper = vtk.vtkPolyDataMapper()
        glyphActor = vtk.vtkActor()

        mapper = vtk.vtkPolyDataMapper()
        act = vtk.vtkActor()

        glyph.Update()
        glyphDataset = glyph.GetOutput()
        streamer.Update()
        lineDataset = streamer.GetOutput()

        deleteLineColors = False
        deleteGlyphColors = False

        # color the streamlines and glyphs
        cmap = self.getColorMap()
        if (self._gm.coloredbyvector):
            numLevels = len(self._contourLevels) - 1
            while len(self._contourColors) < numLevels:
                self._contourColors.append(self._contourColors[-1])

            lut = vtk.vtkLookupTable()
            lut.SetNumberOfTableValues(numLevels)
            for i in range(numLevels):
                r, g, b, a = self.getColorIndexOrRGBA(cmap,
                                                      self._contourColors[i])
                lut.SetTableValue(i, r / 100., g / 100., b / 100., a / 100.)
            lut.SetVectorModeToMagnitude()
            if numpy.allclose(self._contourLevels[0], -1.e20):
                lmn = self._vectorRange[0]
            else:
                lmn = self._contourLevels[0][0]
            if numpy.allclose(self._contourLevels[-1], 1.e20):
                lmx = self._vectorRange[1]
            else:
                lmx = self._contourLevels[-1][-1]
            lut.SetRange(lmn, lmx)

            mapper.ScalarVisibilityOn()
            mapper.SetLookupTable(lut)
            mapper.UseLookupTableScalarRangeOn()
            mapper.SetScalarModeToUsePointFieldData()
            mapper.SelectColorArray("vector")

            lineAttrs = lineDataset.GetPointData()
            lineData = lineAttrs.GetArray("vector")

            if lineData and numLevels:
                lineColors = lut.MapScalars(lineData,
                                            vtk.VTK_COLOR_MODE_DEFAULT, 0)
                deleteLineColors = True
            else:
                print(
                    'WARNING: streamline pipeline cannot map scalars for "lineData", using solid color'
                )
                numTuples = lineDataset.GetNumberOfPoints()
                color = [0, 0, 0, 255]
                lineColors = vcs2vtk.generateSolidColorArray(numTuples, color)

            glyphMapper.ScalarVisibilityOn()
            glyphMapper.SetLookupTable(lut)
            glyphMapper.UseLookupTableScalarRangeOn()
            glyphMapper.SetScalarModeToUsePointFieldData()
            glyphMapper.SelectColorArray("VectorMagnitude")

            glyphAttrs = glyphDataset.GetPointData()
            glyphData = glyphAttrs.GetArray("VectorMagnitude")

            if glyphData and numLevels:
                glyphColors = lut.MapScalars(glyphData,
                                             vtk.VTK_COLOR_MODE_DEFAULT, 0)
                deleteGlyphColors = True
            else:
                print(
                    'WARNING: streamline pipeline cannot map scalars for "glyphData", using solid color'
                )
                numTuples = glyphDataset.GetNumberOfPoints()
                color = [0, 0, 0, 255]
                glyphColors = vcs2vtk.generateSolidColorArray(numTuples, color)
        else:
            mapper.ScalarVisibilityOff()
            glyphMapper.ScalarVisibilityOff()
            if isinstance(lcolor, (list, tuple)):
                r, g, b, a = lcolor
            else:
                r, g, b, a = cmap.index[lcolor]
            act.GetProperty().SetColor(r / 100., g / 100., b / 100.)
            glyphActor.GetProperty().SetColor(r / 100., g / 100., b / 100.)

            fixedColor = [
                int((r / 100.) * 255),
                int((g / 100.) * 255),
                int((b / 100.) * 255), 255
            ]

            numTuples = lineDataset.GetNumberOfPoints()
            lineColors = vcs2vtk.generateSolidColorArray(numTuples, fixedColor)

            numTuples = glyphDataset.GetNumberOfPoints()
            glyphColors = vcs2vtk.generateSolidColorArray(
                numTuples, fixedColor)

        # Add the streamlines
        lineItem = vtk.vtkPolyDataItem()
        lineItem.SetPolyData(lineDataset)
        lineItem.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_POINT_DATA)
        lineItem.SetMappedColors(lineColors)
        if deleteLineColors:
            lineColors.FastDelete()
        area.GetDrawAreaItem().AddItem(lineItem)

        # Add the glyphs
        glyphItem = vtk.vtkPolyDataItem()
        glyphItem.SetPolyData(glyphDataset)
        glyphItem.SetScalarMode(vtk.VTK_SCALAR_MODE_USE_POINT_DATA)
        glyphItem.SetMappedColors(glyphColors)
        if deleteGlyphColors:
            glyphColors.FastDelete()
        area.GetDrawAreaItem().AddItem(glyphItem)

        plotting_dataset_bounds = self.getPlottingBounds()
        vp = self._resultDict.get('ratio_autot_viewport', [
            self._template.data.x1, self._template.data.x2,
            self._template.data.y1, self._template.data.y2
        ])

        kwargs = {
            'vtk_backend_grid':
            self._vtkDataSet,
            'dataset_bounds':
            self._vtkDataSetBounds,
            'plotting_dataset_bounds':
            plotting_dataset_bounds,
            "vtk_dataset_bounds_no_mask":
            self._vtkDataSetBoundsNoMask,
            'vtk_backend_geo':
            self._vtkGeoTransform,
            "vtk_backend_draw_area_bounds":
            continentBounds,
            "vtk_backend_viewport_scale":
            [self._context_xScale, self._context_yScale]
        }
        if ('ratio_autot_viewport' in self._resultDict):
            kwargs["ratio_autot_viewport"] = vp
        self._resultDict.update(self._context().renderTemplate(
            self._template, self._data1, self._gm, taxis, zaxis, **kwargs))
        if (self._gm.coloredbyvector):
            self._resultDict.update(self._context().renderColorBar(
                self._template, self._contourLevels, self._contourColors, None,
                self.getColorMap()))

        kwargs['xaxisconvert'] = self._gm.xaxisconvert
        kwargs['yaxisconvert'] = self._gm.yaxisconvert
        if self._data1.getAxis(-1).isLongitude() and self._data1.getAxis(
                -2).isLatitude():
            self._context().plotContinents(
                self._plot_kargs.get("continents", self._useContinents),
                plotting_dataset_bounds, projection, self._dataWrapModulo, vp,
                self._template.data.priority, **kwargs)
        self._resultDict["vtk_backend_actors"] = [[
            lineItem, plotting_dataset_bounds
        ]]
        self._resultDict["vtk_backend_luts"] = [[None, None]]