#include "StdAfx.h"
#include "ObjBase.h"
#include "LogMgr.h"
#include "GlobalFunction.h"
#include "GlobalDrawMgr.h"
#include "MarkParMgr.h"
#include "WorkFileLable.h"
#include "WorkFileMgr.h"
#include "CommonFlowMgr.h"

CObjBase::CObjBase(void)
{
    SetSelected(false);//是否被选中
    SetLock(false);//是否锁定
    m_bDraw = true;//是否绘制
    m_bOffsetAreaRect = false;//是否为偏移调整区域对象
    OnCreat();
}
CObjBase::~CObjBase(void)
{
}
//创建的时候
void CObjBase::OnCreat()
{
     m_PenNum = gMarkParMgr->GetCurPenNum();
}
#if 1
void CObjBase::WriteWorkFileBase(vector<CLab> &LabVec)
{
     LabVec.push_back(CLab(LAB_OBJ_TYPE,(int)GetType()));//obj 的类型
     LabVec.push_back(CLab(LAB_PEN_NUM,m_PenNum));//obj 轮廓的笔号
     LabVec.push_back(CLab(LAB_OBJ_IS_OFFSET_RECT,m_bOffsetAreaRect));//是否为偏移调整区域对象
}
void CObjBase::ReadWorkFileBase(CLabVecRang &LabVecRang)
{
     CWorkFileMgr WorkFileMgr;
     //读取笔号------------------------------------------------
     {
             CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_PEN_NUM);
             if(Lab.m_ValType != _TYPE_NULL)
             {
                  m_PenNum = Lab.m_Int;
             }
     }
     {
             CLab Lab = WorkFileMgr.FindLab(LabVecRang,LAB_OBJ_IS_OFFSET_RECT);
             if(Lab.m_ValType != _TYPE_NULL)
             {
                  m_bOffsetAreaRect = Lab.m_Bool;
             }
     }
}
void CObjBase::WriteWorkFile(vector<CLab> &LabVec)
{
     //写入公共信息
     WriteWorkFileBase(LabVec);
     WriteWorkFileExt(LabVec);
}
void CObjBase::ReadWorkFile(CLabVecRang &LabVecRang)
{
     //读取公共信息
     ReadWorkFileBase(LabVecRang);
     ReadWorkFileExt(LabVecRang);
}
void CObjBase::WriteWorkFileExt(vector<CLab> &LabVec)
{
     m_PtContainer.WriteWorkFile(LabVec);
}
void CObjBase::ReadWorkFileExt(CLabVecRang &LabVecRang)
{
     //读取数据点--------------------------------------------
     m_PtContainer.ReadWorkFile(LabVecRang);
}
#endif
#if 1
//拷贝构造函数
CObjBase::CObjBase(CObjBase &rhs)
{
    m_bSelected = rhs.m_bSelected;//是否被选中
    m_PtContainer.Load(rhs.m_PtContainer);//坐标数据的容器
    m_NodePtContainer.Load(rhs.m_NodePtContainer);
    m_PenNum = rhs.m_PenNum;
    m_bLocked = rhs.m_bLocked;
    m_bDraw = rhs.m_bDraw;//是否绘制
    m_bOffsetAreaRect = rhs.m_bOffsetAreaRect;//是否为偏移调整区域对象
}
//复制rhs 的数据点
void CObjBase::CopyPt(CObjBase &rhs)
{
    m_PtContainer.Load(rhs.m_PtContainer);
}
#endif
#if 1
void CObjBase::Draw(CDC* pDC,CPen &Pen)
{
     if(!m_bDraw)
         return;
     //图形数据
     m_PtContainer.Draw(pDC,Pen);
     //节点
     if(IsSelected())
     {
         m_PtContainer.DrawNode(pDC);
     }
     //填充线
     DrawFill(pDC,Pen);
}
void CObjBase::Draw(CDC* pDC)
{
    if(!m_bDraw)
         return;
    CPen Pen;
    Pen.CreatePen(PS_INSIDEFRAME,0.5,gMarkParMgr->GetPenColor(m_PenNum));
    Draw(pDC,Pen);
}
//绘制最后一个线段
void CObjBase::DrawLastLine(CDC* pDC,CPen &Pen)
{
     if(!m_bDraw)
         return;
     m_PtContainer.DrawLastLine(pDC,Pen);
}
#endif
//添加一个数据点
void CObjBase::AddDataPoint(CDataPoint pt)
{
    m_PtContainer.AddDataPoint(pt);
}
//添加额外用于捕获的点
void CObjBase::AddNodePt(CDataPoint pt)
{
    m_NodePtContainer.AddDataPoint(pt);
}
bool CObjBase::Empty()
{
    return (m_PtContainer.GetPtCnt()<2) ;
}
void CObjBase::DelAllPt()//删除所有数据点
{
    m_PtContainer.DelAllPt();
    m_NodePtContainer.DelAllPt();
}
//获取点的个数
int CObjBase::GetPtCnt()
{
    return m_PtContainer.GetPtCnt();
}
void CObjBase::DelLastDataPoint()//删除最后一个节点
{
    m_PtContainer.DelLastDataPoint();
}
int CObjBase::GetNodePtIdx(Dbxy pt)
{
    return m_PtContainer.GetNodePtIdx(pt);
}
void CObjBase::DelNodePtByIdx(int idx)
{
    m_PtContainer.DelNodePtByIdx(idx);
}
void CObjBase::SetNodePtByIdx(int idx,Dbxy pt)
{
    m_PtContainer.SetNodePtByIdx(idx,pt);
}
void CObjBase::InsertNode(int idx,Dbxy pt)
{
    m_PtContainer.InsertNode(idx,pt);
}
void CObjBase::SetLastPoint(CDataPoint &pt)
{
    m_PtContainer.SetLastPoint(pt);
}

