devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：正经夜光杯 | 2024-06-20 12:02:58

赞

踩

stable diffusion cpp

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 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);

    }
}

  1. using System;
  2. using System.Runtime.InteropServices;
  3.  
  4. namespace StableDiffusionSharp
  5. {
  6.     using static StableDiffusionSharp.Structs;
  7.     using int32_t = Int32;
  8.     using int64_t = Int64;
  9.     using SdContext = IntPtr;
  10.     using SDImagePtr = IntPtr;
  11.     using UpscalerContext = IntPtr;
  12.  
  13.     internal class Native
  14.     {
  15.         const string DllName = "stable-diffusion";
  16.  
  17.         internal delegate void SdLogCallback(SdLogLevel level, [MarshalAs(UnmanagedType.LPStr)] string text, IntPtr data);
  18.         internal delegate void SdProgressCallback(int step, int steps, float time, IntPtr data);
  19.  
  20.         [DllImport(DllName, EntryPoint = "new_sd_ctx", CallingConvention = CallingConvention.Cdecl)]
  21.         internal extern static SdContext new_sd_ctx(string model_path,
  22.                                                      string vae_path,
  23.                                                      string taesd_path,
  24.                                                      string control_net_path_c_str,
  25.                                                      string lora_model_dir,
  26.                                                      string embed_dir_c_str,
  27.                                                      string stacked_id_embed_dir_c_str,
  28.                                                      bool vae_decode_only,
  29.                                                      bool vae_tiling,
  30.                                                      bool free_params_immediately,
  31.                                                      int n_threads,
  32.                                                      WeightType weightType,
  33.                                                      RngType rng_type,
  34.                                                      ScheduleType s,
  35.                                                      bool keep_clip_on_cpu,
  36.                                                      bool keep_control_net_cpu,
  37.                                                      bool keep_vae_on_cpu);
  38.  
  39.  
  40.         [DllImport(DllName, EntryPoint = "txt2img", CallingConvention = CallingConvention.Cdecl)]
  41.         internal static extern SDImagePtr txt2img(SdContext sd_ctx,
  42.                            string prompt,
  43.                            string negative_prompt,
  44.                            int clip_skip,
  45.                            float cfg_scale,
  46.                            int width,
  47.                            int height,
  48.                            SampleMethod sample_method,
  49.                            int sample_steps,
  50.                            int64_t seed,
  51.                            int batch_count,
  52.                            SDImagePtr control_cond,
  53.                            float control_strength,
  54.                            float style_strength,
  55.                            bool normalize_input,
  56.                            string input_id_images_path);
  57.  
  58.         [DllImport(DllName, EntryPoint = "img2img", CallingConvention = CallingConvention.Cdecl)]
  59.         internal static extern SDImagePtr img2img(SdContext sd_ctx,
  60.                     SDImage init_image,
  61.                     string prompt_c_str,
  62.                     string negative_prompt_c_str,
  63.                     int clip_skip,
  64.                     float cfg_scale,
  65.                     int width,
  66.                     int height,
  67.                     SampleMethod sample_method,
  68.                     int sample_steps,
  69.                     float strength,
  70.                     int64_t seed,
  71.                     int batch_count);
  72.  
  73.         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
  74.         internal static extern IntPtr preprocess_canny(IntPtr imgData,
  75.                                  int width,
  76.                                  int height,
  77.                                  float high_threshold,
  78.                                  float low_threshold,
  79.                                  float weak,
  80.                                  float strong,
  81.                                  bool inverse);
  82.  
  83.         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
  84.         internal static extern UpscalerContext new_upscaler_ctx(string esrgan_path,
  85.                                         int n_threads,
  86.                                         WeightType wtype);
  87.  
  88.         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
  89.         internal static extern int32_t get_num_physical_cores();
  90.  
  91.         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
  92.         internal static extern void free_sd_ctx(SdContext sd_ctx);
  93.  
  94.         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
  95.         internal static extern void free_upscaler_ctx(UpscalerContext upscaler_ctx);
  96.  
  97.         [DllImport(DllName, CallingConvention = CallingConvention.Cdecl)]
  98.         internal static extern SDImage upscale(UpscalerContext upscaler_ctx, SDImage input_image, int upscale_factor);
  99.  
  100.         [DllImport(DllName, EntryPoint = "sd_set_log_callback", CallingConvention = CallingConvention.Cdecl)]
  101.         internal static extern void sd_set_log_callback(SdLogCallback cb, IntPtr data);
  102.  
  103.         [DllImport(DllName, EntryPoint = "sd_set_progress_callback", CallingConvention = CallingConvention.Cdecl)]
  104.         internal static extern void sd_set_progress_callback(SdProgressCallback cb, IntPtr data);
  105.  
  106.     }
  107. }

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 });
        }


    }
}

  1. using System;
  2. using System.Drawing;
  3. using System.Drawing.Imaging;
  4. using System.Runtime.InteropServices;
  5.  
  6. namespace StableDiffusionSharp
  7. {
  8.     using static StableDiffusionSharp.Structs;
  9.     using SdContext = IntPtr;
  10.     using SDImagePtr = IntPtr;
  11.     using UpscalerContext = IntPtr;
  12.  
  13.     public class SDHelper
  14.     {
  15.         public bool IsInitialized => SdContext.Zero != sd_ctx;
  16.         public bool IsUpscalerInitialized => UpscalerContext.Zero != upscaler_ctx;
  17.  
  18.         private SdContext sd_ctx = new SdContext();
  19.         private UpscalerContext upscaler_ctx = new UpscalerContext();
  20.  
  21.         public static event EventHandler<StableDiffusionEventArgs.StableDiffusionLogEventArgs> Log;
  22.         public static event EventHandler<StableDiffusionEventArgs.StableDiffusionProgressEventArgs> Progress;
  23.         static readonly Native.SdLogCallback sd_Log_Cb;
  24.         static readonly Native.SdProgressCallback sd_Progress_Cb;
  25.  
  26.         static SDHelper()
  27.         {
  28.             sd_Log_Cb = new Native.SdLogCallback(OnNativeLog);
  29.             Native.sd_set_log_callback(sd_Log_Cb, IntPtr.Zero);
  30.  
  31.             sd_Progress_Cb = new Native.SdProgressCallback(OnProgressRunning);
  32.             Native.sd_set_progress_callback(sd_Progress_Cb, IntPtr.Zero);
  33.  
  34.         }
  35.  
  36.         public bool Initialize(ModelParams modelParams)
  37.         {
  38.             sd_ctx = Native.new_sd_ctx(modelParams.ModelPath,
  39.                                         modelParams.VaePath,
  40.                                         modelParams.TaesdPath,
  41.                                         modelParams.ControlnetPath,
  42.                                         modelParams.LoraModelDir,
  43.                                         modelParams.EmbeddingsPath,
  44.                                         modelParams.StackedIdEmbeddingsPath,
  45.                                         modelParams.VaeDecodeOnly,
  46.                                         modelParams.VaeTiling,
  47.                                         modelParams.FreeParamsImmediately,
  48.                                         modelParams.Threads,
  49.                                         modelParams.SdType,
  50.                                         modelParams.RngType,
  51.                                         modelParams.Schedule,
  52.                                         modelParams.KeepClipOnCpu,
  53.                                         modelParams.KeepControlNetOnCpu,
  54.                                         modelParams.KeepVaeOnCpu);
  55.             return SdContext.Zero != sd_ctx;
  56.         }
  57.  
  58.         public bool InitializeUpscaler(UpscalerParams @params)
  59.         {
  60.             upscaler_ctx = Native.new_upscaler_ctx(@params.ESRGANPath, @params.Threads, @params.SdType);
  61.             return UpscalerContext.Zero != upscaler_ctx;
  62.         }
  63.  
  64.         public void FreeSD()
  65.         {
  66.             if (SdContext.Zero != sd_ctx)
  67.             {
  68.                 Native.free_sd_ctx(sd_ctx);
  69.                 sd_ctx = SdContext.Zero;
  70.             }
  71.         }
  72.  
  73.         public void FreeUpscaler()
  74.         {
  75.             if (UpscalerContext.Zero != upscaler_ctx)
  76.             {
  77.                 Native.free_upscaler_ctx(upscaler_ctx);
  78.                 upscaler_ctx = UpscalerContext.Zero;
  79.             }
  80.         }
  81.  
  82.         public Bitmap[] TextToImage(TextToImageParams textToImageParams)
  83.         {
  84.             if (!IsInitialized) throw new ArgumentNullException("Model not loaded!");
  85.  
  86.             SDImagePtr sd_Image_ptr = Native.txt2img(sd_ctx,
  87.                           textToImageParams.Prompt,
  88.                           textToImageParams.NegativePrompt,
  89.                           textToImageParams.ClipSkip,
  90.                           textToImageParams.CfgScale,
  91.                           textToImageParams.Width,
  92.                           textToImageParams.Height,
  93.                           textToImageParams.SampleMethod,
  94.                           textToImageParams.SampleSteps,
  95.                           textToImageParams.Seed,
  96.                           textToImageParams.BatchCount,
  97.                           SDImagePtr.Zero,
  98.                           textToImageParams.ControlStrength,
  99.                           textToImageParams.StyleStrength,
  100.                           textToImageParams.NormalizeInput,
  101.                           textToImageParams.InputIdImagesPath);
  102.  
  103.             Bitmap[] images = new Bitmap[textToImageParams.BatchCount];
  104.             for (int i = 0; i < textToImageParams.BatchCount; i++)
  105.             {
  106.                 SDImage sd_image = Marshal.PtrToStructure<SDImage>(sd_Image_ptr + i * Marshal.SizeOf<SDImage>());
  107.                 images[i] = GetBitmapFromSdImage(sd_image);
  108.             }
  109.             return images;
  110.         }
  111.  
  112.  
  113.         public Bitmap ImageToImage(ImageToImageParams imageToImageParams)
  114.         {
  115.             if (!IsInitialized) throw new ArgumentNullException("Model not loaded!");
  116.             SDImage input_sd_image = GetSDImageFromBitmap(imageToImageParams.InputImage);
  117.  
  118.             SDImagePtr sdImgPtr = Native.img2img(sd_ctx,
  119.                   input_sd_image,
  120.                   imageToImageParams.Prompt,
  121.                   imageToImageParams.NegativePrompt,
  122.                   imageToImageParams.ClipSkip,
  123.                   imageToImageParams.CfgScale,
  124.                   imageToImageParams.Width,
  125.                   imageToImageParams.Height,
  126.                   imageToImageParams.SampleMethod,
  127.                   imageToImageParams.SampleSteps,
  128.                   imageToImageParams.Strength,
  129.                   imageToImageParams.Seed,
  130.                   imageToImageParams.BatchCount);
  131.             SDImage sdImg = Marshal.PtrToStructure<SDImage>(sdImgPtr);
  132.  
  133.             return GetBitmapFromSdImage(sdImg);
  134.         }
  135.  
  136.         public Bitmap UpscaleImage(Bitmap image, int upscaleFactor)
  137.         {
  138.             if (!IsUpscalerInitialized) throw new ArgumentNullException("Upscaler not loaded!");
  139.             SDImage inputSDImg = GetSDImageFromBitmap(image);
  140.             SDImage result = Native.upscale(upscaler_ctx, inputSDImg, upscaleFactor);
  141.             return GetBitmapFromSdImage(result);
  142.         }
  143.  
  144.         private Bitmap GetBitmapFromSdImage(SDImage sd_Image)
  145.         {
  146.             int width = (int)sd_Image.Width;
  147.             int height = (int)sd_Image.Height;
  148.             int channel = (int)sd_Image.Channel;
  149.             byte[] bytes = new byte[width * height * channel];
  150.             Marshal.Copy(sd_Image.Data, bytes, 0, bytes.Length);
  151.             Bitmap bmp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
  152.             int stride = bmp.Width * channel;
  153.             byte[] des = new byte[bytes.Length];
  154.             for (int i = 0; i < height; i++)
  155.             {
  156.                 for (int j = 0; j < width; j++)
  157.                 {
  158.                     des[stride * i + channel * j + 0] = bytes[stride * i + channel * j + 2];
  159.                     des[stride * i + channel * j + 1] = bytes[stride * i + channel * j + 1];
  160.                     des[stride * i + channel * j + 2] = bytes[stride * i + channel * j + 0];
  161.                 }
  162.             }
  163.             BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, bmp.PixelFormat);
  164.             Marshal.Copy(des, 0, bitmapData.Scan0, bytes.Length);
  165.             bmp.UnlockBits(bitmapData);
  166.  
  167.             return bmp;
  168.         }
  169.  
  170.         private SDImage GetSDImageFromBitmap(Bitmap bmp)
  171.         {
  172.             int width = bmp.Width;
  173.             int height = bmp.Height;
  174.             int channel = Bitmap.GetPixelFormatSize(bmp.PixelFormat) / 8;
  175.             int stride = width * channel;
  176.             byte[] bytes = new byte[width * height * channel];
  177.             BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadOnly, bmp.PixelFormat);
  178.             Marshal.Copy(bitmapData.Scan0, bytes, 0, bytes.Length);
  179.             bmp.UnlockBits(bitmapData);
  180.  
  181.             byte[] sdImageBytes = new byte[bytes.Length];
  182.             for (int i = 0; i < height; i++)
  183.             {
  184.                 for (int j = 0; j < width; j++)
  185.                 {
  186.                     sdImageBytes[stride * i + j * 3 + 0] = bytes[stride * i + j * 3 + 2];
  187.                     sdImageBytes[stride * i + j * 3 + 1] = bytes[stride * i + j * 3 + 1];
  188.                     sdImageBytes[stride * i + j * 3 + 2] = bytes[stride * i + j * 3 + 0];
  189.                 }
  190.             }
  191.  
  192.             SDImage sd_Image = new SDImage
  193.             {
  194.                 Width = (uint)width,
  195.                 Height = (uint)height,
  196.                 Channel = 3,
  197.                 Data = Marshal.UnsafeAddrOfPinnedArrayElement(sdImageBytes, 0),
  198.             };
  199.  
  200.             return sd_Image;
  201.         }
  202.  
  203.         private static void OnNativeLog(SdLogLevel level, string text, IntPtr data)
  204.         {
  205.             Log?.Invoke(null, new StableDiffusionEventArgs.StableDiffusionLogEventArgs { Level = level, Text = text });
  206.         }
  207.  
  208.         private static void OnProgressRunning(int step, int steps, float time, IntPtr data)
  209.         {
  210.             Progress?.Invoke(null, new StableDiffusionEventArgs.StableDiffusionProgressEventArgs { Step = step, Steps = steps, Time = time });
  211.         }
  212.  
  213.  
  214.     }
  215. }

