template<class DATA >
void vtkfig::VectorView::RTBuildVTKPipeline0 ( )
private
be careful here: transform filter transforms vectors as well so one has to transform first without assiging the vector atrribute an assign after transform.
put this into dataset ? So we can immediately get magnitude? CreateMagnitude, CreateComponent(i) Also, we get color scaling by lut.
Definition at line 106 of file vtkfigVectorView.cxx.
   {
     RTCalcTransform();
 
    
     auto transgeometry=vtkSmartPointer<vtkTransformFilter>::New();
     transgeometry->SetInputConnection(data_producer->GetOutputPort());
     transgeometry->SetTransform(transform);
 
    
     auto vector = vtkSmartPointer<vtkAssignAttribute>::New();
     vector->Assign(dataname.c_str(),vtkDataSetAttributes::VECTORS,vtkAssignAttribute::POINT_DATA);
     vector->SetInputConnection(transgeometry->GetOutputPort());
 
 
 
     if (state.show_quiver)
     {
       
       if (!probePolyData)
       {
         throw std::runtime_error("Please dont't forget to set quiver points/grid");
       }
       auto transprobe=vtkSmartPointer<vtkTransformPolyDataFilter>::New();
       transprobe->SetInputDataObject(probePolyData);
       transprobe->SetTransform(transform);
       
       
       
       auto probeFilter = vtkSmartPointer<vtkProbeFilter>::New();
       probeFilter->SetComputeTolerance(true);
       probeFilter->SetSourceConnection(vector->GetOutputPort());
       probeFilter->SetInputConnection(transprobe->GetOutputPort());
       probeFilter->PassPointArraysOn();
 
 
       auto glyph = vtkSmartPointer<vtkGlyph3D>::New();
       glyph->SetInputConnection(probeFilter->GetOutputPort());
       glyph->SetColorModeToColorByVector();
       glyph->SetScaleModeToScaleByVector();
       
       
       if (state.spacedim==2)
       {
         arrow3ds->SetTipResolution(8);
         arrow3ds->SetTipLength(0.35);
         arrow3ds->SetTipRadius(0.15);
         arrow3ds->SetShaftRadius(0.075);
         
         glyph->SetSourceConnection(arrow3d->GetOutputPort());
       }
       else
       {
         arrow3ds->SetTipResolution(16);
         arrow3ds->SetTipLength(0.3);
         arrow3ds->SetTipRadius(0.1);
         arrow3ds->SetShaftRadius(0.025);
         glyph->SetSourceConnection(arrow3d->GetOutputPort());
       }
       // map gridfunction
       auto  mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
       mapper->SetInputConnection(glyph->GetOutputPort());
       mapper->SetLookupTable(quiver_lut);
       mapper->UseLookupTableScalarRangeOn();
       
       
       // create plot quiver actor
       vtkSmartPointer<vtkActor> quiver_actor = vtkSmartPointer<vtkActor>::New();
       quiver_actor->SetMapper(mapper);
       
       
       if (state.show_quiver_colorbar)
         Figure::RTAddActor2D(BuildColorBar(mapper));
       
       // add actors to renderer
       Figure::RTAddActor(quiver_actor);
     }
 
     if (state.show_stream)
     {
       auto calc= vtkSmartPointer<vtkArrayCalculator>::New();
       calc->SetInputConnection(vector->GetOutputPort());
       calc->AddVectorArrayName(dataname.c_str());
 
     std::string func="";
     func+="mag(";
     func+=dataname;
     func+="*1.0)";
 
 
       // std::string func="";
       // func+="mag(";
       // func+=dataname;
       // func+=")";
 
       calc->SetFunction(func.c_str());
       calc->SetResultArrayName((dataname+"magnitude").c_str());
       
       
       auto vecmag = vtkSmartPointer<vtkAssignAttribute>::New();
       vecmag->Assign((dataname+"magnitude").c_str(),vtkDataSetAttributes::SCALARS,vtkAssignAttribute::POINT_DATA);
       vecmag->SetInputConnection(calc->GetOutputPort());
       
       
       auto transseed=vtkSmartPointer<vtkTransformPolyDataFilter>::New();
       transseed->SetInputDataObject(seedPolyData);
       transseed->SetTransform(transform);
       
       
       
       auto stream=vtkSmartPointer<vtkStreamTracer>::New();
       stream->SetInputConnection(vecmag->GetOutputPort());
       stream->SetSourceConnection(transseed->GetOutputPort());
       stream->SetIntegrationStepUnit(vtkStreamTracer::LENGTH_UNIT);
       stream->SetInterpolatorType(vtkStreamTracer::INTERPOLATOR_WITH_CELL_LOCATOR);
       stream->SetMaximumPropagation(state.stream_maximum_propagation);
       stream->SetInitialIntegrationStep(state.stream_initial_integration_step);
       stream->SetMaximumIntegrationStep(state.stream_maximum_integration_step);
       stream->SetIntegrationDirectionToForward();
       stream->SetIntegratorTypeToRungeKutta4();
       stream->SetMaximumNumberOfSteps(state.stream_maximum_number_of_steps);
 
 
       // https://github.com/vejmarie/vtk-7/blob/master/Examples/GUI/Python/StreamlinesWithLineWidget.py
       // streamer = vtk.vtkStreamTracer()
       // streamer.SetInputData(pl3d_output)
       // streamer.SetSourceData(seeds)
       // streamer.SetMaximumPropagation(100)
       // streamer.SetInitialIntegrationStep(.2)
       // streamer.SetIntegrationDirectionToForward()
       // streamer.SetComputeVorticity(1)
       // streamer.SetIntegrator(rk4)
       // rf = vtk.vtkRibbonFilter()
       // rf.SetInputConnection(streamer.GetOutputPort())
       // rf.SetWidth(0.1)
       // rf.SetWidthFactor(5)
       // streamMapper = vtk.vtkPolyDataMapper()
       // streamMapper.SetInputConnection(rf.GetOutputPort())
       // streamMapper.SetScalarRange(pl3d_output.GetScalarRange())
       // streamline = vtk.vtkActor()
       // streamline.SetMapper(streamMapper)
       
       
       if (state.spacedim==2)
       {    
         //stream->SetSurfaceStreamlines(1);
         // works only with point locator
         stream->SetComputeVorticity(false);
       }
       else
       { 
         stream->SetComputeVorticity(true);
       }
       
       
       
       
       auto ribbon=vtkSmartPointer<vtkRibbonFilter>::New();
       ribbon->SetInputConnection(stream->GetOutputPort());
       ribbon->SetWidth(state.stream_ribbonwidth);
       //ribbon->SetVaryWidth(1);
       
       auto  mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
       mapper->SetInputConnection(ribbon->GetOutputPort());
       mapper->ScalarVisibilityOn();
       mapper->SetLookupTable(stream_lut);
       mapper->UseLookupTableScalarRangeOn();
               
       // create plot quiver actor
       vtkSmartPointer<vtkActor> stream_actor = vtkSmartPointer<vtkActor>::New();
       stream_actor->SetMapper(mapper);
       
       
       
       // add actors to renderer
       Figure::RTAddActor(stream_actor);
       if (state.show_stream_colorbar)
         Figure::RTAddActor2D(BuildColorBar(mapper));
       
     }
 
   }
Here is the call graph for this function: