#include "StdAfx.h"
#include "ObjComponentMgr.h"
#include "CStringFuc.h"
#include "GlobalDrawMgr.h"
#include "GlobalFunction.h"
#include "DrawSimpleShape.h"
#include "ObjCircle.h"
#include "WorkFileMgr.h"
#include "Propertie.h"
#include "PropertieMgr.h"
#include "AuthorityMgr.h"
#include "MeasureMgr.h"
#include "MsgBox.h"
#include "WorkCmdInvoker.h"
#include "LogMgr.h"
#include "Layer.h"
#include "ObjContainer.h"
#include "CommonFlowMgr.h"


#define GENG_3 (1.7320508075689)//根号3

CObjComponentMgr *gObjComponentMgr = new CObjComponentMgr;
CObjComponentMgr::CObjComponentMgr(void)
{
     m_CurSelIdx = -1;//当前选择的 索引值
     m_bDrawBase = false;//是否只绘制基准元件
     
     m_ArrayXcntZ = 35;//X 正方向阵列数量
     m_ArrayXcntF = 0;//X 负方向阵列数量
     m_ArrayYcntZ = 3;//Y 正方向阵列数量
     m_ArrayYcntF = 0;//Y 负方向阵列数量
     m_OffsetX = 5;//X 方向间隔
     m_OffsetY = 4.2;//Y 方向间隔

     m_RealOffsetX = m_OffsetX;//实际的X 方向间隔mm
     m_RealOffsetY = m_OffsetY;//实际的Y 方向间隔mm
     
      //限定元件的范围
     m_bUseArea = false;//是否使用限定范围
     
     m_bRectArea = false;//true 为矩形范围,false 为圆形范围
     m_AreaSize.w = 50;//矩形范围的尺寸
     m_AreaSize.h = 50;//矩形范围的尺寸
     m_AreaRadius = 150;//圆形范围的直径
     m_bDrawAllObj = true;//是否绘制所有的原件对象
     m_bDrawFillColor = false;//是否绘制填充
     m_NoSelColor = RGB_GREEN;
     m_SelColor = RGB_RED;
     m_ViewObjColor = RGB_YELLOW;
     m_ViewedObjColor = RGB_GREEN;//观察过的obj 颜色
     
     m_bNeedAllIn = true;//元件是否需要全部在范围内
     m_bAutoArray = false;//是否自动排列
     m_AutoArrayGap = 0.5;//自动排布间隔
     m_DefaultAng = 0;//默认角度

     m_CurSelObjIdx.x = 1;
     m_CurSelObjIdx.y = 1;

     m_bMoveTrackSDir = true;//S形轨迹移动的方向标志
     m_bShowRealObj = false;//显示obj 的实际位置

     m_bObjToCcdMode = false;//true 的时候选择obj 会移动到CCD 观察

     m_bDrawBindingObj = true;//是否绘制绑定的layer obj
}
CObjComponentMgr::~CObjComponentMgr(void)
{
}
#if 1
void CObjComponentMgr::WriteWorkFileExt(vector<CLab> &LabVec)
{
      //读取也要按照这个顺序
      LabVec.push_back(CLab(LAB_NULL,m_ArrayXcntZ));
      LabVec.push_back(CLab(LAB_NULL,m_ArrayXcntF));
      LabVec.push_back(CLab(LAB_NULL,m_ArrayYcntZ));
      LabVec.push_back(CLab(LAB_NULL,m_ArrayYcntF));
      LabVec.push_back(CLab(LAB_NULL,m_OffsetX));
      LabVec.push_back(CLab(LAB_NULL,m_OffsetY));
      LabVec.push_back(CLab(LAB_NULL,m_bUseArea));
      LabVec.push_back(CLab(LAB_NULL,m_bRectArea));
      LabVec.push_back(CLab(LAB_NULL,m_AreaBasePt.x));
      LabVec.push_back(CLab(LAB_NULL,m_AreaBasePt.y));
      LabVec.push_back(CLab(LAB_NULL,m_AreaSize.w));
      LabVec.push_back(CLab(LAB_NULL,m_AreaSize.h));
      LabVec.push_back(CLab(LAB_NULL,m_AreaRadius));
      LabVec.push_back(CLab(LAB_NULL,m_bAutoArray));
      LabVec.push_back(CLab(LAB_NULL,m_AutoArrayGap));
      LabVec.push_back(CLab(LAB_NULL,m_DefaultAng));
      //存储基准对象--------------------------------------------------------
      SaveBaseObj(LabVec);
}
void CObjComponentMgr::ReadWorkFile(CLabVecRang &LabVecRang)
{
      //删除所有
      DelAll();
      
      //读取顺序和类型要和写入相同
      int idx = LabVecRang.GetStart()+1;
      m_ArrayXcntZ = LabVecRang.GetInt(idx++);
      m_ArrayXcntF = LabVecRang.GetInt(idx++);
      m_ArrayYcntZ = LabVecRang.GetInt(idx++);
      m_ArrayYcntF = LabVecRang.GetInt(idx++);
      m_OffsetX = LabVecRang.GetDouble(idx++);
      m_OffsetY = LabVecRang.GetDouble(idx++);
      m_bUseArea = LabVecRang.GetBool(idx++);
      m_bRectArea = LabVecRang.GetBool(idx++);
      m_AreaBasePt.x = LabVecRang.GetDouble(idx++);
      m_AreaBasePt.y = LabVecRang.GetDouble(idx++);
      m_AreaSize.w = LabVecRang.GetDouble(idx++);
      m_AreaSize.h = LabVecRang.GetDouble(idx++);
      m_AreaRadius = LabVecRang.GetDouble(idx++);
      m_bAutoArray = LabVecRang.GetBool(idx++);
      m_AutoArrayGap = LabVecRang.GetDouble(idx++);
      m_DefaultAng = LabVecRang.GetDouble(idx++);
      //读取基准对象
      ReadBaseObj(LabVecRang);
      
      //重新阵列
      Array();
}
//保存基准对象
void CObjComponentMgr::SaveBaseObj(vector<CLab> &LabVec)
{
      vector<CObjComponent>::iterator iter = m_BaseComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_BaseComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
           LabVec.push_back(CLab(LAB_OBJ_START));//数据点开始
     
           Dbxy BasePt = (*iter).GetBasePt();
           DbSize size = (*iter).GetSize();
           LabVec.push_back(CLab(LAB_POINT_X,BasePt.x));
           LabVec.push_back(CLab(LAB_POINT_Y,BasePt.y));
           LabVec.push_back(CLab(LAB_SIZE_W,size.w));
           LabVec.push_back(CLab(LAB_SIZE_H,size.h));
           LabVec.push_back(CLab(LAB_OBJ_IS_CIRCLE,(*iter).IsCircle()));
           
           LabVec.push_back(CLab(LAB_OBJ_END));//数据点结束
      }
}
void CObjComponentMgr::ReadBaseObj(CLabVecRang &LabVecRang)
{
      //分离obj 对象---------------------------------------------------
      vector<CLabVecRang> LabVecRangVec;
      CWorkFileMgr WorkFileMgr;
      WorkFileMgr.SeparateStrVec(LabVecRang,LabVecRangVec,LAB_OBJ_START,LAB_OBJ_END);
      //处理每个obj ---------------------------------------------------
      if(!LabVecRangVec.empty())
      {
            vector<CLabVecRang>::iterator iter = LabVecRangVec.begin();
            vector<CLabVecRang>::iterator iter_end = LabVecRangVec.end();
            for(;iter!=iter_end;iter++)
            {
                  Dbxy BasePt;
                  DbSize size;
                  {//BasePt X 坐标
                          CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_POINT_X);
                          if(Lab.m_ValType != _TYPE_NULL)
                          {
                               BasePt.x = Lab.m_Double;
                          }
                  }
                  {//BasePt Y 坐标
                          CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_POINT_Y);
                          if(Lab.m_ValType != _TYPE_NULL)
                          {
                               BasePt.y = Lab.m_Double;
                          }
                  }
                  {//size w
                          CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_SIZE_W);
                          if(Lab.m_ValType != _TYPE_NULL)
                          {
                               size.w = Lab.m_Double;
                          }
                  }
                  {//size h
                          CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_SIZE_H);
                          if(Lab.m_ValType != _TYPE_NULL)
                          {
                               size.h = Lab.m_Double;
                          }
                  }
                  bool bIsCircle = true;
                  {//size h
                          CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_IS_CIRCLE);
                          if(Lab.m_ValType != _TYPE_NULL)
                          {
                               bIsCircle = Lab.m_Bool;
                          }
                  }
                  CObjComponent Obj(BasePt,size);
                  Obj.SetIsCircle(bIsCircle);
                  m_BaseComponentVec.push_back(Obj);
            }
      }
}
#endif
#if 1
void CObjComponentMgr::Draw(CDC* pDC)
{
     if(!m_bDrawAllObj)
         return;
     {
           //元件
           int size = m_ComponentVec.size();
           for(int i=0;i<size;i++)
           {
                m_ComponentVec[i].Draw(pDC);
           }
           Dbxy Offset;
           DrawArea(pDC,Offset);//限定范围
     }

     if(m_bDrawBase)//基准元件
     {
           int size = m_BaseComponentVec.size();
           for(int i=0;i<size;i++)
           {
                 if(m_CurSelIdx==i)
                 {
                      m_BaseComponentVec[i].SetSelected(true);
                      m_BaseComponentVec[i].Draw(pDC);
                 }
                 else
                 {
                      m_BaseComponentVec[i].SetSelected(false);
                      m_BaseComponentVec[i].Draw(pDC);
                 }
           }
     }
#if 0
     //在所有搜集的obj 中心绘制一个十字
     DbRect Rect(m_AllObjCenterPt,2);
     DrawCrossX(pDC,gDraw->GetMarkPointPen(),Rect);
#endif
}
//按偏移绘制限定范围
void CObjComponentMgr::DrawArea(CDC* pDC,Dbxy Offset)
{
     if(m_bUseArea && !m_ComponentVec.empty())
     {
          Dbxy BasePt;
          BasePt.x += Offset.x;
          BasePt.y += Offset.y;
          if(m_bRectArea)
          {
               
               DbRect rect(BasePt,m_AreaSize);
               DrawRect(pDC,gDraw->GetObjComponentAreaPen(),rect,false);
          }
          else
          {
               CObjCircle Circle;
			   CCirclePar par;
	 par.CenterPt = m_AreaBasePt;
	 par.Radius = m_AreaRadius;
	 par.DEdgeCnt = 200;
     Circle.Creat(par);
               Circle.Draw(pDC,gDraw->GetObjComponentAreaPen());
          }
     }
}
//选择元件
bool CObjComponentMgr::SelObjectInRect(DbRect rect)
{
     if(!m_bDrawAllObj)
         return false;
     
     bool flg = false;
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
          if((*iter).IsInRect(rect))
          {
                //反转选择
                bool b = !((*iter).IsSelected());
                (*iter).SetSelected(b);
                flg = true;

                if(!gDraw->IsbMultipleSel())//不多选
                {
                    Dbxy pt = (*iter).GetBasePt();
                    gLogMgr->WriteDebugLog("Sel Obj ViewCoord :","x","y",pt.x,pt.y);
                    //这里可以观察选择obj 的实际坐标值
                    Dbxy RealBasePt = (*iter).GetRealBasePt();
                    gLogMgr->WriteDebugLog("Sel Obj RealCoord :","x","y",RealBasePt.x,RealBasePt.y);
                    break;
                }
          }
     }
     //响应obj 选择状态的改变
     OnObjSelStateChange();
     return flg;
}
//全选
void CObjComponentMgr::SelAllObj()
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
          (*iter).SetSelected(true);
     }
     //相应obj 选择状态的改变
     OnObjSelStateChange();
}
void CObjComponentMgr::NotSelAllObj()
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
          (*iter).SetSelected(false);
     }
     //相应obj 选择状态的改变
     OnObjSelStateChange();
}
//反选
void CObjComponentMgr::RevSelAllObj()
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
          (*iter).SetSelected(!((*iter).IsSelected()));
     }
     //相应obj 选择状态的改变
     OnObjSelStateChange();
}
//相应obj 选择状态的改变
void CObjComponentMgr::OnObjSelStateChange()
{
}
//获取所有选择obj 的索引值到vec 
void CObjComponentMgr::GetSelObjIdx(vector<bool> &SelObjIdxVec)
{
     SelObjIdxVec.clear();
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     int idx = 0;
     for(;iter!=iter_end;iter++,idx++)
     {
          SelObjIdxVec.push_back((*iter).IsSelected());
     }
}
//通过索引值来设置obj  的选择状态
void CObjComponentMgr::SetSelectedByIdx(int idx,bool b)
{
     int size = m_ComponentVec.size();
     if(idx<size)
     {
            m_ComponentVec[idx].SetSelected(b);
     }
}
//计算所有obj 的中心点
void CObjComponentMgr::CalAllObjCenterPt()
{
     DbRect Rect;
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     int idx = 0;
     for(;iter!=iter_end;iter++,idx++)
     {
          if((*iter).IsbCollecteData())
          {
                AdjustRectByPoint(Rect,(*iter).GetBasePt());
          }
     }
     m_AllObjCenterPt = Rect.GetCenterPt();
}
#endif
#if 1
//获取当前选择obj 的数量
int CObjComponentMgr::GetSelObjCnt()
{
      int cnt = 0;
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
            if((*iter).IsSelected())
               cnt++;
      }
      return cnt;
}
//获取当前设定的mark 数量
int CObjComponentMgr::GetMarkObjCnt()
{
      int cnt = 0;
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
            if((*iter).IsMarkObj())
               cnt++;
      }
      return cnt;
}
void CObjComponentMgr::ResetAllMarkObj()
{
      int cnt = 0;
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
            (*iter).SetbMarkObj(false);
      }
}
//设置当前选择的obj 为mark
void CObjComponentMgr::SetSelObjMark(int CurMarkCnt)
{
      int idx = CurMarkCnt+1;
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
            if((*iter).IsSelected())
            {
                  (*iter).SetbMarkObj(true);
                  CString LogStr;
                  LogStr.Format(("Set Mark Pt [%d]"),idx++);
                  gLogMgr->WriteDebugLog(LogStr);
                  Dbxy pt = (*iter).GetBasePt();
                  LogStr.Format(("[pt.x] = [%f] ,[pt.y] = [%f]"),pt.x,pt.y);
                  gLogMgr->WriteDebugLog(LogStr);
            }
      }
}
//设置当前选择的obj 为mark obj
bool CObjComponentMgr::SetMarkObj()
{
      int SelObjCnt = GetSelObjCnt();//选择的个数
      if(SelObjCnt>2)
      {
            //gLogMgr->WriteDebugLog("不能指定两个以上obj 为mark");
            return false;
      }
      if(SelObjCnt==0)
      {
            return false;
      }
      int MarkObjCnt = GetMarkObjCnt();//现在mark obj 的个数
      if(MarkObjCnt>=2)
      {
            ResetAllMarkObj();
            MarkObjCnt = 0;
      }
      //设置当前选择的obj 为mark
      SetSelObjMark(MarkObjCnt);
      return true;
}
#endif
#if 1
//添加一个基准元件
void CObjComponentMgr::AddBaseComponent()
{
     Dbxy pt;
     DbSize size(2,2);
     AddBaseComponent(pt,size);
}
void CObjComponentMgr::AddBaseComponent(Dbxy pt,DbSize size)
{
     CObjComponent Component(pt,size);
     Component.SetBase(true);
     m_BaseComponentVec.push_back(Component);
}

