# Cutting/slicing for XML Unstructured Grid Data

**URL:** https://discourse.vtk.org/t/cutting-slicing-for-xml-unstructured-grid-data/3653
**Category:** Support
**Created:** [June 26, 2020, 7:06am UTC](https://discourse.vtk.org/t/cutting-slicing-for-xml-unstructured-grid-data/3653 "2020-06-26T07:06:16Z")
**Posts on this page:** 1
**Page:** 1

<div class="post-metadata">

### Author: ![sugeng](https://discourse.vtk.org/user_avatar/discourse.vtk.org/sugeng/32/2026_2.png) [@sugeng](https://discourse.vtk.org/u/sugeng)
#### Post date: [June 26, 2020, 7:06am UTC](https://discourse.vtk.org/t/cutting-slicing-for-xml-unstructured-grid-data/3653/1 "2020-06-26T07:06:16Z")

</div>

Dear All,

I have a main code for cutting/slicing process using vtkCutter below.

The code in general is working well but the only problem is the scalar values obtained from the input file are not correctly captured by vtkCutter (and its corresponding call back method) indicated by mozaic-like colours.

I tried to find the solution (or the online VTK examples) in the last two weeks but the problem remains unsolved.

Many thanks in advance for your help.

Warm regards,  
Sugeng

#include “vtkActor.h”  
#include “vtkProperty.h”  
#include “vtkCamera.h”  
#include “vtkCutter.h”  
#include “vtkRenderWindow.h”  
#include “vtkRenderWindowInteractor.h”  
#include “vtkRenderer.h”  
#include “vtkUnstructuredGrid.h”  
#include “vtkUnstructuredGridReader.h”  
#include “vtkUnstructuredGridWriter.h”  
#include “vtkXMLUnstructuredGridReader.h”  
#include “vtkXMLUnstructuredGridWriter.h”  
#include “vtkExtractUnstructuredGrid.h”  
#include “vtkDataSetMapper.h”  
#include “vtkInteractorStyleTrackballActor.h”  
#include “vtkInteractorStyleTerrain.h”  
#include “vtkPolyData.h”  
#include “vtkDataSet.h”  
#include “vtkDataSetWriter.h”  
#include “vtkGeometryFilter.h”  
#include “vtkAxes.h”  
#include “vtkLogLookupTable.h”  
#include “vtkPolyDataMapper.h”  
#include “vtkPlane.h”  
#include “vtkCommand.h”  
#include “vtkImplicitPlaneWidget.h”  
#include “vtkScalarBarActor.h”  
#include “vtkCubeAxesActor2D.h”  
#include “vtkPlaneSource.h”

#include “vtkLookUpTable.h”  
#include “vtkNew.h”  
#include “vtkPointData.h”  
#include “vtkPointSource.h”  
#include “vtkRibbonFilter.h”  
#include “vtkStreamTracer.h”  
#include “vtkSmartPointer.h”  
#include \<vtkArrayCalculator.h\>  
#include “vtkCellData.h”

// create callback class to provide implicit plane widget  
// with data interaction as well  
class vtkCutCallback : public vtkCommand  
{  
public:  
static vtkCutCallback \*New()  
{ return new vtkCutCallback; }  
virtual void Execute(vtkObject _caller, unsigned long, void_)  
{  
//call back cutting plane  
vtkImplicitPlaneWidget _planeWidget =  
reinterpret\_cast\<vtkImplicitPlaneWidget_\>(caller);  
planeWidget-\>GetPlane(this-\>Plane);

```
 //call back range of scalar data (min,max)
   cutMapper1->SetScalarRange(cut2->GetOutput()->GetScalarRange());
  
 //call back look up table of mapper
   scalarBar1->SetLookupTable(cutMapper1->GetLookupTable());
  
   this->Actor->VisibilityOn(); 

```

}  
vtkCutCallback():Plane(0),Actor(0){}  
vtkPlane \*Plane;  
vtkActor \*Actor;  
vtkCutter \*cut2;  
vtkPolyDataMapper \*cutMapper1;  
vtkScalarBarActor \*scalarBar1;

};

//main function  
void main(int argc, char \*argv[])  
{

```
char* fname = "..file name here....";

vtkSmartPointer<vtkXMLUnstructuredGridReader> reader =
	vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
reader->SetFileName(fname);
reader->Update();

vtkSmartPointer<vtkExtractUnstructuredGrid> exG = 
	vtkSmartPointer<vtkExtractUnstructuredGrid>::New();
exG->SetInputConnection(reader->GetOutputPort());
exG->SetMerging(1);
exG->Update();

vtkSmartPointer<vtkDataSetMapper> sampleMapper = 
	vtkSmartPointer<vtkDataSetMapper>::New();
sampleMapper->SetInputConnection(exG->GetOutputPort());
sampleMapper->ScalarVisibilityOff();

vtkSmartPointer<vtkProperty> sampleProp =
	vtkSmartPointer<vtkProperty>::New();
sampleProp->SetRepresentationToSurface();
sampleProp->SetOpacity(1);
sampleProp->SetLineWidth(0.1);

vtkSmartPointer<vtkActor> sampleActor=
	vtkSmartPointer<vtkActor>::New();
sampleActor->SetMapper(sampleMapper);
sampleActor->SetProperty(sampleProp);

vtkSmartPointer<vtkPlane> plane =
	vtkSmartPointer<vtkPlane>::New();
plane->SetNormal(0, 0, 1);
plane->SetOrigin(0, 0, 0);

vtkSmartPointer<vtkCutter> cut1 =
	vtkSmartPointer<vtkCutter>::New();
cut1->SetInputConnection(exG->GetOutputPort());
cut1->SetCutFunction(plane);
cut1->GenerateCutScalarsOn();

vtkSmartPointer<vtkPolyDataMapper> cutMapper =
	vtkSmartPointer<vtkPolyDataMapper>::New();
cutMapper->SetScalarRange(cut1->GetOutput()->GetScalarRange());
cutMapper->SetInputConnection(cut1->GetOutputPort());

vtkSmartPointer<vtkScalarBarActor> scalarBar =
	vtkSmartPointer<vtkScalarBarActor>::New();
scalarBar->SetLookupTable(cutMapper->GetLookupTable());
scalarBar->SetTitle("Heads");
(scalarBar->GetPositionCoordinate())->SetValue(0.1, 0.01);
scalarBar->SetOrientationToHorizontal();
scalarBar->SetWidth(0.5);
scalarBar->SetHeight(0.17);

vtkSmartPointer<vtkActor> cutActor =
	vtkSmartPointer<vtkActor>::New();
cutActor->GetProperty()->SetOpacity(1);
cutActor->SetMapper(cutMapper);

vtkSmartPointer<vtkRenderer> ren1 =
	vtkSmartPointer<vtkRenderer>::New();

vtkSmartPointer<vtkRenderWindow> renWin =
	vtkSmartPointer<vtkRenderWindow>::New();
renWin->AddRenderer(ren1);

vtkSmartPointer<vtkRenderWindowInteractor> iren =
	vtkSmartPointer<vtkRenderWindowInteractor>::New();
iren->SetRenderWindow(renWin);

vtkSmartPointer<vtkModCutCallback> myCallback =
	vtkSmartPointer<vtkModCutCallback>::New();
myCallback->Plane = plane;
myCallback->Actor = cutActor;
myCallback->cut2 = cut1;
myCallback->cutMapper1 = cutMapper;
myCallback->scalarBar1 = scalarBar;

vtkSmartPointer<vtkImplicitPlaneWidget> planeWidget =
	vtkSmartPointer<vtkImplicitPlaneWidget>::New();
planeWidget->SetInteractor(iren);
planeWidget->SetPlaceFactor(1.0);
planeWidget->SetInputConnection(exG->GetOutputPort());
planeWidget->PlaceWidget();
planeWidget->SetOrigin(500, 500, 500);
planeWidget->AddObserver(vtkCommand::InteractionEvent, myCallback);

ren1->AddActor(scalarBar);
ren1->AddActor(cutActor);

ren1->SetBackground(0, 0, 0);
renWin->SetSize(1000, 1000);

vtkSmartPointer<vtkCubeAxesActor2D> axes =
	vtkSmartPointer<vtkCubeAxesActor2D>::New();
axes->SetInputConnection(exG->GetOutputPort());
axes->SetCamera(ren1->GetActiveCamera());
axes->SetLabelFormat("%6.4g");
axes->SetFlyModeToOuterEdges();
axes->SetFontFactor(0.8);

// render the image
iren->Initialize();
renWin->Render();
iren->Start();

return EXIT_SUCCESS;

```

}