c# select smaller 3d array from larger 3d array - c#-4.0

Question

I have an array (object[,,]), let us assume for arguments sake the array is x1000, y1000,z*1000 and represents a matrix of points on an x,y,z plane.
at position: x50,y10,z199, for example I want to extract another object[,,] containing a smaller cube, say a submatrix of 100 cubed(or whatever is available, nulls if empty?) from the parent array using the reference point as a centerpoint, is this possible, I was hoping I could do it in linq but got hopelessly lost.. how would you/ should I tackle this.. one though was to do the following:
1.Create a new 3d array with the size of the amount of items i want to retrieve (xyz).
2.Iterate over each axis (x, y, z).
3.Copy the value from the source array to the target array (offsetX+x, offsetY+y, offsetZ+z).
4.Return new array.
but if this is being called a lot, I see it being quite a bottleneck, ideas anyone?

Answer 1

Depending on your usage of the smaller array, this may or may not suit your needs.
To represent a sub section (chunk) of array, instead of creating a new array or doing any copying, you could write your own class which serves as a view to that chunk of array.
Note that this example has the following properties:
No guard clauses in constructor
Chunk is always cube (x, y, z length are equal)
Chunk length is always odd (since we are expanding out from point of reference)
public class ArrayChunk<T>
{
// Array this chunk is from.
private readonly T[,,] _parentArray;
// Point of reference.
private readonly int _x, _y, _z;
// How many elements to move outwards in each direction from point of reference.
private readonly int _numToExpand;
public ArrayChunk(T[,,] parentArray, int x, int y, int z, int numToExpand)
{
_parentArray = parentArray;
_x = x;
_y = y;
_z = z;
_numToExpand = numToExpand;
}
public int Length => _numToExpand*2 + 1;
public T this[int x, int y, int z]
{
get
{
// Make sure index is within chunk range.
EnsureInChunkRange(x, y, z);
// Map chunk index to parent array index.
int parentX = MapToParent(_x, x),
parentY = MapToParent(_y, y),
parentZ = MapToParent(_z, z);
// If parent array index is in parent array range, return element from parent array.
if (IsInRangeOfParent(parentX, parentY, parentZ))
return _parentArray[parentX, parentY, parentZ];
// Otherwise return default element for type T.
return default(T);
}
set
{
EnsureInChunkRange(x, y, z);
int parentX = MapToParent(_x, x),
parentY = MapToParent(_y, y),
parentZ = MapToParent(_z, z);
if (IsInRangeOfParent(parentX, parentY, parentZ))
_parentArray[parentX, parentY, parentZ] = value;
else
throw new InvalidOperationException();
}
}
private void EnsureInChunkRange(int x, int y, int z)
{
if (x < 0 || y < 0 || z < 0 ||
x >= Length || y >= Length || z >= Length)
{
throw new IndexOutOfRangeException();
}
}
private int MapToParent(int referenceIndex, int index)
{
return referenceIndex - _numToExpand + index;
}
private bool IsInRangeOfParent(int parentX, int parentY, int parentZ)
{
return
parentX >= 0 &&
parentY >= 0 &&
parentZ >= 0 &&
parentX < _parentArray.GetLength(0) &&
parentY < _parentArray.GetLength(1) &&
parentZ < _parentArray.GetLength(2);
}
}
To easily get chunk from array, you could declare an extension method:
public static class ArrayChunkExtensions
{
public static ArrayChunk<T> GetChunk<T>(this T[,,] array, int x, int y, int z, int numToExpand)
{
return new ArrayChunk<T>(array, x, y, z, numToExpand);
}
}
Here's a sample usage:
Action<int, Action<int, int, int>> iterate = (length, action) =>
{
for (int x = 0; x < length; x++)
for (int y = 0; y < length; y++)
for (int z = 0; z < length; z++)
action(x, y, z);
};
// Create 5x5x5 parent array.
const int size = 5;
var array = new string[size, size, size];
iterate(size, (x, y, z) => array[x, y, z] = $"x:{x} y:{y} z:{z}");
// Take 3x3x3 chunk from parent array center.
const int indexOfReference = 2;
const int numToExpand = 1;
ArrayChunk<string> chunk = array.GetChunk(indexOfReference, indexOfReference, indexOfReference, numToExpand);
iterate(chunk.Length, (x, y, z) => Console.WriteLine(chunk[x, y, z]));