FIX安装目录/src/fixSharedMemory_dll/
  fixSharedMemory_api.h          <- 头文件（唯一需要 include 的文件）
  fixSharedMemoryDll.dll         <- 动态链接库
  fixSharedMemoryDll.lib         <- 导入库（链接用）
  fixSharedMemory_dll_README.md  <- 本文档
  example.cpp                    <- 完整示例代码
  main.cpp                       <- 测试程序源码（来自 test_fixSharedMemoryDll）
  test_fixSharedMemoryDll.exe    <- 预编译测试程序（可直接运行验证连接）

test_fixSharedMemoryDll.exe -d E:\3D\data\tif -n myVolume -t teaching1 -r ResultPath -w 120
test_fixSharedMemoryDll.exe -d D:\data.raw -n rawVol -x 1536 -y 1536 -z 256
test_fixSharedMemoryDll.exe -d E:\3D\proj\tif -n PROJ1 -p --recon-config D:\rc.json -w 300

#include "fixSharedMemory_api.h"
#pragma comment(lib, "fixSharedMemoryDll.lib")

int main(void)
{
    /* ① 连接 FIX 软件（确保 FIX 已启动） */
    FSChannelHandle ch = fsChannelCreate(NULL);
    if (!ch) {
        printf("连接失败! 请先启动 FIX 检测软件\n");
        return -1;
    }

    /* ② 发送体数据, 等待检测完成 */
    int ret = fsChannelSendVolumeAndWait(
        ch,
        myVolumeData,                /* 你的体数据指针 */
        "sample_001",                /* 给这份数据起个名字 */
        "TeachingFileName",          /* 教学文件名称, 没有就传 NULL */
        "D:\\Results",               /* 结果(Results, XML)保存到哪个文件夹, 不需要就传 NULL */
        256, 256, 100,               /* 宽, 高, 深度(切片数) */
        FS_IMAGE_C_GRAY16U,          /* 像素类型: 16位无符号 (最常用) */
        0.05, 0.05, 0.05,           /* 体素尺寸 X/Y/Z, 单位 mm */
        60000,                       /* 超时 60 秒, 传 0 也是 60 秒 */
        NULL, NULL, 0                /* 不需要详细结果, 全传 NULL/0 */
    );

    if (ret == FS_API_OK)
        printf("检测完成!\n");
    else
        printf("检测失败, 错误码: %d\n", ret);

    /* ③ 用完释放 */
    fsChannelDestroy(ch);
    return 0;
}

#include <stdio.h>
#include "fixSharedMemory_api.h"
#pragma comment(lib, "fixSharedMemoryDll.lib")

int doInspection(void* volumeData,
                 uint32_t width, uint32_t height, uint32_t depth)
{
    /* 连接 */
    FSChannelHandle ch = fsChannelCreate(NULL);
    if (!ch) {
        printf("连接失败! 请确认 FIX 软件已启动\n");
        return -1;
    }

    /* 发送并等待 */
    FSResultC result = {0};          /* 用于接收耗时等详细信息 */
    char msg[512] = {0};             /* 用于接收错误/完成消息文本 */

    int ret = fsChannelSendVolumeAndWait(
        ch,
        volumeData, "my_sample",
        "C:\\Teaching\\my.tch",      /* 教学文件, 没有传 NULL */
        "C:\\Results",               /* 结果目录, 不需要传 NULL */
        width, height, depth,
        FS_IMAGE_C_GRAY16U,          /* 16-bit 灰度, 最常见 */
        0.05, 0.05, 0.05,           /* 体素尺寸 mm */
        120000,                      /* 大数据建议加长超时 */
        &result,                     /* [输出] 详细结果 */
        msg, sizeof(msg)             /* [输出] 消息文本 */
    );

    /* 检查结果 */
    switch (ret) {
    case FS_API_OK:
        printf("检测完成! 耗时 %lld ms, 消息: %s\n",
               (long long)result.elapsedMs, msg);
        break;
    case FS_API_ERROR_TIMEOUT:
        printf("超时了! 已等待 %lld ms\n", (long long)result.elapsedMs);
        break;
    default:
        printf("失败! 错误码=%d, 消息: %s\n", ret, msg);
        break;
    }

    /* 释放 */
    fsChannelDestroy(ch);
    return ret;
}

#include <stdio.h>
#include <windows.h>      /* Sleep */
#include "fixSharedMemory_api.h"
#pragma comment(lib, "fixSharedMemoryDll.lib")

