From 7eaba88f797da06af91a96b87cdd54ee1c8a5749 Mon Sep 17 00:00:00 2001 From: enk Date: Tue, 17 May 2005 06:49:04 +0000 Subject: [PATCH] PROJECT: POST-PROCESSOR 2005 TASK: T 1.5 4.5.1.Implementation of graduated rules in SALOME VTK viewer --- src/VTKFilter/Makefile.in | 6 +- src/VTKFilter/SALOME_CubeAxesActor2D.cxx | 499 +++++++++++++++++++++++ src/VTKFilter/SALOME_CubeAxesActor2D.h | 97 +++++ 3 files changed, 600 insertions(+), 2 deletions(-) create mode 100644 src/VTKFilter/SALOME_CubeAxesActor2D.cxx create mode 100644 src/VTKFilter/SALOME_CubeAxesActor2D.h diff --git a/src/VTKFilter/Makefile.in b/src/VTKFilter/Makefile.in index e8297f1f8..cfe009bbc 100644 --- a/src/VTKFilter/Makefile.in +++ b/src/VTKFilter/Makefile.in @@ -37,7 +37,8 @@ EXPORT_HEADERS = SALOME_Transform.h \ SALOME_PassThroughFilter.h \ SALOME_ShrinkFilter.h \ SALOME_GeometryFilter.h \ - SALOME_ExtractUnstructuredGrid.h + SALOME_ExtractUnstructuredGrid.h \ + SALOME_CubeAxesActor2D.h \ # Libraries targets @@ -47,7 +48,8 @@ LIB_SRC = SALOME_Transform.cxx \ SALOME_PassThroughFilter.cxx \ SALOME_ShrinkFilter.cxx \ SALOME_GeometryFilter.cxx \ - SALOME_ExtractUnstructuredGrid.cxx + SALOME_ExtractUnstructuredGrid.cxx \ + SALOME_CubeAxesActor2D.cxx \ # Executables targets diff --git a/src/VTKFilter/SALOME_CubeAxesActor2D.cxx b/src/VTKFilter/SALOME_CubeAxesActor2D.cxx new file mode 100644 index 000000000..10a35daf8 --- /dev/null +++ b/src/VTKFilter/SALOME_CubeAxesActor2D.cxx @@ -0,0 +1,499 @@ +// SALOME OBJECT : kernel of SALOME component +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : SALOME_CubeAxesActor2D.cxx +// Author : Eugeny Nikolaev +// Module : SALOME +// $Header$ + +#include "SALOME_CubeAxesActor2D.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +vtkCxxRevisionMacro(SALOME_CubeAxesActor2D, "$Revision$"); +vtkStandardNewMacro(SALOME_CubeAxesActor2D); + +//---------------------------------------------------------------------------- +// Instantiate this object. +SALOME_CubeAxesActor2D::SALOME_CubeAxesActor2D() +{ + this->wireActorXY = vtkActor::New(); + this->wireActorYZ = vtkActor::New(); + this->wireActorXZ = vtkActor::New(); + + this->planeXY = vtkRectilinearGridGeometryFilter::New(); + this->planeYZ = vtkRectilinearGridGeometryFilter::New(); + this->planeXZ = vtkRectilinearGridGeometryFilter::New(); + + this->rgridMapperXY = vtkPolyDataMapper::New(); + this->rgridMapperYZ = vtkPolyDataMapper::New(); + this->rgridMapperXZ = vtkPolyDataMapper::New(); + + this->rgridMapperXY->SetInput(this->planeXY->GetOutput()); + this->rgridMapperYZ->SetInput(this->planeYZ->GetOutput()); + this->rgridMapperXZ->SetInput(this->planeXZ->GetOutput()); + + this->wireActorXY->SetMapper(rgridMapperXY); + this->wireActorYZ->SetMapper(rgridMapperYZ); + this->wireActorXZ->SetMapper(rgridMapperXZ); + + this->wireActorXY->GetProperty()->SetRepresentationToWireframe(); + this->wireActorYZ->GetProperty()->SetRepresentationToWireframe(); + this->wireActorXZ->GetProperty()->SetRepresentationToWireframe(); + + // setting ambient to 1 (if no - incorrect reaction on light) + this->wireActorXY->GetProperty()->SetAmbient(1); + this->wireActorYZ->GetProperty()->SetAmbient(1); + this->wireActorXZ->GetProperty()->SetAmbient(1); + + +} + +//---------------------------------------------------------------------------- +SALOME_CubeAxesActor2D::~SALOME_CubeAxesActor2D() +{ + this->wireActorXY->Delete(); + this->wireActorYZ->Delete(); + this->wireActorXZ->Delete(); + + this->planeXY->Delete(); + this->planeYZ->Delete(); + this->planeXZ->Delete(); + + this->rgridMapperXY->Delete(); + this->rgridMapperYZ->Delete(); + this->rgridMapperXZ->Delete(); +} + +//---------------------------------------------------------------------------- +// Static variable describes connections in cube. +static int Conn[8][3] = {{1,2,4}, {0,3,5}, {3,0,6}, {2,1,7}, + {5,6,0}, {4,7,1}, {7,4,2}, {6,5,3}}; + +//---------------------------------------------------------------------------- +// Project the bounding box and compute edges on the border of the bounding +// cube. Determine which parts of the edges are visible via intersection +// with the boundary of the viewport (minus borders). +int SALOME_CubeAxesActor2D::RenderOverlay(vtkViewport *viewport) +{ + int renderedSomething=0; + + // Initialization + if ( ! this->RenderSomething ) + { + return 0; + } + + //Render the axes + if ( this->XAxisVisibility ) + { + renderedSomething += this->XAxis->RenderOverlay(viewport); + } + if ( this->YAxisVisibility ) + { + renderedSomething += this->YAxis->RenderOverlay(viewport); + } + if ( this->ZAxisVisibility ) + { + renderedSomething += this->ZAxis->RenderOverlay(viewport); + } + + bool RX=false,RY=false; + if (this->XAxisVisibility){ + this->wireActorXY->RenderOverlay(viewport); + this->wireActorXZ->RenderOverlay(viewport); + RX = true; + } + if (this->YAxisVisibility){ + if(!RX) this->wireActorXY->RenderOverlay(viewport); + this->wireActorYZ->RenderOverlay(viewport); + RY = true; + } + if (this->ZAxisVisibility){ + if(!RX) this->wireActorXZ->RenderOverlay(viewport); + if(!RY) this->wireActorYZ->RenderOverlay(viewport); + } + + return renderedSomething; +} + +//---------------------------------------------------------------------------- +// Project the bounding box and compute edges on the border of the bounding +// cube. Determine which parts of the edges are visible via intersection +// with the boundary of the viewport (minus borders). +int SALOME_CubeAxesActor2D::RenderOpaqueGeometry(vtkViewport *viewport) +{ + float bounds[6], slope = 0.0, minSlope, num, den; + float pts[8][3], d2, d2Min, min; + int i, idx = 0; + int xIdx, yIdx = 0, zIdx = 0, zIdx2, renderedSomething=0; + int xAxes = 0, yAxes, zAxes; + + // Initialization + if ( !this->Camera ) + { + vtkErrorMacro(<<"No camera!"); + this->RenderSomething = 0; + return 0; + } + + this->RenderSomething = 1; + + // determine the bounds to use + this->GetBounds(bounds); + + // Build the axes (almost always needed so we don't check mtime) + // Transform all points into display coordinates + this->TransformBounds(viewport, bounds, pts); + + // Find the portion of the bounding box that fits within the viewport, + if ( this->ClipBounds(viewport, pts, bounds) == 0 ) + { + this->RenderSomething = 0; + return 0; + } + + // Take into account the inertia. Process only so often. + if ( this->RenderCount++ == 0 || !(this->RenderCount % this->Inertia) ) + { + // Okay, we have a bounding box, maybe clipped and scaled, that is visible. + // We setup the axes depending on the fly mode. + if ( this->FlyMode == VTK_FLY_CLOSEST_TRIAD ) + { + // Loop over points and find the closest point to the camera + min = VTK_LARGE_FLOAT; + for (i=0; i < 8; i++) + { + if ( pts[i][2] < min ) + { + idx = i; + min = pts[i][2]; + } + } + + // Setup the three axes to be drawn + xAxes = 0; + xIdx = Conn[idx][0]; + yAxes = 1; + yIdx = Conn[idx][1]; + zAxes = 2; + zIdx = idx; + zIdx2 = Conn[idx][2]; + } + else + { + float e1[2], e2[2], e3[2]; + + // Find distance to origin + d2Min = VTK_LARGE_FLOAT; + for (i=0; i < 8; i++) + { + d2 = pts[i][0]*pts[i][0] + pts[i][1]*pts[i][1]; + if ( d2 < d2Min ) + { + d2Min = d2; + idx = i; + } + } + + // find minimum slope point connected to closest point and on + // right side (in projected coordinates). This is the first edge. + minSlope = VTK_LARGE_FLOAT; + for (xIdx=0, i=0; i<3; i++) + { + num = (pts[Conn[idx][i]][1] - pts[idx][1]); + den = (pts[Conn[idx][i]][0] - pts[idx][0]); + if ( den != 0.0 ) + { + slope = num / den; + } + if ( slope < minSlope && den > 0 ) + { + xIdx = Conn[idx][i]; + yIdx = Conn[idx][(i+1)%3]; + zIdx = Conn[idx][(i+2)%3]; + xAxes = i; + minSlope = slope; + } + } + + // find edge (connected to closest point) on opposite side + for ( i=0; i<2; i++) + { + e1[i] = (pts[xIdx][i] - pts[idx][i]); + e2[i] = (pts[yIdx][i] - pts[idx][i]); + e3[i] = (pts[zIdx][i] - pts[idx][i]); + } + vtkMath::Normalize2D(e1); + vtkMath::Normalize2D(e2); + vtkMath::Normalize2D(e3); + + if ( vtkMath::Dot2D(e1,e2) < vtkMath::Dot2D(e1,e3) ) + { + yAxes = (xAxes + 1) % 3; + } + else + { + yIdx = zIdx; + yAxes = (xAxes + 2) % 3; + } + + // Find the final point by determining which global x-y-z axes have not + // been represented, and then determine the point closest to the viewer. + zAxes = (xAxes != 0 && yAxes != 0 ? 0 : + (xAxes != 1 && yAxes != 1 ? 1 : 2)); + if ( pts[Conn[xIdx][zAxes]][2] < pts[Conn[yIdx][zAxes]][2] ) + { + zIdx = xIdx; + zIdx2 = Conn[xIdx][zAxes]; + } + else + { + zIdx = yIdx; + zIdx2 = Conn[yIdx][zAxes]; + } + }//else boundary edges fly mode + this->InertiaAxes[0] = idx; + this->InertiaAxes[1] = xIdx; + this->InertiaAxes[2] = yIdx; + this->InertiaAxes[3] = zIdx; + this->InertiaAxes[4] = zIdx2; + this->InertiaAxes[5] = xAxes; + this->InertiaAxes[6] = yAxes; + this->InertiaAxes[7] = zAxes; + } //inertia + else + { + idx = this->InertiaAxes[0]; + xIdx = this->InertiaAxes[1]; + yIdx = this->InertiaAxes[2]; + zIdx = this->InertiaAxes[3]; + zIdx2 = this->InertiaAxes[4]; + xAxes = this->InertiaAxes[5]; + yAxes = this->InertiaAxes[6]; + zAxes = this->InertiaAxes[7]; + } + + // Setup the axes for plotting + float xCoords[4], yCoords[4], zCoords[4], xRange[2], yRange[2], zRange[2]; + this->AdjustAxes(pts, bounds, idx, xIdx, yIdx, zIdx, zIdx2, + xAxes, yAxes, zAxes, + xCoords, yCoords, zCoords, xRange, yRange, zRange); + + // Upate axes + this->Labels[0] = this->XLabel; + this->Labels[1] = this->YLabel; + this->Labels[2] = this->ZLabel; + + this->XAxis->GetPositionCoordinate()->SetValue(xCoords[0], xCoords[1]); + this->XAxis->GetPosition2Coordinate()->SetValue(xCoords[2], xCoords[3]); + this->XAxis->SetRange(xRange[0], xRange[1]); + this->XAxis->SetTitle(this->Labels[xAxes]); + this->XAxis->SetNumberOfLabels(this->NumberOfLabels); + this->XAxis->SetLabelFormat(this->LabelFormat); + this->XAxis->SetFontFactor(this->FontFactor); + this->XAxis->SetProperty(this->GetProperty()); + + this->YAxis->GetPositionCoordinate()->SetValue(yCoords[2], yCoords[3]); + this->YAxis->GetPosition2Coordinate()->SetValue(yCoords[0], yCoords[1]); + this->YAxis->SetRange(yRange[1], yRange[0]); + this->YAxis->SetTitle(this->Labels[yAxes]); + this->YAxis->SetNumberOfLabels(this->NumberOfLabels); + this->YAxis->SetLabelFormat(this->LabelFormat); + this->YAxis->SetFontFactor(this->FontFactor); + this->YAxis->SetProperty(this->GetProperty()); + + this->ZAxis->GetPositionCoordinate()->SetValue(zCoords[0], zCoords[1]); + this->ZAxis->GetPosition2Coordinate()->SetValue(zCoords[2], zCoords[3]); + this->ZAxis->SetRange(zRange[0], zRange[1]); + this->ZAxis->SetTitle(this->Labels[zAxes]); + this->ZAxis->SetNumberOfLabels(this->NumberOfLabels); + this->ZAxis->SetLabelFormat(this->LabelFormat); + this->ZAxis->SetFontFactor(this->FontFactor); + this->ZAxis->SetProperty(this->GetProperty()); + + + // ENK:: need specify property + + int numOfLabelsX = XAxis->GetNumberOfLabels(); + int numOfLabelsY = YAxis->GetNumberOfLabels(); + int numOfLabelsZ = ZAxis->GetNumberOfLabels(); + + // XCoords coordinates for X grid + vtkFloatArray *XCoords = vtkFloatArray::New(); + for(int i=0;iInsertNextValue(val); + } + // YCoords coordinates for Y grid + vtkFloatArray *YCoords = vtkFloatArray::New(); + for(int i=0;iInsertNextValue(val); + } + // ZCoords coordinates for Z grid + vtkFloatArray *ZCoords = vtkFloatArray::New(); + for(int i=0;iInsertNextValue(val); + } + + vtkRectilinearGrid *rgrid = vtkRectilinearGrid::New(); + rgrid->SetDimensions(numOfLabelsX,numOfLabelsY,numOfLabelsZ); + rgrid->SetXCoordinates(XCoords); + rgrid->SetYCoordinates(YCoords); + rgrid->SetZCoordinates(ZCoords); + + this->planeXY->SetInput(rgrid); + this->planeYZ->SetInput(rgrid); + this->planeXZ->SetInput(rgrid); + + XCoords->Delete(); + YCoords->Delete(); + ZCoords->Delete(); + rgrid->Delete(); + + // ENK:: here must be setting of correct placement of planex + this->planeXY->SetExtent(0,numOfLabelsX, 0,numOfLabelsY, 0,0); + this->planeYZ->SetExtent(0,0, 0,numOfLabelsY, 0,numOfLabelsZ); + this->planeXZ->SetExtent(0,numOfLabelsX, 0,0, 0,numOfLabelsZ); + + float color[3]; + + this->GetProperty()->GetColor(color); + this->wireActorXY->GetProperty()->SetColor(color); + this->wireActorYZ->GetProperty()->SetColor(color); + this->wireActorXZ->GetProperty()->SetColor(color); + + // Rebuid text props + // Perform shallow copy here since each individual axis can be + // accessed through the class API (i.e. each individual axis text prop + // can be changed). Therefore, we can not just assign pointers otherwise + // each individual axis text prop would point to the same text prop. + + if (this->AxisLabelTextProperty && + this->AxisLabelTextProperty->GetMTime() > this->BuildTime) + { + if (this->XAxis->GetLabelTextProperty()) + { + this->XAxis->GetLabelTextProperty()->ShallowCopy( + this->AxisLabelTextProperty); + } + if (this->YAxis->GetLabelTextProperty()) + { + this->YAxis->GetLabelTextProperty()->ShallowCopy( + this->AxisLabelTextProperty); + } + if (this->ZAxis->GetLabelTextProperty()) + { + this->ZAxis->GetLabelTextProperty()->ShallowCopy( + this->AxisLabelTextProperty); + } + } + + if (this->AxisTitleTextProperty && + this->AxisTitleTextProperty->GetMTime() > this->BuildTime) + { + if (this->XAxis->GetLabelTextProperty()) + { + this->XAxis->GetTitleTextProperty()->ShallowCopy( + this->AxisTitleTextProperty); + } + if (this->YAxis->GetLabelTextProperty()) + { + this->YAxis->GetTitleTextProperty()->ShallowCopy( + this->AxisTitleTextProperty); + } + if (this->ZAxis->GetLabelTextProperty()) + { + this->ZAxis->GetTitleTextProperty()->ShallowCopy( + this->AxisTitleTextProperty); + } + } + + this->BuildTime.Modified(); + + //Render the axes + if ( this->XAxisVisibility ) + { + renderedSomething += this->XAxis->RenderOpaqueGeometry(viewport); + } + if ( this->YAxisVisibility ) + { + renderedSomething += this->YAxis->RenderOpaqueGeometry(viewport); + } + if ( this->ZAxisVisibility ) + { + renderedSomething += this->ZAxis->RenderOpaqueGeometry(viewport); + } + + bool RX=false,RY=false; + if (this->XAxisVisibility){ + this->wireActorXY->RenderOpaqueGeometry(viewport); + this->wireActorXZ->RenderOpaqueGeometry(viewport); + RX = true; + } + if (this->YAxisVisibility){ + if(!RX) this->wireActorXY->RenderOpaqueGeometry(viewport); + this->wireActorYZ->RenderOpaqueGeometry(viewport); + RY = true; + } + if (this->ZAxisVisibility){ + if(!RX) this->wireActorXZ->RenderOpaqueGeometry(viewport); + if(!RY) this->wireActorYZ->RenderOpaqueGeometry(viewport); + } + + + return renderedSomething; +} + +//---------------------------------------------------------------------------- +// Release any graphics resources that are being consumed by this actor. +// The parameter window could be used to determine which graphic +// resources to release. +void SALOME_CubeAxesActor2D::ReleaseGraphicsResources(vtkWindow *win) +{ + + this->XAxis->ReleaseGraphicsResources(win); + this->YAxis->ReleaseGraphicsResources(win); + this->ZAxis->ReleaseGraphicsResources(win); + + this->wireActorXY->ReleaseGraphicsResources(win); + this->wireActorYZ->ReleaseGraphicsResources(win); + this->wireActorXZ->ReleaseGraphicsResources(win); + +} diff --git a/src/VTKFilter/SALOME_CubeAxesActor2D.h b/src/VTKFilter/SALOME_CubeAxesActor2D.h new file mode 100644 index 000000000..0f7ef969e --- /dev/null +++ b/src/VTKFilter/SALOME_CubeAxesActor2D.h @@ -0,0 +1,97 @@ +// SALOME OBJECT : kernel of SALOME component +// +// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// +// +// +// File : SALOME_CubeAxesActor2D.h +// Author : Eugeny Nikolaev +// Module : SALOME +// $Header$ + +#ifndef __SALOME_CubeAxesActor2D_h +#define __SALOME_CubeAxesActor2D_h + +#include "vtkCubeAxesActor2D.h" + +class vtkActor; +class vtkAxisActor2D; +class vtkCamera; +class vtkDataSet; +class vtkTextProperty; +class vtkPolyDataMapper; +class vtkRectilinearGridGeometryFilter; + +class VTK_HYBRID_EXPORT SALOME_CubeAxesActor2D : public vtkCubeAxesActor2D +{ +public: + vtkTypeRevisionMacro(SALOME_CubeAxesActor2D,vtkCubeAxesActor2D); + + // Description: + // Instantiate object with bold, italic, and shadow enabled; font family + // set to Arial; and label format "6.3g". The number of labels per axis + // is set to 3. + static SALOME_CubeAxesActor2D *New(); + + // Description: + // Draw the axes as per the vtkProp superclass' API. + int RenderOverlay(vtkViewport*); + int RenderOpaqueGeometry(vtkViewport*); + + // Description: + // Release any graphics resources that are being consumed by this actor. + // The parameter window could be used to determine which graphic + // resources to release. + void ReleaseGraphicsResources(vtkWindow *); + + // Description: + + vtkActor* GetWireActorXY(){return this->wireActorXY;} + vtkActor* GetWireActorYZ(){return this->wireActorYZ;} + vtkActor* GetWireActorXZ(){return this->wireActorXZ;} + +protected: + SALOME_CubeAxesActor2D(); + ~SALOME_CubeAxesActor2D(); + + vtkActor* wireActorXY; + vtkActor* wireActorYZ; + vtkActor* wireActorXZ; + +private: + // hide the superclass' ShallowCopy() from the user and the compiler. + void ShallowCopy(vtkProp *prop) { this->vtkProp::ShallowCopy( prop ); }; + + vtkRectilinearGridGeometryFilter *planeXY; // rectilinear grid XY + vtkPolyDataMapper *rgridMapperXY; + + vtkRectilinearGridGeometryFilter *planeYZ; // rectilinear grid YZ + vtkPolyDataMapper *rgridMapperYZ; + + vtkRectilinearGridGeometryFilter *planeXZ; // rectilinear grid XZ + vtkPolyDataMapper *rgridMapperXZ; + +private: + SALOME_CubeAxesActor2D(const SALOME_CubeAxesActor2D&); // Not implemented. + void operator=(const SALOME_CubeAxesActor2D&); // Not implemented. +}; + + +#endif -- 2.39.2