}
//=======================================================================
-//function : addLinksWithShapes
-//purpose : set links of the Kinematic Joint on the OCAF
-//=======================================================================
-Standard_Boolean addLinksWithShapes(const Handle(XSControl_WorkSession)& theWS,
- const Handle(TDocStd_Document)& theDoc,
- const Handle(StepKinematics_KinematicLinkRepresentation)& aLinkRepresentation,
- TDF_Label& theLink,
- const TDF_Label& aMechanism,
- TColStd_SequenceOfTransient& aCollOfLinks,
- TDF_LabelSequence& aSeqOfLinksL,
- const XCAFDoc_DataMapOfShapeLabel& aMap,
- const Standard_Boolean& IsBase = Standard_False)
+//function : addLinkWithShapes
+//purpose : set links of the Kinematic Joint in the OCAF
+//=======================================================================
+Standard_Boolean addLinkWithShapes(const Handle(XSControl_WorkSession)& theWS,
+ const Handle(TDocStd_Document)& theDoc,
+ const Handle(StepKinematics_KinematicLinkRepresentation)& theLinkRepresentation,
+ const TDF_Label& theMechanism,
+ const XCAFDoc_DataMapOfShapeLabel& theMap,
+ TDF_Label& theLink,
+ NCollection_DataMap<Handle(StepKinematics_KinematicLinkRepresentation), TDF_Label>& theMapOfLinks,
+ const Standard_Boolean& theIsBase = Standard_False)
{
Handle(XSControl_TransferReader) aTR = theWS->TransferReader();
Handle(Transfer_TransientProcess) aTP = aTR->TransientProcess();
Handle(XCAFDoc_ShapeTool) aSTool = XCAFDoc_DocumentTool::ShapeTool(theDoc->Main());
Handle(XCAFDoc_KinematicTool) aKTool = XCAFDoc_DocumentTool::KinematicTool(theDoc->Main());
TDF_LabelSequence aShapes;
- Handle(StepKinematics_KinematicLink) aLink = aLinkRepresentation->RepresentedLink();
- for (Standard_Integer anIndexOfLink = 1; anIndexOfLink <= aCollOfLinks.Length(); ++anIndexOfLink)
- {
- if (aCollOfLinks(anIndexOfLink) == aLink)
- {
- theLink = aSeqOfLinksL(anIndexOfLink);
- aCollOfLinks.Append(aLink);
- aSeqOfLinksL.Append(theLink);
- return Standard_True;
- }
- }
+ Handle(StepKinematics_KinematicLink) aLink = theLinkRepresentation->RepresentedLink();
+ if(theMapOfLinks.Find(theLinkRepresentation, theLink))
+ return Standard_True;
Handle(StepKinematics_KinematicLinkRepresentationAssociation) aKLRA1;
- for (Interface_EntityIterator anIterLinks = aGraph.Sharings(aLinkRepresentation);
+ for (Interface_EntityIterator anIterLinks = aGraph.Sharings(theLinkRepresentation);
anIterLinks.More() && aKLRA1.IsNull(); anIterLinks.Next())
{
- if (!anIterLinks.Value()->IsKind(STANDARD_TYPE(StepKinematics_KinematicLinkRepresentationAssociation)))
- continue;
aKLRA1 = Handle(StepKinematics_KinematicLinkRepresentationAssociation)::DownCast(anIterLinks.Value());
}
if (aKLRA1.IsNull())
}
Handle(StepRepr_PropertyDefinition) aPD =
Handle(StepRepr_PropertyDefinition)::DownCast(aCDKLR->RepresentedProductRelation());
+ if (aPD.IsNull())
+ return Standard_False;
TDF_Label aShapeLabel;
Handle(Transfer_Binder) binder = aTP->Find(aPD->Definition().Value());
TopoDS_Shape aShape = TransferBRep::ShapeResult(aTP, binder);
if (aShape.IsNull())
return Standard_False;
- if (aMap.IsBound(aShape))
- aShapeLabel = aMap(aShape);
+ if (theMap.IsBound(aShape))
+ aShapeLabel = theMap(aShape);
else
aSTool->Search(aShape, aShapeLabel, Standard_True, Standard_True, Standard_True);
aShapes.Append(aShapeLabel);
if (aShapes.Length() == 0)
return Standard_False;
- theLink = aKTool->AddLink(aMechanism, aShapes, IsBase);
+ theLink = aKTool->AddLink(theMechanism, aShapes, theIsBase);
if (!aLink->Name()->IsEmpty())
TDataStd_Name::Set(theLink, aLink->Name()->String());
if (theLink.IsNull())
return Standard_False;
-
- aCollOfLinks.Append(aLink);
- aSeqOfLinksL.Append(theLink);
-
+ theMapOfLinks.Bind(theLinkRepresentation, theLink);
return Standard_True;
}
//function : getKinematicType
//purpose : get type of the Kinematic Pair
//=======================================================================
-XCAFKinematics_PairType getKinematicType(const Handle(StepKinematics_KinematicPair)& aKP)
+XCAFKinematics_PairType getKinematicType(const Handle(StepKinematics_KinematicPair)& theKP)
{
// Low order pairs
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_FullyConstrainedPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_FullyConstrainedPair)))
return XCAFKinematics_PairType_FullyConstrained;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RevolutePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RevolutePair)))
return XCAFKinematics_PairType_Revolute;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPair)))
return XCAFKinematics_PairType_Prismatic;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPair)))
return XCAFKinematics_PairType_Cylindrical;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_UniversalPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_UniversalPair)))
return XCAFKinematics_PairType_Universal;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_HomokineticPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_HomokineticPair)))
return XCAFKinematics_PairType_Homokinetic;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPin)))
return XCAFKinematics_PairType_SphericalWithPin;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPair)))
return XCAFKinematics_PairType_Spherical;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarPair)))
return XCAFKinematics_PairType_Planar;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_UnconstrainedPair)) ||
- aKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithRange)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_UnconstrainedPair)) ||
+ theKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithRange)))
return XCAFKinematics_PairType_Unconstrained;
// Low order pairs with motion coupling
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair)))
return XCAFKinematics_PairType_Screw;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPair)))
return XCAFKinematics_PairType_RackAndPinion;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_GearPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_GearPair)))
return XCAFKinematics_PairType_Gear;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPinionPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPinionPair)))
return XCAFKinematics_PairType_LinearFlexibleAndPinion;
// High order pairs
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair)))
return XCAFKinematics_PairType_PointOnSurface;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingSurfacePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingSurfacePair)))
return XCAFKinematics_PairType_SlidingSurface;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RollingSurfacePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RollingSurfacePair)))
return XCAFKinematics_PairType_RollingSurface;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePair)))
return XCAFKinematics_PairType_PointOnPlanarCurve;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingCurvePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingCurvePair)))
return XCAFKinematics_PairType_SlidingCurve;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RollingCurvePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RollingCurvePair)))
return XCAFKinematics_PairType_RollingCurve;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPlanarCurvePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPlanarCurvePair)))
return XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve;
return XCAFKinematics_PairType_NoType;
}
//======================== ===============================================
-//function : setKinematicPairLimits
-//purpose : set limits of the Kinematic Pair on the OCAF
+//function : setKinematicPairLimit
+//purpose : set limits of the Kinematic Pair in the OCAF
//=======================================================================
-Standard_Boolean setKinematicPairLimits(Handle(XCAFKinematics_PairObject)& aKinematicPairObj,
- const Handle(StepKinematics_KinematicPair)& aKP)
+Standard_Boolean setKinematicPairLimit(const Handle(StepKinematics_KinematicPair)& theKP,
+ Handle(XCAFKinematics_PairObject)& theKinematicPairObj)
{
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_FullyConstrainedPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_FullyConstrainedPair)))
return Standard_False; // no DOF
// Low order pairs
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair)))
{
- Handle(XCAFKinematics_LowOrderPairObject) anObj = Handle(XCAFKinematics_LowOrderPairObject)::DownCast(aKinematicPairObj);
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RevolutePairWithRange))) // one rotation DOF
+ Handle(XCAFKinematics_LowOrderPairObject) anObj = Handle(XCAFKinematics_LowOrderPairObject)::DownCast(theKinematicPairObj);
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RevolutePairWithRange))) // one rotation DOF
{
- Handle(StepKinematics_RevolutePairWithRange) aRevolutePairWithRange = Handle(StepKinematics_RevolutePairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_RevolutePairWithRange) aRevolutePairWithRange = Handle(StepKinematics_RevolutePairWithRange)::DownCast(theKP);
anObj->SetMaxRotationZ(aRevolutePairWithRange->UpperLimitActualRotation());
anObj->SetMinRotationZ(aRevolutePairWithRange->LowerLimitActualRotation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange)))// one translation DOF
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairWithRange)))// one translation DOF
{
- Handle(StepKinematics_PrismaticPairWithRange) aPrismaticPairWithRange = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_PrismaticPairWithRange) aPrismaticPairWithRange = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(theKP);
anObj->SetMaxTranslationX(aPrismaticPairWithRange->UpperLimitActualTranslation());
anObj->SetMinTranslationX(aPrismaticPairWithRange->LowerLimitActualTranslation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPairWithRange)))//one rotation and one translation DOF
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPairWithRange)))//one rotation and one translation DOF
{
- Handle(StepKinematics_CylindricalPairWithRange) aCylindricalPairWithRange = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_CylindricalPairWithRange) aCylindricalPairWithRange = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(theKP);
anObj->SetMaxRotationZ(aCylindricalPairWithRange->UpperLimitActualRotation());
anObj->SetMinRotationZ(aCylindricalPairWithRange->LowerLimitActualRotation());
anObj->SetMaxTranslationZ(aCylindricalPairWithRange->UpperLimitActualTranslation());
anObj->SetMinTranslationZ(aCylindricalPairWithRange->LowerLimitActualTranslation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_UniversalPairWithRange)))// two rotation DOF
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_UniversalPairWithRange)))// two rotation DOF
{
- Handle(StepKinematics_UniversalPairWithRange) aUniversalPairWithRange = Handle(StepKinematics_UniversalPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_UniversalPairWithRange) aUniversalPairWithRange = Handle(StepKinematics_UniversalPairWithRange)::DownCast(theKP);
anObj->SetMaxRotationX(aUniversalPairWithRange->UpperLimitFirstRotation());
anObj->SetMinRotationX(aUniversalPairWithRange->LowerLimitFirstRotation());
anObj->SetMaxRotationZ(aUniversalPairWithRange->UpperLimitSecondRotation());
anObj->SetMinRotationZ(aUniversalPairWithRange->LowerLimitSecondRotation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPinAndRange)))// two rotation DOF
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithPinAndRange)))// two rotation DOF
{
- Handle(StepKinematics_SphericalPairWithPinAndRange) aSphericalPairWithPinAndRange = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(aKP);
+ Handle(StepKinematics_SphericalPairWithPinAndRange) aSphericalPairWithPinAndRange = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(theKP);
//Pitch Yaw Roll (Y Z X) <angle>
anObj->SetMaxRotationZ(aSphericalPairWithPinAndRange->UpperLimitYaw());
anObj->SetMinRotationZ(aSphericalPairWithPinAndRange->LowerLimitYaw());
anObj->SetMaxRotationX(aSphericalPairWithPinAndRange->UpperLimitRoll());
anObj->SetMinRotationX(aSphericalPairWithPinAndRange->LowerLimitRoll());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithRange)))// three rotation DOF
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairWithRange)))// three rotation DOF
{
//Pitch Yaw Roll (Y Z X) <angle>
- Handle(StepKinematics_SphericalPairWithRange) aSphericalPairWithRange = Handle(StepKinematics_SphericalPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_SphericalPairWithRange) aSphericalPairWithRange = Handle(StepKinematics_SphericalPairWithRange)::DownCast(theKP);
anObj->SetMaxRotationZ(aSphericalPairWithRange->UpperLimitYaw());
anObj->SetMinRotationZ(aSphericalPairWithRange->LowerLimitYaw());
anObj->SetMaxRotationX(aSphericalPairWithRange->UpperLimitRoll());
anObj->SetMaxRotationY(aSphericalPairWithRange->UpperLimitPitch());
anObj->SetMinRotationY(aSphericalPairWithRange->LowerLimitPitch());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarPairWithRange))) // one rotation and two translation DOF
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarPairWithRange))) // one rotation and two translation DOF
{
- Handle(StepKinematics_PlanarPairWithRange) aPlanarPairWithRange = Handle(StepKinematics_PlanarPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_PlanarPairWithRange) aPlanarPairWithRange = Handle(StepKinematics_PlanarPairWithRange)::DownCast(theKP);
anObj->SetMaxRotationZ(aPlanarPairWithRange->UpperLimitActualRotation());
anObj->SetMinRotationZ(aPlanarPairWithRange->LowerLimitActualRotation());
anObj->SetMaxTranslationX(aPlanarPairWithRange->UpperLimitActualTranslationX());
anObj->SetMaxTranslationY(aPlanarPairWithRange->UpperLimitActualTranslationY());
anObj->SetMinTranslationY(aPlanarPairWithRange->LowerLimitActualTranslationY());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithRange))) // three rotation and three translation DOF
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithRange))) // three rotation and three translation DOF
{
- Handle(StepKinematics_LowOrderKinematicPairWithRange) anUnconstrainedPair = Handle(StepKinematics_LowOrderKinematicPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_LowOrderKinematicPairWithRange) anUnconstrainedPair = Handle(StepKinematics_LowOrderKinematicPairWithRange)::DownCast(theKP);
anObj->SetMaxRotationX(anUnconstrainedPair->UpperLimitActualRotationX());
anObj->SetMinRotationX(anUnconstrainedPair->LowerLimitActualRotationX());
anObj->SetMaxRotationY(anUnconstrainedPair->UpperLimitActualRotationY());
return Standard_True;
}
// Low order pairs with motion coupling
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithMotionCoupling)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithMotionCoupling)))
{
- Handle(XCAFKinematics_LowOrderPairObjectWithCoupling) anObj = Handle(XCAFKinematics_LowOrderPairObjectWithCoupling)::DownCast(aKinematicPairObj);
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_ScrewPairWithRange)))
+ Handle(XCAFKinematics_LowOrderPairObjectWithCoupling) anObj = Handle(XCAFKinematics_LowOrderPairObjectWithCoupling)::DownCast(theKinematicPairObj);
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_ScrewPairWithRange)))
{
- Handle(StepKinematics_ScrewPairWithRange) aScrewPairWithRange = Handle(StepKinematics_ScrewPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_ScrewPairWithRange) aScrewPairWithRange = Handle(StepKinematics_ScrewPairWithRange)::DownCast(theKP);
anObj->SetLowLimit(aScrewPairWithRange->LowerLimitActualRotation());
anObj->SetUpperLimit(aScrewPairWithRange->UpperLimitActualRotation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPairWithRange)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPairWithRange)))
{
- Handle(StepKinematics_RackAndPinionPairWithRange) aRackAndPinionPairWithRange = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_RackAndPinionPairWithRange) aRackAndPinionPairWithRange = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(theKP);
anObj->SetUpperLimit(aRackAndPinionPairWithRange->UpperLimitRackDisplacement());
anObj->SetLowLimit(aRackAndPinionPairWithRange->LowerLimitRackDisplacement());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_GearPairWithRange)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_GearPairWithRange)))
{
- Handle(StepKinematics_GearPairWithRange) aGearPairWithRange = Handle(StepKinematics_GearPairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_GearPairWithRange) aGearPairWithRange = Handle(StepKinematics_GearPairWithRange)::DownCast(theKP);
anObj->SetLowLimit(aGearPairWithRange->LowerLimitActualRotation1());
anObj->SetUpperLimit(aGearPairWithRange->UpperLimitActualRotation1());
}
return Standard_True;
}
// High order pairs
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_HighOrderKinematicPair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_HighOrderKinematicPair)))
{
- Handle(XCAFKinematics_HighOrderPairObject) anObj = Handle(XCAFKinematics_HighOrderPairObject)::DownCast(aKinematicPairObj);//new XCAFKinematics_HighOrderPairObject;
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairWithRange)))
+ Handle(XCAFKinematics_HighOrderPairObject) anObj = Handle(XCAFKinematics_HighOrderPairObject)::DownCast(theKinematicPairObj);//new XCAFKinematics_HighOrderPairObject;
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairWithRange)))
{
- Handle(StepKinematics_PointOnSurfacePairWithRange) aPointOnSurfacePairWithRange = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_PointOnSurfacePairWithRange) aPointOnSurfacePairWithRange = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(theKP);
anObj->SetLowLimitYaw(aPointOnSurfacePairWithRange->LowerLimitYaw());
anObj->SetUpperLimitYaw(aPointOnSurfacePairWithRange->UpperLimitYaw());
anObj->SetLowLimitPitch(aPointOnSurfacePairWithRange->LowerLimitPitch());
anObj->SetUpperLimitRoll(aPointOnSurfacePairWithRange->UpperLimitRoll());
anObj->SetTrimmedSurface(StepToGeom::MakeRectangularTrimmedSurface(aPointOnSurfacePairWithRange->RangeOnPairSurface()));
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairWithRange)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairWithRange)))
{
- Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aPointOnPlanarCurvePairWithRange = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(aKP);
+ Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aPointOnPlanarCurvePairWithRange = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(theKP);
anObj->SetLowLimitYaw(aPointOnPlanarCurvePairWithRange->LowerLimitYaw());
anObj->SetUpperLimitYaw(aPointOnPlanarCurvePairWithRange->UpperLimitYaw());
anObj->SetLowLimitPitch(aPointOnPlanarCurvePairWithRange->LowerLimitPitch());
anObj->SetUpperLimitRoll(aPointOnPlanarCurvePairWithRange->UpperLimitRoll());
anObj->SetTrimmedCurve(StepToGeom::MakeTrimmedCurve(aPointOnPlanarCurvePairWithRange->RangeOnPairCurve()));
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePairRange)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePairRange)))
{
- Handle(StepKinematics_PlanarCurvePairRange) aPlanarCurvePairRange = Handle(StepKinematics_PlanarCurvePairRange)::DownCast(aKP);
+ Handle(StepKinematics_PlanarCurvePairRange) aPlanarCurvePairRange = Handle(StepKinematics_PlanarCurvePairRange)::DownCast(theKP);
anObj->SetFirstCurve(StepToGeom::MakeCurve(aPlanarCurvePairRange->RangeOnCurve1()));
anObj->SetSecondCurve(StepToGeom::MakeCurve(aPlanarCurvePairRange->RangeOnCurve2()));
}
//function : createXCAFKinematicPairObject
//purpose : create XCAFKinematicPairObject with main parameters of the Kinematic Pair
//=======================================================================
-Handle(XCAFKinematics_PairObject) createXCAFKinematicPairObject(const Handle(StepKinematics_KinematicPair)& aKP)
+Handle(XCAFKinematics_PairObject) createXCAFKinematicPairObject(const Handle(StepKinematics_KinematicPair)& theKP)
{
Handle(XCAFKinematics_PairObject) anObj;
// Low order pairs
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPair)))
{
anObj = new XCAFKinematics_LowOrderPairObject;
- anObj->SetType(getKinematicType(aKP));
+ anObj->SetType(getKinematicType(theKP));
Handle(XCAFKinematics_LowOrderPairObject) anLowOrderKinPairObj = Handle(XCAFKinematics_LowOrderPairObject)::DownCast(anObj);
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_UniversalPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_UniversalPair)))
{
- Handle(StepKinematics_UniversalPair) anUniversalPair = Handle(StepKinematics_UniversalPair)::DownCast(aKP);
+ Handle(StepKinematics_UniversalPair) anUniversalPair = Handle(StepKinematics_UniversalPair)::DownCast(theKP);
anLowOrderKinPairObj->SetSkewAngle(anUniversalPair->InputSkewAngle());
}
}
// Low order pairs with motion coupling
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithMotionCoupling)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LowOrderKinematicPairWithMotionCoupling)))
{
anObj = new XCAFKinematics_LowOrderPairObjectWithCoupling;
- anObj->SetType(getKinematicType(aKP));
+ anObj->SetType(getKinematicType(theKP));
Handle(XCAFKinematics_LowOrderPairObjectWithCoupling) anLowOrderKinPairWthCouplingObj = Handle(XCAFKinematics_LowOrderPairObjectWithCoupling)::DownCast(anObj);
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_ScrewPair)))
{
- Handle(StepKinematics_ScrewPair) aScrewPair = Handle(StepKinematics_ScrewPair)::DownCast(aKP);
+ Handle(StepKinematics_ScrewPair) aScrewPair = Handle(StepKinematics_ScrewPair)::DownCast(theKP);
anLowOrderKinPairWthCouplingObj->SetPitch(aScrewPair->Pitch());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPair)))
{
- Handle(StepKinematics_RackAndPinionPair) aRackAndPinionPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(aKP);
+ Handle(StepKinematics_RackAndPinionPair) aRackAndPinionPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(theKP);
anLowOrderKinPairWthCouplingObj->SetPinionRadius(aRackAndPinionPair->PinionRadius());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_GearPair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_GearPair)))
{
- Handle(StepKinematics_GearPair) aGearPair = Handle(StepKinematics_GearPair)::DownCast(aKP);
+ Handle(StepKinematics_GearPair) aGearPair = Handle(StepKinematics_GearPair)::DownCast(theKP);
anLowOrderKinPairWthCouplingObj->SetBevel(aGearPair->Bevel());
anLowOrderKinPairWthCouplingObj->SetGearRatio(aGearPair->GearRatio());
anLowOrderKinPairWthCouplingObj->SetHelicalAngle(aGearPair->HelicalAngle());
anLowOrderKinPairWthCouplingObj->SetRadiusFirstLink(aGearPair->RadiusFirstLink());
anLowOrderKinPairWthCouplingObj->SetRadiusSecondLink(aGearPair->RadiusSecondLink());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPinionPair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPinionPair)))
{
- Handle(StepKinematics_LinearFlexibleAndPinionPair) aLinearFlexibleAndPinionPair = Handle(StepKinematics_LinearFlexibleAndPinionPair)::DownCast(aKP);
+ Handle(StepKinematics_LinearFlexibleAndPinionPair) aLinearFlexibleAndPinionPair = Handle(StepKinematics_LinearFlexibleAndPinionPair)::DownCast(theKP);
anLowOrderKinPairWthCouplingObj->SetPinionRadius(aLinearFlexibleAndPinionPair->PinionRadius());
}
}
// High order pairs
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_HighOrderKinematicPair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_HighOrderKinematicPair)))
{
anObj = new XCAFKinematics_HighOrderPairObject;
- anObj->SetType(getKinematicType(aKP));
+ anObj->SetType(getKinematicType(theKP));
Handle(XCAFKinematics_HighOrderPairObject) aHighOrderPairObject = Handle(XCAFKinematics_HighOrderPairObject)::DownCast(anObj);
- if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair)))
+ if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePair)))
{
- Handle(StepKinematics_PointOnSurfacePair) aPointOnSurfacePair = Handle(StepKinematics_PointOnSurfacePair)::DownCast(aKP);
+ Handle(StepKinematics_PointOnSurfacePair) aPointOnSurfacePair = Handle(StepKinematics_PointOnSurfacePair)::DownCast(theKP);
aHighOrderPairObject->SetSurface(StepToGeom::MakeSurface(aPointOnSurfacePair->PairSurface()));
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RollingSurfacePair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RollingSurfacePair)))
{
- Handle(StepKinematics_RollingSurfacePair) aRollingSurfacePair = Handle(StepKinematics_RollingSurfacePair)::DownCast(aKP);
+ Handle(StepKinematics_RollingSurfacePair) aRollingSurfacePair = Handle(StepKinematics_RollingSurfacePair)::DownCast(theKP);
aHighOrderPairObject->SetFirstSurface(StepToGeom::MakeSurface(aRollingSurfacePair->Surface1()));
aHighOrderPairObject->SetSecondSurface(StepToGeom::MakeSurface(aRollingSurfacePair->Surface2()));
aHighOrderPairObject->SetOrientation(aRollingSurfacePair->Orientation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingSurfacePair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingSurfacePair)))
{
- Handle(StepKinematics_SlidingSurfacePair) aSlidingSurfacePair = Handle(StepKinematics_SlidingSurfacePair)::DownCast(aKP);
+ Handle(StepKinematics_SlidingSurfacePair) aSlidingSurfacePair = Handle(StepKinematics_SlidingSurfacePair)::DownCast(theKP);
aHighOrderPairObject->SetFirstSurface(StepToGeom::MakeSurface(aSlidingSurfacePair->Surface1()));
aHighOrderPairObject->SetSecondSurface(StepToGeom::MakeSurface(aSlidingSurfacePair->Surface2()));
aHighOrderPairObject->SetOrientation(aSlidingSurfacePair->Orientation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingCurvePair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_SlidingCurvePair)))
{
- Handle(StepKinematics_SlidingCurvePair) aSlidingCurvePair = Handle(StepKinematics_SlidingCurvePair)::DownCast(aKP);
+ Handle(StepKinematics_SlidingCurvePair) aSlidingCurvePair = Handle(StepKinematics_SlidingCurvePair)::DownCast(theKP);
aHighOrderPairObject->SetFirstCurve(StepToGeom::MakeCurve(aSlidingCurvePair->Curve1()));
aHighOrderPairObject->SetSecondCurve(StepToGeom::MakeCurve(aSlidingCurvePair->Curve2()));
aHighOrderPairObject->SetOrientation(aSlidingCurvePair->Orientation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_RollingCurvePair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_RollingCurvePair)))
{
- Handle(StepKinematics_RollingCurvePair) aRollingCurvePair = Handle(StepKinematics_RollingCurvePair)::DownCast(aKP);
+ Handle(StepKinematics_RollingCurvePair) aRollingCurvePair = Handle(StepKinematics_RollingCurvePair)::DownCast(theKP);
aHighOrderPairObject->SetFirstCurve(StepToGeom::MakeCurve(aRollingCurvePair->Curve1()));
aHighOrderPairObject->SetSecondCurve(StepToGeom::MakeCurve(aRollingCurvePair->Curve2()));
aHighOrderPairObject->SetOrientation(aRollingCurvePair->Orientation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePair)))
{
- Handle(StepKinematics_PointOnPlanarCurvePair) aPointOnPlanarCurvePair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(aKP);
+ Handle(StepKinematics_PointOnPlanarCurvePair) aPointOnPlanarCurvePair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(theKP);
aHighOrderPairObject->SetOrientation(aPointOnPlanarCurvePair->Orientation());
aHighOrderPairObject->SetCurve(StepToGeom::MakeCurve(aPointOnPlanarCurvePair->PairCurve()));
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_PlanarCurvePair)))
{
- Handle(StepKinematics_PlanarCurvePair) aPlanarCurvePair = Handle(StepKinematics_PlanarCurvePair)::DownCast(aKP);
+ Handle(StepKinematics_PlanarCurvePair) aPlanarCurvePair = Handle(StepKinematics_PlanarCurvePair)::DownCast(theKP);
aHighOrderPairObject->SetFirstCurve(StepToGeom::MakeCurve(aPlanarCurvePair->Curve1()));
aHighOrderPairObject->SetSecondCurve(StepToGeom::MakeCurve(aPlanarCurvePair->Curve2()));
aHighOrderPairObject->SetOrientation(aPlanarCurvePair->Orientation());
}
- else if (aKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPlanarCurvePair)))
+ else if (theKP->IsKind(STANDARD_TYPE(StepKinematics_LinearFlexibleAndPlanarCurvePair)))
{
- Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair) aLinearFlexibleAndPlanarCurvePair = Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)::DownCast(aKP);
+ Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair) aLinearFlexibleAndPlanarCurvePair = Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)::DownCast(theKP);
aHighOrderPairObject->SetFirstCurve(StepToGeom::MakeCurve(aLinearFlexibleAndPlanarCurvePair->PairCurve()));
aHighOrderPairObject->SetOrientation(aLinearFlexibleAndPlanarCurvePair->Orientation());
}
}
if (!anObj.IsNull())
{
- Handle(StepRepr_RepresentationItem) aTransformItem1 = aKP->ItemDefinedTransformation()->TransformItem1();
- Handle(StepRepr_RepresentationItem) aTransformItem2 = aKP->ItemDefinedTransformation()->TransformItem2();
+ Handle(StepRepr_RepresentationItem) aTransformItem1 = theKP->ItemDefinedTransformation()->TransformItem1();
+ Handle(StepRepr_RepresentationItem) aTransformItem2 = theKP->ItemDefinedTransformation()->TransformItem2();
Handle(Geom_Axis2Placement) aPlacementFirst;
Handle(Geom_Axis2Placement) aPlacementSecond;
if (aTransformItem1->IsKind(STANDARD_TYPE(StepKinematics_SuParameters)))
aPlacementSecond = StepToGeom::MakeAxis2Placement(Handle(StepKinematics_SuParameters)::DownCast(aTransformItem2));
else
aPlacementSecond = StepToGeom::MakeAxis2Placement(Handle(StepGeom_Axis2Placement3d)::DownCast(aTransformItem2));
- if (!aKP->Joint()->Name()->IsEmpty())
- anObj->SetName(aKP->Joint()->Name()->String());
+ if (!theKP->Joint()->Name()->IsEmpty())
+ anObj->SetName(theKP->Joint()->Name()->String());
anObj->SetFirstTransformation(aPlacementFirst->Ax2());
anObj->SetSecondTransformation(aPlacementSecond->Ax2());
//=======================================================================
//function : setPairValue
-//purpose : set pair Value of the kinematic pair on OCAF
+//purpose : set pair Value of the kinematic pair in OCAF
//=======================================================================
Standard_Boolean setKinematicPairValue(const Handle(XSControl_WorkSession)& theWS,
const Handle(TDocStd_Document)& theDoc,
- const XCAFKinematics_PairType aType,
- const Handle(StepKinematics_PairValue)& aValue,
- const TDF_Label& aState,
- const TDF_Label& aJoint)
+ const Handle(StepKinematics_KinematicJoint)& theKinematicJoint,
+ const Handle(StepKinematics_PairValue)& theValue,
+ const TDF_Label& theState,
+ const TDF_Label& theJoint)
{
Handle(XSControl_TransferReader) aTR = theWS->TransferReader();
Handle(Transfer_TransientProcess) aTP = aTR->TransientProcess();
const Interface_Graph& aGraph = aTP->Graph();
Handle(XCAFDoc_KinematicTool) aKTool = XCAFDoc_DocumentTool::KinematicTool(theDoc->Main());
- Handle(XCAFKinematics_PairValueObject) aValueObject;
- aValueObject = new XCAFKinematics_PairValueObject();
- aValueObject->SetType(aType);
+ Handle(XCAFKinematics_PairValueObject) aValueObject = new XCAFKinematics_PairValueObject();
- if (aType == 0)
+ Handle(StepKinematics_KinematicLink) aLink = Handle(StepKinematics_KinematicLink)::DownCast(theKinematicJoint->EdgeStart());
+ if (aLink.IsNull())
+ return Standard_False;
+ Handle(StepKinematics_KinematicLinkRepresentation) aLinkRepresentation;
+ Interface_EntityIterator anIterLinkRepr = aGraph.Sharings(aLink);
+ for (anIterLinkRepr.Start(); anIterLinkRepr.More() && aLinkRepresentation.IsNull(); anIterLinkRepr.Next())
+ aLinkRepresentation = Handle(StepKinematics_KinematicLinkRepresentation)::DownCast(anIterLinkRepr.Value());
+ if(aLinkRepresentation.IsNull())
return Standard_False;
+ Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx) aContext =
+ Handle(StepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx)::DownCast(aLinkRepresentation->ContextOfItems());
+
+ Handle(XCAFDoc_KinematicPair) aKPairAttr;
+ if (!theJoint.FindAttribute(XCAFDoc_KinematicPair::GetID(), aKPairAttr))
+ return Standard_False;
+ XCAFKinematics_PairType aPairType = aKPairAttr->GetObject()->Type();
+ if (aPairType == XCAFKinematics_PairType_NoType)
+ return Standard_False;
+ aValueObject->SetType(aPairType);
TDF_TagSource aTag;
- TDF_Label aValueL = aTag.NewChild(aState);
+ TDF_Label aValueL = aTag.NewChild(theState);
// Low order pairs
- if (aValue->IsKind(STANDARD_TYPE(StepKinematics_RevolutePairValue)))
+ if (theValue->IsKind(STANDARD_TYPE(StepKinematics_RevolutePairValue)))
{
- Handle(StepKinematics_RevolutePairValue) aRevolutePairValue = Handle(StepKinematics_RevolutePairValue)::DownCast(aValue);
+ Handle(StepKinematics_RevolutePairValue) aRevolutePairValue = Handle(StepKinematics_RevolutePairValue)::DownCast(theValue);
aValueObject->SetRotation(aRevolutePairValue->ActualRotation());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_PrismaticPairValue)))
{
- Handle(StepKinematics_PrismaticPairValue) aPrismaticPairValue = Handle(StepKinematics_PrismaticPairValue)::DownCast(aValue);
+ Handle(StepKinematics_PrismaticPairValue) aPrismaticPairValue = Handle(StepKinematics_PrismaticPairValue)::DownCast(theValue);
aValueObject->SetTranslation(aPrismaticPairValue->ActualTranslation());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_CylindricalPairValue)))
{
- Handle(StepKinematics_CylindricalPairValue) aCylindricalPairValue = Handle(StepKinematics_CylindricalPairValue)::DownCast(aValue);
+ Handle(StepKinematics_CylindricalPairValue) aCylindricalPairValue = Handle(StepKinematics_CylindricalPairValue)::DownCast(theValue);
aValueObject->SetTranslation(aCylindricalPairValue->ActualTranslation());
aValueObject->SetRotation(aCylindricalPairValue->ActualRotation());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_SphericalPairValue)))
{
- Handle(StepKinematics_SphericalPairValue) aSphericalPairValue = Handle(StepKinematics_SphericalPairValue)::DownCast(aValue);
- aValueObject->SetYPR(aSphericalPairValue->InputOrientation().YprRotation()->Value(1),
- aSphericalPairValue->InputOrientation().YprRotation()->Value(2), aSphericalPairValue->InputOrientation().YprRotation()->Value(3));
+ Handle(StepKinematics_SphericalPairValue) aSphericalPairValue = Handle(StepKinematics_SphericalPairValue)::DownCast(theValue);
+ if(aContext.IsNull())
+ return Standard_False;
+ Handle(TColStd_HArray1OfReal) anYprRotation = StepToGeom::MakeYprRotation(aSphericalPairValue->InputOrientation(), aContext->GlobalUnitAssignedContext());
+ if (anYprRotation.IsNull())
+ return Standard_False;
+ aValueObject->SetYPR(anYprRotation->Value(1), anYprRotation->Value(2), anYprRotation->Value(3));
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_UniversalPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_UniversalPairValue)))
{
- Handle(StepKinematics_UniversalPairValue) aUniversalPairValue = Handle(StepKinematics_UniversalPairValue)::DownCast(aValue);
+ Handle(StepKinematics_UniversalPairValue) aUniversalPairValue = Handle(StepKinematics_UniversalPairValue)::DownCast(theValue);
aValueObject->SetFirstRotation(aUniversalPairValue->FirstRotationAngle());
- aValueObject->SetSecondRotation(aUniversalPairValue->SecondRotationAngle()); //CHECK
+ aValueObject->SetSecondRotation(aUniversalPairValue->SecondRotationAngle());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_UnconstrainedPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_UnconstrainedPairValue)))
{
- Handle(StepKinematics_UnconstrainedPairValue) anUnconstrainedPairValue = Handle(StepKinematics_UnconstrainedPairValue)::DownCast(aValue);
+ Handle(StepKinematics_UnconstrainedPairValue) anUnconstrainedPairValue = Handle(StepKinematics_UnconstrainedPairValue)::DownCast(theValue);
aValueObject->SetTransformation(StepToGeom::MakeAxis2Placement(anUnconstrainedPairValue->ActualPlacement())->Ax2());
}
// Low order pairs with motion coupling
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_ScrewPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_ScrewPairValue)))
{
- Handle(StepKinematics_ScrewPairValue) aScrewPairValue = Handle(StepKinematics_ScrewPairValue)::DownCast(aValue);
+ Handle(StepKinematics_ScrewPairValue) aScrewPairValue = Handle(StepKinematics_ScrewPairValue)::DownCast(theValue);
aValueObject->SetRotation(aScrewPairValue->ActualRotation());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_GearPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_GearPairValue)))
{
- Handle(StepKinematics_GearPairValue) aGearPairValue = Handle(StepKinematics_GearPairValue)::DownCast(aValue);
+ Handle(StepKinematics_GearPairValue) aGearPairValue = Handle(StepKinematics_GearPairValue)::DownCast(theValue);
aValueObject->SetRotation(aGearPairValue->ActualRotation1());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_RackAndPinionPairValue)))
{
- Handle(StepKinematics_RackAndPinionPairValue) aRackAndPinionPairValue = Handle(StepKinematics_RackAndPinionPairValue)::DownCast(aValue);
+ Handle(StepKinematics_RackAndPinionPairValue) aRackAndPinionPairValue = Handle(StepKinematics_RackAndPinionPairValue)::DownCast(theValue);
aValueObject->SetTranslation(aRackAndPinionPairValue->ActualDisplacement());
}
// High order pairs
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_SlidingSurfacePairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_SlidingSurfacePairValue)))
{
- Handle(StepKinematics_SlidingSurfacePairValue) aSlidingSurfacePairValue = Handle(StepKinematics_SlidingSurfacePairValue)::DownCast(aValue);
+ Handle(StepKinematics_SlidingSurfacePairValue) aSlidingSurfacePairValue = Handle(StepKinematics_SlidingSurfacePairValue)::DownCast(theValue);
aValueObject->SetFirstPointOnSurface(aSlidingSurfacePairValue->ActualPointOnSurface1()->PointParameterU(), aSlidingSurfacePairValue->ActualPointOnSurface1()->PointParameterV());
aValueObject->SetSecondPointOnSurface(aSlidingSurfacePairValue->ActualPointOnSurface2()->PointParameterU(), aSlidingSurfacePairValue->ActualPointOnSurface2()->PointParameterV());
aValueObject->SetRotation(aSlidingSurfacePairValue->ActualRotation());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_RollingSurfacePairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_RollingSurfacePairValue)))
{
- Handle(StepKinematics_RollingSurfacePairValue) aRollingSurfacePairValue = Handle(StepKinematics_RollingSurfacePairValue)::DownCast(aValue);
+ Handle(StepKinematics_RollingSurfacePairValue) aRollingSurfacePairValue = Handle(StepKinematics_RollingSurfacePairValue)::DownCast(theValue);
aValueObject->SetRotation(aRollingSurfacePairValue->ActualRotation());
aValueObject->SetFirstPointOnSurface(aRollingSurfacePairValue->ActualPointOnSurface()->PointParameterU(), aRollingSurfacePairValue->ActualPointOnSurface()->PointParameterV());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_SlidingCurvePairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_SlidingCurvePairValue)))
{
- Handle(StepKinematics_SlidingCurvePairValue) aSlidingCurvePairValue = Handle(StepKinematics_SlidingCurvePairValue)::DownCast(aValue);
+ Handle(StepKinematics_SlidingCurvePairValue) aSlidingCurvePairValue = Handle(StepKinematics_SlidingCurvePairValue)::DownCast(theValue);
aValueObject->SetFirstPointOnCurve(aSlidingCurvePairValue->ActualPointOnCurve1()->PointParameter());
aValueObject->SetSecondPointOnCurve(aSlidingCurvePairValue->ActualPointOnCurve2()->PointParameter());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_RollingCurvePairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_RollingCurvePairValue)))
{
- Handle(StepKinematics_RollingCurvePairValue) aRollingCurvePairValue = Handle(StepKinematics_RollingCurvePairValue)::DownCast(aValue);
+ Handle(StepKinematics_RollingCurvePairValue) aRollingCurvePairValue = Handle(StepKinematics_RollingCurvePairValue)::DownCast(theValue);
aValueObject->SetPointOnCurve(aRollingCurvePairValue->ActualPointOnCurve1()->PointParameter());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_PlanarPairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_PlanarPairValue)))
{
- Handle(StepKinematics_PlanarPairValue) aPlanarPairValue = Handle(StepKinematics_PlanarPairValue)::DownCast(aValue);
+ Handle(StepKinematics_PlanarPairValue) aPlanarPairValue = Handle(StepKinematics_PlanarPairValue)::DownCast(theValue);
aValueObject->SetRotation(aPlanarPairValue->ActualRotation());
aValueObject->SetFirstTranslation(aPlanarPairValue->ActualTranslationX());
aValueObject->SetSecondTranslation(aPlanarPairValue->ActualTranslationY());
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_PointOnSurfacePairValue)))
{
- Handle(StepKinematics_PointOnSurfacePairValue) aPointOnSurfacePairValue = Handle(StepKinematics_PointOnSurfacePairValue)::DownCast(aValue);
+ Handle(StepKinematics_PointOnSurfacePairValue) aPointOnSurfacePairValue = Handle(StepKinematics_PointOnSurfacePairValue)::DownCast(theValue);
aValueObject->SetPointOnSurface(aPointOnSurfacePairValue->ActualPointOnSurface()->PointParameterU(),
aPointOnSurfacePairValue->ActualPointOnSurface()->PointParameterV());
- aValueObject->SetYPR(aPointOnSurfacePairValue->InputOrientation().YprRotation()->Value(1),
- aPointOnSurfacePairValue->InputOrientation().YprRotation()->Value(2), aPointOnSurfacePairValue->InputOrientation().YprRotation()->Value(3));
+ if (aContext.IsNull())
+ return Standard_False;
+ Handle(TColStd_HArray1OfReal) anYprRotation = StepToGeom::MakeYprRotation(aPointOnSurfacePairValue->InputOrientation(), aContext->GlobalUnitAssignedContext());
+ if (anYprRotation.IsNull())
+ return Standard_False;
+ aValueObject->SetYPR(anYprRotation->Value(1), anYprRotation->Value(2), anYprRotation->Value(3));
}
- else if (aValue->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairValue)))
+ else if (theValue->IsKind(STANDARD_TYPE(StepKinematics_PointOnPlanarCurvePairValue)))
{
- Handle(StepKinematics_PointOnPlanarCurvePairValue) aPointOnPlanarCurvePairValue = Handle(StepKinematics_PointOnPlanarCurvePairValue)::DownCast(aValue);
+ Handle(StepKinematics_PointOnPlanarCurvePairValue) aPointOnPlanarCurvePairValue = Handle(StepKinematics_PointOnPlanarCurvePairValue)::DownCast(theValue);
aValueObject->SetFirstPointOnCurve(aPointOnPlanarCurvePairValue->ActualPointOnCurve()->PointParameter());
- aValueObject->SetYPR(aPointOnPlanarCurvePairValue->InputOrientation().YprRotation()->Value(1),
- aPointOnPlanarCurvePairValue->InputOrientation().YprRotation()->Value(2), aPointOnPlanarCurvePairValue->InputOrientation().YprRotation()->Value(3));
+ if (aContext.IsNull())
+ return Standard_False;
+ Handle(TColStd_HArray1OfReal) anYprRotation = StepToGeom::MakeYprRotation(aPointOnPlanarCurvePairValue->InputOrientation(), aContext->GlobalUnitAssignedContext());
+ if (anYprRotation.IsNull())
+ return Standard_False;
+ aValueObject->SetYPR(anYprRotation->Value(1), anYprRotation->Value(2), anYprRotation->Value(3));
}
else
return Standard_False;
- if (aValueObject->GetAllValues().IsNull())
- return Standard_False;
- Handle(XCAFDoc_KinematicPairValue) aCAFKinematicPairValue = XCAFDoc_KinematicPairValue::Set(aValueL, aJoint);
+ Handle(XCAFDoc_KinematicPairValue) aCAFKinematicPairValue = XCAFDoc_KinematicPairValue::Set(aValueL, theJoint);
aCAFKinematicPairValue->SetObject(aValueObject);
- if (!aValue->Name()->IsEmpty())
- TDataStd_Name::Set(aValueL, aValue->Name()->ToCString());
+ if (!theValue->Name()->IsEmpty())
+ TDataStd_Name::Set(aValueL, theValue->Name()->ToCString());
return Standard_True;
}
//purpose :
//=======================================================================
Standard_Boolean STEPCAFControl_Reader::ReadKinematics(const Handle(XSControl_WorkSession)& theWS,
- Handle(TDocStd_Document)& theDoc,
- const XCAFDoc_DataMapOfShapeLabel& aShapeLabelMap) const
+ Handle(TDocStd_Document)& theDoc,
+ const XCAFDoc_DataMapOfShapeLabel& theShapeLabelMap) const
{
const Handle(Interface_InterfaceModel)& aModel = theWS->Model();
const Interface_Graph& aGraph = theWS->Graph();
Handle(StepKinematics_KinematicPropertyMechanismRepresentation)::DownCast(anEnt);
Handle(StepKinematics_MechanismRepresentation) aKMR =
Handle(StepKinematics_MechanismRepresentation)::DownCast(aKPMR->UsedRepresentation());
- TDF_Label aMechanism;
if (aKMR.IsNull())
continue;
-
+ TDF_Label aMechanism;
aMechanism = aKTool->AddMechanism();
- //Collecting entity of States and labels of States
- //States and their labels located at a single index
if (!aKMR->Name()->IsEmpty())
TDataStd_Name::Set(aMechanism, aKMR->Name()->String());
- TDF_LabelSequence aStates;
- Handle(TColStd_HArray1OfTransient) aArrayOfStates;
- Interface_EntityIterator anIterStates = aGraph.TypedSharings(aKMR, STANDARD_TYPE(StepKinematics_MechanismStateRepresentation));
- const Standard_Integer aCountOfStates = anIterStates.NbEntities();
- Standard_Boolean hasStates = Standard_False;
- if (aCountOfStates > 0)
- {
- aArrayOfStates = new TColStd_HArray1OfTransient(1, aCountOfStates);
- hasStates = Standard_True;
- }
- for (Standard_Integer indState = 1; anIterStates.More(); anIterStates.Next(), ++indState)
- {
- Handle(StepKinematics_MechanismStateRepresentation) aMechanismState = Handle(StepKinematics_MechanismStateRepresentation)::DownCast(anIterStates.Value());
- TDF_Label aState = aKTool->AddState(aMechanism);
- if (!aMechanismState->Name().IsNull() && !aMechanismState->Name()->IsEmpty())
- TDataStd_Name::Set(aState, aMechanismState->Name()->ToCString());
- aStates.Append(aState);
- aArrayOfStates->ChangeValue(indState) = aMechanismState;
- }
-
- //Collecting Joints and labels of Joints
- //Joints and their labels located at a single index
- TColStd_SequenceOfTransient aCollOfLinks;
- TDF_LabelSequence aSeqOfLinksL;
+ //Collecting Links and labels of Links
+ NCollection_DataMap<Handle(StepKinematics_KinematicLinkRepresentation), TDF_Label> theMapOfLinks;
//read base link
- //base link should be first label
- //if mechanism hasn't a base link, first link became base
if (!aKPMR->Base().IsNull())
{
TDF_Label aLableOfBaseLink;
- addLinksWithShapes(theWS, theDoc, aKPMR->Base(), aLableOfBaseLink, aMechanism, aCollOfLinks, aSeqOfLinksL, aShapeLabelMap, Standard_True);
+ addLinkWithShapes(theWS, theDoc, aKPMR->Base(), aMechanism, theShapeLabelMap, aLableOfBaseLink, theMapOfLinks, Standard_True);
}
-
+
+ //read joints with their links
+ NCollection_DataMap<Handle(StepKinematics_KinematicJoint), TDF_Label> theMapOfJoints;
for (Standard_Integer aPairIndex = 1; aPairIndex <= aKMR->NbItems(); ++aPairIndex)
{
if (!aKMR->ItemsValue(aPairIndex)->IsKind(STANDARD_TYPE(StepKinematics_PairRepresentationRelationship)))
if (aLinkRepresentation1.IsNull() || aLinkRepresentation2.IsNull())
continue;
TDF_Label aJoint, aLink1, aLink2;
- if (!addLinksWithShapes(theWS, theDoc, aLinkRepresentation1, aLink1, aMechanism, aCollOfLinks, aSeqOfLinksL, aShapeLabelMap))
+ if (!addLinkWithShapes(theWS, theDoc, aLinkRepresentation1, aMechanism, theShapeLabelMap, aLink1, theMapOfLinks))
continue;
- if (!addLinksWithShapes(theWS, theDoc, aLinkRepresentation2, aLink2, aMechanism, aCollOfLinks, aSeqOfLinksL, aShapeLabelMap))
+ if (!addLinkWithShapes(theWS, theDoc, aLinkRepresentation2, aMechanism, theShapeLabelMap, aLink2, theMapOfLinks))
continue;
//Setting info
aJoint = aKTool->AddJoint(aMechanism, aLink1, aLink2);
Handle(XCAFKinematics_PairObject) aPairObject = createXCAFKinematicPairObject(aKinematicPair);
if (aPairObject.IsNull())
continue;
- setKinematicPairLimits(aPairObject, aKinematicPair);
+ setKinematicPairLimit(aKinematicPair, aPairObject);
aCAFKinPair->SetObject(aPairObject);
+ theMapOfJoints.Bind(aKinematicJoint, aJoint);
+ }
- //Set Values of Joint on the OCAF
- for (Standard_Integer IndState = 1; hasStates && IndState <= aArrayOfStates->Length(); ++IndState)
+ // (optional)
+ // Set mechanism's states with their values in the OCAF
+ Interface_EntityIterator anIterStates = aGraph.TypedSharings(aKMR, STANDARD_TYPE(StepKinematics_MechanismStateRepresentation));
+ for (anIterStates.Start(); anIterStates.More(); anIterStates.Next())
+ {
+ Handle(StepKinematics_MechanismStateRepresentation) aMechanismState = Handle(StepKinematics_MechanismStateRepresentation)::DownCast(anIterStates.Value());
+ TDF_Label aState = aKTool->AddState(aMechanism);
+ if (!aMechanismState->Name().IsNull() && !aMechanismState->Name()->IsEmpty())
+ TDataStd_Name::Set(aState, aMechanismState->Name()->ToCString());
+ for (Standard_Integer anIndValue = 1; anIndValue <= aMechanismState->Items()->Length(); ++anIndValue)
{
- Handle(StepKinematics_MechanismStateRepresentation) aMechanismState =
- Handle(StepKinematics_MechanismStateRepresentation)::DownCast(aArrayOfStates->Value(IndState));
- for (Standard_Integer IndValue = 1; IndValue <= aMechanismState->Items()->Length(); ++IndValue)
- {
- Handle(StepKinematics_PairValue) aValue = Handle(StepKinematics_PairValue)::DownCast(aMechanismState->Items()->Value(IndValue));
- Handle(StepKinematics_KinematicJoint) aRefJoint =
- Handle(StepKinematics_KinematicJoint)::DownCast(aValue->AppliesToPair()->Joint());
- if (aRefJoint == aKinematicJoint)
- {
- setKinematicPairValue(theWS, theDoc, aPairObject->Type(), aValue, aStates.Value(IndState), aJoint);
- }
- }
+ Handle(StepKinematics_PairValue) aValue = Handle(StepKinematics_PairValue)::DownCast(aMechanismState->Items()->Value(anIndValue));
+ Handle(StepKinematics_KinematicJoint) aKinematicJoint = aValue->AppliesToPair()->Joint();
+ if (aKinematicJoint.IsNull())
+ continue;
+ TDF_Label aJoint = theMapOfJoints.Find(aKinematicJoint);
+ setKinematicPairValue(theWS, theDoc, aKinematicJoint, aValue, aState, aJoint);
}
}
-
}
return Standard_True;
}
}
if ( NAUO.IsNull() )
return Standard_False;
- // get Relatinf or Related product definition
+ // get Relating or Related product definition
if ( !IsRelating )
PD = NAUO->RelatedProductDefinition();
else
return Standard_True;
}
-//=======================================================================
-//function : MakeTrimmedCurve
-//purpose : auxilary
-//=======================================================================
-static Handle(StepGeom_TrimmedCurve) MakeTrimmedCurve(const Handle(StepGeom_Curve)& C,
- const Handle(Geom_TrimmedCurve) TC,
- Standard_Boolean sense)
-{
- Handle(StepGeom_HArray1OfTrimmingSelect) aSTS1 =
- new StepGeom_HArray1OfTrimmingSelect(1, 2);
- StepGeom_TrimmingSelect tSel;
- GeomToStep_MakeCartesianPoint aMP1(TC->StartPoint());
- tSel.SetValue(aMP1.Value());
- aSTS1->SetValue(1, tSel);
- tSel.SetParameterValue(TC->FirstParameter());
- aSTS1->SetValue(2, tSel);
-
- Handle(StepGeom_HArray1OfTrimmingSelect) aSTS2 =
- new StepGeom_HArray1OfTrimmingSelect(1, 2);
- GeomToStep_MakeCartesianPoint aMP2(TC->EndPoint());
- tSel.SetValue(aMP2.Value());
- aSTS2->SetValue(1, tSel);
- tSel.SetParameterValue(TC->LastParameter());
- aSTS2->SetValue(2, tSel);
-
- Handle(TCollection_HAsciiString) empty =
- new TCollection_HAsciiString("");
- Handle(StepGeom_TrimmedCurve) pmsTC = new StepGeom_TrimmedCurve;
- pmsTC->Init(empty, C, aSTS1, aSTS2, sense, StepGeom_tpParameter);
- return pmsTC;
-}
-
//=======================================================================
//function : createKinematicLink
//purpose : auxilary
//=======================================================================
static Standard_Boolean createKinematicLink(const Handle(Transfer_FinderProcess)& FP,
- const Handle(XCAFDoc_KinematicTool)& aKTool,
- Handle(StepKinematics_KinematicLink)& theLink,
- const Interface_Graph& aGraph,
- const TDF_Label& theLabelLink,
- Handle(StepShape_ShapeRepresentation)& aShapeRepr,
- Handle(StepRepr_PropertyDefinition)& aPDS)
+ const Handle(XCAFDoc_KinematicTool)& theKTool,
+ const Interface_Graph& theGraph,
+ const TDF_Label& theLabelLink,
+ Handle(StepKinematics_KinematicLink)& theLink,
+ Handle(StepShape_ShapeRepresentation)& theShapeRepr,
+ Handle(StepRepr_PropertyDefinition)& thePDS)
{
theLink = new StepKinematics_KinematicLink;
- Handle(TDataStd_Name) aNameLinkStart;
- theLabelLink.FindAttribute(TDataStd_Name::GetID(), aNameLinkStart);
- Handle(TCollection_HAsciiString) aHNameLinkStart = new TCollection_HAsciiString(aNameLinkStart->Get());
- theLink->Init(aHNameLinkStart);
+ Handle(TDataStd_Name) aNameLink;
+ Handle(TCollection_HAsciiString) aHNameLink;
+ if (theLabelLink.FindAttribute(TDataStd_Name::GetID(), aNameLink))
+ aHNameLink = new TCollection_HAsciiString(aNameLink->Get());
+ else
+ aHNameLink = new TCollection_HAsciiString("Link "+ theLabelLink.Tag());
+ theLink->Init(aHNameLink);
// find ref shapes
- TDF_LabelSequence aShapesStartL = aKTool->GetRefShapes(theLabelLink);
+ TDF_LabelSequence aShapesStartL = theKTool->GetRefShapes(theLabelLink);
if (aShapesStartL.IsEmpty()) return Standard_False;
TopoDS_Shape aTopoShapeStart = XCAFDoc_ShapeTool::GetShape(aShapesStartL.Value(1));
TopLoc_Location aLocStart;
}
// get PDS of Shape
- Interface_EntityIterator anIter = aGraph.Sharings(seqRI.Value(1));
- for (anIter.Start(); anIter.More() && aPDS.IsNull(); anIter.Next()) {
- aShapeRepr = Handle(StepShape_ShapeRepresentation)::DownCast(anIter.Value());
- if (aShapeRepr.IsNull())
+ Interface_EntityIterator anIter = theGraph.Sharings(seqRI.Value(1));
+ for (anIter.Start(); anIter.More() && thePDS.IsNull(); anIter.Next()) {
+ theShapeRepr = Handle(StepShape_ShapeRepresentation)::DownCast(anIter.Value());
+ if (theShapeRepr.IsNull())
continue;
- Interface_EntityIterator aSDRIt = aGraph.Sharings(aShapeRepr);
- for (aSDRIt.Start(); aSDRIt.More() && aPDS.IsNull(); aSDRIt.Next()) {
+ Interface_EntityIterator aSDRIt = theGraph.Sharings(theShapeRepr);
+ for (aSDRIt.Start(); aSDRIt.More() && thePDS.IsNull(); aSDRIt.Next()) {
Handle(StepShape_ShapeDefinitionRepresentation) aSDR =
Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(aSDRIt.Value());
if (aSDR.IsNull()) continue;
- aPDS = aSDR->Definition().PropertyDefinition();
- if (!aPDS.IsNull())
+ thePDS = aSDR->Definition().PropertyDefinition();
+ if (!thePDS.IsNull())
return Standard_True;
}
}
//function : createKinematicJoint
//purpose : auxilary
//=======================================================================
-static Standard_Boolean createKinematicJoint(const Handle(Transfer_FinderProcess)& FP,
- const Handle(XCAFDoc_KinematicTool)& aKTool,
- const Interface_Graph& aGraph,
- const TDF_Label& theLabelJoint,
- const Handle(XCAFKinematics_PairObject)& aKinPairObj,
- TDF_LabelSequence& aSeqOfLinskL,
- Handle(StepKinematics_RigidLinkRepresentation)& aRigLinkRepr1,
- Handle(StepKinematics_RigidLinkRepresentation)& aRigLinkRepr2,
- Handle(TColStd_HArray1OfTransient)& aArrayOfRigidLinks,
- Handle(StepKinematics_KinematicJoint)& theJoint)
+static Standard_Boolean createKinematicJoint(const Handle(Transfer_FinderProcess)& theFP,
+ const Handle(XCAFDoc_KinematicTool)& theKTool,
+ const Interface_Graph& theGraph,
+ const TDF_Label& theLabelJoint,
+ const Handle(XCAFKinematics_PairObject)& theKinPairObj,
+ const NCollection_DataMap<TDF_Label, Handle(StepKinematics_RigidLinkRepresentation), TDF_LabelMapHasher>& theMapOfLinks,
+ Handle(StepKinematics_RigidLinkRepresentation)& theRigLinkRepr1,
+ Handle(StepKinematics_RigidLinkRepresentation)& theRigLinkRepr2,
+ Handle(StepKinematics_KinematicJoint)& theJoint)
{
TDF_Label aLinkStartL, aLinkEndL;
theJoint = new StepKinematics_KinematicJoint;
- aKTool->GetLinksOfJoint(theLabelJoint, aLinkStartL, aLinkEndL);
- Handle(TCollection_HAsciiString) aNameJoint = new TCollection_HAsciiString(aKinPairObj->Name());
-
- Handle(TDataStd_Name) aNameLinkStart;
- aLinkStartL.FindAttribute(TDataStd_Name::GetID(), aNameLinkStart);
+ theKTool->GetLinksOfJoint(theLabelJoint, aLinkStartL, aLinkEndL);
+ Handle(TCollection_HAsciiString) aNameJoint = new TCollection_HAsciiString(theKinPairObj->Name());
- Handle(TDataStd_Name) aNameLinkEnd;
- aLinkEndL.FindAttribute(TDataStd_Name::GetID(), aNameLinkEnd);
Handle(StepShape_Vertex) aEdgeStart;
Handle(StepShape_Vertex) aEdgeEnd;
- //find represent of link in the containers
- //link and their label has single index
- Standard_Integer aLinkInd;
- for (aLinkInd = 1; (aLinkInd <= aArrayOfRigidLinks->Length()) && (aEdgeStart.IsNull() || aEdgeEnd.IsNull()); ++aLinkInd)
- {
- if (aSeqOfLinskL(aLinkInd) == aLinkStartL)
- {
- aRigLinkRepr1 = Handle(StepKinematics_RigidLinkRepresentation)::DownCast(aArrayOfRigidLinks->Value(aLinkInd));
- if (aRigLinkRepr1.IsNull())
- return Standard_False;
- aEdgeStart = aRigLinkRepr1->RepresentedLink();
- }
- else if (aSeqOfLinskL(aLinkInd) == aLinkEndL)
- {
- aRigLinkRepr2 = Handle(StepKinematics_RigidLinkRepresentation)::DownCast(aArrayOfRigidLinks->Value(aLinkInd));
- if (aRigLinkRepr2.IsNull())
- return Standard_False;
- aEdgeEnd = aRigLinkRepr2->RepresentedLink();
- }
- }
- if (aEdgeEnd.IsNull() || aEdgeStart.IsNull())
+ if (!theMapOfLinks.Find(aLinkStartL, theRigLinkRepr1))
return Standard_False;
- theJoint->Init(aNameJoint, aEdgeStart, aEdgeEnd);
+ if (!theMapOfLinks.Find(aLinkEndL, theRigLinkRepr2))
+ return Standard_False;
+
+ aEdgeStart = theRigLinkRepr1->RepresentedLink();
+ aEdgeEnd = theRigLinkRepr2->RepresentedLink();
+ if (aEdgeEnd.IsNull() || aEdgeStart.IsNull())
+ return Standard_False;
+ theJoint->Init(aNameJoint, aEdgeStart, aEdgeEnd);
return Standard_True;
}
//function : createKinematicPair
//purpose : auxilary
//=======================================================================
-static Standard_Boolean createKinematicPair(const Handle(XCAFKinematics_PairObject)& aKinPairObj,
- Handle(StepKinematics_KinematicPair)& aKinematicPair,
- const Handle(StepKinematics_KinematicJoint)& theJoint,
- const TDF_LabelSequence& aSeqOfLinskL,
- Handle(StepKinematics_RigidLinkRepresentation)& aRigLinkRepr1,
- Handle(StepKinematics_RigidLinkRepresentation)& aRigLinkRepr2,
- const Handle(TColStd_HArray1OfTransient)& aArrayOfRigidLinks)
+static Standard_Boolean createKinematicPair(const Handle(XCAFKinematics_PairObject)& theKinPairObj,
+ const Handle(StepKinematics_KinematicJoint)& theJoint,
+ Handle(StepKinematics_KinematicPair)& theKinematicPair,
+ Handle(StepKinematics_RigidLinkRepresentation)& theRigLinkRepr1,
+ Handle(StepKinematics_RigidLinkRepresentation)& theRigLinkRepr2)
{
- if (aKinPairObj->Type() == XCAFKinematics_PairType_NoType)
+ if (theKinPairObj->Type() == XCAFKinematics_PairType_NoType)
return Standard_False;
- Handle(StepRepr_RepresentationItem) theTransformItem1 = GeomToStep_MakeAxis2Placement3d(aKinPairObj->FirstTransformation()).Value();
- Handle(StepRepr_RepresentationItem) theTransformItem2 = GeomToStep_MakeAxis2Placement3d(aKinPairObj->SecondTransformation()).Value();
+ Handle(StepRepr_RepresentationItem) theTransformItem1 = GeomToStep_MakeAxis2Placement3d(theKinPairObj->FirstTransformation()).Value();
+ Handle(StepRepr_RepresentationItem) theTransformItem2 = GeomToStep_MakeAxis2Placement3d(theKinPairObj->SecondTransformation()).Value();
- aRigLinkRepr1->Items()->Resize(aRigLinkRepr1->Items()->Lower(), aRigLinkRepr1->Items()->Upper() + 1, Standard_True);
- aRigLinkRepr1->Items()->ChangeLast() = theTransformItem1;
+ theRigLinkRepr1->Items()->Resize(theRigLinkRepr1->Items()->Lower(), theRigLinkRepr1->Items()->Upper() + 1, Standard_True);
+ theRigLinkRepr1->Items()->ChangeLast() = theTransformItem1;
- aRigLinkRepr2->Items()->Resize(aRigLinkRepr2->Items()->Lower(), aRigLinkRepr2->Items()->Upper() + 1, Standard_True);
- aRigLinkRepr2->Items()->ChangeLast() = theTransformItem1;
+ theRigLinkRepr2->Items()->Resize(theRigLinkRepr2->Items()->Lower(), theRigLinkRepr2->Items()->Upper() + 1, Standard_True);
+ theRigLinkRepr2->Items()->ChangeLast() = theTransformItem2;
Standard_Boolean hasDescription = Standard_False;
- Handle(TCollection_HAsciiString) aPairName = new TCollection_HAsciiString(aKinPairObj->Name());
+ Handle(TCollection_HAsciiString) aPairName = new TCollection_HAsciiString(theKinPairObj->Name());
Handle(TCollection_HAsciiString) aDescription;
- Standard_Boolean HasRange = aKinPairObj->HasLimits();
- if (aKinPairObj->IsKind(STANDARD_TYPE(XCAFKinematics_LowOrderPairObject)))
+ Standard_Boolean aHasRange = theKinPairObj->HasLimits();
+ if (theKinPairObj->IsKind(STANDARD_TYPE(XCAFKinematics_LowOrderPairObject)))
{
- Handle(XCAFKinematics_LowOrderPairObject) aLowOrderPairObj = Handle(XCAFKinematics_LowOrderPairObject)::DownCast(aKinPairObj);
+ Handle(XCAFKinematics_LowOrderPairObject) aLowOrderPairObj = Handle(XCAFKinematics_LowOrderPairObject)::DownCast(theKinPairObj);
Standard_Boolean aTX = Standard_True;
Standard_Boolean aTY = Standard_True;
Standard_Boolean aTZ = Standard_True;
Standard_Boolean aRX = Standard_True;
Standard_Boolean aRY = Standard_True;
Standard_Boolean aRZ = Standard_True;
- switch (aKinPairObj->Type())
+ switch (theKinPairObj->Type())
{
case(XCAFKinematics_PairType_Revolute):
{
aTZ = Standard_False;
aRX = Standard_False;
aRY = Standard_False;
- if (HasRange)
+ if (aHasRange)
{
- aKinematicPair = new StepKinematics_RevolutePairWithRange;
+ theKinematicPair = new StepKinematics_RevolutePairWithRange;
Standard_Real aLowerLimitActualRotation = aLowOrderPairObj->MinRotationZ();
Standard_Real aUpperLimitActualRotation = aLowOrderPairObj->MaxRotationZ();
aRZ = Standard_True;
- Handle(StepKinematics_RevolutePairWithRange) aRevolutePairWithRange = Handle(StepKinematics_RevolutePairWithRange)::DownCast(aKinematicPair);
+ Handle(StepKinematics_RevolutePairWithRange) aRevolutePairWithRange = Handle(StepKinematics_RevolutePairWithRange)::DownCast(theKinematicPair);
aRevolutePairWithRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ, Standard_True, aLowerLimitActualRotation, Standard_True, aUpperLimitActualRotation);
}
else
{
- aKinematicPair = new StepKinematics_RevolutePair;
- Handle(StepKinematics_RevolutePair) aRevolutePair = Handle(StepKinematics_RevolutePair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_RevolutePair;
+ Handle(StepKinematics_RevolutePair) aRevolutePair = Handle(StepKinematics_RevolutePair)::DownCast(theKinematicPair);
aRevolutePair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ);
aRX = Standard_False;
aRY = Standard_False;
aRZ = Standard_False;
- if (HasRange)
+ if (aHasRange)
{
- aKinematicPair = new StepKinematics_PrismaticPairWithRange;
- Handle(StepKinematics_PrismaticPairWithRange) aPrismaticPairWithRange = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_PrismaticPairWithRange;
+ Handle(StepKinematics_PrismaticPairWithRange) aPrismaticPairWithRange = Handle(StepKinematics_PrismaticPairWithRange)::DownCast(theKinematicPair);
Standard_Real aUpperLimitActualTranslation = aLowOrderPairObj->MaxTranslationX();
Standard_Real aLowerLimitActualTranslation = aLowOrderPairObj->MinTranslationX();
aPrismaticPairWithRange->Init(aPairName, aPairName, hasDescription,
}
else
{
- aKinematicPair = new StepKinematics_PrismaticPair;
- Handle(StepKinematics_PrismaticPair) aPrismaticPair = Handle(StepKinematics_PrismaticPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_PrismaticPair;
+ Handle(StepKinematics_PrismaticPair) aPrismaticPair = Handle(StepKinematics_PrismaticPair)::DownCast(theKinematicPair);
aPrismaticPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ);
aTY = Standard_False;
aRX = Standard_False;
aRY = Standard_False;
- if (HasRange)
+ if (aHasRange)
{
- aKinematicPair = new StepKinematics_CylindricalPairWithRange;
- Handle(StepKinematics_CylindricalPairWithRange) aCylindricalPairWithRange = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_CylindricalPairWithRange;
+ Handle(StepKinematics_CylindricalPairWithRange) aCylindricalPairWithRange = Handle(StepKinematics_CylindricalPairWithRange)::DownCast(theKinematicPair);
Standard_Real aUpperLimitActualTranslation = aLowOrderPairObj->MaxTranslationZ();
Standard_Real aLowerLimitActualTranslation = aLowOrderPairObj->MinTranslationZ();
Standard_Real aLowerLimitActualRotation = aLowOrderPairObj->MinRotationZ();
}
else
{
- aKinematicPair = new StepKinematics_CylindricalPair;
- Handle(StepKinematics_CylindricalPair) aCylindricalPair = Handle(StepKinematics_CylindricalPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_CylindricalPair;
+ Handle(StepKinematics_CylindricalPair) aCylindricalPair = Handle(StepKinematics_CylindricalPair)::DownCast(theKinematicPair);
aCylindricalPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ);
aTZ = Standard_False;
aRY = Standard_False;
Standard_Real theUniversalPair_InputSkewAngle = aLowOrderPairObj->SkewAngle();
- if (HasRange)
+ if (aHasRange)
{
- aKinematicPair = new StepKinematics_UniversalPairWithRange;
- Handle(StepKinematics_UniversalPairWithRange) anUniversalPairWithRange = Handle(StepKinematics_UniversalPairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_UniversalPairWithRange;
+ Handle(StepKinematics_UniversalPairWithRange) anUniversalPairWithRange = Handle(StepKinematics_UniversalPairWithRange)::DownCast(theKinematicPair);
Standard_Real aUpperLimitActualRotationX = aLowOrderPairObj->MaxRotationX();
Standard_Real aLowerLimitActualRotationX = aLowOrderPairObj->MinRotationX();
Standard_Real aUpperLimitActualRotationZ = aLowOrderPairObj->MaxRotationZ();
}
else
{
- aKinematicPair = new StepKinematics_UniversalPair;
- Handle(StepKinematics_UniversalPair) anUniversalPair = Handle(StepKinematics_UniversalPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_UniversalPair;
+ Handle(StepKinematics_UniversalPair) anUniversalPair = Handle(StepKinematics_UniversalPair)::DownCast(theKinematicPair);
anUniversalPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ, Standard_True, theUniversalPair_InputSkewAngle);
aTZ = Standard_False;
aRX = Standard_False;
aRY = Standard_False;
- if (HasRange)
+ if (aHasRange)
{
Standard_Real aUpperLimitYaw = aLowOrderPairObj->MaxRotationZ();
Standard_Real aLowerLimitYaw = aLowOrderPairObj->MinRotationZ();
Standard_Real aUpperLimitRoll = aLowOrderPairObj->MaxRotationX();
Standard_Real aLowerLimitRoll = aLowOrderPairObj->MinRotationX();
- aKinematicPair = new StepKinematics_SphericalPairWithPinAndRange;
- Handle(StepKinematics_SphericalPairWithPinAndRange) aSphericalPairWithPinAndRange = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_SphericalPairWithPinAndRange;
+ Handle(StepKinematics_SphericalPairWithPinAndRange) aSphericalPairWithPinAndRange = Handle(StepKinematics_SphericalPairWithPinAndRange)::DownCast(theKinematicPair);
aSphericalPairWithPinAndRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ, Standard_True, aLowerLimitYaw, Standard_True,
}
else
{
- aKinematicPair = new StepKinematics_SphericalPairWithPin;
- Handle(StepKinematics_SphericalPairWithPin) aSphericalPairWithPin = Handle(StepKinematics_SphericalPairWithPin)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_SphericalPairWithPin;
+ Handle(StepKinematics_SphericalPairWithPin) aSphericalPairWithPin = Handle(StepKinematics_SphericalPairWithPin)::DownCast(theKinematicPair);
aSphericalPairWithPin->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ);
aTX = Standard_False;
aTY = Standard_False;
aTZ = Standard_False;
- if (HasRange)
+ if (aHasRange)
{
Standard_Real aUpperLimitYaw = aLowOrderPairObj->MaxRotationZ();
Standard_Real aLowerLimitYaw = aLowOrderPairObj->MinRotationZ();
Standard_Real aLowerLimitRoll = aLowOrderPairObj->MinRotationX();
Standard_Real aUpperLimitPitch = aLowOrderPairObj->MaxRotationY();
Standard_Real aLowerLimitPitch= aLowOrderPairObj->MinRotationY();
- aKinematicPair = new StepKinematics_SphericalPairWithRange;
- Handle(StepKinematics_SphericalPairWithRange) aSphericalPairWithRange = Handle(StepKinematics_SphericalPairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_SphericalPairWithRange;
+ Handle(StepKinematics_SphericalPairWithRange) aSphericalPairWithRange = Handle(StepKinematics_SphericalPairWithRange)::DownCast(theKinematicPair);
aSphericalPairWithRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ, Standard_True, aLowerLimitYaw, Standard_True,
}
else
{
- aKinematicPair = new StepKinematics_SphericalPair;
- Handle(StepKinematics_SphericalPair) aSphericalPair = Handle(StepKinematics_SphericalPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_SphericalPair;
+ Handle(StepKinematics_SphericalPair) aSphericalPair = Handle(StepKinematics_SphericalPair)::DownCast(theKinematicPair);
aSphericalPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ);
}
case(XCAFKinematics_PairType_Planar):
{
- if (HasRange)
- aKinematicPair = new StepKinematics_PlanarPairWithRange;
+ if (aHasRange)
+ theKinematicPair = new StepKinematics_PlanarPairWithRange;
else
- aKinematicPair = new StepKinematics_PlanarPair;
+ theKinematicPair = new StepKinematics_PlanarPair;
aTZ = Standard_False;
aRX = Standard_False;
aRY = Standard_False;
- if (HasRange)
+ if (aHasRange)
{
- aKinematicPair = new StepKinematics_PlanarPairWithRange;
- Handle(StepKinematics_PlanarPairWithRange) aPlanarPairWithRange = Handle(StepKinematics_PlanarPairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_PlanarPairWithRange;
+ Handle(StepKinematics_PlanarPairWithRange) aPlanarPairWithRange = Handle(StepKinematics_PlanarPairWithRange)::DownCast(theKinematicPair);
Standard_Real aUpperLimitActualTranslationX = aLowOrderPairObj->MaxTranslationX();
Standard_Real aLowerLimitActualTranslationX = aLowOrderPairObj->MinTranslationX();
Standard_Real aUpperLimitActualTranslationY = aLowOrderPairObj->MaxTranslationY();
}
else
{
- aKinematicPair = new StepKinematics_PlanarPair;
- Handle(StepKinematics_PlanarPair) aPlanarPair = Handle(StepKinematics_PlanarPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_PlanarPair;
+ Handle(StepKinematics_PlanarPair) aPlanarPair = Handle(StepKinematics_PlanarPair)::DownCast(theKinematicPair);
aPlanarPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ);
}
case(XCAFKinematics_PairType_Unconstrained):
{
- aKinematicPair = new StepKinematics_LowOrderKinematicPairWithRange;
+ theKinematicPair = new StepKinematics_LowOrderKinematicPairWithRange;
Standard_Real aUpperLimitActualTranslationX = aLowOrderPairObj->MaxTranslationX();
Standard_Real aLowerLimitActualTranslationX = aLowOrderPairObj->MinTranslationX();
Standard_Real aUpperLimitActualRotationY = aLowOrderPairObj->MaxRotationY();
Standard_Real aLowerLimitActualRotationZ = aLowOrderPairObj->MinRotationZ();
Standard_Real aUpperLimitActualRotationZ = aLowOrderPairObj->MaxRotationZ();
- Handle(StepKinematics_LowOrderKinematicPairWithRange) anUnconstrainedPairWithRange = Handle(StepKinematics_LowOrderKinematicPairWithRange)::DownCast(aKinematicPair);
+ Handle(StepKinematics_LowOrderKinematicPairWithRange) anUnconstrainedPairWithRange = Handle(StepKinematics_LowOrderKinematicPairWithRange)::DownCast(theKinematicPair);
anUnconstrainedPairWithRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ, Standard_True, aLowerLimitActualRotationX, Standard_True, aUpperLimitActualRotationX,
}
case(XCAFKinematics_PairType_FullyConstrained):
{
- aKinematicPair = new StepKinematics_FullyConstrainedPair;
- Handle(StepKinematics_FullyConstrainedPair) aFullyConstrainedPair = Handle(StepKinematics_FullyConstrainedPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_FullyConstrainedPair;
+ Handle(StepKinematics_FullyConstrainedPair) aFullyConstrainedPair = Handle(StepKinematics_FullyConstrainedPair)::DownCast(theKinematicPair);
aFullyConstrainedPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ);
aTZ = Standard_False;
aRY = Standard_False;
Standard_Real InputSkewAngle = aLowOrderPairObj->SkewAngle();
- aKinematicPair = new StepKinematics_HomokineticPair;
- Handle(StepKinematics_HomokineticPair) aHomokineticPair = Handle(StepKinematics_HomokineticPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_HomokineticPair;
+ Handle(StepKinematics_HomokineticPair) aHomokineticPair = Handle(StepKinematics_HomokineticPair)::DownCast(theKinematicPair);
aHomokineticPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,
aTX, aTY, aTZ, aRX, aRY, aRZ, Standard_True, InputSkewAngle);
}
return Standard_True;
}
- else if (aKinPairObj->IsKind(STANDARD_TYPE(XCAFKinematics_LowOrderPairObjectWithCoupling)))
+ else if (theKinPairObj->IsKind(STANDARD_TYPE(XCAFKinematics_LowOrderPairObjectWithCoupling)))
{
- Handle(XCAFKinematics_LowOrderPairObjectWithCoupling) aLowOrderPairObjectWithCoupling = Handle(XCAFKinematics_LowOrderPairObjectWithCoupling)::DownCast(aKinPairObj);
- switch (aKinPairObj->Type())
+ Handle(XCAFKinematics_LowOrderPairObjectWithCoupling) aLowOrderPairObjectWithCoupling = Handle(XCAFKinematics_LowOrderPairObjectWithCoupling)::DownCast(theKinPairObj);
+ switch (theKinPairObj->Type())
{
case(XCAFKinematics_PairType_Screw):
{
Standard_Real aPitch = aLowOrderPairObjectWithCoupling->Pitch();
- if (HasRange)
+ if (aHasRange)
{
- aKinematicPair = new StepKinematics_ScrewPairWithRange;
- Handle(StepKinematics_ScrewPairWithRange) aScrewPairWithRange = Handle(StepKinematics_ScrewPairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_ScrewPairWithRange;
+ Handle(StepKinematics_ScrewPairWithRange) aScrewPairWithRange = Handle(StepKinematics_ScrewPairWithRange)::DownCast(theKinematicPair);
Standard_Real aLowLimit = aLowOrderPairObjectWithCoupling->LowLimit();
Standard_Real aUpperLimit = aLowOrderPairObjectWithCoupling->UpperLimit();
aScrewPairWithRange->Init(aPairName, aPairName, hasDescription,
}
else
{
- aKinematicPair = new StepKinematics_ScrewPair;
- Handle(StepKinematics_ScrewPair) aScrewPair = Handle(StepKinematics_ScrewPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_ScrewPair;
+ Handle(StepKinematics_ScrewPair) aScrewPair = Handle(StepKinematics_ScrewPair)::DownCast(theKinematicPair);
aScrewPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,aPitch);
}
case(XCAFKinematics_PairType_RackAndPinion):
{
Standard_Real aPinionRadius = aLowOrderPairObjectWithCoupling->PinionRadius();
- if (HasRange)
+ if (aHasRange)
{
- aKinematicPair = new StepKinematics_RackAndPinionPairWithRange;
+ theKinematicPair = new StepKinematics_RackAndPinionPairWithRange;
Standard_Real aLowLimit = aLowOrderPairObjectWithCoupling->LowLimit();
Standard_Real aUpperLimit = aLowOrderPairObjectWithCoupling->UpperLimit();
- Handle(StepKinematics_RackAndPinionPairWithRange) aRackAndPinionPairWithRange = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(aKinematicPair);
+ Handle(StepKinematics_RackAndPinionPairWithRange) aRackAndPinionPairWithRange = Handle(StepKinematics_RackAndPinionPairWithRange)::DownCast(theKinematicPair);
aRackAndPinionPairWithRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPinionRadius,
Standard_True, aLowLimit, Standard_True, aUpperLimit);
}
else
{
- aKinematicPair = new StepKinematics_RackAndPinionPair;
- Handle(StepKinematics_RackAndPinionPair) aRackAndPinionPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_RackAndPinionPair;
+ Handle(StepKinematics_RackAndPinionPair) aRackAndPinionPair = Handle(StepKinematics_RackAndPinionPair)::DownCast(theKinematicPair);
aRackAndPinionPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPinionRadius);
}
Standard_Real aHelicalAngle = aLowOrderPairObjectWithCoupling->HelicalAngle();
Standard_Real aRadiusFirstLink = aLowOrderPairObjectWithCoupling->RadiusFirstLink();;
Standard_Real aRadiusSecondLink = aLowOrderPairObjectWithCoupling->RadiusSecondLink();;
- if (HasRange)
+ if (aHasRange)
{
Standard_Real aLowLimit = aLowOrderPairObjectWithCoupling->LowLimit();
Standard_Real aUpperLimit = aLowOrderPairObjectWithCoupling->UpperLimit();
- aKinematicPair = new StepKinematics_GearPairWithRange;
- Handle(StepKinematics_GearPairWithRange) aGearPairWithRange = Handle(StepKinematics_GearPairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_GearPairWithRange;
+ Handle(StepKinematics_GearPairWithRange) aGearPairWithRange = Handle(StepKinematics_GearPairWithRange)::DownCast(theKinematicPair);
aGearPairWithRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aRadiusFirstLink, aRadiusSecondLink, aBevel, aHelicalAngle, aGearRatio,
Standard_True, aLowLimit, Standard_True, aUpperLimit);
}
else
{
- aKinematicPair = new StepKinematics_GearPair;
- Handle(StepKinematics_GearPair) aGearPair = Handle(StepKinematics_GearPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_GearPair;
+ Handle(StepKinematics_GearPair) aGearPair = Handle(StepKinematics_GearPair)::DownCast(theKinematicPair);
aGearPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,aRadiusFirstLink,aRadiusSecondLink,aBevel,aHelicalAngle, aGearRatio);
}
case(XCAFKinematics_PairType_LinearFlexibleAndPinion):
{
Standard_Real aPinionRadius = aLowOrderPairObjectWithCoupling->PinionRadius();
- aKinematicPair = new StepKinematics_LinearFlexibleAndPinionPair;
- Handle(StepKinematics_LinearFlexibleAndPinionPair) aLinearFlexibleAndPinionPair = Handle(StepKinematics_LinearFlexibleAndPinionPair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_LinearFlexibleAndPinionPair;
+ Handle(StepKinematics_LinearFlexibleAndPinionPair) aLinearFlexibleAndPinionPair = Handle(StepKinematics_LinearFlexibleAndPinionPair)::DownCast(theKinematicPair);
aLinearFlexibleAndPinionPair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPinionRadius);
break;
}
return Standard_True;
}
- else if (aKinPairObj->IsKind(STANDARD_TYPE(XCAFKinematics_HighOrderPairObject))) //need to fix
+ else if (theKinPairObj->IsKind(STANDARD_TYPE(XCAFKinematics_HighOrderPairObject))) //need to fix
{
- Handle(XCAFKinematics_HighOrderPairObject) aHighOrderPairObject = Handle(XCAFKinematics_HighOrderPairObject)::DownCast(aKinPairObj);
- switch (aKinPairObj->Type())
+ Handle(XCAFKinematics_HighOrderPairObject) aHighOrderPairObject = Handle(XCAFKinematics_HighOrderPairObject)::DownCast(theKinPairObj);
+ switch (theKinPairObj->Type())
{
case(XCAFKinematics_PairType_PointOnSurface):
{
- if (HasRange)
+ if (aHasRange)
{
GeomToStep_MakeSurface aMaker(aHighOrderPairObject->Surface());
Handle(StepGeom_Surface) aPairSurface = aMaker.Value();
Standard_Real aUpperLimitRoll = aHighOrderPairObject->UpperLimitRoll();
GeomToStep_MakeRectangularTrimmedSurface aMakerTrimmered(aHighOrderPairObject->TrimmedSurface());
Handle(StepGeom_RectangularTrimmedSurface) aRangeOnPairSurface = aMakerTrimmered.Value();
- aKinematicPair = new StepKinematics_PointOnSurfacePairWithRange;
- Handle(StepKinematics_PointOnSurfacePairWithRange) aPointOnSurfacePairWithRange = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_PointOnSurfacePairWithRange;
+ Handle(StepKinematics_PointOnSurfacePairWithRange) aPointOnSurfacePairWithRange = Handle(StepKinematics_PointOnSurfacePairWithRange)::DownCast(theKinematicPair);
aPointOnSurfacePairWithRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairSurface,aRangeOnPairSurface, Standard_True, aLowerLimitYaw, Standard_True, aUpperLimitYaw, Standard_True,
aLowerLimitPitch, Standard_True, aUpperLimitPitch, Standard_True, aLowerLimitRoll, Standard_True, aUpperLimitRoll);
}
else
{
- aKinematicPair = new StepKinematics_PointOnSurfacePair;
+ theKinematicPair = new StepKinematics_PointOnSurfacePair;
GeomToStep_MakeSurface aMaker(aHighOrderPairObject->Surface());
Handle(StepGeom_Surface) aPairSurface = aMaker.Value();
- Handle(StepKinematics_PointOnSurfacePair) aPointOnSurface = Handle(StepKinematics_PointOnSurfacePair)::DownCast(aKinematicPair);
+ Handle(StepKinematics_PointOnSurfacePair) aPointOnSurface = Handle(StepKinematics_PointOnSurfacePair)::DownCast(theKinematicPair);
aPointOnSurface->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint,aPairSurface);
}
}
case(XCAFKinematics_PairType_SlidingSurface):
{
- aKinematicPair = new StepKinematics_SlidingSurfacePair;
+ theKinematicPair = new StepKinematics_SlidingSurfacePair;
GeomToStep_MakeSurface aMaker(aHighOrderPairObject->FirstSurface());
Handle(StepGeom_Surface) aPairSurfac1 = aMaker.Value();
GeomToStep_MakeSurface aMaker2(aHighOrderPairObject->SecondSurface());
Handle(StepGeom_Surface) aPairSurface2 = aMaker2.Value();
Standard_Boolean anOrientation = aHighOrderPairObject->Orientation();
- Handle(StepKinematics_SlidingSurfacePair) aSlidingSurfacePair = Handle(StepKinematics_SlidingSurfacePair)::DownCast(aKinematicPair);
+ Handle(StepKinematics_SlidingSurfacePair) aSlidingSurfacePair = Handle(StepKinematics_SlidingSurfacePair)::DownCast(theKinematicPair);
aSlidingSurfacePair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairSurfac1, aPairSurface2, anOrientation);
break;
}
case(XCAFKinematics_PairType_RollingSurface):
{
- aKinematicPair = new StepKinematics_RollingSurfacePair;
+ theKinematicPair = new StepKinematics_RollingSurfacePair;
GeomToStep_MakeSurface aMaker(aHighOrderPairObject->FirstSurface());
Handle(StepGeom_Surface) aPairSurfac1 = aMaker.Value();
GeomToStep_MakeSurface aMaker2(aHighOrderPairObject->SecondSurface());
Handle(StepGeom_Surface) aPairSurface2 = aMaker2.Value();
Standard_Boolean anOrientation = aHighOrderPairObject->Orientation();
- Handle(StepKinematics_RollingSurfacePair) aRollingSurfacePair = Handle(StepKinematics_RollingSurfacePair)::DownCast(aKinematicPair);
+ Handle(StepKinematics_RollingSurfacePair) aRollingSurfacePair = Handle(StepKinematics_RollingSurfacePair)::DownCast(theKinematicPair);
aRollingSurfacePair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairSurfac1, aPairSurface2, anOrientation);
break;
GeomToStep_MakeCurve aMaker(aHighOrderPairObject->Curve());
Handle(StepGeom_Curve) aPairCurve = aMaker.Value();
Standard_Boolean anOrientation = aHighOrderPairObject->Orientation();
- if (HasRange)
+ if (aHasRange)
{
Standard_Real aLowerLimitYaw = aHighOrderPairObject->LowLimitYaw();
Standard_Real aUpperLimitYaw = aHighOrderPairObject->UpperLimitYaw();
Standard_Real aLowerLimitRoll = aHighOrderPairObject->LowLimitRoll();
Standard_Real aUpperLimitRoll = aHighOrderPairObject->UpperLimitRoll();
Handle(Geom_TrimmedCurve) aRangeOnCurve = aHighOrderPairObject->TrimmedCurve();
- Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve = MakeTrimmedCurve(aPairCurve, aHighOrderPairObject->TrimmedCurve(), Standard_True);
- aKinematicPair = new StepKinematics_PointOnPlanarCurvePairWithRange;
- Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aPointOnPlanarCurvePairWithRange = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(aKinematicPair);
+ Handle(StepGeom_HArray1OfTrimmingSelect) aSTS1 =
+ new StepGeom_HArray1OfTrimmingSelect(1, 2);
+ StepGeom_TrimmingSelect tSel;
+ GeomToStep_MakeCartesianPoint aMP1(aRangeOnCurve->StartPoint());
+ tSel.SetValue(aMP1.Value());
+ aSTS1->SetValue(1, tSel);
+ tSel.SetParameterValue(aRangeOnCurve->FirstParameter());
+ aSTS1->SetValue(2, tSel);
+
+ Handle(StepGeom_HArray1OfTrimmingSelect) aSTS2 =
+ new StepGeom_HArray1OfTrimmingSelect(1, 2);
+ GeomToStep_MakeCartesianPoint aMP2(aRangeOnCurve->EndPoint());
+ tSel.SetValue(aMP2.Value());
+ aSTS2->SetValue(1, tSel);
+ tSel.SetParameterValue(aRangeOnCurve->LastParameter());
+ aSTS2->SetValue(2, tSel);
+
+ Handle(TCollection_HAsciiString) empty =
+ new TCollection_HAsciiString("");
+ Handle(StepGeom_TrimmedCurve) aRangeOnPairCurve = new StepGeom_TrimmedCurve;
+ aRangeOnPairCurve->Init(empty, aPairCurve, aSTS1, aSTS2, Standard_True, StepGeom_tpParameter);
+ theKinematicPair = new StepKinematics_PointOnPlanarCurvePairWithRange;
+ Handle(StepKinematics_PointOnPlanarCurvePairWithRange) aPointOnPlanarCurvePairWithRange = Handle(StepKinematics_PointOnPlanarCurvePairWithRange)::DownCast(theKinematicPair);
aPointOnPlanarCurvePairWithRange->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairCurve, anOrientation, aRangeOnPairCurve,Standard_True,aLowerLimitYaw, Standard_True,aUpperLimitYaw, Standard_True,
aLowerLimitPitch, Standard_True, aUpperLimitPitch, Standard_True,aLowerLimitRoll, Standard_True, aUpperLimitRoll);
}
else
{
- aKinematicPair = new StepKinematics_PointOnPlanarCurvePair;
- Handle(StepKinematics_PointOnPlanarCurvePair) aPointOnPlanarCurvePair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_PointOnPlanarCurvePair;
+ Handle(StepKinematics_PointOnPlanarCurvePair) aPointOnPlanarCurvePair = Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(theKinematicPair);
aPointOnPlanarCurvePair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairCurve, anOrientation);
}
Standard_Boolean anOrientation = aHighOrderPairObject->Orientation();
GeomToStep_MakeCurve aMaker2(aHighOrderPairObject->SecondCurve());
Handle(StepGeom_Curve) aPairCurve2 = aMaker2.Value();
- aKinematicPair = new StepKinematics_SlidingCurvePair;
- Handle(StepKinematics_SlidingCurvePair) aSlidingCurvePair = Handle(StepKinematics_SlidingCurvePair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_SlidingCurvePair;
+ Handle(StepKinematics_SlidingCurvePair) aSlidingCurvePair = Handle(StepKinematics_SlidingCurvePair)::DownCast(theKinematicPair);
aSlidingCurvePair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairCurve, aPairCurve2, anOrientation);
break;
Standard_Boolean anOrientation = aHighOrderPairObject->Orientation();
GeomToStep_MakeCurve aMaker2(aHighOrderPairObject->SecondCurve());
Handle(StepGeom_Curve) aPairCurve2 = aMaker2.Value();
- aKinematicPair = new StepKinematics_RollingCurvePair;
- Handle(StepKinematics_RollingCurvePair) aRollingCurvePair = Handle(StepKinematics_RollingCurvePair)::DownCast(aKinematicPair);
+ theKinematicPair = new StepKinematics_RollingCurvePair;
+ Handle(StepKinematics_RollingCurvePair) aRollingCurvePair = Handle(StepKinematics_RollingCurvePair)::DownCast(theKinematicPair);
aRollingCurvePair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairCurve, aPairCurve2, anOrientation);
break;
}
case(XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve):
{
- aKinematicPair = new StepKinematics_LinearFlexibleAndPlanarCurvePair;
+ theKinematicPair = new StepKinematics_LinearFlexibleAndPlanarCurvePair;
GeomToStep_MakeCurve aMaker(aHighOrderPairObject->Curve());
Handle(StepGeom_Curve) aPairCurve = aMaker.Value();
Standard_Boolean anOrientation = aHighOrderPairObject->Orientation();
- Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair) aLinearFlexibleAndPlanarCurvePair = Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)::DownCast(aKinematicPair);
+ Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair) aLinearFlexibleAndPlanarCurvePair = Handle(StepKinematics_LinearFlexibleAndPlanarCurvePair)::DownCast(theKinematicPair);
aLinearFlexibleAndPlanarCurvePair->Init(aPairName, aPairName, hasDescription,
aDescription, theTransformItem1, theTransformItem2, theJoint, aPairCurve, anOrientation);
break;
return Standard_False;
}
-static Standard_Boolean createKinematicPairValue(const Handle(XCAFKinematics_PairValueObject)& aKinPairValueObj,
- Handle(StepKinematics_PairValue)& aPairValue,
- const Handle(StepKinematics_PairRepresentationRelationship)& aPairReprRelationship)
+static Standard_Boolean createKinematicPairValue(const Handle(XCAFKinematics_PairValueObject)& theKinPairValueObj,
+ const Handle(StepKinematics_PairRepresentationRelationship)& thePairReprRelationship,
+ Handle(StepKinematics_PairValue)& thePairValue)
{
- if (aKinPairValueObj->Type() == XCAFKinematics_PairType_NoType)
+ if (theKinPairValueObj->Type() == XCAFKinematics_PairType_NoType)
return Standard_False;
-
- switch (aKinPairValueObj->Type())
+ switch (theKinPairValueObj->Type())
{
case(XCAFKinematics_PairType_Revolute):
{
- aPairValue = new StepKinematics_RevolutePairValue;
+ thePairValue = new StepKinematics_RevolutePairValue;
Handle(StepKinematics_RevolutePairValue) aRevolutePairValue =
- Handle(StepKinematics_RevolutePairValue)::DownCast(aPairValue);
- aRevolutePairValue->SetActualRotation(aKinPairValueObj->GetRotation());
+ Handle(StepKinematics_RevolutePairValue)::DownCast(thePairValue);
+ aRevolutePairValue->SetActualRotation(theKinPairValueObj->GetRotation());
break;
}
case(XCAFKinematics_PairType_Prismatic):
{
- aPairValue = new StepKinematics_PrismaticPairValue;
+ thePairValue = new StepKinematics_PrismaticPairValue;
Handle(StepKinematics_PrismaticPairValue) aPrismaticPairValue =
- Handle(StepKinematics_PrismaticPairValue)::DownCast(aPairValue);
- aPrismaticPairValue->SetActualTranslation(aKinPairValueObj->GetTranslation());
+ Handle(StepKinematics_PrismaticPairValue)::DownCast(thePairValue);
+ aPrismaticPairValue->SetActualTranslation(theKinPairValueObj->GetTranslation());
break;
}
case(XCAFKinematics_PairType_Cylindrical):
{
- aPairValue = new StepKinematics_CylindricalPairValue;
+ thePairValue = new StepKinematics_CylindricalPairValue;
Handle(StepKinematics_CylindricalPairValue) aCylindricalPairValue =
- Handle(StepKinematics_CylindricalPairValue)::DownCast(aPairValue);
- aCylindricalPairValue->SetActualTranslation(aKinPairValueObj->GetTranslation());
- aCylindricalPairValue->SetActualRotation(aKinPairValueObj->GetRotation());
+ Handle(StepKinematics_CylindricalPairValue)::DownCast(thePairValue);
+ aCylindricalPairValue->SetActualTranslation(theKinPairValueObj->GetTranslation());
+ aCylindricalPairValue->SetActualRotation(theKinPairValueObj->GetRotation());
break;
}
case(XCAFKinematics_PairType_Universal):
{
- aPairValue = new StepKinematics_UniversalPairValue;
+ thePairValue = new StepKinematics_UniversalPairValue;
Handle(StepKinematics_UniversalPairValue) aUniversalPairValue =
- Handle(StepKinematics_UniversalPairValue)::DownCast(aPairValue);
- aUniversalPairValue->SetFirstRotationAngle(aKinPairValueObj->GetFirstRotation());
- aUniversalPairValue->SetSecondRotationAngle(aKinPairValueObj->GetSecondRotation());
+ Handle(StepKinematics_UniversalPairValue)::DownCast(thePairValue);
+ aUniversalPairValue->SetFirstRotationAngle(theKinPairValueObj->GetFirstRotation());
+ aUniversalPairValue->SetSecondRotationAngle(theKinPairValueObj->GetSecondRotation());
break;
}
case(XCAFKinematics_PairType_Homokinetic):
{
- aPairValue = new StepKinematics_UniversalPairValue;
+ thePairValue = new StepKinematics_UniversalPairValue;
Handle(StepKinematics_UniversalPairValue) aUniversalPairValue =
- Handle(StepKinematics_UniversalPairValue)::DownCast(aPairValue);
- aUniversalPairValue->SetFirstRotationAngle(aKinPairValueObj->GetFirstRotation());
- aUniversalPairValue->SetSecondRotationAngle(aKinPairValueObj->GetSecondRotation());
+ Handle(StepKinematics_UniversalPairValue)::DownCast(thePairValue);
+ aUniversalPairValue->SetFirstRotationAngle(theKinPairValueObj->GetFirstRotation());
+ aUniversalPairValue->SetSecondRotationAngle(theKinPairValueObj->GetSecondRotation());
break;
}
case(XCAFKinematics_PairType_Spherical):
{
- aPairValue = new StepKinematics_SphericalPairValue;
+ thePairValue = new StepKinematics_SphericalPairValue;
Handle(StepKinematics_SphericalPairValue) aSphericalPairValue =
- Handle(StepKinematics_SphericalPairValue)::DownCast(aPairValue);
+ Handle(StepKinematics_SphericalPairValue)::DownCast(thePairValue);
StepKinematics_SpatialRotation InputRotation;
- InputRotation.SetValue(aKinPairValueObj->GetAllValues());
+ InputRotation.SetValue(theKinPairValueObj->GetAllValues());
aSphericalPairValue->SetInputOrientation(InputRotation);
break;
}
case(XCAFKinematics_PairType_SphericalWithPin):
{
- aPairValue = new StepKinematics_SphericalPairValue;
+ thePairValue = new StepKinematics_SphericalPairValue;
Handle(StepKinematics_SphericalPairValue) aSphericalPairValue =
- Handle(StepKinematics_SphericalPairValue)::DownCast(aPairValue);
+ Handle(StepKinematics_SphericalPairValue)::DownCast(thePairValue);
StepKinematics_SpatialRotation InputRotation;
- InputRotation.SetValue(aKinPairValueObj->GetAllValues());
+ InputRotation.SetValue(theKinPairValueObj->GetAllValues());
aSphericalPairValue->SetInputOrientation(InputRotation);
break;
}
case(XCAFKinematics_PairType_Planar):
{
- aPairValue = new StepKinematics_PlanarPairValue;
+ thePairValue = new StepKinematics_PlanarPairValue;
Handle(StepKinematics_PlanarPairValue) aPlanarPairValue =
- Handle(StepKinematics_PlanarPairValue)::DownCast(aPairValue);
- aPlanarPairValue->SetActualRotation(aKinPairValueObj->GetRotation());
- aPlanarPairValue->SetActualTranslationX(aKinPairValueObj->GetFirstTranslation());
- aPlanarPairValue->SetActualTranslationY(aKinPairValueObj->GetSecondTranslation());
+ Handle(StepKinematics_PlanarPairValue)::DownCast(thePairValue);
+ aPlanarPairValue->SetActualRotation(theKinPairValueObj->GetRotation());
+ aPlanarPairValue->SetActualTranslationX(theKinPairValueObj->GetFirstTranslation());
+ aPlanarPairValue->SetActualTranslationY(theKinPairValueObj->GetSecondTranslation());
break;
}
case(XCAFKinematics_PairType_Unconstrained):
{
- aPairValue = new StepKinematics_UnconstrainedPairValue;
+ thePairValue = new StepKinematics_UnconstrainedPairValue;
Handle(StepKinematics_UnconstrainedPairValue) anUnconstrainedPairValue =
- Handle(StepKinematics_UnconstrainedPairValue)::DownCast(aPairValue);
- GeomToStep_MakeAxis2Placement3d anActualPlacement(aKinPairValueObj->GetTransformation());
+ Handle(StepKinematics_UnconstrainedPairValue)::DownCast(thePairValue);
+ GeomToStep_MakeAxis2Placement3d anActualPlacement(theKinPairValueObj->GetTransformation());
anUnconstrainedPairValue->SetActualPlacement(anActualPlacement.Value());
break;
}
case(XCAFKinematics_PairType_Screw):
{
- aPairValue = new StepKinematics_ScrewPairValue;
+ thePairValue = new StepKinematics_ScrewPairValue;
Handle(StepKinematics_ScrewPairValue) aScrewPairValue =
- Handle(StepKinematics_ScrewPairValue)::DownCast(aPairValue);
- aScrewPairValue->SetActualRotation(aKinPairValueObj->GetRotation());
+ Handle(StepKinematics_ScrewPairValue)::DownCast(thePairValue);
+ aScrewPairValue->SetActualRotation(theKinPairValueObj->GetRotation());
break;
}
case(XCAFKinematics_PairType_RackAndPinion):
{
- aPairValue = new StepKinematics_RackAndPinionPairValue;
+ thePairValue = new StepKinematics_RackAndPinionPairValue;
Handle(StepKinematics_RackAndPinionPairValue) aRackAndPinionPairValue =
- Handle(StepKinematics_RackAndPinionPairValue)::DownCast(aPairValue);
- aRackAndPinionPairValue->SetActualDisplacement(aKinPairValueObj->GetTranslation());
+ Handle(StepKinematics_RackAndPinionPairValue)::DownCast(thePairValue);
+ aRackAndPinionPairValue->SetActualDisplacement(theKinPairValueObj->GetTranslation());
break;
}
case(XCAFKinematics_PairType_Gear):
{
- aPairValue = new StepKinematics_GearPairValue;
+ thePairValue = new StepKinematics_GearPairValue;
Handle(StepKinematics_GearPairValue) aGearPairValue =
- Handle(StepKinematics_GearPairValue)::DownCast(aPairValue);
- aGearPairValue->SetActualRotation1(aKinPairValueObj->GetRotation());
+ Handle(StepKinematics_GearPairValue)::DownCast(thePairValue);
+ aGearPairValue->SetActualRotation1(theKinPairValueObj->GetRotation());
break;
}
case(XCAFKinematics_PairType_PointOnSurface):
{
- aPairValue = new StepKinematics_PointOnSurfacePairValue;
+ thePairValue = new StepKinematics_PointOnSurfacePairValue;
Handle(StepKinematics_PointOnSurfacePairValue) aPointOnSurfacePairValue =
- Handle(StepKinematics_PointOnSurfacePairValue)::DownCast(aPairValue);
+ Handle(StepKinematics_PointOnSurfacePairValue)::DownCast(thePairValue);
Handle(StepGeom_PointOnSurface) aActualPointOnSurface = new StepGeom_PointOnSurface;
Handle(StepKinematics_PointOnSurfacePair) aPointOnSurfacePair =
- Handle(StepKinematics_PointOnSurfacePair)::DownCast(aPairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
+ Handle(StepKinematics_PointOnSurfacePair)::DownCast(thePairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
Standard_Real theU;
Standard_Real theV;
- aKinPairValueObj->GetPointOnSurface(theU, theV);
+ theKinPairValueObj->GetPointOnSurface(theU, theV);
aActualPointOnSurface->Init(new TCollection_HAsciiString, aPointOnSurfacePair->PairSurface(), theU, theV);
aPointOnSurfacePairValue->SetActualPointOnSurface(aActualPointOnSurface);
StepKinematics_SpatialRotation aYRP;
Standard_Real aYaw;
Standard_Real aPitch;
Standard_Real aRoll;
- aKinPairValueObj->GetYPR(aYaw, aPitch, aRoll);
+ theKinPairValueObj->GetYPR(aYaw, aPitch, aRoll);
anArrayYRP->SetValue(1, aYaw);
anArrayYRP->SetValue(2, aPitch);
anArrayYRP->SetValue(3, aRoll);
}
case(XCAFKinematics_PairType_SlidingSurface):
{
- aPairValue = new StepKinematics_SlidingSurfacePairValue;
+ thePairValue = new StepKinematics_SlidingSurfacePairValue;
Handle(StepKinematics_SlidingSurfacePairValue) aSlidingSurfacePairValue =
- Handle(StepKinematics_SlidingSurfacePairValue)::DownCast(aPairValue);
+ Handle(StepKinematics_SlidingSurfacePairValue)::DownCast(thePairValue);
Handle(StepGeom_PointOnSurface) aActualPointOnSurface1 = new StepGeom_PointOnSurface;
Handle(StepKinematics_SlidingSurfacePair) SlidingSurfacePair =
- Handle(StepKinematics_SlidingSurfacePair)::DownCast(aPairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
+ Handle(StepKinematics_SlidingSurfacePair)::DownCast(thePairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
Standard_Real theU1;
Standard_Real theV1;
- aKinPairValueObj->GetFirstPointOnSurface(theU1, theV1);
+ theKinPairValueObj->GetFirstPointOnSurface(theU1, theV1);
aActualPointOnSurface1->Init(new TCollection_HAsciiString, SlidingSurfacePair->Surface1(), theU1, theV1);
aSlidingSurfacePairValue->SetActualPointOnSurface1(aActualPointOnSurface1);
Handle(StepGeom_PointOnSurface) aActualPointOnSurface2 = new StepGeom_PointOnSurface;
Standard_Real theU2;
Standard_Real theV2;
- aKinPairValueObj->GetSecondPointOnSurface(theU2, theV2);
+ theKinPairValueObj->GetSecondPointOnSurface(theU2, theV2);
aActualPointOnSurface2->Init(new TCollection_HAsciiString, SlidingSurfacePair->Surface2(), theU2, theV2);
aSlidingSurfacePairValue->SetActualPointOnSurface2(aActualPointOnSurface2);
- aSlidingSurfacePairValue->SetActualRotation(aKinPairValueObj->GetRotation());
+ aSlidingSurfacePairValue->SetActualRotation(theKinPairValueObj->GetRotation());
break;
}
case(XCAFKinematics_PairType_RollingSurface):
{
- aPairValue = new StepKinematics_RollingSurfacePairValue;
+ thePairValue = new StepKinematics_RollingSurfacePairValue;
Handle(StepKinematics_RollingSurfacePairValue) aRollingSurfacePairValue =
- Handle(StepKinematics_RollingSurfacePairValue)::DownCast(aPairValue);
- aRollingSurfacePairValue->SetActualRotation(aKinPairValueObj->GetRotation());
+ Handle(StepKinematics_RollingSurfacePairValue)::DownCast(thePairValue);
+ aRollingSurfacePairValue->SetActualRotation(theKinPairValueObj->GetRotation());
Handle(StepGeom_PointOnSurface) aActualPointOnSurface = new StepGeom_PointOnSurface;
Handle(StepKinematics_RollingSurfacePair) aRollingSurfacePair =
- Handle(StepKinematics_RollingSurfacePair)::DownCast(aPairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
+ Handle(StepKinematics_RollingSurfacePair)::DownCast(thePairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
Standard_Real theU;
Standard_Real theV;
- aKinPairValueObj->GetPointOnSurface(theU, theV);
+ theKinPairValueObj->GetPointOnSurface(theU, theV);
aActualPointOnSurface->Init(new TCollection_HAsciiString, aRollingSurfacePair->Surface1(), theU, theV);
aRollingSurfacePairValue->SetActualPointOnSurface(aActualPointOnSurface);
break;
}
case(XCAFKinematics_PairType_PointOnPlanarCurve):
{
- aPairValue = new StepKinematics_PointOnPlanarCurvePairValue;
+ thePairValue = new StepKinematics_PointOnPlanarCurvePairValue;
Handle(StepKinematics_PointOnPlanarCurvePairValue) aPointOnPlanarCurvePairValue =
- Handle(StepKinematics_PointOnPlanarCurvePairValue)::DownCast(aPairValue);
+ Handle(StepKinematics_PointOnPlanarCurvePairValue)::DownCast(thePairValue);
StepKinematics_SpatialRotation aYRP;
Handle(TColStd_HArray1OfReal) anArrayYRP = new TColStd_HArray1OfReal(1, 3);
Standard_Real aYaw;
Standard_Real aPitch;
Standard_Real aRoll;
- aKinPairValueObj->GetYPR(aYaw, aPitch, aRoll);
+ theKinPairValueObj->GetYPR(aYaw, aPitch, aRoll);
anArrayYRP->SetValue(1, aYaw);
anArrayYRP->SetValue(2, aPitch);
anArrayYRP->SetValue(3, aRoll);
aPointOnPlanarCurvePairValue->SetInputOrientation(aYRP);
Handle(StepGeom_PointOnCurve) anActualPointOnCurve = new StepGeom_PointOnCurve;
Handle(StepKinematics_PointOnPlanarCurvePair) aPointOnPlanarCurvePair =
- Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(aPairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
- Standard_Real aParametr = aKinPairValueObj->GetPointOnCurve();
+ Handle(StepKinematics_PointOnPlanarCurvePair)::DownCast(thePairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
+ Standard_Real aParametr = theKinPairValueObj->GetPointOnCurve();
anActualPointOnCurve->Init(aPointOnPlanarCurvePair->Name(), aPointOnPlanarCurvePair->PairCurve(), aParametr);
aPointOnPlanarCurvePairValue->SetActualPointOnCurve(anActualPointOnCurve);
break;
}
case(XCAFKinematics_PairType_SlidingCurve):
{
- aPairValue = new StepKinematics_SlidingCurvePairValue;
+ thePairValue = new StepKinematics_SlidingCurvePairValue;
Handle(StepKinematics_SlidingCurvePairValue) aSlidingCurvePairValue =
- Handle(StepKinematics_SlidingCurvePairValue)::DownCast(aPairValue);
+ Handle(StepKinematics_SlidingCurvePairValue)::DownCast(thePairValue);
Handle(StepGeom_PointOnCurve) anActualPointOnCurve1 = new StepGeom_PointOnCurve;
Handle(StepKinematics_SlidingCurvePair) aSlidingCurvePair =
- Handle(StepKinematics_SlidingCurvePair)::DownCast(aPairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
- Standard_Real aParametr1 = aKinPairValueObj->GetFirstPointOnCurve();
+ Handle(StepKinematics_SlidingCurvePair)::DownCast(thePairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
+ Standard_Real aParametr1 = theKinPairValueObj->GetFirstPointOnCurve();
anActualPointOnCurve1->Init(aSlidingCurvePair->Name(), aSlidingCurvePair->Curve1(), aParametr1);
aSlidingCurvePairValue->SetActualPointOnCurve1(anActualPointOnCurve1);
Handle(StepGeom_PointOnCurve) anActualPointOnCurve2 = new StepGeom_PointOnCurve;
- Standard_Real aParametr2 = aKinPairValueObj->GetSecondPointOnCurve();
+ Standard_Real aParametr2 = theKinPairValueObj->GetSecondPointOnCurve();
anActualPointOnCurve2->Init(aSlidingCurvePair->Name(), aSlidingCurvePair->Curve2(), aParametr2);
aSlidingCurvePairValue->SetActualPointOnCurve2(anActualPointOnCurve2);
break;
}
case(XCAFKinematics_PairType_RollingCurve):
{
- aPairValue = new StepKinematics_RollingCurvePairValue;
+ thePairValue = new StepKinematics_RollingCurvePairValue;
Handle(StepKinematics_RollingCurvePairValue) aRollingCurvePairValue =
- Handle(StepKinematics_RollingCurvePairValue)::DownCast(aPairValue);
+ Handle(StepKinematics_RollingCurvePairValue)::DownCast(thePairValue);
Handle(StepGeom_PointOnCurve) anActualPointOnCurve = new StepGeom_PointOnCurve;
Handle(StepKinematics_RollingCurvePair) aRollingCurvePair =
- Handle(StepKinematics_RollingCurvePair)::DownCast(aPairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
- Standard_Real aParametr = aKinPairValueObj->GetPointOnCurve();
+ Handle(StepKinematics_RollingCurvePair)::DownCast(thePairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
+ Standard_Real aParametr = theKinPairValueObj->GetPointOnCurve();
anActualPointOnCurve->Init(aRollingCurvePair->Name(), aRollingCurvePair->Curve1(), aParametr);
aRollingCurvePairValue->SetActualPointOnCurve1(anActualPointOnCurve);
break;
break;
}
Handle(StepKinematics_KinematicPair) aAppliesToPair =
- Handle(StepKinematics_KinematicPair)::DownCast(aPairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
- aPairValue->SetAppliesToPair(aAppliesToPair);
- aPairValue->SetName(aAppliesToPair->Name());
+ Handle(StepKinematics_KinematicPair)::DownCast(thePairReprRelationship->RepresentationRelationshipWithTransformation()->TransformationOperator().KinematicPair());
+ thePairValue->SetAppliesToPair(aAppliesToPair);
+ thePairValue->SetName(aAppliesToPair->Name());
return Standard_True;
}
-Standard_EXPORT Standard_Boolean STEPCAFControl_Writer::WriteKinematics(const Handle(XSControl_WorkSession)& WS, const TDF_LabelSequence& labels)
+//=======================================================================
+//function : WriteKinematics
+//purpose :
+//=======================================================================
+Standard_EXPORT Standard_Boolean STEPCAFControl_Writer::WriteKinematics(const Handle(XSControl_WorkSession)& theWS, const TDF_LabelSequence& theLabels)
{
- if (labels.Length() <= 0) return Standard_False;
+ if (theLabels.Length() <= 0) return Standard_False;
// get working data
- const Handle(Interface_InterfaceModel)& Model = WS->Model();
- const Handle(XSControl_TransferWriter)& TW = WS->TransferWriter();
+ const Handle(Interface_InterfaceModel)& Model = theWS->Model();
+ const Handle(XSControl_TransferWriter)& TW = theWS->TransferWriter();
const Handle(Transfer_FinderProcess)& FP = TW->FinderProcess();
- const Handle(Interface_HGraph) aHGraph = WS->HGraph();
+ const Handle(Interface_HGraph) aHGraph = theWS->HGraph();
if (aHGraph.IsNull())
return Standard_False;
Interface_Graph aGraph = aHGraph->Graph();
- Handle(XCAFDoc_KinematicTool) aKTool = XCAFDoc_DocumentTool::KinematicTool(labels(1));
+ Handle(XCAFDoc_KinematicTool) aKTool = XCAFDoc_DocumentTool::KinematicTool(theLabels(1));
if (aKTool.IsNull())
return Standard_False;
if (aMechanismsL.Length() <= 0) return Standard_False;
Standard_Integer aMechInd;
- for (aMechInd = 1; aMechInd <= aMechanismsL.Length(); aMechInd++)
+ for (Standard_Integer aMechInd = 1; aMechInd <= aMechanismsL.Length(); aMechInd++)
{
- //write Links
- Handle(StepKinematics_KinematicLinkRepresentation) aBaseLinksOfMech;
+ // write Links
+ Handle(StepKinematics_RigidLinkRepresentation) aBaseLinkOfMech;
Handle(StepRepr_PropertyDefinition) aGeneralDefinition;
- //containers storing Links and their labels located at a single index
TDF_LabelSequence aSeqOfLinskL = aKTool->GetLinks(aMechanismsL.Value(aMechInd));
if (aSeqOfLinskL.Length() <= 0)
- return Standard_False;
- Handle(TColStd_HArray1OfTransient) aArrayOfRigidLinks = new TColStd_HArray1OfTransient(1, aSeqOfLinskL.Length());
+ continue;
+ NCollection_DataMap<TDF_Label, Handle(StepKinematics_RigidLinkRepresentation), TDF_LabelMapHasher> aMapOfLinks;
for (Standard_Integer aLinkInd = 1; aLinkInd <= aSeqOfLinskL.Length(); aLinkInd++)
{
Handle(StepKinematics_KinematicLink) aLink;
Handle(StepShape_ShapeRepresentation) aRefShapeOfLink;
Handle(StepRepr_PropertyDefinition) aPD;
- if (!createKinematicLink(FP, aKTool, aLink, aGraph, aLinkL, aRefShapeOfLink, aPD))
+ if (!createKinematicLink(FP, aKTool, aGraph, aLinkL, aLink, aRefShapeOfLink, aPD))
continue;
Handle(StepRepr_RepresentationContext) aRepresentationContextOfLink = aRefShapeOfLink->ContextOfItems();
Handle(StepKinematics_RigidLinkRepresentation) aLinkRepresentation = new StepKinematics_RigidLinkRepresentation;
Handle(TCollection_HAsciiString) aNameOfLinkRepr = new TCollection_HAsciiString("");
Handle(StepRepr_HArray1OfRepresentationItem) aPlacementsOfPairs = new StepRepr_HArray1OfRepresentationItem;
aLinkRepresentation->Init(aNameOfLinkRepr, aPlacementsOfPairs, aRepresentationContextOfLink, aLink);
- aArrayOfRigidLinks->SetValue(aLinkInd, aLinkRepresentation);
+ aMapOfLinks.Bind(aSeqOfLinskL(aLinkInd), aLinkRepresentation);
Handle(TDataStd_Integer) aBase;
- if (aBaseLinksOfMech.IsNull() && aLinkL.FindAttribute(TDataStd_Integer::GetID(), aBase))
- aBaseLinksOfMech = aLinkRepresentation;
+ if (aBaseLinkOfMech.IsNull() && aLinkL.FindAttribute(TDataStd_Integer::GetID(), aBase))
+ aBaseLinkOfMech = aLinkRepresentation;
Handle(StepKinematics_KinematicLinkRepresentationAssociation) aLinkRepresentationAssociation = new StepKinematics_KinematicLinkRepresentationAssociation;
- aLinkRepresentationAssociation->Init(aNameOfLinkRepr, aNameOfLinkRepr, aRefShapeOfLink, aLinkRepresentation);
+ aLinkRepresentationAssociation->Init(aNameOfLinkRepr, aNameOfLinkRepr, aLinkRepresentation, aRefShapeOfLink);
Handle(StepKinematics_ContextDependentKinematicLinkRepresentation) aCDKLRS = new StepKinematics_ContextDependentKinematicLinkRepresentation;
Handle(StepKinematics_ProductDefinitionRelationshipKinematics) aPDRK = new StepKinematics_ProductDefinitionRelationshipKinematics;
- aGeneralDefinition = aPD; //Work, but think out
+ aGeneralDefinition = aPD;
aPDRK->Init(aNameOfLinkRepr, Standard_False, aLinkRepresentationAssociation->Description(), aPD->Definition());
aCDKLRS->Init(aLinkRepresentationAssociation, aPDRK);
Model->AddEntity(aLink);
Model->AddEntity(aPDRK);
Model->AddEntity(aCDKLRS);
}
- if (aBaseLinksOfMech.IsNull())
- aBaseLinksOfMech = Handle(StepKinematics_KinematicLinkRepresentation)::DownCast(aArrayOfRigidLinks->Value(1));
-
if (aGeneralDefinition.IsNull())
continue;
- //write joints
- //containers storing Joints and their labels located at a single index
- //any joint corresponds a unique pair with the same index
+ // if not found base link in OCAF
+ // first link became base of the mechanism
+ if (aBaseLinkOfMech.IsNull() && !aMapOfLinks.Find(aSeqOfLinskL(1), aBaseLinkOfMech))
+ continue;
+
+ // write joints
TDF_LabelSequence aSeqOfJointsL = aKTool->GetJoints(aMechanismsL.Value(aMechInd));
if (aSeqOfJointsL.Length() <= 0)
- return Standard_False;
- Handle(TColStd_HArray1OfTransient) aArrayOfJoints = new TColStd_HArray1OfTransient(1, aSeqOfJointsL.Length());
+ continue;
+ NCollection_IndexedDataMap<TDF_Label, Handle(StepKinematics_KinematicJoint), TDF_LabelMapHasher> aMapofJoints;
Handle(StepRepr_HArray1OfRepresentationItem) anArrayOfPairs = new StepRepr_HArray1OfRepresentationItem(1, aSeqOfJointsL.Length());
Handle(StepKinematics_KinematicPropertyMechanismRepresentation) aPropertyMechanismRepr = new StepKinematics_KinematicPropertyMechanismRepresentation;
Handle(XCAFKinematics_PairObject) aPairObject = aKPairAttr->GetObject();
Handle(StepKinematics_RigidLinkRepresentation) aRigLinkRepr1;
Handle(StepKinematics_RigidLinkRepresentation) aRigLinkRepr2;
- if (!createKinematicJoint(FP, aKTool, aGraph, aJointL, aPairObject, aSeqOfLinskL, aRigLinkRepr1, aRigLinkRepr2, aArrayOfRigidLinks, aJoint))
+ if (!createKinematicJoint(FP, aKTool, aGraph, aJointL, aPairObject, aMapOfLinks, aRigLinkRepr1, aRigLinkRepr2, aJoint))
continue;
- if (!createKinematicPair(aPairObject, aKinematicPair, aJoint, aSeqOfLinskL, aRigLinkRepr1, aRigLinkRepr2, aArrayOfRigidLinks))
+ if (!createKinematicPair(aPairObject,aJoint,aKinematicPair, aRigLinkRepr1, aRigLinkRepr2))
continue;
- aArrayOfJoints->SetValue(aJointInd, aJoint);
+ aMapofJoints.Add(aSeqOfJointsL(aJointInd), aJoint);
Handle(StepKinematics_PairRepresentationRelationship) aPairReprRelationship = new StepKinematics_PairRepresentationRelationship;
StepRepr_RepresentationOrRepresentationReference aDataLinkStart;
aDataLinkStart.SetValue(aRigLinkRepr1);
Model->AddWithRefs(aPairReprRelationship);
}
- //write mechanism
+ // write mechanism
Handle(StepKinematics_ProductDefinitionKinematics) aProductDefKin = new StepKinematics_ProductDefinitionKinematics;
aProductDefKin->Init(new TCollection_HAsciiString, Standard_False, new TCollection_HAsciiString, aGeneralDefinition->Definition());
- aKTopoStruct->Init(new TCollection_HAsciiString, anArrayOfPairs, aBaseLinksOfMech->ContextOfItems());
+ aKTopoStruct->Init(new TCollection_HAsciiString, anArrayOfPairs, aBaseLinkOfMech->ContextOfItems());
StepKinematics_KinematicTopologyRepresentationSelect aTopoSelect;
aTopoSelect.SetValue(aKTopoStruct);
Handle(TDataStd_Name) aAttrName;
aMechanismsL.Value(aMechInd).FindAttribute(TDataStd_Name::GetID(), aAttrName);
Handle(TCollection_HAsciiString) aHNameMechanism = new TCollection_HAsciiString(aAttrName->Get());
aPDK.SetValue(aProductDefKin);
- aMechanism->Init(aHNameMechanism, anArrayOfPairs, aBaseLinksOfMech->ContextOfItems(), aTopoSelect);
- aPropertyMechanismRepr->Init(aPDK, aMechanism, aBaseLinksOfMech);
+ aMechanism->Init(aHNameMechanism, anArrayOfPairs, aBaseLinkOfMech->ContextOfItems(), aTopoSelect);
+ aPropertyMechanismRepr->Init(aPDK, aMechanism, aBaseLinkOfMech);
Model->AddWithRefs(aPropertyMechanismRepr);
- //(optional) write States
+ // (optional) write States
TDF_LabelSequence aSeqOfStates = aKTool->GetStates(aMechanismsL.Value(aMechInd));
for (Standard_Integer aStateInd = 1; aStateInd <= aSeqOfStates.Length(); ++aStateInd)
{
TDF_Label aJointL = aKTool->GetJointOfValue(aSeqOfValues(aValueInd));
Handle(StepKinematics_KinematicJoint) aJoint;
Handle(StepKinematics_PairRepresentationRelationship) aPairReprRelationship;
- Standard_Integer anIndOfPair;
- for (anIndOfPair = 1; anIndOfPair <= aSeqOfJointsL.Length(); ++anIndOfPair)
- {
- if (aSeqOfJointsL(anIndOfPair) == aJointL)
- {
- aPairReprRelationship = Handle(StepKinematics_PairRepresentationRelationship)::DownCast(anArrayOfPairs->Value(anIndOfPair));
- aJoint = Handle(StepKinematics_KinematicJoint)::DownCast(aArrayOfJoints->Value(anIndOfPair));
- break;
- }
- }
- if (aJoint.IsNull() || aPairReprRelationship.IsNull())
+ if (!aMapofJoints.FindFromKey(aJointL, aJoint))
+ continue;
+ aPairReprRelationship = Handle(StepKinematics_PairRepresentationRelationship)::DownCast(anArrayOfPairs->Value(aMapofJoints.FindIndex(aJointL)));
+ if (aPairReprRelationship.IsNull())
continue;
Handle(XCAFDoc_KinematicPairValue) aKPairValueAttr;
if (!aSeqOfValues(aValueInd).FindAttribute(XCAFDoc_KinematicPairValue::GetID(), aKPairValueAttr))
continue;
Handle(XCAFKinematics_PairValueObject) aPairValueObject = aKPairValueAttr->GetObject();
Handle(StepKinematics_PairValue) aPairValue;
- if (!createKinematicPairValue(aPairValueObject, aPairValue, aPairReprRelationship))
+ if (!createKinematicPairValue(aPairValueObject, aPairReprRelationship, aPairValue))
continue;
aPairValue->SetName(aNameOfValue);
aItems->SetValue(aValueInd, aPairValue);
StepKinematics_MechanismStateRepresentation::StepKinematics_MechanismStateRepresentation() {}
-void StepKinematics_MechanismStateRepresentation::Init(const Handle(TCollection_HAsciiString)& aName,
- const Handle(StepRepr_HArray1OfRepresentationItem)& aItems,
- const Handle(StepRepr_RepresentationContext)& aContextOfItems,
- const Handle(StepKinematics_MechanismRepresentation) aMechanism)
+void StepKinematics_MechanismStateRepresentation::Init(const Handle(TCollection_HAsciiString)& theName,
+ const Handle(StepRepr_HArray1OfRepresentationItem)& theItems,
+ const Handle(StepRepr_RepresentationContext)& theContextOfItems,
+ const Handle(StepKinematics_MechanismRepresentation) theMechanism)
{
- StepRepr_Representation::Init(aName, aItems, aContextOfItems);
- representedMechanism = aMechanism;
+ StepRepr_Representation::Init(theName, theItems, theContextOfItems);
+ myRepresentedMechanism = theMechanism;
}
-void StepKinematics_MechanismStateRepresentation::SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& aMechanism)
+void StepKinematics_MechanismStateRepresentation::SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& theMechanism)
{
- representedMechanism = aMechanism;
+ myRepresentedMechanism = theMechanism;
}
Handle(StepKinematics_MechanismRepresentation) StepKinematics_MechanismStateRepresentation::Mechanism() const
{
- return representedMechanism;
+ return myRepresentedMechanism;
}
\ No newline at end of file
//! Returns a MechanismStateRepresentation
Standard_EXPORT StepKinematics_MechanismStateRepresentation();
- Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& aName, const Handle(StepRepr_HArray1OfRepresentationItem)& aItems, const Handle(StepRepr_RepresentationContext)& aContextOfItems, const Handle(StepKinematics_MechanismRepresentation) aMechanism);
+ Standard_EXPORT void Init(const Handle(TCollection_HAsciiString)& theName, const Handle(StepRepr_HArray1OfRepresentationItem)& theItems, const Handle(StepRepr_RepresentationContext)& theContextOfItems, const Handle(StepKinematics_MechanismRepresentation) theMechanism);
- Standard_EXPORT void SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& aMechanism);
+ Standard_EXPORT void SetMechanism(const Handle(StepKinematics_MechanismRepresentation)& theMechanism);
Standard_EXPORT Handle(StepKinematics_MechanismRepresentation) Mechanism() const;
private:
- Handle(StepKinematics_MechanismRepresentation) representedMechanism;
+ Handle(StepKinematics_MechanismRepresentation) myRepresentedMechanism;
DEFINE_STANDARD_RTTIEXT(StepKinematics_MechanismStateRepresentation,StepRepr_Representation)
};
#include <StepGeom_UniformSurfaceAndRationalBSplineSurface.hxx>
#include <StepGeom_Vector.hxx>
#include <StepKinematics_SuParameters.hxx>
+#include <StepKinematics_SpatialRotation.hxx>
+#include <StepKinematics_RotationAboutDirection.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
+#include <StepBasic_PlaneAngleMeasureWithUnit.hxx>
+#include <StepBasic_ConversionBasedUnitAndPlaneAngleUnit.hxx>
+#include <StepBasic_SiUnitAndPlaneAngleUnit.hxx>
+#include <StepRepr_GlobalUnitAssignedContext.hxx>
#include <UnitsMethods.hxx>
//=============================================================================
}
return 0;
}
+
+//=============================================================================
+// Creation d' un YptRotation de Kinematic a partir d' un SpatialRotation de Step
+//=============================================================================
+
+Handle(TColStd_HArray1OfReal) StepToGeom::MakeYprRotation(const StepKinematics_SpatialRotation& SR, const Handle(StepRepr_GlobalUnitAssignedContext)& theCntxt)
+{
+ //If rotation is already a ypr_rotation, return it immediately
+ Handle(TColStd_HArray1OfReal) anYPRRotation;
+ if (!SR.YprRotation().IsNull() &&
+ SR.YprRotation()->Length() == 3)
+ {
+ anYPRRotation = SR.YprRotation();
+ }
+ //rotation is a rotation_about_direction
+ else if (!SR.RotationAboutDirection().IsNull() &&
+ SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatios()->Length() == 3 &&
+ !theCntxt.IsNull())
+ {
+ Handle(Geom_Direction) anAxis;
+ anAxis = new Geom_Direction(SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(1),
+ SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(2),
+ SR.RotationAboutDirection()->DirectionOfAxis()->DirectionRatiosValue(3));
+ Standard_Real anAngle = SR.RotationAboutDirection()->RotationAngle();
+ if (anAngle == 0.)
+ {
+ // a zero rotation is converted trivially
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, 0.);
+ anYPRRotation->SetValue(2, 0.);
+ anYPRRotation->SetValue(3, 0.);
+ return anYPRRotation;
+ }
+ Standard_Real dx = anAxis->X();
+ Standard_Real dy = anAxis->Y();
+ Standard_Real dz = anAxis->Z();
+ NCollection_Sequence<Handle(StepBasic_NamedUnit)> aPaUnits;
+ for (Standard_Integer anInd = 1; anInd <= theCntxt->Units()->Length(); ++anInd)
+ {
+ if (theCntxt->UnitsValue(anInd)->IsKind(STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit))||
+ theCntxt->UnitsValue(anInd)->IsKind(STANDARD_TYPE(StepBasic_SiUnitAndPlaneAngleUnit)))
+ aPaUnits.Append(theCntxt->UnitsValue(anInd));
+ }
+ if (aPaUnits.Length() != 1)
+ return anYPRRotation;
+ Handle(StepBasic_NamedUnit) aPau = aPaUnits.Value(1);
+ while (!aPau.IsNull() && aPau->IsKind((STANDARD_TYPE(StepBasic_ConversionBasedUnitAndPlaneAngleUnit))))
+ {
+ Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit) aConverUnit = Handle(StepBasic_ConversionBasedUnitAndPlaneAngleUnit)::DownCast(aPau);
+ anAngle = anAngle * aConverUnit->ConversionFactor()->ValueComponent();
+ aPau = aConverUnit->ConversionFactor()->UnitComponent().NamedUnit();
+ }
+ if(aPau.IsNull())
+ return anYPRRotation;
+ Handle(StepBasic_SiUnitAndPlaneAngleUnit) aSiUnit = Handle(StepBasic_SiUnitAndPlaneAngleUnit)::DownCast(aPau);
+ if(aSiUnit.IsNull() || aSiUnit->Name() != StepBasic_SiUnitName::StepBasic_sunRadian)
+ return anYPRRotation;
+ switch (aSiUnit->Prefix())
+ {
+ case(StepBasic_spExa):
+ anAngle = 1.E18 * anAngle;
+ break;
+ case(StepBasic_spPeta):
+ anAngle = 1.E15 * anAngle;
+ break;
+ case(StepBasic_spTera):
+ anAngle = 1.E12 * anAngle;
+ break;
+ case(StepBasic_spGiga):
+ anAngle = 1.E9 * anAngle;
+ break;
+ case(StepBasic_spMega):
+ anAngle = 1.E6 * anAngle;
+ break;
+ case(StepBasic_spKilo):
+ anAngle = 1.E3 * anAngle;
+ break;
+ case(StepBasic_spHecto):
+ anAngle = 1.E2 * anAngle;
+ break;
+ case(StepBasic_spDeca):
+ anAngle = 1.E1 * anAngle;
+ break;
+ case(StepBasic_spDeci):
+ anAngle = 1.E-1 * anAngle;
+ break;
+ case(StepBasic_spCenti):
+ anAngle = 1.E-2 * anAngle;
+ break;
+ case(StepBasic_spMilli):
+ anAngle = 1.E-3 * anAngle;
+ break;
+ case(StepBasic_spMicro):
+ anAngle = 1.E-6 * anAngle;
+ break;
+ case(StepBasic_spNano):
+ anAngle = 1.E-9 * anAngle;
+ break;
+ case(StepBasic_spPico):
+ anAngle = 1.E-12 * anAngle;
+ break;
+ case(StepBasic_spFemto):
+ anAngle = 1.E-15 * anAngle;
+ break;
+ case(StepBasic_spAtto):
+ anAngle = 1.E-18 * anAngle;
+ break;
+ }
+ Standard_Real anUcf = SR.RotationAboutDirection()->RotationAngle() / anAngle;
+ Standard_Real aSA = Sin(anAngle);
+ Standard_Real aCA = Cos(anAngle);
+ Standard_Real aYaw = 0, aPitch = 0, aRoll = 0;
+ // axis parallel either to x-axis or to z-axis?
+ if (dy == 0. && dx * dz == 0.)
+ {
+ while (anAngle <= -M_PI)
+ anAngle = anAngle + 2 * M_PI;
+ while (anAngle > M_PI)
+ anAngle = anAngle - 2 * M_PI;
+
+ aYaw = anUcf * anAngle;
+ if (anAngle != M_PI)
+ aRoll = -aYaw;
+ else
+ aRoll = aYaw;
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, 0.);
+ anYPRRotation->SetValue(2, 0.);
+ anYPRRotation->SetValue(3, 0.);
+ if (dx != 0.)
+ if (dx > 0.)
+ anYPRRotation->SetValue(3, aYaw);
+ else
+ anYPRRotation->SetValue(3, aRoll);
+ else
+ if (dz > 0.)
+ anYPRRotation->SetValue(1, aYaw);
+ else
+ anYPRRotation->SetValue(1, aRoll);
+ return anYPRRotation;
+ }
+
+ // axis parallel to y-axis - use y-axis as pitch axis
+ if ((dy != 0.0) && (dx == 0.0) && (dz == 0.0))
+ {
+ if (aCA >= 0.0)
+ {
+ aYaw = 0.0;
+ aRoll = 0.0;
+ }
+ else
+ {
+ aYaw = anUcf * M_PI;
+ aRoll = aYaw;
+ }
+ aPitch = anUcf * ATan2(aSA, Abs(aCA));
+ if (dy < 0.0)
+ aPitch = -aPitch;
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, aYaw);
+ anYPRRotation->SetValue(2, aPitch);
+ anYPRRotation->SetValue(3, aRoll);
+ return anYPRRotation;
+ }
+ // axis not parallel to any axis of coordinate system
+ // compute rotation matrix
+ Standard_Real aCm1 = 1 - aCA;
+
+ Standard_Real aRotMat[3][3] = { { dx * dx * aCm1 + aCA ,dx * dy * aCm1 - dz * aSA, dx * dz * aCm1 + dy * aSA },
+ { dx * dy * aCm1 + dz * aSA,dy * dy * aCm1 + aCA, dy * dz * aCm1 - dx * aSA },
+ { dx * dz * aCm1 - dy * aSA, dy * dz * aCm1 + dx * aSA,dz * dz * aCm1 + aCA } };
+
+ // aRotMat[1][3] equals SIN(pitch_angle)
+ if (Abs(aRotMat[0][2] == 1.))
+ {
+ // |aPithc| = PI/2
+ if (aRotMat[0][2] == 1.)
+ aPitch = M_PI_2;
+ else
+ aPitch = -M_PI_2;
+ // In this case, only the sum or difference of roll and yaw angles
+ // is relevant and can be evaluated from the matrix.
+ // According to IP `rectangular pitch angle' for ypr_rotation,
+ // the roll angle is set to zero.
+ aRoll = 0.;
+ aYaw = ATan2(aRotMat[1][0], aRotMat[1][1]);
+ // result of ATAN is in the range[-PI / 2, PI / 2].
+ // Here all four quadrants are needed.
+
+ if (aRotMat[1][1] < 0.)
+ if (aYaw <= 0.)
+ aYaw = aYaw + M_PI;
+ else
+ aYaw = aYaw - M_PI;
+ }
+ else
+ {
+ // COS (pitch_angle) not equal to zero
+ aYaw = ATan2(-aRotMat[0][1], aRotMat[0][0]);
+
+ if (aRotMat[0][0] < 0.)
+ {
+ if (aYaw <= 0.)
+ aYaw = aYaw + M_PI;
+ else
+ aYaw = aYaw - M_PI;
+ }
+ Standard_Real aSY = Sin(aYaw);
+ Standard_Real aCY = Cos(aYaw);
+ Standard_Real aSR = Sin(aRoll);
+ Standard_Real aCR = Cos(aRoll);
+
+ if (Abs(aSY) > Abs(aCY) &&
+ Abs(aSY) > Abs(aSR) &&
+ Abs(aSY) > Abs(aCR))
+ aCm1 = -aRotMat[0][1] / aSY;
+ else
+ if (Abs(aCY) > Abs(aSR) && Abs(aCY) > Abs(aCR))
+ aCm1 = aRotMat[0][0] / aCY;
+ else
+ if (Abs(aSR) > Abs(aCR))
+ aCm1 = -aRotMat[1][2] / aSR;
+ else
+ aCm1 = aRotMat[2][2] / aCR;
+ aPitch = ATan2(aRotMat[0][2], aCm1);
+ }
+ aYaw = aYaw * anUcf;
+ aPitch = aPitch * anUcf;
+ aRoll = aRoll * anUcf;
+ anYPRRotation = new TColStd_HArray1OfReal(1, 3);
+ anYPRRotation->SetValue(1, aYaw);
+ anYPRRotation->SetValue(2, aPitch);
+ anYPRRotation->SetValue(3, aRoll);
+ }
+ return anYPRRotation;
+}
class StepGeom_TrimmedCurve;
class StepGeom_Vector;
class StepKinematics_SuParameters;
+class StepKinematics_SpatialRotation;
+class StepRepr_GlobalUnitAssignedContext;
+class TColStd_HArray1OfReal;
//! This class provides static methods to convert STEP geometric entities to OCCT.
//! The methods returning handles will return null handle in case of error.
Standard_EXPORT static Handle(Geom2d_BSplineCurve) MakeTrimmedCurve2d (const Handle(StepGeom_TrimmedCurve)& SC);
Standard_EXPORT static Handle(Geom_VectorWithMagnitude) MakeVectorWithMagnitude (const Handle(StepGeom_Vector)& SV);
Standard_EXPORT static Handle(Geom2d_VectorWithMagnitude) MakeVectorWithMagnitude2d (const Handle(StepGeom_Vector)& SV);
+ Standard_EXPORT static Handle(TColStd_HArray1OfReal) MakeYprRotation(const StepKinematics_SpatialRotation& SR, const Handle(StepRepr_GlobalUnitAssignedContext)& theCntxt);
};
#endif // _StepToGeom_HeaderFile
// High order pairs
if (theObject->Type() >= XCAFKinematics_PairType_PointOnSurface &&
- theObject->Type() <= XCAFKinematics_PairType_RollingCurve) {
+ theObject->Type() <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve) {
Handle(XCAFKinematics_HighOrderPairObject) anObject =
Handle(XCAFKinematics_HighOrderPairObject)::DownCast(theObject);
TDataStd_Integer::Set(Label(), getParamsID(), (Standard_Integer)anObject->Orientation());
TNaming_Builder aTNBuild(Label().FindChild(ChildLab_FirstGeomParam));
aTNBuild.Generated(anEdge);
}
- if (theObject->Type() == XCAFKinematics_PairType_SlidingCurve ||
- theObject->Type() == XCAFKinematics_PairType_RollingCurve)
+ if (theObject->Type() >= XCAFKinematics_PairType_SlidingCurve &&
+ theObject->Type() <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve)
{
TopoDS_Edge anEdge1, anEdge2;
if (!anObject->FirstCurve().IsNull()) {
aType <= XCAFKinematics_PairType_Unconstrained)
anObject = new XCAFKinematics_LowOrderPairObject();
else if (aType >= XCAFKinematics_PairType_Screw &&
- aType <= XCAFKinematics_PairType_Gear)
+ aType <= XCAFKinematics_PairType_LinearFlexibleAndPinion)
anObject = new XCAFKinematics_LowOrderPairObjectWithCoupling();
else if (aType >= XCAFKinematics_PairType_PointOnSurface &&
- aType <= XCAFKinematics_PairType_RollingCurve)
+ aType <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve)
anObject = new XCAFKinematics_HighOrderPairObject();
anObject->SetType((XCAFKinematics_PairType)aType);
}
// Low order pairs with motion coupling
if (anObject->Type() >= XCAFKinematics_PairType_Screw &&
- anObject->Type() <= XCAFKinematics_PairType_Gear) {
+ anObject->Type() <= XCAFKinematics_PairType_LinearFlexibleAndPinion) {
Handle(XCAFKinematics_LowOrderPairObjectWithCoupling) aDefObject =
Handle(XCAFKinematics_LowOrderPairObjectWithCoupling)::DownCast(anObject);
Handle(TDataStd_RealArray) aParamsAttr;
// High order pairs
if (anObject->Type() >= XCAFKinematics_PairType_PointOnSurface &&
- anObject->Type() <= XCAFKinematics_PairType_RollingCurve) {
+ anObject->Type() <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve) {
Handle(XCAFKinematics_HighOrderPairObject) aDefObject =
Handle(XCAFKinematics_HighOrderPairObject)::DownCast(anObject);
Handle(TDataStd_Integer) anOrienAttr;
aDefObject->SetCurve(BRep_Tool::Curve(anEdge, aFirst, aLast));
}
}
- if (anObject->Type() == XCAFKinematics_PairType_SlidingCurve ||
- anObject->Type() == XCAFKinematics_PairType_RollingCurve)
+ if (anObject->Type() >= XCAFKinematics_PairType_SlidingCurve &&
+ anObject->Type() <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve)
{
if (Label().FindChild(ChildLab_FirstGeomParam).FindAttribute(TNaming_NamedShape::GetID(), aNS))
{
//purpose :
//=======================================================================
TDF_Label XCAFDoc_KinematicTool::AddLink(const TDF_Label& theMechanism,
- const Standard_Boolean& IsBase)
+ const Standard_Boolean& isBase)
{
if (!IsMechanism(theMechanism))
return TDF_Label();
TDF_TagSource aTag;
TDF_Label aLink = aTag.NewChild(getRootOfLinks(theMechanism));
- if (IsBase)
+ if (isBase)
{
SetBaseLink(aLink);
}
//=======================================================================
TDF_Label XCAFDoc_KinematicTool::AddLink(const TDF_Label& theMechanism,
const TDF_LabelSequence& theShapes,
- const Standard_Boolean& IsBase)
+ const Standard_Boolean& isBase)
{
- TDF_Label aNewLink = AddLink(theMechanism, IsBase);
+ TDF_Label aNewLink = AddLink(theMechanism, isBase);
if (aNewLink.IsNull() || theShapes.Length() == 0)
return aNewLink;
//=======================================================================
TDF_Label XCAFDoc_KinematicTool::AddLink(const TDF_Label& theMechanism,
const TDF_Label& theShape,
- const Standard_Boolean& IsBase)
+ const Standard_Boolean& isBase)
{
TDF_LabelSequence anAuxSequence;
anAuxSequence.Append(theShape);
- return AddLink(theMechanism, anAuxSequence, IsBase);
+ return AddLink(theMechanism, anAuxSequence, isBase);
}
//=======================================================================
//=======================================================================
Standard_EXPORT Standard_Boolean XCAFDoc_KinematicTool::SetBaseLink(const TDF_Label& theLink)
{
- TDataStd_Name::Set(theLink, "Base");
TDF_Label aMechanism = theLink.Father().Father();
if (!IsMechanism(aMechanism))
return Standard_False;
}
}
}
+ TDataStd_Name::Set(theLink, "Base");
TDataStd_Integer::Set(theLink, 1);
}
return aStatesArray;
}
+//=======================================================================
+//function : GetStateOfValue
+//purpose :
+//=======================================================================
+TDF_Label XCAFDoc_KinematicTool::GetStateOfValue(const TDF_Label& theValue) const
+{
+ TDF_Label aState;
+ if (!IsValue(theValue))
+ return aState;
+ aState = theValue.Father();
+ return aState;
+}
+
//=======================================================================
//function : GetValuesOfState
//purpose :
if (theJoint.FindAttribute(XCAFDoc::KinematicRefJointGUID(), aNode)) {
aChildNode = aNode->First();
while (!aChildNode.IsNull()) {
- aValuesArray.Append(aChildNode->Label());
+ if (IsValue(aChildNode->Label()))
+ aValuesArray.Append(aChildNode->Label());
aChildNode = aChildNode->Next();
}
}
//! Adds new empty label for link.
//! \param[in] theMechanism parent mechanism
- //! param[in] IsBase link is base of mechanism
+ //! \param[in] isBase link is base of mechanism
//! \return created link label
Standard_EXPORT TDF_Label AddLink(const TDF_Label& theMechanism,
- const Standard_Boolean& IsBase = Standard_False);
+ const Standard_Boolean& isBase = Standard_False);
//! Adds new label with link.
- //! param[in] theMechanism parent mechanism
- //! param[in] theShapes all details of link
- //! param[in] IsBase link is base of mechanism
+ //! \param[in] theMechanism parent mechanism
+ //! \param[in] theShapes all details of link
+ //! \param[in] isBase link is base of mechanism
//! \return created link label
Standard_EXPORT TDF_Label AddLink(const TDF_Label& theMechanism,
const TDF_LabelSequence& theShapes,
- const Standard_Boolean& IsBase = Standard_False);
+ const Standard_Boolean& isBase = Standard_False);
//! Adds new label with link.
//! \param[in] theMechanism parent mechanism
//! \param[in] theShape singular detail of link
+ //! \param[in] isBase link is base of mechanism
//! \return created link label
Standard_EXPORT TDF_Label AddLink(const TDF_Label& theMechanism,
- const TDF_Label& theShapeá,
- const Standard_Boolean& IsBase = Standard_False);
+ const TDF_Label& theShape,
+ const Standard_Boolean& isBase = Standard_False);
//! Checks is the given label a link
//! \return the result of check
Standard_EXPORT Standard_Boolean IsLink(const TDF_Label& theLink) const;
//! Sets shapes references for link
- //! param[in] theLink link to set shapes
- //! param[in] theShapes all details of link
+ //! \param[in] theLink link to set shapes
+ //! \param[in] theShapes all details of link
//! \return true in case of success, false otherwise
Standard_EXPORT Standard_Boolean SetLink(const TDF_Label& theLink,
const TDF_LabelSequence& theShapes);
//! Sets shapes references for link
- //! param[in] theLink link to set base
+ //! \param[in] theLink link to set base
//! \return true in case of success, false otherwise
Standard_EXPORT Standard_Boolean SetBaseLink(const TDF_Label& theLink);
// Retrieves all values labels of the given state
//! \param[in] theState parent state
- //! \return value set
+ //! \return set of values
Standard_EXPORT TDF_LabelSequence GetValuesOfState(const TDF_Label& theState) const;
+ //! Gets references to state of the given value.
+ //! \param[in] theValue value to get
+ //! \return state
+ Standard_EXPORT TDF_Label GetStateOfValue(const TDF_Label& theValue) const;
+
//! Gets references to joints of the given value.
//! \param[in] theValue value to get
//! \return a joint
XCAFKinematics_HighOrderPairObject()
{
myLimits = NULL;
- isRanged = Standard_False;
+ myIsRanged = Standard_False;
}
//=======================================================================
myOrientation = theObj->myOrientation;
myLimits = theObj->myLimits;
myGeom = theObj->myGeom;
- isRanged = theObj->HasLimits();
+ myIsRanged = theObj->HasLimits();
}
//=======================================================================
myGeom = NCollection_Array1<Handle(Geom_Geometry)>(1, 2);
break;
}
+ case XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve: {
+ myLimits = NULL;
+ myGeom = NCollection_Array1<Handle(Geom_Geometry)>(1, 1);
+ break;
+ }
}
}
if (theLimits->Length() == aNbLimits)
{
myLimits = theLimits;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
//=======================================================================
Standard_Boolean XCAFKinematics_HighOrderPairObject::HasLimits() const
{
- return isRanged;
+ return myIsRanged;
}
//=======================================================================
if (Type() == XCAFKinematics_PairType_SlidingSurface || Type() == XCAFKinematics_PairType_RollingSurface)
{
myLimits->ChangeValue(1) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
if (Type() == XCAFKinematics_PairType_SlidingSurface || Type() == XCAFKinematics_PairType_RollingSurface)
{
myLimits->ChangeValue(2) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
if (Type() == XCAFKinematics_PairType_PointOnPlanarCurve || Type() == XCAFKinematics_PairType_PointOnSurface)
{
myLimits->ChangeValue(1) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
if (Type() == XCAFKinematics_PairType_PointOnPlanarCurve || Type() == XCAFKinematics_PairType_PointOnSurface)
{
myLimits->ChangeValue(2) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
if (Type() == XCAFKinematics_PairType_PointOnPlanarCurve || Type() == XCAFKinematics_PairType_PointOnSurface)
{
myLimits->ChangeValue(3) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
if (Type() == XCAFKinematics_PairType_PointOnPlanarCurve || Type() == XCAFKinematics_PairType_PointOnSurface)
{
myLimits->ChangeValue(4) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
if (Type() == XCAFKinematics_PairType_PointOnPlanarCurve || Type() == XCAFKinematics_PairType_PointOnSurface)
{
myLimits->ChangeValue(5) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
if (Type() == XCAFKinematics_PairType_PointOnPlanarCurve || Type() == XCAFKinematics_PairType_PointOnSurface)
{
myLimits->ChangeValue(6) = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
}
//=======================================================================
void XCAFKinematics_HighOrderPairObject::SetFirstCurve(const Handle(Geom_Curve)& theCurve)
{
- if (Type() == XCAFKinematics_PairType_SlidingCurve || Type() == XCAFKinematics_PairType_RollingCurve)
+ if (Type() >= XCAFKinematics_PairType_SlidingCurve && Type() <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve)
myGeom.ChangeFirst() = theCurve;
}
//=======================================================================
Handle(Geom_Curve) XCAFKinematics_HighOrderPairObject::FirstCurve() const
{
- if (Type() == XCAFKinematics_PairType_SlidingCurve || Type() == XCAFKinematics_PairType_RollingCurve)
+ if (Type() >= XCAFKinematics_PairType_SlidingCurve && Type() <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve)
return Handle(Geom_Curve)::DownCast(myGeom.First());
return NULL;
}
//! - XCAFKinematics_PairType_PointOnPlanarCurve
//! - XCAFKinematics_PairType_SlidingCurve
//! - XCAFKinematics_PairType_RollingCurve
+//! - XCAFKinematics_PairType_RollingCurve
+//! - XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve
class XCAFKinematics_HighOrderPairObject : public XCAFKinematics_PairObject
{
//! \return curve
Standard_EXPORT Handle(Geom_Curve) SecondCurve() const;
- ////! Sets curve attribute (only for PointOnCurve)
- ////! \param[in] theTrimmedCurve trimmed curve
+ //! Sets curve attribute (only for PointOnCurve)
+ //! \param[in] theTrimmedCurve trimmed curve
//Standard_EXPORT void SetTrimmedCurve(const Standard_Real& theTrim1, const Standard_Real& theTrim2);
//! Sets trimmed curve attribute (only for PointOnCurve)
//! \return trimmed curve
Standard_EXPORT Handle(Geom_TrimmedCurve) TrimmedCurve() const;
- ////! \return trimmed curve
+ //! \return trimmed curve
//Standard_EXPORT void TrimmedCurve(Standard_Real& theTrim1,Standard_Real& theTrim2) const;
//! Sets surface attribute (only for PointOnSurface)
//! \return surface
Standard_EXPORT Handle(Geom_Surface) SecondSurface() const;
- ////! Sets surface attribute (only for PointOnSurface)
- ////! \param[in] theTrimmedSurface trimmed surface
+ //! Sets surface attribute (only for PointOnSurface)
+ //! \param[in] theTrimmedSurface trimmed surface
//Standard_EXPORT void SetTrimmedSurface(const Standard_Real& U1, const Standard_Real& U2, const Standard_Real& V1, const Standard_Real& V2);
//! Sets trimmed surface attribute (only for PointOnSurface)
Standard_Boolean myOrientation; //!< orientation
Handle(TColStd_HArray1OfReal) myLimits; //!< array of limits, size depends on type
NCollection_Array1<Handle(Geom_Geometry)> myGeom; //!< curve(s) or surface(s) attributes
- Standard_Boolean isRanged; //!< flag "is limits defined"
+ Standard_Boolean myIsRanged; //!< flag "is limits defined"
};
myMaxTranslationY = Precision::Infinite();
myMinTranslationZ = -Precision::Infinite();
myMaxTranslationZ = Precision::Infinite();
- isRanged = Standard_False;
+ myIsRanged = Standard_False;
}
//=======================================================================
myMaxTranslationY = theObj->myMaxTranslationY;
myMinTranslationZ = theObj->myMinTranslationZ;
myMaxTranslationZ = theObj->myMaxTranslationZ;
- isRanged = theObj->HasLimits();
+ myIsRanged = theObj->HasLimits();
}
//=======================================================================
//=======================================================================
Standard_Boolean XCAFKinematics_LowOrderPairObject::HasLimits() const
{
- return isRanged;
+ return myIsRanged;
}
//=======================================================================
myMaxTranslationY = theLimits->Value(10);
myMinTranslationZ = theLimits->Value(11);
myMaxTranslationZ = theLimits->Value(12);
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
void SetMinRotationX(const Standard_Real theLimit)
{
myMinRotationX = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MinRotationX() const
void SetMaxRotationX(const Standard_Real theLimit)
{
myMaxRotationX = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MaxRotationX() const
void SetMinRotationY(const Standard_Real theLimit)
{
myMinRotationY = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MinRotationY() const
void SetMaxRotationY(const Standard_Real theLimit)
{
myMaxRotationY = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MaxRotationY() const
void SetMinRotationZ(const Standard_Real theLimit)
{
myMinRotationZ = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MinRotationZ() const
void SetMaxRotationZ(const Standard_Real theLimit)
{
myMaxRotationZ = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MaxRotationZ() const
void SetMinTranslationX(const Standard_Real theLimit)
{
myMinTranslationX = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MinTranslationX() const
void SetMaxTranslationX(const Standard_Real theLimit)
{
myMaxTranslationX = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MaxTranslationX() const
void SetMinTranslationY(const Standard_Real theLimit)
{
myMinTranslationY = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MinTranslationY() const
void SetMaxTranslationY(const Standard_Real theLimit)
{
myMaxTranslationY = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MaxTranslationY() const
void SetMinTranslationZ(const Standard_Real theLimit)
{
myMinTranslationZ = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MinTranslationZ() const
void SetMaxTranslationZ(const Standard_Real theLimit)
{
myMaxTranslationZ = theLimit;
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
}
Standard_Real MaxTranslationZ() const
Standard_Real myMinTranslationZ; //!< minimum value of translation in z-direction
Standard_Real myMaxTranslationZ; //!< maximum value of translation in z-direction
Standard_Real mySkewAngle; //!< param for universal/homokinetic pair
- Standard_Boolean isRanged; //!< flag "is limits defined"
+ Standard_Boolean myIsRanged; //!< flag "is limits defined"
};
XCAFKinematics_LowOrderPairObjectWithCoupling::
XCAFKinematics_LowOrderPairObjectWithCoupling()
{
- isRanged = Standard_False;
+ myIsRanged = Standard_False;
myLowLimit = -Precision::Infinite();
myUpperLimit = Precision::Infinite();
myParams = NULL;
SetType(theObj->Type());
SetFirstTransformation(theObj->FirstTransformation());
SetSecondTransformation(theObj->SecondTransformation());
- isRanged = theObj->HasLimits();
+ myIsRanged = theObj->HasLimits();
myLowLimit = theObj->LowLimit();
myUpperLimit = theObj->UpperLimit();
myParams = theObj->GetAllParams();
//=======================================================================
void XCAFKinematics_LowOrderPairObjectWithCoupling::SetPinionRadius(const Standard_Real theRadius)
{
- if (Type() == XCAFKinematics_PairType_RackAndPinion)
+ if (Type() == XCAFKinematics_PairType_RackAndPinion || Type() == XCAFKinematics_PairType_LinearFlexibleAndPinion)
myParams->ChangeFirst() = theRadius;
}
//=======================================================================
Standard_Real XCAFKinematics_LowOrderPairObjectWithCoupling::PinionRadius() const
{
- if (Type() == XCAFKinematics_PairType_RackAndPinion)
+ if (Type() == XCAFKinematics_PairType_RackAndPinion || Type() == XCAFKinematics_PairType_LinearFlexibleAndPinion)
return myParams->First();
return 0;
}
//=======================================================================
Standard_Boolean XCAFKinematics_LowOrderPairObjectWithCoupling::HasLimits() const
{
- return isRanged;
+ return myIsRanged;
}
//=======================================================================
{
if (theLimits->Length() == 2)
{
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
myLowLimit = theLimits->Value(1);
myUpperLimit = theLimits->Value(2);
}
void SetLowLimit(const Standard_Real theLimit)
{
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
myLowLimit = theLimit;
}
void SetUpperLimit(const Standard_Real theLimit)
{
- isRanged = Standard_True;
+ myIsRanged = Standard_True;
myUpperLimit = theLimit;
}
Standard_Real myLowLimit; //!< low limit of motion range
Standard_Real myUpperLimit; //!< upper limit of motion range
Handle(TColStd_HArray1OfReal) myParams; //!< additional parameters of kinematic pair
- Standard_Boolean isRanged; //!< flag "is limits defined"
+ Standard_Boolean myIsRanged; //!< flag "is limits defined"
};
TDF_Label aMechanism;
if (!getLabel(di, aDoc, argv[2], aMechanism))
return 1;
- Standard_Boolean IsBase = argc >= 4 && TCollection_AsciiString(argv[3]).IsEqual("-base");
+ Standard_Boolean isBase = argc >= 4 && TCollection_AsciiString(argv[3]).IsEqual("-base");
TDF_LabelSequence aShapeArray;
- for (Standard_Integer i = (IsBase) ? 4 : 3; i < argc; i++) {
+ for (Standard_Integer i = (isBase) ? 4 : 3; i < argc; i++) {
TDF_Label aLabel;
if (!getLabel(di, aDoc, argv[i], aLabel))
continue;
}
Handle(XCAFDoc_KinematicTool) aTool = XCAFDoc_DocumentTool::KinematicTool(aDoc->Main());
- di << getEntry(aTool->AddLink(aMechanism, aShapeArray, IsBase));
+ di << getEntry(aTool->AddLink(aMechanism, aShapeArray, isBase));
return 0;
}
di << "Pitch = " << anObject->Pitch();
break;
case XCAFKinematics_PairType_RackAndPinion:
+ case XCAFKinematics_PairType_LinearFlexibleAndPinion:
di << "Pinion Radius = " << anObject->PinionRadius();
break;
case XCAFKinematics_PairType_Gear:
return 0;
}
+//=======================================================================
+//function : dump
+//purpose :
+//=======================================================================
+static Standard_Integer dump(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
+{
+ if (argc < 2) {
+ di << "Use: XDumpKinematics Doc\n";
+ return 1;
+ }
+ Handle(TDocStd_Document) aDoc;
+ DDocStd::GetDocument(argv[1], aDoc);
+ if (aDoc.IsNull()) {
+ di << argv[1] << " is not a document\n";
+ return 1;
+ }
+ Handle(XCAFDoc_KinematicTool) aKTool = XCAFDoc_DocumentTool::KinematicTool(aDoc->Main());
+
+ TDF_LabelSequence aMechanisms = aKTool->GetMechanisms();
+
+ di << "\n NbOfMechanisms : ( " << aMechanisms.Length()<<" )";
+ Standard_Integer nbLinks = 0,
+ nbRefShapes = 0,
+ nbHigeOrderPairs = 0,
+ nbLowOrderPairsWithMotionCoupling = 0,
+ nbLowOrderPairs = 0,
+ nbHigeOrderPairsWithRange = 0,
+ nbLowOrderPairsWithMotionCouplingAndRange = 0,
+ nbLowOrderPairsWithRange = 0,
+ nbStates = 0,
+ nbHigeOrderPairValues = 0,
+ nbLowOrderPairWithMotionCouplingValues = 0,
+ nbLowOrderPairValues = 0;
+
+ for (Standard_Integer aMechInd = 1; aMechInd <= aMechanisms.Length(); ++aMechInd)
+ {
+ TDF_Label aMechanism = aMechanisms.Value(aMechInd);
+ TDF_LabelSequence aLinks = aKTool->GetLinks(aMechanism);
+ nbLinks += aLinks.Length();
+ for (Standard_Integer aLinkInd = 1; aLinkInd <= nbLinks; ++aLinkInd)
+ nbRefShapes += aKTool->GetRefShapes(aLinks.Value(aLinkInd)).Length();
+ TDF_LabelSequence aJoints = aKTool->GetJoints(aMechanism);
+ for (Standard_Integer aJointInd = 1; aJointInd <= aJoints.Length(); ++aJointInd)
+ {
+ Handle(XCAFDoc_KinematicPair) aKinAttr;
+ if (!aJoints.Value(aJointInd).FindAttribute(XCAFDoc_KinematicPair::GetID(), aKinAttr))
+ continue;
+ Handle(XCAFKinematics_PairObject) anObject = aKinAttr->GetObject();
+ if (anObject.IsNull())
+ continue;
+ XCAFKinematics_PairType aKinType = anObject->Type();
+ if (aKinType >= XCAFKinematics_PairType_FullyConstrained &&
+ aKinType <= XCAFKinematics_PairType_Unconstrained)
+ {
+ if (anObject->HasLimits())
+ nbLowOrderPairsWithRange++;
+ else
+ nbLowOrderPairs++;
+ nbLowOrderPairValues += aKTool->GetValuesOfJoint(aJoints.Value(aJointInd)).Length();
+ }
+ else if (aKinType >= XCAFKinematics_PairType_Screw &&
+ aKinType <= XCAFKinematics_PairType_LinearFlexibleAndPinion)
+ {
+ if (anObject->HasLimits())
+ nbLowOrderPairsWithMotionCouplingAndRange++;
+ else
+ nbLowOrderPairsWithMotionCoupling++;
+ nbLowOrderPairWithMotionCouplingValues += aKTool->GetValuesOfJoint(aJoints.Value(aJointInd)).Length();
+ }
+ else if (aKinType >= XCAFKinematics_PairType_PointOnSurface &&
+ aKinType <= XCAFKinematics_PairType_LinearFlexibleAndPlanarCurve)
+ {
+ if (anObject->HasLimits())
+ nbHigeOrderPairsWithRange++;
+ else
+ nbHigeOrderPairs++;
+ nbHigeOrderPairValues += aKTool->GetValuesOfJoint(aJoints.Value(aJointInd)).Length();
+ }
+ }
+ nbStates += aKTool->GetStates(aMechanism).Length();
+ }
+ di << "\n NbOfKinematicLinks : ( " << nbLinks <<" )";
+ di << "\n NbOfRefShapes : ( " << nbRefShapes << " )";
+ di << "\n KinematicPairsWithoutRange : ";
+ di << " NbOfLowOrderPairs ( " << nbLowOrderPairs << " )";
+ di << " NbOfLowOrderPairsWithMotionCoupling ( " << nbLowOrderPairsWithMotionCoupling << " )";
+ di << " NbOfHightOrderPairs ( " << nbHigeOrderPairs << " )";
+ di << "\n KinematicPairsWithRange : ";
+ di << " NbOfLowOrderPairs ( " << nbLowOrderPairsWithRange << " )";
+ di << " NbOfLowOrderPairsWithMotionCoupling ( " << nbLowOrderPairsWithMotionCouplingAndRange << " )";
+ di << " NbOfHightOrderPairs ( " << nbHigeOrderPairsWithRange << " )";
+ di << "\n NbOfStates : ( " << nbStates << " )";
+ di << "\n KinematicValues : ";
+ di << " NbOfLowOrderPairs ( " << nbLowOrderPairValues << " )";
+ di << " NbOfLowOrderPairsWithMotionCoupling ( " << nbLowOrderPairWithMotionCouplingValues << " )";
+ di << " NbOfHightOrderPairs ( " << nbHigeOrderPairValues << " )";
+ return 0;
+}
+
+
//=======================================================================
//function : InitCommands
//purpose :
"\t 18 PointOnPlanarCurve\n"
"\t 19 SlidingCurve\n"
"\t 20 RollingCurve\n"
+ "\t 21 LinearFlexibleAndPlanarCurve\n"
__FILE__, setType, g);
di.Add("XGetPairType", "XGetPairType Doc Joint",
"\t-ypr - current yaw pitch roll angles - 3 numbers"
"\t-trsf - for unconstrained only current location direction xdirection - 9 numbers",
__FILE__, getValues, g);
+
+ di.Add("XDumpKinematics", "XDumpKinematics Doc",
+ __FILE__, dump, g);
}
006 view
007 notes
008 kinematics
+009 kinematics_export
# Test scenario for kinematics
#==============================
-# ReadStep D [locate_data_file as1-oc-214.stp]
+ ReadStep D [locate_data_file as1-oc-214.stp]
# Load document with shape structure
-ReadStep D C:/Work/files/as1.stp
+# ReadStep D C:/Work/files/as1.stp
# Add parent mechanism
set mech [XAddMechanism D]
--- /dev/null
+# Rolling curve pair
+
+# Prepare a document
+XNewDoc D
+box b 1 1 1
+box bb 2 0 0 1 1 1
+XAddShape D b
+XAddShape D bb
+set mech [XAddMechanism D]
+set link1 [XAddLink D $mech 0:1:1:1]
+set link2 [XAddLink D $mech 0:1:1:2]
+set joint [XAddJoint D $mech $link1 $link2]
+
+# Start testing
+XSetPairName D $joint linear flexible and pinion
+set name [XGetPairName D $joint]
+if {$name != "linear flexible and pinion"} {
+ puts "Error: wrong parameter"
+}
+XSetPairType D $joint 14
+set type [XGetPairType D $joint]
+if {$type != "14"} {
+ puts "Error: wrong parameter"
+}
+
+plane p1 10 20 30 -1 0 0
+plane p2 10 0 0 1 0 0 0 1 0
+XSetPairTransformation D $joint 1 p1
+XSetPairTransformation D $joint 2 p2
+set dump_in [dump p1]
+XGetPairTransformation D $joint 1 p1
+set dump_out [dump p1]
+if {$dump_in != $dump_out} {
+ puts "Error: wrong parameter"
+}
+set dump_in [dump p2]
+XGetPairTransformation D $joint 2 p2
+set dump_out [dump p2]
+if {$dump_in != $dump_out} {
+ puts "Error: wrong parameter"
+}
+
+XSetPairParams D $joint 3
+set param [XGetPairParams D $joint]
+if {$param != "Pinion Radius = 3"} {
+ puts "Error: wrong parameter"
+}
+
+Close D
\ No newline at end of file
--- /dev/null
+# Rolling curve pair
+
+# Prepare a document
+XNewDoc D
+box b 1 1 1
+box bb 2 0 0 1 1 1
+XAddShape D b
+XAddShape D bb
+set mech [XAddMechanism D]
+set link1 [XAddLink D $mech 0:1:1:1]
+set link2 [XAddLink D $mech 0:1:1:2]
+set joint [XAddJoint D $mech $link1 $link2]
+
+# Start testing
+XSetPairName D $joint linear flexible and planar curve
+set name [XGetPairName D $joint]
+if {$name != "linear flexible and planar curve"} {
+ puts "Error: wrong parameter"
+}
+XSetPairType D $joint 21
+set type [XGetPairType D $joint]
+if {$type != "21"} {
+ puts "Error: wrong parameter"
+}
+
+plane p1 10 20 30 -1 0 0
+plane p2 10 0 0 1 0 0 0 1 0
+XSetPairTransformation D $joint 1 p1
+XSetPairTransformation D $joint 2 p2
+set dump_in [dump p1]
+XGetPairTransformation D $joint 1 p1
+set dump_out [dump p1]
+if {$dump_in != $dump_out} {
+ puts "Error: wrong parameter"
+}
+set dump_in [dump p2]
+XGetPairTransformation D $joint 2 p2
+set dump_out [dump p2]
+if {$dump_in != $dump_out} {
+ puts "Error: wrong parameter"
+}
+
+circle cir1 4 4 4 1
+XSetPairGeomParam D $joint 1 cir1
+set dump_in [dump cir1]
+XGetPairGeomParam D $joint 1 cir1
+set dump_out [dump cir1]
+if {$dump_in != $dump_out} {
+ puts "Error: wrong parameter"
+}
+
+XSetPairOrientation D $joint 1
+set ori [XGetPairOrientation D $joint]
+if {$ori != 1} {
+ puts "Error: wrong parameter"
+}
+
+Close D
\ No newline at end of file
--- /dev/null
+# !!!! This file is generated automatically, do not edit manually! See end script
+set filename chuck_3_jaw_AP242_v2.stp
+
+set ref_data {
+
+ NbOfMechanisms : ( 1 )
+ NbOfKinematicLinks : ( 4 )
+ NbOfRefShapes : ( 4 )
+ KinematicPairsWithoutRange : NbOfLowOrderPairs ( 0 ) NbOfLowOrderPairsWithMotionCoupling ( 0 ) NbOfHightOrderPairs ( 0 )
+ KinematicPairsWithRange : NbOfLowOrderPairs ( 3 ) NbOfLowOrderPairsWithMotionCoupling ( 0 ) NbOfHightOrderPairs ( 0 )
+ NbOfStates : ( 2 )
+ KinematicValues : NbOfLowOrderPairs ( 6 ) NbOfLowOrderPairsWithMotionCoupling ( 0 ) NbOfHightOrderPairs ( 0 )
+}
--- /dev/null
+# !!!! This file is generated automatically, do not edit manually! See end script
+set filename mazak_kinematic_v3.stp
+
+set ref_data {
+
+ NbOfMechanisms : ( 1 )
+ NbOfKinematicLinks : ( 8 )
+ NbOfRefShapes : ( 8 )
+ KinematicPairsWithoutRange : NbOfLowOrderPairs ( 2 ) NbOfLowOrderPairsWithMotionCoupling ( 0 ) NbOfHightOrderPairs ( 0 )
+ KinematicPairsWithRange : NbOfLowOrderPairs ( 5 ) NbOfLowOrderPairsWithMotionCoupling ( 0 ) NbOfHightOrderPairs ( 0 )
+ NbOfStates : ( 10 )
+ KinematicValues : NbOfLowOrderPairs ( 15 ) NbOfLowOrderPairsWithMotionCoupling ( 0 ) NbOfHightOrderPairs ( 0 )
+}
--- /dev/null
+NewDocument D
--- /dev/null
+# Set flag dump_file to 1 in order to regenerate script files with actual data
+# used as reference. In this mode all tests intentionaly report failure.
+set dump_file 0
+########################################################################
+set mist 0;
+# Kinematic Mechanism
+set nbMechanism_First 0; set nbMechanism_Second 0;
+# Kinematic Links
+set nbLink_First 0; set nbLink_Second 0;
+set nbRefShape_First 0; set nbRefShape_Second 0;
+# Kinematic Pairs
+set nbLowPair_First 0; set nbLowPair_Second 0;
+set nbLowPairWthMotCoupl_First 0; set nbLowPairWthMotCoupl_Second 0;
+set nbHighPair_First 0; set nbHighPair_Second 0;
+set nbLowPairWthRng_First 0; set nbLowPairWthRng_Second 0;
+set nbLowPairWthMotCouplAndRng_First 0; set nbLowPairWthMotCouplAndRng_Second 0;
+set nbHighPairWthRng_First 0; set nbHighPairWthRange_Second 0;
+# Kinematic States
+set nbState_First 0; set nbState_Second 0;
+# Kinematic Values
+set nbLowPairVls_First 0; set nbLowPairVls_Second 0;
+set nbLowPairWthMotCouplVls_First 0; set nbLowPairWthMotCouplVls_Second 0;
+set nbHighPairVls_First 0; set nbHighPairVls_Second 0;
+###################################################################
+set ref_Compare 0
+set todo_msg ""
+set todo_mask "puts \"TODO CR31388 ALL: "
+set end_line "\" \n"
+##################################################################
+
+# Read original file
+if { [string length $filename] > 1} {
+ set path_file [locate_data_file $filename]
+ if { [catch { ReadStep D_First $path_file } catch_result] } {
+ set err_msg "Error: First - file was not read - exception "
+ puts $err_msg
+ append todo_msg $todo_mask $err_msg $end_line
+ set mist 1
+ }
+} else {
+ set mist 1
+}
+
+# Get information about kinematics
+if { $mist < 1} {
+ puts ""
+ set xst [ XDumpKinematics D_First]
+
+ if { [llength $xst] > 0 } {
+ regexp {NbOfMechanisms +: +[(] +([-0-9.+eE]+) +[)]} $xst full nbMechanism_First
+ regexp {NbOfKinematicLinks +: +[(] +([-0-9.+eE]+) +[)]} $xst full nbLink_First
+ regexp {NbOfRefShapes +: +[(] +([-0-9.+eE]+) +[)]} $xst full nbRefShape_First
+ regexp {KinematicPairsWithoutRange +: +NbOfLowOrderPairs +[(] +([-0-9.+eE]+) +[)] +NbOfLowOrderPairsWithMotionCoupling +[(] +([-0-9.+eE]+) +[)] +NbOfHightOrderPairs +[(] +([-0-9.+eE]+) +[)]} $xst full nbLowPair_First nbLowPairWthMotCoupl_First nbHighPair_First
+ regexp {KinematicPairsWithRange +: +NbOfLowOrderPairs +[(] +([-0-9.+eE]+) +[)] +NbOfLowOrderPairsWithMotionCoupling +[(] +([-0-9.+eE]+) +[)] +NbOfHightOrderPairs +[(] +([-0-9.+eE]+) +[)]} $xst full nbLowPairWthRng_First nbLowPairWthMotCouplAndRng_First nbHighPairWthRng_First
+ regexp {NbOfStates +: +[(] +([-0-9.+eE]+) +[)]} $xst full nbState_First
+ regexp {KinematicValues +: +NbOfLowOrderPairs +[(] +([-0-9.+eE]+) +[)] +NbOfLowOrderPairsWithMotionCoupling +[(] +([-0-9.+eE]+) +[)] +NbOfHightOrderPairs +[(] +([-0-9.+eE]+) +[)]} $xst full nbLowPairVls_First nbLowPairWthMotCouplVls_First nbHighPairVls_First
+ } else {
+ puts " Kinematics information was NOT provided"
+ }
+}
+
+if { $mist != 1 } {
+ puts ""
+ set result ""
+ append result [format $xst]
+}
+
+# Writing file
+if { $mist < 1} {
+ puts " "
+ puts "-----------------------------WRITING FILE ------------------------------"
+ if { [catch { WriteStep D_First $imagedir/${casename}_D_First.stp } catch_result] } {
+ set err_msg "Error: First - file was not written - exception"
+ puts $err_msg
+ append todo_msg $todo_mask $err_msg $end_line
+ set mist 1
+ }
+ if { $mist < 1 } {
+ if { [catch { ReadStep D_Second $imagedir/${casename}_D_First.stp } catch_result] } {
+ set err_msg "Error: Second - file was not read - exception"
+ puts $err_msg
+ append todo_msg $todo_mask $err_msg $end_line
+ set mist 1
+ }
+ }
+}
+
+catch {[file delete $imagedir/${casename}_D_First.stp]}
+if { [catch { Close D_First } catch_result] } {
+ set err_msg "Error : cannot close a document D_First - exception"
+ puts $err_msg
+}
+
+# Get information about kinematics
+if { $mist < 1} {
+ puts ""
+ set xst2 [ XDumpKinematics D_Second]
+
+ if { [llength $xst2] > 0 } {
+ regexp {NbOfMechanisms +: +[(] +([-0-9.+eE]+) +[)]} $xst2 full nbMechanism_Second
+ regexp {NbOfKinematicLinks +: +[(] +([-0-9.+eE]+) +[)]} $xst2 full nbLink_Second
+ regexp {NbOfRefShapes +: +[(] +([-0-9.+eE]+) +[)]} $xst2 full nbRefShape_Secondt
+ regexp {KinematicPairsWithoutRange +: +NbOfLowOrderPairs +[(] +([-0-9.+eE]+) +[)] +NbOfLowOrderPairsWithMotionCoupling +[(] +([-0-9.+eE]+) +[)] +NbOfHightOrderPairs +[(] +([-0-9.+eE]+) +[)]} $xst2 full nbLowPair_Second nbLowPairWthMotCoupl_Second nbHighPair_Second
+ regexp {KinematicPairsWithRange +: +NbOfLowOrderPairs +[(] +([-0-9.+eE]+) +[)] +NbOfLowOrderPairsWithMotionCoupling +[(] +([-0-9.+eE]+) +[)] +NbOfHightOrderPairs +[(] +([-0-9.+eE]+) +[)]} $xst2 full nbLowPairWthRng_Second nbLowPairWthMotCouplAndRng_Second nbHighPairWthRng__Second
+ regexp {NbOfStates +: +[(] +([-0-9.+eE]+) +[)]} $xst2 full nbState_Second
+ regexp {KinematicValues +: +NbOfLowOrderPairs +[(] +([-0-9.+eE]+) +[)] +NbOfLowOrderPairsWithMotionCoupling +[(] +([-0-9.+eE]+) +[)] +NbOfHightOrderPairs +[(] +([-0-9.+eE]+) +[)]} $xst2 full nbLowPairVls_Second nbLowPairWthMotCouplVls_Second nbHighPairVls_Second
+ } else {
+ puts " Kinematics information was NOT provided"
+ }
+ if { [catch { Close D_Second } catch_result] } {
+ set err_msg "Error : cannot close a document D_Second - exception"
+ puts $err_msg
+ }
+}
+
+if { $mist != 1 } {
+ puts ""
+ set result2 ""
+ append result2 [format $xst2]
+}
+set err_compare_ref ""
+# Put reference data to the test script file if option "dump" is set
+if { $dump_file == 1 } {
+ set fd_stream [open $dirname/$groupname/$gridname/$casename w]
+ puts $fd_stream "# !!!! This file is generated automatically, do not edit manually! See end script"
+ puts $fd_stream "set filename $filename"
+ if { $mist != 1 } {
+ puts $fd_stream ""
+ puts $fd_stream "set ref_data \{"
+ puts $fd_stream $result
+ puts $fd_stream "\}"
+ }
+ close $fd_stream
+} elseif { $mist != 1 } {
+ puts "========================== Comparision with reference data ========"
+ puts ""
+ # Comparision of reference data with obtained result
+ set ref_list [split $ref_data \n]
+ set cur_list [split $result \n]
+ set cur2_list [split $result2 \n]
+ set nb_ref [llength $ref_list]
+ for { set i 0 } { $i < $nb_ref } { incr i } {
+ set j [expr $i +1]
+ set refstr [lindex $ref_list $j]
+ set curstr [lindex $cur_list $i]
+ set cur2str [lindex $cur2_list $i]
+ set isOK 1;
+
+ if {[string equal $refstr $curstr] == 0} {
+ set isOK 0
+ }
+
+ if {[string equal $curstr $cur2str] == 0} {
+ set isOK 0
+ }
+
+ if { $isOK == 0} {
+ incr ref_Compare
+ append err_compare_ref " Reference data - $refstr\n"
+ append err_compare_ref " Current data - $curstr\n"
+ append err_compare_ref " Current data after writing - $cur2str\n"
+ append err_compare_ref "--------------------------------------------------------------------\n"
+ }
+ }
+}
+
+if { $dump_file != 0 } {
+ puts "Error : Running in regeneration mode, comparision was not performed!"
+ if { $mist != 1 } {
+ puts "Generation of test file $groupname/$gridname/$casename successful"
+ } else {
+ puts "Generation of reference data failed"
+ }
+} else {
+ if { $ref_Compare > 0} {
+ puts "Error : $ref_Compare differences with reference data found :\n$err_compare_ref"
+ } else {
+ puts "Comparision of current result with reference data - OK\n"
+ }
+}
+
+puts "--------------------------------------------------------------------"
+puts ""
+
+puts "TEST COMPLETED"
projects / occt-copy.git / commitdiff