ControlNet-v1-1-Annotators-cpu

Running

App Files Files Community

ControlNet-v1-1-Annotators-cpu / app.py

atatakun

Update app.py

fce3d1e verified 7 days ago

raw history blame contribute delete

No virus

21.7 kB

	import gradio as gr
	import cv2
	import numpy as np

	from annotator.util import resize_image, HWC3


	DESCRIPTION = '# ControlNet v1.1 Annotators (that runs on cpu only)'
	DESCRIPTION += '\n<p>This app generates Control Image for Mochi Diffusion's ControlNet.</p>'
	DESCRIPTION += '\n<p>HEIC image is not converted. Please use PNG or JPG image.</p>'
	DESCRIPTION += '\n<p>Gradioのバージョンが上がって変換された画像がWebpになっています。最新のMochiDiffusionでは問題なく使えるようです。</p>'
	#DESCRIPTION += '\n<p>Safariではドラッグ＆ドロップで画像をアップロードすることができませんので、クリックしてアップロードをご利用ください。</p>'
	#DESCRIPTION += '\n<p>The version of Gradio has been upgraded and the converted images are now Webp. It seems to be usable with the latest MochiDiffusion without any problems.</p>'
	#DESCRIPTION += '\n<p>If you are using Safari, you cannot upload images by drag and drop, so please use the upload button.</p>'


	model_canny = None


	def canny(img, res, l, h):
	img = resize_image(HWC3(img), res)
	global model_canny
	if model_canny is None:
	from annotator.canny import CannyDetector
	model_canny = CannyDetector()
	result = model_canny(img, l, h)
	return [result]


	model_hed = None


	def hed(img, res):
	img = resize_image(HWC3(img), res)
	global model_hed
	if model_hed is None:
	from annotator.hed import HEDdetector
	model_hed = HEDdetector()
	result = model_hed(img)
	return [result]


	model_pidi = None


	def pidi(img, res):
	img = resize_image(HWC3(img), res)
	global model_pidi
	if model_pidi is None:
	from annotator.pidinet import PidiNetDetector
	model_pidi = PidiNetDetector()
	result = model_pidi(img)
	return [result]


	model_mlsd = None


	def mlsd(img, res, thr_v, thr_d):
	img = resize_image(HWC3(img), res)
	global model_mlsd
	if model_mlsd is None:
	from annotator.mlsd import MLSDdetector
	model_mlsd = MLSDdetector()
	result = model_mlsd(img, thr_v, thr_d)
	return [result]


	model_midas = None


	def midas(img, res):
	img = resize_image(HWC3(img), res)
	global model_midas
	if model_midas is None:
	from annotator.midas import MidasDetector
	model_midas = MidasDetector()
	result = model_midas(img)
	return [result]


	model_zoe = None


	def zoe(img, res):
	img = resize_image(HWC3(img), res)
	global model_zoe
	if model_zoe is None:
	from annotator.zoe import ZoeDetector
	model_zoe = ZoeDetector()
	result = model_zoe(img)
	return [result]


	model_normalbae = None


	def normalbae(img, res):
	img = resize_image(HWC3(img), res)
	global model_normalbae
	if model_normalbae is None:
	from annotator.normalbae import NormalBaeDetector
	model_normalbae = NormalBaeDetector()
	result = model_normalbae(img)
	return [result]


	model_openpose = None


	def openpose(img, res, hand_and_face):
	img = resize_image(HWC3(img), res)
	global model_openpose
	if model_openpose is None:
	from annotator.openpose import OpenposeDetector
	model_openpose = OpenposeDetector()
	result = model_openpose(img, hand_and_face)
	return [result]

	model_dwpose = None

	def dwpose(img, res):
	img = resize_image(HWC3(img), res)
	global model_dwpose
	if model_dwpose is None:
	from annotator.dwpose import DWposeDetector
	model_dwpose = DWposeDetector()
	result = model_dwpose(img)
	return [result]


	#model_uniformer = None


	#def uniformer(img, res):
	# img = resize_image(HWC3(img), res)
	# global model_uniformer
	# if model_uniformer is None:
	# from annotator.uniformer import UniformerDetector
	# model_uniformer = UniformerDetector()
	# result = model_uniformer(img)
	# return [result]


	model_lineart_anime = None


	def lineart_anime(img, res, invert=True):
	img = resize_image(HWC3(img), res)
	global model_lineart_anime
	if model_lineart_anime is None:
	from annotator.lineart_anime import LineartAnimeDetector
	model_lineart_anime = LineartAnimeDetector()
	# result = model_lineart_anime(img)
	if (invert):
	result = cv2.bitwise_not(model_lineart_anime(img))
	else:
	result = model_lineart_anime(img)
	return [result]


	model_lineart = None


	def lineart(img, res, coarse=False, invert=True):
	img = resize_image(HWC3(img), res)
	global model_lineart
	if model_lineart is None:
	from annotator.lineart import LineartDetector
	model_lineart = LineartDetector()
	# result = model_lineart(img, coarse)
	if (invert):
	result = cv2.bitwise_not(model_lineart(img, coarse))
	else:
	result = model_lineart(img, coarse)
	return [result]


	model_oneformer_coco = None


	def oneformer_coco(img, res):
	img = resize_image(HWC3(img), res)
	global model_oneformer_coco
	if model_oneformer_coco is None:
	from annotator.oneformer import OneformerCOCODetector
	model_oneformer_coco = OneformerCOCODetector()
	result = model_oneformer_coco(img)
	return [result]


	model_oneformer_ade20k = None


	def oneformer_ade20k(img, res):
	img = resize_image(HWC3(img), res)
	global model_oneformer_ade20k
	if model_oneformer_ade20k is None:
	from annotator.oneformer import OneformerADE20kDetector
	model_oneformer_ade20k = OneformerADE20kDetector()
	result = model_oneformer_ade20k(img)
	return [result]


	model_content_shuffler = None


	def content_shuffler(img, res):
	img = resize_image(HWC3(img), res)
	global model_content_shuffler
	if model_content_shuffler is None:
	from annotator.shuffle import ContentShuffleDetector
	model_content_shuffler = ContentShuffleDetector()
	result = model_content_shuffler(img)
	return [result]


	model_color_shuffler = None


	def color_shuffler(img, res):
	img = resize_image(HWC3(img), res)
	global model_color_shuffler
	if model_color_shuffler is None:
	from annotator.shuffle import ColorShuffleDetector
	model_color_shuffler = ColorShuffleDetector()
	result = model_color_shuffler(img)
	return [result]

	model_inpaint = None


	def inpaint(image, invert):
	# image = resize_image(img, res)
	# color = HWC3(image["image"])
	color = HWC3(image["background"])
	if(invert):
	# alpha = image["mask"][:, :, 0:1]
	alpha = image["layers"][0][:, :, 3:]
	else:
	# alpha = 255 - image["mask"][:, :, 0:1]
	alpha = 255 - image["layers"][0][:, :, 3:]
	result = np.concatenate([color, alpha], axis=2)
	return [result]



	#def predict(im):
	# return im["composite"]
	# return im["inputmask"] # bad
	# return im["layers"][0]

	custom_theme = gr.themes.Soft(primary_hue="blue").set(
	button_secondary_background_fill="*neutral_100",
	button_secondary_background_fill_hover="*neutral_200")
	custom_css = '''#disp_image {
	text-align: center; /* Horizontally center the content */
	}'''


	block = gr.Blocks(theme=custom_theme, css=custom_css).queue()

	with block:
	gr.Markdown(DESCRIPTION)
	with gr.Row():
	gr.Markdown("## Canny Edge")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	low_threshold = gr.Slider(label="low_threshold", minimum=1, maximum=255, value=100, step=1)
	high_threshold = gr.Slider(label="high_threshold", minimum=1, maximum=255, value=200, step=1)
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=canny, inputs=[input_image, resolution, low_threshold, high_threshold], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Inpaint \n<p>画像はツールのUpload buttonを押してアップロードして下さい。")
	with gr.Row():
	with gr.Column():
	input_image = gr.ImageMask(sources="upload", type="numpy", height="auto")
	# im_preview = gr.Image()
	# input_image.change(predict, outputs=im_preview, inputs=input_image, show_progress="hidden")
	# input_image = gr.ImageEditor(sources="upload", type="numpy", height="auto", layers="False", brush=gr.Brush(colors=["#000000"]))
	# input_image = gr.Image(source='upload', type="numpy", tool="sketch", height=512)
	# resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	invert = gr.Checkbox(label='Invert Mask', value=False)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=inpaint, inputs=[input_image, invert], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## HED Edge "SoftEdge"")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=hed, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Pidi Edge "SoftEdge"")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=pidi, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## MLSD Edge")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	value_threshold = gr.Slider(label="value_threshold", minimum=0.01, maximum=2.0, value=0.1, step=0.01)
	distance_threshold = gr.Slider(label="distance_threshold", minimum=0.01, maximum=20.0, value=0.1, step=0.01)
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=384, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=mlsd, inputs=[input_image, resolution, value_threshold, distance_threshold], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## MIDAS Depth")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=384, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=midas, inputs=[input_image, resolution], outputs=[gallery])


	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Zoe Depth")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=zoe, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Normal Bae")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=normalbae, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## DWPose")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=dwpose, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Openpose")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	hand_and_face = gr.Checkbox(label='Hand and Face', value=False)
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=openpose, inputs=[input_image, resolution, hand_and_face], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Lineart Anime \n<p>Check Invert to use with Mochi Diffusion.")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	invert = gr.Checkbox(label='Invert', value=True)
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=lineart_anime, inputs=[input_image, resolution, invert], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Lineart \n<p>Check Invert to use with Mochi Diffusion. Inverted image can also be created here for use with ControlNet Scribble.")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	coarse = gr.Checkbox(label='Using coarse model', value=False)
	invert = gr.Checkbox(label='Invert', value=True)
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=lineart, inputs=[input_image, resolution, coarse, invert], outputs=[gallery])

	# with gr.Row():
	# gr.Markdown("## Uniformer Segmentation")
	# with gr.Row():
	# with gr.Column():
	# input_image = gr.Image(source='upload', type="numpy")
	# resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	# run_button = gr.Button(label="Run")
	# with gr.Column():
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	# run_button.click(fn=uniformer, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Oneformer COCO Segmentation")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=oneformer_coco, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Oneformer ADE20K Segmentation")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=640, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=oneformer_ade20k, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Content Shuffle")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=content_shuffler, inputs=[input_image, resolution], outputs=[gallery])

	gr.Markdown("<hr>")
	with gr.Row():
	gr.Markdown("## Color Shuffle")
	with gr.Row():
	with gr.Column():
	input_image = gr.Image(label="Input Image", type="numpy", height=480)
	# input_image = gr.Image(source='upload', type="numpy")
	resolution = gr.Slider(label="resolution", minimum=256, maximum=1024, value=512, step=64)
	run_button = gr.Button("Run")
	# run_button = gr.Button(label="Run")
	with gr.Column():
	gallery = gr.Gallery(label="Generated images", show_label=False, height="auto")
	# gallery = gr.Gallery(label="Generated images", show_label=False).style(height="auto")
	run_button.click(fn=color_shuffler, inputs=[input_image, resolution], outputs=[gallery])


	block.launch(server_name='0.0.0.0')