//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "KnitArrange.h"
#include "Common.h"
#include "Exception.h"
#include "TClrUtil.hpp"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
#define XLD    0
#define XRD    1
#define XLU    2
#define XRU    3
#define YLD    4
#define YRD    5
#define YLU    6
#define YRU    7
//---------------------------------------------------------------------------
__fastcall TKnitArrange::TKnitArrange()
{
   Dmark.set = 0x00;
   Dmark.cnt = 2;
   Dmark.sp[0] = &Smark[MS_MISS].data;
   Dmark.chart[0] = OFFCHART;

   Dmark.sp[1] = &Smark[MS_FRONT].data;
   Dmark.chart[1] = OFFCHART;

   Dyarn.set = 0;
   Dyarn.data[0].type = 0;
   Dyarn.data[0].cnt = 0;
   memset(Dyarn.data[0].color, 0, 8);

   Dyarn.cnt = 0;

   for (int i=0; i<65; i++) {
     Dyarn.ydData[i] = NULL;
   }

   kdsn.wpi = 12;
   kdsn.cpi = 10;
}
//---------------------------------------------------------------------------
__fastcall TKnitArrange::~TKnitArrange()
{
  for (int i=0; i<65; i++) {
    if (Dyarn.ydData[i]) delete Dyarn.ydData[i];
  }
}
//---------------------------------------------------------------------------
void __fastcall TKnitArrange::SetFrontBack(int i)
{
  if (i == MS_FRONT) {
    Dmark.set &= 0xBF;
    Dmark.sp[1] = &Smark[MS_FRONT].data;
  } else if (i == MS_BACK) {
    Dmark.set |= 0x40;
    Dmark.sp[1] = &Smark[MS_BACK].data;
  }
}
//---------------------------------------------------------------------------
void __fastcall TKnitArrange::slope(TKnitData &kd)
{
  short sx, sy;

  sy = *kd.pos[YLU].pointer(kd.dx, kd.dy)-*kd.pos[YLD].pointer(kd.dx, kd.dy);
  if (sy) {
    kd.nxy[0] = (double)(*kd.pos[XLU].pointer(kd.dx, kd.dy)-*kd.pos[XLD].pointer(kd.dx, kd.dy))/sy;
  } else kd.nxy[0] = 0.0;
  sy = *kd.pos[YRU].pointer(kd.dx, kd.dy)-*kd.pos[YRD].pointer(kd.dx, kd.dy);
  if (sy) {
    kd.nxy[1] = (double)(*kd.pos[XRU].pointer(kd.dx, kd.dy)-*kd.pos[XRD].pointer(kd.dx, kd.dy))/sy;
  } else kd.nxy[1] = 0.0;
  sx = *kd.pos[XRD].pointer(kd.dx, kd.dy)-*kd.pos[XLD].pointer(kd.dx, kd.dy);
  if (sx) {
    kd.nyx[0] = (double)(*kd.pos[YRD].pointer(kd.dx, kd.dy)-*kd.pos[YLD].pointer(kd.dx, kd.dy))/sx;
  } else kd.nyx[0] = 0.0;
  sx = *kd.pos[XRU].pointer(kd.dx, kd.dy)-*kd.pos[XLU].pointer(kd.dx, kd.dy);
  if (sx) {
    kd.nyx[1] = (double)(*kd.pos[YRU].pointer(kd.dx, kd.dy)-*kd.pos[YLU].pointer(kd.dx, kd.dy))/sx;
  } else kd.nyx[1] = 0.0;
}
//---------------------------------------------------------------------------
short __fastcall TKnitArrange::stx(TKnitData &kd, short x, short y)
{
  short sx = *kd.pos[XLD].pointer(kd.dx, kd.dy)+(y-*kd.pos[YLD].pointer(kd.dx, kd.dy))*kd.nxy[0];
  short ex = *kd.pos[XRD].pointer(kd.dx, kd.dy)+(y-*kd.pos[YRD].pointer(kd.dx, kd.dy))*kd.nxy[1];
  if (ex-sx!=0) return 39*(x-sx)/(ex-sx); else return 39;
}
//---------------------------------------------------------------------------
short __fastcall TKnitArrange::sty(TKnitData &kd, short x, short y)
{
  short sy = *kd.pos[YLD].pointer(kd.dx, kd.dy)+(x-*kd.pos[XLD].pointer(kd.dx, kd.dy))*kd.nyx[0];
  short ey = *kd.pos[YLU].pointer(kd.dx, kd.dy)+(x-*kd.pos[XLU].pointer(kd.dx, kd.dy))*kd.nyx[1];
  if (ey-sy!=0) return 39*(y-sy)/(ey-sy); else return 39;
}
//---------------------------------------------------------------------------
Axis __fastcall TKnitArrange::basis_mark(TKnitData &kd, Byte m, short sx, short sy)
{
  Axis rtn, mp;
  Byte *p;

  mp.y = sy;
  for (short y=0; y<Dmark.sp[m]->course; y++, mp.y++) {
    p = kd.bmMark.ScanLine(mp.y)+sx;
    for (short x=0; x<Dmark.sp[m]->wale; x++, p--) {
      if ((*p&0xBF)==m) {
        rtn.x = x; rtn.y = y;
      }
    }
  }
  return rtn;
}
//---------------------------------------------------------------------------
Byte __fastcall TKnitArrange::yarncolor(TKnitData &kd, Byte video, short cx, short cy, short sx, short sy)
{
  Byte yarncolor;
  int x, y, length, width, thick, start;
  Byte cc = kd.index[*(kd.bmYarn.ScanLine(cy)+cx)];
  Byte ec = (video&0x18)>>3;
  length = Dyarn.ydData[cc]->Length;
  width = Dyarn.ydData[cc]->Width;
  thick = Dyarn.ydData[cc]->Thick;

  if (sx<20) {
    start = thick*7.14*(cy*kd.StitchWidth+cx);
    if (ec == 0) { //
      start += sy * thick / 20;
      start %= length;
    } else if (ec == 1) { //关 内
      start += (sy + 40) * thick / 20;
      start %= length;
    } else if (ec == 2) {  // 拉 内
      start += (sy - 40) * thick / 20;
      start %= length;
    }
    y = width/2 + (double)(sx-10)/20*thick;
    x = start;
  } else {
    start = thick*7.14*(cy*kd.StitchWidth+cx) + thick*3.57;
    if (ec == 0) { //
      start += (40 - sy) * thick / 20;
      start %= length;
    } else if (ec == 1) { //关 内
      start += ( - sy) * thick / 20;
      start %= length;
    } else if (ec == 2) {  // 拉 内
      start += (80 - sy) * thick / 20 + thick*2;
      start %= length;
    }
    y = width/2 + (double)(30-sx)/20*thick;
    x = start;
  }

  yarncolor = *((Byte *)Dyarn.ydData[cc]->Map + y*length + x);
//    yarncolor = 1;

  return yarncolor;
}
//---------------------------------------------------------------------------
void __fastcall TKnitArrange::lowerupperyarn(TKnitData &kd, short cx, short cy)
{
  Byte mark;
  Axis bm, move;
  int i, j;

  kd.lx = kd.dn.pointer(cx, cy)->x;
  kd.ly = kd.dn.pointer(cx, cy)->y;
  kd.ux = kd.up.pointer(cx, cy)->x;
  kd.uy = kd.up.pointer(cx, cy)->y;

  if (kd.lx == BCIRCLE) mark = *(kd.bmMark.ScanLine(kd.dy)+kd.dx);
  else mark = *(kd.bmMark.ScanLine(kd.ly)+kd.lx);
  kd.front_down = (mark&0x40)>>6;
  mark = *(kd.bmMark.ScanLine(kd.uy)+kd.ux);
  kd.front_up = (mark&0x40)>>6;
  mark = *(kd.bmMark.ScanLine(cy)+cx-1);
  kd.front_left = (mark&0x40)>>6;
  mark = *(kd.bmMark.ScanLine(cy)+cx+1);
  kd.front_right = (mark&0x40)>>6;
}
//---------------------------------------------------------------------------
Byte __fastcall TKnitArrange::view(TKnitData &kd, short cx, short cy, short sx, short sy, Byte light)
{
  Byte video, mark, ec, cc, video_1, front;

  short l[5][7] = {
    { -3, -3, -3, -2, -1,  0,  1 },
    { -3, -3, -2, -1,  0,  1,  2 },
    { -3, -2, -1,  0,  1,  2,  3 },
    { -2, -1,  0,  1,  2,  3,  3 },
    { -1,  0,  1,  2,  3,  3,  3 }
  };
  Axis bm;

  video = *(kd.Stitch[(*kd.dmp&0x40)>>6].ScanLine(sy)+sx);
  video_1 = *(kd.Stitch[kd.front_up].ScanLine(sy)+sx);
  if (kd.lx == BCIRCLE) video = *(kd.Stitch[3].ScanLine(sy)+sx);

  front = (*kd.dmp&0x40)>>6;
  if (front == kd.front_up) {
    if (front == MS_FRONT) {
      if (front != kd.front_left) if (rand()%40 > sx) light+=2;
      if (front != kd.front_right) if (rand()%40 < sx) light+=2;
    } else {
      if (front != kd.front_left) if (rand()%40 > sx) light-=2;
      if (front != kd.front_right) if (rand()%40 < sx) light-=2;
    }
  } else {
    if (front == MS_FRONT) {
      if ((video_1&0x18)>>3 == 2) video = video_1;
      else {
        if (rand()%40 < sy) light-=2;
      }
      if (front != kd.front_left) if (rand()%40 > sx) light+=2;
      if (front != kd.front_right) if (rand()%40 < sx) light+=2;
    } else {
      if ((video&0x18)>>3 != 1) {
        video = video_1;
        if (rand()%40 > sy) light-=2;
      }
      if (front != kd.front_left) if (rand()%40 > sx) light-=2;
      if (front != kd.front_right) if (rand()%40 < sx) light-=2;
    }
  }
  if (light>4) light = 4;

  if (video!=0xFF) {
    ec = (video&0x18)>>3;
    if (ec==1) {  //lower yarn
      if (kd.lx == BCIRCLE) {
        cx = kd.dx; cy = kd.dy;
      } else {
        cx = kd.lx; cy = kd.ly;
      }
    } else if (ec==2) {  //upper yarn
      cx = kd.ux; cy = kd.uy;
    }
    cc = kd.index[*(kd.bmYarn.ScanLine(cy)+cx)];
    if (cc) {
      switch (Dyarn.data[cc].type) {
        case DYT_NORMAL:
          return kd.GradeColor[Dyarn.data[cc].color[0]]+l[light][video&7];
        case DYT_MELANGE:
          return kd.GradeColor[Dyarn.data[cc].color[rand()%Dyarn.data[cc].cnt]]+l[light][video&7];
        case DYT_DESIGN:
          Byte yarn = yarncolor(kd, video, cx, cy, sx, sy);
          return kd.GradeColor[Dyarn.data[cc].color[yarn>>3]]+l[light][video&7];
      }
    } else return 1;
  } else return 1;
}
//---------------------------------------------------------------------------
void __fastcall TKnitArrange::view_stitch(TKnitData &kd, Byte light)
{
try {
  BYTE *op, n;
  short x, y, cx, cy, minx, miny, maxx, maxy, sx, sy;
  DWORD rgb;
  x =*kd.pos[XLD].pointer(kd.dx, kd.dy); y=*kd.pos[XLU].pointer(kd.dx, kd.dy);
  minx = min(*kd.pos[XLD].pointer(kd.dx, kd.dy), *kd.pos[XLU].pointer(kd.dx, kd.dy));
  minx = max((int)minx, 0);
  maxx = max(*kd.pos[XRD].pointer(kd.dx, kd.dy), *kd.pos[XRU].pointer(kd.dx, kd.dy));
  maxx = min((int)maxx, kd.OutputWidth-1);
  x=*kd.pos[XRD].pointer(kd.dx, kd.dy); y=*kd.pos[XRU].pointer(kd.dx, kd.dy);

  x=*kd.pos[YLD].pointer(kd.dx, kd.dy); y=*kd.pos[YRD].pointer(kd.dx, kd.dy);
  miny = min(*kd.pos[YLD].pointer(kd.dx, kd.dy), *kd.pos[YRD].pointer(kd.dx, kd.dy));
  miny = max((int)miny, 0);
  maxy = max(*kd.pos[YLU].pointer(kd.dx, kd.dy), *kd.pos[YRU].pointer(kd.dx, kd.dy));
  maxy = min((int)maxy, kd.OutputHeight-1);
  x=*kd.pos[YLU].pointer(kd.dx, kd.dy); y=*kd.pos[YRU].pointer(kd.dx, kd.dy);
  slope(kd);
  lowerupperyarn(kd, kd.dx, kd.dy);  //7/41

  for (y=miny; y<=maxy; y++) {
    op = kd.bmOutput.ScanLine(y)+minx;
    for (x=minx; x<=maxx; x++, op++) {
      kd.csp = 1;
      cx = (x<*kd.pos[XLD].pointer(kd.dx, kd.dy)) ? 1 : 0;
      cx |= (x<*kd.pos[XLU].pointer(kd.dx, kd.dy)) ? 2 : 0;
      cx |= (x>*kd.pos[XRD].pointer(kd.dx, kd.dy)) ? 4 : 0;
      cx |= (x>*kd.pos[XRU].pointer(kd.dx, kd.dy)) ? 8 : 0;
      if (cx==0x01 || cx==0x02) {
        if (x<*kd.pos[XLD].pointer(kd.dx, kd.dy)+(y-*kd.pos[YLD].pointer(kd.dx, kd.dy))*
          kd.nxy[0]) kd.csp = 0;
      } else if (cx==0x04 || cx==0x08) {
        if (x>*kd.pos[XRD].pointer(kd.dx, kd.dy)+(y-*kd.pos[YRD].pointer(kd.dx, kd.dy))*
          kd.nxy[1]) kd.csp = 0;
      } else if (cx==0x03 || cx==0x0C) kd.csp = 0;
      cy = (y<*kd.pos[YLD].pointer(kd.dx, kd.dy)) ? 1 : 0;
      cy |= (y<*kd.pos[YRD].pointer(kd.dx, kd.dy)) ? 2 : 0;
      cy |= (y>*kd.pos[YLU].pointer(kd.dx, kd.dy)) ? 4 : 0;
      cy |= (y>*kd.pos[YRU].pointer(kd.dx, kd.dy)) ? 8 : 0;
      if (cy==0x01 || cy==0x02) {
        if (y<*kd.pos[YLD].pointer(kd.dx, kd.dy)+(x-*kd.pos[XLD].pointer(kd.dx, kd.dy))*
          kd.nyx[0]) kd.csp = 0;
      } else if (cy==0x04 || cy==0x08) {
        if (y>*kd.pos[YLU].pointer(kd.dx, kd.dy)+(x-*kd.pos[XLU].pointer(kd.dx, kd.dy))*
          kd.nyx[1]) kd.csp = 0;
      } else if (cy==0x03 || cy==0x0C) kd.csp = 0;
      if (kd.csp) {
        sx = stx(kd, x, y);
        sy = sty(kd, x, y);
        if (sx >= 0 && sx < 40 && sy >= 0 && sy < 40) {
          *op = view(kd, kd.dx, kd.dy, sx, sy, light);
        } else {
          *op = 1;
        }
      }
    }
  }
} catch (...) {
  char *func = __FUNC__;
  int line = __LINE__;
  MessageDlg(Format("Error : %s (%d)", OPENARRAY(TVarRec, (func, line))),
    mtInformation, TMsgDlgButtons() << mbOK, 0);
}

}
//---------------------------------------------------------------------------
void __fastcall TKnitArrange::Simulation(TTexpiaBitmap *Bitmap, TPWorkArea *wa,
  RECT Range, Word dpi, TStatusProgress *sp)
{
try {
  TKnitData kd;
  RGBQUAD rgb[256], gc[256];
  Byte move, c, *dst;
  short i, j, k, x, y, sx, sy, cx, cy, dx, dy, sh;
  double dps[2], h, l, s;
  TPMemoryArea<short> xmove;
  TTexpiaBitmap *pYarn, *pMark, *pOutput;
  TPException ec = EC_NONE;
  TRect rcOutput, wr;
  AnsiString msg;
  Axis bm, up;
  short light;
  AnsiString mname;
  smd *MarkData;
  double bent[8];
  Byte *IP, *OP;  

  sp->Maximum = 6;
  sp->Position = 0;

  pYarn = Bitmap;
  pMark = Bitmap+1;
  pOutput = Bitmap+2;

  kd.StitchWidth = pYarn->Width;
  kd.StitchHeight = pYarn->Height;
  kd.OutputWidth = pOutput->Width;
  kd.OutputHeight = pOutput->Height;

  if (wa != NULL) {
    if (wa->Mask) {
      kd.rcStitch.Left = wa->Range.left * (double) kdsn.wpi / dpi + 0.5;
      kd.rcStitch.Top = pYarn->Height - (wa->Range.bottom * (double) kdsn.cpi / dpi - 0.5);
      kd.rcStitch.Right = wa->Range.right * (double) kdsn.wpi / dpi + 0.5;
      kd.rcStitch.Bottom = pYarn->Height - (wa->Range.top * (double) kdsn.cpi / dpi - 0.5);
      if (kd.rcStitch.Right > pYarn->Width) kd.rcStitch.Right = pYarn->Width;
      if (kd.rcStitch.Bottom > pYarn->Height) kd.rcStitch.Bottom = pYarn->Height;
      wr = wa->Range;
    } else {
      kd.rcStitch.Left = 0;
      kd.rcStitch.Top = 0;
      kd.rcStitch.Right = pYarn->Width;
      kd.rcStitch.Bottom = pYarn->Height;
      wr = Rect(0, 0, kd.OutputWidth, kd.OutputHeight);
    }
  } else {
    kd.rcStitch.Left = Range.left * (double) kdsn.wpi / dpi + 0.5 - 5;
    kd.rcStitch.Top = pYarn->Height - (Range.bottom * (double) kdsn.cpi / dpi - 0.5) - 5;
    kd.rcStitch.Right = Range.right * (double) kdsn.wpi / dpi + 0.5 + 5;
    kd.rcStitch.Bottom = pYarn->Height - (Range.top * (double) kdsn.cpi / dpi - 0.5) + 5;
    if (kd.rcStitch.Left < 0) kd.rcStitch.Left = 0;
    if (kd.rcStitch.Top < 0) kd.rcStitch.Top = 0;
    if (kd.rcStitch.Right > pYarn->Width) kd.rcStitch.Right = pYarn->Width;
    if (kd.rcStitch.Bottom > pYarn->Height) kd.rcStitch.Bottom = pYarn->Height;
    wr = Range;
  }

  for (i=0; i<4; i++) {
    if (i==2) continue;
    if (!kd.Stitch[i].Create(Smark[i].stitch->Width, Smark[i].stitch->Height, 8)) goto fail;
    if (kd.Stitch[i].Lock()==NULL) goto fail;
    Smark[i].stitch->SaveToMemory(kd.Stitch[i].ScanLine(), kd.Stitch[i].BytesPerLine);
  }

  if (!kd.bmYarn.Create(kd.StitchWidth, kd.StitchHeight, 8)) goto fail;
  if (kd.bmYarn.Lock()==NULL) goto fail;
  pYarn->SaveToMemory(kd.bmYarn.ScanLine(), kd.bmYarn.BytesPerLine, true);

  if (!kd.bmMark.Create(kd.StitchWidth, kd.StitchHeight, 8)) goto fail;
  if (kd.bmMark.Lock()==NULL) goto fail;
  pMark->SaveToMemory(kd.bmMark.ScanLine(), kd.bmMark.BytesPerLine, true);

  if (!kd.bmOutput.Create(kd.OutputWidth, kd.OutputHeight, 8)) goto fail;
  if (kd.bmOutput.Lock()==NULL) goto fail;

  pYarn->GetColors(0, 256, rgb);

  memset(kd.index, 0, 256);
  memset(kd.GradeColor, 0, 256);
  gc[0] = rgb[0];
  gc[1] = rgb[1];
  gc[255] = rgb[255];
  Count = 0;
  for (i=1; i<=Dyarn.cnt; i++) {
    if (Dyarn.data[i].cnt>0) {
      kd.index[Dyarn.data[i].color[0]] = i;
      for (j=0; j<Dyarn.data[i].cnt; j++) {
        if (kd.GradeColor[Dyarn.data[i].color[j]]==0) {
          k = 5+Count*7;
          kd.GradeColor[Dyarn.data[i].color[j]] = k;
          gc[k] = rgb[Dyarn.data[i].color[j]];
          RGBQUAD2HLS(gc[k], h, l, s);
          gc[k-3] = HLS2RGBQUAD(h, l-0.12<0 ? 0 : l-0.12, s);
          gc[k-2] = HLS2RGBQUAD(h, l-0.08<0 ? 0 : l-0.08, s);
          gc[k-1] = HLS2RGBQUAD(h, l-0.04<0 ? 0 : l-0.04, s);
          gc[k+1] = HLS2RGBQUAD(h, l+0.04>1 ? 1 : l+0.04, s);
          gc[k+2] = HLS2RGBQUAD(h, l+0.08>1 ? 1 : l+0.08, s);
          gc[k+3] = HLS2RGBQUAD(h, l+0.12>1 ? 1 : l+0.12, s);
          Count++;
        }
      }
    }
  }
  pOutput->PutColors(0, 256, gc);

  dps[0] = (double)dpi/kdsn.wpi;
  dps[1] = (double)dpi/kdsn.cpi;
  for (i=0; i<8; i++) {
    if (!kd.pos[i].create(kd.StitchWidth, kd.StitchHeight)) goto fail;
    if (kd.pos[i].lock()==NULL) goto fail;
  }
//7.41
  if (!kd.up.create(kd.StitchWidth, kd.StitchHeight)) goto fail;
  if (kd.up.lock()==NULL) goto fail;
  if (!kd.dn.create(kd.StitchWidth, kd.StitchHeight)) goto fail;
  if (kd.dn.lock()==NULL) goto fail;
//
  for (y= kd.rcStitch.Top; y < kd.rcStitch.Bottom; y++) {
    for (x= kd.rcStitch.Left; x < kd.rcStitch.Right; x++) {
      *kd.pos[XLD].pointer(x, y) = *kd.pos[XLU].pointer(x, y) = x*dps[0];
      *kd.pos[XRD].pointer(x, y) = *kd.pos[XRU].pointer(x, y) = (x+1)*dps[0];
      *kd.pos[YLD].pointer(x, y) = *kd.pos[YRD].pointer(x, y) = y*dps[1];
      *kd.pos[YLU].pointer(x, y) = *kd.pos[YRU].pointer(x, y) = (y+1)*dps[1];
    }
  }

  if (wa != NULL) {
    if (wa->Mask) {           // 累诀备开俊 尝况 嘎眠扁....     99/05/31 addition
      for (x= kd.rcStitch.Left; x < kd.rcStitch.Right; x++) {
        *kd.pos[YLD].pointer(x, kd.rcStitch.Top)
          = *kd.pos[YRD].pointer(x, kd.rcStitch.Top) = pOutput->Height - wr.Bottom;
        *kd.pos[YLU].pointer(x, kd.rcStitch.Bottom - 1)
          = *kd.pos[YRU].pointer(x, kd.rcStitch.Bottom - 1) = pOutput->Height - wr.Top - 1;
      }

      for (y= kd.rcStitch.Top; y < kd.rcStitch.Bottom; y++) {
        *kd.pos[XLD].pointer(kd.rcStitch.Left, y)
          = *kd.pos[XLU].pointer(kd.rcStitch.Left, y) = wr.Left;
        *kd.pos[XRD].pointer(kd.rcStitch.Right - 1, y)
          = *kd.pos[XRU].pointer(kd.rcStitch.Right - 1, y) = wr.Right - 1;
      }
    }
  }


  for (y=0; y<1; y++) {
    sh = dx = 0;
    kd.dmp = kd.bmMark.ScanLine(y);
    for (x=0; x<kd.StitchWidth; x++, kd.dmp++) {
      kd.csp = *kd.dmp&0x3F;
      mname = Dmark.sp[kd.csp]->mname;
      kd.dn.pointer(x, y)->x = x; kd.dn.pointer(x, y)->y = y;
    }
  }
  for (y=0; y<kd.StitchHeight-1; y++) {
    sh = dx = 0;
    kd.dmp = kd.bmMark.ScanLine(y);
    for (x=0; x<kd.StitchWidth; x++, kd.dmp++) {
      kd.csp = *kd.dmp&0x3F;
      mname = Dmark.sp[kd.csp]->mname;
      if (mname.Pos("MISS") > 0) {
        dx = 0; dy = 1;
        kd.up.pointer(x, y)->x = x+dx;    kd.up.pointer(x, y)->y = y+dy;
        kd.dn.pointer(x+dx, y+dy)->x = x; kd.dn.pointer(x+dx, y+dy)->y = y;
      } else if (mname.Pos("FRONT") > 0 || mname.Pos("BACK") > 0) {
        dy = 1;
        kd.up.pointer(x, y)->x = x+dx;    kd.up.pointer(x, y)->y = y+dy;
        kd.dn.pointer(x+dx, y+dy)->x = x; kd.dn.pointer(x+dx, y+dy)->y = y;
      } else if (mname.Pos("TOG2") > 0) {
        sh = (dx<=0 ? dx : dx-1);
        dy = 1;
        kd.up.pointer(x, y)->x = x+sh;    kd.up.pointer(x, y)->y = y+dy;
        kd.dn.pointer(x+sh, y+dy)->x = x; kd.dn.pointer(x+sh, y+dy)->y = y;

        if (*(kd.dmp+1)&0x3F == 1)
        if (dx<=0) {
          if (mname == "TOG2 Left") {
            kd.up.pointer(x+1, y)->x = x+sh;  kd.up.pointer(x+1, y)->y = y+dy;
            x++; kd.dmp++;
          }
        } else {
          if (mname == "TOG2 Left") {
            kd.dn.pointer(x+sh, y+dy)->x = x-1; kd.dn.pointer(x+sh, y+dy)->y = y;
          }
        }

        dx--;
      } else if (mname.Pos("TOG3") > 0) {
        dy = 1;
        kd.up.pointer(x-1, y)->x = x+dx-1;  kd.up.pointer(x-1, y)->y = y+dy;
        kd.up.pointer(x, y)->x = x+dx-1;    kd.up.pointer(x, y)->y = y+dy;
        kd.up.pointer(x+1, y)->x = x+dx-1;  kd.up.pointer(x+1, y)->y = y+dy;
        if (mname == "TOG3 Left") {
        } else if (mname == "TOG3 Right") {
          kd.dn.pointer(x+dx-1, y+dy)->x = x+1; kd.dn.pointer(x+sh, y+dy)->y = y;
        } else if (mname == "TOG3 Center") {
          kd.dn.pointer(x+dx-1, y+dy)->x = x; kd.dn.pointer(x+sh, y+dy)->y = y;
        }
        dx -= 2;
      } else if (mname.Pos("CIRCLE") > 0) {
        sh = (dx>=0 ? dx+1 : dx);
        dy = 1;
        kd.up.pointer(x, y)->x = x+sh;    kd.up.pointer(x, y)->y = y+dy;
        kd.dn.pointer(x+sh, y+dy)->x = x; kd.dn.pointer(x+sh, y+dy)->y = y;
        if (dx>=0) { kd.dn.pointer(x+sh-1, y+dy)->x = BCIRCLE;
                     kd.dn.pointer(x+sh-1, y+dy)->y = BCIRCLE;
        } else     { kd.dn.pointer(x+sh+1, y+dy)->x = BCIRCLE;
                     kd.dn.pointer(x+sh+1, y+dy)->y = BCIRCLE;
        }
        dx++;
      } else if (mname.Pos("CROSS") > 0) {
        for (i=0; i<Dmark.sp[kd.csp]->wale; i++, x++, kd.dmp++) {
          dx = Dmark.sp[kd.csp]->move[i].x;
          dy = 1;
          kd.up.pointer(x, y)->x = x+dx;    kd.up.pointer(x, y)->y = y+dy;
          kd.dn.pointer(x+dx, y+dy)->x = x; kd.dn.pointer(x+dx, y+dy)->y = y;
        }
        x--; kd.dmp--;
        dx = 0;
      } else if (mname.Pos("TUCK") > 0) {
        if ((*kd.dmp&0x80) == 0)
        for (i=0; i<Dmark.sp[kd.csp]->course; i++) {
          dx = Dmark.sp[kd.csp]->move[i].x;
          dy = Dmark.sp[kd.csp]->move[i].y;
          kd.up.pointer(x, y-i)->x = x+dx;    kd.up.pointer(x, y-i)->y = y+dy;
          kd.dn.pointer(x+dx, y-i+dy)->x = x; kd.dn.pointer(x+dx, y-i+dy)->y = y-i;
        }
        dx = 0;
      }
    }
  }
  for (y=kd.StitchHeight-1; y<kd.StitchHeight; y++) {
    kd.dmp = kd.bmMark.ScanLine(y);
    for (x=0; x<kd.StitchWidth; x++, kd.dmp++) {
      kd.up.pointer(x, y)->x = x; kd.up.pointer(x, y)->y = y;
    }
  }


  for (y=kd.rcStitch.Top; y<kd.rcStitch.Bottom; y++) {
    sh = 0;
    kd.dmp = kd.bmMark.ScanLine(y)+kd.rcStitch.Left;
    for (i=0; i<8; i++) bent[i] = 0.0;
    for (x=kd.rcStitch.Left; x<kd.rcStitch.Right; x++, kd.dmp++) {
      kd.csp = *kd.dmp&0x3F;
      if (kd.csp>1 && (*kd.dmp&0x80)==0) {
        mname = Dmark.sp[kd.csp]->mname;
        MarkData = Dmark.sp[kd.csp];
        if (mname.Pos("TOG2") > 0) {
          if (sh <= 0) {
            sh--;
            for (i=0; i<8; i++) {
              *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
            }
            for (i=0; i<8; i++)
              bent[i] += *(Dmark.sp[kd.csp]->bent[i]+Dmark.sp[kd.csp]->size.x+1);
          } else {
            sh--;
            for (i=0; i<8; i++)
              bent[i] += *(Dmark.sp[kd.csp]->bent[i]+Dmark.sp[kd.csp]->size.x+1);
            for (i=0; i<8; i++) {
              *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
            }
          }
        } else if (mname.Pos("CIRCLE") > 0) {
          if (sh >= 0) {
            sh++;
            for (i=0; i<8; i++)
              bent[i] += *(Dmark.sp[kd.csp]->bent[i]+Dmark.sp[kd.csp]->size.x+1);
            for (i=0; i<8; i++) {
              *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
            }
          } else {
            sh++;
            for (i=0; i<8; i++) {
              *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
            }
            for (i=0; i<8; i++)
              bent[i] += *(Dmark.sp[kd.csp]->bent[i]+Dmark.sp[kd.csp]->size.x+1);
          }
        } else if (mname.Pos("TOG3") > 0) {
          for (i=0; i<8; i++)
            bent[i] += *(Dmark.sp[kd.csp]->bent[i]+Dmark.sp[kd.csp]->size.x+1);
          if (sh==0) {
                  for (i=0; i<8; i++) {
                    *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
                  }
          } else if (sh==1){
                  for (i=0; i<8; i++) {
                    *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
                  }
          } else if (sh==2){
                  for (i=0; i<8; i++) {
                    *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
                  }
          }
          for (i=0; i<8; i++)
            bent[i] += *(Dmark.sp[kd.csp]->bent[i]+Dmark.sp[kd.csp]->size.x+1);
          sh -= 2;
        } else {
          for (i=0; i<8; i++)
            bent[i] = 0.0;
          sy = y+Dmark.sp[kd.csp]->start.y;
          for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
            sx = x+Dmark.sp[kd.csp]->start.x;
            for (cx=0; cx<Dmark.sp[kd.csp]->size.x; cx++, sx++) {
              if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                for (i=0; i<8; i++) {
                  *kd.pos[i].pointer(sx, sy) += *(Dmark.sp[kd.csp]->bent[i]+
                    cy*Dmark.sp[kd.csp]->size.x+cx)*dps[i>>2];
                }
            }
          }
        }
      } else if (kd.csp <= 1) {
        if (sh<0) {
                  for (i=0; i<8; i++) {
                    *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
                  }
        } else if (sh>0) {
                  for (i=0; i<8; i++) {
                    *kd.pos[i].pointer(x, y) += (bent[i])*dps[i>>2];
                  }
        }
      }
    }
  }


  if (!xmove.create(kd.StitchWidth, kd.StitchHeight)) goto fail;
  if (xmove.lock()==NULL) goto fail;
  for (y=kd.rcStitch.Top; y<kd.rcStitch.Bottom; y++) {
    sh = 0;
    kd.dmp = kd.bmMark.ScanLine(y)+kd.rcStitch.Left;
    for (x=kd.rcStitch.Left; x<kd.rcStitch.Right; x++, kd.dmp++) {
      kd.csp = *kd.dmp&0x3F;
      if (kd.csp>1 && (*kd.dmp&0x80)==0) {
        mname = Dmark.sp[kd.csp]->mname;
        if (mname.Pos("TOG2") > 0) {
          if (sh <= 0) {
            sh--;
            sy = y+Dmark.sp[kd.csp]->start.y;
            for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
              sx = x+Dmark.sp[kd.csp]->start.x;
              for (cx=0; cx<=abs(Dmark.sp[kd.csp]->start.x); cx++, sx++) {
                if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                  *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                    cy*Dmark.sp[kd.csp]->size.x+cx);
              }
            }
          } else {
            sh--;
            sy = y+Dmark.sp[kd.csp]->start.y;
            for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
              sx = x+Dmark.sp[kd.csp]->start.x;
              for (cx=Dmark.sp[kd.csp]->size.x/2; cx<Dmark.sp[kd.csp]->size.x; cx++, sx++) {
                if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                  *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                    cy*Dmark.sp[kd.csp]->size.x+cx);
              }
            }
          }
        } else if (mname.Pos("CIRCLE") > 0) {
          if (sh >= 0) {
            sh++;
            sy = y+Dmark.sp[kd.csp]->start.y;
            for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
              sx = x+Dmark.sp[kd.csp]->start.x;
              for (cx=0; cx<=abs(Dmark.sp[kd.csp]->start.x); cx++, sx++) {
                if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                  *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                    cy*Dmark.sp[kd.csp]->size.x+cx);
              }
            }
          } else {
            sh++;
            sy = y+Dmark.sp[kd.csp]->start.y;
            for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
              sx = x+Dmark.sp[kd.csp]->start.x;
              for (cx=Dmark.sp[kd.csp]->size.x/2; cx<Dmark.sp[kd.csp]->size.x; cx++, sx++) {
                if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                  *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                    cy*Dmark.sp[kd.csp]->size.x+cx);
              }
            }
          }
        } else if (mname.Pos("TOG3") > 0) {
          if (sh==0) {
            sh-=2;
            sy = y+Dmark.sp[kd.csp]->start.y;
            for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
              sx = x+Dmark.sp[kd.csp]->start.x;
              for (cx=0; cx<Dmark.sp[kd.csp]->size.x/3; cx++, sx++) {
                if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                  *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                    cy*Dmark.sp[kd.csp]->size.x+cx);
              }
            }
          } else if (sh==1){
            sh-=2;
            sy = y+Dmark.sp[kd.csp]->start.y;
            for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
              sx = x+Dmark.sp[kd.csp]->start.x;
              for (cx=Dmark.sp[kd.csp]->size.x/3; cx<Dmark.sp[kd.csp]->size.x*2/3; cx++, sx++) {
                if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                  *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                    cy*Dmark.sp[kd.csp]->size.x+cx);
              }
            }
          } else if (sh==2){
            sh-=2;
            sy = y+Dmark.sp[kd.csp]->start.y;
            for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
              sx = x+Dmark.sp[kd.csp]->start.x;
              for (cx=Dmark.sp[kd.csp]->size.x*2/3; cx<Dmark.sp[kd.csp]->size.x; cx++, sx++) {
                if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                  *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                    cy*Dmark.sp[kd.csp]->size.x+cx);
              }
            }
          }
        } else {
          sy = y+Dmark.sp[kd.csp]->start.y;
          for (cy=0; cy<Dmark.sp[kd.csp]->size.y; cy++, sy++) {
            sx = x+Dmark.sp[kd.csp]->start.x;
            for (cx=0; cx<Dmark.sp[kd.csp]->size.x; cx++, sx++) {
              if (0<=sx && sx<kd.StitchWidth && 0<=sy && sy<kd.StitchHeight)
                *xmove.pointer(sx, sy) |= *(Dmark.sp[kd.csp]->fix+
                  cy*Dmark.sp[kd.csp]->size.x+cx);
            }
          }
        }
      }
    }
  }


  for (y=kd.rcStitch.Top; y<kd.rcStitch.Bottom-1; y++) {
    for (x=kd.rcStitch.Left; x<kd.rcStitch.Right-1; x++, kd.dmp++) {
      up = *kd.up.pointer(x, y);
      move = *xmove.pointer(x, y);
        if ((move&1)==0) {
          *kd.pos[XRD].pointer(x, y) = *kd.pos[XLD].pointer(x+1, y) =
            (*kd.pos[XRD].pointer(x, y)+*kd.pos[XLD].pointer(x+1, y))>>1;
        }
        *kd.pos[YRD].pointer(x, y) = *kd.pos[YLD].pointer(x+1, y) =
          (*kd.pos[YRD].pointer(x, y)+*kd.pos[YLD].pointer(x+1, y))>>1;
        if ((move&4)==0) {
          *kd.pos[XLU].pointer(x, y) = *kd.pos[XLD].pointer(up.x, up.y) =
            (*kd.pos[XLU].pointer(x, y)+*kd.pos[XLD].pointer(up.x, up.y))>>1;
        }
        *kd.pos[YLU].pointer(x, y) = *kd.pos[YLD].pointer(up.x, up.y) =
          (*kd.pos[YLU].pointer(x, y)+*kd.pos[YLD].pointer(up.x, up.y))>>1;
        if ((move&2)==0 && (move&8)==0) {
          *kd.pos[XRU].pointer(x, y) = *kd.pos[XLU].pointer(x+1, y) =
          *kd.pos[XRD].pointer(up.x, up.y) = *kd.pos[XLD].pointer(up.x+1, up.y) =
            (*kd.pos[XRU].pointer(x, y) + *kd.pos[XLU].pointer(x+1, y) +
             *kd.pos[XRD].pointer(up.x, up.y) + *kd.pos[XLD].pointer(up.x+1, up.y))/4;
          *kd.pos[YRU].pointer(x, y) = *kd.pos[YLU].pointer(x+1, y) =
          *kd.pos[YRD].pointer(up.x, up.y) = *kd.pos[YLD].pointer(up.x+1, up.y) =
            (*kd.pos[YRU].pointer(x, y) + *kd.pos[YLU].pointer(x+1, y) +
             *kd.pos[YRD].pointer(up.x, up.y) + *kd.pos[YLD].pointer(up.x+1, up.y))/4;
        } else {
          if ((move&2)==0) {
            *kd.pos[XRU].pointer(x, y) = *kd.pos[XLU].pointer(x+1, y) =
              (*kd.pos[XRU].pointer(x, y)+*kd.pos[XLU].pointer(x+1, y))>>1;
          }
          *kd.pos[YRU].pointer(x, y) = *kd.pos[YLU].pointer(x+1, y) =
            (*kd.pos[YRU].pointer(x, y)+*kd.pos[YLU].pointer(x+1, y))>>1;
          if ((move&8)==0) {
            *kd.pos[XRU].pointer(x, y) = *kd.pos[XRD].pointer(up.x, up.y) =
              (*kd.pos[XRU].pointer(x, y)+*kd.pos[XRD].pointer(up.x, up.y))>>1;
          }
          *kd.pos[YRU].pointer(x, y) = *kd.pos[YRD].pointer(up.x, up.y) =
            (*kd.pos[YRU].pointer(x, y)+*kd.pos[YRD].pointer(up.x, up.y))>>1;
        }
          *kd.pos[XLU].pointer(x, y) = *kd.pos[XLD].pointer(up.x, up.y) =
            (*kd.pos[XLU].pointer(x, y)+*kd.pos[XLD].pointer(up.x, up.y))>>1;
        *kd.pos[YLU].pointer(x, y) = *kd.pos[YLD].pointer(up.x, up.y) =
          (*kd.pos[YLU].pointer(x, y)+*kd.pos[YLD].pointer(up.x, up.y))>>1;
            *kd.pos[XRU].pointer(x, y) = *kd.pos[XRD].pointer(up.x, up.y) =
              (*kd.pos[XRU].pointer(x, y)+*kd.pos[XRD].pointer(up.x, up.y))>>1;
          *kd.pos[YRU].pointer(x, y) = *kd.pos[YRD].pointer(up.x, up.y) =
            (*kd.pos[YRU].pointer(x, y)+*kd.pos[YRD].pointer(up.x, up.y))>>1;

    }
  }

  if (wa == NULL) {
    kd.rcStitch.Left = Range.left * (double) kdsn.wpi / dpi + 0.5 - 1;
    kd.rcStitch.Top = pYarn->Height - (Range.bottom * (double) kdsn.cpi / dpi - 0.5) - 1;
    kd.rcStitch.Right = Range.right * (double) kdsn.wpi / dpi + 0.5 + 1;
    kd.rcStitch.Bottom = pYarn->Height - (Range.top * (double) kdsn.cpi / dpi - 0.5) + 1;
    if (kd.rcStitch.Left < 0) kd.rcStitch.Left = 0;
    if (kd.rcStitch.Top < 0) kd.rcStitch.Top = 0;
    if (kd.rcStitch.Right > pYarn->Width) kd.rcStitch.Right = pYarn->Width;
    if (kd.rcStitch.Bottom > pYarn->Height) kd.rcStitch.Bottom = pYarn->Height;
  }


  sp->Position = 1;
  kd.bmOutput.Fill(1);
  for (kd.dy=kd.rcStitch.Top; kd.dy<kd.rcStitch.Bottom; kd.dy++) {
    sp->Position = 1+(double)kd.dy/(kd.rcStitch.Bottom-kd.rcStitch.Top);
    kd.dmp = kd.bmMark.ScanLine(kd.dy)+kd.rcStitch.Left;
    for (kd.dx=kd.rcStitch.Left; kd.dx<kd.rcStitch.Right; kd.dx++, kd.dmp++) {
      light = 0;
      lowerupperyarn(kd, kd.dx, kd.dy);  //7/41
      if (kd.lx == BCIRCLE) move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      else move = *xmove.pointer(kd.lx, kd.ly)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      move = *xmove.pointer(kd.ux, kd.uy)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      light = light/4.0 + 0.5;

      move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      if (*kd.dmp&0x3F && move==0x10) {
        view_stitch(kd, light);
      }
    }
  }
  sp->Position = 2;
  for (kd.dy=kd.rcStitch.Top; kd.dy<kd.rcStitch.Bottom; kd.dy++) {
    sp->Position = 2+(double)kd.dy/(kd.rcStitch.Bottom-kd.rcStitch.Top);
    kd.dmp = kd.bmMark.ScanLine(kd.dy)+kd.rcStitch.Left;
    for (kd.dx=kd.rcStitch.Left; kd.dx<kd.rcStitch.Right; kd.dx++, kd.dmp++) {
      light = 0;
      lowerupperyarn(kd, kd.dx, kd.dy);  //7/41
      if (kd.lx == BCIRCLE) move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      else move = *xmove.pointer(kd.lx, kd.ly)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      move = *xmove.pointer(kd.ux, kd.uy)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      light = light/4.0 + 0.5;

      move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) {
        view_stitch(kd, light);
      }
    }
  }
  sp->Position = 3;
  for (kd.dy=kd.rcStitch.Top; kd.dy<kd.rcStitch.Bottom; kd.dy++) {
    sp->Position = 3+(double)kd.dy/(kd.rcStitch.Bottom-kd.rcStitch.Top);
    kd.dmp = kd.bmMark.ScanLine(kd.dy)+kd.rcStitch.Left;
    for (kd.dx=kd.rcStitch.Left; kd.dx<kd.rcStitch.Right; kd.dx++, kd.dmp++) {
      light = 0;
      lowerupperyarn(kd, kd.dx, kd.dy);  //7/41
      if (kd.lx == BCIRCLE) move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      else move = *xmove.pointer(kd.lx, kd.ly)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      move = *xmove.pointer(kd.ux, kd.uy)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      if (*kd.dmp&0x3F && move==0x10)              light += 0;
      if (*kd.dmp&0x3F && (move==0 || move==0x30)) light += 2;
      if (*kd.dmp&0x3F && move==0x20)              light += 4;
      light = light/4.0 + 0.5;

      move = *xmove.pointer(kd.dx, kd.dy)&0xF0;
      if (*kd.dmp&0x3F && move==0x20) {
        view_stitch(kd, light);
      }
    }
  }
  sp->Position = 4;

