OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-04 18:06:22 +03:00
Code Packages Releases Activity
occt/src/IVtkDraw/IVtkDraw.cxx
abv 896faa7296 0028417: Using PRECOMPILED HEADER to speed up compilation time 
Use of Cotire tool is introduced for acceleration of CMake builds, by usage of precompiled headers.
CMake option BUILD_USE_PCH is added to enable / disable use of precompiled headers

When precompiled headers are used, additional compiler macros are defined globally in the build system to avoid problems due to different order of included files:
- NOMINMAX is defined on Windows to prevent defining "min" and "max" as macros by windows.h
- STRSAFE_NO_DEPRECATE and _SCL_SECURE_NO_WARNINGS are defined on Windows to prevent declaring functions of standard C library as deprecated by #pragma, and other warnings in system headers
- GL_GLEXT_LEGACY and GLX_GLEXT_LEGACY are defined to ensure that only OCCT's own glext.h is used
- __STDC_FORMAT_MACROS is defined to have standard C print format macros always defined

Code is corrected to avoid conflicts with system headers and in case of compiling together as unity builds (partially):
- Some locally defined variables in TKV3d, TKHLR are renamed to be unique
- Duplicated definitions of macros and global functions are eliminated in TKSTEP
- Useless header WNT_UInt.hxx is removed
- Usage of local variables conflicting with X11 macro is avoided in Draw_Viewer.cxx
- Local variables in AIS_ConcentricRelation.cxx are renamed to avoid conflict with macros defined in windows.h
- HXX files containing code are renamed to PXX or merged with corresponding CXX files.

IVtkTools classes are corrected to avoid compiler warnings disabled in non-PCH builds by inclusion of VTK headers.

Useless pragmas disabling warnings on MSVC are removed
2017-07-06 12:41:41 +03:00

1242 lines
36 KiB
C++
Raw Blame History

