based on
Code:

void draw(){
  background(255);
  int x,y;
  for(int p = 0; p < g.length; p++){
    x = p % w;
    y = p / w;

    println("y "+y+"    x "+x);
    //println(g[p]);
    stroke(g[p]);

    point(10 + x* 10, 10+y*10);
  }
} 

;

which is for a 2d grid, i tried to convert for a 3d grid.
Only they y has to start again once it reaches the bottom.
And the z is new...

Does someone know the magical formula for the 3d version?


Code:

int w = 3, h = 6, d = 9;
int Max = w*h*d;

for(int p = 0; p < Max; p++){
  int x = p % w;
  int y = p;//how
  int z = p;//how
  println("z : "+z+"   y : "+y+"   x : "+x);
} 
 

your on a good way but it's not correct.

int w = 3, h = 6, d = 9;

w is x
h is y
d is z

By you x and y are switched

Quote:


Also the x in prev version was correct.
so

Code:

  int x = p % w;
  int z = p / (w * h);//how
 

work, only y needs a working solution now.
Allready thx for the z!

thank you so much
You will be part of history

one question, why:
//int x = (p - z * w * h)%w;

instand of?
int x = p % w;

haha i don't understand that at all.

So it's better to use this?

int x = (p - z * w * h)%w;

Quaestions aren't stupid.

I tried multiple things and i think this method will be the fastest to check if there's a point left/right/under/up/in front/behind of it (i hope). I can be wrong but i'm gonna try this way anyway. I have another sketch that doesn't use this method and there certain calculations get done according to 2 images to create a 3d shape out of those images. Atm it can take up to 5 min before frame 1 is drawn (after that it goes smooth).

Also it's nice to improve my skills (since i lack of that )

There's my answer

clankill3r wrote on Jan 5^th, 2010, 10:07am:


And if it is for checking left/right/...

Here is some code that clearly proves it isn't very efficient:

Code:

int w = 300, h = 600, d = 900;
void setup()
{  
  long startTime = millis();
  {  
    int max = w*h*d;
    for(int p = 0; p < max; p++)
    {
	int z = p / (w * h);
	int y = (p - z * w * h)/w;
	int x = (p - z * w * h)%w;
	
	check(x, y, z);
    }
  }
  println("First method: " + (millis()-startTime));
  
  startTime = millis();
  {  
    for(int x = 0; x < w; x++)
    {
	for(int y = 0; y < h; y++)
	{
	  for(int z = 0; z < d; z++)
	  {
	    check(x, y, z);
	  }
	}
    }
  }
  println("Second method: " + (millis()-startTime));  
}

void check(int x, int y, int z)
{
  //Yes, ... this does not do anything
}
 

I made the w, h, d values bigger to make the time difference clearly visible

Result on my PC:
First method: 2563ms
Second method: 125ms

Nice one lollypop yes it does make the pattern clearer.

My statement when comparing 1D and 3D arrays was
Quote:

To make a valid test of this would require us to compare array access time.
The code below creates both 1D and 3D arrays each with 162 million elements, it first populates (writes) the arrays with numbers and then sees how long it takes to sum (read) the elements. The results on my PC for just 1 iteration of the array were


Populate arrays
Array 3D time = 3297
Array 1D time = 2844
Sum elements of the arrays
Array 3D time = 734     sum = -81007808
Array 1D time = 625     sum = -80992192


I first noticed this difference when I was working on a sketch to load and display 3D models stored in MD2 format. Avoiding multiple access to the same element in a 3D array greatly increased the frame rates achieved.


Code:

int w = 300, h = 600, d = 900 , maxp;
int sum;
long time;

void setup(){
  maxp = w*h*d;
  byte a1d[] = new byte[maxp];
  byte a3d[][][] = new byte[w][h][d];
  
  byte c = 0;
  println("Populate arrays");
  time = millis();
  for(int x = 0; x < w; x++){
    for(int y = 0; y < h; y++){
      for(int z = 0; z < d; z++){
        a3d[x][y][z] = (byte)((c++ % 250)- 125);
      }
    }
  }
  time = millis()- time;
  println("Array 3D time = "+time);

  time = millis();
  for(int i = 0; i < maxp; i++){
    a1d[i] = (byte)((c++ % 250)- 125);
  }
  time = millis()- time;
  println("Array 1D time = "+time);

  println("Sum elements of the arrays");

  sum = 0;
  time = millis();
  for(int x = 0; x < w; x++){
    for(int y = 0; y < h; y++){
      for(int z = 0; z < d; z++){
        sum += a3d[x][y][z];
      }
    }
  }
  time = millis()- time;
  println("Array 3D time = "+time + "     sum = " + sum);

  sum = 0;
  time = millis();
  for(int i = 0; i < maxp; i++){
    sum += a1d[i];
  }
  time = millis()- time;
  println("Array 1D time = "+time + "     sum = " + sum);


}