|
|
#include "StdAfx.h"
|
|
|
#include ".\itemcurveprocess.h"
|
|
|
#include "SigmaDoc.h"
|
|
|
#include "SigmaView.h"
|
|
|
#include ".\itemlinkcurve.h"
|
|
|
#include ".\actionembellishitem.h"
|
|
|
#include ".\actionmodifieditem.h"
|
|
|
#include ".\actionbackupitem.h"
|
|
|
#include "ActionListItem.h"
|
|
|
#include "ActionComboItem.h"
|
|
|
#include ".\actionchangelayeritem.h"
|
|
|
#include "TinyXml/tinyxml.h"
|
|
|
#include "Util.h"
|
|
|
#include "../SSBase/VoronoiMap/PolygonOperation.h"
|
|
|
|
|
|
//#define USINGZ
|
|
|
#include "keyholing.h"
|
|
|
|
|
|
|
|
|
CItemCurveProcess::CItemCurveProcess(CSigmaDoc * ppDoc)
|
|
|
: CItemFocusRect(ppDoc)
|
|
|
, m_idea(0)
|
|
|
, name(_T(""))
|
|
|
, m_pColor(NULL)
|
|
|
, a(10)
|
|
|
, decimal(8)
|
|
|
, m_bIsE(FALSE)
|
|
|
, m_bIsLog(false)
|
|
|
, m_selSmooth(1)
|
|
|
, m_bIsDelete(TRUE)
|
|
|
, m_processResult(0)
|
|
|
{
|
|
|
SetUpdatePropertyGridState(FALSE);
|
|
|
this->SetType(ITEM_CURVE_PROCESS);
|
|
|
|
|
|
cycle=30;
|
|
|
swing=10;
|
|
|
dnum=20;
|
|
|
m_bDeleteSourveCurve=FALSE;
|
|
|
m_dCurveOffset=10;
|
|
|
m_dStep=200;
|
|
|
m_nMode=0;
|
|
|
m_error=0;
|
|
|
m_bInteger=TRUE;
|
|
|
}
|
|
|
|
|
|
CItemCurveProcess::~CItemCurveProcess(void)
|
|
|
{
|
|
|
if(m_pColor)delete m_pColor;
|
|
|
m_pColor=NULL;
|
|
|
}
|
|
|
|
|
|
void CItemCurveProcess::DoLButtonUp(CDC *pDC)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
|
|
|
int c=0;
|
|
|
BOOL bEnableDefaultTool=TRUE;
|
|
|
switch(m_idea)
|
|
|
{
|
|
|
case CURVE_FITTING:
|
|
|
c=FittingCurve();
|
|
|
break;
|
|
|
case CURVE_NULL_EMBELLISH:
|
|
|
c=SetNullEmbellish();
|
|
|
break;
|
|
|
case CURVE_SET_EMBELLISH:
|
|
|
c=SetEmbellish();
|
|
|
break;
|
|
|
case CURVE_CONTOUR:
|
|
|
c=CurveContour();
|
|
|
break;
|
|
|
case CURVE_AUTO_LOCATION:
|
|
|
c=AutoLocation();
|
|
|
break;
|
|
|
case CURVE_REVERSAL:
|
|
|
c=Reversal();
|
|
|
bEnableDefaultTool=FALSE;
|
|
|
break;
|
|
|
case CURVE_SET_NAME:
|
|
|
c=SetName();
|
|
|
break;
|
|
|
case CURVE_NAME_TO_Z:
|
|
|
c=NameToZ();
|
|
|
break;
|
|
|
case CURVE_Z_TO_NAME:
|
|
|
c=ZToName();
|
|
|
break;
|
|
|
case CURVE_LAYER_TO_NAME:
|
|
|
c=LayerToName();
|
|
|
break;
|
|
|
case CURVE_NAME_LOG:
|
|
|
c=NameLog();
|
|
|
break;
|
|
|
case CURVE_NAME_EXPONENTIAL:
|
|
|
c=NameExponential();
|
|
|
break;
|
|
|
case CURVE_NAME_IS_NULL:
|
|
|
//c=FindNameIsNull();
|
|
|
break;
|
|
|
case CURVE_ANY_NAME:
|
|
|
c=AnyName();
|
|
|
if(c==0)
|
|
|
pDoc->Invalidate(GetPos());
|
|
|
break;
|
|
|
case ARC_TO_CURVE:
|
|
|
//c=ArcToCurve();
|
|
|
break;
|
|
|
case CURVE_SMOOTH:
|
|
|
c=CurveSmooth();
|
|
|
break;
|
|
|
case CURVE_TO_WAVE:
|
|
|
c=ToWave();
|
|
|
break;
|
|
|
case CURVE_OFFSET:
|
|
|
c=CurveOffset();
|
|
|
break;
|
|
|
case CURVE_NODE_ENCRYPT:
|
|
|
c=NodeEncrypt();
|
|
|
break;
|
|
|
case CURVE_REDUNDANT:
|
|
|
c=ToRedundant();
|
|
|
break;
|
|
|
case CURVE_CLOSE:
|
|
|
c=CloseCurve();
|
|
|
bEnableDefaultTool=FALSE;
|
|
|
break;
|
|
|
case CURVE_SURFACE_Z:
|
|
|
c = SetZFromSurface();
|
|
|
break;
|
|
|
}
|
|
|
m_processResult = c;
|
|
|
if(c>0)
|
|
|
{
|
|
|
//pDoc->Modified();
|
|
|
//pDoc->Invalidate();
|
|
|
}
|
|
|
//if(bEnableDefaultTool)
|
|
|
//pDoc->EnableDefaultTool();
|
|
|
}
|
|
|
|
|
|
bool CItemCurveProcess::NodeEncrypt(int mode, double step, bool bRounding, CPositionList & selectionSet)
|
|
|
{
|
|
|
CRect8 rect = this->GetRect();
|
|
|
if (selectionSet.IsEmpty())
|
|
|
return false;
|
|
|
|
|
|
CActionListItem* pAction = new CActionListItem(GetDoc(), ID_PROCESS_CURVE_ENCRYPT);
|
|
|
|
|
|
int count = 0;
|
|
|
POSITION pos, pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos = selectionSet.GetHeadPosition();
|
|
|
BOOL bR = bRounding ? TRUE : FALSE;
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = selectionSet.GetNext(pos);
|
|
|
pOne = m_pDoc->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
continue;
|
|
|
pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
|
|
|
CActionModifiedItem* pModifiedItem = new CActionModifiedItem(GetDoc(), IDS_STRING_CURVE);
|
|
|
pModifiedItem->BackupOldItem(pt, pOne);
|
|
|
pCurve->GetLocation();
|
|
|
pCurve->EncryptNode(mode, step, bR);
|
|
|
pModifiedItem->BackupNewItem();
|
|
|
pAction->AddTailItem(pModifiedItem);
|
|
|
count++;
|
|
|
|
|
|
m_pDoc->Modified();
|
|
|
}
|
|
|
|
|
|
if (count > 0)
|
|
|
GetDoc()->SetActionItem(pAction);
|
|
|
else
|
|
|
delete pAction;
|
|
|
return count != 0;
|
|
|
}
|
|
|
int CItemCurveProcess::PolygonConnect(CPositionList& selections, CString& layerName, bool deleteOriginalCurves)
|
|
|
{
|
|
|
if (selections.IsEmpty())
|
|
|
return false;
|
|
|
vector<CPolyline*> srcVec;
|
|
|
int count = 0;
|
|
|
POSITION pos, pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
|
|
|
/// ʹ<><CAB9>Clippers2<73><32><EFBFBD><EFBFBD>
|
|
|
Paths64 subjects;
|
|
|
int pathCount = selections.GetCount();
|
|
|
subjects.reserve(pathCount);
|
|
|
|
|
|
CPositionList removeElements;
|
|
|
|
|
|
pos = selections.GetHeadPosition();
|
|
|
while (pos) {
|
|
|
pt = selections.GetNext(pos);
|
|
|
pOne = m_pDoc->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
continue;
|
|
|
pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
if (pCurve->num < 3) {
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
removeElements.AddTail(pt);
|
|
|
|
|
|
Path64 pathTmp;
|
|
|
int nNum = pCurve->num;
|
|
|
pathTmp.reserve(nNum);
|
|
|
for (int i = 0; i < nNum; i++)
|
|
|
{
|
|
|
Point64 pt64 = toPoint64(pCurve->x[i], pCurve->y[i]); //, pCurve->z[i]
|
|
|
pathTmp.push_back(Point64(pt64.x, pt64.y));//, pCurve->z[i]
|
|
|
}
|
|
|
subjects.push_back(pathTmp);
|
|
|
}
|
|
|
PolyTree64 polytree;
|
|
|
Clipper64 c64;
|
|
|
c64.AddSubject(subjects);
|
|
|
c64.Execute(ClipType::Union, FillRule::EvenOdd, polytree);
|
|
|
|
|
|
// <20><><EFBFBD>Ⱥϲ<C8BA><CFB2>ཻ<EFBFBD><E0BDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD><EFBFBD>
|
|
|
Paths64 solutionMerge;
|
|
|
if (!KeyHole(polytree, solutionMerge)) return false;
|
|
|
|
|
|
Path64 pathConn64 = ConnectPolygons(solutionMerge);
|
|
|
Path64 pathResult64 = TrimCollinear(pathConn64);
|
|
|
|
|
|
PathD pathResult = fromPolygon64(pathConn64);
|
|
|
|
|
|
PathsD solution;
|
|
|
solution.emplace_back(pathResult);
|
|
|
|
|
|
CList<POSITION, POSITION> addList;
|
|
|
|
|
|
CLayer* pLayerResult = GetDoc()->GetDraw()->FindAddLayer(layerName);
|
|
|
for (size_t i = 0; i < solution.size(); ++i)
|
|
|
{
|
|
|
int nSize = solution[i].size();
|
|
|
CPointList PointList;
|
|
|
for (int j= 0; j < nSize; j++)
|
|
|
{
|
|
|
dfPoint point;
|
|
|
point.x0 = solution[i][j].x;
|
|
|
point.y0 = solution[i][j].y;
|
|
|
//point.z0 = solution[i][j].z;
|
|
|
PointList.AddTail(point);
|
|
|
}
|
|
|
dfPoint ptTail;
|
|
|
ptTail.x0 = solution[i][0].x;
|
|
|
ptTail.y0 = solution[i][0].y;
|
|
|
PointList.AddTail(ptTail);
|
|
|
CCurveEx* pCurveNew = new CCurveEx;
|
|
|
pCurveNew->SetName("");
|
|
|
pCurveNew->SetPoints(PointList, 2);
|
|
|
|
|
|
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
pos = GetDoc()->GetDraw()->AddElement(pCurveNew, DOUBLEFOX_CURVE);
|
|
|
|
|
|
addList.AddTail(pos);
|
|
|
}
|
|
|
|
|
|
///////////////
|
|
|
//pos = selections.GetHeadPosition();
|
|
|
//while (pos)
|
|
|
//{
|
|
|
// pt = selections.GetNext(pos);
|
|
|
// pOne = m_pDoc->GetDraw()->GetAt(pt);
|
|
|
// if (pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
// continue;
|
|
|
// pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
// if (pCurve->num < 3) {
|
|
|
// continue;
|
|
|
// }
|
|
|
// CPolyline* pLineNew = new CPolyline();
|
|
|
// for (int i = 0; i < pCurve->num; i++)
|
|
|
// {
|
|
|
// pLineNew->AddPoint(pCurve->x[i], pCurve->y[i], pCurve->z[i]);
|
|
|
// }
|
|
|
// srcVec.push_back(pLineNew);
|
|
|
//}
|
|
|
|
|
|
//vector<CPolyline*> dstVec;
|
|
|
//CPolygonOperation::DigHoles(srcVec, dstVec);
|
|
|
//CLayer* pLayerNew = GetDoc()->GetDraw()->FindAddLayer(layerName);
|
|
|
|
|
|
|
|
|
////pAction->AddAddItem(pNewOne);
|
|
|
//for (auto polyLine : dstVec) {
|
|
|
// int numPl = polyLine->GetLength();
|
|
|
// CPointList PointList;
|
|
|
// for (int i = 0; i < numPl; i++)
|
|
|
// {
|
|
|
// dfPoint point;
|
|
|
// point.x0 = polyLine->GetPoint(i).x0;
|
|
|
// point.y0 = polyLine->GetPoint(i).y0;
|
|
|
// point.z0 = polyLine->GetPoint(i).z0;
|
|
|
// PointList.AddTail(point);
|
|
|
// }
|
|
|
// CCurveEx* pCurveNew = new CCurveEx;
|
|
|
// pCurveNew->SetName(polyLine->GetName());
|
|
|
// pCurveNew->SetPoints(PointList, 2);
|
|
|
|
|
|
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
// pos = GetDoc()->GetDraw()->AddElement(pCurveNew, DOUBLEFOX_CURVE);
|
|
|
|
|
|
// addList.AddTail(pos);
|
|
|
//}
|
|
|
int nCount = addList.GetCount();
|
|
|
if (nCount > 0) {
|
|
|
CActionListItem* pItem = new CActionListItem(GetDoc(), ID_EDIT_TOOL_CONNECT_CURVE);
|
|
|
pItem->AddAddItem(addList);
|
|
|
if (deleteOriginalCurves)
|
|
|
{
|
|
|
pItem->AddDeleteItem(removeElements);
|
|
|
}
|
|
|
GetDoc()->SetActionItem(pItem);
|
|
|
}
|
|
|
return nCount;
|
|
|
}
|
|
|
bool CItemCurveProcess::ToRedundant(double tolerance, CPositionList & selectSet)
|
|
|
{
|
|
|
if (tolerance < 0)
|
|
|
return false;
|
|
|
|
|
|
if (selectSet.IsEmpty())
|
|
|
return false;
|
|
|
CActionListItem* pAction = new CActionListItem(GetDoc(), ID_PROCESS_CURVE_REDUNDANT);
|
|
|
|
|
|
int count = 0;
|
|
|
POSITION pos, pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos = selectSet.GetHeadPosition();
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = selectSet.GetNext(pos);
|
|
|
pOne = m_pDoc->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
continue;
|
|
|
pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
|
|
|
CActionModifiedItem* pModifiedItem = new CActionModifiedItem(GetDoc(), IDS_STRING_CURVE);
|
|
|
pModifiedItem->BackupOldItem(pt, pOne);
|
|
|
|
|
|
CCurveEx* pc = new CCurveEx;
|
|
|
*pc = *pCurve;
|
|
|
CCurveRedundant cr(*pc);
|
|
|
cr.Execute(tolerance);
|
|
|
cr.GetRedundantCurve(*pCurve);
|
|
|
if (pCurve->bAutoLocation)
|
|
|
pCurve->GetLocation();
|
|
|
delete pc;
|
|
|
|
|
|
pModifiedItem->BackupNewItem();
|
|
|
pAction->AddTailItem(pModifiedItem);
|
|
|
|
|
|
count++;
|
|
|
m_pDoc->Modified();
|
|
|
}
|
|
|
|
|
|
if (count > 0)
|
|
|
GetDoc()->SetActionItem(pAction);
|
|
|
else
|
|
|
delete pAction;
|
|
|
return count !=0 ;
|
|
|
}
|
|
|
|
|
|
//<2F>⻬<EFBFBD><E2BBAC><EFBFBD><EFBFBD>
|
|
|
//mode 0--B<><42><EFBFBD><EFBFBD> 1--<2D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
bool CItemCurveProcess::SmoothCurve(int mode, double step, CPositionList & selecctionSet)
|
|
|
{
|
|
|
if (selecctionSet.IsEmpty())
|
|
|
return false;
|
|
|
|
|
|
if (mode != 0 && mode != 1)
|
|
|
return false;
|
|
|
|
|
|
CActionListItem* pAction = new CActionListItem(GetDoc(), ID_PROCESS_CURVE_SMOOTH);
|
|
|
|
|
|
CPointList bp;
|
|
|
int count = 0;
|
|
|
POSITION pos, pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos = selecctionSet.GetHeadPosition();
|
|
|
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = selecctionSet.GetNext(pos);
|
|
|
pOne = m_pDoc->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
continue;
|
|
|
|
|
|
pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
|
|
|
CActionModifiedItem* pModifiedItem = new CActionModifiedItem(GetDoc(), IDS_STRING_CURVE);
|
|
|
pModifiedItem->BackupOldItem(pt, pOne);
|
|
|
|
|
|
switch (mode)
|
|
|
{
|
|
|
default:
|
|
|
case 1:
|
|
|
pCurve->CurveToBezier(bp, step, FALSE);
|
|
|
break;
|
|
|
case 0:
|
|
|
pCurve->CurveToSpline(bp, step, FALSE);
|
|
|
break;
|
|
|
}
|
|
|
pCurve->SetPoints(bp, pCurve->nPoint, pCurve->bAutoLocation);
|
|
|
bp.RemoveAll();
|
|
|
count++;
|
|
|
|
|
|
pModifiedItem->BackupNewItem();
|
|
|
pAction->AddTailItem(pModifiedItem);
|
|
|
}
|
|
|
|
|
|
if (count > 0)
|
|
|
GetDoc()->SetActionItem(pAction);
|
|
|
else
|
|
|
delete pAction;
|
|
|
|
|
|
return count != 0;
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::SetProcessIdea(int nIdea)
|
|
|
{
|
|
|
if (nIdea < 1 || nIdea > 23)
|
|
|
return -1;
|
|
|
|
|
|
m_idea=nIdea;
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::SetNullEmbellish(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
|
|
|
//Ϊ<><CEAA><EFBFBD><EFBFBD><EFBFBD>ε<EFBFBD>Redo/Undo
|
|
|
CActionComboItem *pAction= new CActionComboItem(pDoc, IDS_GI_EMBELLISH_SELF);
|
|
|
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
|
|
|
//for undo/redo
|
|
|
CActionEmbellishItem* pActionItem=new CActionEmbellishItem(pDoc, 0, pOne);
|
|
|
pActionItem->SetOldHowToView(pOne); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
|
if(pOne->HowToViewCurve!=NULL)
|
|
|
{
|
|
|
delete pOne->HowToViewCurve;
|
|
|
pOne->HowToViewCurve=NULL;
|
|
|
}
|
|
|
//<2F><><EFBFBD><EFBFBD>ԭʼ<D4AD><CABC><EFBFBD><EFBFBD>
|
|
|
pOne->color=0;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
pCurve->width=0;
|
|
|
pCurve->m_type=0;
|
|
|
pCurve->VirtualType.Clear();
|
|
|
|
|
|
pActionItem->SetNewHowToView(pOne);
|
|
|
pAction->AddAction(pActionItem);
|
|
|
|
|
|
count++;
|
|
|
}
|
|
|
|
|
|
if (count > 0)
|
|
|
{
|
|
|
m_pDoc->Modified();
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
delete pAction;
|
|
|
}
|
|
|
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::SetEmbellish(void)
|
|
|
{
|
|
|
/*
|
|
|
CXTPResizePropertySheet sheet(IDS_STRING_PANE_PROPERTIES, GetView());
|
|
|
sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CEmbellishPage page;
|
|
|
//page.SetUnit(pDoc->GetDraw()->GetUnit());
|
|
|
page.SetUnitMode(GetUnitMode().m_unit, GetUnitMode().m_dScaleFactor, GetUnitMode().m_nMode);
|
|
|
sheet.AddPage(&page);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
if(page.GetHowToViewCurve()==NULL) return 0;
|
|
|
*/
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
|
|
|
//Ϊ<><CEAA><EFBFBD><EFBFBD><EFBFBD>ε<EFBFBD>Redo/Undo
|
|
|
CActionComboItem *pAction= new CActionComboItem(pDoc, IDS_GI_EMBELLISH_SELF);
|
|
|
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
|
|
|
////for undo/redo
|
|
|
CActionEmbellishItem* pActionItem=new CActionEmbellishItem(pDoc, 0, pOne);
|
|
|
pActionItem->SetOldHowToView(pOne); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
|
if(pOne->HowToViewCurve)
|
|
|
delete pOne->HowToViewCurve;
|
|
|
pOne->HowToViewCurve=new CHowToViewCurve();
|
|
|
*pOne->HowToViewCurve=m_CurveStyle;
|
|
|
|
|
|
pActionItem->SetNewHowToView(pOne); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
pAction->AddAction(pActionItem);
|
|
|
|
|
|
count++;
|
|
|
}
|
|
|
|
|
|
if (count > 0)
|
|
|
{
|
|
|
m_pDoc->Modified();
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
delete pAction;
|
|
|
}
|
|
|
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::AutoLocation(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
CActionBackupItem* pAction=new CActionBackupItem(pDoc, ID_OPERATION_CURVE_LOCATION);
|
|
|
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
if(pCurve->bAutoLocation) continue;
|
|
|
|
|
|
pAction->Backup(pOne);
|
|
|
|
|
|
pCurve->bAutoLocation=TRUE;
|
|
|
if(pCurve->nPoint>3)pCurve->nPoint=3;
|
|
|
pCurve->GetLocation();
|
|
|
count++;
|
|
|
}
|
|
|
if (count > 0)
|
|
|
{
|
|
|
pAction->BackupNew();
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
}
|
|
|
else delete pAction;
|
|
|
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::Reversal(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
pDoc->SetActionItem(new CActionCurveReversalItem(pDoc, ID_OPERATION_CURVE_REVERSAL, select));
|
|
|
pDoc->Modified();
|
|
|
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
pCurve->Reversal();
|
|
|
if(pCurve->bAutoLocation)
|
|
|
pCurve->GetLocation();
|
|
|
count ++;
|
|
|
}
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
//#include "DrawModelColor\colorsheet.h"
|
|
|
int CItemCurveProcess::CurveContour(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
|
|
|
CColorSheet sheet("Color", GetView());
|
|
|
if(m_pColor==NULL) m_pColor=new CColorBase;
|
|
|
sheet.SetColor(m_pColor);
|
|
|
sheet.SetWizardMode();
|
|
|
if(sheet.DoModal()!=ID_WIZFINISH)
|
|
|
// if(!m_pColor->CreateWizard(GetView(),0))
|
|
|
return 0;
|
|
|
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_OPERATION_CURVE_CONTOUR);
|
|
|
|
|
|
COLORREF col=0;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
double value;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
value=atof(((CCurveEx*)pOne->GetValue())->GetName());
|
|
|
col=m_pColor->GetColor(value);
|
|
|
if(col == pOne->color) continue;
|
|
|
pAction->AddChangeColorItem(pt, pOne->color, col); //for redo/undo
|
|
|
pOne->color=col;
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::SetName(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CPropertiesSheet sheet(IDS_STRING_CURVE,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_OPERATION_CURVE_CONTOUR);
|
|
|
|
|
|
CCurveEx* pCurve;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
pAction->AddChangeNameItem(pt, pCurve->GetName(), name);
|
|
|
pCurve->SetName(name);
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
int CItemCurveProcess::NameToZ(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
CRect8 rect = this->GetRect();
|
|
|
CList<POSITION, POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect, select);
|
|
|
if (select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
CActionBackupItem* pAction = new CActionBackupItem(pDoc, ID_OPERATION_CURVE_NAMETOZ);
|
|
|
|
|
|
int count = 0, i;
|
|
|
double z;
|
|
|
POSITION pos, pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos = select.GetHeadPosition();
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = select.GetNext(pos);
|
|
|
pOne = pDoc->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE)continue;
|
|
|
pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
z = atof(pCurve->GetName());
|
|
|
|
|
|
pAction->Backup(pOne);
|
|
|
|
|
|
for (i = 0; i < pCurve->num; i++)
|
|
|
pCurve->z[i] = z;
|
|
|
if (pCurve->nPoint < 3)pCurve->nPoint = 3;
|
|
|
count++;
|
|
|
}
|
|
|
if (count > 0)
|
|
|
{
|
|
|
pAction->BackupNew();
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
pDoc->Modified();
|
|
|
}
|
|
|
else
|
|
|
delete pAction;
|
|
|
|
|
|
return count;
|
|
|
}
|
|
|
int CItemCurveProcess::SetZFromSurface(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
POSITION pos = GetDoc()->GetDraw()->FindFirstElement(DOUBLEFOX_MESH);
|
|
|
if (pos == NULL) {
|
|
|
return 0;
|
|
|
}
|
|
|
CMesh* pMesh = (CMesh*)GetDoc()->GetDraw()->GetAtValue(pos);
|
|
|
//for redo/undo
|
|
|
CActionBackupItem* pAction=new CActionBackupItem(pDoc, ID_PROCESS_SURFACE_LINEVALUE);
|
|
|
|
|
|
int count = 0;
|
|
|
COne* pOne;
|
|
|
POSITION pt;
|
|
|
|
|
|
CPointList dp;
|
|
|
dfPoint point;
|
|
|
double dx, dy;
|
|
|
pMesh->GetDelt(dx, dy);
|
|
|
|
|
|
CRect8 range = pMesh->GetRect();
|
|
|
CCurveEx *pCurve;
|
|
|
pos = select.GetHeadPosition();
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = select.GetNext(pos);
|
|
|
pOne = GetDoc()->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE) continue;
|
|
|
pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
if (!pCurve->IsInRange(range)) continue;
|
|
|
|
|
|
pAction->Backup(pt);
|
|
|
//switch (m_nLineValueMode)
|
|
|
//{
|
|
|
//case 0://<2F><><EFBFBD><EFBFBD>Դ<EFBFBD>ڵ<EFBFBD>
|
|
|
for (int i = 0; i < pCurve->num; i++)
|
|
|
{
|
|
|
if (!range.PtInRect(pCurve->x[i], pCurve->y[i]))continue;
|
|
|
pCurve->z[i] = pMesh->GetValue(pCurve->x[i], pCurve->y[i]);
|
|
|
if (pCurve->nPoint < 3)
|
|
|
{
|
|
|
pCurve->nPoint = 3;
|
|
|
}
|
|
|
}
|
|
|
// break;
|
|
|
//case 1://<2F><><EFBFBD>ݲ<EFBFBD><DDB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>²<EFBFBD>ֵ
|
|
|
// if (m_dLineValueStep < 1e-10)
|
|
|
// m_dLineValueStep = min(dx, dy);
|
|
|
// pCurve->GetPoint(0, point);
|
|
|
// if (range.PtInRect(point.x0, point.y0))
|
|
|
// point.z0 = pMesh->GetValue(point.x0, point.y0);
|
|
|
// dp.AddTail(point);
|
|
|
// {
|
|
|
// int si = 1;
|
|
|
// int i = 0;
|
|
|
// double l0 = pCurve->l[0] + m_dLineValueStep;
|
|
|
// double lmax = pCurve->l[pCurve->num - 1];
|
|
|
// if (pCurve->l[0] > pCurve->l[pCurve->num - 1])
|
|
|
// {
|
|
|
// l0 = pCurve->l[pCurve->num - 1] + m_dLineValueStep;
|
|
|
// lmax = pCurve->l[0];
|
|
|
// si = -1;
|
|
|
// i = pCurve->num - 2;
|
|
|
// }
|
|
|
// while (l0 < lmax)
|
|
|
// {
|
|
|
// if (l0 > pCurve->l[i])
|
|
|
// {
|
|
|
// pCurve->GetPoint(i, point);
|
|
|
// if (range.PtInRect(point.x0, point.y0))
|
|
|
// point.z0 = pMesh->GetValue(point.x0, point.y0);
|
|
|
// dp.AddTail(point);
|
|
|
// i += si;
|
|
|
// }
|
|
|
// point.l = l0;
|
|
|
// pCurve->GetCoordinate(point.l, point.x0, point.y0, point.z0);
|
|
|
// if (range.PtInRect(point.x0, point.y0))
|
|
|
// point.z0 = pMesh->GetValue(point.x0, point.y0);
|
|
|
// dp.AddTail(point);
|
|
|
// l0 += m_dLineValueStep;
|
|
|
// }
|
|
|
// }
|
|
|
|
|
|
// pCurve->GetPoint(pCurve->num - 1, point);
|
|
|
// if (range.PtInRect(point.x0, point.y0))
|
|
|
// point.z0 = pMesh->GetValue(point.x0, point.y0);
|
|
|
// dp.AddTail(point);
|
|
|
|
|
|
// if (pCurve->nPoint < 3) pCurve->nPoint = 3;
|
|
|
// pCurve->SetPoints(dp, pCurve->nPoint, pCurve->bAutoLocation);
|
|
|
// dp.RemoveAll();
|
|
|
// break;
|
|
|
//}
|
|
|
count++;
|
|
|
}
|
|
|
if (count > 0)
|
|
|
{
|
|
|
//GetDoc()->SetModifiedFlag();
|
|
|
pAction->BackupNew();
|
|
|
GetDoc()->SetActionItem(pAction);
|
|
|
}
|
|
|
else
|
|
|
delete pAction;
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::ZToName(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_OPERATION_CURVE_ZTONAME);
|
|
|
|
|
|
int count=0;
|
|
|
CString name;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
std::unique_ptr<CActionModifiedItem> pModifiedItem = std::make_unique<CActionModifiedItem>(GetDoc(), 0);
|
|
|
pModifiedItem->BackupOldItem(pt, pOne);
|
|
|
::AfxGetPublicFunction()->FloatToString(name,pCurve->z[0]);
|
|
|
pCurve->SetName(name);
|
|
|
pModifiedItem->BackupNewItem();
|
|
|
pAction->AddTailItem(pModifiedItem.release());
|
|
|
count++;
|
|
|
}
|
|
|
if (count > 0)
|
|
|
{
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
pDoc->Modified();
|
|
|
}
|
|
|
else
|
|
|
delete pAction;
|
|
|
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::LayerToName(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
//CActionListItem* pAction=new CActionListItem(pDoc, ID_OPERATION_CURVE_LAYER_TO_NAME);
|
|
|
//
|
|
|
int count=0;
|
|
|
CString name;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CLayerName ln;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
ln.SetPathName(pOne->m_pLayer->GetPathName());
|
|
|
name=ln.GetTailPathName();
|
|
|
//pAction->AddChangeNameItem(pt, pCurve->GetName(), name);
|
|
|
pCurve->SetName(name);
|
|
|
count++;
|
|
|
}
|
|
|
//if(count>0) pDoc->SetActionItem(pAction);
|
|
|
//else delete pAction;
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::NameLog(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CPropertiesSheet sheet(IDS_STRING_CURVE,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
if(!(a>1e-300 && a!=1.0) && m_bIsE==FALSE) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_OPERATION_CURVE_NAME_LOG);
|
|
|
|
|
|
CCurveEx* pCurve;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
double b;
|
|
|
CString name;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
b=atof(pCurve->GetName());
|
|
|
if(fabs(b)<1e-100) continue;
|
|
|
if(m_bIsE)//Ϊ<><CEAA>Ȼ<EFBFBD><C8BB><EFBFBD><EFBFBD>
|
|
|
b=log(b);
|
|
|
else
|
|
|
b=log(b)/log(a);
|
|
|
if(decimal==0) name.Format("%.0lf",b);
|
|
|
else ::AfxGetPublicFunction()->FloatToString(name,b,decimal);
|
|
|
|
|
|
pAction->AddChangeNameItem(pt, pCurve->GetName(), name);
|
|
|
pCurve->SetName(name);
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::NameExponential(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CPropertiesSheet sheet(IDS_STRING_CURVE,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
if(!(a>1e-300 && a!=1.0) && m_bIsE==FALSE) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_OPERATION_CURVE_NAME_EXPONENTIAL);
|
|
|
|
|
|
CCurveEx* pCurve;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
double b;
|
|
|
CString name;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
b=atof(pCurve->GetName());
|
|
|
if(fabs(b)<1e-100) continue;
|
|
|
if(m_bIsE)//Ϊ<><CEAA>Ȼ<EFBFBD><C8BB><EFBFBD><EFBFBD>
|
|
|
b=exp(b);
|
|
|
else
|
|
|
b=pow(a,b);
|
|
|
if(decimal==0) name.Format("%.0lf",b);
|
|
|
else ::AfxGetPublicFunction()->FloatToString(name,b,decimal);
|
|
|
|
|
|
pAction->AddChangeNameItem(pt, pCurve->GetName(), name);
|
|
|
pCurve->SetName(name);
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
struct CItemCruveProcessItem
|
|
|
{
|
|
|
CItemCruveProcessItem() = default;
|
|
|
|
|
|
CItemCruveProcessItem(uint64_t id, const CString &name, POSITION position)
|
|
|
{
|
|
|
this->id = id;
|
|
|
this->name = name;
|
|
|
this->position = position;
|
|
|
}
|
|
|
|
|
|
uint64_t id = 0;
|
|
|
CString name;
|
|
|
POSITION position;
|
|
|
};
|
|
|
|
|
|
static std::string ConvertCurvesOfEmptyNameToXML(const std::vector<CItemCruveProcessItem> & items);
|
|
|
|
|
|
std::string CItemCurveProcess::FindNameIsNull(CPositionList & selectionSet)
|
|
|
{
|
|
|
if (selectionSet.IsEmpty())
|
|
|
return "";
|
|
|
|
|
|
int count = 0;
|
|
|
int sel = 0;
|
|
|
POSITION pos, pt;
|
|
|
COne* pOne;
|
|
|
//CString type, txt;
|
|
|
//type.LoadString(IDS_STRING_CURVE);
|
|
|
pos = selectionSet.GetHeadPosition();
|
|
|
std::vector<CItemCruveProcessItem> curveItemArray;
|
|
|
CString numberStr;
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = selectionSet.GetNext(pos);
|
|
|
pOne = m_pDoc->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
continue;
|
|
|
|
|
|
if (((CCurveEx*)pOne->GetValue())->name != NULL)
|
|
|
continue;
|
|
|
|
|
|
curveItemArray.emplace_back(count + 1, pOne->GetLayer()->GetPathName(), pt);
|
|
|
count++;
|
|
|
}
|
|
|
|
|
|
return ConvertCurvesOfEmptyNameToXML(curveItemArray);
|
|
|
|
|
|
/*
|
|
|
CMainFrame* pmf = (CMainFrame*)GetDoc()->GetMainFrame();
|
|
|
ASSERT(pmf);
|
|
|
pmf->ShowPane(COMMAND_BAR_RESULT_LIST);
|
|
|
CListCtrl* pList=pmf->GetResultListCtrl();
|
|
|
ASSERT(pList);
|
|
|
pmf->m_pPaneResultList->InitList();
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
int count=0,sel;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CString type,txt;
|
|
|
type.LoadString(IDS_STRING_CURVE);
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
if(((CCurveEx*)pOne->GetValue())->name!=NULL)continue;
|
|
|
|
|
|
txt.Format("%ld",count+1);
|
|
|
sel=pList->InsertItem(count,txt);
|
|
|
pList->SetItemText(sel,2,type);
|
|
|
pList->SetItemText(sel,3,pOne->GetLayer()->GetPathName());
|
|
|
pList->SetItemData(sel,(DWORD)pOne);
|
|
|
|
|
|
count++;
|
|
|
}
|
|
|
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
|
|
|
int CItemCurveProcess::AnyName(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CPropertySheet sheet(IDS_STRING_PANE_PROPERTIES, GetView());
|
|
|
sheet.m_psh.dwFlags |= PSH_NOAPPLYNOW;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CEmbellishPage page;
|
|
|
//page.SetUnit(pDoc->GetDraw()->GetUnit());
|
|
|
page.SetUnitMode(GetUnitMode().m_unit, GetUnitMode().m_dScaleFactor, GetUnitMode().m_nMode);
|
|
|
sheet.AddPage(&page);
|
|
|
CHowToViewCurve* pHowToViewCurve=new CHowToViewCurve;
|
|
|
pHowToViewCurve->Add(new CCurveInNameAny());
|
|
|
page.SetHowToViewCurve(pHowToViewCurve);
|
|
|
delete pHowToViewCurve;
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
if(page.GetHowToViewCurve()==NULL) return 0;
|
|
|
|
|
|
ASSERT(GetPos());
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CPositionList select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CCurveEx* pCurve=(CCurveEx*)pDoc->GetDraw()->GetAtValue(GetPos());
|
|
|
CCurveEx* pcn;
|
|
|
|
|
|
CCurveInNameAny* pany;
|
|
|
int i,j;
|
|
|
for(i=0; i<page.GetHowToViewCurve()->GetCount(); ++i)
|
|
|
{
|
|
|
if(page.GetHowToViewCurve()->GetAt(i)->GetType()!=CurveInNameAny)continue;
|
|
|
j=i;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
CCrossPoint cp;
|
|
|
POSITION ts;
|
|
|
CCrossList xy;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
if(pt==GetPos())continue;
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
|
|
|
pcn=(CCurveEx*)pOne->GetValue();
|
|
|
pcn->Cross(*(CCurve*)pCurve,xy);
|
|
|
if(xy.IsEmpty()) continue;
|
|
|
|
|
|
if(pOne->HowToViewCurve==NULL)
|
|
|
pOne->HowToViewCurve=new CHowToViewCurve;
|
|
|
*pOne->HowToViewCurve=*page.GetHowToViewCurve();
|
|
|
|
|
|
pany=(CCurveInNameAny*)pOne->HowToViewCurve->GetAt(j);
|
|
|
pany->m_nameNum=(int)xy.GetCount();
|
|
|
pany->l0=new double[pany->m_nameNum];
|
|
|
ts=xy.GetHeadPosition();
|
|
|
for(i=0;i<pany->m_nameNum;i++)
|
|
|
{
|
|
|
cp=xy.GetNext(ts);
|
|
|
pany->l0[i]=cp.x[0];
|
|
|
}
|
|
|
xy.RemoveAll();
|
|
|
count++;
|
|
|
}
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
POSITION CItemCurveProcess::SelectOneCurve(UINT nFlags, CPoint point)
|
|
|
{
|
|
|
CSigmaDoc* pDoc=GetDoc();
|
|
|
CPoint2D rp=GetDC()->GetReal(point);
|
|
|
POSITION pos=NULL;
|
|
|
//if(pDoc->IsMoveSelect() && pDoc->MoveSelect!=NULL)
|
|
|
// pos=pDoc->MoveSelect;
|
|
|
//else
|
|
|
pos=pDoc->GetSelectedItem(rp);
|
|
|
if(pos==NULL)
|
|
|
{
|
|
|
::AfxMessageBox(IDS_STRING_NOT_ELEMENT);
|
|
|
return NULL;
|
|
|
}
|
|
|
else if(pDoc->GetDraw()->GetElementType(pos)!=DOUBLEFOX_CURVE)
|
|
|
{
|
|
|
::AfxMessageBox(IDS_STRING_IS_NOT_CURVE);
|
|
|
return NULL;
|
|
|
}
|
|
|
return pos;
|
|
|
}
|
|
|
|
|
|
void CItemCurveProcess::OnLButtonDown(CDC *pDC, UINT nFlags, CPoint point, int vk)
|
|
|
{
|
|
|
m_processResult = 0;
|
|
|
if(m_idea==CURVE_ANY_NAME && GetPos()==NULL)
|
|
|
{
|
|
|
position=SelectOneCurve(nFlags,point);
|
|
|
if(GetPos())OnDraw(GetDC());
|
|
|
}
|
|
|
else
|
|
|
CItemFocusRect::OnLButtonDown(pDC, nFlags,point, vk);
|
|
|
}
|
|
|
|
|
|
void CItemCurveProcess::OnRButtonDown(UINT nFlags, CPoint point)
|
|
|
{
|
|
|
m_processResult = 0;
|
|
|
switch(m_idea)
|
|
|
{
|
|
|
case CURVE_REVERSAL:
|
|
|
case CURVE_CLOSE:
|
|
|
//GetDoc()->EnableDefaultTool();
|
|
|
break;
|
|
|
default:
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
BOOL CItemCurveProcess::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message)
|
|
|
{
|
|
|
return TRUE;
|
|
|
/*
|
|
|
if(m_idea==CURVE_ANY_NAME && GetPos()==NULL)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
pDoc->GetCursor().SetCursor(CursorSelectItem);
|
|
|
return pDoc->GetCursor().SetCursor();
|
|
|
}
|
|
|
return CItemFocusRect::OnSetCursor(pWnd,nHitTest,message);
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
void CItemCurveProcess::OnDraw(CXyDC* pDC)
|
|
|
{
|
|
|
if(GetPos()==NULL) return;
|
|
|
CSigmaDoc * pDoc=GetDoc();
|
|
|
CCurveEx* pCurve=(CCurveEx*)pDoc->GetDraw()->GetAtValue(GetPos());
|
|
|
CItemLinkCurve item(pDoc);
|
|
|
item.Draw(pDC,pCurve,RGB(255,0,0));
|
|
|
}
|
|
|
|
|
|
int CItemCurveProcess::CurveSmooth(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CString str;
|
|
|
str.LoadString(IDS_GI_CURVE_PROCESS_SMOOTH_HEAD);
|
|
|
int i=str.Find("\n");
|
|
|
if(i>0) str=str.Left(i);
|
|
|
|
|
|
CPropertiesSheet sheet(str,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CPositionList select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_PROCESS_CURVE_SMOOTH);
|
|
|
|
|
|
CPointList bp;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
|
|
|
pAction->AddModifiedItem(pt, pOne);
|
|
|
switch(m_selSmooth)
|
|
|
{
|
|
|
default:
|
|
|
case 1:
|
|
|
pCurve->CurveToBezier(bp, a, FALSE);
|
|
|
break;
|
|
|
case 0:
|
|
|
pCurve->CurveToSpline(bp, a, FALSE);
|
|
|
break;
|
|
|
}
|
|
|
pCurve->SetPoints(bp, pCurve->nPoint, pCurve->bAutoLocation);
|
|
|
bp.RemoveAll();
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::ToWave(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CString str;
|
|
|
str.LoadString(ID_PROCESS_CURVE_TO_WAVE);
|
|
|
int i=str.Find("\n");
|
|
|
if(i>0) str=str.Left(i);
|
|
|
|
|
|
CPropertiesSheet sheet(str,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_PROCESS_CURVE_TO_WAVE);
|
|
|
|
|
|
CPointList bp;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
COne* pNewOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
if(m_bDeleteSourveCurve)
|
|
|
{
|
|
|
if(pCurve->CurveToWave(bp, cycle, swing, dnum)>0)
|
|
|
{
|
|
|
pAction->AddModifiedItem(pt, pOne);
|
|
|
pCurve->SetPoints(bp, pCurve->nPoint, pCurve->bAutoLocation);
|
|
|
bp.RemoveAll();
|
|
|
count++;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pNewOne=new COne;
|
|
|
*pNewOne=*pOne;
|
|
|
pCurve=(CCurveEx*)pNewOne->GetValue();
|
|
|
if(pCurve->CurveToWave(bp, cycle, swing, dnum)>0)
|
|
|
{
|
|
|
pCurve->SetPoints(bp, pCurve->nPoint, pCurve->bAutoLocation);
|
|
|
pDoc->AddElement(pNewOne);
|
|
|
pAction->AddAddItem(pNewOne);
|
|
|
bp.RemoveAll();
|
|
|
count++;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::CurveOffset(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CString str;
|
|
|
str.LoadString(ID_PROCESS_CURVE_OFFSET);
|
|
|
int i=str.Find("\n");
|
|
|
if(i>0) str=str.Left(i);
|
|
|
|
|
|
CPropertiesSheet sheet(str,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_PROCESS_CURVE_OFFSET);
|
|
|
|
|
|
CPointList bp;
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pNewOne;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
if(m_bDeleteSourveCurve)
|
|
|
{
|
|
|
pAction->AddModifiedItem(pt, pOne);
|
|
|
(*(CCurve*)pCurve) += m_dCurveOffset;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
pNewOne=new COne;
|
|
|
*pNewOne=*pOne;
|
|
|
(*(CCurve*)pNewOne->GetValue()) += m_dCurveOffset;
|
|
|
pDoc->AddElement(pNewOne);
|
|
|
pAction->AddAddItem(pNewOne);
|
|
|
}
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::NodeEncrypt(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CString str;
|
|
|
str.LoadString(ID_PROCESS_CURVE_ENCRYPT);
|
|
|
int i=str.Find("\n");
|
|
|
if(i>0) str=str.Left(i);
|
|
|
|
|
|
CPropertiesSheet sheet(str,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_PROCESS_CURVE_ENCRYPT);
|
|
|
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
|
|
|
pAction->AddModifiedItem(pt, pOne);
|
|
|
pCurve->EncryptNode(m_nMode, m_dStep, m_bInteger);
|
|
|
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::ToRedundant(void)
|
|
|
{
|
|
|
return 0;
|
|
|
/*
|
|
|
CString str;
|
|
|
str.LoadString(ID_PROCESS_CURVE_REDUNDANT);
|
|
|
int i=str.Find("\n");
|
|
|
if(i>0) str=str.Left(i);
|
|
|
|
|
|
CPropertiesSheet sheet(str,GetView(),0,FALSE);
|
|
|
sheet.SetItem(this);
|
|
|
if(sheet.DoModal()!=IDOK) return 0;
|
|
|
|
|
|
CDFDrawProDoc* pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CList<POSITION,POSITION> select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(pDoc, ID_PROCESS_CURVE_REDUNDANT);
|
|
|
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE)continue;
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
|
|
|
pAction->AddModifiedItem(pt, pOne);
|
|
|
|
|
|
CCurveEx* pc=new CCurveEx;
|
|
|
*pc=*pCurve;
|
|
|
CCurveRedundant cr(*pc);
|
|
|
cr.Execute(m_error);
|
|
|
cr.GetRedundantCurve(*pCurve);
|
|
|
if(pCurve->bAutoLocation)
|
|
|
pCurve->GetLocation();
|
|
|
delete pc;
|
|
|
|
|
|
count++;
|
|
|
}
|
|
|
if(count>0) pDoc->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
return count;
|
|
|
*/
|
|
|
}
|
|
|
|
|
|
|
|
|
void NItem::CItemCurveProcess::SetCurveStyle(CHowToViewCurve& curveStyle)
|
|
|
{
|
|
|
this->m_CurveStyle = curveStyle;
|
|
|
}
|
|
|
|
|
|
|
|
|
int CItemCurveProcess::ArcToCurve(CPositionList & select, double step)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
CRect8 rect = this->GetRect();
|
|
|
//CPositionList select;
|
|
|
//pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
//if(select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
CActionBackupItem* pAction = new CActionBackupItem(pDoc, ID_PROCESS_ARC_TO_CURVE);
|
|
|
|
|
|
COne* pOne;
|
|
|
// COne *pOneOther;
|
|
|
CArc* parc;
|
|
|
CEllipse* pEll;
|
|
|
CCurveEx* pc;
|
|
|
int c = 0;
|
|
|
POSITION pos, pt;
|
|
|
pos = select.GetHeadPosition();
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = select.GetNext(pos);
|
|
|
pOne = pDoc->GetDraw()->GetAt(pt);
|
|
|
switch (pOne->GetType())
|
|
|
{
|
|
|
default:
|
|
|
continue;
|
|
|
case DOUBLEFOX_ARC:
|
|
|
pAction->Backup(pOne);
|
|
|
parc = (CArc*)pOne->GetValue();
|
|
|
pc = new CCurveEx;
|
|
|
parc->GetCurve(a);
|
|
|
*pc = *parc->GetCurve();
|
|
|
break;
|
|
|
case DOUBLEFOX_CIRCLE:
|
|
|
case DOUBLEFOX_ELLIPSE:
|
|
|
pAction->Backup(pOne);
|
|
|
pEll = (CEllipse*)pOne->GetValue();
|
|
|
pc = pEll->ToCurve(a);
|
|
|
break;
|
|
|
case DOUBLEFOX_CRECT:
|
|
|
pAction->Backup(pOne);
|
|
|
pc = new CCurveEx;
|
|
|
((CCurveRect*)pOne->GetValue())->GetCurve(*pc);
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
//<2F><><EFBFBD>ݣ<EFBFBD>Ϊ<EFBFBD><CEAA>redo undo
|
|
|
//pOneOther=new COne;
|
|
|
//*pOneOther=*pOne;
|
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD>ת<EFBFBD><D7AA>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD>
|
|
|
pOne->ClearValue();
|
|
|
pOne->SetValue(pc, DOUBLEFOX_CURVE);
|
|
|
c++;
|
|
|
}
|
|
|
if (c > 0)
|
|
|
{
|
|
|
pAction->BackupNew();
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
pDoc->Modified();
|
|
|
}
|
|
|
else
|
|
|
delete pAction;
|
|
|
|
|
|
return c;
|
|
|
}
|
|
|
|
|
|
void NItem::CItemCurveProcess::SetCurveName(CString curveName, CPositionList & selectionSet)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
CActionListItem* pAction = new CActionListItem(pDoc, ID_OPERATION_CURVE_CONTOUR);
|
|
|
|
|
|
CCurveEx* pCurve;
|
|
|
int count = 0;
|
|
|
POSITION pos, pt;
|
|
|
COne* pOne;
|
|
|
pos = selectionSet.GetHeadPosition();
|
|
|
while (pos)
|
|
|
{
|
|
|
pt = selectionSet.GetNext(pos);
|
|
|
pOne = pDoc->GetDraw()->GetAt(pt);
|
|
|
if (pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
continue;
|
|
|
|
|
|
pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
pAction->AddChangeNameItem(pt, pCurve->GetName(), curveName);
|
|
|
pCurve->SetName(curveName);
|
|
|
count++;
|
|
|
}
|
|
|
|
|
|
if (count > 0)
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
else
|
|
|
delete pAction;
|
|
|
|
|
|
//return count;
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::CloseCurve(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc = GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CPositionList select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
//for redo/undo
|
|
|
CActionBackupItem* pAction=new CActionBackupItem(pDoc, ID_OPERATION_CURVE_CLOSE);
|
|
|
|
|
|
int count=0;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
CCurveEx* pCurve;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if(pOne->GetType()!=DOUBLEFOX_CURVE) continue;
|
|
|
|
|
|
pAction->Backup(pOne);
|
|
|
|
|
|
pCurve=(CCurveEx*)pOne->GetValue();
|
|
|
if(!pCurve->EnableClose(TRUE)) //<2F><><EFBFBD>ò<EFBFBD><C3B2>ɹ<EFBFBD>ʱ<EFBFBD><CAB1>ɾ<EFBFBD><C9BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
{
|
|
|
pAction->RemoveBackupTail();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (pCurve->bAutoLocation)
|
|
|
{
|
|
|
pCurve->GetLocation();
|
|
|
}
|
|
|
count++;
|
|
|
}
|
|
|
}
|
|
|
if (count > 0)
|
|
|
{
|
|
|
pAction->BackupNew();
|
|
|
pDoc->SetActionItem(pAction);
|
|
|
pDoc->Modified();
|
|
|
}
|
|
|
else
|
|
|
delete pAction;
|
|
|
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::AutoLinkCurve(double maxError /*= 1E-5*/, bool onlySameName)
|
|
|
{
|
|
|
double dMaxError = maxError == 0 ? 0.0001 : maxError;
|
|
|
|
|
|
int count=0;
|
|
|
CClassList* pClassList= GetDoc()->GetDraw()->GetClassList();
|
|
|
CLayerList* pLayerList;
|
|
|
CLayer* pLayer;
|
|
|
CPositionList select;
|
|
|
|
|
|
double num=pClassList->GetLayerCount();
|
|
|
|
|
|
CActionListItem* pAction=new CActionListItem(GetDoc(), ID_PROCESS_CURVE_AUTO_LINK);
|
|
|
POSITION pos, pt;
|
|
|
pos=pClassList->GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pLayerList=pClassList->GetNext(pos);
|
|
|
|
|
|
pt=pLayerList->GetHeadPosition();
|
|
|
while(pt)
|
|
|
{
|
|
|
pLayer=pLayerList->GetNext(pt);
|
|
|
select.RemoveAll();
|
|
|
CXyElementFilter filter;
|
|
|
filter.addLayer(pLayer->GetName(), true)
|
|
|
.addType(DOUBLEFOX_CURVE)
|
|
|
.setIncludeHidden(false)
|
|
|
.setIncludeNotEditable(false);
|
|
|
|
|
|
if(GetDoc()->GetDraw()->GetElement(filter, select)<1) continue;
|
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ߣ<EFBFBD><DFA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӵ<EFBFBD><D3B5><EFBFBD><EFBFBD>߱<EFBFBD><DFB1><EFBFBD><EFBFBD><EFBFBD>ͬһ<CDAC><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>µ<EFBFBD><C2B5><EFBFBD><EFBFBD><EFBFBD>
|
|
|
while(1)
|
|
|
{
|
|
|
if(select.GetCount()<=1) break;
|
|
|
int n=GetNextLinkCurve(select, pAction, dMaxError, onlySameName);
|
|
|
count+=n;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if(count>0) GetDoc()->SetActionItem(pAction);
|
|
|
else delete pAction;
|
|
|
|
|
|
return count;
|
|
|
}
|
|
|
|
|
|
int NItem::CItemCurveProcess::GetNextLinkCurve(CPositionList& select, void* pActionList, double maxError, bool onlySameName)
|
|
|
{
|
|
|
if(select.GetCount()<=1) return 0;
|
|
|
CActionListItem* pAction=(CActionListItem*)pActionList;
|
|
|
|
|
|
POSITION pos, posBak, posHead, posNext;
|
|
|
CPointList bp;
|
|
|
dfPoint head, tail;
|
|
|
|
|
|
int sel; //1(head,head),2(head,tail),3(tail,head),4(tail,tail)
|
|
|
double dis, dis_tail;
|
|
|
CCurveEx* pCurve;
|
|
|
int total=0;
|
|
|
int count=0; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ߵ<EFBFBD><DFB5><EFBFBD><EFBFBD><EFBFBD>
|
|
|
|
|
|
CSigmaDoc* pDoc=GetDoc();
|
|
|
posHead=select.GetHead();
|
|
|
COne* pHeadOne=pDoc->GetDraw()->GetAt(posHead);
|
|
|
CCurveEx* pHeadCurve=(CCurveEx*)pHeadOne->GetValue();
|
|
|
select.RemoveHead(); //ȥ<><C8A5><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
if(::AfxGetPublicFunction()->IsCurveSolid(pHeadCurve->m_type)) return 0;
|
|
|
|
|
|
pHeadCurve->GetPoint(bp);
|
|
|
|
|
|
head=bp.GetHead();
|
|
|
tail=bp.GetTail();
|
|
|
CString strCurveName = pHeadCurve->GetName();
|
|
|
while(1)
|
|
|
{
|
|
|
count=0;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
posBak=pos;
|
|
|
posNext=select.GetNext(pos);
|
|
|
pCurve=(CCurveEx*)pDoc->GetDraw()->GetAtValue(posNext);
|
|
|
if(::AfxGetPublicFunction()->IsCurveSolid(pCurve->m_type)) continue;
|
|
|
if (onlySameName)
|
|
|
{
|
|
|
CString strCurveNameNext = pCurve->GetName();
|
|
|
if (strCurveNameNext != strCurveName) {
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
sel=1;
|
|
|
dis=::AfxGetPublicFunction()->Distance2(head.x0, head.y0, pCurve->x[0], pCurve->y[0]);
|
|
|
dis_tail=::AfxGetPublicFunction()->Distance2(head.x0, head.y0, pCurve->x[pCurve->num-1], pCurve->y[pCurve->num-1]);
|
|
|
if(dis>dis_tail) {sel=2; dis=dis_tail;}
|
|
|
dis_tail=::AfxGetPublicFunction()->Distance2(tail.x0, tail.y0, pCurve->x[0], pCurve->y[0]);
|
|
|
if(dis>dis_tail) {sel=3; dis=dis_tail;}
|
|
|
dis_tail=::AfxGetPublicFunction()->Distance2(tail.x0, tail.y0, pCurve->x[pCurve->num-1], pCurve->y[pCurve->num-1]);
|
|
|
if(dis>dis_tail) {sel=4; dis=dis_tail;}
|
|
|
dis=sqrt(dis);
|
|
|
if(dis> maxError) continue;
|
|
|
|
|
|
switch(sel)
|
|
|
{
|
|
|
case 1://head,head
|
|
|
pCurve->GetPoint(bp, FALSE, TRUE);
|
|
|
break;
|
|
|
case 2://head,tail
|
|
|
pCurve->GetPoint(bp, TRUE, TRUE);
|
|
|
break;
|
|
|
case 3://tail,head
|
|
|
pCurve->GetPoint(bp, FALSE, FALSE);
|
|
|
break;
|
|
|
case 4://tail,tail
|
|
|
pCurve->GetPoint(bp, TRUE, FALSE);
|
|
|
break;
|
|
|
}
|
|
|
pAction->AddDeleteItem(posNext);
|
|
|
count++;
|
|
|
select.RemoveAt(posBak);
|
|
|
|
|
|
head=bp.GetHead();
|
|
|
tail=bp.GetTail();
|
|
|
}
|
|
|
if(count==0) break;
|
|
|
total+=count;
|
|
|
}
|
|
|
if(total==0) return 0;
|
|
|
|
|
|
pAction->AddDeleteItem(posHead);
|
|
|
total++;
|
|
|
|
|
|
pCurve=new CCurveEx;
|
|
|
*pCurve=*pHeadCurve;
|
|
|
pCurve->SetPoints(bp, 2);
|
|
|
COne* pNewOne=new COne;
|
|
|
pNewOne->CloneOtherParameter(*pHeadOne);
|
|
|
pNewOne->value=pCurve;
|
|
|
pos=pDoc->GetDraw()->InsertElementBefore(posHead, pNewOne);
|
|
|
|
|
|
pAction->AddAddItem(pNewOne);
|
|
|
total++;
|
|
|
return total;
|
|
|
}
|
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɢ<EFBFBD><C9A2><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD>γ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
int NItem::CItemCurveProcess::FittingCurve(void)
|
|
|
{
|
|
|
CSigmaDoc * pDoc=GetDoc();
|
|
|
CRect8 rect=this->GetRect();
|
|
|
CPositionList select;
|
|
|
pDoc->GetDraw()->IsInRange(rect,select);
|
|
|
if(select.IsEmpty()) return 0;
|
|
|
|
|
|
CPointList bp;
|
|
|
dfPoint point;
|
|
|
CPointNameEx* pp;
|
|
|
POSITION pos,pt;
|
|
|
COne* pOne;
|
|
|
pos=select.GetHeadPosition();
|
|
|
while(pos)
|
|
|
{
|
|
|
pt=select.GetNext(pos);
|
|
|
pOne=pDoc->GetDraw()->GetAt(pt);
|
|
|
if( pOne->GetType()!=DOUBLEFOX_POINT && pOne->GetType() != DOUBLEFOX_XYZ)
|
|
|
continue;
|
|
|
pp=(CPointNameEx*)pOne->GetValue();
|
|
|
point.x0 = pp->x0;
|
|
|
point.y0 = pp->y0;
|
|
|
bp.AddTail(point);
|
|
|
}
|
|
|
|
|
|
if(bp.GetCount()<=1) return 0;
|
|
|
CCurveEx* pCurve = new CCurveEx;
|
|
|
pCurve->SetPoints(bp, 2);
|
|
|
if(pCurve->num>2)
|
|
|
{
|
|
|
::AfxGetBaseFunction()->SortCoordinate(pCurve->x, pCurve->y, pCurve->num);
|
|
|
pCurve->GetLocation();
|
|
|
}
|
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
pos=pDoc->GetDraw()->AddElement(pCurve, DOUBLEFOX_CURVE);
|
|
|
if(pos) pDoc->Invalidate(pos);
|
|
|
pDoc->Modified();
|
|
|
|
|
|
//Redo/Undo surport
|
|
|
pOne=pDoc->GetDraw()->GetAt(pos);
|
|
|
GetView()->ActionAdd(pOne, ID_PROCESS_CURVE_FITTING);
|
|
|
|
|
|
return 1;
|
|
|
}
|
|
|
|
|
|
static void AddCurvesElement(TiXmlElement *rootElement, uint64_t id, const CString & pathName, POSITION position)
|
|
|
{
|
|
|
CString name, txt;
|
|
|
TiXmlElement *itemElement = new TiXmlElement("Item");
|
|
|
rootElement->LinkEndChild(itemElement);
|
|
|
TiXmlElement *idElement = new TiXmlElement("ID");
|
|
|
TiXmlElement *nameElement = new TiXmlElement("Name");
|
|
|
TiXmlElement *typeElement = new TiXmlElement("Type");
|
|
|
TiXmlElement *layerElement = new TiXmlElement("Layer");
|
|
|
TiXmlElement *symbolElement = new TiXmlElement("Symbol");
|
|
|
TiXmlElement *lengthElement = new TiXmlElement("RealLength");
|
|
|
TiXmlElement *areaElement = new TiXmlElement("Area");
|
|
|
TiXmlElement *azimuthElement = new TiXmlElement("Azimuth");
|
|
|
TiXmlElement *positionElement = new TiXmlElement("Position");
|
|
|
TiXmlElement *xElement = new TiXmlElement("X");
|
|
|
TiXmlElement *yElement = new TiXmlElement("Y");
|
|
|
TiXmlElement *zElement = new TiXmlElement("Z");
|
|
|
itemElement->LinkEndChild(idElement);
|
|
|
//TiXmlElement *zElement = new TiXmlElement("Z");
|
|
|
|
|
|
itemElement->LinkEndChild(idElement);
|
|
|
itemElement->LinkEndChild(nameElement);
|
|
|
itemElement->LinkEndChild(typeElement);
|
|
|
itemElement->LinkEndChild(layerElement);
|
|
|
itemElement->LinkEndChild(symbolElement);
|
|
|
itemElement->LinkEndChild(lengthElement);
|
|
|
itemElement->LinkEndChild(areaElement);
|
|
|
itemElement->LinkEndChild(azimuthElement);
|
|
|
itemElement->LinkEndChild(positionElement);
|
|
|
itemElement->LinkEndChild(xElement);
|
|
|
itemElement->LinkEndChild(yElement);
|
|
|
itemElement->LinkEndChild(zElement);
|
|
|
|
|
|
TiXmlText *idValue = new TiXmlText(std::to_string(id).c_str());
|
|
|
idElement->LinkEndChild(idValue);
|
|
|
|
|
|
TiXmlText *layerValue = new TiXmlText(pathName);
|
|
|
layerElement->LinkEndChild(layerValue);
|
|
|
|
|
|
positionElement->LinkEndChild(new TiXmlText(std::to_string((uint64_t)position).c_str()));
|
|
|
|
|
|
TiXmlText * typeValue = new TiXmlText("<EFBFBD><EFBFBD><EFBFBD><EFBFBD>");
|
|
|
typeElement->LinkEndChild(typeValue);
|
|
|
}
|
|
|
|
|
|
//<2F><><EFBFBD><EFBFBD>xml<6D>ַ<EFBFBD><D6B7><EFBFBD>
|
|
|
static std::string ConvertCurvesOfEmptyNameToXML(const std::vector<CItemCruveProcessItem> & items)
|
|
|
{
|
|
|
// <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>XML<4D><4C><EFBFBD>ĵ<EFBFBD><C4B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
|
|
TiXmlDocument *xmlDocument = new TiXmlDocument();
|
|
|
TiXmlDeclaration * decl = new TiXmlDeclaration("1.0", "UTF-8", "");
|
|
|
xmlDocument->LinkEndChild(decl);
|
|
|
// <20><>Ԫ<EFBFBD>ء<EFBFBD>
|
|
|
TiXmlElement *rootElement = new TiXmlElement("ROOT");
|
|
|
xmlDocument->LinkEndChild(rootElement);
|
|
|
|
|
|
size_t count = items.size();
|
|
|
|
|
|
for (const auto &item : items)
|
|
|
{
|
|
|
AddCurvesElement(rootElement, item.id, item.name, item.position);
|
|
|
}
|
|
|
|
|
|
TiXmlPrinter printer;
|
|
|
string xmlstr;
|
|
|
xmlDocument->Accept(&printer);
|
|
|
xmlstr = printer.CStr();
|
|
|
|
|
|
return std::string(printer.CStr());
|
|
|
} |