Generalise Bresenham algorithm height octant - c++

Question

I'm trying to implement Bresenham algorithms to have something like :
So in my main, I tested a lot of algorithm something like :
line(ushort x0, ushort y0, ushort x1, ushort y1, const Color couleur)
int dx = abs(x1-x0);
int dy = abs(y1-y0);
int sx,sy;
sx=sy=0;
if(x0 < x1) sx = 1;
else sx = -1;
if(y0 < y1) sy = 1;
else sy = -1;
int err = dx-dy;
while(1)
{
pixel(x0, y0) = couleur;
if(x0 == x1 && y0 == y1) break;
int e2 = 2* err;
if(e2 > -dy)
{
err = err - dy;
x0 = x0 + sx;
}
if(e2 < dy)
{
err = err + dx;
y0 = y0 + sy;
}
}
Or
ushort x=x1;
ushort y=y1;
int longX=x2-x1;
int longY=y2-y1;
if(longY<longX)
{ // 1er Octant
const int c1=2*(longY-longX);
const int c2=2*longY;
int critère=c2-longX;
while(x<=x2)
{
DessinePoint(x,y,couleur);
if(critère>=0)
{ // changement de ligne horizontale
y++;
critère=critère+c1;
}
else
// toujours la même ligne horizontale
critère=critère+c2;
x++; // ligne suivante, et recommence
}
}
else
{ // 2eme Octant
const int c1=2*(longX-longY);
const int c2=2*longX;
int critère=c2-longY;
while(y<=y2)
{
DessinePoint(x,y,couleur);
if(critère>=0)
{ // changement de ligne verticale
x++;
critère=critère+c1;
}
else
// toujours la même ligne verticale
critère=critère+c2;
y++; // ligne suivante, et recommence
}
}
for two octants.
I also tried what we can find in wikipedia, but nothing special.
A last function I tried to implement :
line(ushort xi, ushort yi, ushort xf, ushort yf, const Color couleur)
{
int dx,dy,i,xinc,yinc,cumul,x,y ;
x = xi ;
y = yi ;
dx = xf - xi ;
dy = yf - yi ;
xinc = ( dx > 0 ) ? 1 : -1 ;
yinc = ( dy > 0 ) ? 1 : -1 ;
dx = abs(dx) ;
dy = abs(dy) ;
pixel(x,y)= couleur;
if ( dx > dy )
{
cumul = dx / 2 ;
for ( i = 1 ; i <= dx ; i++ )
{
x += xinc ;
cumul += dy ;
if ( cumul >= dx )
{
cumul -= dx ;
y += yinc ;
}
pixel(x,y) = couleur ;
}
}
else
{
cumul = dy / 2 ;
for ( i = 1 ; i <= dy ; i++ )
{
y += yinc ;
cumul += dx ;
if ( cumul >= dy )
{
cumul -= dy ;
x += xinc ;
}
pixel(x,y) = couleur ;
}
}
So , someone know any solution ?

Answer 1

http://tech-algorithm.com/articles/drawing-line-using-bresenham-algorithm/
void LineBresenham(int x,int y,int x2, int y2, int color)
{
int w = x2 - x ;
int h = y2 - y ;
int dx1 = 0, dy1 = 0, dx2 = 0, dy2 = 0 ;
if (w<0) dx1 = -1 ; else if (w>0) dx1 = 1 ;
if (h<0) dy1 = -1 ; else if (h>0) dy1 = 1 ;
if (w<0) dx2 = -1 ; else if (w>0) dx2 = 1 ;
int longest = abs(w) ;
int shortest = abs(h) ;
if (!(longest>shortest))
{
longest = abs(h) ;
shortest = abs(w) ;
if (h<0) dy2 = -1 ;
else if (h>0) dy2 = 1 ;
dx2 = 0 ;
}
int numerator = longest >> 1 ;
for (int i=0;i<=longest;i++)
{
PlotPixel(x,y,color) ;
numerator += shortest ;
if (!(numerator<longest))
{
numerator -= longest ;
x += dx1 ;
y += dy1 ;
} else {
x += dx2 ;
y += dy2 ;
}
}
}

Answer 2

The octant can be generalized by some extra variables dx0, dy0, dx1, dy1.
if (error < delta)
{
x += dx0;
y += dy0;
} else {
x += dx1;
y += dy1;
}
Depending on the octant, one of dx0, dy0 is zero; also the "delta variables" can have negative values.