now fixed old otl selectEdgeLoop, it can work on new ver.

   961   2   0
User Avatar
Member
11 posts
Joined:
Offline
download animatrix__selectEdgeLoop otl
allow Editing of Contents
use new code replace attribwrangle_traverse_edge_loops
now it can work

int Contains(string collection[]; string item)
{
    for ( int i=0; i< len(collection); ++i)
        if (collection[i] == item)
            return 1;
    return 0;
}


int Contains(int collection[]; int item)
{
    for ( int i=0; i< len(collection); ++i)
        if (collection[i] == item)
            return 1;
    return 0;
}


//  VEX grammar doesn't support functions that return arrays.
//  So we are using a dash separated string that represents a collection.

string GetPrimsFromEdge(int input; int pt0; int pt1)
{
    string 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)
            {
                prims += itoa(pr) + "-";
                hedge = hedge_nextequiv(input, hedge);
            }
        }
    }
    return prims;
}


int GetNextPoint (int input; int edgept0; int edgept1; int currentpt)
{
    int pointNeighbors[] = neighbours (input,currentpt);
    
    string sprims = GetPrimsFromEdge (input,edgept0,edgept1);
    string aprims[] = split(sprims, "-");
    int prims[];
    foreach (string s; aprims)
        push (prims,atoi(s));

    int primPoints[];
    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);
            push (primPoints, pointIndex);
        }
    }

    int uniquePoints[];
    for (int i=0; i<len(pointNeighbors); ++i)
    {
        if ( !Contains ( primPoints, pointNeighbors[i]))
            push (uniquePoints,pointNeighbors[i]);
    }
    
    if (len(uniquePoints) == 1)
        return uniquePoints[0];

    return -1;
}


string BuildEdgeList (int input; string edgeCollection)
{
    if (edgeCollection == "")
        return "!*";
    
    string edges[];
    string sedges[] = split(edgeCollection, " ");
    int traverseCount = 0;
    
    int totalCount = len(sedges);
    
    while (len(sedges)>0)
    {
        string sedge;
        sedge = pop(sedges);
        string edgePoints[] = split(sedge,"-");
        
        if (!Contains(edges,sedge))
        {
            ++traverseCount;
            for (int c=0; c<2; ++c )
            {
                int points[];
                int pt0 = atoi (edgePoints[c]);
                int pt1 = atoi (edgePoints[1-c]);
                int currentpt = pt0;
                int lastPoint = pt0;
                push ( points, currentpt );
                int nextPoint = GetNextPoint ( input, pt0, pt1, currentpt );
                //printf( "nextpt: %s\n", nextPoint );
                while ( nextPoint != -1 && nextPoint != lastPoint )
                {
                    pt0 = currentpt;
                    pt1 = nextPoint;
                    currentpt = pt1;
                    push ( points, currentpt );
                    nextPoint = GetNextPoint ( input, pt0, pt1, currentpt );
                    //printf( "nextpt: %s\n", nextPoint );
                }
                
                for (int i=0; i<len(points)-1;++i)
                {
                    int p0 = min(points[i], points[i+1]);
                    int p1 = max(points[i], points[i+1]);
                    push(edges, sprintf("%s-%s",p0,p1));
                    
                }
                
            }
            push ( edges, sedge );
        }
        //else
            //printf( "BYPASS: %s\n", sedge );
    }
    
    string edgelist = "";
    foreach ( string s; edges )
        edgelist += "p" + s + " ";
    
    //printf( "Traversed: %s edges out of %s edges\n", traverseCount, totalCount );
    return edgelist;
}

s@edgelist = BuildEdgeList(0, chs("edges"));


this is for selectEdgeRing
download animatrix__selectEdgeRing otl
allow Editing of Contents
use new code replace attribwrangle_traverse_edge_loops
now it can work


int Contains (string collection[]; string item )
{
    for ( int i = 0; i < len ( collection ); ++i )
        if ( collection [ i ] == item )
            return 1;
    return 0;
}


