OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-05-11 10:44:53 +03:00
Code
occt/src/IVtkDraw/IVtkDraw.cxx
luz paz 0177fe2617 0031939: Coding - correction of spelling errors in comments [part 4] 
Fix various typos

Fixed via `codespell v2.1.dev
2020-12-17 21:17:43 +03:00

1633 lines
50 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 _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 <V3d.hxx>
#include <V3d_TypeOfOrientation.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>
// prevent disabling some MSVC warning messages by VTK headers
#include <Standard_WarningsDisable.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 <X11/Xutil.h>
#include <GL/glx.h>
#include <Xw_Window.hxx>
#include <vtkXRenderWindowInteractor.h>
#include <vtkXOpenGLRenderWindow.h>
#include <tk.h>
#endif
#include <Standard_WarningsRestore.hxx>
#if (VTK_MAJOR_VERSION > 8) || (VTK_MAJOR_VERSION == 8 && VTK_MINOR_VERSION >= 1)
#define HAVE_VTK_SRGB
#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(WNT_WClass)& IVtkDraw::WClass()
{
static Handle(WNT_WClass) aWindowClass;
#ifdef _WIN32
if (aWindowClass.IsNull())
{
aWindowClass = new WNT_WClass ("GWVTK_Class", NULL,
CS_VREDRAW | CS_HREDRAW, 0, 0,
::LoadCursorW (NULL, IDC_ARROW));
}
#endif
return aWindowClass;
}
//==============================================================
// Function : ViewerInit
// Purpose :
//==============================================================
void IVtkDraw::ViewerInit (const IVtkWinParams& theParams)
{
Standard_Integer aPxLeft = 0, aPxTop = 460;
Standard_Integer aPxWidth = 409, aPxHeight = 409;
if (theParams.TopLeft.x() != 0)
{
aPxLeft = theParams.TopLeft.x();
}
if (theParams.TopLeft.y() != 0)
{
aPxTop = theParams.TopLeft.y();
}
if (theParams.Size.x() != 0)
{
aPxWidth = theParams.Size.x();
}
if (theParams.Size.y() != 0)
{
aPxHeight = theParams.Size.y();
}
if (!GetRenderer())
{
SetDisplayConnection (new Aspect_DisplayConnection ());
#ifdef _WIN32
if (GetWindow().IsNull())
{
GetWindow() = new WNT_Window ("IVtkTest", 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);
aRenWin->SetMultiSamples (theParams.NbMsaaSample);
aRenWin->SetAlphaBitPlanes (1);
#ifdef HAVE_VTK_SRGB
aRenWin->SetUseSRGBColorSpace (theParams.UseSRGBColorSpace);
#else
if (theParams.UseSRGBColorSpace)
{
Message::SendWarning() << "Warning: skipped option -srgb unsupported by old VTK";
}
#endif
#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();
}
GetWindow()->Map();
}
//================================================================
// Function : VtkInit
// Purpose :
//================================================================
static Standard_Integer VtkInit (Draw_Interpretor& ,
Standard_Integer theNbArgs,
const char** theArgVec)
{
bool hasSize = false;
IVtkDraw::IVtkWinParams aParams;
for (Standard_Integer anArgIter = 1; anArgIter < theNbArgs; ++anArgIter)
{
TCollection_AsciiString anArg (theArgVec[anArgIter]);
anArg.LowerCase();
if (anArg == "-msaa"
&& anArgIter + 1 < theNbArgs)
{
aParams.NbMsaaSample = Draw::Atoi (theArgVec[++anArgIter]);
}
else if (anArg == "-srgb")
{
aParams.UseSRGBColorSpace = true;
if (anArgIter + 1 < theNbArgs
&& Draw::ParseOnOff (theArgVec[anArgIter + 1], aParams.UseSRGBColorSpace))
{
++anArgIter;
}
}
else if (!hasSize
&& anArgIter + 3 < theNbArgs)
{
aParams.TopLeft.SetValues (Draw::Atoi (theArgVec[anArgIter + 0]),
Draw::Atoi (theArgVec[anArgIter + 1]));
aParams.Size .SetValues (Draw::Atoi (theArgVec[anArgIter + 2]),
Draw::Atoi (theArgVec[anArgIter + 3]));
}
else
{
Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
IVtkDraw::ViewerInit (aParams);
return 0;
}
//================================================================
// Function : VtkClose
// Purpose :
//================================================================
static Standard_Integer VtkClose (Draw_Interpretor& ,
Standard_Integer theNbArgs,
const char** )
{
if (theNbArgs > 1)
{
Message::SendFail() << "Syntax error: wrong number of arguments";
return 1;
}
if (GetWindow())
{
GetWindow()->Unmap();
}
GetWindow().Nullify();
if (GetInteractor())
{
GetInteractor()->GetRenderWindow()->Finalize();
//GetInteractor()->SetRenderWindow (NULL);
GetInteractor()->TerminateApp();
}
GetInteractor() = NULL;
GetRenderer() = NULL;
GetPicker() = NULL;
return 0;
}
//================================================================
// Function : VtkRenderParams
// Purpose :
//================================================================
static Standard_Integer VtkRenderParams (Draw_Interpretor& ,
Standard_Integer theNbArgs,
const char** theArgVec)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Syntax error: call ivtkinit before";
return 1;
}
else if (theNbArgs <= 1)
{
Message::SendFail() << "Syntax error: wrong number of arguments";
return 1;
}
for (Standard_Integer anArgIter = 1; anArgIter < theNbArgs; ++anArgIter)
{
TCollection_AsciiString anArg (theArgVec[anArgIter]);
anArg.LowerCase();
if (anArg == "-depthpeeling"
&& anArgIter + 1 < theNbArgs)
{
Standard_Integer aNbLayers = Draw::Atoi (theArgVec[++anArgIter]);
GetRenderer()->SetUseDepthPeeling (aNbLayers > 0);
GetRenderer()->SetMaximumNumberOfPeels (aNbLayers);
}
else if (anArg == "-shadows")
{
bool toUseShadows = true;
if (anArgIter + 1 < theNbArgs
&& Draw::ParseOnOff (theArgVec[anArgIter + 1], toUseShadows))
{
++anArgIter;
}
#if (VTK_MAJOR_VERSION >= 7)
GetRenderer()->SetUseShadows (toUseShadows);
#else
Message::SendWarning() << "Warning: skipped option -shadows unsupported by old VTK";
#endif
}
else
{
Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
GetInteractor()->GetRenderWindow()->Render();
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& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error : call ivtkinit before";
return 1;
}
if (theArgNum < 2)
{
Message::SendFail() << "Error : expects at least 1 argument\n";
return 1;
}
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& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
vtkSmartPointer<vtkRenderer> aRenderer = GetRenderer();
if (theArgNum == 1)
{
// Erase all objects
DoubleMapOfActorsAndNames::Iterator anIterator (GetMapOfActors());
while (anIterator.More())
{
PipelineByActor (anIterator.Key1())->RemoveFromRenderer (aRenderer);
anIterator.Next();
}
}
else
{
// Erase named objects
for (Standard_Integer anIndex = 1; anIndex < theArgNum; ++anIndex)
{
TCollection_AsciiString aName = theArgs[anIndex];
vtkSmartPointer<vtkActor> anActor;
if (!GetMapOfActors().Find2 (aName, anActor))
{
Message::SendFail() << "Syntax error: object '" << aName << "' not found";
return 1;
}
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& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
vtkSmartPointer<vtkRenderer> aRenderer = GetRenderer();
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();
}
else
{
// Remove named objects
for (Standard_Integer anIndex = 1; anIndex < theArgNum; ++anIndex)
{
TCollection_AsciiString aName = theArgs[anIndex];
vtkSmartPointer<vtkActor> anActor;
if (!GetMapOfActors().Find2 (aName, anActor))
{
Message::SendFail() << "Syntax error: object '" << aName << "' not found";
return 1;
}
// Remove the actor and its pipeline (if found) from the renderer
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 pipeline
}
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& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
else if (theArgNum != 2 && theArgNum != 3)
{
Message::SendFail() << "Syntax error: expects 1 or 2 arguments";
return 1;
}
if (theArgNum == 2)
{
// Set disp mode for all objects
Standard_Integer aMode = Draw::Atoi (theArgs[1]); // Get mode
DoubleMapOfActorsAndNames::Iterator anIter (GetMapOfActors());
while (anIter.More())
{
vtkSmartPointer<vtkActor> 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
{
TCollection_AsciiString aName = theArgs[1];
vtkSmartPointer<vtkActor> anActor;
if (!GetMapOfActors().Find2 (aName, anActor))
{
Message::SendFail() << "Syntax error: object '" << aName << "' not found";
return 1;
}
Standard_Integer aMode = atoi(theArgs[2]);
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 : VtkSetBoundaryDraw
// Purpose :
//================================================================
static Standard_Integer VtkSetBoundaryDraw (Draw_Interpretor& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
else if (theArgNum != 2 && theArgNum != 3)
{
Message::SendFail() << "Syntax error: expects 1 or 2 arguments";
return 1;
}
if (theArgNum == 2)
{
// Set disp mode for all objects
Standard_Boolean toDraw = true;
Draw::ParseOnOff (theArgs[1], toDraw);
DoubleMapOfActorsAndNames::Iterator anIter(GetMapOfActors());
while (anIter.More())
{
vtkSmartPointer<vtkActor> anActor = anIter.Key1();
// Set Red color for boundary edges
vtkLookupTable* aTable = (vtkLookupTable*)anActor->GetMapper()->GetLookupTable();
IVtkTools::SetLookupTableColor(aTable, MT_SharedEdge, 1., 0., 0., 1.);
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(DM_Shading);
aFilter->SetFaceBoundaryDraw(toDraw != 0);
aFilter->Modified();
aFilter->Update();
}
}
anIter.Next();
}
}
else
{
// Set disp mode for named object
TCollection_AsciiString aName = theArgs[1];
vtkSmartPointer<vtkActor> anActor;
if (!GetMapOfActors().Find2 (aName, anActor))
{
Message::SendFail() << "Syntax error: object '" << aName << "' not found";
return 1;
}
Standard_Boolean toDraw = true;
Draw::ParseOnOff (theArgs[2], toDraw);
// Set Red color for boundary edges
vtkLookupTable* aTable = (vtkLookupTable*)anActor->GetMapper()->GetLookupTable();
IVtkTools::SetLookupTableColor (aTable, MT_SharedEdge, 1., 0., 0., 1.);
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 (DM_Shading);
aFilter->SetFaceBoundaryDraw (toDraw != 0);
aFilter->Modified();
aFilter->Update();
}
}
}
// Redraw window
GetInteractor()->Render();
return 0;
}
//================================================================
// Function : VtkSetSelectionMode
// Purpose :
//================================================================
static Standard_Integer VtkSetSelectionMode (Draw_Interpretor& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
else if (theArgNum != 3 && theArgNum != 4)
{
Message::SendFail() << "Syntax error: expects 2 or 3 arguments";
return 1;
}
if (theArgNum == 3)
{
// Set sel mode for all objects
const Standard_Integer aMode = Draw::Atoi (theArgs[1]);
Standard_Boolean isTurnOn = true;
if (aMode < 0 || aMode > 8 || !Draw::ParseOnOff (theArgs[2], isTurnOn))
{
Message::SendFail() << "Syntax error: only 0-8 selection modes are supported";
return 1;
}
DoubleMapOfActorsAndNames::Iterator anIter (GetMapOfActors());
while (anIter.More())
{
vtkSmartPointer<vtkActor> 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();
}
}
if (theArgNum == 4)
{
// Set sel mode for named object
const Standard_Integer aMode = Draw::Atoi (theArgs[2]);
Standard_Boolean isTurnOn = true;
if (aMode < 0 || aMode > 8 || !Draw::ParseOnOff (theArgs[3], isTurnOn))
{
Message::SendFail() << "Syntax error: only 0-8 selection modes are supported";
return 1;
}
TCollection_AsciiString aName = theArgs[1];
if (GetMapOfActors().IsBound2 (aName))
{
vtkSmartPointer<vtkActor> 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 : VtkSetColor
// Purpose :
//================================================================
static Standard_Integer VtkSetColor (Draw_Interpretor& ,
Standard_Integer theArgNb,
const char** theArgVec)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before\n";
return 1;
}
NCollection_Sequence< vtkSmartPointer<vtkActor> > anActorSeq;
Quantity_Color aQColor;
bool hasColor = false;
for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
TCollection_AsciiString anArg (theArgVec[anArgIter]);
vtkSmartPointer<vtkActor> anActor;
if (hasColor)
{
Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
else if (GetMapOfActors().Find2 (anArg, anActor))
{
anActorSeq.Append (anActor);
}
else
{
Standard_Integer aNbParsed = Draw::ParseColor (theArgNb - anArgIter,
theArgVec + anArgIter,
aQColor);
if (aNbParsed == 0)
{
Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
anArgIter += aNbParsed - 1;
hasColor = true;
}
}
if (!hasColor || anActorSeq.IsEmpty())
{
Message::SendFail() << "Syntax error: wrong number of arguments";
return 1;
}
bool isSRGBAware = false;
#ifdef HAVE_VTK_SRGB
isSRGBAware = GetRenderer()->GetRenderWindow()->GetUseSRGBColorSpace();
#endif
const Graphic3d_Vec3 aColor = isSRGBAware ? (Graphic3d_Vec3 )aQColor : Quantity_Color::Convert_LinearRGB_To_sRGB ((Graphic3d_Vec3 )aQColor);
for (NCollection_Sequence< vtkSmartPointer<vtkActor> >::Iterator anActorIter (anActorSeq); anActorIter.More(); anActorIter.Next())
{
const vtkSmartPointer<vtkActor>& anActor = anActorIter.Value();
vtkLookupTable* aTable = (vtkLookupTable* )anActor->GetMapper()->GetLookupTable();
IVtkTools::SetLookupTableColor (aTable, MT_ShadedFace, aColor.r(), aColor.g(), aColor.b(), 1.0);
}
GetInteractor()->Render();
return 0;
}
//================================================================
// Function : VtkSetTransparency
// Purpose :
//================================================================
static Standard_Integer VtkSetTransparency (Draw_Interpretor& ,
Standard_Integer theArgNb,
const char** theArgVec)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before\n";
return 1;
}
NCollection_Sequence< vtkSmartPointer<vtkActor> > anActorSeq;
Standard_Real aTransparency = -1.0;
for (Standard_Integer anArgIter = 1; anArgIter < theArgNb; ++anArgIter)
{
TCollection_AsciiString anArg (theArgVec[anArgIter]);
vtkSmartPointer<vtkActor> anActor;
if (aTransparency >= 0.0)
{
Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
else if (GetMapOfActors().Find2 (anArg, anActor))
{
anActorSeq.Append (anActor);
}
else if (!Draw::ParseReal (theArgVec[anArgIter], aTransparency)
|| aTransparency < 0.0
|| aTransparency >= 1.0)
{
Message::SendFail() << "Syntax error at '" << anArg << "'";
return 1;
}
}
if (aTransparency < 0.0 || aTransparency >= 1)
{
Message::SendFail() << "Syntax error: wrong number of arguments";
return 1;
}
for (NCollection_Sequence< vtkSmartPointer<vtkActor> >::Iterator anActorIter (anActorSeq); anActorIter.More(); anActorIter.Next())
{
const vtkSmartPointer<vtkActor>& anActor = anActorIter.Value();
anActor->GetProperty()->SetOpacity (1.0 - aTransparency);
}
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)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
else if (theArgNum != 3)
{
Message::SendFail() << "Syntax error: expects 2 arguments";
return 1;
}
Standard_Integer anY = GetInteractor()->GetRenderWindow()->GetSize()[1] - atoi (theArgs[2]) - 1;
GetInteractor()->MoveTo (atoi (theArgs[1]), anY);
gp_XYZ aPickPnt;
GetInteractor()->Selector()->GetPickPosition (aPickPnt.ChangeData());
theDI << aPickPnt.X() << " " << aPickPnt.Y() << " " << aPickPnt.Z();
return 0;
}
//================================================================
// Function : VtkSelect
// Purpose :
//================================================================
static Standard_Integer VtkSelect (Draw_Interpretor& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
else if (theArgNum != 3)
{
Message::SendFail() << "Syntax error: expects 3 arguments";
return 1;
}
Standard_Integer anY = GetInteractor()->GetRenderWindow()->GetSize()[1] - atoi (theArgs[2]) - 1;
GetInteractor()->MoveTo (atoi (theArgs[1]), anY);
GetInteractor()->OnSelection();
return 0;
}
//===================================================================
// Fubction : VtkViewProj
// Purpose :
//===================================================================
static Standard_Integer VtkViewProj (Draw_Interpretor& ,
Standard_Integer theNbArgs,
const char** theArgVec)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
else if (theNbArgs != 1)
{
Message::SendFail() << "Syntax error: wrong number of arguments";
return 1;
}
TCollection_AsciiString aCmd (theArgVec[0]);
aCmd.LowerCase();
V3d_TypeOfOrientation aProj = V3d_Xpos;
bool hasProjDir = false;
if (aCmd == "ivtkaxo")
{
hasProjDir = true;
aProj = V3d_TypeOfOrientation_Zup_AxoRight;
}
else if (aCmd == "ivtktop")
{
hasProjDir = true;
aProj = V3d_TypeOfOrientation_Zup_Top;
}
else if (aCmd == "ivtkbottom")
{
hasProjDir = true;
aProj = V3d_TypeOfOrientation_Zup_Bottom;
}
else if (aCmd == "ivtkfront")
{
hasProjDir = true;
aProj = V3d_TypeOfOrientation_Zup_Front;
}
else if (aCmd == "ivtkback")
{
hasProjDir = true;
aProj = V3d_TypeOfOrientation_Zup_Back;
}
else if (aCmd == "ivtkleft")
{
hasProjDir = true;
aProj = V3d_TypeOfOrientation_Zup_Left;
}
else if (aCmd == "ivtkright")
{
hasProjDir = true;
aProj = V3d_TypeOfOrientation_Zup_Right;
}
if (hasProjDir)
{
const gp_Dir aBck = V3d::GetProjAxis (aProj);
Graphic3d_Vec3d anUp (0.0, 0.0, 1.0);
if (aProj == V3d_Zpos)
{
anUp.SetValues (0.0, 1.0, 0.0);
}
else if (aProj == V3d_Zneg)
{
anUp.SetValues (0.0, -1.0, 0.0);
}
vtkCamera* aCam = GetRenderer()->GetActiveCamera();
const double aDist = aCam->GetDistance();
Graphic3d_Vec3d aNewEye = Graphic3d_Vec3d (aBck.X(), aBck.Y(), aBck.Z()) * aDist;
aCam->SetPosition (aNewEye.x(), aNewEye.y(), aNewEye.z());
aCam->SetFocalPoint (0.0, 0.0, 0.0);
aCam->SetViewUp (anUp.x(), anUp.y(), anUp.z());
aCam->OrthogonalizeViewUp();
}
GetRenderer()->ResetCamera();
GetInteractor()->Render();
return 0;
}
//===================================================================
// Fubction : VtkDump
// Purpose :
//===================================================================
static Standard_Integer VtkDump (Draw_Interpretor& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error : call ivtkinit before";
return 1;
}
else if (theArgNum < 2)
{
Message::SendFail() << "Syntax error: wrong number of parameters";
return 1;
}
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
{
Message::SendFail() << "Syntax error: unknown value for stereo projection";
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())
{
Message::SendWarning() << "Warning: the image format is not set.\n"
<< "The image will be saved into PNG format.";
anImageWriter = vtkSmartPointer<vtkPNGWriter>::New();
aFormat = TCollection_AsciiString ("png");
if (anExtStart != -1)
{
aFilename.Split (anExtStart);
}
else
{
aFilename += ".";
}
aFilename += aFormat;
}
else
{
Message::SendFail() << "Error: the image format " << aFormat << " is not supported";
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 :
//===================================================================
static Standard_Integer VtkBackgroundColor (Draw_Interpretor& ,
Standard_Integer theArgNum,
const char** theArgs)
{
if (!GetInteractor()
|| !GetInteractor()->IsEnabled())
{
Message::SendFail() << "Error: call ivtkinit before";
return 1;
}
Quantity_Color aQColor1;
const Standard_Integer aNbParsed1 = Draw::ParseColor (theArgNum - 1, theArgs + 1, aQColor1);
if (aNbParsed1 == 0)
{
Message::SendFail() << "Syntax error: wrong number of parameters";
return 1;
}
bool isSRGBAware = false;
#ifdef HAVE_VTK_SRGB
isSRGBAware = GetRenderer()->GetRenderWindow()->GetUseSRGBColorSpace();
#endif
const Graphic3d_Vec3 aColor1 = isSRGBAware ? (Graphic3d_Vec3 )aQColor1 : Quantity_Color::Convert_LinearRGB_To_sRGB ((Graphic3d_Vec3 )aQColor1);
GetRenderer()->SetGradientBackground(false);
GetRenderer()->SetBackground (aColor1.r(), aColor1.g(), aColor1.b());
if (theArgNum - 1 > aNbParsed1)
{
Quantity_Color aQColor2;
const Standard_Integer aNbParsed2 = Draw::ParseColor (theArgNum - 1 - aNbParsed1, theArgs + 1 + aNbParsed1, aQColor2);
if (aNbParsed2 == 0)
{
Message::SendFail() << "Syntax error: wrong number of parameters";
return 1;
}
const Graphic3d_Vec3 aColor2 = isSRGBAware ? (Graphic3d_Vec3 )aQColor2 : Quantity_Color::Convert_LinearRGB_To_sRGB ((Graphic3d_Vec3 )aQColor2);
GetRenderer()->SetBackground2 (aColor2.r(), aColor2.g(), aColor2.b());
GetRenderer()->SetGradientBackground (true);
}
GetInteractor()->Render();
return 0;
}
//================================================================
// Function : Commands
// Purpose :
//================================================================
void IVtkDraw::Commands (Draw_Interpretor& theCommands)
{
const char *group = "VtkViewer";
theCommands.Add("ivtkinit",
"ivtkinit [leftPx topPx widthPx heightPx] [-srgb {on|off}] [-msaa NbSamples]"
"\n\t\t: Creates the Vtk window."
"\n\t\t: -srgb Enable/disable sRGB colorspace; OFF by default."
"\n\t\t: -msaa Requests desired number of samples for multisampling buffer;"
"\n\t\t: 0 by default meaning no MSAA.",
__FILE__, VtkInit, group);
theCommands.Add("ivtkclose",
"ivtkclose : Closes the Vtk window.",
__FILE__, VtkClose, group);
theCommands.Add("ivtkrenderparams",
"ivtkrenderparams [-depthPeeling NbLayers] [-shadows {on|off}]"
"\n\t\t: Sets Vtk rendering parameters."
"\n\t\t: -shadows Turn shadows on/off; OFF by default."
"\n\t\t: -depthPeeling Enable/disable depth peeling for rendering transparent objects"
"\n\t\t: with specified number of layers;"
"\n\t\t: 0 by default meaning order-dependent transparency without depth peeling.",
__FILE__, VtkRenderParams, group);
theCommands.Add("ivtkdisplay",
"ivtkdisplay name1 [name2 ...]"
"\n\t\t: Displays named objects in Vtk view.",
__FILE__, VtkDisplay, group);
theCommands.Add("ivtkerase",
"ivtkerase [name1 name2 ...]"
"\n\t\t: Hides in Vtk renderer named objects or all objects.",
__FILE__, VtkErase, group);
theCommands.Add("ivtkremove",
"ivtkremove name1 [name2 ...]"
"\n\t\t: Removes from Vtk renderer named objects.",
__FILE__, VtkRemove, group);
theCommands.Add("ivtkclear",
"ivtkclear : Removes all objects from Vtk renderer.",
__FILE__, VtkRemove, group);
theCommands.Add("ivtksetdispmode",
"ivtksetdispmode [name] mode={0|1}"
"\n\t\t: Sets or unsets display mode 'mode' to the object with name 'name' or to all objects.",
__FILE__, VtkSetDisplayMode, group);
theCommands.Add("ivtksetboundingdraw",
"ivtksetboundingdraw [name] {on|off}"
"\n\t\t: Sets or unsets boundaries drawing for shading display mode"
"\n\t\t: to the object with name 'name' or to all objects.",
__FILE__, VtkSetBoundaryDraw, group);
theCommands.Add("ivtksetselmode",
"ivtksetselmode [name] mode {on|off}"
"\n\t\t: Sets or unsets selection mode 'mode' to the object with name 'name'"
"\n\t\t: or to the all displayed objects.",
__FILE__, VtkSetSelectionMode, group);
theCommands.Add("ivtkmoveto",
"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 x y"
"\n\t\t: Selects object which correspond to the pixel with input coordinates (x,y).",
__FILE__, VtkSelect, group);
theCommands.Add("ivtkfit",
"ivtkfit : Fits all displayed objects into Vtk view.",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtkaxo",
"ivtkaxo : Resets Vtk view orientation to axo",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtkfront",
"ivtkfront : Resets Vtk view orientation to front",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtkback",
"ivtkback : Resets Vtk view orientation to back",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtktop",
"ivtktop : Resets Vtk view orientation to top",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtkbottom",
"ivtkbottom : Resets Vtk view orientation to bottom",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtkleft",
"ivtkleft : Resets Vtk view orientation to left",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtkright",
"ivtkright : Resets Vtk view orientation to right",
__FILE__, VtkViewProj, group);
theCommands.Add("ivtkdump",
"ivtkdump <FullFilename>.{png|bmp|jpeg|tiff|pnm} [buffer={rgb|rgba|depth}]"
"\n\t\t: [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 Color1 [Color2]"
"\n\t\t: Sets uniform background color or gradient one if second triple of parameters is set.",
__FILE__, VtkBackgroundColor, group);
theCommands.Add("ivtksetcolor",
"ivtksetcolor name {ColorName|R G B}"
"\n\t\t: Sets color to the object with name 'name'.",
__FILE__, VtkSetColor, group);
theCommands.Add("ivtksettransparency",
"ivtksettransparency name 0..1"
"\n\t\t: Sets transparency to the object with name 'name'.",
__FILE__, VtkSetTransparency, 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