Перелік використаних джерел

1. Теоретические основы радиолокации. Под ред. Ширмана Н. К. Учебное пособие для вузов. М., изд-во «Советское радио», 1970, 560с.

2. Теоретические основы радиолокации: Учебн. пособие для вузов / А. А. Коростелев, Н. Ф. Клюев, Ю. А. Мельник и др.; Под ред. В. Е. Дулевича. — 2-е изд., перераб. и доп. — М., Сов. радно, 1978. —608 с.

3. Сетевые спутниковые радионавигационные системы/В. С. Шебшаевич, П. П. Дмитриев, Н. В. Иванцевич и др.; Под ред. В. С. Шебшаевича.—2-е изд., перераб. и доп.—М: Радио и связь, 1993.—408 с: ил.

4. Корякин В. И., Хребтов А. А. От астролябии к навигационным комплексам, достроение, 1994.— 240 с.

5. Финкельштейн М. И. Основы радиолокации: Учебник для вузов. — 2-е изд., перераб. и доп. — М.: Радио и связь, 1983. — 536 с, ил.

6. Белоцерковский Г. Б. Основы радиолокации и радиолокационные устройства. М., «Сов. радио», 1975.

7. Е. П. Титов, Н. Л. Носов. Воздушная радионавигация. М., Государственное военной издательство, 255 с.

8. Богомолов А. Ф. Основы радиолокации. М., «Сов. радио», 1954. –338 с.

9. Боек Н. Использование лазеров для измерения расстояний. — «За­рубежная радиоэлектроника», 1964, № 3.

10. Буренин Н. И. Радиолокационные станции с синтезированной ан­тенной. М., «Сов. радио», 1972. – 328 с.

11. Вакин С. А., Шустов Л. Н. Основы радиопротиводействия и радио­технической разведки. М., «Сов. радио». 1968. – 236 с.

12. Васин В. В., Степанов Б. М. Справочник задачник по радиолокации М, «Сов. радио», 1977, 320 с.

13. Интегрированные системы ориентации и навигации для морских подвижных объектов/О.Н.Анучин, Г.И.Емельян-цсв/Под общей ред. чл.-кор. РАН В.Г.Пешехонова -СПб., 1999. - 357 с.

14. Воздушная навигация: справочник / А. М. Белкин, Н. Ф. Дронов, Ю. И. Рублев, Ю. Н. Саранский М.: Транспорт. 1988.

15. Колчинcкий В. Е., Мандуровский И. А., Константиновский М. И. Автономные допплеровские устрой­ства и системы навигации летательных аппаратов. Под ред. В. Е. Колчинского. М., «Сов. радио», 1975, 432 с.

16. Фрадкин С. Л. Основы теории и расчета радиолокационных приемников. – М.: Машиностроение. – 1969. – 199 с.

17. Волковский С. А., Оноприенко Е. И., Савинов В. А. Радиоустрой­ства систем управления летательными аппаратами. М., «Машино­строение», 1972.

18. Власов О. В., Смокин И. В. Радиооборудование летательных аппаратов. М.. Воениздат. 1971.

19. Буренин Н. И. Радиолокационные станции с синтезированной антенной. М.. «Сов. радио», 1972.

20. Ермолаев Г. И. Основы радиолокации и радиолокационное обо­рудование летательных аппаратов. М., «Машиностроение», 1967.

21. Коллинз, Харуэлл. Фазированная антенная решетка РЛС НАБ^И. — «Зарубежная радиоэлектроника», 1973, № 6.

22. Красноголовый Б. Н. Индикаторные устройства. Минск, «Вышэйшая школа», 1970.

23. Красноголовый Б. Н. Проектирование и расчет элементов инди­каторных устройств. Минск, «Вышэйшая школа», 1971.

24. Малышкин Е. А. Пассивная радиолокаци-я. М., Воениздат, 1961.

25. Мельник Ю. А., Стогов Г. В. Основы радиотехники и радиотех­нические устройства. М., «Сов. радио», 1973.

26. Мельник Ю. А. Самолетные радиолокационные бомбоприцелы и радиолокационные станции перехвата. Воениздат, 1954.

27. Вельтмандер П. В. Машинная графика: Учеб. пособие в 3-х книгах. Книга 2. Основные ал­горитмы/ Новосиб. ун-т. Новосибирск. 1997.  193 с, ил.

28. Шилдт Г. С++. Базовый курс: справочное пособие / Г. Шилдт. – СПб.: Вильямс, 2005. – 788 с.

