Slides - Ocean - Schlumberger

18: User Interface - Interaction 

User Interface - Interaction 

Ocean for Petrel 2012.1 

© 2012 Schlumberger. All rights reserved. www.ocean.slb.com/developers 

1


Objectives 

Ocean Petrel UI interaction concepts and customization 

Petrel native window modes 

picking interfaces 

custom window modes 


2


Interactions in Petrel windows 

Users interact with domain objects displayed in Petrel windows 

native Petrel windows are always in given window mode 

available from Petrel UI process toolbar 

mode defines interpretation of interactive events 

viewing 

measure distance 

manipulate plane 

magnify 

picking 

drag plane 

Petrel window modes 


3


Native Petrel window modes 

WellKnownWindowModes exposes native window modes 

standard 

modes for 

all windows 

public static class WellKnownWindowModes 

{ ... 

static WindowMode Viewing; 

static WindowMode Magnify; 

static WindowMode MeasureDistance; 

static WindowMode PickSelect; 

static WindowMode ManipulatePlane; 

} 

static IEnumerable All { get; } 


4


Native Petrel window modes, continued 

Some window modes are specific to 3D windows 

3D window 

specific modes 

public static class WellKnownWindowModes 

{ ... 

static WindowMode BoundingBoxSelect; 

static WindowMode AddNewPillarBy1Point; 

static WindowMode AddNewPillarBy2Points; 

static WindowMode SelectEditLine; 

static WindowMode Eraser; 

... 

} 


5


Process - WindowMode association 

Window modes available to end user are defined by Process 

override WindowModesCore to define window modes 

class MyProcess : Process 

{ ... 

private IList myWinModes; 

public MyProcess() : base("MyProcess") 

{ myWinModes = new List(); 

myWinModes.Add(WellKnownWindowModes.Viewing); 

myWinModes.Add(WellKnownWindowModes.Magnify); 

myWinModes.Add(WellKnownWindowModes.SelectPick); 

myWinModes.Add(...); 

} 

// return list of allowed window modes 

protected override IEnumerable WindowModesCore 

{ get { return myWinModes; } } 

} 


6


Using process-window combination 

Window modes controlled by active process/window combination 

active 

process 


active 

window 

window 

modes 

7


Active process-window example 

Check active window in WindowModesCore 

called 

when 

process 

is active 

is map 

window 

active 

class MyProcess : Process 

{ 

MyWindowMode sel = ... 

... 


{ 

get 

{ 

IToggleWindows wm = PetrelProject.ToggleWindows; 

bool SelInModes = myWinModes.Contains(sel); 

if (wm.Active is MapWindow) 

{ 

if (!SelInModes) 

myWinModes.Add(sel); 

} 

else if (SelInModes) 

myWinModes.Remove(sel); 

return myWinModes; 

} 

} 

} 


8


Window mode class 

WindowMode represents interactive mode in Petrel 

configure tool, cursor, visibility, activation 

decide visibility based on active window/object/process 

– disable if window mode cannot be used 

public abstract class WindowMode 

{ ... 

virtual Bitmap BitmapCore { get; } 

virtual string ToolTipCore { get; } 

virtual Cursor GetCursorCore { get; } 

} 

virtual bool CanBeVisibleCore { get; } 

virtual bool CanBeActivatedCore { get; } 

virtual void OnActivateCore( WindowModeContext context); 

virtual void OnDeactivateCore(WindowModeContext context); 


9


Window mode class and interaction 

Interactive events in window channeled to active window mode 

mouse events used to manipulate domain object or record info 

each event provides event information 


{ ... 

virtual void OnDragCore (PickedPoint args); 

virtual void OnDragFinishCore(PickedPoint args); 

virtual void OnDragStartCore (PickedPoint args); 

virtual void OnMouseClickCore(PickedPoint args); 

virtual void OnKeyDownCore (PickedPoint args); 

virtual void OnKeyUpCore (PickedPoint args); 

} 


10


PickedPoint class 

Describes interactive event at world position in any Petrel window 

subclass for each extensible renderer 

mouse buttons, 

keys state 

vertical domain 

active process 

world position 

window mode 

gets description 

of current pick 

