• 因为是直接将资料保存在记忆体中，并将记忆体的资讯传递给对方去存取，所以效率很高
  • 可以传递任何格式(包含图片)
  • 只能在同一台电脑上执行，想要在不同电脑上传输资料请使用Socket
  • 这边做一个简单的范例，透过OpenCV提供载入图片、显示图片、翻转图片与保存图片的功能

建立一个cv.py档

from multiprocessing import shared_memory # 使用Python的共享记忆体
import cv2 # pip install opencv-python
import numpy as np # pip install numpy

class ImageLoader:
def __init__(self):
# 因为Python有自己的记忆体管理机制，使得我们没办法像C++一样直接存取到它的记忆体资料(因为会自动回收记忆体空间内的资料导致后续出现非法存取的例外讯息)
# 所以我们需要使用Python的共享记忆体功能
# 共享记忆体需要我们手动建立与删除
self.share_memory = dict()

def CreateShareMemory(self, name, size):
# 手动建立共享记忆体
self.share_memory[name] = shared_memory.SharedMemory(create=True, size=size, name=name)

def ClearAllShareMemory(self):
# 手动删除所有共享记忆体
for key, value in self.share_memory.items():
value.close()
value.unlink()
self.share_memory.clear()

def ClearShareMemory(self, name):
# 删除指定的共享记忆体
if (name in self.share_memory.keys()):
self.share_memory[name].close()
self.share_memory[name].unlink()
del self.share_memory[name]

def Load(self, path:str, share_name:str) -> tuple:
image = cv2.imread(path) # 载入影像
height, width, channels = image.shape

share_frame = np.ndarray((height, width, channels), dtype=image.dtype, buffer=self.share_memory[share_name].buf) # 建立一个np.ndarray，并指定该array的位置为共享记忆体空间的位置
share_frame[:] = image[:] # 将载入的影像资料保存到共享记忆体空间中

return int(height), int(width), int(channels) # 将影像的参数回传

def Show(self, window_name:str, share_name:str, height:int, width:int, channel:int):
shape = (height, width, channel) # 影像的尺寸
image = np.ndarray(shape, dtype=np.uint8, buffer=self.share_memory[share_name].buf) # 建立一个np.ndarray，并指定该array的位置为共享记忆体空间的位置
cv2.imshow(window_name, image) # 显示影像

def Delay(self, delay):
cv2.waitKey(delay)

def CloseWindows(self):
cv2.destroyAllWindows()

def Flip(self, share_name_src:str, share_name_dst:str, direct:int, height:int, width:int, channel:int):
\'\'\'
direct=-1, Vertically and Horizontal flip
direct=0, Vertically flip
direct=1, Horizontal flip
\'\'\'
shape = (height, width, channel)
image_share = np.ndarray(shape, dtype=np.uint8, buffer=self.share_memory[share_name_src].buf) # 建立一个np.ndarray，并指定该array的位置为共享记忆体空间的位置

dst_share = np.ndarray(shape, dtype=np.uint8, buffer=self.share_memory[share_name_dst].buf) # 建立一个np.ndarray，并指定该array的位置为共享记忆体空间的位置
dst = cv2.flip(image_share, direct) # 翻转影像
dst_share[:] = dst[:] # 将翻转后的结果保存到共享记忆体中

def SaveImage(self, filename:str, share_name:str, height:int=0, width:int=0, channel:int=0):
origin_shape = (height, width, channel)
image = np.ndarray(origin_shape, dtype=np.uint8, buffer=self.share_memory[share_name].buf) # 建立一个np.ndarray，并指定该array的位置为共享记忆体空间的位置
cv2.imwrite(filename, image) # 保存图片

