🔬 R18 CG集 品質指標化
​科学的管理システム完全設計書

💡 最重要結論 3点

• 均一化の定量排除が最優先: 表情多様性スコア(EDS)≥0.75・構図バリエーションを指標化し、毎Vol数値確認を義務化する
• 自動5指標 + 目視2指標の分業: ES/CSR/EDS/EroS/MVSは Python自動処理、CCS(髪色)とEroS最終確認のみ目視。月96Vol×120枚=約11,520枚を5分/Volで処理
• QS=80点を出品ゲート: 80点未満Volは即再生成キューへ、60点未満は設定ごと見直し。月間不合格率5%以内が目標

🏮 FANZA AI CG集 2025年市場実態

🎯 なぜ品質の科学化が売上直結するか

• FANZA購入者レビュー「表情が単調」「キャラが途中で変わる」「エロシーンが少ない」が最多NG評価
• EDS (表情多様性) が高い作品はリピート購入率が高く、シリーズ化に成功しやすい
• CCS (一貫性) が低い作品は低評価レビューで検索順位が下落 → 新規流入がゼロに
• QS80以上のVol群は口コミ拡散がおき、自然検索流入が3-5倍になる傾向^[4]

🕛 処理時間試算 (96Vol/月)

定義・計算式

ES = (skin_ratio × 100) + stage_bonus + nipple_bonus + penetration_bonus

ステージ目標偏差ペナルティ: |ES_actual - ES_target| > 15pt → ES_score を10pt減点

ステージ間単調増加チェック: ES(s_n) > ES(s_{n-1}) でなければアラート (逆行エラー)

Pythonコード (自動計算)

import cv2
import numpy as np
from pathlib import Path

# ステージ別設定
STAGE_CONFIG = {
    0: {"target": 10, "bonus": 0,  "range": (5, 20)},
    1: {"target": 32, "bonus": 15, "range": (20, 45)},
    2: {"target": 58, "bonus": 30, "range": (48, 70)},
    3: {"target": 72, "bonus": 40, "range": (60, 82)},
    4: {"target": 83, "bonus": 50, "range": (72, 92)},
    5: {"target": 95, "bonus": 60, "range": (85, 100)},
}

def detect_skin_ratio(img_bgr: np.ndarray) -> float:
    """HSV閾値で肌色領域を検出し画面占有率を返す"""
    hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)
    # 肌色 HSV範囲 (アニメ絵対応・広め設定)
    lower1 = np.array([0,  20, 100])
    upper1 = np.array([18, 180, 255])
    lower2 = np.array([160, 20, 100])  # 赤みがかった肌
    upper2 = np.array([180, 180, 255])
    mask1 = cv2.inRange(hsv, lower1, upper1)
    mask2 = cv2.inRange(hsv, lower2, upper2)
    skin_mask = cv2.bitwise_or(mask1, mask2)
    h, w = img_bgr.shape[:2]
    return np.sum(skin_mask > 0) / (h * w)

def calc_es(img_path: str, stage: int,
            has_nipple: bool = False,
            has_penetration: bool = False) -> dict:
    img = cv2.imread(img_path)
    if img is None:
        return {"es": 0, "error": "cannot_read"}
    cfg = STAGE_CONFIG[stage]
    skin_r = detect_skin_ratio(img)
    es_raw = skin_r * 100 + cfg["bonus"]
    if has_nipple:      es_raw += 10
    if has_penetration: es_raw += 20
    es = min(100, max(0, es_raw))
    lo, hi = cfg["range"]
    in_range = lo <= es <= hi
    penalty  = 10 if abs(es - cfg["target"]) > 15 else 0
    es_score = max(0, es - penalty)  # 100点満点換算スコア
    return {
        "es": round(es, 1),
        "es_score": round(es_score, 1),  # QS計算に使用
        "in_range": in_range,
        "target": cfg["target"],
        "penalty": penalty,
        "skin_ratio_pct": round(skin_r * 100, 2),
    }

