Hi, 
I'm using vtkOctree to segment my Mesh to 8 regions. I tried to pick on the mesh in order to get the picked point's coordinates, but i got an unhandled exception. The program is using the vtk Octree, here is my code:
<h3>
#include <vtkObjectFactory.h>
#include "vtkOctree.h"
#include "RenderWindow.h"
#include <vtkRenderWindowInteractor.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkPointPicker.h>
#include <vtkSmartPointer.h>
#include <vtkUnstructuredGrid.h>
#include <vtkPolyDataMapper.h>
#include <vtkActor.h>
// Catch mouse events
class MouseInteractorStyle : public vtkInteractorStyleTrackballCamera
{
  public:
  static MouseInteractorStyle* New();

  vtkSurface* Mesh2;
  vtkIntArray *lesNodes;
 
    virtual void OnLeftButtonDown()
    {
                
      // Get the location of the click (in window coordinates)
      int* pos = this->GetInteractor()->GetEventPosition();
 
          vtkSmartPointer<vtkPointPicker> picker =
        vtkSmartPointer<vtkPointPicker>::New();
     
 
      // Pick from this location.
      picker->Pick(pos[0], pos[1], pos[2], this->GetDefaultRenderer());
 
      double* worldPosition = picker->GetPickPosition();
          vtkIdType c=picker->GetPointId();
          cout<<" the PointId is : "<<picker->GetPointId()<&lt;endl;
cout&lt;&lt;&quot; point coordinates are: &quot;&lt;&lt;pos[0]&lt;&lt;&quot; &quot;&lt;&lt;pos[1]&lt;&lt;&quot; &quot;&lt;&lt;pos[2]&lt;&lt;endl;
                

                        Mesh2-&gt;GetPoint(c);
                cout<<"nombre des sommets : "<<        Mesh2->GetNumberOfPoints()<&lt;endl;
                
  this-&gt;Interactor->GetRenderWindow()->GetRenderers()->GetFirstRenderer()->AddActor(selectedActor);
 
        
      // Forward events
      vtkInteractorStyleTrackballCamera::OnLeftButtonDown();
        };

 
   // vtkSmartPointer<vtkPolyData> Data;
    vtkSmartPointer<vtkDataSetMapper> selectedMapper;
    vtkSmartPointer<vtkActor> selectedActor;
 
};
 
vtkStandardNewMacro(MouseInteractorStyle);




