vtk 继承vtkActor

我们使用 继承 vtkActor，如果只是简单继承，发现，并不能正常显示，原因是它需要重写几个方法。

下面看一下 vtkActor 这个类几个方法：

//支持标准的渲染方法
 virtual int RenderOpaqueGeometry(vtkViewport *viewport);//不透明的; 
virtual int RenderTranslucentPolygonalGeometry(vtkViewport *viewport);//透明的几何体;
 

virtual void Render(vtkRenderer *, vtkMapper *) {};//这使得这个actor将会被渲染，将会渲染actor's property, texture map and then mapper。property如果没有声明，则会自动创建一个。这个方法的运行将会导致流水线的更新

void ReleaseGraphicsResources(vtkWindow *);//释放由这个actor消耗的图形资源，参数window用来决定那些图形资源将要被释放
 

样例，我写了一个为了实现通过二个点来画一个 圆柱体的Actor

#ifndef hozCylinderActor_h
#define hozCylinderActor_h

#include "vtkActor.h"
#include "vtkCoordinate.h"
#include <vtkPolyDataMapper.h>
#include <vtkSmartPointer.h>
class hozCylinderActor: public vtkActor
{
public:
	vtkTypeMacro(hozCylinderActor, vtkActor);
	//void PrintSelf(ostream& os, vtkIndent indent) override;

	/**
	* Instantiate object.
	*/
	static hozCylinderActor* New();

public:
	 void SetPointStart(double x[3]) { this->SetPointStart(x[0], x[1], x[2]); }
	 void SetPointStart(double x, double y, double z);
	 double* GetPointStart();

	 void SetPointEnd(double x[3]) { this->SetPointEnd(x[0], x[1], x[2]); }
	 void SetPointEnd(double x, double y, double z);
	 double* GetPointEnd();

	vtkSetClampMacro(Radius, double, 0.0, VTK_DOUBLE_MAX);
	vtkGetMacro(Radius, double);


	void Build();

	//@{
	/**
	* Draw the 
	*/
	virtual void Render(vtkRenderer *ren);
	virtual void ReleaseGraphicsResources(vtkWindow *window);
	int RenderOpaqueGeometry(vtkViewport* viewport) override;
 
	int RenderTranslucentPolygonalGeometry(vtkViewport* viewport) override;
 
 
protected:
	hozCylinderActor();
	~hozCylinderActor();

protected:
	vtkCoordinate* PointStartCoordinate;
	vtkCoordinate* PointEndCoordinate;
	double Radius; //minimum radius of tube

	vtkSmartPointer<vtkPolyDataMapper> mMapper;
 
	vtkActor* Device;
};
#endif

#include "hozCylinderActor.h"
#include <vtkRenderer.h>
#include <vtkLineSource.h>
#include <vtkTubeFilter.h>
#include <vtkTriangleFilter.h>
#include <vtkProperty.h>
#include <vtkTexture.h>

hozCylinderActor::hozCylinderActor()
{
	this->PointStartCoordinate = vtkCoordinate::New();
	this->PointStartCoordinate->SetCoordinateSystemToWorld();
	this->PointStartCoordinate->SetValue(0.0, 0.0, 0.0);

	this->PointEndCoordinate = vtkCoordinate::New();
	this->PointEndCoordinate->SetCoordinateSystemToWorld();
	this->PointEndCoordinate->SetValue(0.75, 0.0, 0.0);

	mMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
	this->Device = vtkActor::New();
}


hozCylinderActor::~hozCylinderActor()
{
	this->Device->Delete();
}


void hozCylinderActor::SetPointStart(double x, double y, double z)
{
	this->PointStartCoordinate->SetValue(x, y, z);
}

//---------------------------------------------------------------------------
void hozCylinderActor::SetPointEnd(double x, double y, double z)
{
	this->PointEndCoordinate->SetValue(x, y, z);
}

//---------------------------------------------------------------------------
double* hozCylinderActor::GetPointStart()
{
	return this->PointStartCoordinate->GetValue();
}

//---------------------------------------------------------------------------
double* hozCylinderActor::GetPointEnd()
{
	return this->PointEndCoordinate->GetValue();
}
 
void hozCylinderActor::Build()
{
	vtkSmartPointer<vtkLineSource> lineSource =
		vtkSmartPointer<vtkLineSource>::New();
	lineSource->SetPoint1(PointStartCoordinate->GetValue());
	lineSource->SetPoint2(PointEndCoordinate->GetValue());
	vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
	tubeFilter->SetInputConnection(lineSource->GetOutputPort());
	tubeFilter->SetRadius(Radius);
	tubeFilter->SetNumberOfSides(50);
	tubeFilter->CappingOn();
  
	//Create a mapper and actor for the cylinder
 
  
	mMapper->SetInputConnection(tubeFilter->GetOutputPort());
 
	this->SetMapper(mMapper);
}

void hozCylinderActor::ReleaseGraphicsResources(vtkWindow *window) {
	 
	this->Superclass::ReleaseGraphicsResources(window);
}
int hozCylinderActor::RenderOpaqueGeometry(vtkViewport* viewport)
{
	if (!this->Mapper) {
		return 0;
	}
	if (!this->Property) {
		this->GetProperty();
	}
	if (this->GetIsOpaque()) {
		vtkRenderer *ren = static_cast<vtkRenderer *>(viewport);
		this->Render(ren);
		return 1;
	}
	return 0;
}

 
//-----------------------------------------------------------------------------
// Build the translucent poly actors and render.
//-----------------------------------------------------------------------------
int hozCylinderActor::RenderTranslucentPolygonalGeometry(vtkViewport* viewport)
{
	if (!this->Mapper) {
		return 0;
	}
	if (!this->Property) {
		this->GetProperty();
	}
	if (!this->GetIsOpaque()) {
		vtkRenderer *ren = static_cast<vtkRenderer *>(viewport);
		this->Render(ren);
		return 1;
	}
	return 0;
}
 

void hozCylinderActor::Render(vtkRenderer *ren) {
	this->Property->Render(this, ren);
	this->Device->SetProperty(this->Property);
	this->Property->Render(this, ren);
	if (this->BackfaceProperty) {
		this->BackfaceProperty->BackfaceRender(this, ren);
		this->Device->SetBackfaceProperty(this->BackfaceProperty);
	}
	if (this->Texture) {
		this->Texture->Render(ren);
	}
 
	this->ComputeMatrix();
	this->Device->SetUserMatrix(this->Matrix);
	this->Device->Render(ren, this->Mapper);
 
}
vtkStandardNewMacro(hozCylinderActor);