Load Images

[AceroMagico]

It would be great if you added to the nodes :

Load Image and Load Batch Images

the ability to change the folder path through a file dialog in addition to writing directly that there is already.

And in the Load Image node if possible, to have a ComboBox with the list of all the images contained in the chosen path folder, to speed up the change of the selected image.

[WASasquatch]

ComfyUI doesn't have the ability to output from nodes to the GUI currently, and doesn't have prompt windows.

I've been waiting for these crucial features. And WAS Node Suite isn't meant to modify base ComfyUI

[AceroMagico]

Ok for the dialog file I understood but why is it not possible to have, using a variant of your system with the written path (but folder not file) , the list of images in a folder and select from the widget the one go to the flow ?

Regarding this, a staging branch with an improvement for Combo widget filter/search is on the way, you see : comfyanonymous/ComfyUI#369 ?

The problems with the ComfyUI original load image node is that :

1. it copies into the input the images that are loaded with the dialog file or by drag and drop. And this is completely non-standard, there is no reason to double the images on the hard disk nor to necessarily have them only in the input as source.

2. That the subfolders of the input are not seen.

3. That the input is loaded only at the server start and if one or more images are added after the start without using the dialog file (for avoid the doubled copy) the widget does not see them until the server restart.

[WASasquatch]

1. 2. And 3. This is a web server and it's the only way to display the images. That's why they exist in input/output and why my nodes show no images for anything outside them. Comfy doesn't want to add base64 support.

A list can't be added because the node will have no input. And the node runs linearly and has no data return from the web front until you run it.

[AceroMagico]

I don't understand why you write :

"That's why they exist in input/output and why my nodes don't show images for anything outside of them."

Your load nodes (both image and image bath) work fine with folders outside the server, even in a different hard disk from the server one.
For example in your Image Load node I can write F:/ThisForlderIsNotInServerPath/test.png in the path field and the image is loaded perfectly.
Same thing with your Load Image Batch node where if I type F:/ThisForlderIsNotInServerPath in the path field the images are indexed perfectly.

In fact, your Load Image Batch node (when used insingle_imagemode) already does almost everything I'm asking.
Except display a field with the combobox list of all the images in the folder specified in the field path.

Now you say:

1. you can't do it because the node has no input
2. the node runs linearly and has no data return from the web front until you run it

Point 1:
It is not true that it has no input; the field path (aka the reference folder from which to take the source images) is the input that is needed to acquire the list of images.

Point 2:
Also not true, when the node starts it can take the list of files contained in the folder and put them in the combobox. The index variable remains as you programmed it but if you then select from the combobox an image this also changes the index variable and we have the new image in the flow at next run.

This way your logic in the code does not have to be changed. Simply instead of selecting an index with the mouse, I select an image in the combobox and the code translates it into the index.

Regarding whether or not you can acquire the list of files from a custom node look at this :

    def INPUT_TYPES(cls):
        return {
            "required": {
                "path": ("STRING", {"default": ""}),
                "index": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
            },
        }

......

def doStuff(self, path, index):
        if not os.path.exists(path):
            raise Exception("Path does not exist")
        images = []
        for image in os.listdir(path):
            if any(image.endswith(ext) for ext in [".png", ".jpg", ".jpeg"]):
                images.append(image)
        image = Image.open(os.path.join(path, images[index]))

(source code VextraNodes)

and with the new Combo widget filter/search is on the way : comfyanonymous/ComfyUI#369 can also be searched by typing

[WASasquatch]

None of that is what I'm talking about. The node will only show image physically on the node for local images within Comfy. Yes, I know my node can load from anywhere, including URLs from the internet, I programmed it that way.

The code you gave has nothing to do with showing images on the node input (and already use similar code), that's down in the INPUT_TYPES which is input. So It would already need to somehow know your destination before you entered it to show a list to select from

[AceroMagico]

I don't want to bore you with this, and I have no doubt that you know better than I do knots that you created. ;)
But I really don't understand.

Perhaps the misunderstanding comes from this :
That the node visually displays the image is not very important since you can attach a preview after the node to see the chosen one. What matters is having the image list in the combobox.

You talk to me about destination but in this case you need a source, a source folder. Maybe by destination you mean the choice of the image among the many in the list. At the first run you cannot know the user's choice but just make a preset on the first combobox item as you just do it with index 0 in your node batch. By the second run the user has chosen the image and then you know the user desired image selection (destination).

