OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-03 17:56:21 +03:00
Code Packages Releases Activity

0027870: Modeling - refactoring of HLR algorithms

Browse Source 
Toolkit 'TKHLR' was fully refactored for 'Standard_Address' and macros except about half of package 'HLRBREP' there 'Standard_Address' is used through the 'generic' mechanism.
This commit is contained in:
abk 2016-10-05 13:49:44 +03:00 committed by apn
parent 4a6d278356
commit 681f3919f0
69 changed files with 2533 additions and 3949 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Contap/Contap_ContAna.cxx
View File

@ -28,7 +28,7 @@
#include <Standard_OutOfRange.hxx>
#include <StdFail_NotDone.hxx>
#define Tolpetit 1.e-8
static const Standard_Real Tolpetit = 1.e-8;
Contap_ContAna::Contap_ContAna (): done(Standard_False) {}

4
src/Contap/Contap_Contour.cxx
View File

@ -44,9 +44,9 @@
#include <TColStd_Array1OfInteger.hxx>
#include <TopTrans_CurveTransition.hxx>
#define Tolpetit 1.e-10 // pour dist au carre
static const Standard_Real Tolpetit = 1.e-10; // pour dist au carre
#define tole 5.e-6
static const Standard_Real tole = 5.e-6;
Contap_Contour::Contap_Contour () :
done(Standard_False),modeset(Standard_False)

2
src/Contap/Contap_SurfFunction.cxx
View File

@ -14,7 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// jag 940616 #define Tolpetit 1.e-16
// jag 940616 Tolpetit = 1.e-16
#include <Adaptor3d_HSurface.hxx>
#include <Adaptor3d_HSurfaceTool.hxx>

2
src/DBRep/DBRep_HideData.cxx
View File

@ -72,7 +72,7 @@ void DBRep_HideData::Set(const Standard_Integer viewID,
HLRAlgo_EdgeStatus status;
for (hider->InitHide(); hider->MoreHide(); hider->NextHide()) {
hider->Hide(Coordinates,status,Sori,reg1,regn,outl,intl);
Coordinates = &hider->Hide(status,Sori,reg1,regn,outl,intl);
dx = PntX2 - PntX1;
dy = PntY2 - PntY1;
dz = PntZ2 - PntZ1;

8
src/HLRAlgo/FILES
View File

@ -6,9 +6,7 @@ HLRAlgo_Array1OfPISeg.hxx
HLRAlgo_Array1OfTData.hxx
HLRAlgo_BiPoint.cxx
HLRAlgo_BiPoint.hxx
HLRAlgo_Coincidence.cxx
HLRAlgo_Coincidence.hxx
HLRAlgo_Coincidence.lxx
HLRAlgo_EdgeIterator.cxx
HLRAlgo_EdgeIterator.hxx
HLRAlgo_EdgeIterator.lxx
@ -36,15 +34,13 @@ HLRAlgo_PolyData.cxx
HLRAlgo_PolyData.hxx
HLRAlgo_PolyData.lxx
HLRAlgo_PolyHidingData.hxx
HLRAlgo_PolyHidingData.lxx
HLRAlgo_PolyInternalData.cxx
HLRAlgo_PolyInternalData.hxx
HLRAlgo_PolyInternalData.lxx
HLRAlgo_PolyInternalNode.cxx
HLRAlgo_PolyInternalNode.hxx
HLRAlgo_PolyInternalNode.lxx
HLRAlgo_PolyInternalSegment.hxx
HLRAlgo_PolyInternalSegment.lxx
HLRAlgo_PolyMask.hxx
HLRAlgo_PolyShellData.cxx
HLRAlgo_PolyShellData.hxx
HLRAlgo_PolyShellData.lxx
@ -52,7 +48,5 @@ HLRAlgo_Projector.cxx
HLRAlgo_Projector.hxx
HLRAlgo_Projector.lxx
HLRAlgo_TriangleData.hxx
HLRAlgo_TriangleData.lxx
HLRAlgo_WiresBlock.cxx
HLRAlgo_WiresBlock.hxx
HLRAlgo_WiresBlock.lxx

228
src/HLRAlgo/HLRAlgo.cxx
View File

@ -40,8 +40,8 @@ static const Standard_Real sinu6 = sin(6.*M_PI/14.);
void HLRAlgo::UpdateMinMax (const Standard_Real x,
const Standard_Real y,
const Standard_Real z,
const Standard_Address Min,
const Standard_Address Max)
Standard_Real Min[16],
Standard_Real Max[16])
{
Standard_Real d[16];
d[ 0] = cosu0 * x + sinu0 * y;
@ -61,12 +61,16 @@ void HLRAlgo::UpdateMinMax (const Standard_Real x,
d[14] = z;
d[15] = z;
Standard_Integer i = 0;
while (i < 16)
for (Standard_Integer i = 0; i < 16; ++i)
{
if (((Standard_Real*)Min)[i] > d[i]) ((Standard_Real*)Min)[i] = d[i];
if (((Standard_Real*)Max)[i] < d[i]) ((Standard_Real*)Max)[i] = d[i];
i++;
if (Min[i] > d[i])
{
Min[i] = d[i];
}
if (Max[i] < d[i])
{
Max[i] = d[i];
}
}
}
@ -76,14 +80,14 @@ void HLRAlgo::UpdateMinMax (const Standard_Real x,
//=======================================================================
void HLRAlgo::EnlargeMinMax (const Standard_Real tol,
const Standard_Address Min,
const Standard_Address Max)
Standard_Real Min[16],
Standard_Real Max[16])
{
Standard_Integer i = 0;
while (i < 16)
{
((Standard_Real*)Min)[i] -= tol;
((Standard_Real*)Max)[i] += tol;
Min[i] -= tol;
Max[i] += tol;
i++;
}
}
@ -94,14 +98,14 @@ void HLRAlgo::EnlargeMinMax (const Standard_Real tol,
//=======================================================================
void HLRAlgo::InitMinMax (const Standard_Real Big,
const Standard_Address Min,
const Standard_Address Max)
Standard_Real Min[16],
Standard_Real Max[16])
{
Standard_Integer i = 0;
while (i < 16)
{
((Standard_Real*)Min)[i] = Big;
((Standard_Real*)Max)[i] = -Big;
Min[i] = Big;
Max[i] = -Big;
i++;
}
}
@ -111,42 +115,42 @@ void HLRAlgo::InitMinMax (const Standard_Real Big,
//purpose :
//=======================================================================
void HLRAlgo::EncodeMinMax (const Standard_Address Min,
const Standard_Address Max,
const Standard_Address MM)
void HLRAlgo::EncodeMinMax (HLRAlgo_EdgesBlock::MinMaxIndices& Min,
HLRAlgo_EdgesBlock::MinMaxIndices& Max,
HLRAlgo_EdgesBlock::MinMaxIndices& MM)
{
((Standard_Integer*)MM)[ 0] = ((Standard_Integer*)Min)[ 1]&0x00007fff;
((Standard_Integer*)MM)[ 8] = ((Standard_Integer*)Max)[ 1]&0x00007fff;
((Standard_Integer*)MM)[ 0]+=(((Standard_Integer*)Min)[ 0]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 8]+=(((Standard_Integer*)Max)[ 0]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 1] = ((Standard_Integer*)Min)[ 3]&0x00007fff;
((Standard_Integer*)MM)[ 9] = ((Standard_Integer*)Max)[ 3]&0x00007fff;
((Standard_Integer*)MM)[ 1]+=(((Standard_Integer*)Min)[ 2]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 9]+=(((Standard_Integer*)Max)[ 2]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 2] = ((Standard_Integer*)Min)[ 5]&0x00007fff;
((Standard_Integer*)MM)[10] = ((Standard_Integer*)Max)[ 5]&0x00007fff;
((Standard_Integer*)MM)[ 2]+=(((Standard_Integer*)Min)[ 4]&0x00007fff)<<16;
((Standard_Integer*)MM)[10]+=(((Standard_Integer*)Max)[ 4]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 3] = ((Standard_Integer*)Min)[ 7]&0x00007fff;
((Standard_Integer*)MM)[11] = ((Standard_Integer*)Max)[ 7]&0x00007fff;
((Standard_Integer*)MM)[ 3]+=(((Standard_Integer*)Min)[ 6]&0x00007fff)<<16;
((Standard_Integer*)MM)[11]+=(((Standard_Integer*)Max)[ 6]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 4] = ((Standard_Integer*)Min)[ 9]&0x00007fff;
((Standard_Integer*)MM)[12] = ((Standard_Integer*)Max)[ 9]&0x00007fff;
((Standard_Integer*)MM)[ 4]+=(((Standard_Integer*)Min)[ 8]&0x00007fff)<<16;
((Standard_Integer*)MM)[12]+=(((Standard_Integer*)Max)[ 8]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 5] = ((Standard_Integer*)Min)[11]&0x00007fff;
((Standard_Integer*)MM)[13] = ((Standard_Integer*)Max)[11]&0x00007fff;
((Standard_Integer*)MM)[ 5]+=(((Standard_Integer*)Min)[10]&0x00007fff)<<16;
((Standard_Integer*)MM)[13]+=(((Standard_Integer*)Max)[10]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 6] = ((Standard_Integer*)Min)[13]&0x00007fff;
((Standard_Integer*)MM)[14] = ((Standard_Integer*)Max)[13]&0x00007fff;
((Standard_Integer*)MM)[ 6]+=(((Standard_Integer*)Min)[12]&0x00007fff)<<16;
((Standard_Integer*)MM)[14]+=(((Standard_Integer*)Max)[12]&0x00007fff)<<16;
((Standard_Integer*)MM)[ 7] = ((Standard_Integer*)Min)[15]&0x00007fff;
((Standard_Integer*)MM)[15] = ((Standard_Integer*)Max)[15]&0x00007fff;
((Standard_Integer*)MM)[ 7]+=(((Standard_Integer*)Min)[14]&0x00007fff)<<16;
((Standard_Integer*)MM)[15]+=(((Standard_Integer*)Max)[14]&0x00007fff)<<16;
MM.Min[0] = Min.Min[1] & 0x00007fff;
MM.Max[0] = Max.Min[1] & 0x00007fff;
MM.Min[0] += (Min.Min[0] & 0x00007fff) << 16;
MM.Max[0] += (Max.Min[0] & 0x00007fff) <<16;
MM.Min[1] = Min.Min[3] & 0x00007fff;
MM.Max[1] = Max.Min[3] & 0x00007fff;
MM.Min[1] += (Min.Min[2] & 0x00007fff) << 16;
MM.Max[1] += (Max.Min[2] & 0x00007fff) << 16;
MM.Min[2] = Min.Min[5] & 0x00007fff;
MM.Max[2] = Max.Min[5] & 0x00007fff;
MM.Min[2] += (Min.Min[4] & 0x00007fff) << 16;
MM.Max[2] += (Max.Min[4] & 0x00007fff) << 16;
MM.Min[3] = Min.Min[7] & 0x00007fff;
MM.Max[3] = Max.Min[7] & 0x00007fff;
MM.Min[3] += (Min.Min[6] & 0x00007fff) << 16;
MM.Max[3] += (Max.Min[6] & 0x00007fff) << 16;
MM.Min[4] = Min.Max[1] & 0x00007fff;
MM.Max[4] = Max.Max[1] & 0x00007fff;
MM.Min[4] += (Min.Max[0] & 0x00007fff) << 16;
MM.Max[4] += (Max.Max[0] & 0x00007fff) << 16;
MM.Min[5] = Min.Max[3] & 0x00007fff;
MM.Max[5] = Max.Max[3] & 0x00007fff;
MM.Min[5] += (Min.Max[2] & 0x00007fff) << 16;
MM.Max[5] += (Max.Max[2] & 0x00007fff) << 16;
MM.Min[6] = Min.Max[5] & 0x00007fff;
MM.Max[6] = Max.Max[5] & 0x00007fff;
MM.Min[6] += (Min.Max[4] & 0x00007fff) << 16;
MM.Max[6] += (Max.Max[4] & 0x00007fff) << 16;
MM.Min[7] = Min.Max[7] & 0x00007fff;
MM.Max[7] = Max.Max[7] & 0x00007fff;
MM.Min[7] += (Min.Max[6] & 0x00007fff) << 16;
MM.Max[7] += (Max.Max[6] & 0x00007fff) << 16;
}
//=======================================================================
@ -154,15 +158,17 @@ void HLRAlgo::EncodeMinMax (const Standard_Address Min,
//purpose :
//=======================================================================
Standard_Real HLRAlgo::SizeBox(const Standard_Address Min,
const Standard_Address Max)
Standard_Real HLRAlgo::SizeBox(HLRAlgo_EdgesBlock::MinMaxIndices& Min,
HLRAlgo_EdgesBlock::MinMaxIndices& Max)
{
Standard_Real s = ((Standard_Integer *)Max)[0] - ((Standard_Integer *)Min)[0];
Standard_Integer i = 1;
while (i < 14)
Standard_Real s = Max.Min[0] - Min.Min[0];
for (Standard_Integer aI = 1; aI < 8; ++aI)
{
s *= ((Standard_Integer *)Max)[i] - ((Standard_Integer *)Min)[i];
i++;
s *= Max.Min[aI] - Min.Min[aI];
}
for (Standard_Integer aI = 0; aI < 6; ++aI)
{
s *= Max.Max[aI] - Min.Max[aI];
}
return s;
}
@ -172,61 +178,42 @@ Standard_Real HLRAlgo::SizeBox(const Standard_Address Min,
//purpose :
//=======================================================================
void HLRAlgo::DecodeMinMax (const Standard_Address MM,
const Standard_Address Min,
const Standard_Address Max)
void HLRAlgo::DecodeMinMax (const HLRAlgo_EdgesBlock::MinMaxIndices& MM,
HLRAlgo_EdgesBlock::MinMaxIndices& Min,
HLRAlgo_EdgesBlock::MinMaxIndices& Max)
{
((Standard_Integer*)Min)[ 0]=(((Standard_Integer*)MM)[ 0]&0x7fff0000)>>16;
((Standard_Integer*)Max)[ 0]=(((Standard_Integer*)MM)[ 8]&0x7fff0000)>>16;
((Standard_Integer*)Min)[ 1]= ((Standard_Integer*)MM)[ 0]&0x00007fff;
((Standard_Integer*)Max)[ 1]= ((Standard_Integer*)MM)[ 8]&0x00007fff;
((Standard_Integer*)Min)[ 2]=(((Standard_Integer*)MM)[ 1]&0x7fff0000)>>16;
((Standard_Integer*)Max)[ 2]=(((Standard_Integer*)MM)[ 9]&0x7fff0000)>>16;
((Standard_Integer*)Min)[ 3]= ((Standard_Integer*)MM)[ 1]&0x00007fff;
((Standard_Integer*)Max)[ 3]= ((Standard_Integer*)MM)[ 9]&0x00007fff;
((Standard_Integer*)Min)[ 4]=(((Standard_Integer*)MM)[ 2]&0x7fff0000)>>16;
((Standard_Integer*)Max)[ 4]=(((Standard_Integer*)MM)[10]&0x7fff0000)>>16;
((Standard_Integer*)Min)[ 5]= ((Standard_Integer*)MM)[ 2]&0x00007fff;
((Standard_Integer*)Max)[ 5]= ((Standard_Integer*)MM)[10]&0x00007fff;
((Standard_Integer*)Min)[ 6]=(((Standard_Integer*)MM)[ 3]&0x7fff0000)>>16;
((Standard_Integer*)Max)[ 6]=(((Standard_Integer*)MM)[11]&0x7fff0000)>>16;
((Standard_Integer*)Min)[ 7]= ((Standard_Integer*)MM)[ 3]&0x00007fff;
((Standard_Integer*)Max)[ 7]= ((Standard_Integer*)MM)[11]&0x00007fff;
((Standard_Integer*)Min)[ 8]=(((Standard_Integer*)MM)[ 4]&0x7fff0000)>>16;
((Standard_Integer*)Max)[ 8]=(((Standard_Integer*)MM)[12]&0x7fff0000)>>16;
((Standard_Integer*)Min)[ 9]= ((Standard_Integer*)MM)[ 4]&0x00007fff;
((Standard_Integer*)Max)[ 9]= ((Standard_Integer*)MM)[12]&0x00007fff;
((Standard_Integer*)Min)[10]=(((Standard_Integer*)MM)[ 5]&0x7fff0000)>>16;
((Standard_Integer*)Max)[10]=(((Standard_Integer*)MM)[13]&0x7fff0000)>>16;
((Standard_Integer*)Min)[11]= ((Standard_Integer*)MM)[ 5]&0x00007fff;
((Standard_Integer*)Max)[11]= ((Standard_Integer*)MM)[13]&0x00007fff;
((Standard_Integer*)Min)[12]=(((Standard_Integer*)MM)[ 6]&0x7fff0000)>>16;
((Standard_Integer*)Max)[12]=(((Standard_Integer*)MM)[14]&0x7fff0000)>>16;
((Standard_Integer*)Min)[13]= ((Standard_Integer*)MM)[ 6]&0x00007fff;
((Standard_Integer*)Max)[13]= ((Standard_Integer*)MM)[14]&0x00007fff;
((Standard_Integer*)Min)[14]=(((Standard_Integer*)MM)[ 7]&0x7fff0000)>>16;
((Standard_Integer*)Max)[14]=(((Standard_Integer*)MM)[15]&0x7fff0000)>>16;
((Standard_Integer*)Min)[15]= ((Standard_Integer*)MM)[ 7]&0x00007fff;
((Standard_Integer*)Max)[15]= ((Standard_Integer*)MM)[15]&0x00007fff;
}
//=======================================================================
//function :CopyMinMax
//purpose :
//=======================================================================
void HLRAlgo::CopyMinMax (const Standard_Address IMin,
const Standard_Address IMax,
const Standard_Address OMin,
const Standard_Address OMax)
{
Standard_Integer i = 0;
while (i < 16)
{
((Standard_Integer*)OMin)[i]=((Standard_Integer*)IMin)[i];
((Standard_Integer*)OMax)[i]=((Standard_Integer*)IMax)[i];
i++;
}
Min.Min[0] =(MM.Min[0] & 0x7fff0000)>>16;
Max.Min[0] =(MM.Max[0] & 0x7fff0000)>>16;
Min.Min[1] = MM.Min[0] & 0x00007fff;
Max.Min[1] = MM.Max[0] & 0x00007fff;
Min.Min[2] =(MM.Min[1] & 0x7fff0000)>>16;
Max.Min[2] =(MM.Max[1] & 0x7fff0000)>>16;
Min.Min[3] = MM.Min[1] & 0x00007fff;
Max.Min[3] = MM.Max[1] & 0x00007fff;
Min.Min[4] =(MM.Min[2] & 0x7fff0000)>>16;
Max.Min[4] =(MM.Max[2] & 0x7fff0000)>>16;
Min.Min[5] = MM.Min[2] & 0x00007fff;
Max.Min[5] = MM.Max[2] & 0x00007fff;
Min.Min[6] =(MM.Min[3] & 0x7fff0000)>>16;
Max.Min[6] =(MM.Max[3] & 0x7fff0000)>>16;
Min.Min[7] = MM.Min[3] & 0x00007fff;
Max.Min[7] = MM.Max[3] & 0x00007fff;
Min.Max[0] =(MM.Min[4] & 0x7fff0000)>>16;
Max.Max[0] =(MM.Max[4] & 0x7fff0000)>>16;
Min.Max[1] = MM.Min[4] & 0x00007fff;
Max.Max[1] = MM.Max[4] & 0x00007fff;
Min.Max[2] =(MM.Min[5] & 0x7fff0000)>>16;
Max.Max[2] =(MM.Max[5] & 0x7fff0000)>>16;
Min.Max[3] = MM.Min[5] & 0x00007fff;
Max.Max[3] = MM.Max[5] & 0x00007fff;
Min.Max[4] =(MM.Min[6] & 0x7fff0000)>>16;
Max.Max[4] =(MM.Max[6] & 0x7fff0000)>>16;
Min.Max[5] = MM.Min[6] & 0x00007fff;
Max.Max[5] = MM.Max[6] & 0x00007fff;
Min.Max[6] =(MM.Min[7] & 0x7fff0000)>>16;
Max.Max[6] =(MM.Max[7] & 0x7fff0000)>>16;
Min.Max[7] = MM.Min[7] & 0x00007fff;
Max.Max[7] = MM.Max[7] & 0x00007fff;
}
//=======================================================================
@ -234,18 +221,11 @@ void HLRAlgo::CopyMinMax (const Standard_Address IMin,
//purpose :
//=======================================================================
void HLRAlgo::AddMinMax (const Standard_Address IMin,
const Standard_Address IMax,
const Standard_Address OMin,
const Standard_Address OMax)
void HLRAlgo::AddMinMax (HLRAlgo_EdgesBlock::MinMaxIndices& IMin,
HLRAlgo_EdgesBlock::MinMaxIndices& IMax,
HLRAlgo_EdgesBlock::MinMaxIndices& OMin,
HLRAlgo_EdgesBlock::MinMaxIndices& OMax)
{
Standard_Integer i = 0;
while (i < 16)
{
if (((Standard_Integer*)OMin)[i] > ((Standard_Integer*)IMin)[i])
((Standard_Integer*)OMin)[i]=((Standard_Integer*)IMin)[i];
if (((Standard_Integer*)OMax)[i] < ((Standard_Integer*)IMax)[i])
((Standard_Integer*)OMax)[i]=((Standard_Integer*)IMax)[i];
i++;
}
OMin.Minimize(IMin);
OMax.Maximize(IMax);
}

24
src/HLRAlgo/HLRAlgo.hxx
View File

@ -17,12 +17,14 @@
#ifndef _HLRAlgo_HeaderFile
#define _HLRAlgo_HeaderFile
#include <HLRAlgo_WiresBlock.hxx>
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Real.hxx>
#include <Standard_Address.hxx>
class HLRAlgo_BiPoint;
class HLRAlgo_PolyShellData;
class HLRAlgo_PolyInternalData;
@ -73,21 +75,25 @@ public:
//! Iterator on the visible or hidden parts of an
//! EdgeStatus.
Standard_EXPORT static void UpdateMinMax (const Standard_Real x, const Standard_Real y, const Standard_Real z, const Standard_Address Min, const Standard_Address Max);
Standard_EXPORT static void UpdateMinMax (const Standard_Real x, const Standard_Real y, const Standard_Real z, Standard_Real Min[16], Standard_Real Max[16]);
Standard_EXPORT static void EnlargeMinMax (const Standard_Real tol, const Standard_Address Min, const Standard_Address Max);
Standard_EXPORT static void EnlargeMinMax (const Standard_Real tol, Standard_Real Min[16], Standard_Real Max[16]);
Standard_EXPORT static void InitMinMax (const Standard_Real Big, const Standard_Address Min, const Standard_Address Max);
Standard_EXPORT static void InitMinMax (const Standard_Real Big, Standard_Real Min[16], Standard_Real Max[16]);
Standard_EXPORT static void EncodeMinMax (const Standard_Address Min, const Standard_Address Max, const Standard_Address MinMax);
Standard_EXPORT static void EncodeMinMax (HLRAlgo_EdgesBlock::MinMaxIndices& Min, HLRAlgo_EdgesBlock::MinMaxIndices& Max, HLRAlgo_EdgesBlock::MinMaxIndices& MinMax);
Standard_EXPORT static Standard_Real SizeBox (const Standard_Address Min, const Standard_Address Max);
Standard_EXPORT static Standard_Real SizeBox (HLRAlgo_EdgesBlock::MinMaxIndices& Min, HLRAlgo_EdgesBlock::MinMaxIndices& Max);
Standard_EXPORT static void DecodeMinMax (const Standard_Address MinMax, const Standard_Address Min, const Standard_Address Max);
Standard_EXPORT static void DecodeMinMax (const HLRAlgo_EdgesBlock::MinMaxIndices& MinMax, HLRAlgo_EdgesBlock::MinMaxIndices& Min, HLRAlgo_EdgesBlock::MinMaxIndices& Max);
Standard_EXPORT static void CopyMinMax (const Standard_Address IMin, const Standard_Address IMax, const Standard_Address OMin, const Standard_Address OMax);
static void CopyMinMax (HLRAlgo_EdgesBlock::MinMaxIndices& IMin, HLRAlgo_EdgesBlock::MinMaxIndices& IMax, HLRAlgo_EdgesBlock::MinMaxIndices& OMin, HLRAlgo_EdgesBlock::MinMaxIndices& OMax)
{
OMin = IMin;
OMax = IMax;
}
Standard_EXPORT static void AddMinMax (const Standard_Address IMin, const Standard_Address IMax, const Standard_Address OMin, const Standard_Address OMax);
Standard_EXPORT static void AddMinMax (HLRAlgo_EdgesBlock::MinMaxIndices& IMin, HLRAlgo_EdgesBlock::MinMaxIndices& IMax, HLRAlgo_EdgesBlock::MinMaxIndices& OMin, HLRAlgo_EdgesBlock::MinMaxIndices& OMax);

192
src/HLRAlgo/HLRAlgo_BiPoint.cxx
View File

@ -21,30 +21,6 @@
#include <HLRAlgo_BiPoint.hxx>
#define PntX1 myCoordinates[ 0]
#define PntY1 myCoordinates[ 1]
#define PntZ1 myCoordinates[ 2]
#define PntX2 myCoordinates[ 3]
#define PntY2 myCoordinates[ 4]
#define PntZ2 myCoordinates[ 5]
#define PntXP1 myCoordinates[ 6]
#define PntYP1 myCoordinates[ 7]
#define PntZP1 myCoordinates[ 8]
#define PntXP2 myCoordinates[ 9]
#define PntYP2 myCoordinates[10]
#define PntZP2 myCoordinates[11]
#define ShapeIndex myIndices[0]
#define FaceConex1 myIndices[1]
#define Face1Pt1 myIndices[2]
#define Face1Pt2 myIndices[3]
#define FaceConex2 myIndices[4]
#define Face2Pt1 myIndices[5]
#define Face2Pt2 myIndices[6]
#define MinSeg myIndices[7]
#define MaxSeg myIndices[8]
#define SegFlags myIndices[9]
//=======================================================================
//function : HLRAlgo_BiPoint
//purpose :
@ -68,22 +44,14 @@ HLRAlgo_BiPoint::HLRAlgo_BiPoint (const Standard_Real X1,
const Standard_Boolean outl,
const Standard_Boolean intl)
{
PntX1 = X1;
PntY1 = Y1;
PntZ1 = Z1;
PntX2 = X2;
PntY2 = Y2;
PntZ2 = Z2;
PntXP1 = XT1;
PntYP1 = YT1;
PntZP1 = ZT1;
PntXP2 = XT2;
PntYP2 = YT2;
PntZP2 = ZT2;
ShapeIndex = Index;
FaceConex1 = Face1Pt1 = Face1Pt2 =
FaceConex2 = Face2Pt1 = Face2Pt2 = 0;
SegFlags = 0;
myPoints.Pnt1.SetCoord(X1, Y1, Z1);
myPoints.Pnt2.SetCoord(X2, Y2, Z2);
myPoints.PntP1.SetCoord(XT1, YT1, ZT1);
myPoints.PntP2.SetCoord(XT2, YT2, ZT2);
myIndices.ShapeIndex = Index;
myIndices.FaceConex1 = myIndices.Face1Pt1 = myIndices.Face1Pt2 =
myIndices.FaceConex2 = myIndices.Face2Pt1 = myIndices.Face2Pt2 = 0;
myIndices.SegFlags = 0;
Rg1Line(reg1);
RgNLine(regn);
OutLine(outl);
@ -111,22 +79,14 @@ HLRAlgo_BiPoint::HLRAlgo_BiPoint (const Standard_Real X1,
const Standard_Integer Index,
const Standard_Integer flag)
{
PntX1 = X1;
PntY1 = Y1;
PntZ1 = Z1;
PntX2 = X2;
PntY2 = Y2;
PntZ2 = Z2;
PntXP1 = XT1;
PntYP1 = YT1;
PntZP1 = ZT1;
PntXP2 = XT2;
PntYP2 = YT2;
PntZP2 = ZT2;
ShapeIndex = Index;
FaceConex1 = Face1Pt1 = Face1Pt2 =
FaceConex2 = Face2Pt1 = Face2Pt2 = 0;
SegFlags = flag;
myPoints.Pnt1 = gp_XYZ(X1, Y1, Z1);
myPoints.Pnt2 = gp_XYZ(X2, Y2, Z2);
myPoints.PntP1 = gp_XYZ(XT1, YT1, ZT1);
myPoints.PntP2 = gp_XYZ(XT2, YT2, ZT2);
myIndices.ShapeIndex = Index;
myIndices.FaceConex1 = myIndices.Face1Pt1 = myIndices.Face1Pt2 =
myIndices.FaceConex2 = myIndices.Face2Pt1 = myIndices.Face2Pt2 = 0;
myIndices.SegFlags = flag;
Hidden(Standard_False);
}
@ -156,24 +116,16 @@ HLRAlgo_BiPoint::HLRAlgo_BiPoint (const Standard_Real X1,
const Standard_Boolean outl,
const Standard_Boolean intl)
{
PntX1 = X1;
PntY1 = Y1;
PntZ1 = Z1;
PntX2 = X2;
PntY2 = Y2;
PntZ2 = Z2;
PntXP1 = XT1;
PntYP1 = YT1;
PntZP1 = ZT1;
PntXP2 = XT2;
PntYP2 = YT2;
PntZP2 = ZT2;
ShapeIndex = Index;
FaceConex1 = i1;
Face1Pt1 = i1p1;
Face1Pt2 = i1p2;
FaceConex2 = Face2Pt1 = Face2Pt2 = 0;
SegFlags = 0;
myPoints.Pnt1.SetCoord(X1, Y1, Z1);
myPoints.Pnt2.SetCoord(X2, Y2, Z2);
myPoints.PntP1.SetCoord(XT1, YT1, ZT1);
myPoints.PntP2.SetCoord(XT2, YT2, ZT2);
myIndices.ShapeIndex = Index;
myIndices.FaceConex1 = i1;
myIndices.Face1Pt1 = i1p1;
myIndices.Face1Pt2 = i1p2;
myIndices.FaceConex2 = myIndices.Face2Pt1 = myIndices.Face2Pt2 = 0;
myIndices.SegFlags = 0;
Rg1Line(reg1);
RgNLine(regn);
OutLine(outl);
@ -204,24 +156,16 @@ HLRAlgo_BiPoint::HLRAlgo_BiPoint (const Standard_Real X1,
const Standard_Integer i1p2,
const Standard_Integer flag)
{
PntX1 = X1;
PntY1 = Y1;
PntZ1 = Z1;
PntX2 = X2;
PntY2 = Y2;
PntZ2 = Z2;
PntXP1 = XT1;
PntYP1 = YT1;
PntZP1 = ZT1;
PntXP2 = XT2;
PntYP2 = YT2;
PntZP2 = ZT2;
ShapeIndex = Index;
FaceConex1 = i1;
Face1Pt1 = i1p1;
Face1Pt2 = i1p2;
FaceConex2 = Face2Pt1 = Face2Pt2 = 0;
SegFlags = flag;
myPoints.Pnt1.SetCoord(X1, Y1, Z1);
myPoints.Pnt2.SetCoord(X2, Y2, Z2);
myPoints.PntP1.SetCoord(XT1, YT1, ZT1);
myPoints.PntP2.SetCoord(XT2, YT2, ZT2);
myIndices.ShapeIndex = Index;
myIndices.FaceConex1 = i1;
myIndices.Face1Pt1 = i1p1;
myIndices.Face1Pt2 = i1p2;
myIndices.FaceConex2 = myIndices.Face2Pt1 = myIndices.Face2Pt2 = 0;
myIndices.SegFlags = flag;
Hidden(Standard_False);
}
@ -254,26 +198,18 @@ HLRAlgo_BiPoint::HLRAlgo_BiPoint (const Standard_Real X1,
const Standard_Boolean outl,
const Standard_Boolean intl)
{
PntX1 = X1;
PntY1 = Y1;
PntZ1 = Z1;
PntX2 = X2;
PntY2 = Y2;
PntZ2 = Z2;
PntXP1 = XT1;
PntYP1 = YT1;
PntZP1 = ZT1;
PntXP2 = XT2;
PntYP2 = YT2;
PntZP2 = ZT2;
ShapeIndex = Index;
FaceConex1 = i1;
Face1Pt1 = i1p1;
Face1Pt2 = i1p2;
FaceConex2 = i2;
Face2Pt1 = i2p1;
Face2Pt2 = i2p2;
SegFlags = 0;
myPoints.Pnt1.SetCoord(X1, Y1, Z1);
myPoints.Pnt2.SetCoord(X2, Y2, Z2);
myPoints.PntP1.SetCoord(XT1, YT1, ZT1);
myPoints.PntP2.SetCoord(XT2, YT2, ZT2);
myIndices.ShapeIndex = Index;
myIndices.FaceConex1 = i1;
myIndices.Face1Pt1 = i1p1;
myIndices.Face1Pt2 = i1p2;
myIndices.FaceConex2 = i2;
myIndices.Face2Pt1 = i2p1;
myIndices.Face2Pt2 = i2p2;
myIndices.SegFlags = 0;
Rg1Line(reg1);
RgNLine(regn);
OutLine(outl);
@ -307,25 +243,17 @@ HLRAlgo_BiPoint::HLRAlgo_BiPoint (const Standard_Real X1,
const Standard_Integer i2p2,
const Standard_Integer flag)
{
PntX1 = X1;
PntY1 = Y1;
PntZ1 = Z1;
PntX2 = X2;
PntY2 = Y2;
PntZ2 = Z2;
PntXP1 = XT1;
PntYP1 = YT1;
PntZP1 = ZT1;
PntXP2 = XT2;
PntYP2 = YT2;
PntZP2 = ZT2;
ShapeIndex = Index;
FaceConex1 = i1;
Face1Pt1 = i1p1;
Face1Pt2 = i1p2;
FaceConex2 = i2;
Face2Pt1 = i2p1;
Face2Pt2 = i2p2;
SegFlags = flag;
myPoints.Pnt1.SetCoord(X1, Y1, Z1);
myPoints.Pnt2.SetCoord(X2, Y2, Z2);
myPoints.PntP1.SetCoord(XT1, YT1, ZT1);
myPoints.PntP2.SetCoord(XT2, YT2, ZT2);
myIndices.ShapeIndex = Index;
myIndices.FaceConex1 = i1;
myIndices.Face1Pt1 = i1p1;
myIndices.Face1Pt2 = i1p2;
myIndices.FaceConex2 = i2;
myIndices.Face2Pt1 = i2p1;
myIndices.Face2Pt2 = i2p2;
myIndices.SegFlags = flag;
Hidden(Standard_False);
}

96
src/HLRAlgo/HLRAlgo_BiPoint.hxx
View File

@ -24,13 +24,45 @@
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Address.hxx>
#include <gp_XYZ.hxx>
#include <gp_XY.hxx>
class HLRAlgo_BiPoint
class HLRAlgo_BiPoint
{
public:
struct IndicesT
{
Standard_Integer ShapeIndex;
Standard_Integer FaceConex1;
Standard_Integer Face1Pt1;
Standard_Integer Face1Pt2;
Standard_Integer FaceConex2;
Standard_Integer Face2Pt1;
Standard_Integer Face2Pt2;
Standard_Integer MinSeg;
Standard_Integer MaxSeg;
Standard_Integer SegFlags;
};
struct PointsT
{
gp_XYZ Pnt1;
gp_XYZ Pnt2;
gp_XYZ PntP1;
gp_XYZ PntP2;
gp_XY PntP12D() const
{
return gp_XY(PntP1.X(), PntP1.Y());
}
gp_XY PntP22D() const
{
return gp_XY(PntP2.X(), PntP2.Y());
}
};
DEFINE_STANDARD_ALLOC
@ -48,49 +80,70 @@ public:
Standard_EXPORT HLRAlgo_BiPoint(const Standard_Real X1, const Standard_Real Y1, const Standard_Real Z1, const Standard_Real X2, const Standard_Real Y2, const Standard_Real Z2, const Standard_Real XT1, const Standard_Real YT1, const Standard_Real ZT1, const Standard_Real XT2, const Standard_Real YT2, const Standard_Real ZT2, const Standard_Integer Index, const Standard_Integer i1, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i2, const Standard_Integer i2p1, const Standard_Integer i2p2, const Standard_Integer flag);
Standard_Boolean Rg1Line() const { return (myIndices[9] & EMskRg1Line) != 0; }
Standard_Boolean Rg1Line() const
{
return (myIndices.SegFlags & EMskRg1Line) != 0;
}
void Rg1Line (const Standard_Boolean B)
{
if (B) myIndices[9] |= EMskRg1Line;
else myIndices[9] &= ~EMskRg1Line;
if (B) myIndices.SegFlags |= EMskRg1Line;
else myIndices.SegFlags &= ~EMskRg1Line;
}
Standard_Boolean RgNLine() const { return (myIndices[9] & EMskRgNLine) != 0; }
Standard_Boolean RgNLine() const
{
return (myIndices.SegFlags & EMskRgNLine) != 0;
}
void RgNLine (const Standard_Boolean B)
{
if (B) myIndices[9] |= EMskRgNLine;
else myIndices[9] &= ~EMskRgNLine;
if (B) myIndices.SegFlags |= EMskRgNLine;
else myIndices.SegFlags &= ~EMskRgNLine;
}
Standard_Boolean OutLine() const { return (myIndices[9] & EMskOutLine) != 0; }
Standard_Boolean OutLine() const
{
return (myIndices.SegFlags & EMskOutLine) != 0;
}
void OutLine (const Standard_Boolean B)
{
if (B) myIndices[9] |= EMskOutLine;
else myIndices[9] &= ~EMskOutLine;
if (B) myIndices.SegFlags |= EMskOutLine;
else myIndices.SegFlags &= ~EMskOutLine;
}
Standard_Boolean IntLine() const { return (myIndices[9] & EMskIntLine) != 0; }
Standard_Boolean IntLine() const
{
return (myIndices.SegFlags & EMskIntLine) != 0;
}
void IntLine (const Standard_Boolean B)
{
if (B) myIndices[9] |= EMskIntLine;
else myIndices[9] &= ~EMskIntLine;
if (B) myIndices.SegFlags |= EMskIntLine;
else myIndices.SegFlags &= ~EMskIntLine;
}
Standard_Boolean Hidden() const { return (myIndices[9] & EMskHidden) != 0; }
Standard_Boolean Hidden() const
{
return (myIndices.SegFlags & EMskHidden) != 0;
}
void Hidden (const Standard_Boolean B)
{
if (B) myIndices[9] |= EMskHidden;
else myIndices[9] &= ~EMskHidden;
if (B) myIndices.SegFlags |= EMskHidden;
else myIndices.SegFlags &= ~EMskHidden;
}
Standard_Address Indices() const { return const_cast<Standard_Integer* >(myIndices); }
IndicesT& Indices()
{
return myIndices;
}
Standard_Address Coordinates() const { return const_cast<Standard_Real* >(myCoordinates); }
PointsT& Points()
{
return myPoints;
}
protected:
@ -104,9 +157,8 @@ protected:
};
private:
Standard_Integer myIndices[10];
Standard_Real myCoordinates[12];
IndicesT myIndices;
PointsT myPoints;
};

30
src/HLRAlgo/HLRAlgo_Coincidence.cxx
View File

@ -1,30 +0,0 @@
// Created on: 1992-02-19
// Created by: Christophe MARION
// Copyright (c) 1992-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.
#include <HLRAlgo_Coincidence.hxx>
//=======================================================================
//function : HLRAlgo_Coincidence
//purpose :
//=======================================================================
HLRAlgo_Coincidence::HLRAlgo_Coincidence()
: myFE(0),
myParam(0.),
myStBef(TopAbs_IN),
myStAft(TopAbs_IN)
{
}

58
src/HLRAlgo/HLRAlgo_Coincidence.hxx
View File

@ -25,7 +25,6 @@
#include <Standard_Real.hxx>
#include <TopAbs_State.hxx>
//! The Coincidence class is used in an Inteference to
//! store informations on the "hiding" edge.
//!
@ -38,49 +37,48 @@
//! intersection with the face (before and after).
//! This is necessary when the intersection is "ON"
//! the face.
class HLRAlgo_Coincidence
class HLRAlgo_Coincidence
{
public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT HLRAlgo_Coincidence();
void Set2D (const Standard_Integer FE, const Standard_Real Param);
void SetState3D (const TopAbs_State stbef, const TopAbs_State staft);
void Value2D (Standard_Integer& FE, Standard_Real& Param) const;
void State3D (TopAbs_State& stbef, TopAbs_State& staft) const;
protected:
Standard_EXPORT HLRAlgo_Coincidence() :
myFE(0),
myParam(0.),
myStBef(TopAbs_IN),
myStAft(TopAbs_IN)
{
}
void Set2D (const Standard_Integer FE, const Standard_Real Param)
{
myFE = FE;
myParam = Param;
}
void SetState3D (const TopAbs_State stbef, const TopAbs_State staft)
{
myStBef = stbef;
myStAft = staft;
}
void Value2D (Standard_Integer& FE, Standard_Real& Param) const
{
FE = myFE;
Param = myParam;
}
void State3D (TopAbs_State& stbef, TopAbs_State& staft) const
{
stbef = myStBef;
staft = myStAft;
}
private:
Standard_Integer myFE;
Standard_Real myParam;
TopAbs_State myStBef;
TopAbs_State myStAft;
};
#include <HLRAlgo_Coincidence.lxx>
#endif // _HLRAlgo_Coincidence_HeaderFile

65
src/HLRAlgo/HLRAlgo_Coincidence.lxx
View File

@ -1,65 +0,0 @@
// Created on: 1992-02-19
// Created by: Christophe MARION
// Copyright (c) 1992-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.
//=======================================================================
//function : Set2D
//purpose :
//=======================================================================
inline void HLRAlgo_Coincidence::Set2D
(const Standard_Integer FE,
const Standard_Real Param)
{
myFE = FE;
myParam = Param;
}
//=======================================================================
//function : SetState3D
//purpose :
//=======================================================================
inline void HLRAlgo_Coincidence::SetState3D
(const TopAbs_State stbef,const TopAbs_State staft)
{
myStBef = stbef;
myStAft = staft;
}
//=======================================================================
//function : Value2D
//purpose :
//=======================================================================
inline void HLRAlgo_Coincidence::Value2D
(Standard_Integer& FE,
Standard_Real& Param) const
{
FE = myFE;
Param = myParam;
}
//=======================================================================
//function : State3D
//purpose :
//=======================================================================
inline void HLRAlgo_Coincidence::State3D
(TopAbs_State& stbef,TopAbs_State& staft) const
{
stbef = myStBef;
staft = myStAft;
}

4
src/HLRAlgo/HLRAlgo_EdgeIterator.cxx
View File

@ -34,9 +34,9 @@ HLRAlgo_EdgeIterator::HLRAlgo_EdgeIterator ()
//purpose :
//=======================================================================
void HLRAlgo_EdgeIterator::InitHidden (const HLRAlgo_EdgeStatus& status)
void HLRAlgo_EdgeIterator::InitHidden (HLRAlgo_EdgeStatus& status)
{
EHid = (Standard_Address)&status;
EHid = &status;
iHid = 1;
if (((HLRAlgo_EdgeStatus*)EHid)->AllHidden()) {
((HLRAlgo_EdgeStatus*)EHid)->Bounds

9
src/HLRAlgo/HLRAlgo_EdgeIterator.hxx
View File

@ -22,7 +22,6 @@
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <Standard_ShortReal.hxx>
#include <Standard_Boolean.hxx>
@ -41,7 +40,7 @@ public:
//! edge.
Standard_EXPORT HLRAlgo_EdgeIterator();
Standard_EXPORT void InitHidden (const HLRAlgo_EdgeStatus& status);
Standard_EXPORT void InitHidden (HLRAlgo_EdgeStatus& status);
Standard_Boolean MoreHidden() const;
@ -51,7 +50,7 @@ public:
//! of the current Hidden Interval
void Hidden (Standard_Real& Start, Standard_ShortReal& TolStart, Standard_Real& End, Standard_ShortReal& TolEnd) const;
void InitVisible (const HLRAlgo_EdgeStatus& status);
void InitVisible (HLRAlgo_EdgeStatus& status);
Standard_Boolean MoreVisible() const;
@ -76,8 +75,8 @@ private:
Standard_Integer myNbVis;
Standard_Integer myNbHid;
Standard_Address EVis;
Standard_Address EHid;
HLRAlgo_EdgeStatus* EVis;
HLRAlgo_EdgeStatus* EHid;
Standard_Integer iVis;
Standard_Integer iHid;
Standard_Real myHidStart;

4
src/HLRAlgo/HLRAlgo_EdgeIterator.lxx
View File

@ -47,9 +47,9 @@ HLRAlgo_EdgeIterator::Hidden (Standard_Real& Start,
//=======================================================================
inline void
HLRAlgo_EdgeIterator::InitVisible (const HLRAlgo_EdgeStatus& status)
HLRAlgo_EdgeIterator::InitVisible(HLRAlgo_EdgeStatus& status)
{
EVis = (Standard_Address)&status;
EVis = &status;
iVis = 1;
myNbVis = ((HLRAlgo_EdgeStatus*)EVis)->NbVisiblePart();
}

11
src/HLRAlgo/HLRAlgo_EdgesBlock.cxx
View File

@ -31,14 +31,3 @@ IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_EdgesBlock,MMgt_TShared)
HLRAlgo_EdgesBlock::HLRAlgo_EdgesBlock (const Standard_Integer NbEdges) :
myEdges(1,NbEdges), myFlags(1,NbEdges)
{}
//=======================================================================
//function : UpdateMinMax
//purpose :
//=======================================================================
void HLRAlgo_EdgesBlock::UpdateMinMax (const Standard_Address TotMinMax)
{
for (Standard_Integer i = 0; i <= 15; i++)
myMinMax[i] = ((Standard_Integer*)TotMinMax)[i];
}

50
src/HLRAlgo/HLRAlgo_EdgesBlock.hxx
View File

@ -26,7 +26,6 @@
#include <MMgt_TShared.hxx>
#include <TopAbs_Orientation.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Address.hxx>
class HLRAlgo_EdgesBlock;
@ -48,6 +47,42 @@ class HLRAlgo_EdgesBlock : public MMgt_TShared
{
public:
struct MinMaxIndices
{
Standard_Integer Min[8], Max[8];
MinMaxIndices& Minimize(const MinMaxIndices& theMinMaxIndices)
{
for (Standard_Integer aI = 0; aI < 8; ++aI)
{
if (Min[aI] > theMinMaxIndices.Min[aI])
{
Min[aI] = theMinMaxIndices.Min[aI];
}
if (Max[aI] > theMinMaxIndices.Max[aI])
{
Max[aI] = theMinMaxIndices.Max[aI];
}
}
return *this;
}
MinMaxIndices& Maximize(const MinMaxIndices& theMinMaxIndices)
{
for (Standard_Integer aI = 0; aI < 8; ++aI)
{
if (Min[aI] < theMinMaxIndices.Min[aI])
{
Min[aI] = theMinMaxIndices.Min[aI];
}
if (Max[aI] < theMinMaxIndices.Max[aI])
{
Max[aI] = theMinMaxIndices.Max[aI];
}
}
return *this;
}
};
//! Create a Block of Edges for a wire.
Standard_EXPORT HLRAlgo_EdgesBlock(const Standard_Integer NbEdges);
@ -101,9 +136,15 @@ public:
else myFlags(I) &= ~EMaskIsoLine;
}
Standard_EXPORT void UpdateMinMax (const Standard_Address TotMinMax);
void UpdateMinMax(const MinMaxIndices& TotMinMax)
{
myMinMax = TotMinMax;
}
Standard_Address MinMax() const { return (Standard_Address )&myMinMax; }
MinMaxIndices& MinMax()
{
return myMinMax;
}
DEFINE_STANDARD_RTTIEXT(HLRAlgo_EdgesBlock,MMgt_TShared)
@ -122,8 +163,7 @@ private:
TColStd_Array1OfInteger myEdges;
TColStd_Array1OfInteger myFlags;
Standard_Integer myMinMax[16];
MinMaxIndices myMinMax;
};
#endif // _HLRAlgo_EdgesBlock_HeaderFile

203
src/HLRAlgo/HLRAlgo_PolyAlgo.cxx
View File

@ -23,72 +23,14 @@
#include <HLRAlgo_EdgeStatus.hxx>
#include <HLRAlgo_ListOfBPoint.hxx>
#include <HLRAlgo_PolyAlgo.hxx>
#include <HLRAlgo_PolyData.hxx>
#include <HLRAlgo_PolyShellData.hxx>
#include <HLRAlgo_PolyMask.hxx>
#include <Precision.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo,MMgt_TShared)
#define EMskGrALin1 ((Standard_Integer) 8)
#define EMskGrALin2 ((Standard_Integer) 16)
#define EMskGrALin3 ((Standard_Integer) 32)
#define FMskHiding ((Standard_Integer) 256)
#define TriNode1 ((Standard_Integer*)TriIndices)[0]
#define TriNode2 ((Standard_Integer*)TriIndices)[1]
#define TriNode3 ((Standard_Integer*)TriIndices)[2]
#define TriFlags ((Standard_Integer*)TriIndices)[3]
#define XV1 myRealPtr[0]
#define XV2 myRealPtr[1]
#define XV3 myRealPtr[2]
#define YV1 myRealPtr[3]
#define YV2 myRealPtr[4]
#define YV3 myRealPtr[5]
#define Param myRealPtr[6]
#define myTolParam myRealPtr[7]
#define myTolAngular myRealPtr[8]
#define myTolerance myRealPtr[9]
#define PntX1 ((Standard_Real*)Coordinates)[ 0]
#define PntY1 ((Standard_Real*)Coordinates)[ 1]
#define PntZ1 ((Standard_Real*)Coordinates)[ 2]
#define PntX2 ((Standard_Real*)Coordinates)[ 3]
#define PntY2 ((Standard_Real*)Coordinates)[ 4]
#define PntZ2 ((Standard_Real*)Coordinates)[ 5]
#define PntXP1 ((Standard_Real*)Coordinates)[ 6]
#define PntYP1 ((Standard_Real*)Coordinates)[ 7]
#define PntZP1 ((Standard_Real*)Coordinates)[ 8]
#define PntXP2 ((Standard_Real*)Coordinates)[ 9]
#define PntYP2 ((Standard_Real*)Coordinates)[10]
#define PntZP2 ((Standard_Real*)Coordinates)[11]
#define TotXMin ((Standard_Real*)TotMinMax)[0]
#define TotYMin ((Standard_Real*)TotMinMax)[1]
#define TotZMin ((Standard_Real*)TotMinMax)[2]
#define TotXMax ((Standard_Real*)TotMinMax)[3]
#define TotYMax ((Standard_Real*)TotMinMax)[4]
#define TotZMax ((Standard_Real*)TotMinMax)[5]
#define ShapeIndex ((Standard_Integer*)IndexPtr)[0]
#define FaceConex1 ((Standard_Integer*)IndexPtr)[1]
#define Face1Pt1 ((Standard_Integer*)IndexPtr)[2]
#define Face1Pt2 ((Standard_Integer*)IndexPtr)[3]
#define FaceConex2 ((Standard_Integer*)IndexPtr)[4]
#define Face2Pt1 ((Standard_Integer*)IndexPtr)[5]
#define Face2Pt2 ((Standard_Integer*)IndexPtr)[6]
#define MinSeg ((Standard_Integer*)IndexPtr)[7]
#define MaxSeg ((Standard_Integer*)IndexPtr)[8]
#define SegFlags ((Standard_Integer*)IndexPtr)[9]
#define MinShell ((Standard_Integer*)ShellIndices)[0]
#define MaxShell ((Standard_Integer*)ShellIndices)[1]
#define FIndex ((Standard_Integer*)PolyTIndices)[0]
#define MinPolyT ((Standard_Integer*)PolyTIndices)[1]
#define MaxPolyT ((Standard_Integer*)PolyTIndices)[2]
//static Standard_Integer ERROR = Standard_False;
//=======================================================================
@ -98,8 +40,8 @@ IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo,MMgt_TShared)
HLRAlgo_PolyAlgo::HLRAlgo_PolyAlgo ()
{
myTolParam = 0.00000001;
myTolAngular = 0.0001;
myTriangle.TolParam = 0.00000001;
myTriangle.TolAng = 0.0001;
}
//=======================================================================
@ -141,45 +83,39 @@ void HLRAlgo_PolyAlgo::Update ()
Standard_Real xTrianMax,yTrianMax,zTrianMax;
Standard_Real xSegmnMin,ySegmnMin,zSegmnMin;
Standard_Real xSegmnMax,ySegmnMax,zSegmnMax;
Standard_Real TotMinMax[6];
Standard_Real Big = Precision::Infinite();
TotMinMax[0] = Big;
TotMinMax[1] = Big;
TotMinMax[2] = Big;
TotMinMax[3] = -Big;
TotMinMax[4] = -Big;
TotMinMax[5] = -Big;
HLRAlgo_PolyData::Box aBox(Big, Big, Big, -Big, -Big, -Big);
TColStd_Array1OfTransient& Shell = myHShell->ChangeArray1();
myNbrShell = Shell.Upper();
Handle(HLRAlgo_PolyShellData)* psd1 =
(Handle(HLRAlgo_PolyShellData)*)&(Shell.ChangeValue(1));
for (i = 1; i <= myNbrShell; i++) {
(*psd1)->UpdateGlobalMinMax(&TotMinMax);
(*psd1)->UpdateGlobalMinMax(aBox);
psd1++;
}
Standard_Real dx = TotMinMax[3] - TotMinMax[0];
Standard_Real dy = TotMinMax[4] - TotMinMax[1];
Standard_Real dz = TotMinMax[5] - TotMinMax[2];
Standard_Real dx = aBox.XMax - aBox.XMin;
Standard_Real dy = aBox.YMax - aBox.YMin;
Standard_Real dz = aBox.ZMax - aBox.ZMin;
Standard_Real precad = dx;
if (precad < dy) precad = dy;
if (precad < dz) precad = dz;
myTolerance = precad * myTolParam;
myTriangle.Tolerance = precad * myTriangle.TolParam;
precad = precad * 0.01;
Standard_Real SurDX = 1020 / (dx + precad);
Standard_Real SurDY = 1020 / (dy + precad);
Standard_Real SurDZ = 508 / (dz + precad);
precad = precad * 0.5;
Standard_Real DecaX = - TotMinMax[0] + precad;
Standard_Real DecaY = - TotMinMax[1] + precad;
Standard_Real DecaZ = - TotMinMax[2] + precad;
Standard_Real DecaX = - aBox.XMin + precad;
Standard_Real DecaY = - aBox.YMin + precad;
Standard_Real DecaZ = - aBox.ZMin + precad;
Handle(HLRAlgo_PolyShellData)* psd2 =
(Handle(HLRAlgo_PolyShellData)*)&(Shell.ChangeValue(1));
for (i = 1; i <= myNbrShell; i++) {
const Standard_Address ShellIndices = (*psd2)->Indices();
HLRAlgo_PolyShellData::ShellIndices& aShellIndices = (*psd2)->Indices();
xShellMin = Big;
yShellMin = Big;
zShellMin = Big;
@ -191,26 +127,26 @@ void HLRAlgo_PolyAlgo::Update ()
mySegListIt.More();
mySegListIt.Next()) {
HLRAlgo_BiPoint& BP = mySegListIt.Value();
const Standard_Address Coordinates = BP.Coordinates();
const Standard_Address IndexPtr = BP.Indices();
if (PntXP1 < PntXP2) { xSegmnMin = PntXP1; xSegmnMax = PntXP2; }
else { xSegmnMin = PntXP2; xSegmnMax = PntXP1; }
if (PntYP1 < PntYP2) { ySegmnMin = PntYP1; ySegmnMax = PntYP2; }
else { ySegmnMin = PntYP2; ySegmnMax = PntYP1; }
if (PntZP1 < PntZP2) { zSegmnMin = PntZP1; zSegmnMax = PntZP2; }
else { zSegmnMin = PntZP2; zSegmnMax = PntZP1; }
HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
HLRAlgo_BiPoint::IndicesT& theIndices = BP.Indices();
if (aPoints.PntP1.X() < aPoints.PntP2.X()) { xSegmnMin = aPoints.PntP1.X(); xSegmnMax = aPoints.PntP2.X(); }
else { xSegmnMin = aPoints.PntP2.X(); xSegmnMax = aPoints.PntP1.X(); }
if (aPoints.PntP1.Y() < aPoints.PntP2.Y()) { ySegmnMin = aPoints.PntP1.Y(); ySegmnMax = aPoints.PntP2.Y(); }
else { ySegmnMin = aPoints.PntP2.Y(); ySegmnMax = aPoints.PntP1.Y(); }
if (aPoints.PntP1.Z() < aPoints.PntP2.Z()) { zSegmnMin = aPoints.PntP1.Z(); zSegmnMax = aPoints.PntP2.Z(); }
else { zSegmnMin = aPoints.PntP2.Z(); zSegmnMax = aPoints.PntP1.Z(); }
nxMin = (Standard_Integer)((DecaX + xSegmnMin) * SurDX);
nyMin = (Standard_Integer)((DecaY + ySegmnMin) * SurDY);
nzMin = (Standard_Integer)((DecaZ + zSegmnMin) * SurDZ);
nxMax = (Standard_Integer)((DecaX + xSegmnMax) * SurDX);
nyMax = (Standard_Integer)((DecaY + ySegmnMax) * SurDY);
nzMax = (Standard_Integer)((DecaZ + zSegmnMax) * SurDZ);
MinSeg = nyMin + (nxMin << 11);
MinSeg <<= 10;
MinSeg += nzMin;
MaxSeg = nyMax + (nxMax << 11);
MaxSeg <<= 10;
MaxSeg += nzMax + 0x00000200;
theIndices.MinSeg = nyMin + (nxMin << 11);
theIndices.MinSeg <<= 10;
theIndices.MinSeg += nzMin;
theIndices.MaxSeg = nyMax + (nxMax << 11);
theIndices.MaxSeg <<= 10;
theIndices.MaxSeg += nzMax + 0x00000200;
if (xShellMin > xSegmnMin) xShellMin = xSegmnMin;
if (xShellMax < xSegmnMax) xShellMax = xSegmnMax;
if (yShellMin > ySegmnMin) yShellMin = ySegmnMin;
@ -238,7 +174,7 @@ void HLRAlgo_PolyAlgo::Update ()
Standard_Real dn,dnx,dny,dnz,dx1,dy1,dz1,dx2,dy2,dz2,dx3,dy3;
Standard_Real adx1,ady1,adx2,ady2,adx3,ady3;
Standard_Real a =0.,b =0.,c =0.,d =0.;
const Standard_Address PolyTIndices = (*pd)->Indices();
HLRAlgo_PolyData::FaceIndices& PolyTIndices = (*pd)->Indices();
TColgp_Array1OfXYZ & Nodes = (*pd)->Nodes();
HLRAlgo_Array1OfTData& TData = (*pd)->TData();
HLRAlgo_Array1OfPHDat& PHDat = (*pd)->PHDat();
@ -246,11 +182,10 @@ void HLRAlgo_PolyAlgo::Update ()
HLRAlgo_TriangleData* TD = &(TData.ChangeValue(1));
for (otheri = 1; otheri <= nbT; otheri++) {
const Standard_Address TriIndices = TD->Indices();
if (TriFlags & FMskHiding) {
const gp_XYZ& P1 = Nodes(TriNode1);
const gp_XYZ& P2 = Nodes(TriNode2);
const gp_XYZ& P3 = Nodes(TriNode3);
if (TD->Flags & HLRAlgo_PolyMask_FMskHiding) {
const gp_XYZ& P1 = Nodes(TD->Node1);
const gp_XYZ& P2 = Nodes(TD->Node2);
const gp_XYZ& P3 = Nodes(TD->Node3);
X1 = P1.X();
Y1 = P1.Y();
Z1 = P1.Z();
@ -320,12 +255,12 @@ void HLRAlgo_PolyAlgo::Update ()
ady3 = dy3;
if (dx3 < 0) adx3 = -dx3;
if (dy3 < 0) ady3 = -dy3;
if (adx1 > ady1) TriFlags |= EMskGrALin1;
else TriFlags &= ~EMskGrALin1;
if (adx2 > ady2) TriFlags |= EMskGrALin2;
else TriFlags &= ~EMskGrALin2;
if (adx3 > ady3) TriFlags |= EMskGrALin3;
else TriFlags &= ~EMskGrALin3;
if (adx1 > ady1) TD->Flags |= HLRAlgo_PolyMask_EMskGrALin1;
else TD->Flags &= ~HLRAlgo_PolyMask_EMskGrALin1;
if (adx2 > ady2) TD->Flags |= HLRAlgo_PolyMask_EMskGrALin2;
else TD->Flags &= ~HLRAlgo_PolyMask_EMskGrALin2;
if (adx3 > ady3) TD->Flags |= HLRAlgo_PolyMask_EMskGrALin3;
else TD->Flags &= ~HLRAlgo_PolyMask_EMskGrALin3;
if (xPolyTMin > xTrianMin) xPolyTMin = xTrianMin;
if (xPolyTMax < xTrianMax) xPolyTMax = xTrianMax;
if (yPolyTMin > yTrianMin) yPolyTMin = yTrianMin;
@ -341,12 +276,12 @@ void HLRAlgo_PolyAlgo::Update ()
nxMax = (Standard_Integer)((DecaX + xPolyTMax) * SurDX);
nyMax = (Standard_Integer)((DecaY + yPolyTMax) * SurDY);
nzMax = (Standard_Integer)((DecaZ + zPolyTMax) * SurDZ);
MinPolyT = nyMin + (nxMin << 11);
MinPolyT <<= 10;
MinPolyT += nzMin - 0x00000200;
MaxPolyT = nyMax + (nxMax << 11);
MaxPolyT <<= 10;
MaxPolyT += nzMax;
PolyTIndices.Min = nyMin + (nxMin << 11);
PolyTIndices.Min <<= 10;
PolyTIndices.Min += nzMin - 0x00000200;
PolyTIndices.Max = nyMax + (nxMax << 11);
PolyTIndices.Max <<= 10;
PolyTIndices.Max += nzMax;
if (xShellMin > xPolyTMin) xShellMin = xPolyTMin;
if (xShellMax < xPolyTMax) xShellMax = xPolyTMax;
if (yShellMin > yPolyTMin) yShellMin = yPolyTMin;
@ -363,12 +298,12 @@ void HLRAlgo_PolyAlgo::Update ()
nxMax = (Standard_Integer)((DecaX + xShellMax) * SurDX);
nyMax = (Standard_Integer)((DecaY + yShellMax) * SurDY);
nzMax = (Standard_Integer)((DecaZ + zShellMax) * SurDZ);
MinShell = nyMin + (nxMin << 11);
MinShell <<= 10;
MinShell += nzMin - 0x00000200;
MaxShell = nyMax + (nxMax << 11);
MaxShell <<= 10;
MaxShell += nzMax;
aShellIndices.Min = nyMin + (nxMin << 11);
aShellIndices.Min <<= 10;
aShellIndices.Min += nzMin - 0x00000200;
aShellIndices.Max = nyMax + (nxMax << 11);
aShellIndices.Max <<= 10;
aShellIndices.Max += nzMax;
(*psd2)->UpdateHiding(nbFaHi);
TColStd_Array1OfTransient& PolHi = (*psd2)->HidingPolyData();
pd = (Handle(HLRAlgo_PolyData)*)&(Polyg.ChangeValue(1));
@ -385,8 +320,8 @@ void HLRAlgo_PolyAlgo::Update ()
}
else {
(*psd2)->UpdateHiding(0);
MinShell = 0;
MaxShell = 0;
aShellIndices.Min = 0;
aShellIndices.Max = 0;
}
psd2++;
}
@ -427,7 +362,7 @@ void HLRAlgo_PolyAlgo::NextHide ()
//purpose :
//=======================================================================
void HLRAlgo_PolyAlgo::Hide (Standard_Address& Coordinates,
HLRAlgo_BiPoint::PointsT& HLRAlgo_PolyAlgo::Hide (
HLRAlgo_EdgeStatus& status,
Standard_Integer& Index,
Standard_Boolean& reg1,
@ -436,10 +371,10 @@ void HLRAlgo_PolyAlgo::Hide (Standard_Address& Coordinates,
Standard_Boolean& intl)
{
HLRAlgo_BiPoint& BP = mySegListIt.Value();
Coordinates = BP.Coordinates();
const Standard_Address IndexPtr = BP.Indices();
status = HLRAlgo_EdgeStatus(0.,(Standard_ShortReal)myTolParam,1.,(Standard_ShortReal)myTolParam);
Index = ShapeIndex;
HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
HLRAlgo_BiPoint::IndicesT& theIndices = BP.Indices();
status = HLRAlgo_EdgeStatus(0.,(Standard_ShortReal)myTriangle.TolParam,1.,(Standard_ShortReal)myTriangle.TolParam);
Index = theIndices.ShapeIndex;
reg1 = BP.Rg1Line();
regn = BP.RgNLine();
outl = BP.OutLine();
@ -454,9 +389,9 @@ void HLRAlgo_PolyAlgo::Hide (Standard_Address& Coordinates,
for (Standard_Integer s = 1; s <= myNbrShell; s++) {
if ((*psd)->Hiding()) {
const Standard_Address ShellIndices = (*psd)->Indices();
if (((MaxShell - MinSeg) & 0x80100200) == 0 &&
((MaxSeg - MinShell) & 0x80100000) == 0) {
HLRAlgo_PolyShellData::ShellIndices& aShellIndices = (*psd)->Indices();
if (((aShellIndices.Max - theIndices.MinSeg) & 0x80100200) == 0 &&
((theIndices.MaxSeg - aShellIndices.Min) & 0x80100000) == 0) {
HidingShell = (s == myCurShell);
TColStd_Array1OfTransient& Face = (*psd)->HidingPolyData();
Standard_Integer nbFace = Face.Upper();
@ -464,9 +399,9 @@ void HLRAlgo_PolyAlgo::Hide (Standard_Address& Coordinates,
(Handle(HLRAlgo_PolyData)*)&(Face.ChangeValue(1));
for (Standard_Integer f = 1; f <= nbFace; f++) {
(*pd)->HideByPolyData(Coordinates,
(Standard_Address)myRealPtr,
IndexPtr,
(*pd)->HideByPolyData(aPoints,
myTriangle,
theIndices,
HidingShell,
status);
pd++;
@ -476,6 +411,7 @@ void HLRAlgo_PolyAlgo::Hide (Standard_Address& Coordinates,
psd++;
}
}
return aPoints;
}
//=======================================================================
@ -508,7 +444,7 @@ void HLRAlgo_PolyAlgo::NextShow ()
//purpose :
//=======================================================================
void HLRAlgo_PolyAlgo::Show (Standard_Address& Coordinates,
HLRAlgo_BiPoint::PointsT& HLRAlgo_PolyAlgo::Show (
Standard_Integer& Index,
Standard_Boolean& reg1,
Standard_Boolean& regn,
@ -516,12 +452,13 @@ void HLRAlgo_PolyAlgo::Show (Standard_Address& Coordinates,
Standard_Boolean& intl)
{
HLRAlgo_BiPoint& BP = mySegListIt.Value();
Standard_Address IndexPtr = BP.Indices();
Coordinates = BP.Coordinates();
Index = ShapeIndex;
HLRAlgo_BiPoint::IndicesT& theIndices = BP.Indices();
HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
Index = theIndices.ShapeIndex;
reg1 = BP.Rg1Line();
regn = BP.RgNLine();
outl = BP.OutLine();
intl = BP.IntLine();
return aPoints;
}

10
src/HLRAlgo/HLRAlgo_PolyAlgo.hxx
View File

@ -17,6 +17,8 @@
#ifndef _HLRAlgo_PolyAlgo_HeaderFile
#define _HLRAlgo_PolyAlgo_HeaderFile
#include <HLRAlgo_PolyData.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
@ -27,7 +29,7 @@
#include <Standard_Boolean.hxx>
#include <MMgt_TShared.hxx>
#include <TColStd_Array1OfTransient.hxx>
#include <Standard_Address.hxx>
class HLRAlgo_EdgeStatus;
@ -59,7 +61,7 @@ public:
Standard_EXPORT void NextHide();
//! process hiding between <Pt1> and <Pt2>.
Standard_EXPORT void Hide (Standard_Address& Coordinates, HLRAlgo_EdgeStatus& status, Standard_Integer& Index, Standard_Boolean& reg1, Standard_Boolean& regn, Standard_Boolean& outl, Standard_Boolean& intl);
Standard_EXPORT HLRAlgo_BiPoint::PointsT& Hide (HLRAlgo_EdgeStatus& status, Standard_Integer& Index, Standard_Boolean& reg1, Standard_Boolean& regn, Standard_Boolean& outl, Standard_Boolean& intl);
void InitShow();
@ -68,7 +70,7 @@ public:
Standard_EXPORT void NextShow();
//! process hiding between <Pt1> and <Pt2>.
Standard_EXPORT void Show (Standard_Address& Coordinates, Standard_Integer& Index, Standard_Boolean& reg1, Standard_Boolean& regn, Standard_Boolean& outl, Standard_Boolean& intl);
Standard_EXPORT HLRAlgo_BiPoint::PointsT& Show (Standard_Integer& Index, Standard_Boolean& reg1, Standard_Boolean& regn, Standard_Boolean& outl, Standard_Boolean& intl);
@ -84,7 +86,7 @@ private:
Handle(TColStd_HArray1OfTransient) myHShell;
Standard_Real myRealPtr[10];
HLRAlgo_PolyData::Triangle myTriangle;
HLRAlgo_ListIteratorOfListOfBPoint mySegListIt;
Standard_Integer myNbrShell;
Standard_Integer myCurShell;

512
src/HLRAlgo/HLRAlgo_PolyData.cxx
View File

@ -17,75 +17,12 @@
#include <HLRAlgo_PolyData.hxx>
#include <HLRAlgo_EdgeStatus.hxx>
#include <HLRAlgo_PolyMask.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyData,MMgt_TShared)
#define EMskGrALin1 ((Standard_Integer) 8)
#define EMskGrALin2 ((Standard_Integer) 16)
#define EMskGrALin3 ((Standard_Integer) 32)
#define FMskHiding ((Standard_Integer) 256)
#define FIndex myIndices[0]
#define MinFac myIndices[1]
#define MaxFac myIndices[2]
#define TriNode1 ((Standard_Integer*)TriIndices)[0]
#define TriNode2 ((Standard_Integer*)TriIndices)[1]
#define TriNode3 ((Standard_Integer*)TriIndices)[2]
#define TriFlags ((Standard_Integer*)TriIndices)[3]
#define PntX1 ((Standard_Real*)Coordinates)[ 0]
#define PntY1 ((Standard_Real*)Coordinates)[ 1]
#define PntZ1 ((Standard_Real*)Coordinates)[ 2]
#define PntX2 ((Standard_Real*)Coordinates)[ 3]
#define PntY2 ((Standard_Real*)Coordinates)[ 4]
#define PntZ2 ((Standard_Real*)Coordinates)[ 5]
#define PntXP1 ((Standard_Real*)Coordinates)[ 6]
#define PntYP1 ((Standard_Real*)Coordinates)[ 7]
#define PntZP1 ((Standard_Real*)Coordinates)[ 8]
#define PntXP2 ((Standard_Real*)Coordinates)[ 9]
#define PntYP2 ((Standard_Real*)Coordinates)[10]
#define PntZP2 ((Standard_Real*)Coordinates)[11]
#define XV1 ((Standard_Real*)RealPtr)[0]
#define XV2 ((Standard_Real*)RealPtr)[1]
#define XV3 ((Standard_Real*)RealPtr)[2]
#define YV1 ((Standard_Real*)RealPtr)[3]
#define YV2 ((Standard_Real*)RealPtr)[4]
#define YV3 ((Standard_Real*)RealPtr)[5]
#define Param ((Standard_Real*)RealPtr)[6]
#define TolParam ((Standard_Real*)RealPtr)[7]
#define TolAng ((Standard_Real*)RealPtr)[8]
#define Tolerance ((Standard_Real*)RealPtr)[9]
#define TotXMin ((Standard_Real*)TotMinMax)[0]
#define TotYMin ((Standard_Real*)TotMinMax)[1]
#define TotZMin ((Standard_Real*)TotMinMax)[2]
#define TotXMax ((Standard_Real*)TotMinMax)[3]
#define TotYMax ((Standard_Real*)TotMinMax)[4]
#define TotZMax ((Standard_Real*)TotMinMax)[5]
#define IndexTri ((Standard_Integer*)MinMaxPtr)[0]
#define MinTri ((Standard_Integer*)MinMaxPtr)[1]
#define MaxTri ((Standard_Integer*)MinMaxPtr)[2]
#define APlan ((Standard_Real*)PlanPtr)[0]
#define BPlan ((Standard_Real*)PlanPtr)[1]
#define CPlan ((Standard_Real*)PlanPtr)[2]
#define DPlan ((Standard_Real*)PlanPtr)[3]
#define ShapeIndex ((Standard_Integer*)Indices)[0]
#define FaceConex1 ((Standard_Integer*)Indices)[1]
#define Face1Pt1 ((Standard_Integer*)Indices)[2]
#define Face1Pt2 ((Standard_Integer*)Indices)[3]
#define FaceConex2 ((Standard_Integer*)Indices)[4]
#define Face2Pt1 ((Standard_Integer*)Indices)[5]
#define Face2Pt2 ((Standard_Integer*)Indices)[6]
#define MinSeg ((Standard_Integer*)Indices)[7]
#define MaxSeg ((Standard_Integer*)Indices)[8]
#define SegFlags ((Standard_Integer*)Indices)[9]
#ifdef OCCT_DEBUG
static Standard_Integer ERROR = Standard_False;
#endif
@ -127,7 +64,7 @@ void HLRAlgo_PolyData::HPHDat(const Handle(HLRAlgo_HArray1OfPHDat)& HPHDat)
//=======================================================================
void
HLRAlgo_PolyData::UpdateGlobalMinMax (const Standard_Address TotMinMax)
HLRAlgo_PolyData::UpdateGlobalMinMax (Box& theBox)
{
Standard_Integer i;
Standard_Real X1,X2,X3,Y1,Y2,Y3,Z1,Z2,Z3;
@ -137,11 +74,10 @@ HLRAlgo_PolyData::UpdateGlobalMinMax (const Standard_Address TotMinMax)
HLRAlgo_TriangleData* TD = &(TData.ChangeValue(1));
for (i = 1; i <= nbT; i++) {
const Standard_Address TriIndices = TD->Indices();
if (TriFlags & FMskHiding) {
const gp_XYZ& P1 = Nodes(TriNode1);
const gp_XYZ& P2 = Nodes(TriNode2);
const gp_XYZ& P3 = Nodes(TriNode3);
if (TD->Flags & HLRAlgo_PolyMask_FMskHiding) {
const gp_XYZ& P1 = Nodes(TD->Node1);
const gp_XYZ& P2 = Nodes(TD->Node2);
const gp_XYZ& P3 = Nodes(TD->Node3);
X1 = P1.X();
Y1 = P1.Y();
Z1 = P1.Z();
@ -151,24 +87,24 @@ HLRAlgo_PolyData::UpdateGlobalMinMax (const Standard_Address TotMinMax)
X3 = P3.X();
Y3 = P3.Y();
Z3 = P3.Z();
if (TotXMin > X1) TotXMin = X1;
else if (TotXMax < X1) TotXMax = X1;
if (TotYMin > Y1) TotYMin = Y1;
else if (TotYMax < Y1) TotYMax = Y1;
if (TotZMin > Z1) TotZMin = Z1;
else if (TotZMax < Z1) TotZMax = Z1;
if (TotXMin > X2) TotXMin = X2;
else if (TotXMax < X2) TotXMax = X2;
if (TotYMin > Y2) TotYMin = Y2;
else if (TotYMax < Y2) TotYMax = Y2;
if (TotZMin > Z2) TotZMin = Z2;
else if (TotZMax < Z2) TotZMax = Z2;
if (TotXMin > X3) TotXMin = X3;
else if (TotXMax < X3) TotXMax = X3;
if (TotYMin > Y3) TotYMin = Y3;
else if (TotYMax < Y3) TotYMax = Y3;
if (TotZMin > Z3) TotZMin = Z3;
else if (TotZMax < Z3) TotZMax = Z3;
if (theBox.XMin > X1) theBox.XMin = X1;
else if (theBox.XMax < X1) theBox.XMax = X1;
if (theBox.YMin > Y1) theBox.YMin = Y1;
else if (theBox.YMax < Y1) theBox.YMax = Y1;
if (theBox.ZMin > Z1) theBox.ZMin = Z1;
else if (theBox.ZMax < Z1) theBox.ZMax = Z1;
if (theBox.XMin > X2) theBox.XMin = X2;
else if (theBox.XMax < X2) theBox.XMax = X2;
if (theBox.YMin > Y2) theBox.YMin = Y2;
else if (theBox.YMax < Y2) theBox.YMax = Y2;
if (theBox.ZMin > Z2) theBox.ZMin = Z2;
else if (theBox.ZMax < Z2) theBox.ZMax = Z2;
if (theBox.XMin > X3) theBox.XMin = X3;
else if (theBox.XMax < X3) theBox.XMax = X3;
if (theBox.YMin > Y3) theBox.YMin = Y3;
else if (theBox.YMax < Y3) theBox.YMax = Y3;
if (theBox.ZMin > Z3) theBox.ZMin = Z3;
else if (theBox.ZMax < Z3) theBox.ZMax = Z3;
}
TD++;
}
@ -179,14 +115,14 @@ HLRAlgo_PolyData::UpdateGlobalMinMax (const Standard_Address TotMinMax)
//purpose :
//=======================================================================
void HLRAlgo_PolyData::HideByPolyData (const Standard_Address Coordinates,
const Standard_Address RealPtr,
const Standard_Address Indices,
void HLRAlgo_PolyData::HideByPolyData (const HLRAlgo_BiPoint::PointsT& thePoints,
Triangle& theTriangle,
HLRAlgo_BiPoint::IndicesT& theIndices,
const Standard_Boolean HidingShell,
HLRAlgo_EdgeStatus& status)
{
if (((MaxFac - MinSeg) & 0x80100200) == 0 &&
((MaxSeg - MinFac) & 0x80100000) == 0) {
if (((myFaceIndices.Max - theIndices.MinSeg) & 0x80100200) == 0 &&
((theIndices.MaxSeg - myFaceIndices.Min) & 0x80100000) == 0) {
HLRAlgo_Array1OfPHDat& PHDat = myHPHDat->ChangeArray1();
const HLRAlgo_Array1OfTData& TData = myHTData->Array1();
Standard_Real d1,d2;
@ -194,105 +130,92 @@ void HLRAlgo_PolyData::HideByPolyData (const Standard_Address Coordinates,
Standard_Boolean isCrossing = Standard_False;
Standard_Boolean toHideBefore = Standard_False;
Standard_Integer TFlag = 0;
Standard_Address PlanPtr,MinMaxPtr,TriIndices;
Standard_Integer h,h2 = PHDat.Upper();
HLRAlgo_PolyHidingData* PH = &(PHDat(1));
for (h = 1; h <= h2; h++) {
MinMaxPtr = PH->IndexAndMinMax();
if (((MaxTri - MinSeg) & 0x80100200) == 0 &&
((MaxSeg - MinTri) & 0x80100000) == 0) {
TriIndices = TData(IndexTri).Indices();
HLRAlgo_PolyHidingData::TriangleIndices& aTriangleIndices = PH->Indices();
if (((aTriangleIndices.Max - theIndices.MinSeg) & 0x80100200) == 0 &&
((theIndices.MaxSeg - aTriangleIndices.Min) & 0x80100000) == 0) {
const HLRAlgo_TriangleData& aTriangle = TData(aTriangleIndices.Index);
NotConnex = Standard_True;
if (HidingShell) {
if (FIndex == FaceConex1) {
if (Face1Pt1 == TriNode1)
NotConnex = Face1Pt2 != TriNode2 && Face1Pt2 != TriNode3;
else if (Face1Pt1 == TriNode2)
NotConnex = Face1Pt2 != TriNode3 && Face1Pt2 != TriNode1;
else if (Face1Pt1 == TriNode3)
NotConnex = Face1Pt2 != TriNode1 && Face1Pt2 != TriNode2;
if (myFaceIndices.Index == theIndices.FaceConex1) {
if (theIndices.Face1Pt1 == aTriangle.Node1)
NotConnex = theIndices.Face1Pt2 != aTriangle.Node2 && theIndices.Face1Pt2 != aTriangle.Node3;
else if (theIndices.Face1Pt1 == aTriangle.Node2)
NotConnex = theIndices.Face1Pt2 != aTriangle.Node3 && theIndices.Face1Pt2 != aTriangle.Node1;
else if (theIndices.Face1Pt1 == aTriangle.Node3)
NotConnex = theIndices.Face1Pt2 != aTriangle.Node1 && theIndices.Face1Pt2 != aTriangle.Node2;
}
else if (FIndex == FaceConex2) {
if (Face2Pt1 == TriNode1)
NotConnex = Face2Pt2 != TriNode2 && Face2Pt2 != TriNode3;
else if (Face2Pt1 == TriNode2)
NotConnex = Face2Pt2 != TriNode3 && Face2Pt2 != TriNode1;
else if (Face2Pt1 == TriNode3)
NotConnex = Face2Pt2 != TriNode1 && Face2Pt2 != TriNode2;
else if (myFaceIndices.Index == theIndices.FaceConex2) {
if (theIndices.Face2Pt1 == aTriangle.Node1)
NotConnex = theIndices.Face2Pt2 != aTriangle.Node2 && theIndices.Face2Pt2 != aTriangle.Node3;
else if (theIndices.Face2Pt1 == aTriangle.Node2)
NotConnex = theIndices.Face2Pt2 != aTriangle.Node3 && theIndices.Face2Pt2 != aTriangle.Node1;
else if (theIndices.Face2Pt1 == aTriangle.Node3)
NotConnex = theIndices.Face2Pt2 != aTriangle.Node1 && theIndices.Face2Pt2 != aTriangle.Node2;
}
}
if (NotConnex) {
PlanPtr = PH->Plan();
d1 = APlan * PntXP1 + BPlan * PntYP1 + CPlan * PntZP1 - DPlan;
d2 = APlan * PntXP2 + BPlan * PntYP2 + CPlan * PntZP2 - DPlan;
if (d1 > Tolerance) {
if (d2 < -Tolerance) {
Param = d1 / ( d1 - d2 );
HLRAlgo_PolyHidingData::PlaneT& aPlane = PH->Plane();
d1 = aPlane.Normal * thePoints.PntP1 - aPlane.D;
d2 = aPlane.Normal * thePoints.PntP2 - aPlane.D;
if (d1 > theTriangle.Tolerance) {
if (d2 < -theTriangle.Tolerance) {
theTriangle.Param = d1 / ( d1 - d2 );
toHideBefore = Standard_False;
isCrossing = Standard_True;
TFlag = TriFlags;
TFlag = aTriangle.Flags;
const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
const gp_XYZ & P1 = Nodes(TriNode1);
const gp_XYZ & P2 = Nodes(TriNode2);
const gp_XYZ & P3 = Nodes(TriNode3);
XV1 = P1.X();
YV1 = P1.Y();
XV2 = P2.X();
YV2 = P2.Y();
XV3 = P3.X();
YV3 = P3.Y();
hideByOneTriangle (Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
const gp_XYZ & P1 = Nodes(aTriangle.Node1);
const gp_XYZ & P2 = Nodes(aTriangle.Node2);
const gp_XYZ & P3 = Nodes(aTriangle.Node3);
theTriangle.V1 = gp_XY(P1.X(), P1.Y());
theTriangle.V2 = gp_XY(P2.X(), P2.Y());
theTriangle.V3 = gp_XY(P3.X(), P3.Y());
hideByOneTriangle (thePoints, theTriangle, isCrossing, toHideBefore, TFlag, status);
}
}
else if (d1 < -Tolerance) {
if (d2 > Tolerance) {
Param = d1 / ( d1 - d2 );
else if (d1 < -theTriangle.Tolerance) {
if (d2 > theTriangle.Tolerance) {
theTriangle.Param = d1 / ( d1 - d2 );
toHideBefore = Standard_True;
isCrossing = Standard_True;
TFlag = TriFlags;
TFlag = aTriangle.Flags;
const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
const gp_XYZ & P1 = Nodes(TriNode1);
const gp_XYZ & P2 = Nodes(TriNode2);
const gp_XYZ & P3 = Nodes(TriNode3);
XV1 = P1.X();
YV1 = P1.Y();
XV2 = P2.X();
YV2 = P2.Y();
XV3 = P3.X();
YV3 = P3.Y();
hideByOneTriangle (Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
const gp_XYZ & P1 = Nodes(aTriangle.Node1);
const gp_XYZ & P2 = Nodes(aTriangle.Node2);
const gp_XYZ & P3 = Nodes(aTriangle.Node3);
theTriangle.V1 = gp_XY(P1.X(), P1.Y());
theTriangle.V2 = gp_XY(P2.X(), P2.Y());
theTriangle.V3 = gp_XY(P3.X(), P3.Y());
hideByOneTriangle (thePoints, theTriangle, isCrossing, toHideBefore, TFlag, status);
}
else {
isCrossing = Standard_False;
TFlag = TriFlags;
TFlag = aTriangle.Flags;
const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
const gp_XYZ & P1 = Nodes(TriNode1);
const gp_XYZ & P2 = Nodes(TriNode2);
const gp_XYZ & P3 = Nodes(TriNode3);
XV1 = P1.X();
YV1 = P1.Y();
XV2 = P2.X();
YV2 = P2.Y();
XV3 = P3.X();
YV3 = P3.Y();
hideByOneTriangle (Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
const gp_XYZ & P1 = Nodes(aTriangle.Node1);
const gp_XYZ & P2 = Nodes(aTriangle.Node2);
const gp_XYZ & P3 = Nodes(aTriangle.Node3);
theTriangle.V1 = gp_XY(P1.X(), P1.Y());
theTriangle.V2 = gp_XY(P2.X(), P2.Y());
theTriangle.V3 = gp_XY(P3.X(), P3.Y());
hideByOneTriangle (thePoints, theTriangle, isCrossing, toHideBefore, TFlag, status);
}
}
else if (d2 < -Tolerance) {
else if (d2 < -theTriangle.Tolerance) {
isCrossing = Standard_False;
TFlag = TriFlags;
TFlag = aTriangle.Flags;
const TColgp_Array1OfXYZ& Nodes = myHNodes->Array1();
const gp_XYZ & P1 = Nodes(TriNode1);
const gp_XYZ & P2 = Nodes(TriNode2);
const gp_XYZ & P3 = Nodes(TriNode3);
XV1 = P1.X();
YV1 = P1.Y();
XV2 = P2.X();
YV2 = P2.Y();
XV3 = P3.X();
YV3 = P3.Y();
hideByOneTriangle(Coordinates, RealPtr, isCrossing, toHideBefore, TFlag, status);
const gp_XYZ & P1 = Nodes(aTriangle.Node1);
const gp_XYZ & P2 = Nodes(aTriangle.Node2);
const gp_XYZ & P3 = Nodes(aTriangle.Node3);
theTriangle.V1 = gp_XY(P1.X(), P1.Y());
theTriangle.V2 = gp_XY(P2.X(), P2.Y());
theTriangle.V3 = gp_XY(P3.X(), P3.Y());
hideByOneTriangle(thePoints, theTriangle, isCrossing, toHideBefore, TFlag, status);
}
}
}
@ -306,66 +229,68 @@ void HLRAlgo_PolyData::HideByPolyData (const Standard_Address Coordinates,
//purpose :
//=======================================================================
void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
const Standard_Address RealPtr,
void HLRAlgo_PolyData::hideByOneTriangle (const HLRAlgo_BiPoint::PointsT& thePoints,
Triangle& theTriangle,
const Standard_Boolean Crossing,
const Standard_Boolean HideBefore,
const Standard_Integer TrFlags,
HLRAlgo_EdgeStatus& status)
{
Standard_Boolean o[2],m[2];
Standard_Integer l,n1=0,nn1,nn2,npi=-1,npiRej=0;
Standard_Real a,b,c,da,db,d1,d2,p[2]={0.,0.},pd1,pd2,pdp,pp,psta=0.,pend=1.;
Standard_Boolean CrosSeg;
Standard_Boolean CrosSeg = Standard_False;
Standard_Integer n1 = 0;
Standard_Real pd1 = 0., pd2 = 0.;
Standard_Integer nn1 = 0, nn2 = 0;
Standard_Real pend = 1., psta = 0., pp = 0., pdp = 0.;
Standard_Integer npi = -1;
Standard_Boolean o[] = {Standard_False, Standard_False};
Standard_Boolean m[] = {Standard_False, Standard_False};
Standard_Real p[] = {0., 0.};
Standard_Integer npiRej = 0;
da = XV2 - XV1;
db = YV2 - YV1;
a = -db;
b = da;
c = sqrt( a * a + b * b);
a /= c;
b /= c;
c = a * XV1 + b * YV1;
d1 = a * PntXP1 + b * PntYP1 - c;
d2 = a * PntXP2 + b * PntYP2 - c;
if (d1 > Tolerance) {
if (d2 < -Tolerance) {
{
const gp_XY aD = theTriangle.V2 - theTriangle.V1;
const gp_XY aA = (1 / aD.Modulus()) * gp_XY(-aD.Y(), aD.X());
const Standard_Real aDot = aA * theTriangle.V1;
const Standard_Real d1 = aA * thePoints.PntP12D() - aDot;
const Standard_Real d2 = aA * thePoints.PntP22D() - aDot;
if (d1 > theTriangle.Tolerance) {
if (d2 < -theTriangle.Tolerance) {
n1 = 2;
CrosSeg = Standard_True;
}
else
CrosSeg = Standard_False;
}
else if (d1 < -Tolerance) {
if (d2 > Tolerance) {
else if (d1 < -theTriangle.Tolerance) {
if (d2 > theTriangle.Tolerance) {
n1 = -1;
CrosSeg = Standard_True;
}
else return;
}
else {
if (d2 > Tolerance)
if (d2 > theTriangle.Tolerance)
CrosSeg = Standard_False;
else if (d2 < -Tolerance) return;
else if (d2 < -theTriangle.Tolerance) return;
else {
CrosSeg = Standard_False;
if (TrFlags & EMskGrALin1) {
pd1 = (PntXP1 - XV1) / da;
pd2 = (PntXP2 - XV1) / da;
if (TrFlags & HLRAlgo_PolyMask_EMskGrALin1) {
pd1 = (thePoints.PntP1.X() - theTriangle.V1.X()) / aD.X();
pd2 = (thePoints.PntP2.X() - theTriangle.V1.X()) / aD.X();
}
else {
pd1 = (PntYP1 - YV1) / db;
pd2 = (PntYP2 - YV1) / db;
pd1 = (thePoints.PntP1.Y() - theTriangle.V1.Y()) / aD.Y();
pd2 = (thePoints.PntP2.Y() - theTriangle.V1.Y()) / aD.Y();
}
if (pd1 < -TolParam) nn1 = 1;
else if (pd1 < TolParam) nn1 = 2;
else if (pd1 - 1. < -TolParam) nn1 = 3;
else if (pd1 - 1. < TolParam) nn1 = 4;
if (pd1 < -theTriangle.TolParam) nn1 = 1;
else if (pd1 < theTriangle.TolParam) nn1 = 2;
else if (pd1 - 1. < -theTriangle.TolParam) nn1 = 3;
else if (pd1 - 1. < theTriangle.TolParam) nn1 = 4;
else nn1 = 5;
if (pd2 < -TolParam) nn2 = 1;
else if (pd2 < TolParam) nn2 = 2;
else if (pd2 - 1. < -TolParam) nn2 = 3;
else if (pd2 - 1. < TolParam) nn2 = 4;
if (pd2 < -theTriangle.TolParam) nn2 = 1;
else if (pd2 < theTriangle.TolParam) nn2 = 2;
else if (pd2 - 1. < -theTriangle.TolParam) nn2 = 3;
else if (pd2 - 1. < theTriangle.TolParam) nn2 = 4;
else nn2 = 5;
if (nn1 == 3) {
if (nn2 == 1) pend = pd1 / (pd1 - pd2);
@ -401,17 +326,17 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
Standard_Real ad2 = d2;
if (d2 < 0) ad2 = -d2;
pp = ad1 / ( ad1 + ad2 );
if (TrFlags & EMskGrALin1)
pdp = (PntXP1 + (PntXP2 - PntXP1) * pp - XV1) / da;
if (TrFlags & HLRAlgo_PolyMask_EMskGrALin1)
pdp = (thePoints.PntP1.X() + (thePoints.PntP2.X() - thePoints.PntP1.X()) * pp - theTriangle.V1.X()) / aD.X();
else
pdp = (PntYP1 + (PntYP2 - PntYP1) * pp - YV1) / db;
pdp = (thePoints.PntP1.Y() + (thePoints.PntP2.Y() - thePoints.PntP1.Y()) * pp - theTriangle.V1.Y()) / aD.Y();
Standard_Boolean OutSideP = Standard_False;
Standard_Boolean Multiple = Standard_False;
if (pdp < -TolParam) OutSideP = Standard_True;
else if (pdp < TolParam) {
if (pdp < -theTriangle.TolParam) OutSideP = Standard_True;
else if (pdp < theTriangle.TolParam) {
Multiple = Standard_True;
for (l = 0; l <= npi; l++) {
for (Standard_Integer l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
@ -427,11 +352,11 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
}
}
}
else if (pdp - 1. < -TolParam) {}
else if (pdp - 1. < TolParam) {
else if (pdp - 1. < -theTriangle.TolParam) {}
else if (pdp - 1. < theTriangle.TolParam) {
Multiple = Standard_True;
for (l = 0; l <= npi; l++) {
for (Standard_Integer l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (n1 == -1)) {
@ -463,55 +388,52 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
#endif
}
}
}
da = XV3 - XV2;
db = YV3 - YV2;
a = -db;
b = da;
c = sqrt(a * a + b * b);
a /= c;
b /= c;
c = a * XV2 + b * YV2;
d1 = a * PntXP1 + b * PntYP1 - c;
d2 = a * PntXP2 + b * PntYP2 - c;
if (d1 > Tolerance) {
if (d2 < -Tolerance) {
{
const gp_XY aD = theTriangle.V3 - theTriangle.V2;
const gp_XY aA = (1 / aD.Modulus()) * gp_XY(-aD.Y(), aD.X());
const Standard_Real aDot = aA * theTriangle.V2;
const Standard_Real d1 = aA * thePoints.PntP12D() - aDot;
const Standard_Real d2 = aA * thePoints.PntP22D() - aDot;
if (d1 > theTriangle.Tolerance) {
if (d2 < -theTriangle.Tolerance) {
n1 = 2;
CrosSeg = Standard_True;
}
else
CrosSeg = Standard_False;
}
else if (d1 < -Tolerance) {
if (d2 > Tolerance) {
else if (d1 < -theTriangle.Tolerance) {
if (d2 > theTriangle.Tolerance) {
n1 = -1;
CrosSeg = Standard_True;
}
else return;
}
else {
if (d2 > Tolerance)
if (d2 > theTriangle.Tolerance)
CrosSeg = Standard_False;
else if (d2 < -Tolerance) return;
else if (d2 < -theTriangle.Tolerance) return;
else {
CrosSeg = Standard_False;
if (TrFlags & EMskGrALin2) {
pd1 = (PntXP1 - XV2) / da;
pd2 = (PntXP2 - XV2) / da;
if (TrFlags & HLRAlgo_PolyMask_EMskGrALin2) {
pd1 = (thePoints.PntP1.X() - theTriangle.V2.X()) / aD.X();
pd2 = (thePoints.PntP2.X() - theTriangle.V2.X()) / aD.X();
}
else {
pd1 = (PntYP1 - YV2) / db;
pd2 = (PntYP2 - YV2) / db;
pd1 = (thePoints.PntP1.Y() - theTriangle.V2.Y()) / aD.Y();
pd2 = (thePoints.PntP2.Y() - theTriangle.V2.Y()) / aD.Y();
}
if (pd1 < -TolParam) nn1 = 1;
else if (pd1 < TolParam) nn1 = 2;
else if (pd1 - 1. < -TolParam) nn1 = 3;
else if (pd1 - 1. < TolParam) nn1 = 4;
if (pd1 < -theTriangle.TolParam) nn1 = 1;
else if (pd1 < theTriangle.TolParam) nn1 = 2;
else if (pd1 - 1. < -theTriangle.TolParam) nn1 = 3;
else if (pd1 - 1. < theTriangle.TolParam) nn1 = 4;
else nn1 = 5;
if (pd2 < -TolParam) nn2 = 1;
else if (pd2 < TolParam) nn2 = 2;
else if (pd2 - 1. < -TolParam) nn2 = 3;
else if (pd2 - 1. < TolParam) nn2 = 4;
if (pd2 < -theTriangle.TolParam) nn2 = 1;
else if (pd2 < theTriangle.TolParam) nn2 = 2;
else if (pd2 - 1. < -theTriangle.TolParam) nn2 = 3;
else if (pd2 - 1. < theTriangle.TolParam) nn2 = 4;
else nn2 = 5;
if (nn1 == 3) {
if (nn2 == 1) pend = pd1 / (pd1 - pd2);
@ -547,17 +469,17 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
Standard_Real ad2 = d2;
if (d2 < 0) ad2 = -d2;
pp = ad1 / ( ad1 + ad2 );
if (TrFlags & EMskGrALin2)
pdp = (PntXP1 + (PntXP2 - PntXP1) * pp - XV2) / da;
if (TrFlags & HLRAlgo_PolyMask_EMskGrALin2)
pdp = (thePoints.PntP1.X() + (thePoints.Pnt2.X() - thePoints.PntP1.X()) * pp - theTriangle.V2.X()) / aD.X();
else
pdp = (PntYP1 + (PntYP2 - PntYP1) * pp - YV2) / db;
pdp = (thePoints.PntP1.Y() + (thePoints.PntP2.Y() - thePoints.PntP1.Y()) * pp - theTriangle.V2.Y()) / aD.Y();
Standard_Boolean OutSideP = Standard_False;
Standard_Boolean Multiple = Standard_False;
if (pdp < -TolParam) OutSideP = Standard_True;
else if (pdp < TolParam) {
if (pdp < -theTriangle.TolParam) OutSideP = Standard_True;
else if (pdp < theTriangle.TolParam) {
Multiple = Standard_True;
for (l = 0; l <= npi; l++) {
for (Standard_Integer l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (n1 == -1)) {
@ -572,11 +494,11 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
}
}
}
else if (pdp - 1. < -TolParam) {}
else if (pdp - 1. < TolParam) {
else if (pdp - 1. < -theTriangle.TolParam) {}
else if (pdp - 1. < theTriangle.TolParam) {
Multiple = Standard_True;
for (l = 0; l <= npi; l++) {
for (Standard_Integer l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (n1 == -1)) {
@ -608,55 +530,52 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
#endif
}
}
}
da = XV1 - XV3;
db = YV1 - YV3;
a = -db;
b = da;
c = sqrt(a * a + b * b);
a /= c;
b /= c;
c = a * XV3 + b * YV3;
d1 = a * PntXP1 + b * PntYP1 - c;
d2 = a * PntXP2 + b * PntYP2 - c;
if (d1 > Tolerance) {
if (d2 < -Tolerance) {
{
const gp_XY aD = theTriangle.V1 - theTriangle.V3;
const gp_XY aA = (1 / aD.Modulus()) * gp_XY(-aD.Y(), aD.X());
const Standard_Real aDot = aA * theTriangle.V3;
const Standard_Real d1 = aA * thePoints.PntP12D() - aDot;
const Standard_Real d2 = aA * thePoints.PntP22D() - aDot;
if (d1 > theTriangle.Tolerance) {
if (d2 < -theTriangle.Tolerance) {
n1 = 2;
CrosSeg = Standard_True;
}
else
CrosSeg = Standard_False;
}
else if (d1 < -Tolerance) {
if (d2 > Tolerance) {
else if (d1 < -theTriangle.Tolerance) {
if (d2 > theTriangle.Tolerance) {
n1 = -1;
CrosSeg = Standard_True;
}
else return;
}
else {
if (d2 > Tolerance)
if (d2 > theTriangle.Tolerance)
CrosSeg = Standard_False;
else if (d2 < -Tolerance) return;
else if (d2 < -theTriangle.Tolerance) return;
else {
CrosSeg = Standard_False;
if (TrFlags & EMskGrALin3) {
pd1 = (PntXP1 - XV3) / da;
pd2 = (PntXP2 - XV3) / da;
if (TrFlags & HLRAlgo_PolyMask_EMskGrALin3) {
pd1 = (thePoints.PntP1.X() - theTriangle.V3.X()) / aD.X();
pd2 = (thePoints.PntP2.X() - theTriangle.V3.X()) / aD.X();
}
else {
pd1 = (PntYP1 - YV3) / db;
pd2 = (PntYP2 - YV3) / db;
pd1 = (thePoints.PntP1.Y() - theTriangle.V3.Y()) / aD.Y();
pd2 = (thePoints.PntP2.Y() - theTriangle.V3.Y()) / aD.Y();
}
if (pd1 < -TolParam) nn1 = 1;
else if (pd1 < TolParam) nn1 = 2;
else if (pd1 - 1. < -TolParam) nn1 = 3;
else if (pd1 - 1. < TolParam) nn1 = 4;
if (pd1 < -theTriangle.TolParam) nn1 = 1;
else if (pd1 < theTriangle.TolParam) nn1 = 2;
else if (pd1 - 1. < -theTriangle.TolParam) nn1 = 3;
else if (pd1 - 1. < theTriangle.TolParam) nn1 = 4;
else nn1 = 5;
if (pd2 < -TolParam) nn2 = 1;
else if (pd2 < TolParam) nn2 = 2;
else if (pd2 - 1. < -TolParam) nn2 = 3;
else if (pd2 - 1. < TolParam) nn2 = 4;
if (pd2 < -theTriangle.TolParam) nn2 = 1;
else if (pd2 < theTriangle.TolParam) nn2 = 2;
else if (pd2 - 1. < -theTriangle.TolParam) nn2 = 3;
else if (pd2 - 1. < theTriangle.TolParam) nn2 = 4;
else nn2 = 5;
if (nn1 == 3) {
if (nn2 == 1) pend = pd1 / (pd1 - pd2);
@ -692,17 +611,17 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
Standard_Real ad2 = d2;
if (d2 < 0) ad2 = -d2;
pp = ad1 / ( ad1 + ad2 );
if (TrFlags & EMskGrALin3)
pdp = (PntXP1 + (PntXP2 - PntXP1) * pp - XV3) / da;
if (TrFlags & HLRAlgo_PolyMask_EMskGrALin3)
pdp = (thePoints.PntP1.X() + (thePoints.PntP2.X() - thePoints.PntP1.X()) * pp - theTriangle.V3.X()) / aD.X();
else
pdp = (PntYP1 + (PntYP2 - PntYP1) * pp - YV3) / db;
pdp = (thePoints.PntP1.Y() + (thePoints.PntP2.Y() - thePoints.PntP1.Y()) * pp - theTriangle.V3.Y()) / aD.Y();
Standard_Boolean OutSideP = Standard_False;
Standard_Boolean Multiple = Standard_False;
if (pdp < -TolParam) OutSideP = Standard_True;
else if (pdp < TolParam) {
if (pdp < -theTriangle.TolParam) OutSideP = Standard_True;
else if (pdp < theTriangle.TolParam) {
Multiple = Standard_True;
for (l = 0; l <= npi; l++) {
for (Standard_Integer l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (n1 == -1)) {
@ -717,11 +636,11 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
}
}
}
else if (pdp - 1. < -TolParam) {}
else if (pdp - 1. < TolParam) {
else if (pdp - 1. < -theTriangle.TolParam) {}
else if (pdp - 1. < theTriangle.TolParam) {
Multiple = Standard_True;
for (l = 0; l <= npi; l++) {
for (Standard_Integer l = 0; l <= npi; l++) {
if (m[l]) {
OutSideP = Standard_True;
if (o[l] != (n1 == -1)) {
@ -753,7 +672,8 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
#endif
}
}
}
if (npi == -1) {
if (npiRej >= 2) return;
}
@ -780,24 +700,24 @@ void HLRAlgo_PolyData::hideByOneTriangle (const Standard_Address Coordinates,
if (Crossing) {
if (HideBefore) {
if (Param-psta < TolParam) return;
else if (Param < pend) pend = Param;
if (theTriangle.Param - psta < theTriangle.TolParam) return;
else if (theTriangle.Param < pend) pend = theTriangle.Param;
}
else {
if (pend-Param < TolParam) return;
else if (psta < Param) psta = Param;
if (pend - theTriangle.Param < theTriangle.TolParam) return;
else if (psta < theTriangle.Param) psta = theTriangle.Param;
}
}
Standard_Boolean total;
if (psta > 0) total = psta < TolParam;
else total = psta > -TolParam;
if (psta > 0) total = psta < theTriangle.TolParam;
else total = psta > -theTriangle.TolParam;
if (total) {
Standard_Real pfin = pend - 1.;
if (pfin > 0) total = pfin < TolParam;
else total = pfin > -TolParam;
if (pfin > 0) total = pfin < theTriangle.TolParam;
else total = pfin > -theTriangle.TolParam;
}
if (total) status.HideAll();
else status.Hide(psta,(Standard_ShortReal)TolParam,pend,(Standard_ShortReal)TolParam,
else status.Hide(psta,(Standard_ShortReal)theTriangle.TolParam,pend,(Standard_ShortReal)theTriangle.TolParam,
Standard_False,Standard_False);
}

57
src/HLRAlgo/HLRAlgo_PolyData.hxx
View File

@ -17,6 +17,7 @@
#ifndef _HLRAlgo_PolyData_HeaderFile
#define _HLRAlgo_PolyData_HeaderFile
#include <HLRAlgo_BiPoint.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
@ -28,10 +29,9 @@
#include <TColgp_Array1OfXYZ.hxx>
#include <HLRAlgo_Array1OfTData.hxx>
#include <HLRAlgo_Array1OfPHDat.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
class HLRAlgo_EdgeStatus;
class HLRAlgo_EdgeStatus;
class HLRAlgo_PolyData;
DEFINE_STANDARD_HANDLE(HLRAlgo_PolyData, MMgt_TShared)
@ -41,8 +41,44 @@ class HLRAlgo_PolyData : public MMgt_TShared
{
public:
struct FaceIndices
{
Standard_Integer Index, Min, Max;
};
struct Triangle
{
gp_XY V1, V2, V3;
Standard_Real Param, TolParam, TolAng, Tolerance;
};
struct Box
{
Standard_Real XMin, YMin, ZMin, XMax, YMax, ZMax;
//! The default constructor.
Box()
{
}
//! The initializing constructor.
Box(
const Standard_Real& theXMin,
const Standard_Real& theYMin,
const Standard_Real& theZMin,
const Standard_Real& theXMax,
const Standard_Real& theYMax,
const Standard_Real& theZMax) :
XMin(theXMin),
YMin(theYMin),
ZMin(theZMin),
XMax(theXMax),
YMax(theYMax),
ZMax(theZMax)
{
}
};
Standard_EXPORT HLRAlgo_PolyData();
Standard_EXPORT void HNodes (const Handle(TColgp_HArray1OfXYZ)& HNodes);
@ -61,28 +97,31 @@ public:
HLRAlgo_Array1OfPHDat& PHDat() const;
Standard_EXPORT void UpdateGlobalMinMax (const Standard_Address ToTMinMax);
Standard_EXPORT void UpdateGlobalMinMax (Box& theBox);
Standard_Boolean Hiding() const;
//! process hiding between <Pt1> and <Pt2>.
Standard_EXPORT void HideByPolyData (const Standard_Address Coordinates, const Standard_Address RealPtr, const Standard_Address Indices, const Standard_Boolean HidingShell, HLRAlgo_EdgeStatus& status);
Standard_EXPORT void HideByPolyData (const HLRAlgo_BiPoint::PointsT& thePoints, Triangle& theTriangle, HLRAlgo_BiPoint::IndicesT& theIndices, const Standard_Boolean HidingShell, HLRAlgo_EdgeStatus& status);
Standard_Address Indices();
FaceIndices& Indices()
{
return myFaceIndices;
}
DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyData,MMgt_TShared)
private:
//! evident.
void hideByOneTriangle (const Standard_Address Coordinates,
const Standard_Address RealPtr,
void hideByOneTriangle (const HLRAlgo_BiPoint::PointsT& thePoints,
Triangle& theTriangle,
const Standard_Boolean Crossing,
const Standard_Boolean HideBefore,
const Standard_Integer TrFlags,
HLRAlgo_EdgeStatus& status);
Standard_Integer myIndices[3];
FaceIndices myFaceIndices;
Handle(TColgp_HArray1OfXYZ) myHNodes;
Handle(HLRAlgo_HArray1OfTData) myHTData;
Handle(HLRAlgo_HArray1OfPHDat) myHPHDat;

16
src/HLRAlgo/HLRAlgo_PolyData.lxx
View File

@ -25,7 +25,9 @@
inline void
HLRAlgo_PolyData::FaceIndex (const Standard_Integer I)
{ myIndices[0] = I; }
{
myFaceIndices.Index = I;
}
//=======================================================================
//function : FaceIndex
@ -34,7 +36,9 @@ HLRAlgo_PolyData::FaceIndex (const Standard_Integer I)
inline Standard_Integer
HLRAlgo_PolyData::FaceIndex () const
{ return myIndices[0]; }
{
return myFaceIndices.Index;
}
//=======================================================================
//function : Nodes
@ -70,11 +74,3 @@ HLRAlgo_PolyData::PHDat () const
inline Standard_Boolean HLRAlgo_PolyData::Hiding () const
{ return !myHPHDat.IsNull(); }
//=======================================================================
//function : Indices
//purpose :
//=======================================================================
inline Standard_Address HLRAlgo_PolyData::Indices ()
{ return (Standard_Address)myIndices; }

67
src/HLRAlgo/HLRAlgo_PolyHidingData.hxx
View File

@ -23,49 +23,58 @@
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Standard_Address.hxx>
//! Data structure of a set of Hiding Triangles.
class HLRAlgo_PolyHidingData
class HLRAlgo_PolyHidingData
{
public:
DEFINE_STANDARD_ALLOC
HLRAlgo_PolyHidingData();
void Set (const Standard_Integer Index, const Standard_Integer Minim, const Standard_Integer Maxim, const Standard_Real A, const Standard_Real B, const Standard_Real C, const Standard_Real D);
Standard_Address IndexAndMinMax() const;
Standard_Address Plan() const;
struct TriangleIndices
{
Standard_Integer Index, Min, Max;
};
struct PlaneT
{
gp_XYZ Normal;
Standard_Real D;
};
HLRAlgo_PolyHidingData()
{
}
void Set (
const Standard_Integer Index,
const Standard_Integer Minim,
const Standard_Integer Maxim,
const Standard_Real A,
const Standard_Real B,
const Standard_Real C,
const Standard_Real D)
{
myIndices.Index = Index;
myIndices.Min = Minim;
myIndices.Max = Maxim;
myPlane.Normal = gp_XYZ(A, B, C);
myPlane.D = D;
}
protected:
TriangleIndices& Indices()
{
return myIndices;
}
PlaneT& Plane()
{
return myPlane;
}
private:
Standard_Integer myMinMax[3];
Standard_Real myPlan[4];
TriangleIndices myIndices;
PlaneT myPlane;
};
#include <HLRAlgo_PolyHidingData.lxx>
#endif // _HLRAlgo_PolyHidingData_HeaderFile

64
src/HLRAlgo/HLRAlgo_PolyHidingData.lxx
View File

@ -1,64 +0,0 @@
// Created on: 1995-06-21
// Created by: Christophe MARION
// Copyright (c) 1995-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.
//=======================================================================
//function : PolyHidingData
//purpose :
//=======================================================================
inline HLRAlgo_PolyHidingData::HLRAlgo_PolyHidingData ()
{}
//=======================================================================
//function : Set
//purpose :
//=======================================================================
inline void
HLRAlgo_PolyHidingData::Set (const Standard_Integer Index,
const Standard_Integer Minim,
const Standard_Integer Maxim,
const Standard_Real A,
const Standard_Real B,
const Standard_Real C,
const Standard_Real D)
{
myMinMax[0] = Index;
myMinMax[1] = Minim;
myMinMax[2] = Maxim;
myPlan[0] = A;
myPlan[1] = B;
myPlan[2] = C;
myPlan[3] = D;
}
//=======================================================================
//function : IndexAndMinMax
//purpose :
//=======================================================================
inline Standard_Address
HLRAlgo_PolyHidingData::IndexAndMinMax() const
{ return (Standard_Address)myMinMax; }
//=======================================================================
//function : Plan
//purpose :
//=======================================================================
inline Standard_Address
HLRAlgo_PolyHidingData::Plan() const
{ return (Standard_Address)myPlan; }

693
src/HLRAlgo/HLRAlgo_PolyInternalData.cxx
View File

@ -22,97 +22,6 @@
IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyInternalData,MMgt_TShared)
#define Tri1Node1 ((Standard_Integer*)Tri1Indices)[0]
#define Tri1Node2 ((Standard_Integer*)Tri1Indices)[1]
#define Tri1Node3 ((Standard_Integer*)Tri1Indices)[2]
#define Tri1Flags ((Standard_Integer*)Tri1Indices)[3]
#define Tri2Node1 ((Standard_Integer*)Tri2Indices)[0]
#define Tri2Node2 ((Standard_Integer*)Tri2Indices)[1]
#define Tri2Node3 ((Standard_Integer*)Tri2Indices)[2]
#define Tri2Flags ((Standard_Integer*)Tri2Indices)[3]
#define Seg1LstSg1 ((Standard_Integer*)Seg1Indices)[0]
#define Seg1LstSg2 ((Standard_Integer*)Seg1Indices)[1]
#define Seg1NxtSg1 ((Standard_Integer*)Seg1Indices)[2]
#define Seg1NxtSg2 ((Standard_Integer*)Seg1Indices)[3]
#define Seg1Conex1 ((Standard_Integer*)Seg1Indices)[4]
#define Seg1Conex2 ((Standard_Integer*)Seg1Indices)[5]
#define Seg2LstSg1 ((Standard_Integer*)Seg2Indices)[0]
#define Seg2LstSg2 ((Standard_Integer*)Seg2Indices)[1]
#define Seg2NxtSg1 ((Standard_Integer*)Seg2Indices)[2]
#define Seg2NxtSg2 ((Standard_Integer*)Seg2Indices)[3]
#define Seg2Conex1 ((Standard_Integer*)Seg2Indices)[4]
#define Seg2Conex2 ((Standard_Integer*)Seg2Indices)[5]
#define Nod1NdSg ((Standard_Integer*)Nod1Indices)[0]
#define Nod1Flag ((Standard_Integer*)Nod1Indices)[1]
#define Nod1Edg1 ((Standard_Integer*)Nod1Indices)[2]
#define Nod1Edg2 ((Standard_Integer*)Nod1Indices)[3]
#define Nod1PntX ((Standard_Real*)Nod1RValues)[ 0]
#define Nod1PntY ((Standard_Real*)Nod1RValues)[ 1]
#define Nod1PntZ ((Standard_Real*)Nod1RValues)[ 2]
#define Nod1PntU ((Standard_Real*)Nod1RValues)[ 3]
#define Nod1PntV ((Standard_Real*)Nod1RValues)[ 4]
#define Nod1NrmX ((Standard_Real*)Nod1RValues)[ 5]
#define Nod1NrmY ((Standard_Real*)Nod1RValues)[ 6]
#define Nod1NrmZ ((Standard_Real*)Nod1RValues)[ 7]
#define Nod1PCu1 ((Standard_Real*)Nod1RValues)[ 8]
#define Nod1PCu2 ((Standard_Real*)Nod1RValues)[ 9]
#define Nod1Scal ((Standard_Real*)Nod1RValues)[10]
#define Nod2NdSg ((Standard_Integer*)Nod2Indices)[0]
#define Nod2Flag ((Standard_Integer*)Nod2Indices)[1]
#define Nod2Edg1 ((Standard_Integer*)Nod2Indices)[2]
#define Nod2Edg2 ((Standard_Integer*)Nod2Indices)[3]
#define Nod2PntX ((Standard_Real*)Nod2RValues)[ 0]
#define Nod2PntY ((Standard_Real*)Nod2RValues)[ 1]
#define Nod2PntZ ((Standard_Real*)Nod2RValues)[ 2]
#define Nod2PntU ((Standard_Real*)Nod2RValues)[ 3]
#define Nod2PntV ((Standard_Real*)Nod2RValues)[ 4]
#define Nod2NrmX ((Standard_Real*)Nod2RValues)[ 5]
#define Nod2NrmY ((Standard_Real*)Nod2RValues)[ 6]
#define Nod2NrmZ ((Standard_Real*)Nod2RValues)[ 7]
#define Nod2PCu1 ((Standard_Real*)Nod2RValues)[ 8]
#define Nod2PCu2 ((Standard_Real*)Nod2RValues)[ 9]
#define Nod2Scal ((Standard_Real*)Nod2RValues)[10]
#define Nod3NdSg ((Standard_Integer*)Nod3Indices)[0]
#define Nod3Flag ((Standard_Integer*)Nod3Indices)[1]
#define Nod3Edg1 ((Standard_Integer*)Nod3Indices)[2]
#define Nod3Edg2 ((Standard_Integer*)Nod3Indices)[3]
#define Nod3PntX ((Standard_Real*)Nod3RValues)[ 0]
#define Nod3PntY ((Standard_Real*)Nod3RValues)[ 1]
#define Nod3PntZ ((Standard_Real*)Nod3RValues)[ 2]
#define Nod3PntU ((Standard_Real*)Nod3RValues)[ 3]
#define Nod3PntV ((Standard_Real*)Nod3RValues)[ 4]
#define Nod3NrmX ((Standard_Real*)Nod3RValues)[ 5]
#define Nod3NrmY ((Standard_Real*)Nod3RValues)[ 6]
#define Nod3NrmZ ((Standard_Real*)Nod3RValues)[ 7]
#define Nod3PCu1 ((Standard_Real*)Nod3RValues)[ 8]
#define Nod3PCu2 ((Standard_Real*)Nod3RValues)[ 9]
#define Nod3Scal ((Standard_Real*)Nod3RValues)[10]
#define Nod4NdSg ((Standard_Integer*)Nod4Indices)[0]
#define Nod4Flag ((Standard_Integer*)Nod4Indices)[1]
#define Nod4Edg1 ((Standard_Integer*)Nod4Indices)[2]
#define Nod4Edg2 ((Standard_Integer*)Nod4Indices)[3]
#define Nod4PntX ((Standard_Real*)Nod4RValues)[ 0]
#define Nod4PntY ((Standard_Real*)Nod4RValues)[ 1]
#define Nod4PntZ ((Standard_Real*)Nod4RValues)[ 2]
#define Nod4PntU ((Standard_Real*)Nod4RValues)[ 3]
#define Nod4PntV ((Standard_Real*)Nod4RValues)[ 4]
#define Nod4NrmX ((Standard_Real*)Nod4RValues)[ 5]
#define Nod4NrmY ((Standard_Real*)Nod4RValues)[ 6]
#define Nod4NrmZ ((Standard_Real*)Nod4RValues)[ 7]
#define Nod4PCu1 ((Standard_Real*)Nod4RValues)[ 8]
#define Nod4PCu2 ((Standard_Real*)Nod4RValues)[ 9]
#define Nod4Scal ((Standard_Real*)Nod4RValues)[10]
#ifdef OCCT_DEBUG
static Standard_Integer TRACE = Standard_False;
static Standard_Integer ERROR = Standard_False;
@ -141,8 +50,7 @@ HLRAlgo_PolyInternalData::HLRAlgo_PolyInternalData
HLRAlgo_Array1OfPINod& PINod = myPINod->ChangeArray1();
Handle(HLRAlgo_PolyInternalNode)* NN = &(PINod.ChangeValue(1));
// Standard_Address Nod1Indices;
for (i = 1; i <= myMxPINod; i++) {
*NN = new HLRAlgo_PolyInternalNode();
NN++;
@ -155,230 +63,225 @@ HLRAlgo_PolyInternalData::HLRAlgo_PolyInternalData
//=======================================================================
void HLRAlgo_PolyInternalData::UpdateLinks
(Standard_Address& TData,
Standard_Address& PISeg,
Standard_Address& PINod)
(HLRAlgo_Array1OfTData*& TData,
HLRAlgo_Array1OfPISeg*& PISeg,
HLRAlgo_Array1OfPINod*& PINod)
{
Standard_Integer i,n1,n2;
Standard_Integer find,iiii,icsv = 0;
Standard_Address A1,A2,A3,Nod1Indices,Nod2Indices,Seg2Indices = NULL,Tri2Indices;
HLRAlgo_PolyInternalSegment* aSegIndices = NULL;
Standard_Boolean newSeg = Standard_False;
HLRAlgo_TriangleData* TD =
&(((HLRAlgo_Array1OfTData*)TData)->ChangeValue(1));
for (i = 1; i <= myNbTData; i++) {
Tri2Indices = TD->Indices();
A1 = ((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(Tri2Node1)->Indices();
A2 = ((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(Tri2Node2)->Indices();
A3 = ((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(Tri2Node3)->Indices();
n1 = Tri2Node1;
n2 = Tri2Node2;
Nod1Indices = A1;
Nod2Indices = A2;
HLRAlgo_PolyInternalNode::NodeIndices& A1 =
PINod->ChangeValue(TD->Node1)->Indices();
HLRAlgo_PolyInternalNode::NodeIndices& A2 =
PINod->ChangeValue(TD->Node2)->Indices();
HLRAlgo_PolyInternalNode::NodeIndices& A3 =
PINod->ChangeValue(TD->Node3)->Indices();
{
n1 = TD->Node1;
n2 = TD->Node2;
newSeg = Standard_False;
if (Nod1NdSg == 0 && Nod2NdSg == 0) {
if (A1.NdSg == 0 && A2.NdSg == 0) {
newSeg = Standard_True;
myNbPISeg++;
Nod1NdSg = myNbPISeg;
Nod2NdSg = myNbPISeg;
A1.NdSg = myNbPISeg;
A2.NdSg = myNbPISeg;
}
else {
iiii = Nod1NdSg;
iiii = A1.NdSg;
if (iiii != 0) {
find = 0;
while (iiii != 0 && find == 0) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n1) {
if (Seg2LstSg2 == n2) find = iiii;
else iiii = Seg2NxtSg1;
aSegIndices = &PISeg->ChangeValue(iiii);
if (aSegIndices->LstSg1 == n1) {
if (aSegIndices->LstSg2 == n2) find = iiii;
else iiii = aSegIndices->NxtSg1;
icsv = 1;
}
else {
if (Seg2LstSg1 == n2) find = iiii;
else iiii = Seg2NxtSg2;
if (aSegIndices->LstSg1 == n2) find = iiii;
else iiii = aSegIndices->NxtSg2;
icsv = 2;
}
}
if (find == 0) {
newSeg = Standard_True;
myNbPISeg++;
if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
else Seg2NxtSg2 = myNbPISeg;
if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else Seg2Conex2 = i;
else aSegIndices->Conex2 = i;
}
else {
newSeg = Standard_True;
myNbPISeg++;
Nod1NdSg = myNbPISeg;
A1.NdSg = myNbPISeg;
}
if (newSeg) {
iiii = Nod2NdSg;
iiii = A2.NdSg;
if (iiii != 0) {
while (iiii != 0) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n2) { icsv = 1; iiii = Seg2NxtSg1; }
else { icsv = 2; iiii = Seg2NxtSg2; }
aSegIndices = &PISeg->ChangeValue(iiii);
if (aSegIndices->LstSg1 == n2) { icsv = 1; iiii = aSegIndices->NxtSg1; }
else { icsv = 2; iiii = aSegIndices->NxtSg2; }
}
if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
else Seg2NxtSg2 = myNbPISeg;
if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else Nod2NdSg = myNbPISeg;
else A2.NdSg = myNbPISeg;
}
}
if (newSeg) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(myNbPISeg).Indices();
Seg2LstSg1 = n1;
Seg2LstSg2 = n2;
Seg2Conex1 = i;
Seg2Conex2 = 0;
Seg2NxtSg1 = 0;
Seg2NxtSg2 = 0;
aSegIndices = &PISeg->ChangeValue(myNbPISeg);
aSegIndices->LstSg1 = n1;
aSegIndices->LstSg2 = n2;
aSegIndices->Conex1 = i;
aSegIndices->Conex2 = 0;
aSegIndices->NxtSg1 = 0;
aSegIndices->NxtSg2 = 0;
}
n1 = Tri2Node2;
n2 = Tri2Node3;
Nod1Indices = A2;
Nod2Indices = A3;
}
{
n1 = TD->Node2;
n2 = TD->Node3;
newSeg = Standard_False;
if (Nod1NdSg == 0 && Nod2NdSg == 0) {
if (A2.NdSg == 0 && A3.NdSg == 0) {
newSeg = Standard_True;
myNbPISeg++;
Nod1NdSg = myNbPISeg;
Nod2NdSg = myNbPISeg;
A2.NdSg = myNbPISeg;
A3.NdSg = myNbPISeg;
}
else {
iiii = Nod1NdSg;
iiii = A2.NdSg;
if (iiii != 0) {
find = 0;
while (iiii != 0 && find == 0) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n1) {
if (Seg2LstSg2 == n2) find = iiii;
else iiii = Seg2NxtSg1;
aSegIndices = &PISeg->ChangeValue(iiii);
if (aSegIndices->LstSg1 == n1) {
if (aSegIndices->LstSg2 == n2) find = iiii;
else iiii = aSegIndices->NxtSg1;
icsv = 1;
}
else {
if (Seg2LstSg1 == n2) find = iiii;
else iiii = Seg2NxtSg2;
if (aSegIndices->LstSg1 == n2) find = iiii;
else iiii = aSegIndices->NxtSg2;
icsv = 2;
}
}
if (find == 0) {
newSeg = Standard_True;
myNbPISeg++;
if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
else Seg2NxtSg2 = myNbPISeg;
if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else Seg2Conex2 = i;
else aSegIndices->Conex2 = i;
}
else {
newSeg = Standard_True;
myNbPISeg++;
Nod1NdSg = myNbPISeg;
A2.NdSg = myNbPISeg;
}
if (newSeg) {
iiii = Nod2NdSg;
iiii = A3.NdSg;
if (iiii != 0) {
while (iiii != 0) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n2) { icsv = 1; iiii = Seg2NxtSg1; }
else { icsv = 2; iiii = Seg2NxtSg2; }
aSegIndices = &PISeg->ChangeValue(iiii);
if (aSegIndices->LstSg1 == n2) { icsv = 1; iiii = aSegIndices->NxtSg1; }
else { icsv = 2; iiii = aSegIndices->NxtSg2; }
}
if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
else Seg2NxtSg2 = myNbPISeg;
if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else Nod2NdSg = myNbPISeg;
else A3.NdSg = myNbPISeg;
}
}
if (newSeg) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(myNbPISeg).Indices();
Seg2LstSg1 = n1;
Seg2LstSg2 = n2;
Seg2Conex1 = i;
Seg2Conex2 = 0;
Seg2NxtSg1 = 0;
Seg2NxtSg2 = 0;
aSegIndices = &PISeg->ChangeValue(myNbPISeg);
aSegIndices->LstSg1 = n1;
aSegIndices->LstSg2 = n2;
aSegIndices->Conex1 = i;
aSegIndices->Conex2 = 0;
aSegIndices->NxtSg1 = 0;
aSegIndices->NxtSg2 = 0;
}
n1 = Tri2Node3;
n2 = Tri2Node1;
Nod1Indices = A3;
Nod2Indices = A1;
}
{
n1 = TD->Node3;
n2 = TD->Node1;
newSeg = Standard_False;
if (Nod1NdSg == 0 && Nod2NdSg == 0) {
if (A3.NdSg == 0 && A1.NdSg == 0) {
newSeg = Standard_True;
myNbPISeg++;
Nod1NdSg = myNbPISeg;
Nod2NdSg = myNbPISeg;
A3.NdSg = myNbPISeg;
A1.NdSg = myNbPISeg;
}
else {
iiii = Nod1NdSg;
iiii = A3.NdSg;
if (iiii != 0) {
find = 0;
while (iiii != 0 && find == 0) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n1) {
if (Seg2LstSg2 == n2) find = iiii;
else iiii = Seg2NxtSg1;
aSegIndices = &PISeg->ChangeValue(iiii);
if (aSegIndices->LstSg1 == n1) {
if (aSegIndices->LstSg2 == n2) find = iiii;
else iiii = aSegIndices->NxtSg1;
icsv = 1;
}
else {
if (Seg2LstSg1 == n2) find = iiii;
else iiii = Seg2NxtSg2;
if (aSegIndices->LstSg1 == n2) find = iiii;
else iiii = aSegIndices->NxtSg2;
icsv = 2;
}
}
if (find == 0) {
newSeg = Standard_True;
myNbPISeg++;
if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
else Seg2NxtSg2 = myNbPISeg;
if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else Seg2Conex2 = i;
else aSegIndices->Conex2 = i;
}
else {
newSeg = Standard_True;
myNbPISeg++;
Nod1NdSg = myNbPISeg;
A3.NdSg = myNbPISeg;
}
if (newSeg) {
iiii = Nod2NdSg;
iiii = A1.NdSg;
if (iiii != 0) {
while (iiii != 0) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n2) { icsv = 1; iiii = Seg2NxtSg1; }
else { icsv = 2; iiii = Seg2NxtSg2; }
aSegIndices = &PISeg->ChangeValue(iiii);
if (aSegIndices->LstSg1 == n2) { icsv = 1; iiii = aSegIndices->NxtSg1; }
else { icsv = 2; iiii = aSegIndices->NxtSg2; }
}
if (icsv == 1) Seg2NxtSg1 = myNbPISeg;
else Seg2NxtSg2 = myNbPISeg;
if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else Nod2NdSg = myNbPISeg;
else A1.NdSg = myNbPISeg;
}
}
if (newSeg) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(myNbPISeg).Indices();
Seg2LstSg1 = n1;
Seg2LstSg2 = n2;
Seg2Conex1 = i;
Seg2Conex2 = 0;
Seg2NxtSg1 = 0;
Seg2NxtSg2 = 0;
aSegIndices = &PISeg->ChangeValue(myNbPISeg);
aSegIndices->LstSg1 = n1;
aSegIndices->LstSg2 = n2;
aSegIndices->Conex1 = i;
aSegIndices->Conex2 = 0;
aSegIndices->NxtSg1 = 0;
aSegIndices->NxtSg2 = 0;
}
}
TD++;
}
@ -390,14 +293,15 @@ void HLRAlgo_PolyInternalData::UpdateLinks
//=======================================================================
Standard_Integer
HLRAlgo_PolyInternalData::AddNode (const Standard_Address Nod1RValues,
const Standard_Address Nod2RValues,
Standard_Address& PINod1,
Standard_Address& PINod2,
const Standard_Real coef1,
const Standard_Real X3,
const Standard_Real Y3,
const Standard_Real Z3)
HLRAlgo_PolyInternalData::AddNode (
HLRAlgo_PolyInternalNode::NodeData& Nod1RValues,
HLRAlgo_PolyInternalNode::NodeData& Nod2RValues,
HLRAlgo_Array1OfPINod*& PINod1,
HLRAlgo_Array1OfPINod*& PINod2,
const Standard_Real coef1,
const Standard_Real X3,
const Standard_Real Y3,
const Standard_Real Z3)
{
Standard_Real coef2 = 1 - coef1;
IncPINod(PINod1,PINod2);
@ -405,30 +309,21 @@ HLRAlgo_PolyInternalData::AddNode (const Standard_Address Nod1RValues,
Handle(HLRAlgo_PolyInternalNode)* pip3 =
&(((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip3));
*pip3 = new HLRAlgo_PolyInternalNode();
const Standard_Address Nod3RValues = (*pip3)->RValues();
const Standard_Address Nod3Indices = (*pip3)->Indices();
Nod3NdSg = 0;
Nod3Flag = 0;
Nod3PntX = X3;
Nod3PntY = Y3;
Nod3PntZ = Z3;
Nod3PntU = Nod1PntU * coef2 + Nod2PntU * coef1;
Nod3PntV = Nod1PntV * coef2 + Nod2PntV * coef1;
Nod3Scal = Nod1Scal * coef2 + Nod2Scal * coef1;
Standard_Real x = Nod1NrmX * coef2 + Nod2NrmX * coef1;
Standard_Real y = Nod1NrmY * coef2 + Nod2NrmY * coef1;
Standard_Real z = Nod1NrmZ * coef2 + Nod2NrmZ * coef1;
Standard_Real d = sqrt(x * x + y * y + z * z);
HLRAlgo_PolyInternalNode::NodeData& Nod3RValues = (*pip3)->Data();
HLRAlgo_PolyInternalNode::NodeIndices& aNodeIndices = (*pip3)->Indices();
aNodeIndices.NdSg = 0;
aNodeIndices.Flag = 0;
Nod3RValues.Point = gp_XYZ(X3, Y3, Z3);
Nod3RValues.UV = coef2 * Nod1RValues.UV + coef1 * Nod2RValues.UV;
Nod3RValues.Scal = Nod1RValues.Scal * coef2 + Nod2RValues.Scal * coef1;
const gp_XYZ aXYZ = coef2 * Nod1RValues.Normal + coef1 * Nod2RValues.Normal;
const Standard_Real aNorm = aXYZ.Modulus();
if (d > 0) {
Nod3NrmX = x / d;
Nod3NrmY = y / d;
Nod3NrmZ = z / d;
if (aNorm > 0) {
Nod3RValues.Normal = (1 / aNorm) * aXYZ;
}
else {
Nod3NrmX = 1;
Nod3NrmY = 0;
Nod3NrmZ = 0;
Nod3RValues.Normal = gp_XYZ(1., 0., 0.);
#ifdef OCCT_DEBUG
if (ERROR)
cout << "HLRAlgo_PolyInternalData::AddNode" << endl;
@ -446,16 +341,16 @@ void
HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
const Standard_Integer ip2,
const Standard_Integer ip3,
Standard_Address& TData1,
Standard_Address& TData2,
Standard_Address& PISeg1,
Standard_Address& PISeg2,
Standard_Address& PINod1,
Standard_Address& )
HLRAlgo_Array1OfTData*& TData1,
HLRAlgo_Array1OfTData*& TData2,
HLRAlgo_Array1OfPISeg*& PISeg1,
HLRAlgo_Array1OfPISeg*& PISeg2,
HLRAlgo_Array1OfPINod*& PINod1,
HLRAlgo_Array1OfPINod*& )
{
Standard_Integer find,iiii,iisv,icsv,iip2 =0,cnx1 =0,cnx2 =0;
Standard_Address Seg1Indices,Seg2Indices = NULL;
Seg1Indices = 0;
HLRAlgo_PolyInternalSegment* aSegIndices = NULL;
HLRAlgo_PolyInternalSegment* aSegIndices2 = NULL;
find = 0;
iisv = 0;
icsv = 0;
@ -468,54 +363,53 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
IncTData(TData1,TData2);
myNbTData--;
myNbTData--;
Standard_Address Nod1Indices =
((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip1)->Indices();
Standard_Address Nod2Indices =
((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip2)->Indices();
Standard_Address Nod3Indices =
((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip3)->Indices();
iiii = Nod2NdSg;
HLRAlgo_PolyInternalNode::NodeIndices* aNodIndices1 =
&PINod1->ChangeValue(ip1)->Indices();
HLRAlgo_PolyInternalNode::NodeIndices& aNodIndices2 =
PINod1->ChangeValue(ip2)->Indices();
HLRAlgo_PolyInternalNode::NodeIndices& aNodIndices3 =
PINod1->ChangeValue(ip3)->Indices();
iiii = aNodIndices2.NdSg;
while (iiii != 0 && find == 0) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == ip2) {
if (Seg2LstSg2 == ip1) {
aSegIndices2 = &PISeg1->ChangeValue(iiii);
if (aSegIndices2->LstSg1 == ip2) {
if (aSegIndices2->LstSg2 == ip1) {
find = iiii;
cnx1 = Seg2Conex1;
cnx2 = Seg2Conex2;
Seg2LstSg1 = ip3;
iip2 = Seg2NxtSg1;
Seg2NxtSg1 = myNbPISeg;
if (iisv == 0) Nod2NdSg = myNbPISeg;
else if (icsv == 1) Seg1NxtSg1 = myNbPISeg;
else Seg1NxtSg2 = myNbPISeg;
cnx1 = aSegIndices2->Conex1;
cnx2 = aSegIndices2->Conex2;
aSegIndices2->LstSg1 = ip3;
iip2 = aSegIndices2->NxtSg1;
aSegIndices2->NxtSg1 = myNbPISeg;
if (iisv == 0) aNodIndices2.NdSg = myNbPISeg;
else if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else {
iisv = iiii;
icsv = 1;
}
iiii = Seg2NxtSg1;
iiii = aSegIndices2->NxtSg1;
}
else {
if (Seg2LstSg1 == ip1) {
if (aSegIndices2->LstSg1 == ip1) {
find = iiii;
cnx1 = Seg2Conex1;
cnx2 = Seg2Conex2;
Seg2LstSg2 = ip3;
iip2 = Seg2NxtSg2;
Seg2NxtSg2 = myNbPISeg;
if (iisv == 0) Nod2NdSg = myNbPISeg;
else if (icsv == 1) Seg1NxtSg1 = myNbPISeg;
else Seg1NxtSg2 = myNbPISeg;
cnx1 = aSegIndices2->Conex1;
cnx2 = aSegIndices2->Conex2;
aSegIndices2->LstSg2 = ip3;
iip2 = aSegIndices2->NxtSg2;
aSegIndices2->NxtSg2 = myNbPISeg;
if (iisv == 0) aNodIndices2.NdSg = myNbPISeg;
else if (icsv == 1) aSegIndices->NxtSg1 = myNbPISeg;
else aSegIndices->NxtSg2 = myNbPISeg;
}
else {
iisv = iiii;
icsv = 2;
}
iiii = Seg2NxtSg2;
iiii = aSegIndices2->NxtSg2;
}
Seg1Indices = Seg2Indices;
aSegIndices = aSegIndices2;
}
if (find == 0) {
myNbPISeg--;
@ -527,15 +421,14 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
#endif
}
else {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(myNbPISeg).Indices();
Seg2NxtSg1 = 0;
Seg2NxtSg2 = iip2;
Seg2LstSg1 = ip3;
Seg2LstSg2 = ip2;
Seg2Conex1 = cnx1;
Seg2Conex2 = cnx2;
Nod3NdSg = find;
aSegIndices2 = &PISeg1->ChangeValue(myNbPISeg);
aSegIndices2->NxtSg1 = 0;
aSegIndices2->NxtSg2 = iip2;
aSegIndices2->LstSg1 = ip3;
aSegIndices2->LstSg2 = ip2;
aSegIndices2->Conex1 = cnx1;
aSegIndices2->Conex2 = cnx2;
aNodIndices3.NdSg = find;
Standard_Integer iOld,iNew,iTr,skip,ip4,itpk[2];
Standard_Integer n1,n2,n3,nOld[3],nNew[3],New[4];
@ -554,13 +447,11 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
iOld = New[skip];
iNew = New[skip + 2];
if (iOld != 0) {
Standard_Address Tri1Indices =
((HLRAlgo_Array1OfTData*)TData1)->ChangeValue(iOld).Indices();
Standard_Address Tri2Indices =
((HLRAlgo_Array1OfTData*)TData1)->ChangeValue(iNew).Indices();
n1 = Tri1Node1;
n2 = Tri1Node2;
n3 = Tri1Node3;
HLRAlgo_TriangleData& aTriangle = TData1->ChangeValue(iOld);
HLRAlgo_TriangleData& aTriangle2 = TData1->ChangeValue(iNew);
n1 = aTriangle.Node1;
n2 = aTriangle.Node2;
n3 = aTriangle.Node3;
nOld[0] = n1;
nOld[1] = n2;
nOld[2] = n3;
@ -607,26 +498,25 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
if (found) {
myNbTData++;
ip4 = itpk[skip];
Standard_Address Nod4Indices =
((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(ip4)->Indices();
Tri1Node1 = nOld[0];
Tri1Node2 = nOld[1];
Tri1Node3 = nOld[2];
Tri2Node1 = nNew[0];
Tri2Node2 = nNew[1];
Tri2Node3 = nNew[2];
Tri2Flags = Tri1Flags;
HLRAlgo_PolyInternalNode::NodeIndices& aNodIndices4 =
PINod1->ChangeValue(ip4)->Indices();
aTriangle.Node1 = nOld[0];
aTriangle.Node2 = nOld[1];
aTriangle.Node3 = nOld[2];
aTriangle2.Node1 = nNew[0];
aTriangle2.Node2 = nNew[1];
aTriangle2.Node3 = nNew[2];
aTriangle2.Flags = aTriangle.Flags;
myNbPISeg++;
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(myNbPISeg).Indices();
Seg2LstSg1 = ip3;
Seg2LstSg2 = ip4;
Seg2NxtSg1 = Nod3NdSg;
Seg2NxtSg2 = Nod4NdSg;
Seg2Conex1 = iOld;
Seg2Conex2 = iNew;
Nod3NdSg = myNbPISeg;
Nod4NdSg = myNbPISeg;
aSegIndices2 = &PISeg1->ChangeValue(myNbPISeg);
aSegIndices2->LstSg1 = ip3;
aSegIndices2->LstSg2 = ip4;
aSegIndices2->NxtSg1 = aNodIndices3.NdSg;
aSegIndices2->NxtSg2 = aNodIndices4.NdSg;
aSegIndices2->Conex1 = iOld;
aSegIndices2->Conex2 = iNew;
aNodIndices3.NdSg = myNbPISeg;
aNodIndices4.NdSg = myNbPISeg;
}
#ifdef OCCT_DEBUG
else if (ERROR) {
@ -644,37 +534,34 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
iOld = New [skip];
ip4 = itpk[skip];
if (iNew != 0) {
Standard_Address Tri2Indices =
((HLRAlgo_Array1OfTData*)TData1)->ChangeValue(iNew).Indices();
n1 = Tri2Node1;
n2 = Tri2Node2;
n3 = Tri2Node3;
HLRAlgo_TriangleData& aTriangle2 = TData1->ChangeValue(iNew);
n1 = aTriangle2.Node1;
n2 = aTriangle2.Node2;
n3 = aTriangle2.Node3;
if (!((n1 == ip3 && n2 == ip4) ||
(n2 == ip3 && n1 == ip4))) {
Standard_Boolean found = Standard_False;
Nod1Indices =
((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(n1)->Indices();
iiii = Nod1NdSg;
aNodIndices1 = &PINod1->ChangeValue(n1)->Indices();
iiii = aNodIndices1->NdSg;
while (iiii != 0 && !found) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n1) {
if (Seg2LstSg2 == n2) {
aSegIndices2 = &PISeg1->ChangeValue(iiii);
if (aSegIndices2->LstSg1 == n1) {
if (aSegIndices2->LstSg2 == n2) {
found = Standard_True;
if (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
if (aSegIndices2->Conex1 == iOld) aSegIndices2->Conex1 = iNew;
else if (aSegIndices2->Conex2 == iOld) aSegIndices2->Conex2 = iNew;
}
else iiii = Seg2NxtSg1;
else iiii = aSegIndices2->NxtSg1;
}
else {
if (Seg2LstSg1 == n2) {
if (aSegIndices2->LstSg1 == n2) {
found = Standard_True;
if (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
if (aSegIndices2->Conex1 == iOld) aSegIndices2->Conex1 = iNew;
else if (aSegIndices2->Conex2 == iOld) aSegIndices2->Conex2 = iNew;
}
else iiii = Seg2NxtSg2;
else iiii = aSegIndices2->NxtSg2;
}
}
}
@ -682,28 +569,26 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
if (!((n2 == ip3 && n3 == ip4) ||
(n3 == ip3 && n2 == ip4))) {
Standard_Boolean found = Standard_False;
Nod1Indices =
((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(n2)->Indices();
iiii = Nod1NdSg;
aNodIndices1 = &PINod1->ChangeValue(n2)->Indices();
iiii = aNodIndices1->NdSg;
while (iiii != 0 && !found) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n2) {
if (Seg2LstSg2 == n3) {
aSegIndices2 = &PISeg1->ChangeValue(iiii);
if (aSegIndices2->LstSg1 == n2) {
if (aSegIndices2->LstSg2 == n3) {
found = Standard_True;
if (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
if (aSegIndices2->Conex1 == iOld) aSegIndices2->Conex1 = iNew;
else if (aSegIndices2->Conex2 == iOld) aSegIndices2->Conex2 = iNew;
}
else iiii = Seg2NxtSg1;
else iiii = aSegIndices2->NxtSg1;
}
else {
if (Seg2LstSg1 == n3) {
if (aSegIndices2->LstSg1 == n3) {
found = Standard_True;
if (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
if (aSegIndices2->Conex1 == iOld) aSegIndices2->Conex1 = iNew;
else if (aSegIndices2->Conex2 == iOld) aSegIndices2->Conex2 = iNew;
}
else iiii = Seg2NxtSg2;
else iiii = aSegIndices2->NxtSg2;
}
}
}
@ -711,28 +596,26 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
if (!((n3 == ip3 && n1 == ip4) ||
(n1 == ip3 && n3 == ip4))) {
Standard_Boolean found = Standard_False;
Nod1Indices =
((HLRAlgo_Array1OfPINod*)PINod1)->ChangeValue(n3)->Indices();
iiii = Nod1NdSg;
aNodIndices1 = &PINod1->ChangeValue(n3)->Indices();
iiii = aNodIndices1->NdSg;
while (iiii != 0 && !found) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg1)->ChangeValue(iiii).Indices();
if (Seg2LstSg1 == n3) {
if (Seg2LstSg2 == n1) {
aSegIndices2 = &PISeg1->ChangeValue(iiii);
if (aSegIndices2->LstSg1 == n3) {
if (aSegIndices2->LstSg2 == n1) {
found = Standard_True;
if (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
if (aSegIndices2->Conex1 == iOld) aSegIndices2->Conex1 = iNew;
else if (aSegIndices2->Conex2 == iOld) aSegIndices2->Conex2 = iNew;
}
else iiii = Seg2NxtSg1;
else iiii = aSegIndices2->NxtSg1;
}
else {
if (Seg2LstSg1 == n1) {
if (aSegIndices2->LstSg1 == n1) {
found = Standard_True;
if (Seg2Conex1 == iOld) Seg2Conex1 = iNew;
else if (Seg2Conex2 == iOld) Seg2Conex2 = iNew;
if (aSegIndices2->Conex1 == iOld) aSegIndices2->Conex1 = iNew;
else if (aSegIndices2->Conex2 == iOld) aSegIndices2->Conex2 = iNew;
}
else iiii = Seg2NxtSg2;
else iiii = aSegIndices2->NxtSg2;
}
}
}
@ -749,44 +632,40 @@ HLRAlgo_PolyInternalData::UpdateLinks (const Standard_Integer ip1,
void HLRAlgo_PolyInternalData::Dump () const
{
Standard_Integer i;//,i1,i2,i3;
Standard_Address Seg2Indices;
Standard_Address TData = &myTData->ChangeArray1();
Standard_Address PISeg = &myPISeg->ChangeArray1();
Standard_Address PINod = &myPINod->ChangeArray1();
HLRAlgo_Array1OfTData* TData = &myTData->ChangeArray1();
HLRAlgo_Array1OfPISeg* PISeg = &myPISeg->ChangeArray1();
HLRAlgo_Array1OfPINod* PINod = &myPINod->ChangeArray1();
for (i = 1; i <= myNbPINod; i++) {
const Handle(HLRAlgo_PolyInternalNode)* pi =
&(((HLRAlgo_Array1OfPINod*)PINod)->ChangeValue(i));
Standard_Address Nod1Indices = (*pi)->Indices();
Standard_Address Nod1RValues = (*pi)->RValues();
const Handle(HLRAlgo_PolyInternalNode)* pi = &PINod->ChangeValue(i);
HLRAlgo_PolyInternalNode::NodeIndices& aNodIndices1 = (*pi)->Indices();
HLRAlgo_PolyInternalNode::NodeData& Nod1RValues = (*pi)->Data();
cout << "Node " << setw(6) << i << " : ";
cout << setw(6) << Nod1NdSg;
cout << setw(20)<< Nod1PntX;
cout << setw(20)<< Nod1PntY;
cout << setw(20)<< Nod1PntZ;
cout << setw(6) << aNodIndices1.NdSg;
cout << setw(20)<< Nod1RValues.Point.X();
cout << setw(20)<< Nod1RValues.Point.Y();
cout << setw(20)<< Nod1RValues.Point.Z();
cout << endl;
}
for (i = 1; i <= myNbPISeg; i++) {
Seg2Indices =
((HLRAlgo_Array1OfPISeg*)PISeg)->ChangeValue(i).Indices();
HLRAlgo_PolyInternalSegment* aSegIndices = &PISeg->ChangeValue(i);
cout << "Segment " << setw(6) << i << " : ";
cout << setw(6) << Seg2LstSg1;
cout << setw(6) << Seg2LstSg2;
cout << setw(6) << Seg2NxtSg1;
cout << setw(6) << Seg2NxtSg2;
cout << setw(6) << Seg2Conex1;
cout << setw(6) << Seg2Conex2;
cout << setw(6) << aSegIndices->LstSg1;
cout << setw(6) << aSegIndices->LstSg2;
cout << setw(6) << aSegIndices->NxtSg1;
cout << setw(6) << aSegIndices->NxtSg2;
cout << setw(6) << aSegIndices->Conex1;
cout << setw(6) << aSegIndices->Conex2;
cout << endl;
}
for (i = 1; i <= myNbTData; i++) {
Standard_Address Tri2Indices =
((HLRAlgo_Array1OfTData*)TData)->ChangeValue(i).Indices();
HLRAlgo_TriangleData& aTriangle = TData->ChangeValue(i);
cout << "Triangle " << setw(6) << i << " : ";
cout << setw(6) << Tri2Node1;
cout << setw(6) << Tri2Node2;
cout << setw(6) << Tri2Node3;
cout << setw(6) << aTriangle.Node1;
cout << setw(6) << aTriangle.Node2;
cout << setw(6) << aTriangle.Node3;
cout << endl;
}
}
@ -796,9 +675,8 @@ void HLRAlgo_PolyInternalData::Dump () const
//purpose :
//=======================================================================
void HLRAlgo_PolyInternalData::
IncTData (Standard_Address& TData1,
Standard_Address& TData2)
void HLRAlgo_PolyInternalData::IncTData(
HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfTData*& TData2)
{
if (myNbTData >= myMxTData) {
#ifdef OCCT_DEBUG
@ -813,19 +691,10 @@ IncTData (Standard_Address& TData1,
new HLRAlgo_HArray1OfTData(0,k);
HLRAlgo_Array1OfTData& oTData = myTData->ChangeArray1();
HLRAlgo_Array1OfTData& nTData = NwTData->ChangeArray1();
HLRAlgo_TriangleData* OT = &(oTData.ChangeValue(1));
HLRAlgo_TriangleData* NT = &(nTData.ChangeValue(1));
Standard_Address Tri1Indices,Tri2Indices;
for (i = 1; i <= j; i++) {
Tri1Indices = OT->Indices();
Tri2Indices = NT->Indices();
Tri2Node1 = Tri1Node1;
Tri2Node2 = Tri1Node2;
Tri2Node3 = Tri1Node3;
Tri2Flags = Tri1Flags;
OT++;
NT++;
for (i = 1; i <= j; i++)
{
nTData.ChangeValue(i) = oTData.Value(i);
}
myMxTData = k;
myTData = NwTData;
@ -845,9 +714,8 @@ IncTData (Standard_Address& TData1,
//purpose :
//=======================================================================
void HLRAlgo_PolyInternalData::
IncPISeg (Standard_Address& PISeg1,
Standard_Address& PISeg2)
void HLRAlgo_PolyInternalData::IncPISeg(
HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPISeg*& PISeg2)
{
if (myNbPISeg >= myMxPISeg) {
#ifdef OCCT_DEBUG
@ -861,21 +729,10 @@ IncPISeg (Standard_Address& PISeg1,
new HLRAlgo_HArray1OfPISeg(0,k);
HLRAlgo_Array1OfPISeg& oPISeg = myPISeg->ChangeArray1();
HLRAlgo_Array1OfPISeg& nPISeg = NwPISeg->ChangeArray1();
HLRAlgo_PolyInternalSegment* OS = &(oPISeg.ChangeValue(1));
HLRAlgo_PolyInternalSegment* NS = &(nPISeg.ChangeValue(1));
Standard_Address Seg1Indices,Seg2Indices;
for (i = 1; i <= j; i++) {
Seg1Indices = OS->Indices();
Seg2Indices = NS->Indices();
Seg2LstSg1 = Seg1LstSg1;
Seg2LstSg2 = Seg1LstSg2;
Seg2NxtSg1 = Seg1NxtSg1;
Seg2NxtSg2 = Seg1NxtSg2;
Seg2Conex1 = Seg1Conex1;
Seg2Conex2 = Seg1Conex2;
OS++;
NS++;
for (i = 1; i <= j; i++)
{
nPISeg.ChangeValue(i) = oPISeg.Value(i);
}
myMxPISeg = k;
myPISeg = NwPISeg;
@ -895,9 +752,8 @@ IncPISeg (Standard_Address& PISeg1,
//purpose :
//=======================================================================
void HLRAlgo_PolyInternalData::
IncPINod (Standard_Address& PINod1,
Standard_Address& PINod2)
void HLRAlgo_PolyInternalData::IncPINod(
HLRAlgo_Array1OfPINod*& PINod1, HLRAlgo_Array1OfPINod*& PINod2)
{
if (myNbPINod >= myMxPINod) {
#ifdef OCCT_DEBUG
@ -905,7 +761,6 @@ IncPINod (Standard_Address& PINod1,
cout << "HLRAlgo_PolyInternalData::IncPINod : " << myMxPINod << endl;
#endif
Standard_Integer i,j,k;
// Standard_Address Nod1Indices;
j = myMxPINod;
k = 2 * j;
Handle(HLRAlgo_HArray1OfPINod) NwPINod =

13
src/HLRAlgo/HLRAlgo_PolyInternalData.hxx
View File

@ -26,7 +26,6 @@
#include <HLRAlgo_HArray1OfPISeg.hxx>
#include <HLRAlgo_HArray1OfPINod.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <HLRAlgo_Array1OfTData.hxx>
#include <HLRAlgo_Array1OfPISeg.hxx>
@ -45,19 +44,19 @@ public:
Standard_EXPORT HLRAlgo_PolyInternalData(const Standard_Integer nbNod, const Standard_Integer nbTri);
Standard_EXPORT void UpdateLinks (Standard_Address& TData, Standard_Address& PISeg, Standard_Address& PINod);
Standard_EXPORT void UpdateLinks (HLRAlgo_Array1OfTData*& TData, HLRAlgo_Array1OfPISeg*& PISeg, HLRAlgo_Array1OfPINod*& PINod);
Standard_EXPORT Standard_Integer AddNode (const Standard_Address Nod1RValues, const Standard_Address Nod2RValues, Standard_Address& PINod1, Standard_Address& PINod2, const Standard_Real coef1, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3);
Standard_EXPORT Standard_Integer AddNode (HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_PolyInternalNode::NodeData& Nod2RValues, HLRAlgo_Array1OfPINod*& PINod1, HLRAlgo_Array1OfPINod*& PINod2, const Standard_Real coef1, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3);
Standard_EXPORT void UpdateLinks (const Standard_Integer ip1, const Standard_Integer ip2, const Standard_Integer ip3, Standard_Address& TData1, Standard_Address& TData2, Standard_Address& PISeg1, Standard_Address& PISeg2, Standard_Address& PINod1, Standard_Address& PINod2);
Standard_EXPORT void UpdateLinks (const Standard_Integer ip1, const Standard_Integer ip2, const Standard_Integer ip3, HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfTData*& TData2, HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPISeg*& PISeg2, HLRAlgo_Array1OfPINod*& PINod1, HLRAlgo_Array1OfPINod*& PINod2);
Standard_EXPORT void Dump() const;
Standard_EXPORT void IncTData (Standard_Address& TData1, Standard_Address& TData2);
Standard_EXPORT void IncTData (HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfTData*& TData2);
Standard_EXPORT void IncPISeg (Standard_Address& PISeg1, Standard_Address& PISeg2);
Standard_EXPORT void IncPISeg (HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPISeg*& PISeg2);
Standard_EXPORT void IncPINod (Standard_Address& PINod1, Standard_Address& PINod2);
Standard_EXPORT void IncPINod (HLRAlgo_Array1OfPINod*& PINod1, HLRAlgo_Array1OfPINod*& PINod2);
void DecTData();

55
src/HLRAlgo/HLRAlgo_PolyInternalNode.hxx
View File

@ -23,7 +23,8 @@
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_Address.hxx>
#include <gp_XYZ.hxx>
#include <gp_XY.hxx>
class HLRAlgo_PolyInternalNode;
@ -32,40 +33,42 @@ DEFINE_STANDARD_HANDLE(HLRAlgo_PolyInternalNode, MMgt_TShared)
//! to Update OutLines.
class HLRAlgo_PolyInternalNode : public MMgt_TShared
{
public:
struct NodeIndices
{
Standard_Integer NdSg, Flag, Edg1, Edg2;
};
HLRAlgo_PolyInternalNode();
Standard_Address Indices() const;
Standard_Address RValues() const;
struct NodeData
{
gp_XYZ Point, Normal;
gp_XY UV;
Standard_Real PCu1, PCu2, Scal;
};
HLRAlgo_PolyInternalNode()
{
myIndices.NdSg = 0;
myIndices.Flag = 0;
myIndices.Edg1 = 0;
myIndices.Edg2 = 0;
}
NodeIndices& Indices()
{
return myIndices;
}
NodeData& Data()
{
return myData;
}
DEFINE_STANDARD_RTTIEXT(HLRAlgo_PolyInternalNode,MMgt_TShared)
protected:
private:
Standard_Integer myIndices[4];
Standard_Real myRValues[11];
NodeIndices myIndices;
NodeData myData;
};
#include <HLRAlgo_PolyInternalNode.lxx>
#endif // _HLRAlgo_PolyInternalNode_HeaderFile

44
src/HLRAlgo/HLRAlgo_PolyInternalNode.lxx
View File

@ -1,44 +0,0 @@
// Created on: 1997-01-10
// Created by: Christophe MARION
// Copyright (c) 1997-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.
//=======================================================================
//function : HLRAlgo_PolyInternalNode
//purpose :
//=======================================================================
inline HLRAlgo_PolyInternalNode::HLRAlgo_PolyInternalNode ()
{
myIndices[0] = 0;
myIndices[1] = 0;
myIndices[2] = 0;
myIndices[3] = 0;
}
//=======================================================================
//function : Indices
//purpose :
//=======================================================================
inline Standard_Address HLRAlgo_PolyInternalNode::Indices () const
{ return (Standard_Address)myIndices; }
//=======================================================================
//function : RValues
//purpose :
//=======================================================================
inline Standard_Address HLRAlgo_PolyInternalNode::RValues () const
{ return (Standard_Address)myRValues; }

35
src/HLRAlgo/HLRAlgo_PolyInternalSegment.hxx
View File

@ -22,44 +22,13 @@
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
//! to Update OutLines.
class HLRAlgo_PolyInternalSegment
struct HLRAlgo_PolyInternalSegment
{
public:
DEFINE_STANDARD_ALLOC
HLRAlgo_PolyInternalSegment();
Standard_Address Indices() const;
protected:
private:
Standard_Integer myIndices[6];
Standard_Integer LstSg1, LstSg2, NxtSg1, NxtSg2, Conex1, Conex2;
};
#include <HLRAlgo_PolyInternalSegment.lxx>
#endif // _HLRAlgo_PolyInternalSegment_HeaderFile

31
src/HLRAlgo/HLRAlgo_PolyInternalSegment.lxx
View File

@ -1,31 +0,0 @@
// Created on: 1996-12-03
// Created by: Christophe MARION
// Copyright (c) 1996-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.
//=======================================================================
//function : HLRAlgo_PolyInternalSegment
//purpose :
//=======================================================================
inline HLRAlgo_PolyInternalSegment::HLRAlgo_PolyInternalSegment ()
{}
//=======================================================================
//function : Indices
//purpose :
//=======================================================================
inline Standard_Address HLRAlgo_PolyInternalSegment::Indices () const
{ return (Standard_Address)myIndices; }

37
src/HLRAlgo/HLRAlgo_PolyMask.hxx Normal file
View File

@ -0,0 +1,37 @@
// Created on: 2016-10-14
// Created by: Aleksandr Bobkov
// Copyright (c) 1993-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.
#ifndef _HLRAlgo_PolyMask_HeaderFile
#define _HLRAlgo_PolyMask_HeaderFile
enum HLRAlgo_PolyMask
{
HLRAlgo_PolyMask_EMskOutLin1 = 1,
HLRAlgo_PolyMask_EMskOutLin2 = 2,
HLRAlgo_PolyMask_EMskOutLin3 = 4,
HLRAlgo_PolyMask_EMskGrALin1 = 8,
HLRAlgo_PolyMask_EMskGrALin2 = 16,
HLRAlgo_PolyMask_EMskGrALin3 = 32,
HLRAlgo_PolyMask_FMskBack = 64,
HLRAlgo_PolyMask_FMskSide = 128,
HLRAlgo_PolyMask_FMskHiding = 256,
HLRAlgo_PolyMask_FMskFlat = 512,
HLRAlgo_PolyMask_FMskOnOutL = 1024,
HLRAlgo_PolyMask_FMskOrBack = 2048,
HLRAlgo_PolyMask_FMskFrBack = 4096
};
#endif // _HLRAlgo_PolyData_HeaderFile

57
src/HLRAlgo/HLRAlgo_PolyShellData.cxx
View File

@ -27,26 +27,6 @@
IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyShellData,MMgt_TShared)
#define PntX1 ((Standard_Real*)Coordinates)[ 0]
#define PntY1 ((Standard_Real*)Coordinates)[ 1]
#define PntZ1 ((Standard_Real*)Coordinates)[ 2]
#define PntX2 ((Standard_Real*)Coordinates)[ 3]
#define PntY2 ((Standard_Real*)Coordinates)[ 4]
#define PntZ2 ((Standard_Real*)Coordinates)[ 5]
#define PntXP1 ((Standard_Real*)Coordinates)[ 6]
#define PntYP1 ((Standard_Real*)Coordinates)[ 7]
#define PntZP1 ((Standard_Real*)Coordinates)[ 8]
#define PntXP2 ((Standard_Real*)Coordinates)[ 9]
#define PntYP2 ((Standard_Real*)Coordinates)[10]
#define PntZP2 ((Standard_Real*)Coordinates)[11]
#define TotXMin ((Standard_Real*)TotMinMax)[0]
#define TotYMin ((Standard_Real*)TotMinMax)[1]
#define TotZMin ((Standard_Real*)TotMinMax)[2]
#define TotXMax ((Standard_Real*)TotMinMax)[3]
#define TotYMax ((Standard_Real*)TotMinMax)[4]
#define TotZMax ((Standard_Real*)TotMinMax)[5]
//=======================================================================
//function : HLRAlgo_PolyShellData
//purpose :
@ -63,37 +43,36 @@ HLRAlgo_PolyShellData (const Standard_Integer nbFace)
//=======================================================================
void
HLRAlgo_PolyShellData::
UpdateGlobalMinMax(const Standard_Address TotMinMax)
HLRAlgo_PolyShellData::UpdateGlobalMinMax(HLRAlgo_PolyData::Box& theBox)
{
HLRAlgo_ListIteratorOfListOfBPoint it;
for (it.Initialize(mySegList); it.More(); it.Next()) {
HLRAlgo_BiPoint& BP = it.Value();
const Standard_Address Coordinates = BP.Coordinates();
if (PntXP1 < PntXP2) {
if (TotXMin > PntXP1) TotXMin = PntXP1;
else if (TotXMax < PntXP2) TotXMax = PntXP2;
HLRAlgo_BiPoint::PointsT& aPoints = BP.Points();
if (aPoints.PntP1.X() < aPoints.PntP2.X()) {
if (theBox.XMin > aPoints.PntP1.X()) theBox.XMin = aPoints.PntP1.X();
else if (theBox.XMax < aPoints.PntP2.X()) theBox.XMax = aPoints.PntP2.X();
}
else {
if (TotXMin > PntXP2) TotXMin = PntXP2;
else if (TotXMax < PntXP1) TotXMax = PntXP1;
if (theBox.XMin > aPoints.PntP2.X()) theBox.XMin = aPoints.PntP2.X();
else if (theBox.XMax < aPoints.PntP1.X()) theBox.XMax = aPoints.PntP1.X();
}
if (PntYP1 < PntYP2) {
if (TotYMin > PntYP1) TotYMin = PntYP1;
else if (TotYMax < PntYP2) TotYMax = PntYP2;
if (aPoints.PntP1.Y() < aPoints.PntP2.Y()) {
if (theBox.YMin > aPoints.PntP1.Y()) theBox.YMin = aPoints.PntP1.Y();
else if (theBox.YMax < aPoints.PntP2.Y()) theBox.YMax = aPoints.PntP2.Y();
}
else {
if (TotYMin > PntYP2) TotYMin = PntYP2;
else if (TotYMax < PntYP1) TotYMax = PntYP1;
if (theBox.YMin > aPoints.PntP2.Y()) theBox.YMin = aPoints.PntP2.Y();
else if (theBox.YMax < aPoints.PntP1.Y()) theBox.YMax = aPoints.PntP1.Y();
}
if (PntZP1 < PntZP2) {
if (TotZMin > PntZP1) TotZMin = PntZP1;
else if (TotZMax < PntZP2) TotZMax = PntZP2;
if (aPoints.PntP1.Z() < aPoints.PntP2.Z()) {
if (theBox.ZMin > aPoints.PntP1.Z()) theBox.ZMin = aPoints.PntP1.Z();
else if (theBox.ZMax < aPoints.PntP2.Z()) theBox.ZMax = aPoints.PntP2.Z();
}
else {
if (TotZMin > PntZP2) TotZMin = PntZP2;
else if (TotZMax < PntZP1) TotZMax = PntZP1;
if (theBox.ZMin > aPoints.PntP2.Z()) theBox.ZMin = aPoints.PntP2.Z();
else if (theBox.ZMax < aPoints.PntP1.Z()) theBox.ZMax = aPoints.PntP1.Z();
}
}
Standard_Integer nbFace = myPolyg.Upper();
@ -101,7 +80,7 @@ UpdateGlobalMinMax(const Standard_Address TotMinMax)
if(nbFace > 0) pd = (Handle(HLRAlgo_PolyData)*)&(myPolyg.ChangeValue(1));
for (Standard_Integer i = 1; i <= nbFace; i++) {
(*pd)->UpdateGlobalMinMax(TotMinMax);
(*pd)->UpdateGlobalMinMax(theBox);
pd++;
}
}

14
src/HLRAlgo/HLRAlgo_PolyShellData.hxx
View File

@ -25,7 +25,6 @@
#include <TColStd_HArray1OfTransient.hxx>
#include <HLRAlgo_ListOfBPoint.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
@ -37,11 +36,15 @@ class HLRAlgo_PolyShellData : public MMgt_TShared
{
public:
struct ShellIndices
{
Standard_Integer Min, Max;
};
Standard_EXPORT HLRAlgo_PolyShellData(const Standard_Integer nbFace);
Standard_EXPORT void UpdateGlobalMinMax (const Standard_Address TotMinMax);
Standard_EXPORT void UpdateGlobalMinMax (HLRAlgo_PolyData::Box& theBox);
Standard_EXPORT void UpdateHiding (const Standard_Integer nbHiding);
@ -53,7 +56,10 @@ public:
HLRAlgo_ListOfBPoint& Edges();
Standard_Address Indices();
ShellIndices& Indices()
{
return myIndices;
}
@ -68,7 +74,7 @@ protected:
private:
Standard_Integer myMinMax[2];
ShellIndices myIndices;
TColStd_Array1OfTransient myPolyg;
Handle(TColStd_HArray1OfTransient) myHPolHi;
HLRAlgo_ListOfBPoint mySegList;

8
src/HLRAlgo/HLRAlgo_PolyShellData.lxx
View File

@ -51,11 +51,3 @@ HLRAlgo_PolyShellData::HidingPolyData ()
inline HLRAlgo_ListOfBPoint &
HLRAlgo_PolyShellData::Edges ()
{ return mySegList; }
//=======================================================================
//function : Indices
//purpose :
//=======================================================================
inline Standard_Address HLRAlgo_PolyShellData::Indices ()
{ return (Standard_Address)myMinMax; }

35
src/HLRAlgo/HLRAlgo_TriangleData.hxx
View File

@ -22,44 +22,13 @@
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
//! Data structure of a triangle.
class HLRAlgo_TriangleData
struct HLRAlgo_TriangleData
{
public:
DEFINE_STANDARD_ALLOC
HLRAlgo_TriangleData();
Standard_Address Indices() const;
protected:
private:
Standard_Integer myIndices[4];
Standard_Integer Node1, Node2, Node3, Flags;
};
#include <HLRAlgo_TriangleData.lxx>
#endif // _HLRAlgo_TriangleData_HeaderFile

31
src/HLRAlgo/HLRAlgo_TriangleData.lxx
View File

@ -1,31 +0,0 @@
// Created on: 1993-01-11
// Created by: Christophe MARION
// Copyright (c) 1993-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.
//=======================================================================
//function : TriangleData
//purpose :
//=======================================================================
inline HLRAlgo_TriangleData::HLRAlgo_TriangleData ()
{}
//=======================================================================
//function : Indices
//purpose :
//=======================================================================
inline Standard_Address HLRAlgo_TriangleData::Indices () const
{ return (Standard_Address)myIndices; }

47
src/HLRAlgo/HLRAlgo_WiresBlock.cxx
View File

@ -18,54 +18,7 @@
#define No_Exception
#endif
#include <HLRAlgo_EdgesBlock.hxx>
#include <HLRAlgo_WiresBlock.hxx>
#include <Standard_Type.hxx>
IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_WiresBlock,MMgt_TShared)
//=======================================================================
//function : HLRAlgo_WiresBlock
//purpose :
//=======================================================================
HLRAlgo_WiresBlock::HLRAlgo_WiresBlock (const Standard_Integer NbWires) :
myWires(1,NbWires)
{}
//=======================================================================
//function : NbWires
//purpose :
//=======================================================================
Standard_Integer HLRAlgo_WiresBlock::NbWires () const
{ return myWires.Upper(); }
//=======================================================================
//function : Set
//purpose :
//=======================================================================
void HLRAlgo_WiresBlock::Set (const Standard_Integer I,
const Handle(HLRAlgo_EdgesBlock)& W)
{ myWires (I) = W; }
//=======================================================================
//function : Wire
//purpose :
//=======================================================================
Handle(HLRAlgo_EdgesBlock) &
HLRAlgo_WiresBlock::Wire (const Standard_Integer I)
{ return *((Handle(HLRAlgo_EdgesBlock)*) &myWires(I)); }
//=======================================================================
//function : UpdateMinMax
//purpose :
//=======================================================================
void HLRAlgo_WiresBlock::UpdateMinMax (const Standard_Address TotMinMax)
{
for (Standard_Integer i = 0; i <= 15; i++)
myMinMax[i] = ((Standard_Integer*)TotMinMax)[i];
}

56
src/HLRAlgo/HLRAlgo_WiresBlock.hxx
View File

@ -17,14 +17,14 @@
#ifndef _HLRAlgo_WiresBlock_HeaderFile
#define _HLRAlgo_WiresBlock_HeaderFile
#include <HLRAlgo_EdgesBlock.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <TColStd_Array1OfTransient.hxx>
#include <Standard_Integer.hxx>
#include <MMgt_TShared.hxx>
#include <Standard_Address.hxx>
class HLRAlgo_EdgesBlock;
class HLRAlgo_WiresBlock;
@ -38,47 +38,41 @@ DEFINE_STANDARD_HANDLE(HLRAlgo_WiresBlock, MMgt_TShared)
//! * An Array of Blocks.
class HLRAlgo_WiresBlock : public MMgt_TShared
{
public:
//! Create a Block of Blocks.
Standard_EXPORT HLRAlgo_WiresBlock(const Standard_Integer NbWires);
HLRAlgo_WiresBlock(const Standard_Integer NbWires) :
myWires(1,NbWires)
{
}
Standard_EXPORT Standard_Integer NbWires() const;
Standard_Integer NbWires() const
{
return myWires.Upper();
}
Standard_EXPORT void Set (const Standard_Integer I, const Handle(HLRAlgo_EdgesBlock)& W);
void Set (const Standard_Integer I, const Handle(HLRAlgo_EdgesBlock)& W)
{
myWires (I) = W;
}
Standard_EXPORT Handle(HLRAlgo_EdgesBlock)& Wire (const Standard_Integer I);
Handle(HLRAlgo_EdgesBlock)& Wire (const Standard_Integer I)
{
return *((Handle(HLRAlgo_EdgesBlock)*) &myWires(I));
}
Standard_EXPORT void UpdateMinMax (const Standard_Address TotMinMax);
Standard_Address MinMax() const;
void UpdateMinMax (const HLRAlgo_EdgesBlock::MinMaxIndices& theMinMaxes)
{myMinMax = theMinMaxes;}
HLRAlgo_EdgesBlock::MinMaxIndices& MinMax()
{
return myMinMax;
}
DEFINE_STANDARD_RTTIEXT(HLRAlgo_WiresBlock,MMgt_TShared)
protected:
private:
TColStd_Array1OfTransient myWires;
Standard_Integer myMinMax[16];
HLRAlgo_EdgesBlock::MinMaxIndices myMinMax;
};
#include <HLRAlgo_WiresBlock.lxx>
#endif // _HLRAlgo_WiresBlock_HeaderFile

23
src/HLRAlgo/HLRAlgo_WiresBlock.lxx
View File

@ -1,23 +0,0 @@
// Created on: 1995-09-05
// Created by: Christophe MARION
// Copyright (c) 1995-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.
//=======================================================================
//function : MinMax
//purpose :
//=======================================================================
inline Standard_Address HLRAlgo_WiresBlock::MinMax () const
{ return (Standard_Address)&myMinMax; }

26
src/HLRBRep/HLRBRep_BiPnt2D.hxx
View File

@ -37,7 +37,9 @@ public:
: myRg1Line (false),
myRgNLine (false),
myOutLine (false),
myIntLine (false) {}
myIntLine (false)
{
}
HLRBRep_BiPnt2D(const Standard_Real x1, const Standard_Real y1, const Standard_Real x2, const Standard_Real y2, const TopoDS_Shape& S, const Standard_Boolean reg1, const Standard_Boolean regn, const Standard_Boolean outl, const Standard_Boolean intl)
: myP1(x1,y1),
@ -46,7 +48,27 @@ public:
myRg1Line (reg1),
myRgNLine (regn),
myOutLine (outl),
myIntLine (intl) {}
myIntLine (intl)
{
}
HLRBRep_BiPnt2D(
const gp_XY& thePoint1,
const gp_XY& thePoint2,
const TopoDS_Shape& S,
const Standard_Boolean reg1,
const Standard_Boolean regn,
const Standard_Boolean outl,
const Standard_Boolean intl) :
myP1(thePoint1),
myP2(thePoint2),
myShape(S),
myRg1Line (reg1),
myRgNLine (regn),
myOutLine (outl),
myIntLine (intl)
{
}
const gp_Pnt2d& P1() const { return myP1; }

10
src/HLRBRep/HLRBRep_CLProps.hxx
View File

@ -21,7 +21,6 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
#include <gp_Pnt2d.hxx>
@ -37,6 +36,7 @@ class gp_Vec2d;
class gp_Pnt2d;
class gp_Dir2d;
class HLRBRep_CLPropsATool;
class HLRBRep_Curve;
@ -56,12 +56,12 @@ public:
//! only the tangent, N should be equal to 1.
//! <Resolution> is the linear tolerance (it is used to test
//! if a vector is null).
Standard_EXPORT HLRBRep_CLProps(const Standard_Address& C, const Standard_Integer N, const Standard_Real Resolution);
Standard_EXPORT HLRBRep_CLProps(const HLRBRep_Curve*& C, const Standard_Integer N, const Standard_Real Resolution);
//! Same as previous constructor but here the parameter is
//! set to the value <U>.
//! All the computations done will be related to <C> and <U>.
Standard_EXPORT HLRBRep_CLProps(const Standard_Address& C, const Standard_Real U, const Standard_Integer N, const Standard_Real Resolution);
Standard_EXPORT HLRBRep_CLProps(const HLRBRep_Curve*& C, const Standard_Real U, const Standard_Integer N, const Standard_Real Resolution);
//! Same as previous constructor but here the parameter is
//! set to the value <U> and the curve is set
@ -77,7 +77,7 @@ public:
//! Initializes the local properties of the curve
//! for the new curve.
Standard_EXPORT void SetCurve (const Standard_Address& C);
Standard_EXPORT void SetCurve (const HLRBRep_Curve*& C);
//! Returns the Point.
Standard_EXPORT const gp_Pnt2d& Value() const;
@ -124,7 +124,7 @@ private:
Standard_Address myCurve;
const HLRBRep_Curve* myCurve;
Standard_Real myU;
Standard_Integer myDerOrder;
Standard_Real myCN;

15
src/HLRBRep/HLRBRep_CLPropsATool.hxx
View File

@ -21,7 +21,6 @@
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
class gp_Pnt2d;
@ -38,35 +37,35 @@ public:
//! Computes the point <P> of parameter <U> on the
//! Curve from HLRBRep <C>.
static void Value (const Standard_Address A, const Standard_Real U, gp_Pnt2d& P);
static void Value (const HLRBRep_Curve* A, const Standard_Real U, gp_Pnt2d& P);
//! Computes the point <P> and first derivative <V1>
//! of parameter <U> on the curve <C>.
static void D1 (const Standard_Address A, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1);
static void D1 (const HLRBRep_Curve* A, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1);
//! Computes the point <P>, the first derivative <V1>
//! and second derivative <V2> of parameter <U> on the
//! curve <C>.
static void D2 (const Standard_Address A, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
static void D2 (const HLRBRep_Curve* A, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2);
//! Computes the point <P>, the first derivative <V1>,
//! the second derivative <V2> and third derivative
//! <V3> of parameter <U> on the curve <C>.
static void D3 (const Standard_Address A, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
static void D3 (const HLRBRep_Curve* A, const Standard_Real U, gp_Pnt2d& P, gp_Vec2d& V1, gp_Vec2d& V2, gp_Vec2d& V3);
//! returns the order of continuity of the curve <C>.
//! returns 1 : first derivative only is computable
//! returns 2 : first and second derivative only are
//! computable. returns 3 : first, second and third
//! are computable.
static Standard_Integer Continuity (const Standard_Address A);
static Standard_Integer Continuity (const HLRBRep_Curve* A);
//! returns the first parameter bound of the curve.
static Standard_Real FirstParameter (const Standard_Address A);
static Standard_Real FirstParameter (const HLRBRep_Curve* A);
//! returns the last parameter bound of the curve.
//! FirstParameter must be less than LastParamenter.
static Standard_Real LastParameter (const Standard_Address A);
static Standard_Real LastParameter (const HLRBRep_Curve* A);

26
src/HLRBRep/HLRBRep_CLPropsATool.lxx
View File

@ -24,10 +24,10 @@
//=======================================================================
inline void HLRBRep_CLPropsATool::Value
(const Standard_Address A,
(const HLRBRep_Curve* A,
const Standard_Real U,
gp_Pnt2d& P)
{ P = ((HLRBRep_Curve*)A)->Value(U); }
{ P = A->Value(U); }
//=======================================================================
//function : D1
@ -35,11 +35,11 @@ inline void HLRBRep_CLPropsATool::Value
//=======================================================================
inline void HLRBRep_CLPropsATool::D1
(const Standard_Address A,
(const HLRBRep_Curve* A,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& V1)
{ ((HLRBRep_Curve*)A)->D1(U,P,V1); }
{ A->D1(U,P,V1); }
//=======================================================================
//function : D2
@ -47,12 +47,12 @@ inline void HLRBRep_CLPropsATool::D1
//=======================================================================
inline void HLRBRep_CLPropsATool::D2
(const Standard_Address A,
(const HLRBRep_Curve* A,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& V1,
gp_Vec2d& V2)
{ ((HLRBRep_Curve*)A)->D2(U, P, V1, V2); }
{ A->D2(U, P, V1, V2); }
//=======================================================================
//function : D3
@ -60,13 +60,13 @@ inline void HLRBRep_CLPropsATool::D2
//=======================================================================
inline void HLRBRep_CLPropsATool::D3
(const Standard_Address A,
(const HLRBRep_Curve* A,
const Standard_Real U,
gp_Pnt2d& P,
gp_Vec2d& V1,
gp_Vec2d& V2,
gp_Vec2d& V3)
{ ((HLRBRep_Curve*)A)->D3(U, P, V1, V2, V3); }
{ A->D3(U, P, V1, V2, V3); }
//=======================================================================
//function : Continuity
@ -74,7 +74,7 @@ inline void HLRBRep_CLPropsATool::D3
//=======================================================================
inline Standard_Integer HLRBRep_CLPropsATool::Continuity
(const Standard_Address)
(const HLRBRep_Curve*)
{ return GeomAbs_C2; }
//=======================================================================
@ -83,8 +83,8 @@ inline Standard_Integer HLRBRep_CLPropsATool::Continuity
//=======================================================================
inline Standard_Real HLRBRep_CLPropsATool::FirstParameter
(const Standard_Address A)
{ return ((HLRBRep_Curve*)A)->FirstParameter(); }
(const HLRBRep_Curve* A)
{ return A->FirstParameter(); }
//=======================================================================
//function : LastParameter
@ -92,5 +92,5 @@ inline Standard_Real HLRBRep_CLPropsATool::FirstParameter
//=======================================================================
inline Standard_Real HLRBRep_CLPropsATool::LastParameter
(const Standard_Address A)
{ return ((HLRBRep_Curve*)A)->LastParameter(); }
(const HLRBRep_Curve* A)
{ return A->LastParameter(); }

4
src/HLRBRep/HLRBRep_CLProps_0.cxx
View File

@ -26,8 +26,8 @@
#include <HLRBRep_CLPropsATool.hxx>
#define Curve Standard_Address
#define Curve_hxx <Standard_Address.hxx>
#define Curve HLRBRep_Curve*
#define Curve_hxx <HLRBRep_Curve.hxx>
#define Vec gp_Vec2d
#define Vec_hxx <gp_Vec2d.hxx>
#define Pnt gp_Pnt2d

21
src/HLRBRep/HLRBRep_Curve.cxx
View File

@ -127,8 +127,8 @@ HLRBRep_Curve::Parameter3d (const Standard_Real P2d) const
//purpose :
//=======================================================================
Standard_Real HLRBRep_Curve::Update (const Standard_Address TotMin,
const Standard_Address TotMax)
Standard_Real HLRBRep_Curve::Update(
Standard_Real TotMin[16], Standard_Real TotMax[16])
{
GeomAbs_CurveType typ = HLRBRep_BCurveTool::GetType(myCurve);
myType = GeomAbs_OtherCurve;
@ -229,9 +229,8 @@ Standard_Real HLRBRep_Curve::Update (const Standard_Address TotMin,
//purpose :
//=======================================================================
Standard_Real
HLRBRep_Curve::UpdateMinMax (const Standard_Address TotMin,
const Standard_Address TotMax)
Standard_Real HLRBRep_Curve::UpdateMinMax(
Standard_Real TotMin[16], Standard_Real TotMax[16])
{
Standard_Real a = HLRBRep_BCurveTool::FirstParameter(myCurve);
Standard_Real b = HLRBRep_BCurveTool::LastParameter(myCurve);
@ -302,8 +301,8 @@ void HLRBRep_Curve::Tangent (const Standard_Boolean AtStart,
D0(U,P);
HLRBRep_CLProps CLP(2,Epsilon(1.));
const Standard_Address crv = (const Standard_Address)this;
CLP.SetCurve(crv);
const HLRBRep_Curve* aCurve = this;
CLP.SetCurve(aCurve);
CLP.SetParameter(U);
StdFail_UndefinedDerivative_Raise_if
(!CLP.IsTangentDefined(), "HLRBRep_Curve::Tangent");
@ -463,7 +462,7 @@ gp_Lin2d HLRBRep_Curve::Line () const
gp_Circ2d HLRBRep_Curve::Circle () const
{
gp_Circ C = HLRBRep_BCurveTool::Circle(myCurve);
C.Transform(((HLRAlgo_Projector*) myProj)->Transformation());
C.Transform(myProj->Transformation());
return ProjLib::Project(gp_Pln(gp::XOY()),C);
}
@ -476,12 +475,12 @@ gp_Elips2d HLRBRep_Curve::Ellipse () const
{
if (HLRBRep_BCurveTool::GetType(myCurve) == GeomAbs_Ellipse) {
gp_Elips E = HLRBRep_BCurveTool::Ellipse(myCurve);
E.Transform(((HLRAlgo_Projector*) myProj)->Transformation());
E.Transform(myProj->Transformation());
return ProjLib::Project(gp_Pln(gp::XOY()),E);
}
// this is a circle
gp_Circ C = HLRBRep_BCurveTool::Circle(myCurve);
C.Transform(((HLRAlgo_Projector*) myProj)->Transformation());
C.Transform(myProj->Transformation());
const gp_Dir& D1 = C.Axis().Direction();
const gp_Dir& D3 = D1.Crossed(gp::DZ());
const gp_Dir& D2 = D1.Crossed(D3);
@ -526,7 +525,7 @@ void HLRBRep_Curve::Poles (TColgp_Array1OfPnt2d& TP) const
(HLRBRep_BCurveTool::Bezier(myCurve))->Poles(TP3);
}
for (Standard_Integer i = i1; i <= i2; i++) {
((HLRAlgo_Projector*) myProj)->Transform(TP3(i));
myProj->Transform(TP3(i));
TP(i).SetCoord(TP3(i).X(),TP3(i).Y());
}
}

11
src/HLRBRep/HLRBRep_Curve.hxx
View File

@ -23,7 +23,6 @@
#include <BRepAdaptor_Curve.hxx>
#include <GeomAbs_CurveType.hxx>
#include <Standard_Address.hxx>
#include <Standard_Real.hxx>
#include <gp_Pnt.hxx>
#include <Standard_Boolean.hxx>
@ -50,6 +49,7 @@ class gp_Elips2d;
class gp_Hypr2d;
class gp_Parab2d;
class Geom_BSplineCurve;
class HLRAlgo_Projector;
//! Defines a 2d curve by projection of a 3D curve on
@ -65,7 +65,8 @@ public:
//! Creates an undefined Curve.
Standard_EXPORT HLRBRep_Curve();
void Projector (const Standard_Address Proj);
void Projector (const HLRAlgo_Projector* Proj)
{myProj = Proj;}
//! Returns the 3D curve.
BRepAdaptor_Curve& Curve();
@ -85,10 +86,10 @@ public:
Standard_EXPORT Standard_Real Parameter3d (const Standard_Real P2d) const;
//! Update the minmax and the internal data
Standard_EXPORT Standard_Real Update (const Standard_Address TotMin, const Standard_Address TotMax);
Standard_EXPORT Standard_Real Update (Standard_Real TotMin[16], Standard_Real TotMax[16]);
//! Update the minmax returns tol for enlarge;
Standard_EXPORT Standard_Real UpdateMinMax (const Standard_Address TotMin, const Standard_Address TotMax);
Standard_EXPORT Standard_Real UpdateMinMax (Standard_Real TotMin[16], Standard_Real TotMax[16]);
//! Computes the Z coordinate of the point of
//! parameter U on the curve in the viewing coordinate system
@ -221,7 +222,7 @@ private:
BRepAdaptor_Curve myCurve;
GeomAbs_CurveType myType;
Standard_Address myProj;
const HLRAlgo_Projector* myProj;
Standard_Real myOX;
Standard_Real myOZ;
Standard_Real myVX;

8
src/HLRBRep/HLRBRep_Curve.lxx
View File

@ -24,14 +24,6 @@
#include <gp_Parab2d.hxx>
#include <HLRBRep_BCurveTool.hxx>
//=======================================================================
//function : Projector
//purpose :
//=======================================================================
inline void HLRBRep_Curve::Projector(const Standard_Address Proj)
{ myProj = Proj; }
//=======================================================================
//function : Curve
//purpose :

746
src/HLRBRep/HLRBRep_Data.cxx
View File

@ -57,114 +57,7 @@ static const Standard_Real CutBig = 1.e-1;
//-- voir HLRAlgo.cxx
#define MinShap1 ((Standard_Integer*)MinMaxShap)[ 0]
#define MinShap2 ((Standard_Integer*)MinMaxShap)[ 1]
#define MinShap3 ((Standard_Integer*)MinMaxShap)[ 2]
#define MinShap4 ((Standard_Integer*)MinMaxShap)[ 3]
#define MinShap5 ((Standard_Integer*)MinMaxShap)[ 4]
#define MinShap6 ((Standard_Integer*)MinMaxShap)[ 5]
#define MinShap7 ((Standard_Integer*)MinMaxShap)[ 6]
#define MinShap8 ((Standard_Integer*)MinMaxShap)[ 7]
#define MaxShap1 ((Standard_Integer*)MinMaxShap)[ 8]
#define MaxShap2 ((Standard_Integer*)MinMaxShap)[ 9]
#define MaxShap3 ((Standard_Integer*)MinMaxShap)[10]
#define MaxShap4 ((Standard_Integer*)MinMaxShap)[11]
#define MaxShap5 ((Standard_Integer*)MinMaxShap)[12]
#define MaxShap6 ((Standard_Integer*)MinMaxShap)[13]
#define MaxShap7 ((Standard_Integer*)MinMaxShap)[14]
#define MaxShap8 ((Standard_Integer*)MinMaxShap)[15]
#define MinFace1 ((Standard_Integer*)iFaceMinMax)[ 0]
#define MinFace2 ((Standard_Integer*)iFaceMinMax)[ 1]
#define MinFace3 ((Standard_Integer*)iFaceMinMax)[ 2]
#define MinFace4 ((Standard_Integer*)iFaceMinMax)[ 3]
#define MinFace5 ((Standard_Integer*)iFaceMinMax)[ 4]
#define MinFace6 ((Standard_Integer*)iFaceMinMax)[ 5]
#define MinFace7 ((Standard_Integer*)iFaceMinMax)[ 6]
#define MinFace8 ((Standard_Integer*)iFaceMinMax)[ 7]
#define MaxFace1 ((Standard_Integer*)iFaceMinMax)[ 8]
#define MaxFace2 ((Standard_Integer*)iFaceMinMax)[ 9]
#define MaxFace3 ((Standard_Integer*)iFaceMinMax)[10]
#define MaxFace4 ((Standard_Integer*)iFaceMinMax)[11]
#define MaxFace5 ((Standard_Integer*)iFaceMinMax)[12]
#define MaxFace6 ((Standard_Integer*)iFaceMinMax)[13]
#define MaxFace7 ((Standard_Integer*)iFaceMinMax)[14]
#define MaxFace8 ((Standard_Integer*)iFaceMinMax)[15]
#define MinWire1 ((Standard_Integer*)MinMaxWire)[ 0]
#define MinWire2 ((Standard_Integer*)MinMaxWire)[ 1]
#define MinWire3 ((Standard_Integer*)MinMaxWire)[ 2]
#define MinWire4 ((Standard_Integer*)MinMaxWire)[ 3]
#define MinWire5 ((Standard_Integer*)MinMaxWire)[ 4]
#define MinWire6 ((Standard_Integer*)MinMaxWire)[ 5]
#define MinWire7 ((Standard_Integer*)MinMaxWire)[ 6]
#define MinWire8 ((Standard_Integer*)MinMaxWire)[ 7]
#define MaxWire1 ((Standard_Integer*)MinMaxWire)[ 8]
#define MaxWire2 ((Standard_Integer*)MinMaxWire)[ 9]
#define MaxWire3 ((Standard_Integer*)MinMaxWire)[10]
#define MaxWire4 ((Standard_Integer*)MinMaxWire)[11]
#define MaxWire5 ((Standard_Integer*)MinMaxWire)[12]
#define MaxWire6 ((Standard_Integer*)MinMaxWire)[13]
#define MaxWire7 ((Standard_Integer*)MinMaxWire)[14]
#define MaxWire8 ((Standard_Integer*)MinMaxWire)[15]
#define MinLEdg1 ((Standard_Integer*)myLEMinMax)[ 0]
#define MinLEdg2 ((Standard_Integer*)myLEMinMax)[ 1]
#define MinLEdg3 ((Standard_Integer*)myLEMinMax)[ 2]
#define MinLEdg4 ((Standard_Integer*)myLEMinMax)[ 3]
#define MinLEdg5 ((Standard_Integer*)myLEMinMax)[ 4]
#define MinLEdg6 ((Standard_Integer*)myLEMinMax)[ 5]
#define MinLEdg7 ((Standard_Integer*)myLEMinMax)[ 6]
#define MinLEdg8 ((Standard_Integer*)myLEMinMax)[ 7]
#define MaxLEdg1 ((Standard_Integer*)myLEMinMax)[ 8]
#define MaxLEdg2 ((Standard_Integer*)myLEMinMax)[ 9]
#define MaxLEdg3 ((Standard_Integer*)myLEMinMax)[10]
#define MaxLEdg4 ((Standard_Integer*)myLEMinMax)[11]
#define MaxLEdg5 ((Standard_Integer*)myLEMinMax)[12]
#define MaxLEdg6 ((Standard_Integer*)myLEMinMax)[13]
#define MaxLEdg7 ((Standard_Integer*)myLEMinMax)[14]
#define MaxLEdg8 ((Standard_Integer*)myLEMinMax)[15]
#define MinFEdg1 ((Standard_Integer*)MinMaxFEdg)[ 0]
#define MinFEdg2 ((Standard_Integer*)MinMaxFEdg)[ 1]
#define MinFEdg3 ((Standard_Integer*)MinMaxFEdg)[ 2]
#define MinFEdg4 ((Standard_Integer*)MinMaxFEdg)[ 3]
#define MinFEdg5 ((Standard_Integer*)MinMaxFEdg)[ 4]
#define MinFEdg6 ((Standard_Integer*)MinMaxFEdg)[ 5]
#define MinFEdg7 ((Standard_Integer*)MinMaxFEdg)[ 6]
#define MinFEdg8 ((Standard_Integer*)MinMaxFEdg)[ 7]
#define MaxFEdg1 ((Standard_Integer*)MinMaxFEdg)[ 8]
#define MaxFEdg2 ((Standard_Integer*)MinMaxFEdg)[ 9]
#define MaxFEdg3 ((Standard_Integer*)MinMaxFEdg)[10]
#define MaxFEdg4 ((Standard_Integer*)MinMaxFEdg)[11]
#define MaxFEdg5 ((Standard_Integer*)MinMaxFEdg)[12]
#define MaxFEdg6 ((Standard_Integer*)MinMaxFEdg)[13]
#define MaxFEdg7 ((Standard_Integer*)MinMaxFEdg)[14]
#define MaxFEdg8 ((Standard_Integer*)MinMaxFEdg)[15]
#define MinVert1 MinMaxVert[ 0]
#define MinVert2 MinMaxVert[ 1]
#define MinVert3 MinMaxVert[ 2]
#define MinVert4 MinMaxVert[ 3]
#define MinVert5 MinMaxVert[ 4]
#define MinVert6 MinMaxVert[ 5]
#define MinVert7 MinMaxVert[ 6]
#define MinVert8 MinMaxVert[ 7]
#define MaxVert1 MinMaxVert[ 8]
#define MaxVert2 MinMaxVert[ 9]
#define MaxVert3 MinMaxVert[10]
#define MaxVert4 MinMaxVert[11]
#define MaxVert5 MinMaxVert[12]
#define MaxVert6 MinMaxVert[13]
#define MaxVert7 MinMaxVert[14]
#define MaxVert8 MinMaxVert[15]
#define DERIVEE_PREMIERE_NULLE 0.000000000001
static const Standard_Real DERIVEE_PREMIERE_NULLE = 0.000000000001;
//-- ======================================================================
//--
@ -181,7 +74,7 @@ static long unsigned Mask32[32] = { 1,2,4,8, 16,32,64,128, 256,512,1024,2048,
16777216,33554432,67108864,134217728,
268435456,536870912,1073741824,2147483648U};
#define SIZEUV 8
static const Standard_Integer SIZEUV = 8;
class TableauRejection {
public:
@ -520,7 +413,7 @@ HLRBRep_Data::HLRBRep_Data (const Standard_Integer NV,
mySLProps(2,Epsilon(1.)),
myHideCount(0)
{
myReject=(void *)(new TableauRejection());
myReject = new TableauRejection();
((TableauRejection *)myReject)->SetDim(myNbEdges);
}
@ -601,13 +494,13 @@ void HLRBRep_Data::Update (const HLRAlgo_Projector& P)
Standard_Integer i;
Standard_Real tolMinMax = 0;
Standard_Integer FaceMin[16],FaceMax[16],MinMaxFace[16];
Standard_Integer WireMin[16],WireMax[16],MinMaxWire[16];
Standard_Integer EdgeMin[16],EdgeMax[16],MinMaxEdge[16];
HLRAlgo_EdgesBlock::MinMaxIndices FaceMin, FaceMax;
HLRAlgo_EdgesBlock::MinMaxIndices MinMaxFace;
HLRAlgo_EdgesBlock::MinMaxIndices WireMin, WireMax, MinMaxWire;
HLRAlgo_EdgesBlock::MinMaxIndices EdgeMin, EdgeMax;
HLRAlgo_EdgesBlock::MinMaxIndices MinMaxEdge;
Standard_Real TotMin[16],TotMax[16];
HLRAlgo::InitMinMax(Precision::Infinite(),
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::InitMinMax(Precision::Infinite(), TotMin, TotMax);
// compute the global MinMax
// *************************
@ -617,13 +510,10 @@ void HLRBRep_Data::Update (const HLRAlgo_Projector& P)
HLRBRep_EdgeData& ed = myEData.ChangeValue(edge);
HLRBRep_Curve& EC = ed.ChangeGeometry();
EC.Projector(&myProj);
Standard_Real enl =EC.Update((Standard_Address)TotMin,
(Standard_Address)TotMax);
Standard_Real enl =EC.Update(TotMin, TotMax);
if (enl > tolMinMax) tolMinMax = enl;
}
HLRAlgo::EnlargeMinMax(tolMinMax,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::EnlargeMinMax(tolMinMax, TotMin, TotMax);
Standard_Real d[16];
Standard_Real precad = -Precision::Infinite();
@ -651,11 +541,8 @@ void HLRBRep_Data::Update (const HLRAlgo_Projector& P)
HLRBRep_EdgeData& ed = myEData.ChangeValue(edge);
HLRBRep_Curve& EC = ed.ChangeGeometry();
HLRAlgo::InitMinMax(Precision::Infinite(),
(Standard_Address)TotMin,
(Standard_Address)TotMax);
tolMinMax = EC.UpdateMinMax((Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::InitMinMax(Precision::Infinite(), TotMin, TotMax);
tolMinMax = EC.UpdateMinMax(TotMin, TotMax);
tol = (Standard_Real)(ed.Tolerance());
ed.Vertical(TotMax[0] - TotMin[0] < tol &&
TotMax[1] - TotMin[1] < tol &&
@ -664,47 +551,43 @@ void HLRBRep_Data::Update (const HLRAlgo_Projector& P)
TotMax[4] - TotMin[4] < tol &&
TotMax[5] - TotMin[5] < tol &&
TotMax[6] - TotMin[6] < tol );
HLRAlgo::EnlargeMinMax(tolMinMax,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::EnlargeMinMax(tolMinMax, TotMin, TotMax);
// Linux warning : assignment to `int' from `double'. Cast has been added.
EdgeMin[ 0] = (Standard_Integer)( (myDeca[ 0] + TotMin[ 0]) * mySurD[ 0]);
EdgeMax[ 0] = (Standard_Integer)( (myDeca[ 0] + TotMax[ 0]) * mySurD[ 0]);
EdgeMin[ 1] = (Standard_Integer)( (myDeca[ 1] + TotMin[ 1]) * mySurD[ 1]);
EdgeMax[ 1] = (Standard_Integer)( (myDeca[ 1] + TotMax[ 1]) * mySurD[ 1]);
EdgeMin[ 2] = (Standard_Integer)( (myDeca[ 2] + TotMin[ 2]) * mySurD[ 2]);
EdgeMax[ 2] = (Standard_Integer)( (myDeca[ 2] + TotMax[ 2]) * mySurD[ 2]);
EdgeMin[ 3] = (Standard_Integer)( (myDeca[ 3] + TotMin[ 3]) * mySurD[ 3]);
EdgeMax[ 3] = (Standard_Integer)( (myDeca[ 3] + TotMax[ 3]) * mySurD[ 3]);
EdgeMin[ 4] = (Standard_Integer)( (myDeca[ 4] + TotMin[ 4]) * mySurD[ 4]);
EdgeMax[ 4] = (Standard_Integer)( (myDeca[ 4] + TotMax[ 4]) * mySurD[ 4]);
EdgeMin[ 5] = (Standard_Integer)( (myDeca[ 5] + TotMin[ 5]) * mySurD[ 5]);
EdgeMax[ 5] = (Standard_Integer)( (myDeca[ 5] + TotMax[ 5]) * mySurD[ 5]);
EdgeMin[ 6] = (Standard_Integer)( (myDeca[ 6] + TotMin[ 6]) * mySurD[ 6]);
EdgeMax[ 6] = (Standard_Integer)( (myDeca[ 6] + TotMax[ 6]) * mySurD[ 6]);
EdgeMin[ 7] = (Standard_Integer)( (myDeca[ 7] + TotMin[ 7]) * mySurD[ 7]);
EdgeMax[ 7] = (Standard_Integer)( (myDeca[ 7] + TotMax[ 7]) * mySurD[ 7]);
EdgeMin[ 8] = (Standard_Integer)( (myDeca[ 8] + TotMin[ 8]) * mySurD[ 8]);
EdgeMax[ 8] = (Standard_Integer)( (myDeca[ 8] + TotMax[ 8]) * mySurD[ 8]);
EdgeMin[ 9] = (Standard_Integer)( (myDeca[ 9] + TotMin[ 9]) * mySurD[ 9]);
EdgeMax[ 9] = (Standard_Integer)( (myDeca[ 9] + TotMax[ 9]) * mySurD[ 9]);
EdgeMin[10] = (Standard_Integer)( (myDeca[10] + TotMin[10]) * mySurD[10]);
EdgeMax[10] = (Standard_Integer)( (myDeca[10] + TotMax[10]) * mySurD[10]);
EdgeMin[11] = (Standard_Integer)( (myDeca[11] + TotMin[11]) * mySurD[11]);
EdgeMax[11] = (Standard_Integer)( (myDeca[11] + TotMax[11]) * mySurD[11]);
EdgeMin[12] = (Standard_Integer)( (myDeca[12] + TotMin[12]) * mySurD[12]);
EdgeMax[12] = (Standard_Integer)( (myDeca[12] + TotMax[12]) * mySurD[12]);
EdgeMin[13] = (Standard_Integer)( (myDeca[13] + TotMin[13]) * mySurD[13]);
EdgeMax[13] = (Standard_Integer)( (myDeca[13] + TotMax[13]) * mySurD[13]);
EdgeMin[14] = (Standard_Integer)( (myDeca[14] + TotMin[14]) * mySurD[14]);
EdgeMax[14] = (Standard_Integer)( (myDeca[14] + TotMax[14]) * mySurD[14]);
EdgeMin[15] = (Standard_Integer)( (myDeca[15] + TotMin[15]) * mySurD[15]);
EdgeMax[15] = (Standard_Integer)( (myDeca[15] + TotMax[15]) * mySurD[15]);
EdgeMin.Min[0] = (Standard_Integer)( (myDeca[ 0] + TotMin[ 0]) * mySurD[ 0]);
EdgeMax.Min[0] = (Standard_Integer)( (myDeca[ 0] + TotMax[ 0]) * mySurD[ 0]);
EdgeMin.Min[1] = (Standard_Integer)( (myDeca[ 1] + TotMin[ 1]) * mySurD[ 1]);
EdgeMax.Min[1] = (Standard_Integer)( (myDeca[ 1] + TotMax[ 1]) * mySurD[ 1]);
EdgeMin.Min[2] = (Standard_Integer)( (myDeca[ 2] + TotMin[ 2]) * mySurD[ 2]);
EdgeMax.Min[2] = (Standard_Integer)( (myDeca[ 2] + TotMax[ 2]) * mySurD[ 2]);
EdgeMin.Min[3] = (Standard_Integer)( (myDeca[ 3] + TotMin[ 3]) * mySurD[ 3]);
EdgeMax.Min[3] = (Standard_Integer)( (myDeca[ 3] + TotMax[ 3]) * mySurD[ 3]);
EdgeMin.Min[4] = (Standard_Integer)( (myDeca[ 4] + TotMin[ 4]) * mySurD[ 4]);
EdgeMax.Min[4] = (Standard_Integer)( (myDeca[ 4] + TotMax[ 4]) * mySurD[ 4]);
EdgeMin.Min[5] = (Standard_Integer)( (myDeca[ 5] + TotMin[ 5]) * mySurD[ 5]);
EdgeMax.Min[5] = (Standard_Integer)( (myDeca[ 5] + TotMax[ 5]) * mySurD[ 5]);
EdgeMin.Min[6] = (Standard_Integer)( (myDeca[ 6] + TotMin[ 6]) * mySurD[ 6]);
EdgeMax.Min[6] = (Standard_Integer)( (myDeca[ 6] + TotMax[ 6]) * mySurD[ 6]);
EdgeMin.Min[7] = (Standard_Integer)( (myDeca[ 7] + TotMin[ 7]) * mySurD[ 7]);
EdgeMax.Min[7] = (Standard_Integer)( (myDeca[ 7] + TotMax[ 7]) * mySurD[ 7]);
EdgeMin.Max[0] = (Standard_Integer)( (myDeca[ 8] + TotMin[ 8]) * mySurD[ 8]);
EdgeMax.Max[0] = (Standard_Integer)( (myDeca[ 8] + TotMax[ 8]) * mySurD[ 8]);
EdgeMin.Max[1] = (Standard_Integer)( (myDeca[ 9] + TotMin[ 9]) * mySurD[ 9]);
EdgeMax.Max[1] = (Standard_Integer)( (myDeca[ 9] + TotMax[ 9]) * mySurD[ 9]);
EdgeMin.Max[2] = (Standard_Integer)( (myDeca[10] + TotMin[10]) * mySurD[10]);
EdgeMax.Max[2] = (Standard_Integer)( (myDeca[10] + TotMax[10]) * mySurD[10]);
EdgeMin.Max[3] = (Standard_Integer)( (myDeca[11] + TotMin[11]) * mySurD[11]);
EdgeMax.Max[3] = (Standard_Integer)( (myDeca[11] + TotMax[11]) * mySurD[11]);
EdgeMin.Max[4] = (Standard_Integer)( (myDeca[12] + TotMin[12]) * mySurD[12]);
EdgeMax.Max[4] = (Standard_Integer)( (myDeca[12] + TotMax[12]) * mySurD[12]);
EdgeMin.Max[5] = (Standard_Integer)( (myDeca[13] + TotMin[13]) * mySurD[13]);
EdgeMax.Max[5] = (Standard_Integer)( (myDeca[13] + TotMax[13]) * mySurD[13]);
EdgeMin.Max[6] = (Standard_Integer)( (myDeca[14] + TotMin[14]) * mySurD[14]);
EdgeMax.Max[6] = (Standard_Integer)( (myDeca[14] + TotMax[14]) * mySurD[14]);
EdgeMin.Max[7] = (Standard_Integer)( (myDeca[15] + TotMin[15]) * mySurD[15]);
EdgeMax.Max[7] = (Standard_Integer)( (myDeca[15] + TotMax[15]) * mySurD[15]);
HLRAlgo::EncodeMinMax((Standard_Address)EdgeMin,
(Standard_Address)EdgeMax,
(Standard_Address)MinMaxEdge);
ed.UpdateMinMax((Standard_Address)MinMaxEdge);
HLRAlgo::EncodeMinMax(EdgeMin, EdgeMax, MinMaxEdge);
ed.UpdateMinMax(MinMaxEdge);
if (ed.Vertical()) {
ver1 = Standard_True;
ver2 = Standard_True;
@ -889,42 +772,24 @@ void HLRBRep_Data::Update (const HLRAlgo_Projector& P)
myFE = myFaceItr1.Edge();
HLRBRep_EdgeData& EDataFE2 = myEData(myFE);
if (!fd.Simple()) EDataFE2.AutoIntersectionDone(Standard_False);
HLRAlgo::DecodeMinMax(EDataFE2.MinMax(),
(Standard_Address)EdgeMin,
(Standard_Address)EdgeMax);
HLRAlgo::DecodeMinMax(EDataFE2.MinMax(), EdgeMin, EdgeMax);
if (myFaceItr1.BeginningOfWire())
HLRAlgo::CopyMinMax((Standard_Address)EdgeMin,
(Standard_Address)EdgeMax,
(Standard_Address)WireMin,
(Standard_Address)WireMax);
HLRAlgo::CopyMinMax(EdgeMin, EdgeMax, WireMin, WireMax);
else
HLRAlgo::AddMinMax((Standard_Address)EdgeMin,
(Standard_Address)EdgeMax,
(Standard_Address)WireMin,
(Standard_Address)WireMax);
HLRAlgo::AddMinMax(EdgeMin, EdgeMax, WireMin, WireMax);
if (myFaceItr1.EndOfWire()) {
HLRAlgo::EncodeMinMax((Standard_Address)WireMin,
(Standard_Address)WireMax,
(Standard_Address)MinMaxWire);
myFaceItr1.Wire()->UpdateMinMax((Standard_Address)MinMaxWire);
HLRAlgo::EncodeMinMax(WireMin, WireMax, MinMaxWire);
myFaceItr1.Wire()->UpdateMinMax(MinMaxWire);
if (FirstTime) {
FirstTime = Standard_False;
HLRAlgo::CopyMinMax((Standard_Address)WireMin,
(Standard_Address)WireMax,
(Standard_Address)FaceMin,
(Standard_Address)FaceMax);
HLRAlgo::CopyMinMax(WireMin, WireMax, FaceMin, FaceMax);
}
else
HLRAlgo::AddMinMax((Standard_Address)WireMin,
(Standard_Address)WireMax,
(Standard_Address)FaceMin,
(Standard_Address)FaceMax);
HLRAlgo::AddMinMax(WireMin, WireMax, FaceMin, FaceMax);
}
}
HLRAlgo::EncodeMinMax((Standard_Address)FaceMin,
(Standard_Address)FaceMax,
(Standard_Address)MinMaxFace);
fd.Wires()->UpdateMinMax((Standard_Address)MinMaxFace);
HLRAlgo::EncodeMinMax(FaceMin, FaceMax, MinMaxFace);
fd.Wires()->UpdateMinMax(MinMaxFace);
fd.Size(HLRAlgo::SizeBox(FaceMin,FaceMax));
}
}
@ -935,32 +800,32 @@ void HLRBRep_Data::Update (const HLRAlgo_Projector& P)
//=======================================================================
void
HLRBRep_Data::InitBoundSort (const Standard_Address MinMaxTot,
HLRBRep_Data::InitBoundSort (const HLRAlgo_EdgesBlock::MinMaxIndices& MinMaxTot,
const Standard_Integer e1,
const Standard_Integer e2)
{
myNbrSortEd = 0;
Standard_Address MinMaxShap = MinMaxTot;
const HLRAlgo_EdgesBlock::MinMaxIndices& MinMaxShap = MinMaxTot;
for (Standard_Integer e = e1; e <= e2; e++) {
HLRBRep_EdgeData& ed = myEData(e);
if (!ed.Status().AllHidden()) {
myLEMinMax = ed.MinMax();
if (((MaxShap1 - MinLEdg1) & 0x80008000) == 0 &&
((MaxLEdg1 - MinShap1) & 0x80008000) == 0 &&
((MaxShap2 - MinLEdg2) & 0x80008000) == 0 &&
((MaxLEdg2 - MinShap2) & 0x80008000) == 0 &&
((MaxShap3 - MinLEdg3) & 0x80008000) == 0 &&
((MaxLEdg3 - MinShap3) & 0x80008000) == 0 &&
((MaxShap4 - MinLEdg4) & 0x80008000) == 0 &&
((MaxLEdg4 - MinShap4) & 0x80008000) == 0 &&
((MaxShap5 - MinLEdg5) & 0x80008000) == 0 &&
((MaxLEdg5 - MinShap5) & 0x80008000) == 0 &&
((MaxShap6 - MinLEdg6) & 0x80008000) == 0 &&
((MaxLEdg6 - MinShap6) & 0x80008000) == 0 &&
((MaxShap7 - MinLEdg7) & 0x80008000) == 0 &&
((MaxLEdg7 - MinShap7) & 0x80008000) == 0 &&
((MaxShap8 - MinLEdg8) & 0x80008000) == 0) { //- rejection en z
myLEMinMax = &ed.MinMax();
if (((MinMaxShap.Max[0] - myLEMinMax->Min[0]) & 0x80008000) == 0 &&
((myLEMinMax->Max[0] - MinMaxShap.Min[0]) & 0x80008000) == 0 &&
((MinMaxShap.Max[1] - myLEMinMax->Min[1]) & 0x80008000) == 0 &&
((myLEMinMax->Max[1] - MinMaxShap.Min[1]) & 0x80008000) == 0 &&
((MinMaxShap.Max[2] - myLEMinMax->Min[2]) & 0x80008000) == 0 &&
((myLEMinMax->Max[2] - MinMaxShap.Min[2]) & 0x80008000) == 0 &&
((MinMaxShap.Max[3] - myLEMinMax->Min[3]) & 0x80008000) == 0 &&
((myLEMinMax->Max[3] - MinMaxShap.Min[3]) & 0x80008000) == 0 &&
((MinMaxShap.Max[4] - myLEMinMax->Min[4]) & 0x80008000) == 0 &&
((myLEMinMax->Max[4] - MinMaxShap.Min[4]) & 0x80008000) == 0 &&
((MinMaxShap.Max[5] - myLEMinMax->Min[5]) & 0x80008000) == 0 &&
((myLEMinMax->Max[5] - MinMaxShap.Min[5]) & 0x80008000) == 0 &&
((MinMaxShap.Max[6] - myLEMinMax->Min[6]) & 0x80008000) == 0 &&
((myLEMinMax->Max[6] - MinMaxShap.Min[6]) & 0x80008000) == 0 &&
((MinMaxShap.Max[7] - myLEMinMax->Min[7]) & 0x80008000) == 0) { //- rejection en z
myNbrSortEd++;
myEdgeIndices(myNbrSortEd) = e;
}
@ -980,10 +845,10 @@ void HLRBRep_Data::InitEdge (const Standard_Integer FI,
iFace = FI;
iFaceData = &myFData(iFace);
iFaceGeom = &(((HLRBRep_FaceData*)iFaceData)->Geometry());
iFaceBack = ((HLRBRep_FaceData*)iFaceData)->Back();
iFaceSimp = ((HLRBRep_FaceData*)iFaceData)->Simple();
iFaceMinMax = ((HLRBRep_FaceData*)iFaceData)->Wires()->MinMax();
iFaceGeom = &iFaceData->Geometry();
iFaceBack = iFaceData->Back();
iFaceSimp = iFaceData->Simple();
iFaceMinMax = &iFaceData->Wires()->MinMax();
iFaceType = ((HLRBRep_Surface*)iFaceGeom)->GetType();
iFaceTest = !iFaceSimp;
mySLProps.SetSurface(iFaceGeom);
@ -1010,12 +875,12 @@ void HLRBRep_Data::InitEdge (const Standard_Integer FI,
}
if (iFaceTest) {
iFaceSmpl = !((HLRBRep_FaceData*)iFaceData)->Cut();
myFaceItr2.InitEdge(*((HLRBRep_FaceData*)iFaceData));
iFaceSmpl = !iFaceData->Cut();
myFaceItr2.InitEdge(*iFaceData);
}
else {
for (myFaceItr1.InitEdge(*((HLRBRep_FaceData*)iFaceData));
for (myFaceItr1.InitEdge(*iFaceData);
myFaceItr1.MoreEdge();
myFaceItr1.NextEdge()) {
myFE = myFaceItr1.Edge(); // edges of a simple hiding
@ -1043,18 +908,18 @@ Standard_Boolean HLRBRep_Data::MoreEdge ()
myLEDouble = myFaceItr2.Double ();
myLEIsoLine = myFaceItr2.IsoLine ();
myLEData = &myEData(myLE);
myLEGeom = &(((HLRBRep_EdgeData*)myLEData)->ChangeGeometry());
myLEMinMax = ((HLRBRep_EdgeData*)myLEData)->MinMax();
myLETol = ((HLRBRep_EdgeData*)myLEData)->Tolerance();
myLEType = ((HLRBRep_Curve *)myLEGeom)->GetType();
myLEGeom = &myLEData->ChangeGeometry();
myLEMinMax = &myLEData->MinMax();
myLETol = myLEData->Tolerance();
myLEType = myLEGeom->GetType();
if (!myLEDouble)
((HLRBRep_EdgeData*)myLEData)->HideCount(myHideCount-1);
myLEData->HideCount(myHideCount-1);
return Standard_True;
}
else {
iFaceTest = Standard_False; // at the end of the test
iFaceSimp = iFaceSmpl; // we know if it is a simple face
((HLRBRep_FaceData*)iFaceData)->Simple(iFaceSimp);
iFaceData->Simple(iFaceSimp);
myCurSortEd = 1;
NextEdge(Standard_False);
}
@ -1081,10 +946,10 @@ void HLRBRep_Data::NextEdge (const Standard_Boolean skip)
myLEDouble = myFaceItr2.Double ();
myLEIsoLine = myFaceItr2.IsoLine ();
myLEData = &myEData(myLE);
myLEGeom = &(((HLRBRep_EdgeData*)myLEData)->ChangeGeometry());
myLEMinMax = ((HLRBRep_EdgeData*)myLEData)->MinMax();
myLETol = ((HLRBRep_EdgeData*)myLEData)->Tolerance();
myLEType = ((HLRBRep_Curve *)myLEGeom)->GetType();
myLEGeom = &myLEData->ChangeGeometry();
myLEMinMax = &myLEData->MinMax();
myLETol = myLEData->Tolerance();
myLEType = myLEGeom->GetType();
if (((HLRBRep_EdgeData*)myLEData)->Vertical() ||
(myLEDouble &&
((HLRBRep_EdgeData*)myLEData)->HideCount() == myHideCount-1))
@ -1099,10 +964,10 @@ void HLRBRep_Data::NextEdge (const Standard_Boolean skip)
myLEDouble = Standard_False;
myLEIsoLine = Standard_False;
myLEData = &myEData(myLE);
myLEGeom = &(((HLRBRep_EdgeData*)myLEData)->ChangeGeometry());
myLEMinMax = ((HLRBRep_EdgeData*)myLEData)->MinMax();
myLETol = ((HLRBRep_EdgeData*)myLEData)->Tolerance();
myLEType = ((HLRBRep_Curve *)myLEGeom)->GetType();
myLEGeom = &myLEData->ChangeGeometry();
myLEMinMax = &myLEData->MinMax();
myLETol = myLEData->Tolerance();
myLEType = myLEGeom->GetType();
}
if (((HLRBRep_EdgeData*)myLEData)->Vertical()) {
NextEdge();
@ -1116,21 +981,21 @@ void HLRBRep_Data::NextEdge (const Standard_Boolean skip)
NextEdge();
return;
}
if (((MaxFace1 - MinLEdg1) & 0x80008000) != 0 ||
((MaxLEdg1 - MinFace1) & 0x80008000) != 0 ||
((MaxFace2 - MinLEdg2) & 0x80008000) != 0 ||
((MaxLEdg2 - MinFace2) & 0x80008000) != 0 ||
((MaxFace3 - MinLEdg3) & 0x80008000) != 0 ||
((MaxLEdg3 - MinFace3) & 0x80008000) != 0 ||
((MaxFace4 - MinLEdg4) & 0x80008000) != 0 ||
((MaxLEdg4 - MinFace4) & 0x80008000) != 0 ||
((MaxFace5 - MinLEdg5) & 0x80008000) != 0 ||
((MaxLEdg5 - MinFace5) & 0x80008000) != 0 ||
((MaxFace6 - MinLEdg6) & 0x80008000) != 0 ||
((MaxLEdg6 - MinFace6) & 0x80008000) != 0 ||
((MaxFace7 - MinLEdg7) & 0x80008000) != 0 ||
((MaxLEdg7 - MinFace7) & 0x80008000) != 0 ||
((MaxFace8 - MinLEdg8) & 0x80008000) != 0) { //-- rejection en z
if (((iFaceMinMax->Max[0] - myLEMinMax->Min[0]) & 0x80008000) != 0 ||
((myLEMinMax->Max[0] - iFaceMinMax->Min[0]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[1] - myLEMinMax->Min[1]) & 0x80008000) != 0 ||
((myLEMinMax->Max[1] - iFaceMinMax->Min[1]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[2] - myLEMinMax->Min[2]) & 0x80008000) != 0 ||
((myLEMinMax->Max[2] - iFaceMinMax->Min[2]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[3] - myLEMinMax->Min[3]) & 0x80008000) != 0 ||
((myLEMinMax->Max[3] - iFaceMinMax->Min[3]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[4] - myLEMinMax->Min[4]) & 0x80008000) != 0 ||
((myLEMinMax->Max[4] - iFaceMinMax->Min[4]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[5] - myLEMinMax->Min[5]) & 0x80008000) != 0 ||
((myLEMinMax->Max[5] - iFaceMinMax->Min[5]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[6] - myLEMinMax->Min[6]) & 0x80008000) != 0 ||
((myLEMinMax->Max[6] - iFaceMinMax->Min[6]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[7] - myLEMinMax->Min[7]) & 0x80008000) != 0) { //-- rejection en z
NextEdge();
return;
}
@ -1182,22 +1047,22 @@ void HLRBRep_Data::NextInterference ()
// rejection of current wire
if (myFaceItr1.BeginningOfWire()) {
Standard_Address MinMaxWire = myFaceItr1.Wire()->MinMax();
if (((MaxWire1 - MinLEdg1) & 0x80008000) != 0 ||
((MaxLEdg1 - MinWire1) & 0x80008000) != 0 ||
((MaxWire2 - MinLEdg2) & 0x80008000) != 0 ||
((MaxLEdg2 - MinWire2) & 0x80008000) != 0 ||
((MaxWire3 - MinLEdg3) & 0x80008000) != 0 ||
((MaxLEdg3 - MinWire3) & 0x80008000) != 0 ||
((MaxWire4 - MinLEdg4) & 0x80008000) != 0 ||
((MaxLEdg4 - MinWire4) & 0x80008000) != 0 ||
((MaxWire5 - MinLEdg5) & 0x80008000) != 0 ||
((MaxLEdg5 - MinWire5) & 0x80008000) != 0 ||
((MaxWire6 - MinLEdg6) & 0x80008000) != 0 ||
((MaxLEdg6 - MinWire6) & 0x80008000) != 0 ||
((MaxWire7 - MinLEdg7) & 0x80008000) != 0 ||
((MaxLEdg7 - MinWire7) & 0x80008000) != 0 ||
((MaxWire8 - MinLEdg8) & 0x80008000) != 0) { //-- Rejection en Z
HLRAlgo_EdgesBlock::MinMaxIndices& MinMaxWire = myFaceItr1.Wire()->MinMax();
if (((MinMaxWire.Max[0] - myLEMinMax->Min[0]) & 0x80008000) != 0 ||
((myLEMinMax->Max[0] - MinMaxWire.Min[0]) & 0x80008000) != 0 ||
((MinMaxWire.Max[1] - myLEMinMax->Min[1]) & 0x80008000) != 0 ||
((myLEMinMax->Max[1] - MinMaxWire.Min[1]) & 0x80008000) != 0 ||
((MinMaxWire.Max[2] - myLEMinMax->Min[2]) & 0x80008000) != 0 ||
((myLEMinMax->Max[2] - MinMaxWire.Min[2]) & 0x80008000) != 0 ||
((MinMaxWire.Max[3] - myLEMinMax->Min[3]) & 0x80008000) != 0 ||
((myLEMinMax->Max[3] - MinMaxWire.Min[3]) & 0x80008000) != 0 ||
((MinMaxWire.Max[4] - myLEMinMax->Min[4]) & 0x80008000) != 0 ||
((myLEMinMax->Max[4] - MinMaxWire.Min[4]) & 0x80008000) != 0 ||
((MinMaxWire.Max[5] - myLEMinMax->Min[5]) & 0x80008000) != 0 ||
((myLEMinMax->Max[5] - MinMaxWire.Min[5]) & 0x80008000) != 0 ||
((MinMaxWire.Max[6] - myLEMinMax->Min[6]) & 0x80008000) != 0 ||
((myLEMinMax->Max[6] - MinMaxWire.Min[6]) & 0x80008000) != 0 ||
((MinMaxWire.Max[7] - myLEMinMax->Min[7]) & 0x80008000) != 0) { //-- Rejection en Z
myFaceItr1.SkipWire();
continue;
}
@ -1218,7 +1083,7 @@ void HLRBRep_Data::NextInterference ()
// Edge from the boundary
if (!((HLRBRep_EdgeData*)myFEData)->Vertical() && !(myFEDouble && !myFEOutLine)) {
// not a vertical edge and not a double Edge
Standard_Address MinMaxFEdg = ((HLRBRep_EdgeData*)myFEData)->MinMax();
HLRAlgo_EdgesBlock::MinMaxIndices* MinMaxFEdg = &((HLRBRep_EdgeData*)myFEData)->MinMax();
//-- -----------------------------------------------------------------------
//-- Max - Min doit etre positif pour toutes les directions
//--
@ -1236,21 +1101,21 @@ void HLRBRep_Data::NextInterference ()
NoIntersection(myLE,myFE) == Standard_False) {
if (((MaxFEdg1 - MinLEdg1) & 0x80008000) == 0 &&
((MaxLEdg1 - MinFEdg1) & 0x80008000) == 0 &&
((MaxFEdg2 - MinLEdg2) & 0x80008000) == 0 &&
((MaxLEdg2 - MinFEdg2) & 0x80008000) == 0 &&
((MaxFEdg3 - MinLEdg3) & 0x80008000) == 0 &&
((MaxLEdg3 - MinFEdg3) & 0x80008000) == 0 &&
((MaxFEdg4 - MinLEdg4) & 0x80008000) == 0 &&
((MaxLEdg4 - MinFEdg4) & 0x80008000) == 0 &&
((MaxFEdg5 - MinLEdg5) & 0x80008000) == 0 &&
((MaxLEdg5 - MinFEdg5) & 0x80008000) == 0 &&
((MaxFEdg6 - MinLEdg6) & 0x80008000) == 0 &&
((MaxLEdg6 - MinFEdg6) & 0x80008000) == 0 &&
((MaxFEdg7 - MinLEdg7) & 0x80008000) == 0 &&
((MaxLEdg7 - MinFEdg7) & 0x80008000) == 0 &&
((MaxFEdg8 - MinLEdg8) & 0x80008000) == 0) { //-- Rejection en Z
if (((MinMaxFEdg->Max[0] - myLEMinMax->Min[0]) & 0x80008000) == 0 &&
((myLEMinMax->Max[0] - MinMaxFEdg->Min[0]) & 0x80008000) == 0 &&
((MinMaxFEdg->Max[1] - myLEMinMax->Min[1]) & 0x80008000) == 0 &&
((myLEMinMax->Max[1] - MinMaxFEdg->Min[1]) & 0x80008000) == 0 &&
((MinMaxFEdg->Max[2] - myLEMinMax->Min[2]) & 0x80008000) == 0 &&
((myLEMinMax->Max[2] - MinMaxFEdg->Min[2]) & 0x80008000) == 0 &&
((MinMaxFEdg->Max[3] - myLEMinMax->Min[3]) & 0x80008000) == 0 &&
((myLEMinMax->Max[3] - MinMaxFEdg->Min[3]) & 0x80008000) == 0 &&
((MinMaxFEdg->Max[4] - myLEMinMax->Min[4]) & 0x80008000) == 0 &&
((myLEMinMax->Max[4] - MinMaxFEdg->Min[4]) & 0x80008000) == 0 &&
((MinMaxFEdg->Max[5] - myLEMinMax->Min[5]) & 0x80008000) == 0 &&
((myLEMinMax->Max[5] - MinMaxFEdg->Min[5]) & 0x80008000) == 0 &&
((MinMaxFEdg->Max[6] - myLEMinMax->Min[6]) & 0x80008000) == 0 &&
((myLEMinMax->Max[6] - MinMaxFEdg->Min[6]) & 0x80008000) == 0 &&
((MinMaxFEdg->Max[7] - myLEMinMax->Min[7]) & 0x80008000) == 0) { //-- Rejection en Z
// not rejected perform intersection
Standard_Boolean rej = Standard_False;
if (myLE == myFE) { // test if an auto-intersection is not usefull
@ -1465,7 +1330,8 @@ void HLRBRep_Data::LocalFEGeometry2D (const Standard_Integer FE,
gp_Dir2d& Nm,
Standard_Real& Cu)
{
myFLProps.SetCurve(&(myEData(FE).ChangeGeometry()));
const HLRBRep_Curve* aCurve = &myEData(FE).ChangeGeometry();
myFLProps.SetCurve(aCurve);
myFLProps.SetParameter(Param);
if (!myFLProps.IsTangentDefined())
Standard_Failure::Raise("HLRBRep_Data::LocalGeometry2D");
@ -1794,40 +1660,52 @@ void HLRBRep_Data::OrientOthEdge (const Standard_Integer I,
//function : Classify
//purpose :
//=======================================================================
namespace
{
#define REJECT1 \
VertMin[ 0] = (Standard_Integer)((myDeca[ 0]+TotMin[ 0])*mySurD[ 0]); \
VertMax[ 0] = (Standard_Integer)((myDeca[ 0]+TotMax[ 0])*mySurD[ 0]); \
VertMin[ 1] = (Standard_Integer)((myDeca[ 1]+TotMin[ 1])*mySurD[ 1]); \
VertMax[ 1] = (Standard_Integer)((myDeca[ 1]+TotMax[ 1])*mySurD[ 1]); \
VertMin[ 2] = (Standard_Integer)((myDeca[ 2]+TotMin[ 2])*mySurD[ 2]); \
VertMax[ 2] = (Standard_Integer)((myDeca[ 2]+TotMax[ 2])*mySurD[ 2]); \
VertMin[ 3] = (Standard_Integer)((myDeca[ 3]+TotMin[ 3])*mySurD[ 3]); \
VertMax[ 3] = (Standard_Integer)((myDeca[ 3]+TotMax[ 3])*mySurD[ 3]); \
VertMin[ 4] = (Standard_Integer)((myDeca[ 4]+TotMin[ 4])*mySurD[ 4]); \
VertMax[ 4] = (Standard_Integer)((myDeca[ 4]+TotMax[ 4])*mySurD[ 4]); \
VertMin[ 5] = (Standard_Integer)((myDeca[ 5]+TotMin[ 5])*mySurD[ 5]); \
VertMax[ 5] = (Standard_Integer)((myDeca[ 5]+TotMax[ 5])*mySurD[ 5]); \
VertMin[ 6] = (Standard_Integer)((myDeca[ 6]+TotMin[ 6])*mySurD[ 6]); \
VertMax[ 6] = (Standard_Integer)((myDeca[ 6]+TotMax[ 6])*mySurD[ 6]); \
VertMin[ 7] = (Standard_Integer)((myDeca[ 7]+TotMin[ 7])*mySurD[ 7]); \
VertMax[ 7] = (Standard_Integer)((myDeca[ 7]+TotMax[ 7])*mySurD[ 7]); \
VertMin[ 8] = (Standard_Integer)((myDeca[ 8]+TotMin[ 8])*mySurD[ 8]); \
VertMax[ 8] = (Standard_Integer)((myDeca[ 8]+TotMax[ 8])*mySurD[ 8]); \
VertMin[ 9] = (Standard_Integer)((myDeca[ 9]+TotMin[ 9])*mySurD[ 9]); \
VertMax[ 9] = (Standard_Integer)((myDeca[ 9]+TotMax[ 9])*mySurD[ 9]); \
VertMin[10] = (Standard_Integer)((myDeca[10]+TotMin[10])*mySurD[10]); \
VertMax[10] = (Standard_Integer)((myDeca[10]+TotMax[10])*mySurD[10]); \
VertMin[11] = (Standard_Integer)((myDeca[11]+TotMin[11])*mySurD[11]); \
VertMax[11] = (Standard_Integer)((myDeca[11]+TotMax[11])*mySurD[11]); \
VertMin[12] = (Standard_Integer)((myDeca[12]+TotMin[12])*mySurD[12]); \
VertMax[12] = (Standard_Integer)((myDeca[12]+TotMax[12])*mySurD[12]); \
VertMin[13] = (Standard_Integer)((myDeca[13]+TotMin[13])*mySurD[13]); \
VertMax[13] = (Standard_Integer)((myDeca[13]+TotMax[13])*mySurD[13]); \
VertMin[14] = (Standard_Integer)((myDeca[14]+TotMin[14])*mySurD[14]); \
VertMax[14] = (Standard_Integer)((myDeca[14]+TotMax[14])*mySurD[14]); \
VertMin[15] = (Standard_Integer)((myDeca[15]+TotMin[15])*mySurD[15]); \
VertMax[15] = (Standard_Integer)((myDeca[15]+TotMax[15])*mySurD[15]);
static void REJECT1(
const Standard_Real theDeca[],
const Standard_Real theTotMin[],
const Standard_Real theTotMax[],
const Standard_Real theSurD[],
HLRAlgo_EdgesBlock::MinMaxIndices& theVertMin,
HLRAlgo_EdgesBlock::MinMaxIndices& theVertMax)
{
theVertMin.Min[0] = (Standard_Integer)((theDeca[ 0]+theTotMin[ 0]) * theSurD[ 0]);
theVertMax.Min[0] = (Standard_Integer)((theDeca[ 0]+theTotMax[ 0]) * theSurD[ 0]);
theVertMin.Min[1] = (Standard_Integer)((theDeca[ 1]+theTotMin[ 1]) * theSurD[ 1]);
theVertMax.Min[1] = (Standard_Integer)((theDeca[ 1]+theTotMax[ 1]) * theSurD[ 1]);
theVertMin.Min[2] = (Standard_Integer)((theDeca[ 2]+theTotMin[ 2]) * theSurD[ 2]);
theVertMax.Min[2] = (Standard_Integer)((theDeca[ 2]+theTotMax[ 2]) * theSurD[ 2]);
theVertMin.Min[3] = (Standard_Integer)((theDeca[ 3]+theTotMin[ 3]) * theSurD[ 3]);
theVertMax.Min[3] = (Standard_Integer)((theDeca[ 3]+theTotMax[ 3]) * theSurD[ 3]);
theVertMin.Min[4] = (Standard_Integer)((theDeca[ 4]+theTotMin[ 4]) * theSurD[ 4]);
theVertMax.Min[4] = (Standard_Integer)((theDeca[ 4]+theTotMax[ 4]) * theSurD[ 4]);
theVertMin.Min[5] = (Standard_Integer)((theDeca[ 5]+theTotMin[ 5]) * theSurD[ 5]);
theVertMax.Min[5] = (Standard_Integer)((theDeca[ 5]+theTotMax[ 5]) * theSurD[ 5]);
theVertMin.Min[6] = (Standard_Integer)((theDeca[ 6]+theTotMin[ 6]) * theSurD[ 6]);
theVertMax.Min[6] = (Standard_Integer)((theDeca[ 6]+theTotMax[ 6]) * theSurD[ 6]);
theVertMin.Min[7] = (Standard_Integer)((theDeca[ 7]+theTotMin[ 7]) * theSurD[ 7]);
theVertMax.Min[7] = (Standard_Integer)((theDeca[ 7]+theTotMax[ 7]) * theSurD[ 7]);
theVertMin.Max[0] = (Standard_Integer)((theDeca[ 8]+theTotMin[ 8]) * theSurD[ 8]);
theVertMax.Max[0] = (Standard_Integer)((theDeca[ 8]+theTotMax[ 8]) * theSurD[ 8]);
theVertMin.Max[1] = (Standard_Integer)((theDeca[ 9]+theTotMin[ 9]) * theSurD[ 9]);
theVertMax.Max[1] = (Standard_Integer)((theDeca[ 9]+theTotMax[ 9]) * theSurD[ 9]);
theVertMin.Max[2] = (Standard_Integer)((theDeca[10]+theTotMin[10]) * theSurD[10]);
theVertMax.Max[2] = (Standard_Integer)((theDeca[10]+theTotMax[10]) * theSurD[10]);
theVertMin.Max[3] = (Standard_Integer)((theDeca[11]+theTotMin[11]) * theSurD[11]);
theVertMax.Max[3] = (Standard_Integer)((theDeca[11]+theTotMax[11]) * theSurD[11]);
theVertMin.Max[4] = (Standard_Integer)((theDeca[12]+theTotMin[12]) * theSurD[12]);
theVertMax.Max[4] = (Standard_Integer)((theDeca[12]+theTotMax[12]) * theSurD[12]);
theVertMin.Max[5] = (Standard_Integer)((theDeca[13]+theTotMin[13]) * theSurD[13]);
theVertMax.Max[5] = (Standard_Integer)((theDeca[13]+theTotMax[13]) * theSurD[13]);
theVertMin.Max[6] = (Standard_Integer)((theDeca[14]+theTotMin[14]) * theSurD[14]);
theVertMax.Max[6] = (Standard_Integer)((theDeca[14]+theTotMax[14]) * theSurD[14]);
theVertMin.Max[7] = (Standard_Integer)((theDeca[15]+theTotMin[15]) * theSurD[15]);
theVertMax.Max[7] = (Standard_Integer)((theDeca[15]+theTotMax[15]) * theSurD[15]);
}
}
TopAbs_State
HLRBRep_Data::Classify (const Standard_Integer E,
@ -1839,7 +1717,7 @@ HLRBRep_Data::Classify (const Standard_Integer E,
(void)E; // avoid compiler warning
nbClassification++;
Standard_Integer VertMin[16],VertMax[16],MinMaxVert[16];
HLRAlgo_EdgesBlock::MinMaxIndices VertMin, VertMax, MinMaxVert;
Standard_Real TotMin[16],TotMax[16];
Standard_Integer i;
@ -1856,35 +1734,27 @@ HLRBRep_Data::Classify (const Standard_Integer E,
//-- les rejections sont faites dans l intersecteur a moindre frais
//-- puisque la surface sera chargee
HLRAlgo::InitMinMax(Precision::Infinite(),
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::EnlargeMinMax(tol,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
REJECT1;
HLRAlgo::InitMinMax(Precision::Infinite(), TotMin, TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta, TotMin, TotMax);
HLRAlgo::EnlargeMinMax(tol, TotMin, TotMax);
REJECT1(myDeca, TotMin, TotMax, mySurD, VertMin, VertMax);
HLRAlgo::EncodeMinMax((Standard_Address)VertMin,
(Standard_Address)VertMax,
(Standard_Address)MinMaxVert);
if (((MaxFace1 - MinVert1) & 0x80008000) != 0 ||
((MaxVert1 - MinFace1) & 0x80008000) != 0 ||
((MaxFace2 - MinVert2) & 0x80008000) != 0 ||
((MaxVert2 - MinFace2) & 0x80008000) != 0 ||
((MaxFace3 - MinVert3) & 0x80008000) != 0 ||
((MaxVert3 - MinFace3) & 0x80008000) != 0 ||
((MaxFace4 - MinVert4) & 0x80008000) != 0 ||
((MaxVert4 - MinFace4) & 0x80008000) != 0 ||
((MaxFace5 - MinVert5) & 0x80008000) != 0 ||
((MaxVert5 - MinFace5) & 0x80008000) != 0 ||
((MaxFace6 - MinVert6) & 0x80008000) != 0 ||
((MaxVert6 - MinFace6) & 0x80008000) != 0 ||
((MaxFace7 - MinVert7) & 0x80008000) != 0 ||
((MaxVert7 - MinFace7) & 0x80008000) != 0 ||
((MaxFace8 - MinVert8) & 0x80008000) != 0) { //-- Rejection en Z
HLRAlgo::EncodeMinMax(VertMin, VertMax, MinMaxVert);
if (((iFaceMinMax->Max[0] - MinMaxVert.Min[0]) & 0x80008000) != 0 ||
((MinMaxVert.Max[0] - iFaceMinMax->Min[0]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[1] - MinMaxVert.Min[1]) & 0x80008000) != 0 ||
((MinMaxVert.Max[1] - iFaceMinMax->Min[1]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[2] - MinMaxVert.Min[2]) & 0x80008000) != 0 ||
((MinMaxVert.Max[2] - iFaceMinMax->Min[2]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[3] - MinMaxVert.Min[3]) & 0x80008000) != 0 ||
((MinMaxVert.Max[3] - iFaceMinMax->Min[3]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[4] - MinMaxVert.Min[4]) & 0x80008000) != 0 ||
((MinMaxVert.Max[4] - iFaceMinMax->Min[4]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[5] - MinMaxVert.Min[5]) & 0x80008000) != 0 ||
((MinMaxVert.Max[5] - iFaceMinMax->Min[5]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[6] - MinMaxVert.Min[6]) & 0x80008000) != 0 ||
((MinMaxVert.Max[6] - iFaceMinMax->Min[6]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[7] - MinMaxVert.Min[7]) & 0x80008000) != 0) { //-- Rejection en Z
return state;
}
}
@ -1894,71 +1764,55 @@ HLRBRep_Data::Classify (const Standard_Integer E,
//-- les rejections sont faites dans l intersecteur a moindre frais
//-- puisque la surface sera chargee
HLRAlgo::InitMinMax(Precision::Infinite(),
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::EnlargeMinMax(tol,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::InitMinMax(Precision::Infinite(), TotMin, TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta, TotMin, TotMax);
HLRAlgo::EnlargeMinMax(tol, TotMin, TotMax);
REJECT1;
REJECT1(myDeca, TotMin, TotMax, mySurD, VertMin, VertMax);
HLRAlgo::EncodeMinMax((Standard_Address)VertMin,
(Standard_Address)VertMax,
(Standard_Address)MinMaxVert);
if (((MaxFace1 - MinVert1) & 0x80008000) != 0 ||
((MaxVert1 - MinFace1) & 0x80008000) != 0 ||
((MaxFace2 - MinVert2) & 0x80008000) != 0 ||
((MaxVert2 - MinFace2) & 0x80008000) != 0 ||
((MaxFace3 - MinVert3) & 0x80008000) != 0 ||
((MaxVert3 - MinFace3) & 0x80008000) != 0 ||
((MaxFace4 - MinVert4) & 0x80008000) != 0 ||
((MaxVert4 - MinFace4) & 0x80008000) != 0 ||
((MaxFace5 - MinVert5) & 0x80008000) != 0 ||
((MaxVert5 - MinFace5) & 0x80008000) != 0 ||
((MaxFace6 - MinVert6) & 0x80008000) != 0 ||
((MaxVert6 - MinFace6) & 0x80008000) != 0 ||
((MaxFace7 - MinVert7) & 0x80008000) != 0 ||
((MaxVert7 - MinFace7) & 0x80008000) != 0 ||
((MaxFace8 - MinVert8) & 0x80008000) != 0) { //-- Rejection en Z
HLRAlgo::EncodeMinMax(VertMin, VertMax, MinMaxVert);
if (((iFaceMinMax->Max[0] - MinMaxVert.Min[0]) & 0x80008000) != 0 ||
((MinMaxVert.Max[0] - iFaceMinMax->Min[0]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[1] - MinMaxVert.Min[1]) & 0x80008000) != 0 ||
((MinMaxVert.Max[1] - iFaceMinMax->Min[1]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[2] - MinMaxVert.Min[2]) & 0x80008000) != 0 ||
((MinMaxVert.Max[2] - iFaceMinMax->Min[2]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[3] - MinMaxVert.Min[3]) & 0x80008000) != 0 ||
((MinMaxVert.Max[3] - iFaceMinMax->Min[3]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[4] - MinMaxVert.Min[4]) & 0x80008000) != 0 ||
((MinMaxVert.Max[4] - iFaceMinMax->Min[4]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[5] - MinMaxVert.Min[5]) & 0x80008000) != 0 ||
((MinMaxVert.Max[5] - iFaceMinMax->Min[5]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[6] - MinMaxVert.Min[6]) & 0x80008000) != 0 ||
((MinMaxVert.Max[6] - iFaceMinMax->Min[6]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[7] - MinMaxVert.Min[7]) & 0x80008000) != 0) { //-- Rejection en Z
return state;
}
end = EC.Parameter3d(EC.LastParameter());
myProj.Project(EC.Value3D(end),xend,yend,zend);
HLRAlgo::InitMinMax(Precision::Infinite(),
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::UpdateMinMax(xend,yend,zend,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::EnlargeMinMax(tol,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::InitMinMax(Precision::Infinite(), TotMin, TotMax);
HLRAlgo::UpdateMinMax(xend,yend,zend, TotMin, TotMax);
HLRAlgo::EnlargeMinMax(tol, TotMin, TotMax);
REJECT1;
REJECT1(myDeca, TotMin, TotMax, mySurD, VertMin, VertMax);
HLRAlgo::EncodeMinMax((Standard_Address)VertMin,
(Standard_Address)VertMax,
(Standard_Address)MinMaxVert);
if (((MaxFace1 - MinVert1) & 0x80008000) != 0 ||
((MaxVert1 - MinFace1) & 0x80008000) != 0 ||
((MaxFace2 - MinVert2) & 0x80008000) != 0 ||
((MaxVert2 - MinFace2) & 0x80008000) != 0 ||
((MaxFace3 - MinVert3) & 0x80008000) != 0 ||
((MaxVert3 - MinFace3) & 0x80008000) != 0 ||
((MaxFace4 - MinVert4) & 0x80008000) != 0 ||
((MaxVert4 - MinFace4) & 0x80008000) != 0 ||
((MaxFace5 - MinVert5) & 0x80008000) != 0 ||
((MaxVert5 - MinFace5) & 0x80008000) != 0 ||
((MaxFace6 - MinVert6) & 0x80008000) != 0 ||
((MaxVert6 - MinFace6) & 0x80008000) != 0 ||
((MaxFace7 - MinVert7) & 0x80008000) != 0 ||
((MaxVert7 - MinFace7) & 0x80008000) != 0 ||
((MaxFace8 - MinVert8) & 0x80008000) != 0) { //-- Rejection en Z
HLRAlgo::EncodeMinMax(VertMin, VertMax, MinMaxVert);
if (((iFaceMinMax->Max[0] - MinMaxVert.Min[0]) & 0x80008000) != 0 ||
((MinMaxVert.Max[0] - iFaceMinMax->Min[0]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[1] - MinMaxVert.Min[1]) & 0x80008000) != 0 ||
((MinMaxVert.Max[1] - iFaceMinMax->Min[1]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[2] - MinMaxVert.Min[2]) & 0x80008000) != 0 ||
((MinMaxVert.Max[2] - iFaceMinMax->Min[2]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[3] - MinMaxVert.Min[3]) & 0x80008000) != 0 ||
((MinMaxVert.Max[3] - iFaceMinMax->Min[3]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[4] - MinMaxVert.Min[4]) & 0x80008000) != 0 ||
((MinMaxVert.Max[4] - iFaceMinMax->Min[4]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[5] - MinMaxVert.Min[5]) & 0x80008000) != 0 ||
((MinMaxVert.Max[5] - iFaceMinMax->Min[5]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[6] - MinMaxVert.Min[6]) & 0x80008000) != 0 ||
((MinMaxVert.Max[6] - iFaceMinMax->Min[6]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[7] - MinMaxVert.Min[7]) & 0x80008000) != 0) { //-- Rejection en Z
return state;
}
sta = 0.4 * sta + 0.6 * end; // dangerous if it is the middle
@ -1966,20 +1820,12 @@ HLRBRep_Data::Classify (const Standard_Integer E,
//-- les rejections sont faites dans l intersecteur a moindre frais
//-- puisque la surface sera chargee
HLRAlgo::InitMinMax(Precision::Infinite(),
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::EnlargeMinMax(tol,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
REJECT1;
HLRAlgo::InitMinMax(Precision::Infinite(), TotMin, TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta, TotMin, TotMax);
HLRAlgo::EnlargeMinMax(tol, TotMin, TotMax);
REJECT1(myDeca, TotMin, TotMax, mySurD, VertMin, VertMax);
HLRAlgo::EncodeMinMax((Standard_Address)VertMin,
(Standard_Address)VertMax,
(Standard_Address)MinMaxVert);
HLRAlgo::EncodeMinMax(VertMin, VertMax, MinMaxVert);
/*
#ifdef OCCT_DEBUG
{
@ -2022,21 +1868,21 @@ HLRBRep_Data::Classify (const Standard_Integer E,
#endif
*/
if (((MaxFace1 - MinVert1) & 0x80008000) != 0 ||
((MaxVert1 - MinFace1) & 0x80008000) != 0 ||
((MaxFace2 - MinVert2) & 0x80008000) != 0 ||
((MaxVert2 - MinFace2) & 0x80008000) != 0 ||
((MaxFace3 - MinVert3) & 0x80008000) != 0 ||
((MaxVert3 - MinFace3) & 0x80008000) != 0 ||
((MaxFace4 - MinVert4) & 0x80008000) != 0 ||
((MaxVert4 - MinFace4) & 0x80008000) != 0 ||
((MaxFace5 - MinVert5) & 0x80008000) != 0 ||
((MaxVert5 - MinFace5) & 0x80008000) != 0 ||
((MaxFace6 - MinVert6) & 0x80008000) != 0 ||
((MaxVert6 - MinFace6) & 0x80008000) != 0 ||
((MaxFace7 - MinVert7) & 0x80008000) != 0 ||
((MaxVert7 - MinFace7) & 0x80008000) != 0 ||
((MaxFace8 - MinVert8) & 0x80008000) != 0) { //-- Rejection en Z
if (((iFaceMinMax->Max[0] - MinMaxVert.Min[0]) & 0x80008000) != 0 ||
((MinMaxVert.Max[0] - iFaceMinMax->Min[0]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[1] - MinMaxVert.Min[1]) & 0x80008000) != 0 ||
((MinMaxVert.Max[1] - iFaceMinMax->Min[1]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[2] - MinMaxVert.Min[2]) & 0x80008000) != 0 ||
((MinMaxVert.Max[2] - iFaceMinMax->Min[2]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[3] - MinMaxVert.Min[3]) & 0x80008000) != 0 ||
((MinMaxVert.Max[3] - iFaceMinMax->Min[3]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[4] - MinMaxVert.Min[4]) & 0x80008000) != 0 ||
((MinMaxVert.Max[4] - iFaceMinMax->Min[4]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[5] - MinMaxVert.Min[5]) & 0x80008000) != 0 ||
((MinMaxVert.Max[5] - iFaceMinMax->Min[5]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[6] - MinMaxVert.Min[6]) & 0x80008000) != 0 ||
((MinMaxVert.Max[6] - iFaceMinMax->Min[6]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[7] - MinMaxVert.Min[7]) & 0x80008000) != 0) { //-- Rejection en Z
return state;
}
}
@ -2124,7 +1970,7 @@ TopAbs_State HLRBRep_Data::SimplClassify (const Standard_Integer /*E*/,
const Standard_Real p2)
{
nbClassification++;
Standard_Integer VertMin[16],VertMax[16],MinMaxVert[16];
HLRAlgo_EdgesBlock::MinMaxIndices VertMin, VertMax, MinMaxVert;
Standard_Real TotMin[16],TotMax[16];
Standard_Integer i;
@ -2141,35 +1987,27 @@ TopAbs_State HLRBRep_Data::SimplClassify (const Standard_Integer /*E*/,
//-- les rejections sont faites dans l intersecteur a moindre frais
//-- puisque la surface sera chargee
HLRAlgo::InitMinMax(Precision::Infinite(),
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
HLRAlgo::EnlargeMinMax(tol,
(Standard_Address)TotMin,
(Standard_Address)TotMax);
REJECT1;
HLRAlgo::InitMinMax(Precision::Infinite(), TotMin, TotMax);
HLRAlgo::UpdateMinMax(xsta,ysta,zsta, TotMin, TotMax);
HLRAlgo::EnlargeMinMax(tol, TotMin, TotMax);
REJECT1(myDeca, TotMin, TotMax, mySurD, VertMin, VertMax);
HLRAlgo::EncodeMinMax((Standard_Address)VertMin,
(Standard_Address)VertMax,
(Standard_Address)MinMaxVert);
if (((MaxFace1 - MinVert1) & 0x80008000) != 0 ||
((MaxVert1 - MinFace1) & 0x80008000) != 0 ||
((MaxFace2 - MinVert2) & 0x80008000) != 0 ||
((MaxVert2 - MinFace2) & 0x80008000) != 0 ||
((MaxFace3 - MinVert3) & 0x80008000) != 0 ||
((MaxVert3 - MinFace3) & 0x80008000) != 0 ||
((MaxFace4 - MinVert4) & 0x80008000) != 0 ||
((MaxVert4 - MinFace4) & 0x80008000) != 0 ||
((MaxFace5 - MinVert5) & 0x80008000) != 0 ||
((MaxVert5 - MinFace5) & 0x80008000) != 0 ||
((MaxFace6 - MinVert6) & 0x80008000) != 0 ||
((MaxVert6 - MinFace6) & 0x80008000) != 0 ||
((MaxFace7 - MinVert7) & 0x80008000) != 0 ||
((MaxVert7 - MinFace7) & 0x80008000) != 0 ||
((MaxFace8 - MinVert8) & 0x80008000) != 0) { //-- Rejection en Z
HLRAlgo::EncodeMinMax(VertMin, VertMax, MinMaxVert);
if (((iFaceMinMax->Max[0] - MinMaxVert.Min[0]) & 0x80008000) != 0 ||
((MinMaxVert.Max[0] - iFaceMinMax->Min[0]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[1] - MinMaxVert.Min[1]) & 0x80008000) != 0 ||
((MinMaxVert.Max[1] - iFaceMinMax->Min[1]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[2] - MinMaxVert.Min[2]) & 0x80008000) != 0 ||
((MinMaxVert.Max[2] - iFaceMinMax->Min[2]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[3] - MinMaxVert.Min[3]) & 0x80008000) != 0 ||
((MinMaxVert.Max[3] - iFaceMinMax->Min[3]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[4] - MinMaxVert.Min[4]) & 0x80008000) != 0 ||
((MinMaxVert.Max[4] - iFaceMinMax->Min[4]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[5] - MinMaxVert.Min[5]) & 0x80008000) != 0 ||
((MinMaxVert.Max[5] - iFaceMinMax->Min[5]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[6] - MinMaxVert.Min[6]) & 0x80008000) != 0 ||
((MinMaxVert.Max[6] - iFaceMinMax->Min[6]) & 0x80008000) != 0 ||
((iFaceMinMax->Max[7] - MinMaxVert.Min[7]) & 0x80008000) != 0) { //-- Rejection en Z
return TopAbs_OUT;
}
}

19
src/HLRBRep/HLRBRep_Data.hxx
View File

@ -50,6 +50,7 @@ class gp_Dir2d;
class HLRBRep_EdgeData;
class HLRBRep_FaceData;
class IntRes2d_IntersectionPoint;
class TableauRejection;
class HLRBRep_Data;
@ -99,7 +100,7 @@ public:
TopTools_IndexedMapOfShape& FaceMap();
//! to compare with only non rejected edges.
Standard_EXPORT void InitBoundSort (const Standard_Address MinMaxTot, const Standard_Integer e1, const Standard_Integer e2);
Standard_EXPORT void InitBoundSort (const HLRAlgo_EdgesBlock::MinMaxIndices& MinMaxTot, const Standard_Integer e1, const Standard_Integer e2);
//! Begin an iteration only on visible Edges
//! crossing the face number <FI>.
@ -228,9 +229,9 @@ private:
HLRBRep_FaceIterator myFaceItr1;
HLRBRep_FaceIterator myFaceItr2;
Standard_Integer iFace;
Standard_Address iFaceData;
HLRBRep_FaceData* iFaceData;
Standard_Address iFaceGeom;
Standard_Address iFaceMinMax;
HLRAlgo_EdgesBlock::MinMaxIndices* iFaceMinMax;
GeomAbs_SurfaceType iFaceType;
Standard_Boolean iFaceBack;
Standard_Boolean iFaceSimp;
@ -246,9 +247,9 @@ private:
Standard_Boolean myLEInternal;
Standard_Boolean myLEDouble;
Standard_Boolean myLEIsoLine;
Standard_Address myLEData;
Standard_Address myLEGeom;
Standard_Address myLEMinMax;
HLRBRep_EdgeData* myLEData;
const HLRBRep_Curve* myLEGeom;
HLRAlgo_EdgesBlock::MinMaxIndices* myLEMinMax;
GeomAbs_CurveType myLEType;
Standard_ShortReal myLETol;
Standard_Integer myFE;
@ -256,8 +257,8 @@ private:
Standard_Boolean myFEOutLine;
Standard_Boolean myFEInternal;
Standard_Boolean myFEDouble;
Standard_Address myFEData;
Standard_Address myFEGeom;
HLRBRep_EdgeData* myFEData;
HLRBRep_Curve* myFEGeom;
GeomAbs_CurveType myFEType;
Standard_ShortReal myFETol;
HLRBRep_Intersector myIntersector;
@ -269,7 +270,7 @@ private:
Standard_Integer iInterf;
HLRAlgo_Interference myIntf;
Standard_Boolean myAboveIntf;
Standard_Address myReject;
TableauRejection* myReject;
};

34
src/HLRBRep/HLRBRep_EdgeData.cxx
View File

@ -21,15 +21,6 @@
#include <HLRBRep_EdgeData.hxx>
#include <TopoDS_Edge.hxx>
//=======================================================================
//function : EdgeData
//purpose :
//=======================================================================
HLRBRep_EdgeData::HLRBRep_EdgeData () :
myFlags(0),
myHideCount(0)
{ Selected(Standard_True); }
//=======================================================================
//function : Set
//purpose :
@ -66,28 +57,3 @@ void HLRBRep_EdgeData::Set (const Standard_Boolean Rg1L,
End ,(Standard_ShortReal)(ChangeGeometry().Curve().Resolution
((Standard_Real)TolEnd )));
}
//=======================================================================
//function : UpdateMinMax
//purpose :
//=======================================================================
void HLRBRep_EdgeData::UpdateMinMax (const Standard_Address TotMinMax)
{
myMinMax[ 0] = ((Standard_Integer*)TotMinMax)[ 0];
myMinMax[ 1] = ((Standard_Integer*)TotMinMax)[ 1];
myMinMax[ 2] = ((Standard_Integer*)TotMinMax)[ 2];
myMinMax[ 3] = ((Standard_Integer*)TotMinMax)[ 3];
myMinMax[ 4] = ((Standard_Integer*)TotMinMax)[ 4];
myMinMax[ 5] = ((Standard_Integer*)TotMinMax)[ 5];
myMinMax[ 6] = ((Standard_Integer*)TotMinMax)[ 6];
myMinMax[ 7] = ((Standard_Integer*)TotMinMax)[ 7];
myMinMax[ 8] = ((Standard_Integer*)TotMinMax)[ 8];
myMinMax[ 9] = ((Standard_Integer*)TotMinMax)[ 9];
myMinMax[10] = ((Standard_Integer*)TotMinMax)[10];
myMinMax[11] = ((Standard_Integer*)TotMinMax)[11];
myMinMax[12] = ((Standard_Integer*)TotMinMax)[12];
myMinMax[13] = ((Standard_Integer*)TotMinMax)[13];
myMinMax[14] = ((Standard_Integer*)TotMinMax)[14];
myMinMax[15] = ((Standard_Integer*)TotMinMax)[15];
}

32
src/HLRBRep/HLRBRep_EdgeData.hxx
View File

@ -17,6 +17,8 @@
#ifndef _HLRBRep_EdgeData_HeaderFile
#define _HLRBRep_EdgeData_HeaderFile
#include <HLRAlgo_WiresBlock.hxx>
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
@ -27,7 +29,6 @@
#include <HLRBRep_Curve.hxx>
#include <Standard_ShortReal.hxx>
#include <Standard_Real.hxx>
#include <Standard_Address.hxx>
class TopoDS_Edge;
class HLRAlgo_EdgeStatus;
class HLRBRep_Curve;
@ -40,9 +41,13 @@ public:
DEFINE_STANDARD_ALLOC
Standard_EXPORT HLRBRep_EdgeData();
HLRBRep_EdgeData() :
myFlags(0),
myHideCount(0)
{
Selected(Standard_True);
}
Standard_EXPORT void Set (const Standard_Boolean Reg1, const Standard_Boolean RegN, const TopoDS_Edge& EG, const Standard_Integer V1, const Standard_Integer V2, const Standard_Boolean Out1, const Standard_Boolean Out2, const Standard_Boolean Cut1, const Standard_Boolean Cut2, const Standard_Real Start, const Standard_ShortReal TolStart, const Standard_Real End, const Standard_ShortReal TolEnd);
Standard_Boolean Selected() const;
@ -109,9 +114,15 @@ public:
void VEnd (const Standard_Integer I);
Standard_EXPORT void UpdateMinMax (const Standard_Address TotMinMax);
void UpdateMinMax (const HLRAlgo_EdgesBlock::MinMaxIndices& theTotMinMax)
{
myMinMax = theTotMinMax;
}
Standard_Address MinMax() const;
HLRAlgo_EdgesBlock::MinMaxIndices& MinMax()
{
return myMinMax;
}
HLRAlgo_EdgeStatus& Status();
@ -119,8 +130,11 @@ public:
const HLRBRep_Curve& Geometry() const;
Standard_Address Curve();
HLRBRep_Curve* Curve()
{
return &myGeometry;
}
Standard_ShortReal Tolerance() const;
protected:
@ -148,7 +162,7 @@ private:
Standard_Integer myHideCount;
Standard_Integer myVSta;
Standard_Integer myVEnd;
Standard_Integer myMinMax[16];
HLRAlgo_EdgesBlock::MinMaxIndices myMinMax;
HLRAlgo_EdgeStatus myStatus;
HLRBRep_Curve myGeometry;
Standard_ShortReal myTolerance;

16
src/HLRBRep/HLRBRep_EdgeData.lxx
View File

@ -310,14 +310,6 @@ inline Standard_Integer HLRBRep_EdgeData::VEnd () const
inline void HLRBRep_EdgeData::VEnd (const Standard_Integer I)
{ myVEnd = I; }
//=======================================================================
//function : MinMax
//purpose :
//=======================================================================
inline Standard_Address HLRBRep_EdgeData::MinMax () const
{ return (Standard_Address)&myMinMax; }
//=======================================================================
//function : Status
//purpose :
@ -342,14 +334,6 @@ inline HLRBRep_Curve & HLRBRep_EdgeData::ChangeGeometry ()
inline const HLRBRep_Curve & HLRBRep_EdgeData::Geometry () const
{ return myGeometry; }
//=======================================================================
//function : Curve
//purpose :
//=======================================================================
inline Standard_Address HLRBRep_EdgeData::Curve ()
{ return ((Standard_Address)&myGeometry); }
//=======================================================================
//function : Tolerance
//purpose :

101
src/HLRBRep/HLRBRep_InternalAlgo.cxx
View File

@ -44,40 +44,6 @@ extern Standard_Integer nbCal3Intersection; // curve-surface intersections
static Standard_Integer TRACE = Standard_True;
static Standard_Integer TRACE10 = Standard_True;
#define MinShBI1 MinMaxShBI[ 0]
#define MinShBI2 MinMaxShBI[ 1]
#define MinShBI3 MinMaxShBI[ 2]
#define MinShBI4 MinMaxShBI[ 3]
#define MinShBI5 MinMaxShBI[ 4]
#define MinShBI6 MinMaxShBI[ 5]
#define MinShBI7 MinMaxShBI[ 6]
#define MinShBI8 MinMaxShBI[ 7]
#define MaxShBI1 MinMaxShBI[ 8]
#define MaxShBI2 MinMaxShBI[ 9]
#define MaxShBI3 MinMaxShBI[10]
#define MaxShBI4 MinMaxShBI[11]
#define MaxShBI5 MinMaxShBI[12]
#define MaxShBI6 MinMaxShBI[13]
#define MaxShBI7 MinMaxShBI[14]
#define MaxShBI8 MinMaxShBI[15]
#define MinShBJ1 MinMaxShBJ[ 0]
#define MinShBJ2 MinMaxShBJ[ 1]
#define MinShBJ3 MinMaxShBJ[ 2]
#define MinShBJ4 MinMaxShBJ[ 3]
#define MinShBJ5 MinMaxShBJ[ 4]
#define MinShBJ6 MinMaxShBJ[ 5]
#define MinShBJ7 MinMaxShBJ[ 6]
#define MinShBJ8 MinMaxShBJ[ 7]
#define MaxShBJ1 MinMaxShBJ[ 8]
#define MaxShBJ2 MinMaxShBJ[ 9]
#define MaxShBJ3 MinMaxShBJ[10]
#define MaxShBJ4 MinMaxShBJ[11]
#define MaxShBJ5 MinMaxShBJ[12]
#define MaxShBJ6 MinMaxShBJ[13]
#define MaxShBJ7 MinMaxShBJ[14]
#define MaxShBJ8 MinMaxShBJ[15]
//=======================================================================
//function : HLRBRep_InternalAlgo
//purpose :
@ -188,8 +154,8 @@ void HLRBRep_InternalAlgo::Update ()
myDS->Update(myProj);
Standard_Integer ShapMin[16],ShapMax[16],MinMaxShap[16];
Standard_Integer TheMin[16],TheMax[16];
HLRAlgo_EdgesBlock::MinMaxIndices ShapMin, ShapMax, MinMaxShap;
HLRAlgo_EdgesBlock::MinMaxIndices TheMin, TheMax;
HLRBRep_Array1OfEData& aEDataArray = myDS->EDataArray();
HLRBRep_Array1OfFData& aFDataArray = myDS->FDataArray();
@ -201,37 +167,22 @@ void HLRBRep_InternalAlgo::Update ()
for (Standard_Integer e = e1; e <= e2; e++) {
HLRBRep_EdgeData ed = aEDataArray.ChangeValue(e);
HLRAlgo::DecodeMinMax(ed.MinMax(),
(Standard_Address)TheMin,
(Standard_Address)TheMax);
HLRAlgo::DecodeMinMax(ed.MinMax(), TheMin, TheMax);
if (FirstTime) {
FirstTime = Standard_False;
HLRAlgo::CopyMinMax((Standard_Address)TheMin,
(Standard_Address)TheMax,
(Standard_Address)ShapMin,
(Standard_Address)ShapMax);
HLRAlgo::CopyMinMax(TheMin, TheMax, ShapMin, ShapMax);
}
else
HLRAlgo::AddMinMax((Standard_Address)TheMin,
(Standard_Address)TheMax,
(Standard_Address)ShapMin,
(Standard_Address)ShapMax);
HLRAlgo::AddMinMax(TheMin, TheMax, ShapMin, ShapMax);
}
for (Standard_Integer f = f1; f <= f2; f++) {
HLRBRep_FaceData& fd = aFDataArray.ChangeValue(f);
HLRAlgo::DecodeMinMax(fd.Wires()->MinMax(),
(Standard_Address)TheMin,
(Standard_Address)TheMax);
HLRAlgo::AddMinMax((Standard_Address)TheMin,
(Standard_Address)TheMax,
(Standard_Address)ShapMin,
(Standard_Address)ShapMax);
HLRAlgo::DecodeMinMax(fd.Wires()->MinMax(), TheMin, TheMax);
HLRAlgo::AddMinMax(TheMin, TheMax, ShapMin, ShapMax);
}
HLRAlgo::EncodeMinMax((Standard_Address)ShapMin,
(Standard_Address)ShapMax,
(Standard_Address)MinMaxShap);
SB.UpdateMinMax((Standard_Address)MinMaxShap);
HLRAlgo::EncodeMinMax(ShapMin, ShapMax, MinMaxShap);
SB.UpdateMinMax(MinMaxShap);
}
}
}
@ -676,24 +627,22 @@ void HLRBRep_InternalAlgo::Hide (const Standard_Integer I,
if (I == J) Hide(I);
else {
Standard_Integer* MinMaxShBI =
(Standard_Integer*)myShapes(I).MinMax();
Standard_Integer* MinMaxShBJ =
(Standard_Integer*)myShapes(J).MinMax();
if (((MaxShBJ1 - MinShBI1) & 0x80008000) == 0 &&
((MaxShBI1 - MinShBJ1) & 0x80008000) == 0 &&
((MaxShBJ2 - MinShBI2) & 0x80008000) == 0 &&
((MaxShBI2 - MinShBJ2) & 0x80008000) == 0 &&
((MaxShBJ3 - MinShBI3) & 0x80008000) == 0 &&
((MaxShBI3 - MinShBJ3) & 0x80008000) == 0 &&
((MaxShBJ4 - MinShBI4) & 0x80008000) == 0 &&
((MaxShBI4 - MinShBJ4) & 0x80008000) == 0 &&
((MaxShBJ5 - MinShBI5) & 0x80008000) == 0 &&
((MaxShBI5 - MinShBJ5) & 0x80008000) == 0 &&
((MaxShBJ6 - MinShBI6) & 0x80008000) == 0 &&
((MaxShBI6 - MinShBJ6) & 0x80008000) == 0 &&
((MaxShBJ7 - MinShBI7) & 0x80008000) == 0 &&
((MaxShBJ8 - MinShBI8) & 0x80008000) == 0) {
HLRAlgo_EdgesBlock::MinMaxIndices* MinMaxShBI = &myShapes(I).MinMax();
HLRAlgo_EdgesBlock::MinMaxIndices* MinMaxShBJ = &myShapes(J).MinMax();
if (((MinMaxShBJ->Max[0] - MinMaxShBI->Min[0]) & 0x80008000) == 0 &&
((MinMaxShBI->Max[0] - MinMaxShBJ->Min[0]) & 0x80008000) == 0 &&
((MinMaxShBJ->Max[1] - MinMaxShBI->Min[1]) & 0x80008000) == 0 &&
((MinMaxShBI->Max[1] - MinMaxShBJ->Min[1]) & 0x80008000) == 0 &&
((MinMaxShBJ->Max[2] - MinMaxShBI->Min[2]) & 0x80008000) == 0 &&
((MinMaxShBI->Max[2] - MinMaxShBJ->Min[2]) & 0x80008000) == 0 &&
((MinMaxShBJ->Max[3] - MinMaxShBI->Min[3]) & 0x80008000) == 0 &&
((MinMaxShBI->Max[3] - MinMaxShBJ->Min[3]) & 0x80008000) == 0 &&
((MinMaxShBJ->Max[4] - MinMaxShBI->Min[4]) & 0x80008000) == 0 &&
((MinMaxShBI->Max[4] - MinMaxShBJ->Min[4]) & 0x80008000) == 0 &&
((MinMaxShBJ->Max[5] - MinMaxShBI->Min[5]) & 0x80008000) == 0 &&
((MinMaxShBI->Max[5] - MinMaxShBJ->Min[5]) & 0x80008000) == 0 &&
((MinMaxShBJ->Max[6] - MinMaxShBI->Min[6]) & 0x80008000) == 0 &&
((MinMaxShBJ->Max[7] - MinMaxShBI->Min[7]) & 0x80008000) == 0) {
if (myDebug) {
cout << " hiding the shape " << I;
cout << " by the shape : " << J << endl;

28
src/HLRBRep/HLRBRep_Intersector.cxx
View File

@ -40,9 +40,9 @@
#include <StdFail_UndefinedDerivative.hxx>
#include <stdio.h>
#define PERF 0
//#define PERF
#if PERF
#ifdef PERF
static Standard_Integer NbIntersCS=0;
static Standard_Integer NbIntersCSVides=0;
static Standard_Integer NbIntersAuto=0;
@ -64,7 +64,7 @@ static Standard_Integer NbIntersSimulate=0;
HLRBRep_Intersector::HLRBRep_Intersector () :
myPolyhedron(NULL)
{
#if PERF
#ifdef PERF
if(NbInters) {
printf("\n--------------------------------------");
printf("\nNbIntersSimulate : %6d",NbIntersSimulate);
@ -99,7 +99,7 @@ void HLRBRep_Intersector::Perform (const Standard_Address A1,
const Standard_Real da1,
const Standard_Real db1)
{
#if PERF
#ifdef PERF
NbIntersAuto++;
#endif
@ -361,7 +361,7 @@ void HLRBRep_Intersector::Perform (const Standard_Integer /*nA*/,
#if PERF
#ifdef PERF
NbInters++;
if(myIntersector.NbPoints()==1) {
if(myIntersector.NbSegments()==0) {
@ -402,7 +402,7 @@ void HLRBRep_Intersector::SimulateOnePoint(const Standard_Address A1,
const Standard_Real u,
const Standard_Address A2,
const Standard_Real v) {
#if PERF
#ifdef PERF
NbIntersSimulate++;
#endif
Standard_Address myC1 = ((HLRBRep_EdgeData*) A1)->Curve();
@ -435,7 +435,7 @@ void HLRBRep_Intersector::Load (Standard_Address& A)
{
mySurface = A;
if (myPolyhedron != NULL) {
delete (HLRBRep_ThePolyhedronOfInterCSurf*)myPolyhedron;
delete myPolyhedron;
myPolyhedron = NULL;
}
}
@ -469,13 +469,11 @@ void HLRBRep_Intersector::Perform (const gp_Lin& L,
v2 = HLRBRep_SurfaceTool::LastVParameter(mySurface);
nbsu = HLRBRep_SurfaceTool::NbSamplesU(mySurface,u1,u2);
nbsv = HLRBRep_SurfaceTool::NbSamplesV(mySurface,v1,v2);
myPolyhedron = (Standard_Address)
(new HLRBRep_ThePolyhedronOfInterCSurf
(mySurface,nbsu,nbsv,u1,v1,u2,v2));
myPolyhedron =
new HLRBRep_ThePolyhedronOfInterCSurf(mySurface,nbsu,nbsv,u1,v1,u2,v2);
}
Standard_Real x0,y0,z0,x1,y1,z1,pmin,pmax;//,pp;
((HLRBRep_ThePolyhedronOfInterCSurf*)myPolyhedron)
->Bounding().Get(x0,y0,z0,x1,y1,z1);
myPolyhedron->Bounding().Get(x0,y0,z0,x1,y1,z1);
#if 0
pmax = pmin = ElCLib::Parameter(L, gp_Pnt((x1+x0)*0.5,
(y1+y0)*0.5,
@ -520,7 +518,7 @@ void HLRBRep_Intersector::Perform (const gp_Lin& L,
}
}
#if PERF
#ifdef PERF
NbIntersCS++;
if(myCSIntersector.NbPoints()==0) {
NbIntersCSVides++;
@ -631,7 +629,7 @@ HLRBRep_Intersector::CSSegment (const Standard_Integer N) const
void HLRBRep_Intersector::Destroy ()
{
if (myPolyhedron != NULL)
delete (HLRBRep_ThePolyhedronOfInterCSurf *)myPolyhedron;
delete myPolyhedron;
}
@ -725,7 +723,7 @@ void HLRBRep_Intersector::Perform (const Standard_Integer nA,
#if PERF
#ifdef PERF
NbInters++;
if(myIntersector.NbPoints()==1) {
if(myIntersector.NbSegments()==0) {

2
src/HLRBRep/HLRBRep_Intersector.hxx
View File

@ -106,7 +106,7 @@ private:
HLRBRep_CInter myIntersector;
HLRBRep_InterCSurf myCSIntersector;
Standard_Address mySurface;
Standard_Address myPolyhedron;
HLRBRep_ThePolyhedronOfInterCSurf* myPolyhedron;
};

2233
src/HLRBRep/HLRBRep_PolyAlgo.cxx
View File

File diff suppressed because it is too large Load Diff

78
src/HLRBRep/HLRBRep_PolyAlgo.hxx
View File

@ -17,6 +17,11 @@
#ifndef _HLRBRep_PolyAlgo_HeaderFile
#define _HLRBRep_PolyAlgo_HeaderFile
#include <HLRAlgo_PolyInternalNode.hxx>
#include <HLRAlgo_Array1OfTData.hxx>
#include <HLRAlgo_Array1OfPISeg.hxx>
#include <HLRAlgo_Array1OfPINod.hxx>
#include <Standard.hxx>
#include <Standard_Type.hxx>
@ -33,10 +38,10 @@
#include <TColStd_Array1OfTransient.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TopTools_MapOfShape.hxx>
#include <Standard_Address.hxx>
#include <HLRAlgo_ListOfBPoint.hxx>
#include <TopTools_ListOfShape.hxx>
#include <GeomAbs_Shape.hxx>
class HLRAlgo_PolyAlgo;
class Geom_Surface;
class Standard_OutOfRange;
@ -45,6 +50,7 @@ class HLRAlgo_Projector;
class TopoDS_Edge;
class HLRAlgo_PolyInternalData;
class HLRAlgo_EdgeStatus;
struct HLRAlgo_TriangleData;
class HLRBRep_PolyAlgo;
@ -163,7 +169,13 @@ public:
void NextHide();
Standard_EXPORT void Hide (Standard_Address& Coordinates, HLRAlgo_EdgeStatus& status, TopoDS_Shape& S, Standard_Boolean& reg1, Standard_Boolean& regn, Standard_Boolean& outl, Standard_Boolean& intl);
Standard_EXPORT HLRAlgo_BiPoint::PointsT& Hide (
HLRAlgo_EdgeStatus& status,
TopoDS_Shape& S,
Standard_Boolean& reg1,
Standard_Boolean& regn,
Standard_Boolean& outl,
Standard_Boolean& intl);
void InitShow();
@ -171,7 +183,7 @@ public:
void NextShow();
Standard_EXPORT void Show (Standard_Address& Coordinates, TopoDS_Shape& S, Standard_Boolean& reg1, Standard_Boolean& regn, Standard_Boolean& outl, Standard_Boolean& intl);
Standard_EXPORT HLRAlgo_BiPoint::PointsT& Show (TopoDS_Shape& S, Standard_Boolean& reg1, Standard_Boolean& regn, Standard_Boolean& outl, Standard_Boolean& intl);
//! Make a shape with the internal outlines in each
//! face.
@ -200,45 +212,50 @@ private:
Standard_EXPORT void StoreShell (const TopoDS_Shape& Shape, Standard_Integer& iShell, TColStd_Array1OfTransient& Shell, const Standard_Boolean IsoledF, const Standard_Boolean IsoledE, TColStd_Array1OfInteger& ES, TColStd_Array1OfTransient& PD, TColStd_Array1OfTransient& PID, TopTools_MapOfShape& ShapeMap1, TopTools_MapOfShape& ShapeMap2);
Standard_EXPORT Standard_Boolean Normal (const Standard_Integer iNode, const Standard_Address Nod1Indices, const Standard_Address Nod1RValues, Standard_Address& TData, Standard_Address& PISeg, Standard_Address& PINod, const Standard_Boolean orient) const;
Standard_EXPORT Standard_Boolean Normal (const Standard_Integer iNode, HLRAlgo_PolyInternalNode::NodeIndices& theNodIndices, HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_Array1OfTData*& TData, HLRAlgo_Array1OfPISeg*& PISeg, HLRAlgo_Array1OfPINod*& PINod, const Standard_Boolean orient) const;
Standard_EXPORT Standard_Boolean AverageNormal (const Standard_Integer iNode, const Standard_Address Nod1Indices, Standard_Address& TData, Standard_Address& PISeg, Standard_Address& PINod, Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const;
Standard_EXPORT void AddNormalOnTriangle (const Standard_Integer iTri, const Standard_Integer iNode, Standard_Integer& jNode, Standard_Address& TData, Standard_Address& PINod, Standard_Real& X, Standard_Real& Y, Standard_Real& Z, Standard_Boolean& OK) const;
Standard_EXPORT Standard_Boolean AverageNormal (const Standard_Integer iNode, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices, HLRAlgo_Array1OfTData*& TData, HLRAlgo_Array1OfPISeg*& PISeg, HLRAlgo_Array1OfPINod*& PINod, Standard_Real& X, Standard_Real& Y, Standard_Real& Z) const;
Standard_Boolean AverageNormal (const Standard_Integer iNode, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices, HLRAlgo_Array1OfTData*& TData, HLRAlgo_Array1OfPISeg*& PISeg, HLRAlgo_Array1OfPINod*& PINod, gp_XYZ& theNormal) const
{
return AverageNormal (iNode, theNodeIndices, TData, PISeg, PINod, theNormal.ChangeCoord(1), theNormal.ChangeCoord(2), theNormal.ChangeCoord(3));
}
Standard_EXPORT void AddNormalOnTriangle (const Standard_Integer iTri, const Standard_Integer iNode, Standard_Integer& jNode, HLRAlgo_Array1OfTData*& TData, HLRAlgo_Array1OfPINod*& PINod, Standard_Real& X, Standard_Real& Y, Standard_Real& Z, Standard_Boolean& OK) const;
Standard_EXPORT void InitBiPointsWithConnexity (const Standard_Integer e, TopoDS_Edge& E, HLRAlgo_ListOfBPoint& List, TColStd_Array1OfTransient& PID, TopTools_ListOfShape& LS, const Standard_Boolean connex);
Standard_EXPORT void Interpolation (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, Standard_Address& Nod11Indices, Standard_Address& Nod11RValues, Standard_Address& Nod12Indices, Standard_Address& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, Standard_Address& TData1, Standard_Address& PISeg1, Standard_Address& PINod1) const;
Standard_EXPORT void Interpolation (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices1, HLRAlgo_PolyInternalNode::NodeData& Nod11RValues, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices2, HLRAlgo_PolyInternalNode::NodeData& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPINod*& PINod1) const;
Standard_EXPORT void Interpolation (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, const GeomAbs_Shape rg, Standard_Address& Nod11Indices, Standard_Address& Nod11RValues, Standard_Address& Nod12Indices, Standard_Address& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, Standard_Address& TData1, Standard_Address& PISeg1, Standard_Address& PINod1, Standard_Address& Nod21Indices, Standard_Address& Nod21RValues, Standard_Address& Nod22Indices, Standard_Address& Nod22RValues, const Standard_Integer i2p1, const Standard_Integer i2p2, const Standard_Integer i2, const Handle(HLRAlgo_PolyInternalData)& pid2, Standard_Address& TData2, Standard_Address& PISeg2, Standard_Address& PINod2) const;
Standard_EXPORT void Interpolation (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, const GeomAbs_Shape rg, HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices, HLRAlgo_PolyInternalNode::NodeData& Nod11RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices, HLRAlgo_PolyInternalNode::NodeData& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPINod*& PINod1, HLRAlgo_PolyInternalNode::NodeIndices& Nod21Indices, HLRAlgo_PolyInternalNode::NodeData& Nod21RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod22Indices, HLRAlgo_PolyInternalNode::NodeData& Nod22RValues, const Standard_Integer i2p1, const Standard_Integer i2p2, const Standard_Integer i2, const Handle(HLRAlgo_PolyInternalData)& pid2, HLRAlgo_Array1OfTData*& TData2, HLRAlgo_Array1OfPISeg*& PISeg2, HLRAlgo_Array1OfPINod*& PINod2) const;
Standard_EXPORT Standard_Boolean Interpolation (const Standard_Real U1, const Standard_Real U2, const Standard_Address Nod1RValues, const Standard_Address Nod2RValues, Standard_Real& X3, Standard_Real& Y3, Standard_Real& Z3, Standard_Real& XT3, Standard_Real& YT3, Standard_Real& ZT3, Standard_Real& coef3, Standard_Real& U3, Standard_Boolean& mP3P1) const;
Standard_EXPORT Standard_Boolean Interpolation (const Standard_Real U1, const Standard_Real U2, HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_PolyInternalNode::NodeData& Nod2RValues, Standard_Real& X3, Standard_Real& Y3, Standard_Real& Z3, Standard_Real& XT3, Standard_Real& YT3, Standard_Real& ZT3, Standard_Real& coef3, Standard_Real& U3, Standard_Boolean& mP3P1) const;
Standard_EXPORT void MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, Standard_Address& Nod11Indices, Standard_Address& Nod11RValues, Standard_Address& Nod12Indices, Standard_Address& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, Standard_Address& TData1, Standard_Address& PISeg1, Standard_Address& PINod1, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Real XT3, const Standard_Real YT3, const Standard_Real ZT3, const Standard_Real coef3, const Standard_Real U3, const Standard_Boolean insP3, const Standard_Boolean mP3P1, const Standard_Integer flag) const;
Standard_EXPORT void MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices, HLRAlgo_PolyInternalNode::NodeData& Nod11RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices, HLRAlgo_PolyInternalNode::NodeData& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPINod*& PINod1, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Real XT3, const Standard_Real YT3, const Standard_Real ZT3, const Standard_Real coef3, const Standard_Real U3, const Standard_Boolean insP3, const Standard_Boolean mP3P1, const Standard_Integer flag) const;
Standard_EXPORT void MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, Standard_Address& Nod11Indices, Standard_Address& Nod11RValues, Standard_Address& Nod12Indices, Standard_Address& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, Standard_Address& TData1, Standard_Address& PISeg1, Standard_Address& PINod1, Standard_Address& Nod21Indices, Standard_Address& Nod21RValues, Standard_Address& Nod22Indices, Standard_Address& Nod22RValues, const Standard_Integer i2p1, const Standard_Integer i2p2, const Standard_Integer i2, const Handle(HLRAlgo_PolyInternalData)& pid2, Standard_Address& TData2, Standard_Address& PISeg2, Standard_Address& PINod2, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Real XT3, const Standard_Real YT3, const Standard_Real ZT3, const Standard_Real coef3, const Standard_Real U3, const Standard_Boolean insP3, const Standard_Boolean mP3P1, const Standard_Integer flag) const;
Standard_EXPORT void MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices, HLRAlgo_PolyInternalNode::NodeData& Nod11RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices, HLRAlgo_PolyInternalNode::NodeData& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPINod*& PINod1, HLRAlgo_PolyInternalNode::NodeIndices& Nod21Indices, HLRAlgo_PolyInternalNode::NodeData& Nod21RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod22Indices, HLRAlgo_PolyInternalNode::NodeData& Nod22RValues, const Standard_Integer i2p1, const Standard_Integer i2p2, const Standard_Integer i2, const Handle(HLRAlgo_PolyInternalData)& pid2, HLRAlgo_Array1OfTData*& TData2, HLRAlgo_Array1OfPISeg*& PISeg2, HLRAlgo_Array1OfPINod*& PINod2, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Real XT3, const Standard_Real YT3, const Standard_Real ZT3, const Standard_Real coef3, const Standard_Real U3, const Standard_Boolean insP3, const Standard_Boolean mP3P1, const Standard_Integer flag) const;
Standard_EXPORT void MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, Standard_Address& Nod11Indices, Standard_Address& Nod11RValues, Standard_Address& Nod12Indices, Standard_Address& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, Standard_Address& TData1, Standard_Address& PISeg1, Standard_Address& PINod1, Standard_Address& Nod21Indices, Standard_Address& Nod21RValues, Standard_Address& Nod22Indices, Standard_Address& Nod22RValues, const Standard_Integer i2p1, const Standard_Integer i2p2, const Standard_Integer i2, const Handle(HLRAlgo_PolyInternalData)& pid2, Standard_Address& TData2, Standard_Address& PISeg2, Standard_Address& PINod2, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Real XT3, const Standard_Real YT3, const Standard_Real ZT3, const Standard_Real coef3, const Standard_Real U3, const Standard_Boolean insP3, const Standard_Boolean mP3P1, const Standard_Real X4, const Standard_Real Y4, const Standard_Real Z4, const Standard_Real XT4, const Standard_Real YT4, const Standard_Real ZT4, const Standard_Real coef4, const Standard_Real U4, const Standard_Boolean insP4, const Standard_Boolean mP4P1, const Standard_Integer flag) const;
Standard_EXPORT void MoveOrInsertPoint (HLRAlgo_ListOfBPoint& List, Standard_Real& X1, Standard_Real& Y1, Standard_Real& Z1, Standard_Real& X2, Standard_Real& Y2, Standard_Real& Z2, Standard_Real& XTI1, Standard_Real& YTI1, Standard_Real& ZTI1, Standard_Real& XTI2, Standard_Real& YTI2, Standard_Real& ZTI2, const Standard_Integer e, Standard_Real& U1, Standard_Real& U2, HLRAlgo_PolyInternalNode::NodeIndices& Nod11Indices, HLRAlgo_PolyInternalNode::NodeData& Nod11RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod12Indices, HLRAlgo_PolyInternalNode::NodeData& Nod12RValues, const Standard_Integer i1p1, const Standard_Integer i1p2, const Standard_Integer i1, const Handle(HLRAlgo_PolyInternalData)& pid1, HLRAlgo_Array1OfTData*& TData1, HLRAlgo_Array1OfPISeg*& PISeg1, HLRAlgo_Array1OfPINod*& PINod1, HLRAlgo_PolyInternalNode::NodeIndices& Nod21Indices, HLRAlgo_PolyInternalNode::NodeData& Nod21RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod22Indices, HLRAlgo_PolyInternalNode::NodeData& Nod22RValues, const Standard_Integer i2p1, const Standard_Integer i2p2, const Standard_Integer i2, const Handle(HLRAlgo_PolyInternalData)& pid2, HLRAlgo_Array1OfTData*& TData2, HLRAlgo_Array1OfPISeg*& PISeg2, HLRAlgo_Array1OfPINod*& PINod2, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Real XT3, const Standard_Real YT3, const Standard_Real ZT3, const Standard_Real coef3, const Standard_Real U3, const Standard_Boolean insP3, const Standard_Boolean mP3P1, const Standard_Real X4, const Standard_Real Y4, const Standard_Real Z4, const Standard_Real XT4, const Standard_Real YT4, const Standard_Real ZT4, const Standard_Real coef4, const Standard_Real U4, const Standard_Boolean insP4, const Standard_Boolean mP4P1, const Standard_Integer flag) const;
Standard_EXPORT void InsertOnOutLine (TColStd_Array1OfTransient& PID);
Standard_EXPORT void CheckFrBackTriangles (HLRAlgo_ListOfBPoint& List, TColStd_Array1OfTransient& PID);
Standard_EXPORT void FindEdgeOnTriangle (const Standard_Address Tri1Indices, const Standard_Integer ip1, const Standard_Integer ip2, Standard_Integer& jtrouv, Standard_Boolean& isDirect) const;
Standard_EXPORT void FindEdgeOnTriangle (const HLRAlgo_TriangleData& theTriangle, const Standard_Integer ip1, const Standard_Integer ip2, Standard_Integer& jtrouv, Standard_Boolean& isDirect) const;
Standard_EXPORT void ChangeNode (const Standard_Integer ip1, const Standard_Integer ip2, const Standard_Address Nod1Indices, const Standard_Address Nod1RValues, const Standard_Address Nod2Indices, const Standard_Address Nod2RValues, const Standard_Real coef1, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Boolean first, Standard_Address& TData, Standard_Address& PISeg, Standard_Address& PINod) const;
Standard_EXPORT void ChangeNode (const Standard_Integer ip1, const Standard_Integer ip2, HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices, HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices, HLRAlgo_PolyInternalNode::NodeData& Nod2RValues, const Standard_Real coef1, const Standard_Real X3, const Standard_Real Y3, const Standard_Real Z3, const Standard_Boolean first, HLRAlgo_Array1OfTData*& TData, HLRAlgo_Array1OfPISeg*& PISeg, HLRAlgo_Array1OfPINod*& PINod) const;
Standard_EXPORT void UpdateAroundNode (const Standard_Integer iNode, const Standard_Address Nod1Indices, const Standard_Address TData, const Standard_Address PISeg, const Standard_Address PINod) const;
Standard_EXPORT void UpdateAroundNode (const Standard_Integer iNode, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices, HLRAlgo_Array1OfTData* TData, HLRAlgo_Array1OfPISeg* PISeg, HLRAlgo_Array1OfPINod* PINod) const;
Standard_EXPORT void OrientTriangle (const Standard_Integer iTri, const Standard_Address Tri1Indices, const Standard_Address Nod1Indices, const Standard_Address Nod1RValues, const Standard_Address Nod2Indices, const Standard_Address Nod2RValues, const Standard_Address Nod3Indices, const Standard_Address Nod3RValues) const;
Standard_EXPORT void OrientTriangle (const Standard_Integer iTri, HLRAlgo_TriangleData& theTriangle, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices1, HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices2, HLRAlgo_PolyInternalNode::NodeData& Nod2RValues, HLRAlgo_PolyInternalNode::NodeIndices& theNodeIndices3, HLRAlgo_PolyInternalNode::NodeData& Nod3RValues) const;
Standard_EXPORT Standard_Boolean Triangles (const Standard_Integer ip1, const Standard_Integer ip2, const Standard_Address Nod1Indices, Standard_Address& PISeg, Standard_Integer& iTri1, Standard_Integer& iTri2) const;
Standard_EXPORT Standard_Boolean Triangles (const Standard_Integer ip1, const Standard_Integer ip2, HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices, HLRAlgo_Array1OfPISeg*& PISeg, Standard_Integer& iTri1, Standard_Integer& iTri2) const;
Standard_EXPORT Standard_Boolean NewNode (const Standard_Address Nod1RValues, const Standard_Address Nod2RValues, Standard_Real& coef1, Standard_Boolean& moveP1) const;
Standard_EXPORT Standard_Boolean NewNode (HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_PolyInternalNode::NodeData& Nod2RValues, Standard_Real& coef1, Standard_Boolean& moveP1) const;
Standard_EXPORT void UVNode (const Standard_Address Nod1RValues, const Standard_Address Nod2RValues, const Standard_Real coef1, Standard_Real& U3, Standard_Real& V3) const;
Standard_EXPORT void UVNode (HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_PolyInternalNode::NodeData& Nod2RValues, const Standard_Real coef1, Standard_Real& U3, Standard_Real& V3) const;
Standard_EXPORT void CheckDegeneratedSegment (const Standard_Address Nod1Indices, const Standard_Address Nod1RValues, const Standard_Address Nod2Indices, const Standard_Address Nod2RValues) const;
Standard_EXPORT void CheckDegeneratedSegment (HLRAlgo_PolyInternalNode::NodeIndices& Nod1Indices, HLRAlgo_PolyInternalNode::NodeData& Nod1RValues, HLRAlgo_PolyInternalNode::NodeIndices& Nod2Indices, HLRAlgo_PolyInternalNode::NodeData& Nod2RValues) const;
Standard_EXPORT void UpdateOutLines (HLRAlgo_ListOfBPoint& List, TColStd_Array1OfTransient& PID);
@ -247,11 +264,26 @@ private:
Standard_EXPORT void UpdatePolyData (TColStd_Array1OfTransient& PD, TColStd_Array1OfTransient& PID, const Standard_Boolean closed);
Standard_EXPORT void TMultiply (Standard_Real& X, Standard_Real& Y, Standard_Real& Z, const Standard_Boolean VecPartOnly = Standard_False) const;
void TMultiply(gp_XYZ& thePoint, const Standard_Boolean VecPartOnly = Standard_False) const
{
TMultiply(thePoint.ChangeCoord(1), thePoint.ChangeCoord(2), thePoint.ChangeCoord(3), VecPartOnly);
}
Standard_EXPORT void TTMultiply (Standard_Real& X, Standard_Real& Y, Standard_Real& Z, const Standard_Boolean VecPartOnly = Standard_False) const;
void TTMultiply (gp_XYZ& thePoint, const Standard_Boolean VecPartOnly = Standard_False) const
{
TTMultiply(thePoint.ChangeCoord(1), thePoint.ChangeCoord(2), thePoint.ChangeCoord(3), VecPartOnly);\
}
Standard_EXPORT void TIMultiply (Standard_Real& X, Standard_Real& Y, Standard_Real& Z, const Standard_Boolean VecPartOnly = Standard_False) const;
void TIMultiply (gp_XYZ& thePoint, const Standard_Boolean VecPartOnly = Standard_False) const
{
TIMultiply(thePoint.ChangeCoord(1), thePoint.ChangeCoord(2), thePoint.ChangeCoord(3), VecPartOnly);
}
HLRAlgo_Projector myProj;
Standard_Real TMat[3][3];
Standard_Real TLoc[3];

62
src/HLRBRep/HLRBRep_PolyHLRToShape.cxx
View File

@ -29,13 +29,6 @@
#include <TopoDS_Shape.hxx>
#include <TopTools_MapOfShape.hxx>
#define PntX1 ((Standard_Real*)Coordinates)[0]
#define PntY1 ((Standard_Real*)Coordinates)[1]
#define PntZ1 ((Standard_Real*)Coordinates)[2]
#define PntX2 ((Standard_Real*)Coordinates)[3]
#define PntY2 ((Standard_Real*)Coordinates)[4]
#define PntZ2 ((Standard_Real*)Coordinates)[5]
//=======================================================================
//function : HLRBRep_PolyHLRToShape
//purpose :
@ -53,7 +46,7 @@ void HLRBRep_PolyHLRToShape::Update (const Handle(HLRBRep_PolyAlgo)& A)
{
myAlgo = A;
myHideMode = Standard_True;
Standard_Real sta,end,XSta,YSta,ZSta,XEnd,YEnd,ZEnd,dx,dy;
Standard_Real sta,end;
Standard_ShortReal tolsta,tolend;
HLRAlgo_EdgeIterator It;
myBiPntVis.Clear();
@ -62,21 +55,17 @@ void HLRBRep_PolyHLRToShape::Update (const Handle(HLRBRep_PolyAlgo)& A)
Standard_Boolean reg1,regn,outl,intl;
const gp_Trsf& T = myAlgo->Projector().Transformation();
HLRAlgo_EdgeStatus status;
Standard_Address Coordinates;
for (myAlgo->InitHide(); myAlgo->MoreHide(); myAlgo->NextHide()) {
myAlgo->Hide(Coordinates,status,S,reg1,regn,outl,intl);
XSta = PntX1;
YSta = PntY1;
ZSta = PntZ1;
XEnd = PntX2;
YEnd = PntY2;
ZEnd = PntZ2;
T.Transforms(XSta,YSta,ZSta);
T.Transforms(XEnd,YEnd,ZEnd);
dx = XEnd - XSta;
dy = YEnd - YSta;
if (sqrt(dx * dx + dy * dy) > 1.e-10) {
HLRAlgo_BiPoint::PointsT& aPoints = myAlgo->Hide(status,S,reg1,regn,outl,intl);
gp_XYZ aSta = aPoints.Pnt1;
gp_XYZ aEnd = aPoints.Pnt2;
T.Transforms(aSta);
T.Transforms(aEnd);
const gp_XY aSta2D(aSta.X(), aSta.Y());
const gp_XY aEnd2D(aEnd.X(), aEnd.Y());
const gp_XY aD = aEnd2D - aSta2D;
if (aD.Modulus() > 1.e-10) {
for (It.InitVisible(status);
It.MoreVisible();
@ -84,8 +73,7 @@ void HLRBRep_PolyHLRToShape::Update (const Handle(HLRBRep_PolyAlgo)& A)
It.Visible(sta,tolsta,end,tolend);
myBiPntVis.Append
(HLRBRep_BiPnt2D
(XSta + sta * dx,YSta + sta * dy,
XSta + end * dx,YSta + end * dy,
(aSta2D + sta * aD, aSta2D + end * aD,
S,reg1,regn,outl,intl));
}
@ -95,8 +83,7 @@ void HLRBRep_PolyHLRToShape::Update (const Handle(HLRBRep_PolyAlgo)& A)
It.Hidden(sta,tolsta,end,tolend);
myBiPntHid.Append
(HLRBRep_BiPnt2D
(XSta + sta * dx,YSta + sta * dy,
XSta + end * dx,YSta + end * dy,
(aSta2D + sta * aD, aSta2D + end * aD,
S,reg1,regn,outl,intl));
}
}
@ -153,11 +140,9 @@ HLRBRep_PolyHLRToShape::InternalCompound (const Standard_Integer typ,
else {
const gp_Trsf& T = myAlgo->Projector().Transformation();
TopoDS_Shape SBP;
Standard_Real XSta,YSta,ZSta,XEnd,YEnd,ZEnd,dx,dy;
Standard_Address Coordinates;
for (myAlgo->InitShow(); myAlgo->MoreShow(); myAlgo->NextShow()) {
myAlgo->Show(Coordinates,SBP,reg1,regn,outl,intl);
HLRAlgo_BiPoint::PointsT& aPoints = myAlgo->Show(SBP,reg1,regn,outl,intl);
if (typ == 1) todraw = intl;
else if (typ == 2) todraw = reg1 && !regn && !outl;
else if (typ == 3) todraw = regn && !outl;
@ -165,19 +150,14 @@ HLRBRep_PolyHLRToShape::InternalCompound (const Standard_Integer typ,
if (todraw)
if (!S.IsNull()) todraw = Map.Contains(SBP);
if (todraw) {
XSta = PntX1;
YSta = PntY1;
ZSta = PntZ1;
XEnd = PntX2;
YEnd = PntY2;
ZEnd = PntZ2;
T.Transforms(XSta,YSta,ZSta);
T.Transforms(XEnd,YEnd,ZEnd);
dx = XEnd - XSta;
dy = YEnd - YSta;
if (sqrt(dx * dx + dy * dy) > 1.e-10) {
B.Add(Result,BRepLib_MakeEdge2d(gp_Pnt2d(XSta,YSta),
gp_Pnt2d(XEnd,YEnd)));
gp_XYZ aSta = aPoints.Pnt1, aEnd = aPoints.Pnt2;
T.Transforms(aSta);
T.Transforms(aEnd);
const gp_XY aSta2D(aSta.X(), aSta.Y());
const gp_XY aEnd2D(aEnd.X(), aEnd.Y());
const gp_XY aD = aEnd2D - aSta2D;
if (aD.Modulus() > 1.e-10) {
B.Add(Result,BRepLib_MakeEdge2d(aSta2D, aEnd2D));
added = Standard_True;
}
}

11
src/HLRBRep/HLRBRep_ShapeBounds.cxx
View File

@ -112,14 +112,3 @@ void HLRBRep_ShapeBounds::Bounds (Standard_Integer& V1,
F1 = myFaceStart;
F2 = myFaceEnd;
}
//=======================================================================
//function : UpdateMinMax
//purpose :
//=======================================================================
void HLRBRep_ShapeBounds::UpdateMinMax (const Standard_Address TotMinMax)
{
for (Standard_Integer i = 0; i <= 15; i++)
myMinMax[i] = ((Standard_Integer*)TotMinMax)[i];
}

15
src/HLRBRep/HLRBRep_ShapeBounds.hxx
View File

@ -17,12 +17,13 @@
#ifndef _HLRBRep_ShapeBounds_HeaderFile
#define _HLRBRep_ShapeBounds_HeaderFile
#include <HLRAlgo_EdgesBlock.hxx>
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Address.hxx>
class HLRTopoBRep_OutLiner;
class MMgt_TShared;
@ -60,9 +61,15 @@ public:
Standard_EXPORT void Bounds (Standard_Integer& V1, Standard_Integer& V2, Standard_Integer& E1, Standard_Integer& E2, Standard_Integer& F1, Standard_Integer& F2) const;
Standard_EXPORT void UpdateMinMax (const Standard_Address TotMinMax);
void UpdateMinMax (const HLRAlgo_EdgesBlock::MinMaxIndices& theTotMinMax)
{
myMinMax = theTotMinMax;
}
Standard_Address MinMax() const;
HLRAlgo_EdgesBlock::MinMaxIndices& MinMax()
{
return myMinMax;
}
@ -86,7 +93,7 @@ private:
Standard_Integer myEdgeEnd;
Standard_Integer myFaceStart;
Standard_Integer myFaceEnd;
Standard_Integer myMinMax[16];
HLRAlgo_EdgesBlock::MinMaxIndices myMinMax;
};

8
src/HLRBRep/HLRBRep_ShapeBounds.lxx
View File

@ -72,11 +72,3 @@ inline void HLRBRep_ShapeBounds::NbOfIso (const Standard_Integer nbIso)
inline Standard_Integer HLRBRep_ShapeBounds::NbOfIso () const
{ return myNbIso; }
//=======================================================================
//function : MinMax
//purpose :
//=======================================================================
inline Standard_Address HLRBRep_ShapeBounds::MinMax () const
{ return (Standard_Address)&myMinMax; }

40
src/HLRBRep/HLRBRep_Surface.cxx
View File

@ -93,7 +93,7 @@ HLRBRep_Surface::SideRowsOfPoles (const Standard_Real tol,
Standard_Real x0,y0,x,y,z;
Standard_Boolean result;
Standard_Real tole = (Standard_Real)tol;
const gp_Trsf& T = ((HLRAlgo_Projector*) myProj)->Transformation();
const gp_Trsf& T = myProj->Transformation();
for (iu = 1; iu <= nbuPoles; iu++) {
@ -160,34 +160,34 @@ HLRBRep_Surface::IsSide (const Standard_Real tolF,
gp_Ax1 A = Pl.Axis();
Pt = A.Location();
D = A.Direction();
Pt.Transform(((HLRAlgo_Projector*) myProj)->Transformation());
D .Transform(((HLRAlgo_Projector*) myProj)->Transformation());
if (((HLRAlgo_Projector*) myProj)->Perspective()) {
r = D.Z() * ((HLRAlgo_Projector*) myProj)->Focus() -
Pt.Transform(myProj->Transformation());
D .Transform(myProj->Transformation());
if (myProj->Perspective()) {
r = D.Z() * myProj->Focus() -
( D.X() * Pt.X() + D.Y() * Pt.Y() + D.Z() * Pt.Z() );
}
else r= D.Z();
return Abs(r) < toler;
}
else if (myType == GeomAbs_Cylinder) {
if (((HLRAlgo_Projector*) myProj)->Perspective()) return Standard_False;
if (myProj->Perspective()) return Standard_False;
gp_Cylinder Cyl = HLRBRep_BSurfaceTool::Cylinder(mySurf);
gp_Ax1 A = Cyl.Axis();
D = A.Direction();
D .Transform(((HLRAlgo_Projector*) myProj)->Transformation());
D .Transform(myProj->Transformation());
r = Sqrt(D.X() * D.X() + D.Y() * D.Y());
return r < toler;
}
else if (myType == GeomAbs_Cone) {
if (!((HLRAlgo_Projector*) myProj)->Perspective()) return Standard_False;
if (!myProj->Perspective()) return Standard_False;
gp_Cone Con = HLRBRep_BSurfaceTool::Cone(mySurf);
Pt = Con.Apex();
Pt.Transform(((HLRAlgo_Projector*) myProj)->Transformation());
Pt.Transform(myProj->Transformation());
Standard_Real tol = 0.001;
return Pt.IsEqual(gp_Pnt(0,0,((HLRAlgo_Projector*) myProj)->Focus()),tol);
return Pt.IsEqual(gp_Pnt(0,0,myProj->Focus()),tol);
}
else if (myType == GeomAbs_BezierSurface) {
if (((HLRAlgo_Projector*) myProj)->Perspective()) return Standard_False;
if (myProj->Perspective()) return Standard_False;
Standard_Integer nu = HLRBRep_BSurfaceTool::NbUPoles(mySurf);
Standard_Integer nv = HLRBRep_BSurfaceTool::NbVPoles(mySurf);
TColgp_Array2OfPnt Pnt(1,nu,1,nv);
@ -195,7 +195,7 @@ HLRBRep_Surface::IsSide (const Standard_Real tolF,
return SideRowsOfPoles (tolF,nu,nv,Pnt);
}
else if (myType == GeomAbs_BSplineSurface) {
if (((HLRAlgo_Projector*) myProj)->Perspective()) return Standard_False;
if (myProj->Perspective()) return Standard_False;
Standard_Integer nu = HLRBRep_BSurfaceTool::NbUPoles(mySurf);
Standard_Integer nv = HLRBRep_BSurfaceTool::NbVPoles(mySurf);
TColgp_Array2OfPnt Pnt(1,nu,1,nv);
@ -214,7 +214,7 @@ HLRBRep_Surface::IsSide (const Standard_Real tolF,
Standard_Boolean
HLRBRep_Surface::IsAbove (const Standard_Boolean back,
const Standard_Address A,
const HLRBRep_Curve* A,
const Standard_Real tol) const
{
Standard_Boolean planar = (myType == GeomAbs_Plane);
@ -224,22 +224,20 @@ HLRBRep_Surface::IsAbove (const Standard_Boolean back,
Pl.Coefficients(a,b,c,d);
Standard_Real u,u1,u2,dd,x,y,z;
gp_Pnt P;
u1 = ((HLRBRep_Curve*)A)->Parameter3d
(((HLRBRep_Curve*)A)->FirstParameter());
u2 = ((HLRBRep_Curve*)A)->Parameter3d
(((HLRBRep_Curve*)A)->LastParameter());
u1 = A->Parameter3d(A->FirstParameter());
u2 = A->Parameter3d(A->LastParameter());
u=u1;
((HLRBRep_Curve*)A)->D0(u,P);
A->D0(u,P);
P.Coord(x,y,z);
dd = a*x + b*y + c*z + d;
if (back) dd = -dd;
if (dd < -tol) return Standard_False;
if (((HLRBRep_Curve*)A)->GetType() != GeomAbs_Line) {
if (A->GetType() != GeomAbs_Line) {
Standard_Integer nbPnt = 30;
Standard_Real step = (u2-u1)/(nbPnt+1);
for (Standard_Integer i = 1; i <= nbPnt; i++) {
u += step;
((HLRBRep_Curve*)A)->D0(u,P);
A->D0(u,P);
P.Coord(x,y,z);
dd = a*x + b*y + c*z + d;
if (back) dd = -dd;
@ -247,7 +245,7 @@ HLRBRep_Surface::IsAbove (const Standard_Boolean back,
}
}
u = u2;
((HLRBRep_Curve*)A)->D0(u,P);
A->D0(u,P);
P.Coord(x,y,z);
dd = a*x + b*y + c*z + d;
if (back) dd = -dd;

12
src/HLRBRep/HLRBRep_Surface.hxx
View File

@ -17,13 +17,14 @@
#ifndef _HLRBRep_Surface_HeaderFile
#define _HLRBRep_Surface_HeaderFile
#include <HLRBRep_Curve.hxx>
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <BRepAdaptor_Surface.hxx>
#include <GeomAbs_SurfaceType.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
#include <Standard_Integer.hxx>
@ -56,7 +57,10 @@ public:
//! Creates an undefined surface with no face loaded.
Standard_EXPORT HLRBRep_Surface();
void Projector (const Standard_Address Proj);
void Projector (const HLRAlgo_Projector* Proj)
{
myProj = Proj;
}
//! Returns the 3D Surface.
BRepAdaptor_Surface& Surface();
@ -67,7 +71,7 @@ public:
//! returns true if it is a side face
Standard_EXPORT Standard_Boolean IsSide (const Standard_Real tolf, const Standard_Real toler) const;
Standard_EXPORT Standard_Boolean IsAbove (const Standard_Boolean back, const Standard_Address A, const Standard_Real tolC) const;
Standard_EXPORT Standard_Boolean IsAbove (const Standard_Boolean back, const HLRBRep_Curve* A, const Standard_Real tolC) const;
Standard_Real FirstUParameter() const;
@ -187,7 +191,7 @@ private:
BRepAdaptor_Surface mySurf;
GeomAbs_SurfaceType myType;
Standard_Address myProj;
const HLRAlgo_Projector* myProj;
};

9
src/HLRBRep/HLRBRep_Surface.lxx
View File

@ -17,15 +17,6 @@
#include <BRepAdaptor_Surface.hxx>
#include <HLRBRep_BSurfaceTool.hxx>
//=======================================================================
//function : Projector
//purpose :
//=======================================================================
inline void
HLRBRep_Surface::Projector(const Standard_Address Proj)
{ myProj = Proj; }
//=======================================================================
//function : Surface
//purpose :

4
src/HLRTest/HLRTest_DrawablePolyEdgeTool.cxx
View File

@ -67,7 +67,7 @@ HLRTest_DrawablePolyEdgeTool (const Handle(HLRBRep_PolyAlgo)& Alg,
Standard_Boolean reg1,regn,outl,intl;
for (myAlgo->InitHide(); myAlgo->MoreHide(); myAlgo->NextHide()) {
myAlgo->Hide(Coordinates,status,S,reg1,regn,outl,intl);
Coordinates = &myAlgo->Hide(status,S,reg1,regn,outl,intl);
dx = PntX2 - PntX1;
dy = PntY2 - PntY1;
dz = PntZ2 - PntZ1;
@ -151,7 +151,7 @@ void HLRTest_DrawablePolyEdgeTool::DrawOn (Draw_Display& D) const
D.SetColor(Draw_vert);
for (myAlgo->InitShow(); myAlgo->MoreShow(); myAlgo->NextShow()) {
myAlgo->Show(Coordinates,S,reg1,regn,outl,intl);
Coordinates = &myAlgo->Show(S,reg1,regn,outl,intl);
Standard_Boolean todraw = Standard_True;
if ((!myDispRg1 && reg1 && !outl) ||
(!myDispRgN && regn && !outl))

5
src/HLRTopoBRep/HLRTopoBRep_DSFiller.cxx
View File

@ -63,11 +63,6 @@
#include <TopoDS_Vertex.hxx>
#include <TopTools_ListIteratorOfListOfShape.hxx>
#define INTERPOLATE 0
#define BRISE 0
#define APPROX 1
//=======================================================================
//function : Insert
//purpose : explore the faces and insert them

4
src/HLRTopoBRep/HLRTopoBRep_Data.cxx
View File

@ -345,7 +345,7 @@ void HLRTopoBRep_Data::InsertBefore (const TopoDS_Vertex& V,
const Standard_Real P)
{
HLRTopoBRep_VData VD(P,V);
((HLRTopoBRep_ListOfVData*)myVList)->InsertBefore(VD,myVIterator);
myVList->InsertBefore(VD,myVIterator);
}
//=======================================================================
@ -357,6 +357,6 @@ void HLRTopoBRep_Data::Append (const TopoDS_Vertex& V,
const Standard_Real P)
{
HLRTopoBRep_VData VD(P,V);
((HLRTopoBRep_ListOfVData*)myVList)->Append(VD);
myVList->Append(VD);
}

3
src/HLRTopoBRep/HLRTopoBRep_Data.hxx
View File

@ -28,7 +28,6 @@
#include <HLRTopoBRep_MapOfShapeListOfVData.hxx>
#include <HLRTopoBRep_DataMapIteratorOfMapOfShapeListOfVData.hxx>
#include <HLRTopoBRep_ListIteratorOfListOfVData.hxx>
#include <Standard_Address.hxx>
#include <Standard_Boolean.hxx>
#include <TopTools_ListOfShape.hxx>
#include <Standard_Real.hxx>
@ -156,7 +155,7 @@ private:
HLRTopoBRep_MapOfShapeListOfVData myEdgesVertices;
HLRTopoBRep_DataMapIteratorOfMapOfShapeListOfVData myEIterator;
HLRTopoBRep_ListIteratorOfListOfVData myVIterator;
Standard_Address myVList;
HLRTopoBRep_ListOfVData* myVList;
};

2
src/StdPrs/StdPrs_HLRPolyShape.cxx
View File

@ -95,7 +95,7 @@ void StdPrs_HLRPolyShape::Add(const Handle (Prs3d_Presentation)& aPresentation,
for (hider->InitHide(); hider->MoreHide(); hider->NextHide())
{
hider->Hide(Coordinates, status, S, reg1, regn, outl, intl);
Coordinates = &hider->Hide(status, S, reg1, regn, outl, intl);
dx = PntX2 - PntX1;
dy = PntY2 - PntY1;