int pts [ ] = pcfind ( 1, "P", @P, ch("radius"), chi("maxpts") );
i@nearpt = pts [ -1 ];

vector p = point ( 1, "P", i@nearpt );
@dist = distance2 ( @P, p );

vector p0 = point ( 1, "P", 0 );
vector p1 = point ( 2, "P", 0 );

int pt0 = addpoint ( 0, p0 );
int pt1 = addpoint ( 0, p1 );

addprim ( 0, "polyline", pt0, pt1 );

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

def filterEdgeGroup ( edgeGroup ):
    group = []
    names = edgeGroup.split ( ' ' )
    for name in names:
        try:
            edges = geo.globEdges ( name )
        except hou.OperationFailed:
            edges = ( )
        
        for edge in edges:
            p0 = edge.points ( ) [ 0 ]
            p1 = edge.points ( ) [ 1 ]
            
            try:
                isValidEdge = geo.findEdge ( p0, p1 )
            except:
                isValidEdge = False
            
            if not isValidEdge:
                continue
            
            if len ( edge.prims ( ) ):
                group.append ( edge )
    
    return group


def getPolysFromEdges ( edges ):
    polys = []
    for edge in edges:
        polys += edge.prims ( )
    
    return polys


def getPointsFromEdges ( edges ):
    points = set ( )
    for edge in edges:
        points.add ( edge.points ( ) [ 0 ] )
        points.add ( edge.points ( ) [ 1 ] )
    
    return points


def getPointsFromPolys ( polys ):
    points = set ( )
    for poly in polys:
        verts = poly.vertices ( )
        for vert in verts:
            points.add ( vert.point ( ) )
    
    return points


def isValidEdge ( point1, point2 ):
    try:
        group = geo.globEdges ( "p{0}-{1} ".format ( point1, point2 ) )
    except hou.OperationFailed:
        return False
    
    for edge in group:
        p0 = edge.points ( ) [ 0 ]
        p1 = edge.points ( ) [ 1 ]
        
        try:
            return geo.findEdge ( p0, p1 ) != None
        except:
            return False


def getEdgePointsOfPoint ( point ):
    points = hou.hscriptExpression ( "pointneighbours(\"" + node.inputs ( ) [ 0 ].path ( ) + "\", " + str ( point ) + ", 1)" )
    points = points.split ( ' ' )
    points = map ( int, points )
    edgePoints = set ( )
    for pt in points:
        if isValidEdge ( point, pt ):
            edgePoints.add ( geo.iterPoints ( ) [ pt ] )
    
    return edgePoints



group = hou.evalParm ( "group" )
amount = hou.evalParm ( "amount" )
edges = filterEdgeGroup ( group )

if not edges:
    raise hou.NodeWarning ( "No valid edges were found in the group." )

polys = getPolysFromEdges ( edges )
points = getPointsFromEdges ( edges )
outerPoints = getPointsFromPolys ( polys )
outerPoints -= points

if not outerPoints:
    raise hou.NodeWarning ( "No valid edges were found in the group." )

first = outerPoints.pop ( )
source = { first }
innerPoints = { first }

while source:
    edgePoints = getEdgePointsOfPoint ( source.pop ( ).number ( ) )
    shared = edgePoints.intersection ( outerPoints )
    source = source.union ( shared )
    innerPoints = innerPoints.union ( shared )
    outerPoints = outerPoints.difference ( edgePoints )

goals = outerPoints
if ( amount < 0 ):
    goals = innerPoints

for point in points:
    edgePoints = getEdgePointsOfPoint ( point.number ( ) )
    target = edgePoints.intersection ( goals )
    if target:
        p0 = target.pop ( ).position ( )
        p1 = point.position ( )
        point.setPosition ( p1 + ( p0 - p1 ) * abs ( amount ) )

<tool name="clearParameterEditor" label="Clear Parameter Editor" icon="SHELF_convert_to_fluid">
<script scriptType="python"><![CDATA[
from utility_ui import clearParameterEditor
clearParameterEditor()
]]></script>
</tool>

float r = rand ( @ptnum );
float angles [ ] = array ( 0, 180 );
float angle = radians ( angles [ r > 0.5 ] );

p@orient = quaternion ( angle, set ( 0,1,0 ) );

def fullscreenSession():
    window = hou.qt.mainWindow()

    def customShowFullScreen():
        screen = window.screen().geometry()

        if not hasattr(window, "_orig_geom"):
            window._orig_geom = window.geometry()

        window.hide()
        window.setWindowFlags(QtCore.Qt.FramelessWindowHint)

        window.show()
        QtWidgets.QApplication.processEvents()

        window.move(screen.x(), screen.y())
        window.resize(screen.width(), screen.height())

        # Cleaner alternative to +1 pixel trick
        window.setContentsMargins(0, 0, 1, 1)
        window.setFixedSize(screen.width(), screen.height())

        QtWidgets.QApplication.processEvents()
        window.raise_()
        window.activateWindow()
        window.repaint()

    def customExitFullScreen():
        ORIGINAL_WINDOW_FLAGS = QtCore.Qt.WindowType(167833601)

        window.hide()
        window.setWindowFlags(ORIGINAL_WINDOW_FLAGS)

        if hasattr(window, "_orig_geom"):
            window.setGeometry(window._orig_geom)
            del window._orig_geom

        window.setMinimumSize(0, 0)
        window.setMaximumSize(16777215, 16777215)

        window.show()
        QtWidgets.QApplication.processEvents()
        window.raise_()
        window.activateWindow()

    if window.windowFlags() & QtCore.Qt.FramelessWindowHint:
        customExitFullScreen()
        window.showMaximized()
        hou.ui.setHideAllMinimizedStowbars(False)
    else:
        for pane in hou.ui.panes():
            pane.setShowPaneTabs(False)

        customShowFullScreen()
        hou.ui.setHideAllMinimizedStowbars(True)