public class PickedPoint 

{ ... 

MouseButtons Button { get; } 

bool ControlIsPressed { get; } 

bool ShiftIsPressed { get; } 

Keys KeyData { get; } 

object DomainObject { get; } 

Domain DomainZ { get; } 

Process Process { get; } 

IToggleWindow Window { get; } 

virtual Point3 World { get; set; } 

IEnumerable PickString { get; set; } 

} 


11


Interaction and custom domain objects 

Window mode uses picked point information in mouse events 

system can not set picked point info for custom domain objects 

you supply picked point information via picking interfaces 

– for 3D, map, interpretation/intersection window where interaction 

needed 

I*Picking adds 

more information if 

custom object hit 

*PickedPoint 


*WindowMode 

uses picked point 

info to manipulate 

domain object or 

record information 

12


Picking interfaces 

Implement picking interface to give hit/pick information 

for interaction with custom domain objects 

on same class that implements renderer interface 

IMapRenderer 

implements 

IIntersectionRenderer 

implements 

IWindow3DRenderer 

implements 

IMapPicking 


IIntersectionPicking 

IWindow3DPicking 

13


IMapPicking 

IMapPicking gives map hit/pick info 

check geometry of custom domain object 

set IsHit to true when custom domain object is hit 

public interface IMapPicking 

{ 

void GetPickInfo(object o, MapPickedPoint pt, 

MapRendererContext cxt); 

} 

set explicitly 

get location 

if null, set it 

public class MapPickedPoint : PickedPoint 

{ ... 

bool IsHit { get; set; } 

Ray3 Ray { get; } 

Point3 World { get; set; } 

} 


14


IIntersectionPicking 

IIntersectionPicking gives intersection hit/pick info 

pick string is displayed if user moves mouse over domain 

object 

public interface IIntersectionPicking 

{ 

void GetPickInfo(object o, IntersectionPickedPoint pt, 

IntersectionRendererContext cxt); 

} 

horizontal position 

on-plane world coordinate 

may be null 

will always be defined 

public class IntersectionPickedPoint : PickedPoint 

{ ... 

double HorizontalHit { get; } 

Point3 IntersectionHit { get; } 

bool IsHit { get; set; } 



double ZHit { get; } 

} 


15


IWindow3DPicking 

IWindow3DPicking gives 2D/3D pick info 

no IsHit property to set, Ocean detects hit on its own 

public interface IWindow3DPicking 

{ 

void GetPickInfo(object o, Window3DPickedPoint p, 

Window3DRendererContext cxt); 

} 

local pixel coordinate 

null if object not hit 

path from root till hit node 

public class Window3DPickedPoint : PickedPoint 

{ ... 

Point Pixel { get; } 



Point3 WorldHit { get; } 

SoPickedPoint PickDetail { get; } 

SoPath PickPath { get; } 

} 


16


Custom window mode interaction scenario 

Scenario: end user interacting with custom domain object 

move/drag circle in Map window, updating its location 

1. end user 

displays 

object 

2. end user 

activates process 


3. end user 

activates 

custom Move 

window mode 

4. end user 

moves object 

17


Custom window mode steps 

Steps to enable interaction with custom object in Map window: 

1. implement custom WindowMode class 

a. appearance: override icon, tooltip and cursor 

b. interactions: override mouse events 

2. add custom window mode(s) to Process class 

3. implement picking interface in renderer for custom objects 


18


Custom window mode example [step 1] 

Derive from abstract class to implement custom MoveXYZ mode 

appearance: override icon, tooltip and cursor 

interactions: override mouse events 


{ ... 

virtual Bitmap BitmapCore { get; } 

virtual string ToolTipCore { get; } 

virtual Cursor GetCursorCore { get; } 

} 

virtual void OnDragStartCore (PickedPoint args); 

virtual void OnDragCore (PickedPoint args); 

class MoveXYZWindowMode : WindowMode 

{ ... } 


19


Custom window mode appearance [step 1a] 

Provide overrides for icon, tooltip and cursor 

icon and tooltip are required for tool button 

mouse cursor can be customized 


