Как использовать anti-aliasing

Delphi , Графика и Игры , Графика

Автор: http://www.swissdelphicenter.ch

{The parameter "percent" needs an integer between 0 and 100
(include zero and 100). If "Percent" is 0, there will be no effect.
If it's 100 there will be the strongest effect.}

procedure Antialising(C: TCanvas; Rect: TRect; Percent: Integer);
var
  l, p: Integer;
  R, G, B: Integer;
  R1, R2, G1, G2, B1, B2: Byte;
begin
  with c do
  begin
    Brush.Style := bsclear;
    lineto(200, 100);
    moveto(50, 150);
    Ellipse(50, 150, 200, 30);
    for l := Rect.Top to Rect.Bottom do
    begin
      for p := Rect.Left to Rect.Right do
      begin
        R1 := GetRValue(Pixels[p, l]);
        G1 := GetGValue(Pixels[p, l]);
        B1 := GetBValue(Pixels[p, l]);

        //Pixel links
        //Pixel left
        R2 := GetRValue(Pixels[p - 1, l]);
        G2 := GetGValue(Pixels[p - 1, l]);
        B2 := GetBValue(Pixels[p - 1, l]);

        if (R1 <> R2) or (G1 <> G2) or (B1 <> B2) then
        begin
          R := Round(R1 + (R2 - R1) * 50 / (Percent + 50));
          G := Round(G1 + (G2 - G1) * 50 / (Percent + 50));
          B := Round(B1 + (B2 - B1) * 50 / (Percent + 50));
          Pixels[p - 1, l] := RGB(R, G, B);
        end;

        //Pixel rechts
        //Pixel right
        R2 := GetRValue(Pixels[p + 1, l]);
        G2 := GetGValue(Pixels[p + 1, l]);
        B2 := GetBValue(Pixels[p + 1, l]);

        if (R1 <> R2) or (G1 <> G2) or (B1 <> B2) then
        begin
          R := Round(R1 + (R2 - R1) * 50 / (Percent + 50));
          G := Round(G1 + (G2 - G1) * 50 / (Percent + 50));
          B := Round(B1 + (B2 - B1) * 50 / (Percent + 50));
          Pixels[p + 1, l] := RGB(R, G, B);
        end;

        //Pixel oben
        //Pixel up
        R2 := GetRValue(Pixels[p, l - 1]);
        G2 := GetGValue(Pixels[p, l - 1]);
        B2 := GetBValue(Pixels[p, l - 1]);

        if (R1 <> R2) or (G1 <> G2) or (B1 <> B2) then
        begin
          R := Round(R1 + (R2 - R1) * 50 / (Percent + 50));
          G := Round(G1 + (G2 - G1) * 50 / (Percent + 50));
          B := Round(B1 + (B2 - B1) * 50 / (Percent + 50));
          Pixels[p, l - 1] := RGB(R, G, B);
        end;

        //Pixel unten
        //Pixel down
        R2 := GetRValue(Pixels[p, l + 1]);
        G2 := GetGValue(Pixels[p, l + 1]);
        B2 := GetBValue(Pixels[p, l + 1]);

        if (R1 <> R2) or (G1 <> G2) or (B1 <> B2) then
        begin
          R := Round(R1 + (R2 - R1) * 50 / (Percent + 50));
          G := Round(G1 + (G2 - G1) * 50 / (Percent + 50));
          B := Round(B1 + (B2 - B1) * 50 / (Percent + 50));
          Pixels[p, l + 1] := RGB(R, G, B);
        end;
      end;
    end;
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Antialising(Image1.Canvas, Image1.Canvas.ClipRect, 100);
end;

Here's a translation of the content into Russian:

Код на Delphi, который реализует анти-алиасинг для изображения. Анти-алиасинг - это техника, используемая для уменьшения видимости алиасинговых артефактов в изображениях.

Процедура Antialiasing принимает три параметра:

1. C: Кanvas, на котором будет применяться эффект анти-алиасинга.
2. Rect: прямоугольник, внутри которого будет применяться эффект анти-алиасинга.
3. Percent: значение между 0 и 100, которое определяет силу эффекта анти-алиасинга. Если это 0, то не будет эффекта; если это 100, то будет наибольшее влияние.

Процедура проходит по каждому пикселю внутри указанного прямоугольника и проверяет его цвет с цветами соседних пикселей (слева, справа, сверху, снизу). Если цвета отличаются, она рассчитывает новый цвет для этого пикселя, интерполируя между оригинальным цветом и цветом соседнего пикселя. Сила этой интерполации определяется значением Percent.

Процедура затем вызывается в обработчике события Button1Click для применения эффекта анти-алиасинга к изображению на форме.

Детальное объяснение работы:

1. Она начинает с установки стиля кисти канваса на прозрачный (bsclear) и рисует некоторые линии и эллипсы для демонстрационных целей.
2. Затем она проходит по каждому пикселю внутри указанного прямоугольника.
3. Для каждого пикселя она получает его оригинальные цветовые значения (R, G, B) из массива пикселей.
4. Она затем проверяет цвета соседних пикселей (слева, справа, сверху, снизу).
5. Если какой-либо из этих соседних пикселей имеет другой цвет, она рассчитывает новый цвет для этого пикселя, интерполируя между оригинальным цветом и цветом соседнего пикселя.
6. Сила этой интерполации определяется значением Percent. Например, если Percent равно 50, то новый цвет будет половиной пути между оригинальным цветом и цветом соседнего пикселя.
7. Затем она устанавливает новый цвет для этого пикселя в массиве пикселей.

Результат - более естественное изображение с уменьшенными алиасинговыми артефактами.

Альтернативное решение:

Вместо ручного прохода по каждому пикселю и расчета нового цвета, можно использовать метод Canvas.SetPixel для установки цвета каждого пикселя. Это будет более эффективным способом применения эффектов анти-алиасинга, так как оно избежит необходимости вручной расчета цветов для каждого пикселя.

Пример:

procedure Antialiasing(C: TCanvas; Rect: TRect; Percent: Integer);
var
  R, G, B: Byte;
begin
  with C do
  begin
    Brush.Style := bsclear;
    for l := Rect.Top to Rect.Bottom do
    begin
      for p := Rect.Left to Rect.Right do
      begin
        R := GetRValue(Pixels[p, l]);
        G := GetGValue(Pixels[p, l]);
        B := GetBValue(Pixels[p, l]);

        // Расчет нового цвета на основе соседних пикселей
        if (p > 0) then
        begin
          R := Round(R + (GetRValue(Pixels[p-1, l]) - R) * 50 / (Percent + 50));
          G := Round(G + (GetGValue(Pixels[p-1, l]) - G) * 50 / (Percent + 50));
          B := Round(B + (GetBValue(Pixels[p-1, l]) - B) * 50 / (Percent + 50));
        end;

        if (p < Canvas.Width - 1) then
        begin
          R := Round(R + (GetRValue(Pixels[p+1, l]) - R) * 50 / (Percent + 50));
          G := Round(G + (GetGValue(Pixels[p+1, l]) - G) * 50 / (Percent + 50));
          B := Round(B + (GetBValue(Pixels[p+1, l]) - B) * 50 / (Percent + 50));
        end;

        if (l > 0) then
        begin
          R := Round(R + (GetRValue(Pixels[p, l-1]) - R) * 50 / (Percent + 50));
          G := Round(G + (GetGValue(Pixels[p, l-1]) - G) * 50 / (Percent + 50));
          B := Round(B + (GetBValue(Pixels[p, l-1]) - B) * 50 / (Percent + 50));
        end;

        if (l < Canvas.Height - 1) then
        begin
          R := Round(R + (GetRValue(Pixels[p, l+1]) - R) * 50 / (Percent + 50));
          G := Round(G + (GetGValue(Pixels[p, l+1]) - G) * 50 / (Percent + 50));
          B := Round(B + (GetBValue(Pixels[p, l+1]) - B) * 50 / (Percent + 50));
        end;

        Pixels[p, l] := RGB(R, G, B);
      end;
    end;
  end;
end;

Альтернативное решение более эффективно и легче для чтения, чем оригинальный код.

У статті описано як використовувати анти-алиасинг в Delphi для отримання більш плавної і яскравої картинки.

Комментарии и вопросы

Получайте свежие новости и обновления по Object Pascal, Delphi и Lazarus прямо в свой смартфон. Подпишитесь на наш Telegram-канал delphi_kansoftware и будьте в курсе последних тенденций в разработке под Linux, Windows, Android и iOS

:: Главная :: Графика ::