0

I have no experience with any type of flood fill algorithms at all. But I gave it my best shot. At first, I would fill one pixel wherever the user clicked with magenta, and then went through a loop which drew a pixel on top, left, bottom, and right of each magenta pixel. This would take up to 8 seconds to complete the fill with especially large areas. So I added another loop which drew straight magenta-colored lines up, down, left, and right. This halved the time. I had the computer draw more lines... up-up-left, up-left, up-left-left, down-left-left... etc. Now it's down to between 1 & 2 seconds. What else can I do to decrease the amount of time it takes to complete the fill? 

  for(Point p:shiftDownPoints)
  {
     //down
     for(int y = p.y+1; y<SCREEN_DIM.height; y++)
     {
        if(capture.getRGB(p.x,y)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x,y,Color.MAGENTA.getRGB());
     }
     //up
     for(int y = p.y-1; y>0; y--)
     {
        if(capture.getRGB(p.x,y)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x,y,Color.MAGENTA.getRGB());
     }
     //right
     for(int x = p.x+1; x<SCREEN_DIM.width; x++)
     {
        if(capture.getRGB(x,p.y)==Color.BLACK.getRGB())break;
        else capture.setRGB(x,p.y,Color.MAGENTA.getRGB());
     }
     //left
     for(int x = p.x-1; x>0; x--)
     {
        if(capture.getRGB(x,p.y)==Color.BLACK.getRGB())break;
        else capture.setRGB(x,p.y,Color.MAGENTA.getRGB());
     }
     //down-right
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x+i,p.y+i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x+i,p.y+i,Color.MAGENTA.getRGB());
     }
     //down-left
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x-i,p.y+i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x-i,p.y+i,Color.MAGENTA.getRGB());
     }
     //up-left
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x-i,p.y-i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x-i,p.y-i,Color.MAGENTA.getRGB());
     }
     //up-right
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x+i,p.y-i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x+i,p.y-i,Color.MAGENTA.getRGB());
     }
     //up-up-left
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x-i,p.y-i*2)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x-i,p.y-i*2,Color.MAGENTA.getRGB());
     }
     //up-left-left
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x-i*2,p.y-i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x-i*2,p.y-i,Color.MAGENTA.getRGB());
     }
     //down-left-left
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x-i*2,p.y+i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x-i*2,p.y+i,Color.MAGENTA.getRGB());
     }
     //down-down-left
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x-i,p.y+i*2)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x-i,p.y+i*2,Color.MAGENTA.getRGB());
     }
     //down-down-right
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x+i,p.y+i*2)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x+i,p.y+i*2,Color.MAGENTA.getRGB());
     }
     //down-right-right
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x+i*2,p.y+i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x+i*2,p.y+i,Color.MAGENTA.getRGB());
     }
     //up-right-right
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x+i*2,p.y-i)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x+i*2,p.y-i,Color.MAGENTA.getRGB());
     }
     //up-up-right
     for(int i = 1; i<Math.min(SCREEN_DIM.width,SCREEN_DIM.height); i++)
     {
        if(capture.getRGB(p.x+i,p.y-i*2)==Color.BLACK.getRGB())break;
        else capture.setRGB(p.x+i,p.y-i*2,Color.MAGENTA.getRGB());
     }
  }

  while(pixelsDrawn)
  {
     pixelsDrawn=false;
     for(int x = 0; x<SCREEN_DIM.width; x++)
        for(int y = 0; y<SCREEN_DIM.height; y++)
        {
           if(capture.getRGB(x,y)==Color.MAGENTA.getRGB())
           {
              if(capture.getRGB(x-1,y)!=Color.MAGENTA.getRGB()
              &&capture.getRGB(x-1,y)!=Color.BLACK.getRGB())
              {
                 capture.setRGB(x-1,y,Color.MAGENTA.getRGB());
                 pixelsDrawn = true;
              }
              if(capture.getRGB(x+1,y)!=Color.MAGENTA.getRGB()
              &&capture.getRGB(x+1,y)!=Color.BLACK.getRGB())
              {
                 capture.setRGB(x+1,y,Color.MAGENTA.getRGB());
                 pixelsDrawn = true;
              }
              if(capture.getRGB(x,y-1)!=Color.MAGENTA.getRGB()
              &&capture.getRGB(x,y-1)!=Color.BLACK.getRGB())
              {
                 capture.setRGB(x,y-1,Color.MAGENTA.getRGB());
                 pixelsDrawn = true;
              }
              if(capture.getRGB(x,y+1)!=Color.MAGENTA.getRGB()
              &&capture.getRGB(x,y+1)!=Color.BLACK.getRGB())
              {
                 capture.setRGB(x,y+1,Color.MAGENTA.getRGB());
                 pixelsDrawn = true;
              }
           }
        }
  }
user3376587
  • 134
  • 2
  • 12
  • Usually how it works is that you only bother checking the pixels next to one of the pixels you just changed - rather than re-checking the whole image repeatedly. – user253751 Aug 27 '15 at 02:37
  • immibis, if that was an answer, I'd vote it as the best. Thanks for that! It was an "oh yeah!" kinda moment when I read your comment, and now I have it down to half a second. Thanks again! – user3376587 Aug 28 '15 at 05:57

2 Answers2

0

Thanks to immibis's suggestion, I got my flood-fill down to half a second. In this new code, I had the computer go along the edge of the outline and create a polygon, and then just used fillPolygon from the graphics.

  for(Point p:iterablePoints)
  {
     int dir = 2; //0:right, 1:down, 2:left, 3:up
     int xPos = p.x;
     int yPos = 0;
     Polygon poly = new Polygon();
     for(int y = p.y; y>0; y--)
     {
        if(capture.getRGB(p.x,y-1)==Color.BLACK.getRGB())
        {
           yPos = y;
           break;
        }
     }
     Vector<Point> tempRecord = new Vector<Point>();
     boolean run = true;
     while(run)
     {               
        if(dir==0&&capture.getRGB(xPos+1,yPos)==Color.BLACK.getRGB())dir--;
        else if(dir==1&&capture.getRGB(xPos,yPos+1)==Color.BLACK.getRGB())dir--;
        else if(dir==2&&capture.getRGB(xPos-1,yPos)==Color.BLACK.getRGB())dir--;
        else if(dir==3&&capture.getRGB(xPos,yPos-1)==Color.BLACK.getRGB())dir--;
        else 
        {
           if(dir==0)xPos++;
           if(dir==1)yPos++;
           if(dir==2)xPos--;
           if(dir==3)yPos--;

           dir++;

           tempRecord.add(new Point(xPos,yPos));
           if(tempRecord.size()>1)if(tempRecord.get(0)==tempRecord.get(1))tempRecord.remove(tempRecord.firstElement());
           else startPoint = tempRecord.get(0);
           if(startPoint!=null)if(startPoint.x==xPos&&startPoint.y==yPos) run=false;
           poly.addPoint(xPos,yPos);capture.setRGB(xPos,yPos,Color.MAGENTA.getRGB());
        }
        if(dir==4)dir=0;
        if(dir==-1)dir=3;
     }
     Graphics cg = capture.getGraphics();
     cg.setColor(Color.MAGENTA);
     cg.fillPolygon(poly);
     cg.dispose();
  }
user3376587
  • 134
  • 2
  • 12
-1

Discussing flood fill algorithm could take a full class session. I think you should consult This Link as it explain everything, how pixel-by-pixel get painted(efficiently) together with algorithm. Hope this helps.

Ferdinand Neman
  • 680
  • 3
  • 6