stable-diffusion.cpp 一个文件解决stable diffusion所有环境，不需要python，stable-diffusion.dll动态库C#调用Demo

stable-diffusion.cpp 一个文件解决stable-diffusion所有环境，不需要python，stable-diffusion.dll动态库C#调用Demo

介绍

效果

Text To Image

Image To Image

Upscale

项目

代码

Native.cs

SDHelper.cs

MainForm.cs

下载

介绍

stable-diffusion.cpp 地址：https://github.com/leejet/stable-diffusion.cpp

StableDiffusionSharp 地址：https://github.com/IntptrMax/StableDiffusionSharp

测试模型下载地址：https://huggingface.co/runwayml/stable-diffusion-v1-5

放大模型下载地址：https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.4/RealESRGAN_x4plus_anime_6B.pth

效果

Text To Image

Image To Image

Upscale

项目

代码

Native.cs

using System;
using System.Runtime.InteropServices;

namespace StableDiffusionSharp
{
using static StableDiffusionSharp.Structs;
using int32_t = Int32;
using int64_t = Int64;
using SdContext = IntPtr;
using SDImagePtr = IntPtr;
using UpscalerContext = IntPtr;

internal class Native
{
const string DllName = "stable-diffusion";

internal delegate void SdLogCallback(SdLogLevel level, [MarshalAs(UnmanagedType.LPStr)] string text, IntPtr data);
internal delegate void SdProgressCallback(int step, int steps, float time, IntPtr data);

[DllImport(DllName, EntryPoint = "new_sd_ctx", CallingConvention = CallingConvention.Cdecl)]
internal extern static SdContext new_sd_ctx(string model_path,
string vae_path,
string taesd_path,
string control_net_path_c_str,
string lora_model_dir,
string embed_dir_c_str,
string stacked_id_embed_dir_c_str,
bool vae_decode_only,
bool vae_tiling,
bool free_params_immediately,
int n_threads,
WeightType weightType,
RngType rng_type,
ScheduleType s,
bool keep_clip_on_cpu,
bool keep_control_net_cpu,
bool keep_vae_on_cpu);

[DllImport(DllName, EntryPoint = "txt2img", CallingConvention = CallingConvention.Cdecl)]
internal static extern SDImagePtr txt2img(SdContext sd_ctx,
string prompt,
string negative_prompt,
int clip_skip,
float cfg_scale,
int width,
int height,
SampleMethod sample_method,
int sample_steps,
int64_t seed,
int batch_count,
SDImagePtr control_cond,
float control_strength,
float style_strength,
bool normalize_input,
string input_id_images_path);

[DllImport(DllName, EntryPoint = "img2img", CallingConvention = CallingConvention.Cdecl)]
internal static extern SDImagePtr img2img(SdContext sd_ctx,
SDImage init_image,
string prompt_c_str,
string negative_prompt_c_str,
int clip_skip,
float cfg_scale,
int width,
int height,
SampleMethod sample_method,
int sample_steps,
float strength,
int64_t seed,
int batch_count);

[DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
internal static extern IntPtr preprocess_canny(IntPtr imgData,
int width,
int height,
float high_threshold,
float low_threshold,
float weak,
float h2,
bool inverse);

[DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
internal static extern UpscalerContext new_upscaler_ctx(string esrgan_path,
int n_threads,
WeightType wtype);

[DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
internal static extern int32_t get_num_physical_cores();

[DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
internal static extern void free_sd_ctx(SdContext sd_ctx);

[DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
internal static extern void free_upscaler_ctx(UpscalerContext upscaler_ctx);

[DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
internal static extern SDImage upscale(UpscalerContext upscaler_ctx, SDImage input_image, int upscale_factor);

[DllImport(DllName, EntryPoint = "sd_set_log_callback", CallingConvention = CallingConvention.Cdecl)]
internal static extern void sd_set_log_callback(SdLogCallback cb, IntPtr data);

[DllImport(DllName, EntryPoint = "sd_set_progress_callback", CallingConvention = CallingConvention.Cdecl)]
internal static extern void sd_set_progress_callback(SdProgressCallback cb, IntPtr data);

}
}

using System; using System.Runtime.InteropServices; namespace StableDiffusionSharp { using static StableDiffusionSharp.Structs; using int32_t = Int32; using int64_t = Int64; using SdContext = IntPtr; using SDImagePtr = IntPtr; using UpscalerContext = IntPtr; internal class Native { const string DllName = "stable-diffusion"; internal delegate void SdLogCallback(SdLogLevel level, [MarshalAs(UnmanagedType.LPStr)] string text, IntPtr data); internal delegate void SdProgressCallback(int step, int steps, float time, IntPtr data); [DllImport(DllName, EntryPoint = "new_sd_ctx", CallingConvention = CallingConvention.Cdecl)] internal extern static SdContext new_sd_ctx(string model_path, string vae_path, string taesd_path, string control_net_path_c_str, string lora_model_dir, string embed_dir_c_str, string stacked_id_embed_dir_c_str, bool vae_decode_only, bool vae_tiling, bool free_params_immediately, int n_threads, WeightType weightType, RngType rng_type, ScheduleType s, bool keep_clip_on_cpu, bool keep_control_net_cpu, bool keep_vae_on_cpu); [DllImport(DllName, EntryPoint = "txt2img", CallingConvention = CallingConvention.Cdecl)] internal static extern SDImagePtr txt2img(SdContext sd_ctx, string prompt, string negative_prompt, int clip_skip, float cfg_scale, int width, int height, SampleMethod sample_method, int sample_steps, int64_t seed, int batch_count, SDImagePtr control_cond, float control_strength, float style_strength, bool normalize_input, string input_id_images_path); [DllImport(DllName, EntryPoint = "img2img", CallingConvention = CallingConvention.Cdecl)] internal static extern SDImagePtr img2img(SdContext sd_ctx, SDImage init_image, string prompt_c_str, string negative_prompt_c_str, int clip_skip, float cfg_scale, int width, int height, SampleMethod sample_method, int sample_steps, float strength, int64_t seed, int batch_count); [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)] internal static extern IntPtr preprocess_canny(IntPtr imgData, int width, int height, float high_threshold, float low_threshold, float weak, float h2, bool inverse); [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)] internal static extern UpscalerContext new_upscaler_ctx(string esrgan_path, int n_threads, WeightType wtype); [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)] internal static extern int32_t get_num_physical_cores(); [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)] internal static extern void free_sd_ctx(SdContext sd_ctx); [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)] internal static extern void free_upscaler_ctx(UpscalerContext upscaler_ctx); [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)] internal static extern SDImage upscale(UpscalerContext upscaler_ctx, SDImage input_image, int upscale_factor); [DllImport(DllName, EntryPoint = "sd_set_log_callback", CallingConvention = CallingConvention.Cdecl)] internal static extern void sd_set_log_callback(SdLogCallback cb, IntPtr data); [DllImport(DllName, EntryPoint = "sd_set_progress_callback", CallingConvention = CallingConvention.Cdecl)] internal static extern void sd_set_progress_callback(SdProgressCallback cb, IntPtr data); } }

