{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside minSize / maxSize.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractSizeEx(var ATPA: T2DPointArray; minSize, maxSize: Integer); callconv
var
  h, i, l, s: Integer;
  z: TIntegerArray;
begin
  h := High(ATPA);
  if (h > -1) then
    if ((minSize <= maxSize) and (maxSize > 0)) then
    begin
      for i := 0 to h do
      begin
        s := Length(ATPA[i]);
        if ((s >= minSize) and (s <= maxSize)) then
        begin
          l := Length(z);
          SetLength(z, (l + 1));
          z[l] := i;
        end;
      end;
      ExtractIndexesATPA(ATPA, z);
    end else
      SetLength(ATPA, 0);
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside size.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractSize(var ATPA: T2DPointArray; size: Integer); callconv
begin
  ATPAExtractSizeEx(ATPA, size, size);
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside minSize.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractSizeMin(var ATPA: T2DPointArray; minSize: Integer); callconv
var
  h, i, l: Integer;
  z: TIntegerArray;
begin
  h := High(ATPA);
  if (h > -1) then
  begin
    for i := 0 to h do
      if (Length(ATPA[i]) >= minSize) then
      begin
        l := Length(z);
        SetLength(z, (l + 1));
        z[l] := i;
      end;
    ExtractIndexesATPA(ATPA, z);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside maxSize.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractSizeMax(var ATPA: T2DPointArray; maxSize: Integer); callconv
var
  h, i, l: Integer;
  z: TIntegerArray;
begin
  h := High(ATPA);
  if (h > -1) then
  begin
    for i := 0 to h do
      if (Length(ATPA[i]) <= maxSize) then
      begin
        l := Length(z);
        SetLength(z, (l + 1));
        z[l] := i;
      end;
    ExtractIndexesATPA(ATPA, z);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within minSize / maxSize.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterSizeEx(var ATPA: T2DPointArray; minSize, maxSize: Integer); callconv
var
  h, i, l, s: Integer;
  z: TIntegerArray;
begin
  h := High(ATPA);
  if (h > -1) then
  begin
    if (minSize <= maxSize) then
    begin
      for i := 0 to h do
      begin
        s := Length(ATPA[i]);
        if ((s < minSize) or (s > maxSize)) then
        begin
          l := Length(z);
          SetLength(z, (l + 1));
          z[l] := i;
        end;
      end;
      ExtractIndexesATPA(ATPA, z);
    end;
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within size.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterSize(var ATPA: T2DPointArray; size: Integer); callconv
begin
  ATPAFilterSizeEx(ATPA, size, size);
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within minSize.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterSizeMin(var ATPA: T2DPointArray; minSize: Integer); callconv
var
  h, i, l: Integer;
  z: TIntegerArray;
begin
  h := High(ATPA);
  if (h > -1) then
  begin
    for i := 0 to h do
      if (Length(ATPA[i]) < minSize) then
      begin
        l := Length(z);
        SetLength(z, (l + 1));
        z[l] := i;
      end;
    ExtractIndexesATPA(ATPA, z);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within maxSize.
 @note: Based on Length()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterSizeMax(var ATPA: T2DPointArray; maxSize: Integer); callconv
var
  h, i, l: Integer;
  z: TIntegerArray;
begin
  h := High(ATPA);
  if (h > -1) then
  begin
    for i := 0 to h do
      if (Length(ATPA[i]) > maxSize) then
      begin
        l := Length(z);
        SetLength(z, (l + 1));
        z[l] := i;
      end;
    ExtractIndexesATPA(ATPA, z);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside minDensity / maxDensity.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDensityEx(var ATPA: T2DPointArray; minDensity, maxDensity: Extended); callconv
var
  h, i: Integer;
  d: Extended;
  z: TIntegerArray;
begin
  h := High(ATPA);
  if (h > -1) then
  begin
    if ((minDensity <= maxDensity) and (maxDensity > 0.0)) then
    for i := h downto 0 do
    begin
      d := TPADensity(ATPA[i]);
      if ((d >= minDensity) and (d <= maxDensity)) then
      begin
        l := Length(z);
        SetLength(z, (l + 1));
        z[l] := i;
      end;
    end;
    ExtractIndexesATPA(ATPA, z);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside density.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDensity(var ATPA: T2DPointArray; density: Extended); callconv
begin
  ATPAExtractDensityEx(ATPA, density, density);
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside minDensity.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDensityMin(var ATPA: T2DPointArray; minDensity: Extended); callconv
var
  h, i: Integer;
  d: Extended;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    d := TPADensity(ATPA[i]);
    if (d < minDensity) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside maxDensity.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDensityMax(var ATPA: T2DPointArray; maxDensity: Extended); callconv
var
  h, i: Integer;
  d: Extended;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    d := TPADensity(ATPA[i]);
    if (d > maxDensity) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within minDensity / maxDensity.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDensityEx(var ATPA: T2DPointArray; minDensity, maxDensity: Extended); callconv
var
  h, i: Integer;
  d: Extended;
begin
  if (minDensity > maxDensity) then
    Exit;
  h := High(ATPA);
  for i := h downto 0 do
  begin
    d := TPADensity(ATPA[i]);
    if ((d >= minDensity) and (d <= maxDensity)) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within density.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDensity(var ATPA: T2DPointArray; density: Extended); callconv
begin
  ATPAFilterDensityEx(ATPA, density, density);
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within minDensity.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDensityMin(var ATPA: T2DPointArray; minDensity: Extended); callconv
var
  h, i: Integer;
  d: Extended;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    d := TPADensity(ATPA[i]);
    if (d >= minDensity) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within maxDensity.
 @note: Based on TPADensity()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDensityMax(var ATPA: T2DPointArray; maxDensity: Extended); callconv
var
  h, i: Integer;
  d: Extended;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    d := TPADensity(ATPA[i]);
    if (d <= maxDensity) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside minimum / maximum dimensions.
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDimensionsEx(var ATPA: T2DPointArray; minWidth, minHeight, maxWidth, maxHeight: Integer); callconv
var
  width, height, h, i: Integer;
begin
  if ((minWidth > maxWidth) or (minHeight > maxHeight)) then
    Exit;
  h := High(ATPA);
  for i := h downto 0 do
  begin
    TPADimensions(ATPA[i], width, height);
    if ((width < minWidth) or (width > maxWidth) or (height < minHeight) or (height > maxHeight)) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside dimensions (width / height).
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDimensions(var ATPA: T2DPointArray; width, height: Integer); callconv
begin
  ATPAExtractDimensionsEx(ATPA, width, height, width, height);
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside minimum dimensions.
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDimensionsMin(var ATPA: T2DPointArray; minWidth, minHeight: Integer); callconv
var
  width, height, h, i: Integer;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    TPADimensions(ATPA[i], width, height);
    if ((width < minWidth) or (height < minHeight)) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall outside maximum dimensions.
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAExtractDimensionsMax(var ATPA: T2DPointArray; maxWidth, maxHeight: Integer); callconv
var
  width, height, h, i: Integer;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    TPADimensions(ATPA[i], width, height);
    if ((width > maxWidth) or (height > maxHeight)) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within minimum / maximum dimensions.
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDimensionsEx(var ATPA: T2DPointArray; minWidth, minHeight, maxWidth, maxHeight: Integer); callconv
var
  width, height, h, i: Integer;
begin
  if ((minWidth > maxWidth) or (minHeight > maxHeight)) then
    Exit;
  h := High(ATPA);
  for i := h downto 0 do
  begin
    TPADimensions(ATPA[i], width, height);
    if ((width >= minWidth) and (width <= maxWidth) or (height >= minHeight) and (height <= maxHeight)) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within dimensions (width / height).
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDimensions(var ATPA: T2DPointArray; width, height: Integer); callconv
begin
  ATPAFilterDimensionsEx(ATPA, width, height, width, height);
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within minimum dimensions.
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDimensionsMin(var ATPA: T2DPointArray; minWidth, minHeight: Integer); callconv
var
  width, height, h, i: Integer;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    TPADimensions(ATPA[i], width, height);
    if ((width >= minWidth) and (height >= minHeight)) then
      Delete(ATPA, i, 1);
  end;
end;

{==============================================================================]
 @action: Removes all TPAs from ATPA that fall within maximum dimensions.
 @note: Based on TPADimensions()
 @contributors: Janilabo, slacky
[==============================================================================}
procedure ATPAFilterDimensionsMax(var ATPA: T2DPointArray; maxWidth, maxHeight: Integer); callconv
var
  width, height, h, i: Integer;
begin
  h := High(ATPA);
  for i := h downto 0 do
  begin
    TPADimensions(ATPA[i], width, height);
    if ((width <= maxWidth) and (height <= maxHeight)) then
      Delete(ATPA, i, 1);
  end;
end;