使用Memory Copy的方式，在虚幻引擎中将数据从Python传输给c++

void UChameleonData::SetImageData(FName AkaName, const TArray<uint8>& RawDataIn, int32 Width, int32 Height, int32 ChannelNum, bool bBGR)

im = cv2.imread(image_path) # cv2.imread will return a bgr order numpy array
...
self.data.set_image_data(self.ui_image_name, im.tobytes(), width, height, channel, bgr=True)

@timeit
def set_image_with_uint8_compressed(self):
    compressor = zlib.compressobj(level=1)  # 最低的压缩率，也是最少的压缩耗时，默认可用zlib.compress()
    compressed_data = compressor.compress(self.im_bytes) + compressor.flush()
    print(f"compression ratio: {len(compressed_data) / len(self.im_bytes) * 100:.2f}%")
    self.data.set_image_data(self.ui_image_name, compressed_data, self.w, self.h, self.channel, True)

UFUNCTION(BlueprintCallable, Category = Scripting)
void SetImageDataBase64(FName AkaName, const FString& Base64String, int32 Width, int32 Height, int32 ChannelNum = 4, bool bBGR = true);

def set_image_with_base64(self):
    self.im_base_64_str = base64.b64encode(self.im_bytes).decode('ascii')
    self.data.set_image_data_base64(self.ui_image_name, self.im_base64_str, self.w, self.h, self.channel, True)

    UFUNCTION(BlueprintCallable, Category = Scripting)
    static void BigStr(const FString& Base64String) {};

unreal.MyBPLib.big_str('a' * 1024 * 1024 * 50)

@timeit
def on_memory_click(self):
    im = self.im
    # im = np.ascontiguousarray(im, dtype=np.uint8)
    size = self.w * self.h * self.channel
    self.data.set_image_data_from_memory(self.ui_image_name, im.ctypes.data, size, self.w, self.h, self.channel, True)

void UChameleonData::SetImageDataFromMemory(FName AkaName, const int64& Address, const int64& Length, int32 Width, int32 Height, int32 ChannelNum, bool bBGR /*true*/) {
    const int64 ExpectedLength = Width * Height * ChannelNum;
    if (Length != ExpectedLength) {
        UE_LOG(PythonTA, Error, TEXT("SetImageDataFromMemory failed, data length: %d != %d * %d * %d, which should be: %d @ %s"),
            Length, Width, Height, ChannelNum, ExpectedLength, *AkaName.ToString());
        return;
    }
    uintptr_t Addr = static_cast<uintptr_t>(Address);

    TArray<uint8> Data;
    if (Length > 0) {
        char* SourceAddr = reinterpret_cast<char*>(Addr);
        if (SourceAddr) {
            Data.SetNumUninitialized(Length);
            FMemory::Memcpy(Data.GetData(), reinterpret_cast<uint8*>(SourceAddr), Length);
        }
    }
    if (!Data.IsEmpty()) {
        SetImageData(AkaName, Data, Width, Height, ChannelNum, bBGR);
    }
    else {
        UE_LOG(PythonTA, Error, TEXT("SetImageDataFromMemory failed, address: %d, @ %s"), Addr, *AkaName.ToString());
    }
}

def on_tick(self):
    # the max fps is limited: 60
    # set "LogOnTickWarnings=False" in config.ini, if you see the warnings
    if self.cap:
        ret, frame = self.cap.read()
        if ret:
            self.data.set_image_data_from_memory(self.ui_image_name, frame.ctypes.data
                                                    , frame.shape[0] * frame.shape[1] * frame.shape[2]
                                                    , frame.shape[1], frame.shape[0], 3, True)
        else:
            self.cap = None

def on_play_video(self):
    if not self.cap:
        if os.path.exists(self.video_path):
            self.cap = cv2.VideoCapture(self.video_path)
        else:
            unreal.log_warning(f"video_path: {self.video_path} not exists")

def on_stop_click(self):
    if self.cap:
        self.cap.release()

self.im_rgb = np.asarray(Image.open(image_path))  # Image will return a rgb order numpy array

self.im = cv2.imread(image_path)  # cv2.imread will return a bgr order numpy array