Getting the centers of all triangles in a bound isometric grid - algorithm

Question

I have a geometry problem:
Consider the following isometric grid where the center is (0, 0) and a side of a triangle are of length one unit:
How can I get the coordinate of all the individual triangles, including the ones that are not complete?
I tried simply dividing the width and height by different factors, but I cannot seem to find a formula that always encompasses partial triangles.

Answer 1

One way to do it:
The coordinates of the center of a triangle is simply the average of it's three vertices.
Since the grid is vertically aligned, you can find the missing vertices of partial triangles in the vertical directions (up and down) by simply adding/subtracting s the length of a side of the triangles to the Y-axis.
Because these are equilateral triangles, you can find the missing vertices of the partial triangles with 2 visible vertices in the horizontal directions (left and right) by adding/subtracting (√3/2)s to the X-axis of one of the existing vertices and setting the Y-axis value to the average of the Y values of the two existing vertices. You can find the missing vertices of partial triangles that have only one visible vertex in the horizontal directions by getting them from thier adjacent horizontal triangles with two visible vertices.
Partial corner triangles (only one vertex) can be extended as follows: first get the vertically-missing vertex by applying rule (2) above. Second, now that you know two vertices, you can get the horizontally-missing vertex by applying rule (3) above.
Note that this is not the only way to do it, no even necessarily the easiest way.

Answer 2

First you need to chose topology of your grid. I see it like this:
Yellow indexes are intersection points on grid and Aqua indexes are individual triangles of the grid. So define basis vectors u,v,w describing 3 possible directions of the grid and then just transform grid point position yellow (i,j) into (x,y). That can be used to form triangles using aqua triangle index parity (even/odd) of each index (4 possible cases) to compute its 3 yellow point indexes ... Here small C++/OpenGL 2D example rendering 2n+1 x 2n+1 triangles grid:
//---------------------------------------------------------------------------
void get_hexpoint(double *p,int i,int j) // i,j yellow
{
static const double deg=M_PI/180.0; // deg -> rad
static const double u[2]={+cos(30.0*deg),-sin(30.0*deg)};
static const double v[2]={+cos(30.0*deg),+sin(30.0*deg)};
static const double w[2]={ 0.0 , +1.0 };
double ii=i,jj=j;
for (i=0;i<2;i++) p[i]=0.0;
for (i=0;i<2;i++) p[i]+=(ii*u[i])+(jj*w[i]);
}
//---------------------------------------------------------------------------
void get_hextriangle(double *p0,double *p1,double *p2,int i,int j) // i,j aqua
{
if (int(j&1)==0)
{
j=(j>>1)+(i>>1);
if (int(i&1)==0)
{
get_hexpoint(p0,i,j);
get_hexpoint(p1,i+1,j);
get_hexpoint(p2,i+1,j+1);
}
else{
get_hexpoint(p0,i,j);
get_hexpoint(p1,i,j+1);
get_hexpoint(p2,i+1,j+1);
}
}
else{
j=(j>>1)+(i>>1);
if (int(i&1)==0)
{
get_hexpoint(p0,i,j);
get_hexpoint(p1,i+1,j+1);
get_hexpoint(p2,i,j+1);
}
else{
j++;
get_hexpoint(p0,i,j);
get_hexpoint(p1,i+1,j);
get_hexpoint(p2,i+1,j+1);
}
}
}
//---------------------------------------------------------------------------
void TMain::draw()
{
scr.cls();
glDisable(GL_DEPTH_TEST);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glScalef(0.2,0.2,1.0);
int i,j,n=10;
double p0[2],p1[2],p2[2];
glLineWidth(3);
for (i=-n;i<=+n;i++)
for (j=-n;j<=+n;j++)
{
get_hextriangle(p0,p1,p2,i,j);
glColor3f(0.2,0.2,0.2);
glBegin(GL_TRIANGLES);
glVertex2dv(p0);
glVertex2dv(p1);
glVertex2dv(p2);
glEnd();
glColor3f(1.0,1.0,1.0);
glBegin(GL_LINE_LOOP);
glVertex2dv(p0);
glVertex2dv(p1);
glVertex2dv(p2);
glEnd();
}
glLineWidth(1);
scr.exe();
scr.rfs();
}
//---------------------------------------------------------------------------
And here the output:
Note that the 4 cases branches might be converted to brunch-less code by changing the logic a bit moving the if statements to point index deltas or by using LUTs... but I am too lazy to do that.