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 Packages Releases Activity

Step Export - Graph optimization (decrease the file size) #190

Browse Source 
Functionality to remove duplicate entities from Step graph is added.
Class MergeSTEPEntities_Merger is main entry point.
Class MergeSTEPEntities_EntityProcessor implements the basic replacement
logic.
Children of MergeSTEPEntities_EntityProcessor implement the logic for
the replacement of particular step entity.

Google tests are added for new classes.
This commit is contained in:
dkulikov 2025-03-28 17:33:02 +00:00
parent 70ba51d3a8
commit 652c3f1da9
40 changed files with 4948 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -2,4 +2,14 @@
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
)

461
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_Axis2Placement3dProcessor_Test.cxx Normal file
View File

@ -0,0 +1,461 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_Axis2Placement3dProcessor.hxx>
#include <StepGeom_Plane.hxx>
#include <StepRepr_ItemDefinedTransformation.hxx>
#include <StepGeom_CylindricalSurface.hxx>
#include <StepShape_ShapeRepresentation.hxx>
#include <StepRepr_RepresentationContext.hxx>
#include <StepRepr_ConstructiveGeometryRepresentation.hxx>
#include <StepGeom_Circle.hxx>
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_StyledItem.hxx>
#include <StepGeom_Ellipse.hxx>
#include <StepGeom_ConicalSurface.hxx>
#include <StepGeom_ToroidalSurface.hxx>
#include <StepShape_AdvancedBrepShapeRepresentation.hxx>
#include <StepGeom_SphericalSurface.hxx>
class MergeSTEPEntities_Axis2Placement3dProcessorTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateAxis2Placement3ds()
{
MergeSTEPEntities_Axis2Placement3dProcessor aProcessor(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Axis2Placement3ds with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, DifferentNames)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d("Axis1");
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d("Axis2");
// Creating a plane containing the first Axis2Placement3d.
Handle(StepGeom_Plane) aPlane1 = new StepGeom_Plane;
aPlane1->Init(new TCollection_HAsciiString, anAxis1);
addToModel(aPlane1);
// Creating a plane containing the second Axis2Placement3d.
Handle(StepGeom_Plane) aPlane2 = new StepGeom_Plane;
aPlane2->Init(new TCollection_HAsciiString, anAxis2);
addToModel(aPlane2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that nothing was removed.
EXPECT_TRUE(aRemovedEntities.IsEmpty());
}
// Check that equal Axis2Placement3ds are merged for StepShape_GeometricCurveSet.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Plane)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a plane containing the first Axis2Placement3d.
Handle(StepGeom_Plane) aPlane1 = new StepGeom_Plane;
aPlane1->Init(new TCollection_HAsciiString, anAxis1);
addToModel(aPlane1);
// Creating a plane containing the second Axis2Placement3d.
Handle(StepGeom_Plane) aPlane2 = new StepGeom_Plane;
aPlane2->Init(new TCollection_HAsciiString, anAxis2);
addToModel(aPlane2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepRepr_ItemDefinedTransformation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepRepr_ItemDefinedTransformation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis3 = addAxis2Placement3d(nullptr, gp_XYZ(1., 1., 1.));
// Creating ItemDefinedTransformation containing the first Axis2Placement3d.
Handle(StepRepr_ItemDefinedTransformation) aItem1 = new StepRepr_ItemDefinedTransformation;
aItem1->Init(new TCollection_HAsciiString, new TCollection_HAsciiString, anAxis1, anAxis3);
addToModel(aItem1);
// Creating ItemDefinedTransformation containing the second Axis2Placement3d.
Handle(StepRepr_ItemDefinedTransformation) aItem2 = new StepRepr_ItemDefinedTransformation;
aItem1->Init(new TCollection_HAsciiString, new TCollection_HAsciiString, anAxis2, anAxis3);
addToModel(aItem2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepGeom_CylindricalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_CylindricalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a cylindrical surface containing the first Axis2Placement3d.
Handle(StepGeom_CylindricalSurface) aCylindricalSurface1 = new StepGeom_CylindricalSurface;
aCylindricalSurface1->Init(new TCollection_HAsciiString, anAxis1, 1.0);
addToModel(aCylindricalSurface1);
// Creating a cylindrical surface containing the second Axis2Placement3d.
Handle(StepGeom_CylindricalSurface) aCylindricalSurface2 = new StepGeom_CylindricalSurface;
aCylindricalSurface2->Init(new TCollection_HAsciiString, anAxis2, 1.0);
addToModel(aCylindricalSurface2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepShape_ShapeRepresentation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepShape_ShapeRepresentation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a shape representation containing the first Axis2Placement3d.
Handle(StepRepr_HArray1OfRepresentationItem) aItems1 =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aItems1->SetValue(1, anAxis1);
Handle(StepShape_ShapeRepresentation) aShapeRepresentation1 = new StepShape_ShapeRepresentation;
aShapeRepresentation1->Init(new TCollection_HAsciiString,
aItems1,
new StepRepr_RepresentationContext);
addToModel(aShapeRepresentation1);
// Creating a shape representation containing the second Axis2Placement3d.
Handle(StepRepr_HArray1OfRepresentationItem) aItems2 =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aItems2->SetValue(1, anAxis2);
Handle(StepShape_ShapeRepresentation) aShapeRepresentation2 = new StepShape_ShapeRepresentation;
aShapeRepresentation2->Init(new TCollection_HAsciiString,
aItems2,
new StepRepr_RepresentationContext);
addToModel(aShapeRepresentation2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepRepr_ConstructiveGeometryRepresentation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepRepr_ConstructiveGeometryRepresentation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a constructive geometry representation containing the first Axis2Placement3d.
Handle(StepRepr_HArray1OfRepresentationItem) aItems1 =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aItems1->SetValue(1, anAxis1);
Handle(StepRepr_ConstructiveGeometryRepresentation) aConstructiveGeometryRepresentation1 =
new StepRepr_ConstructiveGeometryRepresentation;
aConstructiveGeometryRepresentation1->Init(new TCollection_HAsciiString,
aItems1,
new StepRepr_RepresentationContext);
addToModel(aConstructiveGeometryRepresentation1);
// Creating a constructive geometry representation containing the second Axis2Placement3d.
Handle(StepRepr_HArray1OfRepresentationItem) aItems2 =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aItems2->SetValue(1, anAxis2);
Handle(StepRepr_ConstructiveGeometryRepresentation) aConstructiveGeometryRepresentation2 =
new StepRepr_ConstructiveGeometryRepresentation;
aConstructiveGeometryRepresentation2->Init(new TCollection_HAsciiString,
aItems2,
new StepRepr_RepresentationContext);
addToModel(aConstructiveGeometryRepresentation2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepGeom_Circle.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Circle)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a circle containing the first Axis2Placement3d.
StepGeom_Axis2Placement aSelector1;
aSelector1.SetValue(anAxis1);
Handle(StepGeom_Circle) aCircle1 = new StepGeom_Circle;
aCircle1->Init(new TCollection_HAsciiString, aSelector1, 1.0);
addToModel(aCircle1);
// Creating a circle containing the second Axis2Placement3d.
StepGeom_Axis2Placement aSelector2;
aSelector2.SetValue(anAxis2);
Handle(StepGeom_Circle) aCircle2 = new StepGeom_Circle;
aCircle2->Init(new TCollection_HAsciiString, aSelector2, 1.0);
addToModel(aCircle2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepVisual_PresentationLayerAssignment.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepVisual_PresentationLayerAssignment)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a presentation layer assignment containing the first Axis2Placement3d.
Handle(StepVisual_HArray1OfLayeredItem) aAssignedItems1 =
new StepVisual_HArray1OfLayeredItem(1, 1);
StepVisual_LayeredItem aLayeredItem1;
aLayeredItem1.SetValue(anAxis1);
aAssignedItems1->SetValue(1, aLayeredItem1);
Handle(StepVisual_PresentationLayerAssignment) aPresentationLayerAssignment1 =
new StepVisual_PresentationLayerAssignment;
aPresentationLayerAssignment1->Init(new TCollection_HAsciiString,
new TCollection_HAsciiString,
aAssignedItems1);
addToModel(aPresentationLayerAssignment1);
// Creating a presentation layer assignment containing the second Axis2Placement3d.
Handle(StepVisual_HArray1OfLayeredItem) aAssignedItems2 =
new StepVisual_HArray1OfLayeredItem(1, 1);
StepVisual_LayeredItem aLayeredItem2;
aLayeredItem2.SetValue(anAxis2);
aAssignedItems2->SetValue(1, aLayeredItem2);
Handle(StepVisual_PresentationLayerAssignment) aPresentationLayerAssignment2 =
new StepVisual_PresentationLayerAssignment;
aPresentationLayerAssignment2->Init(new TCollection_HAsciiString,
new TCollection_HAsciiString,
aAssignedItems2);
addToModel(aPresentationLayerAssignment2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepVisual_StyledItem.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepVisual_StyledItem)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a styled item containing the first Axis2Placement3d.
Handle(StepVisual_StyledItem) aStiledItem1 = new StepVisual_StyledItem;
aStiledItem1->Init(new TCollection_HAsciiString,
new StepVisual_HArray1OfPresentationStyleAssignment(1, 1),
anAxis1);
addToModel(aStiledItem1);
// Creating a styled item containing the second Axis2Placement3d.
Handle(StepVisual_StyledItem) aStiledItem2 = new StepVisual_StyledItem;
aStiledItem2->Init(new TCollection_HAsciiString,
new StepVisual_HArray1OfPresentationStyleAssignment(1, 1),
anAxis2);
addToModel(aStiledItem2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepGeom_Ellipse.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_Ellipse)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating an ellipse containing the first Axis2Placement3d.
StepGeom_Axis2Placement aSelector1;
aSelector1.SetValue(anAxis1);
Handle(StepGeom_Ellipse) aEllipse1 = new StepGeom_Ellipse;
aEllipse1->Init(new TCollection_HAsciiString, aSelector1, 1.0, 2.0);
addToModel(aEllipse1);
// Creating an ellipse containing the second Axis2Placement3d.
StepGeom_Axis2Placement aSelector2;
aSelector2.SetValue(anAxis2);
Handle(StepGeom_Ellipse) aEllipse2 = new StepGeom_Ellipse;
aEllipse2->Init(new TCollection_HAsciiString, aSelector2, 1.0, 2.0);
addToModel(aEllipse2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepGeom_ConicalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_ConicalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a conical surface containing the first Axis2Placement3d.
Handle(StepGeom_ConicalSurface) aConicalSurface1 = new StepGeom_ConicalSurface;
aConicalSurface1->Init(new TCollection_HAsciiString, anAxis1, 1.0, 1.0);
addToModel(aConicalSurface1);
// Creating a conical surface containing the second Axis2Placement3d.
Handle(StepGeom_ConicalSurface) aConicalSurface2 = new StepGeom_ConicalSurface;
aConicalSurface2->Init(new TCollection_HAsciiString, anAxis2, 1.0, 1.0);
addToModel(aConicalSurface2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepGeom_ToroidalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_ToroidalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a toroidal surface containing the first Axis2Placement3d.
Handle(StepGeom_ToroidalSurface) aToroidalSurface1 = new StepGeom_ToroidalSurface;
aToroidalSurface1->Init(new TCollection_HAsciiString, anAxis1, 1.0, 1.0);
addToModel(aToroidalSurface1);
// Creating a toroidal surface containing the second Axis2Placement3d.
Handle(StepGeom_ToroidalSurface) aToroidalSurface2 = new StepGeom_ToroidalSurface;
aToroidalSurface2->Init(new TCollection_HAsciiString, anAxis2, 1.0, 1.0);
addToModel(aToroidalSurface2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepShape_AdvancedBrepShapeRepresentation.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepShape_AdvancedBrepShapeRepresentation)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a shape representation containing the first Axis2Placement3d.
Handle(StepRepr_HArray1OfRepresentationItem) aItems1 =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aItems1->SetValue(1, anAxis1);
Handle(StepShape_AdvancedBrepShapeRepresentation) aShapeRepresentation1 =
new StepShape_AdvancedBrepShapeRepresentation;
aShapeRepresentation1->Init(new TCollection_HAsciiString,
aItems1,
new StepRepr_RepresentationContext);
addToModel(aShapeRepresentation1);
// Creating a shape representation containing the second Axis2Placement3d.
Handle(StepRepr_HArray1OfRepresentationItem) aItems2 =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aItems2->SetValue(1, anAxis2);
Handle(StepShape_AdvancedBrepShapeRepresentation) aShapeRepresentation2 =
new StepShape_AdvancedBrepShapeRepresentation;
aShapeRepresentation2->Init(new TCollection_HAsciiString,
aItems2,
new StepRepr_RepresentationContext);
addToModel(aShapeRepresentation2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}
// Check that equal Axis2Placement3ds are merged for StepGeom_SphericalSurface.
TEST_F(MergeSTEPEntities_Axis2Placement3dProcessorTest, StepGeom_SphericalSurface)
{
// Creating Axis2Placement3ds.
Handle(StepGeom_Axis2Placement3d) anAxis1 = addAxis2Placement3d();
Handle(StepGeom_Axis2Placement3d) anAxis2 = addAxis2Placement3d();
// Creating a spherical surface containing the first Axis2Placement3d.
Handle(StepGeom_SphericalSurface) aSphericalSurface1 = new StepGeom_SphericalSurface;
aSphericalSurface1->Init(new TCollection_HAsciiString, anAxis1, 1.0);
addToModel(aSphericalSurface1);
// Creating a spherical surface containing the second Axis2Placement3d.
Handle(StepGeom_SphericalSurface) aSphericalSurface2 = new StepGeom_SphericalSurface;
aSphericalSurface2->Init(new TCollection_HAsciiString, anAxis2, 1.0);
addToModel(aSphericalSurface2);
// Performing removal of duplicate Axis2Placement3ds.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateAxis2Placement3ds();
// Check that one Axis2Placement3d was removed.
EXPECT_EQ(aRemovedEntities.Extent(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(anAxis1) || aRemovedEntities.Contains(anAxis2));
}

194
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_BaseTestFixture.hxx Normal file
View File

@ -0,0 +1,194 @@
// 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_BaseTestFixture_HeaderFile
#define _MergeSTEPEntities_BaseTestFixture_HeaderFile
#include <STEPControl_Controller.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <StepGeom_Circle.hxx>
#include <StepGeom_Direction.hxx>
#include <StepGeom_Line.hxx>
#include <StepGeom_Plane.hxx>
#include <StepGeom_Vector.hxx>
#include <XSControl_WorkSession.hxx>
#include <gtest/gtest.h>
class MergeSTEPEntities_BaseTestFixture : public testing::Test
{
protected:
// Initialize the work session and model.
MergeSTEPEntities_BaseTestFixture()
: myWS()
{
STEPControl_Controller::Init();
myWS = new XSControl_WorkSession;
myWS->SelectNorm("STEP");
myWS->SetModel(myWS->NormAdaptor()->NewModel());
}
// Add a Cartesian point to the model.
// @param theName the name of the Cartesian point.
// @param thePoint the coordinates of the Cartesian point.
// @return the added Cartesian point.
Handle(StepGeom_CartesianPoint) addCartesianPoint(const char* theName = nullptr,
const gp_XYZ& thePoint = gp_XYZ(0.,
0.,
0.)) const
{
const Handle(StepGeom_CartesianPoint) aCartesianPoint = new StepGeom_CartesianPoint;
const Handle(TCollection_HAsciiString) aName =
theName ? new TCollection_HAsciiString(theName) : new TCollection_HAsciiString();
aCartesianPoint->Init3D(aName, thePoint.X(), thePoint.Y(), thePoint.Z());
myWS->Model()->AddWithRefs(aCartesianPoint);
return aCartesianPoint;
}
// Add a direction to the model.
// @param theName the name of the direction.
// @param theDirection the direction ratios.
// @return the added direction.
Handle(StepGeom_Direction) addDirection(const char* theName = nullptr,
const gp_XYZ& theDirection = gp_XYZ(0., 0., 1.)) const
{
const Handle(StepGeom_Direction) aDirection = new StepGeom_Direction;
const Handle(TCollection_HAsciiString) aName =
theName ? new TCollection_HAsciiString(theName) : new TCollection_HAsciiString();
Handle(TColStd_HArray1OfReal) aDirectionRatios = new TColStd_HArray1OfReal(1, 3);
aDirectionRatios->SetValue(1, theDirection.X());
aDirectionRatios->SetValue(2, theDirection.Y());
aDirectionRatios->SetValue(3, theDirection.Z());
aDirection->Init(aName, aDirectionRatios);
myWS->Model()->AddWithRefs(aDirection);
return aDirection;
}
// Add a vector to the model.
// @param theName the name of the vector.
// @param theOrientation the orientation of the vector.
// @param aMagnitude the magnitude of the vector.
// @return the added vector.
Handle(StepGeom_Vector) addVector(const char* theName = nullptr,
const gp_XYZ& theOrientation = gp_XYZ(0., 0., 1.),
const double aMagnitude = 1.) const
{
const Handle(StepGeom_Vector) aVector = new StepGeom_Vector;
const Handle(TCollection_HAsciiString) aName =
theName ? new TCollection_HAsciiString(theName) : new TCollection_HAsciiString();
aVector->Init(aName, addDirection(nullptr, theOrientation), aMagnitude);
myWS->Model()->AddWithRefs(aVector);
return aVector;
}
// Add an Axis2Placement3d to the model.
// @param theName the name of the Axis2Placement3d.
// @param theLocation the location of the Axis2Placement3d.
// @param theAxis the axis of the Axis2Placement3d.
// @param theRefDirection the reference direction of the Axis2Placement3d.
// @return the added Axis2Placement3d.
Handle(StepGeom_Axis2Placement3d) addAxis2Placement3d(
const char* theName = nullptr,
const gp_XYZ& theLocation = gp_XYZ(0., 0., 0.),
const gp_XYZ& theAxis = gp_XYZ(0., 0., 1.),
const gp_XYZ& theRefDirection = gp_XYZ(0., 1., 0.)) const
{
const Handle(StepGeom_Axis2Placement3d) aAxis2Placement3d = new StepGeom_Axis2Placement3d;
const Handle(TCollection_HAsciiString) aName =
theName ? new TCollection_HAsciiString(theName) : new TCollection_HAsciiString();
aAxis2Placement3d->Init(aName,
addCartesianPoint(nullptr, theLocation),
true,
addDirection(nullptr, theAxis),
true,
addDirection(nullptr, theRefDirection));
myWS->Model()->AddWithRefs(aAxis2Placement3d);
return aAxis2Placement3d;
}
// Add a line to the model.
// @param theName the name of the line.
// @param theLocation the location of the line.
// @param theOrientation the orientation of the line vector.
// @param theMagnitude the magnitude of the line vector.
// @return the added line.
Handle(StepGeom_Line) addLine(const char* theName = nullptr,
const gp_XYZ& theLocation = gp_XYZ(0., 0., 0.),
const gp_XYZ& theOrientation = gp_XYZ(0., 0., 1.),
const double aMagnitude = 1.) const
{
const Handle(StepGeom_Line) aLine = new StepGeom_Line;
const Handle(TCollection_HAsciiString) aName =
theName ? new TCollection_HAsciiString(theName) : new TCollection_HAsciiString();
aLine->Init(aName,
addCartesianPoint(nullptr, theLocation),
addVector(nullptr, theOrientation, aMagnitude));
myWS->Model()->AddWithRefs(aLine);
return aLine;
}
// Add a circle to the model.
// @param theName the name of the circle.
// @param theLocation the location of the circle.
// @param theAxis the axis of the circle.
// @param theRefDirection the reference direction of the circle.
// @param theRadius the radius of the circle.
// @return the added circle.
Handle(StepGeom_Circle) addCircle(const char* theName = nullptr,
const gp_XYZ& theLocation = gp_XYZ(0., 0., 0.),
const gp_XYZ& theAxis = gp_XYZ(0., 0., 1.),
const gp_XYZ& theRefDirection = gp_XYZ(0., 1., 0.),
const double theRadius = 1.) const
{
const Handle(StepGeom_Circle) aCircle = new StepGeom_Circle;
const Handle(TCollection_HAsciiString) aName =
theName ? new TCollection_HAsciiString(theName) : new TCollection_HAsciiString();
StepGeom_Axis2Placement aSelector;
aSelector.SetValue(addAxis2Placement3d(nullptr, theLocation, theAxis, theRefDirection));
aCircle->Init(aName, aSelector, theRadius);
myWS->Model()->AddWithRefs(aCircle);
return aCircle;
}
// Add a plane to the model.
// @param theName the name of the plane.
// @param theLocation the location of the plane.
// @param theAxis the axis of the plane.
// @param theRefDirection the reference direction of the plane.
// @return the added plane.
Handle(StepGeom_Plane) addPlane(const char* theName = nullptr,
const gp_XYZ& theLocation = gp_XYZ(0., 0., 0.),
const gp_XYZ& theAxis = gp_XYZ(0., 0., 1.),
const gp_XYZ& theRefDirection = gp_XYZ(0., 1., 0.)) const
{
const Handle(StepGeom_Plane) aPlane = new StepGeom_Plane;
const Handle(TCollection_HAsciiString) aName =
theName ? new TCollection_HAsciiString(theName) : new TCollection_HAsciiString();
aPlane->Init(aName, addAxis2Placement3d(nullptr, theLocation, theAxis, theRefDirection));
myWS->Model()->AddWithRefs(aPlane);
return aPlane;
}
// Add an entity to the model.
// @param theEntity the entity to add.
void addToModel(const Handle(Standard_Transient)& theEntity) const
{
myWS->Model()->AddWithRefs(theEntity);
}
protected:
Handle(XSControl_WorkSession) myWS;
};
#endif // _MergeSTEPEntities_BaseTestFixture_HeaderFile

594
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_CartesianPointProcessor_Test.cxx Normal file
View File

@ -0,0 +1,594 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_CartesianPointProcessor.hxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_BSplineCurveWithKnots.hxx>
#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
#include <StepGeom_BSplineSurfaceWithKnots.hxx>
#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <StepGeom_Line.hxx>
#include <StepGeom_RationalBSplineSurface.hxx>
#include <StepRepr_Representation.hxx>
#include <StepRepr_RepresentationContext.hxx>
#include <StepShape_GeometricCurveSet.hxx>
#include <StepShape_VertexPoint.hxx>
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_StyledItem.hxx>
class MergeSTEPEntities_CartesianPointProcessorTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
// Perform removal of duplicate Cartesian points.
TColStd_MapOfTransient replaceDuplicateCartesianPoints()
{
MergeSTEPEntities_CartesianPointProcessor aProcessor(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that points with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, DifferentNames)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint("FirstPt");
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint("SecondPt");
// Creating direction.
Handle(TColStd_HArray1OfReal) aDirCoords = new TColStd_HArray1OfReal(1, 3);
aDirCoords->SetValue(1, 0.);
aDirCoords->SetValue(2, 0.);
aDirCoords->SetValue(3, 1.);
Handle(StepGeom_Direction) aDir = new StepGeom_Direction;
aDir->Init(new TCollection_HAsciiString, aDirCoords);
addToModel(aDir);
// Creating axis containing the first Cartesian point.
Handle(StepGeom_Axis2Placement3d) aFirstAxis = new StepGeom_Axis2Placement3d;
aFirstAxis
->Init(new TCollection_HAsciiString, aPt1, Standard_True, aDir, Standard_False, nullptr);
addToModel(aFirstAxis);
// Creating axis containing the second Cartesian point.
Handle(StepGeom_Axis2Placement3d) aSecondAxis = new StepGeom_Axis2Placement3d;
aSecondAxis
->Init(new TCollection_HAsciiString, aPt2, Standard_True, aDir, Standard_False, nullptr);
addToModel(aSecondAxis);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that nothing was removed.
EXPECT_TRUE(aRemovedEntities.IsEmpty());
}
// Check that points with the same coordinates and same names are
// merged for StepGeom_Axis2Placement3d.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Axis2Placement3d)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating direction.
Handle(TColStd_HArray1OfReal) aDirCoords = new TColStd_HArray1OfReal(1, 3);
aDirCoords->SetValue(1, 0.);
aDirCoords->SetValue(2, 0.);
aDirCoords->SetValue(3, 1.);
Handle(StepGeom_Direction) aDir = new StepGeom_Direction;
aDir->Init(new TCollection_HAsciiString, aDirCoords);
addToModel(aDir);
// Creating axis containing the first Cartesian point.
Handle(StepGeom_Axis2Placement3d) aFirstAxis = new StepGeom_Axis2Placement3d;
aFirstAxis
->Init(new TCollection_HAsciiString, aPt1, Standard_True, aDir, Standard_False, nullptr);
addToModel(aFirstAxis);
// Creating axis containing the second Cartesian point.
Handle(StepGeom_Axis2Placement3d) aSecondAxis = new StepGeom_Axis2Placement3d;
aSecondAxis
->Init(new TCollection_HAsciiString, aPt2, Standard_True, aDir, Standard_False, nullptr);
addToModel(aSecondAxis);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepShape_VertexPoint.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepShape_VertexPoint)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating vertex containing the first Cartesian point.
Handle(StepShape_VertexPoint) aFirstVertex = new StepShape_VertexPoint;
aFirstVertex->Init(new TCollection_HAsciiString, aPt1);
addToModel(aFirstVertex);
// Creating vertex containing the second Cartesian point.
Handle(StepShape_VertexPoint) aSecondVertex = new StepShape_VertexPoint;
aSecondVertex->Init(new TCollection_HAsciiString, aPt2);
addToModel(aSecondVertex);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepShape_GeometricCurveSet.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepShape_GeometricCurveSet)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating curve set containing the first Cartesian point.
Handle(StepShape_HArray1OfGeometricSetSelect) aFirstElements =
new StepShape_HArray1OfGeometricSetSelect(1, 1);
StepShape_GeometricSetSelect aFirstSelect;
aFirstSelect.SetValue(aPt1);
aFirstElements->SetValue(1, aFirstSelect);
addToModel(aFirstElements);
Handle(StepShape_GeometricCurveSet) aFirstCurveSet = new StepShape_GeometricCurveSet;
aFirstCurveSet->Init(new TCollection_HAsciiString, aFirstElements);
addToModel(aFirstCurveSet);
// Creating curve set containing the second Cartesian point.
Handle(StepShape_HArray1OfGeometricSetSelect) aSecondElements =
new StepShape_HArray1OfGeometricSetSelect(1, 1);
StepShape_GeometricSetSelect aSecondSelect;
aSecondSelect.SetValue(aPt2);
aSecondElements->SetValue(1, aSecondSelect);
addToModel(aSecondElements);
Handle(StepShape_GeometricCurveSet) aSecondCurveSet = new StepShape_GeometricCurveSet;
aSecondCurveSet->Init(new TCollection_HAsciiString, aSecondElements);
addToModel(aSecondCurveSet);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepVisual_PresentationLayerAssignment.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepVisual_PresentationLayerAssignment)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating presentation layer assignment containing the first Cartesian point.
Handle(StepVisual_HArray1OfLayeredItem) aFirstAssignedItems =
new StepVisual_HArray1OfLayeredItem(1, 1);
StepVisual_LayeredItem aFirstLayeredItem;
aFirstLayeredItem.SetValue(aPt1);
aFirstAssignedItems->SetValue(1, aFirstLayeredItem);
addToModel(aFirstAssignedItems);
Handle(StepVisual_PresentationLayerAssignment) aFirstAssignment =
new StepVisual_PresentationLayerAssignment;
aFirstAssignment->Init(new TCollection_HAsciiString,
new TCollection_HAsciiString,
aFirstAssignedItems);
addToModel(aFirstAssignment);
// Creating presentation layer assignment containing the second Cartesian point.
Handle(StepVisual_HArray1OfLayeredItem) aSecondAssignedItems =
new StepVisual_HArray1OfLayeredItem(1, 1);
StepVisual_LayeredItem aSecondLayeredItem;
aSecondLayeredItem.SetValue(aPt2);
aSecondAssignedItems->SetValue(1, aSecondLayeredItem);
addToModel(aSecondAssignedItems);
Handle(StepVisual_PresentationLayerAssignment) aSecondAssignment =
new StepVisual_PresentationLayerAssignment;
aSecondAssignment->Init(new TCollection_HAsciiString,
new TCollection_HAsciiString,
aSecondAssignedItems);
addToModel(aSecondAssignment);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepVisual_StyledItem.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepVisual_StyledItem)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating styled item containing the first Cartesian point.
Handle(StepVisual_HArray1OfPresentationStyleAssignment) aFirstAssignedItems =
new StepVisual_HArray1OfPresentationStyleAssignment(1, 1);
Handle(StepVisual_StyledItem) aFirstStyledItem = new StepVisual_StyledItem;
aFirstStyledItem->Init(new TCollection_HAsciiString, aFirstAssignedItems, aPt1);
addToModel(aFirstStyledItem);
// Creating styled item containing the second Cartesian point.
Handle(StepVisual_HArray1OfPresentationStyleAssignment) aSecondAssignedItems =
new StepVisual_HArray1OfPresentationStyleAssignment(1, 1);
Handle(StepVisual_StyledItem) aSecondStyledItem = new StepVisual_StyledItem;
aSecondStyledItem->Init(new TCollection_HAsciiString, aSecondAssignedItems, aPt2);
addToModel(aSecondStyledItem);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineCurveWithKnots.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineCurveWithKnots)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating curve containing the first Cartesian point.
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,
aFirstControlPoints,
StepGeom_bscfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified);
addToModel(aFirstCurve);
// Creating curve containing the second Cartesian point.
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,
aSecondControlPoints,
StepGeom_bscfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified);
addToModel(aSecondCurve);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepGeom_Line.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Line)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating line containing the first Cartesian point.
Handle(StepGeom_Line) aFirstLine = new StepGeom_Line;
aFirstLine->Init(new TCollection_HAsciiString, aPt1, new StepGeom_Vector);
addToModel(aFirstLine);
// Creating line containing the second Cartesian point.
Handle(StepGeom_Line) aSecondLine = new StepGeom_Line;
aSecondLine->Init(new TCollection_HAsciiString, aPt2, new StepGeom_Vector);
addToModel(aSecondLine);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineSurfaceWithKnots.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_BSplineSurfaceWithKnots)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating surface containing the first Cartesian point.
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,
1,
aFirstControlPoints,
StepGeom_bssfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified);
addToModel(aFirstSurface);
// Creating surface containing the second Cartesian point.
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,
1,
aSecondControlPoints,
StepGeom_bssfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified);
addToModel(aSecondSurface);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepGeom_Axis1Placement)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating axis containing the first Cartesian point.
Handle(StepGeom_Axis1Placement) aFirstAxis = new StepGeom_Axis1Placement;
aFirstAxis->Init(new TCollection_HAsciiString, aPt1, false, new StepGeom_Direction);
addToModel(aFirstAxis);
// Creating axis containing the second Cartesian point.
Handle(StepGeom_Axis1Placement) aSecondAxis = new StepGeom_Axis1Placement;
aSecondAxis->Init(new TCollection_HAsciiString, aPt2, false, new StepGeom_Direction);
addToModel(aSecondAxis);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepRepr_Representation.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest, StepRepr_Representation)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating representation containing the first Cartesian point.
Handle(StepRepr_HArray1OfRepresentationItem) aFirstItems =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aFirstItems->SetValue(1, aPt1);
Handle(StepRepr_Representation) aFirstRepresentation = new StepRepr_Representation;
aFirstRepresentation->Init(new TCollection_HAsciiString,
aFirstItems,
new StepRepr_RepresentationContext);
addToModel(aFirstRepresentation);
// Creating representation containing the second Cartesian point.
Handle(StepRepr_HArray1OfRepresentationItem) aSecondItems =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aSecondItems->SetValue(1, aPt2);
Handle(StepRepr_Representation) aSecondRepresentation = new StepRepr_Representation;
aSecondRepresentation->Init(new TCollection_HAsciiString,
aSecondItems,
new StepRepr_RepresentationContext);
addToModel(aSecondRepresentation);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating curve containing the first Cartesian point.
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,
1,
aFirstControlPoints,
StepGeom_bscfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified,
new TColStd_HArray1OfReal);
addToModel(aFirstCurve);
// Creating curve containing the second Cartesian point.
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,
1,
aSecondControlPoints,
StepGeom_bscfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified,
new TColStd_HArray1OfReal);
addToModel(aSecondCurve);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}
// Check that points with the same coordinates and same names are merged
// for StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.
TEST_F(MergeSTEPEntities_CartesianPointProcessorTest,
StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)
{
// Creating Cartesian points.
Handle(StepGeom_CartesianPoint) aPt1 = addCartesianPoint();
Handle(StepGeom_CartesianPoint) aPt2 = addCartesianPoint();
// Creating surface containing the first Cartesian point.
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,
1,
aFirstControlPoints,
StepGeom_bssfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified);
addToModel(aFirstBSSWN);
Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) aFirstSurface =
new StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface;
aFirstSurface->Init(new TCollection_HAsciiString,
1,
1,
aFirstControlPoints,
StepGeom_bssfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
StepData_LUnknown,
aFirstBSSWN,
new StepGeom_RationalBSplineSurface);
addToModel(aFirstSurface);
// Creating surface containing the second Cartesian point.
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,
1,
aSecondControlPoints,
StepGeom_bssfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
StepData_LUnknown,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfInteger,
new TColStd_HArray1OfReal,
new TColStd_HArray1OfReal,
StepGeom_ktUnspecified);
addToModel(aSecondBSSWN);
Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) aSecondSurface =
new StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface;
aSecondSurface->Init(new TCollection_HAsciiString,
1,
1,
aSecondControlPoints,
StepGeom_bssfUnspecified,
StepData_LUnknown,
StepData_LUnknown,
StepData_LUnknown,
new StepGeom_BSplineSurfaceWithKnots,
new StepGeom_RationalBSplineSurface);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCartesianPoints();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPt1) || aRemovedEntities.Contains(aPt2));
}

