float droop_amount = chf("droop_amount");     
float tension = chf("tension");            
int use_ramp = chi("use_ramp");              
float axis_blend = chf("axis_blend");      
int preserve_length = chi("preserve_length");


int prims[] = pointprims(0, @ptnum);
if (len(prims) == 0) return; 
int prim = prims[0]; 

int vtx = vertexindex(0, prim, @ptnum);
int count = primvertexcount(0, prim);


float t = float(vtx) / max(count - 1, 1);


if (use_ramp) {
    t = chramp("droop_ramp", t);
}


vector axis_dir = normalize(lerp({1,0,0}, {0,0,1}, axis_blend));


float arch = pow(t * (1.0 - t), tension);
float dy = -arch * droop_amount;

@P.y += dy;

/*
if (preserve_length) {
    float stretch = 1.0 + abs(dy) * 0.05;
    vector center = getbbox_center(0);
    vector dir = normalize(@P - center);
    @P = center + dir * length(@P - center) * stretch;
}
*/

node = hou.pwd()
geo = node.geometry()


epsilon = 0.5


class Point:
    def __init__(self, index, pos):
        self.index = index
        self.pos = hou.Vector3(pos)


def douglas_peucker(points, epsilon):

    if len(points) < 3:
        return points

    start, end = points[0], points[-1]
    max_distance = 0.0
    index = 0

   
    for i in range(1, len(points) - 1):
        distance = point_line_distance(points[i], start, end)
        if distance > max_distance:
            max_distance = distance
            index = i

    
    if max_distance > epsilon:
        left = douglas_peucker(points[:index + 1], epsilon)
        right = douglas_peucker(points[index:], epsilon)
        
        return left[:-1] + right
    else:
        return [start, end]


def point_line_distance(point, start, end):
    if start.pos == end.pos:
        return (point.pos - start.pos).length()

    line_vec = (end.pos - start.pos).normalized()
    point_vec = point.pos - start.pos
    d = line_vec.dot(point_vec)
    projection = start.pos + line_vec * d
    dist = (point.pos - projection).length()
    
    return dist


points = []
index = 0
for pt in geo.points():
    points.append(Point(index, pt.position()))
    index += 1


simplified_points = douglas_peucker(points, epsilon)


result = []
for i in range(len(simplified_points)):
    result.append(simplified_points[i].index)


geo.addArrayAttrib(hou.attribType.Global, 'result', hou.attribData.Int, 1)
geo.setGlobalAttribValue('result', result)

int pts[] = detail(0, "result");

if(len(pts) > 0 && find(pts, @ptnum) < 0)
    removepoint(0, @ptnum);

def solveForObjects(solver_data, new_dop_objects, existing_dop_objects, time, timestep):
    
    # Reference to the SOP node containing the geometry to copy
    sop_node_path = "/obj/geo1/Nul"  # Replace with your SOP node path
    sop_node = hou.node(sop_node_path)
    sop_geo = sop_node.geometry()

    for dop_object in new_dop_objects:
        # Optional: Set custom DOP attributes or physical parameters
        sub_data = dop_object.createSubData('PhysicalParms', 'SIM_PhysicalParms')
        
        # Access the editable geometry of the DOP object
        with dop_object.editableGeometry() as geo:
            # Merge the SOP geometry into the DOP geometry
            geo.merge(sop_geo)

            # Example: Adding custom attributes to the copied geometry
            geo.addAttrib(hou.attribType.Prim, 'max_nhit',2)