[Inference.Core] Colorize Facial Parts from PoseKPS

This one's a postprocessor, not a preprocessor, and that distinction matters for how you'd actually wire it up. Every other node in this pack takes a raw IMAGE and extracts something from it. This one takes a POSE_KEYPOINT structure - landmark data that's already been extracted by something upstream, like a face mesh or pose detector - and turns it into a colored visualization: a flat-color map showing exactly where the skin, each eye, the nose, and the lips sit, as distinct regions rather than raw coordinates.

The mechanism is drawing, not detection. Feed it keypoints and it renders each facial region in a color you specify, either as small dots at the individual landmark points (mode: point) or as filled shapes covering the whole region (mode: polygon, the default - and the more useful one if you actually want a segmentation-style map rather than a scatter of dots). Seven regions get their own color input as an rgb(...) string: skin, left_eye, right_eye, nose, upper_lip, inner_mouth, and lower_lip, each defaulting to a distinct, deliberately separated color so the regions stay visually distinguishable once rendered. You generally leave these at their defaults unless you're building something downstream that specifically parses these colors back out - the one input worth actually thinking about is mode, dots versus filled regions.

What this is actually for: once you have a face broken into distinct colored regions, you've got something that functions like a mini segmentation map, scoped just to the face - useful for face-region-aware editing or inpainting workflows, where you want to target "just the lips" or "just the eyes" as a mask-like region rather than hand-drawing a mask yourself. The POSE_KEYPOINT input, notably, is required and there's no image input at all - this node does nothing on its own; it needs a face landmark detector earlier in your graph (a MediaPipe Face Mesh node or a DWPose/OpenPose-with-face node) to actually produce the keypoint data first.

This is honestly the most niche, least-documented node in the whole pack - it's a specific downstream utility for face-region workflows rather than a general-purpose ControlNet preprocessor, and it doesn't map onto any of the standard conditioning types (canny, depth, pose, segmentation) that dominate the rest of this list.

Installing it: this ships in LykosAI's ComfyUI-Inference-Core-Nodes pack. LykosAI also makes Stability Matrix, the meta-installer a lot of people use to manage multiple local SD UIs, so this pack's install tends to be more deliberately packaged than a typical solo repo. Search "ComfyUI-Inference-Core-Nodes" in ComfyUI Manager, or manually: cd ComfyUI/custom_nodes && git clone https://github.com/LykosAI/ComfyUI-Inference-Core-Nodes, then run install.py against ComfyUI's Python environment, or pip install -e .[cuda] / .[cuda12] / .[rocm] / .[directml] / .[cpu] matched to your hardware, or a plain pip install -e . without acceleration extras (this node is just drawing shapes from coordinates - it doesn't need onnxruntime). Restart ComfyUI when done.

Troubleshooting: the pack-wide issue people actually hit is ModuleNotFoundError: No module named 'inference_core_nodes' after a git clone, meaning the Python package install step never finished - commonly from install.py running against the wrong interpreter on a portable ComfyUI build, so target python_embeded explicitly there. For this specific node, the most likely thing to go wrong isn't the node itself but what's feeding it - if you get an empty or blank output, check that your upstream pose/face-mesh detector actually produced valid POSE_KEYPOINT data for a detected face before assuming this node is broken; garbage or missing keypoints upstream means nothing to draw downstream.