Как сгладить или проиндексировать 3D-массив в 1D-массиве?

Алгоритм в основном такой же. Если у вас есть 3D-массив Original[HEIGHT, WIDTH, DEPTH], вы можете превратить его в Flat[HEIGHT * WIDTH * DEPTH] с помощью

Flat[x + WIDTH * (y + DEPTH * z)] = Original[x, y, z]

Кроме того, вы должны предпочесть массивы массивов многомерным массивам в .NET. Различия в производительности значительны

Вот решение на Java, которое дает вам и то, и другое:

• от 3D до 1D
• от 1D до 3D

Ниже приведена графическая иллюстрация пути, который я выбрал для обхода 3D-матрицы, ячейки пронумерованы в порядке их обхода:

Функции преобразования:

public int to1D( int x, int y, int z ) {
    return (z * xMax * yMax) + (y * xMax) + x;
}

public int[] to3D( int idx ) {
    final int z = idx / (xMax * yMax);
    idx -= (z * xMax * yMax);
    final int y = idx / xMax;
    final int x = idx % xMax;
    return new int[]{ x, y, z };
}

Я думаю, что сказанное выше требует небольшой поправки. Допустим, у вас ВЫСОТА 10 и ШИРИНА 90, одномерный массив будет 900. Согласно приведенной выше логике, если вы находитесь на последнем элементе массива 9 + 89 * 89, очевидно, что это больше 900. Правильный алгоритм:

Flat[x + HEIGHT* (y + WIDTH* z)] = Original[x, y, z], assuming Original[HEIGHT,WIDTH,DEPTH] 

По иронии судьбы, если вы выберете HEIGHT> WIDTH, вы не испытаете переполнения, а просто получите безумный результат;)

x + y*WIDTH + Z*WIDTH*DEPTH. Визуализируйте его как прямоугольное тело: сначала вы двигаетесь по x, затем каждый y представляет собой "линию" длиной width шага, а каждый z является "плоскостью" WIDTH*DEPTH шагов по площади.

Ты почти там. Вам нужно умножить Z на WIDTH и DEPTH:

Tiles[x + y*WIDTH + Z*WIDTH*DEPTH] = elements[x][y][z]; // or elements[x,y,z]

TL;DR

Правильный ответ можно написать по-разному, но мне больше всего нравится, когда его можно написать так, чтобы его было очень легко понять и визуализировать. Вот точный ответ:

(width * height * z) + (width * y) + x

TS;DR

Визуализируйте это:

someNumberToRepresentZ + someNumberToRepresentY + someNumberToRepresentX

someNumberToRepresentZ указывает, на какой матрице мы находимся (depth). Чтобы узнать, в какой матрице мы находимся, мы должны знать, насколько велика каждая матрица. Матрица имеет размер 2d как width * height, простая. Возникает вопрос: «сколько матриц находится до того, как я использую матрицу?» Ответ z:

someNumberToRepresentZ = width * height * z

someNumberToRepresentY указывает, в какой строке мы находимся (height). Чтобы узнать, в какой строке мы находимся, мы должны знать, насколько велика каждая строка: каждая строка имеет размер 1d, размер width. Возникает вопрос: «сколько строк перед строкой, в которой я сейчас?». Ответ y:

someNumberToRepresentY = width * y

someNumberToRepresentX указывает, в каком столбце мы находимся (width). Чтобы узнать, в каком столбце мы находимся, мы просто используем x:

someNumberToRepresentX = x

Тогда наша визуализация

someNumberToRepresentZ + someNumberToRepresentY + someNumberToRepresentX

Становится

(width * height * z) + (width * y) + x

Прямые и обратные преобразования Самуэля Керриена, приведенные выше, почти верны. Более краткие (основанные на R) карты преобразования включены ниже с примером («a %% b» - это оператор по модулю, представляющий остаток от деления a на b):

dx=5; dy=6; dz=7  # dimensions
x1=1; y1=2; z1=3  # 3D point example
I = dx*dy*z1+dx*y1+x1; I  # corresponding 2D index
# [1] 101
x= I %% dx; x  # inverse transform recovering the x index
# [1] 1
y = ((I - x)/dx) %% dy; y  # inverse transform recovering the y index
# [1] 2
z= (I-x -dx*y)/(dx*dy); z  # inverse transform recovering the z index
# [1] 3

Обратите внимание на операторы деления (/) и модуля (%%).

Чтобы лучше понять описание 3D-массива в 1D-массиве (я думаю, что под глубиной в лучшем ответе подразумевается размер Y)

IndexArray = x + y * InSizeX + z * InSizeX * InSizeY;

IndexArray = x + InSizeX * (y + z * InSizeY);

Правильный алгоритм:

Flat[ x * height * depth + y * depth + z ] = elements[x][y][z] 
where [WIDTH][HEIGHT][DEPTH]

m [x] [y] [z] = данные [xYZ + yZ + z]

x-picture:
0-YZ
.
.
x-YZ

y-picture 

0-Z
.
.
.
y-Z


summing up, it should be : targetX*YZ + targetY*Z + targetZ