org.simantics.g3d.vtk/src/org/simantics/g3d/vtk/awt/InteractiveVtkPanel.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Association for Decentralized Information Management in
   3  * Industry THTH ry.
   4  * All rights reserved. This program and the accompanying materials
   5  * are made available under the terms of the Eclipse Public License v1.0
   6  * which accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *     VTT Technical Research Centre of Finland - initial API and implementation
  11  *******************************************************************************/
  12 package org.simantics.g3d.vtk.awt;
  13
  14 import java.awt.event.KeyEvent;
  15 import java.awt.event.MouseEvent;
  16 import java.util.ArrayList;
  17 import java.util.List;
  18
  19 import org.eclipse.core.runtime.Platform;
  20 import org.simantics.g3d.scenegraph.RenderListener;
  21 import org.simantics.g3d.vtk.action.vtkAction;
  22 import org.simantics.g3d.vtk.common.VtkView;
  23 import org.simantics.scenegraph.utils.DPIUtil;
  24 import org.simantics.utils.threads.AWTThread;
  25 import org.simantics.utils.threads.IThreadWorkQueue;
  26
  27 import vtk.vtkAbstractPicker;
  28 import vtk.vtkAreaPicker;
  29 import vtk.vtkAssemblyNode;
  30 import vtk.vtkAssemblyPath;
  31 import vtk.vtkCellPicker;
  32 import vtk.vtkGenericRenderWindowInteractor;
  33 import vtk.vtkInteractorStyleTrackballCamera;
  34 import vtk.vtkObject;
  35 import vtk.vtkObjectBase;
  36 import vtk.vtkPanel;
  37 import vtk.vtkPointPicker;
  38 import vtk.vtkProp;
  39 import vtk.vtkProp3DCollection;
  40 import vtk.vtkPropCollection;
  41 import vtk.vtkPropPicker;
  42 import vtk.vtkRenderer;
  43 import vtk.vtkScenePicker;
  44
  45 public class InteractiveVtkPanel extends vtkPanel implements VtkView {
  46
  47         protected vtkGenericRenderWindowInteractor iren;
  48
  49
  50         public vtkGenericRenderWindowInteractor getRenderWindowInteractor() {
  51                 return this.iren;
  52         }
  53         private static final long serialVersionUID = 2815073937537950615L;
  54
  55
  56         public InteractiveVtkPanel() {
  57                 super();
  58
  59                 if (!Platform.inDevelopmentMode()) {
  60                         // This is actually a static method in C++
  61                         new vtkObject().GlobalWarningDisplayOff();
  62                 }
  63
  64                 iren = new vtkGenericRenderWindowInteractor();
  65                 iren.SetRenderWindow(rw);
  66                 iren.TimerEventResetsTimerOff();
  67                 iren.SetSize(200, 200);
  68                 iren.ConfigureEvent();
  69                 vtkInteractorStyleTrackballCamera style = new vtkInteractorStyleTrackballCamera();
  70                 iren.SetInteractorStyle(style);
  71                 addDeletable(style);
  72                 addDeletable(iren);
  73         }
  74
  75         @Override
  76         public IThreadWorkQueue getThreadQueue() {
  77                 return AWTThread.getThreadAccess();
  78         }
  79
  80         @Override
  81         public vtkRenderer getRenderer() {
  82                 return GetRenderer();
  83         }
  84
  85         @Override
  86         public void mouseClicked(MouseEvent e) {
  87
  88         }
  89
  90         @Override
  91         public void mouseMoved(MouseEvent e) {
  92
  93         }
  94
  95         @Override
  96         public void mouseEntered(MouseEvent e) {
  97                 super.mouseEntered(e);
  98         }
  99
 100         @Override
 101         public void mouseExited(MouseEvent e) {
 102
 103         }
 104
 105         @Override
 106         public void mousePressed(MouseEvent e) {
 107
 108         }
 109
 110         @Override
 111         public void mouseDragged(MouseEvent e) {
 112
 113         }
 114
 115         @Override
 116         public void mouseReleased(MouseEvent e) {
 117
 118         }
 119
 120         @Override
 121         public void keyPressed(KeyEvent e) {
 122
 123         }
 124
 125         @Override
 126         public void keyTyped(KeyEvent e) {
 127
 128         }
 129
 130         public void setSize(int x, int y) {
 131                 super.setSize(x, y);
 132         }
 133
 134         public void _setSize(int x, int y) {
 135                 System.out.println(this.getClass().getSimpleName() + " " + windowset + " setSize " +x + " " + y);
 136                 if (windowset == 1) {
 137
 138                         Lock();
 139                         rw.SetSize(x, y);
 140                         iren.SetSize(x, y);
 141                         iren.ConfigureEvent();
 142                         UnLock();
 143                 } else {
 144                         if (x > 1000)
 145                                 System.out.println();
 146                 }
 147         }
 148
 149         @Override
 150         public void setBounds(int x, int y, int width, int height) {
 151                 super.setBounds(x, y, width, height);
 152                 _setSize(width, height);
 153         }
 154
 155         private vtkScenePicker scenePicker;
 156
 157         int pickType = 4;
 158
 159         public int getPickType() {
 160                 return pickType;
 161         }
 162
 163         public void setPickType(int pickType) {
 164                 this.pickType = pickType;
 165         }
 166
 167         public vtkProp[] pick(int x, int y) {
 168
 169
 170 //              vtkPicker picker = new vtkPicker();
 171 //              vtkAbstractPicker picker = new vtkAbstractPicker();
 172 //              picker.Pick(x, rw.GetSize()[1] - y, ren);
 173 //              // see page 60 of VTK user's guide
 174 //
 175                 if (pickType == 0) {
 176
 177                         vtkPropPicker picker = new vtkPropPicker();
 178                         Lock();
 179                         picker.PickProp(x, rw.GetSize()[1] - y, ren);
 180
 181                         UnLock();
 182
 183                         vtkAssemblyPath apath = picker.GetPath();
 184                         return processPick(picker, apath);
 185
 186                 } else if (pickType == 1) {
 187                         if (scenePicker == null) {
 188                                 scenePicker = new vtkScenePicker();
 189                                 scenePicker.SetRenderer(ren);
 190                                 scenePicker.EnableVertexPickingOn();
 191
 192                         }
 193                         Lock();
 194
 195                         vtkAssemblyPath apath = ren.PickProp(x, rw.GetSize()[1] - y);
 196                         //int vertexId = scenePicker.GetVertexId(new int[]{x, rw.GetSize()[1] - y});
 197
 198                         UnLock();
 199
 200                         if (apath != null) {
 201                                 apath.InitTraversal();
 202 //                              System.out.println("Pick, actors " + apath.GetNumberOfItems() );
 203 //                              for (int i = 0; i < apath.GetNumberOfItems(); i++) {
 204 //                                      vtkAssemblyNode node = apath.GetNextNode();
 205 //                                      vtkProp test = (vtkProp) node.GetViewProp();
 206 //                                      System.out.println(test.GetClassName());
 207 //                              }
 208
 209                                 vtkAssemblyNode node = apath.GetLastNode();
 210                                 vtkProp test = (vtkProp) node.GetViewProp();
 211                                 apath.Delete();
 212                                 node.Delete();
 213                                 return new vtkProp[]{test};
 214
 215                         }
 216
 217                 } else if (pickType == 2) {
 218                         vtkPointPicker picker = new vtkPointPicker();
 219                         //picker.SetTolerance(2.0/(double)rw.GetSize()[0]);
 220                         picker.SetTolerance(0.00001);
 221                         Lock();
 222                         picker.Pick(new double[]{x, rw.GetSize()[1] - y,0}, ren);
 223                         UnLock();
 224
 225                         vtkAssemblyPath apath = picker.GetPath();
 226                         return processPick(picker, apath);
 227                 } else if (pickType == 3) {
 228                         vtkAreaPicker picker = new vtkAreaPicker();
 229                         Lock();
 230                         picker.Pick(new double[]{x, rw.GetSize()[1] - y,0}, ren);
 231                         //picker.AreaPick(x-1, rw.GetSize()[1] - y-1,x+1,rw.GetSize()[1] - y+1, ren);
 232                         UnLock();
 233                         vtkAssemblyPath apath = picker.GetPath();
 234                         return processPick(picker, apath);
 235                 } else if (pickType == 4) {
 236                         vtkCellPicker picker = new vtkCellPicker();
 237                         //picker.SetTolerance(2.0/(double)rw.GetSize()[0]);
 238                         picker.SetTolerance(0.00001);
 239                         Lock();
 240                         picker.Pick(new double[]{x, rw.GetSize()[1] - y,0}, ren);
 241                         UnLock();
 242                         vtkAssemblyPath apath = picker.GetPath();
 243                         return processPick(picker, apath);
 244                 }
 245
 246                 return null;
 247         }
 248
 249         public vtkProp[] pick2(int x, int y) {
 250
 251
 252 //              vtkPicker picker = new vtkPicker();
 253 //              vtkAbstractPicker picker = new vtkAbstractPicker();
 254 //              picker.Pick(x, rw.GetSize()[1] - y, ren);
 255 //              // see page 60 of VTK user's guide
 256 //
 257                 if (pickType == 0) {
 258
 259                         vtkPropPicker picker = new vtkPropPicker();
 260                         Lock();
 261                         picker.PickProp(x, rw.GetSize()[1] - y, ren);
 262
 263                         UnLock();
 264                         vtkPropCollection coll = picker.GetPickList();
 265                         return processPick(picker, coll);
 266
 267                 } else if (pickType == 1) {
 268                         if (scenePicker == null) {
 269                                 scenePicker = new vtkScenePicker();
 270                                 scenePicker.SetRenderer(ren);
 271                                 scenePicker.EnableVertexPickingOn();
 272
 273                         }
 274                         Lock();
 275
 276
 277                         vtkAssemblyPath apath = ren.PickProp(x, rw.GetSize()[1] - y);
 278
 279                         UnLock();
 280
 281                         if (apath != null) {
 282                                 apath.InitTraversal();
 283
 284
 285                                 vtkAssemblyNode node = apath.GetLastNode();
 286                                 vtkProp test = (vtkProp) node.GetViewProp();
 287                                 apath.Delete();
 288                                 node.Delete();
 289                                 return new vtkProp[]{test};
 290
 291                         }
 292
 293                 } else if (pickType == 2) {
 294                         vtkPointPicker picker = new vtkPointPicker();
 295                         picker.SetTolerance(2.0/(double)rw.GetSize()[0]);
 296                         Lock();
 297                         picker.Pick(new double[]{x, rw.GetSize()[1] - y,0}, ren);
 298                         UnLock();
 299                         vtkProp3DCollection coll = picker.GetProp3Ds();
 300                         return processPick(picker, coll);
 301                 } else if (pickType == 3) {
 302                         vtkAreaPicker picker = new vtkAreaPicker();
 303                         Lock();
 304                         picker.Pick(new double[]{x, rw.GetSize()[1] - y,0}, ren);
 305                         //picker.AreaPick(x-1, rw.GetSize()[1] - y-1,x+1,rw.GetSize()[1] - y+1, ren);
 306                         UnLock();
 307                         vtkProp3DCollection coll = picker.GetProp3Ds();
 308                         return processPick(picker, coll);
 309                 } else if (pickType == 4) {
 310                         vtkCellPicker picker = new vtkCellPicker();
 311                         picker.SetTolerance(2.0/(double)rw.GetSize()[0]);
 312                         Lock();
 313                         picker.Pick(new double[]{x, rw.GetSize()[1] - y,0}, ren);
 314                         UnLock();
 315                         vtkProp3DCollection coll = picker.GetProp3Ds();
 316                         return processPick(picker, coll);
 317                 }
 318
 319                 return null;
 320         }
 321
 322         private vtkProp[] processPick(vtkAbstractPicker picker, vtkAssemblyPath apath) {
 323 //              double[] pickPos = picker.GetPickPosition();
 324                 picker.Delete();
 325                 if (apath != null) {
 326                         apath.InitTraversal();
 327                         vtkProp result[] = new vtkProp[apath.GetNumberOfItems()];
 328                         for (int i = apath.GetNumberOfItems()-1; i >= 0; i--) {
 329                                 vtkAssemblyNode node = apath.GetNextNode();
 330                                 vtkProp test = (vtkProp) node.GetViewProp();
 331 //                              System.out.println("Picked: " + test.GetClassName() + " " + test.GetVTKId());
 332                                 result[i] = test;
 333                                 node.Delete();
 334                         }
 335                         apath.Delete();
 336                         return result;
 337
 338                 }
 339                 return null;
 340         }
 341
 342         private vtkProp[] processPick(vtkAbstractPicker picker, vtkPropCollection coll) {
 343 //              double[] pickPos = picker.GetPickPosition();
 344                 picker.Delete();
 345                 if (coll != null) {
 346                         coll.InitTraversal();
 347                         vtkProp result[] = new vtkProp[coll.GetNumberOfItems()];
 348                         for (int i = coll.GetNumberOfItems()-1; i >= 0; i--) {
 349                                 vtkProp test = coll.GetNextProp();
 350
 351 //                              System.out.println("Picked: " + test.GetClassName() + " " + test.GetVTKId());
 352                                 result[i] = test;
 353
 354                         }
 355                         coll.Delete();
 356                         return result;
 357
 358                 }
 359                 return null;
 360         }
 361
 362
 363         private vtkAwtAction defaultAction;
 364         private vtkAwtAction currentAction;
 365
 366         public void setActiveAction(vtkAction action) {
 367                 if (action.equals(currentAction))
 368                         return;
 369                 if (currentAction != null)
 370                         currentAction.deattach();
 371                 currentAction = (vtkAwtAction)action;
 372                 if (action != null)
 373                         action.attach();
 374         }
 375
 376         public void setDefaultAction(vtkAction defaultAction) {
 377                 this.defaultAction = (vtkAwtAction)defaultAction;
 378         }
 379
 380         public void useDefaultAction() {
 381                 setActiveAction(defaultAction);
 382         }
 383
 384         public vtkAction getDefaultAction() {
 385                 return defaultAction;
 386         }
 387
 388
 389         @Override
 390         public synchronized void Render() {
 391                 //System.out.println("Render " + rendering);
 392                 if (rendering)
 393                         return;
 394
 395                 firePreRender();
 396                 super.Render();
 397                 firePostRender();
 398         }
 399
 400
 401         public void addListener(RenderListener l) {
 402                 listeners.add(l);
 403         }
 404
 405         public void removeListener(RenderListener l) {
 406                 listeners.remove(l);
 407         }
 408
 409         private List<RenderListener> listeners = new ArrayList<RenderListener>();
 410
 411         List<RenderListener> list = new ArrayList<RenderListener>();
 412
 413         private void firePreRender() {
 414                 if (listeners.size() > 0) {
 415                         list.addAll(listeners);
 416                         for (RenderListener l : list)
 417                                 l.preRender();
 418                         list.clear();
 419                 }
 420         }
 421
 422         private void firePostRender() {
 423                 if (listeners.size() > 0) {
 424                         list.addAll(listeners);
 425                         for (RenderListener l : list)
 426                                 l.postRender();
 427                         list.clear();
 428                 }
 429         }
 430
 431
 432         private List<vtkObjectBase> deletable = new ArrayList<vtkObjectBase>();
 433
 434         public void addDeletable(vtkObjectBase o) {
 435                 deletable.add(o);
 436         }
 437
 438         public void removeDeletable (vtkObjectBase o) {
 439                 deletable.remove(o);
 440         }
 441
 442         @Override
 443         public void Delete() {
 444                 for (vtkObjectBase o : deletable) {
 445                         if (o.GetVTKId() != 0) {
 446                                 o.Delete();
 447                         }
 448                 }
 449                 deletable.clear();
 450
 451                 super.Delete();
 452         }
 453
 454         @Override
 455         public void refresh() {
 456                 repaint();
 457         }
 458
 459         @Override
 460         public double upscale(double d) {
 461                 return DPIUtil.upscale(d);
 462         }
 463
 464         @Override
 465         public int upscale(int i) {
 466                 return DPIUtil.upscale(i);
 467         }
 468
 469
 470
 471 }