private static Boolean IsCrossed(PartitionParam setterParam)
{
Partition dividerTest = setterParam.PartitionPre;
PartitionOrigin originTest = setterParam.OriginPost;
Vector3d normal = originTest.BaseLine.UnitNormal;
Polyline trimmed = setterParam.OutlineLabel.Difference;
double coverAllLength = new BoundingBox(new List <Point3d>(trimmed)).Diagonal.Length * 2;
Line testLine = new Line(originTest.Point, originTest.Point + normal * coverAllLength);
foreach (RoomLine i in dividerTest.Lines)
{
if (i.UnitTangent == normal)
{
continue;
}
Point3d crossPt = CCXTools.GetCrossPt(testLine, i.PureLine);
if (PCXTools.IsPtOnLine(crossPt, i.PureLine, 0.005) && PCXTools.IsPtOnLine(crossPt, testLine, 0.005))
{
return(true);
}
}
return(false);
}
private static PartitionParam DrawAtThisBaseEnd(PartitionParam param, double targetArea)
{
PartitionParam thisEndParam = new PartitionParam(param);
thisEndParam.OriginPost.Point = param.OriginPost.BaseLine.EndPt;
PartitionParam thisEndOutput = DrawOrtho(thisEndParam);
if (HasEnoughArea(thisEndOutput, targetArea))
{
if (thisEndParam.OriginPost.Point == param.OriginPost.Point)
{
return(thisEndOutput);
}
return(DrawAtStraight(param, targetArea));
}
if (IsLastSegment(param))
{
return(thisEndOutput);
}
return(DrawAtConvexCorner(param, targetArea));
}
private static void SetOriginFromPerpNext(PartitionParam setterParam)
{
Vector3d cornerPre = new Vector3d(setterParam.OriginPost.BasePureLine.UnitTangent);
SetOriginNextStart(setterParam);
Vector3d cornerPost = setterParam.OriginPost.BasePureLine.UnitTangent;
CornerState cornerStat = GetCCWCornerState(cornerPre, cornerPost);
if (cornerStat == CornerState.Convex)
{
return;
}
int currentIndex = setterParam.OutlineLabel.Core.FindIndex
(i => (i.PureLine == setterParam.OriginPost.BasePureLine));
if (currentIndex == setterParam.OutlineLabel.Core.Count - 1)
{
SetPreEndToOrigin(setterParam);
return;
}
SetNextDivOrigin(setterParam);
return;
}
/// <summary>
/// 初始化dbtune管理工作流程
/// </summary>
private void InitDbtuneDbtuneManageWorkFlow()
{
if (this._workFlow == EnumWorkFlow.TablePartition.ToString())
{
InitDbConnect();
this.txbDbPort.Text = "5151";
CommonUtil.WriteBlog(this.txbBlog, "--- SDE服务当前未连接");
this.cmbDbtuneKeyWord.SelectedIndex = -1;
this.txbDbtuneParamValue.Text = string.Empty;
this.cmbDbtuneKeyWord.Properties.Items.Clear();
}
this.lciConnTips_2.Visibility = LayoutVisibility.Always;
this.cmbDbtuneKeyWord.Enabled = false;
this._dbtuneConfigHelper = null;
this._dbtuneConfigParam = null;
this._featureClass = null;
this.btnImportFeature.Text = string.Empty;
this.lciConnTips_1.Visibility = LayoutVisibility.Never;
this._tbPtitionHelper = null;
this._partitionParam = null;
this.cmbTablespace.SelectedIndex = -1;
this.cmbOriginTable.SelectedIndex = -1;
this.cmbTablespace.Properties.Items.Clear();
this.cmbOriginTable.Properties.Items.Clear();
this._workFlow = EnumWorkFlow.DbtuneManage.ToString();
}
private static void SetOriginFromEndPt(PartitionParam setterParam)
{
int testIndex = setterParam.OutlineLabel.Core.FindIndex
(i => (i.PureLine == setterParam.OriginPost.BasePureLine));
if (testIndex == setterParam.OutlineLabel.Core.Count - 1)
{
return;
}
RoomLine formerCornerLine = setterParam.OutlineLabel.Core[testIndex];
RoomLine laterCornerLine = setterParam.OutlineLabel.Core[testIndex + 1];
PartitionOrigin laterStart = new PartitionOrigin(laterCornerLine.PureLine.PointAt(0), laterCornerLine);
PartitionOrigin laterEnd = new PartitionOrigin(laterCornerLine.PureLine.PointAt(1), laterCornerLine);
CornerState cornerStat = GetCCWCornerState(formerCornerLine.UnitTangent, laterCornerLine.UnitTangent);
if (cornerStat == CornerState.Concave)
{
setterParam.OriginPost = laterEnd;
SetNextDivOrigin(setterParam);
return;
}
return;
}
private static PartitionParam DrawByBinarySearch(PartitionParam param, double targetArea)
{
double skipTolerance = 0.005;
int iterNum = 10;
Point3d ptEnd = param.OriginPost.BaseLine.PointAt(1);
Point3d ptStart = param.OriginPost.Point;
Vector3d searchVector = new Vector3d(ptEnd - ptStart);
double searchRange = searchVector.Length;
double upperBound = searchRange;
double lowerBound = 0;
if (searchRange < skipTolerance)
{
return(DrawOrtho(param));
}
int loopLimiter = 0;
while (lowerBound < upperBound)
{
if (loopLimiter > iterNum)
{
break;
}
double tempStatus = (upperBound - lowerBound) / 2 + lowerBound;
Point3d tempOriginPt = ptStart + searchVector / searchRange * tempStatus;
param.OriginPost.Point = tempOriginPt;
PartitionParam tempOutput = DrawOrtho(param);
double tempArea = tempOutput.Outline.GetArea();
if (targetArea > tempArea)
{
lowerBound = tempStatus;
}
else if (targetArea < tempArea)
{
upperBound = tempStatus;
}
else
{
lowerBound = tempArea;
upperBound = tempArea;
}
loopLimiter++;
}
Point3d newOriginPt = ptStart + searchVector / searchRange * lowerBound;
param.OriginPost.Point = newOriginPt;
return(DrawOrtho(param));
}
public PartitionParam(PartitionParam otherParam)
{
this.PartitionPre = new Partition(otherParam.PartitionPre);
this.PartitionPost = new Partition(otherParam.PartitionPost);
this.OriginPost = new PartitionOrigin(otherParam.OriginPost);
this.OutlineLabel = otherParam.OutlineLabel;
}
private static Boolean IsOriginEndConcave(PartitionParam param)
{
int originCurrentIndex = param.OutlineLabel.Core.FindIndex
(i => (i.PureLine == param.OriginPost.BasePureLine));
RoomLine cornerLinePre = new RoomLine();
RoomLine cornerLinePost = new RoomLine();
if (originCurrentIndex == param.OutlineLabel.Core.Count - 1)
{
return(false);
}
cornerLinePre = param.OutlineLabel.Core[originCurrentIndex];
cornerLinePost = param.OutlineLabel.Core[originCurrentIndex + 1];
PartitionSetter.CornerState cornerStat = PartitionSetter.GetCCWCornerState(cornerLinePre.UnitTangent, cornerLinePost.UnitTangent);
if (cornerStat == PartitionSetter.CornerState.Concave)
{
return(true);
}
return(false);
}
public static void SetNextDivOrigin(PartitionParam setterParam)
{
if (!IsCorridorAvailable(setterParam))
{
int originIndex = setterParam.OutlineLabel.Core.FindIndex
(i => i.PureLine == setterParam.OriginPost.BaseLine.PureLine);
if (originIndex != setterParam.OutlineLabel.Core.Count - 1)
{
FindMinCorridor(setterParam);
}
else
{
FindCorrFromSameBaseLast(setterParam);
}
}
//위 코드 분리가능
if (setterParam.PartitionPre.Lines.Count > 1)
{
SetOriginFromFoldedDiv(setterParam);
return;
}
SetOriginFromSingleDiv(setterParam);
return;
}
//sub method
/*111공통된 부분 줄일 수 있음.. 일단은 구현*/
private static void FindMinCorridor(PartitionParam setterParam)
{
RoomLine nearestCorridor = FindNearestCorridor(setterParam.OutlineLabel.Core, setterParam.OriginPost.BaseLine);
if (setterParam.OriginPost.BasePureLine == nearestCorridor.PureLine)
{
FindCorrFromSameBase(setterParam);
return;
}
if (nearestCorridor.Length < RoomDimension.MinLengthForDoor)
{
SetOriginNextStart(setterParam);
FindCorrFromSameBase(setterParam);
return;
}
Point3d nearestBase = nearestCorridor.StartPt;
Point3d baseWithMinCorridor = new Point3d(nearestBase + nearestCorridor.UnitTangent * RoomDimension.MinLengthForDoor);
PartitionOrigin originNext = new PartitionOrigin(baseWithMinCorridor, nearestCorridor);
setterParam.OriginPost = originNext;
return;
}
private static PartitionParam DrawAtPreCrossed(PartitionParam preParam)
{
PartitionParam lastParam = new PartitionParam(preParam);
lastParam.OriginPost.BaseLine = preParam.OutlineLabel.Core[preParam.OutlineLabel.Core.Count - 2];
lastParam.OriginPost.Point = lastParam.OriginPost.BaseLine.EndPt;
return(PartitionMaker.DrawOrtho(lastParam));
}
private static void SetOriginFromSameBase(PartitionParam setterParam)
{
if (IsEndPt(setterParam.OriginPost))
{
SetOriginFromEndPt(setterParam);
return;
}
return;
}
private static void SetOriginFromSingleDiv(PartitionParam setterParam)
{
if (setterParam.PartitionPre.Origin.BasePureLine == setterParam.OriginPost.BasePureLine)
{
SetOriginFromSameBase(setterParam);
return;
}
SetOriginFromOtherBase(setterParam);
return;
}
//method
private static PartitionParam DrawAtDoughnutType(PartitionParam preParam, PartitionParam initialParam)
{
PartitionParam lastParam = new PartitionParam(preParam);
lastParam.OriginPost.BaseLine = preParam.OutlineLabel.Core[preParam.OutlineLabel.Core.Count - 1];
lastParam.OriginPost.Point = lastParam.OriginPost.BaseLine.EndPt;
lastParam.PartitionPost = new Partition(initialParam.PartitionPre);
lastParam.PartitionPost.Origin = lastParam.OriginPost;
return(lastParam);
}
private static Boolean HasEnoughArea(PartitionParam paramOutput, double targetArea)
{
double outputArea = PolylineTools.GetArea(paramOutput.Outline);
if (outputArea > targetArea)
{
return(true);
}
return(false);
}
public static PartitionParam DrawOrtho(PartitionParam param)
{
Line orthoLine = PCXTools.PCXByEquation(param.OriginPost.Point, param.OutlineLabel.Pure, param.OriginPost.BaseLine.UnitNormal);
List <RoomLine> orthoList = new List <RoomLine> {
new RoomLine(orthoLine, LineType.Inner)
};
Partition dividerCurrent = new Partition(orthoList, param.OriginPost);
PartitionParam paramNext = new PartitionParam(param.PartitionPre, dividerCurrent, dividerCurrent.Origin, param.OutlineLabel);
return(paramNext);
}
private static PartitionParam DrawAtConvexCorner(PartitionParam param, double targetArea)
{
SetPostStartToOrigin(param);
PartitionParam straightOutput = DrawOrtho(param);
if (HasEnoughArea(straightOutput, targetArea))
{
return(TestAtCorner(param, targetArea));
}
return(DrawEachPartition(param, targetArea));
}
/// <summary>
/// 执行数据表分区工作
/// </summary>
/// <param name="txbBlog"></param>
/// <param name="partitionParam"></param>
/// <param name="tbpHelper"></param>
internal static void ExcutePartition(MemoEdit txbBlog, PartitionParam partitionParam, TablePartitionHelper tbpHelper)
{
tbpHelper = new TablePartitionHelper(partitionParam);
if (tbpHelper.PartitionByExchange())
{
WriteBlog(txbBlog, "--- 执行成功");
}
else
{
WriteBlog(txbBlog, "--- 执行失败，请检查参数");
}
}
private static Boolean IsCloseToStart(PartitionParam paramOutput)
{
Point3d currentDivOrigin = paramOutput.PartitionPost.Origin.Point;
Point3d baseLineStart = paramOutput.PartitionPost.BaseLine.StartPt;
double betweenStart = new Vector3d(currentDivOrigin - baseLineStart).Length;
if (betweenStart < RoomDimension.MinLengthForDoor * 0.9)
{
return(true);
}
return(false);
}
/*최소 복도 길이와 본 메서드 톨러런스 둘 다 벗어나는 경우가 있는지..*/
private static Boolean IsCloseToEnd(PartitionParam paramOutput)
{
Point3d currentDivOrigin = paramOutput.PartitionPost.Origin.Point;
Point3d baseLineEnd = paramOutput.PartitionPost.BaseLine.EndPt;
double betweenEnd = new Vector3d(baseLineEnd - currentDivOrigin).Length;
if (betweenEnd < RoomDimension.MinLengthForDoor * 0.9)
{
return(true);
}
return(false);
}
private static Boolean IsLastSegment(PartitionParam param)
{
int originIndex = param.OutlineLabel.Core.FindIndex
(i => i.PureLine == param.OriginPost.BaseLine.PureLine);
int lastIndex = param.OutlineLabel.Core.Count - 1;
if (originIndex == lastIndex)
{
return(true);
}
return(false);
}
/// <summary>
/// 检查分区流程涉及参数
/// </summary>
/// <returns></returns>
internal static bool CheckPartitionParam(MemoEdit txbBlog, PartitionParam partitionParam)
{
if (partitionParam.DBHelper == null)
{
WriteBlog(txbBlog, "--- 数据库连接异常, 请查看错误日志");
return(false);
}
else if (RegexCheck.IsEmpty(partitionParam.TablespaceName))
{
WriteBlog(txbBlog, "--- 未指定表空间");
return(false);
}
else if (RegexCheck.IsEmpty(partitionParam.OriginTableName))
{
WriteBlog(txbBlog, "--- 未指定初始表");
return(false);
}
else if (RegexCheck.IsEmpty(partitionParam.BasicField))
{
WriteBlog(txbBlog, "--- 未指定分区列");
return(false);
}
else if (partitionParam.PartitionWay == EnumPartitionWay.Unknow)
{
WriteBlog(txbBlog, "--- 未指定分区方式");
return(false);
}
else if (!RegexCheck.IsFull(partitionParam.TablespaceSet))
{
WriteBlog(txbBlog, "--- 存在没有指定表空间的分区");
return(false);
}
else if (RegexCheck.IsExist(QueryUnityInfo.QueryTotalTable(partitionParam.DBHelper, partitionParam.TablespaceName), partitionParam.PartitionedTableName))
{
WriteBlog(txbBlog, "--- 名字为 " + partitionParam.PartitionedTableName + "的表已经存在，请更改导出名");
return(false);
}
else
{
if (partitionParam.PartitionWay == EnumPartitionWay.Range && partitionParam.PartitionCount == -1)
{
WriteBlog(txbBlog, "---未指定范围分区数");
return(false);
}
else
{
return(true);
}
}
}
/// <summary>
/// 初始化dbtune配置工作流程
/// </summary>
private void InitDbtuneConfigWorkFlow()
{
if (this._workFlow == EnumWorkFlow.TablePartition.ToString())
{
InitDbConnect();
this.txbDbPort.Text = "5151";
CommonUtil.WriteBlog(this.txbBlog, "--- SDE服务当前未连接");
this.btnImportFeature.Text = string.Empty;
this.cmbColumnIdentity.SelectedIndex = -1;
this.cmbPartitionWay.SelectedIndex = -1;
this.txbTips.Text = string.Empty;
this.btnAssignTablespace.Text = string.Empty;
this.txbTargetName.Text = string.Empty;
this.cmbColumnIdentity.Properties.Items.Clear();
}
this.lciConnTips_1.Visibility = LayoutVisibility.Always;
this._dbtuneConfigParam = new DbtuneConfigParam();
this._dbtuneConfigParam.Clear();
this._featureClass = null;
this._partitionCount = -1;
this._columnInfoSet = new Dictionary <string, string>();
this._boundary = new Dictionary <string, double>();
this._partitionInfoSet = new List <PartitionInfo>();
this._partitionRefer = new List <string>();
this.btnImportFeature.Enabled = false;
this._tbPtitionHelper = null;
this._partitionParam = null;
this.cmbTablespace.SelectedIndex = -1;
this.cmbOriginTable.SelectedIndex = -1;
this.cmbTablespace.Properties.Items.Clear();
this.cmbOriginTable.Properties.Items.Clear();
this._dbtuneManageHelper = null;
this.cmbDbtuneKeyWord.SelectedIndex = -1;
this.txbDbtuneParamValue.Text = string.Empty;
this.cmbDbtuneKeyWord.Properties.Items.Clear();
this.lciConnTips_2.Visibility = LayoutVisibility.Never;
this._workFlow = EnumWorkFlow.DbtuneConfigure.ToString();
}
private static Line GetMainLine(PartitionParam param, List <Point3d> outlineVertex)
{
Point3d noFoldOrigin = param.OriginPost.Point;
Line cornerLinePre = new Line(noFoldOrigin, outlineVertex.Last());
Line cornerLinePost = new Line(noFoldOrigin, outlineVertex.First());
if (cornerLinePre.Length > cornerLinePost.Length)
{
return(cornerLinePre);
}
else
{
return(cornerLinePost);
}
}
private static PartitionParam DrawAtStraight(PartitionParam param, double targetArea)
{
PartitionParam binaryOutput = DrawByBinarySearch(param, targetArea);
if (IsCloseToEnd(binaryOutput))
{
return(PushOriginToEnd(binaryOutput));
}
else if (IsCloseToStart(binaryOutput))
{
return(PushOriginToStart(binaryOutput));
}
return(binaryOutput);
}
//decider method
private static Boolean IsCorridorAvailable(PartitionParam setterParam)
{
int dividerIndex = setterParam.OutlineLabel.Core.FindIndex
(i => i.PureLine == setterParam.PartitionPre.Origin.BasePureLine);
int originIndex = setterParam.OutlineLabel.Core.FindIndex
(i => i.PureLine == setterParam.OriginPost.BasePureLine);
if (dividerIndex == originIndex)
{
return(IsAvailableOnSameBase(setterParam));
}
return(IsAvailableOnOtherBase(setterParam, dividerIndex, originIndex));
}
//sub method
private static PartitionParam DrawAtConcaveCorner(PartitionParam param, double targetArea)
{
int currentIndex = param.OutlineLabel.Core.FindIndex
(i => (i.PureLine == param.OriginPost.BasePureLine));
PartitionParam thisEndParam = new PartitionParam(param);
thisEndParam.OriginPost.Point = param.OriginPost.BaseLine.EndPt;
PartitionParam thisEndOutput = DrawOrtho(thisEndParam);
if (HasEnoughArea(thisEndOutput, targetArea))
{
PartitionParam tempOutput1 = new PartitionParam(param);
PartitionParam tempOutput2 = new PartitionParam(param);
SetPostStartToOrigin(tempOutput2);
List <PartitionParam> outputCandidate = new List <PartitionParam>();
outputCandidate.Add(DrawAtStraight(tempOutput1, targetArea));
outputCandidate.Add(DrawEachPartition(tempOutput2, targetArea));
return(SelectBetterPartition(outputCandidate, targetArea));
}
//바로 위와 순서 바꿈.. 문제 되려나?
if (param.OriginPost.Point == param.OriginPost.BaseLine.EndPt)
{
if (currentIndex == param.OutlineLabel.Core.Count - 2)
{
return(DrawOrtho(param));
}
SetPostStartToOrigin(param);
return(DrawEachPartition(param, targetArea));
}
//이거 나중에 수정
if (currentIndex == param.OutlineLabel.Core.Count - 2)
{
param.OriginPost.Point = param.OriginPost.BaseLine.EndPt;
return(DrawOrtho(param));
}
//SetPostParallelToOrigin(param);
SetPostStartToOrigin(param);
return(DrawEachPartition(param, targetArea));
}
private static void SetPreEndToOrigin(PartitionParam param)
{
int currentIndex = param.OutlineLabel.Core.FindIndex
(i => (i.PureLine == param.OriginPost.BasePureLine));
if (currentIndex == 0)
{
return;
}
RoomLine baseLinePre = param.OutlineLabel.Core[currentIndex - 1];
param.OriginPost = new PartitionOrigin(baseLinePre.EndPt, baseLinePre);
return;
}
//setter랑 중복코드 있음!!
private static void SetPostStartToOrigin(PartitionParam param)
{
int currentIndex = param.OutlineLabel.Core.FindIndex
(i => (i.PureLine == param.OriginPost.BasePureLine));
if (currentIndex == param.OutlineLabel.Core.Count - 1)
{
return;
}
RoomLine baseLinePost = param.OutlineLabel.Core[currentIndex + 1];
param.OriginPost = new PartitionOrigin(baseLinePost.StartPt, baseLinePost);
return;
}
private static Boolean IsAvailableOnSameBase(PartitionParam setterParam)
{
if (setterParam.OriginPost.Type != LineType.Corridor)
{
return(false);
}
double dividerToOrigin = new Vector3d(setterParam.OriginPost.Point - setterParam.PartitionPre.Origin.Point).Length;
if (dividerToOrigin < RoomDimension.MinLengthForDoor)
{
return(false);
}
return(true);
}