/* === 回调函数 (DLL 内部线程调用, 不是主线程!) === */

void onProgress(uint32_t requestId, double progress,
                const char* message, void* userData)
{
    printf("进度: %.0f%% - %s\n", progress * 100.0, message ? message : "");
}

void onDone(uint32_t requestId, uint32_t taskStatus,
            const char* message, int64_t elapsedMs, void* userData)
{
    volatile int* flag = (volatile int*)userData;

    if (taskStatus == FS_TASK_C_COMPLETED)
        printf("完成! 耗时 %lld ms\n", (long long)elapsedMs);
    else
        printf("失败! 状态=%u, 消息: %s\n", taskStatus, message);

    *flag = 1;  /* 通知主线程 */
}

int main(void)
{
    /* 连接 */
    FSChannelHandle ch = fsChannelCreate(NULL);
    if (!ch) { printf("连接失败\n"); return -1; }

    /* 设置回调 */
    volatile int done = 0;
    fsChannelSetProgressCallback(ch, onProgress, NULL);
    fsChannelSetCompletionCallback(ch, onDone, (void*)&done);

    /* 发送 (立即返回, 不阻塞) */
    uint32_t reqId = fsChannelSendVolumeAsync(
        ch, myVolumeData, "sample",
        "C:\\Teaching\\my.tch", "C:\\Results",
        256, 256, 100, FS_IMAGE_C_GRAY16U,
        0.05, 0.05, 0.05);

    if (reqId == 0) {
        printf("发送失败: %s\n", fsChannelGetLastError(ch));
        fsChannelDestroy(ch);
        return -1;
    }

    printf("已发送, requestId=%u, 主线程可以做其他事...\n", reqId);

    /* 主线程等回调通知 (实际项目中用事件/消息循环代替) */
    while (!done) Sleep(100);

    fsChannelDestroy(ch);
    return 0;
}

FSChannelHandle ch = NULL;

/* 连接函数, 可反复调用 */
int connectToFIX(void)
{
    /* 如果旧句柄还在, 先释放 */
    if (ch) {
        fsChannelDestroy(ch);
        ch = NULL;
    }

    ch = fsChannelCreate(NULL);
    if (!ch) return -1;   /* FIX 没启动 */

    /* 重连后回调需要重新设置 */
    fsChannelSetProgressCallback(ch, onProgress, NULL);
    fsChannelSetCompletionCallback(ch, onDone, NULL);
    return 0;
}

/* 使用时: 发现断了就重连 */
void sendData(void* data, uint32_t w, uint32_t h, uint32_t d)
{
    if (!ch || !fsChannelIsConnected(ch)) {
        if (connectToFIX() != 0) {
            printf("FIX 未启动, 无法发送\n");
            return;
        }
    }
    fsChannelSendVolumeAsync(ch, data, "sample", NULL, NULL,
                             w, h, d, FS_IMAGE_C_GRAY16U,
                             0.05, 0.05, 0.05);
}

FSChannelHandle fsChannelCreate(const char* serverName);

int fsChannelIsConnected(FSChannelHandle handle);

void fsChannelDestroy(FSChannelHandle handle);

int fsChannelSendVolumeAndWait(
    FSChannelHandle handle,
    const void* volumeData,
    const char* volumeName,
    const char* teachingFile,
    const char* resultPath,
    uint32_t width, uint32_t height, uint32_t depth,
    int imageType,
    double voxelSizeX, double voxelSizeY, double voxelSizeZ,
    uint32_t timeoutMs,
    FSResultC* outResult,
    char* outMsg, size_t msgBufSize);

volumeData 指向的内存:

  偏移 0:                    slice[0] — width * height 个像素
  偏移 sliceSize:            slice[1]
  偏移 sliceSize * 2:        slice[2]
  ...
  偏移 sliceSize * (depth-1): slice[depth-1]

  sliceSize = width * height * bytesPerPixel
  totalSize = sliceSize * depth

int fsChannelSendProjectionAndWait(
    FSChannelHandle handle,
    const void* projectionData,
    const char* projectionName,
    const char* teachingFile,
    const char* resultPath,
    const char* reconConfigJson,
    uint32_t width, uint32_t height, uint32_t depth,
    int imageType,
    double voxelSizeX, double voxelSizeY, double voxelSizeZ,
    uint32_t timeoutMs,
    FSResultC* outResult,
    char* outMsg, size_t msgBufSize,
    void* outVolumeData, size_t outVolumeSize,
    FSVolumeInfoC* outVolumeInfo);

