ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2025-01-08 15:50:35 +05:00
Code Issues Packages Projects Releases Wiki Activity
d8e687a757
geom/src/EntityGUI/EntityGUI_3DSketcherDlg.cxx
vsr 5b3622aa23 Merge from V6_main 01/04/2013
2013-04-01 12:25:01 +00:00

1884 lines
66 KiB
C++
Executable File
Raw Blame History

// Copyright (C) 2007-2013 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.
//
// 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
//
// GEOM GEOMGUI : GUI for Geometry component
// File : EntityGUI_3DSketcherDlg.cxx
// Author : DMV, OCN
#include <cmath>
#include <string>
#include <boost/lexical_cast.hpp>
#include "EntityGUI_3DSketcherDlg.h"
#include "EntityGUI_Widgets.h"
#include <Basics_OCCTVersion.hxx>
#include <GEOMBase.h>
#include <GeometryGUI.h>
#include <Precision.hxx>
#include <DlgRef.h>
#include <SUIT_Session.h>
#include <SUIT_Desktop.h>
#include <SUIT_MessageBox.h>
#include <SUIT_ResourceMgr.h>
#include <SUIT_ViewWindow.h>
#include <SUIT_ViewManager.h>
#include <SOCC_Prs.h>
#include <SOCC_ViewModel.h>
#include <SalomeApp_Application.h>
#include <SalomeApp_DoubleSpinBox.h>
#include <LightApp_Application.h>
#include <LightApp_SelectionMgr.h>
#include <SalomeApp_Tools.h>
//OCCT includes
#include <TopoDS.hxx>
#include <TColStd_IndexedMapOfInteger.hxx>
#include <BRepBuilderAPI_MakeVertex.hxx>
#include <BRepBuilderAPI_MakePolygon.hxx>
#include <BRepBuilderAPI_MakeEdge.hxx>
#include <AIS_Trihedron.hxx>
#include <AIS_AngleDimension.hxx>
#include <AIS_LengthDimension.hxx>
#include <AIS_Drawer.hxx>
#include <Geom_Axis2Placement.hxx>
#include <Geom_Plane.hxx>
#include <SelectMgr_Selection.hxx>
#include <gce_MakePln.hxx>
#include <Prs3d_AngleAspect.hxx>
#include <Prs3d_LineAspect.hxx>
#include <Prs3d_LengthAspect.hxx>
#if OCC_VERSION_LARGE > 0x06050300
#include <Prs3d_TextAspect.hxx>
#include <Prs3d_Presentation.hxx>
#include <Prs3d_Text.hxx>
#include <Graphic3d_VerticalTextAlignment.hxx>
#include <Graphic3d_HorizontalTextAlignment.hxx>
#include <Graphic3d_AspectText3d.hxx>
#include <Font_FontAspect.hxx>
#endif // OCC_VERSION_LARGE > 0x06050300
// This include must be *AFTER* SOCC_ViewModel.h because
// of the constant ROTATE which is a #define in
// GEOMImpl_Types.hxx and an enum in SOCC_ViewModel.h
#include <GEOMImpl_Types.hxx>
// TODO
//
// Avoid duplication of angle coordinates in cylindrical mode
// Check spherical mode in absolute
enum
{
OXY,
OYZ,
OXZ
};
class Locker
{
public:
Locker(bool& l) : myLock(l) { myLock = true; }
~Locker() { myLock = false; }
private:
bool& myLock;
};
#if OCC_VERSION_LARGE > 0x06050300
DEFINE_STANDARD_HANDLE(AIS_Text, AIS_InteractiveObject)
class AIS_Text:public AIS_InteractiveObject
{
public:
// CASCADE RTTI
DEFINE_STANDARD_RTTI(AIS_Text );
AIS_Text(){};
AIS_Text
(
const TCollection_ExtendedString& , const gp_Pnt& ,
Quantity_Color color,
Standard_Integer aHJust,
Standard_Integer aVJust ,
Standard_Real Angle ,
Standard_Boolean Zoom ,
Standard_Real Height,
Font_FontAspect FontAspect,
Standard_CString Font
);
private:
void Compute ( const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
const Handle(Prs3d_Presentation)& aPresentation,
const Standard_Integer aMode);
void ComputeSelection ( const Handle(SelectMgr_Selection)& aSelection,
const Standard_Integer aMode){} ;
protected:
TCollection_ExtendedString aText;
gp_Pnt aPosition;
Standard_Real Red;
Standard_Real Green;
Standard_Real Blue;
Standard_Real aAngle;
Standard_Real aHeight;
Standard_Boolean aZoomable;
Quantity_Color aColor;
Standard_CString aFont;
Font_FontAspect aFontAspect;
Graphic3d_HorizontalTextAlignment aHJustification;
Graphic3d_VerticalTextAlignment aVJustification;
};
IMPLEMENT_STANDARD_HANDLE(AIS_Text, AIS_InteractiveObject)
IMPLEMENT_STANDARD_RTTIEXT(AIS_Text, AIS_InteractiveObject)
AIS_Text::AIS_Text( const TCollection_ExtendedString& text, const gp_Pnt& position,
Quantity_Color color = Quantity_NOC_YELLOW,
Standard_Integer aHJust = Graphic3d_HTA_LEFT,
Standard_Integer aVJust = Graphic3d_VTA_BOTTOM,
Standard_Real angle = 0.0 ,
Standard_Boolean zoomable = Standard_False,
Standard_Real height = 16.,
Font_FontAspect fontAspect = Font_FA_Regular,
Standard_CString font = "Courier")
{
aText = text;
aPosition = position;
aHJustification = Graphic3d_HorizontalTextAlignment(aHJust);
aVJustification = Graphic3d_VerticalTextAlignment(aVJust);
aAngle = angle;
aZoomable = zoomable;
aHeight = height;
aColor = color;
aFontAspect = fontAspect;
aFont = font;
};
void AIS_Text::Compute(const Handle(PrsMgr_PresentationManager3d)& aPresentationManager,
const Handle(Prs3d_Presentation)& aPresentation,
const Standard_Integer aMode)
{
aPresentation->Clear();
Handle_Prs3d_TextAspect asp = myDrawer->TextAspect();
asp->SetFont(aFont);
asp->SetColor(aColor);
asp->SetHeight(aHeight); // I am changing the myHeight value
asp->SetHorizontalJustification(aHJustification);
asp->SetVerticalJustification(aVJustification);
asp->Aspect()->SetTextZoomable(aZoomable);
asp->Aspect()->SetTextAngle(aAngle);
asp->Aspect()->SetTextFontAspect(aFontAspect);
Prs3d_Text::Draw(aPresentation, asp, aText, aPosition);
};
#endif // OCC_VERSION_LARGE > 0x06050300
bool isSame (double d1, double d2)
{
return Abs(d1 - d2) <= Precision::Confusion();
}
//=================================================================================
// class : EntityGUI_3DSketcherDlg()
// purpose : Constructs a EntityGUI_3DSketcherDlg which is a child of 'parent', with the
// name 'name' and widget flags set to 'f'.
// The dialog will by default be modeless, unless you set 'modal' to
// TRUE to construct a modal dialog.
//=================================================================================
EntityGUI_3DSketcherDlg::EntityGUI_3DSketcherDlg (GeometryGUI* theGeometryGUI, QWidget* parent,
bool modal, Qt::WindowFlags fl,
const double lineWidth)
: GEOMBase_Skeleton(theGeometryGUI, parent, modal, fl),
myMode(-1),
myOK(false),
myLineWidth(lineWidth),
myGeometryGUI(theGeometryGUI),
myLengthIORedoList()
{
QPixmap image0(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_SELECT")));
QPixmap image1(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_UNDO")));
QPixmap image2(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_DLG_REDO")));
QPixmap image3(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICO_3DSKETCH")));
setWindowTitle(tr("GEOM_3DSKETCHER_TITLE"));
/***************************************************************/
mainFrame()->GroupConstructors->setTitle(tr("GEOM_3DSKETCHER"));
mainFrame()->RadioButton1->setIcon(image3);;
mainFrame()->RadioButton2->close();
mainFrame()->RadioButton3->close();
GroupType = new EntityGUI_Type(centralWidget());
GroupType->GroupType2->setTitle(tr("GEOM_COORDINATES_TYPE"));
GroupType->GroupType1->setTitle(tr("GEOM_MODE"));
GroupType->RadioButton1->setText(tr("GEOM_SKETCHER_ABS"));
GroupType->RadioButton2->setText(tr("GEOM_SKETCHER_REL"));
GroupType->RadioButton3->setText(tr("(X,Y,Z)"));
GroupType->RadioButton4->setText(tr("GEOM_ANGLES"));
myTypeGroup1 = new QButtonGroup(this);
myTypeGroup1->setExclusive(true);
myTypeGroup1->addButton(GroupType->RadioButton1, 0);
myTypeGroup1->addButton(GroupType->RadioButton2, 1);
myTypeGroup2 = new QButtonGroup(this);
myTypeGroup2->setExclusive(true);
myTypeGroup2->addButton(GroupType->RadioButton3, 0);
myTypeGroup2->addButton(GroupType->RadioButton4, 1);
Group3Spin = new EntityGUI_3Spin(centralWidget());
Group3Spin->GroupBox1->setTitle(tr("GEOM_SKETCHER_VALUES"));
Group3Spin->buttonApply->setText(tr("GEOM_SKETCHER_APPLY"));
Group3Spin->buttonUndo->setIcon(image1);
Group3Spin->buttonRedo->setIcon(image2);
Group3Spin->TextLabel1->setText(tr("GEOM_SKETCHER_X2"));
Group3Spin->TextLabel2->setText(tr("GEOM_SKETCHER_Y2"));
Group3Spin->TextLabel3->setText(tr("GEOM_SKETCHER_Z2"));
GroupAngles = new EntityGUI_Angles(centralWidget());
GroupAngles->buttonApply->setText(tr("GEOM_SKETCHER_APPLY"));
GroupAngles->buttonUndo->setIcon(image1);
GroupAngles->buttonRedo->setIcon(image2);
GroupAngles->TextLabel1->setText(tr("GEOM_LENGTH"));
GroupAngles->TextLabel2->setText(tr("GEOM_ANGLE"));
GroupAngles->checkBox ->setText(tr("GEOM_ANGLE_2"));
GroupAngles->checkBox_2->setText(tr("GEOM_HEIGHT"));
GroupControls = new EntityGUI_Controls(centralWidget());
GroupControls->GroupBox1->setTitle(tr("GEOM_CONTROLS"));
GroupControls->CheckBox1->setText(tr("GEOM_SHOW_LENGTH"));
GroupControls->CheckBox2->setText(tr("GEOM_SHOW_ANGLE"));
GroupControls->CheckBox3->setText(tr("GEOM_SHOW_POINTS_COORD"));
GroupControls->lineEdit_1->setReadOnly(true);
GroupControls->lineEdit_2->setReadOnly(true);
GroupControls->lineEdit_3->setReadOnly(true);
GroupControls->lineEdit_4->setReadOnly(true);
GroupControls->lineEdit_5->setReadOnly(true);
GroupControls->lineEdit_6->setReadOnly(true);
GroupControls->label_1->setText(tr("X:"));
GroupControls->label_2->setText(tr("Y:"));
GroupControls->label_3->setText(tr("Z:"));
GroupControls->label_4->setText(tr("X:"));
GroupControls->label_5->setText(tr("Y:"));
GroupControls->label_6->setText(tr("Z:"));
GroupControls->label_7->setText(tr("GEOM_START"));
GroupControls->label_8->setText(tr("GEOM_END"));
buttonOk()->setText(tr("GEOM_BUT_END_SKETCH"));
buttonApply()->setText(tr("GEOM_BUT_CLOSE_SKETCH"));
QVBoxLayout* layout = new QVBoxLayout(centralWidget());
layout->setMargin(0); layout->setSpacing(6);
layout->addWidget(GroupType);
layout->addWidget(Group3Spin);
layout->addWidget(GroupAngles);
layout->addWidget(GroupControls);
setHelpFileName("create_3dsketcher_page.html");
resize(100,100);
Init();
}
//=================================================================================
// function : ~EntityGUI_3DSketcherDlg()
// purpose : Destroys the object and frees any allocated resources
//=================================================================================
EntityGUI_3DSketcherDlg::~EntityGUI_3DSketcherDlg()
{
myGeomGUI->SetActiveDialogBox(0);
}
//=================================================================================
// function : Init()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::Init()
{
myOK = false;
myOrientation = OXY;
myPrsType = prsType();
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
myAnglePrs = dynamic_cast<SOCC_Prs*>(((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->CreatePrs(0));
myLengthPrs = dynamic_cast<SOCC_Prs*>(((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->CreatePrs(0));
#if OCC_VERSION_LARGE > 0x06050300
myTextPrs = dynamic_cast<SOCC_Prs*>(((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->CreatePrs(0));
#endif // OCC_VERSION_LARGE > 0x06050300
localSelection(GEOM::GEOM_Object::_nil(), TopAbs_VERTEX);
/* Get setting of step value from file configuration */
double step = SUIT_Session::session()->resourceMgr()->doubleValue("Geometry", "SettingsGeomStep", 100.0);
/* min, max, step and decimals for spin boxes */
initSpinBox(Group3Spin->SpinBox_DX, COORD_MIN, COORD_MAX, step, "length_precision");
initSpinBox(Group3Spin->SpinBox_DY, COORD_MIN, COORD_MAX, step, "length_precision");
initSpinBox(Group3Spin->SpinBox_DZ, COORD_MIN, COORD_MAX, step, "length_precision");
initSpinBox(GroupAngles->SpinBox_DA , -360.0, 360.0, step, "angular_precision");
initSpinBox(GroupAngles->SpinBox_DA2, -90.0, 90.0, step, "angular_precision");
initSpinBox(GroupAngles->SpinBox_DL , COORD_MIN, COORD_MAX, step, "length_precision");
initSpinBox(GroupAngles->SpinBox_DH , COORD_MIN, COORD_MAX, step, "length_precision");
Group3Spin->SpinBox_DX->setValue(0.0);
Group3Spin->SpinBox_DY->setValue(0.0);
Group3Spin->SpinBox_DZ->setValue(0.0);
GroupAngles->SpinBox_DA->setValue(0.0);
GroupAngles->SpinBox_DA2->setValue(0.0);
GroupAngles->SpinBox_DL->setValue(0.0);
GroupAngles->SpinBox_DH->setValue(0.0);
GroupAngles->radioButton_1->setChecked(true);
GroupAngles->checkBox->setChecked(false);
GroupAngles->checkBox_2->setChecked(false);
GroupAngles->SpinBox_DA2->setEnabled(false);
GroupAngles->SpinBox_DH->setEnabled(false);
GroupControls->CheckBox1->setChecked(true);
GroupControls->CheckBox2->setChecked(true);
GroupControls->CheckBox3->setChecked(true);
isLengthVisible = true;
isAngleVisible = true;
GroupAngles->hide();
/* signals and slots connections */
connect(buttonOk(), SIGNAL(clicked()), this, SLOT(ClickOnOk()));
connect(buttonApply(), SIGNAL(clicked()), this, SLOT(ClickOnApply()));
connect(myGeomGUI->getApp()->selectionMgr(), SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
connect(Group3Spin->buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnAddPoint()));
connect(Group3Spin->buttonUndo, SIGNAL(clicked()), this, SLOT(ClickOnUndo()));
connect(Group3Spin->buttonRedo, SIGNAL(clicked()), this, SLOT(ClickOnRedo())) ;
connect(GroupAngles->buttonApply, SIGNAL(clicked()), this, SLOT(ClickOnAddPoint()));
connect(GroupAngles->buttonUndo, SIGNAL(clicked()), this, SLOT(ClickOnUndo()));
connect(GroupAngles->buttonRedo, SIGNAL(clicked()), this, SLOT(ClickOnRedo())) ;
connect(myTypeGroup1, SIGNAL(buttonClicked(int)), this, SLOT(TypeClicked(int)));
connect(myTypeGroup2, SIGNAL(buttonClicked(int)), this, SLOT(TypeClicked(int)));
connect(Group3Spin->SpinBox_DX, SIGNAL(valueChanged(double)), this, SLOT(ValueChangedInSpinBox(double)));
connect(Group3Spin->SpinBox_DY, SIGNAL(valueChanged(double)), this, SLOT(ValueChangedInSpinBox(double)));
connect(Group3Spin->SpinBox_DZ, SIGNAL(valueChanged(double)), this, SLOT(ValueChangedInSpinBox(double)));
connect(GroupAngles->SpinBox_DA, SIGNAL(valueChanged(double)), this, SLOT(ValueChangedInSpinBox(double)));
connect(GroupAngles->SpinBox_DA2, SIGNAL(valueChanged(double)), this, SLOT(ValueChangedInSpinBox(double)));
connect(GroupAngles->SpinBox_DL, SIGNAL(valueChanged(double)), this, SLOT(ValueChangedInSpinBox(double)));
connect(GroupAngles->SpinBox_DH, SIGNAL(valueChanged(double)), this, SLOT(ValueChangedInSpinBox(double)));
connect(GroupAngles->radioButton_1, SIGNAL(clicked (bool)), this, SLOT(ButtonClicked(bool))) ;
connect(GroupAngles->radioButton_2, SIGNAL(clicked (bool)), this, SLOT(ButtonClicked(bool))) ;
connect(GroupAngles->radioButton_3, SIGNAL(clicked (bool)), this, SLOT(ButtonClicked(bool))) ;
connect(GroupAngles->checkBox, SIGNAL(clicked (bool)), this, SLOT(BoxChecked (bool))) ;
connect(GroupAngles->checkBox_2, SIGNAL(clicked (bool)), this, SLOT(BoxChecked (bool))) ;
connect(GroupControls->CheckBox1, SIGNAL(clicked (bool)), this, SLOT(BoxChecked (bool))) ;
connect(GroupControls->CheckBox2, SIGNAL(clicked (bool)), this, SLOT(BoxChecked (bool))) ;
connect(GroupControls->CheckBox3, SIGNAL(clicked (bool)), this, SLOT(BoxChecked (bool))) ;
connect(myGeomGUI, SIGNAL(SignalDefaultStepValueChanged(double)), this, SLOT(SetDoubleSpinBoxStep(double)));
connect(myGeomGUI, SIGNAL(SignalDeactivateActiveDialog()), this, SLOT(DeactivateActiveDialog()));
connect(myGeomGUI, SIGNAL(SignalCloseAllDialogs()), this, SLOT(ClickOnCancel()));
initName(tr("GEOM_3DSKETCHER"));
GroupControls->CheckBox3->click();
UpdateButtonsState();
myMode = 0;
myCoordType = 0;
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : TypeClicked()
// purpose : Radio button management
//=================================================================================
void EntityGUI_3DSketcherDlg::TypeClicked (int id)
{
QButtonGroup* send = (QButtonGroup*) sender();
int coordType = myCoordType;
int mode = myMode;
if (send == myTypeGroup1)
{
if(id == myMode) return;
mode = id;
}
else if (send == myTypeGroup2)
{
if (id == myCoordType) return;
coordType = id;
}
GroupAngles->hide();
Group3Spin->show();
bool blocked = Group3Spin->SpinBox_DX->signalsBlocked();
Group3Spin->SpinBox_DX->blockSignals(true);
Group3Spin->SpinBox_DY->blockSignals(true);
Group3Spin->SpinBox_DZ->blockSignals(true);
// Get setting of step value from file configuration
XYZ xyz = getLastPoint();
bool okx, oky, okz;
Group3Spin->SpinBox_DX->text().toDouble(&okx);
Group3Spin->SpinBox_DY->text().toDouble(&oky);
Group3Spin->SpinBox_DZ->text().toDouble(&okz);
if (coordType == 0) // Cartesian coordinates
{
if (mode == 0) { // XYZ
Group3Spin->TextLabel1->setText(tr("GEOM_SKETCHER_X2"));
Group3Spin->TextLabel2->setText(tr("GEOM_SKETCHER_Y2"));
Group3Spin->TextLabel3->setText(tr("GEOM_SKETCHER_Z2"));
if (myCoordType == 0 && myMode == 1)
{
if (okx) Group3Spin->SpinBox_DX->setValue(xyz.x + Group3Spin->SpinBox_DX->value());
if (oky) Group3Spin->SpinBox_DY->setValue(xyz.y + Group3Spin->SpinBox_DY->value());
if (okz) Group3Spin->SpinBox_DZ->setValue(xyz.z + Group3Spin->SpinBox_DZ->value());
}
Group3Spin->buttonApply->setFocus();
}
else if (mode == 1) { // DXDYDZ
Group3Spin->TextLabel1->setText(tr("GEOM_SKETCHER_DX2"));
Group3Spin->TextLabel2->setText(tr("GEOM_SKETCHER_DY2"));
Group3Spin->TextLabel3->setText(tr("GEOM_SKETCHER_DZ2"));
if (myCoordType == 0 && myMode == 0)
{
if (okx) Group3Spin->SpinBox_DX->setValue(Group3Spin->SpinBox_DX->value() - xyz.x);
if (oky) Group3Spin->SpinBox_DY->setValue(Group3Spin->SpinBox_DY->value() - xyz.y);
if (okz) Group3Spin->SpinBox_DZ->setValue(Group3Spin->SpinBox_DZ->value() - xyz.z);
}
Group3Spin->buttonApply->setFocus();
}
}
else if (coordType == 1) // Angles and Length
{
Group3Spin->hide();
GroupAngles->show();
GroupAngles->buttonApply->setFocus();
}
Group3Spin->SpinBox_DX->blockSignals(blocked);
Group3Spin->SpinBox_DY->blockSignals(blocked);
Group3Spin->SpinBox_DZ->blockSignals(blocked);
myMode = mode;
myCoordType = coordType;
updateGeometry();
resize(minimumSizeHint());
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : ClickOnAddPoint()
// purpose : called when the point coordinates is Applyed
//=================================================================================
void EntityGUI_3DSketcherDlg::ClickOnAddPoint()
{
QString msg;
if (!isValid(msg)) {
showError(msg);
return;
}
myPrsType = prsType();
// if(myMode == 1)
displayDimensions( /*store = */true);
myPointsList.append(getCurrentPoint());
myRedoList.clear();
myLengthIORedoList.Clear();
myAngleIORedoList.Clear();
myTextIORedoList.Clear();
if (myCoordType == 0 && myMode == 1) // RELATIVE CARTESIAN COORDINATES
{
Group3Spin->SpinBox_DX->setValue(0.0);
Group3Spin->SpinBox_DY->setValue(0.0);
Group3Spin->SpinBox_DZ->setValue(0.0);
}
else if (myCoordType == 1 && myMode == 1) // RELATIVE ANGULAR COORDINATES
{
GroupAngles->SpinBox_DA->setValue(0.0);
GroupAngles->SpinBox_DL->setValue(0.0);
GroupAngles->SpinBox_DA2->setValue(0.0);
}
UpdatePointCoordinates();
UpdateButtonsState();
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : UpdateButtonsState()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::UpdateButtonsState()
{
if (myPointsList.count() == 0)
{
GroupType->RadioButton1->click();
GroupType->RadioButton3->click();
}
GroupType->RadioButton2->setEnabled(myPointsList.count() > 0);
// GroupType->RadioButton3->setEnabled(myPointsList.count() > 0);
// GroupType->RadioButton4->setEnabled(myPointsList.count() > 0);
Group3Spin->buttonUndo->setEnabled(myPointsList.count() > 0);
Group3Spin->buttonRedo->setEnabled(myRedoList.count() > 0);
GroupAngles->buttonUndo->setEnabled(myPointsList.count() > 0);
GroupAngles->buttonRedo->setEnabled(myRedoList.count() > 0);
}
//=================================================================================
// function : UpdatePointCoordinates()
// purpose :Update point coordinates in the control groupbox
//=================================================================================
void EntityGUI_3DSketcherDlg::UpdatePointCoordinates()
{
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
int aPrecision = resMgr->integerValue("Geometry", "length_precision", 6);
if (myPointsList.count() == 0)
{
GroupControls->lineEdit_1->setText("");
GroupControls->lineEdit_2->setText("");
GroupControls->lineEdit_3->setText("");
GroupControls->lineEdit_4->setText("");
GroupControls->lineEdit_5->setText("");
GroupControls->lineEdit_6->setText("");
}
else if (myPointsList.count() == 1)
{
GroupControls->lineEdit_1->setText(DlgRef::PrintDoubleValue(getLastPoint().x, aPrecision));
GroupControls->lineEdit_2->setText(DlgRef::PrintDoubleValue(getLastPoint().y, aPrecision));
GroupControls->lineEdit_3->setText(DlgRef::PrintDoubleValue(getLastPoint().z, aPrecision));
GroupControls->lineEdit_4->setText("");
GroupControls->lineEdit_5->setText("");
GroupControls->lineEdit_6->setText("");
}
else
{
GroupControls->lineEdit_4->setText(DlgRef::PrintDoubleValue(getLastPoint().x, aPrecision));
GroupControls->lineEdit_5->setText(DlgRef::PrintDoubleValue(getLastPoint().y, aPrecision));
GroupControls->lineEdit_6->setText(DlgRef::PrintDoubleValue(getLastPoint().z, aPrecision));
}
}
//=================================================================================
// function : ClickOnUndo()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::ClickOnUndo()
{
if (myPointsList.count() > 0) {
myRedoList.append(myPointsList.last());
// Erase dimensions presentations
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myLengthPrs, true);
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myAnglePrs, true);
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myTextPrs, true);
removeLastIOFromPrs();
// Display modified presentation
if (isLengthVisible)
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myLengthPrs);
if (isAngleVisible)
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myAnglePrs);
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myTextPrs);
// Remove last point from list
myPointsList.removeLast();
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
UpdateButtonsState();
// Update of point coordinates in the control groupbox
UpdatePointCoordinates();
updateViewer();
}
}
//=================================================================================
// function : ClickOnRedo()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::ClickOnRedo()
{
if (myRedoList.count() > 0) {
myPointsList.append(myRedoList.last());
// Erase dimensions presentations
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myLengthPrs, true);
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myAnglePrs, true);
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myTextPrs, true);
restoreLastIOToPrs();
// Display modified presentation
if (isLengthVisible)
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myLengthPrs);
if (isAngleVisible)
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myAnglePrs);
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myTextPrs);
// Remove last point from redo list
myRedoList.removeLast();
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
UpdateButtonsState();
// Update of point coordinates in the control groupbox
UpdatePointCoordinates();
updateViewer();
}
}
//=================================================================================
// function : removeLastIO()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::removeLastIOFromPrs ()
{
AIS_ListOfInteractive anIOList;
XYZ Last = getLastPoint();
for (int l = 0; l<Last.L; l++)
{
myLengthPrs->GetObjects(anIOList);
myLengthIORedoList.Prepend(anIOList.First()); // Store last prepended Length IO in redo list
myLengthPrs->RemoveFirst(); // Remove it from myLengthPrs
}
for (int a = 0; a<Last.A; a++)
{
myAnglePrs->GetObjects(anIOList);
myAngleIORedoList.Prepend(anIOList.First()); // Store last prepended Angle IO in redo list
myAnglePrs->RemoveFirst(); // Remove it from myAnglePrs
}
for (int t = 0; t<Last.T; t++)
{
myTextPrs->GetObjects(anIOList);
myTextIORedoList.Prepend(anIOList.First()); // Store last prepended Text IO in redo list
myTextPrs->RemoveFirst(); // Remove it from myTextPrs
}
}
//=================================================================================
// function : restoreLastIO()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::restoreLastIOToPrs ()
{
XYZ LastDeleted = myRedoList.last();
for (int l = 0; l<LastDeleted.L; l++)
{
myLengthPrs->PrependObject(myLengthIORedoList.First()); // Restore last removed IO
myLengthIORedoList.RemoveFirst(); // Remove it from redo list
}
for (int a = 0; a<LastDeleted.A; a++)
{
myAnglePrs->PrependObject(myAngleIORedoList.First()); // Restore last removed IO
myAngleIORedoList.RemoveFirst(); // Remove it from redo list
}
for (int t = 0; t<LastDeleted.T; t++)
{
myTextPrs->PrependObject(myTextIORedoList.First()); // Restore last removed IO
myTextIORedoList.RemoveFirst(); // Remove it from redo list
}
}
//=================================================================================
// function : SelectionIntoArgument()
// purpose : Called when selection as changed
//=================================================================================
void EntityGUI_3DSketcherDlg::SelectionIntoArgument()
{
LightApp_SelectionMgr* aSelMgr = myGeomGUI->getApp()->selectionMgr();
SALOME_ListIO aSelList;
aSelMgr->selectedObjects(aSelList);
int nbSel = aSelList.Extent();
if (nbSel == 1) {
GEOM::GEOM_Object_var aSelectedObject = GEOMBase::ConvertIOinGEOMObject(aSelList.First());
if (!CORBA::is_nil(aSelectedObject)) {
TopoDS_Shape aShape;
if (GEOMBase::GetShape(aSelectedObject, aShape, TopAbs_SHAPE)) {
// Explore the shape if its a local selection
TColStd_IndexedMapOfInteger aMap;
aSelMgr->GetIndexes(aSelList.First(), aMap);
if (aMap.Extent() == 1) {
int anIndex = aMap(1);
GEOM::GEOM_IShapesOperations_var aShapesOp = getGeomEngine()->GetIShapesOperations(getStudyId());
aSelectedObject = aShapesOp->GetSubShape(aSelectedObject, anIndex);
}
}
bool isOk = true;
if (aShape.ShapeType() != TopAbs_VERTEX)
isOk = GEOMBase::GetShape(aSelectedObject, aShape, TopAbs_VERTEX);
if (isOk) {
gp_Pnt aPnt;
if (GEOMBase::VertexToPoint(aShape, aPnt)) {
// set coordinates to the Spin Boxes
double aX, aY, aZ;
aX = aPnt.X();
aY = aPnt.Y();
aZ = aPnt.Z();
bool blocked = Group3Spin->SpinBox_DX->signalsBlocked();
Group3Spin->SpinBox_DX->blockSignals(true);
Group3Spin->SpinBox_DY->blockSignals(true);
Group3Spin->SpinBox_DZ->blockSignals(true);
if (GroupType->RadioButton1->isChecked()) {
Group3Spin->SpinBox_DX->setValue(aX);
Group3Spin->SpinBox_DY->setValue(aY);
Group3Spin->SpinBox_DZ->setValue(aZ);
}
else if (GroupType->RadioButton2->isChecked()) {
XYZ xyz = getLastPoint();
Group3Spin->SpinBox_DX->setValue(aX - xyz.x);
Group3Spin->SpinBox_DY->setValue(aY - xyz.y);
Group3Spin->SpinBox_DZ->setValue(aZ - xyz.z);
}
Group3Spin->SpinBox_DX->blockSignals(blocked);
Group3Spin->SpinBox_DY->blockSignals(blocked);
Group3Spin->SpinBox_DZ->blockSignals(blocked);
}
}
}
}
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : DeactivateActiveDialog()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::DeactivateActiveDialog()
{
setEnabled(false);
globalSelection();
disconnect(myGeomGUI->getApp()->selectionMgr(), 0, this, 0);
myGeomGUI->SetActiveDialogBox(0);
}
//=================================================================================
// function : ActivateThisDialog()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::ActivateThisDialog()
{
myGeomGUI->EmitSignalDeactivateDialog();
setEnabled(true);
myGeomGUI->SetActiveDialogBox(this);
connect(myGeomGUI->getApp()->selectionMgr(),
SIGNAL(currentSelectionChanged()), this, SLOT(SelectionIntoArgument()));
localSelection(GEOM::GEOM_Object::_nil(), TopAbs_VERTEX);
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : ValueChangedInSpinBox()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::ValueChangedInSpinBox (double newValue)
{
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : BoxChecked()
// purpose : ChecBoxes management
//=================================================================================
void EntityGUI_3DSketcherDlg::BoxChecked (bool checked)
{
QCheckBox* send = (QCheckBox*) sender();
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
if (send == GroupAngles->checkBox)
{
GroupAngles->SpinBox_DA2->setEnabled(checked);
if(checked)
{
GroupAngles->SpinBox_DH->setEnabled(false);
GroupAngles->checkBox_2->setChecked(false);
}
}
else if (send == GroupAngles->checkBox_2)
{
GroupAngles->SpinBox_DH->setEnabled(checked);
if(checked)
{
GroupAngles->SpinBox_DA2->setEnabled(false);
GroupAngles->checkBox->setChecked(false);
}
}
else if (send == GroupControls->CheckBox1)
{
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myLengthPrs, true);
if (checked){
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myLengthPrs);
isLengthVisible=true;
}
else
isLengthVisible=false;
}
else if (send == GroupControls->CheckBox2)
{
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myAnglePrs, true);
if (checked)
{
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myAnglePrs);
isAngleVisible=true;
}
else
isAngleVisible=false;
}
else if (send == GroupControls->CheckBox3)
{
GroupControls->lineEdit_1->setVisible(checked);
GroupControls->lineEdit_2->setVisible(checked);
GroupControls->lineEdit_3->setVisible(checked);
GroupControls->lineEdit_4->setVisible(checked);
GroupControls->lineEdit_5->setVisible(checked);
GroupControls->lineEdit_6->setVisible(checked);
GroupControls->label_1->setVisible(checked);
GroupControls->label_2->setVisible(checked);
GroupControls->label_3->setVisible(checked);
GroupControls->label_4->setVisible(checked);
GroupControls->label_5->setVisible(checked);
GroupControls->label_6->setVisible(checked);
GroupControls->label_7->setVisible(checked);
GroupControls->label_8->setVisible(checked);
GroupControls->updateGeometry();
GroupControls->resize(minimumSizeHint());
}
updateGeometry();
resize(minimumSizeHint());
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : ButtonClicked()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::ButtonClicked (bool checked)
{
if (GroupAngles->radioButton_1->isChecked())
myOrientation = OXY;
else if (GroupAngles->radioButton_2->isChecked())
myOrientation = OYZ;
else
myOrientation = OXZ;
GEOMBase_Helper::displayPreview(true, false, true, true, myLineWidth);
}
//=================================================================================
// function : enterEvent()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::enterEvent (QEvent*)
{
if (!mainFrame()->GroupConstructors->isEnabled())
ActivateThisDialog();
}
//=================================================================================
// function : createOperation
// purpose :
//=================================================================================
GEOM::GEOM_IOperations_ptr EntityGUI_3DSketcherDlg::createOperation()
{
return getGeomEngine()->GetICurvesOperations(getStudyId());
}
//=================================================================================
// function : isValid
// purpose :
//=================================================================================
bool EntityGUI_3DSketcherDlg::isValid (QString& msg)
{
bool ok = true;
ok = Group3Spin->SpinBox_DX->isValid(msg, !IsPreview()) && ok;
ok = Group3Spin->SpinBox_DY->isValid(msg, !IsPreview()) && ok;
ok = Group3Spin->SpinBox_DZ->isValid(msg, !IsPreview()) && ok;
return ok;
}
//=================================================================================
// function : execute
// purpose :
//=================================================================================
bool EntityGUI_3DSketcherDlg::execute (ObjectList& objects)
{
//GEOM::ListOfDouble_var aCoordsArray = new GEOM::ListOfDouble;
//if (!myOK || myPointsList.size() == 0)
// aCoordsArray->length((myPointsList.size()+1)*3);
//else
// aCoordsArray->length(myPointsList.size()*3);
QStringList aCommands;
aCommands << "3DSketcher";
QStringList aParameters;
//int i = 0;
QList<XYZ>::const_iterator it;
for (it = myPointsList.begin(); it != myPointsList.end(); ++it) {
//aCoordsArray[i++] = (*it).x;
//aCoordsArray[i++] = (*it).y;
//aCoordsArray[i++] = (*it).z;
aCommands << (*it).command;
aParameters << (*it).params;
}
if (!myOK || myPointsList.size() == 0) {
XYZ xyz = getCurrentPoint();
//aCoordsArray[i++] = xyz.x;
//aCoordsArray[i++] = xyz.y;
//aCoordsArray[i++] = xyz.z;
aCommands << xyz.command;
aParameters << xyz.params;
}
// MESSAGE("aCommands.last() = "<< aCommands.last().toStdString());
GEOM::GEOM_ICurvesOperations_var anOper = GEOM::GEOM_ICurvesOperations::_narrow(getOperation());
//GEOM::GEOM_Object_var anObj = anOper->Make3DSketcher(aCoordsArray);
GEOM::GEOM_Object_var anObj = anOper->Make3DSketcherCommand(aCommands.join(":").toLatin1().constData());
if (!anObj->_is_nil()) {
if (!IsPreview()) anObj->SetParameters(aParameters.join(":").toLatin1().constData());
objects.push_back(anObj._retn());
}
return true;
}
//=================================================================================
// function : SetDoubleSpinBoxStep()
// purpose : Double spin box management
//=================================================================================
void EntityGUI_3DSketcherDlg::SetDoubleSpinBoxStep (double step)
{
Group3Spin->SpinBox_DX->setSingleStep(step);
Group3Spin->SpinBox_DY->setSingleStep(step);
Group3Spin->SpinBox_DZ->setSingleStep(step);
GroupAngles->SpinBox_DA ->setSingleStep(step);
GroupAngles->SpinBox_DA2->setSingleStep(step);
GroupAngles->SpinBox_DL->setSingleStep(step);
GroupAngles->SpinBox_DH->setSingleStep(step);
}
//=================================================================================
// function : ClickOnOk()
// purpose :
//=================================================================================
void EntityGUI_3DSketcherDlg::ClickOnOk()
{
Locker lock(myOK);
if (!onAccept())
return;
ClickOnCancel();
}
//=================================================================================
// function : ClickOnApply()
// purpose :
//=================================================================================
bool EntityGUI_3DSketcherDlg::ClickOnApply()
{
QString msg;
if (!isValid(msg)) {
showError(msg);
return false;
}
if (myPointsList.count() > 0)
myPointsList.append(myPointsList[0]);
Locker lock(myOK);
if (!onAccept())
return false;
ClickOnCancel();
return true;
}
//=================================================================================
// function : getLastPoint()
// purpose : return last points from list
//=================================================================================
EntityGUI_3DSketcherDlg::XYZ EntityGUI_3DSketcherDlg::getLastPoint() const
{
return myPointsList.count() > 0 ? myPointsList.last() : XYZ();
}
//=================================================================================
// function : getPenultimatePoint()
// purpose : return penultimate point from list
//=================================================================================
EntityGUI_3DSketcherDlg::XYZ EntityGUI_3DSketcherDlg::getPenultimatePoint() const
{
double size = myPointsList.count();
return size > 1 ? myPointsList.at(size - 2) : XYZ();
}
//=================================================================================
// function : getCurrentPoint()
// purpose : returns current point
//=================================================================================
EntityGUI_3DSketcherDlg::XYZ EntityGUI_3DSketcherDlg::getCurrentPoint() const
{
XYZ xyz;
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
int aPrecision = resMgr->integerValue("Geometry", "length_precision", 7);
bool spherical = GroupAngles->checkBox->isChecked();
bool cylindrical = GroupAngles->checkBox_2->isChecked();
if (myCoordType == 1)
{
if (GroupAngles->radioButton_1->isChecked())
xyz.command = "OXY";
else if (GroupAngles->radioButton_2->isChecked())
xyz.command = "OYZ";
else
xyz.command = "OXZ";
if (cylindrical) // Cylindrical coordinates (radius, angle, height)
xyz.command += "C";
else
xyz.command += "S"; // Spherical coordinates (radius, angle1, angle2) --> polar if angle2 = 0
if (myMode == 0) // Absolute coordinates
xyz.command += "A ";
else if (myMode == 1) // Relative coordinates
xyz.command += "R ";
double anAngle = GroupAngles->SpinBox_DA->value();
double aLength = GroupAngles->SpinBox_DL->value();
double anAngle2 = 0.0;
QString da2 = "0";
if (spherical) { // Spherical coordinates (radius, angle1, angle2)
anAngle2 = GroupAngles->SpinBox_DA2->value();
da2 = GroupAngles->SpinBox_DA2->text();
}
double aHeight = 0.0;
QString dh = "0";
if (cylindrical) {
aHeight = GroupAngles->SpinBox_DH->value();
dh = GroupAngles->SpinBox_DH->text();
}
xyz.command +=
QString::number(anAngle, 'g', aPrecision) + " ";
xyz.params =
GroupAngles->SpinBox_DA->text() + ":";
if(cylindrical)
{
xyz.command +=
QString::number(aHeight, 'g', aPrecision) + " ";
xyz.params +=
dh + ":";
}
else // Spherical or polar coordinates
{
xyz.command +=
QString::number(anAngle2, 'g', aPrecision) + " ";
xyz.params +=
dh + ":";
}
xyz.command +=
QString::number(aLength, 'g', aPrecision);
xyz.params +=
GroupAngles->SpinBox_DL->text();
// Calculate point coordinates for preview
anAngle = anAngle * M_PI/180.0;
anAngle2 = anAngle2 * M_PI/180.0;
double aProjectedLength = aLength * cos(anAngle2);
XYZ xyzP = getLastPoint();
if (myMode == 0)
xyzP.x=xyzP.y=xyzP.z=0.0;
if (GroupAngles->radioButton_1->isChecked()) // OXY
{
xyz.x = xyzP.x + aProjectedLength * cos(anAngle);
xyz.y = xyzP.y + aProjectedLength * sin(anAngle);
if (cylindrical)
xyz.z = xyzP.z + aHeight;
else
xyz.z = xyzP.z + aLength * sin(anAngle2);
}
else if (GroupAngles->radioButton_2->isChecked()) // OYZ
{
xyz.y = xyzP.y + aProjectedLength * cos(anAngle);
xyz.z = xyzP.z + aProjectedLength * sin(anAngle);
if (cylindrical)
xyz.x = xyzP.x + aHeight;
else
xyz.x = xyzP.x + aLength * sin(anAngle2);
}
else // OXZ
{
xyz.z = xyzP.z + aProjectedLength * sin(anAngle);
xyz.x = xyzP.x + aProjectedLength * cos(anAngle);
if (cylindrical)
xyz.y = xyzP.y + aHeight;
else
xyz.y = xyzP.y + aLength * sin(anAngle2);
}
}
else if(myCoordType == 0) {
if (myMode == 0) { // XYZ
xyz.x = Group3Spin->SpinBox_DX->value();
xyz.y = Group3Spin->SpinBox_DY->value();
xyz.z = Group3Spin->SpinBox_DZ->value();
xyz.command = "TT ";
}
else { // DXDYDZ
xyz = getLastPoint();
xyz.x += Group3Spin->SpinBox_DX->value();
xyz.y += Group3Spin->SpinBox_DY->value();
xyz.z += Group3Spin->SpinBox_DZ->value();
xyz.command = "T ";
}
double aX = Group3Spin->SpinBox_DX->value();
double aY = Group3Spin->SpinBox_DY->value();
double aZ = Group3Spin->SpinBox_DZ->value();
xyz.command +=
QString::number(aX, 'g', aPrecision) + " " +
QString::number(aY, 'g', aPrecision) + " " +
QString::number(aZ, 'g', aPrecision);
xyz.params =
Group3Spin->SpinBox_DX->text() + ":" +
Group3Spin->SpinBox_DY->text() + ":" +
Group3Spin->SpinBox_DZ->text();
}
// Update point presentation type
xyz.A = myPrsType.A; // Number of angle diomensions
xyz.L = myPrsType.L; // Number of length dimensions
xyz.T = myPrsType.T; // Number of text objects
return xyz;
}
//=================================================================================
// function : getPresentationPlane()
// purpose : returns the suitable plane for right
// relative positioning of dimension presentations
//=================================================================================
gp_Dir EntityGUI_3DSketcherDlg::getPresentationPlane() const
{
bool withAngle = (myCoordType == 1);
bool twoAngles = GroupAngles->checkBox->isChecked();
XYZ Last = getLastPoint();
XYZ Current = getCurrentPoint();
XYZ Penultimate = getPenultimatePoint();
gp_Pnt P1 = gp_Pnt(Last.x,Last.y,Last.z);
if (myMode == 0) // Absolute coordinates
P1 = gp::Origin();
gp_Pnt P2 = gp_Pnt(Current.x,Current.y,Current.z);
gp_Pnt P3 = gp_Pnt(Penultimate.x,Penultimate.y,Penultimate.z);
gp_Vec Vec1(P1,P2);
gp_Vec Vec2(P1,P3);
gp_Dir aNormal; // Normal defining the plane of the presentation
if (withAngle) // If one angle
{
// Transformation from the current coordinate system
// to the reference coordinate system
gp_Trsf aTransform = toReferenceSystem (P1);
gp_Dir N1 = gp::DZ();
gp_Dir N2 = gp::DY();
N1.Transform(aTransform);
N2.Transform(aTransform);
if (Vec1.CrossMagnitude(N1) > Precision::Confusion())
{
// The plane is orthogonal to the angle presentation plane
// and contains the current edge
aNormal = N1.Crossed(gp_Dir(Vec1));
}
else
aNormal = N2;
if (twoAngles)
{
gp_Vec V = Vec1.Transformed(aTransform.Inverted());
gp_Vec Vec3(V.X(),V.Y(),0.0);
// Express the coordinates in the refernce coordinate system (OXY)
Vec3.Transform(aTransform);
if(Abs(Vec1.CrossMagnitude(Vec3)) > Precision::Confusion())
{
// set the normal as the cross product of the current edge with its projection
// it ensures that the dimension changes side when the angle becomes negative
aNormal = gp_Dir(Vec1.Crossed(Vec3));
}
}
}
else
{
// Check colinearity
if (Abs(Vec1.CrossMagnitude(Vec2)) < Precision::Confusion())
{
Vec2 = gp_Vec(gp::DX());
if (Abs(Vec1.CrossMagnitude(Vec2)) < Precision::Confusion())
{
Vec2 = gp_Vec(gp::DY());
}
}
// If no angles, the plane is the one formed by the last edge and the current one
aNormal = gp_Dir(Vec1.Crossed(Vec2));
}
return aNormal;
}
//================================================================
// Function : displayPreview
// Purpose : Method for displaying preview of resulting shape
// Redefined from GEOMBase_Helper.
//================================================================
void EntityGUI_3DSketcherDlg::displayPreview (GEOM::GEOM_Object_ptr object,
const bool append,
const bool activate,
const bool update,
const double lineWidth,
const int displayMode,
const int color)
{
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
QColor aColor = resMgr->colorValue("Geometry","line_color",QColor(255,0,0));
Quantity_NameOfColor line_color = SalomeApp_Tools::color(aColor).Name();
// set width of displayed shape
int lw = lineWidth;
if (lw == -1) {
lw = resMgr->integerValue("Geometry", "preview_edge_width", -1);
}
getDisplayer()->SetWidth(lw);
// Disable activation of selection
getDisplayer()->SetToActivate(activate);
// Make a reference to GEOM_Object
CORBA::String_var objStr = myGeometryGUI->getApp()->orb()->object_to_string(object);
getDisplayer()->SetName(objStr.in());
// Create wire from applied object
TopoDS_Shape anApplyedWire, aLastSegment;
if (!createShapes(object, anApplyedWire, aLastSegment))
return;
// Set color for preview shape
getDisplayer()->SetColor(line_color);
// Build prs
SALOME_Prs* aPrs = getDisplayer()->BuildPrs(anApplyedWire);
if (aPrs != 0 && !aPrs->IsNull())
GEOMBase_Helper::displayPreview(aPrs, append, update);
getDisplayer()->SetColor(Quantity_NOC_VIOLET);
aPrs = getDisplayer()->BuildPrs(aLastSegment);
if (aPrs != 0 && !aPrs->IsNull())
GEOMBase_Helper::displayPreview(aPrs, append, update);
getDisplayer()->SetColor(line_color);
// Display local trihedron if the mode is relative
if (myMode == 1)
displayTrihedron(2);
// Display preview of suitable dimension presentations
displayDimensions(false);
getDisplayer()->UnsetName();
// Enable activation of displayed objects
getDisplayer()->SetToActivate(true);
}
//================================================================
// Function : displayTrihedron()
// Purpose : Method for displaying trihedron
//================================================================
void EntityGUI_3DSketcherDlg::displayTrihedron (int selMode)
{
// Add trihedron to preview
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
gp_Pnt P(getLastPoint().x,getLastPoint().y,getLastPoint().z);
Handle(Geom_Axis2Placement) anAxis = new Geom_Axis2Placement(P,gp::DZ(),gp::DX());
Handle(AIS_Trihedron) anIO = new AIS_Trihedron(anAxis);
anIO->SetSelectionMode(selMode);
SOCC_Prs* aSPrs = dynamic_cast<SOCC_Prs*>
(((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->CreatePrs(0));
if (aSPrs) {
aSPrs->PrependObject(anIO);
GEOMBase_Helper::displayPreview(aSPrs, true, true);
}
}
//================================================================
// Function : displayDimensions( bool store )
// Purpose : Method for displaying dimensions. If store = true
// the presentation is stored in a list
//================================================================
void EntityGUI_3DSketcherDlg::displayDimensions (bool store)
{
myPrsType = prsType();
XYZ Last = getLastPoint();
XYZ Current = getCurrentPoint();
gp_Pnt Last_Pnt(Last.x,Last.y,Last.z);
gp_Pnt P0 = Last_Pnt;
gp_Pnt Origin = gp::Origin();
if (myMode == 0) // Absolute coordinates
P0 = Origin;
gp_Pnt Current_Pnt(Current.x,Current.y,Current.z);
gp_Pnt P1, P2;
// Check if last end current point are coincident
if (Last_Pnt.IsEqual(Current_Pnt, 1e-7))
return;
gp_Dir aNormal = getPresentationPlane();
if (myCoordType == 0)
{
bool oneDimensionalMove = (isSame(Last_Pnt.X(), Current_Pnt.X()) &&
isSame(Last_Pnt.Y(), Current_Pnt.Y()) ) ||
(isSame(Last_Pnt.Y(), Current_Pnt.Y()) &&
isSame(Last_Pnt.Z(), Current_Pnt.Z()) ) ||
(isSame(Last_Pnt.X(), Current_Pnt.X()) &&
isSame(Last_Pnt.Z(), Current_Pnt.Z()) );
if (myMode == 0)
{
std::string aCoordText = "( " + doubleToString(Current_Pnt.X()) +
", " + doubleToString(Current_Pnt.Y()) +
", " + doubleToString(Current_Pnt.Z()) + " )";
displayText(aCoordText, Current_Pnt, store);
}
else
{
if (oneDimensionalMove)
{
// For better colocation of dimensions if only one coordinate changes (aNormal is a better choice)
displayLength(P0, Current_Pnt, aNormal, store);
}
else
{
displayLength(gp_Pnt(P0.X(),Current.y,P0.Z()), gp_Pnt(Current.x,Current.y,P0.Z()), gp::DZ().Reversed(), store);
displayLength(gp_Pnt(Current.x,P0.Y(),P0.Z()), gp_Pnt(Current.x,Current.y,P0.Z()), gp::DZ(), store);
displayLength(gp_Pnt(Current.x,Current.y,P0.Z()), Current_Pnt, gp::DX(), store);
}
}
}
else if (myCoordType == 1) // ANGLES
{
bool spherical = GroupAngles->checkBox->isChecked();
bool cylindrical = GroupAngles->checkBox_2->isChecked();
double anAngle1 = GroupAngles->SpinBox_DA->value();
double aLength = GroupAngles->SpinBox_DL->value();
// Set the coordinates in the current coordinate system
P1.SetCoord( aLength, 0.0, 0.0); // X direction
P2.SetCoord( aLength * cos(anAngle1 * M_PI / 180. ),
aLength * sin(anAngle1 * M_PI / 180. ),
0.0);
// Express the coordinates in the refernce coordinate system (OXY)
gp_Trsf aTranform = toReferenceSystem(P0);
P1.Transform(aTranform);
P2.Transform(aTranform);
P1.Translate(Origin, P0);
P2.Translate(Origin, P0);
if(myMode !=0 || !store)
displayAngle(anAngle1, P0, P1, P2, store);
else
{
std::string anAngleText = doubleToString(anAngle1) + " deg.";
displayText(anAngleText, Current_Pnt, store);
}
if(spherical)
{
double anAngle2 = GroupAngles->SpinBox_DA2->value();
displayAngle(anAngle2, P0, P2, Current_Pnt, store);
displayLength(P0, Current_Pnt, aNormal, store);
}
else
{
bool sameRadius = isSame ( radius(Last_Pnt), radius(Current_Pnt) );
bool sameHeight = isSame ( height(Last_Pnt), height(Current_Pnt) );
gp_Vec aVec(P2, Current_Pnt);
if (myMode == 0 && !sameRadius)
{
displayLength(P0.Translated(aVec), P2.Translated(aVec), aNormal, store); // Radius
}
else if (myMode == 1)
displayLength(P0, P2, aNormal, store);
if ( cylindrical &&
(myMode == 1 || !sameHeight) )
displayLength(P2, Current_Pnt, aNormal.Reversed(), store); // Height
}
}
}
//================================================================
// Function : displayAngle()
// Purpose : Method for displaying angle dimensions
//================================================================
void EntityGUI_3DSketcherDlg::displayAngle (double theAngle,
gp_Pnt P0,
gp_Pnt P1,
gp_Pnt P2,
bool store)
{
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
// Creation of the AIS object
Handle(AIS_AngleDimension) anAngleIO = createAISAngleDimension(theAngle,
P0,
P1,
P2);
if (anAngleIO == NULL)
return;
if (store)
{
// Erase dimensions presentations
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myAnglePrs, true);
myAnglePrs->PrependObject(anAngleIO);
// Display modified presentation
if (isAngleVisible)
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myAnglePrs);
// Update dimension presentation angle count for later undo / redo
myPrsType.A += 1;
}
else if ( isAngleVisible)
{
SOCC_Prs* aSPrs = dynamic_cast<SOCC_Prs*>
(((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->CreatePrs(0));
if (aSPrs)
{
aSPrs->AddObject(anAngleIO);
GEOMBase_Helper::displayPreview(aSPrs, true, true);
}
}
}
//================================================================
// Function : displayLength()
// Purpose : Method for displaying length dimensions for a segment
// creation step
//================================================================
void EntityGUI_3DSketcherDlg::displayLength (gp_Pnt P1,
gp_Pnt P2,
gp_Dir theNormal,
bool store)
{
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
double aLength = P1.Distance(P2);
if (aLength < Precision::Confusion())
return;
Handle(AIS_LengthDimension) anIO = createAISLengthDimension(aLength, P1, P2, theNormal);
if (store)
{
// Erase length dimensions presentation
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myLengthPrs, true);
myLengthPrs->PrependObject(anIO);
// Display modified presentation
if (isLengthVisible)
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myLengthPrs);
// Update dimension presentation length count for later undo / redo
myPrsType.L += 1;
}
else if (isLengthVisible)
{
SOCC_Prs* aSPrs = dynamic_cast<SOCC_Prs*>
(((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->CreatePrs(0));
if (aSPrs)
{
aSPrs->PrependObject(anIO);
GEOMBase_Helper::displayPreview(aSPrs, true, true);
}
}
}
//================================================================
// Function : displayText()
// Purpose : Method for displaying length dimensions for a segment
// creation step
//================================================================
void EntityGUI_3DSketcherDlg::displayText ( std::string theText,
gp_Pnt P,
bool store )
{
#if OCC_VERSION_LARGE > 0x06050300
SUIT_ViewWindow* vw = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
Handle(AIS_Text) anIO = new AIS_Text(TCollection_ExtendedString(theText.c_str()), P);
if (store)
{
// Erase length dimensions presentation
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Erase(myTextPrs, true);
myTextPrs->PrependObject(anIO);
// Display modified presentation
((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->Display(myTextPrs);
// Update dimension presentation text count for later undo / redo
myPrsType.T += 1;
}
else
{
SOCC_Prs* aSPrs = dynamic_cast<SOCC_Prs*>
(((SOCC_Viewer*)(vw->getViewManager()->getViewModel()))->CreatePrs(0));
if (aSPrs)
{
aSPrs->PrependObject(anIO);
GEOMBase_Helper::displayPreview(aSPrs, true, true);
}
}
#endif // OCC_VERSION_LARGE > 0x06050300
}
//================================================================
// Function : createAISLengthDimension()
// Purpose : Method for creation of a length dimension object
// Returns an Handle on the AIS_LengthDimension obect
//================================================================
Handle(AIS_LengthDimension) EntityGUI_3DSketcherDlg::createAISLengthDimension(double theLength,
gp_Pnt P1,
gp_Pnt P2,
gp_Dir theNormal)
{
// Convert length to string
std::string aLength_str = doubleToString(theLength);
// Plane construction
gce_MakePln gce_MP(P1, theNormal);
Handle(Geom_Plane) aPlane = new Geom_Plane(gce_MP.Value());
TopoDS_Vertex aVert1 = BRepBuilderAPI_MakeVertex(P1);
TopoDS_Vertex aVert2 = BRepBuilderAPI_MakeVertex(P2);
Handle(AIS_LengthDimension) anIO =
new AIS_LengthDimension(aVert1,
aVert2,
aPlane,
theLength,
TCollection_ExtendedString(aLength_str.c_str()));
anIO->SetArrowSize(theLength/20);
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
int w = resMgr->integerValue("Geometry", "measures_line_width", 1);
Handle(Prs3d_LengthAspect) asp = new Prs3d_LengthAspect();
asp->LineAspect()->SetWidth(w);
anIO->Attributes()->SetLengthAspect(asp);
return anIO;
}
//================================================================
// Function : createAISAngleDimension()
// Purpose : Method for creation of an angle dimension object
// Returns an Handle on the AIS_AngleDimension obect
//================================================================
Handle(AIS_AngleDimension) EntityGUI_3DSketcherDlg::createAISAngleDimension(double theAngle,
gp_Pnt P0,
gp_Pnt P1,
gp_Pnt P2)
{
// Length of the built segment
double aLength = P0.Distance(P1);
// Check input data
if (Abs(theAngle) < Precision::Angular() ||
aLength < Precision::Confusion())
return NULL;
// Convert angles to string
std::string Angle_str = doubleToString(theAngle);
// Construction of the plane
gce_MakePln gce_MP2(P0, P1, P2);
Handle(Geom_Plane) aPlane = new Geom_Plane(gce_MP2.Value());
TopoDS_Vertex V0 = BRepBuilderAPI_MakeVertex(P0);
TopoDS_Vertex V1 = BRepBuilderAPI_MakeVertex(P1);
TopoDS_Vertex V2 = BRepBuilderAPI_MakeVertex(P2);
TopoDS_Edge anEdge1 = BRepBuilderAPI_MakeEdge(V0, V1);
TopoDS_Edge anEdge2 = BRepBuilderAPI_MakeEdge(V0, V2);
Handle(AIS_AngleDimension) anIO =
new AIS_AngleDimension(anEdge1, anEdge2, aPlane, theAngle * M_PI / 180.,
TCollection_ExtendedString(Angle_str.c_str()));
anIO->SetArrowSize((theAngle * M_PI / 180) * (aLength/20));
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
int w = resMgr->integerValue("Geometry", "measures_line_width", 1);
Handle(Prs3d_AngleAspect) asp = new Prs3d_AngleAspect();
asp->LineAspect()->SetWidth(w);
anIO->Attributes()->SetAngleAspect(asp);
return anIO;
}
//================================================================
// Function : createShapes
// Purpose : Create applyed wire, and last segment from entry object
//================================================================
bool EntityGUI_3DSketcherDlg::createShapes (GEOM::GEOM_Object_ptr /*theObject*/,
TopoDS_Shape& theApplyedWire,
TopoDS_Shape& theLastSegment)
{
QList<gp_Pnt> points;
foreach (XYZ xyz, myPointsList) {
gp_Pnt p(xyz.x, xyz.y, xyz.z);
if (points.isEmpty() || points.last().Distance(p) > gp::Resolution())
points << p;
}
if (points.count() == 1) {
// only one point is created
BRepBuilderAPI_MakeVertex mkVertex (points.last());
theApplyedWire = mkVertex.Shape();
}
else if (points.count() > 1) {
// wire is created
BRepBuilderAPI_MakePolygon mkWire;
foreach(gp_Pnt p, points)
mkWire.Add(p);
theApplyedWire = mkWire.Shape();
}
XYZ curxyz = getCurrentPoint();
gp_Pnt curpnt(curxyz.x, curxyz.y, curxyz.z);
if (points.isEmpty() || points.last().Distance(curpnt) <= gp::Resolution()) {
BRepBuilderAPI_MakeVertex mkVertex (curpnt);
theLastSegment = mkVertex.Shape();
}
else {
BRepBuilderAPI_MakeEdge mkEdge(points.last(), curpnt);
theLastSegment = mkEdge.Shape();
}
/* VSR: old algorithm does not work properly, see bug 0020899
TopoDS_Shape aShape;
if (!GEOMBase::GetShape(theObject, aShape))
return false;
if (aShape.ShapeType() != TopAbs_WIRE && aShape.ShapeType() != TopAbs_VERTEX)
return false;
theApplyedWire = aShape;
if (myOK)
return true;
BRepBuilderAPI_MakeWire aBuilder;
TopExp_Explorer edgeExp(aShape, TopAbs_EDGE);
while (1) {
TopoDS_Shape anEdge = edgeExp.Current();
edgeExp.Next();
if (edgeExp.More()) // i.e. non-last edge
aBuilder.Add(TopoDS::Edge(anEdge));
else {
theLastSegment = anEdge;
break;
}
}
if (aBuilder.IsDone()) {
theApplyedWire = aBuilder.Shape();
}
else if (!theLastSegment.IsNull()) {
TopExp_Explorer vertexExp(theLastSegment, TopAbs_VERTEX);
theApplyedWire = vertexExp.Current();
}
*/
return true;
}
//================================================================
// Function : doubleToString
// Purpose : converts double to string
//================================================================
std::string EntityGUI_3DSketcherDlg::doubleToString (double num)
{
// truncate num
int digNum = 5;
char format = 'g'; // truncated to a number of significant digits
return QString::number(num, format, digNum).toStdString();
}
//================================================================
// Function : toReferenceSystem ()
// Purpose :
//================================================================
gp_Trsf EntityGUI_3DSketcherDlg::toReferenceSystem(gp_Pnt origin) const
{
gp_Trsf T; // Identity transformation
gp_Ax3 reference_system; // OXY
reference_system.SetLocation(origin);
gp_Ax3 current_system = reference_system;
switch (myOrientation)
{
case OYZ:
{
current_system = gp_Ax3(origin, gp::DX(), gp::DY());
break;
}
case OXZ:
{
current_system = gp_Ax3(origin, gp::DY().Reversed(), gp::DX());
break;
}
}
T.SetTransformation( current_system, reference_system );
return T;
}
//================================================================
// Function : toCurrentSystem ()
// Purpose :
//================================================================
gp_Trsf EntityGUI_3DSketcherDlg::toCurrentSystem(gp_Pnt origin) const
{
return toReferenceSystem(origin).Inverted();
}
//================================================================
// Function : radius (gp_Pnt) const
// Purpose :
//================================================================
double EntityGUI_3DSketcherDlg::radius (gp_Pnt thePnt) const
{
// Get the point coordinates in the current coordinates system
gp_Trsf aTrsf = toCurrentSystem(gp::Origin());
gp_Pnt aPnt = thePnt.Transformed(aTrsf);
double radius = sqrt(aPnt.X()*aPnt.X() + aPnt.Y()*aPnt.Y());
return radius;
}
//================================================================
// Function : height (gp_Pnt) const
// Purpose :
//================================================================
double EntityGUI_3DSketcherDlg::height (gp_Pnt thePnt) const
{
// Get the point coordinates in the current coordinates system
gp_Trsf aTrsf = toCurrentSystem(gp::Origin());
gp_Pnt aPnt = thePnt.Transformed(aTrsf);
return aPnt.Z();
}
Reference in New Issue View Git Blame Copy Permalink