SDHelper.cs

using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;

namespace StableDiffusionSharp
{
using static StableDiffusionSharp.Structs;
using SdContext = IntPtr;
using SDImagePtr = IntPtr;
using UpscalerContext = IntPtr;

public class SDHelper
{
public bool IsInitialized => SdContext.Zero != sd_ctx;
public bool IsUpscalerInitialized => UpscalerContext.Zero != upscaler_ctx;

private SdContext sd_ctx = new SdContext();
private UpscalerContext upscaler_ctx = new UpscalerContext();

public static event EventHandler<StableDiffusionEventArgs.StableDiffusionLogEventArgs> Log;
public static event EventHandler<StableDiffusionEventArgs.StableDiffusionProgressEventArgs> Progress;
static readonly Native.SdLogCallback sd_Log_Cb;
static readonly Native.SdProgressCallback sd_Progress_Cb;

static SDHelper()
{
sd_Log_Cb = new Native.SdLogCallback(OnNativeLog);
Native.sd_set_log_callback(sd_Log_Cb, IntPtr.Zero);

sd_Progress_Cb = new Native.SdProgressCallback(OnProgressRunning);
Native.sd_set_progress_callback(sd_Progress_Cb, IntPtr.Zero);

}

public bool Initialize(ModelParams modelParams)
{
sd_ctx = Native.new_sd_ctx(modelParams.ModelPath,
modelParams.VaePath,
modelParams.TaesdPath,
modelParams.ControlnetPath,
modelParams.LoraModelDir,
modelParams.EmbeddingsPath,
modelParams.StackedIdEmbeddingsPath,
modelParams.VaeDecodeOnly,
modelParams.VaeTiling,
modelParams.FreeParamsImmediately,
modelParams.Threads,
modelParams.SdType,
modelParams.RngType,
modelParams.Schedule,
modelParams.KeepClipOnCpu,
modelParams.KeepControlNetOnCpu,
modelParams.KeepVaeOnCpu);
return SdContext.Zero != sd_ctx;
}

public bool InitializeUpscaler(UpscalerParams @params)
{
upscaler_ctx = Native.new_upscaler_ctx(@params.ESRGANPath, @params.Threads, @params.SdType);
return UpscalerContext.Zero != upscaler_ctx;
}

public void FreeSD()
{
if (SdContext.Zero != sd_ctx)
{
Native.free_sd_ctx(sd_ctx);
sd_ctx = SdContext.Zero;
}
}

public void FreeUpscaler()
{
if (UpscalerContext.Zero != upscaler_ctx)
{
Native.free_upscaler_ctx(upscaler_ctx);
upscaler_ctx = UpscalerContext.Zero;
}
}

public Bitmap[] TextToImage(TextToImageParams textToImageParams)
{
if (!IsInitialized) throw new ArgumentNullException("Model not loaded!");

SDImagePtr sd_Image_ptr = Native.txt2img(sd_ctx,
textToImageParams.Prompt,
textToImageParams.NegativePrompt,
textToImageParams.ClipSkip,
textToImageParams.CfgScale,
textToImageParams.Width,
textToImageParams.Height,
textToImageParams.SampleMethod,
textToImageParams.SampleSteps,
textToImageParams.Seed,
textToImageParams.BatchCount,
SDImagePtr.Zero,
textToImageParams.ControlStrength,
textToImageParams.StyleStrength,
textToImageParams.NormalizeInput,
textToImageParams.InputIdImagesPath);

Bitmap[] images = new Bitmap[textToImageParams.BatchCount];
for (int i = 0; i < textToImageParams.BatchCount; i++)
{
SDImage sd_image = Marshal.PtrToStructure<SDImage>(sd_Image_ptr + i * Marshal.SizeOf<SDImage>());
images[i] = GetBitmapFromSdImage(sd_image);
}
return images;
}

public Bitmap ImageToImage(ImageToImageParams imageToImageParams)
{
if (!IsInitialized) throw new ArgumentNullException("Model not loaded!");
SDImage input_sd_image = GetSDImageFromBitmap(imageToImageParams.InputImage);

SDImagePtr sdImgPtr = Native.img2img(sd_ctx,
input_sd_image,
imageToImageParams.Prompt,
imageToImageParams.NegativePrompt,
imageToImageParams.ClipSkip,
imageToImageParams.CfgScale,
imageToImageParams.Width,
imageToImageParams.Height,
imageToImageParams.SampleMethod,
imageToImageParams.SampleSteps,
imageToImageParams.Strength,
imageToImageParams.Seed,
imageToImageParams.BatchCount);
SDImage sdImg = Marshal.PtrToStructure<SDImage>(sdImgPtr);

return GetBitmapFromSdImage(sdImg);
}

public Bitmap UpscaleImage(Bitmap image, int upscaleFactor)
{
if (!IsUpscalerInitialized) throw new ArgumentNullException("Upscaler not loaded!");
SDImage inputSDImg = GetSDImageFromBitmap(image);
SDImage result = Native.upscale(upscaler_ctx, inputSDImg, upscaleFactor);
return GetBitmapFromSdImage(result);
}

private Bitmap GetBitmapFromSdImage(SDImage sd_Image)
{
int width = (int)sd_Image.Width;
int height = (int)sd_Image.Height;
int channel = (int)sd_Image.Channel;
byte[] bytes = new byte[width * height * channel];
Marshal.Copy(sd_Image.Data, bytes, 0, bytes.Length);
Bitmap bmp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
int stride = bmp.Width * channel;
byte[] des = new byte[bytes.Length];
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
des[stride * i + channel * j + 0] = bytes[stride * i + channel * j + 2];
des[stride * i + channel * j + 1] = bytes[stride * i + channel * j + 1];
des[stride * i + channel * j + 2] = bytes[stride * i + channel * j + 0];
}
}
BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, bmp.PixelFormat);
Marshal.Copy(des, 0, bitmapData.Scan0, bytes.Length);
bmp.UnlockBits(bitmapData);

