#include <vtkMath.h>
#include <vtkPoints.h>
#include <vtkPolyData.h>
#include <vtkDelaunay2D.h>
#include <vtkBox.h>
#include <vtkPlane.h>
#include <vtkAppendFilter.h>
#include <vtkClipPolyData.h>
#include <vtkPolyDataMapper.h>
#include <vtkDataSetMapper.h>
#include <vtkImplicitSelectionLoop.h>
#include <vtkActor.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkWin32RenderWindowInteractor.h>
#include <vtkInteractorStyleSwitch.h>

#pragma comment(lib,"OpenGL32.lib")
#pragma comment(lib,"vtksys.lib")
#pragma comment(lib,"vtkCommon.lib")
#pragma comment(lib,"vtkRendering.lib")
#pragma comment(lib,"vtkGraphics.lib")
#pragma comment(lib,"vtkFiltering.lib")
#pragma comment(lib,"vtkIO.lib")
#pragma comment(lib,"vtkjpeg.lib")
#pragma comment(lib,"vtkpng.lib")
#pragma comment(lib,"vtktiff.lib")
#pragma comment(lib,"vtkzlib.lib")
#pragma comment(lib,"vtkexpat.lib")

// Three clip methods
#define USING_4PLANES         0
#define USING_BOX             1 
#define USING_SELECTLOOP      2

// current method
#define CLIPMETHOD            USING_4PLANES

