>")
+ self.img.setAlignment(Qt.AlignCenter)
+ self.img.setFixedSize(QSize(512, 512))
+ self.vspacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
+
+ self.prompt = QTextEdit()
+ self.prompt.setPlaceholderText("A fantasy landscape")
+ self.prompt.setAcceptRichText(False)
+ self.neg_prompt = QTextEdit()
+ self.neg_prompt.setPlaceholderText("")
+ self.neg_prompt.setAcceptRichText(False)
+ self.neg_prompt_label = QLabel("Negative prompt (Set guidance scale > 1.0):")
+ self.generate = QPushButton("Generate")
+ self.generate.clicked.connect(self.text_to_image)
+ self.prompt.setFixedHeight(40)
+ self.neg_prompt.setFixedHeight(35)
+ self.browse_results = QPushButton("...")
+ self.browse_results.setFixedWidth(30)
+ self.browse_results.clicked.connect(self.on_open_results_folder)
+ self.browse_results.setToolTip("Open output folder")
+
+ hlayout = QHBoxLayout()
+ hlayout.addWidget(self.neg_prompt)
+ hlayout.addWidget(self.generate)
+ hlayout.addWidget(self.browse_results)
+
+ self.previous_img_btn = QToolButton()
+ self.previous_img_btn.setText("<")
+ self.previous_img_btn.clicked.connect(self.on_show_previous_image)
+ self.next_img_btn = QToolButton()
+ self.next_img_btn.setText(">")
+ self.next_img_btn.clicked.connect(self.on_show_next_image)
+ hlayout_nav = QHBoxLayout()
+ hlayout_nav.addWidget(self.previous_img_btn)
+ hlayout_nav.addWidget(self.img)
+ hlayout_nav.addWidget(self.next_img_btn)
+
+ vlayout = QVBoxLayout()
+ vlayout.addLayout(hlayout_nav)
+ vlayout.addItem(self.vspacer)
+ vlayout.addWidget(self.prompt)
+ vlayout.addWidget(self.neg_prompt_label)
+ vlayout.addLayout(hlayout)
+
+ self.tab_widget = QTabWidget(self)
+ self.tab_main = QWidget()
+ self.tab_settings = QWidget()
+ self.tab_about = QWidget()
+ self.tab_main.setLayout(vlayout)
+
+ self.tab_widget.addTab(self.tab_main, "Text to Image")
+ self.tab_widget.addTab(self.tab_settings, "Settings")
+ self.tab_widget.addTab(self.tab_about, "About")
+
+ self.setCentralWidget(self.tab_widget)
+ self.use_seed = False
+
+ def create_settings_tab(self):
+ self.lcm_model_label = QLabel("Latent Consistency Model:")
+ # self.lcm_model = QLineEdit(LCM_DEFAULT_MODEL)
+ self.lcm_model = QComboBox(self)
+ self.lcm_model.addItems(self.config.lcm_models)
+ self.lcm_model.currentIndexChanged.connect(self.on_lcm_model_changed)
+
+ self.use_lcm_lora = QCheckBox("Use LCM LoRA")
+ self.use_lcm_lora.setChecked(False)
+ self.use_lcm_lora.stateChanged.connect(self.use_lcm_lora_changed)
+
+ self.lora_base_model_id_label = QLabel("Lora base model ID :")
+ self.base_model_id = QComboBox(self)
+ self.base_model_id.addItems(self.config.stable_diffsuion_models)
+ self.base_model_id.currentIndexChanged.connect(self.on_base_model_id_changed)
+
+ self.lcm_lora_model_id_label = QLabel("LCM LoRA model ID :")
+ self.lcm_lora_id = QComboBox(self)
+ self.lcm_lora_id.addItems(self.config.lcm_lora_models)
+ self.lcm_lora_id.currentIndexChanged.connect(self.on_lcm_lora_id_changed)
+
+ self.inference_steps_value = QLabel("Number of inference steps: 4")
+ self.inference_steps = QSlider(orientation=Qt.Orientation.Horizontal)
+ self.inference_steps.setMaximum(25)
+ self.inference_steps.setMinimum(1)
+ self.inference_steps.setValue(4)
+ self.inference_steps.valueChanged.connect(self.update_steps_label)
+
+ self.num_images_value = QLabel("Number of images: 1")
+ self.num_images = QSlider(orientation=Qt.Orientation.Horizontal)
+ self.num_images.setMaximum(100)
+ self.num_images.setMinimum(1)
+ self.num_images.setValue(1)
+ self.num_images.valueChanged.connect(self.update_num_images_label)
+
+ self.guidance_value = QLabel("Guidance scale: 1")
+ self.guidance = QSlider(orientation=Qt.Orientation.Horizontal)
+ self.guidance.setMaximum(20)
+ self.guidance.setMinimum(10)
+ self.guidance.setValue(10)
+ self.guidance.valueChanged.connect(self.update_guidance_label)
+
+ self.clip_skip_value = QLabel("CLIP Skip: 1")
+ self.clip_skip = QSlider(orientation=Qt.Orientation.Horizontal)
+ self.clip_skip.setMaximum(12)
+ self.clip_skip.setMinimum(1)
+ self.clip_skip.setValue(1)
+ self.clip_skip.valueChanged.connect(self.update_clip_skip_label)
+
+ self.token_merging_value = QLabel("Token Merging: 0")
+ self.token_merging = QSlider(orientation=Qt.Orientation.Horizontal)
+ self.token_merging.setMaximum(100)
+ self.token_merging.setMinimum(0)
+ self.token_merging.setValue(0)
+ self.token_merging.valueChanged.connect(self.update_token_merging_label)
+
+ self.width_value = QLabel("Width :")
+ self.width = QComboBox(self)
+ self.width.addItem("256")
+ self.width.addItem("512")
+ self.width.addItem("768")
+ self.width.addItem("1024")
+ self.width.setCurrentText("512")
+ self.width.currentIndexChanged.connect(self.on_width_changed)
+
+ self.height_value = QLabel("Height :")
+ self.height = QComboBox(self)
+ self.height.addItem("256")
+ self.height.addItem("512")
+ self.height.addItem("768")
+ self.height.addItem("1024")
+ self.height.setCurrentText("512")
+ self.height.currentIndexChanged.connect(self.on_height_changed)
+
+ self.seed_check = QCheckBox("Use seed")
+ self.seed_value = QLineEdit()
+ self.seed_value.setInputMask("9999999999")
+ self.seed_value.setText("123123")
+ self.seed_check.stateChanged.connect(self.seed_changed)
+
+ self.safety_checker = QCheckBox("Use safety checker")
+ self.safety_checker.setChecked(True)
+ self.safety_checker.stateChanged.connect(self.use_safety_checker_changed)
+
+ self.use_openvino_check = QCheckBox("Use OpenVINO")
+ self.use_openvino_check.setChecked(False)
+ self.openvino_model_label = QLabel("OpenVINO LCM model:")
+ self.use_local_model_folder = QCheckBox(
+ "Use locally cached model or downloaded model folder(offline)"
+ )
+ self.openvino_lcm_model_id = QComboBox(self)
+ self.openvino_lcm_model_id.addItems(self.config.openvino_lcm_models)
+ self.openvino_lcm_model_id.currentIndexChanged.connect(
+ self.on_openvino_lcm_model_id_changed
+ )
+
+ self.use_openvino_check.setEnabled(enable_openvino_controls())
+ self.use_local_model_folder.setChecked(False)
+ self.use_local_model_folder.stateChanged.connect(self.use_offline_model_changed)
+ self.use_openvino_check.stateChanged.connect(self.use_openvino_changed)
+
+ self.use_tae_sd = QCheckBox(
+ "Use Tiny Auto Encoder - TAESD (Fast, moderate quality)"
+ )
+ self.use_tae_sd.setChecked(False)
+ self.use_tae_sd.stateChanged.connect(self.use_tae_sd_changed)
+
+ hlayout = QHBoxLayout()
+ hlayout.addWidget(self.seed_check)
+ hlayout.addWidget(self.seed_value)
+ hspacer = QSpacerItem(20, 10, QSizePolicy.Expanding, QSizePolicy.Minimum)
+ slider_hspacer = QSpacerItem(20, 10, QSizePolicy.Expanding, QSizePolicy.Minimum)
+
+ self.results_path_label = QLabel("Output path:")
+ self.results_path = QLineEdit()
+ self.results_path.textChanged.connect(self.on_path_changed)
+ self.browse_folder_btn = QToolButton()
+ self.browse_folder_btn.setText("...")
+ self.browse_folder_btn.clicked.connect(self.on_browse_folder)
+
+ self.reset = QPushButton("Reset All")
+ self.reset.clicked.connect(self.reset_all_settings)
+
+ vlayout = QVBoxLayout()
+ vspacer = QSpacerItem(20, 20, QSizePolicy.Minimum, QSizePolicy.Expanding)
+ vlayout.addItem(hspacer)
+ vlayout.setSpacing(3)
+ vlayout.addWidget(self.lcm_model_label)
+ vlayout.addWidget(self.lcm_model)
+ vlayout.addWidget(self.use_local_model_folder)
+ vlayout.addWidget(self.use_lcm_lora)
+ vlayout.addWidget(self.lora_base_model_id_label)
+ vlayout.addWidget(self.base_model_id)
+ vlayout.addWidget(self.lcm_lora_model_id_label)
+ vlayout.addWidget(self.lcm_lora_id)
+ vlayout.addWidget(self.use_openvino_check)
+ vlayout.addWidget(self.openvino_model_label)
+ vlayout.addWidget(self.openvino_lcm_model_id)
+ vlayout.addWidget(self.use_tae_sd)
+ vlayout.addItem(slider_hspacer)
+ vlayout.addWidget(self.inference_steps_value)
+ vlayout.addWidget(self.inference_steps)
+ vlayout.addWidget(self.num_images_value)
+ vlayout.addWidget(self.num_images)
+ vlayout.addWidget(self.width_value)
+ vlayout.addWidget(self.width)
+ vlayout.addWidget(self.height_value)
+ vlayout.addWidget(self.height)
+ vlayout.addWidget(self.guidance_value)
+ vlayout.addWidget(self.guidance)
+ vlayout.addWidget(self.clip_skip_value)
+ vlayout.addWidget(self.clip_skip)
+ vlayout.addWidget(self.token_merging_value)
+ vlayout.addWidget(self.token_merging)
+ vlayout.addLayout(hlayout)
+ vlayout.addWidget(self.safety_checker)
+
+ vlayout.addWidget(self.results_path_label)
+ hlayout_path = QHBoxLayout()
+ hlayout_path.addWidget(self.results_path)
+ hlayout_path.addWidget(self.browse_folder_btn)
+ vlayout.addLayout(hlayout_path)
+ self.tab_settings.setLayout(vlayout)
+ hlayout_reset = QHBoxLayout()
+ hspacer = QSpacerItem(20, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
+ hlayout_reset.addItem(hspacer)
+ hlayout_reset.addWidget(self.reset)
+ vlayout.addLayout(hlayout_reset)
+ vlayout.addItem(vspacer)
+
+ def create_about_tab(self):
+ self.label = QLabel()
+ self.label.setAlignment(Qt.AlignCenter)
+ self.label.setText(
+ f"""FastSD CPU {APP_VERSION}
+ (c)2023 - 2024 Rupesh Sreeraman
+ Faster stable diffusion on CPU
+ Based on Latent Consistency Models
+ GitHub : https://github.com/rupeshs/fastsdcpu/
"""
+ )
+
+ vlayout = QVBoxLayout()
+ vlayout.addWidget(self.label)
+ self.tab_about.setLayout(vlayout)
+
+ def show_image(self, pixmap):
+ image_width = self.config.settings.lcm_diffusion_setting.image_width
+ image_height = self.config.settings.lcm_diffusion_setting.image_height
+ if image_width > 512 or image_height > 512:
+ new_width = 512 if image_width > 512 else image_width
+ new_height = 512 if image_height > 512 else image_height
+ self.img.setPixmap(
+ pixmap.scaled(
+ new_width,
+ new_height,
+ Qt.KeepAspectRatio,
+ )
+ )
+ else:
+ self.img.setPixmap(pixmap)
+
+ def on_show_next_image(self):
+ if self.image_index != len(self.gen_images) - 1 and len(self.gen_images) > 0:
+ self.previous_img_btn.setEnabled(True)
+ self.image_index += 1
+ self.show_image(self.gen_images[self.image_index])
+ if self.image_index == len(self.gen_images) - 1:
+ self.next_img_btn.setEnabled(False)
+
+ def on_open_results_folder(self):
+ QDesktopServices.openUrl(
+ QUrl.fromLocalFile(self.config.settings.generated_images.path)
+ )
+
+ def on_show_previous_image(self):
+ if self.image_index != 0:
+ self.next_img_btn.setEnabled(True)
+ self.image_index -= 1
+ self.show_image(self.gen_images[self.image_index])
+ if self.image_index == 0:
+ self.previous_img_btn.setEnabled(False)
+
+ def on_path_changed(self, text):
+ self.config.settings.generated_images.path = text
+
+ def on_browse_folder(self):
+ options = QFileDialog.Options()
+ options |= QFileDialog.ShowDirsOnly
+
+ folder_path = QFileDialog.getExistingDirectory(
+ self, "Select a Folder", "", options=options
+ )
+
+ if folder_path:
+ self.config.settings.generated_images.path = folder_path
+ self.results_path.setText(folder_path)
+
+ def on_width_changed(self, index):
+ width_txt = self.width.itemText(index)
+ self.config.settings.lcm_diffusion_setting.image_width = int(width_txt)
+
+ def on_height_changed(self, index):
+ height_txt = self.height.itemText(index)
+ self.config.settings.lcm_diffusion_setting.image_height = int(height_txt)
+
+ def on_lcm_model_changed(self, index):
+ model_id = self.lcm_model.itemText(index)
+ self.config.settings.lcm_diffusion_setting.lcm_model_id = model_id
+
+ def on_base_model_id_changed(self, index):
+ model_id = self.base_model_id.itemText(index)
+ self.config.settings.lcm_diffusion_setting.lcm_lora.base_model_id = model_id
+
+ def on_lcm_lora_id_changed(self, index):
+ model_id = self.lcm_lora_id.itemText(index)
+ self.config.settings.lcm_diffusion_setting.lcm_lora.lcm_lora_id = model_id
+
+ def on_openvino_lcm_model_id_changed(self, index):
+ model_id = self.openvino_lcm_model_id.itemText(index)
+ self.config.settings.lcm_diffusion_setting.openvino_lcm_model_id = model_id
+
+ def use_openvino_changed(self, state):
+ if state == 2:
+ self.lcm_model.setEnabled(False)
+ self.use_lcm_lora.setEnabled(False)
+ self.lcm_lora_id.setEnabled(False)
+ self.base_model_id.setEnabled(False)
+ self.neg_prompt.setEnabled(True)
+ self.openvino_lcm_model_id.setEnabled(True)
+ self.config.settings.lcm_diffusion_setting.use_openvino = True
+ else:
+ self.lcm_model.setEnabled(True)
+ self.use_lcm_lora.setEnabled(True)
+ self.lcm_lora_id.setEnabled(True)
+ self.base_model_id.setEnabled(True)
+ self.neg_prompt.setEnabled(False)
+ self.openvino_lcm_model_id.setEnabled(False)
+ self.config.settings.lcm_diffusion_setting.use_openvino = False
+
+ def use_tae_sd_changed(self, state):
+ if state == 2:
+ self.config.settings.lcm_diffusion_setting.use_tiny_auto_encoder = True
+ else:
+ self.config.settings.lcm_diffusion_setting.use_tiny_auto_encoder = False
+
+ def use_offline_model_changed(self, state):
+ if state == 2:
+ self.config.settings.lcm_diffusion_setting.use_offline_model = True
+ else:
+ self.config.settings.lcm_diffusion_setting.use_offline_model = False
+
+ def use_lcm_lora_changed(self, state):
+ if state == 2:
+ self.lcm_model.setEnabled(False)
+ self.lcm_lora_id.setEnabled(True)
+ self.base_model_id.setEnabled(True)
+ self.neg_prompt.setEnabled(True)
+ self.config.settings.lcm_diffusion_setting.use_lcm_lora = True
+ else:
+ self.lcm_model.setEnabled(True)
+ self.lcm_lora_id.setEnabled(False)
+ self.base_model_id.setEnabled(False)
+ self.neg_prompt.setEnabled(False)
+ self.config.settings.lcm_diffusion_setting.use_lcm_lora = False
+
+ def update_clip_skip_label(self, value):
+ self.clip_skip_value.setText(f"CLIP Skip: {value}")
+ self.config.settings.lcm_diffusion_setting.clip_skip = value
+
+ def update_token_merging_label(self, value):
+ val = round(int(value) / 100, 1)
+ self.token_merging_value.setText(f"Token Merging: {val}")
+ self.config.settings.lcm_diffusion_setting.token_merging = val
+
+ def use_safety_checker_changed(self, state):
+ if state == 2:
+ self.config.settings.lcm_diffusion_setting.use_safety_checker = True
+ else:
+ self.config.settings.lcm_diffusion_setting.use_safety_checker = False
+
+ def update_steps_label(self, value):
+ self.inference_steps_value.setText(f"Number of inference steps: {value}")
+ self.config.settings.lcm_diffusion_setting.inference_steps = value
+
+ def update_num_images_label(self, value):
+ self.num_images_value.setText(f"Number of images: {value}")
+ self.config.settings.lcm_diffusion_setting.number_of_images = value
+
+ def update_guidance_label(self, value):
+ val = round(int(value) / 10, 1)
+ self.guidance_value.setText(f"Guidance scale: {val}")
+ self.config.settings.lcm_diffusion_setting.guidance_scale = val
+
+ def seed_changed(self, state):
+ if state == 2:
+ self.seed_value.setEnabled(True)
+ self.config.settings.lcm_diffusion_setting.use_seed = True
+ else:
+ self.seed_value.setEnabled(False)
+ self.config.settings.lcm_diffusion_setting.use_seed = False
+
+ def get_seed_value(self) -> int:
+ use_seed = self.config.settings.lcm_diffusion_setting.use_seed
+ seed_value = int(self.seed_value.text()) if use_seed else -1
+ return seed_value
+
+ def generate_image(self):
+ self.config.settings.lcm_diffusion_setting.seed = self.get_seed_value()
+ self.config.settings.lcm_diffusion_setting.prompt = self.prompt.toPlainText()
+ self.config.settings.lcm_diffusion_setting.negative_prompt = (
+ self.neg_prompt.toPlainText()
+ )
+ self.config.settings.lcm_diffusion_setting.lcm_lora.lcm_lora_id = (
+ self.lcm_lora_id.currentText()
+ )
+ self.config.settings.lcm_diffusion_setting.lcm_lora.base_model_id = (
+ self.base_model_id.currentText()
+ )
+
+ if self.config.settings.lcm_diffusion_setting.use_openvino:
+ model_id = self.openvino_lcm_model_id.currentText()
+ self.config.settings.lcm_diffusion_setting.openvino_lcm_model_id = model_id
+ else:
+ model_id = self.lcm_model.currentText()
+ self.config.settings.lcm_diffusion_setting.lcm_model_id = model_id
+
+ reshape_required = False
+ if self.config.settings.lcm_diffusion_setting.use_openvino:
+ # Detect dimension change
+ reshape_required = is_reshape_required(
+ self.previous_width,
+ self.config.settings.lcm_diffusion_setting.image_width,
+ self.previous_height,
+ self.config.settings.lcm_diffusion_setting.image_height,
+ self.previous_model,
+ model_id,
+ self.previous_num_of_images,
+ self.config.settings.lcm_diffusion_setting.number_of_images,
+ )
+ self.config.settings.lcm_diffusion_setting.diffusion_task = (
+ DiffusionTask.text_to_image.value
+ )
+ images = self.context.generate_text_to_image(
+ self.config.settings,
+ reshape_required,
+ DEVICE,
+ )
+ self.image_index = 0
+ self.gen_images = []
+ for img in images:
+ im = ImageQt(img).copy()
+ pixmap = QPixmap.fromImage(im)
+ self.gen_images.append(pixmap)
+
+ if len(self.gen_images) > 1:
+ self.next_img_btn.setEnabled(True)
+ self.previous_img_btn.setEnabled(False)
+ else:
+ self.next_img_btn.setEnabled(False)
+ self.previous_img_btn.setEnabled(False)
+
+ self.show_image(self.gen_images[0])
+
+ self.previous_width = self.config.settings.lcm_diffusion_setting.image_width
+ self.previous_height = self.config.settings.lcm_diffusion_setting.image_height
+ self.previous_model = model_id
+ self.previous_num_of_images = (
+ self.config.settings.lcm_diffusion_setting.number_of_images
+ )
+
+ def text_to_image(self):
+ self.img.setText("Please wait...")
+ worker = ImageGeneratorWorker(self.generate_image)
+ self.threadpool.start(worker)
+
+ def closeEvent(self, event):
+ self.config.settings.lcm_diffusion_setting.seed = self.get_seed_value()
+ print(self.config.settings.lcm_diffusion_setting)
+ print("Saving settings")
+ self.config.save()
+
+ def reset_all_settings(self):
+ self.use_local_model_folder.setChecked(False)
+ self.width.setCurrentText("512")
+ self.height.setCurrentText("512")
+ self.inference_steps.setValue(4)
+ self.guidance.setValue(10)
+ self.clip_skip.setValue(1)
+ self.token_merging.setValue(0)
+ self.use_openvino_check.setChecked(False)
+ self.seed_check.setChecked(False)
+ self.safety_checker.setChecked(False)
+ self.results_path.setText(FastStableDiffusionPaths().get_results_path())
+ self.use_tae_sd.setChecked(False)
+ self.use_lcm_lora.setChecked(False)
diff --git a/src/frontend/gui/image_generator_worker.py b/src/frontend/gui/image_generator_worker.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a948365085ece82337309ac91d278e77fa03e40
--- /dev/null
+++ b/src/frontend/gui/image_generator_worker.py
@@ -0,0 +1,37 @@
+from PyQt5.QtCore import (
+ pyqtSlot,
+ QRunnable,
+ pyqtSignal,
+ pyqtSlot,
+)
+from PyQt5.QtCore import QObject
+import traceback
+import sys
+
+
+class WorkerSignals(QObject):
+ finished = pyqtSignal()
+ error = pyqtSignal(tuple)
+ result = pyqtSignal(object)
+
+
+class ImageGeneratorWorker(QRunnable):
+ def __init__(self, fn, *args, **kwargs):
+ super(ImageGeneratorWorker, self).__init__()
+ self.fn = fn
+ self.args = args
+ self.kwargs = kwargs
+ self.signals = WorkerSignals()
+
+ @pyqtSlot()
+ def run(self):
+ try:
+ result = self.fn(*self.args, **self.kwargs)
+ except:
+ traceback.print_exc()
+ exctype, value = sys.exc_info()[:2]
+ self.signals.error.emit((exctype, value, traceback.format_exc()))
+ else:
+ self.signals.result.emit(result)
+ finally:
+ self.signals.finished.emit()
diff --git a/src/frontend/gui/ui.py b/src/frontend/gui/ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..9250bf676da1f3dc8a2f5435095b9cec9b08041e
--- /dev/null
+++ b/src/frontend/gui/ui.py
@@ -0,0 +1,15 @@
+from typing import List
+from frontend.gui.app_window import MainWindow
+from PyQt5.QtWidgets import QApplication
+import sys
+from app_settings import AppSettings
+
+
+def start_gui(
+ argv: List[str],
+ app_settings: AppSettings,
+):
+ app = QApplication(sys.argv)
+ window = MainWindow(app_settings)
+ window.show()
+ app.exec()
diff --git a/src/frontend/utils.py b/src/frontend/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d70defdaff21ffa6ae7ab70378bc82f79abbaf8
--- /dev/null
+++ b/src/frontend/utils.py
@@ -0,0 +1,83 @@
+import platform
+from os import path
+from typing import List
+
+from backend.device import is_openvino_device
+from constants import DEVICE
+from paths import get_file_name
+
+
+def is_reshape_required(
+ prev_width: int,
+ cur_width: int,
+ prev_height: int,
+ cur_height: int,
+ prev_model: int,
+ cur_model: int,
+ prev_num_of_images: int,
+ cur_num_of_images: int,
+) -> bool:
+ reshape_required = False
+ if (
+ prev_width != cur_width
+ or prev_height != cur_height
+ or prev_model != cur_model
+ or prev_num_of_images != cur_num_of_images
+ ):
+ print("Reshape and compile")
+ reshape_required = True
+
+ return reshape_required
+
+
+def enable_openvino_controls() -> bool:
+ return is_openvino_device() and platform.system().lower() != "darwin" and platform.processor().lower() != 'arm'
+
+
+
+def get_valid_model_id(
+ models: List,
+ model_id: str,
+ default_model: str = "",
+) -> str:
+ if len(models) == 0:
+ print("Error: model configuration file is empty,please add some models.")
+ return ""
+ if model_id == "":
+ if default_model:
+ return default_model
+ else:
+ return models[0]
+
+ if model_id in models:
+ return model_id
+ else:
+ print(
+ f"Error:{model_id} Model not found in configuration file,so using first model : {models[0]}"
+ )
+ return models[0]
+
+
+def get_valid_lora_model(
+ models: List,
+ cur_model: str,
+ lora_models_dir: str,
+) -> str:
+ if cur_model == "" or cur_model is None:
+ print(
+ f"No lora models found, please add lora models to {lora_models_dir} directory"
+ )
+ return ""
+ else:
+ if path.exists(cur_model):
+ return get_file_name(cur_model)
+ else:
+ print(f"Lora model {cur_model} not found")
+ if len(models) > 0:
+ print(f"Fallback model - {models[0]}")
+ return get_file_name(models[0])
+ else:
+ print(
+ f"No lora models found, please add lora models to {lora_models_dir} directory"
+ )
+ return ""
diff --git a/src/frontend/webui/controlnet_ui.py b/src/frontend/webui/controlnet_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bfab4acb318324a97a9f8191ea96feca80e5cd8
--- /dev/null
+++ b/src/frontend/webui/controlnet_ui.py
@@ -0,0 +1,194 @@
+import gradio as gr
+from PIL import Image
+from backend.lora import get_lora_models
+from state import get_settings
+from backend.models.lcmdiffusion_setting import ControlNetSetting
+from backend.annotators.image_control_factory import ImageControlFactory
+
+_controlnet_models_map = None
+_controlnet_enabled = False
+_adapter_path = None
+
+app_settings = get_settings()
+
+
+def on_user_input(
+ enable: bool,
+ adapter_name: str,
+ conditioning_scale: float,
+ control_image: Image,
+ preprocessor: str,
+):
+ if not isinstance(adapter_name, str):
+ gr.Warning("Please select a valid ControlNet model")
+ return gr.Checkbox(value=False)
+
+ settings = app_settings.settings.lcm_diffusion_setting
+ if settings.controlnet is None:
+ settings.controlnet = ControlNetSetting()
+
+ if enable and (adapter_name is None or adapter_name == ""):
+ gr.Warning("Please select a valid ControlNet adapter")
+ return gr.Checkbox(value=False)
+ elif enable and not control_image:
+ gr.Warning("Please provide a ControlNet control image")
+ return gr.Checkbox(value=False)
+
+ if control_image is None:
+ return gr.Checkbox(value=enable)
+
+ if preprocessor == "None":
+ processed_control_image = control_image
+ else:
+ image_control_factory = ImageControlFactory()
+ control = image_control_factory.create_control(preprocessor)
+ processed_control_image = control.get_control_image(control_image)
+
+ if not enable:
+ settings.controlnet.enabled = False
+ else:
+ settings.controlnet.enabled = True
+ settings.controlnet.adapter_path = _controlnet_models_map[adapter_name]
+ settings.controlnet.conditioning_scale = float(conditioning_scale)
+ settings.controlnet._control_image = processed_control_image
+
+ # This code can be improved; currently, if the user clicks the
+ # "Enable ControlNet" checkbox or changes the currently selected
+ # ControlNet model, it will trigger a pipeline rebuild even if, in
+ # the end, the user leaves the same ControlNet settings
+ global _controlnet_enabled
+ global _adapter_path
+ if settings.controlnet.enabled != _controlnet_enabled or (
+ settings.controlnet.enabled
+ and settings.controlnet.adapter_path != _adapter_path
+ ):
+ settings.rebuild_pipeline = True
+ _controlnet_enabled = settings.controlnet.enabled
+ _adapter_path = settings.controlnet.adapter_path
+ return gr.Checkbox(value=enable)
+
+
+def on_change_conditioning_scale(cond_scale):
+ print(cond_scale)
+ app_settings.settings.lcm_diffusion_setting.controlnet.conditioning_scale = (
+ cond_scale
+ )
+
+
+def get_controlnet_ui() -> None:
+ with gr.Blocks() as ui:
+ gr.HTML(
+ 'Download ControlNet v1.1 model from ControlNet v1.1 (723 MB files) and place it in controlnet_models folder,restart the app'
+ )
+ with gr.Row():
+ with gr.Column():
+ with gr.Row():
+ global _controlnet_models_map
+ _controlnet_models_map = get_lora_models(
+ app_settings.settings.lcm_diffusion_setting.dirs["controlnet"]
+ )
+ controlnet_models = list(_controlnet_models_map.keys())
+ default_model = (
+ controlnet_models[0] if len(controlnet_models) else None
+ )
+
+ enabled_checkbox = gr.Checkbox(
+ label="Enable ControlNet",
+ info="Enable ControlNet",
+ show_label=True,
+ )
+ model_dropdown = gr.Dropdown(
+ _controlnet_models_map.keys(),
+ label="ControlNet model",
+ info="ControlNet model to load (.safetensors format)",
+ value=default_model,
+ interactive=True,
+ )
+ conditioning_scale_slider = gr.Slider(
+ 0.0,
+ 1.0,
+ value=0.5,
+ step=0.05,
+ label="ControlNet conditioning scale",
+ interactive=True,
+ )
+ control_image = gr.Image(
+ label="Control image",
+ type="pil",
+ )
+ preprocessor_radio = gr.Radio(
+ [
+ "Canny",
+ "Depth",
+ "LineArt",
+ "MLSD",
+ "NormalBAE",
+ "Pose",
+ "SoftEdge",
+ "Shuffle",
+ "None",
+ ],
+ label="Preprocessor",
+ info="Select the preprocessor for the control image",
+ value="Canny",
+ interactive=True,
+ )
+
+ enabled_checkbox.input(
+ fn=on_user_input,
+ inputs=[
+ enabled_checkbox,
+ model_dropdown,
+ conditioning_scale_slider,
+ control_image,
+ preprocessor_radio,
+ ],
+ outputs=[enabled_checkbox],
+ )
+ model_dropdown.input(
+ fn=on_user_input,
+ inputs=[
+ enabled_checkbox,
+ model_dropdown,
+ conditioning_scale_slider,
+ control_image,
+ preprocessor_radio,
+ ],
+ outputs=[enabled_checkbox],
+ )
+ conditioning_scale_slider.input(
+ fn=on_user_input,
+ inputs=[
+ enabled_checkbox,
+ model_dropdown,
+ conditioning_scale_slider,
+ control_image,
+ preprocessor_radio,
+ ],
+ outputs=[enabled_checkbox],
+ )
+ control_image.change(
+ fn=on_user_input,
+ inputs=[
+ enabled_checkbox,
+ model_dropdown,
+ conditioning_scale_slider,
+ control_image,
+ preprocessor_radio,
+ ],
+ outputs=[enabled_checkbox],
+ )
+ preprocessor_radio.change(
+ fn=on_user_input,
+ inputs=[
+ enabled_checkbox,
+ model_dropdown,
+ conditioning_scale_slider,
+ control_image,
+ preprocessor_radio,
+ ],
+ outputs=[enabled_checkbox],
+ )
+ conditioning_scale_slider.change(
+ on_change_conditioning_scale, conditioning_scale_slider
+ )
diff --git a/src/frontend/webui/css/style.css b/src/frontend/webui/css/style.css
new file mode 100644
index 0000000000000000000000000000000000000000..216e9f54bd789851bb1aa091cc8beaf98ddbe75d
--- /dev/null
+++ b/src/frontend/webui/css/style.css
@@ -0,0 +1,22 @@
+footer {
+ visibility: hidden
+}
+
+#generate_button {
+ color: white;
+ border-color: #007bff;
+ background: #2563eb;
+
+}
+
+#save_button {
+ color: white;
+ border-color: #028b40;
+ background: #01b97c;
+ width: 200px;
+}
+
+#settings_header {
+ background: rgb(245, 105, 105);
+
+}
\ No newline at end of file
diff --git a/src/frontend/webui/generation_settings_ui.py b/src/frontend/webui/generation_settings_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab47e01b3de38f496342aec3931ef8fe202ed709
--- /dev/null
+++ b/src/frontend/webui/generation_settings_ui.py
@@ -0,0 +1,184 @@
+import gradio as gr
+from state import get_settings
+from backend.models.gen_images import ImageFormat
+
+app_settings = get_settings()
+
+
+def on_change_inference_steps(steps):
+ app_settings.settings.lcm_diffusion_setting.inference_steps = steps
+
+
+def on_change_image_width(img_width):
+ app_settings.settings.lcm_diffusion_setting.image_width = img_width
+
+
+def on_change_image_height(img_height):
+ app_settings.settings.lcm_diffusion_setting.image_height = img_height
+
+
+def on_change_num_images(num_images):
+ app_settings.settings.lcm_diffusion_setting.number_of_images = num_images
+
+
+def on_change_guidance_scale(guidance_scale):
+ app_settings.settings.lcm_diffusion_setting.guidance_scale = guidance_scale
+
+
+def on_change_clip_skip(clip_skip):
+ app_settings.settings.lcm_diffusion_setting.clip_skip = clip_skip
+
+
+def on_change_token_merging(token_merging):
+ app_settings.settings.lcm_diffusion_setting.token_merging = token_merging
+
+
+def on_change_seed_value(seed):
+ app_settings.settings.lcm_diffusion_setting.seed = seed
+
+
+def on_change_seed_checkbox(seed_checkbox):
+ app_settings.settings.lcm_diffusion_setting.use_seed = seed_checkbox
+
+
+def on_change_safety_checker_checkbox(safety_checker_checkbox):
+ app_settings.settings.lcm_diffusion_setting.use_safety_checker = (
+ safety_checker_checkbox
+ )
+
+
+def on_change_tiny_auto_encoder_checkbox(tiny_auto_encoder_checkbox):
+ app_settings.settings.lcm_diffusion_setting.use_tiny_auto_encoder = (
+ tiny_auto_encoder_checkbox
+ )
+
+
+def on_offline_checkbox(offline_checkbox):
+ app_settings.settings.lcm_diffusion_setting.use_offline_model = offline_checkbox
+
+
+def on_change_image_format(image_format):
+ if image_format == "PNG":
+ app_settings.settings.generated_images.format = ImageFormat.PNG.value.upper()
+ else:
+ app_settings.settings.generated_images.format = ImageFormat.JPEG.value.upper()
+
+ app_settings.save()
+
+
+def get_generation_settings_ui() -> None:
+ with gr.Blocks():
+ with gr.Row():
+ with gr.Column():
+ num_inference_steps = gr.Slider(
+ 1,
+ 25,
+ value=app_settings.settings.lcm_diffusion_setting.inference_steps,
+ step=1,
+ label="Inference Steps",
+ interactive=True,
+ )
+
+ image_height = gr.Slider(
+ 256,
+ 1024,
+ value=app_settings.settings.lcm_diffusion_setting.image_height,
+ step=256,
+ label="Image Height",
+ interactive=True,
+ )
+ image_width = gr.Slider(
+ 256,
+ 1024,
+ value=app_settings.settings.lcm_diffusion_setting.image_width,
+ step=256,
+ label="Image Width",
+ interactive=True,
+ )
+ num_images = gr.Slider(
+ 1,
+ 50,
+ value=app_settings.settings.lcm_diffusion_setting.number_of_images,
+ step=1,
+ label="Number of images to generate",
+ interactive=True,
+ )
+ guidance_scale = gr.Slider(
+ 1.0,
+ 10.0,
+ value=app_settings.settings.lcm_diffusion_setting.guidance_scale,
+ step=0.1,
+ label="Guidance Scale",
+ interactive=True,
+ )
+ clip_skip = gr.Slider(
+ 1,
+ 12,
+ value=app_settings.settings.lcm_diffusion_setting.clip_skip,
+ step=1,
+ label="CLIP Skip",
+ interactive=True,
+ )
+ token_merging = gr.Slider(
+ 0.0,
+ 1.0,
+ value=app_settings.settings.lcm_diffusion_setting.token_merging,
+ step=0.01,
+ label="Token Merging",
+ interactive=True,
+ )
+
+
+ seed = gr.Slider(
+ value=app_settings.settings.lcm_diffusion_setting.seed,
+ minimum=0,
+ maximum=999999999,
+ label="Seed",
+ step=1,
+ interactive=True,
+ )
+ seed_checkbox = gr.Checkbox(
+ label="Use seed",
+ value=app_settings.settings.lcm_diffusion_setting.use_seed,
+ interactive=True,
+ )
+
+ safety_checker_checkbox = gr.Checkbox(
+ label="Use Safety Checker",
+ value=app_settings.settings.lcm_diffusion_setting.use_safety_checker,
+ interactive=True,
+ )
+ tiny_auto_encoder_checkbox = gr.Checkbox(
+ label="Use tiny auto encoder for SD",
+ value=app_settings.settings.lcm_diffusion_setting.use_tiny_auto_encoder,
+ interactive=True,
+ )
+ offline_checkbox = gr.Checkbox(
+ label="Use locally cached model or downloaded model folder(offline)",
+ value=app_settings.settings.lcm_diffusion_setting.use_offline_model,
+ interactive=True,
+ )
+ img_format = gr.Radio(
+ label="Output image format",
+ choices=["PNG", "JPEG"],
+ value=app_settings.settings.generated_images.format,
+ interactive=True,
+ )
+
+ num_inference_steps.change(on_change_inference_steps, num_inference_steps)
+ image_height.change(on_change_image_height, image_height)
+ image_width.change(on_change_image_width, image_width)
+ num_images.change(on_change_num_images, num_images)
+ guidance_scale.change(on_change_guidance_scale, guidance_scale)
+ clip_skip.change(on_change_clip_skip, clip_skip)
+ token_merging.change(on_change_token_merging, token_merging)
+ seed.change(on_change_seed_value, seed)
+ seed_checkbox.change(on_change_seed_checkbox, seed_checkbox)
+ safety_checker_checkbox.change(
+ on_change_safety_checker_checkbox, safety_checker_checkbox
+ )
+ tiny_auto_encoder_checkbox.change(
+ on_change_tiny_auto_encoder_checkbox, tiny_auto_encoder_checkbox
+ )
+ offline_checkbox.change(on_offline_checkbox, offline_checkbox)
+ img_format.change(on_change_image_format, img_format)
diff --git a/src/frontend/webui/image_to_image_ui.py b/src/frontend/webui/image_to_image_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d1ca9a7f7e055da17247b349154bca56d2d7c8d
--- /dev/null
+++ b/src/frontend/webui/image_to_image_ui.py
@@ -0,0 +1,120 @@
+from typing import Any
+import gradio as gr
+from backend.models.lcmdiffusion_setting import DiffusionTask
+from models.interface_types import InterfaceType
+from frontend.utils import is_reshape_required
+from constants import DEVICE
+from state import get_settings, get_context
+from concurrent.futures import ThreadPoolExecutor
+
+
+app_settings = get_settings()
+
+previous_width = 0
+previous_height = 0
+previous_model_id = ""
+previous_num_of_images = 0
+
+
+def generate_image_to_image(
+ prompt,
+ negative_prompt,
+ init_image,
+ strength,
+) -> Any:
+ context = get_context(InterfaceType.WEBUI)
+ global previous_height, previous_width, previous_model_id, previous_num_of_images, app_settings
+
+ app_settings.settings.lcm_diffusion_setting.prompt = prompt
+ app_settings.settings.lcm_diffusion_setting.negative_prompt = negative_prompt
+ app_settings.settings.lcm_diffusion_setting.init_image = init_image
+ app_settings.settings.lcm_diffusion_setting.strength = strength
+
+ app_settings.settings.lcm_diffusion_setting.diffusion_task = (
+ DiffusionTask.image_to_image.value
+ )
+ model_id = app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id
+ reshape = False
+ image_width = app_settings.settings.lcm_diffusion_setting.image_width
+ image_height = app_settings.settings.lcm_diffusion_setting.image_height
+ num_images = app_settings.settings.lcm_diffusion_setting.number_of_images
+ if app_settings.settings.lcm_diffusion_setting.use_openvino:
+ reshape = is_reshape_required(
+ previous_width,
+ image_width,
+ previous_height,
+ image_height,
+ previous_model_id,
+ model_id,
+ previous_num_of_images,
+ num_images,
+ )
+
+ with ThreadPoolExecutor(max_workers=1) as executor:
+ future = executor.submit(
+ context.generate_text_to_image,
+ app_settings.settings,
+ reshape,
+ DEVICE,
+ )
+ images = future.result()
+
+ previous_width = image_width
+ previous_height = image_height
+ previous_model_id = model_id
+ previous_num_of_images = num_images
+ return images
+
+
+def get_image_to_image_ui() -> None:
+ with gr.Blocks():
+ with gr.Row():
+ with gr.Column():
+ input_image = gr.Image(label="Init image", type="pil")
+ with gr.Row():
+ prompt = gr.Textbox(
+ show_label=False,
+ lines=3,
+ placeholder="A fantasy landscape",
+ container=False,
+ )
+
+ generate_btn = gr.Button(
+ "Generate",
+ elem_id="generate_button",
+ scale=0,
+ )
+ negative_prompt = gr.Textbox(
+ label="Negative prompt (Works in LCM-LoRA mode, set guidance > 1.0):",
+ lines=1,
+ placeholder="",
+ )
+ strength = gr.Slider(
+ 0.1,
+ 1,
+ value=app_settings.settings.lcm_diffusion_setting.strength,
+ step=0.01,
+ label="Strength",
+ )
+
+ input_params = [
+ prompt,
+ negative_prompt,
+ input_image,
+ strength,
+ ]
+
+ with gr.Column():
+ output = gr.Gallery(
+ label="Generated images",
+ show_label=True,
+ elem_id="gallery",
+ columns=2,
+ height=512,
+ )
+
+ generate_btn.click(
+ fn=generate_image_to_image,
+ inputs=input_params,
+ outputs=output,
+ )
diff --git a/src/frontend/webui/image_variations_ui.py b/src/frontend/webui/image_variations_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..215785601ffd12f3c7fd0ad3a3255503adf88c57
--- /dev/null
+++ b/src/frontend/webui/image_variations_ui.py
@@ -0,0 +1,106 @@
+from typing import Any
+import gradio as gr
+from backend.models.lcmdiffusion_setting import DiffusionTask
+from context import Context
+from models.interface_types import InterfaceType
+from frontend.utils import is_reshape_required
+from constants import DEVICE
+from state import get_settings, get_context
+from concurrent.futures import ThreadPoolExecutor
+
+app_settings = get_settings()
+
+
+previous_width = 0
+previous_height = 0
+previous_model_id = ""
+previous_num_of_images = 0
+
+
+def generate_image_variations(
+ init_image,
+ variation_strength,
+) -> Any:
+ context = get_context(InterfaceType.WEBUI)
+ global previous_height, previous_width, previous_model_id, previous_num_of_images, app_settings
+
+ app_settings.settings.lcm_diffusion_setting.init_image = init_image
+ app_settings.settings.lcm_diffusion_setting.strength = variation_strength
+ app_settings.settings.lcm_diffusion_setting.prompt = ""
+ app_settings.settings.lcm_diffusion_setting.negative_prompt = ""
+
+ app_settings.settings.lcm_diffusion_setting.diffusion_task = (
+ DiffusionTask.image_to_image.value
+ )
+ model_id = app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id
+ reshape = False
+ image_width = app_settings.settings.lcm_diffusion_setting.image_width
+ image_height = app_settings.settings.lcm_diffusion_setting.image_height
+ num_images = app_settings.settings.lcm_diffusion_setting.number_of_images
+ if app_settings.settings.lcm_diffusion_setting.use_openvino:
+ reshape = is_reshape_required(
+ previous_width,
+ image_width,
+ previous_height,
+ image_height,
+ previous_model_id,
+ model_id,
+ previous_num_of_images,
+ num_images,
+ )
+
+ with ThreadPoolExecutor(max_workers=1) as executor:
+ future = executor.submit(
+ context.generate_text_to_image,
+ app_settings.settings,
+ reshape,
+ DEVICE,
+ )
+ images = future.result()
+
+ previous_width = image_width
+ previous_height = image_height
+ previous_model_id = model_id
+ previous_num_of_images = num_images
+ return images
+
+
+def get_image_variations_ui() -> None:
+ with gr.Blocks():
+ with gr.Row():
+ with gr.Column():
+ input_image = gr.Image(label="Init image", type="pil")
+ with gr.Row():
+ generate_btn = gr.Button(
+ "Generate",
+ elem_id="generate_button",
+ scale=0,
+ )
+
+ variation_strength = gr.Slider(
+ 0.1,
+ 1,
+ value=0.4,
+ step=0.01,
+ label="Variations Strength",
+ )
+
+ input_params = [
+ input_image,
+ variation_strength,
+ ]
+
+ with gr.Column():
+ output = gr.Gallery(
+ label="Generated images",
+ show_label=True,
+ elem_id="gallery",
+ columns=2,
+ height=512,
+ )
+
+ generate_btn.click(
+ fn=generate_image_variations,
+ inputs=input_params,
+ outputs=output,
+ )
diff --git a/src/frontend/webui/lora_models_ui.py b/src/frontend/webui/lora_models_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c4b626d5aecdb23b5ce73e5584555f4f498abf2
--- /dev/null
+++ b/src/frontend/webui/lora_models_ui.py
@@ -0,0 +1,185 @@
+import gradio as gr
+from os import path
+from backend.lora import (
+ get_lora_models,
+ get_active_lora_weights,
+ update_lora_weights,
+ load_lora_weight,
+)
+from state import get_settings, get_context
+from frontend.utils import get_valid_lora_model
+from models.interface_types import InterfaceType
+from backend.models.lcmdiffusion_setting import LCMDiffusionSetting
+
+
+_MAX_LORA_WEIGHTS = 5
+
+_custom_lora_sliders = []
+_custom_lora_names = []
+_custom_lora_columns = []
+
+app_settings = get_settings()
+
+
+def on_click_update_weight(*lora_weights):
+ update_weights = []
+ active_weights = get_active_lora_weights()
+ if not len(active_weights):
+ gr.Warning("No active LoRAs, first you need to load LoRA model")
+ return
+ for idx, lora in enumerate(active_weights):
+ update_weights.append(
+ (
+ lora[0],
+ lora_weights[idx],
+ )
+ )
+ if len(update_weights) > 0:
+ update_lora_weights(
+ get_context(InterfaceType.WEBUI).lcm_text_to_image.pipeline,
+ app_settings.settings.lcm_diffusion_setting,
+ update_weights,
+ )
+
+
+def on_click_load_lora(lora_name, lora_weight):
+ if app_settings.settings.lcm_diffusion_setting.use_openvino:
+ gr.Warning("Currently LoRA is not supported in OpenVINO.")
+ return
+ lora_models_map = get_lora_models(
+ app_settings.settings.lcm_diffusion_setting.lora.models_dir
+ )
+
+ # Load a new LoRA
+ settings = app_settings.settings.lcm_diffusion_setting
+ settings.lora.fuse = False
+ settings.lora.enabled = False
+ settings.lora.path = lora_models_map[lora_name]
+ settings.lora.weight = lora_weight
+ if not path.exists(settings.lora.path):
+ gr.Warning("Invalid LoRA model path!")
+ return
+ pipeline = get_context(InterfaceType.WEBUI).lcm_text_to_image.pipeline
+ if not pipeline:
+ gr.Warning("Pipeline not initialized. Please generate an image first.")
+ return
+ settings.lora.enabled = True
+ load_lora_weight(
+ get_context(InterfaceType.WEBUI).lcm_text_to_image.pipeline,
+ settings,
+ )
+
+ # Update Gradio LoRA UI
+ global _MAX_LORA_WEIGHTS
+ values = []
+ labels = []
+ rows = []
+ active_weights = get_active_lora_weights()
+ for idx, lora in enumerate(active_weights):
+ labels.append(f"{lora[0]}: ")
+ values.append(lora[1])
+ rows.append(gr.Row.update(visible=True))
+ for i in range(len(active_weights), _MAX_LORA_WEIGHTS):
+ labels.append(f"Update weight")
+ values.append(0.0)
+ rows.append(gr.Row.update(visible=False))
+ return labels + values + rows
+
+
+def get_lora_models_ui() -> None:
+ with gr.Blocks() as ui:
+ gr.HTML(
+ "Download and place your LoRA model weights in lora_models folders and restart App"
+ )
+ with gr.Row():
+
+ with gr.Column():
+ with gr.Row():
+ lora_models_map = get_lora_models(
+ app_settings.settings.lcm_diffusion_setting.lora.models_dir
+ )
+ valid_model = get_valid_lora_model(
+ list(lora_models_map.values()),
+ app_settings.settings.lcm_diffusion_setting.lora.path,
+ app_settings.settings.lcm_diffusion_setting.lora.models_dir,
+ )
+ if valid_model != "":
+ valid_model_path = lora_models_map[valid_model]
+ app_settings.settings.lcm_diffusion_setting.lora.path = (
+ valid_model_path
+ )
+ else:
+ app_settings.settings.lcm_diffusion_setting.lora.path = ""
+
+ lora_model = gr.Dropdown(
+ lora_models_map.keys(),
+ label="LoRA model",
+ info="LoRA model weight to load (You can use Lora models from Civitai or Hugging Face .safetensors format)",
+ value=valid_model,
+ interactive=True,
+ )
+
+ lora_weight = gr.Slider(
+ 0.0,
+ 1.0,
+ value=app_settings.settings.lcm_diffusion_setting.lora.weight,
+ step=0.05,
+ label="Initial Lora weight",
+ interactive=True,
+ )
+ load_lora_btn = gr.Button(
+ "Load selected LoRA",
+ elem_id="load_lora_button",
+ scale=0,
+ )
+
+ with gr.Row():
+ gr.Markdown(
+ "## Loaded LoRA models",
+ show_label=False,
+ )
+ update_lora_weights_btn = gr.Button(
+ "Update LoRA weights",
+ elem_id="load_lora_button",
+ scale=0,
+ )
+
+ global _MAX_LORA_WEIGHTS
+ global _custom_lora_sliders
+ global _custom_lora_names
+ global _custom_lora_columns
+ for i in range(0, _MAX_LORA_WEIGHTS):
+ new_row = gr.Column(visible=False)
+ _custom_lora_columns.append(new_row)
+ with new_row:
+ lora_name = gr.Markdown(
+ "Lora Name",
+ show_label=True,
+ )
+ lora_slider = gr.Slider(
+ 0.0,
+ 1.0,
+ step=0.05,
+ label="LoRA weight",
+ interactive=True,
+ visible=True,
+ )
+
+ _custom_lora_names.append(lora_name)
+ _custom_lora_sliders.append(lora_slider)
+
+ load_lora_btn.click(
+ fn=on_click_load_lora,
+ inputs=[lora_model, lora_weight],
+ outputs=[
+ *_custom_lora_names,
+ *_custom_lora_sliders,
+ *_custom_lora_columns,
+ ],
+ )
+
+ update_lora_weights_btn.click(
+ fn=on_click_update_weight,
+ inputs=[*_custom_lora_sliders],
+ outputs=None,
+ )
diff --git a/src/frontend/webui/models_ui.py b/src/frontend/webui/models_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5e8e6ca69a67422dd74773934dbd01532627d50
--- /dev/null
+++ b/src/frontend/webui/models_ui.py
@@ -0,0 +1,85 @@
+from app_settings import AppSettings
+from typing import Any
+import gradio as gr
+from constants import LCM_DEFAULT_MODEL, LCM_DEFAULT_MODEL_OPENVINO
+from state import get_settings
+from frontend.utils import get_valid_model_id
+
+app_settings = get_settings()
+app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id = get_valid_model_id(
+ app_settings.openvino_lcm_models,
+ app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id,
+)
+
+
+def change_lcm_model_id(model_id):
+ app_settings.settings.lcm_diffusion_setting.lcm_model_id = model_id
+
+
+def change_lcm_lora_model_id(model_id):
+ app_settings.settings.lcm_diffusion_setting.lcm_lora.lcm_lora_id = model_id
+
+
+def change_lcm_lora_base_model_id(model_id):
+ app_settings.settings.lcm_diffusion_setting.lcm_lora.base_model_id = model_id
+
+
+def change_openvino_lcm_model_id(model_id):
+ app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id = model_id
+
+
+def get_models_ui() -> None:
+ with gr.Blocks():
+ with gr.Row():
+ lcm_model_id = gr.Dropdown(
+ app_settings.lcm_models,
+ label="LCM model",
+ info="Diffusers LCM model ID",
+ value=get_valid_model_id(
+ app_settings.lcm_models,
+ app_settings.settings.lcm_diffusion_setting.lcm_model_id,
+ LCM_DEFAULT_MODEL,
+ ),
+ interactive=True,
+ )
+ with gr.Row():
+ lcm_lora_model_id = gr.Dropdown(
+ app_settings.lcm_lora_models,
+ label="LCM LoRA model",
+ info="Diffusers LCM LoRA model ID",
+ value=get_valid_model_id(
+ app_settings.lcm_lora_models,
+ app_settings.settings.lcm_diffusion_setting.lcm_lora.lcm_lora_id,
+ ),
+ interactive=True,
+ )
+ lcm_lora_base_model_id = gr.Dropdown(
+ app_settings.stable_diffsuion_models,
+ label="LCM LoRA base model",
+ info="Diffusers LCM LoRA base model ID",
+ value=get_valid_model_id(
+ app_settings.stable_diffsuion_models,
+ app_settings.settings.lcm_diffusion_setting.lcm_lora.base_model_id,
+ ),
+ interactive=True,
+ )
+ with gr.Row():
+ lcm_openvino_model_id = gr.Dropdown(
+ app_settings.openvino_lcm_models,
+ label="LCM OpenVINO model",
+ info="OpenVINO LCM-LoRA fused model ID",
+ value=get_valid_model_id(
+ app_settings.openvino_lcm_models,
+ app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id,
+ ),
+ interactive=True,
+ )
+
+ lcm_model_id.change(change_lcm_model_id, lcm_model_id)
+ lcm_lora_model_id.change(change_lcm_lora_model_id, lcm_lora_model_id)
+ lcm_lora_base_model_id.change(
+ change_lcm_lora_base_model_id, lcm_lora_base_model_id
+ )
+ lcm_openvino_model_id.change(
+ change_openvino_lcm_model_id, lcm_openvino_model_id
+ )
diff --git a/src/frontend/webui/realtime_ui.py b/src/frontend/webui/realtime_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..cdceee8a8436c59755447f0e7d7252ff1c53e48f
--- /dev/null
+++ b/src/frontend/webui/realtime_ui.py
@@ -0,0 +1,146 @@
+import gradio as gr
+from backend.lcm_text_to_image import LCMTextToImage
+from backend.models.lcmdiffusion_setting import LCMLora, LCMDiffusionSetting
+from constants import DEVICE, LCM_DEFAULT_MODEL_OPENVINO
+from time import perf_counter
+import numpy as np
+from cv2 import imencode
+import base64
+from backend.device import get_device_name
+from constants import APP_VERSION
+from backend.device import is_openvino_device
+
+lcm_text_to_image = LCMTextToImage()
+lcm_lora = LCMLora(
+ base_model_id="Lykon/dreamshaper-8",
+ lcm_lora_id="latent-consistency/lcm-lora-sdv1-5",
+)
+
+
+# https://github.com/gradio-app/gradio/issues/2635#issuecomment-1423531319
+def encode_pil_to_base64_new(pil_image):
+ image_arr = np.asarray(pil_image)[:, :, ::-1]
+ _, byte_data = imencode(".png", image_arr)
+ base64_data = base64.b64encode(byte_data)
+ base64_string_opencv = base64_data.decode("utf-8")
+ return "data:image/png;base64," + base64_string_opencv
+
+
+# monkey patching encode pil
+gr.processing_utils.encode_pil_to_base64 = encode_pil_to_base64_new
+
+
+def predict(
+ prompt,
+ steps,
+ seed,
+):
+ lcm_diffusion_setting = LCMDiffusionSetting()
+ lcm_diffusion_setting.openvino_lcm_model_id = "rupeshs/sdxs-512-0.9-openvino"
+ lcm_diffusion_setting.prompt = prompt
+ lcm_diffusion_setting.guidance_scale = 1.0
+ lcm_diffusion_setting.inference_steps = steps
+ lcm_diffusion_setting.seed = seed
+ lcm_diffusion_setting.use_seed = True
+ lcm_diffusion_setting.image_width = 512
+ lcm_diffusion_setting.image_height = 512
+ lcm_diffusion_setting.use_openvino = True if is_openvino_device() else False
+ lcm_diffusion_setting.use_tiny_auto_encoder = True
+ lcm_text_to_image.init(
+ DEVICE,
+ lcm_diffusion_setting,
+ )
+ start = perf_counter()
+
+ images = lcm_text_to_image.generate(lcm_diffusion_setting)
+ latency = perf_counter() - start
+ print(f"Latency: {latency:.2f} seconds")
+ return images[0]
+
+
+css = """
+#container{
+ margin: 0 auto;
+ max-width: 40rem;
+}
+#intro{
+ max-width: 100%;
+ text-align: center;
+ margin: 0 auto;
+}
+#generate_button {
+ color: white;
+ border-color: #007bff;
+ background: #007bff;
+ width: 200px;
+ height: 50px;
+}
+footer {
+ visibility: hidden
+}
+"""
+
+
+def _get_footer_message() -> str:
+ version = f" {APP_VERSION} "
+ footer_msg = version + (
+ ' © 2023 - 2024 '
+ " Rupesh Sreeraman
"
+ )
+ return footer_msg
+
+
+with gr.Blocks(css=css) as demo:
+ with gr.Column(elem_id="container"):
+ use_openvino = "- OpenVINO" if is_openvino_device() else ""
+ gr.Markdown(
+ f"""# Realtime FastSD CPU {use_openvino}
+ **Device : {DEVICE} , {get_device_name()}**
+ """,
+ elem_id="intro",
+ )
+
+ with gr.Row():
+ with gr.Row():
+ prompt = gr.Textbox(
+ placeholder="Describe the image you'd like to see",
+ scale=5,
+ container=False,
+ )
+ generate_btn = gr.Button(
+ "Generate",
+ scale=1,
+ elem_id="generate_button",
+ )
+
+ image = gr.Image(type="filepath")
+
+ steps = gr.Slider(
+ label="Steps",
+ value=1,
+ minimum=1,
+ maximum=6,
+ step=1,
+ visible=False,
+ )
+ seed = gr.Slider(
+ randomize=True,
+ minimum=0,
+ maximum=999999999,
+ label="Seed",
+ step=1,
+ )
+ gr.HTML(_get_footer_message())
+
+ inputs = [prompt, steps, seed]
+ prompt.input(fn=predict, inputs=inputs, outputs=image, show_progress=False)
+ generate_btn.click(
+ fn=predict, inputs=inputs, outputs=image, show_progress=False
+ )
+ steps.change(fn=predict, inputs=inputs, outputs=image, show_progress=False)
+ seed.change(fn=predict, inputs=inputs, outputs=image, show_progress=False)
+
+
+def start_realtime_text_to_image(share=False):
+ demo.queue()
+ demo.launch(share=share)
diff --git a/src/frontend/webui/text_to_image_ui.py b/src/frontend/webui/text_to_image_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ec517dcff55cc3f40088ea21788fbe113dda0b0
--- /dev/null
+++ b/src/frontend/webui/text_to_image_ui.py
@@ -0,0 +1,100 @@
+import gradio as gr
+from typing import Any
+from backend.models.lcmdiffusion_setting import DiffusionTask
+from models.interface_types import InterfaceType
+from constants import DEVICE
+from state import get_settings, get_context
+from frontend.utils import is_reshape_required
+from concurrent.futures import ThreadPoolExecutor
+from pprint import pprint
+
+app_settings = get_settings()
+
+previous_width = 0
+previous_height = 0
+previous_model_id = ""
+previous_num_of_images = 0
+
+
+def generate_text_to_image(
+ prompt,
+ neg_prompt,
+) -> Any:
+ context = get_context(InterfaceType.WEBUI)
+ global previous_height, previous_width, previous_model_id, previous_num_of_images, app_settings
+ app_settings.settings.lcm_diffusion_setting.prompt = prompt
+ app_settings.settings.lcm_diffusion_setting.negative_prompt = neg_prompt
+ app_settings.settings.lcm_diffusion_setting.diffusion_task = (
+ DiffusionTask.text_to_image.value
+ )
+ model_id = app_settings.settings.lcm_diffusion_setting.openvino_lcm_model_id
+ reshape = False
+ image_width = app_settings.settings.lcm_diffusion_setting.image_width
+ image_height = app_settings.settings.lcm_diffusion_setting.image_height
+ num_images = app_settings.settings.lcm_diffusion_setting.number_of_images
+ if app_settings.settings.lcm_diffusion_setting.use_openvino:
+ reshape = is_reshape_required(
+ previous_width,
+ image_width,
+ previous_height,
+ image_height,
+ previous_model_id,
+ model_id,
+ previous_num_of_images,
+ num_images,
+ )
+
+ with ThreadPoolExecutor(max_workers=1) as executor:
+ future = executor.submit(
+ context.generate_text_to_image,
+ app_settings.settings,
+ reshape,
+ DEVICE,
+ )
+ images = future.result()
+
+ previous_width = image_width
+ previous_height = image_height
+ previous_model_id = model_id
+ previous_num_of_images = num_images
+ return images
+
+
+def get_text_to_image_ui() -> None:
+ with gr.Blocks():
+ with gr.Row():
+ with gr.Column():
+ with gr.Row():
+ prompt = gr.Textbox(
+ show_label=False,
+ lines=3,
+ placeholder="A fantasy landscape",
+ container=False,
+ )
+
+ generate_btn = gr.Button(
+ "Generate",
+ elem_id="generate_button",
+ scale=0,
+ )
+ negative_prompt = gr.Textbox(
+ label="Negative prompt (Works in LCM-LoRA mode, set guidance > 1.0) :",
+ lines=1,
+ placeholder="",
+ )
+
+ input_params = [prompt, negative_prompt]
+
+ with gr.Column():
+ output = gr.Gallery(
+ label="Generated images",
+ show_label=True,
+ elem_id="gallery",
+ columns=2,
+ height=512,
+ )
+ generate_btn.click(
+ fn=generate_text_to_image,
+ inputs=input_params,
+ outputs=output,
+ )
diff --git a/src/frontend/webui/ui.py b/src/frontend/webui/ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdbc133da4ed2c37187d5112082e062af75331dc
--- /dev/null
+++ b/src/frontend/webui/ui.py
@@ -0,0 +1,90 @@
+import gradio as gr
+from constants import APP_VERSION
+from frontend.webui.text_to_image_ui import get_text_to_image_ui
+from frontend.webui.image_to_image_ui import get_image_to_image_ui
+from frontend.webui.generation_settings_ui import get_generation_settings_ui
+from frontend.webui.models_ui import get_models_ui
+from frontend.webui.image_variations_ui import get_image_variations_ui
+from frontend.webui.upscaler_ui import get_upscaler_ui
+from frontend.webui.lora_models_ui import get_lora_models_ui
+from frontend.webui.controlnet_ui import get_controlnet_ui
+from paths import FastStableDiffusionPaths
+from state import get_settings
+
+app_settings = get_settings()
+
+
+def _get_footer_message() -> str:
+ version = f" {APP_VERSION} "
+ footer_msg = version + (
+ ' © 2023 - 2024 '
+ " Rupesh Sreeraman
"
+ )
+ return footer_msg
+
+
+def get_web_ui() -> gr.Blocks:
+ def change_mode(mode):
+ global app_settings
+ app_settings.settings.lcm_diffusion_setting.use_lcm_lora = False
+ app_settings.settings.lcm_diffusion_setting.use_openvino = False
+ if mode == "LCM-LoRA":
+ app_settings.settings.lcm_diffusion_setting.use_lcm_lora = True
+ elif mode == "LCM-OpenVINO":
+ app_settings.settings.lcm_diffusion_setting.use_openvino = True
+
+ # Prevent saved LoRA and ControlNet settings from being used by
+ # default; in WebUI mode, the user must explicitly enable those
+ if app_settings.settings.lcm_diffusion_setting.lora:
+ app_settings.settings.lcm_diffusion_setting.lora.enabled = False
+ if app_settings.settings.lcm_diffusion_setting.controlnet:
+ app_settings.settings.lcm_diffusion_setting.controlnet.enabled = False
+
+ with gr.Blocks(
+ css=FastStableDiffusionPaths.get_css_path(),
+ title="FastSD CPU",
+ ) as fastsd_web_ui:
+ gr.HTML("FastSD CPU
")
+ current_mode = "LCM"
+ if app_settings.settings.lcm_diffusion_setting.use_openvino:
+ current_mode = "LCM-OpenVINO"
+ elif app_settings.settings.lcm_diffusion_setting.use_lcm_lora:
+ current_mode = "LCM-LoRA"
+
+ mode = gr.Radio(
+ ["LCM", "LCM-LoRA", "LCM-OpenVINO"],
+ label="Mode",
+ info="Current working mode",
+ value=current_mode,
+ )
+ mode.change(change_mode, inputs=mode)
+
+ with gr.Tabs():
+ with gr.TabItem("Text to Image"):
+ get_text_to_image_ui()
+ with gr.TabItem("Image to Image"):
+ get_image_to_image_ui()
+ with gr.TabItem("Image Variations"):
+ get_image_variations_ui()
+ with gr.TabItem("Upscaler"):
+ get_upscaler_ui()
+ with gr.TabItem("Generation Settings"):
+ get_generation_settings_ui()
+ with gr.TabItem("Models"):
+ get_models_ui()
+ with gr.TabItem("Lora Models"):
+ get_lora_models_ui()
+ with gr.TabItem("ControlNet"):
+ get_controlnet_ui()
+
+ gr.HTML(_get_footer_message())
+
+ return fastsd_web_ui
+
+
+def start_webui(
+ share: bool = False,
+):
+ webui = get_web_ui()
+ webui.queue()
+ webui.launch(share=share)
diff --git a/src/frontend/webui/upscaler_ui.py b/src/frontend/webui/upscaler_ui.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c3f7fad8ab5d04399bc9a79e81a46223a71cdea
--- /dev/null
+++ b/src/frontend/webui/upscaler_ui.py
@@ -0,0 +1,84 @@
+from typing import Any
+import gradio as gr
+from models.interface_types import InterfaceType
+from state import get_settings, get_context
+from backend.upscale.upscaler import upscale_image
+from backend.models.upscale import UpscaleMode
+from paths import FastStableDiffusionPaths, join_paths
+from time import time
+
+app_settings = get_settings()
+
+
+previous_width = 0
+previous_height = 0
+previous_model_id = ""
+previous_num_of_images = 0
+
+
+def create_upscaled_image(
+ source_image,
+ upscale_mode,
+) -> Any:
+ context = get_context(InterfaceType.WEBUI)
+ scale_factor = 2
+ if upscale_mode == "SD":
+ mode = UpscaleMode.sd_upscale.value
+ elif upscale_mode == "AURA-SR":
+ mode = UpscaleMode.aura_sr.value
+ scale_factor = 4
+ else:
+ mode = UpscaleMode.normal.value
+
+ upscaled_filepath = FastStableDiffusionPaths.get_upscale_filepath(
+ None,
+ scale_factor,
+ app_settings.settings.generated_images.format,
+ )
+ image = upscale_image(
+ context=context,
+ src_image_path=source_image,
+ dst_image_path=upscaled_filepath,
+ upscale_mode=mode,
+ )
+ return image
+
+
+def get_upscaler_ui() -> None:
+ with gr.Blocks():
+ with gr.Row():
+ with gr.Column():
+ input_image = gr.Image(label="Image", type="filepath")
+ with gr.Row():
+ upscale_mode = gr.Radio(
+ ["EDSR", "SD", "AURA-SR"],
+ label="Upscale Mode (2x) | AURA-SR v2 (4x)",
+ info="Select upscale method, SD Upscale is experimental",
+ value="EDSR",
+ )
+
+ generate_btn = gr.Button(
+ "Upscale",
+ elem_id="generate_button",
+ scale=0,
+ )
+
+ input_params = [
+ input_image,
+ upscale_mode,
+ ]
+
+ with gr.Column():
+ output = gr.Gallery(
+ label="Generated images",
+ show_label=True,
+ elem_id="gallery",
+ columns=2,
+ height=512,
+ )
+
+ generate_btn.click(
+ fn=create_upscaled_image,
+ inputs=input_params,
+ outputs=output,
+ )
diff --git a/src/image_ops.py b/src/image_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..b60e911d37616bf29592b15fca9901f404a6e397
--- /dev/null
+++ b/src/image_ops.py
@@ -0,0 +1,15 @@
+from PIL import Image
+
+
+def resize_pil_image(
+ pil_image: Image,
+ image_width,
+ image_height,
+):
+ return pil_image.convert("RGB").resize(
+ (
+ image_width,
+ image_height,
+ ),
+ Image.Resampling.LANCZOS,
+ )
diff --git a/src/models/interface_types.py b/src/models/interface_types.py
new file mode 100644
index 0000000000000000000000000000000000000000..00f5c0a35fd3cc1f733edc2763e64781e2b7b6a9
--- /dev/null
+++ b/src/models/interface_types.py
@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class InterfaceType(Enum):
+ WEBUI = "Web User Interface"
+ GUI = "Graphical User Interface"
+ CLI = "Command Line Interface"
+ API_SERVER = "API Server"
diff --git a/src/models/settings.py b/src/models/settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..afa1650fb5dab9dcef5645ac4aaf184939e8ae49
--- /dev/null
+++ b/src/models/settings.py
@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+from backend.models.lcmdiffusion_setting import LCMDiffusionSetting, LCMLora
+from backend.models.gen_images import GeneratedImages
+
+
+class Settings(BaseModel):
+ lcm_diffusion_setting: LCMDiffusionSetting = LCMDiffusionSetting(lcm_lora=LCMLora())
+ generated_images: GeneratedImages = GeneratedImages()
diff --git a/src/paths.py b/src/paths.py
new file mode 100644
index 0000000000000000000000000000000000000000..2de41b2ef496b584965d15d6311cfba3519022ee
--- /dev/null
+++ b/src/paths.py
@@ -0,0 +1,98 @@
+import os
+import constants
+from pathlib import Path
+from time import time
+from utils import get_image_file_extension
+
+
+def join_paths(
+ first_path: str,
+ second_path: str,
+) -> str:
+ return os.path.join(first_path, second_path)
+
+
+def get_file_name(file_path: str) -> str:
+ return Path(file_path).stem
+
+
+def get_app_path() -> str:
+ app_dir = os.path.dirname(__file__)
+ work_dir = os.path.dirname(app_dir)
+ return work_dir
+
+
+def get_configs_path() -> str:
+ config_path = join_paths(get_app_path(), constants.CONFIG_DIRECTORY)
+ return config_path
+
+
+class FastStableDiffusionPaths:
+ @staticmethod
+ def get_app_settings_path() -> str:
+ configs_path = get_configs_path()
+ settings_path = join_paths(
+ configs_path,
+ constants.APP_SETTINGS_FILE,
+ )
+ return settings_path
+
+ @staticmethod
+ def get_results_path() -> str:
+ results_path = join_paths(get_app_path(), constants.RESULTS_DIRECTORY)
+ return results_path
+
+ @staticmethod
+ def get_css_path() -> str:
+ app_dir = os.path.dirname(__file__)
+ css_path = os.path.join(
+ app_dir,
+ "frontend",
+ "webui",
+ "css",
+ "style.css",
+ )
+ return css_path
+
+ @staticmethod
+ def get_models_config_path(model_config_file: str) -> str:
+ configs_path = get_configs_path()
+ models_path = join_paths(
+ configs_path,
+ model_config_file,
+ )
+ return models_path
+
+ @staticmethod
+ def get_upscale_filepath(
+ file_path_src: str,
+ scale_factor: int,
+ format: str,
+ ) -> str:
+ if file_path_src:
+ file_name_src = get_file_name(file_path_src)
+ else:
+ file_name_src = "fastsdcpu"
+
+ extension = get_image_file_extension(format)
+ upscaled_filepath = join_paths(
+ FastStableDiffusionPaths.get_results_path(),
+ f"{file_name_src}_{int(scale_factor)}x_upscale_{int(time())}{extension}",
+ )
+ return upscaled_filepath
+
+ @staticmethod
+ def get_lora_models_path() -> str:
+ lora_models_path = join_paths(get_app_path(), constants.LORA_DIRECTORY)
+ return lora_models_path
+
+ @staticmethod
+ def get_controlnet_models_path() -> str:
+ controlnet_models_path = join_paths(
+ get_app_path(), constants.CONTROLNET_DIRECTORY
+ )
+ return controlnet_models_path
+
+
+def get_base_folder_name(path: str) -> str:
+ return os.path.basename(path)
diff --git a/src/state.py b/src/state.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c0c4d5599c192840646f8d655cc16e4fbb8c6b2
--- /dev/null
+++ b/src/state.py
@@ -0,0 +1,32 @@
+from app_settings import AppSettings
+from typing import Optional
+
+from context import Context
+from models.interface_types import InterfaceType
+
+
+class _AppState:
+ _instance: Optional["_AppState"] = None
+ settings: Optional[AppSettings] = None
+ context: Optional[Context] = None
+
+
+def get_state() -> _AppState:
+ if _AppState._instance is None:
+ _AppState._instance = _AppState()
+ return _AppState._instance
+
+
+def get_settings(skip_file: bool = False) -> AppSettings:
+ state = get_state()
+ if state.settings is None:
+ state.settings = AppSettings()
+ state.settings.load(skip_file)
+ return state.settings
+
+
+def get_context(interface_type: InterfaceType) -> Context:
+ state = get_state()
+ if state.context is None:
+ state.context = Context(interface_type)
+ return state.context
diff --git a/src/utils.py b/src/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a83d3909d84808ac874e6314ea4d8fff2587921
--- /dev/null
+++ b/src/utils.py
@@ -0,0 +1,28 @@
+import platform
+from typing import List
+
+
+def show_system_info():
+ try:
+ print(f"Running on {platform.system()} platform")
+ print(f"OS: {platform.platform()}")
+ print(f"Processor: {platform.processor()}")
+ except Exception as ex:
+ print(f"Error occurred while getting system information {ex}")
+
+
+def get_models_from_text_file(file_path: str) -> List:
+ models = []
+ with open(file_path, "r") as file:
+ lines = file.readlines()
+ for repo_id in lines:
+ if repo_id.strip() != "":
+ models.append(repo_id.strip())
+ return models
+
+
+def get_image_file_extension(image_format: str) -> str:
+ if image_format == "JPEG":
+ return ".jpg"
+ elif image_format == "PNG":
+ return ".png"
diff --git a/start-realtime.bat b/start-realtime.bat
new file mode 100644
index 0000000000000000000000000000000000000000..060268beb597047e9ac2b08d9c6c3eaadf7d90a8
--- /dev/null
+++ b/start-realtime.bat
@@ -0,0 +1,25 @@
+@echo off
+setlocal
+echo Starting fastsdcpu...
+
+set "PYTHON_COMMAND=python"
+
+call python --version > nul 2>&1
+if %errorlevel% equ 0 (
+ echo Python command check :OK
+) else (
+ echo "Error: Python command not found, please install Python (Recommended : Python 3.10 or Python 3.11) and try again"
+ pause
+ exit /b 1
+
+)
+
+:check_python_version
+for /f "tokens=2" %%I in ('%PYTHON_COMMAND% --version 2^>^&1') do (
+ set "python_version=%%I"
+)
+
+echo Python version: %python_version%
+
+set PATH=%PATH%;%~dp0env\Lib\site-packages\openvino\libs
+call "%~dp0env\Scripts\activate.bat" && %PYTHON_COMMAND% "%~dp0\src\app.py" --r
\ No newline at end of file
diff --git a/start-webserver.bat b/start-webserver.bat
new file mode 100644
index 0000000000000000000000000000000000000000..2228ee0dcb06da315c94fba9deb7589a9725df51
--- /dev/null
+++ b/start-webserver.bat
@@ -0,0 +1,25 @@
+@echo off
+setlocal
+echo Starting fastsdcpu...
+
+set "PYTHON_COMMAND=python"
+
+call python --version > nul 2>&1
+if %errorlevel% equ 0 (
+ echo Python command check :OK
+) else (
+ echo "Error: Python command not found, please install Python (Recommended : Python 3.10 or Python 3.11) and try again"
+ pause
+ exit /b 1
+
+)
+
+:check_python_version
+for /f "tokens=2" %%I in ('%PYTHON_COMMAND% --version 2^>^&1') do (
+ set "python_version=%%I"
+)
+
+echo Python version: %python_version%
+
+set PATH=%PATH%;%~dp0env\Lib\site-packages\openvino\libs
+call "%~dp0env\Scripts\activate.bat" && %PYTHON_COMMAND% "%~dp0\src\app.py" --api
\ No newline at end of file
diff --git a/start-webserver.sh b/start-webserver.sh
new file mode 100644
index 0000000000000000000000000000000000000000..29b40572df75d26f0c9f7aafbe5862990b60fc24
--- /dev/null
+++ b/start-webserver.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+echo Starting FastSD CPU please wait...
+set -e
+PYTHON_COMMAND="python3"
+
+if ! command -v python3 &>/dev/null; then
+ if ! command -v python &>/dev/null; then
+ echo "Error: Python not found, please install python 3.8 or higher and try again"
+ exit 1
+ fi
+fi
+
+if command -v python &>/dev/null; then
+ PYTHON_COMMAND="python"
+fi
+
+echo "Found $PYTHON_COMMAND command"
+
+python_version=$($PYTHON_COMMAND --version 2>&1 | awk '{print $2}')
+echo "Python version : $python_version"
+
+BASEDIR=$(pwd)
+# shellcheck disable=SC1091
+source "$BASEDIR/env/bin/activate"
+$PYTHON_COMMAND src/app.py --api
\ No newline at end of file
diff --git a/start-webui.bat b/start-webui.bat
new file mode 100644
index 0000000000000000000000000000000000000000..7db54c43784924ab96e45a885c793ec408274110
--- /dev/null
+++ b/start-webui.bat
@@ -0,0 +1,25 @@
+@echo off
+setlocal
+echo Starting fastsdcpu...
+
+set "PYTHON_COMMAND=python"
+
+call python --version > nul 2>&1
+if %errorlevel% equ 0 (
+ echo Python command check :OK
+) else (
+ echo "Error: Python command not found, please install Python (Recommended : Python 3.10 or Python 3.11) and try again"
+ pause
+ exit /b 1
+
+)
+
+:check_python_version
+for /f "tokens=2" %%I in ('%PYTHON_COMMAND% --version 2^>^&1') do (
+ set "python_version=%%I"
+)
+
+echo Python version: %python_version%
+
+set PATH=%PATH%;%~dp0env\Lib\site-packages\openvino\libs
+call "%~dp0env\Scripts\activate.bat" && %PYTHON_COMMAND% "%~dp0\src\app.py" -w
\ No newline at end of file
diff --git a/start-webui.sh b/start-webui.sh
new file mode 100644
index 0000000000000000000000000000000000000000..758cdfd1f9da69b68dabfd1c013baa5ac82eafd3
--- /dev/null
+++ b/start-webui.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+echo Starting FastSD CPU please wait...
+set -e
+PYTHON_COMMAND="python3"
+
+if ! command -v python3 &>/dev/null; then
+ if ! command -v python &>/dev/null; then
+ echo "Error: Python not found, please install python 3.8 or higher and try again"
+ exit 1
+ fi
+fi
+
+if command -v python &>/dev/null; then
+ PYTHON_COMMAND="python"
+fi
+
+echo "Found $PYTHON_COMMAND command"
+
+python_version=$($PYTHON_COMMAND --version 2>&1 | awk '{print $2}')
+echo "Python version : $python_version"
+
+BASEDIR=$(pwd)
+# shellcheck disable=SC1091
+source "$BASEDIR/env/bin/activate"
+$PYTHON_COMMAND src/app.py -w
\ No newline at end of file
diff --git a/start.bat b/start.bat
new file mode 100644
index 0000000000000000000000000000000000000000..886f7c27c48b5d365ee2229b399b98fcb16ddb76
--- /dev/null
+++ b/start.bat
@@ -0,0 +1,25 @@
+@echo off
+setlocal
+echo Starting fastsdcpu...
+
+set "PYTHON_COMMAND=python"
+
+call python --version > nul 2>&1
+if %errorlevel% equ 0 (
+ echo Python command check :OK
+) else (
+ echo "Error: Python command not found, please install Python (Recommended : Python 3.10 or Python 3.11) and try again"
+ pause
+ exit /b 1
+
+)
+
+:check_python_version
+for /f "tokens=2" %%I in ('%PYTHON_COMMAND% --version 2^>^&1') do (
+ set "python_version=%%I"
+)
+
+echo Python version: %python_version%
+
+set PATH=%PATH%;%~dp0env\Lib\site-packages\openvino\libs
+call "%~dp0env\Scripts\activate.bat" && %PYTHON_COMMAND% "%~dp0\src\app.py" --gui
\ No newline at end of file
diff --git a/start.sh b/start.sh
new file mode 100644
index 0000000000000000000000000000000000000000..d35cbc7ec2474e096b32ea6d6a0c24343dc61f6b
--- /dev/null
+++ b/start.sh
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+echo Starting FastSD CPU please wait...
+set -e
+PYTHON_COMMAND="python3"
+
+if ! command -v python3 &>/dev/null; then
+ if ! command -v python &>/dev/null; then
+ echo "Error: Python not found, please install python 3.8 or higher and try again"
+ exit 1
+ fi
+fi
+
+if command -v python &>/dev/null; then
+ PYTHON_COMMAND="python"
+fi
+
+echo "Found $PYTHON_COMMAND command"
+
+python_version=$($PYTHON_COMMAND --version 2>&1 | awk '{print $2}')
+echo "Python version : $python_version"
+
+BASEDIR=$(pwd)
+# shellcheck disable=SC1091
+source "$BASEDIR/env/bin/activate"
+$PYTHON_COMMAND src/app.py --gui
\ No newline at end of file