OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-04-10 18:51:21 +03:00
Code

Fixing remarks

Browse Source
This commit is contained in:
dkulikov 2025-04-03 09:57:36 +01:00
parent d39110dda6
commit 709412d78a
41 changed files with 465 additions and 573 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/DataExchange/TKDESTEP/GTests/FILES.cmake
View File

@ -2,14 +2,13 @@
set(OCCT_TKDESTEP_GTests_FILES_LOCATION "${CMAKE_CURRENT_LIST_DIR}")
set(OCCT_TKDESTEP_GTests_FILES
MergeSTEPEntities_Axis2Placement3dProcessor_Test.cxx
MergeSTEPEntities_BaseTestFixture.hxx
MergeSTEPEntities_CartesianPointProcessor_Test.cxx
MergeSTEPEntities_CircleProcessor_Test.cxx
MergeSTEPEntities_DirectionProcessor_Test.cxx
MergeSTEPEntities_LineProcessor_Test.cxx
MergeSTEPEntities_PlaneProcessor_Test.cxx
MergeSTEPEntities_Merger_Test.cxx
MergeSTEPEntities_VectorProcessor_Test.cxx
StepTidy_BaseTestFixture.pxx
StepTidy_Axis2Placement3dReducer_Test.cxx
StepTidy_CartesianPointReducer_Test.cxx
StepTidy_CircleReducer_Test.cxx
StepTidy_DirectionReducer_Test.cxx
StepTidy_LineReducer_Test.cxx
StepTidy_PlaneReducer_Test.cxx
StepTidy_Merger_Test.cxx
StepTidy_VectorReducer_Test.cxx
)

40
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_Axis2Placement3dProcessor_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_Axis2Placement3dReducer_Test.cxx
View File

