[vtk-developers] Line picking

[pat marion]

I hacked one of the vtk examples to demonstrate the bug.  Attached and
copied below.  With the bug, it will only print "Pick success" when the x
coordinate of the mouse press is 150.

# CMakeLists.txt
cmake_minimum_required(VERSION 2.6)
project(test)
find_package(VTK REQUIRED)
include(${VTK_USE_FILE})
add_executable(test test.cxx)
target_link_libraries(test vtkRendering)

// test.cxx
/*=========================================================================

  Program:   Visualization Toolkit
  Module:    $RCSfile: line5.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.

=========================================================================*/
//
// This example introduces the concepts of interaction into the
// C++ environment. A different interaction style (than
// the default) is defined.
//

// First include the required header files for the VTK classes we are using.
#include "vtkPolyDataMapper.h"
#include "vtkRenderWindow.h"
#include "vtkRenderWindowInteractor.h"
#include "vtkCamera.h"
#include "vtkActor.h"
#include "vtkRenderer.h"
#include "vtkInteractorStyleTrackballCamera.h"

#include "vtkCallbackCommand.h"
#include "vtkLineSource.h"
#include "vtkProperty.h"
#include "vtkPropPicker.h"
#include "vtkSmartPointer.h"

//-----------------------------------------------------------------------------
class PickHelper {
public:
  PickHelper();
  vtkSmartPointer<vtkCallbackCommand> Command;
  vtkSmartPointer<vtkPropPicker> Picker;
  vtkActor* Actor;
  vtkRenderer* Renderer;
  vtkRenderWindowInteractor* Interactor;
};

//-----------------------------------------------------------------------------
void ProcessEvents(vtkObject* object, unsigned long event,
                   void* clientData, void* callData)
{
  PickHelper* h = reinterpret_cast<PickHelper*>(clientData);
  if (event == vtkCommand::LeftButtonPressEvent)
    {
    int x = 150;
    int y = 150;
    h->Interactor->GetEventPosition(x, y);
    printf("Mouse press: %d %d\n", x, y);
    if (h->Picker->PickProp(x, y, h->Renderer)
        && h->Picker->GetViewProp() == h->Actor)
      {
      printf("Pick success.\n");
      }
    }
}

//-----------------------------------------------------------------------------
PickHelper::PickHelper()
{
  this->Picker = vtkSmartPointer<vtkPropPicker>::New();
  this->Command = vtkSmartPointer<vtkCallbackCommand>::New();
  this->Command->SetCallback(ProcessEvents);
  this->Command->SetClientData(this);
  this->Picker->AddObserver(vtkCommand::EndPickEvent, Command);
}