29. Рекомендации по пользовательскому интерфейсу, Microsoft Press, редакция 1995.

30. Бойко В. В., Савинков В. М. Проектирование баз данных информационных систем. – М.: Финансы и статистика. - 1989. – 351 с.

31. Н. З. Елманова, С. П. Кошель. Введение в Borland C++ Builder. - М.: Диалог-МИФИ. - 1998.

32. Боэм Б. У. Инженерное проектирование программного обеспечения: Пер. с англ./Под ред А.А.Красилова. - М.: Радио и связь. 1985. - 512 с.

33. Гласс Р. Руководство по надежному программированию: Пер. с англ. -М.: Финансы и статистика, 1982. - 280 с.

34. Дж.Ульман. Основы систем баз данных. М: Финансы и статистика.1983

35. Тиори Т., Фрай Дж. Проектирование структур баз данных. В 2 кн., – М.: Мир, 1985. Кн. 1. – 287 с.: Кн. 2. – 320 с.

36. Цикритизис Д., Лоховски Ф. Модели данных. – М.: Финансы и статистика, 1999 г.

ДОДАТКИ

ДОДАТОК А

ЛІСТИНГ ПРОГРАМНОГО МОДУЛЮ

void ShowBestPoint(TPaintBox *Palitra, int XC, int YC)

{

//нарисовать окружность

Palitra->Canvas->Arc(XC - 4, YC - 4,

XC + 4, YC + 4,

XC + 4, YC,

XC + 4, YC);

Palitra->Canvas->MoveTo(XC, 0);

Palitra->Canvas->LineTo(XC, Palitra->Height);

Palitra->Canvas->MoveTo(0, YC);

Palitra->Canvas->LineTo(Palitra->Width, YC);

}

//входные параметры - X, Y, Alpha, где Alpha = 0 - 90 градусов

//выходные параметры - X1, Y1 (новые кординаты повернутой точки)

void __fastcall TurnPoint(double X, double Y, double AlphaPoint, double &X1, double &Y1)

{

long double r, f, f1;

long double sinus, cosinus;

AnsiString s;

sinus = 0.0;

cosinus = 0.0;

r = Hypot(X, Y); //вычислить вектор-радиус

SinCos(AlphaPoint / radian_value, sinus, cosinus);

//1й случай: если AlphaPoint = 0, то есть, поворот отсутствует

if(AlphaPoint == 0)

{

X1 = X;

Y1 = Y;

return;

}

if(X == 0 && Y == 0)

{

X1 = X;

Y1 = Y;

return;

}

if((X > 0) && (Y == 0))

{

X1 = r * cosinus;

Y1 = r * sinus;

return;

}

if((X == 0) && (Y > 0))

{

X1 = - r * sinus;

Y1 = r * cosinus;

return;

}

if((X < 0) && (Y == 0))

{

X1 = - r * cosinus;

Y1 = - r * sinus;

return;

}

if((X == 0) && (Y < 0))

{

X1 = r * sinus;

Y1 = - r * cosinus;

return;

}

if((X > 0) && (Y > 0))

{

f = ArcTan2(Y, X) * radian_value

f1 = f + AlphaPoint;

if(f1 <= 90)

{

SinCos(f1 / radian_value, sinus, cosinus);

X1 = r * cosinus;

Y1 = r * sinus;

}

else

{

SinCos((f1 - 90) / radian_value, sinus, cosinus);

X1 = - r * sinus;

Y1 = r * cosinus;

}

return;

}

if((X < 0) && (Y > 0))

{

X = - X; //делаем X положительным

f = ArcTan2(Y, X) * radian_value

f1 = f - AlphaPoint;

if(AlphaPoint <= f)

{

SinCos(f1 / radian_value, sinus, cosinus);

X1 = - r * cosinus;

Y1 = r * sinus;

}

else

{

f1 = AlphaPoint - f;

SinCos(f1 / radian_value, sinus, cosinus);

X1 = - r * cosinus;

Y1 = - r * sinus;

}

return;

}

//9й случай: поворот от точки в третьем квадранте

if((X < 0) && (Y < 0))

{

X = - X; //делаем X положительным

Y = - Y; //делаем Y положительным

f = ArcTan2(Y, X) * radian_value

f1 = f + AlphaPoint;

if(f1 <= 90)

{

SinCos(f1 / radian_value, sinus, cosinus);

X1 = - r * cosinus;

Y1 = - r * sinus;

}

else

{

SinCos((f1 - 90) / radian_value, sinus, cosinus);

X1 = r * sinus;

Y1 = - r * cosinus;

}

return;

}

if((X > 0) && (Y < 0))

{

Y = - Y; //делаем Y положительным

f = ArcTan2(Y, X) * radian_value

f1 = f - AlphaPoint;

if(f1 >= 0)

{

SinCos(f1 / radian_value, sinus, cosinus);

X1 = r * cosinus;

Y1 = - r * sinus;

}

else

{

f1 = - f1; //делаем угол f1 положительным

SinCos(f1 / radian_value, sinus, cosinus);

X1 = r * cosinus;

Y1 = r * sinus;

}

return;

}

}

