¿Cómo "aplanar" o "indexar" 3D-array en 1D array?

Question

Estoy tratando de aplanar matriz 3D en matriz 1D para el sistema "trozo" en mi juego. Es un juego de bloques en 3D y, básicamente, quiero que el sistema de fragmentos sea casi idéntico al sistema de Minecraft (sin embargo, esto no es un clon de Minecraft por ninguna medida). En mis anteriores 2D-juegos que he accedido a la gama aplanado con algoritmo siguiente:

Tiles[x + y * WIDTH] 

Sin embargo, esto obviamente no funciona con 3D, ya que le falta el eje Z. No tengo idea de cómo implementar este tipo de algoritmo en el espacio 3D. El ancho, la altura y la profundidad son todas constantes (y el ancho es tan grande como la altura).

¿Es solo x + y*WIDTH + Z*DEPTH? Soy bastante malo con las matemáticas y recién comienzo la programación en 3D, así que estoy bastante perdido: |

PS. La razón de esto es que estoy haciendo bucles y obteniendo cosas por índice bastante. Sé que las matrices 1D son más rápidas que las matrices multidimensionales (por razones que no puedo recordar: P). Aunque esto puede no ser necesario, quiero el mejor rendimiento posible :)

Answer 1

El algoritmo es casi el mismo. Si usted tiene una matriz 3D Original[HEIGHT, WIDTH, DEPTH] entonces se podría convertirlo en Flat[HEIGHT * WIDTH * DEPTH] por

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

Dicho sea de paso, se debe preferir matrices de matrices sobre matrices multidimensionales en .NET. Las diferencias de rendimiento son significativas

Answer 2

Ya casi está. Es necesario multiplicar por Z WIDTH y DEPTH:

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

Answer 3

x + y*WIDTH + Z*WIDTH*DEPTH. Visualícelo como un sólido rectangular: primero recorre x, luego cada y es una "línea" width pasos largos, y cada z es un "plano" WIDTH*DEPTH pasos en el área.

Answer 4

Creo que lo anterior necesita una pequeña corrección. Digamos que tienes una ALTURA de 10, y un ANCHO de 90, una matriz dimensional única será de 900. Por la lógica anterior, si estás en el último elemento de la matriz 9 + 89 * 89, obviamente esto es mayor que 900.El algoritmo correcto es:

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

Irónicamente si la ALTURA> ancho que no va a experimentar un desbordamiento, simplemente complete resultados Bonkers;)

Answer 5

Para comprender mejor descripción de la matriz 3D en 1D matriz sería de (I supongo Profundidad en la mejor respuesta se entiende el tamaño Y)

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

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

Answer 6

Aquí es una solución en Java que proporciona tanto:

• de 3D a 1D
• de 1D a 3D

a continuación es una ilustración gráfica de la trayectoria he elegido para atravesar la matriz 3D, las células están numeradas en el orden de recorrido:

funciones de conversión:

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 }; 
}