градиент

[trosh]

Пытаюсь сделать градиент, чтобы:
Верхний левый угол - белый (255, 255, 255),
Верхний правый угол – красный (255, 0, 0),
Нижний левый угол – зеленый (0, 0, 255),
Нижний правый угол – черный (0, 0, 0)

Но что-то я с алгоритмом ошибаюсь 

Код:

                 
void __fastcall TForm1::PaintBox1Paint(TObject *Sender)
{
Graphics::TBitmap *Gradient = new Graphics::TBitmap();
Gradient->Height = 220;
Gradient->Width = 220;
int h=Gradient->Height;
int w=Gradient->Width;

struct tRGB{int R,G,B;};

tRGB    Color_W,        Color_H;

        Color_W.R=255,  Color_H.R=0,
        Color_W.G=255,  Color_H.G=0,
        Color_W.B=255,  Color_H.B=0;

for(int i_w=0;i_w<h+1;i_w++)
  {
   for(int i_h=0;i_h<h+1;i_h++)
    {
     for(int iW=0;iW<w+1;iW++)
       {
        Color_W.R-iW;
        Color_W.G-iW;
        Color_W.B-iW;

        for(int iH=0;iH<w+1;iH++)
          {
           Color_H.R+iH;
           Color_H.G+iH;
           Color_H.B+iH;
          }
       }

   Gradient->Canvas->Pixels[i_w][i_h]=TColor(RGB(Color_W.R+i_w,
                                                 Color_W.G+i_w,
                                                 Color_W.B+i_w));
    }
  }

PaintBox1->Canvas->Draw(0,0,Gradient);

delete Gradient;
}
]

Как лучше организовать выбор цвета?

[RXL]

У тебя есть прямоугольник ABCD. Для вершин известны значеия цвета.

Рисуешь Y горизонтальных отрезков с градиентом, перемещаясь от верхнего AB к нижнему DC. Крайние цвета вычисляещь по градиенту AD и BC. Коэффециент градиента: позиция точки деленная на длину отрезка. При отсчете с ноля делить лучше на длину минус один. Соотв. цвет точки = k(R1,G1,B1) + (1-k)(R2,G2,B2).

[Sands]

Вот такой код:

Код:

for(int i=0;i<Image1->Height;i++)
  {
   for(int j=0;j<Image1->Width;j++)
    {
     Image1->Canvas->Pixels[i][j]=RGB(255-j,255-i,255-(i>j?i:j));
    }
  }
 Image1->Refresh();

вроде делает то что тебе надо.
Смысл в том, что как ни крути тебе надо для каждого пикселя кроме того, что ты убавляеш красную компоненту по горизонтали и зеленую по вертикали еще и по горизонтали и по вертикали убавлять синюю компоненту цвета. В моем примере от синей компоненты отнимается максимальное из значений горизонтальной и вертикальной координаты пикселя.
Только тебе придется еще вводить коефициент, поскольку у меня Имейдж имеет 256х256 пикселей, а у тебя 220х220

[RXL]

Примерная логика:

struct color { int r, int g, int b };

inx x,y;
extern struct color a,b,c,d;
struct color cc, c1, c2;
int k1, k2;

for (y = 0; y < 220; y++)
{
    k1 = y;
    k2 = 219 - y;

    c1.r = (a.r * k2 + b.r * k1)/219;
    c1.g = (a.g * k2 + b.g * k1)/219;
    c1.b= (a.b * k2 + b.b * k1)/219;

    c2.r = (d.r * k2 + c.r * k1)/219;
    c2.g = (d.g * k2 + c.g * k1)/219;
    c2.b= (d.b * k2 + c.b * k1)/219;

    for (x = 0; x < 220; x++)
    {
        k1 = x;
        k2 = 219 - x;

        cc.r = (c1.r * k2 + c2.r * k1)/219;
        cc.g = (c1.g * k2 + c2.g * k1)/219;
        cc.b= (c1.b * k2 + c2.b * k1)/219;

        // draw pixel
    }
}

[trosh]

Спасибо!
Получилось следующим образом:

Код:

void __fastcall TMainForm::PBColorGradientPaint(TObject *Sender)
{
Graphics::TBitmap *Gradient = new Graphics::TBitmap();
int w, h;
w= PBColorGradient->Width;
h= PBColorGradient->Height;
Gradient->Width = w;
Gradient->Height = h;
typedef struct {int R, G, B;}CRGB;
                             CRGB    ColorW,
                                     ColorR,    Color_tR,
                                     ColorG,    Color_tG,
                                     ColorB,    Color_tB;
ColorW.R = 255, ColorR.R = 255, ColorG.R = 0,   ColorB.R = 0,
ColorW.G = 255, ColorR.G = 0,   ColorG.G = 0,   ColorB.G = 0,
ColorW.B = 255, ColorR.B = 0,   ColorG.B = 255, ColorB.B = 0;

int k1, k2;
        for(int y=0; y<=w-1; y++)
          {
               k1= y;
               k2= (w-1)-y;
               Color_tR.R = (Color_tG.R*k2 + Color_tB.R*k1)/(w-1);
               Color_tG.G = (Color_tG.G*k2 + Color_tB.G*k1)/(w-1);
               Color_tB.B = (Color_tG.B*k2 + Color_tB.B*k1)/(w-1);

            for(int x=0; x<=w-1; x++)
              {
                k1= x;
                k2= (w-1)-x;
                Color_tG.R = (ColorW.R*k2 + ColorR.R*k1)/(w-1);
                Color_tG.G = (ColorW.G*k2 + ColorR.G*k1)/(w-1);
                Color_tG.B = (ColorW.B*k2 + ColorR.B*k1)/(w-1);

                Color_tB.R = (ColorB.R*k2 + ColorG.R*k1)/(w-1);
                Color_tB.G = (ColorB.G*k2 + ColorG.G*k1)/(w-1);
                Color_tB.B = (ColorB.B*k2 + ColorG.B*k1)/(w-1);
                Gradient->Canvas->Pixels[y][x] = TColor(RGB(Color_tR.R-1,
                                                                             Color_tG.G-1,
                                                                             Color_tB.B-1 ));

              }
          }

PBColorGradient->Canvas->Draw(0,0,Gradient);
delete Gradient;
        
}
//---------------------------------------------------------------------------

void __fastcall TMainForm::PBMonochromeGradientPaint(TObject *Sender)
{
 Graphics::TBitmap *Gradient = new Graphics::TBitmap();
int w, h;
w= PBMonochromeGradient->Width;
h= PBMonochromeGradient->Height;
Gradient->Width = w;
Gradient->Height = h;
typedef struct {int R, G, B;} tRGB;
 tRGB Color1;

Color1.R=0;
Color1.G=0;
Color1.B=0;
 for(int i2=0;i2<=255;i2++)
 {
 for(int i=0;i<=255;i++)
 {
  Gradient->Canvas->Pixels[i][i2]=TColor(RGB(Color1.R+i+55,
                                                             Color1.G+i+55,
                                                             Color1.B+i+55));
 }
 }
PBMonochromeGradient->Canvas->Draw(0,0,Gradient);

delete Gradient;
        
}