The source folder is the one indicated in the field path and it is the one you can use to populate the combobox. try to run this:

[AceroMagico]

import os
import torchvision.transforms.functional as TF
from PIL import Image

class PictureIndex:
    def __init__(self) -> None:
        pass

    @classmethod
    def INPUT_TYPES(cls):
        return {
            "required": {
                "path": ("STRING", {"default": ""}),
                "index": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff}),
            },
        }

    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "doStuff"
    CATEGORY = "VextraNodes"

    def doStuff(self, path, index):
        if not os.path.exists(path):
            raise Exception("Path does not exist")
        images = []
        for image in os.listdir(path):
            if any(image.endswith(ext) for ext in [".png", ".jpg", ".jpeg"]):
                images.append(image)
        image = Image.open(os.path.join(path, images[index]))
        image = TF.to_tensor(image)
        print(image)



        return (image,)

NODE_CLASS_MAPPINGS = {
    "Load Picture Index": PictureIndex,
}

(source code VextraNodes)

[AceroMagico]

as you do an images.append(image) you can also do an append of image names to an array that populates the combobox

[WASasquatch]

The node is already rendered, it doesn't change state after you run it. It just runs defaults and takes input.

Not to mention running means running a prompt, an entire process so that would be extremely counter intuitive and hacky

[WASasquatch]

The node is already rendered, it doesn't change state after you run it. It just runs defaults and takes input.

Not to mention running means running a prompt, an entire process so that would be extremely counter intuitive and hacky

There is no reason to get hacky over this and instead simply wait for ComfyUI to mature. People so desperate over little things that make them want to implement things that would need total rewrite is silly to me.

[AceroMagico]

the checkpointloader node works as I'm pointing out, I don't see what's counterintuitive about it.

I understand your point of view about get hacky, but you will realize that having ComfyUI forcibly copy all source images to the input folder is insane as well, without even being able to subdivide them into subfolders moreover.

if you think it is a small thing okay, but you are getting it wrong because it is not at all from a professional graphics point of view, and a graphics node application is of more interest to professionals than the Sunday ai image renderer Guy, who jumps on things more easy like Midjourney :D

[WASasquatch]

You like to just randomly say "stuff works" without understanding how it works... the checkpoint loader, which was never mentioned here... works how I've already discussed numerous times now. It uses a HARD SET input, to get it's files. This input is already provided to the node before it runs

The batch load images hasn't received it's path to show anything in a input. It would require making the node spit out a list, that you feed to another node, tot hen select from a list of filenames, or copy them all to input to visually browse.

---

In fact I think I'll do that. I've already added dictionary output to Load Text File.

Edit: That's not even possible because the input also isn't accessible accessible accept from within the node when it's running, which doesn't help updating the node with a list of files.

We need a callback when any sort of input is changed that fires another function for a node (not main function, but something designed for a update callback).

[AceroMagico]

Look... even if it were true that I not understood the node input thing, it just because you repeated it a hundred times now I would know :D

I didn't point it out to you for the reason you say, otherwise I would have mentioned it right at the beginning of this conversation.
I pointed it out to you to make you understand that the line we are trying to cross is imposed... and not necessary.
In fact when they write the code for them there is no limit (aka checkpoint loader)

'In fact I think I'll do that. I've already added dictionary output to Load Text File.'
I am glad you are trying to find a solution.

'We need a callback when any sort of input is changed that fires another function for a node (not main function, but something designed for a update callback'
There would be onevent and ontrigger that who could do something similar, if I understood it correctly, but I don't feel like they have implemented it.

[WASasquatch]

'We need a callback when any sort of input is changed that fires another function for a node (not main function, but something designed for a update callback' There would be onevent and ontrigger that who could do something similar, if I understood it correctly, but I don't feel like they have implemented it.

I know there is onchange events for JS, the point is, this functionality needs to be added to ComfyUI, so nodes can get live updates of input change and respond accordingly. Additionally, again ability to output to the node general information or images as base64 would be a game changer. Honestly would be cool if we could just output canvas compatible markdown to do literally anything in the node output area.

[AceroMagico]

I agree that base64 would change the games and compatible markdown is a big thing too!

There is good partial news, I was able to eliminate the use of the index and have the combobox populated automatically as far as the default input folder is concerned, which already and for now is not bad I would say.

the solution is to create the input_types by splitting them into two stages so we can use rootpath into imagename list combobox widget definition and then assign the dictionary directly in def INPUT_TYPES(cls)

