def calcInitialValues(self):
c = self.constraintObject
plane1 = getObjectFaceFromName(self.ob1, c.SubElement1)
plane2 = getObjectFaceFromName(self.ob2, c.SubElement2)
normal1 = a2plib.getPlaneNormal(plane1.Surface)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
angle = math.degrees(normal1.getAngle(normal2))
if angle <= 90.0:
self.direction = "aligned"
else:
self.direction = "opposed"
def recalculateMatingDirection(c):
ob1 = c.Document.getObject(c.Object1)
ob2 = c.Document.getObject(c.Object2)
plane1 = getObjectFaceFromName(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
normal1 = a2plib.getPlaneNormal(plane1.Surface)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
angle = math.degrees(normal1.getAngle(normal2))
if angle <= 90.0:
c.directionConstraint = "aligned"
else:
c.directionConstraint = "opposed"
def recalculateMatingDirection(c):
ob1 = c.Document.getObject(c.Object1)
ob2 = c.Document.getObject(c.Object2)
if c.SubElement1.startswith('Face'):
plane1 = getObjectFaceFromName(ob1, c.SubElement1)
elif c.SubElement1.startswith('Edge'):
#print(self.sub1)
plane1 = Part.Face(Part.Wire(getObjectEdgeFromName(ob1, c.SubElement1)))
if c.SubElement2.startswith('Face'):
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
elif c.SubElement2.startswith('Edge'):
plane2 = Part.Face(Part.Wire(getObjectEdgeFromName(ob2, c.SubElement2)))
axis1 = a2plib.getPlaneNormal(plane1.Surface)
axis2 = a2plib.getPlaneNormal(plane2.Surface)
angle = math.degrees(axis1.getAngle(axis2))
if angle <= 90.0:
c.directionConstraint = "aligned"
else:
c.directionConstraint = "opposed"
def calcInitialValues(self):
if self.sub1.startswith('Face'):
plane1 = getObjectFaceFromName(self.ob1, self.sub1)
elif self.sub1.startswith('Edge'):
#print(self.sub1)
plane1 = Part.Face(Part.Wire(getObjectEdgeFromName(self.ob1, self.sub1)))
if self.sub2.startswith('Face'):
plane2 = getObjectFaceFromName(self.ob2, self.sub2)
elif self.sub2.startswith('Edge'):
plane2 = Part.Face(Part.Wire(getObjectEdgeFromName(self.ob2, self.sub2)))
#plane2 = getObjectFaceFromName(self.ob2, self.sub2)
axis1 = a2plib.getPlaneNormal(plane1.Surface)
axis2 = a2plib.getPlaneNormal(plane2.Surface)
angle = math.degrees(axis1.getAngle(axis2))
if angle <= 90.0:
self.direction = "aligned"
else:
self.direction = "opposed"
self.offset = 0.0
self.lockRotation = False
def recalculateMatingDirection(c):
point = getPos(c.Object1, c.SubElement1)
plane = getObjectFaceFromName(c.Object2, c.SubElement2)
planeNormal = a2plib.getPlaneNormal(plane.Surface)
planePos = getPos(c.Object2, c.SubElement2)
# calculate recent offset...
delta = point.sub(planePos)
offset = delta.dot(planeNormal)
if offset >= 0:
c.offset = abs(c.offset)
else:
c.offset = -abs(c.offset)
def calcInitialValues(self):
c = self.constraintObject
axis1 = getAxis(self.ob1, c.SubElement1)
plane2 = getObjectFaceFromName(self.ob2, c.SubElement2)
axis2 = a2plib.getPlaneNormal(plane2.Surface)
angle = math.degrees(axis1.getAngle(axis2))
# the following section has been tested and is working,
# just it does not meet expectations.
# opposed/aligned are set to the opposite of expectation
# this has to be checked again.
if angle <= 90.0:
self.direction = "opposed"
self.angle = 90 - angle
else:
self.direction = "aligned"
self.angle = -90 + angle
def Create(doc, constraint, solver, rigid1, rigid2):
c = constraint
if c.Type == "sphereCenterIdent" or c.Type == "pointIdentity":
dep1 = DependencyPointIdentity(c, "point")
dep2 = DependencyPointIdentity(c, "point")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
vert1 = getPos(ob1, c.SubElement1)
vert2 = getPos(ob2, c.SubElement2)
dep1.refPoint = vert1
dep2.refPoint = vert2
elif c.Type == "pointOnLine":
dep1 = DependencyPointOnLine(c, "point")
dep2 = DependencyPointOnLine(c, "pointAxis")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
dep1.refPoint = getPos(ob1, c.SubElement1)
dep2.refPoint = getPos(ob2, c.SubElement2)
axis2 = getAxis(ob2, c.SubElement2)
dep2.refAxisEnd = dep2.refPoint.add(axis2)
elif c.Type == "pointOnPlane":
dep1 = DependencyPointOnPlane(c, "point")
dep2 = DependencyPointOnPlane(c, "plane")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
dep1.refPoint = getPos(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep2.refPoint = plane2.Faces[0].BoundBox.Center
normal2 = a2plib.getPlaneNormal(plane2.Surface)
#shift refPoint of plane by offset
try:
offs = c.offset
except:
offs = 0.0
offsetVector = Base.Vector(normal2)
offsetVector.multiply(offs)
dep2.refPoint = dep2.refPoint.add(offsetVector)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
elif c.Type == "circularEdge":
dep1 = DependencyCircularEdge(c, "pointAxis")
dep2 = DependencyCircularEdge(c, "pointAxis")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
dep1.refPoint = getPos(ob1, c.SubElement1)
dep2.refPoint = getPos(ob2, c.SubElement2)
axis1 = getAxis(ob1, c.SubElement1)
axis2 = getAxis(ob2, c.SubElement2)
if dep2.direction == "opposed":
axis2.multiply(-1.0)
dep1.refAxisEnd = dep1.refPoint.add(axis1)
dep2.refAxisEnd = dep2.refPoint.add(axis2)
#
if abs(dep2.offset) > solver.mySOLVER_SPIN_ACCURACY * 1e-1:
offsetAdjustVec = Base.Vector(axis2.x, axis2.y, axis2.z)
offsetAdjustVec.multiply(dep2.offset)
dep2.refPoint = dep2.refPoint.add(offsetAdjustVec)
dep2.refAxisEnd = dep2.refAxisEnd.add(offsetAdjustVec)
elif c.Type == "planesParallel":
dep1 = DependencyParallelPlanes(c, "pointNormal")
dep2 = DependencyParallelPlanes(c, "pointNormal")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
plane1 = getObjectFaceFromName(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep1.refPoint = plane1.Faces[0].BoundBox.Center
dep2.refPoint = plane2.Faces[0].BoundBox.Center
normal1 = a2plib.getPlaneNormal(plane1.Surface)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
if dep2.direction == "opposed":
normal2.multiply(-1.0)
dep1.refAxisEnd = dep1.refPoint.add(normal1)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
elif c.Type == "angledPlanes":
dep1 = DependencyAngledPlanes(c, "pointNormal")
dep2 = DependencyAngledPlanes(c, "pointNormal")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
plane1 = getObjectFaceFromName(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep1.refPoint = plane1.Faces[0].BoundBox.Center
dep2.refPoint = plane2.Faces[0].BoundBox.Center
normal1 = a2plib.getPlaneNormal(plane1.Surface)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
dep1.refAxisEnd = dep1.refPoint.add(normal1)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
elif c.Type == "plane":
dep1 = DependencyPlane(c, "pointNormal")
dep2 = DependencyPlane(c, "pointNormal")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
plane1 = getObjectFaceFromName(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep1.refPoint = plane1.Faces[0].BoundBox.Center
dep2.refPoint = plane2.Faces[0].BoundBox.Center
normal1 = a2plib.getPlaneNormal(plane1.Surface)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
if dep2.direction == "opposed":
normal2.multiply(-1.0)
dep1.refAxisEnd = dep1.refPoint.add(normal1)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
#
if abs(dep2.offset) > solver.mySOLVER_SPIN_ACCURACY * 1e-1:
offsetAdjustVec = Base.Vector(normal2.x, normal2.y, normal2.z)
offsetAdjustVec.multiply(dep2.offset)
dep2.refPoint = dep2.refPoint.add(offsetAdjustVec)
dep2.refAxisEnd = dep2.refAxisEnd.add(offsetAdjustVec)
elif c.Type == "axial":
dep1 = DependencyAxial(c, "pointAxis")
dep2 = DependencyAxial(c, "pointAxis")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
dep1.refPoint = getPos(ob1, c.SubElement1)
dep2.refPoint = getPos(ob2, c.SubElement2)
axis1 = getAxis(ob1, c.SubElement1)
axis2 = getAxis(ob2, c.SubElement2)
if dep2.direction == "opposed":
axis2.multiply(-1.0)
dep1.refPoint = dep1.adjustRefPoints(ob1, c.SubElement1,
dep1.refPoint, axis1)
dep2.refPoint = dep2.adjustRefPoints(ob2, c.SubElement2,
dep2.refPoint, axis2)
dep1.refAxisEnd = dep1.refPoint.add(axis1)
dep2.refAxisEnd = dep2.refPoint.add(axis2)
elif c.Type == "axisParallel":
dep1 = DependencyAxisParallel(c, "pointAxis")
dep2 = DependencyAxisParallel(c, "pointAxis")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
dep1.refPoint = getPos(ob1, c.SubElement1)
dep2.refPoint = getPos(ob2, c.SubElement2)
axis1 = getAxis(ob1, c.SubElement1)
axis2 = getAxis(ob2, c.SubElement2)
if dep2.direction == "opposed":
axis2.multiply(-1.0)
dep1.refAxisEnd = dep1.refPoint.add(axis1)
dep2.refAxisEnd = dep2.refPoint.add(axis2)
elif c.Type == "axisPlaneParallel":
dep1 = DependencyAxisPlaneParallel(c, "pointAxis")
dep2 = DependencyAxisPlaneParallel(c, "pointNormal")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
axis1 = getAxis(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep1.refPoint = getPos(ob1, c.SubElement1)
dep2.refPoint = plane2.Faces[0].BoundBox.Center
axis1Normalized = Base.Vector(axis1)
axis1Normalized.normalize()
dep1.refAxisEnd = dep1.refPoint.add(axis1Normalized)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
elif c.Type == "axisPlaneAngle":
dep1 = DependencyAxisPlaneAngle(c, "pointAxis")
dep2 = DependencyAxisPlaneAngle(c, "pointNormal")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
axis1 = getAxis(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep1.refPoint = getPos(ob1, c.SubElement1)
dep2.refPoint = plane2.Faces[0].BoundBox.Center
axis1Normalized = Base.Vector(axis1)
axis1Normalized.normalize()
dep1.refAxisEnd = dep1.refPoint.add(axis1Normalized)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
if dep2.direction == "opposed":
normal2.multiply(-1.0)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
elif c.Type == "axisPlaneVertical" or c.Type == "axisPlaneNormal": # axisPlaneVertical for compat.
dep1 = DependencyAxisPlaneNormal(c, "pointAxis")
dep2 = DependencyAxisPlaneNormal(c, "pointNormal")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
axis1 = getAxis(ob1, c.SubElement1)
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep1.refPoint = getPos(ob1, c.SubElement1)
dep2.refPoint = plane2.Faces[0].BoundBox.Center
axis1Normalized = Base.Vector(axis1)
axis1Normalized.normalize()
dep1.refAxisEnd = dep1.refPoint.add(axis1Normalized)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
if dep2.direction == "opposed":
normal2.multiply(-1.0)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
elif c.Type == "CenterOfMass":
dep1 = DependencyCenterOfMass(c, "point")
dep2 = DependencyCenterOfMass(c, "point")
ob1 = doc.getObject(c.Object1)
ob2 = doc.getObject(c.Object2)
if c.SubElement1.startswith('Face'):
plane1 = getObjectFaceFromName(ob1, c.SubElement1)
dep1.refPoint = plane1.Faces[0].CenterOfMass
elif c.SubElement1.startswith('Edge'):
plane1 = Part.Face(
Part.Wire(getObjectEdgeFromName(ob1, c.SubElement1)))
dep1.refPoint = plane1.CenterOfMass
if c.SubElement2.startswith('Face'):
plane2 = getObjectFaceFromName(ob2, c.SubElement2)
dep2.refPoint = plane2.Faces[0].CenterOfMass
elif c.SubElement2.startswith('Edge'):
plane2 = Part.Face(
Part.Wire(getObjectEdgeFromName(ob2, c.SubElement2)))
dep2.refPoint = plane2.CenterOfMass
normal1 = a2plib.getPlaneNormal(plane1.Surface)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
if dep2.direction == "opposed":
normal2.multiply(-1.0)
dep1.refAxisEnd = dep1.refPoint.add(normal1)
dep2.refAxisEnd = dep2.refPoint.add(normal2)
# to be improved: toggle direction even if offset == 0.0
if abs(dep2.offset) > solver.mySOLVER_SPIN_ACCURACY * 1e-1:
offsetAdjustVec = Base.Vector(normal2.x, normal2.y, normal2.z)
offsetAdjustVec.multiply(dep2.offset)
dep2.refPoint = dep2.refPoint.add(offsetAdjustVec)
dep2.refAxisEnd = dep2.refAxisEnd.add(offsetAdjustVec)
else:
raise NotImplementedError(
"Constraint type {} was not implemented!".format(c.Type))
# Assignments
dep1.currentRigid = rigid1
dep1.dependedRigid = rigid2
dep1.foreignDependency = dep2
dep2.currentRigid = rigid2
dep2.dependedRigid = rigid1
dep2.foreignDependency = dep1
rigid1.dependencies.append(dep1)
rigid2.dependencies.append(dep2)
def calcInitialValues(self):
plane1 = getObjectFaceFromName(self.ob1, self.sub1)
plane2 = getObjectFaceFromName(self.ob2, self.sub2)
normal1 = a2plib.getPlaneNormal(plane1.Surface)
normal2 = a2plib.getPlaneNormal(plane2.Surface)
self.angle = math.degrees(normal2.getAngle(normal1))