0026710: Coding rules - eliminate GCC warning -Wunused-result in Voxel_Reader.cxx
[occt.git] / dox / user_guides / visualization / visualization.md
CommitLineData
ba06f8bb 1Visualization {#occt_user_guides__visualization}
bf62b306 2========================
3@tableofcontents
72b7576f 4
bf62b306 5@section occt_visu_1 Introduction
72b7576f 6
2683e647 7Visualization in Open CASCADE Technology is based on the separation of:
bf62b306 8 * on the one hand - the data which stores the geometry and topology of the entities you want to display and select, and
9 * on the other hand - its **presentation** (what you see when an object is displayed in a scene) and **selection** (possibility to choose the whole object or its sub-parts interactively to apply application-defined operations to the selected entities).
72b7576f 10
18006a0f 11Presentations are managed through the **Presentation** component, and selection through the **Selection** component.
72b7576f 12
18006a0f 13**Application Interactive Services** (AIS) provides the means to create links between an application GUI viewer and the packages, which are used to manage selection and presentation, which makes management of these functionalities in 3D more intuitive and consequently, more transparent.
72b7576f 14
18006a0f 15*AIS* uses the notion of the *interactive object*, a displayable and selectable entity, which represents an element from the application data. As a result, in 3D, you, the user, have no need to be familiar with any functions underlying AIS unless you want to create your own interactive objects or selection filters.
72b7576f 16
bf62b306 17If, however, you require types of interactive objects and filters other than those provided, you will need to know the mechanics of presentable and selectable objects, specifically how to implement their virtual functions. To do this requires familiarity with such fundamental concepts as the sensitive primitive and the presentable object.
72b7576f 18
2683e647 19The the following packages are used to display 3D objects:
4ee1bdf4 20 * *AIS*;
21 * *StdPrs*;
22 * *Prs3d*;
23 * *PrsMgr*;
24 * *V3d*;
25 * *Graphic3d*.
72b7576f 26
18006a0f 27The packages used to display 3D objects are also applicable for visualization of 2D objects.
72b7576f 28
bf62b306 29The figure below presents a schematic overview of the relations between the key concepts and packages in visualization. Naturally, "Geometry & Topology" is just an example of application data that can be handled by *AIS*, and application-specific interactive objects can deal with any kind of data.
72b7576f 30
bf62b306 31@image html visualization_image003.png "Key concepts and packages in visualization"
32@image latex visualization_image003.png "Key concepts and packages in visualization"
72b7576f 33
2683e647 34To answer different needs of CASCADE users, this User's Guide offers the following three paths in reading it.
35
bf62b306 36 * If the 3D services proposed in AIS meet your requirements, you need only read chapter 3 <a href="#occt_visu_3">AIS: Application Interactive Services</a>.
18006a0f 37 * If you need more detail, for example, a selection filter on another type of entity - you should read chapter 2 <a href="#occt_visu_2">Fundamental Concepts</a>, chapter 3 <a href="#occt_visu_3">AIS: Application Interactive Services</a>, and 4 <a href="#occt_visu_4">3D Presentations</a>. You may want to begin with the chapter presenting AIS.
72b7576f 38
2683e647 39@section occt_visu_2 Fundamental Concepts
72b7576f 40
bf62b306 41@subsection occt_visu_2_1 Presentation
72b7576f 42
bf62b306 43In Open CASCADE Technology, presentation services are separated from the data, which they represent, which is generated by applicative algorithms. This division allows you to modify a geometric or topological algorithm and its resulting objects without modifying the visualization services.
72b7576f 44
bf62b306 45@subsubsection occt_visu_2_1_1 Structure of the Presentation
72b7576f 46
2683e647 47Displaying an object on the screen involves three kinds of entities:
bf62b306 48 * a presentable object, the *AIS_InteractiveObject*
72b7576f 49 * a viewer
50 * an interactive context, the *AIS_InteractiveContext*.
51
18006a0f 52<h4>The presentable object</h4>
bf62b306 53The purpose of a presentable object is to provide the graphical representation of an object in the form of *Graphic3d* structure. On the first display request, it creates this structure by calling the appropriate algorithm and retaining this framework for further display.
72b7576f 54
bf62b306 55Standard presentation algorithms are provided in the *StdPrs* and *Prs3d* packages. You can, however, write specific presentation algorithms of your own, provided that they create presentations made of structures from the *Graphic3d* packages. You can also create several presentations of a single presentable object: one for each visualization mode supported by your application.
72b7576f 56
bf62b306 57Each object to be presented individually must be presentable or associated with a presentable object.
72b7576f 58
bf62b306 59<h4>The viewer </h4>
18006a0f 60The viewer allows interactively manipulating views of the object. When you zoom, translate or rotate a view, the viewer operates on the graphic structure created by the presentable object and not on the data model of the application. Creating Graphic3d structures in your presentation algorithms allows you to use the 3D viewers provided in Open CASCADE Technology for 3D visualisation.
72b7576f 61
bf62b306 62<h4>The Interactive Context </h4>
63The interactive context controls the entire presentation process from a common high-level API. When the application requests the display of an object, the interactive context requests the graphic structure from the presentable object and sends it to the viewer for displaying.
72b7576f 64
bf62b306 65@subsubsection occt_visu_2_1_2 Presentation packages
72b7576f 66
18006a0f 67Presentation involves at least the *AIS, PrsMgr, StdPrs* and *V3d* packages. Additional packages, such as *Prs3d* and *Graphic3d* may be used if you need to implement your own presentation algorithms.
68
bf62b306 69* *AIS* package provides all classes to implement interactive objects (presentable and selectable entities).
18006a0f 70* *PrsMgr* package provides low level services and is only to be used when you do not want to use the services provided by AIS. It contains all classes needed to implement the presentation process: abstract classes *Presentation* and *PresentableObject* and concrete class *PresentationManager3d*.
71* *StdPrs* package provides ready-to-use standard presentation algorithms for specific geometries: points, curves and shapes of the geometry and topology toolkits.
72* *Prs3d* package provides generic presentation algorithms such as wireframe, shading and hidden line removal associated with a *Drawer* class, which controls the attributes of the presentation to be created in terms of color, line type, thickness, etc.
73* *V3d* package provides the services supported by the 3D viewer.
2683e647 74* *Graphic3d* package provides resources to create 3D graphic structures.
18006a0f 75* *Visual3d* package contains classes implementing commands for 3D viewer.
76* *DsgPrs* package provides tools for display of dimensions, relations and XYZ trihedrons.
72b7576f 77
bf62b306 78@subsubsection occt_visu_2_1_3 A Basic Example: How to display a 3D object
72b7576f 79
bf62b306 80~~~~~
2683e647 81Void Standard_Real dx = ...; //Parameters
82Void Standard_Real dy = ...; //to build a wedge
83Void Standard_Real dz = ...;
bf62b306 84Void Standard_Real ltx = ...;
85
86Handle(V3d_Viewer)aViewer = ...;
87Handle(AIS_InteractiveContext)aContext;
88aContext = new AIS_InteractiveContext(aViewer);
89
90BRepPrimAPI_MakeWedge w(dx, dy, dz, ltx);
91TopoDS_Solid & = w.Solid();
92Handle(AIS_Shape) anAis = new AIS_Shape(S);
93//creation of the presentable object
4ee1bdf4 94aContext -> Display(anAis);
bf62b306 95//Display the presentable object in the 3d viewer.
96~~~~~
dba69de2 97
bf62b306 98The shape is created using the *BRepPrimAPI_MakeWedge* command. An *AIS_Shape* is then created from the shape. When calling the *Display* command, the interactive context calls the Compute method of the presentable object to calculate the presentation data and transfer it to the viewer. See figure below.
72b7576f 99
bf62b306 100@image html visualization_image004.png "Processes involved in displaying a presentable shape"
101@image latex visualization_image004.png "Processes involved in displaying a presentable shape"
72b7576f 102
bf62b306 103@subsection occt_visu_2_2 Selection
72b7576f 104
bf62b306 105Objects that may be selected graphically, are displayed as sets of sensitive primitives, which provide sensitive zones in 2D graphic space. These zones are sorted according to their position on the screen when starting the selection process.
106
2683e647 107@image html visualization_image006.png "A model"
108@image latex visualization_image006.png "A model"
72b7576f 109
bf62b306 110The position of the mouse is also associated with a sensitive zone. When moving within the window where objects are displayed, the areas touched by the zone of the mouse are analyzed. The owners of these areas are then highlighted or signaled by other means such as the name of the object highlighted in a list. That way, you are informed of the identity of the detected element.
72b7576f 111
bf62b306 112@image html visualization_image007.png "Modeling faces with sensitive primitives"
113@image latex visualization_image007.png "Modeling faces with sensitive primitives"
72b7576f 114
2683e647 115@image html visualization_image008.png "In a dynamic selection, each sensitive polygon is represented by its bounding rectangle"
bf62b306 116@image latex visualization_image008.png "In a dynamic selection, each sensitive polygon is represented by its bounding rectangle"
72b7576f 117
bf62b306 118@image html visualization_image009.png "Reference to the sensitive primitive, then to the owner"
119@image latex visualization_image009.png "Reference to the sensitive primitive, then to the owner"
72b7576f 120
72b7576f 121
2683e647 122@subsubsection occt_visu_2_2_1 The Sensitive Primitive
72b7576f 123
bf62b306 124The sensitive primitive along with the entity owner allows defining what can be made selectable, and providing the link between the applicative object and the sensitive zones defined by the 2D bounding boxes. To be dynamically selectable, an object has to be represented either as a sensitive primitive or a set of them, e.g. 2D boxes that will be included in a sorting algorithm.
72b7576f 125
2683e647 126The use of 2D boxes allows a pre-selection of the detected entities. After pre-selection, the algorithm checks which sensitive primitives are actually detected. When detected, the primitives provide their owners' identity.
72b7576f 127
bf62b306 128@image html visualization_image010.png "Example of sensitive primitives"
2683e647 129@image latex visualization_image010.png "Example of sensitive primitives"
72b7576f 130
bf62b306 131In the example, the sensitive line segment proposes a bounding box to the selector. During selection, positions 1 and 2 of the mouse detect the box but after sorting, only position 2 retains the line segment as selected by the algorithm.
72b7576f 132
bf62b306 133When the Box associated with the position of the mouse intersects the Box of a sensitive primitive, the owner of the sensitive primitive is called and its presentation is highlighted.
72b7576f 134
bf62b306 135The notion of sensitive primitive is important for the developer when defining his own classes of sensitive primitives for the chosen selection modes. The classes must contain *Areas* and *Matches* functions.
72b7576f 136
bf62b306 137The former provides the list of 2D sensitive boxes representing the sensitive primitive at pre-selection and the latter determines if the detection of the primitive by the 2D boxes is valid.
72b7576f 138
72b7576f 139
bf62b306 140@subsubsection occt_visu_2_2_2 Dynamic Selection
72b7576f 141
bf62b306 142Dynamic selection causes objects in a view to be automatically highlighted
143as the mouse cursor moves over them. This allows the user to be certain that the picked object
144 is the correct one. Dynamic Selection is based on the following two concepts:
72b7576f 145
bf62b306 146 * a Selectable Object (*AIS_InteractiveObject*)
147 * an Interactive Context
148
149<h4>Selectable Object</h4>
72b7576f 150
2683e647 151A selectable object presents a given number of selection modes which can be redefined, and which will be activated or deactivated in the selection manager's selectors.
72b7576f 152
bf62b306 153Note that the selection mode of a selectable object, can refer to the selection mode of the object itself or to the selection mode of its part.
72b7576f 154
bf62b306 155For each selection mode, a *SelectMgr_Selection* object class is included in the selectable object. (Each selection mode establishes a priority of selection for each class of selectable object defined.)
72b7576f 156
bf62b306 157The notion of **Selection** is comparable to the notion of **Display**. Just as a display contains a set of graphic primitives that allow display of the entity in a specific display mode, a **Selection** contains a set of sensitive primitives, which allow detection of the entities they are associated with.
72b7576f 158
159<h4>Interactive Context</h4>
72b7576f 160
bf62b306 161The interactive context is used to manage both selectable objects and selection processes.
72b7576f 162
bf62b306 163Selection modes may be activated or de-activated for given selectable objects. Information is then provided about the status of activated/de-activated selection modes for a given object in a given selector.
72b7576f 164
bf62b306 165See also <a href="#occt_visu_3">AIS: Application Interactive Services</a>.
72b7576f 166
bf62b306 167Let us consider, for example, a 3D selectable shape object, which corresponds to a topological shape.
72b7576f 168
bf62b306 169For this class, seven selection modes can be defined:
2683e647 170* mode 0 - selection of the shape itself
bf62b306 171* mode 1 - selection of vertices
172* mode 2 - selection of edges
173* mode 3 - selection of wires
174* mode 4 - selection of faces
175* mode 5 - selection of shells
176* mode 6 - selection of solids
177* mode 7 - selection of compsolids
178* mode 8 - selection of compounds
72b7576f 179
bf62b306 180Selection 2 includes the sensitive primitives that model all the edges of the shape. Each of these primitives contains a reference to the edge it represents.
72b7576f 181
bf62b306 182The selections may be calculated before any activation and are graph independent as long as they are not activated in a given selector. Activation of selection mode 3 in a selector associated with a view V leads to the projection of the 3D sensitive primitives contained in the selection; then the 2D areas which represent the 2D bounding boxes of these primitives are provided to the sorting process of the selector containing all the detectable areas.
72b7576f 183
184To deactivate selection mode 3 remove all those 2D areas.
185
186
bf62b306 187@subsubsection occt_visu_2_2_3 Selection Packages
72b7576f 188
18006a0f 189Selection of 3D data structures is provided using various algorithms. The following selection packages exist : *SelectBasics*, *SelectMgr*, *Select3D* and *StdSelect*.
190
191### Basic Selection
72b7576f 192
bf62b306 193*SelectBasics* package contains the basic classes of the selection:
18006a0f 194 * the main definition of a sensitive primitive: *SensitiveEntity*, which is a selectable entity in a view;
195 * the definition of a sensitive primitive owner: *EntityOwner* this entity relates the primitive to the application entity which is to be selected in the view.
bf62b306 196 * the algorithm used for sorting sensitive boxes: *SortAlgo*
72b7576f 197
bf62b306 198*EntityOwner* is used to establish a link from *SensitiveEntity* to application-level objects. For example, *SelectMgr_EntityOwner* (see below) class holds a pointer to corresponding *SelectableObject*.
72b7576f 199
18006a0f 200### Standard Selections
201
202*Select3D* package provides definition of all 3D standard sensitive primitives such as point, curve and face. All these classes inherit from 3D *SensitiveEntry* from *SelectBasics* with an additional method, which allows recovery of the bounding boxes in the 2D graphic selection space, if required. This package also includes the 3D-2D projector.
203
204*StdSelect* package provides standard uses of the classes described above and main tools used to prevent the developer from redefining the selection objects. In particular, *StdSelect* includes standard modes for selection of topological shapes, definition of several filter standard <i> Selection2d.ap </i> classes and 3D viewer selectors.
205
206Note that each new Interactive Object must have all its selection modes defined.
207
208### Selection Management
209
210*SelectMgr* package is used to manage the whole dynamic selection process.
211
212It provides low level services and classes *SelectMgr_SelectionManager* and *SelectMgr_ViewerSelector*. They can be used when you do not want to use the services provided by *AIS*.
213
bf62b306 214There are also implementations of *ViewerSelector* interface for 3D selection in *StdSelect* package: *ViewerSelector3d*.
72b7576f 215
18006a0f 216*SelectMgr* manages the process of dynamic selection through the following services:
217
218 * Activating and deactivating selection modes for Interactive Objects.
219 * Adding and removing viewer selectors.
220 * Definitions of abstract filter classes.
221
222The principle of graphic selection consists in representing the objects which you want to select by a bounding box in the selection view.
223The object is selected when you use the mouse to designate the zone produced by the object.
224
225To realize this, the application creates a selection structure which is independent of the point of view.
226This structure is made up of sensitive primitives which have one owner object associated to each of them.
227The role of the sensitive primitive is to reply to the requests of the selection algorithm whereas the owner's purpose is to make the link between the sensitive primitive and the object to be selected.
228Each selection structure corresponds to a selection mode which defines the elements that can be selected.
229
230### Example: Selection of a Geometric Model
231
232For example, to select a complete geometric model, the application can create a sensitive primitive for each face of the interactive object representing the geometric model.
233In this case, all the primitives share the same owner.
234On the other hand, to select an edge in a model, the application must create one sensitive primitive per edge.
235
236~~~~
237
238void InteractiveBox::ComputeSelection (const Handle(SelectMgr_Selection)& theSel,
239 const Standard_Integer theMode)
240{
241switch (theMode)
242{
243 case 0: // locating the whole box by making its faces sensitive
244 {
245 Handle(SelectMgr_EntityOwner) anOwner = new SelectMgr_EntityOwner (this, 5);
246 for (Standard_Integer anIt = 1; anIt <= aFacesNb; anIt++)
247 {
248 theSel->Add (new Select3D_SensitiveFace (anOwner,[array of the vertices] face I);
249 break;
250 }
251 case 1: // locating the edges
252 {
253 for (Standard_Integer anIt = 1; anIt <= 12; anIt++)
254 {
255 // 1 owner per edge
256 Handle(mypk_EdgeOwner) anOwner = new mypk_EdgeOwner (this, anIt, 6); // 6->priority
257 theSel->Add (new Select3D_SensitiveSegment (anOwner, firstpt (anIt), lastpt (anIt));
258 }
259 }
260}
261
262~~~~
263
264The algorithms for creating selection structures store the sensitive primitives in a <i>SelectMgr_Selection</i> object.
265To do this, a set of ready-made sensitive primitives is supplied in the <i>Select3D</i>package.
266New sensitive primitives can be defined through inheritance from <i>SensitiveEntity</i>.
267For the application to make its own objects selectable, it must define owner classes inheriting <i>SelectMgr_EntityOwner</i>.
268
269Selection structures for any interactive object are generated in <i>ComputeSelection()</i> method.
270In the example below there are different modes of selection on the topological shape contained within the interactive object,
271selection of the shape itself, the vertices, the edges, the wires, the faces.
272
273~~~~
274 void MyPack_MyClass::ComputeSelection(
275 const Handle(SelectMgr_Selection)& theaSelection,
276 const Standard_Integer theMode)
277 {
278 switch (theMode)
279 {
280 case 0:
281 StdSelect_BRepSelectionTool::Load (theSelection, this, myShape, TopAbs_SHAPE);
282 break;
283 case 1:
284 StdSelect_BRepSelectionTool::Load (theSelection, this, myShape, TopAbs_VERTEX);
285 break;
286 case 2:
287 StdSelect_BRepSelectionTool::Load (theSelection, this, myShape, TopAbs_EDGE);
288 break;
289 case 3:
290 StdSelect_BRepSelectionTool::Load (theSelection, this, myShape, TopAbs_WIRE);
291 break;
292 case 4:
293 StdSelect_BRepSelectionTool::Load (theSelection, this, myShape, TopAbs_FACE);
294 break;
295 }
296 }
297~~~~
298
299The <i>StdSelect_BRepSelectionTool</i> object provides a high level service which will make the topological shape <i>myShape</i> selectable when the <i>AIS_InteractiveContext</i> is asked to display your object.
300
301Note:
302
303The traditional way of highlighting selected entity owners adopted by Open CASCADE Technology assumes that each entity owner highlights itself on its own. This approach has two drawbacks:
304
305 * Each entity owner has to maintain its own <i>Prs3d_Presentation object</i>, that results in large memory overhead for thousands of owners.
306 * Drawing selected owners one by one is not efficient from the OpenGL usage viewpoint.
72b7576f 307
18006a0f 308That is why a different method has been introduced.
309On the basis of <i>SelectMgr_EntityOwner::IsAutoHilight()</i> return value <i>AIS_LocalContext</i>
310object either uses the traditional way of highlighting (<i>IsAutoHilight()</i> returned true)
311or groups such owners according to their Selectable Objects and finally calls <i> SelectMgr_SelectableObject::HilightSelected()</i> or
312<i>ClearSelected()</i>, passing a group of owners as an argument.
313
314Hence, an application can derive its own interactive object and redefine <i> HilightSelected()</i>,
315<i>ClearSelected()</i> and <i>HilightOwnerWithColor()</i> virtual methods
316to take advantage of such OpenGL technique as arrays of primitives.
317In any case, these methods should at least have empty implementation.
318
319The <i>AIS_LocalContext::UpdateSelected (const Handle(AIS_InteratciveObject)&, Standard_Boolean)</i>
320method can be used for efficient redrawing a selection presentation for a given interactive object from an application code.
321
322Additionally, the <i>SelectMgr_SelectableObject::ClearSelections()</i> method now accepts an optional Boolean argument.
323This parameter defines whether all object selections should be flagged for further update or not.
324This improved method can be used to re-compute an object selection (without redisplaying the object completely)
325when some selection mode is activated not for the first time.
72b7576f 326
bf62b306 327@subsubsection occt_visu_2_2_4 How to use dynamic selection
72b7576f 328
bf62b306 329Several operations must be performed prior to using dynamic selection:
3301. Implement specific sensitive primitives if those defined in Select3D are not sufficient. These primitives must inherit from *SensitiveEntity* from *SelectBasics* or from a suitable Select3D sensitive entity class when a projection from 3D to 2D is necessary.
3312. Define all the owner types, which will be used, and the classes of selectable objects, i.e. the number of possible selection modes for these objects and the calculation of the decomposition of the object into sensitive primitives of all the primitives describing this mode. It is possible to define only one default selection mode for a selectable object if this object is to be selectable in a unique way.
3323. Install the process, which provides the user with the identity of the owner of the detected entities in the selection loop.
72b7576f 333
bf62b306 334When all these steps have been carried out, follow the procedure below:
3351. Create an interactive context.
3362. Create the selectable objects and calculate their various possible selections.
3373. Load these selectable objects in the interactive context. The objects may be common to all the selectors, i.e. they will be seen by all the selectors in the selection manager, or local to one selector or more.
2683e647 3384. Activate or deactivate the objects' selection modes in the selector(s). When activating a selection mode in a selector for a given object, the manager sends the order to make the sensitive primitives in this selector selectable. If the primitives are to projected from 3D to 2D, the selector calls the specific method used to carry out this projection.
72b7576f 339
bf62b306 340At this stage, the selection of selectable entities in the selectors is available.
341The selection loop informs constantly the selectors with the position of the mouse and questions them about the detected entities.
72b7576f 342
bf62b306 343Let us suppose that you create an application that displays houses in a viewer of the V3d package and you want to select houses or parts of these houses (windows, doors, etc.) in the graphic window.
344You define a selectable object called *House* and propose four possible selection modes for this object:
3451. selection of the house itself;
3462. selection of the rooms
3473. selection of the walls
3484. selection of the doors.
72b7576f 349
bf62b306 350You have to write the method, which calculates the four selections above, i.e. the sensitive primitives which are activated when the mode is.
351You must define the class *Owner* specific to your application. This class will contain the reference to the house element it represents: wall, door or room. It inherits from *EntityOwner* from *SelectMgr*.
352For example, let us consider a house with the following representation:
72b7576f 353
bf62b306 354@image html visualization_image011.png "Selection of rooms in a house"
355@image latex visualization_image011.png "Selection of rooms in a house"
72b7576f 356
bf62b306 357To build the selection, which corresponds to the mode "selection of the rooms"
358(selection 2 in the list of selection modes), use the following procedure:
72b7576f 359
bf62b306 360~~~~~
72b7576f 361
362Void House::ComputeSelection
bf62b306 363 (Const Handle(SelectMgr_Selection)& Sel,
2683e647 364 const Standard_Integer mode {
365 switch(mode){
4ee1bdf4 366 case 0: //Selection of the rooms
2683e647 367 {
368 for(Standard_Integer i = 1; i <= myNbRooms; i++)
4ee1bdf4 369 {
370 //for every room, create an instance of the owner, the given room and its name.
371 Handle(RoomOwner) aRoomOwner = new RoomOwner (Room(i), NameRoom(i));
372 //Room() returns a room and NameRoom() returns its name.
bf62b306 373 Handle(Select3d_SensitiveBox) aSensitiveBox;
374 aSensitiveBox = new Select3d_SensitiveBox
375 (aRoomOwner, Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
2683e647 376 Sel -> Add(aSensitiveBox);
377 }
378 break;
379 Case 1: ... //Selection of the doors
4ee1bdf4 380 } //Switch
bf62b306 381) // ComputeSelection
382~~~~~
72b7576f 383
bf62b306 384@image html visualization_image012.png "Activated sensitive boxes corresponding to selection mode 0 (selection of rooms)"
385@image latex visualization_image012.png "Activated sensitive boxes corresponding to selection mode 0 (selection of rooms)"
72b7576f 386
bf62b306 387@image html visualization_image013.png "Activated sensitive rectangles in the selector during dynamic selection in view 1"
388@image latex visualization_image013.png "Activated sensitive rectangles in the selector during dynamic selection in view 1"
72b7576f 389
2683e647 390@image html visualization_image014.png "Activated sensitive polygons corresponding to selection mode 1 (selection of doors)"
391@image latex visualization_image014.png "Activated sensitive polygons corresponding to selection mode 1 (selection of doors)"
72b7576f 392
bf62b306 393@image html visualization_image015.png "Sensitive rectangles in the selector during dynamic selection in view 2"
394@image latex visualization_image015.png "Sensitive rectangles in the selector during dynamic selection in view 2"
72b7576f 395
bf62b306 396@section occt_visu_3 Application Interactive Services
397@subsection occt_visu_3_1 Introduction
72b7576f 398
bf62b306 399Application Interactive Services allow managing presentations and dynamic selection in a viewer in a simple and transparent manner.
72b7576f 400
bf62b306 401The central entity for management of visualization and selections is the **Interactive Context**. It is connected to the main viewer (and if need be, the trash bin viewer). It has two operating modes: the Neutral Point and the local visualization and selection context.
72b7576f 402
bf62b306 403The neutral point, which is the default mode, allows easily visualizing and selecting interactive objects loaded into the context.
72b7576f 404
bf62b306 405**Local Contexts** can be opened to prepare and use a temporary selection environment without disturbing
406the neutral point. It is possible to choose the interactive objects, which you want to act on, the selection modes, which you want to activate, and the temporary visualizations, which you will execute.
72b7576f 407
bf62b306 408When the operation is finished, you close the current local context and return to the state
409in which you were before opening it (neutral point or previous local context).
72b7576f 410
bf62b306 411**Interactive Objects** are the entities, which are visualized and selected. You can use classes of standard interactive objects for which all necessary functions have already been programmed, or you can implement your own classes of interactive objects, by respecting a certain number of rules and conventions described below.
72b7576f 412
bf62b306 413@image html visualization_image016.png
414@image latex visualization_image016.png
72b7576f 415
bf62b306 416An Interactive Object is a "virtual" entity, which can be presented and selected. An Interactive Object can have a certain number of specific graphic attributes, such as visualization mode, color and material.
72b7576f 417
bf62b306 418When an Interactive Object is visualized, the required graphic attributes are taken from its own **Drawer** if it has the required custom attributes or otherwise from the context drawer.
72b7576f 419
bf62b306 420@image html visualization_image017.png
421@image latex visualization_image017.png
72b7576f 422
bf62b306 423It can be necessary to filter the entities to be selected. Consequently there are **Filter** entities, which allow refining the dynamic detection context. Some of these filters can be used at the Neutral Point, others only in an open local context. It is possible to program custom filters and load them into the interactive context.
72b7576f 424
bf62b306 425@subsection occt_visu_3_2 Interactive objects
72b7576f 426
18006a0f 427Entities which are visualized and selected in the AIS viewer are objects. They connect the underlying reference geometry of a model to its graphic representation in *AIS*. You can use the predefined OCCT classes of standard interactive objects, for which all necessary functions have already been programmed, or, if you are an advanced user, you can implement your own classes of interactive objects.
428
bf62b306 429@subsubsection occt_visu_3_2_1 Presentations
72b7576f 430
bf62b306 431An interactive object can have as many presentations as its creator wants to give it.
72b7576f 432
bf62b306 4333D presentations are managed by PresentationManager3D. As this is transparent in AIS, the user does not have to worry about it.
72b7576f 434
bf62b306 435A presentation is identified by an index and by the reference to the Presentation Manager which it depends on.
72b7576f 436
bf62b306 437By convention, the default mode of representation for the Interactive Object has index 0.
72b7576f 438
bf62b306 439@image html visualization_image018.png
440@image latex visualization_image018.png
72b7576f 441
bf62b306 442Calculation of different presentations of an interactive object is done by the *Compute* functions inheriting from *PrsMgr_ PresentableObject::Compute* functions. They are automatically called by *PresentationManager* at a visualization or an update request.
72b7576f 443
bf62b306 444If you are creating your own type of interactive object, you must implement the Compute function in one of the following ways:
72b7576f 445
bf62b306 446#### For 3D:
72b7576f 447
bf62b306 448~~~~~
449void PackageName_ClassName::Compute
450 (const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
2683e647 451 const Handle(Prs3d_Presentation)& aPresentation,
452 const Standard_Integer aMode = 0);
bf62b306 453~~~~~
72b7576f 454
bf62b306 455#### For hidden line removal (HLR) mode in 3D:
456~~~~~
457void PackageName_ClassName::Compute
458 (const Handle(Prs3d_Projector)& aProjector,
2683e647 459 const Handle(Prs3d_Presentation)& aPresentation);
bf62b306 460~~~~~
72b7576f 461
bf62b306 462@subsubsection occt_visu_3_2_2 Hidden Line Removal
72b7576f 463
2683e647 464The view can have two states: the normal mode or the computed mode (Hidden Line Removal mode). When the latter is active, the view looks for all presentations displayed in the normal mode, which have been signalled as accepting HLR mode. An internal mechanism allows calling the interactive object's own *Compute*, that is projector function.
72b7576f 465
bf62b306 466By convention, the Interactive Object accepts or rejects the representation of HLR mode. It is possible to make this declaration in one of two ways:
72b7576f 467
bf62b306 468* Initially by using one of the values of the enumeration *PrsMgr_TypeOfPresentation*:
469 * *PrsMgr_TOP_AllView*,
470 * *PrsMgr_TOP_ProjectorDependant*
72b7576f 471
bf62b306 472* Later by using the function *PrsMgr_PresentableObject::SetTypeOfPresentation*
72b7576f 473
bf62b306 474*AIS_Shape* class is an example of an interactive object that supports HLR representation. It supports two types of the HLR algorithm:
2683e647 475* the polygonal algorithm based on the shape's triangulation;
476* the exact algorithm that works with the shape's real geometry.
72b7576f 477
bf62b306 478The type of the HLR algorithm is stored in *AIS_Drawer* of the shape. It is a value of the *Prs3d_TypeOfHLR* enumeration and can be set to:
479 * *Prs3d_TOH_PolyAlgo* for a polygonal algorithm;
480 * *Prs3d_TOH_Algo* for an exact algorithm;
481 * *Prs3d_TOH_NotSet* if the type of algorithm is not set for the given interactive object instance.
72b7576f 482
bf62b306 483The type of the HLR algorithm used for *AIS_Shape* can be changed by calling the *AIS_Shape::SetTypeOfHLR()* method.
72b7576f 484
bf62b306 485The current HLR algorithm type can be obtained using *AIS_Shape::TypeOfHLR()* method is to be used.
72b7576f 486
bf62b306 487These methods get the value from the drawer of *AIS_Shape*. If the HLR algorithm type in the *AIS_Drawer* is set to *Prs3d_TOH_NotSet*, the *AIS_Drawer* gets the value from the default drawer of *AIS_InteractiveContext*.
72b7576f 488
bf62b306 489So it is possible to change the default HLR algorithm used by all newly displayed interactive objects. The value of the HLR algorithm type stored in the context drawer can be *Prs3d_TOH_Algo* or *Prs3d_TOH_PolyAlgo*. The polygonal algorithm is the default one.
72b7576f 490
bf62b306 491@subsubsection occt_visu_3_2_3 Presentation modes
72b7576f 492
bf62b306 493There are four types of interactive objects in AIS:
494 * the "construction element" or Datum,
495 * the Relation (dimensions and constraints)
496 * the Object
497 * the None type (when the object is of an unknown type).
72b7576f 498
bf62b306 499Inside these categories, additional characterization is available by means of a signature (an index.) By default, the interactive object has a NONE type and a signature of 0 (equivalent to NONE.) If you want to give a particular type and signature to your interactive object, you must redefine two virtual functions:
500 * *AIS_InteractiveObject::Type*
501 * *AIS_InteractiveObject::Signature*.
72b7576f 502
bf62b306 503**Note** that some signatures are already used by "standard" objects provided in AIS (see the <a href="#occt_visu_3_5">list of Standard Interactive Object Classes</a>).
72b7576f 504
bf62b306 505The interactive context can have a default mode of representation for the set of interactive objects. This mode may not be accepted by a given class of objects.
72b7576f 506
bf62b306 507Consequently, to get information about this class it is necessary to use virtual function *AIS_InteractiveObject::AcceptDisplayMode*.
72b7576f 508
bf62b306 509#### Display Mode
72b7576f 510
bf62b306 511The functions *AIS_InteractiveContext::SetDisplayMode* and *AIS_InteractiveContext::UnsetDisplayMode* allow setting a custom display mode for an objects, which can be different from that proposed by the interactive context.
72b7576f 512
bf62b306 513#### Highlight Mode
72b7576f 514
bf62b306 515At dynamic detection, the presentation echoed by the Interactive Context, is by default the presentation already on the screen.
72b7576f 516
bf62b306 517The functions *AIS_InteractiveObject::SetHilightMode* and *AIS_InteractiveObject::UnSetHilightMode* allow specifying the display mode used for highlighting (so called highlight mode), which is valid independently from the active representation of the object. It makes no difference whether this choice is temporary or definitive.
72b7576f 518
bf62b306 519Note that the same presentation (and consequently the same highlight mode) is used for highlighting *detected* objects and for highlighting *selected* objects, the latter being drawn with a special *selection color* (refer to the section related to *Interactive Context* services).
72b7576f 520
bf62b306 521For example, you want to systematically highlight the wireframe presentation of a shape - non regarding if it is visualized in wireframe presentation or with shading. Thus, you set the highlight mode to *0* in the constructor of the interactive object. Do not forget to implement this representation mode in the *Compute* functions.
72b7576f 522
bf62b306 523#### Infinite Status
2683e647 524If you do not want an object to be affected by a *FitAll* view, you must declare it infinite; you can cancel its "infinite" status using *AIS_InteractiveObject::SetInfiniteState* and *AIS_InteractiveObject::IsInfinite* functions.
72b7576f 525
bf62b306 526Let us take for example the class called *IShape* representing an interactive object :
72b7576f 527
bf62b306 528~~~~~
529myPk_IShape::myPK_IShape
530 (const TopoDS_Shape& SH, PrsMgr_TypeOfPresentation aType):
2683e647 531 AIS_InteractiveObject(aType), myShape(SH), myDrwr(new AIS_Drawer()) {SetHilightMode(0);}
bf62b306 532void myPk_IShape::Compute
533 (const Handle(PrsMgr_PresentationManager3d) & PM,
2683e647 534 const Handle(Prs3d_Presentation)& P,
bf62b306 535 const Standard_Integer TheMode)
536{
537 switch (TheMode){
538 case 0:
539 StdPrs_WFDeflectionShape::Add (P,myShape,myDrwr); //algo for calculation of wireframe presentation break;
540 case 1:
541 StdPrs_ShadedShape::Add (P,myShape,myDrwr); //algo for calculation of shading presentation.
542 break;
543 }
544}
545void myPk_IsShape::Compute
546 (const Handle(Prs3d_Projector)& Prj,
547 const Handle(Prs3d_Presentation) P)
548{
549 StdPrs_HLRPolyShape::Add(P,myShape,myDrwr);
550 //Hidden line mode calculation algorithm
551}
552~~~~~
72b7576f 553
bf62b306 554@subsubsection occt_visu_3_2_4 Selection
72b7576f 555
bf62b306 556An interactive object can have an indefinite number of selection modes, each representing a "decomposition" into sensitive primitives; each primitive has an Owner (*SelectMgr_EntityOwner*) which allows identifying the exact entity which has been detected (see <a href="#occt_visu_3_6"> Dynamic Selection</a> chapter).
72b7576f 557
bf62b306 558The set of sensitive primitives, which correspond to a given mode, is stocked in a SELECTION (*SelectMgr_Selection*).
72b7576f 559
bf62b306 560Each Selection mode is identified by an index. By Convention, the default selection mode that allows us to grasp the Interactive object in its entirety is mode *0*.
72b7576f 561
bf62b306 562The calculation of Selection primitives (or sensitive primitives) is done by the intermediary of a virtual function, *ComputeSelection*. This should be implemented for each type of interactive object on which you want to make different type selections using the function *AIS_ConnectedInteractive::ComputeSelection*.
72b7576f 563
bf62b306 564A detailed explanation of the mechanism and the manner of implementing this function has been given in <a href="#occt_visu_3_6"> Dynamic Selection</a> chapter.
72b7576f 565
bf62b306 566Moreover, just as the most frequently manipulated entity is *TopoDS_Shape*, the most used Interactive Object is *AIS_Shape*. You will see below activation functions for standard selection modes are proposed in the Interactive context (selection by vertex, by edges etc). To create new classes of interactive object with the same behavior as *AIS_Shape* - such as vertices and edges - you must redefine the virtual function *AIS_ConnectedInteractive::AcceptShapeDecomposition*.
72b7576f 567
bf62b306 568You can change the default selection mode index of an Interactive Object using the following functions:
569 * *AIS_InteractiveObject::HasSelectionMode* checks if there is a selection mode;
570 * *AIS_InteractiveObject::SelectionMode* check the current selection mode;
571 * *AIS_InteractiveContext::SetSelectionMode* sets a selection mode;
572 * *AIS_InteractiveContext::UnsetSelectionMode* unsets a selection mode.
573
574These functions can be useful if you decide that the *0* mode used by default will not do. In the same way, you can temporarily change the priority of certain interactive objects for selection of 0 mode to facilitate detecting them graphically using the following functions:
575 * *AIS_InteractiveObject::HasSelectionPriority* checks if there is a selection priority setting for the owner;
576 * *AIS_InteractiveObject::SelectionPriority* checks the current priority;
577 * *AIS_InteractiveObject::SetSelectionPriority* sets a priority;
578 * *AIS_InteractiveObject::UnsetSelectionPriority* unsets the priority.
579
2683e647 580
bf62b306 581@subsubsection occt_visu_3_2_5 Graphic attributes
72b7576f 582
18006a0f 583Graphic attributes manager, or *AIS Drawer*, stores graphic attributes for specific interactive objects and for interactive objects controlled by interactive context.
584
585Initially, all drawer attributes are filled out with the predefined values which will define the default 3D object appearance.
586
587When an interactive object is visualized, the required graphic attributes are first taken from its own drawer if one exists, or from the context drawer if no specific drawer for that type of object exists.
588
589Keep in mind the following points concerning graphic attributes:
bf62b306 590 * Each interactive object can have its own visualization attributes.
591 * The set of graphic attributes of an interactive object is stocked in an *AIS_Drawer*, which is only a *Prs3d_Drawer* with the possibility of a link to another drawer
592 * By default, the interactive object takes the graphic attributes of the context in which it is visualized (visualization mode, deflection values for the calculation of presentations, number of isoparameters, color, type of line, material, etc.)
593 * In the *AIS_InteractiveObject* abstract class, standard attributes including color, line thickness, material, and transparency have been privileged. Consequently, there is a certain number of virtual functions, which allow acting on these attributes. Each new class of interactive object can redefine these functions and change the behavior of the class.
72b7576f 594
bf62b306 595@image html visualization_image019.png "Figure 13. Redefinition of virtual functions for changes in AIS_Point"
596@image latex visualization_image019.png "Figure 13. Redefinition of virtual functions for changes in AIS_Point"
72b7576f 597
bf62b306 598@image html visualization_image020.png "Figure 14. Redefinition of virtual functions for changes in AIS_Shape."
599@image latex visualization_image020.png "Figure 14. Redefinition of virtual functions for changes in AIS_Shape."
72b7576f 600
bf62b306 601The following virtual functions provide settings for color, width, material and transparency:
602 * *AIS_InteractiveObject::UnsetColor*
603 * *AIS_InteractiveObject::SetWidth*
604 * *AIS_InteractiveObject::UnsetWidth*
605 * *AIS_InteractiveObject::SetMaterial (const Graphic3d_NameOfPhysicalMaterial & aName)*
2683e647 606 * *AIS_InteractiveObject::SetMaterial (const Graphic3d_MaterialAspect & aMat)*
bf62b306 607 * *AIS_InteractiveObject::UnsetMaterial*
608 * *AIS_InteractiveObject::SetTransparency*
609 * *AIS_InteractiveObject::UnsetTransparency*
72b7576f 610
bf62b306 611For other types of attribute, it is appropriate to change the Drawer of the object directly using:
612 * *AIS_InteractiveObject::SetAttributes*
613 * *AIS_InteractiveObject::UnsetAttributes*
72b7576f 614
bf62b306 615It is important to know which functions may imply the recalculation of presentations of the object.
72b7576f 616
bf62b306 617If the presentation mode of an interactive object is to be updated, a flag from *PrsMgr_PresentableObject* indicates this.
72b7576f 618
bf62b306 619The mode can be updated using the functions *Display* and *Redisplay* in *AIS_InteractiveContext*.
72b7576f 620
bf62b306 621@subsubsection occt_visu_3_2_6 Complementary Services
72b7576f 622
bf62b306 623When you use complementary services for interactive objects, pay special attention to the cases mentioned below.
72b7576f 624
bf62b306 625#### Change the location of an interactive object
72b7576f 626
bf62b306 627The following functions allow temporarily "moving" the representation and selection of Interactive Objects in a view without recalculation.
628 * *AIS_InteractiveContext::SetLocation*
629 * *AIS_InteractiveContext::ResetLocation*
630 * *AIS_InteractiveContext::HasLocation*
631 * *AIS_InteractiveContext::Location*
632
633#### Connect an interactive object to an applicative entity
72b7576f 634
bf62b306 635Each Interactive Object has functions that allow attributing it an *Owner* in form of a *Transient*.
636 * *AIS_InteractiveObject::SetOwner*
637 * *AIS_InteractiveObject::HasOwner*
638 * *AIS_InteractiveObject::Owner*
72b7576f 639
bf62b306 640An interactive object can therefore be associated or not with an applicative entity, without affecting its behavior.
72b7576f 641
bf62b306 642#### Resolving coincident topology
72b7576f 643
bf62b306 644Due to the fact that the accuracy of three-dimensional graphics coordinates has a finite resolution the elements of topological objects can coincide producing the effect of "popping" some elements one over another.
72b7576f 645
bf62b306 646To the problem when the elements of two or more Interactive Objects are coincident you can apply the polygon offset. It is a sort of graphics computational offset, or depth buffer offset, that allows you to arrange elements (by modifying their depth value) without changing their coordinates. The graphical elements that accept this kind of offsets are solid polygons or displayed as boundary lines and points. The polygons could be displayed as lines or points by setting the appropriate interior style.
72b7576f 647
2683e647 648The method *AIS_InteractiveObject::SetPolygonOffsets (const Standard_Integer aMode, const Standard_Real aFactor, const Standard_Real aUnits)* allows setting up the polygon offsets.
72b7576f 649
bf62b306 650The parameter *aMode* can contain various combinations of *Aspect_PolygonOffsetMode* enumeration elements:
651 * *Aspect_POM_None*
652 * *Aspect_POM_Off*
4ee1bdf4 653 * *Aspect_POM_Fill*
654 * *Aspect_POM_Line*
655 * *Aspect_POM_Point*
656 * *Aspect_POM_All*
72b7576f 657
bf62b306 658The combination of these elements defines the polygon display modes that will use the given offsets. You can switch off the polygon offsets by passing *Aspect_POM_Off*. Passing *Aspect_POM_None* allows changing the *aFactor* and *aUnits* values without changing the mode. If *aMode* is different from *Aspect_POM_Off*, the *aFactor* and *aUnits* arguments are used by the graphics renderer to calculate the depth offset value:
659~~~~~
660 offset = aFactor * m + aUnits * r
661~~~~~
662where *m* is the maximum depth slope for the currently displayed polygons, r is the minimum depth resolution (implementation-specific).
72b7576f 663
bf62b306 664Negative offset values move polygons closer to the viewer while positive values shift polygons away.
72b7576f 665
bf62b306 666**Warning**
667
2683e647 668This method has a side effect - it creates its own shading aspect if not yet created, so it is better to set up the object shading aspect first.
72b7576f 669
bf62b306 670You can use the following functions to obtain the current settings for polygon offsets:
671~~~~~
672 void AIS_InteractiveObject::PolygonOffsets
673 (Standard_Integer &aMode,
2683e647 674 Standard_Real &aFactor,
675 Standard_Real &aUnits)
bf62b306 676 Standard_Boolean AIS_InteractiveObject::HasPolygonOffsets()
677~~~~~
72b7576f 678
bf62b306 679The same operation could be performed for the interactive object known by the *AIS_InteractiveContext* with the following methods:
680~~~~~
681void AIS_InteractiveContext::SetPolygonOffsets
682 (const Handle(AIS_InteractiveObject) &anObj,
2683e647 683 const Standard_Integer aMode,
684 const Standard_Real aFactor,
685 const Standard_Real aUnits)
bf62b306 686void AIS_InteractiveContext::PolygonOffsets
687 (const Handle(AIS_InteractiveObject) &anObj,
2683e647 688 Standard_Integer &aMode,
689 Standard_Real &aFactor,
690 Standard_Real &aUnits)
691Standard_Boolean AIS_InteractiveContext::HasPolygonOffsets
bf62b306 692 (const Handle(AIS_InteractiveObject) &anObj)
693~~~~~
72b7576f 694
bf62b306 695@subsection occt_visu_3_3 Interactive Context
72b7576f 696
bf62b306 697@subsubsection occt_visu_3_3_1 Rules
72b7576f 698
18006a0f 699The Interactive Context allows managing in a transparent way the graphic and **selectable** behavior of interactive objects in one or more viewers. Most functions which allow modifying the attributes of interactive objects, and which were presented in the preceding chapter, will be looked at again here.
72b7576f 700
bf62b306 701There is one essential rule to follow: the modification of an interactive object, which is already known by the Context, must be done using Context functions. You can only directly call the functions available for an interactive object if it has not been loaded into an Interactive Context.
72b7576f 702
bf62b306 703~~~~~
704Handle (AIS_Shape) TheAISShape = new AIS_Shape (ashape);
4ee1bdf4 705 myIntContext->Display(TheAISShape);
706 myIntContext->SetDisplayMode(TheAISShape ,1);
707 myIntContext->SetColor(TheAISShape,Quantity_NOC_RED);
bf62b306 708~~~~~
72b7576f 709
bf62b306 710You can also write
72b7576f 711
bf62b306 712~~~~~
713Handle (AIS_Shape) TheAISShape = new AIS_Shape (ashape);
4ee1bdf4 714 TheAISShape->SetColor(Quantity_NOC_RED);
715 TheAISShape->SetDisplayMode(1);
716 myIntContext->Display(TheAISShape);
bf62b306 717~~~~~
72b7576f 718
bf62b306 719@subsubsection occt_visu_3_3_2 Groups of functions
72b7576f 720
18006a0f 721**Neutral Point** and **Local Context** constitute the two operating modes or states of the **Interactive Context**, which is the central entity which pilots visualizations and selections.
72b7576f 722
18006a0f 723The **Neutral Point**, which is the default mode, allows easily visualizing and selecting interactive objects, which have been loaded into the context. Opening **Local contexts** allows preparing and using a temporary selection environment without disturbing the neutral point.
724
725A set of functions allows choosing the interactive objects which you want to act on, the selection modes which you want to activate, and the temporary visualizations which you will execute. When the operation is finished, you close the current local context and return to the state in which you were before opening it (neutral point or previous local context).
72b7576f 726
bf62b306 727The Interactive Context is composed of many functions, which can be conveniently grouped according to the theme:
728 * management proper to the context;
729 * management in the local context;
730 * presentations and selection in open/closed context;
731 * selection strictly speaking.
72b7576f 732
18006a0f 733Some functions can only be used in open Local Context; others in closed local context; others do not have the same behavior in one state as in the other.
72b7576f 734
bf62b306 735@subsubsection occt_visu_3_3_3 Management of the Interactive Context
72b7576f 736
18006a0f 737The **Interactive Context** is made up of a **Principal Viewer** and, optionally, a trash bin or **Collector Viewer**.
738
739An interactive object can have a certain number of specific graphic attributes, such as visualization mode, color, and material. Correspondingly, the interactive context has a set of graphic attributes, the *Drawer*, which is valid by default for the objects it controls.
740
741When an interactive object is visualized, the required graphic attributes are first taken from the object's own <i>Drawer</i> if one exists, or from the context drawer for the others.
742
743The following adjustable settings allow personalizing the behavior of presentations and selections:
744 * Default Drawer, containing all the color and line attributes which can be used by interactive objects, which do not have their own attributes.
bf62b306 745 * Default Visualization Mode for interactive objects. By default: *mode 0* ;
746 * Highlight color of entities detected by mouse movement. By default: *Quantity_NOC_CYAN1*;
747 * Pre-selection color. By default: *Quantity_NOC_GREEN*;
748 * Selection color (when you click on a detected object). By default: *Quantity_NOC_GRAY80*;
18006a0f 749 * Sub-Intensity color. By default: *Quantity_NOC_GRAY40*.
72b7576f 750
bf62b306 751All of these settings can be modified by functions proper to the Context.
72b7576f 752
bf62b306 753When you change a graphic attribute pertaining to the Context (visualization mode, for example), all interactive objects, which do not have the corresponding appropriate attribute, are updated.
72b7576f 754
bf62b306 755Let us examine the case of two interactive objects: *obj1* and *obj2*:
72b7576f 756
bf62b306 757~~~~~
4ee1bdf4 758TheCtx->Display(obj1,Standard_False); // False = no viewer update
759TheCtx->Display(obj2,Standard_True); // True = viewer update
760TheCtx->SetDisplayMode(obj1,3,Standard_False);
761TheCtx->SetDisplayMode(2);
bf62b306 762// obj2 is visualised in mode 2 (if it accepts this mode)
763// obj1 stays visualised in its mode 3.
764~~~~~
72b7576f 765
18006a0f 766*PresentationManager3D* and *Selector3D*, which manage the presentation and selection of present interactive objects, are associated to the main Viewer. The same is true of the optional Collector.
72b7576f 767
bf62b306 768@subsection occt_visu_3_4 Local Context
18006a0f 769
bf62b306 770@subsubsection occt_visu_3_4_1 Rules and Conventions
72b7576f 771
bf62b306 772 * Opening a local context allows preparing an environment for temporary presentations and selections, which will disappear once the local context is closed.
773 * It is possible to open several local contexts, but only the last one will be active.
774 * When you close a local context, the previous one, which is still on the stack, is activated again. If none is left, you return to Neutral Point.
775 * Each local context has an index created when the context opens. You should close the local context, which you have opened.
72b7576f 776
bf62b306 777The interactive object, which is used the most by applications, is *AIS_Shape*. Consequently, standard functions are available which allow you to easily prepare selection operations on the constituent elements of shapes (selection of vertices, edges, faces etc) in an open local context. The selection modes specific to "Shape" type objects are called **Standard Activation Mode**. These modes are only taken into account in open local context and only act on interactive objects which have redefined the virtual function *AcceptShapeDecomposition()* so that it returns *TRUE*.
778 * Objects, which are temporarily in a local context, are not recognized by other local contexts a priori. Only objects visualized in Neutral Point are recognized by all local contexts.
779 * The state of a temporary interactive object in a local context can only be modified while another local context is open.
72b7576f 780
bf62b306 781**Warning**
72b7576f 782
bf62b306 783The specific modes of selection only concern the interactive objects, which are present in the Main Viewer. In the Collector, you can only locate interactive objects, which answer positively to the positioned filters when a local context is open, however, they are never decomposed in standard mode.
72b7576f 784
bf62b306 785@subsubsection occt_visu_3_4_2 Management of Local Context
72b7576f 786
bf62b306 787The local context can be opened using method *AIS_InteractiveContext::OpenLocalContext*. The following options are available:
4ee1bdf4 788 * *UseDisplayedObjects*: allows loading the interactive objects visualized at Neutral Point in the opened local context. If *FALSE*, the local context is empty after being opened. If *TRUE*, the objects at Neutral Point are modified by their default selection mode.
bf62b306 789 * *AllowShapeDecomposition*: *AIS_Shape* allows or prevents decomposition in standard shape location mode of objects at Neutral Point, which are type-privileged (see <a href="#occt_visu_3_2_4"> Selection</a> chapter). This Flag is only taken into account when *UseDisplayedObjects* is *TRUE*.
18006a0f 790 * *AcceptEraseOfObjects*: authorizes other local contexts to erase the interactive objects present in this context. This option is rarely used. The last option has no current use.
72b7576f 791
bf62b306 792This function returns the index of the created local context. It should be kept and used when the context is closed.
72b7576f 793
bf62b306 794To load objects visualized at Neutral Point into a local context or remove them from it use methods
795~~~~~
796 AIS_InteractiveContext::UseDisplayedObjects
797 AIS_InteractiveContext::NotUseDisplayedObjects
798~~~~~
799Closing Local Contexts is done by:
800~~~~~
801 AIS_InteractiveContext::CloseLocalContext
802 AIS_InteractiveContext::CloseAllContexts
803~~~~~
72b7576f 804
bf62b306 805*Warning*
2683e647 806When the index is not specified in the first function, the current Context is closed. This option can be dangerous, as other Interactive Functions can open local contexts without necessarily warning the user. For greater security, you have to close the context with the index given on opening.
72b7576f 807
18006a0f 808To get the index of the current context, use function *AIS_InteractiveContext::IndexOfCurrentLocal*. It allows closing all open local contexts at one go. In this case, you find yourself directly at Neutral Point.
72b7576f 809
18006a0f 810When you close a local context, all temporary interactive objects are deleted, all selection modes concerning the context are canceled, and all content filters are emptied.
72b7576f 811
72b7576f 812
bf62b306 813@subsubsection occt_visu_3_4_3 Presentation in a Neutral Point
72b7576f 814
18006a0f 815You must distinguish between the **Neutral Point** and the **Open Local Context** states. Although the majority of visualization functions can be used in both situations, their behavior is different.
72b7576f 816
bf62b306 817Neutral Point should be used to visualize the interactive objects, which represent and select an applicative entity. Visualization and Erasing orders are straightforward:
72b7576f 818
bf62b306 819~~~~~
820AIS_InteractiveContext::Display
821 (const Handle(AIS_InteractiveObject)& anIobj,
2683e647 822 const Standard_Boolean updateviewer=Standard_True);
bf62b306 823
824AIS_InteractiveContext::Display
825 (const Handle(AIS_InteractiveObject)& anIobj,
2683e647 826 const Standard_Integer amode,
827 const Standard_Integer aSelectionMode,
828 const Standard_Boolean updateviewer = Standard_True,
829 const Standard_Boolean allowdecomposition = Standard_True);
bf62b306 830
831 AIS_InteractiveContext::Erase
832 AIS_InteractiveContext::EraseMode
833 AIS_InteractiveContext::ClearPrs
834 AIS_InteractiveContext::Redisplay
835 AIS_InteractiveContext::Remove
836 AIS_InteractiveContext::EraseAll
837 AIS_InteractiveContext::Hilight
838 AIS_InteractiveContext::HilightWithColor
839~~~~~
840
841Bear in mind the following points:
842 * It is recommended to display and erase interactive objects when no local context is opened, and open a local context for local selection only.
2683e647 843 * The first *Display* function among the two ones available in *InteractiveContext* visualizes the object in its default mode (set with help of SetDisplayMode() method of InteractiveObject prior to Display() call), or in the default context mode, if applicable. If it has neither, the function displays it in 0 presentation mode. The object's default selection mode is automatically activated (0 mode by convention).
bf62b306 844 * Activating the displayed object by default can be turned off with help of *SetAutoActivateSelection()* method. This might be efficient if you are not interested in selection immediately after displaying an object.
845 * The second *Display* function should only be used in Neutral Point to visualize a supplementary mode for the object, which you can erase by *EraseMode (...)*. You activate the selection mode. This is passed as an argument. By convention, if you do not want to activate a selection mode, you must set the *SelectionMode* argument to -1. This function is especially interesting in open local context, as we will see below.
846 * In Neutral Point, it is not advisable to activate other selection modes than the default selection one. It is preferable to open a local context in order to activate particular selection modes.
4ee1bdf4 847 * When you call *Erase(Interactive object)* function, the *PutIncollector* argument, which is *FALSE* by default, allows you to visualize the object directly in the Collector and makes it selectable (by activation of 0 mode). You can nonetheless block its passage through the Collector by changing the value of this option. In this case, the object is present in the Interactive Context, but is not seen anywhere.
2683e647 848 * *Erase()* with *putInCollector = Standard_True* might be slow as it recomputes the object presentation in the Collector. Set *putInCollector* to *Standard_False* if you simply want to hide the object's presentation temporarily.
bf62b306 849 * Visualization attributes and graphic behavior can be modified through a set of functions similar to those for the interactive object (color, thickness of line, material, transparency, locations, etc.) The context then manages immediate and deferred updates.
850 * Call *Remove()* method of *InteractiveContext* as soon as the interactive object is no longer needed and you want to destroy it.. Otherwise, references to *InteractiveObject* are kept by *InteractiveContext*, and the *Object* is not destroyed, which results in memory leaks. In general, if the presentation of an interactive object can be computed quickly, it is recommended to *Remove()* it instead of using *Erase()* method.
72b7576f 851
18006a0f 852@subsubsection occt_visu_3_4_4 Presentation in the Local Context
72b7576f 853
bf62b306 854In open local context, the *Display* functions presented above can be as well.
72b7576f 855
bf62b306 856**WARNING**
72b7576f 857
2683e647 858The function *AIS_InteractiveObject::Display* automatically activates the object's default selection mode. When you only want to visualize an Interactive Object in open Context, you must call the function *AIS_InteractiveContext::Display*.
72b7576f 859
bf62b306 860You can activate or deactivate specific selection modes in the local open context in several different ways:
861Use the Display functions with the appropriate modes.
862
863~~~~~
864 AIS_InteractiveContext::ActivateStandardMode
865 //can be used only if a Local Context is opened.
866 AIS_InteractiveContext::DeactivateStandardMode
867 AIS_InteractiveContext::ActivatedStandardModes
868 AIS_InteractiveContext::SetShapeDecomposition
869~~~~~
72b7576f 870
bf62b306 871This activates the corresponding selection mode for all objects in Local Context, which accept decomposition into sub-shapes. Every new Object which has been loaded into the interactive context and which meets the decomposition criteria is automatically activated according to these modes.
72b7576f 872
bf62b306 873**WARNING**
72b7576f 874
4ee1bdf4 875If you have opened a local context by loading an object with the default options <i>(AllowShapeDecomposition = Standard_True)</i>, all objects of the "Shape" type are also activated with the same modes. You can change the state of these "Standard" objects by using *SetShapeDecomposition(Status)*.
72b7576f 876
bf62b306 877Load an interactive object by the function *AIS_InteractiveContext::Load*.
72b7576f 878
bf62b306 879This function allows loading an Interactive Object whether it is visualized or not with a given selection mode, and/or with the necessary decomposition option. If *AllowDecomp=TRUE* and obviously, if the interactive object is of the "Shape" type, these "standard" selection modes will be automatically activated as a function of the modes present in the Local Context.
72b7576f 880
bf62b306 881Use *AIS_InteractiveContext::Activate* and *AIS_InteractiveContext::Deactivate* to directly activate/deactivate selection modes on an object.
72b7576f 882
bf62b306 883@subsubsection occt_visu_3_4_5 Filters
72b7576f 884
18006a0f 885To define an environment of dynamic detection, you can use standard filter classes or create your own.
886A filter questions the owner of the sensitive primitive in local context to determine if it has the desired qualities. If it answers positively, it is kept. If not, it is rejected.
887
888The root class of objects is *SelectMgr_Filter*. The principle behind it is straightforward: a filter tests to see whether the owners <i>(SelectMgr_EntityOwner)</i> detected in mouse position by the Local context selector answer *OK*. If so, it is kept, otherwise it is rejected.
72b7576f 889
bf62b306 890You can create a custom class of filter objects by implementing the deferred function *IsOk()*:
72b7576f 891
bf62b306 892~~~~~
893class MyFilter : public SelectMgr_Filter { };
894virtual Standard_Boolean MyFilter::IsOk
895 (const Handle(SelectMgr_EntityOwner)& anObj) const = 0;
896~~~~~
72b7576f 897
bf62b306 898In *SelectMgr*, there are also Composition filters (AND Filters, OR Filters), which allow combining several filters. In InteractiveContext , all filters that you add are stocked in an OR filter (which answers *OK* if at least one filter answers *OK*).
72b7576f 899
bf62b306 900There are Standard filters, which have already been implemented in several packages:
901 * *StdSelect_EdgeFilter* - for edges, such as lines and circles;
902 * *StdSelect_FaceFilter* - for faces, such as planes, cylinders and spheres;
18006a0f 903 * *StdSelect_ShapeTypeFilter* - for shape types, such as compounds, solids, shells and wires;
bf62b306 904 * *AIS_TypeFilter* - for types of interactive objects;
905 * *AIS_SignatureFilter* - for types and signatures of interactive objects;
906 * *AIS_AttributeFilter* - for attributes of Interactive Objects, such as color and width.
72b7576f 907
18006a0f 908As there are specific behaviors on shapes, each new *Filter* class must, if necessary, redefine *AIS_LocalContext::ActsOn* function, which informs the Local Context if it acts on specific types of sub-shapes. By default, this function answers *FALSE*.
72b7576f 909
bf62b306 910**WARNING**
911
912Only type filters are activated in Neutral Point to make it possible to identify a specific type of visualized object. For filters to come into play, one or more object selection modes must be activated.
72b7576f 913
bf62b306 914There are several functions to manipulate filters:
4ee1bdf4 915* *AIS_InteractiveContext::AddFilter* adds a filter passed as an argument.
916* *AIS_InteractiveContext::RemoveFilter* removes a filter passed as an argument.
917* *AIS_InteractiveContext::RemoveFilters* removes all present filters.
918* *AIS_InteractiveContext::Filters* gets the list of filters active in a local context.
dba69de2 919
72b7576f 920<h4>Example </h4>
921
bf62b306 922~~~~~
4ee1bdf4 923myContext->OpenLocalContext(Standard_False);
bf62b306 924// no object in neutral point is loaded
72b7576f 925
4ee1bdf4 926myContext->ActivateStandardMode(TopAbs_Face);
bf62b306 927//activates decomposition of shapes into faces.
928Handle (AIS_Shape) myAIShape = new AIS_Shape ( ATopoShape);
72b7576f 929
4ee1bdf4 930myContext->Display(myAIShape,1,-1,Standard_True,Standard_True);
72b7576f 931
4ee1bdf4 932//shading visualization mode, no specific mode, authorization for decomposition into sub-shapes. At this Stage, myAIShape is decomposed into faces...
72b7576f 933
bf62b306 934Handle(StdSelect_FaceFilter) Fil1= new
935 StdSelect_FaceFilter(StdSelect_Revol);
936Handle(StdSelect_FaceFilter) Fil2= new
2683e647 937 StdSelect_FaceFilter(StdSelect_Plane);
72b7576f 938
4ee1bdf4 939myContext->AddFilter(Fil1);
940myContext->AddFilter(Fil2);
72b7576f 941
bf62b306 942//only faces of revolution or planar faces will be selected
943
4ee1bdf4 944myContext->MoveTo( xpix,ypix,Vue);
bf62b306 945// detects the mouse position
946~~~~~
72b7576f 947
bf62b306 948@subsubsection occt_visu_3_4_6 Selection in the Local Context
949
950Dynamic detection and selection are put into effect in a straightforward way. There are only a few conventions and functions to be familiar with. The functions are the same in neutral point and in open local context:
951 * *AIS_InteractiveContext::MoveTo* - passes mouse position to Interactive Context selectors
952 * *AIS_InteractiveContext::Select* - stocks what has been detected on the last *MoveTo*. Replaces the previously selected object. Empties the stack if nothing has been detected at the last move
953 * *AIS_InteractiveContext::ShiftSelect* - if the object detected at the last move was not already selected, it is added to the list of the selected objects. If not, it is withdrawn. Nothing happens if you click on an empty area.
954 * *AIS_InteractiveContext::Select* selects everything found in the surrounding area.
955 * *AIS_InteractiveContext::ShiftSelect* selects what was not previously in the list of selected, deselects those already present.
956
957Highlighting of detected and selected entities is automatically managed by the Interactive Context, whether you are in neutral point or Local Context. The Highlight colors are those dealt with above. You can nonetheless disconnect this automatic mode if you want to manage this part yourself :
958~~~~~
959 AIS_InteractiveContext::SetAutomaticHilight
960 AIS_InteractiveContext::AutomaticHilight
961~~~~~
72b7576f 962
bf62b306 963If there is no open local context, the objects selected are called **current objects**. If there is a local context, they are called **selected objects**. Iterators allow entities to be recovered in either case. A set of functions allows manipulating the objects, which have been placed in these different lists.
964
965**WARNING**
966
967When a Local Context is open, you can select entities other than interactive objects (vertices, edges etc.) from decompositions in standard modes, or from activation in specific modes on specific interactive objects. Only interactive objects are stocked in the list of selected objects.
968
969You can question the Interactive context by moving the mouse. The following functions can be used:
970 * *AIS_InteractiveContext::HasDetected* informs if something has been detected;
971 * *AIS_InteractiveContext::HasDetectedShape* informs if it is a shape;
972 * *AIS_InteractiveContext::DetectedShape* gets the shape if the detected entity is an object;
973 * *AIS_InteractiveContext::DetectedInteractive* gets the interactive object if the detected entity is an object.
974
975After using the *Select* and *ShiftSelect* functions in Neutral Point, you can explore the list of selections, referred to as current objects in this context. The following functions can be used:
976 * *AIS_InteractiveContext::InitCurrent* initiates a scan of this list;
977 * *AIS_InteractiveContext::MoreCurrent* extends the scan;
978 * *AIS_InteractiveContext::NextCurrent* resumes the scan;
979 * *AIS_InteractiveContext::Current* gets the name of the current object detected in the scan;
980 * *AIS_InteractiveContext::FirstCurrentObject* gets the first current interactive object;
981 * *AIS_InteractiveContext::HilightCurrents* highlights current objects;
982 * *AIS_InteractiveContext::UnhilightCurrents* removes highlight from current objects;
983 * *AIS_InteractiveContext::ClearCurrents* empties the list of current objects in order to update it;
984 * *AIS_InteractiveContext::IsCurrent* finds the current object.
985
986In the Local Context, you can explore the list of selected objects available. The following functions can be used:
987 * *AIS_InteractiveContext::InitSelected* initiates the list of objects;
988 * *AIS_InteractiveContext::MoreSelected* extends the list of objects;
989 * *AIS_InteractiveContext::NextSelected* resumes a scan;
990 * *AIS_InteractiveContext::SelectedShape* gets the name of the selected object;
991 * *AIS_InteractiveContext::HasSelectedShape* checks if the selected shape is obtained;
992 * *AIS_InteractiveContext::Interactive* gets the picked interactive object;
993 * *AIS_InteractiveContext::HasApplicative* checks if the applicative object has an owner from Interactive attributed to it;
994 * *AIS_InteractiveContext::Applicative* gets the owner of the detected applicative entity;
995 * *AIS_InteractiveContext::IsSelected* gets the name of the selected object.
72b7576f 996
72b7576f 997
bf62b306 998<h4>Example </h4>
999~~~~~
4ee1bdf4 1000myAISCtx->InitSelected();
1001while (myAISCtx->MoreSelected())
bf62b306 1002 {
4ee1bdf4 1003 if (myAISCtx->HasSelectedShape)
bf62b306 1004 {
4ee1bdf4 1005 TopoDS_Shape ashape = myAISCtx->SelectedShape();
bf62b306 1006 // to be able to use the picked shape
2683e647 1007 }
bf62b306 1008 else
1009 {
4ee1bdf4 1010 Handle_AIS_InteractiveObject anyobj = myAISCtx->Interactive();
bf62b306 1011 // to be able to use the picked interactive object
1012 }
4ee1bdf4 1013myAISCtx->NextSelected();
bf62b306 1014}
1015~~~~~
72b7576f 1016
bf62b306 1017You have to ask whether you have selected a shape or an interactive object before you can recover the entity in the Local Context or in the iteration loop. If you have selected a Shape from *TopoDS* on decomposition in standard mode, the *Interactive()* function returns the interactive object, which provided the selected shape. Other functions allow you to manipulate the content of Selected or Current Objects:
1018 * *AIS_InteractiveContext::EraseSelected* erases the selected objects;
1019 * *AIS_InteractiveContext::DisplaySelected* displays them;
1020 * *AIS_InteractiveContext::SetSelected* puts the objects in the list of selections;
1021 * *AIS_InteractiveContext::SetSelectedCurrent* takes the list of selected objects from a local context and puts it into the list of current objects in Neutral Point;
1022 * *AIS_InteractiveContext::AddOrRemoveSelected* adds or removes an object from the list of selected entities;
1023 * *AIS_InteractiveContext::HilightSelected* highlights the selected object;
1024 * *AIS_InteractiveContext::UnhilightSelected* removes highlighting from the selected object;
1025 * *AIS_InteractiveContext::ClearSelected* empties the list of selected objects.
72b7576f 1026
72b7576f 1027
bf62b306 1028You can highlight and remove highlighting from a current object, and empty the list of current objects using the following functions:
1029~~~~~
1030 AIS_InteractiveContext::HilightCurrents
1031 AIS_InteractiveContext::UnhilightCurrents
1032 AIS_InteractiveContext::ClearCurrents
1033~~~~~
1034When you are in an open Local Context, you may need to keep "temporary" interactive objects. This is possible using the following functions:
1035 * *AIS_InteractiveContext::KeepTemporary* transfers the characteristics of the interactive object seen in its local context (visualization mode, etc.) to the neutral point. When the local context is closed, the object does not disappear.
1036 * *AIS_InteractiveContext::SetSelectedCurrent* allows the selected object to become the current object when you close the local context.
72b7576f 1037
bf62b306 1038You can also want to use function *AIS_InteractiveContext::ClearLocalContext* to modify in a general way the state of the local context before continuing a selection (emptying objects, removing filters, standard activation modes).
72b7576f 1039
bf62b306 1040@subsubsection occt_visu_3_4_7 Recommendations
72b7576f 1041
bf62b306 1042The possibilities of use for local contexts are numerous depending on the type of operation that you want to perform:
72b7576f 1043 * working on all visualized interactive objects,
1044 * working on only a few objects,
1045 * working on a single object.
1046
bf62b306 1047When you want to work on one type of entity, you should open a local context with the option *UseDisplayedObjects* set to FALSE. Some functions which allow you to recover the visualized interactive objects, which have a given Type, and Signature from the "Neutral Point" are:
72b7576f 1048
bf62b306 1049~~~~~
1050AIS_InteractiveContext::DisplayedObjects (AIS_ListOfInteractive& aListOfIO) const;
1051AIS_InteractiveContext::DisplayedObjects (const AIS_KindOfInteractive WhichKind, const Standard_Integer WhichSignature;
1052AIS_ListOfInteractive& aListOfIO) const;
1053~~~~~
72b7576f 1054
bf62b306 1055At this stage, you only have to load the functions *Load, Activate,* and so on.
72b7576f 1056
bf62b306 1057When you open a Local Context with default options, you must keep the following points in mind:
1058* The Interactive Objects visualized at Neutral Point are activated with their default selection mode. You must deactivate those, which you do not want to use.
1059* The Shape Type Interactive Objects are automatically decomposed into sub-shapes when standard activation modes are launched.
1060* The "temporary" Interactive Objects present in the Local Contexts are not automatically taken into account. You have to load them manually if you want to use them.
72b7576f 1061
bf62b306 1062The stages could be the following:
1063 1. Open a Local Context with the right options;
1064 2. Load/Visualize the required complementary objects with the desired activation modes.
1065 3. Activate Standard modes if necessary
1066 4. Create its filters and add them to the Local Context
1067 5. Detect/Select/recover the desired entities
1068 6. Close the Local Context with the adequate index.
72b7576f 1069
bf62b306 1070It is useful to create an **interactive editor**, to which you pass the Interactive Context. This allow setting up different contexts of selection/presentation according to the operation, which you want to perform.
1071
1072Let us assume that you have visualized several types of interactive objects: *AIS_Points*, *AIS_Axes*, *AIS_Trihedrons*, and *AIS_Shapes*.
72b7576f 1073
bf62b306 1074For your applicative function, you need an axis to create a revolved object. You could obtain this axis by identifying:
72b7576f 1075 * an axis which is already visualized,
1076 * 2 points,
1077 * a rectilinear edge on the shapes which are present,
bf62b306 1078 * a cylindrical face on the shapes (You will take the axis of this face)
72b7576f 1079
bf62b306 1080~~~~~
1081myIHMEditor::myIHMEditor
1082 (const Handle(AIS_InteractiveContext)& Ctx,
2683e647 1083 ....) :
1084 myCtx(Ctx),
bf62b306 1085 ...
72b7576f 1086{
1087}
1088
1089myIHMEditor::PrepareContext()
1090{
4ee1bdf4 1091myIndex =myCtx->OpenLocalContext();
72b7576f 1092
bf62b306 1093//the filters
72b7576f 1094
2683e647 1095Handle(AIS_SignatureFilter) F1 = new AIS_SignatureFilter(AIS_KOI_Datum,AIS_SD_Point);
bf62b306 1096//filter on the points
72b7576f 1097
bf62b306 1098Handle(AIS_SignatureFilter) F2 = new AIS_SignatureFilter(AIS_KOI_Datum,AIS_SD_Axis);
1099//filters on the axes.
72b7576f 1100
bf62b306 1101Handle(StdSelect_FaceFilter) F3 = new StdSelect_FaceFilter(AIS_Cylinder);
1102//cylindrical face filters
72b7576f 1103//...
bf62b306 1104// activation of standard modes on the shapes..
4ee1bdf4 1105myCtx->ActivateStandardMode(TopAbs_FACE);
1106myCtx->ActivateStandardMode(TopAbs_VERTEX);
1107myCTX->Add(F1);
1108myCTX->Add(F2);
1109myCTX->Add(F3);
72b7576f 1110
bf62b306 1111// at this point, you can call the selection/detection function
72b7576f 1112}
1113
1114void myIHMEditor::MoveTo(xpix,ypix,Vue)
1115
4ee1bdf4 1116{ myCTX->MoveTo(xpix,ypix,vue);
bf62b306 1117// the highlight of what is detected is automatic.
1118}
1119Standard_Boolean myIHMEditor::Select()
1120{
1121// returns true if you should continue the selection
4ee1bdf4 1122 myCTX->Select();
1123 myCTX->InitSelected();
1124 if(myCTX->MoreSelected())
2683e647 1125 {
1126 if(myCTX->HasSelectedShape())
4ee1bdf4 1127 { const TopoDS_Shape& sh = myCTX->SelectedShape();
bf62b306 1128 if( vertex){
1129 if(myFirstV...)
1130 {
4ee1bdf4 1131 //if it is the first vertex, you stock it, then you deactivate the faces and only keep the filter on the points:
bf62b306 1132 mypoint1 = ....;
4ee1bdf4 1133 myCtx->RemoveFilters();
1134 myCTX->DeactivateStandardMode(TopAbs_FACE);
1135 myCtx->Add(F1);
bf62b306 1136 // the filter on the AIS_Points
4ee1bdf4 1137 myFirstV = Standard_False;
1138 return Standard_True;
2683e647 1139 }
bf62b306 1140 else
2683e647 1141 {
bf62b306 1142 mypoint2 =...;
1143 // construction of the axis return Standard_False;
1144 }
2683e647 1145 }
1146 else
1147 {
bf62b306 1148 //it is a cylindrical face : you recover the axis; visualize it; and stock it.
1149 return Standard_False;
1150 }
2683e647 1151 }
bf62b306 1152 // it is not a shape but is no doubt a point.
1153 else
1154 {
1155 Handle(AIS_InteractiveObject)
4ee1bdf4 1156 SelObj = myCTX->SelectedInteractive();
1157 if(SelObj->Type()==AIS_KOI_Datum)
bf62b306 1158 {
4ee1bdf4 1159 if(SelObj->Signature()==1)
bf62b306 1160 {
1161 if (firstPoint)
1162 {
1163 mypoint1 =...
1164 return Standard_True;
1165 }
1166 else
1167 {
1168 mypoint2 = ...;
1169 //construction of the axis, visualization, stocking
1170 return Standard_False;
1171 }
1172 }
1173
1174 else
1175 {
1176 // you have selected an axis; stock the axis
1177 return Standard_False;
1178 }
1179 }
1180 }
1181 }
1182 }
1183void myIHMEditor::Terminate()
1184{
1185myCtx->CloseLocalContext(myIndex);
1186...
1187}
1188~~~~~
72b7576f 1189
bf62b306 1190@subsection occt_visu_3_5 Standard Interactive Object Classes
72b7576f 1191
18006a0f 1192Interactive Objects are selectable and viewable objects connecting graphic representation and the underlying reference geometry.
1193
1194They are divided into four types:
1195 * the **Datum** - a construction geometric element;
1196 * the **Relation** - a constraint on the interactive shape and the corresponding reference geometry;
1197 * the **Object** - a topological shape or connection between shapes;
1198 * **None** a token, that instead of eliminating the object, tells the application to look further until it finds an acceptable object definition in its generation.
1199
1200Inside these categories, there is a possibility of additional characterization by means of a signature. The signature provides an index to the further characterization. By default, the **Interactive Object** has a *None* type and a signature of 0 (equivalent to *None*).
1201If you want to give a particular type and signature to your interactive object, you must redefine the two virtual methods: <i>Type</i> and <i>Signature</i>.
1202
1203@subsubsection occt_visu_3_5_1 Datum
1204
1205The **Datum** groups together the construction elements such as lines, circles, points, trihedrons, plane trihedrons, planes and axes.
bf62b306 1206
1207*AIS_Point, AIS_Axis, AIS_Line, AIS_Circle, AIS_Plane* and *AIS_Trihedron* have four selection modes:
1208 * mode 0 : selection of a trihedron;
1209 * mode 1 : selection of the origin of the trihedron;
1210 * mode 2 : selection of the axes;
1211 * mode 3 : selection of the planes XOY, YOZ, XOZ.
72b7576f 1212
bf62b306 1213when you activate one of modes: 1 2 3 4, you pick AIS objects of type:
1214 * *AIS_Point*
1215 * *AIS_Axis* (and information on the type of axis)
1216 * *AIS_Plane* (and information on the type of plane).
72b7576f 1217
bf62b306 1218*AIS_PlaneTrihedron* offers three selection modes:
1219 * mode 0 : selection of the whole trihedron;
1220 * mode 1 : selection of the origin of the trihedron;
18006a0f 1221 * mode 2 : selection of the axes - same remarks as for the Trihedron.
72b7576f 1222
bf62b306 1223For the presentation of planes and trihedra, the default unit of length is millimeter, and the default value for the representation of axes is 100. If you modify these dimensions, you must temporarily recover the object **Drawer**. From it, take the *Aspects* in which the values for length are stored (*PlaneAspect* for the plane, *FirstAxisAspect* for trihedra), and change these values inside these Aspects. Finally, recalculate the presentation.
e5bd0d98 1224
18006a0f 1225@subsubsection occt_visu_3_5_2 Object
1226
1227The **Object** type includes topological shapes, and connections between shapes.
e5bd0d98 1228
ba06f8bb 1229*AIS_Shape* has three visualization modes :
72b7576f 1230 * mode 0 : Line (default mode)
1231 * mode 1 : Shading (depending on the type of shape)
1232 * mode 2 : Bounding Box
1233
ba06f8bb 1234And at maximum seven selection modes, depending on the shape complexity:
bf62b306 1235 * mode 0 : selection of the *AIS_Shape*;
1236 * mode 1 : selection of the vertices;
1237 * mode 2 : selection of the edges;
1238 * mode 3 : selection of the wires;
1239 * mode 4 : selection of the faces;
1240 * mode 5 : selection of the shells;
e5bd0d98 1241 * mode 6 : selection of the constituent solids.
72b7576f 1242
ba06f8bb 1243 * *AIS_Triangulation* is a simple interactive object for displaying triangular mesh contained in *Poly_Triangulation* container.
1244 * *AIS_ConnectedInteractive* is an Interactive Object connecting to another interactive object reference, and located elsewhere in the viewer makes it possible not to calculate presentation and selection, but to deduce them from your object reference.
2683e647 1245 * *AIS_ConnectedShape* is an object connected to interactive objects having a shape; this class has the same decompositions as *AIS_Shape*. Furthermore, it allows a presentation of hidden parts, which are calculated automatically from the shape of its reference.
ba06f8bb 1246 * *AIS_MultipleConnectedInteractive* is an object connected to a list of interactive objects (which can also be Connected objects. It does not require memory hungry calculations of presentation)
1247 * *AIS_MultipleConnectedShape* is an interactive Object connected to a list of interactive objects having a Shape <i>(AIS_Shape, AIS_ConnectedShape, AIS_MultipleConnectedShape)</i>. The presentation of hidden parts is calculated automatically.
1248 * *AIS_TexturedShape* is an Interactive Object that supports texture mapping. It is constructed as a usual AIS_Shape, but has additional methods that allow to map a texture on it.
1249 * *MeshVS_Mesh* is an Interactive Object that represents meshes, it has a data source that provides geometrical information (nodes, elements) and can be built up from the source data with a custom presentation builder.
72b7576f 1250
18006a0f 1251
1252The class *AIS_ColoredShape* allows using custom colors and line widths for *TopoDS_Shape* objects and their sub-shapes.
1253
1254~~~~~
1255 AIS_ColoredShape aColoredShape = new AIS_ColoredShape (theShape);
1256
1257 // setup color of entire shape
1258 aColoredShape->SetColor (Quantity_Color (Quantity_NOC_RED));
1259
1260 // setup line width of entire shape
1261 aColoredShape->SetWidth (1.0);
1262
1263 // set transparency value
1264 aColoredShape->SetTransparency (0.5);
1265
1266 // customize color of specified sub-shape
1267 aColoredShape->SetCustomColor (theSubShape, Quantity_Color (Quantity_NOC_BLUE1));
1268
1269 // customize line width of specified sub-shape
1270 aColoredShape->SetCustomWidth (theSubShape, 0.25);
1271~~~~~
1272
1273The presentation class *AIS_PointCloud* can be used for efficient drawing of large arbitrary sets of colored points. It uses *Graphic3d_ArrayOfPoints* to pass point data into OpenGl graphic driver to draw a set points as an array of "point sprites". The point data is packed into vertex buffer object for performance.
1274- The type of point marker used to draw points can be specified as a presentation aspect.
1275- The presentation provides selection by a bounding box of the visualized set of points. It supports two display / highlighting modes: points or bounding box.
1276
1277@image html point_cloud.png "A random colored cloud of points"
1278
1279Example:
1280~~~~~
1281Handle(Graphic3d_ArrayOfPoints) aPoints = new Graphic3d_ArrayOfPoints (2000, Standard_True);
1282aPoints->AddVertex (gp_Pnt(-40.0, -40.0, -40.0), Quantity_Color (Quantity_NOC_BLUE1));
1283aPoints->AddVertex (gp_Pnt (40.0, 40.0, 40.0), Quantity_Color (Quantity_NOC_BLUE2));
1284
1285Handle(AIS_PointCloud) aPntCloud = new AIS_PointCloud();
1286aPntCloud->SetPoints (aPoints);
1287~~~~~
1288
1289The draw command *vpointcloud* builds a cloud of points from shape triangulation.
1290This command can also draw a sphere surface or a volume with a large amount of points (more than one million).
1291
1292
bf62b306 1293@subsubsection occt_visu_3_5_3 Relations
18006a0f 1294
1295The **Relation** is made up of constraints on one or more interactive shapes and the corresponding reference geometry. For example, you might want to constrain two edges in a parallel relation. This constraint is considered as an object in its own right, and is shown as a sensitive primitive. This takes the graphic form of a perpendicular arrow marked with the || symbol and lying between the two edges.
1296
1297The following relations are provided by *AIS*:
bf62b306 1298 * *AIS_ConcentricRelation*
1299 * *AIS_FixRelation*
1300 * *AIS_IdenticRelation*
1301 * *AIS_ParallelRelation*
1302 * *AIS_PerpendicularRelation*
1303 * *AIS_Relation*
1304 * *AIS_SymmetricRelation*
1305 * *AIS_TangentRelation*
72b7576f 1306
bf62b306 1307The list of relations is not exhaustive.
72b7576f 1308
bf62b306 1309@subsubsection occt_visu_3_5_4 Dimensions
1310 * *AIS_AngleDimension*
1311 * *AIS_Chamf3dDimension*
1312 * *AIS_DiameterDimension*
1313 * *AIS_DimensionOwner*
1314 * *AIS_LengthDimension*
1315 * *AIS_OffsetDimension*
1316 * *AIS_RadiusDimension*
72b7576f 1317
bf62b306 1318 @subsubsection occt_visu_3_5_5 MeshVS_Mesh
72b7576f 1319
bf62b306 1320*MeshVS_Mesh* is an Interactive Object that represents meshes. This object differs from the *AIS_Shape* as its geometrical data is supported by the data source *MeshVS_DataSource* that describes nodes and elements of the object. As a result, you can provide your own data source.
72b7576f 1321
2683e647 1322However, the *DataSource* does not provide any information on attributes, for example nodal colors, but you can apply them in a special way - by choosing the appropriate presentation builder.
72b7576f 1323
bf62b306 1324The presentations of *MeshVS_Mesh* are built with the presentation builders *MeshVS_PrsBuilder*. You can choose between the builders to represent the object in a different way. Moreover, you can redefine the base builder class and provide your own presentation builder.
72b7576f 1325
72b7576f 1326You can add/remove builders using the following methods:
bf62b306 1327~~~~~
1328 MeshVS_Mesh::AddBuilder (const Handle (MeshVS_PrsBuilder) &Builder, Standard_Boolean TreatAsHilighter)
1329 MeshVS_Mesh::RemoveBuilder (const Standard_Integer Index)
1330 MeshVS_Mesh::RemoveBuilderById (const Standard_Integer Id)
1331~~~~~
72b7576f 1332
bf62b306 1333There is a set of reserved display and highlighting mode flags for *MeshVS_Mesh*. Mode value is a number of bits that allows selecting additional display parameters and combining the following mode flags, which allow displaying mesh in wireframe, shading and shrink modes:
1334~~~~~
1335 MeshVS_DMF_WireFrame
1336 MeshVS_DMF_Shading
1337 MeshVS_DMF_Shrink
1338~~~~~
72b7576f 1339
bf62b306 1340It is also possible to display deformed mesh in wireframe, shading or shrink modes usung :
1341~~~~~
1342 MeshVS_DMF_DeformedPrsWireFrame
1343 MeshVS_DMF_DeformedPrsShading
1344 MeshVS_DMF_DeformedPrsShrink
1345~~~~~
72b7576f 1346
bf62b306 1347The following methods represent different kinds of data :
1348~~~~~
1349 MeshVS_DMF_VectorDataPrs
1350 MeshVS_DMF_NodalColorDataPrs
1351 MeshVS_DMF_ElementalColorDataPrs
1352 MeshVS_DMF_TextDataPrs
1353 MeshVS_DMF_EntitiesWithData
1354~~~~~
1355
1356The following methods provide selection and highlighting :
1357~~~~~
1358 MeshVS_DMF_SelectionPrs
1359 MeshVS_DMF_HilightPrs
1360~~~~~
72b7576f 1361
bf62b306 1362*MeshVS_DMF_User* is a user-defined mode.
72b7576f 1363
bf62b306 1364These values will be used by the presentation builder.
1365There is also a set of selection modes flags that can be grouped in a combination of bits:
1366 * *MeshVS_SMF_0D*
1367 * *MeshVS_SMF_Link*
1368 * *MeshVS_SMF_Face*
1369 * *MeshVS_SMF_Volume*
1370 * *MeshVS_SMF_Element* - groups *0D, Link, Face* and *Volume* as a bit mask ;
1371 * *MeshVS_SMF_Node*
1372 * *MeshVS_SMF_All* - groups *Element* and *Node* as a bit mask;
1373 * *MeshVS_SMF_Mesh*
1374 * *MeshVS_SMF_Group*
1375
1376Such an object, for example, can be used for displaying the object and stored in the STL file format:
72b7576f 1377
bf62b306 1378~~~~~
1379// read the data and create a data source
1380Handle (StlMesh_Mesh) aSTLMesh = RWStl::ReadFile (aFileName);
1381Handle (XSDRAWSTLVRML_DataSource) aDataSource = new XSDRAWSTLVRML_DataSource (aSTLMesh);
72b7576f 1382
bf62b306 1383// create mesh
1384Handle (MeshVS_Mesh) aMesh = new MeshVS();
4ee1bdf4 1385aMesh->SetDataSource (aDataSource);
72b7576f 1386
bf62b306 1387// use default presentation builder
1388Handle (MeshVS_MeshPrsBuilder) aBuilder = new MeshVS_MeshPrsBuilder (aMesh);
4ee1bdf4 1389aMesh->AddBuilder (aBuilder, Standard_True);
bf62b306 1390~~~~~
72b7576f 1391
bf62b306 1392*MeshVS_NodalColorPrsBuilder* allows representing a mesh with a color scaled texture mapped on it.
1393To do this you should define a color map for the color scale, pass this map to the presentation builder,
2683e647 1394and define an appropriate value in the range of 0.0 - 1.0 for every node.
72b7576f 1395
bf62b306 1396The following example demonstrates how you can do this (check if the view has been set up to display textures):
1397
1398~~~~~
1399// assign nodal builder to the mesh
1400Handle (MeshVS_NodalColorPrsBuilder) aBuilder = new MeshVS_NodalColorPrsBuilder
2683e647 1401 (aMesh,MeshVS_DMF_NodalColorDataPrs | MeshVS_DMF_OCCMask);
4ee1bdf4 1402aBuilder->UseTexture (Standard_True);
bf62b306 1403
1404// prepare color map
1405Aspect_SequenceOfColor aColorMap;
1406aColorMap.Append ((Quantity_NameOfColor) Quantity_NOC_RED);
1407aColorMap.Append ((Quantity_NameOfColor) Quantity_NOC_BLUE1);
1408
1409// assign color scale map values (0..1) to nodes
1410TColStd_DataMapOfIntegerReal aScaleMap;
2683e647 1411...
bf62b306 1412// iterate through the nodes and add an node id and an appropriate value to the map
1413aScaleMap.Bind (anId, aValue);
2683e647 1414
bf62b306 1415// pass color map and color scale values to the builder
4ee1bdf4 1416aBuilder->SetColorMap (aColorMap);
1417aBuilder->SetInvalidColor (Quantity_NOC_BLACK);
1418aBuilder->SetTextureCoords (aScaleMap);
1419aMesh->AddBuilder (aBuilder, Standard_True);
bf62b306 1420~~~~~
72b7576f 1421
bf62b306 1422@subsection occt_visu_3_6 Dynamic Selection
72b7576f 1423
bf62b306 1424The idea of dynamic selection is to represent the entities, which you want to select by a bounding box in the actual 2D space of the selection view. The set of these zones is ordered by a powerful sorting algorithm.
1425To then find the applicative entities actually detected at this position, all you have to do is read which rectangles are touched at mouse position (X,Y) of the view, and judiciously reject some of the entities which have provided these rectangles.
72b7576f 1426
bf62b306 1427@subsubsection occt_visu_3_6_1 How to go from the objects to 2D boxes
72b7576f 1428
1429
bf62b306 1430An intermediary stage consists in representing what you can make selectable by means of sensitive primitives and owners, entities of a high enough level to be known by the selector mechanisms.
72b7576f 1431
bf62b306 1432The sensitive primitive is capable of:
72b7576f 1433 * giving a 2D bounding box to the selector.
bf62b306 1434 * answering the rejection criteria positively or negatively by a "Matches" function.
72b7576f 1435 * being projected from 3D in the 2D space of the view if need be.
bf62b306 1436 * returning the owner which it will represent in terms of selection.
72b7576f 1437
bf62b306 1438A set of standard sensitive primitives exists in Select3D packages for 3D primitives.
72b7576f 1439
bf62b306 1440The owner is the entity, which makes it possible to link the sensitive primitives and the objects that you really wanted to detect. It stocks the diverse information, which makes it possible to find objects. An owner has a priority (*5* by default), which you can change to make one entity more selectable than another.
72b7576f 1441
bf62b306 1442@image html visualization_image021.png
1443@image latex visualization_image021.png
72b7576f 1444
bf62b306 1445@subsubsection occt_visu_3_6_2 Implementation in an interactive/selectable object
1446
1447Define the number of selection modes possible, i.e. what you want to identify by activating each of the selection modes.
72b7576f 1448
bf62b306 1449For example: for an interactive object representing a topological shape:
1450* mode 0: selection of the interactive object itself;
1451* mode 1: selection of the vertices;
1452* mode 2: selection of the edges;
1453* mode 3: selection of the wires;
1454* mode 4: selection of the detectable faces.
72b7576f 1455
bf62b306 1456For each selection mode of an interactive object, "model" is the set of entities, which you want to locate by these primitives and these owners.
72b7576f 1457
bf62b306 1458There is an "owner" root class, *SelectMgr_EntityOwner*, containing a reference to a selectable object, which has created it. If you want to stock its information, you have to create classes derived from this root class. Example: for shapes, there is the *StdSelect_BRepOwner* class, which can save a *TopoDS* shape as a field as well as the Interactive Object.
72b7576f 1459
bf62b306 1460The set of sensitive primitives which has been calculated for a given mode is stocked in *SelectMgr_Selection*.
72b7576f 1461
bf62b306 1462For an Interactive object, the modeling is done in the *ComputeSelection* virtual function.
72b7576f 1463
bf62b306 1464Let us consider an example of an interactive object representing a box.
72b7576f 1465
bf62b306 1466We are interested in two location modes:
1467 * mode 0: location of the whole box.
1468 * mode 1: location of the edges on the box.
72b7576f 1469
bf62b306 1470For the first mode, all sensitive primitives will have the same owner, which will represent the interactive object. In the second case, we have to create an owner for each edge, and this owner will have to contain the index for the edge, which it represents. You will create a class of owner, which derives from *SelectMgr_EntityOwner*.
1471
1472The *ComputeSelection* function for the interactive box can have the following form:
72b7576f 1473
bf62b306 1474~~~~~
1475void InteractiveBox::ComputeSelection
1476 (const Handle(SelectMgr_Selection)& Sel,
2683e647 1477 const Standard_Integer Mode)
bf62b306 1478{
1479 switch(Mode)
1480 { case 0: //locating the whole box by making its faces sensitive...
1481 {
1482 Handle(SelectMgr_EntityOwner) Ownr = new SelectMgr_EntityOwner(this,5);
4ee1bdf4 1483 for(Standard_Integer I=1;I<=Nbfaces;I++)
bf62b306 1484 {
1485 //Array is a TColgp_Array1OfPnt: which represents the array of vertices. Sensitivity is
1486 Select3D_TypeOfSensitivity value
4ee1bdf4 1487 Sel->Add(new Select3D_SensitiveFace(Ownr,Array,Sensitivity));
bf62b306 1488 }
1489 break;
2683e647 1490 }
1491 case 1:
bf62b306 1492 // locates the edges {
4ee1bdf4 1493 for(Standard_Integer i=1;i<=12;i++)
bf62b306 1494 {
1495 // 1 owner per edge...
4ee1bdf4 1496 Handle(mypk_EdgeOwner) Ownr = new mypk_EdgeOwner(this,i,6);
1497 //6->priority
1498 Sel->Add(new Select3D_SensitiveSegment (Ownr,firstpt(i),lastpt(i)));
bf62b306 1499 }
1500 break;
1501 }
1502 }
1503 }
1504~~~~~
72b7576f 1505
bf62b306 1506Selectable objects are loaded in the selection manager, which has one or more selectors; in general, we suggest assigning one selector per viewer. All you have to do afterwards is to activate or deactivate the different selection modes for selectable objects. The *SelectionManager* looks after the call to the *ComputeSelection* functions for different objects.
72b7576f 1507
bf62b306 1508NOTE: This procedure is completely hidden if you use the <a href="#occt_visu_3_3"> AIS Interactive Context </a>
72b7576f 1509
1510<h4>Example </h4>
bf62b306 1511~~~~~
1512//We have several " interactive boxes " box1, box2, box3;
1513 Handle(SelectMgr_SelectionManager) SM = new SelectMgr_SelectionManager();
1514 Handle(StdSelect_ViewerSelector3d) VS = new StdSelect_ViewerSelector3d();
4ee1bdf4 1515 SM->Add(VS);
1516 SM->Load(box1);SM->Load(box2);SM->Load(box3);
bf62b306 1517 // box load.
4ee1bdf4 1518 SM->Activate(box1,0,VS);
bf62b306 1519 // activates mode 0 of box 1 in the selector VS
4ee1bdf4 1520 SM->Activate(box1,1,VS);
1521 M->Activate(box3,1,VS);
1522VS->Pick(xpix,ypix,vue3d)
bf62b306 1523// detection of primitives by mouse position.
4ee1bdf4 1524Handle(EntityOwner) POwnr = VS->OnePicked();
bf62b306 1525// picking of the "best" owner detected
4ee1bdf4 1526for(VS->Init();VS->More();VS->Next())
bf62b306 1527 {
4ee1bdf4 1528 VS->Picked();
bf62b306 1529 // picking of all owners detected
2683e647 1530 }
4ee1bdf4 1531 SM->Deactivate(box1);
bf62b306 1532 // deactivate all active modes of box1
1533~~~~~
72b7576f 1534
bf62b306 1535@section occt_visu_4 3D Presentations
72b7576f 1536
bf62b306 1537@subsection occt_visu_4_1 Glossary of 3D terms
72b7576f 1538
bf62b306 1539* **Anti-aliasing** This mode attempts to improve the screen resolution by drawing lines and curves in a mixture of colors so that to the human eye the line or curve is smooth. The quality of the result is linked to the quality of the algorithm used by the workstation hardware.
1540* **Depth-cueing** Reduces the color intensity for the portion of an object further away from the eye to give the impression of depth. This is used for wireframe objects. Shaded objects do not require this.
1541* **Group** - a set of primitives and attributes on those primitives. Primitives and attributes may be added to a group but cannot be removed from a group, except by erasing them globally. A group can have a pick identity.
1542* **Light** There are five kinds of light source - ambient, headlight, directional, positional and spot. The light is only activated in a shading context in a view.
1543* **Primitive** - a drawable element. It has a definition in 3D space. Primitives can either be lines, faces, text, or markers. Once displayed markers and text remain the same size. Lines and faces can be modified e.g. zoomed. Primitives must be stored in a group.
1544* **Structure** - manages a set of groups. The groups are mutually exclusive. A structure can be edited, adding or removing groups. A structure can reference other structures to form a hierarchy. It has a default (identity) transformation and other transformations may be applied to it (rotation, translation, scale, etc). It has no default attributes for the primitive lines, faces, markers, and text. Attributes may be set in a structure but they are overridden by the attributes in each group. Each structure has a display priority associated with it, which rules the order in which it is redrawn in a 3D viewer. If the visualization mode is incompatible with the view it is not displayed in that view, e.g. a shading-only object is not visualized in a wireframe view.
1545* **View** - is defined by a view orientation, a view mapping, and a context view.
1546* **Viewer** - manages a set of views.
1547* **View orientation** - defines the manner in which the observer looks at the scene in terms of View Reference Coordinates.
1548* **View mapping** - defines the transformation from View Reference Coordinates to the Normalized Projection Coordinates. This follows the Phigs scheme.
1549* **Z-Buffering** -= a form of hidden surface removal in shading mode only. This is always active for a view in the shading mode. It cannot be suppressed.
72b7576f 1550
18006a0f 1551@subsection occt_visu_4_2 Graphic primitives
72b7576f 1552
18006a0f 1553The *Graphic3d* package is used to create 3D graphic objects in a 3D viewer. These objects called **structures** are made up of groups of primitives and attributes, such as polylines, planar polygons with or without holes, text and markers, and attributes, such as color, transparency, reflection, line type, line width, and text font. A group is the smallest editable element of a structure. A transformation can be applied to a structure. Structures can be connected to form a tree of structures, composed by transformations. Structures are globally manipulated by the viewer.
72b7576f 1554
bf62b306 1555Graphic structures can be:
72b7576f 1556 * Displayed,
1557 * Highlighted,
1558 * Erased,
1559 * Transformed,
18006a0f 1560 * Connected to form a tree hierarchy of structures, created by transformations.
bf62b306 1561
1562There are classes for:
72b7576f 1563 * Visual attributes for lines, faces, markers, text, materials,
1564 * Vectors and vertices,
72b7576f 1565 * Graphic objects, groups, and structures.
1566
18006a0f 1567@subsubsection occt_visu_4_2_2 Structure hierarchies
bf62b306 1568
18006a0f 1569The root is the top of a structure hierarchy or structure network. The attributes of a parent structure are passed to its descendants. The attributes of the descendant structures do not affect the parent. Recursive structure networks are not supported.
1570
1571@subsubsection occt_visu_4_2_3 Graphic primitives
bf62b306 1572* **Markers**
72b7576f 1573 * Have one or more vertices,
1574 * Have a type, a scale factor, and a color,
bf62b306 1575 * Have a size, shape, and orientation independent of transformations.
1576* **Polygons**
72b7576f 1577 * Have one closed boundary,
1578 * Have at least three vertices,
1579 * Are planar and have a normal,
bf62b306 1580 * Have interior attributes - style, color, front and back material, texture and reflection ratio,
1581 * Have a boundary with the following attributes - type, width scale factor, color. The boundary is only drawn when the interior style is hollow.
72b7576f 1582
bf62b306 1583* **Polygons with holes**
1584 * Have multiple closed boundaries, each one with at least three vertices,
72b7576f 1585 * Are planar and have a normal,
bf62b306 1586 * Have interior attributes - style, color, front and back material,
1587 * Have a boundary with the following attributes - type, width scale factor, color. The boundary is only drawn when the interior style is hollow.
72b7576f 1588
bf62b306 1589* **Polylines**
72b7576f 1590 * Have two or more vertices,
1591 * Have the following attributes - type, width scale factor, color.
1592
bf62b306 1593* **Text**
72b7576f 1594 * Has geometric and non-geometric attributes,
bf62b306 1595 * Geometric attributes - character height, character up vector, text path, horizontal and vertical alignment, orientation, three-dimensional position, zoomable flag
1596 * Non-geometric attributes - text font, character spacing, character expansion factor, color.
72b7576f 1597
18006a0f 1598@subsubsection occt_visu_4_2_4 Primitive arrays
72b7576f 1599
bf62b306 1600Primitive arrays are a more efficient approach to describe and display the primitives from the aspects of memory usage and graphical performance. The key feature of the primitive arrays is that the primitive data is not duplicated. For example, two polygons could share the same vertices, so it is more efficient to keep the vertices in a single array and specify the polygon vertices with indices of this array. In addition to such kind of memory savings, the OpenGl graphics driver provides the Vertex Buffer Objects (VBO). VBO is a sort of video memory storage that can be allocated to hold the primitive arrays, thus making the display operations more efficient and releasing the RAM memory.
72b7576f 1601
bf62b306 1602The Vertex Buffer Objects are enabled by default, but VBOs availability depends on the implementation of OpenGl. If the VBOs are unavailable or there is not enough video memory to store the primitive arrays, the RAM memory will be used to store the arrays.
72b7576f 1603
bf62b306 1604The Vertex Buffer Objects can be disabled at the application level. You can use the method *Graphic3d_GraphicDriver::EnableVBO (const Standard_Boolean status)* to enable/disable VBOs:
1605
1606The following example shows how to disable the VBO support:
72b7576f 1607
bf62b306 1608~~~~~
4ee1bdf4 1609// get the graphic driver
bf62b306 1610Handle (Graphic3d_GraphicDriver) aDriver =
2683e647 1611 myAISContext->CurrentViewer()->Driver();
72b7576f 1612
4ee1bdf4 1613// disable VBO support
1614aDriver->EnableVBO (Standard_False);
bf62b306 1615~~~~~
72b7576f 1616
bf62b306 1617**Note** that the use of Vertex Buffer Objects requires the application level primitive data provided by the *Graphic3d_ArrayOfPrimitives* to be transferred to the video memory. *TKOpenGl* transfers the data and releases the *Graphic3d_ArrayOfPrimitives* internal pointers to the primitive data. Thus it might be necessary to pay attention to such kind of behaviour, as the pointers could be modified (nullified) by the *TKOpenGl*.
1618
1619The different types of primitives could be presented with the following primitive arrays:
1620 * *Graphic3d_ArrayOfPoints,*
1621 * *Graphic3d_ArrayOfPolygons,*
1622 * *Graphic3d_ArrayOfPolylines,*
1623 * *Graphic3d_ArrayOfQuadrangles,*
1624 * *Graphic3d_ArrayOfQuadrangleStrips,*
1625 * *Graphic3d_ArrayOfSegments,*
1626 * *Graphic3d_ArrayOfTriangleFans,*
1627 * *Graphic3d_ArrayOfTriangles,*
1628 * *Graphic3d_ArrayOfTriangleStrips.*
1629
1630The *Graphic3d_ArrayOfPrimitives* is a base class for these primitive arrays.
1631
1632Method *Graphic3d_ArrayOfPrimitives::AddVertex* allows adding There is a set of similar methods to add vertices to the primitive array.
1633
1634These methods take vertex coordinates as an argument and allow you to define the color, the normal and the texture coordinates assigned to the vertex. The return value is the actual number of vertices in the array.
1635
1636You can also modify the values assigned to the vertex or query these values by the vertex index:
1637 * *void Graphic3d_ArrayOfPrimitives::SetVertice*
1638 * *void Graphic3d_ArrayOfPrimitives::SetVertexColor*
1639 * *void Graphic3d_ArrayOfPrimitives::SetVertexNormal*
1640 * *void Graphic3d_ArrayOfPrimitives::SetVertexTexel*
1641 * *gp_Pnt Graphic3d_ArrayOfPrimitives::Vertices*
2683e647 1642 * *gp_Dir Graphic3d_ArrayOfPrimitives::VertexNormal*
bf62b306 1643 * *gp_Pnt3d Graphic3d_ArrayOfPrimitives::VertexTexel*
1644 * *Quantity_Color Graphic3d_ArrayOfPrimitives::VertexColor*
1645 * *void Graphic3d_ArrayOfPrimitives::Vertices*
1646 * *void Graphic3d_ArrayOfPrimitives::VertexNormal*
1647 * *void Graphic3d_ArrayOfPrimitives::VertexTexel*
1648 * *void Graphic3d_ArrayOfPrimitives::VertexColor*
1649
1650The following example shows how to define an array of points:
72b7576f 1651
bf62b306 1652~~~~~
1653// create an array
1654Handle (Graphic3d_ArrayOfPoints) anArray = new Graphic3d_ArrayOfPoints (aVerticiesMaxCount);
1655
1656// add vertices to the array
4ee1bdf4 1657anArray->AddVertex (10.0, 10.0, 10.0);
1658anArray->AddVertex (0.0, 10.0, 10.0);
72b7576f 1659
bf62b306 1660// add the array to the structure
1661Handle (Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (aPrs);
4ee1bdf4 1662aGroup->BeginPrimitives ();
1663aGroup->AddPrimitiveArray (anArray);
1664aGroup->EndPrimitives ();
bf62b306 1665~~~~~
72b7576f 1666
bf62b306 1667If the primitives share the same vertices (polygons, triangles, etc.) then you can define them as indices of the vertices array.
72b7576f 1668
bf62b306 1669The method *Graphic3d_ArrayOfPrimitives::AddEdge* allows defining the primitives by indices. This method adds an "edge" in the range <i> [1, VertexNumber() ] </i> in the array.
72b7576f 1670
bf62b306 1671It is also possible to query the vertex defined by an edge using method *Graphic3d_ArrayOfPrimitives::Edge*
72b7576f 1672
bf62b306 1673The following example shows how to define an array of triangles:
72b7576f 1674
bf62b306 1675~~~~~
1676// create an array
2683e647 1677Standard_Boolean IsNormals = Standard_False;
1678Standard_Boolean IsColors = Standard_False;
bf62b306 1679Standard_Boolean IsTextureCrds = Standard_False;
1680Handle (Graphic3d_ArrayOfTriangles) anArray =
2683e647 1681 new Graphic3d_ArrayOfTriangles (aVerticesMaxCount,
1682 aEdgesMaxCount,
1683 IsNormals,
1684 IsColors,
1685 IsTextureCrds);
bf62b306 1686// add vertices to the array
2683e647 1687anArray->AddVertex (-1.0, 0.0, 0.0); // vertex 1
1688anArray->AddVertex ( 1.0, 0.0, 0.0); // vertex 2
1689anArray->AddVertex ( 0.0, 1.0, 0.0); // vertex 3
1690anArray->AddVertex ( 0.0,-1.0, 0.0); // vertex 4
bf62b306 1691
1692// add edges to the array
2683e647 1693anArray->AddEdge (1); // first triangle
4ee1bdf4 1694anArray->AddEdge (2);
1695anArray->AddEdge (3);
2683e647 1696anArray->AddEdge (1); // second triangle
4ee1bdf4 1697anArray->AddEdge (2);
1698anArray->AddEdge (4);
bf62b306 1699
1700// add the array to the structure
1701Handle (Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (aPrs);
4ee1bdf4 1702aGroup->BeginPrimitives ();
1703aGroup->AddPrimitiveArray (anArray);
1704aGroup->EndPrimitives ();
bf62b306 1705~~~~~
72b7576f 1706
bf62b306 1707If the primitive array presents primitives built from sequential sets of vertices, for example polygons, then you can specify the bounds, or the number of vertices for each primitive. You can use the method *Graphic3d_ArrayOfPrimitives::AddBound* to define the bounds and the color for each bound. This method returns the actual number of bounds.
72b7576f 1708
bf62b306 1709It is also possible to set the color and query the number of edges in the bound and bound color.
1710~~~~~
1711 Standard_Integer Graphic3d_ArrayOfPrimitives::Bound
1712 Quantity_Color Graphic3d_ArrayOfPrimitives::BoundColor
1713 void Graphic3d_ArrayOfPrimitives::BoundColor
1714~~~~~
1715
1716The following example shows how to define an array of polygons:
72b7576f 1717
bf62b306 1718~~~~~
1719// create an array
2683e647 1720Standard_Boolean IsNormals = Standard_False;
bf62b306 1721Standard_Boolean IsVertexColors = Standard_False;
2683e647 1722Standard_Boolean IsFaceColors = Standard_False;
1723Standard_Boolean IsTextureCrds = Standard_False;
bf62b306 1724Handle (Graphic3d_ArrayOfPolygons) anArray =
2683e647 1725 new Graphic3d_ArrayOfPolygons (aVerticesMaxCount,
1726 aBoundsMaxCount,
1727 aEdgesMaxCount,
1728 IsNormals,
1729 IsVertexColors,
1730 IsFaceColors,
1731 IsTextureCrds);
bf62b306 1732
1733// add bounds to the array, first polygon
4ee1bdf4 1734anArray->AddBound (3);
2683e647 1735anArray->AddVertex (-1.0, 0.0, 0.0);
1736anArray->AddVertex ( 1.0, 0.0, 0.0);
1737anArray->AddVertex ( 0.0, 1.0, 0.0);
bf62b306 1738
1739// add bounds to the array, second polygon
4ee1bdf4 1740anArray->AddBound (4);
2683e647 1741anArray->AddVertex (-1.0, 0.0, 0.0);
1742anArray->AddVertex ( 1.0, 0.0, 0.0);
1743anArray->AddVertex ( 1.0,-1.0, 0.0);
1744anArray->AddVertex (-1.0,-1.0, 0.0);
bf62b306 1745
1746// add the array to the structure
1747Handle (Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (aPrs);
4ee1bdf4 1748aGroup->BeginPrimitives ();
1749aGroup->AddPrimitiveArray (anArray);
1750aGroup->EndPrimitives ();
bf62b306 1751~~~~~
72b7576f 1752
bf62b306 1753There are also several helper methods. You can get the type of the primitive array:
1754~~~~~
1755 Graphic3d_TypeOfPrimitiveArray
1756 Graphic3d_ArrayOfPrimitives::Type
1757 Standard_CString Graphic3d_ArrayOfPrimitives::StringType
1758~~~~~
72b7576f 1759
bf62b306 1760and check if the primitive array provides normals, vertex colors and vertex texels (texture coordinates):
72b7576f 1761
bf62b306 1762~~~~~
1763 Standard_Boolean Graphic3d_ArrayOfPrimitives::HasVertexNormals
1764 Standard_Boolean Graphic3d_ArrayOfPrimitives::HasVertexColors
1765 Standard_Boolean Graphic3d_ArrayOfPrimitives::HasVertexTexels
1766~~~~~
72b7576f 1767or get the number of vertices, edges and bounds:
bf62b306 1768~~~~~
1769 Standard_Integer Graphic3d_ArrayOfPrimitives::VertexNumber
1770 Standard_Integer Graphic3d_ArrayOfPrimitives::EdgeNumber
1771 Standard_Integer Graphic3d_ArrayOfPrimitives::BoundNumber
1772~~~~~
1773
18006a0f 1774@subsubsection occt_visu_4_2_5 Text primitive
72b7576f 1775
bf62b306 1776The OpenGl graphics driver uses advanced text rendering powered by FTGL library. This library provides vector text rendering, as a result the text can be rotated and zoomed without quality loss.
1777*Graphic3d* text primitives have the following features:
72b7576f 1778 * fixed size (non-zoomable) or zoomable,
1779 * can be rotated to any angle in the view plane,
1780 * support unicode charset.
1781
bf62b306 1782The text attributes for the group could be defined with the *Graphic3d_AspectText3d* attributes group.
1783To add any text to the graphic structure you can use the following methods:
1784~~~~~
1785 void Graphic3d_Group::Text
1786 (const Standard_CString AText,
2683e647 1787 const Graphic3d_Vertex& APoint,
1788 const Standard_Real AHeight,
1789 const Quantity_PlaneAngle AAngle,
1790 const Graphic3d_TextPath ATp,
1791 const Graphic3d_HorizontalTextAlignment AHta,
1792 const Graphic3d_VerticalTextAlignment AVta,
1793 const Standard_Boolean EvalMinMax),
bf62b306 1794~~~~~
1795*AText* parameter is the text string, *APoint* is the three-dimensional position of the text, *AHeight* is the text height, *AAngle* is the orientation of the text (at the moment, this parameter has no effect, but you can specify the text orientation through the *Graphic3d_AspectText3d* attributes).
1796
1797*ATp* parameter defines the text path, *AHta* is the horizontal alignment of the text, *AVta* is the vertical alignment of the text.
1798
2683e647 1799You can pass *Standard_False* as *EvalMinMax* if you do not want the graphic3d structure boundaries to be affected by the text position.
bf62b306 1800
1801**Note** that the text orientation angle can be defined by *Graphic3d_AspectText3d* attributes.
1802~~~~~
1803 void Graphic3d_Group::Text
1804 (const Standard_CString AText,
2683e647 1805 const Graphic3d_Vertex& APoint,
1806 const Standard_Real AHeight,
1807 const Standard_Boolean EvalMinMax)
bf62b306 1808 void Graphic3d_Group::Text
1809 (const TCcollection_ExtendedString &AText,
1810 const Graphic3d_Vertex& APoint,
2683e647 1811 const Standard_Real AHeight,
1812 const Quantity_PlaneAngle AAngle,
1813 const Graphic3d_TextPath ATp,
1814 const Graphic3d_HorizontalTextAlignment AHta,
1815 const Graphic3d_VerticalTextAlignment AVta,
1816 const Standard_Boolean EvalMinMax)
bf62b306 1817 void Graphic3d_Group::Text
1818 (const TCcollection_ExtendedString &AText,
2683e647 1819 const Graphic3d_Vertex& APoint,
1820 const Standard_Real AHeight,
1821 const Standard_Boolean EvalMinMax)
bf62b306 1822~~~~~
72b7576f 1823
bf62b306 1824See the example:
1825~~~~~
1826// get the group
1827Handle (Graphic3d_Group) aGroup = Prs3d_Root::CurrentGroup (aPrs);
72b7576f 1828
bf62b306 1829// change the text aspect
1830Handle(Graphic3d_AspectText3d) aTextAspect = new Graphic3d_AspectText3d ();
4ee1bdf4 1831aTextAspect->SetTextZoomable (Standard_True);
1832aTextAspect->SetTextAngle (45.0);
1833aGroup->SetPrimitivesAspect (aTextAspect);
72b7576f 1834
bf62b306 1835// add a text primitive to the structure
72b7576f 1836Graphic3d_Vertex aPoint (1, 1, 1);
4ee1bdf4 1837aGroup->Text (Standard_CString ("Text"), aPoint, 16.0);
bf62b306 1838~~~~~
1839
18006a0f 1840@subsubsection occt_visu_4_2_6 Materials
1841
1842A *Graphic3d_MaterialAspect* is defined by:
1843 * Transparency;
1844 * Diffuse reflection - a component of the object color;
1845 * Ambient reflection;
1846 * Specular reflection - a component of the color of the light source;
1847 * Refraction index.
1848
1849The following items are required to determine the three colors of reflection:
1850 * Color;
1851 * Coefficient of diffuse reflection;
1852 * Coefficient of ambient reflection;
1853 * Coefficient of specular reflection.
1854
1855@subsubsection occt_visu_4_2_7 Textures
1856
1857A *texture* is defined by a name.
1858Three types of texture are available:
1859 * 1D;
1860 * 2D;
1861 * Environment mapping.
1862
1863@subsubsection occt_visu_4_2_8 Shaders
1864
1865OCCT visualization core supports GLSL shaders. Currently OCCT supports only vertex and fragment GLSL shader. Shaders can be assigned to a generic presentation by its drawer attributes (Graphic3d aspects). To enable custom shader for a specific AISShape in your application, the following API functions are used:
1866
1867~~~~~
1868// Create shader program
1869Handle(Graphic3d_ShaderProgram) aProgram = new Graphic3d_ShaderProgram();
1870
1871// Attach vertex shader
1872aProgram->AttachShader (Graphic3d_ShaderObject::CreateFromFile(
1873 Graphic3d_TOS_VERTEX, "<Path to VS>"));
1874
1875// Attach fragment shader
1876aProgram->AttachShader (Graphic3d_ShaderObject::CreateFromFile(
1877 Graphic3d_TOS_FRAGMENT, "<Path to FS>"));
1878
1879// Set values for custom uniform variables (if they are)
1880aProgram->PushVariable ("MyColor", Graphic3d_Vec3(0.0f, 1.0f, 0.0f));
1881
1882// Set aspect property for specific AISShape
1883theAISShape->Attributes()->ShadingAspect()->Aspect()->SetShaderProgram (aProgram);
1884~~~~~
72b7576f 1885
18006a0f 1886@subsection occt_visu_4_3 Graphic attributes
72b7576f 1887
18006a0f 1888@subsubsection occt_visu_4_3_1 Aspect package overview
72b7576f 1889
18006a0f 1890The *Aspect* package provides classes for the graphic elements in the viewer:
1891 * Groups of graphic attributes;
1892 * Edges, lines, background;
1893 * Window;
1894 * Driver;
1895 * Enumerations for many of the above.
72b7576f 1896
18006a0f 1897@subsection occt_visu_4_4 3D view facilities
72b7576f 1898
18006a0f 1899@subsubsection occt_visu_4_4_1 Overview
72b7576f 1900
bf62b306 1901The *V3d* package provides the resources to define a 3D viewer and the views attached to this viewer (orthographic, perspective). This package provides the commands to manipulate the graphic scene of any 3D object visualized in a view on screen.
72b7576f 1902
bf62b306 1903A set of high-level commands allows the separate manipulation of parameters and the result of a projection (Rotations, Zoom, Panning, etc.) as well as the visualization attributes (Mode, Lighting, Clipping, Depth-cueing, etc.) in any particular view.
1904
bf62b306 1905The *V3d* package is basically a set of tools directed by commands from the viewer front-end. This tool set contains methods for creating and editing classes of the viewer such as:
72b7576f 1906 * Default parameters of the viewer,
1907 * Views (orthographic, perspective),
1908 * Lighting (positional, directional, ambient, spot, headlight),
bf62b306 1909 * Clipping planes (note that only Z-clipping planes can work with the Phigs interface),
1910 * Instantiated sequences of views, planes, light sources, graphic structures, and picks,
72b7576f 1911 * Various package methods.
1912
18006a0f 1913@subsubsection occt_visu_4_4_2 A programming example
72b7576f 1914
bf62b306 1915This sample TEST program for the *V3d* Package uses primary packages *Xw* and *Graphic3d* and secondary packages *Visual3d, Aspect, Quantity, Phigs* and *math*.
72b7576f 1916
bf62b306 1917~~~~~
1918//Create a default display connection
1919Handle(Aspect_DisplayConnection) aDisplayConnection = new Aspect_DisplayConnection();
72b7576f 1920
4ee1bdf4 1921//Create a Graphic Driver from the default Aspect_DisplayConnection
18006a0f 1922Handle(OpenGl_GraphicDriver) GD = new OpenGl_GraphicDriver (aDisplayConnection);
bf62b306 1923
1924//Create a Viewer to this Driver
1925Handle(V3d_Viewer) VM = new V3d_Viewer(GD, 400.,
4ee1bdf4 1926 // Space size
1927 V3d_Xpos,
1928 // Default projection
1929 Quantity_NOC_DARKVIOLET,
1930 // Default background
1931 V3d_ZBUFFER,
1932 // Type of visualization
1933 V3d_GOURAUD,
1934 // Shading model
1935 V3d_WAIT);
1936 // Update mode
1937// Create a structure in this Viewer
1938Handle(Graphic3d_Structure) S = new Graphic3d_Structure(VM->Viewer()) ;
1939
1940// Type of structure
1941S->SetVisual (Graphic3d_TOS_SHADING);
1942
1943// Create a group of primitives in this structure
bf62b306 1944Handle(Graphic3d_Group) G = new Graphic3d_Group(S) ;
72b7576f 1945
4ee1bdf4 1946// Fill this group with one polygon of size 100
bf62b306 1947Graphic3d_Array1OfVertex Points(0,3) ;
1948Points(0).SetCoord(-100./2.,-100./2.,-100./2.) ;
1949Points(1).SetCoord(-100./2., 100./2.,-100./2.) ;
1950Points(2).SetCoord( 100./2., 100./2.,-100./2.) ;
4ee1bdf4 1951Points(3).SetCoord( 100./2.,-100./2.,-100./2.) ;
1952Normal.SetCoord(0.,0.,1.) ;
1953G->Polygon(Points,Normal) ;
72b7576f 1954
4ee1bdf4 1955// Create Ambient and Infinite Lights in this Viewer
bf62b306 1956Handle(V3d_AmbientLight) L1 = new V3d_AmbientLight
4ee1bdf4 1957 (VM,Quantity_NOC_GRAY50) ;
bf62b306 1958Handle(V3d_DirectionalLight) L2 = new V3d_DirectionalLight
4ee1bdf4 1959 (VM,V3d_XnegYnegZneg,Quantity_NOC_WHITE) ;
72b7576f 1960
4ee1bdf4 1961// Create a 3D quality Window with the same DisplayConnection
1962Handle(Xw_Window) W = new Xw_Window(aDisplayConnection,"Test V3d",0.5,0.5,0.5,0.5) ;
72b7576f 1963
4ee1bdf4 1964// Map this Window to this screen
1965W->Map() ;
72b7576f 1966
4ee1bdf4 1967// Create a Perspective View in this Viewer
18006a0f 1968Handle(V3d_View) aView = new V3d_View(VM);
1969aView->Camera()->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
1970// Associate this View with the Window
1971aView ->SetWindow(W);
1972// Display ALL structures in this View
1973VM->Viewer()->Display();
1974// Finally update the Visualization in this View
1975aView->Update();
1976~~~~~
1977
1978As an alternative to manual setting of perspective parameters the V3d_View::ZfitAll() and V3d_View::FitAll() functions can be used:
72b7576f 1979
18006a0f 1980~~~~~
1981// Display shape in Viewer VM
1982Handle(AIS_InteractiveContext) aContext = new AIS_InteractiveContext (VM);
1983aContext->Display(shape);
1984// Create a Perspective View in Viewer VM
1985Handle(V3d_View) V = new V3d_View (VM);
1986aview->Camera()->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
1987// Change Z-min and Z-max planes of projection volume to match the displayed objects
1988V->ZFitAll();
1989// Fit view to object size
1990V->FitAll();
1991~~~~~
72b7576f 1992
18006a0f 1993@subsubsection occt_visu_4_4_3 Define viewing parameters
72b7576f 1994
18006a0f 1995View projection and orientation in OCCT *v3d* view are driven by camera. The camera calculates and supplies projection and view orientation matrices for rendering by OpenGL. The allows to the user to control all projection parameters. The camera is defined by the following properties:
72b7576f 1996
18006a0f 1997* **Eye** - Defines the observer (camera) position. Make sure the Eye point never gets between the Front and Back clipping planes.
72b7576f 1998
18006a0f 1999* **Center** - defines the origin of View Reference Coordinates (where camera is aimed at).
72b7576f 2000
18006a0f 2001* **Direction** - defines the direction of camera view (from the Eye to the Center).
72b7576f 2002
18006a0f 2003* **Distance** - defines the distance between the Eye and the Center.
72b7576f 2004
18006a0f 2005* **Front** Plane - Defines the position of the front clipping plane in View Reference Coordinates system.
72b7576f 2006
18006a0f 2007* **Back** Plane - Defines the position of the back clipping plane in View Reference Coordinates system.
72b7576f 2008
18006a0f 2009* **ZNear** - defines the distance between the Eye and the Front plane.
72b7576f 2010
18006a0f 2011* **ZFar** - defines the distance between the Eye and the Back plane.
dba69de2 2012
18006a0f 2013Most common view manipulations (panning, zooming, rotation) are implemented as convenience methods of *V3d_View* class, however *Graphic3d_Camera* class can also be used directly by application developers:
72b7576f 2014
18006a0f 2015Example:
2016~~~~~
2017// rotate camera by X axis on 30.0 degrees
2018gp_Trsf aTrsf;
2019aTrsf.SetRotation (gp_Ax1 (gp_Pnt (0.0, 0.0, 0.0), gp_Dir (1.0, 0.0, 0.0)), 30.0);
2020aView->Camera()->Transform (aTrsf);
2021~~~~~
72b7576f 2022
18006a0f 2023@subsubsection occt_visu_4_4_4 Orthographic Projection
2024
2025@image html view_frustum.png "Perspective and orthographic projection"
72b7576f 2026
18006a0f 2027The following code configures the camera for orthographic rendering:
72b7576f 2028
bf62b306 2029~~~~~
18006a0f 2030// Create an orthographic View in this Viewer
2031Handle(V3d_View) aView = new V3d_View (VM);
2032aView->Camera()->SetProjectionType (Graphic3d_Camera::Projection_Orthographic);
2033// update the Visualization in this View
2034aView->Update();
2035~~~~~
72b7576f 2036
18006a0f 2037@subsubsection occt_visu_4_4_5 Perspective Projection
72b7576f 2038
2683e647 2039**Field of view (FOVy)** - defines the field of camera view by y axis in degrees (45° is default).
72b7576f 2040
18006a0f 2041@image html camera_perspective.png "Perspective frustum"
72b7576f 2042
18006a0f 2043The following code configures the camera for perspective rendering:
72b7576f 2044
bf62b306 2045~~~~~
18006a0f 2046// Create a perspective View in this Viewer
2047Handle(V3d_View) aView = new V3d_View(VM);
2048aView->Camera()->SetProjectionType (Graphic3d_Camera::Projection_Perspective);
2049aView->Update();
2050~~~~~
72b7576f 2051
72b7576f 2052
18006a0f 2053@subsubsection occt_visu_4_4_6 Stereographic Projection
72b7576f 2054
18006a0f 2055**IOD** - defines the intraocular distance (in world space units).
2056
2057There are two types of IOD:
2058* _IODType_Absolute_ : Intraocular distance is defined as an absolute value.
2059* _IODType_Relative_ : Intraocular distance is defined relative to the camera focal length (as its coefficient).
2060
2683e647 2061**Field of view (FOV)** - defines the field of camera view by y axis in degrees (45° is default).
18006a0f 2062
2063**ZFocus** - defines the distance to the point of stereographic focus.
2064
2065@image html stereo.png "Stereographic projection"
2066
2067To enable stereo projection, your workstation should meet the following requirements:
2068
2069* The graphic card should support quad buffering.
2070* You need active 3D glasses (LCD shutter glasses).
2071* The graphic driver needs to be configured to impose quad buffering for newly created OpenGl contexts; the viewer and the view should be created after that.
2072
2073In stereographic projection mode the camera prepares two projection matrices to display different stereo-pictures for the left and for the right eye. In a non-stereo camera this effect is not visible because only the same projection is used for both eyes.
2074
2075To enable quad buffering support you should provide the following settings to the graphic driver *opengl_caps*:
72b7576f 2076
18006a0f 2077~~~~~
2078Handle(OpenGl_GraphicDriver) aDriver = new OpenGl_GraphicDriver();
2079OpenGl_Caps& aCaps = aDriver->ChangeOptions();
2080aCaps.contextStereo = Standard_True;
bf62b306 2081~~~~~
72b7576f 2082
18006a0f 2083The following code configures the camera for stereographic rendering:
72b7576f 2084
18006a0f 2085~~~~~
2086// Create a Stereographic View in this Viewer
2087Handle(V3d_View) aView = new V3d_View(VM);
2088aView->Camera()->SetProjectionType (Graphic3d_Camera::Projection_Stereo);
2089// Change stereo parameters
2090aView->Camera()->SetIOD (IODType_Absolute, 5.0);
2091// Finally update the Visualization in this View
2092aView->Update();
2093~~~~~
72b7576f 2094
18006a0f 2095@subsubsection occt_visu_4_4_7 View frustum culling
72b7576f 2096
18006a0f 2097The algorithm of frustum culling on CPU-side is activated by default for 3D viewer. This algorithm allows skipping the presentation outside camera at the rendering stage, providing better performance. The following features support this method:
2098* *Graphic3d_Structure::CalculateBoundBox()* is used to calculate axis-aligned bounding box of a presentation considering its transformation.
2099* *V3d_View::SetFrustumCulling* enables or disables frustum culling for the specified view.
2100* Classes *OpenGl_BVHClipPrimitiveSet* and *OpenGl_BVHTreeSelector* handle the detection of outer objects and usage of acceleration structure for frustum culling.
2101* *BVH_BinnedBuilder* class splits several objects with null bounding box.
72b7576f 2102
18006a0f 2103@subsubsection occt_visu_4_4_8 Underlay and overlay layers management
72b7576f 2104
18006a0f 2105In addition to interactive 3d graphics displayed in the view you can display underlying and overlying graphics: text, color scales and drawings.
72b7576f 2106
bf62b306 2107All *V3d* view graphical objects in the overlay are managed by the default layer manager (*V3d_LayerMgr*). The *V3d* view has a basic layer manager capable of displaying the color scale, but you can redefine this class to provide your own overlay and underlay graphics.
72b7576f 2108
bf62b306 2109The method *V3d_View::SetLayerMgr(const Handle (V3d_LayerMgr)& aMgr)* allows assigning a custom layer manager to the *V3d* view.
72b7576f 2110
18006a0f 2111There are three virtual methods to prepare graphics in the manager for further drawing: setting up layer dimensions and drawing static graphics. These methods can be redefined:
2112
bf62b306 2113~~~~~
2114 void V3d_LayerMgr::Begin ()
2115 void V3d_LayerMgr::Redraw ()
2116 void V3d_LayerMgr::End ()
2117~~~~~
72b7576f 2118
bf62b306 2119The layer manager controls layers (*Visual3d_Layer*) and layer items (*Visual3d_LayerItem*). Both the overlay and underlay layers can be created by the layer manager.
72b7576f 2120
18006a0f 2121The layer entity is presented by the *Visual3d_Layer* class. This entity provides drawing services in the layer, for example:
bf62b306 2122~~~~~
2123 void Visual3d_Layer::DrawText
2124 void Visual3d_Layer::DrawRectangle
2125 void Visual3d_Layer::SetColor
2126 void Visual3d_Layer::SetViewport
2127~~~~~
18006a0f 2128
2129The following example demonstrates how to draw overlay graphics by the *V3d_LayerMgr*:
72b7576f 2130
bf62b306 2131~~~~~
2132// redefined method of V3d_LayerMgr
2133void MyLayerMgr::Redraw ()
72b7576f 2134{
2683e647 2135 Quantity_Color aRed (Quantity_NOC_RED);
2136 myOverlayLayer->SetColor (aRed);
2137 myOverlayLayer->DrawRectangle (0, 0, 100, 100);
72b7576f 2138}
bf62b306 2139~~~~~
72b7576f 2140
2683e647 2141The layer contains layer items that will be displayed on view redraw. Such items are *Visual3d_LayerItem* entities. To manipulate *Visual3d_LayerItem* entities assigned to the layer's internal list you can use the following methods:
72b7576f 2142
bf62b306 2143~~~~~
2144 void Visual3d_Layer::AddLayerItem (const Handle (Visual3d_LayerItem)& Item)
2683e647 2145 void Visual3d_Layer::RemoveLayerItem (const Handle (Visual3d_LayerItem)& Item)
bf62b306 2146 void Visual3d_Layer::RemoveAllLayerItems ()
2683e647 2147 const Visual3d_NListOfLayerItem& Visual3d_Layer::GetLayerItemList ()
bf62b306 2148~~~~~
2683e647 2149The layer's items are rendered when the method *void Visual3d_Layer::RenderLayerItems()* is called by the graphical driver.
72b7576f 2150
bf62b306 2151The *Visual3d_LayerItem* has virtual methods that are used to render the item:
2152~~~~~
2153 void Visual3d_LayerItem::RedrawLayerPrs ()
2154 void Visual3d_LayerItem::ComputeLayerPrs ()
2155~~~~~
72b7576f 2156
bf62b306 2157The item presentation can be computed before drawing by the *ComputeLayerPrs* method to save time on redraw. It also has an additional flag that is used to tell that the presentation should be recomputed:
2158~~~~~
2159 void Visual3d_LayerItem::SetNeedToRecompute (const Standard_Boolean NeedToRecompute)
2160 Standard_Boolean Visual3d_LayerItem::IsNeedToRecompute
2161~~~~~
72b7576f 2162
2683e647 2163An example of *Visual3d_LayerItem* is *V3d_ColorScaleLayerItem* that represents the color scale entity as the layer's item.
2164The *V3d_ColorScaleLayerItem* sends render requests to the color scale entity represented by it. As this entity (*V3d_ColorScale*) is assigned to the *V3d_LayerMgr* it uses its overlay layer's services for drawing:
72b7576f 2165
72b7576f 2166<h4>Example </h4>
2167
bf62b306 2168~~~~~
2169// tell V3d_ColorScale to draw itself
2170void V3d_ColorScaleLayerItem::RedrawLayerPrs ()
72b7576f 2171{
2683e647 2172 Visual3d_LayerItem::RedrawLayerPrs ()
2173 if (!MyColorScale.IsNull ())
2174 MyColorScale->DrawScale ();
72b7576f 2175}
2176
bf62b306 2177// V3d_ColorScale has a reference to a LayerMgr
2178void V3d_ColorScale::DrawScale ()
2179{
2683e647 2180 // calls V3d_ColorScale::PaintRect, V3d_ColorScale::PaintText, etc.
bf62b306 2181}
72b7576f 2182
bf62b306 2183// PaintRect method uses overlay layer of LayerMgr to draw a rectangle
2184void V3d_ColorScale::PaintRect
2683e647 2185 (const Standard_Integer X, const Standard_Integer Y,
2186 const Standard_Integer W, const Standard_Integer H,
2187 const Quantity_Color aColor,
2188 const Standard_Boolean aFilled)
bf62b306 2189{
2683e647 2190 const Handle (Visual3d_Layer)& theLayer = myLayerMgr->Overlay ();
2191 ...
2192 theLayer->SetColor (aColor);
2193 theLayer->DrawRectangle (X, Y, W, H);
2194 ...
bf62b306 2195}
2196~~~~~
72b7576f 2197
18006a0f 2198@subsubsection occt_visu_4_4_9 View background styles
bf62b306 2199There are three types of background styles available for *V3d_view*: solid color, gradient color and image.
72b7576f 2200
bf62b306 2201To set solid color for the background you can use the following methods:
2202~~~~~
2203 void V3d_View::SetBackgroundColor
2204 (const Quantity_TypeOfColor Type,
2683e647 2205 const Quantity_Parameter V1,
2206 const Quantity_Parameter V2,
2207 const Quantity_Parameter V3)
bf62b306 2208~~~~~
72b7576f 2209
bf62b306 2210This method allows you to specify the background color in RGB (red, green, blue) or HLS (hue, lightness, saturation) color spaces, so the appropriate values of the Type parameter are *Quantity_TOC_RGB* and *Quantity_TOC_HLS*.
72b7576f 2211
bf62b306 2212**Note** that the color value parameters *V1,V2,V3* should be in the range between *0.0-1.0.*
72b7576f 2213
bf62b306 2214~~~~~
2215 void V3d_View::SetBackgroundColor(const Quantity_Color &Color)
2216 void V3d_View::SetBackgroundColor(const Quantity_NameOfColor Name)
2217~~~~~
72b7576f 2218
bf62b306 2219The gradient background style could be set up with the following methods:
2220~~~~~
2221 void V3d_View::SetBgGradientColors
2222 (const Quantity_Color& Color1,
2683e647 2223 const Quantity_Color& Color2,
2224 const Aspect_GradientFillMethod FillStyle,
2225 const Standard_Boolean update)
bf62b306 2226
2227 void V3d_View::SetBgGradientColors
2228 (const Quantity_NameOfColor Color1,
2683e647 2229 const Quantity_NameOfColor Color2,
2230 const Aspect_GradientFillMethod FillStyle,
2231 const Standard_Boolean update)
bf62b306 2232~~~~~
72b7576f 2233
bf62b306 2234The *Color1* and *Color2* parameters define the boundary colors of interpolation, the *FillStyle* parameter defines the direction of interpolation. You can pass *Standard_True* as the last parameter to update the view.
72b7576f 2235
bf62b306 2236The fill style can be also set with the method *void V3d_View::SetBgGradientStyle(const Aspect_GradientFillMethod AMethod, const Standard_Boolean update)*.
72b7576f 2237
bf62b306 2238To get the current background color you can use the following methods:
2239~~~~~
2240 void V3d_View::BackgroundColor
2241 (const Quantity_TypeOfColor Type,
2683e647 2242 Quantity_Parameter &V1,
2243 Quantity_Parameter &V2,
2244 Quantity_Parameter &V3)
bf62b306 2245 Quantity_Color V3d_View::BackgroundColor()
2246 void V3d_View::GradientBackgroundColors(Quantity_Color& Color1, Quantity_Color& Color2)
2247 Aspect_GradientBackground GradientBackground()
2248~~~~~
2249
2250To set the image as a background and change the background image style you can use the following methods:
2251~~~~~
4ee1bdf4 2252 void V3d_View::SetBackgroundImage
bf62b306 2253 (const Standard_CString FileName,
2683e647 2254 const Aspect_FillMethod FillStyle,
2255 const Standard_Boolean update)
4ee1bdf4 2256 void V3d_View::SetBgImageStyle
bf62b306 2257 (const Aspect_FillMethod FillStyle,
2683e647 2258 const Standard_Boolean update)
bf62b306 2259~~~~~
72b7576f 2260
bf62b306 2261The *FileName* parameter defines the image file name and the path to it, the *FillStyle* parameter defines the method of filling the background with the image. The methods are:
2683e647 2262 * *Aspect_FM_NONE* - draws the image in the default position;
bf62b306 2263 * *Aspect_FM_CENTERED* - draws the image at the center of the view;
2264 * *Aspect_FM_TILED* tiles the view with the image;
2265 * *Aspect_FM_STRETCH* stretches the image over the view.
72b7576f 2266
72b7576f 2267
18006a0f 2268@subsubsection occt_visu_4_4_10 Dumping a 3D scene into an image file
72b7576f 2269
18006a0f 2270The 3D scene displayed in the view can be dumped in high resolution into an image file. The high resolution (8192x8192 on some implementations) is achieved using the Frame Buffer Objects (FBO) provided by the graphic driver. Frame Buffer Objects enable off-screen rendering into a virtual view to produce images in the background mode (without displaying any graphics on the screen).
72b7576f 2271
bf62b306 2272The *V3d_View* has the following methods for dumping the 3D scene:
4ee1bdf4 2273~~~~
2274Standard_Boolean V3d_View::Dump
2275 (const Standard_CString theFile,
2276 const Image_TypeOfImage theBufferType)
2277~~~~
2278Dumps the scene into an image file with the view dimensions.
2279
2280~~~~
2281Standard_Boolean V3d_View::Dump
2282 (const Standard_CString theFile,
2283 const Aspect_FormatOfSheetPaper theFormat,
2284 const Image_TypeOfImage theBufferType)
2285~~~~
2286Makes the dimensions of the output image compatible to a certain format of printing paper passed by *theFormat* argument.
bf62b306 2287
2288These methods dump the 3D scene into an image file passed by its name and path as theFile.
72b7576f 2289
18006a0f 2290The raster image data handling algorithm is based on the *Image_PixMap* class. The supported extensions are ".png", ".bmp", ".png", ".png".
72b7576f 2291
4ee1bdf4 2292The value passed as *theBufferType* argument defines the type of the buffer for an output image <i>(RGB, RGBA, floating-point, RGBF, RGBAF)</i>. Both methods return *Standard_True* if the scene has been successfully dumped.
72b7576f 2293
18006a0f 2294There is also class *Image_AlienPixMap* providing import / export from / to external image files in formats supported by **FreeImage** library.
2295
bf62b306 2296**Note** that dumping the image for a paper format with large dimensions is a memory consuming operation, it might be necessary to take care of preparing enough free memory to perform this operation.
72b7576f 2297
4ee1bdf4 2298~~~~
2299Handle_Image_PixMap V3d_View::ToPixMap
2300 (const Standard_Integer theWidth,
2301 const Standard_Integer theHeight,
2302 const Image_TypeOfImage theBufferType,
2303 const Standard_Boolean theForceCentered)
2304~~~~
2305Dumps the displayed 3d scene into a pixmap with a width and height passed as *theWidth* and theHeight arguments.
72b7576f 2306
4ee1bdf4 2307The value passed as *theBufferType* argument defines the type of the buffer for a pixmap <i>(RGB, RGBA, floating-point, RGBF, RGBAF)</i>. The last parameter allows centering the 3D scene on dumping.
72b7576f 2308
bf62b306 2309All these methods assume that you have created a view and displayed a 3d scene in it. However, the window used for such a view could be virtual, so you can dump the 3d scene in the background mode without displaying it on the screen. To use such an opportunity you can perform the following steps:
2310* Create display connection;
2311* Initialize graphic driver;
2312* Create a window;
2313* Set up the window as virtual, *Aspect_Window::SetVirtual()* ;
2314* Create a view and an interactive context;
2315* Assign the virtual window to the view;
2316* Display a 3D scene;
2317* Use one of the functions described above to dump the 3D scene.
72b7576f 2318
bf62b306 2319The following example demonstrates this procedure for *WNT_Window* :
72b7576f 2320
bf62b306 2321~~~~~
2322// create a dummy display connection
2323Handle(Aspect_DisplayConnection) aDisplayConnection;
2324
2325// create a graphic driver
2326Handle (Graphic3d_GraphicDriver) aDriver = Graphic3d::InitGraphicDriver (aDisplayConnection);
2327
2328// create a window
2683e647 2329Standard_Integer aDefWidth = 800;
bf62b306 2330Standard_Integer aDefHeight = 600;
4ee1bdf4 2331Handle (WNT_WClass) aWClass = new WNT_WClass ("Virtual Class",DefWindowProc,
2683e647 2332 CS_VREDRAW | CS_HREDRAW, 0, 0,
2333 ::LoadCursor (NULL, IDC_ARROW));
2334Handle (WNT_Window) aWindow = new WNT_Window ("VirtualWnd", aWClass,
2335 WS_OVERLAPPEDWINDOW, 0, 0,
2336 aDefWidth, aDefHeight);
bf62b306 2337
2338// set up the window as virtual
4ee1bdf4 2339aWindow->SetVirtual (Standard_True);
bf62b306 2340
2341// create a view and an interactive context
4ee1bdf4 2342Handle (V3d_Viewer) aViewer = new V3d_Viewer (aDriver,
2683e647 2343 Standard_ExtString ("Virtual"));
4ee1bdf4 2344Handle (AIS_InteractiveContext) aContext = new AIS_InteractiveContext (aViewer);
2345Handle (V3d_View) aView = aViewer->CreateView ();
bf62b306 2346
2347// assign the virtual window to the view
4ee1bdf4 2348aView->SetWindow (aWindow);
bf62b306 2349
2350// display a 3D scene
4ee1bdf4 2351Handle (AIS_Shape) aBox = new AIS_Shape (BRepPrimAPI_MakeBox (5, 5, 5));
2352aContext->Display (aBox);
2353aView->FitAll();
72b7576f 2354
bf62b306 2355// dump the 3D scene into an image file
4ee1bdf4 2356aView->Dump ("3dscene.png");
bf62b306 2357~~~~~
72b7576f 2358
18006a0f 2359@subsubsection occt_visu_4_4_11 Printing a 3D scene
72b7576f 2360
bf62b306 2361The contents of a view can be printed out. Moreover, the OpenGl graphic driver used by the v3d view supports printing in high resolution. The print method uses the OpenGl frame buffer (Frame Buffer Object) for rendering the view contents and advanced print algorithms that allow printing in, theoretically, any resolution.
72b7576f 2362
2683e647 2363The method *void V3d_View::Print(const Aspect_Handle hPrnDC, const Standard_Boolean showDialog, const Standard_Boolean showBackground, const Standard_CString filename, const Aspect_PrintAlgo printAlgorithm)* prints the view contents:
72b7576f 2364
18006a0f 2365*hPrnDC* is the printer device handle. You can pass your own printer handle or *NULL* to select the printer by the default dialog. In that case you can use the default dialog or pass *Standard_False* as the *showDialog* argument to select the default printer automatically.
72b7576f 2366
bf62b306 2367You can define the filename for the printer driver if you want to print out the result into a file.
2368If you do not want to print the background, you can pass *Standard_False* as the *showBackground* argument.
2369The *printAlgorithm* argument allows choosing between two print algorithms that define how the 3d scene is mapped to the print area when the maximum dimensions of the frame buffer are smaller than the dimensions of the print area by choosing *Aspect_PA_STRETCH* or *Aspect_PA_TILE*
72b7576f 2370
bf62b306 2371The first value defines the stretch algorithm: the scene is drawn with the maximum possible frame buffer dimensions and then is stretched to the whole printing area. The second value defines *TileSplit* algorithm: covering the whole printing area by rendering multiple parts of the viewer.
72b7576f 2372
18006a0f 2373**Note** that at the moment the printing is implemented only for Windows.
72b7576f 2374
18006a0f 2375@subsubsection occt_visu_4_4_12 Vector image export
72b7576f 2376
18006a0f 2377The 3D content of a view can be exported to the vector image file format. The vector image export is powered by the *GL2PS* library. You can export 3D scenes into a file format supported by the GL2PS library: PostScript (PS), Encapsulated PostScript (EPS), Portable Document Format (PDF), Scalable Vector Graphics (SVG), LaTeX file format and Portable LaTeX Graphics (PGF).
72b7576f 2378
bf62b306 2379The method *void Visual3d_View::Export (const Standard_CString FileName, const Graphic3d_ExportFormat Format, const Graphic3d_SortType aSortType, const Standard_Real Precision, const Standard_Address ProgressBarFunc, const Standard_Address ProgressObject)* of *Visual3d_View* class allows exporting a 3D scene:
72b7576f 2380
bf62b306 2381The *FileName* defines the output image file name and the *Format* argument defines the output file format:
18006a0f 2382 * *Graphic3d_EF_PostScript (PS)*,
2383 * *Graphic3d_EF_EhnPostScript (EPS)*,
2384 * *Graphic3d_EF_TEX (TEX)*,
2385 * *Graphic3d_EF_PDF (PDF)*,
2386 * *Graphic3d_EF_SVG (SVG)*,
2387 * *Graphic3d_EF_PGF (PGF)*.
72b7576f 2388
bf62b306 2389The *aSortType* parameter defines *GL2PS* sorting algorithm for the primitives. The *Precision, ProgressBarFunc* and *ProgressObject* parameters are implemented for future uses and at the moment have no effect.
72b7576f 2390
bf62b306 2391The *Export* method supports only basic 3d graphics and has several limitations:
2392 * Rendering large scenes could be slow and can lead to large output files;
2393 * Transparency is only supported for PDF and SVG output;
18006a0f 2394 * Textures and some effects are not supported by the *GL2PS* library.
72b7576f 2395
18006a0f 2396@subsubsection occt_visu_4_4_13 Ray tracing support
72b7576f 2397
18006a0f 2398OCCT visualization provides rendering by real-time ray tracing technique. It is allowed to switch easily between usual rasterization and ray tracing rendering modes. The core of OCCT ray tracing is written using GLSL shaders. The ray tracing has a wide list of features:
2399* Hard shadows
2400* Refractions
2401* Reflection
2402* Transparency
2403* Texturing
2404* Support of non-polygon objects, such as lines, text, highlighting, selection.
2405* Performance optimization using 2-level bounding volume hierarchy (BVH).
72b7576f 2406
18006a0f 2407The ray tracing algorithm is recursive (Whitted's algorithm). It uses BVH effective optimization structure. The structure prepares optimized data for a scene geometry for further displaying it in real-time. The time-consuming re-computation of the BVH is not necessary for view operations, selections, animation and even editing of the scene by transforming location of the objects. It is only necessary when the list of displayed objects or their geometry changes.
2408To make the BVH reusable it has been added into an individual reusable OCCT package *TKMath/BVH*.
2409
2410There are several ray-tracing options that user can switch on/off:
2411* Maximum ray tracing depth
2412* Shadows rendering
2413* Specular reflections
2414* Adaptive anti aliasing
2415* Transparency shadow effects
2416
2417Example:
2418~~~~~
2419Graphic3d_RenderingParams& aParams = aView->ChangeRenderingParams();
2420// specifies rendering mode
2421aParams.Method = Graphic3d_RM_RAYTRACING;
2422// maximum ray-tracing depth
2423aParams.RaytracingDepth = 3;
2424// enable shadows rendering
2425aParams.IsShadowEnabled = Standard_True;
2426// enable specular reflections.
2427aParams.IsReflectionEnabled = Standard_True;
2428// enable adaptive anti-aliasing
2429aParams.IsAntialiasingEnabled = Standard_True;
2430// enable light propagation through transparent media.
2431aParams.IsTransparentShadowEnabled = Standard_True;
2432// update the view
2433aView->Update();
2434~~~~~
2435
2436@subsubsection occt_visu_4_4_14 Display priorities
2437
2438Structure display priorities control the order, in which structures are drawn. When you display a structure you specify its priority. The lower is the value, the lower is the display priority. When the display is regenerated, the structures with the lowest priority are drawn first. The structures with the same display priority are drawn in the same order as they have been displayed. OCCT supports eleven structure display priorities.
2439
2440@subsubsection occt_visu_4_4_15 Z-layer support
2441
2683e647 2442OCCT features depth-arranging functionality called z-layer. A graphical presentation can be put into a z-layer. In general, this function can be used for implementing "bring to front" functionality in a graphical application.
18006a0f 2443
2444Example:
2445
2446~~~~~
2447// set z-layer to an interactive object
2683e647 2448Handle(AIS_InteractiveContext) aContext = ...
2449Handle(AIS_InteractiveObject) anInterObj = ...
18006a0f 2450Standard_Integer anId = 3;
2451aViewer->AddZLayer (anId);
2452aContext->SetZLayer (anInterObj, anId);
2453~~~~~
2454
2455For each z-layer, it is allowed to:
2456* Enable / disable depth test for layer.
2457* Enable / disable depth write for layer.
2458* Enable / disable depth buffer clearing.
2459* Enable / disable polygon offset.
2460
2683e647 2461The corresponding method *SetZLayerOption (...)* is available in *Graphic3d_GraphicDriver* interface. You can get the options using getter from *Visual3d_ViewManager* and *V3d_Viewer*. It returns *Graphic3d_ZLayerSettings* cached in *Visual3d_ViewManager* for a given *LayerId*.
18006a0f 2462
2463Example:
2464~~~~~
2465// change z-layer settings
2466Graphic3d_ZLayerSettings aSettings = aViewer->ZLayerSettings (anId);
2467aSettings.EnableSetting (Graphic3d_ZLayerDepthTest);
2468aSettings.EnableSetting (Graphic3d_ZLayerDepthWrite);
2469aSettings.EnableSetting (Graphic3d_ZLayerDepthClear);
2470aSettings.EnableSetting (Graphic3d_ZLayerDepthOffset);
2471aViewer->SetZLayerSettings (anId, aSettings);
2472~~~~~
2473
2474
2475@subsubsection occt_visu_4_4_16 Clipping planes
2476
2477The ability to define custom clipping planes could be very useful for some tasks. OCCT provides such an opportunity.
2478
2479The *Graphic3d_ClipPlane* class provides the services for clipping planes: it holds the plane equation coefficients and provides its graphical representation. To set and get plane equation coefficients you can use the following methods:
2480
2481~~~~~
2482Graphic3d_ClipPlane::Graphic3d_ClipPlane(const gp_Pln& thePlane)
2483void Graphic3d_ClipPlane::SetEquation (const gp_Pln& thePlane)
2484Graphic3d_ClipPlane::Graphic3d_ClipPlane(const Equation& theEquation)
2485void Graphic3d_ClipPlane::SetEquation (const Equation& theEquation)
2486gp_Pln Graphic3d_ClipPlane::ToPlane() const
2487~~~~~
2488
2489The clipping planes can be activated with the following method:
2490~~~~~
2491void Graphic3d_ClipPlane::SetOn (const Standard_Boolean theIsOn)
2492~~~~~
2493
2494The number of clipping planes is limited. You can check the limit value via method *Graphic3d_GraphicDriver::InquirePlaneLimit()*;
2495
2496~~~~~
2497// get the limit of clipping planes for the current view
2498Standard_Integer aMaxClipPlanes = aView->Viewer()->Driver()->InquirePlaneLimit();
2499~~~~~
2500
2501Let us see for example how to create a new clipping plane with custom parameters and add it to a view or to an object:
2502~~~~~
2503// create a new clipping plane
2504const Handle(Graphic3d_ClipPlane)& aClipPlane = new Graphic3d_ClipPlane();
2505// change equation of the clipping plane
2683e647 2506Standard_Real aCoeffA = ...
2507Standard_Real aCoeffB = ...
2508Standard_Real aCoeffC = ...
2509Standard_Real aCoeffD = ...
18006a0f 2510aClipPlane->SetEquation (gp_Pln (aCoeffA, aCoeffB, aCoeffC, aCoeffD));
2511// set capping
2512aClipPlane->SetCapping (aCappingArg == "on");
2513// set the material with red color of clipping plane
2514Graphic3d_MaterialAspect aMat = aClipPlane->CappingMaterial();
2515Quantity_Color aColor (1.0, 0.0, 0.0, Quantity_TOC_RGB);
2516aMat.SetAmbientColor (aColor);
2517aMat.SetDiffuseColor (aColor);
2518aClipPlane->SetCappingMaterial (aMat);
2519// set the texture of clipping plane
2683e647 2520Handle(Graphic3d_Texture2Dmanual) aTexture = ...
18006a0f 2521aTexture->EnableModulate();
2522aTexture->EnableRepeat();
2523aClipPlane->SetCappingTexture (aTexture);
2524// add the clipping plane to an interactive object
2683e647 2525Handle(AIS_InteractiveObject) aIObj = ...
18006a0f 2526aIObj->AddClipPlane (aClipPlane);
2527// or to the whole view
2528aView->AddClipPlane (aClipPlane);
2529// activate the clipping plane
2530aClipPlane->SetOn(Standard_True);
2531// update the view
2532aView->Update();
2533~~~~~
2534
2535
2536@subsubsection occt_visu_4_4_17 Automatic back face culling
2537
2538Back face culling reduces the rendered number of triangles (which improves the performance) and eliminates artifacts at shape boundaries. However, this option can be used only for solid objects, where the interior is actually invisible from any point of view. Automatic back-face culling mechanism is turned on by default, which is controlled by *V3d_View::SetBackFacingModel()*.
2539
2540The following features are applied in *StdPrs_ToolShadedShape::IsClosed()*, which is used for definition of back face culling in *ShadingAspect*:
2541* disable culling for free closed Shells (not inside the Solid) since reversed orientation of a free Shell is a valid case;
2542* enable culling for Solids packed into a compound;
2543* ignore Solids with incomplete triangulation.
2544
2545Back face culling is turned off at TKOpenGl level in the following cases:
2546* clipping/capping planes are in effect;
2547* for translucent objects;
2548* with hatching presentation style.
2549
2550@subsection occt_visu_4_5 Examples: creating a 3D scene
2551
2552To create 3D graphic objects and display them in the screen, follow the procedure below:
25531. Create attributes.
25542. Create a 3D viewer.
25553. Create a view.
25564. Create an interactive context.
25575. Create interactive objects.
25586. Create primitives in the interactive object.
25597. Display the interactive object.
2560
2561@subsubsection occt_visu_4_5_1 Create attributes
2562
2563Create colors.
2564
2565~~~~~
2566Quantity_Color aBlack (Quantity_NOC_BLACK);
2567Quantity_Color aBlue (Quantity_NOC_MATRABLUE);
2568Quantity_Color aBrown (Quantity_NOC_BROWN4);
2569Quantity_Color aFirebrick (Quantity_NOC_FIREBRICK);
2570Quantity_Color aForest (Quantity_NOC_FORESTGREEN);
2571Quantity_Color aGray (Quantity_NOC_GRAY70);
2572Quantity_Color aMyColor (0.99, 0.65, 0.31, Quantity_TOC_RGB);
2573Quantity_Color aBeet (Quantity_NOC_BEET);
2574Quantity_Color aWhite (Quantity_NOC_WHITE);
2575~~~~~
2576
2577Create line attributes.
2578
2579~~~~~
2580Handle(Graphic3d_AspectLine3d) anAspectBrown = new Graphic3d_AspectLine3d();
2581Handle(Graphic3d_AspectLine3d) anAspectBlue = new Graphic3d_AspectLine3d();
2582Handle(Graphic3d_AspectLine3d) anAspectWhite = new Graphic3d_AspectLine3d();
2583anAspectBrown->SetColor (aBrown);
2584anAspectBlue ->SetColor (aBlue);
2585anAspectWhite->SetColor (aWhite);
2586~~~~~
2587
2588Create marker attributes.
2589~~~~~
2590Handle(Graphic3d_AspectMarker3d aFirebrickMarker = new Graphic3d_AspectMarker3d();
2591// marker attributes
2592aFirebrickMarker->SetColor (Firebrick);
2593aFirebrickMarker->SetScale (1.0);
2594aFirebrickMarker->SetType (Aspect_TOM_BALL);
2595// or this
2596// it is a preferred way (supports full-color images on modern hardware).
2597aFirebrickMarker->SetMarkerImage (theImage)
2598~~~~~
2599
2600Create facet attributes.
2601~~~~~
2602Handle(Graphic3d_AspectFillArea3d) aFaceAspect = new Graphic3d_AspectFillArea3d();
2603Graphic3d_MaterialAspect aBrassMaterial (Graphic3d_NOM_BRASS);
2604Graphic3d_MaterialAspect aGoldMaterial (Graphic3d_NOM_GOLD);
2605aFaceAspect->SetInteriorStyle (Aspect_IS_SOLID);
2606aFaceAspect->SetInteriorColor (aMyColor);
2607aFaceAspect->SetDistinguishOn ();
2608aFaceAspect->SetFrontMaterial (aGoldMaterial);
2609aFaceAspect->SetBackMaterial (aBrassMaterial);
2610aFaceAspect->SetEdgeOn();
2611~~~~~
2612
2613Create text attributes.
2614~~~~~
2615Handle(Graphic3d_AspectText3d) aTextAspect = new Graphic3d_AspectText3d (aForest, Graphic3d_NOF_ASCII_MONO, 1.0, 0.0);
2616~~~~~
2617
2618@subsubsection occt_visu_4_5_2 Create a 3D Viewer (a Windows example)
2619
2620~~~~~
2621// create a default connection
2622Handle(Aspect_DisplayConnection) aDisplayConnection;
2623// create a graphic driver from default connection
2624Handle(OpenGl_GraphicDriver) aGraphicDriver = new OpenGl_GraphicDriver (GetDisplayConnection());
2625// create a viewer
2626TCollection_ExtendedString aName ("3DV");
2627myViewer = new V3d_Viewer (aGraphicDriver,aName.ToExtString(), "");
2628// set parameters for V3d_Viewer
2629// defines default lights -
2630// positional-light 0.3 0.0 0.0
2631// directional-light V3d_XnegYposZpos
2632// directional-light V3d_XnegYneg
2633// ambient-light
2634a3DViewer->SetDefaultLights();
2635// activates all the lights defined in this viewer
2636a3DViewer->SetLightOn();
2637// set background color to black
2638a3DViewer->SetDefaultBackgroundColor (Quantity_NOC_BLACK);
2639~~~~~
2640
2641
2642@subsubsection occt_visu_4_5_3 Create a 3D view (a Windows example)
2643
2644It is assumed that a valid Windows window may already be accessed via the method *GetSafeHwnd()*.
2645~~~~~
2646Handle (WNT_Window) aWNTWindow = new WNT_Window (GetSafeHwnd());
2647myView = myViewer->CreateView();
2648myView->SetWindow (aWNTWindow);
2649~~~~~
2650
2651@subsubsection occt_visu_4_5_4 Create an interactive context
2652
2653~~~~~
2654myAISContext = new AIS_InteractiveContext (myViewer);
2655~~~~~
2656
2657You are now able to display interactive objects such as an *AIS_Shape*.
2658
2659~~~~~
2660TopoDS_Shape aShape = BRepAPI_MakeBox (10, 20, 30).Solid();
2661Handle(AIS_Shape) anAISShape = new AIS_Shape(aShape);
2662myAISContext->Display (anAISShape);<