Initial data commit

Task/Bitmap-Bresenhams-line-algorithm/Erlang/bitmap-bresenhams-line-algorithm-1.erl

@@ -0,0 +1,45 @@
+build_path({Sx, Sy}, {Tx, Ty}) ->
+  if
+    Tx < Sx -> StepX = -1;
+    true -> StepX = 1
+  end,
+  if
+    Ty < Sy -> StepY = -1;
+    true -> StepY = 1
+  end,
+
+  Dx = abs((Tx-Sx)*2),
+  Dy = abs((Ty-Sy)*2),
+
+  if
+    Dy > Dx -> Path = through_y({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, Dx*2-Dy, []);
+    true -> Path = through_x({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, Dy*2-Dx, [])
+  end,
+
+  lists:reverse(Path).
+
+through_x({Tx, _}, {Tx, _}, _, _, _, P) -> P;
+through_x({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 >= 0 ->
+  Ny = Sy + StepY,
+  F1 = F0 - Dx,
+  Nx = Sx + StepX,
+        F2 = F1 + Dy,
+  through_x({Nx, Ny}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F2, [{Nx, Ny}|P]);
+through_x({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 < 0 ->
+  Ny = Sy,
+  Nx = Sx + StepX,
+        F2 = F0 + Dy,
+  through_x({Nx, Ny}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F2, [{Nx, Ny}|P]).
+
+through_y({_, Ty}, {_, Ty}, _, _, _, P) -> P;
+through_y({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 >= 0 ->
+  Nx = Sx + StepX,
+  F1 = F0 - Dy,
+  Ny = Sy + StepY,
+        F2 = F1 + Dx,
+  through_y({Nx, Ny}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F2, [{Nx, Ny}|P]);
+through_y({Sx, Sy}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F0, P) when F0 < 0 ->
+  Nx = Sx,
+  Ny = Sy + StepY,
+        F2 = F0 + Dx,
+  through_y({Nx, Ny}, {Tx, Ty}, {StepX, StepY}, {Dx, Dy}, F2, [{Nx, Ny}|P]).

Task/Bitmap-Bresenhams-line-algorithm/Erlang/bitmap-bresenhams-line-algorithm-2.erl

@@ -0,0 +1,30 @@
+line({X0, Y0}, {X1, Y1}) ->
+  SX = step(X0, X1),
+  SY = step(Y0, Y1),
+  DX = abs(X1 - X0),
+  DY = abs(Y1 - Y0),
+  Err = DX - DY,
+  line({X0, Y0}, {X1, Y1}, {SX, SY}, {DX, DY}, Err, []).
+
+line({X1, Y1}, {X1, Y1}, _, _, _, Acc) ->
+  lists:reverse([{X1, Y1} | Acc]);
+line({X, Y}, {X1, Y1}, {SX, SY}, {DX, DY}, Err, Acc) ->
+  DE = 2 * Err,
+  {X0, Err0} = next_x(X, SX, DY, Err, DE),
+  {Y0, Err1} = next_y(Y, SY, DX, Err0, DE),
+  line({X0, Y0}, {X1, Y1}, {SX, SY}, {DX, DY}, Err1, [{X, Y} | Acc]).
+
+step(P0, P1) when P0 < P1 ->
+  1;
+step(_, _) ->
+  -1.
+
+next_x(X, SX, DY, E, DE) when DE > -DY ->
+  {X + SX, E - DY};
+next_x(X, _SX, _DY, E, _DE) ->
+  {X, E}.
+
+next_y(Y, SY, DX, E, DE) when DE < DX ->
+  {Y + SY, E + DX};
+next_y(Y, _SY, _DX, E, _DE) ->
+  {Y, E}.