int main()
{
  //
  // Next we create an instance of vtkLineSource and set some of its
  // properties. The instance of vtkLineSource "line" is part of a
  // visualization pipeline (it is a source process object); it produces
data
  // (output type is vtkPolyData) which other filters may process.
  //
  vtkLineSource *line = vtkLineSource::New();
  line->SetPoint1( 0, 0, 0);
  line->SetPoint2( 0, 1, 0);

  //
  // In this example we terminate the pipeline with a mapper process object.
  // (Intermediate filters such as vtkShrinkPolyData could be inserted in
  // between the source and the mapper.)  We create an instance of
  // vtkPolyDataMapper to map the polygonal data into graphics primitives.
We
  // connect the output of the line souece to the input of this mapper.
  //
  vtkPolyDataMapper *lineMapper = vtkPolyDataMapper::New();
  lineMapper->SetInputConnection( line->GetOutputPort() );

  //
  // Create an actor to represent the line. The actor orchestrates rendering
  // of the mapper's graphics primitives. An actor also refers to properties
  // via a vtkProperty instance, and includes an internal transformation
  // matrix. We set this actor's mapper to be lineMapper which we created
  // above.
  //
  vtkActor *lineActor = vtkActor::New();
  lineActor->SetMapper( lineMapper );
  lineActor->GetProperty()->SetLineWidth(10);

  //
  // Create the Renderer and assign actors to it. A renderer is like a
  // viewport. It is part or all of a window on the screen and it is
  // responsible for drawing the actors it has.  We also set the background
  // color here.
  //
  vtkRenderer *ren1= vtkRenderer::New();
  ren1->AddActor( lineActor );
  ren1->SetBackground( 0.5, 0.5, 0.5 );

  //
  // Finally we create the render window which will show up on the screen.
  // We put our renderer into the render window using AddRenderer. We also
  // set the size to be 300 pixels by 300.
  //
  vtkRenderWindow *renWin = vtkRenderWindow::New();
  renWin->AddRenderer( ren1 );
  renWin->SetSize( 300, 300 );

  //
  // The vtkRenderWindowInteractor class watches for events (e.g., keypress,
  // mouse) in the vtkRenderWindow. These events are translated into
  // event invocations that VTK understands (see VTK/Common/vtkCommand.h
  // for all events that VTK processes). Then observers of these VTK
  // events can process them as appropriate.
  vtkRenderWindowInteractor *iren = vtkRenderWindowInteractor::New();
  iren->SetRenderWindow(renWin);

  //
  // By default the vtkRenderWindowInteractor instantiates an instance
  // of vtkInteractorStyle. vtkInteractorStyle translates a set of events
  // it observes into operations on the camera, actors, and/or properties
  // in the vtkRenderWindow associated with the vtkRenderWinodwInteractor.
  // Here we specify a particular interactor style.
  vtkInteractorStyleTrackballCamera *style =
    vtkInteractorStyleTrackballCamera::New();
  iren->SetInteractorStyle(style);

  // Initialize the picker
  PickHelper helper;
  helper.Actor = lineActor;
  helper.Renderer = ren1;
  helper.Interactor = iren;
  iren->AddObserver(vtkCommand::LeftButtonPressEvent, helper.Command);

  //
  // Unlike the previous scripts where we performed some operations and then
  // exited, here we leave an event loop running. The user can use the mouse
  // and keyboard to perform the operations on the scene according to the
  // current interaction style. When the user presses the "e" key, by
default
  // an ExitEvent is invoked by the vtkRenderWindowInteractor which is
caught
  // and drops out of the event loop (triggered by the Start() method that
  // follows.
  //
  iren->Initialize();
  iren->Start();

  //
  // Final note: recall that an observers can watch for particular events
and
  // take appropriate action. Pressing "u" in the render window causes the
  // vtkRenderWindowInteractor to invoke a UserEvent. This can be caught to
  // popup a GUI, etc. So the Tcl line5.tcl example for an idea of how this
  // works.

  //
  // Free up any objects we created. All instances in VTK are deleted by
  // using the Delete() method.
  //
  line->Delete();
  lineMapper->Delete();
  lineActor->Delete();
  ren1->Delete();
  renWin->Delete();
  iren->Delete();
  style->Delete();

  return 0;
}


On Fri, Jan 22, 2010 at 1:18 PM, pat marion <pat.marion at kitware.com> wrote:

> Using vtkPropPicker::PickProp it is difficult to pick lines (using a
> vtkLineSource with a vtkPolyDataMapper for example).  Even if I set the line
> width to 10 pixels, the pick is only successful if I click exactly in the
> center of the 10 pixel band, as if the hardware picker was not respecting
> the 10 pixel width.  Can someone that is familiar with this part of vtk
> verify the bug, or point me in the right direction?
>
> Pat
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://public.kitware.com/pipermail/vtk-developers/attachments/20100123/c63372e6/attachment.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: pick_test.tar.gz
Type: application/x-gzip
Size: 2914 bytes
Desc: not available
URL: <http://public.kitware.com/pipermail/vtk-developers/attachments/20100123/c63372e6/attachment-0001.bin>