#include <V3d_Viewer.hxx>
#include <WNT_HIDSpaceMouse.hxx>
+#include <iostream>
+
// =======================================================================
// function : AIS_ViewController
// purpose :
const Handle(V3d_View)& theView,
const AIS_WalkDelta& theWalk)
{
+ std::cout << "handleCameraActions\n";
// apply view actions
if (myGL.Orientation.ToSetViewOrient)
{
myGL.Orientation.ToFitAll = false;
}
+ if (theView->Viewer()->Grid()->IsActive()
+ && theView->Viewer()->GridEcho())
+ {
+ theView->Viewer()->Grid()->Update();
+ }
+
if (myGL.IsNewGesture)
{
if (myAnchorPointPrs1->HasInteractiveContext())
void AIS_ViewController::handleMoveTo (const Handle(AIS_InteractiveContext)& theCtx,
const Handle(V3d_View)& theView)
{
+ std::cout << "handleMoveTo\n";
handleSelectionPick (theCtx, theView);
handleDynamicHighlight(theCtx, theView);
handleSelectionPoly (theCtx, theView);
IMPLEMENT_STANDARD_RTTIEXT(Aspect_Grid,Standard_Transient)
Aspect_Grid::Aspect_Grid (const Standard_Real theXOrigin,
- const Standard_Real theYOrigin,
- const Standard_Real theAngle,
- const Quantity_Color& theColor,
- const Quantity_Color& theTenthColor)
+ const Standard_Real theYOrigin,
+ const Standard_Real theAngle,
+ const Quantity_Color& theColor,
+ const Quantity_Color& theTenthColor)
: myRotationAngle (theAngle),
myXOrigin (theXOrigin),
myYOrigin (theYOrigin),
}
void Aspect_Grid::Translate (const Standard_Real theDx,
- const Standard_Real theDy)
+ const Standard_Real theDy)
{
myXOrigin += theDx;
myYOrigin += theDy;
}
void Aspect_Grid::SetColors (const Quantity_Color& theColor,
- const Quantity_Color& theTenthColor)
+ const Quantity_Color& theTenthColor)
{
myColor = theColor;
myTenthColor = theTenthColor;
}
void Aspect_Grid::Colors (Quantity_Color& theColor,
- Quantity_Color& theTenthColor) const
+ Quantity_Color& theTenthColor) const
{
theColor = myColor;
theTenthColor = myTenthColor;
}
void Aspect_Grid::Hit (const Standard_Real theX,
- const Standard_Real theY,
- Standard_Real& theGridX,
- Standard_Real& theGridY) const
+ const Standard_Real theY,
+ Standard_Real& theGridX,
+ Standard_Real& theGridY) const
{
if (myIsActive)
{
//! Display the grid at screen.
Standard_EXPORT virtual void Display() = 0;
+
+ //!
+ Standard_EXPORT virtual void Update() = 0;
//! Erase the grid from screen.
Standard_EXPORT virtual void Erase() const = 0;
const Standard_Real aFirstAngle,
const Standard_Real aSecondAngle,
const Standard_Real aRotationAngle)
-:Aspect_Grid(anXOrigin,anYOrigin,aRotationAngle),myXStep(aXStep),myYStep(aYStep),myFirstAngle(aFirstAngle),mySecondAngle(aSecondAngle)
-
+: Aspect_Grid (anXOrigin,anYOrigin,aRotationAngle),
+ myXStep (aXStep),
+ myYStep (aYStep),
+ myFirstAngle (aFirstAngle),
+ mySecondAngle (aSecondAngle)
{
- Standard_NumericError_Raise_if(!CheckAngle (aFirstAngle,mySecondAngle),
- "networks are parallel");
-
- Standard_NegativeValue_Raise_if(aXStep < 0. , "invalid x step");
- Standard_NegativeValue_Raise_if(aYStep < 0. , "invalid y step");
- Standard_NullValue_Raise_if(aXStep == 0. , "invalid x step");
- Standard_NullValue_Raise_if(aYStep == 0. , "invalid y step");
+ Standard_NumericError_Raise_if (!CheckAngle (aFirstAngle, mySecondAngle),
+ "networks are parallel");
+ Standard_NegativeValue_Raise_if (aXStep < 0.0, "invalid x step");
+ Standard_NegativeValue_Raise_if (aYStep < 0.0, "invalid y step");
+ Standard_NullValue_Raise_if (aXStep == 0.0, "invalid x step");
+ Standard_NullValue_Raise_if (aYStep == 0.0, "invalid y step");
}
-void Aspect_RectangularGrid::SetXStep(const Standard_Real aStep) {
- Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
- Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
+void Aspect_RectangularGrid::SetXStep (const Standard_Real aStep)
+{
+ Standard_NegativeValue_Raise_if (aStep < 0.0, "invalid x step");
+ Standard_NullValue_Raise_if (aStep == 0.0, "invalid y step");
myXStep = aStep;
Init();
UpdateDisplay();
}
-void Aspect_RectangularGrid::SetYStep(const Standard_Real aStep) {
- Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
- Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
+void Aspect_RectangularGrid::SetYStep (const Standard_Real aStep)
+{
+ Standard_NegativeValue_Raise_if (aStep < 0.0, "invalid x step");
+ Standard_NullValue_Raise_if (aStep == 0.0, "invalid y step");
myYStep = aStep;
Init();
UpdateDisplay();
void Aspect_RectangularGrid::SetAngle (const Standard_Real anAngle1,
const Standard_Real anAngle2)
{
- Standard_NumericError_Raise_if(!CheckAngle (anAngle1,anAngle2 ),
- "axis are parallel");
+ Standard_NumericError_Raise_if (!CheckAngle (anAngle1,anAngle2),
+ "axis are parallel");
myFirstAngle = anAngle1;
mySecondAngle = anAngle2;
Init();
UpdateDisplay();
}
-void Aspect_RectangularGrid::SetGridValues(
- const Standard_Real theXOrigin,
- const Standard_Real theYOrigin,
- const Standard_Real theXStep,
- const Standard_Real theYStep,
- const Standard_Real theRotationAngle) {
-
+void Aspect_RectangularGrid::SetGridValues (
+ const Standard_Real theXOrigin,
+ const Standard_Real theYOrigin,
+ const Standard_Real theXStep,
+ const Standard_Real theYStep,
+ const Standard_Real theRotationAngle)
+{
myXOrigin = theXOrigin;
myYOrigin = theYOrigin;
- Standard_NegativeValue_Raise_if(theXStep < 0. , "invalid x step");
- Standard_NullValue_Raise_if(theXStep == 0. , "invalid x step");
+ Standard_NegativeValue_Raise_if (theXStep < 0.0, "invalid x step");
+ Standard_NullValue_Raise_if (theXStep == 0.0, "invalid x step");
myXStep = theXStep;
- Standard_NegativeValue_Raise_if(theYStep < 0. , "invalid y step");
- Standard_NullValue_Raise_if(theYStep == 0. , "invalid y step");
+ Standard_NegativeValue_Raise_if (theYStep < 0.0, "invalid y step");
+ Standard_NullValue_Raise_if (theYStep == 0.0, "invalid y step");
myYStep = theYStep;
myRotationAngle = theRotationAngle;
Init();
UpdateDisplay();
}
-void Aspect_RectangularGrid::Compute(const Standard_Real X,
- const Standard_Real Y,
- Standard_Real& gridX,
- Standard_Real& gridY) const {
+void Aspect_RectangularGrid::Compute (const Standard_Real X,
+ const Standard_Real Y,
+ Standard_Real& gridX,
+ Standard_Real& gridY) const
+{
Standard_Real D1 = b1 * X - a1 * Y - c1;
Standard_Real D2 = b2 * X - a2 * Y - c2;
- Standard_Integer n1 = Standard_Integer ( Abs(D1)/myXStep + 0.5);
- Standard_Integer n2 = Standard_Integer ( Abs(D2)/myYStep + 0.5);
- Standard_Real offset1 = c1 + Standard_Real(n1) * Sign (myXStep , D1);
- Standard_Real offset2 = c2 + Standard_Real(n2) * Sign (myYStep , D2);
- Standard_Real Delta = a1*b2 - b1*a2;
- gridX = ( offset2*a1 - offset1*a2) /Delta;
- gridY = ( offset2*b1 - offset1*b2) /Delta;
+ Standard_Integer n1 = Standard_Integer (Abs (D1) / myXStep + 0.5);
+ Standard_Integer n2 = Standard_Integer (Abs (D2) / myYStep + 0.5);
+ Standard_Real offset1 = c1 + Standard_Real(n1) * Sign (myXStep, D1);
+ Standard_Real offset2 = c2 + Standard_Real(n2) * Sign (myYStep, D2);
+ Standard_Real Delta = a1 * b2 - b1 * a2;
+ gridX = (offset2 * a1 - offset1 * a2) / Delta;
+ gridY = (offset2 * b1 - offset1 * b2) / Delta;
}
-Standard_Real Aspect_RectangularGrid::XStep() const {
+Standard_Real Aspect_RectangularGrid::XStep() const
+{
return myXStep;
}
-Standard_Real Aspect_RectangularGrid::YStep() const {
+Standard_Real Aspect_RectangularGrid::YStep() const
+{
return myYStep;
}
-Standard_Real Aspect_RectangularGrid::FirstAngle() const {
+Standard_Real Aspect_RectangularGrid::FirstAngle() const
+{
return myFirstAngle;
}
-Standard_Real Aspect_RectangularGrid::SecondAngle() const {
+Standard_Real Aspect_RectangularGrid::SecondAngle() const
+{
return mySecondAngle;
}
-void Aspect_RectangularGrid::Init () {
-
+void Aspect_RectangularGrid::Init()
+{
//+zov Fixing CTS17856
// a1 = Cos (myFirstAngle + RotationAngle() );
// b1 = Sin (myFirstAngle + RotationAngle() );
Standard_Real angle1 = myFirstAngle + RotationAngle();
Standard_Real angle2 = mySecondAngle + RotationAngle();
- if ( angle1 != 0. ) {
- a1 = -Sin (angle1);
+ if (angle1 != 0.0)
+ {
+ a1 = -Sin (angle1);
b1 = Cos (angle1);
c1 = XOrigin() * b1 - YOrigin() * a1;
- } else {
- a1 = 0.; b1 = 1.; c1 = XOrigin();
+ }
+ else
+ {
+ a1 = 0.0;
+ b1 = 1.0;
+ c1 = XOrigin();
}
- if ( angle2 != 0. ) {
- angle2 += M_PI / 2.;
- a2 = -Sin (angle2);
+ if (angle2 != 0.0)
+ {
+ angle2 += M_PI / 2.0;
+ a2 = -Sin (angle2);
b2 = Cos (angle2);
c2 = XOrigin() * b2 - YOrigin() * a2;
- } else {
- a2 = -1.; b2 = 0.; c2 = YOrigin();
+ }
+ else
+ {
+ a2 = -1.0;
+ b2 = 0.0;
+ c2 = YOrigin();
}
//-zov
}
-Standard_Boolean Aspect_RectangularGrid::CheckAngle(const Standard_Real alpha,
- const Standard_Real beta) const {
- return (Abs( Sin(alpha) * Cos(beta + M_PI / 2.) - Cos(alpha) * Sin(beta + M_PI / 2.)) != 0) ;
+Standard_Boolean Aspect_RectangularGrid::CheckAngle (const Standard_Real alpha,
+ const Standard_Real beta) const
+{
+ return (Abs (Sin (alpha) * Cos (beta + M_PI / 2.0) - Cos (alpha) * Sin (beta + M_PI / 2.0)) != 0);
}
//=======================================================================
void V3d_CircularGrid::SetColors (const Quantity_Color& aColor, const Quantity_Color& aTenthColor)
{
- if( myColor != aColor || myTenthColor != aTenthColor ) {
+ if( myColor != aColor || myTenthColor != aTenthColor )
+ {
myColor = aColor;
myTenthColor = aTenthColor;
myCurAreDefined = Standard_False;
}
}
-void V3d_CircularGrid::Display ()
+void V3d_CircularGrid::Display()
{
myStructure->SetDisplayPriority (Graphic3d_DisplayPriority_AlmostBottom);
myStructure->Display();
UpdateDisplay();
}
-void V3d_CircularGrid::Erase () const
+void V3d_CircularGrid::Update()
+{
+ //
+}
+
+void V3d_CircularGrid::Erase() const
{
- myStructure->Erase ();
+ myStructure->Erase();
}
-Standard_Boolean V3d_CircularGrid::IsDisplayed () const
+Standard_Boolean V3d_CircularGrid::IsDisplayed() const
{
- return myStructure->IsDisplayed ();
+ return myStructure->IsDisplayed();
}
-void V3d_CircularGrid::UpdateDisplay ()
+void V3d_CircularGrid::UpdateDisplay()
{
gp_Ax3 ThePlane = myViewer->PrivilegedPlane();
- Standard_Real xl, yl, zl;
+ Standard_Real xl, yl, zl;
Standard_Real xdx, xdy, xdz;
Standard_Real ydx, ydy, ydz;
- Standard_Real dx, dy, dz;
- ThePlane.Location ().Coord (xl, yl, zl);
- ThePlane.XDirection ().Coord (xdx, xdy, xdz);
- ThePlane.YDirection ().Coord (ydx, ydy, ydz);
- ThePlane.Direction ().Coord (dx, dy, dz);
+ Standard_Real dx, dy, dz;
+ ThePlane.Location ().Coord (xl, yl, zl);
+ ThePlane.XDirection().Coord (xdx, xdy, xdz);
+ ThePlane.YDirection().Coord (ydx, ydy, ydz);
+ ThePlane.Direction ().Coord (dx, dy, dz);
Standard_Boolean MakeTransform = !myCurAreDefined;
if (!MakeTransform)
MakeTransform = (RotationAngle() != myCurAngle || XOrigin() != myCurXo || YOrigin() != myCurYo);
if (!MakeTransform)
{
- Standard_Real curxl, curyl, curzl;
+ Standard_Real curxl, curyl, curzl;
Standard_Real curxdx, curxdy, curxdz;
Standard_Real curydx, curydy, curydz;
- Standard_Real curdx, curdy, curdz;
- myCurViewPlane.Location ().Coord (curxl, curyl, curzl);
+ Standard_Real curdx, curdy, curdz;
+ myCurViewPlane.Location ().Coord (curxl, curyl, curzl);
myCurViewPlane.XDirection ().Coord (curxdx, curxdy, curxdz);
myCurViewPlane.YDirection ().Coord (curydx, curydy, curydz);
- myCurViewPlane.Direction ().Coord (curdx, curdy, curdz);
- if (xl != curxl || yl != curyl || zl != curzl ||
+ myCurViewPlane.Direction ().Coord (curdx, curdy, curdz);
+ if (xl != curxl || yl != curyl || zl != curzl ||
xdx != curxdx || xdy != curxdy || xdz != curxdz ||
ydx != curydx || ydy != curydy || ydz != curydz ||
- dx != curdx || dy != curdy || dz != curdz)
+ dx != curdx || dy != curdy || dz != curdz)
+ {
MakeTransform = Standard_True;
+ }
}
}
if (MakeTransform)
{
- const Standard_Real CosAlpha = Cos (RotationAngle ());
- const Standard_Real SinAlpha = Sin (RotationAngle ());
+ const Standard_Real CosAlpha = Cos (RotationAngle());
+ const Standard_Real SinAlpha = Sin (RotationAngle());
gp_Trsf aTrsf;
// Translation
gp_Trsf aTrsf2;
aTrsf2.SetValues ( CosAlpha, SinAlpha, 0.0, -XOrigin(),
-SinAlpha, CosAlpha, 0.0, -YOrigin(),
- 0.0, 0.0, 1.0, 0.0);
+ 0.0, 0.0, 1.0, 0.0 );
aTrsf.Multiply (aTrsf2);
myStructure->SetTransformation (new TopLoc_Datum3D (aTrsf));
- myCurAngle = RotationAngle ();
- myCurXo = XOrigin (), myCurYo = YOrigin ();
+ myCurAngle = RotationAngle();
+ myCurXo = XOrigin();
+ myCurYo = YOrigin();
myCurViewPlane = ThePlane;
}
switch (myDrawMode)
{
case Aspect_GDM_Points:
- DefinePoints ();
+ DefinePoints();
myCurDrawMode = Aspect_GDM_Points;
break;
case Aspect_GDM_Lines:
- DefineLines ();
+ DefineLines();
myCurDrawMode = Aspect_GDM_Lines;
break;
case Aspect_GDM_None:
myCurAreDefined = Standard_True;
}
-void V3d_CircularGrid::DefineLines ()
+void V3d_CircularGrid::DefineLines()
{
- const Standard_Real aStep = RadiusStep ();
- const Standard_Real aDivision = DivisionNumber ();
+ const Standard_Real aStep = RadiusStep();
+ const Standard_Real aDivision = DivisionNumber();
const Standard_Boolean toUpdate = !myCurAreDefined
|| myCurDrawMode != Aspect_GDM_Lines
|| aDivision != myCurDivi
|| aStep != myCurStep;
- if (!toUpdate
- && !myToComputePrs)
+ if (!toUpdate && !myToComputePrs)
{
return;
}
}
myToComputePrs = Standard_False;
- myGroup->Clear ();
+ myGroup->Clear();
- const Standard_Integer Division = (Standard_Integer )( (aDivision >= DIVISION ? aDivision : DIVISION));
+ const Standard_Integer Division = (Standard_Integer )((aDivision >= DIVISION ? aDivision : DIVISION));
Standard_Integer nbpnts = 2 * Division;
// diametres
Standard_Real alpha = M_PI / aDivision;
myGroup->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (myTenthColor, Aspect_TOL_SOLID, 1.0));
- Handle(Graphic3d_ArrayOfSegments) aPrims1 = new Graphic3d_ArrayOfSegments(2*nbpnts);
- const gp_Pnt p0(0., 0., -myOffSet);
- for (Standard_Integer i=1; i<=nbpnts; i++) {
- aPrims1->AddVertex(p0);
- aPrims1->AddVertex(Cos(alpha*i)*myRadius, Sin(alpha*i)*myRadius, -myOffSet);
+ Handle(Graphic3d_ArrayOfSegments) aPrims1 = new Graphic3d_ArrayOfSegments (2 * nbpnts);
+ const gp_Pnt p0 (0.0, 0.0, -myOffSet);
+ for (Standard_Integer i = 1; i <= nbpnts; i++)
+ {
+ aPrims1->AddVertex (p0);
+ aPrims1->AddVertex (Cos (alpha * i) * myRadius, Sin (alpha * i) * myRadius, -myOffSet);
}
- myGroup->AddPrimitiveArray(aPrims1, Standard_False);
+ myGroup->AddPrimitiveArray (aPrims1, Standard_False);
// circles
nbpnts = 2 * Division + 1;
alpha = M_PI / Division;
Standard_Integer nblines = 0;
TColgp_SequenceOfPnt aSeqLines, aSeqTenth;
- for (Standard_Real r=aStep; r<=myRadius; r+=aStep, nblines++) {
- const Standard_Boolean isTenth = (Modulus(nblines, 10) == 0);
- for (Standard_Integer i=0; i<nbpnts; i++) {
- const gp_Pnt pt(Cos(alpha*i)*r,Sin(alpha*i)*r,-myOffSet);
- (isTenth? aSeqTenth : aSeqLines).Append(pt);
+ for (Standard_Real r = aStep; r <= myRadius; r += aStep, nblines++)
+ {
+ const Standard_Boolean isTenth = (Modulus (nblines, 10) == 0);
+ for (Standard_Integer i = 0; i < nbpnts; i++)
+ {
+ const gp_Pnt pt (Cos (alpha * i) * r, Sin (alpha * i) * r, -myOffSet);
+ (isTenth ? aSeqTenth : aSeqLines).Append (pt);
}
}
if (aSeqTenth.Length())
myGroup->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (myTenthColor, Aspect_TOL_SOLID, 1.0));
Standard_Integer n, np;
const Standard_Integer nbl = aSeqTenth.Length() / nbpnts;
- Handle(Graphic3d_ArrayOfPolylines) aPrims2 = new Graphic3d_ArrayOfPolylines(aSeqTenth.Length(),nbl);
- for (np = 1, n=0; n<nbl; n++) {
- aPrims2->AddBound(nbpnts);
- for (Standard_Integer i=0; i<nbpnts; i++, np++)
- aPrims2->AddVertex(aSeqTenth(np));
- }
- myGroup->AddPrimitiveArray(aPrims2, Standard_False);
+ Handle(Graphic3d_ArrayOfPolylines) aPrims2 = new Graphic3d_ArrayOfPolylines (aSeqTenth.Length(), nbl);
+ for (np = 1, n = 0; n < nbl; n++)
+ {
+ aPrims2->AddBound (nbpnts);
+ for (Standard_Integer i = 0; i < nbpnts; i++, np++)
+ {
+ aPrims2->AddVertex (aSeqTenth (np));
+ }
+ }
+ myGroup->AddPrimitiveArray (aPrims2, Standard_False);
}
if (aSeqLines.Length())
{
myGroup->SetPrimitivesAspect (new Graphic3d_AspectLine3d (myColor, Aspect_TOL_SOLID, 1.0));
Standard_Integer n, np;
const Standard_Integer nbl = aSeqLines.Length() / nbpnts;
- Handle(Graphic3d_ArrayOfPolylines) aPrims3 = new Graphic3d_ArrayOfPolylines(aSeqLines.Length(),nbl);
- for (np = 1, n=0; n<nbl; n++) {
+ Handle(Graphic3d_ArrayOfPolylines) aPrims3 = new Graphic3d_ArrayOfPolylines (aSeqLines.Length(), nbl);
+ for (np = 1, n = 0; n < nbl; n++)
+ {
aPrims3->AddBound(nbpnts);
- for (Standard_Integer i=0; i<nbpnts; i++, np++)
- aPrims3->AddVertex(aSeqLines(np));
- }
- myGroup->AddPrimitiveArray(aPrims3, Standard_False);
+ for (Standard_Integer i = 0; i < nbpnts; i++, np++)
+ {
+ aPrims3->AddVertex (aSeqLines (np));
+ }
+ }
+ myGroup->AddPrimitiveArray (aPrims3, Standard_False);
}
myGroup->SetMinMaxValues (-myRadius, -myRadius, -myOffSet, myRadius, myRadius, -myOffSet);
- myCurStep = aStep, myCurDivi = (Standard_Integer ) aDivision;
+ myCurStep = aStep;
+ myCurDivi = (Standard_Integer) aDivision;
// update bounding box
myStructure->CalculateBoundBox();
myViewer->StructureManager()->Update (myStructure->GetZLayer());
}
-void V3d_CircularGrid::DefinePoints ()
+void V3d_CircularGrid::DefinePoints()
{
const Standard_Real aStep = RadiusStep();
const Standard_Real aDivision = DivisionNumber();
|| myCurDrawMode != Aspect_GDM_Points
|| aDivision != myCurDivi
|| aStep != myCurStep;
- if (!toUpdate
- && !myToComputePrs)
+ if (!toUpdate && !myToComputePrs)
{
return;
}
}
myToComputePrs = Standard_False;
- myGroup->Clear ();
+ myGroup->Clear();
- Handle(Graphic3d_AspectMarker3d) MarkerAttrib = new Graphic3d_AspectMarker3d ();
+ Handle(Graphic3d_AspectMarker3d) MarkerAttrib = new Graphic3d_AspectMarker3d();
MarkerAttrib->SetColor (myColor);
MarkerAttrib->SetType (Aspect_TOM_POINT);
- MarkerAttrib->SetScale (3.);
+ MarkerAttrib->SetScale (3.0);
- const Standard_Integer nbpnts = Standard_Integer (2*aDivision);
- Standard_Real r, alpha = M_PI / aDivision;
+ const Standard_Integer nbpnts = Standard_Integer (2 * aDivision);
+ Standard_Real alpha = M_PI / aDivision;
// diameters
TColgp_SequenceOfPnt aSeqPnts;
- aSeqPnts.Append(gp_Pnt(0.0, 0.0, -myOffSet));
- for (r=aStep; r<=myRadius; r+=aStep) {
- for (Standard_Integer i=0; i<nbpnts; i++)
- aSeqPnts.Append(gp_Pnt(Cos(alpha*i)*r, Sin(alpha*i)*r, -myOffSet));
+ aSeqPnts.Append (gp_Pnt (0.0, 0.0, -myOffSet));
+ for (Standard_Real r = aStep; r <= myRadius; r += aStep)
+ {
+ for (Standard_Integer i = 0; i < nbpnts; i++)
+ {
+ aSeqPnts.Append (gp_Pnt (Cos (alpha * i) * r, Sin (alpha * i) * r, -myOffSet));
+ }
}
myGroup->SetGroupPrimitivesAspect (MarkerAttrib);
if (aSeqPnts.Length())
{
Standard_Real X,Y,Z;
const Standard_Integer nbv = aSeqPnts.Length();
- Handle(Graphic3d_ArrayOfPoints) Cercle = new Graphic3d_ArrayOfPoints (nbv);
- for (Standard_Integer i=1; i<=nbv; i++)
+ Handle(Graphic3d_ArrayOfPoints) aCircle = new Graphic3d_ArrayOfPoints (nbv);
+ for (Standard_Integer i = 1; i <= nbv; i++)
{
- aSeqPnts(i).Coord(X,Y,Z);
- Cercle->AddVertex (X,Y,Z);
+ aSeqPnts (i).Coord (X,Y,Z);
+ aCircle->AddVertex (X,Y,Z);
}
- myGroup->AddPrimitiveArray (Cercle, Standard_False);
+ myGroup->AddPrimitiveArray (aCircle, Standard_False);
}
myGroup->SetMinMaxValues (-myRadius, -myRadius, -myOffSet, myRadius, myRadius, -myOffSet);
- myCurStep = aStep, myCurDivi = (Standard_Integer ) aDivision;
+ myCurStep = aStep;
+ myCurDivi = (Standard_Integer) aDivision;
// update bounding box
myStructure->CalculateBoundBox();
void V3d_CircularGrid::SetGraphicValues (const Standard_Real theRadius, const Standard_Real theOffSet)
{
- if (! myCurAreDefined) {
+ if (!myCurAreDefined)
+ {
myRadius = theRadius;
myOffSet = theOffSet;
}
- if (myRadius != theRadius) {
+ if (myRadius != theRadius)
+ {
myRadius = theRadius;
myCurAreDefined = Standard_False;
}
- if (myOffSet != theOffSet) {
+ if (myOffSet != theOffSet)
+ {
myOffSet = theOffSet;
myCurAreDefined = Standard_False;
}
- if( !myCurAreDefined ) UpdateDisplay();
+ if (!myCurAreDefined) { UpdateDisplay(); }
}
//=======================================================================
Standard_EXPORT virtual ~V3d_CircularGrid();
Standard_EXPORT void SetColors (const Quantity_Color& aColor, const Quantity_Color& aTenthColor) Standard_OVERRIDE;
-
+
Standard_EXPORT void Display() Standard_OVERRIDE;
-
+
+ Standard_EXPORT void Update() Standard_OVERRIDE;
+
Standard_EXPORT void Erase() const Standard_OVERRIDE;
-
+
Standard_EXPORT Standard_Boolean IsDisplayed() const Standard_OVERRIDE;
-
+
Standard_EXPORT void GraphicValues (Standard_Real& Radius, Standard_Real& OffSet) const;
-
+
Standard_EXPORT void SetGraphicValues (const Standard_Real Radius, const Standard_Real OffSet);
//! Dumps the content of me into the stream
void V3d_RectangularGrid::SetColors (const Quantity_Color& aColor, const Quantity_Color& aTenthColor)
{
- if( myColor != aColor || myTenthColor != aTenthColor ) {
+ if( myColor != aColor || myTenthColor != aTenthColor )
+ {
myColor = aColor;
myTenthColor = aTenthColor;
myCurAreDefined = Standard_False;
}
}
-void V3d_RectangularGrid::Display ()
+void V3d_RectangularGrid::Display()
{
myStructure->SetDisplayPriority (Graphic3d_DisplayPriority_AlmostBottom);
myStructure->Display();
UpdateDisplay();
}
-void V3d_RectangularGrid::Erase () const
+void V3d_RectangularGrid::Update()
{
- myStructure->Erase ();
+ SetXStep (XStep() + 1);
+ UpdateDisplay();
}
-Standard_Boolean V3d_RectangularGrid::IsDisplayed () const
+void V3d_RectangularGrid::Erase() const
{
- return myStructure->IsDisplayed ();
+ myStructure->Erase();
}
-void V3d_RectangularGrid::UpdateDisplay ()
+Standard_Boolean V3d_RectangularGrid::IsDisplayed() const
{
- gp_Ax3 ThePlane = myViewer->PrivilegedPlane ();
+ return myStructure->IsDisplayed();
+}
+
+void V3d_RectangularGrid::UpdateDisplay()
+{
+ gp_Ax3 ThePlane = myViewer->PrivilegedPlane();
Standard_Boolean MakeTransform = Standard_False;
- Standard_Real xl, yl, zl;
+ Standard_Real xl, yl, zl;
Standard_Real xdx, xdy, xdz;
Standard_Real ydx, ydy, ydz;
- Standard_Real dx, dy, dz;
- ThePlane.Location ().Coord (xl, yl, zl);
- ThePlane.XDirection ().Coord (xdx, xdy, xdz);
- ThePlane.YDirection ().Coord (ydx, ydy, ydz);
- ThePlane.Direction ().Coord (dx, dy, dz);
- if (! myCurAreDefined)
+ Standard_Real dx, dy, dz;
+ ThePlane.Location ().Coord (xl, yl, zl);
+ ThePlane.XDirection().Coord (xdx, xdy, xdz);
+ ThePlane.YDirection().Coord (ydx, ydy, ydz);
+ ThePlane.Direction ().Coord (dx, dy, dz);
+ if (!myCurAreDefined)
+ {
MakeTransform = Standard_True;
- else {
+ }
+ else
+ {
if (RotationAngle() != myCurAngle || XOrigin() != myCurXo || YOrigin() != myCurYo)
+ {
MakeTransform = Standard_True;
- if (! MakeTransform) {
- Standard_Real curxl, curyl, curzl;
+ }
+ if (!MakeTransform)
+ {
+ Standard_Real curxl, curyl, curzl;
Standard_Real curxdx, curxdy, curxdz;
Standard_Real curydx, curydy, curydz;
- Standard_Real curdx, curdy, curdz;
- myCurViewPlane.Location ().Coord (curxl, curyl, curzl);
- myCurViewPlane.XDirection ().Coord (curxdx, curxdy, curxdz);
- myCurViewPlane.YDirection ().Coord (curydx, curydy, curydz);
- myCurViewPlane.Direction ().Coord (curdx, curdy, curdz);
- if (xl != curxl || yl != curyl || zl != curzl ||
+ Standard_Real curdx, curdy, curdz;
+ myCurViewPlane.Location ().Coord (curxl, curyl, curzl);
+ myCurViewPlane.XDirection().Coord (curxdx, curxdy, curxdz);
+ myCurViewPlane.YDirection().Coord (curydx, curydy, curydz);
+ myCurViewPlane.Direction ().Coord (curdx, curdy, curdz);
+ if (xl != curxl || yl != curyl || zl != curzl ||
xdx != curxdx || xdy != curxdy || xdz != curxdz ||
ydx != curydx || ydy != curydy || ydz != curydz ||
- dx != curdx || dy != curdy || dz != curdz)
+ dx != curdx || dy != curdy || dz != curdz)
+ {
MakeTransform = Standard_True;
+ }
}
}
gp_Trsf aTrsf2;
aTrsf2.SetValues ( CosAlpha, SinAlpha, 0.0, -XOrigin(),
-SinAlpha, CosAlpha, 0.0, -YOrigin(),
- 0.0, 0.0, 1.0, 0.0);
+ 0.0, 0.0, 1.0, 0.0 );
aTrsf.Multiply (aTrsf2);
myStructure->SetTransformation (new TopLoc_Datum3D (aTrsf));
- myCurAngle = RotationAngle ();
- myCurXo = XOrigin (), myCurYo = YOrigin ();
+ myCurAngle = RotationAngle();
+ myCurXo = XOrigin();
+ myCurYo = YOrigin();
myCurViewPlane = ThePlane;
}
switch (myDrawMode)
{
case Aspect_GDM_Points:
- DefinePoints ();
+ DefinePoints();
myCurDrawMode = Aspect_GDM_Points;
break;
case Aspect_GDM_Lines:
- DefineLines ();
+ DefineLines();
myCurDrawMode = Aspect_GDM_Lines;
break;
case Aspect_GDM_None:
myCurDrawMode = Aspect_GDM_None;
break;
- }
- myCurAreDefined = Standard_True;
+ }
+ myCurAreDefined = Standard_True;
}
-void V3d_RectangularGrid::DefineLines ()
+void V3d_RectangularGrid::DefineLines()
{
const Standard_Real aXStep = XStep();
const Standard_Real aYStep = YStep();
|| myCurDrawMode != Aspect_GDM_Lines
|| aXStep != myCurXStep
|| aYStep != myCurYStep;
- if (!toUpdate
- && !myToComputePrs)
+ if (!toUpdate && !myToComputePrs)
{
return;
}
TColgp_SequenceOfPnt aSeqLines, aSeqTenth;
// verticals
- aSeqTenth.Append(gp_Pnt(0., -myYSize, -zl));
- aSeqTenth.Append(gp_Pnt(0., myYSize, -zl));
+ aSeqTenth.Append (gp_Pnt (0.0, -myYSize, -zl));
+ aSeqTenth.Append (gp_Pnt (0.0, myYSize, -zl));
for (nblines = 1, xl = aXStep; xl < myXSize; xl += aXStep, nblines++)
{
- TColgp_SequenceOfPnt &aSeq = (Modulus(nblines, 10) != 0)? aSeqLines : aSeqTenth;
- aSeq.Append(gp_Pnt( xl, -myYSize, -zl));
- aSeq.Append(gp_Pnt( xl, myYSize, -zl));
- aSeq.Append(gp_Pnt(-xl, -myYSize, -zl));
- aSeq.Append(gp_Pnt(-xl, myYSize, -zl));
+ TColgp_SequenceOfPnt &aSeq = (Modulus (nblines, 10) != 0) ? aSeqLines : aSeqTenth;
+ aSeq.Append (gp_Pnt ( xl, -myYSize, -zl));
+ aSeq.Append (gp_Pnt ( xl, myYSize, -zl));
+ aSeq.Append (gp_Pnt (-xl, -myYSize, -zl));
+ aSeq.Append (gp_Pnt (-xl, myYSize, -zl));
}
// horizontals
- aSeqTenth.Append(gp_Pnt(-myXSize, 0., -zl));
- aSeqTenth.Append(gp_Pnt( myXSize, 0., -zl));
+ aSeqTenth.Append (gp_Pnt (-myXSize, 0.0, -zl));
+ aSeqTenth.Append (gp_Pnt ( myXSize, 0.0, -zl));
for (nblines = 1, yl = aYStep; yl < myYSize; yl += aYStep, nblines++)
{
- TColgp_SequenceOfPnt &aSeq = (Modulus(nblines, 10) != 0)? aSeqLines : aSeqTenth;
- aSeq.Append(gp_Pnt(-myXSize, yl, -zl));
- aSeq.Append(gp_Pnt( myXSize, yl, -zl));
- aSeq.Append(gp_Pnt(-myXSize, -yl, -zl));
- aSeq.Append(gp_Pnt( myXSize, -yl, -zl));
+ TColgp_SequenceOfPnt &aSeq = (Modulus (nblines, 10) != 0) ? aSeqLines : aSeqTenth;
+ aSeq.Append (gp_Pnt (-myXSize, yl, -zl));
+ aSeq.Append (gp_Pnt ( myXSize, yl, -zl));
+ aSeq.Append (gp_Pnt (-myXSize, -yl, -zl));
+ aSeq.Append (gp_Pnt ( myXSize, -yl, -zl));
}
if (aSeqLines.Length())
Handle(Graphic3d_AspectLine3d) aLineAspect = new Graphic3d_AspectLine3d (myColor, Aspect_TOL_SOLID, 1.0);
myGroup->SetPrimitivesAspect (aLineAspect);
const Standard_Integer nbv = aSeqLines.Length();
- Handle(Graphic3d_ArrayOfSegments) aPrims = new Graphic3d_ArrayOfSegments(nbv);
- Standard_Integer n = 1;
- while (n<=nbv)
- aPrims->AddVertex(aSeqLines(n++));
- myGroup->AddPrimitiveArray(aPrims, Standard_False);
+ Handle(Graphic3d_ArrayOfSegments) aPrims = new Graphic3d_ArrayOfSegments (nbv);
+ for (Standard_Integer n = 1; n <= nbv; n++)
+ {
+ aPrims->AddVertex (aSeqLines (n));
+ }
+ myGroup->AddPrimitiveArray (aPrims, Standard_False);
}
if (aSeqTenth.Length())
{
Handle(Graphic3d_AspectLine3d) aLineAspect = new Graphic3d_AspectLine3d (myTenthColor, Aspect_TOL_SOLID, 1.0);
myGroup->SetPrimitivesAspect (aLineAspect);
const Standard_Integer nbv = aSeqTenth.Length();
- Handle(Graphic3d_ArrayOfSegments) aPrims = new Graphic3d_ArrayOfSegments(nbv);
- Standard_Integer n = 1;
- while (n<=nbv)
- aPrims->AddVertex(aSeqTenth(n++));
- myGroup->AddPrimitiveArray(aPrims, Standard_False);
+ Handle(Graphic3d_ArrayOfSegments) aPrims = new Graphic3d_ArrayOfSegments (nbv);
+ for (Standard_Integer n = 1; n <= nbv; n++)
+ {
+ aPrims->AddVertex (aSeqTenth (n));
+ }
+ myGroup->AddPrimitiveArray (aPrims, Standard_False);
}
- myGroup->SetMinMaxValues(-myXSize, -myYSize, -myOffSet, myXSize, myYSize, -myOffSet);
- myCurXStep = aXStep, myCurYStep = aYStep;
+ myGroup->SetMinMaxValues (-myXSize, -myYSize, -myOffSet, myXSize, myYSize, -myOffSet);
+ myCurXStep = aXStep;
+ myCurYStep = aYStep;
// update bounding box
myStructure->CalculateBoundBox();
myViewer->StructureManager()->Update (myStructure->GetZLayer());
}
-void V3d_RectangularGrid::DefinePoints ()
+void V3d_RectangularGrid::DefinePoints()
{
const Standard_Real aXStep = XStep();
const Standard_Real aYStep = YStep();
// horizontals
Standard_Real xl, yl;
TColgp_SequenceOfPnt aSeqPnts;
- for (xl = 0.0; xl <= myXSize; xl += aXStep) {
- aSeqPnts.Append(gp_Pnt( xl, 0.0, -myOffSet));
- aSeqPnts.Append(gp_Pnt(-xl, 0.0, -myOffSet));
- for (yl = aYStep; yl <= myYSize; yl += aYStep) {
- aSeqPnts.Append(gp_Pnt( xl, yl, -myOffSet));
- aSeqPnts.Append(gp_Pnt( xl, -yl, -myOffSet));
- aSeqPnts.Append(gp_Pnt(-xl, yl, -myOffSet));
- aSeqPnts.Append(gp_Pnt(-xl, -yl, -myOffSet));
+ for (xl = 0.0; xl <= myXSize; xl += aXStep)
+ {
+ aSeqPnts.Append (gp_Pnt ( xl, 0.0, -myOffSet));
+ aSeqPnts.Append (gp_Pnt (-xl, 0.0, -myOffSet));
+ for (yl = aYStep; yl <= myYSize; yl += aYStep)
+ {
+ aSeqPnts.Append (gp_Pnt ( xl, yl, -myOffSet));
+ aSeqPnts.Append (gp_Pnt ( xl, -yl, -myOffSet));
+ aSeqPnts.Append (gp_Pnt (-xl, yl, -myOffSet));
+ aSeqPnts.Append (gp_Pnt (-xl, -yl, -myOffSet));
}
}
if (aSeqPnts.Length())
Standard_Real X,Y,Z;
const Standard_Integer nbv = aSeqPnts.Length();
Handle(Graphic3d_ArrayOfPoints) Vertical = new Graphic3d_ArrayOfPoints (nbv);
- for (i=1; i<=nbv; i++)
+ for (i = 1; i <= nbv; i++)
{
- aSeqPnts(i).Coord(X,Y,Z);
+ aSeqPnts (i).Coord (X,Y,Z);
Vertical->AddVertex (X,Y,Z);
}
myGroup->AddPrimitiveArray (Vertical, Standard_False);
}
- myGroup->SetMinMaxValues(-myXSize, -myYSize, -myOffSet, myXSize, myYSize, -myOffSet);
- myCurXStep = aXStep, myCurYStep = aYStep;
+ myGroup->SetMinMaxValues (-myXSize, -myYSize, -myOffSet, myXSize, myYSize, -myOffSet);
+ myCurXStep = aXStep;
+ myCurYStep = aYStep;
// update bounding box
myStructure->CalculateBoundBox();
void V3d_RectangularGrid::SetGraphicValues (const Standard_Real theXSize, const Standard_Real theYSize, const Standard_Real theOffSet)
{
- if (! myCurAreDefined) {
+ if (! myCurAreDefined)
+ {
myXSize = theXSize;
myYSize = theYSize;
myOffSet = theOffSet;
}
- if (myXSize != theXSize) {
+ if (myXSize != theXSize)
+ {
myXSize = theXSize;
myCurAreDefined = Standard_False;
}
- if (myYSize != theYSize) {
+ if (myYSize != theYSize)
+ {
myYSize = theYSize;
myCurAreDefined = Standard_False;
}
- if (myOffSet != theOffSet) {
+ if (myOffSet != theOffSet)
+ {
myOffSet = theOffSet;
myCurAreDefined = Standard_False;
}
- if( !myCurAreDefined ) UpdateDisplay();
+ if (!myCurAreDefined) { UpdateDisplay(); }
}
//=======================================================================
Standard_EXPORT V3d_RectangularGrid(const V3d_ViewerPointer& aViewer, const Quantity_Color& aColor, const Quantity_Color& aTenthColor);
Standard_EXPORT virtual ~V3d_RectangularGrid();
-
+
Standard_EXPORT virtual void SetColors (const Quantity_Color& aColor, const Quantity_Color& aTenthColor) Standard_OVERRIDE;
-
+
Standard_EXPORT virtual void Display() Standard_OVERRIDE;
-
+
+ Standard_EXPORT virtual void Update() Standard_OVERRIDE;
+
Standard_EXPORT virtual void Erase() const Standard_OVERRIDE;
-
+
Standard_EXPORT virtual Standard_Boolean IsDisplayed() const Standard_OVERRIDE;
-
+
Standard_EXPORT void GraphicValues (Standard_Real& XSize, Standard_Real& YSize, Standard_Real& OffSet) const;
-
+
Standard_EXPORT void SetGraphicValues (const Standard_Real XSize, const Standard_Real YSize, const Standard_Real OffSet);
//! Dumps the content of me into the stream
Standard_EXPORT virtual void DumpJson (Standard_OStream& theOStream, Standard_Integer theDepth = -1) const Standard_OVERRIDE;
protected:
-
+
Standard_EXPORT virtual void UpdateDisplay() Standard_OVERRIDE;
private:
projects / occt.git / commitdiff