[vtkusers] Contents of vtk-developers Digest, Vol 146, Issue 15

[Luis Vieira]

Hi David,


Also, I have tried, unsuccessfully, as well as following:
>> It looks like you are positioning the camera using image parameters...
but you are not mapping the image directly. Instead, you are mapping
geometry from a VRML file and texturing it with the image.
>>
renderer->ComputeVisiblePropBounds(bounds);
vtkCamera* cam = renderer->GetActiveCamera();
cam->SetFocalPoint((bounds[0] + bounds[1]) / 2.0, (bounds[2] + 
cam->bounds[3]) / 2.0, (bounds[4] + bounds[5]) / 2.0); 
cam->SetPosition((bounds[0] + bounds[1]) / 2.0, (bounds[2] + bounds[3]) 
cam->/ 2.0, bounds[4] + bounds[5]); SetViewUp(0, 1, 0);

Please, could you be more clear about this?
>> The pick coordinates will be points on the VRML geometry, not image-space
coordinates. There is an additional transform from texture coordinates to
image coordinates that is being ignored.
>>>

Tks,

Luis Vieira, Toronto - ON
Consultant, Software Engineer
Vektore Exploration Consulting Corporation
luis.vieira at vektore.com
www.vektore.com
-----Original Message-----
From: David Thompson [mailto:david.thompson at kitware.com] 
Sent: June 14, 2016 10:37 AM
To: Luis Vieira <luis.vieira at vektore.com>
Cc: vtk-developers at vtk.org
Subject: Re: [vtk-developers] Rendering Image and Picking Points

Hi Luis,

> ...I am struggling to rendering an Image and set up the camera focal point
to placed that image within the center of the camera.
>  
> 1- I want this because the point is when I am rotating the object and
picking point in its surface I got the X, Y and Z world coordinates that
doesn't match the real coordinates of the camera;
>  
> 2- When I am trying to use those coordinates once I had picked to
calculate the center of mass between them , the results are not accurately
rights. And everything that I have to derivate/build also are not, as well
as when I make a Plane and the its origin goes away into the camera out of
my cylinder(image). ...

It looks like you are positioning the camera using image parameters... but
you are not mapping the image directly. Instead, you are mapping geometry
from a VRML file and texturing it with the image. The pick coordinates will
be points on the VRML geometry, not image-space coordinates. There is an
additional transform from texture coordinates to image coordinates that is
being ignored.

	David

Hello Guys!!

First of all, I have to say that I appreciate any help!

I am struggling to rendering an Image and set up the camera focal point to
placed that image within the center of the camera.

1- I want this because the point is when I am rotating the object and
picking point in its surface I got the X, Y and Z world coordinates that
doesn't match the real coordinates of the camera;

2- When I am trying to use those coordinates once I had picked to calculate
the center of mass between them , the results are not accurately rights. And
everything that I have to derivate/build also are not, as well as when I
make a Plane and the its origin goes away into the camera out of my
cylinder(image).

