def GetIntersectedDoubleline(cls, lineList):
"""
Parameters:
lineList: Type list of Rhino.Geometry.Line
Returns:
boolean
two intersected DoubleLine
"""
doubleLineList = []
if len(lineList) == 4:
for i in range(0, 4):
if len(doubleLineList) < 2:
for j in range(i + 1, 4):
if rs.IsVectorParallelTo(lineList[i].Direction,
lineList[j].Direction) != 0:
myDoubleLine = cls(lineList[i], lineList[j])
doubleLineList.append(myDoubleLine)
break
else:
break
if len(doubleLineList) == 2:
if rs.IsVectorParallelTo(doubleLineList[0].direction,
doubleLineList[1].direction) == 0:
if doubleLineList[0].width != 0 and doubleLineList[
1].width != 0:
return (True, doubleLineList)
return (False, None)
def LinearDimJoin(object_id0, object_id1):
annotation_object0 = sc.doc.Objects.Find( object_id0 )
dim0 = annotation_object0.Geometry
annotation_object1 = sc.doc.Objects.Find( object_id1 )
dim1 = annotation_object1.Geometry
if isinstance(dim0, Rhino.Geometry.LinearDimension) and isinstance(dim1, Rhino.Geometry.LinearDimension):
_, extensionLine01End, extensionLine02End, arrowhead01End, arrowhead02End, dimlinepoint0, _ = dim0.Get3dPoints()
_, extensionLine11End, extensionLine12End, arrowhead11End, arrowhead12End, dimlinepoint1, _ = dim1.Get3dPoints()
line0 = geo.Line(arrowhead01End, arrowhead02End)
direct0=rs.VectorUnitize(line0.Direction)
line1 = geo.Line(arrowhead11End, arrowhead12End)
direct1=rs.VectorUnitize(line1.Direction)
if rs.IsVectorParallelTo(direct0, direct1 ) != 0 :
param0 = line0.ClosestParameter(line1.From)
param1 = line0.ClosestParameter(line1.To)
paramDictionary = {
0.0 : extensionLine01End,
1.0 : extensionLine02End,
param0 : extensionLine11End,
param1 : extensionLine12End
}
extensionLineList = []
for key in sorted(paramDictionary.keys()):
extensionLineList.append(paramDictionary[key])
distance0 = line0.DistanceTo(extensionLineList[0],False)
distance1 = line1.DistanceTo(extensionLineList[0],False)
if distance0 > distance1:
rs.AddLinearDimension(dim0.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint0 )
else:
rs.AddLinearDimension(dim1.Plane, extensionLineList[0], extensionLineList[len(extensionLineList)-1], dimlinepoint1 )
rs.DeleteObject(object_id0)
rs.DeleteObject(object_id1)
def findTwoParallelLines():
gp = Rhino.Input.Custom.GetPoint()
gp.SetCommandPrompt("find doubleline by clicking a point")
gp.Get()
if gp.CommandResult() != Rhino.Commands.Result.Success:
print gp.CommandResult()
pi = gp.Point()
obj = gp.PointOnObject()
if obj and isinstance(obj.Object(), Rhino.DocObjects.CurveObject):
if isinstance(obj.Object().CurveGeometry, Rhino.Geometry.LineCurve):
line = obj.Object().CurveGeometry.Line
width = config.DOUBLELINEWIDTHLIMIT[1]
region = getTwoParallelLineSelectionRegion(line.From, line.To, pi,
width)
filter = Rhino.DocObjects.ObjectType.Curve
objects = sc.doc.Objects.FindByCrossingWindowRegion(
sc.doc.Views.ActiveView.MainViewport, region, True, filter)
anotherObj = None
minDistance = config.DOUBLELINEWIDTHLIMIT[1] + 1.0
if objects:
for rhobj in objects:
# rhobj.Select(True)
if isinstance(rhobj.CurveGeometry, Rhino.Geometry.LineCurve
) and rhobj.Id != obj.Object().Id:
anotherLine = rhobj.CurveGeometry.Line
if rs.IsVectorParallelTo(line.Direction,
anotherLine.Direction) != 0:
if anotherLine.DistanceTo(pi, False) < minDistance:
minDistance = anotherLine.DistanceTo(pi, False)
anotherObj = rhobj
return (pi, obj.Object(), anotherObj)
def AddArcDir(ptStart, ptEnd, vecDir):
vecBase = rs.PointSubtract(ptEnd, ptStart)
if rs.VectorLength(vecBase)==0.0: return
if rs.IsVectorParallelTo(vecBase, vecDir): return
vecBase = rs.VectorUnitize(vecBase)
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
dotProd = rs.VectorDotProduct(vecBisector, vecDir)
midLength = (0.5*rs.Distance(ptStart, ptEnd))/dotProd
vecBisector = rs.VectorScale(vecBisector, midLength)
return rs.AddArc3Pt(ptStart, rs.PointAdd(ptStart, vecBisector), ptEnd)
def __init__(self, line0, line1):
# initialized by two Rhino.Geometry.Line
self.isDoubleLine = True
self.direction = None
self.line0 = None
self.line1 = None
self.width = 0
direction0 = rs.VectorUnitize(line0.Direction)
self.direction = direction0
# not parallel
if rs.IsVectorParallelTo(direction0,
rs.VectorUnitize(line1.Direction)) == 0:
self.isDoubleLine = False
else:
# parallel but in oppersite direction
if rs.IsVectorParallelTo(direction0,
rs.VectorUnitize(line1.Direction)) == -1:
line1.Flip()
# find the closest point to line1's start point
line0ClosePoint = line0.ClosestPoint(line1.From, False)
vector = rs.VectorCreate(line1.From, line0ClosePoint)
distance = rs.Distance(line1.From, line0ClosePoint)
if distance >= config.DOUBLELINEWIDTHLIMIT[
0] and distance <= config.DOUBLELINEWIDTHLIMIT[1]:
self.width = distance
angle = rs.Angle(
(0, 0, 0),
rs.VectorRotate(vector, -rs.Angle(line0.From, line0.To)[0],
(0, 0, 1)))
if abs(angle[0] - 90) < sc.doc.ModelAbsoluteTolerance:
self.line0 = line1
self.line1 = line0
elif abs(angle[0] + 90) < sc.doc.ModelAbsoluteTolerance:
self.line0 = line0
self.line1 = line1
def Cremona1(no, nomes, Linhas, countPF, dicPF):
ptos1 = []
dicUp = {}
for i in range(countPF):
if i == 0:
Spt = dicPF[nomes[i]].PointAt(0)
Ept = dicPF[nomes[i]].PointAt(1)
else:
if i == 1:
cond1 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(1), Tol)
cond2 = rs.PointCompare(dicPF[nomes[i - 1]].PointAt(0),
dicPF[nomes[i]].PointAt(0), Tol)
if cond1 or cond2:
pAux3 = Spt
Spt = Ept
Ept = pAux3
if rs.PointCompare(Ept, dicPF[nomes[i]].PointAt(1), Tol):
ptAux1 = dicPF[nomes[i]].PointAt(1)
ptAux2 = dicPF[nomes[i]].PointAt(0)
else:
ptAux1 = dicPF[nomes[i]].PointAt(0)
ptAux2 = dicPF[nomes[i]].PointAt(1)
Ept += (ptAux2 - ptAux1)
F1 = rs.AddLine(Ept, Spt)
#verificar o paralelismo entre F1 no PF e FG
vec1 = rs.VectorCreate(rs.CurveEndPoint(Linhas[-1]),
rs.CurveStartPoint(Linhas[-1]))
vec2 = rs.VectorCreate(Spt, Ept)
if rs.IsVectorParallelTo(vec2, vec1):
print '______Paralelismo______'
#colovcando F1 no dicionario do PF
dicUp[nomes[-1]] = rs.coerceline(F1)
#-cargas e nomenclatura
#teste de tração e compressão
sin1 = TraComp(no, F1, rs.coerceline(Linhas[-1]), nomes[-1])
#valores das cargas
carga1 = rs.CurveLength(F1) * sin1 / Escala
#teste de tensão admissivel
cor1 = teste_elemento(nomes[-1], carga1, Linhas[-1])
#nomenclatura do FG
txt1 = nomes[-1] + ' = ' + str('%.2f' % carga1)
pt1 = rs.coerceline(Linhas[-1]).PointAt(.5)
ptos1 += [pt1, txt1, cor1]
#nomenclatura do PF
pt1 = rs.coerceline(F1).PointAt(.5)
txt1 = nomes[-1]
ptos1 += [pt1, txt1, cor1]
return dicUp, ptos1
def surface_border_kinks(surface_guid):
kinks = []
borders = surface_borders(surface_guid)
for curve_guid in borders:
start_tgt = rs.CurveTangent(curve_guid,
rs.CurveParameter(curve_guid, 0))
end_tgt = rs.CurveTangent(curve_guid, rs.CurveParameter(curve_guid, 1))
if not rs.IsCurveClosed(curve_guid) or not rs.IsVectorParallelTo(
start_tgt, end_tgt):
start = rs.CurveStartPoint(curve_guid)
end = rs.CurveEndPoint(curve_guid)
if start not in kinks:
kinks.append(start)
if end not in kinks:
kinks.append(end)
return kinks
def addArc(startPt, endPt, vecDir):
vecBase = rs.PointSubtract(endPt, startPt)
if rs.VectorLength(vecBase) == 0.0:
return
if rs.IsVectorParallelTo(vecBase, vecDir):
return
vecBase = rs.VectorUnitize(vecBase)
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
midlength = (0.5*rs.Distance(startPt, endPt)) / (rs.VectorDotProduct(vecBisector, vecDir))
vecBisector = rs.VectorScale(vecBisector, midlength)
return rs.AddArc3Pt(startPt, endPt, rs.PointAdd(startPt, vecBisector))
def addArcDiv(ptStart, ptEnd, vecDir):
vecBase = rs.PointSubtract(ptEnd, ptStart)
# error handling
if rs.VectorLength(vecBase) == 0.0: return
if rs.IsVectorParallelTo(vecBase, vecDir): return
vecBase = rs.VectorUnitize(
vecBase
) # normalize vector == force magnitude to 1 to just compare direction
vecDir = rs.VectorUnitize(vecDir)
vecBisector = rs.VectorAdd(vecDir, vecBase)
vecBisector = rs.VectorUnitize(vecBisector)
dotProd = rs.VectorDotProduct(vecBisector, vecDir)
midLength = (0.5 * rs.Distance(ptStart, ptEnd)) / dotProd
vecBisector = rs.VectorScale(vecBisector, midLength)
return rs.AddArc3Pt(ptStart, rs.PointAdd(pt.Start, vecBisector), ptEnd)
def automatic_constraints(mesh, surface_constraint, curve_constraints = [], point_constraints = []):
"""Defines the constraints on the vertices of the mesh on a point, a curve or a surface.
Parameters
----------
mesh : Mesh
A mesh.
surface_constraint : Rhino surface guid
A surface to project vertices.
curve_constraints : Rhino curve guids
Curve features on surface to constrain vertices.
point_constraints : Rhino point guids
Point features on surface to constrain vertices.
Returns
-------
constraints: dict
Dictionary of constraints {vertex_key: (constraint_type, constraint_information)}.
Raises
------
-
"""
constraints = {}
surface_boundaries = surface_borders(surface_constraint, border_type = 0)
# set point constraints at point feature, curve feature extremities and boundary curve corners
constrained_points = []
for curve_guid in surface_boundaries:
start_tgt = rs.CurveTangent(curve_guid, rs.CurveParameter(curve_guid, 0))
end_tgt = rs.CurveTangent(curve_guid, rs.CurveParameter(curve_guid, 1))
# add only if not closed or closed with a kink
if not rs.IsCurveClosed(curve_guid) or not rs.IsVectorParallelTo(start_tgt, end_tgt):
start = geometric_key(rs.CurveStartPoint(curve_guid))
end = geometric_key(rs.CurveEndPoint(curve_guid))
if start not in constrained_points:
constrained_points.append(start)
if end not in constrained_points:
constrained_points.append(end)
for vkey in mesh.vertices():
xyz = mesh.vertex_coordinates(vkey)
geom_key = geometric_key(xyz)
if geom_key in constrained_points:
constraints[vkey] = ['point', xyz]
# set boundary curve constraints
split_vertices = [vkey for vkey, constraint in constraints.items() if constraint[0] == 'point']
split_mesh_boundaries = mesh_boundaries(mesh, vertex_splits = split_vertices)
# constrain a mesh boundary to a surface boundary if the two extremities of the mesh boundary are on the surface boundary
for mesh_bdry in split_mesh_boundaries:
if mesh_bdry[0] == mesh_bdry[-1]:
crv_cstr = None
for vkey in mesh_bdry:
xyz = mesh.vertex_coordinates(vkey)
for srf_bdry in surface_boundaries:
if is_point_on_curve(srf_bdry, xyz):
crv_cstr = srf_bdry
break
if crv_cstr is not None:
break
if crv_cstr is not None:
for vkey in mesh_bdry:
xyz = mesh.vertex_coordinates(vkey)
if is_point_on_curve(crv_cstr, xyz) and vkey not in constraints:
constraints[vkey] = ['curve', crv_cstr]
for i, vkey in enumerate(mesh_bdry):
if vkey not in constraints:
# find next contrained point
n_plus = 1
norm_t_plus = None
count = len(mesh_bdry)
while count > 0:
count -= 1
vkey_plus = mesh_bdry[i + n_plus - len(mesh_bdry)]
if vkey_plus in constraints:
norm_t_plus = rs.CurveNormalizedParameter(crv_cstr, rs.CurveClosestPoint(crv_cstr, mesh.vertex_coordinates(vkey_plus)))
else:
n_plus += 1
# find previous contrained point
n_minus = 1
norm_t_minus = None
count = len(mesh_bdry)
while count > 0:
count -= 1
vkey_minus = mesh_bdry[i - n_minus]
if vkey_minus in constraints:
norm_t_minus = rs.CurveNormalizedParameter(crv_cstr, rs.CurveClosestPoint(crv_cstr, mesh.vertex_coordinates(vkey_minus)))
else:
n_minus += 1
# calculate barycentric parameter and move to it
# dichotomy required in case of curve seam being between the two parameters
#print n_minus, norm_t_minus, n_plus, norm_t_plus
if norm_t_minus == norm_t_plus:
norm_t = (norm_t_plus + .5) % 1
elif norm_t_minus < norm_t_plus:
norm_t = (n_minus * norm_t_plus + n_plus * norm_t_minus) / (n_minus + n_plus)
else:
norm_t_plus += 1
norm_t = (n_minus * norm_t_plus + n_plus * norm_t_minus) / (n_minus + n_plus)
# update coordiantes
t = rs.CurveParameter(crv_cstr, norm_t)
x, y, z = rs.EvaluateCurve(crv_cstr, t)
attr = mesh.vertex[vkey]
attr['x'] = x
attr['y'] = y
attr['z'] = z
# store constraint
constraints[vkey] = ['curve', crv_cstr]
else:
for srf_bdry in surface_boundaries:
start_xyz = mesh.vertex_coordinates(mesh_bdry[0])
end_xyz = mesh.vertex_coordinates(mesh_bdry[-1])
# if the mesh boundary extremities match the ones of the curve boundary...
if is_point_on_curve(srf_bdry, start_xyz) and is_point_on_curve(srf_bdry, end_xyz):
# ... and if there is an intermediary mesh boundary vertex on this curve boundary (needed for two-sided boundary elements)
to_constrain = False
for vkey in mesh_bdry[1 : -1]:
if is_point_on_curve(srf_bdry, mesh.vertex_coordinates(vkey)):
to_constrain = True
if to_constrain:
crv_cstr = srf_bdry
for vkey in mesh_bdry:
xyz = mesh.vertex_coordinates(vkey)
if is_point_on_curve(crv_cstr, xyz) and vkey not in constraints:
constraints[vkey] = ['curve', crv_cstr]
for i, vkey in enumerate(mesh_bdry):
if vkey not in constraints:
# find next contrained point
n_plus = 1
norm_t_plus = None
count = len(mesh_bdry)
while count > 0:
count -= 1
vkey_plus = mesh_bdry[i + n_plus - len(mesh_bdry)]
if vkey_plus in constraints:
norm_t_plus = rs.CurveNormalizedParameter(crv_cstr, rs.CurveClosestPoint(crv_cstr, mesh.vertex_coordinates(vkey_plus)))
else:
n_plus += 1
# find previous contrained point
n_minus = 1
norm_t_minus = None
count = len(mesh_bdry)
while count > 0:
count -= 1
vkey_minus = mesh_bdry[i - n_minus]
if vkey_minus in constraints:
norm_t_minus = rs.CurveNormalizedParameter(crv_cstr, rs.CurveClosestPoint(crv_cstr, mesh.vertex_coordinates(vkey_minus)))
else:
n_minus += 1
# calculate barycentric parameter and move to it
# dichotomy required in case of curve seam being between the two parameters
#print n_minus, norm_t_minus, n_plus, norm_t_plus
if norm_t_minus == norm_t_plus:
norm_t = (norm_t_plus + .5) % 1
elif norm_t_minus < norm_t_plus:
norm_t = (n_minus * norm_t_plus + n_plus * norm_t_minus) / (n_minus + n_plus)
else:
norm_t_plus += 1
norm_t = (n_minus * norm_t_plus + n_plus * norm_t_minus) / (n_minus + n_plus)
# update coordiantes
t = rs.CurveParameter(crv_cstr, norm_t)
x, y, z = rs.EvaluateCurve(crv_cstr, t)
attr = mesh.vertex[vkey]
attr['x'] = x
attr['y'] = y
attr['z'] = z
# store constraint
constraints[vkey] = ['curve', crv_cstr]
# constrain to point features
point_constraints_keys = [geometric_key(rs.PointCoordinates(pt)) for pt in point_constraints]
for vkey in mesh.vertices():
xyz = mesh.vertex_coordinates(vkey)
geom_key = geometric_key(xyz)
if geom_key in point_constraints_keys:
constraints[vkey] = ['point', xyz]
# constrain to curve features
for crv in curve_constraints:
# extremities
start = rs.CurveStartPoint(crv)
start_geom_key = geometric_key(start)
end = rs.CurveEndPoint(crv)
end_geom_key = geometric_key(end)
for vkey in mesh.vertices():
xyz = mesh.vertex_coordinates(vkey)
geom_key = geometric_key(xyz)
if geom_key == start_geom_key:
constraints[vkey] = ['point', xyz]
start_key = vkey
if geom_key == end_geom_key:
constraints[vkey] = ['point', xyz]
end_key = vkey
# regular nodes
path = [start_key]
for nbr in mesh.vertex_neighbors(start_key):
completed = False
if mesh.is_vertex_on_boundary(nbr):
continue
path.append(nbr)
count = len(list(mesh.vertices()))
while count > 0:
count -= 1
u, v = path[-2], path[-1]
fkey = mesh.halfedge[u][v]
x = mesh.face_vertex_descendant(fkey, v)
fkey = mesh.halfedge[x][v]
w = mesh.face_vertex_descendant(fkey, v)
path.append(w)
if w == end_key:
completed = True
break
elif mesh.is_vertex_on_boundary(w) or len(mesh.vertex_neighbors(w)) != 4:
break
if completed:
break
else:
path = [start_key]
for vkey in path[1 : -1]:
constraints[vkey] = ['curve', crv]
# set surface constraints by default for the others
for vkey in mesh.vertices():
if vkey not in constraints:
constraints[vkey] = ['surface', surface_constraint]
# udpdate drawn mesh
layer = 'pattern_topology'
mesh_guid = rs.ObjectsByLayer(layer)[0]
rs.DeleteObject(mesh_guid)
mesh_guid = draw_mesh(mesh)
rs.ObjectLayer(mesh_guid, layer)
return constraints, surface_boundaries
