org.simantics.g3d.vtk/src/org/simantics/g3d/vtk/swt/vtkCameraAndSelectorAction.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.swt;
  13
  14 import java.awt.event.InputEvent;
  15 import java.awt.event.MouseEvent;
  16 import java.awt.event.MouseWheelEvent;
  17 import java.util.ArrayList;
  18 import java.util.Collection;
  19 import java.util.List;
  20
  21 import org.eclipse.jface.viewers.ISelection;
  22 import org.eclipse.jface.viewers.ISelectionChangedListener;
  23 import org.eclipse.jface.viewers.ISelectionProvider;
  24 import org.eclipse.jface.viewers.SelectionChangedEvent;
  25 import org.eclipse.jface.viewers.StructuredSelection;
  26 import org.eclipse.swt.widgets.Display;
  27 import org.simantics.g3d.tools.AdaptationUtils;
  28
  29 import vtk.vtkCamera;
  30 import vtk.vtkProp;
  31 import vtk.vtkRenderWindow;
  32 import vtk.vtkRenderer;
  33
  34 public class vtkCameraAndSelectorAction extends vtkSwtAction implements ISelectionProvider {
  35
  36         protected vtkRenderer ren;
  37         protected int lastX;
  38         protected int lastY;
  39         protected vtkRenderWindow rw;
  40         protected vtkCamera cam;
  41         protected int InteractionMode = 1;
  42
  43         protected double activeRate = 5.0;
  44         protected double passiveRate = 0.01;
  45         protected boolean doNotRotate = true;
  46
  47         public vtkCameraAndSelectorAction(InteractiveVtkComposite panel) {
  48                 super(panel);
  49                 this.ren = panel.getRenderer();
  50                 this.rw = panel.getRenderWindow();
  51                 this.cam = ren.GetActiveCamera();
  52         }
  53
  54         public void Lock() {
  55                 panel.lock();
  56         }
  57
  58         public void UnLock() {
  59                 panel.unlock();
  60         }
  61
  62         public void InteractionModeRotate() {
  63                 this.InteractionMode = 1;
  64         }
  65
  66         public void InteractionModeTranslate() {
  67                 this.InteractionMode = 2;
  68         }
  69
  70         public void InteractionModeZoom() {
  71                 this.InteractionMode = 3;
  72         }
  73
  74         public void resetCameraClippingRange() {
  75                 Lock();
  76                 ren.ResetCameraClippingRange();
  77                 UnLock();
  78         }
  79
  80         public void resetCamera() {
  81                 Lock();
  82                 ren.ResetCamera();
  83                 UnLock();
  84         }
  85
  86         public boolean mousePressed(MouseEvent e) {
  87
  88                 if (ren.VisibleActorCount() == 0)
  89                         return false;
  90                 rw.SetDesiredUpdateRate(activeRate);
  91                 lastX = e.getX();
  92                 lastY = e.getY();
  93                 if ((e.getModifiers() == InputEvent.BUTTON2_MASK)
  94                                 || (e.getModifiers() == (InputEvent.BUTTON1_MASK | InputEvent.SHIFT_MASK))) {
  95                         InteractionModeTranslate();
  96                 } else if (e.getModifiers() == InputEvent.BUTTON3_MASK) {
  97                         InteractionModeZoom();
  98                 } else {
  99                         InteractionModeRotate();
 100                 }
 101                 return true;
 102         }
 103
 104         public boolean mouseReleased(MouseEvent e) {
 105                 rw.SetDesiredUpdateRate(passiveRate);
 106                 return true;
 107         }
 108
 109         public boolean mouseDragged(MouseEvent e) {
 110                 if (ren.VisibleActorCount() == 0)
 111                         return false;
 112                 int x = e.getX();
 113                 int y = e.getY();
 114                 // rotate
 115                 if (this.InteractionMode == 1) {
 116                         cam.Azimuth(lastX - x);
 117                         cam.Elevation(y - lastY);
 118                         if (doNotRotate)
 119                                 cam.SetRoll(0);
 120                         cam.OrthogonalizeViewUp();
 121                         resetCameraClippingRange();
 122                         // panel.UpdateLight();
 123                 }
 124                 // translate
 125                 if (this.InteractionMode == 2) {
 126                         double FPoint[];
 127                         double PPoint[];
 128                         double APoint[] = new double[3];
 129                         double RPoint[];
 130                         double focalDepth;
 131
 132                         // get the current focal point and position
 133                         FPoint = cam.GetFocalPoint();
 134                         PPoint = cam.GetPosition();
 135
 136                         // calculate the focal depth since we'll be using it a lot
 137                         ren.SetWorldPoint(FPoint[0], FPoint[1], FPoint[2], 1.0);
 138                         ren.WorldToDisplay();
 139                         focalDepth = ren.GetDisplayPoint()[2];
 140
 141                         APoint[0] = rw.GetSize()[0] / 2.0 + (x - lastX);
 142                         APoint[1] = rw.GetSize()[1] / 2.0 - (y - lastY);
 143                         APoint[2] = focalDepth;
 144                         ren.SetDisplayPoint(APoint);
 145                         ren.DisplayToWorld();
 146                         RPoint = ren.GetWorldPoint();
 147                         if (RPoint[3] != 0.0) {
 148                                 RPoint[0] = RPoint[0] / RPoint[3];
 149                                 RPoint[1] = RPoint[1] / RPoint[3];
 150                                 RPoint[2] = RPoint[2] / RPoint[3];
 151                         }
 152
 153                         /*
 154                          * Compute a translation vector, moving everything 1/2 the distance to the
 155                          * cursor. (Arbitrary scale factor)
 156                          */
 157                         cam.SetFocalPoint((FPoint[0] - RPoint[0]) / 2.0 + FPoint[0], (FPoint[1] - RPoint[1]) / 2.0 + FPoint[1],
 158                                         (FPoint[2] - RPoint[2]) / 2.0 + FPoint[2]);
 159                         cam.SetPosition((FPoint[0] - RPoint[0]) / 2.0 + PPoint[0], (FPoint[1] - RPoint[1]) / 2.0 + PPoint[1],
 160                                         (FPoint[2] - RPoint[2]) / 2.0 + PPoint[2]);
 161                         resetCameraClippingRange();
 162                 }
 163                 // zoom
 164                 if (this.InteractionMode == 3) {
 165                         double zoomFactor;
 166                         // double clippingRange[];
 167
 168                         zoomFactor = Math.pow(1.02, (y - lastY));
 169                         if (cam.GetParallelProjection() == 1) {
 170                                 cam.SetParallelScale(cam.GetParallelScale() / zoomFactor);
 171                         } else {
 172                                 cam.Dolly(zoomFactor);
 173                                 resetCameraClippingRange();
 174                         }
 175                 }
 176                 lastX = x;
 177                 lastY = y;
 178                 panel.refresh();
 179                 return true;
 180         }
 181
 182         @Override
 183         public boolean mouseWheelMoved(MouseWheelEvent e) {
 184                 double zoomFactor;
 185                 // double clippingRange[];
 186                 zoomFactor = Math.pow(1.02, (e.getWheelRotation()));
 187                 if (cam.GetParallelProjection() == 1) {
 188                         cam.SetParallelScale(cam.GetParallelScale() / zoomFactor);
 189                 } else {
 190                         cam.Dolly(zoomFactor);
 191                         resetCameraClippingRange();
 192                 }
 193                 panel.refresh();
 194                 return true;
 195         }
 196
 197         protected List<vtkProp> selectActors = new ArrayList<vtkProp>();
 198         protected List<vtkProp> hoverActor = new ArrayList<vtkProp>();
 199
 200         @Override
 201         public boolean mouseClicked(MouseEvent e) {
 202                 if (!panel.getComponent().isFocusControl())
 203                         return false;
 204                 if (e.getButton() != MouseEvent.BUTTON1)
 205                         return false;
 206                 vtkProp spick[] = panel.pick(e.getX(), e.getY());
 207                 if (spick != null && spick.length > 0) {
 208                         for (vtkProp selectActor : spick) {
 209                                 if (!e.isControlDown()) {
 210                                         selectActors.clear();
 211                                         selectActors.add(selectActor);
 212                                 } else {
 213                                         if (selectActors.contains(selectActor))
 214                                                 selectActors.remove(selectActor);
 215                                         else
 216                                                 selectActors.add(selectActor);
 217                                 }
 218                         }
 219                         fireSelectionChanged();
 220                 } else if (!e.isControlDown()) {
 221                         selectActors.clear();
 222                         fireSelectionChanged();
 223                 }
 224                 return true;
 225                 // if (e.getClickCount() > 1)
 226                 // updatePickRay(e.getX(), e.getY());
 227
 228         }
 229
 230         // private void updatePickRay(double x , double y) {
 231         // Ray ray = vtkUtil.createMouseRay(panel.GetRenderer(), x, y);
 232         //
 233         //
 234         // System.out.println(ray.pos + " " + ray.dir);
 235         // vtkPoints linePoints = new vtkPoints();
 236         // linePoints.InsertPoint(0,ray.pos.x, ray.pos.y, ray.pos.z);
 237         // linePoints.InsertPoint(1, ray.pos.x + ray.dir.x, ray.pos.y + ray.dir.y,
 238         // ray.pos.z + ray.dir.z);
 239         // vtkLine aLine = new vtkLine();
 240         // aLine.GetPointIds().SetId(0, 0);
 241         // aLine.GetPointIds().SetId(1, 1);
 242         // vtkUnstructuredGrid aLineGrid = new vtkUnstructuredGrid();
 243         // aLineGrid.Allocate(1, 1);
 244         // aLineGrid.InsertNextCell(aLine.GetCellType(), aLine.GetPointIds());
 245         // aLineGrid.SetPoints(linePoints);
 246         // vtkDataSetMapper aLineMapper = new vtkDataSetMapper();
 247         // aLineMapper.SetInput(aLineGrid);
 248         // vtkActor aLineActor = new vtkActor();
 249         // aLineActor.SetMapper(aLineMapper);
 250         // aLineActor.GetProperty().SetDiffuseColor(.2, 1, 1);
 251         //
 252         // if (rayActor != null) {
 253         // panel.GetRenderer().RemoveActor(rayActor);
 254         // rayActor.Delete();
 255         // }
 256         // rayActor = aLineActor;
 257         // panel.GetRenderer().AddActor(rayActor);
 258         //
 259         // linePoints.Delete();
 260         // aLine.Delete();
 261         // aLineGrid.Delete();
 262         // aLineMapper.Delete();
 263         // panel.repaint();
 264         // }
 265         //
 266         // private vtkActor rayActor;
 267
 268         @Override
 269         public boolean mouseMoved(MouseEvent e) {
 270                 lastX = e.getX();
 271                 lastY = e.getY();
 272
 273                 if (!panel.getComponent().isFocusControl())
 274                         return false;
 275                 List<vtkProp> prevHover = new ArrayList<vtkProp>();
 276                 prevHover.addAll(hoverActor);
 277                 hoverActor.clear();
 278                 vtkProp pick[] = panel.pick(e.getX(), e.getY());
 279                 if (pick != null) {
 280                         for (vtkProp p : pick)
 281                                 hoverActor.add(p);
 282                 }
 283
 284                 if (!prevHover.containsAll(hoverActor) || !hoverActor.containsAll(prevHover)) {
 285                         fireHoverChanged();
 286                 }
 287                 return true;
 288         }
 289
 290         public List<vtkProp> getSelectActor() {
 291                 return selectActors;
 292         }
 293
 294         public List<vtkProp> getHoverActor() {
 295                 return hoverActor;
 296         }
 297
 298         private List<ISelectionChangedListener> selectionListeners = new ArrayList<ISelectionChangedListener>();
 299
 300         @Override
 301         public void addSelectionChangedListener(ISelectionChangedListener listener) {
 302                 selectionListeners.add(listener);
 303         }
 304
 305         @Override
 306         public ISelection getSelection() {
 307                 return new StructuredSelection(selectActors);
 308         }
 309
 310         @Override
 311         public void removeSelectionChangedListener(ISelectionChangedListener listener) {
 312                 selectionListeners.remove(listener);
 313         }
 314
 315         @Override
 316         public void setSelection(ISelection selection) {
 317                 setSelection(selection, false);
 318
 319         }
 320
 321         public void setSelection(ISelection selection, boolean fire) {
 322                 Collection<vtkProp> selectedProps = AdaptationUtils.adaptToCollection(selection, vtkProp.class);
 323
 324                 selectActors.clear();
 325                 selectActors.addAll(selectedProps);
 326                 if (fire)
 327                         fireSelectionChanged();
 328         }
 329
 330         protected void fireSelectionChanged() {
 331                 Display.getDefault().asyncExec(new Runnable() {
 332                         @Override
 333                         public void run() {
 334
 335                                 SelectionChangedEvent evt = new SelectionChangedEvent(vtkCameraAndSelectorAction.this,
 336                                                 new StructuredSelection(selectActors));
 337                                 for (ISelectionChangedListener l : selectionListeners) {
 338                                         l.selectionChanged(evt);
 339                                 }
 340
 341                         }
 342                 });
 343         }
 344
 345         private List<ISelectionChangedListener> hoverListeners = new ArrayList<ISelectionChangedListener>();
 346
 347         public void addHoverChangedListener(ISelectionChangedListener listener) {
 348                 hoverListeners.add(listener);
 349         }
 350
 351         public ISelection getHoverSelection() {
 352                 return new StructuredSelection(hoverActor);
 353         }
 354
 355         public void removeHoverChangedListener(ISelectionChangedListener listener) {
 356                 hoverListeners.remove(listener);
 357         }
 358
 359         private void fireHoverChanged() {
 360                 Display.getDefault().asyncExec(new Runnable() {
 361                         @Override
 362                         public void run() {
 363                                 StructuredSelection sel = null;
 364                                 if (hoverActor == null)
 365                                         sel = new StructuredSelection();
 366                                 else
 367                                         sel = new StructuredSelection(hoverActor);
 368                                 SelectionChangedEvent evt = new SelectionChangedEvent(vtkCameraAndSelectorAction.this, sel);
 369                                 for (ISelectionChangedListener l : hoverListeners) {
 370                                         l.selectionChanged(evt);
 371                                 }
 372
 373                         }
 374                 });
 375         }
 376
 377         public void focus(double x, double y, double z) {
 378                 Lock();
 379                 cam.SetFocalPoint(x, y, z);
 380                 if (doNotRotate)
 381                         cam.SetRoll(0);
 382                 cam.OrthogonalizeViewUp();
 383                 resetCameraClippingRange();
 384                 // panel.UpdateLight();
 385                 UnLock();
 386         }
 387
 388 }