{ ... 

protected override Bitmap BitmapCore 

{ get { return PetrelImages.Wand; } } 

protected override string ToolTipCore 

{ get { return "Move XYZ"; } } 

protected override Cursor GetCursorCore(PickedPoint args) 

{ 

if (args.DomainObject is XYZObject) return Cursors.Cross; 

else return Cursors.Default; 

} 

} 


20


Custom window mode – start drag [step 1b] 

OnDragStartCore called when dragging starts 

get window, domain object, current location from picked point 


{ ... 

private Point2 m_offset; 

private XYZObject m_xyz; 

protected override void OnDragStartCore(PickedPoint args) 

{ 

MapWindow w = args.Window as MapWindow; 

if (w == null) return; 

MapPickedPoint mapArgs = args as MapPickedPoint; 

m_xyz = mapArgs.DomainObject as XYZObject; 

if (m_xyz == null || mapArgs.World == null) return; 

// save offset from clicked point to circle center 

// used to give smooth movement of circle when dragging 

m_offset = new Point2((double)m_xyz.X – (double)mapArgs.World.X, 

(double)m_xyz.Y – (double)mapArgs.World.Y); 

} } 


21


Custom window mode – update position [step 1b] 

OnDragCore updates object position with new coordinates 

get current mouse coordinate from MapPickedPoint 


{ ... 

protected override void OnDragCore(PickedPoint args) 

{ 

MapWindow w = args.Window as MapWindow; 

if (w == null) return; 

MapPickedPoint mapArgs = args as MapPickedPoint; 

m_xyz = mapArgs.DomainObject as XYZObject; 

if (m_xyz == null || mapArgs.World == null) return; 

// new position is current mouse coord + offset 

m_xyz.X = (float)mapArgs.World.X + (float)m_offset.X; 

m_xyz.Y = (float)mapArgs.World.Y + (float)m_offset.Y; 

} 

} 


22


Add custom window mode to process [step 2] 

Check active window and if custom window mode in mode list 

class InteractionProcess : Process 

{ ... 

MoveXYZWindowMode moveXYZMode; List myWinModes; 

public InteractionProcess() : base("InteractionProcess") 

{ 

moveXYZMode = new MoveXYZWindowMode(); 

myWinModes = new List(); 

myWinModes.Add(WellKnownWindowModes.Viewing); 

myWinModes.Add(WellKnownWindowModes.PickSelect); 

} 


{ 

get { bool inModes = myWinModes.Contains(moveXYZMode); 

if (PetrelProject.ToggleWindows.Active is MapWindow) 

{ if (!inModes) myWinModes.Add(moveXYZMode); } 

else if (inModes) 

myWinModes.Remove(moveXYZMode); 

return myWinModes; 

} 

} 

} 


23


Implement IMapPicking [step 3] 

Implement IMapPicking on same class as renderer 

if hit is in custom domain object geometry, set IsHit 

set object’s Z value if required 

class XYZMapView : IMapRenderer, IMapPicking 

{ 

public void GetPickInfo(object o, MapPickedPoint pt, MapRendererContext c) 

{ 

if (o is XYZObject) 

{ 

XYZObject xyz = o as XYZObject; 

// is picked point in xyz’s geometry? get distance and compare to radius 

Point2 xyzCtr = new Point2(xyz.X, xyz.Y); 

Point2 pickPt = new Point2(pt.Ray.Origin.X, pt.Ray.Origin.Y); 

Segment2 seg = new Segment2(xyzCtr, pickPt); 

if (seg.Length


Interaction in well section window 

Different pattern for well section window interaction 

picked point data populated by framework, no picking interface 

override PickCore in derived well section visual class 

window mode uses VisualPick enumerable 

horizontal value 

corresponds to a point 

along trajectory 

world Z value 

public class WellSectionPickedPoint : PickedPoint 

{ ... 

Borehole Borehole { get; } 

Domain DomainZ { get; } 

double TrackValue { get; } 


double MD { get; } 

double Z { get; } 

cgPoint WindowPoint { get; } 

cgTransformation WindowTransformation { get; } 

IEnumerable PickedObjects { get; } 

} 


25


Summary 

Interaction customization 

can re-use Petrel native window modes 

can create custom window modes 


26

Slides - Ocean - Schlumberger

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?