@ -11,9 +11,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_Axis2Placement3dProcessor.hxx>
#include <StepTidy_Axis2Placement3dReducer.pxx>
#include <StepGeom_Plane.hxx>
#include <StepRepr_ItemDefinedTransformation.hxx>
@ -30,26 +30,26 @@
#include <StepShape_AdvancedBrepShapeRepresentation.hxx>
#include <StepGeom_SphericalSurface.hxx>
class MergeSTEPEntities_Axis2Placement3dProcessorTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_Axis2Placement3dReducerTest : public StepTidy_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateAxis2Placement3ds()
{
MergeSTEPEntities_Axis2Placement3dProcessor aProcessor(myWS);
StepTidy_Axis2Placement3dReducer aReducer(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
aReducer.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
aReducer.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Axis2Placement3ds with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, DifferentNames)
TEST_F(StepTidy_Axis2Placement3dReducerTest, DifferentNames)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d("Axis1");
@ -73,7 +73,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, DifferentNames)
}
// Check that equal Axis2Placement3ds are merged for StepShape_GeometricCurveSet.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Plane)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepGeom_Plane)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -98,7 +98,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Plane)
}
// Check that equal Axis2Placement3ds are merged for StepRepr_ItemDefinedTransformation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepRepr_ItemDefinedTransformation)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepRepr_ItemDefinedTransformation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -124,7 +124,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepRepr_ItemDefinedTran
}
// Check that equal Axis2Placement3ds are merged for StepGeom_CylindricalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_CylindricalSurface)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepGeom_CylindricalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -149,7 +149,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_CylindricalSurf
}
// Check that equal Axis2Placement3ds are merged for StepShape_ShapeRepresentation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepShape_ShapeRepresentation)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepShape_ShapeRepresentation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -184,7 +184,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepShape_ShapeRepresent
}
// Check that equal Axis2Placement3ds are merged for StepRepr_ConstructiveGeometryRepresentation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepRepr_ConstructiveGeometryRepresentation)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepRepr_ConstructiveGeometryRepresentation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -221,7 +221,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepRepr_ConstructiveGeo
}
// Check that equal Axis2Placement3ds are merged for StepGeom_Circle.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Circle)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepGeom_Circle)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -250,7 +250,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Circle)
}
// Check that equal Axis2Placement3ds are merged for StepVisual_PresentationLayerAssignment.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepVisual_PresentationLayerAssignment)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepVisual_PresentationLayerAssignment)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -291,7 +291,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepVisual_PresentationL
}
// Check that equal Axis2Placement3ds are merged for StepVisual_StyledItem.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepVisual_StyledItem)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepVisual_StyledItem)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -320,7 +320,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepVisual_StyledItem)
}
// Check that equal Axis2Placement3ds are merged for StepGeom_Ellipse.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Ellipse)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepGeom_Ellipse)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -349,7 +349,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Ellipse)
}
// Check that equal Axis2Placement3ds are merged for StepGeom_ConicalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_ConicalSurface)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepGeom_ConicalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -374,7 +374,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_ConicalSurface)
}
// Check that equal Axis2Placement3ds are merged for StepGeom_ToroidalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_ToroidalSurface)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepGeom_ToroidalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -399,7 +399,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_ToroidalSurface
}
// Check that equal Axis2Placement3ds are merged for StepShape_AdvancedBrepShapeRepresentation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepShape_AdvancedBrepShapeRepresentation)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepShape_AdvancedBrepShapeRepresentation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
@ -436,7 +436,7 @@ TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepShape_AdvancedBrepSh
}
// Check that equal Axis2Placement3ds are merged for StepGeom_SphericalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_SphericalSurface)
TEST_F(StepTidy_Axis2Placement3dReducerTest, StepGeom_SphericalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();

10
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_BaseTestFixture.hxx → src/DataExchange/TKDESTEP/GTests/StepTidy_BaseTestFixture.pxx
View File

@ -11,8 +11,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_BaseTestFixture_HeaderFile
#define _MergeSTEPEntities_BaseTestFixture_HeaderFile
#ifndef _StepTidy_BaseTestFixture_HeaderFile
#define _StepTidy_BaseTestFixture_HeaderFile
#include <STEPControl_Controller.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
@ -26,11 +26,11 @@
#include <gtest/gtest.h>
class MergeSTEPEntities_BaseTestFixture : public testing::Test
class StepTidy_BaseTestFixture : public testing::Test
{
protected:
// Initialize the work session and model.
MergeSTEPEntities_BaseTestFixture()
StepTidy_BaseTestFixture()
: myWS()
{
STEPControl_Controller::Init();
@ -191,4 +191,4 @@ protected:
Handle(XSControl_WorkSession) myWS;
};
#endif // _MergeSTEPEntities_BaseTestFixture_HeaderFile
#endif // _StepTidy_BaseTestFixture_HeaderFile

47
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_CartesianPointProcessor_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_CartesianPointReducer_Test.cxx
View File

@ -11,9 +11,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_CartesianPointProcessor.hxx>
#include <StepTidy_CartesianPointReducer.pxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
@ -30,26 +30,26 @@
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_StyledItem.hxx>
class MergeSTEPEntities_CartesianPointProcessorTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_CartesianPointReducerTest : public StepTidy_BaseTestFixture
{
protected:
// Perform removal of duplicate Cartesian points.
TColStd_MapOfTransient replaceDuplicateCartesianPoints()
{
MergeSTEPEntities_CartesianPointProcessor aProcessor(myWS);
StepTidy_CartesianPointReducer aReducer(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
aReducer.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
aReducer.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that points with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, DifferentNames)
TEST_F(StepTidy_CartesianPointReducerTest, DifferentNames)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint("FirstPt");
@ -85,7 +85,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, DifferentNames)
// Check that points with the same coordinates and same names are
// merged for StepGeom_Axis2Placement3d.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Axis2Placement3d)
TEST_F(StepTidy_CartesianPointReducerTest, StepGeom_Axis2Placement3d)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -122,7 +122,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Axis2Placement3d)
// Check that points with the same coordinates and same names are merged
// for StepShape_VertexPoint.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepShape_VertexPoint)
TEST_F(StepTidy_CartesianPointReducerTest, StepShape_VertexPoint)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -148,7 +148,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepShape_VertexPoint)
// Check that points with the same coordinates and same names are merged
// for StepShape_GeometricCurveSet.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepShape_GeometricCurveSet)
TEST_F(StepTidy_CartesianPointReducerTest, StepShape_GeometricCurveSet)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -186,7 +186,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepShape_GeometricCurveSe
// Check that points with the same coordinates and same names are merged
// for StepVisual_PresentationLayerAssignment.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepVisual_PresentationLayerAssignment)
TEST_F(StepTidy_CartesianPointReducerTest, StepVisual_PresentationLayerAssignment)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -230,7 +230,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepVisual_PresentationLay
// Check that points with the same coordinates and same names are merged
// for StepVisual_StyledItem.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepVisual_StyledItem)
TEST_F(StepTidy_CartesianPointReducerTest, StepVisual_StyledItem)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -260,7 +260,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepVisual_StyledItem)
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineCurveWithKnots.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineCurveWithKnots)
TEST_F(StepTidy_CartesianPointReducerTest, StepGeom_BSplineCurveWithKnots)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -270,7 +270,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineCurveWithK
Handle(StepGeom_HArray1OfCartesianPoint) aFirstControlPoints =
new StepGeom_HArray1OfCartesianPoint(1, 1);
aFirstControlPoints->SetValue(1, aPt1);
addToModel(aFirstControlPoints);
Handle(StepGeom_BSplineCurveWithKnots) aFirstCurve = new StepGeom_BSplineCurveWithKnots;
aFirstCurve->Init(new TCollection_HAsciiString,
1,
@ -287,7 +286,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineCurveWithK
Handle(StepGeom_HArray1OfCartesianPoint) aSecondControlPoints =
new StepGeom_HArray1OfCartesianPoint(1, 1);
aSecondControlPoints->SetValue(1, aPt2);
addToModel(aSecondControlPoints);
Handle(StepGeom_BSplineCurveWithKnots) aSecondCurve = new StepGeom_BSplineCurveWithKnots;
aSecondCurve->Init(new TCollection_HAsciiString,
1,
@ -310,7 +308,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineCurveWithK
// Check that points with the same coordinates and same names are merged
// for StepGeom_Line.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Line)
TEST_F(StepTidy_CartesianPointReducerTest, StepGeom_Line)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -336,7 +334,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Line)
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineSurfaceWithKnots.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineSurfaceWithKnots)
TEST_F(StepTidy_CartesianPointReducerTest, StepGeom_BSplineSurfaceWithKnots)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -346,7 +344,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineSurfaceWit
Handle(StepGeom_HArray2OfCartesianPoint) aFirstControlPoints =
new StepGeom_HArray2OfCartesianPoint(1, 1, 1, 1);
aFirstControlPoints->SetValue(1, 1, aPt1);
addToModel(aFirstControlPoints);
Handle(StepGeom_BSplineSurfaceWithKnots) aFirstSurface = new StepGeom_BSplineSurfaceWithKnots;
aFirstSurface->Init(new TCollection_HAsciiString,
1,
@ -367,7 +364,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineSurfaceWit
Handle(StepGeom_HArray2OfCartesianPoint) aSecondControlPoints =
new StepGeom_HArray2OfCartesianPoint(1, 1, 1, 1);
aSecondControlPoints->SetValue(1, 1, aPt2);
addToModel(aSecondControlPoints);
Handle(StepGeom_BSplineSurfaceWithKnots) aSecondSurface = new StepGeom_BSplineSurfaceWithKnots;
aSecondSurface->Init(new TCollection_HAsciiString,
1,
@ -394,7 +390,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineSurfaceWit
// Check that points with the same coordinates and same names are merged
// for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Axis1Placement)
TEST_F(StepTidy_CartesianPointReducerTest, StepGeom_Axis1Placement)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -420,7 +416,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Axis1Placement)
// Check that points with the same coordinates and same names are merged
// for StepRepr_Representation.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepRepr_Representation)
TEST_F(StepTidy_CartesianPointReducerTest, StepRepr_Representation)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -456,8 +452,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepRepr_Representation)
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)
TEST_F(StepTidy_CartesianPointReducerTest, StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
@ -467,7 +462,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
Handle(StepGeom_HArray1OfCartesianPoint) aFirstControlPoints =
new StepGeom_HArray1OfCartesianPoint(1, 1);
aFirstControlPoints->SetValue(1, aPt1);
addToModel(aFirstControlPoints);
Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) aFirstCurve =
new StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve;
aFirstCurve->Init(new TCollection_HAsciiString,
@ -486,7 +480,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
Handle(StepGeom_HArray1OfCartesianPoint) aSecondControlPoints =
new StepGeom_HArray1OfCartesianPoint(1, 1);
aSecondControlPoints->SetValue(1, aPt2);
addToModel(aSecondControlPoints);
Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) aSecondCurve =
new StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve;
aSecondCurve->Init(new TCollection_HAsciiString,
@ -511,7 +504,7 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
TEST_F(StepTidy_CartesianPointReducerTest,
StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)
{
// Creating Cartesian points.
@ -522,7 +515,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
Handle(StepGeom_HArray2OfCartesianPoint) aFirstControlPoints =
new StepGeom_HArray2OfCartesianPoint(1, 1, 1, 1);
aFirstControlPoints->SetValue(1, 1, aPt1);
addToModel(aFirstControlPoints);
Handle(StepGeom_BSplineSurfaceWithKnots) aFirstBSSWN = new StepGeom_BSplineSurfaceWithKnots;
aFirstBSSWN->Init(new TCollection_HAsciiString,
1,
@ -556,7 +548,6 @@ TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
Handle(StepGeom_HArray2OfCartesianPoint) aSecondControlPoints =
new StepGeom_HArray2OfCartesianPoint(1, 1, 1, 1);
aSecondControlPoints->SetValue(1, 1, aPt2);
addToModel(aSecondControlPoints);
Handle(StepGeom_BSplineSurfaceWithKnots) aSecondBSSWN = new StepGeom_BSplineSurfaceWithKnots;
aSecondBSSWN->Init(new TCollection_HAsciiString,
1,

20
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_CircleProcessor_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_CircleReducer_Test.cxx
View File

@ -11,34 +11,34 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_CircleProcessor.hxx>
#include <StepTidy_CircleReducer.pxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepGeom_SeamCurve.hxx>
class MergeSTEPEntities_CircleProcessorTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_CircleReducerTest : public StepTidy_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateCircles()
{
MergeSTEPEntities_CircleProcessor aProcessor(myWS);
StepTidy_CircleReducer aReducer(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
aReducer.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
aReducer.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Circles with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_CircleProcessorTest, DifferentNames)
TEST_F(StepTidy_CircleReducerTest, DifferentNames)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle("Circle1");
@ -70,7 +70,7 @@ TEST_F(MergeSTEPEntities_CircleProcessorTest, DifferentNames)
}
// Check that equal Circles are merged for StepShape_EdgeCurve.
TEST_F(MergeSTEPEntities_CircleProcessorTest, StepShape_EdgeCurve)
TEST_F(StepTidy_CircleReducerTest, StepShape_EdgeCurve)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle();
@ -103,7 +103,7 @@ TEST_F(MergeSTEPEntities_CircleProcessorTest, StepShape_EdgeCurve)
}
// Check that equal Circles are merged for StepGeom_SurfaceCurve.
TEST_F(MergeSTEPEntities_CircleProcessorTest, StepGeom_SurfaceCurve)
TEST_F(StepTidy_CircleReducerTest, StepGeom_SurfaceCurve)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle();
@ -134,7 +134,7 @@ TEST_F(MergeSTEPEntities_CircleProcessorTest, StepGeom_SurfaceCurve)
}
// Check that equal Circles are merged for StepGeom_SeamCurve.
TEST_F(MergeSTEPEntities_CircleProcessorTest, StepGeom_SeamCurve)
TEST_F(StepTidy_CircleReducerTest, StepGeom_SeamCurve)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle();

20
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_DirectionProcessor_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_DirectionReducer_Test.cxx
View File

@ -11,33 +11,33 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_DirectionProcessor.hxx>
#include <StepTidy_DirectionReducer.pxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
class MergeSTEPEntities_DirectionProcessorTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_DirectionReducerTest : public StepTidy_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateDirections()
{
MergeSTEPEntities_DirectionProcessor aProcessor(myWS);
StepTidy_DirectionReducer aReducer(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
aReducer.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
aReducer.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that directions with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, DifferentNames)
TEST_F(StepTidy_DirectionReducerTest, DifferentNames)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection("dir1");
@ -62,7 +62,7 @@ TEST_F(MergeSTEPEntities_DirectionProcessorTest, DifferentNames)
// Check that directions with the same coordinates and same names are
// merged for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Axis1Placement)
TEST_F(StepTidy_DirectionReducerTest, StepGeom_Axis1Placement)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();
@ -97,7 +97,7 @@ TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Axis1Placement)
// Check that directions with the same coordinates and same names are
// merged for StepGeom_Axis2Placement.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Axis2Placement)
TEST_F(StepTidy_DirectionReducerTest, StepGeom_Axis2Placement)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();
@ -132,7 +132,7 @@ TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Axis2Placement)
// Check that points with the same coordinates and same names are
// merged for StepGeom_Vector.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Vector)
TEST_F(StepTidy_DirectionReducerTest, StepGeom_Vector)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();

24
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_LineProcessor_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_LineReducer_Test.cxx
View File

@ -11,9 +11,9 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_LineProcessor.hxx>
#include <StepTidy_LineReducer.pxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepGeom_TrimmedCurve.hxx>
@ -22,26 +22,26 @@
#include <StepGeom_SeamCurve.hxx>
#include <StepRepr_RepresentationContext.hxx>
class MergeSTEPEntities_LineProcessorTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_LineReducerTest : public StepTidy_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateLines()
{
MergeSTEPEntities_LineProcessor aProcessor(myWS);
StepTidy_LineReducer aReducer(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
aReducer.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
aReducer.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Lines with different names are not merged.
TEST_F(MergeSTEPEntities_LineProcessorTest, DifferentNames)
TEST_F(StepTidy_LineReducerTest, DifferentNames)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine("Line1");
@ -73,7 +73,7 @@ TEST_F(MergeSTEPEntities_LineProcessorTest, DifferentNames)
}
// Check that equal Lines are merged for StepShape_EdgeCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepShape_EdgeCurve)
TEST_F(StepTidy_LineReducerTest, StepShape_EdgeCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
@ -106,7 +106,7 @@ TEST_F(MergeSTEPEntities_LineProcessorTest, StepShape_EdgeCurve)
}
// Check that equal Lines are merged for StepGeom_TrimmedCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_TrimmedCurve)
TEST_F(StepTidy_LineReducerTest, StepGeom_TrimmedCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
@ -141,7 +141,7 @@ TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_TrimmedCurve)
}
// Check that equal Lines are merged for StepGeom_SurfaceCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_SurfaceCurve)
TEST_F(StepTidy_LineReducerTest, StepGeom_SurfaceCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
@ -172,7 +172,7 @@ TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_SurfaceCurve)
}
// Check that equal Lines are merged for StepRepr_DefinitionalRepresentation.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepRepr_DefinitionalRepresentation)
TEST_F(StepTidy_LineReducerTest, StepRepr_DefinitionalRepresentation)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
@ -208,7 +208,7 @@ TEST_F(MergeSTEPEntities_LineProcessorTest, StepRepr_DefinitionalRepresentation)
}
// Check that equal Lines are merged for StepGeom_SeamCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_SeamCurve)
TEST_F(StepTidy_LineReducerTest, StepGeom_SeamCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();

12
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_Merger_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_Merger_Test.cxx
View File

@ -11,13 +11,13 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_Merger.hxx>
#include <StepTidy_DuplicateCleaner.hxx>
#include <StepGeom_Axis1Placement.hxx>
class MergeSTEPEntities_MergerTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_DuplicateCleanerTest : public StepTidy_BaseTestFixture
{
protected:
// Get the number of entities of the specified type.
@ -39,13 +39,13 @@ protected:
//! Perform removal of duplicate entities points.
void performRemoval()
{
MergeSTEPEntities_Merger aMerger(myWS);
StepTidy_DuplicateCleaner aMerger(myWS);
aMerger.Perform();
}
};
// Check that entities with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_MergerTest, DifferentEntities)
TEST_F(StepTidy_DuplicateCleanerTest, DifferentEntities)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection("dir1");
@ -75,7 +75,7 @@ TEST_F(MergeSTEPEntities_MergerTest, DifferentEntities)
// Check that entities with the same coordinates and same names are
// merged for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_MergerTest, EqualEntities)
TEST_F(StepTidy_DuplicateCleanerTest, EqualEntities)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();

18
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_PlaneProcessor_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_PlaneReducer_Test.cxx
View File

@ -11,34 +11,34 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_PlaneProcessor.hxx>
#include <StepTidy_PlaneReducer.pxx>
#include <StepShape_AdvancedFace.hxx>
#include <StepGeom_Pcurve.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
class MergeSTEPEntities_PlaneProcessorTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_PlaneReducerTest : public StepTidy_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicatePlanes()
{
MergeSTEPEntities_PlaneProcessor aProcessor(myWS);
StepTidy_PlaneReducer aReducer(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
aReducer.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
aReducer.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Planes with different names are not merged.
TEST_F(MergeSTEPEntities_PlaneProcessorTest, DifferentNames)
TEST_F(StepTidy_PlaneReducerTest, DifferentNames)
{
// Creating Planes.
Handle(StepGeom_Plane) aPlane1 = addPlane("Plane1");
@ -68,7 +68,7 @@ TEST_F(MergeSTEPEntities_PlaneProcessorTest, DifferentNames)
}
// Check that equal Planes are merged for StepShape_AdvancedFace.
TEST_F(MergeSTEPEntities_PlaneProcessorTest, StepShape_AdvancedFace)
TEST_F(StepTidy_PlaneReducerTest, StepShape_AdvancedFace)
{
// Creating Planes.
Handle(StepGeom_Plane) aPlane1 = addPlane();
@ -99,7 +99,7 @@ TEST_F(MergeSTEPEntities_PlaneProcessorTest, StepShape_AdvancedFace)
}
// Check that equal Planes are merged for StepGeom_Pcurve.
TEST_F(MergeSTEPEntities_PlaneProcessorTest, StepGeom_Pcurve)
TEST_F(StepTidy_PlaneReducerTest, StepGeom_Pcurve)
{
// Creating Planes.
Handle(StepGeom_Plane) aPlane1 = addPlane();

16
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_VectorProcessor_Test.cxx → src/DataExchange/TKDESTEP/GTests/StepTidy_VectorReducer_Test.cxx
View File

@ -11,32 +11,32 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include "MergeSTEPEntities_BaseTestFixture.hxx"
#include "StepTidy_BaseTestFixture.pxx"
#include <MergeSTEPEntities_VectorProcessor.hxx>
#include <StepTidy_VectorReducer.pxx>
#include <StepGeom_Line.hxx>
class MergeSTEPEntities_VectorProcessorTest : public MergeSTEPEntities_BaseTestFixture
class StepTidy_VectorReducerTest : public StepTidy_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateVectors()
{
MergeSTEPEntities_VectorProcessor aProcessor(myWS);
StepTidy_VectorReducer aReducer(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
aReducer.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
aReducer.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Vectors with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_VectorProcessorTest, DifferentNames)
TEST_F(StepTidy_VectorReducerTest, DifferentNames)
{
// Creating Vectors.
Handle(StepGeom_Vector) aVec1 = addVector("vec1");
@ -64,7 +64,7 @@ TEST_F(MergeSTEPEntities_VectorProcessorTest, DifferentNames)
// Check that Vectors with the same coordinates and same names are
// merged for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_VectorProcessorTest, StepGeom_Line)
TEST_F(StepTidy_VectorReducerTest, StepGeom_Line)
{
// Creating Vectors.
Handle(StepGeom_Vector) aVec1 = addVector();

30
src/DataExchange/TKDESTEP/MergeSTEPEntities/FILES.cmake
View File

@ -1,30 +0,0 @@
# Source files for STEPControl package
set(OCCT_MergeSTEPEntities_FILES_LOCATION "${CMAKE_CURRENT_LIST_DIR}")
set(OCCT_MergeSTEPEntities_FILES
MergeSTEPEntities_Axis2Placement2dHasher.hxx
MergeSTEPEntities_Axis2Placement3dHasher.hxx
MergeSTEPEntities_Axis2Placement3dProcessor.cxx
MergeSTEPEntities_Axis2Placement3dProcessor.hxx
MergeSTEPEntities_CartesianPointHasher.hxx
MergeSTEPEntities_CartesianPointProcessor.cxx
MergeSTEPEntities_CartesianPointProcessor.hxx
MergeSTEPEntities_CircleHasher.hxx
MergeSTEPEntities_CircleProcessor.cxx
MergeSTEPEntities_CircleProcessor.hxx
MergeSTEPEntities_DirectionHasher.hxx
MergeSTEPEntities_DirectionProcessor.cxx
MergeSTEPEntities_DirectionProcessor.hxx
MergeSTEPEntities_EntityProcessor.hxx
MergeSTEPEntities_LineHasher.hxx
MergeSTEPEntities_LineProcessor.cxx
MergeSTEPEntities_LineProcessor.hxx
MergeSTEPEntities_Merger.cxx
MergeSTEPEntities_Merger.hxx
MergeSTEPEntities_PlaneHasher.hxx
MergeSTEPEntities_PlaneProcessor.cxx
MergeSTEPEntities_PlaneProcessor.hxx
MergeSTEPEntities_VectorHasher.hxx
MergeSTEPEntities_VectorProcessor.cxx
MergeSTEPEntities_VectorProcessor.hxx
)

46
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Merger.hxx
View File

@ -1,46 +0,0 @@
// Copyright (c) 2025 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 _MergeSTEPEntities_Merger_HeaderFile
#define _MergeSTEPEntities_Merger_HeaderFile
#include <TColStd_MapOfTransient.hxx>
class XSControl_WorkSession;
//! A class to merge STEP entities.
//! This class is used to merge equal STEP entities in the work session and remove duplicates.
//! More detailed information about merging entities cam be found in
//! MergeSTEPEntities_EntityProcessor class and its descendants.
class MergeSTEPEntities_Merger
{
public:
//! Constructor.
//! @param theWS the work session to merge entities in.
Standard_EXPORT MergeSTEPEntities_Merger(Handle(XSControl_WorkSession) theWS);
//! Perform the merging of entities.
//! All entities in a model stored in the provided work session that are considered equal to
//! each other will be merged, and duplicates will be removed.
Standard_EXPORT void Perform();
private:
//! Remove entities from the work session.
//! @param theToRemove the entities to remove.
void removeEntities(const TColStd_MapOfTransient& theToRemove);
private:
Handle(XSControl_WorkSession) myWS; //!< The work session containing the model with entities.
};
#endif // _MergeSTEPEntities_Merger_HeaderFile

2
src/DataExchange/TKDESTEP/PACKAGES.cmake
View File

@ -41,5 +41,5 @@ set(OCCT_TKDESTEP_LIST_OF_PACKAGES
APIHeaderSection
HeaderSection
DESTEP
MergeSTEPEntities
StepTidy
)

6
src/DataExchange/TKDESTEP/RWStepGeom/RWStepGeom_RWBSplineCurveWithKnots.cxx
View File

@ -312,6 +312,12 @@ void RWStepGeom_RWBSplineCurveWithKnots::Check(const Handle(StepGeom_BSplineCurv
{
ach->AddFail("ERROR: No.of KnotMultiplicities not equal No.of Knots");
}
if (nbMult == 0)
{
ach->AddFail("ERROR: No.of KnotMultiplicities is equal to 0");
return;
}
Standard_Integer i; // svv Jan 10 2000: porting on DEC
for (i = 1; i <= nbMult - 1; i++)
{

30
src/DataExchange/TKDESTEP/StepTidy/FILES.cmake Normal file
View File

@ -0,0 +1,30 @@
# Source files for StepTidy package
set(OCCT_StepTidy_FILES_LOCATION "${CMAKE_CURRENT_LIST_DIR}")
set(OCCT_StepTidy_FILES
StepTidy_Axis2Placement2dHasher.pxx
StepTidy_Axis2Placement3dHasher.pxx
StepTidy_Axis2Placement3dReducer.cxx
StepTidy_Axis2Placement3dReducer.pxx
StepTidy_CartesianPointHasher.pxx
StepTidy_CartesianPointReducer.cxx
StepTidy_CartesianPointReducer.pxx
StepTidy_CircleHasher.pxx
StepTidy_CircleReducer.cxx
StepTidy_CircleReducer.pxx
StepTidy_DirectionHasher.pxx
StepTidy_DirectionReducer.cxx
StepTidy_DirectionReducer.pxx
StepTidy_EntityReducer.pxx
StepTidy_LineHasher.pxx
StepTidy_LineReducer.cxx
StepTidy_LineReducer.pxx
StepTidy_DuplicateCleaner.cxx
StepTidy_DuplicateCleaner.hxx
StepTidy_PlaneHasher.pxx
StepTidy_PlaneReducer.cxx
StepTidy_PlaneReducer.pxx
StepTidy_VectorHasher.pxx
StepTidy_VectorReducer.cxx
StepTidy_VectorReducer.pxx
)

26
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement2dHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_Axis2Placement2dHasher.pxx
View File

@ -11,27 +11,27 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_Axis2Placement2dHasher_HeaderFile
#define _MergeSTEPEntities_Axis2Placement2dHasher_HeaderFile
#ifndef _StepTidy_Axis2Placement2dHasher_HeaderFile
#define _StepTidy_Axis2Placement2dHasher_HeaderFile
#include <StepTidy_CartesianPointHasher.pxx>
#include <StepTidy_DirectionHasher.pxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Axis2Placement2d.hxx>
#include <MergeSTEPEntities_CartesianPointHasher.hxx>
#include <MergeSTEPEntities_DirectionHasher.hxx>
//! OCCT-style hasher for StepGeom_Axis2Placement2d entities.
//! Currently only used for implementation of hasher for StepGeom_Circle.
struct MergeSTEPEntities_Axis2Placement2dHasher
struct StepTidy_Axis2Placement2dHasher
{
// Hashes the axis placements.
std::size_t operator()(const Handle(StepGeom_Axis2Placement2d)& thePlacement) const noexcept
{
// Prepare an array of hashes for the location, axis, and ref direction.
// Optimal seed is used for the axis and ref direction if they are not present.
const size_t aHashes[2]{MergeSTEPEntities_CartesianPointHasher{}(thePlacement->Location()),
const size_t aHashes[2]{StepTidy_CartesianPointHasher{}(thePlacement->Location()),
thePlacement->HasRefDirection()
? MergeSTEPEntities_DirectionHasher{}(thePlacement->RefDirection())
? StepTidy_DirectionHasher{}(thePlacement->RefDirection())
: opencascade::MurmurHash::optimalSeed()};
const size_t aHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (thePlacement->Name().IsNull())
@ -61,8 +61,8 @@ struct MergeSTEPEntities_Axis2Placement2dHasher
}
// Compare location, axis, and ref direction.
const bool isSameLocation = MergeSTEPEntities_CartesianPointHasher{}(thePlacement1->Location(),
thePlacement2->Location());
const bool isSameLocation =
StepTidy_CartesianPointHasher{}(thePlacement1->Location(), thePlacement2->Location());
// Have to check if the axis is present and compare it.
// Have to check if the ref direction is present and compare it.
const bool isSameRefDirectionFlag =
@ -70,11 +70,11 @@ struct MergeSTEPEntities_Axis2Placement2dHasher
const bool isSameRefDirection =
isSameRefDirectionFlag
&& (!thePlacement1->HasRefDirection()
|| MergeSTEPEntities_DirectionHasher{}(thePlacement1->RefDirection(),
thePlacement2->RefDirection()));
|| StepTidy_DirectionHasher{}(thePlacement1->RefDirection(),
thePlacement2->RefDirection()));
return isSameLocation && isSameRefDirection;
}
};
#endif // _MergeSTEPEntities_Axis2Placement2dHasher_HeaderFile
#endif // _StepTidy_Axis2Placement2dHasher_HeaderFile

35
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement3dHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_Axis2Placement3dHasher.pxx
View File

@ -11,30 +11,29 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_Axis2Placement3dHasher_HeaderFile
#define _MergeSTEPEntities_Axis2Placement3dHasher_HeaderFile
#ifndef _StepTidy_Axis2Placement3dHasher_HeaderFile
#define _StepTidy_Axis2Placement3dHasher_HeaderFile
#include <StepTidy_CartesianPointHasher.pxx>
#include <StepTidy_DirectionHasher.pxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <MergeSTEPEntities_CartesianPointHasher.hxx>
#include <MergeSTEPEntities_DirectionHasher.hxx>
//! OCCT-style hasher for StepGeom_Axis2Placement3d entities.
struct MergeSTEPEntities_Axis2Placement3dHasher
struct StepTidy_Axis2Placement3dHasher
{
// Hashes the axis placements.
std::size_t operator()(const Handle(StepGeom_Axis2Placement3d)& thePlacement) const noexcept
{
// Prepare an array of hashes for the location, axis, and ref direction.
// Optimal seed is used for the axis and ref direction if they are not present.
const size_t aHashes[3]{MergeSTEPEntities_CartesianPointHasher{}(thePlacement->Location()),
thePlacement->HasAxis()
? MergeSTEPEntities_DirectionHasher{}(thePlacement->Axis())
const size_t aHashes[3]{
StepTidy_CartesianPointHasher{}(thePlacement->Location()),
thePlacement->HasAxis() ? StepTidy_DirectionHasher{}(thePlacement->Axis())
: opencascade::MurmurHash::optimalSeed(),
thePlacement->HasRefDirection()
? MergeSTEPEntities_DirectionHasher{}(thePlacement->RefDirection())
: opencascade::MurmurHash::optimalSeed()};
thePlacement->HasRefDirection() ? StepTidy_DirectionHasher{}(thePlacement->RefDirection())
: opencascade::MurmurHash::optimalSeed()};
const size_t aHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (thePlacement->Name().IsNull())
{
@ -63,25 +62,25 @@ struct MergeSTEPEntities_Axis2Placement3dHasher
}
// Compare location, axis, and ref direction.
const bool isSameLocation = MergeSTEPEntities_CartesianPointHasher{}(thePlacement1->Location(),
thePlacement2->Location());
const bool isSameLocation =
StepTidy_CartesianPointHasher{}(thePlacement1->Location(), thePlacement2->Location());
// Have to check if the axis is present and compare it.
const bool isSameAxisFlag = thePlacement1->HasAxis() == thePlacement2->HasAxis();
const bool isSameAxis =
isSameAxisFlag
&& (!thePlacement1->HasAxis()
|| MergeSTEPEntities_DirectionHasher{}(thePlacement1->Axis(), thePlacement2->Axis()));
|| StepTidy_DirectionHasher{}(thePlacement1->Axis(), thePlacement2->Axis()));
// Have to check if the ref direction is present and compare it.
const bool isSameRefDirectionFlag =
thePlacement1->HasRefDirection() == thePlacement2->HasRefDirection();
const bool isSameRefDirection =
isSameRefDirectionFlag
&& (!thePlacement1->HasRefDirection()
|| MergeSTEPEntities_DirectionHasher{}(thePlacement1->RefDirection(),
thePlacement2->RefDirection()));
|| StepTidy_DirectionHasher{}(thePlacement1->RefDirection(),
thePlacement2->RefDirection()));
return isSameLocation && isSameAxis && isSameRefDirection;
}
};
#endif // _MergeSTEPEntities_Axis2Placement3dHasher_HeaderFile
#endif // _StepTidy_Axis2Placement3dHasher_HeaderFile

33
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement3dProcessor.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_Axis2Placement3dReducer.cxx
View File

@ -11,7 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MergeSTEPEntities_Axis2Placement3dProcessor.hxx>
#include <StepTidy_Axis2Placement3dReducer.pxx>
#include <StepGeom_Plane.hxx>
#include <StepRepr_ItemDefinedTransformation.hxx>
@ -29,10 +29,9 @@
//==================================================================================================
MergeSTEPEntities_Axis2Placement3dProcessor::MergeSTEPEntities_Axis2Placement3dProcessor(
StepTidy_Axis2Placement3dReducer::StepTidy_Axis2Placement3dReducer(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Axis2Placement3d,
MergeSTEPEntities_Axis2Placement3dHasher>(theWS)
: StepTidy_EntityReducer<StepGeom_Axis2Placement3d, StepTidy_Axis2Placement3dHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepGeom_Plane), replacePlane);
registerReplacer(STANDARD_TYPE(StepRepr_ItemDefinedTransformation),
@ -55,7 +54,7 @@ MergeSTEPEntities_Axis2Placement3dProcessor::MergeSTEPEntities_Axis2Placement3dP
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replacePlane(
bool StepTidy_Axis2Placement3dReducer::replacePlane(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -71,7 +70,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replacePlane(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceItemDefinedTransformation(
bool StepTidy_Axis2Placement3dReducer::replaceItemDefinedTransformation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -94,7 +93,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceItemDefinedTransformati
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceCylindricalSurface(
bool StepTidy_Axis2Placement3dReducer::replaceCylindricalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -111,7 +110,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceCylindricalSurface(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceShapeRepresentation(
bool StepTidy_Axis2Placement3dReducer::replaceShapeRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -133,7 +132,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceShapeRepresentation(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceConstructiveGeometryRepresentation(
bool StepTidy_Axis2Placement3dReducer::replaceConstructiveGeometryRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -155,7 +154,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceConstructiveGeometryRep
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceCircle(
bool StepTidy_Axis2Placement3dReducer::replaceCircle(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -172,7 +171,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceCircle(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replacePresentationLayerAssignment(
bool StepTidy_Axis2Placement3dReducer::replacePresentationLayerAssignment(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -195,7 +194,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replacePresentationLayerAssign
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceStyledItem(
bool StepTidy_Axis2Placement3dReducer::replaceStyledItem(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -211,7 +210,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceStyledItem(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceEllipse(
bool StepTidy_Axis2Placement3dReducer::replaceEllipse(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -228,7 +227,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceEllipse(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceConicalSurface(
bool StepTidy_Axis2Placement3dReducer::replaceConicalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -244,7 +243,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceConicalSurface(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceToroidalSurface(
bool StepTidy_Axis2Placement3dReducer::replaceToroidalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -261,7 +260,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceToroidalSurface(
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceAdvancedBrepShapeRepresentation(
bool StepTidy_Axis2Placement3dReducer::replaceAdvancedBrepShapeRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -283,7 +282,7 @@ bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceAdvancedBrepShapeRepres
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceSphericalSurface(
bool StepTidy_Axis2Placement3dReducer::replaceSphericalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)

18
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement3dProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_Axis2Placement3dReducer.pxx
View File

@ -11,25 +11,23 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_Axis2Placement3dProcessor_HeaderFile
#define _MergeSTEPEntities_Axis2Placement3dProcessor_HeaderFile
#ifndef _StepTidy_Axis2Placement3dReducer_HeaderFile
#define _StepTidy_Axis2Placement3dReducer_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_Axis2Placement3dHasher.hxx>
#include <StepTidy_EntityReducer.pxx>
#include <StepTidy_Axis2Placement3dHasher.pxx>
#include <StepGeom_Axis2Placement3d.hxx>
//! Processor for merging StepGeom_Axis2Placement3d entities.
//! This processor merges axis placements with the same location, axis, and ref direction.
class MergeSTEPEntities_Axis2Placement3dProcessor
: public MergeSTEPEntities_EntityProcessor<StepGeom_Axis2Placement3d,
MergeSTEPEntities_Axis2Placement3dHasher>
class StepTidy_Axis2Placement3dReducer
: public StepTidy_EntityReducer<StepGeom_Axis2Placement3d, StepTidy_Axis2Placement3dHasher>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_Axis2Placement3dProcessor(
const Handle(XSControl_WorkSession)& theWS);
Standard_EXPORT StepTidy_Axis2Placement3dReducer(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replaces the old axis placement with the new one in the StepGeom_Plane entity.
@ -157,4 +155,4 @@ private:
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_DirectionProcessor_HeaderFile
#endif // _StepTidy_DirectionReducer_HeaderFile

8
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CartesianPointHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_CartesianPointHasher.pxx
View File

@ -11,15 +11,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_CartesianPointHasher_HeaderFile
#define _MergeSTEPEntities_CartesianPointHasher_HeaderFile
#ifndef _StepTidy_CartesianPointHasher_HeaderFile
#define _StepTidy_CartesianPointHasher_HeaderFile
#include <Standard_HashUtils.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_CartesianPoint entities.
struct MergeSTEPEntities_CartesianPointHasher
struct StepTidy_CartesianPointHasher
{
// Hashes the Cartesian point by its name and coordinates.
std::size_t operator()(const Handle(StepGeom_CartesianPoint)& theCartesianPoint) const noexcept
@ -71,4 +71,4 @@ struct MergeSTEPEntities_CartesianPointHasher
}
};
#endif // _MergeSTEPEntities_CartesianPointHasher_HeaderFile
#endif // _StepTidy_CartesianPointHasher_HeaderFile

38
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CartesianPointProcessor.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_CartesianPointReducer.cxx
View File

@ -11,7 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MergeSTEPEntities_CartesianPointProcessor.hxx>
#include <StepTidy_CartesianPointReducer.pxx>
#include <Interface_Graph.hxx>
#include <StepGeom_Axis1Placement.hxx>
@ -29,10 +29,9 @@
//==================================================================================================
MergeSTEPEntities_CartesianPointProcessor::MergeSTEPEntities_CartesianPointProcessor(
StepTidy_CartesianPointReducer::StepTidy_CartesianPointReducer(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_CartesianPoint,
MergeSTEPEntities_CartesianPointHasher>(theWS)
: StepTidy_EntityReducer<StepGeom_CartesianPoint, StepTidy_CartesianPointHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepGeom_Axis1Placement), replaceAxis1Placement);
registerReplacer(STANDARD_TYPE(StepGeom_Axis2Placement3d), replaceAxis2Placement3d);
@ -53,7 +52,7 @@ MergeSTEPEntities_CartesianPointProcessor::MergeSTEPEntities_CartesianPointProce
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceAxis2Placement3d(
bool StepTidy_CartesianPointReducer::replaceAxis2Placement3d(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -70,7 +69,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceAxis2Placement3d(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceVertexPoint(
bool StepTidy_CartesianPointReducer::replaceVertexPoint(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -86,7 +85,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceVertexPoint(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceGeometricCurveSet(
bool StepTidy_CartesianPointReducer::replaceGeometricCurveSet(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -107,7 +106,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceGeometricCurveSet(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replacePresentationLayerAssignment(
bool StepTidy_CartesianPointReducer::replacePresentationLayerAssignment(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -129,7 +128,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replacePresentationLayerAssignme
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceStyledItem(
bool StepTidy_CartesianPointReducer::replaceStyledItem(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -145,7 +144,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceStyledItem(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineCurveWithKnots(
bool StepTidy_CartesianPointReducer::replaceBSplineCurveWithKnots(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -168,7 +167,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineCurveWithKnots(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceLine(
bool StepTidy_CartesianPointReducer::replaceLine(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -184,7 +183,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceLine(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineSurfaceWithKnots(
bool StepTidy_CartesianPointReducer::replaceBSplineSurfaceWithKnots(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -213,7 +212,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineSurfaceWithKnots(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceAxis1Placement(
bool StepTidy_CartesianPointReducer::replaceAxis1Placement(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -229,7 +228,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceAxis1Placement(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceRepresentation(
bool StepTidy_CartesianPointReducer::replaceRepresentation(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -251,7 +250,7 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceRepresentation(
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineCurveWithKnotsAndRationalBSplineCurve(
bool StepTidy_CartesianPointReducer::replaceBSplineCurveWithKnotsAndRationalBSplineCurve(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -274,11 +273,10 @@ bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineCurveWithKnotsAndR
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::
replaceBSplineSurfaceWithKnotsAndRationalBSplineSurface(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_CartesianPointReducer::replaceBSplineSurfaceWithKnotsAndRationalBSplineSurface(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) aSharing =
Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)::DownCast(theSharing);

20
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CartesianPointProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_CartesianPointReducer.pxx
View File

@ -11,28 +11,26 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_CartesianPointProcessor_HeaderFile
#define _MergeSTEPEntities_CartesianPointProcessor_HeaderFile
#ifndef _StepTidy_CartesianPointReducer_HeaderFile
#define _StepTidy_CartesianPointReducer_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_CartesianPointHasher.hxx>
#include <StepTidy_EntityReducer.pxx>
#include <StepTidy_CartesianPointHasher.pxx>
#include <StepGeom_CartesianPoint.hxx>
//! Processor for merging StepGeom_CartesianPoint entities.
//! This processor is responsible for merging Cartesian points with the same coordinates and names.
//! It is used to remove duplicate Cartesian points from the STEP model.
//! See MergeSTEPEntities_EntityProcessor for the description of the processor workflow.
class MergeSTEPEntities_CartesianPointProcessor
: public MergeSTEPEntities_EntityProcessor<StepGeom_CartesianPoint,
MergeSTEPEntities_CartesianPointHasher>
//! See StepTidy_EntityReducer for the description of the Reducer workflow.
class StepTidy_CartesianPointReducer
: public StepTidy_EntityReducer<StepGeom_CartesianPoint, StepTidy_CartesianPointHasher>
{
public:
//! Constructor. Accepts a work session containing the model to process.
//! Registers replacer functions for all supported sharing entities.
//! @param theWS Work session.
Standard_EXPORT MergeSTEPEntities_CartesianPointProcessor(
const Handle(XSControl_WorkSession)& theWS);
Standard_EXPORT StepTidy_CartesianPointReducer(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replaces the old Cartesian point with the new Cartesian point in
@ -160,4 +158,4 @@ private:
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_CartesianPointProcessor_HeaderFile
#endif // _StepTidy_CartesianPointReducer_HeaderFile

24
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CircleHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_CircleHasher.pxx
View File

@ -11,27 +11,27 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_CircleHasher_HeaderFile
#define _MergeSTEPEntities_CircleHasher_HeaderFile
#ifndef _StepTidy_CircleHasher_HeaderFile
#define _StepTidy_CircleHasher_HeaderFile
#include <MergeSTEPEntities_Axis2Placement2dHasher.hxx>
#include <MergeSTEPEntities_Axis2Placement3dHasher.hxx>
#include <StepTidy_Axis2Placement2dHasher.pxx>
#include <StepTidy_Axis2Placement3dHasher.pxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Circle.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Circle entities.
struct MergeSTEPEntities_CircleHasher
struct StepTidy_CircleHasher
{
//! Returns hash for a Circle entity.
std::size_t operator()(const Handle(StepGeom_Circle)& theCircle) const noexcept
{
const size_t aPositionHash =
!theCircle->Position().Axis2Placement2d().IsNull()
? MergeSTEPEntities_Axis2Placement2dHasher{}(theCircle->Position().Axis2Placement2d())
? StepTidy_Axis2Placement2dHasher{}(theCircle->Position().Axis2Placement2d())
: !theCircle->Position().Axis2Placement3d().IsNull()
? MergeSTEPEntities_Axis2Placement3dHasher{}(theCircle->Position().Axis2Placement3d())
? StepTidy_Axis2Placement3dHasher{}(theCircle->Position().Axis2Placement3d())
: opencascade::MurmurHash::optimalSeed();
const size_t aRadiusHash = opencascade::hash(static_cast<int>(theCircle->Radius()));
@ -72,16 +72,16 @@ struct MergeSTEPEntities_CircleHasher
if (theCircle1->Position().CaseNumber() == 1)
{
if (!MergeSTEPEntities_Axis2Placement2dHasher{}(theCircle1->Position().Axis2Placement2d(),
theCircle2->Position().Axis2Placement2d()))
if (!StepTidy_Axis2Placement2dHasher{}(theCircle1->Position().Axis2Placement2d(),
theCircle2->Position().Axis2Placement2d()))
{
return false;
}
}
else if (theCircle1->Position().CaseNumber() == 2)
{
if (!MergeSTEPEntities_Axis2Placement3dHasher{}(theCircle1->Position().Axis2Placement3d(),
theCircle2->Position().Axis2Placement3d()))
if (!StepTidy_Axis2Placement3dHasher{}(theCircle1->Position().Axis2Placement3d(),
theCircle2->Position().Axis2Placement3d()))
{
return false;
}
@ -98,4 +98,4 @@ struct MergeSTEPEntities_CircleHasher
}
};
#endif // _MergeSTEPEntities_CircleHasher_HeaderFile
#endif // _StepTidy_CircleHasher_HeaderFile

41
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CircleProcessor.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_CircleReducer.cxx
View File

@ -11,20 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// Copyright (c) 2025 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 <MergeSTEPEntities_CircleProcessor.hxx>
#include <StepTidy_CircleReducer.pxx>
#include <Interface_Graph.hxx>
#include <StepShape_EdgeCurve.hxx>
@ -33,9 +20,8 @@
//==================================================================================================
MergeSTEPEntities_CircleProcessor::MergeSTEPEntities_CircleProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Circle, MergeSTEPEntities_CircleHasher>(theWS)
StepTidy_CircleReducer::StepTidy_CircleReducer(const Handle(XSControl_WorkSession)& theWS)
: StepTidy_EntityReducer<StepGeom_Circle, StepTidy_CircleHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepShape_EdgeCurve), replaceEdgeCurve);
registerReplacer(STANDARD_TYPE(StepGeom_SurfaceCurve), replaceSurfaceCurve);
@ -44,10 +30,9 @@ MergeSTEPEntities_CircleProcessor::MergeSTEPEntities_CircleProcessor(
//==================================================================================================
bool MergeSTEPEntities_CircleProcessor::replaceEdgeCurve(
const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_CircleReducer::replaceEdgeCurve(const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepShape_EdgeCurve) aSharing = Handle(StepShape_EdgeCurve)::DownCast(theSharing);
if (aSharing->EdgeGeometry() == theOldEntity)
@ -60,10 +45,9 @@ bool MergeSTEPEntities_CircleProcessor::replaceEdgeCurve(
//==================================================================================================
bool MergeSTEPEntities_CircleProcessor::replaceSurfaceCurve(
const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_CircleReducer::replaceSurfaceCurve(const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_SurfaceCurve) aSharing = Handle(StepGeom_SurfaceCurve)::DownCast(theSharing);
if (aSharing->Curve3d() == theOldEntity)
@ -76,10 +60,9 @@ bool MergeSTEPEntities_CircleProcessor::replaceSurfaceCurve(
//==================================================================================================
bool MergeSTEPEntities_CircleProcessor::replaceSeamCurve(
const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_CircleReducer::replaceSeamCurve(const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_SeamCurve) aSharing = Handle(StepGeom_SeamCurve)::DownCast(theSharing);
if (aSharing->Curve3d() == theOldEntity)

15
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CircleProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_CircleReducer.pxx
View File

@ -11,23 +11,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_CircleProcessor_HeaderFile
#define _MergeSTEPEntities_CircleProcessor_HeaderFile
#ifndef _StepTidy_CircleReducer_HeaderFile
#define _StepTidy_CircleReducer_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_CircleHasher.hxx>
#include <StepTidy_EntityReducer.pxx>
#include <StepTidy_CircleHasher.pxx>
#include <StepGeom_Circle.hxx>
//! Processor for merging StepGeom_Circle entities.
//! This processor merges circles with the same position and radius and names.
class MergeSTEPEntities_CircleProcessor
: public MergeSTEPEntities_EntityProcessor<StepGeom_Circle, MergeSTEPEntities_CircleHasher>
class StepTidy_CircleReducer : public StepTidy_EntityReducer<StepGeom_Circle, StepTidy_CircleHasher>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_CircleProcessor(const Handle(XSControl_WorkSession)& theWS);
Standard_EXPORT StepTidy_CircleReducer(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replacer function for StepShape_EdgeCurve entities.
@ -61,4 +60,4 @@ private:
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_CircleProcessor_HeaderFile
#endif // _StepTidy_CircleReducer_HeaderFile

8
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_DirectionHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_DirectionHasher.pxx
View File

@ -11,15 +11,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_DirectionHasher_HeaderFile
#define _MergeSTEPEntities_DirectionHasher_HeaderFile
#ifndef _StepTidy_DirectionHasher_HeaderFile
#define _StepTidy_DirectionHasher_HeaderFile
#include <Standard_HashUtils.hxx>
#include <StepGeom_Direction.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Direction entities.
struct MergeSTEPEntities_DirectionHasher
struct StepTidy_DirectionHasher
{
// Hashes the direction by its name and direction ratios.
std::size_t operator()(const Handle(StepGeom_Direction)& theDirection) const noexcept
@ -75,4 +75,4 @@ struct MergeSTEPEntities_DirectionHasher
}
};
#endif // _MergeSTEPEntities_DirectionHasher_HeaderFile
#endif // _StepTidy_DirectionHasher_HeaderFile

32
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_DirectionProcessor.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_DirectionReducer.cxx
View File

@ -11,20 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// Copyright (c) 2025 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 <MergeSTEPEntities_DirectionProcessor.hxx>
#include <StepTidy_DirectionReducer.pxx>
#include <Interface_Graph.hxx>
#include <StepGeom_Axis1Placement.hxx>
@ -33,10 +20,8 @@
//==================================================================================================
MergeSTEPEntities_DirectionProcessor::MergeSTEPEntities_DirectionProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Direction, MergeSTEPEntities_DirectionHasher>(
theWS)
StepTidy_DirectionReducer::StepTidy_DirectionReducer(const Handle(XSControl_WorkSession)& theWS)
: StepTidy_EntityReducer<StepGeom_Direction, StepTidy_DirectionHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepGeom_Axis1Placement), replaceAxis1Placement);
registerReplacer(STANDARD_TYPE(StepGeom_Axis2Placement3d), replaceAxis2Placement3d);
@ -45,7 +30,7 @@ MergeSTEPEntities_DirectionProcessor::MergeSTEPEntities_DirectionProcessor(
//==================================================================================================
bool MergeSTEPEntities_DirectionProcessor::replaceAxis1Placement(
bool StepTidy_DirectionReducer::replaceAxis1Placement(
const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -61,7 +46,7 @@ bool MergeSTEPEntities_DirectionProcessor::replaceAxis1Placement(
//==================================================================================================
bool MergeSTEPEntities_DirectionProcessor::replaceAxis2Placement3d(
bool StepTidy_DirectionReducer::replaceAxis2Placement3d(
const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -83,10 +68,9 @@ bool MergeSTEPEntities_DirectionProcessor::replaceAxis2Placement3d(
//==================================================================================================
bool MergeSTEPEntities_DirectionProcessor::replaceVector(
const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_DirectionReducer::replaceVector(const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Vector) aSharing = Handle(StepGeom_Vector)::DownCast(theSharing);
if (aSharing->Orientation() == theOldEntity)

19
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_DirectionProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_DirectionReducer.pxx
View File

@ -11,11 +11,11 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_DirectionProcessor_HeaderFile
#define _MergeSTEPEntities_DirectionProcessor_HeaderFile
#ifndef _StepTidy_DirectionReducer_HeaderFile
#define _StepTidy_DirectionReducer_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_DirectionHasher.hxx>
#include <StepTidy_EntityReducer.pxx>
#include <StepTidy_DirectionHasher.pxx>
#include <StepGeom_Direction.hxx>
@ -23,15 +23,14 @@
//! This processor merges directions with the same direction ratios and names.
//! The processor replaces all occurrences of the old directions with the new ones.
//! The processor does not remove old directions from the model.
//! See MergeSTEPEntities_EntityProcessor for the description of the processor workflow.
class MergeSTEPEntities_DirectionProcessor
: public MergeSTEPEntities_EntityProcessor<StepGeom_Direction,
MergeSTEPEntities_DirectionHasher>
//! See StepTidy_EntityReducer for the description of the Reducer workflow.
class StepTidy_DirectionReducer
: public StepTidy_EntityReducer<StepGeom_Direction, StepTidy_DirectionHasher>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_DirectionProcessor(const Handle(XSControl_WorkSession)& theWS);
Standard_EXPORT StepTidy_DirectionReducer(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replaces the old direction with the new one in the StepGeom_Axis1Placement entity.
@ -62,4 +61,4 @@ private:
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_DirectionProcessor_HeaderFile
#endif // _StepTidy_DirectionReducer_HeaderFile

66
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Merger.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_DuplicateCleaner.cxx
View File

@ -11,29 +11,29 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MergeSTEPEntities_Merger.hxx>
#include <StepTidy_DuplicateCleaner.hxx>
#include <Interface_EntityIterator.hxx>
#include <Interface_Graph.hxx>
#include <MergeSTEPEntities_Axis2Placement3dProcessor.hxx>
#include <MergeSTEPEntities_CartesianPointProcessor.hxx>
#include <MergeSTEPEntities_DirectionProcessor.hxx>
#include <MergeSTEPEntities_LineProcessor.hxx>
#include <MergeSTEPEntities_VectorProcessor.hxx>
#include <MergeSTEPEntities_PlaneProcessor.hxx>
#include <MergeSTEPEntities_CircleProcessor.hxx>
#include <StepTidy_Axis2Placement3dReducer.pxx>
#include <StepTidy_CartesianPointReducer.pxx>
#include <StepTidy_DirectionReducer.pxx>
#include <StepTidy_LineReducer.pxx>
#include <StepTidy_VectorReducer.pxx>
#include <StepTidy_PlaneReducer.pxx>
#include <StepTidy_CircleReducer.pxx>
#include <StepData_StepModel.hxx>
//==================================================================================================
MergeSTEPEntities_Merger::MergeSTEPEntities_Merger(Handle(XSControl_WorkSession) theWS)
StepTidy_DuplicateCleaner::StepTidy_DuplicateCleaner(Handle(XSControl_WorkSession) theWS)
: myWS(theWS)
{
}
//==================================================================================================
void MergeSTEPEntities_Merger::Perform()
void StepTidy_DuplicateCleaner::Perform()
{
Handle(StepData_StepModel) aModel = Handle(StepData_StepModel)::DownCast(myWS->Model());
if (aModel.IsNull())
@ -41,37 +41,37 @@ void MergeSTEPEntities_Merger::Perform()
return;
}
//! Initialize processors.
MergeSTEPEntities_CartesianPointProcessor aCartesianPointProcessor(myWS);
MergeSTEPEntities_DirectionProcessor aDirectionProcessor(myWS);
MergeSTEPEntities_Axis2Placement3dProcessor aAxis2Placement3dProcessor(myWS);
MergeSTEPEntities_VectorProcessor aVectorProcessor(myWS);
MergeSTEPEntities_LineProcessor aLineProcessor(myWS);
MergeSTEPEntities_PlaneProcessor aPlaneProcessor(myWS);
MergeSTEPEntities_CircleProcessor aCircleProcessor(myWS);
//! Initialize Reducers.
StepTidy_CartesianPointReducer aCartesianPointReducer(myWS);
StepTidy_DirectionReducer aDirectionReducer(myWS);
StepTidy_Axis2Placement3dReducer aAxis2Placement3dReducer(myWS);
StepTidy_VectorReducer aVectorReducer(myWS);
StepTidy_LineReducer aLineReducer(myWS);
StepTidy_PlaneReducer aPlaneReducer(myWS);
StepTidy_CircleReducer aCircleReducer(myWS);
// Process all entities.
for (Standard_Integer anIndex = 1; anIndex <= aModel->NbEntities(); ++anIndex)
{
const Handle(Standard_Transient) anEntity = aModel->Value(anIndex);
aCartesianPointProcessor.ProcessEntity(anEntity);
aDirectionProcessor.ProcessEntity(anEntity);
aAxis2Placement3dProcessor.ProcessEntity(anEntity);
aVectorProcessor.ProcessEntity(anEntity);
aLineProcessor.ProcessEntity(anEntity);
aPlaneProcessor.ProcessEntity(anEntity);
aCircleProcessor.ProcessEntity(anEntity);
aCartesianPointReducer.ProcessEntity(anEntity);
aDirectionReducer.ProcessEntity(anEntity);
aAxis2Placement3dReducer.ProcessEntity(anEntity);
aVectorReducer.ProcessEntity(anEntity);
aLineReducer.ProcessEntity(anEntity);
aPlaneReducer.ProcessEntity(anEntity);
aCircleReducer.ProcessEntity(anEntity);
}
// Perform replacement of duplicate entities.
TColStd_MapOfTransient aReplacedEntities;
aCartesianPointProcessor.Perform(aReplacedEntities);
aDirectionProcessor.Perform(aReplacedEntities);
aAxis2Placement3dProcessor.Perform(aReplacedEntities);
aVectorProcessor.Perform(aReplacedEntities);
aLineProcessor.Perform(aReplacedEntities);
aPlaneProcessor.Perform(aReplacedEntities);
aCircleProcessor.Perform(aReplacedEntities);
aCartesianPointReducer.Perform(aReplacedEntities);
aDirectionReducer.Perform(aReplacedEntities);
aAxis2Placement3dReducer.Perform(aReplacedEntities);
aVectorReducer.Perform(aReplacedEntities);
aLineReducer.Perform(aReplacedEntities);
aPlaneReducer.Perform(aReplacedEntities);
aCircleReducer.Perform(aReplacedEntities);
// Remove duplicate entities.
removeEntities(aReplacedEntities);
@ -79,7 +79,7 @@ void MergeSTEPEntities_Merger::Perform()
//==================================================================================================
void MergeSTEPEntities_Merger::removeEntities(const TColStd_MapOfTransient& theToRemove)
void StepTidy_DuplicateCleaner::removeEntities(const TColStd_MapOfTransient& theToRemove)
{
if (theToRemove.IsEmpty())
{

62
src/DataExchange/TKDESTEP/StepTidy/StepTidy_DuplicateCleaner.hxx Normal file
View File

@ -0,0 +1,62 @@
// Copyright (c) 2025 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 _StepTidy_DuplicateCleaner_HeaderFile
#define _StepTidy_DuplicateCleaner_HeaderFile
#include <TColStd_MapOfTransient.hxx>
class XSControl_WorkSession;
//! A class to merge STEP entities.
//! This class is used to merge equal STEP entities in the work session and remove duplicates.
//! It uses the child classes of StepTidy_EntityReducer class to perform the merging.
//! The child classes of StepTidy_EntityReducer are specialized for different types of entities.
//! StepTidy_EntityReducer implements the basic logic for searching and merging entities
//! while child classes implement the logic for replacing specific type of entities in the specific
//! type of sharing entities.
//! Classes StepTidy_*Hasher are used to hash the entities and compare them. They define which
//! entities are considered equal to each other. The hashers are used in the StepTidy_EntityReducer
//! class to store the entities in a map. The map is used to find the duplicates and replace them.
//! From this perspective of this module, 'equal' or 'duplicate' entities are those that
//! has equal names and very close numerical values, like for example Cartesian points with
//! coordinates that are equal up to 1e-12 or Vectors with equal orientations and magnitudes
//! up to 1e-12.
//! After the merging this class calls its own method to remove the duplicates.
//! How to use:
//! 1. Create an instance of the class by providing a pointer to the work session where the
//! entities to process are stored.
//! 2. Call Perform() method to perform the merging of entities. After this call all entities
//! that are considered equal to each other will be merged, and duplicates will be removed.
class StepTidy_DuplicateCleaner
{
public:
//! Constructor.
//! @param theWS the work session to merge entities in.
Standard_EXPORT StepTidy_DuplicateCleaner(Handle(XSControl_WorkSession) theWS);
//! Perform the merging of entities.
//! All entities in a model stored in the provided work session that are considered equal to
//! each other will be merged, and duplicates will be removed.
Standard_EXPORT void Perform();
private:
//! Remove entities from the work session.
//! @param theToRemove the entities to remove.
void removeEntities(const TColStd_MapOfTransient& theToRemove);
private:
Handle(XSControl_WorkSession) myWS; //!< The work session containing the model with entities.
};
#endif // _StepTidy_DuplicateCleaner_HeaderFile

24
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_EntityProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_EntityReducer.pxx
View File

@ -11,8 +11,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_EntityProcessor_HeaderFile
#define _MergeSTEPEntities_EntityProcessor_HeaderFile
#ifndef _StepTidy_EntityReducer_HeaderFile
#define _StepTidy_EntityReducer_HeaderFile
#include <Interface_Graph.hxx>
#include <NCollection_Allocator.hxx>
@ -40,7 +40,7 @@
//! @tparam ProcessedType Type of the processed entities.
//! @tparam ProcessedTypeHasher OCCT-Style hasher for the processed entities.
template <typename ProcessedType, typename ProcessedTypeHasher>
class MergeSTEPEntities_EntityProcessor
class StepTidy_EntityReducer
{
protected:
// Map of duplicate entities. Key is the first processed entity, value is a list of duplicates.
@ -62,7 +62,7 @@ protected:
//! Protected to prevent direct instantiation of the base class. Only child classes should be
//! allowed to instantiate.
//! @param theWS Work session.
MergeSTEPEntities_EntityProcessor(const Handle(XSControl_WorkSession)& theWS);
StepTidy_EntityReducer(const Handle(XSControl_WorkSession)& theWS);
public:
//! Function to process an entity. If the entity can be merged, it will be stored in the internal
@ -116,8 +116,8 @@ private:
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::
MergeSTEPEntities_EntityProcessor(const Handle(XSControl_WorkSession)& theWS)
StepTidy_EntityReducer<ProcessedType, ProcessedTypeHasher>::StepTidy_EntityReducer(
const Handle(XSControl_WorkSession)& theWS)
: myWS(theWS),
myReplacerMap(),
myDuplicateMap()
@ -127,7 +127,7 @@ MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::ProcessEntity(
bool StepTidy_EntityReducer<ProcessedType, ProcessedTypeHasher>::ProcessEntity(
const Handle(Standard_Transient)& theEntity)
{
const Handle(ProcessedType) anEntity = Handle(ProcessedType)::DownCast(theEntity);
@ -158,7 +158,7 @@ bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::Proc
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
void MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::Perform(
void StepTidy_EntityReducer<ProcessedType, ProcessedTypeHasher>::Perform(
TColStd_MapOfTransient& theReplacedEntities)
{
for (typename DuplicateMap::Iterator anIter(myDuplicateMap); anIter.More(); anIter.Next())
@ -190,7 +190,7 @@ void MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::Perf
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
void MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::registerReplacer(
void StepTidy_EntityReducer<ProcessedType, ProcessedTypeHasher>::registerReplacer(
const Handle(Standard_Type)& theType,
const ReplacerFunction& theReplacer)
{
@ -200,7 +200,7 @@ void MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::regi
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::hasAllReplacers(
bool StepTidy_EntityReducer<ProcessedType, ProcessedTypeHasher>::hasAllReplacers(
const Handle(TColStd_HSequenceOfTransient)& theSharings) const
{
if (theSharings.IsNull())
@ -216,7 +216,7 @@ bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::hasA
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::replaceInSharings(
bool StepTidy_EntityReducer<ProcessedType, ProcessedTypeHasher>::replaceInSharings(
const Handle(ProcessedType)& theOldEntity,
const Handle(ProcessedType)& theNewEntity,
const Handle(TColStd_HSequenceOfTransient)& theSharings) const
@ -238,4 +238,4 @@ bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::repl
return isAllReplaced;
}
#endif // _MergeSTEPEntities_EntityProcessor_HeaderFile
#endif // _StepTidy_EntityReducer_HeaderFile

20
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_LineHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_LineHasher.pxx
View File

@ -11,24 +11,24 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_LineHasher_HeaderFile
#define _MergeSTEPEntities_LineHasher_HeaderFile
#ifndef _StepTidy_LineHasher_HeaderFile
#define _StepTidy_LineHasher_HeaderFile
#include <MergeSTEPEntities_CartesianPointHasher.hxx>
#include <MergeSTEPEntities_VectorHasher.hxx>
#include <StepTidy_CartesianPointHasher.pxx>
#include <StepTidy_VectorHasher.pxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Line.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Line entities.
struct MergeSTEPEntities_LineHasher
struct StepTidy_LineHasher
{
// Hashes the Line by its name and Line ratios.
std::size_t operator()(const Handle(StepGeom_Line)& theLine) const noexcept
{
const size_t aHashes[2]{MergeSTEPEntities_CartesianPointHasher{}(theLine->Pnt()),
MergeSTEPEntities_VectorHasher{}(theLine->Dir())};
const size_t aHashes[2]{StepTidy_CartesianPointHasher{}(theLine->Pnt()),
StepTidy_VectorHasher{}(theLine->Dir())};
const size_t aCombinedHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (theLine->Name().IsNull())
@ -59,13 +59,13 @@ struct MergeSTEPEntities_LineHasher
}
// Compare points.
if (!MergeSTEPEntities_CartesianPointHasher{}(theLine1->Pnt(), theLine2->Pnt()))
if (!StepTidy_CartesianPointHasher{}(theLine1->Pnt(), theLine2->Pnt()))
{
return false;
}
// Compare directions.
if (!MergeSTEPEntities_VectorHasher{}(theLine1->Dir(), theLine2->Dir()))
if (!StepTidy_VectorHasher{}(theLine1->Dir(), theLine2->Dir()))
{
return false;
}
@ -74,4 +74,4 @@ struct MergeSTEPEntities_LineHasher
}
};
#endif // _MergeSTEPEntities_LineHasher_HeaderFile
#endif // _StepTidy_LineHasher_HeaderFile

46
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_LineProcessor.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_LineReducer.cxx
View File

@ -11,20 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// Copyright (c) 2025 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 <MergeSTEPEntities_LineProcessor.hxx>
#include <StepTidy_LineReducer.pxx>
#include <Interface_Graph.hxx>
#include <StepShape_EdgeCurve.hxx>
@ -35,9 +22,8 @@
//==================================================================================================
MergeSTEPEntities_LineProcessor::MergeSTEPEntities_LineProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Line, MergeSTEPEntities_LineHasher>(theWS)
StepTidy_LineReducer::StepTidy_LineReducer(const Handle(XSControl_WorkSession)& theWS)
: StepTidy_EntityReducer<StepGeom_Line, StepTidy_LineHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepShape_EdgeCurve), replaceEdgeCurve);
registerReplacer(STANDARD_TYPE(StepGeom_TrimmedCurve), replaceTrimmedCurve);
@ -49,9 +35,9 @@ MergeSTEPEntities_LineProcessor::MergeSTEPEntities_LineProcessor(
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::replaceEdgeCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_LineReducer::replaceEdgeCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepShape_EdgeCurve) aSharing = Handle(StepShape_EdgeCurve)::DownCast(theSharing);
if (aSharing->EdgeGeometry() == theOldEntity)
@ -64,9 +50,9 @@ bool MergeSTEPEntities_LineProcessor::replaceEdgeCurve(const Handle(StepGeom_Lin
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::replaceTrimmedCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_LineReducer::replaceTrimmedCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_TrimmedCurve) aSharing = Handle(StepGeom_TrimmedCurve)::DownCast(theSharing);
if (aSharing->BasisCurve() == theOldEntity)
@ -79,9 +65,9 @@ bool MergeSTEPEntities_LineProcessor::replaceTrimmedCurve(const Handle(StepGeom_
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::replaceSurfaceCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_LineReducer::replaceSurfaceCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_SurfaceCurve) aSharing = Handle(StepGeom_SurfaceCurve)::DownCast(theSharing);
if (aSharing->Curve3d() == theOldEntity)
@ -94,7 +80,7 @@ bool MergeSTEPEntities_LineProcessor::replaceSurfaceCurve(const Handle(StepGeom_
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::replaceDefinitionalRepresentation(
bool StepTidy_LineReducer::replaceDefinitionalRepresentation(
const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
@ -117,9 +103,9 @@ bool MergeSTEPEntities_LineProcessor::replaceDefinitionalRepresentation(
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::replaceSeamCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_LineReducer::replaceSeamCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_SeamCurve) aSharing = Handle(StepGeom_SeamCurve)::DownCast(theSharing);
if (aSharing->Curve3d() == theOldEntity)

15
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_LineProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_LineReducer.pxx
View File

@ -11,23 +11,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_LineProcessor_HeaderFile
#define _MergeSTEPEntities_LineProcessor_HeaderFile
#ifndef _StepTidy_LineReducer_HeaderFile
#define _StepTidy_LineReducer_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_LineHasher.hxx>
#include <StepTidy_EntityReducer.pxx>
#include <StepTidy_LineHasher.pxx>
#include <StepGeom_Line.hxx>
//! Processor for merging StepGeom_Line entities.
//! This processor merges lines with the same point and direction and names.
class MergeSTEPEntities_LineProcessor
: public MergeSTEPEntities_EntityProcessor<StepGeom_Line, MergeSTEPEntities_LineHasher>
class StepTidy_LineReducer : public StepTidy_EntityReducer<StepGeom_Line, StepTidy_LineHasher>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_LineProcessor(const Handle(XSControl_WorkSession)& theWS);
Standard_EXPORT StepTidy_LineReducer(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replacer function for StepShape_EdgeCurve entities.
@ -81,4 +80,4 @@ private:
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_LineProcessor_HeaderFile
#endif // _StepTidy_LineReducer_HeaderFile

14
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_PlaneHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_PlaneHasher.pxx
View File

@ -11,21 +11,21 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_PlaneHasher_HeaderFile
#define _MergeSTEPEntities_PlaneHasher_HeaderFile
#ifndef _StepTidy_PlaneHasher_HeaderFile
#define _StepTidy_PlaneHasher_HeaderFile
#include <MergeSTEPEntities_Axis2Placement3dHasher.hxx>
#include <StepTidy_Axis2Placement3dHasher.pxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Plane.hxx>
//! OCCT-style hasher for StepGeom_Plane entities.
struct MergeSTEPEntities_PlaneHasher
struct StepTidy_PlaneHasher
{
// Hashes the axis Planes.
std::size_t operator()(const Handle(StepGeom_Plane)& thePlane) const noexcept
{
const size_t aHash = MergeSTEPEntities_Axis2Placement3dHasher{}(thePlane->Position());
const size_t aHash = StepTidy_Axis2Placement3dHasher{}(thePlane->Position());
if (thePlane->Name().IsNull())
{
// If the name is not present, return the hash.
@ -53,8 +53,8 @@ struct MergeSTEPEntities_PlaneHasher
}
// Compare axis Planes.
return MergeSTEPEntities_Axis2Placement3dHasher{}(thePlane1->Position(), thePlane2->Position());
return StepTidy_Axis2Placement3dHasher{}(thePlane1->Position(), thePlane2->Position());
}
};
#endif // _MergeSTEPEntities_PlaneHasher_HeaderFile
#endif // _StepTidy_PlaneHasher_HeaderFile

20
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_PlaneProcessor.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_PlaneReducer.cxx
View File

@ -11,16 +11,15 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#include <MergeSTEPEntities_PlaneProcessor.hxx>
#include <StepTidy_PlaneReducer.pxx>
#include <StepShape_AdvancedFace.hxx>
#include <StepGeom_Pcurve.hxx>
//==================================================================================================
MergeSTEPEntities_PlaneProcessor::MergeSTEPEntities_PlaneProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Plane, MergeSTEPEntities_PlaneHasher>(theWS)
StepTidy_PlaneReducer::StepTidy_PlaneReducer(const Handle(XSControl_WorkSession)& theWS)
: StepTidy_EntityReducer<StepGeom_Plane, StepTidy_PlaneHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepShape_AdvancedFace), replaceAdvancedFace);
registerReplacer(STANDARD_TYPE(StepGeom_Pcurve), replacePcurve);
@ -28,10 +27,9 @@ MergeSTEPEntities_PlaneProcessor::MergeSTEPEntities_PlaneProcessor(
//==================================================================================================
bool MergeSTEPEntities_PlaneProcessor::replaceAdvancedFace(
const Handle(StepGeom_Plane)& theOldEntity,
const Handle(StepGeom_Plane)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_PlaneReducer::replaceAdvancedFace(const Handle(StepGeom_Plane)& theOldEntity,
const Handle(StepGeom_Plane)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepShape_AdvancedFace) aSharing = Handle(StepShape_AdvancedFace)::DownCast(theSharing);
if (aSharing->FaceGeometry() == theOldEntity)
@ -43,9 +41,9 @@ bool MergeSTEPEntities_PlaneProcessor::replaceAdvancedFace(
}
//==================================================================================================
bool MergeSTEPEntities_PlaneProcessor::replacePcurve(const Handle(StepGeom_Plane)& theOldEntity,
const Handle(StepGeom_Plane)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_PlaneReducer::replacePcurve(const Handle(StepGeom_Plane)& theOldEntity,
const Handle(StepGeom_Plane)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Pcurve) aSharing = Handle(StepGeom_Pcurve)::DownCast(theSharing);
if (aSharing->BasisSurface() == theOldEntity)

15
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_PlaneProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_PlaneReducer.pxx
View File

@ -11,23 +11,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_PlaneProcessor_HeaderFile
#define _MergeSTEPEntities_PlaneProcessor_HeaderFile
#ifndef _StepTidy_PlaneReducer_HeaderFile
#define _StepTidy_PlaneReducer_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_PlaneHasher.hxx>
#include <StepTidy_EntityReducer.pxx>
#include <StepTidy_PlaneHasher.pxx>
#include <StepGeom_Plane.hxx>
//! Processor for merging StepGeom_Plane entities.
//! This processor merges planes with the same names and placements.
class MergeSTEPEntities_PlaneProcessor
: public MergeSTEPEntities_EntityProcessor<StepGeom_Plane, MergeSTEPEntities_PlaneHasher>
class StepTidy_PlaneReducer : public StepTidy_EntityReducer<StepGeom_Plane, StepTidy_PlaneHasher>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_PlaneProcessor(const Handle(XSControl_WorkSession)& theWS);
Standard_EXPORT StepTidy_PlaneReducer(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replacer function for StepShape_AdvancedFace entities.
@ -51,4 +50,4 @@ private:
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_DirectionProcessor_HeaderFile
#endif // _StepTidy_DirectionReducer_HeaderFile

15
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_VectorHasher.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_VectorHasher.pxx
View File

@ -11,22 +11,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_VectorHasher_HeaderFile
#define _MergeSTEPEntities_VectorHasher_HeaderFile
#ifndef _StepTidy_VectorHasher_HeaderFile
#define _StepTidy_VectorHasher_HeaderFile
#include <MergeSTEPEntities_DirectionHasher.hxx>
#include <StepTidy_DirectionHasher.pxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Vector.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Vector entities.
struct MergeSTEPEntities_VectorHasher
struct StepTidy_VectorHasher
{
// Hashes the Vector by its name and Vector ratios.
std::size_t operator()(const Handle(StepGeom_Vector)& theVector) const noexcept
{
const size_t aHashes[2]{MergeSTEPEntities_DirectionHasher{}(theVector->Orientation()),
const size_t aHashes[2]{StepTidy_DirectionHasher{}(theVector->Orientation()),
opencascade::hash(static_cast<int>(theVector->Magnitude()))};
const size_t aCombinedHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (theVector->Name().IsNull())
@ -63,9 +63,8 @@ struct MergeSTEPEntities_VectorHasher
}
// Compare orientations.
return MergeSTEPEntities_DirectionHasher{}(theVector1->Orientation(),
theVector2->Orientation());
return StepTidy_DirectionHasher{}(theVector1->Orientation(), theVector2->Orientation());
}
};
#endif // _MergeSTEPEntities_VectorHasher_HeaderFile
#endif // _StepTidy_VectorHasher_HeaderFile

26
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_VectorProcessor.cxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_VectorReducer.cxx
View File

@ -11,20 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// Copyright (c) 2025 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 <MergeSTEPEntities_VectorProcessor.hxx>
#include <StepTidy_VectorReducer.pxx>
#include <Interface_Graph.hxx>
#include <StepGeom_Line.hxx>
@ -32,18 +19,17 @@
//==================================================================================================
MergeSTEPEntities_VectorProcessor::MergeSTEPEntities_VectorProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Vector, MergeSTEPEntities_VectorHasher>(theWS)
StepTidy_VectorReducer::StepTidy_VectorReducer(const Handle(XSControl_WorkSession)& theWS)
: StepTidy_EntityReducer<StepGeom_Vector, StepTidy_VectorHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepGeom_Line), replaceLine);
}
//==================================================================================================
bool MergeSTEPEntities_VectorProcessor::replaceLine(const Handle(StepGeom_Vector)& theOldEntity,
const Handle(StepGeom_Vector)& theNewEntity,
Handle(Standard_Transient) theSharing)
bool StepTidy_VectorReducer::replaceLine(const Handle(StepGeom_Vector)& theOldEntity,
const Handle(StepGeom_Vector)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Line) aLine = Handle(StepGeom_Line)::DownCast(theSharing);
if (aLine->Dir() == theOldEntity)

15
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_VectorProcessor.hxx → src/DataExchange/TKDESTEP/StepTidy/StepTidy_VectorReducer.pxx
View File

@ -11,23 +11,22 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _MergeSTEPEntities_VectorProcessor_HeaderFile
#define _MergeSTEPEntities_VectorProcessor_HeaderFile
#ifndef _StepTidy_VectorReducer_HeaderFile
#define _StepTidy_VectorReducer_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_VectorHasher.hxx>
#include <StepTidy_EntityReducer.pxx>
#include <StepTidy_VectorHasher.pxx>
#include <StepGeom_Vector.hxx>
//! Processor for merging StepGeom_Vector entities.
//! This processor merges vectors with the same orientation and magnitude and names.
class MergeSTEPEntities_VectorProcessor
: public MergeSTEPEntities_EntityProcessor<StepGeom_Vector, MergeSTEPEntities_VectorHasher>
class StepTidy_VectorReducer : public StepTidy_EntityReducer<StepGeom_Vector, StepTidy_VectorHasher>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_VectorProcessor(const Handle(XSControl_WorkSession)& theWS);
Standard_EXPORT StepTidy_VectorReducer(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replaces the old vector with the new one in the StepGeom_Line entity.
@ -40,4 +39,4 @@ private:
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_VectorProcessor_HeaderFile
#endif // _StepTidy_VectorReducer_HeaderFile

43
src/Draw/TKXSDRAWSTEP/XSDRAWSTEP/XSDRAWSTEP.cxx
View File

@ -23,7 +23,6 @@
#include <Draw_ProgressIndicator.hxx>
#include <Interface_Macros.hxx>
#include <Interface_Static.hxx>
#include <MergeSTEPEntities_Merger.hxx>
#include <Message.hxx>
#include <OSD_OpenFile.hxx>
#include <OSD_Parallel.hxx>
@ -1094,39 +1093,6 @@ static Standard_Integer WriteStep(Draw_Interpretor& theDI,
//=================================================================================================
static Standard_Integer MergeSTEPEntities(Draw_Interpretor& theDI,
Standard_Integer theNbArgs,
const char** theArgVec)
{
if (theNbArgs < 2)
{
theDI << "Incorrect number of arguments\n";
theDI << "Usage: MergeSTEPEntities input_file output_file\n";
return 1;
}
STEPControl_Reader aReader;
if (aReader.ReadFile(theArgVec[1]) != IFSelect_RetDone)
{
theDI << "Error: Cannot read file " << theArgVec[1] << "\n";
return 1;
}
MergeSTEPEntities_Merger aMerger(aReader.WS());
aMerger.Perform();
STEPControl_Writer aWriter(aReader.WS(), Standard_False);
if (aWriter.Write(theArgVec[2]) != IFSelect_RetDone)
{
theDI << "Error: Cannot write file " << theArgVec[2] << "\n";
return 1;
}
return 0;
}
//=================================================================================================
void XSDRAWSTEP::Factory(Draw_Interpretor& theDI)
{
static Standard_Boolean aIsActivated = Standard_False;
@ -1179,15 +1145,6 @@ void XSDRAWSTEP::Factory(Draw_Interpretor& theDI)
WriteStep,
aGroup);
theDI.Add("MergeSTEPEntities",
"MergeSTEPEntities input_file output_file"
"\n\t\t: Merge equal entities in STEP file"
"\n\t\t: input_file - Step file to read"
"\n\t\t: output_file - Step file to write output to",
__FILE__,
MergeSTEPEntities,
aGroup);
// Load XSDRAW session for pilot activation
XSDRAW::LoadDraw(theDI);
}