void main()
{
	const vtkIdType nPoints = 1000;
	const double maxXY = 1000.0;
	const double maxZ = 20.0;
	vtkIdType i;

	// generate 1000 random points
	vtkPoints *points = vtkPoints::New();
	points->SetNumberOfPoints(nPoints);
	for (i=0; i<nPoints; i++)
		points->SetPoint(i, vtkMath::Random(0.0, maxXY), vtkMath::Random(0.0, maxXY), vtkMath::Random(0.0, maxZ));

	// create input dataset
	vtkPolyData *inPoly = vtkPolyData::New();
	inPoly->SetPoints(points);
	points->Delete();
	inPoly->ComputeBounds();

	// create delaunay2d
	vtkDelaunay2D *del = vtkDelaunay2D::New();
	del->SetInput(inPoly);
	del->SetTolerance(1.0e-06);

	// Method1: using four planes to clip.
#if CLIPMETHOD == USING_4PLANES
	// append filter
	vtkAppendFilter *af = vtkAppendFilter::New();

	vtkPlane *pln1 = vtkPlane::New();
	pln1->SetOrigin(250, 0, 0);
	pln1->SetNormal(1,0,0);
	vtkClipPolyData *clipper1 = vtkClipPolyData::New();
	clipper1->SetInputConnection(del->GetOutputPort());
	del->Delete();
	clipper1->SetClipFunction(pln1);
	pln1->Delete();
	clipper1->GenerateClipScalarsOn();
	clipper1->GenerateClippedOutputOn();
	af->AddInputConnection(clipper1->GetClippedOutputPort());
	clipper1->Delete();

	vtkPlane *pln2 = vtkPlane::New();
	pln2->SetOrigin(750, 0, 0);
	pln2->SetNormal(-1,0,0);
	vtkClipPolyData *clipper2 = vtkClipPolyData::New();
	clipper2->SetInputConnection(clipper1->GetOutputPort());
	clipper2->SetClipFunction(pln2);
	pln2->Delete();
	clipper2->GenerateClipScalarsOn();
	clipper2->GenerateClippedOutputOn();
	af->AddInputConnection(clipper2->GetClippedOutputPort());
	clipper2->Delete();

	vtkPlane *pln3 = vtkPlane::New();
	pln3->SetOrigin(0, 750, 0);
	pln3->SetNormal(0,-1,0);
	vtkClipPolyData *clipper3 = vtkClipPolyData::New();
	clipper3->SetInputConnection(clipper2->GetOutputPort());
	clipper3->SetClipFunction(pln3);
	pln3->Delete();
	clipper3->GenerateClipScalarsOn();
	clipper3->GenerateClippedOutputOn();
	af->AddInputConnection(clipper3->GetClippedOutputPort());
	clipper3->Delete();

	vtkPlane *pln4 = vtkPlane::New();
	pln4->SetOrigin(0, 250, 0);
	pln4->SetNormal(0,1,0);
	vtkClipPolyData *clipper4 = vtkClipPolyData::New();
	clipper4->SetInputConnection(clipper3->GetOutputPort());
	clipper4->SetClipFunction(pln4);
	pln4->Delete();
	clipper4->GenerateClipScalarsOn();
	clipper4->GenerateClippedOutputOn();
	af->AddInputConnection(clipper4->GetClippedOutputPort());
	clipper4->Delete();

	vtkPolyDataMapper *resetMapper = vtkPolyDataMapper::New();
	resetMapper->SetInputConnection(clipper4->GetOutputPort());
	resetMapper->ScalarVisibilityOff();

	vtkDataSetMapper *clippedMapper = vtkDataSetMapper::New();
	clippedMapper->SetInputConnection(af->GetOutputPort());
	af->Delete();

	// Method2: using a box to clip.
#elif CLIPMETHOD == USING_BOX 
	vtkBox *box = vtkBox::New();
	box->SetBounds(250, 750, 250, 750, 0, maxZ);
	vtkClipPolyData *clipper = vtkClipPolyData::New();
	clipper->SetClipFunction(box);
	box->Delete();
	clipper->SetInputConnection(del->GetOutputPort());
	del->Delete();
	clipper->GenerateClippedOutputOn();
	clipper->GenerateClipScalarsOn();

	vtkPolyDataMapper *resetMapper = vtkPolyDataMapper::New();
	resetMapper->SetInputConnection(clipper->GetOutputPort());
	clipper->Delete();
	resetMapper->ScalarVisibilityOff();

	vtkPolyDataMapper *clippedMapper = vtkPolyDataMapper::New();
	clippedMapper->SetInputConnection(clipper->GetClippedOutputPort());
	clippedMapper->ScalarVisibilityOff();
	// Method3: using a select loop to clip.
#else
	vtkPoints *br = vtkPoints::New();
	br->SetNumberOfPoints(4);
	br->SetPoint(0, 250, 250, 0);
	br->SetPoint(1, 250, 750, 0);
	br->SetPoint(2, 750, 750, 0);
	br->SetPoint(3, 250, 750, 0);

	vtkImplicitSelectionLoop *loop = vtkImplicitSelectionLoop::New();
	loop->SetLoop(br);
	br->Delete();
	loop->SetNormal(0,0,1);

	vtkClipPolyData *clipper = vtkClipPolyData::New();
	clipper->SetClipFunction(loop);
	loop->Delete();
	clipper->SetInputConnection(del->GetOutputPort());
	clipper->GenerateClippedOutputOn();
	clipper->GenerateClipScalarsOn();

	vtkPolyDataMapper *resetMapper = vtkPolyDataMapper::New();
	resetMapper->SetInputConnection(clipper->GetOutputPort());
	clipper->Delete();
	resetMapper->ScalarVisibilityOff();

	vtkPolyDataMapper *clippedMapper = vtkPolyDataMapper::New();
	clippedMapper->SetInputConnection(clipper->GetClippedOutputPort());
	clippedMapper->ScalarVisibilityOff();	
#endif

	// clipped mesh actor
	vtkActor *clippedActor = vtkActor::New();
	clippedActor->SetMapper(clippedMapper);
	clippedMapper->Delete();
	clippedActor->GetProperty()->BackfaceCullingOn();
	clippedActor->GetProperty()->SetColor(0,0,1);

	// the reset mesh actor
	vtkActor *resetActor = vtkActor::New();
	resetActor->SetMapper(resetMapper);
	resetMapper->Delete();
	resetActor->GetProperty()->BackfaceCullingOn();
	resetActor->GetProperty()->SetColor(0,1,0);	

	// renderer
	vtkRenderer *ren = vtkRenderer::New();
	ren->AddActor(resetActor);
	resetActor->Delete();
	ren->AddActor(clippedActor);

	// renderer window
	vtkRenderWindow *renWin = vtkRenderWindow::New();
	renWin->AddRenderer(ren);
	renWin->FullScreenOn();
	renWin->LineSmoothingOn();
	renWin->PointSmoothingOn();		

	// interactor
	vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
	vtkInteractorStyleSwitch *is=(vtkInteractorStyleSwitch *)iren->GetInteractorStyle();
	is->SetCurrentStyleToTrackballCamera();	
	iren->SetRenderWindow(renWin);		
	ren->SetBackground(0.1, 0.2, 0.4);

	// begin run
	iren->Initialize();
	renWin->Render();
	iren->Start();
}