cowpuncher's picture
Initial Files. You will Need all of them.
c5be659 verified
Raw History Blame Contribute Delete
44.1 kB
"""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)