void vtkOctree::Decompose(vtkSurface *Mesh1)
{
//        vtkSurface *Edges=vtkSurface::New();
        
        RenderWindow *Window=RenderWindow::New();
        Window->SetInput(this->Input);
        
        vtkIntArray *PointsNode=vtkIntArray::New();
        PointsNode->SetNumberOfValues(this->Input->GetNumberOfPoints());
        
        std::vector<Node> Nodes;
        
        Node Node1;
        
        double Bounds[6];
        
        this->Input->GetPoints()->ComputeBounds();
        this->Input->GetPoints()->GetBounds(Bounds);
        
        // Create Root Node and push it into the array of nodes
        Node1.NumberOfPoints=this->Input->GetNumberOfPoints();
        // subdivide the Mesh to 8 areas
        for (int i=0;i<3;i++)
        {
                Node1.Center[i]=0.5*(Bounds[2*i+1]+Bounds[2*i]);
                Node1.Radius[i]=0.5*(Bounds[2*i+1]-Bounds[2*i]);
        }
        Nodes.push_back(Node1);
        
        // Assign all points to root node        
        for (int i=0;i<this->Input->GetNumberOfPoints();i++)
                PointsNode->SetValue(i,0);
        
        int NumberOfSplitNodes;
        int Level=0;
        for(int h=0;h<2; h++)
        {
                cout<<"Level "<&lt;Level++&lt;&lt;endl;
                NumberOfSplitNodes=0;
                for (int i=0;i&lt;this-&gt;Input->GetNumberOfPoints();i++)
                {
                        int NodeId=PointsNode->GetValue(i);
                        if (Nodes[NodeId].NeedsSplit())
                        {
                                if (!Nodes[NodeId].HasChildren())
                                {
                                        NumberOfSplitNodes++;
                                        // we need to create 8 sub-nodes (one for each octant)
                                        int Coordinates[3];
                                        for (Coordinates[0]=0;Coordinates[0]<2;Coordinates[0]++)
                                        {
                                                for (Coordinates[1]=0;Coordinates[1]<2;Coordinates[1]++)
                                                {
                                                        for (Coordinates[2]=0;Coordinates[2]<2;Coordinates[2]++)
                                                        {
                                                                Node1.Reset();
                                                                // Create one child node
                                                                for (int j=0;j<3;j++)
                                                                {
                                                                        Node1.Center[j]=Nodes[NodeId].Center[j]+
                                                                                ((double) Coordinates[j]-0.5)*Nodes[NodeId].Radius[j];
                                                                        Node1.Radius[j]=0.5*Nodes[NodeId].Radius[j];



                                                                }
                                                                
                                                                Nodes[NodeId].Children[Coordinates[0]][Coordinates[1]][Coordinates[2]]=
                                                                        Nodes.size();
                                                                Nodes.push_back(Node1);
                                                        }
                                                }
                                        }
                                }
                                double Point[3];
                                this->Input->GetPoint(i,Point);
                                int Coordinates[3];
                                for (int j=0;j<3;j++)
                                {
                                        if (Point[j]&lt;Nodes[NodeId].Center[j])
                                                Coordinates[j]=0;
                                        else
                                                Coordinates[j]=1;
                                }
                                int Child=Nodes[NodeId].Children[Coordinates[0]][Coordinates[1]][Coordinates[2]];
                                PointsNode-&gt;SetValue(i,Child);
                                Nodes[Child].NumberOfPoints++;
                                
                                
                                
                }
                        
                        
                }
                h++;

                               
                         
                        
                               
        };
        
                // create polydata for visualization

                cout<&lt;NumberOfSplitNodes&lt;&lt;&quot; Nodes split&quot;&lt;&lt;endl;
                Window-&gt;DisplayVerticesColors(PointsNode);
                Window->Render();
                
                <font color=#32CD32> //here i initialize the interaction</font>
                vtkRenderWindowInteractor *interactor=vtkRenderWindowInteractor::New();
                interactor->SetRenderWindow(Window->GetvtkRenderWindow());
                
                interactor->Initialize();
                
                vtkSmartPointer<MouseInteractorStyle> style = vtkSmartPointer<MouseInteractorStyle>::New();
                style->Mesh2=Mesh1;
                style->lesNodes=PointsNode;
                interactor->SetInteractorStyle(style);
                
                Window->GetvtkRenderWindow()->SetInteractor(interactor);
                interactor->Start();
                Window->Interact();
                
        Window->Delete();
        PointsNode->Delete();
}
</h3>
and this is the main  file:
#include "vtkSurface.h"
#include "RenderWindow.h"
#include "vtkOctree.h"


int main( int argc, char *argv[] )
{
         // Parse command line arguments
  if(argc != 2)
    {
    std::cout << "Usage: " << argv[0] << " Filename(.ply)" << std::endl;
    return EXIT_FAILURE;
    }

        vtkSurface *Mesh;
        
        // Load the mesh and create the vtkSurface data structure
        Mesh=vtkSurface::New();
        cout <<"load : "<&lt;argv[1]&lt;&lt;endl;
        Mesh-&gt;CreateFromFile(argv[1]);
        

        // prints to standard output the mesh caracteristics
        Mesh->DisplayMeshProperties();
        
        vtkOctree *Octree=vtkOctree::New();
        Octree->SetInput(Mesh);
        Octree->Decompose(Mesh);
        
        return (0);
}

        
        
        
<br/><hr align="left" width="300" />
View this message in context: <a href="http://vtk.1045678.n5.nabble.com/unhandled-exception-in-program-using-MouseInteraction-tp5715775.html">unhandled exception in program using MouseInteraction</a><br/>
Sent from the <a href="http://vtk.1045678.n5.nabble.com/VTK-Users-f1224199.html">VTK - Users mailing list archive</a> at Nabble.com.<br/>