works great and now at least for the input folder we can select the image to run from combobox directly.

[AceroMagico]

import os
from PIL import Image
import numpy as np
import torch

# Version automatic ComboBox input Folder Populated
# with image names selection in Combobox
class LoadPicturesList:

    def __init__(self):
        pass

    # Static Custom Inside Class Method for get Images List
    @staticmethod
    def get_filename_listCustom(rootpath):
        supported_image_extensions = {".png", ".jpg", ".jpeg"}
        output_list = []
        if not os.path.exists(rootpath):
            return output_list
        for image in os.listdir(rootpath):
            if any(image.endswith(ext) for ext in supported_image_extensions):
                output_list.append(image)
        return sorted(output_list)

    # Splitted input_types
    rootpath = ""
    input_types = {
        "required": {
            "rootpath": ("STRING", {"default": os.path.abspath("input"), "multiline": False}),
        },
    }

    #test grab rootpath
    print("test rootpath grab " + str(input_types["required"]["rootpath"][1]['default']))

    # so we can use rootpath into imagename list combobox populated widget definition
    input_types["required"].update({
        "imagename": (get_filename_listCustom(str(input_types["required"]["rootpath"][1]['default'])),),
    })

    @classmethod
    def INPUT_TYPES(cls):
        # input_types joined declaration
        return cls.input_types

    RETURN_TYPES = ("IMAGE",)
    FUNCTION = "load_pictures_list"
    CATEGORY = "tests"

    def load_pictures_list(self, rootpath, imagename):
        if not os.path.exists(rootpath):
            raise Exception("Path does not exist")

        image_path = os.path.join(rootpath, imagename)
        i = Image.open(image_path)
        image = i.convert("RGB")
        image = np.array(image).astype(np.float32) / 255.0
        image = torch.from_numpy(image)[None,]

        if 'A' in i.getbands():
            mask = np.array(i.getchannel('A')).astype(np.float32) / 255.0
            mask = 1. - torch.from_numpy(mask)
        else:
            mask = torch.zeros((64, 64), dtype=torch.float32, device="cuda")

        return (image, mask)

NODE_CLASS_MAPPINGS = {
    "Load Pictures List": LoadPicturesList,
}

[AceroMagico]

Now that leaves the point you were saying about how to refresh the combobox when the rootpath changes
and I'm already telling you that this doesn't work:

    def on_input_change(self, changed_input):
        print("on_input_change executed")
        if changed_input == "rootpath":
            rootpath_value = self.input_types["required"]["rootpath"][1]['default']
            self.input_types["required"]["imagename"] = (self.get_filename_listCustom(rootpath_value),)

    def view_ready(self, ui):
        print("View is ready!")
        rootpath_input = ui.inputs["rootpath"]
        rootpath_input.input_widget.bind("<FocusOut>", lambda event: self.on_input_change("rootpath"))

because the events are not called
just a try...

You can have the right folder images list updated and also a desired image index by writing:

    def load_pictures_list(self, rootpath, imagename):
        if not os.path.exists(rootpath):
            raise Exception("Path does not exist")

        # update ok of imagename list
        print("rootpath "+rootpath)
        self.input_types["required"].update({
            "imagename": (self.get_filename_listCustom(rootpath),),
        })

        #test grab from updated imagename ok
        filename_list = self.input_types["required"]["imagename"][0]
        firstImageInfolder = str(filename_list[0])
        print("first Image In new root folder "+firstImageInfolder)

But that doesn't update the combobox obviously.

I'm going to sleep I'm cooked. :D

[WASasquatch]

I know how to do all this, it's the fact the functionality isn't there from the front end, so I am not interested.

[AceroMagico]

But how?
If you are referring to the last message I posted, of course it is not frontend but it is only a test to verify the passage of data.

Compared to the node that I proposed to you instead (as partial solution) I do not understand what there would be frontend if not the fact that not update the populate of the combobox that as I told you remains to be solved and it is possible to add a subfolder target of the input folder as a widget to point to images stored with the order that the user prefers
(this is fundamental compared to an example to a Blender- ComfyUI pipeline. Because it is unthinkable to have images that enter Comfy from different pipeline sources as Blender all mixed in the same input folder)

[WASasquatch]

How many times do I have to flipping say I am not interested in doing any of this until the functionality I want from Comfy is there? I am not debating this anymore.