/*
// -------------------------------------------------------
  for (y=kd.rcStitch.Top; y<kd.rcStitch.Bottom; y++) {
    sp->Position = 4+(double)y/(kd.rcStitch.Bottom-kd.rcStitch.Top);
    kd.dmp = kd.bmMark.ScanLine(y)+kd.rcStitch.Left;
    for (x=kd.rcStitch.Left; x<kd.rcStitch.Right; x++, kd.dmp++) {
      *kd.dmp &= 0x3F;
    }
  }
// --------------------------------------------------------
*/
  sp->Position = 5;

  if (ksmlt.hair.sw==1) {
    if (wa != NULL) {
      if (wa->Mask) {
        rcOutput.Left = wa->Range.left;
        rcOutput.Top = pOutput->Height - wa->Range.bottom;
        rcOutput.Right = wa->Range.right;
        rcOutput.Bottom = pOutput->Height - wa->Range.top;
      } else {
        rcOutput.Left = 0;
        rcOutput.Top = 0;
        rcOutput.Right = pOutput->Width;
        rcOutput.Bottom = pOutput->Height;
      }
    } else {
      rcOutput.Left = Range.left;
      rcOutput.Top = pOutput->Height - Range.bottom;
      rcOutput.Right = Range.right;
      rcOutput.Bottom = pOutput->Height - Range.top;
    }
    for (y=rcOutput.Top; y<rcOutput.Bottom; y+=ksmlt.hair.gap) {
      sp->Position = 5+(double)y/(rcOutput.Bottom-rcOutput.Top);
      for (x=rcOutput.Left; x<rcOutput.Right; x+=ksmlt.hair.gap) {
        sx = x+rand()%ksmlt.hair.gap; sy = y+rand()%ksmlt.hair.gap;
        if (sx>=rcOutput.Left && sy>=rcOutput.Top && sx<rcOutput.Right && sy<rcOutput.Bottom) {
          c = *(kd.bmOutput.ScanLine(sy)+sx);
          if (c) {
            for (i=0; i<ksmlt.hair.len; i++) {
              if (rand()%2) sx += (rand()%2) ? 1 : -1;
              else sy += (rand()%2) ? 1 : -1;
              if (sx>=rcOutput.Left && sy>=rcOutput.Top && sx<rcOutput.Right && sy<rcOutput.Bottom) {
                *(kd.bmOutput.ScanLine(sy)+sx) = c;
              } else break;
            }
          }
        }
      }
    }
  }

