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

#include "tricot.h"
#include "define.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
__fastcall Tricot::Tricot(int W, int H, double rdx, double rdy){

  lpoctopus = new TList;
  for(int i=0;i<W*H;i++){
    Octopus *octo = new Octopus;//new A == new A[1] ??
    lpoctopus->Add(octo);
  }
  lpMovement = new TList;
  for(int i=0;i<W*H;i++){
    Movement *mv = new Movement;//new A == new A[1] ??
    lpMovement->Add(mv);
  }

  Width = W;
  Height = H;
  RDistX=rdx;
  RDistY=rdy;

}
//---------------------------------------------------------------------------
__fastcall Tricot::~Tricot(){
/*
  for(int i=0;i<Width*Height;i++){
    delete (Octopus *)(lpoctopus->Items[lpoctopus->Count-1]);
    lpoctopus->Remove(lpoctopus->Last());
  }
  delete lpoctopus;
  for(int i=0;i<Width*Height;i++){
    delete (Movement *)(lpMovement->Items[lpMovement->Count-1]);
    lpMovement->Remove(lpMovement->Last());
  }
  delete lpMovement;
*/
  Octopus *itemOctopus = NULL;
  for (int i = 0; i < lpoctopus->Count; i++) {
    itemOctopus = (Octopus *)lpoctopus->Items[i];
    delete itemOctopus;
  }
  lpoctopus->Clear();
  delete lpoctopus;

  Movement *itemMovement = NULL;
  for (int i = 0; i < lpMovement->Count; i++) {
    itemMovement = (Movement *)lpMovement->Items[i];
    delete itemMovement;
  }
  lpMovement->Clear();
  delete lpMovement;
}
//---------------------------------------------------------------------------
Octopus *__fastcall Tricot::GetOctopus(int x, int y){
  Octopus *octo = (Octopus *)lpoctopus->Items[GetBoxY(y)*Width + GetBoxX(x)];
  return octo;
}
//---------------------------------------------------------------------------
int __fastcall Tricot::GetBoxX(int x){
  int nx = x;
  while(nx<0){nx+=Width;}
  nx%=Width;
  return nx;
}
//---------------------------------------------------------------------------
int __fastcall Tricot::GetBoxY(int y){
  int ny = y;
  while(ny<0){ny+=Height;}
  ny%=Height;
  return ny;
}
//---------------------------------------------------------------------------
double __fastcall Tricot::FindMidPointX(Octopus *octo, int oi, int oj, bool *NoTension) { //Æò±Õ X¸¦ ±¸ÇÑ´Ù
  LEG *Leg;
  HEAD *Head;
  Octopus *sideocto;

  double Move=0.8;  //º¯ÇüÀÇ ¼Óµµ(Çѹø¿¡ 100% º¯ÇüÀ» ÇÏÁö¾Ê°í Á¶±Ý¾¿ ²ø·Á°¡µµ·ÏÇÔ)
  double LFactor=1; //Leg ²ø¸²
  double HFactor=20;//Head ²ø¸²
  double KFactor=70;//IJIJÁö È¿°ú

  // °¢°¢ÀÇ ½ÇÀÌ F = -kx^3 ÀÇ °ø½ÄÀ¸·Î ¿ë¼öö ó·³ ´ç±ä´Ù°í °¡Á¤ÇÑ´Ù
  // Fi = -ki(x-xi)^3
  // F = F1 + F2 + ... + Fn
  // F = ax^3 + bx^2 + cx + d
  // F = 0 ÀÇ ÇØ´Â ÇϳªÀÌ´Ù(¹°¸®ÀûÀ¸·Î ÇÑÁ¡¿¡ ¼ö·Å)
  // Çظ¦ ±¸ÇÏÀÚ
  // ¾Æ·¡´Â a b c d¸¦ ±¸ÇÏ´Â °úÁ¤
  double a=0,b=0,c=0,d=0;
  double curX=FindRealPosX(octo,oi,oj);

  for(int m=0;m<octo->ListOfLeg->Count;m++){//´Ù¸®
    Leg = (LEG *)octo->ListOfLeg->Items[m];
    if(Leg->ls==NO_LEG)continue;
    if(NoTension[Leg->Layer])continue;
    Octopus *sideocto = (Octopus *)GetOctopus(Leg->link.x,Leg->link.y);
    double xi = FindRealPosX(sideocto,Leg->link.x,Leg->link.y);
    double ki = LFactor;
    xi=(xi-curX)/RDistX;//curX¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistX ºñÀ²·Î ȯ»êÇÑ´Ù
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô//3Á¦°ö ¸¸Å­ ³ª´«´Ù
    if(Leg->ls==BOTTOM_LEG_FORCE||Leg->ls==TOP_LEG_FORCE||Leg->yarn->ym==ymSPANDEX){
      ki+=KFactor;
    }
    if(Leg->ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-Leg->ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  for(int m=0;m<octo->ListOfMLeg->Count;m++){//´Ù¸®
    MLEG *Leg = (MLEG *)octo->ListOfMLeg->Items[m];
    Octopus *sideocto = (Octopus *)GetOctopus(Leg->link.x,Leg->link.y);
    double xi = FindRealPosX(sideocto,Leg->link.x,Leg->link.y);
    double ki = LFactor;
    xi=(xi-curX)/RDistX;//curX¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistX ºñÀ²·Î ȯ»êÇÑ´Ù
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô//3Á¦°ö ¸¸Å­ ³ª´«´Ù
    if(Leg->ls==BOTTOM_LEG_FORCE||Leg->ls==TOP_LEG_FORCE||Leg->yarn->ym==ymSPANDEX){
      ki+=KFactor;
    }
    if(Leg->ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-Leg->ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  sideocto = (Octopus *)GetOctopus(oi, oj+1);
  if(octo->hasHead||sideocto->used==true){
    bool hasK=false;
    for(int m=0;m<octo->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)octo->ListOfHead->Items[m];
      if(Head->yarn->ym==ymSPANDEX){
        hasK=true;
        break;
      }
    }
    int min_ratio=100;
    for(int m=0;m<octo->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)octo->ListOfHead->Items[m];
      if(Head->ratio<min_ratio){
        min_ratio=Head->ratio;
      }
    }
    double xi = FindRealPosX(sideocto,oi,oj+1);
    double ki = HFactor;
    xi=(xi-curX)/RDistX;//curX¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistX ºñÀ²·Î ȯ»êÇÑ´Ù
    if(hasK){
      ki+=KFactor;
    }
    if(min_ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-min_ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  sideocto = GetOctopus(oi,oj-1);
  if(sideocto->hasHead&&sideocto->used==true){
    bool hasK=false;
    for(int m=0;m<sideocto->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)sideocto->ListOfHead->Items[m];
      if(Head->yarn->ym==ymSPANDEX){
        hasK=true;
        break;
      }
    }
    int min_ratio=100;
    for(int m=0;m<sideocto->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)sideocto->ListOfHead->Items[m];
      if(Head->ratio<min_ratio){
        min_ratio=Head->ratio;
      }
    }
    double xi = FindRealPosX(sideocto,oi,oj-1);
    double ki = HFactor;
    xi=(xi-curX)/RDistX;//curX¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistX ºñÀ²·Î ȯ»êÇÑ´Ù
    if(hasK){
      ki+=KFactor;
    }
    if(min_ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-min_ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  //»ïÂ÷ ¹æÁ¤½ÄÀÇ ±ÙÀÇ °ø½Ä¿¡¼­ ±ÙÀÌ ¸®¾ó·çÆ® ÇϳªÀ϶§..
  double root = 0;
  if(a==0) return curX;
  b/=a;
  c/=a;
  d/=a;
  a=1;

  double Q = (b*b-3.0*c)/9.0;
  double R = (2.0*b*b*b-9.0*b*c+27.0*d)/54.0;

  double A = 0;
  double B = 0;

  if(R*R<Q*Q*Q) {
    //±ÙÀÌ ¼¼°³// »ç½Ç ÀÌ°÷À¸·Î µé¾î¿Ã¸®°¡ ¾øÁö¸¸..
    //±×³É ù¹ø° ±ÙÀ» ¸®ÅÏÇÏÀÚ
    double theta = acos(R/sqrt(Q*Q*Q));
    root = -2.0*sqrt(Q)*cos(theta/3.0)-b/3.0;
  } else {
    double K = sqrt(R*R-Q*Q*Q);

    if(R>0) A = -pow(R+K,1.0/3.0);
    else A = pow(-R+K,1.0/3.0);
    if(A==0) B=0;
    else B=Q/A;

    root = (A+B)-b/3.0;

  }
  double midX = curX+root*RDistX;
  return curX*(1.0-Move)+midX*Move;

}
//---------------------------------------------------------------------------
double __fastcall Tricot::FindMidPointY(Octopus *octo, int oi, int oj, bool *NoTension) { //Æò±Õ Y¸¦ ±¸ÇÑ´Ù
  LEG *Leg;
  HEAD *Head;
  Octopus *sideocto;

  double Move=0.8;
  double LFactor=0.5; //Leg ²ø¸²
  double HFactor=20; //Head ²ø¸²
  double KFactor=1000;//IJIJÁö È¿°ú

  // °¢°¢ÀÇ ½ÇÀÌ F = -kx^3 ÀÇ °ø½ÄÀ¸·Î ¿ë¼öö ó·³ ´ç±ä´Ù°í °¡Á¤ÇÑ´Ù
  // Fi = -ki(x-xi)^3
  // F = F1 + F2 + ... + Fn
  // F = ax^3 + bx^2 + cx + d
  // F = 0 ÀÇ ÇØ´Â ÇϳªÀÌ´Ù(¹°¸®ÀûÀ¸·Î ÇÑÁ¡¿¡ ¼ö·Å)
  // Çظ¦ ±¸ÇÏÀÚ
  // ¾Æ·¡´Â a b c d¸¦ ±¸ÇÏ´Â °úÁ¤
  double a=0,b=0,c=0,d=0;
  double curY=FindRealPosY(octo,oi,oj);

  for(int m=0;m<octo->ListOfLeg->Count;m++){//´Ù¸®
    Leg = (LEG *)octo->ListOfLeg->Items[m];
    if(NoTension[Leg->Layer])continue;
    if(Leg->ls==NO_LEG)continue;
    Octopus *sideocto = (Octopus *)GetOctopus(Leg->link.x,Leg->link.y);
    double xi = FindRealPosY(sideocto,Leg->link.x,Leg->link.y);
    double ki = LFactor;
    xi=(xi-curY)/RDistY;//curY¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistY ºñÀ²·Î ȯ»êÇÑ´Ù
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô//3Á¦°ö ¸¸Å­ ³ª´«´Ù
    if(Leg->ls==BOTTOM_LEG_FORCE||Leg->ls==TOP_LEG_FORCE||Leg->yarn->ym==ymSPANDEX){
      ki+=KFactor;
    }
    if(Leg->ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-Leg->ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  for(int m=0;m<octo->ListOfMLeg->Count;m++){//´Ù¸®
    MLEG *Leg = (MLEG *)octo->ListOfMLeg->Items[m];
    Octopus *sideocto = (Octopus *)GetOctopus(Leg->link.x,Leg->link.y);
    double xi = FindRealPosY(sideocto,Leg->link.x,Leg->link.y);
    double ki = LFactor;
    xi=(xi-curY)/RDistY;//curY¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistY ºñÀ²·Î ȯ»êÇÑ´Ù
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô
    ki/=max(abs(oi-Leg->link.x),1);//¾ÖÃʺÎÅÍ ±ä´Ù¸®´Â ´À½¼ÇÏ°Ô//3Á¦°ö ¸¸Å­ ³ª´«´Ù
    if(Leg->ls==BOTTOM_LEG_FORCE||Leg->ls==TOP_LEG_FORCE||Leg->yarn->ym==ymSPANDEX){
      ki+=KFactor;
    }
    if(Leg->ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-Leg->ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  sideocto = (Octopus *)GetOctopus(oi, oj+1);
  if(octo->hasHead||sideocto->used==true){
    bool hasK=false;
    for(int m=0;m<octo->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)octo->ListOfHead->Items[m];
      if(Head->yarn->ym==ymSPANDEX){
        hasK=true;
        break;
      }
    }
    int min_ratio=100;
    for(int m=0;m<octo->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)octo->ListOfHead->Items[m];
      if(Head->ratio<min_ratio){
        min_ratio=Head->ratio;
      }
    }
    double xi = FindRealPosY(sideocto,oi,oj+1);
    double ki = HFactor;
    xi=(xi-curY)/RDistY;//curY¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistY ºñÀ²·Î ȯ»êÇÑ´Ù
    if(hasK){
      ki+=KFactor;
    }
    if(min_ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-min_ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  sideocto = GetOctopus(oi,oj-1);
  if(sideocto->hasHead&&sideocto->used==true){
    bool hasK=false;
    for(int m=0;m<sideocto->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)sideocto->ListOfHead->Items[m];
      if(Head->yarn->ym==ymSPANDEX){
        hasK=true;
        break;
      }
    }
    int min_ratio=100;
    for(int m=0;m<sideocto->ListOfHead->Count;m++){
      HEAD *Head=(HEAD *)sideocto->ListOfHead->Items[m];
      if(Head->ratio<min_ratio){
        min_ratio=Head->ratio;
      }
    }
    double xi = FindRealPosY(sideocto,oi,oj-1);
    double ki = HFactor;
    xi=(xi-curY)/RDistY;//curY¸¦ 0À¸·Î º»´Ù//ºñÀ²·Î RDistY ºñÀ²·Î ȯ»êÇÑ´Ù
    if(hasK){
      ki+=KFactor;
    }
    if(min_ratio<100){ // »çÃâ·®¿¡ ÀÇÇÑ ¼öÃàÀû¿ë
      ki+=100-min_ratio;
    }

    a+=ki;
    b-=3.0*ki*xi;
    c+=3.0*ki*xi*xi;
    d-=ki*xi*xi*xi;
  }

  //»ïÂ÷ ¹æÁ¤½ÄÀÇ ±ÙÀÇ °ø½Ä¿¡¼­ ±ÙÀÌ ¸®¾ó·çÆ® ÇϳªÀ϶§..
  double root = 0;
  if(a==0) return curY;
  b/=a;
  c/=a;
  d/=a;
  a=1;

  double Q = (b*b-3.0*c)/9.0;
  double R = (2.0*b*b*b-9.0*b*c+27.0*d)/54.0;

  double A = 0;
  double B = 0;

  if(R*R<Q*Q*Q) {
    //±ÙÀÌ ¼¼°³// »ç½Ç ÀÌ°÷À¸·Î µé¾î¿Ã¸®°¡ ¾øÁö¸¸..
    //±×³É ù¹ø° ±ÙÀ» ¸®ÅÏÇÏÀÚ
    double theta = acos(R/sqrt(Q*Q*Q));
    root = -2.0*sqrt(Q)*cos(theta/3.0)-b/3.0;
  } else {
    double K = sqrt(R*R-Q*Q*Q);

    if(R>0) A = -pow(R+K,1.0/3.0);
    else A = pow(-R+K,1.0/3.0);
    if(A==0) B=0;
    else B=Q/A;

    root = (A+B)-b/3.0;

  }
  double midY = curY+root*RDistY;
  return curY*(1.0-Move)+midY*Move;

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

double __fastcall Tricot::FindRealPosX(Octopus *octo, int i, int j){ //¸®ÇÍÀ» ¹Ýº¹½Ãų¶§ÀÇ À§Ä¡·Î½á (0,0)Àº À¯ÀÏÇÏ´Ù
  double px = octo->posX;
  int step = (i>=0) ? (i/Width) : ((i + 1)/Width-1);//i°¡ À§Ä¡ÇÏ´Â ¸®ÇÍÀÇ À妽º//½ºÅÜÆã¼Ç°ú °°´Ù
  if(step!=0) px+=(double)step*RDistX*(double)Width;
  return px;
}
//---------------------------------------------------------------------------
double __fastcall Tricot::FindRealPosY(Octopus *octo, int i, int j){ //¸®ÇÍÀ» ¹Ýº¹½Ãų¶§ÀÇ À§Ä¡·Î½á (0,0)Àº À¯ÀÏÇÏ´Ù
  double py = octo->posY;
  int step = (j>=0) ? (j/Height) : ((j + 1)/Height-1);//j°¡ À§Ä¡ÇÏ´Â ¸®ÇÍÀÇ À妽º//½ºÅÜÆã¼Ç°ú °°´Ù
  if(step!=0) py+=(double)step*RDistY*(double)Height;
  return py;
}
//---------------------------------------------------------------------------

void __fastcall Tricot::InitTricot(TexLayer *texlayer, bool *ShowRunin, ProgressPercentage *percent){
//½ÇÀÌ ¿À¸¥ÂÊ¿¡¼­ ¿À´ÂÁö ¿ÞÂÊ¿¡¼­ ¿À´ÂÁö µîÀ» Á¤ÇÔ
  BeforeInitTricot();

  if(percent)percent->Percentage(0);

  Tex *tex;
  KO *ko,*upperko,*lowerko;
  int i,j,k, LayerCnt = texlayer->TexList->Count;
  Octopus *octo;
  POINT p1,p2;

  int total_progress = LayerCnt*Width;
  int progress = 0;

  for(i=0; i< LayerCnt; i++){
    tex = (Tex *)texlayer->TexList->Items[i];
    tex->SetThreading();

    if(tex->old_iotc==0) continue;

    for(k=0;k<Width;k++){
      progress++;
      if(percent)percent->Percentage(100*progress/total_progress);

      Yarn *yarn=NULL;
      yarn=tex->GetYarn(texlayer->YarnList, k, false);
      bool isTransParent=tex->GetTransParent(k);
      if(yarn==NULL) continue;

      bool hold=false;
      for(int l=0; l<Height ;l++){
        KO *ko = (KO *)tex->Curve->Items[l%Height];
        if(ko->in!=ko->via){
          hold=true;
          break;
        }
      }
      bool straight=true;
      for(int l=0; l<Height ;l++){
        KO *ko = (KO *)tex->Curve->Items[l%Height];
        KO *ko2 = (KO *)tex->Curve->Items[(l+1)%Height];
        if(ko->in!=ko2->in||ko->in!=ko2->via){
          straight=false;
          break;
        }
      }

      for(j=0; j<Height ;j++){

        upperko = (KO *)tex->Curve->Items[  (j + 1          ) % Height  ];
        ko      = (KO *)tex->Curve->Items[  (j              )           ];
        lowerko = (KO *)tex->Curve->Items[  (j - 1 + Height ) % Height  ];

        int upperin   = upperko->in   + k + tex->leftShift;
        int via       = ko->via       + k + tex->leftShift;
        int in        = ko->in        + k + tex->leftShift;
        int lowerout  = lowerko->via  + k + tex->leftShift;

        if(in>via) in--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
        if(via>in) via--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù
        if(upperko->in > upperko->via) upperin--;   // ¹Ù´ÃÁÂÇ¥¿Í ½ÇÁÂÇ¥ÀÇ º¯È¯°úÁ¤
        if(lowerko->via > lowerko->in) lowerout--;  // ¹Ù´ÃÁÂÇ¥¿Í ½ÇÁÂÇ¥ÀÇ º¯È¯°úÁ¤

        if(ko->via==ko->in){ // ø»ç(Áö³ª°¡´Â ½Ç)
          if(hold==false) {//°É¸®´Â°Ô Çϳªµµ ¾øÀ¸¸é...//fuzz1 ¶§¹®¿¡ ¼öÁ¤

            for(int m=0;m<Height;m++){
              KO *ko0 = (KO *)tex->Curve->Items[(m-1+Height)%Height];
              KO *ko1 = (KO *)tex->Curve->Items[m%Height];
              KO *ko2 = (KO *)tex->Curve->Items[(m+1)%Height];
              KO *ko3 = (KO *)tex->Curve->Items[(m+2)%Height];

              int via0       = ko0->via       + k + tex->leftShift;
              int in0        = ko0->in        + k + tex->leftShift;
              int via1       = ko1->via       + k + tex->leftShift;
              int in1        = ko1->in        + k + tex->leftShift;
              int via2       = ko2->via       + k + tex->leftShift;
              int in2        = ko2->in        + k + tex->leftShift;
              int via3       = ko3->via       + k + tex->leftShift;
              int in3        = ko3->in        + k + tex->leftShift;


              if(in0>via0) in0--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
              if(via0>in0) via0--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù
              if(in1>via1) in1--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
              if(via1>in1) via1--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù
              if(in2>via2) in2--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
              if(via2>in2) via2--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù
              if(in3>via3) in3--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
              if(via3>in3) via3--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù

              p1.x=GetBoxX(in1);//p1Àº in1ÀÇ À§Ä¡¸¦ %width, %height ÇÑ °Í
              p1.y=GetBoxY(m);
              p2.x=p1.x-in1+in2;//p2´Â width, height ³Ñ¾î°¡´Â °ÍÀ» °í·ÁÇÏÁö ¾Ê°í À§Ä¡¸¦ Á¤ÇÑ´Ù
              p2.y=p1.y+1;
              octo=GetOctopus(p1.x,p1.y);
              octo->posX=p1.x*RDistX; //ÀÚ±â À§Ä¡(´ç±â±â Àü) ±¸ÇÔ
              octo->posY=p1.y*RDistY;
              CourseState2 *cs2=(CourseState2 *)tex->Courses->Items[p1.y];
              if(ShowRunin[i]) octo->tension+=cs2->ratio-100;

              octo->used = true;
              SLEG *Leg = new SLEG;
              Leg->Layer = i;
              Leg->yarn = yarn;
              Leg->isTransParent = isTransParent;
              Leg->link = p2;
              Leg->ls = NORMAL_LEG;
              if(straight) {
                Leg->slt1=C_SLEG;
                Leg->slt2=C_SLEG;
              } else {
                static bool right=true;
                if(ko1->in>ko0->via){
                  Leg->slt1 = R_SLEG; //µé¾î¿À´Â ½ÇÀÌ ¾î´ÀÂÊ¿¡¼­ ¿À³ª
                } else if(ko1->in<ko0->via){
                  Leg->slt1 = L_SLEG;
                } else {
                  if(right){
                    Leg->slt1 = R_SLEG;
                  } else {
                    Leg->slt1 = L_SLEG;
                  }
                }
                if(ko2->in>ko1->via){
                  Leg->slt2 = R_SLEG; //³ª°¡´Â ½ÇÀÌ ¾î´ÀÂÊÀ¸·Î ³ª°¡³ª
                  right=true;
                } else if(ko2->in<ko1->via){
                  Leg->slt2 = L_SLEG;
                  right=false;
                } else {
                  if(right){
                    Leg->slt2 = R_SLEG;
                  } else {
                    Leg->slt2 = L_SLEG;
                  }
                }

              }
              Leg->ratio=cs2->ratio;
              octo->ListOfSLeg->Add(Leg);
            }

            break;//for(j=0; j<Height ;j++){ ÀÌ°ÍÀ» ³ª°¡´Â break;
          } else {
            continue; //ø»ç´Â ÀÏ´Ü Áö³ª°¡°í º»´Ù
          }
        } else {//ÇöÀçÄÚ°¡ Á¤»óÄÚ
          if(upperko->via==upperko->in){ // ÇöÀç ÄÚ´Â Á¤»óÄÚÀÌ°í À§ÂÊ¿¡ ø»ç°¡ ³ªÅ¸³¯¶§
            KO *upperko2=ko;
            int l;

            for(l=1;l<=Height;l++){
              upperko2 = (KO *)tex->Curve->Items[(j+l)%Height];
              if(upperko2->in!=upperko2->via){ //ø»ç°¡ ¾Æ´Ñ Á¤»óÄÚ°¡ ³ªÅ¸³¯¶§±îÁö
                break;
              }
            }

            int upperin2 = upperko2->in + k + tex->leftShift;
            if(upperko2->in > upperko2->via) upperin2--;   // ¹Ù´ÃÁÂÇ¥¿Í ½ÇÁÂÇ¥ÀÇ º¯È¯°úÁ¤

            p1.x=GetBoxX(via);//p1Àº box ¾È¿¡ ¾î¶² octopus¿¡ ´ëÀÀµÊ
            p1.y=GetBoxY(j);
            p2.x=p1.x-via+upperin2;//p2´Â ´ëÀÀµÈ p1¿¡ ´ëÇÑ »ó´ëÀûÀÎ À§Ä¡
            p2.y=p1.y+l;
            octo=GetOctopus(p1.x,p1.y);
            octo->posX=p1.x*RDistX;
            octo->posY=p1.y*RDistY;
            CourseState2 *cs2=(CourseState2 *)tex->Courses->Items[p1.y];
            if(ShowRunin[i]) octo->tension+=cs2->ratio-100;

            octo->used = true;

            octo->hasHead = true;
            HEAD *Head = new HEAD;
            Head->Layer = i;
            Head->yarn = yarn;
            if(ko->via>ko->in){
              if(ko->via>upperko->in){
                Head->ht = R_HEAD; //¿À¸¥ÂÊ¿¡¼­ ´ç±æ ¸Ó¸®
              } else {
                Head->ht = O_HEAD; //¾çÂÊ¿¡¼­ ¶È°°ÀÌ ´ç±è
              }
            } else if(ko->via<ko->in){
              if(ko->via<upperko->in){
                Head->ht = L_HEAD;
              } else {
                Head->ht = O_HEAD;
              }
            }
            Head->isTransParent = isTransParent;
            Head->ratio=cs2->ratio;
            octo->ListOfHead->Add(Head);

            if(i==0){//IJIJÁö//mm per rack°¡ 0ÀÎ ½Ç
              //octo->used = true;
              LEG *Leg = new LEG;
              Leg->Layer = i;
              Leg->yarn = yarn;
              Leg->isTransParent = isTransParent;
              Leg->isTreated = false;
              Leg->link = p2;
              bool *force=(bool *)tex->Force->Items[(j+1)%Height];//½ÃÀÛÁ¡ÀÌ forcedÀ̸é ø»çÀÇ Æ¯¼º»ó forced·Î °¡Á¤ÇÔ
              if(*force){
                Leg->ls = BOTTOM_LEG_FORCE;
              } else {
                Leg->ls = BOTTOM_LEG;
              }
              if(ko->via>upperko->in){
                Leg->lt = RL_LEG;
              } else if(ko->via<upperko->in){
                Leg->lt = LR_LEG;
              } else {
                if(ko->via<ko->in){
                  Leg->lt = RR_LEG;
                } else {
                  Leg->lt = LL_LEG;
                }
              }
              Leg->ratio=cs2->ratio;
              octo->ListOfLeg->Add(Leg);
            } else if(i==LayerCnt-1){//IJIJÁö//mm per rack°¡ 0ÀÎ ½Ç
              //octo->used = true;
              LEG *Leg = new LEG;
              Leg->Layer = i;
              Leg->yarn = yarn;
              Leg->isTransParent = isTransParent;
              Leg->isTreated = false;
              Leg->link = p2;
              bool *force=(bool *)tex->Force->Items[(j+1)%Height];//½ÃÀÛÁ¡ÀÌ forcedÀ̸é ø»çÀÇ Æ¯¼º»ó forced·Î °¡Á¤ÇÔ
              if(*force){
                Leg->ls = TOP_LEG_FORCE;
              } else {
                Leg->ls = TOP_LEG;
              }
              if(ko->via>upperko->in){
                Leg->lt = RL_LEG;
              } else if(ko->via<upperko->in){
                Leg->lt = LR_LEG;
              } else {
                if(ko->via<ko->in){
                  Leg->lt = RR_LEG;
                } else {
                  Leg->lt = LL_LEG;
                }
              }
              Leg->ratio=cs2->ratio;
              octo->ListOfLeg->Add(Leg);
            } else {

              //////////////////////À̺κÐÀº »õ·Î¿î ÀÀ¿ëÀÌ ¹ß°ßµÉ ¶§¸¶´Ù ¼öÁ¤ÇØÁà¾ßÇÔ(º¯Ä¢ÀûÀÎ Á¶Á÷)
              bool AllTop=true;
              for(int m=j+1;m<j+l;m++){
                bool *ol=(bool *)tex->Raise->Items[m%Height]; //ÄÚ½º ¼³Á¤ÀÇ À§·Î¿Ã¸² È¿°ú
                if(*ol==false){
                  AllTop=false;
                  break;
                }
              }
              if(AllTop){//±â¸ðÁöÀÇ Àâ¾ÆÁÖ´Â ½Ç//²ø·Á°¡´Â ½Ç
                //octo->used = true;
                LEG *Leg = new LEG;
                Leg->Layer = i;
                Leg->yarn = yarn;
                Leg->isTransParent = isTransParent;
                Leg->isTreated = false;
                Leg->link = p2;
                bool *force=(bool *)tex->Force->Items[(j+1)%Height];//ÄÚ½º ¼³Á¤ÀÇ ´ç±è È¿°ú //½ÃÀÛÁ¡ÀÌ forcedÀ̸é ø»çÀÇ Æ¯¼º»ó forced·Î °¡Á¤ÇÔ
                if(*force){
                  Leg->ls = TOP_LEG_FORCE;
                } else {
                  Leg->ls = TOP_LEG;
                }
                if(ko->via>upperko->in){
                  Leg->lt = RL_LEG;
                } else if(ko->via<upperko->in){
                  Leg->lt = LR_LEG;
                } else {
                  if(ko->via<ko->in){
                    Leg->lt = RR_LEG;
                  } else {
                    Leg->lt = LL_LEG;
                  }
                }
                Leg->ratio=cs2->ratio;
                octo->ListOfLeg->Add(Leg);
              } else {

                for(int m=0;m<Height;m++){
                  KO *ko = (KO *)tex->Curve->Items[(j+m)%Height];
                  if(m!=0&&ko->in!=ko->via){ //ø»ç°¡ ¾Æ´Ñ Á¤»óÄÚ°¡ ³ªÅ¸³¯¶§±îÁö
                    break;
                  }
                  int n;
                  for(n=j+m+1;n<j+Height;n++){//À§·Î ¿Ã¶ó°¨À̸é n°ªÀ» Å°¿ö¼­ ÇѲ¨¹ø¿¡ ó¸®//¾Æ´Ï¸é ÇÑÄÚ¾¿ ²÷¾î¼­ ó¸®
                    KO *kon = (KO *)tex->Curve->Items[n%Height];
                    bool *ol=(bool *)tex->Raise->Items[n%Height];
                    if(*ol==false){
                      break;
                    }
                    if(kon->in!=kon->via){ //ø»ç°¡ ¾Æ´Ñ Á¤»óÄÚ°¡ ³ªÅ¸³ª¸é..
                      break;
                    }
                  }
                  KO *ko0 = (KO *)tex->Curve->Items[(j+m-1+Height)%Height];
                  KO *ko1 = (KO *)tex->Curve->Items[(j+m)%Height];
                  KO *ko2 = (KO *)tex->Curve->Items[(n)%Height];
                  KO *ko3 = (KO *)tex->Curve->Items[(n+1)%Height];

                  int via0       = ko0->via       + k + tex->leftShift;
                  int in0        = ko0->in        + k + tex->leftShift;
                  int via1       = ko1->via       + k + tex->leftShift;
                  int in1        = ko1->in        + k + tex->leftShift;
                  int via2       = ko2->via       + k + tex->leftShift;
                  int in2        = ko2->in        + k + tex->leftShift;
                  int via3       = ko3->via       + k + tex->leftShift;
                  int in3        = ko3->in        + k + tex->leftShift;

                  if(in0>via0) in0--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
                  if(via0>in0) via0--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù
                  if(in1>via1) in1--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
                  if(via1>in1) via1--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù
                  if(in2>via2) in2--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
                  if(via2>in2) via2--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù
                  if(in3>via3) in3--;                            // KOÀÇ ÁÂÇ¥°è´Â 0¹ø¹Ù´ÃÀÇ ¿À¸¥ÂÊ¿¡¼­ ½ÃÀÛÇÑ´Ù
                  if(via3>in3) via3--;                           // tricot¿Í octopusÀÇ ÁÂÇ¥°è´Â ¹Ù´ÃÁÂÇ¥°èÀÌ´Ù

                  p1.x=GetBoxX(in1);//p1Àº box ¾È¿¡ ¾î¶² octopus¿¡ ´ëÀÀµÊ
                  p1.y=GetBoxY(j+m);
                  p2.x=p1.x-in1+in2;//p2´Â ´ëÀÀµÈ p1¿¡ ´ëÇÑ »ó´ëÀûÀÎ À§Ä¡
                  p2.y=p1.y+(n-(j+m));
                  octo=GetOctopus(p1.x,p1.y);
                  octo->posX=p1.x*RDistX;
                  octo->posY=p1.y*RDistY;
                  CourseState2 *cs2=(CourseState2 *)tex->Courses->Items[p1.y];
                  if(ShowRunin[i]) octo->tension+=cs2->ratio-100;

                  octo->used = true;
                  SLEG *Leg = new SLEG;
                  Leg->Layer = i;
                  Leg->yarn = yarn;
                  Leg->isTransParent = isTransParent;
                  Leg->link = p2;
                  if(n==j+m+1){//À§·Î ¿Ã¶ó°¨ÀÌ ¾Æ´Ñ°æ¿ì ÇÑÄÚ¾¿ ²÷¾îÁü(n==j+m+1)
                    Leg->ls = NORMAL_LEG;
                  } else {
                    bool *force=(bool *)tex->Force->Items[(j+m+1)%Height];//½ÃÀÛÁ¡ÀÌ forcedÀ̸é ø»çÀÇ Æ¯¼º»ó forced·Î °¡Á¤ÇÔ
                    if(*force){
                      Leg->ls = TOP_LEG_FORCE;
                    } else {
                      Leg->ls = TOP_LEG;
                    }
                  }
                  if(straight) {
                    //À̸®·Î µé¾î¿ÀÁö ¸øÇÔ
                    Leg->slt1=C_SLEG;
                    Leg->slt2=C_SLEG;
                  } else {
                    static bool right=true;
                    if(ko1->in>ko0->via){
                      Leg->slt1 = R_SLEG;
                    } else if(ko1->in<ko0->via){
                      Leg->slt1 = L_SLEG;
                    } else {
                      if(right){
                        Leg->slt1 = R_SLEG;
                      } else {
                        Leg->slt1 = L_SLEG;
                      }
                    }
                    if(ko2->in>ko1->via){
                      Leg->slt2 = R_SLEG;
                      right=true;
                    } else if(ko2->in<ko1->via){
                      Leg->slt2 = L_SLEG;
                      right=false;
                    } else {
                      if(right){
                        Leg->slt2 = R_SLEG;
                      } else {
                        Leg->slt2 = L_SLEG;
                      }
                    }

                    if(ko1->via!=ko1->in){
                      Leg->slt1=LL_SLEG;
                    }
                    if(ko2->via!=ko2->in){
                      Leg->slt2=LL_SLEG;
                    }

                  }
                  Leg->ratio=cs2->ratio;
                  octo->ListOfSLeg->Add(Leg);

                  m=n-j-1;
                }
              }
              //////////////////////////////////////////////////////////////////

            }
          } else {  //ÇöÀçÄÚ¿Í À­ÄÚ°¡ Á¤»óÄÚ//¿¬¼Ó Á¤»óÄÚ(2¸ñÆí Æ÷ÇÔ)

            if(via>in){
              for(int o=in;o<via;o++){ //in==viaÁ¦¿Ü
                p1.x=GetBoxX(o);
                p1.y=GetBoxY(j);
                p2.x=p1.x+1;
                p2.y=p1.y;
                octo=GetOctopus(p1.x,p1.y);
                octo->posX=p1.x*RDistX;
                octo->posY=p1.y*RDistY;
                CourseState2 *cs2=(CourseState2 *)tex->Courses->Items[p1.y];
                if(ShowRunin[i]) octo->tension+=cs2->ratio-100;

                octo->used = true;

                octo->hasHead = true;
                HEAD *Head = new HEAD;
                Head->Layer = i;
                Head->yarn = yarn;
                if(ko->via>ko->in){
                  if(ko->via>upperko->in){
                    Head->ht = R_HEAD;
                  } else {
                    Head->ht = O_HEAD;
                  }
                } else if(ko->via<ko->in){
                  if(ko->via<upperko->in){
                    Head->ht = L_HEAD;
                  } else {
                    Head->ht = O_HEAD;
                  }
                }
                Head->isTransParent = isTransParent;
                Head->ratio=cs2->ratio;
                octo->ListOfHead->Add(Head);

                LEG *Leg = new LEG;
                Leg->Layer = i;
                Leg->yarn = yarn;
                Leg->isTransParent = isTransParent;
                Leg->isTreated = false;
                Leg->link = p2;
                Leg->ls = NORMAL_LEG;
                if(ko->via>upperko->in){
                  Leg->lt = RL_LEG;
                } else if(ko->via<upperko->in){
                  Leg->lt = LR_LEG;
                } else {
                  if(ko->via<ko->in){
                    Leg->lt = RR_LEG;
                  } else {
                    Leg->lt = LL_LEG;
                  }
                }
                Leg->ratio=cs2->ratio;
                octo->ListOfLeg->Add(Leg);
              }
            } else if(via<in){
              for(int o=in;o>via;o--){ //in==viaÁ¦¿Ü
                p1.x=GetBoxX(o);
                p1.y=GetBoxY(j);
                p2.x=p1.x-1;
                p2.y=p1.y;
                octo=GetOctopus(p1.x,p1.y);
                octo->posX=p1.x*RDistX;
                octo->posY=p1.y*RDistY;
                CourseState2 *cs2=(CourseState2 *)tex->Courses->Items[p1.y];
                if(ShowRunin[i]) octo->tension+=cs2->ratio-100;

                octo->used = true;

                octo->hasHead = true;
                HEAD *Head = new HEAD;
                Head->Layer = i;
                Head->yarn = yarn;
                if(ko->via>ko->in){
                  if(ko->via>upperko->in){
                    Head->ht = R_HEAD;
                  } else {
                    Head->ht = O_HEAD;
                  }
                } else if(ko->via<ko->in){
                  if(ko->via<upperko->in){
                    Head->ht = L_HEAD;
                  } else {
                    Head->ht = O_HEAD;
                  }
                }
                Head->isTransParent = isTransParent;
                Head->ratio=cs2->ratio;
                octo->ListOfHead->Add(Head);

                LEG *Leg = new LEG;
                Leg->Layer = i;
                Leg->yarn = yarn;
                Leg->isTransParent = isTransParent;
                Leg->isTreated = false;
                Leg->link = p2;
                Leg->ls = NORMAL_LEG;
                if(ko->via>upperko->in){
                  Leg->lt = RL_LEG;
                } else if(ko->via<upperko->in){
                  Leg->lt = LR_LEG;
                } else {
                  if(ko->via<ko->in){
                    Leg->lt = RR_LEG;
                  } else {
                    Leg->lt = LL_LEG;
                  }
                }
                Leg->ratio=cs2->ratio;
                octo->ListOfLeg->Add(Leg);
              }
            }
            p1.x=GetBoxX(via);
            p1.y=GetBoxY(j);
            p2.x=p1.x-via+upperin;
            p2.y=p1.y+1;
            octo=GetOctopus(p1.x,p1.y);
            octo->posX=p1.x*RDistX;
            octo->posY=p1.y*RDistY;
            CourseState2 *cs2=(CourseState2 *)tex->Courses->Items[p1.y];
            if(ShowRunin[i]) octo->tension+=cs2->ratio-100;
           
            octo->used = true;

            octo->hasHead = true;
            HEAD *Head = new HEAD;
            Head->Layer = i;
            Head->yarn = yarn;
            if(ko->via>ko->in){
              if(ko->via>upperko->in){
                Head->ht = R_HEAD;
              } else {
                Head->ht = O_HEAD;
              }
            } else if(ko->via<ko->in){
              if(ko->via<upperko->in){
                Head->ht = L_HEAD;
              } else {
                Head->ht = O_HEAD;
              }
            }
            Head->isTransParent = isTransParent;
            Head->ratio=cs2->ratio;
            octo->ListOfHead->Add(Head);

            LEG *Leg = new LEG;
            Leg->Layer = i;
            Leg->yarn = yarn;
            Leg->isTransParent = isTransParent;
            Leg->isTreated = false;
            Leg->link = p2;
            Leg->ls = NORMAL_LEG;
            if(ko->via>upperko->in){
              Leg->lt = RL_LEG;
            } else if(ko->via<upperko->in){
              Leg->lt = LR_LEG;
            } else {
              if(ko->via<ko->in){
                Leg->lt = RR_LEG;
              } else {
                Leg->lt = LL_LEG;
              }
            }
            Leg->ratio=cs2->ratio;
            octo->ListOfLeg->Add(Leg);

          }
        }
      }
    }
  }

  if(percent)percent->Percentage(100);

  AfterInitTricot();
}
//---------------------------------------------------------------------------

void __fastcall Tricot::Optimize(bool do_optimize, int span_effect, bool *NoTension, ProgressPercentage *percent){

  BeforeOptimize(NoTension);

  if(do_optimize){
    int TERM = 32;
    if(percent)percent->Percentage(0);
    int pro=0;

    HEAD *Head;

    for(int n=0;n<Width*Height*TERM;n++){
      int i=n%Width;//rand()%Width;          //·£´ý¸·À½(040705): ¿­¾î³õÀ¸¸é ½ÇµéÀÌ ¾à°£¾¿ ·£´ýÇÏ°Ô Á¿ì·Î ¿òÁ÷¿©¼­ ·»´õ¸µ µÈ´Ù
      int j=(n/Width)%Height;//rand()%Height;//±×·±µ¥ Á¶Á÷ÀÌ ´Ü¼øÇؼ­ Á¶±Ý¸¸ ·»´õ¸µÇؼ­ ¹Ýº¹µÇ´Â ±¸Á¶ÀÌ¸é ¿òÁ÷ÀΰÍÀÌ ÁÙ·Î º¸ÀδÙ
      Octopus *octo = GetOctopus(i,j);
      if(octo->used==false)continue;
      Octopus *leftocto=NULL;
      double leftx,rightx;
      for(int o=1;o<=Width;o++){
        leftocto = GetOctopus(i+o,j);
        if(leftocto->used==true){
          leftx=FindRealPosX(leftocto,i+o,j);
          break;
        }
        leftocto=NULL;
      }
      Octopus *rightocto=NULL;
      for(int o=1;o<=Width;o++){
        rightocto = GetOctopus(i-o,j);
        if(rightocto->used==true){
          rightx=FindRealPosX(rightocto,i-o,j);
          break;
        }
        rightocto=NULL;
      }

      double midX = FindMidPointX(octo,i,j,NoTension);

      if(span_effect){
        double midY = FindMidPointY(octo,i,j, NoTension);
        octo->posY+= midY - FindRealPosY(octo,i,j);
      }

      int pl=0,pr=0;
      int p=0;

      if(leftocto&&leftocto->used)pl++;
      if(rightocto&&rightocto->used)pr++;
      if(octo->used)p++;

      if(p==1 && pl==1 && pr==1){
        octo->posX+= midX - FindRealPosX(octo,i,j);
      } else if(p==1 && pl==1){
        if(rightx > midX)
          octo->posX+= rightx - FindRealPosX(octo,i,j);
        else octo->posX+= midX - FindRealPosX(octo,i,j);
      } else if(p==1 && pr==1){
        if(leftx < midX)
          octo->posX+= leftx - FindRealPosX(octo,i,j);
        else octo->posX+= midX - FindRealPosX(octo,i,j);
      } else {
        octo->posX+= midX - FindRealPosX(octo,i,j);
      }

      if(n%10==0){
        if(pro!=(n*100/(Width*Height*TERM))){
          if(percent)percent->Percentage(n*100/(Width*Height*TERM));
          //if(DegreeOfOptimizing()<0.001*Width*Height) break;
          pro=(n*100/(Width*Height*TERM));
        }

      }
    }

    if(percent)percent->Percentage(100);
  }

  AfterOptimize();//À§Ä¡ °áÁ¤ ÀÌÈÄ¿¡ º¯°æµÇ¾î¾ßÇÒ »óŸ¦ ¼¼ÆÃ

}

//---------------------------------------------------------------------------
void __fastcall Tricot::BeforeOptimize(bool *NoTension){

  for(int i=0;i<Width;i++){
    for(int j=0;j<Height;j++){
      Octopus *octo = GetOctopus(i,j);
      if(octo->used==false)continue;
      Octopus *upperocto = GetOctopus(i,j+1);
      if(upperocto->used==false){
        octo->hasHead=false;//¸Ó¸®(ÄÚ)¿¡ °É¸®Áö ¾ÊÀ¸¸é ¸Ó¸®(ÄÚ)°¡ »ç¶óÁø´Ù
      }
    }
  }


  for(int i=0;i<Width;i++){//½ºÆǵ¦½º¸¦ À§ÇÑ µ¥ÀÌŸ ÃʱâÈ­//ÇöÀç ¾²ÀÌÁö ¾Ê°í ÀÖÀ½
    for(int j=0;j<Height;j++){
      Octopus *octo = GetOctopus(i,j);
      Movement *mv = (Movement *)lpMovement->Items[j*Width + i];
      mv->ox=mv->x=octo->posX;
      mv->oy=mv->y=octo->posY;
    }
  }

  for(int i=0;i<Width;i++){
    for(int j=0;j<Height;j++){
      Octopus *octo = GetOctopus(i,j);
      if(octo->used==false)continue;
      for(int k=0;k<octo->ListOfLeg->Count;k++){
        LEG *Leg=(LEG *)octo->ListOfLeg->Items[k];
        if(Leg->ls==NO_LEG)continue;
        if(NoTension[Leg->Layer])continue;
        Octopus *octo2=GetOctopus(GetBoxX(Leg->link.x),GetBoxY(Leg->link.y));
        MLEG *MLeg=new MLEG;
        MLeg->yarn=Leg->yarn;
        MLeg->link=Point(i+GetBoxX(Leg->link.x)-Leg->link.x,j+GetBoxY(Leg->link.y)-Leg->link.y);
        MLeg->ls=Leg->ls;
        MLeg->ratio=Leg->ratio;
        octo2->ListOfMLeg->Add(MLeg);
      }
    }
  }

  for(int i=0;i<Width;i++){//ø»çÀÇ ¹Ì·¯·¹±×¸¦ ¸¸µç´Ù//ø»ç´Â Á÷Á¢ ÃÖÀûÈ­¿¡ ¾²ÀÌÁö ¾ÊÀ¸¹Ç·Î//À§Ä¡º¸Á¤À» ÅëÇÏ¿© ½Ö¹æÇ⠹̷¯·¹±×¸¦ »ý¼ºÇÑ´Ù
    for(int j=0;j<Height;j++){
      Octopus *octo = GetOctopus(i,j);
      if(octo->used==false)continue;
      for(int k=0;k<octo->ListOfSLeg->Count;k++){
        Octopus *octo1=NULL,*octo2=NULL;
        POINT p1,p2;
        SLEG *Leg=(SLEG *)octo->ListOfSLeg->Items[k];
        MLEG *MLeg=NULL;
        if(Leg->ls==NO_LEG)continue;
        if(NoTension[Leg->Layer])continue;
        if(Leg->slt1==C_SLEG||Leg->slt2==C_SLEG)continue;
        if(Leg->slt1==R_SLEG||Leg->slt1==RR_SLEG){
          octo1=GetOctopus(i-1,j);
          p1.x=i-1;
          p1.y=j;
        } else {
          octo1=octo;
          p1.x=i;
          p1.y=j;
        }
        if(Leg->slt2==R_SLEG||Leg->slt2==RR_SLEG){
          octo2=GetOctopus(GetBoxX(Leg->link.x-1),GetBoxY(Leg->link.y));
          p2.x=Leg->link.x-1;
          p2.y=Leg->link.y;
        } else {
          octo2=GetOctopus(GetBoxX(Leg->link.x),GetBoxY(Leg->link.y));
          p2.x=Leg->link.x;
          p2.y=Leg->link.y;
        }

        MLeg=new MLEG;
        MLeg->yarn=Leg->yarn;
        MLeg->link=Point(p2.x+GetBoxX(p1.x)-p1.x,p2.y+GetBoxY(p1.y)-p1.y);
        MLeg->ls=Leg->ls;
        MLeg->ratio=Leg->ratio;
        octo1->ListOfMLeg->Add(MLeg);

        MLeg=new MLEG;
        MLeg->yarn=Leg->yarn;
        MLeg->link=Point(p1.x+GetBoxX(p2.x)-p2.x,p1.y+GetBoxY(p2.y)-p2.y);
        MLeg->ls=Leg->ls;
        MLeg->ratio=Leg->ratio;
        octo2->ListOfMLeg->Add(MLeg);
      }
    }
  }

}
//---------------------------------------------------------------------------
void __fastcall Tricot::AfterOptimize(){
  //À§Ä¡ °áÁ¤ÀÌ ³¡³ª°í headstate¸¦ Á¤ÇÑ´Ù
  for(int i=0;i<Width;i++){
    for(int j=0;j<Height;j++){
      Octopus *octo = GetOctopus(i,j);
      Octopus *upocto = GetOctopus(i,j+1);
      if(octo->used==false)continue;
      if(upocto->used==false)continue;

      double DX = fabs(FindRealPosX(octo,i,j)-FindRealPosX(upocto,i,j+1));
      double DY = fabs(FindRealPosY(octo,i,j)-FindRealPosY(upocto,i,j+1));
      double tangent;
      if(DX==0){
        tangent = M_PI*0.5;
      } else {
        tangent = atan(DY/DX);
      }
      if(tangent<0) tangent=-tangent;

      int left=0;
      for(int k=0;k<upocto->ListOfHead->Count;k++){
        HEAD *Head=(HEAD *)upocto->ListOfHead->Items[k];
        if(Head->ht==O_HEAD) left++;
        else if(Head->ht==L_HEAD) left+=2;
      }
      if(octo->hasHead) {
        if(upocto->ListOfHead->Count){
          octo->head_wideness=(double)((upocto->ListOfHead->Count*2-left)*left)/pow(upocto->ListOfHead->Count,2);
          octo->head_wideness=0.5*(octo->head_wideness)+0.5*(tangent/(M_PI*0.5));//0<head_wideness<1
//          octo->head_wideness+=(double)(rand()%11-5)/50.0;
          octo->head_wideness*=0.5;
        } else {
          octo->head_wideness=0;
        }
      }
      if(octo->head_wideness<0) octo->head_wideness=0;
      else if(octo->head_wideness>1) octo->head_wideness=1;
    }
  }

}
//---------------------------------------------------------------------------
void __fastcall Tricot::BeforeInitTricot(){
//  lpUsedLayerMap = VirtualAlloc(NULL,Width*Height*sizeof(int),MEM_COMMIT,PAGE_READWRITE);
//  if(lpUsedLayerMap) VirtualLock(lpUsedLayerMap,Width*Height*sizeof(int));
}
//---------------------------------------------------------------------------
void __fastcall Tricot::AfterInitTricot(){
//  if(lpUsedLayerMap) VirtualUnlock(lpUsedLayerMap,Width*Height*sizeof(int));
//  if(lpUsedLayerMap) VirtualFree(lpUsedLayerMap,Width*Height*sizeof(int),MEM_DECOMMIT);
//  lpUsedLayerMap=NULL;
}
//---------------------------------------------------------------------------
int __fastcall Tricot::GetLength(Octopus *octo, int i, int j, int Layer, int length_method){//mm ´ÜÀ§ ¸®ÅÏ
  double c = 0.01371;
  double d = 0;
  switch(length_method){
    case 0:
    {
      c=0.01371;
      break;
    }
    case 1:
    {
      c=0.019;
      break;
    }
    case 2:
    {
      c=0.0114;
      break;
    }
    default:
    {
      c=0.01371;
      break;
    }
  }

  double len=0;

  LEG *Leg;
  HEAD *Head;

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

  if(octo->hasHead){
    for(int k=0;k<octo->ListOfHead->Count;k++){
      Head = (HEAD *)octo->ListOfHead->Items[k];
      if(Head->Layer!=Layer)continue;
      Octopus *sideocto = (Octopus *)GetOctopus(i, j+1);
      double sx = FindRealPosX(sideocto,i,j+1);
      double sy = FindRealPosY(sideocto,i,j+1);
      if(sideocto->used==true){
        if(d==0){
          if(length_method!=1) d=c*sqrt(Head->yarn->denier);
          else d=c*sqrt(12*Head->yarn->filament-3)/3.0;
        }
        len+=2.05*sqrt((sx-x)*(sx-x)+(sy-y)*(sy-y)+4.0*d*d);
      }
    }
  }

  for(int k=0;k<octo->ListOfLeg->Count;k++){
    Leg = (LEG *)octo->ListOfLeg->Items[k];
    if(Leg->ls==NO_LEG)continue;
    if(Leg->Layer!=Layer)continue;
    Octopus *sideocto = (Octopus *)GetOctopus(Leg->link.x,Leg->link.y);
    double sx = FindRealPosX(sideocto,Leg->link.x,Leg->link.y);
    double sy = FindRealPosY(sideocto,Leg->link.x,Leg->link.y);
    if(d==0){
      if(length_method!=1) d=c*sqrt(Leg->yarn->denier);
      else d=c*sqrt(12*Leg->yarn->filament-3)/3.0;
    }
    switch(Leg->lt){
      case RR_LEG:
        len+=sqrt(
          ((sx+sideocto->plusX)-(x+octo->plusX))*
          ((sx+sideocto->plusX)-(x+octo->plusX))
          +
          ((sy+sideocto->plusY)-(y+octo->plusY))*
          ((sy+sideocto->plusY)-(y+octo->plusY)));
        break;
      case RL_LEG:
        len+=sqrt(
          ((sx-sideocto->plusX)-(x+octo->plusX))*
          ((sx-sideocto->plusX)-(x+octo->plusX))
          +
          ((sy-sideocto->plusY)-(y+octo->plusY))*
          ((sy-sideocto->plusY)-(y+octo->plusY)));
        break;
      case LR_LEG:
        len+=sqrt(
          ((sx+sideocto->plusX)-(x-octo->plusX))*
          ((sx+sideocto->plusX)-(x-octo->plusX))
          +
          ((sy+sideocto->plusY)-(y-octo->plusY))*
          ((sy+sideocto->plusY)-(y-octo->plusY)));
        break;
      case LL_LEG:
        len+=sqrt(
          ((sx-sideocto->plusX)-(x-octo->plusX))*
          ((sx-sideocto->plusX)-(x-octo->plusX))
          +
          ((sy-sideocto->plusY)-(y-octo->plusY))*
          ((sy-sideocto->plusY)-(y-octo->plusY)));
        break;
    }
  }

  Octopus *octo1 = (Octopus *)GetOctopus(i,j);
  Octopus *octo2 = (Octopus *)GetOctopus(i-1,j);
  double x1,x2,y1,y2;
  if(octo2->used){
    x1 = FindRealPosX(octo1,i,j);
    y1 = FindRealPosY(octo1,i,j);
    x2 = FindRealPosX(octo2,i-1,j);
    y2 = FindRealPosY(octo2,i-1,j);
  } else {
    x1 = FindRealPosX(octo1,i,j);
    y1 = 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->Layer!=Layer)continue;
    Octopus *sideocto1 = (Octopus *)GetOctopus(Leg->link.x,Leg->link.y);
    Octopus *sideocto2 = (Octopus *)GetOctopus(Leg->link.x-1,Leg->link.y);
    double sx1,sy1,sx2,sy2;
    if(sideocto2->used){
      sx1 = FindRealPosX(sideocto1,Leg->link.x,Leg->link.y);
      sy1 = FindRealPosY(sideocto1,Leg->link.x,Leg->link.y);
      sx2 = FindRealPosX(sideocto2,Leg->link.x-1,Leg->link.y);
      sy2 = FindRealPosY(sideocto2,Leg->link.x-1,Leg->link.y);
    } else {
      sx1 = FindRealPosX(sideocto1,Leg->link.x,Leg->link.y);
      sy1 = FindRealPosY(sideocto1,Leg->link.x,Leg->link.y);
      sx2 = sx1;
      sy2 = sy1;
    }
    if(d==0){
      if(length_method!=1) d=c*sqrt(Leg->yarn->denier);
      else d=c*sqrt(12*Leg->yarn->filament-3)/3.0;
    }
    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;
    }
    len+=sqrt((ox-sx)*(ox-sx)+(oy-sy)*(oy-sy));
  }
  return (len+7.28*d)*480.0;

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