{
    "geometry": {
        "trajectory": "CBCT",
        "sdAxis": "Z+",
        "rotation": "Zccw",
        "sourceToObject": 500.0,
        "objectToDetector": 500.0,
        "obliqueAngle": 0.0,
        "startAngle": 0.0,
        "scanAngle": 360.0,
        "scanCount": 720
    },
    "detector": {
        "dataType": "UInt16",
        "sizeU": 1536,
        "sizeV": 1536,
        "physicalSizeU": 153.6,
        "physicalSizeV": 153.6,
        "offsetU": 0.0,
        "offsetV": 0.0,
        "tiltAngleU": 0.0,
        "tiltAngleV": 0.0,
        "tiltAngleN": 0.0,
        "flipU": false,
        "flipV": false
    },
    "volume": {
        "dataType": "UInt16",
        "sizeX": 512,
        "sizeY": 512,
        "sizeZ": 512,
        "physicalSizeX": 15.36,
        "physicalSizeY": 15.36,
        "physicalSizeZ": 15.36,
        "offsetX": 0.0,
        "offsetY": 0.0,
        "offsetZ": 0.0,
        "flipX": false,
        "flipY": false,
        "flipZ": false,
        "intensityMin": 0.0,
        "intensityMax": 1.0
    },
    "despeckle": {
        "filterType": "Bilateral",
        "bilateralRadius": 2,
        "bilateralSigmaSpace": 3.0,
        "bilateralSigmaRange": 30.0
    },
    "_metadata": {
        "version": "1.0",
        "dataName": "MySample",
        "loadToViewer": true
    }
}

void fsChannelSetProgressCallback(
    FSChannelHandle handle, FSProgressFunc callback, void* userData);

void myProgressCallback(uint32_t requestId,  // 请求 ID
                        double progress,      // 进度 0.0~1.0
                        const char* message,  // 进度描述文本
                        void* userData);      // 用户数据

void fsChannelSetCompletionCallback(
    FSChannelHandle handle, FSCompletionFunc callback, void* userData);

void myCompletionCallback(uint32_t requestId,    // 请求 ID
                          uint32_t taskStatus,    // 任务状态码 (FSTaskStatusC)
                          const char* message,    // 状态描述文本
                          int64_t elapsedMs,      // 总耗时 (毫秒)
                          void* userData);        // 用户数据

int fsChannelEnableVolumeReceiver(FSChannelHandle handle, size_t volumeDataSize);

void fsChannelSetVolumeCallback(FSChannelHandle handle,
                                 FSVolumeDataFunc callback, void* userData);

void myVolumeCallback(uint32_t requestId,           // 请求 ID
                      const void* volumeData,        // 体数据指针 (仅回调期间有效)
                      const FSVolumeInfoC* volInfo,  // 体数据信息
                      void* userData);               // 用户数据

uint32_t fsChannelSendVolumeAsync(
    FSChannelHandle handle,
    const void* volumeData,
    const char* volumeName,
    const char* teachingFile,
    const char* resultPath,
    uint32_t width, uint32_t height, uint32_t depth,
    int imageType,
    double voxelSizeX, double voxelSizeY, double voxelSizeZ);

uint32_t fsChannelSendProjectionAsync(
    FSChannelHandle handle,
    const void* projectionData,
    const char* projectionName,
    const char* teachingFile,
    const char* resultPath,
    const char* reconConfigJson,
    uint32_t width, uint32_t height, uint32_t depth,
    int imageType,
    double voxelSizeX, double voxelSizeY, double voxelSizeZ);

void fsChannelCancelRequest(FSChannelHandle handle, uint32_t requestId);

const char* fsChannelGetLastError(FSChannelHandle handle);

size_t fsChannelPendingCount(FSChannelHandle handle);

const char* fsGetVersion(void);

typedef struct FSResultC {
    uint32_t taskStatus;   // FSTaskStatusC 枚举值
    uint32_t requestId;    // 请求 ID
    double   progress;     // 最终进度 (通常为 1.0)
    int64_t  elapsedMs;    // 从发送到收到响应的总耗时 (毫秒)
} FSResultC;

typedef struct FSVolumeInfoC {
    uint32_t width;        // X 维度
    uint32_t height;       // Y 维度
    uint32_t depth;        // Z 维度
    int      imageType;    // 像素类型 (FSImageTypeC 值)
    double   voxelSizeX;   // X 方向体素尺寸 (mm)
    double   voxelSizeY;   // Y 方向体素尺寸 (mm)
    double   voxelSizeZ;   // Z 方向体素尺寸 (mm)
    size_t   dataSize;     // 实际体数据字节数
} FSVolumeInfoC;

