function int [ ] GetPrimsFromEdge ( int input; int pt0; int pt1 )
{
    int prims [ ];
    int hedge = pointedge ( input, pt0, pt1 );
    if ( hedge != -1 )
    {
        int count = hedge_equivcount ( input, hedge );
        for ( int i = 0; i < count; ++i )
        {
            int pr = hedge_prim ( input, hedge );
            if ( pr != -1 )
            {
                append ( prims, pr );
                hedge = hedge_nextequiv ( input, hedge );
            }
        }
    }
    return prims;
}



int GetNextPoint ( int input; int edgept0; int edgept1; int currentpt )
{
    int ptneighbours [ ] = neighbours ( input, currentpt );
    
    int primpts [ ];
    int prims [ ] = GetPrimsFromEdge ( input, edgept0, edgept1 );
    for ( int i = 0; i < len ( prims ); ++i )
    {
        int count = primvertexcount ( input, prims [ i ] );
        for ( int f = 0; f < count; ++f )
        {
            int vertIndex = vertexindex ( input, prims [ i ], f );
            int pointIndex = vertexpoint ( input, vertIndex );
            append ( primpts, pointIndex );
        }
    }
    
    int uniquepts [ ];
    foreach ( int pt; ptneighbours )
    {
        if ( find ( primpts, pt ) < 0 )
            append ( uniquepts, pt );
    }
    
    if ( len ( uniquepts ) == 1 )
        return uniquepts [ 0 ];

    return -1;
}



void GroupEdgeLoops ( int input; string edgegroup, groupname )
{
    if ( edgegroup == "" )
    {
        setedgegroup ( geoself ( ), groupname, 0, 0, 0 );
        return;
    }
        
    int loopedgepts [ ] = { };
    int edges [ ] = expandedgegroup ( input, edgegroup );
    if ( len ( edges ) == 0 )
    {
        setedgegroup ( geoself ( ), groupname, 0, 0, 0 );
        return;
    }
        
    int count = int ( 0.5 * len ( edges ) );
    for ( int i = 0; i < count; ++i )
    {
        int edgepts [ ] = sort ( array ( edges [ 2 * i ], edges [ 1 + 2 * i ] ) );
        
        int index0 = find ( loopedgepts, edgepts [ 0 ] );
        int index1 = find ( loopedgepts, edgepts [ 1 ] );
        int edgefound = index0 % 2 == 0 && index1 % 2 == 1 && index1 == 1 + index0;
        if ( !edgefound )
        {
            for ( int c = 0; c < 2; ++c )
            {
                int points [ ];
                int pt0 = edgepts [ c ];
                int pt1 = edgepts [ 1 - c ];
                int currentpt = pt0;
                int lastPoint = pt0;
                append ( points, currentpt );
                int nextPoint = GetNextPoint ( input, pt0, pt1, currentpt );
                while ( nextPoint != -1 && nextPoint != lastPoint )
                {
                    pt0 = currentpt;
                    pt1 = nextPoint;
                    currentpt = pt1;
                    append ( points, currentpt );
                    nextPoint = GetNextPoint ( input, pt0, pt1, currentpt );
                }
                
                int ptcount = len ( points ) - 1;
                for ( int f = 0; f < ptcount; ++f )
                    setedgegroup ( geoself ( ), groupname, points [ f ], points [ 1 + f ], 1 );
            }
            setedgegroup ( geoself ( ), groupname, edgepts [ 0 ], edgepts [ 1 ], 1 );
        }
    }
}

GroupEdgeLoops ( 0, chs("edge_group"), chs("group_name") );

string geo = geounwrap ( 0, "uv" );
int cls = prim ( 0, "class", @primnum );
vector center = getbbox_center ( geo, "@class=" + itoa ( cls ) );
@uv -= center;

float ndist = ch("distance");

int isclosed = primintrinsic ( 0, "closed", @primnum );
string polytype = isclosed ? "poly" : "polyline";

int primpts [ ] = primpoints ( 0, @primnum );
vector pos [ ] = { };
foreach ( int pt; primpts )
{
    vector p = point ( 0, "P", pt );
    append ( pos, p );
}

int count = len ( primpts );
int sharedpts = 0;
if ( primpts [ 0 ] != primpts [ -1 ] )
{
    if ( isclosed )
    {
        append ( primpts, primpts [ 0 ] );
        append ( pos, pos [ 0 ] );
    }
}
else
{
    count -= 1;
    if ( !isclosed )
        sharedpts = 1;
}

int newprimpts [ ] = { };
for ( int i = 0; i < count; ++i )
{
    vector p0 = pos [ i ];
    vector p1 = pos [ i + 1 ];
    
    vector pnew0 = lerp ( p0, p1, ndist );
    vector pnew1 = lerp ( p0, p1, 1 - ndist );
    
    int pt0 = addpoint ( 0, pnew0 );
    int pt1 = addpoint ( 0, pnew1 );
    
    append ( newprimpts, primpts [ i ] );
    append ( newprimpts, pt0 );
    append ( newprimpts, pt1 );
}

if ( sharedpts )
    append ( newprimpts, primpts [ 0 ] );

removeprim ( 0, @primnum, 0 );
addprim ( 0, polytype, newprimpts );

vector up = normalize ( chv("up_vector") );

vector p0 = point ( 1, "P", 0 );
vector p1 = point ( 1, "P", 1 );
vector dir = normalize ( p1 - p0 );
vector cdir = normalize ( cross ( up, dir ) );
dir = normalize ( cross ( cdir, up ) );
matrix3 m = maketransform ( dir, up );

setdetailattrib ( 0, "M", m );

@P *= m;

vector up = normalize ( chv("up_vector") );

vector p0 = point ( 1, "P", 0 );
vector p1 = point ( 1, "P", 1 );
vector dir = normalize ( p1 - p0 );
vector cdir = normalize ( cross ( up, dir ) );
up = cross ( up, cdir );
matrix3 m = maketransform ( dir, up );

setdetailattrib ( 0, "M", m );

@P *= m;

float tol = ch("tolerance");

float s = volumesample ( 1, 0, @P );
if ( s <= tol )
    @Cd = { 1, 1, 0 };

matrix m = detail ( 0, "xform" );
@P *= invert ( m );

matrix m = detail ( 0, "xform" );

vector t = cracktransform ( 0, 0, 0, 0, m );
vector r = cracktransform ( 0, 0, 1, 0, m );

matrix m2 = maketransform ( 0, 0, t, r, 1, 0 );
@P *= invert ( m2 );

vector r = cracktransform ( 0, 3, 1, 0, m );

vector p0 = point ( 1, "P", 0 );
vector p1 = point ( 1, "P", 1 );
vector dir = normalize ( p1 - p0 );

vector x = { 1, 0, 0 };
float angle = radians ( ch("angle") );
matrix3 m = dihedral ( dir, x );
rotate ( m, angle, x );
setdetailattrib ( 0, "M", m );

@P *= m;

matrix3 m = detail ( 1, "M" );
@P *= invert ( m );

int maxpts = chi("maxpts");
int pts [ ] = pcfind ( 0, "P", @P, ch("radius"), maxpts );
if ( len ( pts ) >= maxpts )
    removepoint ( 0, @ptnum );