scene = cur_desktop.paneTabOfType(hou.paneTabType.SceneViewer)
flip_options = scene.flipbookSettings().stash()
flip_options.frameRange( (frame, frame) )
flip_options.output(filename)
scene.flipbook(scene.curViewport(), flip_options)

import traceback
from os.path import dirname,basename,splitext

def getSceneViewer():
    """
    return an instance of a visible viewport. 
    There may be many, some could be closed, any visible are current
    """
    panetabs = hou.ui.paneTabs()
    panetabs = [x for x in panetabs if x.type() == hou.paneTabType.SceneViewer]
    panetabs = sorted(panetabs, key=lambda x: x.isCurrentTab())
    if panetabs:
        return panetabs[-1]
    else:
        print("No SceneViewers detected.")
        return None
    
   
def viewwrite():
    """
    Get the current sceneviewer (may be more than one or hidden)
    and screengrab the perspective viewport to a file in the 
    publish location to be picked up with the publish. 
    
    Note that .png output will render pooly, so use .jpg   
    """
    try:
        node = hou.node(".")
        path = node.parm("outputpath").eval()       
        file,ext = splitext(basename(path))
        filename = f'{dirname(path)}/{file}.jpg'
        frame = hou.frame()
    
        desktop = hou.ui.curDesktop()
        sceneview = getSceneViewer()
        viewport = sceneview.curViewport()
    
        # this will open an mplay window to show the result
        fbs = sceneview.flipbookSettings().stash()
        fbs.frameRange( (frame, frame) )
        fbs.output(filename)
        fbs.outputToMPlay(False)
        sceneview.flipbook(viewport, fbs)
            
    except Exception as e:
        print(f'ERROR: Failed to Capture Viewport\n{traceback.format_exc(2)}')
        

from husd import assetutils

viewer = hou.ui.paneTabOfType(hou.paneTabType.SceneViewer)

assetutils.saveThumbnailFromViewer(
    sceneviewer = viewer,
    frame=1,
    res=(512,512),
    output="$HIP/textures/thumbnail.png"
)

import hou
import os
import subprocess
import time
from time import gmtime, strftime
from pathlib import Path
from sys import platform

widthRatio = 4  # Change to make the screenshot bigger or smaller, this is ~x4 node width

def takeScreenShot(savePath):
    ''' Take screenshot with a region select tool for different platforms '''
    Path(os.path.dirname(Path(savePath))).mkdir(parents=True, exist_ok=True)
    
    if platform == "linux" or platform == "linux2":
        savepath = os.path.dirname(Path(savePath))
        screenshotPNG = subprocess.check_output('mv "$(xfce4-screenshooter -ro ls)" -v ' + savepath, shell=True)
        screenshotPNG = screenshotPNG.decode().strip().split('\n')[0].split(' -> ')[1].replace("'", "")
        os.chdir(savepath)
        os.rename(os.path.basename(screenshotPNG), os.path.basename(savePath))
    elif platform == "darwin":
        pass  # Add Mac-specific screenshot logic here if needed
    elif platform == "win32":
        subprocess.check_call([r"C:\Users\vincent\Downloads\MiniCap\MiniCap.exe", "-captureregselect", "-save", savePath, "-exit"])

    # Ensure the screenshot has been saved and the file exists
    if not os.path.exists(savePath):
        raise FileNotFoundError(f"Screenshot not saved at: {savePath}")

def wait_for_image(path, timeout=10):
    ''' Waits until the screenshot image is available '''
    elapsed = 0
    while not os.path.exists(path) and elapsed < timeout:
        time.sleep(0.5)  # Wait 0.5 seconds before checking again
        elapsed += 0.5
    if not os.path.exists(path):
        raise FileNotFoundError(f"Image not found after waiting {timeout} seconds: {path}")

def removeBackgroundImage(**kwargs):
    ''' Removes background image from the network editor '''
    deletingNode = [x[1] for x in kwargs.items()][0]
    image = deletingNode.userData('houdinipath')
    editor = hou.ui.paneTabOfType(hou.paneTabType.NetworkEditor)
    backgroundImagesDic = editor.backgroundImages()
    backgroundImagesDic = tuple(x for x in backgroundImagesDic if x.path() != image)
    editor.setBackgroundImages(backgroundImagesDic)

def changeBackgroundImageBrightness(event_type, **kwargs):
    ''' Changes brightness/visibility if template or bypass flags are checked '''
    nullNode = [x[1] for x in kwargs.items()][0]
    image = nullNode.userData('houdinipath')
    brightness = 1.0
    if nullNode.isBypassed():
        brightness = 0.0
    elif nullNode.isTemplateFlagSet():
        brightness = 0.5
    editor = hou.ui.paneTabOfType(hou.paneTabType.NetworkEditor)
    backgroundImagesDic = editor.backgroundImages()
    for i, item in enumerate(backgroundImagesDic):
        if item.path() == image:
            backgroundImagesDic[i].setBrightness(brightness)
            break
    editor.setBackgroundImages(backgroundImagesDic)

# Generate unique path for screenshot
timestamp = strftime('%Y%m%d_%H%M%S', gmtime())
hipname = str(hou.getenv('HIPNAME'))
hippath = str(hou.getenv('HIP')) + '/screenshots'
screenshotName = hipname + '.' + timestamp + '.png'
systempath = os.path.join(hippath, screenshotName)
houdinipath = f'$HIP/screenshots/{screenshotName}'

# Take screenshot and wait for the file to be created
takeScreenShot(systempath)
wait_for_image(systempath)

# Set up background image plane
editor = hou.ui.paneTabOfType(hou.paneTabType.NetworkEditor)
image = hou.NetworkImage()
image.setPath(houdinipath)

# Create or select null node
sel = hou.selectedNodes()
nullNode = ''
if sel:
    lastSel = sel[-1]
    nullNode = lastSel.parent().createNode('null', 'screenshot')
    if lastSel.outputConnections():
        nullNode.setInput(0, lastSel)
else:
    nullNode = editor.pwd().createNode('null', 'screenshot')
    nullNode.moveToGoodPosition()
    lastSel = nullNode

# Configure image plane placement
nullNode.setUserData('nodeshape', 'task')
nullNode.setPosition(lastSel.position())
nullNode.setColor(hou.Color(0.3, 0.3, 0.3))

# Adjusted node movement to reduce offset
nullNode.move([lastSel.size()[0] * 1.5, -lastSel.size()[1] * 1.5])

# Calculate image resolution and placement
rez = hou.imageResolution(systempath)
ratio = 1.0 * rez[1] / rez[0]
rect = hou.BoundingRect(0, -lastSel.size()[1] * 1.05, widthRatio, -widthRatio * ratio - lastSel.size()[1] * 1.05)
image.setRelativeToPath(nullNode.path())
image.setRect(rect)

# Store the image path as user data instead of a parameter
nullNode.setUserData('houdinipath', houdinipath)

# Attach a function that deletes the background image plane if the corresponding node is deleted
nullNode.addEventCallback((hou.nodeEventType.BeingDeleted,), removeBackgroundImage)

# Attach a function to change visibility or opacity if corresponding node flags are changed
nullNode.addEventCallback((hou.nodeEventType.FlagChanged,), changeBackgroundImageBrightness)

# Add image to network background
backgroundImagesDic = editor.backgroundImages()
backgroundImagesDic = backgroundImagesDic + (image,)
editor.setBackgroundImages(backgroundImagesDic)