def IsPointInside(meshId, pt, tolerance = 1e-6):
faceVerts = rs.MeshFaces(meshId, face_type=False)
totalAngle = 0
i = 0
while i < len(faceVerts):
ptA = faceVerts[i]
ptB = faceVerts[i + 1]
ptC = faceVerts[i + 2]
a = rs.VectorSubtract(ptA, pt)
b = rs.VectorSubtract(ptB, pt)
c = rs.VectorSubtract(ptC, pt)
angle = GetSolidAngle(a,b,c)
normal = Normal(ptA, ptB, ptC)
center = Centroid(ptA, ptB, ptC)
faceVec = rs.VectorSubtract(pt, center)
dot = rs.VectorDotProduct(normal, faceVec)
factor = 1 if dot > 0 else -1
totalAngle += angle * factor
i += 3
absTotal = abs(totalAngle)
inside = abs(absTotal - (4*math.pi)) < tolerance
print("The total solid angle is %.02fPI"%(absTotal/math.pi))
return inside
def Main():
jointno = 4
list = []
dir0 = rs.GetPoint("from")
dir1 = rs.GetPoint("hub")
dir2 = rs.GetPoints(False, False, "outline_left_to_right")
#THIS VECTOR WILL ALLOW US TO TAKE INTO ACCOUNT POSSIBLE LAYOUT OF DRAWN JOINTS ON THE PAGE
fix = rs.VectorSubtract([0, 0, 0], dir1)
dir0 = rs.VectorAdd(dir0, fix)
dir1 = rs.VectorAdd(dir1, fix)
indir = rs.VectorSubtract(dir1, dir0)
for j in range(len(dir2)):
pt = rs.VectorAdd(dir2[j], fix)
dir2[j] = pt
list.append([dir1, indir, dir2])
for i in (range(jointno)[1:]):
dir0 = rs.GetPoint("from")
dir1 = rs.GetPoint("hub")
dir2 = rs.GetPoint("to")
#THIS VECTOR WILL ALLOW US TO TAKR INTO ACCOUNT POSSIBLE LAYOUT OF DRAWN JOINTS ON THE PAGE
fix = rs.VectorSubtract([0, 0, 0], dir1)
#What is this line doing???
dir0 = rs.VectorAdd(dir0, fix)
dir1 = rs.VectorAdd(dir1, fix)
dir2 = rs.VectorAdd(dir2, fix)
#Setting up direction vectors!
indir = rs.VectorSubtract(dir1, dir0)
outdir = rs.VectorSubtract(dir2, dir1)
lside = rs.GetPoints(False, False, "left")
rside = rs.GetPoints(False, False, "right")
for j in range(len(lside)):
pt = rs.VectorAdd(lside[j], fix)
lside[j] = pt
for j in range(len(rside)):
pt = rs.VectorAdd(rside[j], fix)
rside[j] = pt
list.append([dir1, indir, lside, rside, outdir])
WritePolies(addresss, list)
def MirrorX(lineIn, pIn):
pLine0 = lineIn[0]
pLine1 = lineIn[1]
normal = rs.VectorUnitize(
rs.VectorCrossProduct([0, 0, 1], rs.VectorSubtract(pLine1, pLine0)))
matrix = rs.XformMirror(pLine1, normal)
return rs.PointTransform(pIn, matrix)
def blendcorners():
polyline_id = rs.GetObject("Polyline to blend", 4, True, True)
if not polyline_id: return
vertices = rs.PolylineVertices(polyline_id)
if not vertices: return
radius = rs.GetReal("Blend radius", 1.0, 0.0)
if radius is None: return
between = lambda a, b: (a + b) / 2.0
newverts = []
for i in range(len(vertices) - 1):
a = vertices[i]
b = vertices[i + 1]
segmentlength = rs.Distance(a, b)
vec_segment = rs.PointSubtract(b, a)
vec_segment = rs.VectorUnitize(vec_segment)
if radius < (0.5 * segmentlength):
vec_segment = rs.VectorScale(vec_segment, radius)
else:
vec_segment = rs.VectorScale(vec_segment, 0.5 * segment_length)
w1 = rs.VectorAdd(a, vec_segment)
w2 = rs.VectorSubtract(b, vec_segment)
newverts.append(a)
newverts.append(between(a, w1))
newverts.append(w1)
newverts.append(between(w1, w2))
newverts.append(w2)
newverts.append(between(w2, b))
newverts.append(vertices[len(vertices) - 1])
rs.AddCurve(newverts, 5)
rs.DeleteObject(polyline_id)
def TransformProfile(object, pt1, pt2):
normal = rs.VectorSubtract(pt1, pt2)
normal = rs.VectorUnitize(normal)
plane = rs.PlaneFromNormal(pt1, normal)
transformation = rs.XformRotation1((rs.WorldXYPlane), normal)
profiletras = rs.TransformObject(object, transformation, True)
def copyToOrigin(objs):
#get left bottom
selection_base = rs.GetPoint("Pick export base point")
#box = rs.BoundingBox(objs)
if selection_base:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(selection_base, [0, 0, 0])
return rs.CopyObjects(objs, rs.VectorReverse(vector))
def drawEdge(self,nodes):
p1 = self.posVec
p2 = nodes[self.parentID].posVec
self.geom.append(rs.AddLine(p1,p2))
pNormal = rs.VectorSubtract(p2,p1)
height = rs.VectorLength(pNormal)
plane = rs.PlaneFromNormal(p1,pNormal)
radius = self.radius
self.geom.append(rs.AddCylinder(plane,height,radius))
def attractor(self, mag):
attrPt = rs.VectorCreate((-800,-700,0) , (0,0,0))
steer = rs.VectorCreate( (0,0,0) , (0,0,0) )
diff = rs.VectorSubtract( attrPt, self.p )
diff = rs.VectorUnitize(diff)
steer = rs.VectorAdd(steer , diff)
steer = rs.VectorScale(steer, mag)
self.a = rs.VectorAdd(self.a, steer)
def attract(self, mover):
forceDir = rs.VectorSubtract(self.location, mover.location)
forceMag = rs.Distance(self.location, mover.location)
forceMag = limit(forceMag, 2.0, 27.0)
forceDir = rs.VectorUnitize(forceDir)
# print forceDir
strength = (self.g * self.mass) / (forceMag * forceMag)
# strength = limit(strength,1,15)
# print strength
finalForce = rs.VectorScale(forceDir, strength)
return finalForce
def moveToOrigin(objs, origin):
#box = rs.BoundingBox(objs)
if origin:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(origin, [0, 0, 0])
objs = rs.MoveObjects(objs, rs.VectorReverse(vector))
return True
else:
return False
def _get_centering_vec(self, curve_id, extra_space):
'''
gets the vector that is aligned with curve, and whos length
is half of extra_space
'''
dist = extra_space / 2.0
start = rs.CurveStartPoint(curve_id)
end = rs.CurveEndPoint(curve_id)
vec = rs.VectorSubtract(end, start)
vec_unit = rs.VectorUnitize(vec)
vec_scaled = rs.VectorScale(vec_unit, dist)
return vec_scaled
def throwNode(nodes,speed,stickRange,passParams,resizeThreshold):
boundRadius = passParams[0]
bGeom = passParams[1]
#sFactor = passParams[2]
#print passParams[2]
#assumes time steps of 1
startPos = getBoundaryPos(boundRadius);
endPos = getBoundaryPos(boundRadius);
direction = rs.VectorSubtract(endPos,startPos)
direction = rs.VectorUnitize(direction)
vel = rs.VectorScale(direction,speed);
currentPos = rs.VectorAdd(startPos,vel)
previewGeom = []
isTravelling = True
while(isTravelling):
scriptcontext.escape_test() #hit escape to quit NOT WORKING
time.sleep(0.01*10**-7)
for o in previewGeom: rs.DeleteObjects(o)
dist = rs.VectorLength(currentPos) #distance to origin
#check if particle went out of bounds
if(dist>boundRadius):
isTravelling = False
else:
previewGeom.append(drawPos(currentPos,stickRange))
for i in range(len(nodes)):
n = nodes[i]
if(inStickRange(currentPos,n,stickRange)):
#GOT STUCK! add a new node at that position
newNode = node(currentPos,i,.08) #parent is idx of node stuck too
newNode.increaseRadius(.01, nodes)
nodes.append(newNode)
#rNodes.append(rs.AddPoint(currentPos))
if(math.fabs(boundRadius-dist) <= resizeThreshold):
#print "boundRadius should resize"
rs.DeleteObjects(bGeom)
boundRadius += resizeThreshold/2 #arbitrary
bGeom = rs.AddCircle([0,0,0],boundRadius)
passParams[0] = boundRadius
passParams[1] = bGeom
isTravelling = False
for o in previewGeom: rs.DeleteObjects(o)
break
currentPos = rs.VectorAdd(currentPos,vel)
Rhino.RhinoApp.Wait()
return passParams
def main():
diameter = rs.GetReal("enter cutter diameter", number=0.25)
diameter = diameter*1.1
# first, select objects in three orthogonal planes
obj = rs.GetObject("select object", filter=4) # curve
curve_points = rs.CurvePoints(obj)[:-1]
circles = []
while True:
point = rs.GetPoint("select point")
if point is None:
break
try:
idx = curve_points.index(point)
print "clicked index", idx
except ValueError:
print "invalid point"
continue
points = [
curve_points[(idx+1)%len(curve_points)],
curve_points[idx ],
curve_points[(idx-1)%len(curve_points)],
]
print points
angle = rs.Angle2(
(points[1], points[0]),
(points[1], points[2]),
)
angle = angle[0]
point = rs.VectorAdd(
points[1],
rs.VectorRotate(0.5*diameter*rs.VectorUnitize(rs.VectorSubtract(points[2], points[1])), angle/2, (0,0,1))
)
#p0 = (point.X, point.Y, point.Z + 1000)
#p1 = (point.X, point.Y, point.Z - 1000)
circle = rs.AddCircle(point, diameter/2.0)
circles.append(circle)
#extrusion = rs.ExtrudeCurveStraight(circle, p0, p1)
for circle in circles:
before_obj = obj
obj = rs.CurveBooleanDifference(obj, circle)
rs.DeleteObject(before_obj)
rs.DeleteObjects(circles)
def splitSrfVerticallyByPts(srf,pts):
normals=[]
up=(0,0,1000000000)
half=(0,0,500000000)
cutters=[]
for p in pts:
uv=rs.SurfaceClosestPoint(srf,p)
normal=rs.SurfaceNormal(srf,uv)
normal=rs.VectorScale(normal,1000)
normals.append(normal)
botStart=rs.VectorAdd(rs.VectorSubtract(p,half),normal)
botEnd=rs.VectorSubtract(rs.VectorSubtract(p,half),normal)
l=rs.AddLine(botStart,botEnd)
path=rs.AddLine(botStart,rs.VectorAdd(botStart,up))
cutter=rs.ExtrudeCurve(l,path)
rs.DeleteObjects([l,path])
#print(rs.IsBrep(cutter))
#print(cutter)
cutters.append(cutter)
# rs.SelectObjects(cutters)
srfs=splitSrfBySrfs(srf,cutters)
return srfs
def ResetBlockScale():
try:
blocks = rs.GetObjects("Select blocks to reset",
rs.filter.instance,
preselect=True)
if blocks is None: return
points = [
rg.Point3d(0, 0, 0),
rg.Point3d(1, 0, 0),
rg.Point3d(0, 1, 0),
rg.Point3d(0, 0, 1)
]
for block in blocks:
xform = rs.BlockInstanceXform(block)
namne = rs.BlockInstanceName(block)
pts = rg.Polyline(points)
pts.Transform(xform)
finalOrigin = pts[1]
finalXaxis = rs.VectorSubtract(pts[1], pts[0])
finalYaxis = rs.VectorSubtract(pts[2], pts[0])
finalPlane = rg.Plane(finalOrigin, finalXaxis, finalYaxis)
xFac = 1 / rs.Distance(pts[1], pts[0])
yFac = 1 / rs.Distance(pts[2], pts[0])
zFac = 1 / rs.Distance(pts[3], pts[0])
newXForm = rg.Transform.Scale(finalPlane, xFac, yFac, zFac)
rs.TransformObject(block, newXForm)
return True
except:
return False
def get_perpendicular_vector_to_points(pntI, pntJ, left=True):
'''
returns a unitized vector perpendicular to the vector formed
from pntI to pntJ
^
|
I-------> J
'''
normal = [0, 0, 1]
angle = 90.0
if not left:
angle = -1.0 * angle
vec = rs.VectorSubtract(pntJ, pntI)
vec = rs.VectorRotate(vec, angle, normal)
return rs.VectorUnitize(vec)
def guessHorizontalShift():
"""
This script will correct the horizontal distortion and set it in the V-Ray Camera.
It levels the camera for this correction to work well and resets
lens shift (vertical shift) to 0
Works with V-Ray 5.1
version 0.4
www.studiogijs.nl
"""
viewport = Rhino.RhinoDoc.ActiveDoc.Views.ActiveView.ActiveViewport
if viewport.IsParallelProjection:
print "Stupid, you should select a perspective view"
return
view = Rhino.RhinoDoc.ActiveDoc.Views.ActiveView.ActiveViewport
#set camera location to target height
pt = view.CameraLocation
pt[2] = view.CameraTarget.Z
dir = rs.VectorSubtract(view.CameraTarget, pt)
view.SetCameraLocation(pt, False)
view.SetCameraDirection(dir, False)
#calculate camera direction angle relative to WorldXY plane
cam = view.CameraZ
vec = Rhino.Geometry.Vector3d(1, 0, 0)
plane = Rhino.Geometry.Plane.WorldXY
angle = Rhino.Geometry.Vector3d.VectorAngle(cam, vec, plane)
#calculate the correction factor
for i in range(3):
if angle > math.pi / 2:
angle -= math.pi / 2
else:
break
if 0 <= angle < math.pi / 4:
factor = math.tan(angle)
if math.pi / 4 <= angle < math.pi / 2:
factor = -math.tan(math.pi / 2 - angle)
rv = rs.GetPlugInObject("V-Ray for Rhino").Scene().Plugin(
"/CameraPhysical")
rv.Param("horizontal_shift").Value = factor
print "Horizontal shift factor set to %r." % factor
rv.Param("lens_shift").Value = 0
rs.Redraw()
def surfaceIrradiance_fixed(towerIn, sunIn, intensityIn):
sunUnit = rs.VectorUnitize(sunIn)
for floor in range(len(towerIn)):
numPoints = len(towerIn[floor])
for i in range(numPoints):
p1 = towerIn[floor][i]
p2 = towerIn[floor][(i + 1) % numPoints]
v1 = rs.VectorSubtract(p2, p1)
v2 = [0, 0, 1]
n = rs.VectorCrossProduct(v1, v2)
if rs.VectorLength(n) > rs.UnitAbsoluteTolerance(10**(-3), True):
cosTheta = rs.VectorDotProduct(rs.VectorUnitize(n), sunUnit)
if cosTheta > 0:
factor = intensityIn * cosTheta / 200 #200 is just to shorten the vector to something manageable
v = rs.VectorScale(n, factor)
AddVector(v, p1)
def grow(num): #this method grows the global ptArray list #this method grows teh pointClooud represented by this list if num == 0: return 0 randPt = randomPt(-25,25,-25,25,0,50) joinNode = nodeList[rs.PointArrayClosestPoint(ptArray, randPt)] joinPt = joinNode.pos joinVec = rs.VectorSubtract(randPt, joinPt) growthVec = rs.VectorUnitize(joinVec) newPt = rs.VectorAdd(joinPt, growthVec) newNode = node(newPt, joinNode) g = grow(num-1)
def moveToOrigin(objs):
#get left bottom
rs.EnableRedraw(True)
selection_base = rs.GetPoint("Pick export base point")
rs.EnableRedraw(False)
#box = rs.BoundingBox(objs)
if selection_base:
#selection_base = [box[0].X, box[0].Y, box[0].Z]
vector = rs.VectorSubtract(selection_base, [0, 0, 0])
objs = rs.MoveObjects(objs, rs.VectorReverse(vector))
return True
else:
return False
def get_addition_columns(a,b):
sq2 = math.sqrt(2.0)
if a<ra and b<ra:
p = rg.Vector2d(a,b)
columnradius = ra * sq2 / ((n-1) * 2 + sq2)
p = rot45(p)
p = rs.VectorSubtract(p,rg.Vector3d(sq2 / 2 * ra,0,0))
p = rs.VectorAdd(p,rg.Vector3d(columnradius*sq2,columnradius*sq2,0))
if n%2==1:
p = rs.VectorAdd(p,rg.Vector3d(0,columnradius,0))
p.Y = mod1(p.Y, columnradius*2)
result = p.Length-columnradius
result = min(result, p.X)
result = min(result, a)
return min(result, b)
else:
return min(a,b)
def cohesion(self, mag):
sum = rs.VectorCreate( (0,0,0) , (0,0,0) )
count = 0
for i in pts:
distance = rs.Distance(i.p, self.p)
if distance > 0 and distance < 60:
sum = rs.VectorAdd(sum, i.p)
count += 1
if count>0:
sum = rs.VectorScale(sum, 1.0/count)
steer = rs.VectorSubtract(sum, self.p)
steer = rs.VectorScale(steer, mag)
self.a = rs.VectorAdd(self.a, steer)
def draw_lpoint_triple(text, tail, head):
"""Receives label text and a list of point triples:
str
[<iter>, ...]
Draws text dots with <text>-a, -b, -c
"""
line_vector = rs.PointSubtract(head, tail)
offset_vector = line_vector * offset
offset_tail = rs.VectorAdd(tail, offset_vector)
offset_head = rs.VectorSubtract(head, offset_vector)
axis = [0, 0, 1]
angle = 90
rotated_offset_vector = rs.VectorRotate(offset_vector, angle, axis)
offset_side = rs.VectorAdd(offset_tail, rotated_offset_vector)
rs.AddTextDot(('%s-a' % text), offset_tail)
rs.AddTextDot(('%s-b' % text), offset_head)
rs.AddTextDot(('%s-c' % text), offset_side)
def grow(self):
x1 = self.node[0][0] - (self.size[1] / 2)
x2 = self.node[0][0] + (self.size[1] / 2)
y1 = self.node[0][1] - (self.size[1] / 2)
y2 = self.node[0][1] + (self.size[1] / 2)
z1 = self.node[0][2]
z2 = self.node[0][2] + self.size[0]
i = 0
while i < self.twigCount:
randPt = placePt(x1, x2, y1, y2, z1, z2)
joinPt = self.node[rs.PointArrayClosestPoint(self.node, randPt)]
vec = rs.VectorScale(
rs.VectorUnitize(rs.VectorSubtract(randPt, joinPt)),
self.segLength)
newPt = rs.PointAdd(joinPt, vec)
self.addTwig(joinPt, newPt)
i += 1
def GetPointDynamicDrawFunc(sender, args):
point_b = args.CurrentPoint
point_C = Rhino.Geometry.Point3d((point_a.X + point_b.X) / 2,
(point_a.Y + point_b.Y) / 2,
(point_a.Z + point_b.Z) / 2)
#Rhino.Geometry.Transform.Translation(
vec = rs.VectorCreate(point_b, point_a)
rs.VectorUnitize(vec)
vec2 = rs.VectorScale(vec, 500)
vec3 = rs.coerce3dpoint(rs.VectorAdd(point_b, vec2))
rs.VectorReverse(vec2)
vec4 = rs.coerce3dpoint(rs.VectorSubtract(point_b, vec2))
args.Display.DrawLine(point_a, vec3, line_color_1, 1)
args.Display.DrawLine(point_a, vec4, line_color_1, 1)
args.Display.DrawPoint(point_a, Rhino.Display.PointStyle.ControlPoint,
3, line_color_1)
args.Display.DrawPoint(point_b, Rhino.Display.PointStyle.ControlPoint,
3, line_color_2)
def separate(self, mag):
steer = rs.VectorCreate( (0,0,0) , (0,0,0) )
count = 0
for i in pts:
distance = rs.Distance(i.p, self.p)
if distance > 0 and distance < 30:
diff = rs.VectorSubtract(self.p, i.p)
diff = rs.VectorUnitize(diff)
diff = rs.VectorScale(diff, 1.0/distance)
steer = rs.VectorAdd(steer , diff)
count += 1
if count>0:
steer = rs.VectorScale(steer, 1.0/count)
steer = rs.VectorScale(steer, mag)
self.a = rs.VectorAdd(self.a, steer)
def SeparationVector(self):
sum = [0, 0, 0]
count = 0
for i in range(len(agentlist)):
if self.pos is not agentlist[i].pos:
dis = rs.Distance(self.pos, agentlist[i].pos)
self.setFlag(dis)
if self.doSeparation:
sum = rs.VectorSubtract(sum, agentlist[i].pos)
count += 1
#avepos = rs.VectorScale (sum, 1/count)
avepos = rs.VectorScale(sum, count)
resultingVec = rs.VectorCreate(avepos, self.pos)
resultingVec = vectorlimit(resultingVec, self.mf)
return resultingVec
def avoid(self):
if obstacle:
avoid = [0, 0, 0]
count = 0
sumradar = 0
averadar = 0
for i in range(len(obstacle)):
judge = rs.MeshClosestPoint(obstacle[i], self.pos)
radar = rs.Distance(self.pos, judge[0])
vecradar = rs.VectorCreate(self.pos, judge[0])
# print radar
if radar < 0.5:
self.pos = rs.VectorSubtract(self.posP, self.pos)
vecradar = rs.VectorScale(vecradar, 2)
if radar < 3 and radar > 0.5:
avoid = rs.VectorAdd(avoid, judge[0])
sumradar += radar
count += 1
vecradar = rs.VectorScale(vecradar, 0.5)
obstacle[i] = rs.MoveObject(obstacle[i], vecradar)
if count != 0:
aveavoid = rs.VectorScale(avoid, 1 / count)
averadar = sumradar / count
else:
aveavoid = self.pos
averadar = averadar + 24
vec1 = rs.VectorCreate(self.pos, aveavoid)
vec1 = rs.VectorScale(vec1, ((averadar + 24) / averadar)**2)
if rs.VectorLength(vec1) > 1:
vec1 = vectorlimit(vec1, 1)
# n = rnd.randint(0,10)
# vec1 = rs.VectorRotate (vec1,-60,[0,0,1])
else:
vec1 = [0, 0, 0]
return vec1
def __init__(self, GUID_TERRAIN, CRV, SPEED=1):
# CLASS PROPERTIES
pt_from = rs.CurveStartPoint(CRV)
pt_to = rs.CurveEndPoint(CRV)
self.pos = pt_from
self.vel = rs.VectorSubtract(pt_to, pt_from)
self.vel = rs.VectorUnitize(self.vel)
self.vel = rs.VectorScale(self.vel, SPEED)
self.terrain = GUID_TERRAIN
self.proj_points = []
self.depth_scans = [] # a list store scan data
self.history = [] # remember everywhere i have been
self.history.append(self.pos)
self.render() #drawing the 0-text dot
self.z_distances = []
self.x_pos = []
self.z_difference = []
self.x_difference = []
def addcurvaturegraphsection(idCrv, t0, t1, samples, scale):
if (t1 - t0) <= 0.0: return
N = -1
tstep = (t1 - t0) / samples
t = t0
points = []
objects = []
while t <= (t1 + (0.5 * tstep)):
if t >= t1: t = t1 - 1e-10
N += 1
cData = rs.CurveCurvature(idCrv, t)
if not cData:
points.append(rs.EvaluateCurve(idCrv, t))
else:
c = rs.VectorScale(cData[4], scale)
a = cData[0]
b = rs.VectorSubtract(a, c)
objects.append(rs.AddLine(a, b))
points.append(b)
t += tstep
objects.append(rs.AddInterpCurve(points))
return objects