line algorithm help

Java 2D
#1

I use bufferedimage and have methods to
put a pixel in the image ( edit a value in the array), and i have a myDrawLine(int x,int y) method that draws a line using the pixel method. However it doesnt work as expected, the line drawn has space in it…can someone post an algorithm for drawing a line just by filling in the pixels representing the line?

this is for the 4k competition game im trying to make, i really would like to get this to work by myself but…:confused: im not good enough ::slight_smile:

ive been looking for a basic tutorial on graphics with this kind of algorithm explained and from what i learned i created this method:


public static void myDrawLine(int x1, int y1, int x2, int y2)
            {
                  int deltax = x2 - x1;           // The difference in the x's
                  int deltay = y2 - y1;           // The difference in the y's
                  int y = y1;                     // Start y off at the first pixel value
                  int ynum = deltax / 2;          // The starting value for the numerator
                  for (int x = x1; x <= x2; x++)
                  {
                    Point(x, y);           // Draw the current pixel
                    ynum += deltay;           // Increase the numerator by the top of the fraction
                    if (ynum >= deltax)       // Check if numerator >= denominator
                    {
                      ynum -= deltax;         // Calculate the new numerator value
                      y++;                    // Increase the value in front of the numerator (y)
                    }
                  }
}

but the line created looks incomplete drawn at some
angles…i know this works only when the x coordinate is smaller then the x2 coordinate…

maybe i should just use the Graphics.drawline() method? would save some space probably

#2

You need 2 for loops. One that iterates vertically (y) when deltay > deltax, and one wich iterates horisontally (x) when deltay <= deltax.

#3

Pick one…

public void brese(Graphics g, int x0, int y0, int x1, int y1)
{
      if(x0>x1)
      {
            int s=x0;
            x0=x1;x1=s;
            s=y0;
            y0=y1;y1=s;
      }
      boolean steep=Math.abs(y1-y0)>Math.abs(x1-x0);
      if(steep)
      {
            int s=x0;
            x0=x1;x1=s;
            s=y0;
            y0=y1;y1=s;
      }
      int deltax=x1-x0;
      int deltay=Math.abs(y1-y0);
      int error=0;
      int deltaerr=deltay;
      int y=y0;
      int ystep=y0<y1?1:-1;
      for(int x=x0;x<=x1;x++)
      {
            if(steep)
                  plot(g,y,x);
            else
                  plot(g,x,y);
            error+=deltaerr;
            if(error*2>=deltax)
            {
                  y+=ystep;
                  error-=deltax;
            }
      }
}
public void brese2(Graphics g, int x0, int y0, int x1, int y1)
{
      int dy = y1 - y0;
      int dx = x1 - x0;
      if(dx == 0 && dy == 0)
            return;
      double tX = x0;
      double tY = y0;
      if(Math.abs(dy) > Math.abs(dx))
      {
            int ystep = y1 <= y0 ? -1 : 1;
            double d = (double)dx / (double)dy;
            for(int c = 0; c <= Math.abs(dy); c++)
            {
                  plot(g,(int)Math.round(tX),(int)Math.round(tY));
                  tX += d * (double)ystep;
                  tY += ystep;
            }

      } else
      {
            int xstep = x1 <= x0 ? -1 : 1;
            double d = (double)dy / (double)dx;
            for(int c = 0; c <= Math.abs(dx); c++)
            {
                  int y = (int)Math.round(tY);
                  plot(g,(int)Math.round(tX),(int)Math.round(tY));
                  tY += d * (double)xstep;
                  tX += xstep;
            }

      }
}
public void brese3(Graphics g, int x0, int y0, int x1, int y1)
{
      int dy = y1 - y0;
      int dx = x1 - x0;
      double tX = x0;
      double tY = y0;

      int xstep = x1 <= x0 ? -1 : 1;
      int ystep = y1 <= y0 ? -1 : 1;
      double d;
      boolean ys;
      if(Math.abs(dy) > Math.abs(dx))
      {
            d = (double)dx / (double)dy;
            ys = true;
      }
      else
      {
            d = (double)dy / (double)dx;
            ys = false;
      }
      int cx=x0, cy=y0;
      boolean hack=true;
      do
      {
            if(!hack)
            {
                  if(ys)
                  {
                        tX += d * (double)ystep;
                        tY += ystep;
                  }
                  else
                  {
                        tY += d * (double)xstep;
                        tX += xstep;
                  }
                  cx=(int)Math.round(tX);
                  cy=(int)Math.round(tY);
            }
            hack=false;
            plot(g,cx,cy);
      }while(cx!=x1||cy!=y1);
}