165
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_CircleProcessor_Test.cxx Normal file
View File

@ -0,0 +1,165 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_CircleProcessor.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepGeom_SeamCurve.hxx>
class MergeSTEPEntities_CircleProcessorTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateCircles()
{
MergeSTEPEntities_CircleProcessor aProcessor(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Circles with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_CircleProcessorTest, DifferentNames)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle("Circle1");
Handle(StepGeom_Circle) aCircle2 = addCircle("Circle2");
// Creating EdgeCurve containing the first Circle.
Handle(StepShape_EdgeCurve) aFirstEdgeCurve = new StepShape_EdgeCurve;
aFirstEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aCircle1,
Standard_True);
addToModel(aFirstEdgeCurve);
// Creating EdgeCurve containing the second Circle.
Handle(StepShape_EdgeCurve) aSecondEdgeCurve = new StepShape_EdgeCurve;
aSecondEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aCircle2,
Standard_True);
addToModel(aSecondEdgeCurve);
// Performing removal of duplicate Circles.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCircles();
// Check that nothing was removed.
EXPECT_TRUE(aRemovedEntities.IsEmpty());
}
// Check that equal Circles are merged for StepShape_EdgeCurve.
TEST_F(MergeSTEPEntities_CircleProcessorTest, StepShape_EdgeCurve)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle();
Handle(StepGeom_Circle) aCircle2 = addCircle();
// Creating EdgeCurve containing the first Circle.
Handle(StepShape_EdgeCurve) aFirstEdgeCurve = new StepShape_EdgeCurve;
aFirstEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aCircle1,
Standard_True);
addToModel(aFirstEdgeCurve);
// Creating EdgeCurve containing the second Circle.
Handle(StepShape_EdgeCurve) aSecondEdgeCurve = new StepShape_EdgeCurve;
aSecondEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aCircle2,
Standard_True);
addToModel(aSecondEdgeCurve);
// Performing removal of duplicate Circles.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCircles();
// Check that one Circle was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aCircle1) || aRemovedEntities.Contains(aCircle2));
}
// Check that equal Circles are merged for StepGeom_SurfaceCurve.
TEST_F(MergeSTEPEntities_CircleProcessorTest, StepGeom_SurfaceCurve)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle();
Handle(StepGeom_Circle) aCircle2 = addCircle();
// Creating SurfaceCurve containing the first Circle.
Handle(StepGeom_SurfaceCurve) aFirstSurfaceCurve = new StepGeom_SurfaceCurve;
aFirstSurfaceCurve->Init(new TCollection_HAsciiString,
aCircle1,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aFirstSurfaceCurve);
// Creating SurfaceCurve containing the second Circle.
Handle(StepGeom_SurfaceCurve) aSecondSurfaceCurve = new StepGeom_SurfaceCurve;
aSecondSurfaceCurve->Init(new TCollection_HAsciiString,
aCircle2,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aSecondSurfaceCurve);
// Performing removal of duplicate Circles.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCircles();
// Check that one Circle was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aCircle1) || aRemovedEntities.Contains(aCircle2));
}
// Check that equal Circles are merged for StepGeom_SeamCurve.
TEST_F(MergeSTEPEntities_CircleProcessorTest, StepGeom_SeamCurve)
{
// Creating Circles.
Handle(StepGeom_Circle) aCircle1 = addCircle();
Handle(StepGeom_Circle) aCircle2 = addCircle();
// Creating SeamCurve containing the first Circle.
Handle(StepGeom_SeamCurve) aFirstSeamCurve = new StepGeom_SeamCurve;
aFirstSeamCurve->Init(new TCollection_HAsciiString,
aCircle1,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aFirstSeamCurve);
// Creating SeamCurve containing the second Circle.
Handle(StepGeom_SeamCurve) aSecondSeamCurve = new StepGeom_SeamCurve;
aSecondSeamCurve->Init(new TCollection_HAsciiString,
aCircle2,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aSecondSeamCurve);
// Performing removal of duplicate Circles.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateCircles();
// Check that one Circle was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aCircle1) || aRemovedEntities.Contains(aCircle2));
}

