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

#include "yarnmap.h"
#include "define.h"
#include "common.h"
#include <TClrUtil.hpp>
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
typedef struct tag_My3D {
  bool used;      // »ç¿ëµÇ´Â°¡ ¿©ºÎ
  bool special;   // Ư¼öÇÑ ¼ºÁúÀ» ÁöÁ¤
  int special_cnt;// Ư¼öÇÑ ¼ºÁúÀ» ³»´Â ³à¼®ÀÇ °¹¼ö

  POINT pos[4];   // ½Ã°è¹æÇâÀ¸·Î µ¹¾Æ°£´Ù
  double z;
  double brt;

  double glx, gly;
  double sqr[4];
  double a[4], b[4], c[4];

  void _fastcall set_constant(){
     repro_dis(0, 0, 1);
    repro_dis(1, 2, 3);
     repro_dis(2, 3, 0);
    repro_dis(3, 1, 2);
  }
  void __fastcall repro_dis(int i, int j, int k){
    a[i] = pos[j].y - pos[k].y;
    b[i] = pos[k].x - pos[j].x;
    c[i] = pos[j].x * pos[k].y - pos[k].x * pos[j].y;
    sqr[i] = sqrt(a[i] * a[i] + b[i] * b[i]);
  }
  void _fastcall find_point(int &ix, int &iy, int &ox, int &oy){
    double lx1, lx2, ly1, ly2;
    ly1 = fabs(a[0] * ix + b[0] * iy + c[0]) / sqr[0];
    ly2 = fabs(a[1] * ix + b[1] * iy + c[1]) / sqr[1];
     lx1 = fabs(a[2] * ix + b[2] * iy + c[2]) / sqr[2];
    lx2 = fabs(a[3] * ix + b[3] * iy + c[3]) / sqr[3];
     if (lx1 + lx2 && ly1 + ly2) {
       ox = lx1 * glx / (lx1 + lx2);
      oy = ly1 * gly / (ly1 + ly2);
    } else {
      ox = 0;
      oy = 0;
    }
  }
} My3D;
//---------------------------------------------------------------------------
__fastcall Vector::Vector(){
//  pts = NULL;
//  dim = 0;
  pts[0]=0;
  pts[1]=0;
  pts[2]=0;
  dim = 0;
}
//---------------------------------------------------------------------------
__fastcall Vector::~Vector(){
//  if(pts) delete [] pts;
}
//---------------------------------------------------------------------------
void __fastcall Vector::init(int d){
//  if(pts) delete [] pts;
//  pts = new double[d];
  dim = d;
}
//---------------------------------------------------------------------------
void __fastcall Vector::init3(double x, double y, double z){
  init(3);
  set(0,x);
  set(1,y);
  set(2,z);
}
//---------------------------------------------------------------------------
double __fastcall Vector::get(int n){
  if(dim<=n) return 0;
  return *(pts+n);
}
//---------------------------------------------------------------------------
void __fastcall Vector::set(int n, double x){
  if(dim<=n) return;
  *(pts+n) = x;
}
//---------------------------------------------------------------------------
double __fastcall Vector::length(){
  if(dim==0) return 0;
  double r=0, r1;
  for(int i=0;i<dim;i++){
    r1 = *(pts+i);
    r+= r1*r1;
  }
  return sqrt(r);
}
//---------------------------------------------------------------------------
double __fastcall Vector::dot(Vector &v){
  if(dim==0) return 0;
  if(dim!=v.dim) return 0;
  double r=0;
  for(int i=0;i<dim;i++){
    r+= *(pts+i)*v.get(i);
  }
  return r;
}
//---------------------------------------------------------------------------
void __fastcall Vector::add(Vector &v1, Vector &v2){
  if(dim==0) return;
  if(dim!=v1.dim||dim!=v2.dim) return;
  for(int i=0;i<dim;i++){
    set(i,v1.get(i)+v2.get(i));
  }
}
//---------------------------------------------------------------------------
void __fastcall Vector::sub(Vector &v1, Vector &v2){
  if(dim==0) return;
  if(dim!=v1.dim||dim!=v2.dim) return;
  for(int i=0;i<dim;i++){
    set(i,v1.get(i)-v2.get(i));
  }
}
//---------------------------------------------------------------------------
void __fastcall Vector::cross(Vector &v1, Vector &v2){
  if(dim!=3) return;
  if(v1.dim!=3||v2.dim!=3) {
    return;
  } else {
    set(0,v1.get(1)*v2.get(2)-v1.get(2)*v2.get(1));
    set(1,v1.get(2)*v2.get(0)-v1.get(0)*v2.get(2));
    set(2,v1.get(0)*v2.get(1)-v1.get(1)*v2.get(0));
  }
}
//---------------------------------------------------------------------------
void __fastcall Vector::scalar(double s){
  for(int i=0;i<dim;i++){
    *(pts+i)*=s;
  }
}
//---------------------------------------------------------------------------
void __fastcall Vector::normal(){
  if(0<length()){
    scalar(1.0/length());
  }
}
//---------------------------------------------------------------------------

