|
|
#include "pch.h"
|
|
|
#include "IDWCreator.h"
|
|
|
#include <array>
|
|
|
#include "IDWCalculation.h"
|
|
|
#include <ppl.h>
|
|
|
#include <time.h>
|
|
|
|
|
|
|
|
|
|
|
|
int StepProgress::stepCount = 0;
|
|
|
int StepProgress::progress = 0;
|
|
|
int StepProgress::lastProgress = 0;
|
|
|
CPPCallback StepProgress::DoProgress = nullptr;
|
|
|
|
|
|
using namespace concurrency;
|
|
|
|
|
|
//int StepProgress::stepCount = 0;
|
|
|
//int StepProgress::progress = 0;
|
|
|
CIDWCreator::CIDWCreator()
|
|
|
{
|
|
|
//DoProgress = nullptr;
|
|
|
}
|
|
|
|
|
|
CIDWCreator::~CIDWCreator()
|
|
|
{
|
|
|
|
|
|
}
|
|
|
// 坐标转换
|
|
|
//inline double ConvertX2D(int64_t source, DPoint3& ptOrigin) {
|
|
|
// return source / 100.0 + ptOrigin.x;
|
|
|
//}
|
|
|
//inline double ConvertY2D(int64_t source, DPoint3& ptOrigin) {
|
|
|
// return source / 100.0 + ptOrigin.y;
|
|
|
//}
|
|
|
inline int64_t ConvertX2Int(double source, DPoint3& ptOrigin) {
|
|
|
return (source - ptOrigin.x) * 100;
|
|
|
}
|
|
|
inline int64_t ConvertY2Int(double source, DPoint3& ptOrigin) {
|
|
|
return (source - ptOrigin.y) * 100;
|
|
|
}
|
|
|
//void CALLBACK EXPORT TimerProc(
|
|
|
// HWND hWnd, // handle of CWnd that called SetTimer
|
|
|
// UINT nMsg, // WM_TIMER
|
|
|
// UINT_PTR nIDEvent, // timer identification
|
|
|
// DWORD dwTime // system time
|
|
|
//)
|
|
|
//{
|
|
|
// if (StepProgress::DoProgress != nullptr) {
|
|
|
// StepProgress::DoProgress(_T("网格化"), (int)(((double)StepProgress::progress / StepProgress::stepCount)*100.0));
|
|
|
// }
|
|
|
//}
|
|
|
//************************************
|
|
|
// Method: Create
|
|
|
// FullName: CIDWCreator::Create
|
|
|
// Access: public
|
|
|
// Returns: void
|
|
|
// Qualifier:
|
|
|
// Parameter: CString xyzFile
|
|
|
// Parameter: CString borderFile
|
|
|
// Parameter: int XCount
|
|
|
// Parameter: int insertTimes
|
|
|
//************************************
|
|
|
void CIDWCreator::Create(CString xyzFile, CString borderFile, CString faultFile, CString resultFile,
|
|
|
int XCount, double smoothFactor, int smoothTimes, CPPCallback callBack,
|
|
|
int insertTimes, double contourStep, int contourMarkStep
|
|
|
, double xMin/* = -1*/, double yMin/* = -1*/, double xMax, double yMax) // double dSearchDistance,
|
|
|
{
|
|
|
StepProgress::DoProgress = callBack;
|
|
|
// 读取散点
|
|
|
vector<array<double, 3>> dataXyz;
|
|
|
std::string strXyzFile = string(xyzFile);
|
|
|
ReadInToMatrix(strXyzFile, dataXyz);
|
|
|
size_t len = dataXyz.size();
|
|
|
if (len < 5) {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
ptO.x = dataXyz[0][0];
|
|
|
ptO.y = dataXyz[0][1];
|
|
|
double dZMin = 1E100;
|
|
|
double dZMax = -1E100;
|
|
|
vector<DPoint3>* pPts = new vector<DPoint3>();
|
|
|
|
|
|
for (int i = 0; i < len; i++)
|
|
|
{
|
|
|
DPoint3 pt;
|
|
|
//pt.x = ConvertX2Int(dataXyz[i][0], ptO);
|
|
|
//pt.y = ConvertY2Int(dataXyz[i][1], ptO);
|
|
|
pt.x = dataXyz[i][0];
|
|
|
pt.y = dataXyz[i][1];
|
|
|
pt.z = dataXyz[i][2];
|
|
|
pPts->push_back(pt);
|
|
|
|
|
|
if (pt.z > dZMax) {
|
|
|
dZMax = pt.z;
|
|
|
}
|
|
|
if (pt.z < dZMin) {
|
|
|
dZMin = pt.z;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
parallel_sort(pPts->begin(), pPts->end(), IDWCalculation::PointSort);
|
|
|
|
|
|
// 读取边界文件
|
|
|
CCurveEx* pCurveBorder = nullptr;
|
|
|
CPositionList list;
|
|
|
CXy* pXyBorder = new CXy;
|
|
|
if (!borderFile.IsEmpty() && borderFile != "NULL")
|
|
|
{
|
|
|
OpenFile(borderFile, pXyBorder);
|
|
|
}
|
|
|
|
|
|
POSITION posBorder = NULL;
|
|
|
if (pXyBorder->GetElement(DOUBLEFOX_CURVE, list) > 0)
|
|
|
{
|
|
|
posBorder = list.GetHead();
|
|
|
pCurveBorder = (CCurveEx*)(pXyBorder->GetAtValue(posBorder));
|
|
|
//for (int i = 0; i < pCurveBorder->num; i++) {
|
|
|
// pCurveBorder->x[i] = ConvertX2Int(pCurveBorder->x[i], ptO);
|
|
|
// pCurveBorder->y[i] = ConvertY2Int(pCurveBorder->y[i], ptO);
|
|
|
//}
|
|
|
}
|
|
|
|
|
|
// 断层读取
|
|
|
CXy* pXyFaults = new CXy;
|
|
|
if (!faultFile.IsEmpty() && faultFile != "NULL") {
|
|
|
OpenFile(faultFile, pXyFaults);
|
|
|
}
|
|
|
|
|
|
//PathD lineClip;
|
|
|
//lineClip.push_back(PointD(5461.995, 7790.803));
|
|
|
//lineClip.push_back(PointD(5572.185351, 7918.825292));
|
|
|
//PathsD clip, solutionClosed, solutionOpen;
|
|
|
//clip.push_back(lineClip);
|
|
|
//ClipperD clipperD;
|
|
|
//clipperD.AddOpenSubject(clip);
|
|
|
//clipperD.AddClip(faultages);
|
|
|
//clipperD.Execute(ClipType::Intersection, FillRule::NonZero, solutionClosed, solutionOpen);
|
|
|
//if (solutionOpen.size() > 0) {
|
|
|
// for (int i = 0; i < solutionOpen.size(); i++) {
|
|
|
// TRACE("Pline\r\n");
|
|
|
// for (int j = 0; j < solutionOpen[i].size(); j++) {
|
|
|
// TRACE("%lf,%lf\r\n", solutionOpen[i][j].x, solutionOpen[i][j].y);
|
|
|
// }
|
|
|
// TRACE("\r\n");
|
|
|
// }
|
|
|
//}
|
|
|
//if (solutionClosed.size() > 0) {
|
|
|
// for (int i = 0; i < solutionClosed.size(); i++) {
|
|
|
// TRACE("Pline\r\n");
|
|
|
// for (int j = 0; j < solutionClosed[i].size(); j++) {
|
|
|
// TRACE("%lf,%lf\r\n", solutionClosed[i][j].x, solutionClosed[i][j].y);
|
|
|
// }
|
|
|
// TRACE("\r\n");
|
|
|
// }
|
|
|
//}
|
|
|
//return;
|
|
|
m_XMin = 1E100;
|
|
|
m_YMin = 1E100;
|
|
|
m_XMax = -1E100;
|
|
|
m_YMax = -1E100;
|
|
|
if (pCurveBorder != nullptr&&pCurveBorder->num >= 3)
|
|
|
{
|
|
|
CRect8 range;
|
|
|
range.SetRect(1e100, -1e100, -1e100, 1e100);
|
|
|
pCurveBorder->GetRange(range);
|
|
|
|
|
|
m_XMin = range.left;
|
|
|
m_XMax = range.right;
|
|
|
m_YMin = range.bottom;
|
|
|
m_YMax = range.top;
|
|
|
|
|
|
//m_XMin = ConvertX2Int(m_XMin, ptO);
|
|
|
//m_XMax = ConvertX2Int(m_XMax, ptO);
|
|
|
//m_YMin = ConvertY2Int(m_YMin, ptO);
|
|
|
//m_YMax = ConvertY2Int(m_YMax, ptO);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (xMin > 0 && yMin > 0)
|
|
|
{ // 指定坐标范围
|
|
|
m_XMin = xMin;
|
|
|
m_YMin = yMin;
|
|
|
m_XMax = xMax;
|
|
|
m_YMax = yMax;
|
|
|
}
|
|
|
else {
|
|
|
for (auto& v : dataXyz) {
|
|
|
if (v[0] < m_XMin)
|
|
|
{
|
|
|
m_XMin = v[0];
|
|
|
}
|
|
|
if (v[0] > m_XMax)
|
|
|
{
|
|
|
m_XMax = v[0];
|
|
|
}
|
|
|
if (v[1] < m_YMin)
|
|
|
{
|
|
|
m_YMin = v[1];
|
|
|
}
|
|
|
if (v[1] > m_YMax)
|
|
|
{
|
|
|
m_YMax = v[1];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
//m_XMin = ConvertX2Int(m_XMin, ptO);
|
|
|
//m_XMax = ConvertX2Int(m_XMax, ptO);
|
|
|
//m_YMin = ConvertY2Int(m_YMin, ptO);
|
|
|
//m_YMax = ConvertY2Int(m_YMax, ptO);
|
|
|
|
|
|
pCurveBorder = new CCurveEx;
|
|
|
CPointList bp;
|
|
|
dfPoint point;
|
|
|
point.x0 = m_XMin;
|
|
|
point.y0 = m_YMin;
|
|
|
bp.AddTail(point);
|
|
|
|
|
|
point.x0 = m_XMin;
|
|
|
point.y0 = m_YMax;
|
|
|
bp.AddTail(point);
|
|
|
|
|
|
point.x0 = m_XMax;
|
|
|
point.y0 = m_YMax;
|
|
|
bp.AddTail(point);
|
|
|
|
|
|
point.x0 = m_XMax;
|
|
|
point.y0 = m_YMin;
|
|
|
bp.AddTail(point);
|
|
|
|
|
|
point.x0 = m_XMin;
|
|
|
point.y0 = m_YMin;
|
|
|
bp.AddTail(point);
|
|
|
|
|
|
pCurveBorder->SetPoints(bp, 2);
|
|
|
pXyBorder->AddElement(pCurveBorder, DOUBLEFOX_CURVE);
|
|
|
}
|
|
|
ptO.x = m_XMin;
|
|
|
ptO.y = m_YMin;
|
|
|
// 散点归整
|
|
|
for (int i = 0; i < len; i++)
|
|
|
{
|
|
|
pPts->at(i).x = ConvertX2Int(pPts->at(i).x, ptO);
|
|
|
pPts->at(i).y = ConvertY2Int(pPts->at(i).y, ptO);
|
|
|
}
|
|
|
// 归整断层
|
|
|
Paths64 faultages;
|
|
|
if (pXyFaults != nullptr) {
|
|
|
COne* pOne;
|
|
|
CPtrList* pl = pXyFaults->GetValueList();
|
|
|
POSITION pos = pl->GetHeadPosition();
|
|
|
while (pos)
|
|
|
{
|
|
|
pOne = pXyFaults->GetAt(pos);
|
|
|
if (pOne->GetType() == DOUBLEFOX_CURVE) {
|
|
|
CCurveEx* pCurve = (CCurveEx*)(pOne->GetValue());
|
|
|
Path64 path;
|
|
|
for (int i = 0; i < pCurve->num; i++) {
|
|
|
int64_t x = ConvertX2Int(pCurve->x[i], ptO);
|
|
|
int64_t y = ConvertY2Int(pCurve->y[i], ptO);
|
|
|
path.push_back(Point64(x, y));
|
|
|
}
|
|
|
faultages.push_back(path);
|
|
|
}
|
|
|
pl->GetNext(pos);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 计算步长、网格数
|
|
|
//int nInsertCount = pow(2, insertTimes); // 插入网格个数
|
|
|
this->m_XCount = XCount;
|
|
|
this->m_dX = (m_XMax - m_XMin) / (this->m_XCount);
|
|
|
//double dDxInsert = this->m_dX / nInsertCount;
|
|
|
//int nXCountInsert = (m_XMax - m_XMin) / dDxInsert;
|
|
|
|
|
|
this->m_dY = this->m_dX;
|
|
|
//double dDyInsert = dDxInsert;
|
|
|
|
|
|
this->m_YCount = (m_YMax - m_YMin) / this->m_dY;
|
|
|
if (this->m_YCount*this->m_dY < m_YMax - m_YMin)
|
|
|
{
|
|
|
//this->m_YCount++;
|
|
|
}
|
|
|
this->m_XCount = (this->m_XCount + 1);
|
|
|
this->m_YCount = (this->m_YCount + 1);
|
|
|
|
|
|
// 构造网格
|
|
|
CXy* pXy = new CXy;
|
|
|
CMesh* pMeshNew = new CMesh();
|
|
|
CLayer* pLayer = pXy->FindAddLayer("背景");
|
|
|
|
|
|
POSITION posNew = pXy->AddElement(pMeshNew, DOUBLEFOX_MESH);
|
|
|
pXy->SetElementLayer(posNew, pLayer);
|
|
|
|
|
|
CDimension2D* pDfg = new CDimension2D;
|
|
|
pDfg->Create(this->m_XCount, this->m_YCount, m_XMin, m_YMin, this->m_dX, this->m_dY);
|
|
|
|
|
|
//double valueNull = -1E301;
|
|
|
double dStepHalf = this->m_dX*0.5;
|
|
|
|
|
|
double dArea = 1;
|
|
|
if (pCurveBorder != nullptr&&pCurveBorder->num >= 3)
|
|
|
{
|
|
|
dArea = pCurveBorder->Area();
|
|
|
}
|
|
|
else {
|
|
|
dArea = abs((m_XMax - m_XMin)*(m_YMax - m_YMin));
|
|
|
}
|
|
|
|
|
|
IDWCalculation idw;
|
|
|
idw.SetArea(dArea);
|
|
|
idw.SetSortedData(pPts);
|
|
|
//idw.SetFaultages(&faultages); // 设置断层
|
|
|
double dSearchR = idw.TestR(ConvertX2Int((m_XMax + m_XMin) / 2.0, ptO), ConvertY2Int((m_YMax + m_YMin) / 2, ptO));
|
|
|
|
|
|
//DWORD start_time = GetTickCount64();
|
|
|
|
|
|
int nYCount = this->m_YCount;
|
|
|
StepProgress::stepCount = this->m_XCount;
|
|
|
StepProgress::progress = 0;
|
|
|
SetTimer(NULL, 0, 50, (TIMERPROC)CIDWCreator::TimerProc);
|
|
|
double valueNull = -1E301;
|
|
|
Path64 pathBorder;
|
|
|
int nCount = pCurveBorder->num;
|
|
|
for (int i = 0; i < nCount; i++)
|
|
|
{
|
|
|
pathBorder.push_back(Point64(
|
|
|
ConvertX2Int(pCurveBorder->x[i], ptO)
|
|
|
, ConvertY2Int(pCurveBorder->y[i], ptO)));
|
|
|
}
|
|
|
DPoint3 ptOO = ptO;
|
|
|
CIntersectionUtil m_IntersectHelp;
|
|
|
if (faultages.size() > 0)
|
|
|
{
|
|
|
m_IntersectHelp.SetSourceLines(&faultages);
|
|
|
}
|
|
|
parallel_for(0, this->m_XCount, [&pDfg, pathBorder, faultages,
|
|
|
&m_IntersectHelp, dStepHalf, &ptOO, dArea, pPts, dSearchR, nYCount, valueNull](int i)
|
|
|
//for (int i = 0; i < this->m_XCount; i++)
|
|
|
{
|
|
|
// 反距离加权算法
|
|
|
IDWCalculation idw;
|
|
|
idw.SetArea(dArea);
|
|
|
idw.SetSortedData(pPts);
|
|
|
idw.SetSearchR(dSearchR);
|
|
|
if (faultages.size() > 0)
|
|
|
{
|
|
|
idw.SetFaultageHelp(&m_IntersectHelp); // 设置断层
|
|
|
}
|
|
|
|
|
|
double x = ConvertX2Int(pDfg->x(i), ptOO);// +dStepHalf;
|
|
|
for (int j = 0; j < nYCount; j++)
|
|
|
{
|
|
|
double z;
|
|
|
double y = ConvertY2Int(pDfg->y(j), ptOO);// +dStepHalf;
|
|
|
Point64 pt(x, y);
|
|
|
|
|
|
//if (!IsPointInPolygon(x, y, pCurveBorder))
|
|
|
if (Clipper2Lib::PointInPolygon(pt, pathBorder) == PointInPolygonResult::IsOutside)
|
|
|
{
|
|
|
pDfg->SetValue(i, j, valueNull);
|
|
|
continue;
|
|
|
}
|
|
|
z = idw.GetValue(x, y);
|
|
|
pDfg->SetValue(i, j, z);
|
|
|
//TRACE("i:%d, j:%d, %lf\r\n", i, j, z);
|
|
|
}
|
|
|
|
|
|
StepProgress::progress++;
|
|
|
//if (StepProgress::DoProgress != nullptr) {
|
|
|
// int nProg = (int)(((double)StepProgress::progress / StepProgress::stepCount)*100.0);
|
|
|
// if (nProg != StepProgress::lastProgress)
|
|
|
// {
|
|
|
// StepProgress::lastProgress = nProg;
|
|
|
// StepProgress::DoProgress(_T("网格化"), nProg);
|
|
|
// }
|
|
|
//}
|
|
|
MSG msg;
|
|
|
if (PeekMessage(&msg, NULL, WM_TIMER, WM_TIMER, PM_REMOVE))
|
|
|
// if (GetMessage(&msg, NULL, 0, 0))
|
|
|
{
|
|
|
TranslateMessage(&msg);
|
|
|
DispatchMessage(&msg);
|
|
|
}
|
|
|
}
|
|
|
);//
|
|
|
pDfg->range[0] = dZMin;
|
|
|
pDfg->range[1] = dZMax;
|
|
|
StepProgress::progress = StepProgress::stepCount;
|
|
|
|
|
|
// 进行光滑
|
|
|
int nSmoothTimes = 1; // 光滑次数，最小是3
|
|
|
if (smoothTimes > nSmoothTimes) {
|
|
|
nSmoothTimes = smoothTimes;
|
|
|
}
|
|
|
double nSmoothCoe = smoothFactor; // 光滑系数
|
|
|
for (int i = 0; i < nSmoothTimes; i++)
|
|
|
{
|
|
|
SmoothMesh(pDfg, &m_IntersectHelp, nSmoothCoe);
|
|
|
//pDfg->Smooth(nSmoothCoe);
|
|
|
}
|
|
|
|
|
|
//DWORD end_time = GetTickCount64();
|
|
|
//CString strMsg;
|
|
|
//strMsg.Format("Time:%ld\t\n", end_time - start_time);
|
|
|
//TRACE(strMsg);
|
|
|
//::AfxMessageBox(strMsg);
|
|
|
|
|
|
//pDfg->range[0] = dZMin;
|
|
|
//pDfg->range[1] = dZMax;
|
|
|
|
|
|
//pDfg->GetRange();
|
|
|
|
|
|
pMeshNew->SetMesh(pDfg, MESH_DFG, FALSE);
|
|
|
pMeshNew->m_nTimes = insertTimes;// pow(2, insertTimes);
|
|
|
|
|
|
// 生成等值线
|
|
|
if (abs(contourStep) > 1E-5) {
|
|
|
CString strLayerMark = _T("Layer:\\等值线\\标注");
|
|
|
CString strLayerOther = _T("Layer:\\等值线\\无标注");
|
|
|
|
|
|
CString curLayerName = pXy->GetCurrentLayer()->GetPathName();
|
|
|
CLayer* pMarkLayer = pXy->FindLayer(strLayerMark);
|
|
|
CLayer* pOtherLayer = pXy->FindLayer(strLayerOther);
|
|
|
|
|
|
if (pMarkLayer == NULL)
|
|
|
{
|
|
|
pMarkLayer = pXy->FindAddLayer(strLayerMark);
|
|
|
|
|
|
pMarkLayer->HowToViewCurve = new CHowToViewCurve();
|
|
|
pMarkLayer->HowToViewCurve->EnableDrawSourceCurve(FALSE);
|
|
|
CCurveInName* pInName = new CCurveInName();
|
|
|
CRect8 rect = pMeshNew->GetRect();
|
|
|
pInName->text_h = rect.Width() / 300;
|
|
|
pInName->m_size.cx = pInName->text_h*0.06;
|
|
|
pInName->color = RGB(0, 0, 0);
|
|
|
pMarkLayer->HowToViewCurve->Add(pInName);
|
|
|
}
|
|
|
if (pOtherLayer == NULL)
|
|
|
{
|
|
|
pOtherLayer = pXy->FindAddLayer(strLayerOther);
|
|
|
|
|
|
pOtherLayer->HowToViewCurve = new CHowToViewCurve();
|
|
|
pOtherLayer->HowToViewCurve->EnableDrawSourceCurve(FALSE);
|
|
|
CCurveProperties* pview = new CCurveProperties();
|
|
|
pview->color = RGB(0, 0, 0);
|
|
|
pOtherLayer->HowToViewCurve->Add(pview);
|
|
|
}
|
|
|
|
|
|
// 设置断层
|
|
|
pDfg->CDimensionBase::EmptyLink();//清空已有的断层信息
|
|
|
// 等值线生成设置断层
|
|
|
COne* pOne;
|
|
|
CPtrList* pl = pXyFaults->GetValueList();
|
|
|
POSITION pos = pl->GetHeadPosition();
|
|
|
CLayer* pLayerFault = pXy->FindAddLayer("断层");
|
|
|
while (pos)
|
|
|
{
|
|
|
pOne = pXyFaults->GetAt(pos);
|
|
|
if (pOne->GetType() == DOUBLEFOX_CURVE) {
|
|
|
CCurveEx* pCurveFault = (CCurveEx*)(pOne->GetValue());
|
|
|
CCurveEx* pCurveNew = new CCurveEx;
|
|
|
(*pCurveNew) = (*pCurveFault);
|
|
|
POSITION posNew = pXy->AddElement(pCurveNew, DOUBLEFOX_CURVE);
|
|
|
pXy->SetElementLayer(posNew, pLayerFault);
|
|
|
pDfg->Faultage(*(CCurve*)pCurveNew);
|
|
|
}
|
|
|
pl->GetNext(pos);
|
|
|
}
|
|
|
|
|
|
//CCurveEx* pCurve;
|
|
|
//COne* pOne;
|
|
|
//CPositionList select;
|
|
|
//if (pXy->GetElement("断层", select, FALSE) > 0)
|
|
|
//{
|
|
|
// POSITION pt;
|
|
|
// POSITION pos = select.GetHeadPosition();
|
|
|
// while (pos)
|
|
|
// {
|
|
|
// pt = select.GetNext(pos);
|
|
|
// pOne = pXy->GetAt(pt);
|
|
|
// if (pOne->GetType() != DOUBLEFOX_CURVE) continue;
|
|
|
// pCurve = (CCurveEx*)pOne->GetValue();
|
|
|
// pDfg->Faultage(*(CCurve*)pCurve);
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
|
|
|
// 恢复网格坐标
|
|
|
//pDfg->P0[0] = ConvertX2D(pDfg->P0[0], ptO);
|
|
|
//pDfg->P0[1] = ConvertY2D(pDfg->P0[1], ptO);
|
|
|
|
|
|
//m_XMin = ConvertX2D(m_XMin, ptO);
|
|
|
//m_YMin = ConvertY2D(m_YMin, ptO);
|
|
|
//m_XMax = ConvertX2D(m_XMax, ptO);
|
|
|
//m_YMax = ConvertY2D(m_YMax, ptO);
|
|
|
|
|
|
//this->m_dX = (m_XMax - m_XMin) / (this->m_XCount);
|
|
|
//this->m_dY = this->m_dX;
|
|
|
|
|
|
//pDfg->delt[0]= pDfg->delt[0]/100.0;
|
|
|
//pDfg->delt[1] = pDfg->delt[1]/100.0;
|
|
|
|
|
|
// 生成新等值线
|
|
|
vector<CCurve*>* pCurves = new std::vector<CCurve *>();
|
|
|
vector<CString*>* pLayers = new std::vector<CString *>();
|
|
|
|
|
|
pMeshNew->ContourCreate(pCurves, pLayers, contourStep, contourMarkStep,
|
|
|
strLayerMark, strLayerOther, dZMin, dZMax);
|
|
|
//// 恢复等值线坐标
|
|
|
//for (size_t i = 0; i < pCurves->size(); i++)
|
|
|
//{
|
|
|
// CCurve* pCurve = pCurves->at(i);
|
|
|
// if (pCurve == NULL) continue;
|
|
|
// for (int j = 0; j < pCurve->num; j++) {
|
|
|
// pCurve->x[j] = ConvertX2D(pCurve->x[j], ptO);
|
|
|
// pCurve->y[j] = ConvertY2D(pCurve->y[j], ptO);
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
AddContourCurve(pXy, pCurves, pLayers);
|
|
|
vector<CCurve *>::iterator it = pCurves->begin();
|
|
|
while (it != pCurves->end())
|
|
|
{
|
|
|
delete *it;
|
|
|
it = pCurves->erase(it);
|
|
|
}
|
|
|
vector<CString *>::iterator itL = pLayers->begin();
|
|
|
while (itL != pLayers->end())
|
|
|
{
|
|
|
delete *itL;
|
|
|
itL = pLayers->erase(itL);
|
|
|
}
|
|
|
delete pCurves;
|
|
|
delete pLayers;
|
|
|
}
|
|
|
// 等值线生成结束
|
|
|
pMeshNew->EnableUpdateRuler(TRUE);
|
|
|
pMeshNew->UpdateColorRuler();
|
|
|
pXy->SaveAsWithExtension(resultFile);
|
|
|
|
|
|
//MSG msg;
|
|
|
//BOOL bRet;
|
|
|
//clock_t start = clock();
|
|
|
//while(TRUE)
|
|
|
//{
|
|
|
// if (PeekMessage(&msg, NULL, WM_TIMER, WM_TIMER, PM_REMOVE) == TRUE)
|
|
|
// {
|
|
|
// TranslateMessage(&msg);
|
|
|
// DispatchMessage(&msg);
|
|
|
// break;
|
|
|
// }
|
|
|
// clock_t finish = clock();
|
|
|
// if ((double)(finish - start) / CLK_TCK> 0.1)
|
|
|
// {
|
|
|
// break;
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
delete pPts;
|
|
|
pXyFaults->Clear();
|
|
|
delete pXyFaults;
|
|
|
delete pXyBorder;
|
|
|
delete pXy;
|
|
|
}
|
|
|
inline bool isPointFaultage(double ptX, double ptY, double otherX, double otherY, Paths64* faultages) {
|
|
|
Path64 lineSub;
|
|
|
lineSub.push_back(Point64(ptX, ptY));
|
|
|
lineSub.push_back(Point64(otherX, otherY));
|
|
|
|
|
|
Paths64 clip, solutionClosed, solutionOpen;
|
|
|
clip.push_back(lineSub);
|
|
|
|
|
|
Clipper64 clipperD;
|
|
|
clipperD.AddOpenSubject(clip);
|
|
|
clipperD.AddClip(*faultages);
|
|
|
clipperD.Execute(ClipType::Intersection, FillRule::NonZero, solutionClosed, solutionOpen);
|
|
|
if (solutionOpen.size() > 0) {
|
|
|
clipperD.Clear();
|
|
|
return true;
|
|
|
}
|
|
|
clipperD.Clear();
|
|
|
return false;
|
|
|
}
|
|
|
void CIDWCreator::SmoothMesh(CGrid* pGrid, CIntersectionUtil* intersectHelp, double smoothFactor /*= 1*/) {
|
|
|
if (smoothFactor < 1e-10) {
|
|
|
return;
|
|
|
}
|
|
|
int numx = pGrid->xnum();
|
|
|
int numy = pGrid->ynum();
|
|
|
double dZMin = pGrid->range[0] - 0.001;
|
|
|
double dZMax = pGrid->range[1] + 0.001;
|
|
|
|
|
|
DPoint3 ptOO = ptO;
|
|
|
|
|
|
//double dValueCur = 0, dValueTmp = 0;
|
|
|
|
|
|
//parallel_for(1, numx - 1, [&pGrid, intersectHelp, smoothFactor, &ptOO, dZMin, dZMax, numy](int i)
|
|
|
for (int i = 1; i < numx - 1; i++)
|
|
|
{
|
|
|
double dSigma = 0;
|
|
|
double dPtX = 0, dPtY = 0, dOtherX = 0, dOtherY = 0;
|
|
|
for (int j = 1; j < numy - 1; j++) {
|
|
|
double dValueCur = pGrid->Value(i, j);
|
|
|
if (dValueCur< dZMin || dValueCur>dZMax) {
|
|
|
continue;
|
|
|
}
|
|
|
dPtX = ConvertX2Int(pGrid->x(i), ptOO);
|
|
|
dPtY = ConvertY2Int(pGrid->y(j), ptOO);
|
|
|
dSigma = 0;
|
|
|
int nCount = 0;
|
|
|
double dValueTmp = pGrid->Value(i - 1, j - 1);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i - 1), ptOO), ConvertY2Int(pGrid->y(j - 1), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
dValueTmp = pGrid->Value(i, j - 1);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
//if (!isPointFaultage(dPtX, dPtY, pGrid->x(i), pGrid->y(j - 1), &faultages))
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i), ptOO), ConvertY2Int(pGrid->y(j - 1), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
dValueTmp = pGrid->Value(i + 1, j - 1);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
//if (!isPointFaultage(dPtX, dPtY, pGrid->x(i + 1), pGrid->y(j - 1), &faultages))
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i + 1), ptOO), ConvertY2Int(pGrid->y(j - 1), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
dValueTmp = pGrid->Value(i - 1, j);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
//if (!isPointFaultage(dPtX, dPtY, pGrid->x(i - 1), pGrid->y(j), &faultages))
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i - 1), ptOO), ConvertY2Int(pGrid->y(j), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
dValueTmp = pGrid->Value(i + 1, j);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
//if (!isPointFaultage(dPtX, dPtY, pGrid->x(i + 1), pGrid->y(j), &faultages))
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i + 1), ptOO), ConvertY2Int(pGrid->y(j), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
dValueTmp = pGrid->Value(i - 1, j + 1);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
// if (!isPointFaultage(dPtX, dPtY, pGrid->x(i - 1), pGrid->y(j + 1), &faultages))
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i - 1), ptOO), ConvertY2Int(pGrid->y(j + 1), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
dValueTmp = pGrid->Value(i, j + 1);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
// if (!isPointFaultage(dPtX, dPtY, pGrid->x(i), pGrid->y(j + 1), &faultages))
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i), ptOO), ConvertY2Int(pGrid->y(j + 1), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
dValueTmp = pGrid->Value(i + 1, j + 1);
|
|
|
if (dValueTmp >= dZMin && dValueTmp <= dZMax) {
|
|
|
//if (!isPointFaultage(dPtX, dPtY, pGrid->x(i + 1), pGrid->y(j + 1), &faultages))
|
|
|
if (!intersectHelp->Intersects(LineSegment(Point64(dPtX, dPtY)
|
|
|
, Point64(ConvertX2Int(pGrid->x(i + 1), ptOO), ConvertY2Int(pGrid->y(j + 1), ptOO)))))
|
|
|
{
|
|
|
dSigma += dValueTmp;
|
|
|
nCount++;
|
|
|
}
|
|
|
}
|
|
|
if (nCount == 0) {
|
|
|
return;
|
|
|
}
|
|
|
double dAverage = dSigma / nCount;
|
|
|
double dValueNew = (dValueCur + dAverage * smoothFactor) / (1.0 + smoothFactor);
|
|
|
pGrid->SetValue(i, j, dValueNew);
|
|
|
//TRACE("i:%d, j:%d, %lf\r\n", i, j, dValueNew);
|
|
|
}
|
|
|
}
|
|
|
//);
|
|
|
}
|
|
|
double precision = 1e-10;
|
|
|
bool CIDWCreator::IsPointInPolygon(double ptX, double ptY, CCurve* pCurve)
|
|
|
{
|
|
|
bool isIn = false;
|
|
|
int nCount = pCurve->num;
|
|
|
double dX1 = 0, dX2 = 0, dY1 = 0, dY2 = 0;
|
|
|
for (int i = 0; i < nCount - 1; i++)
|
|
|
{
|
|
|
dX1 = pCurve->x[i];
|
|
|
dY1 = pCurve->y[i];
|
|
|
dX2 = pCurve->x[i + 1];
|
|
|
dY2 = pCurve->y[i + 1];
|
|
|
// 判断点是否与多边形顶点重合
|
|
|
if ((abs(dX1 - ptX) < precision && abs(dY1 - ptY) < precision)
|
|
|
|| (abs(dX2 - ptX) < precision && abs(dY2 - ptY) < precision))
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
// 判断点是否在水平直线上
|
|
|
if (abs(dY1 - dY2) < precision)
|
|
|
{
|
|
|
if (ptX >= min(dX1, dX2) - precision && ptX <= max(dX1, dX2) + precision)
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 判断线段两端点是否在射线两侧
|
|
|
if ((ptY >= dY1 - precision && ptY < dY2 + precision)
|
|
|
|| (ptY < dY1 + precision && ptY >= dY2 - precision))
|
|
|
{
|
|
|
// 斜率
|
|
|
double dK = (dX2 - dX1) / (dY2 - dY1);
|
|
|
// 相交点的x坐标
|
|
|
double dX = dX1 + dK * (ptY - dY1);
|
|
|
|
|
|
// 浮点类型计算容差
|
|
|
if (abs(dX - ptX) < 1e-10) {
|
|
|
return true;
|
|
|
}
|
|
|
// 射线平行于x轴，穿过多边形的边
|
|
|
if (dX > ptX) {
|
|
|
isIn = !isIn;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return isIn;
|
|
|
}
|
|
|
void CALLBACK CIDWCreator::TimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
|
|
|
{
|
|
|
int nProg = (int)(((double)StepProgress::progress / StepProgress::stepCount)*100.0);
|
|
|
|
|
|
if (StepProgress::DoProgress != nullptr) {
|
|
|
if (nProg != StepProgress::lastProgress)
|
|
|
{
|
|
|
StepProgress::lastProgress = nProg;
|
|
|
StepProgress::DoProgress(_T("网格化"), nProg);
|
|
|
}
|
|
|
}
|
|
|
StepProgress::lastProgress = nProg;
|
|
|
if (nProg == 100) {
|
|
|
KillTimer(nullptr, idEvent);
|
|
|
//::AfxMessageBox("Killed");
|
|
|
StepProgress::lastProgress = 0;
|
|
|
}
|
|
|
}
|
|
|
// 加密
|
|
|
//{
|
|
|
//CDimension2D* pDfgInsert = new CDimension2D;
|
|
|
//pDfgInsert->Create(nXCountInsert, nYCountInsert, m_XMin, m_YMin, dDxInsert, dDyInsert);
|
|
|
//for (int i = 0; i < nXCountInsert; i++)
|
|
|
//{
|
|
|
// for (int j = 0; j < nYCountInsert; j++) {
|
|
|
// pDfgInsert->SetValue(i, j, valueNull);
|
|
|
// }
|
|
|
//}
|
|
|
//int nL, nR, nB, nT;
|
|
|
//double dF11, dF21, dF12, dF22;
|
|
|
//BOOL bz1, bz2, bz3, bz4;
|
|
|
//double zmin, zmax;
|
|
|
//for (long j = 0; j < m_YCount - 1; ++j)
|
|
|
//{
|
|
|
// for (long i = 0; i < m_XCount - 1; ++i)
|
|
|
// {
|
|
|
// dF11 = pDfg->Value(i, j);
|
|
|
// dF12 = pDfg->Value(i, j + 1);
|
|
|
// dF22 = pDfg->Value(i + 1, j + 1);
|
|
|
// dF21 = pDfg->Value(i + 1, j);
|
|
|
//
|
|
|
// for (int m = 0; m < nInsertCount; ++m)
|
|
|
// for (int n = 0; n < nInsertCount; ++n)
|
|
|
// {
|
|
|
// double dF = (dF11*(nInsertCount - m)*n +
|
|
|
// dF12 * (nInsertCount - m)*(nInsertCount - n) +
|
|
|
// dF22 * m*(nInsertCount - n) +
|
|
|
// dF21 * m*n) / nInsertCount / nInsertCount;
|
|
|
// pDfgInsert->SetValue(i*nInsertCount + m, j*nInsertCount + n, dF);
|
|
|
// }
|
|
|
// }
|
|
|
//}
|
|
|
//for (int i = 0; i < this->m_XCount; i++)
|
|
|
//{
|
|
|
// for (int j = 0; j < m_YCount; j++)
|
|
|
// {
|
|
|
// double dZCenter = pDfg->Value(i*nInsertCount, j*nInsertCount);
|
|
|
// //TRACE("dZCenter: %ld,%ld,%lf\r\n", i*nInsertCount, j*nInsertCount, z);
|
|
|
// if (i == 0) {
|
|
|
// nL = i;
|
|
|
// }
|
|
|
// else {
|
|
|
// nL = i - 1;
|
|
|
// }
|
|
|
// if (i == m_XCount - 1) {
|
|
|
// nR = m_XCount - 1;
|
|
|
// }
|
|
|
// else {
|
|
|
// nR = i + 1;
|
|
|
// }
|
|
|
// if (j == 0) {
|
|
|
// nB = j;
|
|
|
// }
|
|
|
// else {
|
|
|
// nB = j - 1;
|
|
|
// }
|
|
|
// if (j == m_YCount - 1) {
|
|
|
// nT = m_YCount - 1;
|
|
|
// }
|
|
|
// else {
|
|
|
// nT = j + 1;
|
|
|
// }
|
|
|
// double dF11 = pDfg->Value(nL, nB); // 左下
|
|
|
// double dF21 = pDfg->Value(nR, nB); // 右下
|
|
|
// double dF12 = pDfg->Value(nL, nT); // 左上
|
|
|
// double dF22 = pDfg->Value(nR, nT); // 右上
|
|
|
// //TRACE("%ld,%ld,%ld,%ld %lf,%lf,%lf,%lf\r\n", nL, nB, nR, nT, dF11, dF21, dF12, dF22);
|
|
|
// for (int m = 0; m < nInsertCount; m++)
|
|
|
// {
|
|
|
// for (int n = 0; n < nInsertCount; n++)
|
|
|
// {
|
|
|
// double dX = m + 0.5;
|
|
|
// double dY = n + 0.5;
|
|
|
// double dF = (dF11 * (nInsertCount - dX)*(nInsertCount - dY)
|
|
|
// + dF21 * (dX)*(nInsertCount - dY)
|
|
|
// + dF12 * (nInsertCount - dX)*(dY)
|
|
|
// +dF22 * dX*dY) / (nInsertCount * nInsertCount);
|
|
|
|
|
|
// pDfgInsert->SetValue(i*nInsertCount + m, j*nInsertCount + n, dF);
|
|
|
|
|
|
// //TRACE("%ld,%ld,%lf\r\n", i*nInsertCount + m, j*nInsertCount + n, dF);
|
|
|
// }
|
|
|
// }
|
|
|
// }
|
|
|
//}
|
|
|
//}
|
|
|
void CIDWCreator::AddContourCurve(CXy* pXy, vector<CCurve*>* curves, vector<CString*>* layer)
|
|
|
{
|
|
|
for (size_t i = 0; i < curves->size(); i++)
|
|
|
{
|
|
|
CCurve* pCurve = curves->at(i);
|
|
|
if (pCurve == NULL) continue;
|
|
|
|
|
|
CString* pName = layer->at(i);
|
|
|
|
|
|
CCurveEx *ce = new CCurveEx(pCurve->num);
|
|
|
for (int i = 0; i < ce->num; i++)
|
|
|
{
|
|
|
ce->x[i] = pCurve->x[i];
|
|
|
ce->y[i] = pCurve->y[i];
|
|
|
ce->z[i] = pCurve->z[i];
|
|
|
}
|
|
|
ce->nPoint = pCurve->nPoint;
|
|
|
ce->GetLocation();
|
|
|
POSITION pos = NULL;
|
|
|
if (pCurve->name)
|
|
|
ce->SetName(pCurve->name);
|
|
|
|
|
|
pos = pXy->AddElement(ce, DOUBLEFOX_CURVE);
|
|
|
pXy->SetElementLayer(pos, *pName);
|
|
|
}
|
|
|
}
|
|
|
bool CIDWCreator::Calculate()
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
void CIDWCreator::ReadInToMatrix(string FilePath, vector<array<double, 3>>& data)
|
|
|
{
|
|
|
ifstream in;
|
|
|
in.open(FilePath, ios::in);//打开一个file
|
|
|
if (!in.is_open()) {
|
|
|
//cout << "Can not find " << FilePath << endl;
|
|
|
system("pause");
|
|
|
}
|
|
|
int nDim = 3;
|
|
|
// 以‘,’为分隔符拆分字符串
|
|
|
char seps[] = " ,\t\n";
|
|
|
string buff;
|
|
|
while (getline(in, buff)) {
|
|
|
array<double, 3> nums = { 0 };
|
|
|
// string->char *
|
|
|
char *s_input = (char *)buff.c_str();
|
|
|
char *token = strtok(s_input, seps);
|
|
|
double a;
|
|
|
int i = 0;//行数i
|
|
|
while (token != NULL) {
|
|
|
a = atof(token);
|
|
|
nums[i] = a;
|
|
|
i++;
|
|
|
if (i > 2) break;
|
|
|
token = strtok(NULL, seps);
|
|
|
} // end while
|
|
|
// 数据行不符合要求
|
|
|
if (i < 3) continue;
|
|
|
data.push_back(nums);
|
|
|
}//end while
|
|
|
in.close();
|
|
|
//cout << "get data" << endl;
|
|
|
}
|
|
|
bool CIDWCreator::OpenFile(LPCTSTR lpszFileName, CXy* pXy)
|
|
|
{
|
|
|
if (pXy->ReadOtherWithExtension(lpszFileName))
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
CFile file;
|
|
|
if (file.Open(lpszFileName, CFile::modeRead))
|
|
|
{
|
|
|
// m_FileName = lpszFileName;
|
|
|
CArchive ar(&file, CArchive::load);
|
|
|
Serialize(ar, pXy);
|
|
|
ar.Close();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
file.Close();
|
|
|
return true;
|
|
|
}
|
|
|
void CIDWCreator::Serialize(CArchive& ar, CXy* pXy)
|
|
|
{
|
|
|
if (ar.IsStoring()) {}
|
|
|
else
|
|
|
{
|
|
|
if (pXy == nullptr) pXy = new CXy;
|
|
|
pXy->m_bRealTimeDraw = false;
|
|
|
CString name = ar.GetFile()->GetFileName();
|
|
|
name.MakeLower();
|
|
|
CSplitPath sp(name);
|
|
|
|
|
|
CString ext = sp.GetExtension();
|
|
|
//ar.m_pDocument = this; // set back-pointer in archive
|
|
|
if (ext == _T(".dfb") ||
|
|
|
ext == _T(".dft"))
|
|
|
{
|
|
|
pXy->m_version = pXy->DFB_ReadVersion(ar);
|
|
|
pXy->DFB_ReadEncrypt(ar, pXy->m_version);
|
|
|
if (pXy->IsEncrypted()) {
|
|
|
}
|
|
|
pXy->DFB_Serialize(ar, pXy->m_version);
|
|
|
}
|
|
|
else if (ext == ".dml" || ext == ".xml")
|
|
|
pXy->DML_Read2(*(ar.GetFile()));
|
|
|
else if (ext == ".pcg")
|
|
|
pXy->PCG_Read2(*(ar.GetFile()));
|
|
|
else
|
|
|
pXy->DFD_Read2(*(ar.GetFile()));
|
|
|
}
|
|
|
}
|