C# 如何使用二元遮罩查找边界体素（像素），以仅获取分段曲面

他的问题是我在这里的第一个问题，如果有什么问题，请告诉我。我简要描述了这种情况：有一个大小为512x512xN的体素集（N是层析切片的数量）（新的位数组（512x512xN））。作为其中一种分割算法的结果，获得了该集合中填充体素的索引；BitArray数组用于指示所需的体素，其中值为true的索引为片段，值为false的索引为背景。因此，我想知道如何使用二进制遮罩查找边界体素（像素），该遮罩存储它们的坐标（x，y，z）和背景信息，或者不存储（真-假）），以仅获取片段封套。下面是定义边界索引的代码，但它不正确：

private static async Task<BitArray> EdgeArray(Vector3Int size, BitArray data)
    {
        return await Task.Run(() =>
        {
            var edges = new BitArray(data.Length);
            var mask3d = new Dictionary<Vector3Int,bool>();

            Parallel.For(0, data.Count, i =>
            {
                lock (mask3d)
                {
                    mask3d.Add(size.GetIndex3D(i),data[i]);
                }
            });

            var voxels = mask3d.Keys.ToList();

            Parallel.For(0, voxels.Count, i =>
            {
                if (voxels[i].x == 0 || voxels[i].x == size.x - 1 || voxels[i].y == 0 ||
                    voxels[i].y == size.y - 1 || voxels[i].z == 0 || voxels[i].z == size.z - 1)
                {
                    if (mask3d[voxels[i]])
                    {
                        var index = voxels[i].ToIndex3D(size.x, size.y, size.z);
                        edges[index] = true;
                        Debug.Log(index);
                    }
                }
                else
                {
                    if (mask3d[voxels[i]] && (!mask3d[voxels[i-1]] || !mask3d[voxels[i+1]]))
                    {
                        var index = voxels[i].ToIndex3D(size.x, size.y, size.z);
                        edges[index] = true;
                        Debug.Log(index);
                    }
                }
            });
            return edges;
        });
    }

专用静态异步任务EdgerRay（矢量3int大小，位数组数据）
{
返回等待任务。运行（（）=>
{
var edges=新的位数组（data.Length）；
var mask3d=新字典（）；
Parallel.For（0，data.Count，i=>
{
锁（mask3d）
{
mask3d.Add（size.GetIndex3D（i），data[i]）；
}
});
var voxels=mask3d.Keys.ToList（）；
Parallel.For（0，体素数，i=>
{
如果（体素[i].x==0 | |体素[i].x==size.x-1 | |体素[i].y==0||
体素[i].y==size.y-1 | |体素[i].z==0 | |体素[i].z==size.z-1）
{
if（mask3d[体素[i]]）
{
var index=voxels[i].ToIndex3D（size.x，size.y，size.z）；
边[索引]=真；
Debug.Log（索引）；
}
}
其他的
{
if（mask3d[voxels[i]]&&（！mask3d[voxels[i-1]]| |！mask3d[voxels[i+1]]））
{
var index=voxels[i].ToIndex3D（size.x，size.y，size.z）；
边[索引]=真；
Debug.Log（索引）；
}
}
});
返回边；
});
}

次要功能：

/// <summary>
    /// returns the index in the 3d representation
    /// </summary>
    /// <param name="vector3Int"> array size in 3d representation </param>
    /// <param name="index"> 1d index </param>
    /// <returns>index in the 3d representation</returns>
    public static Vector3Int GetIndex3D(this Vector3Int vector3Int, int index)
    {
        return new Vector3Int
        {
            z = index / (vector3Int.x * vector3Int.y),
            y = index % (vector3Int.x * vector3Int.y) / vector3Int.x,
            x = index % (vector3Int.x * vector3Int.y) % vector3Int.x
        };
    }
    
public static int ToIndex3D(this Vector3Int vector3Int, int width, int height, int depth)
    {
        return vector3Int.z * width * height + vector3Int.y * width + vector3Int.x*depth;
    }

//
///返回三维表示中的索引
/// 
///三维表示中的数组大小
///一维索引
///三维表示中的索引
公共静态向量3int GetIndex3D（此向量3int向量3int，int索引）
{
返回新矢量3int
{
z=指数/（向量3int.x*向量3int.y），
y=指数%（向量3int.x*向量3int.y）/向量3int.x，
x=索引%（向量3int.x*vector3Int.y）%vector3Int.x
};
}
公共静态int到index3d（此向量3int向量3int，int宽度，int高度，int深度）
{
返回向量3int.z*宽度*高度+向量3int.y*宽度+向量3int.x*深度；
}

我认为GetIndex3D（）和ToIndex3D（）函数可能是错误的。 ToIndex3D（）应为：

return vector3Int.z * width * height + vector3Int.y * width + vector3Int.x;

z = index / (vector3Int.x * vector3Int.y),
y = (index / vector3Int.x) % vector3Int.y
x = index % vector3Int.x

和GetIndex3D（）应该是：

return vector3Int.z * width * height + vector3Int.y * width + vector3Int.x;

z = index / (vector3Int.x * vector3Int.y),
y = (index / vector3Int.x) % vector3Int.y
x = index % vector3Int.x

（这是一个未经测试的内存猜测，但我认为将3D数组转换为一维数组是一种不错的方法，反之亦然）