VTK DICOM 手动 测量

#include "vtkDICOMImageReader.h"
#include "vtkPiecewiseFunction.h"
#include "vtkColorTransferFunction.h"
#include "vtkVolumeProperty.h"
#include "vtkVolumeRayCastCompositeFunction.h"
#include "vtkVolumeRayCastMapper.h"
#include "vtkVolume.h"
#include "vtkRenderer.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkImageCast.h"
#include "vtkImageShiftScale.h"
#include "vtkImageShrink3D.h"
#include "vtkFixedPointVolumeRayCastMapper.h"
#include "vtkInteractorStyleTrackballCamera.h"
#include "vtkCellPicker.h"
#include "vtkTextMapper.h"
#include "vtkActor2D.h"
#include "vtkTextProperty.h"
#include "vtkCallbackCommand.h"
#include "vtkCamera.h"
#include "vtkSphereSource.h"
#include "vtkPolyDataMapper.h"
#include "vtkLineSource.h"
#include "vtkProperty.h"
#include <math.h>　
int MouseMotion;
bool pointdown1=false;
vtkRenderer *ren;
vtkRenderWindow *renWin;
vtkRenderWindowInteractor *iren;
vtkCellPicker *picker;
vtkActor2D *textActor;
vtkTextMapper *textMapper;
vtkLineSource *line;
vtkActor *sphereActor1;
vtkActor *sphereActor2;
vtkActor *lineActor ;
vtkVolume *volume;

class PickCommand : public vtkCommand
{
public:

   static PickCommand *New() { return new PickCommand; }
   void Delete() { delete this; }

   virtual void Execute(vtkObject *caller, unsigned long l, void *callData)
   {
       double selpt[3];
       picker->GetSelectionPoint(selpt);
       double x = selpt[0];
       double y = selpt[1];
       double pickPos[3];
       picker->GetPickPosition( pickPos );
       double xp = pickPos[0];
       double yp = pickPos[1];
       double zp = pickPos[2];
	   volume->VisibilityOff();

       if (picker->GetCellId() < 0 )
       {
           textActor->VisibilityOff();
       }
       else
       {
           char text[120];
           sprintf( text, "(%5.5f,  %5.5f,  %5.5f)", xp, yp, zp );
           textMapper->SetInput( text );
           textActor->SetPosition(x, y);
           textActor->VisibilityOn();
       }

	   if (pointdown1==false)
	   {
		   sphereActor1->SetPosition(pickPos) ;
		   sphereActor1->VisibilityOn();
		   lineActor->VisibilityOff();
//		   line->SetPoint1(pickPos);
		   pointdown1=true;
	   }
	   else
	   {
		   sphereActor2->SetPosition(pickPos) ;
		   sphereActor2->VisibilityOn();
//		   line->SetPoint2(pickPos);
//		   lineActor->VisibilityOn();
		   pointdown1=false;
	   }
	   volume->VisibilityOn();
       renWin->Render();
   }
};


void PickerInteractionCallback( vtkObject* vtkNotUsed(object),
                                      unsigned long event,
                                      void* clientdata,
                                      void* vtkNotUsed(calldata) )
{
   vtkInteractorStyleTrackballCamera * style =
		(vtkInteractorStyleTrackballCamera*)clientdata;
   switch( event )
   {
   case vtkCommand::LeftButtonPressEvent:
       MouseMotion = 0;
       style->OnLeftButtonDown();
       break;
   case vtkCommand::RightButtonPressEvent:
	   
		double first[3],second[3];
		sphereActor1->GetPosition(first) ;
		sphereActor2->GetPosition(second) ;

		line->SetPoint1(first[0],first[1],first[2]);
		line->SetPoint2(second[0],second[1],second[2]);
		lineActor->VisibilityOn();

		double length;
		length=sqrt((first[0]-second[0])*(first[0]-second[0])+
		   (first[1]-second[1])*(first[1]-second[1])+
		   (first[2]-second[2])*(first[2]-second[2]));

           char text[120];
           sprintf( text, "The lenght of two points is %5.5f", length);
           textMapper->SetInput( text );

           textActor->SetPosition(10, 10);
           textActor->VisibilityOn();


       style->OnRightButtonDown();
       break;
   case vtkCommand::LeftButtonReleaseEvent:
       if (MouseMotion == 0)
       {
           int *pick = iren->GetEventPosition();
           picker->Pick((double)pick[0], (double)pick[1], 0.0, ren);//拾取操作
       }
       style->OnLeftButtonUp();
       break;
   case vtkCommand::MouseMoveEvent:
       MouseMotion = 1;
       style->OnMouseMove();
       break;
   }
}