//------------------------------------------------------------------------------

//входные параметры - X1, Y1, X2, Y2, Alpha, где Alpha = 0 - 90 градусов

//выходные параметры- X1Turn, Y1Turn, X2Turn, Y2Turn

void __fastcall TurnSegment

(double X1, double Y1, double X2, double Y2,

double AlphaSegment,

double &X1Turn, double &Y1Turn, double &X2Turn, double &Y2Turn)

{

TurnPoint(X1, Y1, AlphaSegment, X1Turn, Y1Turn);

TurnPoint(X2, Y2, AlphaSegment, X2Turn, Y2Turn);

}

//------------------------------------------------------------------------------

//входные параметры - X1, Y1, X2, Y2, Alpha, где Alpha = 0 - 90 градусов

void __fastcall ShowTurnedSegment

(TImage *Im, double X1, double Y1, double X2, double Y2,

double AlphaSegment, double XCenter, double YCenter)

{

double X1new, Y1new, X2new, Y2new;

TurnSegment(X1, Y1, X2, Y2, AlphaSegment, X1new, Y1new, X2new, Y2new);

Im->Canvas->Brush->Color = MyBorderColor;

Im->Canvas->MoveTo(XCenter + X1new, YCenter + Y1new);

Im->Canvas->LineTo(XCenter + X2new, YCenter + Y2new);

}

//------------------------------------------------------------------------------

//проведенных через точку XC, YC в координатах рисунка - Im

//с учетом поворота осей координат на угол AlphaAxis

void __fastcall Show4TurnedSegment

(TImage *Im, double X1, double Y1, double X2, double Y2,

double AlphaAxis, double XCenter, double YCenter)

{

ShowTurnedSegment(Im, X1, Y1, X2, Y2, AlphaAxis, XCenter, YCenter); //в 1ом сегменте

ShowTurnedSegment(Im, - X1, Y1, - X2, Y2, AlphaAxis, XCenter, YCenter); //в 2ом сегменте

ShowTurnedSegment(Im, - X1, - Y1, - X2, - Y2, AlphaAxis, XCenter, YCenter); //в 3ом сегменте

ShowTurnedSegment(Im, X1, - Y1, X2, - Y2, AlphaAxis, XCenter, YCenter); //в 4ом сегменте

}

//------------------------------------------------------------------------------

//функция возвращает средний цвет замкнутой области, ограниченной цветом MyBorderColor

void MiddleColorArea(TImage *Im, TImage *Im2, TColor MyBorderColor, int Xpoint, int Ypoint)

