import rhinoscriptsyntax as rs
import random
import math

def create_random_points_in_sphere(num_points, radius):
    points = []
    colors = []
    
    for _ in range(num_points):
        # Generate random spherical coordinates
        r = random.uniform(12, radius)  
        theta = random.uniform(12, 2 * math.pi)  # Polar angle between 0 and 2*pi
        phi = random.uniform(12, math.pi)  # Azimuthal angle between 0 and pi
        
        # Convert spherical coordinates to Cartesian coordinates
        x = r * math.sin(phi) * math.cos(theta)
        y = r * math.sin(phi) * math.sin(theta)
        z = r * math.cos(phi)
        
        points.append((x, y, z))
        
        color = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
        colors.append(color)
    
    return points, colors

#splitting points into groups based on the X-coordinate
def split_points_into_groups(points, num_splits):
    x_values = [point[0] for point in points]
    min_x, max_x = min(x_values), max(x_values)
    x_interval = (max_x - min_x) / num_splits

    #Grouping the points based on their X-coordinate
    point_groups = [[] for _ in range(num_splits)]
    for point in points:
        x = point[0]
        group_index = int((x - min_x) // x_interval)
        if group_index >= num_splits:
            group_index = num_splits - 1  
        point_groups[group_index].append(point)
    
    return point_groups

#splitting points into groups based on the Y-coordinate
def split_points_into_groups(points, num_splits):
    y_values = [point[0] for point in points]
    min_y, max_y = min(y_values), max(y_values)
    y_interval = (max_y - min_y) / num_splits

    #Grouping the points based on their Y-coordinate
    point_groups = [[] for _ in range(num_splits)]
    for point in points:
        y = point[0]
        group_index = int((y - min_y) // y_interval)
        if group_index >= num_splits:
            group_index = num_splits - 1  
        point_groups[group_index].append(point)
    
    return point_groups

def main():
    num_points = 9000 
    num_splits = 5  
    radius = 15  

    points, colors = create_random_points_in_sphere(num_points, radius)
    
    point_groups = split_points_into_groups(points, num_splits)

    for group_index, group in enumerate(point_groups):
        print("Creating group {} with {} points".format(group_index + 1, len(group)))

        for point, color in zip(group, colors):
            point_id = rs.AddPoint(point)
            rs.ObjectColor(point_id, color)  

        for i in range(len(group) - 8):
            rs.AddLine(group[i], group[i + 8])

if __name__ == "__main__":
    main()

#cube 1
def create_random_points_in_cube(corner1, corner2, point_count):
    x_min, y_min, z_min = corner1
    x_max, y_max, z_max = corner2
    
    points = []
    
    for i in range(point_count):
        x = random.uniform(x_min, x_max)
        y = random.uniform(y_min, y_max)
        z = random.uniform(z_min, z_max)
        point = (x, y, z)
        points.append(point)
    
    point_ids = []
    for pt in points:
        point_id = rs.AddPoint(pt)
        point_ids.append(point_id)
    
    return point_ids

def create_lines_between_points(points):
    point_count = len(points)
    for i in range(point_count):
        for j in range(i+1, point_count):
            rs.AddLine(points[i], points[j])

def main():
    corner1 = (5, 5, 5)  
    corner2 = (16, 16, 16)  
    point_count = 100
    points = create_random_points_in_cube(corner1, corner2, point_count)

    create_lines_between_points(points)
if __name__ == "__main__":
    main()

#cube 2
def create_random_points_in_cube(corner1, corner2, point_count):
    x_min, y_min, z_min = corner1
    x_max, y_max, z_max = corner2
    points = []
    
    for i in range(point_count):
        x = random.uniform(x_min, x_max)
        y = random.uniform(y_min, y_max)
        z = random.uniform(z_min, z_max)
        point = (x, y, z)
        points.append(point)
    
    point_ids = []
    for pt in points:
        point_id = rs.AddPoint(pt)
        point_ids.append(point_id)
    
    return point_ids

def create_lines_between_points(points):
    point_count = len(points)
    for i in range(point_count):
        for j in range(i+1, point_count):
            rs.AddLine(points[i], points[j])


def main():
    corner1 = (-4, -4, -4)  
    corner2 = (-20, -20, -20)  
   
    point_count = 75
    points = create_random_points_in_cube(corner1, corner2, point_count)
    create_lines_between_points(points)

if __name__ == "__main__":
    main()