__fastcall Yarnmap::Yarnmap(int Width, int Height, double Zoom, bool Back, bool ColorOnColor, int fuzz, TColor bgc){

  tricot=NULL;

  TopList = new TList;
  HighList = new TList;
  MidList = new TList;
  LowList = new TList;
  BottomList = new TList;

  this->Width=Width;
  this->Height=Height;

  this->Zoom=Zoom;
  this->Back=Back;
  this->fuzz=fuzz;
  this->ColorOnColor=ColorOnColor;
  bg_color=bgc;
}
//---------------------------------------------------------------------------
__fastcall Yarnmap::~Yarnmap(){

  LINE3D *item = NULL;
  for (int i = 0; i < TopList->Count; i++) {
    item = (LINE3D *)TopList->Items[i];
    delete item;
  }
  TopList->Clear();
  delete TopList;

  for (int i = 0; i < HighList->Count; i++) {
    item = (LINE3D *)HighList->Items[i];
    delete item;
  }
  HighList->Clear();
  delete HighList;

  for (int i = 0; i < MidList->Count; i++) {
    item = (LINE3D *)MidList->Items[i];
    delete item;
  }
  MidList->Clear();
  delete MidList;

  for (int i = 0; i < LowList->Count; i++) {
    item = (LINE3D *)LowList->Items[i];
    delete item;
  }
  LowList->Clear();
  delete LowList;

  for (int i = 0; i < BottomList->Count; i++) {
    item = (LINE3D *)BottomList->Items[i];
    delete item;
  }
  BottomList->Clear();
  delete BottomList;

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::MappingTricot(Tricot *tricot){ //MappingOctopus¸¦ ÀÛµ¿½ÃŲ´Ù
  this->tricot = tricot;

  if(fuzz<0)fuzz=0;
  if(fuzz>99)fuzz=99;

  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Octopus *octo = tricot->GetOctopus(i,j);
      Octopus *octo2 = tricot->GetOctopus(i,j-1);
      if(octo->used!=true)continue;
      double x = tricot->FindRealPosX(octo,i,j);
      double y = tricot->FindRealPosY(octo,i,j);
      octo->plusX=0;
      octo->plusY=0;
      if(octo2->used!=true)continue;
      double Radius=0.3*DOT_PER_CM*Zoom;
      double sx = tricot->FindRealPosX(octo2,i,j-1)+(rand()%(int)(1.0+Radius*fuzz)-Radius*fuzz/2.0)/100.0;
      double sy = tricot->FindRealPosY(octo2,i,j-1)+(rand()%(int)(1.0+Radius*fuzz)-Radius*fuzz/2.0)/100.0;
      double rx,ry;
      FindR90VectorDouble(sx,sy,x,y,rx,ry);
      octo->plusX=rx*(0.05+0.2*octo2->head_wideness);
      octo->plusY=ry*(0.05+0.2*octo2->head_wideness);
    }
  }

  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Octopus *octo = tricot->GetOctopus(i,j);
      if(octo->used==true)MappingOctopus(octo, i, j);
    }
  }

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::MappingOctopus(Octopus *octo, int i, int j){
  LEG *Leg;
  HEAD *Head;

  double x = tricot->FindRealPosX(octo,i,j);
  double y = tricot->FindRealPosY(octo,i,j);

  int max_layer=0;
  int head_stack[MAX_LAYER_COUNT]={0,0,0,0,0,0};
  if(octo->hasHead){
    for(int k=0;k<octo->ListOfHead->Count;k++){
      Head = (HEAD *)octo->ListOfHead->Items[k];
      if(head_stack[Head->Layer]==0){
        max_layer++;
        head_stack[Head->Layer]=max_layer;
      }
    }
  }
  if(octo->hasHead){
    for(int k=0;k<octo->ListOfHead->Count;k++){
      Head = (HEAD *)octo->ListOfHead->Items[k];
      if(Head->isTransParent)continue;
      Octopus *sideocto = (Octopus *)tricot->GetOctopus(i, j+1);
      double sx = tricot->FindRealPosX(sideocto,i,j+1);
      double sy = tricot->FindRealPosY(sideocto,i,j+1);
      if(sideocto->used==true){
        MappingHead(
          sx-sideocto->plusX, sy-sideocto->plusY,
          sx+sideocto->plusX, sy+sideocto->plusY,
          x-octo->plusX, y-octo->plusY,
          x+octo->plusX, y+octo->plusY,
          Head->Layer, Head->yarn, Head->ht, head_stack[Head->Layer]-1);
      }
    }
  }
  
  for(int k=0;k<octo->ListOfLeg->Count;k++){
    Leg = (LEG *)octo->ListOfLeg->Items[k];
    if(Leg->ls==NO_LEG)continue;
    if(Leg->isTransParent)continue;
    Octopus *sideocto = (Octopus *)tricot->GetOctopus(Leg->link.x,Leg->link.y);
    double sx = tricot->FindRealPosX(sideocto,Leg->link.x,Leg->link.y);
    double sy = tricot->FindRealPosY(sideocto,Leg->link.x,Leg->link.y);
    switch(Leg->lt){
      case RR_LEG:
        MappingLeg(x+octo->plusX, y+octo->plusY, sx+sideocto->plusX, sy+sideocto->plusY, Leg->Layer, Leg->yarn, Leg->ls);
        break;
      case RL_LEG:
        MappingLeg(x+octo->plusX, y+octo->plusY, sx-sideocto->plusX, sy-sideocto->plusY, Leg->Layer, Leg->yarn, Leg->ls);
        break;
      case LR_LEG:
        MappingLeg(x-octo->plusX, y-octo->plusY, sx+sideocto->plusX, sy+sideocto->plusY, Leg->Layer, Leg->yarn, Leg->ls);
        break;
      case LL_LEG:
        MappingLeg(x-octo->plusX, y-octo->plusY, sx-sideocto->plusX, sy-sideocto->plusY, Leg->Layer, Leg->yarn, Leg->ls);
        break;
    }
  }

  Octopus *octo1 = (Octopus *)tricot->GetOctopus(i,j);
  Octopus *octo2 = (Octopus *)tricot->GetOctopus(i-1,j);
  double x1,x2,y1,y2;
  if(octo2->used){
    x1 = tricot->FindRealPosX(octo1,i,j);
    y1 = tricot->FindRealPosY(octo1,i,j);
    x2 = tricot->FindRealPosX(octo2,i-1,j);
    y2 = tricot->FindRealPosY(octo2,i-1,j);
  } else {
    x1 = tricot->FindRealPosX(octo1,i,j);
    y1 = tricot->FindRealPosY(octo1,i,j);
    x2 = x1;
    y2 = y1;
  }

  for(int k=0;k<octo->ListOfSLeg->Count;k++){
    SLEG *Leg = (SLEG *)octo->ListOfSLeg->Items[k];
    if(Leg->ls==NO_LEG)continue;
    if(Leg->isTransParent)continue;
    Octopus *sideocto1 = (Octopus *)tricot->GetOctopus(Leg->link.x,Leg->link.y);
    Octopus *sideocto2 = (Octopus *)tricot->GetOctopus(Leg->link.x-1,Leg->link.y);
    double sx1,sy1,sx2,sy2;
    if(sideocto2->used){
      sx1 = tricot->FindRealPosX(sideocto1,Leg->link.x,Leg->link.y);
      sy1 = tricot->FindRealPosY(sideocto1,Leg->link.x,Leg->link.y);
      sx2 = tricot->FindRealPosX(sideocto2,Leg->link.x-1,Leg->link.y);
      sy2 = tricot->FindRealPosY(sideocto2,Leg->link.x-1,Leg->link.y);
    } else {
      sx1 = tricot->FindRealPosX(sideocto1,Leg->link.x,Leg->link.y);
      sy1 = tricot->FindRealPosY(sideocto1,Leg->link.x,Leg->link.y);
      sx2 = sx1;
      sy2 = sy1;
    }

    double ox,oy,sx,sy;
    switch(Leg->slt1){
      case LL_SLEG:
        ox=x1;
        oy=y1;
        break;
      case L_SLEG:
        ox=0.8*x1+0.2*x2;
        oy=0.8*y1+0.2*y2;
        break;
      case C_SLEG:
        ox=(x1+x2)*0.5;
        oy=(y1+y2)*0.5;
        break;
      case R_SLEG:
        ox=0.2*x1+0.8*x2;
        oy=0.2*y1+0.8*y2;
        break;
      case RR_SLEG:
        ox=x2;
        oy=y2;
        break;
    }
    switch(Leg->slt2){
      case LL_SLEG:
        sx=sx1;
        sy=sy1;
        break;
      case L_SLEG:
        sx=0.8*sx1+0.2*sx2;
        sy=0.8*sy1+0.2*sy2;
        break;
      case C_SLEG:
        sx=(sx1+sx2)*0.5;
        sy=(sy1+sy2)*0.5;
        break;
      case R_SLEG:
        sx=0.2*sx1+0.8*sx2;
        sy=0.2*sy1+0.8*sy2;
        break;
      case RR_SLEG:
        sx=sx2;
        sy=sy2;
        break;
    }
    MappingLeg(ox, oy, sx, sy, Leg->Layer, Leg->yarn, Leg->ls);
  }


}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::MappingLeg(double ox, double oy, double sx, double sy,
  int Layer, Yarn *yarn, LEG_STATE ls){

  double effectiveD=DenierToDiameter(yarn->denier, yarn->filament)*DOT_PER_CM*Zoom;
  //effectiveD*=(1+yarn->contraction);//½ºÆÇó·³ ¶¯°Ü¼­ °¨´Â ½ÇÀº ½ÇÁ¦ º¸´Ù ¾ã¾ÆÁø´Ù//±×·¯³ª ¼öÃàµÇ¸é¼­ ´Ù½Ã ¿ø·¡ µÎ²²·Î µ¹¾Æ¿Â´Ù

  LINE3D *line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=ox;
  line->p1y=oy;
  line->p2x=sx*0.1+ox*0.9;
  line->p2y=sy*0.1+oy*0.9;
  line->yarn=yarn;
  HighList->Add(line);
  if(ls==TOP_LEG||ls==TOP_LEG_FORCE){
    line = new LINE3D;
    line->Layer=Layer;
    line->D=effectiveD;
    line->p1x=sx*0.1+ox*0.9;
    line->p1y=sy*0.1+oy*0.9;
    line->p2x=ox*0.1+sx*0.9;
    line->p2y=oy*0.1+sy*0.9;
    line->yarn=yarn;
    TopList->Add(line);
  } else if(ls==BOTTOM_LEG||ls==BOTTOM_LEG_FORCE){
    line = new LINE3D;
    line->Layer=Layer;
    line->D=effectiveD;
    line->p1x=sx*0.1+ox*0.9;
    line->p1y=sy*0.1+oy*0.9;
    line->p2x=ox*0.1+sx*0.9;
    line->p2y=oy*0.1+sy*0.9;
    line->yarn=yarn;
    BottomList->Add(line);
  } else {
    line = new LINE3D;
    line->Layer=Layer;
    line->D=effectiveD;
    line->p1x=sx*0.1+ox*0.9;
    line->p1y=sy*0.1+oy*0.9;
    line->p2x=ox*0.1+sx*0.9;
    line->p2y=oy*0.1+sy*0.9;
    line->yarn=yarn;
    MidList->Add(line);
  }
  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=ox*0.1+sx*0.9;
  line->p1y=oy*0.1+sy*0.9;
  line->p2x=sx;
  line->p2y=sy;
  line->yarn=yarn;
  MidList->Add(line);

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::MappingHead(
  double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4,
  int Layer, Yarn *yarn, HEAD_TYPE ht, int head_stack){

  LINE3D *line;
  double effectiveD=DenierToDiameter(yarn->denier, yarn->filament)*DOT_PER_CM*Zoom;
  //effectiveD*=(1+yarn->contraction);//½ºÆÇó·³ ¶¯°Ü¼­ °¨´Â ½ÇÀº ½ÇÁ¦ º¸´Ù ¾ã¾ÆÁø´Ù//±×·¯³ª ¼öÃàµÇ¸é¼­ ´Ù½Ã ¿ø·¡ µÎ²²·Î µ¹¾Æ¿Â´Ù
  
  double LayerFactor;
  switch(head_stack){
    case 0:
      LayerFactor=0.8;
      break;
    case 1:
      LayerFactor=1.0;
      break;
    case 2:
      LayerFactor=1.2;
      break;
    case 3:
      LayerFactor=1.4;
      break;
    case 4:
      LayerFactor=1.6;
      break;
    case MAX_LAYER_COUNT-1:
      LayerFactor=1.8;
      break;
  }
  switch(ht){
    case R_HEAD: x3=x4;y3=y4; break;
    case L_HEAD: x4=x3;y4=y3; break;
  }

  double rx=0.5*(x1+x2)-0.5*(x3+x4),ry=0.5*(y1+y2)-0.5*(y3+y4),
    rx2=0.5*(x1-x2),ry2=0.5*(y1-y2),
    rx3=0.5*(x1+x2)-x3,ry3=0.5*(y1+y2)-y3,
    rx4=0.5*(x1+x2)-x4,ry4=0.5*(y1+y2)-y4;
  double cx=x2+rx2,cy=y2+ry2;
  double r2=sqrt(rx2*rx2+ry2*ry2);
  double rx2n,ry2n;
  if(r2==0){
    rx2n=0;
    ry2n=0;
  } else {
    rx2n=rx2/r2;
    ry2n=ry2/r2;
  }
  ///¿À¸¥ÂÊ
  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx+rx*0.2*LayerFactor;
  line->p1y=cy+ry*0.2*LayerFactor;
  line->p2x=cx+rx*0.1*LayerFactor -rx2*0.8*LayerFactor  -0.2*effectiveD*rx2n*LayerFactor;
  line->p2y=cy+ry*0.1*LayerFactor -ry2*0.8*LayerFactor  -0.2*effectiveD*ry2n*LayerFactor;
  line->yarn=yarn;
  HighList->Add(line);

  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx+rx*0.1*LayerFactor -rx2*0.8*LayerFactor  -0.2*effectiveD*rx2n*LayerFactor;
  line->p1y=cy+ry*0.1*LayerFactor -ry2*0.8*LayerFactor  -0.2*effectiveD*ry2n*LayerFactor;
  line->p2x=cx                    -rx2*LayerFactor      -0.3*effectiveD*rx2n*LayerFactor;
  line->p2y=cy                    -ry2*LayerFactor      -0.3*effectiveD*ry2n*LayerFactor;
  line->yarn=yarn;
  MidList->Add(line);

  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx                    -rx2*LayerFactor      -0.3*effectiveD*rx2n*LayerFactor;
  line->p1y=cy                    -ry2*LayerFactor      -0.3*effectiveD*ry2n*LayerFactor;
  line->p2x=cx-rx4*0.5            -rx2*0.5*LayerFactor  -0.2*effectiveD*rx2n*LayerFactor;
  line->p2y=cy-ry4*0.5            -ry2*0.5*LayerFactor  -0.2*effectiveD*ry2n*LayerFactor;
  line->yarn=yarn;
  LowList->Add(line);

  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx-rx4*0.5            -rx2*0.5*LayerFactor  -0.2*effectiveD*rx2n*LayerFactor;
  line->p1y=cy-ry4*0.5            -ry2*0.5*LayerFactor  -0.2*effectiveD*ry2n*LayerFactor;
  line->p2x=x4;
  line->p2y=y4;
  line->yarn=yarn;
  LowList->Add(line);

  ///¿ÞÂÊ
  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx+rx*0.2*LayerFactor;
  line->p1y=cy+ry*0.2*LayerFactor;
  line->p2x=cx+rx*0.1*LayerFactor +rx2*0.8*LayerFactor  +0.2*effectiveD*rx2n*LayerFactor;
  line->p2y=cy+ry*0.1*LayerFactor +ry2*0.8*LayerFactor  +0.2*effectiveD*ry2n*LayerFactor;
  line->yarn=yarn;
  HighList->Add(line);

  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx+rx*0.1*LayerFactor +rx2*0.8*LayerFactor  +0.2*effectiveD*rx2n*LayerFactor;
  line->p1y=cy+ry*0.1*LayerFactor +ry2*0.8*LayerFactor  +0.2*effectiveD*ry2n*LayerFactor;
  line->p2x=cx                    +rx2*LayerFactor      +0.3*effectiveD*rx2n*LayerFactor;
  line->p2y=cy                    +ry2*LayerFactor      +0.3*effectiveD*ry2n*LayerFactor;
  line->yarn=yarn;
  MidList->Add(line);

  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx                    +rx2*LayerFactor      +0.3*effectiveD*rx2n*LayerFactor;
  line->p1y=cy                    +ry2*LayerFactor      +0.3*effectiveD*ry2n*LayerFactor;
  line->p2x=cx-rx3*0.5            +rx2*0.5*LayerFactor  +0.2*effectiveD*rx2n*LayerFactor;
  line->p2y=cy-ry3*0.5            +ry2*0.5*LayerFactor  +0.2*effectiveD*ry2n*LayerFactor;
  line->yarn=yarn;
  LowList->Add(line);

  line = new LINE3D;
  line->Layer=Layer;
  line->D=effectiveD;
  line->p1x=cx-rx3*0.5            +rx2*0.5*LayerFactor  +0.2*effectiveD*rx2n*LayerFactor;
  line->p1y=cy-ry3*0.5            +ry2*0.5*LayerFactor  +0.2*effectiveD*ry2n*LayerFactor;
  line->p2x=x3;
  line->p2y=y3;
  line->yarn=yarn;
  LowList->Add(line);

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::Draw(TTexpiaBitmap *bmDst, ProgressPercentage *percent, bool randomness){//´ÜÀ§´Â ¸ðµÎ dotÀÌ´Ù

  percent->Percentage(0);

  HDC dcSrc=NULL, dcDst=NULL;
  TTexpiaBitmap *bmSrc= new TTexpiaBitmap;
  bmSrc->Create(Width,Height, 24);
  bmSrc->FillRect(Rect(0,0,Width,Height),bg_color);

  const int randomdegree = 8;//gabriel
  TTexpiaBitmap *bmSrc_r[randomdegree];
  for (int i=0; i<randomdegree; i++) {
    bmSrc_r[i] = new TTexpiaBitmap;
    bmSrc_r[i]->Create(Width,Height, 24);
    bmSrc_r[i]->FillRect(Rect(0,0,Width,Height),bg_color);
  }


  dcDst = bmDst->CreateDC();
  if(dcDst==NULL){
    goto fail;
  }

  if (randomness) {
    percent->Reset("Processing Yarn effect");
    total_line = TopList->Count+HighList->Count+MidList->Count+LowList->Count+BottomList->Count;
    current_line=0;
    
    for (int i=0;i<randomdegree;i++) {
      bmSrc_r[i]->StartScanLine();
      if(Back){
        DrawList(bmSrc_r[i], TopList, percent,randomdegree);
        DrawList(bmSrc_r[i], HighList, percent);
        DrawList(bmSrc_r[i], MidList, percent);
        DrawList(bmSrc_r[i], LowList, percent);
        DrawList(bmSrc_r[i], BottomList, percent);
      } else {
        DrawList(bmSrc_r[i], BottomList, percent,randomdegree);
        DrawList(bmSrc_r[i], LowList, percent,randomdegree);
        DrawList(bmSrc_r[i], MidList, percent,randomdegree);
        DrawList(bmSrc_r[i], HighList, percent,randomdegree);
        DrawList(bmSrc_r[i], TopList, percent,randomdegree);
      }
      percent->Percentage(100/randomdegree*(i+1));
  
      bmSrc_r[i]->StopScanLine();
    }


    for(int i=0;i<=bmDst->Width/Width;i++){
      for(int j=0;j<=bmDst->Height/Height;j++){
        int index = rand()%randomdegree;
        dcSrc = bmSrc_r[index]->CreateDC();
        BitBlt(dcDst, i*Width, j*Height, Width, Height, dcSrc, 0, 0, SRCCOPY);
        bmSrc_r[index]->DeleteDC(dcSrc);
      }
    }
    bmDst->DeleteDC(dcDst);

  }
  else {
    total_line = TopList->Count+HighList->Count+MidList->Count+LowList->Count+BottomList->Count;
    current_line=0;
  
    bmSrc->StartScanLine();
    if(Back){
      DrawList(bmSrc, TopList, percent);
      DrawList(bmSrc, HighList, percent);
      DrawList(bmSrc, MidList, percent);
      DrawList(bmSrc, LowList, percent);
      DrawList(bmSrc, BottomList, percent);
    } else {
      DrawList(bmSrc, BottomList, percent);
      DrawList(bmSrc, LowList, percent);
      DrawList(bmSrc, MidList, percent);
      DrawList(bmSrc, HighList, percent);
      DrawList(bmSrc, TopList, percent);
    }
    bmSrc->StopScanLine();

    dcSrc = bmSrc->CreateDC();
    for(int i=0;i<=bmDst->Width/Width;i++){
      for(int j=0;j<=bmDst->Height/Height;j++){
        BitBlt(dcDst, i*Width, j*Height, Width, Height, dcSrc, 0, 0, SRCCOPY);
      }
    }
    bmDst->DeleteDC(dcDst);
    bmSrc->DeleteDC(dcSrc);
  }

  if(bmSrc) delete bmSrc;
  for (int i=0;i<randomdegree;i++)
    if(bmSrc_r[i]) delete bmSrc_r[i];
  percent->Percentage(100);
  return;

fail:
  if(dcSrc) bmSrc->DeleteDC(dcSrc);
  if(bmSrc) delete bmSrc;
  for (int i=0;i<randomdegree;i++)
    if(bmSrc_r[i]) delete bmSrc_r[i];  
  percent->Percentage(100);
  ShowMessage(IDS_MESSAGE_TOO_LARGE_BITMAP_ZOOM_REPEAT);
}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::DrawList(TTexpiaBitmap *bmSrc, TList *list, ProgressPercentage *percent,const int randomdegree){//gabriel:add randomdegree
  if(Back){
    for(int j=MAX_LAYER_COUNT-1;j>=0;j--){
      for(int i=0;i<list->Count;i++){
        LINE3D *line=(LINE3D *)list->Items[i];
        if(line->Layer==j) {
          percent->Percentage(100*current_line/total_line/randomdegree);
          current_line++;
          DrawYarn(bmSrc, line);
        }
      }
    }
  } else {
    for(int j=0;j<MAX_LAYER_COUNT;j++){
      for(int i=0;i<list->Count;i++){
        LINE3D *line=(LINE3D *)list->Items[i];
        if(line->Layer==j) {
          percent->Percentage(100*current_line/total_line/randomdegree);
          current_line++;
          DrawYarn(bmSrc, line);
        }
      }
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::DrawYarn(TTexpiaBitmap *bmSrc, LINE3D *line){
  int w=bmSrc->Width;
  int h=bmSrc->Height;
  double p1x,p1y,p2x,p2y;

  ///////////////////////ÁÂÇ¥°è ¹ÝÀü
  if(Back){
    p1x=line->p1x;
    p2x=line->p2x;
  } else {
    p1x=w-1-line->p1x;
    p2x=w-1-line->p2x;
  }
  p1y=h-1-line->p1y;
  p2y=h-1-line->p2y;
  ///////////////////////

  ///////////////////////Ŭ¸®ÇεǴ ½ÇÀ» °¢°¢ÀÇ °æ¿ì¿¡ µû¶ó ¸ðµÎ ±×·ÁÁÜ
  ///////////////////////Texpro TextileÀÇ ÀÚµ¿¹Ýº¹Ã³·³..
  int ixs,ixe;
  int iys,iye;

  ixs = (p1x>=0)?(p1x/w):((p1x+1)/w-1);
  ixe = (p2x>=0)?(p2x/w):((p2x+1)/w-1);
  iys = (p1y>=0)?(p1y/h):((p1y+1)/h-1);
  iye = (p2y>=0)?(p2y/h):((p2y+1)/h-1);
  for(int i=min(ixs,ixe)-1;i<=max(ixs,ixe)+1;i++){
    for(int j=min(iys,iye)-1;j<=max(iys,iye)+1;j++){
      DrawYarnPiece(bmSrc, p1x-i*w, p1y-j*h, p2x-i*w, p2y-j*h, line->D, line->yarn);
    }
  }

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::DrawYarnPiece(TTexpiaBitmap *bmSrc, double p1x, double p1y, double p2x, double p2y,
  double D, Yarn *yarn){

  int w=bmSrc->Width;
  int h=bmSrc->Height;
  double effectiveD=DenierToDiameter(yarn->denier, yarn->filament)*DOT_PER_CM*Zoom;


  if(effectiveD<1.0){//µÎµµÆ® º¸´Ù ÀÛÀ¸¸é ÀüÇô ¾Èº¸ÀÏ È®·üÀÌ ÀÖÀ½
    effectiveD=sqrt(sqrt(effectiveD));//½ÇÀÌ ³Ê¹« ¾ãÀ¸¸é µÎ²²¸¦ Å°¿ìÀÚ
  }
  //effectiveD*=(1+yarn->contraction);//½ºÆÇó·³ ¶¯°Ü¼­ °¨´Â ½ÇÀº ½ÇÁ¦ º¸´Ù ¾ã¾ÆÁø´Ù//±×·¯³ª ¼öÃàµÇ¸é¼­ ´Ù½Ã ¿ø·¡ µÎ²²·Î µ¹¾Æ¿Â´Ù

  RGBQUAD rgb=TColorToRGB(yarn->color);

  double r=sqrt( (p2x-p1x)*(p2x-p1x)+(p2y-p1y)*(p2y-p1y) );
  if(r==0) return;
  double n1x,n1y;//±æÀÌ°¡ 1ÀÎ º¤ÅÍ
  double n2x,n2y;//À§¿¡°ÍÀ» 90µµ ȸÀü
  FindR90VectorDouble(p1x,p1y,p2x,p2y,n2x,n2y);
  n1x=(p2x-p1x)/r;
  n1y=(p2y-p1y)/r;
  n2x/=r;
  n2y/=r;

  if(yarn->exist_image){//gabriel
    //evaluate effectiveD
    //is_simple can be used
    yarn->RealThick = (25.4 / yarn->DPI)* Count2Dot(yarn->DPI, yarn->YarnUnit, yarn->denier);
    effectiveD = yarn->RealThick*DOT_PER_CM*Zoom;
    //effectiveD=DenierToDiameter(yarn->denier, yarn->filament)*DOT_PER_CM*Zoom;

    imagestartpoint = rand()%(yarn->size_of_image/3/YARNIMAGEHEIGHT);

    //get image
    TTexpiaBitmap *yarnimage_Origianl;
    yarnimage_Origianl = new TTexpiaBitmap;
    yarnimage_Origianl->Create(yarn->size_of_image/YARNIMAGEHEIGHT/3,YARNIMAGEHEIGHT,24);
    RECT rect = {0,0,yarn->size_of_image/YARNIMAGEHEIGHT/3,YARNIMAGEHEIGHT};
    yarnimage_Origianl->LoadFromMemory((BYTE*)yarn->lpimage, yarn->size_of_image/YARNIMAGEHEIGHT, rect);

    Byte *ptr, *yptr;
    double sx,ex;
    double sy,ey;
    sx=min(p1x,p2x);
    ex=max(p1x,p2x);
    sy=min(p1y,p2y);
    ey=max(p1y,p2y);

    for(int j=sy-effectiveD*0.5-1;j<=ey+effectiveD*0.5+1;j++){//-1°ú +1Àº ¿µ¿ªÀ» 1¾¿ ³ÐÈù´Ù
      if(j<0||j>=h)continue;

      ptr = bmSrc->GetScanLine(j);
      for(int i=sx-effectiveD*0.5-1;i<=ex+effectiveD*0.5+1;i++){//-1°ú +1Àº ¿µ¿ªÀ» 1¾¿ ³ÐÈù´Ù
        if(i<0||i>=w)continue;
        double qx,qy;//p1¿¡¼­ (i,j)±îÁöÀÇ º¤ÅÍ
        double qn1,qn2;//qÀÇ n1¹æÇâ ¼ººÐ//qÀÇ n2¹æÇâ ¼ººÐ
        qx=i-p1x;
        qy=j-p1y;
        qn1=qx*n1x+qy*n1y;//qn1Àº ½ÇÀ» µû¶ó Á¾ ¹æÇâÀ¸·Î ÁøÇàÇÑ ±æÀÌ
        qn2=qx*n2x+qy*n2y;//qn2°¡ Å©¸é ½Ç·ÎºÎÅÍ °Å¸®°¡ ¸Ö¾îÁø´Ù

        if(qn1<0){
        } else if(qn1>r) {
        } else {
          if(fabs(qn2)<=effectiveD*0.5){//0.5´Â °æÇèÄ¡
            double d=fabs(qn2)/(effectiveD*0.5);//1ÀÌ¸é ½ÇÀÇ Ãø¸é°æ°è//0ÀÌ¸é ½ÇÀÇ Áß½É
            double t=yarn->transparency;//½ÇÀÇ Åõ¸íµµ//³óµµÁ¶Àý
            double a=yarn->reflection;//½ÇÀÇ ¹Ý¦ÀÓÀÇ Á¤µµ//¾Ëº£µµ(albedo)
            double e=effectiveD*0.5-fabs(qn2);//edge
            if(e>1)e=1;

            int qn1_c = (int)(qn1/effectiveD*100) % yarnimage_Origianl->Width;
            int qn2_c = (int)(qn2/effectiveD*100 + yarnimage_Origianl->Height/2) % yarnimage_Origianl->Height;

            while (qn2_c <0 )  //overranged points
               qn2_c += yarnimage_Origianl->Height;

            qn1_c += imagestartpoint;//shift image
            qn1_c %= yarn->size_of_image/YARNIMAGEHEIGHT/3;

            while (qn1_c <0 )
               qn1_c += yarnimage_Origianl->Height;

            COLORREF yarncolor = yarnimage_Origianl->GetPixelColor(qn1_c,qn2_c);

            rgb.rgbBlue = GetBValue(yarncolor);
            rgb.rgbGreen = GetGValue(yarncolor);
            rgb.rgbRed = GetRValue(yarncolor);

            //TEST - is Black color ?
            //if (rgb.rgbBlue == 0x00 || rgb.rgbGreen == 0x00 || rgb.rgbRed == 0x00)
            //  ; //Black ? -- scan »ç¿¡¼­ ³ªÅ¸³²??
            if (rgb.rgbBlue == 0xff && rgb.rgbGreen == 0xff && rgb.rgbRed == 0xff)
              ;  //White --> not drawn
            else if(rgb.rgbBlue > 0xea && rgb.rgbGreen > 0xea && rgb.rgbRed > 0xea)
              ; //Èò»ö°ú °¡±î¿ì¸é..1
            //else if(rgb.rgbBlue > 0xba && rgb.rgbGreen > 0xba && rgb.rgbRed > 0xba)
            //; //Èò»ö°ú °¡±î¿ì¸é..2
            else //not white
              calculate_imagecolor(ptr+3*i,rgb.rgbBlue,rgb.rgbGreen,rgb.rgbRed,d,t,a,e);
          }
        }
      }
      bmSrc->PutScanLine(j);
    }
    if(yarnimage_Origianl) delete yarnimage_Origianl;


  } else {
    //À̹ÌÁö°¡ ¾øÀ» ¶§//°Å¸®°ü°è¸¦ ÀÌ¿ëÇÏ¿© ·»´õ¸µ
    Byte *ptr;
    double sx,ex;
    double sy,ey;
    sx=min(p1x,p2x);
    ex=max(p1x,p2x);
    sy=min(p1y,p2y);
    ey=max(p1y,p2y);

    for(int j=sy-effectiveD*0.5-1;j<=ey+effectiveD*0.5+1;j++){//-1°ú +1Àº ¿µ¿ªÀ» 1¾¿ ³ÐÈù´Ù
      if(j<0||j>=h)continue;
      ptr = bmSrc->GetScanLine(j);
      for(int i=sx-effectiveD*0.5-1;i<=ex+effectiveD*0.5+1;i++){//-1°ú +1Àº ¿µ¿ªÀ» 1¾¿ ³ÐÈù´Ù
        if(i<0||i>=w)continue;
        double qx,qy;//p1¿¡¼­ (i,j)±îÁöÀÇ º¤ÅÍ
        double qn1,qn2;//qÀÇ n1¹æÇâ ¼ººÐ//qÀÇ n2¹æÇâ ¼ººÐ
        qx=i-p1x;
        qy=j-p1y;
        qn1=qx*n1x+qy*n1y;//qn1Àº ½ÇÀ» µû¶ó Á¾ ¹æÇâÀ¸·Î ÁøÇàÇÑ ±æÀÌ
        qn2=qx*n2x+qy*n2y;//qn2°¡ Å©¸é ½Ç·ÎºÎÅÍ °Å¸®°¡ ¸Ö¾îÁø´Ù

        if(qn1<0){
        } else if(qn1>r) {
        } else {
          if(fabs(qn2)<=effectiveD*0.5){
            double d=fabs(qn2)/(effectiveD*0.5);//1ÀÌ¸é ½ÇÀÇ Ãø¸é°æ°è//0ÀÌ¸é ½ÇÀÇ Áß½É
            double t=yarn->transparency;//½ÇÀÇ Åõ¸íµµ//³óµµÁ¶Àý
            double a=yarn->reflection;//½ÇÀÇ ¹Ý¦ÀÓÀÇ Á¤µµ//¾Ëº£µµ(albedo)
            double e=effectiveD*0.5-fabs(qn2);//edge
            if(e>1)e=1;
            calculate_color(ptr+3*i,rgb.rgbBlue,rgb.rgbGreen,rgb.rgbRed,d,t,a,e);
          }
        }
      }
      bmSrc->PutScanLine(j);
    }
  }

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::calculate_color(Byte *p, Byte &rgbb, Byte &rgbg, Byte &rgbr,
  double distance, double transparent, double albedo, double edge){

  if(ColorOnColor){//»ö °­Á¶ ¹æ½Ä
    transparent=1-(1-transparent)*sqrt(edge);
    double s = 0.5+sqrt(1-distance*distance)*(0.5-transparent);

    double c;
    Byte *q;
    Byte v[3]={rgbb,rgbg,rgbr};
    for(int i=0;i<3;i++){
      q=p+i;
      c = (*q)*(1-s)+v[i]*s;//¼¯¾î ³õÀº »ö
      if(c<0) {
        *q=0;
      } else if(c>255) {
        *q=255;
      } else {
        *q=(Byte)DoubleToIntBySubtraction(c);
      }
    }
  } else {
    transparent=1-(1-transparent)*sqrt(edge);
    double s = 0.5+sqrt(1-distance*distance)*(0.5-transparent);

    double bright_plus = 0;
    double bright_distance = distance*distance;
    //½Ç±½±â°¡ ³Ê¹« ¾ãÀ¸¸é °ÝÀÚÁ¡ÀÇ À§Ä¡°¡ ½ÇÀÇ °æ°è¼±ÀÏ È®·üÀÌ ³ô¾ÆÁø´Ù
    //°ÝÀÚ°¡ ½ÇµÎ²²¿¡ ºñÇØ »ó´ëÀûÀ¸·Î ºÎÁ¤È®ÇØÁü¿¡ µû¶ó..
    //±×·¡¼­ ¹à±â Á¶Àý¿¡¼­´Â °¡´ÉÇÑÇÑ ½ÇÀÇ Áß½ÉÀ¸·Î À̵¿½ÃÄÑ °è»êÇÏÀÚ
    double maxb = 96*albedo;//¹à±âÀÇ ÃÖ´ë º¯µ¿Æø
    double minb = -48*(1.0+albedo);

    bright_plus=maxb*(1.0-bright_distance)+minb*bright_distance;

    double c;
    Byte *q;
    Byte v[3]={rgbb,rgbg,rgbr};
    for(int i=0;i<3;i++){
      q=p+i;
      c = (*q)*(1-s)+v[i]*s;//¼¯¾î ³õÀº »ö
      c+=bright_plus;
      if(c<0) {
        *q=0;
      } else if(c>255) {
        *q=255;
      } else {
        *q=(Byte)DoubleToIntBySubtraction(c);
      }
    }
  }

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::calculate_imagecolor(Byte *p, Byte &rgbb, Byte &rgbg, Byte &rgbr,
   double distance, double transparent, double albedo, double edge)//gabriel
{  //¼Óµµ ¶§¹®¿¡ ÁÖ¼®Ã³¸®

//  if(ColorOnColor){//»ö °­Á¶ ¹æ½Ä
    transparent=1-(1-transparent)*sqrt(fabs(edge));
    double s = 0.5+sqrt(fabs(1-distance*distance))*(0.5-transparent);

    double c;
    Byte *q;
    Byte v[3]={rgbb,rgbg,rgbr};   //gabriel: REAL ColorOnColor method...
    for(int i=0;i<3;i++){
      q=p+i;
      //c = (*q)*(1-s)+v[i]*s;//¼¯¾î ³õÀº »ö
      c = v[i];
      if(c<0) {
        *q=0;
      } else if(c>255) {
        *q=255;
      } else {
        *q=(Byte)DoubleToIntBySubtraction(c);
      }
    }
/*  } else {
    transparent=1-(1-transparent)*sqrt(fabs(edge));
    double s = 0.5+sqrt(fabs(1-distance*distance))*(0.5-transparent);

    double bright_plus = 0;
    double bright_distance = distance*distance;
    //½Ç±½±â°¡ ³Ê¹« ¾ãÀ¸¸é °ÝÀÚÁ¡ÀÇ À§Ä¡°¡ ½ÇÀÇ °æ°è¼±ÀÏ È®·üÀÌ ³ô¾ÆÁø´Ù
    //°ÝÀÚ°¡ ½ÇµÎ²²¿¡ ºñÇØ »ó´ëÀûÀ¸·Î ºÎÁ¤È®ÇØÁü¿¡ µû¶ó..
    //±×·¡¼­ ¹à±â Á¶Àý¿¡¼­´Â °¡´ÉÇÑÇÑ ½ÇÀÇ Áß½ÉÀ¸·Î À̵¿½ÃÄÑ °è»êÇÏÀÚ
    double maxb = 96*albedo;//¹à±âÀÇ ÃÖ´ë º¯µ¿Æø
    double minb = -48*(1.0+albedo);

    bright_plus=maxb*(1.0-bright_distance)+minb*bright_distance;

    double c;
    Byte *q;
    Byte v[3]={rgbb,rgbg,rgbr};
    for(int i=0;i<3;i++){
      q=p+i;
      c = (*q)*(1-s)+v[i]*s;//¼¯¾î ³õÀº »ö
      c+=bright_plus;
      if(c<0) {
        *q=0;
      } else if(c>255) {
        *q=255;
      } else {
        *q=(Byte)DoubleToIntBySubtraction(c);
      }
    }
  }
*/
}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::SpandexEffect(TTexpiaBitmap *bmDst, int effect, int power, bool invert, ProgressPercentage *percent){
  if(effect==0) return;
  if(tricot->Width<2||tricot->Height<2) return;

  percent->Percentage(0);

  HDC dcSrc=NULL, dcDst=NULL;
  TTexpiaBitmap *bmSrc= new TTexpiaBitmap;
  bmSrc->Create(Width,Height, 24);
  bmSrc->CopyFromRect(bmDst,0,0,SRCCOPY);


  My3D *buf = (My3D *)VirtualAlloc(NULL,sizeof(My3D)*tricot->Width*tricot->Height,MEM_COMMIT,PAGE_READWRITE);
  if(buf) VirtualLock(buf,sizeof(My3D)*tricot->Width*tricot->Height);

  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 1
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Octopus *octo = tricot->GetOctopus(i,j);
      if(octo->used!=true)continue;
      bool hasSpandex=false;
      int upper_than_span=0;
      if(octo->hasHead){
        HEAD *Head=NULL;
        for(int k=0;k<octo->ListOfHead->Count;k++){
          Head = (HEAD *)octo->ListOfHead->Items[k];
          if(Head->yarn->ym==ymSPANDEX){

            int highspan=Head->Layer;
            HEAD *Head2=NULL;
            for(int k2=k+1;k2<octo->ListOfHead->Count;k2++){//ÇöÀç octopusÀÇ ÃÖ°íÃþ ½ºÆÇÀ» ãÀ½
              Head2 = (HEAD *)octo->ListOfHead->Items[k2];
              if(Head2->yarn->ym==ymSPANDEX&&Head2->Layer>highspan){
                highspan=Head2->Layer;
              }
            }
            bool layer[MAX_LAYER_COUNT]={false,false,false,false,false,false};
            HEAD *Head3=NULL;
            for(int k3=0;k3<octo->ListOfHead->Count;k3++){//½ºÆÇÀ§ÀÇ ÃþÀ» ±¸ÇÔ
              Head3 = (HEAD *)octo->ListOfHead->Items[k3];
              if(Head3->Layer>highspan&&Head3->yarn->ym!=ymSPANDEX){
                layer[Head3->Layer]=true;
              }
            }
            for(int l=0;l<MAX_LAYER_COUNT;l++){
              if(layer[l])upper_than_span++;
            }

            hasSpandex=true;
            break;
          }
        }
      }
      My3D *my3d = (buf+j*tricot->Width+i);
      my3d->pos[0].x = tricot->FindRealPosX(octo,i,j);
      my3d->pos[0].y = tricot->FindRealPosY(octo,i,j);
      my3d->special=hasSpandex;
      my3d->special_cnt=upper_than_span;
      my3d->used=true;
    }
  }

  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 2
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d = (buf+j*tricot->Width+i);
      if(my3d->used==false){
        double x = tricot->RDistX*i;
        double y = tricot->RDistY*j;
        for(int j2=0;j2<tricot->Height;j2++){
          My3D *my3d2 = (buf+((j+j2)%tricot->Height)*tricot->Width+i);
          if(my3d2->used){
            x=my3d2->pos[0].x;
            break;
          }
        }
        for(int i2=0;i2<tricot->Width;i2++){
          My3D *my3d2 = (buf+j*tricot->Width+(i+i2)%tricot->Width);
          if(my3d2->used){
            y=my3d2->pos[0].y;
            break;
          }
        }
        my3d->pos[0].x=x;
        my3d->pos[0].y=y;
      }
    }
  }
  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 3
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d11 = (buf+j*tricot->Width+i);
      My3D *my3d12 = (buf+j*tricot->Width+(i+1)%tricot->Width);
      My3D *my3d21 = (buf+((j+1)%tricot->Height)*tricot->Width+i);
      My3D *my3d22 = (buf+((j+1)%tricot->Height)*tricot->Width+(i+1)%tricot->Width);
      my3d11->pos[1]=my3d12->pos[0];
      my3d11->pos[2]=my3d22->pos[0];
      my3d11->pos[3]=my3d21->pos[0];
    }
  }
  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 3-1
  for(int j=0;j<tricot->Height;j++){
    My3D *my3d = (buf+j*tricot->Width+tricot->Width-1);
    my3d->pos[1].x+=Width;
    my3d->pos[2].x+=Width;
  }
  for(int i=0;i<tricot->Width;i++){
    My3D *my3d = (buf+(tricot->Height-1)*tricot->Width+i);
    my3d->pos[2].y+=Height;
    my3d->pos[3].y+=Height;
  }
  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 4
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d = (buf+j*tricot->Width+i);
      my3d->glx=tricot->RDistX;
      my3d->gly=tricot->RDistY;
      my3d->set_constant();
    }
  }

  ////////////////////////////·£´ýÇÔ¼ö ÀÌ¿ëÇÏ¿© ½ºÆÇ È¿°ú Àû¿ë
  if(effect==1){//solid
    for(int i=0;i<tricot->Width;i++){
      for(int j=0;j<tricot->Height;j++){
        My3D *my3d = (buf+j*tricot->Width+i);
        if(my3d->used){
          if(invert){
            if(my3d->special){
              my3d->z=-1.0-0.2*power*(1.0+my3d->special_cnt);
            } else {
              my3d->z=-1.0;
            }
          } else {
            if(my3d->special){
              my3d->z=1.0+0.2*power*(1.0+my3d->special_cnt);
            } else {
              my3d->z=1.0;
            }
          }
        } else {
          my3d->z=0;
        }
        my3d->z+=0.1-(rand()%10)/50.0;
      }
    }
  } else if(effect==2){//wave

    for(int i=0;i<tricot->Width;i++){
      for(int j=0;j<tricot->Height;j++){
        My3D *my3d = (buf+j*tricot->Width+i);
        my3d->z=1.0;
      }
    }

    ////////////////¼¼·Î¹æÇâ ¼ø¹æÇâ ÃʱâÈ­
    for(int i=0;i<tricot->Width;i++){
      double inc=0;
      bool hasSpecial=false;
      int s;
      for(s=0;s<tricot->Height;s++){
        My3D *my3d = (buf+s*tricot->Width+i);
        if(my3d->special){
          hasSpecial=true;
          break;
        }
      }
      if(!hasSpecial)continue;
      for(int j=s;j<tricot->Height+s;j++){
        My3D *my3d = (buf+(j%tricot->Height)*tricot->Width+i);
        if(my3d->special)inc=0;
        else inc+=1.0;
        my3d->z*=inc;//°è¼Ó °öÇØÁö¸é ½ºÆÇ¿¡¼­ ¸Ö¼ö·Ï Ä¿Áö´Â º¼·ÏÇÑ ¸ð¾çÀÌ µÈ´Ù
      }
    }
    //////////////////¼¼·Î¹æÇâ ¿ª¹æÇâ ÃʱâÈ­
    for(int i=0;i<tricot->Width;i++){
      double inc=0;
      bool hasSpecial=false;
      int s;
      for(s=0;s<tricot->Height;s++){
        My3D *my3d = (buf+s*tricot->Width+i);
        if(my3d->special){
          hasSpecial=true;
          break;
        }
      }
      if(!hasSpecial)continue;
      for(int j=s;j>s-tricot->Height;j--){
        My3D *my3d = (buf+((j+tricot->Height)%tricot->Height)*tricot->Width+i);
        if(my3d->special)inc=0;
        else inc+=1.0;
        my3d->z*=inc;//°è¼Ó °öÇØÁö¸é ½ºÆÇ¿¡¼­ ¸Ö¼ö·Ï Ä¿Áö´Â º¼·ÏÇÑ ¸ð¾çÀÌ µÈ´Ù
      }
    }

    ////////////////°¡·Î¹æÇâ ¼ø¹æÇâ ÃʱâÈ­
    for(int j=0;j<tricot->Height;j++){
      double inc=0;
      bool hasSpecial=false;
      int s;
      for(s=0;s<tricot->Width;s++){
        My3D *my3d = (buf+j*tricot->Width+s);
        if(my3d->special){
          hasSpecial=true;
          break;
        }
      }
      if(!hasSpecial)continue;
      for(int i=s;i<tricot->Width+s;i++){
        My3D *my3d = (buf+(j%tricot->Height)*tricot->Width+i);
        if(my3d->special)inc=0;
        else inc+=1.0;
        my3d->z*=inc;//°è¼Ó °öÇØÁö¸é ½ºÆÇ¿¡¼­ ¸Ö¼ö·Ï Ä¿Áö´Â º¼·ÏÇÑ ¸ð¾çÀÌ µÈ´Ù
      }
    }
    //////////////////°¡·Î¹æÇâ ¿ª¹æÇâ ÃʱâÈ­
    for(int j=0;j<tricot->Height;j++){
      double inc=0;
      bool hasSpecial=false;
      int s;
      for(s=0;s<tricot->Width;s++){
        My3D *my3d = (buf+j*tricot->Width+s);
        if(my3d->special){
          hasSpecial=true;
          break;
        }
      }
      if(!hasSpecial)continue;
      for(int i=s;i>s-tricot->Width;i--){
        My3D *my3d = (buf+(j%tricot->Height)*tricot->Width+(i+tricot->Width)%tricot->Width);
        if(my3d->special)inc=0;
        else inc+=1.0;
        my3d->z*=inc;//°è¼Ó °öÇØÁö¸é ½ºÆÇ¿¡¼­ ¸Ö¼ö·Ï Ä¿Áö´Â º¼·ÏÇÑ ¸ð¾çÀÌ µÈ´Ù
      }
    }

    //////////////°è¼Ó °öÇϸ鼭 4Á¦°öÀÌ µÇ¾úÀ¸¹Ç·Î ¿ø»ó º¹±Í
    for(int i=0;i<tricot->Width;i++){
      for(int j=0;j<tricot->Height;j++){
        My3D *my3d = (buf+j*tricot->Width+i);
        my3d->z=0.1*power*sqrt(sqrt(my3d->z));
      }
    }
    /*
    //////////////Àû´çÈ÷ »çÀÎ Æĸ¦ °öÇÏ¸é ¸ÚÁø ¿þÀÌºê ½ºÆÇÀÌ µÉ°Í..
    for(int i=0;i<tricot->Width;i++){
      for(int j=0;j<tricot->Height;j++){
        My3D *my3d = (buf+j*tricot->Width+i);
      }
    }
    */
  }

  ////////////Àû´çÈ÷ ¸Þµð¾È ¿¬»êÀ» ÅëÇØ z¸¦ ºÎµå·´°Ô Æîħ
  double MoveFactor=0.05;
  int TERM = 16;
  for(int n=0;n<tricot->Width*tricot->Height*TERM;n++){
    int i=rand()%tricot->Width;
    int j=rand()%tricot->Height;
    int im1=(i-1+tricot->Width)%tricot->Width;
    int ip1=(i+1)%tricot->Width;
    int jm1=(j-1+tricot->Height)%tricot->Height;
    int jp1=(j+1)%tricot->Height;

    double v = (
      (buf+jm1*tricot->Width+im1)->z+(buf+jm1*tricot->Width+i)->z +(buf+jm1*tricot->Width+ip1)->z+
      (buf+j*tricot->Width+im1)->z  +(buf+j*tricot->Width+i)->z   +(buf+j*tricot->Width+ip1)->z+
      (buf+jp1*tricot->Width+im1)->z+(buf+jp1*tricot->Width+i)->z +(buf+jp1*tricot->Width+ip1)->z )/9.0;
    (buf+j*tricot->Width+i)->z=v*MoveFactor+(buf+j*tricot->Width+i)->z*(1.0-MoveFactor);

  }
  
  ////////////////////////////////¸í¾ÏÀ» Á¤ÇÑ´Ù

  Vector stand, light;
  stand.init3(0,0,1);
  light.init3(-8,15,30); // ±¤¿øÀÇ ¹æÇâÀ¸·Î ÀÓÀÇ·Î Á¤ÇÑ´Ù
  light.normal();
  double increasefactor = 1.5;
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Vector v1,v2,v3;
      My3D *my3d11 = (buf+j*tricot->Width+i);
      My3D *my3d21 = (buf+j*tricot->Width+(i+1)%tricot->Width);
      My3D *my3d12 = (buf+((j+1)%tricot->Height)*tricot->Width+i);
      My3D *my3d22 = (buf+((j+1)%tricot->Height)*tricot->Width+(i+1)%tricot->Width);
      v1.init3(0,1,my3d12->z-my3d11->z);
      v2.init3(1,0,my3d21->z-my3d11->z);
      v3.init(3);
      v3.cross(v2,v1);
      if(v3.length()<=0){
        my3d11->brt=0.5;
      } else {
        v3.normal();
        double angle = light.dot(v3);  // -1 <= angle <= 1
        if(angle<=0){
          my3d11->brt=0;
        } else {
          my3d11->brt = angle*increasefactor;
        }
      }
    }
  }
  //////////////////////½ÇÁ¦ÀûÀÎ Àû¿ë


  Byte *p;
  if (!bmSrc->StartScanLine()) { goto fail; }

  for(int i=0;i<tricot->Width;i++){
    percent->Percentage(i*100/tricot->Width);
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d = (buf+j*tricot->Width+i);
      TPlaneVertex pv;
      pv.Create(my3d->pos[0], my3d->pos[1], my3d->pos[2], my3d->pos[3]);
       if (my3d->sqr[0]>0.0 && my3d->sqr[1]>0.0 && my3d->sqr[2]>0.0 && my3d->sqr[3]>0.0) {
        for (int y = pv.start.y; y < pv.end.y; y++) {
          int y2=y;
          while(y2<0){y2+=Height;}
          y2%=Height;

          p = bmSrc->GetScanLine(Height-1-y2);

           for (int x = pv.start.x; x < pv.end.x; x++) {
            int x2=x;
            while(x2<0){x2+=Width;}
            x2%=Width;

            int nx, ny;
            int bright;
            int x1, px1;

            if(Back) {
              x1 = 3 * x2;
            } else {
              x1 = 3 * (Width-1-x2);
            }

             if (pv.Check(x, y)) {
              my3d->find_point(x, y, nx, ny);
              My3D *my3d11 = (buf+j*tricot->Width+i);
              My3D *my3d21 = (buf+j*tricot->Width+(i+1)%tricot->Width);
              My3D *my3d12 = (buf+((j+1)%tricot->Height)*tricot->Width+i);
              My3D *my3d22 = (buf+((j+1)%tricot->Height)*tricot->Width+(i+1)%tricot->Width);
              double v =  (my3d11->brt*(1.0-nx/my3d11->glx)+my3d21->brt*(nx/my3d11->glx))*(1.0-ny/my3d11->gly) +
                          (my3d12->brt*(1.0-nx/my3d11->glx)+my3d22->brt*(nx/my3d11->glx))*(ny/my3d11->gly);
              int c1,c2,c3;
              c1 = p[x1]*v;
              c2 = p[x1+1]*v;
              c3 = p[x1+2]*v;
              if(c1<0)c1=0;
              if(c2<0)c2=0;
              if(c3<0)c3=0;
              if(c1>255)c1=255;
              if(c2>255)c2=255;
              if(c3>255)c3=255;
              p[x1]=c1;
              p[x1+1]=c2;
              p[x1+2]=c3;

            }
          }
          bmSrc->PutScanLine(Height-1-y2);
        }
      }
    }
  }
  bmSrc->StopScanLine();

  if(buf) VirtualUnlock(buf,sizeof(My3D)*tricot->Width*tricot->Height);
  if(buf) VirtualFree(buf,sizeof(My3D)*tricot->Width*tricot->Height,MEM_DECOMMIT);

  dcDst = bmDst->CreateDC();
  if(dcDst==NULL){
    goto fail;
  }

  dcSrc = bmSrc->CreateDC();
  for(int i=0;i<=bmDst->Width/Width;i++){
    for(int j=0;j<=bmDst->Height/Height;j++){
      BitBlt(dcDst, i*Width, j*Height, Width, Height, dcSrc, 0, 0, SRCCOPY);
    }
  }
  bmDst->DeleteDC(dcDst);
  bmSrc->DeleteDC(dcSrc);
  if(bmSrc) delete bmSrc;
  percent->Percentage(100);
  return;