{

int X, Yup, Ydown, Ymid;

long double N = 0.0; //общее количество рассматриваемых точек

long double clMidRed = 0.0, clMidGreen = 0.0, clMidBlue = 0.0;//текущие значения средних цветов

TColor Red, Green, Blue; //целые значения средних цветов

////////////////////////////////////////////////////////////////////////////////

//находим общее количество обрабатываемых точек - N

for(int i = 0; i < 2; i++)

{

X = Xpoint;

Yup = Ydown = Ymid = Ypoint;

while(Im->Canvas->Pixels[X][Ymid] != MyBorderColor) //цикл всторону

{

while(Im->Canvas->Pixels[X][Yup] != MyBorderColor)//цикл по вертикали вверх

{

N++;

Yup--; //сдвинуться вверх

if(Yup == 0) break;

}

while(Im->Canvas->Pixels[X][Ydown] != MyBorderColor)//цикл по вертикали вниз

{

N++;

Ydown++; //сдвинуться вниз

if(Ydown > Im->Height) break;

}

i == 0 ? X-- : X++;

if((X == 0) || (X > Im->Width)) break;

Ymid = Ceil((Yup + Ydown) / 2);

Yup = Ydown = Ymid;

}

}

////////////////////////////////////////////////////////////////////////////

//находим средний цвет

for(int i = 0; i < 2; i++)

{

X = Xpoint;

Yup = Ydown = Ymid = Ypoint;

while(Im->Canvas->Pixels[X][Ymid] != MyBorderColor) //цикл всторону

{

while(Im->Canvas->Pixels[X][Yup] != MyBorderColor)//цикл по вертикали вверх

{

clMidRed += (Im->Canvas->Pixels[X][Yup] & 0x000000FF) / N;

clMidGreen += (Im->Canvas->Pixels[X][Yup] & 0x0000FF00) / N;

clMidBlue += (Im->Canvas->Pixels[X][Yup] & 0x00FF0000) / N;

Yup--; //сдвинуться вверх

if(Yup == 0) break;

}

while(Im->Canvas->Pixels[X][Ydown] != MyBorderColor)//цикл по вертикали вниз

{

clMidRed += (Im->Canvas->Pixels[X][Ydown] & 0x000000FF) / N;

clMidGreen += (Im->Canvas->Pixels[X][Ydown] & 0x0000FF00) / N;

clMidBlue += (Im->Canvas->Pixels[X][Ydown] & 0x00FF0000) / N;

Ydown++; //сдвинуться вниз

if(Ydown > Im->Height) break;

}

i == 0 ? X-- : X++;

if((X == 0) || (X > Im->Width)) break;

Ymid = Ceil((Yup + Ydown) / 2);

Yup = Ydown = Ymid;

}

}

////////////////////////////////////////////////////////////////////////////////

//получить целые средние цвета

Red = (TColor)clMidRed;

Green = (TColor)clMidGreen >> 8;

Blue = (TColor)clMidBlue >> 16;

//закрасить средним общим цветом

Im2->Canvas->Brush->Color = (TColor)(0 << 24) | (Blue << 16) | (Green << 8) | Red;

Im2->Canvas->FillRect(Rect(0,0,Im2->Width, Im2->Height));

}

//------------------------------------------------------------------------------

//поворачивает эллипс на Alpha градусов против часовой стрелки

void __fastcall EllipseA(TImage *Im, int X1, int Y1, int X2, int Y2, double Alpha, TImage *Im2)

{

double XC, YC; //координаты центра эллипса

double xnext, ynext;//координаты следующей точки в новой системе координат

double r; //вектор-радиус до точки эллипса

double a, b; //полуоси эллипса

double aa; //квадрат горизонтальной полуоси

double x, y; //текущие координаты эллипса в новой системе координат

long double sinus, cosinus;

//находим полуоси эллипса (чтоб им сдохнуть)

a = Ceil((X2 - X1) / 2);

b = Ceil((Y2 - Y1) / 2);

//находим квадраты полуосей

aa = a * a;

//находим координаты центра эллипса (мать его)

XC = Ceil((X1 + X2) / 2); //округляем до целого

YC = Ceil((Y1 + Y2) / 2); //округляем до целого

//теперь считаем, что в этом центре новая система координат

//значения для первой точки

x = 0; y = b;

for(xnext = 1; xnext <= a; xnext++)

{

ynext = Ceil((b / a) * sqrt(aa - xnext * xnext));

if(y != ynext)

{

Show4TurnedSegment(Im, x, y, xnext, ynext, Alpha, XC, YC);

//переход на следующую точку

x = xnext; y = ynext;

}

}

//закрасить точки пересечения с осями

SinCos(- Alpha / radian_value, sinus, cosinus);

Im->Canvas->Pixels[XC + a * cosinus][YC - a * sinus] = MyBorderColor; // Im->Canvas->Pen->Color;

Im->Canvas->Pixels[XC - b * sinus][YC - b * cosinus] = MyBorderColor; // Im->Canvas->Pen->Color;

Im->Canvas->Pixels[XC - a * cosinus][YC + a * sinus] = MyBorderColor; // Im->Canvas->Pen->Color;

Im->Canvas->Pixels[XC + b * sinus][YC + b * cosinus] = MyBorderColor; // Im->Canvas->Pen->Color;

//вычислить средний цвет внутри эллипса и закрасить этим цветом Im2

MiddleColorArea(Im, Im2, MyBorderColor, XC, YC);

Im = 0; //закрыть (обнулить указатель на рисунок)

Im2 = 0;

}

//------------------------------------------------------------------------------

//возвращает цвет пиксела, накладывая цвет заливки на исходный цвет пиксела

