mirror of
https://github.com/Open-Cascade-SAS/OCCT.git
synced 2026-07-05 15:06:57 +08: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.
325 lines
9.5 KiB
C++
325 lines
9.5 KiB
C++
// 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.
|
|
|
|
// szv#4 S4163
|
|
|
|
#include <BRep_Builder.hxx>
|
|
#include <ShapeExtend_Explorer.hxx>
|
|
#include <TopExp_Explorer.hxx>
|
|
#include <TopoDS_Compound.hxx>
|
|
#include <TopoDS_Iterator.hxx>
|
|
#include <TopoDS_Shape.hxx>
|
|
#include <TopoDS_Shell.hxx>
|
|
#include <TopoDS_Wire.hxx>
|
|
#include <TopTools_ListIteratorOfListOfShape.hxx>
|
|
|
|
//=================================================================================================
|
|
|
|
ShapeExtend_Explorer::ShapeExtend_Explorer() {}
|
|
|
|
//=================================================================================================
|
|
|
|
TopoDS_Shape ShapeExtend_Explorer::CompoundFromSeq(
|
|
const Handle(TopTools_HSequenceOfShape)& seqval) const
|
|
{
|
|
BRep_Builder B;
|
|
TopoDS_Compound C;
|
|
B.MakeCompound(C);
|
|
Standard_Integer i, n = seqval->Length();
|
|
for (i = 1; i <= n; i++)
|
|
B.Add(C, seqval->Value(i));
|
|
return C;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
static void FillList(const Handle(TopTools_HSequenceOfShape)& list,
|
|
const TopoDS_Shape& comp,
|
|
const Standard_Boolean expcomp)
|
|
{
|
|
for (TopoDS_Iterator it(comp); it.More(); it.Next())
|
|
{
|
|
const TopoDS_Shape& sub = it.Value();
|
|
if (sub.ShapeType() != TopAbs_COMPOUND)
|
|
list->Append(sub);
|
|
else if (!expcomp)
|
|
list->Append(sub);
|
|
else
|
|
FillList(list, sub, expcomp);
|
|
}
|
|
}
|
|
|
|
Handle(TopTools_HSequenceOfShape) ShapeExtend_Explorer::SeqFromCompound(
|
|
const TopoDS_Shape& comp,
|
|
const Standard_Boolean expcomp) const
|
|
{
|
|
Handle(TopTools_HSequenceOfShape) list = new TopTools_HSequenceOfShape();
|
|
if (comp.IsNull())
|
|
return list;
|
|
if (comp.ShapeType() != TopAbs_COMPOUND)
|
|
{
|
|
list->Append(comp);
|
|
return list;
|
|
}
|
|
FillList(list, comp, expcomp);
|
|
return list;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void ShapeExtend_Explorer::ListFromSeq(const Handle(TopTools_HSequenceOfShape)& seqval,
|
|
TopTools_ListOfShape& lisval,
|
|
const Standard_Boolean clear) const
|
|
{
|
|
if (clear)
|
|
lisval.Clear();
|
|
if (seqval.IsNull())
|
|
return;
|
|
Standard_Integer i, nb = seqval->Length();
|
|
for (i = 1; i <= nb; i++)
|
|
lisval.Append(seqval->Value(i));
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
Handle(TopTools_HSequenceOfShape) ShapeExtend_Explorer::SeqFromList(
|
|
const TopTools_ListOfShape& lisval) const
|
|
{
|
|
Handle(TopTools_HSequenceOfShape) seqval = new TopTools_HSequenceOfShape();
|
|
TopTools_ListIteratorOfListOfShape it;
|
|
for (it.Initialize(lisval); it.More(); it.Next())
|
|
seqval->Append(it.Value());
|
|
return seqval;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
TopAbs_ShapeEnum ShapeExtend_Explorer::ShapeType(const TopoDS_Shape& shape,
|
|
const Standard_Boolean compound) const
|
|
{
|
|
if (shape.IsNull())
|
|
return TopAbs_SHAPE;
|
|
TopAbs_ShapeEnum res = shape.ShapeType();
|
|
if (!compound || res != TopAbs_COMPOUND)
|
|
return res;
|
|
res = TopAbs_SHAPE;
|
|
for (TopoDS_Iterator iter(shape); iter.More(); iter.Next())
|
|
{
|
|
const TopoDS_Shape& sh = iter.Value();
|
|
if (sh.IsNull())
|
|
continue;
|
|
TopAbs_ShapeEnum typ = sh.ShapeType();
|
|
if (typ == TopAbs_COMPOUND)
|
|
typ = ShapeType(sh, compound);
|
|
if (res == TopAbs_SHAPE)
|
|
res = typ;
|
|
// Egalite : OK; Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
|
|
else if (res == TopAbs_EDGE && typ == TopAbs_WIRE)
|
|
res = typ;
|
|
else if (res == TopAbs_WIRE && typ == TopAbs_EDGE)
|
|
continue;
|
|
else if (res == TopAbs_FACE && typ == TopAbs_SHELL)
|
|
res = typ;
|
|
else if (res == TopAbs_SHELL && typ == TopAbs_FACE)
|
|
continue;
|
|
else if (res != typ)
|
|
return TopAbs_COMPOUND;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
TopoDS_Shape ShapeExtend_Explorer::SortedCompound(const TopoDS_Shape& shape,
|
|
const TopAbs_ShapeEnum type,
|
|
const Standard_Boolean explore,
|
|
const Standard_Boolean compound) const
|
|
{
|
|
if (shape.IsNull())
|
|
return shape;
|
|
TopAbs_ShapeEnum typ = shape.ShapeType();
|
|
TopoDS_Shape sh, sh0;
|
|
Standard_Integer nb = 0;
|
|
|
|
// Compound : on le prend, soit tel quel, soit son contenu
|
|
if (typ == TopAbs_COMPOUND || typ == TopAbs_COMPSOLID)
|
|
{
|
|
TopoDS_Compound C;
|
|
BRep_Builder B;
|
|
B.MakeCompound(C);
|
|
for (TopoDS_Iterator it(shape); it.More(); it.Next())
|
|
{
|
|
sh0 = SortedCompound(it.Value(), type, explore, compound);
|
|
if (sh0.IsNull())
|
|
continue;
|
|
sh = sh0;
|
|
typ = sh.ShapeType();
|
|
if (typ == TopAbs_COMPOUND && !compound)
|
|
{
|
|
for (TopoDS_Iterator it2(sh); it2.More(); it2.Next())
|
|
{
|
|
nb++;
|
|
sh = it2.Value();
|
|
B.Add(C, sh);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
nb++;
|
|
B.Add(C, sh);
|
|
}
|
|
}
|
|
if (nb == 0)
|
|
C.Nullify();
|
|
else if (nb == 1)
|
|
return sh;
|
|
return C;
|
|
}
|
|
|
|
// Egalite : OK; Pseudo-Egalite : EDGE/WIRE ou FACE/SHELL
|
|
if (typ == type)
|
|
return shape;
|
|
if (typ == TopAbs_EDGE && type == TopAbs_WIRE)
|
|
{
|
|
BRep_Builder B;
|
|
TopoDS_Wire W;
|
|
B.MakeWire(W);
|
|
B.Add(W, shape);
|
|
return W;
|
|
}
|
|
if (typ == TopAbs_FACE && type == TopAbs_SHELL)
|
|
{
|
|
BRep_Builder B;
|
|
TopoDS_Shell S;
|
|
B.MakeShell(S);
|
|
B.Add(S, shape);
|
|
return S;
|
|
}
|
|
|
|
// Le reste : selon exploration
|
|
if (!explore)
|
|
{
|
|
TopoDS_Shape nulsh;
|
|
return nulsh;
|
|
}
|
|
|
|
// Ici, on doit explorer
|
|
// SOLID + mode COMPOUND : reconduire les SHELLs
|
|
if (typ == TopAbs_SOLID && compound)
|
|
{
|
|
TopoDS_Compound C;
|
|
BRep_Builder B;
|
|
B.MakeCompound(C);
|
|
for (TopoDS_Iterator it(shape); it.More(); it.Next())
|
|
{
|
|
sh0 = SortedCompound(it.Value(), type, explore, compound);
|
|
if (sh0.IsNull())
|
|
continue;
|
|
sh = sh0;
|
|
nb++;
|
|
B.Add(C, sh);
|
|
}
|
|
if (nb == 0)
|
|
C.Nullify();
|
|
else if (nb == 1)
|
|
return sh;
|
|
return C;
|
|
}
|
|
|
|
// Exploration classique
|
|
TopoDS_Compound CC;
|
|
BRep_Builder BB;
|
|
BB.MakeCompound(CC);
|
|
// Standard_Integer iena = Standard_False; //szv#4:S4163:12Mar99 unused
|
|
for (TopExp_Explorer aExp(shape, type); aExp.More(); aExp.Next())
|
|
{
|
|
nb++;
|
|
sh = aExp.Current();
|
|
BB.Add(CC, sh);
|
|
}
|
|
if (nb == 0)
|
|
CC.Nullify();
|
|
else if (nb == 1)
|
|
return sh;
|
|
return CC;
|
|
}
|
|
|
|
//=================================================================================================
|
|
|
|
void ShapeExtend_Explorer::DispatchList(const Handle(TopTools_HSequenceOfShape)& list,
|
|
Handle(TopTools_HSequenceOfShape)& vertices,
|
|
Handle(TopTools_HSequenceOfShape)& edges,
|
|
Handle(TopTools_HSequenceOfShape)& wires,
|
|
Handle(TopTools_HSequenceOfShape)& faces,
|
|
Handle(TopTools_HSequenceOfShape)& shells,
|
|
Handle(TopTools_HSequenceOfShape)& solids,
|
|
Handle(TopTools_HSequenceOfShape)& compsols,
|
|
Handle(TopTools_HSequenceOfShape)& compounds) const
|
|
{
|
|
if (list.IsNull())
|
|
return;
|
|
if (vertices.IsNull())
|
|
vertices = new TopTools_HSequenceOfShape();
|
|
if (edges.IsNull())
|
|
edges = new TopTools_HSequenceOfShape();
|
|
if (wires.IsNull())
|
|
wires = new TopTools_HSequenceOfShape();
|
|
if (faces.IsNull())
|
|
faces = new TopTools_HSequenceOfShape();
|
|
if (shells.IsNull())
|
|
shells = new TopTools_HSequenceOfShape();
|
|
if (solids.IsNull())
|
|
solids = new TopTools_HSequenceOfShape();
|
|
if (compsols.IsNull())
|
|
compsols = new TopTools_HSequenceOfShape();
|
|
if (compounds.IsNull())
|
|
compounds = new TopTools_HSequenceOfShape();
|
|
|
|
Standard_Integer i, nb = list->Length();
|
|
for (i = 1; i <= nb; i++)
|
|
{
|
|
TopoDS_Shape sh = list->Value(i);
|
|
if (sh.IsNull())
|
|
continue;
|
|
switch (sh.ShapeType())
|
|
{
|
|
case TopAbs_VERTEX:
|
|
vertices->Append(sh);
|
|
break;
|
|
case TopAbs_EDGE:
|
|
edges->Append(sh);
|
|
break;
|
|
case TopAbs_WIRE:
|
|
wires->Append(sh);
|
|
break;
|
|
case TopAbs_FACE:
|
|
faces->Append(sh);
|
|
break;
|
|
case TopAbs_SHELL:
|
|
shells->Append(sh);
|
|
break;
|
|
case TopAbs_SOLID:
|
|
solids->Append(sh);
|
|
break;
|
|
case TopAbs_COMPSOLID:
|
|
compsols->Append(sh);
|
|
break;
|
|
case TopAbs_COMPOUND:
|
|
compounds->Append(sh);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|