def check_stage_monotone(es_list: list) -> bool:
    """s0~s5のESが単調増加しているか確認"""
    return all(es_list[i] <= es_list[i+1] for i in range(len(es_list)-1))

チェックリスト (目視用)

• ✓ s0: 首・手以外の肌が見えていないか確認
• ✓ s3-s4: 挿入シーンが明確に描写されているか
• ✓ s5: 完全脱衣 + 絶頂表情が同一フレームにあるか
• ✗ NGパターン: s2とs3のES値が同程度 (エロ進行が止まっている)

定義・計算式

CSR = (断面図枚数 N_cs) ÷ (総枚数 N_total) × 100

最適配置: s4 (激ピストン) の k=90番前後の1点に固定 (v44e実装済み)

Pythonコード (プロンプトメタデータから自動計算)

import json
from pathlib import Path

def calc_csr_from_metadata(vol_dir: str) -> dict:
    """
    metadata.jsonl から cross_section タグを検索して CSR を計算
    各画像生成時にメタデータ記録が前提 (ComfyUI側で実装)
    """
    vol_path = Path(vol_dir)
    cs_count = 0
    total = 0
    for f in sorted(vol_path.glob("*.json")):
        try:
            meta = json.loads(f.read_text(encoding="utf-8"))
            prompt = meta.get("positive_prompt", "").lower()
            if any(kw in prompt for kw in
                   ["cross.section", "cross_section", "cervix", "womb", "uterus"]):
                cs_count += 1
            total += 1
        except Exception:
            pass
    if total == 0:
        return {"csr": 0, "cs_count": 0, "total": 0, "ok": True}
    csr = cs_count / total * 100
    ok  = cs_count <= 1        # ルール: 最大1枚
    warn = cs_count == 2
    ng  = cs_count >= 3
    # CSR を 100点満点スコアに変換
    if cs_count == 0: csr_score = 90      # 0枚は微減 (多様性観点)
    elif cs_count == 1: csr_score = 100   # 1枚が理想
    elif cs_count == 2: csr_score = 65    # 警告
    else: csr_score = 0                   # 3枚以上は0点
    return {
        "csr": round(csr, 2),
        "cs_count": cs_count,
        "total": total,
        "csr_score": csr_score,
        "ok": ok,
        "warn": warn,
        "ng": ng,
    }

# プロンプトから画像レベルで検出する場合
CROSS_SECTION_KEYWORDS = [
    "cross.section view", "cross_section", "cervix", "uterus",
    "womb", "internal cumshot", "x-ray", "x ray",
]
def is_cross_section(positive_prompt: str) -> bool:
    p = positive_prompt.lower()
    return any(kw in p for kw in CROSS_SECTION_KEYWORDS)

18種表情プール定義

定義・計算式 (Shannon Entropy)

EDS = H(X) / H_max = [-Σ(p_i × log₂(p_i))] / log₂(18)

p_i = 表情i の出現枚数 / 総枚数。EDS=1.0が完全均等分布、EDS=0が1種類しか使っていない状態。

Pythonコード (メタデータから自動計算)

import json, math
from collections import Counter
from pathlib import Path

EXPRESSION_TAGS = [
    "neutral", "smile", "blush", "surprised", "shy",
    "pleasure", "moan", "tears_of_joy", "tears", "ahegao",
    "open_mouth", "tongue_out", "half_closed_eyes", "closed_eyes",
    "wink", "pout", "nervous", "ecstasy",
]
N_POOL = len(EXPRESSION_TAGS)  # 18

def extract_expression(positive_prompt: str) -> str:
    """プロンプトから最もマッチする表情タグを抽出"""
    p = positive_prompt.lower()
    for tag in EXPRESSION_TAGS:
        if tag.replace("_", " ") in p or tag in p:
            return tag
    return "neutral"  # fallback

