|
|
#include "StdAfx.h"
|
|
|
#include "KEDAlgorithm.h"
|
|
|
#include <windows.h>
|
|
|
|
|
|
#ifndef M_PI
|
|
|
#define M_PI 3.14159265358979323846
|
|
|
#endif
|
|
|
|
|
|
template <typename T>
|
|
|
void qDeleteAll(std::vector<T*>& vec)
|
|
|
{
|
|
|
for (auto* p : vec) {
|
|
|
delete p;
|
|
|
}
|
|
|
|
|
|
vec.clear();
|
|
|
}
|
|
|
|
|
|
// 将 std::string 转为 std::wstring
|
|
|
static std::wstring utf8_to_wstring(const std::string& s) {
|
|
|
if (s.empty()) return {};
|
|
|
int needed = MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), NULL, 0);
|
|
|
std::wstring out(needed, 0);
|
|
|
MultiByteToWideChar(CP_UTF8, 0, s.c_str(), (int)s.size(), &out[0], needed);
|
|
|
return out;
|
|
|
}
|
|
|
|
|
|
// 将本地多字节编码 (GBK/ANSI) 转成 Unicode
|
|
|
static std::wstring ansi_to_wstring(const std::string& s) {
|
|
|
if (s.empty()) return {};
|
|
|
int needed = MultiByteToWideChar(CP_ACP, 0, s.c_str(), (int)s.size(), NULL, 0);
|
|
|
std::wstring out(needed, 0);
|
|
|
MultiByteToWideChar(CP_ACP, 0, s.c_str(), (int)s.size(), &out[0], needed);
|
|
|
return out;
|
|
|
}
|
|
|
|
|
|
// 运行 facies_boundaries.exe
|
|
|
bool RunFaciesBoundaries(
|
|
|
const std::string& exePath,
|
|
|
const std::string& grdPath,
|
|
|
const std::string& dfdPath,
|
|
|
std::string& outStdout,
|
|
|
DWORD& outExitCode,
|
|
|
DWORD timeoutMs,
|
|
|
std::atomic<bool>* cancelFlag = nullptr)
|
|
|
{
|
|
|
outStdout.clear();
|
|
|
outExitCode = (DWORD)-1;
|
|
|
|
|
|
// 构造命令行（不变）
|
|
|
std::wstringstream cmd;
|
|
|
cmd << L"\"" << ansi_to_wstring(exePath) << L"\" ";
|
|
|
cmd << L"\"" << ansi_to_wstring(grdPath) << L"\" ";
|
|
|
cmd << L"\"" << ansi_to_wstring(dfdPath) << L"\"";
|
|
|
|
|
|
SECURITY_ATTRIBUTES sa{ sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
|
|
|
HANDLE hRead = NULL, hWrite = NULL;
|
|
|
if (!CreatePipe(&hRead, &hWrite, &sa, 0)) return false;
|
|
|
SetHandleInformation(hRead, HANDLE_FLAG_INHERIT, 0);
|
|
|
|
|
|
STARTUPINFOW si = { 0 };
|
|
|
PROCESS_INFORMATION pi = { 0 };
|
|
|
si.cb = sizeof(si);
|
|
|
si.hStdOutput = hWrite;
|
|
|
si.hStdError = hWrite;
|
|
|
si.dwFlags |= STARTF_USESTDHANDLES;
|
|
|
|
|
|
std::wstring cmdStr = cmd.str();
|
|
|
LPWSTR cmdLine = &cmdStr[0];
|
|
|
|
|
|
BOOL ok = CreateProcessW(
|
|
|
NULL, cmdLine, NULL, NULL, TRUE,
|
|
|
CREATE_NO_WINDOW, NULL, NULL, &si, &pi
|
|
|
);
|
|
|
|
|
|
CloseHandle(hWrite); // 父进程不再写
|
|
|
|
|
|
if (!ok) {
|
|
|
CloseHandle(hRead);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
//关键：循环等待，期间检查 cancelFlag
|
|
|
const DWORD pollInterval = 100; // 每 100ms 检查一次
|
|
|
DWORD totalWait = 0;
|
|
|
bool wasCancelled = false;
|
|
|
|
|
|
while (true) {
|
|
|
// 检查是否被外部请求取消
|
|
|
if (cancelFlag && cancelFlag->load()) {
|
|
|
TerminateProcess(pi.hProcess, 1);
|
|
|
wasCancelled = true;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// 检查是否超时
|
|
|
if (timeoutMs != INFINITE && totalWait >= timeoutMs) {
|
|
|
TerminateProcess(pi.hProcess, 1);
|
|
|
wasCancelled = true;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// 检查进程是否已退出
|
|
|
DWORD exitCode;
|
|
|
if (GetExitCodeProcess(pi.hProcess, &exitCode) && exitCode != STILL_ACTIVE) {
|
|
|
outExitCode = exitCode;
|
|
|
break;
|
|
|
}
|
|
|
|
|
|
// 等待一小段时间
|
|
|
Sleep(pollInterval);
|
|
|
totalWait += pollInterval;
|
|
|
}
|
|
|
|
|
|
// 读取输出（即使被取消，也尽量读完缓冲区）
|
|
|
const DWORD bufSize = 4096;
|
|
|
char buffer[bufSize];
|
|
|
DWORD bytesRead = 0;
|
|
|
std::string output;
|
|
|
while (ReadFile(hRead, buffer, bufSize, &bytesRead, NULL) && bytesRead > 0) {
|
|
|
output.append(buffer, bytesRead);
|
|
|
}
|
|
|
outStdout = output;
|
|
|
|
|
|
// 如果是被取消的，返回 false
|
|
|
bool success = !wasCancelled && (outExitCode == 0);
|
|
|
|
|
|
// 清理句柄
|
|
|
CloseHandle(pi.hProcess);
|
|
|
CloseHandle(pi.hThread);
|
|
|
CloseHandle(hRead);
|
|
|
|
|
|
return success;
|
|
|
}
|
|
|
|
|
|
// 计算多边形包围盒
|
|
|
static inline void ComputePolygonBBox(const CCurveEx* poly, double& xmin, double& xmax, double& ymin, double& ymax)
|
|
|
{
|
|
|
xmin = 1e20; xmax = -1e20;
|
|
|
ymin = 1e20; ymax = -1e20;
|
|
|
for (int i = 0; i < poly->num; ++i) {
|
|
|
xmin = std::min(xmin, (double)poly->x[i]);
|
|
|
xmax = std::max(xmax, (double)poly->x[i]);
|
|
|
ymin = std::min(ymin, (double)poly->y[i]);
|
|
|
ymax = std::max(ymax, (double)poly->y[i]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
KEDAlgorithm::KEDAlgorithm()
|
|
|
{
|
|
|
m_DepositionalMap.clear();
|
|
|
}
|
|
|
|
|
|
KEDAlgorithm::~KEDAlgorithm()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
bool KEDAlgorithm::ProcessExistingGrd(
|
|
|
const CString& grdFile, // 已存在的 GRD 文件
|
|
|
const CString& kevFile, // 输出 KEV 文件
|
|
|
CColorBase base,
|
|
|
bool isFaciesBorder,
|
|
|
std::function<void(int completed, int total)> progressCallback)
|
|
|
{
|
|
|
const int TOTAL_STEPS = 4;
|
|
|
auto reportProgress = [&](int step, bool failed = false) {
|
|
|
if (progressCallback) progressCallback(failed ? -1 : step, TOTAL_STEPS);
|
|
|
};
|
|
|
|
|
|
m_cancelRequested.store(false);
|
|
|
|
|
|
// 检查 GRD 文件
|
|
|
std::ifstream fchk(grdFile);
|
|
|
if (!fchk.is_open()) {
|
|
|
reportProgress(0, true);
|
|
|
return false;
|
|
|
}
|
|
|
fchk.close();
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(1);
|
|
|
|
|
|
std::shared_ptr<CXy> pXy = nullptr;
|
|
|
std::vector<CCurve*> pCurves;
|
|
|
|
|
|
if (isFaciesBorder)
|
|
|
{
|
|
|
// --- 准备路径 ---
|
|
|
CSplitPath sp;
|
|
|
sp.SetModuleFileName();
|
|
|
CString xmlPath;
|
|
|
xmlPath.Format("%s%s", sp.GetPath(), "facies");
|
|
|
sp.MakeDirectory(xmlPath);
|
|
|
|
|
|
CString outdfdPath;
|
|
|
outdfdPath.Format("%s%s", xmlPath, "\\facies.dfd");
|
|
|
|
|
|
CString exePath;
|
|
|
exePath.Format("%s%s", sp.GetPath(), "facies_boundaries.exe");
|
|
|
|
|
|
// --- 调用 EXE ---
|
|
|
std::string grdPath = grdFile;
|
|
|
std::string dfdPath = std::string(outdfdPath);
|
|
|
std::string procOut;
|
|
|
DWORD exitCode = 0;
|
|
|
|
|
|
bool ran = RunFaciesBoundaries(std::string(exePath), grdPath, dfdPath,
|
|
|
procOut, exitCode, 120000, &m_cancelRequested);
|
|
|
|
|
|
if (!ran || exitCode != 0) {
|
|
|
std::cerr << "无法启动 facies_boundaries.exe\n";
|
|
|
reportProgress(2, true);
|
|
|
return false;
|
|
|
}
|
|
|
reportProgress(2);
|
|
|
|
|
|
CFile fw;
|
|
|
if (!fw.Open(outdfdPath, CFile::modeRead)) {
|
|
|
reportProgress(2, true);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 初始化外部定义的 pXy
|
|
|
pXy = std::make_shared<CXy>();
|
|
|
pXy->DFD_Read2(fw);
|
|
|
fw.Close();
|
|
|
|
|
|
CPositionList list;
|
|
|
if (pXy->GetElement("Layer:\\Facies", list) > 0)
|
|
|
{
|
|
|
for (POSITION pos = list.GetHeadPosition(); pos != NULL; list.GetNext(pos)) {
|
|
|
COne* pOne = (COne*)(pXy->GetValueList()->GetAt(list.GetAt(pos)));
|
|
|
CCurve* curve = (CCurve*)pOne->GetValue();
|
|
|
pCurves.push_back(curve);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(3);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// 如果不需要边界，直接跳过中间步骤，但更新进度
|
|
|
reportProgress(2);
|
|
|
reportProgress(3);
|
|
|
}
|
|
|
|
|
|
// 4. 写入 KEV 文件
|
|
|
if (!GrdToKEVFile(grdFile, kevFile, pCurves, base)) {
|
|
|
reportProgress(3, true);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
reportProgress(4);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
std::vector<FaciesConfig> KEDAlgorithm::LoadFaciesSettings(const CString& settingsFile,
|
|
|
std::map<std::string, int>& labelMap)
|
|
|
{
|
|
|
std::vector<FaciesConfig> samples;
|
|
|
|
|
|
std::ifstream file((LPCTSTR)settingsFile);
|
|
|
if(!file.is_open()) throw std::runtime_error("无法打开文件: " + settingsFile);
|
|
|
|
|
|
std::string line;
|
|
|
std::getline(file, line); // 跳过表头
|
|
|
|
|
|
while (std::getline(file, line)) {
|
|
|
if (line.empty()) continue;
|
|
|
std::stringstream ss(line);
|
|
|
std::string name, sCode, sFillCol, sBorderCol, sValue, sX, sY;
|
|
|
|
|
|
// 严格匹配表头顺序：名称, 代码, 填充色, 边界色, 相值, 横坐标, 纵坐标
|
|
|
if (!std::getline(ss, name, ',')) continue;
|
|
|
if (!std::getline(ss, sCode, ',')) continue;
|
|
|
if (!std::getline(ss, sFillCol, ',')) continue;
|
|
|
if (!std::getline(ss, sBorderCol, ',')) continue;
|
|
|
if (!std::getline(ss, sValue, ',')) continue;
|
|
|
if (!std::getline(ss, sX, ',')) continue;
|
|
|
if (!std::getline(ss, sY, ',')) continue;
|
|
|
|
|
|
FaciesConfig config;
|
|
|
config.name = name;
|
|
|
config.code = sCode;
|
|
|
config.fillColor = (COLORREF)std::stoll(sFillCol); // 读取 int 颜色
|
|
|
config.borderColor = (COLORREF)std::stoll(sBorderCol); // 读取 int 颜色
|
|
|
config.value = std::stod(sValue);
|
|
|
config.x = std::stod(sX); // 读取物理横坐标
|
|
|
config.y = std::stod(sY); // 读取物理纵坐标
|
|
|
|
|
|
samples.push_back(config);
|
|
|
// 设置图例：相代码作为 Z 值，相名称作为显示文本
|
|
|
std::string faciesName;
|
|
|
faciesName = name + "-" + sCode;
|
|
|
m_DepositionalMap.insert({ faciesName, config.value });
|
|
|
|
|
|
m_ColorList.insert({ config.value , config.fillColor });
|
|
|
}
|
|
|
return samples;
|
|
|
}
|
|
|
|
|
|
std::vector<Sample> KEDAlgorithm::ReadSamplesCSV(const CString& csvFile,
|
|
|
std::map<std::string, int>& labelMap)
|
|
|
{
|
|
|
std::vector<Sample> samples;
|
|
|
std::ifstream file(csvFile);
|
|
|
if (!file.is_open()) throw std::runtime_error("无法打开文件: " + csvFile);
|
|
|
|
|
|
std::string line;
|
|
|
std::getline(file, line); // 跳过表头
|
|
|
while (std::getline(file, line)) {
|
|
|
std::stringstream ss(line);
|
|
|
std::string sx, sy, sz;
|
|
|
if (!std::getline(ss, sx, ',')) continue;
|
|
|
if (!std::getline(ss, sy, ',')) continue;
|
|
|
if (!std::getline(ss, sz, ',')) continue;
|
|
|
if (sx.empty() || sy.empty()) continue;
|
|
|
|
|
|
double x = std::stod(sx);
|
|
|
double y = std::stod(sy);
|
|
|
|
|
|
if (labelMap.find(sz) == labelMap.end()) {
|
|
|
int newId = static_cast<int>(labelMap.size());
|
|
|
labelMap[sz] = newId;
|
|
|
}
|
|
|
m_DepositionalMap.insert({ sz, labelMap[sz] });
|
|
|
samples.push_back({ x, y, labelMap[sz] });
|
|
|
}
|
|
|
return samples;
|
|
|
}
|
|
|
|
|
|
|
|
|
double KEDAlgorithm::KdeLogDensityBrute(const std::vector<FaciesConfig>& samples,
|
|
|
int label, double qx, double qy,
|
|
|
double bandwidth) const
|
|
|
{
|
|
|
if (samples.empty()) return -std::numeric_limits<double>::infinity();
|
|
|
|
|
|
double log_coeff = -std::log(2.0 * M_PI) - 2.0 * std::log(bandwidth);
|
|
|
double sum_exp = 0.0;
|
|
|
int n = 0;
|
|
|
|
|
|
for (const auto& s : samples) {
|
|
|
if (s.value != label) continue;
|
|
|
double dx = qx - s.x;
|
|
|
double dy = qy - s.y;
|
|
|
double dist2 = dx * dx + dy * dy;
|
|
|
double log_p = log_coeff - 0.5 * dist2 / (bandwidth * bandwidth);
|
|
|
sum_exp += std::exp(log_p);
|
|
|
++n;
|
|
|
}
|
|
|
|
|
|
if (n == 0) return -std::numeric_limits<double>::infinity();
|
|
|
return std::log(sum_exp / n);
|
|
|
}
|
|
|
|
|
|
|
|
|
bool KEDAlgorithm::WriteDSAAFromGrid(const std::string& output_grd,
|
|
|
const std::vector<float>& grid_data,
|
|
|
int nx, int ny,
|
|
|
double minx, double maxx,
|
|
|
double miny, double maxy)
|
|
|
{
|
|
|
if (static_cast<size_t>(nx * ny) != grid_data.size() || grid_data.empty())
|
|
|
return false;
|
|
|
|
|
|
float zmin = *std::min_element(grid_data.begin(), grid_data.end());
|
|
|
float zmax = *std::max_element(grid_data.begin(), grid_data.end());
|
|
|
|
|
|
std::ofstream out(output_grd);
|
|
|
if (!out.is_open()) return false;
|
|
|
|
|
|
out << "DSAA\n";
|
|
|
out << nx << " " << ny << "\n";
|
|
|
out << minx << " " << maxx << "\n";
|
|
|
out << miny << " " << maxy << "\n";
|
|
|
out << zmin << " " << zmax << "\n";
|
|
|
|
|
|
for (int j = 0; j < ny; ++j) {
|
|
|
int src_row = ny - 1 - j;
|
|
|
for (int i = 0; i < nx; ++i) {
|
|
|
size_t index = static_cast<size_t>(src_row) * nx + i;
|
|
|
out << grid_data[index] << " ";
|
|
|
if ((i + 1) % 10 == 0) out << "\n";
|
|
|
}
|
|
|
out << "\n";
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool KEDAlgorithm::GrdToKEVFile(const CString &gridFile, const CString &outputFile,
|
|
|
std::vector<CCurve*> pCurves, CColorBase &base)
|
|
|
{
|
|
|
std::shared_ptr<CXy> pXy = std::make_shared<CXy>();
|
|
|
pXy->FromGridAuto(gridFile);
|
|
|
|
|
|
CLayer* pLayer = pXy->FindAddLayer("背景");
|
|
|
CPositionList pointList;
|
|
|
int index = pXy->GetElement(DOUBLEFOX_MESH, pointList);
|
|
|
if (pointList.GetSize() == 0)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
COne* pNewOne = pXy->GetAt(pointList.GetHead());
|
|
|
pNewOne->SetLayer(pLayer);
|
|
|
|
|
|
if (!CreateFaciesLines(pXy, pCurves))
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 设置颜色
|
|
|
CArray<CColorItem, CColorItem> ColorList;
|
|
|
base.GetColor(ColorList);
|
|
|
if (ColorList.GetSize() > 0)
|
|
|
{
|
|
|
POSITION pt = pXy->FindFirstElement(DOUBLEFOX_MESH);
|
|
|
if (pt == nullptr)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
COne* pOne1 = pXy->GetAt(pt);
|
|
|
CMesh* pMesh = (CMesh*)pOne1->GetValue();
|
|
|
|
|
|
pMesh->color.SetColor(ColorList);
|
|
|
pMesh->UpdateColorRuler();
|
|
|
}
|
|
|
|
|
|
pXy->SaveAsWithExtension(outputFile);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool KEDAlgorithm::CreateFaciesLines(std::shared_ptr<CXy> pXy, std::vector<CCurve*> pCurves)
|
|
|
{
|
|
|
CString strLayerMark = _T("Layer:\\沉积相界\\相界");
|
|
|
CLayer* pLayer = pXy->FindAddLayer(strLayerMark);
|
|
|
|
|
|
AddFaciesCurves(pXy, pCurves, strLayerMark);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void KEDAlgorithm::AddFaciesCurves(std::shared_ptr<CXy> pXy, std::vector<CCurve*> curves, CString layerName)
|
|
|
{
|
|
|
for (size_t i = 0; i < curves.size(); i++)
|
|
|
{
|
|
|
CCurve* pCurve = curves.at(i);
|
|
|
if (pCurve == NULL) continue;
|
|
|
|
|
|
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, layerName);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool KEDAlgorithm::KEDMeshAlgorithm(const CString& csvFile, const CString& kevFile,
|
|
|
double grid_interval, double bandwidth, double beta, int anchor_radius,
|
|
|
std::function<void(int completed, int total)> progressCallback)
|
|
|
{
|
|
|
const int TOTAL_STEPS = 6;
|
|
|
auto reportProgress = [&](int step, bool failed = false) {
|
|
|
if (progressCallback) {
|
|
|
progressCallback(failed ? -1 : step, TOTAL_STEPS);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
m_cancelRequested.store(false);
|
|
|
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
std::map<std::string, int> labelMap;
|
|
|
auto samples = LoadFaciesSettings(csvFile, labelMap);
|
|
|
if (samples.empty()) {
|
|
|
reportProgress(0, true);
|
|
|
return false;
|
|
|
}
|
|
|
reportProgress(1);
|
|
|
int num_classes = static_cast<int>(labelMap.size());
|
|
|
if (num_classes == 0) {
|
|
|
reportProgress(1, true);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 范围
|
|
|
double minx = 1e20, maxx = -1e20, miny = 1e20, maxy = -1e20;
|
|
|
for (const auto& s : samples)
|
|
|
{
|
|
|
minx = std::min(minx, s.x);
|
|
|
maxx = std::max(maxx, s.x);
|
|
|
miny = std::min(miny, s.y);
|
|
|
maxy = std::max(maxy, s.y);
|
|
|
}
|
|
|
|
|
|
int nx = static_cast<int>((maxx - minx) / grid_interval) + 1;
|
|
|
int ny = static_cast<int>((maxy - miny) / grid_interval) + 1;
|
|
|
std::cout << "Grid nx=" << nx << " ny=" << ny << std::endl;
|
|
|
|
|
|
// 概率图
|
|
|
std::vector<cv::Mat> probMaps;
|
|
|
probMaps.reserve(num_classes);
|
|
|
for (int c = 0; c < num_classes; ++c)
|
|
|
probMaps.emplace_back(cv::Mat::zeros(ny, nx, CV_32F));
|
|
|
|
|
|
// KDE + 概率计算
|
|
|
#pragma omp parallel
|
|
|
{
|
|
|
std::vector<double> log_densities(num_classes);
|
|
|
#pragma omp for collapse(2) schedule(dynamic)
|
|
|
for (int iy = 0; iy < ny; ++iy)
|
|
|
{
|
|
|
if (m_cancelRequested.load()) continue;
|
|
|
for (int ix = 0; ix < nx; ++ix)
|
|
|
{
|
|
|
double gx = minx + ix * grid_interval;
|
|
|
double gy = maxy - iy * grid_interval;
|
|
|
|
|
|
for (int c = 0; c < num_classes; ++c)
|
|
|
log_densities[c] = KdeLogDensityBrute(samples, c, gx, gy, bandwidth);
|
|
|
|
|
|
double max_log = *std::max_element(log_densities.begin(), log_densities.end());
|
|
|
if (max_log <= -1e20)
|
|
|
{
|
|
|
for (int c = 0; c < num_classes; ++c)
|
|
|
probMaps[c].at<float>(iy, ix) = 1.0f / num_classes;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
double sum_exp = 0.0;
|
|
|
for (int c = 0; c < num_classes; ++c)
|
|
|
if (log_densities[c] > -1e20)
|
|
|
sum_exp += std::exp(log_densities[c] - max_log);
|
|
|
for (int c = 0; c < num_classes; ++c)
|
|
|
{
|
|
|
double p = 0.0;
|
|
|
if (log_densities[c] > -1e20)
|
|
|
p = std::exp(log_densities[c] - max_log) / sum_exp;
|
|
|
p = (1.0 - beta) * p + beta * (1.0 / num_classes);
|
|
|
probMaps[c].at<float>(iy, ix) = static_cast<float>(p);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(2);
|
|
|
|
|
|
// 初始分类
|
|
|
cv::Mat initialGrid(ny, nx, CV_8UC1, cv::Scalar(0));
|
|
|
for (int iy = 0; iy < ny; ++iy)
|
|
|
{
|
|
|
for (int ix = 0; ix < nx; ++ix)
|
|
|
{
|
|
|
int best_label = 0;
|
|
|
float best_prob = probMaps[0].at<float>(iy, ix);
|
|
|
for (int c = 1; c < num_classes; ++c)
|
|
|
{
|
|
|
float p = probMaps[c].at<float>(iy, ix);
|
|
|
if (p > best_prob) { best_prob = p; best_label = c; }
|
|
|
}
|
|
|
initialGrid.at<uchar>(iy, ix) = static_cast<uchar>(best_label);
|
|
|
}
|
|
|
}
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(3);
|
|
|
|
|
|
// 形态学处理
|
|
|
cv::Mat tempGrid = initialGrid.clone();
|
|
|
cv::morphologyEx(tempGrid, tempGrid, cv::MORPH_OPEN,
|
|
|
cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(5, 5)));
|
|
|
cv::morphologyEx(tempGrid, tempGrid, cv::MORPH_CLOSE,
|
|
|
cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(9, 9)));
|
|
|
|
|
|
cv::Mat finalGrid = tempGrid.clone();
|
|
|
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(4);
|
|
|
// 锚点加固
|
|
|
for (const auto& s : samples)
|
|
|
{
|
|
|
int col = static_cast<int>(std::round((s.x - minx) / grid_interval));
|
|
|
int row = static_cast<int>(std::round((maxy - s.y) / grid_interval));
|
|
|
if (col >= 0 && col < finalGrid.cols &&
|
|
|
row >= 0 && row < finalGrid.rows)
|
|
|
{
|
|
|
cv::circle(finalGrid, cv::Point(col, row), anchor_radius,
|
|
|
cv::Scalar(s.value), -1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
CSplitPath sp;
|
|
|
sp.SetModuleFileName();
|
|
|
CString xmlPath = "";
|
|
|
xmlPath.Format("%s%s", sp.GetPath(), "facies");
|
|
|
sp.MakeDirectory(xmlPath);
|
|
|
|
|
|
CString gridFile = "";
|
|
|
gridFile.Format("%s%s", xmlPath, "\\facies.grd");
|
|
|
|
|
|
// 保存 GRD
|
|
|
std::vector<float> grid_data;
|
|
|
grid_data.reserve(finalGrid.total());
|
|
|
for (int i = 0; i < finalGrid.rows; ++i)
|
|
|
for (int j = 0; j < finalGrid.cols; ++j)
|
|
|
grid_data.push_back(static_cast<float>(finalGrid.at<uchar>(i, j)));
|
|
|
|
|
|
if (!WriteDSAAFromGrid(std::string(gridFile), grid_data,
|
|
|
finalGrid.cols, finalGrid.rows,
|
|
|
minx, maxx, miny, maxy))
|
|
|
{
|
|
|
reportProgress(5, true);
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(5);
|
|
|
|
|
|
CArray<CColorItem, CColorItem> ColorList;
|
|
|
CColorBase base;
|
|
|
base.Clear();
|
|
|
for (const auto& pair : m_ColorList)
|
|
|
{
|
|
|
CColorItem colorMesh;
|
|
|
colorMesh.SetColor(pair.second);
|
|
|
colorMesh.z = pair.first;
|
|
|
colorMesh.m_bContinue = true;
|
|
|
ColorList.Add(colorMesh);
|
|
|
}
|
|
|
base.SetColor(ColorList);
|
|
|
|
|
|
ProcessExistingGrd(gridFile, kevFile, base, true, progressCallback);
|
|
|
reportProgress(6);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
bool KEDAlgorithm::IDWMeshAlgorithm(const CString& csvFile,
|
|
|
const CString& kevFile,
|
|
|
const CString& boundaryFile,
|
|
|
double grid_interval,
|
|
|
int subblock_count,
|
|
|
int idw_neighbors,
|
|
|
double idw_power,
|
|
|
bool use_shepard,
|
|
|
bool smooth_boundary,
|
|
|
bool isFaciesBorder,
|
|
|
std::function<void(int completed, int total)> progressCallback)
|
|
|
{
|
|
|
const int TOTAL_STEPS = 6;
|
|
|
auto reportProgress = [&](int step, bool failed = false) {
|
|
|
if (progressCallback) progressCallback(failed ? -1 : step, TOTAL_STEPS);
|
|
|
};
|
|
|
|
|
|
m_cancelRequested.store(false);
|
|
|
|
|
|
//读取样本点
|
|
|
std::map<std::string, int> labelMap;
|
|
|
auto samples = LoadFaciesSettings(csvFile, labelMap);
|
|
|
if (samples.empty()) { reportProgress(0, true); return false; }
|
|
|
int num_classes = static_cast<int>(labelMap.size());
|
|
|
reportProgress(1);
|
|
|
|
|
|
//计算范围（基于样本点
|
|
|
double minx = 1e20, maxx = -1e20, miny = 1e20, maxy = -1e20;
|
|
|
float sample_zmin = std::numeric_limits<float>::max();
|
|
|
float sample_zmax = std::numeric_limits<float>::lowest();
|
|
|
for (const auto& s : samples)
|
|
|
{
|
|
|
minx = std::min(minx, s.x);
|
|
|
maxx = std::max(maxx, s.x);
|
|
|
miny = std::min(miny, s.y);
|
|
|
maxy = std::max(maxy, s.y);
|
|
|
sample_zmin = std::min(sample_zmin, static_cast<float>(s.value));
|
|
|
sample_zmax = std::max(sample_zmax, static_cast<float>(s.value));
|
|
|
}
|
|
|
reportProgress(2);
|
|
|
|
|
|
//读取边界文件 (仅用于过滤)
|
|
|
std::vector<CCurveEx*> vBorder;
|
|
|
if (!boundaryFile.IsEmpty())
|
|
|
{
|
|
|
vBorder = GetDFDBorder(boundaryFile);
|
|
|
}
|
|
|
bool use_custom_border = !vBorder.empty();
|
|
|
|
|
|
//扩展范围
|
|
|
minx -= grid_interval;
|
|
|
miny -= grid_interval;
|
|
|
maxx += grid_interval;
|
|
|
maxy += grid_interval;
|
|
|
|
|
|
// 构建网格 + KDTree
|
|
|
int nx = static_cast<int>((maxx - minx) / grid_interval) + 1;
|
|
|
int ny = static_cast<int>((maxy - miny) / grid_interval) + 1;
|
|
|
const float NO_DATA_VALUE = 1e301;
|
|
|
std::vector<float> grid_data(nx * ny, NO_DATA_VALUE);
|
|
|
|
|
|
PointCloud cloud; cloud.pts = samples;
|
|
|
typedef KDTreeSingleIndexAdaptor<
|
|
|
L2_Simple_Adaptor<double, PointCloud>,
|
|
|
PointCloud, 2> my_kd_tree_t;
|
|
|
my_kd_tree_t index(2, cloud, KDTreeSingleIndexAdaptorParams(10));
|
|
|
index.buildIndex();
|
|
|
reportProgress(3);
|
|
|
|
|
|
// ================= 新增：建立物理值与数组索引的映射 =================
|
|
|
std::vector<int> uniqueValues;
|
|
|
std::map<int, int> valueToIndex;
|
|
|
int vIdx = 0;
|
|
|
for (const auto& pair : m_ColorList) {
|
|
|
uniqueValues.push_back(pair.first); // 存储物理相值
|
|
|
valueToIndex[pair.first] = vIdx++; // 物理相值 -> 数组下标 (0, 1, 2...)
|
|
|
}
|
|
|
// 确保 num_classes 与实际颜色表大小一致
|
|
|
num_classes = static_cast<int>(uniqueValues.size());
|
|
|
// ==================================================================
|
|
|
|
|
|
// 分块并行 IDW 插值
|
|
|
int block_h = ny / subblock_count;
|
|
|
std::atomic<int> completed_rows{ 0 };
|
|
|
int total_rows = ny;
|
|
|
|
|
|
#pragma omp parallel for schedule(dynamic)
|
|
|
for (int by = 0; by < subblock_count; ++by)
|
|
|
{
|
|
|
int startY = by * block_h;
|
|
|
int endY = (by == subblock_count - 1) ? ny : (by + 1) * block_h;
|
|
|
|
|
|
std::vector<size_t> ret_indexes(idw_neighbors);
|
|
|
std::vector<double> out_dists_sqr(idw_neighbors);
|
|
|
std::vector<double> class_weights_local(num_classes);
|
|
|
|
|
|
for (int iy = startY; iy < endY; ++iy)
|
|
|
{
|
|
|
if (m_cancelRequested.load()) break;
|
|
|
|
|
|
for (int ix = 0; ix < nx; ++ix)
|
|
|
{
|
|
|
double qx = minx + ix * grid_interval;
|
|
|
double qy = maxy - iy * grid_interval;
|
|
|
|
|
|
// 边界限制
|
|
|
if (use_custom_border && !IsPointInPolygon(qx, qy, vBorder))
|
|
|
continue;
|
|
|
|
|
|
double query_pt[2] = { qx, qy };
|
|
|
nanoflann::KNNResultSet<double> resultSet(idw_neighbors);
|
|
|
resultSet.init(&ret_indexes[0], &out_dists_sqr[0]);
|
|
|
index.findNeighbors(resultSet, &query_pt[0]);
|
|
|
|
|
|
std::fill(class_weights_local.begin(), class_weights_local.end(), 0.0);
|
|
|
double R = sqrt(out_dists_sqr.back()) + 1e-9;
|
|
|
|
|
|
for (int k = 0; k < idw_neighbors; ++k)
|
|
|
{
|
|
|
double d = sqrt(out_dists_sqr[k]) + 1e-9;
|
|
|
double w = 0.0;
|
|
|
|
|
|
if (use_shepard)
|
|
|
{
|
|
|
w = pow((R - d) / (R * d + 1e-9), 2);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (idw_power == 2.0)
|
|
|
{
|
|
|
w = 1.0 / (d * d);
|
|
|
}
|
|
|
else {
|
|
|
w = 1.0 / pow(d, idw_power);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
int phys_value = cloud.pts[ret_indexes[k]].value;
|
|
|
int safe_index = valueToIndex[phys_value];
|
|
|
class_weights_local[safe_index] += w;
|
|
|
}
|
|
|
|
|
|
int best_idx = 0;
|
|
|
double best_w = -1.0;
|
|
|
for (int lbl = 0; lbl < num_classes; ++lbl)
|
|
|
{
|
|
|
if (class_weights_local[lbl] > best_w)
|
|
|
{
|
|
|
best_idx = lbl;
|
|
|
best_w = class_weights_local[lbl];
|
|
|
}
|
|
|
}
|
|
|
grid_data[iy * nx + ix] = static_cast<float>(uniqueValues[best_idx]);
|
|
|
}
|
|
|
|
|
|
//动态行进度回传
|
|
|
int done = ++completed_rows;
|
|
|
if (progressCallback && (done % (ny / 100) == 0))
|
|
|
{
|
|
|
// 每约1%更新
|
|
|
int percent = static_cast<int>((done * 100.0) / total_rows);
|
|
|
progressCallback(percent, 100); // 实时百分比模式
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(4);
|
|
|
|
|
|
qDeleteAll(vBorder);
|
|
|
|
|
|
// 写入 GRD (过滤无效值计算z范围)
|
|
|
CSplitPath sp;
|
|
|
sp.SetModuleFileName();
|
|
|
CString xmlPath;
|
|
|
xmlPath.Format("%s%s", sp.GetPath(), "facies");
|
|
|
sp.MakeDirectory(xmlPath);
|
|
|
|
|
|
CString gridFile;
|
|
|
gridFile.Format("%s%s", xmlPath, "\\facies_idw.grd");
|
|
|
|
|
|
WriteDSAAFromGridKeepZRange(
|
|
|
std::string(CT2A(gridFile)),
|
|
|
grid_data, nx, ny,
|
|
|
minx, maxx, miny, maxy,
|
|
|
sample_zmin, sample_zmax);
|
|
|
|
|
|
reportProgress(5);
|
|
|
|
|
|
CArray<CColorItem, CColorItem> ColorList;
|
|
|
CColorBase base;
|
|
|
base.Clear();
|
|
|
for (const auto& pair : m_ColorList)
|
|
|
{
|
|
|
CColorItem colorMesh;
|
|
|
colorMesh.SetColor(pair.second);
|
|
|
colorMesh.z = pair.first;
|
|
|
colorMesh.m_bContinue = true;
|
|
|
ColorList.Add(colorMesh);
|
|
|
}
|
|
|
base.SetColor(ColorList);
|
|
|
|
|
|
//生成 KEV
|
|
|
ProcessExistingGrd(gridFile, kevFile, base, isFaciesBorder, progressCallback);
|
|
|
reportProgress(6);
|
|
|
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
void KEDAlgorithm::StopTask()
|
|
|
{
|
|
|
m_cancelRequested.store(true);
|
|
|
}
|
|
|
|
|
|
// 后处理（平滑 + 过滤 + 去毛刺）
|
|
|
void KEDAlgorithm::PostProcessFaciesBoundaries(
|
|
|
std::vector<CCurve*>& pCurves,
|
|
|
double sigma_smooth,
|
|
|
int min_seg_cells,
|
|
|
double drop_closed_thresh,
|
|
|
double dx, double dy)
|
|
|
{
|
|
|
std::vector<CCurve*> filtered;
|
|
|
filtered.reserve(pCurves.size());
|
|
|
|
|
|
for (auto* curve : pCurves)
|
|
|
{
|
|
|
if (!curve || curve->num < 3) continue;
|
|
|
|
|
|
//去除太短线段
|
|
|
double totalLen = 0.0;
|
|
|
for (int i = 1; i < curve->num; ++i)
|
|
|
{
|
|
|
double dx_ = curve->x[i] - curve->x[i - 1];
|
|
|
double dy_ = curve->y[i] - curve->y[i - 1];
|
|
|
totalLen += std::sqrt(dx_ * dx_ + dy_ * dy_);
|
|
|
}
|
|
|
if (totalLen < min_seg_cells * std::min(dx, dy))
|
|
|
{
|
|
|
delete curve;
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// 高斯平滑线（几何层面）
|
|
|
if (sigma_smooth > 0.1)
|
|
|
{
|
|
|
std::vector<double> newX(curve->num), newY(curve->num);
|
|
|
int r = static_cast<int>(sigma_smooth * 2.0);
|
|
|
double sigma2 = sigma_smooth * sigma_smooth;
|
|
|
|
|
|
for (int i = 0; i < curve->num; ++i)
|
|
|
{
|
|
|
double sumW = 0.0, sumX = 0.0, sumY = 0.0;
|
|
|
for (int j = std::max(0, i - r); j < std::min(curve->num, i + r + 1); ++j)
|
|
|
{
|
|
|
double w = std::exp(-0.5 * (std::pow(i - j, 2) / sigma2));
|
|
|
sumW += w;
|
|
|
sumX += w * curve->x[j];
|
|
|
sumY += w * curve->y[j];
|
|
|
}
|
|
|
newX[i] = sumX / sumW;
|
|
|
newY[i] = sumY / sumW;
|
|
|
}
|
|
|
for (int i = 0; i < curve->num; ++i)
|
|
|
{
|
|
|
curve->x[i] = newX[i];
|
|
|
curve->y[i] = newY[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
filtered.push_back(curve);
|
|
|
}
|
|
|
|
|
|
pCurves.swap(filtered);
|
|
|
}
|
|
|
|
|
|
std::vector<CCurveEx*> KEDAlgorithm::GetDFDBorder(const CString& path)
|
|
|
{
|
|
|
CString borderFile = path;
|
|
|
if (!CFindFileEx::IsFileExists(borderFile)) {
|
|
|
return {};
|
|
|
}
|
|
|
std::shared_ptr<CXy> pXy = std::make_shared<CXy>();
|
|
|
|
|
|
borderFile = borderFile.Trim();
|
|
|
if (borderFile.GetLength() <= 0 || borderFile == "NULL") {
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
if (!pXy->ReadWithExtension(borderFile)) {
|
|
|
return {};
|
|
|
}
|
|
|
|
|
|
std::vector<CCurveEx*> result;
|
|
|
|
|
|
CPtrList* pl = pXy->GetValueList();
|
|
|
for (POSITION pos = pl->GetHeadPosition(); pos != nullptr; pl->GetNext(pos)) {
|
|
|
COne* pOne = (COne*)pl->GetAt(pos);
|
|
|
if (pOne->GetType() == DOUBLEFOX_CURVE) {
|
|
|
CCurveEx* pCurve = (CCurveEx*)(pOne->GetValue());
|
|
|
CCurveEx* pCurveNew = new CCurveEx();
|
|
|
*pCurveNew = *pCurve;
|
|
|
result.push_back(pCurveNew);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* @brief 批量判断点是否在任意多边形内
|
|
|
* @param qx 检查点的 X 坐标
|
|
|
* @param qy 检查点的 Y 坐标
|
|
|
* @return 如果点在内部则返回 true，否则返回 false
|
|
|
*/
|
|
|
bool KEDAlgorithm::IsPointInPolygon(double qx, double qy, const std::vector<CCurveEx*>& polygons)
|
|
|
{
|
|
|
// 如果没有边界，则认为点在边界内
|
|
|
if (polygons.empty()) return true;
|
|
|
|
|
|
for (const auto* poly : polygons) {
|
|
|
if (!poly || poly->num < 3) continue;
|
|
|
|
|
|
int crossings = 0;
|
|
|
int num_vertices = poly->num;
|
|
|
|
|
|
// 处理闭合多边形（首尾点可能重复）
|
|
|
if (poly->x[0] == poly->x[num_vertices - 1] && poly->y[0] == poly->y[num_vertices - 1]) {
|
|
|
num_vertices--;
|
|
|
}
|
|
|
|
|
|
for (int i = 0, j = num_vertices - 1; i < num_vertices; j = i++) {
|
|
|
double xi = poly->x[i], yi = poly->y[i];
|
|
|
double xj = poly->x[j], yj = poly->y[j];
|
|
|
|
|
|
// 射线法：从 qx 向正 X 方向发出射线，统计与多边形边的交点数
|
|
|
if (((yi > qy) != (yj > qy)) && // 线段跨越水平线 y=qy
|
|
|
(qx < (xj - xi) * (qy - yi) / (yj - yi) + xi)) // 检查交点是否在 qx 右侧
|
|
|
{
|
|
|
crossings++;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 奇数交点数表示点在内部
|
|
|
if (crossings % 2 == 1) return true;
|
|
|
}
|
|
|
|
|
|
// 遍历所有多边形都不在内部
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
bool KEDAlgorithm::WriteDSAAFromGridKeepZRange(const std::string& output_grd, const std::vector<float>& grid_data,
|
|
|
int nx, int ny, double minx, double maxx, double miny, double maxy, float zmin, float zmax)
|
|
|
{
|
|
|
if (static_cast<size_t>(nx * ny) != grid_data.size() || grid_data.empty())
|
|
|
return false;
|
|
|
|
|
|
std::ofstream out(output_grd);
|
|
|
if (!out.is_open()) return false;
|
|
|
|
|
|
out << "DSAA\n";
|
|
|
out << nx << " " << ny << "\n";
|
|
|
out << minx << " " << maxx << "\n";
|
|
|
out << miny << " " << maxy << "\n";
|
|
|
out << zmin << " " << zmax << "\n";
|
|
|
|
|
|
for (int j = 0; j < ny; ++j) {
|
|
|
int src_row = ny - 1 - j;
|
|
|
for (int i = 0; i < nx; ++i) {
|
|
|
size_t index = static_cast<size_t>(src_row) * nx + i;
|
|
|
out << grid_data[index] << " ";
|
|
|
if ((i + 1) % 10 == 0) out << "\n";
|
|
|
}
|
|
|
out << "\n";
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
std::unordered_map<std::string, int> KEDAlgorithm::GetDepositionalMap()
|
|
|
{
|
|
|
return m_DepositionalMap;
|
|
|
}
|
|
|
|
|
|
bool KEDAlgorithm::NNMeshAlgorithm(const CString& csvFile,
|
|
|
const CString& kevFile,
|
|
|
const CString& boundaryFile,
|
|
|
double grid_interval,
|
|
|
double sigma,
|
|
|
int open_iter,
|
|
|
int close_iter,
|
|
|
bool isFaciesBorder,
|
|
|
std::function<void(int completed, int total)> progressCallback)
|
|
|
{
|
|
|
const int TOTAL_STEPS = 6;
|
|
|
auto reportProgress = [&](int step, bool failed = false) {
|
|
|
if (progressCallback) progressCallback(failed ? -1 : step, TOTAL_STEPS);
|
|
|
};
|
|
|
|
|
|
m_cancelRequested.store(false);
|
|
|
std::map<std::string, int> labelMap;
|
|
|
auto samples = LoadFaciesSettings(csvFile, labelMap);
|
|
|
if (samples.empty()) { reportProgress(0, true); return false; }
|
|
|
int num_classes = static_cast<int>(labelMap.size());
|
|
|
reportProgress(1);
|
|
|
|
|
|
double minx = 1e20, maxx = -1e20, miny = 1e20, maxy = -1e20;
|
|
|
float sample_zmin = std::numeric_limits<float>::max();
|
|
|
float sample_zmax = std::numeric_limits<float>::lowest();
|
|
|
|
|
|
for (const auto& s : samples) {
|
|
|
minx = std::min(minx, s.x); maxx = std::max(maxx, s.x);
|
|
|
miny = std::min(miny, s.y); maxy = std::max(maxy, s.y);
|
|
|
sample_zmin = std::min(sample_zmin, (float)s.value);
|
|
|
sample_zmax = std::max(sample_zmax, (float)s.value);
|
|
|
}
|
|
|
|
|
|
// Python: np.arange(start, stop + step*0.1, step)
|
|
|
// 保证浮点数计算时涵盖最后一个点
|
|
|
int nx = static_cast<int>(std::floor((maxx - minx + grid_interval * 0.01) / grid_interval)) + 1;
|
|
|
int ny = static_cast<int>(std::floor((maxy - miny + grid_interval * 0.01) / grid_interval)) + 1;
|
|
|
|
|
|
std::vector<CCurveEx*> vBorder;
|
|
|
if (!boundaryFile.IsEmpty())
|
|
|
{
|
|
|
vBorder = GetDFDBorder(boundaryFile);
|
|
|
}
|
|
|
bool use_custom_border = !vBorder.empty();
|
|
|
|
|
|
PointCloud cloud; cloud.pts = samples;
|
|
|
typedef KDTreeSingleIndexAdaptor<L2_Simple_Adaptor<double, PointCloud>, PointCloud, 2> my_kd_tree_t;
|
|
|
my_kd_tree_t index(2, cloud, KDTreeSingleIndexAdaptorParams(10));
|
|
|
index.buildIndex();
|
|
|
|
|
|
reportProgress(2);
|
|
|
|
|
|
// 生成初始网格 (Label索引图)
|
|
|
cv::Mat gridMat(ny, nx, CV_32SC1);
|
|
|
|
|
|
#pragma omp parallel for
|
|
|
for (int iy = 0; iy < ny; ++iy) {
|
|
|
if (m_cancelRequested.load()) continue;
|
|
|
for (int ix = 0; ix < nx; ++ix) {
|
|
|
double qx = minx + ix * grid_interval;
|
|
|
double qy = maxy - iy * grid_interval; // 注意Y轴方向通常是反的，需确认数据源习惯
|
|
|
|
|
|
double query_pt[2] = { qx, qy };
|
|
|
size_t ret_index;
|
|
|
double out_dist_sqr;
|
|
|
nanoflann::KNNResultSet<double> resultSet(1);
|
|
|
resultSet.init(&ret_index, &out_dist_sqr);
|
|
|
index.findNeighbors(resultSet, &query_pt[0]);
|
|
|
|
|
|
gridMat.at<int>(iy, ix) = cloud.pts[ret_index].value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(3);
|
|
|
|
|
|
// 1. 提取所有参与计算的物理相值 (std::map 已自动按从小到大排序)
|
|
|
std::vector<int> uniqueValues;
|
|
|
for (const auto& pair : m_ColorList) {
|
|
|
uniqueValues.push_back(pair.first);
|
|
|
}
|
|
|
int actualNumClasses = static_cast<int>(uniqueValues.size());
|
|
|
|
|
|
// ================= 高斯概率平滑 =================
|
|
|
if (sigma > 0.1 && actualNumClasses > 0) {
|
|
|
std::vector<cv::Mat> probLayers(actualNumClasses);
|
|
|
for (int i = 0; i < actualNumClasses; ++i)
|
|
|
probLayers[i] = cv::Mat::zeros(ny, nx, CV_32F);
|
|
|
|
|
|
// One-Hot Encoding (物理相值映射到平滑层索引)
|
|
|
#pragma omp parallel for
|
|
|
for (int y = 0; y < ny; ++y) {
|
|
|
for (int x = 0; x < nx; ++x) {
|
|
|
int currentVal = gridMat.at<int>(y, x);
|
|
|
// 找到该物理相值对应的层索引
|
|
|
for (int i = 0; i < actualNumClasses; ++i) {
|
|
|
if (uniqueValues[i] == currentVal) {
|
|
|
probLayers[i].at<float>(y, x) = 1.0f;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 核大小计算
|
|
|
int radius = static_cast<int>(4.0 * sigma + 0.5);
|
|
|
int ksize = 2 * radius + 1;
|
|
|
|
|
|
#pragma omp parallel for
|
|
|
for (int i = 0; i < actualNumClasses; ++i) {
|
|
|
cv::GaussianBlur(probLayers[i], probLayers[i],
|
|
|
cv::Size(ksize, ksize),
|
|
|
sigma, sigma,
|
|
|
cv::BORDER_REFLECT);
|
|
|
}
|
|
|
|
|
|
// Argmax 重组 (将最高概率的层索引还原为物理相值)
|
|
|
#pragma omp parallel for
|
|
|
for (int y = 0; y < ny; ++y) {
|
|
|
for (int x = 0; x < nx; ++x) {
|
|
|
int best_idx = 0;
|
|
|
float max_prob = -1.0f;
|
|
|
for (int i = 0; i < actualNumClasses; ++i) {
|
|
|
float p = probLayers[i].at<float>(y, x);
|
|
|
if (p > max_prob) {
|
|
|
max_prob = p;
|
|
|
best_idx = i;
|
|
|
}
|
|
|
}
|
|
|
// 重组写回真实的相值
|
|
|
gridMat.at<int>(y, x) = uniqueValues[best_idx];
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (m_cancelRequested.load()) { reportProgress(-1, true); return false; }
|
|
|
reportProgress(4);
|
|
|
|
|
|
// 形态学运算
|
|
|
if (open_iter > 0 || close_iter > 0) {
|
|
|
// 使用椭圆核，让相的边界产生地质上的圆润感
|
|
|
cv::Mat element = cv::getStructuringElement(cv::MORPH_ELLIPSE, cv::Size(3, 3));
|
|
|
cv::Mat optimizedGrid = gridMat.clone();
|
|
|
|
|
|
// 核心修正：遍历的是真实的物理相值，而不是 0, 1, 2
|
|
|
for (int i = 0; i < actualNumClasses; ++i) {
|
|
|
int physValue = uniqueValues[i];
|
|
|
|
|
|
cv::Mat mask;
|
|
|
// 寻找图像中等于 physValue 的像素
|
|
|
cv::inRange(gridMat, cv::Scalar(physValue), cv::Scalar(physValue), mask);
|
|
|
|
|
|
if (open_iter > 0)
|
|
|
cv::morphologyEx(mask, mask, cv::MORPH_OPEN, element, cv::Point(-1, -1), open_iter);
|
|
|
|
|
|
if (close_iter > 0)
|
|
|
cv::morphologyEx(mask, mask, cv::MORPH_CLOSE, element, cv::Point(-1, -1), close_iter);
|
|
|
|
|
|
// 将平滑后的蒙版区域，使用真实的相值填回去
|
|
|
optimizedGrid.setTo(cv::Scalar(physValue), mask);
|
|
|
}
|
|
|
gridMat = optimizedGrid;
|
|
|
}
|
|
|
|
|
|
reportProgress(5);
|
|
|
|
|
|
std::vector<float> grid_data;
|
|
|
grid_data.reserve(nx * ny);
|
|
|
|
|
|
for (int iy = 0; iy < ny; ++iy) {
|
|
|
for (int ix = 0; ix < nx; ++ix) {
|
|
|
double rx = minx + ix * grid_interval;
|
|
|
double ry = maxy - iy * grid_interval;
|
|
|
|
|
|
if (use_custom_border && !IsPointInPolygon(rx, ry, vBorder)) {
|
|
|
grid_data.push_back(1e301);
|
|
|
}
|
|
|
else {
|
|
|
grid_data.push_back((float)gridMat.at<int>(iy, ix));
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
qDeleteAll(vBorder);
|
|
|
|
|
|
CSplitPath sp;
|
|
|
sp.SetModuleFileName();
|
|
|
CString xmlPath;
|
|
|
xmlPath.Format("%s%s", sp.GetPath(), "facies");
|
|
|
sp.MakeDirectory(xmlPath);
|
|
|
|
|
|
CString gridPath;
|
|
|
gridPath.Format("%s%s", xmlPath, "\\facies_nn.grd");
|
|
|
|
|
|
WriteDSAAFromGridKeepZRange(
|
|
|
std::string(CT2A(gridPath)),
|
|
|
grid_data, nx, ny,
|
|
|
minx, maxx, miny, maxy,
|
|
|
sample_zmin, sample_zmax);
|
|
|
|
|
|
CArray<CColorItem, CColorItem> ColorList;
|
|
|
CColorBase base;
|
|
|
base.Clear();
|
|
|
for (const auto& pair : m_ColorList)
|
|
|
{
|
|
|
CColorItem colorMesh;
|
|
|
colorMesh.SetColor(pair.second);
|
|
|
colorMesh.z = pair.first;
|
|
|
colorMesh.m_bContinue = true;
|
|
|
ColorList.Add(colorMesh);
|
|
|
}
|
|
|
base.SetColor(ColorList);
|
|
|
|
|
|
ProcessExistingGrd(gridPath, kevFile, base, isFaciesBorder, progressCallback);
|
|
|
|
|
|
reportProgress(6);
|
|
|
return true;
|
|
|
} |