[vtkusers] Iterative closest point transform for point clouds - need some help
Sylvain Jaume
sylvain.jaume at kitware.com
Wed Nov 9 14:31:05 EST 2005
Hi Vikas,
I compiled and executed the test program I sent you before, and it was fine.
Try the attached CMakeLists.txt
Cheers,
Sylvain
Vikas Singh wrote:
>Hi Sylvain and Amy:
>
>thanks a lot for your suggestions. Amy: I think your suggestion worked
>and ICPT seems to work ok now. Only, I cant seem to output the
>transform by something like
>transformer->PrintSelf(std::cout,0); where transformer is an object of
>type vtkTransformPolyDataFilter I am applying to the source dataset of
>ICPT. It gives me an output like Transform: 0x805a2a8. I am not sure
>if its out of the ordinary or...
>
>Sylvain, thanks for taking the time to write a new test file and
>vtkIterativeClosestPoint2.*
>Unfortunately, I couldnt compile it. Even when I put the two files in
>my working directory and updated the makefile appropriately, the
>compilation seemed to have some trouble with the existing VTK
>installation. Then, I retrieved the latest CVS sources and put the two
>files you'd provided in Hybrid/ and reinstalled. The problem still
>seemed to persist. I am not sure how to work around that.
>
>regards,
>
>VS.
>
>On 11/9/05, Amy Squillacote <amy.squillacote at kitware.com> wrote:
>
>
>>At 05:34 PM 11/8/2005, Sylvain Jaume wrote:
>>
>>
>>>Hi Vikas,
>>>
>>>You could define one vertex for every point in your input polydata.
>>>You may as well use the attached code.
>>>
>>>Cheers,
>>>Sylvain
>>>
>>>Vikas Singh wrote:
>>>
>>>
>>>
>>>>Hi Sylvain:
>>>>
>>>>I am sorry but your suggestions are not helping me solve the problem.
>>>>I just started on VTK yesterday, maybe I do not know VTK well enough
>>>>to understand what you're trying to tell me :-)
>>>>
>>>>For instance, your suggestion
>>>>vtkMaskPoints *maskPoints1 = vtkMaskPoints::New();
>>>>maskPoints1->SetInput(polyData1);
>>>>maskPoints1->SetMaximumNumberOfPoints(500);
>>>>maskPoints1->GenerateVerticesOn();
>>>>
>>>>_icpt->SetSource(maskPoints1);
>>>>
>>>>
>>Change the above line to the following.
>>_icpt->SetSource(maskPoints1->GetOutput());
>>
>>
>>
>>
>>>>does not compile. When I replace the last line by typecasting
>>>>maskPoints1 it gives me a seg-fault same as before. I am attaching the
>>>>code - its only about 50-60 lines. See if you can help me here.
>>>>
>>>>regards,
>>>>
>>>>Vikas.
>>>>
>>>>On 11/7/05, Sylvain Jaume <sylvain.jaume at kitware.com> wrote:
>>>>
>>>>
>>>>
>>>>
>>>>>Hi Vikas,
>>>>>
>>>>>You could try to create vertices with vtkMaskPoints before the ICP filter:
>>>>>
>>>>>vtkMaskPoints *maskPoints = vtkMaskPoints::New();
>>>>>maskPoints->SetInput(polyData1);
>>>>>maskPoints->SetMaximumNumberOfPoints(numPoints);
>>>>>maskPoints->GenerateVerticesOn();
>>>>>
>>>>>You don't need to cast polyData1. Use vtkPolyDataMaper instead of
>>>>>vtkDataSetMapper.
>>>>>
>>>>>Cheers,
>>>>>Sylvain
>>>>>
>>>>>Vikas Singh wrote:
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>>Hi Sylvain:
>>>>>>
>>>>>>Unfortunately, that doesnt work. I mentioned that in my email
>>>>>>(attached below) that if I do not do a delaunay triangulation and call
>>>>>>icpt directly as
>>>>>>
>>>>>>_icpt->SetSource(polydata_1);
>>>>>>_icpt->SetTarget(polydata_2);
>>>>>>
>>>>>>it gives me a segmentation fault and the following error message:
>>>>>>ERROR: In /usr/local/VTK/Filtering/vtkCellLocator.cxx, line 1190
>>>>>>vtkCellLocator (0x8093b88): No cells to subdivide.
>>>>>>
>>>>>>Same error message even if I typecast it.
>>>>>>
>>>>>>But If I do a Delaunay, I avoid the error message and seg fault.
>>>>>>However, after applying the transformation on the source cloud set, I
>>>>>>cannot see the point set when it renders it.
>>>>>>See partial code below:
>>>>>>
>>>>>>// Iterative Closest Point Transform
>>>>>>vtkIterativeClosestPointTransform *_icpt =
>>>>>>vtkIterativeClosestPointTransform::New();
>>>>>>_icpt->GetLandmarkTransform()->SetModeToRigidBody();
>>>>>>_icpt->StartByMatchingCentroidsOn();
>>>>>>_icpt->SetMaximumNumberOfIterations(100.);
>>>>>>
>>>>>>// del_1 and del_2 are the delaunay triangulations for first and
>>>>>>second point clouds.
>>>>>>_icpt->SetSource((vtkDataSet *)del_1->GetOutput());
>>>>>>cout << "Calling icpt" << endl;
>>>>>>_icpt->SetTarget((vtkDataSet *)del_2->GetOutput());
>>>>>>
>>>>>>_icpt->Update();
>>>>>>
>>>>>>cout << "done icpt" << endl;
>>>>>>
>>>>>>// Now lets tranform the data
>>>>>>vtkTransformPolyDataFilter* transformer =
>>>>>>vtkTransformPolyDataFilter::New();
>>>>>>transformer->SetTransform(_icpt);
>>>>>>
>>>>>>transformer->SetInput((vtkPolyData*)polydata_1);
>>>>>>transformer->Update();
>>>>>>transformer->PrintSelf(std::cout,0);
>>>>>>
>>>>>>// map for displaying
>>>>>>
>>>>>>vtkDataSetMapper *surface_mapper_1 = vtkDataSetMapper::New();
>>>>>>
>>>>>>//surface_mapper_1->SetInput((vtkDataSet*)del_1->GetOutput());
>>>>>>// if i do this ^^^^^^^^^^^^^ it shows the untransformed first point cloud
>>>>>>// and the one below does not show anything (I want it to show the
>>>>>>// the transformed (aligned) point cloud
>>>>>>surface_mapper_1->SetInput(transformer->GetOutput());
>>>>>>
>>>>>>vtkDataSetMapper *surface_mapper_2 = vtkDataSetMapper::New();
>>>>>>surface_mapper_2->SetInput((vtkDataSet*)_icpt->GetTarget());
>>>>>>
>>>>>>// Create an actor for cloud 1.
>>>>>>vtkActor* actor_1 = vtkActor::New();
>>>>>>actor_1->SetMapper(surface_mapper_1);
>>>>>>actor_1->GetProperty()->SetRepresentationToPoints();
>>>>>>actor_1->GetProperty()->SetColor(1,1,1);
>>>>>>
>>>>>>// create an actor for cloud 2
>>>>>>vtkActor* actor_2 = vtkActor::New();
>>>>>>actor_2->SetMapper(surface_mapper_2);
>>>>>>actor_2->GetProperty()->SetRepresentationToPoints();
>>>>>>actor_2->GetProperty()->SetColor(0,1,1);
>>>>>>
>>>>>>......and then the rendering part.
>>>>>>
>>>>>>
>>>>>>Any suggestions ?
>>>>>>
>>>>>>--Vikas
>>>>>>
>>>>>>
>>>>>>On 11/7/05, Sylvain Jaume <sylvain.jaume at kitware.com> wrote:
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>>Hi Vikas,
>>>>>>>
>>>>>>>vtkIterativeClosestPointTransform gives a transform. You need to apply
>>>>>>>the resulting transform to your input dataset using
>>>>>>>vtkTransformPolyDataFilter. You don't need to use vtkDelaunay3D, nor to
>>>>>>>type cast your datasets.
>>>>>>>
>>>>>>>Cheers,
>>>>>>>Sylvain
>>>>>>>
>>>>>>>Vikas Singh wrote:
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>>Hello!
>>>>>>>>
>>>>>>>>I am a newbie to VTK and need some help with ICPT. Been trying all
>>>>>>>>sorts of things since today morning including the VTK User's guide and
>>>>>>>>the online documentation but nothing has worked so far. Seems to me
>>>>>>>>that the problem is simple for someone who knows VTK well.
>>>>>>>>
>>>>>>>>I am trying to randomly generate point clouds and align them
>>>>>>>>(as a start).
>>>>>>>>
>>>>>>>>vtkPolyData* polydata_1 = vtkPolyData::New();
>>>>>>>>vtkDelaunay3D* del_1 = vtkDelaunay3D::New();
>>>>>>>>vtkPoints* cloud_1 = vtkPoints::New();
>>>>>>>>
>>>>>>>>static float mypoint_1[3];
>>>>>>>>
>>>>>>>>for (int i = 0; i < 50; i++)
>>>>>>>> {
>>>>>>>> mypoint_1[0] = drand48()*50;
>>>>>>>> mypoint_1[1] = drand48()*50;
>>>>>>>> mypoint_1[2] = drand48()*50;
>>>>>>>>
>>>>>>>> cloud_1->InsertNextPoint(mypoint_1);
>>>>>>>> }
>>>>>>>>
>>>>>>>>polydata_1->SetPoints(cloud_1);
>>>>>>>>
>>>>>>>>int num_of_points_1 = polydata_1->GetPoints()->GetNumberOfPoints();
>>>>>>>>cout << "in all, num of points in cloud 1 is " <<
>>>>>>>>num_of_points_1 << endl;
>>>>>>>>
>>>>>>>>del_1->SetInput((vtkPointSet*)polydata_1);
>>>>>>>>del_1->SetTolerance(0.01);
>>>>>>>>del_1->PrintSelf(std::cout,0);
>>>>>>>>
>>>>>>>>I repeat the same for cloud 2 - variable names end with "_2".
>>>>>>>>
>>>>>>>>
>>>>>>>>Then I call ICPT as follows:
>>>>>>>>
>>>>>>>>vtkIterativeClosestPointTransform *_icpt =
>>>>>>>>vtkIterativeClosestPointTransform::New();
>>>>>>>>_icpt->GetLandmarkTransform()->SetModeToRigidBody();
>>>>>>>>_icpt->StartByMatchingCentroidsOn();
>>>>>>>>_icpt->SetMaximumNumberOfIterations(10);
>>>>>>>>
>>>>>>>>_icpt->SetSource((vtkDataSet *)del_1->GetOutput());
>>>>>>>>cout << "Calling icpt" << endl;
>>>>>>>>_icpt->SetTarget((vtkDataSet *)del_2->GetOutput());
>>>>>>>>
>>>>>>>>_icpt->Update();
>>>>>>>>
>>>>>>>>
>>>>>>>>To this it gives me an error
>>>>>>>>
>>>>>>>>ERROR: In
>>>>>>>>/usr/local/VTK/Hybrid/vtkIterativeClosestPointTransform.cxx, line 274
>>>>>>>>vtkIterativeClosestPointTransform (0x80650e0): Can't execute
>>>>>>>>with NULL or empty
>>>>>>>>input
>>>>>>>>
>>>>>>>>I think that up until the delaunay triangulation, it is working ok - I
>>>>>>>>rendered it and it is alright. If I do not do a delaunay triangulation
>>>>>>>>and typecast cloud_1 and cloud_2 directly it never returns from ICPT.
>>>>>>>>
>>>>>>>>any pointers, please?
>>>>>>>>
>>>>>>>>VS.
>>>>>>>>_______________________________________________
>>>>>>>>This is the private VTK discussion list.
>>>>>>>>Please keep messages on-topic. Check the FAQ at:
>>>>>>>>http://www.vtk.org/Wiki/VTK_FAQ
>>>>>>>>Follow this link to subscribe/unsubscribe:
>>>>>>>>http://www.vtk.org/mailman/listinfo/vtkusers
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>_______________________________________________
>>>>>>This is the private VTK discussion list.
>>>>>>Please keep messages on-topic. Check the FAQ at:
>>>>>>http://www.vtk.org/Wiki/VTK_FAQ
>>>>>>Follow this link to subscribe/unsubscribe:
>>>>>>http://www.vtk.org/mailman/listinfo/vtkusers
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>------------------------------------------------------------------------
>>>>>
>>>>>// This example demonstrate the use of VTK data arrays as attribute
>>>>>// data as well as field data. It creates geometry (vtkPolyData) as
>>>>>// well as attribute data explicitly.
>>>>>
>>>>>// first include the required header files for the vtk classes we are using
>>>>>#include "vtkActor.h"
>>>>>#include "vtkCellArray.h"
>>>>>#include "vtkDoubleArray.h"
>>>>>#include "vtkFloatArray.h"
>>>>>#include "vtkIntArray.h"
>>>>>#include "vtkPointData.h"
>>>>>#include "vtkPoints.h"
>>>>>#include "vtkPointSet.h"
>>>>>#include "vtkPolyData.h"
>>>>>#include "vtkPolyDataMapper.h"
>>>>>#include "vtkRenderWindow.h"
>>>>>#include "vtkRenderWindowInteractor.h"
>>>>>#include "vtkRenderer.h"
>>>>>#include "vtkDelaunay3D.h"
>>>>>#include "vtkDataSetMapper.h"
>>>>>#include "vtkOutlineFilter.h"
>>>>>#include "vtkProperty.h"
>>>>>#include "vtkIterativeClosestPointTransform.h"
>>>>>#include "vtkLandmarkTransform.h"
>>>>>#include "vtkTransformPolyDataFilter.h"
>>>>>#include "vtkMaskPoints.h"
>>>>>
>>>>>using namespace std;
>>>>>
>>>>>int main( int argc, char *argv[] )
>>>>>{
>>>>> srand48(time(NULL));
>>>>> cout << "Program Starting" << endl;
>>>>>
>>>>> // Create the dataset. In this case, we create a vtkPolyData for
>>>>>first point cloud
>>>>> vtkPolyData* polydata_1 = vtkPolyData::New();
>>>>> vtkDelaunay3D* del_1 = vtkDelaunay3D::New();
>>>>> vtkPoints* cloud_1 = vtkPoints::New();
>>>>>
>>>>> static float mypoint_1[3];
>>>>>
>>>>> for (int i = 0; i < 500; i++)
>>>>> {
>>>>> mypoint_1[0] = drand48()*50;
>>>>> mypoint_1[1] = drand48()*50;
>>>>> mypoint_1[2] = drand48()*50;
>>>>>
>>>>> cloud_1->InsertNextPoint(mypoint_1);
>>>>> }
>>>>>
>>>>> polydata_1->SetPoints(cloud_1);
>>>>>
>>>>> int num_of_points_1 = polydata_1->GetPoints()->GetNumberOfPoints();
>>>>> cout << "in all, num of points in cloud 1 is " << num_of_points_1 << endl;
>>>>>
>>>>> del_1->SetInput((vtkPointSet*)polydata_1);
>>>>> del_1->SetTolerance(0.01);
>>>>> del_1->Update();
>>>>> del_1->SetAlpha(0);
>>>>> //del_1->BoundingTriangulationOn();
>>>>> //del_1->PrintSelf(std::cout,0);
>>>>>
>>>>> // finished dealing with the first point cloud
>>>>>
>>>>>
>>>>> // Create the dataset. In this case, we create a vtkPolyData for
>>>>>second point cloud
>>>>> vtkPolyData* polydata_2 = vtkPolyData::New();
>>>>> vtkDelaunay3D* del_2 = vtkDelaunay3D::New();
>>>>> vtkPoints* cloud_2 = vtkPoints::New();
>>>>>
>>>>> static float mypoint_2[3];
>>>>>
>>>>> for (int i = 0; i < 500; i++)
>>>>> {
>>>>> mypoint_2[0] = drand48()*50;
>>>>> mypoint_2[1] = drand48()*50;
>>>>> mypoint_2[2] = drand48()*50;
>>>>>
>>>>> cloud_2->InsertNextPoint(mypoint_2);
>>>>> }
>>>>>
>>>>> polydata_2->SetPoints(cloud_2);
>>>>>
>>>>> int num_of_points_2 = polydata_2->GetPoints()->GetNumberOfPoints();
>>>>> cout << "in all, num of points in cloud 2 is " << num_of_points_2 << endl;
>>>>>
>>>>> del_2->SetInput(polydata_2);
>>>>> del_2->SetTolerance(0.01);
>>>>> del_2->Update();
>>>>> del_2->SetAlpha(0);
>>>>> //del_1->BoundingTriangulationOn();
>>>>> //del_2->PrintSelf(std::cout,0);
>>>>>
>>>>> // finished dealing with the second point cloud
>>>>>
>>>>>
>>>>> // Iterative Closest Point Transform
>>>>> vtkIterativeClosestPointTransform *_icpt =
>>>>>vtkIterativeClosestPointTransform::New();
>>>>> _icpt->GetLandmarkTransform()->SetModeToRigidBody();
>>>>> _icpt->StartByMatchingCentroidsOn();
>>>>> //_icpt->SetMaximumMeanDistance(atof(MaxMeanDist->Text.c_str()));
>>>>> _icpt->SetMaximumNumberOfIterations(10.);
>>>>> //_icpt->SetMaximumNumberOfLandmarks(atof(MaxNLandmarks->Text.c_str()));
>>>>>
>>>>> vtkMaskPoints *maskPoints1 = vtkMaskPoints::New();
>>>>> maskPoints1->SetInput(polydata_1);
>>>>> maskPoints1->SetMaximumNumberOfPoints(500);
>>>>> maskPoints1->GenerateVerticesOn();
>>>>>
>>>>> vtkMaskPoints *maskPoints2 = vtkMaskPoints::New();
>>>>> maskPoints2->SetInput(polydata_2);
>>>>> maskPoints2->SetMaximumNumberOfPoints(500);
>>>>> maskPoints2->GenerateVerticesOn();
>>>>>
>>>>> //_icpt->SetSource((vtkDataSet *)del_1->GetOutput());
>>>>> _icpt->SetSource((vtkPolyData *)maskPoints1);
>>>>> cout << "Calling icpt" << endl;
>>>>> //_icpt->SetTarget((vtkDataSet *)del_2->GetOutput());
>>>>> _icpt->SetTarget((vtkPolyData *)maskPoints2);
>>>>>
>>>>> _icpt->SetMeanDistanceModeToAbsoluteValue();
>>>>>//_icpt->PrintSelf(std::cout, 0);
>>>>> _icpt->Update();
>>>>>
>>>>> cout << " Mean distance is " << _icpt->GetMeanDistance() << endl;
>>>>> cout << "done icpt" << endl;
>>>>>
>>>>> // Now lets tranform the data
>>>>> vtkTransformPolyDataFilter* transformer =
>>>>>vtkTransformPolyDataFilter::New();
>>>>> transformer->SetTransform(_icpt);
>>>>>
>>>>> //transformer->SetInput((vtkPolyData*)polydata_1);
>>>>> transformer->SetInput((vtkPolyData*)maskPoints1);
>>>>> transformer->Update();
>>>>> transformer->PrintSelf(std::cout,0);
>>>>>
>>>>>
>>>>> // map for displaying
>>>>>
>>>>> vtkDataSetMapper *surface_mapper_1 = vtkDataSetMapper::New();
>>>>> //surface_mapper_1->SetInput((vtkDataSet*)del_1->GetOutput());
>>>>>
>>>>> surface_mapper_1->SetInput((vtkDataSet*)_icpt->GetSource());
>>>>> //surface_mapper_1->SetInput(transformer->GetOutput());
>>>>> //surface_mapper_1->PrintSelf(std::cout,0);
>>>>>
>>>>> vtkDataSetMapper *surface_mapper_2 = vtkDataSetMapper::New();
>>>>> surface_mapper_2->SetInput((vtkDataSet*)_icpt->GetTarget());
>>>>>//surface_mapper_2->PrintSelf(std::cout,0);
>>>>>
>>>>>
>>>>> //cout << (_icpt->GetSource())->GetCenter() << endl;
>>>>>
>>>>> // Create an actor for cloud 1.
>>>>> vtkActor* actor_1 = vtkActor::New();
>>>>> actor_1->SetMapper(surface_mapper_1);
>>>>> //actor->GetProperty()->SetRepresentationToWireframe();
>>>>> actor_1->GetProperty()->SetRepresentationToPoints();
>>>>> actor_1->GetProperty()->SetColor(1,1,1);
>>>>>
>>>>> // create an actor for cloud 2
>>>>> vtkActor* actor_2 = vtkActor::New();
>>>>> actor_2->SetMapper(surface_mapper_2);
>>>>> //actor->GetProperty()->SetRepresentationToWireframe();
>>>>> actor_2->GetProperty()->SetRepresentationToPoints();
>>>>> actor_2->GetProperty()->SetColor(0,1,1);
>>>>>
>>>>> // Create the rendering objects.
>>>>> vtkRenderer* ren = vtkRenderer::New();
>>>>> ren->AddActor(actor_1);
>>>>> ren->AddActor(actor_2);
>>>>>
>>>>> vtkRenderWindow* renWin = vtkRenderWindow::New();
>>>>> renWin->AddRenderer(ren);
>>>>>
>>>>> vtkRenderWindowInteractor* iren = vtkRenderWindowInteractor::New();
>>>>> iren->SetRenderWindow(renWin);
>>>>> iren->Initialize();
>>>>> iren->Start();
>>>>>
>>>>> // pcoords->Delete();
>>>>> // points->Delete();
>>>>> // strips->Delete();
>>>>> // temperature->Delete();
>>>>> // vorticity->Delete();
>>>>> // polydata->Delete();
>>>>> // mapper->Delete();
>>>>> actor_1->Delete();
>>>>> actor_2->Delete();
>>>>> ren->Delete();
>>>>> renWin->Delete();
>>>>> iren->Delete();
>>>>>
>>>>> polydata_1->Delete();
>>>>> del_1->Delete();
>>>>> cloud_1->Delete();
>>>>>
>>>>> return 0;
>>>>>}
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>#include "vtkActor.h"
>>>#include "vtkDoubleArray.h"
>>>#include "vtkPointData.h"
>>>#include "vtkPoints.h"
>>>#include "vtkPolyData.h"
>>>#include "vtkPolyDataMapper.h"
>>>#include "vtkRenderWindow.h"
>>>#include "vtkRenderWindowInteractor.h"
>>>#include "vtkRenderer.h"
>>>#include "vtkProperty.h"
>>>#include "vtkIterativeClosestPointTransform2.h"
>>>#include "vtkLandmarkTransform.h"
>>>#include "vtkTransformPolyDataFilter.h"
>>>#include "vtkMaskPoints.h"
>>>
>>>using namespace std;
>>>
>>>int main( int argc, char *argv[] )
>>>{
>>> srand48(time(NULL));
>>> cout << "Program Starting" << endl;
>>>
>>> vtkPolyData* polyData1 = vtkPolyData::New();
>>> vtkPoints* cloud1 = vtkPoints::New();
>>>
>>> int numPoints = 500;
>>> static float mypoint1[3];
>>>
>>> for (int i = 0; i < numPoints; i++)
>>> {
>>> mypoint1[0] = drand48()*50;
>>> mypoint1[1] = drand48()*50;
>>> mypoint1[2] = drand48()*50;
>>>
>>> cloud1->InsertNextPoint(mypoint1);
>>> }
>>>
>>> polyData1->SetPoints(cloud1);
>>>
>>> int num_of_points1 = polyData1->GetPoints()->GetNumberOfPoints();
>>> cout << "in all, num of points in cloud 1 is " << num_of_points1 << endl;
>>>
>>> vtkPolyData* polyData2 = vtkPolyData::New();
>>> vtkPoints* cloud2 = vtkPoints::New();
>>>
>>> static float mypoint2[3];
>>>
>>> for (int i = 0; i < numPoints; i++)
>>> {
>>> mypoint2[0] = drand48()*50;
>>> mypoint2[1] = drand48()*50;
>>> mypoint2[2] = drand48()*50;
>>>
>>> cloud2->InsertNextPoint(mypoint2);
>>> }
>>>
>>> polyData2->SetPoints(cloud2);
>>>
>>> int num_of_points2 = polyData2->GetPoints()->GetNumberOfPoints();
>>> cout << "in all, num of points in cloud 2 is " << num_of_points2 << endl;
>>>
>>> // Iterative Closest Point Transform
>>> vtkIterativeClosestPointTransform2
>>>*iterativeClosestPointTransform = vtkIterativeClosestPointTransform2::New();
>>> iterativeClosestPointTransform->SetSource(polyData1);
>>> iterativeClosestPointTransform->SetTarget(polyData2);
>>>
>>>iterativeClosestPointTransform->GetLandmarkTransform()->SetModeToRigidBody();
>>> iterativeClosestPointTransform->StartByMatchingCentroidsOn();
>>> iterativeClosestPointTransform->SetMaximumNumberOfIterations(10);
>>> iterativeClosestPointTransform->SetMeanDistanceModeToAbsoluteValue();
>>> iterativeClosestPointTransform->Update();
>>>
>>> cout << "Mean distance: " <<
>>>iterativeClosestPointTransform->GetMeanDistance() << endl;
>>>
>>> // tranform the data
>>> vtkTransformPolyDataFilter* transformPolyDataFilter =
>>>vtkTransformPolyDataFilter::New();
>>> transformPolyDataFilter->SetTransform(iterativeClosestPointTransform);
>>> transformPolyDataFilter->SetInput(polyData1);
>>> polyData1->Delete();
>>> transformPolyDataFilter->Update();
>>>
>>> vtkMaskPoints *maskPoints1 = vtkMaskPoints::New();
>>> maskPoints1->SetInput(transformPolyDataFilter->GetOutput());
>>> transformPolyDataFilter->Delete();
>>> maskPoints1->SetMaximumNumberOfPoints(numPoints);
>>> maskPoints1->GenerateVerticesOn();
>>> maskPoints1->Update();
>>>
>>> vtkMaskPoints *maskPoints2 = vtkMaskPoints::New();
>>> maskPoints2->SetInput(polyData2);
>>> polyData2->Delete();
>>> maskPoints2->SetMaximumNumberOfPoints(numPoints);
>>> maskPoints2->GenerateVerticesOn();
>>> maskPoints2->Update();
>>>
>>> vtkPolyDataMapper *polyDataMapper1 = vtkPolyDataMapper::New();
>>> polyDataMapper1->SetInput(maskPoints1->GetOutput());
>>> maskPoints1->Delete();
>>>
>>> vtkPolyDataMapper *polyDataMapper2 = vtkPolyDataMapper::New();
>>> polyDataMapper2->SetInput(maskPoints2->GetOutput());
>>> maskPoints2->Delete();
>>>
>>> // Create an actor for cloud 1.
>>> vtkActor* actor1 = vtkActor::New();
>>> actor1->SetMapper(polyDataMapper1);
>>> actor1->GetProperty()->SetColor(1,0,0);
>>>
>>> // create an actor for cloud 2
>>> vtkActor* actor2 = vtkActor::New();
>>> actor2->SetMapper(polyDataMapper2);
>>> actor2->GetProperty()->SetColor(0,1,0);
>>>
>>> // Create the rendering objects.
>>> vtkRenderer* ren = vtkRenderer::New();
>>> ren->AddActor(actor1);
>>> ren->AddActor(actor2);
>>>
>>> vtkRenderWindow* renWin = vtkRenderWindow::New();
>>> renWin->AddRenderer(ren);
>>>
>>> vtkRenderWindowInteractor* iren = vtkRenderWindowInteractor::New();
>>> iren->SetRenderWindow(renWin);
>>> iren->Initialize();
>>> iren->Start();
>>>
>>> actor1->Delete();
>>> actor2->Delete();
>>> ren->Delete();
>>> renWin->Delete();
>>> iren->Delete();
>>>
>>> return 0;
>>>}
>>>
>>>
>>>
>>>/*=========================================================================
>>>
>>> Program: Visualization Toolkit
>>> Module: $RCSfile: vtkIterativeClosestPointTransform2.cxx,v $
>>>
>>> Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
>>> All rights reserved.
>>> See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
>>>
>>> This software is distributed WITHOUT ANY WARRANTY; without even
>>> the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
>>> PURPOSE. See the above copyright notice for more information.
>>>
>>>=========================================================================*/
>>>#include "vtkIterativeClosestPointTransform2.h"
>>>
>>>#include "vtkPointLocator.h"
>>>#include "vtkDataSet.h"
>>>#include "vtkLandmarkTransform.h"
>>>#include "vtkMath.h"
>>>#include "vtkObjectFactory.h"
>>>#include "vtkPoints.h"
>>>#include "vtkTransform.h"
>>>
>>>vtkCxxRevisionMacro(vtkIterativeClosestPointTransform2, "$Revision: 1.14 $");
>>>vtkStandardNewMacro(vtkIterativeClosestPointTransform2);
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>vtkIterativeClosestPointTransform2::vtkIterativeClosestPointTransform2()
>>> : vtkLinearTransform()
>>>{
>>> this->Source = NULL;
>>> this->Target = NULL;
>>> this->Locator = NULL;
>>> this->LandmarkTransform = vtkLandmarkTransform::New();
>>> this->MaximumNumberOfIterations = 50;
>>> this->CheckMeanDistance = 0;
>>> this->MeanDistanceMode = VTK_ICP_MODE_RMS;
>>> this->MaximumMeanDistance = 0.01;
>>> this->MaximumNumberOfLandmarks = 200;
>>> this->StartByMatchingCentroids = 0;
>>>
>>> this->NumberOfIterations = 0;
>>> this->MeanDistance = 0.0;
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>const char *vtkIterativeClosestPointTransform2::GetMeanDistanceModeAsString()
>>>{
>>> if ( this->MeanDistanceMode == VTK_ICP_MODE_RMS )
>>> {
>>> return "RMS";
>>> }
>>> else
>>> {
>>> return "AbsoluteValue";
>>> }
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>vtkIterativeClosestPointTransform2::~vtkIterativeClosestPointTransform2()
>>>{
>>> ReleaseSource();
>>> ReleaseTarget();
>>> ReleaseLocator();
>>> this->LandmarkTransform->Delete();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::SetSource(vtkDataSet *source)
>>>{
>>> if (this->Source == source)
>>> {
>>> return;
>>> }
>>>
>>> if (this->Source)
>>> {
>>> this->ReleaseSource();
>>> }
>>>
>>> if (source)
>>> {
>>> source->Register(this);
>>> }
>>>
>>> this->Source = source;
>>> this->Modified();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::ReleaseSource(void) {
>>> if (this->Source)
>>> {
>>> this->Source->UnRegister(this);
>>> this->Source = NULL;
>>> }
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::SetTarget(vtkDataSet *target)
>>>{
>>> if (this->Target == target)
>>> {
>>> return;
>>> }
>>>
>>> if (this->Target)
>>> {
>>> this->ReleaseTarget();
>>> }
>>>
>>> if (target)
>>> {
>>> target->Register(this);
>>> }
>>>
>>> this->Target = target;
>>> this->Modified();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::ReleaseTarget(void) {
>>> if (this->Target)
>>> {
>>> this->Target->UnRegister(this);
>>> this->Target = NULL;
>>> }
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::SetLocator(vtkPointLocator *locator)
>>>{
>>> if (this->Locator == locator)
>>> {
>>> return;
>>> }
>>>
>>> if (this->Locator)
>>> {
>>> this->ReleaseLocator();
>>> }
>>>
>>> if (locator)
>>> {
>>> locator->Register(this);
>>> }
>>>
>>> this->Locator = locator;
>>> this->Modified();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::ReleaseLocator(void) {
>>> if (this->Locator)
>>> {
>>> this->Locator->UnRegister(this);
>>> this->Locator = NULL;
>>> }
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::CreateDefaultLocator() {
>>> if (this->Locator)
>>> {
>>> this->ReleaseLocator();
>>> }
>>>
>>> this->Locator = vtkPointLocator::New();
>>>}
>>>
>>>//------------------------------------------------------------------------
>>>
>>>unsigned long vtkIterativeClosestPointTransform2::GetMTime()
>>>{
>>> unsigned long result = this->vtkLinearTransform::GetMTime();
>>> unsigned long mtime;
>>>
>>> if (this->Source)
>>> {
>>> mtime = this->Source->GetMTime();
>>> if (mtime > result)
>>> {
>>> result = mtime;
>>> }
>>> }
>>>
>>> if (this->Target)
>>> {
>>> mtime = this->Target->GetMTime();
>>> if (mtime > result)
>>> {
>>> result = mtime;
>>> }
>>> }
>>>
>>> if (this->Locator)
>>> {
>>> mtime = this->Locator->GetMTime();
>>> if (mtime > result)
>>> {
>>> result = mtime;
>>> }
>>> }
>>>
>>> if (this->LandmarkTransform)
>>> {
>>> mtime = this->LandmarkTransform->GetMTime();
>>> if (mtime > result)
>>> {
>>> result = mtime;
>>> }
>>> }
>>>
>>> return result;
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::Inverse()
>>>{
>>> vtkDataSet *tmp1 = this->Source;
>>> this->Source = this->Target;
>>> this->Target = tmp1;
>>> this->Modified();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>vtkAbstractTransform *vtkIterativeClosestPointTransform2::MakeTransform()
>>>{
>>> return vtkIterativeClosestPointTransform2::New();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void
>>>vtkIterativeClosestPointTransform2::InternalDeepCopy(vtkAbstractTransform
>>>*transform)
>>>{
>>> vtkIterativeClosestPointTransform2 *t =
>>>(vtkIterativeClosestPointTransform2 *)transform;
>>>
>>> this->SetSource(t->GetSource());
>>> this->SetTarget(t->GetTarget());
>>> this->SetLocator(t->GetLocator());
>>> this->SetMaximumNumberOfIterations(t->GetMaximumNumberOfIterations());
>>> this->SetCheckMeanDistance(t->GetCheckMeanDistance());
>>> this->SetMeanDistanceMode(t->GetMeanDistanceMode());
>>> this->SetMaximumMeanDistance(t->GetMaximumMeanDistance());
>>> this->SetMaximumNumberOfLandmarks(t->GetMaximumNumberOfLandmarks());
>>>
>>> this->Modified();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::InternalUpdate()
>>>{
>>> // Check source, target
>>>
>>> if (this->Source == NULL || !this->Source->GetNumberOfPoints())
>>> {
>>> vtkErrorMacro(<<"Can't execute with NULL or empty input");
>>> return;
>>> }
>>>
>>> if (this->Target == NULL || !this->Target->GetNumberOfPoints())
>>> {
>>> vtkErrorMacro(<<"Can't execute with NULL or empty target");
>>> return;
>>> }
>>>
>>> // Create locator
>>>
>>> this->CreateDefaultLocator();
>>> this->Locator->SetDataSet(this->Target);
>>> //this->Locator->SetNumberOfCellsPerBucket(1);
>>> this->Locator->BuildLocator();
>>>
>>> // Create two sets of points to handle iteration
>>>
>>> int step = 1;
>>> if (this->Source->GetNumberOfPoints() > this->MaximumNumberOfLandmarks)
>>> {
>>> step = this->Source->GetNumberOfPoints() /
>>>this->MaximumNumberOfLandmarks;
>>> vtkDebugMacro(<< "Landmarks step is now : " << step);
>>> }
>>>
>>> vtkIdType nb_points = this->Source->GetNumberOfPoints() / step;
>>>
>>> // Allocate some points.
>>> // - closestp is used so that the internal state of
>>>LandmarkTransform remains
>>> // correct whenever the iteration process is stopped (hence its source
>>> // and landmark points might be used in a vtkThinPlateSplineTransform).
>>> // - points2 could have been avoided, but do not ask me why
>>> // InternalTransformPoint is not working correctly on my computer when
>>> // in and out are the same pointer.
>>>
>>> vtkPoints *points1 = vtkPoints::New();
>>> points1->SetNumberOfPoints(nb_points);
>>>
>>> vtkPoints *closestp = vtkPoints::New();
>>> closestp->SetNumberOfPoints(nb_points);
>>>
>>> vtkPoints *points2 = vtkPoints::New();
>>> points2->SetNumberOfPoints(nb_points);
>>>
>>> // Fill with initial positions (sample dataset using step)
>>>
>>> vtkTransform *accumulate = vtkTransform::New();
>>> accumulate->PostMultiply();
>>>
>>> vtkIdType i;
>>> int j;
>>> double p1[3], p2[3];
>>>
>>> if (StartByMatchingCentroids)
>>> {
>>> double source_centroid[3] = {0,0,0};
>>> for (i = 0; i < this->Source->GetNumberOfPoints(); i++)
>>> {
>>> this->Source->GetPoint(i, p1);
>>> source_centroid[0] += p1[0];
>>> source_centroid[1] += p1[1];
>>> source_centroid[2] += p1[2];
>>> }
>>> source_centroid[0] /= this->Source->GetNumberOfPoints();
>>> source_centroid[1] /= this->Source->GetNumberOfPoints();
>>> source_centroid[2] /= this->Source->GetNumberOfPoints();
>>>
>>> double target_centroid[3] = {0,0,0};
>>> for (i = 0; i < this->Target->GetNumberOfPoints(); i++)
>>> {
>>> this->Target->GetPoint(i, p2);
>>> target_centroid[0] += p2[0];
>>> target_centroid[1] += p2[1];
>>> target_centroid[2] += p2[2];
>>> }
>>> target_centroid[0] /= this->Target->GetNumberOfPoints();
>>> target_centroid[1] /= this->Target->GetNumberOfPoints();
>>> target_centroid[2] /= this->Target->GetNumberOfPoints();
>>>
>>> accumulate->Translate(target_centroid[0] - source_centroid[0],
>>> target_centroid[1] - source_centroid[1],
>>> target_centroid[2] - source_centroid[2]);
>>> accumulate->Update();
>>>
>>> for (i = 0, j = 0; i < nb_points; i++, j += step)
>>> {
>>> double outPoint[3];
>>> accumulate->InternalTransformPoint(this->Source->GetPoint(j),
>>> outPoint);
>>> points1->SetPoint(i, outPoint);
>>> }
>>> }
>>> else
>>> {
>>> for (i = 0, j = 0; i < nb_points; i++, j += step)
>>> {
>>> points1->SetPoint(i, this->Source->GetPoint(j));
>>> }
>>> }
>>>
>>> // Go
>>>
>>> vtkIdType cell_id;
>>> int sub_id;
>>> double dist2, totaldist = 0;
>>> double outPoint[3];
>>>
>>> vtkIdType outPointId = -1;
>>> int targetNumPoints = this->Target->GetNumberOfPoints();
>>> vtkPoints *temp, *a = points1, *b = points2;
>>>
>>> this->NumberOfIterations = 0;
>>>
>>> do
>>> {
>>> // Fill points with the closest points to each vertex in input
>>>
>>> for(i = 0; i < nb_points; i++)
>>> {
>>> outPointId = this->Locator->FindClosestPoint(a->GetPoint(i));
>>>
>>> if ( outPointId < 0 || outPointId >= targetNumPoints )
>>> {
>>> vtkErrorMacro(<<"Cannot find the closest point");
>>> return;
>>> }
>>>
>>> this->Target->GetPoint(outPointId,outPoint);
>>> closestp->SetPoint(i, outPoint);
>>> }
>>>
>>> // Build the landmark transform
>>>
>>> this->LandmarkTransform->SetSourceLandmarks(a);
>>> this->LandmarkTransform->SetTargetLandmarks(closestp);
>>> this->LandmarkTransform->Update();
>>>
>>> // Concatenate (can't use this->Concatenate directly)
>>>
>>> accumulate->Concatenate(this->LandmarkTransform->GetMatrix());
>>>
>>> this->NumberOfIterations++;
>>>
>>> vtkDebugMacro(<< "Iteration: " << this->NumberOfIterations);
>>> if (this->NumberOfIterations >= this->MaximumNumberOfIterations)
>>> {
>>> break;
>>> }
>>>
>>> // Move mesh and compute mean distance if needed
>>>
>>> if (this->CheckMeanDistance)
>>> {
>>> totaldist = 0.0;
>>> }
>>>
>>> for(i = 0; i < nb_points; i++)
>>> {
>>> a->GetPoint(i, p1);
>>> this->LandmarkTransform->InternalTransformPoint(p1, p2);
>>> b->SetPoint(i, p2);
>>> if (this->CheckMeanDistance)
>>> {
>>> if (this->MeanDistanceMode == VTK_ICP_MODE_RMS)
>>> {
>>> totaldist += vtkMath::Distance2BetweenPoints(p1, p2);
>>> } else {
>>> totaldist += sqrt(vtkMath::Distance2BetweenPoints(p1, p2));
>>> }
>>> }
>>> }
>>>
>>> if (this->CheckMeanDistance)
>>> {
>>> if (this->MeanDistanceMode == VTK_ICP_MODE_RMS)
>>> {
>>> this->MeanDistance = sqrt(totaldist / (double)nb_points);
>>> } else {
>>> this->MeanDistance = totaldist / (double)nb_points;
>>> }
>>>
>>> vtkDebugMacro("Mean distance: " << this->MeanDistance);
>>> if (this->MeanDistance <= this->MaximumMeanDistance)
>>> {
>>> break;
>>> }
>>> }
>>>
>>> temp = a;
>>> a = b;
>>> b = temp;
>>> }
>>> while (1);
>>>
>>> // Now recover accumulated result
>>>
>>> this->Matrix->DeepCopy(accumulate->GetMatrix());
>>>
>>> accumulate->Delete();
>>> points1->Delete();
>>> closestp->Delete();
>>> points2->Delete();
>>>}
>>>
>>>//----------------------------------------------------------------------------
>>>
>>>void vtkIterativeClosestPointTransform2::PrintSelf(ostream& os,
>>>vtkIndent indent)
>>>{
>>> this->Superclass::PrintSelf(os,indent);
>>>
>>> if ( this->Source )
>>> {
>>> os << indent << "Source: " << this->Source << "\n";
>>> }
>>> else
>>> {
>>> os << indent << "Source: (none)\n";
>>> }
>>>
>>> if ( this->Target )
>>> {
>>> os << indent << "Target: " << this->Target << "\n";
>>> }
>>> else
>>> {
>>> os << indent << "Target: (none)\n";
>>> }
>>>
>>> if ( this->Locator )
>>> {
>>> os << indent << "Locator: " << this->Locator << "\n";
>>> }
>>> else
>>> {
>>> os << indent << "Locator: (none)\n";
>>> }
>>>
>>> os << indent << "MaximumNumberOfIterations: " <<
>>>this->MaximumNumberOfIterations << "\n";
>>> os << indent << "CheckMeanDistance: " << this->CheckMeanDistance << "\n";
>>> os << indent << "MeanDistanceMode: " <<
>>>this->GetMeanDistanceModeAsString() << "\n";
>>> os << indent << "MaximumMeanDistance: " <<
>>>this->MaximumMeanDistance << "\n";
>>> os << indent << "MaximumNumberOfLandmarks: " <<
>>>this->MaximumNumberOfLandmarks << "\n";
>>> os << indent << "StartByMatchingCentroids: " <<
>>>this->StartByMatchingCentroids << "\n";
>>> os << indent << "NumberOfIterations: " << this->NumberOfIterations << "\n";
>>> os << indent << "MeanDistance: " << this->MeanDistance << "\n";
>>> if(this->LandmarkTransform)
>>> {
>>> os << indent << "LandmarkTransform:\n";
>>> this->LandmarkTransform->PrintSelf(os, indent.GetNextIndent());
>>> }
>>>}
>>>
>>>/*=========================================================================
>>>
>>> Program: Visualization Toolkit
>>> Module: $RCSfile: vtkIterativeClosestPointTransform2.h,v $
>>>
>>> Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
>>> All rights reserved.
>>> See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
>>>
>>> This software is distributed WITHOUT ANY WARRANTY; without even
>>> the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
>>> PURPOSE. See the above copyright notice for more information.
>>>
>>>=========================================================================*/
>>>
>>>// .NAME vtkIterativeClosestPointTransform2 - Implementation of the
>>>ICP algorithm.
>>>// .SECTION Description
>>>// Match two surfaces using the iterative closest point (ICP) algorithm.
>>>// The core of the algorithm is to match each vertex in one surface with
>>>// the closest surface point on the other, then apply the transformation
>>>// that modify one surface to best match the other (in a least square sense).
>>>// This has to be iterated to get proper convergence of the surfaces.
>>>// .SECTION Note
>>>// Use vtkTransformPolyDataFilter to apply the resulting ICP transform to
>>>// your data. You might also set it to your actor's user transform.
>>>// .SECTION Note
>>>// This class makes use of vtkLandmarkTransform internally to compute the
>>>// best fit. Use the GetLandmarkTransform member to get a pointer to that
>>>// transform and set its parameters. You might, for example, constrain the
>>>// number of degrees of freedom of the solution (i.e. rigid body, similarity,
>>>// etc.) by checking the vtkLandmarkTransform documentation for its SetMode
>>>// member.
>>>// .SECTION see also
>>>// vtkLandmarkTransform
>>>
>>>
>>>#ifndef __vtkIterativeClosestPointTransform2_h
>>>#define __vtkIterativeClosestPointTransform2_h
>>>
>>>#include "vtkLinearTransform.h"
>>>
>>>#define VTK_ICP_MODE_RMS 0
>>>#define VTK_ICP_MODE_AV 1
>>>
>>>class vtkPointLocator;
>>>class vtkLandmarkTransform;
>>>class vtkDataSet;
>>>
>>>//class VTK_HYBRID_EXPORT vtkIterativeClosestPointTransform2 :
>>>public vtkLinearTransform
>>>class vtkIterativeClosestPointTransform2 : public vtkLinearTransform
>>>{
>>>public:
>>> static vtkIterativeClosestPointTransform2 *New();
>>>
>>>vtkTypeRevisionMacro(vtkIterativeClosestPointTransform2,vtkLinearTransform);
>>> void PrintSelf(ostream& os, vtkIndent indent);
>>>
>>> // Description:
>>> // Specify the source and target data sets.
>>> void SetSource(vtkDataSet *source);
>>> void SetTarget(vtkDataSet *target);
>>> vtkGetObjectMacro(Source, vtkDataSet);
>>> vtkGetObjectMacro(Target, vtkDataSet);
>>>
>>> // Description:
>>> // Set/Get a spatial locator for speeding up the search process.
>>> // An instance of vtkPointLocator is used by default.
>>> void SetLocator(vtkPointLocator *locator);
>>> vtkGetObjectMacro(Locator,vtkPointLocator);
>>>
>>> // Description:
>>> // Set/Get the maximum number of iterations
>>> vtkSetMacro(MaximumNumberOfIterations, int);
>>> vtkGetMacro(MaximumNumberOfIterations, int);
>>>
>>> // Description:
>>> // Get the number of iterations since the last update
>>> vtkGetMacro(NumberOfIterations, int);
>>>
>>> // Description:
>>> // Force the algorithm to check the mean distance between two iteration.
>>> vtkSetMacro(CheckMeanDistance, int);
>>> vtkGetMacro(CheckMeanDistance, int);
>>> vtkBooleanMacro(CheckMeanDistance, int);
>>>
>>> // Description:
>>> // Specify the mean distance mode. This mode expresses how the mean
>>> // distance is computed. The RMS mode is the square root of the average
>>> // of the sum of squares of the closest point distances. The Absolute
>>> // Value mode is the mean of the sum of absolute values of the closest
>>> // point distances.
>>> vtkSetClampMacro(MeanDistanceMode,int,
>>> VTK_ICP_MODE_RMS,VTK_ICP_MODE_AV);
>>> vtkGetMacro(MeanDistanceMode,int);
>>> void SetMeanDistanceModeToRMS()
>>> {this->SetMeanDistanceMode(VTK_ICP_MODE_RMS);}
>>> void SetMeanDistanceModeToAbsoluteValue()
>>> {this->SetMeanDistanceMode(VTK_ICP_MODE_AV);}
>>> const char *GetMeanDistanceModeAsString();
>>>
>>> // Description:
>>> // Set/Get the maximum mean distance between two iteration. If the mean
>>> // distance is lower than this, the convergence stops.
>>> vtkSetMacro(MaximumMeanDistance, double);
>>> vtkGetMacro(MaximumMeanDistance, double);
>>>
>>> // Description:
>>> // Get the mean distance between the last two iterations.
>>> vtkGetMacro(MeanDistance, double);
>>>
>>> // Description:
>>> // Set/Get the maximum number of landmarks sampled in your dataset.
>>> // If your dataset is dense, then you will typically not need all the
>>> // points to compute the ICP transform.
>>> vtkSetMacro(MaximumNumberOfLandmarks, int);
>>> vtkGetMacro(MaximumNumberOfLandmarks, int);
>>>
>>> // Description:
>>> // Starts the process by translating source centroid to target centroid.
>>> vtkSetMacro(StartByMatchingCentroids, int);
>>> vtkGetMacro(StartByMatchingCentroids, int);
>>> vtkBooleanMacro(StartByMatchingCentroids, int);
>>>
>>> // Description:
>>> // Get the internal landmark transform. Use it to constrain the number of
>>> // degrees of freedom of the solution (i.e. rigid body, similarity, etc.).
>>> vtkGetObjectMacro(LandmarkTransform,vtkLandmarkTransform);
>>>
>>> // Description:
>>> // Invert the transformation. This is done by switching the
>>> // source and target.
>>> void Inverse();
>>>
>>> // Description:
>>> // Make another transform of the same type.
>>> vtkAbstractTransform *MakeTransform();
>>>
>>>protected:
>>>
>>> // Description:
>>> // Release source and target
>>> void ReleaseSource(void);
>>> void ReleaseTarget(void);
>>>
>>> // Description:
>>> // Release locator
>>> void ReleaseLocator(void);
>>>
>>> // Description:
>>> // Create default locator. Used to create one when none is specified.
>>> void CreateDefaultLocator(void);
>>>
>>> // Description:
>>> // Get the MTime of this object also considering the locator.
>>> unsigned long int GetMTime();
>>>
>>> vtkIterativeClosestPointTransform2();
>>> ~vtkIterativeClosestPointTransform2();
>>>
>>> void InternalUpdate();
>>>
>>> // Description:
>>> // This method does no type checking, use DeepCopy instead.
>>> void InternalDeepCopy(vtkAbstractTransform *transform);
>>>
>>> vtkDataSet* Source;
>>> vtkDataSet* Target;
>>> vtkPointLocator *Locator;
>>> int MaximumNumberOfIterations;
>>> int CheckMeanDistance;
>>> int MeanDistanceMode;
>>> double MaximumMeanDistance;
>>> int MaximumNumberOfLandmarks;
>>> int StartByMatchingCentroids;
>>>
>>> int NumberOfIterations;
>>> double MeanDistance;
>>> vtkLandmarkTransform *LandmarkTransform;
>>>private:
>>> vtkIterativeClosestPointTransform2(const
>>>vtkIterativeClosestPointTransform2&); // Not implemented.
>>> void operator=(const vtkIterativeClosestPointTransform2&); //
>>>Not implemented.
>>>};
>>>
>>>#endif
>>>
>>>_______________________________________________
>>>This is the private VTK discussion list.
>>>Please keep messages on-topic. Check the FAQ at:
>>>http://www.vtk.org/Wiki/VTK_FAQ
>>>Follow this link to subscribe/unsubscribe:
>>>http://www.vtk.org/mailman/listinfo/vtkusers
>>>
>>>
>>
>>
>_______________________________________________
>This is the private VTK discussion list.
>Please keep messages on-topic. Check the FAQ at: http://www.vtk.org/Wiki/VTK_FAQ
>Follow this link to subscribe/unsubscribe:
>http://www.vtk.org/mailman/listinfo/vtkusers
>
>
>
-------------- next part --------------
An embedded and charset-unspecified text was scrubbed...
Name: CMakeLists.txt
URL: <http://www.vtk.org/pipermail/vtkusers/attachments/20051109/ea25f53f/attachment.txt>
More information about the vtkusers
mailing list