跳转到主要内容
ComfyUI 原生 Flux 1.1 [pro] Ultra Image 节点 Flux 1.1 [pro] Ultra Image 节点允许你通过文本提示词生成超高分辨率的图像，直接连接 Black Forest Labs 的最新图像生成 API。 此节点支持两种主要使用模式：
  1. 文生图：通过文本提示词生成高质量图像（不使用任何图像收入时）
  2. 图生图：将现有图像与提示词结合，创建融合两者特点的新图像（Remix 模式）
此节点支持通过 API 调用 Ultra 模式，能够生成 4 倍于标准 Flux 1.1 [pro] 分辨率的图像（高达 4MP），同时不牺牲提示词遵循性，并且保持仅 10 秒的超快生成时间。与其他高分辨率模型相比，生成速度提高了 2.5 倍以上。

​
参数说明

​
基本参数

参数类型默认值说明
prompt字符串""生成图像的文本描述
prompt_upsampling布尔值False是否使用提示词上采样技术增强细节。启用后会自动修改提示词以获得更具创造性的生成，但结果会变得不确定（相同种子不会产生完全相同的结果）
seed整数0随机种子值，控制生成的随机性
aspect_ratio字符串”16:9”图像的宽高比，必须在 1:4 到 4:1 之间
raw布尔值False设置为 True 时，生成更少处理痕迹、更自然的图像

​
可选参数

参数类型默认值说明
image_prompt图像无可选输入，用于图生图（Remix）模式
image_prompt_strength浮点数0.1在有image_prompt 输入时生效，调节提示词与图像提示之间的混合程度，值越大输出越接近输入图像，范围为 0.0-1.0

​
输出

输出类型说明
IMAGE图像生成的高分辨率图像结果

​
使用示例

请访问下面的教程查看对应的使用示例

​
工作原理

Flux 1.1 [pro] Ultra 模式利用优化的深度学习架构和高效的 GPU 加速技术，在不牺牲速度的情况下实现高分辨率图像生成。当请求发送到 API 后，系统会解析提示词，应用适当的参数，然后并行计算图像，最终生成并返回高分辨率结果。 与常规模型相比，Ultra 模式特别关注细节保留和大尺寸下的一致性，以确保即使在 4MP 的高分辨率下也能保持令人印象深刻的质量。

​
源码参考

[节点源码 (更新于2025-05-03)] 
class FluxProUltraImageNode(ComfyNodeABC):
    """
    Generates images synchronously based on prompt and resolution.
    """

    MINIMUM_RATIO = 1 / 4
    MAXIMUM_RATIO = 4 / 1
    MINIMUM_RATIO_STR = "1:4"
    MAXIMUM_RATIO_STR = "4:1"

    @classmethod
    def INPUT_TYPES(s):
        return {
            "required": {
                "prompt": (
                    IO.STRING,
                    {
                        "multiline": True,
                        "default": "",
                        "tooltip": "Prompt for the image generation",
                    },
                ),
                "prompt_upsampling": (
                    IO.BOOLEAN,
                    {
                        "default": False,
                        "tooltip": "Whether to perform upsampling on the prompt. If active, automatically modifies the prompt for more creative generation, but results are nondeterministic (same seed will not produce exactly the same result).",
                    },
                ),
                "seed": (
                    IO.INT,
                    {
                        "default": 0,
                        "min": 0,
                        "max": 0xFFFFFFFFFFFFFFFF,
                        "control_after_generate": True,
                        "tooltip": "The random seed used for creating the noise.",
                    },
                ),
                "aspect_ratio": (
                    IO.STRING,
                    {
                        "default": "16:9",
                        "tooltip": "Aspect ratio of image; must be between 1:4 and 4:1.",
                    },
                ),
                "raw": (
                    IO.BOOLEAN,
                    {
                        "default": False,
                        "tooltip": "When True, generate less processed, more natural-looking images.",
                    },
                ),
            },
            "optional": {
                "image_prompt": (IO.IMAGE,),
                "image_prompt_strength": (
                    IO.FLOAT,
                    {
                        "default": 0.1,
                        "min": 0.0,
                        "max": 1.0,
                        "step": 0.01,
                        "tooltip": "Blend between the prompt and the image prompt.",
                    },
                ),
            },
            "hidden": {
                "auth_token": "AUTH_TOKEN_COMFY_ORG",
            },
        }

    @classmethod
    def VALIDATE_INPUTS(cls, aspect_ratio: str):
        try:
            validate_aspect_ratio(
                aspect_ratio,
                minimum_ratio=cls.MINIMUM_RATIO,
                maximum_ratio=cls.MAXIMUM_RATIO,
                minimum_ratio_str=cls.MINIMUM_RATIO_STR,
                maximum_ratio_str=cls.MAXIMUM_RATIO_STR,
            )
        except Exception as e:
            return str(e)
        return True

    RETURN_TYPES = (IO.IMAGE,)
    DESCRIPTION = cleandoc(__doc__ or "")  # Handle potential None value
    FUNCTION = "api_call"
    API_NODE = True
    CATEGORY = "api node/image/bfl"

    def api_call(
        self,
        prompt: str,
        aspect_ratio: str,
        prompt_upsampling=False,
        raw=False,
        seed=0,
        image_prompt=None,
        image_prompt_strength=0.1,
        auth_token=None,
        **kwargs,
    ):
        operation = SynchronousOperation(
            endpoint=ApiEndpoint(
                path="/proxy/bfl/flux-pro-1.1-ultra/generate",
                method=HttpMethod.POST,
                request_model=BFLFluxProUltraGenerateRequest,
                response_model=BFLFluxProGenerateResponse,
            ),
            request=BFLFluxProUltraGenerateRequest(
                prompt=prompt,
                prompt_upsampling=prompt_upsampling,
                seed=seed,
                aspect_ratio=validate_aspect_ratio(
                    aspect_ratio,
                    minimum_ratio=self.MINIMUM_RATIO,
                    maximum_ratio=self.MAXIMUM_RATIO,
                    minimum_ratio_str=self.MINIMUM_RATIO_STR,
                    maximum_ratio_str=self.MAXIMUM_RATIO_STR,
                ),
                raw=raw,
                image_prompt=(
                    image_prompt
                    if image_prompt is None
                    else convert_image_to_base64(image_prompt)
                ),
                image_prompt_strength=(
                    None if image_prompt is None else round(image_prompt_strength, 2)
                ),
            ),
            auth_token=auth_token,
        )
        output_image = handle_bfl_synchronous_operation(operation)
        return (output_image,)