157
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_DirectionProcessor_Test.cxx Normal file
View File

@ -0,0 +1,157 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_DirectionProcessor.hxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
class MergeSTEPEntities_DirectionProcessorTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateDirections()
{
MergeSTEPEntities_DirectionProcessor aProcessor(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that directions with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, DifferentNames)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection("dir1");
Handle(StepGeom_Direction) aDir2 = addDirection("dir2");
// Creating vector containing the first direction.
Handle(StepGeom_Vector) aFirstVector = new StepGeom_Vector;
aFirstVector->Init(new TCollection_HAsciiString, aDir1, 1.);
addToModel(aFirstVector);
// Creating vector containing the second direction.
Handle(StepGeom_Vector) aSecondVector = new StepGeom_Vector;
aSecondVector->Init(new TCollection_HAsciiString, aDir2, 1.);
addToModel(aSecondVector);
// Performing removal of duplicate directions.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateDirections();
// Check that nothing was removed.
EXPECT_TRUE(aRemovedEntities.IsEmpty());
}
// Check that directions with the same coordinates and same names are
// merged for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Axis1Placement)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();
Handle(StepGeom_Direction) aDir2 = addDirection();
// Creating Cartesian point for the location.
Handle(StepGeom_CartesianPoint) aLocation = new StepGeom_CartesianPoint;
Handle(TColStd_HArray1OfReal) aLocationCoords = new TColStd_HArray1OfReal(1, 3);
aLocationCoords->SetValue(1, 0.);
aLocationCoords->SetValue(2, 0.);
aLocationCoords->SetValue(3, 0.);
aLocation->Init(new TCollection_HAsciiString, aLocationCoords);
addToModel(aLocation);
// Creating axis containing the first direction.
Handle(StepGeom_Axis1Placement) aFirstAxis = new StepGeom_Axis1Placement;
aFirstAxis->Init(new TCollection_HAsciiString, aLocation, true, aDir1);
addToModel(aFirstAxis);
// Creating axis containing the second direction.
Handle(StepGeom_Axis1Placement) aSecondAxis = new StepGeom_Axis1Placement;
aSecondAxis->Init(new TCollection_HAsciiString, aLocation, true, aDir2);
addToModel(aSecondAxis);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateDirections();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aDir1) || aRemovedEntities.Contains(aDir2));
}
// Check that directions with the same coordinates and same names are
// merged for StepGeom_Axis2Placement.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Axis2Placement)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();
Handle(StepGeom_Direction) aDir2 = addDirection();
// Creating Cartesian point for the location.
Handle(StepGeom_CartesianPoint) aLocation = new StepGeom_CartesianPoint;
Handle(TColStd_HArray1OfReal) aLocationCoords = new TColStd_HArray1OfReal(1, 3);
aLocationCoords->SetValue(1, 0.);
aLocationCoords->SetValue(2, 0.);
aLocationCoords->SetValue(3, 0.);
aLocation->Init(new TCollection_HAsciiString, aLocationCoords);
addToModel(aLocation);
// Creating axis containing the first direction.
Handle(StepGeom_Axis2Placement3d) aFirstAxis = new StepGeom_Axis2Placement3d;
aFirstAxis->Init(new TCollection_HAsciiString, aLocation, true, aDir1, false, nullptr);
addToModel(aFirstAxis);
// Creating axis containing the second direction.
Handle(StepGeom_Axis2Placement3d) aSecondAxis = new StepGeom_Axis2Placement3d;
aSecondAxis->Init(new TCollection_HAsciiString, aLocation, true, aDir2, false, nullptr);
addToModel(aSecondAxis);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateDirections();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aDir1) || aRemovedEntities.Contains(aDir2));
}
// Check that points with the same coordinates and same names are
// merged for StepGeom_Vector.
TEST_F(MergeSTEPEntities_DirectionProcessorTest, StepGeom_Vector)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();
Handle(StepGeom_Direction) aDir2 = addDirection();
// Creating vector containing the first direction.
Handle(StepGeom_Vector) aFirstVector = new StepGeom_Vector;
aFirstVector->Init(new TCollection_HAsciiString, aDir1, 1.);
addToModel(aFirstVector);
// Creating vector containing the second direction.
Handle(StepGeom_Vector) aSecondVector = new StepGeom_Vector;
aSecondVector->Init(new TCollection_HAsciiString, aDir2, 1.);
addToModel(aSecondVector);
// Performing removal of duplicate Cartesian points.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateDirections();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aDir1) || aRemovedEntities.Contains(aDir2));
}

239
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_LineProcessor_Test.cxx Normal file
View File

