############################## ### DM2_w24 hu_03_setUp ### ### _diag / 2024 10 17 ### ############################## import rhinoscriptsyntax as rs import random, time, sys ### sys.path.append("/Volumes/app/WWW/aeroflot/dm2/") import DM_lib as dm ### reload(dm) ############################## rs.UnitSystem(3) rs.ShowGrid(view=None, show=0) rs.ShowGridAxes(view=None, show=0) rs.ViewDisplayMode(view=None, mode="Wireframe") rs.EnableRedraw(1) rs.DeleteObjects(rs.AllObjects()) ###################################### number = random.choice( range(16, 256, 4) ) dm.allCoords = dm.setUp_hu_03( number ) circle = dm.allCoords[0] ### calling def from DM_lib to get *new* set of coords rectangle = dm.allCoords[1] ### calling def from DM_lib to get *new* set of coords ###################################### randomVector = [random.uniform(-30,30) for i in range(3)] rectangle_pts = [rs.VectorRotate(coordinate, randomVector[0], randomVector) for coordinate in rectangle] circle_pts = [rs.VectorRotate(coordinate, randomVector[0], randomVector) for coordinate in circle] size = rs.Distance( rectangle[0], rectangle[1] ) ### edge length of cubus #dm.textDots( coordsCub ) circle_crv = rs.AddCurve( circle_pts + [circle_pts[0]], 3 ) #rectangle_crv = rs.AddPolyline( rectangle_pts + [rectangle_pts[0]] ) #dm.textDots( coordsCir ) pointcount = len(rectangle_pts) print "*** anz =", pointcount print "*** siz =", round(size, 2), "/ edge lenght =", round(size, 2),"*",int(pointcount/4),"=", round(size*pointcount/4, 2) print "*** **********\n" ### here we go # defs def centroid(*points): x_values = [p[0] for p in points] y_values = [p[1] for p in points] z_values = [p[2] for p in points] _len = len(points) centroid_x = sum(x_values)/_len centroid_y = sum(y_values)/_len centroid_z = sum(z_values)/_len return [centroid_x, centroid_y, centroid_z] # def divide_distance(denominator, *points): points_out = list(points) for i in range(len(points_out))[1:]: vector = rs.VectorCreate(points[i-1], points[i]) increment = rs.VectorDivide(vector, denominator) for step in range(denominator)[1:]: location = rs.VectorAdd(points[i], increment*step) _index = (i-1)*denominator # new_method points_out.insert(_index, location) return points_out # def partition(n, m, sigma): #6,5, lambda x:1; for storage only """ Generates all interpart restricted compositions of n with first part >= m using restriction function sigma. See Kelleher 2006, 'Encoding partitions as ascending compositions' chapters 3 and 4 for details. """ a = [0 for i in range(n + 1)] k = 1 a[0] = m - 1 #4 a[1] = n - m + 1 #2 while k != 0: x = a[k - 1] + 1 #k0,5 y = a[k] - 1 #k1, 1 k -= 1 #k=0 while sigma(x) <= y: #5 ->1 , y =1 => run print "loop2 start" a[k] = x #k0 = 5 print a x = sigma(x) #x=1 y -= x # y1 - x1 =0 k += 1 # k=1 a[k] = x + y # a1= 1, 0 = 1 yield a[:k + 1] # until 2? => 5, 1,0? # def random_partition(n, min_size=1): """ Generates a random partition of n with each part >= min_part. """ partition = [] remaining = n while remaining > 0: # Choose a random part size between min_part and remaining part = random.randint(min_size, min_size + remaining) #random.randint( partition.append(part) remaining -= part return partition # """ def coordinates( a=random.uniform(50,300), move=vecA ): coordinates = [[0,0,0], [a,0,0], [a,a,0], [0,a,0]] rotXYZ = [ random.uniform(-30,30), random.uniform(-30,30), random.uniform(-30,30) ] for i in range( len(coords) ): coordinates[i] = rs.VectorRotate(coordinates[i], 30, rotXYZ) coordinates[i] = rs.VectorAdd(coordinats[i], mov) return coordinates """ def coordinates( a=random.uniform(50,300)): coordinates = [[0,0,0], [a,0,0], [a,a,0], [0,a,0]] print a rotXYZ = [ random.uniform(-30,30), random.uniform(-30,30), random.uniform(-30,30) ] for i in range(4): coordinates[i] = rs.VectorRotate(coordinates[i], 30, rotXYZ) return coordinates # circle = rs.AddCurve(circle_pts) #circle_pts = [ rs.VectorAdd(pt) for pt in circle_pts ] #vector? centroid_circle = centroid(*circle_pts) #old setup new context num = 30 vecA = [ random.uniform(-num,num), random.uniform(-num,num), random.uniform(0,num) ] vecB = [ random.uniform(-num,num), random.uniform(-num,num), random.uniform(-num,0) ] vectors = [vecA, vecB] partitions = random_partition( 360, 40 ) copies = len(partitions) connections = [] for i, partition in enumerate(partitions): #[0:1] copy_angle = sum(partitions[:i]) #print(copy_angle) number = random.uniform(5,10) new_coordinates = coordinates(number) # eine koordinate ist 0,0,0 new_vectors = [ rs.VectorRotate( vec, copy_angle, (0,0,1)) for vec in vectors] #bleibt 0 _copy = [[ rs.VectorAdd( pt, new_vec) for pt in new_coordinates] for new_vec in new_vectors] # #_copy.append(_copy[0]) #_copy.extend(zip(_copy[0], _copy[1])) corners = [] #sides = _copy #test = _copy[1] #test.reverse() zipup = zip(_copy[0], _copy[1]) for i in range(len(zipup)): side = list(zipup[i-1]) side.extend( zipup[i]) #print len(side)#len(side[1]) corners.append(side) print len(_copy) _copy = [[ i[0], i[1], i[3], i[2]] for i in _copy] corners.extend(_copy) sides = [] for (a,b,c,d) in corners: #print (a,b,c,d) points_A = divide_distance(4, a,c) points_B = divide_distance(4, b,d) #points_B.reverse() new_list = [] zipup = zip(points_A, points_B) for i,(a,b) in enumerate(zipup): coordList = divide_distance(4, a,b) new_list.extend(coordList) sides.append(new_list) for i, _list in enumerate(corners): #sides? rs.AddPoints(_list) side_centroid = centroid(*_list) corners[i] = [side_centroid, (_list)] #sort by centroid distances = [] for _list in corners: closest = rs.PointClosestObject(_list[0], circle)[1] distance = rs.Distance( _list[0], closest) distances.append(distance) paired = zip(distances, sides) paired.sort() sorted_distances, sorted_sides = zip(*paired) for points in sorted_sides[:2]: for pt in points: closest = rs.PointClosestObject(pt, circle)[1] #use _list[0] also rs.AddLine(closest, pt) connections.append(sorted_sides[2:4]) #find the two closest sides zipped = [ zip(connections[i-1][0], connections[i][1]) for i in range(len(connections))] for connection in zipped: for (a,b) in connection: rs.AddLine(a,b) # #print len(sides), len(sides[0]), len(sides[0][0])#, len(sides[0][0][0])#, sides[0][0][0] #[ [rs.VectorAdd(vector, pt) for pt in rectangle] for vector in [vecA, vecB] ] #original = [ [rs.VectorAdd(vector, pt) for pt in rectangle] for vector in [vecA, vecB] ] #rotation_axis = [ random.uniform(-30,30), random.uniform(-30,30), random.uniform(-30,30) ] #vector = rs.VectorAdd(vecA, #location = rs.VectorRotate(vecA, sum(partition_angle[:i]), (0,0,1)) #rs.AddPoint(location) # Wo kommt der Kreis her? #""" # Wie entsteht # How does it work in his script? # Mirror at 1.5 the up vector. # Use divide distance to make the coordinates on the sides, # Use the corners to get the centroid, calculate distance to the rings, pop the respective list """ # erstmal verstehen, wie das Rechteck entsteht. # wie kann ich es randomisiert mit mycoords ersetzen. # Kann ich mein Skript ergangen, sodass sich die Seiten extraheiren lassen # Seiten ueber bestehendes Skript mit oben und def myCoords( a=random.uniform(50,300), move=vecA ): #number of points per side -> Otherwere coords = [[0,0,0], [a,0,0], [a,a,0], [0,a,0]] # replace with given rectangle, or make 4 different rectangles for flex? # first start with one and the same? # coords is equal to corners rotXYZ = [ random.uniform(-30,30), random.uniform(-30,30), random.uniform(-30,30) ] for i in range( len(coords) ): coords[i] = rs.VectorAdd(coords[i], mov) coords[i] = rs.VectorRotate(coords[i], 30, rotXYZ) return coords #coords_A = myCoords(random.uniform(50,300), vecA) #coords_B = myCoords(random.uniform(50,300), vecB) #corners_B = # move rectangle outwards ## vector centroid_rectangle = centroid(*rectangle_pts) centroid_circle = centroid(*circle_pts) vector = rs.VectorCreate(centroid_rectangle, centroid_circle) vector[2] = 0 vector = rs.VectorScale(vector, 1.5) ## new points rectangle_pts = [ rs.VectorAdd(pt, vector) for pt in rectangle_pts ] #circle_pts = [ rs.VectorAdd(pt, vector) for pt in circle_pts ] # lists domains = [ (a, a+int(pointcount/4)) for a in range(0,pointcount, int(pointcount/4))] OG_sides = [rectangle_pts[start:end] for (start,end) in domains] OG_corners = [side[0] for side in OG_sides] # copy circle vector_up = rs.VectorCreate(centroid_circle, centroid_rectangle) vector_up[0], vector_up[1], vector_up[2] = 0, 0, vector_up[2]* 2 new_circle = [ rs.VectorAdd(vector_up, pt) for pt in circle_pts ] ## test #rectangle_crv = rs.AddPolyline( OG_corners + [OG_corners[0]]) # rotate around circle copies = 4 connections = [] for i in range(copies): #make copy xform= rs.XformRotation2(i*360/copies, (0,0,1), centroid_circle) sides = [ [rs.VectorTransform(pt, xform) for pt in side ] for side in OG_sides ] corners = [side[0] for side in sides] # which 2 sides are closest to circle? side_midpts = divide_distance(2, *corners ) # + [corners[0]] distances = [] for i in range(0, len(side_midpts), 2): closest = rs.PointClosestObject( side_midpts[i], circle_crv)[1] distances.append(rs.Distance(side_midpts[i], closest)) #sort them distances, closest_sides = zip(*sorted(zip(distances, sides))) for _list in closest_sides[0:2]: # cloest point on curve for point in _list: closest = rs.PointClosestObject(point, circle_crv)[1] rs.AddLine( point, closest) connections.append(closest_sides[2:4]) #accidental code listpairs = [ zip(closest_sides[i-1], closest_sides[i]) for i in range(len(closest_sides))] for connection in listpairs: for (a,b) in connection: rs.AddLine( a, b) zipped = [ zip(connections[i-1][0], connections[i][1]) for i in range(len(connections))] for connection in zipped: for (a,b) in connection: rs.AddLine(a,b) """ ################ rs.ZoomExtents() """ rectangle = coordinates() original = [ [rs.VectorAdd(vector, pt) for pt in rectangle] for vector in vectors ] for copy_angle in partitions: _copy = [ [ rs.VectorRotate( pt, copy_angle, (0,0,1)) for pt in list] for list in original ] for _list in _copy: rs.AddPoints(_list) """