// Created on: 2012-02-03
//
// Copyright (c) 2012-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifdef NOMINMAX
#undef NOMINMAX /* avoid #define min() and max() */
#endif
#ifdef NOMSG
#undef NOMSG /* avoid #define SendMessage etc. */
#endif
#ifdef NODRAWTEXT
#undef NODRAWTEXT /* avoid #define DrawText etc. */
#endif
#ifdef NONLS
#undef NONLS /* avoid #define CompareString etc. */
#endif
#ifdef NOGDI
#undef NOGDI /* avoid #define SetPrinter (winspool.h) etc. */
#endif
#ifdef NOSERVICE
#undef NOSERVICE
#endif
#ifdef NOKERNEL
#undef NOKERNEL
#endif
#ifdef NOUSER
#undef NOUSER
#endif
#ifdef NOMCX
#undef NOMCX
#endif
#ifdef NOIME
#undef NOIME
#endif
#include <stdio.h>
#ifdef HAVE_STRINGS_H
# include <strings.h>
#endif
#ifdef _WIN32
#include <windows.h>
#include <WNT_WClass.hxx>
#include <WNT_Window.hxx>
#endif
#include <Draw.hxx>
#include <Draw_Interpretor.hxx>
#include <Draw_PluginMacro.hxx>
#include <TCollection_AsciiString.hxx>
#include <TopoDS_Shape.hxx>
#include <BRep_Builder.hxx>
#include <BRepTools.hxx>
#include <DBRep.hxx>
#include <NCollection_DoubleMap.hxx>
#include <NCollection_List.hxx>
#include <NCollection_DataMap.hxx>
#include <TopTools_DataMapOfIntegerShape.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <Aspect_DisplayConnection.hxx>
#include <IVtk_Types.hxx>
#include <IVtkVTK_ShapeData.hxx>
#include <IVtkOCC_Shape.hxx>
#include <IVtkOCC_ShapeMesher.hxx>
#include <IVtkTools_ShapeDataSource.hxx>
#include <IVtkTools_ShapeObject.hxx>
#include <IVtkTools_SubPolyDataFilter.hxx>
#include <IVtkTools_DisplayModeFilter.hxx>
#include <IVtkTools_ShapePicker.hxx>
#include <IVtkDraw.hxx>
#include <IVtkDraw_HighlightAndSelectionPipeline.hxx>
#include <IVtkDraw_Interactor.hxx>
#include <vtkAlgorithmOutput.h>
#include <vtkAppendPolyData.h>
#include <vtkBMPWriter.h>
#include <vtkCamera.h>
#include <vtkCellData.h>
#include <vtkCommand.h>
#include <vtkGeometryFilter.h>
#include <vtkIdTypeArray.h>
#include <vtkImageResize.h>
#include <vtkImageWriter.h>
#include <vtkInteractorStyleTrackballCamera.h>
#include <vtkJPEGWriter.h>
#include <vtkPNGWriter.h>
#include <vtkPNMWriter.h>
#include <vtkPolyDataMapper.h>
#include <vtkProperty.h>
#include <vtkRenderWindow.h>
#include <vtkRenderer.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include <vtkTIFFWriter.h>
#include <vtkWindowToImageFilter.h>
#ifndef _WIN32
#include <X11/X.h>
#include <X11/Shell.h>
#include <X11/Xlib.h>
#include <GL/glx.h>
#include <Xw_Window.hxx>
#include <vtkXRenderWindowInteractor.h>
#include <vtkXOpenGLRenderWindow.h>
#include <X11/Xutil.h>
#include <tk.h>
#endif
// workaround name conflicts with OCCT methods (in class TopoDS_Shape for example)
#ifdef Convex
#undef Convex
#endif
#ifdef Status
#undef Status
#endif
//================================================================
// TYPE DEFINITIONS
//================================================================
typedef NCollection_DoubleMap<TopoDS_Shape, TCollection_AsciiString> DoubleMapOfShapesAndNames;
typedef NCollection_DoubleMap<vtkSmartPointer<vtkActor>, TCollection_AsciiString> DoubleMapOfActorsAndNames;
typedef IVtkDraw_HighlightAndSelectionPipeline PipelinePtr;
//================================================================
// GLOBAL VARIABLES
//================================================================
Standard_IMPORT Standard_Boolean Draw_VirtualWindows;
static Handle(Aspect_DisplayConnection)& GetDisplayConnection()
{
static Handle(Aspect_DisplayConnection) aDisplayConnection;
return aDisplayConnection;
}
static void SetDisplayConnection (const Handle(Aspect_DisplayConnection)& theDisplayConnection)
{
GetDisplayConnection() = theDisplayConnection;
}
static DoubleMapOfShapesAndNames& GetMapOfShapes()
{
static DoubleMapOfShapesAndNames aMap;
return aMap;
}
static DoubleMapOfActorsAndNames& GetMapOfActors()
{
static DoubleMapOfActorsAndNames aMap;
return aMap;
}
static vtkSmartPointer<vtkRenderer>& GetRenderer()
{
static vtkSmartPointer<vtkRenderer> aRenderer;
return aRenderer;
}
static Handle(ShapePipelineMap)& GetPipelines()
{
static Handle(ShapePipelineMap) aPLMap;
if (aPLMap.IsNull())
{
aPLMap = new ShapePipelineMap();
}
return aPLMap;
}
static Handle(PipelinePtr) GetPipeline (const IVtk_IdType& theShapeID)
{
Handle(PipelinePtr) aPtr;
GetPipelines()->Find (theShapeID, aPtr);
return aPtr;
}
//! Get VTK render pipeline with shape ID got from actor.
static Handle(PipelinePtr) PipelineByActor (const vtkSmartPointer<vtkActor>& theActor)
{
IVtk_IdType aShapeID = IVtkTools_ShapeObject::GetShapeSource (theActor)->GetShape()->GetId();
return GetPipeline (aShapeID);
}
//! Get VTK render pipeline with actor that has the input name.
static Handle(PipelinePtr) PipelineByActorName (const TCollection_AsciiString& theName)
{
const vtkSmartPointer<vtkActor>& anActor = GetMapOfActors().Find2 (theName);
return PipelineByActor (anActor);
}
#ifdef _WIN32
static Handle(WNT_Window)& GetWindow()
{
static Handle(WNT_Window) aWindow;
return aWindow;
}
#else
static Handle(Xw_Window)& GetWindow()
{
static Handle(Xw_Window) aXWWin;
return aXWWin;
}
#endif
static vtkSmartPointer<IVtkDraw_Interactor>& GetInteractor()
{
static vtkSmartPointer<IVtkDraw_Interactor> anInteractor;
return anInteractor;
}
static vtkSmartPointer<IVtkTools_ShapePicker>& GetPicker()
{
static vtkSmartPointer<IVtkTools_ShapePicker> aPicker;
return aPicker;
}
//! Generate identical number for shape
Standard_Integer GenerateId()
{
static unsigned int aShapesCounter = (unsigned int )-1;
return (Standard_Integer )++aShapesCounter;
}
//=========================================================
// Function : WClass
// Purpose :
//=========================================================
const Handle(Standard_Transient)& IVtkDraw::WClass()
{
static Handle(Standard_Transient) aWindowClass;
#ifdef _WIN32
if (aWindowClass.IsNull())
{
aWindowClass = new WNT_WClass ("GWVTK_Class", DefWindowProc,
CS_VREDRAW | CS_HREDRAW, 0, 0,
::LoadCursorW (NULL, IDC_ARROW));
}
#endif
return aWindowClass;
}
//==============================================================
// Function : ViewerInit
// Purpose :
//==============================================================
void IVtkDraw::ViewerInit (Standard_Integer thePxLeft,
Standard_Integer thePxTop,
Standard_Integer thePxWidth,
Standard_Integer thePxHeight)
{
static Standard_Boolean isFirst = Standard_True;
Standard_Integer aPxLeft = 0;
Standard_Integer aPxTop = 460;
Standard_Integer aPxWidth = 409;
Standard_Integer aPxHeight = 409;
if (thePxLeft != 0)
{
aPxLeft = thePxLeft;
}
if (thePxTop != 0)
{
aPxTop = thePxTop;
}
if (thePxWidth != 0)
{
aPxWidth = thePxWidth;
}
if (thePxHeight != 0)
{
aPxHeight = thePxHeight;
}
if (isFirst)
{
SetDisplayConnection (new Aspect_DisplayConnection ());
#ifdef _WIN32
if (GetWindow().IsNull())
{
GetWindow() = new WNT_Window ("IVtkTest",
Handle(WNT_WClass)::DownCast (WClass()),
WS_OVERLAPPEDWINDOW,
aPxLeft, aPxTop,
aPxWidth, aPxHeight,
Quantity_NOC_BLACK);
GetWindow()->SetVirtual (Draw_VirtualWindows);
}
#else
if (GetWindow().IsNull())
{
GetWindow() = new Xw_Window (GetDisplayConnection(),
"IVtkTest",
aPxLeft, aPxTop,
aPxWidth, aPxHeight);
GetWindow()->SetVirtual (Draw_VirtualWindows);
}
#endif
// Init pipeline
GetRenderer() = vtkSmartPointer<vtkRenderer>::New();
vtkSmartPointer<vtkRenderWindow> aRenWin = vtkSmartPointer<vtkRenderWindow>::New();
aRenWin->AddRenderer (GetRenderer());
GetRenderer()->GetActiveCamera()->ParallelProjectionOn();
aRenWin->SetSize (aPxWidth, aPxHeight);
#ifdef _WIN32
aRenWin->SetWindowId((void*)GetWindow()->HWindow());
#else
Window aWindowId = GetWindow()->XWindow();
aRenWin->SetWindowId ((void*)aWindowId);
Display *aDisplayId = GetDisplayConnection()->GetDisplay();
aRenWin->SetDisplayId (aDisplayId);
// Setup XWindow
XSynchronize (aDisplayId, 1);
GetWindow()->Map();
// X11 : For keyboard on SUN
XWMHints wmhints;
wmhints.flags = InputHint;
wmhints.input = 1;
XSetWMHints (aDisplayId, aWindowId, &wmhints);
XSelectInput (aDisplayId, aWindowId, ExposureMask | KeyPressMask |
ButtonPressMask | ButtonReleaseMask |
StructureNotifyMask |
PointerMotionMask |
Button1MotionMask | Button2MotionMask |
Button3MotionMask
);
XSynchronize (aDisplayId, 0);
#endif
// Init interactor
GetInteractor() = vtkSmartPointer<IVtkDraw_Interactor>::New();
GetInteractor()->SetRenderWindow (aRenWin);
GetInteractor()->SetOCCWindow (GetWindow());
vtkSmartPointer<vtkInteractorStyleTrackballCamera>
aStyle = vtkSmartPointer<vtkInteractorStyleTrackballCamera>::New();
GetInteractor()->SetInteractorStyle (aStyle);
// Init picker
GetPicker() = vtkSmartPointer<IVtkTools_ShapePicker>::New();
GetPicker()->SetTolerance (0.025f);
GetPicker()->SetRenderer (GetRenderer());
GetInteractor()->SetShapePicker (GetPicker());
GetInteractor()->SetPipelines (GetPipelines());
GetInteractor()->Initialize();
aRenWin->SetOffScreenRendering(Draw_VirtualWindows);
aRenWin->Render();
isFirst = Standard_False;
}
GetWindow()->Map();
}
//================================================================
// Function : VtkInit
// Purpose :
//================================================================
static Standard_Integer VtkInit (Draw_Interpretor& ,
Standard_Integer theArgNum,
const char** theArgs)
{
Standard_Integer aPxLeft = (theArgNum > 1) ? atoi(theArgs[1]) : 0;
Standard_Integer aPxTop = (theArgNum > 2) ? atoi(theArgs[2]) : 0;
Standard_Integer aPxWidth = (theArgNum > 3) ? atoi(theArgs[3]) : 0;
Standard_Integer aPxHeight = (theArgNum > 4) ? atoi(theArgs[4]) : 0;
IVtkDraw::ViewerInit (aPxLeft, aPxTop, aPxWidth, aPxHeight);
return 0;
}
//================================================================
// Function : CreateActor
// Purpose :
//================================================================
vtkActor* CreateActor (const Standard_Integer theId,
const TopoDS_Shape& theShape)
{
if ( theShape.IsNull() )
{
return NULL;
}
Handle(PipelinePtr) aPL = new PipelinePtr (theShape, theId);
GetPipelines()->Bind (theId, aPL);
return aPL->Actor();
}
//================================================================
// Function : VtkDisplay
// Purpose :
//================================================================
static Standard_Integer VtkDisplay (Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error : call ivtkinit before\n";
return 1; // TCL_ERROR
}
// Check arguments
if (theArgNum < 2)
{
theDI << theArgs[0] << " error : expects at least 1 argument\n";
return 1; // TCL_ERROR
}
TCollection_AsciiString aName;
TopoDS_Shape anOldShape, aNewShape;
vtkSmartPointer<vtkRenderer>& aRenderer = GetRenderer();
for (Standard_Integer anIndex = 1; anIndex < theArgNum; ++anIndex)
{
// Get name of shape
aName = theArgs[anIndex];
// Get shape from DRAW
aNewShape = DBRep::Get (theArgs[anIndex]);
// The shape is already in the map
if (GetMapOfShapes().IsBound2 (aName))
{
// Get shape from map
anOldShape = GetMapOfShapes().Find2 (aName);
// Equal shapes
if (anOldShape.IsEqual (aNewShape))
{
// Get actor from map and display it
PipelineByActorName (aName)->AddToRenderer (aRenderer);
}
// Different shapes
else
{
if (aNewShape.IsNull()) continue;
// Create actor from DRAW shape
vtkActor* anActor = CreateActor (GenerateId(), aNewShape);
// Remove old actor from render
PipelineByActorName (aName)->RemoveFromRenderer (aRenderer);
// Update maps
GetMapOfShapes().UnBind2 (aName);
GetMapOfShapes().Bind (aNewShape, aName);
GetMapOfActors().UnBind2 (aName);
GetMapOfActors().Bind (anActor, aName);
// Display new actor
PipelineByActorName (aName)->AddToRenderer (aRenderer);
// Compute selection for displayed actors
GetPicker()->SetSelectionMode (SM_Shape, Standard_True);
}
}
// There is no shape with given name in map
else
{
if (aNewShape.IsNull()) continue;
// Create actor from DRAW shape
Standard_Integer anId = GenerateId();
vtkSmartPointer<vtkActor> anActor = CreateActor (anId, aNewShape);
// Update maps
GetMapOfShapes().Bind (aNewShape, aName);
GetMapOfActors().Bind (anActor, aName);
// Display actor
GetPipeline(anId)->AddToRenderer(aRenderer);
// Compute selection for displayed actors
GetPicker()->SetSelectionMode (SM_Shape, Standard_True);
}
}
// Redraw window
aRenderer->ResetCamera();
GetInteractor()->GetRenderWindow()->Render();
return 0;
}
//================================================================
// Function : VtkErase
// Purpose :
//================================================================
static Standard_Integer VtkErase (Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error : call ivtkinit before\n";
return 1; // TCL_ERROR
}
vtkSmartPointer<vtkRenderer> aRenderer = GetRenderer();
// Erase all objects
if (theArgNum == 1)
{
DoubleMapOfActorsAndNames::Iterator anIterator (GetMapOfActors());
while (anIterator.More())
{
PipelineByActor (anIterator.Key1())->RemoveFromRenderer (aRenderer);
anIterator.Next();
}
}
// Erase named objects
else
{
TCollection_AsciiString aName;
for (Standard_Integer anIndex = 1; anIndex < theArgNum; ++anIndex)
{
aName = theArgs[anIndex];
if (GetMapOfActors().IsBound2 (aName))
{
PipelineByActorName (aName)->RemoveFromRenderer (aRenderer);
}
}
}
// Redraw window
aRenderer->ResetCamera();
GetInteractor()->GetRenderWindow()->Render();
return 0;
}
//================================================================
// Function : VtkRemove
// Purpose : Remove the actor from memory.
//================================================================
static Standard_Integer VtkRemove(Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error : call ivtkinit before\n";
return 1; // TCL_ERROR
}
vtkSmartPointer<vtkRenderer> aRenderer = GetRenderer();
// Remove all objects
if (theArgNum == 1)
{
// Remove all actors from the renderer
DoubleMapOfActorsAndNames::Iterator anIterator(GetMapOfActors());
while (anIterator.More())
{
vtkSmartPointer<IVtkTools_ShapeDataSource> aSrc =
IVtkTools_ShapeObject::GetShapeSource(anIterator.Key1());
if (aSrc.GetPointer() != NULL && !(aSrc->GetShape().IsNull()))
{
GetPicker()->RemoveSelectableObject(aSrc->GetShape());
}
else
{
aRenderer->RemoveActor(anIterator.Key1());
}
anIterator.Next();
}
// Remove all pipelines from the renderer
for (ShapePipelineMap::Iterator anIt(*GetPipelines()); anIt.More(); anIt.Next())
{
anIt.Value()->RemoveFromRenderer(aRenderer);
}
// Clear maps and remove all TopoDS_Shapes, actors and pipelines
GetMapOfShapes().Clear();
GetMapOfActors().Clear();
GetPipelines()->Clear();
}
// Remove named objects
else
{
TCollection_AsciiString aName;
for (Standard_Integer anIndex = 1; anIndex < theArgNum; ++anIndex)
{
aName = theArgs[anIndex];
if (GetMapOfActors().IsBound2(aName))
{
// Remove the actor and its pipeline (if found) from the renderer
vtkSmartPointer<vtkActor> anActor = GetMapOfActors().Find2(aName);
vtkSmartPointer<IVtkTools_ShapeDataSource> aSrc =
IVtkTools_ShapeObject::GetShapeSource(anActor);
if (aSrc.GetPointer() != NULL && !(aSrc->GetShape().IsNull()))
{
IVtk_IdType aShapeID = aSrc->GetShape()->GetId();
GetPicker()->RemoveSelectableObject(aSrc->GetShape());
GetPipeline(aSrc->GetShape()->GetId())->RemoveFromRenderer(aRenderer);
GetPipelines()->UnBind(aShapeID); // Remove a pipepline
}
else
{
aRenderer->RemoveActor(anActor);
}
// Remove the TopoDS_Shape and the actor
GetMapOfShapes().UnBind2(aName); // Remove a TopoDS shape
GetMapOfActors().UnBind2(aName); // Remove an actor
}
}
}
// Redraw window
aRenderer->ResetCamera();
GetInteractor()->GetRenderWindow()->Render();
return 0;
}
//================================================================
// Function : VtkSetDisplayMode
// Purpose :
// Draw args : ivtksetdispmode [name] mode(0,1)
//================================================================
static Standard_Integer VtkSetDisplayMode (Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error: call ivtkinit before\n";
return 1; // TCL_ERROR
}
// Check arguments
if (theArgNum != 2 && theArgNum != 3)
{
theDI << theArgs[0] << " error: expects 1 or 2 arguments\n";
return 1; // TCL_ERROR
}
vtkSmartPointer<vtkActor> anActor;
// Set disp mode for all objects
if (theArgNum == 2)
{
// Get mode
Standard_Integer aMode = Draw::Atoi (theArgs[1]);
DoubleMapOfActorsAndNames::Iterator anIter (GetMapOfActors());
while (anIter.More())
{
anActor = anIter.Key1();
IVtkTools_ShapeDataSource* aSrc = IVtkTools_ShapeObject::GetShapeSource (anActor);
if (aSrc)
{
IVtkOCC_Shape::Handle anOccShape = aSrc->GetShape();
if (!anOccShape.IsNull())
{
IVtkTools_DisplayModeFilter* aFilter = GetPipeline ( anOccShape->GetId() )->GetDisplayModeFilter();
aFilter->SetDisplayMode((IVtk_DisplayMode)aMode);
aFilter->Modified();
aFilter->Update();
}
}
anIter.Next();
}
}
// Set disp mode for named object
else
{
Standard_Integer aMode = atoi(theArgs[2]);
TCollection_AsciiString aName = theArgs[1];
if (GetMapOfActors().IsBound2 (aName))
{
anActor = GetMapOfActors().Find2 (aName);
vtkSmartPointer<IVtkTools_ShapeDataSource> aSrc = IVtkTools_ShapeObject::GetShapeSource (anActor);
if (aSrc)
{
IVtkOCC_Shape::Handle anOccShape = aSrc->GetShape();
if (!anOccShape.IsNull())
{
IVtkTools_DisplayModeFilter* aFilter = GetPipeline (anOccShape->GetId())->GetDisplayModeFilter();
aFilter->SetDisplayMode ((IVtk_DisplayMode)aMode);
aFilter->Modified();
aFilter->Update();
}
}
}
}
// Redraw window
GetInteractor()->Render();
return 0;
}
//================================================================
// Function : VtkSetSelectionMode
// Purpose :
// Draw args : ivtksetselmode [name] mode on/off(0,1)
//================================================================
static Standard_Integer VtkSetSelectionMode (Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error: call ivtkinit before\n";
return 1; // TCL_ERROR
}
// Check arguments
if (theArgNum != 3 && theArgNum != 4)
{
theDI << theArgs[0] << " error: expects 2 or 3 arguments\n";
return 1; // TCL_ERROR
}
vtkSmartPointer<vtkActor> anActor;
Standard_Integer aMode;
Standard_Boolean isTurnOn;
// Set sel mode for all objects
if (theArgNum == 3)
{
aMode = atoi (theArgs[1]);
isTurnOn = (atoi (theArgs[2]) != 0);
if (aMode < 0 || aMode > 8)
{
theDI << theArgs[0] << " error: only 0-8 selection modes are supported\n";
return 1; // TCL_ERROR
}
DoubleMapOfActorsAndNames::Iterator anIter (GetMapOfActors());
while (anIter.More())
{
anActor = anIter.Key1();
if (aMode == SM_Shape && isTurnOn)
{
IVtk_SelectionModeList aList = GetPicker()->GetSelectionModes (anActor);
IVtk_SelectionModeList::Iterator anIt (aList);
// Turn off all sel modes differed from SM_Shape
while (anIt.More())
{
IVtk_SelectionMode aCurMode = anIt.Value();
if (SM_Shape != aCurMode)
{
GetPicker()->SetSelectionMode (anActor, aCurMode, Standard_False);
}
anIt.Next();
}
GetPicker()->SetSelectionMode (anActor, SM_Shape);
}
if (aMode != SM_Shape)
{
if (isTurnOn)
{
GetPicker()->SetSelectionMode (anActor, (IVtk_SelectionMode)aMode);
GetPicker()->SetSelectionMode (anActor, SM_Shape, Standard_False);
if (aMode == SM_Vertex)
{
GetPipeline( IVtkTools_ShapeObject::GetShapeSource(anActor)->GetShape()->GetId() )->SharedVerticesSelectionOn();
}
}
else
{
GetPicker()->SetSelectionMode (anActor, (IVtk_SelectionMode)aMode, Standard_False);
IVtk_SelectionModeList aList = GetPicker()->GetSelectionModes (anActor);
if (!aList.Size())
{
GetPicker()->SetSelectionMode(anActor, SM_Shape);
}
if (aMode == SM_Vertex)
{
GetPipeline( IVtkTools_ShapeObject::GetShapeSource(anActor)->GetShape()->GetId() )->SharedVerticesSelectionOff();
}
}
}
anIter.Next();
}
}
// Set sel mode for named object
if (theArgNum == 4)
{
aMode = atoi (theArgs[2]);
isTurnOn = (atoi (theArgs[3]) != 0);
if (aMode < 0 || aMode > 8)
{
theDI << theArgs[0] << " error: only 0-8 selection modes are supported\n";
return 1; // TCL_ERROR
}
TCollection_AsciiString aName = theArgs[1];
if (GetMapOfActors().IsBound2 (aName))
{
anActor = GetMapOfActors().Find2 (aName);
if (aMode == SM_Shape && isTurnOn)
{
IVtk_SelectionModeList aList = GetPicker()->GetSelectionModes (anActor);
IVtk_SelectionModeList::Iterator anIt (aList);
// Turn off all sel modes differed from SM_Shape
while (anIt.More())
{
IVtk_SelectionMode aCurMode = anIt.Value();
if (SM_Shape != aCurMode)
{
GetPicker()->SetSelectionMode (anActor, aCurMode, Standard_False);
}
anIt.Next();
}
GetPicker()->SetSelectionMode (anActor, SM_Shape);
}
if (aMode != SM_Shape)
{
if (isTurnOn)
{
GetPicker()->SetSelectionMode (anActor, (IVtk_SelectionMode)aMode);
GetPicker()->SetSelectionMode (anActor, SM_Shape, Standard_False);
if (aMode == SM_Vertex)
{
GetPipeline( IVtkTools_ShapeObject::GetShapeSource(anActor)->GetShape()->GetId() )->SharedVerticesSelectionOn();
}
}
else
{
GetPicker()->SetSelectionMode (anActor, (IVtk_SelectionMode)aMode, Standard_False);
IVtk_SelectionModeList aList = GetPicker()->GetSelectionModes (anActor);
if (!aList.Size())
{
GetPicker()->SetSelectionMode(anActor, SM_Shape);
}
if (aMode == SM_Vertex)
{
GetPipeline( IVtkTools_ShapeObject::GetShapeSource(anActor)->GetShape()->GetId() )->SharedVerticesSelectionOff();
}
}
}
}
}
// Redraw window
GetInteractor()->Render();
return 0;
}
//================================================================
// Function : VtkMoveTo
// Purpose :
// Draw args : ivtkmoveto x y
//================================================================
static Standard_Integer VtkMoveTo(Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error: call ivtkinit before\n";
return 1; // TCL_ERROR
}
// Check args
if (theArgNum != 3)
{
theDI << theArgs[0] << " error: expects 2 arguments\n";
return 1; // TCL_ERROR
}
Standard_Integer anY = GetInteractor()->GetRenderWindow()->GetSize()[1] - atoi (theArgs[2]) - 1;
GetInteractor()->MoveTo (atoi (theArgs[1]), anY);
return 0;
}
//================================================================
// Function : VtkSelect
// Purpose :
// Draw args : ivtkselect x y
//================================================================
static Standard_Integer VtkSelect (Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error: call ivtkinit before\n";
return 1; // TCL_ERROR
}
// Check args
if (theArgNum != 3)
{
theDI << theArgs[0] << " error: expects 3 arguments\n";
return 1; // TCL_ERROR
}
Standard_Integer anY = GetInteractor()->GetRenderWindow()->GetSize()[1] - atoi (theArgs[2]) - 1;
GetInteractor()->MoveTo (atoi (theArgs[1]), anY);
GetInteractor()->OnSelection();
return 0;
}
//===================================================================
// Fubction : VtkFit
// Purpose :
// Draw args : ivtkfit
//===================================================================
static Standard_Integer VtkFit (Draw_Interpretor& theDI,
Standard_Integer,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
theDI << theArgs[0] << " error : call ivtkinit before \n";
return 1; //TCL_ERROR
}
GetRenderer()->ResetCamera();
GetInteractor()->Render();
return 0;
}
//===================================================================
// Fubction : VtkDump
// Purpose :
// Draw args : ivtkdump FullFilename.{png|bmp|jpeg|tiff|pnm}
// [buffer={rgb|rgba|depth}] [width height]
// [stereoproj={L|R}]
//===================================================================
static Standard_Integer VtkDump (Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
// Check viewer
if (!GetInteractor()->IsEnabled())
{
std::cout << theArgs[0] << " error : call ivtkinit before \n";
return 1;
}
if (theArgNum < 2)
{
theDI << theArgs[0] << " error : wrong number of parameters. Type 'help"
<< theArgs[0] << "' for more information.\n";
}
vtkSmartPointer<vtkWindowToImageFilter> anImageFilter = vtkSmartPointer<vtkWindowToImageFilter>::New();
anImageFilter->SetInput (GetInteractor()->GetRenderWindow());
// Set custom buffer type
if (theArgNum > 2)
{
TCollection_AsciiString aBufferType (theArgs[2]);
aBufferType.LowerCase();
if (aBufferType.IsEqual ("rgb"))
{
anImageFilter->SetInputBufferTypeToRGB();
}
else if (aBufferType.IsEqual ("rgba"))
{
anImageFilter->SetInputBufferTypeToRGBA();
}
else if (aBufferType.IsEqual ("depth"))
{
anImageFilter->SetInputBufferTypeToZBuffer();
}
}
anImageFilter->Update();
// Set custom stereo projection options
if (theArgNum > 5 && GetRenderer()->GetRenderWindow()->GetStereoRender())
{
Standard_CString aStereoProjStr = theArgs[5];
Standard_Integer aStereoType = GetRenderer()->GetRenderWindow()->GetStereoType();
if (strcasecmp (aStereoProjStr, "L"))
{
GetRenderer()->GetRenderWindow()->SetStereoTypeToLeft();
GetRenderer()->GetRenderWindow()->StereoUpdate();
anImageFilter->Update();
GetRenderer()->GetRenderWindow()->SetStereoType (aStereoType);
}
else if (strcasecmp (aStereoProjStr, "R"))
{
GetRenderer()->GetRenderWindow()->SetStereoTypeToRight();
GetRenderer()->GetRenderWindow()->StereoUpdate();
anImageFilter->Update();
GetRenderer()->GetRenderWindow()->SetStereoType (aStereoType);
}
else
{
theDI << theArgs[0] << " error: unknown value for stereo projection.\n";
return 1;
}
}
// Set parameters for image writer
vtkSmartPointer<vtkImageWriter> anImageWriter;
TCollection_AsciiString aFilename (theArgs[1]);
Standard_Integer anExtStart = aFilename.SearchFromEnd (TCollection_AsciiString("."));
TCollection_AsciiString aFormat = (anExtStart == -1) ? TCollection_AsciiString("")
: aFilename.SubString (anExtStart + 1, aFilename.Length());
aFormat.LowerCase();
if (aFormat.IsEqual ("png"))
{
anImageWriter = vtkSmartPointer<vtkPNGWriter>::New();
}
else if (aFormat.IsEqual ("bmp"))
{
anImageWriter = vtkSmartPointer<vtkBMPWriter>::New();
}
else if (aFormat.IsEqual ("jpeg"))
{
anImageWriter = vtkSmartPointer<vtkJPEGWriter>::New();
}
else if (aFormat.IsEqual ("tiff"))
{
anImageWriter = vtkSmartPointer<vtkTIFFWriter>::New();
}
else if (aFormat.IsEqual ("pnm"))
{
anImageWriter = vtkSmartPointer<vtkPNMWriter>::New();
}
else // aFormat is unsupported or not set.
{
if (aFormat.IsEmpty())
{
theDI << theArgs[0] << " warning: the image format is not set.\n"
<< "The image will be saved into PNG format.\n";
anImageWriter = vtkSmartPointer<vtkPNGWriter>::New();
aFormat = TCollection_AsciiString ("png");
if (anExtStart != -1)
{
aFilename.Split (anExtStart);
}
else
{
aFilename += ".";
}
aFilename += aFormat;
}
else
{
theDI << theArgs[0] << " error: the image format "
<< aFormat.ToCString() <<" is not supported.\n";
return 1;
}
}
anImageWriter->SetFileName (aFilename.ToCString());
Standard_Integer aWidth = (theArgNum > 3) ? atoi (theArgs[3]) : 0;
Standard_Integer aHeight = (theArgNum > 4) ? atoi (theArgs[4]) : 0;
if (aWidth >= 0 || aHeight >= 0)
{
// Scale image
vtkSmartPointer<vtkImageResize> anImageResize = vtkSmartPointer<vtkImageResize>::New();
#if VTK_MAJOR_VERSION <= 5
anImageResize->SetInput (anImageFilter->GetOutput());
#else
anImageResize->SetInputData (anImageFilter->GetOutput());
#endif
anImageResize->SetOutputDimensions (aWidth, aHeight, 1);
anImageResize->Update();
anImageWriter->SetInputConnection (anImageResize->GetOutputPort());
}
else
{
anImageWriter->SetInputConnection (anImageFilter->GetOutputPort());
}
anImageWriter->Write();
return 0;
}
//===================================================================
// Fubction : VtkBackgroundColor
// Purpose :
// Draw args : ivtkbgcolor r g b
// r,g,b = [0..255]
//===================================================================
static Standard_Integer VtkBackgroundColor (Draw_Interpretor& theDI,
Standard_Integer theArgNum,
const char** theArgs)
{
if (theArgNum != 4 && theArgNum != 7)
{
theDI << theArgs[0] << " error : wrong number of parameters.\n"
<< "Type 'help " << theArgs[0] << "' for more information.\n";
return 1;
}
// Check viewer
if (!GetInteractor()->IsEnabled())
{
std::cout << theArgs[0] << " error : call ivtkinit before \n";
return 1;
}
Standard_Real aR = Draw::Atof(theArgs[1])/255.0;
Standard_Real aG = Draw::Atof(theArgs[2])/255.0;
Standard_Real aB = Draw::Atof(theArgs[3])/255.0;
GetRenderer()->SetGradientBackground(false);
GetRenderer()->SetBackground (aR, aG, aB);
if (theArgNum == 7)
{
Standard_Real aR2 = Draw::Atof(theArgs[4])/255.0;
Standard_Real aG2 = Draw::Atof(theArgs[5])/255.0;
Standard_Real aB2 = Draw::Atof(theArgs[6])/255.0;
GetRenderer()->SetBackground2(aR2, aG2, aB2);
GetRenderer()->SetGradientBackground(true);
}
GetInteractor()->Render();
return 0;
}
//================================================================
// Function : Commands
// Purpose :
//================================================================
void IVtkDraw::Commands (Draw_Interpretor& theCommands)
{
const char *group = "VtkViewer";
theCommands.Add("ivtkinit",
"ivtkinit usage:\n"
"ivtkinit [leftPx topPx widthPx heightPx]"
"\n\t\t: Creates the Vtk window",
__FILE__, VtkInit, group);
theCommands.Add("ivtkdisplay",
"ivtkdisplay usage:\n"
"ivtkdisplay name1 name2 ..."
"\n\t\t: Displayes named objects in current view.",
__FILE__, VtkDisplay, group);
theCommands.Add("ivtkerase",
"ivtkerase usage:\n"
"ivtkerase [name1 name2 ...]"
"\n\t\t: Removes from renderer named objects or all objects.",
__FILE__, VtkErase, group);
theCommands.Add("ivtkremove",
"ivtkremove usage:\n"
"ivtkremove [name1 name2 ...]"
"\n\t\t: Removes from renderer and from memory named objects or all objects.",
__FILE__, VtkRemove, group);
theCommands.Add("ivtksetdispmode",
"ivtksetdispmode usage:\n"
"ivtksetdispmode [name] mode (0,1)"
"\n\t\t: Sets or unsets display mode 'mode' to the object with name 'name' or to all objects"
"if name is not defined.",
__FILE__, VtkSetDisplayMode, group);
theCommands.Add("ivtksetselmode",
"ivtksetselmode usage:\n"
" ivtksetselmode [name] mode on/off(0,1)"
"\n\t\t: Sets or unsets selection mode 'mode' to the object with name 'name' or to the all displayed objects.",
__FILE__, VtkSetSelectionMode, group);
theCommands.Add("ivtkmoveto",
"ivtkmoveto usage:\n"
"ivtkmoveto x y"
"\n\t\t: Moves position to the pixel with coordinates (x,y). The object on this position is highlighted.",
__FILE__, VtkMoveTo, group);
theCommands.Add("ivtkselect",
"ivtkselect usage:\n"
"ivtkselect x y"
"\n\t\t: Selects object which correspond to the pixel with input coordinates (x,y).",
__FILE__, VtkSelect, group);
theCommands.Add("ivtkfit",
"ivtkfit usage:\n"
"ivtkfit"
"\n\t\t: Fits view according all displayed objects.",
__FILE__, VtkFit, group);
theCommands.Add("ivtkdump",
"ivtkdump usage:\n"
"ivtkdump <FullFilename>.{png|bmp|jpeg|tiff|pnm} [buffer={rgb|rgba|depth}] [width height] [stereoproj={L|R}]"
"\n\t\t: Dumps contents of viewer window to PNG, BMP, JPEG, TIFF or PNM file",
__FILE__, VtkDump, group);
theCommands.Add("ivtkbgcolor",
"ivtkbgcolor usage:\n"
"ivtkbgcolor r g b [r2 g2 b2]\n"
"\n\t\t: Sets uniform background color or gradient one if second triple of paramers is set."
"Color parameters r,g,b = [0..255].",
__FILE__, VtkBackgroundColor, group);
}
//================================================================
// Function : Factory
// Purpose :
//================================================================
void IVtkDraw::Factory (Draw_Interpretor& theDI)
{
// definition of Viewer Commands
IVtkDraw::Commands (theDI);
}
// Declare entry point PLUGINFACTORY
DPLUGIN(IVtkDraw)
View Git Blame Copy Permalink