return bmp;
}

private SDImage GetSDImageFromBitmap(Bitmap bmp)
{
int width = bmp.Width;
int height = bmp.Height;
int channel = Bitmap.GetPixelFormatSize(bmp.PixelFormat) / 8;
int stride = width * channel;
byte[] bytes = new byte[width * height * channel];
BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, bmp.PixelFormat);
Marshal.Copy(bitmapData.Scan0, bytes, 0, bytes.Length);
bmp.UnlockBits(bitmapData);

byte[] sdImageBytes = new byte[bytes.Length];
for (int i = 0; i < height; i++)
{
for (int j = 0; j < width; j++)
{
sdImageBytes[stride * i + j * 3 + 0] = bytes[stride * i + j * 3 + 2];
sdImageBytes[stride * i + j * 3 + 1] = bytes[stride * i + j * 3 + 1];
sdImageBytes[stride * i + j * 3 + 2] = bytes[stride * i + j * 3 + 0];
}
}

SDImage sd_Image = new SDImage
{
Width = (uint)width,
Height = (uint)height,
Channel = 3,
Data = Marshal.UnsafeAddrOfPinnedArrayElement(sdImageBytes, 0),
};

return sd_Image;
}

private static void OnNativeLog(SdLogLevel level, string text, IntPtr data)
{
Log?.Invoke(null, new StableDiffusionEventArgs.StableDiffusionLogEventArgs { Level = level, Text = text });
}