//учитывает процент прозрачности цвета заливки (деленный на 100)

TColor GetPixelColor(TColor BackColor, TColor FillColor, double Transparency, double TransparencyMinus)

{

unsigned char BackRed, BackGreen, BackBlue, BackPalitra, FillRed, FillGreen, FillBlue;

//разложить на составляющие цвета

BackRed = BackColor & 0x000000FF;

BackGreen = (BackColor & 0x0000FF00) >> 8;

BackBlue = (BackColor & 0x00FF0000) >> 16;

BackPalitra = (BackColor & 0xFF000000) >> 24;

FillRed = FillColor & 0x000000FF;

FillGreen = (FillColor & 0x0000FF00) >> 8;

FillBlue = (FillColor & 0x00FF0000) >> 16;

//учесть прозрачность для фона: фоновый рисунок виден на величину прозрачности

BackRed = BackRed * Transparency;

BackGreen = BackGreen * Transparency;

BackBlue = BackBlue * Transparency;

//учесть прозрачность для заливки: заливка видна на остаток от прозрачности

FillRed = FillRed * TransparencyMinus;

FillGreen = FillGreen * TransparencyMinus;

FillBlue = FillBlue * TransparencyMinus;

return (TColor)((BackPalitra << 24) | ((BackBlue + FillBlue) << 16) | ((BackGreen + FillGreen) << 8) | (BackRed + FillRed));

}

//------------------------------------------------------------------------------

//возвращает расстояние в пикселах от заданной точки до точки с цветом MyBorderColor

// по вертикали вверх или вниз по флагу - Flag (1 - вверх, 2 - вниз)

//Xstart, Ystart - абсолютные координаты на рисунке

int GetPixelsCount(TImage *Im, int Xstart, int Ystart, TColor MyBorderColor, int Flag)

{

int Count = 0;

if(Flag == 1)

while(Im->Canvas->Pixels[Xstart][Ystart] != MyBorderColor)

{

Count++;

Ystart--;

}

else

while(Im->Canvas->Pixels[Xstart][Ystart] != MyBorderColor)

{

Count++;

Ystart++;

}

return Count;

}

//заполняет область выделения цветом FillColor, пока не наткнется на цвет границы MyBorderColor,

//начиная от точки Xpoint, Ypoint внутри области выделения

//Transparention - процент прозрачности (от 0 до 100)

void FillAreaTransparent(TImage *Im, Graphics::TBitmap *BackIm, int Xpoint, int Ypoint, TColor FillColor, TColor BorderColor, int Transparency)

{

int X, Yup, Ydown, Ymid;

double TransFactor = double(Transparency) / 100.00;

double TransFactorMinus = 1 - TransFactor;

int Count;

for(int i = 0; i < 2; i++)

{

X = Xpoint;

Yup = Ydown = Ymid = Ypoint;

while(Im->Canvas->Pixels[X][Ymid] != BorderColor) //цикл всторону

{

Count = GetPixelsCount(Im, X, Yup, BorderColor, 1); //длина отрезка вверх

for(int h = 0; h < Count; h++)

{

Im->Canvas->Pixels[X][Yup] = GetPixelColor(BackIm->Canvas->Pixels[X][Yup], FillColor, TransFactor, TransFactorMinus);

Yup--; //сдвинуться вверх

if(Yup == 0) break;

}

Count = GetPixelsCount(Im, X, Ydown, BorderColor, 2); //длина отрезка вниз

for(int h = 0; h < Count; h++)

{

Im->Canvas->Pixels[X][Ydown] = GetPixelColor(BackIm->Canvas->Pixels[X][Ydown], FillColor, TransFactor, TransFactorMinus);

Ydown++; //сдвинуться вниз

if(Ydown > Im->Height) break;

}

i == 0 ? X-- : X++;

if((X == 0) || (X > Im->Width)) break;

Ymid = Ceil((Yup + Ydown) / 2);

Yup = Ydown = Ymid;

}

}

}

//------------------------------------------------------------------------------

//находит средний цвет двух пикселей

TColor GetMiddlePixel(TColor Pixel_11, TColor Pixel_12, TColor Pixel_21, TColor Pixel_22)

