mirror of
https://git.salome-platform.org/gitpub/modules/geom.git
synced 2025-01-01 04:10:34 +05:00
1142 lines
38 KiB
C++
1142 lines
38 KiB
C++
// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
|
|
//
|
|
// Copyright (C) 2003-2007 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, 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
|
|
// 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.salome-platform.org/ or email : webmaster.salome@opencascade.com
|
|
//
|
|
|
|
// File : GEOMGUI_DimensionProperty.cxx
|
|
// Author : Anton POLETAEV, Open CASCADE S.A.S.
|
|
//
|
|
|
|
#include "GEOMGUI_DimensionProperty.h"
|
|
|
|
// OCCT includes
|
|
#include <Standard_ProgramError.hxx>
|
|
#include <gp_Trsf.hxx>
|
|
|
|
#include <SalomeApp_Study.h>
|
|
|
|
// Static patterns for casting value-to-string & value-from-string. The patterns are:
|
|
// ITEM: { name[string] : visibility : type : values[composite] };
|
|
// PLANE: a[float] : b[float] : c[float] : d[float]
|
|
// PROPS: flyout[float] : text h pos[int] : text v pos[int] : arrow pos[int]
|
|
// XYZ: x [float] : y[float] : z[float]
|
|
// FLOAT: value [float]
|
|
namespace
|
|
{
|
|
static const QString PATTERN_ITEM_GROUP = "\\{ (Name=(?::{2,}|.)*:(?!:)Visible=.*:Type=.*:.*) \\}";
|
|
static const QString PATTERN_ITEM = "Name=((?::{2,}|.)*):(?!:)Visible=(\\d{1}):Type=(\\d{1}):(.*)";
|
|
static const QString PATTERN_PLANE = "Plane=\\{(.*):(.*):(.*):(.*)\\}";
|
|
static const QString PATTERN_PROPS = "Flyout=(.*):TextH=(.*):TextV=(.*):Arrow=(.*)";
|
|
static const QString PATTERN_XYZ = "%1=\\{(.*):(.*):(.*)\\}";
|
|
static const QString PATTERN_FLOAT = "%1=(.*)";
|
|
|
|
static const QString PATTERN_LENGTH =
|
|
PATTERN_PLANE + ":" +
|
|
PATTERN_PROPS + ":" +
|
|
PATTERN_XYZ.arg( "Point1" ) + ":" +
|
|
PATTERN_XYZ.arg( "Point2" );
|
|
|
|
static const QString PATTERN_DIAMETER =
|
|
PATTERN_PLANE + ":" +
|
|
PATTERN_PROPS + ":" +
|
|
PATTERN_XYZ.arg( "Position" ) + ":" +
|
|
PATTERN_XYZ.arg( "NDir" ) + ":" +
|
|
PATTERN_XYZ.arg( "XDir" ) + ":" +
|
|
PATTERN_FLOAT.arg( "Radius" );
|
|
|
|
static const QString PATTERN_ANGLE =
|
|
PATTERN_PROPS + ":" +
|
|
PATTERN_XYZ.arg( "Point1" ) + ":" +
|
|
PATTERN_XYZ.arg( "Point2" ) + ":" +
|
|
PATTERN_XYZ.arg( "Point3" );
|
|
};
|
|
|
|
//=================================================================================
|
|
// function : Length::Init
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Length::Init( const Handle(AIS_LengthDimension)& theIO, const gp_Ax3& theLCS )
|
|
{
|
|
gp_Trsf aFromLCS;
|
|
aFromLCS.SetTransformation( gp_Ax3(), theLCS );
|
|
|
|
FirstPoint = theIO->FirstPoint().Transformed( aFromLCS );
|
|
SecondPoint = theIO->SecondPoint().Transformed( aFromLCS );
|
|
Plane = theIO->GetPlane().Transformed( aFromLCS );
|
|
Flyout = theIO->GetFlyout();
|
|
TextHPos = theIO->DimensionAspect()->TextHorizontalPosition();
|
|
TextVPos = theIO->DimensionAspect()->TextVerticalPosition();
|
|
ArrowPos = theIO->DimensionAspect()->ArrowOrientation();
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Length::Update
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Length::Update( Handle(AIS_LengthDimension)& theIO, const gp_Ax3& theLCS )
|
|
{
|
|
gp_Trsf aToLCS;
|
|
aToLCS.SetTransformation( theLCS, gp_Ax3() );
|
|
|
|
gp_Pnt aPoint1 = FirstPoint.Transformed( aToLCS );
|
|
gp_Pnt aPoint2 = SecondPoint.Transformed( aToLCS );
|
|
gp_Pln aPlane = Plane.Transformed( aToLCS );
|
|
|
|
theIO->SetMeasuredGeometry( aPoint1, aPoint2, aPlane );
|
|
theIO->SetFlyout( Flyout );
|
|
|
|
Handle(Prs3d_DimensionAspect) aStyle = new Prs3d_DimensionAspect();
|
|
aStyle->SetTextHorizontalPosition( TextHPos );
|
|
aStyle->SetTextVerticalPosition( TextVPos );
|
|
aStyle->SetArrowOrientation( ArrowPos );
|
|
theIO->SetDimensionAspect( aStyle );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Length::ToValues
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Length::ToValues(std::vector<double>& theValues) const
|
|
{
|
|
// custom plane [2,3,4,5]
|
|
Standard_Real A, B, C, D;
|
|
Plane.Coefficients( A, B, C, D );
|
|
theValues.push_back( (double) A );
|
|
theValues.push_back( (double) B );
|
|
theValues.push_back( (double) C );
|
|
theValues.push_back( (double) D );
|
|
|
|
// flyout size [6]
|
|
theValues.push_back( (double) Flyout );
|
|
|
|
// text flags [7,8]
|
|
theValues.push_back( (double) TextHPos );
|
|
theValues.push_back( (double) TextVPos );
|
|
|
|
// arrow flags [9]
|
|
theValues.push_back( (double) ArrowPos );
|
|
|
|
// point 1 [10,11,12]
|
|
theValues.push_back( (double) FirstPoint.X() );
|
|
theValues.push_back( (double) FirstPoint.Y() );
|
|
theValues.push_back( (double) FirstPoint.Z() );
|
|
|
|
// point 2 [13,14,15]
|
|
theValues.push_back( (double) SecondPoint.X() );
|
|
theValues.push_back( (double) SecondPoint.Y() );
|
|
theValues.push_back( (double) SecondPoint.Z() );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Length::FromValues
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Length::FromValues(int& theIt, const std::vector<double>& theValues)
|
|
{
|
|
// custom plane [2,3,4,5]
|
|
Standard_Real A = (Standard_Real) theValues[theIt++];
|
|
Standard_Real B = (Standard_Real) theValues[theIt++];
|
|
Standard_Real C = (Standard_Real) theValues[theIt++];
|
|
Standard_Real D = (Standard_Real) theValues[theIt++];
|
|
Plane = gp_Pln( A, B, C, D );
|
|
|
|
// flyout size [6]
|
|
Flyout = (Standard_Real) theValues[theIt++];
|
|
|
|
// text flags [7,8]
|
|
TextHPos = (Prs3d_DimensionTextHorizontalPosition)(int)theValues[theIt++];
|
|
TextVPos = (Prs3d_DimensionTextVerticalPosition) (int)theValues[theIt++];
|
|
|
|
// arrow flags [9]
|
|
ArrowPos = (Prs3d_DimensionArrowOrientation) (int)theValues[theIt++];
|
|
|
|
// point 1 [10,11,12]
|
|
Standard_Real aFirstX = theValues[theIt++];
|
|
Standard_Real aFirstY = theValues[theIt++];
|
|
Standard_Real aFirstZ = theValues[theIt++];
|
|
FirstPoint = gp_Pnt( aFirstX, aFirstY, aFirstZ );
|
|
|
|
// point 2 [13,14,15]
|
|
Standard_Real aSecondX = theValues[theIt++];
|
|
Standard_Real aSecondY = theValues[theIt++];
|
|
Standard_Real aSecondZ = theValues[theIt++];
|
|
SecondPoint = gp_Pnt( aSecondX, aSecondY, aSecondZ );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Length::operator ==
|
|
// purpose :
|
|
//=================================================================================
|
|
bool GEOMGUI_DimensionProperty::Length::operator == (const Length& theOther) const
|
|
{
|
|
if ( FirstPoint.X() != theOther.FirstPoint.X()
|
|
|| FirstPoint.Y() != theOther.FirstPoint.Y()
|
|
|| FirstPoint.Z() != theOther.FirstPoint.Z()
|
|
|| SecondPoint.X() != theOther.SecondPoint.X()
|
|
|| SecondPoint.Y() != theOther.SecondPoint.Y()
|
|
|| SecondPoint.Z() != theOther.SecondPoint.Z() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Plane.Location().X() != theOther.Plane.Location().X()
|
|
|| Plane.Location().Y() != theOther.Plane.Location().Y()
|
|
|| Plane.Location().Z() != theOther.Plane.Location().Z()
|
|
|| Plane.Axis().Direction().X() != theOther.Plane.Axis().Direction().X()
|
|
|| Plane.Axis().Direction().Y() != theOther.Plane.Axis().Direction().Y()
|
|
|| Plane.Axis().Direction().Z() != theOther.Plane.Axis().Direction().Z() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Flyout != theOther.Flyout
|
|
|| TextHPos != theOther.TextHPos
|
|
|| TextVPos != theOther.TextVPos
|
|
|| ArrowPos != theOther.ArrowPos )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Diameter::Init
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Diameter::Init( const Handle(AIS_DiameterDimension)& theIO, const gp_Ax3& theLCS )
|
|
{
|
|
gp_Trsf aFromLCS;
|
|
aFromLCS.SetTransformation( gp_Ax3(), theLCS );
|
|
|
|
Circle = theIO->Circle().Transformed( aFromLCS );
|
|
Plane = theIO->GetPlane().Transformed( aFromLCS );
|
|
Flyout = theIO->GetFlyout();
|
|
TextHPos = theIO->DimensionAspect()->TextHorizontalPosition();
|
|
TextVPos = theIO->DimensionAspect()->TextVerticalPosition();
|
|
ArrowPos = theIO->DimensionAspect()->ArrowOrientation();
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Diameter::Update
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Diameter::Update( Handle(AIS_DiameterDimension)& theIO, const gp_Ax3& theLCS )
|
|
{
|
|
gp_Trsf aToLCS;
|
|
aToLCS.SetTransformation( theLCS, gp_Ax3() );
|
|
|
|
gp_Circ aCircle = Circle.Transformed( aToLCS );
|
|
gp_Pln aPlane = Plane.Transformed( aToLCS );
|
|
|
|
Standard_Boolean isParallel =
|
|
aCircle.Axis().Direction().IsParallel( aPlane.Axis().Direction(), Precision::Angular() );
|
|
|
|
if ( isParallel )
|
|
{
|
|
theIO->UnsetCustomPlane();
|
|
theIO->SetMeasuredGeometry( aCircle );
|
|
}
|
|
else
|
|
{
|
|
theIO->SetCustomPlane( aPlane );
|
|
theIO->SetMeasuredGeometry( aCircle );
|
|
}
|
|
|
|
theIO->SetFlyout( Flyout );
|
|
|
|
Handle(Prs3d_DimensionAspect) aStyle = new Prs3d_DimensionAspect();
|
|
aStyle->SetTextHorizontalPosition( TextHPos );
|
|
aStyle->SetTextVerticalPosition( TextVPos );
|
|
aStyle->SetArrowOrientation( ArrowPos );
|
|
theIO->SetDimensionAspect( aStyle );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Diameter::ToValues
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Diameter::ToValues(std::vector<double>& theValues) const
|
|
{
|
|
// custom plane [2,3,4,5]
|
|
Standard_Real A, B, C, D;
|
|
Plane.Coefficients( A, B, C, D );
|
|
theValues.push_back( (double) A );
|
|
theValues.push_back( (double) B );
|
|
theValues.push_back( (double) C );
|
|
theValues.push_back( (double) D );
|
|
|
|
// flyout size [6]
|
|
theValues.push_back( (double) Flyout );
|
|
|
|
// text flags [7,8]
|
|
theValues.push_back( (double) TextHPos );
|
|
theValues.push_back( (double) TextVPos );
|
|
|
|
// arrow flags [9]
|
|
theValues.push_back( (double) ArrowPos );
|
|
|
|
// circle location [10,11,12]
|
|
theValues.push_back( (double) Circle.Location().X() );
|
|
theValues.push_back( (double) Circle.Location().Y() );
|
|
theValues.push_back( (double) Circle.Location().Z() );
|
|
|
|
// circle normal [13,14,15]
|
|
theValues.push_back( (double) Circle.Axis().Direction().X() );
|
|
theValues.push_back( (double) Circle.Axis().Direction().Y() );
|
|
theValues.push_back( (double) Circle.Axis().Direction().Z() );
|
|
|
|
// x-direction [16,17,18]
|
|
theValues.push_back( (double) Circle.XAxis().Direction().X() );
|
|
theValues.push_back( (double) Circle.XAxis().Direction().Y() );
|
|
theValues.push_back( (double) Circle.XAxis().Direction().Z() );
|
|
|
|
// radius [19]
|
|
theValues.push_back( (double) Circle.Radius() );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Diameter::FromValues
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Diameter::FromValues(int& theIt, const std::vector<double>& theValues)
|
|
{
|
|
// custom plane [2,3,4,5]
|
|
Standard_Real A = (Standard_Real) theValues[theIt++];
|
|
Standard_Real B = (Standard_Real) theValues[theIt++];
|
|
Standard_Real C = (Standard_Real) theValues[theIt++];
|
|
Standard_Real D = (Standard_Real) theValues[theIt++];
|
|
Plane = gp_Pln( A, B, C, D );
|
|
|
|
// flyout size [6]
|
|
Flyout = (Standard_Real) theValues[theIt++];
|
|
|
|
// text flags [7,8]
|
|
TextHPos = (Prs3d_DimensionTextHorizontalPosition)(int)theValues[theIt++];
|
|
TextVPos = (Prs3d_DimensionTextVerticalPosition) (int)theValues[theIt++];
|
|
|
|
// arrow flags [9]
|
|
ArrowPos = (Prs3d_DimensionArrowOrientation) (int)theValues[theIt++];
|
|
|
|
// circle location [10,11,12]
|
|
Standard_Real aLocX = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aLocY = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aLocZ = (Standard_Real) theValues[theIt++];
|
|
|
|
// circle normal [13,14,15]
|
|
Standard_Real aNormX = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aNormY = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aNormZ = (Standard_Real) theValues[theIt++];
|
|
|
|
// x-direction [16,17,18]
|
|
Standard_Real aXDirX = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aXDirY = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aXDirZ = (Standard_Real) theValues[theIt++];
|
|
|
|
// radius [19]
|
|
Standard_Real aRadius = (Standard_Real) theValues[theIt++];
|
|
|
|
gp_Ax2 anAx( gp_Pnt( aLocX, aLocY, aLocZ ),
|
|
gp_Dir( aNormX, aNormY, aNormZ ),
|
|
gp_Dir( aXDirX, aXDirY, aXDirZ ) );
|
|
|
|
Circle = gp_Circ( anAx, aRadius );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Diameter::operator ==
|
|
// purpose :
|
|
//=================================================================================
|
|
bool GEOMGUI_DimensionProperty::Diameter::operator == (const Diameter& theOther) const
|
|
{
|
|
if ( Circle.Location().X() != theOther.Circle.Location().X()
|
|
|| Circle.Location().Y() != theOther.Circle.Location().Y()
|
|
|| Circle.Location().Z() != theOther.Circle.Location().Z()
|
|
|| Circle.Axis().Direction().X() != theOther.Circle.Axis().Direction().X()
|
|
|| Circle.Axis().Direction().Y() != theOther.Circle.Axis().Direction().Y()
|
|
|| Circle.Axis().Direction().Z() != theOther.Circle.Axis().Direction().Z()
|
|
|| Circle.XAxis().Direction().X() != theOther.Circle.XAxis().Direction().X()
|
|
|| Circle.XAxis().Direction().Y() != theOther.Circle.XAxis().Direction().Y()
|
|
|| Circle.XAxis().Direction().Z() != theOther.Circle.XAxis().Direction().Z()
|
|
|| Circle.Radius() != theOther.Circle.Radius() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Plane.Location().X() != theOther.Plane.Location().X()
|
|
|| Plane.Location().Y() != theOther.Plane.Location().Y()
|
|
|| Plane.Location().Z() != theOther.Plane.Location().Z()
|
|
|| Plane.Axis().Direction().X() != theOther.Plane.Axis().Direction().X()
|
|
|| Plane.Axis().Direction().Y() != theOther.Plane.Axis().Direction().Y()
|
|
|| Plane.Axis().Direction().Z() != theOther.Plane.Axis().Direction().Z() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Flyout != theOther.Flyout
|
|
|| TextHPos != theOther.TextHPos
|
|
|| TextVPos != theOther.TextVPos
|
|
|| ArrowPos != theOther.ArrowPos )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Angle::Init
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Angle::Init( const Handle(AIS_AngleDimension)& theIO, const gp_Ax3& theLCS )
|
|
{
|
|
gp_Trsf aFromLCS;
|
|
aFromLCS.SetTransformation( gp_Ax3(), theLCS );
|
|
|
|
FirstPoint = theIO->FirstPoint().Transformed( aFromLCS );
|
|
SecondPoint = theIO->SecondPoint().Transformed( aFromLCS );
|
|
CenterPoint = theIO->CenterPoint().Transformed( aFromLCS );
|
|
Flyout = theIO->GetFlyout();
|
|
TextHPos = theIO->DimensionAspect()->TextHorizontalPosition();
|
|
TextVPos = theIO->DimensionAspect()->TextVerticalPosition();
|
|
ArrowPos = theIO->DimensionAspect()->ArrowOrientation();
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Angle::Update
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Angle::Update( Handle(AIS_AngleDimension)& theIO, const gp_Ax3& theLCS )
|
|
{
|
|
gp_Trsf aToLCS;
|
|
aToLCS.SetTransformation( theLCS, gp_Ax3() );
|
|
|
|
gp_Pnt aPoint1 = FirstPoint.Transformed( aToLCS );
|
|
gp_Pnt aPoint2 = CenterPoint.Transformed( aToLCS );
|
|
gp_Pnt aPoint3 = SecondPoint.Transformed( aToLCS );
|
|
|
|
theIO->SetMeasuredGeometry( aPoint1, aPoint2, aPoint3 );
|
|
theIO->SetFlyout( Flyout );
|
|
|
|
Handle(Prs3d_DimensionAspect) aStyle = new Prs3d_DimensionAspect();
|
|
aStyle->SetTextHorizontalPosition( TextHPos );
|
|
aStyle->SetTextVerticalPosition( TextVPos );
|
|
aStyle->SetArrowOrientation( ArrowPos );
|
|
theIO->SetDimensionAspect( aStyle );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Angle::ToValues
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Angle::ToValues(std::vector<double>& theValues) const
|
|
{
|
|
// flyout [2]
|
|
theValues.push_back( (double) Flyout );
|
|
|
|
// text flags [3,4]
|
|
theValues.push_back( (double) TextHPos );
|
|
theValues.push_back( (double) TextVPos );
|
|
|
|
// arrow flags [5]
|
|
theValues.push_back( (double) ArrowPos );
|
|
|
|
// point 1 [6,7,8]
|
|
theValues.push_back( (double) FirstPoint.X() );
|
|
theValues.push_back( (double) FirstPoint.Y() );
|
|
theValues.push_back( (double) FirstPoint.Z() );
|
|
|
|
// point 2 [9,10,11]
|
|
theValues.push_back( (double) SecondPoint.X() );
|
|
theValues.push_back( (double) SecondPoint.Y() );
|
|
theValues.push_back( (double) SecondPoint.Z() );
|
|
|
|
// center [12,13,14]
|
|
theValues.push_back( (double) CenterPoint.X() );
|
|
theValues.push_back( (double) CenterPoint.Y() );
|
|
theValues.push_back( (double) CenterPoint.Z() );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Angle::FromValues
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Angle::FromValues(int& theIt, const std::vector<double>& theValues)
|
|
{
|
|
// flyout [2]
|
|
Flyout = (Standard_Real) theValues[theIt++];
|
|
|
|
// text flags [3,4]
|
|
TextHPos = (Prs3d_DimensionTextHorizontalPosition)(int)theValues[theIt++];
|
|
TextVPos = (Prs3d_DimensionTextVerticalPosition) (int)theValues[theIt++];
|
|
|
|
// arrow flags [5]
|
|
ArrowPos = (Prs3d_DimensionArrowOrientation) (int)theValues[theIt++];
|
|
|
|
// point 1 [6,7,8]
|
|
Standard_Real aFirstX = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aFirstY = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aFirstZ = (Standard_Real) theValues[theIt++];
|
|
|
|
// point 2 [9,10,11]
|
|
Standard_Real aSecondX = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aSecondY = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aSecondZ = (Standard_Real) theValues[theIt++];
|
|
|
|
// center [12,13,14]
|
|
Standard_Real aCenterX = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aCenterY = (Standard_Real) theValues[theIt++];
|
|
Standard_Real aCenterZ = (Standard_Real) theValues[theIt++];
|
|
|
|
FirstPoint = gp_Pnt( aFirstX, aFirstY, aFirstZ );
|
|
SecondPoint = gp_Pnt( aSecondX, aSecondY, aSecondZ );
|
|
CenterPoint = gp_Pnt( aCenterX, aCenterY, aCenterZ );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Angle::operator ==
|
|
// purpose :
|
|
//=================================================================================
|
|
bool GEOMGUI_DimensionProperty::Angle::operator == (const Angle& theOther) const
|
|
{
|
|
if ( FirstPoint.X() != theOther.FirstPoint.X()
|
|
|| FirstPoint.Y() != theOther.FirstPoint.Y()
|
|
|| FirstPoint.Z() != theOther.FirstPoint.Z()
|
|
|| SecondPoint.X() != theOther.SecondPoint.X()
|
|
|| SecondPoint.Y() != theOther.SecondPoint.Y()
|
|
|| SecondPoint.Z() != theOther.SecondPoint.Z()
|
|
|| CenterPoint.X() != theOther.CenterPoint.X()
|
|
|| CenterPoint.Y() != theOther.CenterPoint.Y()
|
|
|| CenterPoint.Z() != theOther.CenterPoint.Z() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( Flyout != theOther.Flyout
|
|
|| TextHPos != theOther.TextHPos
|
|
|| TextVPos != theOther.TextVPos
|
|
|| ArrowPos != theOther.ArrowPos )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Constructor
|
|
// purpose :
|
|
//=================================================================================
|
|
GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty()
|
|
{
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Copy constructor
|
|
// purpose :
|
|
//=================================================================================
|
|
GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty( const GEOMGUI_DimensionProperty& theOther )
|
|
{
|
|
const VectorOfVisibility& aOtherVis = theOther.myVisibility;
|
|
const VectorOfNames& aOtherNames = theOther.myNames;
|
|
const VectorOfRecords& aOtherRecords = theOther.myRecords;
|
|
|
|
VectorOfVisibility::const_iterator aVisIt = aOtherVis.constBegin();
|
|
VectorOfNames::const_iterator aNamesIt = aOtherNames.constBegin();
|
|
VectorOfRecords::const_iterator aRecordIt = aOtherRecords.constBegin();
|
|
for ( ; aRecordIt != aOtherRecords.constEnd(); ++aVisIt, ++aNamesIt, ++aRecordIt )
|
|
{
|
|
RecordPtr aNewRecord;
|
|
const RecordPtr& aRecord = *aRecordIt;
|
|
switch( aRecord->Type() )
|
|
{
|
|
case DimensionType_Length :
|
|
aNewRecord = RecordPtr( new Length( *aRecord->AsLength() ) );
|
|
break;
|
|
|
|
case DimensionType_Diameter :
|
|
aNewRecord = RecordPtr( new Diameter( *aRecord->AsDiameter() ) );
|
|
break;
|
|
|
|
case DimensionType_Angle :
|
|
aNewRecord = RecordPtr( new Angle( *aRecord->AsAngle() ) );
|
|
break;
|
|
}
|
|
|
|
myVisibility.append( *aVisIt );
|
|
myNames.append( *aNamesIt );
|
|
myRecords.append( aNewRecord );
|
|
}
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Init constructor
|
|
// purpose :
|
|
//=================================================================================
|
|
GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty( SalomeApp_Study* theStudy, const std::string& theEntry )
|
|
{
|
|
LoadFromAttribute( theStudy, theEntry );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Init constructor
|
|
// purpose :
|
|
//=================================================================================
|
|
GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty( const QString& theProperty )
|
|
{
|
|
QRegExp aRegExpItemGroups( PATTERN_ITEM_GROUP );
|
|
QRegExp aRegExpItem( "^" + PATTERN_ITEM + "$" );
|
|
aRegExpItemGroups.setMinimal( true );
|
|
aRegExpItem.setMinimal( true );
|
|
|
|
int aPos = 0;
|
|
while ( ( aPos = aRegExpItemGroups.indexIn( theProperty, aPos ) ) != -1 )
|
|
{
|
|
aPos += aRegExpItemGroups.matchedLength();
|
|
|
|
QString aStrItem = aRegExpItemGroups.cap(1);
|
|
|
|
if ( aRegExpItem.indexIn( aStrItem ) < 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// extract name
|
|
QString aStrName = aRegExpItem.cap( 1 );
|
|
QString aStrVisible = aRegExpItem.cap( 2 );
|
|
QString aStrType = aRegExpItem.cap( 3 );
|
|
QString aStrValues = aRegExpItem.cap( 4 );
|
|
|
|
// extract values
|
|
aStrName.replace( "::", ":" );
|
|
bool isVisible = aStrVisible.toInt() != 0;
|
|
int aType = aStrType.toInt();
|
|
|
|
RecordPtr aRecord;
|
|
switch ( aType )
|
|
{
|
|
case DimensionType_Length : aRecord = RecordPtr( new Length ); break;
|
|
case DimensionType_Diameter : aRecord = RecordPtr( new Diameter ); break;
|
|
case DimensionType_Angle : aRecord = RecordPtr( new Angle ); break;
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
QRegExp aRegExpValues;
|
|
switch ( aType )
|
|
{
|
|
case DimensionType_Length : aRegExpValues = QRegExp( "^" + PATTERN_LENGTH + "$" ); break;
|
|
case DimensionType_Diameter : aRegExpValues = QRegExp( "^" + PATTERN_DIAMETER + "$" ); break;
|
|
case DimensionType_Angle : aRegExpValues = QRegExp( "^" + PATTERN_ANGLE + "$" ); break;
|
|
}
|
|
|
|
aRegExpValues.setMinimal(true);
|
|
|
|
if ( aRegExpValues.indexIn( aStrValues ) < 0 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
std::vector<double> aValues;
|
|
|
|
QStringList aStrListOfValues = aRegExpValues.capturedTexts();
|
|
QStringList::Iterator aStrListOfValuesIt = aStrListOfValues.begin();
|
|
++aStrListOfValuesIt; // skip first capture
|
|
for ( ; aStrListOfValuesIt != aStrListOfValues.end(); ++aStrListOfValuesIt )
|
|
{
|
|
aValues.push_back( (*aStrListOfValuesIt).toDouble() );
|
|
}
|
|
|
|
int aValueIt = 0;
|
|
|
|
aRecord->FromValues( aValueIt, aValues );
|
|
|
|
myVisibility.append( isVisible );
|
|
myNames.append( aStrName );
|
|
myRecords.append( aRecord );
|
|
}
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Destructor
|
|
// purpose :
|
|
//=================================================================================
|
|
GEOMGUI_DimensionProperty::~GEOMGUI_DimensionProperty()
|
|
{
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : operator QVariant()
|
|
// purpose :
|
|
//=================================================================================
|
|
GEOMGUI_DimensionProperty::operator QVariant() const
|
|
{
|
|
QVariant aQVariant;
|
|
aQVariant.setValue( *this );
|
|
return aQVariant;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : operator QString()
|
|
// purpose :
|
|
//=================================================================================
|
|
GEOMGUI_DimensionProperty::operator QString() const
|
|
{
|
|
QStringList anItems;
|
|
|
|
VectorOfVisibility::ConstIterator aVisibilityIt = myVisibility.constBegin();
|
|
VectorOfRecords::ConstIterator aRecordIt = myRecords.constBegin();
|
|
VectorOfNames::ConstIterator aNameIt = myNames.constBegin();
|
|
for ( ; aRecordIt != myRecords.constEnd(); ++aRecordIt, ++aNameIt, ++aVisibilityIt )
|
|
{
|
|
QString aName = *aNameIt;
|
|
const bool& isVisible = *aVisibilityIt;
|
|
const RecordPtr& aRecord = *aRecordIt;
|
|
|
|
// pack values
|
|
std::vector<double> aPacked;
|
|
aRecord->ToValues( aPacked );
|
|
|
|
// put values into pattern
|
|
QString aStringValues;
|
|
switch ( aRecord->Type() )
|
|
{
|
|
case DimensionType_Length : aStringValues = PATTERN_LENGTH; break;
|
|
case DimensionType_Diameter : aStringValues = PATTERN_DIAMETER; break;
|
|
case DimensionType_Angle : aStringValues = PATTERN_ANGLE; break;
|
|
default:
|
|
continue;
|
|
}
|
|
|
|
aStringValues.remove("\\");
|
|
|
|
int it = 0;
|
|
for ( ; it < aPacked.size(); ++it )
|
|
{
|
|
int aNextPos = aStringValues.indexOf("(.*)");
|
|
if ( aNextPos < 0 )
|
|
{
|
|
break; // invalid pattern
|
|
}
|
|
|
|
aStringValues.replace( aNextPos, 4, QString::number( aPacked.at(it) ) );
|
|
}
|
|
|
|
if ( it < aPacked.size() )
|
|
{
|
|
continue; // invalid pattern
|
|
}
|
|
|
|
// replace all ':' to '::' for pattern matching
|
|
aName.replace(":", "::");
|
|
|
|
anItems.append(
|
|
QString("{ Name=") + aName +
|
|
QString(":") + QString("Visible=") + QString::number( isVisible ? 1 : 0 ) +
|
|
QString(":") + QString("Type=") + QString::number( (int) aRecord->Type() ) +
|
|
QString(":") + aStringValues + QString(" }") );
|
|
}
|
|
|
|
return anItems.join( ":" );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : operator ==
|
|
// purpose :
|
|
//=================================================================================
|
|
bool GEOMGUI_DimensionProperty::operator == (const GEOMGUI_DimensionProperty& theOther) const
|
|
{
|
|
if ( myVisibility.size() != theOther.myVisibility.size()
|
|
|| myNames.size() != theOther.myNames.size()
|
|
|| myRecords.size() != theOther.myRecords.size() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
for ( int it = 0; it < myRecords.size(); ++it )
|
|
{
|
|
if ( myVisibility[it] != theOther.myVisibility[it] )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( myNames[it] != theOther.myNames[it] )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const RecordPtr& aRecord = myRecords[it];
|
|
const RecordPtr& aOtherRecord = theOther.myRecords[it];
|
|
if ( aRecord->Type() != aOtherRecord->Type() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
switch ( aRecord->Type() )
|
|
{
|
|
case DimensionType_Length:
|
|
if ( (*aRecord->AsLength()) != (*aOtherRecord->AsLength()) )
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case DimensionType_Diameter:
|
|
if ( (*aRecord->AsDiameter()) != (*aOtherRecord->AsDiameter()) )
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
|
|
case DimensionType_Angle:
|
|
if ( (*aRecord->AsAngle()) != (*aOtherRecord->AsAngle()) )
|
|
{
|
|
return false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : GetNumber
|
|
// purpose :
|
|
//=================================================================================
|
|
int GEOMGUI_DimensionProperty::GetNumber() const
|
|
{
|
|
return myRecords.size();
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : AddRecord
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::AddRecord( const Handle(AIS_Dimension)& theIO, const gp_Ax3& theLCS )
|
|
{
|
|
RecordPtr aNewRecord;
|
|
|
|
int aType = TypeFromIO( theIO );
|
|
|
|
switch ( aType )
|
|
{
|
|
case DimensionType_Length :
|
|
{
|
|
Handle(AIS_LengthDimension) aLength =
|
|
Handle(AIS_LengthDimension)::DownCast( theIO );
|
|
|
|
aNewRecord = RecordPtr( new Length() );
|
|
aNewRecord->AsLength()->Init( aLength, theLCS );
|
|
break;
|
|
}
|
|
|
|
case DimensionType_Diameter :
|
|
{
|
|
Handle(AIS_DiameterDimension) aDiam =
|
|
Handle(AIS_DiameterDimension)::DownCast( theIO );
|
|
|
|
aNewRecord = RecordPtr( new Diameter() );
|
|
aNewRecord->AsDiameter()->Init( aDiam, theLCS );
|
|
break;
|
|
}
|
|
|
|
case DimensionType_Angle :
|
|
{
|
|
Handle(AIS_AngleDimension) anAngle =
|
|
Handle(AIS_AngleDimension)::DownCast( theIO );
|
|
|
|
aNewRecord = RecordPtr( new Angle() );
|
|
aNewRecord->AsAngle()->Init( anAngle, theLCS );
|
|
}
|
|
}
|
|
|
|
myVisibility.append( true );
|
|
myNames.append( QString() );
|
|
myRecords.append( aNewRecord );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : AddRecord
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::AddRecord( const RecordPtr& theRecord )
|
|
{
|
|
myVisibility.append( true );
|
|
myNames.append( QString() );
|
|
myRecords.append( theRecord );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : RemoveRecord
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::RemoveRecord( const int theIndex )
|
|
{
|
|
myNames.remove( theIndex );
|
|
myVisibility.remove( theIndex );
|
|
myRecords.remove( theIndex );
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : Clear
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::Clear()
|
|
{
|
|
myNames.clear();
|
|
myVisibility.clear();
|
|
myRecords.clear();
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : SetRecord
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::SetRecord( const int theIndex,
|
|
const Handle(AIS_Dimension)& theIO,
|
|
const gp_Ax3& theLCS )
|
|
{
|
|
int aType = TypeFromIO( theIO );
|
|
|
|
RecordPtr& aChangeRecord = myRecords[theIndex];
|
|
|
|
switch ( aType )
|
|
{
|
|
case DimensionType_Length :
|
|
{
|
|
Handle(AIS_LengthDimension) aLength =
|
|
Handle(AIS_LengthDimension)::DownCast( theIO );
|
|
|
|
aChangeRecord = RecordPtr( new Length() );
|
|
aChangeRecord->AsLength()->Init( aLength, theLCS );
|
|
break;
|
|
}
|
|
|
|
case DimensionType_Diameter :
|
|
{
|
|
Handle(AIS_DiameterDimension) aDiam =
|
|
Handle(AIS_DiameterDimension)::DownCast( theIO );
|
|
|
|
aChangeRecord = RecordPtr( new Diameter() );
|
|
aChangeRecord->AsDiameter()->Init( aDiam, theLCS );
|
|
break;
|
|
}
|
|
|
|
case DimensionType_Angle :
|
|
{
|
|
Handle(AIS_AngleDimension) anAngle =
|
|
Handle(AIS_AngleDimension)::DownCast( theIO );
|
|
|
|
aChangeRecord = RecordPtr( new Angle() );
|
|
aChangeRecord->AsAngle()->Init( anAngle, theLCS );
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : SetRecord
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::SetRecord( const int theIndex, const RecordPtr& theRecord )
|
|
{
|
|
myRecords[theIndex] = theRecord;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : GetRecord
|
|
// purpose :
|
|
//=================================================================================
|
|
const GEOMGUI_DimensionProperty::RecordPtr& GEOMGUI_DimensionProperty::GetRecord( const int theIndex ) const
|
|
{
|
|
return myRecords[theIndex];
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : IsVisible
|
|
// purpose :
|
|
//=================================================================================
|
|
bool GEOMGUI_DimensionProperty::IsVisible( const int theIndex ) const
|
|
{
|
|
return myVisibility[theIndex];
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : SetVisible
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::SetVisible( const int theIndex, const bool theIsVisible )
|
|
{
|
|
myVisibility[theIndex] = theIsVisible;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : GetName
|
|
// purpose :
|
|
//=================================================================================
|
|
QString GEOMGUI_DimensionProperty::GetName( const int theIndex ) const
|
|
{
|
|
return myNames[theIndex];
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : SetName
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::SetName( const int theIndex, const QString &theName )
|
|
{
|
|
myNames[theIndex] = theName;
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : GetType
|
|
// purpose :
|
|
//=================================================================================
|
|
int GEOMGUI_DimensionProperty::GetType( const int theIndex ) const
|
|
{
|
|
return myRecords[theIndex]->Type();
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : LoadFromAttribute
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::LoadFromAttribute( SalomeApp_Study* theStudy,
|
|
const std::string& theEntry )
|
|
{
|
|
Clear();
|
|
|
|
_PTR(SObject) aSObj = theStudy->studyDS()->FindObjectID( theEntry );
|
|
if ( !aSObj )
|
|
{
|
|
return;
|
|
}
|
|
|
|
_PTR(StudyBuilder) aBuilder = theStudy->studyDS()->NewBuilder();
|
|
|
|
_PTR(GenericAttribute) aSeekAtt;
|
|
_PTR(AttributeTableOfReal) aRecordsAtt;
|
|
|
|
if ( !aSObj->FindAttribute( aSeekAtt, "AttributeTableOfReal" ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
aRecordsAtt = aSeekAtt;
|
|
|
|
for ( int aRecordIt = 1; aRecordIt <= aRecordsAtt->GetNbColumns(); ++aRecordIt )
|
|
{
|
|
std::vector<double> aPacked = aRecordsAtt->GetColumn( aRecordIt );
|
|
|
|
RecordPtr aRecord;
|
|
|
|
QString aName( aRecordsAtt->GetColumnTitle( aRecordIt ).c_str() );
|
|
|
|
// unpack records
|
|
int it = 0;
|
|
|
|
// visibility [0]
|
|
bool isVisible = (bool) aPacked[it++];
|
|
|
|
// type [1]
|
|
int aType = (int) aPacked[it++];
|
|
|
|
switch (aType)
|
|
{
|
|
case DimensionType_Length : aRecord = RecordPtr( new Length ); break;
|
|
case DimensionType_Diameter : aRecord = RecordPtr( new Diameter ); break;
|
|
case DimensionType_Angle : aRecord = RecordPtr( new Angle ); break;
|
|
}
|
|
aRecord->FromValues(it, aPacked);
|
|
|
|
myVisibility.append( isVisible );
|
|
myNames.append( aName );
|
|
myRecords.append( aRecord );
|
|
}
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : SaveToAttribute
|
|
// purpose :
|
|
//=================================================================================
|
|
void GEOMGUI_DimensionProperty::SaveToAttribute( SalomeApp_Study *theStudy,
|
|
const std::string &theEntry )
|
|
{
|
|
_PTR(SObject) aSObj = theStudy->studyDS()->FindObjectID( theEntry );
|
|
if ( !aSObj )
|
|
{
|
|
return;
|
|
}
|
|
|
|
_PTR(StudyBuilder) aBuilder = theStudy->studyDS()->NewBuilder();
|
|
|
|
_PTR(AttributeTableOfReal) aRecordsAtt;
|
|
|
|
aRecordsAtt = aBuilder->FindOrCreateAttribute( aSObj, "AttributeTableOfReal" );
|
|
aRecordsAtt->SetNbColumns( 0 );
|
|
|
|
for ( int it = 0; it < myRecords.size(); ++it )
|
|
{
|
|
bool aVisibility = myVisibility[it];
|
|
QString& aName = myNames[it];
|
|
RecordPtr& aRecord = myRecords[it];
|
|
|
|
std::vector<double> aPacked;
|
|
|
|
// visibility [0]
|
|
aPacked.push_back( (double) aVisibility );
|
|
|
|
// type [1]
|
|
aPacked.push_back( (double) aRecord->Type() );
|
|
|
|
// values
|
|
aRecord->ToValues( aPacked );
|
|
|
|
aRecordsAtt->AddColumn( aPacked );
|
|
aRecordsAtt->SetColumnTitle( it + 1, aName.toStdString() );
|
|
}
|
|
}
|
|
|
|
//=================================================================================
|
|
// function : TypeFromIO
|
|
// purpose :
|
|
//=================================================================================
|
|
int GEOMGUI_DimensionProperty::TypeFromIO( const Handle(AIS_Dimension)& theIO ) const
|
|
{
|
|
if ( theIO->IsKind( STANDARD_TYPE( AIS_LengthDimension ) ) )
|
|
{
|
|
return DimensionType_Length;
|
|
}
|
|
|
|
if ( theIO->IsKind( STANDARD_TYPE( AIS_DiameterDimension ) ) )
|
|
{
|
|
return DimensionType_Diameter;
|
|
}
|
|
|
|
if ( theIO->IsKind( STANDARD_TYPE( AIS_AngleDimension ) ) )
|
|
{
|
|
return DimensionType_Angle;
|
|
}
|
|
|
|
Standard_ProgramError::Raise( "unsupported dimension type" );
|
|
|
|
return 0;
|
|
}
|