@ -0,0 +1,239 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_LineProcessor.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepGeom_TrimmedCurve.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
#include <StepGeom_SeamCurve.hxx>
#include <StepRepr_RepresentationContext.hxx>
class MergeSTEPEntities_LineProcessorTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateLines()
{
MergeSTEPEntities_LineProcessor aProcessor(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Lines with different names are not merged.
TEST_F(MergeSTEPEntities_LineProcessorTest, DifferentNames)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine("Line1");
Handle(StepGeom_Line) aLine2 = addLine("Line2");
// Creating EdgeCurve containing the first Line.
Handle(StepShape_EdgeCurve) aFirstEdgeCurve = new StepShape_EdgeCurve;
aFirstEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aLine1,
Standard_True);
addToModel(aFirstEdgeCurve);
// Creating EdgeCurve containing the second Line.
Handle(StepShape_EdgeCurve) aSecondEdgeCurve = new StepShape_EdgeCurve;
aSecondEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aLine2,
Standard_True);
addToModel(aSecondEdgeCurve);
// Performing removal of duplicate Lines.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateLines();
// Check that nothing was removed.
EXPECT_TRUE(aRemovedEntities.IsEmpty());
}
// Check that equal Lines are merged for StepShape_EdgeCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepShape_EdgeCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
Handle(StepGeom_Line) aLine2 = addLine();
// Creating EdgeCurve containing the first Line.
Handle(StepShape_EdgeCurve) aFirstEdgeCurve = new StepShape_EdgeCurve;
aFirstEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aLine1,
Standard_True);
addToModel(aFirstEdgeCurve);
// Creating EdgeCurve containing the second Line.
Handle(StepShape_EdgeCurve) aSecondEdgeCurve = new StepShape_EdgeCurve;
aSecondEdgeCurve->Init(new TCollection_HAsciiString,
new StepShape_Vertex,
new StepShape_Vertex,
aLine2,
Standard_True);
addToModel(aSecondEdgeCurve);
// Performing removal of duplicate Lines.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateLines();
// Check that one Line was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aLine1) || aRemovedEntities.Contains(aLine2));
}
// Check that equal Lines are merged for StepGeom_TrimmedCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_TrimmedCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
Handle(StepGeom_Line) aLine2 = addLine();
// Creating TrimmedCurve containing the first Line.
Handle(StepGeom_TrimmedCurve) aFirstTrimmedCurve = new StepGeom_TrimmedCurve;
aFirstTrimmedCurve->Init(new TCollection_HAsciiString,
aLine1,
new StepGeom_HArray1OfTrimmingSelect,
new StepGeom_HArray1OfTrimmingSelect,
Standard_True,
StepGeom_tpUnspecified);
addToModel(aFirstTrimmedCurve);
// Creating TrimmedCurve containing the second Line.
Handle(StepGeom_TrimmedCurve) aSecondTrimmedCurve = new StepGeom_TrimmedCurve;
aSecondTrimmedCurve->Init(new TCollection_HAsciiString,
aLine2,
new StepGeom_HArray1OfTrimmingSelect,
new StepGeom_HArray1OfTrimmingSelect,
Standard_True,
StepGeom_tpUnspecified);
addToModel(aSecondTrimmedCurve);
// Performing removal of duplicate Lines.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateLines();
// Check that one Line was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aLine1) || aRemovedEntities.Contains(aLine2));
}
// Check that equal Lines are merged for StepGeom_SurfaceCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_SurfaceCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
Handle(StepGeom_Line) aLine2 = addLine();
// Creating SurfaceCurve containing the first Line.
Handle(StepGeom_SurfaceCurve) aFirstSurfaceCurve = new StepGeom_SurfaceCurve;
aFirstSurfaceCurve->Init(new TCollection_HAsciiString,
aLine1,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aFirstSurfaceCurve);
// Creating SurfaceCurve containing the second Line.
Handle(StepGeom_SurfaceCurve) aSecondSurfaceCurve = new StepGeom_SurfaceCurve;
aSecondSurfaceCurve->Init(new TCollection_HAsciiString,
aLine2,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aSecondSurfaceCurve);
// Performing removal of duplicate Lines.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateLines();
// Check that one Line was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aLine1) || aRemovedEntities.Contains(aLine2));
}
// Check that equal Lines are merged for StepRepr_DefinitionalRepresentation.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepRepr_DefinitionalRepresentation)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
Handle(StepGeom_Line) aLine2 = addLine();
// Creating DefinitionalRepresentation containing the first Line.
Handle(StepRepr_HArray1OfRepresentationItem) aFirstItems =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aFirstItems->SetValue(1, aLine1);
Handle(StepRepr_DefinitionalRepresentation) aFirstDefinitionalRepresentation =
new StepRepr_DefinitionalRepresentation;
aFirstDefinitionalRepresentation->Init(new TCollection_HAsciiString,
aFirstItems,
new StepRepr_RepresentationContext);
addToModel(aFirstDefinitionalRepresentation);
// Creating DefinitionalRepresentation containing the second Line.
Handle(StepRepr_HArray1OfRepresentationItem) aSecondItems =
new StepRepr_HArray1OfRepresentationItem(1, 1);
aSecondItems->SetValue(1, aLine2);
Handle(StepRepr_DefinitionalRepresentation) aSecondDefinitionalRepresentation =
new StepRepr_DefinitionalRepresentation;
aSecondDefinitionalRepresentation->Init(new TCollection_HAsciiString,
aSecondItems,
new StepRepr_RepresentationContext);
// Performing removal of duplicate Lines.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateLines();
// Check that one Line was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aLine1) || aRemovedEntities.Contains(aLine2));
}
// Check that equal Lines are merged for StepGeom_SeamCurve.
TEST_F(MergeSTEPEntities_LineProcessorTest, StepGeom_SeamCurve)
{
// Creating Lines.
Handle(StepGeom_Line) aLine1 = addLine();
Handle(StepGeom_Line) aLine2 = addLine();
// Creating SeamCurve containing the first Line.
Handle(StepGeom_SeamCurve) aFirstSeamCurve = new StepGeom_SeamCurve;
aFirstSeamCurve->Init(new TCollection_HAsciiString,
aLine1,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aFirstSeamCurve);
// Creating SeamCurve containing the second Line.
Handle(StepGeom_SeamCurve) aSecondSeamCurve = new StepGeom_SeamCurve;
aSecondSeamCurve->Init(new TCollection_HAsciiString,
aLine2,
new StepGeom_HArray1OfPcurveOrSurface,
StepGeom_pscrCurve3d);
addToModel(aSecondSeamCurve);
// Performing removal of duplicate Lines.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateLines();
// Check that one Line was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aLine1) || aRemovedEntities.Contains(aLine2));
}

113
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_Merger_Test.cxx Normal file
View File

@ -0,0 +1,113 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_Merger.hxx>
#include <StepGeom_Axis1Placement.hxx>
class MergeSTEPEntities_MergerTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
// Get the number of entities of the specified type.
// @param theType the type of entities to count.
// @return the number of entities of the specified type.
int getEntitiesCount(const Handle(Standard_Type)& theType) const
{
int aCount = 0;
for (Standard_Integer i = 1; i <= myWS->Model()->NbEntities(); i++)
{
if (myWS->Model()->Value(i)->IsKind(theType))
{
aCount++;
}
}
return aCount;
}
//! Perform removal of duplicate entities points.
void performRemoval()
{
MergeSTEPEntities_Merger aMerger(myWS);
aMerger.Perform();
}
};
// Check that entities with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_MergerTest, DifferentEntities)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection("dir1");
Handle(StepGeom_Direction) aDir2 = addDirection("dir2");
// Creating vector containing the first direction.
Handle(StepGeom_Vector) aFirstVector = new StepGeom_Vector;
aFirstVector->Init(new TCollection_HAsciiString, aDir1, 1.);
addToModel(aFirstVector);
// Creating vector containing the second direction.
Handle(StepGeom_Vector) aSecondVector = new StepGeom_Vector;
aSecondVector->Init(new TCollection_HAsciiString, aDir2, 1.);
addToModel(aSecondVector);
const int aDirectionCountBefore = getEntitiesCount(STANDARD_TYPE(StepGeom_Direction));
// Performing removal of duplicate directions.
performRemoval();
const int aDirectionCountAfter = getEntitiesCount(STANDARD_TYPE(StepGeom_Direction));
// Check that nothing was removed.
EXPECT_EQ(aDirectionCountBefore, 2);
EXPECT_EQ(aDirectionCountBefore, aDirectionCountAfter);
}
// Check that entities with the same coordinates and same names are
// merged for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_MergerTest, EqualEntities)
{
// Creating directions.
Handle(StepGeom_Direction) aDir1 = addDirection();
Handle(StepGeom_Direction) aDir2 = addDirection();
// Creating Cartesian point for the location.
Handle(StepGeom_CartesianPoint) aLocation = new StepGeom_CartesianPoint;
Handle(TColStd_HArray1OfReal) aLocationCoords = new TColStd_HArray1OfReal(1, 3);
aLocationCoords->SetValue(1, 0.);
aLocationCoords->SetValue(2, 0.);
aLocationCoords->SetValue(3, 0.);
aLocation->Init(new TCollection_HAsciiString, aLocationCoords);
addToModel(aLocation);
// Creating axis containing the first direction.
Handle(StepGeom_Axis1Placement) aFirstAxis = new StepGeom_Axis1Placement;
aFirstAxis->Init(new TCollection_HAsciiString, aLocation, true, aDir1);
addToModel(aFirstAxis);
// Creating axis containing the second direction.
Handle(StepGeom_Axis1Placement) aSecondAxis = new StepGeom_Axis1Placement;
aSecondAxis->Init(new TCollection_HAsciiString, aLocation, true, aDir2);
addToModel(aSecondAxis);
const int aDirectionCountBefore = getEntitiesCount(STANDARD_TYPE(StepGeom_Direction));
// Performing removal of duplicate directions.
performRemoval();
const int aDirectionCountAfter = getEntitiesCount(STANDARD_TYPE(StepGeom_Direction));
// Check that one direction was removed.
EXPECT_EQ(aDirectionCountBefore, 2);
EXPECT_EQ(aDirectionCountAfter, 1);
}

128
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_PlaneProcessor_Test.cxx Normal file
View File

@ -0,0 +1,128 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_PlaneProcessor.hxx>
#include <StepShape_AdvancedFace.hxx>
#include <StepGeom_Pcurve.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
class MergeSTEPEntities_PlaneProcessorTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicatePlanes()
{
MergeSTEPEntities_PlaneProcessor aProcessor(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Planes with different names are not merged.
TEST_F(MergeSTEPEntities_PlaneProcessorTest, DifferentNames)
{
// Creating Planes.
Handle(StepGeom_Plane) aPlane1 = addPlane("Plane1");
Handle(StepGeom_Plane) aPlane2 = addPlane("Plane2");
// Creating StepShape_AdvancedFace containing the first Plane.
Handle(StepShape_AdvancedFace) aFirstAdvancedFace = new StepShape_AdvancedFace;
aFirstAdvancedFace->Init(new TCollection_HAsciiString,
new StepShape_HArray1OfFaceBound,
aPlane1,
Standard_True);
addToModel(aFirstAdvancedFace);
// Creating StepShape_AdvancedFace containing the second Plane.
Handle(StepShape_AdvancedFace) aSecondAdvancedFace = new StepShape_AdvancedFace;
aSecondAdvancedFace->Init(new TCollection_HAsciiString,
new StepShape_HArray1OfFaceBound,
aPlane2,
Standard_True);
addToModel(aSecondAdvancedFace);
// Performing removal of duplicate Planes.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicatePlanes();
// Check that nothing was removed.
EXPECT_TRUE(aRemovedEntities.IsEmpty());
}
// Check that equal Planes are merged for StepShape_AdvancedFace.
TEST_F(MergeSTEPEntities_PlaneProcessorTest, StepShape_AdvancedFace)
{
// Creating Planes.
Handle(StepGeom_Plane) aPlane1 = addPlane();
Handle(StepGeom_Plane) aPlane2 = addPlane();
// Creating StepShape_AdvancedFace containing the first Plane.
Handle(StepShape_AdvancedFace) aFirstAdvancedFace = new StepShape_AdvancedFace;
aFirstAdvancedFace->Init(new TCollection_HAsciiString,
new StepShape_HArray1OfFaceBound,
aPlane1,
Standard_True);
addToModel(aFirstAdvancedFace);
// Creating StepShape_AdvancedFace containing the second Plane.
Handle(StepShape_AdvancedFace) aSecondAdvancedFace = new StepShape_AdvancedFace;
aSecondAdvancedFace->Init(new TCollection_HAsciiString,
new StepShape_HArray1OfFaceBound,
aPlane2,
Standard_True);
addToModel(aSecondAdvancedFace);
// Performing removal of duplicate Planes.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicatePlanes();
// Check that one Plane was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPlane1) || aRemovedEntities.Contains(aPlane2));
}
// Check that equal Planes are merged for StepGeom_Pcurve.
TEST_F(MergeSTEPEntities_PlaneProcessorTest, StepGeom_Pcurve)
{
// Creating Planes.
Handle(StepGeom_Plane) aPlane1 = addPlane();
Handle(StepGeom_Plane) aPlane2 = addPlane();
// Creating StepGeom_Pcurve containing the first Plane.
Handle(StepGeom_Pcurve) aFirstPcurve = new StepGeom_Pcurve;
aFirstPcurve->Init(new TCollection_HAsciiString,
aPlane1,
new StepRepr_DefinitionalRepresentation);
addToModel(aFirstPcurve);
// Creating StepGeom_Pcurve containing the second Plane.
Handle(StepGeom_Pcurve) aSecondPcurve = new StepGeom_Pcurve;
aSecondPcurve->Init(new TCollection_HAsciiString,
aPlane2,
new StepRepr_DefinitionalRepresentation);
addToModel(aSecondPcurve);
// Performing removal of duplicate Planes.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicatePlanes();
// Check that one Plane was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aPlane1) || aRemovedEntities.Contains(aPlane2));
}

92
src/DataExchange/TKDESTEP/GTests/MergeSTEPEntities_VectorProcessor_Test.cxx Normal file
View File

@ -0,0 +1,92 @@
// 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_BaseTestFixture.hxx"
#include <MergeSTEPEntities_VectorProcessor.hxx>
#include <StepGeom_Line.hxx>
class MergeSTEPEntities_VectorProcessorTest : public MergeSTEPEntities_BaseTestFixture
{
protected:
//! Perform removal of duplicate entities.
TColStd_MapOfTransient replaceDuplicateVectors()
{
MergeSTEPEntities_VectorProcessor aProcessor(myWS);
for (Standard_Integer anIndex = 1; anIndex <= myWS->Model()->NbEntities(); ++anIndex)
{
aProcessor.ProcessEntity(myWS->Model()->Value(anIndex));
}
TColStd_MapOfTransient aRemovedEntities;
aProcessor.Perform(aRemovedEntities);
return aRemovedEntities;
}
};
// Check that Vectors with the same coordinates and different names are not merged.
TEST_F(MergeSTEPEntities_VectorProcessorTest, DifferentNames)
{
// Creating Vectors.
Handle(StepGeom_Vector) aVec1 = addVector("vec1");
Handle(StepGeom_Vector) aVec2 = addVector("vec2");
// Creating a cartesian point for the lines.
Handle(StepGeom_CartesianPoint) aPnt = addCartesianPoint(nullptr, {0., 0., 0.});
// Creating aLine containing the first Vector.
Handle(StepGeom_Line) aLine1 = new StepGeom_Line;
aLine1->Init(new TCollection_HAsciiString, aPnt, aVec1);
addToModel(aLine1);
// Creating aLine containing the second Vector.
Handle(StepGeom_Line) aLine2 = new StepGeom_Line;
aLine2->Init(new TCollection_HAsciiString, aPnt, aVec2);
addToModel(aLine2);
// Performing removal of duplicate Vectors.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateVectors();
// Check that nothing was removed.
EXPECT_TRUE(aRemovedEntities.IsEmpty());
}
// Check that Vectors with the same coordinates and same names are
// merged for StepGeom_Axis1Placement.
TEST_F(MergeSTEPEntities_VectorProcessorTest, StepGeom_Line)
{
// Creating Vectors.
Handle(StepGeom_Vector) aVec1 = addVector();
Handle(StepGeom_Vector) aVec2 = addVector();
// Creating a cartesian point for the lines.
Handle(StepGeom_CartesianPoint) aPnt = addCartesianPoint(nullptr, {0., 0., 0.});
// Creating aLine containing the first Vector.
Handle(StepGeom_Line) aLine1 = new StepGeom_Line;
aLine1->Init(new TCollection_HAsciiString, aPnt, aVec1);
addToModel(aLine1);
// Creating aLine containing the second Vector.
Handle(StepGeom_Line) aLine2 = new StepGeom_Line;
aLine2->Init(new TCollection_HAsciiString, aPnt, aVec2);
addToModel(aLine2);
// Performing removal of duplicate Vectors.
TColStd_MapOfTransient aRemovedEntities = replaceDuplicateVectors();
// Check that duplicate was removed.
EXPECT_EQ(aRemovedEntities.Size(), 1);
EXPECT_TRUE(aRemovedEntities.Contains(aVec1) || aRemovedEntities.Contains(aVec2));
}

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

@ -0,0 +1,30 @@
# 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
)

80
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement2dHasher.hxx Normal file
View File

@ -0,0 +1,80 @@
// 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_Axis2Placement2dHasher_HeaderFile
#define _MergeSTEPEntities_Axis2Placement2dHasher_HeaderFile
#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
{
// 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()),
thePlacement->HasRefDirection()
? MergeSTEPEntities_DirectionHasher{}(thePlacement->RefDirection())
: opencascade::MurmurHash::optimalSeed()};
const size_t aHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (thePlacement->Name().IsNull())
{
// If the name is not present, return the hash.
return aHash;
}
// Add the name to the hash if it is present.
const size_t aHashWithName[2]{
aHash,
std::hash<TCollection_AsciiString>{}(thePlacement->Name()->String())};
return opencascade::hashBytes(aHashWithName, sizeof(aHashWithName));
}
// Compares two axis placements.
bool operator()(const Handle(StepGeom_Axis2Placement2d)& thePlacement1,
const Handle(StepGeom_Axis2Placement2d)& thePlacement2) const noexcept
{
// Compare names.
if (thePlacement1->Name().IsNull() != thePlacement2->Name().IsNull())
{
return false;
}
if (!thePlacement1->Name()->IsSameString(thePlacement2->Name()))
{
return false;
}
// Compare location, axis, and ref direction.
const bool isSameLocation = MergeSTEPEntities_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 =
thePlacement1->HasRefDirection() == thePlacement2->HasRefDirection();
const bool isSameRefDirection =
isSameRefDirectionFlag
&& (!thePlacement1->HasRefDirection()
|| MergeSTEPEntities_DirectionHasher{}(thePlacement1->RefDirection(),
thePlacement2->RefDirection()));
return isSameLocation && isSameRefDirection;
}
};
#endif // _MergeSTEPEntities_Axis2Placement2dHasher_HeaderFile

