eKeerar
419 lines
14 KiB
PowerShell
419 lines
14 KiB
PowerShell
param(
|
|
[Parameter(Mandatory=$true)]
|
|
[string]$Source,
|
|
|
|
[string]$OutputDir = "03_Assets\Parts\Images",
|
|
[int]$Width = 520,
|
|
[int]$Height = 900
|
|
)
|
|
|
|
$ErrorActionPreference = "Stop"
|
|
Add-Type -AssemblyName System.Drawing
|
|
|
|
$code = @"
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Drawing.Drawing2D;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
|
|
public static class HarukaRigBuilder
|
|
{
|
|
static readonly string[] PartNames = new string[] {
|
|
"head", "neck", "chest", "pelvis",
|
|
"upperarm_r", "forearm_r", "hand_r",
|
|
"upperarm_l", "forearm_l", "hand_l",
|
|
"thigh_r", "shin_r", "foot_r",
|
|
"thigh_l", "shin_l", "foot_l"
|
|
};
|
|
|
|
public static void Build(string sourcePath, string outputDir, int width, int height)
|
|
{
|
|
Directory.CreateDirectory(outputDir);
|
|
using (var src = new Bitmap(sourcePath))
|
|
using (var keyed = RemoveGreenKey(src))
|
|
{
|
|
Rectangle bbox = FindAlphaBounds(keyed, 8);
|
|
using (var master = NormalizeToCanvas(keyed, bbox, width, height))
|
|
{
|
|
RemoveTinyComponents(master, 24);
|
|
string masterPath = Path.Combine(outputDir, "haruka_part_master_apose.png");
|
|
SavePng(master, masterPath);
|
|
SliceParts(master, outputDir);
|
|
Validate(outputDir, master, width, height);
|
|
}
|
|
}
|
|
}
|
|
|
|
static Bitmap RemoveGreenKey(Bitmap src)
|
|
{
|
|
var dst = new Bitmap(src.Width, src.Height, PixelFormat.Format32bppArgb);
|
|
for (int y = 0; y < src.Height; y++)
|
|
{
|
|
for (int x = 0; x < src.Width; x++)
|
|
{
|
|
Color c = src.GetPixel(x, y);
|
|
int r = c.R, g = c.G, b = c.B;
|
|
int maxRB = Math.Max(r, b);
|
|
int delta = g - maxRB;
|
|
int alpha = 255;
|
|
|
|
if (g > 90 && delta > 35)
|
|
{
|
|
if (delta >= 120) alpha = 0;
|
|
else alpha = Clamp((120 - delta) * 255 / 85, 0, 255);
|
|
|
|
if (alpha < 255)
|
|
{
|
|
int despill = Math.Max(r, b);
|
|
g = Math.Min(g, despill + 8);
|
|
}
|
|
}
|
|
|
|
if (alpha <= 2)
|
|
{
|
|
dst.SetPixel(x, y, Color.FromArgb(0, 0, 0, 0));
|
|
}
|
|
else
|
|
{
|
|
dst.SetPixel(x, y, Color.FromArgb(alpha, r, g, b));
|
|
}
|
|
}
|
|
}
|
|
return dst;
|
|
}
|
|
|
|
static Rectangle FindAlphaBounds(Bitmap bmp, int threshold)
|
|
{
|
|
int minX = bmp.Width, minY = bmp.Height, maxX = -1, maxY = -1;
|
|
for (int y = 0; y < bmp.Height; y++)
|
|
{
|
|
for (int x = 0; x < bmp.Width; x++)
|
|
{
|
|
if (bmp.GetPixel(x, y).A > threshold)
|
|
{
|
|
if (x < minX) minX = x;
|
|
if (x > maxX) maxX = x;
|
|
if (y < minY) minY = y;
|
|
if (y > maxY) maxY = y;
|
|
}
|
|
}
|
|
}
|
|
if (maxX < minX || maxY < minY) return Rectangle.Empty;
|
|
return Rectangle.FromLTRB(minX, minY, maxX + 1, maxY + 1);
|
|
}
|
|
|
|
static Bitmap NormalizeToCanvas(Bitmap src, Rectangle bbox, int width, int height)
|
|
{
|
|
var dst = new Bitmap(width, height, PixelFormat.Format32bppArgb);
|
|
using (var g = Graphics.FromImage(dst))
|
|
{
|
|
g.Clear(Color.Transparent);
|
|
g.CompositingMode = CompositingMode.SourceOver;
|
|
g.CompositingQuality = CompositingQuality.HighQuality;
|
|
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
|
|
g.SmoothingMode = SmoothingMode.HighQuality;
|
|
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
|
|
|
|
float maxW = width - 40f;
|
|
float maxH = height - 40f;
|
|
float scale = Math.Min(maxW / bbox.Width, maxH / bbox.Height);
|
|
int drawW = (int)Math.Round(bbox.Width * scale);
|
|
int drawH = (int)Math.Round(bbox.Height * scale);
|
|
int drawX = (width - drawW) / 2;
|
|
int drawY = 20;
|
|
if (drawY + drawH > height - 20) drawY = (height - drawH) / 2;
|
|
g.DrawImage(src, new Rectangle(drawX, drawY, drawW, drawH), bbox, GraphicsUnit.Pixel);
|
|
}
|
|
HardClearGreen(dst);
|
|
DespillGreenBias(dst);
|
|
return dst;
|
|
}
|
|
|
|
static void HardClearGreen(Bitmap bmp)
|
|
{
|
|
for (int y = 0; y < bmp.Height; y++)
|
|
{
|
|
for (int x = 0; x < bmp.Width; x++)
|
|
{
|
|
Color c = bmp.GetPixel(x, y);
|
|
if (c.A == 0) continue;
|
|
int maxRB = Math.Max(c.R, c.B);
|
|
if (c.G > 70 && c.G - maxRB > 30)
|
|
{
|
|
int a = c.G - maxRB > 80 ? 0 : Math.Max(0, c.A - 140);
|
|
int g = Math.Min(c.G, maxRB + 5);
|
|
bmp.SetPixel(x, y, a == 0 ? Color.FromArgb(0, 0, 0, 0) : Color.FromArgb(a, c.R, g, c.B));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void DespillGreenBias(Bitmap bmp)
|
|
{
|
|
for (int y = 0; y < bmp.Height; y++)
|
|
{
|
|
for (int x = 0; x < bmp.Width; x++)
|
|
{
|
|
Color c = bmp.GetPixel(x, y);
|
|
if (c.A == 0) continue;
|
|
if (c.G > c.R + 6 && c.G > c.B + 10)
|
|
{
|
|
int g = Math.Min(c.G, Math.Max(c.R, c.B) + 4);
|
|
int a = c.A;
|
|
if (c.A < 235 && c.G > Math.Max(c.R, c.B) + 18) a = Math.Max(0, c.A - 35);
|
|
bmp.SetPixel(x, y, Color.FromArgb(a, c.R, g, c.B));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void SliceParts(Bitmap master, string outputDir)
|
|
{
|
|
Rectangle bb = FindAlphaBounds(master, 8);
|
|
var parts = new Dictionary<string, Bitmap>();
|
|
foreach (string name in PartNames)
|
|
parts[name] = new Bitmap(master.Width, master.Height, PixelFormat.Format32bppArgb);
|
|
|
|
for (int y = 0; y < master.Height; y++)
|
|
{
|
|
for (int x = 0; x < master.Width; x++)
|
|
{
|
|
Color c = master.GetPixel(x, y);
|
|
if (c.A == 0) continue;
|
|
string part = ClassifyPixel(c, x, y, bb);
|
|
parts[part].SetPixel(x, y, c);
|
|
}
|
|
}
|
|
|
|
foreach (var kv in parts)
|
|
{
|
|
string path = Path.Combine(outputDir, "haruka_part_" + kv.Key + ".png");
|
|
SavePng(kv.Value, path);
|
|
kv.Value.Dispose();
|
|
}
|
|
}
|
|
|
|
static void RemoveTinyComponents(Bitmap bmp, int minPixels)
|
|
{
|
|
int w = bmp.Width, h = bmp.Height;
|
|
bool[] seen = new bool[w * h];
|
|
int[] stack = new int[w * h];
|
|
int[] comp = new int[w * h];
|
|
int[] dx = new int[] { 1, -1, 0, 0 };
|
|
int[] dy = new int[] { 0, 0, 1, -1 };
|
|
|
|
for (int y = 0; y < h; y++)
|
|
{
|
|
for (int x = 0; x < w; x++)
|
|
{
|
|
int start = y * w + x;
|
|
if (seen[start] || bmp.GetPixel(x, y).A == 0) continue;
|
|
|
|
int top = 0, count = 0;
|
|
stack[top++] = start;
|
|
seen[start] = true;
|
|
|
|
while (top > 0)
|
|
{
|
|
int id = stack[--top];
|
|
comp[count++] = id;
|
|
int cx = id % w;
|
|
int cy = id / w;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
int nx = cx + dx[i], ny = cy + dy[i];
|
|
if (nx < 0 || nx >= w || ny < 0 || ny >= h) continue;
|
|
int nid = ny * w + nx;
|
|
if (seen[nid]) continue;
|
|
seen[nid] = true;
|
|
if (bmp.GetPixel(nx, ny).A > 0) stack[top++] = nid;
|
|
}
|
|
}
|
|
|
|
if (count < minPixels)
|
|
{
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
int id = comp[i];
|
|
bmp.SetPixel(id % w, id / w, Color.FromArgb(0, 0, 0, 0));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static string ClassifyPixel(Color c, int x, int y, Rectangle bb)
|
|
{
|
|
double nx = (x - bb.Left) / (double)Math.Max(1, bb.Width);
|
|
double ny = (y - bb.Top) / (double)Math.Max(1, bb.Height);
|
|
double cx = bb.Left + bb.Width * 0.5;
|
|
bool screenLeft = x < cx;
|
|
double dx = Math.Abs((x - cx) / Math.Max(1.0, bb.Width));
|
|
|
|
bool hair = IsHair(c);
|
|
bool skin = IsSkin(c);
|
|
|
|
if (hair && ny < 0.54) return "head";
|
|
if (ny < 0.255) return "head";
|
|
if (hair && dx > 0.18 && ny < 0.58) return "head";
|
|
|
|
if (skin && dx < 0.09 && ny >= 0.235 && ny < 0.335) return "neck";
|
|
|
|
bool sideArmZone = dx > 0.18 && ny >= 0.28 && ny < 0.65;
|
|
if (sideArmZone)
|
|
{
|
|
string side = screenLeft ? "_r" : "_l";
|
|
bool farHand = (screenLeft && nx < 0.25 && ny >= 0.455) || (!screenLeft && nx > 0.75 && ny >= 0.455);
|
|
if (skin && farHand) return "hand" + side;
|
|
if (ny < 0.435) return "upperarm" + side;
|
|
if (ny < 0.595) return "forearm" + side;
|
|
return "hand" + side;
|
|
}
|
|
|
|
if (ny < 0.33)
|
|
{
|
|
if (dx < 0.085) return "neck";
|
|
return "head";
|
|
}
|
|
|
|
if (ny < 0.505)
|
|
{
|
|
if (dx > 0.15)
|
|
{
|
|
string side = screenLeft ? "_r" : "_l";
|
|
return ny < 0.43 ? "upperarm" + side : "forearm" + side;
|
|
}
|
|
return "chest";
|
|
}
|
|
|
|
if (ny < 0.625)
|
|
{
|
|
if (dx > 0.24 && skin)
|
|
{
|
|
string side = screenLeft ? "_r" : "_l";
|
|
return "hand" + side;
|
|
}
|
|
return "pelvis";
|
|
}
|
|
|
|
if (ny < 0.755)
|
|
return screenLeft ? "thigh_r" : "thigh_l";
|
|
|
|
if (ny < 0.895)
|
|
return screenLeft ? "shin_r" : "shin_l";
|
|
|
|
return screenLeft ? "foot_r" : "foot_l";
|
|
}
|
|
|
|
static bool IsHair(Color c)
|
|
{
|
|
return c.R > 95 && c.R > c.G + 22 && c.G > c.B - 8 && c.B < 155;
|
|
}
|
|
|
|
static bool IsSkin(Color c)
|
|
{
|
|
return c.R > 190 && c.G > 125 && c.B > 95 && c.R >= c.G && c.G >= c.B - 18;
|
|
}
|
|
|
|
static void Validate(string outputDir, Bitmap master, int width, int height)
|
|
{
|
|
string reportPath = Path.Combine(outputDir, "_validation.txt");
|
|
using (var sw = new StreamWriter(reportPath, false))
|
|
{
|
|
sw.WriteLine("Haruka rig part build validation");
|
|
sw.WriteLine("Canvas: " + width + "x" + height);
|
|
sw.WriteLine("Master: haruka_part_master_apose.png");
|
|
foreach (string name in PartNames)
|
|
{
|
|
string path = Path.Combine(outputDir, "haruka_part_" + name + ".png");
|
|
using (var img = new Bitmap(path))
|
|
{
|
|
Rectangle b = FindAlphaBounds(img, 8);
|
|
sw.WriteLine(Path.GetFileName(path) + " | " + img.Width + "x" + img.Height + " | " + img.PixelFormat + " | bbox=" + RectText(b));
|
|
}
|
|
}
|
|
int missing, extra, differing, multiCovered;
|
|
DirectCoverageCheck(outputDir, master, out missing, out extra, out differing, out multiCovered);
|
|
sw.WriteLine("Direct coverage check | missing=" + missing + " | extra=" + extra + " | differing=" + differing + " | multi_covered=" + multiCovered);
|
|
}
|
|
}
|
|
|
|
static void DirectCoverageCheck(string outputDir, Bitmap master, out int missing, out int extra, out int differing, out int multiCovered)
|
|
{
|
|
missing = 0;
|
|
extra = 0;
|
|
differing = 0;
|
|
multiCovered = 0;
|
|
|
|
var loaded = new List<Bitmap>();
|
|
try
|
|
{
|
|
foreach (string name in PartNames)
|
|
loaded.Add(new Bitmap(Path.Combine(outputDir, "haruka_part_" + name + ".png")));
|
|
|
|
for (int y = 0; y < master.Height; y++)
|
|
{
|
|
for (int x = 0; x < master.Width; x++)
|
|
{
|
|
Color m = master.GetPixel(x, y);
|
|
int hits = 0;
|
|
Color last = Color.Transparent;
|
|
foreach (var part in loaded)
|
|
{
|
|
Color c = part.GetPixel(x, y);
|
|
if (c.A > 0)
|
|
{
|
|
hits++;
|
|
last = c;
|
|
}
|
|
}
|
|
|
|
if (m.A > 0 && hits == 0) missing++;
|
|
if (m.A == 0 && hits > 0) extra++;
|
|
if (hits > 1) multiCovered++;
|
|
if (m.A > 0 && hits > 0)
|
|
{
|
|
int d = Math.Abs(m.A - last.A) + Math.Abs(m.R - last.R) + Math.Abs(m.G - last.G) + Math.Abs(m.B - last.B);
|
|
if (d != 0) differing++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
foreach (var bmp in loaded) bmp.Dispose();
|
|
}
|
|
}
|
|
|
|
static string RectText(Rectangle r)
|
|
{
|
|
return r.Left + "," + r.Top + "," + r.Width + "," + r.Height;
|
|
}
|
|
|
|
static void SavePng(Bitmap bmp, string path)
|
|
{
|
|
bmp.Save(path, ImageFormat.Png);
|
|
}
|
|
|
|
static int Clamp(int v, int min, int max)
|
|
{
|
|
return v < min ? min : (v > max ? max : v);
|
|
}
|
|
}
|
|
"@
|
|
|
|
Add-Type -TypeDefinition $code -ReferencedAssemblies "System.Drawing"
|
|
|
|
$resolvedSource = (Resolve-Path -LiteralPath $Source).Path
|
|
$resolvedOut = if (Test-Path -LiteralPath $OutputDir) {
|
|
(Resolve-Path -LiteralPath $OutputDir).Path
|
|
} else {
|
|
New-Item -ItemType Directory -Path $OutputDir -Force | Out-Null
|
|
(Resolve-Path -LiteralPath $OutputDir).Path
|
|
}
|
|
|
|
[HarukaRigBuilder]::Build($resolvedSource, $resolvedOut, $Width, $Height)
|
|
Write-Output "Generated Haruka rig parts in $resolvedOut"
|