//  ksmlt.cp.finish = 1;

  if (wa != NULL) {
    pOutput->LoadFromMemory(kd.bmOutput.ScanLine(), kd.bmOutput.BytesPerLine, true);
  } else {
    Range.top -= dpi/kdsn.cpi;
    Range.bottom += dpi/kdsn.cpi;
    Range.left -= dpi/kdsn.wpi;
    Range.right += dpi/kdsn.wpi;
    if (Range.left < 0) Range.left = 0;
    if (Range.top < 0) Range.top = 0;
    if (Range.right > kd.OutputWidth) Range.right = kd.OutputWidth;
    if (Range.bottom > kd.OutputHeight) Range.bottom = kd.OutputHeight;

    pOutput->FillRect(Range, PALETTEINDEX(1));

    pOutput->StartScanLine();
    for (y=Range.top; y<Range.bottom; y++) {
      IP = kd.bmOutput.ScanLine(pOutput->Height-y-1);
      OP = pOutput->GetScanLine(y);
      for (x=Range.left; x<Range.right; x++) {
        if (*(IP+x) > 1) *(OP+x) = *(IP+x);
      }
      pOutput->PutScanLine(y);
    }
  }

  sp->End();
} catch (...) {
  char *func = __FUNC__;
  int line = __LINE__;
  MessageDlg(Format("Error : %s (%d)", OPENARRAY(TVarRec, (func, line))),
    mtInformation, TMsgDlgButtons() << mbOK, 0);
  return;
}
  return;
fail:
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------