87
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement3dHasher.hxx Normal file
View File

@ -0,0 +1,87 @@
// 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_Axis2Placement3dHasher_HeaderFile
#define _MergeSTEPEntities_Axis2Placement3dHasher_HeaderFile
#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
{
// 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())
: opencascade::MurmurHash::optimalSeed(),
thePlacement->HasRefDirection()
? MergeSTEPEntities_DirectionHasher{}(thePlacement->RefDirection())
: opencascade::MurmurHash::optimalSeed()};
const size_t aHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (thePlacement->Name().IsNull())
{
// If the name is not present, return the hash.
return aHash;
}
// Add the name to the hash if it is present.
const size_t aHashWithName[2]{
aHash,
std::hash<TCollection_AsciiString>{}(thePlacement->Name()->String())};
return opencascade::hashBytes(aHashWithName, sizeof(aHashWithName));
}
// Compares two axis placements.
bool operator()(const Handle(StepGeom_Axis2Placement3d)& thePlacement1,
const Handle(StepGeom_Axis2Placement3d)& thePlacement2) const noexcept
{
// Compare names.
if (thePlacement1->Name().IsNull() != thePlacement2->Name().IsNull())
{
return false;
}
if (!thePlacement1->Name()->IsSameString(thePlacement2->Name()))
{
return false;
}
// Compare location, axis, and ref direction.
const bool isSameLocation = MergeSTEPEntities_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()));
// 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()));
return isSameLocation && isSameAxis && isSameRefDirection;
}
};
#endif // _MergeSTEPEntities_Axis2Placement3dHasher_HeaderFile

299
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement3dProcessor.cxx Normal file
View File