接下来就是C#端

  • 建立一个C#主控台应用程式专案，我命名为net，Framework是.NET 8.0
  • 工具 > NuGet套件管理员(N) > 管理方案的NuGet套件(N) > 搜寻「pythonnet」安装
  • 或者，去PythonNET的网站下载DLL后放到专案内
  • 我这边示范载入图片并显示原始与翻转后的图片，然后将翻转后的图片保存
  • 若要将图片从共享记忆体中取出，请参考更下面的程式码

    • using Python.Runtime;

    namespace net
    {
    internal class Program
    {
    static void Main(string[] args)
    {
    Console.WriteLine("Init Python");
    PythonInit();

    Console.WriteLine("Load Python Module");
    //module和class的类型必须是dyname不然编译器不给过
    dynamic py_module = Py.Import("cv"); //传入要载入的py档名称(不包含副档名)
    dynamic py_class = py_module.ImageLoader();
    string src_name = "src_" + Guid.NewGuid(); //使用UUID功能，避免共享记忆体空间的名字重复
    string dst_name = "dst_" + Guid.NewGuid(); //使用UUID功能，避免共享记忆体空间的名字重复

    using (Py.GIL()) //所有呼叫Python端的程式都需要放在using(Py.GIL()){}内
    {
    /*
    * 呼叫Python端的CreateShareMemory()方法，建立共享记忆体
    * 因为事先不知道图片多大，所以先预设给予一个很大的记忆体空间
    * 3840 * 2160 * 3 = 24,883,200 bits = 3,110,400 bytes = 3,037 KB = 2.966 MB
    */
    py_class.CreateShareMemory(src_name, 3840 * 2160 * 3);
    py_class.CreateShareMemory(dst_name, 3840 * 2160 * 3);

    PyObject result = py_class.Load(@"G:\\cat.jpg", src_name);
    int height = result[0].As<int>();
    int width = result[1].As<int>();
    int channels = result[2].As<int>();
    Console.WriteLine($"Height:{height}, Width:{width}, Channels:{channels}");

    py_class.Flip(src_name, dst_name, 1, height, width, channels); //翻转影像

    //显示图片
    py_class.Show("Origin", src_name, height, width, channels);
    py_class.Delay(1);
    py_class.Show("Flip", dst_name, height, width, channels);
    py_class.Delay(3000); //先让画面显示3000ms

    //保存图片
    py_class.SaveImage(@"G:\\cat_flip.jpg", dst_name, height, width, channels);

    py_class.CloseWindows(); //关闭所有显示的视窗

    py_class.ClearAllShareMemory(); //释放所有的共享记忆体空间
    }
    Console.WriteLine("Finish");
    }

    private static void PythonInit()
    {
    //因为我使用Anaconda来建立Python环境，所以这边要设定该环境的路径
    string pathToVirtualEnv = @"D:\\OtherApp\\anaconda3\\envs\\opencv"; //指定虚拟环境的位置

    //因为我的环境使用的是Python 3.12，可以在该虚拟环境资料夹下找到python312.dll这个档案
    Runtime.PythonDLL = Path.Combine(pathToVirtualEnv, "python312.dll");

    //指定python terminal路径，这个通常不需要修改
    PythonEngine.PythonHome = Path.Combine(pathToVirtualEnv, "python.exe");

    /*
    * 设定Python的环境参数，如果有多个环境参数要使用分号「;」区隔
    * 第一个「D:\\\\Project\\\\Python\\\\ToCSharp\\\\python」是我的cv.py档案位置
    * 「{pathToVirtualEnv}\\\\Lib\\\\site-packages;{pathToVirtualEnv}\\\\Lib;{pathToVirtualEnv}\\\\DLLs」这段要放在最后面，让程式可以获得虚拟环境中安装好的其他Library
    */
    PythonEngine.PythonPath = $"D:\\\\Project\\\\Python\\\\ToCSharp\\\\python;{pathToVirtualEnv}\\\\Lib\\\\site-packages;{pathToVirtualEnv}\\\\Lib;{pathToVirtualEnv}\\\\DLLs";

    // 执行Python初始化
    PythonEngine.Initialize();
    }
    }
    }

    将影像资料从Python端的共享记忆体读取出来并保存到SkiaSharp的SKImage中的程式码

    class MemoryConvert
    {
    /// <summary>
    /// 取得SKBitmap的H, W, C数值
    /// </summary>
    /// <param name="bitmap"></param>
    /// <returns></returns>
    public static int[] GetSKBitmapParams(SKBitmap bitmap)
    {
    int width = bitmap.Width;
    int height = bitmap.Height;
    int channel = 0;
    switch (bitmap.ColorType)
    {
    case SKColorType.Bgra8888:
    channel = 4;
    break;
    case SKColorType.Rgb888x:
    channel = 3;
    break;
    default:
    channel = 1;
    break;
    }
    return new int[] { height, width, channel };
    }

    /// <summary>
    /// 从指定的共享记忆体区读取资料并储存至SKBitmap中
    /// </summary>
    /// <param name="share_name">共享记忆体区名称</param>
    /// <param name="width">Bitmap图片宽度</param>
    /// <param name="height">Bitmap图片高度</param>
    /// <param name="channel">Bitmap图片通道数</param>
    /// <returns></returns>
    public static SKBitmap ShareMemory_To_SKBitmap(string share_name, int width, int height, int channel)
    {
    using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting(share_name))
    {
    using (MemoryMappedViewStream stream = mmf.CreateViewStream())
    {
    byte[] bytes = new byte[height * width * channel];
    stream.Read(bytes, 0, bytes.Length);

    SKColorType colorType;
    switch (channel)
    {
    case 4:
    colorType = SKColorType.Bgra8888;
    break;
    case 3:
    colorType = SKColorType.Rgb888x;
    break;
    default:
    colorType = SKColorType.Gray8;
    break;
    }

    SKBitmap bitmap = new SKBitmap(new SKImageInfo(width, height, colorType));
    IntPtr ptr = bitmap.GetPixels();
    Marshal.Copy(bytes, 0, ptr, bytes.Length);
    return bitmap;
    }
    }
    }

    /// <summary>
    /// 将SKBitmap图片资料写入到指定的共享记忆体中
    /// </summary>
    /// <param name="bitmap">图片Bitmap</param>
    /// <param name="share_name">共享记忆体区名称</param>
    public static void SKBitmap_To_ShareMemory(SKBitmap bitmap, string share_name)
    {
    var shape = GetSKBitmapParams(bitmap);

    byte[] bytes = new byte[shape[0] * shape[1] * shape[2]];
    IntPtr ptr = bitmap.GetPixels();
    Marshal.Copy(ptr, bytes, 0, bytes.Length);

    using (MemoryMappedFile mmf = MemoryMappedFile.OpenExisting(share_name))
    {
    using (MemoryMappedViewStream stream = mmf.CreateViewStream())
    {
    stream.Write(bytes, 0, bytes.Length);
    }
    }
    }