def project_points(self, points):
projections = []
for point in points:
ppoints = rs.ProjectPointToSurface(point, self.guid, [0, 0, 1])
if not ppoints:
raise RhinoSurfaceError('Could not project point to surface.')
ppoint = ppoints[0]
projections.append(list(ppoint))
return projections
def heightfield(self, density=10, over_space=True):
""""""
try:
du, dv = density
except TypeError:
du = density
dv = density
du = int(du)
dv = int(dv)
xyz = []
rs.EnableRedraw(False)
if rs.IsPolysurface(self.guid):
faces = rs.ExplodePolysurfaces(self.guid)
elif rs.IsSurface(self.guid):
faces = [self.guid]
else:
raise RhinoSurfaceError('object is not a surface')
if over_space:
for guid in faces:
face = RhinoSurface(guid)
uv = face.space(density)
for u, v in uv:
xyz.append(list(rs.EvaluateSurface(face.guid, u, v)))
else:
for guid in faces:
bbox = rs.BoundingBox(guid)
xmin = bbox[0][0]
xmax = bbox[1][0]
ymin = bbox[0][1]
ymax = bbox[3][1]
xstep = 1.0 * (xmax - xmin) / (du - 1)
ystep = 1.0 * (ymax - ymin) / (dv - 1)
seeds = []
for i in xrange(du):
for j in xrange(dv):
seed = xmin + i * xstep, ymin + j * ystep, 0
seeds.append(seed)
points = map(list,
rs.ProjectPointToSurface(seeds, guid, [0, 0, 1]))
xyz += points
if len(faces) > 1:
rs.DeleteObjects(faces)
rs.EnableRedraw(True)
return xyz
mdl.add([
RollerDisplacementY(name='disp_top', nodes='nset_top'),
RollerDisplacementY(name='disp_bot', nodes='nset_bot'),
])
# Loads
mdl.add(GravityLoad(name='load_gravity', elements='elset_mesh'))
mesh = mesh_from_guid(Mesh(), rs.ObjectsByLayer('elset_mesh')[0])
point_loads = {}
for key in mesh.vertices():
xyz = mesh.vertex_coordinates(key)
pt = rs.ProjectPointToSurface([xyz],
rs.ObjectsByLayer('surface')[0],
[0, 0, 1])[0]
pz = mesh.vertex_area(key) * distance_point_point(xyz, pt) * 2400 * 9.81
point_loads[mdl.check_node_exists(xyz)] = {'z': -pz}
mdl.add(PointLoads(name='load_points', components=point_loads))
# Steps
displacements = ['disp_top', 'disp_bot']
loads = ['load_gravity', 'load_points']
mdl.add([
GeneralStep(name='step_bc', displacements=displacements),
GeneralStep(name='step_loads', loads=loads, factor=1.35),
BucklingStep(name='step_buckle',
loads=loads,
def project_point(self, point, direction=(0, 0, 1)):
projections = rs.ProjectPointToSurface(point, self.guid, direction)
if not projections:
return self.closest_point(point)
return list(projections[0])
def project_points(self, points, direction=(0, 0, 1), include_none=True):
projections = rs.ProjectPointToSurface(points, self.guid, direction)
if not projections:
return self.closest_points(points)
projections[:] = [self.closest_point(point) if not point else point for point in projections]
return map(list, projections)
stepsx = int(xleng / cellsize) + 1
print stepsy, stepsx
rs.EnableRedraw(False)
ptlist = []
for i in range(stepsy):
rows = []
for j in range(stepsx):
nowpt = [
j * cellsize + min(xlist), i * cellsize + min(ylist),
min(zlist)
]
ptonsrf = rs.ProjectPointToSurface(nowpt, srf, [0, 0, 1])
if len(ptonsrf) > 0:
rs.AddPoints(ptonsrf)
rows.append(ptonsrf[0])
else:
rows.append(nowpt)
rs.AddPoint(nowpt)
ptlist.append(rows)
print len(ptlist), len(rows)
print rows[0]
print rows[1]
#assign variables for text file
ncols = len(ptlist[0])
nrows = len(ptlist)
all_points = []
for i in range(0, 100):
pt = rs.AddPoint(place_pts(100, 100, 100))
index = rs.PointArrayClosestPoint(cloud, pt)
cp = cloud[index]
vect = rs.VectorCreate(cp, pt)
#move = rs.MoveObject(pt,vect)
#vector = rs.VectorCreate(index, pt)
#index_points = rs.PointArrayClosestPoint(pipe_points, pt)
#vector = rs.VectorCreate(index_points, pt)
#rs.VectorCreate()
#unit_vector = rs.VectorUnitize(vector)
#new_pt = rs.MoveObject(pt, unit_vector)
project = rs.ProjectPointToSurface(pt, pipe, vect)
rs.AddPoints(project)
all_points.append(pt)
#pipe_points = []
#for i in range(300):
#contour = rs.CurveContourPoints(pipe, point1, point2, 1)
#SurfaceDomain requires two arguments, second argument = u or v direction, 0 or 1 respectively
#dom_u = rs.SurfaceDomain(pipe,0)
#dom_v = rs.SurfaceDomain(pipe,1)
#eval_srf = rs.EvaluateSurface()(pipe,uv)
#cloud = rs.GetPoints()
#cloud.append(point1)
rndm_number = random.uniform(0, max_probability)
random.seed = random_seed
param = rs.CurveClosestPoint(boundary_curve, i)
pt = rs.EvaluateCurve(boundary_curve, param)
# rndm_cull_points.append(pt)
distance = rs.Distance(pt, i)
invert_distance = 1.0 / distance
# print(str(distance) + str(invert_distance) + ' r: ' + str(rndm_number))
if invert_distance < rndm_number:
rndm_cull_points.append(i)
# Project points to bottom surface
btm_surface = [bottom_surface] # Create a list with one single element
bottom_pts = rs.ProjectPointToSurface(rndm_cull_points, btm_surface, (0,0,-1))
# Project points to top surface
top_surface = [top_surface] # Create a list with one single element
top_pts = rs.ProjectPointToSurface(rndm_cull_points, top_surface, (0,0,1))
# Planes on the bottom
bottom_planes = []
for i in bottom_pts:
view = rs.CurrentView()
planes = rs.CreatePlane(i, (1,0,0), (0,1,0))
bottom_planes.append(planes)
#set sample resolution
cellResolution = 1000 #mm
#plot 2D grid over surface
stepsY = int(distY / cellResolution) + 1
stepsX = int(distX / cellResolution) + 1
#project points to sand surface
ptList = []
for i in range(0, stepsY):
row = []
for j in range(0, stepsX):
nowPt = [j * cellResolution, i * cellResolution, 0]
#project points to sand surface
ptOnSrf = rs.ProjectPointToSurface(nowPt, srf, [0, 0, 1])
#project points to buildings
ptOnBld = []
if blds:
for k in range(len(blds)):
tempPtOnBld = rs.ProjectPointToSurface(nowPt, blds[k],
[0, 0, 1])
if len(ptOnBld) == 0:
ptOnBld = tempPtOnBld
#print tempPtOnBld, ptOnBld
if ptOnSrf:
#check for plant
row.append([ptOnSrf[0], ptOnBld]) #append plant to this list
"""else:
distY = sortList[12][2]
distX = sortList[4][2]
#set sample resolution
cellSizeIdeal = 10 #m
#plot 2D grid over surface
stepsY = int(distY / cellSizeIdeal) + 1
stepsX = int(distX / cellSizeIdeal) + 1
ptList = []
for i in range(0, stepsY):
row = []
for j in range(0, stepsX):
nowPt = [j * cellSizeIdeal, -i * cellSizeIdeal, 0]
ptOnSrf = rs.ProjectPointToSurface(nowPt, srf, [0, 0, 1])
if ptOnSrf:
row.append(ptOnSrf[0])
else:
print "no point!"
ptList.append(row)
#assign variables for text file
ncols = len(ptList[3])
nrows = len(ptList)
xllcorner = 0
yllcorner = 0
cellsize = cellSizeIdeal
NODATA_value = -9999
drawPts(ptList)
displacements = ['disp_top', 'disp_bot']
# Loads
mdl.add_load(GravityLoad(name='load_gravity', elements='elset_mesh'))
loads = ['load_gravity', 'load_points']
Gc = 2400 * 9.81
mesh = mesh_from_guid(Mesh(), rs.ObjectsByLayer('elset_mesh')[0])
surface = rs.ObjectsByLayer('surface')[0]
point_loads = {}
for key in mesh.vertices():
xyz = mesh.vertex_coordinates(key)
node = mdl.check_node_exists(xyz)
pt = rs.ProjectPointToSurface([xyz], surface, [0, 0, 1])[0]
pz = mesh.vertex_area(key) * distance_point_point(xyz, pt) * Gc
point_loads[node] = {'z': -pz}
mdl.add_load(PointLoads(name='load_points', components=point_loads))
# Steps
mdl.add_steps([
GeneralStep(name='step_bc', displacements=displacements),
GeneralStep(name='step_loads', loads=loads, increments=300, factor=1.35),
BucklingStep(name='step_buckle',
loads=loads,
displacements=displacements,
modes=1)
])
mdl.steps_order = ['step_bc', 'step_loads', 'step_buckle']
