522 lines
14 KiB
Python
522 lines
14 KiB
Python
from collections import namedtuple
|
|
import FreeCAD, FreeCADGui
|
|
import asm3.utils as utils
|
|
import asm3.slvs as slvs
|
|
from asm3.utils import logger, objName
|
|
|
|
Types = []
|
|
TypeMap = {}
|
|
TypeNameMap = {}
|
|
|
|
class ConstraintType(type):
|
|
def __init__(cls, name, bases, attrs):
|
|
super(ConstraintType,cls).__init__(name,bases,attrs)
|
|
if cls._id >= 0:
|
|
if cls._id in TypeMap:
|
|
raise RuntimeError(
|
|
'Duplicate constriant type id {}'.format(cls._id))
|
|
if cls.slvsFunc():
|
|
TypeMap[cls._id] = cls
|
|
TypeNameMap[cls.getName()] = cls
|
|
cls._idx = len(Types)
|
|
logger.debug('register constraint "{}":{},{}'.format(
|
|
cls.getName(),cls._id,cls._idx))
|
|
Types.append(cls)
|
|
|
|
|
|
# PartName: text name of the part
|
|
# Placement: the original placement of the part
|
|
# Params: 7 parameters that defines the transformation
|
|
# Workplane: a tuple of three entity handles, that is the workplane, the origin
|
|
# point, and the normal. The workplane, defined by the origin and
|
|
# norml, is essentially the XY reference plane of the part.
|
|
# EntityMap: string -> entity handle map, for caching
|
|
PartInfo = namedtuple('SolverPartInfo',
|
|
('PartName','Placement','Params','Workplane','EntityMap'))
|
|
|
|
def _addEntity(etype,system,partInfo,key,shape):
|
|
key += '.{}'.format(etype)
|
|
h = partInfo.EntityMap.get(key,None)
|
|
if h:
|
|
logger.debug('cache {}: {}'.format(key,h))
|
|
return h
|
|
if etype == 'p': # point
|
|
v = utils.getElementPos(shape)
|
|
e = system.addPoint3dV(*v)
|
|
elif etype == 'n': # normal
|
|
v = utils.getElementNormal(shape)
|
|
e = system.addNormal3dV(*v)
|
|
else:
|
|
raise RuntimeError('unknown entity type {}'.format(etype))
|
|
h = system.addTransform(e,*partInfo.Params)
|
|
logger.debug('{}: {},{}, {}'.format(key,h,e,v))
|
|
partInfo.EntityMap[key] = h
|
|
return h
|
|
|
|
def _p(system,partInfo,key,shape):
|
|
'return a slvs handle of a transformed point derived from "shape"'
|
|
if not system:
|
|
if utils.hasCenter(shape):
|
|
return
|
|
return 'a vertex or circular edge/face'
|
|
return _addEntity('p',system,partInfo,key,shape)
|
|
|
|
def _n(system,partInfo,key,shape):
|
|
'return a slvs handle of a transformed normal derived from "shape"'
|
|
if not system:
|
|
if utils.isAxisOfPlane(shape):
|
|
return
|
|
return 'an edge or face with a surface normal'
|
|
return _addEntity('n',system,partInfo,key,shape)
|
|
|
|
def _l(system,partInfo,key,shape,retAll=False):
|
|
'return a pair of slvs handle of the end points of an edge in "shape"'
|
|
if not system:
|
|
if utils.isLinearEdge(shape):
|
|
return
|
|
return 'a linear edge'
|
|
key += '.l'
|
|
h = partInfo.EntityMap.get(key,None)
|
|
if h:
|
|
logger.debug('cache {}: {}'.format(key,h))
|
|
else:
|
|
v = shape.Edges[0].Vertexes
|
|
p1 = system.addPoint3dV(*v[0].Point)
|
|
p2 = system.addPoint3dV(*v[-1].Point)
|
|
h = system.addLine(p1,p2)
|
|
h = (h,p1,p2)
|
|
logger.debug('{}: {}'.format(key,h))
|
|
partInfo.EntityMap[key] = h
|
|
return h if retAll else h[0]
|
|
|
|
def _w(system,partInfo,key,shape,retAll=False):
|
|
'return a slvs handle of a transformed plane/workplane from "shape"'
|
|
if not system:
|
|
if utils.isAxisOfPlane(shape):
|
|
return
|
|
return 'an edge or face with a planar surface'
|
|
|
|
key2 = key+'.w'
|
|
h = partInfo.EntityMap.get(key2,None)
|
|
if h:
|
|
logger.debug('cache {}: {}'.format(key,h))
|
|
else:
|
|
p = _p(system,partInfo,key,shape)
|
|
n = _n(system,partInfo,key,shape)
|
|
h = system.addWorkplane(p,n)
|
|
h = (h,p,n)
|
|
logger.debug('{}: {}'.format(key,h))
|
|
partInfo.EntityMap[key2] = h
|
|
return h if retAll else h[0]
|
|
|
|
def _c(system,partInfo,key,shape,requireArc=False):
|
|
'return a slvs handle of a transformed circle/arc derived from "shape"'
|
|
if not system:
|
|
r = utils.getElementCircular(shape)
|
|
if not r or (requireArc and not isinstance(r,list,tuple)):
|
|
return
|
|
return 'an cicular arc edge' if requireArc else 'a circular edge'
|
|
key2 = key+'.c'
|
|
h = partInfo.EntityMap.get(key2,None)
|
|
if h:
|
|
logger.debug('cache {}: {}'.format(key,h))
|
|
else:
|
|
h = _w(system,partInfo,key,shape,True)
|
|
r = utils.getElementCircular(shape)
|
|
if not r:
|
|
raise RuntimeError('shape is not cicular')
|
|
if isinstance(r,(list,tuple)):
|
|
l = _l(system,partInfo,key,shape,True)
|
|
h += l[1:]
|
|
h = system.addArcOfCircleV(*h)
|
|
elif requireArc:
|
|
raise RuntimeError('shape is not an arc')
|
|
else:
|
|
h = h[1:]
|
|
h.append(system.addDistanceV(r))
|
|
h = system.addCircle(*h)
|
|
logger.debug('{}: {}, {}'.format(key,h,r))
|
|
partInfo.EntityMap[key2] = h
|
|
return h
|
|
|
|
def _a(system,partInfo,key,shape):
|
|
return _c(system,partInfo,key,shape,True)
|
|
|
|
|
|
_PropertyDistance = ('Value','Distance','PropertyDistance','Constraint')
|
|
_PropertyAngle = ('Value','Angle','PropertyAngle','Constraint')
|
|
_PropertyRatio = (None,'Ratio','PropertyFloat','Constraint')
|
|
_PropertyDifference = (None,'Difference','PropertyFloat','Constraint')
|
|
_PropertyDiameter = (None,'Diameter','PropertyFloat','Constraint')
|
|
_PropertyRadius = (None,'Radius','PropertyFloat','Constraint')
|
|
_PropertySupplement = (None,'Supplement','PropertyBool','Constraint',
|
|
'If True, then the second angle is calculated as 180-angle')
|
|
_PropertyAtEnd = (None,'AtEnd','PropertyBool','Constraint',
|
|
'If True, then tangent at the end point, or else at the start point')
|
|
|
|
_ordinal = ['1st', '2nd', '3rd', '4th', '5th', '6th', '7th' ]
|
|
|
|
class Base:
|
|
__metaclass__ = ConstraintType
|
|
|
|
_id = -1
|
|
_entities = []
|
|
_workplane = False
|
|
_props = []
|
|
_func = None
|
|
|
|
@classmethod
|
|
def getName(cls):
|
|
return cls.__name__
|
|
|
|
@classmethod
|
|
def slvsFunc(cls):
|
|
try:
|
|
if not cls._func:
|
|
cls._func = getattr(slvs.System,'add'+cls.getName())
|
|
return cls._func
|
|
except AttributeError:
|
|
logger.error('Invalid slvs constraint "{}"'.format(cls.getName()))
|
|
|
|
@classmethod
|
|
def getEntityDef(cls,group,checkCount,name=None):
|
|
entities = cls._entities
|
|
if len(group) != len(entities):
|
|
if not checkCount and len(group)<len(entities):
|
|
return entities[:len(group)]
|
|
if cls._workplane and len(group)==len(entities)+1:
|
|
entities = list(entities)
|
|
entities.append(_w)
|
|
else:
|
|
if not name:
|
|
name = cls.getName()
|
|
else:
|
|
name += ' of type "{}"'.format(cls.getName)
|
|
raise RuntimeError('Constraint {} has wrong number of '
|
|
'elements {}, expecting {}'.format(
|
|
name,len(group),len(entities)))
|
|
return entities
|
|
|
|
@classmethod
|
|
def check(cls,group):
|
|
entities = cls.getEntityDef(group,False)
|
|
for i,e in enumerate(entities):
|
|
o = group[i]
|
|
msg = e(None,None,None,o)
|
|
if not msg:
|
|
continue
|
|
if i == len(cls._entities):
|
|
raise RuntimeError('Constraint {} requires the optional {} '
|
|
'element to be a planar face for defining a '
|
|
'workplane'.format(cls.getName(), _ordinal[i], msg))
|
|
raise RuntimeError('Constraint {} requires the {} element to be'
|
|
' {}'.format(cls.getName(), _ordinal[i], msg))
|
|
|
|
def __init__(self,obj,_props):
|
|
if obj._Type != self._id:
|
|
if self._id < 0:
|
|
raise RuntimeError('invalid constraint type {} id: '
|
|
'{}'.format(self.__class__,self._id))
|
|
obj._Type = self._id
|
|
for prop in self.__class__._props:
|
|
obj.addProperty(*prop[1:])
|
|
|
|
@classmethod
|
|
def detach(cls,obj):
|
|
for prop in cls._props:
|
|
obj.removeProperty(prop[1])
|
|
|
|
def onChanged(self,obj,prop):
|
|
pass
|
|
|
|
@classmethod
|
|
def getEntities(cls,obj,solver):
|
|
'''maps fcad element shape to slvs entities'''
|
|
ret = []
|
|
for prop in cls._props:
|
|
v = getattr(obj,prop[1])
|
|
if prop[0]:
|
|
v = getattr(v,prop[0])()
|
|
ret.append(v)
|
|
|
|
elements = obj.Proxy.getElements()
|
|
entities = cls.getEntityDef(elements,True,objName(obj))
|
|
ret = []
|
|
for e,o in zip(entities,elements):
|
|
info = o.Proxy.getInfo()
|
|
partInfo = solver.getPartInfo(info)
|
|
ret.append(e(solver.system,partInfo,info.Subname,info.Shape))
|
|
logger.debug('{}: {}, {}'.format(objName(obj),obj.Type,ret))
|
|
return ret
|
|
|
|
@classmethod
|
|
def prepare(cls,obj,solver):
|
|
e = cls.getEntities(obj,solver)
|
|
cls._func(solver.system,*e,group=solver.group)
|
|
|
|
|
|
class Disabled(Base):
|
|
_id = 0
|
|
_func = True
|
|
|
|
@classmethod
|
|
def prepare(cls,_obj,_solver):
|
|
pass
|
|
|
|
|
|
class PointsCoincident(Base):
|
|
_id = 1
|
|
_entities = (_p,_p)
|
|
_workplane = True
|
|
|
|
|
|
class SameOrientation(Base):
|
|
_id = 2
|
|
_entities = (_n,_n)
|
|
|
|
|
|
class PointInPlane(Base):
|
|
_id = 3
|
|
_entities = (_p,_w)
|
|
|
|
|
|
class PointOnLine(Base):
|
|
_id = 4
|
|
_entities = (_p,_l)
|
|
_workplane = True
|
|
|
|
|
|
class PointsDistance(Base):
|
|
_id = 5
|
|
_entities = (_p,_p)
|
|
_workplane = True
|
|
_props = [_PropertyDistance]
|
|
|
|
|
|
class PointsProjectDistance(Base):
|
|
_id = 6
|
|
_entities = (_p,_p,_l)
|
|
_props = [_PropertyDistance]
|
|
|
|
|
|
class PointPlaneDistance(Base):
|
|
_id = 7
|
|
_entities = (_p,_w)
|
|
_props = [_PropertyDistance]
|
|
|
|
|
|
class PointLineDistance(Base):
|
|
_id = 8
|
|
_entities = (_p,_l)
|
|
_workplane = True
|
|
_props = [_PropertyDistance]
|
|
|
|
|
|
class EqualLength(Base):
|
|
_id = 9
|
|
_entities = (_l,_l)
|
|
_workplane = True
|
|
|
|
|
|
class LengthRatio(Base):
|
|
_id = 10
|
|
_entities = (_l,_l)
|
|
_workplane = True
|
|
_props = [_PropertyRatio]
|
|
|
|
|
|
class LengthDifference(Base):
|
|
_id = 11
|
|
_entities = (_l,_l)
|
|
_workplane = True
|
|
_props = [_PropertyDifference]
|
|
|
|
|
|
class EqualLengthPointLineDistance(Base):
|
|
_id = 12
|
|
_entities = (_p,_l,_l)
|
|
_workplane = True
|
|
|
|
|
|
class EqualPointLineDistance(Base):
|
|
_id = 13
|
|
_entities = (_p,_l,_p,_l)
|
|
_workplane = True
|
|
|
|
|
|
class EqualAngle(Base):
|
|
_id = 14
|
|
_entities = (_l,_l,_l,_l)
|
|
_workplane = True
|
|
_props = [_PropertySupplement]
|
|
|
|
|
|
class EqualLineArcLength(Base):
|
|
_id = 15
|
|
_entities = (_l,_a)
|
|
_workplane = True
|
|
|
|
|
|
class Symmetric(Base):
|
|
_id = 16
|
|
_entities = (_p,_p,_w)
|
|
_workplane = True
|
|
|
|
|
|
class SymmetricHorizontal(Base):
|
|
_id = 17
|
|
_entities = (_p,_p,_w)
|
|
|
|
|
|
class SymmetricVertical(Base):
|
|
_id = 18
|
|
_entities = (_p,_p,_w)
|
|
|
|
|
|
class SymmetricLine(Base):
|
|
_id = 19
|
|
_entities = (_p,_p,_l,_w)
|
|
|
|
|
|
class MidPoint(Base):
|
|
_id = 20
|
|
_entities = (_p,_p,_l)
|
|
_workplane = True
|
|
|
|
|
|
class PointsHorizontal(Base):
|
|
_id = 21
|
|
_entities = (_p,_p)
|
|
_workplane = True
|
|
|
|
|
|
class PointsVertical(Base):
|
|
_id = 22
|
|
_entities = (_p,_p)
|
|
_workplane = True
|
|
|
|
|
|
class LineHorizontal(Base):
|
|
_id = 23
|
|
_entities = [_l]
|
|
_workplane = True
|
|
|
|
|
|
class LineVertical(Base):
|
|
_id = 24
|
|
_entities = [_l]
|
|
_workplane = True
|
|
|
|
|
|
class Diameter(Base):
|
|
_id = 25
|
|
_entities = [_c]
|
|
_prop = [_PropertyDiameter]
|
|
|
|
|
|
class PointOnCircle(Base):
|
|
_id = 26
|
|
_entities = [_p,_c]
|
|
|
|
|
|
class Angle(Base):
|
|
_id = 27
|
|
_entities = (_l,_l)
|
|
_workplane = True
|
|
_props = [_PropertyAngle,_PropertySupplement]
|
|
|
|
|
|
class Perpendicular(Base):
|
|
_id = 28
|
|
_entities = (_l,_l)
|
|
_workplane = True
|
|
|
|
|
|
class Parallel(Base):
|
|
_id = 29
|
|
_entities = (_l,_l)
|
|
_workplane = True
|
|
|
|
|
|
class ArcLineTangent(Base):
|
|
_id = 30
|
|
_entities = (_c,_l)
|
|
_props = [_PropertyAtEnd]
|
|
|
|
|
|
# class CubicLineTangent(Base):
|
|
# _id = 31
|
|
#
|
|
#
|
|
# class CurvesTangent(Base):
|
|
# _id = 32
|
|
|
|
|
|
class EqualRadius(Base):
|
|
_id = 33
|
|
_entities = (_c,_c)
|
|
_props = [_PropertyRadius]
|
|
|
|
|
|
class WhereDragged(Base):
|
|
_id = 34
|
|
_entities = [_p]
|
|
_workplane = True
|
|
|
|
|
|
TypeEnum = namedtuple('AsmConstraintEnum',
|
|
(c.getName() for c in Types))(*range(len(Types)))
|
|
|
|
def attach(obj,checkType=True):
|
|
props = None
|
|
if checkType:
|
|
props = obj.PropertiesList
|
|
if not '_Type' in props:
|
|
raise RuntimeError('Object "{}" has no _Type property'.format(
|
|
objName(obj)))
|
|
if 'Type' in props:
|
|
raise RuntimeError('Object {} already as property "Type"'.format(
|
|
objName(obj)))
|
|
|
|
# The 'Type' property here is to let user select the type in property
|
|
# editor. It is marked as 'transient' to avoid having to save the
|
|
# enumeration value for each object.
|
|
obj.addProperty("App::PropertyEnumeration","Type","Constraint",'',2)
|
|
obj.Type = TypeEnum._fields
|
|
idx = 0
|
|
try:
|
|
idx = TypeMap[obj._Type]._idx
|
|
except AttributeError:
|
|
logger.warn('{} has unknown constraint type {}'.format(
|
|
objName(obj),obj._Type))
|
|
obj.Type = idx
|
|
|
|
constraintType = TypeNameMap[obj.Type]
|
|
cstr = getattr(obj.Proxy,'_cstr',None)
|
|
if type(cstr) is not constraintType:
|
|
if cstr:
|
|
cstr.detach(obj)
|
|
if not props:
|
|
props = obj.PropertiesList
|
|
obj.Proxy._cstr = constraintType(obj,props)
|
|
|
|
|
|
def onChanged(obj,prop):
|
|
if prop == 'Type':
|
|
attach(obj,False)
|
|
return
|
|
elif prop == '_Type':
|
|
obj.Type = TypeMap[obj._Type]._idx
|
|
return
|
|
cstr = getattr(obj.Proxy,'_cstr',None)
|
|
if cstr:
|
|
cstr.onChanged(obj,prop)
|
|
|
|
|
|
def check(tp,group):
|
|
TypeMap[tp].check(group)
|
|
|
|
def prepare(cstr,solver):
|
|
cstr.Proxy._cstr.prepare(cstr,solver)
|
|
|