【GIMP2/3対応】GIMPのAI画像背景削除プラグインで超時短＆微調整が可能に！！

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 原作者：James Huang <elastic192@gmail.com>
#         https://elastic192.blogspot.com/

from gimpfu import *
import os, sys, string, tempfile
import platform
import subprocess

def Rembg(image, drawable, asMask, selModel, AlphaMatting, aeValue):

	#ユーザー設定部分
	#rembg.exeのアドレスを指定する
	aiExe = r"C:\Users\■■■\AppData\Local\Programs\Python\Python■■■\Scripts\rembg.exe"
	#初期値：aiExe = r"C:\Users\■■■\AppData\Local\Programs\Python\Python■■■\Scripts\rembg.exe"

	#画像処理をするアドレスを指定する
	tdir = tempfile.gettempdir()
	#初期値：tdir = tempfile.gettempdir()

	#学習モデル
	tupleModel = ("u2net","u2net_human_seg","u2net_cloth_seg","u2netp","silueta","isnet-general-use",\
"isnet-anime","sam","birefnet-general","birefnet-general-lite","birefnet-portrait",\
"birefnet-dis","birefnet-hrsod","birefnet-cod","birefnet-massive")

	removeTmpFile = True
	OutputMessage = False
	osName = platform.system()
	exportSep = str(os.sep)
	if OutputMessage:
		pdb.gimp_message(tdir)
	jpgFile = "%s%sTemp-gimp-0000.jpg" % (tdir, exportSep)
	pngFile = "%s%sTemp-gimp-0000.png" % (tdir, exportSep)
	errFile = "%s%sErrMsg.txt" % (tdir, exportSep)
	x1 = 0
	y1 = 0
	option = ""

	image.undo_group_start()
	curLayer = pdb.gimp_image_get_active_layer(image)
	x1, y1 = curLayer.offsets

	gimp.progress_init("AI背景除去を実行中...")
	gimp.progress_update(0.1)

	if pdb.gimp_selection_is_empty(image):
		pdb.file_jpeg_save(image, drawable, jpgFile, jpgFile, 0.95, 0, 1, 0, "", 0, 1, 0, 0)
	else:
		pdb.gimp_edit_copy(drawable)
		non_empty, x1, y1, x2, y2 = pdb.gimp_selection_bounds(image)
		tmpImage = gimp.Image(x2-x1, y2-y1, 0)
		tmpDrawable = gimp.Layer(tmpImage, "Temp", tmpImage.width, tmpImage.height, RGB_IMAGE, 100, NORMAL_MODE)
		pdb.gimp_image_add_layer(tmpImage, tmpDrawable, 0)
		pat = pdb.gimp_context_get_pattern()
		pdb.gimp_context_set_pattern("Leopard")
		pdb.gimp_drawable_fill(tmpDrawable, 4)
		pdb.gimp_context_set_pattern(pat)
		pdb.gimp_floating_sel_anchor(pdb.gimp_edit_paste(tmpDrawable,TRUE))
		pdb.file_jpeg_save(tmpImage, tmpDrawable, jpgFile, jpgFile, 0.95, 0, 1, 0, "", 0, 1, 0, 0)
		pdb.gimp_image_delete(tmpImage)

