vtk Transform Matirx

#include <vtkLineSource.h>
#include <vtkPolyData.h>
#include <vtkSmartPointer.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkProperty.h>
#include <vtkAxesActor.h>
#include <vtkConeSource.h>
#include <vtkTextActor.h>
#include <vtkTextProperty.h>
#include <vtkTransform.h>

#include <vtkSphereSource.h>


VTK_MODULE_INIT(vtkRenderingOpenGL2);
VTK_MODULE_INIT(vtkInteractionStyle);
VTK_MODULE_INIT(vtkRenderingFreeType);
VTK_MODULE_INIT(vtkRenderingVolumeOpenGL2);






int mainTT()  //测试Matrix
{
	
	vtkSmartPointer<vtkConeSource> coneSource =
		vtkSmartPointer<vtkConeSource>::New();
	coneSource->SetRadius(.2);
	coneSource->SetHeight(.5);
	coneSource->SetCenter(0, 0, 0);
	vtkSmartPointer<vtkPolyDataMapper> coneMapper =
		vtkSmartPointer<vtkPolyDataMapper>::New();
	coneMapper->SetInputConnection(coneSource->GetOutputPort());
	vtkSmartPointer<vtkActor> coneActor =
		vtkSmartPointer<vtkActor>::New();
	coneActor->SetMapper(coneMapper);

	vtkSmartPointer<vtkAxesActor> axesActor =
		vtkSmartPointer<vtkAxesActor>::New();
	axesActor->SetPosition(0, 0, 0);
	axesActor->SetTotalLength(1, 1, 1);
	axesActor->SetShaftType(0);
	axesActor->SetAxisLabels(0);
	axesActor->SetCylinderRadius(0.02);

	vtkSmartPointer<vtkTransform> trans =
		vtkSmartPointer<vtkTransform>::New();

	//trans->PostMultiply();
	//trans->RotateZ(45);
	trans->Translate(1, 1, 0);
	trans->Update();

	vtkSmartPointer<vtkTransform> trans2 =
		vtkSmartPointer<vtkTransform>::New();

	
	
	trans2->Translate(1, 1, 0);
	trans2->RotateZ(45);
	trans2->GetMatrix();
	vtkSmartPointer<vtkMatrix4x4> Matrix = vtkSmartPointer<vtkMatrix4x4>::New();
	Matrix->DeepCopy(trans2->GetMatrix());
	//vtkMatrix4x4::Multiply4x4(Matrix, Matrix, Matrix);
	//trans->Concatenate(Matrix);
	vtkSmartPointer<vtkMatrix4x4> inverseMatrix = vtkSmartPointer<vtkMatrix4x4>::New();
	//vtkMatrix4x4::Invert(Matrix, inverseMatrix);
	//trans->Concatenate(inverseMatrix);
	vtkMatrix4x4::Multiply4x4(trans->GetMatrix(), trans2->GetMatrix(), inverseMatrix);
	trans->SetMatrix(inverseMatrix);
	coneActor->SetUserTransform(trans);
	

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

	vtkSmartPointer<vtkRenderWindow> renderWindow =
		vtkSmartPointer<vtkRenderWindow>::New();
	renderWindow->SetSize(800, 400);
	renderWindow->AddRenderer(renderer2);
	vtkSmartPointer<vtkRenderWindowInteractor> renderWindowInteractor =
		vtkSmartPointer<vtkRenderWindowInteractor>::New();
	renderWindowInteractor->SetRenderWindow(renderWindow);

	renderer2->AddActor(axesActor);
	renderer2->AddActor(coneActor);
	renderWindow->Render();
	renderWindowInteractor->Start();

	
	
	
	
	double matrix[16] = { 1,0,0,1,
						 0,1,0,-1,
						 0,0,1,0,
						 1,0,0,1 };
	vtkSmartPointer<vtkMatrix4x4> _resliceMatrix = vtkSmartPointer<vtkMatrix4x4>::New();
	_resliceMatrix->DeepCopy(matrix);
	//_resliceMatrix->Print(std::cout);

	double matrix2[16] = { 1,0,0,3,
						 0,1,0,-1,
						 0,0,1,0,
						 1,0,0,1 };
	vtkSmartPointer<vtkMatrix4x4> _resliceMatrix2 = vtkSmartPointer<vtkMatrix4x4>::New();
	_resliceMatrix2->DeepCopy(matrix2);

	vtkNew<vtkTransform> rotateTransform1;
	rotateTransform1->SetMatrix(matrix);
	vtkNew<vtkTransform> rotateTransform2;
	rotateTransform2->SetMatrix(matrix2);
	rotateTransform2->Print(std::cout);
	//rotateTransform2->PostMultiply();
	rotateTransform2->Concatenate(rotateTransform1);
	rotateTransform2->Print(std::cout);

	//vtkNew<vtkMatrix4x4> inverseMatrix;
	//inverseMatrix->DeepCopy(_resliceMatrix);
	//inverseMatrix->Invert();
	//inverseMatrix->Print(std::cout);


	return EXIT_SUCCESS;
}