mirror of
https://git.dev.opencascade.org/repos/occt.git
synced 2025-06-20 11:54:07 +03:00
a5a7b3185b
Update empty method guards to new style with regex (see PR). Used clang-format 18.1.8. New actions to validate code formatting is added. Update .clang-format with disabling of include sorting. It is temporary changes, then include will be sorted. Apply formatting for /src and /tools folder. The files with .hxx,.cxx,.lxx,.h,.pxx,.hpp,*.cpp extensions.
508 lines
18 KiB
C++
508 lines
18 KiB
C++
// Created on: 1995-05-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.
|
|
|
|
#include <HLRAlgo_PolyAlgo.hxx>
|
|
|
|
#include <HLRAlgo_BiPoint.hxx>
|
|
#include <HLRAlgo_EdgeStatus.hxx>
|
|
#include <HLRAlgo_ListOfBPoint.hxx>
|
|
#include <HLRAlgo_PolyShellData.hxx>
|
|
#include <HLRAlgo_PolyMask.hxx>
|
|
#include <Precision.hxx>
|
|
|
|
IMPLEMENT_STANDARD_RTTIEXT(HLRAlgo_PolyAlgo, Standard_Transient)
|
|
|
|
//=================================================================================================
|
|
|
|
HLRAlgo_PolyAlgo::HLRAlgo_PolyAlgo()
|
|
: myNbrShell(0),
|
|
myCurShell(0),
|
|
myFound(Standard_False)
|
|
{
|
|
myTriangle.TolParam = 0.00000001;
|
|
myTriangle.TolAng = 0.0001;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void HLRAlgo_PolyAlgo::Init(const Standard_Integer theNbShells)
|
|
{
|
|
myHShell.Resize(1, theNbShells, false);
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void HLRAlgo_PolyAlgo::Clear()
|
|
{
|
|
NCollection_Array1<Handle(HLRAlgo_PolyShellData)> anEmpty;
|
|
myHShell.Move(anEmpty);
|
|
myNbrShell = 0;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void HLRAlgo_PolyAlgo::Update()
|
|
{
|
|
Standard_Integer j;
|
|
Standard_Integer nxMin, nyMin, nzMin, nxMax, nyMax, nzMax;
|
|
Standard_Real xShellMin, yShellMin, zShellMin;
|
|
Standard_Real xShellMax, yShellMax, zShellMax;
|
|
Standard_Real xPolyTMin, yPolyTMin, zPolyTMin;
|
|
Standard_Real xPolyTMax, yPolyTMax, zPolyTMax;
|
|
Standard_Real xTrianMin, yTrianMin, zTrianMin;
|
|
Standard_Real xTrianMax, yTrianMax, zTrianMax;
|
|
Standard_Real xSegmnMin, ySegmnMin, zSegmnMin;
|
|
Standard_Real xSegmnMax, ySegmnMax, zSegmnMax;
|
|
constexpr Standard_Real Big = Precision::Infinite();
|
|
HLRAlgo_PolyData::Box aBox(Big, Big, Big, -Big, -Big, -Big);
|
|
|
|
myNbrShell = myHShell.Size();
|
|
for (Standard_Integer aShellIter = myHShell.Lower(); aShellIter <= myHShell.Upper(); ++aShellIter)
|
|
{
|
|
const Handle(HLRAlgo_PolyShellData)& aPsd = myHShell.ChangeValue(aShellIter);
|
|
aPsd->UpdateGlobalMinMax(aBox);
|
|
}
|
|
|
|
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;
|
|
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 = -aBox.XMin + precad;
|
|
Standard_Real DecaY = -aBox.YMin + precad;
|
|
Standard_Real DecaZ = -aBox.ZMin + precad;
|
|
|
|
for (Standard_Integer aShellIter = myHShell.Lower(); aShellIter <= myHShell.Upper(); ++aShellIter)
|
|
{
|
|
const Handle(HLRAlgo_PolyShellData)& aPsd = myHShell.ChangeValue(aShellIter);
|
|
HLRAlgo_PolyShellData::ShellIndices& aShellIndices = aPsd->Indices();
|
|
xShellMin = Big;
|
|
yShellMin = Big;
|
|
zShellMin = Big;
|
|
xShellMax = -Big;
|
|
yShellMax = -Big;
|
|
zShellMax = -Big;
|
|
|
|
for (mySegListIt.Initialize(aPsd->Edges()); mySegListIt.More(); mySegListIt.Next())
|
|
{
|
|
HLRAlgo_BiPoint& BP = mySegListIt.ChangeValue();
|
|
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);
|
|
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;
|
|
if (yShellMax < ySegmnMax)
|
|
yShellMax = ySegmnMax;
|
|
if (zShellMin > zSegmnMin)
|
|
zShellMin = zSegmnMin;
|
|
if (zShellMax < zSegmnMax)
|
|
zShellMax = zSegmnMax;
|
|
}
|
|
NCollection_Array1<Handle(HLRAlgo_PolyData)>& aPolyg = aPsd->PolyData();
|
|
const Standard_Integer nbFace = aPolyg.Upper();
|
|
Standard_Integer nbFaHi = 0;
|
|
for (j = 1; j <= nbFace; j++)
|
|
{
|
|
const Handle(HLRAlgo_PolyData)& aPd = aPolyg.ChangeValue(j);
|
|
if (aPd->Hiding())
|
|
{
|
|
nbFaHi++;
|
|
xPolyTMin = Big;
|
|
yPolyTMin = Big;
|
|
zPolyTMin = Big;
|
|
xPolyTMax = -Big;
|
|
yPolyTMax = -Big;
|
|
zPolyTMax = -Big;
|
|
Standard_Integer otheri, nbHide = 0; // min,max;
|
|
Standard_Real X1, X2, X3, Y1, Y2, Y3, Z1, Z2, Z3;
|
|
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.;
|
|
HLRAlgo_PolyData::FaceIndices& PolyTIndices = aPd->Indices();
|
|
TColgp_Array1OfXYZ& Nodes = aPd->Nodes();
|
|
HLRAlgo_Array1OfTData& TData = aPd->TData();
|
|
HLRAlgo_Array1OfPHDat& PHDat = aPd->PHDat();
|
|
Standard_Integer nbT = TData.Upper();
|
|
|
|
for (otheri = 1; otheri <= nbT; otheri++)
|
|
{
|
|
HLRAlgo_TriangleData& aTD = TData.ChangeValue(otheri);
|
|
if (aTD.Flags & HLRAlgo_PolyMask_FMskHiding)
|
|
{
|
|
const gp_XYZ& P1 = Nodes.Value(aTD.Node1);
|
|
const gp_XYZ& P2 = Nodes.Value(aTD.Node2);
|
|
const gp_XYZ& P3 = Nodes.Value(aTD.Node3);
|
|
X1 = P1.X();
|
|
Y1 = P1.Y();
|
|
Z1 = P1.Z();
|
|
X2 = P2.X();
|
|
Y2 = P2.Y();
|
|
Z2 = P2.Z();
|
|
X3 = P3.X();
|
|
Y3 = P3.Y();
|
|
Z3 = P3.Z();
|
|
xTrianMax = xTrianMin = X1;
|
|
yTrianMax = yTrianMin = Y1;
|
|
zTrianMax = zTrianMin = Z1;
|
|
if (xTrianMin > X2)
|
|
xTrianMin = X2;
|
|
else if (xTrianMax < X2)
|
|
xTrianMax = X2;
|
|
if (yTrianMin > Y2)
|
|
yTrianMin = Y2;
|
|
else if (yTrianMax < Y2)
|
|
yTrianMax = Y2;
|
|
if (zTrianMin > Z2)
|
|
zTrianMin = Z2;
|
|
else if (zTrianMax < Z2)
|
|
zTrianMax = Z2;
|
|
if (xTrianMin > X3)
|
|
xTrianMin = X3;
|
|
else if (xTrianMax < X3)
|
|
xTrianMax = X3;
|
|
if (yTrianMin > Y3)
|
|
yTrianMin = Y3;
|
|
else if (yTrianMax < Y3)
|
|
yTrianMax = Y3;
|
|
if (zTrianMin > Z3)
|
|
zTrianMin = Z3;
|
|
else if (zTrianMax < Z3)
|
|
zTrianMax = Z3;
|
|
nxMin = (Standard_Integer)((DecaX + xTrianMin) * SurDX);
|
|
nyMin = (Standard_Integer)((DecaY + yTrianMin) * SurDY);
|
|
nzMin = (Standard_Integer)((DecaZ + zTrianMin) * SurDZ);
|
|
nxMax = (Standard_Integer)((DecaX + xTrianMax) * SurDX);
|
|
nyMax = (Standard_Integer)((DecaY + yTrianMax) * SurDY);
|
|
nzMax = (Standard_Integer)((DecaZ + zTrianMax) * SurDZ);
|
|
Standard_Integer MinTrian, MaxTrian;
|
|
MinTrian = nyMin + (nxMin << 11);
|
|
MinTrian <<= 10;
|
|
MinTrian += nzMin - 0x00000200;
|
|
MaxTrian = nyMax + (nxMax << 11);
|
|
MaxTrian <<= 10;
|
|
MaxTrian += nzMax;
|
|
dx1 = X2 - X1;
|
|
dy1 = Y2 - Y1;
|
|
dz1 = Z2 - Z1;
|
|
dx2 = X3 - X2;
|
|
dy2 = Y3 - Y2;
|
|
dz2 = Z3 - Z2;
|
|
dx3 = X1 - X3;
|
|
dy3 = Y1 - Y3;
|
|
dnx = dy1 * dz2 - dy2 * dz1;
|
|
dny = dz1 * dx2 - dz2 * dx1;
|
|
dnz = dx1 * dy2 - dx2 * dy1;
|
|
dn = sqrt(dnx * dnx + dny * dny + dnz * dnz);
|
|
if (dn > 0)
|
|
{
|
|
a = dnx / dn;
|
|
b = dny / dn;
|
|
c = dnz / dn;
|
|
}
|
|
d = a * X1 + b * Y1 + c * Z1;
|
|
nbHide++;
|
|
PHDat(nbHide).Set(otheri, MinTrian, MaxTrian, a, b, c, d);
|
|
adx1 = dx1;
|
|
ady1 = dy1;
|
|
if (dx1 < 0)
|
|
adx1 = -dx1;
|
|
if (dy1 < 0)
|
|
ady1 = -dy1;
|
|
adx2 = dx2;
|
|
ady2 = dy2;
|
|
if (dx2 < 0)
|
|
adx2 = -dx2;
|
|
if (dy2 < 0)
|
|
ady2 = -dy2;
|
|
adx3 = dx3;
|
|
ady3 = dy3;
|
|
if (dx3 < 0)
|
|
adx3 = -dx3;
|
|
if (dy3 < 0)
|
|
ady3 = -dy3;
|
|
if (adx1 > ady1)
|
|
aTD.Flags |= HLRAlgo_PolyMask_EMskGrALin1;
|
|
else
|
|
aTD.Flags &= ~HLRAlgo_PolyMask_EMskGrALin1;
|
|
if (adx2 > ady2)
|
|
aTD.Flags |= HLRAlgo_PolyMask_EMskGrALin2;
|
|
else
|
|
aTD.Flags &= ~HLRAlgo_PolyMask_EMskGrALin2;
|
|
if (adx3 > ady3)
|
|
aTD.Flags |= HLRAlgo_PolyMask_EMskGrALin3;
|
|
else
|
|
aTD.Flags &= ~HLRAlgo_PolyMask_EMskGrALin3;
|
|
if (xPolyTMin > xTrianMin)
|
|
xPolyTMin = xTrianMin;
|
|
if (xPolyTMax < xTrianMax)
|
|
xPolyTMax = xTrianMax;
|
|
if (yPolyTMin > yTrianMin)
|
|
yPolyTMin = yTrianMin;
|
|
if (yPolyTMax < yTrianMax)
|
|
yPolyTMax = yTrianMax;
|
|
if (zPolyTMin > zTrianMin)
|
|
zPolyTMin = zTrianMin;
|
|
if (zPolyTMax < zTrianMax)
|
|
zPolyTMax = zTrianMax;
|
|
}
|
|
}
|
|
nxMin = (Standard_Integer)((DecaX + xPolyTMin) * SurDX);
|
|
nyMin = (Standard_Integer)((DecaY + yPolyTMin) * SurDY);
|
|
nzMin = (Standard_Integer)((DecaZ + zPolyTMin) * SurDZ);
|
|
nxMax = (Standard_Integer)((DecaX + xPolyTMax) * SurDX);
|
|
nyMax = (Standard_Integer)((DecaY + yPolyTMax) * SurDY);
|
|
nzMax = (Standard_Integer)((DecaZ + zPolyTMax) * SurDZ);
|
|
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;
|
|
if (yShellMax < yPolyTMax)
|
|
yShellMax = yPolyTMax;
|
|
if (zShellMin > zPolyTMin)
|
|
zShellMin = zPolyTMin;
|
|
if (zShellMax < zPolyTMax)
|
|
zShellMax = zPolyTMax;
|
|
}
|
|
}
|
|
if (nbFaHi > 0)
|
|
{
|
|
nxMin = (Standard_Integer)((DecaX + xShellMin) * SurDX);
|
|
nyMin = (Standard_Integer)((DecaY + yShellMin) * SurDY);
|
|
nzMin = (Standard_Integer)((DecaZ + zShellMin) * SurDZ);
|
|
nxMax = (Standard_Integer)((DecaX + xShellMax) * SurDX);
|
|
nyMax = (Standard_Integer)((DecaY + yShellMax) * SurDY);
|
|
nzMax = (Standard_Integer)((DecaZ + zShellMax) * SurDZ);
|
|
aShellIndices.Min = nyMin + (nxMin << 11);
|
|
aShellIndices.Min <<= 10;
|
|
aShellIndices.Min += nzMin - 0x00000200;
|
|
aShellIndices.Max = nyMax + (nxMax << 11);
|
|
aShellIndices.Max <<= 10;
|
|
aShellIndices.Max += nzMax;
|
|
aPsd->UpdateHiding(nbFaHi);
|
|
Standard_Integer aHiddenIndex = 1;
|
|
for (j = 1; j <= nbFace; j++)
|
|
{
|
|
const Handle(HLRAlgo_PolyData)& aPd = aPolyg.ChangeValue(j);
|
|
if (aPd->Hiding())
|
|
{
|
|
aPsd->HidingPolyData().SetValue(aHiddenIndex++, aPd);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aPsd->UpdateHiding(0);
|
|
aShellIndices.Min = 0;
|
|
aShellIndices.Max = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void HLRAlgo_PolyAlgo::NextHide()
|
|
{
|
|
myFound = Standard_False;
|
|
if (myCurShell != 0)
|
|
{
|
|
mySegListIt.Next();
|
|
if (mySegListIt.More())
|
|
myFound = Standard_True;
|
|
}
|
|
|
|
if (!myFound)
|
|
{
|
|
myCurShell++;
|
|
|
|
while (myCurShell <= myNbrShell && !myFound)
|
|
{
|
|
const Handle(HLRAlgo_PolyShellData)& aData = myHShell.ChangeValue(myCurShell);
|
|
mySegListIt.Initialize(aData->Edges());
|
|
if (mySegListIt.More())
|
|
{
|
|
myFound = Standard_True;
|
|
}
|
|
else
|
|
{
|
|
myCurShell++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
HLRAlgo_BiPoint::PointsT& HLRAlgo_PolyAlgo::Hide(HLRAlgo_EdgeStatus& theStatus,
|
|
Standard_Integer& theIndex,
|
|
Standard_Boolean& theReg1,
|
|
Standard_Boolean& theRegn,
|
|
Standard_Boolean& theOutl,
|
|
Standard_Boolean& theIntl)
|
|
{
|
|
HLRAlgo_BiPoint& aBP = mySegListIt.ChangeValue();
|
|
HLRAlgo_BiPoint::PointsT& aPoints = aBP.Points();
|
|
HLRAlgo_BiPoint::IndicesT& anIndices = aBP.Indices();
|
|
theStatus = HLRAlgo_EdgeStatus(0.0,
|
|
(Standard_ShortReal)myTriangle.TolParam,
|
|
1.0,
|
|
(Standard_ShortReal)myTriangle.TolParam);
|
|
theIndex = anIndices.ShapeIndex;
|
|
theReg1 = aBP.Rg1Line();
|
|
theRegn = aBP.RgNLine();
|
|
theOutl = aBP.OutLine();
|
|
theIntl = aBP.IntLine();
|
|
if (aBP.Hidden())
|
|
{
|
|
theStatus.HideAll();
|
|
return aPoints;
|
|
}
|
|
|
|
for (Standard_Integer s = 1; s <= myNbrShell; s++)
|
|
{
|
|
const Handle(HLRAlgo_PolyShellData)& aPsd = myHShell.ChangeValue(s);
|
|
if (!aPsd->Hiding())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
HLRAlgo_PolyShellData::ShellIndices& aShellIndices = aPsd->Indices();
|
|
if (((aShellIndices.Max - anIndices.MinSeg) & 0x80100200) == 0
|
|
&& ((anIndices.MaxSeg - aShellIndices.Min) & 0x80100000) == 0)
|
|
{
|
|
const Standard_Boolean isHidingShell = (s == myCurShell);
|
|
NCollection_Array1<Handle(HLRAlgo_PolyData)>& aFace = aPsd->HidingPolyData();
|
|
const Standard_Integer nbFace = aFace.Upper();
|
|
for (Standard_Integer f = 1; f <= nbFace; f++)
|
|
{
|
|
const Handle(HLRAlgo_PolyData)& aPd = aFace.ChangeValue(f);
|
|
aPd->HideByPolyData(aPoints, myTriangle, anIndices, isHidingShell, theStatus);
|
|
}
|
|
}
|
|
}
|
|
return aPoints;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void HLRAlgo_PolyAlgo::NextShow()
|
|
{
|
|
myFound = Standard_False;
|
|
if (myCurShell != 0)
|
|
{
|
|
mySegListIt.Next();
|
|
if (mySegListIt.More())
|
|
myFound = Standard_True;
|
|
}
|
|
if (!myFound)
|
|
{
|
|
myCurShell++;
|
|
|
|
while (myCurShell <= myNbrShell && !myFound)
|
|
{
|
|
mySegListIt.Initialize(myHShell.ChangeValue(myCurShell)->Edges());
|
|
if (mySegListIt.More())
|
|
{
|
|
myFound = Standard_True;
|
|
}
|
|
else
|
|
{
|
|
myCurShell++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
HLRAlgo_BiPoint::PointsT& HLRAlgo_PolyAlgo::Show(Standard_Integer& Index,
|
|
Standard_Boolean& reg1,
|
|
Standard_Boolean& regn,
|
|
Standard_Boolean& outl,
|
|
Standard_Boolean& intl)
|
|
{
|
|
HLRAlgo_BiPoint& BP = mySegListIt.ChangeValue();
|
|
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;
|
|
}
|