def grow(self, side):
newBranches = []
if len(self.branches) == 0:
self.startBranch()
for i in range(len(self.branches)):
self.pullBranch(self.branches[i])
axis01 = self.findAxis(self.branches[i].end01)
axis02 = self.findAxis(self.branches[i].end02)
if rs.VectorAngle(self.branches[i].axis,
axis01) < 60 and side == 1:
param = rs.CurveClosestPoint(self.path, self.branches[i].end01)
dist = rs.Distance(self.branches[i].end01,
rs.EvaluateCurve(self.path, param))
tan = rs.CurveTangent(self.path, param)
newBranches.append(
branch(self.branches[i].end01, self.branches[i].vec01,
self.ang, axis01))
if rs.VectorAngle(self.branches[i].axis,
axis02) < 60 and side == 2:
param = rs.CurveClosestPoint(self.path, self.branches[i].end02)
dist = rs.Distance(self.branches[i].end02,
rs.EvaluateCurve(self.path, param))
tan = rs.CurveTangent(self.path, param)
vecAng = rs.VectorAngle(self.branches[i].vec02, tan)
vec = rs.VectorRotate(self.branches[i].vec02, -vecAng / 5,
axis02)
newBranches.append(
branch(self.branches[i].end02, self.branches[i].vec02,
self.ang, axis02))
self.branches = []
self.branches.extend(newBranches)
return self.branches
def offset_face(mesh, fkey, t):
cent = mesh.face_centroid(fkey)
vcords = mesh.face_coordinates(fkey, ordered=True)
vkeys = mesh.face_vertices(fkey, ordered=True)
pts = []
vecs = []
keys = [None] * len(vcords)
for i, vcor in enumerate(vcords):
vec1 = rs.VectorUnitize(rs.VectorCreate(vcords[i - 2], vcords[i - 1]))
vec2 = rs.VectorUnitize(rs.VectorCreate(vcords[i], vcords[i - 1]))
vec = rs.VectorAdd(vec1, vec2)
vec = rs.VectorUnitize(vec)
ang = rs.VectorAngle(vec, vec1)
ang = math.radians(ang)
l = t / math.sin(ang)
vec = rs.VectorScale(vec, l)
pt = rs.PointAdd(vcords[i - 1], vec)
keys[i - 1] = mesh.add_vertex(x=pt[0], y=pt[1], z=pt[2])
for i, vkey in enumerate(vkeys):
mesh.add_face([vkeys[i], keys[i], keys[i - 1], vkeys[i - 1]])
mesh.add_face(keys)
del mesh.face[fkey]
def get_reference_vector(b_obj): """pick a reference vector for deciding surface category. note that we can't pick [0,1,0] because the brep might be on a 45deg angle.""" base_ref_vect = rs.VectorCreate([0,1,0],[0,0,0]) up = rs.coerce3dvector([0,0,1]) down = rs.coerce3dvector([0,0,-1]) epsilon = 0.5 faces = b_obj.Faces print faces.Count ref_faces = [] ref_angle_rotation = 90 for k in faces: v = k.NormalAt(0.5,0.5) #top and botom of extrusion have IsSurface = False (why?) if not (v.EpsilonEquals(up,epsilon) or v.EpsilonEquals(down,epsilon)): ref_faces.append(k) angle = rs.VectorAngle(v,base_ref_vect) angle = angle%90 print angle ref_angle_rotation = min(ref_angle_rotation,angle) new_ref_vector = rs.VectorRotate(base_ref_vect,ref_angle_rotation,[0,0,1]) #debug: verify this angle is good # for k in faces: # v = k.NormalAt(0.5,0.5) #top and botom of extrusion have IsSurface = False (why?) # if not (v.EpsilonEquals(up,epsilon) or v.EpsilonEquals(down,epsilon)): # ref_faces.append(k) # angle = rs.VectorAngle(v,new_ref_vector) # angle = angle%180 # print angle return new_ref_vector
def CreateRectangles(self):
futureVel = self.vel.Clone()
futurePos = self.pos.Clone()
futureVel += self.acc
futurePos += futureVel
n0 = self.plane.ZAxis
n1 = futureVel
vecAngle = rs.VectorAngle(n0, n1)
cross = rg.Vector3d.CrossProduct(n0, n1)
self.plane.Rotate(math.radians(vecAngle), cross, self.pos)
self.plane.Origin = self.pos
#self.plane.Origin = self.pos
#self.plane.ZAxis = futureVel
#self.plane.UpdateEquation()
#self.plane = rg.Plane(self.pos, futureVel)
rect = rg.Rectangle3d(self.plane, self.size, self.size)
rect = rect.ToNurbsCurve()
#sc.doc.Objects.AddCurve(rect)
self.history.append(rect)
self.historyPos.append(self.pos)
def radiationForVector(vec, genCumSkyResult, TregenzaPatchesNormalVectors = lb_preparation.TregenzaPatchesNormalVectors):
radiation = 0; patchNum = 0;
for patchNum, patchVec in enumerate(TregenzaPatchesNormalVectors):
vecAngle = rs.VectorAngle(patchVec, vec)
if vecAngle < 90:
radiation = radiation + genCumSkyResult[patchNum] * math.cos(math.radians(vecAngle))
return radiation
def mergeCoincidentLines(segments):
"""
removes coincident, consecutive segments
input: List of GUIDs
returns: List of GUIDs
"""
newSegments = []
i = 0
while i < len(segments):
if (i < len(segments) - 1): #if coincident, delete both, add new.
a = rs.VectorCreate(rs.CurveStartPoint(segments[i]),
rs.CurveEndPoint(segments[i]))
b = rs.VectorCreate(rs.CurveStartPoint(segments[i + 1]),
rs.CurveEndPoint(segments[i + 1]))
a = rs.VectorUnitize(a)
b = rs.VectorUnitize(b)
aAng = rs.VectorAngle(a, b)
if (aAng < .00001):
newLine = rs.AddLine(rs.CurveStartPoint(segments[i]),
rs.CurveEndPoint(segments[i + 1]))
rs.DeleteObject(segments[i])
rs.DeleteObject(segments[i + 1])
newSegments.append(newLine)
i = i + 2
else:
newSegments.append(
segments[i]) #if not coincident, add to array
i = i + 1
else:
newSegments.append(segments[i]) #add last seg to array
i = i + 1
return newSegments
def orientObjAlongPolyPts(obj, pts, basePoint=(0, 0, 0), baseVect=(0, 1, 0)):
print('orient obj along poly points')
up = (0, 0, 1)
generatedObjects = []
for i in range(0, len(pts) - 1):
if i < (len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
n1 = rs.VectorCrossProduct(v1, up)
n2 = rs.VectorCrossProduct(v2, up)
mid = rs.VectorAdd(n1, n2)
n = rs.VectorUnitize(mid)
else:
p0 = pts[i]
p1 = pts[i + 1]
v1 = rs.VectorUnitize(p1 - p0)
n = rs.VectorCrossProduct(v1, up)
rs.AddLine(p1, p1 + n)
a = rs.VectorAngle((0, 1, 0), n)
gen = rs.OrientObject(obj, [basePoint, basePoint + baseVect],
[p1, p1 + n], 1)
generatedObjects.append(gen)
#g=rs.AddGroup()
#groupObjects=rs.AddObjectsToGroup(generatedObjects,g)
return generatedObjects
def update(self):
print('update')
#delete last generated objects
try:
rs.DeleteObjects(self.generatedObjs)
self.generatedObjs = []
except:
print('exception in delete generated object')
divWidth = 600
crv = self.baseCrv
if not rs.IsObject(crv):
print('crv is not an object')
return
if not rs.IsPolyline(crv):
pts = rs.DivideCurveEquidistant(crv, divWidth)
rail = rs.AddPolyline(pts)
else:
rail = rs.CopyObject(crv)
pts = rs.CurveEditPoints(rail)
if len(pts) < 3:
print('too little points')
return
#find vectors to move and orient the profile
vect = pts[1] - pts[0]
vect = rs.VectorUnitize(vect)
a = rs.VectorAngle(vect, (0, 1, 0)) - 90
#load the component
path = self.loadPath
component = None
try:
component = importComponent(path)
except:
print('exception on importing module')
if component is None:
print('component is None')
return None
#rs.MoveObjects(component.breps,pts[0])
#rs.RotateObjects(component.breps,pts[0],a)
for b in component.breps:
self.generatedObjs.append(b)
oriented = orientObjAlongPolyPts(b, pts)
print('pts count:', len(pts), ' num gen:', len(oriented))
rs.MoveObjects(component.polys, pts[0])
rs.RotateObjects(component.polys, pts[0], a)
for c in component.polys:
self.generatedObjs.append(c)
mesh = meshSwipPolyAlongPoly(c, rail)
self.generatedObjs.append(mesh)
rs.DeleteObject(rail)
print('generated obj count:', len(self.generatedObjs))
rs.AddGroup('gen')
rs.AddObjectsToGroup(self.generatedObjs, 'gen')
def CreateRectangles(self):
futureVel = self.vel.Clone()
futurePos = self.pos.Clone()
futureVel += self.acc
futurePos += futureVel
n0 = self.plane.ZAxis
n1 = futureVel
vecAngle = rs.VectorAngle(n0, n1)
cross = rg.Vector3d.CrossProduct(n0, n1)
self.plane.Rotate(math.radians(vecAngle), cross, self.pos)
self.plane.Origin = self.pos
self.plane.Rotate(math.radians(1), self.plane.Normal)
#pts = [rg.Point3d(self.size/2, self.size, 0), rg.Point3d(self.size/2, -self.size, 0), rg.Point3d(-self.size/2, -self.size, 0), rg.Point3d(-self.size/2, self.size, 0), rg.Point3d(self.size/2, self.size, 0)]
pts = [rg.Point3d(self.size/2, self.size, 0), rg.Point3d(self.size/2, -self.size, 0), rg.Point3d(-self.size/2, -self.size, 0), rg.Point3d(-self.size/2, self.size, 0)]
nurb = rg.NurbsCurve.Create(True, 3, pts)
self.plane = rg.Plane(self.pos, self.vel)
circ = rg.Circle(self.plane, self.size)
circ = circ.ToNurbsCurve()
xform = rg.Transform.PlaneToPlane(rg.Plane.WorldXY, self.plane)
nurb.Transform(xform)
rect = rg.Rectangle3d(self.plane, rg.Interval(-self.size, self.size), rg.Interval(-self.size, self.size))
rect = rect.ToNurbsCurve()
#sc.doc.Objects.AddCurve(rect)
self.history.append(circ)
self.historyPos.append(self.pos)
def angAttractor(attPt,testPt,baseVec,baseAng,thres,max):
compare=rs.VectorCreate(attPt,testPt)
editAng=rs.VectorAngle(baseVec,compare)
ang=baseAng+(1-setAttractor(attPt,testPt,thres,0))*(editAng-baseAng)
if ang>max:
ang=max
return ang
def get_face_category(f,v): """pick category: 0: side srfs that get extended 1: side srfs that get shortened 2: top surfaces""" normal = f.NormalAt(0.5,0.5) epsilon = 0.5 up = rs.coerce3dvector([0,0,1]) down = rs.coerce3dvector([0,0,-1]) compare_angle = min(rs.VectorAngle(normal,v),rs.VectorAngle(normal,rs.VectorReverse(v))) if normal.EpsilonEquals(up,epsilon) or normal.EpsilonEquals(down,epsilon): return 2 elif 88 < compare_angle < 92: return 1 else: return 0
def setAngleOfBaseSurface(self):
tmpVector = (0, 0, 1)
self.angleOfSurface = rs.VectorAngle(tmpVector, self.normalVec)
#for debug
if self.angleOfSurface < 0 or self.angleOfSurface > 90:
print('self.angleOfSurface is wseird')
def edgeAngle(myMesh, edgeIndex):
#TODO: make myMesh function which findes angel between two faces of a given edge
faceIdxs = myMesh.getFacesForEdge(edgeIndex)
if (len(faceIdxs) == 2):
faceNorm0 = myMesh.face_normal(faceIdxs[0])
faceNorm1 = myMesh.face_normal(faceIdxs[1])
return rs.VectorAngle(faceNorm0, faceNorm1)
else:
return None
def grow(self):
newBranches = []
if len(self.branches) == 0:
self.startBranch()
for i in range(len(self.branches)):
self.pullBranch(self.branches[i])
axis01 = self.findAxis(self.branches[i].end01)
axis02 = self.findAxis(self.branches[i].end02)
if rs.VectorAngle(self.branches[i].axis, axis01) < 60:
newBranches.append(
branch(self.branches[i].end01, self.branches[i].vec01,
self.ang, axis01))
if rs.VectorAngle(self.branches[i].axis, axis02) < 60:
newBranches.append(
branch(self.branches[i].end02, self.branches[i].vec02,
self.ang, axis02))
self.branches = []
self.branches.extend(newBranches)
return self.branches
def getTabAngles(self, mesh, currFaceIdx, xForm):
# WORKING AWAY FROM THIS: data is implicit in tabFace center
edge = self.meshEdgeIdx
otherFace = getOtherFaceIdx(edge, currFaceIdx, mesh)
if otherFace is not None:
faceCenter = mesh.Faces.GetFaceCenter(otherFace) # Point3d
if getDistanceToEdge(mesh, edge, faceCenter) <= self.tabWidth:
faceCenter.Transform(xForm)
self.tabFaceCenter = faceCenter
else:
posVecCenter = Rhino.Geometry.Vector3d(faceCenter)
pntI, pntJ = getPointsForEdge(mesh, edge) # Point3d
vecEdge = getEdgeVector(mesh, edge) # Vector3d
posVecI = Rhino.Geometry.Vector3d(pntI)
posVecJ = Rhino.Geometry.Vector3d(pntJ)
vecI = Rhino.Geometry.Vector3d.Subtract(posVecCenter, posVecI)
vecJ = Rhino.Geometry.Vector3d.Subtract(posVecJ, posVecCenter)
angleI = rs.VectorAngle(vecI, vecEdge)
angleJ = rs.VectorAngle(vecJ, vecEdge)
self.tabAngles = [angleI, angleJ]
"""
color = (0,0,0,0)
drawVector(vecI,posVecI,color)
drawVector(vecJ,posVecCenter,color)
strI = str(angleI)
strJ = str(angleJ)
rs.AddTextDot(strI,posVecI)
rs.AddTextDot(strJ,posVecJ)
print #wtf: for some reason needed this line to print below
print( 'angleI: %.2f, angleJ: %.2f' %(angleI,angleJ) )
"""
elif otherFace == -1:
print "was nakedEdge"
else:
print "otherFace: ",
print otherFace
def grow(self):
newBranches = []
print(self.ang)
first = False
if len(self.branches) == 0:
self.startBranch()
first = True
for i in range(len(self.branches)):
self.pullBranch(self.branches[i])
axis01 = self.findAxis(self.branches[i].end01)
axis02 = self.findAxis(self.branches[i].end02)
b01 = r.random()
b02 = r.random()
if rs.VectorAngle(self.branches[i].axis, axis01) < 60 and b01 < .5:
ang = self.ang * r.random()
self.branches[i].vec01 = rs.VectorUnitize(
self.branches[i].vec01)
self.branches[i].vec01 = self.branches[i].vec01 * self.len
sc = r.random() + .25
if sc > 1:
sc = 1
v = self.branches[i].vec01 * sc
newBranches.append(
branch(self.branches[i].end01, v, ang, axis01))
if rs.VectorAngle(self.branches[i].axis, axis02) < 60 and b02 < .5:
ang = self.ang * r.random()
self.branches[i].vec02 = rs.VectorUnitize(
self.branches[i].vec02)
self.branches[i].vec02 = self.branches[i].vec02 * self.len
sc = r.random() + .25
if sc > 1:
sc = 1
v = self.branches[i].vec02 * sc
newBranches.append(
branch(self.branches[i].end02, v, self.ang, axis02))
self.branches = []
self.branches.extend(newBranches)
return self.branches
def grow(self):
newBranches = []
if len(self.branches) == 0:
self.startBranch()
for i in range(len(self.branches)):
self.pullBranch(self.branches[i])
axis01 = self.findAxis(self.branches[i].end01)
axis02 = self.findAxis(self.branches[i].end02)
if rs.VectorAngle(self.branches[i].axis, axis01) < 60:
v = rs.VectorCreate(self.branches[i].end01,
self.branches[i].start)
v = rs.VectorScale(v, self.length / rs.VectorLength(v))
newBranches.append(
branch(self.branches[i].end01, v, self.ang, axis01))
if rs.VectorAngle(self.branches[i].axis, axis02) < 60:
v = rs.VectorCreate(self.branches[i].end02,
self.branches[i].start)
v = rs.VectorScale(v, self.length / rs.VectorLength(v))
newBranches.append(
branch(self.branches[i].end02, v, self.ang, axis02))
self.branches = []
self.branches.extend(newBranches)
return self.branches
def AngleABC(a, b, c):
"""AngleABC(a, b, c). As if A-B-C made a polyline, measures the clockwise angle
parameters:
a (pt): first pt
b (pt): elbow between A and C.
c (pt): last point
returns:
clockwise angle in degrees
"""
vec1 = rs.VectorCreate(a, b)
vec2 = rs.VectorCreate(c, b)
inner = rs.VectorAngle(vec1, vec2)
det = vec1[0]*vec2[1]-vec1[1]*vec2[0]
if det<0: return inner
else: return 360-inner
def blkFace(obj):
cameraPos = rs.ViewCamera()
cameraPos.Z = 0
xform = rs.BlockInstanceXform(obj)
plane = rs.PlaneTransform(rs.WorldXYPlane(), xform)
viewdir = rs.VectorUnitize(cameraPos - plane.Origin)
angle = rs.VectorAngle(viewdir, plane.YAxis)
newXform = rs.XformRotation3(plane.YAxis, viewdir, plane.Origin)
rs.TransformObject(obj, newXform)
def assignBlockToPanel(obj):
"""
Assigns block containing a base surface to a surface with the matching name.
Block, base surface, and target surface must all have the same name.
input: target surface (with name)
returns: None
"""
allBlockNames = rs.BlockNames()
for eachBlockName in allBlockNames:
if rs.ObjectName(obj) == eachBlockName:
blockName = eachBlockName
print "Matching Block Found"
objBasePt = rs.SurfaceEditPoints(obj)[0]
objYPt = rs.SurfaceEditPoints(obj)[1]
objXPt = rs.SurfaceEditPoints(obj)[2]
objXVec = rs.VectorCreate(objXPt, objBasePt)
objXLength = rs.VectorLength(objXVec)
objYLength = rs.Distance(objBasePt, objYPt)
blockObjs = rs.BlockObjects(blockName)
for blockObj in blockObjs:
if rs.ObjectName(blockObj) == blockName:
print "Contains base plane"
if rs.IsSurface(blockObj):
blockBasePt = rs.SurfaceEditPoints(blockObj)[0]
blockYPt = rs.SurfaceEditPoints(blockObj)[1]
blockXPt = rs.SurfaceEditPoints(blockObj)[2]
blockXVec = rs.VectorCreate(blockXPt, blockBasePt)
rotAngle = rs.VectorAngle(objXVec, blockXVec)
blockXLength = rs.VectorLength(blockXVec)
blockYLength = rs.VectorLength(
rs.VectorCreate(blockYPt, blockBasePt))
xScale = objXLength / blockXLength
yScale = objYLength / blockYLength
newScale = [yScale, xScale, 1]
rs.InsertBlock(blockName,
objBasePt,
scale=newScale,
angle_degrees=rotAngle)
break
else:
print "Error: Base plane was not a surface"
def detectParalellSurface(self):
#fix layer height
#self.paralellIntersectedCurve
#self.indexParalellSurfaces
explodedSurfaces = rs.ExplodePolysurfaces(self.addtiveObj)
for surface in explodedSurfaces:
#normals.append(rs.SurfaceNormal(surface))
tmpNormal = rs.SurfaceNormal(surface, [0, 0])
gotAngle = rs.VectorAngle(tmpNormal, self.normalVec)
if gotAngle == 0 or gotAngle == 180:
tmpPoints = rs.SurfaceEditPoints(surface)
tmpPlane = rs.PlaneFromNormal(tmpPoints[0], self.normalVec)
distance = rs.DistanceToPlane(tmpPlane, self.basePointForPlane)
distance *= (1.0 / math.cos(math.radians(self.angleOfSurface)))
print("distance")
print(distance)
paralellLayer = int(distance / self.fixedLayerHeight)
if paralellLayer < 0:
paralellLayer *= -1
if paralellLayer == int(
self.distancePrinting /
self.fixedLayerHeight) or int(distance) == 0:
continue
self.indexParalellSurfaces.append(int(paralellLayer))
print("paralellLayer")
print(paralellLayer)
print("layer num")
print(self.distancePrinting / self.fixedLayerHeight)
#there is object to delete
self.paralellIntersectedCurves.append(
rs.JoinCurves(rs.DuplicateEdgeCurves(surface)))
rs.DeleteObjects(explodedSurfaces)
"""
def FaceCamera():
try:
frames = rs.GetObjects("Select Picture Frames",
filter=8,
preselect=True)
# rotate surfaces around z axis towards camera point
if frames:
rs.EnableRedraw(False)
cam = rs.ViewCamera()
camz = (cam.X, cam.Y, 0)
angle = 1
for i in frames:
angle = 1
while angle >= 1:
# get mid point of surface and move to z 0
pointmid = rs.SurfaceAreaCentroid(i)
pointmidz = (pointmid[0].X, pointmid[0].Y, 0)
# Get center UV of surface
domainU = rs.SurfaceDomain(i, 0)
domainV = rs.SurfaceDomain(i, 1)
u = domainU[1] / 2.0
v = domainV[1] / 2.0
# Get normal vector of surface and cam vector
vec1 = rs.SurfaceNormal(i, (u, v))
vec1 = vec1.X, vec1.Y, 0
vec2 = rs.VectorCreate(camz, pointmidz)
# find angle difference between the two vectors
angle = rs.VectorAngle(vec1, vec2)
angle = round(angle)
# Rotate Object
rs.RotateObject(i, pointmidz, angle)
continue
rs.EnableRedraw(True)
except:
print("Failed to execute")
rs.EnableRedraw(True)
return
def trail(self, r):
vectr = [0, 0, 0]
sum = [0, 0, 0]
count = 0
if traillist:
for i in range(len(traillist)):
distan = rs.Distance(self.pos, traillist[i])
vecref = rs.VectorCreate(traillist[i], self.pos)
angl = rs.VectorAngle(self.vel, vecref)
if 0 < distan < r and 0 < angl < 45:
sum = rs.VectorAdd(sum, traillist[i])
count = count + 1
if count > 0:
avep = rs.VectorScale(sum, 1 / count)
vectr = rs.VectorCreate(avep, self.pos)
vectr = vectorlimit(vectr, self.mf)
#if count == 0:
#print(vectr)
return vectr
def makeSliceSurface(surface, maxAngle):
explodedSurfaces = rs.ExplodePolysurfaces(surface)
newSurfaces = []
rs.DeleteObject(surface)
baseVec = (0, 0, 1)
for i in explodedSurfaces:
vec = rs.SurfaceNormal(i, [0, 0])
angle = rs.VectorAngle(baseVec, vec)
if angle > maxAngle:
rs.DeleteObject(i)
else:
newSurfaces.append(i)
joinedSurface = rs.JoinSurfaces(newSurfaces)
return joinedSurface
def UpdateDisplay(self):
if self.id:
sc.doc.Objects.Delete(self.id, True)
growthRate = .05
#Transform start circle scale
xform = rg.Transform.Scale(self.plane.Origin,
(self.size + growthRate) / self.size)
self.size += growthRate
self.endCirc = rg.Circle(self.circ.Plane, self.circ.Radius)
tanEnd = self.path.TangentAt(1)
ptEnd = self.path.PointAt(1)
#Transform circle to end plane
n0 = self.plane.ZAxis
n1 = self.path.TangentAt(1)
vecAngle = rs.VectorAngle(n0, n1)
cross = rg.Vector3d.CrossProduct(n0, n1)
endPlane = self.plane.Clone()
ptEnd = self.path.PointAt(1)
endPlane.Origin = ptEnd
endPlane.Rotate(math.radians(vecAngle), cross, ptEnd)
endPlaneXform = rg.Transform.PlaneToPlane(self.circ.Plane, endPlane)
self.endCirc.Transform(endPlaneXform)
self.circ.Transform(xform)
self.crv0 = rg.Circle(self.circ.Plane, self.circ.Radius)
self.crv0 = self.crv0.ToNurbsCurve()
self.crv1 = rg.Circle(self.endCirc.Plane, self.endCirc.Radius)
self.crv1 = self.crv1.ToNurbsCurve()
loft = rg.Brep()
results = loft.CreateFromLoft([self.crv0, self.crv1], rg.Point3d.Unset,
rg.Point3d.Unset, rg.LoftType.Straight,
False)
self.id = sc.doc.Objects.AddBrep(results[0], self.parent.attr)
def blkFace(obj):
cameraPos = rs.ViewCamera()
cameraPos.Z = 0
plane = rs.WorldXYPlane()
if rs.IsBlockInstance(obj):
plane = blkPlane(obj)
elif rs.IsSurface(obj):
plane = srfPlane(obj)
targetpos = plane.Origin
targetpos.Z = 0
viewdir = rs.VectorUnitize(cameraPos - targetpos)
angle = rs.VectorAngle(viewdir, plane.YAxis)
newXform = rs.XformRotation3(plane.YAxis, viewdir, plane.Origin)
rs.TransformObject(obj, newXform)
def orientObjAlongPolyPts(obj, pts, baseVect=(0, 1, 0)):
up = (0, 0, 1)
for i in range(0, len(pts) - 1):
if i < (len(pts) - 2):
p0 = pts[i]
p1 = pts[i + 1]
p2 = pts[i + 2]
v1 = rs.VectorUnitize(p1 - p0)
v2 = rs.VectorUnitize(p2 - p1)
n1 = rs.VectorCrossProduct(v1, up)
n2 = rs.VectorCrossProduct(v2, up)
mid = rs.VectorAdd(n1, n2)
n = rs.VectorUnitize(mid)
else:
p0 = pts[i]
p1 = pts[i + 1]
v1 = rs.VectorUnitize(p1 - p0)
n = rs.VectorCrossProduct(v1, up)
rs.AddLine(p1, p1 + n)
a = rs.VectorAngle((0, 1, 0), n)
rs.OrientObject(obj, [(0, 0, 0), baseVect], [p1, p1 + n], 1)
def angle(v1, v2):
# rs.VectorAngle returns degrees which is not very convenient
return radians(rs.VectorAngle(v1, v2))
def rc_collapse_box():
go = Rhino.Input.Custom.GetObject()
go.GeometryFilter = Rhino.DocObjects.ObjectType.Brep
default_KeepLayer = sc.sticky["KeepLayer"] if sc.sticky.has_key(
"KeepLayer") else False
default_IgnoreOpen = sc.sticky["IgnoreOpen"] if sc.sticky.has_key(
"IgnoreOpen") else False
opt_KeepLayer = Rhino.Input.Custom.OptionToggle(default_KeepLayer, "No",
"Yes")
opt_IgnoreOpen = Rhino.Input.Custom.OptionToggle(default_IgnoreOpen, "No",
"Yes")
go.SetCommandPrompt("Select Breps")
go.AddOptionToggle("KeepLayer", opt_KeepLayer)
go.AddOptionToggle("IgnoreOpenBreps", opt_IgnoreOpen)
go.GroupSelect = True
go.SubObjectSelect = False
go.AcceptEnterWhenDone(True)
go.AcceptNothing(True)
go.EnableClearObjectsOnEntry(False)
go.EnableUnselectObjectsOnExit(False)
go.GroupSelect = True
go.SubObjectSelect = False
go.DeselectAllBeforePostSelect = False
res = None
bHavePreselectedObjects = True
while True:
res = go.GetMultiple(1, 0)
if res == Rhino.Input.GetResult.Option:
go.EnablePreSelect(False, True)
continue
#If not correct
elif res != Rhino.Input.GetResult.Object:
rs.Redraw()
print "No breps were selected!"
return Rhino.Commands.Result.Cancel
if go.ObjectsWerePreselected:
rs.Redraw()
bHavePreselectedObjects = True
go.EnablePreSelect(False, True)
continue
break
OPT_IGNORE_OPEN = opt_IgnoreOpen.CurrentValue
OPT_KEEP_LAYER = opt_KeepLayer.CurrentValue
sticky["IgnoreOpen"] = OPT_IGNORE_OPEN
sticky["KeepLayer"] = OPT_KEEP_LAYER
rs.EnableRedraw(False)
input_breps = []
for i in xrange(go.ObjectCount):
b_obj = go.Object(i).Object()
input_breps.append(b_obj.Id)
current_cplane = sc.doc.Views.ActiveView.ActiveViewport.GetConstructionPlane(
)
temp_cplane = current_cplane.Plane
current_cplane.Plane = rs.WorldXYPlane()
solid_brep_count = 0
for brep in input_breps:
if not rs.IsObjectSolid(brep):
solid_brep_count += 1
if OPT_IGNORE_OPEN: continue
if OPT_KEEP_LAYER: brep_layer = rs.ObjectLayer(rs.coerceguid(brep))
exploded = rs.ExplodePolysurfaces(brep, True)
remaining_srfs = []
for srf in exploded:
norm = rs.SurfaceNormal(srf, [0.5, 0.5])
if 10 > rs.VectorAngle(norm, [0, 0, 1]) or 10 > rs.VectorAngle(
norm, [0, 0, -1]):
rs.DeleteObject(srf)
else:
remaining_srfs.append(srf)
areas = [rs.SurfaceArea(s) for s in remaining_srfs]
areas = [x[0] for x in areas]
srfs, areas = zip(
*sorted(zip(remaining_srfs, areas), key=lambda x: x[1]))
pt1, _ = rs.SurfaceAreaCentroid(srfs[-1])
pt2, _ = rs.SurfaceAreaCentroid(srfs[-2])
vect = rs.VectorCreate(pt2, pt1)
vect = rs.VectorDivide(vect, 2)
rs.MoveObject(srfs[-1], vect)
if OPT_KEEP_LAYER: rs.ObjectLayer(srfs[-1], brep_layer)
rs.SelectObjects(srfs[-1])
rs.DeleteObjects(srfs[:-1])
rs.EnableRedraw(True)
rs.Redraw()
current_cplane.Plane = temp_cplane
if solid_brep_count > 0:
outcome = " and were not collapsed." if OPT_IGNORE_OPEN else " and may have been flattened incorrectly. Check input geometry."
report = str(solid_brep_count) + " brep(s) were not closed" + outcome
print report
for v_list, r_list in zip(_sphere_testVec.Branches,
_sphere_radiation.Branches):
for v, r in zip(v_list, r_list):
objs.append(OrientationRad(r, v))
# Find the closest Sphere segment to the window (based on srfc normal)
# Calc shading factor
# ------------------------------------------------------------------------------
win_radiation_ = []
sphere_segment_radiation_ = []
win_shading_factor_ = []
max_error = 0
for window in windows:
smallest_angle = 360
for obj in objs:
angle_diff = rs.VectorAngle(obj.srfc_normal, window.srfc_normal)
if angle_diff < smallest_angle:
closestRadVal = obj.radiation
smallest_angle = angle_diff
win_radiation_.append(window.radiation)
sphere_segment_radiation_.append(closestRadVal)
win_shading_factor_.append(window.radiation / closestRadVal)
if smallest_angle > max_error:
max_error = smallest_angle