{

unsigned char Red_11, Green_11, Blue_11,

Red_12, Green_12, Blue_12,

Red_21, Green_21, Blue_21,

Red_22, Green_22, Blue_22,

MidRed, MidGreen, MidBlue,

Palitra;

//разложить на составляющие цвета

Red_11 = Pixel_11 & 0x000000FF;

Green_11 = (Pixel_11 & 0x0000FF00) >> 8;

Blue_11 = (Pixel_11 & 0x00FF0000) >> 16;

Palitra = (Pixel_11 & 0xFF000000) >> 24;

Red_12 = Pixel_12 & 0x000000FF;

Green_12 = (Pixel_12 & 0x0000FF00) >> 8;

Blue_12 = (Pixel_12 & 0x00FF0000) >> 16;

Red_21 = Pixel_21 & 0x000000FF;

Green_21 = (Pixel_21 & 0x0000FF00) >> 8;

Blue_21 = (Pixel_21 & 0x00FF0000) >> 16;

Red_22 = Pixel_22 & 0x000000FF;

Green_22 = (Pixel_22 & 0x0000FF00) >> 8;

Blue_22 = (Pixel_22 & 0x00FF0000) >> 16;

//определить средние составляющие

MidRed = (Red_11 + Red_12 + Red_21 + Red_22) / 4.0;

MidGreen = (Green_11 + Green_12 + Green_21 + Green_22) / 4.0;

MidBlue = (Blue_11 + Blue_12 + Blue_21 + Blue_22) / 4.0;

return (TColor)((Palitra << 24) | (MidBlue << 16) | (MidGreen << 8) | MidRed);

}

//размывает область рисунка - Im, вокруг точки - XC, YC, радиусом - Radius,

void Smooth(TImage *Im, TColor FillColor, double Radius, int Xpoint, int Ypoint, int Transparency)

{

int X, Yup, Ydown, Ymid, HeightCircle, HeightCircleRandom;

int Xplus1, Yupplus1, Ydownplus1;

double RadiusQrt;

int Count;

TColor MidColor, SmoothColor;

double TransFactor = double(Transparency) / 100.00;

double TransFactorMinus = 1 - TransFactor;

RadiusQrt = Radius * Radius;

for(int i = 0; i < 2; i++)

{

X = Xpoint;

Yup = Ydown = Ymid = Ypoint;

for(int r = 0; r < Radius; r++) //цикл всторону

{

Xplus1 = X + 1;

HeightCircle = sqrt( RadiusQrt - r * r);

//Randomize();

HeightCircleRandom = RandomRange(0, HeightCircle);

for(int h = 0; h < HeightCircleRandom; h++)

{

Yupplus1 = Yup + 1;

MidColor = GetMiddlePixel(Im->Canvas->Pixels[X][Yup],

Im->Canvas->Pixels[Xplus1][Yup],

Im->Canvas->Pixels[X][Yupplus1],

Im->Canvas->Pixels[Xplus1][Yupplus1]);

SmoothColor = GetPixelColor(MidColor, FillColor, TransFactor, TransFactorMinus);

Im->Canvas->Pixels[X][Yup] = SmoothColor;

Im->Canvas->Pixels[Xplus1][Yup] = SmoothColor;

Im->Canvas->Pixels[X][Yupplus1] = SmoothColor;

Im->Canvas->Pixels[Xplus1][Yupplus1] = SmoothColor;

Yup--; //сдвинуться вверх

Yup--; //сдвинуться вверх

if(Yup == 0 || Yup < 0) break;

}

//Randomize();

HeightCircleRandom = RandomRange(0, HeightCircle);

for(int h = 0; h < HeightCircleRandom; h++)

{

Ydownplus1 = Ydown + 1;

MidColor = GetMiddlePixel(Im->Canvas->Pixels[X][Ydown],

Im->Canvas->Pixels[Xplus1][Ydown],

Im->Canvas->Pixels[X][Ydownplus1],

Im->Canvas->Pixels[Xplus1][Ydownplus1]);

SmoothColor = GetPixelColor(MidColor, FillColor, TransFactor, TransFactorMinus);

Im->Canvas->Pixels[X][Ydown] = SmoothColor;

Im->Canvas->Pixels[Xplus1][Ydown] = SmoothColor;

Im->Canvas->Pixels[X][Ydownplus1] = SmoothColor;

Im->Canvas->Pixels[Xplus1][Ydownplus1] = SmoothColor;

Ydown++; //сдвинуться вниз

Ydown++; //сдвинуться вниз

if(Ydown > Im->Height) break;

}

i == 0 ? X-- : X++;

if((X == 0) || (X > Im->Width)) break;

Ymid = Ceil((Yup + Ydown) / 2);

Yup = Ydown = Ymid;

}

}

}