The working of FloodFillTPAOn request, I will explain in short how FloodFillTPA works, both in code and function. I include the source of this function at the bottom, as well as a few stuff I used to display it better. I suggest holding the code of the function next to this walk through.
function FloodFillTPA2(const TPA : TPointArray) : T2DPointArray;So the TPA we will give to this function as the parameter is:
[INDENT]
const TPA: TPointArray[/INDENT]
If you wonder how the TPA looks within simba:
[{X = 10, Y = 0}, {X = 11, Y = 0}, {X = 12, Y = 0}, {X = 1, Y = 1}, {X = 9, Y = 1}, {X = 10, Y = 1}, {X = 11, Y = 1}, {X = 12, Y = 1}, {X = 1, Y = 2}, {X = 2, Y = 2}, {X = 3, Y = 2}, {X = 8, Y = 2}, {X = 9, Y = 2}, {X = 10, Y = 2}, {X = 11, Y = 2}, {X = 12, Y = 2}, {X = 2, Y = 3}, {X = 3, Y = 3}, {X = 7, Y = 3}, {X = 8, Y = 3}, {X = 2, Y = 4}, {X = 3, Y = 4}, {X = 7, Y = 4}, {X = 15, Y = 4}, {X = 16, Y = 4}, {X = 17, Y = 4}, {X = 2, Y = 5}, {X = 7, Y = 5}, {X = 14, Y = 5}, {X = 15, Y = 5}, {X = 16, Y = 5}, {X = 17, Y = 5}, {X = 2, Y = 6}, {X = 13, Y = 6}, {X = 14, Y = 6}, {X = 15, Y = 6}, {X = 16, Y = 6}, {X = 17, Y = 6}, {X = 18, Y = 6}, {X = 8, Y = 7}, {X = 12, Y = 7}, {X = 13, Y = 7}, {X = 14, Y = 7}, {X = 15, Y = 7}, {X = 16, Y = 7}, {X = 17, Y = 7}, {X = 18, Y = 7}, {X = 6, Y = 8}, {X = 7, Y = 8}, {X = 8, Y = 8}, {X = 12, Y = 8}, {X = 13, Y = 8}, {X = 14, Y = 8}, {X = 15, Y = 8}, {X = 16, Y = 8}, {X = 17, Y = 8}, {X = 18, Y = 8}, {X = 3, Y = 9}, {X = 4, Y = 9}, {X = 5, Y = 9}, {X = 6, Y = 9}, {X = 7, Y = 9}, {X = 12, Y = 9}, {X = 13, Y = 9}, {X = 14, Y = 9}, {X = 15, Y = 9}, {X = 16, Y = 9}, {X = 17, Y = 9}, {X = 2, Y = 10}, {X = 3, Y = 10}, {X = 4, Y = 10}, {X = 5, Y = 10}, {X = 6, Y = 10}, {X = 13, Y = 10}, {X = 14, Y = 10}, {X = 15, Y = 10}, {X = 4, Y = 11}, {X = 5, Y = 11}, {X = 6, Y = 11}, {X = 11, Y = 13}, {X = 12, Y = 13}, {X = 13, Y = 13}, {X = 14, Y = 13}, {X = 15, Y = 13}, {X = 4, Y = 14}, {X = 5, Y = 14}, {X = 6, Y = 14}, {X = 7, Y = 14}, {X = 8, Y = 14}, {X = 9, Y = 14}, {X = 10, Y = 14}, {X = 13, Y = 14}, {X = 14, Y = 14}, {X = 15, Y = 14}, {X = 16, Y = 14}, {X = 3, Y = 15}, {X = 4, Y = 15}, {X = 5, Y = 15}, {X = 6, Y = 15}, {X = 7, Y = 15}, {X = 8, Y = 15}, {X = 9, Y = 15}, {X = 10, Y = 15}, {X = 14, Y = 15}, {X = 15, Y = 15}, {X = 16, Y = 15}, {X = 17, Y = 15}, {X = 2, Y = 16}, {X = 3, Y = 16}, {X = 4, Y = 16}, {X = 5, Y = 16}, {X = 6, Y = 16}, {X = 7, Y = 16}, {X = 8, Y = 16}, {X = 9, Y = 16}, {X = 10, Y = 16}, {X = 14, Y = 16}, {X = 15, Y = 16}, {X = 16, Y = 16}, {X = 17, Y = 16}, {X = 2, Y = 17}, {X = 3, Y = 17}, {X = 4, Y = 17}, {X = 5, Y = 17}, {X = 6, Y = 17}, {X = 7, Y = 17}, {X = 8, Y = 17}, {X = 9, Y = 17}, {X = 10, Y = 17}, {X = 15, Y = 17}, {X = 16, Y = 17}, {X = 17, Y = 17}, {X = 1, Y = 18}, {X = 2, Y = 18}, {X = 3, Y = 18}, {X = 4, Y = 18}, {X = 5, Y = 18}, {X = 6, Y = 18}, {X = 7, Y = 18}, {X = 8, Y = 18}, {X = 9, Y = 18}, {X = 15, Y = 18}, {X = 16, Y = 18}, {X = 3, Y = 19}, {X = 4, Y = 19}, {X = 5, Y = 19}]
The next thing we will do is create a 2D Array of Boolean, where we will set all the points that needs to be filled to true. That are all the points from the above TPA.
[INDENT]
var PointsToFill: Array of Array of Boolean[/INDENT]
The big pro is that if you want to know if a point needs to be filled is that you can easily check it up by going to the right row and column and check if it is true or false. In the original TPA you would have to loop through each point. Also note how much easier it is to set one element in the 2DBooleanArray to false compare to removing one point of the TPA.
One might note the comment stating that the width and height of this Array are 2 bigger then required. This is done because while looping we can just check these points, see that they are false and skip them. Instead of having an if/else structure searching for the borders. You will see this later on, when we are really floodfilling stuff. So the actual PointsToFill Array looks like this:
[INDENT]
var PointsToFill: Array of Array of Boolean[/INDENT]
Well we are done with preparing. Let's start to flood fill! for I := 0 to LengthTPA do
[INDENT]if PointsToFill[TempTPA.x][TempTPA.y] then[/INDENT]We will loop through every point in the original array and looks if it is true in the PointsToFill variable. In the first run of this loop it will always be true because we just set it to true in PointsToFill earlier.
Stack[0].x := TempTPA.x;
Stack[0].y := TempTPA.y;We add the first point to the stack. The Stack is the array of points we will loop through while filling. In this example we will fill the Stack five times. One for every object we found. The stack is added to the result as one of the arrays.
While CurrentStack > -1 doCurrenStack is an integer used to indicate which are checked and which not. Stack[currentStack] is the point we will be checking the surroundings of.
if PointsToFill[fx+1][fy] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy;PointsToFill[fx+1][fy] := false;
end;
if PointsToFill[fx][fy+1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx;Stack[Currentstack].y := fy+1;PointsToFill[fx][fy+1] := false;
end;
if PointsToFill[fx-1][fy] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy;PointsToFill[fx-1][fy] := false;
end;
if PointsToFill[fx][fy-1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx;Stack[Currentstack].y := fy-1;PointsToFill[fx][fy-1] := false;
end;
if PointsToFill[fx+1][fy+1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy+1;PointsToFill[fx+1][fy+1] := false;
end;
if PointsToFill[fx-1][fy-1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy-1;PointsToFill[fx-1][fy-1] := false;
end;
if PointsToFill[fx-1][fy+1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy+1;PointsToFill[fx-1][fy+1] := false;
end;
if PointsToFill[fx+1][fy-1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy-1;PointsToFill[fx+1][fy-1] := false;
end;
Actually checks the surroundings of the point it currently is checking out. Note that it checks in all the eight directions. It will add the found points to the Stack if it is True within PointsToFill(Green in my images).
[INDENT]
Step by step looping though the stack.[/INDENT]
function FloodFillTPA2(const TPA : TPointArray) : T2DPointArray;
var
x,y,i,CurrentArray, LengthTPA,CurrentStack : integer;
TempBox : TBox;
PointsToFill : array of TBoolArray;
Lengths : TIntegerArray;
TempTPA : TPointArray;
Stack : TPointArray;
fx,fy : integer;
begin;
LengthTPA := High(TPA);
if LengthTPA < 1 then
begin;
if LengthTPA = 0 then
begin;
SetLength(Result,1);
SetLength(Result[0], 1);
Result[0][0] := TPA[0];
end else
SetLength(Result,0);
exit;
end;
TempBox := GetTPABounds(TPA);
SetLength(PointsToFill,TempBox.x2 - TempBox.x1+3); //W + 2, H + 2 so that we can check the borders
for i:=0 to High(PointsToFill) do
SetLength(PointsToFill[i], TempBox.y2 - TempBox.y1+3);
fy := TempBox.y2 - TempBox.y1+3;
fx := TempBox.x2 - TempBox.x1+2;
for i := 0 to fx do
FillChar(PointsToFill[i][0],fy,0);
x := TempBox.x1 - 1;
y := TempBox.y1 - 1;
CurrentArray := -1;
SetLength(Stack , LengthTPA + 1);
SetLength(Lengths , LengthTPA + 1);
SetLength(TempTPA , LengthTPA + 1);
for I := 0 to LengthTPA do
begin;
TempTPA[I].x := TPA[I].x - x;
TempTPA[I].y := TPA[I].y - y;
end;
for I := 0 to LengthTPA do
PointsToFill[TempTPA[I].x][TempTPA[I].y] := True;
for I := 0 to LengthTPA do
if PointsToFill[TempTPA[I].x][TempTPA[I].y] then
begin;
PointsToFill[TempTPA[i].x][TempTPA[i].y] := false;
inc(CurrentArray);
SetLength(Result,CurrentArray + 1);
SetLength(Result[CurrentArray],LengthTPA - I + 1);
Lengths[CurrentArray] := 0;
CurrentStack := 0;
Stack[0].x := TempTPA[I].x;
Stack[0].y := TempTPA[I].y;
While CurrentStack > -1 do
begin;
fx := stack[CurrentStack].x;
fy := stack[CurrentStack].y;
dec(CurrentStack);
Result[CurrentArray][Lengths[CurrentArray]].x := fx + x;
Result[CurrentArray][Lengths[CurrentArray]].y := fy + y;
inc(Lengths[CurrentArray]);
if PointsToFill[fx+1][fy] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy;PointsToFill[fx+1][fy] := false;
end;
if PointsToFill[fx][fy+1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx;Stack[Currentstack].y := fy+1;PointsToFill[fx][fy+1] := false;
end;
if PointsToFill[fx-1][fy] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy;PointsToFill[fx-1][fy] := false;
end;
if PointsToFill[fx][fy-1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx;Stack[Currentstack].y := fy-1;PointsToFill[fx][fy-1] := false;
end;
if PointsToFill[fx+1][fy+1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy+1;PointsToFill[fx+1][fy+1] := false;
end;
if PointsToFill[fx-1][fy-1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy-1;PointsToFill[fx-1][fy-1] := false;
end;
if PointsToFill[fx-1][fy+1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx-1;Stack[Currentstack].y := fy+1;PointsToFill[fx-1][fy+1] := false;
end;
if PointsToFill[fx+1][fy-1] then
begin
inc(CurrentStack);Stack[CurrentStack].x := fx+1;Stack[Currentstack].y := fy-1;PointsToFill[fx+1][fy-1] := false;
end;
end;
SetLength(Result[CurrentArray],Lengths[CurrentArray]);
end;
SetLength(Stack,0);
SetLength(TempTPA,0);
SetLength(Lengths,0);
end;
From: KingKong
(why its not decremented, ask the simba devs, its the way the functions are implemented)
How about it is pascalscript not simba which is doing that… -_- So how about asking the pascalscript devs. Nielsie created LAPE, which doesn't got that problem.