#Rembg操作
	if OutputMessage:
		pdb.gimp_message(aiExe)
	if AlphaMatting:
		option = "-a -ae %d" % (aeValue)
	cmd_list = [aiExe, "i", "-m", tupleModel[selModel]]
	if option:
		cmd_list.extend(option.split())
	cmd_list.extend([jpgFile, pngFile])

	creationflags = 0

	process = subprocess.Popen(cmd_list, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

	while process.poll() is None:
		gimp.progress_update(0.7)
		gimp.displays_flush()
		import time
		time.sleep(0.1)

	stdout, stderr = process.communicate()

	if OutputMessage:
		pdb.gimp_message(str(stderr.decode('cp950', errors='ignore')))
		if os.path.exists(errFile):
			with open(errFile, "r", encoding='cp950') as fp:
				output = fp.read()
				if len(output) > 0:
					unicodestr = output.encode('utf-8')
					if OutputMessage:
						pdb.gimp_message(unicodestr)
			os.remove(errFile)
			if len(output) > 0 and not OutputMessage:
				pdb.gimp_message(unicodestr)

	gimp.progress_update(0.8)

#GIMP操作


	#GIMPに追加されるレイヤー名
	layer_name = str(tupleModel[selModel])
	if asMask:
		layer_name =layer_name + "-mask"
	if AlphaMatting:
		layer_name =layer_name + "-am-" + str(aeValue)

	file_exists = os.path.exists(pngFile)
	if file_exists:
		newlayer = pdb.gimp_file_load_layer(image, pngFile)
   		image.add_layer(newlayer, -1)
		pdb.gimp_layer_set_name(newlayer, layer_name)
   		pdb.gimp_layer_set_offsets(newlayer, x1, y1)
   		if asMask:
   			pdb.gimp_image_select_item(image, CHANNEL_OP_REPLACE, newlayer)
   			image.remove_layer(newlayer)
			copyLayer = pdb.gimp_layer_copy(curLayer, TRUE)
			image.add_layer(copyLayer, -1)
			pdb.gimp_layer_set_name(copyLayer, layer_name)
			mask=copyLayer.create_mask(ADD_SELECTION_MASK)
			copyLayer.add_mask(mask)
			pdb.gimp_selection_none(image)

	gimp.progress_update(0.9)
	image.undo_group_end()
	gimp.displays_flush()

	if removeTmpFile:
		if osName == "Windows":
			del_command = "del \"%s%sTemp-gimp-0000.*\"" % (tdir, exportSep)
		else:
			del_command = "rm %s%sTemp-gimp-0000.*" % (tdir, exportSep)
		os.system(del_command)

register(
    "Rembg",
    "AI背景除去",
    "AI背景除去",
    "JamesH, <elastic192@gmail.com>",
    "JamesH, https://elastic192.blogspot.com",
    "2022/6/4",
    "<Image>/プラグイン/AI背景除去(Rembg)",
    "RGB*",
    [
       (PF_TOGGLE, "asMask", ("レイヤーマスクを作成する"), True),
       (PF_OPTION,"selModel","学習モデル", 0, tupleModel),
       (PF_TOGGLE, "AlphaMatting", ("アルファマット"), False),
       (PF_SPINNER,"aeValue", ("アルファマット侵食サイズ"), 15, (1,100,1))
    ],
    [],
    Rembg,
    domain=("gimp20-python", gimp.locale_directory))

main()

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 原作者：James Huang <elastic192@gmail.com>
#         https://elastic192.blogspot.com/

import sys
import os, string, tempfile
import platform
import subprocess
import gi
gi.require_version('Gimp', '3.0')
from gi.repository import Gimp
gi.require_version('GimpUi', '3.0')
from gi.repository import GimpUi
from gi.repository import GLib
from gi.repository import GObject
from gi.repository import Gio
import time


def N_(message): return message
def _(message): return GLib.dgettext(None, message)

#学習モデル一覧
tupleModel = ("u2net","u2net_human_seg", "u2net_cloth_seg", "u2netp", "silueta", "isnet-general-use", "isnet-anime",
              "birefnet-general","birefnet-general-lite","birefnet-portrait","birefnet-dis","birefnet-hrsod","birefnet-cod","birefnet-massive")

#ユーザー設定部分

#rembg.exeのアドレスを指定する
aiExe = r"C:\Users\■■■\AppData\Local\Programs\Python\Python■■■\Scripts\rembg.exe"
#初期値：aiExe = r"C:\Users\■■■\AppData\Local\Programs\Python\Python■■■\Scripts\rembg.exe"

#画像処理をするアドレスを指定する
tdir = tempfile.gettempdir()
#初期値：tdir = tempfile.gettempdir()

def pdbCall(procedureName, args):
    pdb_proc   = Gimp.get_pdb().lookup_procedure(procedureName)
    pdb_config = pdb_proc.create_config()
    for x in args:
        pdb_config.set_property(x, args[x])
    return pdb_proc.run(pdb_config)

def store_layer_png(image, drawable, path):
    interlace, compression = 0, 2

    _, x, y = drawable.get_offsets()
    width, height = drawable.get_width(), drawable.get_height()
    tmp_img = Gimp.Image.new(width, height, image.get_base_type())
    drawable.set_offsets(0, 0)
    tmp_layer = Gimp.Layer.new_from_drawable (drawable, tmp_img)
    tmp_img.insert_layer (tmp_layer, None, 0)
    drawable.set_offsets(x, y)
    
    args = {
      "run-mode": Gimp.RunMode.NONINTERACTIVE,
      "image": tmp_img,
      "file": Gio.File.new_for_path(path),
      "options": None,
      "interlaced": interlace,
      "compression": compression,
      "bkgd": True,
      "offs": False,
      "phys": True,
      "time": True,
      "save-transparent": True
    }
    pdbCall('file-png-export', args);

    tmp_img.delete()
    
def store_layer_jpg(image, drawable, path):
    _, x, y = drawable.get_offsets()
    width, height = drawable.get_width(), drawable.get_height()
    tmp_img = Gimp.Image.new(width, height, image.get_base_type())
    drawable.set_offsets(0, 0)
    tmp_layer = Gimp.Layer.new_from_drawable (drawable, tmp_img)
    tmp_img.insert_layer (tmp_layer, None, 0)
    drawable.set_offsets(x, y)
    
    args = {
      "run-mode": Gimp.RunMode.NONINTERACTIVE,
      "image": tmp_img,
      "file": Gio.File.new_for_path(path),
      "options": None,
      "quality": 0.95,
      "smoothing": 0,
      "optimize": True
    }
    pdbCall('file-jpeg-export', args);
    
    tmp_img.delete()

def RemoveBG(procedure, run_mode, image, drawables, config, data):
    if run_mode == Gimp.RunMode.INTERACTIVE:
        GimpUi.init('plug-in-RemoveBG-python')
        dialog = GimpUi.ProcedureDialog(procedure=procedure, config=config)
        dialog.fill(["asMask"])
        dialog.fill(["AlphaMatting"])
        dialog.fill(["aeValue"])
        dialog.get_int_combo("selModel", GimpUi.IntStore.new (tupleModel))
        dialog.fill(["selModel"])
        if not dialog.run():
            return procedure.new_return_values(Gimp.PDBStatusType.CANCEL, GLib.Error())
            
    removeTmpFile = True
    OutputMessage = False
    osName = platform.system()
    exportSep = str(os.sep)
    
    if OutputMessage:
        Gimp.message(tdir)
    jpgFile = os.path.join(tdir, "Temp-gimp-0000.jpg")
    pngFile = os.path.join(tdir, "Temp-gimp-0000.png")
    errFile = os.path.join(tdir, "ErrMsg.txt")
    x1 = 0
    y1 = 0
    option = ""
    
    Gimp.progress_init("AI背景削除中")
    Gimp.progress_update(0.0)
            
    
    asMask       = config.get_property('asMask')
    AlphaMatting = config.get_property('AlphaMatting')
    aeValue      = config.get_property('aeValue')
    selModel     = config.get_property('selModel')
    
    if OutputMessage:
        msg = "data: %s %s %d %s" % (asMask, AlphaMatting, aeValue, tupleModel[selModel])
        Gimp.message(msg)

    if OutputMessage:
        Gimp.message(aiExe)

    if AlphaMatting:
        option = "-a -ae %d" % (aeValue)
  
    command_args = [
    aiExe,
    "i",
    "-m",
    tupleModel[selModel]
    ]

    if option:
        command_args.extend(option.split()) 

    command_args.append(jpgFile)
    command_args.append(pngFile)

    if OutputMessage:
        Gimp.message("構築されたコマンド（リスト形式）：" + str(command_args))
 
    Gimp.progress_update(0.1)

    Gimp.context_push()
    image.undo_group_start()
    
    drawable = drawables[0]
    curLayer = drawable
    _, x1, y1 = drawable.get_offsets()
    Gimp.progress_update(0.2)
    
    store_layer_jpg(image, drawable, jpgFile)
    Gimp.progress_update(0.4)
    
    max_attempts = 10
    wait_interval = 0.2 

    file_ready = False
    for i in range(max_attempts):

        if os.path.exists(jpgFile) and os.path.getsize(jpgFile) > 0:
            file_ready = True
            break
        time.sleep(wait_interval)
        Gimp.message(f"一時ファイル '{jpgFile}' の準備を待機中... ({i+1}/{max_attempts}回目)")
    
    if not file_ready:
        Gimp.message(f"エラー: 一時ファイル '{jpgFile}' が時間内に生成されませんでした。処理を中止します。")
        image.undo_group_end() # エラーで終了する場合もundoを閉じる
        Gimp.context_pop()
        Gimp.progress_end()
        return procedure.new_return_values(Gimp.PDBStatusType.FAIL, GLib.Error())

    try:

        result = subprocess.run(
            command_args,
            check=True,
            capture_output=True,
            text=True,
            shell=False
        )

        if OutputMessage and result.stdout:
            Gimp.message("rembg.exe 標準出力:\n" + result.stdout)
        if OutputMessage and result.stderr:
            Gimp.message("rembg.exe 標準エラー:\n" + result.stderr)


    except subprocess.CalledProcessError as e:

        error_message = f"rembg.exe の実行エラー:\n"
        error_message += f"コマンド: {e.cmd}\n"
        error_message += f"戻り値: {e.returncode}\n"
        if e.stdout:
            error_message += f"標準出力:\n{e.stdout}\n"
        if e.stderr:
            error_message += f"標準エラー:\n{e.stderr}"
        Gimp.message(error_message)
        
        image.undo_group_end()
        Gimp.context_pop()
        Gimp.progress_end()
        return procedure.new_return_values(Gimp.PDBStatusType.FAIL, GLib.Error())


    except FileNotFoundError:
        Gimp.message(f"エラー: rembg.exe が見つかりません。\nパス: {aiExe} を確認してください。")
        image.undo_group_end()
        Gimp.context_pop()
        Gimp.progress_end()
        return procedure.new_return_values(Gimp.PDBStatusType.FAIL, GLib.Error())

    except Exception as e:
        Gimp.message(f"不明なエラーが発生しました: {e}")
        image.undo_group_end()
        Gimp.context_pop()
        Gimp.progress_end()
        return procedure.new_return_values(Gimp.PDBStatusType.FAIL, GLib.Error())

    Gimp.progress_update(0.8)

    Gimp.progress_update(0.9)
    file_exists = os.path.exists(pngFile)
    if file_exists:
        args = {
          "run-mode": Gimp.RunMode.NONINTERACTIVE,
          "image": image,
          "file": Gio.File.new_for_path(pngFile)
        }
        result = pdbCall('gimp-file-load-layer', args);
        if (result.index(0) == Gimp.PDBStatusType.SUCCESS):
            gimp_layer = result.index(1)

            gimp_layer.set_offsets(x1, y1)
            image.insert_layer(gimp_layer, drawable.get_parent(),
                               image.get_item_position(drawable))
            if asMask:
                image.select_item(2, gimp_layer)
                image.remove_layer(gimp_layer)
                copyLayer = Gimp.Layer.copy(curLayer)
                image.insert_layer(copyLayer, drawable.get_parent(),
                               image.get_item_position(drawable))

            layer_name = str(tupleModel[selModel])
            if asMask:
            	layer_name =layer_name + "-mask"
            if AlphaMatting:
            	layer_name =layer_name + "-am-" + str(aeValue)

            copyLayer.set_name(layer_name)
            mask=copyLayer.create_mask(4)
            copyLayer.add_mask(mask)
            Gimp.Selection.none(image)
        else:
            print("Error loading layer from openraster image.")
    
    Gimp.displays_flush()
    image.undo_group_end()
    Gimp.context_pop()
    
    if removeTmpFile:
        if osName == "Windows":
            del_command = f"del \"{os.path.join(tdir, 'Temp-gimp-0000.*')}\""
        else:
            del_command = f"rm {os.path.join(tdir, 'Temp-gimp-0000.*')}"
        os.system(del_command)

    Gimp.progress_update(1.0)
    Gimp.progress_end()
    
    return procedure.new_return_values(Gimp.PDBStatusType.SUCCESS, GLib.Error())

class AIRemoveBG (Gimp.PlugIn):
    def do_query_procedures(self):
        return [ "plug-in-RemoveBG-python" ]

    def do_set_i18n (self, name):
        return False

    def do_create_procedure(self, name):
        procedure = Gimp.ImageProcedure.new(self, name,
                                             Gimp.PDBProcType.PLUGIN,
                                             RemoveBG, None)

        procedure.set_image_types("*")

        procedure.set_menu_label("AI背景削除")
        procedure.add_menu_path('<Image>/プラグイン/')

        procedure.set_documentation("AI背景削除",
                                     "AI背景削除",
                                     name)
        procedure.set_attribution("JamesH", "JamesH", "2023")
        
        procedure.add_boolean_argument ("asMask", _("_レイヤーマスクを作成"), _("レイヤーマスクを作成"),
                                         True, GObject.ParamFlags.READWRITE)
        procedure.add_boolean_argument ("AlphaMatting", _("_アルファマット"), _("アルファマット"),
                                         False, GObject.ParamFlags.READWRITE)
        procedure.add_int_argument ("aeValue", _("アルファ_マット侵食サイズ"), _("アルファマット侵食サイズ"),
                                         1, 100, 15, GObject.ParamFlags.READWRITE)
        procedure.add_int_argument ("selModel", _("学習_モデル"), _("学習モデル"),
                                         0, len(tupleModel), 0, GObject.ParamFlags.READWRITE)

        return procedure

Gimp.main(AIRemoveBG.__gtype__, sys.argv)