def calc_eds_from_metadata(vol_dir: str) -> dict:
    vol_path = Path(vol_dir)
    expressions = []
    for f in sorted(vol_path.glob("*.json")):
        try:
            meta = json.loads(f.read_text(encoding="utf-8"))
            expr = extract_expression(meta.get("positive_prompt", ""))
            expressions.append(expr)
        except Exception:
            pass
    if not expressions:
        return {"eds": 0, "eds_score": 0, "distribution": {}}
    counts = Counter(expressions)
    total  = len(expressions)
    entropy = -sum((c/total) * math.log2(c/total)
                   for c in counts.values() if c > 0)
    eds = entropy / math.log2(N_POOL)  # 0.0~1.0

    # 100点換算 (EDS≥0.75=100pt, 0.5=65pt, 0.3=30pt)
    if eds >= 0.75:   eds_score = 100
    elif eds >= 0.60: eds_score = 80
    elif eds >= 0.50: eds_score = 65
    elif eds >= 0.40: eds_score = 50
    else:             eds_score = 30

    # 連続同表情チェック (3連続以上はペナルティ)
    consecutive_penalty = 0
    prev, run = None, 0
    for e in expressions:
        run = run + 1 if e == prev else 1
        if run >= 3:
            consecutive_penalty += 5
        prev = e
    eds_score = max(0, eds_score - consecutive_penalty)

    return {
        "eds": round(eds, 4),
        "eds_score": min(100, eds_score),
        "distribution": dict(counts),
        "consecutive_penalty": consecutive_penalty,
        "unique_expressions": len(counts),
        "total_images": total,
    }

EDS合格基準

4キャラの基準髪色 (HSV Hue範囲)

定義・計算式

CCS = corr(H_ref, H_target) × 70 + (1 - delta_E/100) × 30

corr: Bhattacharyya係数 (0-1)、delta_E: CIE76色差 (参照画像との平均色差)

Pythonコード

import cv2
import numpy as np
from pathlib import Path

# キャラ別髪色HSV範囲 (Hue=0-180 in OpenCV)
CHAR_HAIR_HSV = {
    "akari":  {"lower": np.array([0,   0,  0]),  "upper": np.array([30, 255, 80])},
    "misako": {"lower": np.array([8,  60, 80]),  "upper": np.array([25, 200, 200])},
    "hinata": {"lower": np.array([12, 40,140]),  "upper": np.array([30, 180, 255])},
    "rena":   {"lower": np.array([20, 30, 150]), "upper": np.array([40, 140, 255])},
}

def extract_hair_histogram(img_bgr: np.ndarray, char: str) -> np.ndarray:
    """上部1/4領域から髪色ヒストグラムを抽出"""
    h, w = img_bgr.shape[:2]
    roi = img_bgr[:h//4, :]            # 上1/4に限定
    hsv = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV)
    cfg = CHAR_HAIR_HSV.get(char, CHAR_HAIR_HSV["akari"])
    mask = cv2.inRange(hsv, cfg["lower"], cfg["upper"])
    hist = cv2.calcHist([hsv], [0, 1], mask, [18, 32], [0, 180, 0, 256])
    cv2.normalize(hist, hist)
    return hist

def calc_ccs(ref_img_path: str, target_imgs: list, char: str) -> dict:
    """
    ref_img_path: キャラ三面図 or 初期smoke画像パス
    target_imgs: Volの全画像パスリスト
    """
    ref = cv2.imread(ref_img_path)
    ref_hist = extract_hair_histogram(ref, char)
    scores = []
    for p in target_imgs:
        img = cv2.imread(str(p))
        if img is None:
            continue
        t_hist = extract_hair_histogram(img, char)
        # Bhattacharyya係数 (1=完全一致, 0=全く異なる)
        corr = cv2.compareHist(ref_hist, t_hist, cv2.HISTCMP_BHATTACHARYYA)
        corr_score = (1 - corr) * 100  # 0-100
        scores.append(corr_score)
    if not scores:
        return {"ccs": 0, "ccs_score": 0}
    avg = np.mean(scores)
    low = np.min(scores)
    # 最低値が60以下の枚数 (ドリフト検出)
    drift_count = sum(1 for s in scores if s < 60)
    # ペナルティ: ドリフト枚数×5
    ccs_score = max(0, avg - drift_count * 5)
    return {
        "ccs": round(avg, 2),
        "ccs_score": round(ccs_score, 2),
        "drift_count": drift_count,
        "min_score": round(low, 2),
        "char": char,
        "n_images": len(scores),
    }