bool CObjBase::IsSelected()
{
    return m_bSelected;
}
void CObjBase::SetSelected(bool bSelected)
{
    if(m_bLocked)//锁定状态不能被选中
        return;
    
    m_bSelected = bSelected;
}
DbRect CObjBase::GetRect()
{
    return m_PtContainer.GetRect();
}
Dbxy CObjBase::GetFirstPt()
{
    return m_PtContainer.GetFirstPt();
}
Dbxy CObjBase::GetLastPt()
{
    return m_PtContainer.GetLastPt();
}
//是否有节点在rect 内
bool CObjBase::HasNodeInRect(DbRect rect)
{
    return m_PtContainer.HasNodeInRect(rect);
}
//是否和line 相交
bool CObjBase::IntersectWithLine(DbLine &line)
{
     return m_PtContainer.IntersectWithLine(line);
}
#if 1
void CObjBase::Operate(SObjOperatePar &par)
{
     m_GeometryPorp.Operate(par);//记录几何属性
     m_PtContainer.Operate(par);//数据点
     m_NodePtContainer.Operate(par);//节点
     OperateFill(par);//填充
}
#endif
#if 1//捕获相关函数
//获取obj 和rect 相交的线段(bGetCatchNode 表示是否获得额外的捕捉点)
void CObjBase::GetLineInRect(DbRect &rect,vector<DbLine> &DataPtLineVec,bool bGetCatchNode)
{
     m_PtContainer.GetLineInRect(rect,DataPtLineVec);
     if(bGetCatchNode)
     {
         m_NodePtContainer.GetNodePtLineInRect(rect,DataPtLineVec);
     }
}
#endif
#if 1
//搜集obj 点的数据到vec 中
void CObjBase::GetPtData(vector<vector<Dbxy>> &vec)
{         
     m_PtContainer.GetPtData(vec);
     //填充数据
     #if 0
     vector<CSequentialPoint>::iterator iter = m_FillDataVec.begin();
     vector<CSequentialPoint>::iterator iter_end = m_FillDataVec.end();
     for(;iter!=iter_end;iter++)
     {
          (*iter).GetPtData(vec);
     }
     #endif
}
#endif
#if 1//填充相关函数
//创建填充数据
void CObjBase::CreatFillData(SFillPar FillPar)
{
     m_FillDataVec.clear();

     if(!FillPar.bFill)
         return;
     //搜集obj 点的数据到vec 中
     vector<vector<Dbxy>> vec;
     GetPtData(vec);

     //创建填充
     CObjFill Fill(m_FillDataVec);
     Fill.SetPar(FillPar);
     Fill.CreatFill(vec,GetRect());
}
void CObjBase::DrawFill(CDC* pDC,CPen &Pen)
{
     vector<CSequentialPoint>::iterator iter = m_FillDataVec.begin();
     vector<CSequentialPoint>::iterator iter_end = m_FillDataVec.end();
     for(;iter!=iter_end;iter++)
     {
          (*iter).Draw(pDC,Pen);
     }
}
//操作填充
void CObjBase::OperateFill(SObjOperatePar &par)
{
     vector<CSequentialPoint>::iterator iter = m_FillDataVec.begin();
     vector<CSequentialPoint>::iterator iter_end = m_FillDataVec.end();
     for(;iter!=iter_end;iter++)
     {
          (*iter).Operate(par);
     }
}
//获取填充数据
void CObjBase::GetFillData(vector<vector<Dbxy>> &vec)
{
      //填充数据
      vector<CSequentialPoint>::iterator iter = m_FillDataVec.begin();
      vector<CSequentialPoint>::iterator iter_end = m_FillDataVec.end();
      for(;iter!=iter_end;iter++)
      {
           (*iter).GetPtData(vec);
      }
}
#endif
#if 1
//创建同心数据
void CObjBase::CreatConcentricData(vector<double> &GapVec)
{
       vector<vector<CDataPoint>>  vec;
       
       double FirstGap = gCommonFlowMgr->GetFirstGap();
       double bChangeSize = !IsDbEqualZero(FirstGap);
       if(bChangeSize)//拉伸
       {
            vector<CDataPoint> DataPointVec = GetConcentricData(FirstGap);
            m_PtContainer.DelAllPt();
            AddDataPointVec(DataPointVec);
       }

       if(GapVec.empty())
           return;
       
       double Gap = GapVec[0];
       double CurGap = Gap;
       vector<double>::iterator iter = GapVec.begin();
       vector<double>::iterator iter_end = GapVec.end();
       for(;iter!=iter_end;iter++)
       {
            vector<CDataPoint> DataPointVec = GetConcentricData(CurGap);
            vec.push_back(DataPointVec);
            CurGap += Gap;
       }

       {
             vector<vector<CDataPoint>>::iterator iter = vec.begin();
             vector<vector<CDataPoint>>::iterator iter_end = vec.end();
             for(;iter!=iter_end;iter++)
             {
                  AddDataPointVec(*iter);
             }
       }
}
void CObjBase::AddDataPointVec(vector<CDataPoint> &Vec)
{
       vector<CDataPoint> &DataPointVec =  GetPtContainer();
       
       vector<CDataPoint>::iterator iter = Vec.begin();
       vector<CDataPoint>::iterator iter_end = Vec.end();
       for(;iter!=iter_end;iter++)
       {
             DataPointVec.push_back(*iter);
       }
}
//根据实际加工尺寸来调整obj的尺寸DN cut 2016-09-18
Dbxy CObjBase::GetSizeAdjust2()
{
     double Rang = 40;
     
     Dbxy SizeAdjust2(0.013,-0.012);

     Dbxy CenterPt = GetRect().GetCenterPt();
     SizeAdjust2.x = SizeAdjust2.x *(CenterPt.x/Rang);
     SizeAdjust2.y = SizeAdjust2.y *(CenterPt.x/Rang);
     
     return SizeAdjust2;
}

