Release v1.2.0

Add Github Action for Publishing to Comfy Registry

.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - "pyproject.toml"
+
+permissions:
+  issues: write
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'shin131002' }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@v1
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

.gitignore

@@ -4,13 +4,41 @@ __pycache__/
 *$py.class
 *.so
 .Python
+*.egg-info/
+dist/
+build/
 
-# IDE
+# IDEs
 .vscode/
 .idea/
 *.swp
 *.swo
+*~
 
 # OS
 .DS_Store
-Thumbs.db
+Thumbs.db
+desktop.ini
+
+# Personal folders
+old/
+backup/
+test/
+tmp/
+temp/
+archive/
+_old/
+_backup/
+_test/
+
+# Development files
+DEVELOPMENT_SUMMARY.md
+note_article.md
+release_notes_*.md
+*_backup.md
+*_fixed.toml
+__init___no_advanced.py
+
+# User data
+*.log
+*.cache

CHANGELOG.md

@@ -0,0 +1,138 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [1.2.0] - 2026-01-13
+
+### Added
+
+#### New Node: Filtered Random LoRA Loader (LBW)
+- **LoRA Block Weight (LBW) support** for precise effect control
+- **Automatic SD1.5/SDXL detection** - no manual model type selection needed
+- **4 preset modes**: Style Focused, Character Focused, Structure/Composition Only, Balanced/Soft
+- **Preset: Random mode** - randomly selects one of the 4 presets
+- **Direct Input mode** - custom weight specification with auto-adjustment
+- **Automatic weight adjustment** - handles mismatched element counts
+  - Too few elements: pads with 1.0 at the end
+  - Too many elements: truncates from the end
+- U-Net block structure support:
+  - SDXL: 20 elements (BASE + IN:9 + MID:1 + OUT:9)
+  - SD1.5: 17 elements (BASE + IN:6 + MID:1 + OUT:9)
+- LBW syntax output in `positive_text` for Wildcard Encode compatibility
+- Includes all features from Filtered Random LoRA Loader
+
+#### Video Preview Support (All Nodes)
+- Video file preview support (.mp4, .webm, .avi, .mov)
+- Extracts first frame as static image
+- Requires optional `opencv-python` dependency
+- Graceful fallback to black screen with warning if opencv-python not installed
+- Priority order: static images → animated images → video files
+
+### Changed
+
+#### Model Compatibility
+- ⚠️ **Explicitly SD1.5/SDXL only** - other architectures (Flux, SD3, etc.) not supported
+- LBW feature specifically designed for SD1.5/SDXL U-Net structure
+
+#### Dependencies
+- Added optional dependency: `opencv-python` (for video preview only)
+- Core functionality works without opencv-python
+
+### Technical Details
+
+#### LBW Implementation
+- Direct tensor weight manipulation for precise block control
+- Automatic LoRA type detection via output_blocks analysis
+- Compatible with serial node chaining (different LBW per node)
+- Zero weight (all 0) = complete LoRA disable
+
+#### Preview Image Processing
+- Pillow-only support: .png, .jpg, .jpeg, .gif, .webp (always works)
+- opencv-python support: .mp4, .webm, .avi, .mov (optional)
+- First-frame extraction for animated/video formats
+- Consistent 1240px preprocessing
+
+### Performance
+- No performance impact when LBW not used (Normal mode)
+- Metadata caching unchanged from v1.1.0
+
+---
+
+## [1.1.0] - 2026-01-04
+
+### Added
+
+#### New Node: Filtered Random LoRA Loader
+- Single folder with keyword filtering capabilities
+- Space-separated keyword search with phrase support (`"..."`)
+- AND/OR filtering modes
+- Metadata search with caching (instant 2nd+ time)
+- Designed for chaining multiple instances
+- Supports all features from Random LoRA Loader
+
+#### Preview Image Output (Both Nodes)
+- New `preview` output (IMAGE type)
+- Long edge resized to 1240px (aspect ratio preserved)
+- Center-padded to 1240x1240 for batch compatibility
+- Partial filename matching (case-insensitive)
+- Example: `anime_v1.safetensors` matches `anime_v1.png`, `anime_v1_preview.jpg`, etc.
+
+#### Duplicate Filename Handling (Both Nodes)
+- New `unique_by_filename` parameter (default: `True`)
+- Prevents selecting same LoRA from different subfolders
+- Example: `/style/lora.safetensors` and `/backup/lora.safetensors` → only one selected
+- Logs duplicate detections with paths
+
+### Changed
+
+#### Both Nodes
+- **Breaking**: Split `additional_prompt` into `additional_prompt_positive` and `additional_prompt_negative`
+- Unified strength precision to 1 decimal place (was 2 for Filtered, 1 for Random)
+- Improved LoRA syntax removal from CONDITIONING generation
+
+#### Filtered Random LoRA Loader
+- Better handling when `num_loras` exceeds available files (fills with duplicates)
+- Removed `control_after_generate` (use ComfyUI's default seed control)
+
+### Fixed
+
+#### Both Nodes
+- Fixed negative_text output in `json_sample_prompt` mode
+- Fixed LoRA syntax (`<lora:...>`) appearing in metadata trigger words
+- Fixed parameter order consistency
+
+#### Random LoRA Loader
+- Fixed duplicate parameter in INPUT_TYPES
+
+### Performance
+
+#### Metadata Search Caching
+- Initial load time (SSD):
+  - 1,000 files: ~2 seconds
+  - 5,000 files: ~10 seconds
+  - 10,000 files: ~20 seconds
+  - 20,000 files: ~40 seconds
+  - 50,000 files: ~100 seconds
+- 2nd+ time: Instant (<100ms)
+- Memory usage: ~150MB per 10,000 files
+- Progress display for large collections
+
+---
+
+## [1.0.0] - 2025-12-30
+
+### Initial Release
+
+#### Random LoRA Loader
+- 3-group folder selection
+- Multi-source metadata reading (`.metadata.json`, `.info`, embedded)
+- Strength randomization with range specification
+- Multiple trigger word sources
+- Sample prompt support with LoRA syntax removal
+- Wildcard Encode (Inspire) compatibility
+
+#### Core Features
+- No additional dependencies (uses Python stdlib + ComfyUI)
+- Automatic trigger word extraction
+- CONDITIONING output with cleaned prompts
+- Seed control integration

README_LBW.md

@@ -0,0 +1,382 @@
+# Filtered Random LoRA Loader (LBW)
+
+**LoRA Block Weight (LBW) support with automatic SD1.5/SDXL detection**
+
+![FilteredRandomLoRALoader(LBW) Workflow Example](./images/lbw_final_single.webp)
+
+---
+
+## Features
+
+### **Core Features (from Filtered Random LoRA Loader)**
+- ✅ Random LoRA selection from a single folder
+- ✅ Keyword filtering (AND/OR modes)
+- ✅ Metadata search (filename or embedded metadata)
+- ✅ Preview images (static/animated/video support)
+- ✅ Trigger word extraction
+- ✅ Duplicate removal by filename
+- ✅ Direct serial connection support
+
+### **Advanced Features (LBW)**
+- ✅ **LoRA Block Weight (LBW) support**
+- ✅ **Automatic SD1.5/SDXL detection**
+- ✅ **4 preset modes + custom input**
+- ✅ **Automatic weight adjustment**
+
+---
+
+## LoRA Block Weight (LBW)
+
+### **What is LBW?**
+
+LoRA Block Weight allows you to control which parts of the U-Net model are affected by the LoRA:
+
+- **INPUT blocks**: Structure, composition, layout
+- **MIDDLE block**: Overall features
+- **OUTPUT blocks**: Style, details, fine-tuning
+
+By adjusting weights for each block, you can precisely control the LoRA's effect.
+
+---
+
+## Weight Modes
+
+### **1. Normal (All 1.0)** - Default
+All blocks weighted at 1.0 (standard LoRA application, no LBW).
+
+---
+
+### **2. Style Focused**
+Emphasizes OUTPUT blocks only.
+
+**Best for:**
+- Style LoRAs
+- Art style transfer
+- Visual aesthetic changes
+
+**SDXL:** `1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1`  
+**SD1.5:** `1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1`
+
+**Effect:**
+- ✅ Strong style changes
+- ❌ Minimal structure/character changes
+
+---
+
+### **3. Character Focused**
+Emphasizes INPUT (early) + MIDDLE + OUTPUT blocks.
+
+**Best for:**
+- Character LoRAs
+- Face/feature preservation
+- Balanced application
+
+**SDXL:** `1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1`  
+**SD1.5:** `1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1`
+
+**Effect:**
+- ✅ Strong character features
+- ✅ Balanced overall effect
+
+---
+
+### **4. Structure/Composition Only**
+Emphasizes INPUT + MIDDLE blocks only.
+
+**Best for:**
+- Pose LoRAs
+- Composition LoRAs
+- Layout/structure control
+
+**SDXL:** `1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0`  
+**SD1.5:** `1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0`
+
+**Effect:**
+- ✅ Strong structure/pose changes
+- ❌ Minimal style changes
+
+---
+
+### **5. Balanced / Soft**
+Soft application across selected blocks.
+
+**Best for:**
+- Subtle effects
+- Multi-LoRA workflows
+- General-purpose LoRAs
+
+**SDXL:** `1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0`  
+**SD1.5:** `1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,0`
+
+**Effect:**
+- ✅ Balanced, gentle application
+- ✅ Good for stacking multiple LoRAs
+
+---
+
+### **6. Preset: Random**
+Randomly selects one of the 4 presets above.
+
+**Best for:**
+- Experimentation
+- Variation generation
+- Random effects
+
+---
+
+### **7. Direct Input**
+Custom weight specification.
+
+**Format:**
+- SDXL: 20 comma-separated values
+- SD1.5: 17 comma-separated values
+
+**Example (SDXL):**
+```
+1,0.5,0.5,0.3,0.3,0.3,0.3,0.3,0.3,0.3,0.7,0.7,0.7,1,1,1,1,1,1,1
+```
+
+**Auto-adjustment:**
+- If too few elements: pads with 1.0 at the end
+- If too many elements: truncates from the end
+
+---
+
+## Block Structure
+
+### **SDXL (20 elements)**
+```
+BASE, IN00-IN08 (9), MID (1), OUT00-OUT08 (9)
+```
+
+### **SD1.5 (17 elements)**
+```
+BASE, IN01,IN02,IN04,IN05,IN07,IN08 (6), MID (1), OUT03-OUT11 (9)
+```
+
+---
+
+## Automatic Detection
+
+### **LoRA Type Detection**
+
+The node automatically detects whether a LoRA is SD1.5 or SDXL by analyzing the model structure:
+
+- **SD1.5**: `output_blocks_0` to `output_blocks_11` (12 blocks)
+- **SDXL**: `output_blocks_0` to `output_blocks_8` (9 blocks)
+
+**You don't need to specify the model type manually!** ✅
+
+---
+
+### **Weight Adjustment**
+
+If the number of weights doesn't match the detected LoRA type:
+
+**Example 1: Too few weights**
+```
+Input: 1,0,0 (3 elements)
+Detected: SDXL (requires 20)
+→ Auto-adjusted: 1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
+```
+
+**Example 2: Too many weights**
+```
+Input: 1,0,0,...,0,0,0 (25 elements)
+Detected: SDXL (requires 20)
+→ Auto-adjusted: 1,0,0,...,0,0,0 (first 20 only)
+```
+
+---
+
+## Usage
+
+### **Basic Workflow**
+
+```
+[Filtered Random LoRA Loader (LBW)]
+  MODEL → [KSampler]
+  CLIP → [CLIP Text Encode]
+  positive_text → [Show Text] (optional, for debugging)
+```
+
+### **Parameters**
+
+#### **LoRA Settings**
+- `lora_folder_path`: Path to LoRA folder
+- `num_loras`: Number of LoRAs to apply (0-20)
+- `model_strength`: LoRA strength for MODEL (e.g., "1.0" or "0.6-0.9")
+- `clip_strength`: LoRA strength for CLIP (e.g., "1.0" or "0.6-0.9")
+
+#### **Keyword Filter**
+- `keyword_filter`: Space-separated keywords (e.g., `style anime` or `"anime style" red`)
+- `filter_mode`: AND / OR
+- `search_in_metadata`: Search in JSON/embedded metadata (slower)
+
+#### **LBW Settings** (New!)
+- `weight_mode`: Normal / 4 Presets / Random / Direct Input
+- `lbw_input`: Custom weights (only for Direct Input mode)
+
+#### **Other**
+- `trigger_word_source`: Trigger word extraction method
+- `seed`: Random seed
+
+---
+
+## Output Format
+
+### **LBW Syntax**
+
+When LBW is applied, the `positive_text` output includes LBW syntax:
+
+**Normal (All 1.0):**
+```
+<lora:style_anime:0.8:0.8>
+```
+
+**With LBW (Style Focused, SDXL):**
+```
+<lora:style_anime:0.8:0.8:lbw=1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1>
+```
+
+**Note:** The LBW is applied internally to the MODEL. The syntax in `positive_text` is for reference/re-use with other nodes.
+
+---
+
+## Tips
+
+### **1. Preset Selection Guide**
+
+| LoRA Type | Recommended Preset | Why |
+|-----------|-------------------|-----|
+| Style/Art | Style Focused | OUTPUT blocks control style |
+| Character | Character Focused | Balanced IN+MID+OUT for features |
+| Pose/Composition | Structure/Composition Only | INPUT blocks control layout |
+| General | Balanced / Soft | Gentle, stackable effect |
+
+---
+
+### **2. Effect Visibility**
+
+The difference between presets is **more visible** with:
+- ✅ Strong LoRAs (high model_strength)
+- ✅ Single LoRA application (num_loras=1)
+- ✅ Style or concept LoRAs
+
+The difference is **less visible** with:
+- ⚠️ Weak LoRAs (low model_strength)
+- ⚠️ Multiple LoRAs applied simultaneously
+- ⚠️ LoRAs with evenly distributed training
+
+---
+
+### **3. Zero Weight = No Effect**
+
+Setting all weights to 0 completely disables the LoRA effect:
+```
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+```
+This is equivalent to not applying the LoRA at all.
+
+---
+
+### **4. Serial Connection**
+
+For applying different LBW settings to different LoRAs:
+```
+[Filtered Random LoRA Loader (LBW)] (Style Focused)
+  ↓
+[Filtered Random LoRA Loader (LBW)] (Character Focused)
+  ↓
+[KSampler]
+```
+
+All LoRAs within a single node instance use the same LBW setting.
+
+---
+
+## Requirements
+
+### **⚠️ Supported Models**
+**This node is designed for SD1.5 and SDXL models ONLY.**
+
+- ✅ **Supported:** Stable Diffusion 1.5, Stable Diffusion XL (SDXL)
+- ❌ **NOT Supported:** Flux, SD3, SDXL Turbo, Pony, or other architectures
+
+The LBW feature specifically targets SD1.5/SDXL U-Net architecture. Other model types will not work correctly.
+
+---
+
+### **Dependencies**
+- ComfyUI
+- Pillow (included with ComfyUI)
+- torch (included with ComfyUI)
+
+### **⚠️ Optional: Video Preview**
+**For video preview support (.mp4, .webm, .avi, .mov), opencv-python is REQUIRED:**
+```bash
+pip install opencv-python
+```
+
+**Without opencv-python:**
+- ✅ Static/animated images work
+- ❌ Video files show black screen
+
+---
+
+## Preview Images
+
+Supports the following formats (in priority order):
+
+1. **Static images** (.png, .jpg, .jpeg)
+2. **Animated images** (.gif, .webp) - first frame
+3. **Video files** (.mp4, .webm, .avi, .mov) - first frame (requires opencv-python)
+
+The node automatically searches for preview files matching the LoRA filename.
+
+---
+
+## Disclaimer
+
+- No technical support provided
+- No warranty or guarantee of functionality
+- No guaranteed compatibility with future ComfyUI updates
+- Bug reports and feature requests may not be addressed
+- Use at your own risk
+
+---
+
+## Changelog
+
+### v1.2.0 (2026-01-13)
+- ✅ Added LoRA Block Weight (LBW) support
+- ✅ Automatic SD1.5/SDXL detection
+- ✅ 4 preset modes + custom input
+- ✅ Automatic weight adjustment
+- ✅ Video preview support (.mp4, .webm, etc.)
+
+### v1.1.0 (2026-01-04)
+- ✅ Added Filtered Random LoRA Loader
+- ✅ Keyword filtering with AND/OR modes
+- ✅ Metadata search support
+- ✅ Preview image display
+
+### v1.0.0 (2025-12-30)
+- ✅ Initial release
+- ✅ Random LoRA Loader (3 groups)
+
+---
+
+## License
+
+MIT License
+
+---
+
+## Author
+
+Your Name
+
+---
+
+**Enjoy precise LoRA control with Block Weights!** 🎨✨

README_LBW_ja.md

@@ -0,0 +1,494 @@
+# Filtered Random LoRA Loader (LBW) - 詳細ガイド
+
+**LoRAブロックウェイト（LBW）対応版**
+
+![FilteredRandomLoRALoader(LBW)ワークフロー例](./images/lbw_final_single.webp)
+
+---
+
+## 概要
+
+Filtered Random LoRA Loader (LBW) は、LoRAブロックウェイト（LBW）機能を追加した高度なノードです。U-Netのどの部分にLoRAを適用するかを細かく制御できます。
+
+---
+
+## 主な機能
+
+### **✅ LoRAブロックウェイト（LBW）対応**
+- U-Netのブロックごとに個別の強度を設定
+- 画風、キャラクター、構図などを分離制御
+
+### **✅ 自動SD1.5/SDXL検出**
+- LoRAファイルを自動判定
+- ウェイト数を自動調整
+
+### **✅ 4つのプリセットモード**
+- Style Focused（画風特化）
+- Character Focused（キャラ重視）
+- Structure/Composition Only（構造・構図のみ）
+- Balanced / Soft（バランス・穏やか）
+
+### **✅ カスタム入力**
+- Direct Inputモードで任意のウェイトを指定
+- Preset: Randomモードでランダムプリセット選択
+
+---
+
+## LBWとは？
+
+### **LoRAブロックウェイトの仕組み**
+
+Stable DiffusionのU-Netは以下の3つの部分で構成されています:
+
+```
+INPUT blocks  → 構造、構図、レイアウト
+   ↓
+MIDDLE block  → 全体的な特徴
+   ↓
+OUTPUT blocks → 画風、ディテール、細部調整
+```
+
+LBWを使うと、**各ブロックに異なるLoRA強度を設定**できます。
+
+---
+
+## ブロック構造
+
+### **SDXL（20要素）**
+
+| インデックス | ブロック | 役割 |
+|------------|---------|------|
+| 0 | BASE | 全体ベース |
+| 1-9 | INPUT (IN00-08) | 構造・構図 |
+| 10 | MIDDLE (M00) | 中間特徴 |
+| 11-19 | OUTPUT (OUT00-08) | 画風・ディテール |
+
+**ウェイト例:**
+```
+1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1
+BASE,IN00-08 (OFF),M00,OUT00-08 (ON)
+→ OUTPUTブロックのみLoRA適用（画風特化）
+```
+
+---
+
+### **SD1.5（17要素）**
+
+| インデックス | ブロック | 役割 |
+|------------|---------|------|
+| 0 | BASE | 全体ベース |
+| 1-6 | INPUT (IN01,02,04,05,07,08) | 構造・構図 |
+| 7 | MIDDLE (M00) | 中間特徴 |
+| 8-16 | OUTPUT (OUT03-11) | 画風・ディテール |
+
+**ウェイト例:**
+```
+1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1
+BASE,IN (OFF),M00,OUT (ON)
+→ OUTPUTブロックのみLoRA適用（画風特化）
+```
+
+---
+
+## プリセット詳細
+
+### **1. Style Focused（画風特化）**
+
+**SDXL:** `1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1`  
+**SD1.5:** `1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1`
+
+**特徴:**
+- OUTPUTブロックのみ有効
+- 構図を変えず画風のみ適用
+- 既存の構図を保ちたい場合に最適
+
+**用途:**
+- 画風LoRA（アニメ風、水彩風など）
+- スタイルLoRA
+- エフェクトLoRA
+
+---
+
+### **2. Character Focused（キャラ重視）**
+
+**SDXL:** `1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1`  
+**SD1.5:** `1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1`
+
+**特徴:**
+- INPUT前半 + MIDDLE + OUTPUT有効
+- キャラクターの特徴を保持
+- バランスの取れた適用
+
+**用途:**
+- キャラクターLoRA
+- 人物LoRA
+- コンセプトLoRA
+
+---
+
+### **3. Structure/Composition Only（構造・構図のみ）**
+
+**SDXL:** `1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0`  
+**SD1.5:** `1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0`
+
+**特徴:**
+- INPUT + MIDDLEブロックのみ有効
+- 画風を変えず構図のみ変更
+- ポーズや構図調整に最適
+
+**用途:**
+- ポーズLoRA
+- 構図LoRA
+- レイアウトLoRA
+
+---
+
+### **4. Balanced / Soft（バランス・穏やか）**
+
+**SDXL:** `1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0`  
+**SD1.5:** `1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,0`
+
+**特徴:**
+- 全体的に穏やかな適用
+- OUTPUT後半を弱めて過剰適用を防止
+- 自然な仕上がり
+
+**用途:**
+- 汎用LoRA
+- 微調整用
+- 複数LoRA併用時
+
+---
+
+## 使い方
+
+### **基本的な使い方**
+
+1. **ノードを配置**
+   ```
+   [Filtered Random LoRA Loader (LBW)]
+   ```
+
+2. **フォルダとキーワードを設定**
+   ```
+   lora_folder_path: "path/to/loras"
+   keyword_filter: "anime style"
+   num_loras: 1
+   ```
+
+3. **LBWモードを選択**
+   ```
+   weight_mode: "Style Focused"
+   ```
+
+4. **MODEL/CLIPを接続**
+   ```
+   MODEL → [KSampler]
+   CLIP → [CLIP Text Encode]
+   ```
+
+---
+
+### **Direct Inputモード**
+
+カスタムウェイトを直接入力:
+
+```
+weight_mode: "Direct Input"
+lbw_input: "1,0.5,0.5,0,0,0,0,0,0,0,1,1,1,1,1,1,0.5,0.5,0.5,0.5"
+```
+
+**ルール:**
+- カンマ区切り
+- SDXL: 20要素、SD1.5: 17要素
+- 要素数が合わない場合は自動調整
+
+---
+
+### **Preset: Randomモード**
+
+毎回異なるプリセットをランダム選択:
+
+```
+weight_mode: "Preset: Random"
+→ 実行ごとに4つのプリセットから1つ選択
+```
+
+---
+
+## 使用例
+
+### **例1: 画風のみ変更**
+
+```
+[Load Checkpoint] → [Filtered Random LoRA Loader (LBW)]
+                     weight_mode: "Style Focused"
+                     keyword_filter: "anime"
+                     ↓
+                     [KSampler]
+```
+
+**結果:** 構図はそのまま、画風のみアニメ風に
+
+---
+
+### **例2: 複数LoRAで段階適用**
+
+```
+[Load Checkpoint]
+  ↓
+[Filtered Random LoRA Loader (LBW)] (Structure/Composition Only)
+  keyword_filter: "pose"
+  ↓
+[Filtered Random LoRA Loader (LBW)] (Style Focused)
+  keyword_filter: "watercolor"
+  ↓
+[KSampler]
+```
+
+**結果:** ポーズ調整 → 水彩画風適用
+
+---
+
+### **例3: キャラ + 画風**
+
+```
+[Load Checkpoint]
+  ↓
+[Filtered Random LoRA Loader (LBW)] (Character Focused)
+  keyword_filter: "character_name"
+  ↓
+[Filtered Random LoRA Loader (LBW)] (Style Focused)
+  keyword_filter: "art_style"
+  ↓
+[KSampler]
+```
+
+**結果:** キャラ特徴保持 + 画風変更
+
+---
+
+## ヒント・Tips
+
+### **1. プリセット選択ガイド**
+
+| LoRAタイプ | 推奨プリセット |
+|-----------|--------------|
+| 画風・スタイル | Style Focused |
+| キャラクター | Character Focused |
+| ポーズ・構図 | Structure/Composition Only |
+| 汎用・微調整 | Balanced / Soft |
+
+---
+
+### **2. 直列接続のコツ**
+
+- **構造 → 画風の順**が基本
+- 各ノードで異なるLBW設定可能
+- 強度も個別に調整可能
+
+---
+
+### **3. ウェイト調整のコツ**
+
+- **0**: 完全無効
+- **0.5**: 弱め
+- **1.0**: 標準
+- **1.5以上**: 強め（過剰に注意）
+
+---
+
+### **4. トラブルシューティング**
+
+**効果が出ない場合:**
+- すべて0になっていないか確認
+- LoRAが正しく読み込まれているか確認
+- コンソールでLBW適用メッセージを確認
+
+**効果が強すぎる場合:**
+- model_strengthを下げる
+- Balanced / Softプリセットを試す
+- ウェイトを0.5～0.8に調整
+
+---
+
+## 自動検出
+
+### **SD1.5 / SDXL自動判定**
+
+ノードは自動的にLoRAタイプを検出:
+
+```
+SDXL検出 → 20要素ウェイト使用
+SD1.5検出 → 17要素ウェイト使用
+```
+
+**ユーザーは何も設定不要** ✨
+
+---
+
+### **ウェイト数自動調整**
+
+入力したウェイト数が合わない場合、自動調整:
+
+```
+入力: 15要素（不足）
+検出: SDXL（20要素必要）
+→ 末尾に1.0を5個追加
+
+入力: 25要素（過剰）
+検出: SDXL（20要素必要）
+→ 末尾から5個カット
+```
+
+---
+
+## 要件
+
+### **⚠️ 対応モデル**
+**本ノードはSD1.5とSDXLモデル専用です。**
+
+- ✅ **対応:** Stable Diffusion 1.5、Stable Diffusion XL（SDXL）
+- ❌ **非対応:** Flux、SD3、SDXL Turbo、Pony、その他のアーキテクチャ
+
+LBW機能は、SD1.5/SDXLのU-Netアーキテクチャ専用に設計されています。他のモデルタイプではLBWが正常に動作しません。
+
+---
+
+### **依存関係**
+- ComfyUI
+- Pillow（ComfyUIに含まれる）
+- torch（ComfyUIに含まれる）
+
+### **⚠️ オプション: 動画プレビュー**
+**動画ファイルプレビュー（.mp4, .webm, .avi, .mov）にはopencv-pythonが必須です:**
+```bash
+pip install opencv-python
+```
+
+**opencv-pythonなしの場合:**
+- ✅ 静止画/アニメ画像は動作
+- ❌ 動画ファイルは黒画面
+
+---
+
+## プレビュー画像
+
+以下の形式に対応（優先順位順）:
+
+1. **静止画像**（.png, .jpg, .jpeg） - 常に動作
+2. **アニメ画像**（.gif, .webp） - 1フレーム目、常に動作
+3. **動画ファイル**（.mp4, .webm, .avi, .mov） - 1フレーム目、opencv-python必要
+
+**ファイルマッチング:**
+- LoRAファイル名で始まるファイル（大文字小文字無視）
+- 例: `style_anime.safetensors` にマッチ:
+  - `style_anime.png` ✅
+  - `style_anime_preview.jpg` ✅
+  - `STYLE_ANIME.PNG` ✅
+
+---
+
+## 上級者向け: カスタムプリセット
+
+独自のプリセットを作成したり、既存のプリセットを変更したい場合は、ソースファイルを直接編集できます。
+
+### **編集方法**
+
+**ファイル位置:**
+```
+ComfyUI/custom_nodes/RandomLoRALoader/filtered_random_lora_loader_lbw.py
+```
+
+**編集箇所:** 29～41行目
+
+### **例1: 独自プリセット追加**
+
+```python
+SDXL_PRESETS = {
+    "Style Focused": "1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1",
+    "Character Focused": "1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1",
+    "Structure/Composition Only": "1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0",
+    "Balanced / Soft": "1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0",
+    # ↓ 独自プリセット
+    "My Custom Mix": "0.5,0.5,0.5,0.5,0,0,0,0,0,0,1,0.8,0.8,0.8,0.8,0.8,0.5,0.5,0.5,0.5"
+}
+```
+
+### **例2: 既存プリセット調整**
+
+```python
+SDXL_PRESETS = {
+    # Style Focusedをより強く
+    "Style Focused": "1,0,0,0,0,0,0,0,0,0,0,1.2,1.2,1.2,1.2,1.2,1.2,1.2,1.2,1.2",
+    
+    # Character Focusedをマイルドに
+    "Character Focused": "0.8,0.8,0.8,0.8,0,0,0,0,0,0,0.8,0.8,0.8,0.8,0.8,0.8,0.8,0.8,0.8,0.8",
+    ...
+}
+```
+
+### **例3: プリセット名変更**
+
+```python
+SDXL_PRESETS = {
+    "画風特化": "1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1",
+    "キャラ重視": "1,1,1,1,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1",
+    "構図のみ": "1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0",
+    ...
+}
+```
+
+### **重要な注意事項**
+
+⚠️ **編集前に:**
+- 元ファイルのバックアップを作成
+- Python構文（カンマ、引用符）に注意
+
+⚠️ **ウェイト数:**
+- SDXLプリセット: 必ず20要素
+- SD1.5プリセット: 必ず17要素
+- 要素数が合わない場合は自動調整されますが、正確に指定する方が良いです
+
+⚠️ **編集後:**
+- ComfyUIを完全に再起動して変更を適用
+- コンソールで構文エラーを確認
+
+💡 **ヒント:** ファイル編集が面倒な場合は、「Direct Input」モードを使ってください！
+
+---
+
+## 更新履歴
+
+### v1.2.0（2026-01-13）
+- ✅ LoRAブロックウェイト（LBW）対応追加
+- ✅ SD1.5/SDXL自動検出
+- ✅ 4つのプリセットモード＋カスタム入力
+- ✅ ウェイト数自動調整
+- ✅ 動画プレビュー対応（.mp4, .webm等）
+
+### v1.1.0（2026-01-04）
+- ✅ Filtered Random LoRA Loader追加
+- ✅ キーワードフィルタリング（AND/ORモード）
+- ✅ メタデータ検索対応
+- ✅ プレビュー画像表示
+
+### v1.0.0（2025-12-30）
+- ✅ 初回リリース
+- ✅ Random LoRA Loader（3グループ）
+
+---
+
+## ライセンス
+
+MIT License
+
+---
+
+## 作者
+
+Your Name
+
+---
+
+**ブロックウェイトで精密なLoRA制御を楽しんでください！** 🎨✨

__init__.py

@@ -3,6 +3,30 @@ RandomLoRALoader Custom Node for ComfyUI
 ランダムLoRA選択・適用ノード
 """
 
-from .random_lora_loader import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+from .random_lora_loader import RandomLoRALoader
+from .filtered_random_lora_loader import FilteredRandomLoRALoader
+
+# LBW版は任意（読み込めない場合はスキップ）
+try:
+    from .filtered_random_lora_loader_lbw import FilteredRandomLoRALoaderLBW
+    HAS_LBW = True
+except Exception as e:
+    print(f"[RandomLoRALoader] Failed to load LBW version: {e}")
+    HAS_LBW = False
+
+NODE_CLASS_MAPPINGS = {
+    "RandomLoRALoader": RandomLoRALoader,
+    "FilteredRandomLoRALoader": FilteredRandomLoRALoader,
+}
+
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "RandomLoRALoader": "Random LoRA Loader",
+    "FilteredRandomLoRALoader": "Filtered Random LoRA Loader",
+}
+
+# LBW版が利用可能な場合のみ追加
+if HAS_LBW:
+    NODE_CLASS_MAPPINGS["FilteredRandomLoRALoaderLBW"] = FilteredRandomLoRALoaderLBW
+    NODE_DISPLAY_NAME_MAPPINGS["FilteredRandomLoRALoaderLBW"] = "Filtered Random LoRA Loader (LBW)"
 
 __all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']

pyproject.toml

@@ -0,0 +1,37 @@
+[project]
+name = "comfyui-random-lora-loader"
+version = "1.2.0"
+description = "Randomly select and apply LoRAs with keyword filtering, LoRA Block Weight support, and preview images for ComfyUI"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}  # 必要に応じて変更
+]
+
+keywords = ["comfyui", "lora", "stable-diffusion", "ai", "image-generation", "block-weight", "lbw"]
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+
+[project.optional-dependencies]
+video = ["opencv-python>=4.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/YOUR_USERNAME/RandomLoRALoader"
+Repository = "https://github.com/YOUR_USERNAME/RandomLoRALoader"
+Issues = "https://github.com/YOUR_USERNAME/RandomLoRALoader/issues"
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["RandomLoRALoader"]

random_lora_loader.py

@@ -39,12 +39,15 @@ RandomLoRALoader - ComfyUI Custom Node V1
    - model_strength_3: MODEL適用強度
    - clip_strength_3: CLIP適用強度
    - num_loras_3: 選択するLoRA個数
-19. trigger_word_source: json_combined/json_random/json_sample_prompt（共通）
+19. trigger_word_source: json_combined/json_random/json_sample_prompt/metadata（共通）
 20. seed: ランダム選択のシード値（共通、ComfyUI標準のcontrol_before_generateで制御）
 
 【その他仕様】
-- 外部JSONファイル（{LoRAファイル名}.metadata.json）からトリガーワード/作例を取得
-- JSON読み取り優先順位: trainedWords / images[].meta.prompt
+- メタデータ読み取り優先順位:
+  1. {LoRAファイル名}.metadata.json (ComfyUI Lora Manager)
+  2. {LoRAファイル名}.info (Civitai Helper)
+  3. LoRA本体ファイルの埋め込みメタデータ
+- trigger_word_source="metadata"時は埋め込みメタデータのみを参照
 - 同じLoRAの重複選択なし（不足時は再選択で埋める）
 - json_sample_prompt選択時はpositive/negativeを分離
 - 作例プロンプト内のLoRA記述（<lora:xxx:x.x>）は削除
@@ -63,9 +66,20 @@ import folder_paths
 import comfy.sd
 import comfy.utils
 
+# LoRA埋め込みメタデータ読み込み用
+try:
+    from safetensors.torch import safe_open
+    SAFETENSORS_AVAILABLE = True
+except ImportError:
+    SAFETENSORS_AVAILABLE = False
+    print("[RandomLoRALoader] safetensors not available, embedded metadata reading disabled")
+
 class RandomLoRALoader:
     """ランダムLoRA選択・適用ノード（3グループ対応）"""
     
+    # クラス変数（opencv警告表示フラグ）
+    _opencv_warning_shown = False
+    
     @classmethod
     def INPUT_TYPES(cls):
         return {
@@ -84,10 +98,15 @@ class RandomLoRALoader:
                         "default": "A1111"
                     }
                 ),
-                "additional_prompt": ("STRING", {
+                "additional_prompt_positive": ("STRING", {
                     "default": "",
                     "multiline": True,
-                    "placeholder": "Additional prompt (e.g., 1girl, beautiful)"
+                    "placeholder": "Additional positive prompt"
+                }),
+                "additional_prompt_negative": ("STRING", {
+                    "default": "",
+                    "multiline": True,
+                    "placeholder": "Additional negative prompt"
                 }),
                 # グループ1
                 "lora_folder_path_1": ("STRING", {
@@ -98,6 +117,10 @@ class RandomLoRALoader:
                 "include_subfolders_1": ("BOOLEAN", {
                     "default": True
                 }),
+                "unique_by_filename_1": ("BOOLEAN", {
+                    "default": True,
+                    "label": "Unique by filename (exclude duplicates)"
+                }),
                 "model_strength_1": ("STRING", {
                     "default": "1.0",
                     "multiline": False,
@@ -124,6 +147,10 @@ class RandomLoRALoader:
                 "include_subfolders_2": ("BOOLEAN", {
                     "default": True
                 }),
+                "unique_by_filename_2": ("BOOLEAN", {
+                    "default": True,
+                    "label": "Unique by filename (exclude duplicates)"
+                }),
                 "model_strength_2": ("STRING", {
                     "default": "1.0",
                     "multiline": False,
@@ -150,6 +177,10 @@ class RandomLoRALoader:
                 "include_subfolders_3": ("BOOLEAN", {
                     "default": True
                 }),
+                "unique_by_filename_3": ("BOOLEAN", {
+                    "default": True,
+                    "label": "Unique by filename (exclude duplicates)"
+                }),
                 "model_strength_3": ("STRING", {
                     "default": "1.0",
                     "multiline": False,
@@ -169,7 +200,7 @@ class RandomLoRALoader:
                 }),
                 # 共通設定
                 "trigger_word_source": (
-                    ["json_combined", "json_random", "json_sample_prompt"],
+                    ["json_combined", "json_random", "json_sample_prompt", "metadata"],
                     {
                         "default": "json_combined"
                     }
@@ -184,8 +215,8 @@ class RandomLoRALoader:
             }
         }
     
-    RETURN_TYPES = ("MODEL", "CLIP", "STRING", "STRING", "CONDITIONING", "CONDITIONING")
-    RETURN_NAMES = ("MODEL", "CLIP", "positive_text", "negative_text", "positive", "negative")
+    RETURN_TYPES = ("MODEL", "CLIP", "STRING", "STRING", "CONDITIONING", "CONDITIONING", "IMAGE")
+    RETURN_NAMES = ("MODEL", "CLIP", "positive_text", "negative_text", "positive", "negative", "preview")
     FUNCTION = "load_random_loras"
     CATEGORY = "loaders"
     
@@ -246,6 +277,34 @@ class RandomLoRALoader:
             random.shuffle(selected)
             return selected
     
+    def _unique_by_filename(self, lora_files, group_name=""):
+        """
+        ファイル名でユニーク化（重複ファイル名を除外）
+        
+        Args:
+            lora_files: LoRAファイルパスのリスト
+            group_name: グループ名（ログ用）
+        
+        Returns:
+            list: ファイル名がユニークなファイルパスのリスト
+        """
+        seen_names = {}
+        unique_files = []
+        
+        for file_path in lora_files:
+            filename = os.path.basename(file_path)
+            
+            if filename not in seen_names:
+                seen_names[filename] = file_path
+                unique_files.append(file_path)
+            else:
+                # 重複検出時はログ出力
+                print(f"[RandomLoRALoader] {group_name}: Duplicate filename detected: {filename}")
+                print(f"  Keeping: {seen_names[filename]}")
+                print(f"  Skipping: {file_path}")
+        
+        return unique_files
+    
     def _parse_strength(self, strength_str):
         """
         強度文字列をパースして値を返す
@@ -255,6 +314,7 @@ class RandomLoRALoader:
         - "0.55" → 0.55（そのまま）
         - "0.4-0.8" → 0.4, 0.5, 0.6, 0.7, 0.8からランダム（0.1刻み）
         - "0.44-0.82" → 0.4, 0.5, 0.6, 0.7, 0.8からランダム（範囲を1桁に丸める）
+        - "-0.8--0.3" → -0.8, -0.7, -0.6, ..., -0.3からランダム（マイナス範囲対応）
         
         Args:
             strength_str: 強度文字列
@@ -262,18 +322,19 @@ class RandomLoRALoader:
         Returns:
             float: 実際に使用する強度値
         """
+        import re
         strength_str = str(strength_str).strip()
         
-        # ハイフンがあればランダム範囲指定
-        if '-' in strength_str:
+        # 範囲指定のパターンマッチ（マイナス値対応）
+        # 例: "0.6-0.9", "-0.8--0.3", "-0.5-0.5", "0.3--0.7"
+        range_pattern = r'^(-?\d+\.?\d*)\s*-\s*(-?\d+\.?\d*)$'
+        match = re.match(range_pattern, strength_str)
+        
+        if match:
             try:
-                parts = strength_str.split('-')
-                if len(parts) != 2:
-                    raise ValueError("範囲指定は 'min-max' 形式で入力してください")
-                
                 # 範囲の上限下限を1桁に丸める
-                min_val = round(float(parts[0].strip()), 1)
-                max_val = round(float(parts[1].strip()), 1)
+                min_val = round(float(match.group(1)), 1)
+                max_val = round(float(match.group(2)), 1)
                 
                 # バリデーション
                 if min_val < -10.0 or max_val > 10.0:
@@ -320,7 +381,12 @@ class RandomLoRALoader:
     
     def _load_json_metadata(self, lora_path):
         """
-        外部JSONファイルからメタデータを読み込む
+        外部JSONファイルまたはLoRA埋め込みメタデータを読み込む
+        
+        優先順位:
+        1. {filename}.metadata.json (ComfyUI Lora Manager形式)
+        2. {filename}.info (Civitai Helper形式)
+        3. LoRA本体ファイルの埋め込みメタデータ
         
         Args:
             lora_path: LoRAファイルパス (.safetensors)
@@ -330,17 +396,105 @@ class RandomLoRALoader:
         """
         # .safetensorsを除いたファイル名を取得
         base_name = os.path.splitext(lora_path)[0]
-        json_path = f"{base_name}.metadata.json"
         
-        if not os.path.exists(json_path):
-            print(f"[RandomLoRALoader] JSONファイルが見つかりません: {json_path}")
+        # 優先順位1: .metadata.json (ComfyUI Lora Manager)
+        json_path_metadata = f"{base_name}.metadata.json"
+        if os.path.exists(json_path_metadata):
+            try:
+                with open(json_path_metadata, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"[RandomLoRALoader] JSON読み込みエラー ({json_path_metadata}): {e}")
+        
+        # 優先順位2: .info (Civitai Helper)
+        json_path_info = f"{base_name}.info"
+        if os.path.exists(json_path_info):
+            try:
+                with open(json_path_info, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"[RandomLoRALoader] JSON読み込みエラー ({json_path_info}): {e}")
+        
+        # 優先順位3: LoRA本体ファイルの埋め込みメタデータ
+        embedded_data = self._load_embedded_metadata(lora_path)
+        if embedded_data:
+            return embedded_data
+        
+        # どれも見つからない
+        print(f"[RandomLoRALoader] メタデータが見つかりません: {base_name}")
+        return None
+    
+    def _load_embedded_metadata(self, lora_path):
+        """
+        LoRA本体ファイルの埋め込みメタデータを読み込む
+        
+        Args:
+            lora_path: LoRAファイルパス (.safetensors)
+        
+        Returns:
+            dict: メタデータ（読み込み失敗時はNone）
+        """
+        if not SAFETENSORS_AVAILABLE:
+            return None
+        
+        if not os.path.exists(lora_path):
             return None
         
         try:
-            with open(json_path, 'r', encoding='utf-8') as f:
-                return json.load(f)
+            with safe_open(lora_path, framework="pt", device="cpu") as f:
+                metadata = f.metadata()
+                
+                if not metadata:
+                    return None
+                
+                # ss_tag_frequency（kohya_ss形式）からトリガーワード抽出
+                if "ss_tag_frequency" in metadata:
+                    tag_freq_str = metadata.get("ss_tag_frequency", "{}")
+                    try:
+                        tag_freq = json.loads(tag_freq_str)
+                        # 最も頻度の高いタグセットを取得
+                        if tag_freq:
+                            # 各データセットのタグを結合
+                            all_tags = []
+                            for dataset_tags in tag_freq.values():
+                                all_tags.extend(dataset_tags.keys())
+                            
+                            # 重複除去
+                            unique_tags = list(dict.fromkeys(all_tags))
+                            
+                            # Civitai形式に変換
+                            trigger_words = ", ".join(unique_tags[:20])  # 上位20個
+                            
+                            return {
+                                "civitai": {
+                                    "trainedWords": [trigger_words]
+                                }
+                            }
+                    except json.JSONDecodeError:
+                        pass
+                
+                # その他のメタデータフィールドからトリガーワード抽出
+                if "modelspec.trigger_word" in metadata:
+                    trigger = metadata["modelspec.trigger_word"]
+                    return {
+                        "civitai": {
+                            "trainedWords": [trigger]
+                        }
+                    }
+                
+                # ss_output_name（モデル名）
+                if "ss_output_name" in metadata:
+                    output_name = metadata["ss_output_name"]
+                    return {
+                        "civitai": {
+                            "trainedWords": [output_name]
+                        }
+                    }
+                
+                return None
+                
         except Exception as e:
-            print(f"[RandomLoRALoader] JSON読み込みエラー ({json_path}): {e}")
+            print(f"[RandomLoRALoader] 埋め込みメタデータ読み込みエラー ({lora_path}): {e}")
             return None
     
     def _get_trigger_words_combined(self, lora_path):
@@ -434,8 +588,8 @@ class RandomLoRALoader:
             print(f"[RandomLoRALoader] imagesが見つかりません: {lora_path}")
             return "", ""
         
-        # metaを持つ画像のみをフィルタ
-        valid_images = [img for img in images if "meta" in img]
+        # metaを持つ画像のみをフィルタ（metaがNoneでないことも確認）
+        valid_images = [img for img in images if "meta" in img and img["meta"] is not None]
         if not valid_images:
             print(f"[RandomLoRALoader] metaを持つ画像が見つかりません: {lora_path}")
             return "", ""
@@ -463,6 +617,29 @@ class RandomLoRALoader:
         
         return positive, negative
     
+    def _get_trigger_words_from_embedded(self, lora_path):
+        """
+        LoRA埋め込みメタデータから直接トリガーワードを取得
+        外部JSONファイルを無視して、LoRA本体ファイルのみを参照
+        
+        Args:
+            lora_path: LoRAファイルパス
+        
+        Returns:
+            str: トリガーワード
+        """
+        embedded_data = self._load_embedded_metadata(lora_path)
+        if not embedded_data:
+            return ""
+        
+        # civitai.trainedWordsを取得（_load_embedded_metadataで変換済み）
+        trained_words = embedded_data.get("civitai", {}).get("trainedWords", [])
+        if not trained_words:
+            return ""
+        
+        # 最初のパターンを使用（埋め込みデータは通常1つ）
+        return trained_words[0] if trained_words else ""
+    
     def _load_lora(self, model, clip, lora_path, model_strength, clip_strength):
         """
         LoRAをMODELとCLIPに適用
@@ -570,6 +747,277 @@ class RandomLoRALoader:
         
         return text
     
+    def _load_preview_image_as_tensor(self, lora_path):
+        """
+        プレビュー画像をTensorとして読み込み（部分一致、長辺1240px）
+        
+        検索方法:
+          LoRAファイル名（拡張子除く）で始まるファイルを検索
+          優先順位:
+            1. 静止画像 (.png, .jpg, .jpeg, .webp)
+            2. 動画ファイル (.gif, .webp, .mp4, .webm) の1フレーム目
+          
+          例: style_anime_v1.safetensors
+            → style_anime_v1.png
+            → style_anime_v1_preview.jpg
+            → style_anime_v1.gif (1フレーム目)
+            → style_anime_v1.mp4 (1フレーム目、opencv-pythonが必要)
+            → STYLE_ANIME_V1.PNG (大文字小文字無視)
+        
+        リサイズ:
+          長辺を1240pxに統一（アスペクト比保持）
+        
+        Returns:
+            torch.Tensor: (H, W, C) 形式、見つからない場合はNone
+        """
+        try:
+            from PIL import Image
+            import numpy as np
+            import torch
+        except ImportError:
+            return None
+        
+        # LoRAファイル名（拡張子なし）
+        base_name = os.path.splitext(os.path.basename(lora_path))[0]
+        folder = os.path.dirname(lora_path)
+        
+        # ファイル拡張子（優先順位順）
+        static_image_exts = ('.png', '.jpg', '.jpeg')
+        animated_image_exts = ('.gif', '.webp')  # Pillowで対応可能
+        video_exts = ('.mp4', '.webm', '.avi', '.mov')  # opencv-python必要
+        
+        try:
+            # 同じフォルダ内のファイルを検索
+            files = os.listdir(folder)
+            
+            # 部分一致するファイルを収集
+            matched_files = []
+            for file in files:
+                if file.lower().startswith(base_name.lower()):
+                    matched_files.append(file)
+            
+            if not matched_files:
+                return None
+            
+            # 優先順位でソート
+            def get_priority(filename):
+                lower = filename.lower()
+                if any(lower.endswith(ext) for ext in static_image_exts):
+                    return 0  # 最優先
+                elif any(lower.endswith(ext) for ext in animated_image_exts):
+                    return 1  # 次優先
+                elif any(lower.endswith(ext) for ext in video_exts):
+                    return 2  # 最後
+                else:
+                    return 999  # その他
+            
+            matched_files.sort(key=get_priority)
+            
+            # 各ファイルを試す
+            for file in matched_files:
+                preview_path = os.path.join(folder, file)
+                lower_file = file.lower()
+                
+                # 静止画像
+                if any(lower_file.endswith(ext) for ext in static_image_exts):
+                    img = self._load_static_image(preview_path)
+                    if img is not None:
+                        return img
+                
+                # アニメーション画像（GIF/WebP）
+                elif any(lower_file.endswith(ext) for ext in animated_image_exts):
+                    img = self._load_animated_image_first_frame(preview_path)
+                    if img is not None:
+                        return img
+                
+                # 動画ファイル（opencv-python必要）
+                elif any(lower_file.endswith(ext) for ext in video_exts):
+                    img = self._load_video_first_frame(preview_path)
+                    if img is not None:
+                        return img
+        
+        except Exception as e:
+            print(f"[RandomLoRALoader] Folder read error: {e}")
+        
+        return None
+    
+    def _load_static_image(self, image_path):
+        """静止画像を読み込み"""
+        try:
+            from PIL import Image
+            import numpy as np
+            import torch
+            
+            img = Image.open(image_path).convert('RGB')
+            return self._resize_and_convert_image(img)
+        except Exception as e:
+            print(f"[RandomLoRALoader] Static image load error ({image_path}): {e}")
+            return None
+    
+    def _load_animated_image_first_frame(self, image_path):
+        """アニメーション画像（GIF/WebP）の1フレーム目を読み込み"""
+        try:
+            from PIL import Image
+            import numpy as np
+            import torch
+            
+            img = Image.open(image_path)
+            
+            # 1フレーム目に移動
+            if hasattr(img, 'seek'):
+                img.seek(0)
+            
+            img = img.convert('RGB')
+            return self._resize_and_convert_image(img)
+        except Exception as e:
+            print(f"[RandomLoRALoader] Animated image load error ({image_path}): {e}")
+            return None
+    
+    def _load_video_first_frame(self, video_path):
+        """動画ファイルの1フレーム目を読み込み（opencv-python必要）"""
+        try:
+            import cv2
+            from PIL import Image
+            import numpy as np
+            import torch
+            
+            # OpenCVで動画を開く
+            cap = cv2.VideoCapture(video_path)
+            
+            if not cap.isOpened():
+                return None
+            
+            # 1フレーム目を読み込み
+            ret, frame = cap.read()
+            cap.release()
+            
+            if not ret:
+                return None
+            
+            # BGR → RGB 変換
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            
+            # PIL Imageに変換
+            img = Image.fromarray(frame_rgb)
+            
+            return self._resize_and_convert_image(img)
+        
+        except ImportError:
+            # opencv-pythonがインストールされていない（初回のみ警告）
+            if not RandomLoRALoader._opencv_warning_shown:
+                print("=" * 60)
+                print("[RandomLoRALoader] Video Preview Support")
+                print("=" * 60)
+                print(f"Video file detected: {os.path.basename(video_path)}")
+                print("opencv-python is not installed.")
+                print("")
+                print("To enable video preview support, install:")
+                print("  pip install opencv-python")
+                print("")
+                print("Static images (.png/.jpg) and animated images (.gif/.webp)")
+                print("will continue to work without opencv-python.")
+                print("=" * 60)
+                RandomLoRALoader._opencv_warning_shown = True
+            return None
+        except Exception as e:
+            print(f"[RandomLoRALoader] Video load error ({video_path}): {e}")
+            return None
+    
+    def _resize_and_convert_image(self, img):
+        """画像をリサイズしてTensorに変換"""
+        try:
+            from PIL import Image
+            import numpy as np
+            import torch
+            
+            # 長辺を1240pxにリサイズ（アスペクト比保持）
+            width, height = img.size
+            max_size = 1240
+            
+            if max(width, height) > max_size:
+                # 長辺が1240pxを超える場合はリサイズ
+                if width > height:
+                    new_width = max_size
+                    new_height = int(height * (max_size / width))
+                else:
+                    new_height = max_size
+                    new_width = int(width * (max_size / height))
+                
+                img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+            elif max(width, height) < max_size:
+                # 長辺が1240px未満の場合は拡大
+                if width > height:
+                    new_width = max_size
+                    new_height = int(height * (max_size / width))
+                else:
+                    new_height = max_size
+                    new_width = int(width * (max_size / height))
+                
+                img = img.resize((new_width, new_height), Image.Resampling.LANCZOS)
+            
+            # numpy配列に変換 (H, W, C)
+            img_array = np.array(img).astype(np.float32) / 255.0
+            # Tensor化
+            return torch.from_numpy(img_array)
+        
+        except Exception as e:
+            print(f"[RandomLoRALoader] Image resize/convert error: {e}")
+            return None
+    
+    def _generate_preview_batch(self, preview_images):
+        """
+        プレビュー画像のバッチを生成（1240pxに統一、パディング）
+        
+        Args:
+            preview_images: list of torch.Tensor (各々 H, W, C、長辺1240px)
+        
+        Returns:
+            torch.Tensor: (B, 1240, 1240, C) 形式
+        """
+        try:
+            import torch
+            import torch.nn.functional as F
+        except ImportError:
+            return None
+        
+        if not preview_images:
+            # プレビュー画像なし → 黒画像1枚（1240x1240）
+            black_image = torch.zeros((1, 1240, 1240, 3), dtype=torch.float32)
+            return black_image
+        
+        # 全て1240x1240にパディング
+        padded_images = []
+        target_size = 1240
+        
+        for img in preview_images:
+            h, w, c = img.shape
+            
+            # パディングが必要か確認
+            if h == target_size and w == target_size:
+                padded_images.append(img)
+            else:
+                # パディング量を計算（中央配置）
+                pad_h = target_size - h
+                pad_w = target_size - w
+                pad_top = pad_h // 2
+                pad_bottom = pad_h - pad_top
+                pad_left = pad_w // 2
+                pad_right = pad_w - pad_left
+                
+                # (H, W, C) → (C, H, W) に変換してパディング
+                img_chw = img.permute(2, 0, 1)  # (C, H, W)
+                
+                # F.pad: (left, right, top, bottom)
+                padded = F.pad(img_chw, (pad_left, pad_right, pad_top, pad_bottom), value=0)
+                
+                # (C, H, W) → (H, W, C) に戻す
+                padded = padded.permute(1, 2, 0)
+                padded_images.append(padded)
+        
+        # バッチ化 (B, 1240, 1240, C)
+        preview_batch = torch.stack(padded_images, dim=0)
+        return preview_batch
+    
     def _encode_prompt(self, clip, text, token_normalization, weight_interpretation):
         """
         プロンプトをCLIPでエンコードしてCONDITIONINGを生成
@@ -607,22 +1055,26 @@ class RandomLoRALoader:
         clip,
         token_normalization,
         weight_interpretation,
-        additional_prompt,
+        additional_prompt_positive,
+        additional_prompt_negative,
         # グループ1
         lora_folder_path_1,
         include_subfolders_1,
+        unique_by_filename_1,
         model_strength_1,
         clip_strength_1,
         num_loras_1,
         # グループ2
         lora_folder_path_2,
         include_subfolders_2,
+        unique_by_filename_2,
         model_strength_2,
         clip_strength_2,
         num_loras_2,
         # グループ3
         lora_folder_path_3,
         include_subfolders_3,
+        unique_by_filename_3,
         model_strength_3,
         clip_strength_3,
         num_loras_3,
@@ -646,14 +1098,17 @@ class RandomLoRALoader:
         all_positive_parts = []
         all_negative_parts = []
         
+        # プレビュー画像収集
+        preview_images = []
+        
         # 3つのグループを処理
         groups = [
-            (lora_folder_path_1, include_subfolders_1, model_strength_1, clip_strength_1, num_loras_1, "Group 1"),
-            (lora_folder_path_2, include_subfolders_2, model_strength_2, clip_strength_2, num_loras_2, "Group 2"),
-            (lora_folder_path_3, include_subfolders_3, model_strength_3, clip_strength_3, num_loras_3, "Group 3"),
+            (lora_folder_path_1, include_subfolders_1, unique_by_filename_1, model_strength_1, clip_strength_1, num_loras_1, "Group 1"),
+            (lora_folder_path_2, include_subfolders_2, unique_by_filename_2, model_strength_2, clip_strength_2, num_loras_2, "Group 2"),
+            (lora_folder_path_3, include_subfolders_3, unique_by_filename_3, model_strength_3, clip_strength_3, num_loras_3, "Group 3"),
         ]
         
-        for folder_path, include_subs, model_str, clip_str, num, group_name in groups:
+        for folder_path, include_subs, unique_by_name, model_str, clip_str, num, group_name in groups:
             # フォルダパスが空、またはnum_lorasが0の場合はスキップ
             if not folder_path.strip() or num == 0:
                 print(f"[RandomLoRALoader] {group_name}: スキップ（フォルダ未指定またはnum=0）")
@@ -666,6 +1121,13 @@ class RandomLoRALoader:
                 print(f"[RandomLoRALoader] {group_name}: LoRAファイルが見つかりませんでした")
                 continue
             
+            # ファイル名でユニーク化（重複ファイル名を除外）
+            if unique_by_name:
+                lora_files = self._unique_by_filename(lora_files, group_name)
+                if not lora_files:
+                    print(f"[RandomLoRALoader] {group_name}: ユニーク化後にファイルがありません")
+                    continue
+            
             # ランダムにLoRAを選択（全グループ共通のseedを使用）
             selected_loras = self._select_random_loras(lora_files, num, seed)
             
@@ -702,14 +1164,24 @@ class RandomLoRALoader:
                     all_negative_parts.append(negative_prompt)
                     trigger_display = positive_prompt
                 
+                elif trigger_word_source == "metadata":
+                    trigger_words = self._get_trigger_words_from_embedded(lora_path)
+                    all_positive_parts.append(trigger_words)
+                    trigger_display = trigger_words
+                
                 # テキスト出力に追加（末尾にカンマを付ける）
                 lora_notation = f"<lora:{lora_name}:{actual_model_str}:{actual_clip_str}>"
                 all_text_parts.append(f"{lora_notation}, {trigger_display},")
+                
+                # プレビュー画像を読み込み
+                preview = self._load_preview_image_as_tensor(lora_path)
+                if preview is not None:
+                    preview_images.append(preview)
         
         # テキスト出力を結合（追加プロンプトを先頭に配置、末尾にカンマを付ける）
-        if additional_prompt.strip():
+        if additional_prompt_positive.strip():
             # 追加プロンプトの末尾にカンマがなければ追加
-            additional_with_comma = additional_prompt.strip()
+            additional_with_comma = additional_prompt_positive.strip()
             if not additional_with_comma.endswith(','):
                 additional_with_comma += ','
             if all_text_parts:
@@ -717,7 +1189,7 @@ class RandomLoRALoader:
                 positive_text_output = additional_with_comma + "\n" + "\n".join(all_text_parts)
             else:
                 # LoRAがない場合: 追加プロンプトのみ（末尾カンマなし）
-                positive_text_output = additional_prompt.strip()
+                positive_text_output = additional_prompt_positive.strip()
         else:
             # 追加プロンプトなし
             if all_text_parts:
@@ -727,14 +1199,22 @@ class RandomLoRALoader:
                 # 何もない
                 positive_text_output = ""
         
-        # negativeテキスト出力（json_sample_promptの場合のみ内容あり）
-        negative_text_output = ", ".join([n for n in all_negative_parts if n])
+        # negativeテキスト出力
+        # 1. json_sample_promptからのnegative
+        sample_negative = ", ".join([n for n in all_negative_parts if n])
+        # 2. additional_prompt_negativeと結合
+        negative_parts = []
+        if additional_prompt_negative.strip():
+            negative_parts.append(additional_prompt_negative.strip())
+        if sample_negative:
+            negative_parts.append(sample_negative)
+        negative_text_output = ", ".join(negative_parts)
         
         # positiveプロンプトを結合してCONDITIONINGを生成（追加プロンプトを含める）
         final_positive_parts = []
-        if additional_prompt.strip():
+        if additional_prompt_positive.strip():
             # LoRA構文を削除してクリーンなプロンプトにする
-            cleaned_prompt = self._remove_lora_syntax(additional_prompt.strip())
+            cleaned_prompt = self._remove_lora_syntax(additional_prompt_positive.strip())
             if cleaned_prompt:  # 削除後に空でなければ追加
                 final_positive_parts.append(cleaned_prompt)
         final_positive_parts.extend([p for p in all_positive_parts if p])
@@ -744,7 +1224,13 @@ class RandomLoRALoader:
         )
         
         # negativeプロンプトを結合してCONDITIONINGを生成
-        negative_text = ", ".join([n for n in all_negative_parts if n])
+        final_negative_parts = []
+        if additional_prompt_negative.strip():
+            cleaned_negative = self._remove_lora_syntax(additional_prompt_negative.strip())
+            if cleaned_negative:
+                final_negative_parts.append(cleaned_negative)
+        final_negative_parts.extend([n for n in all_negative_parts if n])
+        negative_text = ", ".join(final_negative_parts)
         negative_conditioning = self._encode_prompt(
             clip, negative_text, token_normalization, weight_interpretation
         )
@@ -752,19 +1238,12 @@ class RandomLoRALoader:
         total_loras = len(all_text_parts)
         if total_loras > 0:
             print(f"[RandomLoRALoader] 適用完了: 合計{total_loras}個のLoRA")
-        elif additional_prompt.strip():
+        elif additional_prompt_positive.strip():
             print(f"[RandomLoRALoader] 適用完了: LoRAなし、追加プロンプトのみ使用")
         else:
             print(f"[RandomLoRALoader] 適用完了: LoRAなし、プロンプトなし")
         
-        return (model, clip, positive_text_output, negative_text_output, positive_conditioning, negative_conditioning)
-
-
-# ComfyUIへのノード登録
-NODE_CLASS_MAPPINGS = {
-    "RandomLoRALoader": RandomLoRALoader
-}
-
-NODE_DISPLAY_NAME_MAPPINGS = {
-    "RandomLoRALoader": "Random LoRA Loader"
-}
+        # プレビュー画像バッチ生成
+        preview_batch = self._generate_preview_batch(preview_images)
+        
+        return (model, clip, positive_text_output, negative_text_output, positive_conditioning, negative_conditioning, preview_batch)