Method loop_close

flow_control.py:451–531

(self, flow_control, current_image, max_iterations, current_mask=None,
                  iteration_count=0, dynprompt=None, unique_id=None)

                self.collect_contained(child_id, upstream, contained)

    def loop_close(self, flow_control, current_image, max_iterations, current_mask=None,
                  iteration_count=0, dynprompt=None, unique_id=None):
        print(f"Iteration {iteration_count} of {max_iterations}")
        
        # 维度处理
        if len(current_image.shape) == 3:
            current_image = current_image.unsqueeze(0)
        if current_mask is not None and len(current_mask.shape) == 2:
            current_mask = current_mask.unsqueeze(0)

        # 检查是否继续循环
        if iteration_count >= max_iterations - 1:
            print(f"Loop finished with {iteration_count + 1} iterations")
            return (current_image, current_mask if current_mask is not None else torch.zeros_like(current_image[:,:,:,0]))

        # 准备下一次循环
        this_node = dynprompt.get_node(unique_id)
        upstream = {}
        parent_ids = []
        self.explore_dependencies(unique_id, dynprompt, upstream, parent_ids)
        parent_ids = list(set(parent_ids))

        # 获取并处理输出节点
        prompts = dynprompt.get_original_prompt()
        output_nodes = {}
        for id in prompts:
            node = prompts[id]
            if "inputs" not in node:
                continue
            class_type = node["class_type"]
            if class_type in ALL_NODE_CLASS_MAPPINGS:
                class_def = ALL_NODE_CLASS_MAPPINGS[class_type]
                if hasattr(class_def, 'OUTPUT_NODE') and class_def.OUTPUT_NODE == True:
                    for k, v in node['inputs'].items():
                        if is_link(v):
                            output_nodes[id] = v

        # 创建新图
        graph = GraphBuilder()
        self.explore_output_nodes(dynprompt, upstream, output_nodes, parent_ids)
        
        contained = {}
        open_node = flow_control[0]
        self.collect_contained(open_node, upstream, contained)
        contained[unique_id] = True
        contained[open_node] = True

        # 创建节点
        for node_id in contained:
            original_node = dynprompt.get_node(node_id)
            node = graph.node(original_node["class_type"], 
                            "Recurse" if node_id == unique_id else node_id)
            node.set_override_display_id(node_id)
            
        # 设置连接
        for node_id in contained:
            original_node = dynprompt.get_node(node_id)
            node = graph.lookup_node("Recurse" if node_id == unique_id else node_id)