# 使用例
# result = calc_ccs("ref/hinata_ref.png",
#                   list(Path("vol_012_hinata").glob("*.png")), "hinata")
# CCS_PASS = result["ccs_score"] >= 85

目視チェックリスト

• ✓ s0とs5の髪色を並べて比較 (最も変化しやすい)
• ✓ akari: 茶系に変わっていないか
• ✓ rena: 銀/白系にドリフトしていないか
• ✗ NG: 同一Vol内でhair colorタグの有無が混在している場合はdrift確定

FANZA/DLsiteユーザー需要ランキング (独自調査・2025年版)

定義・計算式

EroS_raw = 0.40 × aesthetic_score×10 + 0.35 × waifu_score×10 + 0.25 × prompt_bonus

EroS = min(100, EroS_raw)

prompt_bonus: 上記需要ランキングの加点合計 (最大50pt)

Pythonコード

import json
from pathlib import Path

# EroS プロンプト重みマップ
EROS_KEYWORD_WEIGHTS = {
    "ahegao": 15, "rolling eyes": 10,
    "penetration": 12, "vaginal": 8, "sex": 5,
    "nude": 10, "naked": 8, "completely nude": 10,
    "nipples": 8, "bare breasts": 6,
    "moaning": 6, "moan": 6, "open mouth": 4,
    "creampie": 5, "internal cumshot": 5,
    "tears": 4, "teary eyes": 4,
    "armpit": 3,
    "tongue out": 5, "tongue": 3,
    "half.closed eyes": 4, "blush": 3,
    "ecstasy": 8, "orgasm": 10,
}

def calc_prompt_bonus(positive_prompt: str) -> float:
    """プロンプトからEroS加点を計算 (上限50pt)"""
    p = positive_prompt.lower()
    bonus = 0
    for kw, w in EROS_KEYWORD_WEIGHTS.items():
        if kw in p:
            bonus += w
    return min(50.0, bonus)

def calc_eros_from_metadata(
        vol_dir: str,
        aesthetic_scores: dict = None,  # {filename: float 1-10}
        waifu_scores: dict = None       # {filename: float 0-10}
    ) -> dict:
    """
    aesthetic_scores / waifu_scores が None の場合はプロンプト加点のみで計算
    (モデルなし環境でも動作するフォールバック)
    """
    vol_path = Path(vol_dir)
    per_image = []
    for f in sorted(vol_path.glob("*.json")):
        try:
            meta = json.loads(f.read_text(encoding="utf-8"))
            fname = f.stem
            aes = (aesthetic_scores or {}).get(fname, 5.5)   # デフォルト5.5
            wai = (waifu_scores or {}).get(fname, 5.5)       # デフォルト5.5
            pbonus = calc_prompt_bonus(meta.get("positive_prompt", ""))
            # ステージ補正 (s3-s5はボーナス)
            stage = int(meta.get("stage", 0))
            stage_adj = {3: 8, 4: 15, 5: 20}.get(stage, 0)
            eros_raw = 0.40*(aes*10) + 0.35*(wai*10) + 0.25*pbonus + stage_adj
            eros = min(100, max(0, eros_raw))
            per_image.append({"fname": fname, "eros": eros,
                               "aes": aes, "wai": wai, "pbonus": pbonus})
        except Exception:
            pass
    if not per_image:
        return {"eros_score": 0, "n": 0}
    avg_eros = sum(x["eros"] for x in per_image) / len(per_image)
    return {
        "eros_score": round(avg_eros, 2),
        "n": len(per_image),
        "per_image": per_image,
    }