Following my code and attached picture. Thank you very much!! Luis
MainWindow.cpp
void MainWindow::ProcessImage(QString _model, QString _image)
{
     double bounds[6] = { +1, -1, +1, -1, +1, -1 };
    qvtkWidget->setVisible(true);
              std::string iname = _model.toStdString();//model is a *.obj
Cylinder of Solid rock with h1024xw1024";
              std::string imagename = _image.toStdString() ;//is the texture
*.bmp file that wraps up the cylinder";
              vtkRenderer* renderer = vtkRenderer::New();
             
              vtkRenderWindow* renderWindow = vtkRenderWindow::New();
              renderWindow->StereoCapableWindowOn();
              // Activate 3DConnexion device only on the left render window.
              qvtkWidget->SetUseTDx(true);
              qvtkWidget->SetRenderWindow(renderWindow);
              //renderWindow->Delete();

              const double angleSensitivity = 0.02;
              const double translationSensitivity = 0.001;

              QVTKInteractor *iren = qvtkWidget->GetInteractor();
              vtkInteractorStyle *s =
                      static_cast<vtkInteractorStyle
*>(iren->GetInteractorStyle());
              vtkTDxInteractorStyleCamera *t =
                      static_cast<vtkTDxInteractorStyleCamera
*>(s->GetTDxStyle());

              t->GetSettings()->SetAngleSensitivity(angleSensitivity);
 
t->GetSettings()->SetTranslationXSensitivity(translationSensitivity);
 
t->GetSettings()->SetTranslationYSensitivity(translationSensitivity);
 
t->GetSettings()->SetTranslationZSensitivity(translationSensitivity);
         
              // Read the image which will be the texture

              QMenu* popup1 = new QMenu(qvtkWidget);
              popup1->addAction("Draw Line");
              popup1->addAction("Draw Plane");
              popup1->addAction("Draw Clip");
              popup1->addAction("Background White");
              popup1->addAction("Background Black");
              popup1->addAction("Stereo Rendering");
              connect(popup1, SIGNAL(triggered(QAction*)), this,
SLOT(ProcessUserViewPortInteraction(QAction*)));

              std::cout << "Reading image " << imagename << "..." <<
std::endl;

              vtkBMPReader* bmpReader = vtkBMPReader::New();

              bmpReader->SetFileName(imagename.c_str());

              bmpReader->Update();

              std::cout << "Done" << std::endl;

              // Creating the texture

              std::cout << "Making a texture out of the image... " <<
std::endl;

              vtkTexture* texture = vtkTexture::New();

              texture->SetInputConnection(bmpReader->GetOutputPort());

              std::cout << "Done" << std::endl;

              // Import geometry from a VRML file

              vtkSmartPointer<vtkImageViewer2> imageViewer =
                      vtkSmartPointer<vtkImageViewer2>::New();
              imageViewer->SetInputConnection(bmpReader->GetOutputPort());
              //imageViewer->SetupInteractor(renderWindowInteractor);
              imageViewer->SetSize(600, 600);

              vtkDataSet *pDataset;
              // Import geometry from an OBJ file

              std::cout << "Reading OBJ file " << iname << "..." <<
std::endl;

              vtkOBJReader* reader = vtkOBJReader::New();

              reader->SetFileName(iname.c_str());

              reader->Update();

              vtkPolyData *polyData2 = reader->GetOutput();

              std::cout << "Obj reader = " << polyData2->GetNumberOfPoints()
<< std::endl;

              std::cout << "Obj point data = " <<
polyData2->GetPointData()->GetNumberOfArrays() << std::endl;

              std::cout << "Obj point data tuples = " <<
polyData2->GetPointData()->GetArray(0)->GetNumberOfTuples() << std::endl;

              std::cout << "Obj point data compon = " <<
polyData2->GetPointData()->GetArray(0)->GetNumberOfComponents() <<
std::endl;

       //     //// Renderer

              vtkPolyDataMapper* mapper = vtkPolyDataMapper::New();

              mapper->SetInputData(polyData2);

              vtkActor* texturedQuad = vtkActor::New();

              texturedQuad->SetMapper(mapper);

              texturedQuad->SetTexture(texture);
              //texturedQuad->SetPosition(0, 0, 0);

              // Create Normal Vectors to enhance smoothness & illumination 
              vtkSmartPointer<vtkPolyDataNormals> normals =
vtkSmartPointer<vtkPolyDataNormals>::New();
              normals->SetInputData(polyData2);
              normals->SetFeatureAngle(60.0);

              // Mapper
              vtkPolyDataMapper *SolidMapper = vtkPolyDataMapper::New();
              SolidMapper->SetInputData(normals->GetOutput());
              SolidMapper->ScalarVisibilityOff();

              // Actor
              vtkActor *SolidActor = vtkActor::New();
              SolidActor->SetMapper(SolidMapper);
              
              vtkImageData* image = imageViewer->GetInput();
              int dim[3]; image->GetDimensions(dim);
              double spacing[3];
              image->GetSpacing(spacing);
              double origin[3];
              image->GetOrigin(origin);

       renderer->ComputeVisiblePropBounds(bounds);
              Renderer->AddActor(SolidActor);
              Renderer->AddActor(texturedQuad);

              float Cx = (dim[0] * spacing[0]) / 2. + origin[0];
              float Cy = (dim[1] * spacing[1]) / 2. + origin[1];

              vtkCamera* m_Camera = vtkCamera::New();
              m_Camera->SetPosition(Cx, Cy, 1);
              m_Camera->SetFocalPoint(Cx, Cy, 0);
              m_Camera->SetViewUp(0, 1, 0);
              m_Camera->GetDirectionOfProjection();
       
              m_Camera->ParallelProjectionOn();
              Renderer->SetActiveCamera(m_Camera);
              Renderer->SetBackground(0, 0, 0); // Background color white
              Renderer->ResetCamera();
              qvtkWidget->GetRenderWindow()->AddRenderer(Renderer);
              
              qvtkWidget->GetRenderWindow()->Render();
              //renderer->ResetCamera();
              vtkIPWCallback* myCallback =
                      vtkIPWCallback::New();
              myCallback->renderer = Renderer;
              myCallback->renderWindowInteractor =
qvtkWidget->GetRenderWindow()->GetInteractor();
              myCallback->readerClip = vtkOBJReader::New();
              myCallback->readerClip = reader;
              this->styleCallback = myCallback;

              //renderer->ResetCamera();
              this->stylePicker->normalsKore =
vtkSmartPointer<vtkPolyDataNormals>::New();
              this->stylePicker->normalsKore = normals;
              this->stylePicker->renderer =
vtkSmartPointer<vtkRenderer>::New();
              this->stylePicker->actor = vtkActor::New();
              
              this->stylePicker->mapper = vtkPolyDataMapper::New();
              this->stylePicker->points = vtkSmartPointer<vtkPoints>::New();
              this->stylePicker->vertices =
vtkSmartPointer<vtkCellArray>::New();
              this->stylePicker->renderer = Renderer;
              this->stylePicker->renderWindowInteractor =
qvtkWidget->GetRenderWindow()->GetInteractor();
              vtkSmartPointer<vtkPointPicker> pointPicker =
                      vtkSmartPointer<vtkPointPicker>::New();
 
qvtkWidget->GetRenderWindow()->GetInteractor()->SetPicker(pointPicker);
 
qvtkWidget->GetRenderWindow()->GetInteractor()->SetInteractorStyle(this->sty
lePicker);

              Connections = vtkEventQtSlotConnect::New();

 
Connections->Connect(qvtkWidget->GetRenderWindow()->GetInteractor(),
                      vtkCommand::KeyPressEvent,
                      this,
                      SLOT(popup(vtkObject*, unsigned long, void*, void*,
vtkCommand*)),
                      popup1, 1.0);
       }

