#include <memory></memory>

#include <cstring></cstring>

#include "trop.h"

//=======================================================================

class HalfCord {

  std::unique_ptr<int[]> m_array;</int[]>

  int m_radius;

public:

  HalfCord(int radius) : m_radius(radius), m_array(new int[radius + 1]) {

    assert(radius >= 0);

    memset(m_array.get(), 0, (m_radius + 1) * sizeof(int));

    float dCircle = 1.25f - m_radius;  //  inizializza decision variable

    int y         = m_radius;          //  inizializzazione indice scanline

    int x         = 0;                 //  inizializzazione indice colonna

    do {

      m_array[y] = std::max(x, m_array[y]);

      m_array[x] = y;

      if (dCircle <= 0) {

        dCircle = dCircle + 2 * x + 3;

      } else {

        y--;

        dCircle = dCircle + 2 * (x - y) + 5;

      }

      x++;

    } while (y >= x);

  }

  inline int getCord(int x) {

    assert(0 <= x && x <= m_radius);

    return m_array[x];

  };

private:

  // not implemented

  HalfCord(const HalfCord &);

  HalfCord &operator=(const HalfCord &);

};

//=======================================================================

void TRop::brush(TRaster32P ras, const TPoint &aa, const TPoint &bb, int radius,

                 const TPixel32 &col) {

  TPoint a = aa;

  TPoint b = bb;

  if (a.y > b.y) tswap(a, b);  //  a e' piu' in basso di b

  int lx = ras->getLx();

  int ly = ras->getLy();

  ras->lock();

  // ----- radius = 0

  if (radius == 0) {

    //  k = +1/-1 se il rettangolo e' inclinato positivamente

    //  (0<=m)/negativamente (m<0)

    //  (se k<0 viene fatta una riflessione sulle ascisse prima di tornare alle

    //  coordinate "di schermo")

    int k  = 1;

    int dy = b.y - a.y;

    int dx = b.x - a.x;

    if (dx < 0) {

      dx = -dx;

      k  = -1;

    }

    assert(dx >= 0);

    assert(dy >= 0);

    double m;  //  m sara' definita solo per dx!=0)

    if (dx > 0) {

      m = dy / (double)dx;

    }

    // double length = sqrt(dx*dx + dy*dy);

    const int alpha = dy, beta = -dx;

    const int incE  = alpha;

    const int incNE = alpha + beta;

    const int incN  = beta;

    //  N.B. le coordinate sono relative ad un sist. di rif. con l'origine in a

    //  l'eq. della retta e' alpha * x + beta * y = 0

    int yMin = std::max(a.y, 0) - a.y;  //  clipping y + cambio  riferimento

    int yMax = std::min(b.y, ly - 1) - a.y;  //  (trasporto dell'origine in a)

    if (dx > 0 && m <= 1) {

      //  midpoint algorithm

      TPoint segm;

      if (dy == 0)  //  segmento orizzontale: inizializza segm

      {

        segm.x = 0;

        segm.y = yMin;

      } else  //  0

      {

        segm.x = tceil((yMin - 0.5) / m);

        segm.y = yMin;

      }

      int dSegm = tfloor(alpha * (segm.x + 1) + beta * (segm.y + 0.5));

      while (segm.y <= yMax) {

        int count =

            0;  //  i trati orizzontali di segm vengono disegnati in "blocco"

        while (dSegm < 0 && segm.x <= dx)  //  Est:  segm.x<=dx evita il ciclo

        {                                  //  infinito quando m=0 (incE=0)

          dSegm = dSegm + incE;

          segm.x++;

          count++;

        }

        //  NordEst

        int xMin, xMax;

        if (k > 0) {

          xMin = std::max(

              {a.x + segm.x - count, a.x, 0});  //  clipping x + ritorno alle

          xMax = std::min(

              {a.x + segm.x, b.x, lx - 1});  //  coordinate "di schermo"

        } else {

          xMin = std::max({a.x - segm.x, a.x - dx,

                           0});  //  clipping x + riflessione + ritorno

          xMax = std::min({a.x - segm.x + count, a.x,

                           lx - 1});  //  alle  coordinate "di schermo"

        }

        TPixel32 *p = ras->pixels(segm.y + a.y) + xMin;

        TPixel32 *q = p + (xMax - xMin);

        while (p <= q) *p++ = col;

        dSegm = dSegm + incNE;

        segm.x++;

        segm.y++;

      }

    } else  //  m>1 oppure segmento verticale

    {

      //  midpoint algorithm

      TPoint segm;

      if (dx == 0)  //  segmento verticale: inizializza segm

      {

        segm.x = 0;

        segm.y = yMin;

      } else  //  m>1 :  inizializza segm

      {

        segm.x = tround(yMin / m);

        segm.y = yMin;

      }

      int dSegm = tfloor(alpha * (segm.x + 0.5) + beta * (segm.y + 1));

      while (segm.y <= yMax) {

        int xMin, xMax;

        if (k > 0) {

          xMin = std::max(a.x + segm.x, 0);       //  clipping x + ritorno alle

          xMax = std::min(a.x + segm.x, lx - 1);  //  coordinate "di schermo"

        } else {

          xMin =

              std::max(a.x - segm.x, 0);  //  clipping x + riflessione + ritorno

          xMax =

              std::min(a.x - segm.x, lx - 1);  //  alle  coordinate "di schermo"

        }

        TPixel32 *p = ras->pixels(segm.y + a.y) + xMin;

        TPixel32 *q = p + (xMax - xMin);

        while (p <= q) *p++ = col;

        if (dSegm <= 0)  //  NordEst

        {

          dSegm = dSegm + incNE;

          segm.x++;

        } else  //  Nord

        {

          dSegm = dSegm + incN;

        }

        segm.y++;

      }

    }

    ras->unlock();

    return;

  }

  HalfCord halfCord(radius);

  int x, y;

  // ----- punti iniziali coincidenti: disegna un cerchio

  if (a == b) {

    int yMin = std::max(a.y - radius, 0);       //  clipping y

    int yMax = std::min(a.y + radius, ly - 1);  //  clipping y

    for (y = yMin; y <= yMax; y++) {

      int deltay = abs(y - a.y);

      int xMin   = std::max(a.x - halfCord.getCord(deltay), 0);  //  clipping x

      int xMax =

          std::min(a.x + halfCord.getCord(deltay), lx - 1);  //  clipping x

      TPixel32 *p         = ras->pixels(y) + xMin;

      TPixel32 *q         = p + (xMax - xMin);

      while (p <= q) *p++ = col;

    }

    ras->unlock();

    return;

  }

  // -----  rettangolo orizzontale (a.y = b.y, a.x != b.x)

  if (a.y == b.y) {

    int yMin   = std::max((a.y - radius), 0);       //  clipping y

    int yMax   = std::min((a.y + radius), ly - 1);  //  clipping y

    int xLeft  = std::min(a.x, b.x);

    int xRight = std::max(a.x, b.x);

    for (y = yMin; y <= yMax; y++) {

      int deltay = abs(y - a.y);

      int xMin = std::max(xLeft - halfCord.getCord(deltay), 0);  //  clipping x

      int xMax =

          std::min(xRight + halfCord.getCord(deltay), lx - 1);  //  clipping x

      TPixel32 *p         = ras->pixels(y) + xMin;

      TPixel32 *q         = p + (xMax - xMin);

      while (p <= q) *p++ = col;

    }

    ras->unlock();

    return;

  }

  // -----  rettangolo verticale (a.x = b.x, a.y != b.y)

  if (a.x == b.x) {

    int xMin = std::max(a.x - radius, 0);       //  clipping x

    int xMax = std::min(a.x + radius, lx - 1);  //  clipping x

    for (x = xMin; x <= xMax; x++) {

      int deltax = abs(x - a.x);

      int yMin   = std::max(a.y - halfCord.getCord(deltax), 0);  //  clipping y

      int yMax =

          std::min(b.y + halfCord.getCord(deltax), ly - 1);  //  clipping y

      if (yMin <= yMax) {

        TPixel32 *p = ras->pixels(yMin) + x;

        TPixel32 *q = ras->pixels(yMax) + x;

        int wrap    = ras->getWrap();

        while (p <= q) {

          *p = col;

          p += wrap;

        }

      }

    }

    ras->unlock();

    return;

  }

  // -----  rettangolo inclinato

  //	k = +1/-1 se il rettangolo e' inclinato positivamente/negativamente

  int k  = 1;

  int dx = b.x - a.x;

  if (dx < 0) {

    dx = -dx;

    k  = -1;

  }

  int dy = b.y - a.y;

  assert(dx > 0);

  assert(dy > 0);

  double length  = sqrt((double)(dx * dx + dy * dy));

  const double m = dy / (double)dx;

  // punto di tangenza superiore nel sistema di riferimento del cerchio

  TPointD up(-radius * dy / length, radius * dx / length);

  // semi-ampiezza orizzontale delle "calotte" circolari

  int halfAmplCap = tfloor(-up.x);

  //  A meno di intersezioni relative tra le diverse zone:

  //  le scanline della "calotta" circolare superiore sono

  //  (b.y+cutExt,b.y+radius]

  //  le scanline del trapezoide circolare superiore sono [b.y-cutIn,b.y+cutExt]

  //  le scanline del parallelogramma sono (a.y+cutIn,b.y-cutIn)

  //  le scanline del trapezoide circolare inferiore sono [a.y-cutExt,a.y+cutIn]

  //  le scanline della "calotta" circolare inferiore sono

  //  [a.y-radius,a.y-cutExt)

  int cutExt, cutIn;

  // vertici del parallelogramma

  TPointD rightUp;

  TPointD rightDown;

  TPointD leftUp;

  TPointD leftDown;

  double mParall;  // coeff. angolare parallelogramma

  //  NOTA BENE:  halfAmplCap=0 <=> (radius=0 (caso a parte) , 1)

  if (radius > 1) {

    for (cutExt = radius;

         cutExt >= 0 && halfCord.getCord(cutExt) <= halfAmplCap; cutExt--)

      ;

    cutIn       = cutExt;  //  vedi else successivo

    rightUp.x   = dx + halfCord.getCord(cutIn);

    rightUp.y   = dy - cutIn;

    rightDown.x = halfCord.getCord(cutIn);

    rightDown.y = -cutIn;

    leftUp.x    = dx - halfCord.getCord(cutIn);

    leftUp.y    = dy + cutIn;

    leftDown.x  = -halfCord.getCord(cutIn);

    leftDown.y  = cutIn;

    mParall     = dy / (double)dx;

  } else  //  N.B. cutExt != cutIn solo quando radius=1

  {

    cutExt = radius;  //  radius=1 => halfAmplCap=0 (non ci sono mai le

                      //  "calotte" circolari)

    cutIn = 0;        //  anche per radius=1 il limite "interno" dei trapezoidi

                      //  circolari e' < radius

    rightUp.x   = dx - up.x;

    rightUp.y   = dy - up.y;

    rightDown.x = -up.x;

    rightDown.y = -up.y;

    leftUp.x    = dx + up.x;

    leftUp.y    = dy + up.y;

    leftDown.x  = up.x;

    leftDown.y  = up.y;

    mParall     = m;

  }

  // -----  riempie "calotte" circolari

  // -----  riempie "calotta" circolare inferiore

  int yMin = std::max(a.y - radius, 0);           //  clipping y

  int yMax = std::min(a.y - cutExt - 1, ly - 1);  //  clipping y

  for (y = yMin; y <= yMax; y++) {

    int r               = halfCord.getCord(a.y - y);

    int xMin            = std::max(a.x - r, 0);       //  clipping x

    int xMax            = std::min(a.x + r, lx - 1);  //  clipping x

    TPixel32 *p         = ras->pixels(y) + xMin;

    TPixel32 *q         = p + (xMax - xMin);

    while (p <= q) *p++ = col;

  }

  // -----  riempie "calotta" circolare superiore

  yMin = std::max(b.y + cutExt + 1, 0);   //  clipping y

  yMax = std::min(b.y + radius, ly - 1);  //  clipping y

  for (y = yMin; y <= yMax; y++) {

    int r               = halfCord.getCord(y - b.y);

    int xMin            = std::max(b.x - r, 0);       //  clipping x

    int xMax            = std::min(b.x + r, lx - 1);  //  clipping x

    TPixel32 *p         = ras->pixels(y) + xMin;

    TPixel32 *q         = p + (xMax - xMin);

    while (p <= q) *p++ = col;

  }

  // -----  riempie trapezoidi

  // (se k<0 viene fatta una riflessione sulle ascisse prima di tornare alle

  // coordinate "di schermo")

  //  limite destro assoluto delle scanline trapezoide:

  int xSegmMax = tround(dx - up.x);  //  coordinata x del punto di tangenza

                                     //  inferiore sul cerchio superiore

  //  limite sinistro assoluto delle scanline:

  int xSegmMin = tround(up.x);  //  coordinata x del punto di tangenza superiore

                                //  sul cerchio inferiore

  // -----  riempie trapezoide inferiore

  // N.B. le coordinate sono relative ad un sist. di rif. con l'origine sul

  // centro

  // del cerchio inferiore

  yMin = std::max(a.y - cutExt, 0) - a.y;                         //  clipping y

  yMax = std::min({a.y + cutIn, b.y - cutIn - 1, ly - 1}) - a.y;  //  clipping y

  // l'eq. della retta e' alpha * x + beta * y + gammaRight = 0

  const int alpha = dy, beta = -dx;

  const double gammaRight = rightDown.y * dx - rightDown.x * dy;

  const int incE          = alpha;

  const int incNE         = alpha + beta;

  const int incN          = beta;

  if (m <= 1) {

    //  midpoint algorithm; le scanline vengono disegnate solo

    //  sul NordEst. L'ultima scanline non viene disegnata

    TPoint segmRight(

        tceil((yMin + 0.5 - rightDown.y) / mParall + rightDown.x) - 1, yMin);

    int dSegmRight = tfloor(alpha * (segmRight.x + 1) +

                            beta * (segmRight.y + 0.5) + gammaRight);

    while (segmRight.y <= yMax) {

      if (dSegmRight < 0)  //  Est

      {

        dSegmRight = dSegmRight + incE;

        segmRight.x++;

      } else  //  NordEst

      {

        int xMin, xMax;

        if (k > 0) {

          xMin = std::max(a.x - halfCord.getCord(abs(segmRight.y)),

                          0);  //  clipping x

          xMax = std::min(a.x + std::min(segmRight.x, xSegmMax),

                          lx - 1);  //  clipping x

        } else {

          xMin = std::max(a.x - std::min(segmRight.x, xSegmMax),

                          0);  //  clipping x + ritorno alle

          xMax = std::min(a.x + halfCord.getCord(abs(segmRight.y)),

                          lx - 1);  //   coordinate "di schermo"

        }

        TPixel32 *p         = ras->pixels(segmRight.y + a.y) + xMin;

        TPixel32 *q         = p + (xMax - xMin);

        while (p <= q) *p++ = col;

        dSegmRight = dSegmRight + incNE;

        segmRight.x++;

        segmRight.y++;

      }

    }

  } else  //  m>1

  {

    //  midpoint algorithm; le scanline vengono disegnate sempre

    TPoint segmRight(tround((yMin - rightDown.y) / mParall + rightDown.x),

                     yMin);

    int dSegmRight = tfloor(alpha * (segmRight.x + 0.5) +

                            beta * (segmRight.y + 1) + gammaRight);

    while (segmRight.y <= yMax) {

      int xMin, xMax;

      if (k > 0) {

        xMin = std::max(a.x - halfCord.getCord(abs(segmRight.y)),

                        0);                          //  clipping x

        xMax = std::min(a.x + segmRight.x, lx - 1);  //  clipping x

      } else {

        xMin = std::max(a.x - segmRight.x,

                        0);  //  clipping x + ritorno alle coordinate

        xMax = std::min(a.x + halfCord.getCord(abs(segmRight.y)),

                        lx - 1);  //  "di schermo"

      }

      TPixel32 *p         = ras->pixels(segmRight.y + a.y) + xMin;

      TPixel32 *q         = p + (xMax - xMin);

      while (p <= q) *p++ = col;

      if (dSegmRight <= 0)  //  NordEst

      {

        dSegmRight = dSegmRight + incNE;

        segmRight.x++;

      } else  //  Nord

      {

        dSegmRight = dSegmRight + incN;

      }

      segmRight.y++;

    }

  }

  // -----  riempie trapezoide superiore

  //  N.B. le coordinate sono relative ad un sist. di rif. con l'origine sul

  //  centro

  //  del cerchio superiore

  yMin = std::max({b.y - cutIn, a.y + cutIn + 1, 0}) - b.y;  //  clipping y

  yMax = std::min(b.y + cutExt, ly - 1) - b.y;               //  clipping y

  //   l'eq. della retta e' alpha * x + beta * y + gammaLeft = 0

  const double gammaLeft = leftDown.y * dx - leftDown.x * dy;

  if (m <= 1) {

    //  midpoint algorithm; le scanline vengono disegnate solo

    //  sul NordEst. L'ultima scanline non viene disegnata

    TPoint segmLeft(tceil((yMin - 0.5 - leftDown.y) / mParall + leftDown.x),

                    yMin);

    int dSegmLeft = tfloor(alpha * (segmLeft.x + 1) +

                           beta * (segmLeft.y + 0.5) + gammaLeft);

    while (segmLeft.y <= yMax) {

      int xMin, xMax;

      if (k > 0) {

        xMin = std::max(b.x + std::max(segmLeft.x, xSegmMin - dx),

                        0);  //  clipping x

        xMax = std::min(b.x + halfCord.getCord(abs(segmLeft.y)),

                        lx - 1);  //  clipping x

      } else {

        xMin = std::max(b.x - halfCord.getCord(abs(segmLeft.y)),

                        0);  //  clipping x + ritorno alle

        xMax = std::min(b.x - std::max(segmLeft.x, xSegmMin - dx),

                        lx - 1);  //   coordinate "di schermo"

      }

      TPixel32 *p = ras->pixels(segmLeft.y + b.y) + xMin;

      TPixel32 *q = p + (xMax - xMin);

      while (p <= q) *p++ = col;

      while (dSegmLeft < 0) {

        dSegmLeft = dSegmLeft + incE;

        segmLeft.x++;

      }

      dSegmLeft = dSegmLeft + incNE;

      segmLeft.x++;

      segmLeft.y++;

    }

  } else  //  m>1

  {

    //  midpoint algorithm; le scanline vengono disegnate sempre

    TPoint segmLeft(tround((yMin - leftDown.y) / mParall + leftDown.x), yMin);

    int dSegmLeft = tfloor(alpha * (segmLeft.x + 0.5) +

                           beta * (segmLeft.y + 1) + gammaLeft);

    while (segmLeft.y <= yMax) {

      int xMin, xMax;

      if (k > 0) {

        xMin = std::max(b.x + segmLeft.x, 0);  //  clipping x

        xMax = std::min(b.x + halfCord.getCord(abs(segmLeft.y)),

                        lx - 1);  //  clipping x

      } else {

        xMin = std::max(b.x - halfCord.getCord(abs(segmLeft.y)),

                        0);  //  clipping x + ritorno alle

        xMax = std::min(b.x - segmLeft.x, lx - 1);  //   coordinate "di schermo"

      }

      TPixel32 *p = ras->pixels(segmLeft.y + b.y) + xMin;

      TPixel32 *q = p + (xMax - xMin);

      while (p <= q) *p++ = col;

      if (dSegmLeft <= 0)  //  NordEst

      {

        dSegmLeft = dSegmLeft + incNE;

        segmLeft.x++;

      } else  //  Nord

      {

        dSegmLeft = dSegmLeft + incN;

      }

      segmLeft.y++;

    }

  }

  // -----  parallelogramma (in alternativa a "parallelogrammoide circolare")

  // N.B. le coordinate sono relative ad un sist. di rif. con l'origine sul

  // centro

  // del cerchio inferiore

  //  retta destra di equaz.   alpha * x + beta * y + gammaRight = 0

  //  retta sinistra di equaz. alpha * x + beta * y + gammaLeft = 0

  yMin = std::max(a.y + cutIn + 1, 0) - a.y;       // clipping y

  yMax = std::min(b.y - cutIn - 1, ly - 1) - a.y;  // clipping y

  if (m <= 1) {

    //  midpoint algorithm; le scanline vengono disegnate solo

    //  sul NordEst. L'ultima scanline non viene disegnata

    TPoint segmRight(

        tceil((yMin + 0.5 - rightDown.y) / mParall + rightDown.x) - 1, yMin);

    TPoint segmLeft =

        TPoint(tceil((yMin - 0.5 - leftDown.y) / mParall + leftDown.x), yMin);

    int dSegmRight = tfloor(alpha * (segmRight.x + 1) +

                            beta * (segmRight.y + 0.5) + gammaRight);

    int dSegmLeft = tfloor(alpha * (segmLeft.x + 1) +

                           beta * (segmLeft.y + 0.5) + gammaLeft);

    while (segmRight.y <= yMax) {

      if (dSegmRight < 0)  //  segmRight a Est

      {

        dSegmRight = dSegmRight + incE;

        segmRight.x++;

      } else  //  segmRight a NordEst

      {

        int xMin, xMax;

        if (k > 0) {

          xMin =

              std::max(a.x + std::max(segmLeft.x, xSegmMin), 0);  //  clipping x

          xMax = std::min(a.x + std::min(segmRight.x, xSegmMax),

                          lx - 1);  //  clipping x

        } else {

          xMin = std::max(a.x - std::min(segmRight.x, xSegmMax),

                          0);  //  clipping x + ritorno alle

          xMax = std::min(a.x - std::max(segmLeft.x, xSegmMin),

                          lx - 1);  //   coordinate "di schermo"

        }

        TPixel32 *p = ras->pixels(segmRight.y + a.y) + xMin;

        TPixel32 *q = p + (xMax - xMin);

        while (p <= q) *p++ = col;

        dSegmRight = dSegmRight + incNE;

        segmRight.x++;

        segmRight.y++;

        while (dSegmLeft < 0)  //  segmLeft a Est

        {

          dSegmLeft = dSegmLeft + incE;

          segmLeft.x++;

        }

        //  segmLeft a NordEst

        dSegmLeft = dSegmLeft + incNE;

        segmLeft.x++;

        segmLeft.y++;

      }

    }

  } else  //  m>1

  {

    //  midpoint algorithm; le scanline vengono disegnate sempre

    TPoint segmRight(tround((yMin - rightDown.y) / mParall + rightDown.x),

                     yMin);

    TPoint segmLeft(tround((yMin - leftDown.y) / mParall + leftDown.x), yMin);

    int dSegmRight = tfloor(alpha * (segmRight.x + 0.5) +

                            beta * (segmRight.y + 1) + gammaRight);

    int dSegmLeft = tfloor(alpha * (segmLeft.x + 0.5) +

                           beta * (segmLeft.y + 1) + gammaLeft);

    while (segmRight.y <= yMax) {

      int xMin, xMax;

      if (k > 0) {

        xMin = std::max(a.x + segmLeft.x, 0);        //  clipping x

        xMax = std::min(a.x + segmRight.x, lx - 1);  //  clipping x

      } else {

        xMin = std::max(a.x - segmRight.x, 0);  //  clipping x + ritorno alle

        xMax = std::min(a.x - segmLeft.x, lx - 1);  //   coordinate "di schermo"

      }

      TPixel32 *p = ras->pixels(segmRight.y + a.y) + xMin;

      TPixel32 *q = p + (xMax - xMin);

      while (p <= q) *p++ = col;

      if (dSegmRight <= 0)  //  segmRight a NordEst

      {

        dSegmRight = dSegmRight + incNE;

        segmRight.x++;

      } else  //  segmRight a Nord

      {

        dSegmRight = dSegmRight + incN;

      }

      segmRight.y++;

      if (dSegmLeft <= 0)  //  segmLeft a NordEst

      {

        dSegmLeft = dSegmLeft + incNE;

        segmLeft.x++;

      } else  //  segmLeft a Nord

      {

        dSegmLeft = dSegmLeft + incN;

      }

    }

  }

  // ----  parallelogrammoide circolare (in alternativa a parallelogramma)

  // N.B. coordinate di schermo (riflessione per k<0 )

  yMin = std::max(b.y - cutIn, 0);

  yMax = std::min(a.y + cutIn, ly - 1);

  for (y = yMin; y <= yMax; y++) {

    int xMin, xMax;

    if (k > 0) {

      xMin = std::max(a.x - halfCord.getCord(abs(y - a.y)), 0);  //  clipping x

      xMax = std::min(b.x + halfCord.getCord(abs(b.y - y)),

                      lx - 1);  //  clipping x

    } else {

      xMin = std::max(b.x - halfCord.getCord(abs(b.y - y)),

                      0);  //  clipping x + ritorno alle

      xMax = std::min(a.x + halfCord.getCord(abs(y - a.y)),

                      lx - 1);  //   coordinate "di schermo"

    }

    TPixel32 *p         = ras->pixels(y) + xMin;

    TPixel32 *q         = p + (xMax - xMin);

    while (p <= q) *p++ = col;

  }

  ras->unlock();

}