# ---- aesthetic-predictor-v2-5 呼び出しスタブ ----
# pip install aesthetic-predictor-v2-5
# from aesthetic_predictor_v2_5 import convert_v2_5_from_siglip
# model, preprocessor = convert_v2_5_from_siglip()
# pixel_values = preprocessor(images=pil_img, return_tensors="pt").pixel_values
# score = model(pixel_values).logits[0].item()  # 1.0-10.0

EroSと実際の売上相関 (推定)

定義・計算式

MVS = (1 - N_male_face / N_male_visible) × 100

N_male_face: 男の顔が検出された枚数 / N_male_visible: 男が写っている枚数

男が1人も写っていない画像は分母に含めない (s0 introは除外)

Pythonコード

import cv2
import numpy as np
from pathlib import Path

# アニメ顔検出器 (lbpcascade_animeface)
# https://github.com/nagadomi/lbpcascade_animeface
ANIME_CASCADE_PATH = r"D:\projects\fanza3_mass\models\lbpcascade_animeface.xml"

def load_anime_face_detector():
    return cv2.CascadeClassifier(ANIME_CASCADE_PATH)

def detect_male_face(img_bgr: np.ndarray, detector, stage: int) -> dict:
    """
    男の顔を検出する。
    戦略: 画像の下半分・右寄り領域に顔がある場合 = 男の顔の可能性高い
    (女キャラは画面中央～左中心のため)
    """
    if stage == 0:   # s0は男が映らない想定
        return {"male_face_detected": False, "faces": 0}
    h, w = img_bgr.shape[:2]
    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
    faces = detector.detectMultiScale(gray, scaleFactor=1.1,
                                       minNeighbors=5, minSize=(30,30))
    # 顔の位置フィルタ: 画面上部40%以外の顔 = 男の顔候補
    male_faces = []
    for (x, y, fw, fh) in faces:
        if y > h * 0.4:  # 下部に顔 = 男候補
            face_size = fw * fh
            # サイズも考慮: 小さすぎる顔(背景)は除外
            if face_size > (h * w * 0.01):
                male_faces.append((x, y, fw, fh))
    return {
        "male_face_detected": len(male_faces) > 0,
        "male_face_count": len(male_faces),
        "all_faces_detected": len(faces),
    }

def calc_mvs(vol_dir: str, char_stage_map: dict) -> dict:
    """
    vol_dir: Volの画像ディレクトリ
    char_stage_map: {filename: stage} のマッピング
    """
    detector = load_anime_face_detector()
    n_male_visible = 0
    n_male_face    = 0
    flagged = []
    for img_path in sorted(Path(vol_dir).glob("*.png")):
        stage = char_stage_map.get(img_path.name, 3)
        if stage == 0:
            continue   # s0は除外
        img = cv2.imread(str(img_path))
        if img is None:
            continue
        n_male_visible += 1
        result = detect_male_face(img, detector, stage)
        if result["male_face_detected"]:
            n_male_face += 1
            flagged.append(img_path.name)
    if n_male_visible == 0:
        return {"mvs": 100, "mvs_score": 100, "flagged": []}
    mvs = (1 - n_male_face / n_male_visible) * 100
    # MVS≥98 = 100pt, 95-97=80pt, 90-94=60pt, <90=0pt
    if mvs >= 98:   mvs_score = 100
    elif mvs >= 95: mvs_score = 80
    elif mvs >= 90: mvs_score = 60
    else:           mvs_score = 0   # NG: 即確認必須
    return {
        "mvs": round(mvs, 2),
        "mvs_score": mvs_score,
        "n_male_visible": n_male_visible,
        "n_male_face": n_male_face,
        "flagged_images": flagged,
    }

目視チェックリスト

