|
|
// <copyright file="DrawView.cs" company="PlaceholderCompany">
|
|
|
// Copyright (c) PlaceholderCompany. All rights reserved.
|
|
|
// </copyright>
|
|
|
|
|
|
using Detria;
|
|
|
using DevExpress.XtraSpreadsheet.Model;
|
|
|
using GeoSigma.SigmaDrawerElement;
|
|
|
using GeoSigma.SigmaDrawerStyle;
|
|
|
using GeoSigma.UCDraw;
|
|
|
using GeoSigma.UCDraw.WellAndSection;
|
|
|
using GeoSigmaDrawLib;
|
|
|
using InterfaceWorkAreaData;
|
|
|
//using DQ.Construction.NewLook.Utility;
|
|
|
using InterfaceWorkAreaData.LoadCurveData;
|
|
|
using NetTopologySuite;
|
|
|
using NetTopologySuite.Algorithm;
|
|
|
using NetTopologySuite.Geometries;
|
|
|
using NetTopologySuite.Operation.Distance;
|
|
|
using NetTopologySuite.Operation.Overlay;
|
|
|
using NetTopologySuite.Operation.OverlayNG;
|
|
|
using NetTopologySuite.Precision;
|
|
|
using SigmaDrawerElement;
|
|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.Data;
|
|
|
using System.Diagnostics;
|
|
|
using System.Drawing;
|
|
|
using System.IO;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
using System.Threading;
|
|
|
using System.Windows.Forms;
|
|
|
using System.Xml;
|
|
|
using WellWorkDataUI;
|
|
|
using WorkData;
|
|
|
using WorkData.Entity;
|
|
|
using Math = System.Math;
|
|
|
|
|
|
namespace UCDraw
|
|
|
{
|
|
|
//public delegate void StatusColumnInfo(string msg);
|
|
|
//public delegate void EmptyNameCurveLoadHandler(string itemString);
|
|
|
//public delegate void ViewerTipMessageHandler(string tipMessage);
|
|
|
//public delegate void DrawerViewChangeLayerEvent(string eventKind);
|
|
|
//public delegate void MainViewInfoHandler(string info);
|
|
|
|
|
|
/* 基类中 Drawer1在 WellSectionDrawView.designer.cs使用，但是每次修改此设计，会导致Draw1代码被删除，因此需要手动恢复，具体参考WellPoleDrawView.designer.cs中的Draw1*/
|
|
|
public partial class WellPoleDrawViewer : WellBaseDrawView
|
|
|
{
|
|
|
|
|
|
private double smallScollFactor = 0.02;
|
|
|
private double largeScrollFactor = 0.9;
|
|
|
private int scrollPositionYLast = 0;
|
|
|
private bool needHScrollToEnd = false;
|
|
|
private bool needHScrollToBegin = false;
|
|
|
private bool needVScrollToTop = false;
|
|
|
private bool needVScrollToBottom = false;
|
|
|
|
|
|
#region 打印
|
|
|
private PrinterStatus printerStatus = null;
|
|
|
private PrinterDrawer printerDrawer;
|
|
|
private PrintPreviewControl printPreview;
|
|
|
private ViewFactor viewFactor; //进入打印预览后，可能会改变视图。待退出打印预览后，恢复原来的视图。
|
|
|
#endregion
|
|
|
|
|
|
|
|
|
public WellPoleDrawViewer(GeoSigmaXY.eViewType vType = GeoSigmaXY.eViewType.plane)
|
|
|
{
|
|
|
mViewType = vType;
|
|
|
System.Security.Cryptography.RNGCryptoServiceProvider csp = new System.Security.Cryptography.RNGCryptoServiceProvider();
|
|
|
byte[] byteCsp = new byte[10];
|
|
|
csp.GetBytes(byteCsp);
|
|
|
ID = BitConverter.ToInt32(byteCsp, 0);
|
|
|
|
|
|
InitializeComponent();
|
|
|
InitDrawer();
|
|
|
|
|
|
this.Drawer.mViewType = vType;
|
|
|
this.BorderStyle = BorderStyle.None;
|
|
|
//.Dock = DockStyle.Fill;
|
|
|
//pnlMain.Controls.Add(draw1);
|
|
|
//HRuler.Size = new Size(HRuler.Size.Width, 20);
|
|
|
pnlMain.Refresh();
|
|
|
|
|
|
////hRuler1.InitTransform(drawer1.GetRangeGetter());
|
|
|
////vRuler1.InitTransform(drawer1.GetRangeGetter());
|
|
|
|
|
|
////drawer1.MouseMove += hRuler1.ProcessMouseMove;
|
|
|
////drawer1.DrawerZoomIn += hRuler1.Zoom;
|
|
|
////drawer1.DrawerZoomOut += hRuler1.Zoom;
|
|
|
////drawer1.DrawerViewAll += hRuler1.Zoom;
|
|
|
////drawer1.DrawerViewPan += hRuler1.ReDraw;
|
|
|
////drawer1.DrawerOnPaint += hRuler1.ReDraw;
|
|
|
|
|
|
////drawer1.MouseMove += vRuler1.ProcessMouseMove;
|
|
|
////drawer1.DrawerZoomIn += vRuler1.Zoom;
|
|
|
////drawer1.DrawerZoomOut += vRuler1.Zoom;
|
|
|
////drawer1.DrawerViewAll += vRuler1.Zoom;
|
|
|
////drawer1.DrawerViewPan += vRuler1.ReDraw;
|
|
|
////drawer1.DrawerOnPaint += vRuler1.ReDraw;
|
|
|
////drawer1.DrawerPrintPreview += PreviewPrint;
|
|
|
|
|
|
////drawer1.DrawerChangedViewBySynchronizeEvent += (drawer, e) =>
|
|
|
////{
|
|
|
//// vRuler1.Invalidate();
|
|
|
//// hRuler1.Invalidate();
|
|
|
////};
|
|
|
|
|
|
////this.MouseWheel+=Viewer_MouseWheel;
|
|
|
////this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
|
|
|
////this.SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
|
|
|
|
|
|
this.drawer1.SetScrollBar += SetScrollBar;
|
|
|
this.drawer1.DrawerScroll += ScrollScreenAndBar;
|
|
|
this.drawer1.DrawerWheel += ScrollByWheel;
|
|
|
|
|
|
// drawer1.DrawerGotFocus += drawer1_DrawerGotFocus;
|
|
|
drawer1.ENCurveLoadHandler += HandleEmptyNameCurve;
|
|
|
|
|
|
#region 打印
|
|
|
//NewMethod();
|
|
|
#endregion
|
|
|
|
|
|
// drawer1.DrawerCommandStart += OnCommandStart;
|
|
|
// drawer1.DrawerCommandFinish += OnCommandFinish;
|
|
|
//drawer1.TipMessageHandler += ShowTipMessage;
|
|
|
drawer1.ChangeLayerEvent += OnChangeLayer;
|
|
|
drawer1.GetLengthAngleEvent += GetLengthAngle;
|
|
|
|
|
|
drawer1.m_GetWellPoleDocContextMenu = new Drawer.DeletateGetWellPoleDocContextMenu(this.getWellPoleDocContextMenu);// WellPoleDrawViewer.getWellPoleDocContextMenu);
|
|
|
}
|
|
|
//public void SetDrawerMouseLocation(double dx, double dy)
|
|
|
//{
|
|
|
// drawer1?.SetMouseLocation(dx, dy);
|
|
|
//}
|
|
|
/// <summary>
|
|
|
/// 导出到图片
|
|
|
/// </summary>
|
|
|
/// <param name="fileFullPath">文件路径</param>
|
|
|
/// <returns>是否成功</returns>
|
|
|
//public bool Export2Image(string fileFullPath)
|
|
|
//{
|
|
|
// return this.Drawer.Export2Image(fileFullPath);
|
|
|
//}
|
|
|
//public void GetLengthAngle(string info)
|
|
|
//{
|
|
|
// GetLengthAngleEvent?.Invoke(info);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 曲线加密
|
|
|
///// </summary>
|
|
|
//public void CurveExcuteDensity()
|
|
|
//{
|
|
|
// this.Drawer?.CurveExcuteDensity();
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// 多边形连接.
|
|
|
///// </summary>
|
|
|
///// <returns>An int.</returns>
|
|
|
//public int CurveConnect(bool deleteOrignalCurves = false)
|
|
|
//{
|
|
|
// if (this.Drawer == null)
|
|
|
// {
|
|
|
// return 0;
|
|
|
// }
|
|
|
// return this.Drawer.CurveConnect(deleteOrignalCurves);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 曲线冗余处理
|
|
|
///// </summary>
|
|
|
//public void CurveRedundancy()
|
|
|
//{
|
|
|
// this.Drawer?.CurveRedundancy();
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 添加线
|
|
|
///// </summary>
|
|
|
///// <param name="layerName">图层</param>
|
|
|
///// <param name="name">线名</param>
|
|
|
///// <param name="pts">坐标点</param>
|
|
|
//public void AddDrawCurve(string layerName, string name, List<PointD> pts)
|
|
|
//{
|
|
|
// if (this.Drawer == null)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
// this.Drawer.AddCurve(layerName, name, pts);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 添加地震剖面
|
|
|
///// </summary>
|
|
|
///// <param name="sectionData">属性数据</param>
|
|
|
///// <returns>图元索引</returns>
|
|
|
//public long AddSeismicSection(string sectionData, float[] values)
|
|
|
//{
|
|
|
// return this.Drawer.AddSeismicSection(sectionData, values);
|
|
|
//}
|
|
|
//public void DeleteSectionAll()
|
|
|
//{
|
|
|
// this.Drawer.DeleteSeismicSection();
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 删除剖面
|
|
|
///// </summary>
|
|
|
///// <param name="pos">图元</param>
|
|
|
///// <returns>是否成功</returns>
|
|
|
//public bool DeleteSeismicSection(long pos)
|
|
|
//{
|
|
|
// return this.Drawer.DeleteSeismicSection(pos);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 删除图元
|
|
|
///// </summary>
|
|
|
///// <param name="layerName">图层名称</param>
|
|
|
///// <param name="eleName">图元名称</param>
|
|
|
///// <returns>删除的数量</returns>
|
|
|
//public int DeleteElement(string layerName, string eleName)
|
|
|
//{
|
|
|
// return this.Drawer.DeleteElement(layerName, eleName);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 删除点图元
|
|
|
///// </summary>
|
|
|
///// <param name="layerName">层名</param>
|
|
|
///// <param name="eleName">点名称</param>
|
|
|
///// <returns>删除个数</returns>
|
|
|
//public int DeletePoint(string layerName, string eleName)
|
|
|
//{
|
|
|
// return this.Drawer.DeletePoint(layerName, eleName);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 删除点数据
|
|
|
///// </summary>
|
|
|
///// <param name="layerName">图层名称</param>
|
|
|
///// <param name="eleNames">点数据名称列表</param>
|
|
|
//public void DeletePoints(string layerName, List<string> eleNames)
|
|
|
//{
|
|
|
// foreach (string name in eleNames)
|
|
|
// {
|
|
|
// this.Drawer.DeletePoint(layerName, name);
|
|
|
// }
|
|
|
//}
|
|
|
//public void DeletePoints(string layerName, List<DrawerPoint> pts)
|
|
|
//{
|
|
|
// this.Drawer.DeletePoints(layerName, pts);
|
|
|
//}
|
|
|
private void InitPrint()
|
|
|
{
|
|
|
if (printerStatus != null) return;
|
|
|
viewFactor = new ViewFactor();
|
|
|
viewFactor.zoomFactor = 1;
|
|
|
|
|
|
printerStatus = new PrinterStatus();
|
|
|
|
|
|
printPreview = new PrintPreviewControl();
|
|
|
printerDrawer = new PrinterDrawer(printerStatus, printPreview);
|
|
|
pnlMain.Controls.Add(printPreview);
|
|
|
}
|
|
|
|
|
|
//public void CutX()//fbw
|
|
|
//{
|
|
|
// drawer1?.Cutx();
|
|
|
//}
|
|
|
//public void Copy()//fbw
|
|
|
//{
|
|
|
// drawer1?.Copy();
|
|
|
//}
|
|
|
//public void Paste()//fbw
|
|
|
//{
|
|
|
// drawer1?.Paste();
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 截取窗口图形.
|
|
|
///// </summary>
|
|
|
//public void ImageCutWindow()
|
|
|
//{
|
|
|
// drawer1?.ImageCutWindow();
|
|
|
// drawer1?.ShowClipboardSketch();
|
|
|
//}
|
|
|
//public void ImageCutAll()
|
|
|
//{
|
|
|
// drawer1?.ImageCutAll();
|
|
|
// drawer1?.ShowClipboardSketch();
|
|
|
//}
|
|
|
|
|
|
//public void SwitchGrid()
|
|
|
//{
|
|
|
// bShowGrid = !bShowGrid;
|
|
|
// geoSigma.SigmaView_ShowBKGrid(bShowGrid ? 1 : 0);
|
|
|
// drawer1.ReDraw();
|
|
|
//}
|
|
|
//public void DisplayBackgroundGrid(bool show)
|
|
|
//{
|
|
|
// geoSigma.SigmaView_ShowBKGrid(show ? 1 : 0);
|
|
|
// drawer1.ReDraw();
|
|
|
//}
|
|
|
//public void EnableHeighLight(bool enable)
|
|
|
//{
|
|
|
// drawer1?.EnableHeighLight(enable);
|
|
|
//}
|
|
|
//public void Redraw()
|
|
|
//{
|
|
|
// drawer1?.ReDraw(); //TODO:drawer1重命名
|
|
|
//}
|
|
|
|
|
|
////通过DrawView调用Undo/Redo功能 因为有的Undo/Redo需要用到HDC
|
|
|
//public int Undo()
|
|
|
//{
|
|
|
// return (drawer1?.Undo()).Value;
|
|
|
//}
|
|
|
|
|
|
//public int Redo()
|
|
|
//{
|
|
|
// return (drawer1?.Redo()).Value;
|
|
|
//}
|
|
|
|
|
|
//public GeoSigmaXY GetGeoSigma()
|
|
|
//{
|
|
|
// return geoSigma;
|
|
|
//}
|
|
|
//public GeoSigmaXY GeoSigma
|
|
|
//{
|
|
|
// get
|
|
|
// {
|
|
|
// return geoSigma;
|
|
|
// }
|
|
|
//}
|
|
|
//public void SelectAll()
|
|
|
//{
|
|
|
// drawer1?.SelectAll();
|
|
|
//}
|
|
|
|
|
|
//public void SelectAllPoint()
|
|
|
//{
|
|
|
// drawer1?.SelectAllPoint();
|
|
|
//}
|
|
|
|
|
|
//public void SelectAllCurve()
|
|
|
//{
|
|
|
// drawer1?.SelectAllCurve();
|
|
|
//}
|
|
|
//public void ToolRestore()
|
|
|
//{
|
|
|
// drawer1?.RestoreTool();
|
|
|
//}
|
|
|
//public void RestoreToolDefault()
|
|
|
//{
|
|
|
// drawer1?.RestoreToolDefault();
|
|
|
//}
|
|
|
////private DrawToolType activeTool; // active drawing tool
|
|
|
////private DrawTool[] tools; // array of tools
|
|
|
///// <summary>
|
|
|
///// Active drawing tool.
|
|
|
///// </summary>
|
|
|
//public DrawToolType ActiveTool
|
|
|
//{
|
|
|
// get
|
|
|
// {
|
|
|
// return drawer1.ActiveTool;
|
|
|
// }
|
|
|
// set
|
|
|
// {
|
|
|
// drawer1.ActiveTool = value;
|
|
|
// }
|
|
|
//}
|
|
|
//private bool enableMeshPack = true;
|
|
|
//public bool EnableMeshPack
|
|
|
//{
|
|
|
// get
|
|
|
// {
|
|
|
// return enableMeshPack;
|
|
|
// }
|
|
|
// set
|
|
|
// {
|
|
|
// enableMeshPack = value;
|
|
|
// }
|
|
|
//}
|
|
|
//public ViewOperationKind GetViewOperationKind()
|
|
|
//{
|
|
|
// return drawer1.ViewOpKind;
|
|
|
//}
|
|
|
//public void SetViewOperationKind(ViewOperationKind kind)
|
|
|
//{
|
|
|
// drawer1.SetViewOperationKind(kind);
|
|
|
//}
|
|
|
private void SetStateOfControls()
|
|
|
{
|
|
|
if (needHScrollToEnd)
|
|
|
{
|
|
|
scrollH.Value = scrollH.Maximum - scrollH.LargeChange + 1;
|
|
|
needHScrollToEnd = false;
|
|
|
}
|
|
|
if (needHScrollToBegin)
|
|
|
{
|
|
|
scrollH.Value = scrollH.Minimum;
|
|
|
needHScrollToBegin = false;
|
|
|
}
|
|
|
if (needVScrollToBottom)
|
|
|
{
|
|
|
int nCurValue = scrollV.Maximum - scrollV.LargeChange + 1;
|
|
|
if (nCurValue > scrollV.Maximum)
|
|
|
{
|
|
|
nCurValue = scrollV.Maximum;
|
|
|
}
|
|
|
scrollV.Value = nCurValue;
|
|
|
needVScrollToBottom = false;
|
|
|
}
|
|
|
if (needVScrollToTop)
|
|
|
{
|
|
|
scrollV.Value = scrollV.Minimum;
|
|
|
needVScrollToTop = false;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
protected override void OnHandleCreated(EventArgs e)
|
|
|
{
|
|
|
base.OnHandleCreated(e);
|
|
|
//Application.Idle += Application_Idle;
|
|
|
}
|
|
|
|
|
|
protected override void OnHandleDestroyed(EventArgs e)
|
|
|
{
|
|
|
base.OnHandleDestroyed(e);
|
|
|
|
|
|
//Application.Idle -= Application_Idle;
|
|
|
}
|
|
|
private void Application_Idle(object sender, EventArgs e)
|
|
|
{
|
|
|
SetStateOfControls();
|
|
|
}
|
|
|
|
|
|
//public bool ReloadFile()
|
|
|
//{
|
|
|
// try
|
|
|
// {
|
|
|
// geoSigma = drawer1.ReloadFile();
|
|
|
// // hRuler1.InitGeo(geoSigma);
|
|
|
// // vRuler1.InitGeo(geoSigma);
|
|
|
// }
|
|
|
// catch (Exception ex)
|
|
|
// {
|
|
|
// Console.WriteLine(ex.Message);
|
|
|
// return false;
|
|
|
// }
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
|
|
|
// // Geo.EnableMeshPackage(EnableMeshPack);
|
|
|
// Redraw();
|
|
|
|
|
|
// return true;
|
|
|
//}
|
|
|
//public override bool OpenFile(string filePath, GeoSigmaXY.eViewType vType = GeoSigmaXY.eViewType.plane)
|
|
|
//{
|
|
|
// try
|
|
|
// {
|
|
|
// geoSigma = drawer1.OpenFile(filePath,vType);
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
// // geoSigma.EnableMeshPackage(this.enableMeshPack);
|
|
|
// }
|
|
|
// catch (Exception ex)
|
|
|
// {
|
|
|
// Console.WriteLine(ex.Message);
|
|
|
// return false;
|
|
|
// }
|
|
|
// // SetScrollBar();
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
// return true;
|
|
|
//}
|
|
|
//public void ClearGeo()
|
|
|
//{
|
|
|
// drawer1.ClearGeo();
|
|
|
//}
|
|
|
//public bool OpenXy(IntPtr pxy)
|
|
|
//{
|
|
|
// try
|
|
|
// {
|
|
|
// geoSigma = drawer1.OpenXy(pxy);
|
|
|
// // geoSigma.EnableMeshPackage(this.enableMeshPack);
|
|
|
|
|
|
// // hRuler1.InitGeo(geoSigma);
|
|
|
// // vRuler1.InitGeo(geoSigma);
|
|
|
// }
|
|
|
// catch (Exception ex)
|
|
|
// {
|
|
|
// Console.WriteLine(ex.Message);
|
|
|
// return false;
|
|
|
// }
|
|
|
// // SetScrollBar();
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
// return true;
|
|
|
//}
|
|
|
//public void SetBackColor(int r, int g, int b)
|
|
|
//{
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
// drawer1.ViewBackColor = Color.FromArgb(r, g, b);
|
|
|
// //geoSigma.SetViewBackcolor(r, g, b);
|
|
|
//}
|
|
|
//public void SetSymbolView(bool isSymbolView)
|
|
|
//{
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
// geoSigma.SetSymbolView(isSymbolView);
|
|
|
//}
|
|
|
//public bool SaveFile(string fileName)
|
|
|
//{
|
|
|
// if (geoSigma == null) return false;
|
|
|
// return geoSigma.SaveDocument(fileName);
|
|
|
//}
|
|
|
|
|
|
//public bool SaveFile(string fileName, double leftMargin, double rightMargin,
|
|
|
// double topMargin, double bottomMargin, int paperSizeType, int pdfAHType, int pdfPapertDirectionType)
|
|
|
//{
|
|
|
// if (geoSigma == null) return false;
|
|
|
// return geoSigma.SavePdfDocument(fileName, leftMargin, rightMargin,
|
|
|
// topMargin, bottomMargin, paperSizeType, pdfAHType, pdfPapertDirectionType);
|
|
|
//}
|
|
|
|
|
|
|
|
|
public override bool NewFile(string fileName, GeoSigmaXY.eViewType vType = GeoSigmaXY.eViewType.wellpole)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
if (drawer1 == null)
|
|
|
{
|
|
|
MessageBox.Show("drawer1 == null");
|
|
|
}
|
|
|
geoSigma = drawer1.NewFile(fileName, this.mNewWellInfo, vType);
|
|
|
|
|
|
if (vType != GeoSigmaXY.eViewType.wellpole)
|
|
|
return true;
|
|
|
|
|
|
if (workAreaDb.Instance.workData.isConn() == false)
|
|
|
return true;
|
|
|
|
|
|
UInt64 wellHandle = 0;
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
if (mNewWellInfo.tid != -1 && GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle) == true)
|
|
|
{
|
|
|
readWorkAreaDataForWell(this.mNewWellInfo.wellName,wellHandle);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
Console.WriteLine(ex.Message);
|
|
|
return false;
|
|
|
}
|
|
|
if (geoSigma == null)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 将全部内容当前分辨率保存到指定输出文件.
|
|
|
/// </summary>
|
|
|
/// <param name="outputFile">The output file.</param>
|
|
|
/// <param name="left"></param>
|
|
|
/// <param name="top"></param>
|
|
|
/// <param name="right"></param>
|
|
|
/// <param name="bottom"></param>
|
|
|
//public void Draw2Image(string outputFile, double left = 0, double top = 0, double right = 0, double bottom = 0)
|
|
|
//{
|
|
|
// drawer1?.Geo?.Draw2Image(outputFile, left, top, right, bottom);
|
|
|
//}
|
|
|
|
|
|
//public bool SetPointZColor()
|
|
|
//{
|
|
|
// return drawer1.SetPointZColor();
|
|
|
//}
|
|
|
//public string GetLayers(bool withStatus = false)
|
|
|
//{
|
|
|
// return geoSigma != null ? geoSigma.GetLayers(withStatus) : string.Empty;
|
|
|
//}
|
|
|
#region 打印
|
|
|
public override void PreviewPrint()
|
|
|
{
|
|
|
InitPrint();
|
|
|
// vRuler1.Hide();
|
|
|
// hRuler1.Hide();
|
|
|
pnlScrollV.Hide();
|
|
|
pnlScrollH.Hide();
|
|
|
drawer1.Hide();
|
|
|
|
|
|
printerStatus.Init(drawer1.Geo);
|
|
|
printerDrawer.Init(drawer1.Geo);
|
|
|
|
|
|
// drawer1.MouseMove -= hRuler1.ProcessMouseMove;
|
|
|
// drawer1.MouseMove -= vRuler1.ProcessMouseMove;
|
|
|
drawer1.Anchor = AnchorStyles.None;
|
|
|
drawer1.Geo.GetViewFactors(ref viewFactor);
|
|
|
|
|
|
LayoutPreviewPrintCtrl();
|
|
|
}
|
|
|
|
|
|
public void OnClosePreviewWindow(object sender, EventArgs e)
|
|
|
{
|
|
|
// vRuler1.Show();
|
|
|
// hRuler1.Show();
|
|
|
pnlScrollV.Show();
|
|
|
pnlScrollH.Show();
|
|
|
//previewPrintBar.Hide();
|
|
|
printPreview.Visible = false;
|
|
|
|
|
|
// drawer1.MouseMove += hRuler1.ProcessMouseMove;
|
|
|
// drawer1.MouseMove += vRuler1.ProcessMouseMove;
|
|
|
drawer1.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right;
|
|
|
|
|
|
drawer1.RecoverView(viewFactor);
|
|
|
drawer1.Show();
|
|
|
}
|
|
|
|
|
|
protected void LayoutPreviewPrintCtrl()
|
|
|
{
|
|
|
//int previewHeight = Height - previewPrintBar.Height;
|
|
|
//int previewWidth = PrintTool.GetWidthOfPreviewPrintCanvas(printerStatus.PaperName, printerStatus.Orientation, previewHeight);
|
|
|
// int previewX = (Width - previewWidth) / 2;
|
|
|
//printPreview.Location = new Point(previewX, previewPrintBar.Height);
|
|
|
//printPreview.Width = previewWidth;
|
|
|
//printPreview.Height = Height; //previewHeight;
|
|
|
//printPreview.Visible = true;
|
|
|
printerDrawer.Redraw();
|
|
|
}
|
|
|
|
|
|
protected override void OnResize(EventArgs e)
|
|
|
{
|
|
|
base.OnResize(e);
|
|
|
if (printPreview == null || printPreview.Visible == false)
|
|
|
return;
|
|
|
|
|
|
LayoutPreviewPrintCtrl();
|
|
|
}
|
|
|
#endregion
|
|
|
//public int SelectByNames(string nameData)
|
|
|
//{
|
|
|
// return Drawer.SelectByNames(nameData);
|
|
|
//}
|
|
|
/// <summary>
|
|
|
/// 根据名称查找并激活图元
|
|
|
/// </summary>
|
|
|
/// <param name="content">图元名称</param>
|
|
|
/// <param name="matchAll">全字匹配</param>
|
|
|
/// <param name="matchCase">匹配大小写</param>
|
|
|
/// <param name="elementType">图元类型</param>
|
|
|
/// <param name="editableOnly">是否只查找可编辑图元</param>
|
|
|
/// <returns>查找结果</returns>
|
|
|
//public int FindElementByName(string content, bool matchAll = false, bool matchCase = false, int elementType = 0, bool editableOnly = true)
|
|
|
//{
|
|
|
// return Drawer.FindElementByName(content, matchAll, matchCase, elementType, editableOnly);
|
|
|
//}
|
|
|
//public string GetCurrentLayer()
|
|
|
//{
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return string.Empty;
|
|
|
// }
|
|
|
// return geoSigma.GetCurrentLayer();
|
|
|
//}
|
|
|
//public void SetCurrentLayer(string layerName)
|
|
|
//{
|
|
|
// geoSigma?.SetCurrentLayer(layerName);
|
|
|
//}
|
|
|
//public bool RemoveCurveStyle(string layerName, int index)
|
|
|
//{
|
|
|
// if (geoSigma.RemoveCurveStyle(layerName, index))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
//public bool SetLayerHowtoViewPoint(string layerName, string data, bool replace)
|
|
|
//{
|
|
|
// if (geoSigma.SetLayerHowtoViewPoint(layerName, data, replace))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
//public bool SetLayerStyle(CurveView curveStyle, string layerName, int propertyIndex)
|
|
|
//{
|
|
|
// string strCurveStyle = ((CurveView)curveStyle).SerialXml();
|
|
|
// strCurveStyle = strCurveStyle.Replace("true", "1");
|
|
|
// strCurveStyle = strCurveStyle.Replace("false", "0");
|
|
|
|
|
|
// return this.SetLayerHowtoViewCurve(layerName, strCurveStyle, propertyIndex - 1);
|
|
|
//}
|
|
|
|
|
|
//public bool SetLayerHowtoViewCurve(string layerName, string data, int index)
|
|
|
//{
|
|
|
// if (geoSigma.SetLayerHowtoViewCurve(layerName, data, index))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool SetLayerMoveUpCurveStyle(string layerName, int index)
|
|
|
//{
|
|
|
// if (geoSigma.SetLayerMoveUpCurveStyle(layerName, index))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool SetLayerMoveDownCurveStyle(string layerName, int index)
|
|
|
//{
|
|
|
// if (geoSigma.SetLayerMoveDownCurveStyle(layerName, index))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool CreateLayerCurveStyle(string layerName, CurveStyleType type, string data)
|
|
|
//{
|
|
|
// if (geoSigma.CreateLayerCurveStyle(layerName, type, data))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
//public bool AddLayerCurveStyle(string layerName, CurveStyleType type, string data)
|
|
|
//{
|
|
|
// if (geoSigma.AddLayerCurveStyle(layerName, type, data))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool CreateLayerPointStyle(string layerName, string data)
|
|
|
//{
|
|
|
// if (geoSigma.CreateLayerPointStyle(layerName, data))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public void InvokeSelectedChanged(string elementData, long position)
|
|
|
//{
|
|
|
// this.SelectedElementPosition=position;
|
|
|
// if (SelectedElementChanged!=null)
|
|
|
// {
|
|
|
// SelectedElementChanged(this, new ElementArgs(elementData, position));
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// 添加点数据
|
|
|
///// </summary>
|
|
|
///// <param name="layerName">图层名称</param>
|
|
|
///// <param name="drawPoint">点数据</param>
|
|
|
//public void AddDrawPoint(string layerName, DrawerPoint drawPoint)
|
|
|
//{
|
|
|
// Drawer?.AddPoint(layerName, drawPoint);
|
|
|
//}
|
|
|
//public bool RemovePointStyle(string layerName)
|
|
|
//{
|
|
|
// if (geoSigma.RemovePointStyle(layerName))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
/// <summary>
|
|
|
/// Sets the state of the layer.
|
|
|
/// </summary>
|
|
|
/// <param name="layerName">Name of the layer.</param>
|
|
|
/// <param name="status">The status.</param>
|
|
|
//public void SetLayerState(string layerName, LayerStatus status)
|
|
|
//{
|
|
|
// geoSigma.SetLayerState(layerName, status);
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 按图层名称获取层数据
|
|
|
///// </summary>
|
|
|
///// <param name="name"></param>
|
|
|
///// <param name="holes"></param>
|
|
|
///// <param name="boundarys"></param>
|
|
|
///// <param name="wells"></param>
|
|
|
///// <returns></returns>
|
|
|
//public IntPtr GetLayerData(string name, string holes, string boundarys, string wells)
|
|
|
//{
|
|
|
// IntPtr ret = IntPtr.Zero;
|
|
|
// // 使用 Split 方法按分号分割字符串，并存储到数组中
|
|
|
// string[] holeArr = holes.Split(';');
|
|
|
// string[] boundaryArr = boundarys.Split(';');
|
|
|
// string[] wellArr = wells.Split(';');
|
|
|
// bool bHole = false;
|
|
|
// bool bBoundary = false;
|
|
|
// bool bWell = false;
|
|
|
|
|
|
// // 打印每个分割后的字符串
|
|
|
// foreach (string hole in holeArr)
|
|
|
// {
|
|
|
// if (hole == name)
|
|
|
// {
|
|
|
// bHole = true;
|
|
|
// break;
|
|
|
// }
|
|
|
// }
|
|
|
|
|
|
// // 打印每个分割后的字符串
|
|
|
// foreach (string boundary in boundaryArr)
|
|
|
// {
|
|
|
// if (boundary == name)
|
|
|
// {
|
|
|
// bBoundary = true;
|
|
|
// break;
|
|
|
// }
|
|
|
// }
|
|
|
|
|
|
// foreach (string well in wellArr)
|
|
|
// {
|
|
|
// if (well == name)
|
|
|
// {
|
|
|
// bWell = true;
|
|
|
// break;
|
|
|
// }
|
|
|
// }
|
|
|
|
|
|
// ret = geoSigma.GetLayerData(name, bHole, bBoundary, bWell);
|
|
|
// return ret;
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// Processes the mesh fault area.
|
|
|
///// </summary>
|
|
|
///// <param name="pRoot">The p root.</param>
|
|
|
///// <param name="pMainMesh">The p main mesh.</param>
|
|
|
//public void ProcessMeshFaultArea(IntPtr pRoot, IntPtr pMainMesh)
|
|
|
//{
|
|
|
// geoSigma.ProcessMeshFaultArea(pRoot, pMainMesh);
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// 按边界处理网格
|
|
|
///// </summary>
|
|
|
///// <param name="pRoot"></param>
|
|
|
///// <param name="pMainMesh"></param>
|
|
|
//public void ProcessMeshBoundary(IntPtr pRoot, IntPtr pMainMesh)
|
|
|
//{
|
|
|
// geoSigma.ProcessMeshBoundary(pRoot, pMainMesh);
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// Sets the VTK data node checked.
|
|
|
///// </summary>
|
|
|
///// <param name="pNodeData">The p node data.</param>
|
|
|
///// <param name="isChecked">if set to <c>true</c> [is checked].</param>
|
|
|
//public void SetVtkDataNodeChecked(IntPtr pNodeData, bool isChecked)
|
|
|
//{
|
|
|
// geoSigma.SetVtkDataNodeChecked(pNodeData, isChecked);
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// Sets the VTK data node hide.
|
|
|
///// </summary>
|
|
|
///// <param name="pNodeData">The p node data.</param>
|
|
|
///// <param name="isHide">if set to <c>true</c> [is hide].</param>
|
|
|
//public void SetVtkDataNodeHide(IntPtr pNodeData, bool isHide)
|
|
|
//{
|
|
|
// geoSigma.SetVtkDataNodeChecked(pNodeData, isHide);
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
/////
|
|
|
///// </summary>
|
|
|
///// <param name="pParent"></param>
|
|
|
///// <param name="pChild"></param>
|
|
|
//public void AddVtkDataNodeChild(IntPtr pParent, IntPtr pChild)
|
|
|
//{
|
|
|
// geoSigma.AddVtkDataNodeChild(pParent, pChild);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// Adds the data as symble.
|
|
|
///// </summary>
|
|
|
///// <param name="data">The data.</param>
|
|
|
///// <param name="symbolName">The symbol name.</param>
|
|
|
///// <param name="overwrite">If true, overwrite.</param>
|
|
|
///// <returns>An int.</returns>
|
|
|
//public int AddDataAsSymble(string data, string symbolName, bool overwrite = false)
|
|
|
//{
|
|
|
// return Drawer.Geo.AddDataAsSymble(data, symbolName, overwrite);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// Autos the join curves.
|
|
|
///// </summary>
|
|
|
///// <returns>An int.</returns>
|
|
|
//public int AutoJoinCurves()
|
|
|
//{
|
|
|
// FrmJoinCurves frmJoin = new FrmJoinCurves();
|
|
|
// if (frmJoin.ShowDialog(this) != DialogResult.OK)
|
|
|
// {
|
|
|
// return 0;
|
|
|
// }
|
|
|
// double dMaxError = frmJoin.MaxError;
|
|
|
// bool bOnlySameName = frmJoin.OnlySameName;
|
|
|
// return Drawer.Geo.Curve_AutoJoin(dMaxError, bOnlySameName);
|
|
|
//}
|
|
|
//private void Viewer_MouseWheel(object sender, MouseEventArgs e)
|
|
|
//{
|
|
|
// if (geoSigma==null) return;
|
|
|
// // 屏幕坐标偏移量
|
|
|
// int nOffsetScreen = this.VerticalScroll.Value -this.scrollPositionYLast;
|
|
|
|
|
|
// int nScreenAllVert = this.VerticalScroll.Maximum-this.VerticalScroll.Minimum;
|
|
|
// // 实际坐标偏移量
|
|
|
// double dOffsetReal = ((double)nOffsetScreen/nScreenAllVert)* this.mapRange.Height;
|
|
|
|
|
|
// geoSigma.Scroll((int)ScrollOrientation.VerticalScroll, dOffsetReal);
|
|
|
|
|
|
// scrollPositionYLast=this.VerticalScroll.Value;
|
|
|
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
//}
|
|
|
private void SetScrollBar(object sender, EventArgs e)
|
|
|
{
|
|
|
if (mViewType == GeoSigmaXY.eViewType.wellpole)
|
|
|
{
|
|
|
SetScrollBarForWellPole(sender, e);
|
|
|
return;
|
|
|
}
|
|
|
if (geoSigma == null)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
ScrollArgs args = e as ScrollArgs;
|
|
|
int hMax = 0, vMax = 0, hPage = 0, vPage = 0, hPos = 0, vPos = 0;
|
|
|
geoSigma.SetScrollBar(ref hMax, ref vMax, ref hPage, ref vPage, ref hPos, ref vPos);
|
|
|
if (hMax < 100)
|
|
|
{
|
|
|
hMax = 100;
|
|
|
}
|
|
|
if (vMax < 100)
|
|
|
{
|
|
|
vMax = 100;
|
|
|
}
|
|
|
if (hPos == 0)
|
|
|
{
|
|
|
//scrollH.Visible = false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
scrollH.Visible = true;
|
|
|
}
|
|
|
if (vPos == 0)
|
|
|
{
|
|
|
//scrollV.Visible = false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
scrollV.Visible = true;
|
|
|
}
|
|
|
|
|
|
if (hMax < args.ScreenRect.Width)
|
|
|
{
|
|
|
hMax = args.ScreenRect.Width;
|
|
|
hPage = hMax;
|
|
|
hPos = 0;
|
|
|
}
|
|
|
if (vMax < args.ScreenRect.Height)
|
|
|
{
|
|
|
vMax = args.ScreenRect.Height;
|
|
|
vPage = vMax;
|
|
|
vPos = 0;
|
|
|
}
|
|
|
// nMin、nPage、nPos与控件Min,LargeChange、value类似
|
|
|
// 但nMax相当于Max+LargeChange-1
|
|
|
int nMaxValueH = hMax; // hMax-hPage+1;
|
|
|
int nMaxValueV = vMax;
|
|
|
this.scrollH.Minimum = 0;
|
|
|
this.scrollH.Maximum = nMaxValueH;
|
|
|
this.scrollH.LargeChange = (int)((hPage * largeScrollFactor) + 0.5);
|
|
|
this.scrollH.SmallChange = (int)((hPage * 0.2) + 0.5);
|
|
|
if (hPos >= this.scrollH.Minimum && hPos <= this.scrollH.Maximum)
|
|
|
{
|
|
|
this.scrollH.Value = hPos;
|
|
|
}
|
|
|
|
|
|
this.scrollV.Minimum = 0;
|
|
|
this.scrollV.Maximum = nMaxValueV;
|
|
|
this.scrollV.LargeChange = vPage;
|
|
|
this.scrollV.SmallChange = (int)((vPage * 0.2) + 0.5);
|
|
|
if (vPos >= this.scrollV.Minimum && vPos <= this.scrollV.Maximum)
|
|
|
{
|
|
|
this.scrollV.Value = vPos;
|
|
|
}
|
|
|
|
|
|
this.drawer1.ScreenLocationChanged?.Invoke();
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
}
|
|
|
///// <summary>
|
|
|
///// 添加并激活新图层
|
|
|
///// </summary>
|
|
|
///// <param name="strLayerName"></param>
|
|
|
///// <param name="doActive">是否激活</param>
|
|
|
//public void FindAddLayer(string strLayerName, bool doActive = true)
|
|
|
//{
|
|
|
// geoSigma.FindAddLayer(strLayerName, doActive);
|
|
|
//}
|
|
|
//public void LayerRename(string oldName, string newName)
|
|
|
//{
|
|
|
// geoSigma.LayerRename(oldName, newName);
|
|
|
//}
|
|
|
//public void DeleteLayer(List<string> layers, bool withSubLayer = false)
|
|
|
//{
|
|
|
// geoSigma.DeleteLayer(layers.ToArray(), withSubLayer);
|
|
|
//}
|
|
|
//public bool DeleteLayerEmpty()
|
|
|
//{
|
|
|
// return geoSigma.DeleteLayerEmpty();
|
|
|
//}
|
|
|
//public bool GetLayerStyleData(string layerName, ref string curveStyle, ref string pointStyle)
|
|
|
//{
|
|
|
// return geoSigma.GetLayerStyleData(layerName, ref curveStyle, ref pointStyle);
|
|
|
//}
|
|
|
/// <summary>
|
|
|
/// 滚动条事件
|
|
|
/// </summary>
|
|
|
/// <param name="sender"></param>
|
|
|
/// <param name="e"></param>
|
|
|
private void Viewer_Scroll(object sender, ScrollEventArgs e)
|
|
|
{
|
|
|
if (e.Type == ScrollEventType.EndScroll)
|
|
|
{
|
|
|
//Scroll2(800);
|
|
|
return;
|
|
|
}
|
|
|
if (geoSigma == null) return;
|
|
|
|
|
|
if (e.ScrollOrientation == ScrollOrientation.HorizontalScroll)
|
|
|
{
|
|
|
if (Viewer_ScrollHori(sender, e) == true)
|
|
|
{
|
|
|
drawer1.IsViewStatusChanged = true;
|
|
|
}
|
|
|
}
|
|
|
else if (e.ScrollOrientation == ScrollOrientation.VerticalScroll)
|
|
|
{
|
|
|
if (Viewer_ScrollVert(sender, e))
|
|
|
{
|
|
|
drawer1.IsViewStatusChanged = true;
|
|
|
}
|
|
|
}
|
|
|
scrollPositionYLast = this.VerticalScroll.Value;
|
|
|
// 通知相关控件
|
|
|
drawer1.ScreenLocationChanged?.Invoke();
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 水平滚动条
|
|
|
/// </summary>
|
|
|
/// <param name="sender">sender</param>
|
|
|
/// <param name="e">参数</param>
|
|
|
private bool Viewer_ScrollHori(object sender, ScrollEventArgs e)
|
|
|
{
|
|
|
if (this.mViewType == GeoSigmaXY.eViewType.wellpole)
|
|
|
return ScrollHoriForWellPole((int)(e.ScrollOrientation), (int)e.Type, e.NewValue - e.OldValue);
|
|
|
else
|
|
|
return ScrollHori((int)(e.ScrollOrientation), (int)e.Type, e.NewValue - e.OldValue);
|
|
|
}
|
|
|
|
|
|
/// <param name="nOrientation">纵向、横向</param>
|
|
|
/// <param name="nType">ScrollEventType</param>
|
|
|
/// <param name="nValue">滚动条变化量</param>
|
|
|
private bool ScrollHori(int nOrientation, int nType, int nValue)
|
|
|
{
|
|
|
//geoSigma.HScroll(nType, e.NewValue, scrollH.Maximum-scrollH.LargeChange+1);
|
|
|
|
|
|
// 屏幕总宽度
|
|
|
int nScreenAllHor = this.scrollH.Maximum - this.scrollH.Minimum;
|
|
|
// 屏幕宽度 Ws
|
|
|
int nWs = drawer1.Width;
|
|
|
// 屏幕实际距离 Wr
|
|
|
double dWtest = geoSigma.GetRealWidth(nValue);
|
|
|
double dWs = geoSigma.GetRealWidth(nWs);
|
|
|
// dOffset = Wr*nValue/Ws;
|
|
|
double dOffset = 0;
|
|
|
if (Math.Abs(nValue) < 0.01)
|
|
|
{
|
|
|
// TODO:需要进一步修改屏幕滚动范围
|
|
|
if (nType == (int)ScrollEventType.SmallIncrement)
|
|
|
{
|
|
|
nValue = this.scrollH.SmallChange;
|
|
|
scrollH.Maximum = scrollH.Maximum + nValue;
|
|
|
double dF = (double)nValue / nWs;
|
|
|
dOffset = dWs * dF;
|
|
|
//drawer1.enlargeRight(dOffset);
|
|
|
needHScrollToEnd = true;
|
|
|
}
|
|
|
else if (nType == (int)ScrollEventType.SmallDecrement)
|
|
|
{
|
|
|
nValue = -this.scrollH.SmallChange;
|
|
|
scrollH.Minimum = scrollH.Minimum + nValue;
|
|
|
double dF = (double)nValue / nWs;
|
|
|
dOffset = dWs * dF;
|
|
|
//drawer1.enlargeLeft(Math.Abs(dOffset));
|
|
|
needHScrollToBegin = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
// 计算实际坐标变化量
|
|
|
// 变化比例
|
|
|
//double dF = (double)nValue/(nScreenAllHor-this.scrollH.LargeChange+1);
|
|
|
//dOffset=dF*drawer1.MapRange.Width;
|
|
|
double dF = (double)nValue / nWs;
|
|
|
dOffset = dWs * dF;
|
|
|
}
|
|
|
//Console.WriteLine(string.Format("offset {0}", dOffset));
|
|
|
geoSigma.Scroll(nOrientation, dOffset);
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
return true;
|
|
|
}
|
|
|
public void Scroll2(int scrollValue)
|
|
|
{
|
|
|
scrollH.Value = scrollValue;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 垂直滚动条
|
|
|
/// </summary>
|
|
|
/// <param name="sender"></param>
|
|
|
/// <param name="e"></param>
|
|
|
private bool Viewer_ScrollVert(object sender, ScrollEventArgs e)
|
|
|
{
|
|
|
if (this.mViewType == GeoSigmaXY.eViewType.wellpole)
|
|
|
return ScrollVertForWellPole((int)e.ScrollOrientation, (int)e.Type, e.NewValue - e.OldValue);
|
|
|
else
|
|
|
return ScrollVert((int)e.ScrollOrientation, (int)e.Type, e.NewValue - e.OldValue);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 竖向滚动.
|
|
|
/// </summary>
|
|
|
/// <param name="nOrientation">The n orientation.</param>
|
|
|
/// <param name="nType">The n type.</param>
|
|
|
/// <param name="nValue">The n value.</param>
|
|
|
/// <returns>A bool.</returns>
|
|
|
private bool ScrollVert(int nOrientation, int nType, int nValue)
|
|
|
{
|
|
|
int nScreenAllVert = this.scrollV.Maximum - this.scrollV.Minimum;
|
|
|
// 屏幕高度 Ws
|
|
|
int nHs = drawer1.Height;
|
|
|
// 屏幕实际距离 Wr
|
|
|
double dHs = geoSigma.GetRealHeight(nHs);
|
|
|
|
|
|
double dOffset = 0;
|
|
|
if (Math.Abs(nValue) < 0.01)
|
|
|
{
|
|
|
if (nType == (int)ScrollEventType.SmallIncrement)
|
|
|
{
|
|
|
nValue = this.scrollV.SmallChange;
|
|
|
scrollV.Maximum = scrollV.Maximum + nValue;
|
|
|
double dF = (double)nValue / nHs;
|
|
|
dOffset = dHs * dF;
|
|
|
//dOffset=((double)nValue/nScreenAllVert)*drawer1.MapRange.Height;
|
|
|
//drawer1.enlargeBottom(dOffset);
|
|
|
needVScrollToBottom = true;
|
|
|
}
|
|
|
else if (nType == (int)ScrollEventType.SmallDecrement)
|
|
|
{
|
|
|
nValue = -this.scrollV.SmallChange;
|
|
|
scrollV.Minimum = scrollV.Minimum + nValue;
|
|
|
double dF = (double)nValue / nHs;
|
|
|
dOffset = dHs * dF;
|
|
|
//dOffset=((double)nValue/nScreenAllVert)*drawer1.MapRange.Height;
|
|
|
//drawer1.enlargeTop(dOffset);
|
|
|
needVScrollToTop = true;
|
|
|
}
|
|
|
else { return false; }
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
//double dF = (double)nValue/(nScreenAllVert-this.scrollV.LargeChange+1);
|
|
|
//dOffset=dF* drawer1.MapRange.Height;
|
|
|
double dF = (double)nValue / nHs;
|
|
|
dOffset = dHs * dF;
|
|
|
}
|
|
|
geoSigma.Scroll(nOrientation, -dOffset);
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
return true;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 更新属性界面
|
|
|
/// </summary>
|
|
|
public void RefreshProperty()
|
|
|
{
|
|
|
drawer1?.RefreshProperty();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// //通过滑轮滚动图形
|
|
|
/// </summary>
|
|
|
/// <param name="bUp">true向上滚动图形 false向下滚动图形</param>
|
|
|
private void ScrollByWheel(bool bUp)
|
|
|
{
|
|
|
if (mViewType == GeoSigmaXY.eViewType.wellpole)
|
|
|
{
|
|
|
ScrollByWheelForWellPole(bUp);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (geoSigma == null)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
int nValue = this.scrollV.SmallChange;
|
|
|
|
|
|
if (bUp == false)
|
|
|
{
|
|
|
int v = scrollV.Value + nValue;
|
|
|
if (v > scrollV.Maximum)
|
|
|
{
|
|
|
scrollV.Maximum = v;
|
|
|
}
|
|
|
scrollV.Value = v;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
int v = scrollV.Value - nValue;
|
|
|
if (v < scrollV.Minimum)
|
|
|
{
|
|
|
scrollV.Minimum = v;
|
|
|
}
|
|
|
scrollV.Value = v;
|
|
|
}
|
|
|
|
|
|
int nHs = drawer1.Height; // 屏幕高度
|
|
|
|
|
|
double dHs = geoSigma.GetRealHeight(nHs); // 屏幕实际距离
|
|
|
double dF = (double)nValue / nHs;
|
|
|
double dOffset = dHs * dF;
|
|
|
|
|
|
if (bUp)
|
|
|
{
|
|
|
//1--ScrollOrientation.VerticalScroll
|
|
|
geoSigma.Scroll(1, dOffset);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
geoSigma.Scroll(1, -dOffset);
|
|
|
}
|
|
|
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
// 通知相关控件
|
|
|
drawer1.ScreenLocationChanged?.Invoke();
|
|
|
}
|
|
|
//public void GridGenerateContour()
|
|
|
//{
|
|
|
// drawer1?.GridGenerateContour();
|
|
|
//}
|
|
|
//public void GridSmooth()
|
|
|
//{
|
|
|
// drawer1?.GridSmooth();
|
|
|
//}
|
|
|
//public void GridStatics()
|
|
|
//{
|
|
|
// drawer1.GridStatics();
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// Creates the mesh by data async.
|
|
|
///// </summary>
|
|
|
///// <returns>A System.Threading.Tasks.Task.</returns>
|
|
|
//public async System.Threading.Tasks.Task CreateMeshByDataAsync()
|
|
|
//{
|
|
|
// await drawer1.CreateMeshByDataAsync();
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// Creates the mesh by Image async.
|
|
|
///// </summary>
|
|
|
///// <returns>A System.Threading.Tasks.Task.</returns>
|
|
|
//public async System.Threading.Tasks.Task CreateMeshByImageAsync()
|
|
|
//{
|
|
|
// await drawer1.CreateMeshByImageAsync();
|
|
|
//}
|
|
|
//public void ZoomIn()
|
|
|
//{
|
|
|
// drawer1.ZoomIn();
|
|
|
//}
|
|
|
//public void ZoomOut()
|
|
|
//{
|
|
|
// drawer1.ZoomOut();
|
|
|
//}
|
|
|
//public void ViewAll()
|
|
|
//{
|
|
|
// drawer1.ViewAll();
|
|
|
//}
|
|
|
//public void Extend(RectangleF rect)
|
|
|
//{
|
|
|
// drawer1.Extend(rect);
|
|
|
//}
|
|
|
//public void InitlizePaint(RectangleF rect)
|
|
|
//{
|
|
|
// drawer1.InitlizePaint(rect);
|
|
|
//}
|
|
|
private void Viewer_Resize(object sender, EventArgs e)
|
|
|
{
|
|
|
//drawer1.ReDraw();
|
|
|
}
|
|
|
//public void ReDrawWindow()
|
|
|
//{
|
|
|
// drawer1.ReDrawWindow();
|
|
|
//}
|
|
|
|
|
|
//private void ShowTipMessage(string tipMessage)
|
|
|
//{
|
|
|
// TipMessageHandler?.Invoke(tipMessage);
|
|
|
//}
|
|
|
private void drawer1_DrawerGotFocus(object sender, EventArgs e)
|
|
|
{
|
|
|
if (DrawerGotFocus != null)
|
|
|
{
|
|
|
DrawerGotFocus(sender, e);
|
|
|
}
|
|
|
}
|
|
|
///// <summary>
|
|
|
///// 创建泰森图.
|
|
|
///// </summary>
|
|
|
///// <returns>块数</returns>
|
|
|
//public int CreateVoronoi()
|
|
|
//{
|
|
|
// return geoSigma.CreateVoronoi();
|
|
|
//}
|
|
|
//public int CreateVoronoi2()
|
|
|
//{
|
|
|
// return 0;
|
|
|
//}
|
|
|
|
|
|
private bool ptInRange(IEnumerable<Coordinate> coors, Coordinate coor, GeometryFactory gf)
|
|
|
{
|
|
|
Coordinate coorStart = coors.First();//[0];
|
|
|
Coordinate coorEnd = coors.Last();//[coors.Count - 1];
|
|
|
double dDist = DistanceOp.Distance(gf.CreatePoint(coorStart), gf.CreatePoint(coorEnd));
|
|
|
LineString line = new LineString(coors.ToArray());
|
|
|
double dLength = line.Length;
|
|
|
// 不是闭合多边形
|
|
|
if (dDist > dLength * 0.1)
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
Polygon poly = null;
|
|
|
if (coorStart.X != coorEnd.X || coorStart.X != coorEnd.Y)
|
|
|
{
|
|
|
Coordinate[] caCoor = new Coordinate[coors.Count() + 1];
|
|
|
coors.ToArray().CopyTo(caCoor, 0);
|
|
|
caCoor[caCoor.Length - 1] = caCoor[0];
|
|
|
poly = gf.CreatePolygon(caCoor);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
poly = gf.CreatePolygon(coors.ToArray());
|
|
|
}
|
|
|
return poly.Covers(gf.CreatePoint(coor));
|
|
|
}
|
|
|
|
|
|
///// <summary>
|
|
|
///// 创建三角网
|
|
|
///// </summary>
|
|
|
///// <returns>块数</returns>
|
|
|
//public int CreateDelaunay()
|
|
|
//{
|
|
|
// return 0;
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 创建三角网
|
|
|
///// </summary>
|
|
|
///// <returns>块数</returns>
|
|
|
//public int CreateDelaunayConstraint()
|
|
|
//{
|
|
|
// return 0;
|
|
|
//}
|
|
|
private List<Polygon> safeUnion(List<Geometry> polygons)
|
|
|
{
|
|
|
if (polygons == null || polygons.Count == 0)
|
|
|
{
|
|
|
return new List<Polygon>();
|
|
|
}
|
|
|
if (polygons.Count == 1)
|
|
|
{
|
|
|
return new List<Polygon>() { (Polygon)polygons[0] };
|
|
|
}
|
|
|
|
|
|
var unionResult = new List<Polygon>();
|
|
|
var current = polygons[0];
|
|
|
|
|
|
for (int i = 1; i < polygons.Count; i++)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
current = current.Union(polygons[i]);
|
|
|
}
|
|
|
catch (TopologyException ex)
|
|
|
{
|
|
|
// 分步失败时尝试修复后合并
|
|
|
var cleaned2 = polygons[i].Buffer(0);
|
|
|
var pm = new PrecisionModel(1000); // 1e3 = 3位小数
|
|
|
var geom2Prec = GeometryPrecisionReducer.Reduce(cleaned2, pm);
|
|
|
current = OverlayNG.Overlay(current, geom2Prec, SpatialFunction.Union);
|
|
|
//double eps = 1e-6;
|
|
|
//var bufA = current.Buffer(eps);
|
|
|
//var bufB = polygons[i].Buffer(eps);
|
|
|
|
|
|
//var tmp = bufA.Union(bufB);
|
|
|
//current = tmp.Buffer(-eps);
|
|
|
|
|
|
Trace.WriteLine($"断层合并出错:{ex.Message}");
|
|
|
}
|
|
|
}
|
|
|
if (current is MultiPolygon muit)
|
|
|
{
|
|
|
return muit.Geometries.Cast<Polygon>().ToList();
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
unionResult.Add(current as Polygon);
|
|
|
}
|
|
|
return unionResult;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 将两个仅在单一顶点相连的多边形合并为一个连通 Polygon
|
|
|
/// </summary>
|
|
|
public static Polygon MergeAtSharedVertex(Polygon poly1, Polygon poly2)
|
|
|
{
|
|
|
// 1. 提取外环坐标并检测/修正方向
|
|
|
var coords1 = poly1.ExteriorRing.Coordinates;
|
|
|
var coords2 = poly2.ExteriorRing.Coordinates;
|
|
|
if (!NetTopologySuite.Algorithm.Orientation.IsCCWArea(coords1))
|
|
|
{
|
|
|
Array.Reverse(coords1);
|
|
|
}
|
|
|
|
|
|
if (!NetTopologySuite.Algorithm.Orientation.IsCCWArea(coords2))
|
|
|
{
|
|
|
Array.Reverse(coords2);
|
|
|
}
|
|
|
|
|
|
// 2. 定位唯一共享顶点
|
|
|
var shared = coords1.FirstOrDefault(c1 =>
|
|
|
coords2.Any(c2 => c1.Equals2D(c2)));
|
|
|
if (shared == null)
|
|
|
{
|
|
|
throw new InvalidOperationException("两多边形无共享顶点。");
|
|
|
}
|
|
|
|
|
|
int idx1 = Array.FindIndex(coords1, c => c.Equals2D(shared));
|
|
|
int idx2 = Array.FindIndex(coords2, c => c.Equals2D(shared));
|
|
|
|
|
|
// 3. 滚动坐标序列，使共享点为起点
|
|
|
CoordinateArrays.Scroll(coords1, idx1);
|
|
|
CoordinateArrays.Scroll(coords2, idx2);
|
|
|
|
|
|
// 4. 拼接两段序列并去重
|
|
|
var mergedCoords = coords1
|
|
|
.Concat(coords2.Skip(1))
|
|
|
.ToArray();
|
|
|
mergedCoords = CoordinateArrays.RemoveRepeatedPoints(mergedCoords);
|
|
|
|
|
|
// 5. 闭合环：首尾坐标必须相同
|
|
|
if (!mergedCoords[0].Equals2D(mergedCoords[mergedCoords.Length - 1]))
|
|
|
{
|
|
|
mergedCoords = mergedCoords
|
|
|
.Concat(new[] { mergedCoords[0] })
|
|
|
.ToArray();
|
|
|
}
|
|
|
|
|
|
// 6. 构造 LinearRing 并修复几何
|
|
|
var factory = NtsGeometryServices.Instance.CreateGeometryFactory();
|
|
|
var ring = factory.CreateLinearRing(mergedCoords);
|
|
|
var rawPoly = factory.CreatePolygon(ring);
|
|
|
return rawPoly;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 判断两个 Polygon 是否共享至少一个顶点
|
|
|
/// </summary>
|
|
|
private static bool PolygonsShareVertex(Polygon a, Polygon b)
|
|
|
{
|
|
|
return a.ExteriorRing.Coordinates
|
|
|
.Any(c1 => b.ExteriorRing.Coordinates
|
|
|
.Any(c2 => c1.Equals2D(c2))); // :contentReference[oaicite:8]{index=8}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 对多个仅在顶点相连的 Polygon 进行合并，返回合并后的连通面列表
|
|
|
/// </summary>
|
|
|
public static List<Polygon> MergeMultipleAtSharedVertex(IEnumerable<Geometry> polygons)
|
|
|
{
|
|
|
var list = polygons.ToList();
|
|
|
var visited = new bool[list.Count];
|
|
|
var result = new List<Polygon>();
|
|
|
|
|
|
for (int i = 0; i < list.Count; i++)
|
|
|
{
|
|
|
if (visited[i]) continue;
|
|
|
|
|
|
// 广度优先搜索构建连通分量
|
|
|
var queue = new Queue<int>();
|
|
|
queue.Enqueue(i);
|
|
|
visited[i] = true;
|
|
|
Polygon merged = list[i] as Polygon;
|
|
|
|
|
|
while (queue.Any())
|
|
|
{
|
|
|
int idx = queue.Dequeue();
|
|
|
for (int j = 0; j < list.Count; j++)
|
|
|
{
|
|
|
if (visited[j]) continue;
|
|
|
// 若与当前 merged 多边形或其成分共享顶点，则合并
|
|
|
if (PolygonsShareVertex(merged, list[j] as Polygon))
|
|
|
{
|
|
|
merged = MergeAtSharedVertex(merged, list[j] as Polygon);
|
|
|
visited[j] = true;
|
|
|
queue.Enqueue(j);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
result.Add(merged);
|
|
|
}
|
|
|
|
|
|
return result;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 辅助方法：在交叉点处分割线段
|
|
|
/// </summary>
|
|
|
/// <param name="line">线</param>
|
|
|
/// <param name="splitPoint">分割点</param>
|
|
|
/// <returns>分割后线</returns>
|
|
|
private static LineString splitLineAtPoint(LineString line, Coordinate splitPoint)
|
|
|
{
|
|
|
List<Coordinate> coords = line.Coordinates.ToList();
|
|
|
int index = coords.FindIndex(c => c.Equals2D(splitPoint, 1e-6));
|
|
|
|
|
|
// 如果交叉点已是顶点，无需拆分
|
|
|
if (index != -1)
|
|
|
{
|
|
|
return line;
|
|
|
}
|
|
|
PrecisionModel pm = new PrecisionModel(1e6); // 保留6位小数
|
|
|
Coordinate scaledSplitPoint = new Coordinate(pm.MakePrecise(splitPoint.X), pm.MakePrecise(splitPoint.Y));
|
|
|
// 插入新顶点并拆分
|
|
|
List<Coordinate> newCoords = new List<Coordinate>();
|
|
|
for (int i = 0; i < coords.Count - 1; i++)
|
|
|
{
|
|
|
newCoords.Add(coords[i]);
|
|
|
|
|
|
Coordinate coorA = new Coordinate(pm.MakePrecise(coords[i].X), pm.MakePrecise(coords[i].Y));
|
|
|
Coordinate coorB = new Coordinate(pm.MakePrecise(coords[i + 1].X), pm.MakePrecise(coords[i + 1].Y));
|
|
|
|
|
|
bool inRange2 =
|
|
|
splitPoint.X > Math.Min(coorA.X, coorB.X) && splitPoint.X < Math.Max(coorA.X, coorB.X) &&
|
|
|
splitPoint.Y > Math.Min(coorA.Y, coorB.Y) && splitPoint.Y < Math.Max(coorA.Y, coorB.Y);
|
|
|
if (inRange2 == false)
|
|
|
{
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
double dx1 = coorB.X - coorA.X, dy1 = coorB.Y - coorA.Y;
|
|
|
double dx2 = splitPoint.X - coorA.X, dy2 = splitPoint.Y - coorA.Y;
|
|
|
double det = (dx1 * dy2) - (dy1 * dx2);
|
|
|
// 自定义阈值
|
|
|
double EPS = 1e-3;
|
|
|
OrientationIndex orient;
|
|
|
if (Math.Abs(det) <= EPS)
|
|
|
{
|
|
|
orient = OrientationIndex.Straight;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
orient = det > 0
|
|
|
? OrientationIndex.CounterClockwise
|
|
|
: OrientationIndex.Clockwise;
|
|
|
}
|
|
|
|
|
|
//OrientationIndex orient = NetTopologySuite.Algorithm.Orientation.Index(coorA, coorB, splitPoint);
|
|
|
if (orient == OrientationIndex.Straight)
|
|
|
{
|
|
|
newCoords.Add(splitPoint);
|
|
|
}
|
|
|
}
|
|
|
newCoords.Add(coords[coords.Count - 1]);
|
|
|
|
|
|
// 生成拆分后的线段
|
|
|
return new LineString(newCoords.ToArray());
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// creates the index line.
|
|
|
/// </summary>
|
|
|
/// <param name="geoSource">The geo source.</param>
|
|
|
/// <param name="ptsDest">The pts dest.</param>
|
|
|
/// <returns>A list of int.</returns>
|
|
|
private List<int> createIndexLine(Geometry geoSource, List<Vec2> ptsDest)
|
|
|
{
|
|
|
List<int> lstLine = new List<int>();
|
|
|
foreach (Coordinate coor in geoSource.Coordinates)
|
|
|
{
|
|
|
int nIndexFind = ptsDest.FindIndex((it) => { return it.x == coor.X && it.y == coor.Y; });
|
|
|
if (nIndexFind < 0)
|
|
|
{
|
|
|
ptsDest.Add(new Vec2(coor.X, coor.Y));
|
|
|
lstLine.Add(ptsDest.Count - 1);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
lstLine.Add(nIndexFind);
|
|
|
}
|
|
|
}
|
|
|
return lstLine;
|
|
|
}
|
|
|
/// <summary>
|
|
|
/// 判断线是否闭合.
|
|
|
/// </summary>
|
|
|
/// <param name="line">The line.</param>
|
|
|
/// <returns>A bool.</returns>
|
|
|
private bool isLineRing(LineString line)
|
|
|
{
|
|
|
double dDistance = line[0].Distance(line[line.Count - 1]);
|
|
|
double dLength = line.Length;
|
|
|
if (dDistance < dLength * 0.075)
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
private void HandleEmptyNameCurve(string xmlOfEmptyNameCurves)
|
|
|
{
|
|
|
ENCurveLoadHandler?.Invoke(xmlOfEmptyNameCurves);
|
|
|
}
|
|
|
///// <summary>
|
|
|
///// 选择图元事件
|
|
|
///// </summary>
|
|
|
///// <param name="sender">发送者</param>
|
|
|
///// <param name="e">事件参数</param>
|
|
|
//private void drawer1_SelectedElementChanged(object sender, ElementArgs e)
|
|
|
//{
|
|
|
// if (e == null)
|
|
|
// {
|
|
|
// this.SelectedElementPosition = -1;
|
|
|
// SelectedElementChanged?.Invoke(sender, null);
|
|
|
// return;
|
|
|
// }
|
|
|
|
|
|
// this.SelectedElementPosition = e.Position;
|
|
|
// SelectedElementChanged?.Invoke(sender, e);
|
|
|
//}
|
|
|
//public bool SetElementProperty(string elementData)
|
|
|
//{
|
|
|
// if (geoSigma.SelectSetElement(elementData, SelectedElementPosition)) // , data, index
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 将选中图元保存为模版.
|
|
|
///// </summary>
|
|
|
///// <param name="outputFile">The output file.</param>
|
|
|
///// <returns>是否成功</returns>
|
|
|
//public bool SelectWriteTemplate(string outputFile)
|
|
|
//{
|
|
|
// if (geoSigma == null)
|
|
|
// {
|
|
|
// return false;
|
|
|
// }
|
|
|
// return geoSigma.SelectWriteTemplate(outputFile);
|
|
|
//}
|
|
|
|
|
|
//public bool SelectRemoveCurveStyle(int index)
|
|
|
//{
|
|
|
// if (geoSigma.SelectRemoveCurveStyle(SelectedElementPosition, index))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool SelectRemovePointStyle()
|
|
|
//{
|
|
|
// if (geoSigma.SelectRemovePointStyle(SelectedElementPosition))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool SelectMoveUpCurveStyle(int index)
|
|
|
//{
|
|
|
// if (geoSigma.SelectMoveUpCurveStyle(SelectedElementPosition, index))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool SelectMoveDownCurveStyle(int index)
|
|
|
//{
|
|
|
// if (geoSigma.SelectMoveDownCurveStyle(SelectedElementPosition, index))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool SelectCreateCurveStyle(CurveStyleType type, string data)
|
|
|
//{
|
|
|
// if (geoSigma.SelectCreateCurveStyle(SelectedElementPosition, type, data))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 重命名图元
|
|
|
///// </summary>
|
|
|
///// <param name="oldName">旧名称</param>
|
|
|
///// <param name="newName">新名称</param>
|
|
|
///// <param name="layerName">图层</param>
|
|
|
///// <returns>替换的数量</returns>
|
|
|
//public int RenameElement(string oldName, string newName, string layerName)
|
|
|
//{
|
|
|
// return geoSigma.RenameElement(oldName, newName, layerName);
|
|
|
//}
|
|
|
/// <summary>
|
|
|
/// 设置线的属性
|
|
|
/// </summary>
|
|
|
/// <param name="curveName">名称</param>
|
|
|
/// <param name="layerName">图层</param>
|
|
|
/// <param name="curveStyle">属性</param>
|
|
|
/// <returns>应用数量</returns>
|
|
|
//public int ResetCurveStyle(string curveName, string layerName, CurveView curveStyle)
|
|
|
//{
|
|
|
// string strStyleData = curveStyle.SerialXml();
|
|
|
// int nCount = geoSigma.ResetCurveStyle(curveName, layerName, (int)curveStyle.StyleType, strStyleData);
|
|
|
|
|
|
// if (nCount > 0)
|
|
|
// {
|
|
|
// Drawer.UpdateElementSelected();
|
|
|
// }
|
|
|
// return 0;
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 获得选中点的样式
|
|
|
///// </summary>
|
|
|
///// <param name="data">数据</param>
|
|
|
///// <returns>是否成功</returns>
|
|
|
//public bool SelectCreatePointStyle(string data)
|
|
|
//{
|
|
|
// if (geoSigma.SelectCreatePointStyle(SelectedElementPosition, data))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
|
|
|
//public bool SelectGetLayerName(out string layer)
|
|
|
//{
|
|
|
// if (SelectedElementPosition <= 0)
|
|
|
// {
|
|
|
// layer = string.Empty;
|
|
|
// return false;
|
|
|
// }
|
|
|
// return geoSigma.SelectGetLayerName(SelectedElementPosition, out layer);
|
|
|
//}
|
|
|
|
|
|
//public bool SelectSetLayerByName(string layer)
|
|
|
//{
|
|
|
// if (geoSigma.SelectSetLayerByName(SelectedElementPosition, layer))
|
|
|
// {
|
|
|
// geoSigma.EnableRedraw(true);
|
|
|
// return true;
|
|
|
// }
|
|
|
// return false;
|
|
|
//}
|
|
|
//public void EnableCrossLine(bool enable)
|
|
|
//{
|
|
|
// drawer1.EnableCrossLine = enable;
|
|
|
//}
|
|
|
// 窗口尺寸变化
|
|
|
private void DrawViewer_SizeChanged(object sender, EventArgs e)
|
|
|
{
|
|
|
ReDrawWindow();
|
|
|
}
|
|
|
|
|
|
private void ScrollScreenAndBar(ScrollKind kind)
|
|
|
{
|
|
|
int offset = 30;
|
|
|
if (kind == ScrollKind.Left)
|
|
|
{
|
|
|
if (scrollH.Minimum == scrollH.Value) //说明上一次按向右的箭头
|
|
|
return;
|
|
|
|
|
|
int v = scrollH.Value - offset; //直接减的话 scrollH.Value可能为负数 如果为负数 程序就崩溃了 所以做了一个判断
|
|
|
if (v < scrollH.Minimum) //第一次到达最左侧 滚动一次。不然 总是看不到最顶部的图形
|
|
|
{
|
|
|
v = scrollH.Minimum;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
scrollH.Value = v;
|
|
|
ScrollHori((int)ScrollOrientation.HorizontalScroll, (int)ScrollEventType.LargeDecrement, -offset);
|
|
|
}
|
|
|
else if (kind == ScrollKind.Right)
|
|
|
{
|
|
|
int v = scrollH.Value + offset;
|
|
|
if (v > scrollH.Maximum)
|
|
|
{
|
|
|
scrollH.Value = scrollH.Maximum;
|
|
|
return;
|
|
|
}
|
|
|
scrollH.Value = v;
|
|
|
ScrollHori((int)ScrollOrientation.HorizontalScroll, (int)ScrollEventType.LargeDecrement, offset);
|
|
|
}
|
|
|
else if (kind == ScrollKind.Up)
|
|
|
{
|
|
|
if (scrollV.Minimum == scrollV.Value)
|
|
|
return;
|
|
|
|
|
|
int v = scrollV.Value - offset;
|
|
|
if (v < scrollV.Minimum)
|
|
|
{
|
|
|
v = scrollV.Minimum;
|
|
|
}
|
|
|
|
|
|
scrollV.Value = v;
|
|
|
ScrollVert((int)ScrollOrientation.VerticalScroll, (int)ScrollEventType.LargeDecrement, -offset);
|
|
|
}
|
|
|
else if (kind == ScrollKind.Down)
|
|
|
{
|
|
|
int v = scrollV.Value + offset;
|
|
|
if (v > scrollV.Maximum)
|
|
|
{
|
|
|
scrollV.Value = scrollV.Maximum;
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
scrollV.Value = v;
|
|
|
ScrollVert((int)ScrollOrientation.VerticalScroll, (int)ScrollEventType.LargeDecrement, offset);
|
|
|
}
|
|
|
else if (kind == ScrollKind.PageDown)
|
|
|
{
|
|
|
if (scrollV.Value == scrollV.Maximum)
|
|
|
return;
|
|
|
|
|
|
double offsetW;
|
|
|
int offsetS;
|
|
|
CalculateVOffset(out offsetW, out offsetS);
|
|
|
int v = scrollV.Value + offsetS;
|
|
|
if (v > scrollV.Maximum)
|
|
|
{
|
|
|
v = scrollV.Maximum;
|
|
|
}
|
|
|
|
|
|
scrollV.Value = v;
|
|
|
ScrollVert((int)ScrollOrientation.VerticalScroll, (int)ScrollEventType.LargeDecrement, offsetS);
|
|
|
}
|
|
|
else if (kind == ScrollKind.PageUp)
|
|
|
{
|
|
|
if (scrollV.Value == scrollV.Minimum)
|
|
|
return;
|
|
|
|
|
|
double offsetW;
|
|
|
int offsetS;
|
|
|
CalculateVOffset(out offsetW, out offsetS);
|
|
|
int v = scrollV.Value - offsetS;
|
|
|
if (v < scrollV.Minimum)
|
|
|
{
|
|
|
v = scrollV.Minimum;
|
|
|
}
|
|
|
|
|
|
scrollV.Value = v;
|
|
|
ScrollVert((int)ScrollOrientation.VerticalScroll, (int)ScrollEventType.LargeDecrement, -offsetS);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void CalculateVOffset(out double offsetW, out int offsetS)
|
|
|
{
|
|
|
offsetW = 0;
|
|
|
offsetS = 0;
|
|
|
// 屏幕高度 Ws
|
|
|
double totalHWolrd = Math.Abs(geoSigma.GetRealHeight(scrollV.Maximum)); //图纸的总高度
|
|
|
if (totalHWolrd < 1)
|
|
|
return;
|
|
|
|
|
|
double hWorld = Math.Abs(geoSigma.GetRealHeight(drawer1.Height)); //屏幕高度对应的图纸中的高度
|
|
|
double offsetScroll = scrollV.Maximum * hWorld / totalHWolrd;
|
|
|
offsetS = (int)offsetScroll; // (int)(drawer1.Height * offsetScroll / (double)scrollV.Maximum);
|
|
|
offsetW = hWorld;
|
|
|
}
|
|
|
|
|
|
|
|
|
private void OnChangeLayer(string eventKind)
|
|
|
{
|
|
|
ChangeLayerEvent?.Invoke(eventKind);
|
|
|
}
|
|
|
|
|
|
//private void drawer1_MouseMove(object sender, MouseEventArgs e)
|
|
|
//{
|
|
|
// if (!string.IsNullOrWhiteSpace(drawer1.MouseMoveInfo))
|
|
|
// {
|
|
|
// MouseMoveEvent?.Invoke(drawer1.MouseMoveInfo);
|
|
|
// }
|
|
|
// else
|
|
|
// {
|
|
|
// string mouseXY = string.Empty;
|
|
|
// if (geoSigma != null)
|
|
|
// {
|
|
|
// geoSigma.GetMouseMoveXY(e.X, e.Y, ref mouseXY);
|
|
|
// MouseMoveEvent?.Invoke(mouseXY);
|
|
|
// }
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
///// <summary>
|
|
|
///// 为常用菜单添加命令.
|
|
|
///// </summary>
|
|
|
///// <param name="text">The text.</param>
|
|
|
///// <param name="handler">The handler.</param>
|
|
|
///// <param name="needElement">if set to <c>true</c> [need element].</param>
|
|
|
//public void InsertCommonCommand(string text, EventHandler handler, bool needElement = true
|
|
|
// , DrawElementType elementType = DrawElementType.ELEMENT_UNKNOWN)
|
|
|
//{
|
|
|
// drawer1?.InsertCommonCommand(text, handler, needElement
|
|
|
// , elementType);
|
|
|
//}
|
|
|
/// <summary>
|
|
|
/// 获得图层的数据
|
|
|
/// </summary>
|
|
|
/// <param name="layerName">图层名称</param>
|
|
|
/// <returns>数据列表</returns>
|
|
|
//public List<DrawerElementProperty> GetDataByLayer(string layerName)
|
|
|
//{
|
|
|
// return drawer1?.GetDataByLayer(layerName);
|
|
|
//}
|
|
|
//public List<DrawerElementProperty> GetLayerCurve(string layerName)
|
|
|
//{
|
|
|
// return drawer1?.GetLayerCurve(layerName);
|
|
|
//}
|
|
|
///// <summary>
|
|
|
///// 获得选中的所有图元
|
|
|
///// </summary>
|
|
|
///// <returns>选中图元的列表</returns>
|
|
|
//public List<DrawerElementProperty> GetSelectedElements()
|
|
|
//{
|
|
|
// return drawer1?.GetSelectedElements();
|
|
|
//}
|
|
|
///// <summary>
|
|
|
/////
|
|
|
///// </summary>
|
|
|
///// <param name="Bitmap"></param>
|
|
|
///// <returns></returns>
|
|
|
//private static Image Bitmap2Image(System.Drawing.Bitmap Bi)
|
|
|
//{
|
|
|
// MemoryStream ms = new MemoryStream();
|
|
|
// Bi.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
|
|
|
// BitmapImage bImage = new BitmapImage();
|
|
|
// bImage.BeginInit();
|
|
|
// bImage.StreamSource=new MemoryStream(ms.ToArray());
|
|
|
// bImage.EndInit();
|
|
|
// ms.Dispose();
|
|
|
// Bi.Dispose();
|
|
|
// Image i = new Image();
|
|
|
// i.Source=bImage;
|
|
|
// return i;
|
|
|
//}
|
|
|
private void SetScrollBarForWellPole(object sender, EventArgs e)
|
|
|
{
|
|
|
if (geoSigma == null)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
ScrollArgs args = e as ScrollArgs;
|
|
|
int hMax = 0, vMax = 0, hPage = 0, vPage = 0, hPos = 0, vPos = 0;
|
|
|
geoSigma.SetScrollBar(ref hMax, ref vMax, ref hPage, ref vPage, ref hPos, ref vPos);
|
|
|
if (hMax < 100)
|
|
|
{
|
|
|
hMax = 100;
|
|
|
}
|
|
|
if (vMax < 100)
|
|
|
{
|
|
|
vMax = 100;
|
|
|
}
|
|
|
if (hPos == 0)
|
|
|
{
|
|
|
//scrollH.Visible = false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
scrollH.Visible = true;
|
|
|
}
|
|
|
if (vPos == 0)
|
|
|
{
|
|
|
//scrollV.Visible = false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
scrollV.Visible = true;
|
|
|
}
|
|
|
Console.WriteLine($"set scroll bar vmax= {vMax}, vmin = {hMax}, vpos = {vPos}");
|
|
|
if (hMax < args.ScreenRect.Width)
|
|
|
{
|
|
|
hMax = hMax + 20;// args.ScreenRect.Width;
|
|
|
hPage = hMax;
|
|
|
hPos = 0;
|
|
|
}
|
|
|
if (vMax < args.ScreenRect.Height)
|
|
|
{
|
|
|
vMax = args.ScreenRect.Height;
|
|
|
vPage = vMax;
|
|
|
vPos = 0;
|
|
|
}
|
|
|
// nMin、nPage、nPos与控件Min,LargeChange、value类似
|
|
|
// 但nMax相当于Max+LargeChange-1
|
|
|
int nMaxValueH = hMax; // hMax-hPage+1;
|
|
|
int nMaxValueV = vMax;
|
|
|
this.scrollH.Minimum = 0;
|
|
|
this.scrollH.Maximum = nMaxValueH;
|
|
|
this.scrollH.LargeChange = (int)((hPage * largeScrollFactor) + 0.5);
|
|
|
this.scrollH.SmallChange = (int)((hPage * 0.2) + 0.5);
|
|
|
if (hPos >= this.scrollH.Minimum && hPos <= this.scrollH.Maximum)
|
|
|
{
|
|
|
this.scrollH.Value = hPos;
|
|
|
}
|
|
|
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
if (GeoSigmaWellPoleXY.IsLockWellHead())
|
|
|
{
|
|
|
int maxV, pageV, posV;
|
|
|
maxV = pageV = posV = 0;
|
|
|
GeoSigmaWellPoleXY.SetScrollBarVRangeForLockWellHead(ref maxV, ref pageV, ref posV);
|
|
|
this.scrollV.Minimum = 0;
|
|
|
this.scrollV.Maximum = maxV;
|
|
|
this.scrollV.LargeChange = pageV;
|
|
|
this.scrollV.SmallChange = (int)((pageV * 0.2) + 0.5);
|
|
|
if (posV >= this.scrollV.Minimum && posV <= this.scrollV.Maximum)
|
|
|
{
|
|
|
this.scrollV.Value = posV;
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
this.scrollV.Minimum = 0;
|
|
|
this.scrollV.Maximum = nMaxValueV;
|
|
|
this.scrollV.LargeChange = vPage;
|
|
|
this.scrollV.SmallChange = (int)((vPage * 0.2) + 0.5);
|
|
|
if (vPos >= this.scrollV.Minimum && vPos <= this.scrollV.Maximum)
|
|
|
{
|
|
|
this.scrollV.Value = vPos;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
this.drawer1.ScreenLocationChanged?.Invoke();
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
}
|
|
|
|
|
|
public override void SetLockWellHead()
|
|
|
{
|
|
|
drawer1.SetLockWellHead();
|
|
|
drawer1.ResetScrollbar();
|
|
|
}
|
|
|
|
|
|
//public void AddTrack()
|
|
|
//{//test code
|
|
|
// GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
// int[] typeIdArr = new int[0];
|
|
|
// string[] typeStrArr = new string[0];
|
|
|
// GeoSigmaWellPoleXY.GetWellTrackTypeInfo(ref typeIdArr, ref typeStrArr);
|
|
|
|
|
|
// int[] addTypes = new int[3];
|
|
|
// addTypes[0] = (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Text);
|
|
|
// addTypes[1] = (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Curve);
|
|
|
// addTypes[2] = (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Symbol);
|
|
|
// bool b = GeoSigmaWellPoleXY.AddTrackAfterSelectedWellObject(addTypes, 3);
|
|
|
//}
|
|
|
|
|
|
//public void DeleteSelectedWellObject()
|
|
|
//{
|
|
|
// GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
// bool b = GeoSigmaWellPoleXY.DeleteSelectedWellObject();
|
|
|
//}
|
|
|
|
|
|
public void CombineLeftTrack()
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
bool b = GeoSigmaWellPoleXY.SelectedTrackCombineLeftTrack();
|
|
|
}
|
|
|
|
|
|
public void CombineRightTrack()
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
bool b = GeoSigmaWellPoleXY.SelectedTrackCombineRightTrack();
|
|
|
}
|
|
|
|
|
|
public override void AddPictureToWellTrack()
|
|
|
{
|
|
|
OpenFileDialog openFileDialog = new OpenFileDialog();
|
|
|
openFileDialog.Title = "选择图片文件";
|
|
|
openFileDialog.Filter = "图片文件|*.jpg;*.jpeg;*.png;*.bmp;*.gif|所有文件|*.*";
|
|
|
openFileDialog.FilterIndex = 1;
|
|
|
openFileDialog.RestoreDirectory = true;
|
|
|
openFileDialog.Multiselect = false; // 是否允许多选
|
|
|
|
|
|
if (openFileDialog.ShowDialog() == DialogResult.OK)
|
|
|
{
|
|
|
string filePath = openFileDialog.FileName;
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
if (GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref thandle))
|
|
|
{
|
|
|
if (type == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACKINDATA)
|
|
|
&& ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_IMAGE))
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.SetPictureInWellTrack(thandle, filePath);
|
|
|
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
//public GeoSigmaWellPoleXY.NewWellInfo mNewWellInfo = new GeoSigmaWellPoleXY.NewWellInfo();
|
|
|
|
|
|
public void testGetWellObjectProperties()
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
|
|
|
UInt64 wellHandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle);
|
|
|
string[] stratificationClass;
|
|
|
GeoSigmaWellPoleXY.GetWellStratificationClasses(wellHandle, out stratificationClass);
|
|
|
|
|
|
string[] resultSymbols;
|
|
|
GeoSigmaWellPoleXY.GetSymbolNamesForResult(out resultSymbols);
|
|
|
Bitmap bmp = new Bitmap(50, 50);
|
|
|
Graphics gBmp = Graphics.FromImage(bmp);
|
|
|
IntPtr pBmpDC = gBmp.GetHdc();
|
|
|
GeoSigmaWellPoleXY.GetDrawSymbolForResult(resultSymbols[0], pBmpDC, 50, 50);
|
|
|
|
|
|
string[] lithSymbols;
|
|
|
GeoSigmaWellPoleXY.GetSymbolNamesForLithology(out lithSymbols);
|
|
|
Bitmap lithbmp = new Bitmap(50, 50);
|
|
|
Graphics lithgBmp = Graphics.FromImage(lithbmp);
|
|
|
IntPtr plithBmpDC = lithgBmp.GetHdc();
|
|
|
GeoSigmaWellPoleXY.GetDrawSymbolForLithology(lithSymbols[0], plithBmpDC, 50, 50);
|
|
|
|
|
|
string[] lithConSymbols;
|
|
|
GeoSigmaWellPoleXY.GetSymbolNamesForLithConstitution(out lithConSymbols);
|
|
|
Bitmap lithconbmp = new Bitmap(50, 50);
|
|
|
Graphics lithcongBmp = Graphics.FromImage(lithconbmp);
|
|
|
IntPtr plithconBmpDC = lithcongBmp.GetHdc();
|
|
|
GeoSigmaWellPoleXY.GetDrawSymbolForLithConstitution(lithConSymbols[0], plithconBmpDC, 50, 50);
|
|
|
|
|
|
string[] framesLine;
|
|
|
GeoSigmaWellPoleXY.GetWellFrameLineNames(out framesLine);
|
|
|
Bitmap wellLinebmp = new Bitmap(100, 30);
|
|
|
Graphics wellLinegBmp = Graphics.FromImage(wellLinebmp);
|
|
|
IntPtr wellLineBmpDC = wellLinegBmp.GetHdc();
|
|
|
GeoSigmaWellPoleXY.GetDrawWellFrameLine(framesLine[2], wellLineBmpDC, 100, 30);
|
|
|
|
|
|
string[] normalSymbs;
|
|
|
GeoSigmaWellPoleXY.GetNormalSymbolNames(out normalSymbs);
|
|
|
Bitmap norsybbmp = new Bitmap(100, 30);
|
|
|
Graphics gnorsybbmp = Graphics.FromImage(norsybbmp);
|
|
|
IntPtr gnorsybbmpDC = gnorsybbmp.GetHdc();
|
|
|
GeoSigmaWellPoleXY.GetDrawNormalSymbol(normalSymbs[2], gnorsybbmpDC, 100, 30);
|
|
|
|
|
|
|
|
|
string[] CurvePointSymbolNames;
|
|
|
GeoSigmaWellPoleXY.GetCurvePointSymbolNames(out CurvePointSymbolNames);
|
|
|
Bitmap wellptbmp = new Bitmap(100, 30);
|
|
|
Graphics wellptgbmp = Graphics.FromImage(wellptbmp);
|
|
|
IntPtr pwellptbmp = wellptgbmp.GetHdc();
|
|
|
GeoSigmaWellPoleXY.GetDrawCurvePointSymbol(CurvePointSymbolNames[2], pwellptbmp, 100, 30);
|
|
|
|
|
|
string[] stratumLithSymbolNames;
|
|
|
GeoSigmaWellPoleXY.GetStratumLithNames(out stratumLithSymbolNames);
|
|
|
Bitmap slithbmp = new Bitmap(100, 30);
|
|
|
Graphics swellptgbmp = Graphics.FromImage(slithbmp);
|
|
|
IntPtr pswellptbmp = swellptgbmp.GetHdc();
|
|
|
GeoSigmaWellPoleXY.GetDrawStratumLith(stratumLithSymbolNames[2], pswellptbmp, 100, 30);
|
|
|
|
|
|
string[] curveLine;
|
|
|
GeoSigmaWellPoleXY.GetWellCurveLineNames(out curveLine);
|
|
|
|
|
|
List<cPerforation> listPerforations = workAreaDb.Instance.workData.getWellPerforations("DD7-3");
|
|
|
|
|
|
List<cWellInnerLayer> listInnerLayers = workAreaDb.Instance.workData.getInnerLayers("D6-1");
|
|
|
|
|
|
List<cWellCycle> lstLongCycles = workAreaDb.Instance.workData.getWellCycles("D6-1", 1);
|
|
|
List<cWellCycle> lstMediumCycles = workAreaDb.Instance.workData.getWellCycles("D6-1", 2);
|
|
|
List<cWellCycle> lstShorCycles = workAreaDb.Instance.workData.getWellCycles("D6-1", 3);
|
|
|
|
|
|
string strInnerLayer = "";
|
|
|
WellDataConvert.getInnerLayersJson(ref strInnerLayer, listInnerLayers);
|
|
|
|
|
|
List<cWellLithology> lstLiths = workAreaDb.Instance.workData.getWellLithologys("DD7-3");
|
|
|
string strLithJson = "";
|
|
|
WellDataConvert.getWellLithologysJson(ref strLithJson, lstLiths);
|
|
|
|
|
|
List<cWellOilTest> lstOilTest = workAreaDb.Instance.workData.getWellOilTests("DD7-3");
|
|
|
string strOilTestJson = "";
|
|
|
WellDataConvert.getWellOilTestJson(ref strLithJson, lstOilTest);
|
|
|
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
ulong objHandle = 0;
|
|
|
bool b = GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref objHandle);
|
|
|
if (b)
|
|
|
{
|
|
|
string[] curveNames;
|
|
|
GeoSigmaWellPoleXY.GetWellAllCurveNames(objHandle, out curveNames);
|
|
|
|
|
|
string[] discreteNames;
|
|
|
GeoSigmaWellPoleXY.GetWellAllDiscreteNames(objHandle, out discreteNames);
|
|
|
|
|
|
string strXml = "";
|
|
|
|
|
|
b = GeoSigmaWellPoleXY.GetWellObjectAttributesXml(objHandle, type, ttype, ref strXml);
|
|
|
if (b)
|
|
|
{
|
|
|
XmlDocument xmlDoc = new XmlDocument();
|
|
|
try
|
|
|
{
|
|
|
xmlDoc.LoadXml(strXml);
|
|
|
|
|
|
b = GeoSigmaWellPoleXY.SetWellObjectAttributesXml(objHandle, type, ttype, strXml);
|
|
|
}
|
|
|
catch (XmlException xmle)
|
|
|
{
|
|
|
Console.WriteLine(xmle.Message);
|
|
|
}
|
|
|
}
|
|
|
//b = GeoSigmaWellPoleXY.GetWellObjectAttributesJson(objHandle, type, ttype, ref strJson);
|
|
|
//if (b)
|
|
|
//{
|
|
|
// JObject json = JObject.Parse(strJson);
|
|
|
// //JObject propJson = (JObject)json["properties"];
|
|
|
// //JObject inDataJson = (JObject)propJson["道内对象设置"];
|
|
|
// //inDataJson["控制岩性宽度"] = false;
|
|
|
// //string strJsonData = JsonConvert.SerializeObject(json);
|
|
|
// byte[] databytes = Encoding.UTF8.GetBytes(strJson);
|
|
|
// string jsonUtf8 = Encoding.ASCII.GetString(databytes);//
|
|
|
// GeoSigmaWellPoleXY.SetWellObjectAttributesJson(objHandle, type, ttype, databytes, databytes.Length);
|
|
|
//}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//public void ViewExtendCenter()
|
|
|
//{
|
|
|
// drawer1.ViewExtendCenter();
|
|
|
//}
|
|
|
|
|
|
//public void ViewExtendWidth()
|
|
|
//{
|
|
|
// drawer1.ViewExtendWidth();
|
|
|
//}
|
|
|
|
|
|
private bool ScrollVertForWellPole(int nOrientation, int nType, int nValue)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)drawer1.Geo;
|
|
|
if (GeoSigmaWellPoleXY.IsLockWellHead())
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.ScrollVForLockWellHead(nType, scrollV.Value, scrollV.LargeChange, scrollV.SmallChange, scrollV.Minimum, scrollV.Maximum);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
|
|
|
int nHs = drawer1.Height;
|
|
|
// 屏幕实际距离 Wr
|
|
|
double dHs = geoSigma.GetRealHeight(nHs);
|
|
|
|
|
|
double dOffset = 0;
|
|
|
int sliderBlockLen = scrollV.Value + scrollV.LargeChange;
|
|
|
if (nType == (int)ScrollEventType.SmallIncrement)
|
|
|
{
|
|
|
nValue = this.scrollV.SmallChange;
|
|
|
int deltaV = nValue;
|
|
|
if ((sliderBlockLen + nValue) > scrollV.Maximum)
|
|
|
{
|
|
|
deltaV = scrollV.Maximum - sliderBlockLen;
|
|
|
}
|
|
|
if (deltaV < 0)
|
|
|
deltaV = 0;
|
|
|
scrollV.Value += deltaV;
|
|
|
double dF = (double)deltaV / nHs;
|
|
|
dOffset = dHs * dF;
|
|
|
needVScrollToBottom = true;
|
|
|
}
|
|
|
else if (nType == (int)ScrollEventType.SmallDecrement)
|
|
|
{
|
|
|
nValue = -this.scrollV.SmallChange;
|
|
|
int deltaV = nValue;
|
|
|
if ((scrollV.Value + nValue) < scrollV.Minimum)
|
|
|
{
|
|
|
deltaV = scrollV.Minimum - scrollV.Value;
|
|
|
}
|
|
|
if (deltaV > 0)
|
|
|
deltaV = 0;
|
|
|
scrollV.Value += deltaV;
|
|
|
double dF = (double)deltaV / nHs;
|
|
|
dOffset = dHs * dF;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
double dF = (double)nValue / nHs;
|
|
|
dOffset = dHs * dF;
|
|
|
}
|
|
|
|
|
|
geoSigma.Scroll(nOrientation, -dOffset);
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
private bool ScrollHoriForWellPole(int nOrientation, int nType, int nValue)
|
|
|
{
|
|
|
//geoSigma.HScroll(nType, e.NewValue, scrollH.Maximum-scrollH.LargeChange+1);
|
|
|
|
|
|
// 屏幕总宽度
|
|
|
//int nScreenAllHor = this.scrollH.Maximum - this.scrollH.Minimum;
|
|
|
// 屏幕宽度 Ws
|
|
|
int nWs = drawer1.Width;
|
|
|
// 屏幕实际距离 Wr
|
|
|
double dWtest = geoSigma.GetRealWidth(nValue);
|
|
|
double dWs = geoSigma.GetRealWidth(nWs);
|
|
|
// dOffset = Wr*nValue/Ws;
|
|
|
double dOffset = 0;
|
|
|
int sliderBlockLen = scrollH.Value + scrollH.LargeChange;
|
|
|
if (nType == (int)ScrollEventType.SmallIncrement)
|
|
|
{
|
|
|
nValue = this.scrollH.SmallChange;
|
|
|
// scrollH.Maximum = scrollH.Maximum + nValue;
|
|
|
int deltaV = nValue;
|
|
|
if ((sliderBlockLen + nValue) > scrollH.Maximum)
|
|
|
{
|
|
|
deltaV = scrollH.Maximum - sliderBlockLen;
|
|
|
}
|
|
|
if (deltaV < 0)
|
|
|
deltaV = 0;
|
|
|
scrollH.Value += deltaV;
|
|
|
double dF = (double)deltaV / nWs;
|
|
|
dOffset = dWs * dF;
|
|
|
//drawer1.enlargeRight(dOffset);
|
|
|
}
|
|
|
else if (nType == (int)ScrollEventType.SmallDecrement)
|
|
|
{
|
|
|
nValue = -this.scrollH.SmallChange;
|
|
|
|
|
|
int deltaV = nValue;
|
|
|
if ((scrollH.Value + nValue) < scrollH.Minimum)
|
|
|
{
|
|
|
deltaV = scrollH.Minimum - scrollH.Value;
|
|
|
}
|
|
|
if (deltaV > 0)
|
|
|
deltaV = 0;
|
|
|
scrollH.Value += deltaV;
|
|
|
|
|
|
double dF = (double)deltaV / nWs;
|
|
|
dOffset = dWs * dF;
|
|
|
//drawer1.enlargeLeft(Math.Abs(dOffset));
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
double dF = (double)nValue / nWs;
|
|
|
dOffset = dWs * dF;
|
|
|
}
|
|
|
|
|
|
geoSigma.Scroll(nOrientation, dOffset);
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
private void ScrollByWheelForWellPole(bool bUp)
|
|
|
{
|
|
|
if (geoSigma == null)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
GeoSigmaWellPoleXY geoWell = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
if (geoWell.IsLockWellHead())
|
|
|
{
|
|
|
int zdelta = this.scrollV.SmallChange;
|
|
|
if (!bUp)
|
|
|
zdelta = -this.scrollV.SmallChange;
|
|
|
geoWell.MouseWheelForLockWellHead(0, zdelta, 0, 0);
|
|
|
|
|
|
int delta = this.scrollV.SmallChange;
|
|
|
if (bUp == false)
|
|
|
{
|
|
|
int v = scrollV.Value + scrollV.LargeChange + this.scrollV.SmallChange;
|
|
|
if (v > scrollV.Maximum)
|
|
|
{
|
|
|
delta = scrollV.Maximum - (scrollV.Value + scrollV.LargeChange);
|
|
|
}
|
|
|
if (delta < 0)
|
|
|
delta = 0;
|
|
|
scrollV.Value += delta;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
delta = -this.scrollV.SmallChange;
|
|
|
int v = scrollV.Value - this.scrollV.SmallChange;
|
|
|
if (v < scrollV.Minimum)
|
|
|
{
|
|
|
delta = scrollV.Minimum - scrollV.Value;
|
|
|
if (delta > 0)
|
|
|
delta = 0;
|
|
|
}
|
|
|
scrollV.Value += delta;
|
|
|
}
|
|
|
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
double dLeft = 0.0, dTop = 0.0, dRight = 0.0, dBottom = 0.0;
|
|
|
Geo.GetMapRange(ref dLeft, ref dTop, ref dRight, ref dBottom);
|
|
|
|
|
|
Rectangle rect = drawer1.ClientRectangle;
|
|
|
double scLeft = 0.0, scRight = 0.0, scTop = 0.0, scBottom = 0.0;
|
|
|
Geo.GetScreenReal(rect.Left, rect.Top, rect.Right, rect.Bottom, ref scLeft, ref scTop, ref scRight, ref scBottom);
|
|
|
bool bMapLessScreen = false;
|
|
|
if ((dTop - dBottom) < (scTop - scBottom))
|
|
|
bMapLessScreen = true;
|
|
|
|
|
|
int nValue = this.scrollV.SmallChange;
|
|
|
int deltaV = nValue;
|
|
|
if (bMapLessScreen == false)
|
|
|
{
|
|
|
if (bUp == false)
|
|
|
{
|
|
|
int v = scrollV.Value + scrollV.LargeChange + nValue;
|
|
|
if (v > scrollV.Maximum)
|
|
|
{
|
|
|
deltaV = scrollV.Maximum - (scrollV.Value + scrollV.LargeChange);
|
|
|
}
|
|
|
if (deltaV < 0)
|
|
|
deltaV = 0;
|
|
|
scrollV.Value += deltaV;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
deltaV = -nValue;
|
|
|
int v = scrollV.Value - nValue;
|
|
|
if (v < scrollV.Minimum)
|
|
|
{
|
|
|
deltaV = scrollV.Minimum - scrollV.Value;
|
|
|
if (deltaV > 0)
|
|
|
deltaV = 0;
|
|
|
}
|
|
|
scrollV.Value += deltaV;
|
|
|
}
|
|
|
|
|
|
int nHs = drawer1.Height; // 屏幕高度
|
|
|
|
|
|
double dHs = geoSigma.GetRealHeight(nHs); // 屏幕实际距离
|
|
|
double dF = (double)deltaV / nHs;
|
|
|
double dOffset = dHs * dF;
|
|
|
|
|
|
geoSigma.Scroll(1, -dOffset);
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
|
|
|
if (bUp == true)
|
|
|
{//滚轮向下，图向下移动， 图的顶部不高于屏幕的顶部
|
|
|
double OneLine = Geo.GetRealHeight(scrollV.SmallChange);
|
|
|
if ((dBottom + OneLine) < scBottom)
|
|
|
OneLine = scBottom - dBottom;
|
|
|
if (OneLine > 0)
|
|
|
OneLine = 0;
|
|
|
geoSigma.Scroll(1, OneLine);
|
|
|
|
|
|
}
|
|
|
else
|
|
|
{////滚轮向上， 图向上移动 ，图的底部不低于屏幕的底部
|
|
|
double OneLine = -Geo.GetRealHeight(scrollV.SmallChange);
|
|
|
if ((dTop + OneLine) > scTop)
|
|
|
OneLine = scTop - dTop;
|
|
|
if (OneLine < 0)
|
|
|
OneLine = 0;
|
|
|
geoSigma.Scroll(1, OneLine);
|
|
|
}
|
|
|
}
|
|
|
//int nHs = drawer1.Height; // 屏幕高度
|
|
|
|
|
|
//double dHs = geoSigma.GetRealHeight(nHs); // 屏幕实际距离
|
|
|
//double dF = (double)deltaV / nHs;
|
|
|
//double dOffset = dHs * dF;
|
|
|
|
|
|
//geoSigma.Scroll(1, -dOffset);
|
|
|
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
// 通知相关控件
|
|
|
drawer1.ScreenLocationChanged?.Invoke();
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemAddWellTrack_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
AddTrack();
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemWellTrackDel_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
GeoSigmaWellPoleXY.DeleteSelectedWellObject();
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemWellTrackAdd_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
AddTrack(); //ggff20251210
|
|
|
}
|
|
|
|
|
|
void getWellPoleDocContextMenu(ref ContextMenuStrip ctmenu, GeoSigmaWellPoleXY GeoSigmaWellPoleXY)
|
|
|
{
|
|
|
ctmenu = null;
|
|
|
int stype = -1;
|
|
|
int ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
// GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
if (GeoSigmaWellPoleXY.GetSelectWellObject(ref stype, ref ttype, ref thandle))
|
|
|
{
|
|
|
if (stype == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_WELL))
|
|
|
{
|
|
|
ctmenu = ctmWellPole;
|
|
|
|
|
|
foreach (var item in ctmenu.Items)
|
|
|
{
|
|
|
if (item is ToolStripSeparator separator)
|
|
|
continue;
|
|
|
else if (item is ToolStripMenuItem menuItem)
|
|
|
{
|
|
|
if (menuItem.Name == "toolMenuItemRefreshWellPole")
|
|
|
{
|
|
|
if (workAreaDb.Instance.workData.isConn() == false)
|
|
|
{
|
|
|
menuItem.Enabled = false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
menuItem.Enabled = true;
|
|
|
}
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (stype == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK))
|
|
|
{
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Group)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Picture))
|
|
|
{
|
|
|
ctmenu = ctmWellGroupTrack;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
if (ttype != (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Picture))
|
|
|
{
|
|
|
ctmenu = ctmWellTrack;
|
|
|
foreach (var item in ctmenu.Items)
|
|
|
{
|
|
|
if (item is ToolStripSeparator separator)
|
|
|
continue;
|
|
|
else if (item is ToolStripMenuItem menuItem)
|
|
|
{
|
|
|
if (menuItem.Name == "ToolStripMenuItemEditTrackData" || menuItem.Name == "toolStripMenuItemTrackRefreshData")
|
|
|
{
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Depth)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Stratum))
|
|
|
{
|
|
|
menuItem.Enabled = false; menuItem.Visible = false;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
menuItem.Enabled = true; menuItem.Visible = true;
|
|
|
}
|
|
|
}
|
|
|
if (menuItem.Name == "toolStripMenuItemSaveData")
|
|
|
{
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Lith)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_InnerLayer)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Shot)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_SandLayer)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Sandstone)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Result)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Facies)
|
|
|
|| ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Cycle))
|
|
|
{
|
|
|
if (workAreaDb.Instance.workData.isConn())
|
|
|
menuItem.Enabled = true;
|
|
|
else
|
|
|
menuItem.Enabled = false;
|
|
|
menuItem.Visible = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
menuItem.Enabled = false; menuItem.Visible = false;
|
|
|
}
|
|
|
}
|
|
|
if (menuItem.Name == "toolStripMenuItemFaultInDB")
|
|
|
{
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_SandLayer))
|
|
|
{
|
|
|
if (workAreaDb.Instance.workData.isConn())
|
|
|
menuItem.Enabled = true;
|
|
|
else
|
|
|
menuItem.Enabled = false;
|
|
|
menuItem.Visible = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
menuItem.Enabled = false; menuItem.Visible = false;
|
|
|
}
|
|
|
}
|
|
|
if (menuItem.Name == "toolStripMenuItemEditFault")
|
|
|
{
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_SandLayer))
|
|
|
{
|
|
|
menuItem.Visible = true;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
/*menuItem.Enabled = false; */
|
|
|
menuItem.Visible = false;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else if (stype == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACKINDATA))
|
|
|
{
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_IMAGE))
|
|
|
{
|
|
|
ctmenu = contextMenuStripPictureInTrack;
|
|
|
}
|
|
|
else
|
|
|
ctmenu = ctmWellObjInTrack;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemMergerLeftTrack_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
bool b = GeoSigmaWellPoleXY.SelectedTrackCombineLeftTrack();
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemMergeRightTrack_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
bool b = GeoSigmaWellPoleXY.SelectedTrackCombineRightTrack();
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemEditTrackData_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo; // geoSigma;
|
|
|
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref thandle);
|
|
|
if (type != (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK))
|
|
|
return;
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Group) || ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Depth))
|
|
|
return;
|
|
|
|
|
|
if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_Sample)
|
|
|
{
|
|
|
var dataDlg = new FrmRockSampleDataEdit() { StartPosition = FormStartPosition.CenterScreen };
|
|
|
try
|
|
|
{
|
|
|
string strJson = "";
|
|
|
if (GeoSigmaWellPoleXY.GetWellTrackDataJson(thandle, ref strJson) == true)
|
|
|
{
|
|
|
dataDlg.SetRockSampleData(strJson);
|
|
|
if (dataDlg.ShowDialog(this) == DialogResult.OK)
|
|
|
{
|
|
|
byte[] databytes = Encoding.UTF8.GetBytes(dataDlg.mStrDataJson);
|
|
|
// string jsonUtf8 = Encoding.ASCII.GetString(databytes);// Encoding.UTF8.GetString(databytes);
|
|
|
|
|
|
GeoSigmaWellPoleXY.SetWellTrackDataJson(thandle, databytes, databytes.Length);
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
MessageBox.Show(ex.Message);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
var dataDlg = new FrmWellDataEdit() { StartPosition = FormStartPosition.CenterScreen };
|
|
|
try
|
|
|
{
|
|
|
string dataType = string.Empty;
|
|
|
string[] colsName = new string[0];
|
|
|
string[,] datas = new string[0, 0];
|
|
|
GeoSigmaWellPoleXY.GetWellTrackData(thandle, ref dataType, ref colsName, ref datas);
|
|
|
|
|
|
string[] colsNameCH = new string[0];
|
|
|
|
|
|
if(ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_CommonData)
|
|
|
{ //获取数据道的字段名称
|
|
|
string strXml = "";
|
|
|
bool b = GeoSigmaWellPoleXY.GetWellObjectAttributesXml(thandle, (int)GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK, ttype, ref strXml);
|
|
|
if (strXml != "")
|
|
|
{
|
|
|
Type trackType = typeof(WellCommonDataTrack);
|
|
|
WellCommonDataTrack tObjTrack = (WellCommonDataTrack)XmlHelper.Deserialize(trackType, strXml);
|
|
|
if (tObjTrack != null)
|
|
|
{
|
|
|
List<string> listCol = new List<string>();
|
|
|
listCol.Add("顶深");
|
|
|
listCol.Add("底深");
|
|
|
foreach (DataItem item in tObjTrack.dataItems.DataItem)
|
|
|
{
|
|
|
string col = tableInfoQuery.getColumnChsNameFromEngName(tObjTrack.dataItems.RefTableId, item.RefColId);
|
|
|
|
|
|
listCol.Add(col);
|
|
|
colsNameCH = listCol.ToArray();
|
|
|
}
|
|
|
|
|
|
if(tObjTrack.dataItems.DataItem.Count == 0)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.mWellTableInfos.GetTableColumnCHNames(dataType, colsName, ref colsNameCH);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
GeoSigmaWellPoleXY.mWellTableInfos.GetTableColumnCHNames(dataType, colsName, ref colsNameCH);
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
GeoSigmaWellPoleXY.mWellTableInfos.GetTableColumnCHNames(dataType, colsName, ref colsNameCH);
|
|
|
|
|
|
|
|
|
dataDlg.SetData(colsName, colsNameCH, datas);
|
|
|
|
|
|
if (dataDlg.ShowDialog(this) == DialogResult.OK)
|
|
|
{
|
|
|
// byte[] databytes = Encoding.UTF8.GetBytes(dataDlg.strJsonData);
|
|
|
if (dataDlg.m_IsModified == true)
|
|
|
{
|
|
|
if (GeoSigmaWellPoleXY.TrackIsWellTableDataSource(thandle) == true)
|
|
|
{//井内管理数据就直接读去井内数据。
|
|
|
ulong wellHandle = 0;
|
|
|
|
|
|
if (GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle) == true)
|
|
|
{
|
|
|
if (dataType == "ReservesLayer")
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.SetWellReservesLayersJson(wellHandle, dataDlg.strJsonData, true);
|
|
|
//GeoSigmaWellPoleXY.TrackReadWellTableData(thandle);
|
|
|
}
|
|
|
if (dataType == "SandSet")
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.SetWellSandSetsJson(wellHandle, dataDlg.strJsonData, true);
|
|
|
//GeoSigmaWellPoleXY.TrackReadWellTableData(thandle);
|
|
|
}
|
|
|
if (dataType == "FaultPoint")
|
|
|
{
|
|
|
//GeoSigmaWellPoleXY.SetWellFaultDatasJson(wellHandle, dataDlg.strJsonData);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.SetWellTrackDataJson(thandle, dataDlg.strJsonData);
|
|
|
}
|
|
|
this.drawer1.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
MessageBox.Show(ex.Message);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemDelWellObjInTrack_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
GeoSigmaWellPoleXY.DeleteSelectedWellObject();
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemDelPictureInTrack_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
GeoSigmaWellPoleXY.DeleteSelectedWellObject();
|
|
|
}
|
|
|
|
|
|
private void ToolStripMenuItemImportPicutreInTrack_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
OpenFileDialog openFileDialog = new OpenFileDialog();
|
|
|
openFileDialog.Title = "选择图片文件";
|
|
|
openFileDialog.Filter = "图片文件|*.jpg;*.jpeg;*.png;*.bmp;*.gif|所有文件|*.*";
|
|
|
openFileDialog.FilterIndex = 1;
|
|
|
openFileDialog.RestoreDirectory = true;
|
|
|
openFileDialog.Multiselect = false; // 是否允许多选
|
|
|
|
|
|
if (openFileDialog.ShowDialog() == DialogResult.OK)
|
|
|
{
|
|
|
string filePath = openFileDialog.FileName;
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)Geo;
|
|
|
if (GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref thandle))
|
|
|
{
|
|
|
if (type == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACKINDATA)
|
|
|
&& ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_IMAGE))
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.SetPictureInWellTrack(thandle, filePath);
|
|
|
|
|
|
Invalidate();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void toolStripMenuItemGroupTrackDel_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
GeoSigmaWellPoleXY.DeleteSelectedWellObject();
|
|
|
}
|
|
|
|
|
|
private void toolStripMenuItemGroupTrackAdd_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
AddTrack();
|
|
|
}
|
|
|
|
|
|
private void toolStripMenuItemGroupTrackMergeLeft_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
bool b = GeoSigmaWellPoleXY.SelectedTrackCombineLeftTrack();
|
|
|
}
|
|
|
|
|
|
private void toolStripMenuItemGroupTrackMergeRight_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
bool b = GeoSigmaWellPoleXY.SelectedTrackCombineRightTrack();
|
|
|
}
|
|
|
|
|
|
|
|
|
public void AddTrack()
|
|
|
{
|
|
|
var dlg = new FrmAddWellTrack() { StartPosition = FormStartPosition.CenterScreen };
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
string[] typeNames = new string[0];
|
|
|
int[] typeIds = new int[0];
|
|
|
GeoSigmaWellSectionXY.GetWellTrackTypeInfo(ref typeIds, ref typeNames);
|
|
|
dlg.setTypeInfo(typeNames, typeIds);
|
|
|
if (dlg.ShowDialog(this) == DialogResult.OK)
|
|
|
{
|
|
|
if (dlg.mSelectTypeIds.Count > 0)
|
|
|
{
|
|
|
UInt64 wellHandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle);
|
|
|
GeoSigmaWellPoleXY.GetWellBaseInfo(wellHandle, out GeoSigmaWellPoleXY.WellBaseInfo wellinfo);
|
|
|
|
|
|
int[] newTypeIds = dlg.mSelectTypeIds.ToArray();
|
|
|
|
|
|
bool b = GeoSigmaWellPoleXY.AddTrackAfterSelectedWellObject(newTypeIds, newTypeIds.Length, out UInt64[] newTrackHandle, out int[] newTType);
|
|
|
if (newTrackHandle.Length > 0)
|
|
|
{
|
|
|
for (int i = 0; i < newTrackHandle.Length; i++)
|
|
|
{
|
|
|
readTrackWorkAreaData(newTrackHandle[i], newTType[i], wellinfo.wellName, false);
|
|
|
}
|
|
|
this.Invalidate();
|
|
|
}
|
|
|
//viewer.Redraw();
|
|
|
}
|
|
|
// viewer.AddTrack();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
bool getTempateFilePath(ref string templatePath)
|
|
|
{
|
|
|
bool b = false;
|
|
|
templatePath = AppDomain.CurrentDomain.BaseDirectory + "Templates\\WellPole\\";
|
|
|
|
|
|
if (Directory.Exists(templatePath) == false)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
Directory.CreateDirectory(templatePath);
|
|
|
}
|
|
|
catch (UnauthorizedAccessException)
|
|
|
{
|
|
|
MessageBox.Show("没有创建模板目录的权限");
|
|
|
return b;
|
|
|
}
|
|
|
catch (PathTooLongException)
|
|
|
{
|
|
|
MessageBox.Show("路径太长");
|
|
|
return b;
|
|
|
}
|
|
|
catch (IOException ex)
|
|
|
{
|
|
|
MessageBox.Show($"IO错误: {ex.Message}");
|
|
|
return b;
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
MessageBox.Show($"发生错误: {ex.Message}");
|
|
|
return b;
|
|
|
}
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
private void menuSaveWellTemplates_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
string templatePath = "";
|
|
|
|
|
|
if (getTempateFilePath(ref templatePath) == false)
|
|
|
return;
|
|
|
|
|
|
SaveFileDialog dlg = new SaveFileDialog();
|
|
|
dlg.Filter = "模板文件(*.pcg)|*.pcg";
|
|
|
dlg.Title = "保存模板文件";
|
|
|
|
|
|
string fileName = Path.GetFileName(this.drawer1.DrawFileName);
|
|
|
dlg.InitialDirectory = templatePath;
|
|
|
dlg.FileName = "template_" + fileName;
|
|
|
if (dlg.ShowDialog() == DialogResult.OK)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY geoWell = (GeoSigmaWellPoleXY)this.geoSigma;
|
|
|
geoWell.SaveWellPoleTemplateFile(dlg.FileName);
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
private void menuApplyingTemplates_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
string templatePath = "";
|
|
|
|
|
|
if (getTempateFilePath(ref templatePath) == false)
|
|
|
return;
|
|
|
|
|
|
OpenFileDialog dlg = new OpenFileDialog();
|
|
|
dlg.Title = "选择模板文件";
|
|
|
dlg.Filter = "模板文件(*.pcg)|*.pcg";
|
|
|
dlg.RestoreDirectory = true;
|
|
|
dlg.Multiselect = false; // 是否允许多选
|
|
|
dlg.InitialDirectory = templatePath;
|
|
|
if (dlg.ShowDialog() == DialogResult.OK)
|
|
|
{
|
|
|
string filePath = dlg.FileName;
|
|
|
|
|
|
GeoSigmaWellPoleXY geoWell = (GeoSigmaWellPoleXY)this.geoSigma;
|
|
|
|
|
|
if(geoWell.ApplyingWellPoleTemplateFile(filePath))
|
|
|
{
|
|
|
this.drawer1.EnableRedraw = true;
|
|
|
this.drawer1.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void menuItemWellTrajectory_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
UInt64 wellHandle = 0;
|
|
|
if (GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle) == true)
|
|
|
{
|
|
|
var dataDlg = new FrmWellDataEdit() { StartPosition = FormStartPosition.CenterScreen };
|
|
|
try
|
|
|
{
|
|
|
string dataType = "trajectory";
|
|
|
string[] colsName = new string[0];
|
|
|
string[,] datas = new string[0, 0];
|
|
|
GeoSigmaWellPoleXY.GetWellTrajectoryDatasJson(wellHandle, ref colsName, ref datas);
|
|
|
|
|
|
string[] colsNameCH = new string[0];
|
|
|
GeoSigmaWellPoleXY.mWellTableInfos.GetTableColumnCHNames(dataType, colsName, ref colsNameCH);
|
|
|
dataDlg.SetData(colsName, colsNameCH, datas);
|
|
|
|
|
|
if (dataDlg.ShowDialog(this) == DialogResult.OK)
|
|
|
{
|
|
|
byte[] databytes = Encoding.UTF8.GetBytes(dataDlg.strJsonData);
|
|
|
string jsonUtf8 = Encoding.ASCII.GetString(databytes);// Encoding.UTF8.GetString(databytes);
|
|
|
|
|
|
//GeoSigmaWellPoleXY.SetWellTrackDataJson(thandle, databytes, databytes.Length);
|
|
|
Invalidate();
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
MessageBox.Show(ex.Message);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
private void toolMenuItemRefreshWellPole_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
GeoSigmaWellPoleXY.SetWellUndoRedoAction();
|
|
|
|
|
|
UInt64 wellHandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle);
|
|
|
if (wellHandle != 0)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.GetWellBaseInfo(wellHandle, out GeoSigmaWellPoleXY.WellBaseInfo wellinfo);
|
|
|
readWorkAreaDataForWell(wellinfo.wellName, wellHandle);
|
|
|
}
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
MessageBox.Show(ex.Message);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
private void toolStripMenuItemTrackRefreshData_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo; // geoSigma;
|
|
|
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref thandle);
|
|
|
if (type != (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK))
|
|
|
return;
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Group) || ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Depth))
|
|
|
return;
|
|
|
|
|
|
UInt64 wellHandle = 0;
|
|
|
if (GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle) == false)
|
|
|
return;
|
|
|
GeoSigmaWellPoleXY.GetWellBaseInfo(wellHandle, out GeoSigmaWellPoleXY.WellBaseInfo wellinfo);
|
|
|
|
|
|
if (workAreaDb.Instance.workData.isConn())
|
|
|
{
|
|
|
if (ttype == (int)(GeoSigmaWellPoleXY.eWellExtType.Track_Curve))
|
|
|
{
|
|
|
DataTable curvesTable = new DataTable();
|
|
|
InterfaceWorkAreaData.LoadCurveData.ResultDataInfo qCurveResult = new InterfaceWorkAreaData.LoadCurveData.ResultDataInfo();
|
|
|
|
|
|
string strXml = "";
|
|
|
if (GeoSigmaWellPoleXY.GetWellObjectAttributesXml(wellHandle, (int)GeoSigmaWellPoleXY.eWellExtType.KEP_WELL, 0, ref strXml) == true)
|
|
|
{
|
|
|
XmlDocument xmlDoc = new XmlDocument();
|
|
|
try
|
|
|
{
|
|
|
xmlDoc.LoadXml(strXml);
|
|
|
XmlNode node = xmlDoc.SelectSingleNode("/Pcg/Head");
|
|
|
if (node != null)
|
|
|
{
|
|
|
string wellName = node.Attributes["WellName"].Value;
|
|
|
qCurveResult = workAreaDb.Instance.workData.getCurvesData(wellName, ref curvesTable);
|
|
|
|
|
|
string strCurve = "";
|
|
|
if (GeoSigmaWellPoleXY.GetWellObjectAttributesXml(thandle, (int)GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK, ttype, ref strCurve) == true)
|
|
|
{
|
|
|
xmlDoc.LoadXml(strCurve);
|
|
|
node = xmlDoc.SelectSingleNode("/Pcg/WellTrack");
|
|
|
if (node != null)
|
|
|
{
|
|
|
string curveName = node.Attributes["Name"].Value;
|
|
|
WellDataConvert.getWellCurveValueForNewWell(curvesTable, GeoSigmaWellPoleXY, wellHandle, thandle, curveName);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
catch (XmlException xmle)
|
|
|
{
|
|
|
Console.WriteLine(xmle.Message);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
readTrackWorkAreaData(thandle, ttype, wellinfo.wellName);
|
|
|
}
|
|
|
drawer1.EnableRedraw = true;
|
|
|
drawer1.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void toolStripMenuItemSaveData_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo; // geoSigma;
|
|
|
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref thandle);
|
|
|
if (type != (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK))
|
|
|
return;
|
|
|
|
|
|
UInt64 wellHandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle);
|
|
|
GeoSigmaWellPoleXY.GetWellBaseInfo(wellHandle, out GeoSigmaWellPoleXY.WellBaseInfo wellinfo);
|
|
|
|
|
|
string strJson = "";
|
|
|
|
|
|
if (MessageBox.Show("数据入库将删除原有数据，确定要保存数据吗?", "提示", MessageBoxButtons.OKCancel) == DialogResult.Cancel)
|
|
|
return;
|
|
|
|
|
|
if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_Lith)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.GetWellTrackDataJson(thandle, ref strJson);
|
|
|
|
|
|
if (WellDataConvert.getWellLithologyFromJson(wellinfo.wellName, strJson, out List<WellLithology> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<WellLithology>(r => r.Well == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
else if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_InnerLayer)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.GetWellTrackDataJson(thandle, ref strJson);
|
|
|
|
|
|
if (WellDataConvert.getWellInnerLayerFromJson(wellinfo.wellName, strJson, out List<WellInnerLayer> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<WellInnerLayer>(r => r.Well == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
else if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_Shot)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.GetWellTrackDataJson(thandle, ref strJson);
|
|
|
if (WellDataConvert.getWellPerforationFromJson(wellinfo.wellName, strJson, out List<WellPerforation> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<WellPerforation>(r => r.JH == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
else if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_SandLayer)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.GetWellTrackDataJson(thandle, ref strJson);
|
|
|
if (WellDataConvert.getWellInterpretDrillLayerFromJson(wellinfo.wellName, strJson, out List<InterpretDrillWellLayered> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<InterpretDrillWellLayered>(r => r.JH == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
else if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_Sandstone
|
|
|
|| ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_Result
|
|
|
|| ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_Facies)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY.GetWellTableDatasJson(wellHandle, "ReservesLayer", ref strJson);
|
|
|
if (WellDataConvert.getWellReserversLayerFromJson(wellinfo.wellName, strJson, out List<WellReservesLayer> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<WellReservesLayer>(r => r.Well == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
else if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_Cycle)
|
|
|
{
|
|
|
string strSource, strCol;
|
|
|
strSource = strCol = "";
|
|
|
GeoSigmaWellPoleXY.TrackGetDataSourceID(thandle, ref strSource, ref strCol);
|
|
|
GeoSigmaWellPoleXY.GetWellTrackDataJson(thandle, ref strJson);
|
|
|
|
|
|
bool b = false;
|
|
|
|
|
|
if (strSource == WellObjectBaseInfo.CycleTableTypes[(int)(WellObjectBaseInfo.eCycleDataType.CycleLongterm)]) //"CycleLongterm")
|
|
|
{
|
|
|
if (WellDataConvert.getWellLongCyClesJsonFromJson(wellinfo.wellName, strJson, out List<CycleLongterm> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<CycleLongterm>(r => r.Well == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
else if (strSource == WellObjectBaseInfo.CycleTableTypes[(int)(WellObjectBaseInfo.eCycleDataType.CycleShortterm)])
|
|
|
{
|
|
|
if (WellDataConvert.getWellShortCyClesJsonFromJson(wellinfo.wellName, strJson, out List<CycleShortterm> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<CycleShortterm>(r => r.Well == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
else if (strSource == WellObjectBaseInfo.CycleTableTypes[(int)(WellObjectBaseInfo.eCycleDataType.CycleMediumterm)])
|
|
|
{
|
|
|
if (WellDataConvert.getWellMediumCyClesJsonFromJson(wellinfo.wellName, strJson, out List<CycleMediumterm> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<CycleMediumterm>(r => r.Well == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public override void SetAddFaultPoint()
|
|
|
{
|
|
|
//GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo;
|
|
|
//int stype = -1;
|
|
|
//int ttype = -1;
|
|
|
//UInt64 thandle = 0;
|
|
|
//if (GeoSigmaWellPoleXY.GetSelectWellObject(ref stype, ref ttype, ref thandle))
|
|
|
//{
|
|
|
// if (stype == (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_WELL))
|
|
|
// {
|
|
|
// FillCurveGradientFrm dlgNew = new FillCurveGradientFrm() { StartPosition = FormStartPosition.CenterScreen };
|
|
|
|
|
|
// dlgNew.bAutoMidClr = false;
|
|
|
// dlgNew.leftValue = 0;
|
|
|
// dlgNew.rightValue = 200;
|
|
|
|
|
|
// dlgNew.leftColor = Color.Red;
|
|
|
// dlgNew.midColor = Color.Aqua;
|
|
|
// dlgNew.rightColor = Color.White;
|
|
|
|
|
|
// GeoSigmaWellPoleXY.GetWellAllCurveNames(thandle, out string[] namesStr);
|
|
|
// for (int i = 0; i < namesStr.Length; i++)
|
|
|
// {
|
|
|
// dlgNew.curvesName.Add(namesStr[i]);
|
|
|
// }
|
|
|
|
|
|
// if (dlgNew.ShowDialog(this) == DialogResult.Cancel)
|
|
|
// {
|
|
|
// return;
|
|
|
// }
|
|
|
// int tt = 100;
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma; //ggff20251210
|
|
|
GeoSigmaWellPoleXY.SetAddFaultPoint();
|
|
|
}
|
|
|
public override bool IsAddFaultPoint()
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
return GeoSigmaWellPoleXY.IsAddFaultPoint();
|
|
|
}
|
|
|
|
|
|
private void toolStripMenuItemEditFault_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo; // geoSigma;
|
|
|
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref thandle);
|
|
|
if (type != (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK))
|
|
|
return;
|
|
|
|
|
|
if (ttype == (int)GeoSigmaWellPoleXY.eWellExtType.Track_SandLayer)
|
|
|
{
|
|
|
var dataDlg = new FrmWellDataEdit() { StartPosition = FormStartPosition.CenterScreen };
|
|
|
try
|
|
|
{
|
|
|
UInt64 wellHandle = 0;
|
|
|
string strJson = "";
|
|
|
GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle);
|
|
|
GeoSigmaWellPoleXY.GetWellTableDatasJson(wellHandle, "FaultPoint", ref strJson);
|
|
|
string dataType = string.Empty;
|
|
|
string[] colsName = new string[0];
|
|
|
string[,] datas = new string[0, 0];
|
|
|
WellDataConvert.getColNameAndDatasFromJson(strJson, ref dataType, ref colsName, ref datas);
|
|
|
|
|
|
string[] colsNameCH = new string[0];
|
|
|
GeoSigmaWellPoleXY.mWellTableInfos.GetTableColumnCHNames(dataType, colsName, ref colsNameCH);
|
|
|
dataDlg.SetData(colsName, colsNameCH, datas);
|
|
|
|
|
|
if (dataDlg.ShowDialog(this) == DialogResult.OK)
|
|
|
{
|
|
|
// byte[] databytes = Encoding.UTF8.GetBytes(dataDlg.strJsonData);
|
|
|
if (dataDlg.m_IsModified == true)
|
|
|
{
|
|
|
|
|
|
GeoSigmaWellPoleXY.SetWellFaultDatasJson(wellHandle, dataDlg.strJsonData, true);
|
|
|
this.drawer1.Invalidate();
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
MessageBox.Show(ex.Message);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private void toolStripMenuItemFaultInDB_Click(object sender, EventArgs e)
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)this.Geo; // geoSigma;
|
|
|
|
|
|
int type, ttype;
|
|
|
type = ttype = -1;
|
|
|
UInt64 thandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectWellObject(ref type, ref ttype, ref thandle);
|
|
|
if (type != (int)(GeoSigmaWellPoleXY.eWellExtType.KEP_TRACK))
|
|
|
return;
|
|
|
|
|
|
UInt64 wellHandle = 0;
|
|
|
GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle);
|
|
|
GeoSigmaWellPoleXY.GetWellBaseInfo(wellHandle, out GeoSigmaWellPoleXY.WellBaseInfo wellinfo);
|
|
|
|
|
|
string strJson = "";
|
|
|
GeoSigmaWellPoleXY.GetWellTableDatasJson(wellHandle, "FaultPoint", ref strJson);
|
|
|
if (WellDataConvert.getWellFaultsFromJson(wellinfo.wellName, strJson, out List<WellBreakPoint> list))
|
|
|
{
|
|
|
DBHelp.NewDb.Deleteable<WellBreakPoint>(r => r.JH == wellinfo.wellName).ExecuteCommand();
|
|
|
DBHelp.NewDb.BulkInsert(list);
|
|
|
MessageBox.Show("写入完毕");
|
|
|
}
|
|
|
}
|
|
|
|
|
|
public void InitStratumDivisionData()
|
|
|
{
|
|
|
GeoSigmaWellPoleXY GeoSigmaWellPoleXY = (GeoSigmaWellPoleXY)geoSigma;
|
|
|
UInt64 wellHandle = 0;
|
|
|
if (GeoSigmaWellPoleXY.GetSelectedWell(ref wellHandle))
|
|
|
{
|
|
|
readStratumDivisionFromWorkArea(wellHandle);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|