# Treating a 1D data structure as 2D grid

I am working with a native class that represents a 2D image as a 1D array. If you want to change one pixel, for example, you need to now how to derive the index from the `x,y` coordinates.

So, let's say we have a 1D array `array1d` like this:

``````array1d = [ a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y ]
``````

In the context of our program, `array1d` represents a 2D grid:

``````a b c d e
f g h i j
k l m n o
p q r s t
u v w x y
``````

And we want to perform operations on `array1d` such as:

• Get the value at `x,y` coordinates (in this example, `1,2` would give `l`)
• Get any sub-grid using `x,y,width,height` (`1,2,2,2` would give `[l, m, q, r]`)
• Set the value at any `x,y` coordinate (etc.)

How do we do these?

• In Matlab, and thus likely math types (which spills into CS), to convert one matrix into another (be it a 1x12 into a 2x6 or a 2x6 into a 3x4) is known as "reshaping" mathworks.com/help/matlab/ref/reshape.html
– user40980
Commented Sep 28, 2013 at 17:08
• @MichaelT: the OP is not reshaping the grid. No mention of reshaping the 5x5 to anything else (which wouldn't make sense anyway). :) Commented Feb 17, 2016 at 12:21
• @IAbstract that question was in revision 1 though.
– user40980
Commented Feb 17, 2016 at 12:51

2D / 1D - mapping is pretty simple. Given x and y, and 2D array sizes `width` (for x-direction) and `height` (for y-direction), you can calculate the according index `i` in 1D space (zero-based) by

``````i = x + width*y;
``````

and the reverse operation is

``````x = i % width;    // % is the "modulo operator", the remainder of i / width;
y = i / width;    // where "/" is an integer division
``````

You can extend this easily to 3 or more dimensions. For example, for a 3D matrix with dimensions "width", "height" and "depth":

``````i = x + width*y + width*height*z;
``````

and reverse:

``````x = i % width;
y = (i / width)%height;
z = i / (width*height);
``````
• @awashburn that is the traditional way to do it, it's even built into compilers for static 2D arrays Commented Sep 28, 2013 at 18:26
• @mtoast: I don't think so, its just basic integer math. Commented Sep 29, 2013 at 19:11
• This example is wrong for 3D. The word depth in the calculation should be height. Commented Jul 22, 2015 at 11:15
• @makakas: that is an exercise left to the reader ;-). Hint: you have to add/substract the lower bound as an offset at the right places. But before you try this, clarify to yourself which of the two arrays you mean, the 1D or the 2D array. Commented Jun 5, 2016 at 18:13
• @WDUK: you need to know the minimal values for x and y. Lets say you have xmin<0 and ymin<0. Now you replace "x" by "x-xmin" and "y" by "y-ymin" in the first formula above (for calculating i). For the reverse operation, you do the opposite and replace x by "x+xmin" and "y" by "y+min". Commented Sep 3, 2020 at 6:13