//添加一个普通原件
void CObjComponentMgr::AddComponent(CObjComponent Component)
{
     m_ComponentVec.push_back(Component);
}
void CObjComponentMgr::InsertList(CListCtrl &List)
{
     int size = m_BaseComponentVec.size();
     for(int i=0;i<size;i++)
     {
          int idx = 0;
          List.InsertItem(i," ");//插入一行
          List.SetItemText(i,idx++,Int2CString(i+1));//序号
          Dbxy pt = m_BaseComponentVec[i].GetBasePt();//基准点
          List.SetItemText(i,idx++,Db2CString(pt.x));
          List.SetItemText(i,idx++,Db2CString(pt.y));
          DbSize size = m_BaseComponentVec[i].GetSize();//尺寸
          List.SetItemText(i,idx++,Db2CString(size.w));
          List.SetItemText(i,idx++,Db2CString(size.h));
     }
}
//检查idx 是否有效
bool CObjComponentMgr::IdxValid(int idx)
{
    int size = m_BaseComponentVec.size();
    if(idx<0 || idx>= size)
       return false;
    return true;
}
void CObjComponentMgr::DelSel(int &idx)
{
     if(!IdxValid(idx))
         return;
     vector<CObjComponent>::iterator iter = m_BaseComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_BaseComponentVec.end();
     int i=0;
     for(;iter!=iter_end;iter++)
     {
          if(i==idx)
          {
               m_BaseComponentVec.erase(iter);
               idx = -1;
               break;
          }
          i++;
     }
}
//删除所有
void CObjComponentMgr::DelAll()
{
     m_BaseComponentVec.clear();
     m_ComponentVec.clear();
     m_CatchPtVec.clear();
}
//操作idx 索引
void CObjComponentMgr::OpArea(int idx,CObjComponent &Area,bool bRead)
{
     int size = m_BaseComponentVec.size();
     for(int i=0;i<size;i++)
     {
           if(idx == i)
           {
                if(bRead)
                {
                     Area = m_BaseComponentVec[i];
                }
                else
                {
                     m_BaseComponentVec[i] = Area;
                }
           }
     }
}
#endif
#if 1
//是否在限定范围内(Size 用来去除挂到边的obj)
bool CObjComponentMgr::IsInArea(Dbxy pt,DbSize Size)
{
     if(!m_bUseArea)
         return true;

     if(!m_bNeedAllIn)
         Size.w = Size.h = 0;
     if(m_bRectArea)//矩形范围
     {
          DbRect rect(m_AreaBasePt,DbSize(m_AreaSize.w-Size.w,m_AreaSize.h-Size.h));
          return IsPointInRect(pt,rect);
     }
     else//圆形
     {
          return CalDistance(m_AreaBasePt,pt)<(m_AreaRadius-Size.w/2);
     }
}
//阵列元件
void CObjComponentMgr::Array()
{
     m_ComponentVec.clear();
     m_CatchPtVec.clear();
     
     if(m_bAutoArray)//自动排布
     {
           AutoArray();
     }
     else
     {
           ArrayExt();
     }
}
//自动排布
void CObjComponentMgr::AutoArray()
{
     if(m_BaseComponentVec.empty())
         return;
     if(!m_bUseArea)
         return;
     //自动排布只取第一个
     Dbxy BasePt = m_BaseComponentVec[0].GetBasePt();
     DbSize Size = m_BaseComponentVec[0].GetSize();
     bool bIsCircle = m_BaseComponentVec[0].IsCircle();
     
     double OffsetX = (Size.w + m_AutoArrayGap)/2;
     double OffsetY = GENG_3*OffsetX;
     
     Dbxy Pt = BasePt;
     while(1)//正向
     {
          if(AutoArrayExt(Pt,Size,OffsetX,OffsetY,bIsCircle)==false)
               break;
          Pt.x += (Size.w + m_AutoArrayGap);
     }
     Pt = BasePt;
     Pt.x -= (Size.w + m_AutoArrayGap);
     while(1)//负向
     {
          if(AutoArrayExt(Pt,Size,OffsetX,OffsetY,bIsCircle)==false)
               break;
          Pt.x -= (Size.w + m_AutoArrayGap);
     }
}
//自动阵列
bool CObjComponentMgr::AutoArrayExt(Dbxy BasePt,DbSize Size,double OffsetX,double OffsetY,bool bIsCircle)
{
     bool ret = false;//是否有范围内的obj
     Dbxy Pt = BasePt;
     for(int i=0;i<m_ArrayYcntZ;i++)//正向
     {
           if(IsInArea(Pt,Size))
           {
                CObjComponent Obj(Pt,Size);
                Obj.SetIsCircle(bIsCircle);
                m_ComponentVec.push_back(Obj);
                ret = true;
           }
           Pt.x += OffsetX;
           Pt.y += OffsetY;
     }
     Pt = BasePt;
     Pt.x -= OffsetX;
     Pt.y -= OffsetY;
     for(int i=0;i<m_ArrayYcntF;i++)//负向
     {
           if(IsInArea(Pt,Size))
           {
                CObjComponent Obj(Pt,Size);
                Obj.SetIsCircle(bIsCircle);
                m_ComponentVec.push_back(Obj);
                ret = true;
           }
           Pt.x -= OffsetX;
           Pt.y -= OffsetY;
     }
     return ret;
}
//XY方向矩阵阵列
void CObjComponentMgr::ArrayExt()
{
     //从右上角开始
     int startX = m_ArrayXcntZ;
     int endX = m_ArrayXcntF*(-1);
     int startY = m_ArrayYcntZ;
     int endY = m_ArrayYcntF*(-1);
     
     Dbxy Offset;//整体偏移
     Offset.x = (endX*m_OffsetX-startX*m_OffsetX)/2;
     Offset.y = (endY*m_OffsetY-startY*m_OffsetY)/2;
     
     Dbxy RealOffset;//整体偏移
     RealOffset.x = (endX*m_RealOffsetX-startX*m_RealOffsetX)/2;
     RealOffset.y = (endY*m_RealOffsetY-startY*m_RealOffsetY)/2;
     
     for(int i = startX;i>=endX;i--)
     {
          for(int j = startY;j>=endY;j--)
          {
                //设置obj 的索引值
                IntXY idx;
                idx.x = (i-startX-1)*(-1);
                idx.y = (j-startY-1)*(-1);
                Arrayij(i,j,idx,Offset,RealOffset);
          }
     }
}
//第i 列第j 行(Offset 显示整体偏移,RealOffset 实际整体偏移)
void CObjComponentMgr::Arrayij(int i,int j,IntXY idx,Dbxy Offset,Dbxy RealOffset)
{
     int size = m_BaseComponentVec.size();
     for(int k=0;k<size;k++)
     {
          Dbxy BasePt = m_BaseComponentVec[k].GetBasePt();
          DbSize Size = m_BaseComponentVec[k].GetSize();
          bool bIsCircle = m_BaseComponentVec[k].IsCircle();
          
          Dbxy RealBasePt = BasePt;//实际坐标
          
          BasePt.x += m_OffsetX*i + Offset.x;
          BasePt.y += m_OffsetY*j + Offset.y;

          RealBasePt.x += m_RealOffsetX*i + RealOffset.x;
          RealBasePt.y += m_RealOffsetY*j + RealOffset.y;
          
          //检查是否在限定范围内
          if(!IsInArea(BasePt,Size))
              continue;
          //创建新的obj 
          CObjComponent Obj(BasePt,Size);
          Obj.SetRealBasePt(RealBasePt);
          Obj.SetIsCircle(bIsCircle);
          if(i==0 && j==0)//标记基准元件
          {
               Obj.SetBase(true);
          }
          Obj.SetIndex(idx);
          
          m_ComponentVec.push_back(Obj);

          if(k==0)//计算抓取用的交点,只计算一次
          {
                Dbxy pt(BasePt.x-m_OffsetX/2,BasePt.y-m_OffsetY/2);
                m_CatchPtVec.push_back(pt);
          }
     }
}
//设置基准obj 的偏移
void CObjComponentMgr::SetBaseObjOffset(Dbxy Offset)
{
     vector<CObjComponent>::iterator iter = m_BaseComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_BaseComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
           (*iter).SetBasePt(Offset);
     }
}
//在交叉点中找到离pt 最近的点
Dbxy CObjComponentMgr::FindNearestPt(Dbxy pt)
{
     Dbxy NearestPt = pt;
     double MinDis = -1;
     vector<Dbxy>::iterator iter = m_CatchPtVec.begin();
     vector<Dbxy>::iterator iter_end = m_CatchPtVec.end();
     for(;iter!=iter_end;iter++)
     {
           double dis = CalDistance(pt,(*iter));
           if(MinDis == -1 || dis < MinDis)
           {
                 MinDis = dis;
                 NearestPt = (*iter);
           }
     }
     return NearestPt;
}
#endif
#if 1
//通过layer 中的图形对象来创建obj 对象
void CObjComponentMgr::CreatObjByLayerObj()
{
      m_ComponentVec.clear();
      
      CLayer &Layer = gLayer;
      CObjContainer &ObjContainer = Layer.GetObjContainer();
      vector<Sptr<CObjBase>> &ObjVec = ObjContainer.GetObjVec();
      
      vector<Sptr<CObjBase>>::iterator iter = ObjVec.begin();
      vector<Sptr<CObjBase>>::iterator iter_end = ObjVec.end();
      for(;iter!=iter_end;iter++)
      {
           DbRect rect = (*iter)->GetRect();
           if(!m_bDrawBindingObj)//是否绘制绑定obj
           {
                 (*iter)->SetbDraw(false);
           }
           (*iter)->SetSelected(false);
           Dbxy pt = rect.GetCenterPt();
           DbSize size = rect.GetSize();
           double MinSize = 2;
           if(size.w<MinSize)
               size.w=MinSize;
           if(size.h<MinSize)
               size.h=MinSize;
               
           double gap = 0.1;//范围比数据大一点
           size.w += gap; 
           size.h += gap;
           CObjComponent Obj(pt,size);
           Obj.SetIsCircle(false);//方形
           Obj.AddObjShape(*iter);//绑定layer obj 的数据
           m_ComponentVec.push_back(Obj);
      }
      //锁定绑定的layer obj (防止编辑)
      SetShapeLockState(true);
}
//从obj 中分析出两个定位mark 的位置(两个同心圆)
//直径小于R 的obj 被认为可能的mark 对象
void CObjComponentMgr::AnalyseMarkPt(double R)
{
      vector<CObjComponent*> MarkVec;
      //先找出半径小于R 的对象
      {
            vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
            vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
            for(;iter!=iter_end;iter++)
            {
                   DbSize Size = (*iter).GetSize();
                   if(Size.w<R && Size.h<R)
                   {
                        (*iter).NotCollect();//不要收集加工数据
                        MarkVec.push_back(&(*iter));
                   }
            }
      }
      //分析出两个同心mark 
      int MarkCnt = 0;//找到mark 的数量
      {
            int size = MarkVec.size();
            for(int i=0;i<size-1;i++)
            {
                 if(MarkVec[i]->IsCollected())//避免重复
                      continue;
                 Dbxy pt1 = MarkVec[i]->GetBasePt();
                 for(int k=i+1;k<size;k++)
                 {
                       if(MarkVec[k]->IsCollected())//避免重复
                            continue;
                       Dbxy pt2 = MarkVec[k]->GetBasePt();
                       double dis = CalDistance(pt1,pt2);
                       if(dis<0.5)//匹配
                       {
                              MarkVec[k]->SetbMarkObj(true);//标记为mark 
                              MarkVec[k]->SetbCollected(true);
                              MarkCnt++;//记录找到mark 的数量
                              break;
                       }
                 }
                 MarkVec[i]->SetbCollected(true);//标记
            }
      }
      CString LogStr;
      LogStr.Format(_T("func: AnalyseMarkPt---->[MarkCnt] = [%d]"),MarkCnt);
      gLogMgr->WriteDebugLog(LogStr);
}
//获得基准对象的
DbSize CObjComponentMgr::GetBaseSize(int idx)
{
      DbSize BaseSize;
      int size = m_BaseComponentVec.size();
      if(idx>=0 && idx<size)
      {
          BaseSize = m_BaseComponentVec[idx].GetSize();
      }
      return BaseSize;
}
bool CObjComponentMgr::IsBaseCircle(int idx)
{
     bool ret = false;
     int size = m_BaseComponentVec.size();
     if(idx>=0 && idx<size)
     {
         ret = m_BaseComponentVec[idx].IsCircle();
     }
     return ret;
}
//重置元件的收集状态NeedSel 为true 表示选择的才收集
void CObjComponentMgr::ResetObjCollectState(bool NeedSel)
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
          (*iter).SetbCollected(false);
          if(NeedSel && (*iter).IsSelected()==false)
          {
               (*iter).SetbCollected(true);//未选择的不要收集
          }
     }
}
//收集rect 范围内元件的工作数据
void CObjComponentMgr::CollectWorkData(DbRect &rect,vector<vector<Dbxy>> &vec,bool bNeedSel)
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
          if(!bNeedSel || (bNeedSel && (*iter).IsSelected()))
          {
               (*iter).CollectWorkData(rect,vec);
          }
     }
}
//返回第一个基准obj 是否是圆形
bool CObjComponentMgr::IsCircle()
{
      if(m_BaseComponentVec.empty())
          return true;
      return m_BaseComponentVec[0].IsCircle();
}
//设置第一个基准obj 是否为圆形
void CObjComponentMgr::SetIsCircle(bool b)
{
      if(!m_BaseComponentVec.empty())
      {
            m_BaseComponentVec[0].SetIsCircle(b);
      }
}
//通过obj 对象创建markarea
void CObjComponentMgr::CreatAreaByObj(CMarkAreaMgr &AreaMgr)
{
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
          CMarkArea Area((*iter).GetBasePt(),(*iter).GetSize());
          AreaMgr.AddArea(Area);
      }
}
#endif
#if 1
//获取第一个选择的obj 的索引值
IntXY CObjComponentMgr::GetFristSelectedObjIdx()
{
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
           if((*iter).IsSelected())
           {
                 return (*iter).GetIndex();
           }
      }
      IntXY idx(-1,-1);
      return idx;
}
//索引编号转换为vector 的索引值(没有匹配返回-1)
int CObjComponentMgr::ConvertIdx(IntXY Idx)
{
      int size = m_ComponentVec.size();
      for(int i=0;i<size;i++)
      {
            if(m_ComponentVec[i].GetIndex() == Idx)
                return i;
      }
      return -1;
}
//移动第一个选择的obj 到目标点TargetPt 
void CObjComponentMgr::MoveFristSelObjToPt(Dbxy TargetPt)
{
     //获取第一个选择obj 的索引
     IntXY IdxXY = GetFristSelectedObjIdx();
     //按索引移动
     MoveObjToPtByIdx(IdxXY,TargetPt);
}
//设置当前观察的obj
void CObjComponentMgr::SetCurViewObjIdx(IntXY Idx)
{
     m_CurSelObjIdx = Idx;
     int size = m_ComponentVec.size();
     for(int i=0;i<size;i++)
     {
           if(m_ComponentVec[i].GetIndex() == Idx)
           {
                 m_ComponentVec[i].SetbView(true);
           }
           else
           {
                 m_ComponentVec[i].SetbView(false);
           }
     }
}
//设置当前选择的obj
void CObjComponentMgr::SetCurSelObjIdx(IntXY Idx)
{
     m_CurSelObjIdx = Idx;
     int size = m_ComponentVec.size();
     for(int i=0;i<size;i++)
     {
           if(m_ComponentVec[i].GetIndex() == Idx)
           {
                 m_ComponentVec[i].SetSelected(true);
           }
           else
           {
                 m_ComponentVec[i].SetSelected(false);
           }
     }
}
//通过索引值来移动obj (最终都是用这个函数来移动观察obj )
bool CObjComponentMgr::MoveObjToPtByIdx(IntXY IdxXY,Dbxy TargetPt)
{
     //转换为容器索引
     int idx = ConvertIdx(IdxXY);
     if(idx>=0)
     {
           CString LogStr;
           LogStr.Format(_T("Fuc:MoveSelObjToPt : Idx[X] = [%d] ,Idx[Y] = [%d]"),IdxXY.x,IdxXY.y);
           gLogMgr->WriteDebugLog(LogStr);
           //记录当前观察obj 的索引值
           SetCurViewObjIdx(IdxXY);
           //设置为已观察
           m_ComponentVec[idx].SetbViewed(true);
           return true;
     }
     return false;
}
//通过方向来移动obj 到指定点
void CObjComponentMgr::MoveObjToCameraByDir(DIRECTION dir,Dbxy TargetPt)
{
      IntXY IdxXY = GetCurViewObjIdx();
      if(dir == _DIR_R)
           IdxXY.x--;
      else if(dir == _DIR_L)
           IdxXY.x++;
      else if(dir == _DIR_U)
           IdxXY.y--;
      else if(dir == _DIR_D)
           IdxXY.y++;
      else if(dir == _DIR_M)
      {
           IdxXY.x = 1;
           IdxXY.y = 1;
      }
      MoveObjToPtByIdx(IdxXY,TargetPt);
}
//按S 形轨迹来移动obj (bDir 向左或向右移动)
void CObjComponentMgr::MoveTrackS(Dbxy TargetPt,IntXY Gap,bool bDir)
{
     IntXY IdxXY = GetCurViewObjIdx();
     IntXY NewIdxXY = IdxXY;

     if(m_bMoveTrackSDir)//向下
          NewIdxXY.y += Gap.y;
     else//向上
          NewIdxXY.y -= Gap.y;
     
     if(MoveObjToPtByIdx(NewIdxXY,TargetPt)==false)//到头了，横向移动
     {
          NewIdxXY.y = IdxXY.y;
          if(bDir)//向左
              NewIdxXY.x += Gap.x;
          else//向右
              NewIdxXY.x -= Gap.x;
          
          if(MoveObjToPtByIdx(NewIdxXY,TargetPt))//横向移动
          {
              m_bMoveTrackSDir = !m_bMoveTrackSDir;//横向移动后Y 方向变向
          }
     }
}
#endif
#if 1
//LPS ISP3000 通过两颗die 的距离来将一个obj 分成两个(bDivideX 是分离方向)
void CObjComponentMgr::DivideBySpacingDis(double dis,bool bDivideX)
{
      if(dis<0.001)
          return;
      
      vector<CObjComponent> ComponentVecTmp;//临时容器
      
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
           ComponentVecTmp.push_back(CopyObj((*iter),-1,dis,bDivideX));
           ComponentVecTmp.push_back(CopyObj((*iter),1,dis,bDivideX));
      }
      m_ComponentVec = ComponentVecTmp;
}
CObjComponent CObjComponentMgr::CopyObj(CObjComponent &Obj,int sign,double dis,bool bDivideX)
{
      Dbxy BasePt = Obj.GetBasePt();//显示点
      Dbxy RealBasePt = Obj.GetRealBasePt();//实际点
      DbSize size = Obj.GetSize();//显示尺寸
      IntXY Idx = Obj.GetIndex();
      CObjComponent NewObj = Obj;
      BasePt.x += (size.w/4)*(sign);
      NewObj.SetBasePt(BasePt);
      RealBasePt.x += (dis/2)*(sign);
      NewObj.SetRealBasePt(RealBasePt);
      size.w /= 2;
      NewObj.SetSize(size);
      Idx.x *=2;
      if(sign==1)
          Idx.x -= 1;
      NewObj.SetIndex(Idx);
      return NewObj;
}
//当前观察过的obj 的数量
int CObjComponentMgr::GetCurViewedObj()
{
      int cnt = 0;
      vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
      vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
      for(;iter!=iter_end;iter++)
      {
            if((*iter).IsbViewed())
               cnt++;
      }
      return cnt;
}
#endif