//obj 缩放
vector<CDataPoint> CObjBase::GetConcentricData(double Gap)
{
       DbRect rect = GetRect();
       Dbxy SizeAdjust = gCommonFlowMgr->GetAdjustSize();
       #if 0//dn cut 2016-09-18
       Dbxy SizeAdjust2 = GetSizeAdjust2();
       SizeAdjust.x += SizeAdjust2.x;
       SizeAdjust.y += SizeAdjust2.y;
       #endif
       SObjOperatePar parX;
       parX.OpType = _OP_STRETCH;
       parX.BasePt = rect.GetCenterPt();
       parX.OldSize = rect.GetSize().w;
       parX.Diff = SizeAdjust.x;
       parX.xy = _X;
  
       SObjOperatePar parY;
       parY.OpType = _OP_STRETCH;
       parY.BasePt = rect.GetCenterPt();
       parY.OldSize = rect.GetSize().h;
       parY.Diff = SizeAdjust.y;
       parY.xy = _Y;
  
       vector<CDataPoint> DataPointVec =  GetPtContainer();//复制数据
       vector<CDataPoint>::iterator iter = DataPointVec.begin();
       vector<CDataPoint>::iterator iter_end = DataPointVec.end();
       for(;iter!=iter_end;iter++)
       {
             (*iter).Operate(parX);
             (*iter).Operate(parY);
       }
       return DataPointVec;
}
#endif