MainForm.cs

  1. using StableDiffusionSharp;
  2. using System;
  3. using System.Diagnostics;
  4. using System.Drawing;
  5. using System.IO;
  6. using System.Threading.Tasks;
  7. using System.Windows.Forms;
  8.  
  9. namespace StableDiffusionSharpGUI
  10. {
  11.     public partial class MainForm : Form
  12.     {
  13.         private readonly SDHelper helper = new SDHelper();
  14.         public MainForm()
  15.         {
  16.             InitializeComponent();
  17.         }
  18.  
  19.         private void Button_LoadModel_Click(object sender, EventArgs e)
  20.         {
  21.             if (Button_LoadModel.Text == "Load Model")
  22.             {
  23.                 if (!helper.IsInitialized)
  24.                 {
  25.                     string modelPath = TextBox_ModelPath.Text;
  26.                     string vaePath = TextBox_VaePath.Text;
  27.                     string loraModelDir = TextBox_LoraModelDir.Text;
  28.                     bool keepVaeOnCpu = CheckBox_CpuVae.Checked;
  29.                     bool vaeTiling = CheckBox_VaeTiling.Checked;
  30.                     if (!File.Exists(modelPath))
  31.                     {
  32.                         Button_LoadModel.Enabled = true;
  33.                         MessageBox.Show("Cannot find the Model");
  34.                         return;
  35.                     }
  36.                     Task.Run(() =>
  37.                     {
  38.                         Button_LoadModel.Invoke((Action)delegate
  39.                         {
  40.                             Button_LoadModel.Enabled = false;
  41.                             TextBox_ModelPath.Enabled = false;
  42.                             TextBox_VaePath.Enabled = false;
  43.                             TextBox_LoraModelDir.Enabled = false;
  44.                             CheckBox_CpuVae.Enabled = false;
  45.                             CheckBox_VaeTiling.Enabled = false;
  46.                             Button_ScanLoraPath.Enabled = false;
  47.                             Button_ScanModelPath.Enabled = false;
  48.                             Button_ScanVaePath.Enabled = false;
  49.                         });
  50.                         Structs.ModelParams modelParams = new Structs.ModelParams
  51.                         {
  52.                             ModelPath = modelPath,
  53.                             VaePath = vaePath,
  54.                             RngType = Structs.RngType.CUDA_RNG,
  55.                             KeepVaeOnCpu = keepVaeOnCpu,
  56.                             VaeTiling = vaeTiling,
  57.                             LoraModelDir = loraModelDir,
  58.                         };
  59.  
  60.                         bool result = helper.Initialize(modelParams);
  61.                         Debug.WriteLine(result ? "Model loaded" : "Model not loaded");
  62.                         Button_LoadModel.Invoke((Action)delegate
  63.                         {
  64.                             Button_LoadModel.Text = "Unload Model";
  65.                             Button_LoadModel.Enabled = true;
  66.                         });
  67.                     });
  68.  
  69.                 }
  70.             }
  71.             else
  72.             {
  73.                 helper.FreeSD();
  74.                 Button_LoadModel.Text = "Load Model";
  75.                 TextBox_ModelPath.Enabled = true;
  76.                 TextBox_VaePath.Enabled = true;
  77.                 TextBox_LoraModelDir.Enabled = true;
  78.                 CheckBox_CpuVae.Enabled = true;
  79.                 CheckBox_VaeTiling.Enabled = true;
  80.                 Button_ScanLoraPath.Enabled = true;
  81.                 Button_ScanModelPath.Enabled = true;
  82.                 Button_ScanVaePath.Enabled = true;
  83.             }
  84.         }
  85.  
  86.         private void Helper_Progress(object sender, StableDiffusionEventArgs.StableDiffusionProgressEventArgs e)
  87.         {
  88.             base.Invoke((Action)delegate
  89.               {
  90.                   label11.Text = $"{e.Step}/{e.Steps}";
  91.                   label14.Text = $"{e.IterationsPerSecond:f2} it/s";
  92.                   ProgressBar_Progress.Value = (int)((e.Progress > 1 ? 1 : e.Progress) * 100);
  93.               });
  94.         }
  95.  
  96.         private void Button_TextToImage_Click(object sender, EventArgs e)
  97.         {
  98.             if (!helper.IsInitialized)
  99.             {
  100.                 MessageBox.Show("Please load Model first");
  101.                 return;
  102.             }
  103.  
  104.             Math.DivRem((int)NumericUpDown_Width.Value, 64, out int result1);
  105.             Math.DivRem((int)NumericUpDown_Height.Value, 64, out int result2);
  106.             if (result1 != 0 || result2 != 0)
  107.             {
  108.                 MessageBox.Show("The width and height of the generated image must be a multiple of 64");
  109.                 return;
  110.             }
  111.  
  112.             Button_TextToImage.Enabled = false;
  113.             Button_ImageToImage.Enabled = false;
  114.  
  115.             Structs.TextToImageParams textToImageParams = new Structs.TextToImageParams
  116.             {
  117.                 Prompt = TextBox_Prompt.Text,
  118.                 NegativePrompt = TextBox_NegativePrompt.Text,
  119.                 SampleMethod = (Structs.SampleMethod)Enum.Parse(typeof(Structs.SampleMethod), ComboBox_SampleMethod.Text),
  120.                 Width = (int)NumericUpDown_Width.Value,
  121.                 Height = (int)NumericUpDown_Height.Value,
  122.                 NormalizeInput = true,
  123.                 ClipSkip = (int)NumericUpDown_ClipSkip.Value,
  124.                 CfgScale = (float)NumericUpDown_CFG.Value,
  125.                 SampleSteps = (int)NumericUpDown_SampleSteps.Value,
  126.                 Seed = (long)NumericUpDown_Seed.Value,
  127.             };
  128.             Task.Run(() =>
  129.             {
  130.                 Stopwatch stopwatch = new Stopwatch();
  131.                 stopwatch.Restart();
  132.                 Bitmap[] outputImages = helper.TextToImage(textToImageParams);
  133.                 for (int i = 0; i < outputImages.Length; i++)
  134.                 {
  135.                     if (!Directory.Exists("output"))
  136.                     {
  137.                         Directory.CreateDirectory("output");
  138.                     }
  139.                     if (!Directory.Exists("./output/txt2img"))
  140.                     {
  141.                         Directory.CreateDirectory("./output/txt2img");
  142.                     }
  143.                     outputImages[i].Save($"./output/txt2img/{DateTime.Now:yyyyMMddHHmmss}-{i}.png");
  144.                 }
  145.                 base.Invoke((Action)delegate
  146.                 {
  147.                     PictureBox_OutputImage.Image = outputImages[0];
  148.                     Button_TextToImage.Enabled = true;
  149.                     Button_ImageToImage.Enabled = true;
  150.                 });
  151.  
  152.  
  153.                 Debug.WriteLine($"Time to elapsed: {stopwatch.ElapsedMilliseconds} ms");
  154.             });
  155.         }
  156.  
  157.         private void MainForm_Load(object sender, EventArgs e)
  158.         {
  159.             SDHelper.Log += SDHelper_Log;
  160.             SDHelper.Progress += Helper_Progress;
  161.  
  162.             ComboBox_SampleMethod.Items.AddRange(Enum.GetNames(typeof(Structs.SampleMethod)));
  163.             ComboBox_SampleMethod.SelectedIndex = 0;
  164.  
  165.             PictureBox_InputImage.AllowDrop = true;
  166.             PictureBox_UpscaleInput.AllowDrop = true;
  167.  
  168.         }
  169.  
  170.         private void SDHelper_Log(object sender, StableDiffusionEventArgs.StableDiffusionLogEventArgs e)
  171.         {
  172.             Console.WriteLine($"time:{DateTime.Now},  {e.Level}: {e.Text}");
  173.             if (e.Text.Contains("vae compute"))
  174.             {
  175.                 base.Invoke((Action)delegate { label12.Text = "VAE Progress"; });
  176.             }
  177.             else if (e.Text.Contains("generating image"))
  178.             {
  179.                 base.Invoke((Action)delegate { label12.Text = "Generate Progress"; });
  180.             }
  181.         }
  182.  
  183.         private void Button_ScanModelPath_Click(object sender, EventArgs e)
  184.         {
  185.             FileDialog fileDialog = new OpenFileDialog
  186.             {
  187.                 Filter = "Safetensors Files (*.safetensors)|*.safetensors|CheckPoint Files (*.ckpt)|*.ckpt|GGUF Files (*.gguf)|*.gguf|All Files (*.*)|*.*"
  188.             };
  189.  
  190.             if (fileDialog.ShowDialog() == DialogResult.OK)
  191.             {
  192.                 TextBox_ModelPath.Text = fileDialog.FileName;
  193.             }
  194.         }
  195.  
  196.         private void Button_ScanVaePath_Click(object sender, EventArgs e)
  197.         {
  198.             FileDialog fileDialog = new OpenFileDialog
  199.             {
  200.                 Filter = "Safetensors Files (*.safetensors)|*.safetensors|CheckPoint Files (*.ckpt)|*.ckpt|GGUF Files (*.gguf)|*.gguf|All Files (*.*)|*.*"
  201.             };
  202.             if (fileDialog.ShowDialog() == DialogResult.OK)
  203.             {
  204.                 TextBox_VaePath.Text = fileDialog.FileName;
  205.             }
  206.         }
  207.  
  208.         private void Button_ScanLoraPath_Click(object sender, EventArgs e)
  209.         {
  210.             FolderBrowserDialog folderBrowserDialog = new FolderBrowserDialog();
  211.             if (folderBrowserDialog.ShowDialog() == DialogResult.OK)
  212.             {
  213.                 TextBox_LoraModelDir.Text = folderBrowserDialog.SelectedPath;
  214.             }
  215.         }
  216.  
  217.         private void Button_ImageToImage_Click(object sender, EventArgs e)
  218.         {
  219.             if (!helper.IsInitialized)
  220.             {
  221.                 MessageBox.Show("Please load a Model");
  222.                 return;
  223.             }
  224.  
  225.             if (null == PictureBox_InputImage.Image)
  226.             {
  227.                 MessageBox.Show("Please select an Image");
  228.                 return;
  229.             }
  230.             Bitmap inputBitmap = PictureBox_InputImage.Image.Clone() as Bitmap;
  231.             Math.DivRem(inputBitmap.Width, 64, out int result1);
  232.             Math.DivRem(inputBitmap.Height, 64, out int result2);
  233.             if (result1 != 0 || result2 != 0)
  234.             {
  235.                 MessageBox.Show("The width and height of the generated image must be a multiple of 64");
  236.                 return;
  237.             }
  238.             Button_TextToImage.Enabled = false;
  239.             Button_ImageToImage.Enabled = false;
  240.             Structs.ImageToImageParams imageToImageParams = new Structs.ImageToImageParams
  241.             {
  242.                 InputImage = inputBitmap,
  243.                 Prompt = TextBox_Prompt.Text,
  244.                 NegativePrompt = TextBox_NegativePrompt.Text,
  245.                 CfgScale = (float)NumericUpDown_CFG.Value,
  246.                 Width = inputBitmap.Width,
  247.                 Height = inputBitmap.Height,
  248.                 SampleMethod = (Structs.SampleMethod)Enum.Parse(typeof(Structs.SampleMethod), ComboBox_SampleMethod.Text),
  249.                 SampleSteps = (int)NumericUpDown_SampleSteps.Value,
  250.                 Strength = (float)NumericUpDown_ReDrawStrength.Value,
  251.                 Seed = (long)NumericUpDown_Seed.Value,
  252.                 ClipSkip = (int)NumericUpDown_ClipSkip.Value,
  253.             };
  254.             Task.Run(() =>
  255.             {
  256.                 Bitmap outputImage = helper.ImageToImage(imageToImageParams);
  257.  
  258.                 if (!Directory.Exists("output"))
  259.                 {
  260.                     Directory.CreateDirectory("output");
  261.                 }
  262.                 if (!Directory.Exists("./output/img2img"))
  263.                 {
  264.                     Directory.CreateDirectory("./output/img2img");
  265.                 }
  266.                 outputImage.Save($"./output/img2img/{DateTime.Now:yyyyMMddHHmmss}.png");
  267.  
  268.                 base.Invoke((Action)delegate
  269.                 {
  270.                     PictureBox_OutputImage.Image = outputImage;
  271.                     Button_TextToImage.Enabled = true;
  272.                     Button_ImageToImage.Enabled = true;
  273.                     Button_TextToImage.Enabled = true;
  274.                 });
  275.             });
  276.  
  277.         }
  278.  
  279.         private void Form1_FormClosed(object sender, FormClosedEventArgs e)
  280.         {
  281.             helper.FreeSD();
  282.             helper.FreeUpscaler();
  283.             GC.Collect();
  284.         }
  285.  
  286.         private void Button_RandomSeed_Click(object sender, EventArgs e)
  287.         {
  288.             Random random = new Random();
  289.             int randomPositiveInteger = random.Next(1, int.MaxValue);
  290.             NumericUpDown_Seed.Value = randomPositiveInteger;
  291.         }
  292.  
  293.         private void PictureBox_InputImage_Click(object sender, EventArgs e)
  294.         {
  295.             OpenFileDialog openFileDialog = new OpenFileDialog
  296.             {
  297.                 Filter = "Image Files (*.png, *.jpg, *.bmp)|*.png;*.jpg;*.bmp"
  298.             };
  299.             if (openFileDialog.ShowDialog() == DialogResult.OK)
  300.             {
  301.                 Bitmap bitmap = new Bitmap(openFileDialog.FileName);
  302.                 PictureBox_InputImage.Image = bitmap;
  303.             }
  304.         }
  305.  
  306.         private void PictureBox_InputImage_DragEnter(object sender, DragEventArgs e)
  307.         {
  308.             if (e.Data.GetDataPresent(DataFormats.FileDrop))
  309.                 e.Effect = DragDropEffects.Link;
  310.             else e.Effect = DragDropEffects.None;
  311.         }
  312.  
  313.         private void PictureBox_InputImage_DragDrop(object sender, DragEventArgs e)
  314.         {
  315.             string fileName = ((Array)e.Data.GetData(DataFormats.FileDrop)).GetValue(0).ToString();
  316.             Bitmap bitmap = new Bitmap(fileName);
  317.             PictureBox_InputImage.Image = bitmap;
  318.         }
  319.  
  320.         private void Button_ScanUpscaleModelPath_Click(object sender, EventArgs e)
  321.         {
  322.             OpenFileDialog openFileDialog = new OpenFileDialog
  323.             {
  324.                 Filter = "ESRGAN Files (*.pth)|*.pth"
  325.             };
  326.             if (openFileDialog.ShowDialog() == DialogResult.OK)
  327.             {
  328.                 TextBox_UpscaleModelPath.Text = openFileDialog.FileName;
  329.             }
  330.         }
  331.  
  332.         private void PictureBox_UpscaleInput_DragDrop(object sender, DragEventArgs e)
  333.         {
  334.             string fileName = ((Array)e.Data.GetData(DataFormats.FileDrop)).GetValue(0).ToString();
  335.             Bitmap bitmap = new Bitmap(fileName);
  336.             PictureBox_UpscaleInput.Image = bitmap;
  337.         }
  338.  
  339.         private void PictureBox_UpscaleInput_DragEnter(object sender, DragEventArgs e)
  340.         {
  341.             if (e.Data.GetDataPresent(DataFormats.FileDrop))
  342.                 e.Effect = DragDropEffects.Link;
  343.             else e.Effect = DragDropEffects.None;
  344.         }
  345.  
  346.         private void Button_Upscale_Click(object sender, EventArgs e)
  347.         {
  348.  
  349.             if (string.IsNullOrEmpty(TextBox_UpscaleModelPath.Text))
  350.             {
  351.                 MessageBox.Show("Please select a upscale Model");
  352.                 return;
  353.             }
  354.             bool upscalerInited = helper.InitializeUpscaler(new Structs.UpscalerParams
  355.             {
  356.                 ESRGANPath = TextBox_UpscaleModelPath.Text,
  357.  
  358.             });
  359.             if (!upscalerInited)
  360.             {
  361.                 MessageBox.Show("There is an error in loading upscale Model");
  362.                 return;
  363.             }
  364.             if (PictureBox_UpscaleInput.Image == null)
  365.             {
  366.                 MessageBox.Show("Please select an Image");
  367.                 return;
  368.             }
  369.             Bitmap upscaleInputImage = PictureBox_UpscaleInput.Image as Bitmap;
  370.             Button_Upscale.Enabled = false;
  371.             Task.Run(() =>
  372.             {
  373.                 try
  374.                 {
  375.                     Button_Upscale.Enabled = false;
  376.                     Bitmap bitmap = helper.UpscaleImage(PictureBox_UpscaleInput.Image as Bitmap, 4);
  377.                     helper.FreeUpscaler();
  378.                     if (!Directory.Exists("output"))
  379.                     {
  380.                         Directory.CreateDirectory("output");
  381.                     }
  382.                     if (!Directory.Exists("./output/upscale"))
  383.                     {
  384.                         Directory.CreateDirectory("./output/upscale");
  385.                     }
  386.                     bitmap.Save($"./output/upscale/{DateTime.Now:yyyyMMddHHmmss}.png");
  387.                     base.Invoke((Action)delegate { PictureBox_UpscaleOutput.Image = bitmap; });
  388.                 }
  389.                 catch (Exception ex)
  390.                 {
  391.                     MessageBox.Show(ex.Message);
  392.                 }
  393.                 finally
  394.                 {
  395.                     base.Invoke((Action)delegate { Button_Upscale.Enabled = true; });
  396.  
  397.                     helper.FreeUpscaler();
  398.                 }
  399.  
  400.             });
  401.  
  402.  
  403.         }
  404.  
  405.         private void PictureBox_UpscaleInput_Click(object sender, EventArgs e)
  406.         {
  407.             OpenFileDialog openFileDialog = new OpenFileDialog
  408.             {
  409.                 Filter = "Image Files (*.png, *.jpg, *.bmp)|*.png;*.jpg;*.bmp"
  410.             };
  411.             if (openFileDialog.ShowDialog() == DialogResult.OK)
  412.             {
  413.                 Bitmap bitmap = new Bitmap(openFileDialog.FileName);
  414.                 PictureBox_UpscaleInput.Image = bitmap;
  415.             }
  416.         }
  417.     }
  418. }

下载 

源码下载

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/739779
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号