void main()
{
  ren = vtkRenderer::New();
  renWin = vtkRenderWindow::New();
	renWin->AddRenderer(ren);

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

  vtkDICOMImageReader   *reader =  vtkDICOMImageReader::New();
	reader->SetDataByteOrderToLittleEndian();
	reader->SetDirectoryName("e://ct");
	reader->SetDataOrigin(0.0, 0.0, 0.0);

  vtkImageShrink3D *Shrink=vtkImageShrink3D::New();
	Shrink->SetInputConnection(reader->GetOutputPort());
	Shrink->SetShrinkFactors(4,4,1);

  vtkImageShiftScale *ShiftScale = vtkImageShiftScale::New();
	ShiftScale->SetInput((vtkDataObject *)Shrink->GetOutput());
	ShiftScale->SetOutputScalarTypeToUnsignedShort();
	ShiftScale->SetShift (2100);
    ShiftScale->ClampOverflowOn();

  reader->Delete();
/*
  vtkPiecewiseFunction *opacityTransferFunction = vtkPiecewiseFunction::New();
	opacityTransferFunction->AddPoint(20, 0.0);
	opacityTransferFunction->AddPoint(255, 0.2);

  vtkColorTransferFunction *colorTransferFunction = vtkColorTransferFunction::New();
	colorTransferFunction->AddRGBPoint(0.0, 0.0, 0.5, 0.0);
    colorTransferFunction->AddRGBPoint(60.0, 1.0, 0.0, 0.0);
    colorTransferFunction->AddRGBPoint(128.0, 0.2, 0.1, 0.9);
    colorTransferFunction->AddRGBPoint(196.0, 0.27, 0.21, 0.1);
    colorTransferFunction->AddRGBPoint(255.0, 0.8, 0.8, 0.8);
*/
	vtkPiecewiseFunction *opacityTransferFunction=
		vtkPiecewiseFunction::New();
		opacityTransferFunction->AddPoint(2069,0.04);
		opacityTransferFunction->AddPoint(2208,0.05);
		opacityTransferFunction->AddPoint(2473,0.84);
		opacityTransferFunction->AddPoint(2745,0.86);
		opacityTransferFunction->AddPoint(3566,0.81);
		opacityTransferFunction->AddPoint(5063,0.72);
		opacityTransferFunction->ClampingOff();
	
	vtkColorTransferFunction *colorTransferFunction=
		vtkColorTransferFunction::New();

		colorTransferFunction->AddRGBPoint(2069,0xff/255.0, 0x31/255.0, 0x2e/255.0);//red
		colorTransferFunction->AddRGBPoint
			(2208,0xff/255.0, 0xff/255.0, 0xff/255.0);//white
		colorTransferFunction->AddRGBPoint
			(2473,0xff/255.0, 0xf4/255.0, 0x78/255.0);//yellow
		
		colorTransferFunction->AddRGBPoint
			(2745,0xff/255.0, 0xff/255.0, 0xff/255.0);
		colorTransferFunction->AddRGBPoint
			(3566,0xff/255.0, 0xff/255.0, 0xff/255.0);
		colorTransferFunction->AddRGBPoint
			(5063,0xfd/255.0, 0xff/255.0, 0xfb/255.0);//half white

  vtkVolumeProperty *volumeProperty = vtkVolumeProperty::New();
  //设定一个体绘容器的属性
	volumeProperty->SetColor(colorTransferFunction);
	volumeProperty->SetScalarOpacity(opacityTransferFunction);
	volumeProperty->ShadeOn();
	volumeProperty->SetInterpolationTypeToLinear();	
	volumeProperty->SetAmbient(0.2);
    volumeProperty->SetDiffuse(0.9);
    volumeProperty->SetSpecular(0.2);
    volumeProperty->SetSpecularPower(10);
	
/*
  vtkVolumeRayCastCompositeFunction *compositeFunction = vtkVolumeRayCastCompositeFunction::New();
	//运行沿着光线合成 

  vtkVolumeRayCastMapper *volumeMapper = vtkVolumeRayCastMapper::New();
	  //体绘制器,特点:slow but accurate 
	  volumeMapper->SetVolumeRayCastFunction(compositeFunction); //体绘光线投射函数
	  volumeMapper->SetInputConnection(ShiftScale->GetOutputPort());//图像数据输入
*/
    vtkFixedPointVolumeRayCastMapper *volumeMapper = vtkFixedPointVolumeRayCastMapper::New();
      volumeMapper->SetInput(ShiftScale->GetOutput());

  volume = vtkVolume::New();
	//表示透示图中的一组三维数据
	  volume->SetMapper(volumeMapper);
	  volume->SetProperty(volumeProperty);
	  volume->PickableOff (); 

   vtkSphereSource *sphere1 = vtkSphereSource::New();
     sphere1->SetRadius(3);

   vtkPolyDataMapper *sphereMapper1 = vtkPolyDataMapper::New(); 
     sphereMapper1->SetInput(sphere1->GetOutput());
     sphereMapper1->GlobalImmediateModeRenderingOn();

   sphereActor1 = vtkActor::New();
     sphereActor1->SetMapper(sphereMapper1);
	 sphereActor1->GetProperty()->SetDiffuseColor(1,0,0);

   vtkSphereSource *sphere2 = vtkSphereSource::New();
     sphere2->SetRadius(3);

   vtkPolyDataMapper *sphereMapper2 = vtkPolyDataMapper::New(); 
     sphereMapper2->SetInput(sphere2->GetOutput());
     sphereMapper2->GlobalImmediateModeRenderingOn();

   sphereActor2 = vtkActor::New();
     sphereActor2->SetMapper(sphereMapper2);
	 sphereActor2->GetProperty()->SetDiffuseColor(1,0,0);

    line=vtkLineSource::New(); 
	  line->SetPoint1(0, 0, 0);
	  line->SetPoint2(0, 0, 0);
	  line->SetResolution(20);

	vtkPolyDataMapper *lineMapper = vtkPolyDataMapper::New();
	  lineMapper->SetInput(line->GetOutput());
	
	lineActor = vtkActor::New();
	  lineActor->SetMapper(lineMapper); 
 	  lineActor->GetProperty()->SetDiffuseColor(0,1,0);

// Create a cell picker.
   PickCommand* pickObserver = PickCommand::New();
   picker = vtkCellPicker::New();
     picker->AddObserver( vtkCommand::EndPickEvent, pickObserver );

// Create a text mapper and actor to display the results of picking.
   textMapper = vtkTextMapper::New();
   vtkTextProperty *tprop = textMapper->GetTextProperty();
     tprop->SetFontFamilyToArial();
     tprop->SetFontSize(12);
     tprop->BoldOn();
//    tprop->ShadowOn();
     tprop->SetColor(1, 0, 0);
   textActor = vtkActor2D::New();
     textActor->VisibilityOff();
     textActor->SetMapper(textMapper);


// Create the Renderer, RenderWindow, and RenderWindowInteractor


   vtkInteractorStyleTrackballCamera *style =
							vtkInteractorStyleTrackballCamera::New();
   vtkCallbackCommand * pickerCommand = vtkCallbackCommand::New();
     pickerCommand->SetClientData(style);
     pickerCommand->SetCallback(PickerInteractionCallback);
     style->AddObserver(vtkCommand::LeftButtonPressEvent, pickerCommand);
     style->AddObserver(vtkCommand::MouseMoveEvent, pickerCommand);
     style->AddObserver(vtkCommand::LeftButtonReleaseEvent, pickerCommand);
     style->AddObserver(vtkCommand::RightButtonPressEvent, pickerCommand);

   iren->SetInteractorStyle(style);
   iren->SetPicker(picker);

	sphereActor1->VisibilityOff();
	sphereActor2->VisibilityOff();
	lineActor->VisibilityOff();

	ren->AddVolume(volume);
	ren->AddActor(sphereActor1);
	ren->AddActor(sphereActor2);
	ren->AddActor(lineActor);
	ren->AddActor2D(textActor);
	ren->SetBackground(1, 1, 1);
	renWin->SetSize(600, 600);
	renWin->Render();

//    iren-> SetStillUpdateRate(0.5);
    iren-> SetDesiredUpdateRate(99);

	iren->Initialize();
	iren->Start();
    ren->ResetCameraClippingRange ();

	volumeMapper->Delete();
	iren->Delete();
	ren->Delete();
	renWin->Delete();
	opacityTransferFunction->Delete();
	volumeProperty->Delete();
//	compositeFunction->Delete();
	volume->Delete();
	colorTransferFunction->Delete();

}