+++ /dev/null
-// 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 <TopLoc_Location.hxx>
-#include <TopoDS_Shape.hxx>
-#include <TopoDS_Vertex.hxx>
-#include <TopoDS.hxx>
-#include <BRepBuilderAPI_MakeVertex.hxx>
-#include <BRep_Tool.hxx>
-#include <gp.hxx>
-#include <gp_Ax1.hxx>
-#include <gp_Trsf.hxx>
-#include <gp_Vec.hxx>
-#include <gp_Pnt.hxx>
-#include <OSD_Parallel.hxx>
-
-#include <gtest/gtest.h>
-
-#include <atomic>
-#include <vector>
-
-namespace
-{
-//! Functor for testing concurrent access to TopLoc_Location::Transformation()
-struct TopLocTransformFunctor
-{
- TopLocTransformFunctor(const std::vector<TopoDS_Shape>& theShapeVec)
- : myShapeVec(&theShapeVec),
- myIsRaceDetected(0)
- {
- }
-
- void operator()(size_t i) const
- {
- if (!myIsRaceDetected)
- {
- const TopoDS_Vertex& aVertex = TopoDS::Vertex(myShapeVec->at(i));
- gp_Pnt aPoint = BRep_Tool::Pnt(aVertex);
- if (aPoint.X() != static_cast<double>(i))
- {
- ++myIsRaceDetected;
- }
- }
- }
-
- const std::vector<TopoDS_Shape>* myShapeVec;
- mutable std::atomic<int> myIsRaceDetected;
-};
-} // namespace
-
-TEST(TopLoc_Location_Test, OCC25545_ConcurrentTransformationAccess)
-{
- // Bug OCC25545: TopLoc_Location::Transformation() provokes data races
- // This test verifies that concurrent access to TopLoc_Location::Transformation()
- // does not cause data races or incorrect geometry results
-
- // Place vertices in a vector, giving the i-th vertex the
- // transformation that translates it on the vector (i,0,0) from the origin
- Standard_Integer n = 1000;
- std::vector<TopoDS_Shape> aShapeVec(n);
- std::vector<TopLoc_Location> aLocVec(n);
- TopoDS_Shape aShape = BRepBuilderAPI_MakeVertex(gp::Origin());
- aShapeVec[0] = aShape;
-
- for (Standard_Integer i = 1; i < n; ++i)
- {
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1, 0, 0));
- aLocVec[i] = aLocVec[i - 1] * aTrsf;
- aShapeVec[i] = aShape.Moved(aLocVec[i]);
- }
-
- // Evaluator function will access vertices geometry concurrently
- TopLocTransformFunctor aFunc(aShapeVec);
-
- // Process concurrently
- OSD_Parallel::For(0, n, aFunc);
-
- // Verify no data race was detected
- EXPECT_EQ(aFunc.myIsRaceDetected, 0)
- << "Data race detected in concurrent TopLoc_Location::Transformation() access";
-}
-
-//=================================================================================================
-// Tests for Phase 1 & 2 Optimizations
-//=================================================================================================
-
-TEST(TopLoc_Location_Test, DefaultConstructor_CreatesIdentity)
-{
- // Test that default constructor creates identity location
- TopLoc_Location aLoc;
-
- EXPECT_TRUE(aLoc.IsIdentity()) << "Default constructed location should be identity";
-
- const gp_Trsf& aTrsf = aLoc.Transformation();
- EXPECT_EQ(aTrsf.Form(), gp_Identity) << "Default location should return identity transformation";
-}
-
-TEST(TopLoc_Location_Test, IdentityTransformation_ReturnsSameInstance)
-{
- // Test that identity locations return the same transformation instance
- TopLoc_Location aLoc1;
- TopLoc_Location aLoc2;
-
- const gp_Trsf& aTrsf1 = aLoc1.Transformation();
- const gp_Trsf& aTrsf2 = aLoc2.Transformation();
-
- // Both should return reference to the same identity transformation
- EXPECT_EQ(&aTrsf1, &aTrsf2) << "Identity locations should share the same transformation instance";
-}
-
-TEST(TopLoc_Location_Test, Squared_EqualsMultipliedBySelf)
-{
- // Test that Squared() equals Multiplied(self)
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 2.0, 3.0));
- TopLoc_Location aLoc(aTrsf);
-
- TopLoc_Location aSquared = aLoc.Squared();
- TopLoc_Location aMultiplied = aLoc.Multiplied(aLoc);
-
- EXPECT_EQ(aSquared, aMultiplied) << "Squared() should equal Multiplied(self)";
-
- // Verify the transformation is actually squared
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aTransformed = anOrigin.Transformed(aSquared.Transformation());
- gp_Pnt anExpected(2.0, 4.0, 6.0); // Double translation
-
- EXPECT_NEAR(aTransformed.X(), anExpected.X(), 1e-10);
- EXPECT_NEAR(aTransformed.Y(), anExpected.Y(), 1e-10);
- EXPECT_NEAR(aTransformed.Z(), anExpected.Z(), 1e-10);
-}
-
-TEST(TopLoc_Location_Test, Powered2_UsesSquaredFastPath)
-{
- // Test that Powered(2) equals Squared() (verifies fast path)
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(5.0, -3.0, 1.5));
- TopLoc_Location aLoc(aTrsf);
-
- TopLoc_Location aPowered = aLoc.Powered(2);
- TopLoc_Location aSquared = aLoc.Squared();
-
- EXPECT_EQ(aPowered, aSquared) << "Powered(2) should equal Squared()";
-}
-
-TEST(TopLoc_Location_Test, Powered_VariousPowers)
-{
- // Test Powered() with various power values
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- // Power 0 should return identity
- TopLoc_Location aPow0 = aLoc.Powered(0);
- EXPECT_TRUE(aPow0.IsIdentity()) << "Powered(0) should return identity";
-
- // Power 1 should return self
- TopLoc_Location aPow1 = aLoc.Powered(1);
- EXPECT_EQ(aPow1, aLoc) << "Powered(1) should return self";
-
- // Power 2 should be double translation
- TopLoc_Location aPow2 = aLoc.Powered(2);
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResult = anOrigin.Transformed(aPow2.Transformation());
- EXPECT_NEAR(aResult.X(), 2.0, 1e-10) << "Powered(2) should double the translation";
-
- // Power 3
- TopLoc_Location aPow3 = aLoc.Powered(3);
- aResult = anOrigin.Transformed(aPow3.Transformation());
- EXPECT_NEAR(aResult.X(), 3.0, 1e-10) << "Powered(3) should triple the translation";
-
- // Negative power (inverse)
- TopLoc_Location aPowNeg1 = aLoc.Powered(-1);
- TopLoc_Location anInverted = aLoc.Inverted();
- EXPECT_EQ(aPowNeg1, anInverted) << "Powered(-1) should equal Inverted()";
-}
-
-TEST(TopLoc_Location_Test, SharesNode_DetectsSharedStructure)
-{
- // Test that SharesNode correctly detects shared list nodes
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 2.0, 3.0));
- TopLoc_Location aLoc1(aTrsf);
-
- // Copy constructor should share the same nodes
- TopLoc_Location aLoc2 = aLoc1;
-
- EXPECT_EQ(aLoc1, aLoc2) << "Copied location should equal original";
-
- // Assignment should also share nodes
- TopLoc_Location aLoc3;
- aLoc3 = aLoc1;
-
- EXPECT_EQ(aLoc3, aLoc1) << "Assigned location should equal original";
-}
-
-TEST(TopLoc_Location_Test, Equality_DifferentTransformations)
-{
- // Test that different transformations are not equal
- gp_Trsf aTrsf1;
- aTrsf1.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc1(aTrsf1);
-
- gp_Trsf aTrsf2;
- aTrsf2.SetTranslation(gp_Vec(0.0, 1.0, 0.0));
- TopLoc_Location aLoc2(aTrsf2);
-
- EXPECT_NE(aLoc1, aLoc2) << "Different transformations should not be equal";
- EXPECT_TRUE(aLoc1.IsDifferent(aLoc2))
- << "IsDifferent should return true for different transformations";
-}
-
-TEST(TopLoc_Location_Test, Multiplication_Composition)
-{
- // Test location multiplication (composition)
- gp_Trsf aTrsf1;
- aTrsf1.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc1(aTrsf1);
-
- gp_Trsf aTrsf2;
- aTrsf2.SetTranslation(gp_Vec(0.0, 2.0, 0.0));
- TopLoc_Location aLoc2(aTrsf2);
-
- TopLoc_Location aComposed = aLoc1 * aLoc2;
-
- // Apply composed transformation
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResult = anOrigin.Transformed(aComposed.Transformation());
-
- EXPECT_NEAR(aResult.X(), 1.0, 1e-10);
- EXPECT_NEAR(aResult.Y(), 2.0, 1e-10);
- EXPECT_NEAR(aResult.Z(), 0.0, 1e-10);
-}
-
-TEST(TopLoc_Location_Test, Inverted_ProducesInverse)
-{
- // Test that Location * Inverted() = Identity
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(5.0, -3.0, 2.0));
- TopLoc_Location aLoc(aTrsf);
-
- TopLoc_Location anInv = aLoc.Inverted();
- TopLoc_Location anIdentity = aLoc * anInv;
-
- EXPECT_TRUE(anIdentity.IsIdentity()) << "Location * Inverted() should produce identity";
-
- // Also test in reverse order
- TopLoc_Location anIdentity2 = anInv * aLoc;
- EXPECT_TRUE(anIdentity2.IsIdentity()) << "Inverted() * Location should also produce identity";
-}
-
-TEST(TopLoc_Location_Test, Divided_EqualsMultipliedByInverse)
-{
- // Test that Divided equals Multiplied by inverse
- gp_Trsf aTrsf1;
- aTrsf1.SetTranslation(gp_Vec(3.0, 4.0, 5.0));
- TopLoc_Location aLoc1(aTrsf1);
-
- gp_Trsf aTrsf2;
- aTrsf2.SetTranslation(gp_Vec(1.0, 1.0, 1.0));
- TopLoc_Location aLoc2(aTrsf2);
-
- TopLoc_Location aDivided = aLoc1 / aLoc2;
- TopLoc_Location aMultiplied = aLoc1 * aLoc2.Inverted();
-
- EXPECT_EQ(aDivided, aMultiplied) << "Divided should equal Multiplied by Inverted";
-}
-
-TEST(TopLoc_Location_Test, Predivided_EqualsInverseMultiplied)
-{
- // Test Predivided = Other.Inverted() * this
- gp_Trsf aTrsf1;
- aTrsf1.SetTranslation(gp_Vec(2.0, 3.0, 4.0));
- TopLoc_Location aLoc1(aTrsf1);
-
- gp_Trsf aTrsf2;
- aTrsf2.SetTranslation(gp_Vec(1.0, 1.0, 1.0));
- TopLoc_Location aLoc2(aTrsf2);
-
- TopLoc_Location aPredivided = aLoc1.Predivided(aLoc2);
- TopLoc_Location anExpected = aLoc2.Inverted() * aLoc1;
-
- EXPECT_EQ(aPredivided, anExpected) << "Predivided should equal Other.Inverted() * this";
-}
-
-TEST(TopLoc_Location_Test, HashCode_ConsistentForEqualLocations)
-{
- // Test that locations sharing the same structure have the same hash code
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 2.0, 3.0));
- TopLoc_Location aLoc1(aTrsf);
-
- // Copy constructor shares the same underlying structure
- TopLoc_Location aLoc2 = aLoc1;
-
- EXPECT_EQ(aLoc1.HashCode(), aLoc2.HashCode())
- << "Copied locations (sharing structure) should have the same hash code";
-
- // Identity locations should have the same hash code
- TopLoc_Location anId1;
- TopLoc_Location anId2;
- EXPECT_EQ(anId1.HashCode(), anId2.HashCode())
- << "Identity locations should have the same hash code";
- EXPECT_EQ(anId1.HashCode(), static_cast<size_t>(0)) << "Identity location hash should be 0";
-}
-
-TEST(TopLoc_Location_Test, HashCode_DifferentForDifferentLocations)
-{
- // Test that different locations (likely) have different hash codes
- gp_Trsf aTrsf1;
- aTrsf1.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc1(aTrsf1);
-
- gp_Trsf aTrsf2;
- aTrsf2.SetTranslation(gp_Vec(0.0, 1.0, 0.0));
- TopLoc_Location aLoc2(aTrsf2);
-
- // Hash codes should (very likely) be different
- // Note: Hash collision is theoretically possible but highly unlikely
- EXPECT_NE(aLoc1.HashCode(), aLoc2.HashCode())
- << "Different locations should (likely) have different hash codes";
-}
-
-TEST(TopLoc_Location_Test, ConstCorrectness_TransformationAccess)
-{
- // Test const correctness of Transformation() access
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 2.0, 3.0));
- const TopLoc_Location aLoc(aTrsf);
-
- // This should compile - Transformation() is const
- const gp_Trsf& aTrsfRef = aLoc.Transformation();
-
- EXPECT_EQ(aTrsfRef.Form(), gp_Translation);
-
- // Test identity case
- const TopLoc_Location anIdLoc;
- const gp_Trsf& anIdTrsf = anIdLoc.Transformation();
-
- EXPECT_EQ(anIdTrsf.Form(), gp_Identity);
-}
-
-TEST(TopLoc_Location_Test, Rotation_Composition)
-{
- // Test rotation transformations
- gp_Trsf aRot;
- gp_Ax1 anAxis(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1));
- aRot.SetRotation(anAxis, M_PI / 2.0); // 90 degrees around Z
-
- TopLoc_Location aLoc(aRot);
- TopLoc_Location aSquared = aLoc.Squared();
-
- // Point at (1,0,0) rotated 90 degrees twice should be at (-1,0,0)
- gp_Pnt aPnt(1, 0, 0);
- gp_Pnt aResult = aPnt.Transformed(aSquared.Transformation());
-
- EXPECT_NEAR(aResult.X(), -1.0, 1e-10);
- EXPECT_NEAR(aResult.Y(), 0.0, 1e-10);
- EXPECT_NEAR(aResult.Z(), 0.0, 1e-10);
-}
-
-TEST(TopLoc_Location_Test, Clear_ResetsToIdentity)
-{
- // Test that Clear() resets location to identity
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 2.0, 3.0));
- TopLoc_Location aLoc(aTrsf);
-
- EXPECT_FALSE(aLoc.IsIdentity()) << "Location should not be identity before Clear()";
-
- aLoc.Clear();
-
- EXPECT_TRUE(aLoc.IsIdentity()) << "Location should be identity after Clear()";
-}
-
-TEST(TopLoc_Location_Test, Identity_Method)
-{
- // Test Identity() method
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 2.0, 3.0));
- TopLoc_Location aLoc(aTrsf);
-
- EXPECT_FALSE(aLoc.IsIdentity());
-
- aLoc.Identity();
-
- EXPECT_TRUE(aLoc.IsIdentity()) << "Identity() should reset location to identity";
-}
-
-//=================================================================================================
-// Additional Edge Case Tests
-//=================================================================================================
-
-TEST(TopLoc_Location_Test, ChainedMultiplication_MultipleLocations)
-{
- // Test multiple location multiplications
- gp_Trsf aTrsf1, aTrsf2, aTrsf3;
- aTrsf1.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- aTrsf2.SetTranslation(gp_Vec(0.0, 1.0, 0.0));
- aTrsf3.SetTranslation(gp_Vec(0.0, 0.0, 1.0));
-
- TopLoc_Location aLoc1(aTrsf1);
- TopLoc_Location aLoc2(aTrsf2);
- TopLoc_Location aLoc3(aTrsf3);
-
- // Chain multiplication
- TopLoc_Location aResult = aLoc1 * aLoc2 * aLoc3;
-
- // Apply to point
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aTransformed = anOrigin.Transformed(aResult.Transformation());
-
- EXPECT_NEAR(aTransformed.X(), 1.0, 1e-10);
- EXPECT_NEAR(aTransformed.Y(), 1.0, 1e-10);
- EXPECT_NEAR(aTransformed.Z(), 1.0, 1e-10);
-}
-
-TEST(TopLoc_Location_Test, IdentityMultiplication_NeutralElement)
-{
- // Test that identity is neutral element for multiplication
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(5.0, 3.0, 1.0));
- TopLoc_Location aLoc(aTrsf);
- TopLoc_Location anIdentity;
-
- // Identity * Location = Location
- TopLoc_Location aResult1 = anIdentity * aLoc;
- EXPECT_EQ(aResult1, aLoc) << "Identity * Location should equal Location";
-
- // Location * Identity = Location
- TopLoc_Location aResult2 = aLoc * anIdentity;
- EXPECT_EQ(aResult2, aLoc) << "Location * Identity should equal Location";
-}
-
-TEST(TopLoc_Location_Test, CopySemantics)
-{
- // Test copy construction and assignment
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(2.0, 3.0, 4.0));
- TopLoc_Location anOriginal(aTrsf);
-
- // Copy construction
- TopLoc_Location aCopied(anOriginal);
- EXPECT_EQ(aCopied, anOriginal);
- EXPECT_EQ(aCopied.HashCode(), anOriginal.HashCode());
-
- // Copy assignment
- TopLoc_Location anAssigned;
- anAssigned = anOriginal;
- EXPECT_EQ(anAssigned, anOriginal);
-
- // All three should be equal (share structure)
- EXPECT_EQ(aCopied, anAssigned);
-}
-
-TEST(TopLoc_Location_Test, ScaleTransformation_Composition)
-{
- // Test scale transformations
- gp_Trsf aScale;
- aScale.SetScale(gp_Pnt(0, 0, 0), 2.0);
-
- TopLoc_Location aLoc(aScale);
- TopLoc_Location aSquared = aLoc.Squared();
-
- // Point scaled by 2, then by 2 again = scaled by 4
- gp_Pnt aPnt(1, 1, 1);
- gp_Pnt aResult = aPnt.Transformed(aSquared.Transformation());
-
- EXPECT_NEAR(aResult.X(), 4.0, 1e-10);
- EXPECT_NEAR(aResult.Y(), 4.0, 1e-10);
- EXPECT_NEAR(aResult.Z(), 4.0, 1e-10);
-}
-
-TEST(TopLoc_Location_Test, ComplexTransformation_TranslationAndRotation)
-{
- // Test combination of translation and rotation
- gp_Trsf aTrans;
- aTrans.SetTranslation(gp_Vec(10.0, 0.0, 0.0));
-
- gp_Trsf aRot;
- gp_Ax1 anAxis(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1));
- aRot.SetRotation(anAxis, M_PI); // 180 degrees
-
- TopLoc_Location aLocTrans(aTrans);
- TopLoc_Location aLocRot(aRot);
-
- // Translate then rotate
- TopLoc_Location aComposed = aLocRot * aLocTrans;
-
- // Point at origin, translate to (10,0,0), then rotate 180 degrees -> (-10,0,0)
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResult = anOrigin.Transformed(aComposed.Transformation());
-
- EXPECT_NEAR(aResult.X(), -10.0, 1e-9);
- EXPECT_NEAR(aResult.Y(), 0.0, 1e-9);
- EXPECT_NEAR(aResult.Z(), 0.0, 1e-9);
-}
-
-TEST(TopLoc_Location_Test, PoweredWithLargePower)
-{
- // Test Powered() with larger power value
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- // Power of 10
- TopLoc_Location aPow10 = aLoc.Powered(10);
-
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResult = anOrigin.Transformed(aPow10.Transformation());
-
- EXPECT_NEAR(aResult.X(), 10.0, 1e-9) << "Powered(10) should translate 10 units";
-}
-
-TEST(TopLoc_Location_Test, SelfMultiplication_MultipleIterations)
-{
- // Test repeated self-multiplication
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- TopLoc_Location aResult = aLoc;
- for (int i = 0; i < 5; ++i)
- {
- aResult = aResult * aLoc;
- }
-
- // Should be 6 times the original (1 + 5 multiplications)
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aTransformed = anOrigin.Transformed(aResult.Transformation());
-
- EXPECT_NEAR(aTransformed.X(), 6.0, 1e-10);
-}
-
-TEST(TopLoc_Location_Test, AssociativityOfMultiplication)
-{
- // Test that (A * B) * C = A * (B * C)
- gp_Trsf aTrsf1, aTrsf2, aTrsf3;
- aTrsf1.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- aTrsf2.SetTranslation(gp_Vec(0.0, 2.0, 0.0));
- aTrsf3.SetTranslation(gp_Vec(0.0, 0.0, 3.0));
-
- TopLoc_Location aLocA(aTrsf1);
- TopLoc_Location aLocB(aTrsf2);
- TopLoc_Location aLocC(aTrsf3);
-
- TopLoc_Location aLeft = (aLocA * aLocB) * aLocC;
- TopLoc_Location aRight = aLocA * (aLocB * aLocC);
-
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResultLeft = anOrigin.Transformed(aLeft.Transformation());
- gp_Pnt aResultRight = anOrigin.Transformed(aRight.Transformation());
-
- EXPECT_NEAR(aResultLeft.X(), aResultRight.X(), 1e-10);
- EXPECT_NEAR(aResultLeft.Y(), aResultRight.Y(), 1e-10);
- EXPECT_NEAR(aResultLeft.Z(), aResultRight.Z(), 1e-10);
-}
-
-TEST(TopLoc_Location_Test, InversionIdempotence)
-{
- // Test that (L.Inverted()).Inverted() = L
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(3.0, 4.0, 5.0));
- TopLoc_Location aLoc(aTrsf);
-
- TopLoc_Location aDoubleInverted = aLoc.Inverted().Inverted();
-
- gp_Pnt aPnt(1, 1, 1);
- gp_Pnt aResult1 = aPnt.Transformed(aLoc.Transformation());
- gp_Pnt aResult2 = aPnt.Transformed(aDoubleInverted.Transformation());
-
- EXPECT_NEAR(aResult1.X(), aResult2.X(), 1e-10);
- EXPECT_NEAR(aResult1.Y(), aResult2.Y(), 1e-10);
- EXPECT_NEAR(aResult1.Z(), aResult2.Z(), 1e-10);
-}
-
-//=================================================================================================
-// Tests for Phase 3: Binary Exponentiation Optimization
-//=================================================================================================
-
-TEST(TopLoc_Location_Test, BinaryExponentiation_PowerOf2)
-{
- // Test binary exponentiation for powers of 2 (4, 8, 16)
- // These should be most efficient: L^8 requires only 3 squarings instead of 7 multiplications
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- // Test power of 4 (2^2)
- TopLoc_Location aPow4 = aLoc.Powered(4);
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResult = anOrigin.Transformed(aPow4.Transformation());
- EXPECT_NEAR(aResult.X(), 4.0, 1e-9) << "Powered(4) should translate 4 units";
-
- // Test power of 8 (2^3)
- TopLoc_Location aPow8 = aLoc.Powered(8);
- aResult = anOrigin.Transformed(aPow8.Transformation());
- EXPECT_NEAR(aResult.X(), 8.0, 1e-9) << "Powered(8) should translate 8 units";
-
- // Test power of 16 (2^4)
- TopLoc_Location aPow16 = aLoc.Powered(16);
- aResult = anOrigin.Transformed(aPow16.Transformation());
- EXPECT_NEAR(aResult.X(), 16.0, 1e-9) << "Powered(16) should translate 16 units";
-}
-
-TEST(TopLoc_Location_Test, BinaryExponentiation_OddPowers)
-{
- // Test binary exponentiation for odd powers (5, 7, 9)
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- gp_Pnt anOrigin(0, 0, 0);
-
- // Test power of 5
- TopLoc_Location aPow5 = aLoc.Powered(5);
- gp_Pnt aResult = anOrigin.Transformed(aPow5.Transformation());
- EXPECT_NEAR(aResult.X(), 5.0, 1e-9) << "Powered(5) should translate 5 units";
-
- // Test power of 7
- TopLoc_Location aPow7 = aLoc.Powered(7);
- aResult = anOrigin.Transformed(aPow7.Transformation());
- EXPECT_NEAR(aResult.X(), 7.0, 1e-9) << "Powered(7) should translate 7 units";
-
- // Test power of 9
- TopLoc_Location aPow9 = aLoc.Powered(9);
- aResult = anOrigin.Transformed(aPow9.Transformation());
- EXPECT_NEAR(aResult.X(), 9.0, 1e-9) << "Powered(9) should translate 9 units";
-}
-
-TEST(TopLoc_Location_Test, BinaryExponentiation_VeryLargePower)
-{
- // Test with very large power to verify efficiency improvement
- // L^64 with binary exponentiation: only 6 squarings
- // L^64 with naive: 63 multiplications
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(0.5, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- TopLoc_Location aPow64 = aLoc.Powered(64);
-
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResult = anOrigin.Transformed(aPow64.Transformation());
-
- EXPECT_NEAR(aResult.X(), 32.0, 1e-8) << "Powered(64) should translate 32 units (64 * 0.5)";
-}
-
-TEST(TopLoc_Location_Test, BinaryExponentiation_NegativePowers)
-{
- // Test binary exponentiation for negative powers
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(1.0, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- // Test power of -4 (should be inverse of power 4)
- TopLoc_Location aPowNeg4 = aLoc.Powered(-4);
- TopLoc_Location aPow4 = aLoc.Powered(4);
-
- TopLoc_Location aIdentity = aPowNeg4 * aPow4;
- EXPECT_TRUE(aIdentity.IsIdentity()) << "L^(-4) * L^4 should produce identity";
-
- // Verify the transformation
- gp_Pnt anOrigin(0, 0, 0);
- gp_Pnt aResult = anOrigin.Transformed(aPowNeg4.Transformation());
- EXPECT_NEAR(aResult.X(), -4.0, 1e-9) << "Powered(-4) should translate -4 units";
-}
-
-TEST(TopLoc_Location_Test, BinaryExponentiation_RotationPowers)
-{
- // Test binary exponentiation with rotation transformations
- // 45 degrees rotation, power of 8 should equal 360 degrees (identity)
- gp_Trsf aRot;
- gp_Ax1 anAxis(gp_Pnt(0, 0, 0), gp_Dir(0, 0, 1));
- aRot.SetRotation(anAxis, M_PI / 4.0); // 45 degrees
-
- TopLoc_Location aLoc(aRot);
- TopLoc_Location aPow8 = aLoc.Powered(8); // 8 * 45 degrees = 360 degrees
-
- // Should be close to identity (full rotation)
- gp_Pnt aPnt(1, 0, 0);
- gp_Pnt aResult = aPnt.Transformed(aPow8.Transformation());
-
- EXPECT_NEAR(aResult.X(), 1.0, 1e-8);
- EXPECT_NEAR(aResult.Y(), 0.0, 1e-8);
- EXPECT_NEAR(aResult.Z(), 0.0, 1e-8);
-}
-
-TEST(TopLoc_Location_Test, BinaryExponentiation_MixedEvenOdd)
-{
- // Test a mix of even and odd powers to verify the algorithm handles both cases
- gp_Trsf aTrsf;
- aTrsf.SetTranslation(gp_Vec(2.0, 0.0, 0.0));
- TopLoc_Location aLoc(aTrsf);
-
- gp_Pnt anOrigin(0, 0, 0);
-
- // Test 6 (even)
- TopLoc_Location aPow6 = aLoc.Powered(6);
- gp_Pnt aResult = anOrigin.Transformed(aPow6.Transformation());
- EXPECT_NEAR(aResult.X(), 12.0, 1e-9);
-
- // Test 11 (odd)
- TopLoc_Location aPow11 = aLoc.Powered(11);
- aResult = anOrigin.Transformed(aPow11.Transformation());
- EXPECT_NEAR(aResult.X(), 22.0, 1e-9);
-
- // Test 15 (odd)
- TopLoc_Location aPow15 = aLoc.Powered(15);
- aResult = anOrigin.Transformed(aPow15.Transformation());
- EXPECT_NEAR(aResult.X(), 30.0, 1e-9);
-}
projects / occt.git / commitdiff