int Contains ( int collection [ ]; int item )
{
    for ( int i = 0; i < len ( collection ); ++i )
        if ( collection [ i ] == item )
            return 1;
    return 0;
}


//  VEX grammar doesn't support functions that return arrays.
//  So we are using a dash separated string that represents a collection.

string GetPrimsFromEdge ( int input; int pt0; int pt1 )
{
    string 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 )
            { 
                prims += itoa ( pr ) + "-";
                hedge = hedge_nextequiv ( input, hedge );
            }
        }
    }
    return prims;
}


string GetNextEdge ( int input; int edgept0; int edgept1; int currentprim )
{
    int primPoints [ ];
    int count = primvertexcount ( input, currentprim );
    for ( int f = 0; f < count; ++f )
    {
        int vertIndex = vertexindex ( input, currentprim, f );
        int pointIndex = vertexpoint ( input, vertIndex );
        if ( pointIndex != edgept0 && pointIndex != edgept1 )
            push ( primPoints, pointIndex );
    }
    int p0 = min ( primPoints [ 0 ], primPoints [ 1 ] );
    int p1 = max ( primPoints [ 0 ], primPoints [ 1 ] );
    return sprintf ( "%s-%s", p0, p1 );
}


//  Traverse Edges

string BuildEdgeList ( int input; string edgeCollection )
{
    if ( edgeCollection == "" )
        return "!*";
    
    string edges [ ];
    string sedges [ ] = split ( edgeCollection, " " );
    
    int traverseCount = 0;
    int totalCount = len ( sedges );
    
    while ( len ( sedges ) > 0 )
    {
        string sedge;
        sedge = pop(sedges);
        string edgePoints [ ] = split ( sedge, "-" );
        
        if ( !Contains ( edges, sedge ) )
        {
            ++traverseCount;
            
            int pt0 = atoi ( edgePoints [ 0 ] );
            int pt1 = atoi ( edgePoints [ 1 ] );
            string sprims = GetPrimsFromEdge ( input, pt0, pt1 );
            string aprims [ ] = split ( sprims, "-" );
            int firstprims [ ];
            foreach ( string s; aprims )
            {
                int pr = atoi ( s );
                if ( primvertexcount ( input, pr ) == 4 )
                    push ( firstprims, atoi ( s ) );
            }
            
            for ( int i = 0; i < len ( firstprims ); ++i )
            {
                int prims[];
                int currentprim = firstprims [ i ];
                push ( prims, currentprim );
                string nextEdge = GetNextEdge ( input, pt0, pt1, currentprim );
                while ( currentprim != -1 )
                {
                    push ( edges, nextEdge );
                    string edgepts [ ] = split ( nextEdge, "-" );
                    int pt0x = atoi ( edgepts [ 0 ] );
                    int pt1x = atoi ( edgepts [ 1 ] );
                    
                    currentprim = -1;
                    sprims = GetPrimsFromEdge ( input, pt0x, pt1x );
                    aprims = split ( sprims, "-" );
                    foreach ( string s; aprims )
                    {
                        int pr = atoi ( s );
                        if ( primvertexcount ( input, pr ) == 4 && !Contains ( prims, pr ) )
                        {
                            currentprim = atoi ( s );
                            push ( prims, currentprim );
                            nextEdge = GetNextEdge ( input, pt0x, pt1x, currentprim );
                            break;
                        }
                    }
                }
            }
            push ( edges, sedge );
        }
        //else
            //printf( "BYPASS: %s\n", sedge );
    }
    
    string edgelist = "";
    foreach ( string s; edges )
        edgelist += "p" + s + " ";
    
    //printf( "Traversed: %s edges out of %s edges\n", traverseCount, totalCount );
    return edgelist;
}

s@edgelist = BuildEdgeList ( 0, chs("edges") );
User Avatar
Member
27 posts
Joined: Feb. 2017
Offline
Since Houdini 18 you can just use Group Find Path SOP
English is not my native language, sorry in advance for any misunderstanding
User Avatar
Member
11 posts
Joined:
Offline
yes,but you can use this vex code to do other things
  • Quick Links