• ✓ s3-s5全画像で男の顔部分が首から上でフレームアウトしているか
• ✓ 後ろから映っている男に顔が反射していないか (鏡・光沢面)
• ✗ NGパターン: 「カメラ目線で男が正面を向いている構図」は即除外

定義・計算式

合否判定ライン

Python 統合実装

import json
from pathlib import Path
from dataclasses import dataclass, asdict

@dataclass
class VolQualityReport:
    vol_id: str
    char: str
    es_score: float
    csr_score: float
    eds_score: float
    ccs_score: float
    eros_score: float
    mvs_score: float

    @property
    def qs(self) -> float:
        return (0.20 * self.es_score  +
                0.10 * self.csr_score +
                0.15 * self.eds_score +
                0.20 * self.ccs_score +
                0.20 * self.eros_score+
                0.15 * self.mvs_score)

    @property
    def verdict(self) -> str:
        q = self.qs
        if q >= 90: return "PREMIUM"
        if q >= 80: return "PASS"
        if q >= 70: return "FIX_MINOR"
        if q >= 60: return "FIX_MAJOR"
        return "REGEN"

    @property
    def weakest_metric(self) -> str:
        scores = {
            "ES": self.es_score, "CSR": self.csr_score,
            "EDS": self.eds_score, "CCS": self.ccs_score,
            "EroS": self.eros_score, "MVS": self.mvs_score,
        }
        return min(scores, key=scores.get)

    def to_json(self, path: str):
        d = asdict(self)
        d["qs"] = round(self.qs, 2)
        d["verdict"] = self.verdict
        d["weakest"] = self.weakest_metric
        Path(path).write_text(json.dumps(d, ensure_ascii=False, indent=2),
                               encoding="utf-8")

def run_full_qa(vol_dir: str, char: str, ref_img: str,
                char_stage_map: dict) -> VolQualityReport:
    """全指標を一括計算して VolQualityReport を返す"""
    from calc_es  import calc_es_vol
    from calc_csr import calc_csr_from_metadata
    from calc_eds import calc_eds_from_metadata
    from calc_ccs import calc_ccs
    from calc_eros import calc_eros_from_metadata
    from calc_mvs import calc_mvs

    vol_id = Path(vol_dir).name
    imgs   = sorted(Path(vol_dir).glob("*.png"))

    es_r   = calc_es_vol(vol_dir, char_stage_map)
    csr_r  = calc_csr_from_metadata(vol_dir)
    eds_r  = calc_eds_from_metadata(vol_dir)
    ccs_r  = calc_ccs(ref_img, imgs, char)
    eros_r = calc_eros_from_metadata(vol_dir)
    mvs_r  = calc_mvs(vol_dir, char_stage_map)

    return VolQualityReport(
        vol_id=vol_id, char=char,
        es_score=es_r["es_score"],
        csr_score=csr_r["csr_score"],
        eds_score=eds_r["eds_score"],
        ccs_score=ccs_r["ccs_score"],
        eros_score=eros_r["eros_score"],
        mvs_score=mvs_r["mvs_score"],
    )

🌐 ダッシュボード全体構成 (Streamlit推奨)

アラート条件一覧

実装スタック推奨

• フロントエンド: Streamlit (Python) — streamlit run qa_dashboard.py でローカル起動
• データストア: D:\projects\fanza3_mass\qa_reports\ 配下のJSONLファイル
• グラフ: Plotly (レーダーチャート + 時系列折れ線)
• 通知: Windows トースト通知 (win10toast) でアラート

🚀 96Vol/月 QAパイプライン全体像

⚠️ 落とし穴 10選

🆕 既存資産活用

📈 30日実装プラン

💵 撤退ライン

• 月間不合格率(REGEN)が15%を超えたら: プロンプト設計を根本から見直す
• QS80以上Volの平均DLが20以下が3ヶ月続いたら: 指標の重み係数を実売データで再キャリブレーション
• CCS平均が75を下回ったら: ComfyUIのモデル設定 (cfg/sampler) を見直す