"""Anima Reference add-on for the Krita "AI Image Diffusion" plugin. What it does Krita's Reference control layers do nothing with Anima styles ("Not supported for Anima"). This add-on makes three of them work, by putting one extra node into the workflows the AI plugin builds whenever such a layer is used together with an Anima style: Reference a character Anima Ref Adapter v2, or SnapRef Style a character and the picture's art style SnapRef, mode "character and style" Face one more picture of the same character SnapRef, several references Nodes: "Anima Ref Adapter" (github.com/ArcAnima/ComfyUI-Anima-Ref-Adapter) and "SnapRef" (github.com/ArcAnima/SnapRef). Only one of the two is ever put into a workflow. How it does it No file of the AI plugin is changed. When Krita starts, a handful of the AI plugin's functions are wrapped in memory. Disable this add-on in Krita's Python Plugin Manager and the AI plugin is exactly as it was. The wrapped functions (AI Image Diffusion 1.53.0): ComfyClient._refresh_models notice the nodes on the server ControlLayer._update_is_supported clearer message when a node is missing ControlLayer.to_api send the reference at full size instead of 224 x 224 workflow.prepare check the request before it is queued workflow.create remember the reference(s) while one workflow is built workflow.apply_attention_mask note the text encoder (SnapRef needs it) workflow.apply_regional_ip_adapter insert the node Things found by running the pieces together (ComfyUI 4da9e2d, tooling nodes ca01116, Anima Ref Adapter f02d54d, SnapRef 1f7e606) and handled here: * Order (Anima Ref Adapter). The node goes after the plugin's region node (ETN_AttentionMask), not before it, where the plugin's own reference hook sits. While a reference is attached the adapter runs its own copy of the Anima forward pass; placed first it skips the region setup. * Regions and reference strength (Anima Ref Adapter). Above ref_guidance 1 the adapter makes one extra model call per step with the reference switched off. The region node misreads that call, which cancels most of the text guidance. With regions the node is run at ref_guidance 1. * Regions and SnapRef do not go together at all. Both replace the model's self-attention function: the region node for the length of one job, SnapRef once and for good. Used in one job, the region node pushes SnapRef's replacement out; that job, or every SnapRef job after it until the server restarts, then stops with "'NoneType' object is not subscriptable". SnapRef is therefore never put into a workflow that has regions. Plain Reference layers use the Anima Ref Adapter there; Style and Face layers are refused with a message. * Control layers. Anima control layers (LLLite) patch the model's projections and only apply to inputs that have exactly as many tokens as the picture being made. If a reference happens to have the same number of tokens, the control is applied to the reference too (both nodes). The reference size is nudged down by 5% steps until the counts differ. """ from __future__ import annotations import inspect import threading import traceback ADDON_VERSION = "1.1" TESTED_VERSIONS = ("1.53.0",) ADAPTER_NODE = "AnimaRefAdapter" SNAPREF_NODE = "SnapRef" # the original node pack's "SnapRef (Advanced)" REGION_NODE = "ETN_AttentionMask" ADAPTER_FILE = "anima_ref_adapter_v2" # the v2 adapter; the older "pilot" file needs other nodes SNAPREF_NEEDS = ("clip", "mode", "ref_megapixels", "image_2", "image_3", "use_batch", "weight_1", "weight_2", "weight_3") MAX_REFERENCES = 2 # different characters: one, or two placed side by side MAX_PICTURES = 5 # pictures of one character (SnapRef) SNAPREF_SLOTS = 3 # image inputs of the SnapRef node; each takes a batch of same-size pictures MAX_REFERENCE_PIXELS = 2 * 1024 * 1024 # larger layers are scaled down before upload RECOMMENDED_GUIDANCE = 4.5 # the adapter author's setting for a normal (cfg 4.5) Anima style REFERENCE_MEGAPIXELS = (1.0, 0.95, 0.9, 0.85, 0.8) # first one whose token count is free; trained on 0.56-1 MP SNAPREF_TOTAL_MEGAPIXELS = 2.0 # all pictures together; one picture is never read above 1 MP MIN_WEIGHT = 0.05 # a picture below this strength is left out MISSING_NODE_TEXT = "Anima Ref Adapter is missing on the server (run install.bat)" MISSING_SNAPREF_TEXT = "SnapRef is missing on the server (run install.bat and answer Y to SnapRef)" # The AI plugin adds its FaceID LoRA to every job that has a Face layer and stops with "LoRA 'face' for # Anima not found" if there is none. It is given this name to find, and the entry is taken out of the # job again before anything is built from it. Never a file. FACE_LORA_PLACEHOLDER = "anima_reference_face_layer_placeholder" CHARACTER, STYLE, EXTRA = "character", "style", "extra" # Strength presets for the control layer's slider (5 positions, interpolated between these). PRESETS = [ {"strength": 0.4, "start": 0.0, "end": 0.6}, {"strength": 1.0, "start": 0.0, "end": 1.0}, {"strength": 1.4, "start": 0.0, "end": 1.0}, ] # Set from the add-on's dialog (Tools > Scripts) and kept in Krita's settings by __init__.py. options = {"prefer_snapref": False} class _State: def __init__(self): self.installed = False self.plugin_version = "" self.tested = False self.error = "" self.originals = [] # (owner, attribute name, original value) self.presets_added = [] # control mode names self.resource_id = "" # Reference + Anima self.resource_ids = {} # role -> resource id, and "face_lora" self.snapref_inputs = () # input names of the SnapRef node on the server self.last_job = "" # what the last workflow used, for the status dialog state = _State() _local = threading.local() # Qt keeps only a weak hold on a function connected as a slot (bound method). The wrappers below # end up connected to the plugin's signals, so they must never be freed, also not after uninstall(). _keep_alive = [] class _Context: """What the node needs while one workflow is being built.""" def __init__(self, engine, vae_name, megapixels, description): self.engine = engine # "v2" or "snapref" self.vae_name = vae_name self.ref_megapixels = megapixels self.description = description # Anima Ref Adapter self.images = [] self.ref_guidance = 1.0 self.ref_end = 1.0 self.lora_name = "" # SnapRef self.adapter = "" self.mode = "char" self.groups = [] # [(pictures of one node input, weight)] self.stitch = False # the first group holds two characters to be placed side by side def _logger(): try: from ai_diffusion.util import client_logger return client_logger except Exception: import logging return logging.getLogger("anima_reference") def ref_guidance_for(strength: float, cfg: float) -> float: """Control layer strength (0 .. 1.5, 1.0 = default) -> the Anima Ref Adapter's ref_guidance. The adapter's author pairs ref_guidance with the text guidance: 4.5 for a normal style (cfg 4.5) and 1 for a turbo setup (cfg 1). Strength 1.0 gives that recommended value, lower strengths go down to 1 (no extra push), higher strengths add up to +1.75. """ recommended = min(RECOMMENDED_GUIDANCE, max(1.0, float(cfg))) strength = max(0.0, float(strength)) if strength <= 1.0: value = 1.0 + (recommended - 1.0) * strength else: value = recommended + (strength - 1.0) * 3.5 return round(min(20.0, max(1.0, value)), 2) def snapref_weight(strength: float) -> float: """Control layer strength -> SnapRef's weight of one picture (1 = as trained, 2 = the node's maximum).""" return round(min(2.0, max(0.0, float(strength))), 2) def _filename(option): return str(option).replace("\\", "/").rsplit("/", 1)[-1].lower() def pick_adapter(options): """The Anima Ref Adapter file to use from the node's list of LoRA files, or None.""" candidates = [o for o in options if ADAPTER_FILE in _filename(o)] if not candidates: return None # The node always lists its own download name, even before the file exists. An entry inside a # sub-folder can only come from a file that is really there, so prefer that one. in_folder = [o for o in candidates if "/" in str(o) or "\\" in str(o)] return (in_folder or candidates)[0] def pick_snapref(options): """The SnapRef weights to use from the node's list of LoRA files, or None. The node lists every LoRA when it finds no SnapRef file, so the name is checked here. Order: v2a stable, the original (bf16) file before its FP8 copy, then newer names first.""" candidates = [o for o in options if "snapref" in _filename(o)] def rank(option): name = _filename(option).replace("snapref", "") # ("snapref" itself contains "pre") stable = "v2a" in name and "pre" not in name return (0 if stable else 1, 1 if "fp8" in name else 0, [-ord(c) for c in name]) return sorted(candidates, key=rank)[0] if candidates else None def is_v2_file(name): return bool(name) and ADAPTER_FILE in _filename(name) def reference_size(images): """Width and height of two pictures placed side by side: the second is scaled to the height of the first (ComfyUI's Image Stitch with match_image_size). One picture: its own size.""" width, height = images[0].width, images[0].height for other in images[1:]: width += int(height * (other.width / other.height)) return width, height def reference_tokens(size, megapixels): """Number of tokens the Anima Ref Adapter turns a reference of this size into (its resize rule).""" width, height = size scale = (megapixels * 1024 * 1024 / (width * height)) ** 0.5 width, height = (max(16, round(d * scale / 16) * 16) for d in (width, height)) return (width // 16) * (height // 16) def snapref_tokens(size, megapixels): """The same for SnapRef: it only ever shrinks, and rounds the sides down to a multiple of 16.""" width, height = size scale = min(1.0, (megapixels * 1024 * 1024 / (width * height)) ** 0.5) width = max(16, int(width * scale) // 16 * 16) height = max(16, int(height * scale) // 16 * 16) return (width // 16) * (height // 16) def target_tokens(width, height): """Number of tokens of a picture generated at this size (8x VAE, 2x2 patches, padded).""" return ((width // 8 + 1) // 2) * ((height // 8 + 1) // 2) def pick_megapixels(size, taken): for megapixels in REFERENCE_MEGAPIXELS: if reference_tokens(size, megapixels) not in taken: return megapixels return REFERENCE_MEGAPIXELS[0] def snapref_budget(count): """Megapixels one picture is read at when there are `count` of them.""" return min(1.0, SNAPREF_TOTAL_MEGAPIXELS / max(1, count)) def pick_snapref_megapixels(sizes, count, taken): """The node's ref_megapixels for pictures of these sizes: the budget, nudged down until no picture has as many tokens as the picture being generated.""" base = snapref_budget(count) for step in REFERENCE_MEGAPIXELS: megapixels = round(base * step, 3) if all(snapref_tokens(size, megapixels) not in taken for size in sizes): return megapixels return round(base, 3) def _partitions(count, limit): """Every way to split the numbers 0 .. count-1 into at most `limit` groups.""" def extend(index, groups): if index == count: yield [list(g) for g in groups] return for group in groups: group.append(index) yield from extend(index + 1, groups) group.pop() if len(groups) < limit: groups.append([index]) yield from extend(index + 1, groups) groups.pop() yield from extend(0, []) def _group_cost(members): """How bad it is to put these (width, height, weight) pictures into one node input: they get one weight, and one canvas size (the unused part is filled with white).""" if len(members) < 2: return 0.0 weights = [m[2] for m in members] # at the same area, a picture of aspect a measures sqrt(a) x 1/sqrt(a) widths = [(m[0] / m[1]) ** 0.5 for m in members] heights = [(m[1] / m[0]) ** 0.5 for m in members] unused = len(members) * (1.0 - 1.0 / (max(widths) * max(heights))) return 10.0 * (max(weights) - min(weights)) + unused def group_pictures(pictures, limit=SNAPREF_SLOTS): """pictures: [(width, height, weight)]. Returns groups of indices, at most `limit` groups: each group goes into one image input of the SnapRef node. Up to `limit` pictures get an input each. With more, the pictures that share an input are the ones closest in weight and shape.""" count = len(pictures) if count <= limit: return [[i] for i in range(count)] best = None for groups in _partitions(count, limit): cost = sum(_group_cost([pictures[i] for i in group]) for group in groups) key = (round(cost, 6), groups) if best is None or key < best: best = key return best[1] def set_engines(models, v2, snap): """Enter what the server has into the AI plugin's own resource list (kept per connection). v2 / snap: the Anima Ref Adapter and SnapRef file names, or None.""" ids = state.resource_ids models.resources[ids[CHARACTER]] = v2 or snap # Reference works with either node models.resources[ids[STYLE]] = snap models.resources[ids[EXTRA]] = snap models.resources[ids["face_lora"]] = FACE_LORA_PLACEHOLDER if snap else None def _need(condition, what): if not condition: raise RuntimeError("AI Image Diffusion looks different than expected: " + what) def _set(owner, name, value): original = getattr(owner, name) _keep_alive.extend((original, value)) state.originals.append((owner, name, original)) setattr(owner, name, value) def _restore(): while state.originals: owner, name, original = state.originals.pop() try: setattr(owner, name, original) except Exception: pass def install(): """Wrap the AI plugin's functions. Safe to call more than once. Never raises.""" if state.installed: return state try: _install() state.installed = True state.error = "" note = "" if state.tested else " (this version is untested, the checks passed)" _logger().info( "Anima Reference add-on " + ADDON_VERSION + ": active for AI Image Diffusion " + state.plugin_version + note ) except Exception as e: _restore() state.installed = False state.error = type(e).__name__ + ": " + str(e) _logger().error("Anima Reference add-on could not start:\n" + traceback.format_exc()) return state def uninstall(): """Undo install(). Used by tests; in Krita, disabling the add-on does the same on restart.""" _restore() try: from ai_diffusion.backend.resources import Arch from ai_diffusion.model.control import ControlPresets presets = ControlPresets.instance()._presets for mode_name in state.presets_added: presets.get(mode_name, {}).pop(Arch.anima.name, None) except Exception: pass state.presets_added = [] try: from ai_diffusion.model.root import root client = root.connection.client_if_connected if client is not None: for resource in state.resource_ids.values(): client.models.resources.pop(resource, None) except Exception: pass state.installed = False def _install(): import ai_diffusion import ai_diffusion.model.model # noqa: F401 (must be loaded before model.control, they import each other) from ai_diffusion.backend import api, comfy_client, resources, workflow from ai_diffusion.backend import client as client_module from ai_diffusion.backend.comfy_workflow import ComfyWorkflow, Output from ai_diffusion.image import Extent, Image from ai_diffusion.model import control as control_module from ai_diffusion.style import StyleSettings from ai_diffusion.util import PluginError try: # Krita 5 from PyQt5.QtCore import Qt except ImportError: # Krita 6 from PyQt6.QtCore import Qt state.plugin_version = str(getattr(ai_diffusion, "__version__", "unknown")) state.tested = state.plugin_version in TESTED_VERSIONS Arch = resources.Arch ControlMode = resources.ControlMode ResourceKind = resources.ResourceKind WorkflowKind = api.WorkflowKind ControlInput = api.ControlInput ControlLayer = control_module.ControlLayer ComfyClient = comfy_client.ComfyClient # ---- Checks first: nothing is changed unless all of them pass ------------------------------ def params(function): return list(inspect.signature(function).parameters) _need(hasattr(Arch, "anima"), "no Anima support") for name in ("reference", "style", "face"): _need(hasattr(ControlMode, name), "ControlMode." + name) _need(params(workflow.create)[:2] == ["i", "models"], "workflow.create") _need(comfy_client.create_workflow is workflow.create, "comfy_client.create_workflow") _need( params(workflow.apply_regional_ip_adapter) == ["w", "model", "regions", "shape", "models"], "workflow.apply_regional_ip_adapter", ) _need(params(workflow.apply_attention_mask)[:4] == ["w", "model", "cond", "clip"], "workflow.apply_attention_mask") _need("models" in params(workflow.prepare), "workflow.prepare") _need(params(ComfyClient._refresh_models)[:2] == ["self", "nodes"], "ComfyClient._refresh_models") _need(params(ControlLayer.to_api) == ["self", "bounds", "time"], "ControlLayer.to_api") _need(params(ControlLayer._update_is_supported) == ["self"], "ControlLayer._update_is_supported") _need(hasattr(ControlLayer, "strength_multiplier"), "ControlLayer.strength_multiplier") for name in ("add", "add_cached", "load_image", "load_vae", "batch_image"): _need(hasattr(ComfyWorkflow, name), "ComfyWorkflow." + name) for name in ("create", "scale", "draw_image"): _need(hasattr(Image, name), "Image." + name) _need(hasattr(client_module.ModelDict, "vae"), "ModelDict.vae") for name in ("generate", "inpaint", "refine", "refine_region", "upscale_tiled"): _need(hasattr(WorkflowKind, name), "WorkflowKind." + name) roles = {ControlMode.reference: CHARACTER, ControlMode.style: STYLE, ControlMode.face: EXTRA} resource_of = { role: resources.resource_id(ResourceKind.ip_adapter, Arch.anima, mode) for mode, role in roles.items() } state.resource_ids = dict(resource_of) state.resource_ids["face_lora"] = resources.resource_id(ResourceKind.lora, Arch.anima, ControlMode.face) state.resource_id = resource_of[CHARACTER] default_vae = StyleSettings.vae.default kinds = ( WorkflowKind.generate, WorkflowKind.inpaint, WorkflowKind.refine, WorkflowKind.refine_region, WorkflowKind.upscale_tiled, ) original_refresh = ComfyClient._refresh_models original_supported = ControlLayer._update_is_supported original_to_api = ControlLayer.to_api original_prepare = workflow.prepare original_create = workflow.create original_attention = workflow.apply_attention_mask original_regional = workflow.apply_regional_ip_adapter prepare_signature = inspect.signature(original_prepare) # ---- 1. Notice the nodes when the plugin lists what the server has ------------------------ def register_engines(models, nodes): v2, snap, inputs = None, None, () if nodes and ADAPTER_NODE in nodes: v2 = pick_adapter(nodes.options(ADAPTER_NODE, "lora_name")) if nodes and SNAPREF_NODE in nodes: inputs = tuple((nodes.inputs(SNAPREF_NODE) or {}).keys()) if all(name in inputs for name in SNAPREF_NEEDS): snap = pick_snapref(nodes.options(SNAPREF_NODE, "adapter")) else: _logger().warning("Anima Reference add-on: the SnapRef node on the server is too old (run install.bat)") state.snapref_inputs = inputs set_engines(models, v2, snap) _logger().info( "Anima Reference add-on: Anima Ref Adapter " + (str(v2) if v2 else "not found") + ", SnapRef " + (str(snap) if snap else "not found") ) def engines(models): """(Anima Ref Adapter file, SnapRef file) on this server; None where one is missing.""" reference = models.resources.get(resource_of[CHARACTER]) return (reference if is_v2_file(reference) else None), (models.resources.get(resource_of[STYLE]) or None) def _refresh_models(self, nodes, *args, **kwargs): result = original_refresh(self, nodes, *args, **kwargs) try: register_engines(self.models, nodes) except Exception: _logger().error("Anima Reference add-on:\n" + traceback.format_exc()) return result # ---- 2. Control layer: is it usable, and what image is sent ------------------------------- def role_of(control): """character / style / extra for a Reference / Style / Face layer in an Anima document.""" try: if control._model.arch is Arch.anima: return roles.get(control.mode) except Exception: pass return None def _update_is_supported(self): original_supported(self) try: role = role_of(self) if self.is_supported or role is None: return from ai_diffusion.model.root import root client = root.connection.client_if_connected if client is not None and not client.models.resources.get(resource_of[role]): self.error_text = MISSING_NODE_TEXT if role == CHARACTER else MISSING_SNAPREF_TEXT except Exception: pass def to_api(self, bounds=None, time=None): if role_of(self) is None: return original_to_api(self, bounds, time) layer = self.layer if not self.is_supported: raise PluginError("Can't use '" + layer.name + "' as control layer: " + self.error_text) if layer.bounds.is_zero: raise PluginError( "Reference layer '" + layer.name + "' is empty (or entirely outside the canvas). " "Pick the layer that holds the reference picture in the control layer's dropdown." ) # The whole layer content, like the plugin does for every reference. The IP-Adapter path # then shrinks it to 224 x 224 for CLIP vision; these nodes read the picture itself. image = layer.get_pixels(None, time) image.make_opaque(background=Qt.GlobalColor.white) image = shrink(image, MAX_REFERENCE_PIXELS) strength = self.strength / self.strength_multiplier return ControlInput(self.mode, image, strength, (self.start, self.end)) def shrink(image, pixels): """The picture scaled down to at most this many pixels (never up).""" area = image.width * image.height if area <= pixels: return image factor = (pixels / area) ** 0.5 return Image.scale(image, Extent(max(1, round(image.width * factor)), max(1, round(image.height * factor)))) def same_size(pictures, megapixels): """Pictures that share one input of the SnapRef node travel as a batch, so they need one size: each is brought to the same area, then centred on a white canvas that fits them all.""" if len(pictures) < 2 or not all(hasattr(p, "_qimage") for p in pictures): return pictures area = min(megapixels * 1024 * 1024, max(p.width * p.height for p in pictures)) scaled = [] for picture in pictures: factor = (area / (picture.width * picture.height)) ** 0.5 extent = Extent(max(1, round(picture.width * factor)), max(1, round(picture.height * factor))) scaled.append(Image.scale(picture, extent)) width, height = max(p.width for p in scaled), max(p.height for p in scaled) canvases = [] for picture in scaled: canvas = Image.create(Extent(width, height), fill=Qt.GlobalColor.white) canvas.draw_image(picture, ((width - picture.width) // 2, (height - picture.height) // 2)) canvases.append(canvas) return canvases # ---- 3. Workflow: which references, which node, and where it goes ------------------------- def collect_references(cond): """(role, control) for every Reference / Style / Face layer: the ones on the root prompt in list order, then the ones attached to regions ordered by where the region sits (left first).""" found = [(roles.get(c.mode), c) for c in cond.control] regional = [] for region in cond.regions: for c in region.control: regional.append((region.bounds.x + region.bounds.width / 2, len(regional), (roles.get(c.mode), c))) regional.sort(key=lambda entry: entry[:2]) found += [entry[2] for entry in regional] return [(role, c) for role, c in found if role is not None and c.image is not None] def plan(i, models): """Context for this job, or None if it has no Anima reference. Raises PluginError with a message meant for the user when the request cannot work.""" checkpoint, cond = i.models, i.conditioning if checkpoint is None or cond is None or i.kind not in kinds: return None if checkpoint.version is not Arch.anima: return None rows = collect_references(cond) if not rows: return None characters = [(role, c) for role, c in rows if role != EXTRA] extras = [c for role, c in rows if role == EXTRA] if not characters: # only Face layers: the first one is the character characters, extras = [(CHARACTER, extras[0])], extras[1:] want_style = any(role == STYLE for role, _ in characters) v2, snap = engines(models) if len(characters) > MAX_REFERENCES: raise PluginError( "Anima can show two different characters at most, and there are " + str(len(characters)) + " Reference/Style layers. For more pictures of the same character, set the extra layers to Face." ) if extras and len(characters) > 1: raise PluginError( "Face layers (more pictures of one character) only work with a single Reference or Style layer. " "With two characters, use one picture each." ) if len(characters) + len(extras) > MAX_PICTURES: raise PluginError( "Anima takes up to " + str(MAX_PICTURES) + " reference pictures of one character (found " + str(len(characters) + len(extras)) + ")." ) needs_snapref = want_style or bool(extras) if len(cond.regions) > 1: # the plugin adds its region node; SnapRef must stay out if needs_snapref: raise PluginError( "Style and Face layers can't be combined with Regions on Anima (SnapRef and Krita's region " "node don't work in one job). Use Reference layers with Regions, or generate without regions." ) if not v2: raise PluginError( "Reference together with Regions needs the Anima Ref Adapter on the server. " "Run install.bat from the Anima Reference package, then restart Krita." ) engine = "v2" elif needs_snapref: if not snap: raise PluginError( "Style and Face layers with an Anima style need SnapRef on the server. Run install.bat from " "the Anima Reference package and answer Y at the SnapRef step, then restart Krita." ) engine = "snapref" elif snap and (options.get("prefer_snapref") or not v2): engine = "snapref" elif v2: engine = "v2" else: raise PluginError( "Reference with an Anima style needs the Anima Ref Adapter on the server. " "Run install.bat from the Anima Reference package, then restart Krita." ) vae_name = checkpoint.vae if checkpoint.vae and checkpoint.vae != default_vae else None taken = generation_tokens(i) if engine == "v2": references = [c for _, c in characters] cfg = i.sampling.cfg_scale if i.sampling is not None else RECOMMENDED_GUIDANCE strength = sum(c.strength for c in references) / len(references) end = max(c.range[1] for c in references) images = [c.image for c in references] who = "1 character" if len(images) == 1 else "2 characters side by side" context = _Context("v2", vae_name, pick_megapixels(reference_size(images), taken), "") context.images = images context.ref_guidance = ref_guidance_for(strength, cfg) context.ref_end = round(min(1.0, max(0.0, float(end))), 2) context.lora_name = v2 context.description = "Anima Ref Adapter: " + who + ", ref_guidance " + str(context.ref_guidance) return context return plan_snapref(characters, extras, want_style, snap, vae_name, taken) def plan_snapref(characters, extras, want_style, adapter, vae_name, taken): what = "character and style" if want_style else "character" if len(characters) == 2: # two characters: one reference picture, left and right pair = [c for _, c in characters] weight = snapref_weight(sum(c.strength for c in pair) / len(pair)) if weight < MIN_WEIGHT: return None images = [c.image for c in pair] megapixels = pick_snapref_megapixels([reference_size(images)], 1, taken) groups, stitch = [(images, weight)], True who = "2 characters side by side, weight " + str(weight) else: pictures = [(c.image, snapref_weight(c.strength)) for c in [characters[0][1]] + extras] pictures = [(image, weight) for image, weight in pictures if weight >= MIN_WEIGHT] if not pictures: return None budget = snapref_budget(len(pictures)) pictures = [(shrink(image, int(budget * 1024 * 1024)), weight) for image, weight in pictures] groups, stitch = [], False for indices in group_pictures([(image.width, image.height, weight) for image, weight in pictures]): weight = round(sum(pictures[n][1] for n in indices) / len(indices), 2) groups.append((same_size([pictures[n][0] for n in indices], budget), weight)) sizes = [(members[0].width, members[0].height) for members, _ in groups] megapixels = pick_snapref_megapixels(sizes, len(pictures), taken) count = str(len(pictures)) + (" picture" if len(pictures) == 1 else " pictures of one character") who = count + ", weight " + " / ".join(str(weight) for _, weight in pictures) context = _Context("snapref", vae_name, megapixels, "SnapRef (" + what + "): " + who) context.adapter = adapter context.mode = "cs" if want_style else "char" context.groups = groups context.stitch = stitch return context def generation_tokens(i): """Token counts of every size this job generates at (first pass, hi-res pass).""" taken = set() try: extents = [i.images.extent.initial, i.images.extent.desired] if i.images is not None else [] if i.crop_upscale_extent is not None: extents.append(i.crop_upscale_extent) for extent in extents: taken.add(target_tokens(extent.width, extent.height)) except Exception: pass return taken def chain_has(w, model, class_type): """True if the chain of nodes that produced this MODEL output contains the node type.""" node_id = str(model.node) for _ in range(200): node = w.root.get(node_id) if node is None: return False if node["class_type"] == class_type: return True source = node["inputs"].get("model") if not (isinstance(source, (list, tuple)) and len(source) == 2): return False node_id = str(source[0]) return False def is_anima_job(i): return i is not None and i.models is not None and i.models.version is Arch.anima def without_placeholder(i): """Take out the FaceID LoRA entry the plugin adds for Face layers (see FACE_LORA_PLACEHOLDER).""" loras = getattr(i.models, "loras", None) if loras and any(lora.name == FACE_LORA_PLACEHOLDER for lora in loras): i.models.loras = [lora for lora in loras if lora.name != FACE_LORA_PLACEHOLDER] def prepare(*args, **kwargs): i = original_prepare(*args, **kwargs) if not is_anima_job(i): return i without_placeholder(i) # Inpainting with an empty prompt normally feeds the surrounding picture to the reference # model as a mild hint. These nodes copy characters, so that would paste the people # around the hole into it. Only layers the user marked as Reference / Style / Face are used. if i.inpaint is not None and getattr(i.inpaint, "use_reference", False): i.inpaint.use_reference = False models = prepare_signature.bind(*args, **kwargs).arguments["models"] plan(i, models) # raises here, before the job is queued, if it cannot work return i def create(i, models, *args, **kwargs): context = None if is_anima_job(i): without_placeholder(i) if i.inpaint is not None and getattr(i.inpaint, "use_reference", False): i.inpaint.use_reference = False context = plan(i, models) if context is not None: state.last_job = context.description previous = getattr(_local, "context", None), getattr(_local, "clip", None) _local.context, _local.clip = context, None try: return original_create(i, models, *args, **kwargs) finally: _local.context, _local.clip = previous def apply_attention_mask(w, model, cond, clip, *args, **kwargs): # Called right before apply_regional_ip_adapter everywhere: the text encoder for SnapRef. _local.clip = getattr(clip, "model", None) return original_attention(w, model, cond, clip, *args, **kwargs) def find_text_encoder(w): for node_id, node in w.root.items(): if node.get("class_type") in ("CLIPLoader", "CLIPLoaderGGUF"): return Output(int(node_id), 0) return None def apply_adapter(w, model, models, context): reference = w.__dict__.get("_anima_reference_image") if reference is None: loaded = [w.load_image(image) for image in context.images] reference = side_by_side(w, loaded) w.__dict__["_anima_reference_image"] = reference vae = w.load_vae(context.vae_name or models.vae) # With regions the adapter's extra reference-off call is misread by the region node # (see the notes at the top), so no extra call there: ref_guidance 1. ref_guidance = 1.0 if chain_has(w, model, REGION_NODE) else context.ref_guidance return w.add_cached( ADAPTER_NODE, 1, model=model, vae=vae, image=reference, lora_name=context.lora_name, ref_guidance=ref_guidance, correction="apg", strength=1.0, ref_end=context.ref_end, ref_megapixels=context.ref_megapixels, ) def side_by_side(w, loaded): reference = loaded[0] for other in loaded[1:]: # as in both nodes' two-character workflows reference = w.add( "ImageStitch", 1, image1=reference, image2=other, direction="right", match_image_size=True, spacing_width=0, spacing_color="white", ) return reference def apply_snapref(w, model, models, context): if chain_has(w, model, REGION_NODE): # plan() refuses this already; never let it through raise PluginError("Style and Face layers can't be combined with Regions on Anima.") clip = getattr(_local, "clip", None) or find_text_encoder(w) if clip is None: raise PluginError("Anima Reference add-on: the workflow has no text encoder node for SnapRef.") inputs = w.__dict__.get("_anima_snapref_inputs") if inputs is None: inputs = [] for pictures, weight in context.groups: loaded = [w.load_image(picture) for picture in pictures] if context.stitch: image = side_by_side(w, loaded) else: image = loaded[0] for other in loaded[1:]: image = w.batch_image(image, other) inputs.append((image, weight)) w.__dict__["_anima_snapref_inputs"] = inputs vae = w.load_vae(context.vae_name or models.vae) values = dict( model=model, clip=clip, vae=vae, image=inputs[0][0], adapter=context.adapter, mode=context.mode, ref_in_uncond=False, ref_megapixels=context.ref_megapixels, strength=0.0, ref_caption="", ref_guidance_on=False, use_batch=not context.stitch and any(len(pictures) > 1 for pictures, _ in context.groups), multi_layout="separate", fidelity=1.0, ) for index, (image, weight) in enumerate(inputs, start=1): values["weight_" + str(index)] = weight if index > 1: values["image_" + str(index)] = image if state.snapref_inputs: # only what this server's node knows values = {name: value for name, value in values.items() if name in state.snapref_inputs} return w.add_cached(SNAPREF_NODE, 1, **values) def apply_regional_ip_adapter(w, model, regions, shape, models): model = original_regional(w, model, regions, shape, models) context = getattr(_local, "context", None) if context is None or models.arch is not Arch.anima: return model if context.engine == "snapref": return apply_snapref(w, model, models, context) return apply_adapter(w, model, models, context) # ---- Install ------------------------------------------------------------------------------ _set(ComfyClient, "_refresh_models", _refresh_models) _set(ControlLayer, "_update_is_supported", _update_is_supported) _set(ControlLayer, "to_api", to_api) _set(workflow, "prepare", prepare) _set(workflow, "create", create) _set(comfy_client, "create_workflow", create) _set(workflow, "apply_attention_mask", apply_attention_mask) _set(workflow, "apply_regional_ip_adapter", apply_regional_ip_adapter) # Strength presets for Reference / Style / Face + Anima, unless the user defined their own. try: presets = control_module.ControlPresets.instance()._presets for mode in roles: by_arch = presets.setdefault(mode.name, {}) if Arch.anima.name not in by_arch: by_arch[Arch.anima.name] = [dict(p) for p in PRESETS] state.presets_added.append(mode.name) except Exception: _logger().warning("Anima Reference add-on: could not add strength presets") # If Krita is already connected (add-on started late), look at the server right away. try: from ai_diffusion.model.root import root client = root.connection.client_if_connected if isinstance(client, ComfyClient): register_engines(client.models, client.models.node_inputs) except Exception: pass def status_text() -> str: """Plain-language status, shown by Tools > Scripts > Anima Reference.""" lines = ["Anima Reference add-on " + ADDON_VERSION, ""] if not state.installed: if state.error: lines.append("NOT ACTIVE.") lines.append("") lines.append("This add-on was made for AI Image Diffusion " + ", ".join(TESTED_VERSIONS) + ".") lines.append("The installed version is " + (state.plugin_version or "unknown") + " and works differently inside:") lines.append(state.error) lines.append("") lines.append("Nothing was changed. Reference with Anima styles stays off until the add-on") lines.append("is updated; everything else in the AI plugin works as before.") else: lines.append("NOT ACTIVE: the AI Image Diffusion plugin is not loaded.") lines.append("Check that it is ticked in Settings > Configure Krita > Python Plugin Manager.") return "\n".join(lines) tested = "tested version" if state.tested else "untested version, checks passed" lines.append("AI Image Diffusion " + state.plugin_version + " (" + tested + ")") lines.append("Add-on: active") try: from ai_diffusion.model.root import root client = root.connection.client_if_connected except Exception: client = None if client is None: lines.append("Server: not connected yet - check again once the AI docker shows Connected") return "\n".join(lines) reference = client.models.resources.get(state.resource_ids.get(CHARACTER, state.resource_id)) snap = client.models.resources.get(state.resource_ids.get(STYLE, "")) or None v2 = reference if is_v2_file(reference) else None lines.append("Server: connected") lines.append("Anima Ref Adapter: " + ("found (" + str(v2) + ")" if v2 else "NOT FOUND on the server")) lines.append("SnapRef: " + ("found (" + str(snap) + ")" if snap else "not found on the server")) lines.append("") if not v2 and not snap: lines.append("Close Krita, run install.bat from the Anima Reference package, start Krita again.") return "\n".join(lines) lines.append("Ready. Control layers that work with an Anima style:") use_snap = bool(snap) and (options.get("prefer_snapref") or not v2) lines.append(" Reference - a character; two layers = left and right character [" + ("SnapRef" if use_snap else "Anima Ref Adapter") + "]") if snap: lines.append(" Style - like Reference, and the picture's art style is taken too [SnapRef]") lines.append(" Face - one more picture of the same character, up to " + str(MAX_PICTURES) + " in total [SnapRef]") else: lines.append(" Style and Face need SnapRef: run install.bat again and answer Y at the SnapRef step.") if state.last_job: lines.append("") lines.append("Last job: " + state.last_job) return "\n".join(lines)