private static void OnProgressRunning(int step, int steps, float time, IntPtr data)
{
Progress?.Invoke(null, new StableDiffusionEventArgs.StableDiffusionProgressEventArgs { Step = step, Steps = steps, Time = time });
}

}
}

using System; using System.Drawing; using System.Drawing.Imaging; using System.Runtime.InteropServices; namespace StableDiffusionSharp { using static StableDiffusionSharp.Structs; using SdContext = IntPtr; using SDImagePtr = IntPtr; using UpscalerContext = IntPtr; public class SDHelper { public bool IsInitialized => SdContext.Zero != sd_ctx; public bool IsUpscalerInitialized => UpscalerContext.Zero != upscaler_ctx; private SdContext sd_ctx = new SdContext(); private UpscalerContext upscaler_ctx = new UpscalerContext(); public static event EventHandler<StableDiffusionEventArgs.StableDiffusionLogEventArgs> Log; public static event EventHandler<StableDiffusionEventArgs.StableDiffusionProgressEventArgs> Progress; static readonly Native.SdLogCallback sd_Log_Cb; static readonly Native.SdProgressCallback sd_Progress_Cb; static SDHelper() { sd_Log_Cb = new Native.SdLogCallback(OnNativeLog); Native.sd_set_log_callback(sd_Log_Cb, IntPtr.Zero); sd_Progress_Cb = new Native.SdProgressCallback(OnProgressRunning); Native.sd_set_progress_callback(sd_Progress_Cb, IntPtr.Zero); } public bool Initialize(ModelParams modelParams) { sd_ctx = Native.new_sd_ctx(modelParams.ModelPath, modelParams.VaePath, modelParams.TaesdPath, modelParams.ControlnetPath, modelParams.LoraModelDir, modelParams.EmbeddingsPath, modelParams.StackedIdEmbeddingsPath, modelParams.VaeDecodeOnly, modelParams.VaeTiling, modelParams.FreeParamsImmediately, modelParams.Threads, modelParams.SdType, modelParams.RngType, modelParams.Schedule, modelParams.KeepClipOnCpu, modelParams.KeepControlNetOnCpu, modelParams.KeepVaeOnCpu); return SdContext.Zero != sd_ctx; } public bool InitializeUpscaler(UpscalerParams @params) { upscaler_ctx = Native.new_upscaler_ctx(@params.ESRGANPath, @params.Threads, @params.SdType); return UpscalerContext.Zero != upscaler_ctx; } public void FreeSD() { if (SdContext.Zero != sd_ctx) { Native.free_sd_ctx(sd_ctx); sd_ctx = SdContext.Zero; } } public void FreeUpscaler() { if (UpscalerContext.Zero != upscaler_ctx) { Native.free_upscaler_ctx(upscaler_ctx); upscaler_ctx = UpscalerContext.Zero; } } public Bitmap[] TextToImage(TextToImageParams textToImageParams) { if (!IsInitialized) throw new ArgumentNullException("Model not loaded!"); SDImagePtr sd_Image_ptr = Native.txt2img(sd_ctx, textToImageParams.Prompt, textToImageParams.NegativePrompt, textToImageParams.ClipSkip, textToImageParams.CfgScale, textToImageParams.Width, textToImageParams.Height, textToImageParams.SampleMethod, textToImageParams.SampleSteps, textToImageParams.Seed, textToImageParams.BatchCount, SDImagePtr.Zero, textToImageParams.ControlStrength, textToImageParams.StyleStrength, textToImageParams.NormalizeInput, textToImageParams.InputIdImagesPath); Bitmap[] images = new Bitmap[textToImageParams.BatchCount]; for (int i = 0; i < textToImageParams.BatchCount; i++) { SDImage sd_image = Marshal.PtrToStructure<SDImage>(sd_Image_ptr + i * Marshal.SizeOf<SDImage>()); images[i] = GetBitmapFromSdImage(sd_image); } return images; } public Bitmap ImageToImage(ImageToImageParams imageToImageParams) { if (!IsInitialized) throw new ArgumentNullException("Model not loaded!"); SDImage input_sd_image = GetSDImageFromBitmap(imageToImageParams.InputImage); SDImagePtr sdImgPtr = Native.img2img(sd_ctx, input_sd_image, imageToImageParams.Prompt, imageToImageParams.NegativePrompt, imageToImageParams.ClipSkip, imageToImageParams.CfgScale, imageToImageParams.Width, imageToImageParams.Height, imageToImageParams.SampleMethod, imageToImageParams.SampleSteps, imageToImageParams.Strength, imageToImageParams.Seed, imageToImageParams.BatchCount); SDImage sdImg = Marshal.PtrToStructure<SDImage>(sdImgPtr); return GetBitmapFromSdImage(sdImg); } public Bitmap UpscaleImage(Bitmap image, int upscaleFactor) { if (!IsUpscalerInitialized) throw new ArgumentNullException("Upscaler not loaded!"); SDImage inputSDImg = GetSDImageFromBitmap(image); SDImage result = Native.upscale(upscaler_ctx, inputSDImg, upscaleFactor); return GetBitmapFromSdImage(result); } private Bitmap GetBitmapFromSdImage(SDImage sd_Image) { int width = (int)sd_Image.Width; int height = (int)sd_Image.Height; int channel = (int)sd_Image.Channel; byte[] bytes = new byte[width * height * channel]; Marshal.Copy(sd_Image.Data, bytes, 0, bytes.Length); Bitmap bmp = new Bitmap(width, height, PixelFormat.Format24bppRgb); int stride = bmp.Width * channel; byte[] des = new byte[bytes.Length]; for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { des[stride * i + channel * j + 0] = bytes[stride * i + channel * j + 2]; des[stride * i + channel * j + 1] = bytes[stride * i + channel * j + 1]; des[stride * i + channel * j + 2] = bytes[stride * i + channel * j + 0]; } } BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, bmp.PixelFormat); Marshal.Copy(des, 0, bitmapData.Scan0, bytes.Length); bmp.UnlockBits(bitmapData); return bmp; } private SDImage GetSDImageFromBitmap(Bitmap bmp) { int width = bmp.Width; int height = bmp.Height; int channel = Bitmap.GetPixelFormatSize(bmp.PixelFormat) / 8; int stride = width * channel; byte[] bytes = new byte[width * height * channel]; BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, bmp.PixelFormat); Marshal.Copy(bitmapData.Scan0, bytes, 0, bytes.Length); bmp.UnlockBits(bitmapData); byte[] sdImageBytes = new byte[bytes.Length]; for (int i = 0; i < height; i++) { for (int j = 0; j < width; j++) { sdImageBytes[stride * i + j * 3 + 0] = bytes[stride * i + j * 3 + 2]; sdImageBytes[stride * i + j * 3 + 1] = bytes[stride * i + j * 3 + 1]; sdImageBytes[stride * i + j * 3 + 2] = bytes[stride * i + j * 3 + 0]; } } SDImage sd_Image = new SDImage { Width = (uint)width, Height = (uint)height, Channel = 3, Data = Marshal.UnsafeAddrOfPinnedArrayElement(sdImageBytes, 0), }; return sd_Image; } private static void OnNativeLog(SdLogLevel level, string text, IntPtr data) { Log?.Invoke(null, new StableDiffusionEventArgs.StableDiffusionLogEventArgs { Level = level, Text = text }); } private static void OnProgressRunning(int step, int steps, float time, IntPtr data) { Progress?.Invoke(null, new StableDiffusionEventArgs.StableDiffusionProgressEventArgs { Step = step, Steps = steps, Time = time }); } } }

