public class SoRayPickAction extends SoPickAction
setRay
and enableConicPickVolume
) for intersection with points and lines. Each intersection is returned as an SoPickedPoint
instance.
The picking ray can be specified as either a ray from the camera location through a particular viewport pixel, or as a world-space ray. Calling any of the setPoint
, setNormalizedPoint
, or setRadius
methods tells the action to compute the picking ray from a viewport pixel. In this case, a camera node must be encountered during traversal of the scene graph in order to determine the location of the ray in world space.
Callers can request the action to compute all intersections along the ray (sorted closest to farthest) by setting the pickAll flag to true. By default, the action computes only the closest intersection. In either case, the intersections are returned in an SoPickedPointList. Each intersection can be examined by accessing the appropriate SoPickedPoint
in the list. The SoPickedPoint
object provides methods to get the path (SoPath
) to the picked geometry in the scene graph, the intersection point in 3D space and other info.
The SoPickedPoint
object can also return one of the subclasses of SoDetail
, which contains more information about the picked geometry. For example, if a polygonal geometry node like SoIndexedFaceSet
was picked, an SoFaceDetail
object is returned which provides methods to get the index of the face in the primitive, the vertices of the face and so on. For vertex based geometry each vertex can then be queried as an SoPointDetail
.
Note: Texture coordinates for the picked point are not computed by default (to save time). If you need this information, use enableTexCoordsGeneration()
. Or set the environment variable OIV_PICK_GENERATE_ALL_PROPERTIES. You can also disable computing the normal vector for the picked if you do not need this information. See enableNormalsGeneration()
.
Open Inventor does true geometric picking in 3D coordinates (it does not use OpenGL for picking), so there are no limits on the number of objects in the scene or the number of objects that can be picked. Geometric picking means that precise intersections with the geometry are computed. It also means that picking works for any type of primitive, including polygonal geometry, meshes (MeshViz) and volumes (VolumeViz). The picking volume can be projected through the scene using orthogonal or perspective projection. See setRay
for details. The shape of the picking volume can be rectangular (prism if orthogonal, frustum if perspective) or conic (cylinder if orthogonal, cone if perspective). See enableConicPickVolume()
.
In the default mode, Inventor computes the intersection of the pick ray with geometry nodes (face, line, point, volume, mesh, etc). In this case SoPickedPoint.getPoint()
returns the coordinate of the intersection and SoPickedPoint.getDetail()
typically returns an SoDetail
class specific to the picked geometry. Since Open Inventor 9.0, SoRayPickAction
also supports a POINT_PICKING mode (see PickingMode
). In this mode, Inventor finds all the vertices inside the pick radius. This is only supported for SoBufferedShape
and classes derived from SoIndexedShape
. This mode can be much faster because, for example, it does not need to check for intersection with all the triangles of an SoIndexedFaceSet
.
Applications can use the SoPickStyle
node to control if and how geometry can be picked. For example application might want to specify that annotation geometry, e.g. a legend, is not pickable. It can also specify that geometry should be picked using its bounding box rather than exact geometry. This may be more efficient for text strings when it is not necessary to know which character in the string was picked.
The application can get platform independent input events, e.g. mouse button press, as SoEvent
objects using the SoEventCallback
node. In the callback function the application can create an SoRayPickAction
and apply it to the scene graph. Note however that the application can also simply call the node's getPickedPoint()
method. In this case Open Inventor automatically applies a pick action to the scene graph and returns the result, so the application does not need to use SoRayPickAction
directly. Creating and using an SoRayPickAction
explicitly does allow more options to be set. In this case the application will normally call setPoint
with the position obtained from the event object. If using system events directly, remember that Open Inventor expects Y pixel values to start from zero at the bottom of the window.
The SoSelection
node provides an even higher level way to manage selecting and de-selecting objects in the scene. This node automatically applies a pick action and maintains a list of currently selected objects (paths). Using SoSelection
the application does not need to use SoRayPickAction
directly. The SoExtSelection
node provides more complex picking algorithms. For example it allows the user to select objects using a "rubberband" rectangle or a freeform shape (lasso). Open Inventor provides special render actions that can automatically highlight objects selected using an SoSelection
or SoExtSelection
node. See SoBoxHighlightRenderAction
and SoLineHighlightRenderAction
.
Optimization
Pick traversals are optimized using hierarchical bounding boxes cached at the SoSeparator
(and a few other) grouping nodes. If the pick ray does not intersect the bounding box then the pick action will not traverse the children of that separator. When optimizing for picking the application should consider first how quickly can Open Inventor find the geometry that should be picked. Organizing the scene graph spatially to take advantage of the bounding box optimization can help with this. Second the application should consider how long will it take to find the face that should be picked. For a very large surface this can be significant. Enabling triangle culling, splitting large surfaces into smaller pieces or using proxy geometry may be helpful.
Note that when using SoRayPickAction
with pixel coordinates (setPoint()
) the pick action must traverse a camera node in order to unproject the coordinate back into 3D space. If the application explicitly creates its own camera, this is usually not a problem because the camera is in the application scene graph. However if the application allows the viewer to automatically create a camera then the camera is in the viewer's scene graph
above the application scene graph. Calling the viewer's getSceneGraph() method returns the application scene graph, not the complete viewer scene graph. To ensure that the traversed scene graph contains a camera, call the viewer's getSceneManager()
method, then call the scene manager's getSceneGraph method. Alternatively, in an event callback call the event action's getPickRoot() method.
SoVolumeRender
nodes: Since Open Inventor 8.6, the SoVolumeRender
node (by default) uses the GPU to compute the picked voxel during an SoRayPickAction
. For this to work, the SoRayPickAction
must have its scene manager initialised using the method SoAction.setSceneManager()
. SoHandleEventAction
does this automatically, so it is not necessary for the application to take any action when using (for example) an SoEventCallback
node and calling the getPickedPoint()
method. However if the application creates its own SoRayPickAction
then it should set the scene manager. If no scene manager is specified, a warning message is issued and software picking is done. If necessary, using the GPU for volume picking may be disabled by setting the environment variable IVVR_GPU_PICKING to 0 (see SoPreferences
).
SoRayPickAction
creates one or more SoPath
objects when applied to the scene graph. The SoPath
object references each node in the path. This reference will prevent the node and its associated memory from being reclaimed for as long as the SoPath
object exists. These SoPath
objects are stored internally in the action and exist until the action object itself is reclaimed or reset (see clearApplyResult()). Shapes that redefine the rayPick method:
In order to make this action work properly with respect to the picked path stored in the picked point list, any shape that redefines the rayPick method must either call the method SoRayPickAction.setObjectSpace()
or the method SoShape.computeObjectSpaceRay() in its rayPick method before calling the addIntersection()
methods. See the chapter "Creating a node - Creating a Shape Node - Picking" in the Inventor Toolmaker Volume 1.
SoPickRayElement
, SoViewportRegionElement
Do picking using an SoEventCallback
node.
Note: In this case, you could do picking by simply calling the SoHandleEventAction
's getPickedPoint()
method, which applies an SoRayPickAction
internally. However it may be necessary to use SoRayPickAction
directly in order to set specific options.
class mouseBtnCB extends SoEventCallbackCB { @Override public void invoke( SoEventCallback node ) { SoMouseButtonEvent evt = (SoMouseButtonEvent)node.getEvent(); // If button 1 was pressed if (SoMouseButtonEvent.isButtonPressEvent( evt, SoMouseButtonEvent.Buttons.BUTTON1 )) { SoHandleEventAction action = node.getAction(); SoRayPickAction rayPick = new SoRayPickAction( action.getViewportRegion() ); rayPick.setPoint( evt.getPosition() ); rayPick.setRadius( 10 ); // Optional: Use larger pick radius rayPick.apply( action.getPickRoot() ); SoPickedPoint pickedPt = rayPick.getPickedPoint(); if (pickedPt != null) { SoPath pickedPath = pickedPt.getPath(); SoNode pickedNode = pickedPath.full.getTail(); } } } }
See also:
SoPickedPoint
, SoPickedPointList, SoPickStyle
Modifier and Type | Class and Description |
---|---|
static class |
SoRayPickAction.PickingModes |
SoAction.AppliedCodes, SoAction.DistribModes, SoAction.PathCodes, SoAction.PathIndices
Inventor.ConstructorCommand
VERBOSE_LEVEL, ZeroHandle
Constructor and Description |
---|
SoRayPickAction(SbViewportRegion viewportRegion)
Constructor takes viewport region to use for picking.
|
Modifier and Type | Method and Description |
---|---|
SoPickedPoint |
addIntersection(SbVec3f objectSpacePoint)
Adds an
SoPickedPoint instance representing the given object space point to the current list and returns it. |
SoPickedPoint |
addIntersection(SoPickedPoint pp) |
void |
clearPickedPointList()
Deprecated.
As of Open Inventor 9600 Use clearApplyResult() method
|
void |
computeWorldSpaceRay() |
void |
enableConicPickVolume(boolean flag)
Controls the pick volume shape for picking with
setRay() . |
static void |
enableElement(java.lang.Class<? extends Inventor> t,
int stkIndex) |
void |
enableNormalsGeneration(boolean enable)
Enables generation of normal vectors for picked points.
|
void |
enableRadiusForTriangles(boolean flag)
Enable radius for triangle-based shape.
|
void |
enableTexCoordsGeneration(boolean enable)
Enables generation of texture coordinates for picked points.
|
static void |
enableTriangleCulling(boolean flag)
Enables culling of triangles relative to the ray frustum.
|
SbLine |
getLine() |
SbVec2f |
getNormalizedPoint()
Gets the viewport point in normalized coordinates
|
SoPickedPoint |
getPickedPoint()
Calls getPickedPoint((int)0).
|
SoPickedPoint |
getPickedPoint(int index)
Returns the indexed picked point from the list.
|
java.util.Vector<SoPickedPoint> |
getPickedPointList()
Returns list of picked points.
|
int |
getPickedPointsListLength() |
SoRayPickAction.PickingModes |
getPickingMode()
Returns the
PickingMode used for the ray pick action. |
SbVec2s |
getPoint()
Gets the viewport point in pixels (returns the last value passed to
setPoint ). |
SbVec2f |
getPointFloat()
Float version of
getPoint() . |
float |
getRadius()
Gets the radius (in pixels) around the point.
|
static SoCamera.StereoModes |
getStereoMode()
Returns the view used to perform pick when stereo is active.
|
SoPickedPoint |
getUnsortedPickedPoint(int i) |
SbViewVolume |
getViewVolume() |
boolean |
hasWorldSpaceRay() |
boolean |
intersect(SbBox3f box)
Calls intersect(box, true).
|
boolean |
intersect(SbBox3f box,
boolean useFullViewVolume)
Bounding box: just return whether the ray intersects it.
|
boolean |
intersect(SbVec3f point) |
SbVec3f |
intersect(SbVec3f v0,
SbVec3f v1) |
boolean |
intersect(SbXfBox3f box)
Calls intersect(box, true).
|
boolean |
intersect(SbXfBox3f box,
boolean useFullViewVolume)
Bounding box: just return whether the ray intersects it.
|
boolean |
isBetweenPlanes(SbVec3f intersection) |
boolean |
isConicPickVolume()
Returns true if the picking volume is a conic shape (not a frustum).
|
boolean |
isNormalsGenerationEnabled()
Returns whether generation of normal vectors is enabled for picked points.
|
boolean |
isPickAll()
Returns whether the action will return all objects intersected or just the closest one.
|
boolean |
isRadiusEnableForTriangles()
Returns whether the pick radius specified by
setRadius is taken into account for picking on triangle-based shapes. |
boolean |
isTexCoordsGenerationEnabled()
Returns whether texture coordinate generation is enabled for picked points.
|
static boolean |
isTriangleCulling()
Returns whether triangle culling is enabled.
|
void |
setNormalizedPoint(SbVec2f normPoint)
Sets the viewport point in normalized coordinates, which range from (0,0) at the lower left to (1,1) at the upper right.
|
void |
setObjectSpace() |
void |
setObjectSpace(SbMatrix matrix) |
void |
setPickAll(boolean flag)
Sets whether the action will return all objects intersected or just the closest one.
|
void |
setPickingMode(SoRayPickAction.PickingModes pickingMode)
Sets the picking mode.
|
void |
setPoint(SbVec2f viewportPoint)
Float version of
setPoint . |
void |
setPoint(SbVec2s viewportPoint)
Sets the viewport point through which the ray passes, starting at the camera position.
|
void |
setRadius(float radius)
Sets the radius around the point.
|
void |
setRay(float fovy,
SbVec3f start,
SbVec3f direction)
Calls setRay(fovy, start, direction, (float)-1.0, (float)-1.0).
|
void |
setRay(float fovy,
SbVec3f start,
SbVec3f direction,
float nearDistance)
Calls setRay(fovy, start, direction, nearDistance, (float)-1.0).
|
void |
setRay(float fovy,
SbVec3f start,
SbVec3f direction,
float nearDistance,
float farDistance)
Sets a world-space ray along which to pick in the the same way as the other version of
setRay() , but allows you to set a view angle value. |
void |
setRay(SbVec3f start,
SbVec3f direction)
Calls setRay(start, direction, (float)-1.0, (float)-1.0).
|
void |
setRay(SbVec3f start,
SbVec3f direction,
float nearDistance)
Calls setRay(start, direction, nearDistance, (float)-1.0).
|
void |
setRay(SbVec3f start,
SbVec3f direction,
float nearDistance,
float farDistance)
Sets a world-space ray along which to pick.
|
static void |
setStereoMode(SoCamera.StereoModes stereoMode)
Tells ray pick action in which view the pick occurs.
|
enableCulling, getViewportRegion, isCullingEnabled, setViewportRegion
apply, apply, clearApplyResult, forwardTraversal, getContinueActionInBranchFlag, getCurPath, getDistribMode, getNodeAppliedTo, getOriginalPathListAppliedTo, getPathAppliedTo, getPathCode, getPathListAppliedTo, getPipeId, getSceneManager, getState, getWhatAppliedTo, hasTerminated, invalidateState, isBeingApplied, isLastPathListAppliedTo, isUsingAlternateRep, nullAction, postDelayedTraversal, preDelayedTraversal, resetContinueActionInBranchFlag, setPipeId, setSceneManager, setUpState, stopActionInBranch, traverse, useAlternateRep
dispose, getNativeResourceHandle
public SoRayPickAction(SbViewportRegion viewportRegion)
public void setRay(SbVec3f start, SbVec3f direction)
public boolean intersect(SbBox3f box)
public SoPickedPoint getPickedPoint()
public void setRay(SbVec3f start, SbVec3f direction, float nearDistance)
public void setRay(float fovy, SbVec3f start, SbVec3f direction)
public void setRay(float fovy, SbVec3f start, SbVec3f direction, float nearDistance)
public boolean intersect(SbXfBox3f box)
public void setPickAll(boolean flag)
public void setRay(SbVec3f start, SbVec3f direction, float nearDistance, float farDistance)
SoCamera
. A negative distance (such as the default values) means disable clipping to that plane.
The ray-picking is orthogonal. This means the pick volume is a rectangular prism with a square base having edges of length setRadius
* 2 or else a cylinder having radius setRadius
if enableConicPickVolume
is set to true.
NOTE: You can use this method or the setPoint
/ setNormalizedPoint
Whichever method you call last is the one that takes effect.
public void setRay(float fovy, SbVec3f start, SbVec3f direction, float nearDistance, float farDistance)
setRay()
, but allows you to set a view angle value.
The ray is defined as a world space starting point and direction vector. The direction vector will be normalized automatically. The last two arguments specify optional near and far plane clipping during the pick operation. These values are distances from the start point along the direction vector, similar to nearDistance and farDistance in SoCamera
. A negative distance (such as the default values) means disable clipping to that plane.
If fovy is non-zero, perspective ray-picking is used. This means the pick volume is a frustum intersecting the plane passing through the point specified as start argument and having normal vector specified by the direction argument and whose base is a square having edges of length setRadius
* 2 or else a circle of radius setRadius
if enableConicPickVolume
is set to true.
NOTE: You can use this method or the setPoint
/ setNormalizedPoint
Whichever method you call last is the one that takes effect.
public boolean isPickAll()
public void enableRadiusForTriangles(boolean flag)
setRadius
is taken in account when checking for a ray intersection with triangle-based shapes (e.g., SoCylinder
). Otherwise, the pick radius for these shapes is 1 pixel regardless of the specified pick radius. Default is false for performance.public boolean isRadiusEnableForTriangles()
setRadius
is taken into account for picking on triangle-based shapes.public void enableTexCoordsGeneration(boolean enable)
public java.util.Vector<SoPickedPoint> getPickedPointList()
SoPickedPoint
object in the list.public SoPickedPoint getPickedPoint(int index)
@Deprecated public void clearPickedPointList()
public SoRayPickAction.PickingModes getPickingMode()
PickingMode
used for the ray pick action.public void setPoint(SbVec2s viewportPoint)
NOTE: You can use this method or setNormalizedPoint
or setRay
. Whichever method you call last is the one that takes effect.
public void setPoint(SbVec2f viewportPoint)
setPoint
.
It can be used when a desktop is magnified on a wall of screens using ScaleViz with a tracker device calibrated for this wall.
NOTE: You can use this method or setNormalizedPoint
or setRay
. Whichever method you call last is the one that takes effect.
public void setObjectSpace()
public void setPickingMode(SoRayPickAction.PickingModes pickingMode)
public SbVec2f getNormalizedPoint()
If no point has been set or the setRay method was called instead of setXXXPoint, this method returns an undefined coordinate (NaN, NaN).
public void setRadius(float radius)
setPoint
or setNormalizedPoint
method, and is defined in world coordinates, when the ray is defined using the setRay
method. By default, for the setPoint and setNormalizedPoint method the radius is 5 pixels.
For the setRay method, by default, the radius is not taken into account for triangle based shapes, only for points and lines. To enable this use the enableRadiusForTriangles
method. When radius is taken into account, the ray is extended in 3D space. For perspectivecameras, the ray is extended to be a cone. For orthographic cameras, the ray is extended to be a cylinder.
Specifying a radius of 0 may give better performance. In particular, some shapes like MoMeshSkin and SoIndexedFaceSet
implement a fast GPU picking algorithm that can only be used when radius is 0.
public float getRadius()
public SbVec2s getPoint()
setPoint
).public SbVec2f getPointFloat()
getPoint()
.
It can be used when a desktop is magnified on a wall of screens using ScaleViz with a tracker device calibrated for this wall.public void setNormalizedPoint(SbVec2f normPoint)
public int getPickedPointsListLength()
public boolean intersect(SbBox3f box, boolean useFullViewVolume)
public SoPickedPoint getUnsortedPickedPoint(int i)
public void setObjectSpace(SbMatrix matrix)
public boolean intersect(SbVec3f point)
public SbLine getLine()
public boolean isBetweenPlanes(SbVec3f intersection)
public SoPickedPoint addIntersection(SbVec3f objectSpacePoint)
SoPickedPoint
instance representing the given object space point to the current list and returns it.
If pickAll is true, this inserts the instance in correct sorted order. If it is false, it replaces the one instance in the list only if the new one is closer; if the new one is farther away, no instance is created and NULL is returned, meaning that no more work has to be done to set up the SoPickedPoint
.public boolean intersect(SbXfBox3f box, boolean useFullViewVolume)
public SoPickedPoint addIntersection(SoPickedPoint pp)
public SbViewVolume getViewVolume()
public void enableConicPickVolume(boolean flag)
setRay()
.
The default is false, meaning that the picking volume is a rectangular shape, either a prism or a frustum (depending on which version of setRay was called). When enableConicPickVolume is true the picking volume is a conic shape, either a cylinder or a cone (depending on which version of setRay was called).
Setting enableConicPickVolume to true ensures that the entities picked using setRay()
will be the same as picking using an equivalent call to setPoint()
, but this mode is slightly more costly than frustum picking.
public boolean isConicPickVolume()
public static void setStereoMode(SoCamera.StereoModes stereoMode)
public void enableNormalsGeneration(boolean enable)
public boolean isTexCoordsGenerationEnabled()
enableTexCoordsGeneration()
.public boolean isNormalsGenerationEnabled()
enableNormalsGeneration()
.public static void enableElement(java.lang.Class<? extends Inventor> t, int stkIndex)
public void computeWorldSpaceRay()
public boolean hasWorldSpaceRay()
public static SoCamera.StereoModes getStereoMode()
public static void enableTriangleCulling(boolean flag)
public static boolean isTriangleCulling()
Generated on July 31, 2019, Copyright © Thermo Fisher Scientific. All rights reserved. http://www.openinventor.com