fsChannelCreate(NULL)        创建句柄 + 连接 (失败返回 NULL)
    |
fsChannelSendVolumeAndWait   发送数据, 阻塞等待
    |                        (检查返回值和 outResult)
    |
fsChannelDestroy             释放资源

fsChannelCreate(NULL)          创建句柄 + 连接 (失败返回 NULL)
    |
fsChannelSetProgressCallback   设置进度回调
fsChannelSetCompletionCallback 设置完成回调
    |
fsChannelSendVolumeAsync       发送数据, 立即返回 requestId
    |
    |--- (主线程继续做其他事情) ---
    |
    |   onProgress(requestId, 0.3, "处理中...", userData)    <- DLL 内部线程
    |   onProgress(requestId, 0.7, "处理中...", userData)
    |   onCompletion(requestId, 200, "完成", 1234, userData) <- DLL 内部线程
    |
fsChannelDestroy               释放资源

fsChannelCreate(NULL)                     创建句柄 + 连接 (失败返回 NULL)
    |
fsChannelEnableVolumeReceiver(size)       启用体数据接收器 (一次)
    |
fsChannelSendProjectionAndWait(...,       发送投影, 阻塞等待
    buf, bufSize, &volInfo)               最后 3 个参数接收体数据
    |
    |  ret == FS_API_OK && volInfo.dataSize > 0
    |  → buf 中已有重建体数据
    |
    |  (可多次调用 sendProjectionAndWait, 接收器可复用)
    |
fsChannelDestroy                          释放资源

fsChannelCreate(NULL)                     创建句柄 + 连接 (失败返回 NULL)
    |
fsChannelEnableVolumeReceiver(size)       启用体数据接收器 (一次)
fsChannelSetVolumeCallback(onVolume, ud)  设置体数据回调
fsChannelSetCompletionCallback(onDone, ud)
    |
fsChannelSendProjectionAsync(...)         异步发送投影
    |
    |   onVolume(reqId, data, &info, ud)    <- 体数据先到达
    |   onDone(reqId, 200, "完成", ms, ud)  <- 完成状态后到达
    |
fsChannelDestroy                          释放资源

/* 把超时从 60 秒改大, 比如 5 分钟 */
fsChannelSendVolumeAndWait(ch, ..., 300000, ...);
/*                                  ^^^^^^ 300000 毫秒 = 5 分钟 */

FSResultC result = {0};
char msg[512] = {0};
int ret = fsChannelSendVolumeAndWait(ch, ..., &result, msg, sizeof(msg));
if (ret != FS_API_OK) {
    printf("错误消息: %s\n", msg);          /* 看服务端返回了什么 */
    printf("状态码: %u\n", result.taskStatus); /* 400=失败, 401=取消, 408=超时 */
}

内存布局 (以 256x256x100, 16-bit 为例):

  总大小 = 256 * 256 * 100 * 2 = 13107200 字节 (12.5 MB)

  byte[0 ~ 131071]         = 第 0 张切片 (256*256*2 字节)
  byte[131072 ~ 262143]    = 第 1 张切片
  ...
  byte[12975128 ~ 13107199] = 第 99 张切片

uint32_t width  = 256;
uint32_t height = 256;
uint32_t depth  = 100;

/* 16-bit 灰度: 每像素 2 字节 */
size_t totalSize = (size_t)width * height * depth * 2;
uint16_t* data = (uint16_t*)malloc(totalSize);

/* 访问第 z 张切片、第 y 行、第 x 列的像素: */
uint16_t pixel = data[z * width * height + y * width + x];

/* 不用教学文件, 也不保存结果 */
fsChannelSendVolumeAndWait(ch, data, "sample",
    NULL,    /* teachingFile: 不使用教学文件 */
    NULL,    /* resultPath:   不保存结果 */
    ...);

fsChannelDestroy(ch);   /* 之后 ch 不能再用 */
ch = NULL;              /* 好习惯: 置空防止误用 */

FSChannelHandle ch1 = fsChannelCreate(NULL);        /* 连接默认 FIX */
FSChannelHandle ch2 = fsChannelCreate("MyServer");   /* 连接另一个服务 */
/* ... 各自独立使用 ... */
fsChannelDestroy(ch1);
fsChannelDestroy(ch2);