-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
//
// 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.
+// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
//
#include "VTKViewer_ArcBuilder.h"
-#include <math.h>
+#include <cmath>
#include <float.h>
//VTK includes
#define ANGLE_PRECISION 0.5
//#define _MY_DEBUG_
+#include <limits>
#ifdef _MY_DEBUG_
#include <iostream>
#endif
-
bool CheckAngle(const double compare, const double angle){
if((angle <= compare - ANGLE_PRECISION) || (angle >= compare + ANGLE_PRECISION))
return true;
const double Zv)
{
double D = sqrt (Xv * Xv + Yv * Yv + Zv * Zv);
- if(D != 0) {
+ if(D > std::numeric_limits<double>::min() ) {
coord.SetX(Xv / D);
coord.SetY(Yv / D);
coord.SetZ(Zv / D);
}
+ else {
+ coord.SetX(0);
+ coord.SetY(0);
+ coord.SetZ(0);
+ }
}
/*!
double x = GetXYZ().Y()*Other.GetXYZ().Z() - GetXYZ().Z()*Other.GetXYZ().Y();
double y = GetXYZ().Z()*Other.GetXYZ().X() - GetXYZ().X()*Other.GetXYZ().Z();
double z = GetXYZ().X()*Other.GetXYZ().Y() - GetXYZ().Y()*Other.GetXYZ().X();
- Vec *aRes = new Vec(x,y,z);
- return *aRes;
+ return Vec(x,y,z);
}
/*---------------------Class Plane --------------------------------*/
aInputPnts.push_back(thePnt2);
aInputPnts.push_back(thePnt3);
- vtkUnstructuredGrid* aGrid = BuildGrid(aInputPnts);
+ vtkSmartPointer<vtkUnstructuredGrid> aGrid = BuildGrid(aInputPnts);
+ aGrid->Delete();
bool needRotation = true;
if(anAngle == 0 || anAngle == 180)
needRotation = false;
if(aGrid) {
- vtkUnstructuredGrid* aTransformedGrid;
if(needRotation) {
- aTransformedGrid = TransformGrid(aGrid,aAxis,anAngle);
- aTransformedGrid->Update();
+ aGrid = TransformGrid(aGrid,aAxis,anAngle);
+ aGrid->Delete();
#ifdef _MY_DEBUG_
cout<<"Need Rotation!!!"<<endl;
#endif
}
else {
- aTransformedGrid = aGrid;
#ifdef _MY_DEBUG_
cout<<"Rotation does not need!!!"<<endl;
#endif
}
double coords[3];
- aTransformedGrid->GetPoint(0,coords);
+ aGrid->GetPoint(0,coords);
myPnt1 = Pnt(coords[0],coords[1],coords[2], thePnt1.GetScalarValue());
- aTransformedGrid->GetPoint(1,coords);
+ aGrid->GetPoint(1,coords);
myPnt2 = Pnt(coords[0],coords[1],coords[2], thePnt2.GetScalarValue());
- aTransformedGrid->GetPoint(2,coords);
+ aGrid->GetPoint(2,coords);
myPnt3 = Pnt(coords[0],coords[1],coords[2], thePnt3.GetScalarValue());
- std::vector<double> aScalarValues;
- vtkUnstructuredGrid* anArc = BuildArc(aScalarValues);
- vtkUnstructuredGrid* anTransArc;
+
+ vtkSmartPointer<vtkUnstructuredGrid> anArc = BuildArc(myScalarValues);
+ anArc->Delete();
if(needRotation) {
- anTransArc = TransformGrid(anArc,aAxis,-anAngle);
- anTransArc->Update();
+ anArc = TransformGrid(anArc,aAxis,-anAngle);
+ anArc->Delete();
}
- else
- anTransArc = anArc;
-
- myPoints = anTransArc->GetPoints();
- myScalarValues = aScalarValues;
+ myPoints = anArc->GetPoints();
myStatus = Arc_Done;
}
}
aList.push_back(thePnt2);
aList.push_back(thePnt3);
vtkUnstructuredGrid* aGrid = BuildGrid(aList);
- aGrid->Update();
myPoints = aGrid->GetPoints();
+ aGrid->Delete();
myScalarValues.clear();
myScalarValues.push_back(thePnt1.GetScalarValue());
aTransform->RotateWXYZ(angle, theAxis.GetXYZ().X(), theAxis.GetXYZ().Y(), theAxis.GetXYZ().Z());
vtkTransformFilter* aTransformFilter = vtkTransformFilter::New();
aTransformFilter->SetTransform(aTransform);
- aTransformFilter->SetInput(theGrid);
aTransform->Delete();
- return aTransformFilter->GetUnstructuredGridOutput();
+ aTransformFilter->SetInputData(theGrid);
+ aTransformFilter->Update();
+ vtkUnstructuredGrid * aGrid = aTransformFilter->GetUnstructuredGridOutput();
+ aGrid->Register(0);
+ aTransformFilter->Delete();
+ return aGrid;
}
return value;
}
-vtkUnstructuredGrid* VTKViewer_ArcBuilder::BuildArc(std::vector<double>& theScalarValues){
+vtkUnstructuredGrid* VTKViewer_ArcBuilder::BuildArc(std::vector<double>& theScalarValues)
+{
double x1 = myPnt1.GetXYZ().X(); double x2 = myPnt2.GetXYZ().X(); double x3 = myPnt3.GetXYZ().X();
double y1 = myPnt1.GetXYZ().Y(); double y2 = myPnt2.GetXYZ().Y(); double y3 = myPnt3.GetXYZ().Y();
double z = myPnt1.GetXYZ().Z(); //Points on plane || XOY
/* double aTotalAngle = fabs(angle3 - angle1);
- if (aTotalAngle > vtkMath::DoublePi())
- aTotalAngle = 2*vtkMath::DoublePi()-aTotalAngle;
+ if (aTotalAngle > vtkMath::Pi())
+ aTotalAngle = 2*vtkMath::Pi()-aTotalAngle;
*/
double aTotalAngle = 0;
const double theXPoint, const double theYPoint){
double result = atan2(theYCenter - theYPoint, theXPoint - theXCenter);
if(result < 0 )
- result = result+vtkMath::DoublePi()*2;
- return vtkMath::DoublePi()*2-result;
+ result = result+vtkMath::Pi()*2;
+ return vtkMath::Pi()*2-result;
return result;
}
aResult = VTKViewer_ArcBuilder::PLUS;
}
else if((P1 < P3 && P3 < P2) || (P2 < P1 && P1 < P3)){
- *Ang = 2*vtkMath::DoublePi() - P3 + P1;
+ *Ang = 2*vtkMath::Pi() - P3 + P1;
aResult = VTKViewer_ArcBuilder::MINUS;
}
else if((P2 < P3 && P3 < P1) || (P3 < P1 && P1 < P2)){
- *Ang = 2*vtkMath::DoublePi() - P1 + P3;
+ *Ang = 2*vtkMath::Pi() - P1 + P3;
aResult = VTKViewer_ArcBuilder::PLUS;
}
else if(P3 < P2 && P2 < P1){
//------------------------------------------------------------------------
Pnt CreatePnt(vtkCell* cell, vtkDataArray* scalars, vtkIdType index)
{
- vtkFloatingPointType coord[3];
+ double coord[3];
cell->GetPoints()->GetPoint(index, coord);
vtkIdType pointId = cell->GetPointId(index);
double scalarValue = scalars ? scalars->GetTuple1(pointId) : 0;
//------------------------------------------------------------------------
vtkIdType Build1DArc(vtkIdType cellId, vtkUnstructuredGrid* input,
vtkPolyData *output,vtkIdType *pts,
- vtkFloatingPointType myMaxArcAngle){
+ double myMaxArcAngle){
vtkIdType aResult = -1;
vtkIdType *aNewPoints;
vtkPoints* aPoints = aBuilder.GetPoints();
std::vector<double> aScalarValues = aBuilder.GetScalarValues();
vtkIdType aNbPts = aPoints->GetNumberOfPoints();
- aNewPoints = new vtkIdType[aNbPts];
+ std::vector< vtkIdType > aNewPoints( aNbPts );
vtkIdType curID;
vtkIdType aCellType = VTK_POLY_LINE;
-
+
aNewPoints[0] = pts[0];
for(vtkIdType idx = 1; idx < aNbPts-1;idx++) {
curID = output->GetPoints()->InsertNextPoint(aPoints->GetPoint(idx));
aNewPoints[idx] = curID;
}
aNewPoints[aNbPts-1] = pts[1];
-
- aResult = output->InsertNextCell(aCellType,aNbPts,aNewPoints);
+
+ aResult = output->InsertNextCell(aCellType,aNbPts,&aNewPoints[0]);
return aResult;
- }
+ }
}
/*!
* Add all points from the input vector theCollection into thePoints.
* Array theIds - it is array with ids of added points.
*/
-vtkIdType MergevtkPoints(const std::vector<vtkPoints*>& theCollection,
+vtkIdType MergevtkPoints(const std::vector< vtkSmartPointer< vtkPoints > >& theCollection,
const std::vector< std::vector<double> >& theScalarCollection,
vtkPoints* thePoints,
std::map<int, double>& thePntId2ScalarValue,
vtkIdType aNbPoints = 0;
vtkIdType anIdCounter = 0;
vtkIdType aNewPntId = 0;
-
+
//Compute number of points
- std::vector<vtkPoints*>::const_iterator it = theCollection.begin();
+ std::vector< vtkSmartPointer< vtkPoints > >::const_iterator it = theCollection.begin();
for(;it != theCollection.end();it++){
vtkPoints* aPoints = *it;
if(aPoints) {