fail:
  if(dcSrc) bmSrc->DeleteDC(dcSrc);
  if(bmSrc) delete bmSrc;
  percent->Percentage(100);
  ShowMessage(IDS_MESSAGE_TOO_LARGE_BITMAP_ZOOM_REPEAT);

}
//---------------------------------------------------------------------------
void __fastcall Yarnmap::TensionEffect(TTexpiaBitmap *bmDst, bool *ShowRunin, ProgressPercentage *percent){
  if(tricot->Width<2||tricot->Height<2) return;
  if(!(ShowRunin[0]|ShowRunin[1]|ShowRunin[2]|ShowRunin[3])) return;
  bool no_tension=true;
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Octopus *octo = tricot->GetOctopus(i,j);
      if(octo->tension){
        no_tension=false;
        break;
      }
    }
  }
  if(no_tension)return;

  percent->Percentage(0);

  HDC dcSrc=NULL, dcDst=NULL;
  TTexpiaBitmap *bmSrc= new TTexpiaBitmap;
  bmSrc->Create(Width,Height, 24);
  bmSrc->CopyFromRect(bmDst,0,0,SRCCOPY);

  My3D *buf = (My3D *)VirtualAlloc(NULL,sizeof(My3D)*tricot->Width*tricot->Height,MEM_COMMIT,PAGE_READWRITE);
  if(buf) VirtualLock(buf,sizeof(My3D)*tricot->Width*tricot->Height);

  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 1
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Octopus *octo = tricot->GetOctopus(i,j);
      if(octo->used!=true)continue;

      My3D *my3d = (buf+j*tricot->Width+i);
      my3d->pos[0].x = tricot->FindRealPosX(octo,i,j);
      my3d->pos[0].y = tricot->FindRealPosY(octo,i,j);
      my3d->special=false;
      my3d->special_cnt=octo->tension;
      if(my3d->special_cnt>10)my3d->special_cnt=10;
      if(my3d->special_cnt<-10)my3d->special_cnt=-10;
      my3d->used=true;
    }
  }

  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 2
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d = (buf+j*tricot->Width+i);
      if(my3d->used==false){
        double x = tricot->RDistX*i;
        double y = tricot->RDistY*j;
        for(int j2=0;j2<tricot->Height;j2++){
          My3D *my3d2 = (buf+((j+j2)%tricot->Height)*tricot->Width+i);
          if(my3d2->used){
            x=my3d2->pos[0].x;
            break;
          }
        }
        for(int i2=0;i2<tricot->Width;i2++){
          My3D *my3d2 = (buf+j*tricot->Width+(i+i2)%tricot->Width);
          if(my3d2->used){
            y=my3d2->pos[0].y;
            break;
          }
        }
        my3d->pos[0].x=x;
        my3d->pos[0].y=y;
      }
    }
  }
  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 3
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d11 = (buf+j*tricot->Width+i);
      My3D *my3d12 = (buf+j*tricot->Width+(i+1)%tricot->Width);
      My3D *my3d21 = (buf+((j+1)%tricot->Height)*tricot->Width+i);
      My3D *my3d22 = (buf+((j+1)%tricot->Height)*tricot->Width+(i+1)%tricot->Width);
      my3d11->pos[1]=my3d12->pos[0];
      my3d11->pos[2]=my3d22->pos[0];
      my3d11->pos[3]=my3d21->pos[0];
    }
  }
  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 3-1
  for(int j=0;j<tricot->Height;j++){
    My3D *my3d = (buf+j*tricot->Width+tricot->Width-1);
    my3d->pos[1].x+=Width;
    my3d->pos[2].x+=Width;
  }
  for(int i=0;i<tricot->Width;i++){
    My3D *my3d = (buf+(tricot->Height-1)*tricot->Width+i);
    my3d->pos[2].y+=Height;
    my3d->pos[3].y+=Height;
  }
  ////////////////////////////My3D µ¥ÀÌŸ ÃʱâÈ­ 4
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d = (buf+j*tricot->Width+i);
      my3d->glx=tricot->RDistX;
      my3d->gly=tricot->RDistY;
      my3d->set_constant();
    }
  }

  ////////////////////////////·£´ýÇÔ¼ö ÀÌ¿ëÇÏ¿© tension È¿°ú Àû¿ë
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d = (buf+j*tricot->Width+i);
      if(my3d->used){
        if(Back){
          my3d->z=-0.5*my3d->special_cnt;
        } else {
          //if(my3d->special_cnt>0) my3d->z=0;//else
          my3d->z=0.5*my3d->special_cnt;
        }
      } else {
        my3d->z=0;
      }
      my3d->z+=0.1-(rand()%10)/50.0;
    }
  }


  ////////////Àû´çÈ÷ ¸Þµð¾È ¿¬»êÀ» ÅëÇØ z¸¦ ºÎµå·´°Ô Æîħ
  /*
  double MoveFactor1=0.3;//¼¼·Î¹æÇâ
  int TERM1 = 32;
  for(int n=0;n<tricot->Width*tricot->Height*TERM1;n++){
    int i=rand()%tricot->Width;
    int j=rand()%tricot->Height;
    int im1=(i-1+tricot->Width)%tricot->Width;
    int ip1=(i+1)%tricot->Width;
    int jm1=(j-1+tricot->Height)%tricot->Height;
    int jp1=(j+1)%tricot->Height;

    double v = ((buf+jm1*tricot->Width+i)->z+(buf+j*tricot->Width+i)->z+(buf+jp1*tricot->Width+i)->z)/3.0;
    (buf+j*tricot->Width+i)->z=v*MoveFactor1+(buf+j*tricot->Width+i)->z*(1.0-MoveFactor1);

  }
  double MoveFactor2=0.1;//°¡·Î¹æÇâ
  int TERM2 = 8;
  for(int n=0;n<tricot->Width*tricot->Height*TERM2;n++){
    int i=rand()%tricot->Width;
    int j=rand()%tricot->Height;
    int im1=(i-1+tricot->Width)%tricot->Width;
    int ip1=(i+1)%tricot->Width;
    int jm1=(j-1+tricot->Height)%tricot->Height;
    int jp1=(j+1)%tricot->Height;

    double v = ((buf+j*tricot->Width+im1)->z+(buf+j*tricot->Width+i)->z+(buf+j*tricot->Width+ip1)->z)/3.0;
    (buf+j*tricot->Width+i)->z=v*MoveFactor2+(buf+j*tricot->Width+i)->z*(1.0-MoveFactor2);

  }*/

  ////////////////////////////////¸í¾ÏÀ» Á¤ÇÑ´Ù

  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d11 = (buf+j*tricot->Width+i);
      My3D *my3d21 = (buf+j*tricot->Width+(i+1)%tricot->Width);
      My3D *my3d12 = (buf+((j+1)%tricot->Height)*tricot->Width+i);
      My3D *my3d22 = (buf+((j+1)%tricot->Height)*tricot->Width+(i+1)%tricot->Width);
      my3d11->brt = (my3d11->z+15.0)/15.0;
    }
  }
  /*
  Vector stand, light;
  stand.init3(0,0,1);
  light.init3(-4,0,30); // ±¤¿øÀÇ ¹æÇâÀ¸·Î ÀÓÀÇ·Î Á¤ÇÑ´Ù
  light.normal();
  double increasefactor = 1.5;
  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Vector v1,v2,v3;
      My3D *my3d11 = (buf+j*tricot->Width+i);
      My3D *my3d21 = (buf+j*tricot->Width+(i+1)%tricot->Width);
      My3D *my3d12 = (buf+((j+1)%tricot->Height)*tricot->Width+i);
      My3D *my3d22 = (buf+((j+1)%tricot->Height)*tricot->Width+(i+1)%tricot->Width);
      v1.init3(0,1,my3d12->z-my3d11->z);
      v2.init3(1,0,my3d21->z-my3d11->z);
      v3.init(3);
      v3.cross(v2,v1);
      if(v3.length()<=0){
        my3d11->brt=0.5;
      } else {
        v3.normal();
        double angle = light.dot(v3);  // -1 <= angle <= 1
        if(angle<=0){
          my3d11->brt=0;
        } else {
          my3d11->brt = angle*increasefactor;
        }
      }
    }
  }*/

  //////////////////////½ÇÁ¦ÀûÀÎ Àû¿ë
  Byte *p;
  if (!bmSrc->StartScanLine()) { goto fail; }

  for(int i=0;i<tricot->Width;i++){
    percent->Percentage(i*100/tricot->Width);
    for(int j=0;j<tricot->Height;j++){
      My3D *my3d = (buf+j*tricot->Width+i);
      TPlaneVertex pv;
      pv.Create(my3d->pos[0], my3d->pos[1], my3d->pos[2], my3d->pos[3]);
       if (my3d->sqr[0]>0.0 && my3d->sqr[1]>0.0 && my3d->sqr[2]>0.0 && my3d->sqr[3]>0.0) {
        for (int y = pv.start.y; y < pv.end.y; y++) {
          int y2=y;
          while(y2<0){y2+=Height;}
          y2%=Height;

          p = bmSrc->GetScanLine(Height-1-y2);

           for (int x = pv.start.x; x < pv.end.x; x++) {
            int x2=x;
            while(x2<0){x2+=Width;}
            x2%=Width;

            int nx, ny;
            int bright;
            int x1, px1;

            if(Back) {
              x1 = 3 * x2;
            } else {
              x1 = 3 * (Width-1-x2);
            }

             if (pv.Check(x, y)) {
              my3d->find_point(x, y, nx, ny);
              My3D *my3d11 = (buf+j*tricot->Width+i);
              My3D *my3d21 = (buf+j*tricot->Width+(i+1)%tricot->Width);
              My3D *my3d12 = (buf+((j+1)%tricot->Height)*tricot->Width+i);
              My3D *my3d22 = (buf+((j+1)%tricot->Height)*tricot->Width+(i+1)%tricot->Width);
              double v =  (my3d11->brt*(1.0-nx/my3d11->glx)+my3d21->brt*(nx/my3d11->glx))*(1.0-ny/my3d11->gly) +
                          (my3d12->brt*(1.0-nx/my3d11->glx)+my3d22->brt*(nx/my3d11->glx))*(ny/my3d11->gly);
              int c1,c2,c3;
              c1 = p[x1]*v;
              c2 = p[x1+1]*v;
              c3 = p[x1+2]*v;
              if(c1<0)c1=0;
              if(c2<0)c2=0;
              if(c3<0)c3=0;
              if(c1>255)c1=255;
              if(c2>255)c2=255;
              if(c3>255)c3=255;
              p[x1]=c1;
              p[x1+1]=c2;
              p[x1+2]=c3;

            }
          }
          bmSrc->PutScanLine(Height-1-y2);
        }
      }
    }
  }
  bmSrc->StopScanLine();

  if(buf) VirtualUnlock(buf,sizeof(My3D)*tricot->Width*tricot->Height);
  if(buf) VirtualFree(buf,sizeof(My3D)*tricot->Width*tricot->Height,MEM_DECOMMIT);

  dcDst = bmDst->CreateDC();
  if(dcDst==NULL){
    goto fail;
  }

  dcSrc = bmSrc->CreateDC();
  for(int i=0;i<=bmDst->Width/Width;i++){
    for(int j=0;j<=bmDst->Height/Height;j++){
      BitBlt(dcDst, i*Width, j*Height, Width, Height, dcSrc, 0, 0, SRCCOPY);
    }
  }
  bmDst->DeleteDC(dcDst);
  bmSrc->DeleteDC(dcSrc);
  if(bmSrc) delete bmSrc;
  percent->Percentage(100);
  return;

fail:
  if(dcSrc) bmSrc->DeleteDC(dcSrc);
  if(bmSrc) delete bmSrc;
  percent->Percentage(100);
  ShowMessage(IDS_MESSAGE_TOO_LARGE_BITMAP_ZOOM_REPEAT);

}
//---------------------------------------------------------------------------