MainForm.cs

using StableDiffusionSharp; using System; using System.Diagnostics; using System.Drawing; using System.IO; using System.Threading.Tasks; using System.Windows.Forms; namespace StableDiffusionSharpGUI { public partial class MainForm : Form { private readonly SDHelper helper = new SDHelper(); public MainForm() { InitializeComponent(); } private void Button_LoadModel_Click(object sender, EventArgs e) { if (Button_LoadModel.Text == "Load Model") { if (!helper.IsInitialized) { string modelPath = TextBox_ModelPath.Text; string vaePath = TextBox_VaePath.Text; string loraModelDir = TextBox_LoraModelDir.Text; bool keepVaeOnCpu = CheckBox_CpuVae.Checked; bool vaeTiling = CheckBox_VaeTiling.Checked; if (!File.Exists(modelPath)) { Button_LoadModel.Enabled = true; MessageBox.Show("Cannot find the Model"); return; } Task.Run(() => { Button_LoadModel.Invoke((Action)delegate { Button_LoadModel.Enabled = false; TextBox_ModelPath.Enabled = false; TextBox_VaePath.Enabled = false; TextBox_LoraModelDir.Enabled = false; CheckBox_CpuVae.Enabled = false; CheckBox_VaeTiling.Enabled = false; Button_ScanLoraPath.Enabled = false; Button_ScanModelPath.Enabled = false; Button_ScanVaePath.Enabled = false; }); Structs.ModelParams modelParams = new Structs.ModelParams { ModelPath = modelPath, VaePath = vaePath, RngType = Structs.RngType.CUDA_RNG, KeepVaeOnCpu = keepVaeOnCpu, VaeTiling = vaeTiling, LoraModelDir = loraModelDir, }; bool result = helper.Initialize(modelParams); Debug.WriteLine(result ? "Model loaded" : "Model not loaded"); Button_LoadModel.Invoke((Action)delegate { Button_LoadModel.Text = "Unload Model"; Button_LoadModel.Enabled = true; }); }); } } else { helper.FreeSD(); Button_LoadModel.Text = "Load Model"; TextBox_ModelPath.Enabled = true; TextBox_VaePath.Enabled = true; TextBox_LoraModelDir.Enabled = true; CheckBox_CpuVae.Enabled = true; CheckBox_VaeTiling.Enabled = true; Button_ScanLoraPath.Enabled = true; Button_ScanModelPath.Enabled = true; Button_ScanVaePath.Enabled = true; } } private void Helper_Progress(object sender, StableDiffusionEventArgs.StableDiffusionProgressEventArgs e) { base.Invoke((Action)delegate { label11.Text = $"{e.Step}/{e.Steps}"; label14.Text = $"{e.IterationsPerSecond:f2} it/s"; ProgressBar_Progress.Value = (int)((e.Progress > 1 ? 1 : e.Progress) * 100); }); } private void Button_TextToImage_Click(object sender, EventArgs e) { if (!helper.IsInitialized) { MessageBox.Show("Please load Model first"); return; } Math.DivRem((int)NumericUpDown_Width.Value, 64, out int result1); Math.DivRem((int)NumericUpDown_Height.Value, 64, out int result2); if (result1 != 0 || result2 != 0) { MessageBox.Show("The width and height of the generated image must be a multiple of 64"); return; } Button_TextToImage.Enabled = false; Button_ImageToImage.Enabled = false; Structs.TextToImageParams textToImageParams = new Structs.TextToImageParams { Prompt = TextBox_Prompt.Text, NegativePrompt = TextBox_NegativePrompt.Text, SampleMethod = (Structs.SampleMethod)Enum.Parse(typeof(Structs.SampleMethod), ComboBox_SampleMethod.Text), Width = (int)NumericUpDown_Width.Value, Height = (int)NumericUpDown_Height.Value, NormalizeInput = true, ClipSkip = (int)NumericUpDown_ClipSkip.Value, CfgScale = (float)NumericUpDown_CFG.Value, SampleSteps = (int)NumericUpDown_SampleSteps.Value, Seed = (long)NumericUpDown_Seed.Value, }; Task.Run(() => { Stopwatch stopwatch = new Stopwatch(); stopwatch.Restart(); Bitmap[] outputImages = helper.TextToImage(textToImageParams); for (int i = 0; i < outputImages.Length; i++) { if (!Directory.Exists("output")) { Directory.CreateDirectory("output"); } if (!Directory.Exists("./output/txt2img")) { Directory.CreateDirectory("./output/txt2img"); } outputImages[i].Save($"./output/txt2img/{DateTime.Now:yyyyMMddHHmmss}-{i}.png"); } base.Invoke((Action)delegate { PictureBox_OutputImage.Image = outputImages[0]; Button_TextToImage.Enabled = true; Button_ImageToImage.Enabled = true; }); Debug.WriteLine($"Time to elapsed: {stopwatch.ElapsedMilliseconds} ms"); }); } private void MainForm_Load(object sender, EventArgs e) { SDHelper.Log += SDHelper_Log; SDHelper.Progress += Helper_Progress; ComboBox_SampleMethod.Items.AddRange(Enum.GetNames(typeof(Structs.SampleMethod))); ComboBox_SampleMethod.SelectedIndex = 0; PictureBox_InputImage.AllowDrop = true; PictureBox_UpscaleInput.AllowDrop = true; } private void SDHelper_Log(object sender, StableDiffusionEventArgs.StableDiffusionLogEventArgs e) { Console.WriteLine($"time:{DateTime.Now}, {e.Level}: {e.Text}"); if (e.Text.Contains("vae compute")) { base.Invoke((Action)delegate { label12.Text = "VAE Progress"; }); } else if (e.Text.Contains("generating image")) { base.Invoke((Action)delegate { label12.Text = "Generate Progress"; }); } } private void Button_ScanModelPath_Click(object sender, EventArgs e) { FileDialog fileDialog = new OpenFileDialog { Filter = "Safetensors Files (*.safetensors)|*.safetensors|CheckPoint Files (*.ckpt)|*.ckpt|GGUF Files (*.gguf)|*.gguf|All Files (*.*)|*.*" }; if (fileDialog.ShowDialog() == DialogResult.OK) { TextBox_ModelPath.Text = fileDialog.FileName; } } private void Button_ScanVaePath_Click(object sender, EventArgs e) { FileDialog fileDialog = new OpenFileDialog { Filter = "Safetensors Files (*.safetensors)|*.safetensors|CheckPoint Files (*.ckpt)|*.ckpt|GGUF Files (*.gguf)|*.gguf|All Files (*.*)|*.*" }; if (fileDialog.ShowDialog() == DialogResult.OK) { TextBox_VaePath.Text = fileDialog.FileName; } } private void Button_ScanLoraPath_Click(object sender, EventArgs e) { FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog(); if (folderBrowserDialog.ShowDialog() == DialogResult.OK) { TextBox_LoraModelDir.Text = folderBrowserDialog.SelectedPath; } } private void Button_ImageToImage_Click(object sender, EventArgs e) { if (!helper.IsInitialized) { MessageBox.Show("Please load a Model"); return; } if (null == PictureBox_InputImage.Image) { MessageBox.Show("Please select an Image"); return; } Bitmap inputBitmap = PictureBox_InputImage.Image.Clone() as Bitmap; Math.DivRem(inputBitmap.Width, 64, out int result1); Math.DivRem(inputBitmap.Height, 64, out int result2); if (result1 != 0 || result2 != 0) { MessageBox.Show("The width and height of the generated image must be a multiple of 64"); return; } Button_TextToImage.Enabled = false; Button_ImageToImage.Enabled = false; Structs.ImageToImageParams imageToImageParams = new Structs.ImageToImageParams { InputImage = inputBitmap, Prompt = TextBox_Prompt.Text, NegativePrompt = TextBox_NegativePrompt.Text, CfgScale = (float)NumericUpDown_CFG.Value, Width = inputBitmap.Width, Height = inputBitmap.Height, SampleMethod = (Structs.SampleMethod)Enum.Parse(typeof(Structs.SampleMethod), ComboBox_SampleMethod.Text), SampleSteps = (int)NumericUpDown_SampleSteps.Value, Strength = (float)NumericUpDown_ReDrawStrength.Value, Seed = (long)NumericUpDown_Seed.Value, ClipSkip = (int)NumericUpDown_ClipSkip.Value, }; Task.Run(() => { Bitmap outputImage = helper.ImageToImage(imageToImageParams); if (!Directory.Exists("output")) { Directory.CreateDirectory("output"); } if (!Directory.Exists("./output/img2img")) { Directory.CreateDirectory("./output/img2img"); } outputImage.Save($"./output/img2img/{DateTime.Now:yyyyMMddHHmmss}.png"); base.Invoke((Action)delegate { PictureBox_OutputImage.Image = outputImage; Button_TextToImage.Enabled = true; Button_ImageToImage.Enabled = true; Button_TextToImage.Enabled = true; }); }); } private void Form1_FormClosed(object sender, FormClosedEventArgs e) { helper.FreeSD(); helper.FreeUpscaler(); GC.Collect(); } private void Button_RandomSeed_Click(object sender, EventArgs e) { Random random = new Random(); int randomPositiveInteger = random.Next(1, int.MaxValue); NumericUpDown_Seed.Value = randomPositiveInteger; } private void PictureBox_InputImage_Click(object sender, EventArgs e) { OpenFileDialog openFileDialog = new OpenFileDialog { Filter = "Image Files (*.png, *.jpg, *.bmp)|*.png;*.jpg;*.bmp" }; if (openFileDialog.ShowDialog() == DialogResult.OK) { Bitmap bitmap = new Bitmap(openFileDialog.FileName); PictureBox_InputImage.Image = bitmap; } } private void PictureBox_InputImage_DragEnter(object sender, DragEventArgs e) { if (e.Data.GetDataPresent(DataFormats.FileDrop)) e.Effect = DragDropEffects.Link; else e.Effect = DragDropEffects.None; } private void PictureBox_InputImage_DragDrop(object sender, DragEventArgs e) { string fileName = ((Array)e.Data.GetData(DataFormats.FileDrop)).GetValue(0).ToString(); Bitmap bitmap = new Bitmap(fileName); PictureBox_InputImage.Image = bitmap; } private void Button_ScanUpscaleModelPath_Click(object sender, EventArgs e) { OpenFileDialog openFileDialog = new OpenFileDialog { Filter = "ESRGAN Files (*.pth)|*.pth" }; if (openFileDialog.ShowDialog() == DialogResult.OK) { TextBox_UpscaleModelPath.Text = openFileDialog.FileName; } } private void PictureBox_UpscaleInput_DragDrop(object sender, DragEventArgs e) { string fileName = ((Array)e.Data.GetData(DataFormats.FileDrop)).GetValue(0).ToString(); Bitmap bitmap = new Bitmap(fileName); PictureBox_UpscaleInput.Image = bitmap; } private void PictureBox_UpscaleInput_DragEnter(object sender, DragEventArgs e) { if (e.Data.GetDataPresent(DataFormats.FileDrop)) e.Effect = DragDropEffects.Link; else e.Effect = DragDropEffects.None; } private void Button_Upscale_Click(object sender, EventArgs e) { if (string.IsNullOrEmpty(TextBox_UpscaleModelPath.Text)) { MessageBox.Show("Please select a upscale Model"); return; } bool upscalerInited = helper.InitializeUpscaler(new Structs.UpscalerParams { ESRGANPath = TextBox_UpscaleModelPath.Text, }); if (!upscalerInited) { MessageBox.Show("There is an error in loading upscale Model"); return; } if (PictureBox_UpscaleInput.Image == null) { MessageBox.Show("Please select an Image"); return; } Bitmap upscaleInputImage = PictureBox_UpscaleInput.Image as Bitmap; Button_Upscale.Enabled = false; Task.Run(() => { try { Button_Upscale.Enabled = false; Bitmap bitmap = helper.UpscaleImage(PictureBox_UpscaleInput.Image as Bitmap, 4); helper.FreeUpscaler(); if (!Directory.Exists("output")) { Directory.CreateDirectory("output"); } if (!Directory.Exists("./output/upscale")) { Directory.CreateDirectory("./output/upscale"); } bitmap.Save($"./output/upscale/{DateTime.Now:yyyyMMddHHmmss}.png"); base.Invoke((Action)delegate { PictureBox_UpscaleOutput.Image = bitmap; }); } catch (Exception ex) { MessageBox.Show(ex.Message); } finally { base.Invoke((Action)delegate { Button_Upscale.Enabled = true; }); helper.FreeUpscaler(); } }); } private void PictureBox_UpscaleInput_Click(object sender, EventArgs e) { OpenFileDialog openFileDialog = new OpenFileDialog { Filter = "Image Files (*.png, *.jpg, *.bmp)|*.png;*.jpg;*.bmp" }; if (openFileDialog.ShowDialog() == DialogResult.OK) { Bitmap bitmap = new Bitmap(openFileDialog.FileName); PictureBox_UpscaleInput.Image = bitmap; } } } }