Loading files
// Created on: 1991-12-13
// Created by: Christophe MARION
// Copyright (c) 1991-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// **-----------**** Other
// ***-----* IsBefore
// ***------------* IsJustBefore
// ***-----------------* IsOverlappingAtStart
// ***--------------------------* IsJustEnclosingAtEnd
// ***-------------------------------------* IsEnclosing
// ***----* IsJustOverlappingAtStart
// ***-------------* IsSimilar
// ***------------------------* IsJustEnclosingAtStart
// ***-* IsInside
// ***------* IsJustOverlappingAtEnd
// ***-----------------* IsOverlappingAtEnd
// ***--------* IsJustAfter
// ***---* IsAfter
//=================================================================================================
inline double Intrv_Interval::Start() const
{
return myStart;
}
//=================================================================================================
inline double Intrv_Interval::End() const
{
return myEnd;
}
//=================================================================================================
inline float Intrv_Interval::TolStart() const
{
return myTolStart;
}
//=================================================================================================
inline float Intrv_Interval::TolEnd() const
{
return myTolEnd;
}
//=================================================================================================
inline void Intrv_Interval::Bounds(double& Start, float& TolStart, double& End, float& TolEnd) const
{
Start = myStart;
TolStart = myTolStart;
End = myEnd;
TolEnd = myTolEnd;
}
//=================================================================================================
inline void Intrv_Interval::SetStart(const double Start, const float TolStart)
{
myStart = Start;
myTolStart = TolStart;
}
//=======================================================================
// function : FuseAtStart
//
// ****+****--------------------> Old one
// ****+****------------------------> New one to fuse
// <<< <<<
// ****+****------------------------> result
//
//=======================================================================
inline void Intrv_Interval::FuseAtStart(const double Start, const float TolStart)
{
if (myStart != RealFirst())
{
double a = std::min(myStart - myTolStart, Start - TolStart);
double b = std::min(myStart + myTolStart, Start + TolStart);
myStart = (a + b) / 2;
myTolStart = (float)(b - a) / 2;
}
}
//=======================================================================
// function : CutAtStart
//
// ****+****-----------> Old one
// <----------**+** Tool for cutting
// >>> >>>
// ****+****-----------> result
//
//=======================================================================
inline void Intrv_Interval::CutAtStart(const double Start, const float TolStart)
{
if (myStart != RealFirst())
{
double a = std::max(myStart - myTolStart, Start - TolStart);
double b = std::max(myStart + myTolStart, Start + TolStart);
myStart = (a + b) / 2;
myTolStart = (float)(b - a) / 2;
}
}
//=================================================================================================
inline void Intrv_Interval::SetEnd(const double End, const float TolEnd)
{
myEnd = End;
myTolEnd = TolEnd;
}
//=======================================================================
// function : FuseAtEnd
//
// <---------------------****+**** Old one
// <-----------------**+** New one to fuse
// >>> >>>
// <---------------------****+**** result
//
//=======================================================================
inline void Intrv_Interval::FuseAtEnd(const double End, const float TolEnd)
{
if (myEnd != RealLast())
{
double a = std::max(myEnd - myTolEnd, End - TolEnd);
double b = std::max(myEnd + myTolEnd, End + TolEnd);
myEnd = (a + b) / 2;
myTolEnd = (float)(b - a) / 2;
}
}
//=======================================================================
// function : CutAtEnd
//
// <-----****+**** Old one
// **+**------> Tool for cutting
// <<< <<<
// <-----****+**** result
//
//=======================================================================
inline void Intrv_Interval::CutAtEnd(const double End, const float TolEnd)
{
if (myEnd != RealLast())
{
double a = std::min(myEnd - myTolEnd, End - TolEnd);
double b = std::min(myEnd + myTolEnd, End + TolEnd);
myEnd = (a + b) / 2;
myTolEnd = (float)(b - a) / 2;
}
}
//=================================================================================================
inline bool AreFused(const double c1, const float t1, const double c2, const float t2)
{
return t1 + t2 >= std::abs(c1 - c2);
}
//=================================================================================================
inline bool Intrv_Interval::IsProbablyEmpty() const
{
return AreFused(myStart, myTolStart, myEnd, myTolEnd);
}
//=======================================================================
// **-----------**** Other
// ***-----* IsBefore
//=======================================================================
inline bool Intrv_Interval::IsBefore(const Intrv_Interval& Other) const
{
return myTolEnd + Other.myTolStart < Other.myStart - myEnd;
}
//=======================================================================
// **-----------**** Other
// ***---* IsAfter
//=======================================================================
inline bool Intrv_Interval::IsAfter(const Intrv_Interval& Other) const
{
return myTolStart + Other.myTolEnd < myStart - Other.myEnd;
}
//=======================================================================
// **-----------**** Other
// ***-* IsInside
//=======================================================================
inline bool Intrv_Interval::IsInside(const Intrv_Interval& Other) const
{
return myTolStart + Other.myTolStart < myStart - Other.myStart
&& myTolEnd + Other.myTolEnd < Other.myEnd - myEnd;
}
//=======================================================================
// **-----------**** Other
// ***-------------------------------------* IsEnclosing
//=======================================================================
inline bool Intrv_Interval::IsEnclosing(const Intrv_Interval& Other) const
{
return myTolStart + Other.myTolStart < Other.myStart - myStart
&& myTolEnd + Other.myTolEnd < myEnd - Other.myEnd;
}
//=======================================================================
// **-----------**** Other
// ***------------------------* IsJustEnclosingAtStart
//=======================================================================
inline bool Intrv_Interval::IsJustEnclosingAtStart(const Intrv_Interval& Other) const
{
return AreFused(myStart, myTolStart, Other.myStart, Other.myTolStart)
&& myTolEnd + Other.myTolEnd < myEnd - Other.myEnd;
}
//=======================================================================
// **-----------**** Other
// ***--------------------------* IsJustEnclosingAtEnd
//=======================================================================
inline bool Intrv_Interval::IsJustEnclosingAtEnd(const Intrv_Interval& Other) const
{
return myTolStart + Other.myTolStart < Other.myStart - myStart
&& AreFused(Other.myEnd, Other.myTolEnd, myEnd, myTolEnd);
}
//=======================================================================
// **-----------**** Other
// ***------------* IsJustBefore
//=======================================================================
inline bool Intrv_Interval::IsJustBefore(const Intrv_Interval& Other) const
{
return AreFused(myEnd, myTolEnd, Other.myStart, Other.myTolStart);
}
//=======================================================================
// **-----------**** Other
// ***--------* IsJustAfter
//=======================================================================
inline bool Intrv_Interval::IsJustAfter(const Intrv_Interval& Other) const
{
return AreFused(Other.myEnd, Other.myTolEnd, myStart, myTolStart);
}
//=======================================================================
// **-----------**** Other
// ***-----------------* IsOverlappingAtStart
//=======================================================================
inline bool Intrv_Interval::IsOverlappingAtStart(const Intrv_Interval& Other) const
{
return myTolStart + Other.myTolStart < Other.myStart - myStart
&& myTolEnd + Other.myTolStart < myEnd - Other.myStart
&& myTolEnd + Other.myTolEnd < Other.myEnd - myEnd;
}
//=======================================================================
// **-----------**** Other
// ***-----------------* IsOverlappingAtEnd
//=======================================================================
inline bool Intrv_Interval::IsOverlappingAtEnd(const Intrv_Interval& Other) const
{
return myTolStart + Other.myTolStart < myStart - Other.myStart
&& myTolStart + Other.myTolEnd < Other.myEnd - myStart
&& myTolEnd + Other.myTolEnd < myEnd - Other.myEnd;
}
//=======================================================================
// **-----------**** Other
// ***----* IsJustOverlappingAtStart
//=======================================================================
inline bool Intrv_Interval::IsJustOverlappingAtStart(const Intrv_Interval& Other) const
{
return AreFused(myStart, myTolStart, Other.myStart, Other.myTolStart)
&& myTolEnd + Other.myTolEnd < Other.myEnd - myEnd;
}
//=======================================================================
// **-----------**** Other
// ***------* IsJustOverlappingAtEnd
//=======================================================================
inline bool Intrv_Interval::IsJustOverlappingAtEnd(const Intrv_Interval& Other) const
{
return myTolStart + Other.myTolStart < myStart - Other.myStart
&& AreFused(Other.myEnd, Other.myTolEnd, myEnd, myTolEnd);
}
//=======================================================================
// **-----------**** Other
// ***-------------* IsSimilar
//=======================================================================
inline bool Intrv_Interval::IsSimilar(const Intrv_Interval& Other) const
{
bool b1, b2;
b1 = AreFused(myStart, myTolStart, Other.myStart, Other.myTolStart);
b2 = AreFused(myEnd, myTolEnd, Other.myEnd, Other.myTolEnd);
return b1 && b2;
}
f2929057eThis file is pinned to the selected release. Download the original to open it in your design tool.