Сглаживание

Delphi , Графика и Игры , Изображения

Оформил: DeeCo
Автор: http://www.swissdelphicenter.ch

{ 
Originally written by Horst Kniebusch, modified by alioth to make it(alot) faster. 
}

 procedure Antialiasing(Image: TImage; Percent: Integer);
 type
   TRGBTripleArray = array[0..32767] of TRGBTriple;
   PRGBTripleArray = ^TRGBTripleArray;
 var
   SL, SL2: PRGBTripleArray;
   l, m, p: Integer;
   R, G, B: TColor;
   R1, R2, G1, G2, B1, B2: Byte;
 begin
   with Image.Canvas do
   begin
     Brush.Style  := bsClear;
     Pixels[1, 1] := Pixels[1, 1];
     for l := 0 to Image.Height - 1 do
     begin
       SL := Image.Picture.Bitmap.ScanLine[l];
       for p := 1 to Image.Width - 1 do
       begin
         R1 := SL[p].rgbtRed;
         G1 := SL[p].rgbtGreen;
         B1 := SL[p].rgbtBlue;

         // Left 
        if (p < 1) then m := Image.Width
         else
           m := p - 1;
         R2 := SL[m].rgbtRed;
         G2 := SL[m].rgbtGreen;
         B2 := SL[m].rgbtBlue;
         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));
           SL[m].rgbtRed := R;
           SL[m].rgbtGreen := G;
           SL[m].rgbtBlue := B;
         end;

         //Right 
        if (p > Image.Width - 2) then m := 0
         else
           m := p + 1;
         R2 := SL[m].rgbtRed;
         G2 := SL[m].rgbtGreen;
         B2 := SL[m].rgbtBlue;
         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));
           SL[m].rgbtRed := R;
           SL[m].rgbtGreen := G;
           SL[m].rgbtBlue := B;
         end;

         if (l < 1) then m := Image.Height - 1
         else
           m := l - 1;
         //Over 
        SL2 := Image.Picture.Bitmap.ScanLine[m];
         R2  := SL2[p].rgbtRed;
         G2  := SL2[p].rgbtGreen;
         B2  := SL2[p].rgbtBlue;
         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));
           SL2[p].rgbtRed := R;
           SL2[p].rgbtGreen := G;
           SL2[p].rgbtBlue := B;
         end;

         if (l > Image.Height - 2) then m := 0
         else
           m := l + 1;
         //Under 
        SL2 := Image.Picture.Bitmap.ScanLine[m];
         R2  := SL2[p].rgbtRed;
         G2  := SL2[p].rgbtGreen;
         B2  := SL2[p].rgbtBlue;
         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));
           SL2[p].rgbtRed := R;
           SL2[p].rgbtGreen := G;
           SL2[p].rgbtBlue := B;
         end;
       end;
     end;
   end;
 end;


 //Example: 
procedure TForm1.Button1Click(Sender: TObject);
 begin
   Antialiasing(Image1, 80);
 end;

Перевод контента на русский язык:

Программа на языке Pascal для Delphi, которая реализует простой алгоритм антиалиасинга для изображения. Процедура Antialiasing принимает в себя изображение и процентное значение как входные параметры, и она пытается уменьшить контрастность краев изображения, смешивая цвета соседних пикселей.

Алгоритм работает следующим образом:

1. Он проходит по каждому пикселю в изображении.
2. Для каждого пикселя он проверяет, есть ли рядом пиксели с другими цветами (красный, зеленый или синий). Если есть, то он рассчитывает значение смешанного цвета для этого пикселя, среднеарифметически суммируя соседние цвета.

Смешивание происходит по следующей формуле:

R := Round(R1 + (R2 - R1) * 50 / (Percent + 50));
G := Round(G1 + (G2 - G1) * 50 / (Percent + 50));
B := Round(B1 + (B2 - B1) * 50 / (Percent + 50));

Где R, G и B - значения смешанных цветов, R1, G1 и B1 - оригинальные цвета пикселя, R2, G2 и B2 - цвета соседних пикселей, а Percent - значение, контролирующее степень смешивания (выше значения результатит в более сильном смешивании).

Код также обрабатывает краевые случаи, проверяя, является ли текущий пиксель на границе изображения. Если да, то он использует противоположную границу изображения как соседний пиксель.

Процедура Antialiasing вызывается из обработчика события Button1Click, который передает в процедуру изображение и процентное значение (80 в этом случае).

Хотя этот алгоритм может помочь уменьшить контрастность некоторых краев, он не является сложным антиалиасинговым техникой. Для болееadvanced антиалиасинга вы можете рассмотреть использование библиотеки или фреймворка, который предоставляет встроенную поддержку для этого функционала.

Некоторые предложения по улучшению:

1. Используйте более robust формулу смешивания, учитывающую расстояние между пикселями и разницу цветов.
2. Рассмотрите использование более эффективной структуры данных для хранения пикселей изображения, например, TBitmap с свойством ScanLine.
3. Добавьте обработку ошибок для случаев, когда изображение является недопустимым или процентное значение выходит за пределы диапазона.
4. Рассмотрите добавление опций для контроля силы смешивания и количества соседних пикселей, которые учитываются.

В целом, это код предоставляет простой пример реализации антиалиасинга в Delphi, но он может не быть пригоден для использования в производственной среде без дальнейшей доработки.

В статье представлен алгоритм сглаживания для изображений на языке Delphi, который выполняет сглаживание влево, вправо, сверху и снизу.

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

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

:: Главная :: Изображения ::