//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "ImageAssemble_F.h"
#include "MainImage.h"
#include "Rotation.h"
#include "MoveCopy_F.h"
#include "Palette.h"
#include "LogData.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "RzButton"
#pragma link "RzPanel"
#pragma link "RzRadChk"
#pragma resource "*.dfm"
TImageAssembleForm *ImageAssembleForm;

#define IDS_ASSEMBLE              StringTable[0]
#define IDS_ASSEMBLEMERGE         StringTable[1]
#define IDS_ASSEMBLEREPEAT        StringTable[2]
#define IDS_ASSEMBLESETWORKAREA   StringTable[3]
#define IDS_ASSEMBLESETPOINTS     StringTable[4]
#define IDS_ASSEMBLESETREPEATAREA StringTable[5]
#define IDS_ASSEMBLESETGRID       StringTable[6]
#define IDS_ASSEMBLEMODIFYGRID    StringTable[7]
#define IDS_ASSEMBLERUN           StringTable[8]

//---------------------------------------------------------------------------
__fastcall TImageAssembleForm::TImageAssembleForm(TComponent* Owner)
  : TForm(Owner)
{
  BEGIN_LOG("");

	hWnd = ((TWinControl *)Owner)->Handle;
	//==============================================================
	StringTable.Create(DirectoryItem, Language, "ImageAssemble");

  rzbtIAMerge->Caption      = IDS_ASSEMBLEMERGE;
  rzbtIARepeat->Caption     = IDS_ASSEMBLEREPEAT;
  rzchbIASetPoints->Caption = IDS_ASSEMBLESETPOINTS;
  rzbtRun->Caption          = IDS_ASSEMBLERUN;

  rzbtIASetWorkArea->Hint = IDS_ASSEMBLESETWORKAREA;
  rzbtIAWorkArea->Hint    = IDS_ASSEMBLESETREPEATAREA;
  rzbtIASetGrid->Hint     = IDS_ASSEMBLESETGRID;
  rzbtIAModifyGrid->Hint  = IDS_ASSEMBLEMODIFYGRID;

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TImageAssembleForm::FormCreate(TObject *Sender)
{
  BEGIN_LOG("");

  workAreaMenu = new TWorkAreaMenu;
  Init();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TImageAssembleForm::Init()   // ¾Ë°í¸®Áò¿¡ °ü·ÃµÈ ³»¿ë ÃʱâÈ­
{
  BEGIN_LOG("");

  ResetPoint();

  imageAssembleItem = I_NONE;
  imageAssembleMode = IA_MERGE;

	window.Bitmap = NULL;
	window.Mask = NULL;
  window.Back = NULL;

  workAreaMenu->Create();
  workAreaMenu->InitMenu();
  workAreaMenu->InitItem(WI_IRREGULAR);
//  MainForm->rztoolbarWorkArea->Visible = false;
//  workAreaMenu->ResetBitmapRegion();

  //rzToolbar = MainForm->rztoolbarImageAssemble;
  //MainForm->SubMenuForm = NULL;
  //MainForm->rztoolbarImageAssemble->OnVisibleChanged = Close;

  MainImageForm->iMainImage->OnPaintUpperVector = DrawLine;    //ã¾Æ¼­ ¿¬°á

  /*
  MainForm->miIAImageMergeSetWorkArea->OnClick = MergeItemClick;
  MainForm->miIAImageMergeSetPoints->OnClick = MergeItemClick;
  MainForm->miIAImageMergeRun->OnClick = MergeItemClick;
  MainForm->miIAImageRepeatSetWorkArea->OnClick = RepeatItemClick;
  MainForm->miIAImageRepeatSetGrid->OnClick = RepeatItemClick;
  MainForm->miIAImageRepeatModifyGrid->OnClick = RepeatItemClick;
  MainForm->miIAImageRepeatRun->OnClick = RepeatItemClick;

  MainForm->miIAImageMerge->Caption = IDS_ASSEMBLEMERGE;
  MainForm->miIAImageRepeat->Caption = IDS_ASSEMBLEREPEAT;
  MainForm->miIAImageMergeSetWorkArea->Caption = IDS_ASSEMBLESETWORKAREA;
  MainForm->miIAImageMergeSetPoints->Caption = IDS_ASSEMBLESETPOINTS;
  MainForm->miIAImageMergeRun->Caption = IDS_ASSEMBLERUN;
  MainForm->miIAImageRepeatSetWorkArea->Caption = IDS_ASSEMBLESETREPEATAREA;
  MainForm->miIAImageRepeatSetGrid->Caption = IDS_ASSEMBLESETGRID;
  MainForm->miIAImageRepeatModifyGrid->Caption = IDS_ASSEMBLEMODIFYGRID;
  MainForm->miIAImageRepeatRun->Caption = IDS_ASSEMBLERUN;
  */

  ShowToolButton();

  END_LOG;
}

//---------------------------------------------------------------------------
void __fastcall TImageAssembleForm::Close(TObject* Sender)
{

}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::Destroy()  // Åø¹Ù³ª Æû Á¦°Å
{
  MainImageForm->iMainImage->OnPaintUpperVector = NULL;
  //MainForm->rztoolbarMoveCopy->OnVisibleChanged = NULL;
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::ModeClick(TObject *Sender)
{
  BEGIN_LOG("");

  if(rzbtIAMerge->Down == true)
  {
    imageAssembleMode = IA_MERGE;
    workAreaMenu->ExitItem();
    workAreaMenu->InitItem(WI_IRREGULAR);
    WorkAreaClick(rzbtIASetWorkArea);
  }
  else
  {
    ResetBitmapRegion();
    imageAssembleMode = IA_REPEAT;
    workAreaMenu->ExitItem();
    workAreaMenu->InitItem(WI_SHAPE);
    workAreaMenu->SubItem = WSI_RECTANGLE;
    WorkAreaClick(rzbtIAWorkArea);
  }
  //imageAssembleItem = I_NONE;

  ShowToolButton();
  MainImageForm->iMainImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TImageAssembleForm::InitForm()
{
  BEGIN_LOG("");

	//TCursor OldCursor;

	//ParentHeight = Parent->Height;
	//ClientHeight = 113;
	//Parent->Height = ParentHeight+ClientHeight;
	//OldCursor      = Screen->Cursor;
	//Screen->Cursor = crHourGlass;

	//Parent->Repaint();

	END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TImageAssembleForm::FormDestroy(TObject *Sender)
{
  BEGIN_LOG("");

  if (workAreaMenu){
    workAreaMenu->ExitItem();
    delete workAreaMenu;
    workAreaMenu = NULL;
  }

  Destroy();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TImageAssembleForm::ExitForm()
{
//
}
//---------------------------------------------------------------------------
///ÀÛ¾÷±¸¿ª Àâ´Â ±â´É buttonÀ» ´­·¶À»¶§.
void __fastcall TImageAssembleForm::WorkAreaClick(TObject *Sender)
{
  BEGIN_LOG("");

  TRzBitBtn* sender = dynamic_cast<TRzBitBtn*>(Sender);
  sender->Down == true ? imageAssembleItem = I_SETWORKAREA : imageAssembleItem = I_NONE;
  if (imageAssembleMode == IA_MERGE) rzchbIASetPoints->Checked = false;
  ShowToolButton();
  MainImageForm->iMainImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
///³×Á¡±â´É¿¡¼­ 4°³ÀÇ Á¡À» ÁöÁ¤ÇÏ´Â ±â´É buttonÀ» ´­·¶À»¶§
void __fastcall TImageAssembleForm::SetPointsClick(TObject *Sender)
{
  BEGIN_LOG("");

  TRzCheckBox* sender = dynamic_cast<TRzCheckBox*>(Sender);
  sender->Checked == true ? imageAssembleItem = I_SETPOINTS : imageAssembleItem = I_SETWORKAREA;
  rzbtIASetWorkArea->Down = false;
  ResetPoint();
  ShowToolButton();
  MainImageForm->iMainImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
///grid±â´É¿¡¼­ grid¸¦ Ãß°¡ÇÏ´Â ±â´É buttonÀ» ´­·¶À»¶§.
void __fastcall TImageAssembleForm::SetGridClick(TObject *Sender)
{
  BEGIN_LOG("");

  TPoint left_top    (MainImageForm->WorkArea->Range.left, MainImageForm->WorkArea->Range.top);
  TPoint right_top   (MainImageForm->WorkArea->Range.right, MainImageForm->WorkArea->Range.top);
  TPoint right_bottom(MainImageForm->WorkArea->Range.right, MainImageForm->WorkArea->Range.bottom);
  TPoint left_bottom (MainImageForm->WorkArea->Range.left, MainImageForm->WorkArea->Range.bottom);

  TRzBitBtn* sender = dynamic_cast<TRzBitBtn*>(Sender);

  if(sender->Down == true)
  {
    switch(imageAssembleItem)
    {
      case I_SETWORKAREA:
        lattice.Init(left_top, right_top, right_bottom, left_bottom);
        break;
      case I_MODIFYGRID:
        lattice.InitByKeyOfPoint();
        break;
    }
    imageAssembleItem = I_SETGRID;
  }
  else
  {
    imageAssembleItem = I_SETWORKAREA;
  }
  ShowToolButton();
  MainImageForm->iMainImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
///grid±â´É¿¡¼­ grid¸¦ º¯ÇüÇÏ´Â ±â´É buttonÀ» ´­·¶À»¶§
void __fastcall TImageAssembleForm::ModifyGridClick(TObject *Sender)
{
  BEGIN_LOG("");

  TRzBitBtn* sender = dynamic_cast<TRzBitBtn*>(Sender);
  sender->Down == true ? imageAssembleItem = I_MODIFYGRID : imageAssembleItem = I_SETGRID;

  ShowToolButton();
  MainImageForm->iMainImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
///½ÇÇàbuttonÀ» ´­·¶À»¶§.
/**
³×Á¡±â´ÉÀ϶§´Â ÀÌ¹Ì ÁöÁ¤µÇ¾îÀÖ´Â µÎ ½ÖÀÇ Á¡ÀÇ °¢µµ¸¦ ±¸Çس»°í RotateWorkArea\()·Î ȸÀüº¯È¯ÇÔ.
grid±â´ÉÀ϶§´Â CaptureRectArea()·Î ÀÌ¹Ì ÁöÁ¤µÈ ÀÛ¾÷±¸¿ªÀÇ image¸¦ ÀúÀåÇÏ°í
transformedRectArea¿¡ µé¾îÀÖ´Â »ç°¢Çü ÇϳªÇϳª¿¡ ´ëÇؼ­ pull_image_repro()·Î º¯È¯ÇÔ.
*/
void __fastcall TImageAssembleForm::RunClick(TObject *Sender)
{
  BEGIN_LOG("");

  switch(imageAssembleMode)
  {
    case IA_MERGE:
      firstAngle = ArcTan2(point[0].y - point[2].y, point[0].x - point[2].x);
      secondAngle = ArcTan2(point[1].y - point[3].y, point[1].x - point[3].x);
      RotateWorkArea();
      WorkAreaClick(rzbtIASetWorkArea);
      break;

    case IA_REPEAT:
      lattice.Run();
      WorkAreaClick(rzbtIAWorkArea);
  }

  ShowToolButton();
  pnAssemble->SetFocus();

  END_LOG;
}
//---------------------------------------------------------------------------
///imageAssembleMode¿Í imageAssembleItemÀ» ÂüÁ¶ÇÏ¿© Çö »óÅ¿¡ ¸Â´Â ¸Þ´ºÀÇ iconµéÀ» º¸¿©ÁÖ°í ¼û±è
void __fastcall TImageAssembleForm::ShowToolButton()
{
  BEGIN_LOG("");

  rzbtIAMerge->Down = false;
  rzbtIARepeat->Down = false;
  rzbtIASetWorkArea->Down = false;
  rzbtIAWorkArea->Down = false;
  rzbtIASetGrid->Down = false;
  rzbtIAModifyGrid->Down = false;
  rzchbIASetPoints->Checked = (imageAssembleItem == I_SETPOINTS ? true : false);
  rzbtRun->Down = false;

  rzbtIASetGrid->Enabled = false;
  rzbtIAModifyGrid->Enabled = false;
  rzchbIASetPoints->Enabled = false;
	rzbtRun->Enabled = false;

  //rztbIASetGrid->Visible = false;
  //rztbIAModifyGrid->Visible = false;
  //rzchbIASetPoints->Visible = false;

  switch(imageAssembleMode)
  {
    case IA_MERGE:
      rzbtIAMerge->Down = true;
      pnMerge->Visible = true;
      pnMerge->BringToFront();

      //rzchbIASetPoints->Visible = true;
      break;
    case IA_REPEAT:
      rzbtIARepeat->Down = true;
      pnRepeat->Visible = true;
      pnRepeat->BringToFront();
      //rzbtIASetGrid->Visible = true;
      //rzbtIAModifyGrid->Visible = true;
      break;
  }
  switch(imageAssembleItem)
  {
    case I_NONE:
      rzbtIAWorkArea->Enabled = true;
      break;

    case I_SETWORKAREA:
      rzbtIASetWorkArea->Down = true;
      rzbtIAWorkArea->Down = true;
      rzbtIAWorkArea->Enabled = true;
      if(MainImageForm->WorkArea->Mask)
      {
        rzbtIASetGrid->Enabled = true;
        rzchbIASetPoints->Enabled = true;
      }
      break;

    case I_SETPOINTS:
      rzchbIASetPoints->Checked = true;
      rzchbIASetPoints->Enabled = true;
			rzbtRun->Enabled = (nthPoint >= pointArraySize ? true : false);
      break;

    case I_SETGRID:
      rzbtIASetGrid->Down = true;
      rzbtIASetGrid->Enabled = true;
      rzbtIAModifyGrid->Enabled = true;
      break;

    case I_MODIFYGRID:
      rzbtIAModifyGrid->Down = true;
      rzbtIAModifyGrid->Enabled = true;
      rzbtIASetGrid->Enabled = true;
      rzbtRun->Enabled = true;
      break;

    case I_RUNNABLE:
      rzbtRun->Down = true;
      rzbtRun->Enabled = true;
      break;
  }

  /*
  MainForm->miIAImageMergeSetWorkArea->Enabled = MainForm->rztbIAWorkArea->Enabled;
  MainForm->miIAImageMergeSetPoints->Enabled = MainForm->rzchbIASetPoints->Enabled;
  MainForm->miIAImageMergeRun->Enabled = MainForm->rztbIARun->Enabled;
  MainForm->miIAImageRepeatSetWorkArea->Enabled = MainForm->rztbIAWorkArea->Enabled;
  MainForm->miIAImageRepeatSetGrid->Enabled = MainForm->rztbIASetGrid->Enabled;
  MainForm->miIAImageRepeatModifyGrid->Enabled = MainForm->rztbIAModifyGrid->Enabled;
  MainForm->miIAImageRepeatRun->Enabled = MainForm->rztbIARun->Enabled;
  */

  END_LOG;
}
//-----------------------------------------------------------------------------
///³×Á¡±â´É¿¡¼­ ³× Á¡ÀÇ À§Ä¡¸¦ (-1, -1)·Î reset(ÃʱâÈ­)ÇÏ´Â ÇÔ¼ö
void __fastcall TImageAssembleForm::ResetPoint()
{
  nthPoint = 0, pointArraySize = sizeof(point)/sizeof(TPoint);
  point[0] = point[1] = point[2] = point[3] = Point(-1, -1);
  indexOfSelectedPoint = -1;
}
//-----------------------------------------------------------------------------
///³×Á¡±â´É¿¡¼­ ³× Á¡À» º¯ÇüÇϱâÀ§ÇØ ¾î¶² Á¡À» Á¶ÀÛÇÏ·Á°í (X, Y)¸¦ clickÇßÀ»¶§ °Å±â¿¡ ÇØ´çÇÏ´Â Á¡ÀÇ index¸¦ ¹Ý³³
int __fastcall TImageAssembleForm::GetIndexOfSelectedPoint(int X, int Y)
{
  BEGIN_LOG("");

  for(int index = 0; index < pointArraySize ; ++index)
  {
    if(abs(X - point[index].x) < 4 && abs(Y - point[index].y) < 4)
    {
      END_LOG;
      return index;
    }
  }

  END_LOG;
  return -1;
}
//-----------------------------------------------------------------------------
///³×Á¡±â´ÉÀ̳ª grid±â´É¿¡¼­ 4°³ Á¡À» ÀÕ´Â ¼±À̳ª grid¸¦ ÀÌ·ç´Â ¼±À» ±×·ÁÁÖ´Â ÇÔ¼ö
void __fastcall TImageAssembleForm::DrawLine(HDC dcDst, int px, int py, int vw, int vh)
{
  BEGIN_LOG("");

  switch(imageAssembleItem)
  {
    case I_SETGRID:
    case I_MODIFYGRID:
      lattice.DrawTetraLine(dcDst);
      break;
    case I_SETPOINTS:
      DrawPointLine(dcDst);
      break;
    default:
      break;
  }

  END_LOG;
}
//-----------------------------------------------------------------------------
///³×Á¡±â´É¿¡¼­ °¢ ½ÖÀÇ Á¡À» ÀÕ´Â ¼±À» ±×·ÁÁÜ. class member point array¸¦ ÂüÁ¶ÇÏ¿© ±×¸°´Ù.
void __fastcall TImageAssembleForm::DrawPointLine(HDC dcDst)
{
  BEGIN_LOG("");

  TPoint view_point[4];
  list< pair<TPoint, int> > point_list;
  set<pair<TPoint, TPoint>, TPointPairLess> line_set;


  TPItemImage* Image = MainImageForm->iMainImage;
  float ratio = (float)Image->ZoomIn / Image->ZoomOut;
  int nXOffset = -Image->PositionX * ratio;
  int nYOffset = -Image->PositionY * ratio;

  int old_pen_mode = GetROP2(dcDst);
  int old_bg_mode = SetBkMode(dcDst, TRANSPARENT);
  COLORREF old_text_color = GetTextColor(dcDst);
  SetROP2(dcDst, R2_NOT);


  for(int index = 0 ; index < pointArraySize-2 ; index += 2)
  {


    for(int i = 0 ; i < 4 ; ++i)
    {
      if(point[index+i].x != -1 && point[index+i].y != -1)
      {
        view_point[i].x = nXOffset + (point[index+i].x * ratio);
        view_point[i].y = nYOffset + (point[index+i].y * ratio);
      }
      else
      {
        view_point[i].x = -1;
        view_point[i].y = -1;
      }

      point_list.push_back(make_pair(view_point[i], index+i));
    }

    line_set.insert(make_pair(view_point[0], view_point[1]));
    line_set.insert(make_pair(view_point[1], view_point[3]));
    line_set.insert(make_pair(view_point[2], view_point[3]));
    line_set.insert(make_pair(view_point[0], view_point[2]));
  }


  for(list< pair<TPoint, int> >::iterator i = point_list.begin() ; i != point_list.end() ; ++i)
  {
    if(i->first.x != -1 && i->first.y != -1)
    {
      Rectangle(dcDst, i->first.x - 4, i->first.y - 4, i->first.x + 4, i->first.y + 4);
      SetTextColor(dcDst, GetPixel(dcDst, i->first.x, i->first.y));
      TextOut(dcDst, i->first.x + 4, i->first.y + 4,
			  String(i->second).c_str(), String(i->second).Length());
    }
  }
	for(set< pair<TPoint, TPoint>, TPointPairLess >::iterator i = line_set.begin() ; i != line_set.end() ; ++i)
  {
    if(i->first.x != -1 && i->first.y != -1 && i->second.x != -1 && i->second.y  != -1)
    {
      view_point[0] = i->first;
      view_point[1] = i->second;
	  Polyline(dcDst, view_point, 2);
    }
  }


  SetROP2(dcDst, old_pen_mode);
  SetBkMode(dcDst, old_bg_mode);
  SetTextColor(dcDst, old_text_color);

  END_LOG;
}
//-----------------------------------------------------------------------------
///³×Á¡±â´É¿¡¼­ ÀÛ¾÷±¸¿ªÀ» ȸÀü È®´ëÇؼ­ user°¡ ÁöÁ¤ÇÑ Á¡¿¡ ¿Å±â´Â ÇÔ¼ö
/**
(¸ÕÀú movecopymenuÀÇ È®´ë ȸÀü ¸Þ´º¸¦ ½áº¸°í ¿À±æ ¹Ù¶÷)
¸ÕÀú user°¡ ÁöÁ¤ÇÑ µÎ ½ÖÀÇ Á¡À¸·Î »ý±â´Â ¼±ºÐÀÇ ±æÀ̸¦ ±¸ÇÑ´Ù.
±æÀÌÀÇ ºñ¿¡ µû¶ó ÀÛ¾÷±¸¿ªÀ» ¾ó¸¶³ª È®´ëÇÒÁö¸¦ °áÁ¤ÇÏ¿© ±×¿¡ ¸Â´Â À§Ä¡¿¡ clickÇÏ´Â
event¸¦ ¹ß»ý½ÃŲ´Ù. ±×¸®°í µÎ ¼±ºÐÀÇ °¢À» ±¸ÇØ ¾ó¸¶³ª ȸÀüÇÒÁö¸¦ °áÁ¤ÇÏ¿©
±×¿¡ ¸Â´Â À§Ä¡¿¡ clickÇÏ´Â event¸¦ ¹ß»ý½ÃŲ´Ù.
*/
void __fastcall TImageAssembleForm::RotateWorkArea()
{
  BEGIN_LOG("");

  double left = MainImageForm->WorkArea->Range.left;
  double right = MainImageForm->WorkArea->Range.right;
  double top = MainImageForm->WorkArea->Range.top;
  double bottom = MainImageForm->WorkArea->Range.bottom;

  double work_area_width = right - left;
  double work_area_height = bottom - top;

  expansionRatio = sqrt(  pow(point[1].x-point[3].x, 2) + pow(point[1].y-point[3].y, 2)  )
                   /
                   sqrt(  pow(point[0].x-point[2].x, 2) + pow(point[0].y-point[2].y, 2)  );

  expandedCentralPoint.x = left + (work_area_width * expansionRatio / 2.f);
  expandedCentralPoint.y = top + (work_area_height * expansionRatio / 2.f);

  expandedWindowSize = TPoint(work_area_width * expansionRatio, work_area_height * expansionRatio);

  double expanded_point_x = ((point[0].x - left) * expansionRatio) + left;
  double expanded_point_y = ((point[0].y - top)  * expansionRatio) + top;


  double rotated_point_x = (expanded_point_x - expandedCentralPoint.x)*cos(rotateAngle) -
                           (expanded_point_y - expandedCentralPoint.y)*sin(rotateAngle) +
                           expandedCentralPoint.x;
  double rotated_point_y = (expanded_point_x - expandedCentralPoint.x)*sin(rotateAngle) +
                           (expanded_point_y - expandedCentralPoint.y)*cos(rotateAngle) +
                           expandedCentralPoint.y;

  rotatedCentralPoint = TPoint(expandedCentralPoint.x - (rotated_point_x - point[1].x),
                               expandedCentralPoint.y - (rotated_point_y - point[1].y));

  InitWindow();
  EvalRotatedPoint();
  CreateWindowBitmap(rotatedWindowSize.x, rotatedWindowSize.y);
  MakeRotateImage();
  EraseWorkAreaIn();
  PutRotateImage();

  DeleteWindowBitmap();
  //MainImageForm->iMainImage->Repaint();

  END_LOG;
}
//-----------------------------------------------------------------------------
double __fastcall TImageAssembleForm::FrotateAngle()
{
  return FsecondAngle - FfirstAngle;
}
//-----------------------------------------------------------------------------
double __fastcall TImageAssembleForm::FfirstAngleInDeg()
{
  return FfirstAngle * 180 / M_PI;
}
//-----------------------------------------------------------------------------
double __fastcall TImageAssembleForm::FsecondAngleInDeg()
{
  return FsecondAngle * 180 / M_PI;
}
//-----------------------------------------------------------------------------
double __fastcall TImageAssembleForm::FrotateAngleInDeg()
{
  double rotate_angle_in_deg = (FsecondAngle - FfirstAngle) * 180 / M_PI;
  return (rotate_angle_in_deg<0   ?
          rotate_angle_in_deg+360 :
          rotate_angle_in_deg);
}
//-----------------------------------------------------------------------------
bool __fastcall TImageAssembleForm::iMainImageMouseDown(TObject *Sender, TMouseButton Button,
    TShiftState Shift, int X, int Y)
{
  if(Button != mbLeft)
    return false;

  BEGIN_LOG("");

  switch(imageAssembleItem)
  {
    case I_SETWORKAREA:
      workAreaMenu->iMainImageMouseDown(Sender, Button, Shift, X, Y);
      break;

    case I_SETPOINTS:
      if(nthPoint >= pointArraySize)
      {
        indexOfSelectedPoint = GetIndexOfSelectedPoint(X, Y);
      }
      else
      {
        point[nthPoint] = Point(X, Y);
      }
      ++nthPoint;
      break;

    case I_SETGRID:
      Shift.Contains(ssShift) ? lattice.SplitAreaByHorizontalLine(Y) : lattice.SplitAreaByVerticalLine(X);
      break;

    case I_MODIFYGRID:
      lattice.GetKeyOfSelectedPoint(X, Y, true);
      break;

    default:
      END_LOG;
      return true;
  }
  ShowToolButton();

  END_LOG;
  return false;
}
//-----------------------------------------------------------------------------
bool __fastcall TImageAssembleForm::iMainImageMouseMove(TObject *Sender, TShiftState Shift,
    int X, int Y)
{
  BEGIN_LOG("");

  TPoint temp_point;
  switch(imageAssembleItem)
  {
    case I_SETWORKAREA:
      workAreaMenu->iMainImageMouseMove(Sender, Shift, X, Y);
      break;

    case I_SETPOINTS:
      if(nthPoint < pointArraySize)
        break;

      if(indexOfSelectedPoint != -1 && Shift.Contains(ssLeft) && !Shift.Contains(ssCtrl))
      {
        point[indexOfSelectedPoint] = TPoint(X, Y);
        MainImageForm->iMainImage->Repaint();
      }

      if(GetIndexOfSelectedPoint(X, Y) != -1 && !Shift.Contains(ssCtrl))
      {
        MainImageForm->iMainImage->Cursor = crHandPoint;
      }
      else
      {
        MainImageForm->iMainImage->Cursor = crCross;
      }
      break;

    case I_SETGRID:
      MainImageForm->iMainImage->Cursor = crCross;
      break;

    case I_MODIFYGRID:
      if(Shift.Contains(ssLeft))
      {
        lattice.SetPointOfSelectedPoint(X, Y);
        MainImageForm->iMainImage->Repaint();
      }

      temp_point = lattice.GetKeyOfSelectedPoint(X, Y);
      if(temp_point.x != -1 && temp_point.y != -1)
      {
        MainImageForm->iMainImage->Cursor = crHandPoint;
      }
      else
      {
        MainImageForm->iMainImage->Cursor = crDefault;
      }
      break;

    default:
      END_LOG;
      return true;
  }
  END_LOG;
  return false;
}
//-----------------------------------------------------------------------------
bool __fastcall TImageAssembleForm::iMainImageMouseUp(TObject *Sender, TMouseButton Button,
    TShiftState Shift, int X, int Y)
{
  BEGIN_LOG("");

  switch(imageAssembleItem)
  {
    case I_SETWORKAREA:
      workAreaMenu->iMainImageMouseUp(Sender, Button, Shift, X, Y);
      break;
    default:
      END_LOG;
      return true;
  }
  END_LOG;
  return false;
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::iMainImageMouseLeave(TObject *Sender)
{
  switch(imageAssembleItem)
  {
    default:
      Screen->Cursor = crDefault;
    break;
  }
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::iMainImageMouseEnter(TObject *Sender)
{
}
//-----------------------------------------------------------------------------
bool __fastcall TImageAssembleForm::iMainImagePaint(TObject *Sender)
{
  BEGIN_LOG("");

  switch(imageAssembleItem)
  {
    case I_SETWORKAREA:
      workAreaMenu->iMainImagePaint(Sender);
      break;
    default:
      END_LOG;
      return true;
  }
  END_LOG;
  return false;
}
//-----------------------------------------------------------------------------
bool __fastcall TImageAssembleForm::iMainImageChange(TObject *Sender)
{
  return false;
}
//-----------------------------------------------------------------------------
bool __fastcall TImageAssembleForm::iMainImagePositionChange(TObject *Sender)
{
  return false;
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::iMainImageKeyDown(TObject *Sender, WORD Key, TShiftState Shift)
{
  BEGIN_LOG("");

  switch(imageAssembleItem)
  {
    case I_SETWORKAREA:
      workAreaMenu->iMainImageKeyDown(Sender, Key, Shift);
      break;

    case I_SETPOINTS:
    case I_MODIFYGRID:
      if(Key == VK_RETURN && rzbtRun->Enabled == true)
      {
        RunClick(rzbtRun);
      }
      break;
    default:
      END_LOG;
      return;
  }
  ShowToolButton();

  END_LOG;
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::iMainImageKeyUp(TObject *Sender, WORD Key, TShiftState Shift)
{
  BEGIN_LOG("");

  switch(imageAssembleItem)
  {
    case I_SETWORKAREA:
      workAreaMenu->iMainImageKeyUp(Sender, Key);
      break;
    default:
      END_LOG;
      return;
  }

  END_LOG;
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::EvalRotatedPoint()
{
  BEGIN_LOG("");

  TPException ec = EC_NONE;
  Extended sx[4], sy[4];
  TPRotation *Trans = NULL;
  TPoint expanded_end_point = TPoint(window.s.x + window.size.x * expansionRatio,
                                     window.s.y + window.size.y * expansionRatio);

	if ((Trans = new TPRotation) == NULL)  { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
  Trans->translation(-expandedCentralPoint.x, -expandedCentralPoint.y);
  Trans->rotation(rotateAngle);



  Trans->convert(window.s.x, window.s.y, sx[0], sy[0]);
	sx[0] = sx[0] + rotatedCentralPoint.x;
	sy[0] = sy[0] + rotatedCentralPoint.y;
	Trans->convert(window.s.x, expanded_end_point.y, sx[1], sy[1]);
	sx[1] = sx[1] + rotatedCentralPoint.x;
	sy[1] = sy[1] + rotatedCentralPoint.y;
	Trans->convert(expanded_end_point.x, window.s.y, sx[2], sy[2]);
	sx[2] = sx[2] + rotatedCentralPoint.x;
	sy[2] = sy[2] + rotatedCentralPoint.y;
	Trans->convert(expanded_end_point.x, expanded_end_point.y, sx[3], sy[3]);
	sx[3] = sx[3] + rotatedCentralPoint.x;
	sy[3] = sy[3] + rotatedCentralPoint.y;
	max_x = (int)sx[0]; min_x = (int)max_x;
	max_y = (int)sy[0]; min_y = (int)max_y;

	for (int i = 0; i <= 3; i++) {
		if (min_x >= sx[i]) min_x = sx[i];
		else if (max_x <= sx[i]) max_x = sx[i];
		if (min_y >= sy[i]) min_y = sy[i];
		else if (max_y <= sy[i]) max_y = sy[i];
	}

  rotatedWindowSize = TPoint(max_x - min_x, max_y - min_y);

  if (Trans) delete Trans;
  END_LOG;
  return;
fail:
  if (Trans) delete Trans;
	EXCEPTION_MESSAGE_OK(ec);
  END_LOG;
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::InitWindow()
{
  BEGIN_LOG("");

	TCursor OldCursor;
	TPItemImage *Image = MainImageForm->iMainImage;
  TPException ec = EC_NONE;

	OldCursor      = Screen->Cursor;
	Screen->Cursor = crHourGlass;


	if ((window.Bitmap = new TUnionBitmap) == NULL) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; } // convert by celberus
	if ((window.Mask = new TUnionBitmap) == NULL) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; } // convert by celberus
	if ((window.Back = new TUnionBitmap) == NULL) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; } // convert by celberus

  window.s = TPoint(MainImageForm->WorkArea->Range.left, MainImageForm->WorkArea->Range.top);
  window.e = TPoint(MainImageForm->WorkArea->Range.right, MainImageForm->WorkArea->Range.bottom);
  window.size = TPoint(window.e.x - window.s.x, window.e.y - window.s.y);

	Screen->Cursor = OldCursor;

  END_LOG;
	return;

fail:
	Screen->Cursor = OldCursor;
	if (window.Bitmap) { delete window.Bitmap; window.Bitmap = 0; }
	if (window.Mask) { delete window.Mask; window.Mask = 0; }
	if (window.Back) { delete window.Back; window.Back = 0; }
	EXCEPTION_MESSAGE_OK(ec);
  END_LOG;
}
//-----------------------------------------------------------------------------
bool __fastcall TImageAssembleForm::CreateWindowBitmap(int width, int height)
{
  BEGIN_LOG("");

	TPItemImage *Image = MainImageForm->iMainImage;
  TPException ec = EC_NONE;

  TCursor OldCursor;
	OldCursor = Screen->Cursor;
	Screen->Cursor = crHourGlass;

	RGBQUAD	rgb[256];

  if (Image->uBitmap->BitsPerPixel==8) {
    MainImageForm->Palette->ToRGBQUAD(rgb, 256);
    if (!window.Bitmap->Create(width, height, 8, rgb)) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
    if (!window.Mask->Create(width, height, 8, rgb)) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
    window.Bitmap->BackgroundColor = PALETTEINDEX(0x00);
    window.Mask->BackgroundColor = PALETTEINDEX(0xFF);
  } else {
    if (!window.Bitmap->Create(width, height, 24)) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
    if (!window.Mask->Create(width, height, 1)) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
    window.Bitmap->BackgroundColor = 0;
    window.Mask->BackgroundColor = 0xFFFFFF;
  }

	Screen->Cursor = OldCursor;
  END_LOG;
	return true;
fail:
  DeleteWindowBitmap();
	Screen->Cursor = OldCursor;
	EXCEPTION_MESSAGE_OK(ec);
  END_LOG;
  return false;
}   //OK
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::DeleteWindowBitmap()
{
	TPItemImage *Image = MainImageForm->iMainImage;
	if (window.Bitmap) { delete window.Bitmap; window.Bitmap = NULL; }
	if (window.Mask) { delete window.Mask; window.Mask = NULL; }
	if (window.Back) { delete window.Back; window.Back = 0; }
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::MakeRotateImage()
{
  BEGIN_LOG("");

  TPItemImage *Image = MainImageForm->iMainImage;                               //TPImage-TPLayerImage-TPItemImage
	TPRotation *Trans = NULL;
	Extended dx, dy, px, py;
	int LX, LY, xx, yy, i, j;
  Byte *IP, *AP, *MP;
  int nuBitmapAccNum = -1, nuBitmapOldLine = -1;
  int bytes_per_pixel = Image->uBitmap->BitsPerPixel / 8;
	COLORREF bgc;
  TPException ec = EC_NONE;

  WAItr *waItr = NULL;
  WindowItr *windowItr_local = NULL;

  LX = expandedWindowSize.x / 2;                                               //TWindowData-window,MoveCopyRect,bendwindow
	LY = expandedWindowSize.y / 2;

	if ((Trans = new TPRotation) == NULL)  { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }


  Trans->translation(-rotatedCentralPoint.x, -rotatedCentralPoint.y);
  Trans->rotation(-rotateAngle);

  if (Image->uBitmap->BitsPerPixel==8) {
    waItr = (WAItr *) new WAItr_8(Image->uBitmap, Image->LayerMask, MainImageForm->WorkArea, &window);
    windowItr_local = (WindowItr *) new WindowItr_8(&window);
  }	else {
    waItr = (WAItr *) new WAItr_24(Image->uBitmap, Image->LayerMask, MainImageForm->WorkArea, &window);
    windowItr_local = (WindowItr *) new WindowItr_24(&window);
    bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
    waItr->setBGColor(bgc);
    windowItr_local->setBGColor(bgc);
  }

  MainImageForm->UndoSave(UK_ALL, Rect(min_x, min_y, max_x, max_y));

  waItr->startScanLine();
  windowItr_local->startScanLine();

  StatusProgress->Maximum = rotatedWindowSize.y;
  for (i=0; i<rotatedWindowSize.y; i++) {
    StatusProgress->Position = i;
    if(min_y + i < 0) continue;

    windowItr_local->getScanLine(i, 0, rotatedWindowSize.x + 1);

    for (j=0; j<rotatedWindowSize.x; j++)
    {
      if(min_x + j < 0) continue;

      Trans->convert(j+min_x, i+min_y, dx, dy);
      py = dy+LY;
      yy = floor(py);
      if (yy>=0 && yy<expandedWindowSize.y) {
        yy = yy / expansionRatio;
        px = dx+LX;
        xx = floor(px);
        if (xx>=0 && xx<expandedWindowSize.x) {
          xx = xx / expansionRatio;
          waItr->getScanLine(yy, xx, 1);
          if (waItr->isInArea(xx)) {
            windowItr_local->copyPixel(j, waItr->getPixelPointer(xx));
            continue;
          }
        }
      }
      windowItr_local->setToBlank(j);
    }
    windowItr_local->putScanLine(i, 0, rotatedWindowSize.x + 1);
  }
  StatusProgress->End();


  waItr->stopScanLine();
  windowItr_local->stopScanLine();

	if (Trans) delete Trans;
  if(waItr) delete waItr;
  if(windowItr_local) delete windowItr_local;
  END_LOG;
	return;
fail:
  waItr->stopScanLine();
	if (Trans) delete Trans;
  if(waItr) delete waItr;
  if(windowItr_local) delete windowItr_local;

	EXCEPTION_MESSAGE_OK(ec);
  END_LOG;
}   //OK
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::PutRotateImage()
{
  BEGIN_LOG("");

  TPItemImage *Image = MainImageForm->iMainImage;
  Image->uBitmap->Copy(min_x, min_y, rotatedWindowSize.x,
    rotatedWindowSize.y, window.Mask, 0, 0, SRCAND, StatusProgress);
  Image->uBitmap->Copy(min_x, min_y, rotatedWindowSize.x,
    rotatedWindowSize.y, window.Bitmap, 0, 0, SRCPAINT, StatusProgress);

  END_LOG;
}
//-----------------------------------------------------------------------------
void __fastcall TImageAssembleForm::EraseWorkAreaIn()
{
  BEGIN_LOG("");

	int i, j;
	Byte *IP, *WP, *LP, wm;
	COLORREF color;
	TPItemImage *Image = MainImageForm->iMainImage;
  WAItr *waItr = NULL;
  TPException ec = EC_NONE;

  if (Image->uBitmap->BitsPerPixel==8) {
    waItr = (WAItr *) new WAItr_8(Image->uBitmap, Image->LayerMask, MainImageForm->WorkArea, &window);
  }	else {
    waItr = (WAItr *) new WAItr_24(Image->uBitmap, Image->LayerMask, MainImageForm->WorkArea, &window);
    color = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
    waItr->setBGColor(color);
  }

  if (!waItr->startScanLine()) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
  StatusProgress->Maximum = window.size.y;
  for (i=0; i<window.size.y; i++) {
    StatusProgress->Position = i;
    waItr->getScanLine(i);
    for (j=0; j<window.size.x; j++) {		//////adsfadsf_for//////adsfadsf_Variable_Checked
      if (waItr->isInArea(j)) {
         waItr->erasePixel(j);
      }
    }
    waItr->putScanLine(i);
  }
  StatusProgress->End();
  waItr->stopScanLine();
  Image->InitBackGround(0x02);     /* TODO : ÀÌ°Ç ¿ÖÇϴ°ɱî */

  ResetBitmapRegion();
  if(waItr) delete waItr;
  //if (rsiAutoRepeat) { delete []rsiAutoRepeat; rsiAutoRepeat = NULL; }
  END_LOG;
	return;
fail:
  waItr->stopScanLine();
  if(waItr) delete waItr;
	EXCEPTION_MESSAGE_OK(ec);
  END_LOG;
} // OK
//-----------------------------------------------------------------------------
void __fastcall TLattice::Init(TPoint left_top, TPoint right_top, TPoint right_bottom, TPoint left_bottom)
{
  BEGIN_LOG("");

  Clear();

  pointMap[left_top] = left_top;
  pointMap[right_top] = right_top;
  pointMap[right_bottom] = right_bottom;
  pointMap[left_bottom] = left_bottom;

  initWorkArea = Rect(left_top.x, left_top.y, right_bottom.x, right_bottom.y);

  Tetragon rect;
  rect.leftTop     = left_top;
  rect.rightTop    = right_top;
  rect.rightBottom = right_bottom;
  rect.leftBottom  = left_bottom;

  transformedRectArea.push_back(rect);

  width = 1;
  height = 1;

  END_LOG;
}
//-----------------------------------------------------------------------------
void __fastcall TLattice::InitByKeyOfPoint()
{
  BEGIN_LOG("");

  list<Tetragon>::iterator rect_iter;

  for(rect_iter = transformedRectArea.begin() ; rect_iter != transformedRectArea.end() ; ++rect_iter)
  {
    pointMap[rect_iter->leftTop] = rect_iter->leftTop;
    pointMap[rect_iter->rightTop] = rect_iter->rightTop;
    pointMap[rect_iter->leftBottom] = rect_iter->leftBottom;
    pointMap[rect_iter->rightBottom] = rect_iter->rightBottom;
  }

  END_LOG;
}
//-----------------------------------------------------------------------------
void __fastcall TLattice::Clear()
{
  BEGIN_LOG("");

  pointMap.clear();
  transformedRectArea.clear();

  END_LOG;
}
//-----------------------------------------------------------------------------
///grid±â´É¿¡¼­ ¼¼·Î·Î gridÃß°¡¸¦ ÇßÀ»¶§ È£ÃâµÇ´Â ÇÔ¼ö
/**
list transformedRectArea¿¡ µé¾îÀÖ´Â »ç°¢Çü ÇϳªÇϳª¿¡ ´ëÇؼ­ Ãß°¡µÈ grid¿¡ ÀÇÇØ
ÂÉ°³Áö´Â °ÍÀÌ ÀÖ´ÂÁö¸¦ »ìÇÉ´Ù. ÂÉ°³Áö´Â°ÍÀ̸é list¿¡¼­ »ç°¢ÇüÀ» »èÁ¦ÇÏ°í
ºÐÇÒµÈ µÎ °³ÀÇ »ç°¢ÇüÀ» »õ·Î list¿¡ ³Ö´Â´Ù.
*/
void __fastcall TLattice::SplitAreaByVerticalLine(int x_line)
{
  BEGIN_LOG("");

  list<Tetragon>::iterator rect_iter;

  for(rect_iter = transformedRectArea.begin() ; rect_iter != transformedRectArea.end() ; ++rect_iter)
  {
    if(rect_iter->leftTop.x < x_line && rect_iter->rightBottom.x > x_line)
    {
      TPoint left_top1    (rect_iter->leftTop.x   , rect_iter->leftTop.y);
      TPoint right_top1   (x_line                 , rect_iter->rightTop.y);
      TPoint right_bottom1(x_line                 , rect_iter->rightBottom.y);
      TPoint left_bottom1 (rect_iter->leftBottom.x, rect_iter->leftBottom.y);

      TPoint left_top2    (x_line                  , rect_iter->leftTop.y);
      TPoint right_top2   (rect_iter->rightTop.x   , rect_iter->rightTop.y);
      TPoint right_bottom2(rect_iter->rightBottom.x, rect_iter->rightBottom.y);
      TPoint left_bottom2 (x_line                  , rect_iter->leftBottom.y);

      pointMap[left_top2] = left_top2;
      pointMap[left_bottom2] = left_bottom2;


      Tetragon rect1, rect2;
      rect1.leftTop     = left_top1;
      rect1.rightTop    = right_top1;
      rect1.rightBottom = right_bottom1;
      rect1.leftBottom  = left_bottom1;

      rect2.leftTop     = left_top2;
      rect2.rightTop    = right_top2;
      rect2.rightBottom = right_bottom2;
      rect2.leftBottom  = left_bottom2;

      rect_iter = transformedRectArea.erase(rect_iter);

      transformedRectArea.insert(rect_iter, rect1);
      transformedRectArea.insert(rect_iter, rect2);

      --rect_iter;
    }
  }

  ++width;

  END_LOG;
}
//-----------------------------------------------------------------------------
///grid±â´É¿¡¼­ °¡·Î·Î gridÃß°¡¸¦ ÇßÀ»¶§ È£ÃâµÇ´Â ÇÔ¼ö
/**
list transformedRectArea¿¡ µé¾îÀÖ´Â »ç°¢Çü ÇϳªÇϳª¿¡ ´ëÇؼ­ Ãß°¡µÈ grid¿¡ ÀÇÇØ
ÂÉ°³Áö´Â °ÍÀÌ ÀÖ´ÂÁö¸¦ »ìÇÉ´Ù. ÂÉ°³Áö´Â°ÍÀ̸é list¿¡¼­ »ç°¢ÇüÀ» »èÁ¦ÇÏ°í
ºÐÇÒµÈ µÎ °³ÀÇ »ç°¢ÇüÀ» »õ·Î list¿¡ ³Ö´Â´Ù.
*/
void __fastcall TLattice::SplitAreaByHorizontalLine(int y_line)
{
  BEGIN_LOG("");

  list<Tetragon>::iterator rect_iter;

  for(rect_iter = transformedRectArea.begin() ; rect_iter != transformedRectArea.end() ; ++rect_iter)
  {
    if(rect_iter->leftTop.y < y_line && rect_iter->rightBottom.y > y_line)
    {
      TPoint left_top1    (rect_iter->leftTop.x    , rect_iter->leftTop.y);
      TPoint right_top1   (rect_iter->rightTop.x   , rect_iter->rightTop.y);
      TPoint right_bottom1(rect_iter->rightBottom.x, y_line);
      TPoint left_bottom1 (rect_iter->leftBottom.x , y_line);

      TPoint left_top2    (rect_iter->leftTop.x    , y_line);
      TPoint right_top2   (rect_iter->rightTop.x   , y_line);
      TPoint right_bottom2(rect_iter->rightBottom.x, rect_iter->rightBottom.y);
      TPoint left_bottom2 (rect_iter->leftBottom.x , rect_iter->leftBottom.y);

      pointMap[left_top2] = left_top2;
      pointMap[right_top2] = right_top2;


      Tetragon rect1, rect2;
      rect1.leftTop     = left_top1;
      rect1.rightTop    = right_top1;
      rect1.rightBottom = right_bottom1;
      rect1.leftBottom  = left_bottom1;

      rect2.leftTop     = left_top2;
      rect2.rightTop    = right_top2;
      rect2.rightBottom = right_bottom2;
      rect2.leftBottom  = left_bottom2;

      rect_iter = transformedRectArea.erase(rect_iter);

      transformedRectArea.insert(rect_iter, rect1);
      advance(rect_iter, width-1);
      transformedRectArea.insert(rect_iter, rect2);
      advance(rect_iter, -width-1);
    }
  }

  ++height;

  END_LOG;
}
//-----------------------------------------------------------------------------
///grid±â´É¿¡¼­ grid¸¦ º¯ÇüÇϱâÀ§ÇØ ¾î¶² Á¡À» Á¶ÀÛÇÏ·Á°í (X, Y)¸¦ clickÇßÀ»¶§ °Å±â¿¡ ÇØ´çÇÏ´Â Á¡ÀÇ key¸¦ ¹Ýȯ&¼³Á¤
TPoint __fastcall TLattice::GetKeyOfSelectedPoint(int X, int Y, bool is_setting_also)
{
  BEGIN_LOG("");

	map<TPoint, TPoint, TPointLess>::iterator point_iter = NULL;
	for(point_iter = pointMap.begin() ; point_iter != pointMap.end() ; ++point_iter)
  {
    if(abs(X - point_iter->second.x) < 4 && abs(Y - point_iter->second.y) < 4)
		{
      END_LOG;
      return keyOfSelectedPoint = point_iter->first;
    }
  }

  END_LOG;
  return keyOfSelectedPoint = TPoint(-1, -1);
}
//-----------------------------------------------------------------------------
///grid±â´É¿¡¼­ À¯Àú°¡ ¼±ÅÃÇÑ Á¡À» (X, Y)·Î ¼¼ÆÃÇØÁÜ
void __fastcall TLattice::SetPointOfSelectedPoint(int X, int Y)
{
  BEGIN_LOG("");

  if(keyOfSelectedPoint.x != -1 && keyOfSelectedPoint.y != -1)
  {
    pointMap[keyOfSelectedPoint].x = X;
    pointMap[keyOfSelectedPoint].y = Y;
  }

  END_LOG;
}
//-----------------------------------------------------------------------------
///grid±â´É¿¡¼­ grid¸¦ ÀÌ·ç´Â »ç°¢ÇüµéÀ» ±×·ÁÁÜ
/**
list transformedRectArea¿¡¼­ »ç°¢ÇüµéÀ» Çϳª¾¿ ²¨³½´Ù. ¿©±â¼­ »ç°¢Çü¿¡ µé¾îÀÖ´Â ³× °³ÀÇ
Á¡Àº ½ÇÁ¦ »ç°¢ÇüÀÇ ²ÀÁöÁ¡ÀÌ µÉ ³× Á¡ÀÌ ¾Æ´Ï´Ù. ÀÌ Á¡µéÀº pointMap¿¡¼­ ½ÇÁ¦ »ç°¢ÇüÀÇ
²ÀÁöÁ¡À» ¾ò±âÀ§ÇÑ key°¡ µÈ´Ù. ÀÌ key·Î pointMap¿¡¼­ ½ÇÁ¦ »ç°¢ÇüÀÇ ³× ²ÀÁöÁ¡À» ¾ò°í
ÇöÀç user°¡ º¸°íÀÖ´Â È­¸éÀÇ È®´ë ºñÀ²¿¡ µû¶ó È­¸é¿¡ ½ÇÁ¦ ±×¸± point¸¦ ¾ò¾î¼­
»ç°¢ÇüÀÇ ³× º¯À» ¾ò´Â´Ù. ÀÌ º¯µéÀ» lineSet¿¡ ´Ù ³Ö´Â ÀÛ¾÷À» ÇÏ°í ³ªÁß¿¡ lineSet¿¡
ÀÖ´Â lineµéÀ» ±×·Á¼­ Áߺ¹¾øÀÌ ¸ðµç grid¸¦ ´Ù ±×¸±¼ö ÀÖµµ·Ï ÇÑ´Ù.
*/
void __fastcall TLattice::DrawTetraLine(HDC dcDst)
{
  BEGIN_LOG("");

  TPoint view_point[4];
  set<pair<TPoint, TPoint>, TPointPairLess> line_set;

  TPItemImage* Image = MainImageForm->iMainImage;
  float ratio = (float)Image->ZoomIn / Image->ZoomOut;
  int nXOffset = -Image->PositionX * ratio;
  int nYOffset = -Image->PositionY * ratio;

  int old_mode = GetROP2(dcDst);
  SetROP2(dcDst, R2_NOT);

  for(list<Tetragon>::iterator i = transformedRectArea.begin() ; i != transformedRectArea.end() ; ++i)
  {
    view_point[0].x = nXOffset + (pointMap[i->leftTop].x * ratio);
    view_point[0].y = nYOffset + (pointMap[i->leftTop].y * ratio);
    view_point[1].x = nXOffset + (pointMap[i->rightTop].x * ratio);
    view_point[1].y = nYOffset + (pointMap[i->rightTop].y * ratio);
    view_point[2].x = nXOffset + (pointMap[i->rightBottom].x * ratio);
    view_point[2].y = nYOffset + (pointMap[i->rightBottom].y * ratio);
    view_point[3].x = nXOffset + (pointMap[i->leftBottom].x * ratio);
    view_point[3].y = nYOffset + (pointMap[i->leftBottom].y * ratio);

    line_set.insert(make_pair(view_point[0], view_point[1]));
    line_set.insert(make_pair(view_point[1], view_point[2]));
    line_set.insert(make_pair(view_point[3], view_point[2]));
    line_set.insert(make_pair(view_point[0], view_point[3]));
  }
	for(set< pair<TPoint, TPoint>, TPointPairLess >::iterator i = line_set.begin() ; i != line_set.end() ; ++i)
  {
    view_point[0] = i->first;
    view_point[1] = i->second;
    Polyline(dcDst, view_point, 2);
  }

  SetROP2(dcDst, old_mode);

  END_LOG;
}
//---------------------------------------------------------------------------
///grid±â´É¿¡¼­ imageº¯ÇüÀ» ÇϱâÀü¿¡ ¿øº»À» ÀúÀåÇÏ´Â ÇÔ¼ö
/**
pull_image_repro()¿¡¼­ imageº¯ÇüÀ» ÇϱâÀü¿¡ ¹Ì¸® ¿øº»À» ÀúÀåÇÏ´Â ÇÔ¼ö.
pull_image_repro()¿¡¼­´Â transformedRectAreaÀÇ ÇϳªÀÇ »ç°¢Çü¿¡ ´ëÇؼ­¸¸
imageº¯ÇüÀ» ÇÏÁö¸¸ º¯ÇüÀ» Çϸ鼭 ´Ù¸¥ »ç°¢ÇüÀÇ ¿µ¿ª¿¡ ´ëÇؼ­µµ ¿µÇâÀ»
¹ÌÄ¥¼ö ÀÖÀ¸¹Ç·Î ¿©±â¼­ ¸ÕÀú ¸ðµç »ç°¢Çü¿¡ ´ëÇؼ­ ¿øº»À» ÀúÀåÇسõ´Â´Ù.
transformedRectArea¿¡¼­ °¢ »ç°¢Çü¸¶´ÙÀÇ ±¸¿ª¿¡ ÇØ´çÇÏ´Â ¿øº»À» area¿¡ ÀúÀåÇÏ°í
±×°ÍÀ» vector captured_rect_area¿¡ ÀúÀåÇÏ°í ¹ÝȯÇÑ´Ù.
*/
vector<TUnionBitmap*> __fastcall TLattice::CaptureRectArea()
{
  BEGIN_LOG("");

  int i;
  TPException ec = EC_NONE;
  list<Tetragon>::iterator tetra_iter;

  vector<TUnionBitmap*> captured_rect_area;
  TUnionBitmap* area;

  TPItemImage *Image = MainImageForm->iMainImage;

  for(tetra_iter = transformedRectArea.begin(), i=0 ;
      tetra_iter != transformedRectArea.end() ;
      ++tetra_iter, ++i)
  {
    TPlaneVertex pv;
    pv.Create(pointMap[tetra_iter->leftTop]    , pointMap[tetra_iter->rightTop],
              pointMap[tetra_iter->rightBottom], pointMap[tetra_iter->leftBottom]);

    captured_rect_area.push_back(area = new TUnionBitmap);

    int width = tetra_iter->rightTop.x - tetra_iter->leftTop.x;
    int height = tetra_iter->rightBottom.y - tetra_iter->leftTop.y;

    if (Image->uBitmap->BitsPerPixel==8) {
      RGBQUAD rgb[256];
      Image->uBitmap->GetColors(0, 256, rgb);
      if(!area->Create(width, height, 8, rgb)) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
      area->Copy(0, 0, width, height, Image->uBitmap, tetra_iter->leftTop.x, tetra_iter->leftTop.y, SRCCOPY);
    }
    else
    {
      if(!area->Create(width, height, 24)) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
      area->Copy(0, 0, width, height, Image->uBitmap, tetra_iter->leftTop.x, tetra_iter->leftTop.y, SRCCOPY);
    }
  }

  END_LOG;
  return captured_rect_area;

fail :
  if(area) delete area;
  EXCEPTION_MESSAGE_OK(ec);
  END_LOG;
  return captured_rect_area;
}
//---------------------------------------------------------------------------
///ºÎÁ¤ÇüÀÎ »ç°¢ÇüÀÇ ³× º¯Áß ÇÑ º¯ÀÌ µÇ´Â Á÷¼±ÀÇ ¹æÁ¤½Ä ax+by+c=0 À» ±¸ÇÏ´Â ÇÔ¼ö
/**
ºÎÁ¤ÇüÀÎ »ç°¢ÇüÀ» ÀÌ·ç´Â ³× Á¡ÀÌ Àִµ¥ ¿©±â¼­ pos1, pos2 ´Â ±× ÁßÀÇ µÎ Á¡À» »ó¡ÇÑ´Ù.
pos1¿Í pos2¸¦ ÀÌÀ½À¸·Î¼­ »ý±â´Â Á÷¼± ax + by + c = 0 ÀÇ a, b, c¸¦ ±¸Çؼ­ ÀúÀåÇÔ.
*/
void __fastcall TLattice::repro_dis(double *a, double *b, double *c, double *sqr, int i,
                                             TPoint pos1, TPoint pos2)
{
  BEGIN_LOG("");

  a[i]   = pos1.y - pos2.y;
  b[i]   = pos2.x - pos1.x;
  c[i]   = pos1.x * pos2.y - pos2.x * pos1.y;
  sqr[i] = sqrt(a[i] * a[i] + b[i] * b[i]);
  if(sqr[i]==0){sqr[i]=1; c[i]=pos1.x;}

  END_LOG;
}
//---------------------------------------------------------------------------
///ºÎÁ¤ÇüÀÎ »ç°¢ÇüÀ» ÀÛ¾÷±¸¿ªÀ¸·Î imageº¯È¯ÇÏ´Â ÇÔ¼ö
/**
¸ÕÀú area¿¡´Â »ç°¢ÇüÀÇ ³»¿ëÀÌ º¹»çµÇ¾îÀÖÀ¸¸ç tetra_area´Â ±× »ç°¢ÇüÀÇ ³× Á¡À» ±¸ÇÒ ¼ö ÀÖ´Â key°¡ ÀÖ´Ù.
window¿¡ ÀÛ¾÷±¸¿ªÀÇ ³× Á¡À» ÀÔ·ÂÇÏ¿© ÀÛ¾÷±¸¿ªÀ» ÀÎ½Ä ½ÃÅ°°í
pv¿¡ »ç°¢ÇüÀÇ ³× Á¡À» ÀÔ·ÂÇÏ¿© »ç°¢ÇüÀÇ ¸ð¾çÀ» ÀνĽÃŲ´Ù.
pvÀÇ Á¤º¸¸¦ ÅëÇØ »ç°¢Çü¿¡ ¹ÙÅÁ»öÀ» Ä¥ÇÑ´Ù.
repro_dis()¸¦ ÅëÇØ »ç°¢ÇüÀÇ ³× º¯À» ¸¸µå´Â Á÷¼±ÀÇ ¹æÁ¤½ÄµéÀ» ±¸ÇÑ´Ù.
±× ÈÄ´Â 3¹øÀÇ ºÐ±â°¡ Àִµ¥ maskarea°¡ Àֳľø³Ä, 256Ä÷¯³Ä ¾Æ´Ï³Ä, º¸È£»öÀÌ ÀÖ´À³Ä ¾ø´À³Ä
¿¡ µû¶ó ÀÛ¾÷ÀÌ ³ª´©¾îÁø´Ù. ÇÏÁö¸¸ ±âº»ÀûÀ¸·Î ÇÏ´Â µ¿ÀÛÀº °ÅÀÇ ºñ½ÁÇÏ´Ù.
ÀÛ¾÷±¸¿ª³»ÀÇ Á¡ÀÎ (x, y)°¡ ÀÛ¾÷±¸¿ª ³»¿¡¼­ ¾î´ÀÁ¤µµÀÇ À§Ä¡¿¡ ÀÖ³ª °Å¸®ºñ¸¦ ÆľÇÇÑ ÈÄ
repro_dis()¸¦ ÅëÇØ ±¸Çß´ø Á÷¼±µé°ú ±× Á¤µµÀÇ °Å¸®ºñ¸¦ °®´Â Á¡À» ±¸ÇÑ´Ù.
±× °Å¸®ºñ¿¡ µû¶ó area¿øº»¿¡¼­ ¾î´À pixelÀÇ »ö±òÀ» µû¶ó¾ßÇÒÁö¸¦ °áÁ¤ÇÏ¿© »öÀ» Ä¥ÇÑ´Ù.
*/
void __fastcall TLattice::pull_image_repro(Tetragon tetra_area, TUnionBitmap* area)
{
  BEGIN_LOG("");

///*      //BeConverted by linuxjun for Undo_Method
  int x, y, nx, ny, winlx, winly;
  double k, l, lx1, lx2, ly1, ly2;
  double a[4], b[4], c[4], sqr[4];
  Byte *IP, *AP, *MP;
  bool undoSw = false;
  TPlaneVertex pv;
  TPItemImage *Image = MainImageForm->iMainImage;
  THistoryData *ud;
  TPException ec = EC_NONE;

  pv.Create(pointMap[tetra_area.leftTop]    , pointMap[tetra_area.rightTop],
            pointMap[tetra_area.rightBottom], pointMap[tetra_area.leftBottom]);

  WORD bits_per_pixel = Image->uBitmap->BitsPerPixel;
  WORD bytes_per_pixel = bits_per_pixel / 8;
  COLORREF bg_color_ref = PaletteForm->DIB256Palette->GetBGCOLORREF(bits_per_pixel);


  if (Image->uBitmap->StartScanLine () == false) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
  // MMF : [CheckScanLine °ü·Ã] - by monkman (2006.07.11)
  if (area->StartScanLine() == false) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }

  repro_dis(a, b, c, sqr, 0, pointMap[tetra_area.leftTop]    , pointMap[tetra_area.rightTop]);
  repro_dis(a, b, c, sqr, 1, pointMap[tetra_area.rightBottom], pointMap[tetra_area.leftBottom]);
  repro_dis(a, b, c, sqr, 2, pointMap[tetra_area.leftBottom] , pointMap[tetra_area.leftTop]);
  repro_dis(a, b, c, sqr, 3, pointMap[tetra_area.rightTop]   , pointMap[tetra_area.rightBottom]);

  winlx = tetra_area.rightTop.x - tetra_area.leftTop.x;
  winly = tetra_area.leftBottom.y - tetra_area.leftTop.y;



  if (MainImageForm->MaskArea) {
    if (Image->Mask->StartScanLine() == false) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
    // MMF : [CheckScanLine °ü·Ã] - by monkman (2006.07.11)
	  if (Image->uBitmap->BitsPerPixel==8) {
		  if (MainImageForm->Protect) {
  			for (y = pv.start.y; y < pv.end.y; y++) {
    			if (y < Image->uBitmap->Height) {
      			IP = Image->uBitmap->GetScanLine(y)    + pv.start.x;
      			MP = Image->Mask->GetScanLine(y)      + pv.start.x;
      			for (x = pv.start.x; x < pv.end.x; x++, IP++, MP++) {
        			if (x < Image->uBitmap->Width) {
   	  					if (MainImageForm->Palette->ColorData[*IP]->Protect == 0 && (*MP == 0)) {
          				if (pv.Check(x, y)) {
            				ly1 = fabs(a[0] * x + b[0] * y + c[0]) / sqr[0];
		            		ly2 = fabs(a[1] * x + b[1] * y + c[1]) / sqr[1];
  		          		lx1 = fabs(a[2] * x + b[2] * y + c[2]) / sqr[2];
    		        		lx2 = fabs(a[3] * x + b[3] * y + c[3]) / sqr[3];
                    if(lx1==0 && lx2==0) lx2=1;
                    if(ly1==0 && ly2==0) ly2=1;

      		      		nx  = winlx * lx1 / (lx1 + lx2);
        		    		ny  = winly * ly1 / (ly1 + ly2);

                    if(nx < 0) nx = 0;
                    if(ny < 0) ny = 0;
                    if(nx >= winlx) nx = winlx-1;
                    if(ny >= winly) ny = winly-1;
                    memcpy(IP, area->GetScanLine(ny) + bytes_per_pixel * nx, bytes_per_pixel);

          				}
	            	}
	  	      	}
  	  	  	}
    	  		Image->uBitmap->PutScanLine(y, pv.start.x, pv.end.x-pv.start.x +1);
    			}
	  		}
		  }
      else {
  			for (y = pv.start.y; y < pv.end.y; y++) {
  	  		if (y < Image->uBitmap->Height) {
      			IP = Image->uBitmap->GetScanLine(y)    + pv.start.x;
      			MP = Image->Mask->GetScanLine(y)      + pv.start.x;
      			for (x = pv.start.x; x < pv.end.x; x++, IP++, MP++) {
        			if (x < Image->uBitmap->Width) {
   	  					if (*MP == 0) {
          				if (pv.Check(x, y)) {
  	         				ly1 = fabs(a[0] * x + b[0] * y + c[0]) / sqr[0];
	  	         			ly2 = fabs(a[1] * x + b[1] * y + c[1]) / sqr[1];
		  	         		lx1 = fabs(a[2] * x + b[2] * y + c[2]) / sqr[2];
  		  	       		lx2 = fabs(a[3] * x + b[3] * y + c[3]) / sqr[3];
                    if(lx1==0 && lx2==0) lx2=1;
                    if(ly1==0 && ly2==0) ly2=1;

    		  	     		nx  = winlx * lx1 / (lx1 + lx2);
      		  	   		ny  = winly * ly1 / (ly1 + ly2);

                    if(nx < 0) nx = 0;
                    if(ny < 0) ny = 0;
                    if(nx >= winlx) nx = winlx-1;
                    if(ny >= winly) ny = winly-1;

                    memcpy(IP, area->GetScanLine(ny) + bytes_per_pixel * nx, bytes_per_pixel);

            			}
                }
		        	}
  		    	}
    		  	Image->uBitmap->PutScanLine(y, pv.start.x, pv.end.x-pv.start.x +1);
    			}
	      }
  		}
	  }
    else {
 			for (y = pv.start.y; y < pv.end.y; y++) {
 	  		if (y < Image->uBitmap->Height) {

   	  		IP = Image->uBitmap->GetScanLine(y)+3*pv.start.x;
     			for (x = pv.start.x; x < pv.end.x; x++, IP+=3) {
       			if (x < Image->uBitmap->Width) {
              if ((MP[x >> 3] & (0x80 >> (x & 7))) == 0) {
         				if (pv.Check(x, y)) {
         					ly1 = fabs(a[0] * x + b[0] * y + c[0]) / sqr[0];
		         			ly2 = fabs(a[1] * x + b[1] * y + c[1]) / sqr[1];
  		         		lx1 = fabs(a[2] * x + b[2] * y + c[2]) / sqr[2];
 	  		       		lx2 = fabs(a[3] * x + b[3] * y + c[3]) / sqr[3];
                  if(lx1==0 && lx2==0) lx2=1;
                  if(ly1==0 && ly2==0) ly2=1;

   	  		     		nx  = winlx * lx1 / (lx1 + lx2);
     	  		   		ny  = winly * ly1 / (ly1 + ly2);

                  if(nx < 0) nx = 0;
                  if(ny < 0) ny = 0;
                  if(nx >= winlx) nx = winlx-1;
                  if(ny >= winly) ny = winly-1;

                  memcpy(IP, area->GetScanLine(ny) + bytes_per_pixel * nx, bytes_per_pixel);

	           		}
              }
  	      	}
 	  	  	}
   	  		Image->uBitmap->PutScanLine(y, pv.start.x, pv.end.x-pv.start.x +1);
	   		}
  	  }
	  }
    Image->Mask->StopScanLine();
  }
  else {
		  if (MainImageForm->Protect) {
	 			for (y = pv.start.y; y < pv.end.y; y++) {
    			if (y < Image->uBitmap->Height) {
    	  		IP = Image->uBitmap->GetScanLine(y) + bytes_per_pixel * pv.start.x;
	     			for (x = pv.start.x; x < pv.end.x; ++x, IP += bytes_per_pixel) {
        			if (x < Image->uBitmap->Width) {
                if (MainImageForm->Palette->ColorData[*IP]->Protect == 0 && pv.Check(x, y)) {
                  //(x, y)¿Í »ç°¢ÇüÀÇ º¯À» ÀÌ·ç´Â °¢ Á÷¼±µé°úÀÇ °Å¸®¸¦ ±¸ÇÔ
                  ly1 = fabs(a[0] * x + b[0] * y + c[0]) / sqr[0];
                  ly2 = fabs(a[1] * x + b[1] * y + c[1]) / sqr[1];
                  lx1 = fabs(a[2] * x + b[2] * y + c[2]) / sqr[2];
                  lx2 = fabs(a[3] * x + b[3] * y + c[3]) / sqr[3];
                  if(lx1==0 && lx2==0) lx2=1;
                  if(ly1==0 && ly2==0) ly2=1;

                  //±× °Å¸®ºñ¸¦ ±¸ÇÔ
                  nx  = winlx * lx1 / (lx1 + lx2);
                  ny  = winly * ly1 / (ly1 + ly2);

                  if(nx < 0) nx = 0;
                  if(ny < 0) ny = 0;
                  if(nx >= winlx) nx = winlx-1;
                  if(ny >= winly) ny = winly-1;

                  memcpy(IP, area->GetScanLine(ny) + bytes_per_pixel * nx, bytes_per_pixel);
               	}
	  	      	}
  	  	  	}
    		  	Image->uBitmap->PutScanLine(y, pv.start.x, pv.end.x-pv.start.x +1);
    			}
	  		}
		  }
      else {
	 			for (y = pv.start.y; y < pv.end.y; y++) {
    			if (y < Image->uBitmap->Height) {
    	  		IP = Image->uBitmap->GetScanLine(y) + bytes_per_pixel * pv.start.x;
	     			for (x = pv.start.x; x < pv.end.x; ++x, IP += bytes_per_pixel) {
        			if (x < Image->uBitmap->Width) {
                if (pv.Check(x, y)) {
                  //(x, y)¿Í »ç°¢ÇüÀÇ º¯À» ÀÌ·ç´Â °¢ Á÷¼±µé°úÀÇ °Å¸®¸¦ ±¸ÇÔ
                  ly1 = fabs(a[0] * x + b[0] * y + c[0]) / sqr[0];
                  ly2 = fabs(a[1] * x + b[1] * y + c[1]) / sqr[1];
                  lx1 = fabs(a[2] * x + b[2] * y + c[2]) / sqr[2];
                  lx2 = fabs(a[3] * x + b[3] * y + c[3]) / sqr[3];
                  if(lx1==0 && lx2==0) lx2=1;
                  if(ly1==0 && ly2==0) ly2=1;

                  //±× °Å¸®ºñ¸¦ ±¸ÇÔ
                  nx  = winlx * lx1 / (lx1 + lx2);
                  ny  = winly * ly1 / (ly1 + ly2);

                  if(nx < 0) nx = 0;
                  if(ny < 0) ny = 0;
                  if(nx >= winlx) nx = winlx-1;
                  if(ny >= winly) ny = winly-1;

                  memcpy(IP, area->GetScanLine(ny) + bytes_per_pixel * nx, bytes_per_pixel);

	            	}
	  	      	}
  	  	  	}
    		  	Image->uBitmap->PutScanLine(y, pv.start.x, pv.end.x-pv.start.x +1);
    			}
	  		}
  		}
  }
  area->StopScanLine();
  Image->uBitmap->StopScanLine();
  ::RepaintImage();
  END_LOG;
  return;
fail :
  if (Image->Mask) {
    Image->Mask->StopScanLine();
  }
  Image->uBitmap->StopScanLine();
  EXCEPTION_MESSAGE_OK(ec);
  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TLattice::Run()
{
  BEGIN_LOG("");

  vector<TUnionBitmap*> captured_rect_area = CaptureRectArea();

  int i;
  list<Tetragon>::iterator tetra_iter;

  MainImageForm->UndoSave(UK_ALL, initWorkArea);

  for(tetra_iter = transformedRectArea.begin(), i=0 ;
      tetra_iter != transformedRectArea.end() ;
      ++tetra_iter, ++i)
  {
    pull_image_repro(*tetra_iter, captured_rect_area[i]);
    delete captured_rect_area[i];
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TImageAssembleForm::FormClose(TObject *Sender, TCloseAction &Action)
{
	BEGIN_LOG("");

	PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);

	END_LOG;
}
//---------------------------------------------------------------------------