#if  1
//切换是否移动到ccd 的模式
bool CObjComponentMgr::SwithObjToCcdMode()
{
     m_bObjToCcdMode = !m_bObjToCcdMode;
     return m_bObjToCcdMode;
}
//获取第一个选择的obj 的中心点
Dbxy CObjComponentMgr::GetFristSelObjCenter()
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
           if((*iter).IsSelected())
              return (*iter).GetRealBasePt();
     }
     Dbxy pt;
     return pt;
}
#endif
#if 1
//设置rect 区域内obj 的mark 状态(bSel 表示是否需要选择时设置)
//返回obj 的数据范围(用来调整markarea)
DbRect CObjComponentMgr::SetMarkedStateRect(DbRect AreaRect,bool bSel)
{
     DbRect DataRect;//数据范围
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
          if(bSel && !(*iter).IsSelected())
              continue;
          if(!(*iter).IsbMarked() && (*iter).IsInRect(AreaRect,true))
          {
               (*iter).SetbMarked(true);
               AdjustRectByRect(DataRect,(*iter).GetRect());
          }
     }
     return DataRect;
}
//重置所有obj 的加工状态
void CObjComponentMgr::ResetAllMarkedState()
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
           (*iter).SetbMarked(false);
     }
}
//设置原件绑定layer obj 的锁定状态(用来删除)
void CObjComponentMgr::SetShapeLockState(bool b)
{
     vector<CObjComponent>::iterator iter = m_ComponentVec.begin();
     vector<CObjComponent>::iterator iter_end = m_ComponentVec.end();
     for(;iter!=iter_end;iter++)
     {
           (*iter).SetShapeLockState(b);
     }
}
#endif