MainWindow.h
//Point PickFunction
       class MouseInteractorStyle2 : public
vtkInteractorStyleTrackballCamera
       {

       public:
              std::vector<double*> pointList;
              std::vector<double*> pointListPlane;

              vtkSmartPointer<vtkMatrix4x4> matrix;
              vtkSmartPointer<vtkPolyDataNormals> normalsKore =
vtkSmartPointer<vtkPolyDataNormals>::New();
              vtkSmartPointer<vtkSphereSource> spherePickSource;
              vtkSmartPointer<vtkPoints> points =
vtkSmartPointer<vtkPoints>::New();
              vtkSmartPointer<vtkCellArray> vertices =
vtkSmartPointer<vtkCellArray>::New();
              vtkSmartPointer<vtkPolyData> polydata;
              vtkSmartPointer<vtkRenderer> renderer =
                      vtkSmartPointer<vtkRenderer>::New();
              vtkSmartPointer<vtkRenderWindowInteractor>
renderWindowInteractor =
                     vtkSmartPointer<vtkRenderWindowInteractor>::New();
              vtkActor* actor;
              
              vtkPolyDataMapper* mapper;
              static MouseInteractorStyle2* New()
              {
                      return new MouseInteractorStyle2;
              }
              //vtkTypeMacro(MouseInteractorStyle2,
vtkInteractorStyleTrackballCamera);

              virtual void OnRightButtonDown()
              {


                     int* clickPos =
this->renderWindowInteractor->GetEventPosition();

                      // Pick from this location.
                      vtkPropPicker*  picker =
                             vtkPropPicker::New();
                      picker->Pick(clickPos[0], clickPos[1], 0,
this->renderer);
                      

                      picker->Pick(clickPos[0], clickPos[1], 0,
this->renderer);

                      double* pos = picker->GetPickPosition();
                      std::cout << "Pick position (world coordinates) is: "
                             << pos[0] << " " << pos[1]
                             << " " << pos[2] << std::endl;

                             std::cout << "Picked actor: " <<
picker->GetActor() << std::endl;
                             // Add label array.
                             polydata = vtkSmartPointer<vtkPolyData>::New();
                             spherePickSource =
                                    vtkSmartPointer<vtkSphereSource>::New();
                             spherePickSource->SetRadius(0.030);
                             spherePickSource->SetCenter(pos[0], pos[1],
pos[2]);

                             if (pointList.size() < 2)
                             {   //pointList.clear();
                                    pointList.push_back(pos);
                             }
                             if (pointListPlane.size() < 30)
                             {
                                 pointListPlane.push_back(pos);
                             }
                             //Create a mapper and actor
                             mapper =
                                    vtkPolyDataMapper::New();
 
mapper->SetInputConnection(spherePickSource->GetOutputPort());

                             actor =
                                    vtkActor::New();
                             actor->SetMapper(mapper);
                             actor->GetProperty()->SetPointSize(5);
                             actor->GetProperty()->SetColor(1, 1, 1);
                      
                             this->renderer->AddActor(actor);

                     vtkInteractorStyleTrackballCamera::OnRightButtonDown();
              }
       private:
             
       };
   
Luis Vieira, Toronto - ON
Consultant, Software Engineer
Vektore Exploration Consulting Corporation
luis.vieira at vektore.com
www.vektore.com