1. AI技术聚合首页
  2. IT

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

社会演员多 • • IT • 阅读 21

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

目录

介绍

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 strong,
                                 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 strong,
                                 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;
            }
        }
    }
}

下载 

源码下载

版权声明：本文为博主作者：天天代码码天天原创文章，版权归属原作者，如果侵权，请联系我们删除！

原文链接：https://blog.csdn.net/lw112190/article/details/137017746

共计人评分，平均分

到目前为止还没有投票！成为第一位评论此文章。

赞 (0)
社会演员多的头像社会演员多普通用户
0
上一篇 2024年4月10日
下一篇 2024年4月10日

相关推荐