-- increased by the same amount.
is static;
- Get(me; aXmin, aYmin, aZmin, aXmax, aYmax, aZmax : out Real)
- ---Purpose: Returns the bounds of this bounding box. The gap is included.
- -- If this bounding box is infinite (i.e. "open"), returned values
- -- may be equal to +/- Precision::Infinite().
+ Get (me; theXmin, theYmin, theZmin, theXmax, theYmax, theZmax : out Real)
+ ---Purpose: Returns the bounds of this bounding box. The gap is included.
+ -- If this bounding box is infinite (i.e. "open"), returned values
+ -- may be equal to +/- Precision::Infinite().
+ -- Standard_ConstructionError exception will be thrown if the box is void.
raises ConstructionError -- if IsVoid()
is static;
-
+
+ CornerMin(me) returns Pnt from gp
+ ---Purpose: Returns the lower corner of this bounding box. The gap is included.
+ -- If this bounding box is infinite (i.e. "open"), returned values
+ -- may be equal to +/- Precision::Infinite().
+ -- Standard_ConstructionError exception will be thrown if the box is void.
+ raises ConstructionError -- if IsVoid()
+ is static;
+
+ CornerMax(me) returns Pnt from gp
+ ---Purpose: Returns the upper corner of this bounding box. The gap is included.
+ -- If this bounding box is infinite (i.e. "open"), returned values
+ -- may be equal to +/- Precision::Infinite().
+ -- Standard_ConstructionError exception will be thrown if the box is void.
+ raises ConstructionError -- if IsVoid()
+ is static;
+
OpenXmin(me : in out)
---Purpose: The Box will be infinitely long in the Xmin
-- direction.
//purpose :
//=======================================================================
-void Bnd_Box::Get (Standard_Real& x,
- Standard_Real& y,
- Standard_Real& z,
- Standard_Real& X,
- Standard_Real& Y,
- Standard_Real& Z) const
+void Bnd_Box::Get (Standard_Real& theXmin,
+ Standard_Real& theYmin,
+ Standard_Real& theZmin,
+ Standard_Real& theXmax,
+ Standard_Real& theYmax,
+ Standard_Real& theZmax) const
{
+ if (VoidFlag())
+ {
+ Standard_ConstructionError::Raise ("Bnd_Box is void");
+ }
+
+ if (XminFlag()) theXmin = -Bnd_Precision_Infinite;
+ else theXmin = Xmin - Gap;
+ if (XmaxFlag()) theXmax = Bnd_Precision_Infinite;
+ else theXmax = Xmax + Gap;
+ if (YminFlag()) theYmin = -Bnd_Precision_Infinite;
+ else theYmin = Ymin - Gap;
+ if (YmaxFlag()) theYmax = Bnd_Precision_Infinite;
+ else theYmax = Ymax + Gap;
+ if (ZminFlag()) theZmin = -Bnd_Precision_Infinite;
+ else theZmin = Zmin - Gap;
+ if (ZmaxFlag()) theZmax = Bnd_Precision_Infinite;
+ else theZmax = Zmax + Gap;
+}
+
+//=======================================================================
+//function : CornerMin
+//purpose :
+//=======================================================================
+
+gp_Pnt Bnd_Box::CornerMin() const
+{
+ gp_Pnt aCornerMin;
+ if (VoidFlag())
+ {
+ Standard_ConstructionError::Raise ("Bnd_Box is void");
+ return aCornerMin;
+ }
+ if (XminFlag()) aCornerMin.SetX (-Bnd_Precision_Infinite);
+ else aCornerMin.SetX (Xmin - Gap);
+ if (YminFlag()) aCornerMin.SetY (-Bnd_Precision_Infinite);
+ else aCornerMin.SetY (Ymin - Gap);
+ if (ZminFlag()) aCornerMin.SetZ (-Bnd_Precision_Infinite);
+ else aCornerMin.SetZ (Zmin - Gap);
+ return aCornerMin;
+}
+
+//=======================================================================
+//function : CornerMax
+//purpose :
+//=======================================================================
+
+gp_Pnt Bnd_Box::CornerMax() const
+{
+ gp_Pnt aCornerMax;
if(VoidFlag())
- Standard_ConstructionError::Raise("Bnd_Box is void");
- if (XminFlag()) x = -Bnd_Precision_Infinite;
- else x = Xmin-Gap;
- if (XmaxFlag()) X = Bnd_Precision_Infinite;
- else X = Xmax+Gap;
- if (YminFlag()) y = -Bnd_Precision_Infinite;
- else y = Ymin-Gap;
- if (YmaxFlag()) Y = Bnd_Precision_Infinite;
- else Y = Ymax+Gap;
- if (ZminFlag()) z = -Bnd_Precision_Infinite;
- else z = Zmin-Gap;
- if (ZmaxFlag()) Z = Bnd_Precision_Infinite;
- else Z = Zmax+Gap;
+ {
+ Standard_ConstructionError::Raise ("Bnd_Box is void");
+ return aCornerMax;
+ }
+ if (XmaxFlag()) aCornerMax.SetX (Bnd_Precision_Infinite);
+ else aCornerMax.SetX (Xmax + Gap);
+ if (YminFlag()) aCornerMax.SetY (Bnd_Precision_Infinite);
+ else aCornerMax.SetY (Ymax + Gap);
+ if (ZminFlag()) aCornerMax.SetZ (Bnd_Precision_Infinite);
+ else aCornerMax.SetZ (Zmax + Gap);
+ return aCornerMax;
}
//=======================================================================
WNT,
Image,
gp,
- Font
+ Font,
+ Bnd
is
-----------------------
#include <Standard_Atomic.hxx>
#include <Standard_Assert.hxx>
+#include <NCollection_Sequence.hxx>
+
IMPLEMENT_STANDARD_HANDLE(Graphic3d_Camera, Standard_Transient)
IMPLEMENT_STANDARD_RTTIEXT(Graphic3d_Camera, Standard_Transient)
// should be computed using information on boundaries of primary application actors,
// (e.g. representing the displayed model) - to ensure that they are not unreasonably clipped.
-
- Standard_Real aMinMax[6]; // applicative min max boundaries
- theMinMax.Get (aMinMax[0], aMinMax[1], aMinMax[2], aMinMax[3], aMinMax[4], aMinMax[5]);
-
- Standard_Real aGraphicBB[6]; // real graphical boundaries (not accounting infinite flag).
- theGraphicBB.Get (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2], aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]);
-
- // Check if anything can be adjusted
- Standard_Real aLim = (ShortRealLast() - 1.0);
- if (Abs (aGraphicBB[0]) > aLim || Abs (aGraphicBB[1]) > aLim || Abs (aGraphicBB[2]) > aLim ||
- Abs (aGraphicBB[3]) > aLim || Abs (aGraphicBB[4]) > aLim || Abs (aGraphicBB[5]) > aLim)
+ if (theGraphicBB.IsVoid())
{
// ShortReal precision factor used to add meaningful tolerance to
// ZNear, ZFar values in order to avoid equality after type conversion
}
// Measure depth of boundary points from camera eye
- gp_Pnt aPntsToMeasure[16] =
+ NCollection_Sequence<gp_Pnt> aPntsToMeasure;
+
+ Standard_Real aGraphicBB[6]; // real graphical boundaries (not accounting infinite flag).
+ theGraphicBB.Get (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2], aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]);
+
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2]));
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[5]));
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[2]));
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[5]));
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[2]));
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[5]));
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[2]));
+ aPntsToMeasure.Append (gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]));
+
+ if (!theMinMax.IsVoid() && !theMinMax.IsWhole())
{
- gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[2]),
- gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[5]),
- gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[2]),
- gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[5]),
- gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[2]),
- gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[5]),
- gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[2]),
- gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[5]),
-
- gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2]),
- gp_Pnt (aGraphicBB[0], aGraphicBB[1], aGraphicBB[5]),
- gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[2]),
- gp_Pnt (aGraphicBB[0], aGraphicBB[4], aGraphicBB[5]),
- gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[2]),
- gp_Pnt (aGraphicBB[3], aGraphicBB[1], aGraphicBB[5]),
- gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[2]),
- gp_Pnt (aGraphicBB[3], aGraphicBB[4], aGraphicBB[5])
- };
+ Standard_Real aMinMax[6]; // applicative min max boundaries
+ theMinMax.Get (aMinMax[0], aMinMax[1], aMinMax[2], aMinMax[3], aMinMax[4], aMinMax[5]);
+
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[2]));
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[1], aMinMax[5]));
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[2]));
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[0], aMinMax[4], aMinMax[5]));
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[2]));
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[1], aMinMax[5]));
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[2]));
+ aPntsToMeasure.Append (gp_Pnt (aMinMax[3], aMinMax[4], aMinMax[5]));
+ }
// Camera eye plane
gp_Dir aCamDir = Direction();
const gp_XYZ& anAxialScale = myAxialScale;
// Get minimum and maximum distances to the eye plane
- for (Standard_Integer aPntIt = 0; aPntIt < 16; ++aPntIt)
+ Standard_Integer aCounter = 0;
+ NCollection_Sequence<gp_Pnt>::Iterator aPntIt(aPntsToMeasure);
+ for (; aPntIt.More(); aPntIt.Next())
{
- gp_Pnt aMeasurePnt = aPntsToMeasure[aPntIt];
-
- if (Abs (aMeasurePnt.X()) > aLim || Abs (aMeasurePnt.Y()) > aLim || Abs (aMeasurePnt.Z()) > aLim)
- {
- continue;
- }
+ gp_Pnt aMeasurePnt = aPntIt.Value();
aMeasurePnt = gp_Pnt (aMeasurePnt.X() * anAxialScale.X(),
- aMeasurePnt.Y() * anAxialScale.Y(),
- aMeasurePnt.Z() * anAxialScale.Z());
+ aMeasurePnt.Y() * anAxialScale.Y(),
+ aMeasurePnt.Z() * anAxialScale.Z());
Standard_Real aDistance = aCamPln.Distance (aMeasurePnt);
aDistance *= -1;
}
- Standard_Real& aChangeMinDist = aPntIt >= 8 ? aGraphicMinDist : aModelMinDist;
- Standard_Real& aChangeMaxDist = aPntIt >= 8 ? aGraphicMaxDist : aModelMaxDist;
+ // the first eight points are from theGraphicBB, the last eight points are from theMinMax
+ // (they can be absent).
+ Standard_Real& aChangeMinDist = aCounter >= 8 ? aModelMinDist : aGraphicMinDist;
+ Standard_Real& aChangeMaxDist = aCounter >= 8 ? aModelMaxDist : aGraphicMaxDist;
aChangeMinDist = Min (aDistance, aChangeMinDist);
aChangeMaxDist = Max (aDistance, aChangeMaxDist);
+ aCounter++;
}
// Compute depth of bounding box center
Pnt from gp,
SequenceOfHClipPlane from Graphic3d,
BndBox4f from Graphic3d,
- BndBox4d from Graphic3d
+ BndBox4d from Graphic3d,
+ Box from Bnd
raises
---Purpose: Returns the current group of graphic attributes used
-- for 3d marker primitives.
- MinMaxValues (me;
- theXMin, theYMin, theZMin : out Real from Standard;
- theXMax, theYMax, theZMax : out Real from Standard;
- theToIgnoreInfiniteFlag : Boolean from Standard = Standard_False)
+ MinMaxValues (me; theToIgnoreInfiniteFlag : Boolean from Standard = Standard_False)
+ returns Box from Bnd
is static;
---Level: Public
---Purpose: Returns the coordinates of the boundary box of the structure <me>.
-- of the structure. This approach generally used for application
-- specific fit operation (e.g. fitting the model into screen,
-- not taking into accout infinite helper elements).
- -- Warning: If the structure <me> is empty or infinite then :
- -- theXMin = theYMin = theZMin = RealFirst ().
- -- theXMax = theYMax = theZMax = RealLast ().
+ -- Warning: If the structure <me> is empty then the empty box is returned,
+ -- If the structure <me> is infinite then the whole box is returned.
---Category: Inquire methods
PrimitivesAspect ( me;
//function : MinMaxValues
//purpose :
//=============================================================================
-void Graphic3d_Structure::MinMaxValues (Standard_Real& theXMin,
- Standard_Real& theYMin,
- Standard_Real& theZMin,
- Standard_Real& theXMax,
- Standard_Real& theYMax,
- Standard_Real& theZMax,
- const Standard_Boolean theToIgnoreInfiniteFlag) const
+Bnd_Box Graphic3d_Structure::MinMaxValues (const Standard_Boolean theToIgnoreInfiniteFlag) const
{
Graphic3d_BndBox4d aBox;
+ Bnd_Box aResult;
addTransformed (aBox, theToIgnoreInfiniteFlag);
- if (!aBox.IsValid())
- {
- theXMin = RealFirst();
- theYMin = RealFirst();
- theZMin = RealFirst();
- theXMax = RealLast();
- theYMax = RealLast();
- theZMax = RealLast();
- return;
+ if (aBox.IsValid())
+ {
+ aResult.Add (gp_Pnt (aBox.CornerMin().x(),
+ aBox.CornerMin().y(),
+ aBox.CornerMin().z()));
+ aResult.Add (gp_Pnt (aBox.CornerMax().x(),
+ aBox.CornerMax().y(),
+ aBox.CornerMax().z()));
+
+ Standard_Real aLimMin = ShortRealFirst() + 1.0;
+ Standard_Real aLimMax = ShortRealLast() - 1.0;
+ gp_Pnt aMin = aResult.CornerMin();
+ gp_Pnt aMax = aResult.CornerMax();
+ if (aMin.X() < aLimMin && aMin.Y() < aLimMin && aMin.Z() < aLimMin &&
+ aMax.X() > aLimMax && aMax.Y() > aLimMax && aMax.Z() > aLimMax)
+ {
+ //For structure which infinite in all three dimensions the Whole bounding box will be returned
+ aResult.SetWhole();
+ }
}
-
- theXMin = aBox.CornerMin().x();
- theYMin = aBox.CornerMin().y();
- theZMin = aBox.CornerMin().z();
- theXMax = aBox.CornerMax().x();
- theYMax = aBox.CornerMax().y();
- theZMax = aBox.CornerMax().z();
+ return aResult;
}
//=============================================================================
Standard_Boolean NIS_View::FitAll3d (const Quantity_Coefficient theCoef)
{
- Bnd_B3f aBox = GetBndBox();
+ Bnd_B3f aB3fBox = GetBndBox();
- if (aBox.IsVoid() || MyView->IsDefined() == Standard_False)
+ if (aB3fBox.IsVoid() || MyView->IsDefined() == Standard_False)
{
return Standard_False;
}
- gp_XYZ aMin = aBox.CornerMin();
- gp_XYZ aMax = aBox.CornerMax();
+ Bnd_Box aBox;
+ aBox.Add (gp_Pnt (aB3fBox.CornerMin()));
+ aBox.Add (gp_Pnt (aB3fBox.CornerMax()));
- if (!FitMinMax (myCamera, aMin, aMax, theCoef, 0.0, Standard_False))
+ if (!FitMinMax (myCamera, aBox, theCoef, 0.0, Standard_False))
{
return Standard_False;
}
}
// Take the bounding box of AIS objects displayed in the view
- Standard_Real aVal[6];
- View()->MinMaxValues(aVal[0], aVal[1], aVal[2], aVal[3], aVal[4], aVal[5]);
- if (aVal[3] < 0.5 * RealLast()) {
- aBox.Add (gp_XYZ (aVal[0], aVal[1], aVal[2]));
- aBox.Add (gp_XYZ (aVal[3], aVal[4], aVal[5]));
+ Bnd_Box aVal = View()->MinMaxValues();
+ if (!aVal.IsVoid())
+ {
+ aBox.Add (aVal.CornerMin());
+ aBox.Add (aVal.CornerMax());
}
return aBox;
Image,
gp,
OSD,
- Font
+ Font,
+ Bnd
is
SequenceOfHClipPlane from Graphic3d,
RenderingMode from Graphic3d,
RenderingParams from Graphic3d,
- XYZ from gp
+ XYZ from gp,
+ Box from Bnd
raises
BadValue from V3d, TypeMismatch from Standard,
FitMinMax (me;
theCamera : Camera_Handle from Graphic3d;
- theMinCorner : XYZ from gp;
- theMaxCorner : XYZ from gp;
+ theBox : Box from Bnd;
theMargin : Real from Standard;
theResolution : Real from Standard = 0.0;
theToEnlargeIfLine : Boolean from Standard = Standard_True)
---Purpose: Transform camera eye, center and scale to fit in the
-- passed bounding box specified in WCS.
-- @param theCamera [in] the camera.
- -- @param theMinCorner [in] the minimal corner of bounding box.
- -- @param theMaxCorner [in] the maximal corner of bounding box.
+ -- @param theBox [in] the bounding box.
-- @param theMargin [in] the margin coefficient for view borders.
-- @param theResolution [in] the minimum size of projection of
-- bounding box in Xv or Yv direction when it considered to
return;
}
- Standard_Real aXmin, aYmin, aZmin, aXmax, aYmax, aZmax;
- MyView->MinMaxValues (aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
- gp_XYZ aMin (aXmin, aYmin, aZmin);
- gp_XYZ aMax (aXmax, aYmax, aZmax);
-
- if (!FitMinMax (myCamera, aMin, aMax, theMargin, 10.0 * Precision::Confusion()))
+ if (!FitMinMax (myCamera, MyView->MinMaxValues(), theMargin, 10.0 * Precision::Confusion()))
{
return;
}
return ;
}
- MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
-
- Standard_Real LIM = ShortRealLast() -1.;
- if (Abs(Xmin) > LIM || Abs(Ymin) > LIM || Abs(Zmin) > LIM
- || Abs(Xmax) > LIM || Abs(Ymax) > LIM || Abs(Zmax) > LIM ) {
- ImmediateUpdate();
- return ;
- }
-
- if (Xmin == Xmax && Ymin == Ymax && Zmin == Zmax) {
- ImmediateUpdate();
- return ;
- }
+ Bnd_Box aBox = MyView->MinMaxValues();
+ if (aBox.IsVoid())
+ {
+ ImmediateUpdate();
+ return ;
+ }
+ aBox.Get (Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
MyView->Projects(Xmin,Ymin,Zmin,U,V,W) ;
MyView->Projects(Xmax,Ymax,Zmax,U1,V1,W1) ;
Umin = Min(U,U1) ; Umax = Max(U,U1) ;
Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
if( Nstruct ) {
- MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
+ Bnd_Box aBox = MyView->MinMaxValues();
+ aBox.Get (Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
MyView->Projects(Xmin,Ymin,Zmin,Umin,Vmin,Wmin) ;
MyView->Projects(Xmax,Ymax,Zmax,Umax,Vmax,Wmax) ;
MyView->Projects(Xmin,Ymin,Zmax,U,V,W) ;
Standard_Integer Nstruct = MyView->NumberOfDisplayedStructures() ;
if( Nstruct ) {
- MyView->MinMaxValues(Xmin,Ymin,Zmin,Xmax,Ymax,Zmax) ;
+ Bnd_Box aBox = MyView->MinMaxValues();
+ aBox.Get (Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
}
return Nstruct ;
}
const Handle(Graphic3d_Structure)& aStruct = MyIterator.Key();
if (!aStruct->IsEmpty())
{
- aStruct->MinMaxValues (Xmin, Ymin, Zmin, Xmax, Ymax, Zmax);
+ Bnd_Box aBox = aStruct->MinMaxValues();
// Check bounding box for validness
- Standard_Real aLim = (ShortRealLast() - 1.0);
- if (Abs (Xmin) > aLim || Abs (Ymin) > aLim || Abs (Zmin) > aLim ||
- Abs (Xmax) > aLim || Abs (Ymax) > aLim || Abs (Zmax) > aLim)
+ if (aBox.IsVoid())
{
continue;
}
// use camera projection to find gravity point
+ aBox.Get (Xmin,Ymin,Zmin,Xmax,Ymax,Zmax);
gp_Pnt aPnts[8] = {
gp_Pnt (Xmin, Ymin, Zmin), gp_Pnt (Xmin, Ymin, Zmax),
gp_Pnt (Xmin, Ymax, Zmin), gp_Pnt (Xmin, Ymax, Zmax),
// purpose : Internal
// =======================================================================
Standard_Boolean V3d_View::FitMinMax (const Handle(Graphic3d_Camera)& theCamera,
- const gp_XYZ& theMinCorner,
- const gp_XYZ& theMaxCorner,
+ const Bnd_Box& theBox,
const Standard_Real theMargin,
const Standard_Real theResolution,
const Standard_Boolean theToEnlargeIfLine) const
{
// Check bounding box for validness
- Standard_Real aLim = (ShortRealLast() - 1.0);
- if (Abs (theMinCorner.X()) > aLim || Abs (theMinCorner.Y()) > aLim || Abs (theMinCorner.Z()) > aLim ||
- Abs (theMaxCorner.X()) > aLim || Abs (theMaxCorner.Y()) > aLim || Abs (theMaxCorner.Z()) > aLim)
+ if (theBox.IsVoid())
{
return Standard_False; // bounding box is out of bounds...
}
// option is to perform frustum plane adjustment algorithm in view camera space,
// which will lead to a number of additional world-view space conversions and
// loosing precision as well.
- Standard_Real aXmin = theMinCorner.X() * theCamera->AxialScale().X();
- Standard_Real aXmax = theMaxCorner.X() * theCamera->AxialScale().X();
- Standard_Real aYmin = theMinCorner.Y() * theCamera->AxialScale().Y();
- Standard_Real aYmax = theMaxCorner.Y() * theCamera->AxialScale().Y();
- Standard_Real aZmin = theMinCorner.Z() * theCamera->AxialScale().Z();
- Standard_Real aZmax = theMaxCorner.Z() * theCamera->AxialScale().Z();
+ gp_Pnt aMinCorner = theBox.CornerMin();
+ gp_Pnt aMaxCorner = theBox.CornerMax();
+ Standard_Real aXmin = aMinCorner.X() * theCamera->AxialScale().X();
+ Standard_Real aXmax = aMaxCorner.X() * theCamera->AxialScale().X();
+ Standard_Real aYmin = aMinCorner.Y() * theCamera->AxialScale().Y();
+ Standard_Real aYmax = aMaxCorner.Y() * theCamera->AxialScale().Y();
+ Standard_Real aZmin = aMinCorner.Z() * theCamera->AxialScale().Z();
+ Standard_Real aZmax = aMaxCorner.Z() * theCamera->AxialScale().Z();
Bnd_Box aBBox;
aBBox.Update (aXmin, aYmin, aZmin, aXmax, aYmax, aZmax);
}
case BndAction_Print:
{
- Graphic3d_Vec3d aMin, aMax;
- thePrs->Presentation()->MinMaxValues (aMin.x(), aMin.y(), aMin.z(),
- aMax.x(), aMax.y(), aMax.z());
+ Bnd_Box aBox = thePrs->Presentation()->MinMaxValues();
+ gp_Pnt aMin = aBox.CornerMin();
+ gp_Pnt aMax = aBox.CornerMax();
theDI << theName << "\n"
- << aMin.x() << " " << aMin.y() << " " << aMin.z() << " "
- << aMax.x() << " " << aMax.y() << " " << aMax.z() << "\n";
+ << aMin.X() << " " << aMin.Y() << " " << aMin.Z() << " "
+ << aMax.X() << " " << aMax.Y() << " " << aMax.Z() << "\n";
break;
}
}
MMgt,
WNT,
OSD,
- Font
+ Font,
+ Bnd
is
ExtendedString from TCollection,
CGraduatedTrihedron from Graphic3d,
- PixMap from Image
+ PixMap from Image,
+ Box from Bnd
raises
TransformError from Visual3d,
---Category: Inquire methods
MinMaxValues (me;
- theXMin, theYMin, theZMin : out Real from Standard;
- theXMax, theYMax, theZMax : out Real from Standard;
theToIgnoreInfiniteFlag : Boolean from Standard = Standard_False)
+ returns Box from Bnd
is static;
---Level: Public
---Purpose: Returns the coordinates of the boundary box of all
MinMaxValues (me;
theSet : MapOfStructure from Graphic3d;
- theXMin, theYMin, theZMin : out Real from Standard;
- theXMax, theYMax, theZMax : out Real from Standard;
theToIgnoreInfiniteFlag : Boolean from Standard = Standard_False)
+ returns Box from Bnd
is static;
---Level: Public
---Purpose: Returns the coordinates of the boundary box of all
-- structures in the set <theSet>.
-- If <theToIgnoreInfiniteFlag> is TRUE, then the boundary box
-- also includes minimum and maximum limits of graphical elements
- -- forming parts of infinite structures.
-
- MinMaxValues (me;
- theXMin, theYMin : out Real from Standard;
- theXMax, theYMax : out Real from Standard;
- theToIgnoreInfiniteFlag : Boolean from Standard = Standard_False)
- is static;
- ---Level: Public
- ---Purpose: Returns the coordinates of the projection of the
- -- boundary box of all structures displayed in the view <me>.
- -- If <theToIgnoreInfiniteFlag> is TRUE, then the boundary box
- -- also includes minimum and maximum limits of graphical elements
- -- forming parts of infinite structures.
-
- MinMaxValues (me;
- theSet : MapOfStructure from Graphic3d;
- theXMin, theYMin : out Real from Standard;
- theXMax, theYMax : out Real from Standard;
- theToIgnoreInfiniteFlag : Boolean from Standard = Standard_False)
- is static;
- ---Level: Public
- ---Purpose: Returns the coordinates of the projection of the
- -- boundary box of all structures in the set <ASet>.
- -- If <theToIgnoreInfiniteFlag> is TRUE, then the boundary box
- -- also includes minimum and maximum limits of graphical elements
-- forming parts of infinite structures.
NumberOfDisplayedStructures ( me )
// ========================================================================
void Visual3d_View::ZFitAll (const Standard_Real theScaleFactor)
{
- Standard_Real aMinMax[6]; // applicative min max boundaries
- MinMaxValues (aMinMax[0], aMinMax[1], aMinMax[2],
- aMinMax[3], aMinMax[4], aMinMax[5],
- Standard_False);
-
- Standard_Real aGraphicBB[6]; // real graphical boundaries (not accounting infinite flag).
- MinMaxValues (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2],
- aGraphicBB[3], aGraphicBB[4], aGraphicBB[5],
- Standard_True);
-
- Bnd_Box aMinMaxBox;
- Bnd_Box aGraphicBox;
-
- aMinMaxBox.Update (aMinMax[0], aMinMax[1], aMinMax[2],
- aMinMax[3], aMinMax[4], aMinMax[5]);
-
- aGraphicBox.Update (aGraphicBB[0], aGraphicBB[1], aGraphicBB[2],
- aGraphicBB[3], aGraphicBB[4], aGraphicBB[5]);
+ Bnd_Box aMinMaxBox = MinMaxValues (Standard_False); // applicative min max boundaries
+ Bnd_Box aGraphicBox = MinMaxValues (Standard_True); // real graphical boundaries (not accounting infinite flag).
const Handle(Graphic3d_Camera)& aCamera = MyCView.Context.Camera;
aCamera->ZFitAll (theScaleFactor, aMinMaxBox, aGraphicBox);
// function : MinMaxValues
// purpose :
// ========================================================================
-void Visual3d_View::MinMaxValues (Standard_Real& theXMin,
- Standard_Real& theYMin,
- Standard_Real& theZMin,
- Standard_Real& theXMax,
- Standard_Real& theYMax,
- Standard_Real& theZMax,
- const Standard_Boolean theToIgnoreInfiniteFlag) const
+Bnd_Box Visual3d_View::MinMaxValues (const Standard_Boolean theToIgnoreInfiniteFlag) const
{
- MinMaxValues (myStructsDisplayed,
- theXMin, theYMin, theZMin,
- theXMax, theYMax, theZMax,
- theToIgnoreInfiniteFlag);
+ return MinMaxValues (myStructsDisplayed,
+ theToIgnoreInfiniteFlag);
}
// ========================================================================
// function : MinMaxValues
// purpose :
// ========================================================================
-void Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& theSet,
- Standard_Real& theXMin,
- Standard_Real& theYMin,
- Standard_Real& theZMin,
- Standard_Real& theXMax,
- Standard_Real& theYMax,
- Standard_Real& theZMax,
- const Standard_Boolean theToIgnoreInfiniteFlag) const
+Bnd_Box Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& theSet,
+ const Standard_Boolean theToIgnoreInfiniteFlag) const
{
+ Bnd_Box aResult;
if (theSet.IsEmpty ())
{
- theXMin = RealFirst();
- theYMin = RealFirst();
- theZMin = RealFirst();
-
- theXMax = RealLast();
- theYMax = RealLast();
- theZMax = RealLast();
+ // Return an empty box.
+ return aResult;
}
- else
+ Graphic3d_MapIteratorOfMapOfStructure anIterator (theSet);
+ for (anIterator.Initialize (theSet); anIterator.More(); anIterator.Next())
{
- Standard_Real aXm, aYm, aZm, aXM, aYM, aZM;
- Graphic3d_MapIteratorOfMapOfStructure anIterator (theSet);
-
- theXMin = RealLast();
- theYMin = RealLast();
- theZMin = RealLast();
+ const Handle(Graphic3d_Structure)& aStructure = anIterator.Key();
- theXMax = RealFirst ();
- theYMax = RealFirst ();
- theZMax = RealFirst ();
+ if (!aStructure->IsVisible())
+ continue;
- for (anIterator.Initialize (theSet); anIterator.More(); anIterator.Next())
+ if (aStructure->IsInfinite() && !theToIgnoreInfiniteFlag)
{
- const Handle(Graphic3d_Structure)& aStructure = anIterator.Key();
-
- if (!aStructure->IsVisible())
- continue;
-
- if (aStructure->IsInfinite() && !theToIgnoreInfiniteFlag)
+ //XMin, YMin .... ZMax are initialized by means of infinite line data
+ Bnd_Box aBox = aStructure->MinMaxValues (Standard_False);
+ if (!aBox.IsWhole() && !aBox.IsVoid())
{
- //XMin, YMin .... ZMax are initialized by means of infinite line data
- aStructure->MinMaxValues (aXm, aYm, aZm, aXM, aYM, aZM, Standard_False);
- if (aXm != RealFirst() && aXm < theXMin)
- {
- theXMin = aXm;
- }
- if (aYm != RealFirst() && aYm < theYMin)
- {
- theYMin = aYm;
- }
- if (aZm != RealFirst() && aZm < theZMin)
- {
- theZMin = aZm;
- }
- if (aXM != RealLast() && aXM > theXMax)
- {
- theXMax = aXM;
- }
- if (aYM != RealLast() && aYM > theYMax)
- {
- theYMax = aYM;
- }
- if (aZM != RealLast() && aZM > theZMax)
- {
- theZMax = aZM;
- }
+ aResult.Add (aBox);
}
+ }
- // Only non-empty and non-infinite structures
- // are taken into account for calculation of MinMax
- if ((!aStructure->IsInfinite() || theToIgnoreInfiniteFlag) && !aStructure->IsEmpty())
- {
- aStructure->MinMaxValues (aXm, aYm, aZm, aXM, aYM, aZM, theToIgnoreInfiniteFlag);
+ // Only non-empty and non-infinite structures
+ // are taken into account for calculation of MinMax
+ if ((!aStructure->IsInfinite() || theToIgnoreInfiniteFlag) && !aStructure->IsEmpty())
+ {
+ Bnd_Box aBox = aStructure->MinMaxValues (theToIgnoreInfiniteFlag);
- /* ABD 29/10/04 Transform Persistence of Presentation( pan, zoom, rotate ) */
- //"FitAll" operation ignores object with transform persitence parameter
- if(aStructure->TransformPersistenceMode() == Graphic3d_TMF_None )
- {
- theXMin = Min (aXm, theXMin);
- theYMin = Min (aYm, theYMin);
- theZMin = Min (aZm, theZMin);
- theXMax = Max (aXM, theXMax);
- theYMax = Max (aYM, theYMax);
- theZMax = Max (aZM, theZMax);
- }
+ /* ABD 29/10/04 Transform Persistence of Presentation( pan, zoom, rotate ) */
+ //"FitAll" operation ignores object with transform persitence parameter
+ if(aStructure->TransformPersistenceMode() == Graphic3d_TMF_None )
+ {
+ aResult.Add (aBox);
}
}
-
- // The following cases are relevant
- // For exemple if all structures are empty or infinite
- if (theXMax < theXMin) { aXm = theXMin; theXMin = theXMax; theXMax = aXm; }
- if (theYMax < theYMin) { aYm = theYMin; theYMin = theYMax; theYMax = aYm; }
- if (theZMax < theZMin) { aZm = theZMin; theZMin = theZMax; theZMax = aZm; }
}
-}
-
-// ========================================================================
-// function : MinMaxValues
-// purpose :
-// ========================================================================
-void Visual3d_View::MinMaxValues (Standard_Real& theXMin,
- Standard_Real& theYMin,
- Standard_Real& theXMax,
- Standard_Real& theYMax,
- const Standard_Boolean theToIgnoreInfiniteFlag) const
-{
- MinMaxValues (myStructsDisplayed,
- theXMin, theYMin,
- theXMax, theYMax,
- theToIgnoreInfiniteFlag);
-}
-
-// ========================================================================
-// function : MinMaxValues
-// purpose :
-// ========================================================================
-void Visual3d_View::MinMaxValues (const Graphic3d_MapOfStructure& theSet,
- Standard_Real& theXMin,
- Standard_Real& theYMin,
- Standard_Real& theXMax,
- Standard_Real& theYMax,
- const Standard_Boolean theToIgnoreInfiniteFlag) const
-{
- Standard_Real aXm, aYm, aZm, aXM, aYM, aZM;
- Standard_Real aXp, aYp, aZp;
-
- MinMaxValues (theSet, aXm, aYm, aZm, aXM, aYM, aZM, theToIgnoreInfiniteFlag);
-
- Projects (aXm, aYm, aZm, aXp, aYp, aZp);
- theXMin = aXp;
- theYMin = aYp;
-
- Projects (aXM, aYM, aZM, aXp, aYp, aZp);
- theXMax = aXp;
- theYMax = aYp;
-
- if (theXMax < theXMin) { aXp = theXMax; theXMax = theXMin; theXMin = aXp; }
- if (theYMax < theYMin) { aYp = theYMax; theYMax = theYMin; theYMin = aYp; }
+ return aResult;
}
// =======================================================================
myGraphicDriver->TriedronEcho (MyCView, theType);
}
-static Standard_Boolean checkFloat (const Standard_Real theValue)
-{
- return theValue > -FLT_MAX
- && theValue < FLT_MAX;
-}
-
static void SetMinMaxValuesCallback (Visual3d_View* theView)
{
- Graphic3d_Vec3d aMin, aMax;
- theView->MinMaxValues (aMin.x(), aMin.y(), aMin.z(),
- aMax.x(), aMax.y(), aMax.z());
- if (checkFloat (aMin.x()) && checkFloat (aMin.y()) && checkFloat (aMin.z())
- && checkFloat (aMax.x()) && checkFloat (aMax.y()) && checkFloat (aMax.z()))
+ Bnd_Box aBox = theView->MinMaxValues();
+ if (!aBox.IsVoid())
{
+ gp_Pnt aMin = aBox.CornerMin();
+ gp_Pnt aMax = aBox.CornerMax();
const Handle(Graphic3d_GraphicDriver)& aDriver = theView->GraphicDriver();
- aDriver->GraduatedTrihedronMinMaxValues ((Standard_ShortReal )aMin.x(), (Standard_ShortReal )aMin.y(), (Standard_ShortReal )aMin.z(),
- (Standard_ShortReal )aMax.x(), (Standard_ShortReal )aMax.y(), (Standard_ShortReal )aMax.z());
+ aDriver->GraduatedTrihedronMinMaxValues ((Standard_ShortReal )aMin.X(), (Standard_ShortReal )aMin.Y(), (Standard_ShortReal )aMin.Z(),
+ (Standard_ShortReal )aMax.X(), (Standard_ShortReal )aMax.Y(), (Standard_ShortReal )aMax.Z());
}
}
projects / occt-copy.git / commitdiff