@ -0,0 +1,299 @@
// 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_Axis2Placement3dProcessor.hxx>
#include <StepGeom_Plane.hxx>
#include <StepRepr_ItemDefinedTransformation.hxx>
#include <StepGeom_CylindricalSurface.hxx>
#include <StepShape_ShapeRepresentation.hxx>
#include <StepRepr_ConstructiveGeometryRepresentation.hxx>
#include <StepGeom_Circle.hxx>
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_StyledItem.hxx>
#include <StepGeom_Ellipse.hxx>
#include <StepGeom_ConicalSurface.hxx>
#include <StepGeom_ToroidalSurface.hxx>
#include <StepShape_AdvancedBrepShapeRepresentation.hxx>
#include <StepGeom_SphericalSurface.hxx>
//==================================================================================================
MergeSTEPEntities_Axis2Placement3dProcessor::MergeSTEPEntities_Axis2Placement3dProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Axis2Placement3d,
MergeSTEPEntities_Axis2Placement3dHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepGeom_Plane), replacePlane);
registerReplacer(STANDARD_TYPE(StepRepr_ItemDefinedTransformation),
replaceItemDefinedTransformation);
registerReplacer(STANDARD_TYPE(StepGeom_CylindricalSurface), replaceCylindricalSurface);
registerReplacer(STANDARD_TYPE(StepShape_ShapeRepresentation), replaceShapeRepresentation);
registerReplacer(STANDARD_TYPE(StepRepr_ConstructiveGeometryRepresentation),
replaceConstructiveGeometryRepresentation);
registerReplacer(STANDARD_TYPE(StepGeom_Circle), replaceCircle);
registerReplacer(STANDARD_TYPE(StepVisual_PresentationLayerAssignment),
replacePresentationLayerAssignment);
registerReplacer(STANDARD_TYPE(StepVisual_StyledItem), replaceStyledItem);
registerReplacer(STANDARD_TYPE(StepGeom_Ellipse), replaceEllipse);
registerReplacer(STANDARD_TYPE(StepGeom_ConicalSurface), replaceConicalSurface);
registerReplacer(STANDARD_TYPE(StepGeom_ToroidalSurface), replaceToroidalSurface);
registerReplacer(STANDARD_TYPE(StepShape_AdvancedBrepShapeRepresentation),
replaceAdvancedBrepShapeRepresentation);
registerReplacer(STANDARD_TYPE(StepGeom_SphericalSurface), replaceSphericalSurface);
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replacePlane(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Plane) aSharing = Handle(StepGeom_Plane)::DownCast(theSharing);
if (aSharing->Position() == theOldEntity)
{
aSharing->SetPosition(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceItemDefinedTransformation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepRepr_ItemDefinedTransformation) aSharing =
Handle(StepRepr_ItemDefinedTransformation)::DownCast(theSharing);
bool isReplaced = false;
if (aSharing->TransformItem1() == theOldEntity)
{
aSharing->SetTransformItem1(theNewEntity);
isReplaced = true;
}
if (aSharing->TransformItem2() == theOldEntity)
{
aSharing->SetTransformItem2(theNewEntity);
isReplaced = true;
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceCylindricalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_CylindricalSurface) aSharing =
Handle(StepGeom_CylindricalSurface)::DownCast(theSharing);
if (aSharing->Position() == theOldEntity)
{
aSharing->SetPosition(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceShapeRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepShape_ShapeRepresentation) aSharing =
Handle(StepShape_ShapeRepresentation)::DownCast(theSharing);
bool isReplaced = false;
for (Standard_Integer anIndex = aSharing->Items()->Lower(); anIndex <= aSharing->Items()->Upper();
++anIndex)
{
if (aSharing->Items()->Value(anIndex) == theOldEntity)
{
aSharing->Items()->SetValue(anIndex, theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceConstructiveGeometryRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepRepr_ConstructiveGeometryRepresentation) aSharing =
Handle(StepRepr_ConstructiveGeometryRepresentation)::DownCast(theSharing);
bool isReplaced = false;
for (Standard_Integer anIndex = aSharing->Items()->Lower(); anIndex <= aSharing->Items()->Upper();
++anIndex)
{
if (aSharing->Items()->Value(anIndex) == theOldEntity)
{
aSharing->Items()->SetValue(anIndex, theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceCircle(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Circle) aSharing = Handle(StepGeom_Circle)::DownCast(theSharing);
StepGeom_Axis2Placement aSelector = aSharing->Position();
if (aSelector.Axis2Placement3d() == theOldEntity)
{
aSelector.SetValue(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replacePresentationLayerAssignment(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepVisual_PresentationLayerAssignment) aSharing =
Handle(StepVisual_PresentationLayerAssignment)::DownCast(theSharing);
bool isReplaced = false;
Handle(StepVisual_HArray1OfLayeredItem) anItems = aSharing->AssignedItems();
for (Standard_Integer anIndex = anItems->Lower(); anIndex <= anItems->Upper(); ++anIndex)
{
StepVisual_LayeredItem& aLayeredItem = anItems->ChangeValue(anIndex);
if (aLayeredItem.RepresentationItem() == theOldEntity)
{
aLayeredItem.SetValue(theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceStyledItem(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepVisual_StyledItem) aSharing = Handle(StepVisual_StyledItem)::DownCast(theSharing);
if (aSharing->Item() == theOldEntity)
{
aSharing->SetItem(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceEllipse(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Ellipse) aSharing = Handle(StepGeom_Ellipse)::DownCast(theSharing);
StepGeom_Axis2Placement aSelector = aSharing->Position();
if (aSelector.Axis2Placement3d() == theOldEntity)
{
aSelector.SetValue(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceConicalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_ConicalSurface) aSharing = Handle(StepGeom_ConicalSurface)::DownCast(theSharing);
if (aSharing->Position() == theOldEntity)
{
aSharing->SetPosition(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceToroidalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_ToroidalSurface) aSharing =
Handle(StepGeom_ToroidalSurface)::DownCast(theSharing);
if (aSharing->Position() == theOldEntity)
{
aSharing->SetPosition(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceAdvancedBrepShapeRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepShape_AdvancedBrepShapeRepresentation) aSharing =
Handle(StepShape_AdvancedBrepShapeRepresentation)::DownCast(theSharing);
bool isReplaced = false;
for (Standard_Integer anIndex = aSharing->Items()->Lower(); anIndex <= aSharing->Items()->Upper();
++anIndex)
{
if (aSharing->Items()->Value(anIndex) == theOldEntity)
{
aSharing->Items()->SetValue(anIndex, theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_Axis2Placement3dProcessor::replaceSphericalSurface(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_SphericalSurface) aSharing =
Handle(StepGeom_SphericalSurface)::DownCast(theSharing);
if (aSharing->Position() == theOldEntity)
{
aSharing->SetPosition(theNewEntity);
return true;
}
return false;
}

160
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Axis2Placement3dProcessor.hxx Normal file
View File

@ -0,0 +1,160 @@
// 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_Axis2Placement3dProcessor_HeaderFile
#define _MergeSTEPEntities_Axis2Placement3dProcessor_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_Axis2Placement3dHasher.hxx>
#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>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_Axis2Placement3dProcessor(
const Handle(XSControl_WorkSession)& theWS);
private:
//! Replaces the old axis placement with the new one in the StepGeom_Plane entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_Plane entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replacePlane(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepRepr_ItemDefinedTransformation
//! entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepRepr_ItemDefinedTransformation entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceItemDefinedTransformation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepGeom_CylindricalSurface entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_CylindricalSurface entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceCylindricalSurface(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepShape_ShapeRepresentation entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepShape_ShapeRepresentation entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceShapeRepresentation(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the
//! StepRepr_ConstructiveGeometryRepresentation entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepRepr_ConstructiveGeometryRepresentation entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceConstructiveGeometryRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepGeom_Circle entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_Circle entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceCircle(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepGeom_PresentationLayerAssignment
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_PresentationLayerAssignment entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replacePresentationLayerAssignment(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepVisual_StyledItem entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepVisual_StyledItem entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceStyledItem(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepGeom_Ellipse entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_Ellipse entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceEllipse(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepGeom_ConicalSurface entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_ConicalSurface entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceConicalSurface(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepGeom_ToroidalSurface entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_ToroidalSurface entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceToroidalSurface(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the
//! StepShape_AdvancedBrepShapeRepresentation entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepShape_AdvancedBrepShapeRepresentation entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceAdvancedBrepShapeRepresentation(
const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old axis placement with the new one in the StepGeom_SphericalSurface entity.
//! @param theOldEntity the old axis placement.
//! @param theNewEntity the new axis placement to replace the old one.
//! @param theSharing the StepGeom_SphericalSurface entity to update.
//! @return true if the axis placement was replaced, false otherwise.
static bool replaceSphericalSurface(const Handle(StepGeom_Axis2Placement3d)& theOldEntity,
const Handle(StepGeom_Axis2Placement3d)& theNewEntity,
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_DirectionProcessor_HeaderFile

74
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CartesianPointHasher.hxx Normal file
View File

@ -0,0 +1,74 @@
// 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_CartesianPointHasher_HeaderFile
#define _MergeSTEPEntities_CartesianPointHasher_HeaderFile
#include <Standard_HashUtils.hxx>
#include <StepGeom_CartesianPoint.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_CartesianPoint entities.
struct MergeSTEPEntities_CartesianPointHasher
{
// Hashes the Cartesian point by its name and coordinates.
std::size_t operator()(const Handle(StepGeom_CartesianPoint)& theCartesianPoint) const noexcept
{
const std::array<Standard_Real, 3>& aCoords = theCartesianPoint->Coordinates();
// If Cartesian point has no name, hash only coordinates.
if (theCartesianPoint->Name().IsNull())
{
return opencascade::hashBytes(aCoords.data(), static_cast<int>(aCoords.size()));
}
// Otherwise, hash both coordinates and name.
const size_t aHashes[2]{
opencascade::hashBytes(aCoords.data(), static_cast<int>(aCoords.size())),
std::hash<TCollection_AsciiString>{}(theCartesianPoint->Name()->String())};
return opencascade::hashBytes(aHashes, sizeof(aHashes));
}
// Compares two Cartesian points by their names and coordinates.
bool operator()(const Handle(StepGeom_CartesianPoint)& theCartesianPoint1,
const Handle(StepGeom_CartesianPoint)& theCartesianPoint2) const noexcept
{
// Compare names.
if (theCartesianPoint1->Name().IsNull() != theCartesianPoint2->Name().IsNull())
{
return false;
}
if (!theCartesianPoint1->Name()->IsSameString(theCartesianPoint2->Name()))
{
return false;
}
// Compare coordinates.
constexpr double aTolerance = 1e-12;
const std::array<Standard_Real, 3>& aCoords1 = theCartesianPoint1->Coordinates();
const std::array<Standard_Real, 3>& aCoords2 = theCartesianPoint2->Coordinates();
if (aCoords1.size() != aCoords2.size())
{
return false;
}
for (Standard_Integer anIndex = 0; anIndex < aCoords1.size(); ++anIndex)
{
if (std::abs(aCoords1[anIndex] - aCoords2[anIndex]) > aTolerance)
{
return false;
}
}
return true;
}
};
#endif // _MergeSTEPEntities_CartesianPointHasher_HeaderFile

303
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CartesianPointProcessor.cxx Normal file
View File

@ -0,0 +1,303 @@
// 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_CartesianPointProcessor.hxx>
#include <Interface_Graph.hxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_BSplineCurveWithKnots.hxx>
#include <StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.hxx>
#include <StepGeom_BSplineSurfaceWithKnots.hxx>
#include <StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.hxx>
#include <StepGeom_Line.hxx>
#include <StepRepr_Representation.hxx>
#include <StepShape_GeometricCurveSet.hxx>
#include <StepShape_VertexPoint.hxx>
#include <StepVisual_PresentationLayerAssignment.hxx>
#include <StepVisual_StyledItem.hxx>
//==================================================================================================
MergeSTEPEntities_CartesianPointProcessor::MergeSTEPEntities_CartesianPointProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_CartesianPoint,
MergeSTEPEntities_CartesianPointHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepGeom_Axis1Placement), replaceAxis1Placement);
registerReplacer(STANDARD_TYPE(StepGeom_Axis2Placement3d), replaceAxis2Placement3d);
registerReplacer(STANDARD_TYPE(StepShape_VertexPoint), replaceVertexPoint);
registerReplacer(STANDARD_TYPE(StepShape_GeometricCurveSet), replaceGeometricCurveSet);
registerReplacer(STANDARD_TYPE(StepVisual_PresentationLayerAssignment),
replacePresentationLayerAssignment);
registerReplacer(STANDARD_TYPE(StepVisual_StyledItem), replaceStyledItem);
registerReplacer(STANDARD_TYPE(StepGeom_BSplineCurveWithKnots), replaceBSplineCurveWithKnots);
registerReplacer(STANDARD_TYPE(StepGeom_Line), replaceLine);
registerReplacer(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnots), replaceBSplineSurfaceWithKnots);
registerReplacer(STANDARD_TYPE(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve),
replaceBSplineCurveWithKnotsAndRationalBSplineCurve);
registerReplacer(STANDARD_TYPE(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface),
replaceBSplineSurfaceWithKnotsAndRationalBSplineSurface);
registerReplacer(STANDARD_TYPE(StepRepr_Representation), replaceRepresentation);
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceAxis2Placement3d(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Axis2Placement3d) aSharing =
Handle(StepGeom_Axis2Placement3d)::DownCast(theSharing);
if (aSharing->Location() == theOldEntity)
{
aSharing->SetLocation(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceVertexPoint(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepShape_VertexPoint) aSharing = Handle(StepShape_VertexPoint)::DownCast(theSharing);
if (aSharing->VertexGeometry() == theOldEntity)
{
aSharing->SetVertexGeometry(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceGeometricCurveSet(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepShape_GeometricSet) aSharing = Handle(StepShape_GeometricSet)::DownCast(theSharing);
bool isReplaced = false;
for (auto& anElement : *aSharing->Elements())
{
const Handle(StepGeom_Point) aCurrentPoint = anElement.Point();
if (aCurrentPoint && aCurrentPoint == theOldEntity)
{
anElement.SetValue(theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replacePresentationLayerAssignment(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepVisual_PresentationLayerAssignment) aSharing =
Handle(StepVisual_PresentationLayerAssignment)::DownCast(theSharing);
bool isReplaced = false;
for (auto& anAssignedItem : *aSharing->AssignedItems())
{
const Handle(StepRepr_RepresentationItem) aRepItem = anAssignedItem.RepresentationItem();
if (aRepItem == theOldEntity)
{
anAssignedItem.SetValue(theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceStyledItem(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepVisual_StyledItem) aSharing = Handle(StepVisual_StyledItem)::DownCast(theSharing);
if (aSharing->Item() == theOldEntity)
{
aSharing->SetItem(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineCurveWithKnots(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_BSplineCurveWithKnots) aSharing =
Handle(StepGeom_BSplineCurveWithKnots)::DownCast(theSharing);
bool isReplaced = false;
Handle(StepGeom_HArray1OfCartesianPoint) aControlPoints = aSharing->ControlPointsList();
for (Standard_Integer anIndex = aControlPoints->Lower(); anIndex <= aControlPoints->Upper();
++anIndex)
{
if (aControlPoints->Value(anIndex) == theOldEntity)
{
aControlPoints->SetValue(anIndex, theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceLine(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Line) aSharing = Handle(StepGeom_Line)::DownCast(theSharing);
if (aSharing->Pnt() == theOldEntity)
{
aSharing->SetPnt(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineSurfaceWithKnots(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_BSplineSurfaceWithKnots) aSharing =
Handle(StepGeom_BSplineSurfaceWithKnots)::DownCast(theSharing);
bool isReplaced = false;
Handle(StepGeom_HArray2OfCartesianPoint) aControlPoints = aSharing->ControlPointsList();
for (Standard_Integer anIndexI = aControlPoints->LowerRow();
anIndexI <= aControlPoints->UpperRow();
++anIndexI)
{
for (Standard_Integer anIndexJ = aControlPoints->LowerCol();
anIndexJ <= aControlPoints->UpperCol();
++anIndexJ)
{
if (aControlPoints->Value(anIndexI, anIndexJ) == theOldEntity)
{
aControlPoints->SetValue(anIndexI, anIndexJ, theNewEntity);
isReplaced = true;
}
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceAxis1Placement(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Axis1Placement) aSharing = Handle(StepGeom_Axis1Placement)::DownCast(theSharing);
if (aSharing->Location() == theOldEntity)
{
aSharing->SetLocation(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceRepresentation(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepRepr_Representation) aSharing = Handle(StepRepr_Representation)::DownCast(theSharing);
bool isReplaced = false;
Handle(StepRepr_HArray1OfRepresentationItem) anItems = aSharing->Items();
for (Standard_Integer anIndex = 1; anIndex <= aSharing->NbItems(); ++anIndex)
{
const Handle(StepRepr_RepresentationItem) aRepItem = anItems->Value(anIndex);
if (aRepItem == theOldEntity)
{
anItems->SetValue(anIndex, theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::replaceBSplineCurveWithKnotsAndRationalBSplineCurve(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve) aSharing =
Handle(StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve)::DownCast(theSharing);
bool isReplaced = false;
Handle(StepGeom_HArray1OfCartesianPoint) aControlPoints = aSharing->ControlPointsList();
for (Standard_Integer anIndex = aControlPoints->Lower(); anIndex <= aControlPoints->Upper();
++anIndex)
{
if (aControlPoints->Value(anIndex) == theOldEntity)
{
aControlPoints->SetValue(anIndex, theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_CartesianPointProcessor::
replaceBSplineSurfaceWithKnotsAndRationalBSplineSurface(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface) aSharing =
Handle(StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface)::DownCast(theSharing);
bool isReplaced = false;
Handle(StepGeom_HArray2OfCartesianPoint) aControlPoints = aSharing->ControlPointsList();
for (Standard_Integer anIndexI = aControlPoints->LowerRow();
anIndexI <= aControlPoints->UpperRow();
++anIndexI)
{
for (Standard_Integer anIndexJ = aControlPoints->LowerCol();
anIndexJ <= aControlPoints->UpperCol();
++anIndexJ)
{
if (aControlPoints->Value(anIndexI, anIndexJ) == theOldEntity)
{
aControlPoints->SetValue(anIndexI, anIndexJ, theNewEntity);
isReplaced = true;
}
}
}
return isReplaced;
}

163
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CartesianPointProcessor.hxx Normal file
View File

@ -0,0 +1,163 @@
// 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_CartesianPointProcessor_HeaderFile
#define _MergeSTEPEntities_CartesianPointProcessor_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_CartesianPointHasher.hxx>
#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>
{
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);
private:
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepGeom_Axis2Placement3d.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepGeom_Axis2Placement3d sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceAxis2Placement3d(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepShape_VertexPoint.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepShape_VertexPoint sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceVertexPoint(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepShape_GeometricSet.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepShape_GeometricSet sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceGeometricCurveSet(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepVisual_PresentationLayerAssignment.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepVisual_PresentationLayerAssignment sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replacePresentationLayerAssignment(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepVisual_StyledItem.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepVisual_StyledItem sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceStyledItem(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepGeom_BSplineCurveWithKnots.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepGeom_BSplineCurveWithKnots sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceBSplineCurveWithKnots(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepGeom_Line.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepGeom_Line sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceLine(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepGeom_BSplineSurfaceWithKnots.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepGeom_BSplineSurfaceWithKnots sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceBSplineSurfaceWithKnots(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepGeom_Axis1Placement.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepGeom_Axis1Placement sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceAxis1Placement(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepRepr_Representation.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepRepr_Representation sharing the old entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceRepresentation(const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve sharing the old
//! entity.
//! @return True if the entity was replaced, false if it was not.
static bool replaceBSplineCurveWithKnotsAndRationalBSplineCurve(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old Cartesian point with the new Cartesian point in
//! the sharing StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface.
//! @param theOldEntity Old Cartesian point to replace.
//! @param theNewEntity New Cartesian point to replace the old entity with.
//! @param theSharing The StepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface sharing the
//! old entity.
static bool replaceBSplineSurfaceWithKnotsAndRationalBSplineSurface(
const Handle(StepGeom_CartesianPoint)& theOldEntity,
const Handle(StepGeom_CartesianPoint)& theNewEntity,
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_CartesianPointProcessor_HeaderFile

101
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CircleHasher.hxx Normal file
View File

@ -0,0 +1,101 @@
// 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_CircleHasher_HeaderFile
#define _MergeSTEPEntities_CircleHasher_HeaderFile
#include <MergeSTEPEntities_Axis2Placement2dHasher.hxx>
#include <MergeSTEPEntities_Axis2Placement3dHasher.hxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Circle.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Circle entities.
struct MergeSTEPEntities_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())
: !theCircle->Position().Axis2Placement3d().IsNull()
? MergeSTEPEntities_Axis2Placement3dHasher{}(theCircle->Position().Axis2Placement3d())
: opencascade::MurmurHash::optimalSeed();
const size_t aRadiusHash = opencascade::hash(static_cast<int>(theCircle->Radius()));
const size_t aHashes[2]{aPositionHash, aRadiusHash};
const size_t aCombinedHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (theCircle->Name().IsNull())
{
// If the name is not present, return the hash.
return aCombinedHash;
}
// Add the name to the hash if it is present.
const size_t aHashWithName[2]{
aCombinedHash,
std::hash<TCollection_AsciiString>{}(theCircle->Name()->String())};
return opencascade::hashBytes(aHashWithName, sizeof(aHashWithName));
}
//! Compares two Circle entities.
bool operator()(const Handle(StepGeom_Circle)& theCircle1,
const Handle(StepGeom_Circle)& theCircle2) const noexcept
{
// Compare names.
if (theCircle1->Name().IsNull() != theCircle2->Name().IsNull())
{
return false;
}
if (!theCircle1->Name()->IsSameString(theCircle2->Name()))
{
return false;
}
// Compare axis placements.
if (theCircle1->Position().CaseNumber() != theCircle2->Position().CaseNumber())
{
return false;
}
if (theCircle1->Position().CaseNumber() == 1)
{
if (!MergeSTEPEntities_Axis2Placement2dHasher{}(theCircle1->Position().Axis2Placement2d(),
theCircle2->Position().Axis2Placement2d()))
{
return false;
}
}
else if (theCircle1->Position().CaseNumber() == 2)
{
if (!MergeSTEPEntities_Axis2Placement3dHasher{}(theCircle1->Position().Axis2Placement3d(),
theCircle2->Position().Axis2Placement3d()))
{
return false;
}
}
// Compare radius.
constexpr Standard_Real aTolerance = 1e-12;
if (Abs(theCircle1->Radius() - theCircle2->Radius()) > aTolerance)
{
return false;
}
return true;
}
};
#endif // _MergeSTEPEntities_CircleHasher_HeaderFile

91
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CircleProcessor.cxx Normal file
View File

@ -0,0 +1,91 @@
// 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.
// 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 <Interface_Graph.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepGeom_SeamCurve.hxx>
//==================================================================================================
MergeSTEPEntities_CircleProcessor::MergeSTEPEntities_CircleProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Circle, MergeSTEPEntities_CircleHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepShape_EdgeCurve), replaceEdgeCurve);
registerReplacer(STANDARD_TYPE(StepGeom_SurfaceCurve), replaceSurfaceCurve);
registerReplacer(STANDARD_TYPE(StepGeom_SeamCurve), replaceSeamCurve);
}
//==================================================================================================
bool MergeSTEPEntities_CircleProcessor::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)
{
aSharing->SetEdgeGeometry(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_CircleProcessor::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)
{
aSharing->SetCurve3d(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_CircleProcessor::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)
{
aSharing->SetCurve3d(theNewEntity);
return true;
}
return false;
}

64
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_CircleProcessor.hxx Normal file
View File

@ -0,0 +1,64 @@
// 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_CircleProcessor_HeaderFile
#define _MergeSTEPEntities_CircleProcessor_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_CircleHasher.hxx>
#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>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_CircleProcessor(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replacer function for StepShape_EdgeCurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceEdgeCurve(const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replacer function for StepGeom_SurfaceCurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceSurfaceCurve(const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replacer function for StepGeom_SeamCurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceSeamCurve(const Handle(StepGeom_Circle)& theOldEntity,
const Handle(StepGeom_Circle)& theNewEntity,
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_CircleProcessor_HeaderFile

78
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_DirectionHasher.hxx Normal file
View File

@ -0,0 +1,78 @@
// 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_DirectionHasher_HeaderFile
#define _MergeSTEPEntities_DirectionHasher_HeaderFile
#include <Standard_HashUtils.hxx>
#include <StepGeom_Direction.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Direction entities.
struct MergeSTEPEntities_DirectionHasher
{
// Hashes the direction by its name and direction ratios.
std::size_t operator()(const Handle(StepGeom_Direction)& theDirection) const noexcept
{
// Prepare an array of direction ratios.
const Handle(TColStd_HArray1OfReal) aCoords = theDirection->DirectionRatios();
int anArray[3]{};
for (int anIndex = aCoords->Lower(); anIndex < aCoords->Upper(); ++anIndex)
{
anArray[anIndex] = static_cast<int>(aCoords->Value(anIndex));
}
// If direction has no name, hash only direction ratios.
if (theDirection->Name().IsNull())
{
return opencascade::hashBytes(anArray, sizeof(anArray));
}
// Otherwise, hash both direction ratios and name.
const size_t aHashes[2]{opencascade::hashBytes(anArray, sizeof(anArray)),
std::hash<TCollection_AsciiString>{}(theDirection->Name()->String())};
return opencascade::hashBytes(aHashes, sizeof(aHashes));
}
// Compares two directions by their names and direction ratios.
bool operator()(const Handle(StepGeom_Direction)& theDirection1,
const Handle(StepGeom_Direction)& theDirection2) const noexcept
{
// Compare names.
if (theDirection1->Name().IsNull() != theDirection2->Name().IsNull())
{
return false;
}
if (!theDirection1->Name()->IsSameString(theDirection2->Name()))
{
return false;
}
// Compare coordinates.
constexpr double aTolerance = 1e-12;
const Handle(TColStd_HArray1OfReal) aCoords1 = theDirection1->DirectionRatios();
const Handle(TColStd_HArray1OfReal) aCoords2 = theDirection2->DirectionRatios();
if (aCoords1->Length() != aCoords2->Length())
{
return false;
}
for (Standard_Integer i = aCoords1->Lower(); i <= aCoords1->Upper(); ++i)
{
if (std::abs(aCoords1->Value(i) - aCoords2->Value(i)) > aTolerance)
{
return false;
}
}
return true;
}
};
#endif // _MergeSTEPEntities_DirectionHasher_HeaderFile

98
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_DirectionProcessor.cxx Normal file
View File

@ -0,0 +1,98 @@
// 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.
// 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 <Interface_Graph.hxx>
#include <StepGeom_Axis1Placement.hxx>
#include <StepGeom_Axis2Placement3d.hxx>
#include <StepGeom_Vector.hxx>
//==================================================================================================
MergeSTEPEntities_DirectionProcessor::MergeSTEPEntities_DirectionProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Direction, MergeSTEPEntities_DirectionHasher>(
theWS)
{
registerReplacer(STANDARD_TYPE(StepGeom_Axis1Placement), replaceAxis1Placement);
registerReplacer(STANDARD_TYPE(StepGeom_Axis2Placement3d), replaceAxis2Placement3d);
registerReplacer(STANDARD_TYPE(StepGeom_Vector), replaceVector);
}
//==================================================================================================
bool MergeSTEPEntities_DirectionProcessor::replaceAxis1Placement(
const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Axis1Placement) aSharing = Handle(StepGeom_Axis1Placement)::DownCast(theSharing);
if (aSharing->Axis() == theOldEntity)
{
aSharing->SetAxis(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_DirectionProcessor::replaceAxis2Placement3d(
const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepGeom_Axis2Placement3d) aSharing =
Handle(StepGeom_Axis2Placement3d)::DownCast(theSharing);
if (aSharing->Axis() == theOldEntity)
{
aSharing->SetAxis(theNewEntity);
return true;
}
else if (aSharing->RefDirection() == theOldEntity)
{
aSharing->SetRefDirection(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_DirectionProcessor::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)
{
aSharing->SetOrientation(theNewEntity);
return true;
}
return false;
}

65
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_DirectionProcessor.hxx Normal file
View File

@ -0,0 +1,65 @@
// 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_DirectionProcessor_HeaderFile
#define _MergeSTEPEntities_DirectionProcessor_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_DirectionHasher.hxx>
#include <StepGeom_Direction.hxx>
//! Processor for merging StepGeom_Direction entities.
//! 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>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_DirectionProcessor(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replaces the old direction with the new one in the StepGeom_Axis1Placement entity.
//! @param theOldEntity the old direction.
//! @param theNewEntity the new direction.
//! @param theSharing the StepGeom_Axis1Placement entity to update.
//! @return true if the direction was replaced, false otherwise.
static bool replaceAxis1Placement(const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old direction with the new one in the StepGeom_Axis2Placement3d entity.
//! @param theOldEntity the old direction.
//! @param theNewEntity the new direction.
//! @param theSharing the StepGeom_Axis2Placement3d entity to update.
//! @return true if the direction was replaced, false otherwise.
static bool replaceAxis2Placement3d(const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replaces the old direction with the new one in the StepGeom_Vector entity.
//! @param theOldEntity the old direction.
//! @param theNewEntity the new direction.
//! @param theSharing the StepGeom_Vector entity to update.
//! @return true if the direction was replaced, false otherwise.
static bool replaceVector(const Handle(StepGeom_Direction)& theOldEntity,
const Handle(StepGeom_Direction)& theNewEntity,
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_DirectionProcessor_HeaderFile

241
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_EntityProcessor.hxx Normal file
View File

@ -0,0 +1,241 @@
// 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_EntityProcessor_HeaderFile
#define _MergeSTEPEntities_EntityProcessor_HeaderFile
#include <Interface_Graph.hxx>
#include <NCollection_Allocator.hxx>
#include <NCollection_DataMap.hxx>
#include <Standard_HashUtils.hxx>
#include <XSControl_WorkSession.hxx>
#include <TColStd_MapOfTransient.hxx>
#include <functional>
//! Base class for removing duplicate entities.
//! Implements the logic of processing entities and removing duplicates.
//! Child classes should only implement and register replacer functions
//! for each specific type of sharing entity.
//! How to use:
//! 1. Create an instance of the child class.
//! 2. Add entities to the processor using ProcessEntity() method. Entities
//! that can be merged will be stored in the internal map, others will be ignored.
//! 3. Call Perform() method to replace duplicate entities. After this call
//! all duplicate entities will be replaced in a model with the first processed entity
//! that is evaluated as equal to them.
//! IMPORTANT: Duplicated entities will be replaced but not removed from the model!
//! 4. Call GetReplacedEntities() to get a list of replaced duplicates. This list can be used
//! to remove entities from the model.
//! @tparam ProcessedType Type of the processed entities.
//! @tparam ProcessedTypeHasher OCCT-Style hasher for the processed entities.
template <typename ProcessedType, typename ProcessedTypeHasher>
class MergeSTEPEntities_EntityProcessor
{
protected:
// Map of duplicate entities. Key is the first processed entity, value is a list of duplicates.
using DuplicateMap = NCollection_DataMap<Handle(ProcessedType),
std::vector<Handle(ProcessedType)>,
ProcessedTypeHasher>;
// Function to replace an entity in sharings. First argument is the old entity, second is the new
// entity, third is the sharing in which the entity should be replaced. Returns true if the entity
// was replaced, false otherwise.
using ReplacerFunction = std::function<bool(const Handle(ProcessedType)&,
const Handle(ProcessedType)&,
const Handle(Standard_Transient))>;
// Map of replacer functions. Key is the type of the sharing entity, value is the replacer
// function for this type.
using ReplacerMap = NCollection_DataMap<Handle(Standard_Type), ReplacerFunction>;
protected:
//! Constructor. Accepts a work session containing the model to process.
//! 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);
public:
//! Function to process an entity. If the entity can be merged, it will be stored in the internal
//! map. If the entity cannot be merged, it will be ignored.
//! Entity can only be processed if:
//! 1. The type of entity is ProcessedType.
//! 2. All sharings of the entity have a registered replacer function.
//! @param theEntity Entity to process.
//! @return True if the entity was processed, false if it was ignored.
Standard_EXPORT bool ProcessEntity(const Handle(Standard_Transient)& theEntity);
//! Function to replace duplicate entities. After this call, all duplicate entities will be
//! replaced with the first processed entity that is evaluated as equal to them.
//! IMPORTANT: Duplicated entities will be replaced but not removed from the model!
//! @param theReplacedEntities List where replaced entities will be stored.
//! This list can be used to remove entities from the model.
Standard_EXPORT void Perform(TColStd_MapOfTransient& theReplacedEntities);
protected:
//! Register a replacer function for a specific type of sharing entity.
//! Should be used by child classes to register replacer functions for each specific type of
//! sharing entity. If a sharing entity of the specified type is encountered during processing,
//! the registered replacer function will be called to replace the old entity with the new one.
//! All replacers must be registered before calling ProcessEntity() method.
//! @param theType Type of the sharing entity.
//! @param theReplacer Replacer function.
void registerReplacer(const Handle(Standard_Type)& theType, const ReplacerFunction& theReplacer);
public:
//! Checks if all sharings have registered replacers for their types.
//! @param theSharings List of sharings to check.
//! @return True if all sharings have registered replacers, false otherwise.
bool hasAllReplacers(const Handle(TColStd_HSequenceOfTransient)& theSharings) const;
//! Replaces an old entity with a new entity in sharings.
//! Should only be called if all sharings have registered replacers.
//! @param theOldEntity Old entity to replace.
//! @param theNewEntity New entity to replace old entity with.
//! @param theSharings List of old entity sharings to replace the entity in.
//! @return True if all entities were replaced, false if at least one entity was not replaced.
bool replaceInSharings(const Handle(ProcessedType)& theOldEntity,
const Handle(ProcessedType)& theNewEntity,
const Handle(TColStd_HSequenceOfTransient)& theSharings) const;
private:
Handle(XSControl_WorkSession) myWS; //!< Work session.
ReplacerMap myReplacerMap; //!< Map of replacer functions.
DuplicateMap myDuplicateMap; //!< Map of duplicate entities.
};
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::
MergeSTEPEntities_EntityProcessor(const Handle(XSControl_WorkSession)& theWS)
: myWS(theWS),
myReplacerMap(),
myDuplicateMap()
{
}
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::ProcessEntity(
const Handle(Standard_Transient)& theEntity)
{
const Handle(ProcessedType) anEntity = Handle(ProcessedType)::DownCast(theEntity);
if (anEntity.IsNull())
{
return false;
}
const Interface_Graph& aGraph = myWS->Graph();
const Handle(TColStd_HSequenceOfTransient) aSharings = aGraph.GetSharings(anEntity);
if (hasAllReplacers(aSharings))
{
std::vector<Handle(ProcessedType)>* anIter = myDuplicateMap.ChangeSeek(anEntity);
if (anIter == nullptr)
{
// Add as a new key.
myDuplicateMap.Bind(anEntity, std::vector<Handle(ProcessedType)>{});
}
else
{
// Add as a value.
anIter->push_back(anEntity);
}
}
return true;
}
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
void MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::Perform(
TColStd_MapOfTransient& theReplacedEntities)
{
for (DuplicateMap::Iterator anIter(myDuplicateMap); anIter.More(); anIter.Next())
{
const Handle(ProcessedType)& anEntity = anIter.Key();
const std::vector<Handle(ProcessedType)>& aDuplicates = anIter.Value();
if (aDuplicates.empty())
{
continue;
}
const Interface_Graph& aGraph = myWS->Graph();
for (const auto& aDuplicate : aDuplicates)
{
Handle(TColStd_HSequenceOfTransient) aSharings = aGraph.GetSharings(aDuplicate);
if (aSharings.IsNull())
{
continue;
}
if (replaceInSharings(aDuplicate, anEntity, aSharings))
{
theReplacedEntities.Add(aDuplicate);
}
}
}
}
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
void MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::registerReplacer(
const Handle(Standard_Type)& theType,
const ReplacerFunction& theReplacer)
{
myReplacerMap.Bind(theType, theReplacer);
}
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::hasAllReplacers(
const Handle(TColStd_HSequenceOfTransient)& theSharings) const
{
if (theSharings.IsNull())
{
return false;
}
return std::all_of(theSharings->cbegin(),
theSharings->cend(),
[this](const Handle(Standard_Transient)& theSharing) {
return myReplacerMap.IsBound(theSharing->DynamicType());
});
}
//==================================================================================================
template <typename ProcessedType, typename ProcessedTypeHasher>
bool MergeSTEPEntities_EntityProcessor<ProcessedType, ProcessedTypeHasher>::replaceInSharings(
const Handle(ProcessedType)& theOldEntity,
const Handle(ProcessedType)& theNewEntity,
const Handle(TColStd_HSequenceOfTransient)& theSharings) const
{
bool isAllReplaced = true;
for (const auto& aSharing : *theSharings)
{
if (aSharing.IsNull())
{
continue;
}
const ReplacerFunction& aReplacer = myReplacerMap.Find(aSharing->DynamicType());
if (!aReplacer(theOldEntity, theNewEntity, aSharing))
{
isAllReplaced = false;
}
}
return isAllReplaced;
}
#endif // _MergeSTEPEntities_EntityProcessor_HeaderFile

77
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_LineHasher.hxx Normal file
View File

@ -0,0 +1,77 @@
// 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_LineHasher_HeaderFile
#define _MergeSTEPEntities_LineHasher_HeaderFile
#include <MergeSTEPEntities_CartesianPointHasher.hxx>
#include <MergeSTEPEntities_VectorHasher.hxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Line.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Line entities.
struct MergeSTEPEntities_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 aCombinedHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (theLine->Name().IsNull())
{
// If the name is not present, return the hash.
return aCombinedHash;
}
// Add the name to the hash if it is present.
const size_t aCombinedHashWithName[2]{
aCombinedHash,
std::hash<TCollection_AsciiString>{}(theLine->Name()->String())};
return opencascade::hashBytes(aCombinedHashWithName, sizeof(aCombinedHashWithName));
}
// Compares two Lines by their names and Line ratios.
bool operator()(const Handle(StepGeom_Line)& theLine1,
const Handle(StepGeom_Line)& theLine2) const noexcept
{
// Compare names.
if (theLine1->Name().IsNull() != theLine2->Name().IsNull())
{
return false;
}
if (!theLine1->Name()->IsSameString(theLine2->Name()))
{
return false;
}
// Compare points.
if (!MergeSTEPEntities_CartesianPointHasher{}(theLine1->Pnt(), theLine2->Pnt()))
{
return false;
}
// Compare directions.
if (!MergeSTEPEntities_VectorHasher{}(theLine1->Dir(), theLine2->Dir()))
{
return false;
}
return true;
}
};
#endif // _MergeSTEPEntities_LineHasher_HeaderFile

131
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_LineProcessor.cxx Normal file
View File

@ -0,0 +1,131 @@
// 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.
// 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 <Interface_Graph.hxx>
#include <StepShape_EdgeCurve.hxx>
#include <StepGeom_TrimmedCurve.hxx>
#include <StepGeom_SurfaceCurve.hxx>
#include <StepRepr_DefinitionalRepresentation.hxx>
#include <StepGeom_SeamCurve.hxx>
//==================================================================================================
MergeSTEPEntities_LineProcessor::MergeSTEPEntities_LineProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Line, MergeSTEPEntities_LineHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepShape_EdgeCurve), replaceEdgeCurve);
registerReplacer(STANDARD_TYPE(StepGeom_TrimmedCurve), replaceTrimmedCurve);
registerReplacer(STANDARD_TYPE(StepGeom_SurfaceCurve), replaceSurfaceCurve);
registerReplacer(STANDARD_TYPE(StepRepr_DefinitionalRepresentation),
replaceDefinitionalRepresentation);
registerReplacer(STANDARD_TYPE(StepGeom_SeamCurve), replaceSeamCurve);
}
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::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)
{
aSharing->SetEdgeGeometry(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::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)
{
aSharing->SetBasisCurve(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::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)
{
aSharing->SetCurve3d(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::replaceDefinitionalRepresentation(
const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing)
{
Handle(StepRepr_DefinitionalRepresentation) aSharing =
Handle(StepRepr_DefinitionalRepresentation)::DownCast(theSharing);
bool isReplaced = false;
Handle(StepRepr_HArray1OfRepresentationItem) anItems = aSharing->Items();
for (Standard_Integer anIndex = 1; anIndex <= aSharing->NbItems(); ++anIndex)
{
const Handle(StepRepr_RepresentationItem) aRepItem = anItems->Value(anIndex);
if (aRepItem == theOldEntity)
{
anItems->SetValue(anIndex, theNewEntity);
isReplaced = true;
}
}
return isReplaced;
}
//==================================================================================================
bool MergeSTEPEntities_LineProcessor::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)
{
aSharing->SetCurve3d(theNewEntity);
return true;
}
return false;
}

84
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_LineProcessor.hxx Normal file
View File

@ -0,0 +1,84 @@
// 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_LineProcessor_HeaderFile
#define _MergeSTEPEntities_LineProcessor_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_LineHasher.hxx>
#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>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_LineProcessor(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replacer function for StepShape_EdgeCurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceEdgeCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replacer function for StepGeom_TrimmedCurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceTrimmedCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replacer function for StepGeom_SurfaceCurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceSurfaceCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replacer function for StepRepr_DefinitionalRepresentation entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceDefinitionalRepresentation(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replacer function for StepGeom_SeamCurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing entity in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceSeamCurve(const Handle(StepGeom_Line)& theOldEntity,
const Handle(StepGeom_Line)& theNewEntity,
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_LineProcessor_HeaderFile

123
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_Merger.cxx Normal file
View File

@ -0,0 +1,123 @@
// 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_Merger.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 <StepData_StepModel.hxx>
//==================================================================================================
MergeSTEPEntities_Merger::MergeSTEPEntities_Merger(Handle(XSControl_WorkSession) theWS)
: myWS(theWS)
{
}
//==================================================================================================
void MergeSTEPEntities_Merger::Perform()
{
Handle(StepData_StepModel) aModel = Handle(StepData_StepModel)::DownCast(myWS->Model());
if (aModel.IsNull())
{
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);
// 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);
}
// 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);
// Remove duplicate entities.
removeEntities(aReplacedEntities);
}
//==================================================================================================
void MergeSTEPEntities_Merger::removeEntities(const TColStd_MapOfTransient& theToRemove)
{
if (theToRemove.IsEmpty())
{
return;
}
// Remove entities.
Handle(StepData_StepModel) anIntermediateModel = new StepData_StepModel();
Handle(StepData_StepModel) aReadModel = Handle(StepData_StepModel)::DownCast(myWS->Model());
anIntermediateModel->SetProtocol(aReadModel->Protocol());
anIntermediateModel->SetGTool(aReadModel->GTool());
for (Standard_Integer i = 1; i <= aReadModel->NbEntities(); i++)
{
const Handle(Standard_Transient)& anEnt = aReadModel->Value(i);
if (!theToRemove.Contains(anEnt))
{
anIntermediateModel->AddWithRefs(anEnt);
}
}
myWS->SetModel(anIntermediateModel);
myWS->ComputeGraph();
// Clean hanged entities.
Handle(StepData_StepModel) aNewModel = new StepData_StepModel();
aNewModel->SetProtocol(anIntermediateModel->Protocol());
aNewModel->SetGTool(anIntermediateModel->GTool());
const auto& aGraph = myWS->Graph();
for (Standard_Integer i = 1; i <= anIntermediateModel->NbEntities(); i++)
{
const Handle(Standard_Transient)& anEnt = anIntermediateModel->Value(i);
if (aGraph.Shareds(anEnt).NbEntities() > 0 || aGraph.Sharings(anEnt).NbEntities() > 0)
{
aNewModel->AddWithRefs(anEnt);
}
}
myWS->SetModel(aNewModel);
myWS->ComputeGraph();
}

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

@ -0,0 +1,46 @@
// 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

60
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_PlaneHasher.hxx Normal file
View File

@ -0,0 +1,60 @@
// 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_PlaneHasher_HeaderFile
#define _MergeSTEPEntities_PlaneHasher_HeaderFile
#include <MergeSTEPEntities_Axis2Placement3dHasher.hxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Plane.hxx>
//! OCCT-style hasher for StepGeom_Plane entities.
struct MergeSTEPEntities_PlaneHasher
{
// Hashes the axis Planes.
std::size_t operator()(const Handle(StepGeom_Plane)& thePlane) const noexcept
{
const size_t aHash = MergeSTEPEntities_Axis2Placement3dHasher{}(thePlane->Position());
if (thePlane->Name().IsNull())
{
// If the name is not present, return the hash.
return aHash;
}
// Add the name to the hash if it is present.
const size_t aCombinedHashWithName[2]{
aHash,
std::hash<TCollection_AsciiString>{}(thePlane->Name()->String())};
return opencascade::hashBytes(aCombinedHashWithName, sizeof(aCombinedHashWithName));
}
// Compares two axis Planes.
bool operator()(const Handle(StepGeom_Plane)& thePlane1,
const Handle(StepGeom_Plane)& thePlane2) const noexcept
{
// Compare names.
if (thePlane1->Name().IsNull() != thePlane2->Name().IsNull())
{
return false;
}
if (!thePlane1->Name()->IsSameString(thePlane2->Name()))
{
return false;
}
// Compare axis Planes.
return MergeSTEPEntities_Axis2Placement3dHasher{}(thePlane1->Position(), thePlane2->Position());
}
};
#endif // _MergeSTEPEntities_PlaneHasher_HeaderFile

57
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_PlaneProcessor.cxx Normal file
View File

@ -0,0 +1,57 @@
// 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_PlaneProcessor.hxx>
#include <StepShape_AdvancedFace.hxx>
#include <StepGeom_Pcurve.hxx>
//==================================================================================================
MergeSTEPEntities_PlaneProcessor::MergeSTEPEntities_PlaneProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Plane, MergeSTEPEntities_PlaneHasher>(theWS)
{
registerReplacer(STANDARD_TYPE(StepShape_AdvancedFace), replaceAdvancedFace);
registerReplacer(STANDARD_TYPE(StepGeom_Pcurve), replacePcurve);
}
//==================================================================================================
bool MergeSTEPEntities_PlaneProcessor::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)
{
aSharing->SetFaceGeometry(theNewEntity);
return true;
}
return false;
}
//==================================================================================================
bool MergeSTEPEntities_PlaneProcessor::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)
{
aSharing->SetBasisSurface(theNewEntity);
return true;
}
return false;
}

54
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_PlaneProcessor.hxx Normal file
View File

@ -0,0 +1,54 @@
// 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_PlaneProcessor_HeaderFile
#define _MergeSTEPEntities_PlaneProcessor_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_PlaneHasher.hxx>
#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>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_PlaneProcessor(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replacer function for StepShape_AdvancedFace entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing StepShape_AdvancedFace in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replaceAdvancedFace(const Handle(StepGeom_Plane)& theOldEntity,
const Handle(StepGeom_Plane)& theNewEntity,
Handle(Standard_Transient) theSharing);
//! Replacer function for StepGeom_Pcurve entities.
//! Replaces the old entity with the new one in the sharing entity.
//! @param theOldEntity the old entity to replace.
//! @param theNewEntity the new entity to replace with.
//! @param theSharing the sharing StepGeom_Pcurve in which to replace the old entity.
//! @return true if the entity was replaced, false otherwise.
static bool replacePcurve(const Handle(StepGeom_Plane)& theOldEntity,
const Handle(StepGeom_Plane)& theNewEntity,
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_DirectionProcessor_HeaderFile

71
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_VectorHasher.hxx Normal file
View File

@ -0,0 +1,71 @@
// 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_VectorHasher_HeaderFile
#define _MergeSTEPEntities_VectorHasher_HeaderFile
#include <MergeSTEPEntities_DirectionHasher.hxx>
#include <Standard_HashUtils.hxx>
#include <StepGeom_Vector.hxx>
#include <TCollection_HAsciiString.hxx>
//! OCCT-style hasher for StepGeom_Vector entities.
struct MergeSTEPEntities_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()),
opencascade::hash(static_cast<int>(theVector->Magnitude()))};
const size_t aCombinedHash = opencascade::hashBytes(aHashes, sizeof(aHashes));
if (theVector->Name().IsNull())
{
// If the name is not present, return the hash.
return aCombinedHash;
}
// Add the name to the hash if it is present.
const size_t aCombinedHashWithName[2]{
aCombinedHash,
std::hash<TCollection_AsciiString>{}(theVector->Name()->String())};
return opencascade::hashBytes(aCombinedHashWithName, sizeof(aCombinedHashWithName));
}
// Compares two Vectors by their names and Vector ratios.
bool operator()(const Handle(StepGeom_Vector)& theVector1,
const Handle(StepGeom_Vector)& theVector2) const noexcept
{
// Compare names.
if (theVector1->Name().IsNull() != theVector2->Name().IsNull())
{
return false;
}
if (!theVector1->Name()->IsSameString(theVector2->Name()))
{
return false;
}
// Compare magnitudes.
constexpr double aTolerance = 1e-12;
if (fabs(theVector1->Magnitude() - theVector2->Magnitude()) > aTolerance)
{
return false;
}
// Compare orientations.
return MergeSTEPEntities_DirectionHasher{}(theVector1->Orientation(),
theVector2->Orientation());
}
};
#endif // _MergeSTEPEntities_VectorHasher_HeaderFile

55
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_VectorProcessor.cxx Normal file
View File

@ -0,0 +1,55 @@
// 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.
// 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 <Interface_Graph.hxx>
#include <StepGeom_Line.hxx>
#include <StepGeom_Vector.hxx>
//==================================================================================================
MergeSTEPEntities_VectorProcessor::MergeSTEPEntities_VectorProcessor(
const Handle(XSControl_WorkSession)& theWS)
: MergeSTEPEntities_EntityProcessor<StepGeom_Vector, MergeSTEPEntities_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)
{
Handle(StepGeom_Line) aLine = Handle(StepGeom_Line)::DownCast(theSharing);
if (aLine->Dir() == theOldEntity)
{
aLine->SetDir(theNewEntity);
return true;
}
return false;
}

43
src/DataExchange/TKDESTEP/MergeSTEPEntities/MergeSTEPEntities_VectorProcessor.hxx Normal file
View File

@ -0,0 +1,43 @@
// 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_VectorProcessor_HeaderFile
#define _MergeSTEPEntities_VectorProcessor_HeaderFile
#include <MergeSTEPEntities_EntityProcessor.hxx>
#include <MergeSTEPEntities_VectorHasher.hxx>
#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>
{
public:
//! Constructor. Stores the work session and registers replacer functions.
//! @param theWS the work session.
Standard_EXPORT MergeSTEPEntities_VectorProcessor(const Handle(XSControl_WorkSession)& theWS);
private:
//! Replaces the old vector with the new one in the StepGeom_Line entity.
//! @param theOldEntity the old vector.
//! @param theNewEntity the new vector to replace the old one.
//! @param theSharing the StepGeom_Line entity to update.
//! @return true if the vector was replaced, false otherwise.
static bool replaceLine(const Handle(StepGeom_Vector)& theOldEntity,
const Handle(StepGeom_Vector)& theNewEntity,
Handle(Standard_Transient) theSharing);
};
#endif // _MergeSTEPEntities_VectorProcessor_HeaderFile

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

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

14
src/DataExchange/TKDESTEP/StepGeom/StepGeom_CartesianPoint.cxx
View File

@ -39,6 +39,7 @@ void StepGeom_CartesianPoint::Init2D(const Handle(TCollection_HAsciiString)& aNa
nbcoord = 2;
coords[0] = X;
coords[1] = Y;
coords[2] = 0;
// --- classe inherited fields ---
StepRepr_RepresentationItem::Init(aName);
}
@ -65,13 +66,14 @@ void StepGeom_CartesianPoint::SetCoordinates(const Handle(TColStd_HArray1OfReal)
// coordinates = aCoordinates;
}
Handle(TColStd_HArray1OfReal) StepGeom_CartesianPoint::Coordinates() const
void StepGeom_CartesianPoint::SetCoordinates(const std::array<Standard_Real, 3>& theCoordinates)
{
Handle(TColStd_HArray1OfReal) coordinates = new TColStd_HArray1OfReal(1, nbcoord);
coordinates->SetValue(1, coords[0]);
coordinates->SetValue(2, coords[1]);
coordinates->SetValue(3, coords[2]);
return coordinates;
coords = theCoordinates;
}
const std::array<Standard_Real, 3>& StepGeom_CartesianPoint::Coordinates() const
{
return coords;
}
Standard_Real StepGeom_CartesianPoint::CoordinatesValue(const Standard_Integer num) const

11
src/DataExchange/TKDESTEP/StepGeom/StepGeom_CartesianPoint.hxx
View File

@ -23,6 +23,9 @@
#include <Standard_Integer.hxx>
#include <StepGeom_Point.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <array>
class TCollection_HAsciiString;
class StepGeom_CartesianPoint;
@ -49,7 +52,9 @@ public:
Standard_EXPORT void SetCoordinates(const Handle(TColStd_HArray1OfReal)& aCoordinates);
Standard_EXPORT Handle(TColStd_HArray1OfReal) Coordinates() const;
Standard_EXPORT void SetCoordinates(const std::array<Standard_Real, 3>& theCoordinates);
Standard_EXPORT const std::array<Standard_Real, 3>& Coordinates() const;
Standard_EXPORT Standard_Real CoordinatesValue(const Standard_Integer num) const;
@ -59,8 +64,8 @@ public:
protected:
private:
Standard_Integer nbcoord;
Standard_Real coords[3];
Standard_Integer nbcoord;
std::array<Standard_Real, 3> coords;
};
#endif // _StepGeom_CartesianPoint_HeaderFile

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

@ -23,6 +23,7 @@
#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>
@ -1093,6 +1094,39 @@ 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;
@ -1145,6 +1179,15 @@ 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);
}